blob_id stringlengths 40 40 | directory_id stringlengths 40 40 | path stringlengths 3 264 | content_id stringlengths 40 40 | detected_licenses listlengths 0 85 | license_type stringclasses 2
values | repo_name stringlengths 5 140 | snapshot_id stringlengths 40 40 | revision_id stringlengths 40 40 | branch_name stringclasses 986
values | visit_date timestamp[us] | revision_date timestamp[us] | committer_date timestamp[us] | github_id int64 3.89k 681M ⌀ | star_events_count int64 0 209k | fork_events_count int64 0 110k | gha_license_id stringclasses 23
values | gha_event_created_at timestamp[us] | gha_created_at timestamp[us] | gha_language stringclasses 145
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 122
values | content stringlengths 3 10.4M | authors listlengths 1 1 | author_id stringlengths 0 158 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
84d3832e1174624d86cb6a49f911c72ffd222a5f | 9c6f5fbb43a00fdd4838d78b4299cdf2c34e279b | /tdt/cvs/driver/player2_191/player/frame_parser/frame_parser_audio_aac.cpp | cd29eed1839191a14047c07d360f3387cb3965be | [] | no_license | TitanNit/tdt | 90ac830771170abc96255457ef59780687ff0a47 | 22a09713b68c881fd1d4e4f6247b314cd52f4d7a | refs/heads/master | 2021-01-17T09:50:39.729337 | 2016-05-06T13:26:53 | 2016-05-06T13:26:53 | 34,450,580 | 2 | 2 | null | null | null | null | UTF-8 | C++ | false | false | 28,398 | cpp | /************************************************************************
Copyright (C) 2007 STMicroelectronics. All Rights Reserved.
This file is part of the Player2 Library.
Player2 is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License version 2 as published by the
Free Software Foundation.
Player2 is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License along
with player2; see the file COPYING. If not, write to the Free Software
Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
The Player2 Library may alternatively be licensed under a proprietary
license from ST.
Source file name : frame_parser_audio_aac.cpp
Author : Adam
Implementation of the aac audio frame parser class for player 2.
Date Modification Name
---- ------------ --------
05-Jul-07 Created (from frame_parser_audio_mpeg.cpp) Adam
************************************************************************/
////////////////////////////////////////////////////////////////////////
///
/// \class FrameParser_AudioAac_c
/// \brief Frame parser for AAC audio.
///
// /////////////////////////////////////////////////////////////////////
//
// Include any component headers
#include "aac_audio.h"
#include "frame_parser_audio_aac.h"
//
// /////////////////////////////////////////////////////////////////////////
//
// Locally defined constants
//
#undef FRAME_TAG
#define FRAME_TAG "AAC audio frame parser"
const unsigned int UnplayabilityThreshold = 4;
static BufferDataDescriptor_t AacAudioStreamParametersBuffer = BUFFER_AAC_AUDIO_STREAM_PARAMETERS_TYPE;
static BufferDataDescriptor_t AacAudioFrameParametersBuffer = BUFFER_AAC_AUDIO_FRAME_PARAMETERS_TYPE;
//
// Sample rate lookup table for AAC audio frame parsing
//
#define AAC_MAX_SAMPLE_RATE_IDX 12
static int aac_sample_rates[AAC_MAX_SAMPLE_RATE_IDX+1] =
{
96000, 88200, 64000, 48000, 44100, 32000,
24000, 22050, 16000, 12000, 11025, 8000, 7350
};
#define AAC_MAX_CHANNELS_IDX 7
#if 0
static int aac_channels[AAC_MAX_CHANNELS_IDX+1] =
{
0, 1, 2, 3, 4, 5, 6, 8
};
#endif
const char* FrameTypeName[] =
{
"ADTS",
"ADIF",
"MP4",
"LOAS",
"RAW"
};
#define FRAME_COND_ERROR(fmt, args...) do { if ( Action != AAC_GET_SYNCHRO ) { FRAME_ERROR(fmt, ##args); } } while (0);
// /////////////////////////////////////////////////////////////////////////
//
// Locally defined structures
//
////////////////////////////////////////////////////////////////////////////
///
/// Examine the supplied frame header and extract the information contained within.
///
/// This is a utility function shared by the frame parser and the equivalent
/// collator. Due to its shared nature this is a static method and does not access
/// any information not provided via the function arguments.
///
/// ** AAC format **
///
/// AAAAAAAA AAAABCCD EEFFFFGH HHIJKLMM
/// MMMMMMMM MMMNNNNN NNNNNNOO ........
///
/// Sign Length Position Description
///
/// A 12 (31-20) Sync code
/// B 1 (19) ID
/// C 2 (18-17) layer
/// D 1 (16) protect absent
/// E 2 (15-14) profile
/// F 4 (13-10) sample freq index
/// G 1 (9) private
/// H 3 (8-6) channel config
/// I 1 (5) original/copy
/// J 1 (4) home
/// K 1 (3) copyright id
/// L 1 (2) copyright start
/// M 13 (1-0,31-21) frame length
/// N 11 (20-10) adts buffer fullness
/// O 2 (9-8) num of raw data blocks in frame
///
/////////////////////////////////////////////////////////////////////////////////////////
//
// Private - parse a frame header (NOTE do we already know it has a valid sync word?).
//
///
/// \return Frame parser status code, FrameParserNoError indicates success.
///
FrameParserStatus_t FrameParser_AudioAac_c::ParseFrameHeader( unsigned char *FrameHeaderBytes,
AacAudioParsedFrameHeader_t *ParsedFrameHeader,
int AvailableBytes,
AacFrameParsingPurpose_t Action,
bool EnableHeaderUnplayableErrors )
{
unsigned int SamplingFrequency = 0;
unsigned int SampleCount = 0;
unsigned int FrameSize = 0;
BitStreamClass_c Bits;
AacFormatType_t Type;
Bits.SetPointer(FrameHeaderBytes);
unsigned int Sync = Bits.Get(11);
if (Sync == AAC_AUDIO_LOAS_ASS_SYNC_WORD)
{
Type = AAC_AUDIO_LOAS_FORMAT;
FrameSize = Bits.Get(13) + AAC_LOAS_ASS_SYNC_LENGTH_HEADER_SIZE;
if (FrameSize > AAC_LOAS_ASS_MAX_FRAME_SIZE)
{
FRAME_COND_ERROR( "Invalid frame size (%d bytes)\n", FrameSize );
return FrameParserError;
}
if (FrameParserNoError != FrameParser_AudioAac_c::ParseAudioMuxElementConfig( &Bits,
&SamplingFrequency,
&SampleCount,
AvailableBytes - AAC_LOAS_ASS_SYNC_LENGTH_HEADER_SIZE,
Action ))
{
return FrameParserError;
}
}
else
{
// get more bits
Sync |= Bits.Get(1) << 11;
if (Sync == AAC_AUDIO_ADTS_SYNC_WORD)
{
Type = AAC_AUDIO_ADTS_FORMAT;
Bits.FlushUnseen(1); //bool ID = Bits.Get(1);
unsigned char Layer = Bits.Get(2);
if (Layer != 0)
{
FRAME_COND_ERROR( "Invalid AAC layer %d\n", Layer );
return FrameParserError;
}
Bits.FlushUnseen(1); //protection_absent;
unsigned int profile_ObjectType = Bits.Get(2);
if ((profile_ObjectType+1) != AAC_AUDIO_PROFILE_LC)
{
if( EnableHeaderUnplayableErrors )
{
FRAME_COND_ERROR("Unsupported AAC profile in ADTS: %d\n", profile_ObjectType);
return FrameParserHeaderUnplayable;
}
}
unsigned char sampling_frequency_index = Bits.Get(4);
if (sampling_frequency_index > AAC_MAX_SAMPLE_RATE_IDX)
{
FRAME_COND_ERROR("Invalid sampling frequency index %d\n", sampling_frequency_index);
return FrameParserError;
}
// multiple the sampling freq by two in case a sbr object is present
SamplingFrequency = aac_sample_rates[sampling_frequency_index] * 2;
Bits.FlushUnseen(1); //private_bit
unsigned char channel_configuration = Bits.Get(3);
if (channel_configuration > AAC_MAX_CHANNELS_IDX)
{
FRAME_COND_ERROR("Invalid channel configuration %d\n", channel_configuration);
return FrameParserError;
}
Bits.FlushUnseen(1 + 1 + 1 + 1); //original/copy, home, copyright_identification_bit, copyright_identification_start
FrameSize = Bits.Get(13); // aac_frame_length
if (FrameSize < AAC_ADTS_MIN_FRAME_SIZE)
{
FRAME_COND_ERROR( "Invalid frame size (%d bytes)\n", FrameSize );
return FrameParserError;
}
Bits.FlushUnseen(11); //adts_buffer_fullness
unsigned int no_raw_data_blocks_in_frame = Bits.Get(2);
// multiple the sample count by two in case a sbr object is present
SampleCount = (no_raw_data_blocks_in_frame + 1) * 1024 * 2 ;
}
else
{
Sync |= Bits.Get(4) << 12;
if (Sync == AAC_AUDIO_LOAS_EPASS_SYNC_WORD)
{
Type = AAC_AUDIO_LOAS_FORMAT;
Bits.FlushUnseen(4); //futureUse
FrameSize = Bits.Get(13) + AAC_LOAS_EP_ASS_HEADER_SIZE;
// continue the parsing to get more info about the frame
Bits.FlushUnseen(5 + 18); //frameCounter, headerParity
AvailableBytes -= AAC_LOAS_EP_ASS_HEADER_SIZE;
// now parse the EPMuxElement...
bool epUsePreviousMuxConfig = Bits.Get(1);
Bits.FlushUnseen(2); //epUsePreviousMuxConfigParity
if (!epUsePreviousMuxConfig)
{
unsigned int epSpecificConfigLength = Bits.Get(10);
unsigned int epSpecificConfigLengthParity = Bits.Get(11);
AvailableBytes -= 3;
if (AvailableBytes > 0)
{
Bits.FlushUnseen(epSpecificConfigLength*8); //ErrorProtectionSpecificConfig
Bits.FlushUnseen(epSpecificConfigLengthParity*8); //ErrorProtectionSpecificConfigParity
AvailableBytes -= epSpecificConfigLength + epSpecificConfigLengthParity;
}
}
else
{
Bits.FlushUnseen(5); //ByteAlign()
AvailableBytes -= 1;
}
if (FrameParserNoError != FrameParser_AudioAac_c::ParseAudioMuxElementConfig( &Bits,
&SamplingFrequency,
&SampleCount,
AvailableBytes,
Action ))
{
return FrameParserError;
}
}
else
{
Sync |= Bits.Get(16) << 16;
if (Sync == AAC_AUDIO_ADIF_SYNC_WORD)
{
Type = AAC_AUDIO_ADIF_FORMAT;
FRAME_COND_ERROR( "The AAC ADIF format is not supported yet!\n");
return FrameParserHeaderUnplayable;
}
else
{
FRAME_COND_ERROR( "Unknown Synchronization (0x%x)\n", Sync);
return FrameParserError;
}
}
}
}
ParsedFrameHeader->SamplingFrequency = SamplingFrequency;
ParsedFrameHeader->NumberOfSamples = SampleCount;
ParsedFrameHeader->Length = FrameSize;
ParsedFrameHeader->Type = Type;
return FrameParserNoError;
}
FrameParserStatus_t FrameParser_AudioAac_c::ParseAudioMuxElementConfig( BitStreamClass_c * Bits,
unsigned int * SamplingFrequency,
unsigned int * SampleCount,
int AvailableBytes,
AacFrameParsingPurpose_t Action )
{
// do as if a sbr extension is always present (searching for the sbr flag requires parsing efforts...)
bool ImplicitSbrExtension = true;
bool ExplicitSbrExtension = false;
bool useSameStreamMux;
if (AvailableBytes > 0)
{
useSameStreamMux = Bits->Get(1);
}
else
{
useSameStreamMux = true;
}
if ( !useSameStreamMux )
{
bool audioMuxVersion = Bits->Get(1);
if (!audioMuxVersion)
{
// only get program 0 and layer 0 information ...
Bits->FlushUnseen(1 + 6 + 4 + 3); // allStreamSameTimeFraming, numSubFrames, numProgram, numLayer
// now parse AudioSpecificConfig
unsigned int audioObjectType = Bits->Get(5);
if ((audioObjectType != AAC_AUDIO_PROFILE_LC) && (audioObjectType != AAC_AUDIO_PROFILE_SBR))
{
// supported audio profiles (audio firmware):
// are LC (low complexity) and HE (LC+SBR)
FRAME_COND_ERROR("Unsupported AAC Audio Object type: %d\n", audioObjectType);
return FrameParserError;
}
unsigned int samplingFrequencyIndex = Bits->Get(4);
if (samplingFrequencyIndex == 0xf)
{
*SamplingFrequency = Bits->Get(24);
}
else if (samplingFrequencyIndex <= AAC_MAX_SAMPLE_RATE_IDX)
{
*SamplingFrequency = aac_sample_rates[samplingFrequencyIndex];
}
else
{
FRAME_COND_ERROR("Invalid sampling frequency index %d\n", samplingFrequencyIndex);
return FrameParserError;
}
unsigned int channelConfiguration = Bits->Get(4);
if (channelConfiguration > AAC_MAX_CHANNELS_IDX)
{
FRAME_COND_ERROR("Invalid channel configuration %d\n", channelConfiguration);
return FrameParserError;
}
if (audioObjectType == AAC_AUDIO_PROFILE_SBR)
{
ImplicitSbrExtension = false;
ExplicitSbrExtension = true;
// simply perform checks on the following values...
samplingFrequencyIndex = Bits->Get(4);
if (samplingFrequencyIndex == 0xf)
{
*SamplingFrequency = Bits->Get(24);
}
else if (samplingFrequencyIndex <= AAC_MAX_SAMPLE_RATE_IDX)
{
*SamplingFrequency = aac_sample_rates[samplingFrequencyIndex];
}
else
{
FRAME_COND_ERROR("Invalid sampling frequency index %d\n", samplingFrequencyIndex);
return FrameParserError;
}
audioObjectType = Bits->Get(5);
if (audioObjectType != AAC_AUDIO_PROFILE_LC)
{
// supported audio profiles (audio firmware):
// is LC (low complexity)
FRAME_COND_ERROR("Unsupported AAC Audio Object type: %d\n", audioObjectType);
return FrameParserError;
}
}
}
else
{
FRAME_COND_ERROR( "AAC LOAS parser: invalid audioMuxVersion reserved value\n");
return FrameParserError;
}
// Nick changed this to distinguish between implicit and explicit signalling of SBR
// See NOTE 3 of Table 1.21, page 47 of w5711_(14496-3_3rd_sp1).doc - document name
// ISO/IEC 14496-3:2001(E) provided by Gael
*SampleCount = 1024 * ((ImplicitSbrExtension || ExplicitSbrExtension)?2:1);
*SamplingFrequency *= (ImplicitSbrExtension?2:1);
} // !useSameStreamMux
else
{
// we're in the situation whare we found the sync word but don't have
if ( Action == AAC_GET_SYNCHRO )
{
// means we cannot sync without knowing all the audio properties. (useSameconfig is true)
return FrameParserError;
}
// use same parameters as last frame...
*SampleCount = 0;
*SamplingFrequency = 0;
}
return FrameParserNoError;
}
////////////////////////////////////////////////////////////////////////////
///
/// Constructor
///
FrameParser_AudioAac_c::FrameParser_AudioAac_c( void )
{
Configuration.FrameParserName = "AudioAac";
Configuration.StreamParametersCount = 32;
Configuration.StreamParametersDescriptor = &AacAudioStreamParametersBuffer;
Configuration.FrameParametersCount = 32;
Configuration.FrameParametersDescriptor = &AacAudioFrameParametersBuffer;
//
Reset();
}
////////////////////////////////////////////////////////////////////////////
///
/// Destructor
///
FrameParser_AudioAac_c::~FrameParser_AudioAac_c( void )
{
Halt();
Reset();
}
////////////////////////////////////////////////////////////////////////////
///
/// The Reset function release any resources, and reset all variable
///
FrameParserStatus_t FrameParser_AudioAac_c::Reset( void )
{
memset( &CurrentStreamParameters, 0, sizeof(CurrentStreamParameters) );
CurrentStreamParameters.Layer = 0; // illegal layer... force frames a parameters update
NumHeaderUnplayableErrors = 0;
isFirstFrame = true;
return FrameParser_Audio_c::Reset();
}
////////////////////////////////////////////////////////////////////////////
///
/// The register output ring function
///
FrameParserStatus_t FrameParser_AudioAac_c::RegisterOutputBufferRing( Ring_t Ring )
{
//
// Clear our parameter pointers
//
StreamParameters = NULL;
FrameParameters = NULL;
//
// Pass the call down the line
//
return FrameParser_Audio_c::RegisterOutputBufferRing( Ring );
}
////////////////////////////////////////////////////////////////////////////
///
/// Parse the frame header and store the results for when we emit the frame.
///
FrameParserStatus_t FrameParser_AudioAac_c::ReadHeaders( void )
{
FrameParserStatus_t Status;
//
// Perform the common portion of the read headers function
//
FrameParser_Audio_c::ReadHeaders();
//
// save the previous frame parameters
AacAudioParsedFrameHeader_t LastParsedFrameHeader;
memcpy(&LastParsedFrameHeader, &ParsedFrameHeader, sizeof(AacAudioParsedFrameHeader_t));
Status = ParseFrameHeader( BufferData, &ParsedFrameHeader, BufferLength, AAC_GET_FRAME_PROPERTIES, true );
if( Status != FrameParserNoError )
{
if( Status == FrameParserHeaderUnplayable )
{
NumHeaderUnplayableErrors++;
if( NumHeaderUnplayableErrors >= UnplayabilityThreshold )
{
// this is clearly not a passing bit error
FRAME_ERROR("Too many unplayability reports, marking stream unplayable\n");
Player->MarkStreamUnPlayable( Stream );
}
}
else
{
FRAME_ERROR("Failed to parse frame header, bad collator selected?\n");
}
return Status;
}
if (ParsedFrameHeader.Length != BufferLength)
{
FRAME_ERROR("Buffer length is inconsistant with frame header, bad collator selected?\n");
return FrameParserError;
}
if (isFirstFrame)
{
isFirstFrame = false;
FRAME_TRACE("AAC Frame type: %s, FrameSize %d, Number of samples: %d, SamplingFrequency %d, \n",
FrameTypeName[ParsedFrameHeader.Type],
ParsedFrameHeader.Length,
ParsedFrameHeader.NumberOfSamples,
ParsedFrameHeader.SamplingFrequency);
}
if ((ParsedFrameHeader.SamplingFrequency == 0) || (ParsedFrameHeader.NumberOfSamples == 0))
{
// the current frame has no such properties, we must refer to the previous frame...
if ((LastParsedFrameHeader.SamplingFrequency == 0) || (LastParsedFrameHeader.NumberOfSamples == 0))
{
// the previous frame has no properties either, we cannot decode this frame...
FrameToDecode = false;
FRAME_ERROR("This frame should not be sent for decode (it relies on previous frame for audio parameters)\n");
return FrameParserError;
}
else
{
FrameToDecode = true;
// make the previous frame properties the current ones..
memcpy(&ParsedFrameHeader, &LastParsedFrameHeader, sizeof(AacAudioParsedFrameHeader_t));
}
}
else
{
FrameToDecode = true;
}
NumHeaderUnplayableErrors = 0;
Status = GetNewFrameParameters( (void **) &FrameParameters );
if( Status != FrameParserNoError )
{
FRAME_ERROR( "Cannot get new frame parameters\n" );
return Status;
}
// Nick inserted some default values here
ParsedFrameParameters->FirstParsedParametersForOutputFrame = true;
ParsedFrameParameters->FirstParsedParametersAfterInputJump = FirstDecodeAfterInputJump;
ParsedFrameParameters->SurplusDataInjected = SurplusDataInjected;
ParsedFrameParameters->ContinuousReverseJump = ContinuousReverseJump;
ParsedFrameParameters->KeyFrame = true;
ParsedFrameParameters->ReferenceFrame = false;
ParsedFrameParameters->NewFrameParameters = true;
ParsedFrameParameters->SizeofFrameParameterStructure = sizeof(AacAudioFrameParameters_t);
ParsedFrameParameters->FrameParameterStructure = FrameParameters;
FrameParameters->FrameSize = ParsedFrameHeader.Length;
FrameParameters->Type = ParsedFrameHeader.Type;
ParsedAudioParameters->Source.BitsPerSample = 0; // filled in by codec
ParsedAudioParameters->Source.ChannelCount = 0; // filled in by codec
ParsedAudioParameters->Source.SampleRateHz = ParsedFrameHeader.SamplingFrequency;
ParsedAudioParameters->SampleCount = ParsedFrameHeader.NumberOfSamples;
ParsedAudioParameters->Organisation = 0; // filled in by codec
return FrameParserNoError;
}
////////////////////////////////////////////////////////////////////////////
///
/// The reset reference frame list function
///
FrameParserStatus_t FrameParser_AudioAac_c::ResetReferenceFrameList( void )
{
FRAME_DEBUG(">><<");
Player->CallInSequence( Stream, SequenceTypeImmediate, TIME_NOT_APPLICABLE, CodecFnReleaseReferenceFrame, CODEC_RELEASE_ALL );
return FrameParserNoError;
}
///////////////////////////////////////////////////////////////////////////
///
/// Not required or implemented for AAC audio.
///
/// \copydoc FrameParser_Audio_c::PurgeQueuedPostDecodeParameterSettings()
///
FrameParserStatus_t FrameParser_AudioAac_c::PurgeQueuedPostDecodeParameterSettings( void )
{
return FrameParserNoError;
}
///////////////////////////////////////////////////////////////////////////
///
/// Not required or implemented for AAC audio.
///
/// \copydoc FrameParser_Audio_c::ProcessQueuedPostDecodeParameterSettings()
///
FrameParserStatus_t FrameParser_AudioAac_c::ProcessQueuedPostDecodeParameterSettings( void )
{
return FrameParserNoError;
}
////////////////////////////////////////////////////////////////////////////
///
/// Determine the display frame index and presentation time of the decoded frame.
///
/// For MPEG audio these can be determined immediately (although it the first
/// frame for decode does not contain a PTS we must synthesize one).
///
FrameParserStatus_t FrameParser_AudioAac_c::GeneratePostDecodeParameterSettings( void )
{
FrameParserStatus_t Status;
//
//
// Default setting
//
ParsedFrameParameters->DisplayFrameIndex = INVALID_INDEX;
ParsedFrameParameters->NativePlaybackTime = INVALID_TIME;
ParsedFrameParameters->NormalizedPlaybackTime = INVALID_TIME;
ParsedFrameParameters->NativeDecodeTime = INVALID_TIME;
ParsedFrameParameters->NormalizedDecodeTime = INVALID_TIME;
//
// Record in the structure the decode and presentation times if specified
//
if( CodedFrameParameters->PlaybackTimeValid )
{
ParsedFrameParameters->NativePlaybackTime = CodedFrameParameters->PlaybackTime;
TranslatePlaybackTimeNativeToNormalized( CodedFrameParameters->PlaybackTime, &ParsedFrameParameters->NormalizedPlaybackTime );
}
if( CodedFrameParameters->DecodeTimeValid )
{
ParsedFrameParameters->NativeDecodeTime = CodedFrameParameters->DecodeTime;
TranslatePlaybackTimeNativeToNormalized( CodedFrameParameters->DecodeTime, &ParsedFrameParameters->NormalizedDecodeTime );
}
//
// Sythesize the presentation time if required
//
Status = HandleCurrentFrameNormalizedPlaybackTime();
if( Status != FrameParserNoError )
{
return Status;
}
//
// We can't fail after this point so this is a good time to provide a display frame index
//
ParsedFrameParameters->DisplayFrameIndex = NextDisplayFrameIndex++;
//
// Use the super-class utilities to complete our housekeeping chores
//
// no call to HandleUpdateStreamParameters() because UpdateStreamParameters is always false
FRAME_ASSERT( false == UpdateStreamParameters && NULL == StreamParametersBuffer );
GenerateNextFrameNormalizedPlaybackTime(ParsedFrameHeader.NumberOfSamples,
ParsedFrameHeader.SamplingFrequency);
//
//DumpParsedFrameParameters( ParsedFrameParameters, __PRETTY_FUNCTION__ );
return FrameParserNoError;
}
////////////////////////////////////////////////////////////////////////////
///
/// Not required or implemented for AAC audio.
///
/// \copydoc FrameParser_Audio_c::PrepareReferenceFrameList()
///
FrameParserStatus_t FrameParser_AudioAac_c::PrepareReferenceFrameList( void )
{
return FrameParserNoError;
}
////////////////////////////////////////////////////////////////////////////
///
/// Not required or implemented for AAC audio.
///
/// \copydoc FrameParser_Audio_c::PrepareReferenceFrameList()
///
FrameParserStatus_t FrameParser_AudioAac_c::UpdateReferenceFrameList( void )
{
return FrameParserNoError;
}
////////////////////////////////////////////////////////////////////////////
///
/// Not required or implemented for AAC audio.
///
/// \copydoc FrameParser_Audio_c::ProcessReverseDecodeUnsatisfiedReferenceStack()
///
FrameParserStatus_t FrameParser_AudioAac_c::ProcessReverseDecodeUnsatisfiedReferenceStack( void )
{
return FrameParserNoError;
}
////////////////////////////////////////////////////////////////////////////
///
/// Not required or implemented for AAC audio.
///
/// \copydoc FrameParser_Audio_c::ProcessReverseDecodeStack()
///
FrameParserStatus_t FrameParser_AudioAac_c::ProcessReverseDecodeStack( void )
{
return FrameParserNoError;
}
////////////////////////////////////////////////////////////////////////////
///
/// Not required or implemented for AAC audio.
///
/// \copydoc FrameParser_Audio_c::PurgeReverseDecodeUnsatisfiedReferenceStack()
///
FrameParserStatus_t FrameParser_AudioAac_c::PurgeReverseDecodeUnsatisfiedReferenceStack( void )
{
return FrameParserNoError;
}
////////////////////////////////////////////////////////////////////////////
///
/// Not required or implemented for AAC audio.
///
/// \copydoc FrameParser_Audio_c::PurgeReverseDecodeStack()
///
FrameParserStatus_t FrameParser_AudioAac_c::PurgeReverseDecodeStack( void )
{
return FrameParserNoError;
}
////////////////////////////////////////////////////////////////////////////
///
/// Not required or implemented for AAC audio.
///
/// \copydoc FrameParser_Audio_c::TestForTrickModeFrameDrop()
///
FrameParserStatus_t FrameParser_AudioAac_c::TestForTrickModeFrameDrop( void )
{
return FrameParserNoError;
}
| [
"konfetti@gmx.net"
] | konfetti@gmx.net |
f4a409ee9f7ff851d65e61c647af54ece338770d | 27088b1b3f25ca17b89f43f20fcb33b2e71472a0 | /Core/Main/GTesting/itkElastixRegistrationMethodGTest.cxx | 5d21789c15077162f388d1efe7e31b0d9ba7e698 | [
"LicenseRef-scancode-warranty-disclaimer",
"BSD-3-Clause",
"Apache-2.0",
"LicenseRef-scancode-unknown-license-reference",
"BSD-2-Clause"
] | permissive | SuperElastix/elastix | a7c1e04fd5f34d1a6f07607e9ff85ae215386ab1 | 9347f1d4c4bd47763c1b4d7cb086f14ade883b88 | refs/heads/main | 2023-09-01T02:19:47.769376 | 2023-08-29T15:01:47 | 2023-08-29T18:47:37 | 91,586,944 | 414 | 115 | Apache-2.0 | 2023-09-13T18:26:20 | 2017-05-17T14:41:22 | C++ | UTF-8 | C++ | false | false | 114,501 | cxx | /*=========================================================================
*
* Copyright UMC Utrecht and contributors
*
* 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.txt
*
* 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.
*
*=========================================================================*/
#define _USE_MATH_DEFINES // For M_PI.
// First include the header file to be tested:
#include <itkElastixRegistrationMethod.h>
#include <itkTransformixFilter.h>
#include "GTesting/elxGTestUtilities.h"
#include "elxCoreMainGTestUtilities.h"
#include "elxDefaultConstruct.h"
#include "elxForEachSupportedImageType.h"
#include "elxTransformIO.h"
// ITK header file:
#include <itkAffineTransform.h>
#include <itkBSplineTransform.h>
#include <itkCompositeTransform.h>
#include <itkDisplacementFieldTransform.h>
#include <itkEuler2DTransform.h>
#include <itkImage.h>
#include <itkIndexRange.h>
#include <itkFileTools.h>
#include <itkSimilarity2DTransform.h>
#include <itkTranslationTransform.h>
#include <itkTransformFileReader.h>
// GoogleTest header file:
#include <gtest/gtest.h>
#include <algorithm> // For transform
#include <cmath> // For M_PI
#include <map>
#include <random>
#include <string>
#include <utility> // For pair
// Type aliases:
using ParameterMapType = itk::ParameterFileParser::ParameterMapType;
using ParameterType = ParameterMapType::value_type;
using ParameterValuesType = itk::ParameterFileParser::ParameterValuesType;
using ParameterMapVectorType = elx::ParameterObject::ParameterMapVectorType;
// Using-declarations:
using elx::CoreMainGTestUtilities::CheckNew;
using elx::CoreMainGTestUtilities::ConvertStringsToVectorOfDouble;
using elx::CoreMainGTestUtilities::ConvertToOffset;
using elx::CoreMainGTestUtilities::CreateImage;
using elx::CoreMainGTestUtilities::CreateImageFilledWithSequenceOfNaturalNumbers;
using elx::CoreMainGTestUtilities::CreateParameterMap;
using elx::CoreMainGTestUtilities::CreateParameterObject;
using elx::CoreMainGTestUtilities::CreateRandomImageDomain;
using elx::CoreMainGTestUtilities::DerefRawPointer;
using elx::CoreMainGTestUtilities::DerefSmartPointer;
using elx::CoreMainGTestUtilities::FillImageRegion;
using elx::CoreMainGTestUtilities::Front;
using elx::CoreMainGTestUtilities::GetCurrentBinaryDirectoryPath;
using elx::CoreMainGTestUtilities::GetDataDirectoryPath;
using elx::CoreMainGTestUtilities::GetNameOfTest;
using elx::CoreMainGTestUtilities::GetTransformParametersFromFilter;
using elx::CoreMainGTestUtilities::ImageDomain;
using elx::CoreMainGTestUtilities::TypeHolder;
using elx::CoreMainGTestUtilities::minimumImageSizeValue;
using elx::GTestUtilities::MakeMergedMap;
template <typename TImage>
using ElastixRegistrationMethodType = itk::ElastixRegistrationMethod<TImage, TImage>;
namespace
{
auto
ParameterToCurlyBracedString(const ParameterMapType::value_type & parameter)
{
std::string result = " { \"" + parameter.first + "\", {";
for (const auto & str : parameter.second)
{
if (&str != &(parameter.second.front()))
{
result += ", ";
}
result += " \"" + str + "\" ";
}
result += "} }";
return result;
}
const ParameterMapType defaultRegistrationParameterMap =
CreateParameterMap({ // Parameters in alphabetic order:
ParameterType{ "ASGDParameterEstimationMethod", { "Original" } },
ParameterType{ "AutomaticParameterEstimation", { "true" } },
ParameterType{ "BSplineInterpolationOrder", { "1" } },
ParameterType{ "CheckNumberOfSamples", { "false" } },
ParameterType{ "FinalBSplineInterpolationOrder", { "3" } },
ParameterType{ "FixedImagePyramid", { "FixedSmoothingImagePyramid" } },
ParameterType{ "FixedInternalImagePixelType", { "float" } },
ParameterType{ "HowToCombineTransforms", { "Compose" } },
ParameterType{ "InitialTransformParameterFileName", { "NoInitialTransform" } },
ParameterType{ "Interpolator", { "BSplineInterpolator" } },
ParameterType{ "MaxBandCovSize", { "192" } },
ParameterType{ "MaximumNumberOfSamplingAttempts", { "0" } },
ParameterType{ "MaximumStepLength", { "1" } },
ParameterType{ "MaximumStepLengthRatio", { "1" } },
ParameterType{ "MovingImagePyramid", { "MovingSmoothingImagePyramid" } },
ParameterType{ "MovingInternalImagePixelType", { "float" } },
ParameterType{ "NewSamplesEveryIteration", { "false" } },
ParameterType{ "NumberOfBandStructureSamples", { "10" } },
ParameterType{ "NumberOfGradientMeasurements", { "0" } },
ParameterType{ "NumberOfJacobianMeasurements", { "1000" } },
ParameterType{ "NumberOfSamplesForExactGradient", { "100000" } },
ParameterType{ "Registration", { "MultiResolutionRegistration" } },
ParameterType{ "ResampleInterpolator", { "FinalBSplineInterpolator" } },
ParameterType{ "Resampler", { "DefaultResampler" } },
ParameterType{ "ShowExactMetricValue", { "false" } },
ParameterType{ "SigmoidInitialTime", { "0" } },
ParameterType{ "SigmoidScaleFactor", { "0.1" } },
ParameterType{ "SP_a", { "0.602" } },
ParameterType{ "SP_A", { "20" } },
ParameterType{ "SP_alpha", { "0.602" } },
ParameterType{ "SubtractMean", { "true" } },
ParameterType{ "UseAdaptiveStepSizes", { "true" } },
ParameterType{ "UseConstantStep", { "false" } },
ParameterType{ "UseDirectionCosines", { "true" } },
ParameterType{ "UseMultiThreadingForMetrics", { "true" } },
ParameterType{ "WriteResultImage", { "true" } } });
const ParameterMapType defaultTransformParameterMap = CreateParameterMap(
{ // Parameters in alphabetic order:
ParameterType{ "BSplineTransformSplineOrder", { "3" } },
ParameterType{ "FinalBSplineInterpolationOrder", { "3" } },
ParameterType{ "FixedImagePyramid", { "FixedSmoothingImagePyramid" } },
ParameterType{ "FixedInternalImagePixelType", { "float" } },
ParameterType{ "GridDirection", elx::Conversion::ToVectorOfStrings(itk::Matrix<int, 2, 2>::GetIdentity()) },
ParameterType{ "GridIndex", ParameterValuesType(2, "0") },
ParameterType{ "GridOrigin", ParameterValuesType(2, "0") },
ParameterType{ "GridSize", ParameterValuesType(2, "1") },
ParameterType{ "GridSpacing", ParameterValuesType(2, "1") },
ParameterType{ "HowToCombineTransforms", { "Compose" } },
ParameterType{ "InitialTransformParameterFileName", { "NoInitialTransform" } },
ParameterType{ "Interpolator", { "BSplineInterpolator" } },
ParameterType{ "MovingImagePyramid", { "MovingSmoothingImagePyramid" } },
ParameterType{ "MovingInternalImagePixelType", { "float" } },
ParameterType{ "NewSamplesEveryIteration", { "false" } },
ParameterType{ "Registration", { "MultiResolutionRegistration" } },
ParameterType{ "ResampleInterpolator", { "FinalBSplineInterpolator" } },
ParameterType{ "Resampler", { "DefaultResampler" } },
ParameterType{ "UseCyclicTransform", { "false" } },
ParameterType{ "UseDirectionCosines", { "true" } } });
auto
DefaultTransformParameter(const ParameterMapType::value_type & parameter)
{
EXPECT_EQ(defaultTransformParameterMap.count(parameter.first), 1)
<< " parameter = " << ParameterToCurlyBracedString(parameter);
EXPECT_EQ(defaultTransformParameterMap.at(parameter.first), parameter.second);
return parameter;
}
auto
NonDefaultTransformParameter(const ParameterMapType::value_type & parameter)
{
const auto end = defaultTransformParameterMap.cend();
EXPECT_EQ(std::find(defaultTransformParameterMap.cbegin(), end, parameter), end);
if (const auto found = defaultTransformParameterMap.find(parameter.first); found != end)
{
EXPECT_NE(found->second, parameter.second);
}
return parameter;
}
auto
DefaultRegistrationParameter(const ParameterMapType::value_type & parameter)
{
EXPECT_EQ(defaultRegistrationParameterMap.count(parameter.first), 1)
<< " parameter = " << ParameterToCurlyBracedString(parameter);
EXPECT_EQ(defaultRegistrationParameterMap.at(parameter.first), parameter.second);
return parameter;
}
auto
NonDefaultRegistrationParameter(const ParameterMapType::value_type & parameter)
{
const auto end = defaultRegistrationParameterMap.cend();
EXPECT_EQ(std::find(defaultRegistrationParameterMap.cbegin(), end, parameter), end);
if (const auto found = defaultRegistrationParameterMap.find(parameter.first); found != end)
{
EXPECT_NE(found->second, parameter.second);
}
return parameter;
}
template <unsigned int VDimension>
auto
ConvertIndexToOffset(const itk::Index<VDimension> & index)
{
return index - itk::Index<VDimension>{};
};
template <unsigned int VDimension>
void
Expect_equal_output_SetInitialTransformParameterObject_and_Transformix_SetTransformParameterObject(
const ParameterMapVectorType & transformParameterMaps,
const ImageDomain<VDimension> & fixedImageDomain,
const ImageDomain<VDimension> & movingImageDomain)
{
ASSERT_FALSE(transformParameterMaps.empty());
using PixelType = float;
using ImageType = itk::Image<PixelType, VDimension>;
itk::Size<VDimension> movingImageSize;
std::iota(movingImageSize.begin(), movingImageSize.end(), 5U);
elx::DefaultConstruct<ImageType> fixedImage{};
fixedImageDomain.ToImage(fixedImage);
fixedImage.Allocate(true);
elx::DefaultConstruct<ImageType> movingImage{};
movingImageDomain.ToImage(movingImage);
movingImage.Allocate(true);
const itk::ImageBufferRange<ImageType> movingImageBufferRange(movingImage);
std::mt19937 randomNumberEngine{};
std::generate(movingImageBufferRange.begin(), movingImageBufferRange.end(), [&randomNumberEngine] {
return std::uniform_real_distribution<PixelType>{ PixelType{ 1 }, PixelType{ 2 } }(randomNumberEngine);
});
elx::DefaultConstruct<elx::ParameterObject> registrationParameterObject{};
// Parameter map of a registration that "does nothing".
const ParameterMapType registrationParameterMap = CreateParameterMap({
// Default parameters in alphabetic order:
DefaultRegistrationParameter({ "ASGDParameterEstimationMethod", { "Original" } }),
DefaultRegistrationParameter({ "AutomaticParameterEstimation", { "true" } }),
DefaultRegistrationParameter({ "BSplineInterpolationOrder", { "1" } }),
DefaultRegistrationParameter({ "CheckNumberOfSamples", { "false" } }),
DefaultRegistrationParameter({ "FinalBSplineInterpolationOrder", { "3" } }),
DefaultRegistrationParameter({ "FixedImagePyramid", { "FixedSmoothingImagePyramid" } }),
DefaultRegistrationParameter({ "FixedInternalImagePixelType", { "float" } }),
DefaultRegistrationParameter({ "HowToCombineTransforms", { "Compose" } }),
DefaultRegistrationParameter({ "InitialTransformParameterFileName", { "NoInitialTransform" } }),
DefaultRegistrationParameter({ "Interpolator", { "BSplineInterpolator" } }),
DefaultRegistrationParameter({ "MaxBandCovSize", { "192" } }),
DefaultRegistrationParameter({ "MaximumNumberOfSamplingAttempts", { "0" } }),
DefaultRegistrationParameter({ "MaximumStepLength", { "1" } }),
DefaultRegistrationParameter({ "MaximumStepLengthRatio", { "1" } }),
DefaultRegistrationParameter({ "MovingImagePyramid", { "MovingSmoothingImagePyramid" } }),
DefaultRegistrationParameter({ "MovingInternalImagePixelType", { "float" } }),
DefaultRegistrationParameter({ "NewSamplesEveryIteration", { "false" } }),
DefaultRegistrationParameter({ "NumberOfBandStructureSamples", { "10" } }),
DefaultRegistrationParameter({ "NumberOfGradientMeasurements", { "0" } }),
DefaultRegistrationParameter({ "NumberOfJacobianMeasurements", { "1000" } }),
DefaultRegistrationParameter({ "NumberOfSamplesForExactGradient", { "100000" } }),
DefaultRegistrationParameter({ "Registration", { "MultiResolutionRegistration" } }),
DefaultRegistrationParameter({ "ResampleInterpolator", { "FinalBSplineInterpolator" } }),
DefaultRegistrationParameter({ "Resampler", { "DefaultResampler" } }),
DefaultRegistrationParameter({ "ShowExactMetricValue", { "false" } }),
DefaultRegistrationParameter({ "SigmoidInitialTime", { "0" } }),
DefaultRegistrationParameter({ "SigmoidScaleFactor", { "0.1" } }),
DefaultRegistrationParameter({ "SP_a", { "0.602" } }),
DefaultRegistrationParameter({ "SP_A", { "20" } }),
DefaultRegistrationParameter({ "SP_alpha", { "0.602" } }),
DefaultRegistrationParameter({ "SubtractMean", { "true" } }),
DefaultRegistrationParameter({ "UseAdaptiveStepSizes", { "true" } }),
DefaultRegistrationParameter({ "UseConstantStep", { "false" } }),
DefaultRegistrationParameter({ "UseDirectionCosines", { "true" } }),
DefaultRegistrationParameter({ "UseMultiThreadingForMetrics", { "true" } }),
DefaultRegistrationParameter({ "WriteResultImage", { "true" } }),
// Non-default parameters in alphabetic order:
NonDefaultRegistrationParameter({ "AutomaticTransformInitialization", { "false" } }),
NonDefaultRegistrationParameter({ "ImageSampler", { "Full" } }), // required
NonDefaultRegistrationParameter({ "MaximumNumberOfIterations", { "0" } }),
NonDefaultRegistrationParameter({ "Metric", { "AdvancedNormalizedCorrelation" } }), // default ""
NonDefaultRegistrationParameter({ "NumberOfResolutions", { "1" } }),
NonDefaultRegistrationParameter({ "Optimizer", { "AdaptiveStochasticGradientDescent" } }), // default ""
NonDefaultRegistrationParameter({ "Transform", { "TranslationTransform" } }), // default ""
});
registrationParameterObject.SetParameterMaps(
ParameterMapVectorType(transformParameterMaps.size(), registrationParameterMap));
elx::DefaultConstruct<elx::ParameterObject> transformParameterObject{};
elx::DefaultConstruct<elx::ParameterObject> transformixParameterObject{};
// Add the parameters that specify the fixed image domain to the last transformix parameter map.
auto transformixParameterMaps = transformParameterMaps;
transformixParameterMaps.back().merge(fixedImageDomain.AsParameterMap());
transformParameterObject.SetParameterMaps(transformParameterMaps);
transformixParameterObject.SetParameterMaps(transformixParameterMaps);
elx::DefaultConstruct<ElastixRegistrationMethodType<ImageType>> registration{};
elx::DefaultConstruct<itk::TransformixFilter<ImageType>> transformix{};
registration.SetParameterObject(®istrationParameterObject);
registration.SetInitialTransformParameterObject(&transformParameterObject);
transformix.SetTransformParameterObject(&transformixParameterObject);
registration.SetFixedImage(&fixedImage);
registration.SetMovingImage(&movingImage);
transformix.SetMovingImage(&movingImage);
registration.Update();
transformix.Update();
const auto & transformixOutput = DerefRawPointer(transformix.GetOutput());
// Sanity checks, checking that our test is non-trivial.
EXPECT_NE(transformixOutput, fixedImage);
EXPECT_NE(transformixOutput, movingImage);
const auto & actualRegistrationOutput = DerefRawPointer(registration.GetOutput());
EXPECT_EQ(actualRegistrationOutput, transformixOutput);
}
// Expects transformix to yield the same output image as an elastix registration, when transformix has the
// "TransformParameterObject" taken from the elastix registration result.
template <unsigned int VDimension>
void
Expect_equal_output_Transformix_SetTransformParameterObject_GetTransformParameterObject(
const ParameterMapVectorType & initialTransformParameterMaps,
const ImageDomain<VDimension> & fixedImageDomain,
const ImageDomain<VDimension> & movingImageDomain)
{
using PixelType = float;
using ImageType = itk::Image<PixelType, VDimension>;
std::mt19937 randomNumberEngine{};
const auto fillImageBufferRandomly = [&randomNumberEngine](ImageType & image) {
const itk::ImageBufferRange<ImageType> imageBufferRange(image);
std::generate(imageBufferRange.begin(), imageBufferRange.end(), [&randomNumberEngine] {
return std::uniform_real_distribution<PixelType>{ PixelType{ 1 }, PixelType{ 2 } }(randomNumberEngine);
});
};
itk::Size<VDimension> movingImageSize;
std::iota(movingImageSize.begin(), movingImageSize.end(), 5U);
elx::DefaultConstruct<ImageType> fixedImage{};
fixedImageDomain.ToImage(fixedImage);
fixedImage.Allocate(true);
fillImageBufferRandomly(fixedImage);
elx::DefaultConstruct<ImageType> movingImage{};
movingImageDomain.ToImage(movingImage);
movingImage.Allocate(true);
fillImageBufferRandomly(movingImage);
elx::DefaultConstruct<elx::ParameterObject> registrationParameterObject{};
const ParameterMapType registrationParameterMap = CreateParameterMap({
// Non-default parameters in alphabetic order:
NonDefaultRegistrationParameter({ "ImageSampler", { "Full" } }), // required
NonDefaultRegistrationParameter({ "MaximumNumberOfIterations", { "2" } }),
NonDefaultRegistrationParameter({ "Metric", { "AdvancedNormalizedCorrelation" } }), // default ""
NonDefaultRegistrationParameter({ "NumberOfResolutions", { "1" } }),
NonDefaultRegistrationParameter({ "Optimizer", { "AdaptiveStochasticGradientDescent" } }), // default ""
// RequiredRatioOfValidSamples as in the example in the elxMetricBase.h documentation. The FAQ even suggests 0.05:
// https://github.com/SuperElastix/elastix/wiki/FAQ/702a35cf0f5e0cf797b531fcbe3297ff9a9f3a18#i-am-getting-the-error-message-too-many-samples-map-outside-moving-image-buffer-what-does-that-mean
NonDefaultRegistrationParameter({ "RequiredRatioOfValidSamples", { "0.1" } }),
NonDefaultRegistrationParameter({ "Transform", { "BSplineTransform" } }), // default ""
});
registrationParameterObject.SetParameterMap(registrationParameterMap);
elx::DefaultConstruct<elx::ParameterObject> initialTransformParameterObject{};
initialTransformParameterObject.SetParameterMaps(initialTransformParameterMaps);
elx::DefaultConstruct<ElastixRegistrationMethodType<ImageType>> registration{};
registration.SetParameterObject(®istrationParameterObject);
registration.SetInitialTransformParameterObject(&initialTransformParameterObject);
registration.SetFixedImage(&fixedImage);
registration.SetMovingImage(&movingImage);
registration.Update();
elx::DefaultConstruct<itk::TransformixFilter<ImageType>> transformix{};
transformix.SetTransformParameterObject(registration.GetTransformParameterObject());
transformix.SetMovingImage(&movingImage);
transformix.Update();
const auto & transformixOutput = DerefRawPointer(transformix.GetOutput());
// Sanity checks, checking that our test is non-trivial.
EXPECT_NE(movingImage, fixedImage);
EXPECT_NE(transformixOutput, fixedImage);
EXPECT_NE(transformixOutput, movingImage);
const auto & actualRegistrationOutput = DerefRawPointer(registration.GetOutput());
EXPECT_EQ(actualRegistrationOutput, transformixOutput);
}
template <unsigned NDimension, unsigned NSplineOrder>
void
Test_WriteBSplineTransformToItkFileFormat(const std::string & rootOutputDirectoryPath)
{
using PixelType = float;
using ImageType = itk::Image<PixelType, NDimension>;
const auto image = CreateImage<PixelType>(itk::Size<NDimension>::Filled(4));
using ItkBSplineTransformType = itk::BSplineTransform<double, NDimension, NSplineOrder>;
const elx::DefaultConstruct<ItkBSplineTransformType> itkBSplineTransform;
const auto defaultFixedParameters = itkBSplineTransform.GetFixedParameters();
// FixedParameters store the grid size, origin, spacing, and direction, according to the ITK `BSplineTransform`
// default-constructor at
// https://github.com/InsightSoftwareConsortium/ITK/blob/v5.2.0/Modules/Core/Transform/include/itkBSplineTransform.hxx#L35-L61.
constexpr auto expectedNumberOfFixedParameters = NDimension * (NDimension + 3);
ASSERT_EQ(defaultFixedParameters.size(), expectedNumberOfFixedParameters);
elx::DefaultConstruct<ElastixRegistrationMethodType<ImageType>> registration{};
registration.SetFixedImage(image);
registration.SetMovingImage(image);
for (const std::string fileNameExtension : { "h5", "tfm" })
{
const std::string outputDirectoryPath = rootOutputDirectoryPath + "/" + std::to_string(NDimension) + "D_" +
"SplineOrder=" + std::to_string(NSplineOrder) +
"_FileNameExtension=" + fileNameExtension;
itk::FileTools::CreateDirectory(outputDirectoryPath);
registration.SetOutputDirectory(outputDirectoryPath);
registration.SetParameterObject(
CreateParameterObject({ // Parameters in alphabetic order:
{ "AutomaticTransformInitialization", "false" },
{ "ImageSampler", "Full" },
{ "BSplineTransformSplineOrder", std::to_string(NSplineOrder) },
{ "ITKTransformOutputFileNameExtension", fileNameExtension },
{ "MaximumNumberOfIterations", "0" },
{ "Metric", "AdvancedNormalizedCorrelation" },
{ "Optimizer", "AdaptiveStochasticGradientDescent" },
{ "Transform", "BSplineTransform" } }));
registration.Update();
const itk::TransformBase::ConstPointer readTransform =
elx::TransformIO::Read(outputDirectoryPath + "/TransformParameters.0." + fileNameExtension);
const itk::TransformBase & actualTransform = DerefSmartPointer(readTransform);
EXPECT_EQ(typeid(actualTransform), typeid(ItkBSplineTransformType));
EXPECT_EQ(actualTransform.GetParameters(), itkBSplineTransform.GetParameters());
const auto actualFixedParameters = actualTransform.GetFixedParameters();
ASSERT_EQ(actualFixedParameters.size(), expectedNumberOfFixedParameters);
for (unsigned i{}; i < NDimension; ++i)
{
EXPECT_EQ(actualFixedParameters[i], defaultFixedParameters[i]);
}
for (unsigned i{ NDimension }; i < 3 * NDimension; ++i)
{
// The actual values of the FixedParameters for grid origin and spacing differ from the corresponding
// default-constructed transform! That is expected!
EXPECT_NE(actualFixedParameters[i], defaultFixedParameters[i]);
}
for (unsigned i{ 3 * NDimension }; i < expectedNumberOfFixedParameters; ++i)
{
EXPECT_EQ(actualFixedParameters[i], defaultFixedParameters[i]);
}
}
}
template <typename TParametersValueType, unsigned int VInputDimension, unsigned int VOutputDimension>
itk::SizeValueType
GetNumberOfTransforms(const itk::Transform<TParametersValueType, VInputDimension, VOutputDimension> & transform)
{
if (const auto multiTransform =
dynamic_cast<const itk::MultiTransform<TParametersValueType, VInputDimension, VOutputDimension> *>(&transform))
{
return multiTransform->GetNumberOfTransforms();
}
return 1;
};
} // namespace
static_assert(sizeof(itk::ElastixLogLevel) == sizeof(elx::log::level),
"The log level enum types should have the same size!");
static_assert(sizeof(itk::ElastixLogLevel) == 1, "The log level enum type should have just one byte!");
static_assert(itk::ElastixLogLevel::Info == itk::ElastixLogLevel{}, "The default log level should be `Info`!");
static_assert(static_cast<int>(itk::ElastixLogLevel::Info) == static_cast<int>(elx::log::level::info) &&
static_cast<int>(itk::ElastixLogLevel::Warning) == static_cast<int>(elx::log::level::warn) &&
static_cast<int>(itk::ElastixLogLevel::Error) == static_cast<int>(elx::log::level::err) &&
static_cast<int>(itk::ElastixLogLevel::Off) == static_cast<int>(elx::log::level::off),
"Corresponding log level enumerators should have the same underlying integer value!");
GTEST_TEST(itkElastixRegistrationMethod, LogLevel)
{
using ImageType = itk::Image<float>;
elx::DefaultConstruct<ElastixRegistrationMethodType<ImageType>> elastixRegistrationMethod;
ASSERT_EQ(elastixRegistrationMethod.GetLogLevel(), itk::ElastixLogLevel{});
for (const auto logLevel : { itk::ElastixLogLevel::Info,
itk::ElastixLogLevel::Warning,
itk::ElastixLogLevel::Error,
itk::ElastixLogLevel::Off })
{
elastixRegistrationMethod.SetLogLevel(logLevel);
EXPECT_EQ(elastixRegistrationMethod.GetLogLevel(), logLevel);
}
}
GTEST_TEST(itkElastixRegistrationMethod, IsDefaultInitialized)
{
constexpr auto ImageDimension = 2U;
using PixelType = float;
using ImageType = itk::Image<PixelType, ImageDimension>;
const elx::DefaultConstruct<ElastixRegistrationMethodType<ImageType>> elastixRegistrationMethod;
EXPECT_EQ(elastixRegistrationMethod.GetInitialTransformParameterFileName(), std::string{});
EXPECT_EQ(elastixRegistrationMethod.GetFixedPointSetFileName(), std::string{});
EXPECT_EQ(elastixRegistrationMethod.GetMovingPointSetFileName(), std::string{});
EXPECT_EQ(elastixRegistrationMethod.GetOutputDirectory(), std::string{});
EXPECT_EQ(elastixRegistrationMethod.GetLogFileName(), std::string{});
EXPECT_FALSE(elastixRegistrationMethod.GetLogToConsole());
EXPECT_FALSE(elastixRegistrationMethod.GetLogToFile());
EXPECT_EQ(elastixRegistrationMethod.GetNumberOfThreads(), 0);
}
// Tests that the value zero is rejected for the "NumberOfResolutions" parameter.
GTEST_TEST(itkElastixRegistrationMethod, RejectZeroValueForNumberOfResolution)
{
constexpr auto ImageDimension = 2U;
using PixelType = float;
using ImageType = itk::Image<PixelType, ImageDimension>;
const itk::Size<ImageDimension> imageSize{ { 5, 6 } };
elx::DefaultConstruct<elx::ParameterObject> parameterObject{};
elx::DefaultConstruct<ElastixRegistrationMethodType<ImageType>> registration{};
registration.SetFixedImage(CreateImage<PixelType>(imageSize));
registration.SetMovingImage(CreateImage<PixelType>(imageSize));
registration.SetParameterObject(¶meterObject);
elx::ParameterObject::ParameterMapType parameterMap{ // Parameters in alphabetic order:
{ "ImageSampler", { "Full" } },
{ "MaximumNumberOfIterations", { "2" } },
{ "Metric", { "AdvancedNormalizedCorrelation" } },
{ "Optimizer", { "AdaptiveStochasticGradientDescent" } },
{ "Transform", { "TranslationTransform" } }
};
parameterObject.SetParameterMap(parameterMap);
// OK: "NumberOfResolutions" is unspecified, so use its default value.
EXPECT_NO_THROW(registration.Update());
for (const unsigned int numberOfResolutions : { 1, 2 })
{
// OK: Use a value greater than zero.
parameterMap["NumberOfResolutions"] = { std::to_string(numberOfResolutions) };
parameterObject.SetParameterMap(parameterMap);
EXPECT_NO_THROW(registration.Update());
}
// Expected to be rejected: the value zero.
parameterMap["NumberOfResolutions"] = { "0" };
parameterObject.SetParameterMap(parameterMap);
EXPECT_THROW(registration.Update(), itk::ExceptionObject);
}
// Tests registering two small (5x6) binary images, which are translated with respect to each other.
GTEST_TEST(itkElastixRegistrationMethod, Translation)
{
constexpr auto ImageDimension = 2U;
using PixelType = float;
using ImageType = itk::Image<PixelType, ImageDimension>;
using SizeType = itk::Size<ImageDimension>;
using IndexType = itk::Index<ImageDimension>;
using OffsetType = itk::Offset<ImageDimension>;
const OffsetType translationOffset{ { 1, -2 } };
const auto regionSize = SizeType::Filled(2);
const SizeType imageSize{ { 5, 6 } };
const IndexType fixedImageRegionIndex{ { 1, 3 } };
const auto fixedImage = CreateImage<PixelType>(imageSize);
FillImageRegion(*fixedImage, fixedImageRegionIndex, regionSize);
const auto movingImage = CreateImage<PixelType>(imageSize);
FillImageRegion(*movingImage, fixedImageRegionIndex + translationOffset, regionSize);
elx::DefaultConstruct<ElastixRegistrationMethodType<ImageType>> registration{};
registration.SetFixedImage(fixedImage);
registration.SetMovingImage(movingImage);
registration.SetParameterObject(CreateParameterObject({ // Parameters in alphabetic order:
{ "ImageSampler", "Full" },
{ "MaximumNumberOfIterations", "2" },
{ "Metric", "AdvancedNormalizedCorrelation" },
{ "Optimizer", "AdaptiveStochasticGradientDescent" },
{ "Transform", "TranslationTransform" } }));
registration.LogToConsoleOn();
registration.Update();
const auto transformParameters = GetTransformParametersFromFilter(registration);
EXPECT_EQ(ConvertToOffset<ImageDimension>(transformParameters), translationOffset);
}
// Tests "MaximumNumberOfIterations" value "0"
GTEST_TEST(itkElastixRegistrationMethod, MaximumNumberOfIterationsZero)
{
constexpr auto ImageDimension = 2U;
using PixelType = float;
using ImageType = itk::Image<PixelType, ImageDimension>;
using SizeType = itk::Size<ImageDimension>;
using IndexType = itk::Index<ImageDimension>;
using OffsetType = itk::Offset<ImageDimension>;
const OffsetType translationOffset{ { 1, -2 } };
const auto regionSize = SizeType::Filled(2);
const SizeType imageSize{ { 5, 6 } };
const IndexType fixedImageRegionIndex{ { 1, 3 } };
const auto fixedImage = CreateImage<PixelType>(imageSize);
FillImageRegion(*fixedImage, fixedImageRegionIndex, regionSize);
const auto movingImage = CreateImage<PixelType>(imageSize);
FillImageRegion(*movingImage, fixedImageRegionIndex + translationOffset, regionSize);
for (const auto optimizer :
{ "AdaptiveStochasticGradientDescent", "FiniteDifferenceGradientDescent", "StandardGradientDescent" })
{
elx::DefaultConstruct<ElastixRegistrationMethodType<ImageType>> registration{};
registration.SetFixedImage(fixedImage);
registration.SetMovingImage(movingImage);
registration.SetParameterObject(CreateParameterObject({ // Parameters in alphabetic order:
{ "ImageSampler", "Full" },
{ "MaximumNumberOfIterations", "0" },
{ "Metric", "AdvancedNormalizedCorrelation" },
{ "Optimizer", optimizer },
{ "Transform", "TranslationTransform" } }));
registration.Update();
const auto transformParameters = GetTransformParametersFromFilter(registration);
for (const auto & transformParameter : transformParameters)
{
EXPECT_EQ(transformParameter, 0.0);
}
}
}
// Tests "AutomaticTransformInitializationMethod" "CenterOfGravity".
GTEST_TEST(itkElastixRegistrationMethod, AutomaticTransformInitializationCenterOfGravity)
{
constexpr auto ImageDimension = 2U;
using PixelType = float;
using ImageType = itk::Image<PixelType, ImageDimension>;
using SizeType = itk::Size<ImageDimension>;
using IndexType = itk::Index<ImageDimension>;
using OffsetType = itk::Offset<ImageDimension>;
const OffsetType translationOffset{ { 1, -2 } };
const auto regionSize = SizeType::Filled(2);
const SizeType imageSize{ { 5, 6 } };
const IndexType fixedImageRegionIndex{ { 1, 3 } };
const auto fixedImage = CreateImage<PixelType>(imageSize);
FillImageRegion(*fixedImage, fixedImageRegionIndex, regionSize);
const auto movingImage = CreateImage<PixelType>(imageSize);
FillImageRegion(*movingImage, fixedImageRegionIndex + translationOffset, regionSize);
for (const bool automaticTransformInitialization : { false, true })
{
elx::DefaultConstruct<ElastixRegistrationMethodType<ImageType>> registration{};
registration.SetFixedImage(fixedImage);
registration.SetMovingImage(movingImage);
registration.SetParameterObject(CreateParameterObject(
{ // Parameters in alphabetic order:
{ "AutomaticTransformInitialization", automaticTransformInitialization ? "true" : "false" },
{ "AutomaticTransformInitializationMethod", "CenterOfGravity" },
{ "ImageSampler", "Full" },
{ "MaximumNumberOfIterations", "0" },
{ "Metric", "AdvancedNormalizedCorrelation" },
{ "Optimizer", "AdaptiveStochasticGradientDescent" },
{ "Transform", "TranslationTransform" } }));
registration.Update();
const auto transformParameters = GetTransformParametersFromFilter(registration);
const auto estimatedOffset = ConvertToOffset<ImageDimension>(transformParameters);
EXPECT_EQ(estimatedOffset == translationOffset, automaticTransformInitialization);
}
}
// Tests registering two images, having "WriteResultImage" set.
GTEST_TEST(itkElastixRegistrationMethod, WriteResultImage)
{
constexpr auto ImageDimension = 2U;
using PixelType = float;
using ImageType = itk::Image<PixelType, ImageDimension>;
using SizeType = itk::Size<ImageDimension>;
using IndexType = itk::Index<ImageDimension>;
using OffsetType = itk::Offset<ImageDimension>;
const OffsetType translationOffset{ { 1, -2 } };
const auto regionSize = SizeType::Filled(2);
const SizeType imageSize{ { 5, 6 } };
const IndexType fixedImageRegionIndex{ { 1, 3 } };
const auto fixedImage = CreateImage<PixelType>(imageSize);
FillImageRegion(*fixedImage, fixedImageRegionIndex, regionSize);
const auto movingImage = CreateImage<PixelType>(imageSize);
FillImageRegion(*movingImage, fixedImageRegionIndex + translationOffset, regionSize);
for (const bool writeResultImage : { true, false })
{
elx::DefaultConstruct<ElastixRegistrationMethodType<ImageType>> registration{};
registration.SetFixedImage(fixedImage);
registration.SetMovingImage(movingImage);
registration.SetParameterObject(
CreateParameterObject({ // Parameters in alphabetic order:
{ "ImageSampler", "Full" },
{ "MaximumNumberOfIterations", "2" },
{ "Metric", "AdvancedNormalizedCorrelation" },
{ "Optimizer", "AdaptiveStochasticGradientDescent" },
{ "Transform", "TranslationTransform" },
{ "WriteResultImage", (writeResultImage ? "true" : "false") } }));
registration.Update();
const auto & output = DerefRawPointer(registration.GetOutput());
const auto & outputImageSize = output.GetBufferedRegion().GetSize();
const auto * const outputBufferPointer = output.GetBufferPointer();
if (writeResultImage)
{
EXPECT_EQ(outputImageSize, imageSize);
ASSERT_NE(outputBufferPointer, nullptr);
// When "WriteResultImage" is true, expect an output image that is very much like the fixed image.
for (const auto index : itk::ZeroBasedIndexRange<ImageDimension>(imageSize))
{
EXPECT_EQ(std::round(output.GetPixel(index)), std::round(fixedImage->GetPixel(index)));
}
}
else
{
// When "WriteResultImage" is false, expect an empty output image.
EXPECT_EQ(outputImageSize, ImageType::SizeType());
EXPECT_EQ(outputBufferPointer, nullptr);
}
const auto transformParameters = GetTransformParametersFromFilter(registration);
EXPECT_EQ(ConvertToOffset<ImageDimension>(transformParameters), translationOffset);
}
}
// Tests registering two images, having a custom "ResultImageName" specified.
GTEST_TEST(itkElastixRegistrationMethod, ResultImageName)
{
constexpr auto ImageDimension = 2U;
using PixelType = float;
using ImageType = itk::Image<PixelType, ImageDimension>;
using SizeType = itk::Size<ImageDimension>;
using IndexType = itk::Index<ImageDimension>;
using OffsetType = itk::Offset<ImageDimension>;
const OffsetType translationOffset{ { 1, -2 } };
const auto regionSize = SizeType::Filled(2);
const SizeType imageSize{ { 5, 6 } };
const IndexType fixedImageRegionIndex{ { 1, 3 } };
const auto fixedImage = CreateImage<PixelType>(imageSize);
FillImageRegion(*fixedImage, fixedImageRegionIndex, regionSize);
const auto movingImage = CreateImage<PixelType>(imageSize);
FillImageRegion(*movingImage, fixedImageRegionIndex + translationOffset, regionSize);
const std::string rootOutputDirectoryPath = GetCurrentBinaryDirectoryPath() + '/' + GetNameOfTest(*this);
itk::FileTools::CreateDirectory(rootOutputDirectoryPath);
const auto numberOfResolutions = 2u;
const std::string customResultImageName = "CustomResultImageName";
const auto getOutputSubdirectoryPath = [rootOutputDirectoryPath](const bool useCustomResultImageName) {
return rootOutputDirectoryPath + '/' +
(useCustomResultImageName ? "DefaultResultImageName" : "CustomResultImageName");
};
for (const bool useCustomResultImageName : { true, false })
{
elx::DefaultConstruct<ElastixRegistrationMethodType<ImageType>> registration{};
const std::string outputSubdirectoryPath = getOutputSubdirectoryPath(useCustomResultImageName);
itk::FileTools::CreateDirectory(outputSubdirectoryPath);
registration.SetOutputDirectory(outputSubdirectoryPath);
registration.SetFixedImage(fixedImage);
registration.SetMovingImage(movingImage);
auto parameterMap = CreateParameterMap({ // Parameters in alphabetic order:
{ "ImageSampler", "Full" },
{ "MaximumNumberOfIterations", "2" },
{ "Metric", "AdvancedNormalizedCorrelation" },
{ "NumberOfResolutions", std::to_string(numberOfResolutions) },
{ "Optimizer", "AdaptiveStochasticGradientDescent" },
{ "Transform", "TranslationTransform" },
{ "WriteResultImageAfterEachResolution", "true" } });
if (useCustomResultImageName)
{
parameterMap["ResultImageName"] = { customResultImageName };
}
const auto parameterObject = elx::ParameterObject::New();
parameterObject->SetParameterMap(parameterMap);
registration.SetParameterObject(parameterObject);
registration.Update();
}
for (unsigned int resolutionNumber{ 0 }; resolutionNumber < numberOfResolutions; ++resolutionNumber)
{
const auto fileNamePostFix = ".0.R" + std::to_string(resolutionNumber) + ".mhd";
const auto expectedImage =
itk::ReadImage<ImageType>(getOutputSubdirectoryPath(false) + "/result" + fileNamePostFix);
const auto actualImage =
itk::ReadImage<ImageType>(getOutputSubdirectoryPath(true) + '/' + customResultImageName + fileNamePostFix);
ASSERT_NE(expectedImage, nullptr);
ASSERT_NE(actualImage, nullptr);
EXPECT_EQ(*actualImage, *expectedImage);
}
}
// Tests that the origin of the output image is equal to the origin of the fixed image (by default).
GTEST_TEST(itkElastixRegistrationMethod, OutputHasSameOriginAsFixedImage)
{
constexpr auto ImageDimension = 2U;
using PixelType = float;
using ImageType = itk::Image<PixelType, ImageDimension>;
using SizeType = itk::Size<ImageDimension>;
using IndexType = itk::Index<ImageDimension>;
using OffsetType = itk::Offset<ImageDimension>;
const OffsetType translationOffset{ { 1, -2 } };
const auto regionSize = SizeType::Filled(2);
const SizeType imageSize{ { 12, 16 } };
const IndexType fixedImageRegionIndex{ { 3, 9 } };
const auto fixedImage = CreateImage<PixelType>(imageSize);
FillImageRegion(*fixedImage, fixedImageRegionIndex, regionSize);
const auto movingImage = CreateImage<PixelType>(imageSize);
FillImageRegion(*movingImage, fixedImageRegionIndex + translationOffset, regionSize);
for (const auto fixedImageOrigin : { itk::MakePoint(-1.0, -2.0), ImageType::PointType(), itk::MakePoint(0.25, 0.75) })
{
fixedImage->SetOrigin(fixedImageOrigin);
for (const auto movingImageOrigin :
{ itk::MakePoint(-1.0, -2.0), ImageType::PointType(), itk::MakePoint(0.25, 0.75) })
{
movingImage->SetOrigin(movingImageOrigin);
elx::DefaultConstruct<ElastixRegistrationMethodType<ImageType>> registration{};
registration.SetFixedImage(fixedImage);
registration.SetMovingImage(movingImage);
registration.SetParameterObject(CreateParameterObject({ // Parameters in alphabetic order:
{ "ImageSampler", "Full" },
{ "MaximumNumberOfIterations", "2" },
{ "Metric", "AdvancedNormalizedCorrelation" },
{ "Optimizer", "AdaptiveStochasticGradientDescent" },
{ "Transform", "TranslationTransform" } }));
registration.Update();
const auto & output = DerefRawPointer(registration.GetOutput());
// The most essential check of this test.
EXPECT_EQ(output.GetOrigin(), fixedImageOrigin);
ASSERT_EQ(output.GetBufferedRegion().GetSize(), imageSize);
ASSERT_NE(output.GetBufferPointer(), nullptr);
// Expect an output image that is very much like the fixed image.
for (const auto & index : itk::ZeroBasedIndexRange<ImageDimension>(imageSize))
{
EXPECT_EQ(std::round(output.GetPixel(index)), std::round(fixedImage->GetPixel(index)));
}
const auto transformParameters = GetTransformParametersFromFilter(registration);
ASSERT_EQ(transformParameters.size(), ImageDimension);
for (std::size_t i{}; i < ImageDimension; ++i)
{
EXPECT_EQ(std::round(transformParameters[i] + fixedImageOrigin[i] - movingImageOrigin[i]),
translationOffset[i]);
}
}
}
}
GTEST_TEST(itkElastixRegistrationMethod, InitialTransformParameterFile)
{
using PixelType = float;
constexpr auto ImageDimension = 2U;
using ImageType = itk::Image<PixelType, ImageDimension>;
using SizeType = itk::Size<ImageDimension>;
using IndexType = itk::Index<ImageDimension>;
using OffsetType = itk::Offset<ImageDimension>;
const OffsetType initialTranslation{ { 1, -2 } };
const auto regionSize = SizeType::Filled(2);
const SizeType imageSize{ { 5, 6 } };
const IndexType fixedImageRegionIndex{ { 1, 3 } };
const auto fixedImage = CreateImage<PixelType>(imageSize);
FillImageRegion(*fixedImage, fixedImageRegionIndex, regionSize);
const auto movingImage = CreateImage<PixelType>(imageSize);
elx::DefaultConstruct<ElastixRegistrationMethodType<ImageType>> registration{};
registration.SetFixedImage(fixedImage);
registration.SetInitialTransformParameterFileName(GetDataDirectoryPath() +
"/Translation(1,-2)/TransformParameters.txt");
registration.SetParameterObject(CreateParameterObject({ // Parameters in alphabetic order:
{ "ImageSampler", "Full" },
{ "MaximumNumberOfIterations", "2" },
{ "Metric", "AdvancedNormalizedCorrelation" },
{ "Optimizer", "AdaptiveStochasticGradientDescent" },
{ "Transform", "TranslationTransform" } }));
for (const auto index :
itk::ImageRegionIndexRange<ImageDimension>(itk::ImageRegion<ImageDimension>({ 0, -2 }, { 2, 3 })))
{
const auto actualTranslation = ConvertIndexToOffset(index);
movingImage->FillBuffer(0);
FillImageRegion(*movingImage, fixedImageRegionIndex + actualTranslation, regionSize);
registration.SetMovingImage(movingImage);
registration.Update();
const auto transformParameters = GetTransformParametersFromFilter(registration);
EXPECT_EQ(initialTranslation + ConvertToOffset<ImageDimension>(transformParameters), actualTranslation);
}
}
GTEST_TEST(itkElastixRegistrationMethod, InitialTransformParameterFileWithInitialTransformParameterFile)
{
using PixelType = float;
enum
{
ImageDimension = 2U
};
using ImageType = itk::Image<PixelType, ImageDimension>;
const auto doDummyRegistration =
[](const std::string & initialTransformParameterFileName) -> itk::SmartPointer<ImageType> {
const ImageType::SizeType imageSize{ { 5, 6 } };
std::mt19937 randomNumberEngine{};
const auto fillImageBufferRandomly = [&randomNumberEngine](ImageType & image) {
const itk::ImageBufferRange<ImageType> imageBufferRange(image);
std::generate(imageBufferRange.begin(), imageBufferRange.end(), [&randomNumberEngine] {
return std::uniform_real_distribution<PixelType>{ PixelType{ 1 }, PixelType{ 2 } }(randomNumberEngine);
});
};
elx::DefaultConstruct<ImageType> fixedImage{};
fixedImage.SetRegions(imageSize);
fixedImage.Allocate(true);
fillImageBufferRandomly(fixedImage);
elx::DefaultConstruct<ImageType> movingImage{};
movingImage.SetRegions(imageSize);
movingImage.Allocate(true);
fillImageBufferRandomly(movingImage);
elx::DefaultConstruct<ElastixRegistrationMethodType<ImageType>> registration{};
registration.SetFixedImage(&fixedImage);
registration.SetMovingImage(&movingImage);
registration.SetInitialTransformParameterFileName(initialTransformParameterFileName);
registration.SetParameterObject(CreateParameterObject({ // Parameters in alphabetic order:
{ "AutomaticTransformInitialization", "false" },
{ "ImageSampler", "Full" },
{ "MaximumNumberOfIterations", "0" },
{ "Metric", "AdvancedNormalizedCorrelation" },
{ "Optimizer", "AdaptiveStochasticGradientDescent" },
{ "Transform", "TranslationTransform" } }));
registration.Update();
return registration.GetOutput();
};
EXPECT_EQ(
DerefSmartPointer(doDummyRegistration(
GetDataDirectoryPath() + "/Translation(1,-2)/TransformParametersWithInitialTransformParameterFile.txt")),
DerefSmartPointer(doDummyRegistration(GetDataDirectoryPath() + "/Translation(1,-2)/TransformParameters.txt")));
}
GTEST_TEST(itkElastixRegistrationMethod, SetInitialTransform)
{
using PixelType = float;
enum
{
ImageDimension = 2U
};
using ImageType = itk::Image<PixelType, ImageDimension>;
using SizeType = itk::Size<ImageDimension>;
using IndexType = itk::Index<ImageDimension>;
using OffsetType = itk::Offset<ImageDimension>;
const OffsetType initialTranslation{ { 1, -2 } };
const auto regionSize = SizeType::Filled(2);
const SizeType imageSize{ { 5, 6 } };
const IndexType fixedImageRegionIndex{ { 1, 3 } };
using TransformType = ElastixRegistrationMethodType<ImageType>::TransformType;
const TransformType::ConstPointer singleInitialTransform = [] {
const auto singleTransform = itk::TranslationTransform<double, ImageDimension>::New();
singleTransform->SetOffset(itk::MakeVector(1.0, -2.0));
return singleTransform;
}();
const TransformType::ConstPointer compositeInitialTransform = [] {
const auto translationTransformX = itk::TranslationTransform<double, ImageDimension>::New();
translationTransformX->SetOffset(itk::MakeVector(1.0, 0.0));
const auto translationTransformY = itk::TranslationTransform<double, ImageDimension>::New();
translationTransformY->SetOffset(itk::MakeVector(0.0, -2.0));
const auto compositeTransform = itk::CompositeTransform<double, ImageDimension>::New();
compositeTransform->AddTransform(translationTransformX);
compositeTransform->AddTransform(translationTransformY);
return compositeTransform;
}();
// Test both a single and a composite transform as initial transform.
for (const TransformType * const initialTransform : { singleInitialTransform, compositeInitialTransform })
{
const auto fixedImage = CreateImage<PixelType>(imageSize);
FillImageRegion(*fixedImage, fixedImageRegionIndex, regionSize);
const auto movingImage = CreateImage<PixelType>(imageSize);
elx::DefaultConstruct<elx::ParameterObject> registrationParameterObject{};
elx::DefaultConstruct<ElastixRegistrationMethodType<ImageType>> registration{};
registration.SetFixedImage(fixedImage);
registration.SetInitialTransform(initialTransform);
registration.SetParameterObject(®istrationParameterObject);
const elx::ParameterObject::ParameterMapType registrationParameterMap{
// Parameters in alphabetic order:
{ "ImageSampler", { "Full" } },
{ "MaximumNumberOfIterations", { "2" } },
{ "Metric", { "AdvancedNormalizedCorrelation" } },
{ "Optimizer", { "AdaptiveStochasticGradientDescent" } },
{ "Transform", { "TranslationTransform" } }
};
for (const unsigned int numberOfRegistrationParameterMaps : { 1, 2, 3 })
{
// Specify multiple (one or more) registration parameter maps.
registrationParameterObject.SetParameterMaps(
ParameterMapVectorType(numberOfRegistrationParameterMaps, registrationParameterMap));
const auto numberOfInitialTransformParameterMaps = GetNumberOfTransforms(*initialTransform);
// Do the test for a few possible translations.
for (const auto index :
itk::ImageRegionIndexRange<ImageDimension>(itk::ImageRegion<ImageDimension>({ 0, -2 }, { 2, 3 })))
{
const auto actualTranslation = ConvertIndexToOffset(index);
movingImage->FillBuffer(0);
FillImageRegion(*movingImage, fixedImageRegionIndex + actualTranslation, regionSize);
registration.SetMovingImage(movingImage);
registration.Update();
const auto & transformParameterMaps =
DerefRawPointer(registration.GetTransformParameterObject()).GetParameterMaps();
ASSERT_EQ(transformParameterMaps.size(),
numberOfInitialTransformParameterMaps + numberOfRegistrationParameterMaps);
// All transform parameter maps, except for the initial transformations and the transform parameter map of the
// first registration should just have a zero-translation.
for (auto i = numberOfInitialTransformParameterMaps + 1; i < numberOfRegistrationParameterMaps; ++i)
{
const auto transformParameters =
ConvertStringsToVectorOfDouble(transformParameterMaps[i].at("TransformParameters"));
EXPECT_EQ(ConvertToOffset<ImageDimension>(transformParameters), OffsetType{});
}
// Together the initial translation and the first registration should yield the actual image translation.
const auto transformParameters = ConvertStringsToVectorOfDouble(
transformParameterMaps[numberOfInitialTransformParameterMaps].at("TransformParameters"));
EXPECT_EQ(initialTranslation + ConvertToOffset<ImageDimension>(transformParameters), actualTranslation);
}
}
}
}
GTEST_TEST(itkElastixRegistrationMethod, SetInitialTransformParameterObject)
{
using PixelType = float;
constexpr auto ImageDimension = 2U;
using ImageType = itk::Image<PixelType, ImageDimension>;
using SizeType = itk::Size<ImageDimension>;
using IndexType = itk::Index<ImageDimension>;
using OffsetType = itk::Offset<ImageDimension>;
const OffsetType initialTranslation{ { 1, -2 } };
const auto regionSize = SizeType::Filled(2);
const SizeType imageSize{ { 5, 6 } };
const IndexType fixedImageRegionIndex{ { 1, 3 } };
const auto fixedImage = CreateImage<PixelType>(imageSize);
FillImageRegion(*fixedImage, fixedImageRegionIndex, regionSize);
const auto movingImage = CreateImage<PixelType>(imageSize);
elx::DefaultConstruct<elx::ParameterObject> registrationParameterObject{};
elx::DefaultConstruct<elx::ParameterObject> initialTransformParameterObject{};
elx::DefaultConstruct<ElastixRegistrationMethodType<ImageType>> registration{};
registration.SetFixedImage(fixedImage);
registration.SetInitialTransformParameterObject(&initialTransformParameterObject);
registration.SetParameterObject(®istrationParameterObject);
const elx::ParameterObject::ParameterMapType registrationParameterMap{
// Parameters in alphabetic order:
{ "ImageSampler", { "Full" } },
{ "MaximumNumberOfIterations", { "2" } },
{ "Metric", { "AdvancedNormalizedCorrelation" } },
{ "Optimizer", { "AdaptiveStochasticGradientDescent" } },
{ "Transform", { "TranslationTransform" } }
};
for (const unsigned int numberOfRegistrationParameterMaps : { 1, 2, 3 })
{
using ParameterMapVectorType = elx::ParameterObject::ParameterMapVectorType;
// Specify multiple (one or more) registration parameter maps.
registrationParameterObject.SetParameterMaps(
ParameterMapVectorType(numberOfRegistrationParameterMaps, registrationParameterMap));
// Test both one and two transform parameter maps (both specifying a (1, -2) translation in this case).
for (const auto & initialTransformParameterMaps :
{ ParameterMapVectorType{ { { "NumberOfParameters", { "2" } },
{ "Transform", { "TranslationTransform" } },
{ "TransformParameters", { "1", "-2" } } } },
ParameterMapVectorType{ { { "NumberOfParameters", { "2" } },
{ "Transform", { "TranslationTransform" } },
{ "TransformParameters", { "1", "0" } } },
{ { "NumberOfParameters", { "2" } },
{ "Transform", { "TranslationTransform" } },
{ "TransformParameters", { "0", "-2" } } } } })
{
const auto numberOfInitialTransformParameterMaps = initialTransformParameterMaps.size();
initialTransformParameterObject.SetParameterMaps(initialTransformParameterMaps);
// Do the test for a few possible translations.
for (const auto index :
itk::ImageRegionIndexRange<ImageDimension>(itk::ImageRegion<ImageDimension>({ 0, -2 }, { 2, 3 })))
{
const auto actualTranslation = ConvertIndexToOffset(index);
movingImage->FillBuffer(0);
FillImageRegion(*movingImage, fixedImageRegionIndex + actualTranslation, regionSize);
registration.SetMovingImage(movingImage);
registration.Update();
const auto & transformParameterMaps =
DerefRawPointer(registration.GetTransformParameterObject()).GetParameterMaps();
ASSERT_EQ(transformParameterMaps.size(),
numberOfInitialTransformParameterMaps + numberOfRegistrationParameterMaps);
for (std::size_t i{}; i < numberOfInitialTransformParameterMaps; ++i)
{
EXPECT_EQ(transformParameterMaps[i], initialTransformParameterMaps[i]);
}
// All registration parameter maps, except for the first one, should just have a zero-translation.
for (auto i = numberOfInitialTransformParameterMaps + 1; i < numberOfRegistrationParameterMaps; ++i)
{
const auto transformParameters =
ConvertStringsToVectorOfDouble(transformParameterMaps[i].at("TransformParameters"));
EXPECT_EQ(ConvertToOffset<ImageDimension>(transformParameters), OffsetType{});
}
// Together the initial translation and the first registration should have the actual image translation.
const auto transformParameters = ConvertStringsToVectorOfDouble(
transformParameterMaps[numberOfInitialTransformParameterMaps].at("TransformParameters"));
EXPECT_EQ(initialTranslation + ConvertToOffset<ImageDimension>(transformParameters), actualTranslation);
}
}
}
}
GTEST_TEST(itkElastixRegistrationMethod, SetExternalTransformAsInitialTransform)
{
constexpr unsigned int ImageDimension{ 2 };
using PixelType = float;
using SizeType = itk::Size<ImageDimension>;
const SizeType imageSize{ { 5, 6 } };
using ImageType = itk::Image<PixelType, ImageDimension>;
using TransformixFilterType = itk::TransformixFilter<ImageType>;
const ImageDomain<ImageDimension> imageDomain(imageSize);
elx::DefaultConstruct<itk::TranslationTransform<double, ImageDimension>> itkTransform;
itkTransform.SetOffset(itk::MakeVector(1.0, -2.0));
using ImageType = itk::Image<PixelType, ImageDimension>;
using SizeType = itk::Size<ImageDimension>;
using IndexType = itk::Index<ImageDimension>;
using OffsetType = itk::Offset<ImageDimension>;
const OffsetType initialTranslation{ { 1, -2 } };
const auto regionSize = SizeType::Filled(2);
const IndexType fixedImageRegionIndex{ { 1, 3 } };
const auto fixedImage = CreateImage<PixelType>(imageSize);
FillImageRegion(*fixedImage, fixedImageRegionIndex, regionSize);
const auto movingImage = CreateImage<PixelType>(imageSize);
elx::DefaultConstruct<elx::ParameterObject> registrationParameterObject{};
elx::DefaultConstruct<elx::ParameterObject> initialTransformParameterObject{};
elx::DefaultConstruct<ElastixRegistrationMethodType<ImageType>> registration{};
registration.SetFixedImage(fixedImage);
registration.SetInitialTransformParameterObject(&initialTransformParameterObject);
registration.SetParameterObject(®istrationParameterObject);
registration.SetLogToConsole(true);
const elx::ParameterObject::ParameterMapType registrationParameterMap{
// Parameters in alphabetic order:
{ "ImageSampler", { "Full" } },
{ "MaximumNumberOfIterations", { "2" } },
{ "Metric", { "AdvancedNormalizedCorrelation" } },
{ "Optimizer", { "AdaptiveStochasticGradientDescent" } },
{ "Transform", { "TranslationTransform" } }
};
registrationParameterObject.SetParameterMap(registrationParameterMap);
const ParameterMapType initialTransformParameterMap{ { "NumberOfParameters", { "0" } },
{ "Transform", { "ExternalTransform" } },
{ "TransformAddress",
{ elx::Conversion::ObjectPtrToString(&itkTransform) } } };
initialTransformParameterObject.SetParameterMap(initialTransformParameterMap);
// Do the test for a few possible translations.
for (const auto index :
itk::ImageRegionIndexRange<ImageDimension>(itk::ImageRegion<ImageDimension>({ 0, -2 }, { 2, 3 })))
{
const auto actualTranslation = ConvertIndexToOffset(index);
movingImage->FillBuffer(0);
FillImageRegion(*movingImage, fixedImageRegionIndex + actualTranslation, regionSize);
registration.SetMovingImage(movingImage);
registration.Update();
const auto & transformParameterMaps =
DerefRawPointer(registration.GetTransformParameterObject()).GetParameterMaps();
ASSERT_EQ(transformParameterMaps.size(), 2);
EXPECT_EQ(transformParameterMaps.front(), initialTransformParameterMap);
// Together the initial translation and the first registration should have the actual image translation.
const auto transformParameters =
ConvertStringsToVectorOfDouble(transformParameterMaps.back().at("TransformParameters"));
EXPECT_EQ(initialTranslation + ConvertToOffset<ImageDimension>(transformParameters), actualTranslation);
}
}
GTEST_TEST(itkElastixRegistrationMethod, SetExternalInitialTransform)
{
constexpr unsigned int ImageDimension{ 2 };
using PixelType = float;
using SizeType = itk::Size<ImageDimension>;
const SizeType imageSize{ { 5, 6 } };
using ImageType = itk::Image<PixelType, ImageDimension>;
using TransformixFilterType = itk::TransformixFilter<ImageType>;
const ImageDomain<ImageDimension> imageDomain(imageSize);
using ImageType = itk::Image<PixelType, ImageDimension>;
using SizeType = itk::Size<ImageDimension>;
using IndexType = itk::Index<ImageDimension>;
using OffsetType = itk::Offset<ImageDimension>;
const OffsetType initialTranslation{ { 1, -2 } };
const auto regionSize = SizeType::Filled(2);
const IndexType fixedImageRegionIndex{ { 1, 3 } };
elx::DefaultConstruct<itk::DisplacementFieldTransform<double, ImageDimension>> itkTransform{};
const auto displacementField = itk::Image<itk::Vector<double, ImageDimension>, ImageDimension>::New();
displacementField->SetRegions(imageSize);
displacementField->Allocate(true);
itkTransform.SetDisplacementField(displacementField);
const itk::ImageBufferRange displacementFieldImageBufferRange{ *displacementField };
std::fill_n(displacementFieldImageBufferRange.begin(),
displacementFieldImageBufferRange.size(),
// C++17 note: for itk::Vector (ITK 5.3.0) template argument deduction (CTAD) cannot be used here! The
// template arguments of `itk::Vector{ std::array{ 1.0, -2.0 } }` are deduced to `std::array<double, 2>,
// 3` by both GNU 9.4.0 and MacOS11/Xcode_13.2.1/MacOSX12.1 Clang.
itk::Vector<double, ImageDimension>{ std::array{ 1.0, -2.0 } });
const auto fixedImage = CreateImage<PixelType>(imageSize);
FillImageRegion(*fixedImage, fixedImageRegionIndex, regionSize);
const auto movingImage = CreateImage<PixelType>(imageSize);
elx::DefaultConstruct<elx::ParameterObject> registrationParameterObject{};
elx::DefaultConstruct<elx::ParameterObject> initialTransformParameterObject{};
elx::DefaultConstruct<ElastixRegistrationMethodType<ImageType>> registration{};
registration.SetFixedImage(fixedImage);
registration.SetExternalInitialTransform(&itkTransform);
registration.SetParameterObject(®istrationParameterObject);
const elx::ParameterObject::ParameterMapType registrationParameterMap{
// Parameters in alphabetic order:
{ "ImageSampler", { "Full" } },
{ "MaximumNumberOfIterations", { "2" } },
{ "Metric", { "AdvancedNormalizedCorrelation" } },
{ "Optimizer", { "AdaptiveStochasticGradientDescent" } },
{ "Transform", { "TranslationTransform" } }
};
registrationParameterObject.SetParameterMap(registrationParameterMap);
const ParameterMapType initialTransformParameterMap{ { "NumberOfParameters", { "0" } },
{ "Transform", { "ExternalTransform" } },
{ "TransformAddress",
{ elx::Conversion::ObjectPtrToString(&itkTransform) } } };
// Do the test for a few possible translations.
for (const auto index :
itk::ImageRegionIndexRange<ImageDimension>(itk::ImageRegion<ImageDimension>({ 0, -2 }, { 2, 3 })))
{
const auto actualTranslation = ConvertIndexToOffset(index);
movingImage->FillBuffer(0);
FillImageRegion(*movingImage, fixedImageRegionIndex + actualTranslation, regionSize);
registration.SetMovingImage(movingImage);
registration.Update();
const auto & transformParameterMaps =
DerefRawPointer(registration.GetTransformParameterObject()).GetParameterMaps();
ASSERT_EQ(transformParameterMaps.size(), 2);
EXPECT_EQ(transformParameterMaps.front(), initialTransformParameterMap);
// Together the initial translation and the first registration should have the actual image translation.
const auto transformParameters =
ConvertStringsToVectorOfDouble(transformParameterMaps.back().at("TransformParameters"));
EXPECT_EQ(initialTranslation + ConvertToOffset<ImageDimension>(transformParameters), actualTranslation);
}
}
GTEST_TEST(itkElastixRegistrationMethod, SetExternalInitialTransformAndOutputDirectory)
{
const std::string outputDirectoryPath = GetCurrentBinaryDirectoryPath() + '/' + GetNameOfTest(*this);
itk::FileTools::CreateDirectory(outputDirectoryPath);
enum
{
ImageDimension = 2
};
using PixelType = float;
using SizeType = itk::Size<ImageDimension>;
const SizeType imageSize{ { 5, 6 } };
using ImageType = itk::Image<PixelType, ImageDimension>;
const auto displacementField = itk::Image<itk::Vector<double, ImageDimension>, ImageDimension>::New();
displacementField->SetRegions(imageSize);
displacementField->Allocate(true);
std::mt19937 randomNumberEngine{};
// Generate a rather arbitrary displacement field.
const itk::ImageBufferRange displacementFieldImageBufferRange{ *displacementField };
std::generate_n(
displacementFieldImageBufferRange.begin(), displacementFieldImageBufferRange.size(), [&randomNumberEngine] {
itk::Vector<double, ImageDimension> displacementVector{};
std::generate_n(displacementVector.begin(), ImageDimension, [&randomNumberEngine] {
return std::uniform_int_distribution<>{ -1, 1 }(randomNumberEngine);
});
return displacementVector;
});
elx::DefaultConstruct<itk::DisplacementFieldTransform<double, ImageDimension>> itkTransform{};
itkTransform.SetDisplacementField(displacementField);
const auto fixedImage = CreateImage<PixelType>(imageSize);
const auto movingImage = CreateImage<PixelType>(imageSize);
const elx::ParameterObject::ParameterMapType registrationParameterMap{
// Parameters in alphabetic order:
{ "ImageSampler", { "Full" } },
{ "MaximumNumberOfIterations", { "2" } },
{ "Metric", { "AdvancedNormalizedCorrelation" } },
{ "Optimizer", { "AdaptiveStochasticGradientDescent" } },
{ "Transform", { "TranslationTransform" } }
};
elx::DefaultConstruct<elx::ParameterObject> registrationParameterObject{};
registrationParameterObject.SetParameterMap(registrationParameterMap);
elx::DefaultConstruct<ElastixRegistrationMethodType<ImageType>> registration{};
registration.SetFixedImage(fixedImage);
registration.SetMovingImage(movingImage);
registration.SetExternalInitialTransform(&itkTransform);
registration.SetOutputDirectory(outputDirectoryPath);
registration.SetParameterObject(®istrationParameterObject);
registration.Update();
// Read back the initial transform that should have been written by registration.Update().
const auto reader = itk::TransformFileReader::New();
reader->SetFileName(outputDirectoryPath + "/InitialTransform.0.tfm");
reader->Update();
// Check that the read transform is equal to the initially specified ITK transform.
const auto & readTransformList = DerefRawPointer(reader->GetTransformList());
ASSERT_EQ(readTransformList.size(), 1);
const auto & readTransform = DerefSmartPointer(readTransformList.front());
EXPECT_EQ(readTransform.GetParameters(), itkTransform.GetParameters());
EXPECT_EQ(readTransform.GetFixedParameters(), itkTransform.GetFixedParameters());
EXPECT_EQ(readTransform.GetTransformTypeAsString(), itkTransform.GetTransformTypeAsString());
}
// Tests that the CombinationTransform produced by a registration using an external initial transform can be converted
// to an ITK CompositeTransform. Tests that this CompositeTransform has a pointer to the initial transform as its "back
// transform".
GTEST_TEST(itkElastixRegistrationMethod, SetExternalInitialTransformAndConvertToItkTransform)
{
constexpr auto ImageDimension = 2u;
using PixelType = float;
using ImageType = itk::Image<PixelType, ImageDimension>;
const itk::Size<ImageDimension> imageSize{ { 5, 6 } };
elx::DefaultConstruct<itk::DisplacementFieldTransform<double, ImageDimension>> externalTransform{};
externalTransform.SetDisplacementField(CreateImage<itk::Vector<double, ImageDimension>, ImageDimension>(imageSize));
elx::DefaultConstruct<elx::ParameterObject> registrationParameterObject{};
registrationParameterObject.SetParameterMap(
ParameterMapType{ // Parameters in alphabetic order:
{ "ImageSampler", { "Full" } },
{ "MaximumNumberOfIterations", { "2" } },
{ "Metric", { "AdvancedNormalizedCorrelation" } },
{ "Optimizer", { "AdaptiveStochasticGradientDescent" } },
{ "Transform", { "TranslationTransform" } } });
elx::DefaultConstruct<ElastixRegistrationMethodType<ImageType>> registration{};
registration.SetFixedImage(CreateImage<PixelType>(imageSize));
registration.SetMovingImage(CreateImage<PixelType>(imageSize));
registration.SetParameterObject(®istrationParameterObject);
registration.SetExternalInitialTransform(&externalTransform);
registration.Update();
const auto combinationTransform = registration.GetCombinationTransform();
const auto convertedTransform =
ElastixRegistrationMethodType<ImageType>::ConvertToItkTransform(DerefRawPointer(combinationTransform));
const auto & compositeTransform =
DerefRawPointer(dynamic_cast<itk::CompositeTransform<double, ImageDimension> *>(convertedTransform.GetPointer()));
ASSERT_EQ(compositeTransform.GetNumberOfTransforms(), 2);
EXPECT_NE(compositeTransform.GetFrontTransform(), &externalTransform);
EXPECT_EQ(compositeTransform.GetBackTransform(), &externalTransform);
}
GTEST_TEST(itkElastixRegistrationMethod, SetInitialTransformParameterObjectVersusTransformix)
{
{
std::mt19937 randomNumberEngine{};
const auto ImageDimension = 2U;
const auto randomSign = [&randomNumberEngine] { return (randomNumberEngine() % 2 == 0) ? -1.0 : 1.0; };
const std::array translationTransformParameters = {
randomSign() * (1.0 + std::uniform_real_distribution<>{}(randomNumberEngine)),
randomSign() * (1.0 + std::uniform_real_distribution<>{}(randomNumberEngine))
};
const elx::ParameterObject::ParameterMapType translationTransformParameterMap = CreateParameterMap(
{ // Default parameters in alphabetic order:
DefaultTransformParameter({ "FinalBSplineInterpolationOrder", { "3" } }),
DefaultTransformParameter({ "FixedInternalImagePixelType", { "float" } }),
DefaultTransformParameter({ "HowToCombineTransforms", { "Compose" } }),
DefaultTransformParameter({ "InitialTransformParameterFileName", { "NoInitialTransform" } }),
DefaultTransformParameter({ "MovingInternalImagePixelType", { "float" } }),
DefaultTransformParameter({ "ResampleInterpolator", { "FinalBSplineInterpolator" } }),
DefaultTransformParameter({ "Resampler", { "DefaultResampler" } }),
// Non-default parameters in alphabetic order:
NonDefaultTransformParameter(
{ "NumberOfParameters", { std::to_string(translationTransformParameters.size()) } }),
NonDefaultTransformParameter({ "Transform", { "TranslationTransform" } }),
NonDefaultTransformParameter(
{ "TransformParameters", elx::Conversion::ToVectorOfStrings(translationTransformParameters) }) });
constexpr auto gridValueSize = 4U;
std::array<double, ImageDimension * itk::Math::UnsignedPower(gridValueSize, ImageDimension)>
bsplineTransformParameters;
std::generate(bsplineTransformParameters.begin(), bsplineTransformParameters.end(), [&randomNumberEngine] {
return std::uniform_real_distribution<>{ -1.0, 1.0 }(randomNumberEngine);
});
const elx::ParameterObject::ParameterMapType bsplineTransformParameterMap = CreateParameterMap(
{ // Default parameters in alphabetic order:
DefaultTransformParameter({ "FinalBSplineInterpolationOrder", { "3" } }),
DefaultTransformParameter({ "FixedInternalImagePixelType", { "float" } }),
DefaultTransformParameter({ "HowToCombineTransforms", { "Compose" } }),
DefaultTransformParameter({ "InitialTransformParameterFileName", { "NoInitialTransform" } }),
DefaultTransformParameter({ "MovingInternalImagePixelType", { "float" } }),
DefaultTransformParameter({ "ResampleInterpolator", { "FinalBSplineInterpolator" } }),
DefaultTransformParameter({ "Resampler", { "DefaultResampler" } }),
DefaultTransformParameter({ "BSplineTransformSplineOrder", { "3" } }),
DefaultTransformParameter({ "UseCyclicTransform", { "false" } }),
DefaultTransformParameter({ "GridIndex", ParameterValuesType(ImageDimension, "0") }),
DefaultTransformParameter({ "GridSpacing", ParameterValuesType(ImageDimension, "1") }),
DefaultTransformParameter({ "GridOrigin", ParameterValuesType(ImageDimension, "0") }),
DefaultTransformParameter(
{ "GridDirection",
elx::Conversion::ToVectorOfStrings(itk::Matrix<int, ImageDimension, ImageDimension>::GetIdentity()) }),
// Non-default parameters in alphabetic order:
NonDefaultTransformParameter({ "GridSize", ParameterValuesType(2, std::to_string(gridValueSize)) }),
NonDefaultTransformParameter({ "NumberOfParameters", { std::to_string(bsplineTransformParameters.size()) } }),
NonDefaultTransformParameter({ "Transform", { "BSplineTransform" } }),
NonDefaultTransformParameter(
{ "TransformParameters", elx::Conversion::ToVectorOfStrings(bsplineTransformParameters) }) });
using ImageDomainType = ImageDomain<ImageDimension>;
// ITK's RecursiveSeparableImageFilter "requires a minimum of four pixels along the dimension to be processed", at
// https://github.com/InsightSoftwareConsortium/ITK/blob/v5.3.0/Modules/Filtering/ImageFilterBase/include/itkRecursiveSeparableImageFilter.hxx#L226
enum
{
smallImageSizeValue = 8
};
const ImageDomainType simpleImageDomain{
ImageDomainType::SizeType::Filled(smallImageSizeValue),
};
const auto createRandomImageDomain = [&randomNumberEngine] {
const auto createRandomDirection = [&randomNumberEngine] {
const auto randomRotation = std::uniform_real_distribution<>{ -M_PI / 8, M_PI / 8 }(randomNumberEngine);
const auto cosRandomRotation = std::cos(randomRotation);
const auto sinRandomRotation = std::sin(randomRotation);
const itk::SpacePrecisionType randomDirectionMatrix[][2] = { { cosRandomRotation, sinRandomRotation },
{ -sinRandomRotation, cosRandomRotation } };
return ImageDomainType::DirectionType{ randomDirectionMatrix };
};
const auto createRandomIndex = [&randomNumberEngine] {
ImageDomainType::IndexType randomIndex{};
std::generate(randomIndex.begin(), randomIndex.end(), [&randomNumberEngine] {
return std::uniform_int_distribution<itk::IndexValueType>{ -1, 2 }(randomNumberEngine);
});
return randomIndex;
};
const auto createRandomImageSize = [&randomNumberEngine] {
ImageDomainType::SizeType randomImageSize{};
std::generate(randomImageSize.begin(), randomImageSize.end(), [&randomNumberEngine] {
return std::uniform_int_distribution<itk::SizeValueType>{ smallImageSizeValue,
(3 * smallImageSizeValue) / 2 }(randomNumberEngine);
});
return randomImageSize;
};
const auto createRandomSpacing = [&randomNumberEngine] {
ImageDomainType::SpacingType randomSpacing{};
std::generate(randomSpacing.begin(), randomSpacing.end(), [&randomNumberEngine] {
return std::uniform_real_distribution<itk::SpacePrecisionType>{ 0.75, 1.5 }(randomNumberEngine);
});
return randomSpacing;
};
const auto createRandomPoint = [&randomNumberEngine] {
ImageDomainType::PointType randomPoint{};
std::generate(randomPoint.begin(), randomPoint.end(), [&randomNumberEngine] {
return std::uniform_real_distribution<itk::SpacePrecisionType>{ -2, 2 }(randomNumberEngine);
});
return randomPoint;
};
return ImageDomainType{ createRandomDirection(),
createRandomIndex(),
createRandomImageSize(),
createRandomSpacing(),
createRandomPoint() };
};
Expect_equal_output_SetInitialTransformParameterObject_and_Transformix_SetTransformParameterObject(
{ translationTransformParameterMap }, simpleImageDomain, simpleImageDomain);
Expect_equal_output_SetInitialTransformParameterObject_and_Transformix_SetTransformParameterObject(
{ translationTransformParameterMap }, createRandomImageDomain(), createRandomImageDomain());
Expect_equal_output_SetInitialTransformParameterObject_and_Transformix_SetTransformParameterObject(
{ translationTransformParameterMap, bsplineTransformParameterMap },
createRandomImageDomain(),
createRandomImageDomain());
Expect_equal_output_Transformix_SetTransformParameterObject_GetTransformParameterObject(
{ translationTransformParameterMap }, createRandomImageDomain(), createRandomImageDomain());
}
}
GTEST_TEST(itkElastixRegistrationMethod, InitialTransformParameterFileLinkToTransformFile)
{
using PixelType = float;
constexpr auto ImageDimension = 2U;
using ImageType = itk::Image<PixelType, ImageDimension>;
using SizeType = itk::Size<ImageDimension>;
using IndexType = itk::Index<ImageDimension>;
using OffsetType = itk::Offset<ImageDimension>;
using RegistrationMethodType = ElastixRegistrationMethodType<ImageType>;
const OffsetType initialTranslation{ { 1, -2 } };
const auto regionSize = SizeType::Filled(2);
const SizeType imageSize{ { 5, 6 } };
const IndexType fixedImageRegionIndex{ { 1, 3 } };
const auto fixedImage = CreateImage<PixelType>(imageSize);
FillImageRegion(*fixedImage, fixedImageRegionIndex, regionSize);
const auto movingImage = CreateImage<PixelType>(imageSize);
const auto createRegistration = [fixedImage](const std::string & initialTransformParameterFileName) {
const auto registration = CheckNew<RegistrationMethodType>();
registration->SetFixedImage(fixedImage);
registration->SetInitialTransformParameterFileName(GetDataDirectoryPath() + "/Translation(1,-2)/" +
initialTransformParameterFileName);
registration->SetParameterObject(CreateParameterObject({ // Parameters in alphabetic order:
{ "ImageSampler", "Full" },
{ "MaximumNumberOfIterations", "2" },
{ "Metric", "AdvancedNormalizedCorrelation" },
{ "Optimizer", "AdaptiveStochasticGradientDescent" },
{ "Transform", "TranslationTransform" } }));
return registration;
};
const auto registration1 = createRegistration("TransformParameters.txt");
for (const auto transformParameterFileName :
{ "TransformParameters-link-to-ITK-tfm-file.txt",
"TransformParameters-link-to-ITK-HDF5-file.txt",
"TransformParameters-link-to-file-with-special-chars-in-path-name.txt" })
{
const auto registration2 = createRegistration(transformParameterFileName);
for (const auto index :
itk::ImageRegionIndexRange<ImageDimension>(itk::ImageRegion<ImageDimension>({ 0, -2 }, { 2, 3 })))
{
movingImage->FillBuffer(0);
FillImageRegion(*movingImage, fixedImageRegionIndex + ConvertIndexToOffset(index), regionSize);
const auto updateAndRetrieveTransformParameterMap = [movingImage](RegistrationMethodType & registration) {
registration.SetMovingImage(movingImage);
registration.Update();
const elx::ParameterObject & transformParameterObject =
DerefRawPointer(registration.GetTransformParameterObject());
const auto & transformParameterMaps = transformParameterObject.GetParameterMaps();
EXPECT_EQ(transformParameterMaps.size(), 1);
return Front(transformParameterMaps);
};
const auto transformParameterMap1 = updateAndRetrieveTransformParameterMap(*registration1);
const auto transformParameterMap2 = updateAndRetrieveTransformParameterMap(*registration2);
ASSERT_EQ(transformParameterMap1.size(), transformParameterMap2.size());
for (const auto & transformParameter : transformParameterMap1)
{
const auto found = transformParameterMap2.find(transformParameter.first);
ASSERT_NE(found, transformParameterMap2.end());
if (transformParameter.first == "InitialTransformParameterFileName")
{
ASSERT_NE(*found, transformParameter);
}
else
{
ASSERT_EQ(*found, transformParameter);
}
}
}
}
}
GTEST_TEST(itkElastixRegistrationMethod, GetCombinationTransform)
{
constexpr auto ImageDimension = 2U;
using ImageType = itk::Image<float, ImageDimension>;
const auto image =
CreateImageFilledWithSequenceOfNaturalNumbers<ImageType::PixelType>(itk::Size<ImageDimension>{ 5, 6 });
elx::DefaultConstruct<ElastixRegistrationMethodType<ImageType>> registration{};
registration.SetFixedImage(image);
registration.SetMovingImage(image);
const std::string rootOutputDirectoryPath = GetCurrentBinaryDirectoryPath() + '/' + GetNameOfTest(*this);
itk::FileTools::CreateDirectory(rootOutputDirectoryPath);
for (const bool useInitialTransform : { false, true })
{
registration.SetInitialTransformParameterFileName(
useInitialTransform ? (GetDataDirectoryPath() + "/Translation(1,-2)/TransformParameters.txt") : "");
const std::string outputSubdirectoryPath =
rootOutputDirectoryPath + "/" + (useInitialTransform ? "InitialTranslation(1,-2)" : "NoInitialTransform");
itk::FileTools::CreateDirectory(outputSubdirectoryPath);
using PairType = std::pair<const char *, itk::Transform<double, ImageDimension, ImageDimension>::Pointer>;
for (const auto [transformName, itkTransform] :
{ PairType{ "AffineTransform", itk::AffineTransform<double, ImageDimension>::New() },
PairType{ "BSplineTransform", itk::BSplineTransform<double, ImageDimension>::New() },
PairType{ "EulerTransform", itk::Euler2DTransform<>::New() },
PairType{ "RecursiveBSplineTransform", itk::BSplineTransform<double, ImageDimension>::New() },
PairType{ "SimilarityTransform", itk::Similarity2DTransform<>::New() },
PairType{ "TranslationTransform", itk::TranslationTransform<double, ImageDimension>::New() } })
{
const auto & expectedItkTransform = *itkTransform;
const auto expectedNumberOfFixedParameters = expectedItkTransform.GetFixedParameters().size();
registration.SetParameterObject(CreateParameterObject({ // Parameters in alphabetic order:
{ "AutomaticTransformInitialization", "false" },
{ "ImageSampler", "Full" },
{ "MaximumNumberOfIterations", "0" },
{ "Metric", "AdvancedNormalizedCorrelation" },
{ "Optimizer", "AdaptiveStochasticGradientDescent" },
{ "Transform", transformName } }));
registration.Update();
using CompositeTransformType = itk::CompositeTransform<double, ImageDimension>;
const auto combinationTransform = registration.GetCombinationTransform();
EXPECT_NE(combinationTransform, nullptr);
}
}
}
GTEST_TEST(itkElastixRegistrationMethod, GetNumberOfTransforms)
{
constexpr auto ImageDimension = 2U;
using ImageType = itk::Image<float, ImageDimension>;
const auto image =
CreateImageFilledWithSequenceOfNaturalNumbers<ImageType::PixelType>(itk::Size<ImageDimension>{ 5, 6 });
elx::DefaultConstruct<ElastixRegistrationMethodType<ImageType>> registration{};
registration.SetFixedImage(image);
registration.SetMovingImage(image);
for (const bool useInitialTransform : { false, true })
{
registration.SetInitialTransformParameterFileName(
useInitialTransform ? (GetDataDirectoryPath() + "/Translation(1,-2)/TransformParameters.txt") : "");
registration.SetParameterObject(CreateParameterObject({ // Parameters in alphabetic order:
{ "AutomaticTransformInitialization", "false" },
{ "ImageSampler", "Full" },
{ "MaximumNumberOfIterations", "0" },
{ "Metric", "AdvancedNormalizedCorrelation" },
{ "Optimizer", "AdaptiveStochasticGradientDescent" },
{ "Transform", "BSplineTransform" } }));
registration.Update();
EXPECT_EQ(registration.GetNumberOfTransforms(), useInitialTransform ? 2 : 1);
}
}
GTEST_TEST(itkElastixRegistrationMethod, GetNthTransform)
{
constexpr auto ImageDimension = 2U;
using ImageType = itk::Image<float, ImageDimension>;
const auto image =
CreateImageFilledWithSequenceOfNaturalNumbers<ImageType::PixelType>(itk::Size<ImageDimension>{ 5, 6 });
elx::DefaultConstruct<ElastixRegistrationMethodType<ImageType>> registration{};
registration.SetFixedImage(image);
registration.SetMovingImage(image);
for (const bool useInitialTransform : { false, true })
{
registration.SetInitialTransformParameterFileName(
useInitialTransform ? (GetDataDirectoryPath() + "/Translation(1,-2)/TransformParameters.txt") : "");
const std::string nameOfLastTransform = "BSplineTransform";
registration.SetParameterObject(CreateParameterObject({ // Parameters in alphabetic order:
{ "AutomaticTransformInitialization", "false" },
{ "ImageSampler", "Full" },
{ "MaximumNumberOfIterations", "0" },
{ "Metric", "AdvancedNormalizedCorrelation" },
{ "Optimizer", "AdaptiveStochasticGradientDescent" },
{ "Transform", nameOfLastTransform } }));
registration.Update();
const unsigned int numberOfTransforms{ useInitialTransform ? 2U : 1U };
for (unsigned int n{ 0 }; n < numberOfTransforms; ++n)
{
EXPECT_NE(registration.GetNthTransform(n), nullptr);
}
}
}
GTEST_TEST(itkElastixRegistrationMethod, ConvertToItkTransform)
{
constexpr auto ImageDimension = 2U;
using ImageType = itk::Image<float, ImageDimension>;
const auto image =
CreateImageFilledWithSequenceOfNaturalNumbers<ImageType::PixelType>(itk::Size<ImageDimension>{ 5, 6 });
elx::DefaultConstruct<ElastixRegistrationMethodType<ImageType>> registration{};
registration.SetFixedImage(image);
registration.SetMovingImage(image);
for (const bool useInitialTransform : { false, true })
{
registration.SetInitialTransformParameterFileName(
useInitialTransform ? (GetDataDirectoryPath() + "/Translation(1,-2)/TransformParameters.txt") : "");
const std::string nameOfLastTransform = "BSplineTransform";
registration.SetParameterObject(CreateParameterObject({ // Parameters in alphabetic order:
{ "AutomaticTransformInitialization", "false" },
{ "ImageSampler", "Full" },
{ "MaximumNumberOfIterations", "0" },
{ "Metric", "AdvancedNormalizedCorrelation" },
{ "Optimizer", "AdaptiveStochasticGradientDescent" },
{ "Transform", nameOfLastTransform } }));
registration.Update();
const unsigned int numberOfTransforms{ useInitialTransform ? 2U : 1U };
for (unsigned int n{ 0 }; n < numberOfTransforms; ++n)
{
// TODO Check result
const auto result =
ElastixRegistrationMethodType<ImageType>::ConvertToItkTransform(*registration.GetNthTransform(n));
ASSERT_NE(result, nullptr);
EXPECT_EQ(result->GetReferenceCount(), 1);
}
}
}
GTEST_TEST(itkElastixRegistrationMethod, WriteCompositeTransform)
{
constexpr auto ImageDimension = 2U;
using ImageType = itk::Image<float, ImageDimension>;
const auto image =
CreateImageFilledWithSequenceOfNaturalNumbers<ImageType::PixelType>(itk::Size<ImageDimension>{ 5, 6 });
elx::DefaultConstruct<ElastixRegistrationMethodType<ImageType>> registration{};
registration.SetFixedImage(image);
registration.SetMovingImage(image);
const std::string rootOutputDirectoryPath = GetCurrentBinaryDirectoryPath() + '/' + GetNameOfTest(*this);
itk::FileTools::CreateDirectory(rootOutputDirectoryPath);
for (const bool useInitialTransform : { false, true })
{
registration.SetInitialTransformParameterFileName(
useInitialTransform ? (GetDataDirectoryPath() + "/Translation(1,-2)/TransformParameters.txt") : "");
const std::string outputSubdirectoryPath =
rootOutputDirectoryPath + "/" + (useInitialTransform ? "InitialTranslation(1,-2)" : "NoInitialTransform");
itk::FileTools::CreateDirectory(outputSubdirectoryPath);
using PairType = std::pair<const char *, itk::Transform<double, ImageDimension, ImageDimension>::Pointer>;
for (const auto [transformName, itkTransform] :
{ PairType{ "AffineTransform", itk::AffineTransform<double, ImageDimension>::New() },
PairType{ "BSplineTransform", itk::BSplineTransform<double, ImageDimension>::New() },
PairType{ "EulerTransform", itk::Euler2DTransform<>::New() },
PairType{ "RecursiveBSplineTransform", itk::BSplineTransform<double, ImageDimension>::New() },
PairType{ "SimilarityTransform", itk::Similarity2DTransform<>::New() },
PairType{ "TranslationTransform", itk::TranslationTransform<double, ImageDimension>::New() } })
{
for (const std::string fileNameExtension : { "", "h5", "tfm" })
{
const std::string outputDirectoryPath = outputSubdirectoryPath + "/" + transformName + fileNameExtension;
itk::FileTools::CreateDirectory(outputDirectoryPath);
registration.SetOutputDirectory(outputDirectoryPath);
registration.SetParameterObject(
CreateParameterObject({ // Parameters in alphabetic order:
{ "AutomaticTransformInitialization", "false" },
{ "ImageSampler", "Full" },
{ "ITKTransformOutputFileNameExtension", fileNameExtension },
{ "MaximumNumberOfIterations", "0" },
{ "Metric", "AdvancedNormalizedCorrelation" },
{ "Optimizer", "AdaptiveStochasticGradientDescent" },
{ "Transform", transformName },
{ "WriteITKCompositeTransform", "true" } }));
registration.Update();
if (!fileNameExtension.empty())
{
const auto & expectedItkTransform = *itkTransform;
const auto expectedNumberOfFixedParameters = expectedItkTransform.GetFixedParameters().size();
const itk::TransformBase::ConstPointer singleTransform =
elx::TransformIO::Read(outputDirectoryPath + "/TransformParameters.0." + fileNameExtension);
using CompositeTransformType = itk::CompositeTransform<double, ImageDimension>;
const itk::TransformBase::Pointer compositeTransform =
elx::TransformIO::Read(outputDirectoryPath + "/TransformParameters.0-Composite." + fileNameExtension);
const auto & transformQueue =
DerefRawPointer(dynamic_cast<const CompositeTransformType *>(compositeTransform.GetPointer()))
.GetTransformQueue();
ASSERT_EQ(transformQueue.size(), useInitialTransform ? 2 : 1);
const itk::TransformBase * const frontTransform = transformQueue.front();
for (const auto actualTransformPtr : { singleTransform.GetPointer(), frontTransform })
{
const itk::TransformBase & actualTransform = DerefRawPointer(actualTransformPtr);
EXPECT_EQ(typeid(actualTransform), typeid(expectedItkTransform));
EXPECT_EQ(actualTransform.GetParameters(), expectedItkTransform.GetParameters());
// Note that the actual values of the FixedParameters may not be exactly like the expected
// default-constructed transform.
EXPECT_EQ(actualTransform.GetFixedParameters().size(), expectedNumberOfFixedParameters);
}
EXPECT_EQ(singleTransform->GetFixedParameters(), frontTransform->GetFixedParameters());
if (useInitialTransform)
{
// Expect that the back of the transformQueue has a translation according to the
// InitialTransformParameterFileName.
const auto & backTransform = DerefSmartPointer(transformQueue.back());
const auto & translationTransform =
DerefRawPointer(dynamic_cast<const itk::TranslationTransform<double, ImageDimension> *>(&backTransform));
EXPECT_EQ(translationTransform.GetOffset(), itk::MakeVector(1.0, -2.0));
}
}
}
}
}
}
GTEST_TEST(itkElastixRegistrationMethod, WriteBSplineTransformToItkFileFormat)
{
const std::string rootOutputDirectoryPath = GetCurrentBinaryDirectoryPath() + '/' + GetNameOfTest(*this);
itk::FileTools::CreateDirectory(rootOutputDirectoryPath);
Test_WriteBSplineTransformToItkFileFormat<2, 1>(rootOutputDirectoryPath);
Test_WriteBSplineTransformToItkFileFormat<2, 2>(rootOutputDirectoryPath);
Test_WriteBSplineTransformToItkFileFormat<2, 3>(rootOutputDirectoryPath);
Test_WriteBSplineTransformToItkFileFormat<3, 1>(rootOutputDirectoryPath);
Test_WriteBSplineTransformToItkFileFormat<3, 2>(rootOutputDirectoryPath);
Test_WriteBSplineTransformToItkFileFormat<3, 3>(rootOutputDirectoryPath);
}
// Tests registering two small (8x8) binary images, which are translated with respect to each other.
GTEST_TEST(itkElastixRegistrationMethod, EulerTranslation2D)
{
using PixelType = float;
constexpr auto ImageDimension = 2U;
using ImageType = itk::Image<PixelType, ImageDimension>;
using SizeType = itk::Size<ImageDimension>;
using IndexType = itk::Index<ImageDimension>;
using OffsetType = itk::Offset<ImageDimension>;
const auto imageSizeValue = 8;
const auto imageSize = SizeType::Filled(imageSizeValue);
const auto fixedImageRegionIndex = IndexType::Filled(imageSizeValue / 2 - 1);
const auto setPixelsOfSquareRegion = [](ImageType & image, const IndexType & regionIndex) {
// Set a different value to each of the pixels of a little square region, to ensure that no rotation is assumed.
const itk::ImageRegionRange<ImageType> imageRegionRange{ image, { regionIndex, SizeType::Filled(2) } };
std::iota(std::begin(imageRegionRange), std::end(imageRegionRange), 1);
};
const auto fixedImage = CreateImage<PixelType>(imageSize);
setPixelsOfSquareRegion(*fixedImage, fixedImageRegionIndex);
elx::DefaultConstruct<ElastixRegistrationMethodType<ImageType>> registration{};
registration.SetFixedImage(fixedImage);
registration.SetParameterObject(CreateParameterObject({ // Parameters in alphabetic order:
{ "AutomaticTransformInitialization", "false" },
{ "ImageSampler", "Full" },
{ "MaximumNumberOfIterations", "2" },
{ "Metric", "AdvancedNormalizedCorrelation" },
{ "Optimizer", "AdaptiveStochasticGradientDescent" },
{ "Transform", "EulerTransform" } }));
const auto movingImage = CreateImage<PixelType>(imageSize);
// Test translation for each direction from (-1, -1) to (1, 1).
for (const auto & index : itk::ZeroBasedIndexRange<ImageDimension>(SizeType::Filled(3)))
{
movingImage->FillBuffer(0);
const OffsetType translation = index - IndexType::Filled(1);
setPixelsOfSquareRegion(*movingImage, fixedImageRegionIndex + translation);
registration.SetMovingImage(movingImage);
registration.Update();
const auto transformParameters = GetTransformParametersFromFilter(registration);
ASSERT_EQ(transformParameters.size(), 3);
// The detected rotation angle is expected to be close to zero.
// (Absolute angle values of up to 3.77027e-06 were encountered, which seems acceptable.)
const auto rotationAngle = transformParameters[0];
EXPECT_LT(std::abs(rotationAngle), 1e-5);
for (unsigned i{}; i <= 1; ++i)
{
EXPECT_EQ(std::round(transformParameters[i + 1]), translation[i]);
}
}
}
// Tests registering two images which are rotated with respect to each other.
GTEST_TEST(itkElastixRegistrationMethod, EulerDiscRotation2D)
{
using PixelType = float;
enum
{
ImageDimension = 2,
imageSizeValue = 128
};
using ImageType = itk::Image<PixelType, ImageDimension>;
using SizeType = itk::Size<ImageDimension>;
using RegionType = ImageType::RegionType;
const auto imageSize = SizeType::Filled(imageSizeValue);
const auto setPixelsOfDisc = [imageSize](ImageType & image, const double rotationAngle) {
for (const auto & index : itk::ZeroBasedIndexRange<ImageDimension>{ imageSize })
{
std::array<double, ImageDimension> offset;
for (int i{}; i < ImageDimension; ++i)
{
offset[i] = index[i] - ((imageSizeValue - 1) / 2.0);
}
constexpr auto radius = (imageSizeValue / 2.0) - 2.0;
if (std::inner_product(offset.begin(), offset.end(), offset.begin(), 0.0) < (radius * radius))
{
const auto directionAngle = std::atan2(offset[1], offset[0]);
// Estimate the turn (between 0 and 1), rotated according to the specified rotation angle.
const auto rotatedDirectionTurn =
std::fmod(std::fmod((directionAngle + rotationAngle) / (2.0 * M_PI), 1.0) + 1.0, 1.0);
// Multiplication by 64 may be useful for integer pixel types.
image.SetPixel(index, static_cast<PixelType>(64.0 * rotatedDirectionTurn));
}
}
};
const auto fixedImage = CreateImage<PixelType>(imageSize);
setPixelsOfDisc(*fixedImage, 0.0);
const auto movingImage = CreateImage<PixelType>(imageSize);
elx::DefaultConstruct<ElastixRegistrationMethodType<ImageType>> registration{};
registration.SetFixedImage(fixedImage);
registration.SetParameterObject(CreateParameterObject({ // Parameters in alphabetic order:
{ "AutomaticTransformInitialization", "false" },
{ "AutomaticScalesEstimation", "true" },
{ "ImageSampler", "Full" },
{ "MaximumNumberOfIterations", "16" },
{ "Metric", "AdvancedNormalizedCorrelation" },
{ "Optimizer", "RegularStepGradientDescent" },
{ "Transform", "EulerTransform" },
{ "WriteResultImage", "false" } }));
for (const auto degree : { -2, 0, 1, 30 })
{
constexpr auto radiansPerDegree = M_PI / 180.0;
setPixelsOfDisc(*movingImage, degree * radiansPerDegree);
registration.SetMovingImage(movingImage);
registration.Update();
const auto transformParameters = GetTransformParametersFromFilter(registration);
ASSERT_EQ(transformParameters.size(), 3);
EXPECT_EQ(std::round(transformParameters[0] / radiansPerDegree), -degree); // rotation angle
EXPECT_EQ(std::round(transformParameters[1]), 0.0); // translation X
EXPECT_EQ(std::round(transformParameters[2]), 0.0); // translation Y
}
}
// Checks a minimum size moving image having the same pixel type as any of the supported internal pixel types.
GTEST_TEST(itkElastixRegistrationMethod, CheckMinimumMovingImageHavingInternalPixelType)
{
elx::ForEachSupportedImageType([](const auto elxTypedef) {
using ElxTypedef = decltype(elxTypedef);
using ImageType = typename ElxTypedef::MovingImageType;
constexpr auto ImageDimension = ElxTypedef::MovingDimension;
using PixelType = typename ImageType::PixelType;
const auto imageSize = itk::Size<ElxTypedef::MovingDimension>::Filled(minimumImageSizeValue);
const ImageDomain<ElxTypedef::MovingDimension> imageDomain(imageSize);
elx::DefaultConstruct<ImageType> fixedImage{};
imageDomain.ToImage(fixedImage);
fixedImage.Allocate(true);
elx::DefaultConstruct<ImageType> movingImage{};
imageDomain.ToImage(movingImage);
movingImage.Allocate(true);
// Some "extreme" values to test if each of them is preserved during the transformation.
const std::array pixelValues{ PixelType{},
PixelType{ 1 },
std::numeric_limits<PixelType>::lowest(),
std::numeric_limits<PixelType>::min(),
PixelType{ std::numeric_limits<PixelType>::max() - 1 },
std::numeric_limits<PixelType>::max() };
std::copy(pixelValues.cbegin(), pixelValues.cend(), itk::ImageBufferRange<ImageType>(movingImage).begin());
// A dummy registration (that does not do any optimization).
elx::DefaultConstruct<itk::ElastixRegistrationMethod<ImageType, ImageType>> registration{};
registration.SetParameterObject(
CreateParameterObject({ // Parameters in alphabetic order:
{ "AutomaticParameterEstimation", { "false" } },
{ "FixedInternalImagePixelType", { ElxTypedef::FixedPixelTypeString } },
{ "MovingInternalImagePixelType", { ElxTypedef::MovingPixelTypeString } },
{ "ImageSampler", "Full" },
{ "MaximumNumberOfIterations", "0" },
{ "Metric", "AdvancedNormalizedCorrelation" },
{ "Optimizer", { "AdaptiveStochasticGradientDescent" } },
{ "ResampleInterpolator", { "FinalLinearInterpolator" } },
{ "Transform", "TranslationTransform" } }));
registration.SetFixedImage(&fixedImage);
registration.SetMovingImage(&movingImage);
registration.Update();
EXPECT_EQ(DerefRawPointer(registration.GetOutput()), movingImage);
});
}
// Checks a zero-filled moving image with a random domain, having the same pixel type as any of the supported internal
// pixel types.
GTEST_TEST(itkElastixRegistrationMethod, CheckZeroFilledMovingImageWithRandomDomainHavingInternalPixelType)
{
std::mt19937 randomNumberEngine{};
elx::ForEachSupportedImageType([&randomNumberEngine](const auto elxTypedef) {
using ElxTypedef = decltype(elxTypedef);
using ImageType = typename ElxTypedef::MovingImageType;
constexpr auto ImageDimension = ElxTypedef::MovingDimension;
using PixelType = typename ImageType::PixelType;
auto imageDomain = CreateRandomImageDomain<ElxTypedef::MovingDimension>(randomNumberEngine);
// Reset index to avoid "FixedImageRegion does not overlap the fixed image buffered region" exceptions from
// itk::ImageToImageMetric::Initialize()
imageDomain.index = {};
// Create an image with values 1, 2, 3, ... N. We could have used arbitrary pixel values instead.
const auto fixedImage = CreateImageFilledWithSequenceOfNaturalNumbers<PixelType>(imageDomain);
elx::DefaultConstruct<ImageType> movingImage{};
imageDomain.ToImage(movingImage);
movingImage.Allocate(true);
// A dummy registration (that does not do any optimization).
elx::DefaultConstruct<itk::ElastixRegistrationMethod<ImageType, ImageType>> registration{};
registration.SetParameterObject(
CreateParameterObject({ // Parameters in alphabetic order:
{ "AutomaticParameterEstimation", { "false" } },
{ "FixedInternalImagePixelType", { ElxTypedef::FixedPixelTypeString } },
{ "MovingInternalImagePixelType", { ElxTypedef::MovingPixelTypeString } },
{ "ImageSampler", "Full" },
{ "MaximumNumberOfIterations", "0" },
{ "Metric", "AdvancedNormalizedCorrelation" },
{ "Optimizer", { "AdaptiveStochasticGradientDescent" } },
{ "ResampleInterpolator", { "FinalLinearInterpolator" } },
{ "Transform", "TranslationTransform" } }));
registration.SetFixedImage(fixedImage);
registration.SetMovingImage(&movingImage);
registration.Update();
EXPECT_EQ(DerefRawPointer(registration.GetOutput()), movingImage);
});
}
// Checks a minimum size moving image using any supported internal pixel type (which may be different from the input
// pixel type).
GTEST_TEST(itkElastixRegistrationMethod, CheckMinimumMovingImageUsingAnyInternalPixelType)
{
const auto check = [](const auto inputPixelTypeHolder) {
elx::ForEachSupportedImageType([](const auto elxTypedef) {
using ElxTypedef = decltype(elxTypedef);
using InputPixelType = typename decltype(inputPixelTypeHolder)::Type;
using InputImageType = itk::Image<InputPixelType, ElxTypedef::MovingDimension>;
const ImageDomain<ElxTypedef::MovingDimension> imageDomain(
itk::Size<ElxTypedef::MovingDimension>::Filled(minimumImageSizeValue));
elx::DefaultConstruct<InputImageType> fixedImage{};
imageDomain.ToImage(fixedImage);
fixedImage.Allocate(true);
const auto movingImage = CreateImageFilledWithSequenceOfNaturalNumbers<InputPixelType>(imageDomain);
// A dummy registration (that does not do any optimization).
elx::DefaultConstruct<itk::ElastixRegistrationMethod<InputImageType, InputImageType>> registration{};
registration.SetParameterObject(
CreateParameterObject({ // Parameters in alphabetic order:
{ "AutomaticParameterEstimation", { "false" } },
{ "FixedInternalImagePixelType", { ElxTypedef::FixedPixelTypeString } },
{ "MovingInternalImagePixelType", { ElxTypedef::MovingPixelTypeString } },
{ "ImageSampler", "Full" },
{ "MaximumNumberOfIterations", "0" },
{ "Metric", "AdvancedNormalizedCorrelation" },
{ "Optimizer", { "AdaptiveStochasticGradientDescent" } },
{ "ResampleInterpolator", { "FinalLinearInterpolator" } },
{ "Transform", "TranslationTransform" } }));
registration.SetFixedImage(&fixedImage);
registration.SetMovingImage(movingImage);
registration.Update();
EXPECT_EQ(DerefRawPointer(registration.GetOutput()), DerefSmartPointer(movingImage));
});
};
check(TypeHolder<char>{});
check(TypeHolder<short>{});
check(TypeHolder<float>{});
check(TypeHolder<double>{});
}
// Checks a zero-filled moving image with a random domain, using any supported internal pixel type (which may be
// different from the input pixel type).
GTEST_TEST(itkElastixRegistrationMethod, CheckZeroFilledMovingImageWithRandomDomainUsingAnyInternalPixelType)
{
std::mt19937 randomNumberEngine{};
const auto check = [&randomNumberEngine](const auto inputPixelTypeHolder) {
elx::ForEachSupportedImageType([&randomNumberEngine](const auto elxTypedef) {
using ElxTypedef = decltype(elxTypedef);
using InputPixelType = typename decltype(inputPixelTypeHolder)::Type;
using InputImageType = itk::Image<InputPixelType, ElxTypedef::MovingDimension>;
auto imageDomain = CreateRandomImageDomain<ElxTypedef::MovingDimension>(randomNumberEngine);
// Reset index to avoid "FixedImageRegion does not overlap the fixed image buffered region" exceptions from
// itk::ImageToImageMetric::Initialize()
imageDomain.index = {};
// Create an image with values 1, 2, 3, ... N. We could have used arbitrary pixel values instead.
const auto fixedImage = CreateImageFilledWithSequenceOfNaturalNumbers<InputPixelType>(imageDomain);
elx::DefaultConstruct<InputImageType> movingImage{};
imageDomain.ToImage(movingImage);
movingImage.Allocate(true);
// A dummy registration (that does not do any optimization).
elx::DefaultConstruct<itk::ElastixRegistrationMethod<InputImageType, InputImageType>> registration{};
registration.SetParameterObject(
CreateParameterObject({ // Parameters in alphabetic order:
{ "AutomaticParameterEstimation", { "false" } },
{ "FixedInternalImagePixelType", { ElxTypedef::FixedPixelTypeString } },
{ "MovingInternalImagePixelType", { ElxTypedef::MovingPixelTypeString } },
{ "ImageSampler", "Full" },
{ "MaximumNumberOfIterations", "0" },
{ "Metric", "AdvancedNormalizedCorrelation" },
{ "Optimizer", { "AdaptiveStochasticGradientDescent" } },
{ "ResampleInterpolator", { "FinalLinearInterpolator" } },
{ "Transform", "TranslationTransform" } }));
registration.SetFixedImage(fixedImage);
registration.SetMovingImage(&movingImage);
registration.Update();
EXPECT_EQ(DerefRawPointer(registration.GetOutput()), movingImage);
});
};
check(TypeHolder<char>{});
check(TypeHolder<short>{});
check(TypeHolder<float>{});
check(TypeHolder<double>{});
}
// Checks that InitialTransform and ExternalInitialTransform are mutually exclusive.
GTEST_TEST(itkElastixRegistrationMethod, SetAndGetInitialTransform)
{
constexpr auto ImageDimension = 2U;
using ImageType = itk::Image<float, ImageDimension>;
elx::DefaultConstruct<itk::DisplacementFieldTransform<double, ImageDimension>> displacementFieldTransform{};
const elx::DefaultConstruct<itk::TranslationTransform<double, ImageDimension>> translationTransform{};
elx::DefaultConstruct<ElastixRegistrationMethodType<ImageType>> registration{};
EXPECT_EQ(registration.GetInitialTransform(), nullptr);
EXPECT_EQ(registration.GetExternalInitialTransform(), nullptr);
registration.SetInitialTransform(&translationTransform);
EXPECT_EQ(registration.GetInitialTransform(), &translationTransform);
EXPECT_EQ(registration.GetExternalInitialTransform(), nullptr);
registration.SetExternalInitialTransform(&displacementFieldTransform);
EXPECT_EQ(registration.GetInitialTransform(), nullptr);
EXPECT_EQ(registration.GetExternalInitialTransform(), &displacementFieldTransform);
registration.SetInitialTransform(nullptr);
EXPECT_EQ(registration.GetInitialTransform(), nullptr);
EXPECT_EQ(registration.GetExternalInitialTransform(), nullptr);
registration.SetExternalInitialTransform(nullptr);
EXPECT_EQ(registration.GetInitialTransform(), nullptr);
EXPECT_EQ(registration.GetExternalInitialTransform(), nullptr);
}
| [
"N.Dekker@lumc.nl"
] | N.Dekker@lumc.nl |
255616d4e1ce54555dfb4d772591bcb849946d56 | fd67b98f57273d307a71030ab67a37045b9ed7de | /Codechef/DYNAMO - Chef and Dynamo.cpp | 015132bcd56e1d17e053dd68b3567bded227a358 | [] | no_license | ngandhi369/Competitive_Programming | 5c16012b0074b2c36648bdcdc544c71d4699b93f | abb39c8903e49da2e7415501c3b011e21dc73c2f | refs/heads/master | 2023-01-02T06:38:43.848913 | 2020-10-28T18:21:58 | 2020-10-28T18:21:58 | 286,952,040 | 0 | 0 | null | 2020-09-18T09:39:01 | 2020-08-12T07:53:28 | C++ | UTF-8 | C++ | false | false | 586 | cpp | #include<iostream>
#include<cstdio>
#include<cmath>
using namespace std;
int main()
{
int t,n,k;
long long int a,b,c,d,e,s;
cin>>t;
for(int i=0;i<t;i++)
{
cin>>n>>a;
s=a+2*(unsigned long long)pow(10,n);
cout<<s<<endl;
fflush(stdout);
cin>>b;
c=(unsigned long long)pow(10,n)-b;
cout<<c<<endl;
fflush(stdout);
cin>>d;
e=s-a-b-c-d;
cout<<e<<endl;
fflush(stdout);
cin>>k;
if(k==-1)
break;
else
continue;
}
return 0;
}
| [
"gandhinirdosh@gmail.com"
] | gandhinirdosh@gmail.com |
a1ec38183d094e6307d879aec3025db961e66681 | d939fb99344c9d660f7445c7b2a82cd62685e876 | /qubic/src/QcGenerator/main.cpp | 812c9febf2c5a509d7a0224d2daa0dc0de4962fc | [] | no_license | floreks/Qubic | d2236b90dac1b8925c39153b34068a69cd142b47 | d0f8057b9c0bd8a2eefd1f8163c66e4b88174fd4 | refs/heads/master | 2020-04-13T07:25:59.541236 | 2014-09-24T20:18:39 | 2014-09-24T20:18:39 | 6,854,093 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 667 | cpp | #include "qcgenerator.h"
#include <QApplication>
#include <QTranslator>
#include "qclogger.h"
#include "properties/qcstaticproperties.h"
int main(int argc, char *argv[])
{
// ------------------ Initial configuration ------------------ //
QApplication a(argc, argv);
QString locale = QLocale::system().name();
QTranslator translator;
qInstallMessageHandler(0);
translator.load(QString("qubic_") + locale, QC_TRANSLATIONS_DIR);
a.installTranslator(&translator);
// ------------------- Logger setup ------------------- //
QcLogger::setLoggingLevel(QsLogging::InfoLevel);
QcGenerator w;
w.show();
return a.exec();
}
| [
"iszopl12@gmail.com"
] | iszopl12@gmail.com |
81344f666b973f02fe569f04d700a69ab3604a4c | 0a6afc4316f3c2e673af3019eedc5729e8875b90 | /src/pbrt/util/noise.h | 1b627b19c73887e9d66bbf158caeed56226749a8 | [
"Apache-2.0"
] | permissive | anderslanglands/pbrt-v4 | 8726f63e601f64434500ac168c7c7442167ff699 | 70fc776fd84718eb5bb98b2963b7ab5caab4b1f6 | refs/heads/master | 2022-12-23T06:37:12.577080 | 2020-09-20T03:18:09 | 2020-09-20T03:18:09 | 296,988,401 | 2 | 0 | Apache-2.0 | 2020-09-20T02:36:41 | 2020-09-20T02:36:40 | null | UTF-8 | C++ | false | false | 690 | h | // pbrt is Copyright(c) 1998-2020 Matt Pharr, Wenzel Jakob, and Greg Humphreys.
// The pbrt source code is licensed under the Apache License, Version 2.0.
// SPDX: Apache-2.0
#ifndef PBRT_UTIL_NOISE_H
#define PBRT_UTIL_NOISE_H
#include <pbrt/pbrt.h>
namespace pbrt {
PBRT_CPU_GPU
Float Noise(Float x, Float y = .5f, Float z = .5f);
PBRT_CPU_GPU
Float Noise(const Point3f &p);
PBRT_CPU_GPU
Float FBm(const Point3f &p, const Vector3f &dpdx, const Vector3f &dpdy, Float omega,
int octaves);
PBRT_CPU_GPU
Float Turbulence(const Point3f &p, const Vector3f &dpdx, const Vector3f &dpdy,
Float omega, int octaves);
} // namespace pbrt
#endif // PBRT_UTIL_NOISE_H
| [
"matt@pharr.org"
] | matt@pharr.org |
48e4b585cbb9945dd03e034266a284e40499eaa5 | f975b58d8afae4588f4808c77c6207a4372d68fb | /SlidingTilePuzzleNode.cpp | 89faf805ea705f94644ca54360f83fbb1867006f | [] | no_license | coderodde/libidpp | 533dacf03a3c3f281e163193100154c2ef3ac076 | 3fd18056149461080a83c0a6ec012fb423ee037a | refs/heads/master | 2020-04-18T12:26:20.801270 | 2019-02-09T09:14:46 | 2019-02-09T09:14:46 | 167,533,234 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 6,017 | cpp | #include "SlidingTilePuzzleNode.hpp"
#include <algorithm>
#include <cmath>
#include <iomanip>
#include <ios>
#include <iostream>
#include <ostream>
#include <string>
void SlidingTilePuzzleNode::checkOnSlideUp() const
{
if (m_zero_tile_y == 0) {
ZeroTileOutsideException exception(std::string("'m_zero_tile_y == 0' upon slideUp"));
throw exception;
}
}
void SlidingTilePuzzleNode::checkOnSlideDown() const
{
if (m_zero_tile_y == m_height - 1) {
ZeroTileOutsideException exception(std::string("'m_zero_tile_y == m_height - 1' upon slideDown"));
throw exception;
}
}
void SlidingTilePuzzleNode::checkOnSlideLeft() const
{
if (m_zero_tile_x == 0) {
ZeroTileOutsideException exception(
std::string("'m_zero_tile_x == 0' upon slideLeft"));
throw exception;
}
}
void SlidingTilePuzzleNode::checkOnSlideRight() const
{
if (m_zero_tile_x == m_width - 1) {
ZeroTileOutsideException exception(
std::string("'m_zero_tile_x == m_width - 1' upon slideRight"));
throw exception;
}
}
// Initial constructor building the solved slide puzzle:
SlidingTilePuzzleNode::SlidingTilePuzzleNode(std::size_t width,
std::size_t height)
:
m_width(width),
m_height(height),
m_zero_tile_x(width - 1),
m_zero_tile_y(height - 1)
{
// Copy the state:
m_state.resize(m_width * m_height);
std::size_t n;
std::generate(m_state.begin(), m_state.end(), [n = 1]() mutable {
return n++;
});
// Deal with the empty tile:
m_state[width * height - 1] = 0;
// Build the row index:
for (std::size_t y = 0; y < m_height; y++) {
SlidingTilePuzzleNodeRowSelector row_selector(this, y * width);
m_row_map[y] = row_selector;
}
}
// Copy constructor.
SlidingTilePuzzleNode::SlidingTilePuzzleNode(const SlidingTilePuzzleNode& other)
{
// Copy the easy stuff.
this->m_height = other.m_height;
this->m_width = other.m_width;
this->m_zero_tile_x = other.m_zero_tile_x;
this->m_zero_tile_y = other.m_zero_tile_y;
this->m_state = other.m_state;
std::size_t y = 0;
for (auto const& entry : other.m_row_map) {
SlidingTilePuzzleNodeRowSelector row_selector(this, y);
this->m_row_map[entry.first] = row_selector;
y += m_width;
}
}
// Copy assignment.
SlidingTilePuzzleNode& SlidingTilePuzzleNode::operator=(const SlidingTilePuzzleNode& other)
{
this->m_height = other.m_height;
this->m_width = other.m_width;
this->m_zero_tile_x = other.m_zero_tile_x;
this->m_zero_tile_y = other.m_zero_tile_y;
this->m_state = other.m_state;
this->m_row_map = other.m_row_map;
// Correct the map values to row selectors of this tile:
for (auto& entry : m_row_map) {
SlidingTilePuzzleNodeRowSelector row_selector(this, entry.first);
entry.second = row_selector;
}
return *this;
}
// Move assignment.
SlidingTilePuzzleNode& SlidingTilePuzzleNode::operator=(SlidingTilePuzzleNode&& other)
{
m_height = other.m_height;
m_width = other.m_width;
m_zero_tile_x = other.m_zero_tile_x;
m_zero_tile_y = other.m_zero_tile_y;
m_state = std::move(other.m_state);
m_row_map = std::move(other.m_row_map);
std::size_t y = 0;
for (auto& entry : m_row_map) {
SlidingTilePuzzleNodeRowSelector row_selector(this, y);
entry.second = row_selector;
y += m_width;
}
return *this;
}
SlidingTilePuzzleNode::~SlidingTilePuzzleNode() = default;
SlidingTilePuzzleNode SlidingTilePuzzleNode::slideUp()
{
checkOnSlideUp();
SlidingTilePuzzleNode node(*this);
auto x2 = m_zero_tile_x;
auto y2 = m_zero_tile_y - 1;
std::swap(node[m_zero_tile_y][m_zero_tile_x], node[y2][x2]);
node.setZeroTileCoordinates(x2, y2);
return node;
}
SlidingTilePuzzleNode SlidingTilePuzzleNode::slideDown()
{
checkOnSlideDown();
SlidingTilePuzzleNode node(*this);
auto x2 = m_zero_tile_x;
auto y2 = m_zero_tile_y + 1;
std::swap(node[m_zero_tile_y][m_zero_tile_x], node[y2][x2]);
node.setZeroTileCoordinates(x2, y2);
return node;
}
SlidingTilePuzzleNode SlidingTilePuzzleNode::slideLeft()
{
checkOnSlideLeft();
SlidingTilePuzzleNode node(*this);
auto x2 = m_zero_tile_x - 1;
auto y2 = m_zero_tile_y;
std::swap(node[m_zero_tile_y][m_zero_tile_x], node[y2][x2]);
node.setZeroTileCoordinates(x2, y2);
return node;
}
SlidingTilePuzzleNode SlidingTilePuzzleNode::slideRight()
{
checkOnSlideRight();
SlidingTilePuzzleNode node(*this);
auto x2 = m_zero_tile_x + 1;
auto y2 = m_zero_tile_y;
std::swap(node[m_zero_tile_y][m_zero_tile_x], node[y2][x2]);
node.setZeroTileCoordinates(x2, y2);
return node;
}
SlidingTilePuzzleNodeRowSelector::SlidingTilePuzzleNodeRowSelector(
SlidingTilePuzzleNode* node,
std::size_t start_index)
:
m_node(node),
m_offset_index(start_index)
{
}
int& SlidingTilePuzzleNodeRowSelector::operator[](std::size_t x)
{
return m_node->m_state.at(m_offset_index + x);
}
SlidingTilePuzzleNodeRowSelector& SlidingTilePuzzleNode::operator[](std::size_t y)
{
return m_row_map[y];
}
std::ostream& operator<<(std::ostream& out, SlidingTilePuzzleNode& node)
{
const auto max_tile_number = node.getHeight() * node.getWidth() - 1;
const auto max_tile_number_length =
static_cast<std::size_t>(
std::floor(std::log10(max_tile_number)) + 1);
for (auto y = 0; y < node.getHeight(); y++) {
if (y > 0) {
out << '\n';
}
for (auto x = 0; x < node.getWidth(); x++) {
if (x > 0) {
out << " ";
}
out << std::setfill(' ')
<< std::setw(max_tile_number_length)
<< node[y][x];
}
}
return out;
}
inline void SlidingTilePuzzleNode::setZeroTileCoordinates(std::size_t x, std::size_t y)
{
m_zero_tile_x = x;
m_zero_tile_y = y;
}
| [
"rodion.efremov@helsinki.fi"
] | rodion.efremov@helsinki.fi |
38a5f83a6090eabfd023ff95573b2f842e075626 | bd8eda6121dc036844b404b63cafb0b3c926d3c2 | /no of chocolates.cpp | 77aea04c68dfc0003c82a85e8a571243e76acd38 | [] | no_license | Yinkular/HackerRank | 7b92427027ada196cfbbe63e8ca58340e7cfe29e | 15c3c534818725049cbd6836747d1e66e14cc431 | refs/heads/master | 2020-05-29T08:45:17.341262 | 2016-09-23T23:46:12 | 2016-09-23T23:46:12 | 69,068,018 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 652 | cpp | #include <cmath>
#include <cstdio>
#include <vector>
#include <iostream>
#include <algorithm>
using namespace std;
int main(){
int t;
cin >> t;
for(int a0 = 0; a0 < t; a0++){
int n;
int c;
int m;
cin >> n >> c >> m;
int no_of_choc,wrappers,choc_from_wrappers;
no_of_choc = n/c;
wrappers = no_of_choc;
while(wrappers >= m)
{
choc_from_wrappers = wrappers/m;
wrappers = choc_from_wrappers + wrappers % m;
no_of_choc+=choc_from_wrappers;
}
cout << no_of_choc << endl;
}
return 0;
} | [
"olayinka.soyinka@gmail.com"
] | olayinka.soyinka@gmail.com |
70a802a27fa08bd6bb59c77fc078452f945a9466 | ece01a11883ca3fc215cb57d451190fe5ce11e33 | /C++ProgrammingLanguage/01week/05palindrome.cpp | 2ba8cf3176b14a9aa3336a0e5ca870d972a2299d | [] | no_license | adamcavendish/HomeworkGitShare | 24fffb2376fa7da42a0fa7798aafc8283de96a99 | ef8d1543a5cc04d192088ea2a91a8db730f37d35 | refs/heads/master | 2021-01-18T21:23:53.414669 | 2016-04-30T21:35:24 | 2016-04-30T21:35:24 | 12,865,845 | 0 | 2 | null | null | null | null | UTF-8 | C++ | false | false | 632 | cpp | #include <algorithm>
#include <iostream>
#include <string>
#include <limits>
// alogrithm
using std::equal;
// iostream
using std::cin;
using std::cout;
using std::endl;
// string
using std::string;
// limits
using std::numeric_limits;
inline bool is_palindrome(string word) { return equal(word.begin(), word.end(), word.rbegin()); }
int main()
{
size_t case_num;
string word;
cin >> case_num;
cin.ignore(numeric_limits<std::streamsize>::max(), '\n');
for(int i = 0; i < case_num; ++i) {
getline(cin, word);
cout << "Case " << i << ": " << (is_palindrome(word) ? "YES." : "NO.") << endl;
}//for
return 0;
}//main
| [
"GetbetterABC@yeah.net"
] | GetbetterABC@yeah.net |
85ede5756c4fa5e7ca87c88cc3f8883a73050aae | e44f19bfcdf0b37b6a35a680ba0ea6f0ae82c6af | /NxWidgets/libnxwidgets/src/cscaledbitmap.cxx | 1ebf60324a6e70f18693dfa544550f33eda55847 | [
"BSD-3-Clause"
] | permissive | AlexShiLucky/nuttx-stm32f4disc-bb | 8b17db6e11e0c509f8c3026177086d75fbc0dda8 | cdf05897ba81a19ae313dc704639e21ab4fd33dd | refs/heads/master | 2020-03-11T18:11:18.915127 | 2014-05-13T10:24:46 | 2014-05-13T10:24:46 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 17,311 | cxx | /****************************************************************************
* NxWidgets/libnxwidgets/src/cscaledbitmap.hxx
*
* Copyright (C) 2013 Gregory Nutt. All rights reserved.
* Author: Gregory Nutt <gnutt@nuttx.org>
*
* 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 NuttX, NxWidgets, nor the names of its contributors
* me 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.
*
****************************************************************************/
/****************************************************************************
* Included Files
****************************************************************************/
#include <nuttx/config.h>
#include <stdint.h>
#include <stdbool.h>
#include <cstring>
#include <nuttx/nx/nxglib.h>
#include "cscaledbitmap.hxx"
/****************************************************************************
* Pre-Processor Definitions
****************************************************************************/
/****************************************************************************
* Method Implementations
****************************************************************************/
using namespace NXWidgets;
/**
* Constructor.
*
* @param bitmap The bitmap structure being scaled.
* @newSize The new, scaled size of the image
*/
CScaledBitmap::CScaledBitmap(IBitmap *bitmap, struct nxgl_size_s &newSize)
: m_bitmap(bitmap), m_size(newSize)
{
// xScale will be used to convert a request X position to an X position
// in the contained bitmap:
//
// xImage = xRequested * oldWidth / newWidth
// = xRequested * xScale
m_xScale = itob16((uint32_t)m_bitmap->getWidth()) / newSize.w;
// Similarly, yScale will be used to convert a request Y position to a Y
// positionin the contained bitmap:
//
// yImage = yRequested * oldHeight / newHeight
// = yRequested * yScale
m_yScale = itob16((uint32_t)m_bitmap->getHeight()) / newSize.h;
// Allocate and initialize the row cache
size_t stride = bitmap->getStride();
m_rowCache[0] = new uint8_t[stride];
m_rowCache[1] = new uint8_t[stride];
// Read the first two rows into the cache
m_row = m_bitmap->getWidth(); // Set to an impossible value
cacheRows(0);
}
/**
* Destructor.
*/
CScaledBitmap::~CScaledBitmap(void)
{
// Delete the allocated row cache memory
if (m_rowCache[0])
{
delete m_rowCache[0];
}
if (m_rowCache[1])
{
delete m_rowCache[1];
}
// We are also responsible for deleting the contained IBitmap
if (m_bitmap)
{
delete m_bitmap;
}
}
/**
* Get the bitmap's color format.
*
* @return The bitmap's width.
*/
const uint8_t CScaledBitmap::getColorFormat(void) const
{
return m_bitmap->getColorFormat();
}
/**
* Get the bitmap's color format.
*
* @return The bitmap's color format.
*/
const uint8_t CScaledBitmap::getBitsPerPixel(void) const
{
return m_bitmap->getBitsPerPixel();
}
/**
* Get the bitmap's width (in pixels/columns).
*
* @return The bitmap's pixel depth.
*/
const nxgl_coord_t CScaledBitmap::getWidth(void) const
{
return m_size.w;
}
/**
* Get the bitmap's height (in rows).
*
* @return The bitmap's height (in rows).
*/
const nxgl_coord_t CScaledBitmap::getHeight(void) const
{
return m_size.h;
}
/**
* Get the bitmap's width (in bytes).
*
* @return The bitmap's width (in bytes).
*/
const size_t CScaledBitmap::getStride(void) const
{
return (m_bitmap->getBitsPerPixel() * m_size.w + 7) / 8;
}
/**
* Get one row from the bit map image.
*
* REVISIT: This algorithm is really intended to expand images. Hence,
* for example, interpolation is between row and row+1 and column and
* column+1 in the original, unscaled image. You would the interpolation
* differently if you really wanted to sub-sample well.
*
* @param x The offset into the row to get
* @param y The row number to get
* @param width The number of pixels to get from the row
* @param data The memory location provided by the caller
* in which to return the data. This should be at least
* (getWidth()*getBitsPerPixl() + 7)/8 bytes in length
* and properly aligned for the pixel color format.
* @param True if the run was returned successfully.
*/
bool CScaledBitmap::getRun(nxgl_coord_t x, nxgl_coord_t y,
nxgl_coord_t width, FAR void *data)
{
#if CONFIG_NXWIDGETS_FMT == FB_FMT_RGB8_332 || CONFIG_NXWIDGETS_FMT == FB_FMT_RGB24
FAR uint8_t *dest = (FAR uint8_t *)data;
#elif CONFIG_NXWIDGETS_FMT == FB_FMT_RGB16_565
FAR uint16_t *dest = (FAR uint16_t *)data;
#elif CONFIG_NXWIDGETS_FMT == FB_FMT_RGB32
FAR uint32_t *dest = (FAR uint32_t *)data;
#else
# error Unsupported, invalid, or undefined color format
#endif
// Check ranges. Casts to unsigned int are ugly but permit one-sided comparisons
if (((unsigned int)x >= (unsigned int)m_size.w) &&
((unsigned int)(x + width) > (unsigned int)m_size.w) &&
((unsigned int)y <= (unsigned int)m_size.h))
{
return false;
}
// Get the row number in the unscaled image corresponding to the
// requested y position. This must be either the exact row or the
// closest row just before the requested position
b16_t row16 = y * m_yScale;
nxgl_coord_t row = b16toi(row16);
// Get that row and the one after it into the row cache. We know that
// the pixel value that we want is one between the two rows. This
// may seem wasteful to read two entire rows. However, in normal usage
// we will be traversal each image from top-left to bottom-right in
// order. In that case, the caching is most efficient.
if (!cacheRows(row))
{
return false;
}
// Now scale and copy the data from the cached row data
for (int i = 0; i < width; i++, x++)
{
// Get the column number in the unscaled row corresponding to the
// requested x position. This must be either the exact column or the
// closest column just before the requested position
b16_t column = x * m_xScale;
// Get the color at the position on the first row
struct rgbcolor_s color1;
if (!rowColor(m_rowCache[0], column, color1))
{
gdbg("ERROR rowColor failed for the first row\n");
return false;
}
// Get the color at the position on the first row
struct rgbcolor_s color2;
if (!rowColor(m_rowCache[1], column, color2))
{
gdbg("ERROR rowColor failed for the second row\n");
return false;
}
// Check for transparent colors
bool transparent1;
bool transparent2;
#if CONFIG_NXWIDGETS_FMT == FB_FMT_RGB8_332
uint8_t color = RGBTO8(color1.r, color1.g, color1.b);
transparent1 = (color == CONFIG_NXWIDGETS_TRANSPARENT_COLOR);
color = RGBTO8(color2.r, color2.g, color2.b);
transparent2 = (color == CONFIG_NXWIDGETS_TRANSPARENT_COLOR);
#elif CONFIG_NXWIDGETS_FMT == FB_FMT_RGB16_565
uint16_t color = RGBTO16(color1.r, color1.g, color1.b);
transparent1 = (color == CONFIG_NXWIDGETS_TRANSPARENT_COLOR);
color = RGBTO16(color2.r, color2.g, color2.b);
transparent2 = (color == CONFIG_NXWIDGETS_TRANSPARENT_COLOR);
#elif CONFIG_NXWIDGETS_FMT == FB_FMT_RGB24 || CONFIG_NXWIDGETS_FMT == FB_FMT_RGB32
uint32_t color = RGBTO24(color1.r, color1.g, color1.b);
transparent1 = (color == CONFIG_NXWIDGETS_TRANSPARENT_COLOR);
color = RGBTO24(color2.r, color2.g, color2.b);
transparent2 = (color == CONFIG_NXWIDGETS_TRANSPARENT_COLOR);
#else
# error Unsupported, invalid, or undefined color format
#endif
// Is one of the colors transparent?
struct rgbcolor_s scaledColor;
b16_t fraction b16frac(row16);
if (transparent1 || transparent2)
{
// Yes.. don't interpolate within transparent regions or
// between transparent and opaque regions.
// Get the color closest to the requested position
if (fraction < b16HALF)
{
scaledColor.r = color1.r;
scaledColor.g = color1.g;
scaledColor.b = color1.b;
}
else
{
scaledColor.r = color2.r;
scaledColor.g = color2.g;
scaledColor.b = color2.b;
}
}
else
{
// No.. both colors are opaque
if (!scaleColor(color1, color2, fraction, scaledColor))
{
return false;
}
}
// Write the interpolated data to the user buffer
#if CONFIG_NXWIDGETS_FMT == FB_FMT_RGB8_332
color = RGBTO8(scaledColor.r, scaledColor.g, scaledColor.b);
*dest++ = color;
#elif CONFIG_NXWIDGETS_FMT == FB_FMT_RGB16_565
color = RGBTO16(scaledColor.r, scaledColor.g, scaledColor.b);
*dest++ = color;
#elif CONFIG_NXWIDGETS_FMT == FB_FMT_RGB24
*dest++ = color2.b;
*dest++ = color2.r;
*dest++ = color2.g;
#elif CONFIG_NXWIDGETS_FMT == FB_FMT_RGB32
color = RGBTO24(scaledColor.r, scaledColor.g, scaledColor.b);
*dest++ = color;
#else
# error Unsupported, invalid, or undefined color format
#endif
}
return true;
}
/**
* Read two rows into the row cache
*
* @param row - The row number of the first row to cache
*/
bool CScaledBitmap::cacheRows(unsigned int row)
{
nxgl_coord_t bitmapWidth = m_bitmap->getWidth();
nxgl_coord_t bitmapHeight = m_bitmap->getHeight();
// A common case is to advance by one row. In this case, we only
// need to read one row
if (row == m_row + 1)
{
// Swap rows
FAR uint8_t *saveRow = m_rowCache[0];
m_rowCache[0] = m_rowCache[1];
m_rowCache[1] = saveRow;
// Save number of the first row that we have in the cache
m_row = row;
// Now read the new row into the second row cache buffer
if (++row >= (unsigned int)bitmapHeight)
{
row = bitmapHeight - 1;
}
if (!m_bitmap->getRun(0, row, bitmapWidth, m_rowCache[1]))
{
gdbg("Failed to read bitmap row %d\n", row);
return false;
}
}
// Do we need to read two new rows? Or do we already have the
// request row in the cache?
else if (row != m_row)
{
// Read the first row into the cache
if (row >= (unsigned int)bitmapHeight)
{
row = bitmapHeight - 1;
}
if (!m_bitmap->getRun(0, row, bitmapWidth, m_rowCache[0]))
{
gdbg("Failed to read bitmap row %d\n", row);
return false;
}
// Save number of the first row that we have in the cache
m_row = row;
// Read the next row into the cache
if (++row >= (unsigned int)bitmapHeight)
{
row = bitmapHeight - 1;
}
if (!m_bitmap->getRun(0, row, bitmapWidth, m_rowCache[1]))
{
gdbg("Failed to read bitmap row %d\n", row);
return false;
}
}
return true;
}
/**
* Given an two RGB colors and a fractional value, return the scaled
* value between the two colors.
*
* @param incolor1 - The first color to be used
* @param incolor2 - The second color to be used
* @param fraction - The fractional value
* @param outcolor - The returned, scaled color
*/
bool CScaledBitmap::scaleColor(FAR const struct rgbcolor_s &incolor1,
FAR const struct rgbcolor_s &incolor2,
b16_t fraction, FAR struct rgbcolor_s &outcolor)
{
uint8_t component;
b16_t red;
b16_t green;
b16_t blue;
// A fraction of < 0.5 would mean to use use mostly color1; a fraction
// greater than 0.5 would men to use mostly color2
b16_t remainder = b16ONE - fraction;
// Interpolate each color value (converting to b15)
red = (b16_t)incolor1.r * remainder + (b16_t)incolor2.r * fraction;
green = (b16_t)incolor1.g * remainder + (b16_t)incolor2.g * fraction;
blue = (b16_t)incolor1.b * remainder + (b16_t)incolor2.b * fraction;
// Return the integer, interpolated values, clipping to the range of
// uint8_t
component = b16toi(red);
outcolor.r = component < 256 ? component : 255;
component = b16toi(green);
outcolor.g = component < 256 ? component : 255;
component = b16toi(blue);
outcolor.b = component < 256 ? component : 255;
return true;
}
/**
* Given an image row and a non-integer column offset, return the
* interpolated RGB color value corresponding to that position
*
* @param row - The pointer to the row in the row cache to use
* @param column - The non-integer column offset
* @param outcolor - The returned, interpolated color
*
*/
bool CScaledBitmap::rowColor(FAR uint8_t *row, b16_t column,
FAR struct rgbcolor_s &outcolor)
{
// This is the col at or just before the pixel of interest
nxgl_coord_t col1 = b16toi(column);
nxgl_coord_t col2 = col1 + 1;
nxgl_coord_t bitmapWidth = m_bitmap->getWidth();
if (col2 >= bitmapWidth)
{
col2 = bitmapWidth - 1;
}
b16_t fraction = b16frac(column);
struct rgbcolor_s color1;
struct rgbcolor_s color2;
bool transparent1;
bool transparent2;
#if CONFIG_NXWIDGETS_FMT == FB_FMT_RGB8_332
uint8_t color = row[col1];
color1.r = RBG8RED(color);
color1.g = RBG8GREEN(color);
color1.b = RBG8BLUE(color);
transparent1 = (color == CONFIG_NXWIDGETS_TRANSPARENT_COLOR);
color = row[col2];
color2.r = RBG8RED(color);
color2.g = RBG8GREEN(color);
color2.b = RBG8BLUE(color);
transparent2 = (color == CONFIG_NXWIDGETS_TRANSPARENT_COLOR);
#elif CONFIG_NXWIDGETS_FMT == FB_FMT_RGB16_565
FAR uint16_t *row16 = (FAR uint16_t*)row;
uint16_t color = row16[col1];
color1.r = RBG16RED(color);
color1.g = RBG16GREEN(color);
color1.b = RBG16BLUE(color);
transparent1 = (color == CONFIG_NXWIDGETS_TRANSPARENT_COLOR);
color = row16[col2];
color2.r = RBG16RED(color);
color2.g = RBG16GREEN(color);
color2.b = RBG16BLUE(color);
transparent2 = (color == CONFIG_NXWIDGETS_TRANSPARENT_COLOR);
#elif CONFIG_NXWIDGETS_FMT == FB_FMT_RGB24
unsigned int ndx = 3*col1;
color1.r = row[ndx+2];
color1.g = row[ndx+1];
color1.b = row[ndx];
uint32_t color = RGBTO24(color1.r, color1.g, color1.b);
transparent1 = (color == CONFIG_NXWIDGETS_TRANSPARENT_COLOR);
ndx = 3*col2;
color2.r = row[ndx+2];
color2.g = row[ndx+1];
color2.b = row[ndx];
color = RGBTO24(color2.r, color2.g, color2.b);
transparent2 = (color == CONFIG_NXWIDGETS_TRANSPARENT_COLOR);
#elif CONFIG_NXWIDGETS_FMT == FB_FMT_RGB32
FAR uint32_t *row32 = (FAR uint32_t*)row;
uint32_t color = row32[col1];
color1.r = RBG24RED(color);
color1.g = RBG24GREEN(color);
color1.b = RBG24BLUE(color);
transparent1 = (color == CONFIG_NXWIDGETS_TRANSPARENT_COLOR);
color = row32[col2];
color2.r = RBG24RED(color);
color2.g = RBG24GREEN(color);
color2.b = RBG24BLUE(color);
transparent2 = (color == CONFIG_NXWIDGETS_TRANSPARENT_COLOR);
#else
# error Unsupported, invalid, or undefined color format
#endif
// Is one of the colors transparent?
if (transparent1 || transparent2)
{
// Yes.. don't interpolate within transparent regions or
// between transparent and opaque regions.
// Return the color closest to the requested position
//
// A fraction of < 0.5 would mean to use use mostly color1; a fraction
// greater than 0.5 would men to use mostly color2
if (fraction < b16HALF)
{
outcolor.r = color1.r;
outcolor.g = color1.b;
outcolor.g = color1.g;
}
else
{
outcolor.r = color2.r;
outcolor.g = color2.b;
outcolor.g = color2.g;
}
return true;
}
else
{
// No.. both colors are opaque
return scaleColor(color1, color2, fraction, outcolor);
}
}
| [
"gnutt@nuttx.org"
] | gnutt@nuttx.org |
3e123f6080a1d521191f892eec2867fcc751b5e7 | 5446d249c2752e70ad027fadf82bcfcd8a15edb6 | /public/node_modules/firebase-admin/node_modules/grpc/third_party/boringssl/include/openssl/hmac.h | e4cc04e6e1eec0712dcb9b59cf76e29968915078 | [
"BSD-3-Clause",
"OpenSSL",
"ISC",
"LicenseRef-scancode-openssl",
"LicenseRef-scancode-ssleay-windows",
"Apache-2.0",
"MIT",
"LicenseRef-scancode-proprietary-license"
] | permissive | levindoneto/IoT-Modelling-Tool | 9717bb5cfa82d8788f27c4c02a91c3da6ff060f7 | 366a1aae6f1f3e17279edbd93bb6f3fb9f69516d | refs/heads/master | 2022-11-26T15:31:36.895821 | 2022-11-15T17:11:23 | 2022-11-15T17:11:23 | 89,625,981 | 18 | 2 | MIT | 2022-11-15T17:11:24 | 2017-04-27T18:02:19 | JavaScript | UTF-8 | C++ | false | false | 7,240 | h | /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
* All rights reserved.
*
* This package is an SSL implementation written
* by Eric Young (eay@cryptsoft.com).
* The implementation was written so as to conform with Netscapes SSL.
*
* This library is free for commercial and non-commercial use as long as
* the following conditions are aheared to. The following conditions
* apply to all code found in this distribution, be it the RC4, RSA,
* lhash, DES, etc., code; not just the SSL code. The SSL documentation
* included with this distribution is covered by the same copyright terms
* except that the holder is Tim Hudson (tjh@cryptsoft.com).
*
* Copyright remains Eric Young's, and as such any Copyright notices in
* the code are not to be removed.
* If this package is used in a product, Eric Young should be given attribution
* as the author of the parts of the library used.
* This can be in the form of a textual message at program startup or
* in documentation (online or textual) provided with the package.
*
* 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 copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. All advertising materials mentioning features or use of this software
* must display the following acknowledgement:
* "This product includes cryptographic software written by
* Eric Young (eay@cryptsoft.com)"
* The word 'cryptographic' can be left out if the rouines from the library
* being used are not cryptographic related :-).
* 4. If you include any Windows specific code (or a derivative thereof) from
* the apps directory (application code) you must include an acknowledgement:
* "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
*
* THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``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 AUTHOR 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.
*
* The licence and distribution terms for any publically available version or
* derivative of this code cannot be changed. i.e. this code cannot simply be
* copied and put under another distribution licence
* [including the GNU Public Licence.] */
#ifndef OPENSSL_HEADER_HMAC_H
#define OPENSSL_HEADER_HMAC_H
#include <openssl/base.h>
#include <openssl/digest.h>
#if defined(__cplusplus)
extern "C" {
#endif
/* HMAC contains functions for constructing PRFs from Merkle–Damgård hash
* functions using HMAC. */
/* One-shot operation. */
/* HMAC calculates the HMAC of |data_len| bytes of |data|, using the given key
* and hash function, and writes the result to |out|. On entry, |out| must
* contain at least |EVP_MD_size| bytes of space. The actual length of the
* result is written to |*out_len|. An output size of |EVP_MAX_MD_SIZE| will
* always be large enough. It returns |out| or NULL on error. */
OPENSSL_EXPORT uint8_t *HMAC(const EVP_MD *evp_md, const void *key,
size_t key_len, const uint8_t *data,
size_t data_len, uint8_t *out,
unsigned int *out_len);
/* Incremental operation. */
/* HMAC_CTX_init initialises |ctx| for use in an HMAC operation. It's assumed
* that HMAC_CTX objects will be allocated on the stack thus no allocation
* function is provided. If needed, allocate |sizeof(HMAC_CTX)| and call
* |HMAC_CTX_init| on it. */
OPENSSL_EXPORT void HMAC_CTX_init(HMAC_CTX *ctx);
/* HMAC_CTX_cleanup frees data owned by |ctx|. */
OPENSSL_EXPORT void HMAC_CTX_cleanup(HMAC_CTX *ctx);
/* HMAC_Init_ex sets up an initialised |HMAC_CTX| to use |md| as the hash
* function and |key| as the key. For a non-initial call, |md| may be NULL, in
* which case the previous hash function will be used. If the hash function has
* not changed and |key| is NULL, |ctx| reuses the previous key. It returns one
* on success or zero otherwise.
*
* WARNING: NULL and empty keys are ambiguous on non-initial calls. Passing NULL
* |key| but repeating the previous |md| reuses the previous key rather than the
* empty key. */
OPENSSL_EXPORT int HMAC_Init_ex(HMAC_CTX *ctx, const void *key, size_t key_len,
const EVP_MD *md, ENGINE *impl);
/* HMAC_Update hashes |data_len| bytes from |data| into the current HMAC
* operation in |ctx|. It returns one. */
OPENSSL_EXPORT int HMAC_Update(HMAC_CTX *ctx, const uint8_t *data,
size_t data_len);
/* HMAC_Final completes the HMAC operation in |ctx| and writes the result to
* |out| and the sets |*out_len| to the length of the result. On entry, |out|
* must contain at least |HMAC_size| bytes of space. An output size of
* |EVP_MAX_MD_SIZE| will always be large enough. It returns one on success or
* zero on error. */
OPENSSL_EXPORT int HMAC_Final(HMAC_CTX *ctx, uint8_t *out,
unsigned int *out_len);
/* Utility functions. */
/* HMAC_size returns the size, in bytes, of the HMAC that will be produced by
* |ctx|. On entry, |ctx| must have been setup with |HMAC_Init_ex|. */
OPENSSL_EXPORT size_t HMAC_size(const HMAC_CTX *ctx);
/* HMAC_CTX_copy_ex sets |dest| equal to |src|. On entry, |dest| must have been
* initialised by calling |HMAC_CTX_init|. It returns one on success and zero
* on error. */
OPENSSL_EXPORT int HMAC_CTX_copy_ex(HMAC_CTX *dest, const HMAC_CTX *src);
/* Deprecated functions. */
OPENSSL_EXPORT int HMAC_Init(HMAC_CTX *ctx, const void *key, int key_len,
const EVP_MD *md);
/* HMAC_CTX_copy calls |HMAC_CTX_init| on |dest| and then sets it equal to
* |src|. On entry, |dest| must /not/ be initialised for an operation with
* |HMAC_Init_ex|. It returns one on success and zero on error. */
OPENSSL_EXPORT int HMAC_CTX_copy(HMAC_CTX *dest, const HMAC_CTX *src);
/* Private functions */
struct hmac_ctx_st {
const EVP_MD *md;
EVP_MD_CTX md_ctx;
EVP_MD_CTX i_ctx;
EVP_MD_CTX o_ctx;
} /* HMAC_CTX */;
#if defined(__cplusplus)
} /* extern C */
#if !defined(BORINGSSL_NO_CXX)
extern "C++" {
namespace bssl {
using ScopedHMAC_CTX =
internal::StackAllocated<HMAC_CTX, void, HMAC_CTX_init, HMAC_CTX_cleanup>;
} // namespace bssl
} // extern C++
#endif
#endif
#endif /* OPENSSL_HEADER_HMAC_H */
| [
"levindogtn@gmail.com"
] | levindogtn@gmail.com |
0f2133718afe1313cef2c6417d4a6532bdf79de2 | b538ad8b58864b4d206ed07a00dc9c37c482d280 | /Module01/ex05/includes/Human.hpp | 0ed6f4340971af0b22d6f8e63809eecebf3a05c8 | [] | no_license | aberry-21/CPP_Module | 0083035a4bc7be7cf83035738458660c23a2389c | 42f08b10e6ebada9d0034464a0bed9a8a2dfada6 | refs/heads/main | 2023-04-21T21:37:51.882909 | 2021-04-29T17:30:32 | 2021-04-29T17:30:32 | 357,558,067 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 386 | hpp | //
// Created by Aaron Berry on 4/18/21.
//
#pragma once
#ifndef HUMAN_HPP
#define HUMAN_HPP
#include <string>
#include "includes/Brain.hpp"
class Human {
Brain const *brain_;
public:
Human(const Human &other);
virtual ~Human();
Human();
Brain const &getBrain() const;
std::string identify() const;
Human &operator=(const Human &other);
};
#endif // HUMAN_HPP
| [
"lot.lebedevok@gmail.com"
] | lot.lebedevok@gmail.com |
9eca36264138e4d0ac319d0a16cea0bc433f38c5 | 627cd624fa23cdcb28b449b4c831cc1ff924da40 | /INFIX TO PREFIX CONVERTER/main.cpp | e36edd898628a5510defe14bc198394390a4f671 | [] | no_license | Taha-Imtiaz/Data-Structures | 5e7c09e0edae59f11610d45fbbbf71a35b695319 | 4b60f3f72df1dfc47b6518057820d46b883ee83f | refs/heads/master | 2020-11-24T05:37:32.706901 | 2019-12-14T08:02:05 | 2019-12-14T08:02:05 | 227,987,081 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 4,790 | cpp | #include <stdio.h>
#include <stdlib.h>
#include<conio.h>
#include<iostream>
#include<string>
//void Innfix(string);
using namespace std;
struct node
{
string value;
struct node *next;
};
/*void Innfix(string input)
{
for(int i=0;i<input.length();i++)
{
cout<<input[i]<<endl;
}
}*/
struct Stack
{
char value;
struct Stack *next;
};
void push_value(struct Stack **top,char element)
{
struct Stack *ptr;
ptr=(struct Stack*)malloc(sizeof(struct Stack));
ptr->value=element;
// printf("Pushed value is %d\n",element);
ptr->next=*top;
*top=ptr;
}
char pop_value(struct Stack **top)
{
if(*top==NULL)
{
printf("\nStack is underflow");
}
if(*top!=NULL)
{
struct Stack *temp;
temp=*top;
(*top)=(*top)->next;
//printf("%d has popped\n",temp->value);
free(temp);
return temp->value;
}
}
void peek_stack(struct Stack *start)
{
struct Stack *curr=start;
printf("The Elements in a stack are\n");
while(curr!=NULL)
{
printf("%d\n",curr->value);
curr=curr->next;
}
}
char Peak(struct Stack *top)
{
if(top!=NULL)
return top->value;
}
int Check_Precedence(char Operator)
{
if (Operator=='(')
{
return 6;
}
else if(Operator=='*'||Operator=='/'||Operator=='%')
{
return 5;
}
else if(Operator=='+'||Operator=='-')
{
return 4;
}
else if(Operator=='<'||Operator=='>'||Operator=='='||Operator=='~')
{
return 3;
}
else if(Operator=='&')
{
return 2;
}
else if(Operator=='|')
{
return 1;
}
else if(Operator==')')
{
return -1;
}
}
bool IsEmpty(struct Stack *top)
{
if(top==NULL)
return true;
else
return false;
}
void insert(struct node **Infix)
{
struct node *ptr;
string input;
ptr=(struct node*)malloc(sizeof(struct node));
cout<<"\nEnter Infix Expression\t";
cin>>input;
ptr->value=input;
ptr->next=NULL;
if(*Infix==NULL)
{
*Infix=ptr;
}
else
{
struct node * curr=*Infix;
while(curr->next!=NULL)
{
curr=curr->next;
}
curr->next=ptr;
}
//Innfix(input);
}
void Infix_Prefix(struct node *Infix)
{
struct node *curr=Infix;
while(curr->next!=NULL)
{
curr=curr->next;
}
string infix=curr->value;
// cout<<endl<<infix;
string postFix = "";
int n = infix.length();
string reverseInfix="";
string preFix;
char peak;
int precPeak,precPresent;
//list stack;
struct Stack *top = NULL;
for(int i=n-1;i>=0;i--)
{
reverseInfix.push_back(infix[i]);
}
//cout<<"\nReverse string is:\t"<<reverseInfix;
//cout<<"\nReverse:";
for(int i=0;i<=n-1;i++)
{
// cout<<reverseInfix[i];
if(reverseInfix[i]=='(')
{
reverseInfix[i]=')';
}
else if(reverseInfix[i]==')')
{
reverseInfix[i]='(';
}
}
cout<<"\n";
/*for(int i=0;i<=n;i++)
{
cout<<reverseInfix[i];
}*/
for(int i=0;i<=n;i++)
{
if((reverseInfix[i] >= 'A' && reverseInfix[i]<= 'Z') || (reverseInfix[i] >= 'a' && reverseInfix[i] <= 'z')|| (reverseInfix[i] >= '0' &&reverseInfix[i] <= '9'))
{
postFix.push_back(reverseInfix[i]);
}
else
{
if(!(IsEmpty(top)))
{
peak= Peak(top);
precPeak = Check_Precedence(peak);
precPresent =Check_Precedence(reverseInfix[i]);
}
if(IsEmpty(top) || peak == '(' || precPresent > precPeak)
{
push_value(&top,reverseInfix[i]);
}
else if(reverseInfix[i] == ')')
{
while(peak!= '(')
{
postFix.push_back(pop_value(&top));
peak = Peak(top);
}
pop_value(&top);
}
else if(precPresent <= precPeak && peak!= '(')
{
while(precPeak >= precPresent && !(IsEmpty(top)))
{
postFix.push_back(pop_value(&top));
precPeak = Check_Precedence(Peak(top));
}
push_value(&top,reverseInfix[i]);
}
else if(!top){
while(!(IsEmpty(top)))
{
postFix.push_back(pop_value(&top));
}
}
}
}
//cout<<"\nPostfix is:\t"<<postFix<<endl;
//cout<<"\nPrefix is:\t";
for(int i=n-1;i>=0;i--)
{
preFix.push_back(postFix[i]);
}
//cout<<"\nThe Prefix of the given infix expression is:\t";
/*for(int i=n-1;i>=0;i--)
{
cout<<preFix[i];
}*/
//cout<<"\nPrefix is:\t"<<preFix<<endl;
cout<<"\nThe Prefix of the given infix expression is:\t"<<preFix;
}
void display_Infix(struct node *Infix)
{
struct node * curr=Infix;
while(curr->next!=NULL)
{
// cout<<endl<<"Infix is: "<<curr->value;
curr=curr->next;
}
cout<<endl<<"Infix is: "<<curr->value;
}
//void Infix_Postfix
int main()
{
struct node* Infix=NULL;
insert(&Infix);
display_Infix(Infix);
Infix_Prefix(Infix);
cout<<endl<<endl;
insert(&Infix);
display_Infix(Infix);
Infix_Prefix(Infix);
}
| [
"tahaimtiaz1996@gmail.com"
] | tahaimtiaz1996@gmail.com |
d12036a44929f8ae369bb2afab7b194cdf188e1d | 8dc84558f0058d90dfc4955e905dab1b22d12c08 | /net/third_party/quiche/src/quic/test_tools/simple_session_notifier.cc | c6e38015df1fd0cee4614693ee5b2f6368871fed | [
"BSD-3-Clause",
"LicenseRef-scancode-unknown-license-reference"
] | permissive | meniossin/src | 42a95cc6c4a9c71d43d62bc4311224ca1fd61e03 | 44f73f7e76119e5ab415d4593ac66485e65d700a | refs/heads/master | 2022-12-16T20:17:03.747113 | 2020-09-03T10:43:12 | 2020-09-03T10:43:12 | 263,710,168 | 1 | 0 | BSD-3-Clause | 2020-05-13T18:20:09 | 2020-05-13T18:20:08 | null | UTF-8 | C++ | false | false | 26,690 | cc | // Copyright (c) 2018 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "net/third_party/quiche/src/quic/test_tools/simple_session_notifier.h"
#include "net/third_party/quiche/src/quic/core/quic_utils.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_logging.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_map_util.h"
#include "net/third_party/quiche/src/quic/test_tools/quic_test_utils.h"
namespace quic {
namespace test {
SimpleSessionNotifier::SimpleSessionNotifier(QuicConnection* connection)
: last_control_frame_id_(kInvalidControlFrameId),
least_unacked_(1),
least_unsent_(1),
connection_(connection) {}
SimpleSessionNotifier::~SimpleSessionNotifier() {
while (!control_frames_.empty()) {
DeleteFrame(&control_frames_.front());
control_frames_.pop_front();
}
}
SimpleSessionNotifier::StreamState::StreamState()
: bytes_total(0),
bytes_sent(0),
fin_buffered(false),
fin_sent(false),
fin_outstanding(false),
fin_lost(false) {}
SimpleSessionNotifier::StreamState::~StreamState() {}
QuicConsumedData SimpleSessionNotifier::WriteOrBufferData(
QuicStreamId id,
QuicByteCount data_length,
StreamSendingState state) {
if (!QuicContainsKey(stream_map_, id)) {
stream_map_[id] = StreamState();
}
StreamState& stream_state = stream_map_.find(id)->second;
const bool had_buffered_data =
HasBufferedStreamData() || HasBufferedControlFrames();
QuicConsumedData total_consumed(0, false);
QuicStreamOffset offset = stream_state.bytes_sent;
QUIC_DVLOG(1) << "WriteOrBuffer stream_id: " << id << " [" << offset << ", "
<< offset + data_length << "), fin: " << (state != NO_FIN);
stream_state.bytes_total += data_length;
stream_state.fin_buffered = state != NO_FIN;
if (had_buffered_data) {
QUIC_DLOG(WARNING) << "Connection is write blocked";
return {0, false};
}
const size_t length = stream_state.bytes_total - stream_state.bytes_sent;
connection_->SetTransmissionType(NOT_RETRANSMISSION);
QuicConsumedData consumed =
connection_->SendStreamData(id, length, stream_state.bytes_sent,
stream_state.fin_buffered ? FIN : NO_FIN);
QUIC_DVLOG(1) << "consumed: " << consumed;
OnStreamDataConsumed(id, stream_state.bytes_sent, consumed.bytes_consumed,
consumed.fin_consumed);
return consumed;
}
void SimpleSessionNotifier::OnStreamDataConsumed(QuicStreamId id,
QuicStreamOffset offset,
QuicByteCount data_length,
bool fin) {
StreamState& state = stream_map_.find(id)->second;
if (QuicUtils::IsCryptoStreamId(connection_->transport_version(), id) &&
data_length > 0) {
crypto_bytes_transferred_[connection_->encryption_level()].Add(
offset, offset + data_length);
}
state.bytes_sent += data_length;
state.fin_sent = fin;
state.fin_outstanding = fin;
}
size_t SimpleSessionNotifier::WriteCryptoData(EncryptionLevel level,
QuicByteCount data_length,
QuicStreamOffset offset) {
crypto_state_[level].bytes_total += data_length;
size_t bytes_written =
connection_->SendCryptoData(level, data_length, offset);
crypto_state_[level].bytes_sent += bytes_written;
crypto_bytes_transferred_[level].Add(offset, offset + bytes_written);
return bytes_written;
}
void SimpleSessionNotifier::WriteOrBufferRstStream(
QuicStreamId id,
QuicRstStreamErrorCode error,
QuicStreamOffset bytes_written) {
QUIC_DVLOG(1) << "Writing RST_STREAM_FRAME";
const bool had_buffered_data =
HasBufferedStreamData() || HasBufferedControlFrames();
control_frames_.emplace_back((QuicFrame(new QuicRstStreamFrame(
++last_control_frame_id_, id, error, bytes_written))));
if (error != QUIC_STREAM_NO_ERROR) {
// Delete stream to avoid retransmissions.
stream_map_.erase(id);
}
if (had_buffered_data) {
QUIC_DLOG(WARNING) << "Connection is write blocked";
return;
}
WriteBufferedControlFrames();
}
void SimpleSessionNotifier::WriteOrBufferPing() {
QUIC_DVLOG(1) << "Writing PING_FRAME";
const bool had_buffered_data =
HasBufferedStreamData() || HasBufferedControlFrames();
control_frames_.emplace_back(
(QuicFrame(QuicPingFrame(++last_control_frame_id_))));
if (had_buffered_data) {
QUIC_DLOG(WARNING) << "Connection is write blocked";
return;
}
WriteBufferedControlFrames();
}
void SimpleSessionNotifier::NeuterUnencryptedData() {
// TODO(nharper): Handle CRYPTO frame case.
if (QuicVersionUsesCryptoFrames(connection_->transport_version())) {
return;
}
for (const auto& interval : crypto_bytes_transferred_[ENCRYPTION_INITIAL]) {
QuicStreamFrame stream_frame(
QuicUtils::GetCryptoStreamId(connection_->transport_version()), false,
interval.min(), interval.max() - interval.min());
OnFrameAcked(QuicFrame(stream_frame), QuicTime::Delta::Zero(),
QuicTime::Zero());
}
}
void SimpleSessionNotifier::OnCanWrite() {
if (!RetransmitLostCryptoData() || !RetransmitLostControlFrames() ||
!RetransmitLostStreamData()) {
return;
}
// Write buffered control frames.
if (!WriteBufferedControlFrames()) {
return;
}
// Write new data.
for (const auto& pair : stream_map_) {
const auto& state = pair.second;
if (!StreamHasBufferedData(pair.first)) {
continue;
}
const size_t length = state.bytes_total - state.bytes_sent;
const bool can_bundle_fin =
state.fin_buffered && (state.bytes_sent + length == state.bytes_total);
connection_->SetTransmissionType(NOT_RETRANSMISSION);
QuicConsumedData consumed = connection_->SendStreamData(
pair.first, length, state.bytes_sent, can_bundle_fin ? FIN : NO_FIN);
QUIC_DVLOG(1) << "Tries to write stream_id: " << pair.first << " ["
<< state.bytes_sent << ", " << state.bytes_sent + length
<< "), fin: " << can_bundle_fin
<< ", and consumed: " << consumed;
OnStreamDataConsumed(pair.first, state.bytes_sent, consumed.bytes_consumed,
consumed.fin_consumed);
if (length != consumed.bytes_consumed ||
(can_bundle_fin && !consumed.fin_consumed)) {
break;
}
}
}
bool SimpleSessionNotifier::WillingToWrite() const {
QUIC_DVLOG(1) << "has_buffered_control_frames: " << HasBufferedControlFrames()
<< " as_lost_control_frames: " << !lost_control_frames_.empty()
<< " has_buffered_stream_data: " << HasBufferedStreamData()
<< " has_lost_stream_data: " << HasLostStreamData();
return HasBufferedControlFrames() || !lost_control_frames_.empty() ||
HasBufferedStreamData() || HasLostStreamData();
}
QuicByteCount SimpleSessionNotifier::StreamBytesSent() const {
QuicByteCount bytes_sent = 0;
for (const auto& pair : stream_map_) {
const auto& state = pair.second;
bytes_sent += state.bytes_sent;
}
return bytes_sent;
}
QuicByteCount SimpleSessionNotifier::StreamBytesToSend() const {
QuicByteCount bytes_to_send = 0;
for (const auto& pair : stream_map_) {
const auto& state = pair.second;
bytes_to_send += (state.bytes_total - state.bytes_sent);
}
return bytes_to_send;
}
bool SimpleSessionNotifier::OnFrameAcked(const QuicFrame& frame,
QuicTime::Delta /*ack_delay_time*/,
QuicTime /*receive_timestamp*/) {
QUIC_DVLOG(1) << "Acking " << frame;
if (frame.type == CRYPTO_FRAME) {
StreamState* state = &crypto_state_[frame.crypto_frame->level];
QuicStreamOffset offset = frame.crypto_frame->offset;
QuicByteCount data_length = frame.crypto_frame->data_length;
QuicIntervalSet<QuicStreamOffset> newly_acked(offset, offset + data_length);
newly_acked.Difference(state->bytes_acked);
if (newly_acked.Empty()) {
return false;
}
state->bytes_acked.Add(offset, offset + data_length);
state->pending_retransmissions.Difference(offset, offset + data_length);
return true;
}
if (frame.type != STREAM_FRAME) {
return OnControlFrameAcked(frame);
}
if (!QuicContainsKey(stream_map_, frame.stream_frame.stream_id)) {
return false;
}
auto* state = &stream_map_.find(frame.stream_frame.stream_id)->second;
QuicStreamOffset offset = frame.stream_frame.offset;
QuicByteCount data_length = frame.stream_frame.data_length;
QuicIntervalSet<QuicStreamOffset> newly_acked(offset, offset + data_length);
newly_acked.Difference(state->bytes_acked);
const bool fin_newly_acked = frame.stream_frame.fin && state->fin_outstanding;
if (newly_acked.Empty() && !fin_newly_acked) {
return false;
}
state->bytes_acked.Add(offset, offset + data_length);
if (fin_newly_acked) {
state->fin_outstanding = false;
state->fin_lost = false;
}
state->pending_retransmissions.Difference(offset, offset + data_length);
return true;
}
void SimpleSessionNotifier::OnFrameLost(const QuicFrame& frame) {
QUIC_DVLOG(1) << "Losting " << frame;
if (frame.type == CRYPTO_FRAME) {
StreamState* state = &crypto_state_[frame.crypto_frame->level];
QuicStreamOffset offset = frame.crypto_frame->offset;
QuicByteCount data_length = frame.crypto_frame->data_length;
QuicIntervalSet<QuicStreamOffset> bytes_lost(offset, offset + data_length);
bytes_lost.Difference(state->bytes_acked);
if (bytes_lost.Empty()) {
return;
}
for (const auto& lost : bytes_lost) {
state->pending_retransmissions.Add(lost.min(), lost.max());
}
return;
}
if (frame.type != STREAM_FRAME) {
OnControlFrameLost(frame);
return;
}
if (!QuicContainsKey(stream_map_, frame.stream_frame.stream_id)) {
return;
}
auto* state = &stream_map_.find(frame.stream_frame.stream_id)->second;
QuicStreamOffset offset = frame.stream_frame.offset;
QuicByteCount data_length = frame.stream_frame.data_length;
QuicIntervalSet<QuicStreamOffset> bytes_lost(offset, offset + data_length);
bytes_lost.Difference(state->bytes_acked);
const bool fin_lost = state->fin_outstanding && frame.stream_frame.fin;
if (bytes_lost.Empty() && !fin_lost) {
return;
}
for (const auto& lost : bytes_lost) {
state->pending_retransmissions.Add(lost.min(), lost.max());
}
state->fin_lost = fin_lost;
}
void SimpleSessionNotifier::RetransmitFrames(const QuicFrames& frames,
TransmissionType type) {
QuicConnection::ScopedPacketFlusher retransmission_flusher(
connection_, QuicConnection::SEND_ACK_IF_QUEUED);
connection_->SetTransmissionType(type);
for (const QuicFrame& frame : frames) {
if (frame.type == CRYPTO_FRAME) {
const StreamState& state = crypto_state_[frame.crypto_frame->level];
QuicIntervalSet<QuicStreamOffset> retransmission(
frame.crypto_frame->offset,
frame.crypto_frame->offset + frame.crypto_frame->data_length);
retransmission.Difference(state.bytes_acked);
for (const auto& interval : retransmission) {
QuicStreamOffset offset = interval.min();
QuicByteCount length = interval.max() - interval.min();
size_t consumed = connection_->SendCryptoData(frame.crypto_frame->level,
length, offset);
// CRYPTO frames should never be write blocked.
DCHECK_EQ(consumed, length);
}
}
if (frame.type != STREAM_FRAME) {
if (GetControlFrameId(frame) == kInvalidControlFrameId) {
continue;
}
QuicFrame copy = CopyRetransmittableControlFrame(frame);
if (!connection_->SendControlFrame(copy)) {
// Connection is write blocked.
DeleteFrame(©);
return;
}
continue;
}
if (!QuicContainsKey(stream_map_, frame.stream_frame.stream_id)) {
continue;
}
const auto& state = stream_map_.find(frame.stream_frame.stream_id)->second;
QuicIntervalSet<QuicStreamOffset> retransmission(
frame.stream_frame.offset,
frame.stream_frame.offset + frame.stream_frame.data_length);
EncryptionLevel retransmission_encryption_level =
connection_->encryption_level();
EncryptionLevel current_encryption_level = connection_->encryption_level();
if (QuicUtils::IsCryptoStreamId(connection_->transport_version(),
frame.stream_frame.stream_id)) {
for (size_t i = 0; i < NUM_ENCRYPTION_LEVELS; ++i) {
if (retransmission.Intersects(crypto_bytes_transferred_[i])) {
retransmission_encryption_level = static_cast<EncryptionLevel>(i);
retransmission.Intersection(crypto_bytes_transferred_[i]);
break;
}
}
}
retransmission.Difference(state.bytes_acked);
bool retransmit_fin = frame.stream_frame.fin && state.fin_outstanding;
QuicConsumedData consumed(0, false);
for (const auto& interval : retransmission) {
QuicStreamOffset retransmission_offset = interval.min();
QuicByteCount retransmission_length = interval.max() - interval.min();
const bool can_bundle_fin =
retransmit_fin &&
(retransmission_offset + retransmission_length == state.bytes_sent);
if (QuicUtils::IsCryptoStreamId(connection_->transport_version(),
frame.stream_frame.stream_id)) {
// Set appropriate encryption level for crypto stream.
connection_->SetDefaultEncryptionLevel(retransmission_encryption_level);
}
consumed = connection_->SendStreamData(
frame.stream_frame.stream_id, retransmission_length,
retransmission_offset, can_bundle_fin ? FIN : NO_FIN);
QUIC_DVLOG(1) << "stream " << frame.stream_frame.stream_id
<< " is forced to retransmit stream data ["
<< retransmission_offset << ", "
<< retransmission_offset + retransmission_length
<< ") and fin: " << can_bundle_fin
<< ", consumed: " << consumed;
if (can_bundle_fin) {
retransmit_fin = !consumed.fin_consumed;
}
if (QuicUtils::IsCryptoStreamId(connection_->transport_version(),
frame.stream_frame.stream_id)) {
// Restore encryption level.
connection_->SetDefaultEncryptionLevel(current_encryption_level);
}
if (consumed.bytes_consumed < retransmission_length ||
(can_bundle_fin && !consumed.fin_consumed)) {
// Connection is write blocked.
return;
}
}
if (retransmit_fin) {
QUIC_DVLOG(1) << "stream " << frame.stream_frame.stream_id
<< " retransmits fin only frame.";
consumed = connection_->SendStreamData(frame.stream_frame.stream_id, 0,
state.bytes_sent, FIN);
}
}
}
bool SimpleSessionNotifier::IsFrameOutstanding(const QuicFrame& frame) const {
if (frame.type == CRYPTO_FRAME) {
QuicStreamOffset offset = frame.crypto_frame->offset;
QuicByteCount data_length = frame.crypto_frame->data_length;
bool ret = data_length > 0 &&
!crypto_state_[frame.crypto_frame->level].bytes_acked.Contains(
offset, offset + data_length);
return ret;
}
if (frame.type != STREAM_FRAME) {
return IsControlFrameOutstanding(frame);
}
if (!QuicContainsKey(stream_map_, frame.stream_frame.stream_id)) {
return false;
}
const auto& state = stream_map_.find(frame.stream_frame.stream_id)->second;
QuicStreamOffset offset = frame.stream_frame.offset;
QuicByteCount data_length = frame.stream_frame.data_length;
return (data_length > 0 &&
!state.bytes_acked.Contains(offset, offset + data_length)) ||
(frame.stream_frame.fin && state.fin_outstanding);
}
bool SimpleSessionNotifier::HasUnackedCryptoData() const {
if (QuicVersionUsesCryptoFrames(connection_->transport_version())) {
for (size_t i = 0; i < NUM_ENCRYPTION_LEVELS; ++i) {
const StreamState& state = crypto_state_[i];
if (state.bytes_total > state.bytes_sent) {
return true;
}
QuicIntervalSet<QuicStreamOffset> bytes_to_ack(0, state.bytes_total);
bytes_to_ack.Difference(state.bytes_acked);
if (!bytes_to_ack.Empty()) {
return true;
}
}
return false;
}
if (!QuicContainsKey(stream_map_, QuicUtils::GetCryptoStreamId(
connection_->transport_version()))) {
return false;
}
const auto& state =
stream_map_
.find(QuicUtils::GetCryptoStreamId(connection_->transport_version()))
->second;
if (state.bytes_total > state.bytes_sent) {
return true;
}
QuicIntervalSet<QuicStreamOffset> bytes_to_ack(0, state.bytes_total);
bytes_to_ack.Difference(state.bytes_acked);
return !bytes_to_ack.Empty();
}
bool SimpleSessionNotifier::OnControlFrameAcked(const QuicFrame& frame) {
QuicControlFrameId id = GetControlFrameId(frame);
if (id == kInvalidControlFrameId) {
return false;
}
DCHECK(id < least_unacked_ + control_frames_.size());
if (id < least_unacked_ ||
GetControlFrameId(control_frames_.at(id - least_unacked_)) ==
kInvalidControlFrameId) {
return false;
}
SetControlFrameId(kInvalidControlFrameId,
&control_frames_.at(id - least_unacked_));
lost_control_frames_.erase(id);
while (!control_frames_.empty() &&
GetControlFrameId(control_frames_.front()) == kInvalidControlFrameId) {
DeleteFrame(&control_frames_.front());
control_frames_.pop_front();
++least_unacked_;
}
return true;
}
void SimpleSessionNotifier::OnControlFrameLost(const QuicFrame& frame) {
QuicControlFrameId id = GetControlFrameId(frame);
if (id == kInvalidControlFrameId) {
return;
}
DCHECK(id < least_unacked_ + control_frames_.size());
if (id < least_unacked_ ||
GetControlFrameId(control_frames_.at(id - least_unacked_)) ==
kInvalidControlFrameId) {
return;
}
if (!QuicContainsKey(lost_control_frames_, id)) {
lost_control_frames_[id] = true;
}
}
bool SimpleSessionNotifier::IsControlFrameOutstanding(
const QuicFrame& frame) const {
QuicControlFrameId id = GetControlFrameId(frame);
if (id == kInvalidControlFrameId) {
return false;
}
return id < least_unacked_ + control_frames_.size() && id >= least_unacked_ &&
GetControlFrameId(control_frames_.at(id - least_unacked_)) !=
kInvalidControlFrameId;
}
bool SimpleSessionNotifier::RetransmitLostControlFrames() {
while (!lost_control_frames_.empty()) {
QuicFrame pending = control_frames_.at(lost_control_frames_.begin()->first -
least_unacked_);
QuicFrame copy = CopyRetransmittableControlFrame(pending);
connection_->SetTransmissionType(LOSS_RETRANSMISSION);
if (!connection_->SendControlFrame(copy)) {
// Connection is write blocked.
DeleteFrame(©);
break;
}
lost_control_frames_.pop_front();
}
return lost_control_frames_.empty();
}
bool SimpleSessionNotifier::RetransmitLostCryptoData() {
if (QuicVersionUsesCryptoFrames(connection_->transport_version())) {
for (EncryptionLevel level :
{ENCRYPTION_INITIAL, ENCRYPTION_HANDSHAKE, ENCRYPTION_ZERO_RTT,
ENCRYPTION_FORWARD_SECURE}) {
auto& state = crypto_state_[level];
while (!state.pending_retransmissions.Empty()) {
connection_->SetTransmissionType(HANDSHAKE_RETRANSMISSION);
EncryptionLevel current_encryption_level =
connection_->encryption_level();
connection_->SetDefaultEncryptionLevel(level);
QuicIntervalSet<QuicStreamOffset> retransmission(
state.pending_retransmissions.begin()->min(),
state.pending_retransmissions.begin()->max());
retransmission.Intersection(crypto_bytes_transferred_[level]);
QuicStreamOffset retransmission_offset = retransmission.begin()->min();
QuicByteCount retransmission_length =
retransmission.begin()->max() - retransmission.begin()->min();
size_t bytes_consumed = connection_->SendCryptoData(
level, retransmission_length, retransmission_offset);
// Restore encryption level.
connection_->SetDefaultEncryptionLevel(current_encryption_level);
state.pending_retransmissions.Difference(
retransmission_offset, retransmission_offset + bytes_consumed);
if (bytes_consumed < retransmission_length) {
return false;
}
}
}
return true;
}
if (!QuicContainsKey(stream_map_, QuicUtils::GetCryptoStreamId(
connection_->transport_version()))) {
return true;
}
auto& state =
stream_map_
.find(QuicUtils::GetCryptoStreamId(connection_->transport_version()))
->second;
while (!state.pending_retransmissions.Empty()) {
connection_->SetTransmissionType(HANDSHAKE_RETRANSMISSION);
QuicIntervalSet<QuicStreamOffset> retransmission(
state.pending_retransmissions.begin()->min(),
state.pending_retransmissions.begin()->max());
EncryptionLevel retransmission_encryption_level = ENCRYPTION_INITIAL;
for (size_t i = 0; i < NUM_ENCRYPTION_LEVELS; ++i) {
if (retransmission.Intersects(crypto_bytes_transferred_[i])) {
retransmission_encryption_level = static_cast<EncryptionLevel>(i);
retransmission.Intersection(crypto_bytes_transferred_[i]);
break;
}
}
QuicStreamOffset retransmission_offset = retransmission.begin()->min();
QuicByteCount retransmission_length =
retransmission.begin()->max() - retransmission.begin()->min();
EncryptionLevel current_encryption_level = connection_->encryption_level();
// Set appropriate encryption level.
connection_->SetDefaultEncryptionLevel(retransmission_encryption_level);
QuicConsumedData consumed = connection_->SendStreamData(
QuicUtils::GetCryptoStreamId(connection_->transport_version()),
retransmission_length, retransmission_offset, NO_FIN);
// Restore encryption level.
connection_->SetDefaultEncryptionLevel(current_encryption_level);
state.pending_retransmissions.Difference(
retransmission_offset, retransmission_offset + consumed.bytes_consumed);
if (consumed.bytes_consumed < retransmission_length) {
break;
}
}
return state.pending_retransmissions.Empty();
}
bool SimpleSessionNotifier::RetransmitLostStreamData() {
for (auto& pair : stream_map_) {
StreamState& state = pair.second;
QuicConsumedData consumed(0, false);
while (!state.pending_retransmissions.Empty() || state.fin_lost) {
connection_->SetTransmissionType(LOSS_RETRANSMISSION);
if (state.pending_retransmissions.Empty()) {
QUIC_DVLOG(1) << "stream " << pair.first
<< " retransmits fin only frame.";
consumed =
connection_->SendStreamData(pair.first, 0, state.bytes_sent, FIN);
state.fin_lost = !consumed.fin_consumed;
if (state.fin_lost) {
QUIC_DLOG(INFO) << "Connection is write blocked";
return false;
}
} else {
QuicStreamOffset offset = state.pending_retransmissions.begin()->min();
QuicByteCount length = state.pending_retransmissions.begin()->max() -
state.pending_retransmissions.begin()->min();
const bool can_bundle_fin =
state.fin_lost && (offset + length == state.bytes_sent);
consumed = connection_->SendStreamData(pair.first, length, offset,
can_bundle_fin ? FIN : NO_FIN);
QUIC_DVLOG(1) << "stream " << pair.first
<< " tries to retransmit stream data [" << offset << ", "
<< offset + length << ") and fin: " << can_bundle_fin
<< ", consumed: " << consumed;
state.pending_retransmissions.Difference(
offset, offset + consumed.bytes_consumed);
if (consumed.fin_consumed) {
state.fin_lost = false;
}
if (length > consumed.bytes_consumed ||
(can_bundle_fin && !consumed.fin_consumed)) {
QUIC_DVLOG(1) << "Connection is write blocked";
break;
}
}
}
}
return !HasLostStreamData();
}
bool SimpleSessionNotifier::WriteBufferedControlFrames() {
while (HasBufferedControlFrames()) {
QuicFrame frame_to_send =
control_frames_.at(least_unsent_ - least_unacked_);
QuicFrame copy = CopyRetransmittableControlFrame(frame_to_send);
connection_->SetTransmissionType(NOT_RETRANSMISSION);
if (!connection_->SendControlFrame(copy)) {
// Connection is write blocked.
DeleteFrame(©);
break;
}
++least_unsent_;
}
return !HasBufferedControlFrames();
}
bool SimpleSessionNotifier::HasBufferedControlFrames() const {
return least_unsent_ < least_unacked_ + control_frames_.size();
}
bool SimpleSessionNotifier::HasBufferedStreamData() const {
for (const auto& pair : stream_map_) {
const auto& state = pair.second;
if (state.bytes_total > state.bytes_sent ||
(state.fin_buffered && !state.fin_sent)) {
return true;
}
}
return false;
}
bool SimpleSessionNotifier::StreamIsWaitingForAcks(QuicStreamId id) const {
if (!QuicContainsKey(stream_map_, id)) {
return false;
}
const StreamState& state = stream_map_.find(id)->second;
return !state.bytes_acked.Contains(0, state.bytes_sent) ||
state.fin_outstanding;
}
bool SimpleSessionNotifier::StreamHasBufferedData(QuicStreamId id) const {
if (!QuicContainsKey(stream_map_, id)) {
return false;
}
const StreamState& state = stream_map_.find(id)->second;
return state.bytes_total > state.bytes_sent ||
(state.fin_buffered && !state.fin_sent);
}
bool SimpleSessionNotifier::HasLostStreamData() const {
for (const auto& pair : stream_map_) {
const auto& state = pair.second;
if (!state.pending_retransmissions.Empty() || state.fin_lost) {
return true;
}
}
return false;
}
} // namespace test
} // namespace quic
| [
"arnaud@geometry.ee"
] | arnaud@geometry.ee |
7dc2d640b65f2328e78a0077f269481d93f3b413 | 0d932614bc73fe618c7c061e6e14932da69d90a3 | /Temp/il2cppOutput/il2cppOutput/mscorlib18.cpp | a965b17057a9f0bb79c5a301a97666e77b274d05 | [] | no_license | Fhleux/Fps-Unity-VR | d5d87baa9809c45c10291c94aae17213b9bc5484 | 8113b0abc61b4da2db420dd00b109a2860f4834b | refs/heads/master | 2020-05-25T16:31:32.220015 | 2019-05-24T16:13:31 | 2019-05-24T16:13:31 | 187,886,745 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 956,047 | cpp | #include "il2cpp-config.h"
#ifndef _MSC_VER
# include <alloca.h>
#else
# include <malloc.h>
#endif
#include <cstring>
#include <string.h>
#include <stdio.h>
#include <cmath>
#include <limits>
#include <assert.h>
#include <stdint.h>
#include "codegen/il2cpp-codegen.h"
#include "icalls/mscorlib/System/TypedReference.h"
#include "icalls/mscorlib/System/ValueType.h"
#include "il2cpp-object-internals.h"
template <typename R>
struct VirtFuncInvoker0
{
typedef R (*Func)(void*, const RuntimeMethod*);
static inline R Invoke (Il2CppMethodSlot slot, RuntimeObject* obj)
{
const VirtualInvokeData& invokeData = il2cpp_codegen_get_virtual_invoke_data(slot, obj);
return ((Func)invokeData.methodPtr)(obj, invokeData.method);
}
};
template <typename R, typename T1, typename T2, typename T3>
struct VirtFuncInvoker3
{
typedef R (*Func)(void*, T1, T2, T3, const RuntimeMethod*);
static inline R Invoke (Il2CppMethodSlot slot, RuntimeObject* obj, T1 p1, T2 p2, T3 p3)
{
const VirtualInvokeData& invokeData = il2cpp_codegen_get_virtual_invoke_data(slot, obj);
return ((Func)invokeData.methodPtr)(obj, p1, p2, p3, invokeData.method);
}
};
template <typename R, typename T1, typename T2>
struct VirtFuncInvoker2
{
typedef R (*Func)(void*, T1, T2, const RuntimeMethod*);
static inline R Invoke (Il2CppMethodSlot slot, RuntimeObject* obj, T1 p1, T2 p2)
{
const VirtualInvokeData& invokeData = il2cpp_codegen_get_virtual_invoke_data(slot, obj);
return ((Func)invokeData.methodPtr)(obj, p1, p2, invokeData.method);
}
};
template <typename R, typename T1>
struct VirtFuncInvoker1
{
typedef R (*Func)(void*, T1, const RuntimeMethod*);
static inline R Invoke (Il2CppMethodSlot slot, RuntimeObject* obj, T1 p1)
{
const VirtualInvokeData& invokeData = il2cpp_codegen_get_virtual_invoke_data(slot, obj);
return ((Func)invokeData.methodPtr)(obj, p1, invokeData.method);
}
};
template <typename T1>
struct VirtActionInvoker1
{
typedef void (*Action)(void*, T1, const RuntimeMethod*);
static inline void Invoke (Il2CppMethodSlot slot, RuntimeObject* obj, T1 p1)
{
const VirtualInvokeData& invokeData = il2cpp_codegen_get_virtual_invoke_data(slot, obj);
((Action)invokeData.methodPtr)(obj, p1, invokeData.method);
}
};
template <typename T1, typename T2>
struct VirtActionInvoker2
{
typedef void (*Action)(void*, T1, T2, const RuntimeMethod*);
static inline void Invoke (Il2CppMethodSlot slot, RuntimeObject* obj, T1 p1, T2 p2)
{
const VirtualInvokeData& invokeData = il2cpp_codegen_get_virtual_invoke_data(slot, obj);
((Action)invokeData.methodPtr)(obj, p1, p2, invokeData.method);
}
};
template <typename R, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7>
struct VirtFuncInvoker7
{
typedef R (*Func)(void*, T1, T2, T3, T4, T5, T6, T7, const RuntimeMethod*);
static inline R Invoke (Il2CppMethodSlot slot, RuntimeObject* obj, T1 p1, T2 p2, T3 p3, T4 p4, T5 p5, T6 p6, T7 p7)
{
const VirtualInvokeData& invokeData = il2cpp_codegen_get_virtual_invoke_data(slot, obj);
return ((Func)invokeData.methodPtr)(obj, p1, p2, p3, p4, p5, p6, p7, invokeData.method);
}
};
template <typename T1>
struct GenericVirtActionInvoker1
{
typedef void (*Action)(void*, T1, const RuntimeMethod*);
static inline void Invoke (const RuntimeMethod* method, RuntimeObject* obj, T1 p1)
{
VirtualInvokeData invokeData;
il2cpp_codegen_get_generic_virtual_invoke_data(method, obj, &invokeData);
((Action)invokeData.methodPtr)(obj, p1, invokeData.method);
}
};
template <typename T1, typename T2>
struct GenericVirtActionInvoker2
{
typedef void (*Action)(void*, T1, T2, const RuntimeMethod*);
static inline void Invoke (const RuntimeMethod* method, RuntimeObject* obj, T1 p1, T2 p2)
{
VirtualInvokeData invokeData;
il2cpp_codegen_get_generic_virtual_invoke_data(method, obj, &invokeData);
((Action)invokeData.methodPtr)(obj, p1, p2, invokeData.method);
}
};
template <typename 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 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 T1, typename T2>
struct InterfaceActionInvoker2
{
typedef void (*Action)(void*, T1, T2, const RuntimeMethod*);
static inline void Invoke (Il2CppMethodSlot slot, RuntimeClass* declaringInterface, RuntimeObject* obj, T1 p1, T2 p2)
{
const VirtualInvokeData& invokeData = il2cpp_codegen_get_interface_invoke_data(slot, obj, declaringInterface);
((Action)invokeData.methodPtr)(obj, p1, p2, invokeData.method);
}
};
template <typename T1>
struct GenericInterfaceActionInvoker1
{
typedef void (*Action)(void*, T1, const RuntimeMethod*);
static inline void Invoke (const RuntimeMethod* method, RuntimeObject* obj, T1 p1)
{
VirtualInvokeData invokeData;
il2cpp_codegen_get_generic_interface_invoke_data(method, obj, &invokeData);
((Action)invokeData.methodPtr)(obj, p1, invokeData.method);
}
};
template <typename T1, typename T2>
struct GenericInterfaceActionInvoker2
{
typedef void (*Action)(void*, T1, T2, const RuntimeMethod*);
static inline void Invoke (const RuntimeMethod* method, RuntimeObject* obj, T1 p1, T2 p2)
{
VirtualInvokeData invokeData;
il2cpp_codegen_get_generic_interface_invoke_data(method, obj, &invokeData);
((Action)invokeData.methodPtr)(obj, p1, p2, invokeData.method);
}
};
// Mono.Globalization.Unicode.SimpleCollator
struct SimpleCollator_tC3A1720B7D3D850D5C23BE8E366D821EBA923D89;
// System.ArgumentException
struct ArgumentException_tEDCD16F20A09ECE461C3DA766C16EDA8864057D1;
// System.ArgumentNullException
struct ArgumentNullException_t581DF992B1F3E0EC6EFB30CC5DC43519A79B27AD;
// System.ArgumentOutOfRangeException
struct ArgumentOutOfRangeException_t94D19DF918A54511AEDF4784C9A08741BAD1DEDA;
// System.ArraySpec
struct ArraySpec_tF374BB8994F7190916C6F14C7EA8FE6EFE017970;
// System.AsyncCallback
struct AsyncCallback_t3F3DA3BEDAEE81DD1D24125DF8EB30E85EE14DA4;
// System.Byte[]
struct ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821;
// System.Char
struct Char_tBF22D9FC341BE970735250BB6FF1A4A92BBA58B9;
// System.Char[]
struct CharU5BU5D_t4CC6ABF0AD71BEC97E3C2F1E9C5677E46D3A75C2;
// System.Collections.Generic.Dictionary`2<System.Int32,System.Globalization.CultureInfo>
struct Dictionary_2_tC88A56872F7C79DBB9582D4F3FC22ED5D8E0B98B;
// System.Collections.Generic.Dictionary`2<System.String,Mono.Globalization.Unicode.SimpleCollator>
struct Dictionary_2_t61B96E9258C1E296057BCD8C4D2015846D2BB8F3;
// System.Collections.Generic.Dictionary`2<System.String,System.Globalization.CultureInfo>
struct Dictionary_2_tBA5388DBB42BF620266F9A48E8B859BBBB224E25;
// System.Collections.Generic.Dictionary`2<System.String,System.Int32>
struct Dictionary_2_tD6E204872BA9FD506A0287EF68E285BEB9EC0DFB;
// System.Collections.Generic.List`1<System.Int32>
struct List_1_tE1526161A558A17A39A8B69D8EEF3801393B6226;
// System.Collections.Generic.List`1<System.ModifierSpec>
struct List_1_tFD995FD9C5961BB4B415EE63B297C4B19643A3C2;
// System.Collections.Generic.List`1<System.Object>
struct List_1_t05CC3C859AB5E6024394EF9A42E3E696628CA02D;
// System.Collections.Generic.List`1<System.TypeIdentifier>
struct List_1_tB8129EB4ADDDECD38E3E178F0A902C921B575166;
// System.Collections.Generic.List`1<System.TypeSpec>
struct List_1_t8C8BF378AAB72B34B6EE63F686877AE7290ECFBA;
// System.Collections.Hashtable
struct Hashtable_t978F65B8006C8F5504B286526AEC6608FF983FC9;
// System.Collections.IComparer
struct IComparer_t6A5E1BC727C7FF28888E407A797CE1ED92DA8E95;
// System.Collections.IDictionary
struct IDictionary_t1BD5C1546718A374EA8122FBD6C6EE45331E8CE7;
// System.Collections.IEqualityComparer
struct IEqualityComparer_t3102D0F5BABD60224F6DFF4815BCA1045831FB7C;
// System.Delegate
struct Delegate_t;
// System.DelegateData
struct DelegateData_t1BF9F691B56DAE5F8C28C5E084FDE94F15F27BBE;
// System.Delegate[]
struct DelegateU5BU5D_tDFCDEE2A6322F96C0FE49AF47E9ADB8C4B294E86;
// System.Diagnostics.StackTrace[]
struct StackTraceU5BU5D_t855F09649EA34DEE7C1B6F088E0538E3CCC3F196;
// System.EventArgs
struct EventArgs_t8E6CA180BE0E56674C6407011A94BAF7C757352E;
// System.Exception
struct Exception_t;
// System.Func`2<System.Object,System.Object>
struct Func_2_tE9A60F007AC624EA27BF19DEF4242B7DA2F1C2A4;
// System.Func`2<System.Reflection.AssemblyName,System.Reflection.Assembly>
struct Func_2_t13827C9725E0D12567E029E178981FB7D0E13430;
// System.Func`4<System.Object,System.Object,System.Boolean,System.Object>
struct Func_4_tBDBA893DF2D6BD3ADD95FBC243F607CECF2077B0;
// System.Func`4<System.Reflection.Assembly,System.String,System.Boolean,System.Type>
struct Func_4_t3D7857A2A0F731D1E992FC5B09E983A8621FABFF;
// System.Globalization.Calendar
struct Calendar_tF55A785ACD277504CF0D2F2C6AD56F76C6E91BD5;
// System.Globalization.CompareInfo
struct CompareInfo_tB9A071DBC11AC00AF2EA2066D0C2AE1DCB1865D1;
// System.Globalization.CultureData
struct CultureData_tF43B080FFA6EB278F4F289BCDA3FB74B6C208ECD;
// System.Globalization.CultureInfo
struct CultureInfo_t345AC6924134F039ED9A11F3E03F8E91B6A3225F;
// System.Globalization.DateTimeFormatInfo
struct DateTimeFormatInfo_tF4BB3AA482C2F772D2A9022F78BF8727830FAF5F;
// System.Globalization.NumberFormatInfo
struct NumberFormatInfo_tFDF57037EBC5BC833D0A53EF0327B805994860A8;
// System.Globalization.SortVersion
struct SortVersion_tE7080CE09A0B8CE226F8046C0D1374DD0A0CAE71;
// System.Globalization.TextInfo
struct TextInfo_t5F1E697CB6A7E5EC80F0DC3A968B9B4A70C291D8;
// System.Globalization.TokenHashValue[]
struct TokenHashValueU5BU5D_t5C8B41D89122FC1D3ED53C946C2656DA03CE899A;
// System.IAsyncResult
struct IAsyncResult_t8E194308510B375B42432981AE5E7488C458D598;
// System.IConvertible
struct IConvertible_tB52671A602A64FCCFD27EA5817E2A6C2B693D380;
// System.IFormatProvider
struct IFormatProvider_t4247E13AE2D97A079B88D594B7ABABF313259901;
// System.IO.FileNotFoundException
struct FileNotFoundException_t0B3F0AE5C94A781A7E2ABBD786F91C229B703431;
// System.IndexOutOfRangeException
struct IndexOutOfRangeException_tEC7665FC66525AB6A6916A7EB505E5591683F0CF;
// System.InputRecord
struct InputRecord_tAB007C739F339BE208F3C4796B53E9044ADF0A78;
// System.Int32[]
struct Int32U5BU5D_t2B9E4FDDDB9F0A00EC0AC631BA2DA915EB1ECF83;
// System.IntPtr[]
struct IntPtrU5BU5D_t4DC01DCB9A6DF6C9792A6513595D7A11E637DCDD;
// System.InvalidCastException
struct InvalidCastException_t91DF9E7D7FCCDA6C562CB4A9A18903E016680FDA;
// System.InvalidOperationException
struct InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1;
// System.LocalDataStoreHolder
struct LocalDataStoreHolder_tE0636E08496405406FD63190AC51EEB2EE51E304;
// System.LocalDataStoreMgr
struct LocalDataStoreMgr_t1964DDB9F2BE154BE3159A7507D0D0CCBF8FDCA9;
// System.MissingMemberException
struct MissingMemberException_t165349A7E04FC51DAA5C2251C6DCDD2DD60255DD;
// System.ModifierSpec
struct ModifierSpec_t0A5286DDFBD682F1E1D8AEBE5FD9D34EAB4CF1E5;
// System.ModifierSpec[]
struct ModifierSpecU5BU5D_tAEF81765D168567C7F55496AB5F6C43084E398C7;
// System.MonoTypeInfo
struct MonoTypeInfo_t9A65BA5324D14FDFEB7644EEE6E1BDF74B8A393D;
// System.MulticastDelegate
struct MulticastDelegate_t;
// System.NotImplementedException
struct NotImplementedException_t8AD6EBE5FEDB0AEBECEE0961CF73C35B372EFFA4;
// System.NotSupportedException
struct NotSupportedException_tE75B318D6590A02A5D9B29FD97409B1750FA0010;
// System.Object[]
struct ObjectU5BU5D_t3C9242B5C88A48B2A5BD9FDA6CD0024E792AF08A;
// System.OverflowException
struct OverflowException_tD89571E2350DE06D9DE4AB65ADCA77D607B5693D;
// System.PlatformNotSupportedException
struct PlatformNotSupportedException_t14FE109377F8FA8B3B2F9A0C4FE3BF10662C73B5;
// System.PointerSpec
struct PointerSpec_tBCE1666DC24EC6E4E5376FEC214499984EC26892;
// System.Reflection.Assembly
struct Assembly_t;
// System.Reflection.Assembly/ResolveEventHolder
struct ResolveEventHolder_t5267893EB7CB9C12F7B9B463FD4C221BEA03326E;
// System.Reflection.AssemblyName
struct AssemblyName_t6F3EC58113268060348EE894DCB46F6EF6BBBB82;
// System.Reflection.Binder
struct Binder_t4D5CB06963501D32847C057B57157D6DC49CA759;
// System.Reflection.FieldInfo
struct FieldInfo_t;
// System.Reflection.FieldInfo[]
struct FieldInfoU5BU5D_t9C36FA93372CA01DAF85946064B058CD9CE2E8BE;
// System.Reflection.InvalidFilterCriteriaException
struct InvalidFilterCriteriaException_tB11C87F151CD79ACA0837773B9BFD8791CA715BA;
// System.Reflection.MemberFilter
struct MemberFilter_t25C1BD92C42BE94426E300787C13C452CB89B381;
// System.Reflection.MemberInfo
struct MemberInfo_t;
// System.Reflection.MethodBase
struct MethodBase_t;
// System.Reflection.MethodInfo
struct MethodInfo_t;
// System.Reflection.Missing
struct Missing_t81434A5DBDCCA844BD22E1659DDE1EE7DE8B4ED7;
// System.Reflection.Module
struct Module_t882FB0C491B9CD194BE7CD1AC62FEFB31EEBE5D7;
// System.Reflection.RuntimeAssembly
struct RuntimeAssembly_t5EE9CD749D82345AE5635B9665665C31A3308EB1;
// System.Reflection.RuntimeConstructorInfo
struct RuntimeConstructorInfo_tF21A59967629968D0BE5D0DAF677662824E9629D;
// System.Reflection.RuntimeFieldInfo
struct RuntimeFieldInfo_t9C8BA644F857EBE60EC6587AE1C1148E420E66F7;
// System.Reflection.StrongNameKeyPair
struct StrongNameKeyPair_tD9AA282E59F4526338781AFD862680ED461FCCFD;
// System.Reflection.TypeFilter
struct TypeFilter_t30BB04A68BC9FB949345457F71A9648BDB67FF18;
// System.Runtime.Serialization.IFormatterConverter
struct IFormatterConverter_tC3280D64D358F47EA4DAF1A65609BA0FC081888A;
// System.Runtime.Serialization.SafeSerializationManager
struct SafeSerializationManager_t4A754D86B0F784B18CBC36C073BA564BED109770;
// System.Runtime.Serialization.SerializationException
struct SerializationException_tA1FDFF6779406E688C2192E71C38DBFD7A4A2210;
// System.Runtime.Serialization.SerializationInfo
struct SerializationInfo_t1BB80E9C9DEA52DBF464487234B045E2930ADA26;
// System.RuntimeType
struct RuntimeType_t40F13BCEAD97478C72C4B40BFDC2A220161CDB8F;
// System.Security.Principal.IPrincipal
struct IPrincipal_t63FD7F58FBBE134C8FE4D31710AAEA00B000F0BF;
// System.String
struct String_t;
// System.String[]
struct StringU5BU5D_t933FB07893230EA91C40FF900D5400665E87B14E;
// System.SystemException
struct SystemException_t5380468142AA850BE4A341D7AF3EAB9C78746782;
// System.Text.StringBuilder
struct StringBuilder_t;
// System.Threading.AsyncLocal`1<System.Globalization.CultureInfo>
struct AsyncLocal_1_tD39651C2EDD14B144FF3D9B9C716F807EB57655A;
// System.Threading.ExecutionContext
struct ExecutionContext_t0E11C30308A4CC964D8A2EA9132F9BDCE5362C70;
// System.Threading.InternalThread
struct InternalThread_tA4C58C2A7D15AF43C3E7507375E6D31DBBE7D192;
// System.Threading.Thread
struct Thread_tF60E0A146CD3B5480CB65FF9B6016E84C5460CC7;
// System.Type
struct Type_t;
// System.TypeIdentifier
struct TypeIdentifier_tEF8C0B5CA8B33CD2A732C822D0B9BD62B8DA2F12;
// System.TypeIdentifier[]
struct TypeIdentifierU5BU5D_t95E17776299DF69C41AE3200141420FF69ADB766;
// System.TypeIdentifiers/Display
struct Display_t0222D7CB4CF0F85131FC5E26328FE94E0A27F5E5;
// System.TypeInitializationException
struct TypeInitializationException_t5223A07113C97D6DC875A82C68D4C132737ADEAE;
// System.TypeLoadException
struct TypeLoadException_t510963B29CB27C6EA3ACDF5FB76E72E1BC372CD1;
// System.TypeName
struct TypeName_t0C63929669D92B034691B7E78AF79FA1F8592513;
// System.TypeNames/ATypeName
struct ATypeName_t8FD4A465E3C2846D11FEAE25ED5BF3D67FF94421;
// System.TypeSpec
struct TypeSpec_t943289F7C537252144A22588159B36C6B6759A7F;
// System.TypeSpec[]
struct TypeSpecU5BU5D_t9767F25128C75FBAC1A17F15DFC9ACA4105B37DF;
// System.Type[]
struct TypeU5BU5D_t7FE623A666B49176DE123306221193E888A12F5F;
// System.UInt32[]
struct UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB;
// System.UnauthorizedAccessException
struct UnauthorizedAccessException_tC2210A745BFDD3AE3559A87A4219E2945EEC9F75;
// System.UnhandledExceptionEventArgs
struct UnhandledExceptionEventArgs_t39DD47D43B0D764FE2C9847FBE760031FBEA0FD1;
// System.UnhandledExceptionEventHandler
struct UnhandledExceptionEventHandler_tB0DFF05ABF7A3A234C87D4F7A71F98E9AB2D91DE;
// System.UnitySerializationHolder
struct UnitySerializationHolder_t6B17ABB985ACD3F8D9F9E3C146DEA5F730E1CEAC;
// System.ValueType
struct ValueType_t4D0C27076F7C36E76190FB3328E232BCB1CD1FFF;
// System.Version
struct Version_tDBE6876C59B6F56D4F8CAA03851177ABC6FE0DFD;
// System.Void
struct Void_t22962CB4C05B1D89B55A6E1139F0E87A90987017;
// System.WeakReference
struct WeakReference_t0495CC81CD6403E662B7700B802443F6F730E39D;
// System.WindowsConsoleDriver
struct WindowsConsoleDriver_t953AB92956013BD3ED7E260FEC4944E603008B42;
// System.__ComObject
struct __ComObject_t7C4C78B18A827C344A9826ECC7FCC40B7F6FD77C;
// System.__Filters
struct __Filters_tDD9D6B7C7A31B12AB3D5CCF1B115DD693F62DB34;
// System.__Il2CppComDelegate
struct __Il2CppComDelegate_t0A30496F74225C39A0CF7FADB94934C0536120FD;
// System.__Il2CppComObject
struct Il2CppComObject;
IL2CPP_EXTERN_C RuntimeClass* ArgumentException_tEDCD16F20A09ECE461C3DA766C16EDA8864057D1_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C RuntimeClass* ArgumentNullException_t581DF992B1F3E0EC6EFB30CC5DC43519A79B27AD_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C RuntimeClass* ArgumentOutOfRangeException_t94D19DF918A54511AEDF4784C9A08741BAD1DEDA_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C RuntimeClass* ArraySpec_tF374BB8994F7190916C6F14C7EA8FE6EFE017970_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C RuntimeClass* AssemblyName_t6F3EC58113268060348EE894DCB46F6EF6BBBB82_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C RuntimeClass* CharU5BU5D_t4CC6ABF0AD71BEC97E3C2F1E9C5677E46D3A75C2_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C RuntimeClass* Char_tBF22D9FC341BE970735250BB6FF1A4A92BBA58B9_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C RuntimeClass* ConstructorInfo_t9CB51BFC178DF1CBCA5FD16B2D58229618F23EFF_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C RuntimeClass* Convert_t1C7A851BFB2F0782FD7F72F6AA1DCBB7B53A9C7E_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C RuntimeClass* CultureInfo_t345AC6924134F039ED9A11F3E03F8E91B6A3225F_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C RuntimeClass* DBNull_t7400E04939C2C29699B389B106997892BF53A8E5_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C RuntimeClass* DateTimeParse_t657E38D9FF27E5FD6A33E23887031A86248D97D4_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C RuntimeClass* Display_t0222D7CB4CF0F85131FC5E26328FE94E0A27F5E5_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C RuntimeClass* Empty_t31C7ECDF7D102AFFCE029D8AB11D8595F0316ED2_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C RuntimeClass* EventArgs_t8E6CA180BE0E56674C6407011A94BAF7C757352E_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C RuntimeClass* Exception_t_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C RuntimeClass* FieldInfo_t_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C RuntimeClass* FileNotFoundException_t0B3F0AE5C94A781A7E2ABBD786F91C229B703431_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C RuntimeClass* HashHelpers_tDC6BF33BEF3A798515BA62BA704DD83AEBFA9C33_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C RuntimeClass* IndexOutOfRangeException_tEC7665FC66525AB6A6916A7EB505E5591683F0CF_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C RuntimeClass* Int32U5BU5D_t2B9E4FDDDB9F0A00EC0AC631BA2DA915EB1ECF83_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C RuntimeClass* Int32_t585191389E07734F19F3156FF88FB3EF4800D102_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C RuntimeClass* IntPtrU5BU5D_t4DC01DCB9A6DF6C9792A6513595D7A11E637DCDD_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C RuntimeClass* IntPtr_t_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C RuntimeClass* InvalidCastException_t91DF9E7D7FCCDA6C562CB4A9A18903E016680FDA_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C RuntimeClass* InvalidFilterCriteriaException_tB11C87F151CD79ACA0837773B9BFD8791CA715BA_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C RuntimeClass* InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C RuntimeClass* List_1_t8C8BF378AAB72B34B6EE63F686877AE7290ECFBA_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C RuntimeClass* List_1_tB8129EB4ADDDECD38E3E178F0A902C921B575166_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C RuntimeClass* List_1_tE1526161A558A17A39A8B69D8EEF3801393B6226_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C RuntimeClass* List_1_tFD995FD9C5961BB4B415EE63B297C4B19643A3C2_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C RuntimeClass* Marshal_tC795CE9CC2FFBA41EDB1AC1C0FEC04607DFA8A40_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C RuntimeClass* MethodBase_t_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C RuntimeClass* MethodInfo_t_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C RuntimeClass* MissingMemberException_t165349A7E04FC51DAA5C2251C6DCDD2DD60255DD_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C RuntimeClass* Missing_t81434A5DBDCCA844BD22E1659DDE1EE7DE8B4ED7_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C RuntimeClass* ModifierSpec_t0A5286DDFBD682F1E1D8AEBE5FD9D34EAB4CF1E5_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C RuntimeClass* Module_t882FB0C491B9CD194BE7CD1AC62FEFB31EEBE5D7_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C RuntimeClass* NotImplementedException_t8AD6EBE5FEDB0AEBECEE0961CF73C35B372EFFA4_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C RuntimeClass* NotSupportedException_tE75B318D6590A02A5D9B29FD97409B1750FA0010_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C RuntimeClass* ObjectU5BU5D_t3C9242B5C88A48B2A5BD9FDA6CD0024E792AF08A_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C RuntimeClass* OverflowException_tD89571E2350DE06D9DE4AB65ADCA77D607B5693D_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C RuntimeClass* PlatformNotSupportedException_t14FE109377F8FA8B3B2F9A0C4FE3BF10662C73B5_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C RuntimeClass* PointerSpec_tBCE1666DC24EC6E4E5376FEC214499984EC26892_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C RuntimeClass* RuntimeFieldInfo_t9C8BA644F857EBE60EC6587AE1C1148E420E66F7_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C RuntimeClass* RuntimeObject_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C RuntimeClass* RuntimeType_t40F13BCEAD97478C72C4B40BFDC2A220161CDB8F_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C RuntimeClass* SerializationException_tA1FDFF6779406E688C2192E71C38DBFD7A4A2210_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C RuntimeClass* StringBuilder_t_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C RuntimeClass* String_t_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C RuntimeClass* TypeLoadException_t510963B29CB27C6EA3ACDF5FB76E72E1BC372CD1_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C RuntimeClass* TypeName_t0C63929669D92B034691B7E78AF79FA1F8592513_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C RuntimeClass* TypeSpec_t943289F7C537252144A22588159B36C6B6759A7F_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C RuntimeClass* TypeU5BU5D_t7FE623A666B49176DE123306221193E888A12F5F_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C RuntimeClass* Type_t_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C RuntimeClass* UInt16_tAE45CEF73BF720100519F6867F32145D075F928E_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C RuntimeClass* UInt32_t4980FA09003AFAAB5A6E361BA2748EA9A005709B_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C RuntimeClass* UInt64_tA02DF3B59C8FC4A849BD207DA11038CC64E4CB4E_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C RuntimeClass* UIntPtr_t_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C RuntimeClass* ValueTuple_tC6981F8FD1D7836C91BF332F5F894A8AEEF569D6_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C RuntimeClass* Version_tDBE6876C59B6F56D4F8CAA03851177ABC6FE0DFD_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C RuntimeClass* __DTString_t6E7DE2A99E4F15F384EC29CC6CD5185F46818DD9_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C RuntimeClass* __Filters_tDD9D6B7C7A31B12AB3D5CCF1B115DD693F62DB34_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C String_t* _stringLiteral04C3F2AE89DF36B5CF6D0051651235DA171DFEE7;
IL2CPP_EXTERN_C String_t* _stringLiteral089B0BA8B1E0758ECEBCD291E88238CE548D665D;
IL2CPP_EXTERN_C String_t* _stringLiteral0E8A3AD980EC179856012B7EECF4327E99CD44CD;
IL2CPP_EXTERN_C String_t* _stringLiteral10A53546C08F0C2B88527F528FDD3D15B5959B33;
IL2CPP_EXTERN_C String_t* _stringLiteral163313709722AD7AEFE1D71EECEA06F9FCDFEC2D;
IL2CPP_EXTERN_C String_t* _stringLiteral1653AF59DA2921FD4F1494A7DAD6B7D7FC320C47;
IL2CPP_EXTERN_C String_t* _stringLiteral18C9D4621EF6C3113CE1F960346D7603E88406E8;
IL2CPP_EXTERN_C String_t* _stringLiteral1B6453892473A467D07372D45EB05ABC2031647A;
IL2CPP_EXTERN_C String_t* _stringLiteral1CBD801F805A5FBD3AD0F5E193C36FE40C2BB005;
IL2CPP_EXTERN_C String_t* _stringLiteral1E5FC82CCB72553A236B455041C2CC6D97965017;
IL2CPP_EXTERN_C String_t* _stringLiteral1EBF18F72F75A7724D91ED7167E98A93A6497F6E;
IL2CPP_EXTERN_C String_t* _stringLiteral20FED387605751EEA20B8EDAA265186F0E25C9DD;
IL2CPP_EXTERN_C String_t* _stringLiteral24EC69BAF51BF30190B6C95CBC8DA59798F5F532;
IL2CPP_EXTERN_C String_t* _stringLiteral27BED7455215AA8A8EA1D7944A4975BAA72AA6B6;
IL2CPP_EXTERN_C String_t* _stringLiteral2CF6DC09435066749111F8BD9F5270166FE06F3F;
IL2CPP_EXTERN_C String_t* _stringLiteral2DBCA2328A7A87F4A438EE5BD7F4CE528F0DCD14;
IL2CPP_EXTERN_C String_t* _stringLiteral33370356128AA3B1263898B5524D4D405A01CA5E;
IL2CPP_EXTERN_C String_t* _stringLiteral3886FAAB186277EC9F7FEBBB72CE301AC5E2773C;
IL2CPP_EXTERN_C String_t* _stringLiteral39633794BA5C406D0D71A70F2C47493DB1E986D2;
IL2CPP_EXTERN_C String_t* _stringLiteral3C4D966BBA6CE40E91BAFB95088822186ECB287B;
IL2CPP_EXTERN_C String_t* _stringLiteral3CC14F805C52F5EF488C806DE2DB5C83C5496346;
IL2CPP_EXTERN_C String_t* _stringLiteral3D708CB7F76AF5A68201B998794CB435ACA1B0D5;
IL2CPP_EXTERN_C String_t* _stringLiteral3F90E4D12E77695269D01EC8AAEF48EEF6C79412;
IL2CPP_EXTERN_C String_t* _stringLiteral40CC7C91CEDB85B93D4EACD5B58CD3EED8F78995;
IL2CPP_EXTERN_C String_t* _stringLiteral48E3C7922E67FC100CF2B7A133A26ADCFB2044FE;
IL2CPP_EXTERN_C String_t* _stringLiteral4BECD3F9C90F8D7A184FB632D4DEDA9B5481791D;
IL2CPP_EXTERN_C String_t* _stringLiteral571BFF034952AEEE7E64D932D2A2A51072118F24;
IL2CPP_EXTERN_C String_t* _stringLiteral59BD0A3FF43B32849B319E645D4798D8A5D1E889;
IL2CPP_EXTERN_C String_t* _stringLiteral61E4C2772989AB31A7C2799E5C64D7030B05229C;
IL2CPP_EXTERN_C String_t* _stringLiteral673CD30ADECC250EA8B762ED51852F93E288BB89;
IL2CPP_EXTERN_C String_t* _stringLiteral6769C7D05AE4784134EB90FB28856F9D7D5D581A;
IL2CPP_EXTERN_C String_t* _stringLiteral68EB0192F01DDAA7B81A607B464BC951839404CE;
IL2CPP_EXTERN_C String_t* _stringLiteral6972AB6A4112783DFDFEE444146EB3CF741CCD13;
IL2CPP_EXTERN_C String_t* _stringLiteral698C2F7C87FA878A3D506FEDB570238873872A3C;
IL2CPP_EXTERN_C String_t* _stringLiteral69A99906F5A06EA1BDBFC02E6132D35DE781D3F1;
IL2CPP_EXTERN_C String_t* _stringLiteral6BF0FD54E37B109D934887898BCA5680FCDF70C5;
IL2CPP_EXTERN_C String_t* _stringLiteral70B4BB2684C3F8969E2FE9E14B470906FD4CF3C6;
IL2CPP_EXTERN_C String_t* _stringLiteral77DE68DAECD823BABBB58EDB1C8E14D7106E83BB;
IL2CPP_EXTERN_C String_t* _stringLiteral7D1F754EE65E8FC64F63B1262838D9592369E1F7;
IL2CPP_EXTERN_C String_t* _stringLiteral7E95DB629C3A5AA1BCFEB547A0BD39A78FE49276;
IL2CPP_EXTERN_C String_t* _stringLiteral80754AF91BFB6D1073585B046FE0A474CE868509;
IL2CPP_EXTERN_C String_t* _stringLiteral8110CD10A3C3177EDC45160F406A8FFD951DFD52;
IL2CPP_EXTERN_C String_t* _stringLiteral853ABCEF8465C8AE084B7B61A1A26F39EDB717B5;
IL2CPP_EXTERN_C String_t* _stringLiteral868E70DE0948AAB2E5C3FEF19E1D3C1808994229;
IL2CPP_EXTERN_C String_t* _stringLiteral8B1AF543422B5976D44B9C740EF3CA472E5EF490;
IL2CPP_EXTERN_C String_t* _stringLiteral9037B62BA73A6A3E99186380F4A8BEDFA5D40E1C;
IL2CPP_EXTERN_C String_t* _stringLiteral9B7256A537E36FBE0EFCE164ED58060E7D8F006C;
IL2CPP_EXTERN_C String_t* _stringLiteral9E430F17EB96D796BF49C46584B98C497F8AE559;
IL2CPP_EXTERN_C String_t* _stringLiteral9FA22049CF6367C2DB11AB15BC3EDE8D5104CB06;
IL2CPP_EXTERN_C String_t* _stringLiteralA466EFF47B9A04F03416534E8768A5ED5BC7AFBC;
IL2CPP_EXTERN_C String_t* _stringLiteralA9914DA9D64B4FCE39273016F570714425122C67;
IL2CPP_EXTERN_C String_t* _stringLiteralA9C97EF8AFEE4B1DBDBC6ACD84D8BB932359DE53;
IL2CPP_EXTERN_C String_t* _stringLiteralABFC501D210FA3194339D5355419BE3336C98217;
IL2CPP_EXTERN_C String_t* _stringLiteralAC223DCCCDBCF3FC5FA4ADAE3AB814451427CD3F;
IL2CPP_EXTERN_C String_t* _stringLiteralAD69AC24021D712B02ED72DF3DD0A70E1B01A01B;
IL2CPP_EXTERN_C String_t* _stringLiteralB35BB38DF9605E4C5858316B7853A16E42EA6997;
IL2CPP_EXTERN_C String_t* _stringLiteralB3A8637874FFB852B3B8942459614113859FEE0F;
IL2CPP_EXTERN_C String_t* _stringLiteralB4E34B56A9437FD11B5764C22789947A48B35EA5;
IL2CPP_EXTERN_C String_t* _stringLiteralB6589FC6AB0DC82CF12099D1C2D40AB994E8410C;
IL2CPP_EXTERN_C String_t* _stringLiteralBB589D0621E5472F470FA3425A234C74B1E202E8;
IL2CPP_EXTERN_C String_t* _stringLiteralC10B7D725CE2223CDFE7B945291104E7C0ACE1D9;
IL2CPP_EXTERN_C String_t* _stringLiteralC85C60695430CEA397A21E8BE862BFEA63409E51;
IL2CPP_EXTERN_C String_t* _stringLiteralCAADDB127D0DC4313E5704D5F010772D3AD766ED;
IL2CPP_EXTERN_C String_t* _stringLiteralD0941E68DA8F38151FF86A61FC59F7C5CF9FCAA2;
IL2CPP_EXTERN_C String_t* _stringLiteralD3B81375F999BE146F923A83BD6CBA9441E1F676;
IL2CPP_EXTERN_C String_t* _stringLiteralD3BC9A378DAAA1DDDBA1B19C1AA641D3E9683C46;
IL2CPP_EXTERN_C String_t* _stringLiteralD41884932BDB9E7E6E2E6DB3F0FFD3968A302E6B;
IL2CPP_EXTERN_C String_t* _stringLiteralD98E4C3E01D3ED0C6FD51F3FF6F8A3C9CA9223C3;
IL2CPP_EXTERN_C String_t* _stringLiteralDA4B9237BACCCDF19C0760CAB7AEC4A8359010B0;
IL2CPP_EXTERN_C String_t* _stringLiteralDF7A2F270E0369172CE2F27B621403FE9FEBEF74;
IL2CPP_EXTERN_C String_t* _stringLiteralE31F38791120074366DE542990E5E66B4AEB3A22;
IL2CPP_EXTERN_C String_t* _stringLiteralE364CE10A99220B5DFCBF4821A817898A97E5BCB;
IL2CPP_EXTERN_C String_t* _stringLiteralE52C610014830CF451FCD5BFE6176FFC7E9E5500;
IL2CPP_EXTERN_C String_t* _stringLiteralE5559C91F3F57F398B8B547CA356C67FFA1F6497;
IL2CPP_EXTERN_C String_t* _stringLiteralE5E429BCC9C2E4A41A3C7A4D96203BE6CB273B11;
IL2CPP_EXTERN_C String_t* _stringLiteralE71E7BC3FE9E9F3C39E46B53FFFF0C83D9CC9A36;
IL2CPP_EXTERN_C String_t* _stringLiteralE8C2E73741ABBBE9D320E65848D6DB0BCF7D63A5;
IL2CPP_EXTERN_C String_t* _stringLiteralEAE79D6E0CFF76FC7A3BB78723690B0B2367F849;
IL2CPP_EXTERN_C String_t* _stringLiteralEF78999D7670EEBB7B9C4D640E261383DD2C6094;
IL2CPP_EXTERN_C String_t* _stringLiteralEFCF610D1253173FB3E0DF195C1F8D2667415453;
IL2CPP_EXTERN_C String_t* _stringLiteralF0541457E2B7EF76AA2DDC177C44B4FF6B95E9C5;
IL2CPP_EXTERN_C String_t* _stringLiteralF1C632B1F91BC26A3DBD8A50A7FCDF474F316978;
IL2CPP_EXTERN_C String_t* _stringLiteralF1E5BAF5ECC3589631088C40CBDD43061976ED8F;
IL2CPP_EXTERN_C String_t* _stringLiteralF221811315A6A4EB975642C56E41ECFB1B78BF7A;
IL2CPP_EXTERN_C String_t* _stringLiteralF9065FA7389750E16FE00D7BA36748F61D3E0DF6;
IL2CPP_EXTERN_C String_t* _stringLiteralFA8B27A553F27F158C5E4C81F3AA90D26451F922;
IL2CPP_EXTERN_C String_t* _stringLiteralFAA5E8C43BB2D5850732EFD9442E467318BFD9C8;
IL2CPP_EXTERN_C String_t* _stringLiteralFE66537A952957258311139D35B0945C0FC518DC;
IL2CPP_EXTERN_C String_t* _stringLiteralFEE63D97CA760412103B668617F8B29605625B7D;
IL2CPP_EXTERN_C const RuntimeMethod* Enumerator_Dispose_m4B5D4976D2C83F3DB387137CD7DE096E0C28370B_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* Enumerator_Dispose_m9FE451117A551A3AD97A0FC27C1C159B551B25F3_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* Enumerator_MoveNext_m5FA83E49042D278C984097B83622E3165E4564AD_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* Enumerator_MoveNext_mD91BF5A0EE3F48F18729E9A081A22223CBA9134E_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* Enumerator_get_Current_m1FE262A1143A9C0B744CAE59FDF00A529A47DA7C_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* Enumerator_get_Current_mABF1CE6A366A00FB242CDDC13D80881F14052780_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* Func_2_Invoke_m18E0D4D4C27DA4526F57145018F8C5B7D4555786_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* Func_4_Invoke_m95D3A234FD84599FDA35F785ACE24B58A5103D13_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* List_1_Add_m12E0FC5DF0E1CB81E7DEADBBDD311E3E1AFC2DB4_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* List_1_Add_m191DF682AFC83E635052DB3C303E514D6D7233A2_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* List_1_Add_m50C0D1F69B2EF31137658E2F052EBBAC7BF82771_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* List_1_Add_mEA738D5941352BC4540C28F701A4BF01E2DF7914_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* List_1_GetEnumerator_m2E4A41A21C3DEA2E56F3BAAC22CAC54ADDAAE89A_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* List_1_GetEnumerator_m7F1A981C4F56927EB6D80776859EFEB2A949645F_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* List_1_ToArray_mFEF088E03E18EF79C06317909C301876B3037D98_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* List_1__ctor_m21E88645DC77FDCB68ED0EA3602951A2609C963C_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* List_1__ctor_mA7F9F92F641CEECFD9D8CFDC667568A05FFD27B4_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* List_1__ctor_mA97DC4CD260A1FD5F8FD67E06EE8F27E5C03CF63_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* List_1__ctor_mAF11022CD0FF8181D72047FFC57B48590F17FFAC_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* List_1_get_Count_m516B184735436F6F6363D5BDBC6469AAA19A10A4_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* List_1_get_Item_m942CEFAE0020F8EC07462ED0CFC951FFE66CBD46_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* ThrowStub_ThrowNotSupportedException_mA248D7D785682F31CDF02FDC1FAB3173EE1B1E19_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* TypeLoadException_GetObjectData_m5198722D9966C5F04FD07467B5EE5AB84D86E499_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* TypeLoadException__ctor_m7D81F0BF798D436FF6ECF3F4B48F206DB8AB1293_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* TypeSpec_BoundCheck_m5CF5E6F2632D8D4D205DC26F6666BE9EA7D874FB_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* TypeSpec_Parse_m7DDF2C8D81E80856BA9EEFDB84421AE2F81B58C1_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* TypeSpec_Parse_m9AE5F2E214E154E1AEDCB27FD207B0C4C8EBC405_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* TypeSpec_Resolve_mCE50015512C48D97F6D5558A2001825102BDDBF7_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* TypedReference_Equals_m167F7EDD4393DE114882916B753AC2D23A3840EA_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* TypedReference_MakeTypedReference_m4258853ADBD3EA5DB6AB0B3F48C82F81DBA1C1DC_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* TypedReference_SetTypedReference_mCA19C65317890F40F1D808976B785A5368DFE411_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* UInt16_CompareTo_m91AEACDAA81D12A2A8D868938F797B112330EC44_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* UInt16_Parse_m12E00A51D9C346D8537FD42FC93C9113D2A0D254_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* UInt16_System_IConvertible_ToDateTime_m7AD170006FECE0BAC29179FFE72D7AC1B0D0C735_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* UInt32_CompareTo_mA6BFE8D9033149D2FEF46526E251A3CDEB1889EB_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* UInt32_System_IConvertible_ToDateTime_m450F7E1864FB6A396E9009116F8301B972DAE724_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* UInt64_CompareTo_mB5A28DD05266BC32BD6FD24A6659B0464FFA8950_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* UInt64_System_IConvertible_ToDateTime_m1DE2B7B00676B061B66F18FCCC7CBC5D848B0EBA_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* UIntPtr_System_Runtime_Serialization_ISerializable_GetObjectData_mB6B1C508A6E9BFD526F23A38634C1E703595B733_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* UnSafeCharBuffer_AppendString_m1E2967E285FC06FDE141B90EF186745D5D2814FE_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* UnitySerializationHolder_GetObjectData_m7562EAA093BA2732DED6A3D94E676EEAAC1D8310_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* UnitySerializationHolder_GetRealObject_mB8BD0D19FE747C6B7F739F9686AA52CBA9E6FA9E_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* UnitySerializationHolder_ThrowInsufficientInformation_mC9EC8B972B617DB4A56CC8BAF3B814ACF0E7A7EE_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* UnitySerializationHolder__ctor_m2DBB21E6B4107323DB20C23AD6D9290F50BF2B1E_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* ValueTuple_System_Collections_IStructuralComparable_CompareTo_mC5A3E5494E6AE2CEBA28F16A2324F69E8E7E1061_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* ValueTuple_System_IComparable_CompareTo_m6E4FCA0C1525C685EB58B41763A4A4D8F2CE5EF5_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* Version_CompareTo_m604CF8F6AFAB12D2F64E223B72F518528A3F85A2_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* Version_ToString_m8B385B5C25D9FD3A25EE2DDF02B592CAFC1C0AB0_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* Version__ctor_mFA5AABF2294D59FA7B3F32BB48CB238BCACBDF80_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* WeakReference_GetObjectData_m1DBED399F8C4A13F8C764A2AADFC5B6EBA5643D4_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* WeakReference__ctor_m9740BD0F2AEC959BF2210503D085723C6C1E09DF_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* WindowsConsoleDriver_ReadKey_mDE4EDC7320EFF2B8D0B888A203D0C96531855568_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* __ComObject__ctor_m2A98911F497D95AC1C931674CC745F002A36C878_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* __Filters_FilterAttribute_mBF9879ECFB908212C56CAE0B42C9E29BFCB347C1_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* __Filters_FilterIgnoreCase_m883976C13C53B21BE3430DE51D4317CBCF89F53A_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* __Filters_FilterName_m768C2766720890EE1D07554E3433C0F828D427DB_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeType* Int32U5BU5D_t2B9E4FDDDB9F0A00EC0AC631BA2DA915EB1ECF83_0_0_0_var;
IL2CPP_EXTERN_C const RuntimeType* MethodBase_t_0_0_0_var;
IL2CPP_EXTERN_C const RuntimeType* RuntimeObject_0_0_0_var;
IL2CPP_EXTERN_C const RuntimeType* String_t_0_0_0_var;
IL2CPP_EXTERN_C const RuntimeType* TypeU5BU5D_t7FE623A666B49176DE123306221193E888A12F5F_0_0_0_var;
IL2CPP_EXTERN_C const RuntimeType* Type_t_0_0_0_var;
IL2CPP_EXTERN_C const RuntimeType* UnitySerializationHolder_t6B17ABB985ACD3F8D9F9E3C146DEA5F730E1CEAC_0_0_0_var;
IL2CPP_EXTERN_C const uint32_t ATypeName_Equals_m7D88938E443BA9FAEA8615EEFBAE8E23B1BE6BD2_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t ATypeName_Equals_mCADC0D866B2E78D4BA563475D528D45DA5AA92FD_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t ThrowStub_ThrowNotSupportedException_mA248D7D785682F31CDF02FDC1FAB3173EE1B1E19_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t TypeIdentifiers_FromDisplay_m08FB8BE03D80603F9A030774E218310DC96693CE_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t TypeInitializationException_GetObjectData_m61A4C223CD68BB6170CD4E5593358B6A2CD0D1AE_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t TypeInitializationException__ctor_m392481761B076335738D194514B219AC5A6D8A7E_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t TypeInitializationException__ctor_mAF515ADEF54825D8F19E8773B04D49CA1EEAA4A2_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t TypeInitializationException__ctor_mECB421CF0582FE4EADA4DD7B5687CA64635D71B7_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t TypeInitializationException_get_TypeName_mB1D7D9D4E2400579F85B80BA0B012504AB15A5A8_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t TypeLoadException_GetObjectData_m5198722D9966C5F04FD07467B5EE5AB84D86E499_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t TypeLoadException_SetMessageField_m23CD2003031C6BF6A4AD01D4FFF2DC786DA580E0_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t TypeLoadException__ctor_m7D81F0BF798D436FF6ECF3F4B48F206DB8AB1293_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t TypeLoadException__ctor_mEF05D23A192E0B9BFAAA97A77A0FC1BCBE7B4355_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t TypeSpec_AddModifier_m082500BAE4A512BA0E84CC85A71F4A67DA885909_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t TypeSpec_AddName_mEF7336F662841D8A5B8157BA703C8959A808C9B7_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t TypeSpec_BoundCheck_m5CF5E6F2632D8D4D205DC26F6666BE9EA7D874FB_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t TypeSpec_GetDisplayFullName_m4D6D7AED6CBFC324310480BA07461682A09822B6_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t TypeSpec_GetModifierString_m879659900335844914FDD6BEB1B373531DC990FE_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t TypeSpec_Parse_m7DDF2C8D81E80856BA9EEFDB84421AE2F81B58C1_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t TypeSpec_Parse_m9AE5F2E214E154E1AEDCB27FD207B0C4C8EBC405_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t TypeSpec_Resolve_mCE50015512C48D97F6D5558A2001825102BDDBF7_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t TypeSpec_SkipSpace_mF388B6F9C82F795BA722B706A5435B0E799A531C_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t TypeSpec_UnescapeInternalName_m7B3F1C73984FAF9159F89F62C97AF144EDC4347E_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t TypedReference_Equals_m167F7EDD4393DE114882916B753AC2D23A3840EA_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t TypedReference_GetHashCode_m6A586AC495B0AB6D55E7EAE301C82BB2752A4289_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t TypedReference_MakeTypedReference_m4258853ADBD3EA5DB6AB0B3F48C82F81DBA1C1DC_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t TypedReference_SetTypedReference_mCA19C65317890F40F1D808976B785A5368DFE411_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t UInt16_CompareTo_m91AEACDAA81D12A2A8D868938F797B112330EC44_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t UInt16_Equals_mBCD7FC4A11D0CEEFF4BC6559137A9E397D7017B8_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t UInt16_Parse_m12E00A51D9C346D8537FD42FC93C9113D2A0D254_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t UInt16_System_IConvertible_ToBoolean_mC81E40A61B311E3D9E69439B629E90816966F72A_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t UInt16_System_IConvertible_ToByte_mA95B992F24924E773C5602A6FEE29BDE5EE2072F_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t UInt16_System_IConvertible_ToChar_m6CD04280CB5C9546579E13211911F5B42B498F0F_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t UInt16_System_IConvertible_ToDateTime_m7AD170006FECE0BAC29179FFE72D7AC1B0D0C735_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t UInt16_System_IConvertible_ToDecimal_m74D92DB8814035966C6CFF447753338B03287E43_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t UInt16_System_IConvertible_ToDouble_m62236A4E72E544543EA440ED142B8BA093ADCB40_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t UInt16_System_IConvertible_ToInt16_m0818293E3F1271A2AD126AE950B71DBDDD3286D3_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t UInt16_System_IConvertible_ToInt32_mA3C6E3F7DE9C6C893CAA5301EEDA26036554F34C_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t UInt16_System_IConvertible_ToInt64_mC204E05417B4F982A189912080F57F20E24275CB_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t UInt16_System_IConvertible_ToSByte_mA4AD532B0AF50FD2F6AEBCDB581EA1EE43FCA3CF_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t UInt16_System_IConvertible_ToSingle_m6B087CB34DBF0B394642977BB68F8B503DED3C7E_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t UInt16_System_IConvertible_ToType_m2FD8E8941C266AE4254B1C4C068F4C5238C08695_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t UInt16_System_IConvertible_ToUInt32_m6DA7A076663655EB849211FF9BD16582F863C5F3_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t UInt16_System_IConvertible_ToUInt64_m510EF773A50C42F0B60B2C8AE753FC7873B3A97B_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t UInt32_CompareTo_mA6BFE8D9033149D2FEF46526E251A3CDEB1889EB_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t UInt32_Equals_m44E796DB35F5DB4E5D4C98EC6AB5053242A320C3_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t UInt32_System_IConvertible_ToBoolean_mFC8A4EC8666918A944AED690BAA21AD7B6132A7E_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t UInt32_System_IConvertible_ToByte_m9386861ED644D7B5E76BD0D7FB86DEEB0173A0A5_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t UInt32_System_IConvertible_ToChar_mC0A386C36A0EBC656E6F887A1CCD5DBBFF078030_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t UInt32_System_IConvertible_ToDateTime_m450F7E1864FB6A396E9009116F8301B972DAE724_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t UInt32_System_IConvertible_ToDecimal_m1C78EB4A4D9A092C050487129E0AE477ADBBE5A7_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t UInt32_System_IConvertible_ToDouble_m4A3EDEA2044FAA202D4ED3C81672CF0308FAE7E8_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t UInt32_System_IConvertible_ToInt16_mC8FA3B04E544531449665298BE73AB2F486AE393_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t UInt32_System_IConvertible_ToInt32_mB0FCB9A9ACF700AAD49333618A4B819E24F0F0B9_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t UInt32_System_IConvertible_ToInt64_m6E1441BF4C3D5FDFCAEEED65CFE96E6D9F08007B_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t UInt32_System_IConvertible_ToSByte_mD7E08EC2B52A7612582C3E8C26878BAC0AB80984_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t UInt32_System_IConvertible_ToSingle_m2B438F2707D2FB9C8FDC6D79B263677FA3C37096_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t UInt32_System_IConvertible_ToType_mEFD4D7AB69CB399E6603ADA3EDDF10FC622E4A3A_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t UInt32_System_IConvertible_ToUInt16_mBEE9936EF6F5D9D150E507F28CDA17A8C1C92E1C_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t UInt32_System_IConvertible_ToUInt64_m659A2E594AAC8E26152B3EAAF1D80CECD2F43120_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t UInt64_CompareTo_mB5A28DD05266BC32BD6FD24A6659B0464FFA8950_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t UInt64_Equals_mE61D24B984F0B91A2FC1094402F1532A0F82C232_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t UInt64_System_IConvertible_ToBoolean_mCDB7FA8F90588F8FDDF7F0CB26AF43651F9B3884_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t UInt64_System_IConvertible_ToByte_m4F0E7D7E850AA40CE8FEE68B44B5FF29409CCB27_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t UInt64_System_IConvertible_ToChar_mBB0EEBDF5CB12C5CE93ECD9C39124D33F221A523_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t UInt64_System_IConvertible_ToDateTime_m1DE2B7B00676B061B66F18FCCC7CBC5D848B0EBA_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t UInt64_System_IConvertible_ToDecimal_mFE274863205856F4B130AD096D6BC7E40AA65FC7_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t UInt64_System_IConvertible_ToDouble_mE29DD1148D7D94855DCB7CE8B4FC4B9424A00A82_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t UInt64_System_IConvertible_ToInt16_m6D785A19C7E04176E1B60131C70A965ABB427E20_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t UInt64_System_IConvertible_ToInt32_mBF342D7305B0F4643B8B2FB2EAC54F6B5C943746_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t UInt64_System_IConvertible_ToInt64_mFA654AF22149F693965B34C380C2FF61764D7BD4_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t UInt64_System_IConvertible_ToSByte_m6309BC2235A2F03BAE4107E9CCDF53604B9E7BB7_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t UInt64_System_IConvertible_ToSingle_m04A4372F398081E930044EEECC7B73B4686EE8F0_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t UInt64_System_IConvertible_ToType_m176FFA8FD3BDEAB82C5BD41CF3CF81C83AC21803_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t UInt64_System_IConvertible_ToUInt16_m6B443639CDAEEDBE636A47EF6D07B045B51C2A51_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t UInt64_System_IConvertible_ToUInt32_mFF9B4ABD152C30CB4A9F09BAED4D197245141AF7_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t UIntPtr_Equals_m8C135DEDA578597066AB67C1DD5A5A34E4F860EB_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t UIntPtr_System_Runtime_Serialization_ISerializable_GetObjectData_mB6B1C508A6E9BFD526F23A38634C1E703595B733_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t UIntPtr_ToString_m1512332A1A79F9DA551731E9CA7F071A3C88043D_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t UIntPtr__cctor_m4D964FAB1256A389E1DA1838C169AB4B559D28B8_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t UnSafeCharBuffer_AppendString_m1E2967E285FC06FDE141B90EF186745D5D2814FE_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t UnauthorizedAccessException__ctor_mE67AE27F79595BF7594E2D76D24336E64293693E_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t UnhandledExceptionEventArgs__ctor_m126C64897FC12C485717061C6903DBC02E10A9A0_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t UnitySerializationHolder_AddElementTypes_m0C8810EE3D2A09BD766FC74C37086846A0268D45_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t UnitySerializationHolder_GetObjectData_m7562EAA093BA2732DED6A3D94E676EEAAC1D8310_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t UnitySerializationHolder_GetRealObject_mB8BD0D19FE747C6B7F739F9686AA52CBA9E6FA9E_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t UnitySerializationHolder_GetUnitySerializationInfo_m45D2EDC32022880C84BBE25124F5EDCA12B57ED2_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t UnitySerializationHolder_GetUnitySerializationInfo_m73DC8BA292A8CD7C89FC189779D656E0A07D4D3D_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t UnitySerializationHolder_GetUnitySerializationInfo_m86F654140996546DB4D6D8228BF9FE45E9BAEC3E_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t UnitySerializationHolder_ThrowInsufficientInformation_mC9EC8B972B617DB4A56CC8BAF3B814ACF0E7A7EE_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t UnitySerializationHolder__ctor_m2DBB21E6B4107323DB20C23AD6D9290F50BF2B1E_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t ValueTuple_CombineHashCodes_m43A0AF2B2A3E284D995D8D8FC386D13D19A3F5CC_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t ValueTuple_Equals_m0675CB3C2023AE4A3B1FEB34C87EFE2D6CAB081A_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t ValueTuple_System_Collections_IStructuralComparable_CompareTo_mC5A3E5494E6AE2CEBA28F16A2324F69E8E7E1061_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t ValueTuple_System_Collections_IStructuralEquatable_Equals_m97AEC150FCB956B281470A28DBBE312ABE2B7021_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t ValueTuple_System_IComparable_CompareTo_m6E4FCA0C1525C685EB58B41763A4A4D8F2CE5EF5_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t ValueTuple_ToString_mBF8C414E974C2EAA15E250F90E6B50993AAA1B2D_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t ValueType_DefaultEquals_m139582CD1BAD7472B45D806F76E4E14E82E629DB_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t Variant_Clear_m7622B0C52C7794CC4C33434D2ED8170ECDDE5DAF_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t Version_Clone_mC9305AB873E1FF41BA1B81C2988F0C113CC11035_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t Version_CompareTo_m604CF8F6AFAB12D2F64E223B72F518528A3F85A2_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t Version_CompareTo_mB6A6C226C3401C8903DD32602F72FA644631C33C_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t Version_Equals_m7C93B95F0594CB28E1B1C96936B03069BF8968D3_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t Version_Equals_mD76B915CF93D19541FFE323B20D0B7992B62927B_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t Version_ToString_m8B385B5C25D9FD3A25EE2DDF02B592CAFC1C0AB0_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t Version__cctor_m255F2F683982C0B54105CCDAFF40FF467B19B8D3_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t Version__ctor_mFA5AABF2294D59FA7B3F32BB48CB238BCACBDF80_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t Version_op_Inequality_mBF83F266057D2C028BA2F423372DA7E738B25CD0_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t WeakReference_GetObjectData_m1DBED399F8C4A13F8C764A2AADFC5B6EBA5643D4_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t WeakReference__ctor_m9740BD0F2AEC959BF2210503D085723C6C1E09DF_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t WindowsConsoleDriver_ReadKey_mDE4EDC7320EFF2B8D0B888A203D0C96531855568_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t __ComObject__ctor_m2A98911F497D95AC1C931674CC745F002A36C878_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t __DTString_GetNextDigit_mE662D3828A0E0648E24F62FC5D750DA554364EFB_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t __DTString_GetRegularToken_mD79E9337E33F2F9535DD89437EEDC2AF3F5A0B39_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t __DTString_GetSeparatorToken_m2F4CE10AC9C39A5380D3DD5344B81F79C7006EF1_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t __DTString_MatchSpecifiedWords_mAD172D28B54FDBB34D5E8C8F92CB6C8B0EECDBA0_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t __DTString_RemoveLeadingInQuoteSpaces_m71E36820EEC9E50FFC1FA2F53FCFA3495EB2BC19_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t __DTString_RemoveTrailingInQuoteSpaces_m18A5B81964E3027BF02B1393CCD7781AB3ECA72F_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t __DTString_SkipWhiteSpaceCurrent_m85EF1DCFFB216A209FEB3CC53CB8E977C51D71DB_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t __DTString_SkipWhiteSpaces_mB4AA5270916EF04CD52A4F3C16B1FB08D0B0CF4F_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t __DTString_TrimTail_m23E23486D88B86A755B551A9881F1FDA9D6DD99A_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t __DTString__cctor_mC97C8C04AED3132252833D2119019C73BF6EFA80_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t __Filters_FilterAttribute_mBF9879ECFB908212C56CAE0B42C9E29BFCB347C1_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t __Filters_FilterIgnoreCase_m883976C13C53B21BE3430DE51D4317CBCF89F53A_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t __Filters_FilterName_m768C2766720890EE1D07554E3433C0F828D427DB_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t __Filters__cctor_mAC913CDF08E7AB6541101C4B96483BF49C6E2F14_MetadataUsageId;
struct Assembly_t_marshaled_com;
struct Assembly_t_marshaled_pinvoke;
struct CultureData_tF43B080FFA6EB278F4F289BCDA3FB74B6C208ECD_marshaled_com;
struct CultureData_tF43B080FFA6EB278F4F289BCDA3FB74B6C208ECD_marshaled_pinvoke;
struct CultureInfo_t345AC6924134F039ED9A11F3E03F8E91B6A3225F_marshaled_com;
struct CultureInfo_t345AC6924134F039ED9A11F3E03F8E91B6A3225F_marshaled_pinvoke;
struct Delegate_t_marshaled_com;
struct Delegate_t_marshaled_pinvoke;
struct Exception_t_marshaled_com;
struct Exception_t_marshaled_pinvoke;
struct InputRecord_tAB007C739F339BE208F3C4796B53E9044ADF0A78;;
struct InputRecord_tAB007C739F339BE208F3C4796B53E9044ADF0A78_marshaled_pinvoke;
struct InputRecord_tAB007C739F339BE208F3C4796B53E9044ADF0A78_marshaled_pinvoke;;
struct CharU5BU5D_t4CC6ABF0AD71BEC97E3C2F1E9C5677E46D3A75C2;
struct DelegateU5BU5D_tDFCDEE2A6322F96C0FE49AF47E9ADB8C4B294E86;
struct Int32U5BU5D_t2B9E4FDDDB9F0A00EC0AC631BA2DA915EB1ECF83;
struct IntPtrU5BU5D_t4DC01DCB9A6DF6C9792A6513595D7A11E637DCDD;
struct ObjectU5BU5D_t3C9242B5C88A48B2A5BD9FDA6CD0024E792AF08A;
struct FieldInfoU5BU5D_t9C36FA93372CA01DAF85946064B058CD9CE2E8BE;
struct StringU5BU5D_t933FB07893230EA91C40FF900D5400665E87B14E;
struct TypeU5BU5D_t7FE623A666B49176DE123306221193E888A12F5F;
IL2CPP_EXTERN_C_BEGIN
IL2CPP_EXTERN_C_END
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Object
struct Il2CppArrayBounds;
// System.Array
// System.ArraySpec
struct ArraySpec_tF374BB8994F7190916C6F14C7EA8FE6EFE017970 : public RuntimeObject
{
public:
// System.Int32 System.ArraySpec::dimensions
int32_t ___dimensions_0;
// System.Boolean System.ArraySpec::bound
bool ___bound_1;
public:
inline static int32_t get_offset_of_dimensions_0() { return static_cast<int32_t>(offsetof(ArraySpec_tF374BB8994F7190916C6F14C7EA8FE6EFE017970, ___dimensions_0)); }
inline int32_t get_dimensions_0() const { return ___dimensions_0; }
inline int32_t* get_address_of_dimensions_0() { return &___dimensions_0; }
inline void set_dimensions_0(int32_t value)
{
___dimensions_0 = value;
}
inline static int32_t get_offset_of_bound_1() { return static_cast<int32_t>(offsetof(ArraySpec_tF374BB8994F7190916C6F14C7EA8FE6EFE017970, ___bound_1)); }
inline bool get_bound_1() const { return ___bound_1; }
inline bool* get_address_of_bound_1() { return &___bound_1; }
inline void set_bound_1(bool value)
{
___bound_1 = value;
}
};
// System.Collections.Generic.List`1<System.Int32>
struct List_1_tE1526161A558A17A39A8B69D8EEF3801393B6226 : public RuntimeObject
{
public:
// T[] System.Collections.Generic.List`1::_items
Int32U5BU5D_t2B9E4FDDDB9F0A00EC0AC631BA2DA915EB1ECF83* ____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;
public:
inline static int32_t get_offset_of__items_1() { return static_cast<int32_t>(offsetof(List_1_tE1526161A558A17A39A8B69D8EEF3801393B6226, ____items_1)); }
inline Int32U5BU5D_t2B9E4FDDDB9F0A00EC0AC631BA2DA915EB1ECF83* get__items_1() const { return ____items_1; }
inline Int32U5BU5D_t2B9E4FDDDB9F0A00EC0AC631BA2DA915EB1ECF83** get_address_of__items_1() { return &____items_1; }
inline void set__items_1(Int32U5BU5D_t2B9E4FDDDB9F0A00EC0AC631BA2DA915EB1ECF83* value)
{
____items_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&____items_1), (void*)value);
}
inline static int32_t get_offset_of__size_2() { return static_cast<int32_t>(offsetof(List_1_tE1526161A558A17A39A8B69D8EEF3801393B6226, ____size_2)); }
inline int32_t get__size_2() const { return ____size_2; }
inline int32_t* get_address_of__size_2() { return &____size_2; }
inline void set__size_2(int32_t value)
{
____size_2 = value;
}
inline static int32_t get_offset_of__version_3() { return static_cast<int32_t>(offsetof(List_1_tE1526161A558A17A39A8B69D8EEF3801393B6226, ____version_3)); }
inline int32_t get__version_3() const { return ____version_3; }
inline int32_t* get_address_of__version_3() { return &____version_3; }
inline void set__version_3(int32_t value)
{
____version_3 = value;
}
inline static int32_t get_offset_of__syncRoot_4() { return static_cast<int32_t>(offsetof(List_1_tE1526161A558A17A39A8B69D8EEF3801393B6226, ____syncRoot_4)); }
inline RuntimeObject * get__syncRoot_4() const { return ____syncRoot_4; }
inline RuntimeObject ** get_address_of__syncRoot_4() { return &____syncRoot_4; }
inline void set__syncRoot_4(RuntimeObject * value)
{
____syncRoot_4 = value;
Il2CppCodeGenWriteBarrier((void**)(&____syncRoot_4), (void*)value);
}
};
struct List_1_tE1526161A558A17A39A8B69D8EEF3801393B6226_StaticFields
{
public:
// T[] System.Collections.Generic.List`1::_emptyArray
Int32U5BU5D_t2B9E4FDDDB9F0A00EC0AC631BA2DA915EB1ECF83* ____emptyArray_5;
public:
inline static int32_t get_offset_of__emptyArray_5() { return static_cast<int32_t>(offsetof(List_1_tE1526161A558A17A39A8B69D8EEF3801393B6226_StaticFields, ____emptyArray_5)); }
inline Int32U5BU5D_t2B9E4FDDDB9F0A00EC0AC631BA2DA915EB1ECF83* get__emptyArray_5() const { return ____emptyArray_5; }
inline Int32U5BU5D_t2B9E4FDDDB9F0A00EC0AC631BA2DA915EB1ECF83** get_address_of__emptyArray_5() { return &____emptyArray_5; }
inline void set__emptyArray_5(Int32U5BU5D_t2B9E4FDDDB9F0A00EC0AC631BA2DA915EB1ECF83* value)
{
____emptyArray_5 = value;
Il2CppCodeGenWriteBarrier((void**)(&____emptyArray_5), (void*)value);
}
};
// System.Collections.Generic.List`1<System.ModifierSpec>
struct List_1_tFD995FD9C5961BB4B415EE63B297C4B19643A3C2 : public RuntimeObject
{
public:
// T[] System.Collections.Generic.List`1::_items
ModifierSpecU5BU5D_tAEF81765D168567C7F55496AB5F6C43084E398C7* ____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;
public:
inline static int32_t get_offset_of__items_1() { return static_cast<int32_t>(offsetof(List_1_tFD995FD9C5961BB4B415EE63B297C4B19643A3C2, ____items_1)); }
inline ModifierSpecU5BU5D_tAEF81765D168567C7F55496AB5F6C43084E398C7* get__items_1() const { return ____items_1; }
inline ModifierSpecU5BU5D_tAEF81765D168567C7F55496AB5F6C43084E398C7** get_address_of__items_1() { return &____items_1; }
inline void set__items_1(ModifierSpecU5BU5D_tAEF81765D168567C7F55496AB5F6C43084E398C7* value)
{
____items_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&____items_1), (void*)value);
}
inline static int32_t get_offset_of__size_2() { return static_cast<int32_t>(offsetof(List_1_tFD995FD9C5961BB4B415EE63B297C4B19643A3C2, ____size_2)); }
inline int32_t get__size_2() const { return ____size_2; }
inline int32_t* get_address_of__size_2() { return &____size_2; }
inline void set__size_2(int32_t value)
{
____size_2 = value;
}
inline static int32_t get_offset_of__version_3() { return static_cast<int32_t>(offsetof(List_1_tFD995FD9C5961BB4B415EE63B297C4B19643A3C2, ____version_3)); }
inline int32_t get__version_3() const { return ____version_3; }
inline int32_t* get_address_of__version_3() { return &____version_3; }
inline void set__version_3(int32_t value)
{
____version_3 = value;
}
inline static int32_t get_offset_of__syncRoot_4() { return static_cast<int32_t>(offsetof(List_1_tFD995FD9C5961BB4B415EE63B297C4B19643A3C2, ____syncRoot_4)); }
inline RuntimeObject * get__syncRoot_4() const { return ____syncRoot_4; }
inline RuntimeObject ** get_address_of__syncRoot_4() { return &____syncRoot_4; }
inline void set__syncRoot_4(RuntimeObject * value)
{
____syncRoot_4 = value;
Il2CppCodeGenWriteBarrier((void**)(&____syncRoot_4), (void*)value);
}
};
struct List_1_tFD995FD9C5961BB4B415EE63B297C4B19643A3C2_StaticFields
{
public:
// T[] System.Collections.Generic.List`1::_emptyArray
ModifierSpecU5BU5D_tAEF81765D168567C7F55496AB5F6C43084E398C7* ____emptyArray_5;
public:
inline static int32_t get_offset_of__emptyArray_5() { return static_cast<int32_t>(offsetof(List_1_tFD995FD9C5961BB4B415EE63B297C4B19643A3C2_StaticFields, ____emptyArray_5)); }
inline ModifierSpecU5BU5D_tAEF81765D168567C7F55496AB5F6C43084E398C7* get__emptyArray_5() const { return ____emptyArray_5; }
inline ModifierSpecU5BU5D_tAEF81765D168567C7F55496AB5F6C43084E398C7** get_address_of__emptyArray_5() { return &____emptyArray_5; }
inline void set__emptyArray_5(ModifierSpecU5BU5D_tAEF81765D168567C7F55496AB5F6C43084E398C7* value)
{
____emptyArray_5 = value;
Il2CppCodeGenWriteBarrier((void**)(&____emptyArray_5), (void*)value);
}
};
// System.Collections.Generic.List`1<System.TypeIdentifier>
struct List_1_tB8129EB4ADDDECD38E3E178F0A902C921B575166 : public RuntimeObject
{
public:
// T[] System.Collections.Generic.List`1::_items
TypeIdentifierU5BU5D_t95E17776299DF69C41AE3200141420FF69ADB766* ____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;
public:
inline static int32_t get_offset_of__items_1() { return static_cast<int32_t>(offsetof(List_1_tB8129EB4ADDDECD38E3E178F0A902C921B575166, ____items_1)); }
inline TypeIdentifierU5BU5D_t95E17776299DF69C41AE3200141420FF69ADB766* get__items_1() const { return ____items_1; }
inline TypeIdentifierU5BU5D_t95E17776299DF69C41AE3200141420FF69ADB766** get_address_of__items_1() { return &____items_1; }
inline void set__items_1(TypeIdentifierU5BU5D_t95E17776299DF69C41AE3200141420FF69ADB766* value)
{
____items_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&____items_1), (void*)value);
}
inline static int32_t get_offset_of__size_2() { return static_cast<int32_t>(offsetof(List_1_tB8129EB4ADDDECD38E3E178F0A902C921B575166, ____size_2)); }
inline int32_t get__size_2() const { return ____size_2; }
inline int32_t* get_address_of__size_2() { return &____size_2; }
inline void set__size_2(int32_t value)
{
____size_2 = value;
}
inline static int32_t get_offset_of__version_3() { return static_cast<int32_t>(offsetof(List_1_tB8129EB4ADDDECD38E3E178F0A902C921B575166, ____version_3)); }
inline int32_t get__version_3() const { return ____version_3; }
inline int32_t* get_address_of__version_3() { return &____version_3; }
inline void set__version_3(int32_t value)
{
____version_3 = value;
}
inline static int32_t get_offset_of__syncRoot_4() { return static_cast<int32_t>(offsetof(List_1_tB8129EB4ADDDECD38E3E178F0A902C921B575166, ____syncRoot_4)); }
inline RuntimeObject * get__syncRoot_4() const { return ____syncRoot_4; }
inline RuntimeObject ** get_address_of__syncRoot_4() { return &____syncRoot_4; }
inline void set__syncRoot_4(RuntimeObject * value)
{
____syncRoot_4 = value;
Il2CppCodeGenWriteBarrier((void**)(&____syncRoot_4), (void*)value);
}
};
struct List_1_tB8129EB4ADDDECD38E3E178F0A902C921B575166_StaticFields
{
public:
// T[] System.Collections.Generic.List`1::_emptyArray
TypeIdentifierU5BU5D_t95E17776299DF69C41AE3200141420FF69ADB766* ____emptyArray_5;
public:
inline static int32_t get_offset_of__emptyArray_5() { return static_cast<int32_t>(offsetof(List_1_tB8129EB4ADDDECD38E3E178F0A902C921B575166_StaticFields, ____emptyArray_5)); }
inline TypeIdentifierU5BU5D_t95E17776299DF69C41AE3200141420FF69ADB766* get__emptyArray_5() const { return ____emptyArray_5; }
inline TypeIdentifierU5BU5D_t95E17776299DF69C41AE3200141420FF69ADB766** get_address_of__emptyArray_5() { return &____emptyArray_5; }
inline void set__emptyArray_5(TypeIdentifierU5BU5D_t95E17776299DF69C41AE3200141420FF69ADB766* value)
{
____emptyArray_5 = value;
Il2CppCodeGenWriteBarrier((void**)(&____emptyArray_5), (void*)value);
}
};
// System.Collections.Generic.List`1<System.TypeSpec>
struct List_1_t8C8BF378AAB72B34B6EE63F686877AE7290ECFBA : public RuntimeObject
{
public:
// T[] System.Collections.Generic.List`1::_items
TypeSpecU5BU5D_t9767F25128C75FBAC1A17F15DFC9ACA4105B37DF* ____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;
public:
inline static int32_t get_offset_of__items_1() { return static_cast<int32_t>(offsetof(List_1_t8C8BF378AAB72B34B6EE63F686877AE7290ECFBA, ____items_1)); }
inline TypeSpecU5BU5D_t9767F25128C75FBAC1A17F15DFC9ACA4105B37DF* get__items_1() const { return ____items_1; }
inline TypeSpecU5BU5D_t9767F25128C75FBAC1A17F15DFC9ACA4105B37DF** get_address_of__items_1() { return &____items_1; }
inline void set__items_1(TypeSpecU5BU5D_t9767F25128C75FBAC1A17F15DFC9ACA4105B37DF* value)
{
____items_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&____items_1), (void*)value);
}
inline static int32_t get_offset_of__size_2() { return static_cast<int32_t>(offsetof(List_1_t8C8BF378AAB72B34B6EE63F686877AE7290ECFBA, ____size_2)); }
inline int32_t get__size_2() const { return ____size_2; }
inline int32_t* get_address_of__size_2() { return &____size_2; }
inline void set__size_2(int32_t value)
{
____size_2 = value;
}
inline static int32_t get_offset_of__version_3() { return static_cast<int32_t>(offsetof(List_1_t8C8BF378AAB72B34B6EE63F686877AE7290ECFBA, ____version_3)); }
inline int32_t get__version_3() const { return ____version_3; }
inline int32_t* get_address_of__version_3() { return &____version_3; }
inline void set__version_3(int32_t value)
{
____version_3 = value;
}
inline static int32_t get_offset_of__syncRoot_4() { return static_cast<int32_t>(offsetof(List_1_t8C8BF378AAB72B34B6EE63F686877AE7290ECFBA, ____syncRoot_4)); }
inline RuntimeObject * get__syncRoot_4() const { return ____syncRoot_4; }
inline RuntimeObject ** get_address_of__syncRoot_4() { return &____syncRoot_4; }
inline void set__syncRoot_4(RuntimeObject * value)
{
____syncRoot_4 = value;
Il2CppCodeGenWriteBarrier((void**)(&____syncRoot_4), (void*)value);
}
};
struct List_1_t8C8BF378AAB72B34B6EE63F686877AE7290ECFBA_StaticFields
{
public:
// T[] System.Collections.Generic.List`1::_emptyArray
TypeSpecU5BU5D_t9767F25128C75FBAC1A17F15DFC9ACA4105B37DF* ____emptyArray_5;
public:
inline static int32_t get_offset_of__emptyArray_5() { return static_cast<int32_t>(offsetof(List_1_t8C8BF378AAB72B34B6EE63F686877AE7290ECFBA_StaticFields, ____emptyArray_5)); }
inline TypeSpecU5BU5D_t9767F25128C75FBAC1A17F15DFC9ACA4105B37DF* get__emptyArray_5() const { return ____emptyArray_5; }
inline TypeSpecU5BU5D_t9767F25128C75FBAC1A17F15DFC9ACA4105B37DF** get_address_of__emptyArray_5() { return &____emptyArray_5; }
inline void set__emptyArray_5(TypeSpecU5BU5D_t9767F25128C75FBAC1A17F15DFC9ACA4105B37DF* value)
{
____emptyArray_5 = value;
Il2CppCodeGenWriteBarrier((void**)(&____emptyArray_5), (void*)value);
}
};
// System.DBNull
struct DBNull_t7400E04939C2C29699B389B106997892BF53A8E5 : public RuntimeObject
{
public:
public:
};
struct DBNull_t7400E04939C2C29699B389B106997892BF53A8E5_StaticFields
{
public:
// System.DBNull System.DBNull::Value
DBNull_t7400E04939C2C29699B389B106997892BF53A8E5 * ___Value_0;
public:
inline static int32_t get_offset_of_Value_0() { return static_cast<int32_t>(offsetof(DBNull_t7400E04939C2C29699B389B106997892BF53A8E5_StaticFields, ___Value_0)); }
inline DBNull_t7400E04939C2C29699B389B106997892BF53A8E5 * get_Value_0() const { return ___Value_0; }
inline DBNull_t7400E04939C2C29699B389B106997892BF53A8E5 ** get_address_of_Value_0() { return &___Value_0; }
inline void set_Value_0(DBNull_t7400E04939C2C29699B389B106997892BF53A8E5 * value)
{
___Value_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___Value_0), (void*)value);
}
};
// System.Empty
struct Empty_t31C7ECDF7D102AFFCE029D8AB11D8595F0316ED2 : public RuntimeObject
{
public:
public:
};
struct Empty_t31C7ECDF7D102AFFCE029D8AB11D8595F0316ED2_StaticFields
{
public:
// System.Empty System.Empty::Value
Empty_t31C7ECDF7D102AFFCE029D8AB11D8595F0316ED2 * ___Value_0;
public:
inline static int32_t get_offset_of_Value_0() { return static_cast<int32_t>(offsetof(Empty_t31C7ECDF7D102AFFCE029D8AB11D8595F0316ED2_StaticFields, ___Value_0)); }
inline Empty_t31C7ECDF7D102AFFCE029D8AB11D8595F0316ED2 * get_Value_0() const { return ___Value_0; }
inline Empty_t31C7ECDF7D102AFFCE029D8AB11D8595F0316ED2 ** get_address_of_Value_0() { return &___Value_0; }
inline void set_Value_0(Empty_t31C7ECDF7D102AFFCE029D8AB11D8595F0316ED2 * value)
{
___Value_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___Value_0), (void*)value);
}
};
// System.EventArgs
struct EventArgs_t8E6CA180BE0E56674C6407011A94BAF7C757352E : public RuntimeObject
{
public:
public:
};
struct EventArgs_t8E6CA180BE0E56674C6407011A94BAF7C757352E_StaticFields
{
public:
// System.EventArgs System.EventArgs::Empty
EventArgs_t8E6CA180BE0E56674C6407011A94BAF7C757352E * ___Empty_0;
public:
inline static int32_t get_offset_of_Empty_0() { return static_cast<int32_t>(offsetof(EventArgs_t8E6CA180BE0E56674C6407011A94BAF7C757352E_StaticFields, ___Empty_0)); }
inline EventArgs_t8E6CA180BE0E56674C6407011A94BAF7C757352E * get_Empty_0() const { return ___Empty_0; }
inline EventArgs_t8E6CA180BE0E56674C6407011A94BAF7C757352E ** get_address_of_Empty_0() { return &___Empty_0; }
inline void set_Empty_0(EventArgs_t8E6CA180BE0E56674C6407011A94BAF7C757352E * value)
{
___Empty_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___Empty_0), (void*)value);
}
};
// System.Exception
struct Exception_t : public RuntimeObject
{
public:
// System.String System.Exception::_className
String_t* ____className_1;
// System.String System.Exception::_message
String_t* ____message_2;
// System.Collections.IDictionary System.Exception::_data
RuntimeObject* ____data_3;
// System.Exception System.Exception::_innerException
Exception_t * ____innerException_4;
// System.String System.Exception::_helpURL
String_t* ____helpURL_5;
// System.Object System.Exception::_stackTrace
RuntimeObject * ____stackTrace_6;
// System.String System.Exception::_stackTraceString
String_t* ____stackTraceString_7;
// System.String System.Exception::_remoteStackTraceString
String_t* ____remoteStackTraceString_8;
// System.Int32 System.Exception::_remoteStackIndex
int32_t ____remoteStackIndex_9;
// System.Object System.Exception::_dynamicMethods
RuntimeObject * ____dynamicMethods_10;
// System.Int32 System.Exception::_HResult
int32_t ____HResult_11;
// System.String System.Exception::_source
String_t* ____source_12;
// System.Runtime.Serialization.SafeSerializationManager System.Exception::_safeSerializationManager
SafeSerializationManager_t4A754D86B0F784B18CBC36C073BA564BED109770 * ____safeSerializationManager_13;
// System.Diagnostics.StackTrace[] System.Exception::captured_traces
StackTraceU5BU5D_t855F09649EA34DEE7C1B6F088E0538E3CCC3F196* ___captured_traces_14;
// System.IntPtr[] System.Exception::native_trace_ips
IntPtrU5BU5D_t4DC01DCB9A6DF6C9792A6513595D7A11E637DCDD* ___native_trace_ips_15;
public:
inline static int32_t get_offset_of__className_1() { return static_cast<int32_t>(offsetof(Exception_t, ____className_1)); }
inline String_t* get__className_1() const { return ____className_1; }
inline String_t** get_address_of__className_1() { return &____className_1; }
inline void set__className_1(String_t* value)
{
____className_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&____className_1), (void*)value);
}
inline static int32_t get_offset_of__message_2() { return static_cast<int32_t>(offsetof(Exception_t, ____message_2)); }
inline String_t* get__message_2() const { return ____message_2; }
inline String_t** get_address_of__message_2() { return &____message_2; }
inline void set__message_2(String_t* value)
{
____message_2 = value;
Il2CppCodeGenWriteBarrier((void**)(&____message_2), (void*)value);
}
inline static int32_t get_offset_of__data_3() { return static_cast<int32_t>(offsetof(Exception_t, ____data_3)); }
inline RuntimeObject* get__data_3() const { return ____data_3; }
inline RuntimeObject** get_address_of__data_3() { return &____data_3; }
inline void set__data_3(RuntimeObject* value)
{
____data_3 = value;
Il2CppCodeGenWriteBarrier((void**)(&____data_3), (void*)value);
}
inline static int32_t get_offset_of__innerException_4() { return static_cast<int32_t>(offsetof(Exception_t, ____innerException_4)); }
inline Exception_t * get__innerException_4() const { return ____innerException_4; }
inline Exception_t ** get_address_of__innerException_4() { return &____innerException_4; }
inline void set__innerException_4(Exception_t * value)
{
____innerException_4 = value;
Il2CppCodeGenWriteBarrier((void**)(&____innerException_4), (void*)value);
}
inline static int32_t get_offset_of__helpURL_5() { return static_cast<int32_t>(offsetof(Exception_t, ____helpURL_5)); }
inline String_t* get__helpURL_5() const { return ____helpURL_5; }
inline String_t** get_address_of__helpURL_5() { return &____helpURL_5; }
inline void set__helpURL_5(String_t* value)
{
____helpURL_5 = value;
Il2CppCodeGenWriteBarrier((void**)(&____helpURL_5), (void*)value);
}
inline static int32_t get_offset_of__stackTrace_6() { return static_cast<int32_t>(offsetof(Exception_t, ____stackTrace_6)); }
inline RuntimeObject * get__stackTrace_6() const { return ____stackTrace_6; }
inline RuntimeObject ** get_address_of__stackTrace_6() { return &____stackTrace_6; }
inline void set__stackTrace_6(RuntimeObject * value)
{
____stackTrace_6 = value;
Il2CppCodeGenWriteBarrier((void**)(&____stackTrace_6), (void*)value);
}
inline static int32_t get_offset_of__stackTraceString_7() { return static_cast<int32_t>(offsetof(Exception_t, ____stackTraceString_7)); }
inline String_t* get__stackTraceString_7() const { return ____stackTraceString_7; }
inline String_t** get_address_of__stackTraceString_7() { return &____stackTraceString_7; }
inline void set__stackTraceString_7(String_t* value)
{
____stackTraceString_7 = value;
Il2CppCodeGenWriteBarrier((void**)(&____stackTraceString_7), (void*)value);
}
inline static int32_t get_offset_of__remoteStackTraceString_8() { return static_cast<int32_t>(offsetof(Exception_t, ____remoteStackTraceString_8)); }
inline String_t* get__remoteStackTraceString_8() const { return ____remoteStackTraceString_8; }
inline String_t** get_address_of__remoteStackTraceString_8() { return &____remoteStackTraceString_8; }
inline void set__remoteStackTraceString_8(String_t* value)
{
____remoteStackTraceString_8 = value;
Il2CppCodeGenWriteBarrier((void**)(&____remoteStackTraceString_8), (void*)value);
}
inline static int32_t get_offset_of__remoteStackIndex_9() { return static_cast<int32_t>(offsetof(Exception_t, ____remoteStackIndex_9)); }
inline int32_t get__remoteStackIndex_9() const { return ____remoteStackIndex_9; }
inline int32_t* get_address_of__remoteStackIndex_9() { return &____remoteStackIndex_9; }
inline void set__remoteStackIndex_9(int32_t value)
{
____remoteStackIndex_9 = value;
}
inline static int32_t get_offset_of__dynamicMethods_10() { return static_cast<int32_t>(offsetof(Exception_t, ____dynamicMethods_10)); }
inline RuntimeObject * get__dynamicMethods_10() const { return ____dynamicMethods_10; }
inline RuntimeObject ** get_address_of__dynamicMethods_10() { return &____dynamicMethods_10; }
inline void set__dynamicMethods_10(RuntimeObject * value)
{
____dynamicMethods_10 = value;
Il2CppCodeGenWriteBarrier((void**)(&____dynamicMethods_10), (void*)value);
}
inline static int32_t get_offset_of__HResult_11() { return static_cast<int32_t>(offsetof(Exception_t, ____HResult_11)); }
inline int32_t get__HResult_11() const { return ____HResult_11; }
inline int32_t* get_address_of__HResult_11() { return &____HResult_11; }
inline void set__HResult_11(int32_t value)
{
____HResult_11 = value;
}
inline static int32_t get_offset_of__source_12() { return static_cast<int32_t>(offsetof(Exception_t, ____source_12)); }
inline String_t* get__source_12() const { return ____source_12; }
inline String_t** get_address_of__source_12() { return &____source_12; }
inline void set__source_12(String_t* value)
{
____source_12 = value;
Il2CppCodeGenWriteBarrier((void**)(&____source_12), (void*)value);
}
inline static int32_t get_offset_of__safeSerializationManager_13() { return static_cast<int32_t>(offsetof(Exception_t, ____safeSerializationManager_13)); }
inline SafeSerializationManager_t4A754D86B0F784B18CBC36C073BA564BED109770 * get__safeSerializationManager_13() const { return ____safeSerializationManager_13; }
inline SafeSerializationManager_t4A754D86B0F784B18CBC36C073BA564BED109770 ** get_address_of__safeSerializationManager_13() { return &____safeSerializationManager_13; }
inline void set__safeSerializationManager_13(SafeSerializationManager_t4A754D86B0F784B18CBC36C073BA564BED109770 * value)
{
____safeSerializationManager_13 = value;
Il2CppCodeGenWriteBarrier((void**)(&____safeSerializationManager_13), (void*)value);
}
inline static int32_t get_offset_of_captured_traces_14() { return static_cast<int32_t>(offsetof(Exception_t, ___captured_traces_14)); }
inline StackTraceU5BU5D_t855F09649EA34DEE7C1B6F088E0538E3CCC3F196* get_captured_traces_14() const { return ___captured_traces_14; }
inline StackTraceU5BU5D_t855F09649EA34DEE7C1B6F088E0538E3CCC3F196** get_address_of_captured_traces_14() { return &___captured_traces_14; }
inline void set_captured_traces_14(StackTraceU5BU5D_t855F09649EA34DEE7C1B6F088E0538E3CCC3F196* value)
{
___captured_traces_14 = value;
Il2CppCodeGenWriteBarrier((void**)(&___captured_traces_14), (void*)value);
}
inline static int32_t get_offset_of_native_trace_ips_15() { return static_cast<int32_t>(offsetof(Exception_t, ___native_trace_ips_15)); }
inline IntPtrU5BU5D_t4DC01DCB9A6DF6C9792A6513595D7A11E637DCDD* get_native_trace_ips_15() const { return ___native_trace_ips_15; }
inline IntPtrU5BU5D_t4DC01DCB9A6DF6C9792A6513595D7A11E637DCDD** get_address_of_native_trace_ips_15() { return &___native_trace_ips_15; }
inline void set_native_trace_ips_15(IntPtrU5BU5D_t4DC01DCB9A6DF6C9792A6513595D7A11E637DCDD* value)
{
___native_trace_ips_15 = value;
Il2CppCodeGenWriteBarrier((void**)(&___native_trace_ips_15), (void*)value);
}
};
struct Exception_t_StaticFields
{
public:
// System.Object System.Exception::s_EDILock
RuntimeObject * ___s_EDILock_0;
public:
inline static int32_t get_offset_of_s_EDILock_0() { return static_cast<int32_t>(offsetof(Exception_t_StaticFields, ___s_EDILock_0)); }
inline RuntimeObject * get_s_EDILock_0() const { return ___s_EDILock_0; }
inline RuntimeObject ** get_address_of_s_EDILock_0() { return &___s_EDILock_0; }
inline void set_s_EDILock_0(RuntimeObject * value)
{
___s_EDILock_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___s_EDILock_0), (void*)value);
}
};
// Native definition for P/Invoke marshalling of System.Exception
struct Exception_t_marshaled_pinvoke
{
char* ____className_1;
char* ____message_2;
RuntimeObject* ____data_3;
Exception_t_marshaled_pinvoke* ____innerException_4;
char* ____helpURL_5;
Il2CppIUnknown* ____stackTrace_6;
char* ____stackTraceString_7;
char* ____remoteStackTraceString_8;
int32_t ____remoteStackIndex_9;
Il2CppIUnknown* ____dynamicMethods_10;
int32_t ____HResult_11;
char* ____source_12;
SafeSerializationManager_t4A754D86B0F784B18CBC36C073BA564BED109770 * ____safeSerializationManager_13;
StackTraceU5BU5D_t855F09649EA34DEE7C1B6F088E0538E3CCC3F196* ___captured_traces_14;
intptr_t* ___native_trace_ips_15;
};
// Native definition for COM marshalling of System.Exception
struct Exception_t_marshaled_com
{
Il2CppChar* ____className_1;
Il2CppChar* ____message_2;
RuntimeObject* ____data_3;
Exception_t_marshaled_com* ____innerException_4;
Il2CppChar* ____helpURL_5;
Il2CppIUnknown* ____stackTrace_6;
Il2CppChar* ____stackTraceString_7;
Il2CppChar* ____remoteStackTraceString_8;
int32_t ____remoteStackIndex_9;
Il2CppIUnknown* ____dynamicMethods_10;
int32_t ____HResult_11;
Il2CppChar* ____source_12;
SafeSerializationManager_t4A754D86B0F784B18CBC36C073BA564BED109770 * ____safeSerializationManager_13;
StackTraceU5BU5D_t855F09649EA34DEE7C1B6F088E0538E3CCC3F196* ___captured_traces_14;
intptr_t* ___native_trace_ips_15;
};
// System.Globalization.CultureInfo
struct CultureInfo_t345AC6924134F039ED9A11F3E03F8E91B6A3225F : public RuntimeObject
{
public:
// 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_tFDF57037EBC5BC833D0A53EF0327B805994860A8 * ___numInfo_10;
// System.Globalization.DateTimeFormatInfo modreq(System.Runtime.CompilerServices.IsVolatile) System.Globalization.CultureInfo::dateTimeInfo
DateTimeFormatInfo_tF4BB3AA482C2F772D2A9022F78BF8727830FAF5F * ___dateTimeInfo_11;
// System.Globalization.TextInfo modreq(System.Runtime.CompilerServices.IsVolatile) System.Globalization.CultureInfo::textInfo
TextInfo_t5F1E697CB6A7E5EC80F0DC3A968B9B4A70C291D8 * ___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_t933FB07893230EA91C40FF900D5400665E87B14E* ___native_calendar_names_20;
// System.Globalization.CompareInfo modreq(System.Runtime.CompilerServices.IsVolatile) System.Globalization.CultureInfo::compareInfo
CompareInfo_tB9A071DBC11AC00AF2EA2066D0C2AE1DCB1865D1 * ___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_tF55A785ACD277504CF0D2F2C6AD56F76C6E91BD5 * ___calendar_24;
// System.Globalization.CultureInfo System.Globalization.CultureInfo::parent_culture
CultureInfo_t345AC6924134F039ED9A11F3E03F8E91B6A3225F * ___parent_culture_25;
// System.Boolean System.Globalization.CultureInfo::constructed
bool ___constructed_26;
// System.Byte[] System.Globalization.CultureInfo::cached_serialized_form
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* ___cached_serialized_form_27;
// System.Globalization.CultureData System.Globalization.CultureInfo::m_cultureData
CultureData_tF43B080FFA6EB278F4F289BCDA3FB74B6C208ECD * ___m_cultureData_28;
// System.Boolean System.Globalization.CultureInfo::m_isInherited
bool ___m_isInherited_29;
public:
inline static int32_t get_offset_of_m_isReadOnly_3() { return static_cast<int32_t>(offsetof(CultureInfo_t345AC6924134F039ED9A11F3E03F8E91B6A3225F, ___m_isReadOnly_3)); }
inline bool get_m_isReadOnly_3() const { return ___m_isReadOnly_3; }
inline bool* get_address_of_m_isReadOnly_3() { return &___m_isReadOnly_3; }
inline void set_m_isReadOnly_3(bool value)
{
___m_isReadOnly_3 = value;
}
inline static int32_t get_offset_of_cultureID_4() { return static_cast<int32_t>(offsetof(CultureInfo_t345AC6924134F039ED9A11F3E03F8E91B6A3225F, ___cultureID_4)); }
inline int32_t get_cultureID_4() const { return ___cultureID_4; }
inline int32_t* get_address_of_cultureID_4() { return &___cultureID_4; }
inline void set_cultureID_4(int32_t value)
{
___cultureID_4 = value;
}
inline static int32_t get_offset_of_parent_lcid_5() { return static_cast<int32_t>(offsetof(CultureInfo_t345AC6924134F039ED9A11F3E03F8E91B6A3225F, ___parent_lcid_5)); }
inline int32_t get_parent_lcid_5() const { return ___parent_lcid_5; }
inline int32_t* get_address_of_parent_lcid_5() { return &___parent_lcid_5; }
inline void set_parent_lcid_5(int32_t value)
{
___parent_lcid_5 = value;
}
inline static int32_t get_offset_of_datetime_index_6() { return static_cast<int32_t>(offsetof(CultureInfo_t345AC6924134F039ED9A11F3E03F8E91B6A3225F, ___datetime_index_6)); }
inline int32_t get_datetime_index_6() const { return ___datetime_index_6; }
inline int32_t* get_address_of_datetime_index_6() { return &___datetime_index_6; }
inline void set_datetime_index_6(int32_t value)
{
___datetime_index_6 = value;
}
inline static int32_t get_offset_of_number_index_7() { return static_cast<int32_t>(offsetof(CultureInfo_t345AC6924134F039ED9A11F3E03F8E91B6A3225F, ___number_index_7)); }
inline int32_t get_number_index_7() const { return ___number_index_7; }
inline int32_t* get_address_of_number_index_7() { return &___number_index_7; }
inline void set_number_index_7(int32_t value)
{
___number_index_7 = value;
}
inline static int32_t get_offset_of_default_calendar_type_8() { return static_cast<int32_t>(offsetof(CultureInfo_t345AC6924134F039ED9A11F3E03F8E91B6A3225F, ___default_calendar_type_8)); }
inline int32_t get_default_calendar_type_8() const { return ___default_calendar_type_8; }
inline int32_t* get_address_of_default_calendar_type_8() { return &___default_calendar_type_8; }
inline void set_default_calendar_type_8(int32_t value)
{
___default_calendar_type_8 = value;
}
inline static int32_t get_offset_of_m_useUserOverride_9() { return static_cast<int32_t>(offsetof(CultureInfo_t345AC6924134F039ED9A11F3E03F8E91B6A3225F, ___m_useUserOverride_9)); }
inline bool get_m_useUserOverride_9() const { return ___m_useUserOverride_9; }
inline bool* get_address_of_m_useUserOverride_9() { return &___m_useUserOverride_9; }
inline void set_m_useUserOverride_9(bool value)
{
___m_useUserOverride_9 = value;
}
inline static int32_t get_offset_of_numInfo_10() { return static_cast<int32_t>(offsetof(CultureInfo_t345AC6924134F039ED9A11F3E03F8E91B6A3225F, ___numInfo_10)); }
inline NumberFormatInfo_tFDF57037EBC5BC833D0A53EF0327B805994860A8 * get_numInfo_10() const { return ___numInfo_10; }
inline NumberFormatInfo_tFDF57037EBC5BC833D0A53EF0327B805994860A8 ** get_address_of_numInfo_10() { return &___numInfo_10; }
inline void set_numInfo_10(NumberFormatInfo_tFDF57037EBC5BC833D0A53EF0327B805994860A8 * value)
{
___numInfo_10 = value;
Il2CppCodeGenWriteBarrier((void**)(&___numInfo_10), (void*)value);
}
inline static int32_t get_offset_of_dateTimeInfo_11() { return static_cast<int32_t>(offsetof(CultureInfo_t345AC6924134F039ED9A11F3E03F8E91B6A3225F, ___dateTimeInfo_11)); }
inline DateTimeFormatInfo_tF4BB3AA482C2F772D2A9022F78BF8727830FAF5F * get_dateTimeInfo_11() const { return ___dateTimeInfo_11; }
inline DateTimeFormatInfo_tF4BB3AA482C2F772D2A9022F78BF8727830FAF5F ** get_address_of_dateTimeInfo_11() { return &___dateTimeInfo_11; }
inline void set_dateTimeInfo_11(DateTimeFormatInfo_tF4BB3AA482C2F772D2A9022F78BF8727830FAF5F * value)
{
___dateTimeInfo_11 = value;
Il2CppCodeGenWriteBarrier((void**)(&___dateTimeInfo_11), (void*)value);
}
inline static int32_t get_offset_of_textInfo_12() { return static_cast<int32_t>(offsetof(CultureInfo_t345AC6924134F039ED9A11F3E03F8E91B6A3225F, ___textInfo_12)); }
inline TextInfo_t5F1E697CB6A7E5EC80F0DC3A968B9B4A70C291D8 * get_textInfo_12() const { return ___textInfo_12; }
inline TextInfo_t5F1E697CB6A7E5EC80F0DC3A968B9B4A70C291D8 ** get_address_of_textInfo_12() { return &___textInfo_12; }
inline void set_textInfo_12(TextInfo_t5F1E697CB6A7E5EC80F0DC3A968B9B4A70C291D8 * value)
{
___textInfo_12 = value;
Il2CppCodeGenWriteBarrier((void**)(&___textInfo_12), (void*)value);
}
inline static int32_t get_offset_of_m_name_13() { return static_cast<int32_t>(offsetof(CultureInfo_t345AC6924134F039ED9A11F3E03F8E91B6A3225F, ___m_name_13)); }
inline String_t* get_m_name_13() const { return ___m_name_13; }
inline String_t** get_address_of_m_name_13() { return &___m_name_13; }
inline void set_m_name_13(String_t* value)
{
___m_name_13 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_name_13), (void*)value);
}
inline static int32_t get_offset_of_englishname_14() { return static_cast<int32_t>(offsetof(CultureInfo_t345AC6924134F039ED9A11F3E03F8E91B6A3225F, ___englishname_14)); }
inline String_t* get_englishname_14() const { return ___englishname_14; }
inline String_t** get_address_of_englishname_14() { return &___englishname_14; }
inline void set_englishname_14(String_t* value)
{
___englishname_14 = value;
Il2CppCodeGenWriteBarrier((void**)(&___englishname_14), (void*)value);
}
inline static int32_t get_offset_of_nativename_15() { return static_cast<int32_t>(offsetof(CultureInfo_t345AC6924134F039ED9A11F3E03F8E91B6A3225F, ___nativename_15)); }
inline String_t* get_nativename_15() const { return ___nativename_15; }
inline String_t** get_address_of_nativename_15() { return &___nativename_15; }
inline void set_nativename_15(String_t* value)
{
___nativename_15 = value;
Il2CppCodeGenWriteBarrier((void**)(&___nativename_15), (void*)value);
}
inline static int32_t get_offset_of_iso3lang_16() { return static_cast<int32_t>(offsetof(CultureInfo_t345AC6924134F039ED9A11F3E03F8E91B6A3225F, ___iso3lang_16)); }
inline String_t* get_iso3lang_16() const { return ___iso3lang_16; }
inline String_t** get_address_of_iso3lang_16() { return &___iso3lang_16; }
inline void set_iso3lang_16(String_t* value)
{
___iso3lang_16 = value;
Il2CppCodeGenWriteBarrier((void**)(&___iso3lang_16), (void*)value);
}
inline static int32_t get_offset_of_iso2lang_17() { return static_cast<int32_t>(offsetof(CultureInfo_t345AC6924134F039ED9A11F3E03F8E91B6A3225F, ___iso2lang_17)); }
inline String_t* get_iso2lang_17() const { return ___iso2lang_17; }
inline String_t** get_address_of_iso2lang_17() { return &___iso2lang_17; }
inline void set_iso2lang_17(String_t* value)
{
___iso2lang_17 = value;
Il2CppCodeGenWriteBarrier((void**)(&___iso2lang_17), (void*)value);
}
inline static int32_t get_offset_of_win3lang_18() { return static_cast<int32_t>(offsetof(CultureInfo_t345AC6924134F039ED9A11F3E03F8E91B6A3225F, ___win3lang_18)); }
inline String_t* get_win3lang_18() const { return ___win3lang_18; }
inline String_t** get_address_of_win3lang_18() { return &___win3lang_18; }
inline void set_win3lang_18(String_t* value)
{
___win3lang_18 = value;
Il2CppCodeGenWriteBarrier((void**)(&___win3lang_18), (void*)value);
}
inline static int32_t get_offset_of_territory_19() { return static_cast<int32_t>(offsetof(CultureInfo_t345AC6924134F039ED9A11F3E03F8E91B6A3225F, ___territory_19)); }
inline String_t* get_territory_19() const { return ___territory_19; }
inline String_t** get_address_of_territory_19() { return &___territory_19; }
inline void set_territory_19(String_t* value)
{
___territory_19 = value;
Il2CppCodeGenWriteBarrier((void**)(&___territory_19), (void*)value);
}
inline static int32_t get_offset_of_native_calendar_names_20() { return static_cast<int32_t>(offsetof(CultureInfo_t345AC6924134F039ED9A11F3E03F8E91B6A3225F, ___native_calendar_names_20)); }
inline StringU5BU5D_t933FB07893230EA91C40FF900D5400665E87B14E* get_native_calendar_names_20() const { return ___native_calendar_names_20; }
inline StringU5BU5D_t933FB07893230EA91C40FF900D5400665E87B14E** get_address_of_native_calendar_names_20() { return &___native_calendar_names_20; }
inline void set_native_calendar_names_20(StringU5BU5D_t933FB07893230EA91C40FF900D5400665E87B14E* value)
{
___native_calendar_names_20 = value;
Il2CppCodeGenWriteBarrier((void**)(&___native_calendar_names_20), (void*)value);
}
inline static int32_t get_offset_of_compareInfo_21() { return static_cast<int32_t>(offsetof(CultureInfo_t345AC6924134F039ED9A11F3E03F8E91B6A3225F, ___compareInfo_21)); }
inline CompareInfo_tB9A071DBC11AC00AF2EA2066D0C2AE1DCB1865D1 * get_compareInfo_21() const { return ___compareInfo_21; }
inline CompareInfo_tB9A071DBC11AC00AF2EA2066D0C2AE1DCB1865D1 ** get_address_of_compareInfo_21() { return &___compareInfo_21; }
inline void set_compareInfo_21(CompareInfo_tB9A071DBC11AC00AF2EA2066D0C2AE1DCB1865D1 * value)
{
___compareInfo_21 = value;
Il2CppCodeGenWriteBarrier((void**)(&___compareInfo_21), (void*)value);
}
inline static int32_t get_offset_of_textinfo_data_22() { return static_cast<int32_t>(offsetof(CultureInfo_t345AC6924134F039ED9A11F3E03F8E91B6A3225F, ___textinfo_data_22)); }
inline void* get_textinfo_data_22() const { return ___textinfo_data_22; }
inline void** get_address_of_textinfo_data_22() { return &___textinfo_data_22; }
inline void set_textinfo_data_22(void* value)
{
___textinfo_data_22 = value;
}
inline static int32_t get_offset_of_m_dataItem_23() { return static_cast<int32_t>(offsetof(CultureInfo_t345AC6924134F039ED9A11F3E03F8E91B6A3225F, ___m_dataItem_23)); }
inline int32_t get_m_dataItem_23() const { return ___m_dataItem_23; }
inline int32_t* get_address_of_m_dataItem_23() { return &___m_dataItem_23; }
inline void set_m_dataItem_23(int32_t value)
{
___m_dataItem_23 = value;
}
inline static int32_t get_offset_of_calendar_24() { return static_cast<int32_t>(offsetof(CultureInfo_t345AC6924134F039ED9A11F3E03F8E91B6A3225F, ___calendar_24)); }
inline Calendar_tF55A785ACD277504CF0D2F2C6AD56F76C6E91BD5 * get_calendar_24() const { return ___calendar_24; }
inline Calendar_tF55A785ACD277504CF0D2F2C6AD56F76C6E91BD5 ** get_address_of_calendar_24() { return &___calendar_24; }
inline void set_calendar_24(Calendar_tF55A785ACD277504CF0D2F2C6AD56F76C6E91BD5 * value)
{
___calendar_24 = value;
Il2CppCodeGenWriteBarrier((void**)(&___calendar_24), (void*)value);
}
inline static int32_t get_offset_of_parent_culture_25() { return static_cast<int32_t>(offsetof(CultureInfo_t345AC6924134F039ED9A11F3E03F8E91B6A3225F, ___parent_culture_25)); }
inline CultureInfo_t345AC6924134F039ED9A11F3E03F8E91B6A3225F * get_parent_culture_25() const { return ___parent_culture_25; }
inline CultureInfo_t345AC6924134F039ED9A11F3E03F8E91B6A3225F ** get_address_of_parent_culture_25() { return &___parent_culture_25; }
inline void set_parent_culture_25(CultureInfo_t345AC6924134F039ED9A11F3E03F8E91B6A3225F * value)
{
___parent_culture_25 = value;
Il2CppCodeGenWriteBarrier((void**)(&___parent_culture_25), (void*)value);
}
inline static int32_t get_offset_of_constructed_26() { return static_cast<int32_t>(offsetof(CultureInfo_t345AC6924134F039ED9A11F3E03F8E91B6A3225F, ___constructed_26)); }
inline bool get_constructed_26() const { return ___constructed_26; }
inline bool* get_address_of_constructed_26() { return &___constructed_26; }
inline void set_constructed_26(bool value)
{
___constructed_26 = value;
}
inline static int32_t get_offset_of_cached_serialized_form_27() { return static_cast<int32_t>(offsetof(CultureInfo_t345AC6924134F039ED9A11F3E03F8E91B6A3225F, ___cached_serialized_form_27)); }
inline ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* get_cached_serialized_form_27() const { return ___cached_serialized_form_27; }
inline ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821** get_address_of_cached_serialized_form_27() { return &___cached_serialized_form_27; }
inline void set_cached_serialized_form_27(ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* value)
{
___cached_serialized_form_27 = value;
Il2CppCodeGenWriteBarrier((void**)(&___cached_serialized_form_27), (void*)value);
}
inline static int32_t get_offset_of_m_cultureData_28() { return static_cast<int32_t>(offsetof(CultureInfo_t345AC6924134F039ED9A11F3E03F8E91B6A3225F, ___m_cultureData_28)); }
inline CultureData_tF43B080FFA6EB278F4F289BCDA3FB74B6C208ECD * get_m_cultureData_28() const { return ___m_cultureData_28; }
inline CultureData_tF43B080FFA6EB278F4F289BCDA3FB74B6C208ECD ** get_address_of_m_cultureData_28() { return &___m_cultureData_28; }
inline void set_m_cultureData_28(CultureData_tF43B080FFA6EB278F4F289BCDA3FB74B6C208ECD * value)
{
___m_cultureData_28 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_cultureData_28), (void*)value);
}
inline static int32_t get_offset_of_m_isInherited_29() { return static_cast<int32_t>(offsetof(CultureInfo_t345AC6924134F039ED9A11F3E03F8E91B6A3225F, ___m_isInherited_29)); }
inline bool get_m_isInherited_29() const { return ___m_isInherited_29; }
inline bool* get_address_of_m_isInherited_29() { return &___m_isInherited_29; }
inline void set_m_isInherited_29(bool value)
{
___m_isInherited_29 = value;
}
};
struct CultureInfo_t345AC6924134F039ED9A11F3E03F8E91B6A3225F_StaticFields
{
public:
// System.Globalization.CultureInfo modreq(System.Runtime.CompilerServices.IsVolatile) System.Globalization.CultureInfo::invariant_culture_info
CultureInfo_t345AC6924134F039ED9A11F3E03F8E91B6A3225F * ___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_t345AC6924134F039ED9A11F3E03F8E91B6A3225F * ___default_current_culture_2;
// System.Globalization.CultureInfo modreq(System.Runtime.CompilerServices.IsVolatile) System.Globalization.CultureInfo::s_DefaultThreadCurrentUICulture
CultureInfo_t345AC6924134F039ED9A11F3E03F8E91B6A3225F * ___s_DefaultThreadCurrentUICulture_33;
// System.Globalization.CultureInfo modreq(System.Runtime.CompilerServices.IsVolatile) System.Globalization.CultureInfo::s_DefaultThreadCurrentCulture
CultureInfo_t345AC6924134F039ED9A11F3E03F8E91B6A3225F * ___s_DefaultThreadCurrentCulture_34;
// System.Collections.Generic.Dictionary`2<System.Int32,System.Globalization.CultureInfo> System.Globalization.CultureInfo::shared_by_number
Dictionary_2_tC88A56872F7C79DBB9582D4F3FC22ED5D8E0B98B * ___shared_by_number_35;
// System.Collections.Generic.Dictionary`2<System.String,System.Globalization.CultureInfo> System.Globalization.CultureInfo::shared_by_name
Dictionary_2_tBA5388DBB42BF620266F9A48E8B859BBBB224E25 * ___shared_by_name_36;
// System.Boolean System.Globalization.CultureInfo::IsTaiwanSku
bool ___IsTaiwanSku_37;
public:
inline static int32_t get_offset_of_invariant_culture_info_0() { return static_cast<int32_t>(offsetof(CultureInfo_t345AC6924134F039ED9A11F3E03F8E91B6A3225F_StaticFields, ___invariant_culture_info_0)); }
inline CultureInfo_t345AC6924134F039ED9A11F3E03F8E91B6A3225F * get_invariant_culture_info_0() const { return ___invariant_culture_info_0; }
inline CultureInfo_t345AC6924134F039ED9A11F3E03F8E91B6A3225F ** get_address_of_invariant_culture_info_0() { return &___invariant_culture_info_0; }
inline void set_invariant_culture_info_0(CultureInfo_t345AC6924134F039ED9A11F3E03F8E91B6A3225F * value)
{
___invariant_culture_info_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___invariant_culture_info_0), (void*)value);
}
inline static int32_t get_offset_of_shared_table_lock_1() { return static_cast<int32_t>(offsetof(CultureInfo_t345AC6924134F039ED9A11F3E03F8E91B6A3225F_StaticFields, ___shared_table_lock_1)); }
inline RuntimeObject * get_shared_table_lock_1() const { return ___shared_table_lock_1; }
inline RuntimeObject ** get_address_of_shared_table_lock_1() { return &___shared_table_lock_1; }
inline void set_shared_table_lock_1(RuntimeObject * value)
{
___shared_table_lock_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___shared_table_lock_1), (void*)value);
}
inline static int32_t get_offset_of_default_current_culture_2() { return static_cast<int32_t>(offsetof(CultureInfo_t345AC6924134F039ED9A11F3E03F8E91B6A3225F_StaticFields, ___default_current_culture_2)); }
inline CultureInfo_t345AC6924134F039ED9A11F3E03F8E91B6A3225F * get_default_current_culture_2() const { return ___default_current_culture_2; }
inline CultureInfo_t345AC6924134F039ED9A11F3E03F8E91B6A3225F ** get_address_of_default_current_culture_2() { return &___default_current_culture_2; }
inline void set_default_current_culture_2(CultureInfo_t345AC6924134F039ED9A11F3E03F8E91B6A3225F * value)
{
___default_current_culture_2 = value;
Il2CppCodeGenWriteBarrier((void**)(&___default_current_culture_2), (void*)value);
}
inline static int32_t get_offset_of_s_DefaultThreadCurrentUICulture_33() { return static_cast<int32_t>(offsetof(CultureInfo_t345AC6924134F039ED9A11F3E03F8E91B6A3225F_StaticFields, ___s_DefaultThreadCurrentUICulture_33)); }
inline CultureInfo_t345AC6924134F039ED9A11F3E03F8E91B6A3225F * get_s_DefaultThreadCurrentUICulture_33() const { return ___s_DefaultThreadCurrentUICulture_33; }
inline CultureInfo_t345AC6924134F039ED9A11F3E03F8E91B6A3225F ** get_address_of_s_DefaultThreadCurrentUICulture_33() { return &___s_DefaultThreadCurrentUICulture_33; }
inline void set_s_DefaultThreadCurrentUICulture_33(CultureInfo_t345AC6924134F039ED9A11F3E03F8E91B6A3225F * value)
{
___s_DefaultThreadCurrentUICulture_33 = value;
Il2CppCodeGenWriteBarrier((void**)(&___s_DefaultThreadCurrentUICulture_33), (void*)value);
}
inline static int32_t get_offset_of_s_DefaultThreadCurrentCulture_34() { return static_cast<int32_t>(offsetof(CultureInfo_t345AC6924134F039ED9A11F3E03F8E91B6A3225F_StaticFields, ___s_DefaultThreadCurrentCulture_34)); }
inline CultureInfo_t345AC6924134F039ED9A11F3E03F8E91B6A3225F * get_s_DefaultThreadCurrentCulture_34() const { return ___s_DefaultThreadCurrentCulture_34; }
inline CultureInfo_t345AC6924134F039ED9A11F3E03F8E91B6A3225F ** get_address_of_s_DefaultThreadCurrentCulture_34() { return &___s_DefaultThreadCurrentCulture_34; }
inline void set_s_DefaultThreadCurrentCulture_34(CultureInfo_t345AC6924134F039ED9A11F3E03F8E91B6A3225F * value)
{
___s_DefaultThreadCurrentCulture_34 = value;
Il2CppCodeGenWriteBarrier((void**)(&___s_DefaultThreadCurrentCulture_34), (void*)value);
}
inline static int32_t get_offset_of_shared_by_number_35() { return static_cast<int32_t>(offsetof(CultureInfo_t345AC6924134F039ED9A11F3E03F8E91B6A3225F_StaticFields, ___shared_by_number_35)); }
inline Dictionary_2_tC88A56872F7C79DBB9582D4F3FC22ED5D8E0B98B * get_shared_by_number_35() const { return ___shared_by_number_35; }
inline Dictionary_2_tC88A56872F7C79DBB9582D4F3FC22ED5D8E0B98B ** get_address_of_shared_by_number_35() { return &___shared_by_number_35; }
inline void set_shared_by_number_35(Dictionary_2_tC88A56872F7C79DBB9582D4F3FC22ED5D8E0B98B * value)
{
___shared_by_number_35 = value;
Il2CppCodeGenWriteBarrier((void**)(&___shared_by_number_35), (void*)value);
}
inline static int32_t get_offset_of_shared_by_name_36() { return static_cast<int32_t>(offsetof(CultureInfo_t345AC6924134F039ED9A11F3E03F8E91B6A3225F_StaticFields, ___shared_by_name_36)); }
inline Dictionary_2_tBA5388DBB42BF620266F9A48E8B859BBBB224E25 * get_shared_by_name_36() const { return ___shared_by_name_36; }
inline Dictionary_2_tBA5388DBB42BF620266F9A48E8B859BBBB224E25 ** get_address_of_shared_by_name_36() { return &___shared_by_name_36; }
inline void set_shared_by_name_36(Dictionary_2_tBA5388DBB42BF620266F9A48E8B859BBBB224E25 * value)
{
___shared_by_name_36 = value;
Il2CppCodeGenWriteBarrier((void**)(&___shared_by_name_36), (void*)value);
}
inline static int32_t get_offset_of_IsTaiwanSku_37() { return static_cast<int32_t>(offsetof(CultureInfo_t345AC6924134F039ED9A11F3E03F8E91B6A3225F_StaticFields, ___IsTaiwanSku_37)); }
inline bool get_IsTaiwanSku_37() const { return ___IsTaiwanSku_37; }
inline bool* get_address_of_IsTaiwanSku_37() { return &___IsTaiwanSku_37; }
inline void set_IsTaiwanSku_37(bool value)
{
___IsTaiwanSku_37 = value;
}
};
// Native definition for P/Invoke marshalling of System.Globalization.CultureInfo
struct CultureInfo_t345AC6924134F039ED9A11F3E03F8E91B6A3225F_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_tFDF57037EBC5BC833D0A53EF0327B805994860A8 * ___numInfo_10;
DateTimeFormatInfo_tF4BB3AA482C2F772D2A9022F78BF8727830FAF5F * ___dateTimeInfo_11;
TextInfo_t5F1E697CB6A7E5EC80F0DC3A968B9B4A70C291D8 * ___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_tB9A071DBC11AC00AF2EA2066D0C2AE1DCB1865D1 * ___compareInfo_21;
void* ___textinfo_data_22;
int32_t ___m_dataItem_23;
Calendar_tF55A785ACD277504CF0D2F2C6AD56F76C6E91BD5 * ___calendar_24;
CultureInfo_t345AC6924134F039ED9A11F3E03F8E91B6A3225F_marshaled_pinvoke* ___parent_culture_25;
int32_t ___constructed_26;
uint8_t* ___cached_serialized_form_27;
CultureData_tF43B080FFA6EB278F4F289BCDA3FB74B6C208ECD_marshaled_pinvoke* ___m_cultureData_28;
int32_t ___m_isInherited_29;
};
// Native definition for COM marshalling of System.Globalization.CultureInfo
struct CultureInfo_t345AC6924134F039ED9A11F3E03F8E91B6A3225F_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_tFDF57037EBC5BC833D0A53EF0327B805994860A8 * ___numInfo_10;
DateTimeFormatInfo_tF4BB3AA482C2F772D2A9022F78BF8727830FAF5F * ___dateTimeInfo_11;
TextInfo_t5F1E697CB6A7E5EC80F0DC3A968B9B4A70C291D8 * ___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_tB9A071DBC11AC00AF2EA2066D0C2AE1DCB1865D1 * ___compareInfo_21;
void* ___textinfo_data_22;
int32_t ___m_dataItem_23;
Calendar_tF55A785ACD277504CF0D2F2C6AD56F76C6E91BD5 * ___calendar_24;
CultureInfo_t345AC6924134F039ED9A11F3E03F8E91B6A3225F_marshaled_com* ___parent_culture_25;
int32_t ___constructed_26;
uint8_t* ___cached_serialized_form_27;
CultureData_tF43B080FFA6EB278F4F289BCDA3FB74B6C208ECD_marshaled_com* ___m_cultureData_28;
int32_t ___m_isInherited_29;
};
// System.Numerics.Hashing.HashHelpers
struct HashHelpers_tDC6BF33BEF3A798515BA62BA704DD83AEBFA9C33 : public RuntimeObject
{
public:
public:
};
struct HashHelpers_tDC6BF33BEF3A798515BA62BA704DD83AEBFA9C33_StaticFields
{
public:
// System.Int32 System.Numerics.Hashing.HashHelpers::RandomSeed
int32_t ___RandomSeed_0;
public:
inline static int32_t get_offset_of_RandomSeed_0() { return static_cast<int32_t>(offsetof(HashHelpers_tDC6BF33BEF3A798515BA62BA704DD83AEBFA9C33_StaticFields, ___RandomSeed_0)); }
inline int32_t get_RandomSeed_0() const { return ___RandomSeed_0; }
inline int32_t* get_address_of_RandomSeed_0() { return &___RandomSeed_0; }
inline void set_RandomSeed_0(int32_t value)
{
___RandomSeed_0 = value;
}
};
// System.PointerSpec
struct PointerSpec_tBCE1666DC24EC6E4E5376FEC214499984EC26892 : public RuntimeObject
{
public:
// System.Int32 System.PointerSpec::pointer_level
int32_t ___pointer_level_0;
public:
inline static int32_t get_offset_of_pointer_level_0() { return static_cast<int32_t>(offsetof(PointerSpec_tBCE1666DC24EC6E4E5376FEC214499984EC26892, ___pointer_level_0)); }
inline int32_t get_pointer_level_0() const { return ___pointer_level_0; }
inline int32_t* get_address_of_pointer_level_0() { return &___pointer_level_0; }
inline void set_pointer_level_0(int32_t value)
{
___pointer_level_0 = value;
}
};
// System.Reflection.MemberInfo
struct MemberInfo_t : public RuntimeObject
{
public:
public:
};
// System.Reflection.Missing
struct Missing_t81434A5DBDCCA844BD22E1659DDE1EE7DE8B4ED7 : public RuntimeObject
{
public:
public:
};
struct Missing_t81434A5DBDCCA844BD22E1659DDE1EE7DE8B4ED7_StaticFields
{
public:
// System.Reflection.Missing System.Reflection.Missing::Value
Missing_t81434A5DBDCCA844BD22E1659DDE1EE7DE8B4ED7 * ___Value_0;
public:
inline static int32_t get_offset_of_Value_0() { return static_cast<int32_t>(offsetof(Missing_t81434A5DBDCCA844BD22E1659DDE1EE7DE8B4ED7_StaticFields, ___Value_0)); }
inline Missing_t81434A5DBDCCA844BD22E1659DDE1EE7DE8B4ED7 * get_Value_0() const { return ___Value_0; }
inline Missing_t81434A5DBDCCA844BD22E1659DDE1EE7DE8B4ED7 ** get_address_of_Value_0() { return &___Value_0; }
inline void set_Value_0(Missing_t81434A5DBDCCA844BD22E1659DDE1EE7DE8B4ED7 * value)
{
___Value_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___Value_0), (void*)value);
}
};
// System.Runtime.ConstrainedExecution.CriticalFinalizerObject
struct CriticalFinalizerObject_t8B006E1DEE084E781F5C0F3283E9226E28894DD9 : public RuntimeObject
{
public:
public:
};
// System.Runtime.Serialization.SerializationInfo
struct SerializationInfo_t1BB80E9C9DEA52DBF464487234B045E2930ADA26 : public RuntimeObject
{
public:
// System.String[] System.Runtime.Serialization.SerializationInfo::m_members
StringU5BU5D_t933FB07893230EA91C40FF900D5400665E87B14E* ___m_members_3;
// System.Object[] System.Runtime.Serialization.SerializationInfo::m_data
ObjectU5BU5D_t3C9242B5C88A48B2A5BD9FDA6CD0024E792AF08A* ___m_data_4;
// System.Type[] System.Runtime.Serialization.SerializationInfo::m_types
TypeU5BU5D_t7FE623A666B49176DE123306221193E888A12F5F* ___m_types_5;
// System.Collections.Generic.Dictionary`2<System.String,System.Int32> System.Runtime.Serialization.SerializationInfo::m_nameToIndex
Dictionary_2_tD6E204872BA9FD506A0287EF68E285BEB9EC0DFB * ___m_nameToIndex_6;
// System.Int32 System.Runtime.Serialization.SerializationInfo::m_currMember
int32_t ___m_currMember_7;
// System.Runtime.Serialization.IFormatterConverter System.Runtime.Serialization.SerializationInfo::m_converter
RuntimeObject* ___m_converter_8;
// System.String System.Runtime.Serialization.SerializationInfo::m_fullTypeName
String_t* ___m_fullTypeName_9;
// System.String System.Runtime.Serialization.SerializationInfo::m_assemName
String_t* ___m_assemName_10;
// System.Type System.Runtime.Serialization.SerializationInfo::objectType
Type_t * ___objectType_11;
// System.Boolean System.Runtime.Serialization.SerializationInfo::isFullTypeNameSetExplicit
bool ___isFullTypeNameSetExplicit_12;
// System.Boolean System.Runtime.Serialization.SerializationInfo::isAssemblyNameSetExplicit
bool ___isAssemblyNameSetExplicit_13;
// System.Boolean System.Runtime.Serialization.SerializationInfo::requireSameTokenInPartialTrust
bool ___requireSameTokenInPartialTrust_14;
public:
inline static int32_t get_offset_of_m_members_3() { return static_cast<int32_t>(offsetof(SerializationInfo_t1BB80E9C9DEA52DBF464487234B045E2930ADA26, ___m_members_3)); }
inline StringU5BU5D_t933FB07893230EA91C40FF900D5400665E87B14E* get_m_members_3() const { return ___m_members_3; }
inline StringU5BU5D_t933FB07893230EA91C40FF900D5400665E87B14E** get_address_of_m_members_3() { return &___m_members_3; }
inline void set_m_members_3(StringU5BU5D_t933FB07893230EA91C40FF900D5400665E87B14E* value)
{
___m_members_3 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_members_3), (void*)value);
}
inline static int32_t get_offset_of_m_data_4() { return static_cast<int32_t>(offsetof(SerializationInfo_t1BB80E9C9DEA52DBF464487234B045E2930ADA26, ___m_data_4)); }
inline ObjectU5BU5D_t3C9242B5C88A48B2A5BD9FDA6CD0024E792AF08A* get_m_data_4() const { return ___m_data_4; }
inline ObjectU5BU5D_t3C9242B5C88A48B2A5BD9FDA6CD0024E792AF08A** get_address_of_m_data_4() { return &___m_data_4; }
inline void set_m_data_4(ObjectU5BU5D_t3C9242B5C88A48B2A5BD9FDA6CD0024E792AF08A* value)
{
___m_data_4 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_data_4), (void*)value);
}
inline static int32_t get_offset_of_m_types_5() { return static_cast<int32_t>(offsetof(SerializationInfo_t1BB80E9C9DEA52DBF464487234B045E2930ADA26, ___m_types_5)); }
inline TypeU5BU5D_t7FE623A666B49176DE123306221193E888A12F5F* get_m_types_5() const { return ___m_types_5; }
inline TypeU5BU5D_t7FE623A666B49176DE123306221193E888A12F5F** get_address_of_m_types_5() { return &___m_types_5; }
inline void set_m_types_5(TypeU5BU5D_t7FE623A666B49176DE123306221193E888A12F5F* value)
{
___m_types_5 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_types_5), (void*)value);
}
inline static int32_t get_offset_of_m_nameToIndex_6() { return static_cast<int32_t>(offsetof(SerializationInfo_t1BB80E9C9DEA52DBF464487234B045E2930ADA26, ___m_nameToIndex_6)); }
inline Dictionary_2_tD6E204872BA9FD506A0287EF68E285BEB9EC0DFB * get_m_nameToIndex_6() const { return ___m_nameToIndex_6; }
inline Dictionary_2_tD6E204872BA9FD506A0287EF68E285BEB9EC0DFB ** get_address_of_m_nameToIndex_6() { return &___m_nameToIndex_6; }
inline void set_m_nameToIndex_6(Dictionary_2_tD6E204872BA9FD506A0287EF68E285BEB9EC0DFB * value)
{
___m_nameToIndex_6 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_nameToIndex_6), (void*)value);
}
inline static int32_t get_offset_of_m_currMember_7() { return static_cast<int32_t>(offsetof(SerializationInfo_t1BB80E9C9DEA52DBF464487234B045E2930ADA26, ___m_currMember_7)); }
inline int32_t get_m_currMember_7() const { return ___m_currMember_7; }
inline int32_t* get_address_of_m_currMember_7() { return &___m_currMember_7; }
inline void set_m_currMember_7(int32_t value)
{
___m_currMember_7 = value;
}
inline static int32_t get_offset_of_m_converter_8() { return static_cast<int32_t>(offsetof(SerializationInfo_t1BB80E9C9DEA52DBF464487234B045E2930ADA26, ___m_converter_8)); }
inline RuntimeObject* get_m_converter_8() const { return ___m_converter_8; }
inline RuntimeObject** get_address_of_m_converter_8() { return &___m_converter_8; }
inline void set_m_converter_8(RuntimeObject* value)
{
___m_converter_8 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_converter_8), (void*)value);
}
inline static int32_t get_offset_of_m_fullTypeName_9() { return static_cast<int32_t>(offsetof(SerializationInfo_t1BB80E9C9DEA52DBF464487234B045E2930ADA26, ___m_fullTypeName_9)); }
inline String_t* get_m_fullTypeName_9() const { return ___m_fullTypeName_9; }
inline String_t** get_address_of_m_fullTypeName_9() { return &___m_fullTypeName_9; }
inline void set_m_fullTypeName_9(String_t* value)
{
___m_fullTypeName_9 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_fullTypeName_9), (void*)value);
}
inline static int32_t get_offset_of_m_assemName_10() { return static_cast<int32_t>(offsetof(SerializationInfo_t1BB80E9C9DEA52DBF464487234B045E2930ADA26, ___m_assemName_10)); }
inline String_t* get_m_assemName_10() const { return ___m_assemName_10; }
inline String_t** get_address_of_m_assemName_10() { return &___m_assemName_10; }
inline void set_m_assemName_10(String_t* value)
{
___m_assemName_10 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_assemName_10), (void*)value);
}
inline static int32_t get_offset_of_objectType_11() { return static_cast<int32_t>(offsetof(SerializationInfo_t1BB80E9C9DEA52DBF464487234B045E2930ADA26, ___objectType_11)); }
inline Type_t * get_objectType_11() const { return ___objectType_11; }
inline Type_t ** get_address_of_objectType_11() { return &___objectType_11; }
inline void set_objectType_11(Type_t * value)
{
___objectType_11 = value;
Il2CppCodeGenWriteBarrier((void**)(&___objectType_11), (void*)value);
}
inline static int32_t get_offset_of_isFullTypeNameSetExplicit_12() { return static_cast<int32_t>(offsetof(SerializationInfo_t1BB80E9C9DEA52DBF464487234B045E2930ADA26, ___isFullTypeNameSetExplicit_12)); }
inline bool get_isFullTypeNameSetExplicit_12() const { return ___isFullTypeNameSetExplicit_12; }
inline bool* get_address_of_isFullTypeNameSetExplicit_12() { return &___isFullTypeNameSetExplicit_12; }
inline void set_isFullTypeNameSetExplicit_12(bool value)
{
___isFullTypeNameSetExplicit_12 = value;
}
inline static int32_t get_offset_of_isAssemblyNameSetExplicit_13() { return static_cast<int32_t>(offsetof(SerializationInfo_t1BB80E9C9DEA52DBF464487234B045E2930ADA26, ___isAssemblyNameSetExplicit_13)); }
inline bool get_isAssemblyNameSetExplicit_13() const { return ___isAssemblyNameSetExplicit_13; }
inline bool* get_address_of_isAssemblyNameSetExplicit_13() { return &___isAssemblyNameSetExplicit_13; }
inline void set_isAssemblyNameSetExplicit_13(bool value)
{
___isAssemblyNameSetExplicit_13 = value;
}
inline static int32_t get_offset_of_requireSameTokenInPartialTrust_14() { return static_cast<int32_t>(offsetof(SerializationInfo_t1BB80E9C9DEA52DBF464487234B045E2930ADA26, ___requireSameTokenInPartialTrust_14)); }
inline bool get_requireSameTokenInPartialTrust_14() const { return ___requireSameTokenInPartialTrust_14; }
inline bool* get_address_of_requireSameTokenInPartialTrust_14() { return &___requireSameTokenInPartialTrust_14; }
inline void set_requireSameTokenInPartialTrust_14(bool value)
{
___requireSameTokenInPartialTrust_14 = value;
}
};
// System.String
struct String_t : public RuntimeObject
{
public:
// System.Int32 System.String::m_stringLength
int32_t ___m_stringLength_0;
// System.Char System.String::m_firstChar
Il2CppChar ___m_firstChar_1;
public:
inline static int32_t get_offset_of_m_stringLength_0() { return static_cast<int32_t>(offsetof(String_t, ___m_stringLength_0)); }
inline int32_t get_m_stringLength_0() const { return ___m_stringLength_0; }
inline int32_t* get_address_of_m_stringLength_0() { return &___m_stringLength_0; }
inline void set_m_stringLength_0(int32_t value)
{
___m_stringLength_0 = value;
}
inline static int32_t get_offset_of_m_firstChar_1() { return static_cast<int32_t>(offsetof(String_t, ___m_firstChar_1)); }
inline Il2CppChar get_m_firstChar_1() const { return ___m_firstChar_1; }
inline Il2CppChar* get_address_of_m_firstChar_1() { return &___m_firstChar_1; }
inline void set_m_firstChar_1(Il2CppChar value)
{
___m_firstChar_1 = value;
}
};
struct String_t_StaticFields
{
public:
// System.String System.String::Empty
String_t* ___Empty_5;
public:
inline static int32_t get_offset_of_Empty_5() { return static_cast<int32_t>(offsetof(String_t_StaticFields, ___Empty_5)); }
inline String_t* get_Empty_5() const { return ___Empty_5; }
inline String_t** get_address_of_Empty_5() { return &___Empty_5; }
inline void set_Empty_5(String_t* value)
{
___Empty_5 = value;
Il2CppCodeGenWriteBarrier((void**)(&___Empty_5), (void*)value);
}
};
// System.Text.StringBuilder
struct StringBuilder_t : public RuntimeObject
{
public:
// System.Char[] System.Text.StringBuilder::m_ChunkChars
CharU5BU5D_t4CC6ABF0AD71BEC97E3C2F1E9C5677E46D3A75C2* ___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;
public:
inline static int32_t get_offset_of_m_ChunkChars_0() { return static_cast<int32_t>(offsetof(StringBuilder_t, ___m_ChunkChars_0)); }
inline CharU5BU5D_t4CC6ABF0AD71BEC97E3C2F1E9C5677E46D3A75C2* get_m_ChunkChars_0() const { return ___m_ChunkChars_0; }
inline CharU5BU5D_t4CC6ABF0AD71BEC97E3C2F1E9C5677E46D3A75C2** get_address_of_m_ChunkChars_0() { return &___m_ChunkChars_0; }
inline void set_m_ChunkChars_0(CharU5BU5D_t4CC6ABF0AD71BEC97E3C2F1E9C5677E46D3A75C2* value)
{
___m_ChunkChars_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_ChunkChars_0), (void*)value);
}
inline static int32_t get_offset_of_m_ChunkPrevious_1() { return static_cast<int32_t>(offsetof(StringBuilder_t, ___m_ChunkPrevious_1)); }
inline StringBuilder_t * get_m_ChunkPrevious_1() const { return ___m_ChunkPrevious_1; }
inline StringBuilder_t ** get_address_of_m_ChunkPrevious_1() { return &___m_ChunkPrevious_1; }
inline void set_m_ChunkPrevious_1(StringBuilder_t * value)
{
___m_ChunkPrevious_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_ChunkPrevious_1), (void*)value);
}
inline static int32_t get_offset_of_m_ChunkLength_2() { return static_cast<int32_t>(offsetof(StringBuilder_t, ___m_ChunkLength_2)); }
inline int32_t get_m_ChunkLength_2() const { return ___m_ChunkLength_2; }
inline int32_t* get_address_of_m_ChunkLength_2() { return &___m_ChunkLength_2; }
inline void set_m_ChunkLength_2(int32_t value)
{
___m_ChunkLength_2 = value;
}
inline static int32_t get_offset_of_m_ChunkOffset_3() { return static_cast<int32_t>(offsetof(StringBuilder_t, ___m_ChunkOffset_3)); }
inline int32_t get_m_ChunkOffset_3() const { return ___m_ChunkOffset_3; }
inline int32_t* get_address_of_m_ChunkOffset_3() { return &___m_ChunkOffset_3; }
inline void set_m_ChunkOffset_3(int32_t value)
{
___m_ChunkOffset_3 = value;
}
inline static int32_t get_offset_of_m_MaxCapacity_4() { return static_cast<int32_t>(offsetof(StringBuilder_t, ___m_MaxCapacity_4)); }
inline int32_t get_m_MaxCapacity_4() const { return ___m_MaxCapacity_4; }
inline int32_t* get_address_of_m_MaxCapacity_4() { return &___m_MaxCapacity_4; }
inline void set_m_MaxCapacity_4(int32_t value)
{
___m_MaxCapacity_4 = value;
}
};
// System.TypeIdentifiers
struct TypeIdentifiers_tBC5BC4024D376DCB779D877A1616CF4D7DB809E6 : public RuntimeObject
{
public:
public:
};
// System.TypeNameParser
struct TypeNameParser_tBEF78C9D6AEC3DE5E2993F6EDC24C06F7B713741 : public RuntimeObject
{
public:
public:
};
// System.TypeNames
struct TypeNames_t59FBD5EB0A62A2B3A8178016670631D61DEE00F9 : public RuntimeObject
{
public:
public:
};
// System.TypeNames_ATypeName
struct ATypeName_t8FD4A465E3C2846D11FEAE25ED5BF3D67FF94421 : public RuntimeObject
{
public:
public:
};
// System.TypeSpec
struct TypeSpec_t943289F7C537252144A22588159B36C6B6759A7F : public RuntimeObject
{
public:
// System.TypeIdentifier System.TypeSpec::name
RuntimeObject* ___name_0;
// System.String System.TypeSpec::assembly_name
String_t* ___assembly_name_1;
// System.Collections.Generic.List`1<System.TypeIdentifier> System.TypeSpec::nested
List_1_tB8129EB4ADDDECD38E3E178F0A902C921B575166 * ___nested_2;
// System.Collections.Generic.List`1<System.TypeSpec> System.TypeSpec::generic_params
List_1_t8C8BF378AAB72B34B6EE63F686877AE7290ECFBA * ___generic_params_3;
// System.Collections.Generic.List`1<System.ModifierSpec> System.TypeSpec::modifier_spec
List_1_tFD995FD9C5961BB4B415EE63B297C4B19643A3C2 * ___modifier_spec_4;
// System.Boolean System.TypeSpec::is_byref
bool ___is_byref_5;
// System.String System.TypeSpec::display_fullname
String_t* ___display_fullname_6;
public:
inline static int32_t get_offset_of_name_0() { return static_cast<int32_t>(offsetof(TypeSpec_t943289F7C537252144A22588159B36C6B6759A7F, ___name_0)); }
inline RuntimeObject* get_name_0() const { return ___name_0; }
inline RuntimeObject** get_address_of_name_0() { return &___name_0; }
inline void set_name_0(RuntimeObject* value)
{
___name_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___name_0), (void*)value);
}
inline static int32_t get_offset_of_assembly_name_1() { return static_cast<int32_t>(offsetof(TypeSpec_t943289F7C537252144A22588159B36C6B6759A7F, ___assembly_name_1)); }
inline String_t* get_assembly_name_1() const { return ___assembly_name_1; }
inline String_t** get_address_of_assembly_name_1() { return &___assembly_name_1; }
inline void set_assembly_name_1(String_t* value)
{
___assembly_name_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___assembly_name_1), (void*)value);
}
inline static int32_t get_offset_of_nested_2() { return static_cast<int32_t>(offsetof(TypeSpec_t943289F7C537252144A22588159B36C6B6759A7F, ___nested_2)); }
inline List_1_tB8129EB4ADDDECD38E3E178F0A902C921B575166 * get_nested_2() const { return ___nested_2; }
inline List_1_tB8129EB4ADDDECD38E3E178F0A902C921B575166 ** get_address_of_nested_2() { return &___nested_2; }
inline void set_nested_2(List_1_tB8129EB4ADDDECD38E3E178F0A902C921B575166 * value)
{
___nested_2 = value;
Il2CppCodeGenWriteBarrier((void**)(&___nested_2), (void*)value);
}
inline static int32_t get_offset_of_generic_params_3() { return static_cast<int32_t>(offsetof(TypeSpec_t943289F7C537252144A22588159B36C6B6759A7F, ___generic_params_3)); }
inline List_1_t8C8BF378AAB72B34B6EE63F686877AE7290ECFBA * get_generic_params_3() const { return ___generic_params_3; }
inline List_1_t8C8BF378AAB72B34B6EE63F686877AE7290ECFBA ** get_address_of_generic_params_3() { return &___generic_params_3; }
inline void set_generic_params_3(List_1_t8C8BF378AAB72B34B6EE63F686877AE7290ECFBA * value)
{
___generic_params_3 = value;
Il2CppCodeGenWriteBarrier((void**)(&___generic_params_3), (void*)value);
}
inline static int32_t get_offset_of_modifier_spec_4() { return static_cast<int32_t>(offsetof(TypeSpec_t943289F7C537252144A22588159B36C6B6759A7F, ___modifier_spec_4)); }
inline List_1_tFD995FD9C5961BB4B415EE63B297C4B19643A3C2 * get_modifier_spec_4() const { return ___modifier_spec_4; }
inline List_1_tFD995FD9C5961BB4B415EE63B297C4B19643A3C2 ** get_address_of_modifier_spec_4() { return &___modifier_spec_4; }
inline void set_modifier_spec_4(List_1_tFD995FD9C5961BB4B415EE63B297C4B19643A3C2 * value)
{
___modifier_spec_4 = value;
Il2CppCodeGenWriteBarrier((void**)(&___modifier_spec_4), (void*)value);
}
inline static int32_t get_offset_of_is_byref_5() { return static_cast<int32_t>(offsetof(TypeSpec_t943289F7C537252144A22588159B36C6B6759A7F, ___is_byref_5)); }
inline bool get_is_byref_5() const { return ___is_byref_5; }
inline bool* get_address_of_is_byref_5() { return &___is_byref_5; }
inline void set_is_byref_5(bool value)
{
___is_byref_5 = value;
}
inline static int32_t get_offset_of_display_fullname_6() { return static_cast<int32_t>(offsetof(TypeSpec_t943289F7C537252144A22588159B36C6B6759A7F, ___display_fullname_6)); }
inline String_t* get_display_fullname_6() const { return ___display_fullname_6; }
inline String_t** get_address_of_display_fullname_6() { return &___display_fullname_6; }
inline void set_display_fullname_6(String_t* value)
{
___display_fullname_6 = value;
Il2CppCodeGenWriteBarrier((void**)(&___display_fullname_6), (void*)value);
}
};
// System.UnitySerializationHolder
struct UnitySerializationHolder_t6B17ABB985ACD3F8D9F9E3C146DEA5F730E1CEAC : public RuntimeObject
{
public:
// System.Type[] System.UnitySerializationHolder::m_instantiation
TypeU5BU5D_t7FE623A666B49176DE123306221193E888A12F5F* ___m_instantiation_0;
// System.Int32[] System.UnitySerializationHolder::m_elementTypes
Int32U5BU5D_t2B9E4FDDDB9F0A00EC0AC631BA2DA915EB1ECF83* ___m_elementTypes_1;
// System.Int32 System.UnitySerializationHolder::m_genericParameterPosition
int32_t ___m_genericParameterPosition_2;
// System.Type System.UnitySerializationHolder::m_declaringType
Type_t * ___m_declaringType_3;
// System.Reflection.MethodBase System.UnitySerializationHolder::m_declaringMethod
MethodBase_t * ___m_declaringMethod_4;
// System.String System.UnitySerializationHolder::m_data
String_t* ___m_data_5;
// System.String System.UnitySerializationHolder::m_assemblyName
String_t* ___m_assemblyName_6;
// System.Int32 System.UnitySerializationHolder::m_unityType
int32_t ___m_unityType_7;
public:
inline static int32_t get_offset_of_m_instantiation_0() { return static_cast<int32_t>(offsetof(UnitySerializationHolder_t6B17ABB985ACD3F8D9F9E3C146DEA5F730E1CEAC, ___m_instantiation_0)); }
inline TypeU5BU5D_t7FE623A666B49176DE123306221193E888A12F5F* get_m_instantiation_0() const { return ___m_instantiation_0; }
inline TypeU5BU5D_t7FE623A666B49176DE123306221193E888A12F5F** get_address_of_m_instantiation_0() { return &___m_instantiation_0; }
inline void set_m_instantiation_0(TypeU5BU5D_t7FE623A666B49176DE123306221193E888A12F5F* value)
{
___m_instantiation_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_instantiation_0), (void*)value);
}
inline static int32_t get_offset_of_m_elementTypes_1() { return static_cast<int32_t>(offsetof(UnitySerializationHolder_t6B17ABB985ACD3F8D9F9E3C146DEA5F730E1CEAC, ___m_elementTypes_1)); }
inline Int32U5BU5D_t2B9E4FDDDB9F0A00EC0AC631BA2DA915EB1ECF83* get_m_elementTypes_1() const { return ___m_elementTypes_1; }
inline Int32U5BU5D_t2B9E4FDDDB9F0A00EC0AC631BA2DA915EB1ECF83** get_address_of_m_elementTypes_1() { return &___m_elementTypes_1; }
inline void set_m_elementTypes_1(Int32U5BU5D_t2B9E4FDDDB9F0A00EC0AC631BA2DA915EB1ECF83* value)
{
___m_elementTypes_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_elementTypes_1), (void*)value);
}
inline static int32_t get_offset_of_m_genericParameterPosition_2() { return static_cast<int32_t>(offsetof(UnitySerializationHolder_t6B17ABB985ACD3F8D9F9E3C146DEA5F730E1CEAC, ___m_genericParameterPosition_2)); }
inline int32_t get_m_genericParameterPosition_2() const { return ___m_genericParameterPosition_2; }
inline int32_t* get_address_of_m_genericParameterPosition_2() { return &___m_genericParameterPosition_2; }
inline void set_m_genericParameterPosition_2(int32_t value)
{
___m_genericParameterPosition_2 = value;
}
inline static int32_t get_offset_of_m_declaringType_3() { return static_cast<int32_t>(offsetof(UnitySerializationHolder_t6B17ABB985ACD3F8D9F9E3C146DEA5F730E1CEAC, ___m_declaringType_3)); }
inline Type_t * get_m_declaringType_3() const { return ___m_declaringType_3; }
inline Type_t ** get_address_of_m_declaringType_3() { return &___m_declaringType_3; }
inline void set_m_declaringType_3(Type_t * value)
{
___m_declaringType_3 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_declaringType_3), (void*)value);
}
inline static int32_t get_offset_of_m_declaringMethod_4() { return static_cast<int32_t>(offsetof(UnitySerializationHolder_t6B17ABB985ACD3F8D9F9E3C146DEA5F730E1CEAC, ___m_declaringMethod_4)); }
inline MethodBase_t * get_m_declaringMethod_4() const { return ___m_declaringMethod_4; }
inline MethodBase_t ** get_address_of_m_declaringMethod_4() { return &___m_declaringMethod_4; }
inline void set_m_declaringMethod_4(MethodBase_t * value)
{
___m_declaringMethod_4 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_declaringMethod_4), (void*)value);
}
inline static int32_t get_offset_of_m_data_5() { return static_cast<int32_t>(offsetof(UnitySerializationHolder_t6B17ABB985ACD3F8D9F9E3C146DEA5F730E1CEAC, ___m_data_5)); }
inline String_t* get_m_data_5() const { return ___m_data_5; }
inline String_t** get_address_of_m_data_5() { return &___m_data_5; }
inline void set_m_data_5(String_t* value)
{
___m_data_5 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_data_5), (void*)value);
}
inline static int32_t get_offset_of_m_assemblyName_6() { return static_cast<int32_t>(offsetof(UnitySerializationHolder_t6B17ABB985ACD3F8D9F9E3C146DEA5F730E1CEAC, ___m_assemblyName_6)); }
inline String_t* get_m_assemblyName_6() const { return ___m_assemblyName_6; }
inline String_t** get_address_of_m_assemblyName_6() { return &___m_assemblyName_6; }
inline void set_m_assemblyName_6(String_t* value)
{
___m_assemblyName_6 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_assemblyName_6), (void*)value);
}
inline static int32_t get_offset_of_m_unityType_7() { return static_cast<int32_t>(offsetof(UnitySerializationHolder_t6B17ABB985ACD3F8D9F9E3C146DEA5F730E1CEAC, ___m_unityType_7)); }
inline int32_t get_m_unityType_7() const { return ___m_unityType_7; }
inline int32_t* get_address_of_m_unityType_7() { return &___m_unityType_7; }
inline void set_m_unityType_7(int32_t value)
{
___m_unityType_7 = value;
}
};
// System.ValueType
struct ValueType_t4D0C27076F7C36E76190FB3328E232BCB1CD1FFF : public RuntimeObject
{
public:
public:
};
// Native definition for P/Invoke marshalling of System.ValueType
struct ValueType_t4D0C27076F7C36E76190FB3328E232BCB1CD1FFF_marshaled_pinvoke
{
};
// Native definition for COM marshalling of System.ValueType
struct ValueType_t4D0C27076F7C36E76190FB3328E232BCB1CD1FFF_marshaled_com
{
};
// System.Version
struct Version_tDBE6876C59B6F56D4F8CAA03851177ABC6FE0DFD : public RuntimeObject
{
public:
// System.Int32 System.Version::_Major
int32_t ____Major_0;
// System.Int32 System.Version::_Minor
int32_t ____Minor_1;
// System.Int32 System.Version::_Build
int32_t ____Build_2;
// System.Int32 System.Version::_Revision
int32_t ____Revision_3;
public:
inline static int32_t get_offset_of__Major_0() { return static_cast<int32_t>(offsetof(Version_tDBE6876C59B6F56D4F8CAA03851177ABC6FE0DFD, ____Major_0)); }
inline int32_t get__Major_0() const { return ____Major_0; }
inline int32_t* get_address_of__Major_0() { return &____Major_0; }
inline void set__Major_0(int32_t value)
{
____Major_0 = value;
}
inline static int32_t get_offset_of__Minor_1() { return static_cast<int32_t>(offsetof(Version_tDBE6876C59B6F56D4F8CAA03851177ABC6FE0DFD, ____Minor_1)); }
inline int32_t get__Minor_1() const { return ____Minor_1; }
inline int32_t* get_address_of__Minor_1() { return &____Minor_1; }
inline void set__Minor_1(int32_t value)
{
____Minor_1 = value;
}
inline static int32_t get_offset_of__Build_2() { return static_cast<int32_t>(offsetof(Version_tDBE6876C59B6F56D4F8CAA03851177ABC6FE0DFD, ____Build_2)); }
inline int32_t get__Build_2() const { return ____Build_2; }
inline int32_t* get_address_of__Build_2() { return &____Build_2; }
inline void set__Build_2(int32_t value)
{
____Build_2 = value;
}
inline static int32_t get_offset_of__Revision_3() { return static_cast<int32_t>(offsetof(Version_tDBE6876C59B6F56D4F8CAA03851177ABC6FE0DFD, ____Revision_3)); }
inline int32_t get__Revision_3() const { return ____Revision_3; }
inline int32_t* get_address_of__Revision_3() { return &____Revision_3; }
inline void set__Revision_3(int32_t value)
{
____Revision_3 = value;
}
};
struct Version_tDBE6876C59B6F56D4F8CAA03851177ABC6FE0DFD_StaticFields
{
public:
// System.Char[] System.Version::SeparatorsArray
CharU5BU5D_t4CC6ABF0AD71BEC97E3C2F1E9C5677E46D3A75C2* ___SeparatorsArray_4;
public:
inline static int32_t get_offset_of_SeparatorsArray_4() { return static_cast<int32_t>(offsetof(Version_tDBE6876C59B6F56D4F8CAA03851177ABC6FE0DFD_StaticFields, ___SeparatorsArray_4)); }
inline CharU5BU5D_t4CC6ABF0AD71BEC97E3C2F1E9C5677E46D3A75C2* get_SeparatorsArray_4() const { return ___SeparatorsArray_4; }
inline CharU5BU5D_t4CC6ABF0AD71BEC97E3C2F1E9C5677E46D3A75C2** get_address_of_SeparatorsArray_4() { return &___SeparatorsArray_4; }
inline void set_SeparatorsArray_4(CharU5BU5D_t4CC6ABF0AD71BEC97E3C2F1E9C5677E46D3A75C2* value)
{
___SeparatorsArray_4 = value;
Il2CppCodeGenWriteBarrier((void**)(&___SeparatorsArray_4), (void*)value);
}
};
// System.__ComObject
struct __ComObject_t7C4C78B18A827C344A9826ECC7FCC40B7F6FD77C : public RuntimeObject
{
public:
public:
};
// System.__Filters
struct __Filters_tDD9D6B7C7A31B12AB3D5CCF1B115DD693F62DB34 : public RuntimeObject
{
public:
public:
};
struct __Filters_tDD9D6B7C7A31B12AB3D5CCF1B115DD693F62DB34_StaticFields
{
public:
// System.__Filters System.__Filters::Instance
__Filters_tDD9D6B7C7A31B12AB3D5CCF1B115DD693F62DB34 * ___Instance_0;
public:
inline static int32_t get_offset_of_Instance_0() { return static_cast<int32_t>(offsetof(__Filters_tDD9D6B7C7A31B12AB3D5CCF1B115DD693F62DB34_StaticFields, ___Instance_0)); }
inline __Filters_tDD9D6B7C7A31B12AB3D5CCF1B115DD693F62DB34 * get_Instance_0() const { return ___Instance_0; }
inline __Filters_tDD9D6B7C7A31B12AB3D5CCF1B115DD693F62DB34 ** get_address_of_Instance_0() { return &___Instance_0; }
inline void set_Instance_0(__Filters_tDD9D6B7C7A31B12AB3D5CCF1B115DD693F62DB34 * value)
{
___Instance_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___Instance_0), (void*)value);
}
};
// System.__Il2CppComObject
// System.ApplicationException
struct ApplicationException_t664823C3E0D3E1E7C7FA1C0DB4E19E98E9811C74 : public Exception_t
{
public:
public:
};
// System.Boolean
struct Boolean_tB53F6830F670160873277339AA58F15CAED4399C
{
public:
// System.Boolean System.Boolean::m_value
bool ___m_value_0;
public:
inline static int32_t get_offset_of_m_value_0() { return static_cast<int32_t>(offsetof(Boolean_tB53F6830F670160873277339AA58F15CAED4399C, ___m_value_0)); }
inline bool get_m_value_0() const { return ___m_value_0; }
inline bool* get_address_of_m_value_0() { return &___m_value_0; }
inline void set_m_value_0(bool value)
{
___m_value_0 = value;
}
};
struct Boolean_tB53F6830F670160873277339AA58F15CAED4399C_StaticFields
{
public:
// System.String System.Boolean::TrueString
String_t* ___TrueString_5;
// System.String System.Boolean::FalseString
String_t* ___FalseString_6;
public:
inline static int32_t get_offset_of_TrueString_5() { return static_cast<int32_t>(offsetof(Boolean_tB53F6830F670160873277339AA58F15CAED4399C_StaticFields, ___TrueString_5)); }
inline String_t* get_TrueString_5() const { return ___TrueString_5; }
inline String_t** get_address_of_TrueString_5() { return &___TrueString_5; }
inline void set_TrueString_5(String_t* value)
{
___TrueString_5 = value;
Il2CppCodeGenWriteBarrier((void**)(&___TrueString_5), (void*)value);
}
inline static int32_t get_offset_of_FalseString_6() { return static_cast<int32_t>(offsetof(Boolean_tB53F6830F670160873277339AA58F15CAED4399C_StaticFields, ___FalseString_6)); }
inline String_t* get_FalseString_6() const { return ___FalseString_6; }
inline String_t** get_address_of_FalseString_6() { return &___FalseString_6; }
inline void set_FalseString_6(String_t* value)
{
___FalseString_6 = value;
Il2CppCodeGenWriteBarrier((void**)(&___FalseString_6), (void*)value);
}
};
// System.Byte
struct Byte_tF87C579059BD4633E6840EBBBEEF899C6E33EF07
{
public:
// System.Byte System.Byte::m_value
uint8_t ___m_value_0;
public:
inline static int32_t get_offset_of_m_value_0() { return static_cast<int32_t>(offsetof(Byte_tF87C579059BD4633E6840EBBBEEF899C6E33EF07, ___m_value_0)); }
inline uint8_t get_m_value_0() const { return ___m_value_0; }
inline uint8_t* get_address_of_m_value_0() { return &___m_value_0; }
inline void set_m_value_0(uint8_t value)
{
___m_value_0 = value;
}
};
// System.Char
struct Char_tBF22D9FC341BE970735250BB6FF1A4A92BBA58B9
{
public:
// System.Char System.Char::m_value
Il2CppChar ___m_value_0;
public:
inline static int32_t get_offset_of_m_value_0() { return static_cast<int32_t>(offsetof(Char_tBF22D9FC341BE970735250BB6FF1A4A92BBA58B9, ___m_value_0)); }
inline Il2CppChar get_m_value_0() const { return ___m_value_0; }
inline Il2CppChar* get_address_of_m_value_0() { return &___m_value_0; }
inline void set_m_value_0(Il2CppChar value)
{
___m_value_0 = value;
}
};
struct Char_tBF22D9FC341BE970735250BB6FF1A4A92BBA58B9_StaticFields
{
public:
// System.Byte[] System.Char::categoryForLatin1
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* ___categoryForLatin1_3;
public:
inline static int32_t get_offset_of_categoryForLatin1_3() { return static_cast<int32_t>(offsetof(Char_tBF22D9FC341BE970735250BB6FF1A4A92BBA58B9_StaticFields, ___categoryForLatin1_3)); }
inline ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* get_categoryForLatin1_3() const { return ___categoryForLatin1_3; }
inline ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821** get_address_of_categoryForLatin1_3() { return &___categoryForLatin1_3; }
inline void set_categoryForLatin1_3(ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* value)
{
___categoryForLatin1_3 = value;
Il2CppCodeGenWriteBarrier((void**)(&___categoryForLatin1_3), (void*)value);
}
};
// System.Collections.Generic.List`1_Enumerator<System.ModifierSpec>
struct Enumerator_t947A94EE32E8D5A1E40EDCC5D83206D0832E531D
{
public:
// System.Collections.Generic.List`1<T> System.Collections.Generic.List`1_Enumerator::list
List_1_tFD995FD9C5961BB4B415EE63B297C4B19643A3C2 * ___list_0;
// System.Int32 System.Collections.Generic.List`1_Enumerator::index
int32_t ___index_1;
// System.Int32 System.Collections.Generic.List`1_Enumerator::version
int32_t ___version_2;
// T System.Collections.Generic.List`1_Enumerator::current
RuntimeObject* ___current_3;
public:
inline static int32_t get_offset_of_list_0() { return static_cast<int32_t>(offsetof(Enumerator_t947A94EE32E8D5A1E40EDCC5D83206D0832E531D, ___list_0)); }
inline List_1_tFD995FD9C5961BB4B415EE63B297C4B19643A3C2 * get_list_0() const { return ___list_0; }
inline List_1_tFD995FD9C5961BB4B415EE63B297C4B19643A3C2 ** get_address_of_list_0() { return &___list_0; }
inline void set_list_0(List_1_tFD995FD9C5961BB4B415EE63B297C4B19643A3C2 * value)
{
___list_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___list_0), (void*)value);
}
inline static int32_t get_offset_of_index_1() { return static_cast<int32_t>(offsetof(Enumerator_t947A94EE32E8D5A1E40EDCC5D83206D0832E531D, ___index_1)); }
inline int32_t get_index_1() const { return ___index_1; }
inline int32_t* get_address_of_index_1() { return &___index_1; }
inline void set_index_1(int32_t value)
{
___index_1 = value;
}
inline static int32_t get_offset_of_version_2() { return static_cast<int32_t>(offsetof(Enumerator_t947A94EE32E8D5A1E40EDCC5D83206D0832E531D, ___version_2)); }
inline int32_t get_version_2() const { return ___version_2; }
inline int32_t* get_address_of_version_2() { return &___version_2; }
inline void set_version_2(int32_t value)
{
___version_2 = value;
}
inline static int32_t get_offset_of_current_3() { return static_cast<int32_t>(offsetof(Enumerator_t947A94EE32E8D5A1E40EDCC5D83206D0832E531D, ___current_3)); }
inline RuntimeObject* get_current_3() const { return ___current_3; }
inline RuntimeObject** get_address_of_current_3() { return &___current_3; }
inline void set_current_3(RuntimeObject* value)
{
___current_3 = value;
Il2CppCodeGenWriteBarrier((void**)(&___current_3), (void*)value);
}
};
// System.Collections.Generic.List`1_Enumerator<System.Object>
struct Enumerator_tE0C99528D3DCE5863566CE37BD94162A4C0431CD
{
public:
// System.Collections.Generic.List`1<T> System.Collections.Generic.List`1_Enumerator::list
List_1_t05CC3C859AB5E6024394EF9A42E3E696628CA02D * ___list_0;
// System.Int32 System.Collections.Generic.List`1_Enumerator::index
int32_t ___index_1;
// System.Int32 System.Collections.Generic.List`1_Enumerator::version
int32_t ___version_2;
// T System.Collections.Generic.List`1_Enumerator::current
RuntimeObject * ___current_3;
public:
inline static int32_t get_offset_of_list_0() { return static_cast<int32_t>(offsetof(Enumerator_tE0C99528D3DCE5863566CE37BD94162A4C0431CD, ___list_0)); }
inline List_1_t05CC3C859AB5E6024394EF9A42E3E696628CA02D * get_list_0() const { return ___list_0; }
inline List_1_t05CC3C859AB5E6024394EF9A42E3E696628CA02D ** get_address_of_list_0() { return &___list_0; }
inline void set_list_0(List_1_t05CC3C859AB5E6024394EF9A42E3E696628CA02D * value)
{
___list_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___list_0), (void*)value);
}
inline static int32_t get_offset_of_index_1() { return static_cast<int32_t>(offsetof(Enumerator_tE0C99528D3DCE5863566CE37BD94162A4C0431CD, ___index_1)); }
inline int32_t get_index_1() const { return ___index_1; }
inline int32_t* get_address_of_index_1() { return &___index_1; }
inline void set_index_1(int32_t value)
{
___index_1 = value;
}
inline static int32_t get_offset_of_version_2() { return static_cast<int32_t>(offsetof(Enumerator_tE0C99528D3DCE5863566CE37BD94162A4C0431CD, ___version_2)); }
inline int32_t get_version_2() const { return ___version_2; }
inline int32_t* get_address_of_version_2() { return &___version_2; }
inline void set_version_2(int32_t value)
{
___version_2 = value;
}
inline static int32_t get_offset_of_current_3() { return static_cast<int32_t>(offsetof(Enumerator_tE0C99528D3DCE5863566CE37BD94162A4C0431CD, ___current_3)); }
inline RuntimeObject * get_current_3() const { return ___current_3; }
inline RuntimeObject ** get_address_of_current_3() { return &___current_3; }
inline void set_current_3(RuntimeObject * value)
{
___current_3 = value;
Il2CppCodeGenWriteBarrier((void**)(&___current_3), (void*)value);
}
};
// System.Collections.Generic.List`1_Enumerator<System.TypeIdentifier>
struct Enumerator_tF3C2A3B3C8EE5956E26FA5AE4C14FC7655975628
{
public:
// System.Collections.Generic.List`1<T> System.Collections.Generic.List`1_Enumerator::list
List_1_tB8129EB4ADDDECD38E3E178F0A902C921B575166 * ___list_0;
// System.Int32 System.Collections.Generic.List`1_Enumerator::index
int32_t ___index_1;
// System.Int32 System.Collections.Generic.List`1_Enumerator::version
int32_t ___version_2;
// T System.Collections.Generic.List`1_Enumerator::current
RuntimeObject* ___current_3;
public:
inline static int32_t get_offset_of_list_0() { return static_cast<int32_t>(offsetof(Enumerator_tF3C2A3B3C8EE5956E26FA5AE4C14FC7655975628, ___list_0)); }
inline List_1_tB8129EB4ADDDECD38E3E178F0A902C921B575166 * get_list_0() const { return ___list_0; }
inline List_1_tB8129EB4ADDDECD38E3E178F0A902C921B575166 ** get_address_of_list_0() { return &___list_0; }
inline void set_list_0(List_1_tB8129EB4ADDDECD38E3E178F0A902C921B575166 * value)
{
___list_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___list_0), (void*)value);
}
inline static int32_t get_offset_of_index_1() { return static_cast<int32_t>(offsetof(Enumerator_tF3C2A3B3C8EE5956E26FA5AE4C14FC7655975628, ___index_1)); }
inline int32_t get_index_1() const { return ___index_1; }
inline int32_t* get_address_of_index_1() { return &___index_1; }
inline void set_index_1(int32_t value)
{
___index_1 = value;
}
inline static int32_t get_offset_of_version_2() { return static_cast<int32_t>(offsetof(Enumerator_tF3C2A3B3C8EE5956E26FA5AE4C14FC7655975628, ___version_2)); }
inline int32_t get_version_2() const { return ___version_2; }
inline int32_t* get_address_of_version_2() { return &___version_2; }
inline void set_version_2(int32_t value)
{
___version_2 = value;
}
inline static int32_t get_offset_of_current_3() { return static_cast<int32_t>(offsetof(Enumerator_tF3C2A3B3C8EE5956E26FA5AE4C14FC7655975628, ___current_3)); }
inline RuntimeObject* get_current_3() const { return ___current_3; }
inline RuntimeObject** get_address_of_current_3() { return &___current_3; }
inline void set_current_3(RuntimeObject* value)
{
___current_3 = value;
Il2CppCodeGenWriteBarrier((void**)(&___current_3), (void*)value);
}
};
// System.Coord
struct Coord_t6CEFF682745DD47B1B4DA3ED268C0933021AC34A
{
public:
// System.Int16 System.Coord::X
int16_t ___X_0;
// System.Int16 System.Coord::Y
int16_t ___Y_1;
public:
inline static int32_t get_offset_of_X_0() { return static_cast<int32_t>(offsetof(Coord_t6CEFF682745DD47B1B4DA3ED268C0933021AC34A, ___X_0)); }
inline int16_t get_X_0() const { return ___X_0; }
inline int16_t* get_address_of_X_0() { return &___X_0; }
inline void set_X_0(int16_t value)
{
___X_0 = value;
}
inline static int32_t get_offset_of_Y_1() { return static_cast<int32_t>(offsetof(Coord_t6CEFF682745DD47B1B4DA3ED268C0933021AC34A, ___Y_1)); }
inline int16_t get_Y_1() const { return ___Y_1; }
inline int16_t* get_address_of_Y_1() { return &___Y_1; }
inline void set_Y_1(int16_t value)
{
___Y_1 = value;
}
};
// System.DateTime
struct DateTime_t349B7449FBAAFF4192636E2B7A07694DA9236132
{
public:
// System.UInt64 System.DateTime::dateData
uint64_t ___dateData_44;
public:
inline static int32_t get_offset_of_dateData_44() { return static_cast<int32_t>(offsetof(DateTime_t349B7449FBAAFF4192636E2B7A07694DA9236132, ___dateData_44)); }
inline uint64_t get_dateData_44() const { return ___dateData_44; }
inline uint64_t* get_address_of_dateData_44() { return &___dateData_44; }
inline void set_dateData_44(uint64_t value)
{
___dateData_44 = value;
}
};
struct DateTime_t349B7449FBAAFF4192636E2B7A07694DA9236132_StaticFields
{
public:
// System.Int32[] System.DateTime::DaysToMonth365
Int32U5BU5D_t2B9E4FDDDB9F0A00EC0AC631BA2DA915EB1ECF83* ___DaysToMonth365_29;
// System.Int32[] System.DateTime::DaysToMonth366
Int32U5BU5D_t2B9E4FDDDB9F0A00EC0AC631BA2DA915EB1ECF83* ___DaysToMonth366_30;
// System.DateTime System.DateTime::MinValue
DateTime_t349B7449FBAAFF4192636E2B7A07694DA9236132 ___MinValue_31;
// System.DateTime System.DateTime::MaxValue
DateTime_t349B7449FBAAFF4192636E2B7A07694DA9236132 ___MaxValue_32;
public:
inline static int32_t get_offset_of_DaysToMonth365_29() { return static_cast<int32_t>(offsetof(DateTime_t349B7449FBAAFF4192636E2B7A07694DA9236132_StaticFields, ___DaysToMonth365_29)); }
inline Int32U5BU5D_t2B9E4FDDDB9F0A00EC0AC631BA2DA915EB1ECF83* get_DaysToMonth365_29() const { return ___DaysToMonth365_29; }
inline Int32U5BU5D_t2B9E4FDDDB9F0A00EC0AC631BA2DA915EB1ECF83** get_address_of_DaysToMonth365_29() { return &___DaysToMonth365_29; }
inline void set_DaysToMonth365_29(Int32U5BU5D_t2B9E4FDDDB9F0A00EC0AC631BA2DA915EB1ECF83* value)
{
___DaysToMonth365_29 = value;
Il2CppCodeGenWriteBarrier((void**)(&___DaysToMonth365_29), (void*)value);
}
inline static int32_t get_offset_of_DaysToMonth366_30() { return static_cast<int32_t>(offsetof(DateTime_t349B7449FBAAFF4192636E2B7A07694DA9236132_StaticFields, ___DaysToMonth366_30)); }
inline Int32U5BU5D_t2B9E4FDDDB9F0A00EC0AC631BA2DA915EB1ECF83* get_DaysToMonth366_30() const { return ___DaysToMonth366_30; }
inline Int32U5BU5D_t2B9E4FDDDB9F0A00EC0AC631BA2DA915EB1ECF83** get_address_of_DaysToMonth366_30() { return &___DaysToMonth366_30; }
inline void set_DaysToMonth366_30(Int32U5BU5D_t2B9E4FDDDB9F0A00EC0AC631BA2DA915EB1ECF83* value)
{
___DaysToMonth366_30 = value;
Il2CppCodeGenWriteBarrier((void**)(&___DaysToMonth366_30), (void*)value);
}
inline static int32_t get_offset_of_MinValue_31() { return static_cast<int32_t>(offsetof(DateTime_t349B7449FBAAFF4192636E2B7A07694DA9236132_StaticFields, ___MinValue_31)); }
inline DateTime_t349B7449FBAAFF4192636E2B7A07694DA9236132 get_MinValue_31() const { return ___MinValue_31; }
inline DateTime_t349B7449FBAAFF4192636E2B7A07694DA9236132 * get_address_of_MinValue_31() { return &___MinValue_31; }
inline void set_MinValue_31(DateTime_t349B7449FBAAFF4192636E2B7A07694DA9236132 value)
{
___MinValue_31 = value;
}
inline static int32_t get_offset_of_MaxValue_32() { return static_cast<int32_t>(offsetof(DateTime_t349B7449FBAAFF4192636E2B7A07694DA9236132_StaticFields, ___MaxValue_32)); }
inline DateTime_t349B7449FBAAFF4192636E2B7A07694DA9236132 get_MaxValue_32() const { return ___MaxValue_32; }
inline DateTime_t349B7449FBAAFF4192636E2B7A07694DA9236132 * get_address_of_MaxValue_32() { return &___MaxValue_32; }
inline void set_MaxValue_32(DateTime_t349B7449FBAAFF4192636E2B7A07694DA9236132 value)
{
___MaxValue_32 = value;
}
};
// System.Decimal
struct Decimal_t44EE9DA309A1BF848308DE4DDFC070CAE6D95EE8
{
public:
// System.Int32 System.Decimal::flags
int32_t ___flags_14;
// System.Int32 System.Decimal::hi
int32_t ___hi_15;
// System.Int32 System.Decimal::lo
int32_t ___lo_16;
// System.Int32 System.Decimal::mid
int32_t ___mid_17;
public:
inline static int32_t get_offset_of_flags_14() { return static_cast<int32_t>(offsetof(Decimal_t44EE9DA309A1BF848308DE4DDFC070CAE6D95EE8, ___flags_14)); }
inline int32_t get_flags_14() const { return ___flags_14; }
inline int32_t* get_address_of_flags_14() { return &___flags_14; }
inline void set_flags_14(int32_t value)
{
___flags_14 = value;
}
inline static int32_t get_offset_of_hi_15() { return static_cast<int32_t>(offsetof(Decimal_t44EE9DA309A1BF848308DE4DDFC070CAE6D95EE8, ___hi_15)); }
inline int32_t get_hi_15() const { return ___hi_15; }
inline int32_t* get_address_of_hi_15() { return &___hi_15; }
inline void set_hi_15(int32_t value)
{
___hi_15 = value;
}
inline static int32_t get_offset_of_lo_16() { return static_cast<int32_t>(offsetof(Decimal_t44EE9DA309A1BF848308DE4DDFC070CAE6D95EE8, ___lo_16)); }
inline int32_t get_lo_16() const { return ___lo_16; }
inline int32_t* get_address_of_lo_16() { return &___lo_16; }
inline void set_lo_16(int32_t value)
{
___lo_16 = value;
}
inline static int32_t get_offset_of_mid_17() { return static_cast<int32_t>(offsetof(Decimal_t44EE9DA309A1BF848308DE4DDFC070CAE6D95EE8, ___mid_17)); }
inline int32_t get_mid_17() const { return ___mid_17; }
inline int32_t* get_address_of_mid_17() { return &___mid_17; }
inline void set_mid_17(int32_t value)
{
___mid_17 = value;
}
};
struct Decimal_t44EE9DA309A1BF848308DE4DDFC070CAE6D95EE8_StaticFields
{
public:
// System.UInt32[] System.Decimal::Powers10
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* ___Powers10_6;
// System.Decimal System.Decimal::Zero
Decimal_t44EE9DA309A1BF848308DE4DDFC070CAE6D95EE8 ___Zero_7;
// System.Decimal System.Decimal::One
Decimal_t44EE9DA309A1BF848308DE4DDFC070CAE6D95EE8 ___One_8;
// System.Decimal System.Decimal::MinusOne
Decimal_t44EE9DA309A1BF848308DE4DDFC070CAE6D95EE8 ___MinusOne_9;
// System.Decimal System.Decimal::MaxValue
Decimal_t44EE9DA309A1BF848308DE4DDFC070CAE6D95EE8 ___MaxValue_10;
// System.Decimal System.Decimal::MinValue
Decimal_t44EE9DA309A1BF848308DE4DDFC070CAE6D95EE8 ___MinValue_11;
// System.Decimal System.Decimal::NearNegativeZero
Decimal_t44EE9DA309A1BF848308DE4DDFC070CAE6D95EE8 ___NearNegativeZero_12;
// System.Decimal System.Decimal::NearPositiveZero
Decimal_t44EE9DA309A1BF848308DE4DDFC070CAE6D95EE8 ___NearPositiveZero_13;
public:
inline static int32_t get_offset_of_Powers10_6() { return static_cast<int32_t>(offsetof(Decimal_t44EE9DA309A1BF848308DE4DDFC070CAE6D95EE8_StaticFields, ___Powers10_6)); }
inline UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* get_Powers10_6() const { return ___Powers10_6; }
inline UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB** get_address_of_Powers10_6() { return &___Powers10_6; }
inline void set_Powers10_6(UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* value)
{
___Powers10_6 = value;
Il2CppCodeGenWriteBarrier((void**)(&___Powers10_6), (void*)value);
}
inline static int32_t get_offset_of_Zero_7() { return static_cast<int32_t>(offsetof(Decimal_t44EE9DA309A1BF848308DE4DDFC070CAE6D95EE8_StaticFields, ___Zero_7)); }
inline Decimal_t44EE9DA309A1BF848308DE4DDFC070CAE6D95EE8 get_Zero_7() const { return ___Zero_7; }
inline Decimal_t44EE9DA309A1BF848308DE4DDFC070CAE6D95EE8 * get_address_of_Zero_7() { return &___Zero_7; }
inline void set_Zero_7(Decimal_t44EE9DA309A1BF848308DE4DDFC070CAE6D95EE8 value)
{
___Zero_7 = value;
}
inline static int32_t get_offset_of_One_8() { return static_cast<int32_t>(offsetof(Decimal_t44EE9DA309A1BF848308DE4DDFC070CAE6D95EE8_StaticFields, ___One_8)); }
inline Decimal_t44EE9DA309A1BF848308DE4DDFC070CAE6D95EE8 get_One_8() const { return ___One_8; }
inline Decimal_t44EE9DA309A1BF848308DE4DDFC070CAE6D95EE8 * get_address_of_One_8() { return &___One_8; }
inline void set_One_8(Decimal_t44EE9DA309A1BF848308DE4DDFC070CAE6D95EE8 value)
{
___One_8 = value;
}
inline static int32_t get_offset_of_MinusOne_9() { return static_cast<int32_t>(offsetof(Decimal_t44EE9DA309A1BF848308DE4DDFC070CAE6D95EE8_StaticFields, ___MinusOne_9)); }
inline Decimal_t44EE9DA309A1BF848308DE4DDFC070CAE6D95EE8 get_MinusOne_9() const { return ___MinusOne_9; }
inline Decimal_t44EE9DA309A1BF848308DE4DDFC070CAE6D95EE8 * get_address_of_MinusOne_9() { return &___MinusOne_9; }
inline void set_MinusOne_9(Decimal_t44EE9DA309A1BF848308DE4DDFC070CAE6D95EE8 value)
{
___MinusOne_9 = value;
}
inline static int32_t get_offset_of_MaxValue_10() { return static_cast<int32_t>(offsetof(Decimal_t44EE9DA309A1BF848308DE4DDFC070CAE6D95EE8_StaticFields, ___MaxValue_10)); }
inline Decimal_t44EE9DA309A1BF848308DE4DDFC070CAE6D95EE8 get_MaxValue_10() const { return ___MaxValue_10; }
inline Decimal_t44EE9DA309A1BF848308DE4DDFC070CAE6D95EE8 * get_address_of_MaxValue_10() { return &___MaxValue_10; }
inline void set_MaxValue_10(Decimal_t44EE9DA309A1BF848308DE4DDFC070CAE6D95EE8 value)
{
___MaxValue_10 = value;
}
inline static int32_t get_offset_of_MinValue_11() { return static_cast<int32_t>(offsetof(Decimal_t44EE9DA309A1BF848308DE4DDFC070CAE6D95EE8_StaticFields, ___MinValue_11)); }
inline Decimal_t44EE9DA309A1BF848308DE4DDFC070CAE6D95EE8 get_MinValue_11() const { return ___MinValue_11; }
inline Decimal_t44EE9DA309A1BF848308DE4DDFC070CAE6D95EE8 * get_address_of_MinValue_11() { return &___MinValue_11; }
inline void set_MinValue_11(Decimal_t44EE9DA309A1BF848308DE4DDFC070CAE6D95EE8 value)
{
___MinValue_11 = value;
}
inline static int32_t get_offset_of_NearNegativeZero_12() { return static_cast<int32_t>(offsetof(Decimal_t44EE9DA309A1BF848308DE4DDFC070CAE6D95EE8_StaticFields, ___NearNegativeZero_12)); }
inline Decimal_t44EE9DA309A1BF848308DE4DDFC070CAE6D95EE8 get_NearNegativeZero_12() const { return ___NearNegativeZero_12; }
inline Decimal_t44EE9DA309A1BF848308DE4DDFC070CAE6D95EE8 * get_address_of_NearNegativeZero_12() { return &___NearNegativeZero_12; }
inline void set_NearNegativeZero_12(Decimal_t44EE9DA309A1BF848308DE4DDFC070CAE6D95EE8 value)
{
___NearNegativeZero_12 = value;
}
inline static int32_t get_offset_of_NearPositiveZero_13() { return static_cast<int32_t>(offsetof(Decimal_t44EE9DA309A1BF848308DE4DDFC070CAE6D95EE8_StaticFields, ___NearPositiveZero_13)); }
inline Decimal_t44EE9DA309A1BF848308DE4DDFC070CAE6D95EE8 get_NearPositiveZero_13() const { return ___NearPositiveZero_13; }
inline Decimal_t44EE9DA309A1BF848308DE4DDFC070CAE6D95EE8 * get_address_of_NearPositiveZero_13() { return &___NearPositiveZero_13; }
inline void set_NearPositiveZero_13(Decimal_t44EE9DA309A1BF848308DE4DDFC070CAE6D95EE8 value)
{
___NearPositiveZero_13 = value;
}
};
// System.Double
struct Double_t358B8F23BDC52A5DD700E727E204F9F7CDE12409
{
public:
// System.Double System.Double::m_value
double ___m_value_0;
public:
inline static int32_t get_offset_of_m_value_0() { return static_cast<int32_t>(offsetof(Double_t358B8F23BDC52A5DD700E727E204F9F7CDE12409, ___m_value_0)); }
inline double get_m_value_0() const { return ___m_value_0; }
inline double* get_address_of_m_value_0() { return &___m_value_0; }
inline void set_m_value_0(double value)
{
___m_value_0 = value;
}
};
struct Double_t358B8F23BDC52A5DD700E727E204F9F7CDE12409_StaticFields
{
public:
// System.Double System.Double::NegativeZero
double ___NegativeZero_7;
public:
inline static int32_t get_offset_of_NegativeZero_7() { return static_cast<int32_t>(offsetof(Double_t358B8F23BDC52A5DD700E727E204F9F7CDE12409_StaticFields, ___NegativeZero_7)); }
inline double get_NegativeZero_7() const { return ___NegativeZero_7; }
inline double* get_address_of_NegativeZero_7() { return &___NegativeZero_7; }
inline void set_NegativeZero_7(double value)
{
___NegativeZero_7 = value;
}
};
// System.Enum
struct Enum_t2AF27C02B8653AE29442467390005ABC74D8F521 : public ValueType_t4D0C27076F7C36E76190FB3328E232BCB1CD1FFF
{
public:
public:
};
struct Enum_t2AF27C02B8653AE29442467390005ABC74D8F521_StaticFields
{
public:
// System.Char[] System.Enum::enumSeperatorCharArray
CharU5BU5D_t4CC6ABF0AD71BEC97E3C2F1E9C5677E46D3A75C2* ___enumSeperatorCharArray_0;
public:
inline static int32_t get_offset_of_enumSeperatorCharArray_0() { return static_cast<int32_t>(offsetof(Enum_t2AF27C02B8653AE29442467390005ABC74D8F521_StaticFields, ___enumSeperatorCharArray_0)); }
inline CharU5BU5D_t4CC6ABF0AD71BEC97E3C2F1E9C5677E46D3A75C2* get_enumSeperatorCharArray_0() const { return ___enumSeperatorCharArray_0; }
inline CharU5BU5D_t4CC6ABF0AD71BEC97E3C2F1E9C5677E46D3A75C2** get_address_of_enumSeperatorCharArray_0() { return &___enumSeperatorCharArray_0; }
inline void set_enumSeperatorCharArray_0(CharU5BU5D_t4CC6ABF0AD71BEC97E3C2F1E9C5677E46D3A75C2* value)
{
___enumSeperatorCharArray_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___enumSeperatorCharArray_0), (void*)value);
}
};
// Native definition for P/Invoke marshalling of System.Enum
struct Enum_t2AF27C02B8653AE29442467390005ABC74D8F521_marshaled_pinvoke
{
};
// Native definition for COM marshalling of System.Enum
struct Enum_t2AF27C02B8653AE29442467390005ABC74D8F521_marshaled_com
{
};
// System.InputRecord
struct InputRecord_tAB007C739F339BE208F3C4796B53E9044ADF0A78
{
public:
// System.Int16 System.InputRecord::EventType
int16_t ___EventType_0;
// System.Boolean System.InputRecord::KeyDown
bool ___KeyDown_1;
// System.Int16 System.InputRecord::RepeatCount
int16_t ___RepeatCount_2;
// System.Int16 System.InputRecord::VirtualKeyCode
int16_t ___VirtualKeyCode_3;
// System.Int16 System.InputRecord::VirtualScanCode
int16_t ___VirtualScanCode_4;
// System.Char System.InputRecord::Character
Il2CppChar ___Character_5;
// System.Int32 System.InputRecord::ControlKeyState
int32_t ___ControlKeyState_6;
// System.Int32 System.InputRecord::pad1
int32_t ___pad1_7;
// System.Boolean System.InputRecord::pad2
bool ___pad2_8;
public:
inline static int32_t get_offset_of_EventType_0() { return static_cast<int32_t>(offsetof(InputRecord_tAB007C739F339BE208F3C4796B53E9044ADF0A78, ___EventType_0)); }
inline int16_t get_EventType_0() const { return ___EventType_0; }
inline int16_t* get_address_of_EventType_0() { return &___EventType_0; }
inline void set_EventType_0(int16_t value)
{
___EventType_0 = value;
}
inline static int32_t get_offset_of_KeyDown_1() { return static_cast<int32_t>(offsetof(InputRecord_tAB007C739F339BE208F3C4796B53E9044ADF0A78, ___KeyDown_1)); }
inline bool get_KeyDown_1() const { return ___KeyDown_1; }
inline bool* get_address_of_KeyDown_1() { return &___KeyDown_1; }
inline void set_KeyDown_1(bool value)
{
___KeyDown_1 = value;
}
inline static int32_t get_offset_of_RepeatCount_2() { return static_cast<int32_t>(offsetof(InputRecord_tAB007C739F339BE208F3C4796B53E9044ADF0A78, ___RepeatCount_2)); }
inline int16_t get_RepeatCount_2() const { return ___RepeatCount_2; }
inline int16_t* get_address_of_RepeatCount_2() { return &___RepeatCount_2; }
inline void set_RepeatCount_2(int16_t value)
{
___RepeatCount_2 = value;
}
inline static int32_t get_offset_of_VirtualKeyCode_3() { return static_cast<int32_t>(offsetof(InputRecord_tAB007C739F339BE208F3C4796B53E9044ADF0A78, ___VirtualKeyCode_3)); }
inline int16_t get_VirtualKeyCode_3() const { return ___VirtualKeyCode_3; }
inline int16_t* get_address_of_VirtualKeyCode_3() { return &___VirtualKeyCode_3; }
inline void set_VirtualKeyCode_3(int16_t value)
{
___VirtualKeyCode_3 = value;
}
inline static int32_t get_offset_of_VirtualScanCode_4() { return static_cast<int32_t>(offsetof(InputRecord_tAB007C739F339BE208F3C4796B53E9044ADF0A78, ___VirtualScanCode_4)); }
inline int16_t get_VirtualScanCode_4() const { return ___VirtualScanCode_4; }
inline int16_t* get_address_of_VirtualScanCode_4() { return &___VirtualScanCode_4; }
inline void set_VirtualScanCode_4(int16_t value)
{
___VirtualScanCode_4 = value;
}
inline static int32_t get_offset_of_Character_5() { return static_cast<int32_t>(offsetof(InputRecord_tAB007C739F339BE208F3C4796B53E9044ADF0A78, ___Character_5)); }
inline Il2CppChar get_Character_5() const { return ___Character_5; }
inline Il2CppChar* get_address_of_Character_5() { return &___Character_5; }
inline void set_Character_5(Il2CppChar value)
{
___Character_5 = value;
}
inline static int32_t get_offset_of_ControlKeyState_6() { return static_cast<int32_t>(offsetof(InputRecord_tAB007C739F339BE208F3C4796B53E9044ADF0A78, ___ControlKeyState_6)); }
inline int32_t get_ControlKeyState_6() const { return ___ControlKeyState_6; }
inline int32_t* get_address_of_ControlKeyState_6() { return &___ControlKeyState_6; }
inline void set_ControlKeyState_6(int32_t value)
{
___ControlKeyState_6 = value;
}
inline static int32_t get_offset_of_pad1_7() { return static_cast<int32_t>(offsetof(InputRecord_tAB007C739F339BE208F3C4796B53E9044ADF0A78, ___pad1_7)); }
inline int32_t get_pad1_7() const { return ___pad1_7; }
inline int32_t* get_address_of_pad1_7() { return &___pad1_7; }
inline void set_pad1_7(int32_t value)
{
___pad1_7 = value;
}
inline static int32_t get_offset_of_pad2_8() { return static_cast<int32_t>(offsetof(InputRecord_tAB007C739F339BE208F3C4796B53E9044ADF0A78, ___pad2_8)); }
inline bool get_pad2_8() const { return ___pad2_8; }
inline bool* get_address_of_pad2_8() { return &___pad2_8; }
inline void set_pad2_8(bool value)
{
___pad2_8 = value;
}
};
// Native definition for P/Invoke marshalling of System.InputRecord
struct InputRecord_tAB007C739F339BE208F3C4796B53E9044ADF0A78_marshaled_pinvoke
{
int16_t ___EventType_0;
int32_t ___KeyDown_1;
int16_t ___RepeatCount_2;
int16_t ___VirtualKeyCode_3;
int16_t ___VirtualScanCode_4;
uint8_t ___Character_5;
int32_t ___ControlKeyState_6;
int32_t ___pad1_7;
int32_t ___pad2_8;
};
// Native definition for COM marshalling of System.InputRecord
struct InputRecord_tAB007C739F339BE208F3C4796B53E9044ADF0A78_marshaled_com
{
int16_t ___EventType_0;
int32_t ___KeyDown_1;
int16_t ___RepeatCount_2;
int16_t ___VirtualKeyCode_3;
int16_t ___VirtualScanCode_4;
uint8_t ___Character_5;
int32_t ___ControlKeyState_6;
int32_t ___pad1_7;
int32_t ___pad2_8;
};
// System.Int16
struct Int16_t823A20635DAF5A3D93A1E01CFBF3CBA27CF00B4D
{
public:
// System.Int16 System.Int16::m_value
int16_t ___m_value_0;
public:
inline static int32_t get_offset_of_m_value_0() { return static_cast<int32_t>(offsetof(Int16_t823A20635DAF5A3D93A1E01CFBF3CBA27CF00B4D, ___m_value_0)); }
inline int16_t get_m_value_0() const { return ___m_value_0; }
inline int16_t* get_address_of_m_value_0() { return &___m_value_0; }
inline void set_m_value_0(int16_t value)
{
___m_value_0 = value;
}
};
// System.Int32
struct Int32_t585191389E07734F19F3156FF88FB3EF4800D102
{
public:
// System.Int32 System.Int32::m_value
int32_t ___m_value_0;
public:
inline static int32_t get_offset_of_m_value_0() { return static_cast<int32_t>(offsetof(Int32_t585191389E07734F19F3156FF88FB3EF4800D102, ___m_value_0)); }
inline int32_t get_m_value_0() const { return ___m_value_0; }
inline int32_t* get_address_of_m_value_0() { return &___m_value_0; }
inline void set_m_value_0(int32_t value)
{
___m_value_0 = value;
}
};
// System.Int64
struct Int64_t7A386C2FF7B0280A0F516992401DDFCF0FF7B436
{
public:
// System.Int64 System.Int64::m_value
int64_t ___m_value_0;
public:
inline static int32_t get_offset_of_m_value_0() { return static_cast<int32_t>(offsetof(Int64_t7A386C2FF7B0280A0F516992401DDFCF0FF7B436, ___m_value_0)); }
inline int64_t get_m_value_0() const { return ___m_value_0; }
inline int64_t* get_address_of_m_value_0() { return &___m_value_0; }
inline void set_m_value_0(int64_t value)
{
___m_value_0 = value;
}
};
// System.IntPtr
struct IntPtr_t
{
public:
// System.Void* System.IntPtr::m_value
void* ___m_value_0;
public:
inline static int32_t get_offset_of_m_value_0() { return static_cast<int32_t>(offsetof(IntPtr_t, ___m_value_0)); }
inline void* get_m_value_0() const { return ___m_value_0; }
inline void** get_address_of_m_value_0() { return &___m_value_0; }
inline void set_m_value_0(void* value)
{
___m_value_0 = value;
}
};
struct IntPtr_t_StaticFields
{
public:
// System.IntPtr System.IntPtr::Zero
intptr_t ___Zero_1;
public:
inline static int32_t get_offset_of_Zero_1() { return static_cast<int32_t>(offsetof(IntPtr_t_StaticFields, ___Zero_1)); }
inline intptr_t get_Zero_1() const { return ___Zero_1; }
inline intptr_t* get_address_of_Zero_1() { return &___Zero_1; }
inline void set_Zero_1(intptr_t value)
{
___Zero_1 = value;
}
};
// System.Reflection.FieldInfo
struct FieldInfo_t : public MemberInfo_t
{
public:
public:
};
// System.Reflection.MethodBase
struct MethodBase_t : public MemberInfo_t
{
public:
public:
};
// System.Runtime.InteropServices.GCHandle
struct GCHandle_t39FAEE3EA592432C93B574A31DD83B87F1847DE3
{
public:
// System.Int32 System.Runtime.InteropServices.GCHandle::handle
int32_t ___handle_0;
public:
inline static int32_t get_offset_of_handle_0() { return static_cast<int32_t>(offsetof(GCHandle_t39FAEE3EA592432C93B574A31DD83B87F1847DE3, ___handle_0)); }
inline int32_t get_handle_0() const { return ___handle_0; }
inline int32_t* get_address_of_handle_0() { return &___handle_0; }
inline void set_handle_0(int32_t value)
{
___handle_0 = value;
}
};
// System.SByte
struct SByte_t9070AEA2966184235653CB9B4D33B149CDA831DF
{
public:
// System.SByte System.SByte::m_value
int8_t ___m_value_0;
public:
inline static int32_t get_offset_of_m_value_0() { return static_cast<int32_t>(offsetof(SByte_t9070AEA2966184235653CB9B4D33B149CDA831DF, ___m_value_0)); }
inline int8_t get_m_value_0() const { return ___m_value_0; }
inline int8_t* get_address_of_m_value_0() { return &___m_value_0; }
inline void set_m_value_0(int8_t value)
{
___m_value_0 = value;
}
};
// System.Single
struct Single_tDDDA9169C4E4E308AC6D7A824F9B28DC82204AE1
{
public:
// System.Single System.Single::m_value
float ___m_value_0;
public:
inline static int32_t get_offset_of_m_value_0() { return static_cast<int32_t>(offsetof(Single_tDDDA9169C4E4E308AC6D7A824F9B28DC82204AE1, ___m_value_0)); }
inline float get_m_value_0() const { return ___m_value_0; }
inline float* get_address_of_m_value_0() { return &___m_value_0; }
inline void set_m_value_0(float value)
{
___m_value_0 = value;
}
};
// System.SmallRect
struct SmallRect_t18C271B0FF660F6ED4EC6D99B26C4D35F51CA532
{
public:
// System.Int16 System.SmallRect::Left
int16_t ___Left_0;
// System.Int16 System.SmallRect::Top
int16_t ___Top_1;
// System.Int16 System.SmallRect::Right
int16_t ___Right_2;
// System.Int16 System.SmallRect::Bottom
int16_t ___Bottom_3;
public:
inline static int32_t get_offset_of_Left_0() { return static_cast<int32_t>(offsetof(SmallRect_t18C271B0FF660F6ED4EC6D99B26C4D35F51CA532, ___Left_0)); }
inline int16_t get_Left_0() const { return ___Left_0; }
inline int16_t* get_address_of_Left_0() { return &___Left_0; }
inline void set_Left_0(int16_t value)
{
___Left_0 = value;
}
inline static int32_t get_offset_of_Top_1() { return static_cast<int32_t>(offsetof(SmallRect_t18C271B0FF660F6ED4EC6D99B26C4D35F51CA532, ___Top_1)); }
inline int16_t get_Top_1() const { return ___Top_1; }
inline int16_t* get_address_of_Top_1() { return &___Top_1; }
inline void set_Top_1(int16_t value)
{
___Top_1 = value;
}
inline static int32_t get_offset_of_Right_2() { return static_cast<int32_t>(offsetof(SmallRect_t18C271B0FF660F6ED4EC6D99B26C4D35F51CA532, ___Right_2)); }
inline int16_t get_Right_2() const { return ___Right_2; }
inline int16_t* get_address_of_Right_2() { return &___Right_2; }
inline void set_Right_2(int16_t value)
{
___Right_2 = value;
}
inline static int32_t get_offset_of_Bottom_3() { return static_cast<int32_t>(offsetof(SmallRect_t18C271B0FF660F6ED4EC6D99B26C4D35F51CA532, ___Bottom_3)); }
inline int16_t get_Bottom_3() const { return ___Bottom_3; }
inline int16_t* get_address_of_Bottom_3() { return &___Bottom_3; }
inline void set_Bottom_3(int16_t value)
{
___Bottom_3 = value;
}
};
// System.SystemException
struct SystemException_t5380468142AA850BE4A341D7AF3EAB9C78746782 : public Exception_t
{
public:
public:
};
// System.Threading.Thread
struct Thread_tF60E0A146CD3B5480CB65FF9B6016E84C5460CC7 : public CriticalFinalizerObject_t8B006E1DEE084E781F5C0F3283E9226E28894DD9
{
public:
// System.Threading.InternalThread System.Threading.Thread::internal_thread
InternalThread_tA4C58C2A7D15AF43C3E7507375E6D31DBBE7D192 * ___internal_thread_6;
// System.Object System.Threading.Thread::m_ThreadStartArg
RuntimeObject * ___m_ThreadStartArg_7;
// System.Object System.Threading.Thread::pending_exception
RuntimeObject * ___pending_exception_8;
// System.Security.Principal.IPrincipal System.Threading.Thread::principal
RuntimeObject* ___principal_9;
// System.Int32 System.Threading.Thread::principal_version
int32_t ___principal_version_10;
// System.MulticastDelegate System.Threading.Thread::m_Delegate
MulticastDelegate_t * ___m_Delegate_12;
// System.Threading.ExecutionContext System.Threading.Thread::m_ExecutionContext
ExecutionContext_t0E11C30308A4CC964D8A2EA9132F9BDCE5362C70 * ___m_ExecutionContext_13;
// System.Boolean System.Threading.Thread::m_ExecutionContextBelongsToOuterScope
bool ___m_ExecutionContextBelongsToOuterScope_14;
public:
inline static int32_t get_offset_of_internal_thread_6() { return static_cast<int32_t>(offsetof(Thread_tF60E0A146CD3B5480CB65FF9B6016E84C5460CC7, ___internal_thread_6)); }
inline InternalThread_tA4C58C2A7D15AF43C3E7507375E6D31DBBE7D192 * get_internal_thread_6() const { return ___internal_thread_6; }
inline InternalThread_tA4C58C2A7D15AF43C3E7507375E6D31DBBE7D192 ** get_address_of_internal_thread_6() { return &___internal_thread_6; }
inline void set_internal_thread_6(InternalThread_tA4C58C2A7D15AF43C3E7507375E6D31DBBE7D192 * value)
{
___internal_thread_6 = value;
Il2CppCodeGenWriteBarrier((void**)(&___internal_thread_6), (void*)value);
}
inline static int32_t get_offset_of_m_ThreadStartArg_7() { return static_cast<int32_t>(offsetof(Thread_tF60E0A146CD3B5480CB65FF9B6016E84C5460CC7, ___m_ThreadStartArg_7)); }
inline RuntimeObject * get_m_ThreadStartArg_7() const { return ___m_ThreadStartArg_7; }
inline RuntimeObject ** get_address_of_m_ThreadStartArg_7() { return &___m_ThreadStartArg_7; }
inline void set_m_ThreadStartArg_7(RuntimeObject * value)
{
___m_ThreadStartArg_7 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_ThreadStartArg_7), (void*)value);
}
inline static int32_t get_offset_of_pending_exception_8() { return static_cast<int32_t>(offsetof(Thread_tF60E0A146CD3B5480CB65FF9B6016E84C5460CC7, ___pending_exception_8)); }
inline RuntimeObject * get_pending_exception_8() const { return ___pending_exception_8; }
inline RuntimeObject ** get_address_of_pending_exception_8() { return &___pending_exception_8; }
inline void set_pending_exception_8(RuntimeObject * value)
{
___pending_exception_8 = value;
Il2CppCodeGenWriteBarrier((void**)(&___pending_exception_8), (void*)value);
}
inline static int32_t get_offset_of_principal_9() { return static_cast<int32_t>(offsetof(Thread_tF60E0A146CD3B5480CB65FF9B6016E84C5460CC7, ___principal_9)); }
inline RuntimeObject* get_principal_9() const { return ___principal_9; }
inline RuntimeObject** get_address_of_principal_9() { return &___principal_9; }
inline void set_principal_9(RuntimeObject* value)
{
___principal_9 = value;
Il2CppCodeGenWriteBarrier((void**)(&___principal_9), (void*)value);
}
inline static int32_t get_offset_of_principal_version_10() { return static_cast<int32_t>(offsetof(Thread_tF60E0A146CD3B5480CB65FF9B6016E84C5460CC7, ___principal_version_10)); }
inline int32_t get_principal_version_10() const { return ___principal_version_10; }
inline int32_t* get_address_of_principal_version_10() { return &___principal_version_10; }
inline void set_principal_version_10(int32_t value)
{
___principal_version_10 = value;
}
inline static int32_t get_offset_of_m_Delegate_12() { return static_cast<int32_t>(offsetof(Thread_tF60E0A146CD3B5480CB65FF9B6016E84C5460CC7, ___m_Delegate_12)); }
inline MulticastDelegate_t * get_m_Delegate_12() const { return ___m_Delegate_12; }
inline MulticastDelegate_t ** get_address_of_m_Delegate_12() { return &___m_Delegate_12; }
inline void set_m_Delegate_12(MulticastDelegate_t * value)
{
___m_Delegate_12 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_Delegate_12), (void*)value);
}
inline static int32_t get_offset_of_m_ExecutionContext_13() { return static_cast<int32_t>(offsetof(Thread_tF60E0A146CD3B5480CB65FF9B6016E84C5460CC7, ___m_ExecutionContext_13)); }
inline ExecutionContext_t0E11C30308A4CC964D8A2EA9132F9BDCE5362C70 * get_m_ExecutionContext_13() const { return ___m_ExecutionContext_13; }
inline ExecutionContext_t0E11C30308A4CC964D8A2EA9132F9BDCE5362C70 ** get_address_of_m_ExecutionContext_13() { return &___m_ExecutionContext_13; }
inline void set_m_ExecutionContext_13(ExecutionContext_t0E11C30308A4CC964D8A2EA9132F9BDCE5362C70 * value)
{
___m_ExecutionContext_13 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_ExecutionContext_13), (void*)value);
}
inline static int32_t get_offset_of_m_ExecutionContextBelongsToOuterScope_14() { return static_cast<int32_t>(offsetof(Thread_tF60E0A146CD3B5480CB65FF9B6016E84C5460CC7, ___m_ExecutionContextBelongsToOuterScope_14)); }
inline bool get_m_ExecutionContextBelongsToOuterScope_14() const { return ___m_ExecutionContextBelongsToOuterScope_14; }
inline bool* get_address_of_m_ExecutionContextBelongsToOuterScope_14() { return &___m_ExecutionContextBelongsToOuterScope_14; }
inline void set_m_ExecutionContextBelongsToOuterScope_14(bool value)
{
___m_ExecutionContextBelongsToOuterScope_14 = value;
}
};
struct Thread_tF60E0A146CD3B5480CB65FF9B6016E84C5460CC7_StaticFields
{
public:
// System.LocalDataStoreMgr System.Threading.Thread::s_LocalDataStoreMgr
LocalDataStoreMgr_t1964DDB9F2BE154BE3159A7507D0D0CCBF8FDCA9 * ___s_LocalDataStoreMgr_0;
// System.Threading.AsyncLocal`1<System.Globalization.CultureInfo> System.Threading.Thread::s_asyncLocalCurrentCulture
AsyncLocal_1_tD39651C2EDD14B144FF3D9B9C716F807EB57655A * ___s_asyncLocalCurrentCulture_4;
// System.Threading.AsyncLocal`1<System.Globalization.CultureInfo> System.Threading.Thread::s_asyncLocalCurrentUICulture
AsyncLocal_1_tD39651C2EDD14B144FF3D9B9C716F807EB57655A * ___s_asyncLocalCurrentUICulture_5;
public:
inline static int32_t get_offset_of_s_LocalDataStoreMgr_0() { return static_cast<int32_t>(offsetof(Thread_tF60E0A146CD3B5480CB65FF9B6016E84C5460CC7_StaticFields, ___s_LocalDataStoreMgr_0)); }
inline LocalDataStoreMgr_t1964DDB9F2BE154BE3159A7507D0D0CCBF8FDCA9 * get_s_LocalDataStoreMgr_0() const { return ___s_LocalDataStoreMgr_0; }
inline LocalDataStoreMgr_t1964DDB9F2BE154BE3159A7507D0D0CCBF8FDCA9 ** get_address_of_s_LocalDataStoreMgr_0() { return &___s_LocalDataStoreMgr_0; }
inline void set_s_LocalDataStoreMgr_0(LocalDataStoreMgr_t1964DDB9F2BE154BE3159A7507D0D0CCBF8FDCA9 * value)
{
___s_LocalDataStoreMgr_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___s_LocalDataStoreMgr_0), (void*)value);
}
inline static int32_t get_offset_of_s_asyncLocalCurrentCulture_4() { return static_cast<int32_t>(offsetof(Thread_tF60E0A146CD3B5480CB65FF9B6016E84C5460CC7_StaticFields, ___s_asyncLocalCurrentCulture_4)); }
inline AsyncLocal_1_tD39651C2EDD14B144FF3D9B9C716F807EB57655A * get_s_asyncLocalCurrentCulture_4() const { return ___s_asyncLocalCurrentCulture_4; }
inline AsyncLocal_1_tD39651C2EDD14B144FF3D9B9C716F807EB57655A ** get_address_of_s_asyncLocalCurrentCulture_4() { return &___s_asyncLocalCurrentCulture_4; }
inline void set_s_asyncLocalCurrentCulture_4(AsyncLocal_1_tD39651C2EDD14B144FF3D9B9C716F807EB57655A * value)
{
___s_asyncLocalCurrentCulture_4 = value;
Il2CppCodeGenWriteBarrier((void**)(&___s_asyncLocalCurrentCulture_4), (void*)value);
}
inline static int32_t get_offset_of_s_asyncLocalCurrentUICulture_5() { return static_cast<int32_t>(offsetof(Thread_tF60E0A146CD3B5480CB65FF9B6016E84C5460CC7_StaticFields, ___s_asyncLocalCurrentUICulture_5)); }
inline AsyncLocal_1_tD39651C2EDD14B144FF3D9B9C716F807EB57655A * get_s_asyncLocalCurrentUICulture_5() const { return ___s_asyncLocalCurrentUICulture_5; }
inline AsyncLocal_1_tD39651C2EDD14B144FF3D9B9C716F807EB57655A ** get_address_of_s_asyncLocalCurrentUICulture_5() { return &___s_asyncLocalCurrentUICulture_5; }
inline void set_s_asyncLocalCurrentUICulture_5(AsyncLocal_1_tD39651C2EDD14B144FF3D9B9C716F807EB57655A * value)
{
___s_asyncLocalCurrentUICulture_5 = value;
Il2CppCodeGenWriteBarrier((void**)(&___s_asyncLocalCurrentUICulture_5), (void*)value);
}
};
struct Thread_tF60E0A146CD3B5480CB65FF9B6016E84C5460CC7_ThreadStaticFields
{
public:
// System.LocalDataStoreHolder System.Threading.Thread::s_LocalDataStore
LocalDataStoreHolder_tE0636E08496405406FD63190AC51EEB2EE51E304 * ___s_LocalDataStore_1;
// System.Globalization.CultureInfo System.Threading.Thread::m_CurrentCulture
CultureInfo_t345AC6924134F039ED9A11F3E03F8E91B6A3225F * ___m_CurrentCulture_2;
// System.Globalization.CultureInfo System.Threading.Thread::m_CurrentUICulture
CultureInfo_t345AC6924134F039ED9A11F3E03F8E91B6A3225F * ___m_CurrentUICulture_3;
// System.Threading.Thread System.Threading.Thread::current_thread
Thread_tF60E0A146CD3B5480CB65FF9B6016E84C5460CC7 * ___current_thread_11;
public:
inline static int32_t get_offset_of_s_LocalDataStore_1() { return static_cast<int32_t>(offsetof(Thread_tF60E0A146CD3B5480CB65FF9B6016E84C5460CC7_ThreadStaticFields, ___s_LocalDataStore_1)); }
inline LocalDataStoreHolder_tE0636E08496405406FD63190AC51EEB2EE51E304 * get_s_LocalDataStore_1() const { return ___s_LocalDataStore_1; }
inline LocalDataStoreHolder_tE0636E08496405406FD63190AC51EEB2EE51E304 ** get_address_of_s_LocalDataStore_1() { return &___s_LocalDataStore_1; }
inline void set_s_LocalDataStore_1(LocalDataStoreHolder_tE0636E08496405406FD63190AC51EEB2EE51E304 * value)
{
___s_LocalDataStore_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___s_LocalDataStore_1), (void*)value);
}
inline static int32_t get_offset_of_m_CurrentCulture_2() { return static_cast<int32_t>(offsetof(Thread_tF60E0A146CD3B5480CB65FF9B6016E84C5460CC7_ThreadStaticFields, ___m_CurrentCulture_2)); }
inline CultureInfo_t345AC6924134F039ED9A11F3E03F8E91B6A3225F * get_m_CurrentCulture_2() const { return ___m_CurrentCulture_2; }
inline CultureInfo_t345AC6924134F039ED9A11F3E03F8E91B6A3225F ** get_address_of_m_CurrentCulture_2() { return &___m_CurrentCulture_2; }
inline void set_m_CurrentCulture_2(CultureInfo_t345AC6924134F039ED9A11F3E03F8E91B6A3225F * value)
{
___m_CurrentCulture_2 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_CurrentCulture_2), (void*)value);
}
inline static int32_t get_offset_of_m_CurrentUICulture_3() { return static_cast<int32_t>(offsetof(Thread_tF60E0A146CD3B5480CB65FF9B6016E84C5460CC7_ThreadStaticFields, ___m_CurrentUICulture_3)); }
inline CultureInfo_t345AC6924134F039ED9A11F3E03F8E91B6A3225F * get_m_CurrentUICulture_3() const { return ___m_CurrentUICulture_3; }
inline CultureInfo_t345AC6924134F039ED9A11F3E03F8E91B6A3225F ** get_address_of_m_CurrentUICulture_3() { return &___m_CurrentUICulture_3; }
inline void set_m_CurrentUICulture_3(CultureInfo_t345AC6924134F039ED9A11F3E03F8E91B6A3225F * value)
{
___m_CurrentUICulture_3 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_CurrentUICulture_3), (void*)value);
}
inline static int32_t get_offset_of_current_thread_11() { return static_cast<int32_t>(offsetof(Thread_tF60E0A146CD3B5480CB65FF9B6016E84C5460CC7_ThreadStaticFields, ___current_thread_11)); }
inline Thread_tF60E0A146CD3B5480CB65FF9B6016E84C5460CC7 * get_current_thread_11() const { return ___current_thread_11; }
inline Thread_tF60E0A146CD3B5480CB65FF9B6016E84C5460CC7 ** get_address_of_current_thread_11() { return &___current_thread_11; }
inline void set_current_thread_11(Thread_tF60E0A146CD3B5480CB65FF9B6016E84C5460CC7 * value)
{
___current_thread_11 = value;
Il2CppCodeGenWriteBarrier((void**)(&___current_thread_11), (void*)value);
}
};
// System.TypeIdentifiers_Display
struct Display_t0222D7CB4CF0F85131FC5E26328FE94E0A27F5E5 : public ATypeName_t8FD4A465E3C2846D11FEAE25ED5BF3D67FF94421
{
public:
// System.String System.TypeIdentifiers_Display::displayName
String_t* ___displayName_0;
// System.String System.TypeIdentifiers_Display::internal_name
String_t* ___internal_name_1;
public:
inline static int32_t get_offset_of_displayName_0() { return static_cast<int32_t>(offsetof(Display_t0222D7CB4CF0F85131FC5E26328FE94E0A27F5E5, ___displayName_0)); }
inline String_t* get_displayName_0() const { return ___displayName_0; }
inline String_t** get_address_of_displayName_0() { return &___displayName_0; }
inline void set_displayName_0(String_t* value)
{
___displayName_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___displayName_0), (void*)value);
}
inline static int32_t get_offset_of_internal_name_1() { return static_cast<int32_t>(offsetof(Display_t0222D7CB4CF0F85131FC5E26328FE94E0A27F5E5, ___internal_name_1)); }
inline String_t* get_internal_name_1() const { return ___internal_name_1; }
inline String_t** get_address_of_internal_name_1() { return &___internal_name_1; }
inline void set_internal_name_1(String_t* value)
{
___internal_name_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___internal_name_1), (void*)value);
}
};
// System.UInt16
struct UInt16_tAE45CEF73BF720100519F6867F32145D075F928E
{
public:
// System.UInt16 System.UInt16::m_value
uint16_t ___m_value_0;
public:
inline static int32_t get_offset_of_m_value_0() { return static_cast<int32_t>(offsetof(UInt16_tAE45CEF73BF720100519F6867F32145D075F928E, ___m_value_0)); }
inline uint16_t get_m_value_0() const { return ___m_value_0; }
inline uint16_t* get_address_of_m_value_0() { return &___m_value_0; }
inline void set_m_value_0(uint16_t value)
{
___m_value_0 = value;
}
};
// System.UInt32
struct UInt32_t4980FA09003AFAAB5A6E361BA2748EA9A005709B
{
public:
// System.UInt32 System.UInt32::m_value
uint32_t ___m_value_0;
public:
inline static int32_t get_offset_of_m_value_0() { return static_cast<int32_t>(offsetof(UInt32_t4980FA09003AFAAB5A6E361BA2748EA9A005709B, ___m_value_0)); }
inline uint32_t get_m_value_0() const { return ___m_value_0; }
inline uint32_t* get_address_of_m_value_0() { return &___m_value_0; }
inline void set_m_value_0(uint32_t value)
{
___m_value_0 = value;
}
};
// System.UInt64
struct UInt64_tA02DF3B59C8FC4A849BD207DA11038CC64E4CB4E
{
public:
// System.UInt64 System.UInt64::m_value
uint64_t ___m_value_0;
public:
inline static int32_t get_offset_of_m_value_0() { return static_cast<int32_t>(offsetof(UInt64_tA02DF3B59C8FC4A849BD207DA11038CC64E4CB4E, ___m_value_0)); }
inline uint64_t get_m_value_0() const { return ___m_value_0; }
inline uint64_t* get_address_of_m_value_0() { return &___m_value_0; }
inline void set_m_value_0(uint64_t value)
{
___m_value_0 = value;
}
};
// System.UIntPtr
struct UIntPtr_t
{
public:
// System.Void* System.UIntPtr::_pointer
void* ____pointer_1;
public:
inline static int32_t get_offset_of__pointer_1() { return static_cast<int32_t>(offsetof(UIntPtr_t, ____pointer_1)); }
inline void* get__pointer_1() const { return ____pointer_1; }
inline void** get_address_of__pointer_1() { return &____pointer_1; }
inline void set__pointer_1(void* value)
{
____pointer_1 = value;
}
};
struct UIntPtr_t_StaticFields
{
public:
// System.UIntPtr System.UIntPtr::Zero
uintptr_t ___Zero_0;
public:
inline static int32_t get_offset_of_Zero_0() { return static_cast<int32_t>(offsetof(UIntPtr_t_StaticFields, ___Zero_0)); }
inline uintptr_t get_Zero_0() const { return ___Zero_0; }
inline uintptr_t* get_address_of_Zero_0() { return &___Zero_0; }
inline void set_Zero_0(uintptr_t value)
{
___Zero_0 = value;
}
};
// System.UnSafeCharBuffer
struct UnSafeCharBuffer_t99F0962CE65E71C4BA612D5434276C51AC33AF0C
{
public:
// System.Char* System.UnSafeCharBuffer::m_buffer
Il2CppChar* ___m_buffer_0;
// System.Int32 System.UnSafeCharBuffer::m_totalSize
int32_t ___m_totalSize_1;
// System.Int32 System.UnSafeCharBuffer::m_length
int32_t ___m_length_2;
public:
inline static int32_t get_offset_of_m_buffer_0() { return static_cast<int32_t>(offsetof(UnSafeCharBuffer_t99F0962CE65E71C4BA612D5434276C51AC33AF0C, ___m_buffer_0)); }
inline Il2CppChar* get_m_buffer_0() const { return ___m_buffer_0; }
inline Il2CppChar** get_address_of_m_buffer_0() { return &___m_buffer_0; }
inline void set_m_buffer_0(Il2CppChar* value)
{
___m_buffer_0 = value;
}
inline static int32_t get_offset_of_m_totalSize_1() { return static_cast<int32_t>(offsetof(UnSafeCharBuffer_t99F0962CE65E71C4BA612D5434276C51AC33AF0C, ___m_totalSize_1)); }
inline int32_t get_m_totalSize_1() const { return ___m_totalSize_1; }
inline int32_t* get_address_of_m_totalSize_1() { return &___m_totalSize_1; }
inline void set_m_totalSize_1(int32_t value)
{
___m_totalSize_1 = value;
}
inline static int32_t get_offset_of_m_length_2() { return static_cast<int32_t>(offsetof(UnSafeCharBuffer_t99F0962CE65E71C4BA612D5434276C51AC33AF0C, ___m_length_2)); }
inline int32_t get_m_length_2() const { return ___m_length_2; }
inline int32_t* get_address_of_m_length_2() { return &___m_length_2; }
inline void set_m_length_2(int32_t value)
{
___m_length_2 = value;
}
};
// Native definition for P/Invoke marshalling of System.UnSafeCharBuffer
struct UnSafeCharBuffer_t99F0962CE65E71C4BA612D5434276C51AC33AF0C_marshaled_pinvoke
{
Il2CppChar* ___m_buffer_0;
int32_t ___m_totalSize_1;
int32_t ___m_length_2;
};
// Native definition for COM marshalling of System.UnSafeCharBuffer
struct UnSafeCharBuffer_t99F0962CE65E71C4BA612D5434276C51AC33AF0C_marshaled_com
{
Il2CppChar* ___m_buffer_0;
int32_t ___m_totalSize_1;
int32_t ___m_length_2;
};
// System.UnhandledExceptionEventArgs
struct UnhandledExceptionEventArgs_t39DD47D43B0D764FE2C9847FBE760031FBEA0FD1 : public EventArgs_t8E6CA180BE0E56674C6407011A94BAF7C757352E
{
public:
// System.Object System.UnhandledExceptionEventArgs::_Exception
RuntimeObject * ____Exception_1;
// System.Boolean System.UnhandledExceptionEventArgs::_IsTerminating
bool ____IsTerminating_2;
public:
inline static int32_t get_offset_of__Exception_1() { return static_cast<int32_t>(offsetof(UnhandledExceptionEventArgs_t39DD47D43B0D764FE2C9847FBE760031FBEA0FD1, ____Exception_1)); }
inline RuntimeObject * get__Exception_1() const { return ____Exception_1; }
inline RuntimeObject ** get_address_of__Exception_1() { return &____Exception_1; }
inline void set__Exception_1(RuntimeObject * value)
{
____Exception_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&____Exception_1), (void*)value);
}
inline static int32_t get_offset_of__IsTerminating_2() { return static_cast<int32_t>(offsetof(UnhandledExceptionEventArgs_t39DD47D43B0D764FE2C9847FBE760031FBEA0FD1, ____IsTerminating_2)); }
inline bool get__IsTerminating_2() const { return ____IsTerminating_2; }
inline bool* get_address_of__IsTerminating_2() { return &____IsTerminating_2; }
inline void set__IsTerminating_2(bool value)
{
____IsTerminating_2 = value;
}
};
// System.ValueTuple
struct ValueTuple_tC6981F8FD1D7836C91BF332F5F894A8AEEF569D6
{
public:
union
{
struct
{
};
uint8_t ValueTuple_tC6981F8FD1D7836C91BF332F5F894A8AEEF569D6__padding[1];
};
public:
};
// System.Void
struct Void_t22962CB4C05B1D89B55A6E1139F0E87A90987017
{
public:
union
{
struct
{
};
uint8_t Void_t22962CB4C05B1D89B55A6E1139F0E87A90987017__padding[1];
};
public:
};
// System.__DTString
struct __DTString_t6E7DE2A99E4F15F384EC29CC6CD5185F46818DD9
{
public:
// System.String System.__DTString::Value
String_t* ___Value_0;
// System.Int32 System.__DTString::Index
int32_t ___Index_1;
// System.Int32 System.__DTString::len
int32_t ___len_2;
// System.Char System.__DTString::m_current
Il2CppChar ___m_current_3;
// System.Globalization.CompareInfo System.__DTString::m_info
CompareInfo_tB9A071DBC11AC00AF2EA2066D0C2AE1DCB1865D1 * ___m_info_4;
// System.Boolean System.__DTString::m_checkDigitToken
bool ___m_checkDigitToken_5;
public:
inline static int32_t get_offset_of_Value_0() { return static_cast<int32_t>(offsetof(__DTString_t6E7DE2A99E4F15F384EC29CC6CD5185F46818DD9, ___Value_0)); }
inline String_t* get_Value_0() const { return ___Value_0; }
inline String_t** get_address_of_Value_0() { return &___Value_0; }
inline void set_Value_0(String_t* value)
{
___Value_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___Value_0), (void*)value);
}
inline static int32_t get_offset_of_Index_1() { return static_cast<int32_t>(offsetof(__DTString_t6E7DE2A99E4F15F384EC29CC6CD5185F46818DD9, ___Index_1)); }
inline int32_t get_Index_1() const { return ___Index_1; }
inline int32_t* get_address_of_Index_1() { return &___Index_1; }
inline void set_Index_1(int32_t value)
{
___Index_1 = value;
}
inline static int32_t get_offset_of_len_2() { return static_cast<int32_t>(offsetof(__DTString_t6E7DE2A99E4F15F384EC29CC6CD5185F46818DD9, ___len_2)); }
inline int32_t get_len_2() const { return ___len_2; }
inline int32_t* get_address_of_len_2() { return &___len_2; }
inline void set_len_2(int32_t value)
{
___len_2 = value;
}
inline static int32_t get_offset_of_m_current_3() { return static_cast<int32_t>(offsetof(__DTString_t6E7DE2A99E4F15F384EC29CC6CD5185F46818DD9, ___m_current_3)); }
inline Il2CppChar get_m_current_3() const { return ___m_current_3; }
inline Il2CppChar* get_address_of_m_current_3() { return &___m_current_3; }
inline void set_m_current_3(Il2CppChar value)
{
___m_current_3 = value;
}
inline static int32_t get_offset_of_m_info_4() { return static_cast<int32_t>(offsetof(__DTString_t6E7DE2A99E4F15F384EC29CC6CD5185F46818DD9, ___m_info_4)); }
inline CompareInfo_tB9A071DBC11AC00AF2EA2066D0C2AE1DCB1865D1 * get_m_info_4() const { return ___m_info_4; }
inline CompareInfo_tB9A071DBC11AC00AF2EA2066D0C2AE1DCB1865D1 ** get_address_of_m_info_4() { return &___m_info_4; }
inline void set_m_info_4(CompareInfo_tB9A071DBC11AC00AF2EA2066D0C2AE1DCB1865D1 * value)
{
___m_info_4 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_info_4), (void*)value);
}
inline static int32_t get_offset_of_m_checkDigitToken_5() { return static_cast<int32_t>(offsetof(__DTString_t6E7DE2A99E4F15F384EC29CC6CD5185F46818DD9, ___m_checkDigitToken_5)); }
inline bool get_m_checkDigitToken_5() const { return ___m_checkDigitToken_5; }
inline bool* get_address_of_m_checkDigitToken_5() { return &___m_checkDigitToken_5; }
inline void set_m_checkDigitToken_5(bool value)
{
___m_checkDigitToken_5 = value;
}
};
struct __DTString_t6E7DE2A99E4F15F384EC29CC6CD5185F46818DD9_StaticFields
{
public:
// System.Char[] System.__DTString::WhiteSpaceChecks
CharU5BU5D_t4CC6ABF0AD71BEC97E3C2F1E9C5677E46D3A75C2* ___WhiteSpaceChecks_6;
public:
inline static int32_t get_offset_of_WhiteSpaceChecks_6() { return static_cast<int32_t>(offsetof(__DTString_t6E7DE2A99E4F15F384EC29CC6CD5185F46818DD9_StaticFields, ___WhiteSpaceChecks_6)); }
inline CharU5BU5D_t4CC6ABF0AD71BEC97E3C2F1E9C5677E46D3A75C2* get_WhiteSpaceChecks_6() const { return ___WhiteSpaceChecks_6; }
inline CharU5BU5D_t4CC6ABF0AD71BEC97E3C2F1E9C5677E46D3A75C2** get_address_of_WhiteSpaceChecks_6() { return &___WhiteSpaceChecks_6; }
inline void set_WhiteSpaceChecks_6(CharU5BU5D_t4CC6ABF0AD71BEC97E3C2F1E9C5677E46D3A75C2* value)
{
___WhiteSpaceChecks_6 = value;
Il2CppCodeGenWriteBarrier((void**)(&___WhiteSpaceChecks_6), (void*)value);
}
};
// Native definition for P/Invoke marshalling of System.__DTString
struct __DTString_t6E7DE2A99E4F15F384EC29CC6CD5185F46818DD9_marshaled_pinvoke
{
char* ___Value_0;
int32_t ___Index_1;
int32_t ___len_2;
uint8_t ___m_current_3;
CompareInfo_tB9A071DBC11AC00AF2EA2066D0C2AE1DCB1865D1 * ___m_info_4;
int32_t ___m_checkDigitToken_5;
};
// Native definition for COM marshalling of System.__DTString
struct __DTString_t6E7DE2A99E4F15F384EC29CC6CD5185F46818DD9_marshaled_com
{
Il2CppChar* ___Value_0;
int32_t ___Index_1;
int32_t ___len_2;
uint8_t ___m_current_3;
CompareInfo_tB9A071DBC11AC00AF2EA2066D0C2AE1DCB1865D1 * ___m_info_4;
int32_t ___m_checkDigitToken_5;
};
// System.__Il2CppComDelegate
struct __Il2CppComDelegate_t0A30496F74225C39A0CF7FADB94934C0536120FD : public Il2CppComObject
{
public:
public:
};
// System.ArgumentException
struct ArgumentException_tEDCD16F20A09ECE461C3DA766C16EDA8864057D1 : public SystemException_t5380468142AA850BE4A341D7AF3EAB9C78746782
{
public:
// System.String System.ArgumentException::m_paramName
String_t* ___m_paramName_17;
public:
inline static int32_t get_offset_of_m_paramName_17() { return static_cast<int32_t>(offsetof(ArgumentException_tEDCD16F20A09ECE461C3DA766C16EDA8864057D1, ___m_paramName_17)); }
inline String_t* get_m_paramName_17() const { return ___m_paramName_17; }
inline String_t** get_address_of_m_paramName_17() { return &___m_paramName_17; }
inline void set_m_paramName_17(String_t* value)
{
___m_paramName_17 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_paramName_17), (void*)value);
}
};
// System.ArithmeticException
struct ArithmeticException_tF9EF5FE94597830EF315C5934258F994B8648269 : public SystemException_t5380468142AA850BE4A341D7AF3EAB9C78746782
{
public:
public:
};
// System.BRECORD
struct BRECORD_tDDC5F1A5DC569C234C6141FCBA5F8DE8293BC601
{
public:
// System.IntPtr System.BRECORD::pvRecord
intptr_t ___pvRecord_0;
// System.IntPtr System.BRECORD::pRecInfo
intptr_t ___pRecInfo_1;
public:
inline static int32_t get_offset_of_pvRecord_0() { return static_cast<int32_t>(offsetof(BRECORD_tDDC5F1A5DC569C234C6141FCBA5F8DE8293BC601, ___pvRecord_0)); }
inline intptr_t get_pvRecord_0() const { return ___pvRecord_0; }
inline intptr_t* get_address_of_pvRecord_0() { return &___pvRecord_0; }
inline void set_pvRecord_0(intptr_t value)
{
___pvRecord_0 = value;
}
inline static int32_t get_offset_of_pRecInfo_1() { return static_cast<int32_t>(offsetof(BRECORD_tDDC5F1A5DC569C234C6141FCBA5F8DE8293BC601, ___pRecInfo_1)); }
inline intptr_t get_pRecInfo_1() const { return ___pRecInfo_1; }
inline intptr_t* get_address_of_pRecInfo_1() { return &___pRecInfo_1; }
inline void set_pRecInfo_1(intptr_t value)
{
___pRecInfo_1 = value;
}
};
// System.Configuration.Assemblies.AssemblyHashAlgorithm
struct AssemblyHashAlgorithm_t31E4F1BC642CF668706C9D0FBD9DFDF5EE01CEB9
{
public:
// System.Int32 System.Configuration.Assemblies.AssemblyHashAlgorithm::value__
int32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(AssemblyHashAlgorithm_t31E4F1BC642CF668706C9D0FBD9DFDF5EE01CEB9, ___value___2)); }
inline int32_t get_value___2() const { return ___value___2; }
inline int32_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(int32_t value)
{
___value___2 = value;
}
};
// System.Configuration.Assemblies.AssemblyVersionCompatibility
struct AssemblyVersionCompatibility_tEA062AB37A9A750B33F6CA2898EEF03A4EEA496C
{
public:
// System.Int32 System.Configuration.Assemblies.AssemblyVersionCompatibility::value__
int32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(AssemblyVersionCompatibility_tEA062AB37A9A750B33F6CA2898EEF03A4EEA496C, ___value___2)); }
inline int32_t get_value___2() const { return ___value___2; }
inline int32_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(int32_t value)
{
___value___2 = value;
}
};
// System.ConsoleKey
struct ConsoleKey_t0196714F06D59B40580F7B85EA2663D81394682C
{
public:
// System.Int32 System.ConsoleKey::value__
int32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(ConsoleKey_t0196714F06D59B40580F7B85EA2663D81394682C, ___value___2)); }
inline int32_t get_value___2() const { return ___value___2; }
inline int32_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(int32_t value)
{
___value___2 = value;
}
};
// System.ConsoleModifiers
struct ConsoleModifiers_tCB55098B71E4DCCEE972B1056E64D1B8AB9EAB34
{
public:
// System.Int32 System.ConsoleModifiers::value__
int32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(ConsoleModifiers_tCB55098B71E4DCCEE972B1056E64D1B8AB9EAB34, ___value___2)); }
inline int32_t get_value___2() const { return ___value___2; }
inline int32_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(int32_t value)
{
___value___2 = value;
}
};
// System.ConsoleScreenBufferInfo
struct ConsoleScreenBufferInfo_tA8045B7C44EF25956D3B0847F24465E9CF18954F
{
public:
// System.Coord System.ConsoleScreenBufferInfo::Size
Coord_t6CEFF682745DD47B1B4DA3ED268C0933021AC34A ___Size_0;
// System.Coord System.ConsoleScreenBufferInfo::CursorPosition
Coord_t6CEFF682745DD47B1B4DA3ED268C0933021AC34A ___CursorPosition_1;
// System.Int16 System.ConsoleScreenBufferInfo::Attribute
int16_t ___Attribute_2;
// System.SmallRect System.ConsoleScreenBufferInfo::Window
SmallRect_t18C271B0FF660F6ED4EC6D99B26C4D35F51CA532 ___Window_3;
// System.Coord System.ConsoleScreenBufferInfo::MaxWindowSize
Coord_t6CEFF682745DD47B1B4DA3ED268C0933021AC34A ___MaxWindowSize_4;
public:
inline static int32_t get_offset_of_Size_0() { return static_cast<int32_t>(offsetof(ConsoleScreenBufferInfo_tA8045B7C44EF25956D3B0847F24465E9CF18954F, ___Size_0)); }
inline Coord_t6CEFF682745DD47B1B4DA3ED268C0933021AC34A get_Size_0() const { return ___Size_0; }
inline Coord_t6CEFF682745DD47B1B4DA3ED268C0933021AC34A * get_address_of_Size_0() { return &___Size_0; }
inline void set_Size_0(Coord_t6CEFF682745DD47B1B4DA3ED268C0933021AC34A value)
{
___Size_0 = value;
}
inline static int32_t get_offset_of_CursorPosition_1() { return static_cast<int32_t>(offsetof(ConsoleScreenBufferInfo_tA8045B7C44EF25956D3B0847F24465E9CF18954F, ___CursorPosition_1)); }
inline Coord_t6CEFF682745DD47B1B4DA3ED268C0933021AC34A get_CursorPosition_1() const { return ___CursorPosition_1; }
inline Coord_t6CEFF682745DD47B1B4DA3ED268C0933021AC34A * get_address_of_CursorPosition_1() { return &___CursorPosition_1; }
inline void set_CursorPosition_1(Coord_t6CEFF682745DD47B1B4DA3ED268C0933021AC34A value)
{
___CursorPosition_1 = value;
}
inline static int32_t get_offset_of_Attribute_2() { return static_cast<int32_t>(offsetof(ConsoleScreenBufferInfo_tA8045B7C44EF25956D3B0847F24465E9CF18954F, ___Attribute_2)); }
inline int16_t get_Attribute_2() const { return ___Attribute_2; }
inline int16_t* get_address_of_Attribute_2() { return &___Attribute_2; }
inline void set_Attribute_2(int16_t value)
{
___Attribute_2 = value;
}
inline static int32_t get_offset_of_Window_3() { return static_cast<int32_t>(offsetof(ConsoleScreenBufferInfo_tA8045B7C44EF25956D3B0847F24465E9CF18954F, ___Window_3)); }
inline SmallRect_t18C271B0FF660F6ED4EC6D99B26C4D35F51CA532 get_Window_3() const { return ___Window_3; }
inline SmallRect_t18C271B0FF660F6ED4EC6D99B26C4D35F51CA532 * get_address_of_Window_3() { return &___Window_3; }
inline void set_Window_3(SmallRect_t18C271B0FF660F6ED4EC6D99B26C4D35F51CA532 value)
{
___Window_3 = value;
}
inline static int32_t get_offset_of_MaxWindowSize_4() { return static_cast<int32_t>(offsetof(ConsoleScreenBufferInfo_tA8045B7C44EF25956D3B0847F24465E9CF18954F, ___MaxWindowSize_4)); }
inline Coord_t6CEFF682745DD47B1B4DA3ED268C0933021AC34A get_MaxWindowSize_4() const { return ___MaxWindowSize_4; }
inline Coord_t6CEFF682745DD47B1B4DA3ED268C0933021AC34A * get_address_of_MaxWindowSize_4() { return &___MaxWindowSize_4; }
inline void set_MaxWindowSize_4(Coord_t6CEFF682745DD47B1B4DA3ED268C0933021AC34A value)
{
___MaxWindowSize_4 = value;
}
};
// System.DTSubStringType
struct DTSubStringType_tA15E6919CA4FEC2739587ADF93B5F8D550A9BC4E
{
public:
// System.Int32 System.DTSubStringType::value__
int32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(DTSubStringType_tA15E6919CA4FEC2739587ADF93B5F8D550A9BC4E, ___value___2)); }
inline int32_t get_value___2() const { return ___value___2; }
inline int32_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(int32_t value)
{
___value___2 = value;
}
};
// System.Delegate
struct Delegate_t : public RuntimeObject
{
public:
// System.IntPtr System.Delegate::method_ptr
Il2CppMethodPointer ___method_ptr_0;
// System.IntPtr System.Delegate::invoke_impl
intptr_t ___invoke_impl_1;
// System.Object System.Delegate::m_target
RuntimeObject * ___m_target_2;
// System.IntPtr System.Delegate::method
intptr_t ___method_3;
// System.IntPtr System.Delegate::delegate_trampoline
intptr_t ___delegate_trampoline_4;
// System.IntPtr System.Delegate::extra_arg
intptr_t ___extra_arg_5;
// System.IntPtr System.Delegate::method_code
intptr_t ___method_code_6;
// System.Reflection.MethodInfo System.Delegate::method_info
MethodInfo_t * ___method_info_7;
// System.Reflection.MethodInfo System.Delegate::original_method_info
MethodInfo_t * ___original_method_info_8;
// System.DelegateData System.Delegate::data
DelegateData_t1BF9F691B56DAE5F8C28C5E084FDE94F15F27BBE * ___data_9;
// System.Boolean System.Delegate::method_is_virtual
bool ___method_is_virtual_10;
public:
inline static int32_t get_offset_of_method_ptr_0() { return static_cast<int32_t>(offsetof(Delegate_t, ___method_ptr_0)); }
inline Il2CppMethodPointer get_method_ptr_0() const { return ___method_ptr_0; }
inline Il2CppMethodPointer* get_address_of_method_ptr_0() { return &___method_ptr_0; }
inline void set_method_ptr_0(Il2CppMethodPointer value)
{
___method_ptr_0 = value;
}
inline static int32_t get_offset_of_invoke_impl_1() { return static_cast<int32_t>(offsetof(Delegate_t, ___invoke_impl_1)); }
inline intptr_t get_invoke_impl_1() const { return ___invoke_impl_1; }
inline intptr_t* get_address_of_invoke_impl_1() { return &___invoke_impl_1; }
inline void set_invoke_impl_1(intptr_t value)
{
___invoke_impl_1 = value;
}
inline static int32_t get_offset_of_m_target_2() { return static_cast<int32_t>(offsetof(Delegate_t, ___m_target_2)); }
inline RuntimeObject * get_m_target_2() const { return ___m_target_2; }
inline RuntimeObject ** get_address_of_m_target_2() { return &___m_target_2; }
inline void set_m_target_2(RuntimeObject * value)
{
___m_target_2 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_target_2), (void*)value);
}
inline static int32_t get_offset_of_method_3() { return static_cast<int32_t>(offsetof(Delegate_t, ___method_3)); }
inline intptr_t get_method_3() const { return ___method_3; }
inline intptr_t* get_address_of_method_3() { return &___method_3; }
inline void set_method_3(intptr_t value)
{
___method_3 = value;
}
inline static int32_t get_offset_of_delegate_trampoline_4() { return static_cast<int32_t>(offsetof(Delegate_t, ___delegate_trampoline_4)); }
inline intptr_t get_delegate_trampoline_4() const { return ___delegate_trampoline_4; }
inline intptr_t* get_address_of_delegate_trampoline_4() { return &___delegate_trampoline_4; }
inline void set_delegate_trampoline_4(intptr_t value)
{
___delegate_trampoline_4 = value;
}
inline static int32_t get_offset_of_extra_arg_5() { return static_cast<int32_t>(offsetof(Delegate_t, ___extra_arg_5)); }
inline intptr_t get_extra_arg_5() const { return ___extra_arg_5; }
inline intptr_t* get_address_of_extra_arg_5() { return &___extra_arg_5; }
inline void set_extra_arg_5(intptr_t value)
{
___extra_arg_5 = value;
}
inline static int32_t get_offset_of_method_code_6() { return static_cast<int32_t>(offsetof(Delegate_t, ___method_code_6)); }
inline intptr_t get_method_code_6() const { return ___method_code_6; }
inline intptr_t* get_address_of_method_code_6() { return &___method_code_6; }
inline void set_method_code_6(intptr_t value)
{
___method_code_6 = value;
}
inline static int32_t get_offset_of_method_info_7() { return static_cast<int32_t>(offsetof(Delegate_t, ___method_info_7)); }
inline MethodInfo_t * get_method_info_7() const { return ___method_info_7; }
inline MethodInfo_t ** get_address_of_method_info_7() { return &___method_info_7; }
inline void set_method_info_7(MethodInfo_t * value)
{
___method_info_7 = value;
Il2CppCodeGenWriteBarrier((void**)(&___method_info_7), (void*)value);
}
inline static int32_t get_offset_of_original_method_info_8() { return static_cast<int32_t>(offsetof(Delegate_t, ___original_method_info_8)); }
inline MethodInfo_t * get_original_method_info_8() const { return ___original_method_info_8; }
inline MethodInfo_t ** get_address_of_original_method_info_8() { return &___original_method_info_8; }
inline void set_original_method_info_8(MethodInfo_t * value)
{
___original_method_info_8 = value;
Il2CppCodeGenWriteBarrier((void**)(&___original_method_info_8), (void*)value);
}
inline static int32_t get_offset_of_data_9() { return static_cast<int32_t>(offsetof(Delegate_t, ___data_9)); }
inline DelegateData_t1BF9F691B56DAE5F8C28C5E084FDE94F15F27BBE * get_data_9() const { return ___data_9; }
inline DelegateData_t1BF9F691B56DAE5F8C28C5E084FDE94F15F27BBE ** get_address_of_data_9() { return &___data_9; }
inline void set_data_9(DelegateData_t1BF9F691B56DAE5F8C28C5E084FDE94F15F27BBE * value)
{
___data_9 = value;
Il2CppCodeGenWriteBarrier((void**)(&___data_9), (void*)value);
}
inline static int32_t get_offset_of_method_is_virtual_10() { return static_cast<int32_t>(offsetof(Delegate_t, ___method_is_virtual_10)); }
inline bool get_method_is_virtual_10() const { return ___method_is_virtual_10; }
inline bool* get_address_of_method_is_virtual_10() { return &___method_is_virtual_10; }
inline void set_method_is_virtual_10(bool value)
{
___method_is_virtual_10 = value;
}
};
// Native definition for P/Invoke marshalling of System.Delegate
struct Delegate_t_marshaled_pinvoke
{
intptr_t ___method_ptr_0;
intptr_t ___invoke_impl_1;
Il2CppIUnknown* ___m_target_2;
intptr_t ___method_3;
intptr_t ___delegate_trampoline_4;
intptr_t ___extra_arg_5;
intptr_t ___method_code_6;
MethodInfo_t * ___method_info_7;
MethodInfo_t * ___original_method_info_8;
DelegateData_t1BF9F691B56DAE5F8C28C5E084FDE94F15F27BBE * ___data_9;
int32_t ___method_is_virtual_10;
};
// Native definition for COM marshalling of System.Delegate
struct Delegate_t_marshaled_com
{
intptr_t ___method_ptr_0;
intptr_t ___invoke_impl_1;
Il2CppIUnknown* ___m_target_2;
intptr_t ___method_3;
intptr_t ___delegate_trampoline_4;
intptr_t ___extra_arg_5;
intptr_t ___method_code_6;
MethodInfo_t * ___method_info_7;
MethodInfo_t * ___original_method_info_8;
DelegateData_t1BF9F691B56DAE5F8C28C5E084FDE94F15F27BBE * ___data_9;
int32_t ___method_is_virtual_10;
};
// System.Globalization.CompareOptions
struct CompareOptions_t163DCEA9A0972750294CC1A8348E5CA69E943939
{
public:
// System.Int32 System.Globalization.CompareOptions::value__
int32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(CompareOptions_t163DCEA9A0972750294CC1A8348E5CA69E943939, ___value___2)); }
inline int32_t get_value___2() const { return ___value___2; }
inline int32_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(int32_t value)
{
___value___2 = value;
}
};
// System.Globalization.DateTimeFormatFlags
struct DateTimeFormatFlags_tA363B5524F41DE008B4AB8304F1E995E2C8CF675
{
public:
// System.Int32 System.Globalization.DateTimeFormatFlags::value__
int32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(DateTimeFormatFlags_tA363B5524F41DE008B4AB8304F1E995E2C8CF675, ___value___2)); }
inline int32_t get_value___2() const { return ___value___2; }
inline int32_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(int32_t value)
{
___value___2 = value;
}
};
// System.Globalization.DateTimeStyles
struct DateTimeStyles_tD09B34DB3747CD91D8AAA1238C7595845715301E
{
public:
// System.Int32 System.Globalization.DateTimeStyles::value__
int32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(DateTimeStyles_tD09B34DB3747CD91D8AAA1238C7595845715301E, ___value___2)); }
inline int32_t get_value___2() const { return ___value___2; }
inline int32_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(int32_t value)
{
___value___2 = value;
}
};
// System.Globalization.NumberStyles
struct NumberStyles_tB0ADA2D9CCAA236331AED14C42BE5832B2351592
{
public:
// System.Int32 System.Globalization.NumberStyles::value__
int32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(NumberStyles_tB0ADA2D9CCAA236331AED14C42BE5832B2351592, ___value___2)); }
inline int32_t get_value___2() const { return ___value___2; }
inline int32_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(int32_t value)
{
___value___2 = value;
}
};
// System.Handles
struct Handles_tC13FB0F0810977450CE811097C1B15BCF5E4CAD7
{
public:
// System.Int32 System.Handles::value__
int32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(Handles_tC13FB0F0810977450CE811097C1B15BCF5E4CAD7, ___value___2)); }
inline int32_t get_value___2() const { return ___value___2; }
inline int32_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(int32_t value)
{
___value___2 = value;
}
};
// System.IO.IOException
struct IOException_t60E052020EDE4D3075F57A1DCC224FF8864354BA : public SystemException_t5380468142AA850BE4A341D7AF3EAB9C78746782
{
public:
// System.String System.IO.IOException::_maybeFullPath
String_t* ____maybeFullPath_17;
public:
inline static int32_t get_offset_of__maybeFullPath_17() { return static_cast<int32_t>(offsetof(IOException_t60E052020EDE4D3075F57A1DCC224FF8864354BA, ____maybeFullPath_17)); }
inline String_t* get__maybeFullPath_17() const { return ____maybeFullPath_17; }
inline String_t** get_address_of__maybeFullPath_17() { return &____maybeFullPath_17; }
inline void set__maybeFullPath_17(String_t* value)
{
____maybeFullPath_17 = value;
Il2CppCodeGenWriteBarrier((void**)(&____maybeFullPath_17), (void*)value);
}
};
// System.IndexOutOfRangeException
struct IndexOutOfRangeException_tEC7665FC66525AB6A6916A7EB505E5591683F0CF : public SystemException_t5380468142AA850BE4A341D7AF3EAB9C78746782
{
public:
public:
};
// System.InvalidCastException
struct InvalidCastException_t91DF9E7D7FCCDA6C562CB4A9A18903E016680FDA : public SystemException_t5380468142AA850BE4A341D7AF3EAB9C78746782
{
public:
public:
};
// System.InvalidOperationException
struct InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 : public SystemException_t5380468142AA850BE4A341D7AF3EAB9C78746782
{
public:
public:
};
// System.MemberAccessException
struct MemberAccessException_tDA869AFFB4FC1EA0EEF3143D85999710AC4774F0 : public SystemException_t5380468142AA850BE4A341D7AF3EAB9C78746782
{
public:
public:
};
// System.NotImplementedException
struct NotImplementedException_t8AD6EBE5FEDB0AEBECEE0961CF73C35B372EFFA4 : public SystemException_t5380468142AA850BE4A341D7AF3EAB9C78746782
{
public:
public:
};
// System.NotSupportedException
struct NotSupportedException_tE75B318D6590A02A5D9B29FD97409B1750FA0010 : public SystemException_t5380468142AA850BE4A341D7AF3EAB9C78746782
{
public:
public:
};
// System.Reflection.Assembly
struct Assembly_t : public RuntimeObject
{
public:
// System.IntPtr System.Reflection.Assembly::_mono_assembly
intptr_t ____mono_assembly_0;
// System.Reflection.Assembly_ResolveEventHolder System.Reflection.Assembly::resolve_event_holder
ResolveEventHolder_t5267893EB7CB9C12F7B9B463FD4C221BEA03326E * ___resolve_event_holder_1;
// System.Object System.Reflection.Assembly::_evidence
RuntimeObject * ____evidence_2;
// System.Object System.Reflection.Assembly::_minimum
RuntimeObject * ____minimum_3;
// System.Object System.Reflection.Assembly::_optional
RuntimeObject * ____optional_4;
// System.Object System.Reflection.Assembly::_refuse
RuntimeObject * ____refuse_5;
// System.Object System.Reflection.Assembly::_granted
RuntimeObject * ____granted_6;
// System.Object System.Reflection.Assembly::_denied
RuntimeObject * ____denied_7;
// System.Boolean System.Reflection.Assembly::fromByteArray
bool ___fromByteArray_8;
// System.String System.Reflection.Assembly::assemblyName
String_t* ___assemblyName_9;
public:
inline static int32_t get_offset_of__mono_assembly_0() { return static_cast<int32_t>(offsetof(Assembly_t, ____mono_assembly_0)); }
inline intptr_t get__mono_assembly_0() const { return ____mono_assembly_0; }
inline intptr_t* get_address_of__mono_assembly_0() { return &____mono_assembly_0; }
inline void set__mono_assembly_0(intptr_t value)
{
____mono_assembly_0 = value;
}
inline static int32_t get_offset_of_resolve_event_holder_1() { return static_cast<int32_t>(offsetof(Assembly_t, ___resolve_event_holder_1)); }
inline ResolveEventHolder_t5267893EB7CB9C12F7B9B463FD4C221BEA03326E * get_resolve_event_holder_1() const { return ___resolve_event_holder_1; }
inline ResolveEventHolder_t5267893EB7CB9C12F7B9B463FD4C221BEA03326E ** get_address_of_resolve_event_holder_1() { return &___resolve_event_holder_1; }
inline void set_resolve_event_holder_1(ResolveEventHolder_t5267893EB7CB9C12F7B9B463FD4C221BEA03326E * value)
{
___resolve_event_holder_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___resolve_event_holder_1), (void*)value);
}
inline static int32_t get_offset_of__evidence_2() { return static_cast<int32_t>(offsetof(Assembly_t, ____evidence_2)); }
inline RuntimeObject * get__evidence_2() const { return ____evidence_2; }
inline RuntimeObject ** get_address_of__evidence_2() { return &____evidence_2; }
inline void set__evidence_2(RuntimeObject * value)
{
____evidence_2 = value;
Il2CppCodeGenWriteBarrier((void**)(&____evidence_2), (void*)value);
}
inline static int32_t get_offset_of__minimum_3() { return static_cast<int32_t>(offsetof(Assembly_t, ____minimum_3)); }
inline RuntimeObject * get__minimum_3() const { return ____minimum_3; }
inline RuntimeObject ** get_address_of__minimum_3() { return &____minimum_3; }
inline void set__minimum_3(RuntimeObject * value)
{
____minimum_3 = value;
Il2CppCodeGenWriteBarrier((void**)(&____minimum_3), (void*)value);
}
inline static int32_t get_offset_of__optional_4() { return static_cast<int32_t>(offsetof(Assembly_t, ____optional_4)); }
inline RuntimeObject * get__optional_4() const { return ____optional_4; }
inline RuntimeObject ** get_address_of__optional_4() { return &____optional_4; }
inline void set__optional_4(RuntimeObject * value)
{
____optional_4 = value;
Il2CppCodeGenWriteBarrier((void**)(&____optional_4), (void*)value);
}
inline static int32_t get_offset_of__refuse_5() { return static_cast<int32_t>(offsetof(Assembly_t, ____refuse_5)); }
inline RuntimeObject * get__refuse_5() const { return ____refuse_5; }
inline RuntimeObject ** get_address_of__refuse_5() { return &____refuse_5; }
inline void set__refuse_5(RuntimeObject * value)
{
____refuse_5 = value;
Il2CppCodeGenWriteBarrier((void**)(&____refuse_5), (void*)value);
}
inline static int32_t get_offset_of__granted_6() { return static_cast<int32_t>(offsetof(Assembly_t, ____granted_6)); }
inline RuntimeObject * get__granted_6() const { return ____granted_6; }
inline RuntimeObject ** get_address_of__granted_6() { return &____granted_6; }
inline void set__granted_6(RuntimeObject * value)
{
____granted_6 = value;
Il2CppCodeGenWriteBarrier((void**)(&____granted_6), (void*)value);
}
inline static int32_t get_offset_of__denied_7() { return static_cast<int32_t>(offsetof(Assembly_t, ____denied_7)); }
inline RuntimeObject * get__denied_7() const { return ____denied_7; }
inline RuntimeObject ** get_address_of__denied_7() { return &____denied_7; }
inline void set__denied_7(RuntimeObject * value)
{
____denied_7 = value;
Il2CppCodeGenWriteBarrier((void**)(&____denied_7), (void*)value);
}
inline static int32_t get_offset_of_fromByteArray_8() { return static_cast<int32_t>(offsetof(Assembly_t, ___fromByteArray_8)); }
inline bool get_fromByteArray_8() const { return ___fromByteArray_8; }
inline bool* get_address_of_fromByteArray_8() { return &___fromByteArray_8; }
inline void set_fromByteArray_8(bool value)
{
___fromByteArray_8 = value;
}
inline static int32_t get_offset_of_assemblyName_9() { return static_cast<int32_t>(offsetof(Assembly_t, ___assemblyName_9)); }
inline String_t* get_assemblyName_9() const { return ___assemblyName_9; }
inline String_t** get_address_of_assemblyName_9() { return &___assemblyName_9; }
inline void set_assemblyName_9(String_t* value)
{
___assemblyName_9 = value;
Il2CppCodeGenWriteBarrier((void**)(&___assemblyName_9), (void*)value);
}
};
// Native definition for P/Invoke marshalling of System.Reflection.Assembly
struct Assembly_t_marshaled_pinvoke
{
intptr_t ____mono_assembly_0;
ResolveEventHolder_t5267893EB7CB9C12F7B9B463FD4C221BEA03326E * ___resolve_event_holder_1;
Il2CppIUnknown* ____evidence_2;
Il2CppIUnknown* ____minimum_3;
Il2CppIUnknown* ____optional_4;
Il2CppIUnknown* ____refuse_5;
Il2CppIUnknown* ____granted_6;
Il2CppIUnknown* ____denied_7;
int32_t ___fromByteArray_8;
char* ___assemblyName_9;
};
// Native definition for COM marshalling of System.Reflection.Assembly
struct Assembly_t_marshaled_com
{
intptr_t ____mono_assembly_0;
ResolveEventHolder_t5267893EB7CB9C12F7B9B463FD4C221BEA03326E * ___resolve_event_holder_1;
Il2CppIUnknown* ____evidence_2;
Il2CppIUnknown* ____minimum_3;
Il2CppIUnknown* ____optional_4;
Il2CppIUnknown* ____refuse_5;
Il2CppIUnknown* ____granted_6;
Il2CppIUnknown* ____denied_7;
int32_t ___fromByteArray_8;
Il2CppChar* ___assemblyName_9;
};
// System.Reflection.AssemblyContentType
struct AssemblyContentType_t9869DE40B7B1976B389F3B6A5A5D18B09E623401
{
public:
// System.Int32 System.Reflection.AssemblyContentType::value__
int32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(AssemblyContentType_t9869DE40B7B1976B389F3B6A5A5D18B09E623401, ___value___2)); }
inline int32_t get_value___2() const { return ___value___2; }
inline int32_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(int32_t value)
{
___value___2 = value;
}
};
// System.Reflection.AssemblyNameFlags
struct AssemblyNameFlags_t7834EDF078E7ECA985AA434A1EA0D95C2A44F256
{
public:
// System.Int32 System.Reflection.AssemblyNameFlags::value__
int32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(AssemblyNameFlags_t7834EDF078E7ECA985AA434A1EA0D95C2A44F256, ___value___2)); }
inline int32_t get_value___2() const { return ___value___2; }
inline int32_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(int32_t value)
{
___value___2 = value;
}
};
// System.Reflection.BindingFlags
struct BindingFlags_tE35C91D046E63A1B92BB9AB909FCF9DA84379ED0
{
public:
// System.Int32 System.Reflection.BindingFlags::value__
int32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(BindingFlags_tE35C91D046E63A1B92BB9AB909FCF9DA84379ED0, ___value___2)); }
inline int32_t get_value___2() const { return ___value___2; }
inline int32_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(int32_t value)
{
___value___2 = value;
}
};
// System.Reflection.ConstructorInfo
struct ConstructorInfo_t9CB51BFC178DF1CBCA5FD16B2D58229618F23EFF : public MethodBase_t
{
public:
public:
};
struct ConstructorInfo_t9CB51BFC178DF1CBCA5FD16B2D58229618F23EFF_StaticFields
{
public:
// System.String System.Reflection.ConstructorInfo::ConstructorName
String_t* ___ConstructorName_0;
// System.String System.Reflection.ConstructorInfo::TypeConstructorName
String_t* ___TypeConstructorName_1;
public:
inline static int32_t get_offset_of_ConstructorName_0() { return static_cast<int32_t>(offsetof(ConstructorInfo_t9CB51BFC178DF1CBCA5FD16B2D58229618F23EFF_StaticFields, ___ConstructorName_0)); }
inline String_t* get_ConstructorName_0() const { return ___ConstructorName_0; }
inline String_t** get_address_of_ConstructorName_0() { return &___ConstructorName_0; }
inline void set_ConstructorName_0(String_t* value)
{
___ConstructorName_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___ConstructorName_0), (void*)value);
}
inline static int32_t get_offset_of_TypeConstructorName_1() { return static_cast<int32_t>(offsetof(ConstructorInfo_t9CB51BFC178DF1CBCA5FD16B2D58229618F23EFF_StaticFields, ___TypeConstructorName_1)); }
inline String_t* get_TypeConstructorName_1() const { return ___TypeConstructorName_1; }
inline String_t** get_address_of_TypeConstructorName_1() { return &___TypeConstructorName_1; }
inline void set_TypeConstructorName_1(String_t* value)
{
___TypeConstructorName_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___TypeConstructorName_1), (void*)value);
}
};
// System.Reflection.FieldAttributes
struct FieldAttributes_t53FAFABBE4087C280EE0ED26F8F0EF29D24CC0B1
{
public:
// System.Int32 System.Reflection.FieldAttributes::value__
int32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(FieldAttributes_t53FAFABBE4087C280EE0ED26F8F0EF29D24CC0B1, ___value___2)); }
inline int32_t get_value___2() const { return ___value___2; }
inline int32_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(int32_t value)
{
___value___2 = value;
}
};
// System.Reflection.InvalidFilterCriteriaException
struct InvalidFilterCriteriaException_tB11C87F151CD79ACA0837773B9BFD8791CA715BA : public ApplicationException_t664823C3E0D3E1E7C7FA1C0DB4E19E98E9811C74
{
public:
public:
};
// System.Reflection.MemberTypes
struct MemberTypes_t3FEDC67D8B994D09AF155FFB2CFD26023F245041
{
public:
// System.Int32 System.Reflection.MemberTypes::value__
int32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(MemberTypes_t3FEDC67D8B994D09AF155FFB2CFD26023F245041, ___value___2)); }
inline int32_t get_value___2() const { return ___value___2; }
inline int32_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(int32_t value)
{
___value___2 = value;
}
};
// System.Reflection.MethodAttributes
struct MethodAttributes_tBEF3274421B682BFF8D0FF0BEA84C8FD9D63F202
{
public:
// System.Int32 System.Reflection.MethodAttributes::value__
int32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(MethodAttributes_tBEF3274421B682BFF8D0FF0BEA84C8FD9D63F202, ___value___2)); }
inline int32_t get_value___2() const { return ___value___2; }
inline int32_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(int32_t value)
{
___value___2 = value;
}
};
// System.Reflection.MethodInfo
struct MethodInfo_t : public MethodBase_t
{
public:
public:
};
// System.Reflection.ProcessorArchitecture
struct ProcessorArchitecture_t0CFB73A83469D6AC222B9FE46E81EAC73C2627C7
{
public:
// System.Int32 System.Reflection.ProcessorArchitecture::value__
int32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(ProcessorArchitecture_t0CFB73A83469D6AC222B9FE46E81EAC73C2627C7, ___value___2)); }
inline int32_t get_value___2() const { return ___value___2; }
inline int32_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(int32_t value)
{
___value___2 = value;
}
};
// System.Reflection.RuntimeFieldInfo
struct RuntimeFieldInfo_t9C8BA644F857EBE60EC6587AE1C1148E420E66F7 : public FieldInfo_t
{
public:
public:
};
// System.Runtime.InteropServices.GCHandleType
struct GCHandleType_t7155EF9CB120186C6753EE17470D37E148CB2EF1
{
public:
// System.Int32 System.Runtime.InteropServices.GCHandleType::value__
int32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(GCHandleType_t7155EF9CB120186C6753EE17470D37E148CB2EF1, ___value___2)); }
inline int32_t get_value___2() const { return ___value___2; }
inline int32_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(int32_t value)
{
___value___2 = value;
}
};
// System.Runtime.Serialization.SerializationException
struct SerializationException_tA1FDFF6779406E688C2192E71C38DBFD7A4A2210 : public SystemException_t5380468142AA850BE4A341D7AF3EAB9C78746782
{
public:
public:
};
struct SerializationException_tA1FDFF6779406E688C2192E71C38DBFD7A4A2210_StaticFields
{
public:
// System.String System.Runtime.Serialization.SerializationException::_nullMessage
String_t* ____nullMessage_17;
public:
inline static int32_t get_offset_of__nullMessage_17() { return static_cast<int32_t>(offsetof(SerializationException_tA1FDFF6779406E688C2192E71C38DBFD7A4A2210_StaticFields, ____nullMessage_17)); }
inline String_t* get__nullMessage_17() const { return ____nullMessage_17; }
inline String_t** get_address_of__nullMessage_17() { return &____nullMessage_17; }
inline void set__nullMessage_17(String_t* value)
{
____nullMessage_17 = value;
Il2CppCodeGenWriteBarrier((void**)(&____nullMessage_17), (void*)value);
}
};
// System.Runtime.Serialization.StreamingContextStates
struct StreamingContextStates_t6D16CD7BC584A66A29B702F5FD59DF62BB1BDD3F
{
public:
// System.Int32 System.Runtime.Serialization.StreamingContextStates::value__
int32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(StreamingContextStates_t6D16CD7BC584A66A29B702F5FD59DF62BB1BDD3F, ___value___2)); }
inline int32_t get_value___2() const { return ___value___2; }
inline int32_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(int32_t value)
{
___value___2 = value;
}
};
// System.RuntimeFieldHandle
struct RuntimeFieldHandle_t844BDF00E8E6FE69D9AEAA7657F09018B864F4EF
{
public:
// System.IntPtr System.RuntimeFieldHandle::value
intptr_t ___value_0;
public:
inline static int32_t get_offset_of_value_0() { return static_cast<int32_t>(offsetof(RuntimeFieldHandle_t844BDF00E8E6FE69D9AEAA7657F09018B864F4EF, ___value_0)); }
inline intptr_t get_value_0() const { return ___value_0; }
inline intptr_t* get_address_of_value_0() { return &___value_0; }
inline void set_value_0(intptr_t value)
{
___value_0 = value;
}
};
// System.RuntimeTypeHandle
struct RuntimeTypeHandle_t7B542280A22F0EC4EAC2061C29178845847A8B2D
{
public:
// System.IntPtr System.RuntimeTypeHandle::value
intptr_t ___value_0;
public:
inline static int32_t get_offset_of_value_0() { return static_cast<int32_t>(offsetof(RuntimeTypeHandle_t7B542280A22F0EC4EAC2061C29178845847A8B2D, ___value_0)); }
inline intptr_t get_value_0() const { return ___value_0; }
inline intptr_t* get_address_of_value_0() { return &___value_0; }
inline void set_value_0(intptr_t value)
{
___value_0 = value;
}
};
// System.StringComparison
struct StringComparison_t02BAA95468CE9E91115C604577611FDF58FEDCF0
{
public:
// System.Int32 System.StringComparison::value__
int32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(StringComparison_t02BAA95468CE9E91115C604577611FDF58FEDCF0, ___value___2)); }
inline int32_t get_value___2() const { return ___value___2; }
inline int32_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(int32_t value)
{
___value___2 = value;
}
};
// System.Threading.StackCrawlMark
struct StackCrawlMark_t857D8DE506F124E737FD26BB7ADAAAAD13E4F943
{
public:
// System.Int32 System.Threading.StackCrawlMark::value__
int32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(StackCrawlMark_t857D8DE506F124E737FD26BB7ADAAAAD13E4F943, ___value___2)); }
inline int32_t get_value___2() const { return ___value___2; }
inline int32_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(int32_t value)
{
___value___2 = value;
}
};
// System.TokenType
struct TokenType_t192580F19CFCC8A71F0BD44B8BE1056BA64D869A
{
public:
// System.Int32 System.TokenType::value__
int32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(TokenType_t192580F19CFCC8A71F0BD44B8BE1056BA64D869A, ___value___2)); }
inline int32_t get_value___2() const { return ___value___2; }
inline int32_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(int32_t value)
{
___value___2 = value;
}
};
// System.TypeCode
struct TypeCode_t03ED52F888000DAF40C550C434F29F39A23D61C6
{
public:
// System.Int32 System.TypeCode::value__
int32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(TypeCode_t03ED52F888000DAF40C550C434F29F39A23D61C6, ___value___2)); }
inline int32_t get_value___2() const { return ___value___2; }
inline int32_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(int32_t value)
{
___value___2 = value;
}
};
// System.TypeInitializationException
struct TypeInitializationException_t5223A07113C97D6DC875A82C68D4C132737ADEAE : public SystemException_t5380468142AA850BE4A341D7AF3EAB9C78746782
{
public:
// System.String System.TypeInitializationException::_typeName
String_t* ____typeName_17;
public:
inline static int32_t get_offset_of__typeName_17() { return static_cast<int32_t>(offsetof(TypeInitializationException_t5223A07113C97D6DC875A82C68D4C132737ADEAE, ____typeName_17)); }
inline String_t* get__typeName_17() const { return ____typeName_17; }
inline String_t** get_address_of__typeName_17() { return &____typeName_17; }
inline void set__typeName_17(String_t* value)
{
____typeName_17 = value;
Il2CppCodeGenWriteBarrier((void**)(&____typeName_17), (void*)value);
}
};
// System.TypeLoadException
struct TypeLoadException_t510963B29CB27C6EA3ACDF5FB76E72E1BC372CD1 : public SystemException_t5380468142AA850BE4A341D7AF3EAB9C78746782
{
public:
// System.String System.TypeLoadException::ClassName
String_t* ___ClassName_17;
// System.String System.TypeLoadException::AssemblyName
String_t* ___AssemblyName_18;
// System.String System.TypeLoadException::MessageArg
String_t* ___MessageArg_19;
// System.Int32 System.TypeLoadException::ResourceId
int32_t ___ResourceId_20;
public:
inline static int32_t get_offset_of_ClassName_17() { return static_cast<int32_t>(offsetof(TypeLoadException_t510963B29CB27C6EA3ACDF5FB76E72E1BC372CD1, ___ClassName_17)); }
inline String_t* get_ClassName_17() const { return ___ClassName_17; }
inline String_t** get_address_of_ClassName_17() { return &___ClassName_17; }
inline void set_ClassName_17(String_t* value)
{
___ClassName_17 = value;
Il2CppCodeGenWriteBarrier((void**)(&___ClassName_17), (void*)value);
}
inline static int32_t get_offset_of_AssemblyName_18() { return static_cast<int32_t>(offsetof(TypeLoadException_t510963B29CB27C6EA3ACDF5FB76E72E1BC372CD1, ___AssemblyName_18)); }
inline String_t* get_AssemblyName_18() const { return ___AssemblyName_18; }
inline String_t** get_address_of_AssemblyName_18() { return &___AssemblyName_18; }
inline void set_AssemblyName_18(String_t* value)
{
___AssemblyName_18 = value;
Il2CppCodeGenWriteBarrier((void**)(&___AssemblyName_18), (void*)value);
}
inline static int32_t get_offset_of_MessageArg_19() { return static_cast<int32_t>(offsetof(TypeLoadException_t510963B29CB27C6EA3ACDF5FB76E72E1BC372CD1, ___MessageArg_19)); }
inline String_t* get_MessageArg_19() const { return ___MessageArg_19; }
inline String_t** get_address_of_MessageArg_19() { return &___MessageArg_19; }
inline void set_MessageArg_19(String_t* value)
{
___MessageArg_19 = value;
Il2CppCodeGenWriteBarrier((void**)(&___MessageArg_19), (void*)value);
}
inline static int32_t get_offset_of_ResourceId_20() { return static_cast<int32_t>(offsetof(TypeLoadException_t510963B29CB27C6EA3ACDF5FB76E72E1BC372CD1, ___ResourceId_20)); }
inline int32_t get_ResourceId_20() const { return ___ResourceId_20; }
inline int32_t* get_address_of_ResourceId_20() { return &___ResourceId_20; }
inline void set_ResourceId_20(int32_t value)
{
___ResourceId_20 = value;
}
};
// System.TypeNameFormatFlags
struct TypeNameFormatFlags_tDAD267AC4A655D16C608DD230B5C97F8226E94C8
{
public:
// System.Int32 System.TypeNameFormatFlags::value__
int32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(TypeNameFormatFlags_tDAD267AC4A655D16C608DD230B5C97F8226E94C8, ___value___2)); }
inline int32_t get_value___2() const { return ___value___2; }
inline int32_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(int32_t value)
{
___value___2 = value;
}
};
// System.TypeNameKind
struct TypeNameKind_t200043F25E9EACB6294E8B825E5FED441F04C2BF
{
public:
// System.Int32 System.TypeNameKind::value__
int32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(TypeNameKind_t200043F25E9EACB6294E8B825E5FED441F04C2BF, ___value___2)); }
inline int32_t get_value___2() const { return ___value___2; }
inline int32_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(int32_t value)
{
___value___2 = value;
}
};
// System.TypeSpec_DisplayNameFormat
struct DisplayNameFormat_tFEA54E2FCA44D62D61CCCE98E4F02DE2D186DF47
{
public:
// System.Int32 System.TypeSpec_DisplayNameFormat::value__
int32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(DisplayNameFormat_tFEA54E2FCA44D62D61CCCE98E4F02DE2D186DF47, ___value___2)); }
inline int32_t get_value___2() const { return ___value___2; }
inline int32_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(int32_t value)
{
___value___2 = value;
}
};
// System.UInt16Enum
struct UInt16Enum_tB3380938EFBC6B524E2C8143A7982637F0EA4456
{
public:
// System.UInt16 System.UInt16Enum::value__
uint16_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(UInt16Enum_tB3380938EFBC6B524E2C8143A7982637F0EA4456, ___value___2)); }
inline uint16_t get_value___2() const { return ___value___2; }
inline uint16_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(uint16_t value)
{
___value___2 = value;
}
};
// System.UInt32Enum
struct UInt32Enum_tE44175EB3151A633676D60A642EDA3BD5C6760DA
{
public:
// System.UInt32 System.UInt32Enum::value__
uint32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(UInt32Enum_tE44175EB3151A633676D60A642EDA3BD5C6760DA, ___value___2)); }
inline uint32_t get_value___2() const { return ___value___2; }
inline uint32_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(uint32_t value)
{
___value___2 = value;
}
};
// System.UInt64Enum
struct UInt64Enum_tEAD217F175F60689A664303784384DEF759D24C8
{
public:
// System.UInt64 System.UInt64Enum::value__
uint64_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(UInt64Enum_tEAD217F175F60689A664303784384DEF759D24C8, ___value___2)); }
inline uint64_t get_value___2() const { return ___value___2; }
inline uint64_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(uint64_t value)
{
___value___2 = value;
}
};
// System.UnauthorizedAccessException
struct UnauthorizedAccessException_tC2210A745BFDD3AE3559A87A4219E2945EEC9F75 : public SystemException_t5380468142AA850BE4A341D7AF3EAB9C78746782
{
public:
public:
};
// System.WeakReference
struct WeakReference_t0495CC81CD6403E662B7700B802443F6F730E39D : public RuntimeObject
{
public:
// System.Boolean System.WeakReference::isLongReference
bool ___isLongReference_0;
// System.Runtime.InteropServices.GCHandle System.WeakReference::gcHandle
GCHandle_t39FAEE3EA592432C93B574A31DD83B87F1847DE3 ___gcHandle_1;
public:
inline static int32_t get_offset_of_isLongReference_0() { return static_cast<int32_t>(offsetof(WeakReference_t0495CC81CD6403E662B7700B802443F6F730E39D, ___isLongReference_0)); }
inline bool get_isLongReference_0() const { return ___isLongReference_0; }
inline bool* get_address_of_isLongReference_0() { return &___isLongReference_0; }
inline void set_isLongReference_0(bool value)
{
___isLongReference_0 = value;
}
inline static int32_t get_offset_of_gcHandle_1() { return static_cast<int32_t>(offsetof(WeakReference_t0495CC81CD6403E662B7700B802443F6F730E39D, ___gcHandle_1)); }
inline GCHandle_t39FAEE3EA592432C93B574A31DD83B87F1847DE3 get_gcHandle_1() const { return ___gcHandle_1; }
inline GCHandle_t39FAEE3EA592432C93B574A31DD83B87F1847DE3 * get_address_of_gcHandle_1() { return &___gcHandle_1; }
inline void set_gcHandle_1(GCHandle_t39FAEE3EA592432C93B574A31DD83B87F1847DE3 value)
{
___gcHandle_1 = value;
}
};
// System.WindowsConsoleDriver
struct WindowsConsoleDriver_t953AB92956013BD3ED7E260FEC4944E603008B42 : public RuntimeObject
{
public:
// System.IntPtr System.WindowsConsoleDriver::inputHandle
intptr_t ___inputHandle_0;
// System.IntPtr System.WindowsConsoleDriver::outputHandle
intptr_t ___outputHandle_1;
// System.Int16 System.WindowsConsoleDriver::defaultAttribute
int16_t ___defaultAttribute_2;
public:
inline static int32_t get_offset_of_inputHandle_0() { return static_cast<int32_t>(offsetof(WindowsConsoleDriver_t953AB92956013BD3ED7E260FEC4944E603008B42, ___inputHandle_0)); }
inline intptr_t get_inputHandle_0() const { return ___inputHandle_0; }
inline intptr_t* get_address_of_inputHandle_0() { return &___inputHandle_0; }
inline void set_inputHandle_0(intptr_t value)
{
___inputHandle_0 = value;
}
inline static int32_t get_offset_of_outputHandle_1() { return static_cast<int32_t>(offsetof(WindowsConsoleDriver_t953AB92956013BD3ED7E260FEC4944E603008B42, ___outputHandle_1)); }
inline intptr_t get_outputHandle_1() const { return ___outputHandle_1; }
inline intptr_t* get_address_of_outputHandle_1() { return &___outputHandle_1; }
inline void set_outputHandle_1(intptr_t value)
{
___outputHandle_1 = value;
}
inline static int32_t get_offset_of_defaultAttribute_2() { return static_cast<int32_t>(offsetof(WindowsConsoleDriver_t953AB92956013BD3ED7E260FEC4944E603008B42, ___defaultAttribute_2)); }
inline int16_t get_defaultAttribute_2() const { return ___defaultAttribute_2; }
inline int16_t* get_address_of_defaultAttribute_2() { return &___defaultAttribute_2; }
inline void set_defaultAttribute_2(int16_t value)
{
___defaultAttribute_2 = value;
}
};
// System.ArgumentNullException
struct ArgumentNullException_t581DF992B1F3E0EC6EFB30CC5DC43519A79B27AD : public ArgumentException_tEDCD16F20A09ECE461C3DA766C16EDA8864057D1
{
public:
public:
};
// System.ArgumentOutOfRangeException
struct ArgumentOutOfRangeException_t94D19DF918A54511AEDF4784C9A08741BAD1DEDA : public ArgumentException_tEDCD16F20A09ECE461C3DA766C16EDA8864057D1
{
public:
// System.Object System.ArgumentOutOfRangeException::m_actualValue
RuntimeObject * ___m_actualValue_19;
public:
inline static int32_t get_offset_of_m_actualValue_19() { return static_cast<int32_t>(offsetof(ArgumentOutOfRangeException_t94D19DF918A54511AEDF4784C9A08741BAD1DEDA, ___m_actualValue_19)); }
inline RuntimeObject * get_m_actualValue_19() const { return ___m_actualValue_19; }
inline RuntimeObject ** get_address_of_m_actualValue_19() { return &___m_actualValue_19; }
inline void set_m_actualValue_19(RuntimeObject * value)
{
___m_actualValue_19 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_actualValue_19), (void*)value);
}
};
struct ArgumentOutOfRangeException_t94D19DF918A54511AEDF4784C9A08741BAD1DEDA_StaticFields
{
public:
// System.String modreq(System.Runtime.CompilerServices.IsVolatile) System.ArgumentOutOfRangeException::_rangeMessage
String_t* ____rangeMessage_18;
public:
inline static int32_t get_offset_of__rangeMessage_18() { return static_cast<int32_t>(offsetof(ArgumentOutOfRangeException_t94D19DF918A54511AEDF4784C9A08741BAD1DEDA_StaticFields, ____rangeMessage_18)); }
inline String_t* get__rangeMessage_18() const { return ____rangeMessage_18; }
inline String_t** get_address_of__rangeMessage_18() { return &____rangeMessage_18; }
inline void set__rangeMessage_18(String_t* value)
{
____rangeMessage_18 = value;
Il2CppCodeGenWriteBarrier((void**)(&____rangeMessage_18), (void*)value);
}
};
// System.ConsoleKeyInfo
struct ConsoleKeyInfo_t5BE3CE05E8258CDB5404256E96AF7C22BC5DE768
{
public:
// System.Char System.ConsoleKeyInfo::_keyChar
Il2CppChar ____keyChar_0;
// System.ConsoleKey System.ConsoleKeyInfo::_key
int32_t ____key_1;
// System.ConsoleModifiers System.ConsoleKeyInfo::_mods
int32_t ____mods_2;
public:
inline static int32_t get_offset_of__keyChar_0() { return static_cast<int32_t>(offsetof(ConsoleKeyInfo_t5BE3CE05E8258CDB5404256E96AF7C22BC5DE768, ____keyChar_0)); }
inline Il2CppChar get__keyChar_0() const { return ____keyChar_0; }
inline Il2CppChar* get_address_of__keyChar_0() { return &____keyChar_0; }
inline void set__keyChar_0(Il2CppChar value)
{
____keyChar_0 = value;
}
inline static int32_t get_offset_of__key_1() { return static_cast<int32_t>(offsetof(ConsoleKeyInfo_t5BE3CE05E8258CDB5404256E96AF7C22BC5DE768, ____key_1)); }
inline int32_t get__key_1() const { return ____key_1; }
inline int32_t* get_address_of__key_1() { return &____key_1; }
inline void set__key_1(int32_t value)
{
____key_1 = value;
}
inline static int32_t get_offset_of__mods_2() { return static_cast<int32_t>(offsetof(ConsoleKeyInfo_t5BE3CE05E8258CDB5404256E96AF7C22BC5DE768, ____mods_2)); }
inline int32_t get__mods_2() const { return ____mods_2; }
inline int32_t* get_address_of__mods_2() { return &____mods_2; }
inline void set__mods_2(int32_t value)
{
____mods_2 = value;
}
};
// Native definition for P/Invoke marshalling of System.ConsoleKeyInfo
struct ConsoleKeyInfo_t5BE3CE05E8258CDB5404256E96AF7C22BC5DE768_marshaled_pinvoke
{
uint8_t ____keyChar_0;
int32_t ____key_1;
int32_t ____mods_2;
};
// Native definition for COM marshalling of System.ConsoleKeyInfo
struct ConsoleKeyInfo_t5BE3CE05E8258CDB5404256E96AF7C22BC5DE768_marshaled_com
{
uint8_t ____keyChar_0;
int32_t ____key_1;
int32_t ____mods_2;
};
// System.DTSubString
struct DTSubString_t0B5F9998AD0833CCE29248DE20EFEBFE9EBFB93D
{
public:
// System.String System.DTSubString::s
String_t* ___s_0;
// System.Int32 System.DTSubString::index
int32_t ___index_1;
// System.Int32 System.DTSubString::length
int32_t ___length_2;
// System.DTSubStringType System.DTSubString::type
int32_t ___type_3;
// System.Int32 System.DTSubString::value
int32_t ___value_4;
public:
inline static int32_t get_offset_of_s_0() { return static_cast<int32_t>(offsetof(DTSubString_t0B5F9998AD0833CCE29248DE20EFEBFE9EBFB93D, ___s_0)); }
inline String_t* get_s_0() const { return ___s_0; }
inline String_t** get_address_of_s_0() { return &___s_0; }
inline void set_s_0(String_t* value)
{
___s_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___s_0), (void*)value);
}
inline static int32_t get_offset_of_index_1() { return static_cast<int32_t>(offsetof(DTSubString_t0B5F9998AD0833CCE29248DE20EFEBFE9EBFB93D, ___index_1)); }
inline int32_t get_index_1() const { return ___index_1; }
inline int32_t* get_address_of_index_1() { return &___index_1; }
inline void set_index_1(int32_t value)
{
___index_1 = value;
}
inline static int32_t get_offset_of_length_2() { return static_cast<int32_t>(offsetof(DTSubString_t0B5F9998AD0833CCE29248DE20EFEBFE9EBFB93D, ___length_2)); }
inline int32_t get_length_2() const { return ___length_2; }
inline int32_t* get_address_of_length_2() { return &___length_2; }
inline void set_length_2(int32_t value)
{
___length_2 = value;
}
inline static int32_t get_offset_of_type_3() { return static_cast<int32_t>(offsetof(DTSubString_t0B5F9998AD0833CCE29248DE20EFEBFE9EBFB93D, ___type_3)); }
inline int32_t get_type_3() const { return ___type_3; }
inline int32_t* get_address_of_type_3() { return &___type_3; }
inline void set_type_3(int32_t value)
{
___type_3 = value;
}
inline static int32_t get_offset_of_value_4() { return static_cast<int32_t>(offsetof(DTSubString_t0B5F9998AD0833CCE29248DE20EFEBFE9EBFB93D, ___value_4)); }
inline int32_t get_value_4() const { return ___value_4; }
inline int32_t* get_address_of_value_4() { return &___value_4; }
inline void set_value_4(int32_t value)
{
___value_4 = value;
}
};
// Native definition for P/Invoke marshalling of System.DTSubString
struct DTSubString_t0B5F9998AD0833CCE29248DE20EFEBFE9EBFB93D_marshaled_pinvoke
{
char* ___s_0;
int32_t ___index_1;
int32_t ___length_2;
int32_t ___type_3;
int32_t ___value_4;
};
// Native definition for COM marshalling of System.DTSubString
struct DTSubString_t0B5F9998AD0833CCE29248DE20EFEBFE9EBFB93D_marshaled_com
{
Il2CppChar* ___s_0;
int32_t ___index_1;
int32_t ___length_2;
int32_t ___type_3;
int32_t ___value_4;
};
// System.Globalization.CompareInfo
struct CompareInfo_tB9A071DBC11AC00AF2EA2066D0C2AE1DCB1865D1 : public RuntimeObject
{
public:
// System.String System.Globalization.CompareInfo::m_name
String_t* ___m_name_3;
// System.String System.Globalization.CompareInfo::m_sortName
String_t* ___m_sortName_4;
// System.Int32 System.Globalization.CompareInfo::win32LCID
int32_t ___win32LCID_5;
// System.Int32 System.Globalization.CompareInfo::culture
int32_t ___culture_6;
// System.Globalization.SortVersion System.Globalization.CompareInfo::m_SortVersion
SortVersion_tE7080CE09A0B8CE226F8046C0D1374DD0A0CAE71 * ___m_SortVersion_20;
// Mono.Globalization.Unicode.SimpleCollator System.Globalization.CompareInfo::collator
SimpleCollator_tC3A1720B7D3D850D5C23BE8E366D821EBA923D89 * ___collator_21;
public:
inline static int32_t get_offset_of_m_name_3() { return static_cast<int32_t>(offsetof(CompareInfo_tB9A071DBC11AC00AF2EA2066D0C2AE1DCB1865D1, ___m_name_3)); }
inline String_t* get_m_name_3() const { return ___m_name_3; }
inline String_t** get_address_of_m_name_3() { return &___m_name_3; }
inline void set_m_name_3(String_t* value)
{
___m_name_3 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_name_3), (void*)value);
}
inline static int32_t get_offset_of_m_sortName_4() { return static_cast<int32_t>(offsetof(CompareInfo_tB9A071DBC11AC00AF2EA2066D0C2AE1DCB1865D1, ___m_sortName_4)); }
inline String_t* get_m_sortName_4() const { return ___m_sortName_4; }
inline String_t** get_address_of_m_sortName_4() { return &___m_sortName_4; }
inline void set_m_sortName_4(String_t* value)
{
___m_sortName_4 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_sortName_4), (void*)value);
}
inline static int32_t get_offset_of_win32LCID_5() { return static_cast<int32_t>(offsetof(CompareInfo_tB9A071DBC11AC00AF2EA2066D0C2AE1DCB1865D1, ___win32LCID_5)); }
inline int32_t get_win32LCID_5() const { return ___win32LCID_5; }
inline int32_t* get_address_of_win32LCID_5() { return &___win32LCID_5; }
inline void set_win32LCID_5(int32_t value)
{
___win32LCID_5 = value;
}
inline static int32_t get_offset_of_culture_6() { return static_cast<int32_t>(offsetof(CompareInfo_tB9A071DBC11AC00AF2EA2066D0C2AE1DCB1865D1, ___culture_6)); }
inline int32_t get_culture_6() const { return ___culture_6; }
inline int32_t* get_address_of_culture_6() { return &___culture_6; }
inline void set_culture_6(int32_t value)
{
___culture_6 = value;
}
inline static int32_t get_offset_of_m_SortVersion_20() { return static_cast<int32_t>(offsetof(CompareInfo_tB9A071DBC11AC00AF2EA2066D0C2AE1DCB1865D1, ___m_SortVersion_20)); }
inline SortVersion_tE7080CE09A0B8CE226F8046C0D1374DD0A0CAE71 * get_m_SortVersion_20() const { return ___m_SortVersion_20; }
inline SortVersion_tE7080CE09A0B8CE226F8046C0D1374DD0A0CAE71 ** get_address_of_m_SortVersion_20() { return &___m_SortVersion_20; }
inline void set_m_SortVersion_20(SortVersion_tE7080CE09A0B8CE226F8046C0D1374DD0A0CAE71 * value)
{
___m_SortVersion_20 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_SortVersion_20), (void*)value);
}
inline static int32_t get_offset_of_collator_21() { return static_cast<int32_t>(offsetof(CompareInfo_tB9A071DBC11AC00AF2EA2066D0C2AE1DCB1865D1, ___collator_21)); }
inline SimpleCollator_tC3A1720B7D3D850D5C23BE8E366D821EBA923D89 * get_collator_21() const { return ___collator_21; }
inline SimpleCollator_tC3A1720B7D3D850D5C23BE8E366D821EBA923D89 ** get_address_of_collator_21() { return &___collator_21; }
inline void set_collator_21(SimpleCollator_tC3A1720B7D3D850D5C23BE8E366D821EBA923D89 * value)
{
___collator_21 = value;
Il2CppCodeGenWriteBarrier((void**)(&___collator_21), (void*)value);
}
};
struct CompareInfo_tB9A071DBC11AC00AF2EA2066D0C2AE1DCB1865D1_StaticFields
{
public:
// System.Collections.Generic.Dictionary`2<System.String,Mono.Globalization.Unicode.SimpleCollator> System.Globalization.CompareInfo::collators
Dictionary_2_t61B96E9258C1E296057BCD8C4D2015846D2BB8F3 * ___collators_22;
// System.Boolean System.Globalization.CompareInfo::managedCollation
bool ___managedCollation_23;
// System.Boolean System.Globalization.CompareInfo::managedCollationChecked
bool ___managedCollationChecked_24;
public:
inline static int32_t get_offset_of_collators_22() { return static_cast<int32_t>(offsetof(CompareInfo_tB9A071DBC11AC00AF2EA2066D0C2AE1DCB1865D1_StaticFields, ___collators_22)); }
inline Dictionary_2_t61B96E9258C1E296057BCD8C4D2015846D2BB8F3 * get_collators_22() const { return ___collators_22; }
inline Dictionary_2_t61B96E9258C1E296057BCD8C4D2015846D2BB8F3 ** get_address_of_collators_22() { return &___collators_22; }
inline void set_collators_22(Dictionary_2_t61B96E9258C1E296057BCD8C4D2015846D2BB8F3 * value)
{
___collators_22 = value;
Il2CppCodeGenWriteBarrier((void**)(&___collators_22), (void*)value);
}
inline static int32_t get_offset_of_managedCollation_23() { return static_cast<int32_t>(offsetof(CompareInfo_tB9A071DBC11AC00AF2EA2066D0C2AE1DCB1865D1_StaticFields, ___managedCollation_23)); }
inline bool get_managedCollation_23() const { return ___managedCollation_23; }
inline bool* get_address_of_managedCollation_23() { return &___managedCollation_23; }
inline void set_managedCollation_23(bool value)
{
___managedCollation_23 = value;
}
inline static int32_t get_offset_of_managedCollationChecked_24() { return static_cast<int32_t>(offsetof(CompareInfo_tB9A071DBC11AC00AF2EA2066D0C2AE1DCB1865D1_StaticFields, ___managedCollationChecked_24)); }
inline bool get_managedCollationChecked_24() const { return ___managedCollationChecked_24; }
inline bool* get_address_of_managedCollationChecked_24() { return &___managedCollationChecked_24; }
inline void set_managedCollationChecked_24(bool value)
{
___managedCollationChecked_24 = value;
}
};
// System.Globalization.DateTimeFormatInfo
struct DateTimeFormatInfo_tF4BB3AA482C2F772D2A9022F78BF8727830FAF5F : public RuntimeObject
{
public:
// System.Globalization.CultureData System.Globalization.DateTimeFormatInfo::m_cultureData
CultureData_tF43B080FFA6EB278F4F289BCDA3FB74B6C208ECD * ___m_cultureData_1;
// System.String System.Globalization.DateTimeFormatInfo::m_name
String_t* ___m_name_2;
// System.String System.Globalization.DateTimeFormatInfo::m_langName
String_t* ___m_langName_3;
// System.Globalization.CompareInfo System.Globalization.DateTimeFormatInfo::m_compareInfo
CompareInfo_tB9A071DBC11AC00AF2EA2066D0C2AE1DCB1865D1 * ___m_compareInfo_4;
// System.Globalization.CultureInfo System.Globalization.DateTimeFormatInfo::m_cultureInfo
CultureInfo_t345AC6924134F039ED9A11F3E03F8E91B6A3225F * ___m_cultureInfo_5;
// System.String System.Globalization.DateTimeFormatInfo::amDesignator
String_t* ___amDesignator_6;
// System.String System.Globalization.DateTimeFormatInfo::pmDesignator
String_t* ___pmDesignator_7;
// System.String System.Globalization.DateTimeFormatInfo::dateSeparator
String_t* ___dateSeparator_8;
// System.String System.Globalization.DateTimeFormatInfo::generalShortTimePattern
String_t* ___generalShortTimePattern_9;
// System.String System.Globalization.DateTimeFormatInfo::generalLongTimePattern
String_t* ___generalLongTimePattern_10;
// System.String System.Globalization.DateTimeFormatInfo::timeSeparator
String_t* ___timeSeparator_11;
// System.String System.Globalization.DateTimeFormatInfo::monthDayPattern
String_t* ___monthDayPattern_12;
// System.String System.Globalization.DateTimeFormatInfo::dateTimeOffsetPattern
String_t* ___dateTimeOffsetPattern_13;
// System.Globalization.Calendar System.Globalization.DateTimeFormatInfo::calendar
Calendar_tF55A785ACD277504CF0D2F2C6AD56F76C6E91BD5 * ___calendar_17;
// System.Int32 System.Globalization.DateTimeFormatInfo::firstDayOfWeek
int32_t ___firstDayOfWeek_18;
// System.Int32 System.Globalization.DateTimeFormatInfo::calendarWeekRule
int32_t ___calendarWeekRule_19;
// System.String System.Globalization.DateTimeFormatInfo::fullDateTimePattern
String_t* ___fullDateTimePattern_20;
// System.String[] System.Globalization.DateTimeFormatInfo::abbreviatedDayNames
StringU5BU5D_t933FB07893230EA91C40FF900D5400665E87B14E* ___abbreviatedDayNames_21;
// System.String[] System.Globalization.DateTimeFormatInfo::m_superShortDayNames
StringU5BU5D_t933FB07893230EA91C40FF900D5400665E87B14E* ___m_superShortDayNames_22;
// System.String[] System.Globalization.DateTimeFormatInfo::dayNames
StringU5BU5D_t933FB07893230EA91C40FF900D5400665E87B14E* ___dayNames_23;
// System.String[] System.Globalization.DateTimeFormatInfo::abbreviatedMonthNames
StringU5BU5D_t933FB07893230EA91C40FF900D5400665E87B14E* ___abbreviatedMonthNames_24;
// System.String[] System.Globalization.DateTimeFormatInfo::monthNames
StringU5BU5D_t933FB07893230EA91C40FF900D5400665E87B14E* ___monthNames_25;
// System.String[] System.Globalization.DateTimeFormatInfo::genitiveMonthNames
StringU5BU5D_t933FB07893230EA91C40FF900D5400665E87B14E* ___genitiveMonthNames_26;
// System.String[] System.Globalization.DateTimeFormatInfo::m_genitiveAbbreviatedMonthNames
StringU5BU5D_t933FB07893230EA91C40FF900D5400665E87B14E* ___m_genitiveAbbreviatedMonthNames_27;
// System.String[] System.Globalization.DateTimeFormatInfo::leapYearMonthNames
StringU5BU5D_t933FB07893230EA91C40FF900D5400665E87B14E* ___leapYearMonthNames_28;
// System.String System.Globalization.DateTimeFormatInfo::longDatePattern
String_t* ___longDatePattern_29;
// System.String System.Globalization.DateTimeFormatInfo::shortDatePattern
String_t* ___shortDatePattern_30;
// System.String System.Globalization.DateTimeFormatInfo::yearMonthPattern
String_t* ___yearMonthPattern_31;
// System.String System.Globalization.DateTimeFormatInfo::longTimePattern
String_t* ___longTimePattern_32;
// System.String System.Globalization.DateTimeFormatInfo::shortTimePattern
String_t* ___shortTimePattern_33;
// System.String[] System.Globalization.DateTimeFormatInfo::allYearMonthPatterns
StringU5BU5D_t933FB07893230EA91C40FF900D5400665E87B14E* ___allYearMonthPatterns_34;
// System.String[] System.Globalization.DateTimeFormatInfo::allShortDatePatterns
StringU5BU5D_t933FB07893230EA91C40FF900D5400665E87B14E* ___allShortDatePatterns_35;
// System.String[] System.Globalization.DateTimeFormatInfo::allLongDatePatterns
StringU5BU5D_t933FB07893230EA91C40FF900D5400665E87B14E* ___allLongDatePatterns_36;
// System.String[] System.Globalization.DateTimeFormatInfo::allShortTimePatterns
StringU5BU5D_t933FB07893230EA91C40FF900D5400665E87B14E* ___allShortTimePatterns_37;
// System.String[] System.Globalization.DateTimeFormatInfo::allLongTimePatterns
StringU5BU5D_t933FB07893230EA91C40FF900D5400665E87B14E* ___allLongTimePatterns_38;
// System.String[] System.Globalization.DateTimeFormatInfo::m_eraNames
StringU5BU5D_t933FB07893230EA91C40FF900D5400665E87B14E* ___m_eraNames_39;
// System.String[] System.Globalization.DateTimeFormatInfo::m_abbrevEraNames
StringU5BU5D_t933FB07893230EA91C40FF900D5400665E87B14E* ___m_abbrevEraNames_40;
// System.String[] System.Globalization.DateTimeFormatInfo::m_abbrevEnglishEraNames
StringU5BU5D_t933FB07893230EA91C40FF900D5400665E87B14E* ___m_abbrevEnglishEraNames_41;
// System.Int32[] System.Globalization.DateTimeFormatInfo::optionalCalendars
Int32U5BU5D_t2B9E4FDDDB9F0A00EC0AC631BA2DA915EB1ECF83* ___optionalCalendars_42;
// System.Boolean System.Globalization.DateTimeFormatInfo::m_isReadOnly
bool ___m_isReadOnly_44;
// System.Globalization.DateTimeFormatFlags System.Globalization.DateTimeFormatInfo::formatFlags
int32_t ___formatFlags_45;
// System.Int32 System.Globalization.DateTimeFormatInfo::CultureID
int32_t ___CultureID_47;
// System.Boolean System.Globalization.DateTimeFormatInfo::m_useUserOverride
bool ___m_useUserOverride_48;
// System.Boolean System.Globalization.DateTimeFormatInfo::bUseCalendarInfo
bool ___bUseCalendarInfo_49;
// System.Int32 System.Globalization.DateTimeFormatInfo::nDataItem
int32_t ___nDataItem_50;
// System.Boolean System.Globalization.DateTimeFormatInfo::m_isDefaultCalendar
bool ___m_isDefaultCalendar_51;
// System.String[] System.Globalization.DateTimeFormatInfo::m_dateWords
StringU5BU5D_t933FB07893230EA91C40FF900D5400665E87B14E* ___m_dateWords_53;
// System.String System.Globalization.DateTimeFormatInfo::m_fullTimeSpanPositivePattern
String_t* ___m_fullTimeSpanPositivePattern_54;
// System.String System.Globalization.DateTimeFormatInfo::m_fullTimeSpanNegativePattern
String_t* ___m_fullTimeSpanNegativePattern_55;
// System.Globalization.TokenHashValue[] System.Globalization.DateTimeFormatInfo::m_dtfiTokenHash
TokenHashValueU5BU5D_t5C8B41D89122FC1D3ED53C946C2656DA03CE899A* ___m_dtfiTokenHash_57;
public:
inline static int32_t get_offset_of_m_cultureData_1() { return static_cast<int32_t>(offsetof(DateTimeFormatInfo_tF4BB3AA482C2F772D2A9022F78BF8727830FAF5F, ___m_cultureData_1)); }
inline CultureData_tF43B080FFA6EB278F4F289BCDA3FB74B6C208ECD * get_m_cultureData_1() const { return ___m_cultureData_1; }
inline CultureData_tF43B080FFA6EB278F4F289BCDA3FB74B6C208ECD ** get_address_of_m_cultureData_1() { return &___m_cultureData_1; }
inline void set_m_cultureData_1(CultureData_tF43B080FFA6EB278F4F289BCDA3FB74B6C208ECD * value)
{
___m_cultureData_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_cultureData_1), (void*)value);
}
inline static int32_t get_offset_of_m_name_2() { return static_cast<int32_t>(offsetof(DateTimeFormatInfo_tF4BB3AA482C2F772D2A9022F78BF8727830FAF5F, ___m_name_2)); }
inline String_t* get_m_name_2() const { return ___m_name_2; }
inline String_t** get_address_of_m_name_2() { return &___m_name_2; }
inline void set_m_name_2(String_t* value)
{
___m_name_2 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_name_2), (void*)value);
}
inline static int32_t get_offset_of_m_langName_3() { return static_cast<int32_t>(offsetof(DateTimeFormatInfo_tF4BB3AA482C2F772D2A9022F78BF8727830FAF5F, ___m_langName_3)); }
inline String_t* get_m_langName_3() const { return ___m_langName_3; }
inline String_t** get_address_of_m_langName_3() { return &___m_langName_3; }
inline void set_m_langName_3(String_t* value)
{
___m_langName_3 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_langName_3), (void*)value);
}
inline static int32_t get_offset_of_m_compareInfo_4() { return static_cast<int32_t>(offsetof(DateTimeFormatInfo_tF4BB3AA482C2F772D2A9022F78BF8727830FAF5F, ___m_compareInfo_4)); }
inline CompareInfo_tB9A071DBC11AC00AF2EA2066D0C2AE1DCB1865D1 * get_m_compareInfo_4() const { return ___m_compareInfo_4; }
inline CompareInfo_tB9A071DBC11AC00AF2EA2066D0C2AE1DCB1865D1 ** get_address_of_m_compareInfo_4() { return &___m_compareInfo_4; }
inline void set_m_compareInfo_4(CompareInfo_tB9A071DBC11AC00AF2EA2066D0C2AE1DCB1865D1 * value)
{
___m_compareInfo_4 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_compareInfo_4), (void*)value);
}
inline static int32_t get_offset_of_m_cultureInfo_5() { return static_cast<int32_t>(offsetof(DateTimeFormatInfo_tF4BB3AA482C2F772D2A9022F78BF8727830FAF5F, ___m_cultureInfo_5)); }
inline CultureInfo_t345AC6924134F039ED9A11F3E03F8E91B6A3225F * get_m_cultureInfo_5() const { return ___m_cultureInfo_5; }
inline CultureInfo_t345AC6924134F039ED9A11F3E03F8E91B6A3225F ** get_address_of_m_cultureInfo_5() { return &___m_cultureInfo_5; }
inline void set_m_cultureInfo_5(CultureInfo_t345AC6924134F039ED9A11F3E03F8E91B6A3225F * value)
{
___m_cultureInfo_5 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_cultureInfo_5), (void*)value);
}
inline static int32_t get_offset_of_amDesignator_6() { return static_cast<int32_t>(offsetof(DateTimeFormatInfo_tF4BB3AA482C2F772D2A9022F78BF8727830FAF5F, ___amDesignator_6)); }
inline String_t* get_amDesignator_6() const { return ___amDesignator_6; }
inline String_t** get_address_of_amDesignator_6() { return &___amDesignator_6; }
inline void set_amDesignator_6(String_t* value)
{
___amDesignator_6 = value;
Il2CppCodeGenWriteBarrier((void**)(&___amDesignator_6), (void*)value);
}
inline static int32_t get_offset_of_pmDesignator_7() { return static_cast<int32_t>(offsetof(DateTimeFormatInfo_tF4BB3AA482C2F772D2A9022F78BF8727830FAF5F, ___pmDesignator_7)); }
inline String_t* get_pmDesignator_7() const { return ___pmDesignator_7; }
inline String_t** get_address_of_pmDesignator_7() { return &___pmDesignator_7; }
inline void set_pmDesignator_7(String_t* value)
{
___pmDesignator_7 = value;
Il2CppCodeGenWriteBarrier((void**)(&___pmDesignator_7), (void*)value);
}
inline static int32_t get_offset_of_dateSeparator_8() { return static_cast<int32_t>(offsetof(DateTimeFormatInfo_tF4BB3AA482C2F772D2A9022F78BF8727830FAF5F, ___dateSeparator_8)); }
inline String_t* get_dateSeparator_8() const { return ___dateSeparator_8; }
inline String_t** get_address_of_dateSeparator_8() { return &___dateSeparator_8; }
inline void set_dateSeparator_8(String_t* value)
{
___dateSeparator_8 = value;
Il2CppCodeGenWriteBarrier((void**)(&___dateSeparator_8), (void*)value);
}
inline static int32_t get_offset_of_generalShortTimePattern_9() { return static_cast<int32_t>(offsetof(DateTimeFormatInfo_tF4BB3AA482C2F772D2A9022F78BF8727830FAF5F, ___generalShortTimePattern_9)); }
inline String_t* get_generalShortTimePattern_9() const { return ___generalShortTimePattern_9; }
inline String_t** get_address_of_generalShortTimePattern_9() { return &___generalShortTimePattern_9; }
inline void set_generalShortTimePattern_9(String_t* value)
{
___generalShortTimePattern_9 = value;
Il2CppCodeGenWriteBarrier((void**)(&___generalShortTimePattern_9), (void*)value);
}
inline static int32_t get_offset_of_generalLongTimePattern_10() { return static_cast<int32_t>(offsetof(DateTimeFormatInfo_tF4BB3AA482C2F772D2A9022F78BF8727830FAF5F, ___generalLongTimePattern_10)); }
inline String_t* get_generalLongTimePattern_10() const { return ___generalLongTimePattern_10; }
inline String_t** get_address_of_generalLongTimePattern_10() { return &___generalLongTimePattern_10; }
inline void set_generalLongTimePattern_10(String_t* value)
{
___generalLongTimePattern_10 = value;
Il2CppCodeGenWriteBarrier((void**)(&___generalLongTimePattern_10), (void*)value);
}
inline static int32_t get_offset_of_timeSeparator_11() { return static_cast<int32_t>(offsetof(DateTimeFormatInfo_tF4BB3AA482C2F772D2A9022F78BF8727830FAF5F, ___timeSeparator_11)); }
inline String_t* get_timeSeparator_11() const { return ___timeSeparator_11; }
inline String_t** get_address_of_timeSeparator_11() { return &___timeSeparator_11; }
inline void set_timeSeparator_11(String_t* value)
{
___timeSeparator_11 = value;
Il2CppCodeGenWriteBarrier((void**)(&___timeSeparator_11), (void*)value);
}
inline static int32_t get_offset_of_monthDayPattern_12() { return static_cast<int32_t>(offsetof(DateTimeFormatInfo_tF4BB3AA482C2F772D2A9022F78BF8727830FAF5F, ___monthDayPattern_12)); }
inline String_t* get_monthDayPattern_12() const { return ___monthDayPattern_12; }
inline String_t** get_address_of_monthDayPattern_12() { return &___monthDayPattern_12; }
inline void set_monthDayPattern_12(String_t* value)
{
___monthDayPattern_12 = value;
Il2CppCodeGenWriteBarrier((void**)(&___monthDayPattern_12), (void*)value);
}
inline static int32_t get_offset_of_dateTimeOffsetPattern_13() { return static_cast<int32_t>(offsetof(DateTimeFormatInfo_tF4BB3AA482C2F772D2A9022F78BF8727830FAF5F, ___dateTimeOffsetPattern_13)); }
inline String_t* get_dateTimeOffsetPattern_13() const { return ___dateTimeOffsetPattern_13; }
inline String_t** get_address_of_dateTimeOffsetPattern_13() { return &___dateTimeOffsetPattern_13; }
inline void set_dateTimeOffsetPattern_13(String_t* value)
{
___dateTimeOffsetPattern_13 = value;
Il2CppCodeGenWriteBarrier((void**)(&___dateTimeOffsetPattern_13), (void*)value);
}
inline static int32_t get_offset_of_calendar_17() { return static_cast<int32_t>(offsetof(DateTimeFormatInfo_tF4BB3AA482C2F772D2A9022F78BF8727830FAF5F, ___calendar_17)); }
inline Calendar_tF55A785ACD277504CF0D2F2C6AD56F76C6E91BD5 * get_calendar_17() const { return ___calendar_17; }
inline Calendar_tF55A785ACD277504CF0D2F2C6AD56F76C6E91BD5 ** get_address_of_calendar_17() { return &___calendar_17; }
inline void set_calendar_17(Calendar_tF55A785ACD277504CF0D2F2C6AD56F76C6E91BD5 * value)
{
___calendar_17 = value;
Il2CppCodeGenWriteBarrier((void**)(&___calendar_17), (void*)value);
}
inline static int32_t get_offset_of_firstDayOfWeek_18() { return static_cast<int32_t>(offsetof(DateTimeFormatInfo_tF4BB3AA482C2F772D2A9022F78BF8727830FAF5F, ___firstDayOfWeek_18)); }
inline int32_t get_firstDayOfWeek_18() const { return ___firstDayOfWeek_18; }
inline int32_t* get_address_of_firstDayOfWeek_18() { return &___firstDayOfWeek_18; }
inline void set_firstDayOfWeek_18(int32_t value)
{
___firstDayOfWeek_18 = value;
}
inline static int32_t get_offset_of_calendarWeekRule_19() { return static_cast<int32_t>(offsetof(DateTimeFormatInfo_tF4BB3AA482C2F772D2A9022F78BF8727830FAF5F, ___calendarWeekRule_19)); }
inline int32_t get_calendarWeekRule_19() const { return ___calendarWeekRule_19; }
inline int32_t* get_address_of_calendarWeekRule_19() { return &___calendarWeekRule_19; }
inline void set_calendarWeekRule_19(int32_t value)
{
___calendarWeekRule_19 = value;
}
inline static int32_t get_offset_of_fullDateTimePattern_20() { return static_cast<int32_t>(offsetof(DateTimeFormatInfo_tF4BB3AA482C2F772D2A9022F78BF8727830FAF5F, ___fullDateTimePattern_20)); }
inline String_t* get_fullDateTimePattern_20() const { return ___fullDateTimePattern_20; }
inline String_t** get_address_of_fullDateTimePattern_20() { return &___fullDateTimePattern_20; }
inline void set_fullDateTimePattern_20(String_t* value)
{
___fullDateTimePattern_20 = value;
Il2CppCodeGenWriteBarrier((void**)(&___fullDateTimePattern_20), (void*)value);
}
inline static int32_t get_offset_of_abbreviatedDayNames_21() { return static_cast<int32_t>(offsetof(DateTimeFormatInfo_tF4BB3AA482C2F772D2A9022F78BF8727830FAF5F, ___abbreviatedDayNames_21)); }
inline StringU5BU5D_t933FB07893230EA91C40FF900D5400665E87B14E* get_abbreviatedDayNames_21() const { return ___abbreviatedDayNames_21; }
inline StringU5BU5D_t933FB07893230EA91C40FF900D5400665E87B14E** get_address_of_abbreviatedDayNames_21() { return &___abbreviatedDayNames_21; }
inline void set_abbreviatedDayNames_21(StringU5BU5D_t933FB07893230EA91C40FF900D5400665E87B14E* value)
{
___abbreviatedDayNames_21 = value;
Il2CppCodeGenWriteBarrier((void**)(&___abbreviatedDayNames_21), (void*)value);
}
inline static int32_t get_offset_of_m_superShortDayNames_22() { return static_cast<int32_t>(offsetof(DateTimeFormatInfo_tF4BB3AA482C2F772D2A9022F78BF8727830FAF5F, ___m_superShortDayNames_22)); }
inline StringU5BU5D_t933FB07893230EA91C40FF900D5400665E87B14E* get_m_superShortDayNames_22() const { return ___m_superShortDayNames_22; }
inline StringU5BU5D_t933FB07893230EA91C40FF900D5400665E87B14E** get_address_of_m_superShortDayNames_22() { return &___m_superShortDayNames_22; }
inline void set_m_superShortDayNames_22(StringU5BU5D_t933FB07893230EA91C40FF900D5400665E87B14E* value)
{
___m_superShortDayNames_22 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_superShortDayNames_22), (void*)value);
}
inline static int32_t get_offset_of_dayNames_23() { return static_cast<int32_t>(offsetof(DateTimeFormatInfo_tF4BB3AA482C2F772D2A9022F78BF8727830FAF5F, ___dayNames_23)); }
inline StringU5BU5D_t933FB07893230EA91C40FF900D5400665E87B14E* get_dayNames_23() const { return ___dayNames_23; }
inline StringU5BU5D_t933FB07893230EA91C40FF900D5400665E87B14E** get_address_of_dayNames_23() { return &___dayNames_23; }
inline void set_dayNames_23(StringU5BU5D_t933FB07893230EA91C40FF900D5400665E87B14E* value)
{
___dayNames_23 = value;
Il2CppCodeGenWriteBarrier((void**)(&___dayNames_23), (void*)value);
}
inline static int32_t get_offset_of_abbreviatedMonthNames_24() { return static_cast<int32_t>(offsetof(DateTimeFormatInfo_tF4BB3AA482C2F772D2A9022F78BF8727830FAF5F, ___abbreviatedMonthNames_24)); }
inline StringU5BU5D_t933FB07893230EA91C40FF900D5400665E87B14E* get_abbreviatedMonthNames_24() const { return ___abbreviatedMonthNames_24; }
inline StringU5BU5D_t933FB07893230EA91C40FF900D5400665E87B14E** get_address_of_abbreviatedMonthNames_24() { return &___abbreviatedMonthNames_24; }
inline void set_abbreviatedMonthNames_24(StringU5BU5D_t933FB07893230EA91C40FF900D5400665E87B14E* value)
{
___abbreviatedMonthNames_24 = value;
Il2CppCodeGenWriteBarrier((void**)(&___abbreviatedMonthNames_24), (void*)value);
}
inline static int32_t get_offset_of_monthNames_25() { return static_cast<int32_t>(offsetof(DateTimeFormatInfo_tF4BB3AA482C2F772D2A9022F78BF8727830FAF5F, ___monthNames_25)); }
inline StringU5BU5D_t933FB07893230EA91C40FF900D5400665E87B14E* get_monthNames_25() const { return ___monthNames_25; }
inline StringU5BU5D_t933FB07893230EA91C40FF900D5400665E87B14E** get_address_of_monthNames_25() { return &___monthNames_25; }
inline void set_monthNames_25(StringU5BU5D_t933FB07893230EA91C40FF900D5400665E87B14E* value)
{
___monthNames_25 = value;
Il2CppCodeGenWriteBarrier((void**)(&___monthNames_25), (void*)value);
}
inline static int32_t get_offset_of_genitiveMonthNames_26() { return static_cast<int32_t>(offsetof(DateTimeFormatInfo_tF4BB3AA482C2F772D2A9022F78BF8727830FAF5F, ___genitiveMonthNames_26)); }
inline StringU5BU5D_t933FB07893230EA91C40FF900D5400665E87B14E* get_genitiveMonthNames_26() const { return ___genitiveMonthNames_26; }
inline StringU5BU5D_t933FB07893230EA91C40FF900D5400665E87B14E** get_address_of_genitiveMonthNames_26() { return &___genitiveMonthNames_26; }
inline void set_genitiveMonthNames_26(StringU5BU5D_t933FB07893230EA91C40FF900D5400665E87B14E* value)
{
___genitiveMonthNames_26 = value;
Il2CppCodeGenWriteBarrier((void**)(&___genitiveMonthNames_26), (void*)value);
}
inline static int32_t get_offset_of_m_genitiveAbbreviatedMonthNames_27() { return static_cast<int32_t>(offsetof(DateTimeFormatInfo_tF4BB3AA482C2F772D2A9022F78BF8727830FAF5F, ___m_genitiveAbbreviatedMonthNames_27)); }
inline StringU5BU5D_t933FB07893230EA91C40FF900D5400665E87B14E* get_m_genitiveAbbreviatedMonthNames_27() const { return ___m_genitiveAbbreviatedMonthNames_27; }
inline StringU5BU5D_t933FB07893230EA91C40FF900D5400665E87B14E** get_address_of_m_genitiveAbbreviatedMonthNames_27() { return &___m_genitiveAbbreviatedMonthNames_27; }
inline void set_m_genitiveAbbreviatedMonthNames_27(StringU5BU5D_t933FB07893230EA91C40FF900D5400665E87B14E* value)
{
___m_genitiveAbbreviatedMonthNames_27 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_genitiveAbbreviatedMonthNames_27), (void*)value);
}
inline static int32_t get_offset_of_leapYearMonthNames_28() { return static_cast<int32_t>(offsetof(DateTimeFormatInfo_tF4BB3AA482C2F772D2A9022F78BF8727830FAF5F, ___leapYearMonthNames_28)); }
inline StringU5BU5D_t933FB07893230EA91C40FF900D5400665E87B14E* get_leapYearMonthNames_28() const { return ___leapYearMonthNames_28; }
inline StringU5BU5D_t933FB07893230EA91C40FF900D5400665E87B14E** get_address_of_leapYearMonthNames_28() { return &___leapYearMonthNames_28; }
inline void set_leapYearMonthNames_28(StringU5BU5D_t933FB07893230EA91C40FF900D5400665E87B14E* value)
{
___leapYearMonthNames_28 = value;
Il2CppCodeGenWriteBarrier((void**)(&___leapYearMonthNames_28), (void*)value);
}
inline static int32_t get_offset_of_longDatePattern_29() { return static_cast<int32_t>(offsetof(DateTimeFormatInfo_tF4BB3AA482C2F772D2A9022F78BF8727830FAF5F, ___longDatePattern_29)); }
inline String_t* get_longDatePattern_29() const { return ___longDatePattern_29; }
inline String_t** get_address_of_longDatePattern_29() { return &___longDatePattern_29; }
inline void set_longDatePattern_29(String_t* value)
{
___longDatePattern_29 = value;
Il2CppCodeGenWriteBarrier((void**)(&___longDatePattern_29), (void*)value);
}
inline static int32_t get_offset_of_shortDatePattern_30() { return static_cast<int32_t>(offsetof(DateTimeFormatInfo_tF4BB3AA482C2F772D2A9022F78BF8727830FAF5F, ___shortDatePattern_30)); }
inline String_t* get_shortDatePattern_30() const { return ___shortDatePattern_30; }
inline String_t** get_address_of_shortDatePattern_30() { return &___shortDatePattern_30; }
inline void set_shortDatePattern_30(String_t* value)
{
___shortDatePattern_30 = value;
Il2CppCodeGenWriteBarrier((void**)(&___shortDatePattern_30), (void*)value);
}
inline static int32_t get_offset_of_yearMonthPattern_31() { return static_cast<int32_t>(offsetof(DateTimeFormatInfo_tF4BB3AA482C2F772D2A9022F78BF8727830FAF5F, ___yearMonthPattern_31)); }
inline String_t* get_yearMonthPattern_31() const { return ___yearMonthPattern_31; }
inline String_t** get_address_of_yearMonthPattern_31() { return &___yearMonthPattern_31; }
inline void set_yearMonthPattern_31(String_t* value)
{
___yearMonthPattern_31 = value;
Il2CppCodeGenWriteBarrier((void**)(&___yearMonthPattern_31), (void*)value);
}
inline static int32_t get_offset_of_longTimePattern_32() { return static_cast<int32_t>(offsetof(DateTimeFormatInfo_tF4BB3AA482C2F772D2A9022F78BF8727830FAF5F, ___longTimePattern_32)); }
inline String_t* get_longTimePattern_32() const { return ___longTimePattern_32; }
inline String_t** get_address_of_longTimePattern_32() { return &___longTimePattern_32; }
inline void set_longTimePattern_32(String_t* value)
{
___longTimePattern_32 = value;
Il2CppCodeGenWriteBarrier((void**)(&___longTimePattern_32), (void*)value);
}
inline static int32_t get_offset_of_shortTimePattern_33() { return static_cast<int32_t>(offsetof(DateTimeFormatInfo_tF4BB3AA482C2F772D2A9022F78BF8727830FAF5F, ___shortTimePattern_33)); }
inline String_t* get_shortTimePattern_33() const { return ___shortTimePattern_33; }
inline String_t** get_address_of_shortTimePattern_33() { return &___shortTimePattern_33; }
inline void set_shortTimePattern_33(String_t* value)
{
___shortTimePattern_33 = value;
Il2CppCodeGenWriteBarrier((void**)(&___shortTimePattern_33), (void*)value);
}
inline static int32_t get_offset_of_allYearMonthPatterns_34() { return static_cast<int32_t>(offsetof(DateTimeFormatInfo_tF4BB3AA482C2F772D2A9022F78BF8727830FAF5F, ___allYearMonthPatterns_34)); }
inline StringU5BU5D_t933FB07893230EA91C40FF900D5400665E87B14E* get_allYearMonthPatterns_34() const { return ___allYearMonthPatterns_34; }
inline StringU5BU5D_t933FB07893230EA91C40FF900D5400665E87B14E** get_address_of_allYearMonthPatterns_34() { return &___allYearMonthPatterns_34; }
inline void set_allYearMonthPatterns_34(StringU5BU5D_t933FB07893230EA91C40FF900D5400665E87B14E* value)
{
___allYearMonthPatterns_34 = value;
Il2CppCodeGenWriteBarrier((void**)(&___allYearMonthPatterns_34), (void*)value);
}
inline static int32_t get_offset_of_allShortDatePatterns_35() { return static_cast<int32_t>(offsetof(DateTimeFormatInfo_tF4BB3AA482C2F772D2A9022F78BF8727830FAF5F, ___allShortDatePatterns_35)); }
inline StringU5BU5D_t933FB07893230EA91C40FF900D5400665E87B14E* get_allShortDatePatterns_35() const { return ___allShortDatePatterns_35; }
inline StringU5BU5D_t933FB07893230EA91C40FF900D5400665E87B14E** get_address_of_allShortDatePatterns_35() { return &___allShortDatePatterns_35; }
inline void set_allShortDatePatterns_35(StringU5BU5D_t933FB07893230EA91C40FF900D5400665E87B14E* value)
{
___allShortDatePatterns_35 = value;
Il2CppCodeGenWriteBarrier((void**)(&___allShortDatePatterns_35), (void*)value);
}
inline static int32_t get_offset_of_allLongDatePatterns_36() { return static_cast<int32_t>(offsetof(DateTimeFormatInfo_tF4BB3AA482C2F772D2A9022F78BF8727830FAF5F, ___allLongDatePatterns_36)); }
inline StringU5BU5D_t933FB07893230EA91C40FF900D5400665E87B14E* get_allLongDatePatterns_36() const { return ___allLongDatePatterns_36; }
inline StringU5BU5D_t933FB07893230EA91C40FF900D5400665E87B14E** get_address_of_allLongDatePatterns_36() { return &___allLongDatePatterns_36; }
inline void set_allLongDatePatterns_36(StringU5BU5D_t933FB07893230EA91C40FF900D5400665E87B14E* value)
{
___allLongDatePatterns_36 = value;
Il2CppCodeGenWriteBarrier((void**)(&___allLongDatePatterns_36), (void*)value);
}
inline static int32_t get_offset_of_allShortTimePatterns_37() { return static_cast<int32_t>(offsetof(DateTimeFormatInfo_tF4BB3AA482C2F772D2A9022F78BF8727830FAF5F, ___allShortTimePatterns_37)); }
inline StringU5BU5D_t933FB07893230EA91C40FF900D5400665E87B14E* get_allShortTimePatterns_37() const { return ___allShortTimePatterns_37; }
inline StringU5BU5D_t933FB07893230EA91C40FF900D5400665E87B14E** get_address_of_allShortTimePatterns_37() { return &___allShortTimePatterns_37; }
inline void set_allShortTimePatterns_37(StringU5BU5D_t933FB07893230EA91C40FF900D5400665E87B14E* value)
{
___allShortTimePatterns_37 = value;
Il2CppCodeGenWriteBarrier((void**)(&___allShortTimePatterns_37), (void*)value);
}
inline static int32_t get_offset_of_allLongTimePatterns_38() { return static_cast<int32_t>(offsetof(DateTimeFormatInfo_tF4BB3AA482C2F772D2A9022F78BF8727830FAF5F, ___allLongTimePatterns_38)); }
inline StringU5BU5D_t933FB07893230EA91C40FF900D5400665E87B14E* get_allLongTimePatterns_38() const { return ___allLongTimePatterns_38; }
inline StringU5BU5D_t933FB07893230EA91C40FF900D5400665E87B14E** get_address_of_allLongTimePatterns_38() { return &___allLongTimePatterns_38; }
inline void set_allLongTimePatterns_38(StringU5BU5D_t933FB07893230EA91C40FF900D5400665E87B14E* value)
{
___allLongTimePatterns_38 = value;
Il2CppCodeGenWriteBarrier((void**)(&___allLongTimePatterns_38), (void*)value);
}
inline static int32_t get_offset_of_m_eraNames_39() { return static_cast<int32_t>(offsetof(DateTimeFormatInfo_tF4BB3AA482C2F772D2A9022F78BF8727830FAF5F, ___m_eraNames_39)); }
inline StringU5BU5D_t933FB07893230EA91C40FF900D5400665E87B14E* get_m_eraNames_39() const { return ___m_eraNames_39; }
inline StringU5BU5D_t933FB07893230EA91C40FF900D5400665E87B14E** get_address_of_m_eraNames_39() { return &___m_eraNames_39; }
inline void set_m_eraNames_39(StringU5BU5D_t933FB07893230EA91C40FF900D5400665E87B14E* value)
{
___m_eraNames_39 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_eraNames_39), (void*)value);
}
inline static int32_t get_offset_of_m_abbrevEraNames_40() { return static_cast<int32_t>(offsetof(DateTimeFormatInfo_tF4BB3AA482C2F772D2A9022F78BF8727830FAF5F, ___m_abbrevEraNames_40)); }
inline StringU5BU5D_t933FB07893230EA91C40FF900D5400665E87B14E* get_m_abbrevEraNames_40() const { return ___m_abbrevEraNames_40; }
inline StringU5BU5D_t933FB07893230EA91C40FF900D5400665E87B14E** get_address_of_m_abbrevEraNames_40() { return &___m_abbrevEraNames_40; }
inline void set_m_abbrevEraNames_40(StringU5BU5D_t933FB07893230EA91C40FF900D5400665E87B14E* value)
{
___m_abbrevEraNames_40 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_abbrevEraNames_40), (void*)value);
}
inline static int32_t get_offset_of_m_abbrevEnglishEraNames_41() { return static_cast<int32_t>(offsetof(DateTimeFormatInfo_tF4BB3AA482C2F772D2A9022F78BF8727830FAF5F, ___m_abbrevEnglishEraNames_41)); }
inline StringU5BU5D_t933FB07893230EA91C40FF900D5400665E87B14E* get_m_abbrevEnglishEraNames_41() const { return ___m_abbrevEnglishEraNames_41; }
inline StringU5BU5D_t933FB07893230EA91C40FF900D5400665E87B14E** get_address_of_m_abbrevEnglishEraNames_41() { return &___m_abbrevEnglishEraNames_41; }
inline void set_m_abbrevEnglishEraNames_41(StringU5BU5D_t933FB07893230EA91C40FF900D5400665E87B14E* value)
{
___m_abbrevEnglishEraNames_41 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_abbrevEnglishEraNames_41), (void*)value);
}
inline static int32_t get_offset_of_optionalCalendars_42() { return static_cast<int32_t>(offsetof(DateTimeFormatInfo_tF4BB3AA482C2F772D2A9022F78BF8727830FAF5F, ___optionalCalendars_42)); }
inline Int32U5BU5D_t2B9E4FDDDB9F0A00EC0AC631BA2DA915EB1ECF83* get_optionalCalendars_42() const { return ___optionalCalendars_42; }
inline Int32U5BU5D_t2B9E4FDDDB9F0A00EC0AC631BA2DA915EB1ECF83** get_address_of_optionalCalendars_42() { return &___optionalCalendars_42; }
inline void set_optionalCalendars_42(Int32U5BU5D_t2B9E4FDDDB9F0A00EC0AC631BA2DA915EB1ECF83* value)
{
___optionalCalendars_42 = value;
Il2CppCodeGenWriteBarrier((void**)(&___optionalCalendars_42), (void*)value);
}
inline static int32_t get_offset_of_m_isReadOnly_44() { return static_cast<int32_t>(offsetof(DateTimeFormatInfo_tF4BB3AA482C2F772D2A9022F78BF8727830FAF5F, ___m_isReadOnly_44)); }
inline bool get_m_isReadOnly_44() const { return ___m_isReadOnly_44; }
inline bool* get_address_of_m_isReadOnly_44() { return &___m_isReadOnly_44; }
inline void set_m_isReadOnly_44(bool value)
{
___m_isReadOnly_44 = value;
}
inline static int32_t get_offset_of_formatFlags_45() { return static_cast<int32_t>(offsetof(DateTimeFormatInfo_tF4BB3AA482C2F772D2A9022F78BF8727830FAF5F, ___formatFlags_45)); }
inline int32_t get_formatFlags_45() const { return ___formatFlags_45; }
inline int32_t* get_address_of_formatFlags_45() { return &___formatFlags_45; }
inline void set_formatFlags_45(int32_t value)
{
___formatFlags_45 = value;
}
inline static int32_t get_offset_of_CultureID_47() { return static_cast<int32_t>(offsetof(DateTimeFormatInfo_tF4BB3AA482C2F772D2A9022F78BF8727830FAF5F, ___CultureID_47)); }
inline int32_t get_CultureID_47() const { return ___CultureID_47; }
inline int32_t* get_address_of_CultureID_47() { return &___CultureID_47; }
inline void set_CultureID_47(int32_t value)
{
___CultureID_47 = value;
}
inline static int32_t get_offset_of_m_useUserOverride_48() { return static_cast<int32_t>(offsetof(DateTimeFormatInfo_tF4BB3AA482C2F772D2A9022F78BF8727830FAF5F, ___m_useUserOverride_48)); }
inline bool get_m_useUserOverride_48() const { return ___m_useUserOverride_48; }
inline bool* get_address_of_m_useUserOverride_48() { return &___m_useUserOverride_48; }
inline void set_m_useUserOverride_48(bool value)
{
___m_useUserOverride_48 = value;
}
inline static int32_t get_offset_of_bUseCalendarInfo_49() { return static_cast<int32_t>(offsetof(DateTimeFormatInfo_tF4BB3AA482C2F772D2A9022F78BF8727830FAF5F, ___bUseCalendarInfo_49)); }
inline bool get_bUseCalendarInfo_49() const { return ___bUseCalendarInfo_49; }
inline bool* get_address_of_bUseCalendarInfo_49() { return &___bUseCalendarInfo_49; }
inline void set_bUseCalendarInfo_49(bool value)
{
___bUseCalendarInfo_49 = value;
}
inline static int32_t get_offset_of_nDataItem_50() { return static_cast<int32_t>(offsetof(DateTimeFormatInfo_tF4BB3AA482C2F772D2A9022F78BF8727830FAF5F, ___nDataItem_50)); }
inline int32_t get_nDataItem_50() const { return ___nDataItem_50; }
inline int32_t* get_address_of_nDataItem_50() { return &___nDataItem_50; }
inline void set_nDataItem_50(int32_t value)
{
___nDataItem_50 = value;
}
inline static int32_t get_offset_of_m_isDefaultCalendar_51() { return static_cast<int32_t>(offsetof(DateTimeFormatInfo_tF4BB3AA482C2F772D2A9022F78BF8727830FAF5F, ___m_isDefaultCalendar_51)); }
inline bool get_m_isDefaultCalendar_51() const { return ___m_isDefaultCalendar_51; }
inline bool* get_address_of_m_isDefaultCalendar_51() { return &___m_isDefaultCalendar_51; }
inline void set_m_isDefaultCalendar_51(bool value)
{
___m_isDefaultCalendar_51 = value;
}
inline static int32_t get_offset_of_m_dateWords_53() { return static_cast<int32_t>(offsetof(DateTimeFormatInfo_tF4BB3AA482C2F772D2A9022F78BF8727830FAF5F, ___m_dateWords_53)); }
inline StringU5BU5D_t933FB07893230EA91C40FF900D5400665E87B14E* get_m_dateWords_53() const { return ___m_dateWords_53; }
inline StringU5BU5D_t933FB07893230EA91C40FF900D5400665E87B14E** get_address_of_m_dateWords_53() { return &___m_dateWords_53; }
inline void set_m_dateWords_53(StringU5BU5D_t933FB07893230EA91C40FF900D5400665E87B14E* value)
{
___m_dateWords_53 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_dateWords_53), (void*)value);
}
inline static int32_t get_offset_of_m_fullTimeSpanPositivePattern_54() { return static_cast<int32_t>(offsetof(DateTimeFormatInfo_tF4BB3AA482C2F772D2A9022F78BF8727830FAF5F, ___m_fullTimeSpanPositivePattern_54)); }
inline String_t* get_m_fullTimeSpanPositivePattern_54() const { return ___m_fullTimeSpanPositivePattern_54; }
inline String_t** get_address_of_m_fullTimeSpanPositivePattern_54() { return &___m_fullTimeSpanPositivePattern_54; }
inline void set_m_fullTimeSpanPositivePattern_54(String_t* value)
{
___m_fullTimeSpanPositivePattern_54 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_fullTimeSpanPositivePattern_54), (void*)value);
}
inline static int32_t get_offset_of_m_fullTimeSpanNegativePattern_55() { return static_cast<int32_t>(offsetof(DateTimeFormatInfo_tF4BB3AA482C2F772D2A9022F78BF8727830FAF5F, ___m_fullTimeSpanNegativePattern_55)); }
inline String_t* get_m_fullTimeSpanNegativePattern_55() const { return ___m_fullTimeSpanNegativePattern_55; }
inline String_t** get_address_of_m_fullTimeSpanNegativePattern_55() { return &___m_fullTimeSpanNegativePattern_55; }
inline void set_m_fullTimeSpanNegativePattern_55(String_t* value)
{
___m_fullTimeSpanNegativePattern_55 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_fullTimeSpanNegativePattern_55), (void*)value);
}
inline static int32_t get_offset_of_m_dtfiTokenHash_57() { return static_cast<int32_t>(offsetof(DateTimeFormatInfo_tF4BB3AA482C2F772D2A9022F78BF8727830FAF5F, ___m_dtfiTokenHash_57)); }
inline TokenHashValueU5BU5D_t5C8B41D89122FC1D3ED53C946C2656DA03CE899A* get_m_dtfiTokenHash_57() const { return ___m_dtfiTokenHash_57; }
inline TokenHashValueU5BU5D_t5C8B41D89122FC1D3ED53C946C2656DA03CE899A** get_address_of_m_dtfiTokenHash_57() { return &___m_dtfiTokenHash_57; }
inline void set_m_dtfiTokenHash_57(TokenHashValueU5BU5D_t5C8B41D89122FC1D3ED53C946C2656DA03CE899A* value)
{
___m_dtfiTokenHash_57 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_dtfiTokenHash_57), (void*)value);
}
};
struct DateTimeFormatInfo_tF4BB3AA482C2F772D2A9022F78BF8727830FAF5F_StaticFields
{
public:
// System.Globalization.DateTimeFormatInfo modreq(System.Runtime.CompilerServices.IsVolatile) System.Globalization.DateTimeFormatInfo::invariantInfo
DateTimeFormatInfo_tF4BB3AA482C2F772D2A9022F78BF8727830FAF5F * ___invariantInfo_0;
// System.Boolean System.Globalization.DateTimeFormatInfo::preferExistingTokens
bool ___preferExistingTokens_46;
// System.Collections.Hashtable modreq(System.Runtime.CompilerServices.IsVolatile) System.Globalization.DateTimeFormatInfo::s_calendarNativeNames
Hashtable_t978F65B8006C8F5504B286526AEC6608FF983FC9 * ___s_calendarNativeNames_52;
// System.Globalization.DateTimeFormatInfo modreq(System.Runtime.CompilerServices.IsVolatile) System.Globalization.DateTimeFormatInfo::s_jajpDTFI
DateTimeFormatInfo_tF4BB3AA482C2F772D2A9022F78BF8727830FAF5F * ___s_jajpDTFI_82;
// System.Globalization.DateTimeFormatInfo modreq(System.Runtime.CompilerServices.IsVolatile) System.Globalization.DateTimeFormatInfo::s_zhtwDTFI
DateTimeFormatInfo_tF4BB3AA482C2F772D2A9022F78BF8727830FAF5F * ___s_zhtwDTFI_83;
public:
inline static int32_t get_offset_of_invariantInfo_0() { return static_cast<int32_t>(offsetof(DateTimeFormatInfo_tF4BB3AA482C2F772D2A9022F78BF8727830FAF5F_StaticFields, ___invariantInfo_0)); }
inline DateTimeFormatInfo_tF4BB3AA482C2F772D2A9022F78BF8727830FAF5F * get_invariantInfo_0() const { return ___invariantInfo_0; }
inline DateTimeFormatInfo_tF4BB3AA482C2F772D2A9022F78BF8727830FAF5F ** get_address_of_invariantInfo_0() { return &___invariantInfo_0; }
inline void set_invariantInfo_0(DateTimeFormatInfo_tF4BB3AA482C2F772D2A9022F78BF8727830FAF5F * value)
{
___invariantInfo_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___invariantInfo_0), (void*)value);
}
inline static int32_t get_offset_of_preferExistingTokens_46() { return static_cast<int32_t>(offsetof(DateTimeFormatInfo_tF4BB3AA482C2F772D2A9022F78BF8727830FAF5F_StaticFields, ___preferExistingTokens_46)); }
inline bool get_preferExistingTokens_46() const { return ___preferExistingTokens_46; }
inline bool* get_address_of_preferExistingTokens_46() { return &___preferExistingTokens_46; }
inline void set_preferExistingTokens_46(bool value)
{
___preferExistingTokens_46 = value;
}
inline static int32_t get_offset_of_s_calendarNativeNames_52() { return static_cast<int32_t>(offsetof(DateTimeFormatInfo_tF4BB3AA482C2F772D2A9022F78BF8727830FAF5F_StaticFields, ___s_calendarNativeNames_52)); }
inline Hashtable_t978F65B8006C8F5504B286526AEC6608FF983FC9 * get_s_calendarNativeNames_52() const { return ___s_calendarNativeNames_52; }
inline Hashtable_t978F65B8006C8F5504B286526AEC6608FF983FC9 ** get_address_of_s_calendarNativeNames_52() { return &___s_calendarNativeNames_52; }
inline void set_s_calendarNativeNames_52(Hashtable_t978F65B8006C8F5504B286526AEC6608FF983FC9 * value)
{
___s_calendarNativeNames_52 = value;
Il2CppCodeGenWriteBarrier((void**)(&___s_calendarNativeNames_52), (void*)value);
}
inline static int32_t get_offset_of_s_jajpDTFI_82() { return static_cast<int32_t>(offsetof(DateTimeFormatInfo_tF4BB3AA482C2F772D2A9022F78BF8727830FAF5F_StaticFields, ___s_jajpDTFI_82)); }
inline DateTimeFormatInfo_tF4BB3AA482C2F772D2A9022F78BF8727830FAF5F * get_s_jajpDTFI_82() const { return ___s_jajpDTFI_82; }
inline DateTimeFormatInfo_tF4BB3AA482C2F772D2A9022F78BF8727830FAF5F ** get_address_of_s_jajpDTFI_82() { return &___s_jajpDTFI_82; }
inline void set_s_jajpDTFI_82(DateTimeFormatInfo_tF4BB3AA482C2F772D2A9022F78BF8727830FAF5F * value)
{
___s_jajpDTFI_82 = value;
Il2CppCodeGenWriteBarrier((void**)(&___s_jajpDTFI_82), (void*)value);
}
inline static int32_t get_offset_of_s_zhtwDTFI_83() { return static_cast<int32_t>(offsetof(DateTimeFormatInfo_tF4BB3AA482C2F772D2A9022F78BF8727830FAF5F_StaticFields, ___s_zhtwDTFI_83)); }
inline DateTimeFormatInfo_tF4BB3AA482C2F772D2A9022F78BF8727830FAF5F * get_s_zhtwDTFI_83() const { return ___s_zhtwDTFI_83; }
inline DateTimeFormatInfo_tF4BB3AA482C2F772D2A9022F78BF8727830FAF5F ** get_address_of_s_zhtwDTFI_83() { return &___s_zhtwDTFI_83; }
inline void set_s_zhtwDTFI_83(DateTimeFormatInfo_tF4BB3AA482C2F772D2A9022F78BF8727830FAF5F * value)
{
___s_zhtwDTFI_83 = value;
Il2CppCodeGenWriteBarrier((void**)(&___s_zhtwDTFI_83), (void*)value);
}
};
// System.Globalization.NumberFormatInfo
struct NumberFormatInfo_tFDF57037EBC5BC833D0A53EF0327B805994860A8 : public RuntimeObject
{
public:
// System.Int32[] System.Globalization.NumberFormatInfo::numberGroupSizes
Int32U5BU5D_t2B9E4FDDDB9F0A00EC0AC631BA2DA915EB1ECF83* ___numberGroupSizes_1;
// System.Int32[] System.Globalization.NumberFormatInfo::currencyGroupSizes
Int32U5BU5D_t2B9E4FDDDB9F0A00EC0AC631BA2DA915EB1ECF83* ___currencyGroupSizes_2;
// System.Int32[] System.Globalization.NumberFormatInfo::percentGroupSizes
Int32U5BU5D_t2B9E4FDDDB9F0A00EC0AC631BA2DA915EB1ECF83* ___percentGroupSizes_3;
// System.String System.Globalization.NumberFormatInfo::positiveSign
String_t* ___positiveSign_4;
// System.String System.Globalization.NumberFormatInfo::negativeSign
String_t* ___negativeSign_5;
// System.String System.Globalization.NumberFormatInfo::numberDecimalSeparator
String_t* ___numberDecimalSeparator_6;
// System.String System.Globalization.NumberFormatInfo::numberGroupSeparator
String_t* ___numberGroupSeparator_7;
// System.String System.Globalization.NumberFormatInfo::currencyGroupSeparator
String_t* ___currencyGroupSeparator_8;
// System.String System.Globalization.NumberFormatInfo::currencyDecimalSeparator
String_t* ___currencyDecimalSeparator_9;
// System.String System.Globalization.NumberFormatInfo::currencySymbol
String_t* ___currencySymbol_10;
// System.String System.Globalization.NumberFormatInfo::ansiCurrencySymbol
String_t* ___ansiCurrencySymbol_11;
// System.String System.Globalization.NumberFormatInfo::nanSymbol
String_t* ___nanSymbol_12;
// System.String System.Globalization.NumberFormatInfo::positiveInfinitySymbol
String_t* ___positiveInfinitySymbol_13;
// System.String System.Globalization.NumberFormatInfo::negativeInfinitySymbol
String_t* ___negativeInfinitySymbol_14;
// System.String System.Globalization.NumberFormatInfo::percentDecimalSeparator
String_t* ___percentDecimalSeparator_15;
// System.String System.Globalization.NumberFormatInfo::percentGroupSeparator
String_t* ___percentGroupSeparator_16;
// System.String System.Globalization.NumberFormatInfo::percentSymbol
String_t* ___percentSymbol_17;
// System.String System.Globalization.NumberFormatInfo::perMilleSymbol
String_t* ___perMilleSymbol_18;
// System.String[] System.Globalization.NumberFormatInfo::nativeDigits
StringU5BU5D_t933FB07893230EA91C40FF900D5400665E87B14E* ___nativeDigits_19;
// System.Int32 System.Globalization.NumberFormatInfo::m_dataItem
int32_t ___m_dataItem_20;
// System.Int32 System.Globalization.NumberFormatInfo::numberDecimalDigits
int32_t ___numberDecimalDigits_21;
// System.Int32 System.Globalization.NumberFormatInfo::currencyDecimalDigits
int32_t ___currencyDecimalDigits_22;
// System.Int32 System.Globalization.NumberFormatInfo::currencyPositivePattern
int32_t ___currencyPositivePattern_23;
// System.Int32 System.Globalization.NumberFormatInfo::currencyNegativePattern
int32_t ___currencyNegativePattern_24;
// System.Int32 System.Globalization.NumberFormatInfo::numberNegativePattern
int32_t ___numberNegativePattern_25;
// System.Int32 System.Globalization.NumberFormatInfo::percentPositivePattern
int32_t ___percentPositivePattern_26;
// System.Int32 System.Globalization.NumberFormatInfo::percentNegativePattern
int32_t ___percentNegativePattern_27;
// System.Int32 System.Globalization.NumberFormatInfo::percentDecimalDigits
int32_t ___percentDecimalDigits_28;
// System.Int32 System.Globalization.NumberFormatInfo::digitSubstitution
int32_t ___digitSubstitution_29;
// System.Boolean System.Globalization.NumberFormatInfo::isReadOnly
bool ___isReadOnly_30;
// System.Boolean System.Globalization.NumberFormatInfo::m_useUserOverride
bool ___m_useUserOverride_31;
// System.Boolean System.Globalization.NumberFormatInfo::m_isInvariant
bool ___m_isInvariant_32;
// System.Boolean System.Globalization.NumberFormatInfo::validForParseAsNumber
bool ___validForParseAsNumber_33;
// System.Boolean System.Globalization.NumberFormatInfo::validForParseAsCurrency
bool ___validForParseAsCurrency_34;
public:
inline static int32_t get_offset_of_numberGroupSizes_1() { return static_cast<int32_t>(offsetof(NumberFormatInfo_tFDF57037EBC5BC833D0A53EF0327B805994860A8, ___numberGroupSizes_1)); }
inline Int32U5BU5D_t2B9E4FDDDB9F0A00EC0AC631BA2DA915EB1ECF83* get_numberGroupSizes_1() const { return ___numberGroupSizes_1; }
inline Int32U5BU5D_t2B9E4FDDDB9F0A00EC0AC631BA2DA915EB1ECF83** get_address_of_numberGroupSizes_1() { return &___numberGroupSizes_1; }
inline void set_numberGroupSizes_1(Int32U5BU5D_t2B9E4FDDDB9F0A00EC0AC631BA2DA915EB1ECF83* value)
{
___numberGroupSizes_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___numberGroupSizes_1), (void*)value);
}
inline static int32_t get_offset_of_currencyGroupSizes_2() { return static_cast<int32_t>(offsetof(NumberFormatInfo_tFDF57037EBC5BC833D0A53EF0327B805994860A8, ___currencyGroupSizes_2)); }
inline Int32U5BU5D_t2B9E4FDDDB9F0A00EC0AC631BA2DA915EB1ECF83* get_currencyGroupSizes_2() const { return ___currencyGroupSizes_2; }
inline Int32U5BU5D_t2B9E4FDDDB9F0A00EC0AC631BA2DA915EB1ECF83** get_address_of_currencyGroupSizes_2() { return &___currencyGroupSizes_2; }
inline void set_currencyGroupSizes_2(Int32U5BU5D_t2B9E4FDDDB9F0A00EC0AC631BA2DA915EB1ECF83* value)
{
___currencyGroupSizes_2 = value;
Il2CppCodeGenWriteBarrier((void**)(&___currencyGroupSizes_2), (void*)value);
}
inline static int32_t get_offset_of_percentGroupSizes_3() { return static_cast<int32_t>(offsetof(NumberFormatInfo_tFDF57037EBC5BC833D0A53EF0327B805994860A8, ___percentGroupSizes_3)); }
inline Int32U5BU5D_t2B9E4FDDDB9F0A00EC0AC631BA2DA915EB1ECF83* get_percentGroupSizes_3() const { return ___percentGroupSizes_3; }
inline Int32U5BU5D_t2B9E4FDDDB9F0A00EC0AC631BA2DA915EB1ECF83** get_address_of_percentGroupSizes_3() { return &___percentGroupSizes_3; }
inline void set_percentGroupSizes_3(Int32U5BU5D_t2B9E4FDDDB9F0A00EC0AC631BA2DA915EB1ECF83* value)
{
___percentGroupSizes_3 = value;
Il2CppCodeGenWriteBarrier((void**)(&___percentGroupSizes_3), (void*)value);
}
inline static int32_t get_offset_of_positiveSign_4() { return static_cast<int32_t>(offsetof(NumberFormatInfo_tFDF57037EBC5BC833D0A53EF0327B805994860A8, ___positiveSign_4)); }
inline String_t* get_positiveSign_4() const { return ___positiveSign_4; }
inline String_t** get_address_of_positiveSign_4() { return &___positiveSign_4; }
inline void set_positiveSign_4(String_t* value)
{
___positiveSign_4 = value;
Il2CppCodeGenWriteBarrier((void**)(&___positiveSign_4), (void*)value);
}
inline static int32_t get_offset_of_negativeSign_5() { return static_cast<int32_t>(offsetof(NumberFormatInfo_tFDF57037EBC5BC833D0A53EF0327B805994860A8, ___negativeSign_5)); }
inline String_t* get_negativeSign_5() const { return ___negativeSign_5; }
inline String_t** get_address_of_negativeSign_5() { return &___negativeSign_5; }
inline void set_negativeSign_5(String_t* value)
{
___negativeSign_5 = value;
Il2CppCodeGenWriteBarrier((void**)(&___negativeSign_5), (void*)value);
}
inline static int32_t get_offset_of_numberDecimalSeparator_6() { return static_cast<int32_t>(offsetof(NumberFormatInfo_tFDF57037EBC5BC833D0A53EF0327B805994860A8, ___numberDecimalSeparator_6)); }
inline String_t* get_numberDecimalSeparator_6() const { return ___numberDecimalSeparator_6; }
inline String_t** get_address_of_numberDecimalSeparator_6() { return &___numberDecimalSeparator_6; }
inline void set_numberDecimalSeparator_6(String_t* value)
{
___numberDecimalSeparator_6 = value;
Il2CppCodeGenWriteBarrier((void**)(&___numberDecimalSeparator_6), (void*)value);
}
inline static int32_t get_offset_of_numberGroupSeparator_7() { return static_cast<int32_t>(offsetof(NumberFormatInfo_tFDF57037EBC5BC833D0A53EF0327B805994860A8, ___numberGroupSeparator_7)); }
inline String_t* get_numberGroupSeparator_7() const { return ___numberGroupSeparator_7; }
inline String_t** get_address_of_numberGroupSeparator_7() { return &___numberGroupSeparator_7; }
inline void set_numberGroupSeparator_7(String_t* value)
{
___numberGroupSeparator_7 = value;
Il2CppCodeGenWriteBarrier((void**)(&___numberGroupSeparator_7), (void*)value);
}
inline static int32_t get_offset_of_currencyGroupSeparator_8() { return static_cast<int32_t>(offsetof(NumberFormatInfo_tFDF57037EBC5BC833D0A53EF0327B805994860A8, ___currencyGroupSeparator_8)); }
inline String_t* get_currencyGroupSeparator_8() const { return ___currencyGroupSeparator_8; }
inline String_t** get_address_of_currencyGroupSeparator_8() { return &___currencyGroupSeparator_8; }
inline void set_currencyGroupSeparator_8(String_t* value)
{
___currencyGroupSeparator_8 = value;
Il2CppCodeGenWriteBarrier((void**)(&___currencyGroupSeparator_8), (void*)value);
}
inline static int32_t get_offset_of_currencyDecimalSeparator_9() { return static_cast<int32_t>(offsetof(NumberFormatInfo_tFDF57037EBC5BC833D0A53EF0327B805994860A8, ___currencyDecimalSeparator_9)); }
inline String_t* get_currencyDecimalSeparator_9() const { return ___currencyDecimalSeparator_9; }
inline String_t** get_address_of_currencyDecimalSeparator_9() { return &___currencyDecimalSeparator_9; }
inline void set_currencyDecimalSeparator_9(String_t* value)
{
___currencyDecimalSeparator_9 = value;
Il2CppCodeGenWriteBarrier((void**)(&___currencyDecimalSeparator_9), (void*)value);
}
inline static int32_t get_offset_of_currencySymbol_10() { return static_cast<int32_t>(offsetof(NumberFormatInfo_tFDF57037EBC5BC833D0A53EF0327B805994860A8, ___currencySymbol_10)); }
inline String_t* get_currencySymbol_10() const { return ___currencySymbol_10; }
inline String_t** get_address_of_currencySymbol_10() { return &___currencySymbol_10; }
inline void set_currencySymbol_10(String_t* value)
{
___currencySymbol_10 = value;
Il2CppCodeGenWriteBarrier((void**)(&___currencySymbol_10), (void*)value);
}
inline static int32_t get_offset_of_ansiCurrencySymbol_11() { return static_cast<int32_t>(offsetof(NumberFormatInfo_tFDF57037EBC5BC833D0A53EF0327B805994860A8, ___ansiCurrencySymbol_11)); }
inline String_t* get_ansiCurrencySymbol_11() const { return ___ansiCurrencySymbol_11; }
inline String_t** get_address_of_ansiCurrencySymbol_11() { return &___ansiCurrencySymbol_11; }
inline void set_ansiCurrencySymbol_11(String_t* value)
{
___ansiCurrencySymbol_11 = value;
Il2CppCodeGenWriteBarrier((void**)(&___ansiCurrencySymbol_11), (void*)value);
}
inline static int32_t get_offset_of_nanSymbol_12() { return static_cast<int32_t>(offsetof(NumberFormatInfo_tFDF57037EBC5BC833D0A53EF0327B805994860A8, ___nanSymbol_12)); }
inline String_t* get_nanSymbol_12() const { return ___nanSymbol_12; }
inline String_t** get_address_of_nanSymbol_12() { return &___nanSymbol_12; }
inline void set_nanSymbol_12(String_t* value)
{
___nanSymbol_12 = value;
Il2CppCodeGenWriteBarrier((void**)(&___nanSymbol_12), (void*)value);
}
inline static int32_t get_offset_of_positiveInfinitySymbol_13() { return static_cast<int32_t>(offsetof(NumberFormatInfo_tFDF57037EBC5BC833D0A53EF0327B805994860A8, ___positiveInfinitySymbol_13)); }
inline String_t* get_positiveInfinitySymbol_13() const { return ___positiveInfinitySymbol_13; }
inline String_t** get_address_of_positiveInfinitySymbol_13() { return &___positiveInfinitySymbol_13; }
inline void set_positiveInfinitySymbol_13(String_t* value)
{
___positiveInfinitySymbol_13 = value;
Il2CppCodeGenWriteBarrier((void**)(&___positiveInfinitySymbol_13), (void*)value);
}
inline static int32_t get_offset_of_negativeInfinitySymbol_14() { return static_cast<int32_t>(offsetof(NumberFormatInfo_tFDF57037EBC5BC833D0A53EF0327B805994860A8, ___negativeInfinitySymbol_14)); }
inline String_t* get_negativeInfinitySymbol_14() const { return ___negativeInfinitySymbol_14; }
inline String_t** get_address_of_negativeInfinitySymbol_14() { return &___negativeInfinitySymbol_14; }
inline void set_negativeInfinitySymbol_14(String_t* value)
{
___negativeInfinitySymbol_14 = value;
Il2CppCodeGenWriteBarrier((void**)(&___negativeInfinitySymbol_14), (void*)value);
}
inline static int32_t get_offset_of_percentDecimalSeparator_15() { return static_cast<int32_t>(offsetof(NumberFormatInfo_tFDF57037EBC5BC833D0A53EF0327B805994860A8, ___percentDecimalSeparator_15)); }
inline String_t* get_percentDecimalSeparator_15() const { return ___percentDecimalSeparator_15; }
inline String_t** get_address_of_percentDecimalSeparator_15() { return &___percentDecimalSeparator_15; }
inline void set_percentDecimalSeparator_15(String_t* value)
{
___percentDecimalSeparator_15 = value;
Il2CppCodeGenWriteBarrier((void**)(&___percentDecimalSeparator_15), (void*)value);
}
inline static int32_t get_offset_of_percentGroupSeparator_16() { return static_cast<int32_t>(offsetof(NumberFormatInfo_tFDF57037EBC5BC833D0A53EF0327B805994860A8, ___percentGroupSeparator_16)); }
inline String_t* get_percentGroupSeparator_16() const { return ___percentGroupSeparator_16; }
inline String_t** get_address_of_percentGroupSeparator_16() { return &___percentGroupSeparator_16; }
inline void set_percentGroupSeparator_16(String_t* value)
{
___percentGroupSeparator_16 = value;
Il2CppCodeGenWriteBarrier((void**)(&___percentGroupSeparator_16), (void*)value);
}
inline static int32_t get_offset_of_percentSymbol_17() { return static_cast<int32_t>(offsetof(NumberFormatInfo_tFDF57037EBC5BC833D0A53EF0327B805994860A8, ___percentSymbol_17)); }
inline String_t* get_percentSymbol_17() const { return ___percentSymbol_17; }
inline String_t** get_address_of_percentSymbol_17() { return &___percentSymbol_17; }
inline void set_percentSymbol_17(String_t* value)
{
___percentSymbol_17 = value;
Il2CppCodeGenWriteBarrier((void**)(&___percentSymbol_17), (void*)value);
}
inline static int32_t get_offset_of_perMilleSymbol_18() { return static_cast<int32_t>(offsetof(NumberFormatInfo_tFDF57037EBC5BC833D0A53EF0327B805994860A8, ___perMilleSymbol_18)); }
inline String_t* get_perMilleSymbol_18() const { return ___perMilleSymbol_18; }
inline String_t** get_address_of_perMilleSymbol_18() { return &___perMilleSymbol_18; }
inline void set_perMilleSymbol_18(String_t* value)
{
___perMilleSymbol_18 = value;
Il2CppCodeGenWriteBarrier((void**)(&___perMilleSymbol_18), (void*)value);
}
inline static int32_t get_offset_of_nativeDigits_19() { return static_cast<int32_t>(offsetof(NumberFormatInfo_tFDF57037EBC5BC833D0A53EF0327B805994860A8, ___nativeDigits_19)); }
inline StringU5BU5D_t933FB07893230EA91C40FF900D5400665E87B14E* get_nativeDigits_19() const { return ___nativeDigits_19; }
inline StringU5BU5D_t933FB07893230EA91C40FF900D5400665E87B14E** get_address_of_nativeDigits_19() { return &___nativeDigits_19; }
inline void set_nativeDigits_19(StringU5BU5D_t933FB07893230EA91C40FF900D5400665E87B14E* value)
{
___nativeDigits_19 = value;
Il2CppCodeGenWriteBarrier((void**)(&___nativeDigits_19), (void*)value);
}
inline static int32_t get_offset_of_m_dataItem_20() { return static_cast<int32_t>(offsetof(NumberFormatInfo_tFDF57037EBC5BC833D0A53EF0327B805994860A8, ___m_dataItem_20)); }
inline int32_t get_m_dataItem_20() const { return ___m_dataItem_20; }
inline int32_t* get_address_of_m_dataItem_20() { return &___m_dataItem_20; }
inline void set_m_dataItem_20(int32_t value)
{
___m_dataItem_20 = value;
}
inline static int32_t get_offset_of_numberDecimalDigits_21() { return static_cast<int32_t>(offsetof(NumberFormatInfo_tFDF57037EBC5BC833D0A53EF0327B805994860A8, ___numberDecimalDigits_21)); }
inline int32_t get_numberDecimalDigits_21() const { return ___numberDecimalDigits_21; }
inline int32_t* get_address_of_numberDecimalDigits_21() { return &___numberDecimalDigits_21; }
inline void set_numberDecimalDigits_21(int32_t value)
{
___numberDecimalDigits_21 = value;
}
inline static int32_t get_offset_of_currencyDecimalDigits_22() { return static_cast<int32_t>(offsetof(NumberFormatInfo_tFDF57037EBC5BC833D0A53EF0327B805994860A8, ___currencyDecimalDigits_22)); }
inline int32_t get_currencyDecimalDigits_22() const { return ___currencyDecimalDigits_22; }
inline int32_t* get_address_of_currencyDecimalDigits_22() { return &___currencyDecimalDigits_22; }
inline void set_currencyDecimalDigits_22(int32_t value)
{
___currencyDecimalDigits_22 = value;
}
inline static int32_t get_offset_of_currencyPositivePattern_23() { return static_cast<int32_t>(offsetof(NumberFormatInfo_tFDF57037EBC5BC833D0A53EF0327B805994860A8, ___currencyPositivePattern_23)); }
inline int32_t get_currencyPositivePattern_23() const { return ___currencyPositivePattern_23; }
inline int32_t* get_address_of_currencyPositivePattern_23() { return &___currencyPositivePattern_23; }
inline void set_currencyPositivePattern_23(int32_t value)
{
___currencyPositivePattern_23 = value;
}
inline static int32_t get_offset_of_currencyNegativePattern_24() { return static_cast<int32_t>(offsetof(NumberFormatInfo_tFDF57037EBC5BC833D0A53EF0327B805994860A8, ___currencyNegativePattern_24)); }
inline int32_t get_currencyNegativePattern_24() const { return ___currencyNegativePattern_24; }
inline int32_t* get_address_of_currencyNegativePattern_24() { return &___currencyNegativePattern_24; }
inline void set_currencyNegativePattern_24(int32_t value)
{
___currencyNegativePattern_24 = value;
}
inline static int32_t get_offset_of_numberNegativePattern_25() { return static_cast<int32_t>(offsetof(NumberFormatInfo_tFDF57037EBC5BC833D0A53EF0327B805994860A8, ___numberNegativePattern_25)); }
inline int32_t get_numberNegativePattern_25() const { return ___numberNegativePattern_25; }
inline int32_t* get_address_of_numberNegativePattern_25() { return &___numberNegativePattern_25; }
inline void set_numberNegativePattern_25(int32_t value)
{
___numberNegativePattern_25 = value;
}
inline static int32_t get_offset_of_percentPositivePattern_26() { return static_cast<int32_t>(offsetof(NumberFormatInfo_tFDF57037EBC5BC833D0A53EF0327B805994860A8, ___percentPositivePattern_26)); }
inline int32_t get_percentPositivePattern_26() const { return ___percentPositivePattern_26; }
inline int32_t* get_address_of_percentPositivePattern_26() { return &___percentPositivePattern_26; }
inline void set_percentPositivePattern_26(int32_t value)
{
___percentPositivePattern_26 = value;
}
inline static int32_t get_offset_of_percentNegativePattern_27() { return static_cast<int32_t>(offsetof(NumberFormatInfo_tFDF57037EBC5BC833D0A53EF0327B805994860A8, ___percentNegativePattern_27)); }
inline int32_t get_percentNegativePattern_27() const { return ___percentNegativePattern_27; }
inline int32_t* get_address_of_percentNegativePattern_27() { return &___percentNegativePattern_27; }
inline void set_percentNegativePattern_27(int32_t value)
{
___percentNegativePattern_27 = value;
}
inline static int32_t get_offset_of_percentDecimalDigits_28() { return static_cast<int32_t>(offsetof(NumberFormatInfo_tFDF57037EBC5BC833D0A53EF0327B805994860A8, ___percentDecimalDigits_28)); }
inline int32_t get_percentDecimalDigits_28() const { return ___percentDecimalDigits_28; }
inline int32_t* get_address_of_percentDecimalDigits_28() { return &___percentDecimalDigits_28; }
inline void set_percentDecimalDigits_28(int32_t value)
{
___percentDecimalDigits_28 = value;
}
inline static int32_t get_offset_of_digitSubstitution_29() { return static_cast<int32_t>(offsetof(NumberFormatInfo_tFDF57037EBC5BC833D0A53EF0327B805994860A8, ___digitSubstitution_29)); }
inline int32_t get_digitSubstitution_29() const { return ___digitSubstitution_29; }
inline int32_t* get_address_of_digitSubstitution_29() { return &___digitSubstitution_29; }
inline void set_digitSubstitution_29(int32_t value)
{
___digitSubstitution_29 = value;
}
inline static int32_t get_offset_of_isReadOnly_30() { return static_cast<int32_t>(offsetof(NumberFormatInfo_tFDF57037EBC5BC833D0A53EF0327B805994860A8, ___isReadOnly_30)); }
inline bool get_isReadOnly_30() const { return ___isReadOnly_30; }
inline bool* get_address_of_isReadOnly_30() { return &___isReadOnly_30; }
inline void set_isReadOnly_30(bool value)
{
___isReadOnly_30 = value;
}
inline static int32_t get_offset_of_m_useUserOverride_31() { return static_cast<int32_t>(offsetof(NumberFormatInfo_tFDF57037EBC5BC833D0A53EF0327B805994860A8, ___m_useUserOverride_31)); }
inline bool get_m_useUserOverride_31() const { return ___m_useUserOverride_31; }
inline bool* get_address_of_m_useUserOverride_31() { return &___m_useUserOverride_31; }
inline void set_m_useUserOverride_31(bool value)
{
___m_useUserOverride_31 = value;
}
inline static int32_t get_offset_of_m_isInvariant_32() { return static_cast<int32_t>(offsetof(NumberFormatInfo_tFDF57037EBC5BC833D0A53EF0327B805994860A8, ___m_isInvariant_32)); }
inline bool get_m_isInvariant_32() const { return ___m_isInvariant_32; }
inline bool* get_address_of_m_isInvariant_32() { return &___m_isInvariant_32; }
inline void set_m_isInvariant_32(bool value)
{
___m_isInvariant_32 = value;
}
inline static int32_t get_offset_of_validForParseAsNumber_33() { return static_cast<int32_t>(offsetof(NumberFormatInfo_tFDF57037EBC5BC833D0A53EF0327B805994860A8, ___validForParseAsNumber_33)); }
inline bool get_validForParseAsNumber_33() const { return ___validForParseAsNumber_33; }
inline bool* get_address_of_validForParseAsNumber_33() { return &___validForParseAsNumber_33; }
inline void set_validForParseAsNumber_33(bool value)
{
___validForParseAsNumber_33 = value;
}
inline static int32_t get_offset_of_validForParseAsCurrency_34() { return static_cast<int32_t>(offsetof(NumberFormatInfo_tFDF57037EBC5BC833D0A53EF0327B805994860A8, ___validForParseAsCurrency_34)); }
inline bool get_validForParseAsCurrency_34() const { return ___validForParseAsCurrency_34; }
inline bool* get_address_of_validForParseAsCurrency_34() { return &___validForParseAsCurrency_34; }
inline void set_validForParseAsCurrency_34(bool value)
{
___validForParseAsCurrency_34 = value;
}
};
struct NumberFormatInfo_tFDF57037EBC5BC833D0A53EF0327B805994860A8_StaticFields
{
public:
// System.Globalization.NumberFormatInfo modreq(System.Runtime.CompilerServices.IsVolatile) System.Globalization.NumberFormatInfo::invariantInfo
NumberFormatInfo_tFDF57037EBC5BC833D0A53EF0327B805994860A8 * ___invariantInfo_0;
public:
inline static int32_t get_offset_of_invariantInfo_0() { return static_cast<int32_t>(offsetof(NumberFormatInfo_tFDF57037EBC5BC833D0A53EF0327B805994860A8_StaticFields, ___invariantInfo_0)); }
inline NumberFormatInfo_tFDF57037EBC5BC833D0A53EF0327B805994860A8 * get_invariantInfo_0() const { return ___invariantInfo_0; }
inline NumberFormatInfo_tFDF57037EBC5BC833D0A53EF0327B805994860A8 ** get_address_of_invariantInfo_0() { return &___invariantInfo_0; }
inline void set_invariantInfo_0(NumberFormatInfo_tFDF57037EBC5BC833D0A53EF0327B805994860A8 * value)
{
___invariantInfo_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___invariantInfo_0), (void*)value);
}
};
// System.IO.FileNotFoundException
struct FileNotFoundException_t0B3F0AE5C94A781A7E2ABBD786F91C229B703431 : public IOException_t60E052020EDE4D3075F57A1DCC224FF8864354BA
{
public:
// System.String System.IO.FileNotFoundException::_fileName
String_t* ____fileName_18;
// System.String System.IO.FileNotFoundException::_fusionLog
String_t* ____fusionLog_19;
public:
inline static int32_t get_offset_of__fileName_18() { return static_cast<int32_t>(offsetof(FileNotFoundException_t0B3F0AE5C94A781A7E2ABBD786F91C229B703431, ____fileName_18)); }
inline String_t* get__fileName_18() const { return ____fileName_18; }
inline String_t** get_address_of__fileName_18() { return &____fileName_18; }
inline void set__fileName_18(String_t* value)
{
____fileName_18 = value;
Il2CppCodeGenWriteBarrier((void**)(&____fileName_18), (void*)value);
}
inline static int32_t get_offset_of__fusionLog_19() { return static_cast<int32_t>(offsetof(FileNotFoundException_t0B3F0AE5C94A781A7E2ABBD786F91C229B703431, ____fusionLog_19)); }
inline String_t* get__fusionLog_19() const { return ____fusionLog_19; }
inline String_t** get_address_of__fusionLog_19() { return &____fusionLog_19; }
inline void set__fusionLog_19(String_t* value)
{
____fusionLog_19 = value;
Il2CppCodeGenWriteBarrier((void**)(&____fusionLog_19), (void*)value);
}
};
// System.MissingMemberException
struct MissingMemberException_t165349A7E04FC51DAA5C2251C6DCDD2DD60255DD : public MemberAccessException_tDA869AFFB4FC1EA0EEF3143D85999710AC4774F0
{
public:
// System.String System.MissingMemberException::ClassName
String_t* ___ClassName_17;
// System.String System.MissingMemberException::MemberName
String_t* ___MemberName_18;
// System.Byte[] System.MissingMemberException::Signature
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* ___Signature_19;
public:
inline static int32_t get_offset_of_ClassName_17() { return static_cast<int32_t>(offsetof(MissingMemberException_t165349A7E04FC51DAA5C2251C6DCDD2DD60255DD, ___ClassName_17)); }
inline String_t* get_ClassName_17() const { return ___ClassName_17; }
inline String_t** get_address_of_ClassName_17() { return &___ClassName_17; }
inline void set_ClassName_17(String_t* value)
{
___ClassName_17 = value;
Il2CppCodeGenWriteBarrier((void**)(&___ClassName_17), (void*)value);
}
inline static int32_t get_offset_of_MemberName_18() { return static_cast<int32_t>(offsetof(MissingMemberException_t165349A7E04FC51DAA5C2251C6DCDD2DD60255DD, ___MemberName_18)); }
inline String_t* get_MemberName_18() const { return ___MemberName_18; }
inline String_t** get_address_of_MemberName_18() { return &___MemberName_18; }
inline void set_MemberName_18(String_t* value)
{
___MemberName_18 = value;
Il2CppCodeGenWriteBarrier((void**)(&___MemberName_18), (void*)value);
}
inline static int32_t get_offset_of_Signature_19() { return static_cast<int32_t>(offsetof(MissingMemberException_t165349A7E04FC51DAA5C2251C6DCDD2DD60255DD, ___Signature_19)); }
inline ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* get_Signature_19() const { return ___Signature_19; }
inline ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821** get_address_of_Signature_19() { return &___Signature_19; }
inline void set_Signature_19(ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* value)
{
___Signature_19 = value;
Il2CppCodeGenWriteBarrier((void**)(&___Signature_19), (void*)value);
}
};
// System.MulticastDelegate
struct MulticastDelegate_t : public Delegate_t
{
public:
// System.Delegate[] System.MulticastDelegate::delegates
DelegateU5BU5D_tDFCDEE2A6322F96C0FE49AF47E9ADB8C4B294E86* ___delegates_11;
public:
inline static int32_t get_offset_of_delegates_11() { return static_cast<int32_t>(offsetof(MulticastDelegate_t, ___delegates_11)); }
inline DelegateU5BU5D_tDFCDEE2A6322F96C0FE49AF47E9ADB8C4B294E86* get_delegates_11() const { return ___delegates_11; }
inline DelegateU5BU5D_tDFCDEE2A6322F96C0FE49AF47E9ADB8C4B294E86** get_address_of_delegates_11() { return &___delegates_11; }
inline void set_delegates_11(DelegateU5BU5D_tDFCDEE2A6322F96C0FE49AF47E9ADB8C4B294E86* value)
{
___delegates_11 = value;
Il2CppCodeGenWriteBarrier((void**)(&___delegates_11), (void*)value);
}
};
// Native definition for P/Invoke marshalling of System.MulticastDelegate
struct MulticastDelegate_t_marshaled_pinvoke : public Delegate_t_marshaled_pinvoke
{
Delegate_t_marshaled_pinvoke** ___delegates_11;
};
// Native definition for COM marshalling of System.MulticastDelegate
struct MulticastDelegate_t_marshaled_com : public Delegate_t_marshaled_com
{
Delegate_t_marshaled_com** ___delegates_11;
};
// System.ObjectDisposedException
struct ObjectDisposedException_tF68E471ECD1419AD7C51137B742837395F50B69A : public InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1
{
public:
// System.String System.ObjectDisposedException::objectName
String_t* ___objectName_17;
public:
inline static int32_t get_offset_of_objectName_17() { return static_cast<int32_t>(offsetof(ObjectDisposedException_tF68E471ECD1419AD7C51137B742837395F50B69A, ___objectName_17)); }
inline String_t* get_objectName_17() const { return ___objectName_17; }
inline String_t** get_address_of_objectName_17() { return &___objectName_17; }
inline void set_objectName_17(String_t* value)
{
___objectName_17 = value;
Il2CppCodeGenWriteBarrier((void**)(&___objectName_17), (void*)value);
}
};
// System.OverflowException
struct OverflowException_tD89571E2350DE06D9DE4AB65ADCA77D607B5693D : public ArithmeticException_tF9EF5FE94597830EF315C5934258F994B8648269
{
public:
public:
};
// System.PlatformNotSupportedException
struct PlatformNotSupportedException_t14FE109377F8FA8B3B2F9A0C4FE3BF10662C73B5 : public NotSupportedException_tE75B318D6590A02A5D9B29FD97409B1750FA0010
{
public:
public:
};
// System.Reflection.AssemblyName
struct AssemblyName_t6F3EC58113268060348EE894DCB46F6EF6BBBB82 : public RuntimeObject
{
public:
// System.String System.Reflection.AssemblyName::name
String_t* ___name_0;
// System.String System.Reflection.AssemblyName::codebase
String_t* ___codebase_1;
// System.Int32 System.Reflection.AssemblyName::major
int32_t ___major_2;
// System.Int32 System.Reflection.AssemblyName::minor
int32_t ___minor_3;
// System.Int32 System.Reflection.AssemblyName::build
int32_t ___build_4;
// System.Int32 System.Reflection.AssemblyName::revision
int32_t ___revision_5;
// System.Globalization.CultureInfo System.Reflection.AssemblyName::cultureinfo
CultureInfo_t345AC6924134F039ED9A11F3E03F8E91B6A3225F * ___cultureinfo_6;
// System.Reflection.AssemblyNameFlags System.Reflection.AssemblyName::flags
int32_t ___flags_7;
// System.Configuration.Assemblies.AssemblyHashAlgorithm System.Reflection.AssemblyName::hashalg
int32_t ___hashalg_8;
// System.Reflection.StrongNameKeyPair System.Reflection.AssemblyName::keypair
StrongNameKeyPair_tD9AA282E59F4526338781AFD862680ED461FCCFD * ___keypair_9;
// System.Byte[] System.Reflection.AssemblyName::publicKey
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* ___publicKey_10;
// System.Byte[] System.Reflection.AssemblyName::keyToken
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* ___keyToken_11;
// System.Configuration.Assemblies.AssemblyVersionCompatibility System.Reflection.AssemblyName::versioncompat
int32_t ___versioncompat_12;
// System.Version System.Reflection.AssemblyName::version
Version_tDBE6876C59B6F56D4F8CAA03851177ABC6FE0DFD * ___version_13;
// System.Reflection.ProcessorArchitecture System.Reflection.AssemblyName::processor_architecture
int32_t ___processor_architecture_14;
// System.Reflection.AssemblyContentType System.Reflection.AssemblyName::contentType
int32_t ___contentType_15;
public:
inline static int32_t get_offset_of_name_0() { return static_cast<int32_t>(offsetof(AssemblyName_t6F3EC58113268060348EE894DCB46F6EF6BBBB82, ___name_0)); }
inline String_t* get_name_0() const { return ___name_0; }
inline String_t** get_address_of_name_0() { return &___name_0; }
inline void set_name_0(String_t* value)
{
___name_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___name_0), (void*)value);
}
inline static int32_t get_offset_of_codebase_1() { return static_cast<int32_t>(offsetof(AssemblyName_t6F3EC58113268060348EE894DCB46F6EF6BBBB82, ___codebase_1)); }
inline String_t* get_codebase_1() const { return ___codebase_1; }
inline String_t** get_address_of_codebase_1() { return &___codebase_1; }
inline void set_codebase_1(String_t* value)
{
___codebase_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___codebase_1), (void*)value);
}
inline static int32_t get_offset_of_major_2() { return static_cast<int32_t>(offsetof(AssemblyName_t6F3EC58113268060348EE894DCB46F6EF6BBBB82, ___major_2)); }
inline int32_t get_major_2() const { return ___major_2; }
inline int32_t* get_address_of_major_2() { return &___major_2; }
inline void set_major_2(int32_t value)
{
___major_2 = value;
}
inline static int32_t get_offset_of_minor_3() { return static_cast<int32_t>(offsetof(AssemblyName_t6F3EC58113268060348EE894DCB46F6EF6BBBB82, ___minor_3)); }
inline int32_t get_minor_3() const { return ___minor_3; }
inline int32_t* get_address_of_minor_3() { return &___minor_3; }
inline void set_minor_3(int32_t value)
{
___minor_3 = value;
}
inline static int32_t get_offset_of_build_4() { return static_cast<int32_t>(offsetof(AssemblyName_t6F3EC58113268060348EE894DCB46F6EF6BBBB82, ___build_4)); }
inline int32_t get_build_4() const { return ___build_4; }
inline int32_t* get_address_of_build_4() { return &___build_4; }
inline void set_build_4(int32_t value)
{
___build_4 = value;
}
inline static int32_t get_offset_of_revision_5() { return static_cast<int32_t>(offsetof(AssemblyName_t6F3EC58113268060348EE894DCB46F6EF6BBBB82, ___revision_5)); }
inline int32_t get_revision_5() const { return ___revision_5; }
inline int32_t* get_address_of_revision_5() { return &___revision_5; }
inline void set_revision_5(int32_t value)
{
___revision_5 = value;
}
inline static int32_t get_offset_of_cultureinfo_6() { return static_cast<int32_t>(offsetof(AssemblyName_t6F3EC58113268060348EE894DCB46F6EF6BBBB82, ___cultureinfo_6)); }
inline CultureInfo_t345AC6924134F039ED9A11F3E03F8E91B6A3225F * get_cultureinfo_6() const { return ___cultureinfo_6; }
inline CultureInfo_t345AC6924134F039ED9A11F3E03F8E91B6A3225F ** get_address_of_cultureinfo_6() { return &___cultureinfo_6; }
inline void set_cultureinfo_6(CultureInfo_t345AC6924134F039ED9A11F3E03F8E91B6A3225F * value)
{
___cultureinfo_6 = value;
Il2CppCodeGenWriteBarrier((void**)(&___cultureinfo_6), (void*)value);
}
inline static int32_t get_offset_of_flags_7() { return static_cast<int32_t>(offsetof(AssemblyName_t6F3EC58113268060348EE894DCB46F6EF6BBBB82, ___flags_7)); }
inline int32_t get_flags_7() const { return ___flags_7; }
inline int32_t* get_address_of_flags_7() { return &___flags_7; }
inline void set_flags_7(int32_t value)
{
___flags_7 = value;
}
inline static int32_t get_offset_of_hashalg_8() { return static_cast<int32_t>(offsetof(AssemblyName_t6F3EC58113268060348EE894DCB46F6EF6BBBB82, ___hashalg_8)); }
inline int32_t get_hashalg_8() const { return ___hashalg_8; }
inline int32_t* get_address_of_hashalg_8() { return &___hashalg_8; }
inline void set_hashalg_8(int32_t value)
{
___hashalg_8 = value;
}
inline static int32_t get_offset_of_keypair_9() { return static_cast<int32_t>(offsetof(AssemblyName_t6F3EC58113268060348EE894DCB46F6EF6BBBB82, ___keypair_9)); }
inline StrongNameKeyPair_tD9AA282E59F4526338781AFD862680ED461FCCFD * get_keypair_9() const { return ___keypair_9; }
inline StrongNameKeyPair_tD9AA282E59F4526338781AFD862680ED461FCCFD ** get_address_of_keypair_9() { return &___keypair_9; }
inline void set_keypair_9(StrongNameKeyPair_tD9AA282E59F4526338781AFD862680ED461FCCFD * value)
{
___keypair_9 = value;
Il2CppCodeGenWriteBarrier((void**)(&___keypair_9), (void*)value);
}
inline static int32_t get_offset_of_publicKey_10() { return static_cast<int32_t>(offsetof(AssemblyName_t6F3EC58113268060348EE894DCB46F6EF6BBBB82, ___publicKey_10)); }
inline ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* get_publicKey_10() const { return ___publicKey_10; }
inline ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821** get_address_of_publicKey_10() { return &___publicKey_10; }
inline void set_publicKey_10(ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* value)
{
___publicKey_10 = value;
Il2CppCodeGenWriteBarrier((void**)(&___publicKey_10), (void*)value);
}
inline static int32_t get_offset_of_keyToken_11() { return static_cast<int32_t>(offsetof(AssemblyName_t6F3EC58113268060348EE894DCB46F6EF6BBBB82, ___keyToken_11)); }
inline ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* get_keyToken_11() const { return ___keyToken_11; }
inline ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821** get_address_of_keyToken_11() { return &___keyToken_11; }
inline void set_keyToken_11(ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* value)
{
___keyToken_11 = value;
Il2CppCodeGenWriteBarrier((void**)(&___keyToken_11), (void*)value);
}
inline static int32_t get_offset_of_versioncompat_12() { return static_cast<int32_t>(offsetof(AssemblyName_t6F3EC58113268060348EE894DCB46F6EF6BBBB82, ___versioncompat_12)); }
inline int32_t get_versioncompat_12() const { return ___versioncompat_12; }
inline int32_t* get_address_of_versioncompat_12() { return &___versioncompat_12; }
inline void set_versioncompat_12(int32_t value)
{
___versioncompat_12 = value;
}
inline static int32_t get_offset_of_version_13() { return static_cast<int32_t>(offsetof(AssemblyName_t6F3EC58113268060348EE894DCB46F6EF6BBBB82, ___version_13)); }
inline Version_tDBE6876C59B6F56D4F8CAA03851177ABC6FE0DFD * get_version_13() const { return ___version_13; }
inline Version_tDBE6876C59B6F56D4F8CAA03851177ABC6FE0DFD ** get_address_of_version_13() { return &___version_13; }
inline void set_version_13(Version_tDBE6876C59B6F56D4F8CAA03851177ABC6FE0DFD * value)
{
___version_13 = value;
Il2CppCodeGenWriteBarrier((void**)(&___version_13), (void*)value);
}
inline static int32_t get_offset_of_processor_architecture_14() { return static_cast<int32_t>(offsetof(AssemblyName_t6F3EC58113268060348EE894DCB46F6EF6BBBB82, ___processor_architecture_14)); }
inline int32_t get_processor_architecture_14() const { return ___processor_architecture_14; }
inline int32_t* get_address_of_processor_architecture_14() { return &___processor_architecture_14; }
inline void set_processor_architecture_14(int32_t value)
{
___processor_architecture_14 = value;
}
inline static int32_t get_offset_of_contentType_15() { return static_cast<int32_t>(offsetof(AssemblyName_t6F3EC58113268060348EE894DCB46F6EF6BBBB82, ___contentType_15)); }
inline int32_t get_contentType_15() const { return ___contentType_15; }
inline int32_t* get_address_of_contentType_15() { return &___contentType_15; }
inline void set_contentType_15(int32_t value)
{
___contentType_15 = value;
}
};
// Native definition for P/Invoke marshalling of System.Reflection.AssemblyName
struct AssemblyName_t6F3EC58113268060348EE894DCB46F6EF6BBBB82_marshaled_pinvoke
{
char* ___name_0;
char* ___codebase_1;
int32_t ___major_2;
int32_t ___minor_3;
int32_t ___build_4;
int32_t ___revision_5;
CultureInfo_t345AC6924134F039ED9A11F3E03F8E91B6A3225F_marshaled_pinvoke* ___cultureinfo_6;
int32_t ___flags_7;
int32_t ___hashalg_8;
StrongNameKeyPair_tD9AA282E59F4526338781AFD862680ED461FCCFD * ___keypair_9;
uint8_t* ___publicKey_10;
uint8_t* ___keyToken_11;
int32_t ___versioncompat_12;
Version_tDBE6876C59B6F56D4F8CAA03851177ABC6FE0DFD * ___version_13;
int32_t ___processor_architecture_14;
int32_t ___contentType_15;
};
// Native definition for COM marshalling of System.Reflection.AssemblyName
struct AssemblyName_t6F3EC58113268060348EE894DCB46F6EF6BBBB82_marshaled_com
{
Il2CppChar* ___name_0;
Il2CppChar* ___codebase_1;
int32_t ___major_2;
int32_t ___minor_3;
int32_t ___build_4;
int32_t ___revision_5;
CultureInfo_t345AC6924134F039ED9A11F3E03F8E91B6A3225F_marshaled_com* ___cultureinfo_6;
int32_t ___flags_7;
int32_t ___hashalg_8;
StrongNameKeyPair_tD9AA282E59F4526338781AFD862680ED461FCCFD * ___keypair_9;
uint8_t* ___publicKey_10;
uint8_t* ___keyToken_11;
int32_t ___versioncompat_12;
Version_tDBE6876C59B6F56D4F8CAA03851177ABC6FE0DFD * ___version_13;
int32_t ___processor_architecture_14;
int32_t ___contentType_15;
};
// System.Reflection.Module
struct Module_t882FB0C491B9CD194BE7CD1AC62FEFB31EEBE5D7 : public RuntimeObject
{
public:
// System.IntPtr System.Reflection.Module::_impl
intptr_t ____impl_2;
// System.Reflection.Assembly System.Reflection.Module::assembly
Assembly_t * ___assembly_3;
// System.String System.Reflection.Module::fqname
String_t* ___fqname_4;
// System.String System.Reflection.Module::name
String_t* ___name_5;
// System.String System.Reflection.Module::scopename
String_t* ___scopename_6;
// System.Boolean System.Reflection.Module::is_resource
bool ___is_resource_7;
// System.Int32 System.Reflection.Module::token
int32_t ___token_8;
public:
inline static int32_t get_offset_of__impl_2() { return static_cast<int32_t>(offsetof(Module_t882FB0C491B9CD194BE7CD1AC62FEFB31EEBE5D7, ____impl_2)); }
inline intptr_t get__impl_2() const { return ____impl_2; }
inline intptr_t* get_address_of__impl_2() { return &____impl_2; }
inline void set__impl_2(intptr_t value)
{
____impl_2 = value;
}
inline static int32_t get_offset_of_assembly_3() { return static_cast<int32_t>(offsetof(Module_t882FB0C491B9CD194BE7CD1AC62FEFB31EEBE5D7, ___assembly_3)); }
inline Assembly_t * get_assembly_3() const { return ___assembly_3; }
inline Assembly_t ** get_address_of_assembly_3() { return &___assembly_3; }
inline void set_assembly_3(Assembly_t * value)
{
___assembly_3 = value;
Il2CppCodeGenWriteBarrier((void**)(&___assembly_3), (void*)value);
}
inline static int32_t get_offset_of_fqname_4() { return static_cast<int32_t>(offsetof(Module_t882FB0C491B9CD194BE7CD1AC62FEFB31EEBE5D7, ___fqname_4)); }
inline String_t* get_fqname_4() const { return ___fqname_4; }
inline String_t** get_address_of_fqname_4() { return &___fqname_4; }
inline void set_fqname_4(String_t* value)
{
___fqname_4 = value;
Il2CppCodeGenWriteBarrier((void**)(&___fqname_4), (void*)value);
}
inline static int32_t get_offset_of_name_5() { return static_cast<int32_t>(offsetof(Module_t882FB0C491B9CD194BE7CD1AC62FEFB31EEBE5D7, ___name_5)); }
inline String_t* get_name_5() const { return ___name_5; }
inline String_t** get_address_of_name_5() { return &___name_5; }
inline void set_name_5(String_t* value)
{
___name_5 = value;
Il2CppCodeGenWriteBarrier((void**)(&___name_5), (void*)value);
}
inline static int32_t get_offset_of_scopename_6() { return static_cast<int32_t>(offsetof(Module_t882FB0C491B9CD194BE7CD1AC62FEFB31EEBE5D7, ___scopename_6)); }
inline String_t* get_scopename_6() const { return ___scopename_6; }
inline String_t** get_address_of_scopename_6() { return &___scopename_6; }
inline void set_scopename_6(String_t* value)
{
___scopename_6 = value;
Il2CppCodeGenWriteBarrier((void**)(&___scopename_6), (void*)value);
}
inline static int32_t get_offset_of_is_resource_7() { return static_cast<int32_t>(offsetof(Module_t882FB0C491B9CD194BE7CD1AC62FEFB31EEBE5D7, ___is_resource_7)); }
inline bool get_is_resource_7() const { return ___is_resource_7; }
inline bool* get_address_of_is_resource_7() { return &___is_resource_7; }
inline void set_is_resource_7(bool value)
{
___is_resource_7 = value;
}
inline static int32_t get_offset_of_token_8() { return static_cast<int32_t>(offsetof(Module_t882FB0C491B9CD194BE7CD1AC62FEFB31EEBE5D7, ___token_8)); }
inline int32_t get_token_8() const { return ___token_8; }
inline int32_t* get_address_of_token_8() { return &___token_8; }
inline void set_token_8(int32_t value)
{
___token_8 = value;
}
};
struct Module_t882FB0C491B9CD194BE7CD1AC62FEFB31EEBE5D7_StaticFields
{
public:
// System.Reflection.TypeFilter System.Reflection.Module::FilterTypeName
TypeFilter_t30BB04A68BC9FB949345457F71A9648BDB67FF18 * ___FilterTypeName_0;
// System.Reflection.TypeFilter System.Reflection.Module::FilterTypeNameIgnoreCase
TypeFilter_t30BB04A68BC9FB949345457F71A9648BDB67FF18 * ___FilterTypeNameIgnoreCase_1;
public:
inline static int32_t get_offset_of_FilterTypeName_0() { return static_cast<int32_t>(offsetof(Module_t882FB0C491B9CD194BE7CD1AC62FEFB31EEBE5D7_StaticFields, ___FilterTypeName_0)); }
inline TypeFilter_t30BB04A68BC9FB949345457F71A9648BDB67FF18 * get_FilterTypeName_0() const { return ___FilterTypeName_0; }
inline TypeFilter_t30BB04A68BC9FB949345457F71A9648BDB67FF18 ** get_address_of_FilterTypeName_0() { return &___FilterTypeName_0; }
inline void set_FilterTypeName_0(TypeFilter_t30BB04A68BC9FB949345457F71A9648BDB67FF18 * value)
{
___FilterTypeName_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___FilterTypeName_0), (void*)value);
}
inline static int32_t get_offset_of_FilterTypeNameIgnoreCase_1() { return static_cast<int32_t>(offsetof(Module_t882FB0C491B9CD194BE7CD1AC62FEFB31EEBE5D7_StaticFields, ___FilterTypeNameIgnoreCase_1)); }
inline TypeFilter_t30BB04A68BC9FB949345457F71A9648BDB67FF18 * get_FilterTypeNameIgnoreCase_1() const { return ___FilterTypeNameIgnoreCase_1; }
inline TypeFilter_t30BB04A68BC9FB949345457F71A9648BDB67FF18 ** get_address_of_FilterTypeNameIgnoreCase_1() { return &___FilterTypeNameIgnoreCase_1; }
inline void set_FilterTypeNameIgnoreCase_1(TypeFilter_t30BB04A68BC9FB949345457F71A9648BDB67FF18 * value)
{
___FilterTypeNameIgnoreCase_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___FilterTypeNameIgnoreCase_1), (void*)value);
}
};
// Native definition for P/Invoke marshalling of System.Reflection.Module
struct Module_t882FB0C491B9CD194BE7CD1AC62FEFB31EEBE5D7_marshaled_pinvoke
{
intptr_t ____impl_2;
Assembly_t_marshaled_pinvoke* ___assembly_3;
char* ___fqname_4;
char* ___name_5;
char* ___scopename_6;
int32_t ___is_resource_7;
int32_t ___token_8;
};
// Native definition for COM marshalling of System.Reflection.Module
struct Module_t882FB0C491B9CD194BE7CD1AC62FEFB31EEBE5D7_marshaled_com
{
intptr_t ____impl_2;
Assembly_t_marshaled_com* ___assembly_3;
Il2CppChar* ___fqname_4;
Il2CppChar* ___name_5;
Il2CppChar* ___scopename_6;
int32_t ___is_resource_7;
int32_t ___token_8;
};
// System.Reflection.RuntimeAssembly
struct RuntimeAssembly_t5EE9CD749D82345AE5635B9665665C31A3308EB1 : public Assembly_t
{
public:
public:
};
// System.Runtime.Serialization.StreamingContext
struct StreamingContext_t2CCDC54E0E8D078AF4A50E3A8B921B828A900034
{
public:
// System.Object System.Runtime.Serialization.StreamingContext::m_additionalContext
RuntimeObject * ___m_additionalContext_0;
// System.Runtime.Serialization.StreamingContextStates System.Runtime.Serialization.StreamingContext::m_state
int32_t ___m_state_1;
public:
inline static int32_t get_offset_of_m_additionalContext_0() { return static_cast<int32_t>(offsetof(StreamingContext_t2CCDC54E0E8D078AF4A50E3A8B921B828A900034, ___m_additionalContext_0)); }
inline RuntimeObject * get_m_additionalContext_0() const { return ___m_additionalContext_0; }
inline RuntimeObject ** get_address_of_m_additionalContext_0() { return &___m_additionalContext_0; }
inline void set_m_additionalContext_0(RuntimeObject * value)
{
___m_additionalContext_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_additionalContext_0), (void*)value);
}
inline static int32_t get_offset_of_m_state_1() { return static_cast<int32_t>(offsetof(StreamingContext_t2CCDC54E0E8D078AF4A50E3A8B921B828A900034, ___m_state_1)); }
inline int32_t get_m_state_1() const { return ___m_state_1; }
inline int32_t* get_address_of_m_state_1() { return &___m_state_1; }
inline void set_m_state_1(int32_t value)
{
___m_state_1 = value;
}
};
// Native definition for P/Invoke marshalling of System.Runtime.Serialization.StreamingContext
struct StreamingContext_t2CCDC54E0E8D078AF4A50E3A8B921B828A900034_marshaled_pinvoke
{
Il2CppIUnknown* ___m_additionalContext_0;
int32_t ___m_state_1;
};
// Native definition for COM marshalling of System.Runtime.Serialization.StreamingContext
struct StreamingContext_t2CCDC54E0E8D078AF4A50E3A8B921B828A900034_marshaled_com
{
Il2CppIUnknown* ___m_additionalContext_0;
int32_t ___m_state_1;
};
// System.Type
struct Type_t : public MemberInfo_t
{
public:
// System.RuntimeTypeHandle System.Type::_impl
RuntimeTypeHandle_t7B542280A22F0EC4EAC2061C29178845847A8B2D ____impl_9;
public:
inline static int32_t get_offset_of__impl_9() { return static_cast<int32_t>(offsetof(Type_t, ____impl_9)); }
inline RuntimeTypeHandle_t7B542280A22F0EC4EAC2061C29178845847A8B2D get__impl_9() const { return ____impl_9; }
inline RuntimeTypeHandle_t7B542280A22F0EC4EAC2061C29178845847A8B2D * get_address_of__impl_9() { return &____impl_9; }
inline void set__impl_9(RuntimeTypeHandle_t7B542280A22F0EC4EAC2061C29178845847A8B2D value)
{
____impl_9 = value;
}
};
struct Type_t_StaticFields
{
public:
// System.Reflection.MemberFilter System.Type::FilterAttribute
MemberFilter_t25C1BD92C42BE94426E300787C13C452CB89B381 * ___FilterAttribute_0;
// System.Reflection.MemberFilter System.Type::FilterName
MemberFilter_t25C1BD92C42BE94426E300787C13C452CB89B381 * ___FilterName_1;
// System.Reflection.MemberFilter System.Type::FilterNameIgnoreCase
MemberFilter_t25C1BD92C42BE94426E300787C13C452CB89B381 * ___FilterNameIgnoreCase_2;
// System.Object System.Type::Missing
RuntimeObject * ___Missing_3;
// System.Char System.Type::Delimiter
Il2CppChar ___Delimiter_4;
// System.Type[] System.Type::EmptyTypes
TypeU5BU5D_t7FE623A666B49176DE123306221193E888A12F5F* ___EmptyTypes_5;
// System.Reflection.Binder System.Type::defaultBinder
Binder_t4D5CB06963501D32847C057B57157D6DC49CA759 * ___defaultBinder_6;
public:
inline static int32_t get_offset_of_FilterAttribute_0() { return static_cast<int32_t>(offsetof(Type_t_StaticFields, ___FilterAttribute_0)); }
inline MemberFilter_t25C1BD92C42BE94426E300787C13C452CB89B381 * get_FilterAttribute_0() const { return ___FilterAttribute_0; }
inline MemberFilter_t25C1BD92C42BE94426E300787C13C452CB89B381 ** get_address_of_FilterAttribute_0() { return &___FilterAttribute_0; }
inline void set_FilterAttribute_0(MemberFilter_t25C1BD92C42BE94426E300787C13C452CB89B381 * value)
{
___FilterAttribute_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___FilterAttribute_0), (void*)value);
}
inline static int32_t get_offset_of_FilterName_1() { return static_cast<int32_t>(offsetof(Type_t_StaticFields, ___FilterName_1)); }
inline MemberFilter_t25C1BD92C42BE94426E300787C13C452CB89B381 * get_FilterName_1() const { return ___FilterName_1; }
inline MemberFilter_t25C1BD92C42BE94426E300787C13C452CB89B381 ** get_address_of_FilterName_1() { return &___FilterName_1; }
inline void set_FilterName_1(MemberFilter_t25C1BD92C42BE94426E300787C13C452CB89B381 * value)
{
___FilterName_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___FilterName_1), (void*)value);
}
inline static int32_t get_offset_of_FilterNameIgnoreCase_2() { return static_cast<int32_t>(offsetof(Type_t_StaticFields, ___FilterNameIgnoreCase_2)); }
inline MemberFilter_t25C1BD92C42BE94426E300787C13C452CB89B381 * get_FilterNameIgnoreCase_2() const { return ___FilterNameIgnoreCase_2; }
inline MemberFilter_t25C1BD92C42BE94426E300787C13C452CB89B381 ** get_address_of_FilterNameIgnoreCase_2() { return &___FilterNameIgnoreCase_2; }
inline void set_FilterNameIgnoreCase_2(MemberFilter_t25C1BD92C42BE94426E300787C13C452CB89B381 * value)
{
___FilterNameIgnoreCase_2 = value;
Il2CppCodeGenWriteBarrier((void**)(&___FilterNameIgnoreCase_2), (void*)value);
}
inline static int32_t get_offset_of_Missing_3() { return static_cast<int32_t>(offsetof(Type_t_StaticFields, ___Missing_3)); }
inline RuntimeObject * get_Missing_3() const { return ___Missing_3; }
inline RuntimeObject ** get_address_of_Missing_3() { return &___Missing_3; }
inline void set_Missing_3(RuntimeObject * value)
{
___Missing_3 = value;
Il2CppCodeGenWriteBarrier((void**)(&___Missing_3), (void*)value);
}
inline static int32_t get_offset_of_Delimiter_4() { return static_cast<int32_t>(offsetof(Type_t_StaticFields, ___Delimiter_4)); }
inline Il2CppChar get_Delimiter_4() const { return ___Delimiter_4; }
inline Il2CppChar* get_address_of_Delimiter_4() { return &___Delimiter_4; }
inline void set_Delimiter_4(Il2CppChar value)
{
___Delimiter_4 = value;
}
inline static int32_t get_offset_of_EmptyTypes_5() { return static_cast<int32_t>(offsetof(Type_t_StaticFields, ___EmptyTypes_5)); }
inline TypeU5BU5D_t7FE623A666B49176DE123306221193E888A12F5F* get_EmptyTypes_5() const { return ___EmptyTypes_5; }
inline TypeU5BU5D_t7FE623A666B49176DE123306221193E888A12F5F** get_address_of_EmptyTypes_5() { return &___EmptyTypes_5; }
inline void set_EmptyTypes_5(TypeU5BU5D_t7FE623A666B49176DE123306221193E888A12F5F* value)
{
___EmptyTypes_5 = value;
Il2CppCodeGenWriteBarrier((void**)(&___EmptyTypes_5), (void*)value);
}
inline static int32_t get_offset_of_defaultBinder_6() { return static_cast<int32_t>(offsetof(Type_t_StaticFields, ___defaultBinder_6)); }
inline Binder_t4D5CB06963501D32847C057B57157D6DC49CA759 * get_defaultBinder_6() const { return ___defaultBinder_6; }
inline Binder_t4D5CB06963501D32847C057B57157D6DC49CA759 ** get_address_of_defaultBinder_6() { return &___defaultBinder_6; }
inline void set_defaultBinder_6(Binder_t4D5CB06963501D32847C057B57157D6DC49CA759 * value)
{
___defaultBinder_6 = value;
Il2CppCodeGenWriteBarrier((void**)(&___defaultBinder_6), (void*)value);
}
};
// System.TypedReference
struct TypedReference_t118BC3B643F75F52DB9C99D5E051299F886EB2A8
{
public:
// System.RuntimeTypeHandle System.TypedReference::type
RuntimeTypeHandle_t7B542280A22F0EC4EAC2061C29178845847A8B2D ___type_0;
// System.IntPtr System.TypedReference::Value
intptr_t ___Value_1;
// System.IntPtr System.TypedReference::Type
intptr_t ___Type_2;
public:
inline static int32_t get_offset_of_type_0() { return static_cast<int32_t>(offsetof(TypedReference_t118BC3B643F75F52DB9C99D5E051299F886EB2A8, ___type_0)); }
inline RuntimeTypeHandle_t7B542280A22F0EC4EAC2061C29178845847A8B2D get_type_0() const { return ___type_0; }
inline RuntimeTypeHandle_t7B542280A22F0EC4EAC2061C29178845847A8B2D * get_address_of_type_0() { return &___type_0; }
inline void set_type_0(RuntimeTypeHandle_t7B542280A22F0EC4EAC2061C29178845847A8B2D value)
{
___type_0 = value;
}
inline static int32_t get_offset_of_Value_1() { return static_cast<int32_t>(offsetof(TypedReference_t118BC3B643F75F52DB9C99D5E051299F886EB2A8, ___Value_1)); }
inline intptr_t get_Value_1() const { return ___Value_1; }
inline intptr_t* get_address_of_Value_1() { return &___Value_1; }
inline void set_Value_1(intptr_t value)
{
___Value_1 = value;
}
inline static int32_t get_offset_of_Type_2() { return static_cast<int32_t>(offsetof(TypedReference_t118BC3B643F75F52DB9C99D5E051299F886EB2A8, ___Type_2)); }
inline intptr_t get_Type_2() const { return ___Type_2; }
inline intptr_t* get_address_of_Type_2() { return &___Type_2; }
inline void set_Type_2(intptr_t value)
{
___Type_2 = value;
}
};
// System.Variant
struct Variant_tBC94A369178CDE161E918F24FD18166A3DC58C18
{
public:
union
{
#pragma pack(push, tp, 1)
struct
{
// System.Int16 System.Variant::vt
int16_t ___vt_0;
};
#pragma pack(pop, tp)
struct
{
int16_t ___vt_0_forAlignmentOnly;
};
#pragma pack(push, tp, 1)
struct
{
char ___wReserved1_1_OffsetPadding[2];
// System.UInt16 System.Variant::wReserved1
uint16_t ___wReserved1_1;
};
#pragma pack(pop, tp)
struct
{
char ___wReserved1_1_OffsetPadding_forAlignmentOnly[2];
uint16_t ___wReserved1_1_forAlignmentOnly;
};
#pragma pack(push, tp, 1)
struct
{
char ___wReserved2_2_OffsetPadding[4];
// System.UInt16 System.Variant::wReserved2
uint16_t ___wReserved2_2;
};
#pragma pack(pop, tp)
struct
{
char ___wReserved2_2_OffsetPadding_forAlignmentOnly[4];
uint16_t ___wReserved2_2_forAlignmentOnly;
};
#pragma pack(push, tp, 1)
struct
{
char ___wReserved3_3_OffsetPadding[6];
// System.UInt16 System.Variant::wReserved3
uint16_t ___wReserved3_3;
};
#pragma pack(pop, tp)
struct
{
char ___wReserved3_3_OffsetPadding_forAlignmentOnly[6];
uint16_t ___wReserved3_3_forAlignmentOnly;
};
#pragma pack(push, tp, 1)
struct
{
char ___llVal_4_OffsetPadding[8];
// System.Int64 System.Variant::llVal
int64_t ___llVal_4;
};
#pragma pack(pop, tp)
struct
{
char ___llVal_4_OffsetPadding_forAlignmentOnly[8];
int64_t ___llVal_4_forAlignmentOnly;
};
#pragma pack(push, tp, 1)
struct
{
char ___lVal_5_OffsetPadding[8];
// System.Int32 System.Variant::lVal
int32_t ___lVal_5;
};
#pragma pack(pop, tp)
struct
{
char ___lVal_5_OffsetPadding_forAlignmentOnly[8];
int32_t ___lVal_5_forAlignmentOnly;
};
#pragma pack(push, tp, 1)
struct
{
char ___bVal_6_OffsetPadding[8];
// System.Byte System.Variant::bVal
uint8_t ___bVal_6;
};
#pragma pack(pop, tp)
struct
{
char ___bVal_6_OffsetPadding_forAlignmentOnly[8];
uint8_t ___bVal_6_forAlignmentOnly;
};
#pragma pack(push, tp, 1)
struct
{
char ___iVal_7_OffsetPadding[8];
// System.Int16 System.Variant::iVal
int16_t ___iVal_7;
};
#pragma pack(pop, tp)
struct
{
char ___iVal_7_OffsetPadding_forAlignmentOnly[8];
int16_t ___iVal_7_forAlignmentOnly;
};
#pragma pack(push, tp, 1)
struct
{
char ___fltVal_8_OffsetPadding[8];
// System.Single System.Variant::fltVal
float ___fltVal_8;
};
#pragma pack(pop, tp)
struct
{
char ___fltVal_8_OffsetPadding_forAlignmentOnly[8];
float ___fltVal_8_forAlignmentOnly;
};
#pragma pack(push, tp, 1)
struct
{
char ___dblVal_9_OffsetPadding[8];
// System.Double System.Variant::dblVal
double ___dblVal_9;
};
#pragma pack(pop, tp)
struct
{
char ___dblVal_9_OffsetPadding_forAlignmentOnly[8];
double ___dblVal_9_forAlignmentOnly;
};
#pragma pack(push, tp, 1)
struct
{
char ___boolVal_10_OffsetPadding[8];
// System.Int16 System.Variant::boolVal
int16_t ___boolVal_10;
};
#pragma pack(pop, tp)
struct
{
char ___boolVal_10_OffsetPadding_forAlignmentOnly[8];
int16_t ___boolVal_10_forAlignmentOnly;
};
#pragma pack(push, tp, 1)
struct
{
char ___bstrVal_11_OffsetPadding[8];
// System.IntPtr System.Variant::bstrVal
intptr_t ___bstrVal_11;
};
#pragma pack(pop, tp)
struct
{
char ___bstrVal_11_OffsetPadding_forAlignmentOnly[8];
intptr_t ___bstrVal_11_forAlignmentOnly;
};
#pragma pack(push, tp, 1)
struct
{
char ___cVal_12_OffsetPadding[8];
// System.SByte System.Variant::cVal
int8_t ___cVal_12;
};
#pragma pack(pop, tp)
struct
{
char ___cVal_12_OffsetPadding_forAlignmentOnly[8];
int8_t ___cVal_12_forAlignmentOnly;
};
#pragma pack(push, tp, 1)
struct
{
char ___uiVal_13_OffsetPadding[8];
// System.UInt16 System.Variant::uiVal
uint16_t ___uiVal_13;
};
#pragma pack(pop, tp)
struct
{
char ___uiVal_13_OffsetPadding_forAlignmentOnly[8];
uint16_t ___uiVal_13_forAlignmentOnly;
};
#pragma pack(push, tp, 1)
struct
{
char ___ulVal_14_OffsetPadding[8];
// System.UInt32 System.Variant::ulVal
uint32_t ___ulVal_14;
};
#pragma pack(pop, tp)
struct
{
char ___ulVal_14_OffsetPadding_forAlignmentOnly[8];
uint32_t ___ulVal_14_forAlignmentOnly;
};
#pragma pack(push, tp, 1)
struct
{
char ___ullVal_15_OffsetPadding[8];
// System.UInt64 System.Variant::ullVal
uint64_t ___ullVal_15;
};
#pragma pack(pop, tp)
struct
{
char ___ullVal_15_OffsetPadding_forAlignmentOnly[8];
uint64_t ___ullVal_15_forAlignmentOnly;
};
#pragma pack(push, tp, 1)
struct
{
char ___intVal_16_OffsetPadding[8];
// System.Int32 System.Variant::intVal
int32_t ___intVal_16;
};
#pragma pack(pop, tp)
struct
{
char ___intVal_16_OffsetPadding_forAlignmentOnly[8];
int32_t ___intVal_16_forAlignmentOnly;
};
#pragma pack(push, tp, 1)
struct
{
char ___uintVal_17_OffsetPadding[8];
// System.UInt32 System.Variant::uintVal
uint32_t ___uintVal_17;
};
#pragma pack(pop, tp)
struct
{
char ___uintVal_17_OffsetPadding_forAlignmentOnly[8];
uint32_t ___uintVal_17_forAlignmentOnly;
};
#pragma pack(push, tp, 1)
struct
{
char ___pdispVal_18_OffsetPadding[8];
// System.IntPtr System.Variant::pdispVal
intptr_t ___pdispVal_18;
};
#pragma pack(pop, tp)
struct
{
char ___pdispVal_18_OffsetPadding_forAlignmentOnly[8];
intptr_t ___pdispVal_18_forAlignmentOnly;
};
#pragma pack(push, tp, 1)
struct
{
char ___bRecord_19_OffsetPadding[8];
// System.BRECORD System.Variant::bRecord
BRECORD_tDDC5F1A5DC569C234C6141FCBA5F8DE8293BC601 ___bRecord_19;
};
#pragma pack(pop, tp)
struct
{
char ___bRecord_19_OffsetPadding_forAlignmentOnly[8];
BRECORD_tDDC5F1A5DC569C234C6141FCBA5F8DE8293BC601 ___bRecord_19_forAlignmentOnly;
};
};
public:
inline static int32_t get_offset_of_vt_0() { return static_cast<int32_t>(offsetof(Variant_tBC94A369178CDE161E918F24FD18166A3DC58C18, ___vt_0)); }
inline int16_t get_vt_0() const { return ___vt_0; }
inline int16_t* get_address_of_vt_0() { return &___vt_0; }
inline void set_vt_0(int16_t value)
{
___vt_0 = value;
}
inline static int32_t get_offset_of_wReserved1_1() { return static_cast<int32_t>(offsetof(Variant_tBC94A369178CDE161E918F24FD18166A3DC58C18, ___wReserved1_1)); }
inline uint16_t get_wReserved1_1() const { return ___wReserved1_1; }
inline uint16_t* get_address_of_wReserved1_1() { return &___wReserved1_1; }
inline void set_wReserved1_1(uint16_t value)
{
___wReserved1_1 = value;
}
inline static int32_t get_offset_of_wReserved2_2() { return static_cast<int32_t>(offsetof(Variant_tBC94A369178CDE161E918F24FD18166A3DC58C18, ___wReserved2_2)); }
inline uint16_t get_wReserved2_2() const { return ___wReserved2_2; }
inline uint16_t* get_address_of_wReserved2_2() { return &___wReserved2_2; }
inline void set_wReserved2_2(uint16_t value)
{
___wReserved2_2 = value;
}
inline static int32_t get_offset_of_wReserved3_3() { return static_cast<int32_t>(offsetof(Variant_tBC94A369178CDE161E918F24FD18166A3DC58C18, ___wReserved3_3)); }
inline uint16_t get_wReserved3_3() const { return ___wReserved3_3; }
inline uint16_t* get_address_of_wReserved3_3() { return &___wReserved3_3; }
inline void set_wReserved3_3(uint16_t value)
{
___wReserved3_3 = value;
}
inline static int32_t get_offset_of_llVal_4() { return static_cast<int32_t>(offsetof(Variant_tBC94A369178CDE161E918F24FD18166A3DC58C18, ___llVal_4)); }
inline int64_t get_llVal_4() const { return ___llVal_4; }
inline int64_t* get_address_of_llVal_4() { return &___llVal_4; }
inline void set_llVal_4(int64_t value)
{
___llVal_4 = value;
}
inline static int32_t get_offset_of_lVal_5() { return static_cast<int32_t>(offsetof(Variant_tBC94A369178CDE161E918F24FD18166A3DC58C18, ___lVal_5)); }
inline int32_t get_lVal_5() const { return ___lVal_5; }
inline int32_t* get_address_of_lVal_5() { return &___lVal_5; }
inline void set_lVal_5(int32_t value)
{
___lVal_5 = value;
}
inline static int32_t get_offset_of_bVal_6() { return static_cast<int32_t>(offsetof(Variant_tBC94A369178CDE161E918F24FD18166A3DC58C18, ___bVal_6)); }
inline uint8_t get_bVal_6() const { return ___bVal_6; }
inline uint8_t* get_address_of_bVal_6() { return &___bVal_6; }
inline void set_bVal_6(uint8_t value)
{
___bVal_6 = value;
}
inline static int32_t get_offset_of_iVal_7() { return static_cast<int32_t>(offsetof(Variant_tBC94A369178CDE161E918F24FD18166A3DC58C18, ___iVal_7)); }
inline int16_t get_iVal_7() const { return ___iVal_7; }
inline int16_t* get_address_of_iVal_7() { return &___iVal_7; }
inline void set_iVal_7(int16_t value)
{
___iVal_7 = value;
}
inline static int32_t get_offset_of_fltVal_8() { return static_cast<int32_t>(offsetof(Variant_tBC94A369178CDE161E918F24FD18166A3DC58C18, ___fltVal_8)); }
inline float get_fltVal_8() const { return ___fltVal_8; }
inline float* get_address_of_fltVal_8() { return &___fltVal_8; }
inline void set_fltVal_8(float value)
{
___fltVal_8 = value;
}
inline static int32_t get_offset_of_dblVal_9() { return static_cast<int32_t>(offsetof(Variant_tBC94A369178CDE161E918F24FD18166A3DC58C18, ___dblVal_9)); }
inline double get_dblVal_9() const { return ___dblVal_9; }
inline double* get_address_of_dblVal_9() { return &___dblVal_9; }
inline void set_dblVal_9(double value)
{
___dblVal_9 = value;
}
inline static int32_t get_offset_of_boolVal_10() { return static_cast<int32_t>(offsetof(Variant_tBC94A369178CDE161E918F24FD18166A3DC58C18, ___boolVal_10)); }
inline int16_t get_boolVal_10() const { return ___boolVal_10; }
inline int16_t* get_address_of_boolVal_10() { return &___boolVal_10; }
inline void set_boolVal_10(int16_t value)
{
___boolVal_10 = value;
}
inline static int32_t get_offset_of_bstrVal_11() { return static_cast<int32_t>(offsetof(Variant_tBC94A369178CDE161E918F24FD18166A3DC58C18, ___bstrVal_11)); }
inline intptr_t get_bstrVal_11() const { return ___bstrVal_11; }
inline intptr_t* get_address_of_bstrVal_11() { return &___bstrVal_11; }
inline void set_bstrVal_11(intptr_t value)
{
___bstrVal_11 = value;
}
inline static int32_t get_offset_of_cVal_12() { return static_cast<int32_t>(offsetof(Variant_tBC94A369178CDE161E918F24FD18166A3DC58C18, ___cVal_12)); }
inline int8_t get_cVal_12() const { return ___cVal_12; }
inline int8_t* get_address_of_cVal_12() { return &___cVal_12; }
inline void set_cVal_12(int8_t value)
{
___cVal_12 = value;
}
inline static int32_t get_offset_of_uiVal_13() { return static_cast<int32_t>(offsetof(Variant_tBC94A369178CDE161E918F24FD18166A3DC58C18, ___uiVal_13)); }
inline uint16_t get_uiVal_13() const { return ___uiVal_13; }
inline uint16_t* get_address_of_uiVal_13() { return &___uiVal_13; }
inline void set_uiVal_13(uint16_t value)
{
___uiVal_13 = value;
}
inline static int32_t get_offset_of_ulVal_14() { return static_cast<int32_t>(offsetof(Variant_tBC94A369178CDE161E918F24FD18166A3DC58C18, ___ulVal_14)); }
inline uint32_t get_ulVal_14() const { return ___ulVal_14; }
inline uint32_t* get_address_of_ulVal_14() { return &___ulVal_14; }
inline void set_ulVal_14(uint32_t value)
{
___ulVal_14 = value;
}
inline static int32_t get_offset_of_ullVal_15() { return static_cast<int32_t>(offsetof(Variant_tBC94A369178CDE161E918F24FD18166A3DC58C18, ___ullVal_15)); }
inline uint64_t get_ullVal_15() const { return ___ullVal_15; }
inline uint64_t* get_address_of_ullVal_15() { return &___ullVal_15; }
inline void set_ullVal_15(uint64_t value)
{
___ullVal_15 = value;
}
inline static int32_t get_offset_of_intVal_16() { return static_cast<int32_t>(offsetof(Variant_tBC94A369178CDE161E918F24FD18166A3DC58C18, ___intVal_16)); }
inline int32_t get_intVal_16() const { return ___intVal_16; }
inline int32_t* get_address_of_intVal_16() { return &___intVal_16; }
inline void set_intVal_16(int32_t value)
{
___intVal_16 = value;
}
inline static int32_t get_offset_of_uintVal_17() { return static_cast<int32_t>(offsetof(Variant_tBC94A369178CDE161E918F24FD18166A3DC58C18, ___uintVal_17)); }
inline uint32_t get_uintVal_17() const { return ___uintVal_17; }
inline uint32_t* get_address_of_uintVal_17() { return &___uintVal_17; }
inline void set_uintVal_17(uint32_t value)
{
___uintVal_17 = value;
}
inline static int32_t get_offset_of_pdispVal_18() { return static_cast<int32_t>(offsetof(Variant_tBC94A369178CDE161E918F24FD18166A3DC58C18, ___pdispVal_18)); }
inline intptr_t get_pdispVal_18() const { return ___pdispVal_18; }
inline intptr_t* get_address_of_pdispVal_18() { return &___pdispVal_18; }
inline void set_pdispVal_18(intptr_t value)
{
___pdispVal_18 = value;
}
inline static int32_t get_offset_of_bRecord_19() { return static_cast<int32_t>(offsetof(Variant_tBC94A369178CDE161E918F24FD18166A3DC58C18, ___bRecord_19)); }
inline BRECORD_tDDC5F1A5DC569C234C6141FCBA5F8DE8293BC601 get_bRecord_19() const { return ___bRecord_19; }
inline BRECORD_tDDC5F1A5DC569C234C6141FCBA5F8DE8293BC601 * get_address_of_bRecord_19() { return &___bRecord_19; }
inline void set_bRecord_19(BRECORD_tDDC5F1A5DC569C234C6141FCBA5F8DE8293BC601 value)
{
___bRecord_19 = value;
}
};
// System.AsyncCallback
struct AsyncCallback_t3F3DA3BEDAEE81DD1D24125DF8EB30E85EE14DA4 : public MulticastDelegate_t
{
public:
public:
};
// System.Func`2<System.Reflection.AssemblyName,System.Reflection.Assembly>
struct Func_2_t13827C9725E0D12567E029E178981FB7D0E13430 : public MulticastDelegate_t
{
public:
public:
};
// System.Func`4<System.Reflection.Assembly,System.String,System.Boolean,System.Type>
struct Func_4_t3D7857A2A0F731D1E992FC5B09E983A8621FABFF : public MulticastDelegate_t
{
public:
public:
};
// System.Reflection.TypeInfo
struct TypeInfo_t9D6F65801A41B97F36138B15FD270A1550DBB3FC : public Type_t
{
public:
public:
};
// System.UnhandledExceptionEventHandler
struct UnhandledExceptionEventHandler_tB0DFF05ABF7A3A234C87D4F7A71F98E9AB2D91DE : public MulticastDelegate_t
{
public:
public:
};
// Unity.ThrowStub
struct ThrowStub_tFA0E21DBAA52F61535595DCC8B44B0CD087A0406 : public ObjectDisposedException_tF68E471ECD1419AD7C51137B742837395F50B69A
{
public:
public:
};
// System.RuntimeType
struct RuntimeType_t40F13BCEAD97478C72C4B40BFDC2A220161CDB8F : public TypeInfo_t9D6F65801A41B97F36138B15FD270A1550DBB3FC
{
public:
// System.MonoTypeInfo System.RuntimeType::type_info
MonoTypeInfo_t9A65BA5324D14FDFEB7644EEE6E1BDF74B8A393D * ___type_info_26;
// System.Object System.RuntimeType::GenericCache
RuntimeObject * ___GenericCache_27;
// System.Reflection.RuntimeConstructorInfo System.RuntimeType::m_serializationCtor
RuntimeConstructorInfo_tF21A59967629968D0BE5D0DAF677662824E9629D * ___m_serializationCtor_28;
public:
inline static int32_t get_offset_of_type_info_26() { return static_cast<int32_t>(offsetof(RuntimeType_t40F13BCEAD97478C72C4B40BFDC2A220161CDB8F, ___type_info_26)); }
inline MonoTypeInfo_t9A65BA5324D14FDFEB7644EEE6E1BDF74B8A393D * get_type_info_26() const { return ___type_info_26; }
inline MonoTypeInfo_t9A65BA5324D14FDFEB7644EEE6E1BDF74B8A393D ** get_address_of_type_info_26() { return &___type_info_26; }
inline void set_type_info_26(MonoTypeInfo_t9A65BA5324D14FDFEB7644EEE6E1BDF74B8A393D * value)
{
___type_info_26 = value;
Il2CppCodeGenWriteBarrier((void**)(&___type_info_26), (void*)value);
}
inline static int32_t get_offset_of_GenericCache_27() { return static_cast<int32_t>(offsetof(RuntimeType_t40F13BCEAD97478C72C4B40BFDC2A220161CDB8F, ___GenericCache_27)); }
inline RuntimeObject * get_GenericCache_27() const { return ___GenericCache_27; }
inline RuntimeObject ** get_address_of_GenericCache_27() { return &___GenericCache_27; }
inline void set_GenericCache_27(RuntimeObject * value)
{
___GenericCache_27 = value;
Il2CppCodeGenWriteBarrier((void**)(&___GenericCache_27), (void*)value);
}
inline static int32_t get_offset_of_m_serializationCtor_28() { return static_cast<int32_t>(offsetof(RuntimeType_t40F13BCEAD97478C72C4B40BFDC2A220161CDB8F, ___m_serializationCtor_28)); }
inline RuntimeConstructorInfo_tF21A59967629968D0BE5D0DAF677662824E9629D * get_m_serializationCtor_28() const { return ___m_serializationCtor_28; }
inline RuntimeConstructorInfo_tF21A59967629968D0BE5D0DAF677662824E9629D ** get_address_of_m_serializationCtor_28() { return &___m_serializationCtor_28; }
inline void set_m_serializationCtor_28(RuntimeConstructorInfo_tF21A59967629968D0BE5D0DAF677662824E9629D * value)
{
___m_serializationCtor_28 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_serializationCtor_28), (void*)value);
}
};
struct RuntimeType_t40F13BCEAD97478C72C4B40BFDC2A220161CDB8F_StaticFields
{
public:
// System.RuntimeType System.RuntimeType::ValueType
RuntimeType_t40F13BCEAD97478C72C4B40BFDC2A220161CDB8F * ___ValueType_10;
// System.RuntimeType System.RuntimeType::EnumType
RuntimeType_t40F13BCEAD97478C72C4B40BFDC2A220161CDB8F * ___EnumType_11;
// System.RuntimeType System.RuntimeType::ObjectType
RuntimeType_t40F13BCEAD97478C72C4B40BFDC2A220161CDB8F * ___ObjectType_12;
// System.RuntimeType System.RuntimeType::StringType
RuntimeType_t40F13BCEAD97478C72C4B40BFDC2A220161CDB8F * ___StringType_13;
// System.RuntimeType System.RuntimeType::DelegateType
RuntimeType_t40F13BCEAD97478C72C4B40BFDC2A220161CDB8F * ___DelegateType_14;
// System.Type[] System.RuntimeType::s_SICtorParamTypes
TypeU5BU5D_t7FE623A666B49176DE123306221193E888A12F5F* ___s_SICtorParamTypes_15;
// System.RuntimeType System.RuntimeType::s_typedRef
RuntimeType_t40F13BCEAD97478C72C4B40BFDC2A220161CDB8F * ___s_typedRef_25;
public:
inline static int32_t get_offset_of_ValueType_10() { return static_cast<int32_t>(offsetof(RuntimeType_t40F13BCEAD97478C72C4B40BFDC2A220161CDB8F_StaticFields, ___ValueType_10)); }
inline RuntimeType_t40F13BCEAD97478C72C4B40BFDC2A220161CDB8F * get_ValueType_10() const { return ___ValueType_10; }
inline RuntimeType_t40F13BCEAD97478C72C4B40BFDC2A220161CDB8F ** get_address_of_ValueType_10() { return &___ValueType_10; }
inline void set_ValueType_10(RuntimeType_t40F13BCEAD97478C72C4B40BFDC2A220161CDB8F * value)
{
___ValueType_10 = value;
Il2CppCodeGenWriteBarrier((void**)(&___ValueType_10), (void*)value);
}
inline static int32_t get_offset_of_EnumType_11() { return static_cast<int32_t>(offsetof(RuntimeType_t40F13BCEAD97478C72C4B40BFDC2A220161CDB8F_StaticFields, ___EnumType_11)); }
inline RuntimeType_t40F13BCEAD97478C72C4B40BFDC2A220161CDB8F * get_EnumType_11() const { return ___EnumType_11; }
inline RuntimeType_t40F13BCEAD97478C72C4B40BFDC2A220161CDB8F ** get_address_of_EnumType_11() { return &___EnumType_11; }
inline void set_EnumType_11(RuntimeType_t40F13BCEAD97478C72C4B40BFDC2A220161CDB8F * value)
{
___EnumType_11 = value;
Il2CppCodeGenWriteBarrier((void**)(&___EnumType_11), (void*)value);
}
inline static int32_t get_offset_of_ObjectType_12() { return static_cast<int32_t>(offsetof(RuntimeType_t40F13BCEAD97478C72C4B40BFDC2A220161CDB8F_StaticFields, ___ObjectType_12)); }
inline RuntimeType_t40F13BCEAD97478C72C4B40BFDC2A220161CDB8F * get_ObjectType_12() const { return ___ObjectType_12; }
inline RuntimeType_t40F13BCEAD97478C72C4B40BFDC2A220161CDB8F ** get_address_of_ObjectType_12() { return &___ObjectType_12; }
inline void set_ObjectType_12(RuntimeType_t40F13BCEAD97478C72C4B40BFDC2A220161CDB8F * value)
{
___ObjectType_12 = value;
Il2CppCodeGenWriteBarrier((void**)(&___ObjectType_12), (void*)value);
}
inline static int32_t get_offset_of_StringType_13() { return static_cast<int32_t>(offsetof(RuntimeType_t40F13BCEAD97478C72C4B40BFDC2A220161CDB8F_StaticFields, ___StringType_13)); }
inline RuntimeType_t40F13BCEAD97478C72C4B40BFDC2A220161CDB8F * get_StringType_13() const { return ___StringType_13; }
inline RuntimeType_t40F13BCEAD97478C72C4B40BFDC2A220161CDB8F ** get_address_of_StringType_13() { return &___StringType_13; }
inline void set_StringType_13(RuntimeType_t40F13BCEAD97478C72C4B40BFDC2A220161CDB8F * value)
{
___StringType_13 = value;
Il2CppCodeGenWriteBarrier((void**)(&___StringType_13), (void*)value);
}
inline static int32_t get_offset_of_DelegateType_14() { return static_cast<int32_t>(offsetof(RuntimeType_t40F13BCEAD97478C72C4B40BFDC2A220161CDB8F_StaticFields, ___DelegateType_14)); }
inline RuntimeType_t40F13BCEAD97478C72C4B40BFDC2A220161CDB8F * get_DelegateType_14() const { return ___DelegateType_14; }
inline RuntimeType_t40F13BCEAD97478C72C4B40BFDC2A220161CDB8F ** get_address_of_DelegateType_14() { return &___DelegateType_14; }
inline void set_DelegateType_14(RuntimeType_t40F13BCEAD97478C72C4B40BFDC2A220161CDB8F * value)
{
___DelegateType_14 = value;
Il2CppCodeGenWriteBarrier((void**)(&___DelegateType_14), (void*)value);
}
inline static int32_t get_offset_of_s_SICtorParamTypes_15() { return static_cast<int32_t>(offsetof(RuntimeType_t40F13BCEAD97478C72C4B40BFDC2A220161CDB8F_StaticFields, ___s_SICtorParamTypes_15)); }
inline TypeU5BU5D_t7FE623A666B49176DE123306221193E888A12F5F* get_s_SICtorParamTypes_15() const { return ___s_SICtorParamTypes_15; }
inline TypeU5BU5D_t7FE623A666B49176DE123306221193E888A12F5F** get_address_of_s_SICtorParamTypes_15() { return &___s_SICtorParamTypes_15; }
inline void set_s_SICtorParamTypes_15(TypeU5BU5D_t7FE623A666B49176DE123306221193E888A12F5F* value)
{
___s_SICtorParamTypes_15 = value;
Il2CppCodeGenWriteBarrier((void**)(&___s_SICtorParamTypes_15), (void*)value);
}
inline static int32_t get_offset_of_s_typedRef_25() { return static_cast<int32_t>(offsetof(RuntimeType_t40F13BCEAD97478C72C4B40BFDC2A220161CDB8F_StaticFields, ___s_typedRef_25)); }
inline RuntimeType_t40F13BCEAD97478C72C4B40BFDC2A220161CDB8F * get_s_typedRef_25() const { return ___s_typedRef_25; }
inline RuntimeType_t40F13BCEAD97478C72C4B40BFDC2A220161CDB8F ** get_address_of_s_typedRef_25() { return &___s_typedRef_25; }
inline void set_s_typedRef_25(RuntimeType_t40F13BCEAD97478C72C4B40BFDC2A220161CDB8F * value)
{
___s_typedRef_25 = value;
Il2CppCodeGenWriteBarrier((void**)(&___s_typedRef_25), (void*)value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
// System.Object[]
struct ObjectU5BU5D_t3C9242B5C88A48B2A5BD9FDA6CD0024E792AF08A : public RuntimeArray
{
public:
ALIGN_FIELD (8) RuntimeObject * m_Items[1];
public:
inline RuntimeObject * GetAt(il2cpp_array_size_t index) const
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
return m_Items[index];
}
inline RuntimeObject ** GetAddressAt(il2cpp_array_size_t index)
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
return m_Items + index;
}
inline void SetAt(il2cpp_array_size_t index, RuntimeObject * value)
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
m_Items[index] = value;
Il2CppCodeGenWriteBarrier((void**)m_Items + index, (void*)value);
}
inline RuntimeObject * GetAtUnchecked(il2cpp_array_size_t index) const
{
return m_Items[index];
}
inline RuntimeObject ** GetAddressAtUnchecked(il2cpp_array_size_t index)
{
return m_Items + index;
}
inline void SetAtUnchecked(il2cpp_array_size_t index, RuntimeObject * value)
{
m_Items[index] = value;
Il2CppCodeGenWriteBarrier((void**)m_Items + index, (void*)value);
}
};
// System.Type[]
struct TypeU5BU5D_t7FE623A666B49176DE123306221193E888A12F5F : public RuntimeArray
{
public:
ALIGN_FIELD (8) Type_t * m_Items[1];
public:
inline Type_t * GetAt(il2cpp_array_size_t index) const
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
return m_Items[index];
}
inline Type_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, Type_t * value)
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
m_Items[index] = value;
Il2CppCodeGenWriteBarrier((void**)m_Items + index, (void*)value);
}
inline Type_t * GetAtUnchecked(il2cpp_array_size_t index) const
{
return m_Items[index];
}
inline Type_t ** GetAddressAtUnchecked(il2cpp_array_size_t index)
{
return m_Items + index;
}
inline void SetAtUnchecked(il2cpp_array_size_t index, Type_t * value)
{
m_Items[index] = value;
Il2CppCodeGenWriteBarrier((void**)m_Items + index, (void*)value);
}
};
// System.Reflection.FieldInfo[]
struct FieldInfoU5BU5D_t9C36FA93372CA01DAF85946064B058CD9CE2E8BE : public RuntimeArray
{
public:
ALIGN_FIELD (8) FieldInfo_t * m_Items[1];
public:
inline FieldInfo_t * GetAt(il2cpp_array_size_t index) const
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
return m_Items[index];
}
inline FieldInfo_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, FieldInfo_t * value)
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
m_Items[index] = value;
Il2CppCodeGenWriteBarrier((void**)m_Items + index, (void*)value);
}
inline FieldInfo_t * GetAtUnchecked(il2cpp_array_size_t index) const
{
return m_Items[index];
}
inline FieldInfo_t ** GetAddressAtUnchecked(il2cpp_array_size_t index)
{
return m_Items + index;
}
inline void SetAtUnchecked(il2cpp_array_size_t index, FieldInfo_t * value)
{
m_Items[index] = value;
Il2CppCodeGenWriteBarrier((void**)m_Items + index, (void*)value);
}
};
// System.IntPtr[]
struct IntPtrU5BU5D_t4DC01DCB9A6DF6C9792A6513595D7A11E637DCDD : public RuntimeArray
{
public:
ALIGN_FIELD (8) intptr_t m_Items[1];
public:
inline intptr_t GetAt(il2cpp_array_size_t index) const
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
return m_Items[index];
}
inline intptr_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, intptr_t value)
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
m_Items[index] = value;
}
inline intptr_t GetAtUnchecked(il2cpp_array_size_t index) const
{
return m_Items[index];
}
inline intptr_t* GetAddressAtUnchecked(il2cpp_array_size_t index)
{
return m_Items + index;
}
inline void SetAtUnchecked(il2cpp_array_size_t index, intptr_t value)
{
m_Items[index] = value;
}
};
// System.Delegate[]
struct DelegateU5BU5D_tDFCDEE2A6322F96C0FE49AF47E9ADB8C4B294E86 : public RuntimeArray
{
public:
ALIGN_FIELD (8) Delegate_t * m_Items[1];
public:
inline Delegate_t * GetAt(il2cpp_array_size_t index) const
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
return m_Items[index];
}
inline Delegate_t ** GetAddressAt(il2cpp_array_size_t index)
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
return m_Items + index;
}
inline void SetAt(il2cpp_array_size_t index, Delegate_t * value)
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
m_Items[index] = value;
Il2CppCodeGenWriteBarrier((void**)m_Items + index, (void*)value);
}
inline Delegate_t * GetAtUnchecked(il2cpp_array_size_t index) const
{
return m_Items[index];
}
inline Delegate_t ** GetAddressAtUnchecked(il2cpp_array_size_t index)
{
return m_Items + index;
}
inline void SetAtUnchecked(il2cpp_array_size_t index, Delegate_t * value)
{
m_Items[index] = value;
Il2CppCodeGenWriteBarrier((void**)m_Items + index, (void*)value);
}
};
// System.Int32[]
struct Int32U5BU5D_t2B9E4FDDDB9F0A00EC0AC631BA2DA915EB1ECF83 : public RuntimeArray
{
public:
ALIGN_FIELD (8) int32_t m_Items[1];
public:
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;
}
};
// System.Char[]
struct CharU5BU5D_t4CC6ABF0AD71BEC97E3C2F1E9C5677E46D3A75C2 : public RuntimeArray
{
public:
ALIGN_FIELD (8) Il2CppChar m_Items[1];
public:
inline Il2CppChar GetAt(il2cpp_array_size_t index) const
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
return m_Items[index];
}
inline Il2CppChar* 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, Il2CppChar value)
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
m_Items[index] = value;
}
inline Il2CppChar GetAtUnchecked(il2cpp_array_size_t index) const
{
return m_Items[index];
}
inline Il2CppChar* GetAddressAtUnchecked(il2cpp_array_size_t index)
{
return m_Items + index;
}
inline void SetAtUnchecked(il2cpp_array_size_t index, Il2CppChar value)
{
m_Items[index] = value;
}
};
// System.String[]
struct StringU5BU5D_t933FB07893230EA91C40FF900D5400665E87B14E : public RuntimeArray
{
public:
ALIGN_FIELD (8) String_t* m_Items[1];
public:
inline String_t* GetAt(il2cpp_array_size_t index) const
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
return m_Items[index];
}
inline String_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, String_t* value)
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
m_Items[index] = value;
Il2CppCodeGenWriteBarrier((void**)m_Items + index, (void*)value);
}
inline String_t* GetAtUnchecked(il2cpp_array_size_t index) const
{
return m_Items[index];
}
inline String_t** GetAddressAtUnchecked(il2cpp_array_size_t index)
{
return m_Items + index;
}
inline void SetAtUnchecked(il2cpp_array_size_t index, String_t* value)
{
m_Items[index] = value;
Il2CppCodeGenWriteBarrier((void**)m_Items + index, (void*)value);
}
};
IL2CPP_EXTERN_C void InputRecord_tAB007C739F339BE208F3C4796B53E9044ADF0A78_marshal_pinvoke(const InputRecord_tAB007C739F339BE208F3C4796B53E9044ADF0A78& unmarshaled, InputRecord_tAB007C739F339BE208F3C4796B53E9044ADF0A78_marshaled_pinvoke& marshaled);
IL2CPP_EXTERN_C void InputRecord_tAB007C739F339BE208F3C4796B53E9044ADF0A78_marshal_pinvoke_back(const InputRecord_tAB007C739F339BE208F3C4796B53E9044ADF0A78_marshaled_pinvoke& marshaled, InputRecord_tAB007C739F339BE208F3C4796B53E9044ADF0A78& unmarshaled);
IL2CPP_EXTERN_C void InputRecord_tAB007C739F339BE208F3C4796B53E9044ADF0A78_marshal_pinvoke_cleanup(InputRecord_tAB007C739F339BE208F3C4796B53E9044ADF0A78_marshaled_pinvoke& marshaled);
// System.Collections.Generic.List`1/Enumerator<T> System.Collections.Generic.List`1<System.Object>::GetEnumerator()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Enumerator_tE0C99528D3DCE5863566CE37BD94162A4C0431CD List_1_GetEnumerator_m52CC760E475D226A2B75048D70C4E22692F9F68D_gshared (List_1_t05CC3C859AB5E6024394EF9A42E3E696628CA02D * __this, const RuntimeMethod* method);
// T System.Collections.Generic.List`1/Enumerator<System.Object>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * Enumerator_get_Current_mD7829C7E8CFBEDD463B15A951CDE9B90A12CC55C_gshared (Enumerator_tE0C99528D3DCE5863566CE37BD94162A4C0431CD * __this, const RuntimeMethod* method);
// System.Boolean System.Collections.Generic.List`1/Enumerator<System.Object>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool Enumerator_MoveNext_m38B1099DDAD7EEDE2F4CDAB11C095AC784AC2E34_gshared (Enumerator_tE0C99528D3DCE5863566CE37BD94162A4C0431CD * __this, const RuntimeMethod* method);
// System.Void System.Collections.Generic.List`1/Enumerator<System.Object>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void Enumerator_Dispose_m94D0DAE031619503CDA6E53C5C3CC78AF3139472_gshared (Enumerator_tE0C99528D3DCE5863566CE37BD94162A4C0431CD * __this, const RuntimeMethod* method);
// T System.Collections.Generic.List`1<System.Object>::get_Item(System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * List_1_get_Item_mFDB8AD680C600072736579BBF5F38F7416396588_gshared (List_1_t05CC3C859AB5E6024394EF9A42E3E696628CA02D * __this, int32_t p0, const RuntimeMethod* method);
// System.Int32 System.Collections.Generic.List`1<System.Object>::get_Count()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t List_1_get_Count_m507C9149FF7F83AAC72C29091E745D557DA47D22_gshared (List_1_t05CC3C859AB5E6024394EF9A42E3E696628CA02D * __this, const RuntimeMethod* method);
// TResult System.Func`2<System.Object,System.Object>::Invoke(T)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * Func_2_Invoke_m552C133A8966B9ED91540130ACA9BD367212EED4_gshared (Func_2_tE9A60F007AC624EA27BF19DEF4242B7DA2F1C2A4 * __this, RuntimeObject * p0, const RuntimeMethod* method);
// TResult System.Func`4<System.Object,System.Object,System.Boolean,System.Object>::Invoke(T1,T2,T3)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * Func_4_Invoke_m48AC95858F77056A04413DD54457CA20A88EA954_gshared (Func_4_tBDBA893DF2D6BD3ADD95FBC243F607CECF2077B0 * __this, RuntimeObject * p0, RuntimeObject * p1, bool p2, const RuntimeMethod* method);
// System.Void System.Collections.Generic.List`1<System.Object>::.ctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void List_1__ctor_mC832F1AC0F814BAEB19175F5D7972A7507508BC3_gshared (List_1_t05CC3C859AB5E6024394EF9A42E3E696628CA02D * __this, const RuntimeMethod* method);
// System.Void System.Collections.Generic.List`1<System.Object>::Add(T)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void List_1_Add_m6930161974C7504C80F52EC379EF012387D43138_gshared (List_1_t05CC3C859AB5E6024394EF9A42E3E696628CA02D * __this, RuntimeObject * p0, const RuntimeMethod* method);
// System.Void System.Collections.Generic.List`1<System.Int32>::.ctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void List_1__ctor_mA7F9F92F641CEECFD9D8CFDC667568A05FFD27B4_gshared (List_1_tE1526161A558A17A39A8B69D8EEF3801393B6226 * __this, const RuntimeMethod* method);
// System.Void System.Collections.Generic.List`1<System.Int32>::Add(T)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void List_1_Add_m50C0D1F69B2EF31137658E2F052EBBAC7BF82771_gshared (List_1_tE1526161A558A17A39A8B69D8EEF3801393B6226 * __this, int32_t p0, const RuntimeMethod* method);
// T[] System.Collections.Generic.List`1<System.Int32>::ToArray()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Int32U5BU5D_t2B9E4FDDDB9F0A00EC0AC631BA2DA915EB1ECF83* List_1_ToArray_mFEF088E03E18EF79C06317909C301876B3037D98_gshared (List_1_tE1526161A558A17A39A8B69D8EEF3801393B6226 * __this, const RuntimeMethod* method);
// System.Void System.TypeIdentifiers/Display::.ctor(System.String)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void Display__ctor_mA1C635B551554AB64CB2761AE4343A7AAC521D86 (Display_t0222D7CB4CF0F85131FC5E26328FE94E0A27F5E5 * __this, String_t* ___displayName0, const RuntimeMethod* method);
// System.Void System.TypeNames/ATypeName::.ctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void ATypeName__ctor_mB865CB8CFBAD77532030E15AB4DF856DB368D307 (ATypeName_t8FD4A465E3C2846D11FEAE25ED5BF3D67FF94421 * __this, const RuntimeMethod* method);
// System.String System.TypeIdentifiers/Display::GetInternalName()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR String_t* Display_GetInternalName_m9B890BB08D3AE39E9CF2AAF14D5F33C759CC6C36 (Display_t0222D7CB4CF0F85131FC5E26328FE94E0A27F5E5 * __this, const RuntimeMethod* method);
// System.String System.TypeSpec::UnescapeInternalName(System.String)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR String_t* TypeSpec_UnescapeInternalName_m7B3F1C73984FAF9159F89F62C97AF144EDC4347E (String_t* ___displayName0, const RuntimeMethod* method);
// System.String System.Environment::GetResourceString(System.String)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR String_t* Environment_GetResourceString_m2C75C2AF268F01E2BF34AD1C2E1352CF4BA51AD9 (String_t* ___key0, const RuntimeMethod* method);
// System.Void System.SystemException::.ctor(System.String)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void SystemException__ctor_mF67B7FA639B457BDFB2103D7C21C8059E806175A (SystemException_t5380468142AA850BE4A341D7AF3EAB9C78746782 * __this, String_t* ___message0, const RuntimeMethod* method);
// System.Void System.Exception::SetErrorCode(System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void Exception_SetErrorCode_m742C1E687C82E56F445893685007EF4FC017F4A7 (Exception_t * __this, int32_t ___hr0, const RuntimeMethod* method);
// System.String System.Environment::GetResourceString(System.String,System.Object[])
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR String_t* Environment_GetResourceString_m7389941B4C0688D875CC647D99A739DA2F907ADB (String_t* ___key0, ObjectU5BU5D_t3C9242B5C88A48B2A5BD9FDA6CD0024E792AF08A* ___values1, const RuntimeMethod* method);
// System.Void System.SystemException::.ctor(System.String,System.Exception)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void SystemException__ctor_mA18D2EA5642C066F35CB8C965398F9A542C33B0A (SystemException_t5380468142AA850BE4A341D7AF3EAB9C78746782 * __this, String_t* ___message0, Exception_t * ___innerException1, const RuntimeMethod* method);
// System.Void System.SystemException::.ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void SystemException__ctor_mB0550111A1A8D18B697B618F811A5B20C160D949 (SystemException_t5380468142AA850BE4A341D7AF3EAB9C78746782 * __this, SerializationInfo_t1BB80E9C9DEA52DBF464487234B045E2930ADA26 * ___info0, StreamingContext_t2CCDC54E0E8D078AF4A50E3A8B921B828A900034 ___context1, const RuntimeMethod* method);
// System.String System.Runtime.Serialization.SerializationInfo::GetString(System.String)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR String_t* SerializationInfo_GetString_m06805A4E368E0B98D5FA70A9333B277CBDD84CF4 (SerializationInfo_t1BB80E9C9DEA52DBF464487234B045E2930ADA26 * __this, String_t* ___name0, const RuntimeMethod* method);
// System.Void System.Exception::GetObjectData(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void Exception_GetObjectData_m76F759ED00FA218FFC522C32626B851FDE849AD6 (Exception_t * __this, SerializationInfo_t1BB80E9C9DEA52DBF464487234B045E2930ADA26 * ___info0, StreamingContext_t2CCDC54E0E8D078AF4A50E3A8B921B828A900034 ___context1, const RuntimeMethod* method);
// System.String System.TypeInitializationException::get_TypeName()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR String_t* TypeInitializationException_get_TypeName_mB1D7D9D4E2400579F85B80BA0B012504AB15A5A8 (TypeInitializationException_t5223A07113C97D6DC875A82C68D4C132737ADEAE * __this, const RuntimeMethod* method);
// System.Type System.Type::GetTypeFromHandle(System.RuntimeTypeHandle)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Type_t * Type_GetTypeFromHandle_m9DC58ADF0512987012A8A016FB64B068F3B1AFF6 (RuntimeTypeHandle_t7B542280A22F0EC4EAC2061C29178845847A8B2D ___handle0, const RuntimeMethod* method);
// System.Void System.Runtime.Serialization.SerializationInfo::AddValue(System.String,System.Object,System.Type)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void SerializationInfo_AddValue_mE0A104C01EFA55A83D4CAE4662A9B4C6459911FC (SerializationInfo_t1BB80E9C9DEA52DBF464487234B045E2930ADA26 * __this, String_t* ___name0, RuntimeObject * ___value1, Type_t * ___type2, const RuntimeMethod* method);
// System.Void System.TypeLoadException::SetMessageField()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void TypeLoadException_SetMessageField_m23CD2003031C6BF6A4AD01D4FFF2DC786DA580E0 (TypeLoadException_t510963B29CB27C6EA3ACDF5FB76E72E1BC372CD1 * __this, const RuntimeMethod* method);
// System.Globalization.CultureInfo System.Globalization.CultureInfo::get_CurrentCulture()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR CultureInfo_t345AC6924134F039ED9A11F3E03F8E91B6A3225F * CultureInfo_get_CurrentCulture_mD86F3D8E5D332FB304F80D9B9CA4DE849C2A6831 (const RuntimeMethod* method);
// System.String System.String::Format(System.IFormatProvider,System.String,System.Object,System.Object,System.Object)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR String_t* String_Format_mCE84582533EA9934933F3F1496451F3D9DA652A4 (RuntimeObject* ___provider0, String_t* ___format1, RuntimeObject * ___arg02, RuntimeObject * ___arg13, RuntimeObject * ___arg24, const RuntimeMethod* method);
// System.Void System.TypeLoadException::.ctor(System.String,System.String,System.String,System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void TypeLoadException__ctor_m6AB219D6FD444BC779001D783A48DE29CCB4D670 (TypeLoadException_t510963B29CB27C6EA3ACDF5FB76E72E1BC372CD1 * __this, String_t* ___className0, String_t* ___assemblyName1, String_t* ___messageArg2, int32_t ___resourceId3, const RuntimeMethod* method);
// System.Void System.ArgumentNullException::.ctor(System.String)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void ArgumentNullException__ctor_mEE0C0D6FCB2D08CD7967DBB1329A0854BBED49ED (ArgumentNullException_t581DF992B1F3E0EC6EFB30CC5DC43519A79B27AD * __this, String_t* ___paramName0, const RuntimeMethod* method);
// System.Int32 System.Runtime.Serialization.SerializationInfo::GetInt32(System.String)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t SerializationInfo_GetInt32_mB47BD46A0BDBBAF5B47BB62E6EFF8E092E3F3656 (SerializationInfo_t1BB80E9C9DEA52DBF464487234B045E2930ADA26 * __this, String_t* ___name0, const RuntimeMethod* method);
// System.Void System.Runtime.Serialization.SerializationInfo::AddValue(System.String,System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void SerializationInfo_AddValue_m7C73917D9DC4B8FE4AFEF4BA8EBEDAB046A8D0BD (SerializationInfo_t1BB80E9C9DEA52DBF464487234B045E2930ADA26 * __this, String_t* ___name0, int32_t ___value1, const RuntimeMethod* method);
// System.TypeSpec System.TypeSpec::Parse(System.String)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR TypeSpec_t943289F7C537252144A22588159B36C6B6759A7F * TypeSpec_Parse_m7DDF2C8D81E80856BA9EEFDB84421AE2F81B58C1 (String_t* ___typeName0, const RuntimeMethod* method);
// System.Type System.TypeSpec::Resolve(System.Func`2<System.Reflection.AssemblyName,System.Reflection.Assembly>,System.Func`4<System.Reflection.Assembly,System.String,System.Boolean,System.Type>,System.Boolean,System.Boolean)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Type_t * TypeSpec_Resolve_mCE50015512C48D97F6D5558A2001825102BDDBF7 (TypeSpec_t943289F7C537252144A22588159B36C6B6759A7F * __this, Func_2_t13827C9725E0D12567E029E178981FB7D0E13430 * ___assemblyResolver0, Func_4_t3D7857A2A0F731D1E992FC5B09E983A8621FABFF * ___typeResolver1, bool ___throwOnError2, bool ___ignoreCase3, const RuntimeMethod* method);
// System.Boolean System.String::op_Equality(System.String,System.String)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool String_op_Equality_m139F0E4195AE2F856019E63B241F36F016997FCE (String_t* ___a0, String_t* ___b1, const RuntimeMethod* method);
// System.Boolean System.TypeNames/ATypeName::Equals(System.TypeName)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool ATypeName_Equals_m7D88938E443BA9FAEA8615EEFBAE8E23B1BE6BD2 (ATypeName_t8FD4A465E3C2846D11FEAE25ED5BF3D67FF94421 * __this, RuntimeObject* ___other0, const RuntimeMethod* method);
// System.Void System.Object::.ctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void Object__ctor_m925ECA5E85CA100E3FB86A4F9E15C120E9A184C0 (RuntimeObject * __this, const RuntimeMethod* method);
// System.Void System.Text.StringBuilder::.ctor(System.String)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void StringBuilder__ctor_m53E278FB62B3EAEFAF82890C97219B9B5E2A56C3 (StringBuilder_t * __this, String_t* ___value0, const RuntimeMethod* method);
// System.Collections.Generic.List`1/Enumerator<T> System.Collections.Generic.List`1<System.TypeIdentifier>::GetEnumerator()
inline Enumerator_tF3C2A3B3C8EE5956E26FA5AE4C14FC7655975628 List_1_GetEnumerator_m2E4A41A21C3DEA2E56F3BAAC22CAC54ADDAAE89A (List_1_tB8129EB4ADDDECD38E3E178F0A902C921B575166 * __this, const RuntimeMethod* method)
{
return (( Enumerator_tF3C2A3B3C8EE5956E26FA5AE4C14FC7655975628 (*) (List_1_tB8129EB4ADDDECD38E3E178F0A902C921B575166 *, const RuntimeMethod*))List_1_GetEnumerator_m52CC760E475D226A2B75048D70C4E22692F9F68D_gshared)(__this, method);
}
// T System.Collections.Generic.List`1/Enumerator<System.TypeIdentifier>::get_Current()
inline RuntimeObject* Enumerator_get_Current_m1FE262A1143A9C0B744CAE59FDF00A529A47DA7C (Enumerator_tF3C2A3B3C8EE5956E26FA5AE4C14FC7655975628 * __this, const RuntimeMethod* method)
{
return (( RuntimeObject* (*) (Enumerator_tF3C2A3B3C8EE5956E26FA5AE4C14FC7655975628 *, const RuntimeMethod*))Enumerator_get_Current_mD7829C7E8CFBEDD463B15A951CDE9B90A12CC55C_gshared)(__this, method);
}
// System.Text.StringBuilder System.Text.StringBuilder::Append(System.Char)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR StringBuilder_t * StringBuilder_Append_m05C12F58ADC2D807613A9301DF438CB3CD09B75A (StringBuilder_t * __this, Il2CppChar ___value0, const RuntimeMethod* method);
// System.Text.StringBuilder System.Text.StringBuilder::Append(System.String)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR StringBuilder_t * StringBuilder_Append_mDBB8CCBB7750C67BE2F2D92F47E6C0FA42793260 (StringBuilder_t * __this, String_t* ___value0, const RuntimeMethod* method);
// System.Boolean System.Collections.Generic.List`1/Enumerator<System.TypeIdentifier>::MoveNext()
inline bool Enumerator_MoveNext_m5FA83E49042D278C984097B83622E3165E4564AD (Enumerator_tF3C2A3B3C8EE5956E26FA5AE4C14FC7655975628 * __this, const RuntimeMethod* method)
{
return (( bool (*) (Enumerator_tF3C2A3B3C8EE5956E26FA5AE4C14FC7655975628 *, const RuntimeMethod*))Enumerator_MoveNext_m38B1099DDAD7EEDE2F4CDAB11C095AC784AC2E34_gshared)(__this, method);
}
// System.Void System.Collections.Generic.List`1/Enumerator<System.TypeIdentifier>::Dispose()
inline void Enumerator_Dispose_m9FE451117A551A3AD97A0FC27C1C159B551B25F3 (Enumerator_tF3C2A3B3C8EE5956E26FA5AE4C14FC7655975628 * __this, const RuntimeMethod* method)
{
(( void (*) (Enumerator_tF3C2A3B3C8EE5956E26FA5AE4C14FC7655975628 *, const RuntimeMethod*))Enumerator_Dispose_m94D0DAE031619503CDA6E53C5C3CC78AF3139472_gshared)(__this, method);
}
// T System.Collections.Generic.List`1<System.TypeSpec>::get_Item(System.Int32)
inline TypeSpec_t943289F7C537252144A22588159B36C6B6759A7F * List_1_get_Item_m942CEFAE0020F8EC07462ED0CFC951FFE66CBD46 (List_1_t8C8BF378AAB72B34B6EE63F686877AE7290ECFBA * __this, int32_t p0, const RuntimeMethod* method)
{
return (( TypeSpec_t943289F7C537252144A22588159B36C6B6759A7F * (*) (List_1_t8C8BF378AAB72B34B6EE63F686877AE7290ECFBA *, int32_t, const RuntimeMethod*))List_1_get_Item_mFDB8AD680C600072736579BBF5F38F7416396588_gshared)(__this, p0, method);
}
// System.String System.TypeSpec::get_DisplayFullName()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR String_t* TypeSpec_get_DisplayFullName_mE25183941E02D8885546E07565C790AF63A890FA (TypeSpec_t943289F7C537252144A22588159B36C6B6759A7F * __this, const RuntimeMethod* method);
// System.Int32 System.Collections.Generic.List`1<System.TypeSpec>::get_Count()
inline int32_t List_1_get_Count_m516B184735436F6F6363D5BDBC6469AAA19A10A4 (List_1_t8C8BF378AAB72B34B6EE63F686877AE7290ECFBA * __this, const RuntimeMethod* method)
{
return (( int32_t (*) (List_1_t8C8BF378AAB72B34B6EE63F686877AE7290ECFBA *, const RuntimeMethod*))List_1_get_Count_m507C9149FF7F83AAC72C29091E745D557DA47D22_gshared)(__this, method);
}
// System.Text.StringBuilder System.TypeSpec::GetModifierString(System.Text.StringBuilder)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR StringBuilder_t * TypeSpec_GetModifierString_m879659900335844914FDD6BEB1B373531DC990FE (TypeSpec_t943289F7C537252144A22588159B36C6B6759A7F * __this, StringBuilder_t * ___sb0, const RuntimeMethod* method);
// System.Collections.Generic.List`1/Enumerator<T> System.Collections.Generic.List`1<System.ModifierSpec>::GetEnumerator()
inline Enumerator_t947A94EE32E8D5A1E40EDCC5D83206D0832E531D List_1_GetEnumerator_m7F1A981C4F56927EB6D80776859EFEB2A949645F (List_1_tFD995FD9C5961BB4B415EE63B297C4B19643A3C2 * __this, const RuntimeMethod* method)
{
return (( Enumerator_t947A94EE32E8D5A1E40EDCC5D83206D0832E531D (*) (List_1_tFD995FD9C5961BB4B415EE63B297C4B19643A3C2 *, const RuntimeMethod*))List_1_GetEnumerator_m52CC760E475D226A2B75048D70C4E22692F9F68D_gshared)(__this, method);
}
// T System.Collections.Generic.List`1/Enumerator<System.ModifierSpec>::get_Current()
inline RuntimeObject* Enumerator_get_Current_mABF1CE6A366A00FB242CDDC13D80881F14052780 (Enumerator_t947A94EE32E8D5A1E40EDCC5D83206D0832E531D * __this, const RuntimeMethod* method)
{
return (( RuntimeObject* (*) (Enumerator_t947A94EE32E8D5A1E40EDCC5D83206D0832E531D *, const RuntimeMethod*))Enumerator_get_Current_mD7829C7E8CFBEDD463B15A951CDE9B90A12CC55C_gshared)(__this, method);
}
// System.Boolean System.Collections.Generic.List`1/Enumerator<System.ModifierSpec>::MoveNext()
inline bool Enumerator_MoveNext_mD91BF5A0EE3F48F18729E9A081A22223CBA9134E (Enumerator_t947A94EE32E8D5A1E40EDCC5D83206D0832E531D * __this, const RuntimeMethod* method)
{
return (( bool (*) (Enumerator_t947A94EE32E8D5A1E40EDCC5D83206D0832E531D *, const RuntimeMethod*))Enumerator_MoveNext_m38B1099DDAD7EEDE2F4CDAB11C095AC784AC2E34_gshared)(__this, method);
}
// System.Void System.Collections.Generic.List`1/Enumerator<System.ModifierSpec>::Dispose()
inline void Enumerator_Dispose_m4B5D4976D2C83F3DB387137CD7DE096E0C28370B (Enumerator_t947A94EE32E8D5A1E40EDCC5D83206D0832E531D * __this, const RuntimeMethod* method)
{
(( void (*) (Enumerator_t947A94EE32E8D5A1E40EDCC5D83206D0832E531D *, const RuntimeMethod*))Enumerator_Dispose_m94D0DAE031619503CDA6E53C5C3CC78AF3139472_gshared)(__this, method);
}
// System.String System.TypeSpec::GetDisplayFullName(System.TypeSpec/DisplayNameFormat)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR String_t* TypeSpec_GetDisplayFullName_m4D6D7AED6CBFC324310480BA07461682A09822B6 (TypeSpec_t943289F7C537252144A22588159B36C6B6759A7F * __this, int32_t ___flags0, const RuntimeMethod* method);
// System.TypeSpec System.TypeSpec::Parse(System.String,System.Int32&,System.Boolean,System.Boolean)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR TypeSpec_t943289F7C537252144A22588159B36C6B6759A7F * TypeSpec_Parse_m9AE5F2E214E154E1AEDCB27FD207B0C4C8EBC405 (String_t* ___name0, int32_t* ___p1, bool ___is_recurse2, bool ___allow_aqn3, const RuntimeMethod* method);
// System.Int32 System.String::get_Length()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t String_get_Length_mD48C8A16A5CF1914F330DCE82D9BE15C3BEDD018 (String_t* __this, const RuntimeMethod* method);
// System.Void System.ArgumentException::.ctor(System.String,System.String)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void ArgumentException__ctor_m26DC3463C6F3C98BF33EA39598DD2B32F0249CA8 (ArgumentException_tEDCD16F20A09ECE461C3DA766C16EDA8864057D1 * __this, String_t* ___message0, String_t* ___paramName1, const RuntimeMethod* method);
// System.Void System.Text.StringBuilder::.ctor(System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void StringBuilder__ctor_m1C0F2D97B838537A2D0F64033AE4EF02D150A956 (StringBuilder_t * __this, int32_t ___capacity0, const RuntimeMethod* method);
// System.Char System.String::get_Chars(System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Il2CppChar String_get_Chars_m14308AC3B95F8C1D9F1D1055B116B37D595F1D96 (String_t* __this, int32_t ___index0, const RuntimeMethod* method);
// System.Type System.Type::GetType(System.String,System.Boolean,System.Boolean)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Type_t * Type_GetType_m77EF3A5A858B45C53D8BF27C74FA00CA83B53E59 (String_t* ___typeName0, bool ___throwOnError1, bool ___ignoreCase2);
// System.Void System.Reflection.AssemblyName::.ctor(System.String)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void AssemblyName__ctor_m9B2E1009DD65CCC1807A629A09D7CDEC26756FBF (AssemblyName_t6F3EC58113268060348EE894DCB46F6EF6BBBB82 * __this, String_t* ___assemblyName0, const RuntimeMethod* method);
// TResult System.Func`2<System.Reflection.AssemblyName,System.Reflection.Assembly>::Invoke(T)
inline Assembly_t * Func_2_Invoke_m18E0D4D4C27DA4526F57145018F8C5B7D4555786 (Func_2_t13827C9725E0D12567E029E178981FB7D0E13430 * __this, AssemblyName_t6F3EC58113268060348EE894DCB46F6EF6BBBB82 * p0, const RuntimeMethod* method)
{
return (( Assembly_t * (*) (Func_2_t13827C9725E0D12567E029E178981FB7D0E13430 *, AssemblyName_t6F3EC58113268060348EE894DCB46F6EF6BBBB82 *, const RuntimeMethod*))Func_2_Invoke_m552C133A8966B9ED91540130ACA9BD367212EED4_gshared)(__this, p0, method);
}
// System.Reflection.Assembly System.Reflection.Assembly::Load(System.String)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Assembly_t * Assembly_Load_m4640304E91781FC3D197CD014B0C2DCEAFCFFF55 (String_t* ___assemblyString0, const RuntimeMethod* method);
// System.Boolean System.Reflection.Assembly::op_Equality(System.Reflection.Assembly,System.Reflection.Assembly)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool Assembly_op_Equality_m4B6A318CE4104781ABF30A2BBBCCCFB0FE342316 (Assembly_t * ___left0, Assembly_t * ___right1, const RuntimeMethod* method);
// System.String System.String::Concat(System.String,System.String,System.String)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR String_t* String_Concat_mF4626905368D6558695A823466A1AF65EADB9923 (String_t* ___str00, String_t* ___str11, String_t* ___str22, const RuntimeMethod* method);
// System.Void System.IO.FileNotFoundException::.ctor(System.String)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void FileNotFoundException__ctor_mA72DAA77008E903BC162A8D32FDE7F874B27E858 (FileNotFoundException_t0B3F0AE5C94A781A7E2ABBD786F91C229B703431 * __this, String_t* ___message0, const RuntimeMethod* method);
// TResult System.Func`4<System.Reflection.Assembly,System.String,System.Boolean,System.Type>::Invoke(T1,T2,T3)
inline Type_t * Func_4_Invoke_m95D3A234FD84599FDA35F785ACE24B58A5103D13 (Func_4_t3D7857A2A0F731D1E992FC5B09E983A8621FABFF * __this, Assembly_t * p0, String_t* p1, bool p2, const RuntimeMethod* method)
{
return (( Type_t * (*) (Func_4_t3D7857A2A0F731D1E992FC5B09E983A8621FABFF *, Assembly_t *, String_t*, bool, const RuntimeMethod*))Func_4_Invoke_m48AC95858F77056A04413DD54457CA20A88EA954_gshared)(__this, p0, p1, p2, method);
}
// System.Boolean System.Type::op_Equality(System.Type,System.Type)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool Type_op_Equality_m7040622C9E1037EFC73E1F0EDB1DD241282BE3D8 (Type_t * ___left0, Type_t * ___right1, const RuntimeMethod* method);
// System.String System.String::Concat(System.Object,System.Object,System.Object)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR String_t* String_Concat_m2E1F71C491D2429CC80A28745488FEA947BB7AAC (RuntimeObject * ___arg00, RuntimeObject * ___arg11, RuntimeObject * ___arg22, const RuntimeMethod* method);
// System.Void System.TypeLoadException::.ctor(System.String)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void TypeLoadException__ctor_m80951BFF6EB67A1ED3052D05569EF70D038B1581 (TypeLoadException_t510963B29CB27C6EA3ACDF5FB76E72E1BC372CD1 * __this, String_t* ___message0, const RuntimeMethod* method);
// System.TypeIdentifier System.TypeSpec::ParsedTypeIdentifier(System.String)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject* TypeSpec_ParsedTypeIdentifier_m9D32F152A6F9863DCF3EFBF495B6CC16747E851E (String_t* ___displayName0, const RuntimeMethod* method);
// System.Void System.Collections.Generic.List`1<System.TypeIdentifier>::.ctor()
inline void List_1__ctor_m21E88645DC77FDCB68ED0EA3602951A2609C963C (List_1_tB8129EB4ADDDECD38E3E178F0A902C921B575166 * __this, const RuntimeMethod* method)
{
(( void (*) (List_1_tB8129EB4ADDDECD38E3E178F0A902C921B575166 *, const RuntimeMethod*))List_1__ctor_mC832F1AC0F814BAEB19175F5D7972A7507508BC3_gshared)(__this, method);
}
// System.Void System.Collections.Generic.List`1<System.TypeIdentifier>::Add(T)
inline void List_1_Add_m191DF682AFC83E635052DB3C303E514D6D7233A2 (List_1_tB8129EB4ADDDECD38E3E178F0A902C921B575166 * __this, RuntimeObject* p0, const RuntimeMethod* method)
{
(( void (*) (List_1_tB8129EB4ADDDECD38E3E178F0A902C921B575166 *, RuntimeObject*, const RuntimeMethod*))List_1_Add_m6930161974C7504C80F52EC379EF012387D43138_gshared)(__this, p0, method);
}
// System.Void System.Collections.Generic.List`1<System.ModifierSpec>::.ctor()
inline void List_1__ctor_mA97DC4CD260A1FD5F8FD67E06EE8F27E5C03CF63 (List_1_tFD995FD9C5961BB4B415EE63B297C4B19643A3C2 * __this, const RuntimeMethod* method)
{
(( void (*) (List_1_tFD995FD9C5961BB4B415EE63B297C4B19643A3C2 *, const RuntimeMethod*))List_1__ctor_mC832F1AC0F814BAEB19175F5D7972A7507508BC3_gshared)(__this, method);
}
// System.Void System.Collections.Generic.List`1<System.ModifierSpec>::Add(T)
inline void List_1_Add_mEA738D5941352BC4540C28F701A4BF01E2DF7914 (List_1_tFD995FD9C5961BB4B415EE63B297C4B19643A3C2 * __this, RuntimeObject* p0, const RuntimeMethod* method)
{
(( void (*) (List_1_tFD995FD9C5961BB4B415EE63B297C4B19643A3C2 *, RuntimeObject*, const RuntimeMethod*))List_1_Add_m6930161974C7504C80F52EC379EF012387D43138_gshared)(__this, p0, method);
}
// System.Boolean System.Char::IsWhiteSpace(System.Char)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool Char_IsWhiteSpace_m8AE1C4157A1E1D8F5022630F4229AB26223BDC6B (Il2CppChar ___c0, const RuntimeMethod* method);
// System.TypeIdentifier System.TypeIdentifiers::FromDisplay(System.String)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject* TypeIdentifiers_FromDisplay_m08FB8BE03D80603F9A030774E218310DC96693CE (String_t* ___displayName0, const RuntimeMethod* method);
// System.Void System.TypeSpec::.ctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void TypeSpec__ctor_m18DCF64756F091CE7A7DA6CDAD3142419602D901 (TypeSpec_t943289F7C537252144A22588159B36C6B6759A7F * __this, const RuntimeMethod* method);
// System.Void System.TypeSpec::SkipSpace(System.String,System.Int32&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void TypeSpec_SkipSpace_mF388B6F9C82F795BA722B706A5435B0E799A531C (String_t* ___name0, int32_t* ___pos1, const RuntimeMethod* method);
// System.String System.String::Substring(System.Int32,System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR String_t* String_Substring_mB593C0A320C683E6E47EFFC0A12B7A465E5E43BB (String_t* __this, int32_t ___startIndex0, int32_t ___length1, const RuntimeMethod* method);
// System.Void System.TypeSpec::AddName(System.String)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void TypeSpec_AddName_mEF7336F662841D8A5B8157BA703C8959A808C9B7 (TypeSpec_t943289F7C537252144A22588159B36C6B6759A7F * __this, String_t* ___type_name0, const RuntimeMethod* method);
// System.Void System.PointerSpec::.ctor(System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void PointerSpec__ctor_mB00CD482EDE6910DE19A767C128B00785F1A2136 (PointerSpec_tBCE1666DC24EC6E4E5376FEC214499984EC26892 * __this, int32_t ___pointer_level0, const RuntimeMethod* method);
// System.Void System.TypeSpec::AddModifier(System.ModifierSpec)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void TypeSpec_AddModifier_m082500BAE4A512BA0E84CC85A71F4A67DA885909 (TypeSpec_t943289F7C537252144A22588159B36C6B6759A7F * __this, RuntimeObject* ___md0, const RuntimeMethod* method);
// System.Void System.ArgumentException::.ctor(System.String)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void ArgumentException__ctor_m9A85EF7FEFEC21DDD525A67E831D77278E5165B7 (ArgumentException_tEDCD16F20A09ECE461C3DA766C16EDA8864057D1 * __this, String_t* ___message0, const RuntimeMethod* method);
// System.String System.String::Trim()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR String_t* String_Trim_mB52EB7876C7132358B76B7DC95DEACA20722EF4D (String_t* __this, const RuntimeMethod* method);
// System.String System.String::Substring(System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR String_t* String_Substring_m2C4AFF5E79DD8BADFD2DFBCF156BF728FBB8E1AE (String_t* __this, int32_t ___startIndex0, const RuntimeMethod* method);
// System.Void System.Collections.Generic.List`1<System.TypeSpec>::.ctor()
inline void List_1__ctor_mAF11022CD0FF8181D72047FFC57B48590F17FFAC (List_1_t8C8BF378AAB72B34B6EE63F686877AE7290ECFBA * __this, const RuntimeMethod* method)
{
(( void (*) (List_1_t8C8BF378AAB72B34B6EE63F686877AE7290ECFBA *, const RuntimeMethod*))List_1__ctor_mC832F1AC0F814BAEB19175F5D7972A7507508BC3_gshared)(__this, method);
}
// System.Boolean System.TypeSpec::get_HasModifiers()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool TypeSpec_get_HasModifiers_mF783ED5C395D4ACB94D30014B9F79E19E90EC9FD (TypeSpec_t943289F7C537252144A22588159B36C6B6759A7F * __this, const RuntimeMethod* method);
// System.Void System.Collections.Generic.List`1<System.TypeSpec>::Add(T)
inline void List_1_Add_m12E0FC5DF0E1CB81E7DEADBBDD311E3E1AFC2DB4 (List_1_t8C8BF378AAB72B34B6EE63F686877AE7290ECFBA * __this, TypeSpec_t943289F7C537252144A22588159B36C6B6759A7F * p0, const RuntimeMethod* method)
{
(( void (*) (List_1_t8C8BF378AAB72B34B6EE63F686877AE7290ECFBA *, TypeSpec_t943289F7C537252144A22588159B36C6B6759A7F *, const RuntimeMethod*))List_1_Add_m6930161974C7504C80F52EC379EF012387D43138_gshared)(__this, p0, method);
}
// System.Void System.TypeSpec::BoundCheck(System.Int32,System.String)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void TypeSpec_BoundCheck_m5CF5E6F2632D8D4D205DC26F6666BE9EA7D874FB (int32_t ___idx0, String_t* ___s1, const RuntimeMethod* method);
// System.String System.Char::ToString()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR String_t* Char_ToString_mA42A88FEBA41B72D48BB24373E3101B7A91B6FD8 (Il2CppChar* __this, const RuntimeMethod* method);
// System.String System.String::Concat(System.String,System.String)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR String_t* String_Concat_mB78D0094592718DA6D5DB6C712A9C225631666BE (String_t* ___str00, String_t* ___str11, const RuntimeMethod* method);
// System.Void System.ArraySpec::.ctor(System.Int32,System.Boolean)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void ArraySpec__ctor_m7829BADEF006060440EBF1330EC85B9FF17CE6B4 (ArraySpec_tF374BB8994F7190916C6F14C7EA8FE6EFE017970 * __this, int32_t ___dimensions0, bool ___bound1, const RuntimeMethod* method);
// System.String System.String::Concat(System.Object[])
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR String_t* String_Concat_mB7BA84F13912303B2E5E40FBF0109E1A328ACA07 (ObjectU5BU5D_t3C9242B5C88A48B2A5BD9FDA6CD0024E792AF08A* ___args0, const RuntimeMethod* method);
// System.Type System.Object::GetType()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Type_t * Object_GetType_m2E0B62414ECCAA3094B703790CE88CBB2F83EA60 (RuntimeObject * __this, const RuntimeMethod* method);
// System.Boolean System.Reflection.FieldInfo::op_Equality(System.Reflection.FieldInfo,System.Reflection.FieldInfo)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool FieldInfo_op_Equality_m924E721654B7BDF09AA6E20C6E8D2BC4D4AF9DB7 (FieldInfo_t * ___left0, FieldInfo_t * ___right1, const RuntimeMethod* method);
// System.Boolean System.Reflection.FieldInfo::get_IsInitOnly()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool FieldInfo_get_IsInitOnly_m55ECD5C1B5F908CC9D10FDA743C9014CDB45E044 (FieldInfo_t * __this, const RuntimeMethod* method);
// System.Boolean System.Reflection.FieldInfo::get_IsStatic()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool FieldInfo_get_IsStatic_mDEB4099D238E5846246F0ACED3FF9AD9C93D8ECA (FieldInfo_t * __this, const RuntimeMethod* method);
// System.RuntimeType System.Reflection.RuntimeFieldInfo::GetDeclaringTypeInternal()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeType_t40F13BCEAD97478C72C4B40BFDC2A220161CDB8F * RuntimeFieldInfo_GetDeclaringTypeInternal_m8325660CADABFA47D55C9CD649176638BE521046 (RuntimeFieldInfo_t9C8BA644F857EBE60EC6587AE1C1148E420E66F7 * __this, const RuntimeMethod* method);
// System.Boolean System.RuntimeType::op_Inequality(System.RuntimeType,System.RuntimeType)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool RuntimeType_op_Inequality_mA98A719712593FEE5DCCFDB47CCABDB58BEE1B0D (RuntimeType_t40F13BCEAD97478C72C4B40BFDC2A220161CDB8F * ___left0, RuntimeType_t40F13BCEAD97478C72C4B40BFDC2A220161CDB8F * ___right1, const RuntimeMethod* method);
// System.Void System.MissingMemberException::.ctor(System.String)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void MissingMemberException__ctor_m2F8C7F0015B6EFEC5BD07F8240D53C2AEE4649DC (MissingMemberException_t165349A7E04FC51DAA5C2251C6DCDD2DD60255DD * __this, String_t* ___message0, const RuntimeMethod* method);
// System.Boolean System.Type::get_IsPrimitive()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool Type_get_IsPrimitive_m8E39430EE4B70E1AE690B51E9BE681C7758DFF5A (Type_t * __this, const RuntimeMethod* method);
// System.Boolean System.Type::get_IsValueType()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool Type_get_IsValueType_mDDCCBAE9B59A483CBC3E5C02E3D68CEBEB2E41A8 (Type_t * __this, const RuntimeMethod* method);
// System.IntPtr System.RuntimeFieldHandle::get_Value()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR intptr_t RuntimeFieldHandle_get_Value_m2C81CBF4FC895E7A343C344BE8EE96D9DEBEA3DA (RuntimeFieldHandle_t844BDF00E8E6FE69D9AEAA7657F09018B864F4EF * __this, const RuntimeMethod* method);
// System.TypedReference System.TypedReference::MakeTypedReferenceInternal(System.Object,System.Reflection.FieldInfo[])
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR TypedReference_t118BC3B643F75F52DB9C99D5E051299F886EB2A8 TypedReference_MakeTypedReferenceInternal_mD1DFB634CA2F3B5335B4FFDA97A25DEB90DD170C (RuntimeObject * ___target0, FieldInfoU5BU5D_t9C36FA93372CA01DAF85946064B058CD9CE2E8BE* ___fields1, const RuntimeMethod* method);
// System.Boolean System.IntPtr::op_Equality(System.IntPtr,System.IntPtr)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool IntPtr_op_Equality_mEE8D9FD2DFE312BBAA8B4ED3BF7976B3142A5934 (intptr_t ___value10, intptr_t ___value21, const RuntimeMethod* method);
// System.Int32 System.TypedReference::GetHashCode()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t TypedReference_GetHashCode_m6A586AC495B0AB6D55E7EAE301C82BB2752A4289 (TypedReference_t118BC3B643F75F52DB9C99D5E051299F886EB2A8 * __this, const RuntimeMethod* method);
// System.Void System.NotSupportedException::.ctor(System.String)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void NotSupportedException__ctor_mD023A89A5C1F740F43F0A9CD6C49DC21230B3CEE (NotSupportedException_tE75B318D6590A02A5D9B29FD97409B1750FA0010 * __this, String_t* ___message0, const RuntimeMethod* method);
// System.Boolean System.TypedReference::Equals(System.Object)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool TypedReference_Equals_m167F7EDD4393DE114882916B753AC2D23A3840EA (TypedReference_t118BC3B643F75F52DB9C99D5E051299F886EB2A8 * __this, RuntimeObject * ___o0, const RuntimeMethod* method);
// System.Boolean System.IntPtr::IsNull()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool IntPtr_IsNull_mEB01FA7670F5CA3BE36507B9528EC6F1D5AAC6B4 (intptr_t* __this, const RuntimeMethod* method);
// System.Boolean System.TypedReference::get_IsNull()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool TypedReference_get_IsNull_mD2B185E19B07577D8434A7DAD3AF5F9E2D09C532 (TypedReference_t118BC3B643F75F52DB9C99D5E051299F886EB2A8 * __this, const RuntimeMethod* method);
// System.Void System.NotImplementedException::.ctor(System.String)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void NotImplementedException__ctor_mEBAED0FCA8B8CCE7E96492474350BA35D14CF59C (NotImplementedException_t8AD6EBE5FEDB0AEBECEE0961CF73C35B372EFFA4 * __this, String_t* ___message0, const RuntimeMethod* method);
// System.Int32 System.UInt16::CompareTo(System.Object)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t UInt16_CompareTo_m91AEACDAA81D12A2A8D868938F797B112330EC44 (uint16_t* __this, RuntimeObject * ___value0, const RuntimeMethod* method);
// System.Int32 System.UInt16::CompareTo(System.UInt16)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t UInt16_CompareTo_mC43C95442258DFAD3852458A9EC9E1CB76EEE644 (uint16_t* __this, uint16_t ___value0, const RuntimeMethod* method);
// System.Boolean System.UInt16::Equals(System.Object)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool UInt16_Equals_mBCD7FC4A11D0CEEFF4BC6559137A9E397D7017B8 (uint16_t* __this, RuntimeObject * ___obj0, const RuntimeMethod* method);
// System.Boolean System.UInt16::Equals(System.UInt16)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool UInt16_Equals_m276F4220CB70A960FF4E874EE1D388C277EF806C (uint16_t* __this, uint16_t ___obj0, const RuntimeMethod* method);
// System.Int32 System.UInt16::GetHashCode()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t UInt16_GetHashCode_m6EA43320256903F18CCA1A82905DB6F75BC4FB6E (uint16_t* __this, const RuntimeMethod* method);
// System.Globalization.NumberFormatInfo System.Globalization.NumberFormatInfo::get_CurrentInfo()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR NumberFormatInfo_tFDF57037EBC5BC833D0A53EF0327B805994860A8 * NumberFormatInfo_get_CurrentInfo_m595DF03E32E0C5B01F1EC45F7264B2BD09BA61C9 (const RuntimeMethod* method);
// System.String System.Number::FormatUInt32(System.UInt32,System.String,System.Globalization.NumberFormatInfo)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR String_t* Number_FormatUInt32_m585E2571063A256E46836A51BC4A54CFF151BDEE (uint32_t ___value0, String_t* ___format1, NumberFormatInfo_tFDF57037EBC5BC833D0A53EF0327B805994860A8 * ___info2, const RuntimeMethod* method);
// System.String System.UInt16::ToString()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR String_t* UInt16_ToString_m4B42F0450EE965C7C9DD2AB19EB000D47CE978A2 (uint16_t* __this, const RuntimeMethod* method);
// System.Globalization.NumberFormatInfo System.Globalization.NumberFormatInfo::GetInstance(System.IFormatProvider)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR NumberFormatInfo_tFDF57037EBC5BC833D0A53EF0327B805994860A8 * NumberFormatInfo_GetInstance_m713D298B436F3765F059FEA6C446F0A6ABF0A89A (RuntimeObject* ___formatProvider0, const RuntimeMethod* method);
// System.String System.UInt16::ToString(System.IFormatProvider)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR String_t* UInt16_ToString_m50316C445AD23CCA40AA52A381C5E06A3786F12A (uint16_t* __this, RuntimeObject* ___provider0, const RuntimeMethod* method);
// System.String System.UInt16::ToString(System.String,System.IFormatProvider)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR String_t* UInt16_ToString_mD0CBA1F073A0E16528C1A7EB4E8A9892D218895B (uint16_t* __this, String_t* ___format0, RuntimeObject* ___provider1, const RuntimeMethod* method);
// System.UInt16 System.UInt16::Parse(System.String,System.Globalization.NumberStyles,System.Globalization.NumberFormatInfo)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR uint16_t UInt16_Parse_m12E00A51D9C346D8537FD42FC93C9113D2A0D254 (String_t* ___s0, int32_t ___style1, NumberFormatInfo_tFDF57037EBC5BC833D0A53EF0327B805994860A8 * ___info2, const RuntimeMethod* method);
// System.Void System.Globalization.NumberFormatInfo::ValidateParseStyleInteger(System.Globalization.NumberStyles)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void NumberFormatInfo_ValidateParseStyleInteger_m5BD1C04C26D5589F0DFA5953294B72E1DDC2B7E3 (int32_t ___style0, const RuntimeMethod* method);
// System.UInt32 System.Number::ParseUInt32(System.String,System.Globalization.NumberStyles,System.Globalization.NumberFormatInfo)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR uint32_t Number_ParseUInt32_mF280A62925FED84E23D64DC6B86BC50AD96896FB (String_t* ___value0, int32_t ___options1, NumberFormatInfo_tFDF57037EBC5BC833D0A53EF0327B805994860A8 * ___numfmt2, const RuntimeMethod* method);
// System.Void System.OverflowException::.ctor(System.String,System.Exception)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void OverflowException__ctor_m15CD001EEB2E79D7497E101546B04D9A5520357E (OverflowException_tD89571E2350DE06D9DE4AB65ADCA77D607B5693D * __this, String_t* ___message0, Exception_t * ___innerException1, const RuntimeMethod* method);
// System.Void System.OverflowException::.ctor(System.String)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void OverflowException__ctor_mE1A042FFEBF00B79612E8595B8D49785B357D731 (OverflowException_tD89571E2350DE06D9DE4AB65ADCA77D607B5693D * __this, String_t* ___message0, const RuntimeMethod* method);
// System.TypeCode System.UInt16::GetTypeCode()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t UInt16_GetTypeCode_m3F7CA335640E0702177D473528E70C8D58E0E068 (uint16_t* __this, const RuntimeMethod* method);
// System.Boolean System.Convert::ToBoolean(System.UInt16)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool Convert_ToBoolean_m1AFE52438BC600124643ECEB4EDF9C3FE21171FE (uint16_t ___value0, const RuntimeMethod* method);
// System.Boolean System.UInt16::System.IConvertible.ToBoolean(System.IFormatProvider)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool UInt16_System_IConvertible_ToBoolean_mC81E40A61B311E3D9E69439B629E90816966F72A (uint16_t* __this, RuntimeObject* ___provider0, const RuntimeMethod* method);
// System.Char System.Convert::ToChar(System.UInt16)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Il2CppChar Convert_ToChar_m14666E8E6027FFF4BFA6DA0563A4CAAEA6A6989B (uint16_t ___value0, const RuntimeMethod* method);
// System.Char System.UInt16::System.IConvertible.ToChar(System.IFormatProvider)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Il2CppChar UInt16_System_IConvertible_ToChar_m6CD04280CB5C9546579E13211911F5B42B498F0F (uint16_t* __this, RuntimeObject* ___provider0, const RuntimeMethod* method);
// System.SByte System.Convert::ToSByte(System.UInt16)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int8_t Convert_ToSByte_m4455F931B18E5D87DE1F99B2686F3D4770E9D177 (uint16_t ___value0, const RuntimeMethod* method);
// System.SByte System.UInt16::System.IConvertible.ToSByte(System.IFormatProvider)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int8_t UInt16_System_IConvertible_ToSByte_mA4AD532B0AF50FD2F6AEBCDB581EA1EE43FCA3CF (uint16_t* __this, RuntimeObject* ___provider0, const RuntimeMethod* method);
// System.Byte System.Convert::ToByte(System.UInt16)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR uint8_t Convert_ToByte_m4D9F94693332601CE2F1CF8DB9933F7C0FE882B1 (uint16_t ___value0, const RuntimeMethod* method);
// System.Byte System.UInt16::System.IConvertible.ToByte(System.IFormatProvider)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR uint8_t UInt16_System_IConvertible_ToByte_mA95B992F24924E773C5602A6FEE29BDE5EE2072F (uint16_t* __this, RuntimeObject* ___provider0, const RuntimeMethod* method);
// System.Int16 System.Convert::ToInt16(System.UInt16)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int16_t Convert_ToInt16_m57BC4B92DCAEAA22820CD1915778B407AC23D9C5 (uint16_t ___value0, const RuntimeMethod* method);
// System.Int16 System.UInt16::System.IConvertible.ToInt16(System.IFormatProvider)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int16_t UInt16_System_IConvertible_ToInt16_m0818293E3F1271A2AD126AE950B71DBDDD3286D3 (uint16_t* __this, RuntimeObject* ___provider0, const RuntimeMethod* method);
// System.UInt16 System.UInt16::System.IConvertible.ToUInt16(System.IFormatProvider)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR uint16_t UInt16_System_IConvertible_ToUInt16_mC5507444643901A95C85AA36B8F702EEA4616C81 (uint16_t* __this, RuntimeObject* ___provider0, const RuntimeMethod* method);
// System.Int32 System.Convert::ToInt32(System.UInt16)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t Convert_ToInt32_m8A95C977AFB27DA577E58CAE3255F8B24EE79517 (uint16_t ___value0, const RuntimeMethod* method);
// System.Int32 System.UInt16::System.IConvertible.ToInt32(System.IFormatProvider)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t UInt16_System_IConvertible_ToInt32_mA3C6E3F7DE9C6C893CAA5301EEDA26036554F34C (uint16_t* __this, RuntimeObject* ___provider0, const RuntimeMethod* method);
// System.UInt32 System.Convert::ToUInt32(System.UInt16)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR uint32_t Convert_ToUInt32_mED4922B504189D92D2F6F52BB959895A5979EE40 (uint16_t ___value0, const RuntimeMethod* method);
// System.UInt32 System.UInt16::System.IConvertible.ToUInt32(System.IFormatProvider)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR uint32_t UInt16_System_IConvertible_ToUInt32_m6DA7A076663655EB849211FF9BD16582F863C5F3 (uint16_t* __this, RuntimeObject* ___provider0, const RuntimeMethod* method);
// System.Int64 System.Convert::ToInt64(System.UInt16)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int64_t Convert_ToInt64_mE191CDE636529E410288B04286028D56CBC8EE53 (uint16_t ___value0, const RuntimeMethod* method);
// System.Int64 System.UInt16::System.IConvertible.ToInt64(System.IFormatProvider)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int64_t UInt16_System_IConvertible_ToInt64_mC204E05417B4F982A189912080F57F20E24275CB (uint16_t* __this, RuntimeObject* ___provider0, const RuntimeMethod* method);
// System.UInt64 System.Convert::ToUInt64(System.UInt16)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR uint64_t Convert_ToUInt64_m13A97BCFDAB847AC0D6379DA3FBE031509801944 (uint16_t ___value0, const RuntimeMethod* method);
// System.UInt64 System.UInt16::System.IConvertible.ToUInt64(System.IFormatProvider)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR uint64_t UInt16_System_IConvertible_ToUInt64_m510EF773A50C42F0B60B2C8AE753FC7873B3A97B (uint16_t* __this, RuntimeObject* ___provider0, const RuntimeMethod* method);
// System.Single System.Convert::ToSingle(System.UInt16)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR float Convert_ToSingle_mFBCC3DBA2C1A176506B5B23193DD0F5F27085EAA (uint16_t ___value0, const RuntimeMethod* method);
// System.Single System.UInt16::System.IConvertible.ToSingle(System.IFormatProvider)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR float UInt16_System_IConvertible_ToSingle_m6B087CB34DBF0B394642977BB68F8B503DED3C7E (uint16_t* __this, RuntimeObject* ___provider0, const RuntimeMethod* method);
// System.Double System.Convert::ToDouble(System.UInt16)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR double Convert_ToDouble_m5427641E8803E839561F9C10071C3E33A1A6F854 (uint16_t ___value0, const RuntimeMethod* method);
// System.Double System.UInt16::System.IConvertible.ToDouble(System.IFormatProvider)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR double UInt16_System_IConvertible_ToDouble_m62236A4E72E544543EA440ED142B8BA093ADCB40 (uint16_t* __this, RuntimeObject* ___provider0, const RuntimeMethod* method);
// System.Decimal System.Convert::ToDecimal(System.UInt16)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Decimal_t44EE9DA309A1BF848308DE4DDFC070CAE6D95EE8 Convert_ToDecimal_mFD0BC78E6BE4EDBFD7A0767E7D95A39E40F0260F (uint16_t ___value0, const RuntimeMethod* method);
// System.Decimal System.UInt16::System.IConvertible.ToDecimal(System.IFormatProvider)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Decimal_t44EE9DA309A1BF848308DE4DDFC070CAE6D95EE8 UInt16_System_IConvertible_ToDecimal_m74D92DB8814035966C6CFF447753338B03287E43 (uint16_t* __this, RuntimeObject* ___provider0, const RuntimeMethod* method);
// System.Void System.InvalidCastException::.ctor(System.String)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InvalidCastException__ctor_m3795145150387C6C362DA693613505C604AB8812 (InvalidCastException_t91DF9E7D7FCCDA6C562CB4A9A18903E016680FDA * __this, String_t* ___message0, const RuntimeMethod* method);
// System.DateTime System.UInt16::System.IConvertible.ToDateTime(System.IFormatProvider)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR DateTime_t349B7449FBAAFF4192636E2B7A07694DA9236132 UInt16_System_IConvertible_ToDateTime_m7AD170006FECE0BAC29179FFE72D7AC1B0D0C735 (uint16_t* __this, RuntimeObject* ___provider0, const RuntimeMethod* method);
// System.Object System.Convert::DefaultToType(System.IConvertible,System.Type,System.IFormatProvider)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * Convert_DefaultToType_m899D5F6B9FE3E8B878BC56172C6BFE788B6C1BE3 (RuntimeObject* ___value0, Type_t * ___targetType1, RuntimeObject* ___provider2, const RuntimeMethod* method);
// System.Object System.UInt16::System.IConvertible.ToType(System.Type,System.IFormatProvider)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * UInt16_System_IConvertible_ToType_m2FD8E8941C266AE4254B1C4C068F4C5238C08695 (uint16_t* __this, Type_t * ___type0, RuntimeObject* ___provider1, const RuntimeMethod* method);
// System.Int32 System.UInt32::CompareTo(System.Object)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t UInt32_CompareTo_mA6BFE8D9033149D2FEF46526E251A3CDEB1889EB (uint32_t* __this, RuntimeObject * ___value0, const RuntimeMethod* method);
// System.Int32 System.UInt32::CompareTo(System.UInt32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t UInt32_CompareTo_mB4DB0539EACF9C37A2DDDB1439F553E0CD2AA380 (uint32_t* __this, uint32_t ___value0, const RuntimeMethod* method);
// System.Boolean System.UInt32::Equals(System.Object)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool UInt32_Equals_m44E796DB35F5DB4E5D4C98EC6AB5053242A320C3 (uint32_t* __this, RuntimeObject * ___obj0, const RuntimeMethod* method);
// System.Boolean System.UInt32::Equals(System.UInt32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool UInt32_Equals_m14536B6BD41067948C7ED484437DF75E3414F0D1 (uint32_t* __this, uint32_t ___obj0, const RuntimeMethod* method);
// System.Int32 System.UInt32::GetHashCode()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t UInt32_GetHashCode_m791E3E038DAA8DC313758009B1C532CD91194B0D (uint32_t* __this, const RuntimeMethod* method);
// System.String System.UInt32::ToString()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR String_t* UInt32_ToString_m7D8A934AF1D74C5C8194D1556AA71BBA0D4600F2 (uint32_t* __this, const RuntimeMethod* method);
// System.String System.UInt32::ToString(System.IFormatProvider)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR String_t* UInt32_ToString_mC81601CD79044D74065228749C2CA9B629CFA3EA (uint32_t* __this, RuntimeObject* ___provider0, const RuntimeMethod* method);
// System.String System.UInt32::ToString(System.String,System.IFormatProvider)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR String_t* UInt32_ToString_m57BE7A0F4A653986FEAC4794CD13B04CE012F4EE (uint32_t* __this, String_t* ___format0, RuntimeObject* ___provider1, const RuntimeMethod* method);
// System.Boolean System.Number::TryParseUInt32(System.String,System.Globalization.NumberStyles,System.Globalization.NumberFormatInfo,System.UInt32&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool Number_TryParseUInt32_m5D5F513C1F31174E132E2646CC964C32E55F9436 (String_t* ___s0, int32_t ___style1, NumberFormatInfo_tFDF57037EBC5BC833D0A53EF0327B805994860A8 * ___info2, uint32_t* ___result3, const RuntimeMethod* method);
// System.TypeCode System.UInt32::GetTypeCode()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t UInt32_GetTypeCode_mA0E730CD3883A383AC3E4BA4FD639811906BDD90 (uint32_t* __this, const RuntimeMethod* method);
// System.Boolean System.Convert::ToBoolean(System.UInt32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool Convert_ToBoolean_m26CFF98BC762FA7371C580FB19013250FD567F46 (uint32_t ___value0, const RuntimeMethod* method);
// System.Boolean System.UInt32::System.IConvertible.ToBoolean(System.IFormatProvider)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool UInt32_System_IConvertible_ToBoolean_mFC8A4EC8666918A944AED690BAA21AD7B6132A7E (uint32_t* __this, RuntimeObject* ___provider0, const RuntimeMethod* method);
// System.Char System.Convert::ToChar(System.UInt32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Il2CppChar Convert_ToChar_m56A1099464A288FD3AB6F82B7433DB063F671B29 (uint32_t ___value0, const RuntimeMethod* method);
// System.Char System.UInt32::System.IConvertible.ToChar(System.IFormatProvider)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Il2CppChar UInt32_System_IConvertible_ToChar_mC0A386C36A0EBC656E6F887A1CCD5DBBFF078030 (uint32_t* __this, RuntimeObject* ___provider0, const RuntimeMethod* method);
// System.SByte System.Convert::ToSByte(System.UInt32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int8_t Convert_ToSByte_m2BA3408A7B10119B60B923928EFCFA17D3C46D50 (uint32_t ___value0, const RuntimeMethod* method);
// System.SByte System.UInt32::System.IConvertible.ToSByte(System.IFormatProvider)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int8_t UInt32_System_IConvertible_ToSByte_mD7E08EC2B52A7612582C3E8C26878BAC0AB80984 (uint32_t* __this, RuntimeObject* ___provider0, const RuntimeMethod* method);
// System.Byte System.Convert::ToByte(System.UInt32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR uint8_t Convert_ToByte_m5B2E3D791EE1E14A7604D126C24AA62FE2587B60 (uint32_t ___value0, const RuntimeMethod* method);
// System.Byte System.UInt32::System.IConvertible.ToByte(System.IFormatProvider)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR uint8_t UInt32_System_IConvertible_ToByte_m9386861ED644D7B5E76BD0D7FB86DEEB0173A0A5 (uint32_t* __this, RuntimeObject* ___provider0, const RuntimeMethod* method);
// System.Int16 System.Convert::ToInt16(System.UInt32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int16_t Convert_ToInt16_mE8E094D5AD321E5E6756E332116FAF1C084A1CD2 (uint32_t ___value0, const RuntimeMethod* method);
// System.Int16 System.UInt32::System.IConvertible.ToInt16(System.IFormatProvider)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int16_t UInt32_System_IConvertible_ToInt16_mC8FA3B04E544531449665298BE73AB2F486AE393 (uint32_t* __this, RuntimeObject* ___provider0, const RuntimeMethod* method);
// System.UInt16 System.Convert::ToUInt16(System.UInt32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR uint16_t Convert_ToUInt16_m19D8F9B74EB5F96C835FA5045E925F000750A8B3 (uint32_t ___value0, const RuntimeMethod* method);
// System.UInt16 System.UInt32::System.IConvertible.ToUInt16(System.IFormatProvider)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR uint16_t UInt32_System_IConvertible_ToUInt16_mBEE9936EF6F5D9D150E507F28CDA17A8C1C92E1C (uint32_t* __this, RuntimeObject* ___provider0, const RuntimeMethod* method);
// System.Int32 System.Convert::ToInt32(System.UInt32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t Convert_ToInt32_m966337716B0CC4A45307D82BC21BCA1F8BB22D1C (uint32_t ___value0, const RuntimeMethod* method);
// System.Int32 System.UInt32::System.IConvertible.ToInt32(System.IFormatProvider)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t UInt32_System_IConvertible_ToInt32_mB0FCB9A9ACF700AAD49333618A4B819E24F0F0B9 (uint32_t* __this, RuntimeObject* ___provider0, const RuntimeMethod* method);
// System.UInt32 System.UInt32::System.IConvertible.ToUInt32(System.IFormatProvider)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR uint32_t UInt32_System_IConvertible_ToUInt32_m7F98AF966A31B1A315E7DFFEE3F2A68D48E690AF (uint32_t* __this, RuntimeObject* ___provider0, const RuntimeMethod* method);
// System.Int64 System.Convert::ToInt64(System.UInt32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int64_t Convert_ToInt64_m32144C3A1499C6810428CC3F22BCB095EFFEE99F (uint32_t ___value0, const RuntimeMethod* method);
// System.Int64 System.UInt32::System.IConvertible.ToInt64(System.IFormatProvider)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int64_t UInt32_System_IConvertible_ToInt64_m6E1441BF4C3D5FDFCAEEED65CFE96E6D9F08007B (uint32_t* __this, RuntimeObject* ___provider0, const RuntimeMethod* method);
// System.UInt64 System.Convert::ToUInt64(System.UInt32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR uint64_t Convert_ToUInt64_mC8F7AEA2A46B8BEB45B65312F49EEE2540B596EC (uint32_t ___value0, const RuntimeMethod* method);
// System.UInt64 System.UInt32::System.IConvertible.ToUInt64(System.IFormatProvider)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR uint64_t UInt32_System_IConvertible_ToUInt64_m659A2E594AAC8E26152B3EAAF1D80CECD2F43120 (uint32_t* __this, RuntimeObject* ___provider0, const RuntimeMethod* method);
// System.Single System.Convert::ToSingle(System.UInt32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR float Convert_ToSingle_m6F50A25E0020F35AEC587BE3A91E1A6D78351249 (uint32_t ___value0, const RuntimeMethod* method);
// System.Single System.UInt32::System.IConvertible.ToSingle(System.IFormatProvider)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR float UInt32_System_IConvertible_ToSingle_m2B438F2707D2FB9C8FDC6D79B263677FA3C37096 (uint32_t* __this, RuntimeObject* ___provider0, const RuntimeMethod* method);
// System.Double System.Convert::ToDouble(System.UInt32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR double Convert_ToDouble_mA48AAD04072EF9CD5A30C2B2EC69A796A0BA6194 (uint32_t ___value0, const RuntimeMethod* method);
// System.Double System.UInt32::System.IConvertible.ToDouble(System.IFormatProvider)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR double UInt32_System_IConvertible_ToDouble_m4A3EDEA2044FAA202D4ED3C81672CF0308FAE7E8 (uint32_t* __this, RuntimeObject* ___provider0, const RuntimeMethod* method);
// System.Decimal System.Convert::ToDecimal(System.UInt32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Decimal_t44EE9DA309A1BF848308DE4DDFC070CAE6D95EE8 Convert_ToDecimal_m291E4FE569EB911F06EF4269522C1DA0BEB7CB5F (uint32_t ___value0, const RuntimeMethod* method);
// System.Decimal System.UInt32::System.IConvertible.ToDecimal(System.IFormatProvider)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Decimal_t44EE9DA309A1BF848308DE4DDFC070CAE6D95EE8 UInt32_System_IConvertible_ToDecimal_m1C78EB4A4D9A092C050487129E0AE477ADBBE5A7 (uint32_t* __this, RuntimeObject* ___provider0, const RuntimeMethod* method);
// System.DateTime System.UInt32::System.IConvertible.ToDateTime(System.IFormatProvider)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR DateTime_t349B7449FBAAFF4192636E2B7A07694DA9236132 UInt32_System_IConvertible_ToDateTime_m450F7E1864FB6A396E9009116F8301B972DAE724 (uint32_t* __this, RuntimeObject* ___provider0, const RuntimeMethod* method);
// System.Object System.UInt32::System.IConvertible.ToType(System.Type,System.IFormatProvider)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * UInt32_System_IConvertible_ToType_mEFD4D7AB69CB399E6603ADA3EDDF10FC622E4A3A (uint32_t* __this, Type_t * ___type0, RuntimeObject* ___provider1, const RuntimeMethod* method);
// System.Int32 System.UInt64::CompareTo(System.Object)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t UInt64_CompareTo_mB5A28DD05266BC32BD6FD24A6659B0464FFA8950 (uint64_t* __this, RuntimeObject * ___value0, const RuntimeMethod* method);
// System.Int32 System.UInt64::CompareTo(System.UInt64)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t UInt64_CompareTo_m03A38257A9E54676839E92A530E8BB17D6A58873 (uint64_t* __this, uint64_t ___value0, const RuntimeMethod* method);
// System.Boolean System.UInt64::Equals(System.Object)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool UInt64_Equals_mE61D24B984F0B91A2FC1094402F1532A0F82C232 (uint64_t* __this, RuntimeObject * ___obj0, const RuntimeMethod* method);
// System.Boolean System.UInt64::Equals(System.UInt64)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool UInt64_Equals_m8C3B2C55776A9086B7F78F6A636F9B15B059F058 (uint64_t* __this, uint64_t ___obj0, const RuntimeMethod* method);
// System.Int32 System.UInt64::GetHashCode()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t UInt64_GetHashCode_mCBB4031BF70D0CBD023B4D71F4FEA37BE2C749AD (uint64_t* __this, const RuntimeMethod* method);
// System.String System.Number::FormatUInt64(System.UInt64,System.String,System.Globalization.NumberFormatInfo)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR String_t* Number_FormatUInt64_m04004F09D1913C13C59635153D0F45AF37F8248A (uint64_t ___value0, String_t* ___format1, NumberFormatInfo_tFDF57037EBC5BC833D0A53EF0327B805994860A8 * ___info2, const RuntimeMethod* method);
// System.String System.UInt64::ToString()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR String_t* UInt64_ToString_mF0E40B7459C207B89A1C8C04CE7F183AC0E6D672 (uint64_t* __this, const RuntimeMethod* method);
// System.String System.UInt64::ToString(System.IFormatProvider)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR String_t* UInt64_ToString_m6CBBC10ABBA0EE36F5E72F926A38F6CD7F497A55 (uint64_t* __this, RuntimeObject* ___provider0, const RuntimeMethod* method);
// System.String System.UInt64::ToString(System.String)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR String_t* UInt64_ToString_m46B46DBB5F74DCDC6082A8AC8C695E2295925E71 (uint64_t* __this, String_t* ___format0, const RuntimeMethod* method);
// System.String System.UInt64::ToString(System.String,System.IFormatProvider)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR String_t* UInt64_ToString_mF6F94603E535C161BBD87AC747A1F403C274E8CD (uint64_t* __this, String_t* ___format0, RuntimeObject* ___provider1, const RuntimeMethod* method);
// System.UInt64 System.Number::ParseUInt64(System.String,System.Globalization.NumberStyles,System.Globalization.NumberFormatInfo)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR uint64_t Number_ParseUInt64_m80F0E92F3D98C3390741451845F261F93A103E27 (String_t* ___value0, int32_t ___options1, NumberFormatInfo_tFDF57037EBC5BC833D0A53EF0327B805994860A8 * ___numfmt2, const RuntimeMethod* method);
// System.TypeCode System.UInt64::GetTypeCode()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t UInt64_GetTypeCode_m96414C98F5BEB1E6DD540B07EE96558CE9E313F4 (uint64_t* __this, const RuntimeMethod* method);
// System.Boolean System.Convert::ToBoolean(System.UInt64)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool Convert_ToBoolean_m545BC5397A9E121A21E4891E2A76A8C2B31D59D2 (uint64_t ___value0, const RuntimeMethod* method);
// System.Boolean System.UInt64::System.IConvertible.ToBoolean(System.IFormatProvider)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool UInt64_System_IConvertible_ToBoolean_mCDB7FA8F90588F8FDDF7F0CB26AF43651F9B3884 (uint64_t* __this, RuntimeObject* ___provider0, const RuntimeMethod* method);
// System.Char System.Convert::ToChar(System.UInt64)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Il2CppChar Convert_ToChar_mBFD88FBE8D41F3FEB4049B8EF556C2D996F5F531 (uint64_t ___value0, const RuntimeMethod* method);
// System.Char System.UInt64::System.IConvertible.ToChar(System.IFormatProvider)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Il2CppChar UInt64_System_IConvertible_ToChar_mBB0EEBDF5CB12C5CE93ECD9C39124D33F221A523 (uint64_t* __this, RuntimeObject* ___provider0, const RuntimeMethod* method);
// System.SByte System.Convert::ToSByte(System.UInt64)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int8_t Convert_ToSByte_m5F3E822A40FB8BC9DCE9D39C07D0BFDB5CAE38C3 (uint64_t ___value0, const RuntimeMethod* method);
// System.SByte System.UInt64::System.IConvertible.ToSByte(System.IFormatProvider)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int8_t UInt64_System_IConvertible_ToSByte_m6309BC2235A2F03BAE4107E9CCDF53604B9E7BB7 (uint64_t* __this, RuntimeObject* ___provider0, const RuntimeMethod* method);
// System.Byte System.Convert::ToByte(System.UInt64)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR uint8_t Convert_ToByte_mBA74300A0EBF60E75A3ABED4AA4AAB62DF40014A (uint64_t ___value0, const RuntimeMethod* method);
// System.Byte System.UInt64::System.IConvertible.ToByte(System.IFormatProvider)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR uint8_t UInt64_System_IConvertible_ToByte_m4F0E7D7E850AA40CE8FEE68B44B5FF29409CCB27 (uint64_t* __this, RuntimeObject* ___provider0, const RuntimeMethod* method);
// System.Int16 System.Convert::ToInt16(System.UInt64)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int16_t Convert_ToInt16_mC121EAEA7C8458D987480F1669C6A40082AA93C1 (uint64_t ___value0, const RuntimeMethod* method);
// System.Int16 System.UInt64::System.IConvertible.ToInt16(System.IFormatProvider)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int16_t UInt64_System_IConvertible_ToInt16_m6D785A19C7E04176E1B60131C70A965ABB427E20 (uint64_t* __this, RuntimeObject* ___provider0, const RuntimeMethod* method);
// System.UInt16 System.Convert::ToUInt16(System.UInt64)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR uint16_t Convert_ToUInt16_mC540754A3F101A7A13FB26FD89836025507E7E80 (uint64_t ___value0, const RuntimeMethod* method);
// System.UInt16 System.UInt64::System.IConvertible.ToUInt16(System.IFormatProvider)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR uint16_t UInt64_System_IConvertible_ToUInt16_m6B443639CDAEEDBE636A47EF6D07B045B51C2A51 (uint64_t* __this, RuntimeObject* ___provider0, const RuntimeMethod* method);
// System.Int32 System.Convert::ToInt32(System.UInt64)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t Convert_ToInt32_m4E8E4BA500C8372D58B20E706C76C8126F7F5260 (uint64_t ___value0, const RuntimeMethod* method);
// System.Int32 System.UInt64::System.IConvertible.ToInt32(System.IFormatProvider)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t UInt64_System_IConvertible_ToInt32_mBF342D7305B0F4643B8B2FB2EAC54F6B5C943746 (uint64_t* __this, RuntimeObject* ___provider0, const RuntimeMethod* method);
// System.UInt32 System.Convert::ToUInt32(System.UInt64)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR uint32_t Convert_ToUInt32_m7DC544C6EB3CA7920C82A243D9C387B462697BAC (uint64_t ___value0, const RuntimeMethod* method);
// System.UInt32 System.UInt64::System.IConvertible.ToUInt32(System.IFormatProvider)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR uint32_t UInt64_System_IConvertible_ToUInt32_mFF9B4ABD152C30CB4A9F09BAED4D197245141AF7 (uint64_t* __this, RuntimeObject* ___provider0, const RuntimeMethod* method);
// System.Int64 System.Convert::ToInt64(System.UInt64)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int64_t Convert_ToInt64_m396C2B4FA8F12D0C76E0AA3A31872D93BF5EA11D (uint64_t ___value0, const RuntimeMethod* method);
// System.Int64 System.UInt64::System.IConvertible.ToInt64(System.IFormatProvider)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int64_t UInt64_System_IConvertible_ToInt64_mFA654AF22149F693965B34C380C2FF61764D7BD4 (uint64_t* __this, RuntimeObject* ___provider0, const RuntimeMethod* method);
// System.UInt64 System.UInt64::System.IConvertible.ToUInt64(System.IFormatProvider)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR uint64_t UInt64_System_IConvertible_ToUInt64_m2D81AD0924E713479AACA50B8C236935A2315BB4 (uint64_t* __this, RuntimeObject* ___provider0, const RuntimeMethod* method);
// System.Single System.Convert::ToSingle(System.UInt64)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR float Convert_ToSingle_mEB588F7F980A4BF31BDBACC733574C97A32E357A (uint64_t ___value0, const RuntimeMethod* method);
// System.Single System.UInt64::System.IConvertible.ToSingle(System.IFormatProvider)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR float UInt64_System_IConvertible_ToSingle_m04A4372F398081E930044EEECC7B73B4686EE8F0 (uint64_t* __this, RuntimeObject* ___provider0, const RuntimeMethod* method);
// System.Double System.Convert::ToDouble(System.UInt64)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR double Convert_ToDouble_m18E2BC69DA3D88A0C5CD258FFBF1DB5BA097C316 (uint64_t ___value0, const RuntimeMethod* method);
// System.Double System.UInt64::System.IConvertible.ToDouble(System.IFormatProvider)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR double UInt64_System_IConvertible_ToDouble_mE29DD1148D7D94855DCB7CE8B4FC4B9424A00A82 (uint64_t* __this, RuntimeObject* ___provider0, const RuntimeMethod* method);
// System.Decimal System.Convert::ToDecimal(System.UInt64)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Decimal_t44EE9DA309A1BF848308DE4DDFC070CAE6D95EE8 Convert_ToDecimal_mC4A6FC31B0F2C506D113380567B082CCB6A4FEED (uint64_t ___value0, const RuntimeMethod* method);
// System.Decimal System.UInt64::System.IConvertible.ToDecimal(System.IFormatProvider)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Decimal_t44EE9DA309A1BF848308DE4DDFC070CAE6D95EE8 UInt64_System_IConvertible_ToDecimal_mFE274863205856F4B130AD096D6BC7E40AA65FC7 (uint64_t* __this, RuntimeObject* ___provider0, const RuntimeMethod* method);
// System.DateTime System.UInt64::System.IConvertible.ToDateTime(System.IFormatProvider)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR DateTime_t349B7449FBAAFF4192636E2B7A07694DA9236132 UInt64_System_IConvertible_ToDateTime_m1DE2B7B00676B061B66F18FCCC7CBC5D848B0EBA (uint64_t* __this, RuntimeObject* ___provider0, const RuntimeMethod* method);
// System.Object System.UInt64::System.IConvertible.ToType(System.Type,System.IFormatProvider)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * UInt64_System_IConvertible_ToType_m176FFA8FD3BDEAB82C5BD41CF3CF81C83AC21803 (uint64_t* __this, Type_t * ___type0, RuntimeObject* ___provider1, const RuntimeMethod* method);
// System.Void System.UIntPtr::.ctor(System.UInt32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void UIntPtr__ctor_m7DB6B4A7AE8195A45E5FB3FEBD2ECB4609D8C084 (uintptr_t* __this, uint32_t ___value0, const RuntimeMethod* method);
// System.Boolean System.UIntPtr::Equals(System.Object)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool UIntPtr_Equals_m8C135DEDA578597066AB67C1DD5A5A34E4F860EB (uintptr_t* __this, RuntimeObject * ___obj0, const RuntimeMethod* method);
// System.Int32 System.UIntPtr::GetHashCode()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t UIntPtr_GetHashCode_m713296172AF735B0CB68B60859FC8EE5B4840D5C (uintptr_t* __this, const RuntimeMethod* method);
// System.Int32 System.UIntPtr::get_Size()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t UIntPtr_get_Size_m063860D6F716C79EE77F379C6B20436413389E0B (const RuntimeMethod* method);
// System.String System.UIntPtr::ToString()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR String_t* UIntPtr_ToString_m1512332A1A79F9DA551731E9CA7F071A3C88043D (uintptr_t* __this, const RuntimeMethod* method);
// System.Void System.Runtime.Serialization.SerializationInfo::AddValue(System.String,System.UInt64)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void SerializationInfo_AddValue_m9861690C28AB414534D1A7F599E050DBA7A99303 (SerializationInfo_t1BB80E9C9DEA52DBF464487234B045E2930ADA26 * __this, String_t* ___name0, uint64_t ___value1, const RuntimeMethod* method);
// System.Void System.UIntPtr::System.Runtime.Serialization.ISerializable.GetObjectData(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void UIntPtr_System_Runtime_Serialization_ISerializable_GetObjectData_mB6B1C508A6E9BFD526F23A38634C1E703595B733 (uintptr_t* __this, SerializationInfo_t1BB80E9C9DEA52DBF464487234B045E2930ADA26 * ___info0, StreamingContext_t2CCDC54E0E8D078AF4A50E3A8B921B828A900034 ___context1, const RuntimeMethod* method);
// System.Void System.UnSafeCharBuffer::.ctor(System.Char*,System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void UnSafeCharBuffer__ctor_mF7AA675CC9B4BF79D4A8FD4EB7146CFFECEEB14D (UnSafeCharBuffer_t99F0962CE65E71C4BA612D5434276C51AC33AF0C * __this, Il2CppChar* ___buffer0, int32_t ___bufferSize1, const RuntimeMethod* method);
// System.Boolean System.String::IsNullOrEmpty(System.String)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool String_IsNullOrEmpty_m06A85A206AC2106D1982826C5665B9BD35324229 (String_t* ___value0, const RuntimeMethod* method);
// System.Void System.IndexOutOfRangeException::.ctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void IndexOutOfRangeException__ctor_m17448AB4B27BC9D8AEB4605CDB0EA053626ABEC1 (IndexOutOfRangeException_tEC7665FC66525AB6A6916A7EB505E5591683F0CF * __this, const RuntimeMethod* method);
// System.Int32 System.Runtime.CompilerServices.RuntimeHelpers::get_OffsetToStringData()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t RuntimeHelpers_get_OffsetToStringData_mF3B79A906181F1A2734590DA161E2AF183853F8B (const RuntimeMethod* method);
// System.Void System.Buffer::Memcpy(System.Byte*,System.Byte*,System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void Buffer_Memcpy_m4D475106A101E5ED38EB22776EAAFB6D02F63678 (uint8_t* ___dest0, uint8_t* ___src1, int32_t ___size2, const RuntimeMethod* method);
// System.Void System.UnSafeCharBuffer::AppendString(System.String)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void UnSafeCharBuffer_AppendString_m1E2967E285FC06FDE141B90EF186745D5D2814FE (UnSafeCharBuffer_t99F0962CE65E71C4BA612D5434276C51AC33AF0C * __this, String_t* ___stringToAppend0, const RuntimeMethod* method);
// System.Void System.EventArgs::.ctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EventArgs__ctor_m3551293259861C5A78CD47689D559F828ED29DF7 (EventArgs_t8E6CA180BE0E56674C6407011A94BAF7C757352E * __this, const RuntimeMethod* method);
// System.Void System.Runtime.Serialization.SerializationInfo::SetType(System.Type)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void SerializationInfo_SetType_m3F30AFEB3555E20E995D31713C0604E26B2CF784 (SerializationInfo_t1BB80E9C9DEA52DBF464487234B045E2930ADA26 * __this, Type_t * ___type0, const RuntimeMethod* method);
// System.Void System.Collections.Generic.List`1<System.Int32>::.ctor()
inline void List_1__ctor_mA7F9F92F641CEECFD9D8CFDC667568A05FFD27B4 (List_1_tE1526161A558A17A39A8B69D8EEF3801393B6226 * __this, const RuntimeMethod* method)
{
(( void (*) (List_1_tE1526161A558A17A39A8B69D8EEF3801393B6226 *, const RuntimeMethod*))List_1__ctor_mA7F9F92F641CEECFD9D8CFDC667568A05FFD27B4_gshared)(__this, method);
}
// System.Void System.Collections.Generic.List`1<System.Int32>::Add(T)
inline void List_1_Add_m50C0D1F69B2EF31137658E2F052EBBAC7BF82771 (List_1_tE1526161A558A17A39A8B69D8EEF3801393B6226 * __this, int32_t p0, const RuntimeMethod* method)
{
(( void (*) (List_1_tE1526161A558A17A39A8B69D8EEF3801393B6226 *, int32_t, const RuntimeMethod*))List_1_Add_m50C0D1F69B2EF31137658E2F052EBBAC7BF82771_gshared)(__this, p0, method);
}
// System.Boolean System.Type::get_IsArray()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool Type_get_IsArray_m0B4E20F93B1B34C0B5C4B089F543D1AA338DC9FE (Type_t * __this, const RuntimeMethod* method);
// System.Boolean System.Type::get_IsPointer()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool Type_get_IsPointer_mF823CB662C6A04674589640771E6AD6B71093E57 (Type_t * __this, const RuntimeMethod* method);
// System.Boolean System.Type::get_IsByRef()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool Type_get_IsByRef_m13C04A998C9B19058B596A81D188B368333D24F8 (Type_t * __this, const RuntimeMethod* method);
// System.Boolean System.Type::get_HasElementType()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool Type_get_HasElementType_m598BEFE66F168CE1D1132C87D394B2EF41F449BF (Type_t * __this, const RuntimeMethod* method);
// T[] System.Collections.Generic.List`1<System.Int32>::ToArray()
inline Int32U5BU5D_t2B9E4FDDDB9F0A00EC0AC631BA2DA915EB1ECF83* List_1_ToArray_mFEF088E03E18EF79C06317909C301876B3037D98 (List_1_tE1526161A558A17A39A8B69D8EEF3801393B6226 * __this, const RuntimeMethod* method)
{
return (( Int32U5BU5D_t2B9E4FDDDB9F0A00EC0AC631BA2DA915EB1ECF83* (*) (List_1_tE1526161A558A17A39A8B69D8EEF3801393B6226 *, const RuntimeMethod*))List_1_ToArray_mFEF088E03E18EF79C06317909C301876B3037D98_gshared)(__this, method);
}
// System.Type System.Type::GetRootElementType()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Type_t * Type_GetRootElementType_mE4F0579E18FAAEEB2DB86F1315BFBEC1A9A2FD56 (Type_t * __this, const RuntimeMethod* method);
// System.RuntimeType System.UnitySerializationHolder::AddElementTypes(System.Runtime.Serialization.SerializationInfo,System.RuntimeType)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeType_t40F13BCEAD97478C72C4B40BFDC2A220161CDB8F * UnitySerializationHolder_AddElementTypes_m0C8810EE3D2A09BD766FC74C37086846A0268D45 (SerializationInfo_t1BB80E9C9DEA52DBF464487234B045E2930ADA26 * ___info0, RuntimeType_t40F13BCEAD97478C72C4B40BFDC2A220161CDB8F * ___type1, const RuntimeMethod* method);
// System.Reflection.RuntimeAssembly System.RuntimeType::GetRuntimeAssembly()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeAssembly_t5EE9CD749D82345AE5635B9665665C31A3308EB1 * RuntimeType_GetRuntimeAssembly_m34E13B557A24CE6438916C08EC329EFD16AEBAE4 (RuntimeType_t40F13BCEAD97478C72C4B40BFDC2A220161CDB8F * __this, const RuntimeMethod* method);
// System.Void System.UnitySerializationHolder::GetUnitySerializationInfo(System.Runtime.Serialization.SerializationInfo,System.Int32,System.String,System.Reflection.RuntimeAssembly)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void UnitySerializationHolder_GetUnitySerializationInfo_m86F654140996546DB4D6D8228BF9FE45E9BAEC3E (SerializationInfo_t1BB80E9C9DEA52DBF464487234B045E2930ADA26 * ___info0, int32_t ___unityType1, String_t* ___data2, RuntimeAssembly_t5EE9CD749D82345AE5635B9665665C31A3308EB1 * ___assembly3, const RuntimeMethod* method);
// System.Void System.Runtime.Serialization.SerializationInfo::AddValue(System.String,System.Object)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void SerializationInfo_AddValue_mC9D1E16476E24E1AFE7C59368D3BC0B35F64FBC6 (SerializationInfo_t1BB80E9C9DEA52DBF464487234B045E2930ADA26 * __this, String_t* ___name0, RuntimeObject * ___value1, const RuntimeMethod* method);
// System.Object System.Runtime.Serialization.SerializationInfo::GetValue(System.String,System.Type)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * SerializationInfo_GetValue_m7910CE6C68888C1F863D7A35915391FA33463ECF (SerializationInfo_t1BB80E9C9DEA52DBF464487234B045E2930ADA26 * __this, String_t* ___name0, Type_t * ___type1, const RuntimeMethod* method);
// System.Void System.Runtime.Serialization.SerializationException::.ctor(System.String)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void SerializationException__ctor_m88AAD9671030A8A96AA87CB95701938FBD8F16E1 (SerializationException_tA1FDFF6779406E688C2192E71C38DBFD7A4A2210 * __this, String_t* ___message0, const RuntimeMethod* method);
// System.Type System.UnitySerializationHolder::MakeElementTypes(System.Type)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Type_t * UnitySerializationHolder_MakeElementTypes_m53847C6D77B4D1F96596279EBF443F521CAD7B24 (UnitySerializationHolder_t6B17ABB985ACD3F8D9F9E3C146DEA5F730E1CEAC * __this, Type_t * ___type0, const RuntimeMethod* method);
// System.Boolean System.Reflection.MethodBase::op_Equality(System.Reflection.MethodBase,System.Reflection.MethodBase)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool MethodBase_op_Equality_mB2519FFC5324C515ED0181B94A3FA5D6FE99D736 (MethodBase_t * ___left0, MethodBase_t * ___right1, const RuntimeMethod* method);
// System.Void System.UnitySerializationHolder::ThrowInsufficientInformation(System.String)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void UnitySerializationHolder_ThrowInsufficientInformation_mC9EC8B972B617DB4A56CC8BAF3B814ACF0E7A7EE (UnitySerializationHolder_t6B17ABB985ACD3F8D9F9E3C146DEA5F730E1CEAC * __this, String_t* ___field0, const RuntimeMethod* method);
// System.Boolean System.Reflection.MethodBase::op_Inequality(System.Reflection.MethodBase,System.Reflection.MethodBase)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool MethodBase_op_Inequality_mA03AE708DD0D76404AED7C36A75741E2A6BC6BF7 (MethodBase_t * ___left0, MethodBase_t * ___right1, const RuntimeMethod* method);
// System.Boolean System.Reflection.Module::op_Equality(System.Reflection.Module,System.Reflection.Module)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool Module_op_Equality_m3AEF6BCA2C1DA42DEF271D9C168AD6F5DFFA497A (Module_t882FB0C491B9CD194BE7CD1AC62FEFB31EEBE5D7 * ___left0, Module_t882FB0C491B9CD194BE7CD1AC62FEFB31EEBE5D7 * ___right1, const RuntimeMethod* method);
// System.Boolean System.ValueTuple::Equals(System.Object)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool ValueTuple_Equals_m0675CB3C2023AE4A3B1FEB34C87EFE2D6CAB081A (ValueTuple_tC6981F8FD1D7836C91BF332F5F894A8AEEF569D6 * __this, RuntimeObject * ___obj0, const RuntimeMethod* method);
// System.Boolean System.ValueTuple::Equals(System.ValueTuple)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool ValueTuple_Equals_m4576A8D4CABCAA6BEB3545919F384B2774FE3DFE (ValueTuple_tC6981F8FD1D7836C91BF332F5F894A8AEEF569D6 * __this, ValueTuple_tC6981F8FD1D7836C91BF332F5F894A8AEEF569D6 ___other0, const RuntimeMethod* method);
// System.Boolean System.ValueTuple::System.Collections.IStructuralEquatable.Equals(System.Object,System.Collections.IEqualityComparer)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool ValueTuple_System_Collections_IStructuralEquatable_Equals_m97AEC150FCB956B281470A28DBBE312ABE2B7021 (ValueTuple_tC6981F8FD1D7836C91BF332F5F894A8AEEF569D6 * __this, RuntimeObject * ___other0, RuntimeObject* ___comparer1, const RuntimeMethod* method);
// System.String SR::Format(System.String,System.Object)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR String_t* SR_Format_mCDBB594267CC224AB2A69540BBA598151F0642C7 (String_t* ___resourceFormat0, RuntimeObject * ___p11, const RuntimeMethod* method);
// System.Int32 System.ValueTuple::System.IComparable.CompareTo(System.Object)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t ValueTuple_System_IComparable_CompareTo_m6E4FCA0C1525C685EB58B41763A4A4D8F2CE5EF5 (ValueTuple_tC6981F8FD1D7836C91BF332F5F894A8AEEF569D6 * __this, RuntimeObject * ___other0, const RuntimeMethod* method);
// System.Int32 System.ValueTuple::CompareTo(System.ValueTuple)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t ValueTuple_CompareTo_mF2195A5F94A9E033D7083C3DBA9A53A79F5152E4 (ValueTuple_tC6981F8FD1D7836C91BF332F5F894A8AEEF569D6 * __this, ValueTuple_tC6981F8FD1D7836C91BF332F5F894A8AEEF569D6 ___other0, const RuntimeMethod* method);
// System.Int32 System.ValueTuple::System.Collections.IStructuralComparable.CompareTo(System.Object,System.Collections.IComparer)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t ValueTuple_System_Collections_IStructuralComparable_CompareTo_mC5A3E5494E6AE2CEBA28F16A2324F69E8E7E1061 (ValueTuple_tC6981F8FD1D7836C91BF332F5F894A8AEEF569D6 * __this, RuntimeObject * ___other0, RuntimeObject* ___comparer1, const RuntimeMethod* method);
// System.Int32 System.ValueTuple::GetHashCode()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t ValueTuple_GetHashCode_m7A07476547357BDE782FF7DD4C019EA1C2548160 (ValueTuple_tC6981F8FD1D7836C91BF332F5F894A8AEEF569D6 * __this, const RuntimeMethod* method);
// System.Int32 System.ValueTuple::System.Collections.IStructuralEquatable.GetHashCode(System.Collections.IEqualityComparer)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t ValueTuple_System_Collections_IStructuralEquatable_GetHashCode_m81B8DE52207DAF266AE2D68455F079FB8DD3220B (ValueTuple_tC6981F8FD1D7836C91BF332F5F894A8AEEF569D6 * __this, RuntimeObject* ___comparer0, const RuntimeMethod* method);
// System.String System.ValueTuple::ToString()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR String_t* ValueTuple_ToString_mBF8C414E974C2EAA15E250F90E6B50993AAA1B2D (ValueTuple_tC6981F8FD1D7836C91BF332F5F894A8AEEF569D6 * __this, const RuntimeMethod* method);
// System.Int32 System.Numerics.Hashing.HashHelpers::Combine(System.Int32,System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t HashHelpers_Combine_mC0A377FAA2E385A438B50076FF85AAE6C17B6C33 (int32_t ___h10, int32_t ___h21, const RuntimeMethod* method);
// System.Boolean System.ValueType::InternalEquals(System.Object,System.Object,System.Object[]&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool ValueType_InternalEquals_m09E6AB0EC85DC2C65928B946609823DBB90CF59D (RuntimeObject * ___o10, RuntimeObject * ___o21, ObjectU5BU5D_t3C9242B5C88A48B2A5BD9FDA6CD0024E792AF08A** ___fields2, const RuntimeMethod* method);
// System.Boolean System.ValueType::DefaultEquals(System.Object,System.Object)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool ValueType_DefaultEquals_m139582CD1BAD7472B45D806F76E4E14E82E629DB (RuntimeObject * ___o10, RuntimeObject * ___o21, const RuntimeMethod* method);
// System.Int32 System.ValueType::InternalGetHashCode(System.Object,System.Object[]&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t ValueType_InternalGetHashCode_mDB37E320BD3CA801CB06E1A4CBD088D8C7F0678A (RuntimeObject * ___o0, ObjectU5BU5D_t3C9242B5C88A48B2A5BD9FDA6CD0024E792AF08A** ___fields1, const RuntimeMethod* method);
// System.Void System.Runtime.InteropServices.Marshal::FreeBSTR(System.IntPtr)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void Marshal_FreeBSTR_mB3CD149620B05C68BBC20931307564BADDE71A25 (intptr_t ___ptr0, const RuntimeMethod* method);
// System.Boolean System.IntPtr::op_Inequality(System.IntPtr,System.IntPtr)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool IntPtr_op_Inequality_mB4886A806009EA825EFCC60CD2A7F6EB8E273A61 (intptr_t ___value10, intptr_t ___value21, const RuntimeMethod* method);
// System.Int32 System.Runtime.InteropServices.Marshal::Release(System.IntPtr)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t Marshal_Release_mF0676E7B6EE181109020F407F09E1063D681B5F8 (intptr_t ___pUnk0, const RuntimeMethod* method);
// System.Void System.Variant::Clear()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void Variant_Clear_m7622B0C52C7794CC4C33434D2ED8170ECDDE5DAF (Variant_tBC94A369178CDE161E918F24FD18166A3DC58C18 * __this, const RuntimeMethod* method);
// System.Void System.ArgumentOutOfRangeException::.ctor(System.String,System.String)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void ArgumentOutOfRangeException__ctor_m300CE4D04A068C209FD858101AC361C1B600B5AE (ArgumentOutOfRangeException_t94D19DF918A54511AEDF4784C9A08741BAD1DEDA * __this, String_t* ___paramName0, String_t* ___message1, const RuntimeMethod* method);
// System.Void System.Version::.ctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void Version__ctor_m2033F9EE96782C92B9978E42BB4EAEF240950B51 (Version_tDBE6876C59B6F56D4F8CAA03851177ABC6FE0DFD * __this, const RuntimeMethod* method);
// System.Boolean System.Version::op_Equality(System.Version,System.Version)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool Version_op_Equality_m9E4E82DB85F13E3C19AB5D4AF94C4F399971374D (Version_tDBE6876C59B6F56D4F8CAA03851177ABC6FE0DFD * ___v10, Version_tDBE6876C59B6F56D4F8CAA03851177ABC6FE0DFD * ___v21, const RuntimeMethod* method);
// System.String System.Version::ToString(System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR String_t* Version_ToString_m8B385B5C25D9FD3A25EE2DDF02B592CAFC1C0AB0 (Version_tDBE6876C59B6F56D4F8CAA03851177ABC6FE0DFD * __this, int32_t ___fieldCount0, const RuntimeMethod* method);
// System.String System.Int32::ToString()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR String_t* Int32_ToString_m1863896DE712BF97C031D55B12E1583F1982DC02 (int32_t* __this, const RuntimeMethod* method);
// System.Text.StringBuilder System.Text.StringBuilderCache::Acquire(System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR StringBuilder_t * StringBuilderCache_Acquire_mCA3DDB17F0BFEF32DA9B4D7E8501D5705890557D (int32_t ___capacity0, const RuntimeMethod* method);
// System.Void System.Version::AppendPositiveNumber(System.Int32,System.Text.StringBuilder)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void Version_AppendPositiveNumber_mEDCCE1D1AC63EE1F509538B86EA00A698A9D7C98 (int32_t ___num0, StringBuilder_t * ___sb1, const RuntimeMethod* method);
// System.String System.Text.StringBuilderCache::GetStringAndRelease(System.Text.StringBuilder)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR String_t* StringBuilderCache_GetStringAndRelease_mDD5B8378FE9378CACF8660EB460E0CE545F215F7 (StringBuilder_t * ___sb0, const RuntimeMethod* method);
// System.Int32 System.Text.StringBuilder::get_Length()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t StringBuilder_get_Length_m44BCD2BF32D45E9376761FF33AA429BFBD902F07 (StringBuilder_t * __this, const RuntimeMethod* method);
// System.Text.StringBuilder System.Text.StringBuilder::Insert(System.Int32,System.Char)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR StringBuilder_t * StringBuilder_Insert_m5A00CEB69C56B823E3766C84114D8B8ACCFC67A1 (StringBuilder_t * __this, int32_t ___index0, Il2CppChar ___value1, const RuntimeMethod* method);
// System.Boolean System.Version::Equals(System.Version)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool Version_Equals_m7C93B95F0594CB28E1B1C96936B03069BF8968D3 (Version_tDBE6876C59B6F56D4F8CAA03851177ABC6FE0DFD * __this, Version_tDBE6876C59B6F56D4F8CAA03851177ABC6FE0DFD * ___obj0, const RuntimeMethod* method);
// System.Runtime.InteropServices.GCHandle System.Runtime.InteropServices.GCHandle::Alloc(System.Object,System.Runtime.InteropServices.GCHandleType)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR GCHandle_t39FAEE3EA592432C93B574A31DD83B87F1847DE3 GCHandle_Alloc_m30DAF14F75E3A692C594965CE6724E2454DE9A2E (RuntimeObject * ___value0, int32_t ___type1, const RuntimeMethod* method);
// System.Void System.WeakReference::.ctor(System.Object,System.Boolean)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void WeakReference__ctor_m55A06AD20FF65C11015FFBE5FF31F2E7B1656E20 (WeakReference_t0495CC81CD6403E662B7700B802443F6F730E39D * __this, RuntimeObject * ___target0, bool ___trackResurrection1, const RuntimeMethod* method);
// System.Void System.WeakReference::AllocateHandle(System.Object)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void WeakReference_AllocateHandle_m116757CBF336A309363C5F2DFE13A2E426368780 (WeakReference_t0495CC81CD6403E662B7700B802443F6F730E39D * __this, RuntimeObject * ___target0, const RuntimeMethod* method);
// System.Boolean System.Runtime.Serialization.SerializationInfo::GetBoolean(System.String)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool SerializationInfo_GetBoolean_m5CAA35E19A152535A5481502BEDBC7A0E276E455 (SerializationInfo_t1BB80E9C9DEA52DBF464487234B045E2930ADA26 * __this, String_t* ___name0, const RuntimeMethod* method);
// System.Boolean System.Runtime.InteropServices.GCHandle::get_IsAllocated()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool GCHandle_get_IsAllocated_m91323BCB568B1150F90515EF862B00F193E77808 (GCHandle_t39FAEE3EA592432C93B574A31DD83B87F1847DE3 * __this, const RuntimeMethod* method);
// System.Object System.Runtime.InteropServices.GCHandle::get_Target()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * GCHandle_get_Target_mDBDEA6883245CF1EF963D9FA945569B2D59DCCF8 (GCHandle_t39FAEE3EA592432C93B574A31DD83B87F1847DE3 * __this, const RuntimeMethod* method);
// System.Void System.Runtime.InteropServices.GCHandle::Free()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void GCHandle_Free_m392ECC9B1058E35A0FD5CF21A65F212873FC26F0 (GCHandle_t39FAEE3EA592432C93B574A31DD83B87F1847DE3 * __this, const RuntimeMethod* method);
// System.Void System.Object::Finalize()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void Object_Finalize_m4015B7D3A44DE125C5FE34D7276CD4697C06F380 (RuntimeObject * __this, const RuntimeMethod* method);
// System.Void System.Runtime.Serialization.SerializationInfo::AddValue(System.String,System.Boolean)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void SerializationInfo_AddValue_m1229CE68F507974EBA0DA9C7C728A09E611D18B1 (SerializationInfo_t1BB80E9C9DEA52DBF464487234B045E2930ADA26 * __this, String_t* ___name0, bool ___value1, const RuntimeMethod* method);
// System.IntPtr System.WindowsConsoleDriver::GetStdHandle(System.Handles)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR intptr_t WindowsConsoleDriver_GetStdHandle_m411672A3E27D4266E946FF166C9DA279A75B3FB5 (int32_t ___handle0, const RuntimeMethod* method);
// System.Boolean System.WindowsConsoleDriver::GetConsoleScreenBufferInfo(System.IntPtr,System.ConsoleScreenBufferInfo&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool WindowsConsoleDriver_GetConsoleScreenBufferInfo_m0DF841B5A1BF2651A1D9BFEA3D61280110461C80 (intptr_t ___handle0, ConsoleScreenBufferInfo_tA8045B7C44EF25956D3B0847F24465E9CF18954F * ___info1, const RuntimeMethod* method);
// System.Boolean System.WindowsConsoleDriver::ReadConsoleInput(System.IntPtr,System.InputRecord&,System.Int32,System.Int32&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool WindowsConsoleDriver_ReadConsoleInput_mAA31A86190A2F7B76CD7205DCE7C2743E7C8AAA2 (intptr_t ___handle0, InputRecord_tAB007C739F339BE208F3C4796B53E9044ADF0A78 * ___record1, int32_t ___length2, int32_t* ___nread3, const RuntimeMethod* method);
// System.Int32 System.Runtime.InteropServices.Marshal::GetLastWin32Error()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t Marshal_GetLastWin32Error_mE1A714E69515F70001BA6714077880530257AEC7 (const RuntimeMethod* method);
// System.String System.String::Concat(System.Object,System.Object)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR String_t* String_Concat_mBB19C73816BDD1C3519F248E1ADC8E11A6FDB495 (RuntimeObject * ___arg00, RuntimeObject * ___arg11, const RuntimeMethod* method);
// System.Void System.InvalidOperationException::.ctor(System.String)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706 (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * __this, String_t* ___message0, const RuntimeMethod* method);
// System.Boolean System.WindowsConsoleDriver::IsModifierKey(System.Int16)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool WindowsConsoleDriver_IsModifierKey_mCBF637C09E9D2BD063E44FA5C8B8D2E317C4A1AE (int16_t ___virtualKeyCode0, const RuntimeMethod* method);
// System.Void System.ConsoleKeyInfo::.ctor(System.Char,System.ConsoleKey,System.Boolean,System.Boolean,System.Boolean)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void ConsoleKeyInfo__ctor_mF5F427F75CCD5D4BCAADCE6AE31F61D70BD95B98 (ConsoleKeyInfo_t5BE3CE05E8258CDB5404256E96AF7C22BC5DE768 * __this, Il2CppChar ___keyChar0, int32_t ___key1, bool ___shift2, bool ___alt3, bool ___control4, const RuntimeMethod* method);
// System.Void System.NotSupportedException::.ctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void NotSupportedException__ctor_mA121DE1CAC8F25277DEB489DC7771209D91CAE33 (NotSupportedException_tE75B318D6590A02A5D9B29FD97409B1750FA0010 * __this, const RuntimeMethod* method);
// System.Void System.__DTString::.ctor(System.String,System.Globalization.DateTimeFormatInfo)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void __DTString__ctor_mE5FC300B73DE2B23E51414546030AF8625D1109E (__DTString_t6E7DE2A99E4F15F384EC29CC6CD5185F46818DD9 * __this, String_t* ___str0, DateTimeFormatInfo_tF4BB3AA482C2F772D2A9022F78BF8727830FAF5F * ___dtfi1, const RuntimeMethod* method);
// System.Void System.__DTString::.ctor(System.String,System.Globalization.DateTimeFormatInfo,System.Boolean)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void __DTString__ctor_m9E9D21ACAC80CD2A8935D885767A9D7320A78FCF (__DTString_t6E7DE2A99E4F15F384EC29CC6CD5185F46818DD9 * __this, String_t* ___str0, DateTimeFormatInfo_tF4BB3AA482C2F772D2A9022F78BF8727830FAF5F * ___dtfi1, bool ___checkDigitToken2, const RuntimeMethod* method);
// System.Globalization.CompareInfo System.Globalization.DateTimeFormatInfo::get_CompareInfo()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR CompareInfo_tB9A071DBC11AC00AF2EA2066D0C2AE1DCB1865D1 * DateTimeFormatInfo_get_CompareInfo_mD70321935C290535664E8821CBE0D304580230C8 (DateTimeFormatInfo_tF4BB3AA482C2F772D2A9022F78BF8727830FAF5F * __this, const RuntimeMethod* method);
// System.Globalization.DateTimeFormatFlags System.Globalization.DateTimeFormatInfo::get_FormatFlags()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t DateTimeFormatInfo_get_FormatFlags_m42B106A8C2AC470D425032034608045AABB71731 (DateTimeFormatInfo_tF4BB3AA482C2F772D2A9022F78BF8727830FAF5F * __this, const RuntimeMethod* method);
// System.Threading.Thread System.Threading.Thread::get_CurrentThread()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Thread_tF60E0A146CD3B5480CB65FF9B6016E84C5460CC7 * Thread_get_CurrentThread_mB7A83CAE2B9A74CEA053196DFD1AF1E7AB30A70E (const RuntimeMethod* method);
// System.Globalization.CultureInfo System.Threading.Thread::get_CurrentCulture()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR CultureInfo_t345AC6924134F039ED9A11F3E03F8E91B6A3225F * Thread_get_CurrentCulture_m97A15448A16FB3B5EC1E21A0538C9FC1F84AEE66 (Thread_tF60E0A146CD3B5480CB65FF9B6016E84C5460CC7 * __this, const RuntimeMethod* method);
// System.Globalization.CompareInfo System.__DTString::get_CompareInfo()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR CompareInfo_tB9A071DBC11AC00AF2EA2066D0C2AE1DCB1865D1 * __DTString_get_CompareInfo_mE0381FC6A1AB82E0BDAF45F848568124B193FB51 (__DTString_t6E7DE2A99E4F15F384EC29CC6CD5185F46818DD9 * __this, const RuntimeMethod* method);
// System.Boolean System.__DTString::GetNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool __DTString_GetNext_mA99D360775F54B38E339C68D2E6007B7E028E1A3 (__DTString_t6E7DE2A99E4F15F384EC29CC6CD5185F46818DD9 * __this, const RuntimeMethod* method);
// System.Boolean System.__DTString::AtEnd()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool __DTString_AtEnd_mE89AB87FFD62B3BA1D1E5B30052947890000EADC (__DTString_t6E7DE2A99E4F15F384EC29CC6CD5185F46818DD9 * __this, const RuntimeMethod* method);
// System.Boolean System.__DTString::Advance(System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool __DTString_Advance_m6CAEF5CE3C7B57CBBDA5E0F5A391F6517C3791CC (__DTString_t6E7DE2A99E4F15F384EC29CC6CD5185F46818DD9 * __this, int32_t ___count0, const RuntimeMethod* method);
// System.Boolean System.DateTimeParse::IsDigit(System.Char)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool DateTimeParse_IsDigit_mCC840BC9EC5E157F967F148BC12F6A815E75B74A (Il2CppChar ___ch0, const RuntimeMethod* method);
// System.Boolean System.Globalization.DateTimeFormatInfo::Tokenize(System.TokenType,System.TokenType&,System.Int32&,System.__DTString&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool DateTimeFormatInfo_Tokenize_m47644B9B55F1919470E65677B3C8C5573E606217 (DateTimeFormatInfo_tF4BB3AA482C2F772D2A9022F78BF8727830FAF5F * __this, int32_t ___TokenMask0, int32_t* ___tokenType1, int32_t* ___tokenValue2, __DTString_t6E7DE2A99E4F15F384EC29CC6CD5185F46818DD9 * ___str3, const RuntimeMethod* method);
// System.Void System.__DTString::GetRegularToken(System.TokenType&,System.Int32&,System.Globalization.DateTimeFormatInfo)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void __DTString_GetRegularToken_mD79E9337E33F2F9535DD89437EEDC2AF3F5A0B39 (__DTString_t6E7DE2A99E4F15F384EC29CC6CD5185F46818DD9 * __this, int32_t* ___tokenType0, int32_t* ___tokenValue1, DateTimeFormatInfo_tF4BB3AA482C2F772D2A9022F78BF8727830FAF5F * ___dtfi2, const RuntimeMethod* method);
// System.Boolean System.__DTString::SkipWhiteSpaceCurrent()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool __DTString_SkipWhiteSpaceCurrent_m85EF1DCFFB216A209FEB3CC53CB8E977C51D71DB (__DTString_t6E7DE2A99E4F15F384EC29CC6CD5185F46818DD9 * __this, const RuntimeMethod* method);
// System.TokenType System.__DTString::GetSeparatorToken(System.Globalization.DateTimeFormatInfo,System.Int32&,System.Char&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t __DTString_GetSeparatorToken_m2F4CE10AC9C39A5380D3DD5344B81F79C7006EF1 (__DTString_t6E7DE2A99E4F15F384EC29CC6CD5185F46818DD9 * __this, DateTimeFormatInfo_tF4BB3AA482C2F772D2A9022F78BF8727830FAF5F * ___dtfi0, int32_t* ___indexBeforeSeparator1, Il2CppChar* ___charBeforeSeparator2, const RuntimeMethod* method);
// System.Boolean System.__DTString::MatchSpecifiedWord(System.String,System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool __DTString_MatchSpecifiedWord_m6399788FF78434EAD2231A2A7509B580EFED33B5 (__DTString_t6E7DE2A99E4F15F384EC29CC6CD5185F46818DD9 * __this, String_t* ___target0, int32_t ___endIndex1, const RuntimeMethod* method);
// System.Boolean System.__DTString::MatchSpecifiedWord(System.String)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool __DTString_MatchSpecifiedWord_m6B53744885B818B053CFE143A6AD0F778D617410 (__DTString_t6E7DE2A99E4F15F384EC29CC6CD5185F46818DD9 * __this, String_t* ___target0, const RuntimeMethod* method);
// System.Int32 System.String::IndexOfAny(System.Char[],System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t String_IndexOfAny_m30470EE6951771AE5E897773C8FC233DADBAE301 (String_t* __this, CharU5BU5D_t4CC6ABF0AD71BEC97E3C2F1E9C5677E46D3A75C2* ___anyOf0, int32_t ___startIndex1, const RuntimeMethod* method);
// System.Boolean System.Char::IsLetter(System.Char)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool Char_IsLetter_mCC7F387F16C2DE7C85B6A1A0C5BC75D92A813DFE (Il2CppChar ___c0, const RuntimeMethod* method);
// System.Boolean System.__DTString::MatchSpecifiedWords(System.String,System.Boolean,System.Int32&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool __DTString_MatchSpecifiedWords_mAD172D28B54FDBB34D5E8C8F92CB6C8B0EECDBA0 (__DTString_t6E7DE2A99E4F15F384EC29CC6CD5185F46818DD9 * __this, String_t* ___target0, bool ___checkWordBoundary1, int32_t* ___matchLength2, const RuntimeMethod* method);
// System.Boolean System.__DTString::Match(System.String)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool __DTString_Match_m6E1CE300661D15D140D2FAC5C54E74BDBE70EE19 (__DTString_t6E7DE2A99E4F15F384EC29CC6CD5185F46818DD9 * __this, String_t* ___str0, const RuntimeMethod* method);
// System.Boolean System.__DTString::Match(System.Char)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool __DTString_Match_mC0335DA3DE8A7B7F93781B52A02655B6889E01B3 (__DTString_t6E7DE2A99E4F15F384EC29CC6CD5185F46818DD9 * __this, Il2CppChar ___ch0, const RuntimeMethod* method);
// System.Int32 System.__DTString::MatchLongestWords(System.String[],System.Int32&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t __DTString_MatchLongestWords_mCEDB8993665810AAB06045D6EFF076B89572C4BF (__DTString_t6E7DE2A99E4F15F384EC29CC6CD5185F46818DD9 * __this, StringU5BU5D_t933FB07893230EA91C40FF900D5400665E87B14E* ___words0, int32_t* ___maxMatchStrLen1, const RuntimeMethod* method);
// System.Int32 System.__DTString::GetRepeatCount()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t __DTString_GetRepeatCount_m115C785C62A5A67CE2BCEA6789CA89BA5B0A97B5 (__DTString_t6E7DE2A99E4F15F384EC29CC6CD5185F46818DD9 * __this, const RuntimeMethod* method);
// System.Boolean System.__DTString::GetNextDigit()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool __DTString_GetNextDigit_mE662D3828A0E0648E24F62FC5D750DA554364EFB (__DTString_t6E7DE2A99E4F15F384EC29CC6CD5185F46818DD9 * __this, const RuntimeMethod* method);
// System.Char System.__DTString::GetChar()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Il2CppChar __DTString_GetChar_m15E6D62E27D5EC6E7E726D2E6A719A95A521CAE6 (__DTString_t6E7DE2A99E4F15F384EC29CC6CD5185F46818DD9 * __this, const RuntimeMethod* method);
// System.Int32 System.__DTString::GetDigit()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t __DTString_GetDigit_m0A4FC9D7AA54648B77398FAF7997FF7FED3694BF (__DTString_t6E7DE2A99E4F15F384EC29CC6CD5185F46818DD9 * __this, const RuntimeMethod* method);
// System.Void System.__DTString::SkipWhiteSpaces()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void __DTString_SkipWhiteSpaces_mB4AA5270916EF04CD52A4F3C16B1FB08D0B0CF4F (__DTString_t6E7DE2A99E4F15F384EC29CC6CD5185F46818DD9 * __this, const RuntimeMethod* method);
// System.Void System.__DTString::TrimTail()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void __DTString_TrimTail_m23E23486D88B86A755B551A9881F1FDA9D6DD99A (__DTString_t6E7DE2A99E4F15F384EC29CC6CD5185F46818DD9 * __this, const RuntimeMethod* method);
// System.String System.String::Remove(System.Int32,System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR String_t* String_Remove_m54FD37F2B9CA7DBFE440B0CB8503640A2CFF00FF (String_t* __this, int32_t ___startIndex0, int32_t ___count1, const RuntimeMethod* method);
// System.Void System.__DTString::RemoveTrailingInQuoteSpaces()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void __DTString_RemoveTrailingInQuoteSpaces_m18A5B81964E3027BF02B1393CCD7781AB3ECA72F (__DTString_t6E7DE2A99E4F15F384EC29CC6CD5185F46818DD9 * __this, const RuntimeMethod* method);
// System.Void System.__DTString::RemoveLeadingInQuoteSpaces()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void __DTString_RemoveLeadingInQuoteSpaces_m71E36820EEC9E50FFC1FA2F53FCFA3495EB2BC19 (__DTString_t6E7DE2A99E4F15F384EC29CC6CD5185F46818DD9 * __this, const RuntimeMethod* method);
// System.DTSubString System.__DTString::GetSubString()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR DTSubString_t0B5F9998AD0833CCE29248DE20EFEBFE9EBFB93D __DTString_GetSubString_m699C79DE88DFBC0BDD9F85C2CDC155ABB1473DC4 (__DTString_t6E7DE2A99E4F15F384EC29CC6CD5185F46818DD9 * __this, const RuntimeMethod* method);
// System.Void System.__DTString::ConsumeSubString(System.DTSubString)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void __DTString_ConsumeSubString_mDFAADAA4A5FC450399046DB04CE10A4503961FAA (__DTString_t6E7DE2A99E4F15F384EC29CC6CD5185F46818DD9 * __this, DTSubString_t0B5F9998AD0833CCE29248DE20EFEBFE9EBFB93D ___sub0, const RuntimeMethod* method);
// System.Void System.Reflection.InvalidFilterCriteriaException::.ctor(System.String)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InvalidFilterCriteriaException__ctor_m8A7E7373F5BFA58916AA7A8D99E49AA3C6861031 (InvalidFilterCriteriaException_tB11C87F151CD79ACA0837773B9BFD8791CA715BA * __this, String_t* ___message0, const RuntimeMethod* method);
// System.Int32 System.String::LastIndexOf(System.Char)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t String_LastIndexOf_m76C37E3915E802044761572007B8FB0635995F59 (String_t* __this, Il2CppChar ___value0, const RuntimeMethod* method);
// System.Boolean System.String::StartsWith(System.String,System.StringComparison)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool String_StartsWith_m844A95C9A205A0F951B0C45634E0C222E73D0B49 (String_t* __this, String_t* ___value0, int32_t ___comparisonType1, const RuntimeMethod* method);
// System.Boolean System.String::Equals(System.String)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool String_Equals_m9C4D78DFA0979504FE31429B64A4C26DF48020D1 (String_t* __this, String_t* ___value0, const RuntimeMethod* method);
// System.Int32 System.String::Compare(System.String,System.Int32,System.String,System.Int32,System.Int32,System.StringComparison)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t String_Compare_m208E4853037D81DD5C91DCA060C339DADC3A6064 (String_t* ___strA0, int32_t ___indexA1, String_t* ___strB2, int32_t ___indexB3, int32_t ___length4, int32_t ___comparisonType5, const RuntimeMethod* method);
// System.Int32 System.String::Compare(System.String,System.String,System.StringComparison)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t String_Compare_m5BD1EF8904C9B13BEDB7A876B122F117B317B442 (String_t* ___strA0, String_t* ___strB1, int32_t ___comparisonType2, const RuntimeMethod* method);
// System.Void System.__Filters::.ctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void __Filters__ctor_mA9DEA9B853B953C85A78E101A8001E9EE0E66B35 (__Filters_tDD9D6B7C7A31B12AB3D5CCF1B115DD693F62DB34 * __this, const RuntimeMethod* method);
// System.Void System.__Il2CppComObject::Finalize()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void __Il2CppComObject_Finalize_m98123DBAAA7974D2616F9E90F2574955714CA9A9 (Il2CppComObject * __this, const RuntimeMethod* method);
// System.Void System.PlatformNotSupportedException::.ctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void PlatformNotSupportedException__ctor_m651139B17C9EE918551490BC675754EA8EA3E7C7 (PlatformNotSupportedException_t14FE109377F8FA8B3B2F9A0C4FE3BF10662C73B5 * __this, const RuntimeMethod* method);
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.TypeIdentifier System.TypeIdentifiers::FromDisplay(System.String)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject* TypeIdentifiers_FromDisplay_m08FB8BE03D80603F9A030774E218310DC96693CE (String_t* ___displayName0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (TypeIdentifiers_FromDisplay_m08FB8BE03D80603F9A030774E218310DC96693CE_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
String_t* L_0 = ___displayName0;
Display_t0222D7CB4CF0F85131FC5E26328FE94E0A27F5E5 * L_1 = (Display_t0222D7CB4CF0F85131FC5E26328FE94E0A27F5E5 *)il2cpp_codegen_object_new(Display_t0222D7CB4CF0F85131FC5E26328FE94E0A27F5E5_il2cpp_TypeInfo_var);
Display__ctor_mA1C635B551554AB64CB2761AE4343A7AAC521D86(L_1, L_0, /*hidden argument*/NULL);
return L_1;
}
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.TypeIdentifiers_Display::.ctor(System.String)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void Display__ctor_mA1C635B551554AB64CB2761AE4343A7AAC521D86 (Display_t0222D7CB4CF0F85131FC5E26328FE94E0A27F5E5 * __this, String_t* ___displayName0, const RuntimeMethod* method)
{
{
ATypeName__ctor_mB865CB8CFBAD77532030E15AB4DF856DB368D307(__this, /*hidden argument*/NULL);
String_t* L_0 = ___displayName0;
__this->set_displayName_0(L_0);
__this->set_internal_name_1((String_t*)NULL);
return;
}
}
// System.String System.TypeIdentifiers_Display::get_DisplayName()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR String_t* Display_get_DisplayName_mCD0C3FDAAF471D36D084773212A470AA9A69AF53 (Display_t0222D7CB4CF0F85131FC5E26328FE94E0A27F5E5 * __this, const RuntimeMethod* method)
{
{
String_t* L_0 = __this->get_displayName_0();
return L_0;
}
}
// System.String System.TypeIdentifiers_Display::get_InternalName()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR String_t* Display_get_InternalName_m3A89FAAFE48B379CC563243F0DD2FFC5253D86D8 (Display_t0222D7CB4CF0F85131FC5E26328FE94E0A27F5E5 * __this, const RuntimeMethod* method)
{
{
String_t* L_0 = __this->get_internal_name_1();
if (L_0)
{
goto IL_0014;
}
}
{
String_t* L_1 = Display_GetInternalName_m9B890BB08D3AE39E9CF2AAF14D5F33C759CC6C36(__this, /*hidden argument*/NULL);
__this->set_internal_name_1(L_1);
}
IL_0014:
{
String_t* L_2 = __this->get_internal_name_1();
return L_2;
}
}
// System.String System.TypeIdentifiers_Display::GetInternalName()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR String_t* Display_GetInternalName_m9B890BB08D3AE39E9CF2AAF14D5F33C759CC6C36 (Display_t0222D7CB4CF0F85131FC5E26328FE94E0A27F5E5 * __this, const RuntimeMethod* method)
{
{
String_t* L_0 = __this->get_displayName_0();
String_t* L_1 = TypeSpec_UnescapeInternalName_m7B3F1C73984FAF9159F89F62C97AF144EDC4347E(L_0, /*hidden argument*/NULL);
return L_1;
}
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.TypeInitializationException::.ctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void TypeInitializationException__ctor_mAF515ADEF54825D8F19E8773B04D49CA1EEAA4A2 (TypeInitializationException_t5223A07113C97D6DC875A82C68D4C132737ADEAE * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (TypeInitializationException__ctor_mAF515ADEF54825D8F19E8773B04D49CA1EEAA4A2_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
String_t* L_0 = Environment_GetResourceString_m2C75C2AF268F01E2BF34AD1C2E1352CF4BA51AD9(_stringLiteralEF78999D7670EEBB7B9C4D640E261383DD2C6094, /*hidden argument*/NULL);
SystemException__ctor_mF67B7FA639B457BDFB2103D7C21C8059E806175A(__this, L_0, /*hidden argument*/NULL);
Exception_SetErrorCode_m742C1E687C82E56F445893685007EF4FC017F4A7(__this, ((int32_t)-2146233036), /*hidden argument*/NULL);
return;
}
}
// System.Void System.TypeInitializationException::.ctor(System.String,System.Exception)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void TypeInitializationException__ctor_m392481761B076335738D194514B219AC5A6D8A7E (TypeInitializationException_t5223A07113C97D6DC875A82C68D4C132737ADEAE * __this, String_t* ___fullTypeName0, Exception_t * ___innerException1, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (TypeInitializationException__ctor_m392481761B076335738D194514B219AC5A6D8A7E_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
ObjectU5BU5D_t3C9242B5C88A48B2A5BD9FDA6CD0024E792AF08A* L_0 = (ObjectU5BU5D_t3C9242B5C88A48B2A5BD9FDA6CD0024E792AF08A*)(ObjectU5BU5D_t3C9242B5C88A48B2A5BD9FDA6CD0024E792AF08A*)SZArrayNew(ObjectU5BU5D_t3C9242B5C88A48B2A5BD9FDA6CD0024E792AF08A_il2cpp_TypeInfo_var, (uint32_t)1);
ObjectU5BU5D_t3C9242B5C88A48B2A5BD9FDA6CD0024E792AF08A* L_1 = L_0;
String_t* L_2 = ___fullTypeName0;
NullCheck(L_1);
ArrayElementTypeCheck (L_1, L_2);
(L_1)->SetAt(static_cast<il2cpp_array_size_t>(0), (RuntimeObject *)L_2);
String_t* L_3 = Environment_GetResourceString_m7389941B4C0688D875CC647D99A739DA2F907ADB(_stringLiteral853ABCEF8465C8AE084B7B61A1A26F39EDB717B5, L_1, /*hidden argument*/NULL);
Exception_t * L_4 = ___innerException1;
SystemException__ctor_mA18D2EA5642C066F35CB8C965398F9A542C33B0A(__this, L_3, L_4, /*hidden argument*/NULL);
String_t* L_5 = ___fullTypeName0;
__this->set__typeName_17(L_5);
Exception_SetErrorCode_m742C1E687C82E56F445893685007EF4FC017F4A7(__this, ((int32_t)-2146233036), /*hidden argument*/NULL);
return;
}
}
// System.Void System.TypeInitializationException::.ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void TypeInitializationException__ctor_mECB421CF0582FE4EADA4DD7B5687CA64635D71B7 (TypeInitializationException_t5223A07113C97D6DC875A82C68D4C132737ADEAE * __this, SerializationInfo_t1BB80E9C9DEA52DBF464487234B045E2930ADA26 * ___info0, StreamingContext_t2CCDC54E0E8D078AF4A50E3A8B921B828A900034 ___context1, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (TypeInitializationException__ctor_mECB421CF0582FE4EADA4DD7B5687CA64635D71B7_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
SerializationInfo_t1BB80E9C9DEA52DBF464487234B045E2930ADA26 * L_0 = ___info0;
StreamingContext_t2CCDC54E0E8D078AF4A50E3A8B921B828A900034 L_1 = ___context1;
SystemException__ctor_mB0550111A1A8D18B697B618F811A5B20C160D949(__this, L_0, L_1, /*hidden argument*/NULL);
SerializationInfo_t1BB80E9C9DEA52DBF464487234B045E2930ADA26 * L_2 = ___info0;
NullCheck(L_2);
String_t* L_3 = SerializationInfo_GetString_m06805A4E368E0B98D5FA70A9333B277CBDD84CF4(L_2, _stringLiteral9E430F17EB96D796BF49C46584B98C497F8AE559, /*hidden argument*/NULL);
__this->set__typeName_17(L_3);
return;
}
}
// System.String System.TypeInitializationException::get_TypeName()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR String_t* TypeInitializationException_get_TypeName_mB1D7D9D4E2400579F85B80BA0B012504AB15A5A8 (TypeInitializationException_t5223A07113C97D6DC875A82C68D4C132737ADEAE * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (TypeInitializationException_get_TypeName_mB1D7D9D4E2400579F85B80BA0B012504AB15A5A8_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
String_t* L_0 = __this->get__typeName_17();
if (L_0)
{
goto IL_000e;
}
}
{
String_t* L_1 = ((String_t_StaticFields*)il2cpp_codegen_static_fields_for(String_t_il2cpp_TypeInfo_var))->get_Empty_5();
return L_1;
}
IL_000e:
{
String_t* L_2 = __this->get__typeName_17();
return L_2;
}
}
// System.Void System.TypeInitializationException::GetObjectData(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void TypeInitializationException_GetObjectData_m61A4C223CD68BB6170CD4E5593358B6A2CD0D1AE (TypeInitializationException_t5223A07113C97D6DC875A82C68D4C132737ADEAE * __this, SerializationInfo_t1BB80E9C9DEA52DBF464487234B045E2930ADA26 * ___info0, StreamingContext_t2CCDC54E0E8D078AF4A50E3A8B921B828A900034 ___context1, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (TypeInitializationException_GetObjectData_m61A4C223CD68BB6170CD4E5593358B6A2CD0D1AE_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
SerializationInfo_t1BB80E9C9DEA52DBF464487234B045E2930ADA26 * L_0 = ___info0;
StreamingContext_t2CCDC54E0E8D078AF4A50E3A8B921B828A900034 L_1 = ___context1;
Exception_GetObjectData_m76F759ED00FA218FFC522C32626B851FDE849AD6(__this, L_0, L_1, /*hidden argument*/NULL);
SerializationInfo_t1BB80E9C9DEA52DBF464487234B045E2930ADA26 * L_2 = ___info0;
String_t* L_3 = TypeInitializationException_get_TypeName_mB1D7D9D4E2400579F85B80BA0B012504AB15A5A8(__this, /*hidden argument*/NULL);
RuntimeTypeHandle_t7B542280A22F0EC4EAC2061C29178845847A8B2D L_4 = { reinterpret_cast<intptr_t> (String_t_0_0_0_var) };
IL2CPP_RUNTIME_CLASS_INIT(Type_t_il2cpp_TypeInfo_var);
Type_t * L_5 = Type_GetTypeFromHandle_m9DC58ADF0512987012A8A016FB64B068F3B1AFF6(L_4, /*hidden argument*/NULL);
NullCheck(L_2);
SerializationInfo_AddValue_mE0A104C01EFA55A83D4CAE4662A9B4C6459911FC(L_2, _stringLiteral9E430F17EB96D796BF49C46584B98C497F8AE559, L_3, L_5, /*hidden argument*/NULL);
return;
}
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.TypeLoadException::.ctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void TypeLoadException__ctor_mEF05D23A192E0B9BFAAA97A77A0FC1BCBE7B4355 (TypeLoadException_t510963B29CB27C6EA3ACDF5FB76E72E1BC372CD1 * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (TypeLoadException__ctor_mEF05D23A192E0B9BFAAA97A77A0FC1BCBE7B4355_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
String_t* L_0 = Environment_GetResourceString_m2C75C2AF268F01E2BF34AD1C2E1352CF4BA51AD9(_stringLiteralC10B7D725CE2223CDFE7B945291104E7C0ACE1D9, /*hidden argument*/NULL);
SystemException__ctor_mF67B7FA639B457BDFB2103D7C21C8059E806175A(__this, L_0, /*hidden argument*/NULL);
Exception_SetErrorCode_m742C1E687C82E56F445893685007EF4FC017F4A7(__this, ((int32_t)-2146233054), /*hidden argument*/NULL);
return;
}
}
// System.Void System.TypeLoadException::.ctor(System.String)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void TypeLoadException__ctor_m80951BFF6EB67A1ED3052D05569EF70D038B1581 (TypeLoadException_t510963B29CB27C6EA3ACDF5FB76E72E1BC372CD1 * __this, String_t* ___message0, const RuntimeMethod* method)
{
{
String_t* L_0 = ___message0;
SystemException__ctor_mF67B7FA639B457BDFB2103D7C21C8059E806175A(__this, L_0, /*hidden argument*/NULL);
Exception_SetErrorCode_m742C1E687C82E56F445893685007EF4FC017F4A7(__this, ((int32_t)-2146233054), /*hidden argument*/NULL);
return;
}
}
// System.String System.TypeLoadException::get_Message()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR String_t* TypeLoadException_get_Message_mE28CEB00E2315EC208CA7CCF223F1354416FC04A (TypeLoadException_t510963B29CB27C6EA3ACDF5FB76E72E1BC372CD1 * __this, const RuntimeMethod* method)
{
{
TypeLoadException_SetMessageField_m23CD2003031C6BF6A4AD01D4FFF2DC786DA580E0(__this, /*hidden argument*/NULL);
String_t* L_0 = ((Exception_t *)__this)->get__message_2();
return L_0;
}
}
// System.Void System.TypeLoadException::SetMessageField()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void TypeLoadException_SetMessageField_m23CD2003031C6BF6A4AD01D4FFF2DC786DA580E0 (TypeLoadException_t510963B29CB27C6EA3ACDF5FB76E72E1BC372CD1 * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (TypeLoadException_SetMessageField_m23CD2003031C6BF6A4AD01D4FFF2DC786DA580E0_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
String_t* V_0 = NULL;
{
String_t* L_0 = ((Exception_t *)__this)->get__message_2();
if (L_0)
{
goto IL_0084;
}
}
{
String_t* L_1 = __this->get_ClassName_17();
if (L_1)
{
goto IL_0029;
}
}
{
int32_t L_2 = __this->get_ResourceId_20();
if (L_2)
{
goto IL_0029;
}
}
{
String_t* L_3 = Environment_GetResourceString_m2C75C2AF268F01E2BF34AD1C2E1352CF4BA51AD9(_stringLiteralC10B7D725CE2223CDFE7B945291104E7C0ACE1D9, /*hidden argument*/NULL);
((Exception_t *)__this)->set__message_2(L_3);
return;
}
IL_0029:
{
String_t* L_4 = __this->get_AssemblyName_18();
if (L_4)
{
goto IL_0041;
}
}
{
String_t* L_5 = Environment_GetResourceString_m2C75C2AF268F01E2BF34AD1C2E1352CF4BA51AD9(_stringLiteral8B1AF543422B5976D44B9C740EF3CA472E5EF490, /*hidden argument*/NULL);
__this->set_AssemblyName_18(L_5);
}
IL_0041:
{
String_t* L_6 = __this->get_ClassName_17();
if (L_6)
{
goto IL_0059;
}
}
{
String_t* L_7 = Environment_GetResourceString_m2C75C2AF268F01E2BF34AD1C2E1352CF4BA51AD9(_stringLiteral8B1AF543422B5976D44B9C740EF3CA472E5EF490, /*hidden argument*/NULL);
__this->set_ClassName_17(L_7);
}
IL_0059:
{
V_0 = (String_t*)NULL;
V_0 = _stringLiteral3886FAAB186277EC9F7FEBBB72CE301AC5E2773C;
IL2CPP_RUNTIME_CLASS_INIT(CultureInfo_t345AC6924134F039ED9A11F3E03F8E91B6A3225F_il2cpp_TypeInfo_var);
CultureInfo_t345AC6924134F039ED9A11F3E03F8E91B6A3225F * L_8 = CultureInfo_get_CurrentCulture_mD86F3D8E5D332FB304F80D9B9CA4DE849C2A6831(/*hidden argument*/NULL);
String_t* L_9 = V_0;
String_t* L_10 = __this->get_ClassName_17();
String_t* L_11 = __this->get_AssemblyName_18();
String_t* L_12 = __this->get_MessageArg_19();
String_t* L_13 = String_Format_mCE84582533EA9934933F3F1496451F3D9DA652A4(L_8, L_9, L_10, L_11, L_12, /*hidden argument*/NULL);
((Exception_t *)__this)->set__message_2(L_13);
}
IL_0084:
{
return;
}
}
// System.Void System.TypeLoadException::.ctor(System.String,System.String)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void TypeLoadException__ctor_m5BFD68A735888FDA690CE055542FBF350DBDAB1F (TypeLoadException_t510963B29CB27C6EA3ACDF5FB76E72E1BC372CD1 * __this, String_t* ___className0, String_t* ___assemblyName1, const RuntimeMethod* method)
{
{
String_t* L_0 = ___className0;
String_t* L_1 = ___assemblyName1;
TypeLoadException__ctor_m6AB219D6FD444BC779001D783A48DE29CCB4D670(__this, L_0, L_1, (String_t*)NULL, 0, /*hidden argument*/NULL);
return;
}
}
// System.Void System.TypeLoadException::.ctor(System.String,System.String,System.String,System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void TypeLoadException__ctor_m6AB219D6FD444BC779001D783A48DE29CCB4D670 (TypeLoadException_t510963B29CB27C6EA3ACDF5FB76E72E1BC372CD1 * __this, String_t* ___className0, String_t* ___assemblyName1, String_t* ___messageArg2, int32_t ___resourceId3, const RuntimeMethod* method)
{
{
SystemException__ctor_mF67B7FA639B457BDFB2103D7C21C8059E806175A(__this, (String_t*)NULL, /*hidden argument*/NULL);
Exception_SetErrorCode_m742C1E687C82E56F445893685007EF4FC017F4A7(__this, ((int32_t)-2146233054), /*hidden argument*/NULL);
String_t* L_0 = ___className0;
__this->set_ClassName_17(L_0);
String_t* L_1 = ___assemblyName1;
__this->set_AssemblyName_18(L_1);
String_t* L_2 = ___messageArg2;
__this->set_MessageArg_19(L_2);
int32_t L_3 = ___resourceId3;
__this->set_ResourceId_20(L_3);
TypeLoadException_SetMessageField_m23CD2003031C6BF6A4AD01D4FFF2DC786DA580E0(__this, /*hidden argument*/NULL);
return;
}
}
// System.Void System.TypeLoadException::.ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void TypeLoadException__ctor_m7D81F0BF798D436FF6ECF3F4B48F206DB8AB1293 (TypeLoadException_t510963B29CB27C6EA3ACDF5FB76E72E1BC372CD1 * __this, SerializationInfo_t1BB80E9C9DEA52DBF464487234B045E2930ADA26 * ___info0, StreamingContext_t2CCDC54E0E8D078AF4A50E3A8B921B828A900034 ___context1, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (TypeLoadException__ctor_m7D81F0BF798D436FF6ECF3F4B48F206DB8AB1293_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
SerializationInfo_t1BB80E9C9DEA52DBF464487234B045E2930ADA26 * L_0 = ___info0;
StreamingContext_t2CCDC54E0E8D078AF4A50E3A8B921B828A900034 L_1 = ___context1;
SystemException__ctor_mB0550111A1A8D18B697B618F811A5B20C160D949(__this, L_0, L_1, /*hidden argument*/NULL);
SerializationInfo_t1BB80E9C9DEA52DBF464487234B045E2930ADA26 * L_2 = ___info0;
if (L_2)
{
goto IL_0016;
}
}
{
ArgumentNullException_t581DF992B1F3E0EC6EFB30CC5DC43519A79B27AD * L_3 = (ArgumentNullException_t581DF992B1F3E0EC6EFB30CC5DC43519A79B27AD *)il2cpp_codegen_object_new(ArgumentNullException_t581DF992B1F3E0EC6EFB30CC5DC43519A79B27AD_il2cpp_TypeInfo_var);
ArgumentNullException__ctor_mEE0C0D6FCB2D08CD7967DBB1329A0854BBED49ED(L_3, _stringLiteral59BD0A3FF43B32849B319E645D4798D8A5D1E889, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_3, NULL, TypeLoadException__ctor_m7D81F0BF798D436FF6ECF3F4B48F206DB8AB1293_RuntimeMethod_var);
}
IL_0016:
{
SerializationInfo_t1BB80E9C9DEA52DBF464487234B045E2930ADA26 * L_4 = ___info0;
NullCheck(L_4);
String_t* L_5 = SerializationInfo_GetString_m06805A4E368E0B98D5FA70A9333B277CBDD84CF4(L_4, _stringLiteralE31F38791120074366DE542990E5E66B4AEB3A22, /*hidden argument*/NULL);
__this->set_ClassName_17(L_5);
SerializationInfo_t1BB80E9C9DEA52DBF464487234B045E2930ADA26 * L_6 = ___info0;
NullCheck(L_6);
String_t* L_7 = SerializationInfo_GetString_m06805A4E368E0B98D5FA70A9333B277CBDD84CF4(L_6, _stringLiteral3D708CB7F76AF5A68201B998794CB435ACA1B0D5, /*hidden argument*/NULL);
__this->set_AssemblyName_18(L_7);
SerializationInfo_t1BB80E9C9DEA52DBF464487234B045E2930ADA26 * L_8 = ___info0;
NullCheck(L_8);
String_t* L_9 = SerializationInfo_GetString_m06805A4E368E0B98D5FA70A9333B277CBDD84CF4(L_8, _stringLiteral27BED7455215AA8A8EA1D7944A4975BAA72AA6B6, /*hidden argument*/NULL);
__this->set_MessageArg_19(L_9);
SerializationInfo_t1BB80E9C9DEA52DBF464487234B045E2930ADA26 * L_10 = ___info0;
NullCheck(L_10);
int32_t L_11 = SerializationInfo_GetInt32_mB47BD46A0BDBBAF5B47BB62E6EFF8E092E3F3656(L_10, _stringLiteralFE66537A952957258311139D35B0945C0FC518DC, /*hidden argument*/NULL);
__this->set_ResourceId_20(L_11);
return;
}
}
// System.Void System.TypeLoadException::GetObjectData(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void TypeLoadException_GetObjectData_m5198722D9966C5F04FD07467B5EE5AB84D86E499 (TypeLoadException_t510963B29CB27C6EA3ACDF5FB76E72E1BC372CD1 * __this, SerializationInfo_t1BB80E9C9DEA52DBF464487234B045E2930ADA26 * ___info0, StreamingContext_t2CCDC54E0E8D078AF4A50E3A8B921B828A900034 ___context1, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (TypeLoadException_GetObjectData_m5198722D9966C5F04FD07467B5EE5AB84D86E499_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
SerializationInfo_t1BB80E9C9DEA52DBF464487234B045E2930ADA26 * L_0 = ___info0;
if (L_0)
{
goto IL_000e;
}
}
{
ArgumentNullException_t581DF992B1F3E0EC6EFB30CC5DC43519A79B27AD * L_1 = (ArgumentNullException_t581DF992B1F3E0EC6EFB30CC5DC43519A79B27AD *)il2cpp_codegen_object_new(ArgumentNullException_t581DF992B1F3E0EC6EFB30CC5DC43519A79B27AD_il2cpp_TypeInfo_var);
ArgumentNullException__ctor_mEE0C0D6FCB2D08CD7967DBB1329A0854BBED49ED(L_1, _stringLiteral59BD0A3FF43B32849B319E645D4798D8A5D1E889, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_1, NULL, TypeLoadException_GetObjectData_m5198722D9966C5F04FD07467B5EE5AB84D86E499_RuntimeMethod_var);
}
IL_000e:
{
SerializationInfo_t1BB80E9C9DEA52DBF464487234B045E2930ADA26 * L_2 = ___info0;
StreamingContext_t2CCDC54E0E8D078AF4A50E3A8B921B828A900034 L_3 = ___context1;
Exception_GetObjectData_m76F759ED00FA218FFC522C32626B851FDE849AD6(__this, L_2, L_3, /*hidden argument*/NULL);
SerializationInfo_t1BB80E9C9DEA52DBF464487234B045E2930ADA26 * L_4 = ___info0;
String_t* L_5 = __this->get_ClassName_17();
RuntimeTypeHandle_t7B542280A22F0EC4EAC2061C29178845847A8B2D L_6 = { reinterpret_cast<intptr_t> (String_t_0_0_0_var) };
IL2CPP_RUNTIME_CLASS_INIT(Type_t_il2cpp_TypeInfo_var);
Type_t * L_7 = Type_GetTypeFromHandle_m9DC58ADF0512987012A8A016FB64B068F3B1AFF6(L_6, /*hidden argument*/NULL);
NullCheck(L_4);
SerializationInfo_AddValue_mE0A104C01EFA55A83D4CAE4662A9B4C6459911FC(L_4, _stringLiteralE31F38791120074366DE542990E5E66B4AEB3A22, L_5, L_7, /*hidden argument*/NULL);
SerializationInfo_t1BB80E9C9DEA52DBF464487234B045E2930ADA26 * L_8 = ___info0;
String_t* L_9 = __this->get_AssemblyName_18();
RuntimeTypeHandle_t7B542280A22F0EC4EAC2061C29178845847A8B2D L_10 = { reinterpret_cast<intptr_t> (String_t_0_0_0_var) };
Type_t * L_11 = Type_GetTypeFromHandle_m9DC58ADF0512987012A8A016FB64B068F3B1AFF6(L_10, /*hidden argument*/NULL);
NullCheck(L_8);
SerializationInfo_AddValue_mE0A104C01EFA55A83D4CAE4662A9B4C6459911FC(L_8, _stringLiteral3D708CB7F76AF5A68201B998794CB435ACA1B0D5, L_9, L_11, /*hidden argument*/NULL);
SerializationInfo_t1BB80E9C9DEA52DBF464487234B045E2930ADA26 * L_12 = ___info0;
String_t* L_13 = __this->get_MessageArg_19();
RuntimeTypeHandle_t7B542280A22F0EC4EAC2061C29178845847A8B2D L_14 = { reinterpret_cast<intptr_t> (String_t_0_0_0_var) };
Type_t * L_15 = Type_GetTypeFromHandle_m9DC58ADF0512987012A8A016FB64B068F3B1AFF6(L_14, /*hidden argument*/NULL);
NullCheck(L_12);
SerializationInfo_AddValue_mE0A104C01EFA55A83D4CAE4662A9B4C6459911FC(L_12, _stringLiteral27BED7455215AA8A8EA1D7944A4975BAA72AA6B6, L_13, L_15, /*hidden argument*/NULL);
SerializationInfo_t1BB80E9C9DEA52DBF464487234B045E2930ADA26 * L_16 = ___info0;
int32_t L_17 = __this->get_ResourceId_20();
NullCheck(L_16);
SerializationInfo_AddValue_m7C73917D9DC4B8FE4AFEF4BA8EBEDAB046A8D0BD(L_16, _stringLiteralFE66537A952957258311139D35B0945C0FC518DC, L_17, /*hidden argument*/NULL);
return;
}
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Type System.TypeNameParser::GetType(System.String,System.Func`2<System.Reflection.AssemblyName,System.Reflection.Assembly>,System.Func`4<System.Reflection.Assembly,System.String,System.Boolean,System.Type>,System.Boolean,System.Boolean,System.Threading.StackCrawlMarkU26)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Type_t * TypeNameParser_GetType_m8359CD1600F889CE251C669179BB982D1A2F7013 (String_t* ___typeName0, Func_2_t13827C9725E0D12567E029E178981FB7D0E13430 * ___assemblyResolver1, Func_4_t3D7857A2A0F731D1E992FC5B09E983A8621FABFF * ___typeResolver2, bool ___throwOnError3, bool ___ignoreCase4, int32_t* ___stackMark5, const RuntimeMethod* method)
{
{
String_t* L_0 = ___typeName0;
TypeSpec_t943289F7C537252144A22588159B36C6B6759A7F * L_1 = TypeSpec_Parse_m7DDF2C8D81E80856BA9EEFDB84421AE2F81B58C1(L_0, /*hidden argument*/NULL);
Func_2_t13827C9725E0D12567E029E178981FB7D0E13430 * L_2 = ___assemblyResolver1;
Func_4_t3D7857A2A0F731D1E992FC5B09E983A8621FABFF * L_3 = ___typeResolver2;
bool L_4 = ___throwOnError3;
bool L_5 = ___ignoreCase4;
NullCheck(L_1);
Type_t * L_6 = TypeSpec_Resolve_mCE50015512C48D97F6D5558A2001825102BDDBF7(L_1, L_2, L_3, L_4, L_5, /*hidden argument*/NULL);
return L_6;
}
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Boolean System.TypeNames_ATypeName::Equals(System.TypeName)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool ATypeName_Equals_m7D88938E443BA9FAEA8615EEFBAE8E23B1BE6BD2 (ATypeName_t8FD4A465E3C2846D11FEAE25ED5BF3D67FF94421 * __this, RuntimeObject* ___other0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (ATypeName_Equals_m7D88938E443BA9FAEA8615EEFBAE8E23B1BE6BD2_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
RuntimeObject* L_0 = ___other0;
if (!L_0)
{
goto IL_0015;
}
}
{
String_t* L_1 = VirtFuncInvoker0< String_t* >::Invoke(6 /* System.String System.TypeNames/ATypeName::get_DisplayName() */, __this);
RuntimeObject* L_2 = ___other0;
NullCheck(L_2);
String_t* L_3 = InterfaceFuncInvoker0< String_t* >::Invoke(0 /* System.String System.TypeName::get_DisplayName() */, TypeName_t0C63929669D92B034691B7E78AF79FA1F8592513_il2cpp_TypeInfo_var, L_2);
bool L_4 = String_op_Equality_m139F0E4195AE2F856019E63B241F36F016997FCE(L_1, L_3, /*hidden argument*/NULL);
return L_4;
}
IL_0015:
{
return (bool)0;
}
}
// System.Int32 System.TypeNames_ATypeName::GetHashCode()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t ATypeName_GetHashCode_m5F89250BB037822F96C23AC7E0EA08D90A578415 (ATypeName_t8FD4A465E3C2846D11FEAE25ED5BF3D67FF94421 * __this, const RuntimeMethod* method)
{
{
String_t* L_0 = VirtFuncInvoker0< String_t* >::Invoke(6 /* System.String System.TypeNames/ATypeName::get_DisplayName() */, __this);
NullCheck(L_0);
int32_t L_1 = VirtFuncInvoker0< int32_t >::Invoke(2 /* System.Int32 System.Object::GetHashCode() */, L_0);
return L_1;
}
}
// System.Boolean System.TypeNames_ATypeName::Equals(System.Object)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool ATypeName_Equals_mCADC0D866B2E78D4BA563475D528D45DA5AA92FD (ATypeName_t8FD4A465E3C2846D11FEAE25ED5BF3D67FF94421 * __this, RuntimeObject * ___other0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (ATypeName_Equals_mCADC0D866B2E78D4BA563475D528D45DA5AA92FD_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
RuntimeObject * L_0 = ___other0;
bool L_1 = ATypeName_Equals_m7D88938E443BA9FAEA8615EEFBAE8E23B1BE6BD2(__this, ((RuntimeObject*)IsInst((RuntimeObject*)L_0, TypeName_t0C63929669D92B034691B7E78AF79FA1F8592513_il2cpp_TypeInfo_var)), /*hidden argument*/NULL);
return L_1;
}
}
// System.Void System.TypeNames_ATypeName::.ctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void ATypeName__ctor_mB865CB8CFBAD77532030E15AB4DF856DB368D307 (ATypeName_t8FD4A465E3C2846D11FEAE25ED5BF3D67FF94421 * __this, const RuntimeMethod* method)
{
{
Object__ctor_m925ECA5E85CA100E3FB86A4F9E15C120E9A184C0(__this, /*hidden argument*/NULL);
return;
}
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Boolean System.TypeSpec::get_HasModifiers()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool TypeSpec_get_HasModifiers_mF783ED5C395D4ACB94D30014B9F79E19E90EC9FD (TypeSpec_t943289F7C537252144A22588159B36C6B6759A7F * __this, const RuntimeMethod* method)
{
{
List_1_tFD995FD9C5961BB4B415EE63B297C4B19643A3C2 * L_0 = __this->get_modifier_spec_4();
return (bool)((!(((RuntimeObject*)(List_1_tFD995FD9C5961BB4B415EE63B297C4B19643A3C2 *)L_0) <= ((RuntimeObject*)(RuntimeObject *)NULL)))? 1 : 0);
}
}
// System.String System.TypeSpec::GetDisplayFullName(System.TypeSpec_DisplayNameFormat)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR String_t* TypeSpec_GetDisplayFullName_m4D6D7AED6CBFC324310480BA07461682A09822B6 (TypeSpec_t943289F7C537252144A22588159B36C6B6759A7F * __this, int32_t ___flags0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (TypeSpec_GetDisplayFullName_m4D6D7AED6CBFC324310480BA07461682A09822B6_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
bool V_0 = false;
bool V_1 = false;
StringBuilder_t * V_2 = NULL;
Enumerator_tF3C2A3B3C8EE5956E26FA5AE4C14FC7655975628 V_3;
memset((&V_3), 0, sizeof(V_3));
RuntimeObject* V_4 = NULL;
int32_t V_5 = 0;
Exception_t * __last_unhandled_exception = 0;
NO_UNUSED_WARNING (__last_unhandled_exception);
Exception_t * __exception_local = 0;
NO_UNUSED_WARNING (__exception_local);
int32_t __leave_target = -1;
NO_UNUSED_WARNING (__leave_target);
{
int32_t L_0 = ___flags0;
V_0 = (bool)((!(((uint32_t)((int32_t)((int32_t)L_0&(int32_t)1))) <= ((uint32_t)0)))? 1 : 0);
int32_t L_1 = ___flags0;
V_1 = (bool)((((int32_t)((int32_t)((int32_t)L_1&(int32_t)2))) == ((int32_t)0))? 1 : 0);
RuntimeObject* L_2 = __this->get_name_0();
NullCheck(L_2);
String_t* L_3 = InterfaceFuncInvoker0< String_t* >::Invoke(0 /* System.String System.TypeName::get_DisplayName() */, TypeName_t0C63929669D92B034691B7E78AF79FA1F8592513_il2cpp_TypeInfo_var, L_2);
StringBuilder_t * L_4 = (StringBuilder_t *)il2cpp_codegen_object_new(StringBuilder_t_il2cpp_TypeInfo_var);
StringBuilder__ctor_m53E278FB62B3EAEFAF82890C97219B9B5E2A56C3(L_4, L_3, /*hidden argument*/NULL);
V_2 = L_4;
List_1_tB8129EB4ADDDECD38E3E178F0A902C921B575166 * L_5 = __this->get_nested_2();
if (!L_5)
{
goto IL_006c;
}
}
{
List_1_tB8129EB4ADDDECD38E3E178F0A902C921B575166 * L_6 = __this->get_nested_2();
NullCheck(L_6);
Enumerator_tF3C2A3B3C8EE5956E26FA5AE4C14FC7655975628 L_7 = List_1_GetEnumerator_m2E4A41A21C3DEA2E56F3BAAC22CAC54ADDAAE89A(L_6, /*hidden argument*/List_1_GetEnumerator_m2E4A41A21C3DEA2E56F3BAAC22CAC54ADDAAE89A_RuntimeMethod_var);
V_3 = L_7;
}
IL_0033:
try
{ // begin try (depth: 1)
{
goto IL_0053;
}
IL_0035:
{
RuntimeObject* L_8 = Enumerator_get_Current_m1FE262A1143A9C0B744CAE59FDF00A529A47DA7C((Enumerator_tF3C2A3B3C8EE5956E26FA5AE4C14FC7655975628 *)(&V_3), /*hidden argument*/Enumerator_get_Current_m1FE262A1143A9C0B744CAE59FDF00A529A47DA7C_RuntimeMethod_var);
V_4 = L_8;
StringBuilder_t * L_9 = V_2;
NullCheck(L_9);
StringBuilder_t * L_10 = StringBuilder_Append_m05C12F58ADC2D807613A9301DF438CB3CD09B75A(L_9, ((int32_t)43), /*hidden argument*/NULL);
RuntimeObject* L_11 = V_4;
NullCheck(L_11);
String_t* L_12 = InterfaceFuncInvoker0< String_t* >::Invoke(0 /* System.String System.TypeName::get_DisplayName() */, TypeName_t0C63929669D92B034691B7E78AF79FA1F8592513_il2cpp_TypeInfo_var, L_11);
NullCheck(L_10);
StringBuilder_Append_mDBB8CCBB7750C67BE2F2D92F47E6C0FA42793260(L_10, L_12, /*hidden argument*/NULL);
}
IL_0053:
{
bool L_13 = Enumerator_MoveNext_m5FA83E49042D278C984097B83622E3165E4564AD((Enumerator_tF3C2A3B3C8EE5956E26FA5AE4C14FC7655975628 *)(&V_3), /*hidden argument*/Enumerator_MoveNext_m5FA83E49042D278C984097B83622E3165E4564AD_RuntimeMethod_var);
if (L_13)
{
goto IL_0035;
}
}
IL_005c:
{
IL2CPP_LEAVE(0x6C, FINALLY_005e);
}
} // end try (depth: 1)
catch(Il2CppExceptionWrapper& e)
{
__last_unhandled_exception = (Exception_t *)e.ex;
goto FINALLY_005e;
}
FINALLY_005e:
{ // begin finally (depth: 1)
Enumerator_Dispose_m9FE451117A551A3AD97A0FC27C1C159B551B25F3((Enumerator_tF3C2A3B3C8EE5956E26FA5AE4C14FC7655975628 *)(&V_3), /*hidden argument*/Enumerator_Dispose_m9FE451117A551A3AD97A0FC27C1C159B551B25F3_RuntimeMethod_var);
IL2CPP_RESET_LEAVE(0x6C);
IL2CPP_END_FINALLY(94)
} // end finally (depth: 1)
IL2CPP_CLEANUP(94)
{
IL2CPP_JUMP_TBL(0x6C, IL_006c)
IL2CPP_RETHROW_IF_UNHANDLED(Exception_t *)
}
IL_006c:
{
List_1_t8C8BF378AAB72B34B6EE63F686877AE7290ECFBA * L_14 = __this->get_generic_params_3();
if (!L_14)
{
goto IL_010a;
}
}
{
StringBuilder_t * L_15 = V_2;
NullCheck(L_15);
StringBuilder_Append_m05C12F58ADC2D807613A9301DF438CB3CD09B75A(L_15, ((int32_t)91), /*hidden argument*/NULL);
V_5 = 0;
goto IL_00f2;
}
IL_0085:
{
int32_t L_16 = V_5;
if ((((int32_t)L_16) <= ((int32_t)0)))
{
goto IL_0096;
}
}
{
StringBuilder_t * L_17 = V_2;
NullCheck(L_17);
StringBuilder_Append_mDBB8CCBB7750C67BE2F2D92F47E6C0FA42793260(L_17, _stringLiteralD3BC9A378DAAA1DDDBA1B19C1AA641D3E9683C46, /*hidden argument*/NULL);
}
IL_0096:
{
List_1_t8C8BF378AAB72B34B6EE63F686877AE7290ECFBA * L_18 = __this->get_generic_params_3();
int32_t L_19 = V_5;
NullCheck(L_18);
TypeSpec_t943289F7C537252144A22588159B36C6B6759A7F * L_20 = List_1_get_Item_m942CEFAE0020F8EC07462ED0CFC951FFE66CBD46(L_18, L_19, /*hidden argument*/List_1_get_Item_m942CEFAE0020F8EC07462ED0CFC951FFE66CBD46_RuntimeMethod_var);
NullCheck(L_20);
String_t* L_21 = L_20->get_assembly_name_1();
if (!L_21)
{
goto IL_00d3;
}
}
{
StringBuilder_t * L_22 = V_2;
NullCheck(L_22);
StringBuilder_t * L_23 = StringBuilder_Append_m05C12F58ADC2D807613A9301DF438CB3CD09B75A(L_22, ((int32_t)91), /*hidden argument*/NULL);
List_1_t8C8BF378AAB72B34B6EE63F686877AE7290ECFBA * L_24 = __this->get_generic_params_3();
int32_t L_25 = V_5;
NullCheck(L_24);
TypeSpec_t943289F7C537252144A22588159B36C6B6759A7F * L_26 = List_1_get_Item_m942CEFAE0020F8EC07462ED0CFC951FFE66CBD46(L_24, L_25, /*hidden argument*/List_1_get_Item_m942CEFAE0020F8EC07462ED0CFC951FFE66CBD46_RuntimeMethod_var);
NullCheck(L_26);
String_t* L_27 = TypeSpec_get_DisplayFullName_mE25183941E02D8885546E07565C790AF63A890FA(L_26, /*hidden argument*/NULL);
NullCheck(L_23);
StringBuilder_t * L_28 = StringBuilder_Append_mDBB8CCBB7750C67BE2F2D92F47E6C0FA42793260(L_23, L_27, /*hidden argument*/NULL);
NullCheck(L_28);
StringBuilder_Append_m05C12F58ADC2D807613A9301DF438CB3CD09B75A(L_28, ((int32_t)93), /*hidden argument*/NULL);
goto IL_00ec;
}
IL_00d3:
{
StringBuilder_t * L_29 = V_2;
List_1_t8C8BF378AAB72B34B6EE63F686877AE7290ECFBA * L_30 = __this->get_generic_params_3();
int32_t L_31 = V_5;
NullCheck(L_30);
TypeSpec_t943289F7C537252144A22588159B36C6B6759A7F * L_32 = List_1_get_Item_m942CEFAE0020F8EC07462ED0CFC951FFE66CBD46(L_30, L_31, /*hidden argument*/List_1_get_Item_m942CEFAE0020F8EC07462ED0CFC951FFE66CBD46_RuntimeMethod_var);
NullCheck(L_32);
String_t* L_33 = TypeSpec_get_DisplayFullName_mE25183941E02D8885546E07565C790AF63A890FA(L_32, /*hidden argument*/NULL);
NullCheck(L_29);
StringBuilder_Append_mDBB8CCBB7750C67BE2F2D92F47E6C0FA42793260(L_29, L_33, /*hidden argument*/NULL);
}
IL_00ec:
{
int32_t L_34 = V_5;
V_5 = ((int32_t)il2cpp_codegen_add((int32_t)L_34, (int32_t)1));
}
IL_00f2:
{
int32_t L_35 = V_5;
List_1_t8C8BF378AAB72B34B6EE63F686877AE7290ECFBA * L_36 = __this->get_generic_params_3();
NullCheck(L_36);
int32_t L_37 = List_1_get_Count_m516B184735436F6F6363D5BDBC6469AAA19A10A4(L_36, /*hidden argument*/List_1_get_Count_m516B184735436F6F6363D5BDBC6469AAA19A10A4_RuntimeMethod_var);
if ((((int32_t)L_35) < ((int32_t)L_37)))
{
goto IL_0085;
}
}
{
StringBuilder_t * L_38 = V_2;
NullCheck(L_38);
StringBuilder_Append_m05C12F58ADC2D807613A9301DF438CB3CD09B75A(L_38, ((int32_t)93), /*hidden argument*/NULL);
}
IL_010a:
{
bool L_39 = V_1;
if (!L_39)
{
goto IL_0115;
}
}
{
StringBuilder_t * L_40 = V_2;
TypeSpec_GetModifierString_m879659900335844914FDD6BEB1B373531DC990FE(__this, L_40, /*hidden argument*/NULL);
}
IL_0115:
{
String_t* L_41 = __this->get_assembly_name_1();
bool L_42 = V_0;
if (!((int32_t)((int32_t)((!(((RuntimeObject*)(String_t*)L_41) <= ((RuntimeObject*)(RuntimeObject *)NULL)))? 1 : 0)&(int32_t)L_42)))
{
goto IL_0139;
}
}
{
StringBuilder_t * L_43 = V_2;
NullCheck(L_43);
StringBuilder_t * L_44 = StringBuilder_Append_mDBB8CCBB7750C67BE2F2D92F47E6C0FA42793260(L_43, _stringLiteralD3BC9A378DAAA1DDDBA1B19C1AA641D3E9683C46, /*hidden argument*/NULL);
String_t* L_45 = __this->get_assembly_name_1();
NullCheck(L_44);
StringBuilder_Append_mDBB8CCBB7750C67BE2F2D92F47E6C0FA42793260(L_44, L_45, /*hidden argument*/NULL);
}
IL_0139:
{
StringBuilder_t * L_46 = V_2;
NullCheck(L_46);
String_t* L_47 = VirtFuncInvoker0< String_t* >::Invoke(3 /* System.String System.Object::ToString() */, L_46);
return L_47;
}
}
// System.Text.StringBuilder System.TypeSpec::GetModifierString(System.Text.StringBuilder)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR StringBuilder_t * TypeSpec_GetModifierString_m879659900335844914FDD6BEB1B373531DC990FE (TypeSpec_t943289F7C537252144A22588159B36C6B6759A7F * __this, StringBuilder_t * ___sb0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (TypeSpec_GetModifierString_m879659900335844914FDD6BEB1B373531DC990FE_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
Enumerator_t947A94EE32E8D5A1E40EDCC5D83206D0832E531D V_0;
memset((&V_0), 0, sizeof(V_0));
Exception_t * __last_unhandled_exception = 0;
NO_UNUSED_WARNING (__last_unhandled_exception);
Exception_t * __exception_local = 0;
NO_UNUSED_WARNING (__exception_local);
int32_t __leave_target = -1;
NO_UNUSED_WARNING (__leave_target);
{
List_1_tFD995FD9C5961BB4B415EE63B297C4B19643A3C2 * L_0 = __this->get_modifier_spec_4();
if (!L_0)
{
goto IL_003d;
}
}
{
List_1_tFD995FD9C5961BB4B415EE63B297C4B19643A3C2 * L_1 = __this->get_modifier_spec_4();
NullCheck(L_1);
Enumerator_t947A94EE32E8D5A1E40EDCC5D83206D0832E531D L_2 = List_1_GetEnumerator_m7F1A981C4F56927EB6D80776859EFEB2A949645F(L_1, /*hidden argument*/List_1_GetEnumerator_m7F1A981C4F56927EB6D80776859EFEB2A949645F_RuntimeMethod_var);
V_0 = L_2;
}
IL_0014:
try
{ // begin try (depth: 1)
{
goto IL_0024;
}
IL_0016:
{
RuntimeObject* L_3 = Enumerator_get_Current_mABF1CE6A366A00FB242CDDC13D80881F14052780((Enumerator_t947A94EE32E8D5A1E40EDCC5D83206D0832E531D *)(&V_0), /*hidden argument*/Enumerator_get_Current_mABF1CE6A366A00FB242CDDC13D80881F14052780_RuntimeMethod_var);
StringBuilder_t * L_4 = ___sb0;
NullCheck(L_3);
InterfaceFuncInvoker1< StringBuilder_t *, StringBuilder_t * >::Invoke(1 /* System.Text.StringBuilder System.ModifierSpec::Append(System.Text.StringBuilder) */, ModifierSpec_t0A5286DDFBD682F1E1D8AEBE5FD9D34EAB4CF1E5_il2cpp_TypeInfo_var, L_3, L_4);
}
IL_0024:
{
bool L_5 = Enumerator_MoveNext_mD91BF5A0EE3F48F18729E9A081A22223CBA9134E((Enumerator_t947A94EE32E8D5A1E40EDCC5D83206D0832E531D *)(&V_0), /*hidden argument*/Enumerator_MoveNext_mD91BF5A0EE3F48F18729E9A081A22223CBA9134E_RuntimeMethod_var);
if (L_5)
{
goto IL_0016;
}
}
IL_002d:
{
IL2CPP_LEAVE(0x3D, FINALLY_002f);
}
} // end try (depth: 1)
catch(Il2CppExceptionWrapper& e)
{
__last_unhandled_exception = (Exception_t *)e.ex;
goto FINALLY_002f;
}
FINALLY_002f:
{ // begin finally (depth: 1)
Enumerator_Dispose_m4B5D4976D2C83F3DB387137CD7DE096E0C28370B((Enumerator_t947A94EE32E8D5A1E40EDCC5D83206D0832E531D *)(&V_0), /*hidden argument*/Enumerator_Dispose_m4B5D4976D2C83F3DB387137CD7DE096E0C28370B_RuntimeMethod_var);
IL2CPP_RESET_LEAVE(0x3D);
IL2CPP_END_FINALLY(47)
} // end finally (depth: 1)
IL2CPP_CLEANUP(47)
{
IL2CPP_JUMP_TBL(0x3D, IL_003d)
IL2CPP_RETHROW_IF_UNHANDLED(Exception_t *)
}
IL_003d:
{
bool L_6 = __this->get_is_byref_5();
if (!L_6)
{
goto IL_004e;
}
}
{
StringBuilder_t * L_7 = ___sb0;
NullCheck(L_7);
StringBuilder_Append_m05C12F58ADC2D807613A9301DF438CB3CD09B75A(L_7, ((int32_t)38), /*hidden argument*/NULL);
}
IL_004e:
{
StringBuilder_t * L_8 = ___sb0;
return L_8;
}
}
// System.String System.TypeSpec::get_DisplayFullName()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR String_t* TypeSpec_get_DisplayFullName_mE25183941E02D8885546E07565C790AF63A890FA (TypeSpec_t943289F7C537252144A22588159B36C6B6759A7F * __this, const RuntimeMethod* method)
{
{
String_t* L_0 = __this->get_display_fullname_6();
if (L_0)
{
goto IL_0015;
}
}
{
String_t* L_1 = TypeSpec_GetDisplayFullName_m4D6D7AED6CBFC324310480BA07461682A09822B6(__this, 0, /*hidden argument*/NULL);
__this->set_display_fullname_6(L_1);
}
IL_0015:
{
String_t* L_2 = __this->get_display_fullname_6();
return L_2;
}
}
// System.TypeSpec System.TypeSpec::Parse(System.String)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR TypeSpec_t943289F7C537252144A22588159B36C6B6759A7F * TypeSpec_Parse_m7DDF2C8D81E80856BA9EEFDB84421AE2F81B58C1 (String_t* ___typeName0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (TypeSpec_Parse_m7DDF2C8D81E80856BA9EEFDB84421AE2F81B58C1_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
int32_t V_0 = 0;
TypeSpec_t943289F7C537252144A22588159B36C6B6759A7F * G_B4_0 = NULL;
TypeSpec_t943289F7C537252144A22588159B36C6B6759A7F * G_B3_0 = NULL;
{
V_0 = 0;
String_t* L_0 = ___typeName0;
if (L_0)
{
goto IL_0010;
}
}
{
ArgumentNullException_t581DF992B1F3E0EC6EFB30CC5DC43519A79B27AD * L_1 = (ArgumentNullException_t581DF992B1F3E0EC6EFB30CC5DC43519A79B27AD *)il2cpp_codegen_object_new(ArgumentNullException_t581DF992B1F3E0EC6EFB30CC5DC43519A79B27AD_il2cpp_TypeInfo_var);
ArgumentNullException__ctor_mEE0C0D6FCB2D08CD7967DBB1329A0854BBED49ED(L_1, _stringLiteral9FA22049CF6367C2DB11AB15BC3EDE8D5104CB06, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_1, NULL, TypeSpec_Parse_m7DDF2C8D81E80856BA9EEFDB84421AE2F81B58C1_RuntimeMethod_var);
}
IL_0010:
{
String_t* L_2 = ___typeName0;
TypeSpec_t943289F7C537252144A22588159B36C6B6759A7F * L_3 = TypeSpec_Parse_m9AE5F2E214E154E1AEDCB27FD207B0C4C8EBC405(L_2, (int32_t*)(&V_0), (bool)0, (bool)1, /*hidden argument*/NULL);
int32_t L_4 = V_0;
String_t* L_5 = ___typeName0;
NullCheck(L_5);
int32_t L_6 = String_get_Length_mD48C8A16A5CF1914F330DCE82D9BE15C3BEDD018(L_5, /*hidden argument*/NULL);
G_B3_0 = L_3;
if ((((int32_t)L_4) >= ((int32_t)L_6)))
{
G_B4_0 = L_3;
goto IL_0033;
}
}
{
ArgumentException_tEDCD16F20A09ECE461C3DA766C16EDA8864057D1 * L_7 = (ArgumentException_tEDCD16F20A09ECE461C3DA766C16EDA8864057D1 *)il2cpp_codegen_object_new(ArgumentException_tEDCD16F20A09ECE461C3DA766C16EDA8864057D1_il2cpp_TypeInfo_var);
ArgumentException__ctor_m26DC3463C6F3C98BF33EA39598DD2B32F0249CA8(L_7, _stringLiteralA466EFF47B9A04F03416534E8768A5ED5BC7AFBC, _stringLiteral9FA22049CF6367C2DB11AB15BC3EDE8D5104CB06, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_7, NULL, TypeSpec_Parse_m7DDF2C8D81E80856BA9EEFDB84421AE2F81B58C1_RuntimeMethod_var);
}
IL_0033:
{
return G_B4_0;
}
}
// System.String System.TypeSpec::UnescapeInternalName(System.String)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR String_t* TypeSpec_UnescapeInternalName_m7B3F1C73984FAF9159F89F62C97AF144EDC4347E (String_t* ___displayName0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (TypeSpec_UnescapeInternalName_m7B3F1C73984FAF9159F89F62C97AF144EDC4347E_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
StringBuilder_t * V_0 = NULL;
int32_t V_1 = 0;
Il2CppChar V_2 = 0x0;
{
String_t* L_0 = ___displayName0;
NullCheck(L_0);
int32_t L_1 = String_get_Length_mD48C8A16A5CF1914F330DCE82D9BE15C3BEDD018(L_0, /*hidden argument*/NULL);
StringBuilder_t * L_2 = (StringBuilder_t *)il2cpp_codegen_object_new(StringBuilder_t_il2cpp_TypeInfo_var);
StringBuilder__ctor_m1C0F2D97B838537A2D0F64033AE4EF02D150A956(L_2, L_1, /*hidden argument*/NULL);
V_0 = L_2;
V_1 = 0;
goto IL_003e;
}
IL_0010:
{
String_t* L_3 = ___displayName0;
int32_t L_4 = V_1;
NullCheck(L_3);
Il2CppChar L_5 = String_get_Chars_m14308AC3B95F8C1D9F1D1055B116B37D595F1D96(L_3, L_4, /*hidden argument*/NULL);
V_2 = L_5;
Il2CppChar L_6 = V_2;
if ((!(((uint32_t)L_6) == ((uint32_t)((int32_t)92)))))
{
goto IL_0032;
}
}
{
int32_t L_7 = V_1;
int32_t L_8 = ((int32_t)il2cpp_codegen_add((int32_t)L_7, (int32_t)1));
V_1 = L_8;
String_t* L_9 = ___displayName0;
NullCheck(L_9);
int32_t L_10 = String_get_Length_mD48C8A16A5CF1914F330DCE82D9BE15C3BEDD018(L_9, /*hidden argument*/NULL);
if ((((int32_t)L_8) >= ((int32_t)L_10)))
{
goto IL_0032;
}
}
{
String_t* L_11 = ___displayName0;
int32_t L_12 = V_1;
NullCheck(L_11);
Il2CppChar L_13 = String_get_Chars_m14308AC3B95F8C1D9F1D1055B116B37D595F1D96(L_11, L_12, /*hidden argument*/NULL);
V_2 = L_13;
}
IL_0032:
{
StringBuilder_t * L_14 = V_0;
Il2CppChar L_15 = V_2;
NullCheck(L_14);
StringBuilder_Append_m05C12F58ADC2D807613A9301DF438CB3CD09B75A(L_14, L_15, /*hidden argument*/NULL);
int32_t L_16 = V_1;
V_1 = ((int32_t)il2cpp_codegen_add((int32_t)L_16, (int32_t)1));
}
IL_003e:
{
int32_t L_17 = V_1;
String_t* L_18 = ___displayName0;
NullCheck(L_18);
int32_t L_19 = String_get_Length_mD48C8A16A5CF1914F330DCE82D9BE15C3BEDD018(L_18, /*hidden argument*/NULL);
if ((((int32_t)L_17) < ((int32_t)L_19)))
{
goto IL_0010;
}
}
{
StringBuilder_t * L_20 = V_0;
NullCheck(L_20);
String_t* L_21 = VirtFuncInvoker0< String_t* >::Invoke(3 /* System.String System.Object::ToString() */, L_20);
return L_21;
}
}
// System.Type System.TypeSpec::Resolve(System.Func`2<System.Reflection.AssemblyName,System.Reflection.Assembly>,System.Func`4<System.Reflection.Assembly,System.String,System.Boolean,System.Type>,System.Boolean,System.Boolean)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Type_t * TypeSpec_Resolve_mCE50015512C48D97F6D5558A2001825102BDDBF7 (TypeSpec_t943289F7C537252144A22588159B36C6B6759A7F * __this, Func_2_t13827C9725E0D12567E029E178981FB7D0E13430 * ___assemblyResolver0, Func_4_t3D7857A2A0F731D1E992FC5B09E983A8621FABFF * ___typeResolver1, bool ___throwOnError2, bool ___ignoreCase3, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (TypeSpec_Resolve_mCE50015512C48D97F6D5558A2001825102BDDBF7_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
Assembly_t * V_0 = NULL;
Type_t * V_1 = NULL;
Enumerator_tF3C2A3B3C8EE5956E26FA5AE4C14FC7655975628 V_2;
memset((&V_2), 0, sizeof(V_2));
RuntimeObject* V_3 = NULL;
Type_t * V_4 = NULL;
Type_t * V_5 = NULL;
TypeU5BU5D_t7FE623A666B49176DE123306221193E888A12F5F* V_6 = NULL;
int32_t V_7 = 0;
Type_t * V_8 = NULL;
Enumerator_t947A94EE32E8D5A1E40EDCC5D83206D0832E531D V_9;
memset((&V_9), 0, sizeof(V_9));
Exception_t * __last_unhandled_exception = 0;
NO_UNUSED_WARNING (__last_unhandled_exception);
Exception_t * __exception_local = 0;
NO_UNUSED_WARNING (__exception_local);
int32_t __leave_target = -1;
NO_UNUSED_WARNING (__leave_target);
{
V_0 = (Assembly_t *)NULL;
Func_2_t13827C9725E0D12567E029E178981FB7D0E13430 * L_0 = ___assemblyResolver0;
if (L_0)
{
goto IL_0017;
}
}
{
Func_4_t3D7857A2A0F731D1E992FC5B09E983A8621FABFF * L_1 = ___typeResolver1;
if (L_1)
{
goto IL_0017;
}
}
{
String_t* L_2 = TypeSpec_get_DisplayFullName_mE25183941E02D8885546E07565C790AF63A890FA(__this, /*hidden argument*/NULL);
bool L_3 = ___throwOnError2;
bool L_4 = ___ignoreCase3;
IL2CPP_RUNTIME_CLASS_INIT(Type_t_il2cpp_TypeInfo_var);
Type_t * L_5 = il2cpp_codegen_get_type((Il2CppMethodPointer)&Type_GetType_m77EF3A5A858B45C53D8BF27C74FA00CA83B53E59, L_2, L_3, L_4, "mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089");
return L_5;
}
IL_0017:
{
String_t* L_6 = __this->get_assembly_name_1();
if (!L_6)
{
goto IL_006b;
}
}
{
Func_2_t13827C9725E0D12567E029E178981FB7D0E13430 * L_7 = ___assemblyResolver0;
if (!L_7)
{
goto IL_0036;
}
}
{
Func_2_t13827C9725E0D12567E029E178981FB7D0E13430 * L_8 = ___assemblyResolver0;
String_t* L_9 = __this->get_assembly_name_1();
AssemblyName_t6F3EC58113268060348EE894DCB46F6EF6BBBB82 * L_10 = (AssemblyName_t6F3EC58113268060348EE894DCB46F6EF6BBBB82 *)il2cpp_codegen_object_new(AssemblyName_t6F3EC58113268060348EE894DCB46F6EF6BBBB82_il2cpp_TypeInfo_var);
AssemblyName__ctor_m9B2E1009DD65CCC1807A629A09D7CDEC26756FBF(L_10, L_9, /*hidden argument*/NULL);
NullCheck(L_8);
Assembly_t * L_11 = Func_2_Invoke_m18E0D4D4C27DA4526F57145018F8C5B7D4555786(L_8, L_10, /*hidden argument*/Func_2_Invoke_m18E0D4D4C27DA4526F57145018F8C5B7D4555786_RuntimeMethod_var);
V_0 = L_11;
goto IL_0042;
}
IL_0036:
{
String_t* L_12 = __this->get_assembly_name_1();
Assembly_t * L_13 = Assembly_Load_m4640304E91781FC3D197CD014B0C2DCEAFCFFF55(L_12, /*hidden argument*/NULL);
V_0 = L_13;
}
IL_0042:
{
Assembly_t * L_14 = V_0;
bool L_15 = Assembly_op_Equality_m4B6A318CE4104781ABF30A2BBBCCCFB0FE342316(L_14, (Assembly_t *)NULL, /*hidden argument*/NULL);
if (!L_15)
{
goto IL_006b;
}
}
{
bool L_16 = ___throwOnError2;
if (!L_16)
{
goto IL_0069;
}
}
{
String_t* L_17 = __this->get_assembly_name_1();
String_t* L_18 = String_Concat_mF4626905368D6558695A823466A1AF65EADB9923(_stringLiteralC85C60695430CEA397A21E8BE862BFEA63409E51, L_17, _stringLiteralBB589D0621E5472F470FA3425A234C74B1E202E8, /*hidden argument*/NULL);
FileNotFoundException_t0B3F0AE5C94A781A7E2ABBD786F91C229B703431 * L_19 = (FileNotFoundException_t0B3F0AE5C94A781A7E2ABBD786F91C229B703431 *)il2cpp_codegen_object_new(FileNotFoundException_t0B3F0AE5C94A781A7E2ABBD786F91C229B703431_il2cpp_TypeInfo_var);
FileNotFoundException__ctor_mA72DAA77008E903BC162A8D32FDE7F874B27E858(L_19, L_18, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_19, NULL, TypeSpec_Resolve_mCE50015512C48D97F6D5558A2001825102BDDBF7_RuntimeMethod_var);
}
IL_0069:
{
return (Type_t *)NULL;
}
IL_006b:
{
V_1 = (Type_t *)NULL;
Func_4_t3D7857A2A0F731D1E992FC5B09E983A8621FABFF * L_20 = ___typeResolver1;
if (!L_20)
{
goto IL_0087;
}
}
{
Func_4_t3D7857A2A0F731D1E992FC5B09E983A8621FABFF * L_21 = ___typeResolver1;
Assembly_t * L_22 = V_0;
RuntimeObject* L_23 = __this->get_name_0();
NullCheck(L_23);
String_t* L_24 = InterfaceFuncInvoker0< String_t* >::Invoke(0 /* System.String System.TypeName::get_DisplayName() */, TypeName_t0C63929669D92B034691B7E78AF79FA1F8592513_il2cpp_TypeInfo_var, L_23);
bool L_25 = ___ignoreCase3;
NullCheck(L_21);
Type_t * L_26 = Func_4_Invoke_m95D3A234FD84599FDA35F785ACE24B58A5103D13(L_21, L_22, L_24, L_25, /*hidden argument*/Func_4_Invoke_m95D3A234FD84599FDA35F785ACE24B58A5103D13_RuntimeMethod_var);
V_1 = L_26;
goto IL_009c;
}
IL_0087:
{
Assembly_t * L_27 = V_0;
RuntimeObject* L_28 = __this->get_name_0();
NullCheck(L_28);
String_t* L_29 = InterfaceFuncInvoker0< String_t* >::Invoke(0 /* System.String System.TypeName::get_DisplayName() */, TypeName_t0C63929669D92B034691B7E78AF79FA1F8592513_il2cpp_TypeInfo_var, L_28);
bool L_30 = ___ignoreCase3;
NullCheck(L_27);
Type_t * L_31 = VirtFuncInvoker3< Type_t *, String_t*, bool, bool >::Invoke(18 /* System.Type System.Reflection.Assembly::GetType(System.String,System.Boolean,System.Boolean) */, L_27, L_29, (bool)0, L_30);
V_1 = L_31;
}
IL_009c:
{
Type_t * L_32 = V_1;
IL2CPP_RUNTIME_CLASS_INIT(Type_t_il2cpp_TypeInfo_var);
bool L_33 = Type_op_Equality_m7040622C9E1037EFC73E1F0EDB1DD241282BE3D8(L_32, (Type_t *)NULL, /*hidden argument*/NULL);
if (!L_33)
{
goto IL_00c5;
}
}
{
bool L_34 = ___throwOnError2;
if (!L_34)
{
goto IL_00c3;
}
}
{
RuntimeObject* L_35 = __this->get_name_0();
String_t* L_36 = String_Concat_m2E1F71C491D2429CC80A28745488FEA947BB7AAC(_stringLiteralEFCF610D1253173FB3E0DF195C1F8D2667415453, L_35, _stringLiteralBB589D0621E5472F470FA3425A234C74B1E202E8, /*hidden argument*/NULL);
TypeLoadException_t510963B29CB27C6EA3ACDF5FB76E72E1BC372CD1 * L_37 = (TypeLoadException_t510963B29CB27C6EA3ACDF5FB76E72E1BC372CD1 *)il2cpp_codegen_object_new(TypeLoadException_t510963B29CB27C6EA3ACDF5FB76E72E1BC372CD1_il2cpp_TypeInfo_var);
TypeLoadException__ctor_m80951BFF6EB67A1ED3052D05569EF70D038B1581(L_37, L_36, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_37, NULL, TypeSpec_Resolve_mCE50015512C48D97F6D5558A2001825102BDDBF7_RuntimeMethod_var);
}
IL_00c3:
{
return (Type_t *)NULL;
}
IL_00c5:
{
List_1_tB8129EB4ADDDECD38E3E178F0A902C921B575166 * L_38 = __this->get_nested_2();
if (!L_38)
{
goto IL_013a;
}
}
{
List_1_tB8129EB4ADDDECD38E3E178F0A902C921B575166 * L_39 = __this->get_nested_2();
NullCheck(L_39);
Enumerator_tF3C2A3B3C8EE5956E26FA5AE4C14FC7655975628 L_40 = List_1_GetEnumerator_m2E4A41A21C3DEA2E56F3BAAC22CAC54ADDAAE89A(L_39, /*hidden argument*/List_1_GetEnumerator_m2E4A41A21C3DEA2E56F3BAAC22CAC54ADDAAE89A_RuntimeMethod_var);
V_2 = L_40;
}
IL_00d9:
try
{ // begin try (depth: 1)
{
goto IL_0121;
}
IL_00db:
{
RuntimeObject* L_41 = Enumerator_get_Current_m1FE262A1143A9C0B744CAE59FDF00A529A47DA7C((Enumerator_tF3C2A3B3C8EE5956E26FA5AE4C14FC7655975628 *)(&V_2), /*hidden argument*/Enumerator_get_Current_m1FE262A1143A9C0B744CAE59FDF00A529A47DA7C_RuntimeMethod_var);
V_3 = L_41;
Type_t * L_42 = V_1;
RuntimeObject* L_43 = V_3;
NullCheck(L_43);
String_t* L_44 = InterfaceFuncInvoker0< String_t* >::Invoke(0 /* System.String System.TypeName::get_DisplayName() */, TypeName_t0C63929669D92B034691B7E78AF79FA1F8592513_il2cpp_TypeInfo_var, L_43);
NullCheck(L_42);
Type_t * L_45 = VirtFuncInvoker2< Type_t *, String_t*, int32_t >::Invoke(49 /* System.Type System.Type::GetNestedType(System.String,System.Reflection.BindingFlags) */, L_42, L_44, ((int32_t)48));
V_4 = L_45;
Type_t * L_46 = V_4;
IL2CPP_RUNTIME_CLASS_INIT(Type_t_il2cpp_TypeInfo_var);
bool L_47 = Type_op_Equality_m7040622C9E1037EFC73E1F0EDB1DD241282BE3D8(L_46, (Type_t *)NULL, /*hidden argument*/NULL);
if (!L_47)
{
goto IL_011e;
}
}
IL_00fd:
{
bool L_48 = ___throwOnError2;
if (!L_48)
{
goto IL_0116;
}
}
IL_0100:
{
RuntimeObject* L_49 = V_3;
String_t* L_50 = String_Concat_m2E1F71C491D2429CC80A28745488FEA947BB7AAC(_stringLiteralEFCF610D1253173FB3E0DF195C1F8D2667415453, L_49, _stringLiteralBB589D0621E5472F470FA3425A234C74B1E202E8, /*hidden argument*/NULL);
TypeLoadException_t510963B29CB27C6EA3ACDF5FB76E72E1BC372CD1 * L_51 = (TypeLoadException_t510963B29CB27C6EA3ACDF5FB76E72E1BC372CD1 *)il2cpp_codegen_object_new(TypeLoadException_t510963B29CB27C6EA3ACDF5FB76E72E1BC372CD1_il2cpp_TypeInfo_var);
TypeLoadException__ctor_m80951BFF6EB67A1ED3052D05569EF70D038B1581(L_51, L_50, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_51, NULL, TypeSpec_Resolve_mCE50015512C48D97F6D5558A2001825102BDDBF7_RuntimeMethod_var);
}
IL_0116:
{
V_5 = (Type_t *)NULL;
IL2CPP_LEAVE(0x218, FINALLY_012c);
}
IL_011e:
{
Type_t * L_52 = V_4;
V_1 = L_52;
}
IL_0121:
{
bool L_53 = Enumerator_MoveNext_m5FA83E49042D278C984097B83622E3165E4564AD((Enumerator_tF3C2A3B3C8EE5956E26FA5AE4C14FC7655975628 *)(&V_2), /*hidden argument*/Enumerator_MoveNext_m5FA83E49042D278C984097B83622E3165E4564AD_RuntimeMethod_var);
if (L_53)
{
goto IL_00db;
}
}
IL_012a:
{
IL2CPP_LEAVE(0x13A, FINALLY_012c);
}
} // end try (depth: 1)
catch(Il2CppExceptionWrapper& e)
{
__last_unhandled_exception = (Exception_t *)e.ex;
goto FINALLY_012c;
}
FINALLY_012c:
{ // begin finally (depth: 1)
Enumerator_Dispose_m9FE451117A551A3AD97A0FC27C1C159B551B25F3((Enumerator_tF3C2A3B3C8EE5956E26FA5AE4C14FC7655975628 *)(&V_2), /*hidden argument*/Enumerator_Dispose_m9FE451117A551A3AD97A0FC27C1C159B551B25F3_RuntimeMethod_var);
IL2CPP_RESET_LEAVE(0x13A);
IL2CPP_END_FINALLY(300)
} // end finally (depth: 1)
IL2CPP_CLEANUP(300)
{
IL2CPP_JUMP_TBL(0x218, IL_0218)
IL2CPP_JUMP_TBL(0x13A, IL_013a)
IL2CPP_RETHROW_IF_UNHANDLED(Exception_t *)
}
IL_013a:
{
List_1_t8C8BF378AAB72B34B6EE63F686877AE7290ECFBA * L_54 = __this->get_generic_params_3();
if (!L_54)
{
goto IL_01c9;
}
}
{
List_1_t8C8BF378AAB72B34B6EE63F686877AE7290ECFBA * L_55 = __this->get_generic_params_3();
NullCheck(L_55);
int32_t L_56 = List_1_get_Count_m516B184735436F6F6363D5BDBC6469AAA19A10A4(L_55, /*hidden argument*/List_1_get_Count_m516B184735436F6F6363D5BDBC6469AAA19A10A4_RuntimeMethod_var);
TypeU5BU5D_t7FE623A666B49176DE123306221193E888A12F5F* L_57 = (TypeU5BU5D_t7FE623A666B49176DE123306221193E888A12F5F*)(TypeU5BU5D_t7FE623A666B49176DE123306221193E888A12F5F*)SZArrayNew(TypeU5BU5D_t7FE623A666B49176DE123306221193E888A12F5F_il2cpp_TypeInfo_var, (uint32_t)L_56);
V_6 = L_57;
V_7 = 0;
goto IL_01b8;
}
IL_015c:
{
List_1_t8C8BF378AAB72B34B6EE63F686877AE7290ECFBA * L_58 = __this->get_generic_params_3();
int32_t L_59 = V_7;
NullCheck(L_58);
TypeSpec_t943289F7C537252144A22588159B36C6B6759A7F * L_60 = List_1_get_Item_m942CEFAE0020F8EC07462ED0CFC951FFE66CBD46(L_58, L_59, /*hidden argument*/List_1_get_Item_m942CEFAE0020F8EC07462ED0CFC951FFE66CBD46_RuntimeMethod_var);
Func_2_t13827C9725E0D12567E029E178981FB7D0E13430 * L_61 = ___assemblyResolver0;
Func_4_t3D7857A2A0F731D1E992FC5B09E983A8621FABFF * L_62 = ___typeResolver1;
bool L_63 = ___throwOnError2;
bool L_64 = ___ignoreCase3;
NullCheck(L_60);
Type_t * L_65 = TypeSpec_Resolve_mCE50015512C48D97F6D5558A2001825102BDDBF7(L_60, L_61, L_62, L_63, L_64, /*hidden argument*/NULL);
V_8 = L_65;
Type_t * L_66 = V_8;
IL2CPP_RUNTIME_CLASS_INIT(Type_t_il2cpp_TypeInfo_var);
bool L_67 = Type_op_Equality_m7040622C9E1037EFC73E1F0EDB1DD241282BE3D8(L_66, (Type_t *)NULL, /*hidden argument*/NULL);
if (!L_67)
{
goto IL_01ab;
}
}
{
bool L_68 = ___throwOnError2;
if (!L_68)
{
goto IL_01a9;
}
}
{
List_1_t8C8BF378AAB72B34B6EE63F686877AE7290ECFBA * L_69 = __this->get_generic_params_3();
int32_t L_70 = V_7;
NullCheck(L_69);
TypeSpec_t943289F7C537252144A22588159B36C6B6759A7F * L_71 = List_1_get_Item_m942CEFAE0020F8EC07462ED0CFC951FFE66CBD46(L_69, L_70, /*hidden argument*/List_1_get_Item_m942CEFAE0020F8EC07462ED0CFC951FFE66CBD46_RuntimeMethod_var);
NullCheck(L_71);
RuntimeObject* L_72 = L_71->get_name_0();
String_t* L_73 = String_Concat_m2E1F71C491D2429CC80A28745488FEA947BB7AAC(_stringLiteralEFCF610D1253173FB3E0DF195C1F8D2667415453, L_72, _stringLiteralBB589D0621E5472F470FA3425A234C74B1E202E8, /*hidden argument*/NULL);
TypeLoadException_t510963B29CB27C6EA3ACDF5FB76E72E1BC372CD1 * L_74 = (TypeLoadException_t510963B29CB27C6EA3ACDF5FB76E72E1BC372CD1 *)il2cpp_codegen_object_new(TypeLoadException_t510963B29CB27C6EA3ACDF5FB76E72E1BC372CD1_il2cpp_TypeInfo_var);
TypeLoadException__ctor_m80951BFF6EB67A1ED3052D05569EF70D038B1581(L_74, L_73, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_74, NULL, TypeSpec_Resolve_mCE50015512C48D97F6D5558A2001825102BDDBF7_RuntimeMethod_var);
}
IL_01a9:
{
return (Type_t *)NULL;
}
IL_01ab:
{
TypeU5BU5D_t7FE623A666B49176DE123306221193E888A12F5F* L_75 = V_6;
int32_t L_76 = V_7;
Type_t * L_77 = V_8;
NullCheck(L_75);
ArrayElementTypeCheck (L_75, L_77);
(L_75)->SetAt(static_cast<il2cpp_array_size_t>(L_76), (Type_t *)L_77);
int32_t L_78 = V_7;
V_7 = ((int32_t)il2cpp_codegen_add((int32_t)L_78, (int32_t)1));
}
IL_01b8:
{
int32_t L_79 = V_7;
TypeU5BU5D_t7FE623A666B49176DE123306221193E888A12F5F* L_80 = V_6;
NullCheck(L_80);
if ((((int32_t)L_79) < ((int32_t)(((int32_t)((int32_t)(((RuntimeArray*)L_80)->max_length)))))))
{
goto IL_015c;
}
}
{
Type_t * L_81 = V_1;
TypeU5BU5D_t7FE623A666B49176DE123306221193E888A12F5F* L_82 = V_6;
NullCheck(L_81);
Type_t * L_83 = VirtFuncInvoker1< Type_t *, TypeU5BU5D_t7FE623A666B49176DE123306221193E888A12F5F* >::Invoke(89 /* System.Type System.Type::MakeGenericType(System.Type[]) */, L_81, L_82);
V_1 = L_83;
}
IL_01c9:
{
List_1_tFD995FD9C5961BB4B415EE63B297C4B19643A3C2 * L_84 = __this->get_modifier_spec_4();
if (!L_84)
{
goto IL_0207;
}
}
{
List_1_tFD995FD9C5961BB4B415EE63B297C4B19643A3C2 * L_85 = __this->get_modifier_spec_4();
NullCheck(L_85);
Enumerator_t947A94EE32E8D5A1E40EDCC5D83206D0832E531D L_86 = List_1_GetEnumerator_m7F1A981C4F56927EB6D80776859EFEB2A949645F(L_85, /*hidden argument*/List_1_GetEnumerator_m7F1A981C4F56927EB6D80776859EFEB2A949645F_RuntimeMethod_var);
V_9 = L_86;
}
IL_01de:
try
{ // begin try (depth: 1)
{
goto IL_01ee;
}
IL_01e0:
{
RuntimeObject* L_87 = Enumerator_get_Current_mABF1CE6A366A00FB242CDDC13D80881F14052780((Enumerator_t947A94EE32E8D5A1E40EDCC5D83206D0832E531D *)(&V_9), /*hidden argument*/Enumerator_get_Current_mABF1CE6A366A00FB242CDDC13D80881F14052780_RuntimeMethod_var);
Type_t * L_88 = V_1;
NullCheck(L_87);
Type_t * L_89 = InterfaceFuncInvoker1< Type_t *, Type_t * >::Invoke(0 /* System.Type System.ModifierSpec::Resolve(System.Type) */, ModifierSpec_t0A5286DDFBD682F1E1D8AEBE5FD9D34EAB4CF1E5_il2cpp_TypeInfo_var, L_87, L_88);
V_1 = L_89;
}
IL_01ee:
{
bool L_90 = Enumerator_MoveNext_mD91BF5A0EE3F48F18729E9A081A22223CBA9134E((Enumerator_t947A94EE32E8D5A1E40EDCC5D83206D0832E531D *)(&V_9), /*hidden argument*/Enumerator_MoveNext_mD91BF5A0EE3F48F18729E9A081A22223CBA9134E_RuntimeMethod_var);
if (L_90)
{
goto IL_01e0;
}
}
IL_01f7:
{
IL2CPP_LEAVE(0x207, FINALLY_01f9);
}
} // end try (depth: 1)
catch(Il2CppExceptionWrapper& e)
{
__last_unhandled_exception = (Exception_t *)e.ex;
goto FINALLY_01f9;
}
FINALLY_01f9:
{ // begin finally (depth: 1)
Enumerator_Dispose_m4B5D4976D2C83F3DB387137CD7DE096E0C28370B((Enumerator_t947A94EE32E8D5A1E40EDCC5D83206D0832E531D *)(&V_9), /*hidden argument*/Enumerator_Dispose_m4B5D4976D2C83F3DB387137CD7DE096E0C28370B_RuntimeMethod_var);
IL2CPP_RESET_LEAVE(0x207);
IL2CPP_END_FINALLY(505)
} // end finally (depth: 1)
IL2CPP_CLEANUP(505)
{
IL2CPP_JUMP_TBL(0x207, IL_0207)
IL2CPP_RETHROW_IF_UNHANDLED(Exception_t *)
}
IL_0207:
{
bool L_91 = __this->get_is_byref_5();
if (!L_91)
{
goto IL_0216;
}
}
{
Type_t * L_92 = V_1;
NullCheck(L_92);
Type_t * L_93 = VirtFuncInvoker0< Type_t * >::Invoke(18 /* System.Type System.Type::MakeByRefType() */, L_92);
V_1 = L_93;
}
IL_0216:
{
Type_t * L_94 = V_1;
return L_94;
}
IL_0218:
{
Type_t * L_95 = V_5;
return L_95;
}
}
// System.Void System.TypeSpec::AddName(System.String)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void TypeSpec_AddName_mEF7336F662841D8A5B8157BA703C8959A808C9B7 (TypeSpec_t943289F7C537252144A22588159B36C6B6759A7F * __this, String_t* ___type_name0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (TypeSpec_AddName_mEF7336F662841D8A5B8157BA703C8959A808C9B7_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
RuntimeObject* L_0 = __this->get_name_0();
if (L_0)
{
goto IL_0015;
}
}
{
String_t* L_1 = ___type_name0;
RuntimeObject* L_2 = TypeSpec_ParsedTypeIdentifier_m9D32F152A6F9863DCF3EFBF495B6CC16747E851E(L_1, /*hidden argument*/NULL);
__this->set_name_0(L_2);
return;
}
IL_0015:
{
List_1_tB8129EB4ADDDECD38E3E178F0A902C921B575166 * L_3 = __this->get_nested_2();
if (L_3)
{
goto IL_0028;
}
}
{
List_1_tB8129EB4ADDDECD38E3E178F0A902C921B575166 * L_4 = (List_1_tB8129EB4ADDDECD38E3E178F0A902C921B575166 *)il2cpp_codegen_object_new(List_1_tB8129EB4ADDDECD38E3E178F0A902C921B575166_il2cpp_TypeInfo_var);
List_1__ctor_m21E88645DC77FDCB68ED0EA3602951A2609C963C(L_4, /*hidden argument*/List_1__ctor_m21E88645DC77FDCB68ED0EA3602951A2609C963C_RuntimeMethod_var);
__this->set_nested_2(L_4);
}
IL_0028:
{
List_1_tB8129EB4ADDDECD38E3E178F0A902C921B575166 * L_5 = __this->get_nested_2();
String_t* L_6 = ___type_name0;
RuntimeObject* L_7 = TypeSpec_ParsedTypeIdentifier_m9D32F152A6F9863DCF3EFBF495B6CC16747E851E(L_6, /*hidden argument*/NULL);
NullCheck(L_5);
List_1_Add_m191DF682AFC83E635052DB3C303E514D6D7233A2(L_5, L_7, /*hidden argument*/List_1_Add_m191DF682AFC83E635052DB3C303E514D6D7233A2_RuntimeMethod_var);
return;
}
}
// System.Void System.TypeSpec::AddModifier(System.ModifierSpec)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void TypeSpec_AddModifier_m082500BAE4A512BA0E84CC85A71F4A67DA885909 (TypeSpec_t943289F7C537252144A22588159B36C6B6759A7F * __this, RuntimeObject* ___md0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (TypeSpec_AddModifier_m082500BAE4A512BA0E84CC85A71F4A67DA885909_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
List_1_tFD995FD9C5961BB4B415EE63B297C4B19643A3C2 * L_0 = __this->get_modifier_spec_4();
if (L_0)
{
goto IL_0013;
}
}
{
List_1_tFD995FD9C5961BB4B415EE63B297C4B19643A3C2 * L_1 = (List_1_tFD995FD9C5961BB4B415EE63B297C4B19643A3C2 *)il2cpp_codegen_object_new(List_1_tFD995FD9C5961BB4B415EE63B297C4B19643A3C2_il2cpp_TypeInfo_var);
List_1__ctor_mA97DC4CD260A1FD5F8FD67E06EE8F27E5C03CF63(L_1, /*hidden argument*/List_1__ctor_mA97DC4CD260A1FD5F8FD67E06EE8F27E5C03CF63_RuntimeMethod_var);
__this->set_modifier_spec_4(L_1);
}
IL_0013:
{
List_1_tFD995FD9C5961BB4B415EE63B297C4B19643A3C2 * L_2 = __this->get_modifier_spec_4();
RuntimeObject* L_3 = ___md0;
NullCheck(L_2);
List_1_Add_mEA738D5941352BC4540C28F701A4BF01E2DF7914(L_2, L_3, /*hidden argument*/List_1_Add_mEA738D5941352BC4540C28F701A4BF01E2DF7914_RuntimeMethod_var);
return;
}
}
// System.Void System.TypeSpec::SkipSpace(System.String,System.Int32U26)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void TypeSpec_SkipSpace_mF388B6F9C82F795BA722B706A5435B0E799A531C (String_t* ___name0, int32_t* ___pos1, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (TypeSpec_SkipSpace_mF388B6F9C82F795BA722B706A5435B0E799A531C_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
int32_t V_0 = 0;
{
int32_t* L_0 = ___pos1;
int32_t L_1 = *((int32_t*)L_0);
V_0 = L_1;
goto IL_0009;
}
IL_0005:
{
int32_t L_2 = V_0;
V_0 = ((int32_t)il2cpp_codegen_add((int32_t)L_2, (int32_t)1));
}
IL_0009:
{
int32_t L_3 = V_0;
String_t* L_4 = ___name0;
NullCheck(L_4);
int32_t L_5 = String_get_Length_mD48C8A16A5CF1914F330DCE82D9BE15C3BEDD018(L_4, /*hidden argument*/NULL);
if ((((int32_t)L_3) >= ((int32_t)L_5)))
{
goto IL_0020;
}
}
{
String_t* L_6 = ___name0;
int32_t L_7 = V_0;
NullCheck(L_6);
Il2CppChar L_8 = String_get_Chars_m14308AC3B95F8C1D9F1D1055B116B37D595F1D96(L_6, L_7, /*hidden argument*/NULL);
IL2CPP_RUNTIME_CLASS_INIT(Char_tBF22D9FC341BE970735250BB6FF1A4A92BBA58B9_il2cpp_TypeInfo_var);
bool L_9 = Char_IsWhiteSpace_m8AE1C4157A1E1D8F5022630F4229AB26223BDC6B(L_8, /*hidden argument*/NULL);
if (L_9)
{
goto IL_0005;
}
}
IL_0020:
{
int32_t* L_10 = ___pos1;
int32_t L_11 = V_0;
*((int32_t*)L_10) = (int32_t)L_11;
return;
}
}
// System.Void System.TypeSpec::BoundCheck(System.Int32,System.String)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void TypeSpec_BoundCheck_m5CF5E6F2632D8D4D205DC26F6666BE9EA7D874FB (int32_t ___idx0, String_t* ___s1, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (TypeSpec_BoundCheck_m5CF5E6F2632D8D4D205DC26F6666BE9EA7D874FB_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
int32_t L_0 = ___idx0;
String_t* L_1 = ___s1;
NullCheck(L_1);
int32_t L_2 = String_get_Length_mD48C8A16A5CF1914F330DCE82D9BE15C3BEDD018(L_1, /*hidden argument*/NULL);
if ((((int32_t)L_0) < ((int32_t)L_2)))
{
goto IL_0019;
}
}
{
ArgumentException_tEDCD16F20A09ECE461C3DA766C16EDA8864057D1 * L_3 = (ArgumentException_tEDCD16F20A09ECE461C3DA766C16EDA8864057D1 *)il2cpp_codegen_object_new(ArgumentException_tEDCD16F20A09ECE461C3DA766C16EDA8864057D1_il2cpp_TypeInfo_var);
ArgumentException__ctor_m26DC3463C6F3C98BF33EA39598DD2B32F0249CA8(L_3, _stringLiteral2CF6DC09435066749111F8BD9F5270166FE06F3F, _stringLiteral9FA22049CF6367C2DB11AB15BC3EDE8D5104CB06, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_3, NULL, TypeSpec_BoundCheck_m5CF5E6F2632D8D4D205DC26F6666BE9EA7D874FB_RuntimeMethod_var);
}
IL_0019:
{
return;
}
}
// System.TypeIdentifier System.TypeSpec::ParsedTypeIdentifier(System.String)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject* TypeSpec_ParsedTypeIdentifier_m9D32F152A6F9863DCF3EFBF495B6CC16747E851E (String_t* ___displayName0, const RuntimeMethod* method)
{
{
String_t* L_0 = ___displayName0;
RuntimeObject* L_1 = TypeIdentifiers_FromDisplay_m08FB8BE03D80603F9A030774E218310DC96693CE(L_0, /*hidden argument*/NULL);
return L_1;
}
}
// System.TypeSpec System.TypeSpec::Parse(System.String,System.Int32U26,System.Boolean,System.Boolean)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR TypeSpec_t943289F7C537252144A22588159B36C6B6759A7F * TypeSpec_Parse_m9AE5F2E214E154E1AEDCB27FD207B0C4C8EBC405 (String_t* ___name0, int32_t* ___p1, bool ___is_recurse2, bool ___allow_aqn3, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (TypeSpec_Parse_m9AE5F2E214E154E1AEDCB27FD207B0C4C8EBC405_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
int32_t V_0 = 0;
int32_t V_1 = 0;
bool V_2 = false;
TypeSpec_t943289F7C537252144A22588159B36C6B6759A7F * V_3 = NULL;
Il2CppChar V_4 = 0x0;
int32_t V_5 = 0;
int32_t V_6 = 0;
List_1_t8C8BF378AAB72B34B6EE63F686877AE7290ECFBA * V_7 = NULL;
bool V_8 = false;
int32_t V_9 = 0;
bool V_10 = false;
{
int32_t* L_0 = ___p1;
int32_t L_1 = *((int32_t*)L_0);
V_0 = L_1;
V_2 = (bool)0;
TypeSpec_t943289F7C537252144A22588159B36C6B6759A7F * L_2 = (TypeSpec_t943289F7C537252144A22588159B36C6B6759A7F *)il2cpp_codegen_object_new(TypeSpec_t943289F7C537252144A22588159B36C6B6759A7F_il2cpp_TypeInfo_var);
TypeSpec__ctor_m18DCF64756F091CE7A7DA6CDAD3142419602D901(L_2, /*hidden argument*/NULL);
V_3 = L_2;
String_t* L_3 = ___name0;
TypeSpec_SkipSpace_mF388B6F9C82F795BA722B706A5435B0E799A531C(L_3, (int32_t*)(&V_0), /*hidden argument*/NULL);
int32_t L_4 = V_0;
V_1 = L_4;
goto IL_00dd;
}
IL_001a:
{
String_t* L_5 = ___name0;
int32_t L_6 = V_0;
NullCheck(L_5);
Il2CppChar L_7 = String_get_Chars_m14308AC3B95F8C1D9F1D1055B116B37D595F1D96(L_5, L_6, /*hidden argument*/NULL);
V_4 = L_7;
Il2CppChar L_8 = V_4;
switch (((int32_t)il2cpp_codegen_subtract((int32_t)L_8, (int32_t)((int32_t)38))))
{
case 0:
{
goto IL_0098;
}
case 1:
{
goto IL_00d6;
}
case 2:
{
goto IL_00d6;
}
case 3:
{
goto IL_00d6;
}
case 4:
{
goto IL_0098;
}
case 5:
{
goto IL_0061;
}
case 6:
{
goto IL_0077;
}
}
}
{
Il2CppChar L_9 = V_4;
switch (((int32_t)il2cpp_codegen_subtract((int32_t)L_9, (int32_t)((int32_t)91))))
{
case 0:
{
goto IL_0098;
}
case 1:
{
goto IL_00d2;
}
case 2:
{
goto IL_0077;
}
}
}
{
goto IL_00d6;
}
IL_0061:
{
TypeSpec_t943289F7C537252144A22588159B36C6B6759A7F * L_10 = V_3;
String_t* L_11 = ___name0;
int32_t L_12 = V_1;
int32_t L_13 = V_0;
int32_t L_14 = V_1;
NullCheck(L_11);
String_t* L_15 = String_Substring_mB593C0A320C683E6E47EFFC0A12B7A465E5E43BB(L_11, L_12, ((int32_t)il2cpp_codegen_subtract((int32_t)L_13, (int32_t)L_14)), /*hidden argument*/NULL);
NullCheck(L_10);
TypeSpec_AddName_mEF7336F662841D8A5B8157BA703C8959A808C9B7(L_10, L_15, /*hidden argument*/NULL);
int32_t L_16 = V_0;
V_1 = ((int32_t)il2cpp_codegen_add((int32_t)L_16, (int32_t)1));
goto IL_00d6;
}
IL_0077:
{
TypeSpec_t943289F7C537252144A22588159B36C6B6759A7F * L_17 = V_3;
String_t* L_18 = ___name0;
int32_t L_19 = V_1;
int32_t L_20 = V_0;
int32_t L_21 = V_1;
NullCheck(L_18);
String_t* L_22 = String_Substring_mB593C0A320C683E6E47EFFC0A12B7A465E5E43BB(L_18, L_19, ((int32_t)il2cpp_codegen_subtract((int32_t)L_20, (int32_t)L_21)), /*hidden argument*/NULL);
NullCheck(L_17);
TypeSpec_AddName_mEF7336F662841D8A5B8157BA703C8959A808C9B7(L_17, L_22, /*hidden argument*/NULL);
int32_t L_23 = V_0;
V_1 = ((int32_t)il2cpp_codegen_add((int32_t)L_23, (int32_t)1));
V_2 = (bool)1;
bool L_24 = ___is_recurse2;
if (!L_24)
{
goto IL_00d6;
}
}
{
bool L_25 = ___allow_aqn3;
if (L_25)
{
goto IL_00d6;
}
}
{
int32_t* L_26 = ___p1;
int32_t L_27 = V_0;
*((int32_t*)L_26) = (int32_t)L_27;
TypeSpec_t943289F7C537252144A22588159B36C6B6759A7F * L_28 = V_3;
return L_28;
}
IL_0098:
{
String_t* L_29 = ___name0;
int32_t L_30 = V_0;
NullCheck(L_29);
Il2CppChar L_31 = String_get_Chars_m14308AC3B95F8C1D9F1D1055B116B37D595F1D96(L_29, L_30, /*hidden argument*/NULL);
bool L_32 = ___is_recurse2;
if (!((int32_t)((int32_t)((((int32_t)((((int32_t)L_31) == ((int32_t)((int32_t)91)))? 1 : 0)) == ((int32_t)0))? 1 : 0)&(int32_t)L_32)))
{
goto IL_00ba;
}
}
{
ArgumentException_tEDCD16F20A09ECE461C3DA766C16EDA8864057D1 * L_33 = (ArgumentException_tEDCD16F20A09ECE461C3DA766C16EDA8864057D1 *)il2cpp_codegen_object_new(ArgumentException_tEDCD16F20A09ECE461C3DA766C16EDA8864057D1_il2cpp_TypeInfo_var);
ArgumentException__ctor_m26DC3463C6F3C98BF33EA39598DD2B32F0249CA8(L_33, _stringLiteral571BFF034952AEEE7E64D932D2A2A51072118F24, _stringLiteral9FA22049CF6367C2DB11AB15BC3EDE8D5104CB06, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_33, NULL, TypeSpec_Parse_m9AE5F2E214E154E1AEDCB27FD207B0C4C8EBC405_RuntimeMethod_var);
}
IL_00ba:
{
TypeSpec_t943289F7C537252144A22588159B36C6B6759A7F * L_34 = V_3;
String_t* L_35 = ___name0;
int32_t L_36 = V_1;
int32_t L_37 = V_0;
int32_t L_38 = V_1;
NullCheck(L_35);
String_t* L_39 = String_Substring_mB593C0A320C683E6E47EFFC0A12B7A465E5E43BB(L_35, L_36, ((int32_t)il2cpp_codegen_subtract((int32_t)L_37, (int32_t)L_38)), /*hidden argument*/NULL);
NullCheck(L_34);
TypeSpec_AddName_mEF7336F662841D8A5B8157BA703C8959A808C9B7(L_34, L_39, /*hidden argument*/NULL);
int32_t L_40 = V_0;
V_1 = ((int32_t)il2cpp_codegen_add((int32_t)L_40, (int32_t)1));
V_2 = (bool)1;
goto IL_00d6;
}
IL_00d2:
{
int32_t L_41 = V_0;
V_0 = ((int32_t)il2cpp_codegen_add((int32_t)L_41, (int32_t)1));
}
IL_00d6:
{
bool L_42 = V_2;
if (L_42)
{
goto IL_00e9;
}
}
{
int32_t L_43 = V_0;
V_0 = ((int32_t)il2cpp_codegen_add((int32_t)L_43, (int32_t)1));
}
IL_00dd:
{
int32_t L_44 = V_0;
String_t* L_45 = ___name0;
NullCheck(L_45);
int32_t L_46 = String_get_Length_mD48C8A16A5CF1914F330DCE82D9BE15C3BEDD018(L_45, /*hidden argument*/NULL);
if ((((int32_t)L_44) < ((int32_t)L_46)))
{
goto IL_001a;
}
}
IL_00e9:
{
int32_t L_47 = V_1;
int32_t L_48 = V_0;
if ((((int32_t)L_47) >= ((int32_t)L_48)))
{
goto IL_00ff;
}
}
{
TypeSpec_t943289F7C537252144A22588159B36C6B6759A7F * L_49 = V_3;
String_t* L_50 = ___name0;
int32_t L_51 = V_1;
int32_t L_52 = V_0;
int32_t L_53 = V_1;
NullCheck(L_50);
String_t* L_54 = String_Substring_mB593C0A320C683E6E47EFFC0A12B7A465E5E43BB(L_50, L_51, ((int32_t)il2cpp_codegen_subtract((int32_t)L_52, (int32_t)L_53)), /*hidden argument*/NULL);
NullCheck(L_49);
TypeSpec_AddName_mEF7336F662841D8A5B8157BA703C8959A808C9B7(L_49, L_54, /*hidden argument*/NULL);
goto IL_010e;
}
IL_00ff:
{
int32_t L_55 = V_1;
int32_t L_56 = V_0;
if ((!(((uint32_t)L_55) == ((uint32_t)L_56))))
{
goto IL_010e;
}
}
{
TypeSpec_t943289F7C537252144A22588159B36C6B6759A7F * L_57 = V_3;
String_t* L_58 = ((String_t_StaticFields*)il2cpp_codegen_static_fields_for(String_t_il2cpp_TypeInfo_var))->get_Empty_5();
NullCheck(L_57);
TypeSpec_AddName_mEF7336F662841D8A5B8157BA703C8959A808C9B7(L_57, L_58, /*hidden argument*/NULL);
}
IL_010e:
{
bool L_59 = V_2;
if (!L_59)
{
goto IL_0510;
}
}
{
goto IL_0504;
}
IL_0119:
{
String_t* L_60 = ___name0;
int32_t L_61 = V_0;
NullCheck(L_60);
Il2CppChar L_62 = String_get_Chars_m14308AC3B95F8C1D9F1D1055B116B37D595F1D96(L_60, L_61, /*hidden argument*/NULL);
V_4 = L_62;
Il2CppChar L_63 = V_4;
if ((!(((uint32_t)L_63) <= ((uint32_t)((int32_t)42)))))
{
goto IL_0139;
}
}
{
Il2CppChar L_64 = V_4;
if ((((int32_t)L_64) == ((int32_t)((int32_t)38))))
{
goto IL_0159;
}
}
{
Il2CppChar L_65 = V_4;
if ((((int32_t)L_65) == ((int32_t)((int32_t)42))))
{
goto IL_017d;
}
}
{
goto IL_04be;
}
IL_0139:
{
Il2CppChar L_66 = V_4;
if ((((int32_t)L_66) == ((int32_t)((int32_t)44))))
{
goto IL_01ce;
}
}
{
Il2CppChar L_67 = V_4;
if ((((int32_t)L_67) == ((int32_t)((int32_t)91))))
{
goto IL_0257;
}
}
{
Il2CppChar L_68 = V_4;
if ((((int32_t)L_68) == ((int32_t)((int32_t)93))))
{
goto IL_04a6;
}
}
{
goto IL_04be;
}
IL_0159:
{
TypeSpec_t943289F7C537252144A22588159B36C6B6759A7F * L_69 = V_3;
NullCheck(L_69);
bool L_70 = L_69->get_is_byref_5();
if (!L_70)
{
goto IL_0171;
}
}
{
ArgumentException_tEDCD16F20A09ECE461C3DA766C16EDA8864057D1 * L_71 = (ArgumentException_tEDCD16F20A09ECE461C3DA766C16EDA8864057D1 *)il2cpp_codegen_object_new(ArgumentException_tEDCD16F20A09ECE461C3DA766C16EDA8864057D1_il2cpp_TypeInfo_var);
ArgumentException__ctor_m26DC3463C6F3C98BF33EA39598DD2B32F0249CA8(L_71, _stringLiteral40CC7C91CEDB85B93D4EACD5B58CD3EED8F78995, _stringLiteral9FA22049CF6367C2DB11AB15BC3EDE8D5104CB06, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_71, NULL, TypeSpec_Parse_m9AE5F2E214E154E1AEDCB27FD207B0C4C8EBC405_RuntimeMethod_var);
}
IL_0171:
{
TypeSpec_t943289F7C537252144A22588159B36C6B6759A7F * L_72 = V_3;
NullCheck(L_72);
L_72->set_is_byref_5((bool)1);
goto IL_0500;
}
IL_017d:
{
TypeSpec_t943289F7C537252144A22588159B36C6B6759A7F * L_73 = V_3;
NullCheck(L_73);
bool L_74 = L_73->get_is_byref_5();
if (!L_74)
{
goto IL_0195;
}
}
{
ArgumentException_tEDCD16F20A09ECE461C3DA766C16EDA8864057D1 * L_75 = (ArgumentException_tEDCD16F20A09ECE461C3DA766C16EDA8864057D1 *)il2cpp_codegen_object_new(ArgumentException_tEDCD16F20A09ECE461C3DA766C16EDA8864057D1_il2cpp_TypeInfo_var);
ArgumentException__ctor_m26DC3463C6F3C98BF33EA39598DD2B32F0249CA8(L_75, _stringLiteral1EBF18F72F75A7724D91ED7167E98A93A6497F6E, _stringLiteral9FA22049CF6367C2DB11AB15BC3EDE8D5104CB06, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_75, NULL, TypeSpec_Parse_m9AE5F2E214E154E1AEDCB27FD207B0C4C8EBC405_RuntimeMethod_var);
}
IL_0195:
{
V_5 = 1;
goto IL_01a4;
}
IL_019a:
{
int32_t L_76 = V_0;
V_0 = ((int32_t)il2cpp_codegen_add((int32_t)L_76, (int32_t)1));
int32_t L_77 = V_5;
V_5 = ((int32_t)il2cpp_codegen_add((int32_t)L_77, (int32_t)1));
}
IL_01a4:
{
int32_t L_78 = V_0;
String_t* L_79 = ___name0;
NullCheck(L_79);
int32_t L_80 = String_get_Length_mD48C8A16A5CF1914F330DCE82D9BE15C3BEDD018(L_79, /*hidden argument*/NULL);
if ((((int32_t)((int32_t)il2cpp_codegen_add((int32_t)L_78, (int32_t)1))) >= ((int32_t)L_80)))
{
goto IL_01bc;
}
}
{
String_t* L_81 = ___name0;
int32_t L_82 = V_0;
NullCheck(L_81);
Il2CppChar L_83 = String_get_Chars_m14308AC3B95F8C1D9F1D1055B116B37D595F1D96(L_81, ((int32_t)il2cpp_codegen_add((int32_t)L_82, (int32_t)1)), /*hidden argument*/NULL);
if ((((int32_t)L_83) == ((int32_t)((int32_t)42))))
{
goto IL_019a;
}
}
IL_01bc:
{
TypeSpec_t943289F7C537252144A22588159B36C6B6759A7F * L_84 = V_3;
int32_t L_85 = V_5;
PointerSpec_tBCE1666DC24EC6E4E5376FEC214499984EC26892 * L_86 = (PointerSpec_tBCE1666DC24EC6E4E5376FEC214499984EC26892 *)il2cpp_codegen_object_new(PointerSpec_tBCE1666DC24EC6E4E5376FEC214499984EC26892_il2cpp_TypeInfo_var);
PointerSpec__ctor_mB00CD482EDE6910DE19A767C128B00785F1A2136(L_86, L_85, /*hidden argument*/NULL);
NullCheck(L_84);
TypeSpec_AddModifier_m082500BAE4A512BA0E84CC85A71F4A67DA885909(L_84, L_86, /*hidden argument*/NULL);
goto IL_0500;
}
IL_01ce:
{
bool L_87 = ___is_recurse2;
bool L_88 = ___allow_aqn3;
if (!((int32_t)((int32_t)L_87&(int32_t)L_88)))
{
goto IL_0229;
}
}
{
int32_t L_89 = V_0;
V_6 = L_89;
goto IL_01de;
}
IL_01d8:
{
int32_t L_90 = V_6;
V_6 = ((int32_t)il2cpp_codegen_add((int32_t)L_90, (int32_t)1));
}
IL_01de:
{
int32_t L_91 = V_6;
String_t* L_92 = ___name0;
NullCheck(L_92);
int32_t L_93 = String_get_Length_mD48C8A16A5CF1914F330DCE82D9BE15C3BEDD018(L_92, /*hidden argument*/NULL);
if ((((int32_t)L_91) >= ((int32_t)L_93)))
{
goto IL_01f4;
}
}
{
String_t* L_94 = ___name0;
int32_t L_95 = V_6;
NullCheck(L_94);
Il2CppChar L_96 = String_get_Chars_m14308AC3B95F8C1D9F1D1055B116B37D595F1D96(L_94, L_95, /*hidden argument*/NULL);
if ((!(((uint32_t)L_96) == ((uint32_t)((int32_t)93)))))
{
goto IL_01d8;
}
}
IL_01f4:
{
int32_t L_97 = V_6;
String_t* L_98 = ___name0;
NullCheck(L_98);
int32_t L_99 = String_get_Length_mD48C8A16A5CF1914F330DCE82D9BE15C3BEDD018(L_98, /*hidden argument*/NULL);
if ((((int32_t)L_97) < ((int32_t)L_99)))
{
goto IL_0209;
}
}
{
ArgumentException_tEDCD16F20A09ECE461C3DA766C16EDA8864057D1 * L_100 = (ArgumentException_tEDCD16F20A09ECE461C3DA766C16EDA8864057D1 *)il2cpp_codegen_object_new(ArgumentException_tEDCD16F20A09ECE461C3DA766C16EDA8864057D1_il2cpp_TypeInfo_var);
ArgumentException__ctor_m9A85EF7FEFEC21DDD525A67E831D77278E5165B7(L_100, _stringLiteral3CC14F805C52F5EF488C806DE2DB5C83C5496346, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_100, NULL, TypeSpec_Parse_m9AE5F2E214E154E1AEDCB27FD207B0C4C8EBC405_RuntimeMethod_var);
}
IL_0209:
{
TypeSpec_t943289F7C537252144A22588159B36C6B6759A7F * L_101 = V_3;
String_t* L_102 = ___name0;
int32_t L_103 = V_0;
int32_t L_104 = V_6;
int32_t L_105 = V_0;
NullCheck(L_102);
String_t* L_106 = String_Substring_mB593C0A320C683E6E47EFFC0A12B7A465E5E43BB(L_102, ((int32_t)il2cpp_codegen_add((int32_t)L_103, (int32_t)1)), ((int32_t)il2cpp_codegen_subtract((int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)L_104, (int32_t)L_105)), (int32_t)1)), /*hidden argument*/NULL);
NullCheck(L_106);
String_t* L_107 = String_Trim_mB52EB7876C7132358B76B7DC95DEACA20722EF4D(L_106, /*hidden argument*/NULL);
NullCheck(L_101);
L_101->set_assembly_name_1(L_107);
int32_t* L_108 = ___p1;
int32_t L_109 = V_6;
*((int32_t*)L_108) = (int32_t)L_109;
TypeSpec_t943289F7C537252144A22588159B36C6B6759A7F * L_110 = V_3;
return L_110;
}
IL_0229:
{
bool L_111 = ___is_recurse2;
if (!L_111)
{
goto IL_0231;
}
}
{
int32_t* L_112 = ___p1;
int32_t L_113 = V_0;
*((int32_t*)L_112) = (int32_t)L_113;
TypeSpec_t943289F7C537252144A22588159B36C6B6759A7F * L_114 = V_3;
return L_114;
}
IL_0231:
{
bool L_115 = ___allow_aqn3;
if (!L_115)
{
goto IL_0500;
}
}
{
TypeSpec_t943289F7C537252144A22588159B36C6B6759A7F * L_116 = V_3;
String_t* L_117 = ___name0;
int32_t L_118 = V_0;
NullCheck(L_117);
String_t* L_119 = String_Substring_m2C4AFF5E79DD8BADFD2DFBCF156BF728FBB8E1AE(L_117, ((int32_t)il2cpp_codegen_add((int32_t)L_118, (int32_t)1)), /*hidden argument*/NULL);
NullCheck(L_119);
String_t* L_120 = String_Trim_mB52EB7876C7132358B76B7DC95DEACA20722EF4D(L_119, /*hidden argument*/NULL);
NullCheck(L_116);
L_116->set_assembly_name_1(L_120);
String_t* L_121 = ___name0;
NullCheck(L_121);
int32_t L_122 = String_get_Length_mD48C8A16A5CF1914F330DCE82D9BE15C3BEDD018(L_121, /*hidden argument*/NULL);
V_0 = L_122;
goto IL_0500;
}
IL_0257:
{
TypeSpec_t943289F7C537252144A22588159B36C6B6759A7F * L_123 = V_3;
NullCheck(L_123);
bool L_124 = L_123->get_is_byref_5();
if (!L_124)
{
goto IL_026f;
}
}
{
ArgumentException_tEDCD16F20A09ECE461C3DA766C16EDA8864057D1 * L_125 = (ArgumentException_tEDCD16F20A09ECE461C3DA766C16EDA8864057D1 *)il2cpp_codegen_object_new(ArgumentException_tEDCD16F20A09ECE461C3DA766C16EDA8864057D1_il2cpp_TypeInfo_var);
ArgumentException__ctor_m26DC3463C6F3C98BF33EA39598DD2B32F0249CA8(L_125, _stringLiteral2DBCA2328A7A87F4A438EE5BD7F4CE528F0DCD14, _stringLiteral9FA22049CF6367C2DB11AB15BC3EDE8D5104CB06, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_125, NULL, TypeSpec_Parse_m9AE5F2E214E154E1AEDCB27FD207B0C4C8EBC405_RuntimeMethod_var);
}
IL_026f:
{
int32_t L_126 = V_0;
V_0 = ((int32_t)il2cpp_codegen_add((int32_t)L_126, (int32_t)1));
int32_t L_127 = V_0;
String_t* L_128 = ___name0;
NullCheck(L_128);
int32_t L_129 = String_get_Length_mD48C8A16A5CF1914F330DCE82D9BE15C3BEDD018(L_128, /*hidden argument*/NULL);
if ((((int32_t)L_127) < ((int32_t)L_129)))
{
goto IL_028c;
}
}
{
ArgumentException_tEDCD16F20A09ECE461C3DA766C16EDA8864057D1 * L_130 = (ArgumentException_tEDCD16F20A09ECE461C3DA766C16EDA8864057D1 *)il2cpp_codegen_object_new(ArgumentException_tEDCD16F20A09ECE461C3DA766C16EDA8864057D1_il2cpp_TypeInfo_var);
ArgumentException__ctor_m26DC3463C6F3C98BF33EA39598DD2B32F0249CA8(L_130, _stringLiteral9037B62BA73A6A3E99186380F4A8BEDFA5D40E1C, _stringLiteral9FA22049CF6367C2DB11AB15BC3EDE8D5104CB06, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_130, NULL, TypeSpec_Parse_m9AE5F2E214E154E1AEDCB27FD207B0C4C8EBC405_RuntimeMethod_var);
}
IL_028c:
{
String_t* L_131 = ___name0;
TypeSpec_SkipSpace_mF388B6F9C82F795BA722B706A5435B0E799A531C(L_131, (int32_t*)(&V_0), /*hidden argument*/NULL);
String_t* L_132 = ___name0;
int32_t L_133 = V_0;
NullCheck(L_132);
Il2CppChar L_134 = String_get_Chars_m14308AC3B95F8C1D9F1D1055B116B37D595F1D96(L_132, L_133, /*hidden argument*/NULL);
if ((((int32_t)L_134) == ((int32_t)((int32_t)44))))
{
goto IL_03d5;
}
}
{
String_t* L_135 = ___name0;
int32_t L_136 = V_0;
NullCheck(L_135);
Il2CppChar L_137 = String_get_Chars_m14308AC3B95F8C1D9F1D1055B116B37D595F1D96(L_135, L_136, /*hidden argument*/NULL);
if ((((int32_t)L_137) == ((int32_t)((int32_t)42))))
{
goto IL_03d5;
}
}
{
String_t* L_138 = ___name0;
int32_t L_139 = V_0;
NullCheck(L_138);
Il2CppChar L_140 = String_get_Chars_m14308AC3B95F8C1D9F1D1055B116B37D595F1D96(L_138, L_139, /*hidden argument*/NULL);
if ((((int32_t)L_140) == ((int32_t)((int32_t)93))))
{
goto IL_03d5;
}
}
{
List_1_t8C8BF378AAB72B34B6EE63F686877AE7290ECFBA * L_141 = (List_1_t8C8BF378AAB72B34B6EE63F686877AE7290ECFBA *)il2cpp_codegen_object_new(List_1_t8C8BF378AAB72B34B6EE63F686877AE7290ECFBA_il2cpp_TypeInfo_var);
List_1__ctor_mAF11022CD0FF8181D72047FFC57B48590F17FFAC(L_141, /*hidden argument*/List_1__ctor_mAF11022CD0FF8181D72047FFC57B48590F17FFAC_RuntimeMethod_var);
V_7 = L_141;
TypeSpec_t943289F7C537252144A22588159B36C6B6759A7F * L_142 = V_3;
NullCheck(L_142);
bool L_143 = TypeSpec_get_HasModifiers_mF783ED5C395D4ACB94D30014B9F79E19E90EC9FD(L_142, /*hidden argument*/NULL);
if (!L_143)
{
goto IL_0398;
}
}
{
ArgumentException_tEDCD16F20A09ECE461C3DA766C16EDA8864057D1 * L_144 = (ArgumentException_tEDCD16F20A09ECE461C3DA766C16EDA8864057D1 *)il2cpp_codegen_object_new(ArgumentException_tEDCD16F20A09ECE461C3DA766C16EDA8864057D1_il2cpp_TypeInfo_var);
ArgumentException__ctor_m26DC3463C6F3C98BF33EA39598DD2B32F0249CA8(L_144, _stringLiteralAC223DCCCDBCF3FC5FA4ADAE3AB814451427CD3F, _stringLiteral9FA22049CF6367C2DB11AB15BC3EDE8D5104CB06, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_144, NULL, TypeSpec_Parse_m9AE5F2E214E154E1AEDCB27FD207B0C4C8EBC405_RuntimeMethod_var);
}
IL_02e0:
{
String_t* L_145 = ___name0;
TypeSpec_SkipSpace_mF388B6F9C82F795BA722B706A5435B0E799A531C(L_145, (int32_t*)(&V_0), /*hidden argument*/NULL);
String_t* L_146 = ___name0;
int32_t L_147 = V_0;
NullCheck(L_146);
Il2CppChar L_148 = String_get_Chars_m14308AC3B95F8C1D9F1D1055B116B37D595F1D96(L_146, L_147, /*hidden argument*/NULL);
V_8 = (bool)((((int32_t)L_148) == ((int32_t)((int32_t)91)))? 1 : 0);
bool L_149 = V_8;
if (!L_149)
{
goto IL_02fd;
}
}
{
int32_t L_150 = V_0;
V_0 = ((int32_t)il2cpp_codegen_add((int32_t)L_150, (int32_t)1));
}
IL_02fd:
{
List_1_t8C8BF378AAB72B34B6EE63F686877AE7290ECFBA * L_151 = V_7;
String_t* L_152 = ___name0;
bool L_153 = V_8;
TypeSpec_t943289F7C537252144A22588159B36C6B6759A7F * L_154 = TypeSpec_Parse_m9AE5F2E214E154E1AEDCB27FD207B0C4C8EBC405(L_152, (int32_t*)(&V_0), (bool)1, L_153, /*hidden argument*/NULL);
NullCheck(L_151);
List_1_Add_m12E0FC5DF0E1CB81E7DEADBBDD311E3E1AFC2DB4(L_151, L_154, /*hidden argument*/List_1_Add_m12E0FC5DF0E1CB81E7DEADBBDD311E3E1AFC2DB4_RuntimeMethod_var);
int32_t L_155 = V_0;
String_t* L_156 = ___name0;
TypeSpec_BoundCheck_m5CF5E6F2632D8D4D205DC26F6666BE9EA7D874FB(L_155, L_156, /*hidden argument*/NULL);
bool L_157 = V_8;
if (!L_157)
{
goto IL_0357;
}
}
{
String_t* L_158 = ___name0;
int32_t L_159 = V_0;
NullCheck(L_158);
Il2CppChar L_160 = String_get_Chars_m14308AC3B95F8C1D9F1D1055B116B37D595F1D96(L_158, L_159, /*hidden argument*/NULL);
if ((!(((uint32_t)L_160) == ((uint32_t)((int32_t)93)))))
{
goto IL_032b;
}
}
{
int32_t L_161 = V_0;
V_0 = ((int32_t)il2cpp_codegen_add((int32_t)L_161, (int32_t)1));
goto IL_0350;
}
IL_032b:
{
String_t* L_162 = ___name0;
int32_t L_163 = V_0;
NullCheck(L_162);
Il2CppChar L_164 = String_get_Chars_m14308AC3B95F8C1D9F1D1055B116B37D595F1D96(L_162, L_163, /*hidden argument*/NULL);
V_4 = L_164;
String_t* L_165 = Char_ToString_mA42A88FEBA41B72D48BB24373E3101B7A91B6FD8((Il2CppChar*)(&V_4), /*hidden argument*/NULL);
String_t* L_166 = String_Concat_mB78D0094592718DA6D5DB6C712A9C225631666BE(_stringLiteral20FED387605751EEA20B8EDAA265186F0E25C9DD, L_165, /*hidden argument*/NULL);
ArgumentException_tEDCD16F20A09ECE461C3DA766C16EDA8864057D1 * L_167 = (ArgumentException_tEDCD16F20A09ECE461C3DA766C16EDA8864057D1 *)il2cpp_codegen_object_new(ArgumentException_tEDCD16F20A09ECE461C3DA766C16EDA8864057D1_il2cpp_TypeInfo_var);
ArgumentException__ctor_m26DC3463C6F3C98BF33EA39598DD2B32F0249CA8(L_167, L_166, _stringLiteral9FA22049CF6367C2DB11AB15BC3EDE8D5104CB06, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_167, NULL, TypeSpec_Parse_m9AE5F2E214E154E1AEDCB27FD207B0C4C8EBC405_RuntimeMethod_var);
}
IL_0350:
{
int32_t L_168 = V_0;
String_t* L_169 = ___name0;
TypeSpec_BoundCheck_m5CF5E6F2632D8D4D205DC26F6666BE9EA7D874FB(L_168, L_169, /*hidden argument*/NULL);
}
IL_0357:
{
String_t* L_170 = ___name0;
int32_t L_171 = V_0;
NullCheck(L_170);
Il2CppChar L_172 = String_get_Chars_m14308AC3B95F8C1D9F1D1055B116B37D595F1D96(L_170, L_171, /*hidden argument*/NULL);
if ((((int32_t)L_172) == ((int32_t)((int32_t)93))))
{
goto IL_03a4;
}
}
{
String_t* L_173 = ___name0;
int32_t L_174 = V_0;
NullCheck(L_173);
Il2CppChar L_175 = String_get_Chars_m14308AC3B95F8C1D9F1D1055B116B37D595F1D96(L_173, L_174, /*hidden argument*/NULL);
if ((!(((uint32_t)L_175) == ((uint32_t)((int32_t)44)))))
{
goto IL_0373;
}
}
{
int32_t L_176 = V_0;
V_0 = ((int32_t)il2cpp_codegen_add((int32_t)L_176, (int32_t)1));
goto IL_0398;
}
IL_0373:
{
String_t* L_177 = ___name0;
int32_t L_178 = V_0;
NullCheck(L_177);
Il2CppChar L_179 = String_get_Chars_m14308AC3B95F8C1D9F1D1055B116B37D595F1D96(L_177, L_178, /*hidden argument*/NULL);
V_4 = L_179;
String_t* L_180 = Char_ToString_mA42A88FEBA41B72D48BB24373E3101B7A91B6FD8((Il2CppChar*)(&V_4), /*hidden argument*/NULL);
String_t* L_181 = String_Concat_mB78D0094592718DA6D5DB6C712A9C225631666BE(_stringLiteral6BF0FD54E37B109D934887898BCA5680FCDF70C5, L_180, /*hidden argument*/NULL);
ArgumentException_tEDCD16F20A09ECE461C3DA766C16EDA8864057D1 * L_182 = (ArgumentException_tEDCD16F20A09ECE461C3DA766C16EDA8864057D1 *)il2cpp_codegen_object_new(ArgumentException_tEDCD16F20A09ECE461C3DA766C16EDA8864057D1_il2cpp_TypeInfo_var);
ArgumentException__ctor_m26DC3463C6F3C98BF33EA39598DD2B32F0249CA8(L_182, L_181, _stringLiteral9FA22049CF6367C2DB11AB15BC3EDE8D5104CB06, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_182, NULL, TypeSpec_Parse_m9AE5F2E214E154E1AEDCB27FD207B0C4C8EBC405_RuntimeMethod_var);
}
IL_0398:
{
int32_t L_183 = V_0;
String_t* L_184 = ___name0;
NullCheck(L_184);
int32_t L_185 = String_get_Length_mD48C8A16A5CF1914F330DCE82D9BE15C3BEDD018(L_184, /*hidden argument*/NULL);
if ((((int32_t)L_183) < ((int32_t)L_185)))
{
goto IL_02e0;
}
}
IL_03a4:
{
int32_t L_186 = V_0;
String_t* L_187 = ___name0;
NullCheck(L_187);
int32_t L_188 = String_get_Length_mD48C8A16A5CF1914F330DCE82D9BE15C3BEDD018(L_187, /*hidden argument*/NULL);
if ((((int32_t)L_186) >= ((int32_t)L_188)))
{
goto IL_03b8;
}
}
{
String_t* L_189 = ___name0;
int32_t L_190 = V_0;
NullCheck(L_189);
Il2CppChar L_191 = String_get_Chars_m14308AC3B95F8C1D9F1D1055B116B37D595F1D96(L_189, L_190, /*hidden argument*/NULL);
if ((((int32_t)L_191) == ((int32_t)((int32_t)93))))
{
goto IL_03c8;
}
}
IL_03b8:
{
ArgumentException_tEDCD16F20A09ECE461C3DA766C16EDA8864057D1 * L_192 = (ArgumentException_tEDCD16F20A09ECE461C3DA766C16EDA8864057D1 *)il2cpp_codegen_object_new(ArgumentException_tEDCD16F20A09ECE461C3DA766C16EDA8864057D1_il2cpp_TypeInfo_var);
ArgumentException__ctor_m26DC3463C6F3C98BF33EA39598DD2B32F0249CA8(L_192, _stringLiteralCAADDB127D0DC4313E5704D5F010772D3AD766ED, _stringLiteral9FA22049CF6367C2DB11AB15BC3EDE8D5104CB06, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_192, NULL, TypeSpec_Parse_m9AE5F2E214E154E1AEDCB27FD207B0C4C8EBC405_RuntimeMethod_var);
}
IL_03c8:
{
TypeSpec_t943289F7C537252144A22588159B36C6B6759A7F * L_193 = V_3;
List_1_t8C8BF378AAB72B34B6EE63F686877AE7290ECFBA * L_194 = V_7;
NullCheck(L_193);
L_193->set_generic_params_3(L_194);
goto IL_0500;
}
IL_03d5:
{
V_9 = 1;
V_10 = (bool)0;
goto IL_0443;
}
IL_03dd:
{
String_t* L_195 = ___name0;
int32_t L_196 = V_0;
NullCheck(L_195);
Il2CppChar L_197 = String_get_Chars_m14308AC3B95F8C1D9F1D1055B116B37D595F1D96(L_195, L_196, /*hidden argument*/NULL);
if ((!(((uint32_t)L_197) == ((uint32_t)((int32_t)42)))))
{
goto IL_0401;
}
}
{
bool L_198 = V_10;
if (!L_198)
{
goto IL_03fc;
}
}
{
ArgumentException_tEDCD16F20A09ECE461C3DA766C16EDA8864057D1 * L_199 = (ArgumentException_tEDCD16F20A09ECE461C3DA766C16EDA8864057D1 *)il2cpp_codegen_object_new(ArgumentException_tEDCD16F20A09ECE461C3DA766C16EDA8864057D1_il2cpp_TypeInfo_var);
ArgumentException__ctor_m26DC3463C6F3C98BF33EA39598DD2B32F0249CA8(L_199, _stringLiteralAD69AC24021D712B02ED72DF3DD0A70E1B01A01B, _stringLiteral9FA22049CF6367C2DB11AB15BC3EDE8D5104CB06, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_199, NULL, TypeSpec_Parse_m9AE5F2E214E154E1AEDCB27FD207B0C4C8EBC405_RuntimeMethod_var);
}
IL_03fc:
{
V_10 = (bool)1;
goto IL_0437;
}
IL_0401:
{
String_t* L_200 = ___name0;
int32_t L_201 = V_0;
NullCheck(L_200);
Il2CppChar L_202 = String_get_Chars_m14308AC3B95F8C1D9F1D1055B116B37D595F1D96(L_200, L_201, /*hidden argument*/NULL);
if ((((int32_t)L_202) == ((int32_t)((int32_t)44))))
{
goto IL_0431;
}
}
{
String_t* L_203 = ___name0;
int32_t L_204 = V_0;
NullCheck(L_203);
Il2CppChar L_205 = String_get_Chars_m14308AC3B95F8C1D9F1D1055B116B37D595F1D96(L_203, L_204, /*hidden argument*/NULL);
V_4 = L_205;
String_t* L_206 = Char_ToString_mA42A88FEBA41B72D48BB24373E3101B7A91B6FD8((Il2CppChar*)(&V_4), /*hidden argument*/NULL);
String_t* L_207 = String_Concat_mB78D0094592718DA6D5DB6C712A9C225631666BE(_stringLiteralB3A8637874FFB852B3B8942459614113859FEE0F, L_206, /*hidden argument*/NULL);
ArgumentException_tEDCD16F20A09ECE461C3DA766C16EDA8864057D1 * L_208 = (ArgumentException_tEDCD16F20A09ECE461C3DA766C16EDA8864057D1 *)il2cpp_codegen_object_new(ArgumentException_tEDCD16F20A09ECE461C3DA766C16EDA8864057D1_il2cpp_TypeInfo_var);
ArgumentException__ctor_m26DC3463C6F3C98BF33EA39598DD2B32F0249CA8(L_208, L_207, _stringLiteral9FA22049CF6367C2DB11AB15BC3EDE8D5104CB06, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_208, NULL, TypeSpec_Parse_m9AE5F2E214E154E1AEDCB27FD207B0C4C8EBC405_RuntimeMethod_var);
}
IL_0431:
{
int32_t L_209 = V_9;
V_9 = ((int32_t)il2cpp_codegen_add((int32_t)L_209, (int32_t)1));
}
IL_0437:
{
int32_t L_210 = V_0;
V_0 = ((int32_t)il2cpp_codegen_add((int32_t)L_210, (int32_t)1));
String_t* L_211 = ___name0;
TypeSpec_SkipSpace_mF388B6F9C82F795BA722B706A5435B0E799A531C(L_211, (int32_t*)(&V_0), /*hidden argument*/NULL);
}
IL_0443:
{
int32_t L_212 = V_0;
String_t* L_213 = ___name0;
NullCheck(L_213);
int32_t L_214 = String_get_Length_mD48C8A16A5CF1914F330DCE82D9BE15C3BEDD018(L_213, /*hidden argument*/NULL);
if ((((int32_t)L_212) >= ((int32_t)L_214)))
{
goto IL_0457;
}
}
{
String_t* L_215 = ___name0;
int32_t L_216 = V_0;
NullCheck(L_215);
Il2CppChar L_217 = String_get_Chars_m14308AC3B95F8C1D9F1D1055B116B37D595F1D96(L_215, L_216, /*hidden argument*/NULL);
if ((!(((uint32_t)L_217) == ((uint32_t)((int32_t)93)))))
{
goto IL_03dd;
}
}
IL_0457:
{
int32_t L_218 = V_0;
String_t* L_219 = ___name0;
NullCheck(L_219);
int32_t L_220 = String_get_Length_mD48C8A16A5CF1914F330DCE82D9BE15C3BEDD018(L_219, /*hidden argument*/NULL);
if ((((int32_t)L_218) >= ((int32_t)L_220)))
{
goto IL_046b;
}
}
{
String_t* L_221 = ___name0;
int32_t L_222 = V_0;
NullCheck(L_221);
Il2CppChar L_223 = String_get_Chars_m14308AC3B95F8C1D9F1D1055B116B37D595F1D96(L_221, L_222, /*hidden argument*/NULL);
if ((((int32_t)L_223) == ((int32_t)((int32_t)93))))
{
goto IL_047b;
}
}
IL_046b:
{
ArgumentException_tEDCD16F20A09ECE461C3DA766C16EDA8864057D1 * L_224 = (ArgumentException_tEDCD16F20A09ECE461C3DA766C16EDA8864057D1 *)il2cpp_codegen_object_new(ArgumentException_tEDCD16F20A09ECE461C3DA766C16EDA8864057D1_il2cpp_TypeInfo_var);
ArgumentException__ctor_m26DC3463C6F3C98BF33EA39598DD2B32F0249CA8(L_224, _stringLiteral33370356128AA3B1263898B5524D4D405A01CA5E, _stringLiteral9FA22049CF6367C2DB11AB15BC3EDE8D5104CB06, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_224, NULL, TypeSpec_Parse_m9AE5F2E214E154E1AEDCB27FD207B0C4C8EBC405_RuntimeMethod_var);
}
IL_047b:
{
int32_t L_225 = V_9;
bool L_226 = V_10;
if (!((int32_t)((int32_t)((((int32_t)L_225) > ((int32_t)1))? 1 : 0)&(int32_t)L_226)))
{
goto IL_0495;
}
}
{
ArgumentException_tEDCD16F20A09ECE461C3DA766C16EDA8864057D1 * L_227 = (ArgumentException_tEDCD16F20A09ECE461C3DA766C16EDA8864057D1 *)il2cpp_codegen_object_new(ArgumentException_tEDCD16F20A09ECE461C3DA766C16EDA8864057D1_il2cpp_TypeInfo_var);
ArgumentException__ctor_m26DC3463C6F3C98BF33EA39598DD2B32F0249CA8(L_227, _stringLiteralE364CE10A99220B5DFCBF4821A817898A97E5BCB, _stringLiteral9FA22049CF6367C2DB11AB15BC3EDE8D5104CB06, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_227, NULL, TypeSpec_Parse_m9AE5F2E214E154E1AEDCB27FD207B0C4C8EBC405_RuntimeMethod_var);
}
IL_0495:
{
TypeSpec_t943289F7C537252144A22588159B36C6B6759A7F * L_228 = V_3;
int32_t L_229 = V_9;
bool L_230 = V_10;
ArraySpec_tF374BB8994F7190916C6F14C7EA8FE6EFE017970 * L_231 = (ArraySpec_tF374BB8994F7190916C6F14C7EA8FE6EFE017970 *)il2cpp_codegen_object_new(ArraySpec_tF374BB8994F7190916C6F14C7EA8FE6EFE017970_il2cpp_TypeInfo_var);
ArraySpec__ctor_m7829BADEF006060440EBF1330EC85B9FF17CE6B4(L_231, L_229, L_230, /*hidden argument*/NULL);
NullCheck(L_228);
TypeSpec_AddModifier_m082500BAE4A512BA0E84CC85A71F4A67DA885909(L_228, L_231, /*hidden argument*/NULL);
goto IL_0500;
}
IL_04a6:
{
bool L_232 = ___is_recurse2;
if (!L_232)
{
goto IL_04ae;
}
}
{
int32_t* L_233 = ___p1;
int32_t L_234 = V_0;
*((int32_t*)L_233) = (int32_t)L_234;
TypeSpec_t943289F7C537252144A22588159B36C6B6759A7F * L_235 = V_3;
return L_235;
}
IL_04ae:
{
ArgumentException_tEDCD16F20A09ECE461C3DA766C16EDA8864057D1 * L_236 = (ArgumentException_tEDCD16F20A09ECE461C3DA766C16EDA8864057D1 *)il2cpp_codegen_object_new(ArgumentException_tEDCD16F20A09ECE461C3DA766C16EDA8864057D1_il2cpp_TypeInfo_var);
ArgumentException__ctor_m26DC3463C6F3C98BF33EA39598DD2B32F0249CA8(L_236, _stringLiteral1E5FC82CCB72553A236B455041C2CC6D97965017, _stringLiteral9FA22049CF6367C2DB11AB15BC3EDE8D5104CB06, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_236, NULL, TypeSpec_Parse_m9AE5F2E214E154E1AEDCB27FD207B0C4C8EBC405_RuntimeMethod_var);
}
IL_04be:
{
ObjectU5BU5D_t3C9242B5C88A48B2A5BD9FDA6CD0024E792AF08A* L_237 = (ObjectU5BU5D_t3C9242B5C88A48B2A5BD9FDA6CD0024E792AF08A*)(ObjectU5BU5D_t3C9242B5C88A48B2A5BD9FDA6CD0024E792AF08A*)SZArrayNew(ObjectU5BU5D_t3C9242B5C88A48B2A5BD9FDA6CD0024E792AF08A_il2cpp_TypeInfo_var, (uint32_t)4);
ObjectU5BU5D_t3C9242B5C88A48B2A5BD9FDA6CD0024E792AF08A* L_238 = L_237;
NullCheck(L_238);
ArrayElementTypeCheck (L_238, _stringLiteral7D1F754EE65E8FC64F63B1262838D9592369E1F7);
(L_238)->SetAt(static_cast<il2cpp_array_size_t>(0), (RuntimeObject *)_stringLiteral7D1F754EE65E8FC64F63B1262838D9592369E1F7);
ObjectU5BU5D_t3C9242B5C88A48B2A5BD9FDA6CD0024E792AF08A* L_239 = L_238;
String_t* L_240 = ___name0;
int32_t L_241 = V_0;
NullCheck(L_240);
Il2CppChar L_242 = String_get_Chars_m14308AC3B95F8C1D9F1D1055B116B37D595F1D96(L_240, L_241, /*hidden argument*/NULL);
V_4 = L_242;
String_t* L_243 = Char_ToString_mA42A88FEBA41B72D48BB24373E3101B7A91B6FD8((Il2CppChar*)(&V_4), /*hidden argument*/NULL);
NullCheck(L_239);
ArrayElementTypeCheck (L_239, L_243);
(L_239)->SetAt(static_cast<il2cpp_array_size_t>(1), (RuntimeObject *)L_243);
ObjectU5BU5D_t3C9242B5C88A48B2A5BD9FDA6CD0024E792AF08A* L_244 = L_239;
NullCheck(L_244);
ArrayElementTypeCheck (L_244, _stringLiteralE52C610014830CF451FCD5BFE6176FFC7E9E5500);
(L_244)->SetAt(static_cast<il2cpp_array_size_t>(2), (RuntimeObject *)_stringLiteralE52C610014830CF451FCD5BFE6176FFC7E9E5500);
ObjectU5BU5D_t3C9242B5C88A48B2A5BD9FDA6CD0024E792AF08A* L_245 = L_244;
int32_t L_246 = V_0;
int32_t L_247 = L_246;
RuntimeObject * L_248 = Box(Int32_t585191389E07734F19F3156FF88FB3EF4800D102_il2cpp_TypeInfo_var, &L_247);
NullCheck(L_245);
ArrayElementTypeCheck (L_245, L_248);
(L_245)->SetAt(static_cast<il2cpp_array_size_t>(3), (RuntimeObject *)L_248);
String_t* L_249 = String_Concat_mB7BA84F13912303B2E5E40FBF0109E1A328ACA07(L_245, /*hidden argument*/NULL);
ArgumentException_tEDCD16F20A09ECE461C3DA766C16EDA8864057D1 * L_250 = (ArgumentException_tEDCD16F20A09ECE461C3DA766C16EDA8864057D1 *)il2cpp_codegen_object_new(ArgumentException_tEDCD16F20A09ECE461C3DA766C16EDA8864057D1_il2cpp_TypeInfo_var);
ArgumentException__ctor_m26DC3463C6F3C98BF33EA39598DD2B32F0249CA8(L_250, L_249, _stringLiteral9FA22049CF6367C2DB11AB15BC3EDE8D5104CB06, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_250, NULL, TypeSpec_Parse_m9AE5F2E214E154E1AEDCB27FD207B0C4C8EBC405_RuntimeMethod_var);
}
IL_0500:
{
int32_t L_251 = V_0;
V_0 = ((int32_t)il2cpp_codegen_add((int32_t)L_251, (int32_t)1));
}
IL_0504:
{
int32_t L_252 = V_0;
String_t* L_253 = ___name0;
NullCheck(L_253);
int32_t L_254 = String_get_Length_mD48C8A16A5CF1914F330DCE82D9BE15C3BEDD018(L_253, /*hidden argument*/NULL);
if ((((int32_t)L_252) < ((int32_t)L_254)))
{
goto IL_0119;
}
}
IL_0510:
{
int32_t* L_255 = ___p1;
int32_t L_256 = V_0;
*((int32_t*)L_255) = (int32_t)L_256;
TypeSpec_t943289F7C537252144A22588159B36C6B6759A7F * L_257 = V_3;
return L_257;
}
}
// System.Void System.TypeSpec::.ctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void TypeSpec__ctor_m18DCF64756F091CE7A7DA6CDAD3142419602D901 (TypeSpec_t943289F7C537252144A22588159B36C6B6759A7F * __this, const RuntimeMethod* method)
{
{
Object__ctor_m925ECA5E85CA100E3FB86A4F9E15C120E9A184C0(__this, /*hidden argument*/NULL);
return;
}
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.TypedReference System.TypedReference::MakeTypedReference(System.Object,System.Reflection.FieldInfo[])
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR TypedReference_t118BC3B643F75F52DB9C99D5E051299F886EB2A8 TypedReference_MakeTypedReference_m4258853ADBD3EA5DB6AB0B3F48C82F81DBA1C1DC (RuntimeObject * ___target0, FieldInfoU5BU5D_t9C36FA93372CA01DAF85946064B058CD9CE2E8BE* ___flds1, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (TypedReference_MakeTypedReference_m4258853ADBD3EA5DB6AB0B3F48C82F81DBA1C1DC_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
IntPtrU5BU5D_t4DC01DCB9A6DF6C9792A6513595D7A11E637DCDD* V_0 = NULL;
RuntimeType_t40F13BCEAD97478C72C4B40BFDC2A220161CDB8F * V_1 = NULL;
int32_t V_2 = 0;
RuntimeFieldInfo_t9C8BA644F857EBE60EC6587AE1C1148E420E66F7 * V_3 = NULL;
RuntimeType_t40F13BCEAD97478C72C4B40BFDC2A220161CDB8F * V_4 = NULL;
RuntimeFieldHandle_t844BDF00E8E6FE69D9AEAA7657F09018B864F4EF V_5;
memset((&V_5), 0, sizeof(V_5));
{
RuntimeObject * L_0 = ___target0;
if (L_0)
{
goto IL_000e;
}
}
{
ArgumentNullException_t581DF992B1F3E0EC6EFB30CC5DC43519A79B27AD * L_1 = (ArgumentNullException_t581DF992B1F3E0EC6EFB30CC5DC43519A79B27AD *)il2cpp_codegen_object_new(ArgumentNullException_t581DF992B1F3E0EC6EFB30CC5DC43519A79B27AD_il2cpp_TypeInfo_var);
ArgumentNullException__ctor_mEE0C0D6FCB2D08CD7967DBB1329A0854BBED49ED(L_1, _stringLiteral0E8A3AD980EC179856012B7EECF4327E99CD44CD, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_1, NULL, TypedReference_MakeTypedReference_m4258853ADBD3EA5DB6AB0B3F48C82F81DBA1C1DC_RuntimeMethod_var);
}
IL_000e:
{
FieldInfoU5BU5D_t9C36FA93372CA01DAF85946064B058CD9CE2E8BE* L_2 = ___flds1;
if (L_2)
{
goto IL_001c;
}
}
{
ArgumentNullException_t581DF992B1F3E0EC6EFB30CC5DC43519A79B27AD * L_3 = (ArgumentNullException_t581DF992B1F3E0EC6EFB30CC5DC43519A79B27AD *)il2cpp_codegen_object_new(ArgumentNullException_t581DF992B1F3E0EC6EFB30CC5DC43519A79B27AD_il2cpp_TypeInfo_var);
ArgumentNullException__ctor_mEE0C0D6FCB2D08CD7967DBB1329A0854BBED49ED(L_3, _stringLiteral4BECD3F9C90F8D7A184FB632D4DEDA9B5481791D, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_3, NULL, TypedReference_MakeTypedReference_m4258853ADBD3EA5DB6AB0B3F48C82F81DBA1C1DC_RuntimeMethod_var);
}
IL_001c:
{
FieldInfoU5BU5D_t9C36FA93372CA01DAF85946064B058CD9CE2E8BE* L_4 = ___flds1;
NullCheck(L_4);
if ((((RuntimeArray*)L_4)->max_length))
{
goto IL_0030;
}
}
{
String_t* L_5 = Environment_GetResourceString_m2C75C2AF268F01E2BF34AD1C2E1352CF4BA51AD9(_stringLiteral10A53546C08F0C2B88527F528FDD3D15B5959B33, /*hidden argument*/NULL);
ArgumentException_tEDCD16F20A09ECE461C3DA766C16EDA8864057D1 * L_6 = (ArgumentException_tEDCD16F20A09ECE461C3DA766C16EDA8864057D1 *)il2cpp_codegen_object_new(ArgumentException_tEDCD16F20A09ECE461C3DA766C16EDA8864057D1_il2cpp_TypeInfo_var);
ArgumentException__ctor_m9A85EF7FEFEC21DDD525A67E831D77278E5165B7(L_6, L_5, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_6, NULL, TypedReference_MakeTypedReference_m4258853ADBD3EA5DB6AB0B3F48C82F81DBA1C1DC_RuntimeMethod_var);
}
IL_0030:
{
FieldInfoU5BU5D_t9C36FA93372CA01DAF85946064B058CD9CE2E8BE* L_7 = ___flds1;
NullCheck(L_7);
IntPtrU5BU5D_t4DC01DCB9A6DF6C9792A6513595D7A11E637DCDD* L_8 = (IntPtrU5BU5D_t4DC01DCB9A6DF6C9792A6513595D7A11E637DCDD*)(IntPtrU5BU5D_t4DC01DCB9A6DF6C9792A6513595D7A11E637DCDD*)SZArrayNew(IntPtrU5BU5D_t4DC01DCB9A6DF6C9792A6513595D7A11E637DCDD_il2cpp_TypeInfo_var, (uint32_t)(((int32_t)((int32_t)(((RuntimeArray*)L_7)->max_length)))));
V_0 = L_8;
RuntimeObject * L_9 = ___target0;
NullCheck(L_9);
Type_t * L_10 = Object_GetType_m2E0B62414ECCAA3094B703790CE88CBB2F83EA60(L_9, /*hidden argument*/NULL);
V_1 = ((RuntimeType_t40F13BCEAD97478C72C4B40BFDC2A220161CDB8F *)CastclassClass((RuntimeObject*)L_10, RuntimeType_t40F13BCEAD97478C72C4B40BFDC2A220161CDB8F_il2cpp_TypeInfo_var));
V_2 = 0;
goto IL_011a;
}
IL_004c:
{
FieldInfoU5BU5D_t9C36FA93372CA01DAF85946064B058CD9CE2E8BE* L_11 = ___flds1;
int32_t L_12 = V_2;
NullCheck(L_11);
int32_t L_13 = L_12;
FieldInfo_t * L_14 = (L_11)->GetAt(static_cast<il2cpp_array_size_t>(L_13));
V_3 = ((RuntimeFieldInfo_t9C8BA644F857EBE60EC6587AE1C1148E420E66F7 *)IsInstClass((RuntimeObject*)L_14, RuntimeFieldInfo_t9C8BA644F857EBE60EC6587AE1C1148E420E66F7_il2cpp_TypeInfo_var));
RuntimeFieldInfo_t9C8BA644F857EBE60EC6587AE1C1148E420E66F7 * L_15 = V_3;
bool L_16 = FieldInfo_op_Equality_m924E721654B7BDF09AA6E20C6E8D2BC4D4AF9DB7(L_15, (FieldInfo_t *)NULL, /*hidden argument*/NULL);
if (!L_16)
{
goto IL_006e;
}
}
{
String_t* L_17 = Environment_GetResourceString_m2C75C2AF268F01E2BF34AD1C2E1352CF4BA51AD9(_stringLiteral1653AF59DA2921FD4F1494A7DAD6B7D7FC320C47, /*hidden argument*/NULL);
ArgumentException_tEDCD16F20A09ECE461C3DA766C16EDA8864057D1 * L_18 = (ArgumentException_tEDCD16F20A09ECE461C3DA766C16EDA8864057D1 *)il2cpp_codegen_object_new(ArgumentException_tEDCD16F20A09ECE461C3DA766C16EDA8864057D1_il2cpp_TypeInfo_var);
ArgumentException__ctor_m9A85EF7FEFEC21DDD525A67E831D77278E5165B7(L_18, L_17, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_18, NULL, TypedReference_MakeTypedReference_m4258853ADBD3EA5DB6AB0B3F48C82F81DBA1C1DC_RuntimeMethod_var);
}
IL_006e:
{
RuntimeFieldInfo_t9C8BA644F857EBE60EC6587AE1C1148E420E66F7 * L_19 = V_3;
NullCheck(L_19);
bool L_20 = FieldInfo_get_IsInitOnly_m55ECD5C1B5F908CC9D10FDA743C9014CDB45E044(L_19, /*hidden argument*/NULL);
if (L_20)
{
goto IL_007e;
}
}
{
RuntimeFieldInfo_t9C8BA644F857EBE60EC6587AE1C1148E420E66F7 * L_21 = V_3;
NullCheck(L_21);
bool L_22 = FieldInfo_get_IsStatic_mDEB4099D238E5846246F0ACED3FF9AD9C93D8ECA(L_21, /*hidden argument*/NULL);
if (!L_22)
{
goto IL_008e;
}
}
IL_007e:
{
String_t* L_23 = Environment_GetResourceString_m2C75C2AF268F01E2BF34AD1C2E1352CF4BA51AD9(_stringLiteralF1C632B1F91BC26A3DBD8A50A7FCDF474F316978, /*hidden argument*/NULL);
ArgumentException_tEDCD16F20A09ECE461C3DA766C16EDA8864057D1 * L_24 = (ArgumentException_tEDCD16F20A09ECE461C3DA766C16EDA8864057D1 *)il2cpp_codegen_object_new(ArgumentException_tEDCD16F20A09ECE461C3DA766C16EDA8864057D1_il2cpp_TypeInfo_var);
ArgumentException__ctor_m9A85EF7FEFEC21DDD525A67E831D77278E5165B7(L_24, L_23, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_24, NULL, TypedReference_MakeTypedReference_m4258853ADBD3EA5DB6AB0B3F48C82F81DBA1C1DC_RuntimeMethod_var);
}
IL_008e:
{
RuntimeType_t40F13BCEAD97478C72C4B40BFDC2A220161CDB8F * L_25 = V_1;
RuntimeFieldInfo_t9C8BA644F857EBE60EC6587AE1C1148E420E66F7 * L_26 = V_3;
NullCheck(L_26);
RuntimeType_t40F13BCEAD97478C72C4B40BFDC2A220161CDB8F * L_27 = RuntimeFieldInfo_GetDeclaringTypeInternal_m8325660CADABFA47D55C9CD649176638BE521046(L_26, /*hidden argument*/NULL);
IL2CPP_RUNTIME_CLASS_INIT(RuntimeType_t40F13BCEAD97478C72C4B40BFDC2A220161CDB8F_il2cpp_TypeInfo_var);
bool L_28 = RuntimeType_op_Inequality_mA98A719712593FEE5DCCFDB47CCABDB58BEE1B0D(L_25, L_27, /*hidden argument*/NULL);
if (!L_28)
{
goto IL_00ba;
}
}
{
RuntimeType_t40F13BCEAD97478C72C4B40BFDC2A220161CDB8F * L_29 = V_1;
RuntimeFieldInfo_t9C8BA644F857EBE60EC6587AE1C1148E420E66F7 * L_30 = V_3;
NullCheck(L_30);
RuntimeType_t40F13BCEAD97478C72C4B40BFDC2A220161CDB8F * L_31 = RuntimeFieldInfo_GetDeclaringTypeInternal_m8325660CADABFA47D55C9CD649176638BE521046(L_30, /*hidden argument*/NULL);
NullCheck(L_29);
bool L_32 = VirtFuncInvoker1< bool, Type_t * >::Invoke(101 /* System.Boolean System.Type::IsSubclassOf(System.Type) */, L_29, L_31);
if (L_32)
{
goto IL_00ba;
}
}
{
String_t* L_33 = Environment_GetResourceString_m2C75C2AF268F01E2BF34AD1C2E1352CF4BA51AD9(_stringLiteral48E3C7922E67FC100CF2B7A133A26ADCFB2044FE, /*hidden argument*/NULL);
MissingMemberException_t165349A7E04FC51DAA5C2251C6DCDD2DD60255DD * L_34 = (MissingMemberException_t165349A7E04FC51DAA5C2251C6DCDD2DD60255DD *)il2cpp_codegen_object_new(MissingMemberException_t165349A7E04FC51DAA5C2251C6DCDD2DD60255DD_il2cpp_TypeInfo_var);
MissingMemberException__ctor_m2F8C7F0015B6EFEC5BD07F8240D53C2AEE4649DC(L_34, L_33, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_34, NULL, TypedReference_MakeTypedReference_m4258853ADBD3EA5DB6AB0B3F48C82F81DBA1C1DC_RuntimeMethod_var);
}
IL_00ba:
{
RuntimeFieldInfo_t9C8BA644F857EBE60EC6587AE1C1148E420E66F7 * L_35 = V_3;
NullCheck(L_35);
Type_t * L_36 = VirtFuncInvoker0< Type_t * >::Invoke(18 /* System.Type System.Reflection.FieldInfo::get_FieldType() */, L_35);
V_4 = ((RuntimeType_t40F13BCEAD97478C72C4B40BFDC2A220161CDB8F *)CastclassClass((RuntimeObject*)L_36, RuntimeType_t40F13BCEAD97478C72C4B40BFDC2A220161CDB8F_il2cpp_TypeInfo_var));
RuntimeType_t40F13BCEAD97478C72C4B40BFDC2A220161CDB8F * L_37 = V_4;
NullCheck(L_37);
bool L_38 = Type_get_IsPrimitive_m8E39430EE4B70E1AE690B51E9BE681C7758DFF5A(L_37, /*hidden argument*/NULL);
if (!L_38)
{
goto IL_00e0;
}
}
{
String_t* L_39 = Environment_GetResourceString_m2C75C2AF268F01E2BF34AD1C2E1352CF4BA51AD9(_stringLiteralDF7A2F270E0369172CE2F27B621403FE9FEBEF74, /*hidden argument*/NULL);
ArgumentException_tEDCD16F20A09ECE461C3DA766C16EDA8864057D1 * L_40 = (ArgumentException_tEDCD16F20A09ECE461C3DA766C16EDA8864057D1 *)il2cpp_codegen_object_new(ArgumentException_tEDCD16F20A09ECE461C3DA766C16EDA8864057D1_il2cpp_TypeInfo_var);
ArgumentException__ctor_m9A85EF7FEFEC21DDD525A67E831D77278E5165B7(L_40, L_39, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_40, NULL, TypedReference_MakeTypedReference_m4258853ADBD3EA5DB6AB0B3F48C82F81DBA1C1DC_RuntimeMethod_var);
}
IL_00e0:
{
int32_t L_41 = V_2;
FieldInfoU5BU5D_t9C36FA93372CA01DAF85946064B058CD9CE2E8BE* L_42 = ___flds1;
NullCheck(L_42);
if ((((int32_t)L_41) >= ((int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)(((int32_t)((int32_t)(((RuntimeArray*)L_42)->max_length)))), (int32_t)1)))))
{
goto IL_0101;
}
}
{
RuntimeType_t40F13BCEAD97478C72C4B40BFDC2A220161CDB8F * L_43 = V_4;
NullCheck(L_43);
bool L_44 = Type_get_IsValueType_mDDCCBAE9B59A483CBC3E5C02E3D68CEBEB2E41A8(L_43, /*hidden argument*/NULL);
if (L_44)
{
goto IL_0101;
}
}
{
String_t* L_45 = Environment_GetResourceString_m2C75C2AF268F01E2BF34AD1C2E1352CF4BA51AD9(_stringLiteral1CBD801F805A5FBD3AD0F5E193C36FE40C2BB005, /*hidden argument*/NULL);
MissingMemberException_t165349A7E04FC51DAA5C2251C6DCDD2DD60255DD * L_46 = (MissingMemberException_t165349A7E04FC51DAA5C2251C6DCDD2DD60255DD *)il2cpp_codegen_object_new(MissingMemberException_t165349A7E04FC51DAA5C2251C6DCDD2DD60255DD_il2cpp_TypeInfo_var);
MissingMemberException__ctor_m2F8C7F0015B6EFEC5BD07F8240D53C2AEE4649DC(L_46, L_45, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_46, NULL, TypedReference_MakeTypedReference_m4258853ADBD3EA5DB6AB0B3F48C82F81DBA1C1DC_RuntimeMethod_var);
}
IL_0101:
{
IntPtrU5BU5D_t4DC01DCB9A6DF6C9792A6513595D7A11E637DCDD* L_47 = V_0;
int32_t L_48 = V_2;
RuntimeFieldInfo_t9C8BA644F857EBE60EC6587AE1C1148E420E66F7 * L_49 = V_3;
NullCheck(L_49);
RuntimeFieldHandle_t844BDF00E8E6FE69D9AEAA7657F09018B864F4EF L_50 = VirtFuncInvoker0< RuntimeFieldHandle_t844BDF00E8E6FE69D9AEAA7657F09018B864F4EF >::Invoke(17 /* System.RuntimeFieldHandle System.Reflection.FieldInfo::get_FieldHandle() */, L_49);
V_5 = L_50;
intptr_t L_51 = RuntimeFieldHandle_get_Value_m2C81CBF4FC895E7A343C344BE8EE96D9DEBEA3DA((RuntimeFieldHandle_t844BDF00E8E6FE69D9AEAA7657F09018B864F4EF *)(&V_5), /*hidden argument*/NULL);
NullCheck(L_47);
(L_47)->SetAt(static_cast<il2cpp_array_size_t>(L_48), (intptr_t)L_51);
RuntimeType_t40F13BCEAD97478C72C4B40BFDC2A220161CDB8F * L_52 = V_4;
V_1 = L_52;
int32_t L_53 = V_2;
V_2 = ((int32_t)il2cpp_codegen_add((int32_t)L_53, (int32_t)1));
}
IL_011a:
{
int32_t L_54 = V_2;
FieldInfoU5BU5D_t9C36FA93372CA01DAF85946064B058CD9CE2E8BE* L_55 = ___flds1;
NullCheck(L_55);
if ((((int32_t)L_54) < ((int32_t)(((int32_t)((int32_t)(((RuntimeArray*)L_55)->max_length)))))))
{
goto IL_004c;
}
}
{
RuntimeObject * L_56 = ___target0;
FieldInfoU5BU5D_t9C36FA93372CA01DAF85946064B058CD9CE2E8BE* L_57 = ___flds1;
TypedReference_t118BC3B643F75F52DB9C99D5E051299F886EB2A8 L_58 = TypedReference_MakeTypedReferenceInternal_mD1DFB634CA2F3B5335B4FFDA97A25DEB90DD170C(L_56, L_57, /*hidden argument*/NULL);
return L_58;
}
}
// System.TypedReference System.TypedReference::MakeTypedReferenceInternal(System.Object,System.Reflection.FieldInfo[])
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR TypedReference_t118BC3B643F75F52DB9C99D5E051299F886EB2A8 TypedReference_MakeTypedReferenceInternal_mD1DFB634CA2F3B5335B4FFDA97A25DEB90DD170C (RuntimeObject * ___target0, FieldInfoU5BU5D_t9C36FA93372CA01DAF85946064B058CD9CE2E8BE* ___fields1, const RuntimeMethod* method)
{
typedef TypedReference_t118BC3B643F75F52DB9C99D5E051299F886EB2A8 (*TypedReference_MakeTypedReferenceInternal_mD1DFB634CA2F3B5335B4FFDA97A25DEB90DD170C_ftn) (RuntimeObject *, FieldInfoU5BU5D_t9C36FA93372CA01DAF85946064B058CD9CE2E8BE*);
using namespace il2cpp::icalls;
return ((TypedReference_MakeTypedReferenceInternal_mD1DFB634CA2F3B5335B4FFDA97A25DEB90DD170C_ftn)mscorlib::System::TypedReference::MakeTypedReferenceInternal) (___target0, ___fields1);
}
// System.Int32 System.TypedReference::GetHashCode()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t TypedReference_GetHashCode_m6A586AC495B0AB6D55E7EAE301C82BB2752A4289 (TypedReference_t118BC3B643F75F52DB9C99D5E051299F886EB2A8 * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (TypedReference_GetHashCode_m6A586AC495B0AB6D55E7EAE301C82BB2752A4289_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
intptr_t L_0 = __this->get_Type_2();
bool L_1 = IntPtr_op_Equality_mEE8D9FD2DFE312BBAA8B4ED3BF7976B3142A5934((intptr_t)L_0, (intptr_t)(0), /*hidden argument*/NULL);
if (!L_1)
{
goto IL_0014;
}
}
{
return 0;
}
IL_0014:
{
IL2CPP_RUNTIME_CLASS_INIT(Type_t_il2cpp_TypeInfo_var);
Type_t * L_2 = Type_GetTypeFromHandle_m9DC58ADF0512987012A8A016FB64B068F3B1AFF6((*(TypedReference_t118BC3B643F75F52DB9C99D5E051299F886EB2A8 *)__this).get_type_0(), /*hidden argument*/NULL);
NullCheck(L_2);
int32_t L_3 = VirtFuncInvoker0< int32_t >::Invoke(2 /* System.Int32 System.Object::GetHashCode() */, L_2);
return L_3;
}
}
IL2CPP_EXTERN_C int32_t TypedReference_GetHashCode_m6A586AC495B0AB6D55E7EAE301C82BB2752A4289_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
TypedReference_t118BC3B643F75F52DB9C99D5E051299F886EB2A8 * _thisAdjusted = reinterpret_cast<TypedReference_t118BC3B643F75F52DB9C99D5E051299F886EB2A8 *>(__this + 1);
return TypedReference_GetHashCode_m6A586AC495B0AB6D55E7EAE301C82BB2752A4289(_thisAdjusted, method);
}
// System.Boolean System.TypedReference::Equals(System.Object)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool TypedReference_Equals_m167F7EDD4393DE114882916B753AC2D23A3840EA (TypedReference_t118BC3B643F75F52DB9C99D5E051299F886EB2A8 * __this, RuntimeObject * ___o0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (TypedReference_Equals_m167F7EDD4393DE114882916B753AC2D23A3840EA_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
String_t* L_0 = Environment_GetResourceString_m2C75C2AF268F01E2BF34AD1C2E1352CF4BA51AD9(_stringLiteral6769C7D05AE4784134EB90FB28856F9D7D5D581A, /*hidden argument*/NULL);
NotSupportedException_tE75B318D6590A02A5D9B29FD97409B1750FA0010 * L_1 = (NotSupportedException_tE75B318D6590A02A5D9B29FD97409B1750FA0010 *)il2cpp_codegen_object_new(NotSupportedException_tE75B318D6590A02A5D9B29FD97409B1750FA0010_il2cpp_TypeInfo_var);
NotSupportedException__ctor_mD023A89A5C1F740F43F0A9CD6C49DC21230B3CEE(L_1, L_0, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_1, NULL, TypedReference_Equals_m167F7EDD4393DE114882916B753AC2D23A3840EA_RuntimeMethod_var);
}
}
IL2CPP_EXTERN_C bool TypedReference_Equals_m167F7EDD4393DE114882916B753AC2D23A3840EA_AdjustorThunk (RuntimeObject * __this, RuntimeObject * ___o0, const RuntimeMethod* method)
{
TypedReference_t118BC3B643F75F52DB9C99D5E051299F886EB2A8 * _thisAdjusted = reinterpret_cast<TypedReference_t118BC3B643F75F52DB9C99D5E051299F886EB2A8 *>(__this + 1);
return TypedReference_Equals_m167F7EDD4393DE114882916B753AC2D23A3840EA(_thisAdjusted, ___o0, method);
}
// System.Boolean System.TypedReference::get_IsNull()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool TypedReference_get_IsNull_mD2B185E19B07577D8434A7DAD3AF5F9E2D09C532 (TypedReference_t118BC3B643F75F52DB9C99D5E051299F886EB2A8 * __this, const RuntimeMethod* method)
{
{
intptr_t* L_0 = __this->get_address_of_Value_1();
bool L_1 = IntPtr_IsNull_mEB01FA7670F5CA3BE36507B9528EC6F1D5AAC6B4((intptr_t*)L_0, /*hidden argument*/NULL);
if (!L_1)
{
goto IL_0019;
}
}
{
intptr_t* L_2 = __this->get_address_of_Type_2();
bool L_3 = IntPtr_IsNull_mEB01FA7670F5CA3BE36507B9528EC6F1D5AAC6B4((intptr_t*)L_2, /*hidden argument*/NULL);
return L_3;
}
IL_0019:
{
return (bool)0;
}
}
IL2CPP_EXTERN_C bool TypedReference_get_IsNull_mD2B185E19B07577D8434A7DAD3AF5F9E2D09C532_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
TypedReference_t118BC3B643F75F52DB9C99D5E051299F886EB2A8 * _thisAdjusted = reinterpret_cast<TypedReference_t118BC3B643F75F52DB9C99D5E051299F886EB2A8 *>(__this + 1);
return TypedReference_get_IsNull_mD2B185E19B07577D8434A7DAD3AF5F9E2D09C532(_thisAdjusted, method);
}
// System.Void System.TypedReference::SetTypedReference(System.TypedReference,System.Object)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void TypedReference_SetTypedReference_mCA19C65317890F40F1D808976B785A5368DFE411 (TypedReference_t118BC3B643F75F52DB9C99D5E051299F886EB2A8 ___target0, RuntimeObject * ___value1, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (TypedReference_SetTypedReference_mCA19C65317890F40F1D808976B785A5368DFE411_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
NotImplementedException_t8AD6EBE5FEDB0AEBECEE0961CF73C35B372EFFA4 * L_0 = (NotImplementedException_t8AD6EBE5FEDB0AEBECEE0961CF73C35B372EFFA4 *)il2cpp_codegen_object_new(NotImplementedException_t8AD6EBE5FEDB0AEBECEE0961CF73C35B372EFFA4_il2cpp_TypeInfo_var);
NotImplementedException__ctor_mEBAED0FCA8B8CCE7E96492474350BA35D14CF59C(L_0, _stringLiteralB4E34B56A9437FD11B5764C22789947A48B35EA5, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_0, NULL, TypedReference_SetTypedReference_mCA19C65317890F40F1D808976B785A5368DFE411_RuntimeMethod_var);
}
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Int32 System.UInt16::CompareTo(System.Object)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t UInt16_CompareTo_m91AEACDAA81D12A2A8D868938F797B112330EC44 (uint16_t* __this, RuntimeObject * ___value0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (UInt16_CompareTo_m91AEACDAA81D12A2A8D868938F797B112330EC44_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
RuntimeObject * L_0 = ___value0;
if (L_0)
{
goto IL_0005;
}
}
{
return 1;
}
IL_0005:
{
RuntimeObject * L_1 = ___value0;
if (!((RuntimeObject *)IsInstSealed((RuntimeObject*)L_1, UInt16_tAE45CEF73BF720100519F6867F32145D075F928E_il2cpp_TypeInfo_var)))
{
goto IL_0017;
}
}
{
int32_t L_2 = *((uint16_t*)__this);
RuntimeObject * L_3 = ___value0;
return ((int32_t)il2cpp_codegen_subtract((int32_t)L_2, (int32_t)((*(uint16_t*)((uint16_t*)UnBox(L_3, UInt16_tAE45CEF73BF720100519F6867F32145D075F928E_il2cpp_TypeInfo_var))))));
}
IL_0017:
{
String_t* L_4 = Environment_GetResourceString_m2C75C2AF268F01E2BF34AD1C2E1352CF4BA51AD9(_stringLiteralA9C97EF8AFEE4B1DBDBC6ACD84D8BB932359DE53, /*hidden argument*/NULL);
ArgumentException_tEDCD16F20A09ECE461C3DA766C16EDA8864057D1 * L_5 = (ArgumentException_tEDCD16F20A09ECE461C3DA766C16EDA8864057D1 *)il2cpp_codegen_object_new(ArgumentException_tEDCD16F20A09ECE461C3DA766C16EDA8864057D1_il2cpp_TypeInfo_var);
ArgumentException__ctor_m9A85EF7FEFEC21DDD525A67E831D77278E5165B7(L_5, L_4, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_5, NULL, UInt16_CompareTo_m91AEACDAA81D12A2A8D868938F797B112330EC44_RuntimeMethod_var);
}
}
IL2CPP_EXTERN_C int32_t UInt16_CompareTo_m91AEACDAA81D12A2A8D868938F797B112330EC44_AdjustorThunk (RuntimeObject * __this, RuntimeObject * ___value0, const RuntimeMethod* method)
{
uint16_t* _thisAdjusted = reinterpret_cast<uint16_t*>(__this + 1);
return UInt16_CompareTo_m91AEACDAA81D12A2A8D868938F797B112330EC44(_thisAdjusted, ___value0, method);
}
// System.Int32 System.UInt16::CompareTo(System.UInt16)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t UInt16_CompareTo_mC43C95442258DFAD3852458A9EC9E1CB76EEE644 (uint16_t* __this, uint16_t ___value0, const RuntimeMethod* method)
{
{
int32_t L_0 = *((uint16_t*)__this);
uint16_t L_1 = ___value0;
return ((int32_t)il2cpp_codegen_subtract((int32_t)L_0, (int32_t)L_1));
}
}
IL2CPP_EXTERN_C int32_t UInt16_CompareTo_mC43C95442258DFAD3852458A9EC9E1CB76EEE644_AdjustorThunk (RuntimeObject * __this, uint16_t ___value0, const RuntimeMethod* method)
{
uint16_t* _thisAdjusted = reinterpret_cast<uint16_t*>(__this + 1);
return UInt16_CompareTo_mC43C95442258DFAD3852458A9EC9E1CB76EEE644(_thisAdjusted, ___value0, method);
}
// System.Boolean System.UInt16::Equals(System.Object)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool UInt16_Equals_mBCD7FC4A11D0CEEFF4BC6559137A9E397D7017B8 (uint16_t* __this, RuntimeObject * ___obj0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (UInt16_Equals_mBCD7FC4A11D0CEEFF4BC6559137A9E397D7017B8_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
RuntimeObject * L_0 = ___obj0;
if (((RuntimeObject *)IsInstSealed((RuntimeObject*)L_0, UInt16_tAE45CEF73BF720100519F6867F32145D075F928E_il2cpp_TypeInfo_var)))
{
goto IL_000a;
}
}
{
return (bool)0;
}
IL_000a:
{
int32_t L_1 = *((uint16_t*)__this);
RuntimeObject * L_2 = ___obj0;
return (bool)((((int32_t)L_1) == ((int32_t)((*(uint16_t*)((uint16_t*)UnBox(L_2, UInt16_tAE45CEF73BF720100519F6867F32145D075F928E_il2cpp_TypeInfo_var))))))? 1 : 0);
}
}
IL2CPP_EXTERN_C bool UInt16_Equals_mBCD7FC4A11D0CEEFF4BC6559137A9E397D7017B8_AdjustorThunk (RuntimeObject * __this, RuntimeObject * ___obj0, const RuntimeMethod* method)
{
uint16_t* _thisAdjusted = reinterpret_cast<uint16_t*>(__this + 1);
return UInt16_Equals_mBCD7FC4A11D0CEEFF4BC6559137A9E397D7017B8(_thisAdjusted, ___obj0, method);
}
// System.Boolean System.UInt16::Equals(System.UInt16)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool UInt16_Equals_m276F4220CB70A960FF4E874EE1D388C277EF806C (uint16_t* __this, uint16_t ___obj0, const RuntimeMethod* method)
{
{
int32_t L_0 = *((uint16_t*)__this);
uint16_t L_1 = ___obj0;
return (bool)((((int32_t)L_0) == ((int32_t)L_1))? 1 : 0);
}
}
IL2CPP_EXTERN_C bool UInt16_Equals_m276F4220CB70A960FF4E874EE1D388C277EF806C_AdjustorThunk (RuntimeObject * __this, uint16_t ___obj0, const RuntimeMethod* method)
{
uint16_t* _thisAdjusted = reinterpret_cast<uint16_t*>(__this + 1);
return UInt16_Equals_m276F4220CB70A960FF4E874EE1D388C277EF806C(_thisAdjusted, ___obj0, method);
}
// System.Int32 System.UInt16::GetHashCode()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t UInt16_GetHashCode_m6EA43320256903F18CCA1A82905DB6F75BC4FB6E (uint16_t* __this, const RuntimeMethod* method)
{
{
int32_t L_0 = *((uint16_t*)__this);
return L_0;
}
}
IL2CPP_EXTERN_C int32_t UInt16_GetHashCode_m6EA43320256903F18CCA1A82905DB6F75BC4FB6E_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
uint16_t* _thisAdjusted = reinterpret_cast<uint16_t*>(__this + 1);
return UInt16_GetHashCode_m6EA43320256903F18CCA1A82905DB6F75BC4FB6E(_thisAdjusted, method);
}
// System.String System.UInt16::ToString()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR String_t* UInt16_ToString_m4B42F0450EE965C7C9DD2AB19EB000D47CE978A2 (uint16_t* __this, const RuntimeMethod* method)
{
{
int32_t L_0 = *((uint16_t*)__this);
NumberFormatInfo_tFDF57037EBC5BC833D0A53EF0327B805994860A8 * L_1 = NumberFormatInfo_get_CurrentInfo_m595DF03E32E0C5B01F1EC45F7264B2BD09BA61C9(/*hidden argument*/NULL);
String_t* L_2 = Number_FormatUInt32_m585E2571063A256E46836A51BC4A54CFF151BDEE(L_0, (String_t*)NULL, L_1, /*hidden argument*/NULL);
return L_2;
}
}
IL2CPP_EXTERN_C String_t* UInt16_ToString_m4B42F0450EE965C7C9DD2AB19EB000D47CE978A2_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
uint16_t* _thisAdjusted = reinterpret_cast<uint16_t*>(__this + 1);
return UInt16_ToString_m4B42F0450EE965C7C9DD2AB19EB000D47CE978A2(_thisAdjusted, method);
}
// System.String System.UInt16::ToString(System.IFormatProvider)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR String_t* UInt16_ToString_m50316C445AD23CCA40AA52A381C5E06A3786F12A (uint16_t* __this, RuntimeObject* ___provider0, const RuntimeMethod* method)
{
{
int32_t L_0 = *((uint16_t*)__this);
RuntimeObject* L_1 = ___provider0;
NumberFormatInfo_tFDF57037EBC5BC833D0A53EF0327B805994860A8 * L_2 = NumberFormatInfo_GetInstance_m713D298B436F3765F059FEA6C446F0A6ABF0A89A(L_1, /*hidden argument*/NULL);
String_t* L_3 = Number_FormatUInt32_m585E2571063A256E46836A51BC4A54CFF151BDEE(L_0, (String_t*)NULL, L_2, /*hidden argument*/NULL);
return L_3;
}
}
IL2CPP_EXTERN_C String_t* UInt16_ToString_m50316C445AD23CCA40AA52A381C5E06A3786F12A_AdjustorThunk (RuntimeObject * __this, RuntimeObject* ___provider0, const RuntimeMethod* method)
{
uint16_t* _thisAdjusted = reinterpret_cast<uint16_t*>(__this + 1);
return UInt16_ToString_m50316C445AD23CCA40AA52A381C5E06A3786F12A(_thisAdjusted, ___provider0, method);
}
// System.String System.UInt16::ToString(System.String,System.IFormatProvider)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR String_t* UInt16_ToString_mD0CBA1F073A0E16528C1A7EB4E8A9892D218895B (uint16_t* __this, String_t* ___format0, RuntimeObject* ___provider1, const RuntimeMethod* method)
{
{
int32_t L_0 = *((uint16_t*)__this);
String_t* L_1 = ___format0;
RuntimeObject* L_2 = ___provider1;
NumberFormatInfo_tFDF57037EBC5BC833D0A53EF0327B805994860A8 * L_3 = NumberFormatInfo_GetInstance_m713D298B436F3765F059FEA6C446F0A6ABF0A89A(L_2, /*hidden argument*/NULL);
String_t* L_4 = Number_FormatUInt32_m585E2571063A256E46836A51BC4A54CFF151BDEE(L_0, L_1, L_3, /*hidden argument*/NULL);
return L_4;
}
}
IL2CPP_EXTERN_C String_t* UInt16_ToString_mD0CBA1F073A0E16528C1A7EB4E8A9892D218895B_AdjustorThunk (RuntimeObject * __this, String_t* ___format0, RuntimeObject* ___provider1, const RuntimeMethod* method)
{
uint16_t* _thisAdjusted = reinterpret_cast<uint16_t*>(__this + 1);
return UInt16_ToString_mD0CBA1F073A0E16528C1A7EB4E8A9892D218895B(_thisAdjusted, ___format0, ___provider1, method);
}
// System.UInt16 System.UInt16::Parse(System.String,System.IFormatProvider)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR uint16_t UInt16_Parse_m63ED81DBC50063DC0C6A7BD92F38D42CE36C14F8 (String_t* ___s0, RuntimeObject* ___provider1, const RuntimeMethod* method)
{
{
String_t* L_0 = ___s0;
RuntimeObject* L_1 = ___provider1;
NumberFormatInfo_tFDF57037EBC5BC833D0A53EF0327B805994860A8 * L_2 = NumberFormatInfo_GetInstance_m713D298B436F3765F059FEA6C446F0A6ABF0A89A(L_1, /*hidden argument*/NULL);
uint16_t L_3 = UInt16_Parse_m12E00A51D9C346D8537FD42FC93C9113D2A0D254(L_0, 7, L_2, /*hidden argument*/NULL);
return L_3;
}
}
// System.UInt16 System.UInt16::Parse(System.String,System.Globalization.NumberStyles,System.IFormatProvider)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR uint16_t UInt16_Parse_mEA6E086539E279750BCC41E5C9638C2514924E8B (String_t* ___s0, int32_t ___style1, RuntimeObject* ___provider2, const RuntimeMethod* method)
{
{
int32_t L_0 = ___style1;
NumberFormatInfo_ValidateParseStyleInteger_m5BD1C04C26D5589F0DFA5953294B72E1DDC2B7E3(L_0, /*hidden argument*/NULL);
String_t* L_1 = ___s0;
int32_t L_2 = ___style1;
RuntimeObject* L_3 = ___provider2;
NumberFormatInfo_tFDF57037EBC5BC833D0A53EF0327B805994860A8 * L_4 = NumberFormatInfo_GetInstance_m713D298B436F3765F059FEA6C446F0A6ABF0A89A(L_3, /*hidden argument*/NULL);
uint16_t L_5 = UInt16_Parse_m12E00A51D9C346D8537FD42FC93C9113D2A0D254(L_1, L_2, L_4, /*hidden argument*/NULL);
return L_5;
}
}
// System.UInt16 System.UInt16::Parse(System.String,System.Globalization.NumberStyles,System.Globalization.NumberFormatInfo)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR uint16_t UInt16_Parse_m12E00A51D9C346D8537FD42FC93C9113D2A0D254 (String_t* ___s0, int32_t ___style1, NumberFormatInfo_tFDF57037EBC5BC833D0A53EF0327B805994860A8 * ___info2, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (UInt16_Parse_m12E00A51D9C346D8537FD42FC93C9113D2A0D254_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
uint32_t V_0 = 0;
OverflowException_tD89571E2350DE06D9DE4AB65ADCA77D607B5693D * V_1 = NULL;
Exception_t * __last_unhandled_exception = 0;
NO_UNUSED_WARNING (__last_unhandled_exception);
Exception_t * __exception_local = 0;
NO_UNUSED_WARNING (__exception_local);
int32_t __leave_target = -1;
NO_UNUSED_WARNING (__leave_target);
{
V_0 = 0;
}
IL_0002:
try
{ // begin try (depth: 1)
String_t* L_0 = ___s0;
int32_t L_1 = ___style1;
NumberFormatInfo_tFDF57037EBC5BC833D0A53EF0327B805994860A8 * L_2 = ___info2;
uint32_t L_3 = Number_ParseUInt32_mF280A62925FED84E23D64DC6B86BC50AD96896FB(L_0, L_1, L_2, /*hidden argument*/NULL);
V_0 = L_3;
goto IL_001f;
} // end try (depth: 1)
catch(Il2CppExceptionWrapper& e)
{
__exception_local = (Exception_t *)e.ex;
if(il2cpp_codegen_class_is_assignable_from (OverflowException_tD89571E2350DE06D9DE4AB65ADCA77D607B5693D_il2cpp_TypeInfo_var, il2cpp_codegen_object_class(e.ex)))
goto CATCH_000d;
throw e;
}
CATCH_000d:
{ // begin catch(System.OverflowException)
V_1 = ((OverflowException_tD89571E2350DE06D9DE4AB65ADCA77D607B5693D *)__exception_local);
String_t* L_4 = Environment_GetResourceString_m2C75C2AF268F01E2BF34AD1C2E1352CF4BA51AD9(_stringLiteral6972AB6A4112783DFDFEE444146EB3CF741CCD13, /*hidden argument*/NULL);
OverflowException_tD89571E2350DE06D9DE4AB65ADCA77D607B5693D * L_5 = V_1;
OverflowException_tD89571E2350DE06D9DE4AB65ADCA77D607B5693D * L_6 = (OverflowException_tD89571E2350DE06D9DE4AB65ADCA77D607B5693D *)il2cpp_codegen_object_new(OverflowException_tD89571E2350DE06D9DE4AB65ADCA77D607B5693D_il2cpp_TypeInfo_var);
OverflowException__ctor_m15CD001EEB2E79D7497E101546B04D9A5520357E(L_6, L_4, L_5, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_6, NULL, UInt16_Parse_m12E00A51D9C346D8537FD42FC93C9113D2A0D254_RuntimeMethod_var);
} // end catch (depth: 1)
IL_001f:
{
uint32_t L_7 = V_0;
if ((!(((uint32_t)L_7) > ((uint32_t)((int32_t)65535)))))
{
goto IL_0037;
}
}
{
String_t* L_8 = Environment_GetResourceString_m2C75C2AF268F01E2BF34AD1C2E1352CF4BA51AD9(_stringLiteral6972AB6A4112783DFDFEE444146EB3CF741CCD13, /*hidden argument*/NULL);
OverflowException_tD89571E2350DE06D9DE4AB65ADCA77D607B5693D * L_9 = (OverflowException_tD89571E2350DE06D9DE4AB65ADCA77D607B5693D *)il2cpp_codegen_object_new(OverflowException_tD89571E2350DE06D9DE4AB65ADCA77D607B5693D_il2cpp_TypeInfo_var);
OverflowException__ctor_mE1A042FFEBF00B79612E8595B8D49785B357D731(L_9, L_8, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_9, NULL, UInt16_Parse_m12E00A51D9C346D8537FD42FC93C9113D2A0D254_RuntimeMethod_var);
}
IL_0037:
{
uint32_t L_10 = V_0;
return (uint16_t)(((int32_t)((uint16_t)L_10)));
}
}
// System.TypeCode System.UInt16::GetTypeCode()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t UInt16_GetTypeCode_m3F7CA335640E0702177D473528E70C8D58E0E068 (uint16_t* __this, const RuntimeMethod* method)
{
{
return (int32_t)(8);
}
}
IL2CPP_EXTERN_C int32_t UInt16_GetTypeCode_m3F7CA335640E0702177D473528E70C8D58E0E068_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
uint16_t* _thisAdjusted = reinterpret_cast<uint16_t*>(__this + 1);
return UInt16_GetTypeCode_m3F7CA335640E0702177D473528E70C8D58E0E068(_thisAdjusted, method);
}
// System.Boolean System.UInt16::System.IConvertible.ToBoolean(System.IFormatProvider)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool UInt16_System_IConvertible_ToBoolean_mC81E40A61B311E3D9E69439B629E90816966F72A (uint16_t* __this, RuntimeObject* ___provider0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (UInt16_System_IConvertible_ToBoolean_mC81E40A61B311E3D9E69439B629E90816966F72A_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
int32_t L_0 = *((uint16_t*)__this);
IL2CPP_RUNTIME_CLASS_INIT(Convert_t1C7A851BFB2F0782FD7F72F6AA1DCBB7B53A9C7E_il2cpp_TypeInfo_var);
bool L_1 = Convert_ToBoolean_m1AFE52438BC600124643ECEB4EDF9C3FE21171FE((uint16_t)L_0, /*hidden argument*/NULL);
return L_1;
}
}
IL2CPP_EXTERN_C bool UInt16_System_IConvertible_ToBoolean_mC81E40A61B311E3D9E69439B629E90816966F72A_AdjustorThunk (RuntimeObject * __this, RuntimeObject* ___provider0, const RuntimeMethod* method)
{
uint16_t* _thisAdjusted = reinterpret_cast<uint16_t*>(__this + 1);
return UInt16_System_IConvertible_ToBoolean_mC81E40A61B311E3D9E69439B629E90816966F72A(_thisAdjusted, ___provider0, method);
}
// System.Char System.UInt16::System.IConvertible.ToChar(System.IFormatProvider)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Il2CppChar UInt16_System_IConvertible_ToChar_m6CD04280CB5C9546579E13211911F5B42B498F0F (uint16_t* __this, RuntimeObject* ___provider0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (UInt16_System_IConvertible_ToChar_m6CD04280CB5C9546579E13211911F5B42B498F0F_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
int32_t L_0 = *((uint16_t*)__this);
IL2CPP_RUNTIME_CLASS_INIT(Convert_t1C7A851BFB2F0782FD7F72F6AA1DCBB7B53A9C7E_il2cpp_TypeInfo_var);
Il2CppChar L_1 = Convert_ToChar_m14666E8E6027FFF4BFA6DA0563A4CAAEA6A6989B((uint16_t)L_0, /*hidden argument*/NULL);
return L_1;
}
}
IL2CPP_EXTERN_C Il2CppChar UInt16_System_IConvertible_ToChar_m6CD04280CB5C9546579E13211911F5B42B498F0F_AdjustorThunk (RuntimeObject * __this, RuntimeObject* ___provider0, const RuntimeMethod* method)
{
uint16_t* _thisAdjusted = reinterpret_cast<uint16_t*>(__this + 1);
return UInt16_System_IConvertible_ToChar_m6CD04280CB5C9546579E13211911F5B42B498F0F(_thisAdjusted, ___provider0, method);
}
// System.SByte System.UInt16::System.IConvertible.ToSByte(System.IFormatProvider)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int8_t UInt16_System_IConvertible_ToSByte_mA4AD532B0AF50FD2F6AEBCDB581EA1EE43FCA3CF (uint16_t* __this, RuntimeObject* ___provider0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (UInt16_System_IConvertible_ToSByte_mA4AD532B0AF50FD2F6AEBCDB581EA1EE43FCA3CF_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
int32_t L_0 = *((uint16_t*)__this);
IL2CPP_RUNTIME_CLASS_INIT(Convert_t1C7A851BFB2F0782FD7F72F6AA1DCBB7B53A9C7E_il2cpp_TypeInfo_var);
int8_t L_1 = Convert_ToSByte_m4455F931B18E5D87DE1F99B2686F3D4770E9D177((uint16_t)L_0, /*hidden argument*/NULL);
return L_1;
}
}
IL2CPP_EXTERN_C int8_t UInt16_System_IConvertible_ToSByte_mA4AD532B0AF50FD2F6AEBCDB581EA1EE43FCA3CF_AdjustorThunk (RuntimeObject * __this, RuntimeObject* ___provider0, const RuntimeMethod* method)
{
uint16_t* _thisAdjusted = reinterpret_cast<uint16_t*>(__this + 1);
return UInt16_System_IConvertible_ToSByte_mA4AD532B0AF50FD2F6AEBCDB581EA1EE43FCA3CF(_thisAdjusted, ___provider0, method);
}
// System.Byte System.UInt16::System.IConvertible.ToByte(System.IFormatProvider)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR uint8_t UInt16_System_IConvertible_ToByte_mA95B992F24924E773C5602A6FEE29BDE5EE2072F (uint16_t* __this, RuntimeObject* ___provider0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (UInt16_System_IConvertible_ToByte_mA95B992F24924E773C5602A6FEE29BDE5EE2072F_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
int32_t L_0 = *((uint16_t*)__this);
IL2CPP_RUNTIME_CLASS_INIT(Convert_t1C7A851BFB2F0782FD7F72F6AA1DCBB7B53A9C7E_il2cpp_TypeInfo_var);
uint8_t L_1 = Convert_ToByte_m4D9F94693332601CE2F1CF8DB9933F7C0FE882B1((uint16_t)L_0, /*hidden argument*/NULL);
return L_1;
}
}
IL2CPP_EXTERN_C uint8_t UInt16_System_IConvertible_ToByte_mA95B992F24924E773C5602A6FEE29BDE5EE2072F_AdjustorThunk (RuntimeObject * __this, RuntimeObject* ___provider0, const RuntimeMethod* method)
{
uint16_t* _thisAdjusted = reinterpret_cast<uint16_t*>(__this + 1);
return UInt16_System_IConvertible_ToByte_mA95B992F24924E773C5602A6FEE29BDE5EE2072F(_thisAdjusted, ___provider0, method);
}
// System.Int16 System.UInt16::System.IConvertible.ToInt16(System.IFormatProvider)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int16_t UInt16_System_IConvertible_ToInt16_m0818293E3F1271A2AD126AE950B71DBDDD3286D3 (uint16_t* __this, RuntimeObject* ___provider0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (UInt16_System_IConvertible_ToInt16_m0818293E3F1271A2AD126AE950B71DBDDD3286D3_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
int32_t L_0 = *((uint16_t*)__this);
IL2CPP_RUNTIME_CLASS_INIT(Convert_t1C7A851BFB2F0782FD7F72F6AA1DCBB7B53A9C7E_il2cpp_TypeInfo_var);
int16_t L_1 = Convert_ToInt16_m57BC4B92DCAEAA22820CD1915778B407AC23D9C5((uint16_t)L_0, /*hidden argument*/NULL);
return L_1;
}
}
IL2CPP_EXTERN_C int16_t UInt16_System_IConvertible_ToInt16_m0818293E3F1271A2AD126AE950B71DBDDD3286D3_AdjustorThunk (RuntimeObject * __this, RuntimeObject* ___provider0, const RuntimeMethod* method)
{
uint16_t* _thisAdjusted = reinterpret_cast<uint16_t*>(__this + 1);
return UInt16_System_IConvertible_ToInt16_m0818293E3F1271A2AD126AE950B71DBDDD3286D3(_thisAdjusted, ___provider0, method);
}
// System.UInt16 System.UInt16::System.IConvertible.ToUInt16(System.IFormatProvider)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR uint16_t UInt16_System_IConvertible_ToUInt16_mC5507444643901A95C85AA36B8F702EEA4616C81 (uint16_t* __this, RuntimeObject* ___provider0, const RuntimeMethod* method)
{
{
int32_t L_0 = *((uint16_t*)__this);
return (uint16_t)L_0;
}
}
IL2CPP_EXTERN_C uint16_t UInt16_System_IConvertible_ToUInt16_mC5507444643901A95C85AA36B8F702EEA4616C81_AdjustorThunk (RuntimeObject * __this, RuntimeObject* ___provider0, const RuntimeMethod* method)
{
uint16_t* _thisAdjusted = reinterpret_cast<uint16_t*>(__this + 1);
return UInt16_System_IConvertible_ToUInt16_mC5507444643901A95C85AA36B8F702EEA4616C81(_thisAdjusted, ___provider0, method);
}
// System.Int32 System.UInt16::System.IConvertible.ToInt32(System.IFormatProvider)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t UInt16_System_IConvertible_ToInt32_mA3C6E3F7DE9C6C893CAA5301EEDA26036554F34C (uint16_t* __this, RuntimeObject* ___provider0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (UInt16_System_IConvertible_ToInt32_mA3C6E3F7DE9C6C893CAA5301EEDA26036554F34C_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
int32_t L_0 = *((uint16_t*)__this);
IL2CPP_RUNTIME_CLASS_INIT(Convert_t1C7A851BFB2F0782FD7F72F6AA1DCBB7B53A9C7E_il2cpp_TypeInfo_var);
int32_t L_1 = Convert_ToInt32_m8A95C977AFB27DA577E58CAE3255F8B24EE79517((uint16_t)L_0, /*hidden argument*/NULL);
return L_1;
}
}
IL2CPP_EXTERN_C int32_t UInt16_System_IConvertible_ToInt32_mA3C6E3F7DE9C6C893CAA5301EEDA26036554F34C_AdjustorThunk (RuntimeObject * __this, RuntimeObject* ___provider0, const RuntimeMethod* method)
{
uint16_t* _thisAdjusted = reinterpret_cast<uint16_t*>(__this + 1);
return UInt16_System_IConvertible_ToInt32_mA3C6E3F7DE9C6C893CAA5301EEDA26036554F34C(_thisAdjusted, ___provider0, method);
}
// System.UInt32 System.UInt16::System.IConvertible.ToUInt32(System.IFormatProvider)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR uint32_t UInt16_System_IConvertible_ToUInt32_m6DA7A076663655EB849211FF9BD16582F863C5F3 (uint16_t* __this, RuntimeObject* ___provider0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (UInt16_System_IConvertible_ToUInt32_m6DA7A076663655EB849211FF9BD16582F863C5F3_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
int32_t L_0 = *((uint16_t*)__this);
IL2CPP_RUNTIME_CLASS_INIT(Convert_t1C7A851BFB2F0782FD7F72F6AA1DCBB7B53A9C7E_il2cpp_TypeInfo_var);
uint32_t L_1 = Convert_ToUInt32_mED4922B504189D92D2F6F52BB959895A5979EE40((uint16_t)L_0, /*hidden argument*/NULL);
return L_1;
}
}
IL2CPP_EXTERN_C uint32_t UInt16_System_IConvertible_ToUInt32_m6DA7A076663655EB849211FF9BD16582F863C5F3_AdjustorThunk (RuntimeObject * __this, RuntimeObject* ___provider0, const RuntimeMethod* method)
{
uint16_t* _thisAdjusted = reinterpret_cast<uint16_t*>(__this + 1);
return UInt16_System_IConvertible_ToUInt32_m6DA7A076663655EB849211FF9BD16582F863C5F3(_thisAdjusted, ___provider0, method);
}
// System.Int64 System.UInt16::System.IConvertible.ToInt64(System.IFormatProvider)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int64_t UInt16_System_IConvertible_ToInt64_mC204E05417B4F982A189912080F57F20E24275CB (uint16_t* __this, RuntimeObject* ___provider0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (UInt16_System_IConvertible_ToInt64_mC204E05417B4F982A189912080F57F20E24275CB_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
int32_t L_0 = *((uint16_t*)__this);
IL2CPP_RUNTIME_CLASS_INIT(Convert_t1C7A851BFB2F0782FD7F72F6AA1DCBB7B53A9C7E_il2cpp_TypeInfo_var);
int64_t L_1 = Convert_ToInt64_mE191CDE636529E410288B04286028D56CBC8EE53((uint16_t)L_0, /*hidden argument*/NULL);
return L_1;
}
}
IL2CPP_EXTERN_C int64_t UInt16_System_IConvertible_ToInt64_mC204E05417B4F982A189912080F57F20E24275CB_AdjustorThunk (RuntimeObject * __this, RuntimeObject* ___provider0, const RuntimeMethod* method)
{
uint16_t* _thisAdjusted = reinterpret_cast<uint16_t*>(__this + 1);
return UInt16_System_IConvertible_ToInt64_mC204E05417B4F982A189912080F57F20E24275CB(_thisAdjusted, ___provider0, method);
}
// System.UInt64 System.UInt16::System.IConvertible.ToUInt64(System.IFormatProvider)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR uint64_t UInt16_System_IConvertible_ToUInt64_m510EF773A50C42F0B60B2C8AE753FC7873B3A97B (uint16_t* __this, RuntimeObject* ___provider0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (UInt16_System_IConvertible_ToUInt64_m510EF773A50C42F0B60B2C8AE753FC7873B3A97B_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
int32_t L_0 = *((uint16_t*)__this);
IL2CPP_RUNTIME_CLASS_INIT(Convert_t1C7A851BFB2F0782FD7F72F6AA1DCBB7B53A9C7E_il2cpp_TypeInfo_var);
uint64_t L_1 = Convert_ToUInt64_m13A97BCFDAB847AC0D6379DA3FBE031509801944((uint16_t)L_0, /*hidden argument*/NULL);
return L_1;
}
}
IL2CPP_EXTERN_C uint64_t UInt16_System_IConvertible_ToUInt64_m510EF773A50C42F0B60B2C8AE753FC7873B3A97B_AdjustorThunk (RuntimeObject * __this, RuntimeObject* ___provider0, const RuntimeMethod* method)
{
uint16_t* _thisAdjusted = reinterpret_cast<uint16_t*>(__this + 1);
return UInt16_System_IConvertible_ToUInt64_m510EF773A50C42F0B60B2C8AE753FC7873B3A97B(_thisAdjusted, ___provider0, method);
}
// System.Single System.UInt16::System.IConvertible.ToSingle(System.IFormatProvider)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR float UInt16_System_IConvertible_ToSingle_m6B087CB34DBF0B394642977BB68F8B503DED3C7E (uint16_t* __this, RuntimeObject* ___provider0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (UInt16_System_IConvertible_ToSingle_m6B087CB34DBF0B394642977BB68F8B503DED3C7E_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
int32_t L_0 = *((uint16_t*)__this);
IL2CPP_RUNTIME_CLASS_INIT(Convert_t1C7A851BFB2F0782FD7F72F6AA1DCBB7B53A9C7E_il2cpp_TypeInfo_var);
float L_1 = Convert_ToSingle_mFBCC3DBA2C1A176506B5B23193DD0F5F27085EAA((uint16_t)L_0, /*hidden argument*/NULL);
return L_1;
}
}
IL2CPP_EXTERN_C float UInt16_System_IConvertible_ToSingle_m6B087CB34DBF0B394642977BB68F8B503DED3C7E_AdjustorThunk (RuntimeObject * __this, RuntimeObject* ___provider0, const RuntimeMethod* method)
{
uint16_t* _thisAdjusted = reinterpret_cast<uint16_t*>(__this + 1);
return UInt16_System_IConvertible_ToSingle_m6B087CB34DBF0B394642977BB68F8B503DED3C7E(_thisAdjusted, ___provider0, method);
}
// System.Double System.UInt16::System.IConvertible.ToDouble(System.IFormatProvider)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR double UInt16_System_IConvertible_ToDouble_m62236A4E72E544543EA440ED142B8BA093ADCB40 (uint16_t* __this, RuntimeObject* ___provider0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (UInt16_System_IConvertible_ToDouble_m62236A4E72E544543EA440ED142B8BA093ADCB40_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
int32_t L_0 = *((uint16_t*)__this);
IL2CPP_RUNTIME_CLASS_INIT(Convert_t1C7A851BFB2F0782FD7F72F6AA1DCBB7B53A9C7E_il2cpp_TypeInfo_var);
double L_1 = Convert_ToDouble_m5427641E8803E839561F9C10071C3E33A1A6F854((uint16_t)L_0, /*hidden argument*/NULL);
return L_1;
}
}
IL2CPP_EXTERN_C double UInt16_System_IConvertible_ToDouble_m62236A4E72E544543EA440ED142B8BA093ADCB40_AdjustorThunk (RuntimeObject * __this, RuntimeObject* ___provider0, const RuntimeMethod* method)
{
uint16_t* _thisAdjusted = reinterpret_cast<uint16_t*>(__this + 1);
return UInt16_System_IConvertible_ToDouble_m62236A4E72E544543EA440ED142B8BA093ADCB40(_thisAdjusted, ___provider0, method);
}
// System.Decimal System.UInt16::System.IConvertible.ToDecimal(System.IFormatProvider)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Decimal_t44EE9DA309A1BF848308DE4DDFC070CAE6D95EE8 UInt16_System_IConvertible_ToDecimal_m74D92DB8814035966C6CFF447753338B03287E43 (uint16_t* __this, RuntimeObject* ___provider0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (UInt16_System_IConvertible_ToDecimal_m74D92DB8814035966C6CFF447753338B03287E43_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
int32_t L_0 = *((uint16_t*)__this);
IL2CPP_RUNTIME_CLASS_INIT(Convert_t1C7A851BFB2F0782FD7F72F6AA1DCBB7B53A9C7E_il2cpp_TypeInfo_var);
Decimal_t44EE9DA309A1BF848308DE4DDFC070CAE6D95EE8 L_1 = Convert_ToDecimal_mFD0BC78E6BE4EDBFD7A0767E7D95A39E40F0260F((uint16_t)L_0, /*hidden argument*/NULL);
return L_1;
}
}
IL2CPP_EXTERN_C Decimal_t44EE9DA309A1BF848308DE4DDFC070CAE6D95EE8 UInt16_System_IConvertible_ToDecimal_m74D92DB8814035966C6CFF447753338B03287E43_AdjustorThunk (RuntimeObject * __this, RuntimeObject* ___provider0, const RuntimeMethod* method)
{
uint16_t* _thisAdjusted = reinterpret_cast<uint16_t*>(__this + 1);
return UInt16_System_IConvertible_ToDecimal_m74D92DB8814035966C6CFF447753338B03287E43(_thisAdjusted, ___provider0, method);
}
// System.DateTime System.UInt16::System.IConvertible.ToDateTime(System.IFormatProvider)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR DateTime_t349B7449FBAAFF4192636E2B7A07694DA9236132 UInt16_System_IConvertible_ToDateTime_m7AD170006FECE0BAC29179FFE72D7AC1B0D0C735 (uint16_t* __this, RuntimeObject* ___provider0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (UInt16_System_IConvertible_ToDateTime_m7AD170006FECE0BAC29179FFE72D7AC1B0D0C735_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
ObjectU5BU5D_t3C9242B5C88A48B2A5BD9FDA6CD0024E792AF08A* L_0 = (ObjectU5BU5D_t3C9242B5C88A48B2A5BD9FDA6CD0024E792AF08A*)(ObjectU5BU5D_t3C9242B5C88A48B2A5BD9FDA6CD0024E792AF08A*)SZArrayNew(ObjectU5BU5D_t3C9242B5C88A48B2A5BD9FDA6CD0024E792AF08A_il2cpp_TypeInfo_var, (uint32_t)2);
ObjectU5BU5D_t3C9242B5C88A48B2A5BD9FDA6CD0024E792AF08A* L_1 = L_0;
NullCheck(L_1);
ArrayElementTypeCheck (L_1, _stringLiteral70B4BB2684C3F8969E2FE9E14B470906FD4CF3C6);
(L_1)->SetAt(static_cast<il2cpp_array_size_t>(0), (RuntimeObject *)_stringLiteral70B4BB2684C3F8969E2FE9E14B470906FD4CF3C6);
ObjectU5BU5D_t3C9242B5C88A48B2A5BD9FDA6CD0024E792AF08A* L_2 = L_1;
NullCheck(L_2);
ArrayElementTypeCheck (L_2, _stringLiteralF1E5BAF5ECC3589631088C40CBDD43061976ED8F);
(L_2)->SetAt(static_cast<il2cpp_array_size_t>(1), (RuntimeObject *)_stringLiteralF1E5BAF5ECC3589631088C40CBDD43061976ED8F);
String_t* L_3 = Environment_GetResourceString_m7389941B4C0688D875CC647D99A739DA2F907ADB(_stringLiteralE5559C91F3F57F398B8B547CA356C67FFA1F6497, L_2, /*hidden argument*/NULL);
InvalidCastException_t91DF9E7D7FCCDA6C562CB4A9A18903E016680FDA * L_4 = (InvalidCastException_t91DF9E7D7FCCDA6C562CB4A9A18903E016680FDA *)il2cpp_codegen_object_new(InvalidCastException_t91DF9E7D7FCCDA6C562CB4A9A18903E016680FDA_il2cpp_TypeInfo_var);
InvalidCastException__ctor_m3795145150387C6C362DA693613505C604AB8812(L_4, L_3, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_4, NULL, UInt16_System_IConvertible_ToDateTime_m7AD170006FECE0BAC29179FFE72D7AC1B0D0C735_RuntimeMethod_var);
}
}
IL2CPP_EXTERN_C DateTime_t349B7449FBAAFF4192636E2B7A07694DA9236132 UInt16_System_IConvertible_ToDateTime_m7AD170006FECE0BAC29179FFE72D7AC1B0D0C735_AdjustorThunk (RuntimeObject * __this, RuntimeObject* ___provider0, const RuntimeMethod* method)
{
uint16_t* _thisAdjusted = reinterpret_cast<uint16_t*>(__this + 1);
return UInt16_System_IConvertible_ToDateTime_m7AD170006FECE0BAC29179FFE72D7AC1B0D0C735(_thisAdjusted, ___provider0, method);
}
// System.Object System.UInt16::System.IConvertible.ToType(System.Type,System.IFormatProvider)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * UInt16_System_IConvertible_ToType_m2FD8E8941C266AE4254B1C4C068F4C5238C08695 (uint16_t* __this, Type_t * ___type0, RuntimeObject* ___provider1, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (UInt16_System_IConvertible_ToType_m2FD8E8941C266AE4254B1C4C068F4C5238C08695_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
int32_t L_0 = *((uint16_t*)__this);
uint16_t L_1 = ((uint16_t)L_0);
RuntimeObject * L_2 = Box(UInt16_tAE45CEF73BF720100519F6867F32145D075F928E_il2cpp_TypeInfo_var, &L_1);
Type_t * L_3 = ___type0;
RuntimeObject* L_4 = ___provider1;
IL2CPP_RUNTIME_CLASS_INIT(Convert_t1C7A851BFB2F0782FD7F72F6AA1DCBB7B53A9C7E_il2cpp_TypeInfo_var);
RuntimeObject * L_5 = Convert_DefaultToType_m899D5F6B9FE3E8B878BC56172C6BFE788B6C1BE3((RuntimeObject*)L_2, L_3, L_4, /*hidden argument*/NULL);
return L_5;
}
}
IL2CPP_EXTERN_C RuntimeObject * UInt16_System_IConvertible_ToType_m2FD8E8941C266AE4254B1C4C068F4C5238C08695_AdjustorThunk (RuntimeObject * __this, Type_t * ___type0, RuntimeObject* ___provider1, const RuntimeMethod* method)
{
uint16_t* _thisAdjusted = reinterpret_cast<uint16_t*>(__this + 1);
return UInt16_System_IConvertible_ToType_m2FD8E8941C266AE4254B1C4C068F4C5238C08695(_thisAdjusted, ___type0, ___provider1, method);
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Int32 System.UInt32::CompareTo(System.Object)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t UInt32_CompareTo_mA6BFE8D9033149D2FEF46526E251A3CDEB1889EB (uint32_t* __this, RuntimeObject * ___value0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (UInt32_CompareTo_mA6BFE8D9033149D2FEF46526E251A3CDEB1889EB_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
uint32_t V_0 = 0;
{
RuntimeObject * L_0 = ___value0;
if (L_0)
{
goto IL_0005;
}
}
{
return 1;
}
IL_0005:
{
RuntimeObject * L_1 = ___value0;
if (!((RuntimeObject *)IsInstSealed((RuntimeObject*)L_1, UInt32_t4980FA09003AFAAB5A6E361BA2748EA9A005709B_il2cpp_TypeInfo_var)))
{
goto IL_0024;
}
}
{
RuntimeObject * L_2 = ___value0;
V_0 = ((*(uint32_t*)((uint32_t*)UnBox(L_2, UInt32_t4980FA09003AFAAB5A6E361BA2748EA9A005709B_il2cpp_TypeInfo_var))));
int32_t L_3 = *((uint32_t*)__this);
uint32_t L_4 = V_0;
if ((!(((uint32_t)L_3) < ((uint32_t)L_4))))
{
goto IL_001b;
}
}
{
return (-1);
}
IL_001b:
{
int32_t L_5 = *((uint32_t*)__this);
uint32_t L_6 = V_0;
if ((!(((uint32_t)L_5) > ((uint32_t)L_6))))
{
goto IL_0022;
}
}
{
return 1;
}
IL_0022:
{
return 0;
}
IL_0024:
{
String_t* L_7 = Environment_GetResourceString_m2C75C2AF268F01E2BF34AD1C2E1352CF4BA51AD9(_stringLiteral3C4D966BBA6CE40E91BAFB95088822186ECB287B, /*hidden argument*/NULL);
ArgumentException_tEDCD16F20A09ECE461C3DA766C16EDA8864057D1 * L_8 = (ArgumentException_tEDCD16F20A09ECE461C3DA766C16EDA8864057D1 *)il2cpp_codegen_object_new(ArgumentException_tEDCD16F20A09ECE461C3DA766C16EDA8864057D1_il2cpp_TypeInfo_var);
ArgumentException__ctor_m9A85EF7FEFEC21DDD525A67E831D77278E5165B7(L_8, L_7, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_8, NULL, UInt32_CompareTo_mA6BFE8D9033149D2FEF46526E251A3CDEB1889EB_RuntimeMethod_var);
}
}
IL2CPP_EXTERN_C int32_t UInt32_CompareTo_mA6BFE8D9033149D2FEF46526E251A3CDEB1889EB_AdjustorThunk (RuntimeObject * __this, RuntimeObject * ___value0, const RuntimeMethod* method)
{
uint32_t* _thisAdjusted = reinterpret_cast<uint32_t*>(__this + 1);
return UInt32_CompareTo_mA6BFE8D9033149D2FEF46526E251A3CDEB1889EB(_thisAdjusted, ___value0, method);
}
// System.Int32 System.UInt32::CompareTo(System.UInt32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t UInt32_CompareTo_mB4DB0539EACF9C37A2DDDB1439F553E0CD2AA380 (uint32_t* __this, uint32_t ___value0, const RuntimeMethod* method)
{
{
int32_t L_0 = *((uint32_t*)__this);
uint32_t L_1 = ___value0;
if ((!(((uint32_t)L_0) < ((uint32_t)L_1))))
{
goto IL_0007;
}
}
{
return (-1);
}
IL_0007:
{
int32_t L_2 = *((uint32_t*)__this);
uint32_t L_3 = ___value0;
if ((!(((uint32_t)L_2) > ((uint32_t)L_3))))
{
goto IL_000e;
}
}
{
return 1;
}
IL_000e:
{
return 0;
}
}
IL2CPP_EXTERN_C int32_t UInt32_CompareTo_mB4DB0539EACF9C37A2DDDB1439F553E0CD2AA380_AdjustorThunk (RuntimeObject * __this, uint32_t ___value0, const RuntimeMethod* method)
{
uint32_t* _thisAdjusted = reinterpret_cast<uint32_t*>(__this + 1);
return UInt32_CompareTo_mB4DB0539EACF9C37A2DDDB1439F553E0CD2AA380(_thisAdjusted, ___value0, method);
}
// System.Boolean System.UInt32::Equals(System.Object)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool UInt32_Equals_m44E796DB35F5DB4E5D4C98EC6AB5053242A320C3 (uint32_t* __this, RuntimeObject * ___obj0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (UInt32_Equals_m44E796DB35F5DB4E5D4C98EC6AB5053242A320C3_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
RuntimeObject * L_0 = ___obj0;
if (((RuntimeObject *)IsInstSealed((RuntimeObject*)L_0, UInt32_t4980FA09003AFAAB5A6E361BA2748EA9A005709B_il2cpp_TypeInfo_var)))
{
goto IL_000a;
}
}
{
return (bool)0;
}
IL_000a:
{
int32_t L_1 = *((uint32_t*)__this);
RuntimeObject * L_2 = ___obj0;
return (bool)((((int32_t)L_1) == ((int32_t)((*(uint32_t*)((uint32_t*)UnBox(L_2, UInt32_t4980FA09003AFAAB5A6E361BA2748EA9A005709B_il2cpp_TypeInfo_var))))))? 1 : 0);
}
}
IL2CPP_EXTERN_C bool UInt32_Equals_m44E796DB35F5DB4E5D4C98EC6AB5053242A320C3_AdjustorThunk (RuntimeObject * __this, RuntimeObject * ___obj0, const RuntimeMethod* method)
{
uint32_t* _thisAdjusted = reinterpret_cast<uint32_t*>(__this + 1);
return UInt32_Equals_m44E796DB35F5DB4E5D4C98EC6AB5053242A320C3(_thisAdjusted, ___obj0, method);
}
// System.Boolean System.UInt32::Equals(System.UInt32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool UInt32_Equals_m14536B6BD41067948C7ED484437DF75E3414F0D1 (uint32_t* __this, uint32_t ___obj0, const RuntimeMethod* method)
{
{
int32_t L_0 = *((uint32_t*)__this);
uint32_t L_1 = ___obj0;
return (bool)((((int32_t)L_0) == ((int32_t)L_1))? 1 : 0);
}
}
IL2CPP_EXTERN_C bool UInt32_Equals_m14536B6BD41067948C7ED484437DF75E3414F0D1_AdjustorThunk (RuntimeObject * __this, uint32_t ___obj0, const RuntimeMethod* method)
{
uint32_t* _thisAdjusted = reinterpret_cast<uint32_t*>(__this + 1);
return UInt32_Equals_m14536B6BD41067948C7ED484437DF75E3414F0D1(_thisAdjusted, ___obj0, method);
}
// System.Int32 System.UInt32::GetHashCode()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t UInt32_GetHashCode_m791E3E038DAA8DC313758009B1C532CD91194B0D (uint32_t* __this, const RuntimeMethod* method)
{
{
int32_t L_0 = *((uint32_t*)__this);
return L_0;
}
}
IL2CPP_EXTERN_C int32_t UInt32_GetHashCode_m791E3E038DAA8DC313758009B1C532CD91194B0D_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
uint32_t* _thisAdjusted = reinterpret_cast<uint32_t*>(__this + 1);
return UInt32_GetHashCode_m791E3E038DAA8DC313758009B1C532CD91194B0D(_thisAdjusted, method);
}
// System.String System.UInt32::ToString()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR String_t* UInt32_ToString_m7D8A934AF1D74C5C8194D1556AA71BBA0D4600F2 (uint32_t* __this, const RuntimeMethod* method)
{
{
int32_t L_0 = *((uint32_t*)__this);
NumberFormatInfo_tFDF57037EBC5BC833D0A53EF0327B805994860A8 * L_1 = NumberFormatInfo_get_CurrentInfo_m595DF03E32E0C5B01F1EC45F7264B2BD09BA61C9(/*hidden argument*/NULL);
String_t* L_2 = Number_FormatUInt32_m585E2571063A256E46836A51BC4A54CFF151BDEE(L_0, (String_t*)NULL, L_1, /*hidden argument*/NULL);
return L_2;
}
}
IL2CPP_EXTERN_C String_t* UInt32_ToString_m7D8A934AF1D74C5C8194D1556AA71BBA0D4600F2_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
uint32_t* _thisAdjusted = reinterpret_cast<uint32_t*>(__this + 1);
return UInt32_ToString_m7D8A934AF1D74C5C8194D1556AA71BBA0D4600F2(_thisAdjusted, method);
}
// System.String System.UInt32::ToString(System.IFormatProvider)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR String_t* UInt32_ToString_mC81601CD79044D74065228749C2CA9B629CFA3EA (uint32_t* __this, RuntimeObject* ___provider0, const RuntimeMethod* method)
{
{
int32_t L_0 = *((uint32_t*)__this);
RuntimeObject* L_1 = ___provider0;
NumberFormatInfo_tFDF57037EBC5BC833D0A53EF0327B805994860A8 * L_2 = NumberFormatInfo_GetInstance_m713D298B436F3765F059FEA6C446F0A6ABF0A89A(L_1, /*hidden argument*/NULL);
String_t* L_3 = Number_FormatUInt32_m585E2571063A256E46836A51BC4A54CFF151BDEE(L_0, (String_t*)NULL, L_2, /*hidden argument*/NULL);
return L_3;
}
}
IL2CPP_EXTERN_C String_t* UInt32_ToString_mC81601CD79044D74065228749C2CA9B629CFA3EA_AdjustorThunk (RuntimeObject * __this, RuntimeObject* ___provider0, const RuntimeMethod* method)
{
uint32_t* _thisAdjusted = reinterpret_cast<uint32_t*>(__this + 1);
return UInt32_ToString_mC81601CD79044D74065228749C2CA9B629CFA3EA(_thisAdjusted, ___provider0, method);
}
// System.String System.UInt32::ToString(System.String,System.IFormatProvider)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR String_t* UInt32_ToString_m57BE7A0F4A653986FEAC4794CD13B04CE012F4EE (uint32_t* __this, String_t* ___format0, RuntimeObject* ___provider1, const RuntimeMethod* method)
{
{
int32_t L_0 = *((uint32_t*)__this);
String_t* L_1 = ___format0;
RuntimeObject* L_2 = ___provider1;
NumberFormatInfo_tFDF57037EBC5BC833D0A53EF0327B805994860A8 * L_3 = NumberFormatInfo_GetInstance_m713D298B436F3765F059FEA6C446F0A6ABF0A89A(L_2, /*hidden argument*/NULL);
String_t* L_4 = Number_FormatUInt32_m585E2571063A256E46836A51BC4A54CFF151BDEE(L_0, L_1, L_3, /*hidden argument*/NULL);
return L_4;
}
}
IL2CPP_EXTERN_C String_t* UInt32_ToString_m57BE7A0F4A653986FEAC4794CD13B04CE012F4EE_AdjustorThunk (RuntimeObject * __this, String_t* ___format0, RuntimeObject* ___provider1, const RuntimeMethod* method)
{
uint32_t* _thisAdjusted = reinterpret_cast<uint32_t*>(__this + 1);
return UInt32_ToString_m57BE7A0F4A653986FEAC4794CD13B04CE012F4EE(_thisAdjusted, ___format0, ___provider1, method);
}
// System.UInt32 System.UInt32::Parse(System.String,System.IFormatProvider)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR uint32_t UInt32_Parse_mE1049C2D5FDBBA83337898D8608580C6E1CCFEE1 (String_t* ___s0, RuntimeObject* ___provider1, const RuntimeMethod* method)
{
{
String_t* L_0 = ___s0;
RuntimeObject* L_1 = ___provider1;
NumberFormatInfo_tFDF57037EBC5BC833D0A53EF0327B805994860A8 * L_2 = NumberFormatInfo_GetInstance_m713D298B436F3765F059FEA6C446F0A6ABF0A89A(L_1, /*hidden argument*/NULL);
uint32_t L_3 = Number_ParseUInt32_mF280A62925FED84E23D64DC6B86BC50AD96896FB(L_0, 7, L_2, /*hidden argument*/NULL);
return L_3;
}
}
// System.UInt32 System.UInt32::Parse(System.String,System.Globalization.NumberStyles,System.IFormatProvider)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR uint32_t UInt32_Parse_mEEC266AE3E2BA9F49F4CD5E69EBDA3A1B008E125 (String_t* ___s0, int32_t ___style1, RuntimeObject* ___provider2, const RuntimeMethod* method)
{
{
int32_t L_0 = ___style1;
NumberFormatInfo_ValidateParseStyleInteger_m5BD1C04C26D5589F0DFA5953294B72E1DDC2B7E3(L_0, /*hidden argument*/NULL);
String_t* L_1 = ___s0;
int32_t L_2 = ___style1;
RuntimeObject* L_3 = ___provider2;
NumberFormatInfo_tFDF57037EBC5BC833D0A53EF0327B805994860A8 * L_4 = NumberFormatInfo_GetInstance_m713D298B436F3765F059FEA6C446F0A6ABF0A89A(L_3, /*hidden argument*/NULL);
uint32_t L_5 = Number_ParseUInt32_mF280A62925FED84E23D64DC6B86BC50AD96896FB(L_1, L_2, L_4, /*hidden argument*/NULL);
return L_5;
}
}
// System.Boolean System.UInt32::TryParse(System.String,System.Globalization.NumberStyles,System.IFormatProvider,System.UInt32U26)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool UInt32_TryParse_mF53E581D2BF1451EC324BC2F601B6AEB0E2F9235 (String_t* ___s0, int32_t ___style1, RuntimeObject* ___provider2, uint32_t* ___result3, const RuntimeMethod* method)
{
{
int32_t L_0 = ___style1;
NumberFormatInfo_ValidateParseStyleInteger_m5BD1C04C26D5589F0DFA5953294B72E1DDC2B7E3(L_0, /*hidden argument*/NULL);
String_t* L_1 = ___s0;
int32_t L_2 = ___style1;
RuntimeObject* L_3 = ___provider2;
NumberFormatInfo_tFDF57037EBC5BC833D0A53EF0327B805994860A8 * L_4 = NumberFormatInfo_GetInstance_m713D298B436F3765F059FEA6C446F0A6ABF0A89A(L_3, /*hidden argument*/NULL);
uint32_t* L_5 = ___result3;
bool L_6 = Number_TryParseUInt32_m5D5F513C1F31174E132E2646CC964C32E55F9436(L_1, L_2, L_4, (uint32_t*)L_5, /*hidden argument*/NULL);
return L_6;
}
}
// System.TypeCode System.UInt32::GetTypeCode()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t UInt32_GetTypeCode_mA0E730CD3883A383AC3E4BA4FD639811906BDD90 (uint32_t* __this, const RuntimeMethod* method)
{
{
return (int32_t)(((int32_t)10));
}
}
IL2CPP_EXTERN_C int32_t UInt32_GetTypeCode_mA0E730CD3883A383AC3E4BA4FD639811906BDD90_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
uint32_t* _thisAdjusted = reinterpret_cast<uint32_t*>(__this + 1);
return UInt32_GetTypeCode_mA0E730CD3883A383AC3E4BA4FD639811906BDD90(_thisAdjusted, method);
}
// System.Boolean System.UInt32::System.IConvertible.ToBoolean(System.IFormatProvider)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool UInt32_System_IConvertible_ToBoolean_mFC8A4EC8666918A944AED690BAA21AD7B6132A7E (uint32_t* __this, RuntimeObject* ___provider0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (UInt32_System_IConvertible_ToBoolean_mFC8A4EC8666918A944AED690BAA21AD7B6132A7E_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
int32_t L_0 = *((uint32_t*)__this);
IL2CPP_RUNTIME_CLASS_INIT(Convert_t1C7A851BFB2F0782FD7F72F6AA1DCBB7B53A9C7E_il2cpp_TypeInfo_var);
bool L_1 = Convert_ToBoolean_m26CFF98BC762FA7371C580FB19013250FD567F46(L_0, /*hidden argument*/NULL);
return L_1;
}
}
IL2CPP_EXTERN_C bool UInt32_System_IConvertible_ToBoolean_mFC8A4EC8666918A944AED690BAA21AD7B6132A7E_AdjustorThunk (RuntimeObject * __this, RuntimeObject* ___provider0, const RuntimeMethod* method)
{
uint32_t* _thisAdjusted = reinterpret_cast<uint32_t*>(__this + 1);
return UInt32_System_IConvertible_ToBoolean_mFC8A4EC8666918A944AED690BAA21AD7B6132A7E(_thisAdjusted, ___provider0, method);
}
// System.Char System.UInt32::System.IConvertible.ToChar(System.IFormatProvider)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Il2CppChar UInt32_System_IConvertible_ToChar_mC0A386C36A0EBC656E6F887A1CCD5DBBFF078030 (uint32_t* __this, RuntimeObject* ___provider0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (UInt32_System_IConvertible_ToChar_mC0A386C36A0EBC656E6F887A1CCD5DBBFF078030_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
int32_t L_0 = *((uint32_t*)__this);
IL2CPP_RUNTIME_CLASS_INIT(Convert_t1C7A851BFB2F0782FD7F72F6AA1DCBB7B53A9C7E_il2cpp_TypeInfo_var);
Il2CppChar L_1 = Convert_ToChar_m56A1099464A288FD3AB6F82B7433DB063F671B29(L_0, /*hidden argument*/NULL);
return L_1;
}
}
IL2CPP_EXTERN_C Il2CppChar UInt32_System_IConvertible_ToChar_mC0A386C36A0EBC656E6F887A1CCD5DBBFF078030_AdjustorThunk (RuntimeObject * __this, RuntimeObject* ___provider0, const RuntimeMethod* method)
{
uint32_t* _thisAdjusted = reinterpret_cast<uint32_t*>(__this + 1);
return UInt32_System_IConvertible_ToChar_mC0A386C36A0EBC656E6F887A1CCD5DBBFF078030(_thisAdjusted, ___provider0, method);
}
// System.SByte System.UInt32::System.IConvertible.ToSByte(System.IFormatProvider)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int8_t UInt32_System_IConvertible_ToSByte_mD7E08EC2B52A7612582C3E8C26878BAC0AB80984 (uint32_t* __this, RuntimeObject* ___provider0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (UInt32_System_IConvertible_ToSByte_mD7E08EC2B52A7612582C3E8C26878BAC0AB80984_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
int32_t L_0 = *((uint32_t*)__this);
IL2CPP_RUNTIME_CLASS_INIT(Convert_t1C7A851BFB2F0782FD7F72F6AA1DCBB7B53A9C7E_il2cpp_TypeInfo_var);
int8_t L_1 = Convert_ToSByte_m2BA3408A7B10119B60B923928EFCFA17D3C46D50(L_0, /*hidden argument*/NULL);
return L_1;
}
}
IL2CPP_EXTERN_C int8_t UInt32_System_IConvertible_ToSByte_mD7E08EC2B52A7612582C3E8C26878BAC0AB80984_AdjustorThunk (RuntimeObject * __this, RuntimeObject* ___provider0, const RuntimeMethod* method)
{
uint32_t* _thisAdjusted = reinterpret_cast<uint32_t*>(__this + 1);
return UInt32_System_IConvertible_ToSByte_mD7E08EC2B52A7612582C3E8C26878BAC0AB80984(_thisAdjusted, ___provider0, method);
}
// System.Byte System.UInt32::System.IConvertible.ToByte(System.IFormatProvider)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR uint8_t UInt32_System_IConvertible_ToByte_m9386861ED644D7B5E76BD0D7FB86DEEB0173A0A5 (uint32_t* __this, RuntimeObject* ___provider0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (UInt32_System_IConvertible_ToByte_m9386861ED644D7B5E76BD0D7FB86DEEB0173A0A5_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
int32_t L_0 = *((uint32_t*)__this);
IL2CPP_RUNTIME_CLASS_INIT(Convert_t1C7A851BFB2F0782FD7F72F6AA1DCBB7B53A9C7E_il2cpp_TypeInfo_var);
uint8_t L_1 = Convert_ToByte_m5B2E3D791EE1E14A7604D126C24AA62FE2587B60(L_0, /*hidden argument*/NULL);
return L_1;
}
}
IL2CPP_EXTERN_C uint8_t UInt32_System_IConvertible_ToByte_m9386861ED644D7B5E76BD0D7FB86DEEB0173A0A5_AdjustorThunk (RuntimeObject * __this, RuntimeObject* ___provider0, const RuntimeMethod* method)
{
uint32_t* _thisAdjusted = reinterpret_cast<uint32_t*>(__this + 1);
return UInt32_System_IConvertible_ToByte_m9386861ED644D7B5E76BD0D7FB86DEEB0173A0A5(_thisAdjusted, ___provider0, method);
}
// System.Int16 System.UInt32::System.IConvertible.ToInt16(System.IFormatProvider)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int16_t UInt32_System_IConvertible_ToInt16_mC8FA3B04E544531449665298BE73AB2F486AE393 (uint32_t* __this, RuntimeObject* ___provider0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (UInt32_System_IConvertible_ToInt16_mC8FA3B04E544531449665298BE73AB2F486AE393_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
int32_t L_0 = *((uint32_t*)__this);
IL2CPP_RUNTIME_CLASS_INIT(Convert_t1C7A851BFB2F0782FD7F72F6AA1DCBB7B53A9C7E_il2cpp_TypeInfo_var);
int16_t L_1 = Convert_ToInt16_mE8E094D5AD321E5E6756E332116FAF1C084A1CD2(L_0, /*hidden argument*/NULL);
return L_1;
}
}
IL2CPP_EXTERN_C int16_t UInt32_System_IConvertible_ToInt16_mC8FA3B04E544531449665298BE73AB2F486AE393_AdjustorThunk (RuntimeObject * __this, RuntimeObject* ___provider0, const RuntimeMethod* method)
{
uint32_t* _thisAdjusted = reinterpret_cast<uint32_t*>(__this + 1);
return UInt32_System_IConvertible_ToInt16_mC8FA3B04E544531449665298BE73AB2F486AE393(_thisAdjusted, ___provider0, method);
}
// System.UInt16 System.UInt32::System.IConvertible.ToUInt16(System.IFormatProvider)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR uint16_t UInt32_System_IConvertible_ToUInt16_mBEE9936EF6F5D9D150E507F28CDA17A8C1C92E1C (uint32_t* __this, RuntimeObject* ___provider0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (UInt32_System_IConvertible_ToUInt16_mBEE9936EF6F5D9D150E507F28CDA17A8C1C92E1C_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
int32_t L_0 = *((uint32_t*)__this);
IL2CPP_RUNTIME_CLASS_INIT(Convert_t1C7A851BFB2F0782FD7F72F6AA1DCBB7B53A9C7E_il2cpp_TypeInfo_var);
uint16_t L_1 = Convert_ToUInt16_m19D8F9B74EB5F96C835FA5045E925F000750A8B3(L_0, /*hidden argument*/NULL);
return L_1;
}
}
IL2CPP_EXTERN_C uint16_t UInt32_System_IConvertible_ToUInt16_mBEE9936EF6F5D9D150E507F28CDA17A8C1C92E1C_AdjustorThunk (RuntimeObject * __this, RuntimeObject* ___provider0, const RuntimeMethod* method)
{
uint32_t* _thisAdjusted = reinterpret_cast<uint32_t*>(__this + 1);
return UInt32_System_IConvertible_ToUInt16_mBEE9936EF6F5D9D150E507F28CDA17A8C1C92E1C(_thisAdjusted, ___provider0, method);
}
// System.Int32 System.UInt32::System.IConvertible.ToInt32(System.IFormatProvider)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t UInt32_System_IConvertible_ToInt32_mB0FCB9A9ACF700AAD49333618A4B819E24F0F0B9 (uint32_t* __this, RuntimeObject* ___provider0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (UInt32_System_IConvertible_ToInt32_mB0FCB9A9ACF700AAD49333618A4B819E24F0F0B9_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
int32_t L_0 = *((uint32_t*)__this);
IL2CPP_RUNTIME_CLASS_INIT(Convert_t1C7A851BFB2F0782FD7F72F6AA1DCBB7B53A9C7E_il2cpp_TypeInfo_var);
int32_t L_1 = Convert_ToInt32_m966337716B0CC4A45307D82BC21BCA1F8BB22D1C(L_0, /*hidden argument*/NULL);
return L_1;
}
}
IL2CPP_EXTERN_C int32_t UInt32_System_IConvertible_ToInt32_mB0FCB9A9ACF700AAD49333618A4B819E24F0F0B9_AdjustorThunk (RuntimeObject * __this, RuntimeObject* ___provider0, const RuntimeMethod* method)
{
uint32_t* _thisAdjusted = reinterpret_cast<uint32_t*>(__this + 1);
return UInt32_System_IConvertible_ToInt32_mB0FCB9A9ACF700AAD49333618A4B819E24F0F0B9(_thisAdjusted, ___provider0, method);
}
// System.UInt32 System.UInt32::System.IConvertible.ToUInt32(System.IFormatProvider)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR uint32_t UInt32_System_IConvertible_ToUInt32_m7F98AF966A31B1A315E7DFFEE3F2A68D48E690AF (uint32_t* __this, RuntimeObject* ___provider0, const RuntimeMethod* method)
{
{
int32_t L_0 = *((uint32_t*)__this);
return L_0;
}
}
IL2CPP_EXTERN_C uint32_t UInt32_System_IConvertible_ToUInt32_m7F98AF966A31B1A315E7DFFEE3F2A68D48E690AF_AdjustorThunk (RuntimeObject * __this, RuntimeObject* ___provider0, const RuntimeMethod* method)
{
uint32_t* _thisAdjusted = reinterpret_cast<uint32_t*>(__this + 1);
return UInt32_System_IConvertible_ToUInt32_m7F98AF966A31B1A315E7DFFEE3F2A68D48E690AF(_thisAdjusted, ___provider0, method);
}
// System.Int64 System.UInt32::System.IConvertible.ToInt64(System.IFormatProvider)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int64_t UInt32_System_IConvertible_ToInt64_m6E1441BF4C3D5FDFCAEEED65CFE96E6D9F08007B (uint32_t* __this, RuntimeObject* ___provider0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (UInt32_System_IConvertible_ToInt64_m6E1441BF4C3D5FDFCAEEED65CFE96E6D9F08007B_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
int32_t L_0 = *((uint32_t*)__this);
IL2CPP_RUNTIME_CLASS_INIT(Convert_t1C7A851BFB2F0782FD7F72F6AA1DCBB7B53A9C7E_il2cpp_TypeInfo_var);
int64_t L_1 = Convert_ToInt64_m32144C3A1499C6810428CC3F22BCB095EFFEE99F(L_0, /*hidden argument*/NULL);
return L_1;
}
}
IL2CPP_EXTERN_C int64_t UInt32_System_IConvertible_ToInt64_m6E1441BF4C3D5FDFCAEEED65CFE96E6D9F08007B_AdjustorThunk (RuntimeObject * __this, RuntimeObject* ___provider0, const RuntimeMethod* method)
{
uint32_t* _thisAdjusted = reinterpret_cast<uint32_t*>(__this + 1);
return UInt32_System_IConvertible_ToInt64_m6E1441BF4C3D5FDFCAEEED65CFE96E6D9F08007B(_thisAdjusted, ___provider0, method);
}
// System.UInt64 System.UInt32::System.IConvertible.ToUInt64(System.IFormatProvider)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR uint64_t UInt32_System_IConvertible_ToUInt64_m659A2E594AAC8E26152B3EAAF1D80CECD2F43120 (uint32_t* __this, RuntimeObject* ___provider0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (UInt32_System_IConvertible_ToUInt64_m659A2E594AAC8E26152B3EAAF1D80CECD2F43120_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
int32_t L_0 = *((uint32_t*)__this);
IL2CPP_RUNTIME_CLASS_INIT(Convert_t1C7A851BFB2F0782FD7F72F6AA1DCBB7B53A9C7E_il2cpp_TypeInfo_var);
uint64_t L_1 = Convert_ToUInt64_mC8F7AEA2A46B8BEB45B65312F49EEE2540B596EC(L_0, /*hidden argument*/NULL);
return L_1;
}
}
IL2CPP_EXTERN_C uint64_t UInt32_System_IConvertible_ToUInt64_m659A2E594AAC8E26152B3EAAF1D80CECD2F43120_AdjustorThunk (RuntimeObject * __this, RuntimeObject* ___provider0, const RuntimeMethod* method)
{
uint32_t* _thisAdjusted = reinterpret_cast<uint32_t*>(__this + 1);
return UInt32_System_IConvertible_ToUInt64_m659A2E594AAC8E26152B3EAAF1D80CECD2F43120(_thisAdjusted, ___provider0, method);
}
// System.Single System.UInt32::System.IConvertible.ToSingle(System.IFormatProvider)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR float UInt32_System_IConvertible_ToSingle_m2B438F2707D2FB9C8FDC6D79B263677FA3C37096 (uint32_t* __this, RuntimeObject* ___provider0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (UInt32_System_IConvertible_ToSingle_m2B438F2707D2FB9C8FDC6D79B263677FA3C37096_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
int32_t L_0 = *((uint32_t*)__this);
IL2CPP_RUNTIME_CLASS_INIT(Convert_t1C7A851BFB2F0782FD7F72F6AA1DCBB7B53A9C7E_il2cpp_TypeInfo_var);
float L_1 = Convert_ToSingle_m6F50A25E0020F35AEC587BE3A91E1A6D78351249(L_0, /*hidden argument*/NULL);
return L_1;
}
}
IL2CPP_EXTERN_C float UInt32_System_IConvertible_ToSingle_m2B438F2707D2FB9C8FDC6D79B263677FA3C37096_AdjustorThunk (RuntimeObject * __this, RuntimeObject* ___provider0, const RuntimeMethod* method)
{
uint32_t* _thisAdjusted = reinterpret_cast<uint32_t*>(__this + 1);
return UInt32_System_IConvertible_ToSingle_m2B438F2707D2FB9C8FDC6D79B263677FA3C37096(_thisAdjusted, ___provider0, method);
}
// System.Double System.UInt32::System.IConvertible.ToDouble(System.IFormatProvider)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR double UInt32_System_IConvertible_ToDouble_m4A3EDEA2044FAA202D4ED3C81672CF0308FAE7E8 (uint32_t* __this, RuntimeObject* ___provider0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (UInt32_System_IConvertible_ToDouble_m4A3EDEA2044FAA202D4ED3C81672CF0308FAE7E8_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
int32_t L_0 = *((uint32_t*)__this);
IL2CPP_RUNTIME_CLASS_INIT(Convert_t1C7A851BFB2F0782FD7F72F6AA1DCBB7B53A9C7E_il2cpp_TypeInfo_var);
double L_1 = Convert_ToDouble_mA48AAD04072EF9CD5A30C2B2EC69A796A0BA6194(L_0, /*hidden argument*/NULL);
return L_1;
}
}
IL2CPP_EXTERN_C double UInt32_System_IConvertible_ToDouble_m4A3EDEA2044FAA202D4ED3C81672CF0308FAE7E8_AdjustorThunk (RuntimeObject * __this, RuntimeObject* ___provider0, const RuntimeMethod* method)
{
uint32_t* _thisAdjusted = reinterpret_cast<uint32_t*>(__this + 1);
return UInt32_System_IConvertible_ToDouble_m4A3EDEA2044FAA202D4ED3C81672CF0308FAE7E8(_thisAdjusted, ___provider0, method);
}
// System.Decimal System.UInt32::System.IConvertible.ToDecimal(System.IFormatProvider)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Decimal_t44EE9DA309A1BF848308DE4DDFC070CAE6D95EE8 UInt32_System_IConvertible_ToDecimal_m1C78EB4A4D9A092C050487129E0AE477ADBBE5A7 (uint32_t* __this, RuntimeObject* ___provider0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (UInt32_System_IConvertible_ToDecimal_m1C78EB4A4D9A092C050487129E0AE477ADBBE5A7_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
int32_t L_0 = *((uint32_t*)__this);
IL2CPP_RUNTIME_CLASS_INIT(Convert_t1C7A851BFB2F0782FD7F72F6AA1DCBB7B53A9C7E_il2cpp_TypeInfo_var);
Decimal_t44EE9DA309A1BF848308DE4DDFC070CAE6D95EE8 L_1 = Convert_ToDecimal_m291E4FE569EB911F06EF4269522C1DA0BEB7CB5F(L_0, /*hidden argument*/NULL);
return L_1;
}
}
IL2CPP_EXTERN_C Decimal_t44EE9DA309A1BF848308DE4DDFC070CAE6D95EE8 UInt32_System_IConvertible_ToDecimal_m1C78EB4A4D9A092C050487129E0AE477ADBBE5A7_AdjustorThunk (RuntimeObject * __this, RuntimeObject* ___provider0, const RuntimeMethod* method)
{
uint32_t* _thisAdjusted = reinterpret_cast<uint32_t*>(__this + 1);
return UInt32_System_IConvertible_ToDecimal_m1C78EB4A4D9A092C050487129E0AE477ADBBE5A7(_thisAdjusted, ___provider0, method);
}
// System.DateTime System.UInt32::System.IConvertible.ToDateTime(System.IFormatProvider)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR DateTime_t349B7449FBAAFF4192636E2B7A07694DA9236132 UInt32_System_IConvertible_ToDateTime_m450F7E1864FB6A396E9009116F8301B972DAE724 (uint32_t* __this, RuntimeObject* ___provider0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (UInt32_System_IConvertible_ToDateTime_m450F7E1864FB6A396E9009116F8301B972DAE724_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
ObjectU5BU5D_t3C9242B5C88A48B2A5BD9FDA6CD0024E792AF08A* L_0 = (ObjectU5BU5D_t3C9242B5C88A48B2A5BD9FDA6CD0024E792AF08A*)(ObjectU5BU5D_t3C9242B5C88A48B2A5BD9FDA6CD0024E792AF08A*)SZArrayNew(ObjectU5BU5D_t3C9242B5C88A48B2A5BD9FDA6CD0024E792AF08A_il2cpp_TypeInfo_var, (uint32_t)2);
ObjectU5BU5D_t3C9242B5C88A48B2A5BD9FDA6CD0024E792AF08A* L_1 = L_0;
NullCheck(L_1);
ArrayElementTypeCheck (L_1, _stringLiteralE71E7BC3FE9E9F3C39E46B53FFFF0C83D9CC9A36);
(L_1)->SetAt(static_cast<il2cpp_array_size_t>(0), (RuntimeObject *)_stringLiteralE71E7BC3FE9E9F3C39E46B53FFFF0C83D9CC9A36);
ObjectU5BU5D_t3C9242B5C88A48B2A5BD9FDA6CD0024E792AF08A* L_2 = L_1;
NullCheck(L_2);
ArrayElementTypeCheck (L_2, _stringLiteralF1E5BAF5ECC3589631088C40CBDD43061976ED8F);
(L_2)->SetAt(static_cast<il2cpp_array_size_t>(1), (RuntimeObject *)_stringLiteralF1E5BAF5ECC3589631088C40CBDD43061976ED8F);
String_t* L_3 = Environment_GetResourceString_m7389941B4C0688D875CC647D99A739DA2F907ADB(_stringLiteralE5559C91F3F57F398B8B547CA356C67FFA1F6497, L_2, /*hidden argument*/NULL);
InvalidCastException_t91DF9E7D7FCCDA6C562CB4A9A18903E016680FDA * L_4 = (InvalidCastException_t91DF9E7D7FCCDA6C562CB4A9A18903E016680FDA *)il2cpp_codegen_object_new(InvalidCastException_t91DF9E7D7FCCDA6C562CB4A9A18903E016680FDA_il2cpp_TypeInfo_var);
InvalidCastException__ctor_m3795145150387C6C362DA693613505C604AB8812(L_4, L_3, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_4, NULL, UInt32_System_IConvertible_ToDateTime_m450F7E1864FB6A396E9009116F8301B972DAE724_RuntimeMethod_var);
}
}
IL2CPP_EXTERN_C DateTime_t349B7449FBAAFF4192636E2B7A07694DA9236132 UInt32_System_IConvertible_ToDateTime_m450F7E1864FB6A396E9009116F8301B972DAE724_AdjustorThunk (RuntimeObject * __this, RuntimeObject* ___provider0, const RuntimeMethod* method)
{
uint32_t* _thisAdjusted = reinterpret_cast<uint32_t*>(__this + 1);
return UInt32_System_IConvertible_ToDateTime_m450F7E1864FB6A396E9009116F8301B972DAE724(_thisAdjusted, ___provider0, method);
}
// System.Object System.UInt32::System.IConvertible.ToType(System.Type,System.IFormatProvider)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * UInt32_System_IConvertible_ToType_mEFD4D7AB69CB399E6603ADA3EDDF10FC622E4A3A (uint32_t* __this, Type_t * ___type0, RuntimeObject* ___provider1, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (UInt32_System_IConvertible_ToType_mEFD4D7AB69CB399E6603ADA3EDDF10FC622E4A3A_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
int32_t L_0 = *((uint32_t*)__this);
uint32_t L_1 = ((uint32_t)L_0);
RuntimeObject * L_2 = Box(UInt32_t4980FA09003AFAAB5A6E361BA2748EA9A005709B_il2cpp_TypeInfo_var, &L_1);
Type_t * L_3 = ___type0;
RuntimeObject* L_4 = ___provider1;
IL2CPP_RUNTIME_CLASS_INIT(Convert_t1C7A851BFB2F0782FD7F72F6AA1DCBB7B53A9C7E_il2cpp_TypeInfo_var);
RuntimeObject * L_5 = Convert_DefaultToType_m899D5F6B9FE3E8B878BC56172C6BFE788B6C1BE3((RuntimeObject*)L_2, L_3, L_4, /*hidden argument*/NULL);
return L_5;
}
}
IL2CPP_EXTERN_C RuntimeObject * UInt32_System_IConvertible_ToType_mEFD4D7AB69CB399E6603ADA3EDDF10FC622E4A3A_AdjustorThunk (RuntimeObject * __this, Type_t * ___type0, RuntimeObject* ___provider1, const RuntimeMethod* method)
{
uint32_t* _thisAdjusted = reinterpret_cast<uint32_t*>(__this + 1);
return UInt32_System_IConvertible_ToType_mEFD4D7AB69CB399E6603ADA3EDDF10FC622E4A3A(_thisAdjusted, ___type0, ___provider1, method);
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Int32 System.UInt64::CompareTo(System.Object)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t UInt64_CompareTo_mB5A28DD05266BC32BD6FD24A6659B0464FFA8950 (uint64_t* __this, RuntimeObject * ___value0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (UInt64_CompareTo_mB5A28DD05266BC32BD6FD24A6659B0464FFA8950_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
uint64_t V_0 = 0;
{
RuntimeObject * L_0 = ___value0;
if (L_0)
{
goto IL_0005;
}
}
{
return 1;
}
IL_0005:
{
RuntimeObject * L_1 = ___value0;
if (!((RuntimeObject *)IsInstSealed((RuntimeObject*)L_1, UInt64_tA02DF3B59C8FC4A849BD207DA11038CC64E4CB4E_il2cpp_TypeInfo_var)))
{
goto IL_0024;
}
}
{
RuntimeObject * L_2 = ___value0;
V_0 = ((*(uint64_t*)((uint64_t*)UnBox(L_2, UInt64_tA02DF3B59C8FC4A849BD207DA11038CC64E4CB4E_il2cpp_TypeInfo_var))));
int64_t L_3 = *((int64_t*)__this);
uint64_t L_4 = V_0;
if ((!(((uint64_t)L_3) < ((uint64_t)L_4))))
{
goto IL_001b;
}
}
{
return (-1);
}
IL_001b:
{
int64_t L_5 = *((int64_t*)__this);
uint64_t L_6 = V_0;
if ((!(((uint64_t)L_5) > ((uint64_t)L_6))))
{
goto IL_0022;
}
}
{
return 1;
}
IL_0022:
{
return 0;
}
IL_0024:
{
String_t* L_7 = Environment_GetResourceString_m2C75C2AF268F01E2BF34AD1C2E1352CF4BA51AD9(_stringLiteral673CD30ADECC250EA8B762ED51852F93E288BB89, /*hidden argument*/NULL);
ArgumentException_tEDCD16F20A09ECE461C3DA766C16EDA8864057D1 * L_8 = (ArgumentException_tEDCD16F20A09ECE461C3DA766C16EDA8864057D1 *)il2cpp_codegen_object_new(ArgumentException_tEDCD16F20A09ECE461C3DA766C16EDA8864057D1_il2cpp_TypeInfo_var);
ArgumentException__ctor_m9A85EF7FEFEC21DDD525A67E831D77278E5165B7(L_8, L_7, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_8, NULL, UInt64_CompareTo_mB5A28DD05266BC32BD6FD24A6659B0464FFA8950_RuntimeMethod_var);
}
}
IL2CPP_EXTERN_C int32_t UInt64_CompareTo_mB5A28DD05266BC32BD6FD24A6659B0464FFA8950_AdjustorThunk (RuntimeObject * __this, RuntimeObject * ___value0, const RuntimeMethod* method)
{
uint64_t* _thisAdjusted = reinterpret_cast<uint64_t*>(__this + 1);
return UInt64_CompareTo_mB5A28DD05266BC32BD6FD24A6659B0464FFA8950(_thisAdjusted, ___value0, method);
}
// System.Int32 System.UInt64::CompareTo(System.UInt64)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t UInt64_CompareTo_m03A38257A9E54676839E92A530E8BB17D6A58873 (uint64_t* __this, uint64_t ___value0, const RuntimeMethod* method)
{
{
int64_t L_0 = *((int64_t*)__this);
uint64_t L_1 = ___value0;
if ((!(((uint64_t)L_0) < ((uint64_t)L_1))))
{
goto IL_0007;
}
}
{
return (-1);
}
IL_0007:
{
int64_t L_2 = *((int64_t*)__this);
uint64_t L_3 = ___value0;
if ((!(((uint64_t)L_2) > ((uint64_t)L_3))))
{
goto IL_000e;
}
}
{
return 1;
}
IL_000e:
{
return 0;
}
}
IL2CPP_EXTERN_C int32_t UInt64_CompareTo_m03A38257A9E54676839E92A530E8BB17D6A58873_AdjustorThunk (RuntimeObject * __this, uint64_t ___value0, const RuntimeMethod* method)
{
uint64_t* _thisAdjusted = reinterpret_cast<uint64_t*>(__this + 1);
return UInt64_CompareTo_m03A38257A9E54676839E92A530E8BB17D6A58873(_thisAdjusted, ___value0, method);
}
// System.Boolean System.UInt64::Equals(System.Object)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool UInt64_Equals_mE61D24B984F0B91A2FC1094402F1532A0F82C232 (uint64_t* __this, RuntimeObject * ___obj0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (UInt64_Equals_mE61D24B984F0B91A2FC1094402F1532A0F82C232_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
RuntimeObject * L_0 = ___obj0;
if (((RuntimeObject *)IsInstSealed((RuntimeObject*)L_0, UInt64_tA02DF3B59C8FC4A849BD207DA11038CC64E4CB4E_il2cpp_TypeInfo_var)))
{
goto IL_000a;
}
}
{
return (bool)0;
}
IL_000a:
{
int64_t L_1 = *((int64_t*)__this);
RuntimeObject * L_2 = ___obj0;
return (bool)((((int64_t)L_1) == ((int64_t)((*(uint64_t*)((uint64_t*)UnBox(L_2, UInt64_tA02DF3B59C8FC4A849BD207DA11038CC64E4CB4E_il2cpp_TypeInfo_var))))))? 1 : 0);
}
}
IL2CPP_EXTERN_C bool UInt64_Equals_mE61D24B984F0B91A2FC1094402F1532A0F82C232_AdjustorThunk (RuntimeObject * __this, RuntimeObject * ___obj0, const RuntimeMethod* method)
{
uint64_t* _thisAdjusted = reinterpret_cast<uint64_t*>(__this + 1);
return UInt64_Equals_mE61D24B984F0B91A2FC1094402F1532A0F82C232(_thisAdjusted, ___obj0, method);
}
// System.Boolean System.UInt64::Equals(System.UInt64)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool UInt64_Equals_m8C3B2C55776A9086B7F78F6A636F9B15B059F058 (uint64_t* __this, uint64_t ___obj0, const RuntimeMethod* method)
{
{
int64_t L_0 = *((int64_t*)__this);
uint64_t L_1 = ___obj0;
return (bool)((((int64_t)L_0) == ((int64_t)L_1))? 1 : 0);
}
}
IL2CPP_EXTERN_C bool UInt64_Equals_m8C3B2C55776A9086B7F78F6A636F9B15B059F058_AdjustorThunk (RuntimeObject * __this, uint64_t ___obj0, const RuntimeMethod* method)
{
uint64_t* _thisAdjusted = reinterpret_cast<uint64_t*>(__this + 1);
return UInt64_Equals_m8C3B2C55776A9086B7F78F6A636F9B15B059F058(_thisAdjusted, ___obj0, method);
}
// System.Int32 System.UInt64::GetHashCode()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t UInt64_GetHashCode_mCBB4031BF70D0CBD023B4D71F4FEA37BE2C749AD (uint64_t* __this, const RuntimeMethod* method)
{
{
int64_t L_0 = *((int64_t*)__this);
int64_t L_1 = *((int64_t*)__this);
return ((int32_t)((int32_t)(((int32_t)((int32_t)L_0)))^(int32_t)(((int32_t)((int32_t)((int64_t)((uint64_t)L_1>>((int32_t)32))))))));
}
}
IL2CPP_EXTERN_C int32_t UInt64_GetHashCode_mCBB4031BF70D0CBD023B4D71F4FEA37BE2C749AD_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
uint64_t* _thisAdjusted = reinterpret_cast<uint64_t*>(__this + 1);
return UInt64_GetHashCode_mCBB4031BF70D0CBD023B4D71F4FEA37BE2C749AD(_thisAdjusted, method);
}
// System.String System.UInt64::ToString()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR String_t* UInt64_ToString_mF0E40B7459C207B89A1C8C04CE7F183AC0E6D672 (uint64_t* __this, const RuntimeMethod* method)
{
{
int64_t L_0 = *((int64_t*)__this);
NumberFormatInfo_tFDF57037EBC5BC833D0A53EF0327B805994860A8 * L_1 = NumberFormatInfo_get_CurrentInfo_m595DF03E32E0C5B01F1EC45F7264B2BD09BA61C9(/*hidden argument*/NULL);
String_t* L_2 = Number_FormatUInt64_m04004F09D1913C13C59635153D0F45AF37F8248A(L_0, (String_t*)NULL, L_1, /*hidden argument*/NULL);
return L_2;
}
}
IL2CPP_EXTERN_C String_t* UInt64_ToString_mF0E40B7459C207B89A1C8C04CE7F183AC0E6D672_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
uint64_t* _thisAdjusted = reinterpret_cast<uint64_t*>(__this + 1);
return UInt64_ToString_mF0E40B7459C207B89A1C8C04CE7F183AC0E6D672(_thisAdjusted, method);
}
// System.String System.UInt64::ToString(System.IFormatProvider)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR String_t* UInt64_ToString_m6CBBC10ABBA0EE36F5E72F926A38F6CD7F497A55 (uint64_t* __this, RuntimeObject* ___provider0, const RuntimeMethod* method)
{
{
int64_t L_0 = *((int64_t*)__this);
RuntimeObject* L_1 = ___provider0;
NumberFormatInfo_tFDF57037EBC5BC833D0A53EF0327B805994860A8 * L_2 = NumberFormatInfo_GetInstance_m713D298B436F3765F059FEA6C446F0A6ABF0A89A(L_1, /*hidden argument*/NULL);
String_t* L_3 = Number_FormatUInt64_m04004F09D1913C13C59635153D0F45AF37F8248A(L_0, (String_t*)NULL, L_2, /*hidden argument*/NULL);
return L_3;
}
}
IL2CPP_EXTERN_C String_t* UInt64_ToString_m6CBBC10ABBA0EE36F5E72F926A38F6CD7F497A55_AdjustorThunk (RuntimeObject * __this, RuntimeObject* ___provider0, const RuntimeMethod* method)
{
uint64_t* _thisAdjusted = reinterpret_cast<uint64_t*>(__this + 1);
return UInt64_ToString_m6CBBC10ABBA0EE36F5E72F926A38F6CD7F497A55(_thisAdjusted, ___provider0, method);
}
// System.String System.UInt64::ToString(System.String)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR String_t* UInt64_ToString_m46B46DBB5F74DCDC6082A8AC8C695E2295925E71 (uint64_t* __this, String_t* ___format0, const RuntimeMethod* method)
{
{
int64_t L_0 = *((int64_t*)__this);
String_t* L_1 = ___format0;
NumberFormatInfo_tFDF57037EBC5BC833D0A53EF0327B805994860A8 * L_2 = NumberFormatInfo_get_CurrentInfo_m595DF03E32E0C5B01F1EC45F7264B2BD09BA61C9(/*hidden argument*/NULL);
String_t* L_3 = Number_FormatUInt64_m04004F09D1913C13C59635153D0F45AF37F8248A(L_0, L_1, L_2, /*hidden argument*/NULL);
return L_3;
}
}
IL2CPP_EXTERN_C String_t* UInt64_ToString_m46B46DBB5F74DCDC6082A8AC8C695E2295925E71_AdjustorThunk (RuntimeObject * __this, String_t* ___format0, const RuntimeMethod* method)
{
uint64_t* _thisAdjusted = reinterpret_cast<uint64_t*>(__this + 1);
return UInt64_ToString_m46B46DBB5F74DCDC6082A8AC8C695E2295925E71(_thisAdjusted, ___format0, method);
}
// System.String System.UInt64::ToString(System.String,System.IFormatProvider)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR String_t* UInt64_ToString_mF6F94603E535C161BBD87AC747A1F403C274E8CD (uint64_t* __this, String_t* ___format0, RuntimeObject* ___provider1, const RuntimeMethod* method)
{
{
int64_t L_0 = *((int64_t*)__this);
String_t* L_1 = ___format0;
RuntimeObject* L_2 = ___provider1;
NumberFormatInfo_tFDF57037EBC5BC833D0A53EF0327B805994860A8 * L_3 = NumberFormatInfo_GetInstance_m713D298B436F3765F059FEA6C446F0A6ABF0A89A(L_2, /*hidden argument*/NULL);
String_t* L_4 = Number_FormatUInt64_m04004F09D1913C13C59635153D0F45AF37F8248A(L_0, L_1, L_3, /*hidden argument*/NULL);
return L_4;
}
}
IL2CPP_EXTERN_C String_t* UInt64_ToString_mF6F94603E535C161BBD87AC747A1F403C274E8CD_AdjustorThunk (RuntimeObject * __this, String_t* ___format0, RuntimeObject* ___provider1, const RuntimeMethod* method)
{
uint64_t* _thisAdjusted = reinterpret_cast<uint64_t*>(__this + 1);
return UInt64_ToString_mF6F94603E535C161BBD87AC747A1F403C274E8CD(_thisAdjusted, ___format0, ___provider1, method);
}
// System.UInt64 System.UInt64::Parse(System.String,System.IFormatProvider)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR uint64_t UInt64_Parse_m601A733732850A76D2469F084F2F0E718EBFFD14 (String_t* ___s0, RuntimeObject* ___provider1, const RuntimeMethod* method)
{
{
String_t* L_0 = ___s0;
RuntimeObject* L_1 = ___provider1;
NumberFormatInfo_tFDF57037EBC5BC833D0A53EF0327B805994860A8 * L_2 = NumberFormatInfo_GetInstance_m713D298B436F3765F059FEA6C446F0A6ABF0A89A(L_1, /*hidden argument*/NULL);
uint64_t L_3 = Number_ParseUInt64_m80F0E92F3D98C3390741451845F261F93A103E27(L_0, 7, L_2, /*hidden argument*/NULL);
return L_3;
}
}
// System.UInt64 System.UInt64::Parse(System.String,System.Globalization.NumberStyles,System.IFormatProvider)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR uint64_t UInt64_Parse_mBCA93243BACC50D7302706C914152213B8AB85A5 (String_t* ___s0, int32_t ___style1, RuntimeObject* ___provider2, const RuntimeMethod* method)
{
{
int32_t L_0 = ___style1;
NumberFormatInfo_ValidateParseStyleInteger_m5BD1C04C26D5589F0DFA5953294B72E1DDC2B7E3(L_0, /*hidden argument*/NULL);
String_t* L_1 = ___s0;
int32_t L_2 = ___style1;
RuntimeObject* L_3 = ___provider2;
NumberFormatInfo_tFDF57037EBC5BC833D0A53EF0327B805994860A8 * L_4 = NumberFormatInfo_GetInstance_m713D298B436F3765F059FEA6C446F0A6ABF0A89A(L_3, /*hidden argument*/NULL);
uint64_t L_5 = Number_ParseUInt64_m80F0E92F3D98C3390741451845F261F93A103E27(L_1, L_2, L_4, /*hidden argument*/NULL);
return L_5;
}
}
// System.TypeCode System.UInt64::GetTypeCode()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t UInt64_GetTypeCode_m96414C98F5BEB1E6DD540B07EE96558CE9E313F4 (uint64_t* __this, const RuntimeMethod* method)
{
{
return (int32_t)(((int32_t)12));
}
}
IL2CPP_EXTERN_C int32_t UInt64_GetTypeCode_m96414C98F5BEB1E6DD540B07EE96558CE9E313F4_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
uint64_t* _thisAdjusted = reinterpret_cast<uint64_t*>(__this + 1);
return UInt64_GetTypeCode_m96414C98F5BEB1E6DD540B07EE96558CE9E313F4(_thisAdjusted, method);
}
// System.Boolean System.UInt64::System.IConvertible.ToBoolean(System.IFormatProvider)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool UInt64_System_IConvertible_ToBoolean_mCDB7FA8F90588F8FDDF7F0CB26AF43651F9B3884 (uint64_t* __this, RuntimeObject* ___provider0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (UInt64_System_IConvertible_ToBoolean_mCDB7FA8F90588F8FDDF7F0CB26AF43651F9B3884_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
int64_t L_0 = *((int64_t*)__this);
IL2CPP_RUNTIME_CLASS_INIT(Convert_t1C7A851BFB2F0782FD7F72F6AA1DCBB7B53A9C7E_il2cpp_TypeInfo_var);
bool L_1 = Convert_ToBoolean_m545BC5397A9E121A21E4891E2A76A8C2B31D59D2(L_0, /*hidden argument*/NULL);
return L_1;
}
}
IL2CPP_EXTERN_C bool UInt64_System_IConvertible_ToBoolean_mCDB7FA8F90588F8FDDF7F0CB26AF43651F9B3884_AdjustorThunk (RuntimeObject * __this, RuntimeObject* ___provider0, const RuntimeMethod* method)
{
uint64_t* _thisAdjusted = reinterpret_cast<uint64_t*>(__this + 1);
return UInt64_System_IConvertible_ToBoolean_mCDB7FA8F90588F8FDDF7F0CB26AF43651F9B3884(_thisAdjusted, ___provider0, method);
}
// System.Char System.UInt64::System.IConvertible.ToChar(System.IFormatProvider)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Il2CppChar UInt64_System_IConvertible_ToChar_mBB0EEBDF5CB12C5CE93ECD9C39124D33F221A523 (uint64_t* __this, RuntimeObject* ___provider0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (UInt64_System_IConvertible_ToChar_mBB0EEBDF5CB12C5CE93ECD9C39124D33F221A523_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
int64_t L_0 = *((int64_t*)__this);
IL2CPP_RUNTIME_CLASS_INIT(Convert_t1C7A851BFB2F0782FD7F72F6AA1DCBB7B53A9C7E_il2cpp_TypeInfo_var);
Il2CppChar L_1 = Convert_ToChar_mBFD88FBE8D41F3FEB4049B8EF556C2D996F5F531(L_0, /*hidden argument*/NULL);
return L_1;
}
}
IL2CPP_EXTERN_C Il2CppChar UInt64_System_IConvertible_ToChar_mBB0EEBDF5CB12C5CE93ECD9C39124D33F221A523_AdjustorThunk (RuntimeObject * __this, RuntimeObject* ___provider0, const RuntimeMethod* method)
{
uint64_t* _thisAdjusted = reinterpret_cast<uint64_t*>(__this + 1);
return UInt64_System_IConvertible_ToChar_mBB0EEBDF5CB12C5CE93ECD9C39124D33F221A523(_thisAdjusted, ___provider0, method);
}
// System.SByte System.UInt64::System.IConvertible.ToSByte(System.IFormatProvider)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int8_t UInt64_System_IConvertible_ToSByte_m6309BC2235A2F03BAE4107E9CCDF53604B9E7BB7 (uint64_t* __this, RuntimeObject* ___provider0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (UInt64_System_IConvertible_ToSByte_m6309BC2235A2F03BAE4107E9CCDF53604B9E7BB7_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
int64_t L_0 = *((int64_t*)__this);
IL2CPP_RUNTIME_CLASS_INIT(Convert_t1C7A851BFB2F0782FD7F72F6AA1DCBB7B53A9C7E_il2cpp_TypeInfo_var);
int8_t L_1 = Convert_ToSByte_m5F3E822A40FB8BC9DCE9D39C07D0BFDB5CAE38C3(L_0, /*hidden argument*/NULL);
return L_1;
}
}
IL2CPP_EXTERN_C int8_t UInt64_System_IConvertible_ToSByte_m6309BC2235A2F03BAE4107E9CCDF53604B9E7BB7_AdjustorThunk (RuntimeObject * __this, RuntimeObject* ___provider0, const RuntimeMethod* method)
{
uint64_t* _thisAdjusted = reinterpret_cast<uint64_t*>(__this + 1);
return UInt64_System_IConvertible_ToSByte_m6309BC2235A2F03BAE4107E9CCDF53604B9E7BB7(_thisAdjusted, ___provider0, method);
}
// System.Byte System.UInt64::System.IConvertible.ToByte(System.IFormatProvider)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR uint8_t UInt64_System_IConvertible_ToByte_m4F0E7D7E850AA40CE8FEE68B44B5FF29409CCB27 (uint64_t* __this, RuntimeObject* ___provider0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (UInt64_System_IConvertible_ToByte_m4F0E7D7E850AA40CE8FEE68B44B5FF29409CCB27_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
int64_t L_0 = *((int64_t*)__this);
IL2CPP_RUNTIME_CLASS_INIT(Convert_t1C7A851BFB2F0782FD7F72F6AA1DCBB7B53A9C7E_il2cpp_TypeInfo_var);
uint8_t L_1 = Convert_ToByte_mBA74300A0EBF60E75A3ABED4AA4AAB62DF40014A(L_0, /*hidden argument*/NULL);
return L_1;
}
}
IL2CPP_EXTERN_C uint8_t UInt64_System_IConvertible_ToByte_m4F0E7D7E850AA40CE8FEE68B44B5FF29409CCB27_AdjustorThunk (RuntimeObject * __this, RuntimeObject* ___provider0, const RuntimeMethod* method)
{
uint64_t* _thisAdjusted = reinterpret_cast<uint64_t*>(__this + 1);
return UInt64_System_IConvertible_ToByte_m4F0E7D7E850AA40CE8FEE68B44B5FF29409CCB27(_thisAdjusted, ___provider0, method);
}
// System.Int16 System.UInt64::System.IConvertible.ToInt16(System.IFormatProvider)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int16_t UInt64_System_IConvertible_ToInt16_m6D785A19C7E04176E1B60131C70A965ABB427E20 (uint64_t* __this, RuntimeObject* ___provider0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (UInt64_System_IConvertible_ToInt16_m6D785A19C7E04176E1B60131C70A965ABB427E20_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
int64_t L_0 = *((int64_t*)__this);
IL2CPP_RUNTIME_CLASS_INIT(Convert_t1C7A851BFB2F0782FD7F72F6AA1DCBB7B53A9C7E_il2cpp_TypeInfo_var);
int16_t L_1 = Convert_ToInt16_mC121EAEA7C8458D987480F1669C6A40082AA93C1(L_0, /*hidden argument*/NULL);
return L_1;
}
}
IL2CPP_EXTERN_C int16_t UInt64_System_IConvertible_ToInt16_m6D785A19C7E04176E1B60131C70A965ABB427E20_AdjustorThunk (RuntimeObject * __this, RuntimeObject* ___provider0, const RuntimeMethod* method)
{
uint64_t* _thisAdjusted = reinterpret_cast<uint64_t*>(__this + 1);
return UInt64_System_IConvertible_ToInt16_m6D785A19C7E04176E1B60131C70A965ABB427E20(_thisAdjusted, ___provider0, method);
}
// System.UInt16 System.UInt64::System.IConvertible.ToUInt16(System.IFormatProvider)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR uint16_t UInt64_System_IConvertible_ToUInt16_m6B443639CDAEEDBE636A47EF6D07B045B51C2A51 (uint64_t* __this, RuntimeObject* ___provider0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (UInt64_System_IConvertible_ToUInt16_m6B443639CDAEEDBE636A47EF6D07B045B51C2A51_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
int64_t L_0 = *((int64_t*)__this);
IL2CPP_RUNTIME_CLASS_INIT(Convert_t1C7A851BFB2F0782FD7F72F6AA1DCBB7B53A9C7E_il2cpp_TypeInfo_var);
uint16_t L_1 = Convert_ToUInt16_mC540754A3F101A7A13FB26FD89836025507E7E80(L_0, /*hidden argument*/NULL);
return L_1;
}
}
IL2CPP_EXTERN_C uint16_t UInt64_System_IConvertible_ToUInt16_m6B443639CDAEEDBE636A47EF6D07B045B51C2A51_AdjustorThunk (RuntimeObject * __this, RuntimeObject* ___provider0, const RuntimeMethod* method)
{
uint64_t* _thisAdjusted = reinterpret_cast<uint64_t*>(__this + 1);
return UInt64_System_IConvertible_ToUInt16_m6B443639CDAEEDBE636A47EF6D07B045B51C2A51(_thisAdjusted, ___provider0, method);
}
// System.Int32 System.UInt64::System.IConvertible.ToInt32(System.IFormatProvider)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t UInt64_System_IConvertible_ToInt32_mBF342D7305B0F4643B8B2FB2EAC54F6B5C943746 (uint64_t* __this, RuntimeObject* ___provider0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (UInt64_System_IConvertible_ToInt32_mBF342D7305B0F4643B8B2FB2EAC54F6B5C943746_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
int64_t L_0 = *((int64_t*)__this);
IL2CPP_RUNTIME_CLASS_INIT(Convert_t1C7A851BFB2F0782FD7F72F6AA1DCBB7B53A9C7E_il2cpp_TypeInfo_var);
int32_t L_1 = Convert_ToInt32_m4E8E4BA500C8372D58B20E706C76C8126F7F5260(L_0, /*hidden argument*/NULL);
return L_1;
}
}
IL2CPP_EXTERN_C int32_t UInt64_System_IConvertible_ToInt32_mBF342D7305B0F4643B8B2FB2EAC54F6B5C943746_AdjustorThunk (RuntimeObject * __this, RuntimeObject* ___provider0, const RuntimeMethod* method)
{
uint64_t* _thisAdjusted = reinterpret_cast<uint64_t*>(__this + 1);
return UInt64_System_IConvertible_ToInt32_mBF342D7305B0F4643B8B2FB2EAC54F6B5C943746(_thisAdjusted, ___provider0, method);
}
// System.UInt32 System.UInt64::System.IConvertible.ToUInt32(System.IFormatProvider)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR uint32_t UInt64_System_IConvertible_ToUInt32_mFF9B4ABD152C30CB4A9F09BAED4D197245141AF7 (uint64_t* __this, RuntimeObject* ___provider0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (UInt64_System_IConvertible_ToUInt32_mFF9B4ABD152C30CB4A9F09BAED4D197245141AF7_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
int64_t L_0 = *((int64_t*)__this);
IL2CPP_RUNTIME_CLASS_INIT(Convert_t1C7A851BFB2F0782FD7F72F6AA1DCBB7B53A9C7E_il2cpp_TypeInfo_var);
uint32_t L_1 = Convert_ToUInt32_m7DC544C6EB3CA7920C82A243D9C387B462697BAC(L_0, /*hidden argument*/NULL);
return L_1;
}
}
IL2CPP_EXTERN_C uint32_t UInt64_System_IConvertible_ToUInt32_mFF9B4ABD152C30CB4A9F09BAED4D197245141AF7_AdjustorThunk (RuntimeObject * __this, RuntimeObject* ___provider0, const RuntimeMethod* method)
{
uint64_t* _thisAdjusted = reinterpret_cast<uint64_t*>(__this + 1);
return UInt64_System_IConvertible_ToUInt32_mFF9B4ABD152C30CB4A9F09BAED4D197245141AF7(_thisAdjusted, ___provider0, method);
}
// System.Int64 System.UInt64::System.IConvertible.ToInt64(System.IFormatProvider)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int64_t UInt64_System_IConvertible_ToInt64_mFA654AF22149F693965B34C380C2FF61764D7BD4 (uint64_t* __this, RuntimeObject* ___provider0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (UInt64_System_IConvertible_ToInt64_mFA654AF22149F693965B34C380C2FF61764D7BD4_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
int64_t L_0 = *((int64_t*)__this);
IL2CPP_RUNTIME_CLASS_INIT(Convert_t1C7A851BFB2F0782FD7F72F6AA1DCBB7B53A9C7E_il2cpp_TypeInfo_var);
int64_t L_1 = Convert_ToInt64_m396C2B4FA8F12D0C76E0AA3A31872D93BF5EA11D(L_0, /*hidden argument*/NULL);
return L_1;
}
}
IL2CPP_EXTERN_C int64_t UInt64_System_IConvertible_ToInt64_mFA654AF22149F693965B34C380C2FF61764D7BD4_AdjustorThunk (RuntimeObject * __this, RuntimeObject* ___provider0, const RuntimeMethod* method)
{
uint64_t* _thisAdjusted = reinterpret_cast<uint64_t*>(__this + 1);
return UInt64_System_IConvertible_ToInt64_mFA654AF22149F693965B34C380C2FF61764D7BD4(_thisAdjusted, ___provider0, method);
}
// System.UInt64 System.UInt64::System.IConvertible.ToUInt64(System.IFormatProvider)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR uint64_t UInt64_System_IConvertible_ToUInt64_m2D81AD0924E713479AACA50B8C236935A2315BB4 (uint64_t* __this, RuntimeObject* ___provider0, const RuntimeMethod* method)
{
{
int64_t L_0 = *((int64_t*)__this);
return L_0;
}
}
IL2CPP_EXTERN_C uint64_t UInt64_System_IConvertible_ToUInt64_m2D81AD0924E713479AACA50B8C236935A2315BB4_AdjustorThunk (RuntimeObject * __this, RuntimeObject* ___provider0, const RuntimeMethod* method)
{
uint64_t* _thisAdjusted = reinterpret_cast<uint64_t*>(__this + 1);
return UInt64_System_IConvertible_ToUInt64_m2D81AD0924E713479AACA50B8C236935A2315BB4(_thisAdjusted, ___provider0, method);
}
// System.Single System.UInt64::System.IConvertible.ToSingle(System.IFormatProvider)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR float UInt64_System_IConvertible_ToSingle_m04A4372F398081E930044EEECC7B73B4686EE8F0 (uint64_t* __this, RuntimeObject* ___provider0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (UInt64_System_IConvertible_ToSingle_m04A4372F398081E930044EEECC7B73B4686EE8F0_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
int64_t L_0 = *((int64_t*)__this);
IL2CPP_RUNTIME_CLASS_INIT(Convert_t1C7A851BFB2F0782FD7F72F6AA1DCBB7B53A9C7E_il2cpp_TypeInfo_var);
float L_1 = Convert_ToSingle_mEB588F7F980A4BF31BDBACC733574C97A32E357A(L_0, /*hidden argument*/NULL);
return L_1;
}
}
IL2CPP_EXTERN_C float UInt64_System_IConvertible_ToSingle_m04A4372F398081E930044EEECC7B73B4686EE8F0_AdjustorThunk (RuntimeObject * __this, RuntimeObject* ___provider0, const RuntimeMethod* method)
{
uint64_t* _thisAdjusted = reinterpret_cast<uint64_t*>(__this + 1);
return UInt64_System_IConvertible_ToSingle_m04A4372F398081E930044EEECC7B73B4686EE8F0(_thisAdjusted, ___provider0, method);
}
// System.Double System.UInt64::System.IConvertible.ToDouble(System.IFormatProvider)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR double UInt64_System_IConvertible_ToDouble_mE29DD1148D7D94855DCB7CE8B4FC4B9424A00A82 (uint64_t* __this, RuntimeObject* ___provider0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (UInt64_System_IConvertible_ToDouble_mE29DD1148D7D94855DCB7CE8B4FC4B9424A00A82_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
int64_t L_0 = *((int64_t*)__this);
IL2CPP_RUNTIME_CLASS_INIT(Convert_t1C7A851BFB2F0782FD7F72F6AA1DCBB7B53A9C7E_il2cpp_TypeInfo_var);
double L_1 = Convert_ToDouble_m18E2BC69DA3D88A0C5CD258FFBF1DB5BA097C316(L_0, /*hidden argument*/NULL);
return L_1;
}
}
IL2CPP_EXTERN_C double UInt64_System_IConvertible_ToDouble_mE29DD1148D7D94855DCB7CE8B4FC4B9424A00A82_AdjustorThunk (RuntimeObject * __this, RuntimeObject* ___provider0, const RuntimeMethod* method)
{
uint64_t* _thisAdjusted = reinterpret_cast<uint64_t*>(__this + 1);
return UInt64_System_IConvertible_ToDouble_mE29DD1148D7D94855DCB7CE8B4FC4B9424A00A82(_thisAdjusted, ___provider0, method);
}
// System.Decimal System.UInt64::System.IConvertible.ToDecimal(System.IFormatProvider)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Decimal_t44EE9DA309A1BF848308DE4DDFC070CAE6D95EE8 UInt64_System_IConvertible_ToDecimal_mFE274863205856F4B130AD096D6BC7E40AA65FC7 (uint64_t* __this, RuntimeObject* ___provider0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (UInt64_System_IConvertible_ToDecimal_mFE274863205856F4B130AD096D6BC7E40AA65FC7_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
int64_t L_0 = *((int64_t*)__this);
IL2CPP_RUNTIME_CLASS_INIT(Convert_t1C7A851BFB2F0782FD7F72F6AA1DCBB7B53A9C7E_il2cpp_TypeInfo_var);
Decimal_t44EE9DA309A1BF848308DE4DDFC070CAE6D95EE8 L_1 = Convert_ToDecimal_mC4A6FC31B0F2C506D113380567B082CCB6A4FEED(L_0, /*hidden argument*/NULL);
return L_1;
}
}
IL2CPP_EXTERN_C Decimal_t44EE9DA309A1BF848308DE4DDFC070CAE6D95EE8 UInt64_System_IConvertible_ToDecimal_mFE274863205856F4B130AD096D6BC7E40AA65FC7_AdjustorThunk (RuntimeObject * __this, RuntimeObject* ___provider0, const RuntimeMethod* method)
{
uint64_t* _thisAdjusted = reinterpret_cast<uint64_t*>(__this + 1);
return UInt64_System_IConvertible_ToDecimal_mFE274863205856F4B130AD096D6BC7E40AA65FC7(_thisAdjusted, ___provider0, method);
}
// System.DateTime System.UInt64::System.IConvertible.ToDateTime(System.IFormatProvider)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR DateTime_t349B7449FBAAFF4192636E2B7A07694DA9236132 UInt64_System_IConvertible_ToDateTime_m1DE2B7B00676B061B66F18FCCC7CBC5D848B0EBA (uint64_t* __this, RuntimeObject* ___provider0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (UInt64_System_IConvertible_ToDateTime_m1DE2B7B00676B061B66F18FCCC7CBC5D848B0EBA_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
ObjectU5BU5D_t3C9242B5C88A48B2A5BD9FDA6CD0024E792AF08A* L_0 = (ObjectU5BU5D_t3C9242B5C88A48B2A5BD9FDA6CD0024E792AF08A*)(ObjectU5BU5D_t3C9242B5C88A48B2A5BD9FDA6CD0024E792AF08A*)SZArrayNew(ObjectU5BU5D_t3C9242B5C88A48B2A5BD9FDA6CD0024E792AF08A_il2cpp_TypeInfo_var, (uint32_t)2);
ObjectU5BU5D_t3C9242B5C88A48B2A5BD9FDA6CD0024E792AF08A* L_1 = L_0;
NullCheck(L_1);
ArrayElementTypeCheck (L_1, _stringLiteral69A99906F5A06EA1BDBFC02E6132D35DE781D3F1);
(L_1)->SetAt(static_cast<il2cpp_array_size_t>(0), (RuntimeObject *)_stringLiteral69A99906F5A06EA1BDBFC02E6132D35DE781D3F1);
ObjectU5BU5D_t3C9242B5C88A48B2A5BD9FDA6CD0024E792AF08A* L_2 = L_1;
NullCheck(L_2);
ArrayElementTypeCheck (L_2, _stringLiteralF1E5BAF5ECC3589631088C40CBDD43061976ED8F);
(L_2)->SetAt(static_cast<il2cpp_array_size_t>(1), (RuntimeObject *)_stringLiteralF1E5BAF5ECC3589631088C40CBDD43061976ED8F);
String_t* L_3 = Environment_GetResourceString_m7389941B4C0688D875CC647D99A739DA2F907ADB(_stringLiteralE5559C91F3F57F398B8B547CA356C67FFA1F6497, L_2, /*hidden argument*/NULL);
InvalidCastException_t91DF9E7D7FCCDA6C562CB4A9A18903E016680FDA * L_4 = (InvalidCastException_t91DF9E7D7FCCDA6C562CB4A9A18903E016680FDA *)il2cpp_codegen_object_new(InvalidCastException_t91DF9E7D7FCCDA6C562CB4A9A18903E016680FDA_il2cpp_TypeInfo_var);
InvalidCastException__ctor_m3795145150387C6C362DA693613505C604AB8812(L_4, L_3, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_4, NULL, UInt64_System_IConvertible_ToDateTime_m1DE2B7B00676B061B66F18FCCC7CBC5D848B0EBA_RuntimeMethod_var);
}
}
IL2CPP_EXTERN_C DateTime_t349B7449FBAAFF4192636E2B7A07694DA9236132 UInt64_System_IConvertible_ToDateTime_m1DE2B7B00676B061B66F18FCCC7CBC5D848B0EBA_AdjustorThunk (RuntimeObject * __this, RuntimeObject* ___provider0, const RuntimeMethod* method)
{
uint64_t* _thisAdjusted = reinterpret_cast<uint64_t*>(__this + 1);
return UInt64_System_IConvertible_ToDateTime_m1DE2B7B00676B061B66F18FCCC7CBC5D848B0EBA(_thisAdjusted, ___provider0, method);
}
// System.Object System.UInt64::System.IConvertible.ToType(System.Type,System.IFormatProvider)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * UInt64_System_IConvertible_ToType_m176FFA8FD3BDEAB82C5BD41CF3CF81C83AC21803 (uint64_t* __this, Type_t * ___type0, RuntimeObject* ___provider1, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (UInt64_System_IConvertible_ToType_m176FFA8FD3BDEAB82C5BD41CF3CF81C83AC21803_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
int64_t L_0 = *((int64_t*)__this);
uint64_t L_1 = ((uint64_t)L_0);
RuntimeObject * L_2 = Box(UInt64_tA02DF3B59C8FC4A849BD207DA11038CC64E4CB4E_il2cpp_TypeInfo_var, &L_1);
Type_t * L_3 = ___type0;
RuntimeObject* L_4 = ___provider1;
IL2CPP_RUNTIME_CLASS_INIT(Convert_t1C7A851BFB2F0782FD7F72F6AA1DCBB7B53A9C7E_il2cpp_TypeInfo_var);
RuntimeObject * L_5 = Convert_DefaultToType_m899D5F6B9FE3E8B878BC56172C6BFE788B6C1BE3((RuntimeObject*)L_2, L_3, L_4, /*hidden argument*/NULL);
return L_5;
}
}
IL2CPP_EXTERN_C RuntimeObject * UInt64_System_IConvertible_ToType_m176FFA8FD3BDEAB82C5BD41CF3CF81C83AC21803_AdjustorThunk (RuntimeObject * __this, Type_t * ___type0, RuntimeObject* ___provider1, const RuntimeMethod* method)
{
uint64_t* _thisAdjusted = reinterpret_cast<uint64_t*>(__this + 1);
return UInt64_System_IConvertible_ToType_m176FFA8FD3BDEAB82C5BD41CF3CF81C83AC21803(_thisAdjusted, ___type0, ___provider1, method);
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.UIntPtr::.ctor(System.UInt32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void UIntPtr__ctor_m7DB6B4A7AE8195A45E5FB3FEBD2ECB4609D8C084 (uintptr_t* __this, uint32_t ___value0, const RuntimeMethod* method)
{
{
uint32_t L_0 = ___value0;
*__this = ((((uintptr_t)L_0)));
return;
}
}
IL2CPP_EXTERN_C void UIntPtr__ctor_m7DB6B4A7AE8195A45E5FB3FEBD2ECB4609D8C084_AdjustorThunk (RuntimeObject * __this, uint32_t ___value0, const RuntimeMethod* method)
{
uintptr_t* _thisAdjusted = reinterpret_cast<uintptr_t*>(__this + 1);
UIntPtr__ctor_m7DB6B4A7AE8195A45E5FB3FEBD2ECB4609D8C084(_thisAdjusted, ___value0, method);
}
// System.Boolean System.UIntPtr::Equals(System.Object)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool UIntPtr_Equals_m8C135DEDA578597066AB67C1DD5A5A34E4F860EB (uintptr_t* __this, RuntimeObject * ___obj0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (UIntPtr_Equals_m8C135DEDA578597066AB67C1DD5A5A34E4F860EB_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
uintptr_t V_0;
memset((&V_0), 0, sizeof(V_0));
{
RuntimeObject * L_0 = ___obj0;
if (!((RuntimeObject *)IsInstSealed((RuntimeObject*)L_0, UIntPtr_t_il2cpp_TypeInfo_var)))
{
goto IL_001f;
}
}
{
RuntimeObject * L_1 = ___obj0;
V_0 = ((*(uintptr_t*)((uintptr_t*)UnBox(L_1, UIntPtr_t_il2cpp_TypeInfo_var))));
uintptr_t L_2 = *__this;
uintptr_t L_3 = V_0;
return (bool)((((intptr_t)L_2) == ((intptr_t)L_3))? 1 : 0);
}
IL_001f:
{
return (bool)0;
}
}
IL2CPP_EXTERN_C bool UIntPtr_Equals_m8C135DEDA578597066AB67C1DD5A5A34E4F860EB_AdjustorThunk (RuntimeObject * __this, RuntimeObject * ___obj0, const RuntimeMethod* method)
{
uintptr_t* _thisAdjusted = reinterpret_cast<uintptr_t*>(__this + 1);
return UIntPtr_Equals_m8C135DEDA578597066AB67C1DD5A5A34E4F860EB(_thisAdjusted, ___obj0, method);
}
// System.Int32 System.UIntPtr::GetHashCode()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t UIntPtr_GetHashCode_m713296172AF735B0CB68B60859FC8EE5B4840D5C (uintptr_t* __this, const RuntimeMethod* method)
{
{
uintptr_t L_0 = *__this;
return (((int32_t)((int32_t)L_0)));
}
}
IL2CPP_EXTERN_C int32_t UIntPtr_GetHashCode_m713296172AF735B0CB68B60859FC8EE5B4840D5C_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
uintptr_t* _thisAdjusted = reinterpret_cast<uintptr_t*>(__this + 1);
return UIntPtr_GetHashCode_m713296172AF735B0CB68B60859FC8EE5B4840D5C(_thisAdjusted, method);
}
// System.String System.UIntPtr::ToString()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR String_t* UIntPtr_ToString_m1512332A1A79F9DA551731E9CA7F071A3C88043D (uintptr_t* __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (UIntPtr_ToString_m1512332A1A79F9DA551731E9CA7F071A3C88043D_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
uint64_t V_0 = 0;
uint32_t V_1 = 0;
{
IL2CPP_RUNTIME_CLASS_INIT(UIntPtr_t_il2cpp_TypeInfo_var);
int32_t L_0 = UIntPtr_get_Size_m063860D6F716C79EE77F379C6B20436413389E0B(/*hidden argument*/NULL);
if ((((int32_t)L_0) < ((int32_t)8)))
{
goto IL_0018;
}
}
{
uintptr_t L_1 = *__this;
V_0 = (((int64_t)((uint64_t)L_1)));
String_t* L_2 = UInt64_ToString_mF0E40B7459C207B89A1C8C04CE7F183AC0E6D672((uint64_t*)(&V_0), /*hidden argument*/NULL);
return L_2;
}
IL_0018:
{
uintptr_t L_3 = *__this;
V_1 = (((int32_t)((uint32_t)L_3)));
String_t* L_4 = UInt32_ToString_m7D8A934AF1D74C5C8194D1556AA71BBA0D4600F2((uint32_t*)(&V_1), /*hidden argument*/NULL);
return L_4;
}
}
IL2CPP_EXTERN_C String_t* UIntPtr_ToString_m1512332A1A79F9DA551731E9CA7F071A3C88043D_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
uintptr_t* _thisAdjusted = reinterpret_cast<uintptr_t*>(__this + 1);
return UIntPtr_ToString_m1512332A1A79F9DA551731E9CA7F071A3C88043D(_thisAdjusted, method);
}
// System.Void System.UIntPtr::System.Runtime.Serialization.ISerializable.GetObjectData(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void UIntPtr_System_Runtime_Serialization_ISerializable_GetObjectData_mB6B1C508A6E9BFD526F23A38634C1E703595B733 (uintptr_t* __this, SerializationInfo_t1BB80E9C9DEA52DBF464487234B045E2930ADA26 * ___info0, StreamingContext_t2CCDC54E0E8D078AF4A50E3A8B921B828A900034 ___context1, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (UIntPtr_System_Runtime_Serialization_ISerializable_GetObjectData_mB6B1C508A6E9BFD526F23A38634C1E703595B733_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
SerializationInfo_t1BB80E9C9DEA52DBF464487234B045E2930ADA26 * L_0 = ___info0;
if (L_0)
{
goto IL_000e;
}
}
{
ArgumentNullException_t581DF992B1F3E0EC6EFB30CC5DC43519A79B27AD * L_1 = (ArgumentNullException_t581DF992B1F3E0EC6EFB30CC5DC43519A79B27AD *)il2cpp_codegen_object_new(ArgumentNullException_t581DF992B1F3E0EC6EFB30CC5DC43519A79B27AD_il2cpp_TypeInfo_var);
ArgumentNullException__ctor_mEE0C0D6FCB2D08CD7967DBB1329A0854BBED49ED(L_1, _stringLiteral59BD0A3FF43B32849B319E645D4798D8A5D1E889, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_1, NULL, UIntPtr_System_Runtime_Serialization_ISerializable_GetObjectData_mB6B1C508A6E9BFD526F23A38634C1E703595B733_RuntimeMethod_var);
}
IL_000e:
{
SerializationInfo_t1BB80E9C9DEA52DBF464487234B045E2930ADA26 * L_2 = ___info0;
uintptr_t L_3 = *__this;
NullCheck(L_2);
SerializationInfo_AddValue_m9861690C28AB414534D1A7F599E050DBA7A99303(L_2, _stringLiteralB35BB38DF9605E4C5858316B7853A16E42EA6997, (((int64_t)((uint64_t)L_3))), /*hidden argument*/NULL);
return;
}
}
IL2CPP_EXTERN_C void UIntPtr_System_Runtime_Serialization_ISerializable_GetObjectData_mB6B1C508A6E9BFD526F23A38634C1E703595B733_AdjustorThunk (RuntimeObject * __this, SerializationInfo_t1BB80E9C9DEA52DBF464487234B045E2930ADA26 * ___info0, StreamingContext_t2CCDC54E0E8D078AF4A50E3A8B921B828A900034 ___context1, const RuntimeMethod* method)
{
uintptr_t* _thisAdjusted = reinterpret_cast<uintptr_t*>(__this + 1);
UIntPtr_System_Runtime_Serialization_ISerializable_GetObjectData_mB6B1C508A6E9BFD526F23A38634C1E703595B733(_thisAdjusted, ___info0, ___context1, method);
}
// System.Boolean System.UIntPtr::op_Equality(System.UIntPtr,System.UIntPtr)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool UIntPtr_op_Equality_m69F127E2A7A8BA5676D14FB08B52F6A6E83794B1 (uintptr_t ___value10, uintptr_t ___value21, const RuntimeMethod* method)
{
{
uintptr_t L_0 = ___value10;
uintptr_t L_1 = ___value21;
return (bool)((((intptr_t)L_0) == ((intptr_t)L_1))? 1 : 0);
}
}
// System.Int32 System.UIntPtr::get_Size()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t UIntPtr_get_Size_m063860D6F716C79EE77F379C6B20436413389E0B (const RuntimeMethod* method)
{
{
uint32_t L_0 = sizeof(void*);
return L_0;
}
}
// System.Void System.UIntPtr::.cctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void UIntPtr__cctor_m4D964FAB1256A389E1DA1838C169AB4B559D28B8 (const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (UIntPtr__cctor_m4D964FAB1256A389E1DA1838C169AB4B559D28B8_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
uintptr_t L_0;
memset((&L_0), 0, sizeof(L_0));
UIntPtr__ctor_m7DB6B4A7AE8195A45E5FB3FEBD2ECB4609D8C084((&L_0), 0, /*hidden argument*/NULL);
return;
}
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// Conversion methods for marshalling of: System.UnSafeCharBuffer
IL2CPP_EXTERN_C void UnSafeCharBuffer_t99F0962CE65E71C4BA612D5434276C51AC33AF0C_marshal_pinvoke(const UnSafeCharBuffer_t99F0962CE65E71C4BA612D5434276C51AC33AF0C& unmarshaled, UnSafeCharBuffer_t99F0962CE65E71C4BA612D5434276C51AC33AF0C_marshaled_pinvoke& marshaled)
{
marshaled.___m_buffer_0 = unmarshaled.get_m_buffer_0();
marshaled.___m_totalSize_1 = unmarshaled.get_m_totalSize_1();
marshaled.___m_length_2 = unmarshaled.get_m_length_2();
}
IL2CPP_EXTERN_C void UnSafeCharBuffer_t99F0962CE65E71C4BA612D5434276C51AC33AF0C_marshal_pinvoke_back(const UnSafeCharBuffer_t99F0962CE65E71C4BA612D5434276C51AC33AF0C_marshaled_pinvoke& marshaled, UnSafeCharBuffer_t99F0962CE65E71C4BA612D5434276C51AC33AF0C& unmarshaled)
{
unmarshaled.set_m_buffer_0(marshaled.___m_buffer_0);
int32_t unmarshaled_m_totalSize_temp_1 = 0;
unmarshaled_m_totalSize_temp_1 = marshaled.___m_totalSize_1;
unmarshaled.set_m_totalSize_1(unmarshaled_m_totalSize_temp_1);
int32_t unmarshaled_m_length_temp_2 = 0;
unmarshaled_m_length_temp_2 = marshaled.___m_length_2;
unmarshaled.set_m_length_2(unmarshaled_m_length_temp_2);
}
// Conversion method for clean up from marshalling of: System.UnSafeCharBuffer
IL2CPP_EXTERN_C void UnSafeCharBuffer_t99F0962CE65E71C4BA612D5434276C51AC33AF0C_marshal_pinvoke_cleanup(UnSafeCharBuffer_t99F0962CE65E71C4BA612D5434276C51AC33AF0C_marshaled_pinvoke& marshaled)
{
}
// Conversion methods for marshalling of: System.UnSafeCharBuffer
IL2CPP_EXTERN_C void UnSafeCharBuffer_t99F0962CE65E71C4BA612D5434276C51AC33AF0C_marshal_com(const UnSafeCharBuffer_t99F0962CE65E71C4BA612D5434276C51AC33AF0C& unmarshaled, UnSafeCharBuffer_t99F0962CE65E71C4BA612D5434276C51AC33AF0C_marshaled_com& marshaled)
{
marshaled.___m_buffer_0 = unmarshaled.get_m_buffer_0();
marshaled.___m_totalSize_1 = unmarshaled.get_m_totalSize_1();
marshaled.___m_length_2 = unmarshaled.get_m_length_2();
}
IL2CPP_EXTERN_C void UnSafeCharBuffer_t99F0962CE65E71C4BA612D5434276C51AC33AF0C_marshal_com_back(const UnSafeCharBuffer_t99F0962CE65E71C4BA612D5434276C51AC33AF0C_marshaled_com& marshaled, UnSafeCharBuffer_t99F0962CE65E71C4BA612D5434276C51AC33AF0C& unmarshaled)
{
unmarshaled.set_m_buffer_0(marshaled.___m_buffer_0);
int32_t unmarshaled_m_totalSize_temp_1 = 0;
unmarshaled_m_totalSize_temp_1 = marshaled.___m_totalSize_1;
unmarshaled.set_m_totalSize_1(unmarshaled_m_totalSize_temp_1);
int32_t unmarshaled_m_length_temp_2 = 0;
unmarshaled_m_length_temp_2 = marshaled.___m_length_2;
unmarshaled.set_m_length_2(unmarshaled_m_length_temp_2);
}
// Conversion method for clean up from marshalling of: System.UnSafeCharBuffer
IL2CPP_EXTERN_C void UnSafeCharBuffer_t99F0962CE65E71C4BA612D5434276C51AC33AF0C_marshal_com_cleanup(UnSafeCharBuffer_t99F0962CE65E71C4BA612D5434276C51AC33AF0C_marshaled_com& marshaled)
{
}
// System.Void System.UnSafeCharBuffer::.ctor(System.Char*,System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void UnSafeCharBuffer__ctor_mF7AA675CC9B4BF79D4A8FD4EB7146CFFECEEB14D (UnSafeCharBuffer_t99F0962CE65E71C4BA612D5434276C51AC33AF0C * __this, Il2CppChar* ___buffer0, int32_t ___bufferSize1, const RuntimeMethod* method)
{
{
Il2CppChar* L_0 = ___buffer0;
__this->set_m_buffer_0((Il2CppChar*)L_0);
int32_t L_1 = ___bufferSize1;
__this->set_m_totalSize_1(L_1);
__this->set_m_length_2(0);
return;
}
}
IL2CPP_EXTERN_C void UnSafeCharBuffer__ctor_mF7AA675CC9B4BF79D4A8FD4EB7146CFFECEEB14D_AdjustorThunk (RuntimeObject * __this, Il2CppChar* ___buffer0, int32_t ___bufferSize1, const RuntimeMethod* method)
{
UnSafeCharBuffer_t99F0962CE65E71C4BA612D5434276C51AC33AF0C * _thisAdjusted = reinterpret_cast<UnSafeCharBuffer_t99F0962CE65E71C4BA612D5434276C51AC33AF0C *>(__this + 1);
UnSafeCharBuffer__ctor_mF7AA675CC9B4BF79D4A8FD4EB7146CFFECEEB14D(_thisAdjusted, ___buffer0, ___bufferSize1, method);
}
// System.Void System.UnSafeCharBuffer::AppendString(System.String)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void UnSafeCharBuffer_AppendString_m1E2967E285FC06FDE141B90EF186745D5D2814FE (UnSafeCharBuffer_t99F0962CE65E71C4BA612D5434276C51AC33AF0C * __this, String_t* ___stringToAppend0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (UnSafeCharBuffer_AppendString_m1E2967E285FC06FDE141B90EF186745D5D2814FE_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
Il2CppChar* V_0 = NULL;
String_t* V_1 = NULL;
{
String_t* L_0 = ___stringToAppend0;
bool L_1 = String_IsNullOrEmpty_m06A85A206AC2106D1982826C5665B9BD35324229(L_0, /*hidden argument*/NULL);
if (!L_1)
{
goto IL_0009;
}
}
{
return;
}
IL_0009:
{
int32_t L_2 = __this->get_m_totalSize_1();
int32_t L_3 = __this->get_m_length_2();
String_t* L_4 = ___stringToAppend0;
NullCheck(L_4);
int32_t L_5 = String_get_Length_mD48C8A16A5CF1914F330DCE82D9BE15C3BEDD018(L_4, /*hidden argument*/NULL);
if ((((int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)L_2, (int32_t)L_3))) >= ((int32_t)L_5)))
{
goto IL_0024;
}
}
{
IndexOutOfRangeException_tEC7665FC66525AB6A6916A7EB505E5591683F0CF * L_6 = (IndexOutOfRangeException_tEC7665FC66525AB6A6916A7EB505E5591683F0CF *)il2cpp_codegen_object_new(IndexOutOfRangeException_tEC7665FC66525AB6A6916A7EB505E5591683F0CF_il2cpp_TypeInfo_var);
IndexOutOfRangeException__ctor_m17448AB4B27BC9D8AEB4605CDB0EA053626ABEC1(L_6, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_6, NULL, UnSafeCharBuffer_AppendString_m1E2967E285FC06FDE141B90EF186745D5D2814FE_RuntimeMethod_var);
}
IL_0024:
{
String_t* L_7 = ___stringToAppend0;
V_1 = L_7;
String_t* L_8 = V_1;
V_0 = (Il2CppChar*)(((uintptr_t)L_8));
Il2CppChar* L_9 = V_0;
if (!L_9)
{
goto IL_0034;
}
}
{
Il2CppChar* L_10 = V_0;
int32_t L_11 = RuntimeHelpers_get_OffsetToStringData_mF3B79A906181F1A2734590DA161E2AF183853F8B(/*hidden argument*/NULL);
V_0 = (Il2CppChar*)((Il2CppChar*)il2cpp_codegen_add((intptr_t)L_10, (int32_t)L_11));
}
IL_0034:
{
Il2CppChar* L_12 = __this->get_m_buffer_0();
int32_t L_13 = __this->get_m_length_2();
Il2CppChar* L_14 = V_0;
String_t* L_15 = ___stringToAppend0;
NullCheck(L_15);
int32_t L_16 = String_get_Length_mD48C8A16A5CF1914F330DCE82D9BE15C3BEDD018(L_15, /*hidden argument*/NULL);
Buffer_Memcpy_m4D475106A101E5ED38EB22776EAAFB6D02F63678((uint8_t*)(uint8_t*)((Il2CppChar*)il2cpp_codegen_add((intptr_t)L_12, (intptr_t)((intptr_t)il2cpp_codegen_multiply((intptr_t)(((intptr_t)L_13)), (int32_t)2)))), (uint8_t*)(uint8_t*)L_14, ((int32_t)il2cpp_codegen_multiply((int32_t)L_16, (int32_t)2)), /*hidden argument*/NULL);
V_1 = (String_t*)NULL;
int32_t L_17 = __this->get_m_length_2();
String_t* L_18 = ___stringToAppend0;
NullCheck(L_18);
int32_t L_19 = String_get_Length_mD48C8A16A5CF1914F330DCE82D9BE15C3BEDD018(L_18, /*hidden argument*/NULL);
__this->set_m_length_2(((int32_t)il2cpp_codegen_add((int32_t)L_17, (int32_t)L_19)));
return;
}
}
IL2CPP_EXTERN_C void UnSafeCharBuffer_AppendString_m1E2967E285FC06FDE141B90EF186745D5D2814FE_AdjustorThunk (RuntimeObject * __this, String_t* ___stringToAppend0, const RuntimeMethod* method)
{
UnSafeCharBuffer_t99F0962CE65E71C4BA612D5434276C51AC33AF0C * _thisAdjusted = reinterpret_cast<UnSafeCharBuffer_t99F0962CE65E71C4BA612D5434276C51AC33AF0C *>(__this + 1);
UnSafeCharBuffer_AppendString_m1E2967E285FC06FDE141B90EF186745D5D2814FE(_thisAdjusted, ___stringToAppend0, method);
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.UnauthorizedAccessException::.ctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void UnauthorizedAccessException__ctor_mE67AE27F79595BF7594E2D76D24336E64293693E (UnauthorizedAccessException_tC2210A745BFDD3AE3559A87A4219E2945EEC9F75 * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (UnauthorizedAccessException__ctor_mE67AE27F79595BF7594E2D76D24336E64293693E_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
String_t* L_0 = Environment_GetResourceString_m2C75C2AF268F01E2BF34AD1C2E1352CF4BA51AD9(_stringLiteral3F90E4D12E77695269D01EC8AAEF48EEF6C79412, /*hidden argument*/NULL);
SystemException__ctor_mF67B7FA639B457BDFB2103D7C21C8059E806175A(__this, L_0, /*hidden argument*/NULL);
Exception_SetErrorCode_m742C1E687C82E56F445893685007EF4FC017F4A7(__this, ((int32_t)-2147024891), /*hidden argument*/NULL);
return;
}
}
// System.Void System.UnauthorizedAccessException::.ctor(System.String)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void UnauthorizedAccessException__ctor_mFE97E700E2ADBC5A46A6A43642CFA2FCB8C0BA85 (UnauthorizedAccessException_tC2210A745BFDD3AE3559A87A4219E2945EEC9F75 * __this, String_t* ___message0, const RuntimeMethod* method)
{
{
String_t* L_0 = ___message0;
SystemException__ctor_mF67B7FA639B457BDFB2103D7C21C8059E806175A(__this, L_0, /*hidden argument*/NULL);
Exception_SetErrorCode_m742C1E687C82E56F445893685007EF4FC017F4A7(__this, ((int32_t)-2147024891), /*hidden argument*/NULL);
return;
}
}
// System.Void System.UnauthorizedAccessException::.ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void UnauthorizedAccessException__ctor_m277E2189AEF94D3192D482ECEC9E8077ED45CD04 (UnauthorizedAccessException_tC2210A745BFDD3AE3559A87A4219E2945EEC9F75 * __this, SerializationInfo_t1BB80E9C9DEA52DBF464487234B045E2930ADA26 * ___info0, StreamingContext_t2CCDC54E0E8D078AF4A50E3A8B921B828A900034 ___context1, const RuntimeMethod* method)
{
{
SerializationInfo_t1BB80E9C9DEA52DBF464487234B045E2930ADA26 * L_0 = ___info0;
StreamingContext_t2CCDC54E0E8D078AF4A50E3A8B921B828A900034 L_1 = ___context1;
SystemException__ctor_mB0550111A1A8D18B697B618F811A5B20C160D949(__this, L_0, L_1, /*hidden argument*/NULL);
return;
}
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.UnhandledExceptionEventArgs::.ctor(System.Object,System.Boolean)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void UnhandledExceptionEventArgs__ctor_m126C64897FC12C485717061C6903DBC02E10A9A0 (UnhandledExceptionEventArgs_t39DD47D43B0D764FE2C9847FBE760031FBEA0FD1 * __this, RuntimeObject * ___exception0, bool ___isTerminating1, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (UnhandledExceptionEventArgs__ctor_m126C64897FC12C485717061C6903DBC02E10A9A0_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
IL2CPP_RUNTIME_CLASS_INIT(EventArgs_t8E6CA180BE0E56674C6407011A94BAF7C757352E_il2cpp_TypeInfo_var);
EventArgs__ctor_m3551293259861C5A78CD47689D559F828ED29DF7(__this, /*hidden argument*/NULL);
RuntimeObject * L_0 = ___exception0;
__this->set__Exception_1(L_0);
bool L_1 = ___isTerminating1;
__this->set__IsTerminating_2(L_1);
return;
}
}
// System.Object System.UnhandledExceptionEventArgs::get_ExceptionObject()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * UnhandledExceptionEventArgs_get_ExceptionObject_m1936F64BC46B54AA159A4B366BED7AF11DEED0C3 (UnhandledExceptionEventArgs_t39DD47D43B0D764FE2C9847FBE760031FBEA0FD1 * __this, const RuntimeMethod* method)
{
{
RuntimeObject * L_0 = __this->get__Exception_1();
return L_0;
}
}
// System.Boolean System.UnhandledExceptionEventArgs::get_IsTerminating()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool UnhandledExceptionEventArgs_get_IsTerminating_m2145F65E573887AEEABC2730BEFF314557152F63 (UnhandledExceptionEventArgs_t39DD47D43B0D764FE2C9847FBE760031FBEA0FD1 * __this, const RuntimeMethod* method)
{
{
bool L_0 = __this->get__IsTerminating_2();
return L_0;
}
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.UnhandledExceptionEventHandler::.ctor(System.Object,System.IntPtr)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void UnhandledExceptionEventHandler__ctor_m6C9D92AF9901334C444EE7E83FE859D7E4833ABB (UnhandledExceptionEventHandler_tB0DFF05ABF7A3A234C87D4F7A71F98E9AB2D91DE * __this, RuntimeObject * ___object0, intptr_t ___method1, const RuntimeMethod* method)
{
__this->set_method_ptr_0(il2cpp_codegen_get_method_pointer((RuntimeMethod*)___method1));
__this->set_method_3(___method1);
__this->set_m_target_2(___object0);
}
// System.Void System.UnhandledExceptionEventHandler::Invoke(System.Object,System.UnhandledExceptionEventArgs)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void UnhandledExceptionEventHandler_Invoke_mC938E535CF92DEF9D290D03129DA15ACD49F251B (UnhandledExceptionEventHandler_tB0DFF05ABF7A3A234C87D4F7A71F98E9AB2D91DE * __this, RuntimeObject * ___sender0, UnhandledExceptionEventArgs_t39DD47D43B0D764FE2C9847FBE760031FBEA0FD1 * ___e1, const RuntimeMethod* method)
{
DelegateU5BU5D_tDFCDEE2A6322F96C0FE49AF47E9ADB8C4B294E86* delegateArrayToInvoke = __this->get_delegates_11();
Delegate_t** delegatesToInvoke;
il2cpp_array_size_t length;
if (delegateArrayToInvoke != NULL)
{
length = delegateArrayToInvoke->max_length;
delegatesToInvoke = reinterpret_cast<Delegate_t**>(delegateArrayToInvoke->GetAddressAtUnchecked(0));
}
else
{
length = 1;
delegatesToInvoke = reinterpret_cast<Delegate_t**>(&__this);
}
for (il2cpp_array_size_t i = 0; i < length; i++)
{
Delegate_t* currentDelegate = delegatesToInvoke[i];
Il2CppMethodPointer targetMethodPointer = currentDelegate->get_method_ptr_0();
RuntimeObject* targetThis = currentDelegate->get_m_target_2();
RuntimeMethod* targetMethod = (RuntimeMethod*)(currentDelegate->get_method_3());
if (!il2cpp_codegen_method_is_virtual(targetMethod))
{
il2cpp_codegen_raise_execution_engine_exception_if_method_is_not_found(targetMethod);
}
bool ___methodIsStatic = MethodIsStatic(targetMethod);
int ___parameterCount = il2cpp_codegen_method_parameter_count(targetMethod);
if (___methodIsStatic)
{
if (___parameterCount == 2)
{
// open
typedef void (*FunctionPointerType) (RuntimeObject *, UnhandledExceptionEventArgs_t39DD47D43B0D764FE2C9847FBE760031FBEA0FD1 *, const RuntimeMethod*);
((FunctionPointerType)targetMethodPointer)(___sender0, ___e1, targetMethod);
}
else
{
// closed
typedef void (*FunctionPointerType) (void*, RuntimeObject *, UnhandledExceptionEventArgs_t39DD47D43B0D764FE2C9847FBE760031FBEA0FD1 *, const RuntimeMethod*);
((FunctionPointerType)targetMethodPointer)(targetThis, ___sender0, ___e1, targetMethod);
}
}
else if (___parameterCount != 2)
{
// open
if (il2cpp_codegen_method_is_virtual(targetMethod) && !il2cpp_codegen_object_is_of_sealed_type(targetThis) && il2cpp_codegen_delegate_has_invoker((Il2CppDelegate*)__this))
{
if (il2cpp_codegen_method_is_generic_instance(targetMethod))
{
if (il2cpp_codegen_method_is_interface_method(targetMethod))
GenericInterfaceActionInvoker1< UnhandledExceptionEventArgs_t39DD47D43B0D764FE2C9847FBE760031FBEA0FD1 * >::Invoke(targetMethod, ___sender0, ___e1);
else
GenericVirtActionInvoker1< UnhandledExceptionEventArgs_t39DD47D43B0D764FE2C9847FBE760031FBEA0FD1 * >::Invoke(targetMethod, ___sender0, ___e1);
}
else
{
if (il2cpp_codegen_method_is_interface_method(targetMethod))
InterfaceActionInvoker1< UnhandledExceptionEventArgs_t39DD47D43B0D764FE2C9847FBE760031FBEA0FD1 * >::Invoke(il2cpp_codegen_method_get_slot(targetMethod), il2cpp_codegen_method_get_declaring_type(targetMethod), ___sender0, ___e1);
else
VirtActionInvoker1< UnhandledExceptionEventArgs_t39DD47D43B0D764FE2C9847FBE760031FBEA0FD1 * >::Invoke(il2cpp_codegen_method_get_slot(targetMethod), ___sender0, ___e1);
}
}
else
{
typedef void (*FunctionPointerType) (RuntimeObject *, UnhandledExceptionEventArgs_t39DD47D43B0D764FE2C9847FBE760031FBEA0FD1 *, const RuntimeMethod*);
((FunctionPointerType)targetMethodPointer)(___sender0, ___e1, targetMethod);
}
}
else
{
// closed
if (il2cpp_codegen_method_is_virtual(targetMethod) && !il2cpp_codegen_object_is_of_sealed_type(targetThis) && il2cpp_codegen_delegate_has_invoker((Il2CppDelegate*)__this))
{
if (targetThis == NULL)
{
typedef void (*FunctionPointerType) (RuntimeObject *, UnhandledExceptionEventArgs_t39DD47D43B0D764FE2C9847FBE760031FBEA0FD1 *, const RuntimeMethod*);
((FunctionPointerType)targetMethodPointer)(___sender0, ___e1, targetMethod);
}
else if (il2cpp_codegen_method_is_generic_instance(targetMethod))
{
if (il2cpp_codegen_method_is_interface_method(targetMethod))
GenericInterfaceActionInvoker2< RuntimeObject *, UnhandledExceptionEventArgs_t39DD47D43B0D764FE2C9847FBE760031FBEA0FD1 * >::Invoke(targetMethod, targetThis, ___sender0, ___e1);
else
GenericVirtActionInvoker2< RuntimeObject *, UnhandledExceptionEventArgs_t39DD47D43B0D764FE2C9847FBE760031FBEA0FD1 * >::Invoke(targetMethod, targetThis, ___sender0, ___e1);
}
else
{
if (il2cpp_codegen_method_is_interface_method(targetMethod))
InterfaceActionInvoker2< RuntimeObject *, UnhandledExceptionEventArgs_t39DD47D43B0D764FE2C9847FBE760031FBEA0FD1 * >::Invoke(il2cpp_codegen_method_get_slot(targetMethod), il2cpp_codegen_method_get_declaring_type(targetMethod), targetThis, ___sender0, ___e1);
else
VirtActionInvoker2< RuntimeObject *, UnhandledExceptionEventArgs_t39DD47D43B0D764FE2C9847FBE760031FBEA0FD1 * >::Invoke(il2cpp_codegen_method_get_slot(targetMethod), targetThis, ___sender0, ___e1);
}
}
else
{
typedef void (*FunctionPointerType) (void*, RuntimeObject *, UnhandledExceptionEventArgs_t39DD47D43B0D764FE2C9847FBE760031FBEA0FD1 *, const RuntimeMethod*);
((FunctionPointerType)targetMethodPointer)(targetThis, ___sender0, ___e1, targetMethod);
}
}
}
}
// System.IAsyncResult System.UnhandledExceptionEventHandler::BeginInvoke(System.Object,System.UnhandledExceptionEventArgs,System.AsyncCallback,System.Object)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject* UnhandledExceptionEventHandler_BeginInvoke_m685D3D37FBE53A62A290C06A727BA6E2559F1B54 (UnhandledExceptionEventHandler_tB0DFF05ABF7A3A234C87D4F7A71F98E9AB2D91DE * __this, RuntimeObject * ___sender0, UnhandledExceptionEventArgs_t39DD47D43B0D764FE2C9847FBE760031FBEA0FD1 * ___e1, AsyncCallback_t3F3DA3BEDAEE81DD1D24125DF8EB30E85EE14DA4 * ___callback2, RuntimeObject * ___object3, const RuntimeMethod* method)
{
void *__d_args[3] = {0};
__d_args[0] = ___sender0;
__d_args[1] = ___e1;
return (RuntimeObject*)il2cpp_codegen_delegate_begin_invoke((RuntimeDelegate*)__this, __d_args, (RuntimeDelegate*)___callback2, (RuntimeObject*)___object3);
}
// System.Void System.UnhandledExceptionEventHandler::EndInvoke(System.IAsyncResult)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void UnhandledExceptionEventHandler_EndInvoke_m88B666E7047BF8B4CAA5979831CB7C2AB7B87A14 (UnhandledExceptionEventHandler_tB0DFF05ABF7A3A234C87D4F7A71F98E9AB2D91DE * __this, RuntimeObject* ___result0, const RuntimeMethod* method)
{
il2cpp_codegen_delegate_end_invoke((Il2CppAsyncResult*) ___result0, 0);
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.UnitySerializationHolder::GetUnitySerializationInfo(System.Runtime.Serialization.SerializationInfo,System.Reflection.Missing)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void UnitySerializationHolder_GetUnitySerializationInfo_m73DC8BA292A8CD7C89FC189779D656E0A07D4D3D (SerializationInfo_t1BB80E9C9DEA52DBF464487234B045E2930ADA26 * ___info0, Missing_t81434A5DBDCCA844BD22E1659DDE1EE7DE8B4ED7 * ___missing1, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (UnitySerializationHolder_GetUnitySerializationInfo_m73DC8BA292A8CD7C89FC189779D656E0A07D4D3D_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
SerializationInfo_t1BB80E9C9DEA52DBF464487234B045E2930ADA26 * L_0 = ___info0;
RuntimeTypeHandle_t7B542280A22F0EC4EAC2061C29178845847A8B2D L_1 = { reinterpret_cast<intptr_t> (UnitySerializationHolder_t6B17ABB985ACD3F8D9F9E3C146DEA5F730E1CEAC_0_0_0_var) };
IL2CPP_RUNTIME_CLASS_INIT(Type_t_il2cpp_TypeInfo_var);
Type_t * L_2 = Type_GetTypeFromHandle_m9DC58ADF0512987012A8A016FB64B068F3B1AFF6(L_1, /*hidden argument*/NULL);
NullCheck(L_0);
SerializationInfo_SetType_m3F30AFEB3555E20E995D31713C0604E26B2CF784(L_0, L_2, /*hidden argument*/NULL);
SerializationInfo_t1BB80E9C9DEA52DBF464487234B045E2930ADA26 * L_3 = ___info0;
NullCheck(L_3);
SerializationInfo_AddValue_m7C73917D9DC4B8FE4AFEF4BA8EBEDAB046A8D0BD(L_3, _stringLiteralD3B81375F999BE146F923A83BD6CBA9441E1F676, 3, /*hidden argument*/NULL);
return;
}
}
// System.RuntimeType System.UnitySerializationHolder::AddElementTypes(System.Runtime.Serialization.SerializationInfo,System.RuntimeType)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeType_t40F13BCEAD97478C72C4B40BFDC2A220161CDB8F * UnitySerializationHolder_AddElementTypes_m0C8810EE3D2A09BD766FC74C37086846A0268D45 (SerializationInfo_t1BB80E9C9DEA52DBF464487234B045E2930ADA26 * ___info0, RuntimeType_t40F13BCEAD97478C72C4B40BFDC2A220161CDB8F * ___type1, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (UnitySerializationHolder_AddElementTypes_m0C8810EE3D2A09BD766FC74C37086846A0268D45_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
List_1_tE1526161A558A17A39A8B69D8EEF3801393B6226 * V_0 = NULL;
{
List_1_tE1526161A558A17A39A8B69D8EEF3801393B6226 * L_0 = (List_1_tE1526161A558A17A39A8B69D8EEF3801393B6226 *)il2cpp_codegen_object_new(List_1_tE1526161A558A17A39A8B69D8EEF3801393B6226_il2cpp_TypeInfo_var);
List_1__ctor_mA7F9F92F641CEECFD9D8CFDC667568A05FFD27B4(L_0, /*hidden argument*/List_1__ctor_mA7F9F92F641CEECFD9D8CFDC667568A05FFD27B4_RuntimeMethod_var);
V_0 = L_0;
goto IL_0063;
}
IL_0008:
{
RuntimeType_t40F13BCEAD97478C72C4B40BFDC2A220161CDB8F * L_1 = ___type1;
NullCheck(L_1);
bool L_2 = VirtFuncInvoker0< bool >::Invoke(68 /* System.Boolean System.Type::get_IsSzArray() */, L_1);
if (!L_2)
{
goto IL_0019;
}
}
{
List_1_tE1526161A558A17A39A8B69D8EEF3801393B6226 * L_3 = V_0;
NullCheck(L_3);
List_1_Add_m50C0D1F69B2EF31137658E2F052EBBAC7BF82771(L_3, 3, /*hidden argument*/List_1_Add_m50C0D1F69B2EF31137658E2F052EBBAC7BF82771_RuntimeMethod_var);
goto IL_0056;
}
IL_0019:
{
RuntimeType_t40F13BCEAD97478C72C4B40BFDC2A220161CDB8F * L_4 = ___type1;
NullCheck(L_4);
bool L_5 = Type_get_IsArray_m0B4E20F93B1B34C0B5C4B089F543D1AA338DC9FE(L_4, /*hidden argument*/NULL);
if (!L_5)
{
goto IL_0036;
}
}
{
List_1_tE1526161A558A17A39A8B69D8EEF3801393B6226 * L_6 = V_0;
RuntimeType_t40F13BCEAD97478C72C4B40BFDC2A220161CDB8F * L_7 = ___type1;
NullCheck(L_7);
int32_t L_8 = VirtFuncInvoker0< int32_t >::Invoke(28 /* System.Int32 System.Type::GetArrayRank() */, L_7);
NullCheck(L_6);
List_1_Add_m50C0D1F69B2EF31137658E2F052EBBAC7BF82771(L_6, L_8, /*hidden argument*/List_1_Add_m50C0D1F69B2EF31137658E2F052EBBAC7BF82771_RuntimeMethod_var);
List_1_tE1526161A558A17A39A8B69D8EEF3801393B6226 * L_9 = V_0;
NullCheck(L_9);
List_1_Add_m50C0D1F69B2EF31137658E2F052EBBAC7BF82771(L_9, 2, /*hidden argument*/List_1_Add_m50C0D1F69B2EF31137658E2F052EBBAC7BF82771_RuntimeMethod_var);
goto IL_0056;
}
IL_0036:
{
RuntimeType_t40F13BCEAD97478C72C4B40BFDC2A220161CDB8F * L_10 = ___type1;
NullCheck(L_10);
bool L_11 = Type_get_IsPointer_mF823CB662C6A04674589640771E6AD6B71093E57(L_10, /*hidden argument*/NULL);
if (!L_11)
{
goto IL_0047;
}
}
{
List_1_tE1526161A558A17A39A8B69D8EEF3801393B6226 * L_12 = V_0;
NullCheck(L_12);
List_1_Add_m50C0D1F69B2EF31137658E2F052EBBAC7BF82771(L_12, 1, /*hidden argument*/List_1_Add_m50C0D1F69B2EF31137658E2F052EBBAC7BF82771_RuntimeMethod_var);
goto IL_0056;
}
IL_0047:
{
RuntimeType_t40F13BCEAD97478C72C4B40BFDC2A220161CDB8F * L_13 = ___type1;
NullCheck(L_13);
bool L_14 = Type_get_IsByRef_m13C04A998C9B19058B596A81D188B368333D24F8(L_13, /*hidden argument*/NULL);
if (!L_14)
{
goto IL_0056;
}
}
{
List_1_tE1526161A558A17A39A8B69D8EEF3801393B6226 * L_15 = V_0;
NullCheck(L_15);
List_1_Add_m50C0D1F69B2EF31137658E2F052EBBAC7BF82771(L_15, 4, /*hidden argument*/List_1_Add_m50C0D1F69B2EF31137658E2F052EBBAC7BF82771_RuntimeMethod_var);
}
IL_0056:
{
RuntimeType_t40F13BCEAD97478C72C4B40BFDC2A220161CDB8F * L_16 = ___type1;
NullCheck(L_16);
Type_t * L_17 = VirtFuncInvoker0< Type_t * >::Invoke(92 /* System.Type System.Type::GetElementType() */, L_16);
___type1 = ((RuntimeType_t40F13BCEAD97478C72C4B40BFDC2A220161CDB8F *)CastclassClass((RuntimeObject*)L_17, RuntimeType_t40F13BCEAD97478C72C4B40BFDC2A220161CDB8F_il2cpp_TypeInfo_var));
}
IL_0063:
{
RuntimeType_t40F13BCEAD97478C72C4B40BFDC2A220161CDB8F * L_18 = ___type1;
NullCheck(L_18);
bool L_19 = Type_get_HasElementType_m598BEFE66F168CE1D1132C87D394B2EF41F449BF(L_18, /*hidden argument*/NULL);
if (L_19)
{
goto IL_0008;
}
}
{
SerializationInfo_t1BB80E9C9DEA52DBF464487234B045E2930ADA26 * L_20 = ___info0;
List_1_tE1526161A558A17A39A8B69D8EEF3801393B6226 * L_21 = V_0;
NullCheck(L_21);
Int32U5BU5D_t2B9E4FDDDB9F0A00EC0AC631BA2DA915EB1ECF83* L_22 = List_1_ToArray_mFEF088E03E18EF79C06317909C301876B3037D98(L_21, /*hidden argument*/List_1_ToArray_mFEF088E03E18EF79C06317909C301876B3037D98_RuntimeMethod_var);
RuntimeTypeHandle_t7B542280A22F0EC4EAC2061C29178845847A8B2D L_23 = { reinterpret_cast<intptr_t> (Int32U5BU5D_t2B9E4FDDDB9F0A00EC0AC631BA2DA915EB1ECF83_0_0_0_var) };
IL2CPP_RUNTIME_CLASS_INIT(Type_t_il2cpp_TypeInfo_var);
Type_t * L_24 = Type_GetTypeFromHandle_m9DC58ADF0512987012A8A016FB64B068F3B1AFF6(L_23, /*hidden argument*/NULL);
NullCheck(L_20);
SerializationInfo_AddValue_mE0A104C01EFA55A83D4CAE4662A9B4C6459911FC(L_20, _stringLiteralD98E4C3E01D3ED0C6FD51F3FF6F8A3C9CA9223C3, (RuntimeObject *)(RuntimeObject *)L_22, L_24, /*hidden argument*/NULL);
RuntimeType_t40F13BCEAD97478C72C4B40BFDC2A220161CDB8F * L_25 = ___type1;
return L_25;
}
}
// System.Type System.UnitySerializationHolder::MakeElementTypes(System.Type)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Type_t * UnitySerializationHolder_MakeElementTypes_m53847C6D77B4D1F96596279EBF443F521CAD7B24 (UnitySerializationHolder_t6B17ABB985ACD3F8D9F9E3C146DEA5F730E1CEAC * __this, Type_t * ___type0, const RuntimeMethod* method)
{
int32_t V_0 = 0;
{
Int32U5BU5D_t2B9E4FDDDB9F0A00EC0AC631BA2DA915EB1ECF83* L_0 = __this->get_m_elementTypes_1();
NullCheck(L_0);
V_0 = ((int32_t)il2cpp_codegen_subtract((int32_t)(((int32_t)((int32_t)(((RuntimeArray*)L_0)->max_length)))), (int32_t)1));
goto IL_006f;
}
IL_000d:
{
Int32U5BU5D_t2B9E4FDDDB9F0A00EC0AC631BA2DA915EB1ECF83* L_1 = __this->get_m_elementTypes_1();
int32_t L_2 = V_0;
NullCheck(L_1);
int32_t L_3 = L_2;
int32_t L_4 = (L_1)->GetAt(static_cast<il2cpp_array_size_t>(L_3));
if ((!(((uint32_t)L_4) == ((uint32_t)3))))
{
goto IL_0022;
}
}
{
Type_t * L_5 = ___type0;
NullCheck(L_5);
Type_t * L_6 = VirtFuncInvoker0< Type_t * >::Invoke(19 /* System.Type System.Type::MakeArrayType() */, L_5);
___type0 = L_6;
goto IL_006b;
}
IL_0022:
{
Int32U5BU5D_t2B9E4FDDDB9F0A00EC0AC631BA2DA915EB1ECF83* L_7 = __this->get_m_elementTypes_1();
int32_t L_8 = V_0;
NullCheck(L_7);
int32_t L_9 = L_8;
int32_t L_10 = (L_7)->GetAt(static_cast<il2cpp_array_size_t>(L_9));
if ((!(((uint32_t)L_10) == ((uint32_t)2))))
{
goto IL_0043;
}
}
{
Type_t * L_11 = ___type0;
Int32U5BU5D_t2B9E4FDDDB9F0A00EC0AC631BA2DA915EB1ECF83* L_12 = __this->get_m_elementTypes_1();
int32_t L_13 = V_0;
int32_t L_14 = ((int32_t)il2cpp_codegen_subtract((int32_t)L_13, (int32_t)1));
V_0 = L_14;
NullCheck(L_12);
int32_t L_15 = L_14;
int32_t L_16 = (L_12)->GetAt(static_cast<il2cpp_array_size_t>(L_15));
NullCheck(L_11);
Type_t * L_17 = VirtFuncInvoker1< Type_t *, int32_t >::Invoke(20 /* System.Type System.Type::MakeArrayType(System.Int32) */, L_11, L_16);
___type0 = L_17;
goto IL_006b;
}
IL_0043:
{
Int32U5BU5D_t2B9E4FDDDB9F0A00EC0AC631BA2DA915EB1ECF83* L_18 = __this->get_m_elementTypes_1();
int32_t L_19 = V_0;
NullCheck(L_18);
int32_t L_20 = L_19;
int32_t L_21 = (L_18)->GetAt(static_cast<il2cpp_array_size_t>(L_20));
if ((!(((uint32_t)L_21) == ((uint32_t)1))))
{
goto IL_0058;
}
}
{
Type_t * L_22 = ___type0;
NullCheck(L_22);
Type_t * L_23 = VirtFuncInvoker0< Type_t * >::Invoke(17 /* System.Type System.Type::MakePointerType() */, L_22);
___type0 = L_23;
goto IL_006b;
}
IL_0058:
{
Int32U5BU5D_t2B9E4FDDDB9F0A00EC0AC631BA2DA915EB1ECF83* L_24 = __this->get_m_elementTypes_1();
int32_t L_25 = V_0;
NullCheck(L_24);
int32_t L_26 = L_25;
int32_t L_27 = (L_24)->GetAt(static_cast<il2cpp_array_size_t>(L_26));
if ((!(((uint32_t)L_27) == ((uint32_t)4))))
{
goto IL_006b;
}
}
{
Type_t * L_28 = ___type0;
NullCheck(L_28);
Type_t * L_29 = VirtFuncInvoker0< Type_t * >::Invoke(18 /* System.Type System.Type::MakeByRefType() */, L_28);
___type0 = L_29;
}
IL_006b:
{
int32_t L_30 = V_0;
V_0 = ((int32_t)il2cpp_codegen_subtract((int32_t)L_30, (int32_t)1));
}
IL_006f:
{
int32_t L_31 = V_0;
if ((((int32_t)L_31) >= ((int32_t)0)))
{
goto IL_000d;
}
}
{
Type_t * L_32 = ___type0;
return L_32;
}
}
// System.Void System.UnitySerializationHolder::GetUnitySerializationInfo(System.Runtime.Serialization.SerializationInfo,System.RuntimeType)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void UnitySerializationHolder_GetUnitySerializationInfo_m45D2EDC32022880C84BBE25124F5EDCA12B57ED2 (SerializationInfo_t1BB80E9C9DEA52DBF464487234B045E2930ADA26 * ___info0, RuntimeType_t40F13BCEAD97478C72C4B40BFDC2A220161CDB8F * ___type1, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (UnitySerializationHolder_GetUnitySerializationInfo_m45D2EDC32022880C84BBE25124F5EDCA12B57ED2_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
int32_t V_0 = 0;
{
RuntimeType_t40F13BCEAD97478C72C4B40BFDC2A220161CDB8F * L_0 = ___type1;
NullCheck(L_0);
Type_t * L_1 = Type_GetRootElementType_mE4F0579E18FAAEEB2DB86F1315BFBEC1A9A2FD56(L_0, /*hidden argument*/NULL);
NullCheck(L_1);
bool L_2 = VirtFuncInvoker0< bool >::Invoke(71 /* System.Boolean System.Type::get_IsGenericParameter() */, L_1);
if (!L_2)
{
goto IL_007a;
}
}
{
SerializationInfo_t1BB80E9C9DEA52DBF464487234B045E2930ADA26 * L_3 = ___info0;
RuntimeType_t40F13BCEAD97478C72C4B40BFDC2A220161CDB8F * L_4 = ___type1;
RuntimeType_t40F13BCEAD97478C72C4B40BFDC2A220161CDB8F * L_5 = UnitySerializationHolder_AddElementTypes_m0C8810EE3D2A09BD766FC74C37086846A0268D45(L_3, L_4, /*hidden argument*/NULL);
___type1 = L_5;
SerializationInfo_t1BB80E9C9DEA52DBF464487234B045E2930ADA26 * L_6 = ___info0;
RuntimeTypeHandle_t7B542280A22F0EC4EAC2061C29178845847A8B2D L_7 = { reinterpret_cast<intptr_t> (UnitySerializationHolder_t6B17ABB985ACD3F8D9F9E3C146DEA5F730E1CEAC_0_0_0_var) };
IL2CPP_RUNTIME_CLASS_INIT(Type_t_il2cpp_TypeInfo_var);
Type_t * L_8 = Type_GetTypeFromHandle_m9DC58ADF0512987012A8A016FB64B068F3B1AFF6(L_7, /*hidden argument*/NULL);
NullCheck(L_6);
SerializationInfo_SetType_m3F30AFEB3555E20E995D31713C0604E26B2CF784(L_6, L_8, /*hidden argument*/NULL);
SerializationInfo_t1BB80E9C9DEA52DBF464487234B045E2930ADA26 * L_9 = ___info0;
NullCheck(L_9);
SerializationInfo_AddValue_m7C73917D9DC4B8FE4AFEF4BA8EBEDAB046A8D0BD(L_9, _stringLiteralD3B81375F999BE146F923A83BD6CBA9441E1F676, 7, /*hidden argument*/NULL);
SerializationInfo_t1BB80E9C9DEA52DBF464487234B045E2930ADA26 * L_10 = ___info0;
RuntimeType_t40F13BCEAD97478C72C4B40BFDC2A220161CDB8F * L_11 = ___type1;
NullCheck(L_11);
int32_t L_12 = VirtFuncInvoker0< int32_t >::Invoke(72 /* System.Int32 System.Type::get_GenericParameterPosition() */, L_11);
NullCheck(L_10);
SerializationInfo_AddValue_m7C73917D9DC4B8FE4AFEF4BA8EBEDAB046A8D0BD(L_10, _stringLiteral089B0BA8B1E0758ECEBCD291E88238CE548D665D, L_12, /*hidden argument*/NULL);
SerializationInfo_t1BB80E9C9DEA52DBF464487234B045E2930ADA26 * L_13 = ___info0;
RuntimeType_t40F13BCEAD97478C72C4B40BFDC2A220161CDB8F * L_14 = ___type1;
NullCheck(L_14);
MethodBase_t * L_15 = VirtFuncInvoker0< MethodBase_t * >::Invoke(16 /* System.Reflection.MethodBase System.Type::get_DeclaringMethod() */, L_14);
RuntimeTypeHandle_t7B542280A22F0EC4EAC2061C29178845847A8B2D L_16 = { reinterpret_cast<intptr_t> (MethodBase_t_0_0_0_var) };
Type_t * L_17 = Type_GetTypeFromHandle_m9DC58ADF0512987012A8A016FB64B068F3B1AFF6(L_16, /*hidden argument*/NULL);
NullCheck(L_13);
SerializationInfo_AddValue_mE0A104C01EFA55A83D4CAE4662A9B4C6459911FC(L_13, _stringLiteral163313709722AD7AEFE1D71EECEA06F9FCDFEC2D, L_15, L_17, /*hidden argument*/NULL);
SerializationInfo_t1BB80E9C9DEA52DBF464487234B045E2930ADA26 * L_18 = ___info0;
RuntimeType_t40F13BCEAD97478C72C4B40BFDC2A220161CDB8F * L_19 = ___type1;
NullCheck(L_19);
Type_t * L_20 = VirtFuncInvoker0< Type_t * >::Invoke(8 /* System.Type System.Reflection.MemberInfo::get_DeclaringType() */, L_19);
RuntimeTypeHandle_t7B542280A22F0EC4EAC2061C29178845847A8B2D L_21 = { reinterpret_cast<intptr_t> (Type_t_0_0_0_var) };
Type_t * L_22 = Type_GetTypeFromHandle_m9DC58ADF0512987012A8A016FB64B068F3B1AFF6(L_21, /*hidden argument*/NULL);
NullCheck(L_18);
SerializationInfo_AddValue_mE0A104C01EFA55A83D4CAE4662A9B4C6459911FC(L_18, _stringLiteral8110CD10A3C3177EDC45160F406A8FFD951DFD52, L_20, L_22, /*hidden argument*/NULL);
return;
}
IL_007a:
{
V_0 = 4;
RuntimeType_t40F13BCEAD97478C72C4B40BFDC2A220161CDB8F * L_23 = ___type1;
NullCheck(L_23);
bool L_24 = VirtFuncInvoker0< bool >::Invoke(70 /* System.Boolean System.Type::get_IsGenericTypeDefinition() */, L_23);
if (L_24)
{
goto IL_00bf;
}
}
{
RuntimeType_t40F13BCEAD97478C72C4B40BFDC2A220161CDB8F * L_25 = ___type1;
NullCheck(L_25);
bool L_26 = VirtFuncInvoker0< bool >::Invoke(73 /* System.Boolean System.Type::get_ContainsGenericParameters() */, L_25);
if (!L_26)
{
goto IL_00bf;
}
}
{
V_0 = 8;
SerializationInfo_t1BB80E9C9DEA52DBF464487234B045E2930ADA26 * L_27 = ___info0;
RuntimeType_t40F13BCEAD97478C72C4B40BFDC2A220161CDB8F * L_28 = ___type1;
RuntimeType_t40F13BCEAD97478C72C4B40BFDC2A220161CDB8F * L_29 = UnitySerializationHolder_AddElementTypes_m0C8810EE3D2A09BD766FC74C37086846A0268D45(L_27, L_28, /*hidden argument*/NULL);
___type1 = L_29;
SerializationInfo_t1BB80E9C9DEA52DBF464487234B045E2930ADA26 * L_30 = ___info0;
RuntimeType_t40F13BCEAD97478C72C4B40BFDC2A220161CDB8F * L_31 = ___type1;
NullCheck(L_31);
TypeU5BU5D_t7FE623A666B49176DE123306221193E888A12F5F* L_32 = VirtFuncInvoker0< TypeU5BU5D_t7FE623A666B49176DE123306221193E888A12F5F* >::Invoke(93 /* System.Type[] System.Type::GetGenericArguments() */, L_31);
RuntimeTypeHandle_t7B542280A22F0EC4EAC2061C29178845847A8B2D L_33 = { reinterpret_cast<intptr_t> (TypeU5BU5D_t7FE623A666B49176DE123306221193E888A12F5F_0_0_0_var) };
IL2CPP_RUNTIME_CLASS_INIT(Type_t_il2cpp_TypeInfo_var);
Type_t * L_34 = Type_GetTypeFromHandle_m9DC58ADF0512987012A8A016FB64B068F3B1AFF6(L_33, /*hidden argument*/NULL);
NullCheck(L_30);
SerializationInfo_AddValue_mE0A104C01EFA55A83D4CAE4662A9B4C6459911FC(L_30, _stringLiteralF221811315A6A4EB975642C56E41ECFB1B78BF7A, (RuntimeObject *)(RuntimeObject *)L_32, L_34, /*hidden argument*/NULL);
RuntimeType_t40F13BCEAD97478C72C4B40BFDC2A220161CDB8F * L_35 = ___type1;
NullCheck(L_35);
Type_t * L_36 = VirtFuncInvoker0< Type_t * >::Invoke(94 /* System.Type System.Type::GetGenericTypeDefinition() */, L_35);
___type1 = ((RuntimeType_t40F13BCEAD97478C72C4B40BFDC2A220161CDB8F *)CastclassClass((RuntimeObject*)L_36, RuntimeType_t40F13BCEAD97478C72C4B40BFDC2A220161CDB8F_il2cpp_TypeInfo_var));
}
IL_00bf:
{
SerializationInfo_t1BB80E9C9DEA52DBF464487234B045E2930ADA26 * L_37 = ___info0;
int32_t L_38 = V_0;
RuntimeType_t40F13BCEAD97478C72C4B40BFDC2A220161CDB8F * L_39 = ___type1;
NullCheck(L_39);
String_t* L_40 = VirtFuncInvoker0< String_t* >::Invoke(25 /* System.String System.Type::get_FullName() */, L_39);
RuntimeType_t40F13BCEAD97478C72C4B40BFDC2A220161CDB8F * L_41 = ___type1;
NullCheck(L_41);
RuntimeAssembly_t5EE9CD749D82345AE5635B9665665C31A3308EB1 * L_42 = RuntimeType_GetRuntimeAssembly_m34E13B557A24CE6438916C08EC329EFD16AEBAE4(L_41, /*hidden argument*/NULL);
UnitySerializationHolder_GetUnitySerializationInfo_m86F654140996546DB4D6D8228BF9FE45E9BAEC3E(L_37, L_38, L_40, L_42, /*hidden argument*/NULL);
return;
}
}
// System.Void System.UnitySerializationHolder::GetUnitySerializationInfo(System.Runtime.Serialization.SerializationInfo,System.Int32,System.String,System.Reflection.RuntimeAssembly)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void UnitySerializationHolder_GetUnitySerializationInfo_m86F654140996546DB4D6D8228BF9FE45E9BAEC3E (SerializationInfo_t1BB80E9C9DEA52DBF464487234B045E2930ADA26 * ___info0, int32_t ___unityType1, String_t* ___data2, RuntimeAssembly_t5EE9CD749D82345AE5635B9665665C31A3308EB1 * ___assembly3, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (UnitySerializationHolder_GetUnitySerializationInfo_m86F654140996546DB4D6D8228BF9FE45E9BAEC3E_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
String_t* V_0 = NULL;
{
SerializationInfo_t1BB80E9C9DEA52DBF464487234B045E2930ADA26 * L_0 = ___info0;
RuntimeTypeHandle_t7B542280A22F0EC4EAC2061C29178845847A8B2D L_1 = { reinterpret_cast<intptr_t> (UnitySerializationHolder_t6B17ABB985ACD3F8D9F9E3C146DEA5F730E1CEAC_0_0_0_var) };
IL2CPP_RUNTIME_CLASS_INIT(Type_t_il2cpp_TypeInfo_var);
Type_t * L_2 = Type_GetTypeFromHandle_m9DC58ADF0512987012A8A016FB64B068F3B1AFF6(L_1, /*hidden argument*/NULL);
NullCheck(L_0);
SerializationInfo_SetType_m3F30AFEB3555E20E995D31713C0604E26B2CF784(L_0, L_2, /*hidden argument*/NULL);
SerializationInfo_t1BB80E9C9DEA52DBF464487234B045E2930ADA26 * L_3 = ___info0;
String_t* L_4 = ___data2;
RuntimeTypeHandle_t7B542280A22F0EC4EAC2061C29178845847A8B2D L_5 = { reinterpret_cast<intptr_t> (String_t_0_0_0_var) };
Type_t * L_6 = Type_GetTypeFromHandle_m9DC58ADF0512987012A8A016FB64B068F3B1AFF6(L_5, /*hidden argument*/NULL);
NullCheck(L_3);
SerializationInfo_AddValue_mE0A104C01EFA55A83D4CAE4662A9B4C6459911FC(L_3, _stringLiteralE5E429BCC9C2E4A41A3C7A4D96203BE6CB273B11, L_4, L_6, /*hidden argument*/NULL);
SerializationInfo_t1BB80E9C9DEA52DBF464487234B045E2930ADA26 * L_7 = ___info0;
int32_t L_8 = ___unityType1;
NullCheck(L_7);
SerializationInfo_AddValue_m7C73917D9DC4B8FE4AFEF4BA8EBEDAB046A8D0BD(L_7, _stringLiteralD3B81375F999BE146F923A83BD6CBA9441E1F676, L_8, /*hidden argument*/NULL);
RuntimeAssembly_t5EE9CD749D82345AE5635B9665665C31A3308EB1 * L_9 = ___assembly3;
bool L_10 = Assembly_op_Equality_m4B6A318CE4104781ABF30A2BBBCCCFB0FE342316(L_9, (Assembly_t *)NULL, /*hidden argument*/NULL);
if (!L_10)
{
goto IL_0043;
}
}
{
String_t* L_11 = ((String_t_StaticFields*)il2cpp_codegen_static_fields_for(String_t_il2cpp_TypeInfo_var))->get_Empty_5();
V_0 = L_11;
goto IL_004a;
}
IL_0043:
{
RuntimeAssembly_t5EE9CD749D82345AE5635B9665665C31A3308EB1 * L_12 = ___assembly3;
NullCheck(L_12);
String_t* L_13 = VirtFuncInvoker0< String_t* >::Invoke(8 /* System.String System.Reflection.Assembly::get_FullName() */, L_12);
V_0 = L_13;
}
IL_004a:
{
SerializationInfo_t1BB80E9C9DEA52DBF464487234B045E2930ADA26 * L_14 = ___info0;
String_t* L_15 = V_0;
NullCheck(L_14);
SerializationInfo_AddValue_mC9D1E16476E24E1AFE7C59368D3BC0B35F64FBC6(L_14, _stringLiteralF0541457E2B7EF76AA2DDC177C44B4FF6B95E9C5, L_15, /*hidden argument*/NULL);
return;
}
}
// System.Void System.UnitySerializationHolder::.ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void UnitySerializationHolder__ctor_m2DBB21E6B4107323DB20C23AD6D9290F50BF2B1E (UnitySerializationHolder_t6B17ABB985ACD3F8D9F9E3C146DEA5F730E1CEAC * __this, SerializationInfo_t1BB80E9C9DEA52DBF464487234B045E2930ADA26 * ___info0, StreamingContext_t2CCDC54E0E8D078AF4A50E3A8B921B828A900034 ___context1, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (UnitySerializationHolder__ctor_m2DBB21E6B4107323DB20C23AD6D9290F50BF2B1E_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
Object__ctor_m925ECA5E85CA100E3FB86A4F9E15C120E9A184C0(__this, /*hidden argument*/NULL);
SerializationInfo_t1BB80E9C9DEA52DBF464487234B045E2930ADA26 * L_0 = ___info0;
if (L_0)
{
goto IL_0014;
}
}
{
ArgumentNullException_t581DF992B1F3E0EC6EFB30CC5DC43519A79B27AD * L_1 = (ArgumentNullException_t581DF992B1F3E0EC6EFB30CC5DC43519A79B27AD *)il2cpp_codegen_object_new(ArgumentNullException_t581DF992B1F3E0EC6EFB30CC5DC43519A79B27AD_il2cpp_TypeInfo_var);
ArgumentNullException__ctor_mEE0C0D6FCB2D08CD7967DBB1329A0854BBED49ED(L_1, _stringLiteral59BD0A3FF43B32849B319E645D4798D8A5D1E889, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_1, NULL, UnitySerializationHolder__ctor_m2DBB21E6B4107323DB20C23AD6D9290F50BF2B1E_RuntimeMethod_var);
}
IL_0014:
{
SerializationInfo_t1BB80E9C9DEA52DBF464487234B045E2930ADA26 * L_2 = ___info0;
NullCheck(L_2);
int32_t L_3 = SerializationInfo_GetInt32_mB47BD46A0BDBBAF5B47BB62E6EFF8E092E3F3656(L_2, _stringLiteralD3B81375F999BE146F923A83BD6CBA9441E1F676, /*hidden argument*/NULL);
__this->set_m_unityType_7(L_3);
int32_t L_4 = __this->get_m_unityType_7();
if ((!(((uint32_t)L_4) == ((uint32_t)3))))
{
goto IL_002f;
}
}
{
return;
}
IL_002f:
{
int32_t L_5 = __this->get_m_unityType_7();
if ((!(((uint32_t)L_5) == ((uint32_t)7))))
{
goto IL_00aa;
}
}
{
SerializationInfo_t1BB80E9C9DEA52DBF464487234B045E2930ADA26 * L_6 = ___info0;
RuntimeTypeHandle_t7B542280A22F0EC4EAC2061C29178845847A8B2D L_7 = { reinterpret_cast<intptr_t> (MethodBase_t_0_0_0_var) };
IL2CPP_RUNTIME_CLASS_INIT(Type_t_il2cpp_TypeInfo_var);
Type_t * L_8 = Type_GetTypeFromHandle_m9DC58ADF0512987012A8A016FB64B068F3B1AFF6(L_7, /*hidden argument*/NULL);
NullCheck(L_6);
RuntimeObject * L_9 = SerializationInfo_GetValue_m7910CE6C68888C1F863D7A35915391FA33463ECF(L_6, _stringLiteral163313709722AD7AEFE1D71EECEA06F9FCDFEC2D, L_8, /*hidden argument*/NULL);
__this->set_m_declaringMethod_4(((MethodBase_t *)IsInstClass((RuntimeObject*)L_9, MethodBase_t_il2cpp_TypeInfo_var)));
SerializationInfo_t1BB80E9C9DEA52DBF464487234B045E2930ADA26 * L_10 = ___info0;
RuntimeTypeHandle_t7B542280A22F0EC4EAC2061C29178845847A8B2D L_11 = { reinterpret_cast<intptr_t> (Type_t_0_0_0_var) };
Type_t * L_12 = Type_GetTypeFromHandle_m9DC58ADF0512987012A8A016FB64B068F3B1AFF6(L_11, /*hidden argument*/NULL);
NullCheck(L_10);
RuntimeObject * L_13 = SerializationInfo_GetValue_m7910CE6C68888C1F863D7A35915391FA33463ECF(L_10, _stringLiteral8110CD10A3C3177EDC45160F406A8FFD951DFD52, L_12, /*hidden argument*/NULL);
__this->set_m_declaringType_3(((Type_t *)IsInstClass((RuntimeObject*)L_13, Type_t_il2cpp_TypeInfo_var)));
SerializationInfo_t1BB80E9C9DEA52DBF464487234B045E2930ADA26 * L_14 = ___info0;
NullCheck(L_14);
int32_t L_15 = SerializationInfo_GetInt32_mB47BD46A0BDBBAF5B47BB62E6EFF8E092E3F3656(L_14, _stringLiteral089B0BA8B1E0758ECEBCD291E88238CE548D665D, /*hidden argument*/NULL);
__this->set_m_genericParameterPosition_2(L_15);
SerializationInfo_t1BB80E9C9DEA52DBF464487234B045E2930ADA26 * L_16 = ___info0;
RuntimeTypeHandle_t7B542280A22F0EC4EAC2061C29178845847A8B2D L_17 = { reinterpret_cast<intptr_t> (Int32U5BU5D_t2B9E4FDDDB9F0A00EC0AC631BA2DA915EB1ECF83_0_0_0_var) };
Type_t * L_18 = Type_GetTypeFromHandle_m9DC58ADF0512987012A8A016FB64B068F3B1AFF6(L_17, /*hidden argument*/NULL);
NullCheck(L_16);
RuntimeObject * L_19 = SerializationInfo_GetValue_m7910CE6C68888C1F863D7A35915391FA33463ECF(L_16, _stringLiteralD98E4C3E01D3ED0C6FD51F3FF6F8A3C9CA9223C3, L_18, /*hidden argument*/NULL);
__this->set_m_elementTypes_1(((Int32U5BU5D_t2B9E4FDDDB9F0A00EC0AC631BA2DA915EB1ECF83*)IsInst((RuntimeObject*)L_19, Int32U5BU5D_t2B9E4FDDDB9F0A00EC0AC631BA2DA915EB1ECF83_il2cpp_TypeInfo_var)));
return;
}
IL_00aa:
{
int32_t L_20 = __this->get_m_unityType_7();
if ((!(((uint32_t)L_20) == ((uint32_t)8))))
{
goto IL_00f3;
}
}
{
SerializationInfo_t1BB80E9C9DEA52DBF464487234B045E2930ADA26 * L_21 = ___info0;
RuntimeTypeHandle_t7B542280A22F0EC4EAC2061C29178845847A8B2D L_22 = { reinterpret_cast<intptr_t> (TypeU5BU5D_t7FE623A666B49176DE123306221193E888A12F5F_0_0_0_var) };
IL2CPP_RUNTIME_CLASS_INIT(Type_t_il2cpp_TypeInfo_var);
Type_t * L_23 = Type_GetTypeFromHandle_m9DC58ADF0512987012A8A016FB64B068F3B1AFF6(L_22, /*hidden argument*/NULL);
NullCheck(L_21);
RuntimeObject * L_24 = SerializationInfo_GetValue_m7910CE6C68888C1F863D7A35915391FA33463ECF(L_21, _stringLiteralF221811315A6A4EB975642C56E41ECFB1B78BF7A, L_23, /*hidden argument*/NULL);
__this->set_m_instantiation_0(((TypeU5BU5D_t7FE623A666B49176DE123306221193E888A12F5F*)IsInst((RuntimeObject*)L_24, TypeU5BU5D_t7FE623A666B49176DE123306221193E888A12F5F_il2cpp_TypeInfo_var)));
SerializationInfo_t1BB80E9C9DEA52DBF464487234B045E2930ADA26 * L_25 = ___info0;
RuntimeTypeHandle_t7B542280A22F0EC4EAC2061C29178845847A8B2D L_26 = { reinterpret_cast<intptr_t> (Int32U5BU5D_t2B9E4FDDDB9F0A00EC0AC631BA2DA915EB1ECF83_0_0_0_var) };
Type_t * L_27 = Type_GetTypeFromHandle_m9DC58ADF0512987012A8A016FB64B068F3B1AFF6(L_26, /*hidden argument*/NULL);
NullCheck(L_25);
RuntimeObject * L_28 = SerializationInfo_GetValue_m7910CE6C68888C1F863D7A35915391FA33463ECF(L_25, _stringLiteralD98E4C3E01D3ED0C6FD51F3FF6F8A3C9CA9223C3, L_27, /*hidden argument*/NULL);
__this->set_m_elementTypes_1(((Int32U5BU5D_t2B9E4FDDDB9F0A00EC0AC631BA2DA915EB1ECF83*)IsInst((RuntimeObject*)L_28, Int32U5BU5D_t2B9E4FDDDB9F0A00EC0AC631BA2DA915EB1ECF83_il2cpp_TypeInfo_var)));
}
IL_00f3:
{
SerializationInfo_t1BB80E9C9DEA52DBF464487234B045E2930ADA26 * L_29 = ___info0;
NullCheck(L_29);
String_t* L_30 = SerializationInfo_GetString_m06805A4E368E0B98D5FA70A9333B277CBDD84CF4(L_29, _stringLiteralE5E429BCC9C2E4A41A3C7A4D96203BE6CB273B11, /*hidden argument*/NULL);
__this->set_m_data_5(L_30);
SerializationInfo_t1BB80E9C9DEA52DBF464487234B045E2930ADA26 * L_31 = ___info0;
NullCheck(L_31);
String_t* L_32 = SerializationInfo_GetString_m06805A4E368E0B98D5FA70A9333B277CBDD84CF4(L_31, _stringLiteralF0541457E2B7EF76AA2DDC177C44B4FF6B95E9C5, /*hidden argument*/NULL);
__this->set_m_assemblyName_6(L_32);
return;
}
}
// System.Void System.UnitySerializationHolder::ThrowInsufficientInformation(System.String)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void UnitySerializationHolder_ThrowInsufficientInformation_mC9EC8B972B617DB4A56CC8BAF3B814ACF0E7A7EE (UnitySerializationHolder_t6B17ABB985ACD3F8D9F9E3C146DEA5F730E1CEAC * __this, String_t* ___field0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (UnitySerializationHolder_ThrowInsufficientInformation_mC9EC8B972B617DB4A56CC8BAF3B814ACF0E7A7EE_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
ObjectU5BU5D_t3C9242B5C88A48B2A5BD9FDA6CD0024E792AF08A* L_0 = (ObjectU5BU5D_t3C9242B5C88A48B2A5BD9FDA6CD0024E792AF08A*)(ObjectU5BU5D_t3C9242B5C88A48B2A5BD9FDA6CD0024E792AF08A*)SZArrayNew(ObjectU5BU5D_t3C9242B5C88A48B2A5BD9FDA6CD0024E792AF08A_il2cpp_TypeInfo_var, (uint32_t)1);
ObjectU5BU5D_t3C9242B5C88A48B2A5BD9FDA6CD0024E792AF08A* L_1 = L_0;
String_t* L_2 = ___field0;
NullCheck(L_1);
ArrayElementTypeCheck (L_1, L_2);
(L_1)->SetAt(static_cast<il2cpp_array_size_t>(0), (RuntimeObject *)L_2);
String_t* L_3 = Environment_GetResourceString_m7389941B4C0688D875CC647D99A739DA2F907ADB(_stringLiteral9B7256A537E36FBE0EFCE164ED58060E7D8F006C, L_1, /*hidden argument*/NULL);
SerializationException_tA1FDFF6779406E688C2192E71C38DBFD7A4A2210 * L_4 = (SerializationException_tA1FDFF6779406E688C2192E71C38DBFD7A4A2210 *)il2cpp_codegen_object_new(SerializationException_tA1FDFF6779406E688C2192E71C38DBFD7A4A2210_il2cpp_TypeInfo_var);
SerializationException__ctor_m88AAD9671030A8A96AA87CB95701938FBD8F16E1(L_4, L_3, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_4, NULL, UnitySerializationHolder_ThrowInsufficientInformation_mC9EC8B972B617DB4A56CC8BAF3B814ACF0E7A7EE_RuntimeMethod_var);
}
}
// System.Void System.UnitySerializationHolder::GetObjectData(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void UnitySerializationHolder_GetObjectData_m7562EAA093BA2732DED6A3D94E676EEAAC1D8310 (UnitySerializationHolder_t6B17ABB985ACD3F8D9F9E3C146DEA5F730E1CEAC * __this, SerializationInfo_t1BB80E9C9DEA52DBF464487234B045E2930ADA26 * ___info0, StreamingContext_t2CCDC54E0E8D078AF4A50E3A8B921B828A900034 ___context1, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (UnitySerializationHolder_GetObjectData_m7562EAA093BA2732DED6A3D94E676EEAAC1D8310_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
String_t* L_0 = Environment_GetResourceString_m2C75C2AF268F01E2BF34AD1C2E1352CF4BA51AD9(_stringLiteral04C3F2AE89DF36B5CF6D0051651235DA171DFEE7, /*hidden argument*/NULL);
NotSupportedException_tE75B318D6590A02A5D9B29FD97409B1750FA0010 * L_1 = (NotSupportedException_tE75B318D6590A02A5D9B29FD97409B1750FA0010 *)il2cpp_codegen_object_new(NotSupportedException_tE75B318D6590A02A5D9B29FD97409B1750FA0010_il2cpp_TypeInfo_var);
NotSupportedException__ctor_mD023A89A5C1F740F43F0A9CD6C49DC21230B3CEE(L_1, L_0, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_1, NULL, UnitySerializationHolder_GetObjectData_m7562EAA093BA2732DED6A3D94E676EEAAC1D8310_RuntimeMethod_var);
}
}
// System.Object System.UnitySerializationHolder::GetRealObject(System.Runtime.Serialization.StreamingContext)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * UnitySerializationHolder_GetRealObject_mB8BD0D19FE747C6B7F739F9686AA52CBA9E6FA9E (UnitySerializationHolder_t6B17ABB985ACD3F8D9F9E3C146DEA5F730E1CEAC * __this, StreamingContext_t2CCDC54E0E8D078AF4A50E3A8B921B828A900034 ___context0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (UnitySerializationHolder_GetRealObject_mB8BD0D19FE747C6B7F739F9686AA52CBA9E6FA9E_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
int32_t V_0 = 0;
Type_t * V_1 = NULL;
Module_t882FB0C491B9CD194BE7CD1AC62FEFB31EEBE5D7 * V_2 = NULL;
{
int32_t L_0 = __this->get_m_unityType_7();
V_0 = L_0;
int32_t L_1 = V_0;
switch (((int32_t)il2cpp_codegen_subtract((int32_t)L_1, (int32_t)1)))
{
case 0:
{
goto IL_0034;
}
case 1:
{
goto IL_003a;
}
case 2:
{
goto IL_0040;
}
case 3:
{
goto IL_00e7;
}
case 4:
{
goto IL_014e;
}
case 5:
{
goto IL_01cb;
}
case 6:
{
goto IL_0086;
}
case 7:
{
goto IL_0046;
}
}
}
{
goto IL_020a;
}
IL_0034:
{
IL2CPP_RUNTIME_CLASS_INIT(Empty_t31C7ECDF7D102AFFCE029D8AB11D8595F0316ED2_il2cpp_TypeInfo_var);
Empty_t31C7ECDF7D102AFFCE029D8AB11D8595F0316ED2 * L_2 = ((Empty_t31C7ECDF7D102AFFCE029D8AB11D8595F0316ED2_StaticFields*)il2cpp_codegen_static_fields_for(Empty_t31C7ECDF7D102AFFCE029D8AB11D8595F0316ED2_il2cpp_TypeInfo_var))->get_Value_0();
return L_2;
}
IL_003a:
{
IL2CPP_RUNTIME_CLASS_INIT(DBNull_t7400E04939C2C29699B389B106997892BF53A8E5_il2cpp_TypeInfo_var);
DBNull_t7400E04939C2C29699B389B106997892BF53A8E5 * L_3 = ((DBNull_t7400E04939C2C29699B389B106997892BF53A8E5_StaticFields*)il2cpp_codegen_static_fields_for(DBNull_t7400E04939C2C29699B389B106997892BF53A8E5_il2cpp_TypeInfo_var))->get_Value_0();
return L_3;
}
IL_0040:
{
IL2CPP_RUNTIME_CLASS_INIT(Missing_t81434A5DBDCCA844BD22E1659DDE1EE7DE8B4ED7_il2cpp_TypeInfo_var);
Missing_t81434A5DBDCCA844BD22E1659DDE1EE7DE8B4ED7 * L_4 = ((Missing_t81434A5DBDCCA844BD22E1659DDE1EE7DE8B4ED7_StaticFields*)il2cpp_codegen_static_fields_for(Missing_t81434A5DBDCCA844BD22E1659DDE1EE7DE8B4ED7_il2cpp_TypeInfo_var))->get_Value_0();
return L_4;
}
IL_0046:
{
__this->set_m_unityType_7(4);
StreamingContext_t2CCDC54E0E8D078AF4A50E3A8B921B828A900034 L_5 = ___context0;
RuntimeObject * L_6 = VirtFuncInvoker1< RuntimeObject *, StreamingContext_t2CCDC54E0E8D078AF4A50E3A8B921B828A900034 >::Invoke(7 /* System.Object System.UnitySerializationHolder::GetRealObject(System.Runtime.Serialization.StreamingContext) */, __this, L_5);
V_1 = ((Type_t *)IsInstClass((RuntimeObject*)L_6, Type_t_il2cpp_TypeInfo_var));
__this->set_m_unityType_7(8);
TypeU5BU5D_t7FE623A666B49176DE123306221193E888A12F5F* L_7 = __this->get_m_instantiation_0();
NullCheck(L_7);
int32_t L_8 = 0;
Type_t * L_9 = (L_7)->GetAt(static_cast<il2cpp_array_size_t>(L_8));
IL2CPP_RUNTIME_CLASS_INIT(Type_t_il2cpp_TypeInfo_var);
bool L_10 = Type_op_Equality_m7040622C9E1037EFC73E1F0EDB1DD241282BE3D8(L_9, (Type_t *)NULL, /*hidden argument*/NULL);
if (!L_10)
{
goto IL_0073;
}
}
{
return NULL;
}
IL_0073:
{
Type_t * L_11 = V_1;
TypeU5BU5D_t7FE623A666B49176DE123306221193E888A12F5F* L_12 = __this->get_m_instantiation_0();
NullCheck(L_11);
Type_t * L_13 = VirtFuncInvoker1< Type_t *, TypeU5BU5D_t7FE623A666B49176DE123306221193E888A12F5F* >::Invoke(89 /* System.Type System.Type::MakeGenericType(System.Type[]) */, L_11, L_12);
Type_t * L_14 = UnitySerializationHolder_MakeElementTypes_m53847C6D77B4D1F96596279EBF443F521CAD7B24(__this, L_13, /*hidden argument*/NULL);
return L_14;
}
IL_0086:
{
MethodBase_t * L_15 = __this->get_m_declaringMethod_4();
bool L_16 = MethodBase_op_Equality_mB2519FFC5324C515ED0181B94A3FA5D6FE99D736(L_15, (MethodBase_t *)NULL, /*hidden argument*/NULL);
if (!L_16)
{
goto IL_00ad;
}
}
{
Type_t * L_17 = __this->get_m_declaringType_3();
IL2CPP_RUNTIME_CLASS_INIT(Type_t_il2cpp_TypeInfo_var);
bool L_18 = Type_op_Equality_m7040622C9E1037EFC73E1F0EDB1DD241282BE3D8(L_17, (Type_t *)NULL, /*hidden argument*/NULL);
if (!L_18)
{
goto IL_00ad;
}
}
{
UnitySerializationHolder_ThrowInsufficientInformation_mC9EC8B972B617DB4A56CC8BAF3B814ACF0E7A7EE(__this, _stringLiteralD41884932BDB9E7E6E2E6DB3F0FFD3968A302E6B, /*hidden argument*/NULL);
}
IL_00ad:
{
MethodBase_t * L_19 = __this->get_m_declaringMethod_4();
bool L_20 = MethodBase_op_Inequality_mA03AE708DD0D76404AED7C36A75741E2A6BC6BF7(L_19, (MethodBase_t *)NULL, /*hidden argument*/NULL);
if (!L_20)
{
goto IL_00ce;
}
}
{
MethodBase_t * L_21 = __this->get_m_declaringMethod_4();
NullCheck(L_21);
TypeU5BU5D_t7FE623A666B49176DE123306221193E888A12F5F* L_22 = VirtFuncInvoker0< TypeU5BU5D_t7FE623A666B49176DE123306221193E888A12F5F* >::Invoke(23 /* System.Type[] System.Reflection.MethodBase::GetGenericArguments() */, L_21);
int32_t L_23 = __this->get_m_genericParameterPosition_2();
NullCheck(L_22);
int32_t L_24 = L_23;
Type_t * L_25 = (L_22)->GetAt(static_cast<il2cpp_array_size_t>(L_24));
return L_25;
}
IL_00ce:
{
Type_t * L_26 = __this->get_m_declaringType_3();
NullCheck(L_26);
TypeU5BU5D_t7FE623A666B49176DE123306221193E888A12F5F* L_27 = VirtFuncInvoker0< TypeU5BU5D_t7FE623A666B49176DE123306221193E888A12F5F* >::Invoke(93 /* System.Type[] System.Type::GetGenericArguments() */, L_26);
int32_t L_28 = __this->get_m_genericParameterPosition_2();
NullCheck(L_27);
int32_t L_29 = L_28;
Type_t * L_30 = (L_27)->GetAt(static_cast<il2cpp_array_size_t>(L_29));
Type_t * L_31 = UnitySerializationHolder_MakeElementTypes_m53847C6D77B4D1F96596279EBF443F521CAD7B24(__this, L_30, /*hidden argument*/NULL);
return L_31;
}
IL_00e7:
{
String_t* L_32 = __this->get_m_data_5();
if (!L_32)
{
goto IL_00fc;
}
}
{
String_t* L_33 = __this->get_m_data_5();
NullCheck(L_33);
int32_t L_34 = String_get_Length_mD48C8A16A5CF1914F330DCE82D9BE15C3BEDD018(L_33, /*hidden argument*/NULL);
if (L_34)
{
goto IL_0107;
}
}
IL_00fc:
{
UnitySerializationHolder_ThrowInsufficientInformation_mC9EC8B972B617DB4A56CC8BAF3B814ACF0E7A7EE(__this, _stringLiteralE5E429BCC9C2E4A41A3C7A4D96203BE6CB273B11, /*hidden argument*/NULL);
}
IL_0107:
{
String_t* L_35 = __this->get_m_assemblyName_6();
if (L_35)
{
goto IL_011a;
}
}
{
UnitySerializationHolder_ThrowInsufficientInformation_mC9EC8B972B617DB4A56CC8BAF3B814ACF0E7A7EE(__this, _stringLiteralF0541457E2B7EF76AA2DDC177C44B4FF6B95E9C5, /*hidden argument*/NULL);
}
IL_011a:
{
String_t* L_36 = __this->get_m_assemblyName_6();
NullCheck(L_36);
int32_t L_37 = String_get_Length_mD48C8A16A5CF1914F330DCE82D9BE15C3BEDD018(L_36, /*hidden argument*/NULL);
if (L_37)
{
goto IL_0135;
}
}
{
String_t* L_38 = __this->get_m_data_5();
IL2CPP_RUNTIME_CLASS_INIT(Type_t_il2cpp_TypeInfo_var);
Type_t * L_39 = il2cpp_codegen_get_type((Il2CppMethodPointer)&Type_GetType_m77EF3A5A858B45C53D8BF27C74FA00CA83B53E59, L_38, (bool)1, (bool)0, "mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089");
return L_39;
}
IL_0135:
{
String_t* L_40 = __this->get_m_assemblyName_6();
Assembly_t * L_41 = Assembly_Load_m4640304E91781FC3D197CD014B0C2DCEAFCFFF55(L_40, /*hidden argument*/NULL);
String_t* L_42 = __this->get_m_data_5();
NullCheck(L_41);
Type_t * L_43 = VirtFuncInvoker3< Type_t *, String_t*, bool, bool >::Invoke(18 /* System.Type System.Reflection.Assembly::GetType(System.String,System.Boolean,System.Boolean) */, L_41, L_42, (bool)1, (bool)0);
return L_43;
}
IL_014e:
{
String_t* L_44 = __this->get_m_data_5();
if (!L_44)
{
goto IL_0163;
}
}
{
String_t* L_45 = __this->get_m_data_5();
NullCheck(L_45);
int32_t L_46 = String_get_Length_mD48C8A16A5CF1914F330DCE82D9BE15C3BEDD018(L_45, /*hidden argument*/NULL);
if (L_46)
{
goto IL_016e;
}
}
IL_0163:
{
UnitySerializationHolder_ThrowInsufficientInformation_mC9EC8B972B617DB4A56CC8BAF3B814ACF0E7A7EE(__this, _stringLiteralE5E429BCC9C2E4A41A3C7A4D96203BE6CB273B11, /*hidden argument*/NULL);
}
IL_016e:
{
String_t* L_47 = __this->get_m_assemblyName_6();
if (L_47)
{
goto IL_0181;
}
}
{
UnitySerializationHolder_ThrowInsufficientInformation_mC9EC8B972B617DB4A56CC8BAF3B814ACF0E7A7EE(__this, _stringLiteralF0541457E2B7EF76AA2DDC177C44B4FF6B95E9C5, /*hidden argument*/NULL);
}
IL_0181:
{
String_t* L_48 = __this->get_m_assemblyName_6();
Assembly_t * L_49 = Assembly_Load_m4640304E91781FC3D197CD014B0C2DCEAFCFFF55(L_48, /*hidden argument*/NULL);
String_t* L_50 = __this->get_m_data_5();
NullCheck(L_49);
Module_t882FB0C491B9CD194BE7CD1AC62FEFB31EEBE5D7 * L_51 = VirtFuncInvoker1< Module_t882FB0C491B9CD194BE7CD1AC62FEFB31EEBE5D7 *, String_t* >::Invoke(19 /* System.Reflection.Module System.Reflection.Assembly::GetModule(System.String) */, L_49, L_50);
V_2 = L_51;
Module_t882FB0C491B9CD194BE7CD1AC62FEFB31EEBE5D7 * L_52 = V_2;
IL2CPP_RUNTIME_CLASS_INIT(Module_t882FB0C491B9CD194BE7CD1AC62FEFB31EEBE5D7_il2cpp_TypeInfo_var);
bool L_53 = Module_op_Equality_m3AEF6BCA2C1DA42DEF271D9C168AD6F5DFFA497A(L_52, (Module_t882FB0C491B9CD194BE7CD1AC62FEFB31EEBE5D7 *)NULL, /*hidden argument*/NULL);
if (!L_53)
{
goto IL_01c9;
}
}
{
ObjectU5BU5D_t3C9242B5C88A48B2A5BD9FDA6CD0024E792AF08A* L_54 = (ObjectU5BU5D_t3C9242B5C88A48B2A5BD9FDA6CD0024E792AF08A*)(ObjectU5BU5D_t3C9242B5C88A48B2A5BD9FDA6CD0024E792AF08A*)SZArrayNew(ObjectU5BU5D_t3C9242B5C88A48B2A5BD9FDA6CD0024E792AF08A_il2cpp_TypeInfo_var, (uint32_t)2);
ObjectU5BU5D_t3C9242B5C88A48B2A5BD9FDA6CD0024E792AF08A* L_55 = L_54;
String_t* L_56 = __this->get_m_data_5();
NullCheck(L_55);
ArrayElementTypeCheck (L_55, L_56);
(L_55)->SetAt(static_cast<il2cpp_array_size_t>(0), (RuntimeObject *)L_56);
ObjectU5BU5D_t3C9242B5C88A48B2A5BD9FDA6CD0024E792AF08A* L_57 = L_55;
String_t* L_58 = __this->get_m_assemblyName_6();
NullCheck(L_57);
ArrayElementTypeCheck (L_57, L_58);
(L_57)->SetAt(static_cast<il2cpp_array_size_t>(1), (RuntimeObject *)L_58);
String_t* L_59 = Environment_GetResourceString_m7389941B4C0688D875CC647D99A739DA2F907ADB(_stringLiteral61E4C2772989AB31A7C2799E5C64D7030B05229C, L_57, /*hidden argument*/NULL);
SerializationException_tA1FDFF6779406E688C2192E71C38DBFD7A4A2210 * L_60 = (SerializationException_tA1FDFF6779406E688C2192E71C38DBFD7A4A2210 *)il2cpp_codegen_object_new(SerializationException_tA1FDFF6779406E688C2192E71C38DBFD7A4A2210_il2cpp_TypeInfo_var);
SerializationException__ctor_m88AAD9671030A8A96AA87CB95701938FBD8F16E1(L_60, L_59, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_60, NULL, UnitySerializationHolder_GetRealObject_mB8BD0D19FE747C6B7F739F9686AA52CBA9E6FA9E_RuntimeMethod_var);
}
IL_01c9:
{
Module_t882FB0C491B9CD194BE7CD1AC62FEFB31EEBE5D7 * L_61 = V_2;
return L_61;
}
IL_01cb:
{
String_t* L_62 = __this->get_m_data_5();
if (!L_62)
{
goto IL_01e0;
}
}
{
String_t* L_63 = __this->get_m_data_5();
NullCheck(L_63);
int32_t L_64 = String_get_Length_mD48C8A16A5CF1914F330DCE82D9BE15C3BEDD018(L_63, /*hidden argument*/NULL);
if (L_64)
{
goto IL_01eb;
}
}
IL_01e0:
{
UnitySerializationHolder_ThrowInsufficientInformation_mC9EC8B972B617DB4A56CC8BAF3B814ACF0E7A7EE(__this, _stringLiteralE5E429BCC9C2E4A41A3C7A4D96203BE6CB273B11, /*hidden argument*/NULL);
}
IL_01eb:
{
String_t* L_65 = __this->get_m_assemblyName_6();
if (L_65)
{
goto IL_01fe;
}
}
{
UnitySerializationHolder_ThrowInsufficientInformation_mC9EC8B972B617DB4A56CC8BAF3B814ACF0E7A7EE(__this, _stringLiteralF0541457E2B7EF76AA2DDC177C44B4FF6B95E9C5, /*hidden argument*/NULL);
}
IL_01fe:
{
String_t* L_66 = __this->get_m_assemblyName_6();
Assembly_t * L_67 = Assembly_Load_m4640304E91781FC3D197CD014B0C2DCEAFCFFF55(L_66, /*hidden argument*/NULL);
return L_67;
}
IL_020a:
{
String_t* L_68 = Environment_GetResourceString_m2C75C2AF268F01E2BF34AD1C2E1352CF4BA51AD9(_stringLiteral24EC69BAF51BF30190B6C95CBC8DA59798F5F532, /*hidden argument*/NULL);
ArgumentException_tEDCD16F20A09ECE461C3DA766C16EDA8864057D1 * L_69 = (ArgumentException_tEDCD16F20A09ECE461C3DA766C16EDA8864057D1 *)il2cpp_codegen_object_new(ArgumentException_tEDCD16F20A09ECE461C3DA766C16EDA8864057D1_il2cpp_TypeInfo_var);
ArgumentException__ctor_m9A85EF7FEFEC21DDD525A67E831D77278E5165B7(L_69, L_68, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_69, NULL, UnitySerializationHolder_GetRealObject_mB8BD0D19FE747C6B7F739F9686AA52CBA9E6FA9E_RuntimeMethod_var);
}
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Boolean System.ValueTuple::Equals(System.Object)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool ValueTuple_Equals_m0675CB3C2023AE4A3B1FEB34C87EFE2D6CAB081A (ValueTuple_tC6981F8FD1D7836C91BF332F5F894A8AEEF569D6 * __this, RuntimeObject * ___obj0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (ValueTuple_Equals_m0675CB3C2023AE4A3B1FEB34C87EFE2D6CAB081A_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
RuntimeObject * L_0 = ___obj0;
return (bool)((!(((RuntimeObject*)(RuntimeObject *)((RuntimeObject *)IsInstSealed((RuntimeObject*)L_0, ValueTuple_tC6981F8FD1D7836C91BF332F5F894A8AEEF569D6_il2cpp_TypeInfo_var))) <= ((RuntimeObject*)(RuntimeObject *)NULL)))? 1 : 0);
}
}
IL2CPP_EXTERN_C bool ValueTuple_Equals_m0675CB3C2023AE4A3B1FEB34C87EFE2D6CAB081A_AdjustorThunk (RuntimeObject * __this, RuntimeObject * ___obj0, const RuntimeMethod* method)
{
ValueTuple_tC6981F8FD1D7836C91BF332F5F894A8AEEF569D6 * _thisAdjusted = reinterpret_cast<ValueTuple_tC6981F8FD1D7836C91BF332F5F894A8AEEF569D6 *>(__this + 1);
return ValueTuple_Equals_m0675CB3C2023AE4A3B1FEB34C87EFE2D6CAB081A(_thisAdjusted, ___obj0, method);
}
// System.Boolean System.ValueTuple::Equals(System.ValueTuple)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool ValueTuple_Equals_m4576A8D4CABCAA6BEB3545919F384B2774FE3DFE (ValueTuple_tC6981F8FD1D7836C91BF332F5F894A8AEEF569D6 * __this, ValueTuple_tC6981F8FD1D7836C91BF332F5F894A8AEEF569D6 ___other0, const RuntimeMethod* method)
{
{
return (bool)1;
}
}
IL2CPP_EXTERN_C bool ValueTuple_Equals_m4576A8D4CABCAA6BEB3545919F384B2774FE3DFE_AdjustorThunk (RuntimeObject * __this, ValueTuple_tC6981F8FD1D7836C91BF332F5F894A8AEEF569D6 ___other0, const RuntimeMethod* method)
{
ValueTuple_tC6981F8FD1D7836C91BF332F5F894A8AEEF569D6 * _thisAdjusted = reinterpret_cast<ValueTuple_tC6981F8FD1D7836C91BF332F5F894A8AEEF569D6 *>(__this + 1);
return ValueTuple_Equals_m4576A8D4CABCAA6BEB3545919F384B2774FE3DFE(_thisAdjusted, ___other0, method);
}
// System.Boolean System.ValueTuple::System.Collections.IStructuralEquatable.Equals(System.Object,System.Collections.IEqualityComparer)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool ValueTuple_System_Collections_IStructuralEquatable_Equals_m97AEC150FCB956B281470A28DBBE312ABE2B7021 (ValueTuple_tC6981F8FD1D7836C91BF332F5F894A8AEEF569D6 * __this, RuntimeObject * ___other0, RuntimeObject* ___comparer1, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (ValueTuple_System_Collections_IStructuralEquatable_Equals_m97AEC150FCB956B281470A28DBBE312ABE2B7021_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
RuntimeObject * L_0 = ___other0;
return (bool)((!(((RuntimeObject*)(RuntimeObject *)((RuntimeObject *)IsInstSealed((RuntimeObject*)L_0, ValueTuple_tC6981F8FD1D7836C91BF332F5F894A8AEEF569D6_il2cpp_TypeInfo_var))) <= ((RuntimeObject*)(RuntimeObject *)NULL)))? 1 : 0);
}
}
IL2CPP_EXTERN_C bool ValueTuple_System_Collections_IStructuralEquatable_Equals_m97AEC150FCB956B281470A28DBBE312ABE2B7021_AdjustorThunk (RuntimeObject * __this, RuntimeObject * ___other0, RuntimeObject* ___comparer1, const RuntimeMethod* method)
{
ValueTuple_tC6981F8FD1D7836C91BF332F5F894A8AEEF569D6 * _thisAdjusted = reinterpret_cast<ValueTuple_tC6981F8FD1D7836C91BF332F5F894A8AEEF569D6 *>(__this + 1);
return ValueTuple_System_Collections_IStructuralEquatable_Equals_m97AEC150FCB956B281470A28DBBE312ABE2B7021(_thisAdjusted, ___other0, ___comparer1, method);
}
// System.Int32 System.ValueTuple::System.IComparable.CompareTo(System.Object)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t ValueTuple_System_IComparable_CompareTo_m6E4FCA0C1525C685EB58B41763A4A4D8F2CE5EF5 (ValueTuple_tC6981F8FD1D7836C91BF332F5F894A8AEEF569D6 * __this, RuntimeObject * ___other0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (ValueTuple_System_IComparable_CompareTo_m6E4FCA0C1525C685EB58B41763A4A4D8F2CE5EF5_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
RuntimeObject * L_0 = ___other0;
if (L_0)
{
goto IL_0005;
}
}
{
return 1;
}
IL_0005:
{
RuntimeObject * L_1 = ___other0;
if (((RuntimeObject *)IsInstSealed((RuntimeObject*)L_1, ValueTuple_tC6981F8FD1D7836C91BF332F5F894A8AEEF569D6_il2cpp_TypeInfo_var)))
{
goto IL_0037;
}
}
{
ValueTuple_tC6981F8FD1D7836C91BF332F5F894A8AEEF569D6 L_2 = (*(ValueTuple_tC6981F8FD1D7836C91BF332F5F894A8AEEF569D6 *)__this);
RuntimeObject * L_3 = Box(ValueTuple_tC6981F8FD1D7836C91BF332F5F894A8AEEF569D6_il2cpp_TypeInfo_var, &L_2);
NullCheck(L_3);
Type_t * L_4 = Object_GetType_m2E0B62414ECCAA3094B703790CE88CBB2F83EA60(L_3, /*hidden argument*/NULL);
NullCheck(L_4);
String_t* L_5 = VirtFuncInvoker0< String_t* >::Invoke(3 /* System.String System.Object::ToString() */, L_4);
String_t* L_6 = SR_Format_mCDBB594267CC224AB2A69540BBA598151F0642C7(_stringLiteralABFC501D210FA3194339D5355419BE3336C98217, L_5, /*hidden argument*/NULL);
ArgumentException_tEDCD16F20A09ECE461C3DA766C16EDA8864057D1 * L_7 = (ArgumentException_tEDCD16F20A09ECE461C3DA766C16EDA8864057D1 *)il2cpp_codegen_object_new(ArgumentException_tEDCD16F20A09ECE461C3DA766C16EDA8864057D1_il2cpp_TypeInfo_var);
ArgumentException__ctor_m26DC3463C6F3C98BF33EA39598DD2B32F0249CA8(L_7, L_6, _stringLiteralD0941E68DA8F38151FF86A61FC59F7C5CF9FCAA2, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_7, NULL, ValueTuple_System_IComparable_CompareTo_m6E4FCA0C1525C685EB58B41763A4A4D8F2CE5EF5_RuntimeMethod_var);
}
IL_0037:
{
return 0;
}
}
IL2CPP_EXTERN_C int32_t ValueTuple_System_IComparable_CompareTo_m6E4FCA0C1525C685EB58B41763A4A4D8F2CE5EF5_AdjustorThunk (RuntimeObject * __this, RuntimeObject * ___other0, const RuntimeMethod* method)
{
ValueTuple_tC6981F8FD1D7836C91BF332F5F894A8AEEF569D6 * _thisAdjusted = reinterpret_cast<ValueTuple_tC6981F8FD1D7836C91BF332F5F894A8AEEF569D6 *>(__this + 1);
return ValueTuple_System_IComparable_CompareTo_m6E4FCA0C1525C685EB58B41763A4A4D8F2CE5EF5(_thisAdjusted, ___other0, method);
}
// System.Int32 System.ValueTuple::CompareTo(System.ValueTuple)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t ValueTuple_CompareTo_mF2195A5F94A9E033D7083C3DBA9A53A79F5152E4 (ValueTuple_tC6981F8FD1D7836C91BF332F5F894A8AEEF569D6 * __this, ValueTuple_tC6981F8FD1D7836C91BF332F5F894A8AEEF569D6 ___other0, const RuntimeMethod* method)
{
{
return 0;
}
}
IL2CPP_EXTERN_C int32_t ValueTuple_CompareTo_mF2195A5F94A9E033D7083C3DBA9A53A79F5152E4_AdjustorThunk (RuntimeObject * __this, ValueTuple_tC6981F8FD1D7836C91BF332F5F894A8AEEF569D6 ___other0, const RuntimeMethod* method)
{
ValueTuple_tC6981F8FD1D7836C91BF332F5F894A8AEEF569D6 * _thisAdjusted = reinterpret_cast<ValueTuple_tC6981F8FD1D7836C91BF332F5F894A8AEEF569D6 *>(__this + 1);
return ValueTuple_CompareTo_mF2195A5F94A9E033D7083C3DBA9A53A79F5152E4(_thisAdjusted, ___other0, method);
}
// System.Int32 System.ValueTuple::System.Collections.IStructuralComparable.CompareTo(System.Object,System.Collections.IComparer)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t ValueTuple_System_Collections_IStructuralComparable_CompareTo_mC5A3E5494E6AE2CEBA28F16A2324F69E8E7E1061 (ValueTuple_tC6981F8FD1D7836C91BF332F5F894A8AEEF569D6 * __this, RuntimeObject * ___other0, RuntimeObject* ___comparer1, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (ValueTuple_System_Collections_IStructuralComparable_CompareTo_mC5A3E5494E6AE2CEBA28F16A2324F69E8E7E1061_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
RuntimeObject * L_0 = ___other0;
if (L_0)
{
goto IL_0005;
}
}
{
return 1;
}
IL_0005:
{
RuntimeObject * L_1 = ___other0;
if (((RuntimeObject *)IsInstSealed((RuntimeObject*)L_1, ValueTuple_tC6981F8FD1D7836C91BF332F5F894A8AEEF569D6_il2cpp_TypeInfo_var)))
{
goto IL_0037;
}
}
{
ValueTuple_tC6981F8FD1D7836C91BF332F5F894A8AEEF569D6 L_2 = (*(ValueTuple_tC6981F8FD1D7836C91BF332F5F894A8AEEF569D6 *)__this);
RuntimeObject * L_3 = Box(ValueTuple_tC6981F8FD1D7836C91BF332F5F894A8AEEF569D6_il2cpp_TypeInfo_var, &L_2);
NullCheck(L_3);
Type_t * L_4 = Object_GetType_m2E0B62414ECCAA3094B703790CE88CBB2F83EA60(L_3, /*hidden argument*/NULL);
NullCheck(L_4);
String_t* L_5 = VirtFuncInvoker0< String_t* >::Invoke(3 /* System.String System.Object::ToString() */, L_4);
String_t* L_6 = SR_Format_mCDBB594267CC224AB2A69540BBA598151F0642C7(_stringLiteralABFC501D210FA3194339D5355419BE3336C98217, L_5, /*hidden argument*/NULL);
ArgumentException_tEDCD16F20A09ECE461C3DA766C16EDA8864057D1 * L_7 = (ArgumentException_tEDCD16F20A09ECE461C3DA766C16EDA8864057D1 *)il2cpp_codegen_object_new(ArgumentException_tEDCD16F20A09ECE461C3DA766C16EDA8864057D1_il2cpp_TypeInfo_var);
ArgumentException__ctor_m26DC3463C6F3C98BF33EA39598DD2B32F0249CA8(L_7, L_6, _stringLiteralD0941E68DA8F38151FF86A61FC59F7C5CF9FCAA2, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_7, NULL, ValueTuple_System_Collections_IStructuralComparable_CompareTo_mC5A3E5494E6AE2CEBA28F16A2324F69E8E7E1061_RuntimeMethod_var);
}
IL_0037:
{
return 0;
}
}
IL2CPP_EXTERN_C int32_t ValueTuple_System_Collections_IStructuralComparable_CompareTo_mC5A3E5494E6AE2CEBA28F16A2324F69E8E7E1061_AdjustorThunk (RuntimeObject * __this, RuntimeObject * ___other0, RuntimeObject* ___comparer1, const RuntimeMethod* method)
{
ValueTuple_tC6981F8FD1D7836C91BF332F5F894A8AEEF569D6 * _thisAdjusted = reinterpret_cast<ValueTuple_tC6981F8FD1D7836C91BF332F5F894A8AEEF569D6 *>(__this + 1);
return ValueTuple_System_Collections_IStructuralComparable_CompareTo_mC5A3E5494E6AE2CEBA28F16A2324F69E8E7E1061(_thisAdjusted, ___other0, ___comparer1, method);
}
// System.Int32 System.ValueTuple::GetHashCode()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t ValueTuple_GetHashCode_m7A07476547357BDE782FF7DD4C019EA1C2548160 (ValueTuple_tC6981F8FD1D7836C91BF332F5F894A8AEEF569D6 * __this, const RuntimeMethod* method)
{
{
return 0;
}
}
IL2CPP_EXTERN_C int32_t ValueTuple_GetHashCode_m7A07476547357BDE782FF7DD4C019EA1C2548160_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
ValueTuple_tC6981F8FD1D7836C91BF332F5F894A8AEEF569D6 * _thisAdjusted = reinterpret_cast<ValueTuple_tC6981F8FD1D7836C91BF332F5F894A8AEEF569D6 *>(__this + 1);
return ValueTuple_GetHashCode_m7A07476547357BDE782FF7DD4C019EA1C2548160(_thisAdjusted, method);
}
// System.Int32 System.ValueTuple::System.Collections.IStructuralEquatable.GetHashCode(System.Collections.IEqualityComparer)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t ValueTuple_System_Collections_IStructuralEquatable_GetHashCode_m81B8DE52207DAF266AE2D68455F079FB8DD3220B (ValueTuple_tC6981F8FD1D7836C91BF332F5F894A8AEEF569D6 * __this, RuntimeObject* ___comparer0, const RuntimeMethod* method)
{
{
return 0;
}
}
IL2CPP_EXTERN_C int32_t ValueTuple_System_Collections_IStructuralEquatable_GetHashCode_m81B8DE52207DAF266AE2D68455F079FB8DD3220B_AdjustorThunk (RuntimeObject * __this, RuntimeObject* ___comparer0, const RuntimeMethod* method)
{
ValueTuple_tC6981F8FD1D7836C91BF332F5F894A8AEEF569D6 * _thisAdjusted = reinterpret_cast<ValueTuple_tC6981F8FD1D7836C91BF332F5F894A8AEEF569D6 *>(__this + 1);
return ValueTuple_System_Collections_IStructuralEquatable_GetHashCode_m81B8DE52207DAF266AE2D68455F079FB8DD3220B(_thisAdjusted, ___comparer0, method);
}
// System.String System.ValueTuple::ToString()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR String_t* ValueTuple_ToString_mBF8C414E974C2EAA15E250F90E6B50993AAA1B2D (ValueTuple_tC6981F8FD1D7836C91BF332F5F894A8AEEF569D6 * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (ValueTuple_ToString_mBF8C414E974C2EAA15E250F90E6B50993AAA1B2D_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
return _stringLiteralF9065FA7389750E16FE00D7BA36748F61D3E0DF6;
}
}
IL2CPP_EXTERN_C String_t* ValueTuple_ToString_mBF8C414E974C2EAA15E250F90E6B50993AAA1B2D_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
ValueTuple_tC6981F8FD1D7836C91BF332F5F894A8AEEF569D6 * _thisAdjusted = reinterpret_cast<ValueTuple_tC6981F8FD1D7836C91BF332F5F894A8AEEF569D6 *>(__this + 1);
return ValueTuple_ToString_mBF8C414E974C2EAA15E250F90E6B50993AAA1B2D(_thisAdjusted, method);
}
// System.Int32 System.ValueTuple::CombineHashCodes(System.Int32,System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t ValueTuple_CombineHashCodes_m43A0AF2B2A3E284D995D8D8FC386D13D19A3F5CC (int32_t ___h10, int32_t ___h21, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (ValueTuple_CombineHashCodes_m43A0AF2B2A3E284D995D8D8FC386D13D19A3F5CC_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
IL2CPP_RUNTIME_CLASS_INIT(HashHelpers_tDC6BF33BEF3A798515BA62BA704DD83AEBFA9C33_il2cpp_TypeInfo_var);
int32_t L_0 = ((HashHelpers_tDC6BF33BEF3A798515BA62BA704DD83AEBFA9C33_StaticFields*)il2cpp_codegen_static_fields_for(HashHelpers_tDC6BF33BEF3A798515BA62BA704DD83AEBFA9C33_il2cpp_TypeInfo_var))->get_RandomSeed_0();
int32_t L_1 = ___h10;
int32_t L_2 = HashHelpers_Combine_mC0A377FAA2E385A438B50076FF85AAE6C17B6C33(L_0, L_1, /*hidden argument*/NULL);
int32_t L_3 = ___h21;
int32_t L_4 = HashHelpers_Combine_mC0A377FAA2E385A438B50076FF85AAE6C17B6C33(L_2, L_3, /*hidden argument*/NULL);
return L_4;
}
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// Conversion methods for marshalling of: System.ValueType
IL2CPP_EXTERN_C void ValueType_t4D0C27076F7C36E76190FB3328E232BCB1CD1FFF_marshal_pinvoke(const ValueType_t4D0C27076F7C36E76190FB3328E232BCB1CD1FFF& unmarshaled, ValueType_t4D0C27076F7C36E76190FB3328E232BCB1CD1FFF_marshaled_pinvoke& marshaled)
{
}
IL2CPP_EXTERN_C void ValueType_t4D0C27076F7C36E76190FB3328E232BCB1CD1FFF_marshal_pinvoke_back(const ValueType_t4D0C27076F7C36E76190FB3328E232BCB1CD1FFF_marshaled_pinvoke& marshaled, ValueType_t4D0C27076F7C36E76190FB3328E232BCB1CD1FFF& unmarshaled)
{
}
// Conversion method for clean up from marshalling of: System.ValueType
IL2CPP_EXTERN_C void ValueType_t4D0C27076F7C36E76190FB3328E232BCB1CD1FFF_marshal_pinvoke_cleanup(ValueType_t4D0C27076F7C36E76190FB3328E232BCB1CD1FFF_marshaled_pinvoke& marshaled)
{
}
// Conversion methods for marshalling of: System.ValueType
IL2CPP_EXTERN_C void ValueType_t4D0C27076F7C36E76190FB3328E232BCB1CD1FFF_marshal_com(const ValueType_t4D0C27076F7C36E76190FB3328E232BCB1CD1FFF& unmarshaled, ValueType_t4D0C27076F7C36E76190FB3328E232BCB1CD1FFF_marshaled_com& marshaled)
{
}
IL2CPP_EXTERN_C void ValueType_t4D0C27076F7C36E76190FB3328E232BCB1CD1FFF_marshal_com_back(const ValueType_t4D0C27076F7C36E76190FB3328E232BCB1CD1FFF_marshaled_com& marshaled, ValueType_t4D0C27076F7C36E76190FB3328E232BCB1CD1FFF& unmarshaled)
{
}
// Conversion method for clean up from marshalling of: System.ValueType
IL2CPP_EXTERN_C void ValueType_t4D0C27076F7C36E76190FB3328E232BCB1CD1FFF_marshal_com_cleanup(ValueType_t4D0C27076F7C36E76190FB3328E232BCB1CD1FFF_marshaled_com& marshaled)
{
}
// System.Void System.ValueType::.ctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void ValueType__ctor_m091BDF02E011A41101A74AABB803417EE40CA5B7 (RuntimeObject * __this, const RuntimeMethod* method)
{
{
Object__ctor_m925ECA5E85CA100E3FB86A4F9E15C120E9A184C0(__this, /*hidden argument*/NULL);
return;
}
}
// System.Boolean System.ValueType::InternalEquals(System.Object,System.Object,System.Object[]U26)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool ValueType_InternalEquals_m09E6AB0EC85DC2C65928B946609823DBB90CF59D (RuntimeObject * ___o10, RuntimeObject * ___o21, ObjectU5BU5D_t3C9242B5C88A48B2A5BD9FDA6CD0024E792AF08A** ___fields2, const RuntimeMethod* method)
{
typedef bool (*ValueType_InternalEquals_m09E6AB0EC85DC2C65928B946609823DBB90CF59D_ftn) (RuntimeObject *, RuntimeObject *, ObjectU5BU5D_t3C9242B5C88A48B2A5BD9FDA6CD0024E792AF08A**);
using namespace il2cpp::icalls;
return ((ValueType_InternalEquals_m09E6AB0EC85DC2C65928B946609823DBB90CF59D_ftn)mscorlib::System::ValueType::InternalEquals) (___o10, ___o21, ___fields2);
}
// System.Boolean System.ValueType::DefaultEquals(System.Object,System.Object)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool ValueType_DefaultEquals_m139582CD1BAD7472B45D806F76E4E14E82E629DB (RuntimeObject * ___o10, RuntimeObject * ___o21, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (ValueType_DefaultEquals_m139582CD1BAD7472B45D806F76E4E14E82E629DB_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
RuntimeType_t40F13BCEAD97478C72C4B40BFDC2A220161CDB8F * V_0 = NULL;
ObjectU5BU5D_t3C9242B5C88A48B2A5BD9FDA6CD0024E792AF08A* V_1 = NULL;
bool V_2 = false;
int32_t V_3 = 0;
RuntimeObject * V_4 = NULL;
RuntimeObject * V_5 = NULL;
{
RuntimeObject * L_0 = ___o10;
if (L_0)
{
goto IL_0008;
}
}
{
RuntimeObject * L_1 = ___o21;
if (L_1)
{
goto IL_0008;
}
}
{
return (bool)1;
}
IL_0008:
{
RuntimeObject * L_2 = ___o10;
if (!L_2)
{
goto IL_000e;
}
}
{
RuntimeObject * L_3 = ___o21;
if (L_3)
{
goto IL_0010;
}
}
IL_000e:
{
return (bool)0;
}
IL_0010:
{
RuntimeObject * L_4 = ___o10;
NullCheck(L_4);
Type_t * L_5 = Object_GetType_m2E0B62414ECCAA3094B703790CE88CBB2F83EA60(L_4, /*hidden argument*/NULL);
RuntimeObject * L_6 = ___o21;
NullCheck(L_6);
Type_t * L_7 = Object_GetType_m2E0B62414ECCAA3094B703790CE88CBB2F83EA60(L_6, /*hidden argument*/NULL);
V_0 = ((RuntimeType_t40F13BCEAD97478C72C4B40BFDC2A220161CDB8F *)CastclassClass((RuntimeObject*)L_7, RuntimeType_t40F13BCEAD97478C72C4B40BFDC2A220161CDB8F_il2cpp_TypeInfo_var));
RuntimeType_t40F13BCEAD97478C72C4B40BFDC2A220161CDB8F * L_8 = V_0;
IL2CPP_RUNTIME_CLASS_INIT(RuntimeType_t40F13BCEAD97478C72C4B40BFDC2A220161CDB8F_il2cpp_TypeInfo_var);
bool L_9 = RuntimeType_op_Inequality_mA98A719712593FEE5DCCFDB47CCABDB58BEE1B0D(((RuntimeType_t40F13BCEAD97478C72C4B40BFDC2A220161CDB8F *)CastclassClass((RuntimeObject*)L_5, RuntimeType_t40F13BCEAD97478C72C4B40BFDC2A220161CDB8F_il2cpp_TypeInfo_var)), L_8, /*hidden argument*/NULL);
if (!L_9)
{
goto IL_0031;
}
}
{
return (bool)0;
}
IL_0031:
{
RuntimeObject * L_10 = ___o10;
RuntimeObject * L_11 = ___o21;
bool L_12 = ValueType_InternalEquals_m09E6AB0EC85DC2C65928B946609823DBB90CF59D(L_10, L_11, (ObjectU5BU5D_t3C9242B5C88A48B2A5BD9FDA6CD0024E792AF08A**)(&V_1), /*hidden argument*/NULL);
V_2 = L_12;
ObjectU5BU5D_t3C9242B5C88A48B2A5BD9FDA6CD0024E792AF08A* L_13 = V_1;
if (L_13)
{
goto IL_0040;
}
}
{
bool L_14 = V_2;
return L_14;
}
IL_0040:
{
V_3 = 0;
goto IL_006b;
}
IL_0044:
{
ObjectU5BU5D_t3C9242B5C88A48B2A5BD9FDA6CD0024E792AF08A* L_15 = V_1;
int32_t L_16 = V_3;
NullCheck(L_15);
int32_t L_17 = L_16;
RuntimeObject * L_18 = (L_15)->GetAt(static_cast<il2cpp_array_size_t>(L_17));
V_4 = L_18;
ObjectU5BU5D_t3C9242B5C88A48B2A5BD9FDA6CD0024E792AF08A* L_19 = V_1;
int32_t L_20 = V_3;
NullCheck(L_19);
int32_t L_21 = ((int32_t)il2cpp_codegen_add((int32_t)L_20, (int32_t)1));
RuntimeObject * L_22 = (L_19)->GetAt(static_cast<il2cpp_array_size_t>(L_21));
V_5 = L_22;
RuntimeObject * L_23 = V_4;
if (L_23)
{
goto IL_005a;
}
}
{
RuntimeObject * L_24 = V_5;
if (!L_24)
{
goto IL_0067;
}
}
{
return (bool)0;
}
IL_005a:
{
RuntimeObject * L_25 = V_4;
RuntimeObject * L_26 = V_5;
NullCheck(L_25);
bool L_27 = VirtFuncInvoker1< bool, RuntimeObject * >::Invoke(0 /* System.Boolean System.Object::Equals(System.Object) */, L_25, L_26);
if (L_27)
{
goto IL_0067;
}
}
{
return (bool)0;
}
IL_0067:
{
int32_t L_28 = V_3;
V_3 = ((int32_t)il2cpp_codegen_add((int32_t)L_28, (int32_t)2));
}
IL_006b:
{
int32_t L_29 = V_3;
ObjectU5BU5D_t3C9242B5C88A48B2A5BD9FDA6CD0024E792AF08A* L_30 = V_1;
NullCheck(L_30);
if ((((int32_t)L_29) < ((int32_t)(((int32_t)((int32_t)(((RuntimeArray*)L_30)->max_length)))))))
{
goto IL_0044;
}
}
{
return (bool)1;
}
}
// System.Boolean System.ValueType::Equals(System.Object)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool ValueType_Equals_m5F6E6FDB8422FE9AFF6435C0C729FBE1032F4980 (RuntimeObject * __this, RuntimeObject * ___obj0, const RuntimeMethod* method)
{
{
RuntimeObject * L_0 = ___obj0;
bool L_1 = ValueType_DefaultEquals_m139582CD1BAD7472B45D806F76E4E14E82E629DB(__this, L_0, /*hidden argument*/NULL);
return L_1;
}
}
// System.Int32 System.ValueType::InternalGetHashCode(System.Object,System.Object[]U26)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t ValueType_InternalGetHashCode_mDB37E320BD3CA801CB06E1A4CBD088D8C7F0678A (RuntimeObject * ___o0, ObjectU5BU5D_t3C9242B5C88A48B2A5BD9FDA6CD0024E792AF08A** ___fields1, const RuntimeMethod* method)
{
typedef int32_t (*ValueType_InternalGetHashCode_mDB37E320BD3CA801CB06E1A4CBD088D8C7F0678A_ftn) (RuntimeObject *, ObjectU5BU5D_t3C9242B5C88A48B2A5BD9FDA6CD0024E792AF08A**);
using namespace il2cpp::icalls;
return ((ValueType_InternalGetHashCode_mDB37E320BD3CA801CB06E1A4CBD088D8C7F0678A_ftn)mscorlib::System::ValueType::InternalGetHashCode) (___o0, ___fields1);
}
// System.Int32 System.ValueType::GetHashCode()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t ValueType_GetHashCode_m48E9FA7FFC7C27D876E764A94E3CF2039ED6C9F9 (RuntimeObject * __this, const RuntimeMethod* method)
{
ObjectU5BU5D_t3C9242B5C88A48B2A5BD9FDA6CD0024E792AF08A* V_0 = NULL;
int32_t V_1 = 0;
int32_t V_2 = 0;
{
int32_t L_0 = ValueType_InternalGetHashCode_mDB37E320BD3CA801CB06E1A4CBD088D8C7F0678A(__this, (ObjectU5BU5D_t3C9242B5C88A48B2A5BD9FDA6CD0024E792AF08A**)(&V_0), /*hidden argument*/NULL);
V_1 = L_0;
ObjectU5BU5D_t3C9242B5C88A48B2A5BD9FDA6CD0024E792AF08A* L_1 = V_0;
if (!L_1)
{
goto IL_002a;
}
}
{
V_2 = 0;
goto IL_0024;
}
IL_0010:
{
ObjectU5BU5D_t3C9242B5C88A48B2A5BD9FDA6CD0024E792AF08A* L_2 = V_0;
int32_t L_3 = V_2;
NullCheck(L_2);
int32_t L_4 = L_3;
RuntimeObject * L_5 = (L_2)->GetAt(static_cast<il2cpp_array_size_t>(L_4));
if (!L_5)
{
goto IL_0020;
}
}
{
int32_t L_6 = V_1;
ObjectU5BU5D_t3C9242B5C88A48B2A5BD9FDA6CD0024E792AF08A* L_7 = V_0;
int32_t L_8 = V_2;
NullCheck(L_7);
int32_t L_9 = L_8;
RuntimeObject * L_10 = (L_7)->GetAt(static_cast<il2cpp_array_size_t>(L_9));
NullCheck(L_10);
int32_t L_11 = VirtFuncInvoker0< int32_t >::Invoke(2 /* System.Int32 System.Object::GetHashCode() */, L_10);
V_1 = ((int32_t)((int32_t)L_6^(int32_t)L_11));
}
IL_0020:
{
int32_t L_12 = V_2;
V_2 = ((int32_t)il2cpp_codegen_add((int32_t)L_12, (int32_t)1));
}
IL_0024:
{
int32_t L_13 = V_2;
ObjectU5BU5D_t3C9242B5C88A48B2A5BD9FDA6CD0024E792AF08A* L_14 = V_0;
NullCheck(L_14);
if ((((int32_t)L_13) < ((int32_t)(((int32_t)((int32_t)(((RuntimeArray*)L_14)->max_length)))))))
{
goto IL_0010;
}
}
IL_002a:
{
int32_t L_15 = V_1;
return L_15;
}
}
// System.String System.ValueType::ToString()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR String_t* ValueType_ToString_mDD1C1C0E1FC55404602E8E02C4E12448B31AEE4F (RuntimeObject * __this, const RuntimeMethod* method)
{
{
Type_t * L_0 = Object_GetType_m2E0B62414ECCAA3094B703790CE88CBB2F83EA60(__this, /*hidden argument*/NULL);
NullCheck(L_0);
String_t* L_1 = VirtFuncInvoker0< String_t* >::Invoke(25 /* System.String System.Type::get_FullName() */, L_0);
return L_1;
}
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.Variant::Clear()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void Variant_Clear_m7622B0C52C7794CC4C33434D2ED8170ECDDE5DAF (Variant_tBC94A369178CDE161E918F24FD18166A3DC58C18 * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (Variant_Clear_m7622B0C52C7794CC4C33434D2ED8170ECDDE5DAF_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
int16_t L_0 = __this->get_vt_0();
if ((!(((uint32_t)L_0) == ((uint32_t)8))))
{
goto IL_0015;
}
}
{
intptr_t L_1 = __this->get_bstrVal_11();
IL2CPP_RUNTIME_CLASS_INIT(Marshal_tC795CE9CC2FFBA41EDB1AC1C0FEC04607DFA8A40_il2cpp_TypeInfo_var);
Marshal_FreeBSTR_mB3CD149620B05C68BBC20931307564BADDE71A25((intptr_t)L_1, /*hidden argument*/NULL);
return;
}
IL_0015:
{
int16_t L_2 = __this->get_vt_0();
if ((((int32_t)L_2) == ((int32_t)((int32_t)9))))
{
goto IL_0029;
}
}
{
int16_t L_3 = __this->get_vt_0();
if ((!(((uint32_t)L_3) == ((uint32_t)((int32_t)13)))))
{
goto IL_0047;
}
}
IL_0029:
{
intptr_t L_4 = __this->get_pdispVal_18();
bool L_5 = IntPtr_op_Inequality_mB4886A806009EA825EFCC60CD2A7F6EB8E273A61((intptr_t)L_4, (intptr_t)(0), /*hidden argument*/NULL);
if (!L_5)
{
goto IL_0047;
}
}
{
intptr_t L_6 = __this->get_pdispVal_18();
IL2CPP_RUNTIME_CLASS_INIT(Marshal_tC795CE9CC2FFBA41EDB1AC1C0FEC04607DFA8A40_il2cpp_TypeInfo_var);
Marshal_Release_mF0676E7B6EE181109020F407F09E1063D681B5F8((intptr_t)L_6, /*hidden argument*/NULL);
}
IL_0047:
{
return;
}
}
IL2CPP_EXTERN_C void Variant_Clear_m7622B0C52C7794CC4C33434D2ED8170ECDDE5DAF_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
Variant_tBC94A369178CDE161E918F24FD18166A3DC58C18 * _thisAdjusted = reinterpret_cast<Variant_tBC94A369178CDE161E918F24FD18166A3DC58C18 *>(__this + 1);
Variant_Clear_m7622B0C52C7794CC4C33434D2ED8170ECDDE5DAF(_thisAdjusted, method);
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.Version::.ctor(System.Int32,System.Int32,System.Int32,System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void Version__ctor_mFA5AABF2294D59FA7B3F32BB48CB238BCACBDF80 (Version_tDBE6876C59B6F56D4F8CAA03851177ABC6FE0DFD * __this, int32_t ___major0, int32_t ___minor1, int32_t ___build2, int32_t ___revision3, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (Version__ctor_mFA5AABF2294D59FA7B3F32BB48CB238BCACBDF80_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
__this->set__Build_2((-1));
__this->set__Revision_3((-1));
Object__ctor_m925ECA5E85CA100E3FB86A4F9E15C120E9A184C0(__this, /*hidden argument*/NULL);
int32_t L_0 = ___major0;
if ((((int32_t)L_0) >= ((int32_t)0)))
{
goto IL_002d;
}
}
{
String_t* L_1 = Environment_GetResourceString_m2C75C2AF268F01E2BF34AD1C2E1352CF4BA51AD9(_stringLiteral698C2F7C87FA878A3D506FEDB570238873872A3C, /*hidden argument*/NULL);
ArgumentOutOfRangeException_t94D19DF918A54511AEDF4784C9A08741BAD1DEDA * L_2 = (ArgumentOutOfRangeException_t94D19DF918A54511AEDF4784C9A08741BAD1DEDA *)il2cpp_codegen_object_new(ArgumentOutOfRangeException_t94D19DF918A54511AEDF4784C9A08741BAD1DEDA_il2cpp_TypeInfo_var);
ArgumentOutOfRangeException__ctor_m300CE4D04A068C209FD858101AC361C1B600B5AE(L_2, _stringLiteral18C9D4621EF6C3113CE1F960346D7603E88406E8, L_1, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_2, NULL, Version__ctor_mFA5AABF2294D59FA7B3F32BB48CB238BCACBDF80_RuntimeMethod_var);
}
IL_002d:
{
int32_t L_3 = ___minor1;
if ((((int32_t)L_3) >= ((int32_t)0)))
{
goto IL_0046;
}
}
{
String_t* L_4 = Environment_GetResourceString_m2C75C2AF268F01E2BF34AD1C2E1352CF4BA51AD9(_stringLiteral698C2F7C87FA878A3D506FEDB570238873872A3C, /*hidden argument*/NULL);
ArgumentOutOfRangeException_t94D19DF918A54511AEDF4784C9A08741BAD1DEDA * L_5 = (ArgumentOutOfRangeException_t94D19DF918A54511AEDF4784C9A08741BAD1DEDA *)il2cpp_codegen_object_new(ArgumentOutOfRangeException_t94D19DF918A54511AEDF4784C9A08741BAD1DEDA_il2cpp_TypeInfo_var);
ArgumentOutOfRangeException__ctor_m300CE4D04A068C209FD858101AC361C1B600B5AE(L_5, _stringLiteralFEE63D97CA760412103B668617F8B29605625B7D, L_4, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_5, NULL, Version__ctor_mFA5AABF2294D59FA7B3F32BB48CB238BCACBDF80_RuntimeMethod_var);
}
IL_0046:
{
int32_t L_6 = ___build2;
if ((((int32_t)L_6) >= ((int32_t)0)))
{
goto IL_005f;
}
}
{
String_t* L_7 = Environment_GetResourceString_m2C75C2AF268F01E2BF34AD1C2E1352CF4BA51AD9(_stringLiteral698C2F7C87FA878A3D506FEDB570238873872A3C, /*hidden argument*/NULL);
ArgumentOutOfRangeException_t94D19DF918A54511AEDF4784C9A08741BAD1DEDA * L_8 = (ArgumentOutOfRangeException_t94D19DF918A54511AEDF4784C9A08741BAD1DEDA *)il2cpp_codegen_object_new(ArgumentOutOfRangeException_t94D19DF918A54511AEDF4784C9A08741BAD1DEDA_il2cpp_TypeInfo_var);
ArgumentOutOfRangeException__ctor_m300CE4D04A068C209FD858101AC361C1B600B5AE(L_8, _stringLiteral80754AF91BFB6D1073585B046FE0A474CE868509, L_7, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_8, NULL, Version__ctor_mFA5AABF2294D59FA7B3F32BB48CB238BCACBDF80_RuntimeMethod_var);
}
IL_005f:
{
int32_t L_9 = ___revision3;
if ((((int32_t)L_9) >= ((int32_t)0)))
{
goto IL_0079;
}
}
{
String_t* L_10 = Environment_GetResourceString_m2C75C2AF268F01E2BF34AD1C2E1352CF4BA51AD9(_stringLiteral698C2F7C87FA878A3D506FEDB570238873872A3C, /*hidden argument*/NULL);
ArgumentOutOfRangeException_t94D19DF918A54511AEDF4784C9A08741BAD1DEDA * L_11 = (ArgumentOutOfRangeException_t94D19DF918A54511AEDF4784C9A08741BAD1DEDA *)il2cpp_codegen_object_new(ArgumentOutOfRangeException_t94D19DF918A54511AEDF4784C9A08741BAD1DEDA_il2cpp_TypeInfo_var);
ArgumentOutOfRangeException__ctor_m300CE4D04A068C209FD858101AC361C1B600B5AE(L_11, _stringLiteralEAE79D6E0CFF76FC7A3BB78723690B0B2367F849, L_10, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_11, NULL, Version__ctor_mFA5AABF2294D59FA7B3F32BB48CB238BCACBDF80_RuntimeMethod_var);
}
IL_0079:
{
int32_t L_12 = ___major0;
__this->set__Major_0(L_12);
int32_t L_13 = ___minor1;
__this->set__Minor_1(L_13);
int32_t L_14 = ___build2;
__this->set__Build_2(L_14);
int32_t L_15 = ___revision3;
__this->set__Revision_3(L_15);
return;
}
}
// System.Void System.Version::.ctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void Version__ctor_m2033F9EE96782C92B9978E42BB4EAEF240950B51 (Version_tDBE6876C59B6F56D4F8CAA03851177ABC6FE0DFD * __this, const RuntimeMethod* method)
{
{
__this->set__Build_2((-1));
__this->set__Revision_3((-1));
Object__ctor_m925ECA5E85CA100E3FB86A4F9E15C120E9A184C0(__this, /*hidden argument*/NULL);
__this->set__Major_0(0);
__this->set__Minor_1(0);
return;
}
}
// System.Int32 System.Version::get_Major()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t Version_get_Major_m7A6BEEF367674B8C06B15F6675AFF0C32CCEE87C (Version_tDBE6876C59B6F56D4F8CAA03851177ABC6FE0DFD * __this, const RuntimeMethod* method)
{
{
int32_t L_0 = __this->get__Major_0();
return L_0;
}
}
// System.Int32 System.Version::get_Minor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t Version_get_Minor_mCBAFA7052D1786A47B4BA971E7193A4EB9A7D059 (Version_tDBE6876C59B6F56D4F8CAA03851177ABC6FE0DFD * __this, const RuntimeMethod* method)
{
{
int32_t L_0 = __this->get__Minor_1();
return L_0;
}
}
// System.Int32 System.Version::get_Build()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t Version_get_Build_m184E3AAE13518CEA172E9C6860E9359D567E64DB (Version_tDBE6876C59B6F56D4F8CAA03851177ABC6FE0DFD * __this, const RuntimeMethod* method)
{
{
int32_t L_0 = __this->get__Build_2();
return L_0;
}
}
// System.Int32 System.Version::get_Revision()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t Version_get_Revision_mB0BADD4E233FA3001FB7BB4795A0A330880453BB (Version_tDBE6876C59B6F56D4F8CAA03851177ABC6FE0DFD * __this, const RuntimeMethod* method)
{
{
int32_t L_0 = __this->get__Revision_3();
return L_0;
}
}
// System.Object System.Version::Clone()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * Version_Clone_mC9305AB873E1FF41BA1B81C2988F0C113CC11035 (Version_tDBE6876C59B6F56D4F8CAA03851177ABC6FE0DFD * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (Version_Clone_mC9305AB873E1FF41BA1B81C2988F0C113CC11035_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
Version_tDBE6876C59B6F56D4F8CAA03851177ABC6FE0DFD * L_0 = (Version_tDBE6876C59B6F56D4F8CAA03851177ABC6FE0DFD *)il2cpp_codegen_object_new(Version_tDBE6876C59B6F56D4F8CAA03851177ABC6FE0DFD_il2cpp_TypeInfo_var);
Version__ctor_m2033F9EE96782C92B9978E42BB4EAEF240950B51(L_0, /*hidden argument*/NULL);
Version_tDBE6876C59B6F56D4F8CAA03851177ABC6FE0DFD * L_1 = L_0;
int32_t L_2 = __this->get__Major_0();
NullCheck(L_1);
L_1->set__Major_0(L_2);
Version_tDBE6876C59B6F56D4F8CAA03851177ABC6FE0DFD * L_3 = L_1;
int32_t L_4 = __this->get__Minor_1();
NullCheck(L_3);
L_3->set__Minor_1(L_4);
Version_tDBE6876C59B6F56D4F8CAA03851177ABC6FE0DFD * L_5 = L_3;
int32_t L_6 = __this->get__Build_2();
NullCheck(L_5);
L_5->set__Build_2(L_6);
Version_tDBE6876C59B6F56D4F8CAA03851177ABC6FE0DFD * L_7 = L_5;
int32_t L_8 = __this->get__Revision_3();
NullCheck(L_7);
L_7->set__Revision_3(L_8);
return L_7;
}
}
// System.Int32 System.Version::CompareTo(System.Object)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t Version_CompareTo_m604CF8F6AFAB12D2F64E223B72F518528A3F85A2 (Version_tDBE6876C59B6F56D4F8CAA03851177ABC6FE0DFD * __this, RuntimeObject * ___version0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (Version_CompareTo_m604CF8F6AFAB12D2F64E223B72F518528A3F85A2_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
Version_tDBE6876C59B6F56D4F8CAA03851177ABC6FE0DFD * V_0 = NULL;
{
RuntimeObject * L_0 = ___version0;
if (L_0)
{
goto IL_0005;
}
}
{
return 1;
}
IL_0005:
{
RuntimeObject * L_1 = ___version0;
V_0 = ((Version_tDBE6876C59B6F56D4F8CAA03851177ABC6FE0DFD *)IsInstSealed((RuntimeObject*)L_1, Version_tDBE6876C59B6F56D4F8CAA03851177ABC6FE0DFD_il2cpp_TypeInfo_var));
Version_tDBE6876C59B6F56D4F8CAA03851177ABC6FE0DFD * L_2 = V_0;
IL2CPP_RUNTIME_CLASS_INIT(Version_tDBE6876C59B6F56D4F8CAA03851177ABC6FE0DFD_il2cpp_TypeInfo_var);
bool L_3 = Version_op_Equality_m9E4E82DB85F13E3C19AB5D4AF94C4F399971374D(L_2, (Version_tDBE6876C59B6F56D4F8CAA03851177ABC6FE0DFD *)NULL, /*hidden argument*/NULL);
if (!L_3)
{
goto IL_0025;
}
}
{
String_t* L_4 = Environment_GetResourceString_m2C75C2AF268F01E2BF34AD1C2E1352CF4BA51AD9(_stringLiteral39633794BA5C406D0D71A70F2C47493DB1E986D2, /*hidden argument*/NULL);
ArgumentException_tEDCD16F20A09ECE461C3DA766C16EDA8864057D1 * L_5 = (ArgumentException_tEDCD16F20A09ECE461C3DA766C16EDA8864057D1 *)il2cpp_codegen_object_new(ArgumentException_tEDCD16F20A09ECE461C3DA766C16EDA8864057D1_il2cpp_TypeInfo_var);
ArgumentException__ctor_m9A85EF7FEFEC21DDD525A67E831D77278E5165B7(L_5, L_4, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_5, NULL, Version_CompareTo_m604CF8F6AFAB12D2F64E223B72F518528A3F85A2_RuntimeMethod_var);
}
IL_0025:
{
int32_t L_6 = __this->get__Major_0();
Version_tDBE6876C59B6F56D4F8CAA03851177ABC6FE0DFD * L_7 = V_0;
NullCheck(L_7);
int32_t L_8 = L_7->get__Major_0();
if ((((int32_t)L_6) == ((int32_t)L_8)))
{
goto IL_0045;
}
}
{
int32_t L_9 = __this->get__Major_0();
Version_tDBE6876C59B6F56D4F8CAA03851177ABC6FE0DFD * L_10 = V_0;
NullCheck(L_10);
int32_t L_11 = L_10->get__Major_0();
if ((((int32_t)L_9) <= ((int32_t)L_11)))
{
goto IL_0043;
}
}
{
return 1;
}
IL_0043:
{
return (-1);
}
IL_0045:
{
int32_t L_12 = __this->get__Minor_1();
Version_tDBE6876C59B6F56D4F8CAA03851177ABC6FE0DFD * L_13 = V_0;
NullCheck(L_13);
int32_t L_14 = L_13->get__Minor_1();
if ((((int32_t)L_12) == ((int32_t)L_14)))
{
goto IL_0065;
}
}
{
int32_t L_15 = __this->get__Minor_1();
Version_tDBE6876C59B6F56D4F8CAA03851177ABC6FE0DFD * L_16 = V_0;
NullCheck(L_16);
int32_t L_17 = L_16->get__Minor_1();
if ((((int32_t)L_15) <= ((int32_t)L_17)))
{
goto IL_0063;
}
}
{
return 1;
}
IL_0063:
{
return (-1);
}
IL_0065:
{
int32_t L_18 = __this->get__Build_2();
Version_tDBE6876C59B6F56D4F8CAA03851177ABC6FE0DFD * L_19 = V_0;
NullCheck(L_19);
int32_t L_20 = L_19->get__Build_2();
if ((((int32_t)L_18) == ((int32_t)L_20)))
{
goto IL_0085;
}
}
{
int32_t L_21 = __this->get__Build_2();
Version_tDBE6876C59B6F56D4F8CAA03851177ABC6FE0DFD * L_22 = V_0;
NullCheck(L_22);
int32_t L_23 = L_22->get__Build_2();
if ((((int32_t)L_21) <= ((int32_t)L_23)))
{
goto IL_0083;
}
}
{
return 1;
}
IL_0083:
{
return (-1);
}
IL_0085:
{
int32_t L_24 = __this->get__Revision_3();
Version_tDBE6876C59B6F56D4F8CAA03851177ABC6FE0DFD * L_25 = V_0;
NullCheck(L_25);
int32_t L_26 = L_25->get__Revision_3();
if ((((int32_t)L_24) == ((int32_t)L_26)))
{
goto IL_00a5;
}
}
{
int32_t L_27 = __this->get__Revision_3();
Version_tDBE6876C59B6F56D4F8CAA03851177ABC6FE0DFD * L_28 = V_0;
NullCheck(L_28);
int32_t L_29 = L_28->get__Revision_3();
if ((((int32_t)L_27) <= ((int32_t)L_29)))
{
goto IL_00a3;
}
}
{
return 1;
}
IL_00a3:
{
return (-1);
}
IL_00a5:
{
return 0;
}
}
// System.Int32 System.Version::CompareTo(System.Version)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t Version_CompareTo_mB6A6C226C3401C8903DD32602F72FA644631C33C (Version_tDBE6876C59B6F56D4F8CAA03851177ABC6FE0DFD * __this, Version_tDBE6876C59B6F56D4F8CAA03851177ABC6FE0DFD * ___value0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (Version_CompareTo_mB6A6C226C3401C8903DD32602F72FA644631C33C_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
Version_tDBE6876C59B6F56D4F8CAA03851177ABC6FE0DFD * L_0 = ___value0;
IL2CPP_RUNTIME_CLASS_INIT(Version_tDBE6876C59B6F56D4F8CAA03851177ABC6FE0DFD_il2cpp_TypeInfo_var);
bool L_1 = Version_op_Equality_m9E4E82DB85F13E3C19AB5D4AF94C4F399971374D(L_0, (Version_tDBE6876C59B6F56D4F8CAA03851177ABC6FE0DFD *)NULL, /*hidden argument*/NULL);
if (!L_1)
{
goto IL_000b;
}
}
{
return 1;
}
IL_000b:
{
int32_t L_2 = __this->get__Major_0();
Version_tDBE6876C59B6F56D4F8CAA03851177ABC6FE0DFD * L_3 = ___value0;
NullCheck(L_3);
int32_t L_4 = L_3->get__Major_0();
if ((((int32_t)L_2) == ((int32_t)L_4)))
{
goto IL_002b;
}
}
{
int32_t L_5 = __this->get__Major_0();
Version_tDBE6876C59B6F56D4F8CAA03851177ABC6FE0DFD * L_6 = ___value0;
NullCheck(L_6);
int32_t L_7 = L_6->get__Major_0();
if ((((int32_t)L_5) <= ((int32_t)L_7)))
{
goto IL_0029;
}
}
{
return 1;
}
IL_0029:
{
return (-1);
}
IL_002b:
{
int32_t L_8 = __this->get__Minor_1();
Version_tDBE6876C59B6F56D4F8CAA03851177ABC6FE0DFD * L_9 = ___value0;
NullCheck(L_9);
int32_t L_10 = L_9->get__Minor_1();
if ((((int32_t)L_8) == ((int32_t)L_10)))
{
goto IL_004b;
}
}
{
int32_t L_11 = __this->get__Minor_1();
Version_tDBE6876C59B6F56D4F8CAA03851177ABC6FE0DFD * L_12 = ___value0;
NullCheck(L_12);
int32_t L_13 = L_12->get__Minor_1();
if ((((int32_t)L_11) <= ((int32_t)L_13)))
{
goto IL_0049;
}
}
{
return 1;
}
IL_0049:
{
return (-1);
}
IL_004b:
{
int32_t L_14 = __this->get__Build_2();
Version_tDBE6876C59B6F56D4F8CAA03851177ABC6FE0DFD * L_15 = ___value0;
NullCheck(L_15);
int32_t L_16 = L_15->get__Build_2();
if ((((int32_t)L_14) == ((int32_t)L_16)))
{
goto IL_006b;
}
}
{
int32_t L_17 = __this->get__Build_2();
Version_tDBE6876C59B6F56D4F8CAA03851177ABC6FE0DFD * L_18 = ___value0;
NullCheck(L_18);
int32_t L_19 = L_18->get__Build_2();
if ((((int32_t)L_17) <= ((int32_t)L_19)))
{
goto IL_0069;
}
}
{
return 1;
}
IL_0069:
{
return (-1);
}
IL_006b:
{
int32_t L_20 = __this->get__Revision_3();
Version_tDBE6876C59B6F56D4F8CAA03851177ABC6FE0DFD * L_21 = ___value0;
NullCheck(L_21);
int32_t L_22 = L_21->get__Revision_3();
if ((((int32_t)L_20) == ((int32_t)L_22)))
{
goto IL_008b;
}
}
{
int32_t L_23 = __this->get__Revision_3();
Version_tDBE6876C59B6F56D4F8CAA03851177ABC6FE0DFD * L_24 = ___value0;
NullCheck(L_24);
int32_t L_25 = L_24->get__Revision_3();
if ((((int32_t)L_23) <= ((int32_t)L_25)))
{
goto IL_0089;
}
}
{
return 1;
}
IL_0089:
{
return (-1);
}
IL_008b:
{
return 0;
}
}
// System.Boolean System.Version::Equals(System.Object)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool Version_Equals_mD76B915CF93D19541FFE323B20D0B7992B62927B (Version_tDBE6876C59B6F56D4F8CAA03851177ABC6FE0DFD * __this, RuntimeObject * ___obj0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (Version_Equals_mD76B915CF93D19541FFE323B20D0B7992B62927B_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
Version_tDBE6876C59B6F56D4F8CAA03851177ABC6FE0DFD * V_0 = NULL;
{
RuntimeObject * L_0 = ___obj0;
V_0 = ((Version_tDBE6876C59B6F56D4F8CAA03851177ABC6FE0DFD *)IsInstSealed((RuntimeObject*)L_0, Version_tDBE6876C59B6F56D4F8CAA03851177ABC6FE0DFD_il2cpp_TypeInfo_var));
Version_tDBE6876C59B6F56D4F8CAA03851177ABC6FE0DFD * L_1 = V_0;
IL2CPP_RUNTIME_CLASS_INIT(Version_tDBE6876C59B6F56D4F8CAA03851177ABC6FE0DFD_il2cpp_TypeInfo_var);
bool L_2 = Version_op_Equality_m9E4E82DB85F13E3C19AB5D4AF94C4F399971374D(L_1, (Version_tDBE6876C59B6F56D4F8CAA03851177ABC6FE0DFD *)NULL, /*hidden argument*/NULL);
if (!L_2)
{
goto IL_0012;
}
}
{
return (bool)0;
}
IL_0012:
{
int32_t L_3 = __this->get__Major_0();
Version_tDBE6876C59B6F56D4F8CAA03851177ABC6FE0DFD * L_4 = V_0;
NullCheck(L_4);
int32_t L_5 = L_4->get__Major_0();
if ((!(((uint32_t)L_3) == ((uint32_t)L_5))))
{
goto IL_004a;
}
}
{
int32_t L_6 = __this->get__Minor_1();
Version_tDBE6876C59B6F56D4F8CAA03851177ABC6FE0DFD * L_7 = V_0;
NullCheck(L_7);
int32_t L_8 = L_7->get__Minor_1();
if ((!(((uint32_t)L_6) == ((uint32_t)L_8))))
{
goto IL_004a;
}
}
{
int32_t L_9 = __this->get__Build_2();
Version_tDBE6876C59B6F56D4F8CAA03851177ABC6FE0DFD * L_10 = V_0;
NullCheck(L_10);
int32_t L_11 = L_10->get__Build_2();
if ((!(((uint32_t)L_9) == ((uint32_t)L_11))))
{
goto IL_004a;
}
}
{
int32_t L_12 = __this->get__Revision_3();
Version_tDBE6876C59B6F56D4F8CAA03851177ABC6FE0DFD * L_13 = V_0;
NullCheck(L_13);
int32_t L_14 = L_13->get__Revision_3();
if ((((int32_t)L_12) == ((int32_t)L_14)))
{
goto IL_004c;
}
}
IL_004a:
{
return (bool)0;
}
IL_004c:
{
return (bool)1;
}
}
// System.Boolean System.Version::Equals(System.Version)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool Version_Equals_m7C93B95F0594CB28E1B1C96936B03069BF8968D3 (Version_tDBE6876C59B6F56D4F8CAA03851177ABC6FE0DFD * __this, Version_tDBE6876C59B6F56D4F8CAA03851177ABC6FE0DFD * ___obj0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (Version_Equals_m7C93B95F0594CB28E1B1C96936B03069BF8968D3_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
Version_tDBE6876C59B6F56D4F8CAA03851177ABC6FE0DFD * L_0 = ___obj0;
IL2CPP_RUNTIME_CLASS_INIT(Version_tDBE6876C59B6F56D4F8CAA03851177ABC6FE0DFD_il2cpp_TypeInfo_var);
bool L_1 = Version_op_Equality_m9E4E82DB85F13E3C19AB5D4AF94C4F399971374D(L_0, (Version_tDBE6876C59B6F56D4F8CAA03851177ABC6FE0DFD *)NULL, /*hidden argument*/NULL);
if (!L_1)
{
goto IL_000b;
}
}
{
return (bool)0;
}
IL_000b:
{
int32_t L_2 = __this->get__Major_0();
Version_tDBE6876C59B6F56D4F8CAA03851177ABC6FE0DFD * L_3 = ___obj0;
NullCheck(L_3);
int32_t L_4 = L_3->get__Major_0();
if ((!(((uint32_t)L_2) == ((uint32_t)L_4))))
{
goto IL_0043;
}
}
{
int32_t L_5 = __this->get__Minor_1();
Version_tDBE6876C59B6F56D4F8CAA03851177ABC6FE0DFD * L_6 = ___obj0;
NullCheck(L_6);
int32_t L_7 = L_6->get__Minor_1();
if ((!(((uint32_t)L_5) == ((uint32_t)L_7))))
{
goto IL_0043;
}
}
{
int32_t L_8 = __this->get__Build_2();
Version_tDBE6876C59B6F56D4F8CAA03851177ABC6FE0DFD * L_9 = ___obj0;
NullCheck(L_9);
int32_t L_10 = L_9->get__Build_2();
if ((!(((uint32_t)L_8) == ((uint32_t)L_10))))
{
goto IL_0043;
}
}
{
int32_t L_11 = __this->get__Revision_3();
Version_tDBE6876C59B6F56D4F8CAA03851177ABC6FE0DFD * L_12 = ___obj0;
NullCheck(L_12);
int32_t L_13 = L_12->get__Revision_3();
if ((((int32_t)L_11) == ((int32_t)L_13)))
{
goto IL_0045;
}
}
IL_0043:
{
return (bool)0;
}
IL_0045:
{
return (bool)1;
}
}
// System.Int32 System.Version::GetHashCode()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t Version_GetHashCode_m3FF6292092A632298FF4E95DCEF1811F81FFB702 (Version_tDBE6876C59B6F56D4F8CAA03851177ABC6FE0DFD * __this, const RuntimeMethod* method)
{
{
int32_t L_0 = __this->get__Major_0();
int32_t L_1 = __this->get__Minor_1();
int32_t L_2 = __this->get__Build_2();
int32_t L_3 = __this->get__Revision_3();
return ((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)0|(int32_t)((int32_t)((int32_t)((int32_t)((int32_t)L_0&(int32_t)((int32_t)15)))<<(int32_t)((int32_t)28)))))|(int32_t)((int32_t)((int32_t)((int32_t)((int32_t)L_1&(int32_t)((int32_t)255)))<<(int32_t)((int32_t)20)))))|(int32_t)((int32_t)((int32_t)((int32_t)((int32_t)L_2&(int32_t)((int32_t)255)))<<(int32_t)((int32_t)12)))))|(int32_t)((int32_t)((int32_t)L_3&(int32_t)((int32_t)4095)))));
}
}
// System.String System.Version::ToString()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR String_t* Version_ToString_mDECF4A07B036D33A66BFC4A647363FBB89323034 (Version_tDBE6876C59B6F56D4F8CAA03851177ABC6FE0DFD * __this, const RuntimeMethod* method)
{
{
int32_t L_0 = __this->get__Build_2();
if ((!(((uint32_t)L_0) == ((uint32_t)(-1)))))
{
goto IL_0011;
}
}
{
String_t* L_1 = Version_ToString_m8B385B5C25D9FD3A25EE2DDF02B592CAFC1C0AB0(__this, 2, /*hidden argument*/NULL);
return L_1;
}
IL_0011:
{
int32_t L_2 = __this->get__Revision_3();
if ((!(((uint32_t)L_2) == ((uint32_t)(-1)))))
{
goto IL_0022;
}
}
{
String_t* L_3 = Version_ToString_m8B385B5C25D9FD3A25EE2DDF02B592CAFC1C0AB0(__this, 3, /*hidden argument*/NULL);
return L_3;
}
IL_0022:
{
String_t* L_4 = Version_ToString_m8B385B5C25D9FD3A25EE2DDF02B592CAFC1C0AB0(__this, 4, /*hidden argument*/NULL);
return L_4;
}
}
// System.String System.Version::ToString(System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR String_t* Version_ToString_m8B385B5C25D9FD3A25EE2DDF02B592CAFC1C0AB0 (Version_tDBE6876C59B6F56D4F8CAA03851177ABC6FE0DFD * __this, int32_t ___fieldCount0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (Version_ToString_m8B385B5C25D9FD3A25EE2DDF02B592CAFC1C0AB0_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
StringBuilder_t * V_0 = NULL;
{
int32_t L_0 = ___fieldCount0;
switch (L_0)
{
case 0:
{
goto IL_0014;
}
case 1:
{
goto IL_001a;
}
case 2:
{
goto IL_0026;
}
}
}
{
goto IL_0056;
}
IL_0014:
{
String_t* L_1 = ((String_t_StaticFields*)il2cpp_codegen_static_fields_for(String_t_il2cpp_TypeInfo_var))->get_Empty_5();
return L_1;
}
IL_001a:
{
int32_t* L_2 = __this->get_address_of__Major_0();
String_t* L_3 = Int32_ToString_m1863896DE712BF97C031D55B12E1583F1982DC02((int32_t*)L_2, /*hidden argument*/NULL);
return L_3;
}
IL_0026:
{
StringBuilder_t * L_4 = StringBuilderCache_Acquire_mCA3DDB17F0BFEF32DA9B4D7E8501D5705890557D(((int32_t)16), /*hidden argument*/NULL);
V_0 = L_4;
int32_t L_5 = __this->get__Major_0();
StringBuilder_t * L_6 = V_0;
IL2CPP_RUNTIME_CLASS_INIT(Version_tDBE6876C59B6F56D4F8CAA03851177ABC6FE0DFD_il2cpp_TypeInfo_var);
Version_AppendPositiveNumber_mEDCCE1D1AC63EE1F509538B86EA00A698A9D7C98(L_5, L_6, /*hidden argument*/NULL);
StringBuilder_t * L_7 = V_0;
NullCheck(L_7);
StringBuilder_Append_m05C12F58ADC2D807613A9301DF438CB3CD09B75A(L_7, ((int32_t)46), /*hidden argument*/NULL);
int32_t L_8 = __this->get__Minor_1();
StringBuilder_t * L_9 = V_0;
Version_AppendPositiveNumber_mEDCCE1D1AC63EE1F509538B86EA00A698A9D7C98(L_8, L_9, /*hidden argument*/NULL);
StringBuilder_t * L_10 = V_0;
String_t* L_11 = StringBuilderCache_GetStringAndRelease_mDD5B8378FE9378CACF8660EB460E0CE545F215F7(L_10, /*hidden argument*/NULL);
return L_11;
}
IL_0056:
{
int32_t L_12 = __this->get__Build_2();
if ((!(((uint32_t)L_12) == ((uint32_t)(-1)))))
{
goto IL_008a;
}
}
{
ObjectU5BU5D_t3C9242B5C88A48B2A5BD9FDA6CD0024E792AF08A* L_13 = (ObjectU5BU5D_t3C9242B5C88A48B2A5BD9FDA6CD0024E792AF08A*)(ObjectU5BU5D_t3C9242B5C88A48B2A5BD9FDA6CD0024E792AF08A*)SZArrayNew(ObjectU5BU5D_t3C9242B5C88A48B2A5BD9FDA6CD0024E792AF08A_il2cpp_TypeInfo_var, (uint32_t)2);
ObjectU5BU5D_t3C9242B5C88A48B2A5BD9FDA6CD0024E792AF08A* L_14 = L_13;
NullCheck(L_14);
ArrayElementTypeCheck (L_14, _stringLiteralB6589FC6AB0DC82CF12099D1C2D40AB994E8410C);
(L_14)->SetAt(static_cast<il2cpp_array_size_t>(0), (RuntimeObject *)_stringLiteralB6589FC6AB0DC82CF12099D1C2D40AB994E8410C);
ObjectU5BU5D_t3C9242B5C88A48B2A5BD9FDA6CD0024E792AF08A* L_15 = L_14;
NullCheck(L_15);
ArrayElementTypeCheck (L_15, _stringLiteralDA4B9237BACCCDF19C0760CAB7AEC4A8359010B0);
(L_15)->SetAt(static_cast<il2cpp_array_size_t>(1), (RuntimeObject *)_stringLiteralDA4B9237BACCCDF19C0760CAB7AEC4A8359010B0);
String_t* L_16 = Environment_GetResourceString_m7389941B4C0688D875CC647D99A739DA2F907ADB(_stringLiteral868E70DE0948AAB2E5C3FEF19E1D3C1808994229, L_15, /*hidden argument*/NULL);
ArgumentException_tEDCD16F20A09ECE461C3DA766C16EDA8864057D1 * L_17 = (ArgumentException_tEDCD16F20A09ECE461C3DA766C16EDA8864057D1 *)il2cpp_codegen_object_new(ArgumentException_tEDCD16F20A09ECE461C3DA766C16EDA8864057D1_il2cpp_TypeInfo_var);
ArgumentException__ctor_m26DC3463C6F3C98BF33EA39598DD2B32F0249CA8(L_17, L_16, _stringLiteralFAA5E8C43BB2D5850732EFD9442E467318BFD9C8, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_17, NULL, Version_ToString_m8B385B5C25D9FD3A25EE2DDF02B592CAFC1C0AB0_RuntimeMethod_var);
}
IL_008a:
{
int32_t L_18 = ___fieldCount0;
if ((!(((uint32_t)L_18) == ((uint32_t)3))))
{
goto IL_00d3;
}
}
{
StringBuilder_t * L_19 = StringBuilderCache_Acquire_mCA3DDB17F0BFEF32DA9B4D7E8501D5705890557D(((int32_t)16), /*hidden argument*/NULL);
V_0 = L_19;
int32_t L_20 = __this->get__Major_0();
StringBuilder_t * L_21 = V_0;
IL2CPP_RUNTIME_CLASS_INIT(Version_tDBE6876C59B6F56D4F8CAA03851177ABC6FE0DFD_il2cpp_TypeInfo_var);
Version_AppendPositiveNumber_mEDCCE1D1AC63EE1F509538B86EA00A698A9D7C98(L_20, L_21, /*hidden argument*/NULL);
StringBuilder_t * L_22 = V_0;
NullCheck(L_22);
StringBuilder_Append_m05C12F58ADC2D807613A9301DF438CB3CD09B75A(L_22, ((int32_t)46), /*hidden argument*/NULL);
int32_t L_23 = __this->get__Minor_1();
StringBuilder_t * L_24 = V_0;
Version_AppendPositiveNumber_mEDCCE1D1AC63EE1F509538B86EA00A698A9D7C98(L_23, L_24, /*hidden argument*/NULL);
StringBuilder_t * L_25 = V_0;
NullCheck(L_25);
StringBuilder_Append_m05C12F58ADC2D807613A9301DF438CB3CD09B75A(L_25, ((int32_t)46), /*hidden argument*/NULL);
int32_t L_26 = __this->get__Build_2();
StringBuilder_t * L_27 = V_0;
Version_AppendPositiveNumber_mEDCCE1D1AC63EE1F509538B86EA00A698A9D7C98(L_26, L_27, /*hidden argument*/NULL);
StringBuilder_t * L_28 = V_0;
String_t* L_29 = StringBuilderCache_GetStringAndRelease_mDD5B8378FE9378CACF8660EB460E0CE545F215F7(L_28, /*hidden argument*/NULL);
return L_29;
}
IL_00d3:
{
int32_t L_30 = __this->get__Revision_3();
if ((!(((uint32_t)L_30) == ((uint32_t)(-1)))))
{
goto IL_0107;
}
}
{
ObjectU5BU5D_t3C9242B5C88A48B2A5BD9FDA6CD0024E792AF08A* L_31 = (ObjectU5BU5D_t3C9242B5C88A48B2A5BD9FDA6CD0024E792AF08A*)(ObjectU5BU5D_t3C9242B5C88A48B2A5BD9FDA6CD0024E792AF08A*)SZArrayNew(ObjectU5BU5D_t3C9242B5C88A48B2A5BD9FDA6CD0024E792AF08A_il2cpp_TypeInfo_var, (uint32_t)2);
ObjectU5BU5D_t3C9242B5C88A48B2A5BD9FDA6CD0024E792AF08A* L_32 = L_31;
NullCheck(L_32);
ArrayElementTypeCheck (L_32, _stringLiteralB6589FC6AB0DC82CF12099D1C2D40AB994E8410C);
(L_32)->SetAt(static_cast<il2cpp_array_size_t>(0), (RuntimeObject *)_stringLiteralB6589FC6AB0DC82CF12099D1C2D40AB994E8410C);
ObjectU5BU5D_t3C9242B5C88A48B2A5BD9FDA6CD0024E792AF08A* L_33 = L_32;
NullCheck(L_33);
ArrayElementTypeCheck (L_33, _stringLiteral77DE68DAECD823BABBB58EDB1C8E14D7106E83BB);
(L_33)->SetAt(static_cast<il2cpp_array_size_t>(1), (RuntimeObject *)_stringLiteral77DE68DAECD823BABBB58EDB1C8E14D7106E83BB);
String_t* L_34 = Environment_GetResourceString_m7389941B4C0688D875CC647D99A739DA2F907ADB(_stringLiteral868E70DE0948AAB2E5C3FEF19E1D3C1808994229, L_33, /*hidden argument*/NULL);
ArgumentException_tEDCD16F20A09ECE461C3DA766C16EDA8864057D1 * L_35 = (ArgumentException_tEDCD16F20A09ECE461C3DA766C16EDA8864057D1 *)il2cpp_codegen_object_new(ArgumentException_tEDCD16F20A09ECE461C3DA766C16EDA8864057D1_il2cpp_TypeInfo_var);
ArgumentException__ctor_m26DC3463C6F3C98BF33EA39598DD2B32F0249CA8(L_35, L_34, _stringLiteralFAA5E8C43BB2D5850732EFD9442E467318BFD9C8, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_35, NULL, Version_ToString_m8B385B5C25D9FD3A25EE2DDF02B592CAFC1C0AB0_RuntimeMethod_var);
}
IL_0107:
{
int32_t L_36 = ___fieldCount0;
if ((!(((uint32_t)L_36) == ((uint32_t)4))))
{
goto IL_0165;
}
}
{
StringBuilder_t * L_37 = StringBuilderCache_Acquire_mCA3DDB17F0BFEF32DA9B4D7E8501D5705890557D(((int32_t)16), /*hidden argument*/NULL);
V_0 = L_37;
int32_t L_38 = __this->get__Major_0();
StringBuilder_t * L_39 = V_0;
IL2CPP_RUNTIME_CLASS_INIT(Version_tDBE6876C59B6F56D4F8CAA03851177ABC6FE0DFD_il2cpp_TypeInfo_var);
Version_AppendPositiveNumber_mEDCCE1D1AC63EE1F509538B86EA00A698A9D7C98(L_38, L_39, /*hidden argument*/NULL);
StringBuilder_t * L_40 = V_0;
NullCheck(L_40);
StringBuilder_Append_m05C12F58ADC2D807613A9301DF438CB3CD09B75A(L_40, ((int32_t)46), /*hidden argument*/NULL);
int32_t L_41 = __this->get__Minor_1();
StringBuilder_t * L_42 = V_0;
Version_AppendPositiveNumber_mEDCCE1D1AC63EE1F509538B86EA00A698A9D7C98(L_41, L_42, /*hidden argument*/NULL);
StringBuilder_t * L_43 = V_0;
NullCheck(L_43);
StringBuilder_Append_m05C12F58ADC2D807613A9301DF438CB3CD09B75A(L_43, ((int32_t)46), /*hidden argument*/NULL);
int32_t L_44 = __this->get__Build_2();
StringBuilder_t * L_45 = V_0;
Version_AppendPositiveNumber_mEDCCE1D1AC63EE1F509538B86EA00A698A9D7C98(L_44, L_45, /*hidden argument*/NULL);
StringBuilder_t * L_46 = V_0;
NullCheck(L_46);
StringBuilder_Append_m05C12F58ADC2D807613A9301DF438CB3CD09B75A(L_46, ((int32_t)46), /*hidden argument*/NULL);
int32_t L_47 = __this->get__Revision_3();
StringBuilder_t * L_48 = V_0;
Version_AppendPositiveNumber_mEDCCE1D1AC63EE1F509538B86EA00A698A9D7C98(L_47, L_48, /*hidden argument*/NULL);
StringBuilder_t * L_49 = V_0;
String_t* L_50 = StringBuilderCache_GetStringAndRelease_mDD5B8378FE9378CACF8660EB460E0CE545F215F7(L_49, /*hidden argument*/NULL);
return L_50;
}
IL_0165:
{
ObjectU5BU5D_t3C9242B5C88A48B2A5BD9FDA6CD0024E792AF08A* L_51 = (ObjectU5BU5D_t3C9242B5C88A48B2A5BD9FDA6CD0024E792AF08A*)(ObjectU5BU5D_t3C9242B5C88A48B2A5BD9FDA6CD0024E792AF08A*)SZArrayNew(ObjectU5BU5D_t3C9242B5C88A48B2A5BD9FDA6CD0024E792AF08A_il2cpp_TypeInfo_var, (uint32_t)2);
ObjectU5BU5D_t3C9242B5C88A48B2A5BD9FDA6CD0024E792AF08A* L_52 = L_51;
NullCheck(L_52);
ArrayElementTypeCheck (L_52, _stringLiteralB6589FC6AB0DC82CF12099D1C2D40AB994E8410C);
(L_52)->SetAt(static_cast<il2cpp_array_size_t>(0), (RuntimeObject *)_stringLiteralB6589FC6AB0DC82CF12099D1C2D40AB994E8410C);
ObjectU5BU5D_t3C9242B5C88A48B2A5BD9FDA6CD0024E792AF08A* L_53 = L_52;
NullCheck(L_53);
ArrayElementTypeCheck (L_53, _stringLiteral1B6453892473A467D07372D45EB05ABC2031647A);
(L_53)->SetAt(static_cast<il2cpp_array_size_t>(1), (RuntimeObject *)_stringLiteral1B6453892473A467D07372D45EB05ABC2031647A);
String_t* L_54 = Environment_GetResourceString_m7389941B4C0688D875CC647D99A739DA2F907ADB(_stringLiteral868E70DE0948AAB2E5C3FEF19E1D3C1808994229, L_53, /*hidden argument*/NULL);
ArgumentException_tEDCD16F20A09ECE461C3DA766C16EDA8864057D1 * L_55 = (ArgumentException_tEDCD16F20A09ECE461C3DA766C16EDA8864057D1 *)il2cpp_codegen_object_new(ArgumentException_tEDCD16F20A09ECE461C3DA766C16EDA8864057D1_il2cpp_TypeInfo_var);
ArgumentException__ctor_m26DC3463C6F3C98BF33EA39598DD2B32F0249CA8(L_55, L_54, _stringLiteralFAA5E8C43BB2D5850732EFD9442E467318BFD9C8, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_55, NULL, Version_ToString_m8B385B5C25D9FD3A25EE2DDF02B592CAFC1C0AB0_RuntimeMethod_var);
}
}
// System.Void System.Version::AppendPositiveNumber(System.Int32,System.Text.StringBuilder)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void Version_AppendPositiveNumber_mEDCCE1D1AC63EE1F509538B86EA00A698A9D7C98 (int32_t ___num0, StringBuilder_t * ___sb1, const RuntimeMethod* method)
{
int32_t V_0 = 0;
int32_t V_1 = 0;
{
StringBuilder_t * L_0 = ___sb1;
NullCheck(L_0);
int32_t L_1 = StringBuilder_get_Length_m44BCD2BF32D45E9376761FF33AA429BFBD902F07(L_0, /*hidden argument*/NULL);
V_0 = L_1;
}
IL_0007:
{
int32_t L_2 = ___num0;
V_1 = ((int32_t)((int32_t)L_2%(int32_t)((int32_t)10)));
int32_t L_3 = ___num0;
___num0 = ((int32_t)((int32_t)L_3/(int32_t)((int32_t)10)));
StringBuilder_t * L_4 = ___sb1;
int32_t L_5 = V_0;
int32_t L_6 = V_1;
NullCheck(L_4);
StringBuilder_Insert_m5A00CEB69C56B823E3766C84114D8B8ACCFC67A1(L_4, L_5, (((int32_t)((uint16_t)((int32_t)il2cpp_codegen_add((int32_t)((int32_t)48), (int32_t)L_6))))), /*hidden argument*/NULL);
int32_t L_7 = ___num0;
if ((((int32_t)L_7) > ((int32_t)0)))
{
goto IL_0007;
}
}
{
return;
}
}
// System.Boolean System.Version::op_Equality(System.Version,System.Version)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool Version_op_Equality_m9E4E82DB85F13E3C19AB5D4AF94C4F399971374D (Version_tDBE6876C59B6F56D4F8CAA03851177ABC6FE0DFD * ___v10, Version_tDBE6876C59B6F56D4F8CAA03851177ABC6FE0DFD * ___v21, const RuntimeMethod* method)
{
{
Version_tDBE6876C59B6F56D4F8CAA03851177ABC6FE0DFD * L_0 = ___v10;
if (L_0)
{
goto IL_0008;
}
}
{
Version_tDBE6876C59B6F56D4F8CAA03851177ABC6FE0DFD * L_1 = ___v21;
return (bool)((((RuntimeObject*)(Version_tDBE6876C59B6F56D4F8CAA03851177ABC6FE0DFD *)L_1) == ((RuntimeObject*)(RuntimeObject *)NULL))? 1 : 0);
}
IL_0008:
{
Version_tDBE6876C59B6F56D4F8CAA03851177ABC6FE0DFD * L_2 = ___v10;
Version_tDBE6876C59B6F56D4F8CAA03851177ABC6FE0DFD * L_3 = ___v21;
NullCheck(L_2);
bool L_4 = Version_Equals_m7C93B95F0594CB28E1B1C96936B03069BF8968D3(L_2, L_3, /*hidden argument*/NULL);
return L_4;
}
}
// System.Boolean System.Version::op_Inequality(System.Version,System.Version)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool Version_op_Inequality_mBF83F266057D2C028BA2F423372DA7E738B25CD0 (Version_tDBE6876C59B6F56D4F8CAA03851177ABC6FE0DFD * ___v10, Version_tDBE6876C59B6F56D4F8CAA03851177ABC6FE0DFD * ___v21, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (Version_op_Inequality_mBF83F266057D2C028BA2F423372DA7E738B25CD0_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
Version_tDBE6876C59B6F56D4F8CAA03851177ABC6FE0DFD * L_0 = ___v10;
Version_tDBE6876C59B6F56D4F8CAA03851177ABC6FE0DFD * L_1 = ___v21;
IL2CPP_RUNTIME_CLASS_INIT(Version_tDBE6876C59B6F56D4F8CAA03851177ABC6FE0DFD_il2cpp_TypeInfo_var);
bool L_2 = Version_op_Equality_m9E4E82DB85F13E3C19AB5D4AF94C4F399971374D(L_0, L_1, /*hidden argument*/NULL);
return (bool)((((int32_t)L_2) == ((int32_t)0))? 1 : 0);
}
}
// System.Void System.Version::.cctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void Version__cctor_m255F2F683982C0B54105CCDAFF40FF467B19B8D3 (const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (Version__cctor_m255F2F683982C0B54105CCDAFF40FF467B19B8D3_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
CharU5BU5D_t4CC6ABF0AD71BEC97E3C2F1E9C5677E46D3A75C2* L_0 = (CharU5BU5D_t4CC6ABF0AD71BEC97E3C2F1E9C5677E46D3A75C2*)(CharU5BU5D_t4CC6ABF0AD71BEC97E3C2F1E9C5677E46D3A75C2*)SZArrayNew(CharU5BU5D_t4CC6ABF0AD71BEC97E3C2F1E9C5677E46D3A75C2_il2cpp_TypeInfo_var, (uint32_t)1);
CharU5BU5D_t4CC6ABF0AD71BEC97E3C2F1E9C5677E46D3A75C2* L_1 = L_0;
NullCheck(L_1);
(L_1)->SetAt(static_cast<il2cpp_array_size_t>(0), (Il2CppChar)((int32_t)46));
((Version_tDBE6876C59B6F56D4F8CAA03851177ABC6FE0DFD_StaticFields*)il2cpp_codegen_static_fields_for(Version_tDBE6876C59B6F56D4F8CAA03851177ABC6FE0DFD_il2cpp_TypeInfo_var))->set_SeparatorsArray_4(L_1);
return;
}
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.WeakReference::AllocateHandle(System.Object)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void WeakReference_AllocateHandle_m116757CBF336A309363C5F2DFE13A2E426368780 (WeakReference_t0495CC81CD6403E662B7700B802443F6F730E39D * __this, RuntimeObject * ___target0, const RuntimeMethod* method)
{
{
bool L_0 = __this->get_isLongReference_0();
if (!L_0)
{
goto IL_0016;
}
}
{
RuntimeObject * L_1 = ___target0;
GCHandle_t39FAEE3EA592432C93B574A31DD83B87F1847DE3 L_2 = GCHandle_Alloc_m30DAF14F75E3A692C594965CE6724E2454DE9A2E(L_1, 1, /*hidden argument*/NULL);
__this->set_gcHandle_1(L_2);
return;
}
IL_0016:
{
RuntimeObject * L_3 = ___target0;
GCHandle_t39FAEE3EA592432C93B574A31DD83B87F1847DE3 L_4 = GCHandle_Alloc_m30DAF14F75E3A692C594965CE6724E2454DE9A2E(L_3, 0, /*hidden argument*/NULL);
__this->set_gcHandle_1(L_4);
return;
}
}
// System.Void System.WeakReference::.ctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void WeakReference__ctor_m4CF255427FB5EE28DA76A12EF072BAA3778AA6AF (WeakReference_t0495CC81CD6403E662B7700B802443F6F730E39D * __this, const RuntimeMethod* method)
{
{
Object__ctor_m925ECA5E85CA100E3FB86A4F9E15C120E9A184C0(__this, /*hidden argument*/NULL);
return;
}
}
// System.Void System.WeakReference::.ctor(System.Object)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void WeakReference__ctor_m12F7412E9F228AA2276BBB37441CFBCD21A0ABBB (WeakReference_t0495CC81CD6403E662B7700B802443F6F730E39D * __this, RuntimeObject * ___target0, const RuntimeMethod* method)
{
{
RuntimeObject * L_0 = ___target0;
WeakReference__ctor_m55A06AD20FF65C11015FFBE5FF31F2E7B1656E20(__this, L_0, (bool)0, /*hidden argument*/NULL);
return;
}
}
// System.Void System.WeakReference::.ctor(System.Object,System.Boolean)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void WeakReference__ctor_m55A06AD20FF65C11015FFBE5FF31F2E7B1656E20 (WeakReference_t0495CC81CD6403E662B7700B802443F6F730E39D * __this, RuntimeObject * ___target0, bool ___trackResurrection1, const RuntimeMethod* method)
{
{
Object__ctor_m925ECA5E85CA100E3FB86A4F9E15C120E9A184C0(__this, /*hidden argument*/NULL);
bool L_0 = ___trackResurrection1;
__this->set_isLongReference_0(L_0);
RuntimeObject * L_1 = ___target0;
WeakReference_AllocateHandle_m116757CBF336A309363C5F2DFE13A2E426368780(__this, L_1, /*hidden argument*/NULL);
return;
}
}
// System.Void System.WeakReference::.ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void WeakReference__ctor_m9740BD0F2AEC959BF2210503D085723C6C1E09DF (WeakReference_t0495CC81CD6403E662B7700B802443F6F730E39D * __this, SerializationInfo_t1BB80E9C9DEA52DBF464487234B045E2930ADA26 * ___info0, StreamingContext_t2CCDC54E0E8D078AF4A50E3A8B921B828A900034 ___context1, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (WeakReference__ctor_m9740BD0F2AEC959BF2210503D085723C6C1E09DF_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
RuntimeObject * V_0 = NULL;
{
Object__ctor_m925ECA5E85CA100E3FB86A4F9E15C120E9A184C0(__this, /*hidden argument*/NULL);
SerializationInfo_t1BB80E9C9DEA52DBF464487234B045E2930ADA26 * L_0 = ___info0;
if (L_0)
{
goto IL_0014;
}
}
{
ArgumentNullException_t581DF992B1F3E0EC6EFB30CC5DC43519A79B27AD * L_1 = (ArgumentNullException_t581DF992B1F3E0EC6EFB30CC5DC43519A79B27AD *)il2cpp_codegen_object_new(ArgumentNullException_t581DF992B1F3E0EC6EFB30CC5DC43519A79B27AD_il2cpp_TypeInfo_var);
ArgumentNullException__ctor_mEE0C0D6FCB2D08CD7967DBB1329A0854BBED49ED(L_1, _stringLiteral59BD0A3FF43B32849B319E645D4798D8A5D1E889, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_1, NULL, WeakReference__ctor_m9740BD0F2AEC959BF2210503D085723C6C1E09DF_RuntimeMethod_var);
}
IL_0014:
{
SerializationInfo_t1BB80E9C9DEA52DBF464487234B045E2930ADA26 * L_2 = ___info0;
NullCheck(L_2);
bool L_3 = SerializationInfo_GetBoolean_m5CAA35E19A152535A5481502BEDBC7A0E276E455(L_2, _stringLiteralA9914DA9D64B4FCE39273016F570714425122C67, /*hidden argument*/NULL);
__this->set_isLongReference_0(L_3);
SerializationInfo_t1BB80E9C9DEA52DBF464487234B045E2930ADA26 * L_4 = ___info0;
RuntimeTypeHandle_t7B542280A22F0EC4EAC2061C29178845847A8B2D L_5 = { reinterpret_cast<intptr_t> (RuntimeObject_0_0_0_var) };
IL2CPP_RUNTIME_CLASS_INIT(Type_t_il2cpp_TypeInfo_var);
Type_t * L_6 = Type_GetTypeFromHandle_m9DC58ADF0512987012A8A016FB64B068F3B1AFF6(L_5, /*hidden argument*/NULL);
NullCheck(L_4);
RuntimeObject * L_7 = SerializationInfo_GetValue_m7910CE6C68888C1F863D7A35915391FA33463ECF(L_4, _stringLiteral7E95DB629C3A5AA1BCFEB547A0BD39A78FE49276, L_6, /*hidden argument*/NULL);
V_0 = L_7;
RuntimeObject * L_8 = V_0;
WeakReference_AllocateHandle_m116757CBF336A309363C5F2DFE13A2E426368780(__this, L_8, /*hidden argument*/NULL);
return;
}
}
// System.Object System.WeakReference::get_Target()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * WeakReference_get_Target_mF924E58A87EF45E9D2A464FAA36B7A6079F10B1F (WeakReference_t0495CC81CD6403E662B7700B802443F6F730E39D * __this, const RuntimeMethod* method)
{
{
GCHandle_t39FAEE3EA592432C93B574A31DD83B87F1847DE3 * L_0 = __this->get_address_of_gcHandle_1();
bool L_1 = GCHandle_get_IsAllocated_m91323BCB568B1150F90515EF862B00F193E77808((GCHandle_t39FAEE3EA592432C93B574A31DD83B87F1847DE3 *)L_0, /*hidden argument*/NULL);
if (L_1)
{
goto IL_000f;
}
}
{
return NULL;
}
IL_000f:
{
GCHandle_t39FAEE3EA592432C93B574A31DD83B87F1847DE3 * L_2 = __this->get_address_of_gcHandle_1();
RuntimeObject * L_3 = GCHandle_get_Target_mDBDEA6883245CF1EF963D9FA945569B2D59DCCF8((GCHandle_t39FAEE3EA592432C93B574A31DD83B87F1847DE3 *)L_2, /*hidden argument*/NULL);
return L_3;
}
}
// System.Boolean System.WeakReference::get_TrackResurrection()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool WeakReference_get_TrackResurrection_m047E08E5BE894FCF92A620D86FDB77C9DA559D56 (WeakReference_t0495CC81CD6403E662B7700B802443F6F730E39D * __this, const RuntimeMethod* method)
{
{
bool L_0 = __this->get_isLongReference_0();
return L_0;
}
}
// System.Void System.WeakReference::Finalize()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void WeakReference_Finalize_m02C66F00C0F5E656FDF04E9A455A19E94A95F827 (WeakReference_t0495CC81CD6403E662B7700B802443F6F730E39D * __this, const RuntimeMethod* method)
{
Exception_t * __last_unhandled_exception = 0;
NO_UNUSED_WARNING (__last_unhandled_exception);
Exception_t * __exception_local = 0;
NO_UNUSED_WARNING (__exception_local);
int32_t __leave_target = -1;
NO_UNUSED_WARNING (__leave_target);
IL_0000:
try
{ // begin try (depth: 1)
GCHandle_t39FAEE3EA592432C93B574A31DD83B87F1847DE3 * L_0 = __this->get_address_of_gcHandle_1();
GCHandle_Free_m392ECC9B1058E35A0FD5CF21A65F212873FC26F0((GCHandle_t39FAEE3EA592432C93B574A31DD83B87F1847DE3 *)L_0, /*hidden argument*/NULL);
IL2CPP_LEAVE(0x14, FINALLY_000d);
} // end try (depth: 1)
catch(Il2CppExceptionWrapper& e)
{
__last_unhandled_exception = (Exception_t *)e.ex;
goto FINALLY_000d;
}
FINALLY_000d:
{ // begin finally (depth: 1)
Object_Finalize_m4015B7D3A44DE125C5FE34D7276CD4697C06F380(__this, /*hidden argument*/NULL);
IL2CPP_RESET_LEAVE(0x14);
IL2CPP_END_FINALLY(13)
} // end finally (depth: 1)
IL2CPP_CLEANUP(13)
{
IL2CPP_JUMP_TBL(0x14, IL_0014)
IL2CPP_RETHROW_IF_UNHANDLED(Exception_t *)
}
IL_0014:
{
return;
}
}
// System.Void System.WeakReference::GetObjectData(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void WeakReference_GetObjectData_m1DBED399F8C4A13F8C764A2AADFC5B6EBA5643D4 (WeakReference_t0495CC81CD6403E662B7700B802443F6F730E39D * __this, SerializationInfo_t1BB80E9C9DEA52DBF464487234B045E2930ADA26 * ___info0, StreamingContext_t2CCDC54E0E8D078AF4A50E3A8B921B828A900034 ___context1, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (WeakReference_GetObjectData_m1DBED399F8C4A13F8C764A2AADFC5B6EBA5643D4_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
Exception_t * __last_unhandled_exception = 0;
NO_UNUSED_WARNING (__last_unhandled_exception);
Exception_t * __exception_local = 0;
NO_UNUSED_WARNING (__exception_local);
int32_t __leave_target = -1;
NO_UNUSED_WARNING (__leave_target);
{
SerializationInfo_t1BB80E9C9DEA52DBF464487234B045E2930ADA26 * L_0 = ___info0;
if (L_0)
{
goto IL_000e;
}
}
{
ArgumentNullException_t581DF992B1F3E0EC6EFB30CC5DC43519A79B27AD * L_1 = (ArgumentNullException_t581DF992B1F3E0EC6EFB30CC5DC43519A79B27AD *)il2cpp_codegen_object_new(ArgumentNullException_t581DF992B1F3E0EC6EFB30CC5DC43519A79B27AD_il2cpp_TypeInfo_var);
ArgumentNullException__ctor_mEE0C0D6FCB2D08CD7967DBB1329A0854BBED49ED(L_1, _stringLiteral59BD0A3FF43B32849B319E645D4798D8A5D1E889, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_1, NULL, WeakReference_GetObjectData_m1DBED399F8C4A13F8C764A2AADFC5B6EBA5643D4_RuntimeMethod_var);
}
IL_000e:
{
SerializationInfo_t1BB80E9C9DEA52DBF464487234B045E2930ADA26 * L_2 = ___info0;
bool L_3 = VirtFuncInvoker0< bool >::Invoke(6 /* System.Boolean System.WeakReference::get_TrackResurrection() */, __this);
NullCheck(L_2);
SerializationInfo_AddValue_m1229CE68F507974EBA0DA9C7C728A09E611D18B1(L_2, _stringLiteralA9914DA9D64B4FCE39273016F570714425122C67, L_3, /*hidden argument*/NULL);
}
IL_001f:
try
{ // begin try (depth: 1)
SerializationInfo_t1BB80E9C9DEA52DBF464487234B045E2930ADA26 * L_4 = ___info0;
RuntimeObject * L_5 = VirtFuncInvoker0< RuntimeObject * >::Invoke(5 /* System.Object System.WeakReference::get_Target() */, __this);
NullCheck(L_4);
SerializationInfo_AddValue_mC9D1E16476E24E1AFE7C59368D3BC0B35F64FBC6(L_4, _stringLiteral7E95DB629C3A5AA1BCFEB547A0BD39A78FE49276, L_5, /*hidden argument*/NULL);
goto IL_0041;
} // end try (depth: 1)
catch(Il2CppExceptionWrapper& e)
{
__exception_local = (Exception_t *)e.ex;
if(il2cpp_codegen_class_is_assignable_from (Exception_t_il2cpp_TypeInfo_var, il2cpp_codegen_object_class(e.ex)))
goto CATCH_0032;
throw e;
}
CATCH_0032:
{ // begin catch(System.Exception)
SerializationInfo_t1BB80E9C9DEA52DBF464487234B045E2930ADA26 * L_6 = ___info0;
NullCheck(L_6);
SerializationInfo_AddValue_mC9D1E16476E24E1AFE7C59368D3BC0B35F64FBC6(L_6, _stringLiteral7E95DB629C3A5AA1BCFEB547A0BD39A78FE49276, NULL, /*hidden argument*/NULL);
goto IL_0041;
} // end catch (depth: 1)
IL_0041:
{
return;
}
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.WindowsConsoleDriver::.ctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void WindowsConsoleDriver__ctor_m9C9E675288391C478152CCB5789D7726611BF70D (WindowsConsoleDriver_t953AB92956013BD3ED7E260FEC4944E603008B42 * __this, const RuntimeMethod* method)
{
ConsoleScreenBufferInfo_tA8045B7C44EF25956D3B0847F24465E9CF18954F V_0;
memset((&V_0), 0, sizeof(V_0));
{
Object__ctor_m925ECA5E85CA100E3FB86A4F9E15C120E9A184C0(__this, /*hidden argument*/NULL);
intptr_t L_0 = WindowsConsoleDriver_GetStdHandle_m411672A3E27D4266E946FF166C9DA279A75B3FB5(((int32_t)-11), /*hidden argument*/NULL);
__this->set_outputHandle_1((intptr_t)L_0);
intptr_t L_1 = WindowsConsoleDriver_GetStdHandle_m411672A3E27D4266E946FF166C9DA279A75B3FB5(((int32_t)-10), /*hidden argument*/NULL);
__this->set_inputHandle_0((intptr_t)L_1);
il2cpp_codegen_initobj((&V_0), sizeof(ConsoleScreenBufferInfo_tA8045B7C44EF25956D3B0847F24465E9CF18954F ));
intptr_t L_2 = __this->get_outputHandle_1();
WindowsConsoleDriver_GetConsoleScreenBufferInfo_m0DF841B5A1BF2651A1D9BFEA3D61280110461C80((intptr_t)L_2, (ConsoleScreenBufferInfo_tA8045B7C44EF25956D3B0847F24465E9CF18954F *)(&V_0), /*hidden argument*/NULL);
ConsoleScreenBufferInfo_tA8045B7C44EF25956D3B0847F24465E9CF18954F L_3 = V_0;
int16_t L_4 = L_3.get_Attribute_2();
__this->set_defaultAttribute_2(L_4);
return;
}
}
// System.ConsoleKeyInfo System.WindowsConsoleDriver::ReadKey(System.Boolean)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR ConsoleKeyInfo_t5BE3CE05E8258CDB5404256E96AF7C22BC5DE768 WindowsConsoleDriver_ReadKey_mDE4EDC7320EFF2B8D0B888A203D0C96531855568 (WindowsConsoleDriver_t953AB92956013BD3ED7E260FEC4944E603008B42 * __this, bool ___intercept0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (WindowsConsoleDriver_ReadKey_mDE4EDC7320EFF2B8D0B888A203D0C96531855568_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
int32_t V_0 = 0;
InputRecord_tAB007C739F339BE208F3C4796B53E9044ADF0A78 V_1;
memset((&V_1), 0, sizeof(V_1));
bool V_2 = false;
bool V_3 = false;
bool V_4 = false;
{
il2cpp_codegen_initobj((&V_1), sizeof(InputRecord_tAB007C739F339BE208F3C4796B53E9044ADF0A78 ));
}
IL_0008:
{
intptr_t L_0 = __this->get_inputHandle_0();
bool L_1 = WindowsConsoleDriver_ReadConsoleInput_mAA31A86190A2F7B76CD7205DCE7C2743E7C8AAA2((intptr_t)L_0, (InputRecord_tAB007C739F339BE208F3C4796B53E9044ADF0A78 *)(&V_1), 1, (int32_t*)(&V_0), /*hidden argument*/NULL);
if (L_1)
{
goto IL_0034;
}
}
{
IL2CPP_RUNTIME_CLASS_INIT(Marshal_tC795CE9CC2FFBA41EDB1AC1C0FEC04607DFA8A40_il2cpp_TypeInfo_var);
int32_t L_2 = Marshal_GetLastWin32Error_mE1A714E69515F70001BA6714077880530257AEC7(/*hidden argument*/NULL);
int32_t L_3 = L_2;
RuntimeObject * L_4 = Box(Int32_t585191389E07734F19F3156FF88FB3EF4800D102_il2cpp_TypeInfo_var, &L_3);
String_t* L_5 = String_Concat_mBB19C73816BDD1C3519F248E1ADC8E11A6FDB495(_stringLiteral68EB0192F01DDAA7B81A607B464BC951839404CE, L_4, /*hidden argument*/NULL);
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_6 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_6, L_5, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_6, NULL, WindowsConsoleDriver_ReadKey_mDE4EDC7320EFF2B8D0B888A203D0C96531855568_RuntimeMethod_var);
}
IL_0034:
{
InputRecord_tAB007C739F339BE208F3C4796B53E9044ADF0A78 L_7 = V_1;
bool L_8 = L_7.get_KeyDown_1();
if (!L_8)
{
goto IL_0008;
}
}
{
InputRecord_tAB007C739F339BE208F3C4796B53E9044ADF0A78 L_9 = V_1;
int16_t L_10 = L_9.get_EventType_0();
if ((!(((uint32_t)L_10) == ((uint32_t)1))))
{
goto IL_0008;
}
}
{
InputRecord_tAB007C739F339BE208F3C4796B53E9044ADF0A78 L_11 = V_1;
int16_t L_12 = L_11.get_VirtualKeyCode_3();
bool L_13 = WindowsConsoleDriver_IsModifierKey_mCBF637C09E9D2BD063E44FA5C8B8D2E317C4A1AE(L_12, /*hidden argument*/NULL);
if (L_13)
{
goto IL_0008;
}
}
{
InputRecord_tAB007C739F339BE208F3C4796B53E9044ADF0A78 L_14 = V_1;
int32_t L_15 = L_14.get_ControlKeyState_6();
V_2 = (bool)((!(((uint32_t)((int32_t)((int32_t)L_15&(int32_t)3))) <= ((uint32_t)0)))? 1 : 0);
InputRecord_tAB007C739F339BE208F3C4796B53E9044ADF0A78 L_16 = V_1;
int32_t L_17 = L_16.get_ControlKeyState_6();
V_3 = (bool)((!(((uint32_t)((int32_t)((int32_t)L_17&(int32_t)((int32_t)12)))) <= ((uint32_t)0)))? 1 : 0);
InputRecord_tAB007C739F339BE208F3C4796B53E9044ADF0A78 L_18 = V_1;
int32_t L_19 = L_18.get_ControlKeyState_6();
V_4 = (bool)((!(((uint32_t)((int32_t)((int32_t)L_19&(int32_t)((int32_t)16)))) <= ((uint32_t)0)))? 1 : 0);
InputRecord_tAB007C739F339BE208F3C4796B53E9044ADF0A78 L_20 = V_1;
Il2CppChar L_21 = L_20.get_Character_5();
InputRecord_tAB007C739F339BE208F3C4796B53E9044ADF0A78 L_22 = V_1;
int16_t L_23 = L_22.get_VirtualKeyCode_3();
bool L_24 = V_4;
bool L_25 = V_2;
bool L_26 = V_3;
ConsoleKeyInfo_t5BE3CE05E8258CDB5404256E96AF7C22BC5DE768 L_27;
memset((&L_27), 0, sizeof(L_27));
ConsoleKeyInfo__ctor_mF5F427F75CCD5D4BCAADCE6AE31F61D70BD95B98((&L_27), L_21, L_23, L_24, L_25, L_26, /*hidden argument*/NULL);
return L_27;
}
}
// System.Boolean System.WindowsConsoleDriver::IsModifierKey(System.Int16)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool WindowsConsoleDriver_IsModifierKey_mCBF637C09E9D2BD063E44FA5C8B8D2E317C4A1AE (int16_t ___virtualKeyCode0, const RuntimeMethod* method)
{
{
int16_t L_0 = ___virtualKeyCode0;
if ((!(((uint32_t)((int32_t)il2cpp_codegen_subtract((int32_t)L_0, (int32_t)((int32_t)16)))) > ((uint32_t)2))))
{
goto IL_0016;
}
}
{
int16_t L_1 = ___virtualKeyCode0;
if ((((int32_t)L_1) == ((int32_t)((int32_t)20))))
{
goto IL_0016;
}
}
{
int16_t L_2 = ___virtualKeyCode0;
if ((!(((uint32_t)((int32_t)il2cpp_codegen_subtract((int32_t)L_2, (int32_t)((int32_t)144)))) <= ((uint32_t)1))))
{
goto IL_0018;
}
}
IL_0016:
{
return (bool)1;
}
IL_0018:
{
return (bool)0;
}
}
#if FORCE_PINVOKE_INTERNAL
IL2CPP_EXTERN_C intptr_t DEFAULT_CALL GetStdHandle(int32_t);
#endif
// System.IntPtr System.WindowsConsoleDriver::GetStdHandle(System.Handles)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR intptr_t WindowsConsoleDriver_GetStdHandle_m411672A3E27D4266E946FF166C9DA279A75B3FB5 (int32_t ___handle0, const RuntimeMethod* method)
{
typedef intptr_t (DEFAULT_CALL *PInvokeFunc) (int32_t);
#if !FORCE_PINVOKE_INTERNAL
static PInvokeFunc il2cppPInvokeFunc;
if (il2cppPInvokeFunc == NULL)
{
int parameterSize = sizeof(int32_t);
il2cppPInvokeFunc = il2cpp_codegen_resolve_pinvoke<PInvokeFunc>(IL2CPP_NATIVE_STRING("kernel32.dll"), "GetStdHandle", IL2CPP_CALL_DEFAULT, CHARSET_UNICODE, parameterSize, false);
if (il2cppPInvokeFunc == NULL)
{
IL2CPP_RAISE_MANAGED_EXCEPTION(il2cpp_codegen_get_not_supported_exception("Unable to find method for p/invoke: 'GetStdHandle'"), NULL, NULL);
}
}
#endif
// Native function invocation
#if FORCE_PINVOKE_INTERNAL
intptr_t returnValue = reinterpret_cast<PInvokeFunc>(GetStdHandle)(___handle0);
#else
intptr_t returnValue = il2cppPInvokeFunc(___handle0);
#endif
il2cpp_codegen_marshal_store_last_error();
return returnValue;
}
#if FORCE_PINVOKE_INTERNAL
IL2CPP_EXTERN_C int32_t DEFAULT_CALL GetConsoleScreenBufferInfo(intptr_t, ConsoleScreenBufferInfo_tA8045B7C44EF25956D3B0847F24465E9CF18954F *);
#endif
// System.Boolean System.WindowsConsoleDriver::GetConsoleScreenBufferInfo(System.IntPtr,System.ConsoleScreenBufferInfoU26)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool WindowsConsoleDriver_GetConsoleScreenBufferInfo_m0DF841B5A1BF2651A1D9BFEA3D61280110461C80 (intptr_t ___handle0, ConsoleScreenBufferInfo_tA8045B7C44EF25956D3B0847F24465E9CF18954F * ___info1, const RuntimeMethod* method)
{
typedef int32_t (DEFAULT_CALL *PInvokeFunc) (intptr_t, ConsoleScreenBufferInfo_tA8045B7C44EF25956D3B0847F24465E9CF18954F *);
#if !FORCE_PINVOKE_INTERNAL
static PInvokeFunc il2cppPInvokeFunc;
if (il2cppPInvokeFunc == NULL)
{
int parameterSize = sizeof(intptr_t) + sizeof(ConsoleScreenBufferInfo_tA8045B7C44EF25956D3B0847F24465E9CF18954F *);
il2cppPInvokeFunc = il2cpp_codegen_resolve_pinvoke<PInvokeFunc>(IL2CPP_NATIVE_STRING("kernel32.dll"), "GetConsoleScreenBufferInfo", IL2CPP_CALL_DEFAULT, CHARSET_UNICODE, parameterSize, false);
if (il2cppPInvokeFunc == NULL)
{
IL2CPP_RAISE_MANAGED_EXCEPTION(il2cpp_codegen_get_not_supported_exception("Unable to find method for p/invoke: 'GetConsoleScreenBufferInfo'"), NULL, NULL);
}
}
#endif
// Native function invocation
#if FORCE_PINVOKE_INTERNAL
int32_t returnValue = reinterpret_cast<PInvokeFunc>(GetConsoleScreenBufferInfo)(___handle0, ___info1);
#else
int32_t returnValue = il2cppPInvokeFunc(___handle0, ___info1);
#endif
il2cpp_codegen_marshal_store_last_error();
return static_cast<bool>(returnValue);
}
#if FORCE_PINVOKE_INTERNAL
IL2CPP_EXTERN_C int32_t DEFAULT_CALL ReadConsoleInput(intptr_t, InputRecord_tAB007C739F339BE208F3C4796B53E9044ADF0A78_marshaled_pinvoke*, int32_t, int32_t*);
#endif
// System.Boolean System.WindowsConsoleDriver::ReadConsoleInput(System.IntPtr,System.InputRecordU26,System.Int32,System.Int32U26)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool WindowsConsoleDriver_ReadConsoleInput_mAA31A86190A2F7B76CD7205DCE7C2743E7C8AAA2 (intptr_t ___handle0, InputRecord_tAB007C739F339BE208F3C4796B53E9044ADF0A78 * ___record1, int32_t ___length2, int32_t* ___nread3, const RuntimeMethod* method)
{
typedef int32_t (DEFAULT_CALL *PInvokeFunc) (intptr_t, InputRecord_tAB007C739F339BE208F3C4796B53E9044ADF0A78_marshaled_pinvoke*, int32_t, int32_t*);
#if !FORCE_PINVOKE_INTERNAL
static PInvokeFunc il2cppPInvokeFunc;
if (il2cppPInvokeFunc == NULL)
{
int parameterSize = sizeof(intptr_t) + sizeof(InputRecord_tAB007C739F339BE208F3C4796B53E9044ADF0A78_marshaled_pinvoke*) + sizeof(int32_t) + sizeof(int32_t*);
il2cppPInvokeFunc = il2cpp_codegen_resolve_pinvoke<PInvokeFunc>(IL2CPP_NATIVE_STRING("kernel32.dll"), "ReadConsoleInput", IL2CPP_CALL_DEFAULT, CHARSET_UNICODE, parameterSize, false);
if (il2cppPInvokeFunc == NULL)
{
IL2CPP_RAISE_MANAGED_EXCEPTION(il2cpp_codegen_get_not_supported_exception("Unable to find method for p/invoke: 'ReadConsoleInput'"), NULL, NULL);
}
}
#endif
// Marshaling of parameter U27___record1U27 to native representation
InputRecord_tAB007C739F339BE208F3C4796B53E9044ADF0A78_marshaled_pinvoke ____record1_empty = {};
InputRecord_tAB007C739F339BE208F3C4796B53E9044ADF0A78_marshaled_pinvoke* ____record1_marshaled = &____record1_empty;
// Native function invocation
#if FORCE_PINVOKE_INTERNAL
int32_t returnValue = reinterpret_cast<PInvokeFunc>(ReadConsoleInput)(___handle0, ____record1_marshaled, ___length2, ___nread3);
#else
int32_t returnValue = il2cppPInvokeFunc(___handle0, ____record1_marshaled, ___length2, ___nread3);
#endif
il2cpp_codegen_marshal_store_last_error();
// Marshaling of parameter U27___record1U27 back from native representation
InputRecord_tAB007C739F339BE208F3C4796B53E9044ADF0A78 _____record1_marshaled_unmarshaled_dereferenced;
memset((&_____record1_marshaled_unmarshaled_dereferenced), 0, sizeof(_____record1_marshaled_unmarshaled_dereferenced));
InputRecord_tAB007C739F339BE208F3C4796B53E9044ADF0A78_marshal_pinvoke_back(*____record1_marshaled, _____record1_marshaled_unmarshaled_dereferenced);
*___record1 = _____record1_marshaled_unmarshaled_dereferenced;
// Marshaling cleanup of parameter U27___record1U27 native representation
InputRecord_tAB007C739F339BE208F3C4796B53E9044ADF0A78_marshal_pinvoke_cleanup(*____record1_marshaled);
return static_cast<bool>(returnValue);
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.__ComObject::.ctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void __ComObject__ctor_m2A98911F497D95AC1C931674CC745F002A36C878 (__ComObject_t7C4C78B18A827C344A9826ECC7FCC40B7F6FD77C * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (__ComObject__ctor_m2A98911F497D95AC1C931674CC745F002A36C878_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
Object__ctor_m925ECA5E85CA100E3FB86A4F9E15C120E9A184C0(__this, /*hidden argument*/NULL);
NotSupportedException_tE75B318D6590A02A5D9B29FD97409B1750FA0010 * L_0 = (NotSupportedException_tE75B318D6590A02A5D9B29FD97409B1750FA0010 *)il2cpp_codegen_object_new(NotSupportedException_tE75B318D6590A02A5D9B29FD97409B1750FA0010_il2cpp_TypeInfo_var);
NotSupportedException__ctor_mA121DE1CAC8F25277DEB489DC7771209D91CAE33(L_0, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_0, NULL, __ComObject__ctor_m2A98911F497D95AC1C931674CC745F002A36C878_RuntimeMethod_var);
}
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// Conversion methods for marshalling of: System.__DTString
IL2CPP_EXTERN_C void __DTString_t6E7DE2A99E4F15F384EC29CC6CD5185F46818DD9_marshal_pinvoke(const __DTString_t6E7DE2A99E4F15F384EC29CC6CD5185F46818DD9& unmarshaled, __DTString_t6E7DE2A99E4F15F384EC29CC6CD5185F46818DD9_marshaled_pinvoke& marshaled)
{
Exception_t* ___m_info_4Exception = il2cpp_codegen_get_marshal_directive_exception("Cannot marshal field 'm_info' of type '__DTString': Reference type field marshaling is not supported.");
IL2CPP_RAISE_MANAGED_EXCEPTION(___m_info_4Exception, NULL, NULL);
}
IL2CPP_EXTERN_C void __DTString_t6E7DE2A99E4F15F384EC29CC6CD5185F46818DD9_marshal_pinvoke_back(const __DTString_t6E7DE2A99E4F15F384EC29CC6CD5185F46818DD9_marshaled_pinvoke& marshaled, __DTString_t6E7DE2A99E4F15F384EC29CC6CD5185F46818DD9& unmarshaled)
{
Exception_t* ___m_info_4Exception = il2cpp_codegen_get_marshal_directive_exception("Cannot marshal field 'm_info' of type '__DTString': Reference type field marshaling is not supported.");
IL2CPP_RAISE_MANAGED_EXCEPTION(___m_info_4Exception, NULL, NULL);
}
// Conversion method for clean up from marshalling of: System.__DTString
IL2CPP_EXTERN_C void __DTString_t6E7DE2A99E4F15F384EC29CC6CD5185F46818DD9_marshal_pinvoke_cleanup(__DTString_t6E7DE2A99E4F15F384EC29CC6CD5185F46818DD9_marshaled_pinvoke& marshaled)
{
}
// Conversion methods for marshalling of: System.__DTString
IL2CPP_EXTERN_C void __DTString_t6E7DE2A99E4F15F384EC29CC6CD5185F46818DD9_marshal_com(const __DTString_t6E7DE2A99E4F15F384EC29CC6CD5185F46818DD9& unmarshaled, __DTString_t6E7DE2A99E4F15F384EC29CC6CD5185F46818DD9_marshaled_com& marshaled)
{
Exception_t* ___m_info_4Exception = il2cpp_codegen_get_marshal_directive_exception("Cannot marshal field 'm_info' of type '__DTString': Reference type field marshaling is not supported.");
IL2CPP_RAISE_MANAGED_EXCEPTION(___m_info_4Exception, NULL, NULL);
}
IL2CPP_EXTERN_C void __DTString_t6E7DE2A99E4F15F384EC29CC6CD5185F46818DD9_marshal_com_back(const __DTString_t6E7DE2A99E4F15F384EC29CC6CD5185F46818DD9_marshaled_com& marshaled, __DTString_t6E7DE2A99E4F15F384EC29CC6CD5185F46818DD9& unmarshaled)
{
Exception_t* ___m_info_4Exception = il2cpp_codegen_get_marshal_directive_exception("Cannot marshal field 'm_info' of type '__DTString': Reference type field marshaling is not supported.");
IL2CPP_RAISE_MANAGED_EXCEPTION(___m_info_4Exception, NULL, NULL);
}
// Conversion method for clean up from marshalling of: System.__DTString
IL2CPP_EXTERN_C void __DTString_t6E7DE2A99E4F15F384EC29CC6CD5185F46818DD9_marshal_com_cleanup(__DTString_t6E7DE2A99E4F15F384EC29CC6CD5185F46818DD9_marshaled_com& marshaled)
{
}
// System.Void System.__DTString::.ctor(System.String,System.Globalization.DateTimeFormatInfo,System.Boolean)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void __DTString__ctor_m9E9D21ACAC80CD2A8935D885767A9D7320A78FCF (__DTString_t6E7DE2A99E4F15F384EC29CC6CD5185F46818DD9 * __this, String_t* ___str0, DateTimeFormatInfo_tF4BB3AA482C2F772D2A9022F78BF8727830FAF5F * ___dtfi1, bool ___checkDigitToken2, const RuntimeMethod* method)
{
{
String_t* L_0 = ___str0;
DateTimeFormatInfo_tF4BB3AA482C2F772D2A9022F78BF8727830FAF5F * L_1 = ___dtfi1;
__DTString__ctor_mE5FC300B73DE2B23E51414546030AF8625D1109E((__DTString_t6E7DE2A99E4F15F384EC29CC6CD5185F46818DD9 *)__this, L_0, L_1, /*hidden argument*/NULL);
bool L_2 = ___checkDigitToken2;
__this->set_m_checkDigitToken_5(L_2);
return;
}
}
IL2CPP_EXTERN_C void __DTString__ctor_m9E9D21ACAC80CD2A8935D885767A9D7320A78FCF_AdjustorThunk (RuntimeObject * __this, String_t* ___str0, DateTimeFormatInfo_tF4BB3AA482C2F772D2A9022F78BF8727830FAF5F * ___dtfi1, bool ___checkDigitToken2, const RuntimeMethod* method)
{
__DTString_t6E7DE2A99E4F15F384EC29CC6CD5185F46818DD9 * _thisAdjusted = reinterpret_cast<__DTString_t6E7DE2A99E4F15F384EC29CC6CD5185F46818DD9 *>(__this + 1);
__DTString__ctor_m9E9D21ACAC80CD2A8935D885767A9D7320A78FCF(_thisAdjusted, ___str0, ___dtfi1, ___checkDigitToken2, method);
}
// System.Void System.__DTString::.ctor(System.String,System.Globalization.DateTimeFormatInfo)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void __DTString__ctor_mE5FC300B73DE2B23E51414546030AF8625D1109E (__DTString_t6E7DE2A99E4F15F384EC29CC6CD5185F46818DD9 * __this, String_t* ___str0, DateTimeFormatInfo_tF4BB3AA482C2F772D2A9022F78BF8727830FAF5F * ___dtfi1, const RuntimeMethod* method)
{
{
__this->set_Index_1((-1));
String_t* L_0 = ___str0;
__this->set_Value_0(L_0);
String_t* L_1 = __this->get_Value_0();
NullCheck(L_1);
int32_t L_2 = String_get_Length_mD48C8A16A5CF1914F330DCE82D9BE15C3BEDD018(L_1, /*hidden argument*/NULL);
__this->set_len_2(L_2);
__this->set_m_current_3(0);
DateTimeFormatInfo_tF4BB3AA482C2F772D2A9022F78BF8727830FAF5F * L_3 = ___dtfi1;
if (!L_3)
{
goto IL_0048;
}
}
{
DateTimeFormatInfo_tF4BB3AA482C2F772D2A9022F78BF8727830FAF5F * L_4 = ___dtfi1;
NullCheck(L_4);
CompareInfo_tB9A071DBC11AC00AF2EA2066D0C2AE1DCB1865D1 * L_5 = DateTimeFormatInfo_get_CompareInfo_mD70321935C290535664E8821CBE0D304580230C8(L_4, /*hidden argument*/NULL);
__this->set_m_info_4(L_5);
DateTimeFormatInfo_tF4BB3AA482C2F772D2A9022F78BF8727830FAF5F * L_6 = ___dtfi1;
NullCheck(L_6);
int32_t L_7 = DateTimeFormatInfo_get_FormatFlags_m42B106A8C2AC470D425032034608045AABB71731(L_6, /*hidden argument*/NULL);
__this->set_m_checkDigitToken_5((bool)((!(((uint32_t)((int32_t)((int32_t)L_7&(int32_t)((int32_t)32)))) <= ((uint32_t)0)))? 1 : 0));
return;
}
IL_0048:
{
Thread_tF60E0A146CD3B5480CB65FF9B6016E84C5460CC7 * L_8 = Thread_get_CurrentThread_mB7A83CAE2B9A74CEA053196DFD1AF1E7AB30A70E(/*hidden argument*/NULL);
NullCheck(L_8);
CultureInfo_t345AC6924134F039ED9A11F3E03F8E91B6A3225F * L_9 = Thread_get_CurrentCulture_m97A15448A16FB3B5EC1E21A0538C9FC1F84AEE66(L_8, /*hidden argument*/NULL);
NullCheck(L_9);
CompareInfo_tB9A071DBC11AC00AF2EA2066D0C2AE1DCB1865D1 * L_10 = VirtFuncInvoker0< CompareInfo_tB9A071DBC11AC00AF2EA2066D0C2AE1DCB1865D1 * >::Invoke(12 /* System.Globalization.CompareInfo System.Globalization.CultureInfo::get_CompareInfo() */, L_9);
__this->set_m_info_4(L_10);
__this->set_m_checkDigitToken_5((bool)0);
return;
}
}
IL2CPP_EXTERN_C void __DTString__ctor_mE5FC300B73DE2B23E51414546030AF8625D1109E_AdjustorThunk (RuntimeObject * __this, String_t* ___str0, DateTimeFormatInfo_tF4BB3AA482C2F772D2A9022F78BF8727830FAF5F * ___dtfi1, const RuntimeMethod* method)
{
__DTString_t6E7DE2A99E4F15F384EC29CC6CD5185F46818DD9 * _thisAdjusted = reinterpret_cast<__DTString_t6E7DE2A99E4F15F384EC29CC6CD5185F46818DD9 *>(__this + 1);
__DTString__ctor_mE5FC300B73DE2B23E51414546030AF8625D1109E(_thisAdjusted, ___str0, ___dtfi1, method);
}
// System.Globalization.CompareInfo System.__DTString::get_CompareInfo()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR CompareInfo_tB9A071DBC11AC00AF2EA2066D0C2AE1DCB1865D1 * __DTString_get_CompareInfo_mE0381FC6A1AB82E0BDAF45F848568124B193FB51 (__DTString_t6E7DE2A99E4F15F384EC29CC6CD5185F46818DD9 * __this, const RuntimeMethod* method)
{
{
CompareInfo_tB9A071DBC11AC00AF2EA2066D0C2AE1DCB1865D1 * L_0 = __this->get_m_info_4();
return L_0;
}
}
IL2CPP_EXTERN_C CompareInfo_tB9A071DBC11AC00AF2EA2066D0C2AE1DCB1865D1 * __DTString_get_CompareInfo_mE0381FC6A1AB82E0BDAF45F848568124B193FB51_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
__DTString_t6E7DE2A99E4F15F384EC29CC6CD5185F46818DD9 * _thisAdjusted = reinterpret_cast<__DTString_t6E7DE2A99E4F15F384EC29CC6CD5185F46818DD9 *>(__this + 1);
return __DTString_get_CompareInfo_mE0381FC6A1AB82E0BDAF45F848568124B193FB51(_thisAdjusted, method);
}
// System.Boolean System.__DTString::GetNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool __DTString_GetNext_mA99D360775F54B38E339C68D2E6007B7E028E1A3 (__DTString_t6E7DE2A99E4F15F384EC29CC6CD5185F46818DD9 * __this, const RuntimeMethod* method)
{
{
int32_t L_0 = __this->get_Index_1();
__this->set_Index_1(((int32_t)il2cpp_codegen_add((int32_t)L_0, (int32_t)1)));
int32_t L_1 = __this->get_Index_1();
int32_t L_2 = __this->get_len_2();
if ((((int32_t)L_1) >= ((int32_t)L_2)))
{
goto IL_0035;
}
}
{
String_t* L_3 = __this->get_Value_0();
int32_t L_4 = __this->get_Index_1();
NullCheck(L_3);
Il2CppChar L_5 = String_get_Chars_m14308AC3B95F8C1D9F1D1055B116B37D595F1D96(L_3, L_4, /*hidden argument*/NULL);
__this->set_m_current_3(L_5);
return (bool)1;
}
IL_0035:
{
return (bool)0;
}
}
IL2CPP_EXTERN_C bool __DTString_GetNext_mA99D360775F54B38E339C68D2E6007B7E028E1A3_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
__DTString_t6E7DE2A99E4F15F384EC29CC6CD5185F46818DD9 * _thisAdjusted = reinterpret_cast<__DTString_t6E7DE2A99E4F15F384EC29CC6CD5185F46818DD9 *>(__this + 1);
return __DTString_GetNext_mA99D360775F54B38E339C68D2E6007B7E028E1A3(_thisAdjusted, method);
}
// System.Boolean System.__DTString::AtEnd()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool __DTString_AtEnd_mE89AB87FFD62B3BA1D1E5B30052947890000EADC (__DTString_t6E7DE2A99E4F15F384EC29CC6CD5185F46818DD9 * __this, const RuntimeMethod* method)
{
{
int32_t L_0 = __this->get_Index_1();
int32_t L_1 = __this->get_len_2();
if ((((int32_t)L_0) < ((int32_t)L_1)))
{
goto IL_0010;
}
}
{
return (bool)1;
}
IL_0010:
{
return (bool)0;
}
}
IL2CPP_EXTERN_C bool __DTString_AtEnd_mE89AB87FFD62B3BA1D1E5B30052947890000EADC_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
__DTString_t6E7DE2A99E4F15F384EC29CC6CD5185F46818DD9 * _thisAdjusted = reinterpret_cast<__DTString_t6E7DE2A99E4F15F384EC29CC6CD5185F46818DD9 *>(__this + 1);
return __DTString_AtEnd_mE89AB87FFD62B3BA1D1E5B30052947890000EADC(_thisAdjusted, method);
}
// System.Boolean System.__DTString::Advance(System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool __DTString_Advance_m6CAEF5CE3C7B57CBBDA5E0F5A391F6517C3791CC (__DTString_t6E7DE2A99E4F15F384EC29CC6CD5185F46818DD9 * __this, int32_t ___count0, const RuntimeMethod* method)
{
{
int32_t L_0 = __this->get_Index_1();
int32_t L_1 = ___count0;
__this->set_Index_1(((int32_t)il2cpp_codegen_add((int32_t)L_0, (int32_t)L_1)));
int32_t L_2 = __this->get_Index_1();
int32_t L_3 = __this->get_len_2();
if ((((int32_t)L_2) >= ((int32_t)L_3)))
{
goto IL_0035;
}
}
{
String_t* L_4 = __this->get_Value_0();
int32_t L_5 = __this->get_Index_1();
NullCheck(L_4);
Il2CppChar L_6 = String_get_Chars_m14308AC3B95F8C1D9F1D1055B116B37D595F1D96(L_4, L_5, /*hidden argument*/NULL);
__this->set_m_current_3(L_6);
return (bool)1;
}
IL_0035:
{
return (bool)0;
}
}
IL2CPP_EXTERN_C bool __DTString_Advance_m6CAEF5CE3C7B57CBBDA5E0F5A391F6517C3791CC_AdjustorThunk (RuntimeObject * __this, int32_t ___count0, const RuntimeMethod* method)
{
__DTString_t6E7DE2A99E4F15F384EC29CC6CD5185F46818DD9 * _thisAdjusted = reinterpret_cast<__DTString_t6E7DE2A99E4F15F384EC29CC6CD5185F46818DD9 *>(__this + 1);
return __DTString_Advance_m6CAEF5CE3C7B57CBBDA5E0F5A391F6517C3791CC(_thisAdjusted, ___count0, method);
}
// System.Void System.__DTString::GetRegularToken(System.TokenTypeU26,System.Int32U26,System.Globalization.DateTimeFormatInfo)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void __DTString_GetRegularToken_mD79E9337E33F2F9535DD89437EEDC2AF3F5A0B39 (__DTString_t6E7DE2A99E4F15F384EC29CC6CD5185F46818DD9 * __this, int32_t* ___tokenType0, int32_t* ___tokenValue1, DateTimeFormatInfo_tF4BB3AA482C2F772D2A9022F78BF8727830FAF5F * ___dtfi2, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (__DTString_GetRegularToken_mD79E9337E33F2F9535DD89437EEDC2AF3F5A0B39_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
int32_t V_0 = 0;
int32_t V_1 = 0;
int32_t V_2 = 0;
int32_t V_3 = 0;
Il2CppChar V_4 = 0x0;
int32_t V_5 = 0;
int32_t V_6 = 0;
{
int32_t* L_0 = ___tokenValue1;
*((int32_t*)L_0) = (int32_t)0;
int32_t L_1 = __this->get_Index_1();
int32_t L_2 = __this->get_len_2();
if ((((int32_t)L_1) < ((int32_t)L_2)))
{
goto IL_0015;
}
}
{
int32_t* L_3 = ___tokenType0;
*((int32_t*)L_3) = (int32_t)6;
return;
}
IL_0015:
{
int32_t* L_4 = ___tokenType0;
*((int32_t*)L_4) = (int32_t)((int32_t)11);
}
IL_0019:
{
Il2CppChar L_5 = __this->get_m_current_3();
IL2CPP_RUNTIME_CLASS_INIT(DateTimeParse_t657E38D9FF27E5FD6A33E23887031A86248D97D4_il2cpp_TypeInfo_var);
bool L_6 = DateTimeParse_IsDigit_mCC840BC9EC5E157F967F148BC12F6A815E75B74A(L_5, /*hidden argument*/NULL);
if (!L_6)
{
goto IL_0112;
}
}
{
int32_t* L_7 = ___tokenValue1;
Il2CppChar L_8 = __this->get_m_current_3();
*((int32_t*)L_7) = (int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)L_8, (int32_t)((int32_t)48)));
int32_t L_9 = __this->get_Index_1();
V_1 = L_9;
goto IL_0070;
}
IL_003d:
{
String_t* L_10 = __this->get_Value_0();
int32_t L_11 = __this->get_Index_1();
NullCheck(L_10);
Il2CppChar L_12 = String_get_Chars_m14308AC3B95F8C1D9F1D1055B116B37D595F1D96(L_10, L_11, /*hidden argument*/NULL);
__this->set_m_current_3(L_12);
Il2CppChar L_13 = __this->get_m_current_3();
V_0 = ((int32_t)il2cpp_codegen_subtract((int32_t)L_13, (int32_t)((int32_t)48)));
int32_t L_14 = V_0;
if ((((int32_t)L_14) < ((int32_t)0)))
{
goto IL_0089;
}
}
{
int32_t L_15 = V_0;
if ((((int32_t)L_15) > ((int32_t)((int32_t)9))))
{
goto IL_0089;
}
}
{
int32_t* L_16 = ___tokenValue1;
int32_t* L_17 = ___tokenValue1;
int32_t L_18 = *((int32_t*)L_17);
int32_t L_19 = V_0;
*((int32_t*)L_16) = (int32_t)((int32_t)il2cpp_codegen_add((int32_t)((int32_t)il2cpp_codegen_multiply((int32_t)L_18, (int32_t)((int32_t)10))), (int32_t)L_19));
}
IL_0070:
{
int32_t L_20 = __this->get_Index_1();
V_2 = ((int32_t)il2cpp_codegen_add((int32_t)L_20, (int32_t)1));
int32_t L_21 = V_2;
__this->set_Index_1(L_21);
int32_t L_22 = V_2;
int32_t L_23 = __this->get_len_2();
if ((((int32_t)L_22) < ((int32_t)L_23)))
{
goto IL_003d;
}
}
IL_0089:
{
int32_t L_24 = __this->get_Index_1();
int32_t L_25 = V_1;
if ((((int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)L_24, (int32_t)L_25))) <= ((int32_t)8)))
{
goto IL_009c;
}
}
{
int32_t* L_26 = ___tokenType0;
*((int32_t*)L_26) = (int32_t)1;
int32_t* L_27 = ___tokenValue1;
*((int32_t*)L_27) = (int32_t)(-1);
goto IL_00af;
}
IL_009c:
{
int32_t L_28 = __this->get_Index_1();
int32_t L_29 = V_1;
if ((((int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)L_28, (int32_t)L_29))) >= ((int32_t)3)))
{
goto IL_00ac;
}
}
{
int32_t* L_30 = ___tokenType0;
*((int32_t*)L_30) = (int32_t)1;
goto IL_00af;
}
IL_00ac:
{
int32_t* L_31 = ___tokenType0;
*((int32_t*)L_31) = (int32_t)2;
}
IL_00af:
{
bool L_32 = __this->get_m_checkDigitToken_5();
if (!L_32)
{
goto IL_0174;
}
}
{
int32_t L_33 = __this->get_Index_1();
V_3 = L_33;
Il2CppChar L_34 = __this->get_m_current_3();
V_4 = L_34;
int32_t L_35 = V_1;
__this->set_Index_1(L_35);
String_t* L_36 = __this->get_Value_0();
int32_t L_37 = __this->get_Index_1();
NullCheck(L_36);
Il2CppChar L_38 = String_get_Chars_m14308AC3B95F8C1D9F1D1055B116B37D595F1D96(L_36, L_37, /*hidden argument*/NULL);
__this->set_m_current_3(L_38);
DateTimeFormatInfo_tF4BB3AA482C2F772D2A9022F78BF8727830FAF5F * L_39 = ___dtfi2;
NullCheck(L_39);
bool L_40 = DateTimeFormatInfo_Tokenize_m47644B9B55F1919470E65677B3C8C5573E606217(L_39, ((int32_t)255), (int32_t*)(&V_5), (int32_t*)(&V_6), (__DTString_t6E7DE2A99E4F15F384EC29CC6CD5185F46818DD9 *)__this, /*hidden argument*/NULL);
if (!L_40)
{
goto IL_0102;
}
}
{
int32_t* L_41 = ___tokenType0;
int32_t L_42 = V_5;
*((int32_t*)L_41) = (int32_t)L_42;
int32_t* L_43 = ___tokenValue1;
int32_t L_44 = V_6;
*((int32_t*)L_43) = (int32_t)L_44;
return;
}
IL_0102:
{
int32_t L_45 = V_3;
__this->set_Index_1(L_45);
Il2CppChar L_46 = V_4;
__this->set_m_current_3(L_46);
return;
}
IL_0112:
{
Il2CppChar L_47 = __this->get_m_current_3();
IL2CPP_RUNTIME_CLASS_INIT(Char_tBF22D9FC341BE970735250BB6FF1A4A92BBA58B9_il2cpp_TypeInfo_var);
bool L_48 = Char_IsWhiteSpace_m8AE1C4157A1E1D8F5022630F4229AB26223BDC6B(L_47, /*hidden argument*/NULL);
if (!L_48)
{
goto IL_0165;
}
}
{
goto IL_0148;
}
IL_0121:
{
String_t* L_49 = __this->get_Value_0();
int32_t L_50 = __this->get_Index_1();
NullCheck(L_49);
Il2CppChar L_51 = String_get_Chars_m14308AC3B95F8C1D9F1D1055B116B37D595F1D96(L_49, L_50, /*hidden argument*/NULL);
__this->set_m_current_3(L_51);
Il2CppChar L_52 = __this->get_m_current_3();
IL2CPP_RUNTIME_CLASS_INIT(Char_tBF22D9FC341BE970735250BB6FF1A4A92BBA58B9_il2cpp_TypeInfo_var);
bool L_53 = Char_IsWhiteSpace_m8AE1C4157A1E1D8F5022630F4229AB26223BDC6B(L_52, /*hidden argument*/NULL);
if (!L_53)
{
goto IL_0019;
}
}
IL_0148:
{
int32_t L_54 = __this->get_Index_1();
V_2 = ((int32_t)il2cpp_codegen_add((int32_t)L_54, (int32_t)1));
int32_t L_55 = V_2;
__this->set_Index_1(L_55);
int32_t L_56 = V_2;
int32_t L_57 = __this->get_len_2();
if ((((int32_t)L_56) < ((int32_t)L_57)))
{
goto IL_0121;
}
}
{
int32_t* L_58 = ___tokenType0;
*((int32_t*)L_58) = (int32_t)6;
return;
}
IL_0165:
{
DateTimeFormatInfo_tF4BB3AA482C2F772D2A9022F78BF8727830FAF5F * L_59 = ___dtfi2;
int32_t* L_60 = ___tokenType0;
int32_t* L_61 = ___tokenValue1;
NullCheck(L_59);
DateTimeFormatInfo_Tokenize_m47644B9B55F1919470E65677B3C8C5573E606217(L_59, ((int32_t)255), (int32_t*)L_60, (int32_t*)L_61, (__DTString_t6E7DE2A99E4F15F384EC29CC6CD5185F46818DD9 *)__this, /*hidden argument*/NULL);
}
IL_0174:
{
return;
}
}
IL2CPP_EXTERN_C void __DTString_GetRegularToken_mD79E9337E33F2F9535DD89437EEDC2AF3F5A0B39_AdjustorThunk (RuntimeObject * __this, int32_t* ___tokenType0, int32_t* ___tokenValue1, DateTimeFormatInfo_tF4BB3AA482C2F772D2A9022F78BF8727830FAF5F * ___dtfi2, const RuntimeMethod* method)
{
__DTString_t6E7DE2A99E4F15F384EC29CC6CD5185F46818DD9 * _thisAdjusted = reinterpret_cast<__DTString_t6E7DE2A99E4F15F384EC29CC6CD5185F46818DD9 *>(__this + 1);
__DTString_GetRegularToken_mD79E9337E33F2F9535DD89437EEDC2AF3F5A0B39(_thisAdjusted, ___tokenType0, ___tokenValue1, ___dtfi2, method);
}
// System.TokenType System.__DTString::GetSeparatorToken(System.Globalization.DateTimeFormatInfo,System.Int32U26,System.CharU26)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t __DTString_GetSeparatorToken_m2F4CE10AC9C39A5380D3DD5344B81F79C7006EF1 (__DTString_t6E7DE2A99E4F15F384EC29CC6CD5185F46818DD9 * __this, DateTimeFormatInfo_tF4BB3AA482C2F772D2A9022F78BF8727830FAF5F * ___dtfi0, int32_t* ___indexBeforeSeparator1, Il2CppChar* ___charBeforeSeparator2, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (__DTString_GetSeparatorToken_m2F4CE10AC9C39A5380D3DD5344B81F79C7006EF1_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
int32_t V_0 = 0;
int32_t V_1 = 0;
{
int32_t* L_0 = ___indexBeforeSeparator1;
int32_t L_1 = __this->get_Index_1();
*((int32_t*)L_0) = (int32_t)L_1;
Il2CppChar* L_2 = ___charBeforeSeparator2;
Il2CppChar L_3 = __this->get_m_current_3();
*((int16_t*)L_2) = (int16_t)L_3;
bool L_4 = __DTString_SkipWhiteSpaceCurrent_m85EF1DCFFB216A209FEB3CC53CB8E977C51D71DB((__DTString_t6E7DE2A99E4F15F384EC29CC6CD5185F46818DD9 *)__this, /*hidden argument*/NULL);
if (L_4)
{
goto IL_001e;
}
}
{
return (int32_t)(((int32_t)512));
}
IL_001e:
{
Il2CppChar L_5 = __this->get_m_current_3();
IL2CPP_RUNTIME_CLASS_INIT(DateTimeParse_t657E38D9FF27E5FD6A33E23887031A86248D97D4_il2cpp_TypeInfo_var);
bool L_6 = DateTimeParse_IsDigit_mCC840BC9EC5E157F967F148BC12F6A815E75B74A(L_5, /*hidden argument*/NULL);
if (L_6)
{
goto IL_0045;
}
}
{
DateTimeFormatInfo_tF4BB3AA482C2F772D2A9022F78BF8727830FAF5F * L_7 = ___dtfi0;
NullCheck(L_7);
bool L_8 = DateTimeFormatInfo_Tokenize_m47644B9B55F1919470E65677B3C8C5573E606217(L_7, ((int32_t)65280), (int32_t*)(&V_0), (int32_t*)(&V_1), (__DTString_t6E7DE2A99E4F15F384EC29CC6CD5185F46818DD9 *)__this, /*hidden argument*/NULL);
if (L_8)
{
goto IL_004b;
}
}
{
V_0 = ((int32_t)768);
goto IL_004b;
}
IL_0045:
{
V_0 = ((int32_t)768);
}
IL_004b:
{
int32_t L_9 = V_0;
return L_9;
}
}
IL2CPP_EXTERN_C int32_t __DTString_GetSeparatorToken_m2F4CE10AC9C39A5380D3DD5344B81F79C7006EF1_AdjustorThunk (RuntimeObject * __this, DateTimeFormatInfo_tF4BB3AA482C2F772D2A9022F78BF8727830FAF5F * ___dtfi0, int32_t* ___indexBeforeSeparator1, Il2CppChar* ___charBeforeSeparator2, const RuntimeMethod* method)
{
__DTString_t6E7DE2A99E4F15F384EC29CC6CD5185F46818DD9 * _thisAdjusted = reinterpret_cast<__DTString_t6E7DE2A99E4F15F384EC29CC6CD5185F46818DD9 *>(__this + 1);
return __DTString_GetSeparatorToken_m2F4CE10AC9C39A5380D3DD5344B81F79C7006EF1(_thisAdjusted, ___dtfi0, ___indexBeforeSeparator1, ___charBeforeSeparator2, method);
}
// System.Boolean System.__DTString::MatchSpecifiedWord(System.String)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool __DTString_MatchSpecifiedWord_m6B53744885B818B053CFE143A6AD0F778D617410 (__DTString_t6E7DE2A99E4F15F384EC29CC6CD5185F46818DD9 * __this, String_t* ___target0, const RuntimeMethod* method)
{
{
String_t* L_0 = ___target0;
String_t* L_1 = ___target0;
NullCheck(L_1);
int32_t L_2 = String_get_Length_mD48C8A16A5CF1914F330DCE82D9BE15C3BEDD018(L_1, /*hidden argument*/NULL);
int32_t L_3 = __this->get_Index_1();
bool L_4 = __DTString_MatchSpecifiedWord_m6399788FF78434EAD2231A2A7509B580EFED33B5((__DTString_t6E7DE2A99E4F15F384EC29CC6CD5185F46818DD9 *)__this, L_0, ((int32_t)il2cpp_codegen_add((int32_t)L_2, (int32_t)L_3)), /*hidden argument*/NULL);
return L_4;
}
}
IL2CPP_EXTERN_C bool __DTString_MatchSpecifiedWord_m6B53744885B818B053CFE143A6AD0F778D617410_AdjustorThunk (RuntimeObject * __this, String_t* ___target0, const RuntimeMethod* method)
{
__DTString_t6E7DE2A99E4F15F384EC29CC6CD5185F46818DD9 * _thisAdjusted = reinterpret_cast<__DTString_t6E7DE2A99E4F15F384EC29CC6CD5185F46818DD9 *>(__this + 1);
return __DTString_MatchSpecifiedWord_m6B53744885B818B053CFE143A6AD0F778D617410(_thisAdjusted, ___target0, method);
}
// System.Boolean System.__DTString::MatchSpecifiedWord(System.String,System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool __DTString_MatchSpecifiedWord_m6399788FF78434EAD2231A2A7509B580EFED33B5 (__DTString_t6E7DE2A99E4F15F384EC29CC6CD5185F46818DD9 * __this, String_t* ___target0, int32_t ___endIndex1, const RuntimeMethod* method)
{
int32_t V_0 = 0;
{
int32_t L_0 = ___endIndex1;
int32_t L_1 = __this->get_Index_1();
V_0 = ((int32_t)il2cpp_codegen_subtract((int32_t)L_0, (int32_t)L_1));
int32_t L_2 = V_0;
String_t* L_3 = ___target0;
NullCheck(L_3);
int32_t L_4 = String_get_Length_mD48C8A16A5CF1914F330DCE82D9BE15C3BEDD018(L_3, /*hidden argument*/NULL);
if ((((int32_t)L_2) == ((int32_t)L_4)))
{
goto IL_0014;
}
}
{
return (bool)0;
}
IL_0014:
{
int32_t L_5 = __this->get_Index_1();
int32_t L_6 = V_0;
int32_t L_7 = __this->get_len_2();
if ((((int32_t)((int32_t)il2cpp_codegen_add((int32_t)L_5, (int32_t)L_6))) <= ((int32_t)L_7)))
{
goto IL_0026;
}
}
{
return (bool)0;
}
IL_0026:
{
CompareInfo_tB9A071DBC11AC00AF2EA2066D0C2AE1DCB1865D1 * L_8 = __this->get_m_info_4();
String_t* L_9 = __this->get_Value_0();
int32_t L_10 = __this->get_Index_1();
int32_t L_11 = V_0;
String_t* L_12 = ___target0;
int32_t L_13 = V_0;
NullCheck(L_8);
int32_t L_14 = VirtFuncInvoker7< int32_t, String_t*, int32_t, int32_t, String_t*, int32_t, int32_t, int32_t >::Invoke(8 /* System.Int32 System.Globalization.CompareInfo::Compare(System.String,System.Int32,System.Int32,System.String,System.Int32,System.Int32,System.Globalization.CompareOptions) */, L_8, L_9, L_10, L_11, L_12, 0, L_13, 1);
return (bool)((((int32_t)L_14) == ((int32_t)0))? 1 : 0);
}
}
IL2CPP_EXTERN_C bool __DTString_MatchSpecifiedWord_m6399788FF78434EAD2231A2A7509B580EFED33B5_AdjustorThunk (RuntimeObject * __this, String_t* ___target0, int32_t ___endIndex1, const RuntimeMethod* method)
{
__DTString_t6E7DE2A99E4F15F384EC29CC6CD5185F46818DD9 * _thisAdjusted = reinterpret_cast<__DTString_t6E7DE2A99E4F15F384EC29CC6CD5185F46818DD9 *>(__this + 1);
return __DTString_MatchSpecifiedWord_m6399788FF78434EAD2231A2A7509B580EFED33B5(_thisAdjusted, ___target0, ___endIndex1, method);
}
// System.Boolean System.__DTString::MatchSpecifiedWords(System.String,System.Boolean,System.Int32U26)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool __DTString_MatchSpecifiedWords_mAD172D28B54FDBB34D5E8C8F92CB6C8B0EECDBA0 (__DTString_t6E7DE2A99E4F15F384EC29CC6CD5185F46818DD9 * __this, String_t* ___target0, bool ___checkWordBoundary1, int32_t* ___matchLength2, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (__DTString_MatchSpecifiedWords_mAD172D28B54FDBB34D5E8C8F92CB6C8B0EECDBA0_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
int32_t V_0 = 0;
int32_t V_1 = 0;
int32_t V_2 = 0;
int32_t V_3 = 0;
int32_t V_4 = 0;
int32_t V_5 = 0;
int32_t V_6 = 0;
{
String_t* L_0 = __this->get_Value_0();
NullCheck(L_0);
int32_t L_1 = String_get_Length_mD48C8A16A5CF1914F330DCE82D9BE15C3BEDD018(L_0, /*hidden argument*/NULL);
int32_t L_2 = __this->get_Index_1();
V_0 = ((int32_t)il2cpp_codegen_subtract((int32_t)L_1, (int32_t)L_2));
int32_t* L_3 = ___matchLength2;
String_t* L_4 = ___target0;
NullCheck(L_4);
int32_t L_5 = String_get_Length_mD48C8A16A5CF1914F330DCE82D9BE15C3BEDD018(L_4, /*hidden argument*/NULL);
*((int32_t*)L_3) = (int32_t)L_5;
int32_t* L_6 = ___matchLength2;
int32_t L_7 = *((int32_t*)L_6);
int32_t L_8 = V_0;
if ((((int32_t)L_7) > ((int32_t)L_8)))
{
goto IL_0043;
}
}
{
CompareInfo_tB9A071DBC11AC00AF2EA2066D0C2AE1DCB1865D1 * L_9 = __this->get_m_info_4();
String_t* L_10 = __this->get_Value_0();
int32_t L_11 = __this->get_Index_1();
int32_t* L_12 = ___matchLength2;
int32_t L_13 = *((int32_t*)L_12);
String_t* L_14 = ___target0;
int32_t* L_15 = ___matchLength2;
int32_t L_16 = *((int32_t*)L_15);
NullCheck(L_9);
int32_t L_17 = VirtFuncInvoker7< int32_t, String_t*, int32_t, int32_t, String_t*, int32_t, int32_t, int32_t >::Invoke(8 /* System.Int32 System.Globalization.CompareInfo::Compare(System.String,System.Int32,System.Int32,System.String,System.Int32,System.Int32,System.Globalization.CompareOptions) */, L_9, L_10, L_11, L_13, L_14, 0, L_16, 1);
if (!L_17)
{
goto IL_0147;
}
}
IL_0043:
{
V_1 = 0;
int32_t L_18 = __this->get_Index_1();
V_2 = L_18;
String_t* L_19 = ___target0;
IL2CPP_RUNTIME_CLASS_INIT(__DTString_t6E7DE2A99E4F15F384EC29CC6CD5185F46818DD9_il2cpp_TypeInfo_var);
CharU5BU5D_t4CC6ABF0AD71BEC97E3C2F1E9C5677E46D3A75C2* L_20 = ((__DTString_t6E7DE2A99E4F15F384EC29CC6CD5185F46818DD9_StaticFields*)il2cpp_codegen_static_fields_for(__DTString_t6E7DE2A99E4F15F384EC29CC6CD5185F46818DD9_il2cpp_TypeInfo_var))->get_WhiteSpaceChecks_6();
int32_t L_21 = V_1;
NullCheck(L_19);
int32_t L_22 = String_IndexOfAny_m30470EE6951771AE5E897773C8FC233DADBAE301(L_19, L_20, L_21, /*hidden argument*/NULL);
V_3 = L_22;
int32_t L_23 = V_3;
if ((!(((uint32_t)L_23) == ((uint32_t)(-1)))))
{
goto IL_005f;
}
}
{
return (bool)0;
}
IL_005f:
{
int32_t L_24 = V_3;
int32_t L_25 = V_1;
V_4 = ((int32_t)il2cpp_codegen_subtract((int32_t)L_24, (int32_t)L_25));
int32_t L_26 = V_2;
String_t* L_27 = __this->get_Value_0();
NullCheck(L_27);
int32_t L_28 = String_get_Length_mD48C8A16A5CF1914F330DCE82D9BE15C3BEDD018(L_27, /*hidden argument*/NULL);
int32_t L_29 = V_4;
if ((((int32_t)L_26) < ((int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)L_28, (int32_t)L_29)))))
{
goto IL_0077;
}
}
{
return (bool)0;
}
IL_0077:
{
int32_t L_30 = V_4;
if (L_30)
{
goto IL_0083;
}
}
{
int32_t* L_31 = ___matchLength2;
int32_t* L_32 = ___matchLength2;
int32_t L_33 = *((int32_t*)L_32);
*((int32_t*)L_31) = (int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)L_33, (int32_t)1));
goto IL_00bf;
}
IL_0083:
{
String_t* L_34 = __this->get_Value_0();
int32_t L_35 = V_2;
int32_t L_36 = V_4;
NullCheck(L_34);
Il2CppChar L_37 = String_get_Chars_m14308AC3B95F8C1D9F1D1055B116B37D595F1D96(L_34, ((int32_t)il2cpp_codegen_add((int32_t)L_35, (int32_t)L_36)), /*hidden argument*/NULL);
IL2CPP_RUNTIME_CLASS_INIT(Char_tBF22D9FC341BE970735250BB6FF1A4A92BBA58B9_il2cpp_TypeInfo_var);
bool L_38 = Char_IsWhiteSpace_m8AE1C4157A1E1D8F5022630F4229AB26223BDC6B(L_37, /*hidden argument*/NULL);
if (L_38)
{
goto IL_009b;
}
}
{
return (bool)0;
}
IL_009b:
{
CompareInfo_tB9A071DBC11AC00AF2EA2066D0C2AE1DCB1865D1 * L_39 = __this->get_m_info_4();
String_t* L_40 = __this->get_Value_0();
int32_t L_41 = V_2;
int32_t L_42 = V_4;
String_t* L_43 = ___target0;
int32_t L_44 = V_1;
int32_t L_45 = V_4;
NullCheck(L_39);
int32_t L_46 = VirtFuncInvoker7< int32_t, String_t*, int32_t, int32_t, String_t*, int32_t, int32_t, int32_t >::Invoke(8 /* System.Int32 System.Globalization.CompareInfo::Compare(System.String,System.Int32,System.Int32,System.String,System.Int32,System.Int32,System.Globalization.CompareOptions) */, L_39, L_40, L_41, L_42, L_43, L_44, L_45, 1);
if (!L_46)
{
goto IL_00b8;
}
}
{
return (bool)0;
}
IL_00b8:
{
int32_t L_47 = V_2;
int32_t L_48 = V_4;
V_2 = ((int32_t)il2cpp_codegen_add((int32_t)((int32_t)il2cpp_codegen_add((int32_t)L_47, (int32_t)L_48)), (int32_t)1));
}
IL_00bf:
{
int32_t L_49 = V_3;
V_1 = ((int32_t)il2cpp_codegen_add((int32_t)L_49, (int32_t)1));
goto IL_00cf;
}
IL_00c5:
{
int32_t L_50 = V_2;
V_2 = ((int32_t)il2cpp_codegen_add((int32_t)L_50, (int32_t)1));
int32_t* L_51 = ___matchLength2;
int32_t* L_52 = ___matchLength2;
int32_t L_53 = *((int32_t*)L_52);
*((int32_t*)L_51) = (int32_t)((int32_t)il2cpp_codegen_add((int32_t)L_53, (int32_t)1));
}
IL_00cf:
{
int32_t L_54 = V_2;
String_t* L_55 = __this->get_Value_0();
NullCheck(L_55);
int32_t L_56 = String_get_Length_mD48C8A16A5CF1914F330DCE82D9BE15C3BEDD018(L_55, /*hidden argument*/NULL);
if ((((int32_t)L_54) >= ((int32_t)L_56)))
{
goto IL_00f0;
}
}
{
String_t* L_57 = __this->get_Value_0();
int32_t L_58 = V_2;
NullCheck(L_57);
Il2CppChar L_59 = String_get_Chars_m14308AC3B95F8C1D9F1D1055B116B37D595F1D96(L_57, L_58, /*hidden argument*/NULL);
IL2CPP_RUNTIME_CLASS_INIT(Char_tBF22D9FC341BE970735250BB6FF1A4A92BBA58B9_il2cpp_TypeInfo_var);
bool L_60 = Char_IsWhiteSpace_m8AE1C4157A1E1D8F5022630F4229AB26223BDC6B(L_59, /*hidden argument*/NULL);
if (L_60)
{
goto IL_00c5;
}
}
IL_00f0:
{
String_t* L_61 = ___target0;
IL2CPP_RUNTIME_CLASS_INIT(__DTString_t6E7DE2A99E4F15F384EC29CC6CD5185F46818DD9_il2cpp_TypeInfo_var);
CharU5BU5D_t4CC6ABF0AD71BEC97E3C2F1E9C5677E46D3A75C2* L_62 = ((__DTString_t6E7DE2A99E4F15F384EC29CC6CD5185F46818DD9_StaticFields*)il2cpp_codegen_static_fields_for(__DTString_t6E7DE2A99E4F15F384EC29CC6CD5185F46818DD9_il2cpp_TypeInfo_var))->get_WhiteSpaceChecks_6();
int32_t L_63 = V_1;
NullCheck(L_61);
int32_t L_64 = String_IndexOfAny_m30470EE6951771AE5E897773C8FC233DADBAE301(L_61, L_62, L_63, /*hidden argument*/NULL);
int32_t L_65 = L_64;
V_3 = L_65;
if ((((int32_t)L_65) >= ((int32_t)0)))
{
goto IL_005f;
}
}
{
int32_t L_66 = V_1;
String_t* L_67 = ___target0;
NullCheck(L_67);
int32_t L_68 = String_get_Length_mD48C8A16A5CF1914F330DCE82D9BE15C3BEDD018(L_67, /*hidden argument*/NULL);
if ((((int32_t)L_66) >= ((int32_t)L_68)))
{
goto IL_0147;
}
}
{
String_t* L_69 = ___target0;
NullCheck(L_69);
int32_t L_70 = String_get_Length_mD48C8A16A5CF1914F330DCE82D9BE15C3BEDD018(L_69, /*hidden argument*/NULL);
int32_t L_71 = V_1;
V_5 = ((int32_t)il2cpp_codegen_subtract((int32_t)L_70, (int32_t)L_71));
int32_t L_72 = V_2;
String_t* L_73 = __this->get_Value_0();
NullCheck(L_73);
int32_t L_74 = String_get_Length_mD48C8A16A5CF1914F330DCE82D9BE15C3BEDD018(L_73, /*hidden argument*/NULL);
int32_t L_75 = V_5;
if ((((int32_t)L_72) <= ((int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)L_74, (int32_t)L_75)))))
{
goto IL_012a;
}
}
{
return (bool)0;
}
IL_012a:
{
CompareInfo_tB9A071DBC11AC00AF2EA2066D0C2AE1DCB1865D1 * L_76 = __this->get_m_info_4();
String_t* L_77 = __this->get_Value_0();
int32_t L_78 = V_2;
int32_t L_79 = V_5;
String_t* L_80 = ___target0;
int32_t L_81 = V_1;
int32_t L_82 = V_5;
NullCheck(L_76);
int32_t L_83 = VirtFuncInvoker7< int32_t, String_t*, int32_t, int32_t, String_t*, int32_t, int32_t, int32_t >::Invoke(8 /* System.Int32 System.Globalization.CompareInfo::Compare(System.String,System.Int32,System.Int32,System.String,System.Int32,System.Int32,System.Globalization.CompareOptions) */, L_76, L_77, L_78, L_79, L_80, L_81, L_82, 1);
if (!L_83)
{
goto IL_0147;
}
}
{
return (bool)0;
}
IL_0147:
{
bool L_84 = ___checkWordBoundary1;
if (!L_84)
{
goto IL_017a;
}
}
{
int32_t L_85 = __this->get_Index_1();
int32_t* L_86 = ___matchLength2;
int32_t L_87 = *((int32_t*)L_86);
V_6 = ((int32_t)il2cpp_codegen_add((int32_t)L_85, (int32_t)L_87));
int32_t L_88 = V_6;
String_t* L_89 = __this->get_Value_0();
NullCheck(L_89);
int32_t L_90 = String_get_Length_mD48C8A16A5CF1914F330DCE82D9BE15C3BEDD018(L_89, /*hidden argument*/NULL);
if ((((int32_t)L_88) >= ((int32_t)L_90)))
{
goto IL_017a;
}
}
{
String_t* L_91 = __this->get_Value_0();
int32_t L_92 = V_6;
NullCheck(L_91);
Il2CppChar L_93 = String_get_Chars_m14308AC3B95F8C1D9F1D1055B116B37D595F1D96(L_91, L_92, /*hidden argument*/NULL);
IL2CPP_RUNTIME_CLASS_INIT(Char_tBF22D9FC341BE970735250BB6FF1A4A92BBA58B9_il2cpp_TypeInfo_var);
bool L_94 = Char_IsLetter_mCC7F387F16C2DE7C85B6A1A0C5BC75D92A813DFE(L_93, /*hidden argument*/NULL);
if (!L_94)
{
goto IL_017a;
}
}
{
return (bool)0;
}
IL_017a:
{
return (bool)1;
}
}
IL2CPP_EXTERN_C bool __DTString_MatchSpecifiedWords_mAD172D28B54FDBB34D5E8C8F92CB6C8B0EECDBA0_AdjustorThunk (RuntimeObject * __this, String_t* ___target0, bool ___checkWordBoundary1, int32_t* ___matchLength2, const RuntimeMethod* method)
{
__DTString_t6E7DE2A99E4F15F384EC29CC6CD5185F46818DD9 * _thisAdjusted = reinterpret_cast<__DTString_t6E7DE2A99E4F15F384EC29CC6CD5185F46818DD9 *>(__this + 1);
return __DTString_MatchSpecifiedWords_mAD172D28B54FDBB34D5E8C8F92CB6C8B0EECDBA0(_thisAdjusted, ___target0, ___checkWordBoundary1, ___matchLength2, method);
}
// System.Boolean System.__DTString::Match(System.String)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool __DTString_Match_m6E1CE300661D15D140D2FAC5C54E74BDBE70EE19 (__DTString_t6E7DE2A99E4F15F384EC29CC6CD5185F46818DD9 * __this, String_t* ___str0, const RuntimeMethod* method)
{
int32_t V_0 = 0;
{
int32_t L_0 = __this->get_Index_1();
V_0 = ((int32_t)il2cpp_codegen_add((int32_t)L_0, (int32_t)1));
int32_t L_1 = V_0;
__this->set_Index_1(L_1);
int32_t L_2 = V_0;
int32_t L_3 = __this->get_len_2();
if ((((int32_t)L_2) < ((int32_t)L_3)))
{
goto IL_001b;
}
}
{
return (bool)0;
}
IL_001b:
{
String_t* L_4 = ___str0;
NullCheck(L_4);
int32_t L_5 = String_get_Length_mD48C8A16A5CF1914F330DCE82D9BE15C3BEDD018(L_4, /*hidden argument*/NULL);
String_t* L_6 = __this->get_Value_0();
NullCheck(L_6);
int32_t L_7 = String_get_Length_mD48C8A16A5CF1914F330DCE82D9BE15C3BEDD018(L_6, /*hidden argument*/NULL);
int32_t L_8 = __this->get_Index_1();
if ((((int32_t)L_5) <= ((int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)L_7, (int32_t)L_8)))))
{
goto IL_0037;
}
}
{
return (bool)0;
}
IL_0037:
{
CompareInfo_tB9A071DBC11AC00AF2EA2066D0C2AE1DCB1865D1 * L_9 = __this->get_m_info_4();
String_t* L_10 = __this->get_Value_0();
int32_t L_11 = __this->get_Index_1();
String_t* L_12 = ___str0;
NullCheck(L_12);
int32_t L_13 = String_get_Length_mD48C8A16A5CF1914F330DCE82D9BE15C3BEDD018(L_12, /*hidden argument*/NULL);
String_t* L_14 = ___str0;
String_t* L_15 = ___str0;
NullCheck(L_15);
int32_t L_16 = String_get_Length_mD48C8A16A5CF1914F330DCE82D9BE15C3BEDD018(L_15, /*hidden argument*/NULL);
NullCheck(L_9);
int32_t L_17 = VirtFuncInvoker7< int32_t, String_t*, int32_t, int32_t, String_t*, int32_t, int32_t, int32_t >::Invoke(8 /* System.Int32 System.Globalization.CompareInfo::Compare(System.String,System.Int32,System.Int32,System.String,System.Int32,System.Int32,System.Globalization.CompareOptions) */, L_9, L_10, L_11, L_13, L_14, 0, L_16, ((int32_t)1073741824));
if (L_17)
{
goto IL_007a;
}
}
{
int32_t L_18 = __this->get_Index_1();
String_t* L_19 = ___str0;
NullCheck(L_19);
int32_t L_20 = String_get_Length_mD48C8A16A5CF1914F330DCE82D9BE15C3BEDD018(L_19, /*hidden argument*/NULL);
__this->set_Index_1(((int32_t)il2cpp_codegen_add((int32_t)L_18, (int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)L_20, (int32_t)1)))));
return (bool)1;
}
IL_007a:
{
return (bool)0;
}
}
IL2CPP_EXTERN_C bool __DTString_Match_m6E1CE300661D15D140D2FAC5C54E74BDBE70EE19_AdjustorThunk (RuntimeObject * __this, String_t* ___str0, const RuntimeMethod* method)
{
__DTString_t6E7DE2A99E4F15F384EC29CC6CD5185F46818DD9 * _thisAdjusted = reinterpret_cast<__DTString_t6E7DE2A99E4F15F384EC29CC6CD5185F46818DD9 *>(__this + 1);
return __DTString_Match_m6E1CE300661D15D140D2FAC5C54E74BDBE70EE19(_thisAdjusted, ___str0, method);
}
// System.Boolean System.__DTString::Match(System.Char)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool __DTString_Match_mC0335DA3DE8A7B7F93781B52A02655B6889E01B3 (__DTString_t6E7DE2A99E4F15F384EC29CC6CD5185F46818DD9 * __this, Il2CppChar ___ch0, const RuntimeMethod* method)
{
int32_t V_0 = 0;
{
int32_t L_0 = __this->get_Index_1();
V_0 = ((int32_t)il2cpp_codegen_add((int32_t)L_0, (int32_t)1));
int32_t L_1 = V_0;
__this->set_Index_1(L_1);
int32_t L_2 = V_0;
int32_t L_3 = __this->get_len_2();
if ((((int32_t)L_2) < ((int32_t)L_3)))
{
goto IL_001b;
}
}
{
return (bool)0;
}
IL_001b:
{
String_t* L_4 = __this->get_Value_0();
int32_t L_5 = __this->get_Index_1();
NullCheck(L_4);
Il2CppChar L_6 = String_get_Chars_m14308AC3B95F8C1D9F1D1055B116B37D595F1D96(L_4, L_5, /*hidden argument*/NULL);
Il2CppChar L_7 = ___ch0;
if ((!(((uint32_t)L_6) == ((uint32_t)L_7))))
{
goto IL_0038;
}
}
{
Il2CppChar L_8 = ___ch0;
__this->set_m_current_3(L_8);
return (bool)1;
}
IL_0038:
{
int32_t L_9 = __this->get_Index_1();
__this->set_Index_1(((int32_t)il2cpp_codegen_subtract((int32_t)L_9, (int32_t)1)));
return (bool)0;
}
}
IL2CPP_EXTERN_C bool __DTString_Match_mC0335DA3DE8A7B7F93781B52A02655B6889E01B3_AdjustorThunk (RuntimeObject * __this, Il2CppChar ___ch0, const RuntimeMethod* method)
{
__DTString_t6E7DE2A99E4F15F384EC29CC6CD5185F46818DD9 * _thisAdjusted = reinterpret_cast<__DTString_t6E7DE2A99E4F15F384EC29CC6CD5185F46818DD9 *>(__this + 1);
return __DTString_Match_mC0335DA3DE8A7B7F93781B52A02655B6889E01B3(_thisAdjusted, ___ch0, method);
}
// System.Int32 System.__DTString::MatchLongestWords(System.String[],System.Int32U26)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t __DTString_MatchLongestWords_mCEDB8993665810AAB06045D6EFF076B89572C4BF (__DTString_t6E7DE2A99E4F15F384EC29CC6CD5185F46818DD9 * __this, StringU5BU5D_t933FB07893230EA91C40FF900D5400665E87B14E* ___words0, int32_t* ___maxMatchStrLen1, const RuntimeMethod* method)
{
int32_t V_0 = 0;
int32_t V_1 = 0;
String_t* V_2 = NULL;
int32_t V_3 = 0;
{
V_0 = (-1);
V_1 = 0;
goto IL_002b;
}
IL_0006:
{
StringU5BU5D_t933FB07893230EA91C40FF900D5400665E87B14E* L_0 = ___words0;
int32_t L_1 = V_1;
NullCheck(L_0);
int32_t L_2 = L_1;
String_t* L_3 = (L_0)->GetAt(static_cast<il2cpp_array_size_t>(L_2));
V_2 = L_3;
String_t* L_4 = V_2;
NullCheck(L_4);
int32_t L_5 = String_get_Length_mD48C8A16A5CF1914F330DCE82D9BE15C3BEDD018(L_4, /*hidden argument*/NULL);
V_3 = L_5;
String_t* L_6 = V_2;
bool L_7 = __DTString_MatchSpecifiedWords_mAD172D28B54FDBB34D5E8C8F92CB6C8B0EECDBA0((__DTString_t6E7DE2A99E4F15F384EC29CC6CD5185F46818DD9 *)__this, L_6, (bool)0, (int32_t*)(&V_3), /*hidden argument*/NULL);
if (!L_7)
{
goto IL_0027;
}
}
{
int32_t L_8 = V_3;
int32_t* L_9 = ___maxMatchStrLen1;
int32_t L_10 = *((int32_t*)L_9);
if ((((int32_t)L_8) <= ((int32_t)L_10)))
{
goto IL_0027;
}
}
{
int32_t* L_11 = ___maxMatchStrLen1;
int32_t L_12 = V_3;
*((int32_t*)L_11) = (int32_t)L_12;
int32_t L_13 = V_1;
V_0 = L_13;
}
IL_0027:
{
int32_t L_14 = V_1;
V_1 = ((int32_t)il2cpp_codegen_add((int32_t)L_14, (int32_t)1));
}
IL_002b:
{
int32_t L_15 = V_1;
StringU5BU5D_t933FB07893230EA91C40FF900D5400665E87B14E* L_16 = ___words0;
NullCheck(L_16);
if ((((int32_t)L_15) < ((int32_t)(((int32_t)((int32_t)(((RuntimeArray*)L_16)->max_length)))))))
{
goto IL_0006;
}
}
{
int32_t L_17 = V_0;
return L_17;
}
}
IL2CPP_EXTERN_C int32_t __DTString_MatchLongestWords_mCEDB8993665810AAB06045D6EFF076B89572C4BF_AdjustorThunk (RuntimeObject * __this, StringU5BU5D_t933FB07893230EA91C40FF900D5400665E87B14E* ___words0, int32_t* ___maxMatchStrLen1, const RuntimeMethod* method)
{
__DTString_t6E7DE2A99E4F15F384EC29CC6CD5185F46818DD9 * _thisAdjusted = reinterpret_cast<__DTString_t6E7DE2A99E4F15F384EC29CC6CD5185F46818DD9 *>(__this + 1);
return __DTString_MatchLongestWords_mCEDB8993665810AAB06045D6EFF076B89572C4BF(_thisAdjusted, ___words0, ___maxMatchStrLen1, method);
}
// System.Int32 System.__DTString::GetRepeatCount()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t __DTString_GetRepeatCount_m115C785C62A5A67CE2BCEA6789CA89BA5B0A97B5 (__DTString_t6E7DE2A99E4F15F384EC29CC6CD5185F46818DD9 * __this, const RuntimeMethod* method)
{
Il2CppChar V_0 = 0x0;
int32_t V_1 = 0;
{
String_t* L_0 = __this->get_Value_0();
int32_t L_1 = __this->get_Index_1();
NullCheck(L_0);
Il2CppChar L_2 = String_get_Chars_m14308AC3B95F8C1D9F1D1055B116B37D595F1D96(L_0, L_1, /*hidden argument*/NULL);
V_0 = L_2;
int32_t L_3 = __this->get_Index_1();
V_1 = ((int32_t)il2cpp_codegen_add((int32_t)L_3, (int32_t)1));
goto IL_0021;
}
IL_001d:
{
int32_t L_4 = V_1;
V_1 = ((int32_t)il2cpp_codegen_add((int32_t)L_4, (int32_t)1));
}
IL_0021:
{
int32_t L_5 = V_1;
int32_t L_6 = __this->get_len_2();
if ((((int32_t)L_5) >= ((int32_t)L_6)))
{
goto IL_0039;
}
}
{
String_t* L_7 = __this->get_Value_0();
int32_t L_8 = V_1;
NullCheck(L_7);
Il2CppChar L_9 = String_get_Chars_m14308AC3B95F8C1D9F1D1055B116B37D595F1D96(L_7, L_8, /*hidden argument*/NULL);
Il2CppChar L_10 = V_0;
if ((((int32_t)L_9) == ((int32_t)L_10)))
{
goto IL_001d;
}
}
IL_0039:
{
int32_t L_11 = V_1;
int32_t L_12 = __this->get_Index_1();
int32_t L_13 = V_1;
__this->set_Index_1(((int32_t)il2cpp_codegen_subtract((int32_t)L_13, (int32_t)1)));
return ((int32_t)il2cpp_codegen_subtract((int32_t)L_11, (int32_t)L_12));
}
}
IL2CPP_EXTERN_C int32_t __DTString_GetRepeatCount_m115C785C62A5A67CE2BCEA6789CA89BA5B0A97B5_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
__DTString_t6E7DE2A99E4F15F384EC29CC6CD5185F46818DD9 * _thisAdjusted = reinterpret_cast<__DTString_t6E7DE2A99E4F15F384EC29CC6CD5185F46818DD9 *>(__this + 1);
return __DTString_GetRepeatCount_m115C785C62A5A67CE2BCEA6789CA89BA5B0A97B5(_thisAdjusted, method);
}
// System.Boolean System.__DTString::GetNextDigit()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool __DTString_GetNextDigit_mE662D3828A0E0648E24F62FC5D750DA554364EFB (__DTString_t6E7DE2A99E4F15F384EC29CC6CD5185F46818DD9 * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (__DTString_GetNextDigit_mE662D3828A0E0648E24F62FC5D750DA554364EFB_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
int32_t V_0 = 0;
{
int32_t L_0 = __this->get_Index_1();
V_0 = ((int32_t)il2cpp_codegen_add((int32_t)L_0, (int32_t)1));
int32_t L_1 = V_0;
__this->set_Index_1(L_1);
int32_t L_2 = V_0;
int32_t L_3 = __this->get_len_2();
if ((((int32_t)L_2) < ((int32_t)L_3)))
{
goto IL_001b;
}
}
{
return (bool)0;
}
IL_001b:
{
String_t* L_4 = __this->get_Value_0();
int32_t L_5 = __this->get_Index_1();
NullCheck(L_4);
Il2CppChar L_6 = String_get_Chars_m14308AC3B95F8C1D9F1D1055B116B37D595F1D96(L_4, L_5, /*hidden argument*/NULL);
IL2CPP_RUNTIME_CLASS_INIT(DateTimeParse_t657E38D9FF27E5FD6A33E23887031A86248D97D4_il2cpp_TypeInfo_var);
bool L_7 = DateTimeParse_IsDigit_mCC840BC9EC5E157F967F148BC12F6A815E75B74A(L_6, /*hidden argument*/NULL);
return L_7;
}
}
IL2CPP_EXTERN_C bool __DTString_GetNextDigit_mE662D3828A0E0648E24F62FC5D750DA554364EFB_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
__DTString_t6E7DE2A99E4F15F384EC29CC6CD5185F46818DD9 * _thisAdjusted = reinterpret_cast<__DTString_t6E7DE2A99E4F15F384EC29CC6CD5185F46818DD9 *>(__this + 1);
return __DTString_GetNextDigit_mE662D3828A0E0648E24F62FC5D750DA554364EFB(_thisAdjusted, method);
}
// System.Char System.__DTString::GetChar()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Il2CppChar __DTString_GetChar_m15E6D62E27D5EC6E7E726D2E6A719A95A521CAE6 (__DTString_t6E7DE2A99E4F15F384EC29CC6CD5185F46818DD9 * __this, const RuntimeMethod* method)
{
{
String_t* L_0 = __this->get_Value_0();
int32_t L_1 = __this->get_Index_1();
NullCheck(L_0);
Il2CppChar L_2 = String_get_Chars_m14308AC3B95F8C1D9F1D1055B116B37D595F1D96(L_0, L_1, /*hidden argument*/NULL);
return L_2;
}
}
IL2CPP_EXTERN_C Il2CppChar __DTString_GetChar_m15E6D62E27D5EC6E7E726D2E6A719A95A521CAE6_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
__DTString_t6E7DE2A99E4F15F384EC29CC6CD5185F46818DD9 * _thisAdjusted = reinterpret_cast<__DTString_t6E7DE2A99E4F15F384EC29CC6CD5185F46818DD9 *>(__this + 1);
return __DTString_GetChar_m15E6D62E27D5EC6E7E726D2E6A719A95A521CAE6(_thisAdjusted, method);
}
// System.Int32 System.__DTString::GetDigit()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t __DTString_GetDigit_m0A4FC9D7AA54648B77398FAF7997FF7FED3694BF (__DTString_t6E7DE2A99E4F15F384EC29CC6CD5185F46818DD9 * __this, const RuntimeMethod* method)
{
{
String_t* L_0 = __this->get_Value_0();
int32_t L_1 = __this->get_Index_1();
NullCheck(L_0);
Il2CppChar L_2 = String_get_Chars_m14308AC3B95F8C1D9F1D1055B116B37D595F1D96(L_0, L_1, /*hidden argument*/NULL);
return ((int32_t)il2cpp_codegen_subtract((int32_t)L_2, (int32_t)((int32_t)48)));
}
}
IL2CPP_EXTERN_C int32_t __DTString_GetDigit_m0A4FC9D7AA54648B77398FAF7997FF7FED3694BF_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
__DTString_t6E7DE2A99E4F15F384EC29CC6CD5185F46818DD9 * _thisAdjusted = reinterpret_cast<__DTString_t6E7DE2A99E4F15F384EC29CC6CD5185F46818DD9 *>(__this + 1);
return __DTString_GetDigit_m0A4FC9D7AA54648B77398FAF7997FF7FED3694BF(_thisAdjusted, method);
}
// System.Void System.__DTString::SkipWhiteSpaces()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void __DTString_SkipWhiteSpaces_mB4AA5270916EF04CD52A4F3C16B1FB08D0B0CF4F (__DTString_t6E7DE2A99E4F15F384EC29CC6CD5185F46818DD9 * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (__DTString_SkipWhiteSpaces_mB4AA5270916EF04CD52A4F3C16B1FB08D0B0CF4F_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
goto IL_002b;
}
IL_0002:
{
String_t* L_0 = __this->get_Value_0();
int32_t L_1 = __this->get_Index_1();
NullCheck(L_0);
Il2CppChar L_2 = String_get_Chars_m14308AC3B95F8C1D9F1D1055B116B37D595F1D96(L_0, ((int32_t)il2cpp_codegen_add((int32_t)L_1, (int32_t)1)), /*hidden argument*/NULL);
IL2CPP_RUNTIME_CLASS_INIT(Char_tBF22D9FC341BE970735250BB6FF1A4A92BBA58B9_il2cpp_TypeInfo_var);
bool L_3 = Char_IsWhiteSpace_m8AE1C4157A1E1D8F5022630F4229AB26223BDC6B(L_2, /*hidden argument*/NULL);
if (L_3)
{
goto IL_001d;
}
}
{
return;
}
IL_001d:
{
int32_t L_4 = __this->get_Index_1();
__this->set_Index_1(((int32_t)il2cpp_codegen_add((int32_t)L_4, (int32_t)1)));
}
IL_002b:
{
int32_t L_5 = __this->get_Index_1();
int32_t L_6 = __this->get_len_2();
if ((((int32_t)((int32_t)il2cpp_codegen_add((int32_t)L_5, (int32_t)1))) < ((int32_t)L_6)))
{
goto IL_0002;
}
}
{
return;
}
}
IL2CPP_EXTERN_C void __DTString_SkipWhiteSpaces_mB4AA5270916EF04CD52A4F3C16B1FB08D0B0CF4F_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
__DTString_t6E7DE2A99E4F15F384EC29CC6CD5185F46818DD9 * _thisAdjusted = reinterpret_cast<__DTString_t6E7DE2A99E4F15F384EC29CC6CD5185F46818DD9 *>(__this + 1);
__DTString_SkipWhiteSpaces_mB4AA5270916EF04CD52A4F3C16B1FB08D0B0CF4F(_thisAdjusted, method);
}
// System.Boolean System.__DTString::SkipWhiteSpaceCurrent()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool __DTString_SkipWhiteSpaceCurrent_m85EF1DCFFB216A209FEB3CC53CB8E977C51D71DB (__DTString_t6E7DE2A99E4F15F384EC29CC6CD5185F46818DD9 * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (__DTString_SkipWhiteSpaceCurrent_m85EF1DCFFB216A209FEB3CC53CB8E977C51D71DB_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
int32_t V_0 = 0;
{
int32_t L_0 = __this->get_Index_1();
int32_t L_1 = __this->get_len_2();
if ((((int32_t)L_0) < ((int32_t)L_1)))
{
goto IL_0010;
}
}
{
return (bool)0;
}
IL_0010:
{
Il2CppChar L_2 = __this->get_m_current_3();
IL2CPP_RUNTIME_CLASS_INIT(Char_tBF22D9FC341BE970735250BB6FF1A4A92BBA58B9_il2cpp_TypeInfo_var);
bool L_3 = Char_IsWhiteSpace_m8AE1C4157A1E1D8F5022630F4229AB26223BDC6B(L_2, /*hidden argument*/NULL);
if (L_3)
{
goto IL_0045;
}
}
{
return (bool)1;
}
IL_001f:
{
String_t* L_4 = __this->get_Value_0();
int32_t L_5 = __this->get_Index_1();
NullCheck(L_4);
Il2CppChar L_6 = String_get_Chars_m14308AC3B95F8C1D9F1D1055B116B37D595F1D96(L_4, L_5, /*hidden argument*/NULL);
__this->set_m_current_3(L_6);
Il2CppChar L_7 = __this->get_m_current_3();
IL2CPP_RUNTIME_CLASS_INIT(Char_tBF22D9FC341BE970735250BB6FF1A4A92BBA58B9_il2cpp_TypeInfo_var);
bool L_8 = Char_IsWhiteSpace_m8AE1C4157A1E1D8F5022630F4229AB26223BDC6B(L_7, /*hidden argument*/NULL);
if (L_8)
{
goto IL_0045;
}
}
{
return (bool)1;
}
IL_0045:
{
int32_t L_9 = __this->get_Index_1();
V_0 = ((int32_t)il2cpp_codegen_add((int32_t)L_9, (int32_t)1));
int32_t L_10 = V_0;
__this->set_Index_1(L_10);
int32_t L_11 = V_0;
int32_t L_12 = __this->get_len_2();
if ((((int32_t)L_11) < ((int32_t)L_12)))
{
goto IL_001f;
}
}
{
return (bool)0;
}
}
IL2CPP_EXTERN_C bool __DTString_SkipWhiteSpaceCurrent_m85EF1DCFFB216A209FEB3CC53CB8E977C51D71DB_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
__DTString_t6E7DE2A99E4F15F384EC29CC6CD5185F46818DD9 * _thisAdjusted = reinterpret_cast<__DTString_t6E7DE2A99E4F15F384EC29CC6CD5185F46818DD9 *>(__this + 1);
return __DTString_SkipWhiteSpaceCurrent_m85EF1DCFFB216A209FEB3CC53CB8E977C51D71DB(_thisAdjusted, method);
}
// System.Void System.__DTString::TrimTail()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void __DTString_TrimTail_m23E23486D88B86A755B551A9881F1FDA9D6DD99A (__DTString_t6E7DE2A99E4F15F384EC29CC6CD5185F46818DD9 * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (__DTString_TrimTail_m23E23486D88B86A755B551A9881F1FDA9D6DD99A_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
int32_t V_0 = 0;
{
int32_t L_0 = __this->get_len_2();
V_0 = ((int32_t)il2cpp_codegen_subtract((int32_t)L_0, (int32_t)1));
goto IL_000f;
}
IL_000b:
{
int32_t L_1 = V_0;
V_0 = ((int32_t)il2cpp_codegen_subtract((int32_t)L_1, (int32_t)1));
}
IL_000f:
{
int32_t L_2 = V_0;
if ((((int32_t)L_2) < ((int32_t)0)))
{
goto IL_0026;
}
}
{
String_t* L_3 = __this->get_Value_0();
int32_t L_4 = V_0;
NullCheck(L_3);
Il2CppChar L_5 = String_get_Chars_m14308AC3B95F8C1D9F1D1055B116B37D595F1D96(L_3, L_4, /*hidden argument*/NULL);
IL2CPP_RUNTIME_CLASS_INIT(Char_tBF22D9FC341BE970735250BB6FF1A4A92BBA58B9_il2cpp_TypeInfo_var);
bool L_6 = Char_IsWhiteSpace_m8AE1C4157A1E1D8F5022630F4229AB26223BDC6B(L_5, /*hidden argument*/NULL);
if (L_6)
{
goto IL_000b;
}
}
IL_0026:
{
String_t* L_7 = __this->get_Value_0();
int32_t L_8 = V_0;
NullCheck(L_7);
String_t* L_9 = String_Substring_mB593C0A320C683E6E47EFFC0A12B7A465E5E43BB(L_7, 0, ((int32_t)il2cpp_codegen_add((int32_t)L_8, (int32_t)1)), /*hidden argument*/NULL);
__this->set_Value_0(L_9);
String_t* L_10 = __this->get_Value_0();
NullCheck(L_10);
int32_t L_11 = String_get_Length_mD48C8A16A5CF1914F330DCE82D9BE15C3BEDD018(L_10, /*hidden argument*/NULL);
__this->set_len_2(L_11);
return;
}
}
IL2CPP_EXTERN_C void __DTString_TrimTail_m23E23486D88B86A755B551A9881F1FDA9D6DD99A_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
__DTString_t6E7DE2A99E4F15F384EC29CC6CD5185F46818DD9 * _thisAdjusted = reinterpret_cast<__DTString_t6E7DE2A99E4F15F384EC29CC6CD5185F46818DD9 *>(__this + 1);
__DTString_TrimTail_m23E23486D88B86A755B551A9881F1FDA9D6DD99A(_thisAdjusted, method);
}
// System.Void System.__DTString::RemoveTrailingInQuoteSpaces()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void __DTString_RemoveTrailingInQuoteSpaces_m18A5B81964E3027BF02B1393CCD7781AB3ECA72F (__DTString_t6E7DE2A99E4F15F384EC29CC6CD5185F46818DD9 * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (__DTString_RemoveTrailingInQuoteSpaces_m18A5B81964E3027BF02B1393CCD7781AB3ECA72F_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
int32_t V_0 = 0;
Il2CppChar V_1 = 0x0;
{
int32_t L_0 = __this->get_len_2();
V_0 = ((int32_t)il2cpp_codegen_subtract((int32_t)L_0, (int32_t)1));
int32_t L_1 = V_0;
if ((((int32_t)L_1) > ((int32_t)1)))
{
goto IL_000e;
}
}
{
return;
}
IL_000e:
{
String_t* L_2 = __this->get_Value_0();
int32_t L_3 = V_0;
NullCheck(L_2);
Il2CppChar L_4 = String_get_Chars_m14308AC3B95F8C1D9F1D1055B116B37D595F1D96(L_2, L_3, /*hidden argument*/NULL);
V_1 = L_4;
Il2CppChar L_5 = V_1;
if ((((int32_t)L_5) == ((int32_t)((int32_t)39))))
{
goto IL_0025;
}
}
{
Il2CppChar L_6 = V_1;
if ((!(((uint32_t)L_6) == ((uint32_t)((int32_t)34)))))
{
goto IL_008f;
}
}
IL_0025:
{
String_t* L_7 = __this->get_Value_0();
int32_t L_8 = V_0;
NullCheck(L_7);
Il2CppChar L_9 = String_get_Chars_m14308AC3B95F8C1D9F1D1055B116B37D595F1D96(L_7, ((int32_t)il2cpp_codegen_subtract((int32_t)L_8, (int32_t)1)), /*hidden argument*/NULL);
IL2CPP_RUNTIME_CLASS_INIT(Char_tBF22D9FC341BE970735250BB6FF1A4A92BBA58B9_il2cpp_TypeInfo_var);
bool L_10 = Char_IsWhiteSpace_m8AE1C4157A1E1D8F5022630F4229AB26223BDC6B(L_9, /*hidden argument*/NULL);
if (!L_10)
{
goto IL_008f;
}
}
{
int32_t L_11 = V_0;
V_0 = ((int32_t)il2cpp_codegen_subtract((int32_t)L_11, (int32_t)1));
goto IL_0044;
}
IL_0040:
{
int32_t L_12 = V_0;
V_0 = ((int32_t)il2cpp_codegen_subtract((int32_t)L_12, (int32_t)1));
}
IL_0044:
{
int32_t L_13 = V_0;
if ((((int32_t)L_13) < ((int32_t)1)))
{
goto IL_005d;
}
}
{
String_t* L_14 = __this->get_Value_0();
int32_t L_15 = V_0;
NullCheck(L_14);
Il2CppChar L_16 = String_get_Chars_m14308AC3B95F8C1D9F1D1055B116B37D595F1D96(L_14, ((int32_t)il2cpp_codegen_subtract((int32_t)L_15, (int32_t)1)), /*hidden argument*/NULL);
IL2CPP_RUNTIME_CLASS_INIT(Char_tBF22D9FC341BE970735250BB6FF1A4A92BBA58B9_il2cpp_TypeInfo_var);
bool L_17 = Char_IsWhiteSpace_m8AE1C4157A1E1D8F5022630F4229AB26223BDC6B(L_16, /*hidden argument*/NULL);
if (L_17)
{
goto IL_0040;
}
}
IL_005d:
{
String_t* L_18 = __this->get_Value_0();
int32_t L_19 = V_0;
String_t* L_20 = __this->get_Value_0();
NullCheck(L_20);
int32_t L_21 = String_get_Length_mD48C8A16A5CF1914F330DCE82D9BE15C3BEDD018(L_20, /*hidden argument*/NULL);
int32_t L_22 = V_0;
NullCheck(L_18);
String_t* L_23 = String_Remove_m54FD37F2B9CA7DBFE440B0CB8503640A2CFF00FF(L_18, L_19, ((int32_t)il2cpp_codegen_subtract((int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)L_21, (int32_t)1)), (int32_t)L_22)), /*hidden argument*/NULL);
__this->set_Value_0(L_23);
String_t* L_24 = __this->get_Value_0();
NullCheck(L_24);
int32_t L_25 = String_get_Length_mD48C8A16A5CF1914F330DCE82D9BE15C3BEDD018(L_24, /*hidden argument*/NULL);
__this->set_len_2(L_25);
}
IL_008f:
{
return;
}
}
IL2CPP_EXTERN_C void __DTString_RemoveTrailingInQuoteSpaces_m18A5B81964E3027BF02B1393CCD7781AB3ECA72F_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
__DTString_t6E7DE2A99E4F15F384EC29CC6CD5185F46818DD9 * _thisAdjusted = reinterpret_cast<__DTString_t6E7DE2A99E4F15F384EC29CC6CD5185F46818DD9 *>(__this + 1);
__DTString_RemoveTrailingInQuoteSpaces_m18A5B81964E3027BF02B1393CCD7781AB3ECA72F(_thisAdjusted, method);
}
// System.Void System.__DTString::RemoveLeadingInQuoteSpaces()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void __DTString_RemoveLeadingInQuoteSpaces_m71E36820EEC9E50FFC1FA2F53FCFA3495EB2BC19 (__DTString_t6E7DE2A99E4F15F384EC29CC6CD5185F46818DD9 * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (__DTString_RemoveLeadingInQuoteSpaces_m71E36820EEC9E50FFC1FA2F53FCFA3495EB2BC19_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
int32_t V_0 = 0;
Il2CppChar V_1 = 0x0;
{
int32_t L_0 = __this->get_len_2();
if ((((int32_t)L_0) > ((int32_t)2)))
{
goto IL_000a;
}
}
{
return;
}
IL_000a:
{
V_0 = 0;
String_t* L_1 = __this->get_Value_0();
int32_t L_2 = V_0;
NullCheck(L_1);
Il2CppChar L_3 = String_get_Chars_m14308AC3B95F8C1D9F1D1055B116B37D595F1D96(L_1, L_2, /*hidden argument*/NULL);
V_1 = L_3;
Il2CppChar L_4 = V_1;
if ((((int32_t)L_4) == ((int32_t)((int32_t)39))))
{
goto IL_0029;
}
}
{
Il2CppChar L_5 = V_1;
if ((!(((uint32_t)L_5) == ((uint32_t)((int32_t)34)))))
{
goto IL_0070;
}
}
{
goto IL_0029;
}
IL_0025:
{
int32_t L_6 = V_0;
V_0 = ((int32_t)il2cpp_codegen_add((int32_t)L_6, (int32_t)1));
}
IL_0029:
{
int32_t L_7 = V_0;
int32_t L_8 = __this->get_len_2();
if ((((int32_t)((int32_t)il2cpp_codegen_add((int32_t)L_7, (int32_t)1))) >= ((int32_t)L_8)))
{
goto IL_0049;
}
}
{
String_t* L_9 = __this->get_Value_0();
int32_t L_10 = V_0;
NullCheck(L_9);
Il2CppChar L_11 = String_get_Chars_m14308AC3B95F8C1D9F1D1055B116B37D595F1D96(L_9, ((int32_t)il2cpp_codegen_add((int32_t)L_10, (int32_t)1)), /*hidden argument*/NULL);
IL2CPP_RUNTIME_CLASS_INIT(Char_tBF22D9FC341BE970735250BB6FF1A4A92BBA58B9_il2cpp_TypeInfo_var);
bool L_12 = Char_IsWhiteSpace_m8AE1C4157A1E1D8F5022630F4229AB26223BDC6B(L_11, /*hidden argument*/NULL);
if (L_12)
{
goto IL_0025;
}
}
IL_0049:
{
int32_t L_13 = V_0;
if (!L_13)
{
goto IL_0070;
}
}
{
String_t* L_14 = __this->get_Value_0();
int32_t L_15 = V_0;
NullCheck(L_14);
String_t* L_16 = String_Remove_m54FD37F2B9CA7DBFE440B0CB8503640A2CFF00FF(L_14, 1, L_15, /*hidden argument*/NULL);
__this->set_Value_0(L_16);
String_t* L_17 = __this->get_Value_0();
NullCheck(L_17);
int32_t L_18 = String_get_Length_mD48C8A16A5CF1914F330DCE82D9BE15C3BEDD018(L_17, /*hidden argument*/NULL);
__this->set_len_2(L_18);
}
IL_0070:
{
return;
}
}
IL2CPP_EXTERN_C void __DTString_RemoveLeadingInQuoteSpaces_m71E36820EEC9E50FFC1FA2F53FCFA3495EB2BC19_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
__DTString_t6E7DE2A99E4F15F384EC29CC6CD5185F46818DD9 * _thisAdjusted = reinterpret_cast<__DTString_t6E7DE2A99E4F15F384EC29CC6CD5185F46818DD9 *>(__this + 1);
__DTString_RemoveLeadingInQuoteSpaces_m71E36820EEC9E50FFC1FA2F53FCFA3495EB2BC19(_thisAdjusted, method);
}
// System.DTSubString System.__DTString::GetSubString()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR DTSubString_t0B5F9998AD0833CCE29248DE20EFEBFE9EBFB93D __DTString_GetSubString_m699C79DE88DFBC0BDD9F85C2CDC155ABB1473DC4 (__DTString_t6E7DE2A99E4F15F384EC29CC6CD5185F46818DD9 * __this, const RuntimeMethod* method)
{
DTSubString_t0B5F9998AD0833CCE29248DE20EFEBFE9EBFB93D V_0;
memset((&V_0), 0, sizeof(V_0));
int32_t V_1 = 0;
Il2CppChar V_2 = 0x0;
int32_t V_3 = 0;
{
il2cpp_codegen_initobj((&V_0), sizeof(DTSubString_t0B5F9998AD0833CCE29248DE20EFEBFE9EBFB93D ));
int32_t L_0 = __this->get_Index_1();
(&V_0)->set_index_1(L_0);
String_t* L_1 = __this->get_Value_0();
(&V_0)->set_s_0(L_1);
goto IL_00a2;
}
IL_0024:
{
String_t* L_2 = __this->get_Value_0();
int32_t L_3 = __this->get_Index_1();
DTSubString_t0B5F9998AD0833CCE29248DE20EFEBFE9EBFB93D L_4 = V_0;
int32_t L_5 = L_4.get_length_2();
NullCheck(L_2);
Il2CppChar L_6 = String_get_Chars_m14308AC3B95F8C1D9F1D1055B116B37D595F1D96(L_2, ((int32_t)il2cpp_codegen_add((int32_t)L_3, (int32_t)L_5)), /*hidden argument*/NULL);
V_2 = L_6;
Il2CppChar L_7 = V_2;
if ((((int32_t)L_7) < ((int32_t)((int32_t)48))))
{
goto IL_004b;
}
}
{
Il2CppChar L_8 = V_2;
if ((((int32_t)L_8) > ((int32_t)((int32_t)57))))
{
goto IL_004b;
}
}
{
V_1 = 2;
goto IL_004d;
}
IL_004b:
{
V_1 = 4;
}
IL_004d:
{
DTSubString_t0B5F9998AD0833CCE29248DE20EFEBFE9EBFB93D L_9 = V_0;
int32_t L_10 = L_9.get_length_2();
if (L_10)
{
goto IL_005f;
}
}
{
int32_t L_11 = V_1;
(&V_0)->set_type_3(L_11);
goto IL_0068;
}
IL_005f:
{
DTSubString_t0B5F9998AD0833CCE29248DE20EFEBFE9EBFB93D L_12 = V_0;
int32_t L_13 = L_12.get_type_3();
int32_t L_14 = V_1;
if ((!(((uint32_t)L_13) == ((uint32_t)L_14))))
{
goto IL_00ba;
}
}
IL_0068:
{
int32_t* L_15 = (&V_0)->get_address_of_length_2();
int32_t* L_16 = L_15;
int32_t L_17 = *((int32_t*)L_16);
*((int32_t*)L_16) = (int32_t)((int32_t)il2cpp_codegen_add((int32_t)L_17, (int32_t)1));
int32_t L_18 = V_1;
if ((!(((uint32_t)L_18) == ((uint32_t)2))))
{
goto IL_00ba;
}
}
{
DTSubString_t0B5F9998AD0833CCE29248DE20EFEBFE9EBFB93D L_19 = V_0;
int32_t L_20 = L_19.get_length_2();
if ((((int32_t)L_20) <= ((int32_t)8)))
{
goto IL_008b;
}
}
{
(&V_0)->set_type_3(1);
DTSubString_t0B5F9998AD0833CCE29248DE20EFEBFE9EBFB93D L_21 = V_0;
return L_21;
}
IL_008b:
{
Il2CppChar L_22 = V_2;
V_3 = ((int32_t)il2cpp_codegen_subtract((int32_t)L_22, (int32_t)((int32_t)48)));
DTSubString_t0B5F9998AD0833CCE29248DE20EFEBFE9EBFB93D L_23 = V_0;
int32_t L_24 = L_23.get_value_4();
int32_t L_25 = V_3;
(&V_0)->set_value_4(((int32_t)il2cpp_codegen_add((int32_t)((int32_t)il2cpp_codegen_multiply((int32_t)L_24, (int32_t)((int32_t)10))), (int32_t)L_25)));
}
IL_00a2:
{
int32_t L_26 = __this->get_Index_1();
DTSubString_t0B5F9998AD0833CCE29248DE20EFEBFE9EBFB93D L_27 = V_0;
int32_t L_28 = L_27.get_length_2();
int32_t L_29 = __this->get_len_2();
if ((((int32_t)((int32_t)il2cpp_codegen_add((int32_t)L_26, (int32_t)L_28))) < ((int32_t)L_29)))
{
goto IL_0024;
}
}
IL_00ba:
{
DTSubString_t0B5F9998AD0833CCE29248DE20EFEBFE9EBFB93D L_30 = V_0;
int32_t L_31 = L_30.get_length_2();
if (L_31)
{
goto IL_00cc;
}
}
{
(&V_0)->set_type_3(3);
DTSubString_t0B5F9998AD0833CCE29248DE20EFEBFE9EBFB93D L_32 = V_0;
return L_32;
}
IL_00cc:
{
DTSubString_t0B5F9998AD0833CCE29248DE20EFEBFE9EBFB93D L_33 = V_0;
return L_33;
}
}
IL2CPP_EXTERN_C DTSubString_t0B5F9998AD0833CCE29248DE20EFEBFE9EBFB93D __DTString_GetSubString_m699C79DE88DFBC0BDD9F85C2CDC155ABB1473DC4_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
__DTString_t6E7DE2A99E4F15F384EC29CC6CD5185F46818DD9 * _thisAdjusted = reinterpret_cast<__DTString_t6E7DE2A99E4F15F384EC29CC6CD5185F46818DD9 *>(__this + 1);
return __DTString_GetSubString_m699C79DE88DFBC0BDD9F85C2CDC155ABB1473DC4(_thisAdjusted, method);
}
// System.Void System.__DTString::ConsumeSubString(System.DTSubString)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void __DTString_ConsumeSubString_mDFAADAA4A5FC450399046DB04CE10A4503961FAA (__DTString_t6E7DE2A99E4F15F384EC29CC6CD5185F46818DD9 * __this, DTSubString_t0B5F9998AD0833CCE29248DE20EFEBFE9EBFB93D ___sub0, const RuntimeMethod* method)
{
{
DTSubString_t0B5F9998AD0833CCE29248DE20EFEBFE9EBFB93D L_0 = ___sub0;
int32_t L_1 = L_0.get_index_1();
DTSubString_t0B5F9998AD0833CCE29248DE20EFEBFE9EBFB93D L_2 = ___sub0;
int32_t L_3 = L_2.get_length_2();
__this->set_Index_1(((int32_t)il2cpp_codegen_add((int32_t)L_1, (int32_t)L_3)));
int32_t L_4 = __this->get_Index_1();
int32_t L_5 = __this->get_len_2();
if ((((int32_t)L_4) >= ((int32_t)L_5)))
{
goto IL_0038;
}
}
{
String_t* L_6 = __this->get_Value_0();
int32_t L_7 = __this->get_Index_1();
NullCheck(L_6);
Il2CppChar L_8 = String_get_Chars_m14308AC3B95F8C1D9F1D1055B116B37D595F1D96(L_6, L_7, /*hidden argument*/NULL);
__this->set_m_current_3(L_8);
}
IL_0038:
{
return;
}
}
IL2CPP_EXTERN_C void __DTString_ConsumeSubString_mDFAADAA4A5FC450399046DB04CE10A4503961FAA_AdjustorThunk (RuntimeObject * __this, DTSubString_t0B5F9998AD0833CCE29248DE20EFEBFE9EBFB93D ___sub0, const RuntimeMethod* method)
{
__DTString_t6E7DE2A99E4F15F384EC29CC6CD5185F46818DD9 * _thisAdjusted = reinterpret_cast<__DTString_t6E7DE2A99E4F15F384EC29CC6CD5185F46818DD9 *>(__this + 1);
__DTString_ConsumeSubString_mDFAADAA4A5FC450399046DB04CE10A4503961FAA(_thisAdjusted, ___sub0, method);
}
// System.Void System.__DTString::.cctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void __DTString__cctor_mC97C8C04AED3132252833D2119019C73BF6EFA80 (const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (__DTString__cctor_mC97C8C04AED3132252833D2119019C73BF6EFA80_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
CharU5BU5D_t4CC6ABF0AD71BEC97E3C2F1E9C5677E46D3A75C2* L_0 = (CharU5BU5D_t4CC6ABF0AD71BEC97E3C2F1E9C5677E46D3A75C2*)(CharU5BU5D_t4CC6ABF0AD71BEC97E3C2F1E9C5677E46D3A75C2*)SZArrayNew(CharU5BU5D_t4CC6ABF0AD71BEC97E3C2F1E9C5677E46D3A75C2_il2cpp_TypeInfo_var, (uint32_t)2);
CharU5BU5D_t4CC6ABF0AD71BEC97E3C2F1E9C5677E46D3A75C2* L_1 = L_0;
NullCheck(L_1);
(L_1)->SetAt(static_cast<il2cpp_array_size_t>(0), (Il2CppChar)((int32_t)32));
CharU5BU5D_t4CC6ABF0AD71BEC97E3C2F1E9C5677E46D3A75C2* L_2 = L_1;
NullCheck(L_2);
(L_2)->SetAt(static_cast<il2cpp_array_size_t>(1), (Il2CppChar)((int32_t)160));
((__DTString_t6E7DE2A99E4F15F384EC29CC6CD5185F46818DD9_StaticFields*)il2cpp_codegen_static_fields_for(__DTString_t6E7DE2A99E4F15F384EC29CC6CD5185F46818DD9_il2cpp_TypeInfo_var))->set_WhiteSpaceChecks_6(L_2);
return;
}
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Boolean System.__Filters::FilterAttribute(System.Reflection.MemberInfo,System.Object)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool __Filters_FilterAttribute_mBF9879ECFB908212C56CAE0B42C9E29BFCB347C1 (__Filters_tDD9D6B7C7A31B12AB3D5CCF1B115DD693F62DB34 * __this, MemberInfo_t * ___m0, RuntimeObject * ___filterCriteria1, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (__Filters_FilterAttribute_mBF9879ECFB908212C56CAE0B42C9E29BFCB347C1_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
int32_t V_0 = 0;
int32_t V_1 = 0;
int32_t V_2 = 0;
int32_t V_3 = 0;
int32_t V_4 = 0;
Exception_t * __last_unhandled_exception = 0;
NO_UNUSED_WARNING (__last_unhandled_exception);
Exception_t * __exception_local = 0;
NO_UNUSED_WARNING (__exception_local);
int32_t __leave_target = -1;
NO_UNUSED_WARNING (__leave_target);
{
RuntimeObject * L_0 = ___filterCriteria1;
if (L_0)
{
goto IL_0013;
}
}
{
String_t* L_1 = Environment_GetResourceString_m2C75C2AF268F01E2BF34AD1C2E1352CF4BA51AD9(_stringLiteralE8C2E73741ABBBE9D320E65848D6DB0BCF7D63A5, /*hidden argument*/NULL);
InvalidFilterCriteriaException_tB11C87F151CD79ACA0837773B9BFD8791CA715BA * L_2 = (InvalidFilterCriteriaException_tB11C87F151CD79ACA0837773B9BFD8791CA715BA *)il2cpp_codegen_object_new(InvalidFilterCriteriaException_tB11C87F151CD79ACA0837773B9BFD8791CA715BA_il2cpp_TypeInfo_var);
InvalidFilterCriteriaException__ctor_m8A7E7373F5BFA58916AA7A8D99E49AA3C6861031(L_2, L_1, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_2, NULL, __Filters_FilterAttribute_mBF9879ECFB908212C56CAE0B42C9E29BFCB347C1_RuntimeMethod_var);
}
IL_0013:
{
MemberInfo_t * L_3 = ___m0;
NullCheck(L_3);
int32_t L_4 = VirtFuncInvoker0< int32_t >::Invoke(6 /* System.Reflection.MemberTypes System.Reflection.MemberInfo::get_MemberType() */, L_3);
V_0 = L_4;
int32_t L_5 = V_0;
if ((((int32_t)L_5) == ((int32_t)1)))
{
goto IL_002c;
}
}
{
int32_t L_6 = V_0;
if ((((int32_t)L_6) == ((int32_t)4)))
{
goto IL_00ce;
}
}
{
int32_t L_7 = V_0;
if ((!(((uint32_t)L_7) == ((uint32_t)8))))
{
goto IL_0160;
}
}
IL_002c:
{
V_1 = 0;
}
IL_002e:
try
{ // begin try (depth: 1)
RuntimeObject * L_8 = ___filterCriteria1;
V_1 = ((*(int32_t*)((int32_t*)UnBox(L_8, Int32_t585191389E07734F19F3156FF88FB3EF4800D102_il2cpp_TypeInfo_var))));
goto IL_0048;
} // end try (depth: 1)
catch(Il2CppExceptionWrapper& e)
{
__exception_local = (Exception_t *)e.ex;
if(il2cpp_codegen_class_is_assignable_from (RuntimeObject_il2cpp_TypeInfo_var, il2cpp_codegen_object_class(e.ex)))
goto CATCH_0037;
throw e;
}
CATCH_0037:
{ // begin catch(System.Object)
String_t* L_9 = Environment_GetResourceString_m2C75C2AF268F01E2BF34AD1C2E1352CF4BA51AD9(_stringLiteralE8C2E73741ABBBE9D320E65848D6DB0BCF7D63A5, /*hidden argument*/NULL);
InvalidFilterCriteriaException_tB11C87F151CD79ACA0837773B9BFD8791CA715BA * L_10 = (InvalidFilterCriteriaException_tB11C87F151CD79ACA0837773B9BFD8791CA715BA *)il2cpp_codegen_object_new(InvalidFilterCriteriaException_tB11C87F151CD79ACA0837773B9BFD8791CA715BA_il2cpp_TypeInfo_var);
InvalidFilterCriteriaException__ctor_m8A7E7373F5BFA58916AA7A8D99E49AA3C6861031(L_10, L_9, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_10, NULL, __Filters_FilterAttribute_mBF9879ECFB908212C56CAE0B42C9E29BFCB347C1_RuntimeMethod_var);
} // end catch (depth: 1)
IL_0048:
{
MemberInfo_t * L_11 = ___m0;
NullCheck(L_11);
int32_t L_12 = VirtFuncInvoker0< int32_t >::Invoke(6 /* System.Reflection.MemberTypes System.Reflection.MemberInfo::get_MemberType() */, L_11);
if ((!(((uint32_t)L_12) == ((uint32_t)8))))
{
goto IL_005f;
}
}
{
MemberInfo_t * L_13 = ___m0;
NullCheck(((MethodInfo_t *)CastclassClass((RuntimeObject*)L_13, MethodInfo_t_il2cpp_TypeInfo_var)));
int32_t L_14 = VirtFuncInvoker0< int32_t >::Invoke(20 /* System.Reflection.MethodAttributes System.Reflection.MethodBase::get_Attributes() */, ((MethodInfo_t *)CastclassClass((RuntimeObject*)L_13, MethodInfo_t_il2cpp_TypeInfo_var)));
V_2 = L_14;
goto IL_006b;
}
IL_005f:
{
MemberInfo_t * L_15 = ___m0;
NullCheck(((ConstructorInfo_t9CB51BFC178DF1CBCA5FD16B2D58229618F23EFF *)CastclassClass((RuntimeObject*)L_15, ConstructorInfo_t9CB51BFC178DF1CBCA5FD16B2D58229618F23EFF_il2cpp_TypeInfo_var)));
int32_t L_16 = VirtFuncInvoker0< int32_t >::Invoke(20 /* System.Reflection.MethodAttributes System.Reflection.MethodBase::get_Attributes() */, ((ConstructorInfo_t9CB51BFC178DF1CBCA5FD16B2D58229618F23EFF *)CastclassClass((RuntimeObject*)L_15, ConstructorInfo_t9CB51BFC178DF1CBCA5FD16B2D58229618F23EFF_il2cpp_TypeInfo_var)));
V_2 = L_16;
}
IL_006b:
{
int32_t L_17 = V_1;
if (!((int32_t)((int32_t)L_17&(int32_t)7)))
{
goto IL_007a;
}
}
{
int32_t L_18 = V_2;
int32_t L_19 = V_1;
if ((((int32_t)((int32_t)((int32_t)L_18&(int32_t)7))) == ((int32_t)((int32_t)((int32_t)L_19&(int32_t)7)))))
{
goto IL_007a;
}
}
{
return (bool)0;
}
IL_007a:
{
int32_t L_20 = V_1;
if (!((int32_t)((int32_t)L_20&(int32_t)((int32_t)16))))
{
goto IL_0088;
}
}
{
int32_t L_21 = V_2;
if (((int32_t)((int32_t)L_21&(int32_t)((int32_t)16))))
{
goto IL_0088;
}
}
{
return (bool)0;
}
IL_0088:
{
int32_t L_22 = V_1;
if (!((int32_t)((int32_t)L_22&(int32_t)((int32_t)32))))
{
goto IL_0096;
}
}
{
int32_t L_23 = V_2;
if (((int32_t)((int32_t)L_23&(int32_t)((int32_t)32))))
{
goto IL_0096;
}
}
{
return (bool)0;
}
IL_0096:
{
int32_t L_24 = V_1;
if (!((int32_t)((int32_t)L_24&(int32_t)((int32_t)64))))
{
goto IL_00a4;
}
}
{
int32_t L_25 = V_2;
if (((int32_t)((int32_t)L_25&(int32_t)((int32_t)64))))
{
goto IL_00a4;
}
}
{
return (bool)0;
}
IL_00a4:
{
int32_t L_26 = V_1;
if (!((int32_t)((int32_t)L_26&(int32_t)((int32_t)1024))))
{
goto IL_00b8;
}
}
{
int32_t L_27 = V_2;
if (((int32_t)((int32_t)L_27&(int32_t)((int32_t)1024))))
{
goto IL_00b8;
}
}
{
return (bool)0;
}
IL_00b8:
{
int32_t L_28 = V_1;
if (!((int32_t)((int32_t)L_28&(int32_t)((int32_t)2048))))
{
goto IL_00cc;
}
}
{
int32_t L_29 = V_2;
if (((int32_t)((int32_t)L_29&(int32_t)((int32_t)2048))))
{
goto IL_00cc;
}
}
{
return (bool)0;
}
IL_00cc:
{
return (bool)1;
}
IL_00ce:
{
V_3 = 0;
}
IL_00d0:
try
{ // begin try (depth: 1)
RuntimeObject * L_30 = ___filterCriteria1;
V_3 = ((*(int32_t*)((int32_t*)UnBox(L_30, Int32_t585191389E07734F19F3156FF88FB3EF4800D102_il2cpp_TypeInfo_var))));
goto IL_00ea;
} // end try (depth: 1)
catch(Il2CppExceptionWrapper& e)
{
__exception_local = (Exception_t *)e.ex;
if(il2cpp_codegen_class_is_assignable_from (RuntimeObject_il2cpp_TypeInfo_var, il2cpp_codegen_object_class(e.ex)))
goto CATCH_00d9;
throw e;
}
CATCH_00d9:
{ // begin catch(System.Object)
String_t* L_31 = Environment_GetResourceString_m2C75C2AF268F01E2BF34AD1C2E1352CF4BA51AD9(_stringLiteralE8C2E73741ABBBE9D320E65848D6DB0BCF7D63A5, /*hidden argument*/NULL);
InvalidFilterCriteriaException_tB11C87F151CD79ACA0837773B9BFD8791CA715BA * L_32 = (InvalidFilterCriteriaException_tB11C87F151CD79ACA0837773B9BFD8791CA715BA *)il2cpp_codegen_object_new(InvalidFilterCriteriaException_tB11C87F151CD79ACA0837773B9BFD8791CA715BA_il2cpp_TypeInfo_var);
InvalidFilterCriteriaException__ctor_m8A7E7373F5BFA58916AA7A8D99E49AA3C6861031(L_32, L_31, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_32, NULL, __Filters_FilterAttribute_mBF9879ECFB908212C56CAE0B42C9E29BFCB347C1_RuntimeMethod_var);
} // end catch (depth: 1)
IL_00ea:
{
MemberInfo_t * L_33 = ___m0;
NullCheck(((FieldInfo_t *)CastclassClass((RuntimeObject*)L_33, FieldInfo_t_il2cpp_TypeInfo_var)));
int32_t L_34 = VirtFuncInvoker0< int32_t >::Invoke(16 /* System.Reflection.FieldAttributes System.Reflection.FieldInfo::get_Attributes() */, ((FieldInfo_t *)CastclassClass((RuntimeObject*)L_33, FieldInfo_t_il2cpp_TypeInfo_var)));
V_4 = L_34;
int32_t L_35 = V_3;
if (!((int32_t)((int32_t)L_35&(int32_t)7)))
{
goto IL_0107;
}
}
{
int32_t L_36 = V_4;
int32_t L_37 = V_3;
if ((((int32_t)((int32_t)((int32_t)L_36&(int32_t)7))) == ((int32_t)((int32_t)((int32_t)L_37&(int32_t)7)))))
{
goto IL_0107;
}
}
{
return (bool)0;
}
IL_0107:
{
int32_t L_38 = V_3;
if (!((int32_t)((int32_t)L_38&(int32_t)((int32_t)16))))
{
goto IL_0116;
}
}
{
int32_t L_39 = V_4;
if (((int32_t)((int32_t)L_39&(int32_t)((int32_t)16))))
{
goto IL_0116;
}
}
{
return (bool)0;
}
IL_0116:
{
int32_t L_40 = V_3;
if (!((int32_t)((int32_t)L_40&(int32_t)((int32_t)32))))
{
goto IL_0125;
}
}
{
int32_t L_41 = V_4;
if (((int32_t)((int32_t)L_41&(int32_t)((int32_t)32))))
{
goto IL_0125;
}
}
{
return (bool)0;
}
IL_0125:
{
int32_t L_42 = V_3;
if (!((int32_t)((int32_t)L_42&(int32_t)((int32_t)64))))
{
goto IL_0134;
}
}
{
int32_t L_43 = V_4;
if (((int32_t)((int32_t)L_43&(int32_t)((int32_t)64))))
{
goto IL_0134;
}
}
{
return (bool)0;
}
IL_0134:
{
int32_t L_44 = V_3;
if (!((int32_t)((int32_t)L_44&(int32_t)((int32_t)128))))
{
goto IL_0149;
}
}
{
int32_t L_45 = V_4;
if (((int32_t)((int32_t)L_45&(int32_t)((int32_t)128))))
{
goto IL_0149;
}
}
{
return (bool)0;
}
IL_0149:
{
int32_t L_46 = V_3;
if (!((int32_t)((int32_t)L_46&(int32_t)((int32_t)8192))))
{
goto IL_015e;
}
}
{
int32_t L_47 = V_4;
if (((int32_t)((int32_t)L_47&(int32_t)((int32_t)8192))))
{
goto IL_015e;
}
}
{
return (bool)0;
}
IL_015e:
{
return (bool)1;
}
IL_0160:
{
return (bool)0;
}
}
// System.Boolean System.__Filters::FilterName(System.Reflection.MemberInfo,System.Object)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool __Filters_FilterName_m768C2766720890EE1D07554E3433C0F828D427DB (__Filters_tDD9D6B7C7A31B12AB3D5CCF1B115DD693F62DB34 * __this, MemberInfo_t * ___m0, RuntimeObject * ___filterCriteria1, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (__Filters_FilterName_m768C2766720890EE1D07554E3433C0F828D427DB_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
String_t* V_0 = NULL;
String_t* V_1 = NULL;
{
RuntimeObject * L_0 = ___filterCriteria1;
if (!L_0)
{
goto IL_000b;
}
}
{
RuntimeObject * L_1 = ___filterCriteria1;
if (((String_t*)IsInstSealed((RuntimeObject*)L_1, String_t_il2cpp_TypeInfo_var)))
{
goto IL_001b;
}
}
IL_000b:
{
String_t* L_2 = Environment_GetResourceString_m2C75C2AF268F01E2BF34AD1C2E1352CF4BA51AD9(_stringLiteralFA8B27A553F27F158C5E4C81F3AA90D26451F922, /*hidden argument*/NULL);
InvalidFilterCriteriaException_tB11C87F151CD79ACA0837773B9BFD8791CA715BA * L_3 = (InvalidFilterCriteriaException_tB11C87F151CD79ACA0837773B9BFD8791CA715BA *)il2cpp_codegen_object_new(InvalidFilterCriteriaException_tB11C87F151CD79ACA0837773B9BFD8791CA715BA_il2cpp_TypeInfo_var);
InvalidFilterCriteriaException__ctor_m8A7E7373F5BFA58916AA7A8D99E49AA3C6861031(L_3, L_2, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_3, NULL, __Filters_FilterName_m768C2766720890EE1D07554E3433C0F828D427DB_RuntimeMethod_var);
}
IL_001b:
{
RuntimeObject * L_4 = ___filterCriteria1;
V_0 = ((String_t*)CastclassSealed((RuntimeObject*)L_4, String_t_il2cpp_TypeInfo_var));
String_t* L_5 = V_0;
NullCheck(L_5);
String_t* L_6 = String_Trim_mB52EB7876C7132358B76B7DC95DEACA20722EF4D(L_5, /*hidden argument*/NULL);
V_0 = L_6;
MemberInfo_t * L_7 = ___m0;
NullCheck(L_7);
String_t* L_8 = VirtFuncInvoker0< String_t* >::Invoke(7 /* System.String System.Reflection.MemberInfo::get_Name() */, L_7);
V_1 = L_8;
MemberInfo_t * L_9 = ___m0;
NullCheck(L_9);
int32_t L_10 = VirtFuncInvoker0< int32_t >::Invoke(6 /* System.Reflection.MemberTypes System.Reflection.MemberInfo::get_MemberType() */, L_9);
if ((!(((uint32_t)L_10) == ((uint32_t)((int32_t)128)))))
{
goto IL_004e;
}
}
{
String_t* L_11 = V_1;
String_t* L_12 = V_1;
NullCheck(L_12);
int32_t L_13 = String_LastIndexOf_m76C37E3915E802044761572007B8FB0635995F59(L_12, ((int32_t)43), /*hidden argument*/NULL);
NullCheck(L_11);
String_t* L_14 = String_Substring_m2C4AFF5E79DD8BADFD2DFBCF156BF728FBB8E1AE(L_11, ((int32_t)il2cpp_codegen_add((int32_t)L_13, (int32_t)1)), /*hidden argument*/NULL);
V_1 = L_14;
}
IL_004e:
{
String_t* L_15 = V_0;
NullCheck(L_15);
int32_t L_16 = String_get_Length_mD48C8A16A5CF1914F330DCE82D9BE15C3BEDD018(L_15, /*hidden argument*/NULL);
if ((((int32_t)L_16) <= ((int32_t)0)))
{
goto IL_0082;
}
}
{
String_t* L_17 = V_0;
String_t* L_18 = V_0;
NullCheck(L_18);
int32_t L_19 = String_get_Length_mD48C8A16A5CF1914F330DCE82D9BE15C3BEDD018(L_18, /*hidden argument*/NULL);
NullCheck(L_17);
Il2CppChar L_20 = String_get_Chars_m14308AC3B95F8C1D9F1D1055B116B37D595F1D96(L_17, ((int32_t)il2cpp_codegen_subtract((int32_t)L_19, (int32_t)1)), /*hidden argument*/NULL);
if ((!(((uint32_t)L_20) == ((uint32_t)((int32_t)42)))))
{
goto IL_0082;
}
}
{
String_t* L_21 = V_0;
String_t* L_22 = V_0;
NullCheck(L_22);
int32_t L_23 = String_get_Length_mD48C8A16A5CF1914F330DCE82D9BE15C3BEDD018(L_22, /*hidden argument*/NULL);
NullCheck(L_21);
String_t* L_24 = String_Substring_mB593C0A320C683E6E47EFFC0A12B7A465E5E43BB(L_21, 0, ((int32_t)il2cpp_codegen_subtract((int32_t)L_23, (int32_t)1)), /*hidden argument*/NULL);
V_0 = L_24;
String_t* L_25 = V_1;
String_t* L_26 = V_0;
NullCheck(L_25);
bool L_27 = String_StartsWith_m844A95C9A205A0F951B0C45634E0C222E73D0B49(L_25, L_26, 4, /*hidden argument*/NULL);
return L_27;
}
IL_0082:
{
String_t* L_28 = V_1;
String_t* L_29 = V_0;
NullCheck(L_28);
bool L_30 = String_Equals_m9C4D78DFA0979504FE31429B64A4C26DF48020D1(L_28, L_29, /*hidden argument*/NULL);
return L_30;
}
}
// System.Boolean System.__Filters::FilterIgnoreCase(System.Reflection.MemberInfo,System.Object)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool __Filters_FilterIgnoreCase_m883976C13C53B21BE3430DE51D4317CBCF89F53A (__Filters_tDD9D6B7C7A31B12AB3D5CCF1B115DD693F62DB34 * __this, MemberInfo_t * ___m0, RuntimeObject * ___filterCriteria1, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (__Filters_FilterIgnoreCase_m883976C13C53B21BE3430DE51D4317CBCF89F53A_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
String_t* V_0 = NULL;
String_t* V_1 = NULL;
{
RuntimeObject * L_0 = ___filterCriteria1;
if (!L_0)
{
goto IL_000b;
}
}
{
RuntimeObject * L_1 = ___filterCriteria1;
if (((String_t*)IsInstSealed((RuntimeObject*)L_1, String_t_il2cpp_TypeInfo_var)))
{
goto IL_001b;
}
}
IL_000b:
{
String_t* L_2 = Environment_GetResourceString_m2C75C2AF268F01E2BF34AD1C2E1352CF4BA51AD9(_stringLiteralFA8B27A553F27F158C5E4C81F3AA90D26451F922, /*hidden argument*/NULL);
InvalidFilterCriteriaException_tB11C87F151CD79ACA0837773B9BFD8791CA715BA * L_3 = (InvalidFilterCriteriaException_tB11C87F151CD79ACA0837773B9BFD8791CA715BA *)il2cpp_codegen_object_new(InvalidFilterCriteriaException_tB11C87F151CD79ACA0837773B9BFD8791CA715BA_il2cpp_TypeInfo_var);
InvalidFilterCriteriaException__ctor_m8A7E7373F5BFA58916AA7A8D99E49AA3C6861031(L_3, L_2, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_3, NULL, __Filters_FilterIgnoreCase_m883976C13C53B21BE3430DE51D4317CBCF89F53A_RuntimeMethod_var);
}
IL_001b:
{
RuntimeObject * L_4 = ___filterCriteria1;
V_0 = ((String_t*)CastclassSealed((RuntimeObject*)L_4, String_t_il2cpp_TypeInfo_var));
String_t* L_5 = V_0;
NullCheck(L_5);
String_t* L_6 = String_Trim_mB52EB7876C7132358B76B7DC95DEACA20722EF4D(L_5, /*hidden argument*/NULL);
V_0 = L_6;
MemberInfo_t * L_7 = ___m0;
NullCheck(L_7);
String_t* L_8 = VirtFuncInvoker0< String_t* >::Invoke(7 /* System.String System.Reflection.MemberInfo::get_Name() */, L_7);
V_1 = L_8;
MemberInfo_t * L_9 = ___m0;
NullCheck(L_9);
int32_t L_10 = VirtFuncInvoker0< int32_t >::Invoke(6 /* System.Reflection.MemberTypes System.Reflection.MemberInfo::get_MemberType() */, L_9);
if ((!(((uint32_t)L_10) == ((uint32_t)((int32_t)128)))))
{
goto IL_004e;
}
}
{
String_t* L_11 = V_1;
String_t* L_12 = V_1;
NullCheck(L_12);
int32_t L_13 = String_LastIndexOf_m76C37E3915E802044761572007B8FB0635995F59(L_12, ((int32_t)43), /*hidden argument*/NULL);
NullCheck(L_11);
String_t* L_14 = String_Substring_m2C4AFF5E79DD8BADFD2DFBCF156BF728FBB8E1AE(L_11, ((int32_t)il2cpp_codegen_add((int32_t)L_13, (int32_t)1)), /*hidden argument*/NULL);
V_1 = L_14;
}
IL_004e:
{
String_t* L_15 = V_0;
NullCheck(L_15);
int32_t L_16 = String_get_Length_mD48C8A16A5CF1914F330DCE82D9BE15C3BEDD018(L_15, /*hidden argument*/NULL);
if ((((int32_t)L_16) <= ((int32_t)0)))
{
goto IL_008d;
}
}
{
String_t* L_17 = V_0;
String_t* L_18 = V_0;
NullCheck(L_18);
int32_t L_19 = String_get_Length_mD48C8A16A5CF1914F330DCE82D9BE15C3BEDD018(L_18, /*hidden argument*/NULL);
NullCheck(L_17);
Il2CppChar L_20 = String_get_Chars_m14308AC3B95F8C1D9F1D1055B116B37D595F1D96(L_17, ((int32_t)il2cpp_codegen_subtract((int32_t)L_19, (int32_t)1)), /*hidden argument*/NULL);
if ((!(((uint32_t)L_20) == ((uint32_t)((int32_t)42)))))
{
goto IL_008d;
}
}
{
String_t* L_21 = V_0;
String_t* L_22 = V_0;
NullCheck(L_22);
int32_t L_23 = String_get_Length_mD48C8A16A5CF1914F330DCE82D9BE15C3BEDD018(L_22, /*hidden argument*/NULL);
NullCheck(L_21);
String_t* L_24 = String_Substring_mB593C0A320C683E6E47EFFC0A12B7A465E5E43BB(L_21, 0, ((int32_t)il2cpp_codegen_subtract((int32_t)L_23, (int32_t)1)), /*hidden argument*/NULL);
V_0 = L_24;
String_t* L_25 = V_1;
String_t* L_26 = V_0;
String_t* L_27 = V_0;
NullCheck(L_27);
int32_t L_28 = String_get_Length_mD48C8A16A5CF1914F330DCE82D9BE15C3BEDD018(L_27, /*hidden argument*/NULL);
int32_t L_29 = String_Compare_m208E4853037D81DD5C91DCA060C339DADC3A6064(L_25, 0, L_26, 0, L_28, 5, /*hidden argument*/NULL);
return (bool)((((int32_t)L_29) == ((int32_t)0))? 1 : 0);
}
IL_008d:
{
String_t* L_30 = V_0;
String_t* L_31 = V_1;
int32_t L_32 = String_Compare_m5BD1EF8904C9B13BEDB7A876B122F117B317B442(L_30, L_31, 5, /*hidden argument*/NULL);
return (bool)((((int32_t)L_32) == ((int32_t)0))? 1 : 0);
}
}
// System.Void System.__Filters::.ctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void __Filters__ctor_mA9DEA9B853B953C85A78E101A8001E9EE0E66B35 (__Filters_tDD9D6B7C7A31B12AB3D5CCF1B115DD693F62DB34 * __this, const RuntimeMethod* method)
{
{
Object__ctor_m925ECA5E85CA100E3FB86A4F9E15C120E9A184C0(__this, /*hidden argument*/NULL);
return;
}
}
// System.Void System.__Filters::.cctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void __Filters__cctor_mAC913CDF08E7AB6541101C4B96483BF49C6E2F14 (const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (__Filters__cctor_mAC913CDF08E7AB6541101C4B96483BF49C6E2F14_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
__Filters_tDD9D6B7C7A31B12AB3D5CCF1B115DD693F62DB34 * L_0 = (__Filters_tDD9D6B7C7A31B12AB3D5CCF1B115DD693F62DB34 *)il2cpp_codegen_object_new(__Filters_tDD9D6B7C7A31B12AB3D5CCF1B115DD693F62DB34_il2cpp_TypeInfo_var);
__Filters__ctor_mA9DEA9B853B953C85A78E101A8001E9EE0E66B35(L_0, /*hidden argument*/NULL);
((__Filters_tDD9D6B7C7A31B12AB3D5CCF1B115DD693F62DB34_StaticFields*)il2cpp_codegen_static_fields_for(__Filters_tDD9D6B7C7A31B12AB3D5CCF1B115DD693F62DB34_il2cpp_TypeInfo_var))->set_Instance_0(L_0);
return;
}
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.__Il2CppComDelegate::Finalize()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void __Il2CppComDelegate_Finalize_m893C22F7BEDFBDF8F015EA584CC1419D144D2187 (__Il2CppComDelegate_t0A30496F74225C39A0CF7FADB94934C0536120FD * __this, const RuntimeMethod* method)
{
__Il2CppComObject_Finalize_m98123DBAAA7974D2616F9E90F2574955714CA9A9(__this, NULL);
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.__Il2CppComObject::Finalize()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void __Il2CppComObject_Finalize_m98123DBAAA7974D2616F9E90F2574955714CA9A9 (Il2CppComObject * __this, const RuntimeMethod* method)
{
if (__this->identity != NULL)
{
il2cpp_codegen_il2cpp_com_object_cleanup(__this);
__this->identity->Release();
__this->identity = NULL;
}
Object_Finalize_m4015B7D3A44DE125C5FE34D7276CD4697C06F380(__this, NULL);
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void Unity.ThrowStub::ThrowNotSupportedException()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void ThrowStub_ThrowNotSupportedException_mA248D7D785682F31CDF02FDC1FAB3173EE1B1E19 ()
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (ThrowStub_ThrowNotSupportedException_mA248D7D785682F31CDF02FDC1FAB3173EE1B1E19_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
PlatformNotSupportedException_t14FE109377F8FA8B3B2F9A0C4FE3BF10662C73B5 * L_0 = (PlatformNotSupportedException_t14FE109377F8FA8B3B2F9A0C4FE3BF10662C73B5 *)il2cpp_codegen_object_new(PlatformNotSupportedException_t14FE109377F8FA8B3B2F9A0C4FE3BF10662C73B5_il2cpp_TypeInfo_var);
PlatformNotSupportedException__ctor_m651139B17C9EE918551490BC675754EA8EA3E7C7(L_0, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_0, NULL, ThrowStub_ThrowNotSupportedException_mA248D7D785682F31CDF02FDC1FAB3173EE1B1E19_RuntimeMethod_var);
}
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
| [
"tony_mederos@hotmail.com"
] | tony_mederos@hotmail.com |
770e1057e58aee4f7aa32795c7c420f555573a8a | b03c342d9169ab186c3ade2c5a5c3144571957f7 | /core/semaphore_file.cpp | 0eb299892612ec1314fead90e9339c01e8da57c4 | [
"Apache-2.0"
] | permissive | SaintShaggy/wwiv | 61990a796410afe88b77b530e0b1826163aadef4 | 9eb5e9b51c41c08187cca40e0b6a4b1dd0a92732 | refs/heads/master | 2023-02-10T15:41:45.743954 | 2023-02-04T23:15:57 | 2023-02-04T23:15:57 | 221,625,308 | 0 | 0 | Apache-2.0 | 2019-11-14T06:12:49 | 2019-11-14T06:12:48 | null | UTF-8 | C++ | false | false | 4,151 | cpp | /**************************************************************************/
/* */
/* WWIV Version 5.x */
/* Copyright (C)1998-2022, WWIV Software Services */
/* */
/* Licensed under the Apache License, Version 2.0 (the "License"); */
/* you may not use this file except in compliance with the License. */
/* You may obtain a copy of the License at */
/* */
/* http://www.apache.org/licenses/LICENSE-2.0 */
/* */
/* Unless required by applicable law or agreed to in writing, */
/* software distributed under the License is distributed on an */
/* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, */
/* either express or implied. See the License for the specific */
/* language governing permissions and limitations under the License. */
/* */
/**************************************************************************/
#include "core/semaphore_file.h"
#include "stl.h"
#include "core/file.h"
#include "core/log.h"
#include "core/os.h"
#include <cerrno>
#include <fcntl.h>
#include <string>
#include <utility>
#ifdef _WIN32
//#include <direct.h>
#include <io.h>
//#include <share.h>
#else // _WIN32
#include <sys/file.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>
#include <utime.h>
#endif // _WIN32
using std::chrono::milliseconds;
using namespace wwiv::os;
namespace wwiv::core {
#ifndef _WIN32
#ifndef O_TEMPORARY
#define O_TEMPORARY 0
#endif // O_TEMPORARY
#endif // _WIN32
// static
SemaphoreFile SemaphoreFile::try_acquire(const std::filesystem::path& filepath,
const std::string& text,
std::chrono::duration<double> timeout) {
VLOG(2) << "SemaphoreFile::try_acquire: '" << filepath << "'";
const auto mode = O_CREAT | O_EXCL | O_TEMPORARY | O_RDWR;
const auto pmode = S_IREAD | S_IWRITE;
auto step = timeout / 10;
if (step > std::chrono::seconds(1)) {
step = std::chrono::seconds(1);
}
const auto start = std::chrono::steady_clock::now();
const auto end = start + timeout;
while (true) {
const auto fn = filepath.string();
if (const auto fd = open(fn.c_str(), mode, pmode); fd >= 0) {
if (const auto written = write(fd, text.c_str(), wwiv::stl::size_int(text));
written != wwiv::stl::ssize(text)) {
LOG(WARNING) << "Short write on Semaphore file: " << written << "; vs: " << text.size();
}
return {filepath, fd};
}
if (std::chrono::steady_clock::now() > end) {
VLOG(1) << "FAILED: SemaphoreFile::try_acquire: '" << filepath << "'";
throw semaphore_not_acquired(filepath);
}
sleep_for(step);
}
}
// static
SemaphoreFile SemaphoreFile::acquire(const std::filesystem::path& filepath,
const std::string& text) {
return try_acquire(filepath, text, std::chrono::duration<double>::max());
}
SemaphoreFile::SemaphoreFile(std::filesystem::path path, int fd)
: path_(std::move(path)), fd_(fd) {
}
SemaphoreFile::~SemaphoreFile() {
VLOG(1) << "~SemaphoreFile(): " << path_ << "; fd: " << fd_;
if (fd_ < 0) {
LOG(ERROR) << "Skipping closing since file already closed: " << path_;
return;
}
if (close(fd_) == -1) {
LOG(ERROR) << "Failed to close file: " << path_ << "; error: " << errno;
}
fd_ = -1;
#ifndef _WIN32
// Since we don't have O_TEMPORARY outside of WIN32, we unlink the file
// which will delete it once the last file handle is closed.
if (!File::Remove(path_, true)) {
LOG(ERROR) << "Failed to unlink file: " << path_ << "; error: " << errno;
}
#endif // _WIN32
}
} // namespace wwiv
| [
"rushfan@wwivbbs.org"
] | rushfan@wwivbbs.org |
bdd94cf777034f41e438ad87841c31f348452aae | 72f2824893b3628d86fc6f05b6d57bfaf6d62870 | /category/cpu/rand.cpp | fb759700788171b5e5f96627f8c569001909658c | [
"MIT"
] | permissive | RuoAndo/Usenix_LISA19 | 679b7113e65d9c13c92f8aed71549b71f7017818 | 4ce32061d7aeeaab9b3662d8b22eecc43ef8a700 | refs/heads/master | 2023-08-20T17:20:08.291729 | 2023-08-08T06:53:56 | 2023-08-08T06:53:56 | 193,852,147 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 241 | cpp | #include <random>
#include <iostream>
int main(int argc, char *argv[])
{
std::random_device rnd; // 非決定的な乱数生成器
for(int i = 0; i < atoi(argv[1]); i++) {
std::cout << rnd() % 9999 << "\n";
}
return 0;
}
| [
"ando.ruo@gmail.com"
] | ando.ruo@gmail.com |
18477b06c2c947e2968d632760e437730e6a3c91 | f0749232d54f17e3c321b0b90daaeb23b9faec82 | /Online Judge Code/[Other] Online-Judge-Solutions-master_from github/Topcoder/Div I/304 - 2.cpp | d454042cc93ba986afad0b180a034d16ae61fdd6 | [] | no_license | tmuttaqueen/MyCodes | c9024a5b901e68e7c7466885eddbfcd31a5c9780 | 80ec40b26649029ad546ce8ce5bfec0b314b1f61 | refs/heads/master | 2020-04-18T22:20:51.845309 | 2019-05-16T18:11:02 | 2019-05-16T18:11:02 | 167,791,029 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,004 | cpp | #include <vector>
#include <string>
#include <list>
#include <map>
#include <set>
#include <deque>
#include <stack>
#include <bitset>
#include <algorithm>
#include <functional>
#include <numeric>
#include <utility>
#include <sstream>
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <ctime>
using namespace std;
class Conditional
{
public:
double probability(int nDice, int maxSide, int v, int theSum)
{
double dp1[51][2501],dp2[51][2501];
memset(dp1,0,sizeof(dp1));
memset(dp2,0,sizeof(dp2));
dp1[0][0] = 1;
for(int i = 1;i<=nDice;++i){
for(int j = nDice*maxSide;j>=0;--j){
if(j>=v) dp2[i][j] = dp1[i-1][j-v];
for(int k = 1;k<=maxSide;++k){
if(k>j) continue;
if(k!=v) dp1[i][j] += dp1[i-1][j-k];
dp2[i][j] += dp2[i-1][j-k];
}
}
}
double s = 0,t = 0;
for(int i = 1;i<=nDice*maxSide;++i){
if(i>=theSum) s += dp2[nDice][i];
t += dp2[nDice][i];
}
return s/t;
}
};
| [
"1505002.tm@ugrad.cse.buet.ac.bd"
] | 1505002.tm@ugrad.cse.buet.ac.bd |
42203070b60555b3fcee53cd2bb728a212f1b365 | 71abc5ebd99c80ab92f6da9c37580af5b9c86117 | /Assignment5.cpp | 27b7bbf2f40fe09e451e834022aa87b0879a7b63 | [] | no_license | josefrancobaquera/CS_471_Programming_Languages | 5ee3862751f7c40d5e171209c911a10cd41430dd | 25ad59dcf528e2324a07539054b2f8e2a61c7f50 | refs/heads/master | 2020-12-24T04:50:32.324994 | 2020-01-31T08:20:28 | 2020-01-31T08:20:28 | 236,944,129 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,327 | cpp | /* -------------------------------------------------------------------------------
* Name: Jose Franco Baquera
* Course: CS 471 - Programming Language Structures 1 at NMSU
* Instructor: Shaun Cooper
* Assignment: Chapter 5 Programming Assignment
* Program/File Name: Assignment5.cpp
* Date: October 4, 2019
*
* Assumptions: There are no assumptions for this program. We do, however, expect that
* global variables are stored in the data segment while local variables are stored
* in the run-time stack segment.
*
* Description/Explanation of Code: The program first declares a global (static) variable x.
* The value of the global variable is then printed in the main function before the first
* assignment statement. This global variable is then assigned a value of 21 and printed again.
* After the second print statement, the program declares a new local variable with the same
* "name" as the global variable (i.e. x). The value of this local variable is then printed.
* Lastly, the program will assign a value of 42 to the local variable and print it.
*
* Purpose: The purpose of the program is to allow students to learn how static scoping works
* using global and local variables. The program's output will demonstrate a "search process"
* that occurs when trying to use a variable. That is, the program will first search declarations
* locally, then in increasingly larger enclosing scopes until one is found for the given name.
* This search process continues until the variable name is found and errors otherwise (i.e. the
* program will search up to global variables). Lastly, the programming assignment will also show
* that you can have multiple variables named "x" declared in different scopes. That is, the L-value
* of the variable "x" will change depending on which scope you are trying to access it.
*
* Program Input/Precondition: None.
*
* Program Output/Post-condition: Prints the value of "x" at different locations within the program.
------------------------------------------------------------------------------- */
/* Include all necessary libraries for the program. */
/* The iostream library will allow the program to print. */
#include <iostream>
/* "using" declaration that will allow us to use I/O variables such as cin and cout. */
using namespace std;
/* Declare a global variable x. */
int x;
/* Main function. The program will start running from this particular function. */
int main( int argc, char *argv[ ] ) {
/* Print the value of global variable x before we assign it a different value. */
cout << "x is " << x << " before the first assignment statement inside main - Language C++\n";
/* Assign the value 21 to the global variable and print the value of it. */
x = 21;
cout << "x is " << x << " after the first assignment statement inside main - Language C++\n";
/* Declare a new local variable x and print the value of it. */
int x;
cout << "x is " << x << " after declaring a new variable x inside main - Language C++\n";
/* Assign the value 42 to the local variable and print the value of it. */
x = 42;
cout << "x is " << x << " after the second assignment statement inside main - Language C++\n";
} /* end main function */
| [
"noreply@github.com"
] | josefrancobaquera.noreply@github.com |
c6fde5c094c072ec1b5b374e46576555837281f4 | 18b783f880dffe2e104c825ed6bd004f648d5dc8 | /aieBootstrap-master/PhysicsEngine/Joint.h | 3bb209cde40c3251cb9b8eacfe4d57c62af4acaf | [
"MIT"
] | permissive | AaronDSmit/PhysicsEngine | 1b74e66acbe25d9eee7836e183284af8c94cbe03 | b0e925b7f944e47b87feedd59a07c2869b02299a | refs/heads/master | 2021-05-03T09:12:19.958319 | 2018-06-15T04:58:01 | 2018-06-15T04:58:01 | 120,572,083 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 505 | h | #ifndef Joint_H
#define Joint_H
#include <glm/glm.hpp>
namespace aie
{
class Renderer2D;
}
/// <summary>
/// A connection between to RigidBodies
/// </summary>
class Joint
{
protected:
Joint();
public:
Joint(class RigidBody* body1, class RigidBody* body2);
virtual void FixedUpdate(glm::vec2 gravity, float fixedDeltaTime) = 0;
virtual void draw(class aie::Renderer2D* renderer);
~Joint() = default;
protected:
class RigidBody* m_body1;
class RigidBody* m_body2;
};
#endif // !Joint_H | [
"smitaaron1@gmail.com"
] | smitaaron1@gmail.com |
d2cb2b2c87e88eed74eddd970036bda7b7cf9fc7 | 3fc7ffa1a8cdeab167851b808493081d9c7d2fe2 | /src/odom2mavros_node.cpp | 751d7cedd1f47d2dccc48a3bf66d025a31851e4c | [] | no_license | leelaser/odom2mavros | 7e07c1d6ce6b83b610614de9cb89095e08ea524e | 0017e1bbfd3114c8a00b78cbe21d8848a39676e1 | refs/heads/master | 2023-03-16T00:47:39.660643 | 2020-01-18T11:39:07 | 2020-01-18T11:39:07 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 4,329 | cpp | #include "ros/ros.h"
#include "std_msgs/String.h"
#include "geometry_msgs/PoseStamped.h"
#include "nav_msgs/Odometry.h"
#include "utils/yamlRead.h"
#include "stdio.h"
#include <sstream>
#include "../3rdPartLib/Sophus/sophus/se3.h"
#include "../3rdPartLib/Sophus/sophus/so3.h"
using namespace std;
using namespace Sophus;
double time_gap;
bool vo_has_pose;
geometry_msgs::PoseStamped latest_pose;
ros::Time lastMsgTime;
bool first_msg;
ros::Publisher mavros_pub;
SE3 T_imu_odom;
SE3 T_odom_imu;
void vo_callback(const nav_msgs::OdometryConstPtr msg)
{
if(first_msg)
{
lastMsgTime = msg->header.stamp;
latest_pose.header.frame_id = "map";
latest_pose.header.stamp=msg->header.stamp;
Quaterniond q=Quaterniond(msg->pose.pose.orientation.w,
msg->pose.pose.orientation.x,
msg->pose.pose.orientation.y,
msg->pose.pose.orientation.z);
Vec3 t = Vec3(msg->pose.pose.position.x,
msg->pose.pose.position.y,
msg->pose.pose.position.z);
SE3 T_w_odom = SE3(q,t);
SE3 T_w_i=T_w_odom*T_odom_imu;
Quaterniond q_w_i = T_w_i.unit_quaternion();
Vec3 t_w_i = T_w_i.translation();
latest_pose.pose.orientation.w = q_w_i.w();
latest_pose.pose.orientation.x = q_w_i.x();
latest_pose.pose.orientation.y = q_w_i.y();
latest_pose.pose.orientation.z = q_w_i.z();
latest_pose.pose.position.x = t_w_i(0);
latest_pose.pose.position.y = t_w_i(1);
latest_pose.pose.position.z = t_w_i(2);
mavros_pub.publish(latest_pose);
first_msg = false;
}
else
{
if((msg->header.stamp.toSec()-lastMsgTime.toSec())>time_gap)
{
lastMsgTime = msg->header.stamp;
latest_pose.header.frame_id = "map";
latest_pose.header.stamp=msg->header.stamp;
Quaterniond q=Quaterniond(msg->pose.pose.orientation.w,
msg->pose.pose.orientation.x,
msg->pose.pose.orientation.y,
msg->pose.pose.orientation.z);
Vec3 t = Vec3(msg->pose.pose.position.x,
msg->pose.pose.position.y,
msg->pose.pose.position.z);
SE3 T_w_odom = SE3(q,t);
SE3 T_w_i=T_w_odom*T_odom_imu;
Quaterniond q_w_i = T_w_i.unit_quaternion();
Vec3 t_w_i = T_w_i.translation();
latest_pose.pose.orientation.w = q_w_i.w();
latest_pose.pose.orientation.x = q_w_i.x();
latest_pose.pose.orientation.y = q_w_i.y();
latest_pose.pose.orientation.z = q_w_i.z();
latest_pose.pose.position.x = t_w_i(0);
latest_pose.pose.position.y = t_w_i(1);
latest_pose.pose.position.z = t_w_i(2);
mavros_pub.publish(latest_pose);
}
}
return;
}
int main(int argc, char **argv)
{
ros::init(argc, argv, "odom2mavros");
ros::NodeHandle nh("~");
string configFilePath, mavros_topic, odom_topic;
int frequency=0;
cout << "get parameter:" << endl;
nh.getParam("odom_topic", odom_topic);
cout << odom_topic << endl;
nh.getParam("mavros_topic", mavros_topic);
cout << mavros_topic << endl;
nh.getParam("config_file_path", configFilePath);
cout << configFilePath << endl;
nh.getParam("pub_frequency", frequency);
cout << frequency << endl;
Mat4x4 mat_imu_odom;//odom to imu frame
mat_imu_odom = Mat44FromYaml(configFilePath,"T_imu_odom");
cout << "Transformation From odom to imu is:" << endl << mat_imu_odom << endl;
T_imu_odom = SE3(SO3(mat_imu_odom.topLeftCorner(3,3)),mat_imu_odom.topRightCorner(3,1));
T_odom_imu = T_imu_odom.inverse();
cout << mat_imu_odom.topLeftCorner(3,3) << endl;
cout << mat_imu_odom.topRightCorner(3,1) << endl;
time_gap = 0.1;//default frequency is 10hz
if(frequency)
{
time_gap = 1.0/((double)frequency);
}
first_msg = true;
mavros_pub = nh.advertise<geometry_msgs::PoseStamped>(mavros_topic, 2);
ros::Subscriber sub = nh.subscribe(odom_topic, 1, vo_callback);
ros::spin();
return 0;
}
| [
"chensy1991@gmail.com"
] | chensy1991@gmail.com |
e95b56b42d948daff3f413421c3e880eb4ef212a | fa0ed969ba921f95764d58cc48b1aaa0d224d642 | /code/scene/Planet.cpp | 9a7abc3cbfacc5d5ad822f39d338a0c07f790d85 | [] | no_license | alexus37/asteroidField | a8dccd4d97cb4e0dfaaba5f636c33d3161d17676 | d0e0b99ff48481aa1618a8f3c51ebd3b8f7016ac | refs/heads/master | 2022-04-06T06:32:43.234999 | 2020-02-27T09:37:19 | 2020-02-27T09:37:19 | 114,906,967 | 2 | 0 | null | 2020-02-27T09:37:21 | 2017-12-20T16:14:01 | C++ | UTF-8 | C++ | false | false | 4,332 | cpp | /**
* \brief Implementation of the planet.
*
* \Author: Alexander Lelidis, Andreas Emch, Uroš Tešić
* \Date: 2017-11-11
*/
#include "Planet.h"
#include <osg/Switch>
#include <osgDB/ReadFile>
#include "../config.h"
#include "../osg/JsonEigenConversions.h"
#include "../osg/OsgEigenConversions.h"
#include "../osg/Loader.h"
#include "../osg/ModelManager.h"
#include "../osg/visitors/ConvexHullVisitor.h"
using namespace pbs17;
/**
* \brief Constructor of Planet.
*
* \param size
* Size of the planet.
*/
Planet::Planet(double size)
: SpaceObject("", 0), _radius(size) {}
/**
* \brief Constructor of Planet with JSON-configuration.
*
* \param j
* JSON-configuration for the planet.
*/
Planet::Planet(json j) : SpaceObject(j) {
_radius = j["size"].get<double>();
Eigen::Vector3d pos = fromJson(j["position"]);
initOsg(pos, j["ratio"].get<double>(), _radius);
Eigen::Vector3d linearVelocity = fromJson(j["linearVelocity"]);
Eigen::Vector3d angularVelocity = fromJson(j["angularVelocity"]);
Eigen::Vector3d force = fromJson(j["force"]);
Eigen::Vector3d torque = fromJson(j["torque"]);
initPhysics(j["mass"].get<double>(), linearVelocity, angularVelocity, force, torque);
if (j["useFollowingRibbon"].is_boolean() && j["useFollowingRibbon"].get<bool>() == true) {
json ribbonInfo = j["followingRibbon"];
initFollowingRibbon(toOsg(fromJson(ribbonInfo["color"])),
ribbonInfo["numPoints"].get<unsigned int>(),
ribbonInfo["halfWidth"].get<float>());
}
}
/**
* \brief Constructor of Planet.
*
* \param size
* Size of the planet.
* \param textureName
* Relative location to the texture-file. (Relative from the data-directory in the source).
*/
Planet::Planet(double size, std::string textureName)
: SpaceObject("", textureName), _radius(size) {}
/**
* \brief Destructor of Planet.
*/
Planet::~Planet() {}
/**
* \brief Initialize the space-object for OSG.
*
* \param position
* Initial position of the object.
* \param ratio
* Ratio of the simplifier. (Supported values: [0..1])
* \param scaling
* Scaling of the model. (1.0 => not scaled, < 1.0 => smaller, > 1.0 => larger)
*/
void Planet::initOsg(Eigen::Vector3d position, double ratio, double scaling) {
// Set the position to the space-object
_position = position;
_scaling = _radius;
// Load the model
std::string modelPath = DATA_PATH + "/sphere.obj";
_modelFile = ModelManager::Instance()->loadModel(modelPath, false);
// Scale the model if needed
if (_radius != 1.0) {
_modelFile = Loader::scaleNode(_modelFile, _radius);
}
// Compute convex hull
osg::Matrix scalingMatrix = osg::Matrix::scale(_radius, _radius, _radius);
ConvexHullVisitor convexHull(scalingMatrix);
_modelFile->accept(convexHull);
_convexHull = convexHull.getConvexHull();
osg::Geode* geodeConvexHull = new osg::Geode;
geodeConvexHull->addDrawable(_convexHull->getOsgModel());
// Switch to decide if the convex hull or the model has to be rendered.
_convexRenderSwitch = new osg::Switch;
_convexRenderSwitch->addChild(_modelFile, true);
_convexRenderSwitch->addChild(geodeConvexHull, false);
// Transformation-node for position and rotation updates.
_transformation = new osg::MatrixTransform;
_transformation->setMatrix(osg::Matrix::translate(toOsg(position)));
_transformation->addChild(_convexRenderSwitch);
calculateAABB();
_modelRoot = new osg::Switch;
_modelRoot->insertChild(0, _transformation, true);
_modelRoot->insertChild(1, _aabbRendering, false);
initTexturing();
}
/**
* \brief Initialize the space-object for physics.
*
* \param mass
* Mass: unit = kg
* \param linearVelocity
* Linear velocity: unit = m/s
* \param angularVelocity
* Angular velocity: unit = rad/s
* \param force
* Global force: unit = vector with norm equals to N
* \param torque
* Global torque: unit = vector with norm equals to N*m (newton metre)
*/
void Planet::initPhysics(double mass, Eigen::Vector3d linearVelocity, Eigen::Vector3d angularVelocity, Eigen::Vector3d force, Eigen::Vector3d torque) {
SpaceObject::initPhysics(mass, linearVelocity, angularVelocity, force, torque);
_momentOfInertia = Eigen::Matrix3d();
_momentOfInertia.setIdentity();
_momentOfInertia *= mass;
_momentOfInertia *= 0.4 * getRadius() * getRadius();
}
| [
"alexlelidis@gmx.de"
] | alexlelidis@gmx.de |
2331ca84677f6c2564ab3084f06f1221aed4c1e0 | 66a06367df71ba5d68ed330d7d318c7b27b7fb27 | /CFPtree.hpp | d52b6f69a37ba2df3ae26d1b5fe317a3033ed584 | [] | no_license | sfchaos/patmine | d3d651e5f6b8ce68aed75a60cb2549e14d58d6ea | 28df2d24363e2debba159cc90dd0080a5ef0516a | refs/heads/master | 2020-05-21T00:45:32.343265 | 2013-06-23T03:43:03 | 2013-06-23T03:43:03 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,583 | hpp | #include <iostream>
#include <sstream>
#include <fstream>
#include <vector>
#include <list>
#include <string>
#include <map>
#include <algorithm>
#include <iterator>
#include <stddef.h>
namespace fpg {
using namespace std;
template <typename K, typename V>
bool less(const pair<K, V>& lhs, const pair<K, V>& rhs)
{
return lhs.second < rhs.second;
}
template <typename K, typename V>
bool greater(const pair<K, V>& lhs, const pair<K, V>& rhs)
{
return !less(lhs, rhs);
}
template <typename K, typename V>
ostream& operator<< (ostream& os, const pair<K, V>& x)
{
os << "key: " << x.first << " value: " << x.second << endl;
return os;
}
template <typename K, typename V>
struct Node
{
typedef std::pair<K, V> NodeInfo;
NodeInfo ni;
Node *lch;
Node *rch;
};
template <typename K = string, typename V = unsigned int>
class FPtree
{
public:
typedef pair<K, V> node_info;
typedef Node<K, V> node_type;
private:
//vector<pair<K, vector<V> > > data;
vector<vector<K> > tran;
map<K, V> itemfreq;
list<pair<K, V> > itemlist;
unsigned int minsup_;
public:
FPtree(unsigned int minsup) : minsup_(minsup) {}
node_type *insert(node_type *p, node_info &node) {
if (p == NULL) {
p = new node_type;
p->ni = node;
p->lch = NULL;
p->rch = NULL;
return p;
}
}
istream& readData(istream &is) {
string line;
vector<K> tmp;
//multimap<K, V> tmp;
K item;
ifstream ifs;
while (getline(is, line)) {
tmp.clear();
istringstream istrs((char *) line.c_str());
while (istrs >> item) {
if (tmp.find(item)==tmp.end()) {
tmp.push_back(item);
}
if (!itemfreq.insert(std::pair<K, V>(item, 1)).second) {
itemfreq[item]++;
}
}
tran.push_back(tmp);
}
return is;
}
void construct() {
for (typename map<K, V>::iterator itr = itemfreq.begin();
itr != itemfreq.end(); ++itr) {
V value = itr->second;
if (value >= minsup_) {
itemlist.push_back(*itr);
}
}
/*
for (typename list<pair<K, V> >::iterator itr = itemlist.begin();
itr != itemlist.end(); ++itr) {
K key = itr->first;
V value = itr->second;
std::cout << "key: " << key << ", value: " << value << std::endl;
}
*/
itemlist.sort(&greater<K, V>);
//copy(itemlist.begin(), itemlist.end(),
// ostream_iterator<pair<K, V> >(cout, "\n"));
for (typename list<pair<K, V> >::iterator itr = itemlist.begin();
itr != itemlist.end(); ++itr) {
K key = itr->first;
V value = itr->second;
std::cout << "key: " << key << " value: " << value << std::endl;
std::cout << "successful" << std::endl;
}
}
};
}
| [
"sfukushim@gmail.com"
] | sfukushim@gmail.com |
dd802a334cbe27c92fc8218c8da21aa6221da691 | ece0df68e529655ac20f66cc69a7147f3481cbed | /gsp.cpp | dd7743b5f83be9bed6286d55925371b172093445 | [] | no_license | myzinsky/googleScholarParser | cc96b68b1ac78ebef3b9bb957ee9392ec1d53adf | 8b36b9f2bdf2947a04bc92f0563f19bd8fe6b146 | refs/heads/master | 2021-01-19T17:37:58.512196 | 2017-04-15T10:02:23 | 2017-04-15T10:02:23 | 88,338,432 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 10,726 | cpp | #include "gsp.h"
#include "ui_gsp.h"
#include <QString>
#include <QDebug>
#include <QNetworkAccessManager>
#include <QNetworkReply>
#include <QEventLoop>
#include <QRegExp>
#include <QList>
#include <QTextBrowser>
#include <QStandardPaths>
#include <QObject>
#include <QSqlDatabase>
#include <QSqlError>
#include <QSqlQuery>
#include <QSqlRecord>
#include <QFile>
#include <QFileInfo>
#include <QProgressDialog>
#include <QProgressBar>
// qcZEIOkAAAAJ
gsp::gsp(QWidget *parent) :
QMainWindow(parent),
ui(new Ui::gsp)
{
ui->setupUi(this);
ui->statusBar->showMessage("(c) 2017 Matthias Jung");
QHeaderView *headerView = ui->tableWidget->horizontalHeader();
headerView->setSectionResizeMode(0, QHeaderView::Stretch);
// Estimate Config Path:
configPath = QStandardPaths::standardLocations(
QStandardPaths::GenericConfigLocation).at(0);
qDebug() << configPath;
QFileInfo check_file(configPath+"/gsp.sqlite");
if(check_file.exists())
{
loadDatabase();
displayPublications();
displayStats();
}
else
{
createDatabase();
}
}
gsp::~gsp()
{
delete ui;
}
void gsp::on_pushButton_clicked()
{
ui->tableWidget->clear();
ui->tableWidget_2->clear();
ui->tableWidget->clearContents();
ui->tableWidget_2->clearContents();
ui->tableWidget->setRowCount(0);
ui->tableWidget_2->setRowCount(0);
publications.clear();
QProgressDialog progress("Query Google Scholar", "Abort", 0, 0);
QProgressBar* bar=new QProgressBar;
progress.setBar(bar);
bar->setMinimum(0);
bar->setMaximum(0);
progress.show();
unsigned int cstart = 0;
QString html = getHTML(ui->lineEdit->text(), cstart);
//TODO check if it worked out!
unsigned int foundPublications = 0;
do
{
foundPublications = getPublications(html);
// If there are more than 100 publ.: we query google scholar again:
if(foundPublications == 100)
{
cstart += 100;
html = getHTML(ui->lineEdit->text(), cstart);
}
}
while(foundPublications == 100);
// Estimate the Name of the Author:
getName(html);
updateDatabase(ui->lineEdit->text());
displayPublications();
displayStats();
progress.close();
}
QString gsp::getHTML(QString id, unsigned int cstart)
{
QString url = "https://scholar.google.com/citations?user="
+ id + "&cstart="+QString::number(cstart)+"&pagesize=100";
QNetworkAccessManager manager;
QNetworkReply *response = manager.get(QNetworkRequest(QUrl(url)));
QEventLoop event;
connect(response,SIGNAL(finished()),&event,SLOT(quit()));
event.exec();
return response->readAll();
}
void gsp::getName(QString html)
{
// Extract Name:
// <div id="gsc_prf_in">.../div>
QRegExp rx("<div id=\"gsc_prf_in\">([^<]+)</div>");
rx.setMinimal(true);
if (rx.indexIn(html) != -1)
{
ui->name->setText(rx.cap(1));
}
}
/// Extracts all publications from an html string and returns the number of
/// found publications
unsigned int gsp::getPublications(QString html)
{
// The publication list which is to find:
// <tr class="gsc_a_tr"> ... </tr>
QRegExp rx("<tr class=\"gsc_a_tr\">(.+)?</tr>");
rx.setMinimal(true);
int pos = 0; // where we are in the string
unsigned int counter = 0; // where we are in the string
// Get all publications:
while (pos >= 0)
{
pos = rx.indexIn(html, pos);
if (pos >= 0)
{
pos++; // move along in html
counter++; // move along in html
parsePublication(rx.cap(1));
}
}
return counter;
}
void gsp::parsePublication(QString html)
{
publication p;
// Extract Title:
// <a href="..." class="gsc_a_at">...</a>
QRegExp rxTitle("<a href=\"(.+)\"\\s*class=\"gsc_a_at\">([^<]+)</a>");
rxTitle.setMinimal(true);
if (rxTitle.indexIn(html) != -1)
{
p.title = rxTitle.cap(2);
p.url = rxTitle.cap(1);
}
// Extract Authors:
// <div class="gs_gray">...</div>
QRegExp rxAuthors("<div class=\"gs_gray\">(.+)</div>");
rxAuthors.setMinimal(true);
if (rxAuthors.indexIn(html) != -1)
{
p.authors = rxAuthors.cap(1);
}
// Extract Citation Count:
// <a href="..." class="gsc_a_ac">...</a>
QRegExp rxCitations("<a href=\"(.+)\" class=\"gsc_a_ac\">(.+)</a>");
rxCitations.setMinimal(true);
if (rxCitations.indexIn(html) != -1)
{
p.citations = rxCitations.cap(2).toInt();
}
// Extract Year:
// <span class="gsc_a_h">2014</span>
QRegExp rxYear("<span class=\"gsc_a_h\">(.+)</span>");
rxYear.setMinimal(true);
if (rxYear.indexIn(html) != -1)
{
p.year = rxYear.cap(1).toInt();
}
publications.append(p);
}
void gsp::displayPublications()
{
for(int i=0; i < publications.count(); i++)
{
ui->tableWidget->insertRow(ui->tableWidget->rowCount());
QTextBrowser * te = new QTextBrowser();
te->setHtml(
"<b><a href=\"https://scholar.google.com"
+ publications.at(i).url
+ "\" target=\"_blank\">"
+ publications.at(i).title + "</a></b><br><i>"
+ publications.at(i).authors + "</i>"
);
te->setOpenExternalLinks(true);
te->setFrameStyle(QFrame::NoFrame);
te->setFocusPolicy(Qt::NoFocus);
//te->setTextInteractionFlags(Qt::LinksAccessibleByMouse);
te->setStyleSheet("background-color: rgba(255, 255, 255, 0);");
te->setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
ui->tableWidget->setRowHeight(ui->tableWidget->rowCount()-1, 40);
ui->tableWidget->setCellWidget(ui->tableWidget->rowCount()-1, 0, te);
ui->tableWidget->setItem(ui->tableWidget->rowCount()-1,
1,
new QTableWidgetItem(QString::number(publications.at(i).citations)));
ui->tableWidget->setItem(ui->tableWidget->rowCount()-1,
2,
new QTableWidgetItem(QString::number(publications.at(i).year)));
//ui->tableWidget->resizeColumnsToContents();
}
}
void gsp::displayStats()
{
ui->tableWidget_2->insertRow(ui->tableWidget_2->rowCount());
ui->tableWidget_2->setItem(ui->tableWidget_2->rowCount()-1,
0,
new QTableWidgetItem("Citations:"));
ui->tableWidget_2->setItem(ui->tableWidget_2->rowCount()-1,
1,
new QTableWidgetItem(QString::number(citations())));
ui->tableWidget_2->insertRow(ui->tableWidget_2->rowCount());
ui->tableWidget_2->setItem(ui->tableWidget_2->rowCount()-1,
0,
new QTableWidgetItem("h-index:"));
ui->tableWidget_2->setItem(ui->tableWidget_2->rowCount()-1,
1,
new QTableWidgetItem(QString::number(hindex())));
ui->tableWidget_2->insertRow(ui->tableWidget_2->rowCount());
ui->tableWidget_2->setItem(ui->tableWidget_2->rowCount()-1,
0,
new QTableWidgetItem("i10-index:"));
ui->tableWidget_2->setItem(ui->tableWidget_2->rowCount()-1,
1,
new QTableWidgetItem(QString::number(i10index())));
}
unsigned int gsp::citations()
{
unsigned int sum = 0;
for(int i=0; i < publications.count(); i++)
{
sum += publications.at(i).citations;
}
return sum;
}
unsigned int gsp::hindex()
{
unsigned int h = 0;
for(int i=0; i < publications.count(); i++)
{
if(publications.at(i).citations > (unsigned int)i)
{
h++;
}
}
return h;
}
unsigned int gsp::i10index()
{
unsigned int h = 0;
for(int i=0; i < publications.count(); i++)
{
if(publications.at(i).citations >= 10)
{
h++;
}
}
return h;
}
void gsp::createDatabase()
{
db = QSqlDatabase::addDatabase("QSQLITE");
db.setDatabaseName(configPath+"/gsp.sqlite");
db.open();
QSqlQuery query;
if(!query.exec("create table publications "
"(id integer primary key, "
"title varchar(500), "
"url varchar(500), "
"authors varchar(500), "
"citations integer, "
"year integer);"))
{
qDebug() << "Cannot create publications table";
}
if(!query.exec("create table settings "
"(scholar varchar(100),"
"name varchar(100));"))
{
qDebug() << "Cannot create settings table";
}
}
void gsp::updateDatabase(QString scholar)
{
// TODO update mechanism!
// TODO Diff Mechanism!
for(int i=0; i < publications.count(); i++)
{
QSqlQuery query;
query.prepare("INSERT INTO publications"
"(title,url,authors,citations,year)"
" VALUES (:title,:url,:authors,:citations,:year)");
query.bindValue(":title", publications.at(i).title);
query.bindValue(":url", publications.at(i).url);
query.bindValue(":authors", publications.at(i).authors);
query.bindValue(":citations", publications.at(i).citations);
query.bindValue(":year", publications.at(i).year);
if(!query.exec())
qDebug() << "Cannot store publication";
}
QSqlQuery query;
query.prepare("INSERT INTO settings"
"(scholar,name)"
" VALUES (:scholar,:name)");
query.bindValue(":scholar", scholar);
query.bindValue(":name", ui->name->text());
if(!query.exec())
qDebug() << "Cannot store config";
}
void gsp::loadDatabase()
{
db = QSqlDatabase::addDatabase("QSQLITE");
db.setDatabaseName(configPath+"/gsp.sqlite");
db.open();
QSqlQuery query("SELECT * FROM publications");
int title = query.record().indexOf("title");
int url = query.record().indexOf("url");
int authors = query.record().indexOf("authors");
int citations = query.record().indexOf("citations");
int year = query.record().indexOf("year");
while (query.next())
{
publication p;
p.title = query.value(title).toString();
p.url = query.value(url).toString();
p.authors = query.value(authors).toString();
p.citations = query.value(citations).toUInt();
p.year = query.value(year).toUInt();
publications.append(p);
}
query.prepare("SELECT * FROM settings");
query.exec();
int scholar = query.record().indexOf("scholar");
int name = query.record().indexOf("name");
while (query.next())
{
ui->lineEdit->setText(query.value(scholar).toString());
ui->name->setText(query.value(name).toString());
}
}
| [
"jungma@eit.uni-kl.de"
] | jungma@eit.uni-kl.de |
b6a2413706ab788c06cc5fdacbc2004d8e635c5f | d3741c83512f403ba47df36945bb50f64d286e59 | /src/reader.cpp | 82dec80e2426400ea9fa772dfd1574224d22e77a | [
"Zlib"
] | permissive | samsaga2/sjasm | c5b19551e0d8aca1c0559f850f235b8727d155c4 | 86addbe636b6ca4d91971eeda3869cde39339d6b | refs/heads/master | 2016-09-06T09:21:01.976153 | 2015-09-08T12:33:20 | 2015-09-08T12:33:20 | 16,372,275 | 6 | 2 | null | null | null | null | UTF-8 | C++ | false | false | 11,009 | cpp | /*
Sjasm Z80 Assembler version 0.42
Copyright 2011 Sjoerd Mastijn
This software is provided 'as-is', without any express or implied warranty.
In no event will the authors be held liable for any damages arising from the
use of this software.
Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute it freely,
subject to the following restrictions:
1. The origin of this software must not be misrepresented; you must not claim
that you wrote the original software. If you use this software in a product,
an acknowledgment in the product documentation would be appreciated but is
not required.
2. Altered source versions must be plainly marked as such, and must not be
misrepresented as being the original software.
3. This notice may not be removed or altered from any source distribution.
*/
#include <cstdlib>
#include "sjasm.h"
int cmphstr(string &p1, string p2) {
int i=0;
if (isupper(p1[i]))
while (p2[i]) {
if (p1[i]!=toupper(p2[i])) return 0;
++i;
}
else
while (p2[i]) {
if (p1[i]!=p2[i]) return 0;
++i;
}
if (p1[i]>' ') return 0;
p1=p1.substr(i);
return 1;
}
int getstringlength(string &s) {
int p=0;
if (s[0]=='"') {
for(;;) {
++p; if (!s[p]) break;
if (s[p]=='\\') {
if (s[p+1]=='"') { ++p; continue; }
if (s[p+1]=='\\') { ++p; continue; }
}
if (s[p]=='"') { ++p; break; }
}
} else if (s[0]=='\'') {
for(;;) {
++p; if (!s[p]) break;
if (s[p]=='\'') { ++p; break; }
}
} else {
error("getstringlength",ERRINTERNAL);
}
return p;
}
string tolower(string b) {
char *bp,*p;
const char *op=b.c_str();
if (b.length()+1>64) bp=p=(char*)malloc(b.length()+1);
else bp=p=tobuffer;
while(*p++=(char)tolower(*op)) ++op;
return bp;
}
void skipblanks(string &p) {
int pos=(int)p.find_first_not_of(' ');
if (pos==string::npos) p.clear();
else p=p.substr(pos);
}
int comma(string &p) {
skipblanks(p);
if (p[0]!=',') return 0;
p.erase(0,1); return 1;
}
int needcomma(string &p) {
if (comma(p)) return 1;
error("Comma expected");
return 0;
}
Find fspacedot(const_cast<char *>(" ."));
string getinstructionpart(string &p) {
int pos=fspacedot.find(p),u=0;
string d=p.substr(0,pos);
if (pos!=string::npos) p=p.substr(pos); else p.clear();
for (istring i=d.begin(); i!=d.end(); ++i) if ((*i)==toupper(*i)) ++u;
if (d.size()==u) return tolower(d);
return d;
}
string getinstruction(string &p) {
string d=getinstructionpart(p);
if (!p.empty()) if (p[0]=='.') d+='.';
return d;
}
Find fid(const_cast<char *>("qwertyuioplkjhgfdsazxcvbnmQWERTYUIOPLKJHGFDSAZXCVBNM1234567890_"));
string getid(string &p) {
skipblanks(p);
if (!isalpha(p[0]) && p[0]!='_') return "";
int pos=fid.findnot(p);
string d=p.substr(0,pos);
if (pos!=string::npos) p=p.substr(pos); else p.clear();
return d;
}
void checkjunk(string &s) {
skipblanks(s);
if (s.empty()) return;
#ifdef _DEBUG
error("Unexpected",s);
#else
error("Unexpected",s,ERRREP);
#endif
s.clear();
}
char nextchar(istring const &p, string const &s) {
if ((p+1)==s.end()) return 0;
return *(p+1);
}
int sbcneed(string &p, char c) {
skipblanks(p); if (p[0]!=c) return 0;
p.erase(0,1); return 1;
}
int cneed(string &p, char c) {
if (p[0]!=c) return 0;
p.erase(0,1); return 1;
}
int needa(string &p, string c1, int r1, string c2, int r2, string c3, int r3) {
if (!isalpha(p[0])) return 0;
if (cmphstr(p,c1)) return r1;
if (!c2.empty() && cmphstr(p,c2)) return r2;
if (!c3.empty() && cmphstr(p,c3)) return r3;
return 0;
}
int need(string &p, char *c) {
skipblanks(p);
while (*c) {
if (p[0]!=*c) { c+=2; continue; }
++c;
if (*c==' ') { p.erase(0,1); return *(c-1); }
if (*c=='_' && p[1]!=*(c-1)) { p.erase(0,1); return *(c-1); }
if (p[1]==*c) { p=p.substr(2); return *(c-1)+*c; }
++c;
}
return 0;
}
int needequ(string &lp) {
string olp=lp;
skipblanks(lp);
if (lp[0]=='=') { lp.erase(0,1); return 1; }
if (cmphstr(lp,"equ")) return 1;
lp=olp;
return 0;
}
int needfield(string &lp) {
string olp=lp;
skipblanks(lp);
if (lp[0]=='#' && lp[1]!='#') { lp.erase(0,1); return 1; }
lp=olp;
return 0;
}
int needset(string &lp) {
string olp=lp;
skipblanks(lp);
if (lp[0]==':' && lp[1]=='=') { lp=lp.substr(2); return 1; }
lp=olp;
return 0;
}
int islabchar(char p) {
if (isalnum(p) || p=='_' || p=='.') return 1;
return 0;
}
void checkparen(string &s) {
int t=0,p=0;
while (1) {
switch (s[p]) {
case 0: return;
case '(': ++t; break;
case ')': if (t==1) { ++p; s=s.substr(p); skipblanks(s); return; } if (!--t) return; break;
case '\'': for(;;) { ++p; if (!s[p]) return; if (s[p]=='\'') break; } break;
case '"': for(;;) { ++p; if (!s[p]) return; if (s[p]=='\\' && s[p+1]=='"') { ++p; continue; } if (s[p]=='"') break; } break;
default: break;
}
++p;
}
}
int check8(int val) {
unsigned int v=val;
if (v!=(v&255) && ~v>127) errorvalue();
return val & 255;
}
int check5(int val) {
unsigned int v=val;
if (v!=(v&31) && ~v>31) errorvalue();
return val & 31;
}
int check3u(int val) {
unsigned int v=val;
if (v>7) errorvalue();
return val & 7;
}
int check8u(int val) {
unsigned int v=val;
if (v>255) errorvalue();
return val & 255;
}
int checki(int val) {
if (val<-128 || val>127) errorvalue("Offset out of range");
return val & 255;
}
int check16(int val) {
unsigned int v=val;
if (v!=(v&65535) && ~v>32767) errorvalue();
return val & 65535;
}
int check24(int val) {
unsigned int v=val;
if (v!=(val&16777215) && ~v>8388607) errorvalue();
return val & 16777215;
}
void makestring(string &s) {
string res;
for(istring i=s.begin();i!=s.end();++i) { if (*i=='"' || *i=='\\') res+='\\'; res+=*i; }
s=res;
}
void getstring(string &s,string &e) {
e.clear();
skipblanks(s);
if (s.empty()) { error("String expected"); return; }
if (s[0]=='\'') {
for(;;) {
s.erase(0,1);
if (s.empty()) break;
if (s[0]=='\'') { s.erase(0,1); break; }
e.push_back(s[0]);
}
} else if (s[0]=='"') {
s.erase(0,1);
do {
int val;
if (s.empty() || s[0]=='"') { error("Syntax error",ERRREP); break; }
getcharconstchar(s,val); e.push_back((byte)val);
} while (s[0]!='"');
s.erase(0,1);
} else
error("String expected");
}
void getcharconstchar(string &op, int &val) {
val=op[0]; op.erase(0,1);
if (val!='\\') return;
val=op[0]; op.erase(0,1);
switch (val) {
case '\\': case '\'': case '\"': case '\?':
return;
case 'n': case 'N': val=10; return;
case 't': case 'T': val=9; return;
case 'v': case 'V': val=11; return;
case 'b': case 'B': val=8; return;
case 'r': case 'R': val=13; return;
case 'f': case 'F': val=12; return;
case 'a': case 'A': val=7; return;
case 'e': case 'E': val=27; return;
case 'd': case 'D': val=127; return;
default: val='\\'; error("Unknown escape"); return;
}
}
StringList getarguments(string &p) {
int pos,haakjes=0,heind,accolade=0;
StringList a;
string res;
if (heind=(p[0]=='(')) p.erase(0,1);
skipblanks(p);
for(;;) {
switch (p[0]) {
case 0:
if (heind) error("Closing ) expected");
if (!res.empty()) a.push_back(res); return a;
case '(':
++haakjes; break;
case ')':
if (!haakjes-- && heind) { a.push_back(res); p.erase(0,1); return a; }
break;
case '\'':
case '"':
pos=getstringlength(p); res+=p.substr(0,pos); p=p.substr(pos);
continue;
case ',':
if (!accolade) { a.push_back(res); res.clear(); p.erase(0,1); skipblanks(p); continue; }
break;
case '{':
if (!accolade++) { p.erase(0,1); continue; }
break;
case '}':
if (accolade--==1) { p.erase(0,1); continue; }
if (accolade<0) accolade=0;
break;
default:
break;
}
res+=p[0]; p.erase(0,1);
}
// return a;
}
string getargument(string &p, bool greedy, bool heind) {
int pos,accolade=0,haakjes=0;
string res;
skipblanks(p);
for(;;) {
switch (p[0]) {
case 0: return res;
case '\'':
case '"':
pos=getstringlength(p); res+=p.substr(0,pos); p=p.substr(pos);
continue;
case ',':
if (!accolade && !greedy) return res;
break;
case '{':
if (!accolade++) { p.erase(0,1); continue; }
break;
case '}':
if (accolade--==1) { p.erase(0,1); continue; }
if (accolade<0) accolade=0;
break;
case '(':
++haakjes;
break;
case ')':
if (!haakjes-- && heind) return res;
break;
default:
break;
}
res+=p[0]; p.erase(0,1);
}
}
string tohex(int n, int w) {
ostringstream s;
s.width(w);
s.fill('0');
s.flags(ios::hex|ios::uppercase);
s << n;
return s.str();
}
int getinSTRUCTion(string &s) {
string os=s;
skipblanks(s);
string n=getinstruction(s);
if (n.empty()) { s=os; return 0; }
switch (n.size()) {
case 1:
if (n[0]=='#') return 7;
break;
case 2:
if (n[0]=='#' && n[1]=='#') return 6;
if (n[0]=='d') {
if (n[1]=='b') return 1;
if (n[1]=='w') return 2;
if (n[1]=='t') return 3;
if (n[1]=='d') return 4;
if (n[1]=='s') return 5;
}
break;
case 4:
if (n=="byte") return 1;
if (n=="word") return 2;
break;
case 5:
if (n=="dword") return 4;
if (n=="align") return 6;
break;
default:
break;
}
error("Syntax error");
s=os;
return 0;
}
string trim(string s) {
if (s[0]==' ') skipblanks(s);
return s=s.substr(0,s.find_last_not_of(' ')+1);
}
void getpage(string &s, IntList &p) {
int min,max,i,v;
p.clear();
synerr=0;
while(1) {
if (ParseExpression(s,v)) min=v; else min=0;
if ((unsigned)min>255) { min=255; error("Invalid page number"); }
if (need(s, const_cast<char *>(".."))) {
if (ParseExpression(s,v)) max=v; else max=255;
if ((unsigned)max>255) { max=255; error("Invalid pagerange"); }
if ((unsigned)min>(unsigned)max) { min=max; error("Invalid pagerange"); }
for (i=min; i!=max+1; ++i) p.push_back(i);
} else {
p.push_back(min);
}
if (!comma(s)) break;
}
synerr=1;
iIntList ii=p.begin();
while (ii!=p.end())
if (!output[onr]->pageok(*ii)) {
error("Page does not exist",tostr(*ii));
ii=p.erase(ii);
}
else ++ii;
if (!p.size()) p.push_back(0);
}
| [
"samsaga2@gmail.com"
] | samsaga2@gmail.com |
40e8b3e529ee6afa64b14c3d926616e44c972912 | 483cfcf06ffd3a35f2d4569994ac2f45bdc07413 | /CogniTest/CognitiveServicesLib/Face/Exposure.cpp | 1462984d8a69b55169499b64d31613414d7178d6 | [
"MIT"
] | permissive | JuergenSchwertl/HoloLens-Cognitive_Services | 18cac617f5116667b46c44c0f8d3e1dd23a45894 | c1243a70ab44dcd65bd66c3d39cec13eba541135 | refs/heads/master | 2021-01-01T06:37:20.445871 | 2017-10-05T08:05:04 | 2017-10-05T08:05:04 | 97,472,270 | 2 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 1,644 | cpp | #include "pch.h"
#include "Exposure.h"
using namespace std;
using namespace Platform;
using namespace CognitiveServicesLib;
#pragma region ExposureLevelHelper implementation
EnumKeyJsonName<ExposureLevel> ExposureLevelHelper::ckvJsonNames[3] =
{
{ ExposureLevel::UnderExposure, L"underExposure" },
{ ExposureLevel::GoodExposure, L"goodExposure" },
{ ExposureLevel::OverExposure, L"overExposure" },
};
#pragma endregion
IMPLEMENT_PROPERTY(Exposure, CognitiveServicesLib::ExposureLevel, ExposureLevel, L"exposureLevel")
IMPLEMENT_PROPERTY(Exposure, double, Value, L"value")
Exposure::Exposure()
{
}
void Exposure::toStringStream(std::wostringstream& out)
{
out.setf(ios::fixed);
out.precision(2);
out << _OBRACKET
<< JSON_PROPERTYNAME_PCWSTR(ExposureLevel) << _COLON
<< EnumHelper<CognitiveServicesLib::ExposureLevel, ExposureLevelHelper>::c_str(PROPERTY_VARIABLE(ExposureLevel)) << L", "
<< JSON_PROPERTYNAME_PCWSTR(Value) << _COLON << PROPERTY_VARIABLE(Value)
<< _CBRACKET;
}
Platform::String^ Exposure::ToString()
{
std::wostringstream out;
toStringStream(out);
out << _ENDS;
return ref new Platform::String(out.str().c_str());
}
Exposure ^ Exposure::FromJson(Windows::Data::Json::JsonObject ^ jsonObject)
{
Exposure^ exp = nullptr;
if (jsonObject != nullptr)
{
exp = ref new Exposure();
String^ strValue = nullptr;
strValue = jsonObject->GetNamedString(JSON_PROPERTYNAME(ExposureLevel), nullptr);
exp->ExposureLevel = EnumHelper<CognitiveServicesLib::ExposureLevel, ExposureLevelHelper>::parse(strValue);
exp->Value = jsonObject->GetNamedNumber(JSON_PROPERTYNAME(Value), 0.0);
}
return exp;
}
| [
"jschwert@microsoft.com"
] | jschwert@microsoft.com |
43fb336b9200396898d8d56e8fee2963c47e1c26 | 00d23979b4c88b8b375f69015785c1c0c704af46 | /OpenGL/Exercicis-Examen/Ex7-CanviPosicioOBS/MyGLWidget.h | 8416199c72a9633aa6bed858b48b897cb440c7ff | [] | no_license | hmonpa/EPSEVG-INDI | 78423819a8cf73f80e1d2bc1bded038749453b5e | 7089db5bf716a54007dba167ee6a1824722e7ba1 | refs/heads/master | 2023-05-26T14:25:02.039527 | 2021-06-08T05:27:57 | 2021-06-08T05:27:57 | 340,000,398 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,670 | h | #define GLM_FORCE_RADIANS
#include <QOpenGLFunctions_3_3_Core>
#include <QOpenGLWidget>
#include <QOpenGLShader>
#include <QOpenGLShaderProgram>
#include <QKeyEvent>
#include <QMouseEvent>
#include "glm/glm.hpp"
#include "glm/gtc/matrix_transform.hpp"
#include "model.h"
class MyGLWidget : public QOpenGLWidget, protected QOpenGLFunctions_3_3_Core
{
Q_OBJECT
public:
MyGLWidget (QWidget *parent=0);
~MyGLWidget ();
protected:
// initializeGL - Aqui incluim les inicialitzacions del contexte grafic.
virtual void initializeGL ( );
// paintGL - Mètode cridat cada cop que cal refrescar la finestra.
// Tot el que es dibuixa es dibuixa aqui.
virtual void paintGL ( );
// resizeGL - És cridat quan canvia la mida del widget
virtual void resizeGL (int width, int height);
// keyPressEvent - Es cridat quan es prem una tecla
virtual void keyPressEvent (QKeyEvent *event);
// mouse{Press/Release/Move}Event - Són cridades quan es realitza l'event
// corresponent de ratolí
virtual void mousePressEvent (QMouseEvent *event);
virtual void mouseReleaseEvent (QMouseEvent *event);
virtual void mouseMoveEvent (QMouseEvent *event);
private:
void createBuffersPatricio ();
void createBuffersTerraIParet ();
void carregaShaders ();
void iniEscena ();
void iniCamera ();
void projectTransform ();
void viewTransform ();
void modelTransformTerra ();
void modelTransformPatricio ();
void calculaCapsaModel ();
// VAO names
GLuint VAO_Patr;
GLuint VAO_Terra;
// Program
QOpenGLShaderProgram *program;
// Viewport
GLint ample, alt;
// uniform locations
GLuint transLoc, projLoc, viewLoc;
// attribute locations
GLuint vertexLoc, normalLoc, matambLoc, matdiffLoc, matspecLoc, matshinLoc;
// model
Model patr;
// paràmetres calculats a partir de la capsa contenidora del model
glm::vec3 centrePatr;
float escala;
// radi de l'escena
float radiEsc;
typedef enum {NONE, ROTATE, ZOOM} InteractiveAction;
InteractiveAction DoingInteractive;
int xClick, yClick;
float angleY;
bool perspectiva;
// Nuevas funciones y atributos
void modelTransformPatricio2();
void calculaRadiEsc();
glm::vec3 centreEsc;
float angleX;
float ra, FOV, FOV_orig;
// Ejercicio5
void modelTransformVaca();
void calculaCapsaVaca();
void createBuffersVaca();
float escalaVaca;
Model vaca;
GLuint VAO_Vaca;
glm::vec3 centreVaca;
// Ejercicio6
float rotaY;
glm::vec3 OBS;
glm::vec3 VRP;
glm::vec3 UP;
float zN, zF;
};
| [
"hmonpa@gmail.com"
] | hmonpa@gmail.com |
95f317c8201a33e82e9c04e57c8946ef15f8b0bf | ca870172cce7a3f9c4710184cc883619b24d6635 | /D3MkEntityTree/GLExtz.cpp | 532345e476e82daa3af6e39d1af8d4bc686180c4 | [] | no_license | kenjiuno/D3MkEntityTree | 3df858f3bbdb2ca63402e4d3b62c39cebd44da72 | 7df5492858c1786a1586fa06d25c89b581d8d3ff | refs/heads/master | 2020-07-06T23:07:34.773812 | 2019-09-24T15:56:12 | 2019-09-24T15:56:12 | 203,167,008 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 44 | cpp |
#include "StdAfx.h"
#include "GLExtz.h"
| [
"h8mastre@gmail.com"
] | h8mastre@gmail.com |
065261d9f598cf1092cc924a16c3702d7cd95176 | 1b73de41f5d5af929087a801d3b3fa45094ed183 | /TrajectoryControllerP.cpp | a99fe6f881511171465db5951913edfede65cb4a | [] | no_license | jmachowinski/control-trajectory_follower | 9679e568916bddda218ebe4bbc07d69e08236a63 | b7ebf44f49ebb94e0d65ff4bcda61617a11e3c54 | refs/heads/master | 2021-01-16T22:34:19.912184 | 2015-09-01T10:14:05 | 2015-09-01T10:14:05 | 38,483,101 | 0 | 0 | null | 2015-07-03T08:56:46 | 2015-07-03T08:56:46 | null | UTF-8 | C++ | false | false | 1,730 | cpp | /*
* =====================================================================================
*
* Filename: TrajectoryControllerP.cpp
*
* Description: Implementation of trajectory controller with orientation control
* from 'Springer handbook of robotics' chapter 34 pg 805
*
* Version: 1.0
* Created: 10/13/09 10:30:32
* Revision: none
* Compiler: gcc
*
* Author: Ajish Babu, ajish.babu@dfki.de
* Company: DFKI
*
* =====================================================================================
*/
#include "TrajectoryControllerP.hpp"
using namespace trajectory_follower;
chainedProportional::chainedProportional ()
{
} /* ----- end of method chainedProportional::chainedProportional (constructor) ----- */
void
chainedProportional::setConstants(double K2_val, double K3_val)
{
K2 = K2_val;
K3 = K3_val;
}
Eigen::Vector2d
chainedProportional::update (double u1, double d, double theta_e, double c, double c_s )
{
double d_dot, s_dot, z2, z3, v1, v2, u2;
d_dot = u1 * sin(theta_e);
s_dot = u1 * cos(theta_e) / (1.0-d*c);
z2 = d;
z3 = (1.0-(d*c))*tan(theta_e);
v1 = u1 * cos(theta_e) /(1.0 - d*c);
v2 = (-v1 * K2 * z2) - (fabs(v1) * K3 * z3);
u2 = ((v2 + ((d_dot*c + d*c_s*s_dot)*tan(theta_e))) / ((1.0-d*c)*(1+pow(tan(theta_e),2)))) - (s_dot*c);
return Eigen::Vector2d(u1, u2);
} /* ----- end of method chainedProportional::update ----- */
bool
chainedProportional::checkInitialStability( double d, double theta_e, double c, double c_max)
{
double z2, z3;
z2 = d;
z3 = (1.0-(d*c))*tan(theta_e);
if( z2*z2+(z3*z3/K2) < (1/(c_max*c_max)) )
return true;
else
return false;
}
| [
"ajish.babu@dfki.de"
] | ajish.babu@dfki.de |
01c40d747f7b4a929ecd93008ed5b3625eee607e | 21a221c20313339ac7380f8d92f8006e5435ef1d | /src/arcscripts/src/LuaEngine/UnitFunctions.h | 21d31b42ec8063a2361ba3d4ea427b38f923fced | [] | no_license | AwkwardDev/Descent-core-scripts-3.3.5 | a947a98d0fdedae36a488c542642fcf61472c3d7 | d773b1a41ed3f9f970d81962235e858d0848103f | refs/heads/master | 2021-01-18T10:16:03.750112 | 2014-08-12T16:28:15 | 2014-08-12T16:28:15 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 136,572 | h | /*
* ArcScript Scripts for Arcemu MMORPG Server
* Copyright (C) 2008-2009 Arcemu Team
* Copyright (C) 2007 Moon++ <http://www.moonplusplus.com/>
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef UNITFUNCTIONS_H
#define UNITFUNCTIONS_H
namespace luaUnit
{
int GetDisplay(lua_State * L, Unit * ptr)
{
if( ptr == NULL )
lua_pushinteger( L, 0 );
else
lua_pushinteger( L, ptr->GetDisplayId() );
return 1;
}
int GetNativeDisplay(lua_State * L, Unit * ptr)
{
if( ptr == NULL )
lua_pushinteger( L, 0 );
else
lua_pushinteger( L, ptr->GetNativeDisplayId() );
return 1;
}
int GossipCreateMenu(lua_State * L, Unit * ptr)
{
int text_id = luaL_checkint(L, 1);
Player * plr = CHECK_PLAYER(L,2);
int autosend = luaL_checkint(L, 3);
if(plr == NULL) return 0;
objmgr.CreateGossipMenuForPlayer(&Menu, ptr->GetGUID(), text_id, plr);
if(autosend)
Menu->SendTo(plr);
return 0;
}
int GossipMenuAddItem(lua_State * L, Unit * ptr)
{
int icon = luaL_checkint(L, 1);
const char * menu_text = luaL_checkstring(L, 2);
int IntId = luaL_checkint(L, 3);
int extra = luaL_checkint(L, 4);
Menu->AddItem(icon, menu_text, IntId, extra);
return 0;
}
int GossipSendMenu(lua_State * L, Unit * ptr)
{
Player* plr = CHECK_PLAYER(L,1);
if(plr != NULL)
Menu->SendTo(plr);
return 0;
}
int GossipSendPOI(lua_State * L, Unit * ptr)
{
TEST_PLAYER()
Player * plr = TO_PLAYER(ptr);
float x = CHECK_FLOAT(L,1);
float y = CHECK_FLOAT(L, 2);
int icon = luaL_checkint(L, 3);
int flags = luaL_checkint(L, 4);
int data = luaL_checkint(L, 5);
const char * name = luaL_checkstring(L, 6);
plr->Gossip_SendPOI(x, y, icon, flags, data, name);
return 0;
}
int GossipComplete(lua_State * L, Unit * ptr)
{
TEST_PLAYER()
Player * plr = TO_PLAYER(ptr);
plr->Gossip_Complete();
return 0;
}
int IsPlayer(lua_State * L, Unit * ptr)
{
if(!ptr)
{
lua_pushboolean(L, 0);
return 1;
}
if(ptr->IsPlayer())
lua_pushboolean(L, 1);
else
lua_pushboolean(L, 0);
return 1;
}
int IsCreature(lua_State * L, Unit * ptr)
{
if(!ptr)
{
lua_pushboolean(L, 0);
return 1;
}
if(ptr->GetTypeId()==TYPEID_UNIT)
lua_pushboolean(L, 1);
else
lua_pushboolean(L, 0);
return 1;
}
int Emote(lua_State * L, Unit * ptr)
{
if(ptr==NULL) return 0;
uint32 emote_id = luaL_checkint(L, 1);
uint32 time = luaL_checkint(L, 2);
if(emote_id==0)
return 0;
if (time > 0)
ptr->EventAddEmote((EmoteType)emote_id,time);
else
ptr->Emote((EmoteType)emote_id);
return 1;
}
int GetName(lua_State * L, Unit * ptr)
{
if(!ptr)
return 0;
switch(ptr->GetTypeId())
{
case TYPEID_UNIT:
lua_pushstring(L, TO_CREATURE(ptr)->GetCreatureInfo() ? TO_CREATURE(ptr)->GetCreatureInfo()->Name : "Unknown");
break;
case TYPEID_PLAYER:
lua_pushstring(L, TO_PLAYER(ptr)->GetName());
break;
default:
lua_pushstring(L, "Unknown");
break;
}
return 1;
}
int PhaseSet(lua_State * L, Unit * ptr)
{
uint32 newphase = CHECK_ULONG(L,1);
bool Save = (luaL_optint(L,2,false)>0 ? true:false);
Creature * crt = 0;
Player * p_target = 0;
//Save is only for creatures. if you want to save to DB with players, use your own query (security purposes).
//Lua: CharDBQuery("UPDATE `characters` SET `phase`='"..phase.."' WHERE (`name`='"..player:GetName().."'",0)
if (!ptr)
return 0;
switch (ptr->GetTypeId())
{
case TYPEID_UNIT:
crt = TO_CREATURE(ptr);
crt->Phase(PHASE_SET, newphase);
if (crt->m_spawn)
crt->m_spawn->phase = newphase;
if (Save)
{
crt->SaveToDB();
crt->m_loadedFromDB = true;
}
break;
case TYPEID_PLAYER:
p_target = TO_PLAYER(ptr);
p_target->Phase(PHASE_SET, newphase);
if( p_target->GetSession() )
{
WorldPacket data(SMSG_SET_PHASE_SHIFT, 4);
data << newphase;
p_target->GetSession()->SendPacket(&data);
}
break;
default:
break;
}
return 0;
}
int PhaseAdd(lua_State * L, Unit * ptr)
{
uint32 newphase = CHECK_ULONG(L,1);
bool Save = (luaL_optint(L,2,false)>0 ? true:false);
Creature * crt = 0;
Player * p_target = 0;
//Save is only for creatures. if you want to save to DB with players, use your own query (security purposes).
//Lua: CharDBQuery("UPDATE `characters` SET `phase`='"..player:GetPhase().."' WHERE (`name`='"..player:GetName().."'",0)
if (!ptr)
return 0;
switch (ptr->GetTypeId())
{
case TYPEID_UNIT:
crt = TO_CREATURE(ptr);
crt->Phase(PHASE_ADD, newphase);
if (crt->m_spawn)
crt->m_spawn->phase |= newphase;
if (Save)
{
crt->SaveToDB();
crt->m_loadedFromDB = true;
}
break;
case TYPEID_PLAYER:
p_target = TO_PLAYER(ptr);
p_target->Phase(PHASE_ADD, newphase);
if( p_target->GetSession() )
{
WorldPacket data(SMSG_SET_PHASE_SHIFT, 4);
data << p_target->m_phase;
p_target->GetSession()->SendPacket(&data);
}
break;
default:
break;
}
return 0;
}
int PhaseDelete(lua_State * L, Unit * ptr)
{
uint32 newphase = CHECK_ULONG(L,1);
bool Save = (luaL_checkint(L,2)>0 ? true:false);
Creature * crt = 0;
Player * p_target = 0;
//Save is only for creatures. if you want to save to DB with players, use your own query (security purposes).
//Lua: CharDBQuery("UPDATE `characters` SET `phase`='"..player:GetPhase().."' WHERE (`name`='"..player:GetName().."'",0)
if (!ptr)
return 0;
switch (ptr->GetTypeId())
{
case TYPEID_UNIT:
crt = TO_CREATURE(ptr);
crt->Phase(PHASE_DEL, newphase);
if (crt->m_spawn)
crt->m_spawn->phase &= ~newphase;
if (Save)
{
crt->SaveToDB();
crt->m_loadedFromDB = true;
}
break;
case TYPEID_PLAYER:
p_target = TO_PLAYER(ptr);
p_target->Phase(PHASE_DEL, newphase);
if( p_target->GetSession() )
{
WorldPacket data(SMSG_SET_PHASE_SHIFT, 4);
data << p_target->m_phase;
p_target->GetSession()->SendPacket(&data);
}
break;
default:
break;
}
return 0;
}
int GetPhase(lua_State * L, Unit * ptr)
{
if (!ptr) return 0;
lua_pushnumber(L,ptr->m_phase);
return 1;
}
int SendChatMessage(lua_State * L, Unit * ptr)
{
TEST_UNIT()
uint32 typ = CHECK_ULONG(L,1);
uint32 lang = CHECK_ULONG(L,2);
const char * message = luaL_checklstring(L, 3, NULL);
if(message == NULL)
return 0;
ptr->SendChatMessage(typ, lang, message);
return 0;
}
int PlayerSendChatMessage(lua_State * L, Unit * ptr)
{
TEST_PLAYER()
uint32 type = CHECK_ULONG(L,1);
uint32 lang = CHECK_ULONG(L,2);
const char * msg = luaL_checklstring(L, 3, NULL);
Player * plr = TO_PLAYER(ptr);
if(msg == NULL || !plr)
return 0;
WorldPacket *data = sChatHandler.FillMessageData( type, lang, msg, plr->GetGUID(), 0 );
plr->GetSession()->SendChatPacket(data, 1, lang, plr->GetSession());
for(set< Object* >::iterator itr = plr->GetInRangePlayerSetBegin(); itr != plr->GetInRangePlayerSetEnd(); ++itr)
{
(static_cast< Player* >(*itr))->GetSession()->SendChatPacket(data, 1, lang, plr->GetSession());
}
return 0;
}
int AggroWithInRangeFriends(lua_State * L, Unit * ptr)
{
TEST_UNIT()
// If Pointer isn't in combat skip everything
if (!ptr->CombatStatus.IsInCombat())
return 0;
Unit * pTarget = ptr->GetAIInterface()->GetNextTarget();
if (!pTarget)
return 0;
Unit * pUnit = NULL;
for(set<Object*>::iterator itr = ptr->GetInRangeSetBegin(); itr != ptr->GetInRangeSetEnd(); ++itr)
{
Object * obj = TO_OBJECT(*itr);
// No Object, Object Isn't a Unit, Unit is Dead
if (!obj || !obj->IsUnit() || TO_UNIT(obj)->IsDead())
continue;
if (!isFriendly(obj, ptr))
continue;
if (ptr->GetDistance2dSq(obj) > 10*10) // 10yrd range?
continue;
pUnit = TO_UNIT(obj);
if (!pUnit) // Should never happen!
continue;
pUnit->GetAIInterface()->SetNextTarget(pTarget);
pUnit->GetAIInterface()->AttackReaction(pTarget, 1, 0);
}
return 0;
}
int MoveTo(lua_State * L, Unit * ptr)
{
TEST_UNIT()
float x = CHECK_FLOAT(L, 1);
float y = CHECK_FLOAT(L, 2);
float z = CHECK_FLOAT(L, 3);
float o = CHECK_FLOAT(L, 4);
ptr->GetAIInterface()->MoveTo(x, y, z, o );
return 0;
}
int MoveRandomArea(lua_State * L, Unit * ptr)
{
TEST_UNIT()
float x1 = CHECK_FLOAT(L, 1);
float y1 = CHECK_FLOAT(L, 2);
float z1 = CHECK_FLOAT(L, 3);
float x2 = CHECK_FLOAT(L, 4);
float y2 = CHECK_FLOAT(L, 5);
float z2 = CHECK_FLOAT(L, 6);
float o2 = CHECK_FLOAT(L, 7);
ptr->GetAIInterface()->MoveTo( x1+(RandomFloat(x2-x1)), y1+(RandomFloat(y2-y1)), z1+(RandomFloat(z2-z1)), o2 );
return 0;
}
int SetMovementType(lua_State * L, Unit * ptr)
{
TEST_UNIT()
uint32 typ = CHECK_ULONG(L,1);
ptr->GetAIInterface()->setMoveType(typ);
return 0;
}
int GetX(lua_State * L, Unit * ptr)
{
if(ptr != NULL)
lua_pushnumber(L, ptr->GetPositionX());
else
lua_pushnil(L);
return 1;
}
int GetY(lua_State * L, Unit * ptr)
{
if(ptr != NULL)
lua_pushnumber(L, ptr->GetPositionY());
else
lua_pushnil(L);
return 1;
}
int GetZ(lua_State * L, Unit * ptr)
{
if(ptr != NULL)
lua_pushnumber(L, ptr->GetPositionZ());
else
lua_pushnil(L);
return 1;
}
int GetO(lua_State * L, Unit * ptr)
{
if(ptr != NULL)
lua_pushnumber(L, ptr->GetOrientation());
else
lua_pushnil(L);
return 1;
}
int CastSpell(lua_State * L, Unit * ptr)
{
uint32 sp = CHECK_ULONG(L,1);
if (sp && ptr)
ptr->CastSpell(ptr,dbcSpell.LookupEntry(sp),true);
return 0;
}
int FullCastSpell(lua_State * L, Unit * ptr)
{
uint32 sp = CHECK_ULONG(L,1);
if (sp && ptr)
ptr->CastSpell(ptr,dbcSpell.LookupEntry(sp),false);
return 0;
}
int FullCastSpellOnTarget(lua_State * L, Unit * ptr)
{
if(ptr != NULL)
{
uint32 sp = CHECK_ULONG(L,1);
Object * target = CHECK_OBJECT(L,2);
if(sp && target != NULL)
ptr->CastSpell(target->GetGUID(),sp,false);
}
return 0;
}
int CastSpellOnTarget(lua_State * L, Unit * ptr)
{
uint32 sp = CHECK_ULONG(L,1);
Object * target = CHECK_OBJECT(L,2);
if(ptr != NULL && sp && target != NULL)
ptr->CastSpell(target->GetGUID(),sp,true);
return 0;
}
int SpawnCreature(lua_State * L, Unit * ptr)
{
if(ptr == NULL) return 0;
uint32 entry = CHECK_ULONG(L,1);
float x = CHECK_FLOAT(L, 2);
float y = CHECK_FLOAT(L, 3);
float z = CHECK_FLOAT(L, 4);
float o = CHECK_FLOAT(L, 5);
uint32 faction = CHECK_ULONG(L,6);
uint32 duration = CHECK_ULONG(L,7);
uint32 equip1 = luaL_optint(L, 8, 1);
uint32 equip2 = luaL_optint(L, 9, 1);
uint32 equip3 = luaL_optint(L, 10, 1);
uint32 phase = luaL_optint(L, 11, ptr->m_phase);
bool save = luaL_optint(L, 12, 0) ? true : false;
if(!entry)
{
lua_pushnil(L);
return 1;
}
CreatureProto *p = CreatureProtoStorage.LookupEntry(entry);
CreatureInfo *i = CreatureNameStorage.LookupEntry(entry);
if(p == NULL || i == NULL) {
lua_pushnil(L);
return 1;
}
CreatureSpawn * sp = new CreatureSpawn;
uint32 gender = i->GenerateModelId(&sp->displayid);
sp->entry = entry;
sp->form = 0;
sp->id = objmgr.GenerateCreatureSpawnID();
sp->movetype = 0;
sp->x = x;
sp->y = y;
sp->z = z;
sp->o = o;
sp->emote_state = 0;
sp->flags = 0;
sp->factionid = faction;
sp->bytes0 = sp->setbyte(0,2,gender);
sp->bytes1 = 0;
sp->bytes2 = 0;
sp->stand_state = 0;
sp->death_state = 0;
sp->channel_target_creature = sp->channel_target_go = sp->channel_spell = 0;
sp->MountedDisplayID = 0;
sp->Item1SlotDisplay = equip1;
sp->Item2SlotDisplay = equip2;
sp->Item3SlotDisplay = equip3;
sp->CanFly = 0;
sp->phase = phase;
Creature * pCreature = ptr->GetMapMgr()->CreateCreature(entry);
if(pCreature == NULL)
{
lua_pushnil(L);
return 1;
}
pCreature->Load(sp, (uint32)NULL, NULL);
pCreature->m_loadedFromDB = true;
pCreature->SetFaction(faction);
pCreature->SetInstanceID(ptr->GetInstanceID());
pCreature->SetMapId(ptr->GetMapId());
pCreature->SetEquippedItem(MELEE,equip1);
pCreature->SetEquippedItem(OFFHAND,equip2);
pCreature->SetEquippedItem(RANGED,equip3);
pCreature->m_noRespawn = true;
pCreature->PushToWorld(ptr->GetMapMgr());
if (duration)
pCreature->Despawn(duration,0);
if (save)
pCreature->SaveToDB();
PUSH_UNIT(L,pCreature);
return 1;
}
int SpawnGameObject(lua_State * L, Unit * ptr)
{
if (ptr == NULL) return 0;
uint32 entry_id = CHECK_ULONG(L,1);
float x = CHECK_FLOAT(L, 2);
float y = CHECK_FLOAT(L, 3);
float z = CHECK_FLOAT(L, 4);
float o = CHECK_FLOAT(L, 5);
uint32 duration = CHECK_ULONG(L, 6);
float scale = (float)(luaL_optint(L, 7, 100) / 100.0f);
uint32 phase = luaL_optint(L, 8, ptr->m_phase);
bool save = luaL_optint(L, 9, 0) ? true : false;
if (entry_id)
{
GameObject *go = ptr->GetMapMgr()->CreateGameObject(entry_id);
uint32 mapid = ptr->GetMapId();
go->SetInstanceID(ptr->GetInstanceID());
go->CreateFromProto(entry_id,mapid,x,y,z,o);
go->Phase(PHASE_SET, phase);
go->SetScale(scale);
// Create spawn instance
GOSpawn * gs = new GOSpawn;
gs->entry = go->GetEntry();
gs->facing = go->GetOrientation();
gs->faction = go->GetFaction();
gs->flags = go->GetUInt32Value(GAMEOBJECT_FLAGS);
gs->id = objmgr.GenerateGameObjectSpawnID();
gs->o = 0.0f;
gs->o1 = go->GetParentRotation(0);
gs->o2 = go->GetParentRotation(2);
gs->o3 = go->GetParentRotation(3);
gs->scale = go->GetScale();
gs->x = go->GetPositionX();
gs->y = go->GetPositionY();
gs->z = go->GetPositionZ();
gs->state = go->GetByte(GAMEOBJECT_BYTES_1, 0);
//gs->stateNpcLink = 0;
gs->phase = go->GetPhase();
go->m_spawn = gs;
go->PushToWorld(ptr->GetMapMgr());
if (duration)
sEventMgr.AddEvent(go,&GameObject::ExpireAndDelete,EVENT_GAMEOBJECT_UPDATE,duration,1,EVENT_FLAG_DO_NOT_EXECUTE_IN_WORLD_CONTEXT);
if (save)
go->SaveToDB();
PUSH_GO(L,go);
}
else
lua_pushnil(L);
return 1;
}
int RegisterEvent(lua_State * L, Unit * ptr)
{
TEST_UNIT();
const char * typeName = luaL_typename(L,1);
int delay=luaL_checkint(L,2);
int repeats=luaL_checkint(L,3);
if(!delay) return 0;
lua_settop(L,1);
int functionRef = 0;
if(!strcmp(typeName,"function") )
functionRef = lua_ref(L,true);
else if(!strcmp(typeName,"string"))
functionRef = ExtractfRefFromCString(L,luaL_checkstring(L,1));
if(functionRef)
{
Creature * creature = TO_CREATURE(ptr);
sEventMgr.AddEvent(creature,&Creature::TriggerScriptEvent, functionRef, EVENT_LUA_CREATURE_EVENTS, delay, repeats, EVENT_FLAG_DO_NOT_EXECUTE_IN_WORLD_CONTEXT);
std::map< uint64,std::set<int> > & objRefs = sLuaMgr.getObjectFunctionRefs();
std::map< uint64,std::set<int> >::iterator itr = objRefs.find(ptr->GetGUID());
if(itr == objRefs.end() )
{
std::set<int> refs;
refs.insert(functionRef);
objRefs.insert(make_pair(ptr->GetGUID(),refs));
}
else
{
std::set<int> & refs = itr->second;
refs.insert(functionRef);
}
}
return 0;
}
/* This one just simply calls the function directly w/o any arguments,
the trick to arguments is done Lua side through closures(function that
calls the wanted function with the wanted arguments */
int CreateLuaEvent(lua_State * L, Unit * ptr)
{
TEST_UNITPLAYER_RET();
const char * typeName = luaL_typename(L,1);
int delay=luaL_checkint(L,2);
int repeats=luaL_checkint(L,3);
if(!delay) return 0;
lua_settop(L,1);
int functionRef = 0;
if(!strcmp(typeName,"function") )
functionRef = lua_ref(L,true);
else if(!strcmp(typeName,"string"))
functionRef = ExtractfRefFromCString(L,luaL_checkstring(L,1));
if(functionRef)
{
TimedEvent * ev = TimedEvent::Allocate(ptr,new CallbackP1<LuaEngine,int>(&sLuaMgr,&LuaEngine::CallFunctionByReference,functionRef),EVENT_LUA_CREATURE_EVENTS,delay,repeats);
ptr->event_AddEvent(ev);
std::map< uint64,std::set<int> > & objRefs = sLuaMgr.getObjectFunctionRefs();
std::map< uint64,std::set<int> >::iterator itr = objRefs.find(ptr->GetGUID());
if(itr == objRefs.end() )
{
std::set<int> refs;
refs.insert(functionRef);
objRefs.insert(make_pair(ptr->GetGUID(),refs));
}
else
{
std::set<int> & refs = itr->second;
refs.insert(functionRef);
}
}
return 0;
}
int RemoveEvents(lua_State * L, Unit * ptr)
{
TEST_UNITPLAYER();
sEventMgr.RemoveEvents(ptr,EVENT_LUA_CREATURE_EVENTS);
//Unref all contained references
std::map< uint64,std::set<int> > & objRefs = sLuaMgr.getObjectFunctionRefs();
std::map< uint64,std::set<int> >::iterator itr = objRefs.find(ptr->GetGUID());
if(itr != objRefs.end() )
{
std::set<int> & refs = itr->second;
for(std::set<int>::iterator it = refs.begin(); it != refs.end(); ++it)
lua_unref(L,(*it));
refs.clear();
}
return 0;
}
int SetFaction(lua_State * L, Unit * ptr)
{
TEST_UNITPLAYER()
int faction = luaL_checkint(L,1);
if(!faction)
return 0;
ptr->SetFaction(faction);
return 0;
}
int GetNativeFaction(lua_State * L, Unit * ptr)
{
TEST_UNITPLAYER_RET()
if (ptr->IsPlayer())
{
RET_INT(TO_PLAYER(ptr)->GetInitialFactionId());
}
else
{
if (TO_CREATURE(ptr)->GetProto())
{
RET_INT(TO_CREATURE(ptr)->GetProto()->Faction);
}
else
{
RET_INT(ptr->GetFaction());
}
}
}
int SetStandState(lua_State * L, Unit * ptr) //states 0..8
{
if (!ptr)
return 0;
int state = luaL_checkint(L,1);
if (state < 0)
return 0;
ptr->SetStandState(state);
return 0;
}
int IsInCombat(lua_State * L, Unit * ptr)
{
if(ptr == NULL || !ptr->IsInWorld() )
RET_NIL()
if(ptr->CombatStatus.IsInCombat())
lua_pushboolean(L, 1);
else
lua_pushboolean(L, 0);
return 1;
}
int SetScale(lua_State * L, Unit * ptr)
{
float scale = CHECK_FLOAT(L,1);
if (scale && ptr)
ptr->SetFloatValue(OBJECT_FIELD_SCALE_X,(float)scale);
else
RET_BOOL(false)
RET_BOOL(true)
}
int SetModel(lua_State * L, Unit * ptr)
{
uint32 model = CHECK_ULONG(L,1);
if(ptr != NULL)
ptr->SetDisplayId(model);
else
RET_BOOL(false)
RET_BOOL(true)
}
int SetNPCFlags(lua_State * L, Unit * ptr)
{
TEST_UNIT()
int flags = luaL_checkint(L,1);
if (flags && ptr)
ptr->SetUInt32Value(UNIT_NPC_FLAGS,flags);
return 0;
}
int SetMount(lua_State * L, Unit * ptr)
{
if (!ptr) return 0;
uint32 DsplId = CHECK_ULONG(L, 1);
ptr->SetMount(DsplId);
return 0;
}
int DestroyCustomWaypointMap(lua_State * L, Unit * ptr)
{
TEST_UNIT()
TO_CREATURE(ptr)->DestroyCustomWaypointMap();
return 0;
}
int CreateCustomWaypointMap(lua_State * L, Unit * ptr)
{
TEST_UNIT()
Creature * pCreature = TO_CREATURE(ptr);
if(pCreature->m_custom_waypoint_map)
{
for(WayPointMap::iterator itr = pCreature->m_custom_waypoint_map->begin(); itr != pCreature->m_custom_waypoint_map->end(); ++itr)
delete (*itr);
delete pCreature->m_custom_waypoint_map;
}
pCreature->m_custom_waypoint_map = new WayPointMap;
pCreature->GetAIInterface()->SetWaypointMap(pCreature->m_custom_waypoint_map);
return 0;
}
int CreateWaypoint(lua_State * L, Unit * ptr)
{
TEST_UNIT()
float x = CHECK_FLOAT(L,1);
float y = CHECK_FLOAT(L,2);
float z = CHECK_FLOAT(L,3);
float o = CHECK_FLOAT(L,4);
int waittime = luaL_checkint(L,5);
int flags = luaL_checkint(L,6);
int modelid = luaL_checkint(L,7);
Creature * pCreature = TO_CREATURE(ptr);
if(!pCreature->m_custom_waypoint_map)
{
pCreature->m_custom_waypoint_map = new WayPointMap;
pCreature->GetAIInterface()->SetWaypointMap(pCreature->m_custom_waypoint_map);
}
if(!modelid)
modelid = pCreature->GetDisplayId();
WayPoint * wp = new WayPoint;
wp->id = (uint32)pCreature->m_custom_waypoint_map->size() + 1;
wp->x = x;
wp->y = y;
wp->z = z;
wp->o = o;
wp->flags = flags;
wp->backwardskinid = modelid;
wp->forwardskinid = modelid;
wp->backwardemoteid = wp->forwardemoteid = 0;
wp->backwardemoteoneshot = wp->forwardemoteoneshot = false;
wp->waittime = waittime;
pCreature->m_custom_waypoint_map->push_back(wp);
pCreature->GetAIInterface()->addWayPoint(wp);
return 0;
}
int CreateCustomWaypoint(lua_State * L, Unit * ptr)
{
Creature * crc = NULL;
if(ptr != NULL && ptr->IsCreature() )
crc = TO_CREATURE(ptr);
if(crc != NULL)
{
uint32 id = CHECK_ULONG(L,1);
float x = CHECK_FLOAT(L,2);
float y = CHECK_FLOAT(L,3);
float z = CHECK_FLOAT(L,4);
float o = CHECK_FLOAT(L,5);
uint32 waitime = CHECK_ULONG(L,6);
uint32 flags = CHECK_ULONG(L,7);
uint32 model = luaL_optint(L,8,0);
WayPoint * wp = new WayPoint;
wp->id = id;
wp->x = x;
wp->y = y;
wp->z = z;
wp->o = o;
wp->waittime = waitime;
wp->flags = flags;
wp->backwardskinid = model;
wp->forwardskinid = model;
crc->GetAIInterface()->addWayPoint(wp);
}
return 0;
}
int DeleteAllWaypoints(lua_State * L, Unit * ptr)
{
Creature * crc = NULL;
if(ptr != NULL && ptr->IsCreature() )
crc = TO_CREATURE(ptr);
crc->GetAIInterface()->deleteWaypoints();
return 0;
}
int MoveToWaypoint(lua_State * L, Unit * ptr)
{
TEST_UNIT()
int id = luaL_checkint(L,1);
if (id)
{
ptr->GetAIInterface()->setMoveType(MOVEMENTTYPE_WANTEDWP);
ptr->GetAIInterface()->setWaypointToMove(id);
}
return 0;
}
int RemoveItem(lua_State * L, Unit * ptr)
{
TEST_PLAYER()
int id = luaL_checkint(L,1);
int count = luaL_checkint(L,2);
TO_PLAYER(ptr)->GetItemInterface()->RemoveItemAmt(id,count);
return 0;
}
int AddItem(lua_State * L, Unit * ptr)
{
TEST_PLAYER()
int id = luaL_checkint(L,1);
int count = luaL_checkint(L,2);
Player * plr = TO_PLAYER(ptr);
ItemPrototype * proto = ItemPrototypeStorage.LookupEntry(id);
if (proto==NULL)
return 0;
Item * add = plr->GetItemInterface()->FindItemLessMax(id,count,false);
if (add==NULL)
{
add=objmgr.CreateItem(id,plr);
add->SetStackCount(count);
if(plr->GetItemInterface()->AddItemToFreeSlot(add))
plr->SendItemPushResult(false, true, false, true, plr->GetItemInterface()->LastSearchItemBagSlot(),
plr->GetItemInterface()->LastSearchItemSlot(), count, add->GetEntry(), add->GetItemRandomSuffixFactor(),
add->GetItemRandomPropertyId(), add->GetStackCount() );
else
delete add;
}
else
{
add->ModStackCount(count);
plr->SendItemPushResult(false, true, false, false,
static_cast<uint8>(plr->GetItemInterface()->GetBagSlotByGuid( add->GetGUID() )), 0xFFFFFFFF,
count , add->GetEntry(), add->GetItemRandomSuffixFactor(), add->GetItemRandomPropertyId(), add->GetStackCount() );
}
PUSH_ITEM(L,add);
return 1;
}
int GetInstanceID(lua_State * L, Unit * ptr)
{
//TEST_UNIT()
if(!ptr || ptr->GetMapMgr() == NULL || ptr->GetMapMgr()->GetMapInfo()->type == INSTANCE_NULL )
lua_pushnil(L);
else
lua_pushinteger(L,ptr->GetInstanceID());
return 1;
}
int GetClosestPlayer(lua_State * L, Unit * ptr)
{
if(!ptr)
return 0;
float dist=0;
float d2=0;
Player * ret=NULL;
for(set< Object* >::iterator itr = ptr->GetInRangePlayerSetBegin(); itr != ptr->GetInRangePlayerSetEnd(); ++itr)
{
d2=(*itr)->GetDistanceSq(ptr);
if(!ret||d2<dist)
{
dist=d2;
ret=TO_PLAYER(*itr);
}
}
if(ret==NULL)
lua_pushnil(L);
else
PUSH_UNIT(L,ret);
return 1;
}
int GetRandomPlayer(lua_State * L, Unit * ptr)
{
if( ptr == NULL )
return 0;
int flag = luaL_checkint( L, 1 );
Player* ret = NULL;
vector<Player*> players;
switch( flag )
{
case RANDOM_ANY:
{
uint32 count = (uint32)ptr->GetInRangePlayersCount();
uint32 r = RandomUInt(count-1);
count=0;
for(set< Object* >::iterator itr = ptr->GetInRangePlayerSetBegin(); itr != ptr->GetInRangePlayerSetEnd(); ++itr)
{
if (count==r)
{
ret= TO_PLAYER(*itr);
break;
}
++count;
}
}
break;
case RANDOM_IN_SHORTRANGE:
{
for(set< Object* >::iterator itr = ptr->GetInRangePlayerSetBegin(); itr != ptr->GetInRangePlayerSetEnd(); ++itr)
{
Player* obj = TO_PLAYER(*itr);
if (obj && obj->CalcDistance(obj,ptr)<=8)
players.push_back(obj);
}
if(players.size())
ret = players[RandomUInt(players.size()-1)];
}
break;
case RANDOM_IN_MIDRANGE:
{
for(set< Object* >::iterator itr = ptr->GetInRangePlayerSetBegin(); itr != ptr->GetInRangePlayerSetEnd(); ++itr)
{
Player* obj = TO_PLAYER(*itr);
float distance = obj->CalcDistance(obj,ptr);
if (distance<20 && distance>8)
players.push_back(obj);
}
if(players.size())
ret = players[RandomUInt(players.size()-1)];
}
break;
case RANDOM_IN_LONGRANGE:
{
for(set< Object* >::iterator itr = ptr->GetInRangePlayerSetBegin(); itr != ptr->GetInRangePlayerSetEnd(); ++itr)
{
Player* obj = TO_PLAYER(*itr);
if (obj && obj->CalcDistance(obj,ptr)>=20)
players.push_back(obj);
}
if(players.size())
ret = players[RandomUInt(players.size()-1)];
}
break;
case RANDOM_WITH_MANA:
{
for(set< Object* >::iterator itr = ptr->GetInRangePlayerSetBegin(); itr != ptr->GetInRangePlayerSetEnd(); ++itr)
{
Player* obj = TO_PLAYER(*itr);
if (obj && obj->GetPowerType() == POWER_TYPE_MANA)
players.push_back(obj);
}
if(players.size())
ret = players[RandomUInt(players.size()-1)];
}
break;
case RANDOM_WITH_ENERGY:
{
for(set< Object* >::iterator itr = ptr->GetInRangePlayerSetBegin(); itr != ptr->GetInRangePlayerSetEnd(); ++itr)
{
Player* obj = TO_PLAYER(*itr);
if (obj && obj->GetPowerType() == POWER_TYPE_ENERGY)
players.push_back(obj);
}
if(players.size())
ret = players[RandomUInt(players.size()-1)];
}
break;
case RANDOM_WITH_RAGE:
{
for(set< Object* >::iterator itr = ptr->GetInRangePlayerSetBegin(); itr != ptr->GetInRangePlayerSetEnd(); ++itr)
{
Player* obj = TO_PLAYER(*itr);
if (obj && obj->GetPowerType() == POWER_TYPE_RAGE)
players.push_back(obj);
}
if(players.size())
ret = players[RandomUInt(players.size()-1)];
}
break;
case RANDOM_NOT_MAINTANK:
{
uint32 count = 0;
Unit* mt = ptr->GetAIInterface()->GetMostHated();
if (mt == NULL || !mt->IsPlayer())
return 0;
for(set< Object* >::iterator itr = ptr->GetInRangePlayerSetBegin(); itr != ptr->GetInRangePlayerSetEnd(); ++itr)
{
Player* obj = TO_PLAYER(*itr);
if (obj != mt)
players.push_back(obj);
}
if(players.size() )
ret = players[RandomUInt(players.size()-1)];
}
break;
}
if(ret==NULL)
lua_pushnil(L);
else
PUSH_UNIT(L,ret);
return 1;
}
int GetRandomFriend(lua_State * L, Unit * ptr)
{
TEST_UNITPLAYER();
Unit * ret=NULL;
uint32 count = 0;
vector<Object*> allies;
for(set<Object*>::iterator itr = ptr->GetInRangeSetBegin(); itr != ptr->GetInRangeSetEnd(); ++itr)
{
Object* obj = TO_OBJECT(*itr);
if (obj->IsUnit() && isFriendly(obj,ptr))
allies.push_back(obj);
}
if(allies.size() )
PUSH_UNIT(L,allies[RandomUInt(allies.size()-1)]);
else
lua_pushnil(L);
return 1;
}
int GetRandomEnemy(lua_State * L, Unit * ptr)
{
TEST_UNITPLAYER();
Unit * ret=NULL;
uint32 count = 0;
vector<Object*> enemies;
for(set<Object*>::iterator itr = ptr->GetInRangeSetBegin(); itr != ptr->GetInRangeSetEnd(); ++itr)
{
Object* obj = TO_OBJECT(*itr);
if (obj->IsUnit() && isHostile(ptr,obj) )
enemies.push_back(obj);
}
if(enemies.size())
PUSH_UNIT(L,enemies[RandomUInt(enemies.size()-1)]);
else
lua_pushnil(L);
return 1;
}
int StopMovement(lua_State * L, Unit * ptr)
{
TEST_UNIT()
int tim = luaL_checkint(L,1);
ptr->GetAIInterface()->StopMovement(tim);
return 0;
}
int RemoveAura(lua_State * L, Unit * ptr)
{
TEST_UNITPLAYER()
int auraid = luaL_checkint(L,1);
ptr->RemoveAura(auraid);
return 0;
}
int CanAttack(lua_State * L, Unit * ptr)
{
TEST_UNITPLAYER_RET();
Unit * target = CHECK_UNIT(L,1);
if (!target) return 0;
if (isAttackable(ptr, target))
lua_pushboolean(L, 1);
else
lua_pushboolean(L, 0);
return 1;
}
int PlaySoundToSet(lua_State * L, Unit * ptr)
{
TEST_UNITPLAYER();
int soundid = luaL_checkint(L,1);
ptr->PlaySoundToSet(soundid);
return 0;
}
int PlaySoundToPlayer(lua_State * L, Unit * ptr)
{
TEST_PLAYER();
int soundid = luaL_checkint(L,1);
Player* plr = TO_PLAYER(ptr);
WorldPacket data;
data.Initialize(SMSG_PLAY_OBJECT_SOUND);
data << uint32(soundid) << plr->GetGUID();
plr->GetSession()->SendPacket(&data);
return 0;
}
int GetUnitBySqlId(lua_State * L, Unit * ptr)
{
int sqlid = luaL_checkint(L,1);
if(!ptr || !sqlid)
return 0;
PUSH_UNIT(L,ptr->GetMapMgr()->GetSqlIdCreature(sqlid));
return 1;
}
int GetInventoryItem(lua_State * L, Unit * ptr)
{
TEST_PLAYER()
int8 containerslot = luaL_checkint(L, 1);
int16 slot = luaL_checkint(L, 2);
Player * plr = TO_PLAYER(ptr);
PUSH_ITEM(L, plr->GetItemInterface()->GetInventoryItem(containerslot, slot));
return 1;
}
int GetInventoryItemById(lua_State * L, Unit * ptr)
{
TEST_PLAYER()
uint32 entry = CHECK_ULONG(L, 1);
Player * plr = TO_PLAYER(ptr);
int16 slot = plr->GetItemInterface()->GetInventorySlotById(entry);
if (slot == -1) //check bags
{
for (uint8 contslot = INVENTORY_SLOT_BAG_START; contslot != INVENTORY_SLOT_BAG_END; contslot++)
{
Container * bag = static_cast<Container*>(plr->GetItemInterface()->GetInventoryItem(contslot));
for (uint8 bslot = 0; bslot != bag->GetNumSlots(); bslot++)
{
if (bag->GetItem(bslot) && bag->GetItem(bslot)->GetEntry() == entry)
{
PUSH_ITEM(L, bag->GetItem(bslot));
return 1;
}
}
}
}
PUSH_ITEM(L, plr->GetItemInterface()->GetInventoryItem(slot));
return 1;
}
int SetZoneWeather(lua_State * L, Unit * ptr)
{
/*
WEATHER_TYPE_NORMAL = 0, // NORMAL (SUNNY)
WEATHER_TYPE_FOG = 1, // FOG
WEATHER_TYPE_RAIN = 2, // RAIN
WEATHER_TYPE_HEAVY_RAIN = 4, // HEAVY_RAIN
WEATHER_TYPE_SNOW = 8, // SNOW
WEATHER_TYPE_SANDSTORM = 16 // SANDSTORM
*/
uint32 zone_id = CHECK_ULONG(L, 1);
uint32 type = CHECK_ULONG(L, 2);
float Density = CHECK_FLOAT(L, 3); //min: 0.30 max: 2.00
if (Density<0.30f || Density>2.0f || !zone_id || !type)
return 0;
uint32 sound;
if(Density<=0.30f)
sound = 0;
switch(type)
{
case 2: //rain
case 4:
if(Density <0.40f)
sound = 8533;
else if(Density <0.70f)
sound = 8534;
else
sound = 8535;
break;
case 8: //snow
if(Density <0.40f)
sound = 8536;
else if(Density <0.70f)
sound = 8537;
else
sound = 8538;
break;
case 16: //storm
if(Density <0.40f)
sound = 8556;
else if(Density <0.70f)
sound = 8557;
else
sound = 8558;
break;
default: //no sound
sound = 0;
break;
}
WorldPacket data(SMSG_WEATHER, 9);
data.Initialize(SMSG_WEATHER);
if(type == 0 ) // set all parameter to 0 for sunny.
data << uint32(0) << float(0) << uint32(0) << uint8(0);
else if (type == 1) // No sound/density for fog
data << type << float(0) << uint32(0) << uint8(0);
else
data << type << Density << sound << uint8(0) ;
sWorld.SendZoneMessage(&data, zone_id, 0);
return 0;
}
int SetPlayerWeather(lua_State * L, Unit * ptr)
{
/*
WEATHER_TYPE_NORMAL = 0, // NORMAL (SUNNY)
WEATHER_TYPE_FOG = 1, // FOG
WEATHER_TYPE_RAIN = 2, // RAIN
WEATHER_TYPE_HEAVY_RAIN = 4, // HEAVY_RAIN
WEATHER_TYPE_SNOW = 8, // SNOW
WEATHER_TYPE_SANDSTORM = 16 // SANDSTORM
*/
TEST_PLAYER()
Player * plr = TO_PLAYER(ptr);
uint32 type = CHECK_ULONG(L, 1);
float Density = CHECK_FLOAT(L, 2); //min: 0.30 max: 2.00
if (Density<0.30f || Density>2.0f || !type)
return 0;
uint32 sound;
if(Density<=0.30f)
sound = 0;
switch(type)
{
case 2: //rain
case 4:
if(Density <0.40f)
sound = 8533;
else if(Density <0.70f)
sound = 8534;
else
sound = 8535;
break;
case 8: //snow
if(Density <0.40f)
sound = 8536;
else if(Density <0.70f)
sound = 8537;
else
sound = 8538;
break;
case 16: //storm
if(Density <0.40f)
sound = 8556;
else if(Density <0.70f)
sound = 8557;
else
sound = 8558;
break;
default: //no sound
sound = 0;
break;
}
WorldPacket data(SMSG_WEATHER, 9);
data.Initialize(SMSG_WEATHER);
if(type == 0 ) // set all parameter to 0 for sunny.
data << uint32(0) << float(0) << uint32(0) << uint8(0);
else if (type == 1) // No sound/density for fog
data << type << float(0) << uint32(0) << uint8(0);
else
data << type << Density << sound << uint8(0) ;
plr->GetSession()->SendPacket(&data);
return 0;
}
int Despawn(lua_State * L, Unit * ptr)
{
TEST_UNIT()
int delay = luaL_checkint(L,1);
int respawntime = luaL_checkint(L,2);
TO_CREATURE(ptr)->Despawn(delay,respawntime);
return 0;
}
int GetInRangeFriends(lua_State * L, Unit * ptr)
{
Object * pC = NULL;
uint32 count = 0;
lua_newtable(L);
for( set<Object*>::iterator itr = ptr->GetInRangeSetBegin(); itr != ptr->GetInRangeSetEnd(); itr++)
{
if( (*itr) ->IsUnit() && isFriendly(ptr, (*itr)) )
{
count++,
pC = *itr;
lua_pushinteger(L,count);
PUSH_UNIT(L,pC);
lua_rawset(L,-3);
}
}
return 1;
}
int GetInRangeEnemies(lua_State * L, Unit * ptr)
{
uint32 count = 0;
lua_newtable(L);
for( set<Object*>::iterator itr = ptr->GetInRangeSetBegin(); itr != ptr->GetInRangeSetEnd(); itr++)
{
if( (*itr) ->IsUnit() && !isFriendly(ptr, (*itr)) )
{
count++,
lua_pushinteger(L,count);
PUSH_UNIT(L,*itr);
lua_rawset(L,-3);
}
}
return 1;
}
int GetInRangeUnits(lua_State * L, Unit * ptr)
{
uint32 count = 0;
lua_newtable(L);
for( set<Object*>::iterator itr = ptr->GetInRangeSetBegin(); itr != ptr->GetInRangeSetEnd(); itr++)
{
if( (*itr) ->IsUnit() )
{
count++,
lua_pushinteger(L,count);
PUSH_UNIT(L,*itr);
lua_rawset(L,-3);
}
}
return 1;
}
int GetHealthPct(lua_State * L, Unit * ptr)
{
if(!ptr)
lua_pushinteger(L,0);
else
lua_pushinteger(L, ptr->GetHealthPct());
return 1;
}
int SetHealthPct(lua_State * L, Unit * ptr)
{
int val = luaL_checkint(L,1);
if (val && ptr)
ptr->SetHealthPct(val);
return 0;
}
int GetItemCount(lua_State * L, Unit * ptr)
{
TEST_PLAYER()
int itemid = luaL_checkint(L,1);
lua_pushinteger(L, TO_PLAYER(ptr)->GetItemInterface()->GetItemCount(itemid,false));
return 1;
}
int GetPrimaryCombatTarget(lua_State * L, Unit * ptr)
{//should use now instead of GetTarget
TEST_PLAYER()
if (!ptr->CombatStatus.IsInCombat())
{
lua_pushinteger(L, 0);
return 1;
}
else
PUSH_UNIT(L, ptr->GetMapMgr()->GetUnit(TO_PLAYER(ptr)->CombatStatus.GetPrimaryAttackTarget()));
return 1;
}
int GetMainTank(lua_State * L, Unit * ptr)
{
TEST_UNIT()
Unit* ret = ptr->GetAIInterface()->GetMostHated();
if (!ret)
lua_pushnil(L);
else
PUSH_UNIT(L,ret);
return 1;
}
int GetAddTank(lua_State * L, Unit * ptr)
{
TEST_UNIT()
Unit* ret = ptr->GetAIInterface()->GetSecondHated();
if(ret==NULL)
lua_pushnil(L);
else
PUSH_UNIT(L,ret);
return 1;
}
int ClearThreatList(lua_State * L, Unit * ptr)
{
TEST_UNIT()
ptr->ClearHateList();
return 0;
}
int GetTauntedBy(lua_State * L, Unit * ptr)
{
TEST_UNIT()
if (!ptr->GetAIInterface()->getTauntedBy())
lua_pushnil(L);
else
PUSH_UNIT(L,ptr->GetAIInterface()->getTauntedBy());
return 1;
}
int SetTauntedBy(lua_State * L, Unit * ptr)
{
TEST_UNIT()
Unit * target = CHECK_UNIT(L, 1);
if (!target || ptr->GetAIInterface()->GetIsTaunted() || target == ptr)
return 0;
else
ptr->GetAIInterface()->taunt(target);
return 0;
}
int ModThreat(lua_State * L, Unit * ptr)
{
Unit * target = CHECK_UNIT(L,1);
int32 amount = luaL_checkint(L,2);
if(ptr && target && amount)
ptr->GetAIInterface()->modThreatByPtr(target,amount);
return 0;
}
int GetThreatByPtr(lua_State * L, Unit * ptr)
{
Unit * target = CHECK_UNIT(L,1);
if(ptr && target)
lua_pushnumber(L,ptr->GetAIInterface()->getThreatByPtr(target));
return 1;
}
int GetSoulLinkedWith(lua_State * L, Unit * ptr)
{
TEST_UNIT()
if (!ptr->GetAIInterface()->GetIsSoulLinked())
lua_pushnil(L);
else
PUSH_UNIT(L,ptr->GetAIInterface()->getSoullinkedWith());
return 1;
}
int SetSoulLinkedWith(lua_State * L, Unit * ptr)
{
TEST_UNIT()
Unit * target = CHECK_UNIT(L, 1);
if (!target || ptr->GetAIInterface()->GetIsSoulLinked() || target == ptr)
return 0;
else
ptr->GetAIInterface()->SetSoulLinkedWith(ptr);
return 1;
}
int ChangeTarget(lua_State * L, Unit * ptr)
{
TEST_UNIT()
Unit * target = CHECK_UNIT(L, 1);
if (!target || !isHostile(ptr,target) || ptr == target)
return 0;
else
ptr->GetAIInterface()->SetNextTarget(target);
return 0;
}
int HasFinishedQuest(lua_State * L, Unit * ptr)
{
TEST_PLAYER_RET()
int questid = luaL_checkint(L,1);
if( TO_PLAYER(ptr)->HasFinishedQuest(questid) )
lua_pushboolean(L,1);
else
lua_pushboolean(L,0);
return 1;
}
int FinishQuest(lua_State * L, Unit * ptr)
{
TEST_PLAYER_RET()
int quest_id = luaL_checkint(L,1);
Player *plr = TO_PLAYER(ptr);
Quest * qst = QuestStorage.LookupEntry(quest_id);
if (qst)
{
if (plr->HasFinishedQuest(quest_id))
{
lua_pushnumber(L, 0);
return 1;
}
else
{
QuestLogEntry * IsPlrOnQuest = plr->GetQuestLogForEntry(quest_id);
if (IsPlrOnQuest)
{
sQuestMgr.GenerateQuestXP(plr, qst);
sQuestMgr.BuildQuestComplete(plr, qst);
IsPlrOnQuest->Finish();
plr->AddToFinishedQuests(quest_id);
lua_pushnumber(L, 1);
return 1;
}
else
{
lua_pushnumber(L, 2);
return 1;
}
}
}
else
return 0;
}
int StartQuest(lua_State * L, Unit * ptr)
{
TEST_PLAYER_RET()
int quest_id = luaL_checkint(L,1);
Player *plr = TO_PLAYER(ptr);
Quest * qst = QuestStorage.LookupEntry(quest_id);
if (qst)
{
if (plr->HasFinishedQuest(quest_id)) {
lua_pushnumber(L, 0);
return 1;
}
else
{
QuestLogEntry * IsPlrOnQuest = plr->GetQuestLogForEntry(quest_id);
if (IsPlrOnQuest)
{
lua_pushnumber(L, 1);
return 1;
}
else
{
int32 open_slot = plr->GetOpenQuestSlot();
if (open_slot == -1)
{
sQuestMgr.SendQuestLogFull(plr);
lua_pushnumber(L, 2);
return 1;
}
else
{
QuestLogEntry *qle = new QuestLogEntry();
qle->Init(qst, plr, (uint32)open_slot);
qle->UpdatePlayerFields();
// If the quest should give any items on begin, give them the items.
for(uint32 i = 0; i < 4; ++i)
{
if(qst->receive_items[i])
{
Item *item = objmgr.CreateItem( qst->receive_items[i], plr);
if(item==NULL)
return false;
if(!plr->GetItemInterface()->AddItemToFreeSlot(item))
item->DeleteMe();
}
}
if(qst->srcitem && qst->srcitem != qst->receive_items[0])
{
Item * item = objmgr.CreateItem( qst->srcitem, plr);
if(item)
{
item->SetStackCount( qst->srcitemcount ? qst->srcitemcount : 1);
if(!plr->GetItemInterface()->AddItemToFreeSlot(item))
item->DeleteMe();
}
}
//if(qst->count_required_item || qst_giver->GetTypeId() == TYPEID_GAMEOBJECT) // gameobject quests deactivate
// plr->UpdateNearbyGameObjects();
//ScriptSystem->OnQuestEvent(qst, static_cast< Creature* >( qst_giver ), _player, QUEST_EVENT_ON_ACCEPT);
sHookInterface.OnQuestAccept( plr, qst, NULL );
lua_pushnumber(L, 3);
return 1;
}
}
}
}
else
{
return 0;
}
lua_pushnumber(L, 999);
return 1;
} //StartQuest
int UnlearnSpell(lua_State * L, Unit * ptr)
{
TEST_PLAYER()
int spellid = luaL_checkint(L,1);
TO_PLAYER(ptr)->removeSpell(spellid,false,false,0);
return 0;
}
int LearnSpell(lua_State * L, Unit* ptr)
{
TEST_PLAYER()
int spellid = luaL_checkint(L,1);
TO_PLAYER(ptr)->addSpell(spellid);
return 0;
}
int LearnSpells(lua_State * L, Unit * ptr)
{
TEST_PLAYER_RET()
if(!strcmp("table",luaL_typename(L,1)) )
{
int table = lua_gettop(L);
lua_pushnil(L);
while(lua_next(L,table) != 0)
{
if(lua_isnumber(L,-1) )
TO_PLAYER(ptr)->addSpell(CHECK_ULONG(L,-1));
lua_pop(L,1);
}
lua_pushboolean(L,1);
lua_replace(L,table);
lua_settop(L,table); // Paroxysm: The stack should be balanced but just in case.
}
else
{
lua_settop(L,0);
lua_pushboolean(L,0);
}
return 1;
}
int MarkQuestObjectiveAsComplete(lua_State * L, Unit * ptr)
{
TEST_PLAYER()
int questid = luaL_checkint(L,1);
int objective = luaL_checkint(L,2);
Player * pl = TO_PLAYER(ptr);
if (!pl->HasFinishedQuest(questid))
{
QuestLogEntry * qle = pl->GetQuestLogForEntry(questid);
qle->SetMobCount(objective, qle->GetQuest()->required_mobcount[objective]);
qle->SendUpdateAddKill(objective);
if (qle->CanBeFinished())
{
qle->SendQuestComplete();
qle->UpdatePlayerFields();
}
}
return 0;
}
int SendAreaTriggerMessage(lua_State * L, Unit * ptr)
{
TEST_PLAYER()
const char * msg = luaL_checkstring(L,1);
if (!msg) return 0;
TO_PLAYER(ptr)->SendAreaTriggerMessage(msg);
return 0;
}
int SendBroadcastMessage(lua_State * L, Unit * ptr)
{
TEST_PLAYER()
const char * msg = luaL_checkstring(L,1);
if (!msg) return 0;
TO_PLAYER(ptr)->BroadcastMessage(msg);
return 0;
}
int TeleportUnit(lua_State * L, Unit * ptr)
{
TEST_PLAYER()
uint32 mapId = CHECK_ULONG(L, 1);
float posX = CHECK_FLOAT(L, 2);
float posY = CHECK_FLOAT(L, 3);
float posZ = CHECK_FLOAT(L, 4);
float Orientation = CHECK_FLOAT(L,5);
if(!posX || !posY || !posZ || !mapId)
{
if (mapId)
{
Log.Notice("LuaEngineMgr", "LUATeleporter ERROR - Wrong Coordinates given (Map, X, Y, Z) :: Map%f%s%f%s%f%s%u", mapId, " X", posX, " Y", posY, " Z", posZ);
return 0;
}
else
mapId = 0; //MapId is false reported as empty if you use Eastern Kingdoms (0) So lets override it IF it is reported as empty.
}
LocationVector vec(posX,posY,posZ,Orientation);
TO_PLAYER(ptr)->SafeTeleport(mapId,0,vec);
return 0;
}
int GetHealth(lua_State * L, Unit * ptr)
{
if (!ptr)
lua_pushinteger( L, 0 );
else
lua_pushinteger( L, ptr->GetUInt32Value( UNIT_FIELD_HEALTH ) );
return 1;
}
int GetMaxHealth(lua_State * L, Unit * ptr)
{
if (!ptr)
lua_pushinteger( L, 0 );
else
lua_pushinteger( L, ptr->GetUInt32Value( UNIT_FIELD_MAXHEALTH ) );
return 1;
}
int SetHealth(lua_State * L, Unit * ptr)
{
int val = luaL_checkint( L, 1 );
if( ptr != NULL && val > 0 )
{
if( (uint32)val > ptr->GetUInt32Value( UNIT_FIELD_MAXHEALTH ) )
ptr->SetHealth(ptr->GetUInt32Value( UNIT_FIELD_MAXHEALTH ) );
else
ptr->SetHealth(val );
}
return 0;
}
int SetMaxHealth(lua_State * L, Unit * ptr)
{
int val = luaL_checkint( L, 1 );
if( ptr != NULL && val > 0 )
{
if( (uint32)val < ptr->GetUInt32Value( UNIT_FIELD_HEALTH ) )
ptr->SetHealth(val );
ptr->SetUInt32Value( UNIT_FIELD_MAXHEALTH, val );
}
return 0;
}
int WipeHateList(lua_State * L, Unit * ptr)
{
TEST_UNIT()
ptr->WipeHateList();
ptr->GetAIInterface()->WipeHateList();
return 0;
}
int WipeTargetList(lua_State * L, Unit * ptr)
{
TEST_UNIT()
ptr->GetAIInterface()->WipeTargetList();
return 0;
}
int WipeCurrentTarget(lua_State * L, Unit * ptr)
{
TEST_UNIT()
ptr->GetAIInterface()->WipeCurrentTarget();
return 0;
}
int GetPlayerClass(lua_State * L, Unit * ptr)
{
if(!ptr || ptr->GetTypeId() != TYPEID_PLAYER)
{
lua_pushstring(L, "Unknown");
return 1;
}
int plrclass = TO_PLAYER(ptr)->getClass();
switch(plrclass)
{
case 1:
lua_pushstring(L, "Warrior");
break;
case 2:
lua_pushstring(L, "Paladin");
break;
case 3:
lua_pushstring(L, "Hunter");
break;
case 4:
lua_pushstring(L, "Rogue");
break;
case 5:
lua_pushstring(L, "Priest");
break;
case 6:
lua_pushstring(L, "Death Knight");
break;
case 7:
lua_pushstring(L, "Shaman");
break;
case 8:
lua_pushstring(L, "Mage");
break;
case 9:
lua_pushstring(L, "Warlock");
break;
//case 10:
case 11:
lua_pushstring(L, "Druid");
break;
default:
lua_pushstring(L, "Unknown");
break;
}
return 1;
}
int ClearHateList(lua_State * L, Unit * ptr)
{
TEST_UNIT()
ptr->ClearHateList();
return 0;
}
int SetMana(lua_State * L, Unit * ptr)
{
int val = luaL_checkint( L, 1);
if (ptr != NULL)
ptr->SetUInt32Value( UNIT_FIELD_POWER1, val );
return 0;
}
int SetMaxMana(lua_State * L, Unit * ptr)
{
int val = luaL_checkint( L, 1);
if (ptr != NULL && val > 0)
{
if( (uint32)val < ptr->GetPower(POWER_TYPE_MANA) )
ptr->SetPower(POWER_TYPE_MANA, val);
ptr->SetMaxPower(POWER_TYPE_MANA, val);
}
return 1;
}
int GetPlayerRace(lua_State * L, Unit * ptr)
{
TEST_PLAYER_RET()
lua_pushinteger( L, TO_PLAYER(ptr)->getRace() );
return 1;
}
int SetFlying(lua_State * L, Unit * ptr)
{
WorldPacket data(SMSG_MOVE_SET_HOVER, 13);
data << ptr->GetNewGUID();
data << uint32(0);
ptr->SendMessageToSet(&data, true);
ptr->GetAIInterface()->disable_melee = true;
ptr->GetAIInterface()->m_moveFly = true;
ptr->Emote(EMOTE_ONESHOT_LIFTOFF);
return 0;
}
int Land(lua_State * L, Unit * ptr)
{
WorldPacket data(SMSG_MOVE_UNSET_HOVER, 13);
data << ptr->GetNewGUID();
data << uint32(0);
ptr->SendMessageToSet(&data, true);
ptr->GetAIInterface()->m_moveFly = false;
ptr->GetAIInterface()->disable_melee = false;
ptr->Emote(EMOTE_ONESHOT_LAND);
return 0;
}
int HasAura(lua_State * L, Unit * ptr)
{
int spellid = luaL_checkint(L,1);
if (!ptr || !spellid)
return 0;
else
{
if(ptr->HasAura(spellid))
lua_pushboolean(L,1);
else
lua_pushboolean(L,0);
}
return 1;
}
int ReturnToSpawnPoint(lua_State * L, Unit * ptr)
{
float x = ptr->GetSpawnX();
float y = ptr->GetSpawnY();
float z = ptr->GetSpawnZ();
float o = ptr->GetSpawnO();
if (ptr)
ptr->GetAIInterface()->MoveTo(x, y, z, o);
return 0;
}
int GetGUID(lua_State * L, Unit * ptr)
{
if (!ptr) return 0;
PUSH_GUID(L,ptr->GetGUID());
return 1;
}
int GetDistance(lua_State * L, Unit * ptr)
{
if (!ptr)
return 0;
Object * target = CHECK_OBJECT(L, 1);
lua_pushnumber(L,(float)ptr->GetDistance2dSq(target) );
return 1;
}
int GetDistanceYards(lua_State * L, Unit * ptr)
{
Object * target = CHECK_OBJECT(L, 1);
if(!ptr || !target)
return 0;
LocationVector vec = ptr->GetPosition();
lua_pushnumber(L,(float)vec.Distance(target->GetPosition()));
return 1;
}
int GetDuelState(lua_State * L, Unit * ptr)
{
TEST_PLAYER()
Player* plr = TO_PLAYER(ptr);
lua_pushnumber(L,plr->GetDuelState());
/*Returns
DUEL_STATE_REQUESTED = 0
DUEL_STATE_STARTED = 1
DUEL_STATE_FINISHED = 2 (Default)
*/
return 1;
}
int GetCreatureNearestCoords(lua_State * L, Unit * ptr)
{
if (!ptr) return 0;
uint32 entryid = CHECK_ULONG(L,4);
float x = CHECK_FLOAT(L,1);
float y = CHECK_FLOAT(L,2);
float z = CHECK_FLOAT(L,3);
PUSH_UNIT(L,ptr->GetMapMgr()->GetInterface()->GetCreatureNearestCoords(x, y, z, entryid));
return 1;
}
int GetGameObjectNearestCoords(lua_State * L, Unit * ptr)
{
if (!ptr) return 0;
uint32 entryid = CHECK_ULONG(L,4);
float x = CHECK_FLOAT(L,1);
float y = CHECK_FLOAT(L,2);
float z = CHECK_FLOAT(L,3);
PUSH_GO(L,ptr->GetMapMgr()->GetInterface()->GetGameObjectNearestCoords(x, y, z, entryid));
return 1;
}
int SetPosition(lua_State * L, Unit * ptr)
{
float x = CHECK_FLOAT(L,1);
float y = CHECK_FLOAT(L,2);
float z = CHECK_FLOAT(L,3);
float o = CHECK_FLOAT(L,4);
ptr->SetFacing(o);
ptr->SetOrientation(o);
WorldPacket data(SMSG_MONSTER_MOVE, 50);
data << ptr->GetNewGUID();
data << uint8(0);
data << ptr->GetPositionX();
data << ptr->GetPositionY();
data << ptr->GetPositionZ();
data << getMSTime();
data << uint8(0x00);
data << uint32(256);
data << uint32(1);
data << uint32(1);
data << x << y << z;
ptr->SendMessageToSet(&data, true);
ptr->SetPosition(x,y,z,o,true);
return 0;
}
int GetLandHeight(lua_State * L, Unit * ptr)
{
float x = CHECK_FLOAT(L,1);
float y = CHECK_FLOAT(L,2);
if (!ptr || !x || !y)
return 0;
float lH = ptr->GetMapMgr()->GetLandHeight(x,y);
lua_pushnumber(L, lH);
return 1;
}
int IsInPhase(lua_State * L, Unit * ptr)
{
uint32 phase = luaL_checkint(L,1);
lua_pushboolean(L, ((ptr->m_phase & phase) != 0) ? 1 : 0);
return 1;
}
int HasFlag(lua_State * L, Unit * ptr)
{
TEST_UNITPLAYER_RET();
uint32 index = CHECK_ULONG(L,1);
uint32 flag = CHECK_ULONG(L,2);
lua_pushboolean(L, ptr->HasFlag(index,flag) ? 1 : 0);
return 1;
}
int QuestAddStarter(lua_State * L, Unit * ptr)
{
TEST_UNIT()
Creature * unit = TO_CREATURE(ptr);
uint32 quest_id = (uint32)luaL_checknumber(L, 1);
if (!unit->HasFlag(UNIT_NPC_FLAGS,UNIT_NPC_FLAG_QUESTGIVER))
unit->SetUInt32Value(UNIT_NPC_FLAGS, unit->GetUInt32Value(UNIT_NPC_FLAGS)+UNIT_NPC_FLAG_QUESTGIVER);
if(!quest_id)
return 0;
Quest * qst = QuestStorage.LookupEntry(quest_id);
if (!qst)
return 0;
uint32 quest_giver = unit->GetEntry();
char my_query1 [200];
sprintf(my_query1,"SELECT id FROM creature_quest_starter WHERE id = %d AND quest = %d", quest_giver, quest_id);
QueryResult *selectResult1 = WorldDatabase.Query(my_query1);
if (selectResult1)
delete selectResult1; //already has quest
else
{
char my_insert1 [200];
sprintf(my_insert1, "INSERT INTO creature_quest_starter (id, quest) VALUES (%d,%d)", quest_giver, quest_id);
WorldDatabase.Execute(my_insert1);
}
sQuestMgr.LoadExtraQuestStuff();
QuestRelation *qstrel = new QuestRelation;
qstrel->qst = qst;
qstrel->type = QUESTGIVER_QUEST_START;
uint8 qstrelid;
if ( unit->HasQuests() )
{
qstrelid = (uint8)unit->GetQuestRelation(quest_id);
unit->DeleteQuest(qstrel);
}
unit->_LoadQuests();
return 0;
}
int QuestAddFinisher(lua_State * L, Unit * ptr)
{
TEST_UNIT()
Creature * unit = TO_CREATURE(ptr);
uint32 quest_id = CHECK_ULONG(L, 1);
if (!unit->HasFlag(UNIT_NPC_FLAGS,UNIT_NPC_FLAG_QUESTGIVER))
unit->SetUInt32Value(UNIT_NPC_FLAGS, unit->GetUInt32Value(UNIT_NPC_FLAGS)+UNIT_NPC_FLAG_QUESTGIVER);
if(!quest_id)
return 0;
Quest * qst = QuestStorage.LookupEntry(quest_id);
if (!qst)
return 0;
uint32 quest_giver = unit->GetEntry();
char my_query1 [200];
sprintf(my_query1,"SELECT id FROM creature_quest_finisher WHERE id = %d AND quest = %d", quest_giver, quest_id);
QueryResult *selectResult1 = WorldDatabase.Query(my_query1);
if (selectResult1)
{
delete selectResult1; //already has quest
}
else
{
char my_insert1 [200];
sprintf(my_insert1, "INSERT INTO creature_quest_finisher (id, quest) VALUES (%d,%d)", quest_giver, quest_id);
WorldDatabase.Execute(my_insert1);
}
sQuestMgr.LoadExtraQuestStuff();
QuestRelation *qstrel = new QuestRelation;
qstrel->qst = qst;
qstrel->type = QUESTGIVER_QUEST_END;
uint8 qstrelid;
if ( unit->HasQuests() )
{
qstrelid = (uint8)unit->GetQuestRelation(quest_id);
unit->DeleteQuest(qstrel);
}
unit->_LoadQuests();
return 0;
}
int CastSpellAoF(lua_State * L, Unit * ptr)
{
float x = CHECK_FLOAT(L,1);
float y = CHECK_FLOAT(L,2);
float z = CHECK_FLOAT(L,3);
uint32 sp = CHECK_ULONG(L, 4);
if(!sp || !ptr)
return 0;
ptr->CastSpellAoF(x,y,z,dbcSpell.LookupEntry(sp), true);
return 0;
}
int FullCastSpellAoF(lua_State * L, Unit * ptr)
{
float x = CHECK_FLOAT(L,1);
float y = CHECK_FLOAT(L,2);
float z = CHECK_FLOAT(L,3);
uint32 sp = CHECK_ULONG(L, 4);
if (!sp || !ptr)
return 0;
ptr->CastSpellAoF(x,y,z,dbcSpell.LookupEntry(sp), false);
return 0;
}
int SetInFront(lua_State * L, Unit * ptr)
{
Unit * target = CHECK_UNIT(L, 1);
if (!target || !ptr)
return 0;
ptr->GetAIInterface()->setInFront(target);
return 0;
}
int RemoveAllAuras(lua_State *L, Unit * ptr)
{
if (!ptr)
return 0;
ptr->RemoveAllAuras();
return 0;
}
int CancelSpell(lua_State * L, Unit * ptr)
{
if(!ptr)
return 0;
ptr->CancelSpell(ptr->GetCurrentSpell());
return 0;
}
int IsAlive(lua_State * L, Unit * ptr)
{
if(ptr)
{
if(ptr->isAlive())
lua_pushboolean(L, 1);
else
lua_pushboolean(L, 0);
}
return 1;
}
int IsDead(lua_State * L, Unit * ptr)
{
if(ptr)
{
if(ptr->isAlive())
lua_pushboolean(L, 0);
else
lua_pushboolean(L, 1);
}
return 1;
}
int IsInWorld(lua_State * L, Unit * ptr)
{
if (ptr)
{
if(ptr->IsInWorld())
lua_pushboolean(L, 1);
else
lua_pushboolean(L, 0);
}
return 1;
}
int GetZoneId(lua_State *L, Unit * ptr)
{
if(!ptr)
return 0;
lua_pushinteger(L,(ptr->GetZoneId()));
return 1;
}
int Root(lua_State * L, Unit * ptr)
{
if(ptr)
ptr->Root();
return 0;
}
int Unroot(lua_State * L, Unit * ptr)
{
if(ptr)
ptr->Unroot();
return 0;
}
int IsCreatureMoving(lua_State * L, Unit * ptr)
{
if(ptr && ptr->GetTypeId() == TYPEID_UNIT)
{
if(ptr->GetAIInterface()->m_creatureState == MOVING)
lua_pushboolean(L, 1);
else
lua_pushboolean(L, 0);
}
return 1;
}
int SetOutOfCombatRange(lua_State * L, Unit * ptr)
{
TEST_UNIT()
int range = luaL_checkint(L, 1);
if (range)
ptr->GetAIInterface()->setOutOfCombatRange(range);
return 0;
}
int ModifyRunSpeed(lua_State * L, Unit * ptr)
{
float Speed = CHECK_FLOAT(L, 1);
if (ptr && Speed)
ptr->m_runSpeed = Speed;
return 0;
}
int ModifyWalkSpeed(lua_State * L, Unit * ptr)
{
float Speed = CHECK_FLOAT(L,1);
if (ptr && Speed)
ptr->m_walkSpeed = Speed;
return 0;
}
int ModifyFlySpeed(lua_State * L, Unit * ptr)
{
float Speed = CHECK_FLOAT(L,1);
if(ptr && Speed)
ptr->m_flySpeed = Speed;
return 0;
}
int IsFlying(lua_State * L, Unit * ptr)
{
TEST_UNIT()
if(ptr->GetAIInterface()->IsFlying())
lua_pushboolean(L, 1);
else
lua_pushboolean(L, 0);
return 1;
}
int SetRotation(lua_State * L, Unit * ptr)
{
ptr->SetRotation(ptr->GetGUID());
return 0;
}
int SetOrientation(lua_State * L, Unit * ptr)
{
float O = CHECK_FLOAT(L, 1);
if(ptr)
ptr->SetOrientation(O);
return 0;
}
int GetSpawnX(lua_State * L, Unit * ptr)
{
if(ptr)
lua_pushnumber(L,ptr->GetSpawnX());
return 1;
}
int GetSpawnY(lua_State * L, Unit * ptr)
{
if(ptr)
lua_pushnumber(L,ptr->GetSpawnY());
return 1;
}
int GetSpawnZ(lua_State * L, Unit * ptr)
{
if(ptr)
lua_pushnumber(L,ptr->GetSpawnZ());
return 1;
}
int GetSpawnO(lua_State * L, Unit * ptr)
{
if(ptr)
lua_pushnumber(L,ptr->GetSpawnO());
return 1;
}
int GetInRangePlayersCount(lua_State * L, Unit * ptr)
{
if(ptr)
lua_pushnumber(L,ptr->GetInRangePlayersCount());
return 1;
}
int GetEntry(lua_State * L, Unit * ptr)
{
if(ptr)
lua_pushnumber(L,ptr->GetEntry());
return 1;
}
int SetMoveRunFlag(lua_State * L, Unit * ptr)
{
TEST_UNIT()
int enabled = luaL_checkint(L, 1);
ptr->GetAIInterface()->setMoveRunFlag((enabled > 0) ? true : false);
return 0;
}
int HandleEvent(lua_State * L, Unit * ptr)
{
TEST_UNIT()
Unit * target = CHECK_UNIT(L, 1);
int event_id = luaL_checkint(L, 2);
int misc_1 = luaL_checkint(L, 3);
ptr->GetAIInterface()->HandleEvent(event_id, target, misc_1);
return 1;
}
int GetCurrentSpellId(lua_State * L, Unit * ptr)
{
if (!ptr) return 0;
if (ptr->GetCurrentSpell())
lua_pushnumber(L, ptr->GetCurrentSpell()->GetProto()->Id);
else
lua_pushnil(L);
return 1;
}
int GetCurrentSpell(lua_State * L, Unit * ptr)
{
if (!ptr) return 0;
if(ptr->GetCurrentSpell() != 0)
PUSH_SPELL(L,ptr->GetCurrentSpell());
else
lua_pushnil(L);
return 1;
}
int AddAssistTargets(lua_State * L, Unit * ptr)
{
TEST_UNIT()
Unit * Friend = CHECK_UNIT(L,1);
if(Friend)
{
if( isFriendly(ptr, Friend))
ptr->GetAIInterface()->addAssistTargets(Friend);
}
return 0;
}
int GetAIState(lua_State * L, Unit * ptr)
{
TEST_UNIT()
lua_pushnumber(L, ptr->GetAIInterface()->getAIState());
return 1;
}
int GetFloatValue(lua_State * L, Unit * ptr)
{
int field = luaL_checkint(L, 1);
if (ptr)
lua_pushnumber(L, ptr->GetFloatValue(field));
return 1;
}
int SendPacket(lua_State * L, Unit * ptr)
{
WorldPacket * data = CHECK_PACKET(L,1);
int self = lua_toboolean(L,2);
if (data && ptr)
ptr->SendMessageToSet(data,(self > 0 ) ? true : false);
return 0;
}
int SendPacketToGroup(lua_State * L, Unit * ptr)
{
WorldPacket * data = CHECK_PACKET(L,1);
TEST_PLAYER()
Player * plr = TO_PLAYER(ptr);
if (!data) return 0;
plr->GetGroup()->SendPacketToAll(data);
return 0;
}
int SendPacketToPlayer(lua_State * L, Unit * ptr)
{
WorldPacket * data = CHECK_PACKET(L,1);
TEST_PLAYER()
Player * plr = TO_PLAYER(ptr);
if (data)
plr->GetSession()->SendPacket(data);
return 0;
}
int ModUInt32Value(lua_State * L, Unit * ptr)
{
int field = luaL_checkint(L, 1);
int value = luaL_checkint(L, 2);
if (ptr)
ptr->ModSignedInt32Value(field, value);
return 0;
}
int ModFloatValue(lua_State * L, Unit * ptr)
{
int field = luaL_checkint(L, 1);
float value = CHECK_FLOAT(L, 2);
if (ptr)
ptr->ModFloatValue(field, value);
return 0;
}
int SetUInt32Value(lua_State * L, Unit * ptr)
{
int field = luaL_checkint(L, 1);
int value = luaL_checkint(L, 2);
if (ptr)
ptr->SetUInt32Value(field, value);
return 0;
}
int SetUInt64Value(lua_State * L, Unit * ptr)
{
uint32 field = CHECK_ULONG(L,1);
uint64 guid = CHECK_GUID(L,2);
if (ptr)
ptr->SetUInt64Value(field, guid);
return 0;
}
int RemoveFlag(lua_State * L, Unit * ptr)
{
int field = luaL_checkint(L,1);
int value = luaL_checkint(L,2);
if (ptr)
ptr->RemoveFlag(field,value);
return 0;
}
int SetFlag(lua_State * L, Unit * ptr)
{
int field = luaL_checkint(L,1);
int value = luaL_checkint(L,2);
if (ptr)
ptr->SetFlag(field,value);
return 0;
}
int SetFloatValue(lua_State * L, Unit * ptr)
{
int field = luaL_checkint(L, 1);
float value = CHECK_FLOAT(L, 2);
if (ptr)
ptr->SetFloatValue(field, value);
return 0;
}
int GetUInt32Value(lua_State * L, Unit * ptr)
{
int field = luaL_checkint(L, 1);
if (ptr)
lua_pushnumber(L, ptr->GetUInt32Value(field));
return 1;
}
int GetUInt64Value(lua_State * L, Unit * ptr)
{
int field = luaL_checkint(L, 1);
if (ptr)
PUSH_GUID(L, ptr->GetUInt64Value(field));
return 1;
}
int AdvanceQuestObjective(lua_State * L, Unit * ptr)
{
TEST_PLAYER()
int questid = luaL_checkint(L,1);
int objective = luaL_checkint(L,2);
Player * pl = TO_PLAYER(ptr);
QuestLogEntry * qle = pl->GetQuestLogForEntry(questid);
if(qle != NULL)
{
qle->SetMobCount(objective, qle->GetMobCount(objective) + 1);
qle->SendUpdateAddKill(objective);
if (qle->CanBeFinished())
qle->SendQuestComplete();
qle->UpdatePlayerFields();
}
return 0;
}
int Heal(lua_State * L, Unit * ptr)
{
Unit * target = CHECK_UNIT(L, 1);
uint32 spellid = CHECK_ULONG(L, 2);
uint32 amount = CHECK_ULONG(L, 3);
if (!target || !spellid || !amount || !ptr)
return 0;
ptr->Heal(target,spellid,amount);
return 0;
}
int Energize(lua_State * L, Unit * ptr)
{
Unit * target = CHECK_UNIT(L, 1);
uint32 spellid = CHECK_ULONG(L, 2);
uint32 amount = CHECK_ULONG(L, 3);
uint32 type = CHECK_ULONG(L, 4);
if(!target || !spellid|| !amount|| !type|| !ptr)
return 0;
ptr->Energize(target,spellid,amount,type);
return 0;
}
int SendChatMessageAlternateEntry(lua_State * L, Unit * ptr)
{
uint32 entry = CHECK_ULONG(L, 1);
uint8 type = CHECK_ULONG(L, 2);
uint32 lang = CHECK_ULONG(L, 3);
const char * msg = luaL_checkstring(L, 4);
if(!entry || !lang || !msg)
return 0;
ptr->SendChatMessageAlternateEntry(entry,type,lang,msg);
return 0;
}
int SendChatMessageToPlayer(lua_State * L, Unit * ptr)
{
uint8 type = CHECK_ULONG(L, 1);
uint32 lang = CHECK_ULONG(L, 2);
const char *msg = luaL_checkstring(L,3);
Player *plr = CHECK_PLAYER(L,4);
if (!plr || !msg || !ptr)
return 0;
ptr->SendChatMessageToPlayer(type,lang,msg,plr);
return 0;
}
int GetManaPct(lua_State * L, Unit * ptr)
{
if(!ptr)
return 0;
if (ptr->GetPowerType() == (uint8)POWER_TYPE_MANA)
lua_pushnumber(L, (int)(ptr->GetPower(POWER_TYPE_MANA) * 100.0f / ptr->GetMaxPower(POWER_TYPE_MANA)));
else
lua_pushnil(L);
return 1;
}
int GetPowerPct(lua_State * L, Unit * ptr)
{
if (!ptr)
{
lua_pushnil(L);
return 1;
}
int powertype = luaL_optint(L, 1, -1);
if (powertype == -1)
powertype = ptr->GetPowerType();
lua_pushnumber(L, (int)(ptr->GetPower(powertype) * 100.0f / ptr->GetMaxPower(powertype)));
return 1;
}
int GetMana(lua_State * L, Unit * ptr)
{
if( ptr == NULL )
lua_pushinteger( L, 0 );
else
lua_pushinteger( L, ptr->GetPower(POWER_TYPE_MANA) );
return 1;
}
int GetPower(lua_State * L, Unit * ptr)
{
if (!ptr)
{
lua_pushnil(L);
return 1;
}
int powertype = luaL_optint(L, 1, -1);
if (powertype == -1)
powertype = ptr->GetPowerType();
lua_pushnumber(L, ptr->GetPower(powertype));
return 1;
}
int GetMaxMana(lua_State * L, Unit * ptr)
{
if( ptr == NULL )
lua_pushinteger( L, 0 );
else
lua_pushinteger( L, ptr->GetMaxPower(POWER_TYPE_MANA) );
return 1;
}
int GetMaxPower(lua_State * L, Unit * ptr)
{
if (!ptr)
{
lua_pushnil(L);
return 1;
}
int powertype = luaL_optint(L, 1, -1);
if (powertype == -1)
powertype = ptr->GetPowerType();
lua_pushnumber(L, ptr->GetMaxPower(powertype));
return 1;
}
int SetPowerType(lua_State * L, Unit * ptr)
{/* POWER_TYPE_MANA = 0,
POWER_TYPE_RAGE = 1,
POWER_TYPE_FOCUS = 2,
POWER_TYPE_ENERGY = 3,
POWER_TYPE_HAPPINESS = 4,
POWER_TYPE_RUNES = 5,
POWER_TYPE_RUNIC_POWER = 6 */
int type = luaL_checkint(L, 1);
if(!ptr || type < 0)
return 0;
ptr->SetPowerType(type);
return 0;
}
int SetMaxPower(lua_State * L, Unit * ptr)
{
int amount = luaL_checkint(L,1);
int powertype = luaL_optint(L, 2, -1);
if (!ptr || amount < 0) return 0;
if (powertype == -1)
powertype = ptr->GetPowerType();
ptr->SetMaxPower(powertype, amount);
return 0;
}
int SetPower(lua_State * L, Unit * ptr)
{
int amount = luaL_checkint(L,1);
int powertype = luaL_optint(L, 2, -1);
if (!ptr || amount < 0) return 0;
if (powertype == -1)
powertype = ptr->GetPowerType();
ptr->SetPower(powertype, amount);
return 0;
}
int SetPowerPct(lua_State * L, Unit * ptr)
{
int amount = luaL_checkint(L,1);
int powertype = luaL_optint(L, 2, -1);
if (!ptr || amount < 0) return 0;
if (powertype == -1)
powertype = ptr->GetPowerType();
ptr->SetPower( powertype, (int)(amount/100) * (ptr->GetMaxPower(powertype)) );
return 0;
}
int GetPowerType(lua_State * L, Unit * ptr)
{
if (!ptr) return 0;
lua_pushinteger(L, ptr->GetPowerType());
return 1;
}
int Strike(lua_State * L, Unit * ptr)
{
TEST_UNIT_RET();
Unit * target = CHECK_UNIT(L, 1);
uint32 weapon_damage_type = luaL_checkint(L, 2);
uint32 sp = CHECK_ULONG(L, 3);
int32 adddmg = luaL_checkint(L, 4);
uint32 exclusive_damage = CHECK_ULONG(L, 5);
int32 pct_dmg_mod = luaL_checkint(L, 6);
if (!target)
return 0;
ptr->Strike(target,weapon_damage_type,dbcSpell.LookupEntry(sp),adddmg,pct_dmg_mod,exclusive_damage,false,false);
return 0;
}
int SetAttackTimer(lua_State * L, Unit * ptr)
{
int32 timer = luaL_checkint(L, 1);
bool offhand = CHECK_BOOL(L,2);
if(!timer || !ptr)
return 0;
ptr->setAttackTimer(timer,offhand);
return 0;
}
int Kill(lua_State * L, Unit * ptr)
{
Unit * target = CHECK_UNIT(L, 1);
if (!ptr || !target)
return 0;
ptr->DealDamage(target,target->GetUInt32Value(UNIT_FIELD_HEALTH),0,0,0,true);
return 0;
}
int DealDamage(lua_State * L, Unit * ptr)
{
Unit * target = CHECK_UNIT(L, 1);
uint32 damage = CHECK_ULONG(L, 2);
uint32 spellid = CHECK_ULONG(L, 3);
if(!ptr || !target)
return 0;
ptr->DealDamage(target,damage,0,0,spellid,true);
return 0;
}
int SetNextTarget(lua_State * L, Unit * ptr)
{
Unit * target = CHECK_UNIT(L, 1);
if (ptr && target)
ptr->GetAIInterface()->SetNextTarget(target);
return 0;
}
int GetNextTarget(lua_State * L, Unit * ptr)
{
TEST_UNIT()
PUSH_UNIT(L, ptr->GetAIInterface()->GetNextTarget());
return 1;
}
int SetPetOwner(lua_State * L, Unit * ptr)
{
TEST_UNIT()
Unit * owner = CHECK_UNIT(L, 1);
if (owner)
ptr->GetAIInterface()->SetPetOwner(owner);
return 0;
}
int DismissPet(lua_State * L, Unit * ptr)
{
TEST_UNIT()
ptr->GetAIInterface()->DismissPet();
return 0;
}
int IsPet(lua_State * L, Unit * ptr)
{
if (ptr)
{
if (ptr->IsPet())
lua_pushboolean(L,1);
else
lua_pushboolean(L, 0);
}
return 1;
}
int GetPetOwner(lua_State * L, Unit * ptr)
{
TEST_UNIT()
PUSH_UNIT(L, ptr->GetAIInterface()->GetPetOwner());
return 1;
}
int SetUnitToFollow(lua_State * L, Unit * ptr)
{
Unit * target = CHECK_UNIT(L, 1);
float dist = CHECK_FLOAT(L, 2);
float angle = CHECK_FLOAT(L, 3);
if(!ptr || !dist || !angle)
return 0;
ptr->GetAIInterface()->SetUnitToFollow(target);
ptr->GetAIInterface()->SetFollowDistance(dist);
ptr->GetAIInterface()->SetUnitToFollowAngle(angle);
return 0;
}
int GetUnitToFollow(lua_State * L, Unit * ptr)
{
TEST_UNIT()
PUSH_UNIT(L,ptr->GetAIInterface()->getUnitToFollow());
return 1;
}
int IsInFront(lua_State * L, Unit * ptr)
{
Object * target = CHECK_OBJECT(L, 1);
if (ptr && target)
{
if(ptr->isInFront(target))
lua_pushboolean(L, 1);
else
lua_pushboolean(L, 0);
}
return 1;
}
int IsInBack(lua_State * L, Unit * ptr)
{
Object * target = CHECK_OBJECT(L, 1);
if (ptr && target)
{
if(ptr->isInBack(target))
lua_pushboolean(L, 1);
else
lua_pushboolean(L, 0);
}
return 1;
}
int IsPacified(lua_State * L, Unit * ptr)
{
if(ptr)
lua_pushboolean(L,(ptr->IsPacified()) ? 1 : 0);
return 1;
}
int SetPacified(lua_State * L, Unit * ptr)
{
bool pacified = CHECK_BOOL(L, 1);
if (!ptr)
return 0;
ptr->m_pacified = pacified ? 1 : 0;
if (pacified)
ptr->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_PACIFIED | UNIT_FLAG_SILENCED);
else
ptr->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_PACIFIED | UNIT_FLAG_SILENCED);
return 0;
}
int IsFeared(lua_State * L, Unit * ptr)
{
if (ptr)
lua_pushboolean(L,(ptr->IsFeared()) ? 1 : 0);
return 1;
}
int IsStunned(lua_State * L, Unit * ptr)
{
if(ptr)
lua_pushboolean(L,(ptr->IsStunned()) ? 1 : 0);
return 1;
}
int CreateGuardian(lua_State * L, Unit * ptr)
{
uint32 guardian_entry = CHECK_ULONG(L,1);
uint32 duration = CHECK_ULONG(L, 2);
float angle = CHECK_FLOAT(L, 3);
uint32 lvl = CHECK_ULONG(L, 4);
if (!ptr || !guardian_entry || !lvl)
return 0;
PUSH_UNIT(L, TO_UNIT(ptr->create_guardian(guardian_entry,duration,angle,lvl,NULL)));
return 1;
}
int IsInArc(lua_State * L, Unit * ptr)
{
Unit * target = CHECK_UNIT(L, 1);
float degrees = CHECK_FLOAT(L, 2);
if (!target || !ptr || !degrees)
return 0;
else
{
if (ptr->isInArc(target,degrees))
lua_pushboolean(L,1);
else
lua_pushboolean(L,0);
}
return 1;
}
int IsInWater(lua_State * L, Unit * ptr)
{
TEST_PLAYER()
if (ptr)
{
if (TO_PLAYER(ptr)->m_UnderwaterState)
lua_pushboolean(L, 1);
else
lua_pushboolean(L, 0);
}
return 1;
}
int GetAITargetsCount(lua_State * L, Unit * ptr)
{
TEST_UNIT()
lua_pushnumber(L,ptr->GetAIInterface()->getAITargetsCount());
return 1;
}
int GetUnitByGUID(lua_State * L, Unit * ptr)
{
uint64 guid = CHECK_GUID(L,1);
if (ptr && guid)
PUSH_UNIT(L,ptr->GetMapMgr()->GetUnit(guid));
return 1;
}
int GetAITargets(lua_State * L, Unit * ptr)
{
TEST_UNIT()
Unit * ret = NULL;
TargetMap::iterator itr;
lua_newtable(L);
int count = 0;
for (itr = ptr->GetAIInterface()->GetAITargets()->begin(); itr!= ptr->GetAIInterface()->GetAITargets()->end(); itr++)
{
ret = ptr->GetMapMgr()->GetUnit(itr->first);
count++;
lua_pushvalue(L,count);
PUSH_UNIT(L,ret);
lua_rawset(L,-3);
}
return 1;
}
int GetInRangeObjectsCount(lua_State * L, Unit * ptr)
{
if(ptr)
lua_pushnumber(L,ptr->GetInRangeCount());
return 1;
}
int GetInRangePlayers(lua_State * L, Unit * ptr)
{
if (!ptr) return 0;
uint32 count = 0;
lua_newtable(L);
for(std::set< Object* >::iterator itr = ptr->GetInRangePlayerSetBegin(); itr != ptr->GetInRangePlayerSetEnd(); itr++)
{
if( (*itr) ->GetTypeId() == TYPEID_PLAYER)
{
count++,
lua_pushinteger(L,count);
PUSH_UNIT(L,*itr);
lua_rawset(L,-3);
}
}
return 1;
}
int GetGroupPlayers(lua_State * L, Unit * ptr)
{
TEST_PLAYER()
Player * _player = TO_PLAYER(ptr);
Group* party = _player->GetGroup();
uint32 count = 0;
lua_newtable(L);
if (party)
{
GroupMembersSet::iterator itr;
SubGroup * sgrp;
party->getLock().Acquire();
for(uint32 i = 0; i < party->GetSubGroupCount(); i++)
{
sgrp = party->GetSubGroup(i);
for(itr = sgrp->GetGroupMembersBegin(); itr != sgrp->GetGroupMembersEnd(); ++itr)
{
if((*itr)->m_loggedInPlayer && (*itr)->m_loggedInPlayer->GetZoneId() == _player->GetZoneId() && _player->GetInstanceID() == (*itr)->m_loggedInPlayer->GetInstanceID())
{
count++,
lua_pushinteger(L,count);
PUSH_UNIT(L,(*itr)->m_loggedInPlayer);
lua_rawset(L,-3);
}
}
}
party->getLock().Release();
}
return 1;
}
int GetDungeonDifficulty(lua_State * L, Unit * ptr)
{ /*
MODE_NORMAL_10MEN = 0,
MODE_NORMAL_25MEN = 1,
MODE_HEROIC_10MEN = 2,
MODE_HEROIC_25MEN = 3
*/
if (ptr->GetTypeId() == TYPEID_PLAYER)
{
Player * plr = TO_PLAYER(ptr);
if (plr->GetGroup())
{
if (plr->GetGroup()->GetGroupType() == GROUP_TYPE_PARTY)
lua_pushnumber(L,plr->GetGroup()->m_difficulty);
else
lua_pushnumber(L,plr->GetGroup()->m_raiddifficulty);
}
else
{
if (!plr->IsInInstance())
return 0;
Instance * pInstance = sInstanceMgr.GetInstanceByIds(plr->GetMapId(), plr->GetInstanceID());
lua_pushinteger(L,pInstance->m_difficulty);
}
return 1;
}
else
{
if (!ptr->IsInInstance())
{
lua_pushboolean(L,0);
return 1;
}
Instance * pInstance = sInstanceMgr.GetInstanceByIds(ptr->GetMapId(), ptr->GetInstanceID());
lua_pushinteger(L,pInstance->m_difficulty);
}
return 1;
}
int GetInstanceOwner(lua_State * L, Unit * ptr)
{
if (!ptr) return 0;
if (!ptr->IsInInstance())
lua_pushnil(L);
else
{
Instance * pInstance = sInstanceMgr.GetInstanceByIds(ptr->GetMapId(), ptr->GetInstanceID());
if (pInstance->m_creatorGuid != 0) // creator guid is 0 if its owned by a group.
{
Player * owner = pInstance->m_mapMgr->GetPlayer(pInstance->m_creatorGuid);
PUSH_UNIT(L,owner);
}
else
{
uint32 gId = pInstance->m_creatorGroup;
PUSH_UNIT(L,objmgr.GetGroupById(gId)->GetLeader()->m_loggedInPlayer);
}
}
return 1;
}
int IsGroupFull(lua_State * L, Unit * ptr)
{
TEST_PLAYER()
Player * plr = TO_PLAYER(ptr);
lua_pushboolean(L,plr->GetGroup()->IsFull() ? 1 : 0);
return 1;
}
int GetGroupLeader(lua_State * L, Unit * ptr)
{
TEST_PLAYER()
Player * plr = TO_PLAYER(ptr);
PUSH_UNIT(L,plr->GetGroup()->GetLeader()->m_loggedInPlayer);
return 1;
}
int SetGroupLeader(lua_State * L, Unit * ptr)
{
TEST_PLAYER()
Player * _plr = CHECK_PLAYER(L,1);
bool silent = CHECK_BOOL(L,2);
Player * plr = TO_PLAYER(ptr);
plr->GetGroup()->SetLeader(_plr, silent);
return 0;
}
int AddGroupMember(lua_State * L, Unit * ptr)
{
TEST_PLAYER()
Player * plr = TO_PLAYER(ptr);
Player * _plr = CHECK_PLAYER(L,1);
int32 subgroup = luaL_optint(L,2,-1);
plr->GetGroup()->AddMember(_plr->getPlayerInfo(),subgroup);
return 0;
}
int SetDungeonDifficulty(lua_State * L, Unit * ptr)
{ /*
MODE_NORMAL_10MEN = 0,
MODE_NORMAL_25MEN = 1,
MODE_HEROIC_10MEN = 2,
MODE_HEROIC_25MEN = 3
*/
uint32 difficulty = CHECK_ULONG(L,1);
if (!ptr) return 0;
if (ptr->IsInInstance())
{
if (ptr->IsPlayer())
{
Player * plr = TO_PLAYER(ptr);
if (plr->GetGroup())
(difficulty > 1 ? plr->GetGroup()->m_difficulty : plr->GetGroup()->m_raiddifficulty) = difficulty;
else
{
Instance * pInstance = sInstanceMgr.GetInstanceByIds(plr->GetMapId(), plr->GetInstanceID());
pInstance->m_difficulty = difficulty;
}
}
else
{
Instance * pInstance = sInstanceMgr.GetInstanceByIds(ptr->GetMapId(), ptr->GetInstanceID());
pInstance->m_difficulty = difficulty;
}
}
return 0;
}
int ExpandToRaid(lua_State * L, Unit * ptr)
{
TEST_PLAYER()
Player * plr = TO_PLAYER(ptr);
plr->GetGroup()->ExpandToRaid();
return 0;
}
int GetInRangeGameObjects(lua_State * L, Unit * ptr)
{
if (!ptr) return 0;
lua_newtable(L);
uint32 count = 0;
for (std::set<Object*>::iterator itr = ptr->GetInRangeSetBegin();itr!= ptr->GetInRangeSetEnd();itr++)
{
if( (*itr) ->GetTypeId() == TYPEID_GAMEOBJECT)
{
count++,
lua_pushinteger(L,count);
PUSH_GO(L,*itr);
lua_rawset(L,-3);
}
}
return 1;
}
int HasInRangeObjects(lua_State * L, Unit * ptr)
{
if(ptr)
{
if(ptr->HasInRangeObjects())
lua_pushboolean(L, 1);
else
lua_pushboolean(L, 0);
}
return 1;
}
int SetFacing(lua_State * L, Unit * ptr)
{
float newo = CHECK_FLOAT(L, 1);
if (!ptr)
return 0;
ptr->SetFacing(newo);
return 0;
}
int CalcToDistance(lua_State * L, Unit * ptr)
{
float x = CHECK_FLOAT(L, 1);
float y = CHECK_FLOAT(L, 2);
float z = CHECK_FLOAT(L, 3);
if (!ptr | !x | !y | !z)
return 0;
lua_pushnumber(L,ptr->CalcDistance(x,y,z));
return 1;
}
int CalcAngle(lua_State * L, Unit * ptr)
{
float x = CHECK_FLOAT(L,1 );
float y = CHECK_FLOAT(L, 2);
float x2 = CHECK_FLOAT(L, 3);
float y2 = CHECK_FLOAT(L, 4);
if(!x || !y || !x2 || !y2|| !ptr)
return 0;
lua_pushnumber(L,ptr->calcAngle(x,y,x2,y2));
return 1;
}
int CalcRadAngle(lua_State * L, Unit * ptr)
{
float ang = 0;
float x = CHECK_FLOAT(L,1 );
float y = CHECK_FLOAT(L, 2);
float dx = CHECK_FLOAT(L, 3);
float dy = CHECK_FLOAT(L, 4);
if (!x || !y || !dx|| !dy || !ptr)
return 0;
else
{
ang = ptr->calcRadAngle(x,y,dx,dy);
lua_pushnumber(L,ang);
}
return 1;
}
int IsInvisible(lua_State * L, Unit * ptr) //THIS IS NOT "IS" IT'S SET!
{
if (!ptr) return 0;
bool enabled = CHECK_BOOL(L,1);
if (enabled)
{
ptr->m_invisFlag = INVIS_FLAG_TOTAL;
ptr->m_invisible = true;
}
else
{
ptr->m_invisFlag = INVIS_FLAG_NORMAL;
ptr->m_invisible = false;
}
return 0;
}
int MoveFly(lua_State * L, Unit * ptr)
{
TEST_UNIT()
bool enabled = CHECK_BOOL(L,1);
ptr->GetAIInterface()->m_moveFly = enabled;
return 0;
}
int IsInvincible(lua_State * L, Unit * ptr) //THIS IS NOT "IS" IT'S SET!
{
bool enabled = CHECK_BOOL(L,1);
if (ptr)
ptr->bInvincible = enabled;
return 0;
}
int ResurrectPlayer(lua_State * L, Unit * ptr)
{
TEST_PLAYER()
TO_PLAYER(ptr)->RemoteRevive();
return 0;
}
int KickPlayer(lua_State * L, Unit * ptr)
{
TEST_PLAYER()
int delay = luaL_checkint(L,1);
TO_PLAYER(ptr)->Kick(delay);
return 0;
}
int CanCallForHelp(lua_State * L, Unit * ptr)
{
TEST_UNIT()
bool enabled = CHECK_BOOL(L,1);
ptr->GetAIInterface()->m_canCallForHelp = enabled;
return 0;
}
int CallForHelpHp(lua_State * L, Unit * ptr)
{
TEST_UNIT()
float hp = CHECK_FLOAT(L, 1);
ptr->GetAIInterface()->m_CallForHelpHealth = hp;
return 0;
}
int SetDeathState(lua_State * L, Unit * ptr)
{
int state = luaL_checkint(L, 1);
if (ptr)
{
switch (state)
{
case 0:
ptr->setDeathState(ALIVE);
break;
case 1:
ptr->setDeathState(JUST_DIED);
break;
case 2:
ptr->setDeathState(CORPSE);
break;
case 3:
ptr->setDeathState(DEAD);
break;
}
}
return 0;
}
int SetCreatureName(lua_State * L, Unit * ptr)
{
TEST_UNIT()
//Paroxysm : This method makes alot of sense...
/*
uint32 id = CHECK_ULONG(L,1);
if(!ptr|!id)
return 0;
TO_PLAYER(ptr)->SetCreatureInfo(CreatureNameStorage.LookupEntry(id));
*/
return 0;
}
int SetBindPoint(lua_State * L, Unit * ptr)
{
TEST_PLAYER()
Player * plr = TO_PLAYER(ptr);
float x = CHECK_FLOAT(L, 1);
float y = CHECK_FLOAT(L, 2);
float z = CHECK_FLOAT(L, 3);
uint32 map = CHECK_ULONG(L, 4);
uint32 zone = CHECK_ULONG(L, 5);
if (!x || !y || !z || !zone)
return 0;
plr->SetBindPoint(x, y, z, map, zone);
return 0;
}
int SoftDisconnect(lua_State * L, Unit * ptr)
{
TEST_PLAYER()
TO_PLAYER(ptr)->SoftDisconnect();
return 0;
}
int Possess(lua_State * L, Unit * ptr)
{
TEST_PLAYER()
Unit * target = CHECK_UNIT(L,1);
if (target)
TO_PLAYER(ptr)->Possess(target);
return 0;
}
int Unpossess(lua_State * L, Unit * ptr)
{
TEST_PLAYER()
TO_PLAYER(ptr)->UnPossess();
return 0;
}
int RemoveFromWorld(lua_State * L, Unit * ptr)
{
if (ptr)
ptr->RemoveFromWorld(true);
return 0;
}
int GetFaction(lua_State * L, Unit * ptr)
{
if(ptr)
lua_pushnumber(L,ptr->GetFaction());
return 1;
}
int SpellNonMeleeDamageLog(lua_State * L, Unit * ptr)
{
Unit * pVictim = CHECK_UNIT(L,1);
uint32 spellid = CHECK_ULONG(L,2);
uint32 damage = CHECK_ULONG(L,3);
bool allowproc = CHECK_BOOL(L,4);
bool static_dmg = CHECK_BOOL(L,5);
bool no_remove_auras = CHECK_BOOL(L,6);
if(pVictim && spellid && damage)
{
ptr->SpellNonMeleeDamageLog(pVictim,spellid,damage,allowproc,static_dmg,no_remove_auras);
}
return 0;
}
int NoRespawn(lua_State * L, Unit * ptr)
{
TEST_UNIT()
bool enabled = CHECK_BOOL(L,1);
TO_CREATURE(ptr)->m_noRespawn = enabled;
return 0;
}
int GetMapId(lua_State * L, Unit * ptr)
{
if (!ptr) return 0;
lua_pushnumber(L, ptr->GetMapId());
return 1;
}
int AttackReaction(lua_State * L, Unit * ptr)
{
Unit * target = CHECK_UNIT(L,1);
uint32 damage = luaL_checkint(L,2);
uint32 spell = luaL_checkint(L,3);
if(ptr && target && damage)
ptr->GetAIInterface()->AttackReaction(target,damage,spell);
return 0;
}
int EventCastSpell(lua_State * L, Unit * ptr)
{
TEST_UNITPLAYER()
Unit * target = CHECK_UNIT(L, 1);
uint32 sp = CHECK_ULONG(L,2);
uint32 delay = CHECK_ULONG(L,3);
uint32 repeats = CHECK_ULONG(L,4);
if (ptr && sp)
{
switch(ptr->GetTypeId())
{
case TYPEID_PLAYER:
sEventMgr.AddEvent(ptr, &Player::EventCastSpell,target,dbcSpell.LookupEntry(sp),EVENT_PLAYER_UPDATE,delay,repeats,EVENT_FLAG_DO_NOT_EXECUTE_IN_WORLD_CONTEXT);
break;
case TYPEID_UNIT:
sEventMgr.AddEvent(ptr, &Unit::EventCastSpell,target,dbcSpell.LookupEntry(sp),EVENT_CREATURE_UPDATE,delay,repeats,EVENT_FLAG_DO_NOT_EXECUTE_IN_WORLD_CONTEXT);
break;
}
}
return 0;
}
int IsPlayerMoving(lua_State * L, Unit * ptr)
{
TEST_PLAYER_RET()
lua_pushboolean(L, (TO_PLAYER(ptr)->m_isMoving) ? 1 : 0);
return 1;
}
int IsPlayerAttacking(lua_State * L, Unit * ptr)
{
TEST_PLAYER_RET()
if( TO_PLAYER(ptr)->IsAttacking())
lua_pushboolean(L,1);
else
lua_pushboolean(L,0);
return 1;
}
int GetFactionStanding(lua_State * L, Unit * ptr)
{
TEST_PLAYER()
uint32 faction = luaL_checkint(L,1);
if (faction)
{
switch (TO_PLAYER(ptr)->GetStandingRank(faction))
{
case STANDING_HATED:
lua_pushstring(L, "Hated");
break;
case STANDING_HOSTILE:
lua_pushstring(L, "Hostile");
break;
case STANDING_UNFRIENDLY:
lua_pushstring(L, "Unfriendly");
break;
case STANDING_NEUTRAL:
lua_pushstring(L, "Neutral");
break;
case STANDING_FRIENDLY:
lua_pushstring(L, "Friendly");
break;
case STANDING_HONORED:
lua_pushstring(L, "Honored");
break;
case STANDING_REVERED:
lua_pushstring(L, "Revered");
break;
case STANDING_EXALTED:
lua_pushstring(L, "Exalted");
break;
}
}
return 1;
}
int SetPlayerAtWar(lua_State * L, Unit * ptr)
{
TEST_PLAYER_RET()
uint32 faction = CHECK_ULONG(L,1);
bool set = CHECK_BOOL(L,3);
if (faction)
{
TO_PLAYER(ptr)->SetAtWar(faction,set);
}
return 0;
}
/*int IsPlayerAtWar(lua_State * L, Unit * ptr)
{
TEST_PLAYER_RET()
uint32 faction = luaL_checkint(L,1);
if (ptr && faction)
if( ((Player*)ptr)->IsAtWar(faction))
lua_pushboolean(L,1);
else
lua_pushboolean(L,0);
return 1;
}*/
int SetPlayerStanding(lua_State * L, Unit * ptr)
{
TEST_PLAYER()
uint32 faction = luaL_checkint(L,1);
uint32 value = luaL_checkint(L,2);
if(faction && value)
TO_PLAYER(ptr)->SetStanding(faction,value);
return 0;
}
int SetPlayerSpeed(lua_State * L, Unit * ptr)
{
TEST_PLAYER()
Player * plr = TO_PLAYER(ptr);
float Speed = CHECK_FLOAT(L,1);
if (Speed<1 || Speed>255)
return 0;
plr->SetPlayerSpeed(RUN, Speed);
plr->SetPlayerSpeed(SWIM, Speed);
plr->SetPlayerSpeed(RUNBACK, Speed / 2);
plr->SetPlayerSpeed(FLY, Speed * 2);
return 0;
}
int GiveHonor(lua_State * L, Unit * ptr)
{
TEST_PLAYER()
Player * plr = TO_PLAYER(ptr);
uint32 honor = CHECK_ULONG(L,1);
plr->m_honorToday += honor;
plr->m_honorPoints += honor;
plr->RecalculateHonor();
return 0;
}
int TakeHonor(lua_State * L, Unit * ptr)
{
TEST_PLAYER()
Player * plr = TO_PLAYER(ptr);
uint32 honor = CHECK_ULONG(L,1);
if (plr->m_honorToday-honor < 0 || plr->m_honorPoints-honor < 0)
return 0;
plr->m_honorToday -= honor;
plr->m_honorPoints -= honor;
plr->RecalculateHonor();
return 0;
}
int GetStanding(lua_State * L, Unit * ptr)
{
TEST_PLAYER()
uint32 faction = luaL_checkint(L,1);
if (faction)
lua_pushinteger(L, TO_PLAYER(ptr)->GetStanding(faction));
return 0;
}
int RemoveThreatByPtr(lua_State * L, Unit * ptr)
{
TEST_UNIT()
Unit * target = CHECK_UNIT(L, 1);
if (target)
ptr->GetAIInterface()->RemoveThreatByPtr(target);
return 0;
}
int HasItem(lua_State * L, Unit * ptr)
{
TEST_PLAYER()
uint32 itemid = luaL_checkint(L,1);
if (itemid)
{
if (TO_PLAYER(ptr)->GetItemInterface()->GetItemCount(itemid,false) > 0)
lua_pushboolean(L,1);
else
lua_pushboolean(L,0);
}
return 1;
}
int PlaySpellVisual(lua_State * L, Unit * ptr)
{
uint64 guid = CHECK_GUID(L,1);
uint32 spell = luaL_checkint(L,2);
if (ptr && guid && spell)
{
WorldPacket data( SMSG_PLAY_SPELL_VISUAL, 12 );
data << guid;
data << uint32( spell );
ptr->SendMessageToSet(&data, ptr->IsPlayer());
}
return 1;
}
int GetLevel(lua_State * L, Unit * ptr)
{
if (!ptr) return 0;
lua_pushinteger(L, ptr->getLevel());
return 1;
}
int SetLevel(lua_State * L, Unit * ptr)
{
if (!ptr) return 0;
uint32 level = CHECK_ULONG(L,1);
if (level <= sWorld.m_levelCap && level > 0)
{
if (ptr->IsPlayer())
{
LevelInfo * Info = objmgr.GetLevelInfo(ptr->getRace(),ptr->getClass(),level);
if (Info)
TO_PLAYER(ptr)->ApplyLevelInfo(Info, level);
}
else
ptr->setLevel(level);
}
return 0;
}
int AddSkill(lua_State * L, Unit * ptr)
{
TEST_PLAYER()
uint32 skill = luaL_checkint(L,1);
uint32 current = luaL_checkint(L,2);
uint32 max = luaL_checkint(L,3);
Player * plr = TO_PLAYER(ptr);
if (!max)
max = 475;
if (current > max)
return 0;
plr->_AddSkillLine(skill,current,max);
plr->_UpdateMaxSkillCounts();
return 0;
}
int RemoveSkill(lua_State * L, Unit * ptr)
{
TEST_PLAYER()
uint32 skill = luaL_checkint(L,1);
if(!ptr || !skill)
return 0;
Player * plr = TO_PLAYER(ptr);
plr->_RemoveSkillLine(skill);
plr->_UpdateMaxSkillCounts();
return 0;
}
int FlyCheat(lua_State * L, Unit * ptr)
{
TEST_PLAYER()
bool enabled = CHECK_BOOL(L,1);
TO_PLAYER(ptr)->FlyCheat = enabled;
return 0;
}
int AdvanceSkill(lua_State * L, Unit * ptr)
{
TEST_PLAYER()
uint32 skill = luaL_checkint(L,1);
uint32 count = luaL_checkint(L,2);
Player * plr = TO_PLAYER(ptr);
if (skill && count)
{
if( plr->_HasSkillLine(skill))
plr->_AdvanceSkillLine(skill,count);
}
return 0;
}
int RemoveAurasByMechanic(lua_State * L, Unit * ptr)
{
TEST_UNITPLAYER()
uint32 mechanic = luaL_checkint(L,1);
bool hostileonly = CHECK_BOOL(L,2);
if(ptr && mechanic)
ptr->RemoveAllAurasByMechanic(mechanic,-1,hostileonly);
return 0;
}
int RemoveAurasType(lua_State * L, Unit * ptr)
{
TEST_UNITPLAYER()
uint32 type = luaL_checkint(L,1);
if (ptr && type)
ptr->RemoveAllAuraType(type);
return 0;
}
int AddAura(lua_State * L, Unit * ptr)
{
TEST_UNITPLAYER()
uint32 spellid = luaL_checkint(L,1);
uint32 duration = luaL_checkint(L,2);
bool temp = CHECK_BOOL(L,3);
if(ptr && spellid)
{
Aura * aura = new Aura(dbcSpell.LookupEntry(spellid), duration, ptr, ptr,temp);
ptr->AddAura(aura);
lua_pushboolean(L, 1);
}
else
lua_pushboolean(L,0);
return 1;
}
int SetAIState(lua_State * L, Unit * ptr)
{
TEST_UNIT()
uint32 state = luaL_checkint(L,1);
if(state)
{
switch(state)
{
case 0:
ptr->GetAIInterface()->SetAIState(STATE_IDLE);
break;
case 1:
ptr->GetAIInterface()->SetAIState(STATE_ATTACKING);
break;
case 2:
ptr->GetAIInterface()->SetAIState(STATE_CASTING);
break;
case 3:
ptr->GetAIInterface()->SetAIState(STATE_FLEEING);
break;
case 4:
ptr->GetAIInterface()->SetAIState(STATE_FOLLOWING);
break;
case 5:
ptr->GetAIInterface()->SetAIState(STATE_EVADE);
break;
case 6:
ptr->GetAIInterface()->SetAIState(STATE_MOVEWP);
break;
case 7:
ptr->GetAIInterface()->SetAIState(STATE_FEAR);
break;
case 8:
ptr->GetAIInterface()->SetAIState(STATE_WANDER);
break;
case 9:
ptr->GetAIInterface()->SetAIState(STATE_STOPPED);
break;
case 10:
ptr->GetAIInterface()->SetAIState(STATE_SCRIPTMOVE);
break;
case 11:
ptr->GetAIInterface()->SetAIState(STATE_SCRIPTIDLE);
break;
}
}
return 0;
}
int SetStealth(lua_State * L, Unit * ptr)
{
if (!ptr) return 0;
uint32 stealthlevel = CHECK_ULONG(L,1);
ptr->SetStealth(stealthlevel);
return 0;
}
int GetStealthLevel(lua_State * L, Unit * ptr)
{
if (!ptr) return 0;
lua_pushinteger(L,ptr->GetStealthLevel());
return 1;
}
int IsStealthed(lua_State * L, Unit * ptr)
{
if (!ptr) return 0;
if(ptr->IsStealth())
lua_pushboolean(L,1);
else
lua_pushboolean(L,0);
return 1;
}
int RemoveStealth(lua_State * L, Unit * ptr)
{
if (!ptr) return 0;
ptr->RemoveStealth();
return 0;
}
int InterruptSpell(lua_State * L, Unit * ptr)
{
if (!ptr) return 0;
ptr->InterruptSpell();
return 0;
}
int IsPoisoned(lua_State * L, Unit * ptr)
{
if (!ptr) return 0;
if(ptr->IsPoisoned())
lua_pushboolean(L,1);
else
lua_pushboolean(L,0);
return 1;
}
int RegisterAIUpdateEvent(lua_State * L, Unit * ptr)
{
TEST_UNIT()
uint32 time = luaL_checkint(L,1);
sEventMgr.AddEvent( TO_CREATURE(ptr), &Creature::CallScriptUpdate, EVENT_SCRIPT_UPDATE_EVENT,time,0,0);
return 0;
}
int ModifyAIUpdateEvent(lua_State * L, Unit * ptr)
{
TEST_UNIT()
uint32 newtime = luaL_checkint(L,1);
sEventMgr.ModifyEventTimeAndTimeLeft(ptr,EVENT_SCRIPT_UPDATE_EVENT,newtime);
return 0;
}
int RemoveAIUpdateEvent(lua_State * L, Unit * ptr)
{
TEST_UNIT()
sEventMgr.RemoveEvents(ptr, EVENT_SCRIPT_UPDATE_EVENT);
return 0;
}
int deleteWaypoint(lua_State * L, Unit * ptr)
{
TEST_UNIT()
uint32 wp = luaL_checkint(L,1);
if(ptr && wp)
TO_CREATURE(ptr)->GetAIInterface()->deleteWayPoint(wp);
return 0;
}
int DealGoldCost(lua_State * L, Unit * ptr)
{
TEST_PLAYER()
Player * plr = TO_PLAYER(ptr);
int32 debt = luaL_checkint(L,1);
if (debt < 0) return 0;
if (!plr->HasGold(debt))
lua_pushboolean(L, 0);
else
{
plr->ModGold(-debt);
lua_pushboolean(L,1);
}
return 1;
}
int DealGoldMerit(lua_State * L, Unit * ptr)
{
TEST_PLAYER()
uint32 profit = CHECK_ULONG(L,1);
TO_PLAYER(ptr)->ModGold(profit);
return 0;
}
int DeMorph(lua_State * L, Unit * ptr)
{
if (!ptr) return 0;
ptr->DeMorph();
return 0;
}
int Attack(lua_State * L, Unit * ptr)
{
TEST_UNIT()
Unit * target = CHECK_UNIT(L, 1);
if (target)
{
ptr->GetAIInterface()->WipeTargetList();
ptr->GetAIInterface()->ClearHateList();
ptr->GetAIInterface()->WipeCurrentTarget();
ptr->GetAIInterface()->taunt(target);
lua_pushboolean(L,1);
}
else
lua_pushboolean(L,0);
return 1;
}
int CanUseCommand(lua_State * L, Unit * ptr)
{
TEST_PLAYER()
char cmdlevel = (char)luaL_checkstring(L,1)[0];
Player * plr = TO_PLAYER(ptr);
if (plr->GetSession()->CanUseCommand(cmdlevel))
lua_pushboolean(L, 1);
else
lua_pushboolean(L, 0);
return 1;
}
int GetTarget(lua_State * L, Unit * ptr)
{
Log.Notice("LuaEngine", "GetTarget is outdated. Please use GetPrimaryCombatTarget.");
TEST_PLAYER()
Player * plr = TO_PLAYER(ptr);
Unit * target = plr->GetMapMgr()->GetUnit(plr->GetTarget());
if(target != NULL)
PUSH_UNIT(L,target);
else
lua_pushnil(L);
return 1;
}
int GetSelection(lua_State * L, Unit * ptr)
{
TEST_PLAYER()
Player * plr = TO_PLAYER(ptr);
Unit * selection = plr->GetMapMgr()->GetUnit(plr->GetSelection());
if (selection)
PUSH_UNIT(L,selection);
else
lua_pushnil(L);
return 1;
}
int GetSelectedGO(lua_State * L, Unit * ptr)
{
TEST_PLAYER()
Player * plr = TO_PLAYER(ptr);
PUSH_GO(L,plr->GetSelectedGo());
return 1;
}
int RepairAllPlayerItems(lua_State * L, Unit * ptr)
{
TEST_PLAYER_RET()
Player * plr = TO_PLAYER(ptr);
Item * pItem = NULL;
Container * pContainer = NULL;
uint32 j, i;
for( i = 0; i < MAX_INVENTORY_SLOT; i++ )
{
pItem = plr->GetItemInterface()->GetInventoryItem( i );
if( pItem != NULL )
{
if( pItem->IsContainer() )
{
pContainer = static_cast<Container*>( pItem );
for( j = 0; j < pContainer->GetProto()->ContainerSlots; ++j )
{
pItem = pContainer->GetItem( j );
if( pItem != NULL ){
pItem->SetDurabilityToMax();
}
}
}
else
{
if( pItem->GetProto()->MaxDurability > 0 && i < INVENTORY_SLOT_BAG_END && pItem->GetDurability() <= 0 )
{
pItem->SetDurabilityToMax();
plr->ApplyItemMods( pItem, i, true );
}
else
{
pItem->SetDurabilityToMax();
}
}
}
}
return 0;
}
int SetKnownTitle(lua_State * L, Unit * ptr)
{
TEST_PLAYER()
int title = luaL_checkint(L,1);
Player * plr = TO_PLAYER(ptr);
plr->SetKnownTitle(RankTitles(title),true);
plr->SaveToDB(false);
return 0;
}
int UnsetKnownTitle(lua_State * L, Unit * ptr)
{
TEST_PLAYER()
int title = luaL_checkint(L,1);
Player * plr = TO_PLAYER(ptr);
plr->SetKnownTitle( RankTitles(title), false );
plr->SaveToDB(false);
return 0;
}
int LifeTimeKills(lua_State * L, Unit * ptr)
{
TEST_PLAYER()
int kills = luaL_checkint(L, 1);
const char * check = luaL_checklstring(L,2,NULL);
Player * plr = TO_PLAYER(ptr);
int killscheck = plr->GetUInt32Value(PLAYER_FIELD_LIFETIME_HONORBALE_KILLS);
if (check && strncmp(check, "add", 4)==0 && kills > 0)
{
plr->SetUInt32Value(PLAYER_FIELD_LIFETIME_HONORBALE_KILLS, killscheck+kills);
plr->SaveToDB(false);
return 0;
}
else if (check && strncmp(check, "del", 4)==0 && killscheck >= kills)
{
plr->SetUInt32Value(PLAYER_FIELD_LIFETIME_HONORBALE_KILLS, killscheck-kills);
plr->SaveToDB(false);
return 0;
}
else if (check && strncmp(check, "set", 4)==0 && kills >= 0)
{
plr->SetUInt32Value(PLAYER_FIELD_LIFETIME_HONORBALE_KILLS, kills);
plr->SaveToDB(false);
return 0;
}
else if (check == NULL || kills == 0)
{
lua_pushinteger( L, killscheck );
return 1;
}
return 0;
}
int HasTitle(lua_State * L, Unit * ptr)
{
TEST_PLAYER()
int title = luaL_checkint(L, 1);
Player * plr = TO_PLAYER(ptr);
if (plr->HasTitle(RankTitles(title)) )
lua_pushboolean(L,1);
else
lua_pushboolean(L,0);
return 1;
}
int GetMaxSkill(lua_State * L, Unit * ptr)
{
TEST_PLAYER()
uint32 skill = luaL_checkint(L, 1);
lua_pushinteger(L, TO_PLAYER(ptr)->_GetSkillLineMax(skill));
return 1;
}
int GetCurrentSkill(lua_State * L, Unit * ptr)
{
TEST_PLAYER()
uint32 skill = luaL_checkint(L, 1);
lua_pushinteger(L, TO_PLAYER(ptr)->_GetSkillLineCurrent(skill));
return 1;
}
int HasSkill(lua_State * L, Unit * ptr)
{
TEST_PLAYER()
uint32 skill = luaL_checkint(L, 1);
lua_pushboolean(L, (TO_PLAYER(ptr)->_HasSkillLine(skill)) ? 1 : 0);
return 1;
}
int GetGuildName(lua_State * L, Unit * ptr)
{
TEST_PLAYER()
Guild * pGuild = objmgr.GetGuild(TO_PLAYER(ptr)->GetGuildId());
if(pGuild != NULL)
lua_pushstring(L,pGuild->GetGuildName());
else
lua_pushnil(L);
return 1;
}
int ClearCooldownForSpell(lua_State * L, Unit * ptr)
{
TEST_PLAYER()
Player * plr = TO_PLAYER(ptr);
plr->ClearCooldownForSpell(luaL_checkint(L, 1));
return 0;
}
int HasSpell(lua_State * L, Unit * ptr)
{
TEST_PLAYER()
uint32 sp = CHECK_ULONG(L,1);
lua_pushboolean(L, (sp && TO_PLAYER(ptr)->HasSpell(sp)) ? 1 : 0);
return 1;
}
int ClearAllCooldowns(lua_State * L, Unit * ptr)
{
TEST_PLAYER()
TO_PLAYER(ptr)->ResetAllCooldowns();
return 0;
}
int ResetAllTalents(lua_State * L, Unit * ptr)
{
TEST_PLAYER()
TO_PLAYER(ptr)->Reset_Talents();
return 0;
}
int GetAccountName(lua_State * L, Unit * ptr)
{
TEST_PLAYER()
const char * aName = TO_PLAYER(ptr)->GetSession()->GetAccountNameS();
lua_pushstring(L,aName);
return 1;
}
int GetGmRank(lua_State * L, Unit * ptr)
{
TEST_PLAYER()
const char * level = TO_PLAYER(ptr)->GetSession()->GetPermissions();
if(level != NULL)
lua_pushstring(L,level);
else
lua_pushnil(L);
return 1;
}
int IsGm(lua_State * L, Unit * ptr)
{
TEST_PLAYER()
if(TO_PLAYER(ptr)->GetSession()->HasGMPermissions())
lua_pushboolean(L,1);
else
lua_pushboolean(L,0);
return 1;
}
int SavePlayer(lua_State * L, Unit * ptr)
{
TEST_PLAYER()
TO_PLAYER(ptr)->SaveToDB(false);
return 0;
}
int HasQuest(lua_State * L, Unit * ptr)
{
TEST_PLAYER()
uint32 quest_id = CHECK_ULONG(L,1);
if (quest_id && TO_PLAYER(ptr)->HasQuest(quest_id))
lua_pushboolean(L,1);
else
lua_pushboolean(L,0);
return 1;
}
int CreatureHasQuest(lua_State * L, Unit * ptr)
{
TEST_UNIT()
Creature * ctr = TO_CREATURE(ptr);
uint32 questid = CHECK_ULONG(L,1);
Quest * qst = QuestStorage.LookupEntry(questid);
if (ctr->HasQuest(qst->id, qst->type))
lua_pushboolean(L,1);
else
lua_pushboolean(L,0);
return 1;
}
int RemovePvPFlag(lua_State * L, Unit * ptr)
{
TEST_PLAYER()
Player * plr = TO_PLAYER(ptr);
if(plr != NULL && plr->IsPvPFlagged())
plr->RemovePvPFlag();
return 0;
}
int RemoveNegativeAuras(lua_State * L, Unit * ptr)
{
if (!ptr) return 0;
ptr->RemoveNegativeAuras();
return 0;
}
int GossipMiscAction(lua_State * L, Unit * ptr)
{
Player* plr = TO_PLAYER(ptr);
Creature * crc = TO_CREATURE(CHECK_UNIT(L, 2));
uint32 miscint = (uint32)luaL_checkint(L, 3);
int actionid = luaL_checkint(L, 1);
if ( !plr || (!crc && actionid < 9) ) return 0;
if (actionid == 1) plr->GetSession()->SendInventoryList(crc);
else if (actionid == 2) plr->GetSession()->SendTrainerList(crc);
else if (actionid == 3) plr->GetSession()->SendInnkeeperBind(crc);
else if (actionid == 4) plr->GetSession()->SendBankerList(crc);
else if (actionid == 5) plr->GetSession()->SendBattlegroundList(crc,miscint);
else if (actionid == 6) plr->GetSession()->SendAuctionList(crc);
else if (actionid == 7) plr->GetSession()->SendTabardHelp(crc);
else if (actionid == 8) plr->GetSession()->SendSpiritHealerRequest(crc);
else if (actionid == 9) plr->SendTalentResetConfirm();
else if (actionid == 10) plr->SendPetUntrainConfirm();
return 0;
}
int SendVendorWindow(lua_State * L, Unit * ptr)
{
TEST_PLAYER()
Player* plr = TO_PLAYER(ptr);
Creature * object = TO_CREATURE(CHECK_UNIT(L, 1)); //NOT entry. The unit pointer.
if(plr != NULL && object != NULL)
plr->GetSession()->SendInventoryList(object);
return 0;
}
int SendTrainerWindow(lua_State * L, Unit * ptr)
{
TEST_PLAYER()
Player* plr = TO_PLAYER(ptr);
Creature * crc = TO_CREATURE(CHECK_UNIT(L, 1)); //NOT entry. The unit pointer.
if(crc != NULL)
plr->GetSession()->SendTrainerList(crc);
return 0;
}
int SendInnkeeperWindow(lua_State * L, Unit * ptr)
{
TEST_PLAYER()
Player* plr = TO_PLAYER(ptr);
Creature * crc = TO_CREATURE(CHECK_UNIT(L, 1)); //NOT entry. The unit pointer.
if(crc != NULL)
plr->GetSession()->SendInnkeeperBind(crc);
return 0;
}
int SendBankWindow(lua_State * L, Unit * ptr)
{
TEST_PLAYER()
Player* plr = TO_PLAYER(ptr);
Creature * crc = TO_CREATURE(CHECK_UNIT(L, 1)); //NOT entry. The unit pointer.
if(crc != NULL)
plr->GetSession()->SendBankerList(crc);
return 0;
}
int SendAuctionWindow(lua_State * L, Unit * ptr)
{
TEST_PLAYER()
Player* plr = TO_PLAYER(ptr);
Creature * crc = TO_CREATURE(CHECK_UNIT(L, 1)); //NOT entry. The unit pointer.
if(crc != NULL)
plr->GetSession()->SendAuctionList(crc);
return 0;
}
int SendBattlegroundWindow(lua_State * L, Unit * ptr)
{
TEST_PLAYER()
Player * plr = TO_PLAYER(ptr);
Creature * crc = TO_CREATURE(CHECK_UNIT(L,1));
uint32 bgid = luaL_checkint(L,2);
if(bgid && crc != NULL)
plr->GetSession()->SendBattlegroundList(crc, bgid); //player filler ftw
return 0;
}
int SendLootWindow(lua_State * L, Unit * ptr)
{
TEST_PLAYER()
uint64 guid = CHECK_GUID(L,1);
uint8 loot_type = (uint8)luaL_checkint(L,2);
uint8 loot_type2 = 1;
Player * plr = TO_PLAYER(ptr);
plr->SetLootGUID(guid);
uint32 guidtype = GET_TYPE_FROM_GUID(guid);
if (guidtype == HIGHGUID_TYPE_UNIT)
{
Unit* pUnit = plr->GetMapMgr()->GetUnit(guid);
CreatureProto * proto = TO_CREATURE(pUnit)->GetProto();
switch (loot_type)
{
default:
lootmgr.FillCreatureLoot(&pUnit->loot, pUnit->GetEntry(), pUnit->GetMapMgr() ? ( pUnit->GetMapMgr()->iInstanceMode ? true : false ) : false);
pUnit->loot.gold = proto ? proto->money : 0;
loot_type2 = 1;
break;
case 2:
lootmgr.FillSkinningLoot(&pUnit->loot, pUnit->GetEntry());
loot_type2 = 2;
break;
case 3:
lootmgr.FillPickpocketingLoot(&pUnit->loot, pUnit->GetEntry());
loot_type2 = 2;
break;
}
}
else if (guidtype == HIGHGUID_TYPE_GAMEOBJECT)
{
GameObject* pGO = plr->GetMapMgr()->GetGameObject(GET_LOWGUID_PART(guid));
switch (loot_type)
{
default:
lootmgr.FillGOLoot(&pGO->loot, pGO->GetEntry(), pGO->GetMapMgr() ? ( pGO->GetMapMgr()->iInstanceMode ? true : false ) : false);
loot_type2 = 1;
break;
case 5:
lootmgr.FillSkinningLoot(&pGO->loot, pGO->GetEntry());
loot_type2 = 2;
break;
}
}
else if(guidtype == HIGHGUID_TYPE_ITEM)
{
Item *pItem = plr->GetItemInterface()->GetItemByGUID(guid);
switch (loot_type)
{
case 6:
lootmgr.FillItemLoot(pItem->loot,pItem->GetEntry());
loot_type2 = 1;
break;
default:
break;
}
}
plr->SendLoot(guid, 2, plr->GetMapId());
return 0;
}
int AddLoot(lua_State * L, Unit * ptr)
{
TEST_UNIT()
uint32 itemid = luaL_checkint(L,1);
uint32 mincount = luaL_checkint(L,2);
uint32 maxcount = luaL_checkint(L,3);
uint32 ffa_loot = luaL_checkint(L,4);
bool perm = ((luaL_optint(L,5,0) == 1) ? true : false);
if (perm)
{
float chance = CHECK_FLOAT(L, 6);
QueryResult* result = WorldDatabase.Query("SELECT * FROM loot_creatures WHERE entryid = %u, itemid = %u", ptr->GetEntry(), itemid);
if (!result)
WorldDatabase.Execute("REPLACE INTO loot_creatures VALUES (%u, %u, %f, 0, 0, 0, %u, %u, %u)", ptr->GetEntry(), itemid, chance, mincount, maxcount, ffa_loot);
}
lootmgr.AddLoot(&ptr->loot,itemid,mincount,maxcount,ffa_loot);
return 0;
}
int VendorAddItem(lua_State * L, Unit * ptr)
{
TEST_UNIT()
Creature * ctr = TO_CREATURE(ptr);
uint32 itemid = (uint32)luaL_checknumber(L, 1);
uint32 amount = (uint32)luaL_checknumber(L, 2);
uint32 costid = (uint32)luaL_checknumber(L, 3);
ItemExtendedCostEntry * ec = (costid > 0) ? dbcItemExtendedCost.LookupEntryForced(costid) : NULL;
if (itemid && amount)
ctr->AddVendorItem(itemid, amount, ec);
return 0;
}
int VendorRemoveItem(lua_State * L, Unit * ptr)
{
TEST_UNIT()
Creature * ctr = TO_CREATURE(ptr);
uint32 itemid = (uint32)luaL_checknumber(L, 1);
int slot = ctr->GetSlotByItemId(itemid);
if(itemid && slot > 0)
ctr->RemoveVendorItem(itemid);
return 0;
}
int VendorRemoveAllItems(lua_State * L, Unit * ptr)
{
TEST_UNIT()
Creature * ctr = TO_CREATURE(ptr);
uint32 i = 0;
if (ctr->HasItems())
{
uint32 creatureitemids[200];
uint32 count = ctr->GetSellItemCount();
for(std::vector<CreatureItem>::iterator itr = ctr->GetSellItemBegin(); itr != ctr->GetSellItemEnd(); ++itr)
{
creatureitemids[i] = itr->itemid;
i+=1;
}
for (i=0; i<count; i++) {
ctr->RemoveVendorItem(creatureitemids[i]);
}
}
return 0;
}
int EquipWeapons(lua_State * L, Unit * ptr)
{
TEST_UNIT()
uint32 equip1 = luaL_checkint(L, 1);
uint32 equip2 = luaL_checkint(L, 2);
uint32 equip3 = luaL_checkint(L, 3);
ptr->SetEquippedItem(MELEE,equip1);
ptr->SetEquippedItem(OFFHAND,equip2);
ptr->SetEquippedItem(RANGED,equip3);
return 0;
}
int Dismount(lua_State * L, Unit * ptr)
{
if (!ptr) return 0;
if(ptr->IsPlayer())
{
Player * plr = TO_PLAYER(ptr);
plr->RemoveAura(plr->m_MountSpellId);
plr->SetUInt32Value( UNIT_FIELD_MOUNTDISPLAYID , 0);
}
else
ptr->SetUInt32Value( UNIT_FIELD_MOUNTDISPLAYID , 0);
return 0;
}
int GiveXp(lua_State * L, Unit * ptr)
{
TEST_PLAYER()
Player * pl = TO_PLAYER(ptr);
uint32 exp = luaL_checkint(L, 1);
pl->GiveXP(exp, pl->GetGUID(), true);
return 0;
}
int AdvanceAllSkills(lua_State * L, Unit * ptr)
{
TEST_PLAYER()
Player * plr = TO_PLAYER(ptr);
uint32 skillvalue = luaL_checkint(L, 1);
plr->_AdvanceAllSkills(skillvalue);
return 0;
}
int GetTeam(lua_State * L, Unit * ptr) //returns 0 for alliance, 1 for horde.
{
TEST_PLAYER()
Player * plr = TO_PLAYER(ptr);
lua_pushinteger(L, plr->GetTeam());
return 1;
}
int StartTaxi(lua_State * L, Unit * ptr)
{
TEST_PLAYER()
Player * plr = TO_PLAYER(ptr);
TaxiPath * tp = CHECK_TAXIPATH(L, 1);
uint32 mount_id = luaL_checkint(L, 2);
plr->TaxiStart(tp, mount_id, 0);
return 0;
}
int IsOnTaxi(lua_State * L, Unit * ptr)
{
TEST_PLAYER()
lua_pushboolean(L, TO_PLAYER(ptr)->GetTaxiState() ? 1 : 0);
return 1;
}
int GetTaxi(lua_State * L, Unit * ptr)
{
TEST_PLAYER()
PUSH_TAXIPATH(L, TO_PLAYER(ptr)->GetTaxiPath());
return 1;
}
int SetPlayerLock(lua_State * L, Unit * ptr)
{
TEST_PLAYER()
bool lock = CHECK_BOOL(L,1);
if (lock)
{
ptr->m_pacified = 1;
ptr->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_PACIFIED | UNIT_FLAG_SILENCED);
WorldPacket data1(9);
data1.Initialize( SMSG_CLIENT_CONTROL_UPDATE );
data1 << ptr->GetNewGUID() << uint8(0x00);
TO_PLAYER(ptr)->GetSession()->SendPacket(&data1);
}
else
{
ptr->m_pacified = 0;
ptr->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_PACIFIED | UNIT_FLAG_SILENCED);
WorldPacket data1(9);
data1.Initialize( SMSG_CLIENT_CONTROL_UPDATE );
data1 << ptr->GetNewGUID() << uint8(0x01);
TO_PLAYER(ptr)->GetSession()->SendPacket(&data1);
}
return 0;
}
int MovePlayerTo(lua_State * L, Unit * ptr)
{
TEST_PLAYER()
float x = CHECK_FLOAT(L,1);
float y = CHECK_FLOAT(L,2);
float z = CHECK_FLOAT(L,3);
float o = CHECK_FLOAT(L,4);
uint32 mov_flag = CHECK_ULONG(L,5); //0 - walk, 256 - teleport, 4096 - run, 12288 - fly
float moveSpeed = (float)luaL_optnumber(L,6,1.0f);
if (moveSpeed == 1.0f)
{
if (mov_flag == 0)
moveSpeed = 2.5f*0.001f;
else
moveSpeed = 7.0f*0.001f;
}
ptr->SetFacing(o);
ptr->SetOrientation(o);
float distance = ptr->CalcDistance(ptr->GetPositionX(), ptr->GetPositionY(), ptr->GetPositionZ(), x, y, z);
uint32 moveTime = uint32(distance / moveSpeed);
WorldPacket data(SMSG_MONSTER_MOVE, 50);
data << ptr->GetNewGUID();
data << uint8(0);
data << ptr->GetPositionX();
data << ptr->GetPositionY();
data << ptr->GetPositionZ();
data << getMSTime();
data << uint8(0x00);
data << uint32(mov_flag);
data << moveTime;
data << uint32(1);
data << x << y << z;
ptr->SendMessageToSet(&data, true);
ptr->SetPosition(x,y,z,o);
return 0;
}
int ChannelSpell(lua_State * L, Unit * ptr)
{
uint32 Csp = luaL_checkint(L, 1);
Object * target = CHECK_OBJECT(L, 2);
if (Csp && target != NULL)
{
ptr->CastSpell(target->GetGUID(),dbcSpell.LookupEntry(Csp),false);
ptr->SetChannelSpellTargetGUID( target->GetGUID());
ptr->SetChannelSpellId(Csp);
}
return 0;
}
int StopChannel(lua_State * L, Unit * ptr)
{
ptr->SetChannelSpellTargetGUID( 0);
ptr->SetChannelSpellId(0);
return 0;
}
//////////////////////////////////////////////////////////////////////////
// WORLDSTATES/WORLD PVP NOT SUPPORTED
//////////////////////////////////////////////////////////////////////////
/*
int SetWorldState(lua_State * L, Unit * ptr)
{
int zone = luaL_checkint(L, 1);
int index = luaL_checkint(L, 2);
int value = luaL_checkint(L, 3);
if(!zone || !index || !value)
lua_pushnil(L);
ptr->GetMapMgr()->SetWorldState(zone, index, value);
lua_pushboolean(L, 1);
return 1;
}
*/
int EnableFlight(lua_State * L, Unit * ptr)
{
TEST_PLAYER()
bool Switch = CHECK_BOOL(L,1);
if (Switch)
{
WorldPacket fly(835, 13);
ptr->EnableFlight();
fly << ptr->GetNewGUID();
fly << uint32(2);
ptr->SendMessageToSet(&fly, true);
}
else
{
WorldPacket fly(836, 13);
ptr->DisableFlight();
fly << ptr->GetNewGUID();
fly << uint32(5);
ptr->SendMessageToSet(&fly, true);
}
return 0;
}
int GetCoinage(lua_State * L, Unit * ptr)
{
TEST_PLAYER()
Player * plr = TO_PLAYER(ptr);
lua_pushinteger(L, plr->GetGold());
return 1;
}
int FlagPvP(lua_State * L, Unit * ptr)
{
TEST_PLAYER()
Player * plr = TO_PLAYER(ptr);
plr->SetPvPFlag();
return 0;
}
int IsMounted(lua_State * L, Unit * ptr)
{
if (!ptr) return 0;
if (ptr->IsPlayer())
{
Player * plr = TO_PLAYER(ptr);
if(plr != NULL && plr->IsMounted())
lua_pushboolean(L,1);
else
lua_pushboolean(L,0);
}
else
lua_pushboolean(L, (ptr->GetMount() > 0) ? 1 : 0);
return 1;
}
//credits to alvanaar for the following 9 functions:
int IsGroupedWith(lua_State * L, Unit * ptr)
{
TEST_PLAYER()
Player * target = CHECK_PLAYER(L,1);
if(ptr->GetGroup()->HasMember(target))
lua_pushboolean(L, 1);
else
lua_pushboolean(L, 0);
return 1;
}
int GetGroupType(lua_State * L, Unit * ptr)
{
TEST_PLAYER()
Player * plr = TO_PLAYER(ptr);
Group * group = plr->GetGroup();
if(group != NULL)
lua_pushinteger(L,group->GetGroupType() );
else
lua_pushnil(L);
return 1;
}
int GetTotalHonor(lua_State * L, Unit * ptr) // I loathe typing "honour" like "honor".
{
TEST_PLAYER()
lua_pushinteger(L, TO_PLAYER(ptr)->m_honorPoints);
return 1;
}
int GetHonorToday(lua_State * L, Unit * ptr)
{
TEST_PLAYER()
lua_pushinteger(L, TO_PLAYER(ptr)->m_honorToday);
return 1;
}
int GetHonorYesterday(lua_State * L, Unit * ptr)
{
TEST_PLAYER()
lua_pushinteger(L, TO_PLAYER(ptr)->m_honorYesterday);
return 1;
}
int GetArenaPoints(lua_State * L, Unit * ptr)
{
TEST_PLAYER()
lua_pushinteger(L, TO_PLAYER(ptr)->m_arenaPoints);
return 1;
}
int AddArenaPoints(lua_State * L, Unit * ptr)
{
TEST_PLAYER()
uint32 pnts = luaL_checkint(L, 1);
Player* plr = TO_PLAYER(ptr);
if (pnts)
{
plr->m_arenaPoints += pnts;
plr->RecalculateHonor();
}
return 0;
}
int RemoveArenaPoints(lua_State * L, Unit * ptr)
{
TEST_PLAYER()
uint32 pnts = luaL_checkint(L, 1);
Player* plr = TO_PLAYER(ptr);
int32 npts = plr->m_arenaPoints-pnts;
if(npts >= 0)
{
plr->m_arenaPoints = npts;
plr->RecalculateHonor();
}
return 0;
}
int AddLifetimeKills(lua_State * L, Unit * ptr)
{
TEST_PLAYER()
uint32 pnts = luaL_checkint(L, 1);
Player * plr = TO_PLAYER(ptr);
plr->m_killsLifetime += pnts;
return 0;
}
int GetGender(lua_State * L, Unit * ptr)
{
if (!ptr) return 0;
lua_pushinteger(L, ptr->getGender());
return 1;
}
int SetGender(lua_State * L, Unit * ptr)
{
if (!ptr) return 0;
uint8 gender = luaL_checkint(L,1);
ptr->setGender(gender);
return 0;
}
//next 5 credits: alvanaar
int SendPacketToGuild(lua_State * L, Unit * ptr)
{
TEST_PLAYER()
WorldPacket * data = CHECK_PACKET(L,1);
Player* plr = TO_PLAYER(ptr);
Guild* guild = plr->GetGuild();
if (data != NULL && guild != NULL)
guild->SendPacket(data);
return 0;
}
int GetGuildId(lua_State * L, Unit * ptr)
{
TEST_PLAYER()
Player* plr = TO_PLAYER(ptr);
if (plr->GetGuild() != NULL)
lua_pushinteger(L, plr->GetGuildId());
else
lua_pushnil(L);
return 1;
}
int GetGuildRank(lua_State * L, Unit * ptr)
{
TEST_PLAYER()
Player * plr = TO_PLAYER(ptr);
if (plr->GetGuild() != NULL)
lua_pushinteger(L, plr->GetGuildRank());
else
lua_pushnil(L);
return 1;
}
int SetGuildRank(lua_State * L, Unit * ptr)
{
TEST_PLAYER()
Player* plr = TO_PLAYER(ptr);
int rank = luaL_checkint(L, 1);
if(plr->IsInGuild() )
plr->SetGuildRank(rank);
return 0;
}
int IsInGuild(lua_State * L, Unit * ptr)
{
TEST_PLAYER()
Player* plr = TO_PLAYER(ptr);
if(plr->IsInGuild())
lua_pushboolean(L, 1);
else
lua_pushboolean(L, 0);
return 1;
}
int SendGuildInvite(lua_State * L, Unit * ptr)
{
TEST_PLAYER()
Player * sender = TO_PLAYER(ptr);
Player * plyr = CHECK_PLAYER(L,1);
std::string inviteeName = plyr->GetName();
Guild *pGuild = sender->getPlayerInfo()->guild;
if(!plyr)
{
Guild::SendGuildCommandResult(sender->GetSession(), GUILD_INVITE_S,inviteeName.c_str(),GUILD_PLAYER_NOT_FOUND);
}
else if(!pGuild)
{
Guild::SendGuildCommandResult(sender->GetSession(), GUILD_CREATE_S,"",GUILD_PLAYER_NOT_IN_GUILD);
}
else if( plyr->GetGuildId() )
{
Guild::SendGuildCommandResult(sender->GetSession(), GUILD_INVITE_S,plyr->GetName(),ALREADY_IN_GUILD);
}
else if( plyr->GetGuildInvitersGuid())
{
Guild::SendGuildCommandResult(sender->GetSession(), GUILD_INVITE_S,plyr->GetName(),ALREADY_INVITED_TO_GUILD);
}
else if(plyr->GetTeam()!=sender->GetTeam() && sender->GetSession()->GetPermissionCount() == 0 && !sWorld.interfaction_guild)
{
Guild::SendGuildCommandResult(sender->GetSession(), GUILD_INVITE_S,"",GUILD_NOT_ALLIED);
}
else {
Guild::SendGuildCommandResult(sender->GetSession(), GUILD_INVITE_S,inviteeName.c_str(),GUILD_U_HAVE_INVITED);
WorldPacket data(SMSG_GUILD_INVITE, 100);
data << sender->GetName();
data << pGuild->GetGuildName();
plyr->GetSession()->SendPacket(&data);
plyr->SetGuildInvitersGuid( sender->GetLowGUID() );
}
return 0;
}
int DemoteGuildMember(lua_State * L, Unit * ptr)
{
TEST_PLAYER()
Player * plr = TO_PLAYER(ptr);
Player * target = CHECK_PLAYER(L,1);
if (target)
plr->GetGuild()->DemoteGuildMember(target->getPlayerInfo(), plr->GetSession());
return 0;
}
int PromoteGuildMember(lua_State * L, Unit * ptr)
{
TEST_PLAYER()
Player * plr = TO_PLAYER(ptr);
Player * target = CHECK_PLAYER(L,1);
if (target)
plr->GetGuild()->PromoteGuildMember(target->getPlayerInfo(), plr->GetSession());
return 0;
}
int SetGuildMotd(lua_State * L, Unit * ptr)
{
TEST_PLAYER()
Player * plr = TO_PLAYER(ptr);
const char * szNewMotd = luaL_checkstring(L,1);
if (szNewMotd != NULL)
plr->GetGuild()->SetMOTD(szNewMotd, plr->GetSession());
return 0;
}
int GetGuildMotd(lua_State * L, Unit * ptr)
{
TEST_PLAYER()
Player * plr = TO_PLAYER(ptr);
if(plr->GetGuild() != NULL)
lua_pushstring(L,plr->GetGuild()->GetMOTD());
else
lua_pushnil(L);
return 1;
}
int SetGuildInformation(lua_State * L, Unit * ptr)
{
TEST_PLAYER()
Player * plr = TO_PLAYER(ptr);
const char * gi = luaL_checkstring(L,1);
if (gi)
plr->GetGuild()->SetGuildInformation(gi, plr->GetSession());
return 0;
}
int AddGuildMember(lua_State * L, Unit * ptr)
{
TEST_PLAYER()
Player * plr = TO_PLAYER(ptr);
Player * target = CHECK_PLAYER(L,1);
int32 rank = luaL_optinteger(L, 2, -1);
if (target)
plr->GetGuild()->AddGuildMember(target->getPlayerInfo(), plr->GetSession(), rank);
return 0;
}
int RemoveGuildMember(lua_State * L, Unit * ptr)
{
TEST_PLAYER()
Player * plr = TO_PLAYER(ptr);
Player * target = CHECK_PLAYER(L,1);
if (target)
plr->GetGuild()->RemoveGuildMember(target->getPlayerInfo(), plr->GetSession());
return 0;
}
int SetPublicNote(lua_State * L, Unit * ptr)
{
TEST_PLAYER()
Player * plr = TO_PLAYER(ptr);
Player * target = CHECK_PLAYER(L,1);
const char * note = luaL_checkstring(L,2);
if (target && note)
plr->GetGuild()->SetPublicNote(target->getPlayerInfo(), note, plr->GetSession());
return 0;
}
int SetOfficerNote(lua_State * L, Unit * ptr)
{
TEST_PLAYER()
Player * plr = TO_PLAYER(ptr);
Player * target = CHECK_PLAYER(L,1);
const char * note = luaL_checkstring(L,2);
if (target && note)
plr->GetGuild()->SetOfficerNote(target->getPlayerInfo(), note, plr->GetSession());
return 0;
}
int DisbandGuild(lua_State * L, Unit * ptr)
{
TEST_PLAYER()
Player * plr = TO_PLAYER(ptr);
if (plr->GetGuild() != NULL)
plr->GetGuild()->Disband();
return 0;
}
int ChangeGuildMaster(lua_State * L, Unit * ptr)
{
TEST_PLAYER()
Player * plr = TO_PLAYER(ptr);
Player * target = CHECK_PLAYER(L,1);
if (target)
plr->GetGuild()->ChangeGuildMaster(target->getPlayerInfo(), plr->GetSession());
return 0;
}
int SendGuildChatMessage(lua_State * L, Unit * ptr)
{
TEST_PLAYER()
Player * plr = TO_PLAYER(ptr);
const char * message = luaL_checkstring(L,1);
bool officer = CHECK_BOOL(L,2);
if(plr->GetGuild() != NULL && message != NULL)
(officer) ? plr->GetGuild()->OfficerChat(message, plr->GetSession(), 0) : plr->GetGuild()->GuildChat(message, plr->GetSession(), 0);
return 0;
}
int SendGuildLog(lua_State * L, Unit * ptr)
{
TEST_PLAYER()
Player * plr = TO_PLAYER(ptr);
if (plr->GetGuild() != NULL)
plr->GetGuild()->SendGuildLog(plr->GetSession());
return 0;
}
int GuildBankDepositMoney(lua_State * L, Unit * ptr)
{
TEST_PLAYER()
Player * plr = TO_PLAYER(ptr);
uint32 amount = luaL_checkint(L,1);
if (plr->GetGuild() != NULL)
plr->GetGuild()->DepositMoney(plr->GetSession(), amount);
return 0;
}
int GuildBankWithdrawMoney(lua_State * L, Unit * ptr)
{
TEST_PLAYER()
Player * plr = TO_PLAYER(ptr);
uint32 amount = luaL_checkint(L,1);
if (plr->GetGuild() != NULL)
plr->GetGuild()->WithdrawMoney(plr->GetSession(), amount);
return 0;
}
int SetByteValue(lua_State * L, Unit * ptr)
{
uint32 index = luaL_checkint(L,1);
uint32 index1 = luaL_checkint(L,2);
uint8 value = luaL_checkint(L,3);
ptr->SetByte(index,index1,value);
return 0;
}
int GetByteValue(lua_State * L, Unit * ptr)
{
uint32 index = luaL_checkint(L,1);
uint32 index1 = luaL_checkint(L,2);
lua_pushinteger(L,ptr->GetByte(index,index1));
return 1;
}
int IsPvPFlagged(lua_State * L, Unit * ptr)
{
TEST_PLAYER()
lua_pushboolean(L,TO_PLAYER(ptr)->IsPvPFlagged() ? 1 : 0);
return 1;
}
int IsFFAPvPFlagged(lua_State * L, Unit * ptr)
{
TEST_PLAYER()
lua_pushboolean(L,TO_PLAYER(ptr)->IsFFAPvPFlagged() ? 1 : 0);
return 1;
}
int GetGuildLeader(lua_State * L, Unit * ptr)
{
TEST_PLAYER()
Guild * pGuild = TO_PLAYER(ptr)->GetGuild();
if(pGuild != NULL)
{
Player * plr = objmgr.GetPlayer(pGuild->GetGuildLeader());
if (plr != NULL)
lua_pushstring(L,plr->GetName());
else
lua_pushnil(L);
}
else
lua_pushnil(L);
return 1;
}
int GetGuildMemberCount(lua_State * L, Unit * ptr)
{
TEST_PLAYER()
Guild * pGuild = TO_PLAYER(ptr)->GetGuild();
(pGuild != NULL) ? lua_pushinteger(L,pGuild->GetNumMembers()) : lua_pushnil(L);
return 1;
}
int IsFriendly(lua_State * L, Unit * ptr)
{
Unit * obj = CHECK_UNIT(L,1);
if (!obj || !ptr) return 0;
if (isFriendly(ptr, obj))
lua_pushboolean(L,1);
else
lua_pushboolean(L,0);
return 1;
}
int IsInChannel(lua_State * L, Unit * ptr)
{
TEST_PLAYER()
const char* channel_name = luaL_checkstring(L, 1);
if(!ptr || !channel_name)
return 0;
Channel* pChannel = channelmgr.GetChannel(channel_name, TO_PLAYER(ptr));
if(pChannel->HasMember(TO_PLAYER(ptr))) // Channels: "General", "Trade", "LocalDefense", "GuildRecruitment", "LookingForGroup", (or any custom channel)
lua_pushboolean(L, 1);
else
lua_pushboolean(L, 0);
return 1;
}
int JoinChannel(lua_State * L, Unit * ptr)
{
TEST_PLAYER()
const char* channel_name = luaL_checkstring(L, 1);
Channel* pChannel = channelmgr.GetChannel(channel_name, TO_PLAYER(ptr));
const char* pw = luaL_optstring(L, 2, pChannel->m_password.c_str());
if(!ptr || !channel_name || pChannel->HasMember(TO_PLAYER(ptr)) || !pChannel)
return 0;
else
pChannel->AttemptJoin(TO_PLAYER(ptr), pw);
return 1;
}
int LeaveChannel(lua_State * L, Unit * ptr)
{
TEST_PLAYER()
const char* channel_name = luaL_checkstring(L, 1);
Channel* pChannel = channelmgr.GetChannel(channel_name, TO_PLAYER(ptr));
if(!ptr || !channel_name || !pChannel || !pChannel->HasMember(TO_PLAYER(ptr)))
return 0;
else
pChannel->Part(TO_PLAYER(ptr), true);
return 1;
}
int SetChannelName(lua_State * L, Unit * ptr)
{
TEST_PLAYER()
const char* current_name = luaL_checkstring(L, 1);
const char* new_name = luaL_checkstring(L, 2);
Channel* pChannel = channelmgr.GetChannel(current_name, TO_PLAYER(ptr));
if(!current_name || !new_name || !ptr || !pChannel || pChannel->m_name == new_name)
return 0;
pChannel->m_name = new_name;
return 1;
}
int SetChannelPassword(lua_State * L, Unit * ptr)
{
TEST_PLAYER()
const char* channel_name = luaL_checkstring(L, 1);
const char* pass = luaL_checkstring(L, 2);
Channel* pChannel = channelmgr.GetChannel(channel_name, TO_PLAYER(ptr));
if(!pass || !ptr || pChannel->m_password == pass)
return 0;
pChannel->Password(TO_PLAYER(ptr), pass);
return 1;
}
int GetChannelPassword(lua_State * L, Unit * ptr)
{
TEST_PLAYER()
const char* channel_name = luaL_checkstring(L, 1);
Channel* pChannel = channelmgr.GetChannel(channel_name, TO_PLAYER(ptr));
if(!ptr)
return 0;
lua_pushstring(L, pChannel->m_password.c_str());
return 1;
}
int KickFromChannel(lua_State * L, Unit * ptr)
{
TEST_PLAYER()
const char* channel_name = luaL_checkstring(L, 1);
Player* plr = TO_PLAYER(ptr);
Channel* pChannel = channelmgr.GetChannel(channel_name, plr);
if(!plr || !pChannel)
return 0;
pChannel->Kick(plr, plr, false);
return 1;
}
int BanFromChannel(lua_State * L, Unit * ptr)
{
TEST_PLAYER()
const char* channel_name = luaL_checkstring(L, 1);
Player* plr = TO_PLAYER(ptr);
Channel* pChannel = channelmgr.GetChannel(channel_name, plr);
if(!plr|| !pChannel)
return 0;
pChannel->Kick(plr, plr, true);
return 1;
}
int UnbanFromChannel(lua_State * L, Unit * ptr)
{
TEST_PLAYER()
const char* channel_name = luaL_checkstring(L, 1);
Player* plr = TO_PLAYER(ptr);
Channel* pChannel = channelmgr.GetChannel(channel_name, plr);
if(!plr || !pChannel)
return 0;
pChannel->Unban(plr, plr->getPlayerInfo());
return 1;
}
int GetChannelMemberCount(lua_State * L, Unit * ptr)
{
TEST_PLAYER()
const char* channel_name = luaL_checkstring(L, 1);
if(!ptr || !channel_name)
return 0;
lua_pushnumber(L, channelmgr.GetChannel(channel_name, TO_PLAYER(ptr))->GetNumMembers());
return 1;
}
int GetPlayerMovementVector(lua_State * L, Unit * ptr)
{
TEST_PLAYER()
Player * plr = TO_PLAYER(ptr);
MovementInfo * movement_info = plr->GetSession()->GetMovementInfo();
if(movement_info != NULL)
{
lua_newtable(L);
lua_pushstring(L, "x");
lua_pushnumber(L, movement_info->x);
lua_rawset(L, -3);
lua_pushstring(L, "y");
lua_pushnumber(L, movement_info->y);
lua_rawset(L, -3);
lua_pushstring(L, "z");
lua_pushnumber(L, movement_info->z);
lua_rawset(L, -3);
lua_pushstring(L, "o");
lua_pushnumber(L, movement_info->orientation);
lua_rawset(L, -3);
}
else
lua_pushnil(L);
return 1;
}
int GetPlayerMovementFlags(lua_State * L, Unit * ptr)
{
TEST_PLAYER()
MovementInfo * move_info = TO_PLAYER(ptr)->GetSession()->GetMovementInfo();
if (move_info != NULL)
lua_pushnumber(L, move_info->flags);
else
RET_NIL()
return 1;
}
int Repop(lua_State * L, Unit * ptr)
{
TEST_PLAYER()
Player * plr = TO_PLAYER(ptr);
if (plr->IsDead())
plr->RepopRequestedPlayer();
return 0;
}
int SetMovementFlags(lua_State * L, Unit * ptr)
{
TEST_UNIT()
int movetype = luaL_checkint(L,1); //0: walk, 1: run, 2: fly.
if (movetype == 2)
{
ptr->GetAIInterface()->m_moveFly = true;
ptr->GetAIInterface()->m_moveRun = false;
ptr->GetAIInterface()->m_moveSprint = false;
}
else if (movetype == 1)
{
ptr->GetAIInterface()->m_moveFly = false;
ptr->GetAIInterface()->m_moveRun = true;
ptr->GetAIInterface()->m_moveSprint = false;
}
else
{
ptr->GetAIInterface()->m_moveFly = false;
ptr->GetAIInterface()->m_moveRun = false;
ptr->GetAIInterface()->m_moveSprint = false;
}
return 0;
}
int GetSpawnId(lua_State * L, Unit * ptr)
{
TEST_UNIT()
Creature * cre = TO_CREATURE(ptr);
lua_pushnumber(L,cre->GetSQL_id());
return 1;
}
int ResetTalents(lua_State * L, Unit * ptr)
{
TEST_PLAYER()
Player * plr = TO_PLAYER(ptr);
plr->Reset_Talents();
return 0;
}
int SetTalentPoints(lua_State * L, Unit * ptr)
{
TEST_PLAYER()
uint32 spec = luaL_checkint(L,1); //0 or 1
uint32 points = luaL_checkint(L,2);
TO_PLAYER(ptr)->m_specs[spec].m_customTalentPointOverride = points;
return 0;
}
int GetTalentPoints(lua_State * L, Unit * ptr)
{
TEST_PLAYER()
uint32 spec = luaL_checkint(L,1); //0 or 1
PlayerSpec plrSpec = TO_PLAYER(ptr)->m_specs[spec];
uint32 Lvl = TO_PLAYER(ptr)->getLevel();
uint32 FreePoints = 0;
if (Lvl > 9)
{
FreePoints = plrSpec.m_customTalentPointOverride > 0 ? plrSpec.m_customTalentPointOverride : Lvl - 9; // compensate for additional given talentpoints
for (std::map<uint32, uint8>::iterator itr = plrSpec.talents.begin(); itr != plrSpec.talents.end(); ++itr)
FreePoints -= (itr->second+1);
}
lua_pushnumber(L,FreePoints);
return 1;
}
int EventChat(lua_State * L, Unit * ptr)
{
TEST_UNIT()
uint8 typ = luaL_checkint(L,1);
uint32 lang = luaL_checkint(L,2);
const char* message = luaL_checkstring(L,3);
uint32 delay = luaL_checkint(L,4);
if (message != NULL && delay)
sEventMgr.AddEvent(ptr, &Unit::SendChatMessage, typ, lang, message, EVENT_UNIT_CHAT_MSG, delay, 1, EVENT_FLAG_DO_NOT_EXECUTE_IN_WORLD_CONTEXT);
return 0;
}
int GetEquippedItemBySlot(lua_State * L, Unit * ptr)
{
TEST_PLAYER()
int16 slot = luaL_checkint(L,1);
Player * plr = TO_PLAYER(ptr);
Item * pItem = plr->GetItemInterface()->GetInventoryItem(slot);
if (pItem)
PUSH_ITEM(L,pItem);
else
lua_pushnil(L);
return 1;
}
int GetGuildMembers(lua_State * L, Unit * ptr)
{
TEST_PLAYER()
Player* plr = TO_PLAYER(ptr);
Guild* pGuild = plr->GetGuild();
uint32 count = 0;
lua_newtable(L);
if(pGuild != NULL)
{
GuildMemberMap::iterator itr;
pGuild->getLock().Acquire();
for(itr = pGuild->GetGuildMembersBegin(); itr != pGuild->GetGuildMembersEnd(); ++itr)
{
count++;
lua_pushinteger(L, count);
//Paroxysm : Why do we push player names are opposed to objects?
//hyper: because guild members might not be logged in
//ret = (*itr).first->m_loggedInPlayer;
//PUSH_UNIT(L, ((Unit*)ret), false);
lua_pushstring(L, (*itr).first->name);
lua_rawset(L, -3);
}
pGuild->getLock().Release();
}
else
lua_pushnil(L);
return 1;
}
#ifdef ENABLE_ACHIEVEMENTS
int AddAchievement(lua_State * L, Unit * ptr)
{
TEST_PLAYER()
int32 achievementID = luaL_checkint(L,1);
Player * plr = TO_PLAYER(ptr);
if (plr->GetAchievementMgr().GMCompleteAchievement(NULL, achievementID))
lua_pushboolean(L, 1);
else
lua_pushboolean(L, 0);
return 1;
}
int RemoveAchievement(lua_State * L, Unit * ptr)
{
TEST_PLAYER()
int32 achievementID = luaL_checkint(L,1);
TO_PLAYER(ptr)->GetAchievementMgr().GMResetAchievement(achievementID);
return 0;
}
int HasAchievement(lua_State * L, Unit * ptr)
{
TEST_PLAYER()
uint32 achievementID = luaL_checkint(L,1);
lua_pushboolean(L, TO_PLAYER(ptr)->GetAchievementMgr().HasCompleted(achievementID) ? 1 : 0);
return 1;
}
#endif
int GetAreaId(lua_State * L, Unit * ptr)
{
TEST_UNITPLAYER_RET();
RET_NUMBER(ptr->GetMapMgr()->GetAreaID(ptr->GetPositionX(), ptr->GetPositionY() ) );
}
int ResetPetTalents(lua_State * L, Unit * ptr)
{
TEST_PLAYER()
Pet * pet = TO_PLAYER(ptr)->GetSummon();
if (pet != NULL)
{
pet->WipeTalents();
pet->SetTPs(pet->GetTPsForLevel(pet->getLevel()));
pet->SendTalentsToOwner();
}
return 0;
}
int IsDazed(lua_State * L, Unit * ptr)
{
TEST_UNITPLAYER_RET();
lua_pushboolean(L,(ptr->IsDazed())?1:0);
return 1;
}
int GetAura(lua_State * L, Unit * ptr)
{
TEST_UNITPLAYER_RET();
uint32 slot = CHECK_ULONG(L,1);
if (slot > MAX_TOTAL_AURAS_START && slot < MAX_TOTAL_AURAS_END)
RET_NUMBER(ptr->m_auras[slot]->GetSpellId());
RET_NIL()
}
int GetAuraObject(lua_State * L, Unit * ptr)
{
TEST_UNITPLAYER_RET();
uint32 slot = CHECK_ULONG(L,1);
if (slot > MAX_TOTAL_AURAS_START && slot < MAX_TOTAL_AURAS_END)
{
PUSH_AURA(L, ptr->m_auras[slot]);
return 1;
}
RET_NIL()
}
int IsRooted(lua_State * L, Unit * ptr)
{
TEST_UNITPLAYER_RET();
if(ptr->isRooted() )
RET_BOOL(true)
RET_BOOL(false)
}
int HasAuraWithMechanic(lua_State * L, Unit * ptr)
{
TEST_UNITPLAYER_RET();
uint32 mechanic = CHECK_ULONG(L,1);
if(mechanic && ptr->HasAuraWithMechanics(mechanic) )
RET_BOOL(true)
RET_BOOL(false)
}
int HasNegativeAura(lua_State * L, Unit * ptr)
{
TEST_UNITPLAYER_RET();
for (uint32 x = MAX_NEGATIVE_VISUAL_AURAS_START; x < MAX_NEGATIVE_VISUAL_AURAS_END; ++x)
{
if (ptr->m_auras[x] && ptr->m_auras[x]->m_spellProto)
RET_BOOL(true)
}
RET_BOOL(false)
}
int HasPositiveAura(lua_State * L, Unit * ptr)
{
TEST_UNITPLAYER()
for (uint32 x = MAX_POSITIVE_VISUAL_AURAS_START; x < MAX_POSITIVE_VISUAL_AURAS_END; ++x)
{
if (ptr->m_auras[x] && ptr->m_auras[x]->m_spellProto)
RET_BOOL(true)
}
RET_BOOL(false)
}
int GetClosestEnemy(lua_State * L, Unit * ptr)
{
TEST_UNITPLAYER()
float closest_dist = 99999.99f;
float current_dist = 0;
Object * closest_unit = NULL;
Unit * ret = NULL;
for (set<Object*>::iterator itr = ptr->GetInRangeSetBegin(); itr != ptr->GetInRangeSetEnd(); ++itr)
{
closest_unit = (*itr);
if(!closest_unit->IsUnit() || !isHostile(ptr,closest_unit) )
continue;
current_dist = ptr->GetDistance2dSq(closest_unit);
if(current_dist < closest_dist)
{
closest_dist = current_dist;
ret = TO_UNIT(closest_unit);
}
}
PUSH_UNIT(L,ret);
return 1;
}
int GetClosestFriend(lua_State * L, Unit * ptr)
{
TEST_UNITPLAYER()
float closest_dist = 99999.99f;
float current_dist = 0.0f;
Object * closest_unit = NULL;
Unit * ret = NULL;
for (set<Object*>::iterator itr = ptr->GetInRangeSetBegin(); itr != ptr->GetInRangeSetEnd(); ++itr)
{
closest_unit = (*itr);
if (!closest_unit->IsUnit() || isHostile(closest_unit, ptr))
continue;
current_dist = closest_unit->GetDistanceSq(ptr);
if(current_dist < closest_dist)
{
closest_dist = current_dist;
ret = TO_UNIT(closest_unit);
}
}
PUSH_UNIT(L,ret);
return 1;
}
int GetClosestUnit(lua_State * L, Unit * ptr)
{
TEST_UNITPLAYER()
float closest_dist = 99999.99f;
float current_dist = 0;
Object * closest_unit = NULL;
Unit * ret = NULL;
for (set<Object*>::iterator itr = ptr->GetInRangeSetBegin(); itr != ptr->GetInRangeSetEnd(); ++itr)
{
closest_unit = (*itr);
if(!closest_unit->IsUnit())
continue;
current_dist = ptr->GetDistance2dSq(closest_unit);
if(current_dist < closest_dist)
{
closest_dist = current_dist;
ret = TO_UNIT(closest_unit);
}
}
PUSH_UNIT(L,ret);
return 1;
}
int GetObjectType(lua_State * L, Unit * ptr)
{
TEST_UNITPLAYER()
if (ptr->IsPlayer())
lua_pushstring(L, "Player");
else
lua_pushstring(L, "Unit");
return 1;
}
int GetCurrentWaypoint(lua_State * L, Unit * ptr)
{
TEST_UNIT()
RET_NUMBER(ptr->GetAIInterface()->getCurrentWaypoint());
}
int DisableMelee(lua_State * L, Unit * ptr)
{
TEST_UNIT_RET()
bool disable = CHECK_BOOL(L,1);
TO_CREATURE(ptr)->GetAIInterface()->disable_melee = disable;
RET_BOOL(true)
}
int DisableSpells(lua_State * L, Unit * ptr)
{
TEST_UNIT_RET()
bool disable = CHECK_BOOL(L,1);
TO_CREATURE(ptr)->GetAIInterface()->disable_spell = disable;
RET_BOOL(true)
}
int DisableRanged(lua_State * L, Unit * ptr)
{
TEST_UNIT_RET()
bool disable = CHECK_BOOL(L,1);
TO_CREATURE(ptr)->GetAIInterface()->disable_ranged = disable;
RET_BOOL(true)
}
int DisableCombat(lua_State * L, Unit * ptr)
{
TEST_UNIT_RET()
bool disable = CHECK_BOOL(L,1);
TO_CREATURE(ptr)->GetAIInterface()->disable_combat = disable;
RET_BOOL(true)
}
int DisableTargeting(lua_State * L, Unit * ptr)
{
TEST_UNIT_RET()
bool disable = CHECK_BOOL(L,1);
TO_CREATURE(ptr)->GetAIInterface()->disable_targeting = disable;
RET_BOOL(true)
}
int IsInGroup(lua_State * L, Unit * ptr)
{
TEST_PLAYER_RET()
if(TO_PLAYER(ptr)->InGroup() )
RET_BOOL(true)
RET_BOOL(false)
}
int GetLocation(lua_State * L, Unit * ptr)
{
TEST_UNITPLAYER()
lua_pushnumber(L,ptr->GetPositionX());
lua_pushnumber(L,ptr->GetPositionY());
lua_pushnumber(L,ptr->GetPositionZ());
lua_pushnumber(L,ptr->GetOrientation());
return 4;
}
int GetByte(lua_State * L, Unit * ptr)
{
TEST_UNITPLAYER()
uint32 index = luaL_checkint(L,1);
uint32 index2 = luaL_checkint(L,2);
uint8 value = ptr->GetByte(index,index2);
RET_INT(value);
}
int SetByte(lua_State * L, Unit * ptr)
{
TEST_UNITPLAYER_RET();
int index = luaL_checkint(L,1);
int index2 = luaL_checkint(L,2);
uint8 value = luaL_checkint(L,3);
ptr->SetByte(index,index2,value);
RET_BOOL(true)
}
int GetSpawnLocation(lua_State * L, Unit * ptr)
{
TEST_UNIT();
lua_pushnumber(L,ptr->GetSpawnX());
lua_pushnumber(L,ptr->GetSpawnY());
lua_pushnumber(L,ptr->GetSpawnZ());
lua_pushnumber(L,ptr->GetSpawnO());
return 4;
}
int GetObject(lua_State * L, Unit * ptr)
{
TEST_UNIT();
uint64 guid = CHECK_GUID(L,1);
Object * obj = ptr->GetMapMgr()->_GetObject(guid);
if(obj != NULL && obj->IsUnit() )
PUSH_UNIT(L,obj);
else if(obj != NULL && obj->IsGameObject() )
PUSH_GO(L,obj);
else
lua_pushnil(L);
return 1;
}
int GetSecondHated(lua_State * L, Unit * ptr)
{
TEST_UNIT();
PUSH_UNIT(L,ptr->GetAIInterface()->GetSecondHated());
return 1;
}
int SaveToInstance(lua_State * L, Unit * ptr)
{
TEST_PLAYER();
Instance * dungeon = sInstanceMgr.GetInstanceByIds(ptr->GetMapId(),ptr->GetInstanceID());
dungeon->SaveToDB();
sInstanceMgr.BuildRaidSavedInstancesForPlayer(TO_PLAYER(ptr));
return 0;
}
int UseAI(lua_State * L, Unit * ptr)
{
bool check = CHECK_BOOL(L,1);
ptr->setAItoUse(check);
return 0;
}
int FlagFFA(lua_State * L, Unit * ptr)
{
TEST_UNITPLAYER();
bool set = CHECK_BOOL(L,1);
if(set)
ptr->SetFFAPvPFlag();
else
ptr->RemoveFFAPvPFlag();
return 0;
}
int TeleportCreature(lua_State * L, Unit * ptr)
{
TEST_UNIT();
float x = CHECK_FLOAT(L,1);
float y = CHECK_FLOAT(L,2);
float z = CHECK_FLOAT(L,3);
ptr->SetPosition(x,y,z,ptr->GetOrientation());
WorldPacket data(SMSG_MONSTER_MOVE,50);
data << ptr->GetNewGUID();
data << uint8(0);
data << ptr->GetPositionX() << ptr->GetPositionY() << ptr->GetPositionZ();
data << getMSTime();
data << uint8(0x0);
data << uint32(0x100);
data << uint32(1) << uint32(1);
data << x << y << z;
ptr->SendMessageToSet(&data,false);
return 0;
}
int IsInDungeon(lua_State * L, Unit * ptr)
{
TEST_UNITPLAYER_RET();
if(ptr->GetMapMgr()->GetMapInfo() && ptr->GetMapMgr()->GetMapInfo()->type == INSTANCE_MULTIMODE)
lua_pushboolean(L,1);
else
lua_pushboolean(L,0);
return 1;
}
int IsInRaid(lua_State * L, Unit * ptr)
{
TEST_UNITPLAYER_RET();
if(ptr->GetMapMgr()->GetMapInfo() && ptr->GetMapMgr()->GetMapInfo()->type == INSTANCE_RAID)
lua_pushboolean(L,1);
else
lua_pushboolean(L,0);
return 1;
}
int IsHostile(lua_State* L, Unit * ptr)
{
Object * B = CHECK_OBJECT(L,1);
lua_pushboolean(L, isHostile(ptr,B));
return 1;
}
int IsAttackable(lua_State* L, Unit * ptr)
{
Object * B = CHECK_OBJECT(L,1);
lua_pushboolean(L, isAttackable(ptr,B));
return 1;
}
int GetNumWaypoints(lua_State * L, Unit * ptr)
{
TEST_UNIT();
RET_NUMBER(ptr->GetAIInterface()->GetWayPointsCount());
return 1;
}
int GetMovementType(lua_State * L, Unit * ptr)
{
TEST_UNIT();
RET_NUMBER(ptr->GetAIInterface()->getMoveType());
return 1;
}
int GetQuestLogSlot(lua_State * L, Unit * ptr)
{
TEST_PLAYER();
uint32 entry = CHECK_ULONG(L,1);
QuestLogEntry * qle = TO_PLAYER(ptr)->GetQuestLogForEntry(entry);
if (!qle)
RET_NUMBER(-1);
lua_pushnumber(L, qle->GetSlot());
return 1;
}
int GetAuraStackCount(lua_State * L, Unit * ptr)
{
TEST_UNITPLAYER_RET();
uint32 id = CHECK_ULONG(L,1);
RET_NUMBER(ptr->GetAuraStackCount(id));
}
int AddAuraObject(lua_State * L, Unit * ptr)
{
TEST_UNITPLAYER();
Aura * aura = CHECK_AURA(L,1);
if (!aura) return 0;
ptr->AddAura(aura);
return 0;
}
int GetAuraObjectById(lua_State * L, Unit * ptr)
{
TEST_UNITPLAYER();
uint32 id = CHECK_ULONG(L,1);
PUSH_AURA(L, ptr->FindAura(id));
return 1;
}
int StopPlayerAttack(lua_State * L, Unit * ptr)
{
TEST_PLAYER();
TO_PLAYER(ptr)->smsg_AttackStop( TO_PLAYER(ptr)->GetSelection() );
return 0;
}
int GetQuestObjectiveCompletion(lua_State * L, Unit * ptr)
{
TEST_PLAYER_RET()
int questid = luaL_checkint(L,1);
int objective = luaL_checkint(L,2);
Player * pl = TO_PLAYER(ptr);
QuestLogEntry * qle = pl->GetQuestLogForEntry(questid);
if (qle != NULL)
lua_pushnumber(L, qle->GetMobCount(objective));
else
lua_pushnil(L);
return 1;
}
}
#endif
| [
"jozsab1@gmail.com"
] | jozsab1@gmail.com |
5855e5af704f5ca1b05868637041741b4de35363 | 3bdc1b429a836088ffda0fa480ac86bace5d9603 | /node.h | 9620b3fe7653073145f4f219222312f920cf2a46 | [] | no_license | bruno99/ArbolGenealogico | 49946713e0a38db964d7c6f895ca1e4d54ef59a4 | b4c0e5d220051853abb9e0c576dc4f3cb672373c | refs/heads/master | 2022-05-26T00:24:06.968854 | 2020-04-29T15:04:51 | 2020-04-29T15:04:51 | 259,957,700 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 774 | h | #ifndef NODE_H
#define NODE_H
#include <vector>
#include <array>
#include "person.h"
using namespace std;
class Node
{
public:
Node(Person *p);
Person *getPerson() const;
void setPerson(Person *value);
void addChildren(Node* n);
void addParent(Node* p);
void addSibling(Node* s);
vector<Node *> getChildren() const;
array<Node *, 2> getParents() const;
vector<Node *> getSiblings() const;
void printRelatives() const;
void print();
Node* search(string name, string surname1, string surname2);
void resetPrint();
void resetVisited();
private:
Person* person;
vector<Node *> children;
array<Node *, 2> parents;
vector<Node *> siblings;
bool printed;
bool visited;
};
#endif // NODE_H
| [
"noreply@github.com"
] | bruno99.noreply@github.com |
c13c11431d998b317e0a2df650874056c7a194ca | 587e228aa2069010c5f65d9b767153aa8aeae558 | /LCLaser/src/builder/control.h | 65939613b0d254d354632cfde95644860d9bc947 | [] | no_license | zb939938758/RPLaser | f17347866e51fd7436ce6f6c5869c01456cea9df | dc15c34466242ab06e2d20492710e515a7f540d8 | refs/heads/master | 2020-04-01T20:07:44.020559 | 2018-10-18T08:33:17 | 2018-10-18T08:33:17 | 153,589,710 | 0 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 6,588 | h | /***************************************************************************
control.h - description
-------------------
begin : Apr. 22 2015
copyright : (C) 2015 by XI'AN JIAOTONG UNIVERSITY
author : Cui Bin
***************************************************************************/
#ifndef RPControl_H
#define RPControl_H
#include <QObject>
#include <iostream>
#include <vector>
#include <QProgressDialog>
#include <QMutex>
#include "gtmock.h"
#include "command.h"
#include "config.h"
#include "matrix4x4.h"
#include "controlinterface.h"
#define LASER_CHANNEL 1
using namespace std;
typedef vector<bool> VBseq;
typedef vector<VBseq> VStatus;
class MainWindow;
class WTabControl;
namespace BuildRP
{
enum PowerMode
{
LPMODE_PWM = 0,
LPMODE_FM,
LPMODE_DA,
};
enum SampePosStauts
{
POS_1 =1<<0,
POS_2 =1<<1,
POS_3 =1<<2,
POS_4 =1<<3,
};
enum AXIS
{
AXIS_BX =1<<0,
AXIS_BY =1<<1,
AXIS_BZ =1<<2,
};
class RPControl : public ControlInterface
{
Q_OBJECT
public:
explicit RPControl(QObject *parent = 0);
~RPControl();
//interface
void setSingleTrack(int trackType);
void setSingleHeight(int smaxHeight);
void setSingleLenghtRadius(double svalue);
void SetSingleDeltaZ(double sdZ);
void singleBuffOn();
void singleBuffOff();
void singleBuffContinue();
void SingleClearBuff();
bool connectMachine();
void disConnectMachine();
void turnOnLaser();
void turnOffLaser();
void switchLaser(bool on);
void setFrequency(double frequency);
void setDutyratio(double dutyratio);
void setVoltage(double voltage);
bool getLaserStatus();
void setui(WTabControl *uip);
bool isBeginSyn();
void disableBeginSyn();
void setLaserPowerMode(unsigned short smode);
unsigned short getLaserPowerMode();
void move2Start();
void move2MeasurePos(Vec3D spos);
short Home(unsigned short axis,long pos,long offset,double vel_high,double vel_low);
void goHome();
//thread function.
static void proPrintAll(RPControl *rpctl);
static void proPushCommd(RPControl *rpctl);
void threadMoveXYZ(double sx, double sy, double sz,double vel,double acc);
void hideAllMoveControl(bool bhide);
void controlDebug();
#ifdef WIN32
static void __stdcall CommandHandle(char *command,short error);
#else
static void CommandHandle(char *command,short error);
#endif
void saveConfig();
bool enableAxis();
bool disableAxis();
void moveXYZfromZero(double sx,double sy,double sz);
void moveXYZfromZero(unsigned int saxis,double srange);
void moveOffset();
bool shouldMoveOffset(const double (&pos)[4]);
void moveXYZ(double sx,double sy,double sz);
void clearLimit();
void getStatus(VStatus& status);
void getLimitStatus();
void setData(DataRP::RPData *pdata);
void switchSIMU(bool isOn);
void printAll();
void refresh();
void startPrint();
void BuffOn();
void BuffOff();
void BuffContinue();
void clearBuff();
void setParaminRuntime();
void setMoveVelValue(double sv);
void setMoveAccValue(double sv);
void setOutlineVelValue(double sv);
void setFillingVelValue(double sv);
void setOutlineFillingAccValue(double sv);
void setLaserOnDelay(double son);
void setLaserOffDelay(double soff);
void setHomeAxis(unsigned short haxis);
void resetZero();
void setOveride(double sr);
double getPrintZ();
void getCurrentPosition(Vec4D &pos);
bool isPrintRun();
void goOrigin();
void setOrigin();
void resetZ();
void resetZ2Bigin();
double mm2pulse(double smm);
double pulse2mm(double pulse);
QMutex m_mutex;
signals:
void updateLaserStatus();
void updateDisplay();
void showInfo(QString info);
public slots:
void handleResults(QString str);
protected:
void setMoveSpeed();
void setFillingSpeed();
void setOutlineSpeed();
void clearCommds();
void setLaser();
void laserWithPowerMode();
static bool isSimulate();
void getCommds();
static void extractOutlines(RPControl* rpconntrol,RPprintItem &item,int &runtype);
static void extractPaths(RPControl* rpconntrol,Line &line);
void dealOutline(RPprintItem &item,int &runtype);
void dealPath(Line &line);
static bool b_simu;
double velConvert(double vel);
double accConvert(double acc);
void do_BuffOn();
void do_BufIOBit(RPCommd &commd);
void do_setSynVel(RPCommd &commd);
void do_arcXY(RPCommd &commd);
void do_arcXYP(RPCommd &commd);
void do_LnXY(RPCommd &commd);
void do_LnXYZ(RPCommd &commd);
void do_LnXYZG0(RPCommd &commd);
void do_Finish(RPCommd &commd);
void do_layerOver(RPCommd &commd);
void drawArc();
void drawLine();
void drawLineZ();
bool dealBlockBuff(short isblock,RPCommd &commd);
private:
double m_frequency;
double m_dutyratio;
double m_voltage;
SpeedSet m_speed;
DataRP::RPData *rp_data;
SIMURP::GTMock *rp_simu;
CommdList m_commds;
double m_minZ;
double m_maxZ;
Vec3D m_position;
Vec3D m_tryposition;
double m_rpp;
double m_pulseEqu; // pulse/mm
bool b_pause;
bool b_runtimeSet;
bool b_printRun;
unsigned short m_homeAxis;
unsigned short m_laserPowerMode;
bool b_waitQuit;
DataRP::LaserAttribute *laserAttr;
int singleTrackType;
double singledeltaZ;
double singleLenghtRadius;
unsigned singleMaxLayer;
double laser_offDelay;
double laser_onDelay;
double m_override;
double m_origin[3];
double m_seekOrigin[3];
WTabControl *ui_control;
int m_loopCnt;
bool b_alreadyBeginSyn;
Vec3D m_threadPostion;
};
}
#endif // RPControl_H
| [
"zhoubeisun@qq.com"
] | zhoubeisun@qq.com |
dcc159afd186e7eb93e07c884a3ce9dd6ded1582 | d1aa6e7d5631d7806531660febbd1f856eaeece7 | /paddle/fluid/platform/profiler/host_tracer.cc | 1c2c00d75bc8586ab5d459c955ea6588c5e9c8de | [
"Apache-2.0"
] | permissive | gongweibao/Paddle | 510cd4bc0ef89bc6ccee7b6b8eca52c00e014b77 | 60f9c60cd8196c66c391d79c35d341e9072f8838 | refs/heads/develop | 2023-03-13T17:43:35.675875 | 2022-09-20T08:46:15 | 2022-09-20T08:46:15 | 82,279,237 | 3 | 2 | Apache-2.0 | 2021-05-26T06:17:43 | 2017-02-17T09:16:16 | Python | UTF-8 | C++ | false | false | 6,574 | cc | // Copyright (c) 2022 PaddlePaddle Authors. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#include "paddle/fluid/platform/profiler/host_tracer.h"
#include <sstream>
#include "glog/logging.h"
#include "paddle/fluid/platform/flags.h"
#include "paddle/fluid/platform/profiler/common_event.h"
#include "paddle/fluid/platform/profiler/host_event_recorder.h"
// Used to filter events, works like glog VLOG(level).
// RecordEvent will works if host_trace_level >= level.
PADDLE_DEFINE_EXPORTED_int64(host_trace_level,
1,
"RecordEvent will works "
"if host_trace_level >= level.");
namespace paddle {
namespace platform {
namespace {
void ProcessHostEvents(const HostEventSection<CommonEvent>& host_events,
TraceEventCollector* collector) {
for (const auto& thr_sec : host_events.thr_sections) {
uint64_t tid = thr_sec.thread_id;
if (thr_sec.thread_name != kDefaultThreadName) {
collector->AddThreadName(tid, thr_sec.thread_name);
}
for (const auto& evt : thr_sec.events) {
HostTraceEvent event;
event.name = evt.name;
event.type = evt.type;
event.start_ns = evt.start_ns;
event.end_ns = evt.end_ns;
event.process_id = host_events.process_id;
event.thread_id = tid;
collector->AddHostEvent(std::move(event));
}
}
}
void ProcessHostMemEvents(
const HostEventSection<CommonMemEvent>& host_mem_events,
TraceEventCollector* collector) {
for (const auto& thr_sec : host_mem_events.thr_sections) {
uint64_t tid = thr_sec.thread_id;
if (thr_sec.thread_name != kDefaultThreadName) {
collector->AddThreadName(tid, thr_sec.thread_name);
}
for (const auto& evt : thr_sec.events) {
MemTraceEvent event;
event.timestamp_ns = evt.timestamp_ns;
event.addr = evt.addr;
event.type = evt.type;
event.increase_bytes = evt.increase_bytes;
event.place = evt.place.DebugString();
event.current_allocated = evt.current_allocated;
event.current_reserved = evt.current_reserved;
event.peak_allocated = evt.peak_allocated;
event.peak_reserved = evt.peak_reserved;
event.process_id = host_mem_events.process_id;
event.thread_id = tid;
collector->AddMemEvent(std::move(event));
}
}
}
void ProcessOperatorSupplementEvents(
const HostEventSection<OperatorSupplementOriginEvent>& op_supplement_events,
TraceEventCollector* collector) {
for (const auto& thr_sec : op_supplement_events.thr_sections) {
uint64_t tid = thr_sec.thread_id;
if (thr_sec.thread_name != kDefaultThreadName) {
collector->AddThreadName(tid, thr_sec.thread_name);
}
for (const auto& evt : thr_sec.events) {
OperatorSupplementEvent event;
event.timestamp_ns = evt.timestamp_ns;
event.op_type = evt.op_type;
std::map<std::string, std::vector<std::vector<int64_t>>> input_shapes;
std::map<std::string, std::vector<std::string>> dtypes;
std::string callstack;
for (auto it = evt.input_shapes.begin(); it != evt.input_shapes.end();
it++) {
for (auto idx = 0lu; idx < it->second.size(); idx++) {
input_shapes[it->first].push_back(std::vector<int64_t>());
for (auto dim_idx = 0; dim_idx < it->second.at(idx).size();
dim_idx++) {
input_shapes[it->first][idx].push_back(
it->second.at(idx).at(dim_idx));
}
}
}
for (auto it = evt.dtypes.begin(); it != evt.dtypes.end(); it++) {
for (auto idx = 0lu; idx < it->second.size(); idx++) {
dtypes[it->first].push_back(
framework::proto::VarType::Type_Name(it->second.at(idx)));
}
}
std::ostringstream result_string;
for (auto it = evt.callstack.begin(); it != evt.callstack.end(); it++) {
result_string << (*it) << std::endl;
}
event.input_shapes = input_shapes;
event.dtypes = dtypes;
event.callstack = result_string.str();
event.process_id = op_supplement_events.process_id;
event.thread_id = tid;
collector->AddOperatorSupplementEvent(std::move(event));
}
}
}
} // namespace
void HostTracer::PrepareTracing() {
// warm up
HostTraceLevel::GetInstance().SetLevel(options_.trace_level);
state_ = TracerState::READY;
}
void HostTracer::StartTracing() {
PADDLE_ENFORCE_EQ(
state_ == TracerState::READY || state_ == TracerState::STOPED,
true,
platform::errors::PreconditionNotMet("TracerState must be READY"));
HostEventRecorder<CommonEvent>::GetInstance().GatherEvents();
HostEventRecorder<CommonMemEvent>::GetInstance().GatherEvents();
HostEventRecorder<OperatorSupplementOriginEvent>::GetInstance()
.GatherEvents();
HostTraceLevel::GetInstance().SetLevel(options_.trace_level);
state_ = TracerState::STARTED;
}
void HostTracer::StopTracing() {
PADDLE_ENFORCE_EQ(
state_,
TracerState::STARTED,
platform::errors::PreconditionNotMet("TracerState must be STARTED"));
HostTraceLevel::GetInstance().SetLevel(HostTraceLevel::kDisabled);
state_ = TracerState::STOPED;
}
void HostTracer::CollectTraceData(TraceEventCollector* collector) {
PADDLE_ENFORCE_EQ(
state_,
TracerState::STOPED,
platform::errors::PreconditionNotMet("TracerState must be STOPED"));
HostEventSection<CommonEvent> host_events =
HostEventRecorder<CommonEvent>::GetInstance().GatherEvents();
ProcessHostEvents(host_events, collector);
HostEventSection<CommonMemEvent> host_mem_events =
HostEventRecorder<CommonMemEvent>::GetInstance().GatherEvents();
ProcessHostMemEvents(host_mem_events, collector);
HostEventSection<OperatorSupplementOriginEvent> op_supplement_events =
HostEventRecorder<OperatorSupplementOriginEvent>::GetInstance()
.GatherEvents();
ProcessOperatorSupplementEvents(op_supplement_events, collector);
}
} // namespace platform
} // namespace paddle
| [
"noreply@github.com"
] | gongweibao.noreply@github.com |
5e4599b929dea47579f2775dd72b1a0cbd26a0e7 | b38383846d082ec4e65ac18c1582f1ce231ea0b4 | /Siv3D/src/Siv3D-Platform/WindowsDesktop/Siv3D/Renderer/D3D11/BackBuffer/D3D11BackBuffer.hpp | 2706c8392036fa57a1e30d2d198a5456f0fc3354 | [
"MIT"
] | permissive | Siv3D/siv6 | 9c12427f470b65772f40504b1e5e5239a60bbe95 | 090e82b2f6398640638dfa43da3f829ba977d0e2 | refs/heads/master | 2021-02-07T05:12:41.108547 | 2020-10-25T05:27:11 | 2020-10-25T05:27:11 | 243,986,884 | 3 | 5 | MIT | 2020-09-27T14:32:38 | 2020-02-29T14:50:43 | C++ | UTF-8 | C++ | false | false | 3,693 | hpp | //-----------------------------------------------
//
// This file is part of the Siv3D Engine.
//
// Copyright (c) 2008-2020 Ryo Suzuki
// Copyright (c) 2016-2020 OpenSiv3D Project
//
// Licensed under the MIT License.
//
//-----------------------------------------------
# pragma once
# include <Siv3D/Common.hpp>
# include <Siv3D/Common/D3D11.hpp>
# include <Siv3D/Scene.hpp>
# include <Siv3D/Graphics.hpp>
# include <Siv3D/FloatRect.hpp>
# include <ThirdParty/EnumBitmask/EnumBitmask.hpp>
# include "../Device/D3D11Device.hpp"
# include "../SwapChain/D3D11SwapChain.hpp"
# include "D3D11InternalTexture2D.hpp"
namespace s3d
{
enum class D3D11ClearTarget
{
BackBuffer = 1 << 0,
Scene = 1 << 1,
All = (BackBuffer | Scene),
};
DEFINE_BITMASK_OPERATORS(D3D11ClearTarget);
class CRenderer2D_D3D11;
class D3D11BackBuffer
{
private:
CRenderer2D_D3D11* pRenderer2D = nullptr;
ID3D11Device* m_device = nullptr;
ID3D11DeviceContext* m_context = nullptr;
IDXGISwapChain1* m_swapChain1 = nullptr;
uint32 m_sampleCount = Graphics::DefaultSampleCount;
ResizeMode m_sceneResizeMode = Scene::DefaultResizeMode;
Size m_sceneSize = Scene::DefaultSceneSize;
D3D11InternalTexture2D m_backBuffer;
struct SceneBuffer
{
D3D11InternalTexture2D scene;
D3D11InternalTexture2D resolved;
} m_sceneBuffers;
ColorF m_letterboxColor = Scene::DefaultLetterBoxColor;
ColorF m_backgroundColor = Scene::DefaultBackgroundColor;
TextureFilter m_sceneTextureFilter = Scene::DefaultTextureFilter;
// 全てのレンダーターゲットを解除
void unbindAllRenderTargets();
void updateSceneSize();
void setRenderTarget(const D3D11InternalTexture2D& texture);
public:
D3D11BackBuffer(const D3D11Device& device, const D3D11SwapChain& swapChain);
~D3D11BackBuffer();
void clear(D3D11ClearTarget clearTargets);
void updateFromSceneBuffer();
void bindRenderTarget(ID3D11RenderTargetView* const rtv);
//////////////////////////////////////////////////
//
// LetterboxColor
//
//////////////////////////////////////////////////
void setLetterboxColor(const ColorF& color) noexcept;
[[nodiscard]]
const ColorF& getLetterBoxColor() const noexcept;
//////////////////////////////////////////////////
//
// BackgroundColor
//
//////////////////////////////////////////////////
void setBackgroundColor(const ColorF& color) noexcept;
[[nodiscard]]
const ColorF& getBackgroundColor() const noexcept;
//////////////////////////////////////////////////
//
// SceneTextureFilter
//
//////////////////////////////////////////////////
void setSceneTextureFilter(TextureFilter textureFilter) noexcept;
[[nodiscard]]
TextureFilter getSceneTextureFilter() const noexcept;
//////////////////////////////////////////////////
//
// SceneResizeMode
//
//////////////////////////////////////////////////
void setSceneResizeMode(ResizeMode resizeMode);
[[nodiscard]]
ResizeMode getSceneResizeMode() const noexcept;
//////////////////////////////////////////////////
//
// BackBuffer
//
//////////////////////////////////////////////////
void setBackBufferSize(Size backBufferSize);
[[nodiscard]]
const Size& getBackBufferSize() const noexcept;
[[nodiscard]]
std::pair<float, RectF> getLetterboxComposition() const noexcept;
//////////////////////////////////////////////////
//
// SceneBuffer
//
//////////////////////////////////////////////////
void setSceneBufferSize(Size size);
[[nodiscard]]
const Size& getSceneBufferSize() const noexcept;
const D3D11InternalTexture2D& getSceneBuffer() const noexcept;
};
}
| [
"reputeless+github@gmail.com"
] | reputeless+github@gmail.com |
ddca1976f2dc6543e6081db987268df6f9683fd1 | b44ade29b2109ff5637e195998a209e67f450995 | /media/libmedia/camera_record_service.cpp | 56c7f9f8277dfbece529ab032939f12df1619e56 | [
"Apache-2.0",
"LicenseRef-scancode-unicode"
] | permissive | ricmm/android_frameworks_av | ac5958fae26e7d59291b408e97035e27919bf1ef | f4135095002670a9b68fe1805662bee900a3778e | refs/heads/ubp-5.1 | 2021-01-11T21:02:04.930104 | 2016-10-26T23:03:43 | 2016-10-26T23:03:43 | 79,231,453 | 0 | 0 | null | 2017-01-17T13:42:11 | 2017-01-17T13:42:11 | null | UTF-8 | C++ | false | false | 8,871 | cpp | /*
* Copyright (C) 2014 Canonical Ltd
*
* 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.
*
* Authored by: Jim Hodapp <jim.hodapp@canonical.com>
*/
#define LOG_NDEBUG 0
#define LOG_TAG "ICameraRecordService"
#include <media/camera_record_service.h>
#include <media/record_thread.h>
#include <media/record_track.h>
#include <binder/IServiceManager.h>
#include <utils/Log.h>
#define REPORT_FUNCTION() ALOGV("%s \n", __PRETTY_FUNCTION__)
namespace android {
// IDecodingServiceSession
BpCameraRecordService::BpCameraRecordService(const sp<IBinder>& impl)
: BpInterface<ICameraRecordService>(impl)
{
REPORT_FUNCTION();
}
BpCameraRecordService::~BpCameraRecordService()
{
REPORT_FUNCTION();
}
status_t BpCameraRecordService::initRecord(
uint32_t sampleRate,
audio_format_t format,
audio_channel_mask_t channelMask)
{
REPORT_FUNCTION();
Parcel data, reply;
data.writeInterfaceToken(ICameraRecordService::getInterfaceDescriptor());
data.writeInt32(sampleRate);
data.writeInt32(format);
data.writeInt32(channelMask);
return remote()->transact(OPEN_RECORD, data, &reply);
}
sp<IAudioRecord> BpCameraRecordService::openRecord(uint32_t sampleRate,
audio_format_t format,
audio_channel_mask_t channelMask,
size_t frameCount,
pid_t tid,
int *sessionId,
status_t *status)
{
REPORT_FUNCTION();
Parcel data, reply;
sp<IAudioRecord> record;
data.writeInterfaceToken(ICameraRecordService::getInterfaceDescriptor());
data.writeInt32(sampleRate);
data.writeInt32(format);
data.writeInt32(channelMask);
data.writeInt32(frameCount);
data.writeInt32((int32_t) tid);
int lSessionId = 0;
if (sessionId != 0)
lSessionId = *sessionId;
data.writeInt32(lSessionId);
status_t lStatus = remote()->transact(OPEN_RECORD, data, &reply);
if (lStatus != NO_ERROR)
ALOGE("openRecord error: %s", strerror(-lStatus));
else {
lStatus = reply.readInt32();
record = interface_cast<IAudioRecord>(reply.readStrongBinder());
if (lStatus == NO_ERROR) {
if (record == 0) {
ALOGE("openRecord should have returned an IAudioRecord instance");
lStatus = UNKNOWN_ERROR;
}
} else {
if (record != 0) {
ALOGE("openRecord returned an IAudioRecord instance but with status %d", lStatus);
record.clear();
}
}
}
if (status)
*status = lStatus;
return record;
}
// ----------------------------------------------------------------------------
IMPLEMENT_META_INTERFACE(CameraRecordService, "android.media.ICameraRecordService");
BnCameraRecordService::BnCameraRecordService()
{
REPORT_FUNCTION();
}
BnCameraRecordService::~BnCameraRecordService()
{
REPORT_FUNCTION();
}
status_t BnCameraRecordService::onTransact(uint32_t code, const Parcel& data,
Parcel* reply, uint32_t flags)
{
REPORT_FUNCTION();
switch (code) {
case INIT_RECORD: {
CHECK_INTERFACE(ICameraRecordService, data, reply);
uint32_t sampleRate = data.readInt32();
audio_format_t format = (audio_format_t) data.readInt32();
audio_channel_mask_t channelMask = data.readInt32();
reply->writeInt32(initRecord(sampleRate, format, channelMask));
return NO_ERROR;
} break;
case OPEN_RECORD: {
CHECK_INTERFACE(ICameraRecordService, data, reply);
uint32_t sampleRate = data.readInt32();
audio_format_t format = (audio_format_t) data.readInt32();
audio_channel_mask_t channelMask = data.readInt32();
size_t frameCount = data.readInt32();
pid_t tid = (pid_t) data.readInt32();
int sessionId = data.readInt32();
status_t status;
sp<IAudioRecord> record = openRecord(sampleRate, format, channelMask,
frameCount, tid, &sessionId, &status);
LOG_ALWAYS_FATAL_IF((record != 0) != (status == NO_ERROR));
reply->writeInt32(sessionId);
reply->writeInt32(status);
reply->writeStrongBinder(record->asBinder());
return NO_ERROR;
} break;
default:
return BBinder::onTransact(code, data, reply, flags);
}
return NO_ERROR;
}
// ----------------------------------------------------------------------------
sp<CameraRecordService> CameraRecordService::camera_record_service;
Mutex CameraRecordService::s_lock;
CameraRecordService::CameraRecordService()
: mNextUniqueId(1)
{
REPORT_FUNCTION();
}
CameraRecordService::~CameraRecordService()
{
REPORT_FUNCTION();
}
void CameraRecordService::instantiate()
{
REPORT_FUNCTION();
defaultServiceManager()->addService(
String16(ICameraRecordService::exported_service_name()), service_instance());
ALOGV("Added Binder service '%s' to ServiceManager", ICameraRecordService::exported_service_name());
}
uint32_t CameraRecordService::nextUniqueId()
{
REPORT_FUNCTION();
return android_atomic_inc(&mNextUniqueId);
}
status_t CameraRecordService::initRecord(
uint32_t sampleRate,
audio_format_t format,
audio_channel_mask_t channelMask)
{
REPORT_FUNCTION();
Mutex::Autolock _l(mLock);
audio_io_handle_t id = nextUniqueId();
mRecordThread = new RecordThread(sampleRate,
channelMask,
id);
if (mRecordThread == NULL) {
ALOGE("Failed to instantiate a new RecordThread, audio recording will not function");
return UNKNOWN_ERROR;
}
return NO_ERROR;
}
sp<IAudioRecord> CameraRecordService::openRecord(uint32_t sampleRate,
audio_format_t format,
audio_channel_mask_t channelMask,
size_t frameCount,
pid_t tid,
int *sessionId,
status_t *status)
{
REPORT_FUNCTION();
status_t lStatus;
sp<RecordTrack> recordTrack;
sp<RecordHandle> recordHandle;
size_t inFrameCount = 0;
int lSessionId = 0;
if (mRecordThread == NULL) {
lStatus = UNKNOWN_ERROR;
ALOGE("mRecordThread is NULL, call initRecord() first");
goto Exit;
}
if (format != AUDIO_FORMAT_PCM_16_BIT) {
ALOGE("openRecord() invalid format %d", format);
lStatus = BAD_VALUE;
goto Exit;
}
{ // scope for mLock
Mutex::Autolock _l(mLock);
// If no audio session id is provided, create one here
if (sessionId != NULL && *sessionId != AUDIO_SESSION_OUTPUT_MIX) {
lSessionId = *sessionId;
} else {
lSessionId = nextUniqueId();
if (sessionId != NULL) {
*sessionId = lSessionId;
}
}
// create new record track.
// The record track uses one track in mHardwareMixerThread by convention.
// TODO: the uid should be passed in as a parameter to openRecord
recordTrack = mRecordThread->createRecordTrack_l(sampleRate, format, channelMask,
frameCount, lSessionId,
IPCThreadState::self()->getCallingUid(),
tid, &lStatus);
LOG_ALWAYS_FATAL_IF((recordTrack != 0) != (lStatus == NO_ERROR));
}
if (lStatus != NO_ERROR) {
recordTrack.clear();
goto Exit;
}
// return to handle to client
recordHandle = new RecordHandle(recordTrack);
lStatus = NO_ERROR;
Exit:
if (status) {
*status = lStatus;
}
return recordHandle;
}
sp<CameraRecordService>& CameraRecordService::service_instance()
{
REPORT_FUNCTION();
Mutex::Autolock _l(s_lock);
if (camera_record_service == NULL)
{
ALOGD("Creating new static instance of CameraRecordService");
camera_record_service = new CameraRecordService();
}
return camera_record_service;
}
} // namespace android
| [
"me@mariogrip.com"
] | me@mariogrip.com |
2201f66a61cc60121ebdd5ef71e177bb79d46af7 | 7ab5c79d2716bc56c2fc2be9bf1cdcb8530379a4 | /c++/Diverse problems and algorithms/Problems/clase/finalrecap/copaci.h | 1e0cd122b6cc9a81c063b3d562813da97826e64f | [] | no_license | TeoPaius/Projects | dfd8771199cd8a0e2df07e18dd165bf63ad08292 | ced149ecf1243da2aa97bb1f0e4cd37140bd2d2d | refs/heads/master | 2021-09-24T02:10:52.220320 | 2018-10-01T16:29:01 | 2018-10-01T16:29:01 | 104,876,094 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 354 | h | #ifndef COPACI_H
#define COPACI_H
using namespace std;
#include <string>
class Copac{
string tip;
string zona;
public:
Copac(string t , string z);
Copac(const Copac& c);
protected:
void GetTip();
};
class Brad : public Copac{
int height;
string culoare;
public :
Brad(int h, string culoare);
};
#endif // COPACI_H
| [
"teodor_paius@yahoo.com"
] | teodor_paius@yahoo.com |
248f8e7d4016d9ff0d444ec569e5cb5feca578cd | 0037b52836594c2c0984af0d258ef8309d9b96e0 | /ShaderGLLib/Image.h | 698bf8a83b786a0632bca31cd2b95b57079d0515 | [
"MIT"
] | permissive | EPAC-Saxon/physically-based-rendeging-JuliePreperier | ca21539af7e09198b122b81c2e1cfd9ce046c7e2 | 3d2e534d25cef631197f91962384f48b02469510 | refs/heads/master | 2021-05-19T04:32:20.492786 | 2020-04-07T07:31:05 | 2020-04-07T07:31:05 | 251,529,035 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 544 | h | #pragma once
#include <vector>
#include <string>
#include "Vector.h"
namespace sgl {
class Image
{
public:
Image(const std::string& file);
virtual ~Image();
public:
const std::pair<size_t, size_t> GetSize() const { return { dx_, dy_ }; }
const float GetWidth() const { return static_cast<float>(dx_); }
const float GetHeight() const { return static_cast<float>(dy_); }
const std::uint8_t* Data() const { return image_; }
private:
size_t dx_ = 0;
size_t dy_ = 0;
std::uint8_t* image_;
};
} // End of namespace sgl.
| [
"frederic.dubouchet@gmail.com"
] | frederic.dubouchet@gmail.com |
275019d541c0ec76ec75a9ed856a2345a5527558 | d4e96aa48ddff651558a3fe2212ebb3a3afe5ac3 | /Modules/Registration/Common/include/itkImageToImageMetric.hxx | 9e375851267881d85e4613c53f5fff1dabefd849 | [
"SMLNJ",
"BSD-3-Clause",
"LicenseRef-scancode-free-unknown",
"LicenseRef-scancode-mit-old-style",
"LicenseRef-scancode-other-permissive",
"LicenseRef-scancode-unknown-license-reference",
"LicenseRef-scancode-warranty-disclaimer",
"NTP",
"IJG",
"GPL-1.0-or-later",
"libtiff",
"BSD-4.3TAHOE",
"... | permissive | nalinimsingh/ITK_4D | 18e8929672df64df58a6446f047e6ec04d3c2616 | 95a2eacaeaffe572889832ef0894239f89e3f303 | refs/heads/master | 2020-03-17T18:58:50.953317 | 2018-10-01T20:46:43 | 2018-10-01T21:21:01 | 133,841,430 | 0 | 0 | Apache-2.0 | 2018-05-17T16:34:54 | 2018-05-17T16:34:53 | null | UTF-8 | C++ | false | false | 50,937 | hxx | /*=========================================================================
*
* Copyright Insight Software Consortium
*
* 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.txt
*
* 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 itkImageToImageMetric_hxx
#define itkImageToImageMetric_hxx
#include "itkImageToImageMetric.h"
#include "itkImageRandomConstIteratorWithIndex.h"
#include "itkMath.h"
namespace itk
{
/**
* Constructor
*/
template< typename TFixedImage, typename TMovingImage >
ImageToImageMetric< TFixedImage, TMovingImage >
::ImageToImageMetric():
m_UseFixedImageIndexes(false),
m_FixedImageIndexes(0),
m_UseFixedImageSamplesIntensityThreshold(false),
m_FixedImageSamplesIntensityThreshold(0),
m_FixedImageSamples(0),
m_NumberOfParameters(0),
m_NumberOfFixedImageSamples(50000),
m_NumberOfPixelsCounted(0),
m_FixedImage(ITK_NULLPTR), // has to be provided by the user.
m_MovingImage(ITK_NULLPTR), // has to be provided by the user.
m_Transform(ITK_NULLPTR), // has to be provided by the user.
m_ThreaderTransform(ITK_NULLPTR), // constructed at initialization.
m_Interpolator(ITK_NULLPTR), // has to be provided by the user.
m_ComputeGradient(true), // metric computes gradient by default
m_GradientImage(ITK_NULLPTR), // computed at initialization
m_FixedImageMask(ITK_NULLPTR),
m_MovingImageMask(ITK_NULLPTR),
m_NumberOfThreads(1),
m_UseAllPixels(false),
m_UseSequentialSampling(false),
m_ReseedIterator(false),
m_RandomSeed(Statistics::MersenneTwisterRandomVariateGenerator::GetNextSeed()),
m_TransformIsBSpline(false),
m_NumBSplineWeights(0),
m_BSplineTransform(ITK_NULLPTR),
m_BSplineTransformWeightsArray(),
m_BSplineTransformIndicesArray(),
m_BSplinePreTransformPointsArray(0),
m_WithinBSplineSupportRegionArray(0),
m_BSplineParametersOffset(),
m_UseCachingOfBSplineWeights(true),
m_BSplineTransformWeights(),
m_BSplineTransformIndices(),
m_ThreaderBSplineTransformWeights(ITK_NULLPTR),
m_ThreaderBSplineTransformIndices(ITK_NULLPTR),
m_InterpolatorIsBSpline(false),
m_BSplineInterpolator(ITK_NULLPTR),
m_DerivativeCalculator(ITK_NULLPTR),
m_Threader(MultiThreaderType::New()),
m_ThreaderNumberOfMovingImageSamples(ITK_NULLPTR),
m_WithinThreadPreProcess(false),
m_WithinThreadPostProcess(false)
{
this->m_ThreaderParameter.metric = this;
this->m_NumberOfThreads = this->m_Threader->GetNumberOfThreads();
/* if 100% backward compatible, we should include this...but...
typename BSplineTransformType::Pointer transformer =
BSplineTransformType::New();
this->SetTransform (transformer);
typename BSplineInterpolatorType::Pointer interpolator =
BSplineInterpolatorType::New();
this->SetInterpolator (interpolator);
*/
}
template< typename TFixedImage, typename TMovingImage >
ImageToImageMetric< TFixedImage, TMovingImage >
::~ImageToImageMetric()
{
delete[] m_ThreaderNumberOfMovingImageSamples;
m_ThreaderNumberOfMovingImageSamples = ITK_NULLPTR;
delete[] m_ThreaderTransform;
m_ThreaderTransform = ITK_NULLPTR;
delete[] this->m_ThreaderBSplineTransformWeights;
this->m_ThreaderBSplineTransformWeights = ITK_NULLPTR;
delete[] this->m_ThreaderBSplineTransformIndices;
this->m_ThreaderBSplineTransformIndices = ITK_NULLPTR;
}
/**
* Set the number of threads. This will be clamped by the
* multithreader, so we must check to see if it is accepted.
*/
template< typename TFixedImage, typename TMovingImage >
void
ImageToImageMetric< TFixedImage, TMovingImage >
::SetNumberOfThreads(ThreadIdType numberOfThreads)
{
m_Threader->SetNumberOfThreads(numberOfThreads);
m_NumberOfThreads = m_Threader->GetNumberOfThreads();
}
/**
* Set the parameters that define a unique transform
*/
template< typename TFixedImage, typename TMovingImage >
void
ImageToImageMetric< TFixedImage, TMovingImage >
::SetTransformParameters(const ParametersType & parameters) const
{
if ( !m_Transform )
{
itkExceptionMacro(<< "Transform has not been assigned");
}
m_Transform->SetParameters(parameters);
}
template< typename TFixedImage, typename TMovingImage >
void
ImageToImageMetric< TFixedImage, TMovingImage >
::SetNumberOfFixedImageSamples(SizeValueType numSamples)
{
if ( numSamples != m_NumberOfFixedImageSamples )
{
m_NumberOfFixedImageSamples = numSamples;
if ( m_NumberOfFixedImageSamples != this->m_FixedImageRegion.GetNumberOfPixels() )
{
this->SetUseAllPixels(false);
}
this->Modified();
}
}
template< typename TFixedImage, typename TMovingImage >
void
ImageToImageMetric< TFixedImage, TMovingImage >
::SetFixedImageIndexes(const FixedImageIndexContainer & indexes)
{
this->SetUseFixedImageIndexes(true);
m_NumberOfFixedImageSamples = indexes.size();
m_FixedImageIndexes.resize(m_NumberOfFixedImageSamples);
for ( unsigned int i = 0; i < m_NumberOfFixedImageSamples; i++ )
{
m_FixedImageIndexes[i] = indexes[i];
}
}
template< typename TFixedImage, typename TMovingImage >
void
ImageToImageMetric< TFixedImage, TMovingImage >
::SetUseFixedImageIndexes(bool useIndexes)
{
if ( useIndexes != m_UseFixedImageIndexes )
{
m_UseFixedImageIndexes = useIndexes;
if ( m_UseFixedImageIndexes )
{
this->SetUseAllPixels(false);
}
else
{
this->Modified();
}
}
}
template< typename TFixedImage, typename TMovingImage >
void
ImageToImageMetric< TFixedImage, TMovingImage >
::SetFixedImageSamplesIntensityThreshold(const FixedImagePixelType & thresh)
{
if ( thresh != m_FixedImageSamplesIntensityThreshold )
{
m_FixedImageSamplesIntensityThreshold = thresh;
this->SetUseFixedImageSamplesIntensityThreshold(true);
this->Modified();
}
}
template< typename TFixedImage, typename TMovingImage >
void
ImageToImageMetric< TFixedImage, TMovingImage >
::SetUseFixedImageSamplesIntensityThreshold(bool useThresh)
{
if ( useThresh != m_UseFixedImageSamplesIntensityThreshold )
{
m_UseFixedImageSamplesIntensityThreshold = useThresh;
if ( m_UseFixedImageSamplesIntensityThreshold )
{
this->SetUseAllPixels(false);
}
else
{
this->Modified();
}
}
}
template< typename TFixedImage, typename TMovingImage >
void
ImageToImageMetric< TFixedImage, TMovingImage >
::SetFixedImageRegion(const FixedImageRegionType reg)
{
if ( reg != m_FixedImageRegion )
{
m_FixedImageRegion = reg;
if ( this->GetUseAllPixels() )
{
this->SetNumberOfFixedImageSamples( this->m_FixedImageRegion.GetNumberOfPixels() );
}
}
}
template< typename TFixedImage, typename TMovingImage >
void
ImageToImageMetric< TFixedImage, TMovingImage >
::SetUseAllPixels(bool useAllPixels)
{
if ( useAllPixels != m_UseAllPixels )
{
m_UseAllPixels = useAllPixels;
if ( m_UseAllPixels )
{
this->SetUseFixedImageSamplesIntensityThreshold(false);
this->SetNumberOfFixedImageSamples( this->m_FixedImageRegion.GetNumberOfPixels() );
this->SetUseSequentialSampling(true);
}
else
{
this->SetUseSequentialSampling(false);
this->Modified();
}
}
}
template< typename TFixedImage, typename TMovingImage >
void
ImageToImageMetric< TFixedImage, TMovingImage >
::SetUseSequentialSampling(bool useSequential)
{
if ( useSequential != m_UseSequentialSampling )
{
m_UseSequentialSampling = useSequential;
if ( !m_UseSequentialSampling )
{
this->SetUseAllPixels(false);
}
else
{
this->Modified();
}
}
}
/**
* Initialize
*/
template< typename TFixedImage, typename TMovingImage >
void
ImageToImageMetric< TFixedImage, TMovingImage >
::Initialize(void)
throw ( ExceptionObject )
{
if ( !m_Transform )
{
itkExceptionMacro(<< "Transform is not present");
}
m_NumberOfParameters = m_Transform->GetNumberOfParameters();
if ( !m_Interpolator )
{
itkExceptionMacro(<< "Interpolator is not present");
}
if ( !m_MovingImage )
{
itkExceptionMacro(<< "MovingImage is not present");
}
if ( !m_FixedImage )
{
itkExceptionMacro(<< "FixedImage is not present");
}
// If the image is provided by a source, update the source.
if ( m_MovingImage->GetSource() )
{
m_MovingImage->GetSource()->Update();
}
// If the image is provided by a source, update the source.
if ( m_FixedImage->GetSource() )
{
m_FixedImage->GetSource()->Update();
}
//The use of FixedImageIndexes and the use of FixedImageRegion
//are mutually exclusive, so they should not both be checked.
if ( this->m_UseFixedImageIndexes == true )
{
if( this->m_FixedImageIndexes.size() == 0 )
{
itkExceptionMacro(<< "FixedImageIndexes list is empty");
}
}
else
{
// Make sure the FixedImageRegion is within the FixedImage buffered region
if ( m_FixedImageRegion.GetNumberOfPixels() == 0 )
{
itkExceptionMacro(<< "FixedImageRegion is empty");
}
if ( !m_FixedImageRegion.Crop( m_FixedImage->GetBufferedRegion() ) )
{
itkExceptionMacro(
<< "FixedImageRegion does not overlap the fixed image buffered region");
}
}
m_Interpolator->SetInputImage(m_MovingImage);
if ( m_ComputeGradient )
{
ComputeGradient();
}
// If there are any observers on the metric, call them to give the
// user code a chance to set parameters on the metric
this->InvokeEvent( InitializeEvent() );
}
/**
* MultiThreading Initialize
*/
template< typename TFixedImage, typename TMovingImage >
void
ImageToImageMetric< TFixedImage, TMovingImage >
::MultiThreadingInitialize(void)
throw ( ExceptionObject )
{
this->SetNumberOfThreads(m_NumberOfThreads);
delete[] m_ThreaderNumberOfMovingImageSamples;
m_ThreaderNumberOfMovingImageSamples = new unsigned int[m_NumberOfThreads - 1];
// Allocate the array of transform clones to be used in every thread
delete[] m_ThreaderTransform;
m_ThreaderTransform = new TransformPointer[m_NumberOfThreads - 1];
for ( ThreadIdType ithread = 0; ithread < m_NumberOfThreads - 1; ++ithread )
{
this->m_ThreaderTransform[ithread] = this->m_Transform->Clone();
}
m_FixedImageSamples.resize(m_NumberOfFixedImageSamples);
if ( m_UseSequentialSampling )
{
//
// Take all the pixels within the fixed image region)
// to create the sample points list.
//
SampleFullFixedImageRegion(m_FixedImageSamples);
}
else
{
if ( m_UseFixedImageIndexes )
{
//
// Use the list of indexes passed to the SetFixedImageIndexes
// member function .
//
SampleFixedImageIndexes(m_FixedImageSamples);
}
else
{
//
// Uniformly sample the fixed image (within the fixed image region)
// to create the sample points list.
//
SampleFixedImageRegion(m_FixedImageSamples);
}
}
//
// Check if the interpolator is of type BSplineInterpolateImageFunction.
// If so, we can make use of its EvaluateDerivatives method.
// Otherwise, we instantiate an external central difference
// derivative calculator.
//
m_InterpolatorIsBSpline = true;
BSplineInterpolatorType *testPtr = dynamic_cast< BSplineInterpolatorType * >(
this->m_Interpolator.GetPointer() );
if ( !testPtr )
{
m_InterpolatorIsBSpline = false;
m_DerivativeCalculator = DerivativeFunctionType::New();
m_DerivativeCalculator->UseImageDirectionOn();
m_DerivativeCalculator->SetInputImage(this->m_MovingImage);
m_BSplineInterpolator = ITK_NULLPTR;
itkDebugMacro("Interpolator is not BSpline");
}
else
{
m_BSplineInterpolator = testPtr;
m_BSplineInterpolator->SetNumberOfThreads(m_NumberOfThreads);
m_BSplineInterpolator->UseImageDirectionOn();
m_DerivativeCalculator = ITK_NULLPTR;
itkDebugMacro("Interpolator is BSpline");
}
//
// Check if the transform is of type BSplineTransform.
//
// If so, several speed up features are implemented.
// [1] Precomputing the results of bulk transform for each sample point.
// [2] Precomputing the BSpline weights for each sample point,
// to be used later to directly compute the deformation vector
// [3] Precomputing the indices of the parameters within the
// the support region of each sample point.
//
m_TransformIsBSpline = true;
BSplineTransformType *testPtr2 = dynamic_cast< BSplineTransformType * >(
this->m_Transform.GetPointer() );
if ( !testPtr2 )
{
m_TransformIsBSpline = false;
m_BSplineTransform = ITK_NULLPTR;
itkDebugMacro("Transform is not BSplineDeformable");
}
else
{
m_BSplineTransform = testPtr2;
m_NumBSplineWeights = m_BSplineTransform->GetNumberOfWeights();
itkDebugMacro("Transform is BSplineDeformable");
}
if ( this->m_TransformIsBSpline )
{
// First, deallocate memory that may have been used from previous run of the Metric
this->m_BSplineTransformWeightsArray.SetSize(1, 1);
this->m_BSplineTransformIndicesArray.SetSize(1, 1);
this->m_BSplinePreTransformPointsArray.resize(1);
this->m_WithinBSplineSupportRegionArray.resize(1);
this->m_BSplineTransformWeights.SetSize(1);
this->m_BSplineTransformIndices.SetSize(1);
delete[] this->m_ThreaderBSplineTransformWeights;
this->m_ThreaderBSplineTransformWeights = ITK_NULLPTR;
delete[] this->m_ThreaderBSplineTransformIndices;
this->m_ThreaderBSplineTransformIndices = ITK_NULLPTR;
if ( this->m_UseCachingOfBSplineWeights )
{
m_BSplineTransformWeightsArray.SetSize(
m_NumberOfFixedImageSamples, m_NumBSplineWeights);
m_BSplineTransformIndicesArray.SetSize(
m_NumberOfFixedImageSamples, m_NumBSplineWeights);
m_BSplinePreTransformPointsArray.resize(m_NumberOfFixedImageSamples);
m_WithinBSplineSupportRegionArray.resize(m_NumberOfFixedImageSamples);
this->PreComputeTransformValues();
}
else
{
this->m_BSplineTransformWeights.SetSize(this->m_NumBSplineWeights);
this->m_BSplineTransformIndices.SetSize(this->m_NumBSplineWeights);
this->m_ThreaderBSplineTransformWeights = new BSplineTransformWeightsType[m_NumberOfThreads - 1];
this->m_ThreaderBSplineTransformIndices = new BSplineTransformIndexArrayType[m_NumberOfThreads - 1];
for ( ThreadIdType ithread = 0; ithread < m_NumberOfThreads - 1; ++ithread )
{
this->m_ThreaderBSplineTransformWeights[ithread].SetSize(this->m_NumBSplineWeights);
this->m_ThreaderBSplineTransformIndices[ithread].SetSize(this->m_NumBSplineWeights);
}
}
for ( unsigned int j = 0; j < FixedImageDimension; j++ )
{
this->m_BSplineParametersOffset[j] = j * this->m_BSplineTransform->GetNumberOfParametersPerDimension();
}
}
}
/**
* Use the indexes that have been passed to the metric
*/
template< typename TFixedImage, typename TMovingImage >
void
ImageToImageMetric< TFixedImage, TMovingImage >
::SampleFixedImageIndexes(FixedImageSampleContainer & samples) const
{
typename FixedImageSampleContainer::iterator iter;
SizeValueType len = static_cast<SizeValueType>( m_FixedImageIndexes.size() );
if ( len != m_NumberOfFixedImageSamples
|| samples.size() != m_NumberOfFixedImageSamples )
{
throw ExceptionObject(__FILE__, __LINE__,
"Index list size does not match desired number of samples");
}
iter = samples.begin();
for ( SizeValueType i = 0; i < len; i++ )
{
// Get sampled index
FixedImageIndexType index = m_FixedImageIndexes[i];
// Translate index to point
m_FixedImage->TransformIndexToPhysicalPoint(index, ( *iter ).point);
// Get sampled fixed image value
( *iter ).value = m_FixedImage->GetPixel(index);
( *iter ).valueIndex = 0;
++iter;
}
}
/**
* Sample the fixed image using a random walk
*/
template< typename TFixedImage, typename TMovingImage >
void
ImageToImageMetric< TFixedImage, TMovingImage >
::SampleFixedImageRegion(FixedImageSampleContainer & samples) const
{
if ( samples.size() != m_NumberOfFixedImageSamples )
{
throw ExceptionObject(__FILE__, __LINE__,
"Sample size does not match desired number of samples");
}
// Set up a random interator within the user specified fixed image region.
typedef ImageRandomConstIteratorWithIndex< FixedImageType > RandomIterator;
RandomIterator randIter( m_FixedImage, GetFixedImageRegion() );
randIter.ReinitializeSeed(Statistics::MersenneTwisterRandomVariateGenerator::GetInstance()->GetSeed());
if (m_ReseedIterator)
{
randIter.ReinitializeSeed();
}
else
{
randIter.ReinitializeSeed(m_RandomSeed++);
}
typename FixedImageSampleContainer::iterator iter;
typename FixedImageSampleContainer::const_iterator end = samples.end();
if ( m_FixedImageMask.IsNotNull()
|| m_UseFixedImageSamplesIntensityThreshold )
{
InputPointType inputPoint;
iter = samples.begin();
SizeValueType samplesFound = 0;
randIter.SetNumberOfSamples(m_NumberOfFixedImageSamples * 1000);
randIter.GoToBegin();
while ( iter != end )
{
if ( randIter.IsAtEnd() )
{
// Must be a small mask since after many random samples we don't
// have enough to fill the desired number. So, we will replicate
// the samples we've found so far to fill-in the desired number
// of samples
SizeValueType count = 0;
while ( iter != end )
{
( *iter ).point = samples[count].point;
( *iter ).value = samples[count].value;
( *iter ).valueIndex = 0;
++count;
if ( count >= samplesFound )
{
count = 0;
}
++iter;
}
break;
}
// Get sampled index
FixedImageIndexType index = randIter.GetIndex();
// Check if the Index is inside the mask, translate index to point
m_FixedImage->TransformIndexToPhysicalPoint(index, inputPoint);
if ( m_FixedImageMask.IsNotNull() )
{
double val;
if ( m_FixedImageMask->ValueAt(inputPoint, val) )
{
if ( Math::AlmostEquals( val, 0.0 ) )
{
++randIter; // jump to another random position
continue;
}
}
else
{
++randIter; // jump to another random position
continue;
}
}
if ( m_UseFixedImageSamplesIntensityThreshold
&& randIter.Get() < m_FixedImageSamplesIntensityThreshold )
{
++randIter;
continue;
}
// Translate index to point
( *iter ).point = inputPoint;
// Get sampled fixed image value
( *iter ).value = randIter.Get();
( *iter ).valueIndex = 0;
++samplesFound;
++randIter;
++iter;
}
}
else
{
randIter.SetNumberOfSamples(m_NumberOfFixedImageSamples);
randIter.GoToBegin();
for ( iter = samples.begin(); iter != end; ++iter )
{
// Get sampled index
FixedImageIndexType index = randIter.GetIndex();
// Translate index to point
m_FixedImage->TransformIndexToPhysicalPoint(index,
( *iter ).point);
// Get sampled fixed image value
( *iter ).value = randIter.Get();
( *iter ).valueIndex = 0;
// Jump to random position
++randIter;
}
}
}
/**
* Sample the fixed image domain using all pixels in the Fixed image region
*/
template< typename TFixedImage, typename TMovingImage >
void
ImageToImageMetric< TFixedImage, TMovingImage >
::SampleFullFixedImageRegion(FixedImageSampleContainer & samples) const
{
if ( samples.size() != m_NumberOfFixedImageSamples )
{
throw ExceptionObject(__FILE__, __LINE__,
"Sample size does not match desired number of samples");
}
// Set up a region interator within the user specified fixed image region.
typedef ImageRegionConstIteratorWithIndex< FixedImageType > RegionIterator;
RegionIterator regionIter( m_FixedImage, GetFixedImageRegion() );
regionIter.GoToBegin();
typename FixedImageSampleContainer::iterator iter;
typename FixedImageSampleContainer::const_iterator end = samples.end();
if ( m_FixedImageMask.IsNotNull()
|| m_UseFixedImageSamplesIntensityThreshold )
{
InputPointType inputPoint;
// repeat until we get enough samples to fill the array
iter = samples.begin();
while ( iter != end )
{
// Get sampled index
FixedImageIndexType index = regionIter.GetIndex();
// Check if the Index is inside the mask, translate index to point
m_FixedImage->TransformIndexToPhysicalPoint(index, inputPoint);
if ( m_FixedImageMask.IsNotNull() )
{
// If not inside the mask, ignore the point
if ( !m_FixedImageMask->IsInside(inputPoint) )
{
++regionIter; // jump to next pixel
if ( regionIter.IsAtEnd() )
{
regionIter.GoToBegin();
}
continue;
}
}
if ( m_UseFixedImageSamplesIntensityThreshold
&& regionIter.Get() < m_FixedImageSamplesIntensityThreshold )
{
++regionIter; // jump to next pixel
if ( regionIter.IsAtEnd() )
{
regionIter.GoToBegin();
}
continue;
}
// Translate index to point
( *iter ).point = inputPoint;
// Get sampled fixed image value
( *iter ).value = regionIter.Get();
( *iter ).valueIndex = 0;
++regionIter;
if ( regionIter.IsAtEnd() )
{
regionIter.GoToBegin();
}
++iter;
}
}
else // not restricting sample throwing to a mask
{
for ( iter = samples.begin(); iter != end; ++iter )
{
// Get sampled index
FixedImageIndexType index = regionIter.GetIndex();
// Translate index to point
m_FixedImage->TransformIndexToPhysicalPoint(index,
( *iter ).point);
// Get sampled fixed image value
( *iter ).value = regionIter.Get();
( *iter ).valueIndex = 0;
++regionIter;
if ( regionIter.IsAtEnd() )
{
regionIter.GoToBegin();
}
}
}
}
/**
* Compute the gradient image and assign it to m_GradientImage.
*/
template< typename TFixedImage, typename TMovingImage >
void
ImageToImageMetric< TFixedImage, TMovingImage >
::ComputeGradient()
{
GradientImageFilterPointer gradientFilter = GradientImageFilterType::New();
gradientFilter->SetInput(m_MovingImage);
const typename MovingImageType::SpacingType & spacing = m_MovingImage
->GetSpacing();
double maximumSpacing = 0.0;
for ( unsigned int i = 0; i < MovingImageDimension; i++ )
{
if ( spacing[i] > maximumSpacing )
{
maximumSpacing = spacing[i];
}
}
gradientFilter->SetSigma(maximumSpacing);
gradientFilter->SetNormalizeAcrossScale(true);
gradientFilter->SetNumberOfThreads(m_NumberOfThreads);
gradientFilter->SetUseImageDirection(true);
gradientFilter->Update();
m_GradientImage = gradientFilter->GetOutput();
}
// Method to reinitialize the seed of the random number generator
template< typename TFixedImage, typename TMovingImage >
void
ImageToImageMetric< TFixedImage, TMovingImage >
::ReinitializeSeed()
{
m_ReseedIterator = true;
}
// Method to reinitialize the seed of the random number generator
template< typename TFixedImage, typename TMovingImage >
void
ImageToImageMetric< TFixedImage, TMovingImage >
::ReinitializeSeed(int seed)
{
m_ReseedIterator = false;
m_RandomSeed = seed;
}
/**
* Cache pre-transformed points, weights and indices.
*/
template< typename TFixedImage, typename TMovingImage >
void
ImageToImageMetric< TFixedImage, TMovingImage >
::PreComputeTransformValues()
{
// Note: This code is specific to the b-spline deformable transform.
// Unfortunately, the BSplineTransform stores a
// pointer to parameters passed to SetParameters(). Since
// we're creating a dummy set of parameters below on the
// stack, this can cause a crash if the transform's
// parameters are not later reset with a more properly
// scoped set of parameters. In addition, we're overwriting
// any previously set parameters. In order to be kinder,
// we'll save a pointer to the current set of parameters
// and restore them after we're done.
// Note the address operator.
// const TransformParametersType* previousParameters = &
// m_Transform->GetParameters();
// Create all zero dummy transform parameters
ParametersType dummyParameters(m_NumberOfParameters);
dummyParameters.Fill(0.0);
m_Transform->SetParameters(dummyParameters);
// Cycle through each sampled fixed image point
BSplineTransformWeightsType weights(m_NumBSplineWeights);
BSplineTransformIndexArrayType indices(m_NumBSplineWeights);
bool valid;
MovingImagePointType mappedPoint;
// Declare iterators for iteration over the sample container
typename FixedImageSampleContainer::const_iterator fiter;
typename FixedImageSampleContainer::const_iterator fend =
m_FixedImageSamples.end();
SizeValueType counter = 0;
for ( fiter = m_FixedImageSamples.begin(); fiter != fend; ++fiter, counter++ )
{
m_BSplineTransform->TransformPoint(m_FixedImageSamples[counter].point,
mappedPoint, weights, indices, valid);
for ( SizeValueType k = 0; k < m_NumBSplineWeights; k++ )
{
m_BSplineTransformWeightsArray[counter][k] = weights[k];
m_BSplineTransformIndicesArray[counter][k] = indices[k];
}
m_BSplinePreTransformPointsArray[counter] = mappedPoint;
m_WithinBSplineSupportRegionArray[counter] = valid;
}
// Restore the previous parameters.
// m_Transform->SetParameters( *previousParameters );
}
/**
* Transform a point from FixedImage domain to MovingImage domain.
* This function also checks if mapped point is within support region.
*/
template< typename TFixedImage, typename TMovingImage >
void
ImageToImageMetric< TFixedImage, TMovingImage >
::TransformPoint(unsigned int sampleNumber,
MovingImagePointType & mappedPoint,
bool & sampleOk,
double & movingImageValue,
ThreadIdType threadId) const
{
sampleOk = true;
TransformType *transform;
if ( threadId > 0 )
{
transform = this->m_ThreaderTransform[threadId - 1];
}
else
{
transform = this->m_Transform;
}
if ( !m_TransformIsBSpline )
{
// Use generic transform to compute mapped position
mappedPoint = transform->TransformPoint(m_FixedImageSamples[sampleNumber].point);
sampleOk = true;
}
else
{
if ( this->m_UseCachingOfBSplineWeights )
{
sampleOk = m_WithinBSplineSupportRegionArray[sampleNumber];
if ( sampleOk )
{
// If the transform is BSplineDeformable, we can use the precomputed
// weights and indices to obtained the mapped position
const WeightsValueType *weights =
m_BSplineTransformWeightsArray[sampleNumber];
const IndexValueType *indices =
m_BSplineTransformIndicesArray[sampleNumber];
for ( unsigned int j = 0; j < FixedImageDimension; j++ )
{
mappedPoint[j] = m_BSplinePreTransformPointsArray[sampleNumber][j];
}
const ParametersType &LocalParameters = m_Transform->GetParameters();
for ( unsigned int k = 0; k < m_NumBSplineWeights; k++ )
{
for ( unsigned int j = 0; j < FixedImageDimension; j++ )
{
mappedPoint[j] += weights[k] * LocalParameters[indices[k]
+ m_BSplineParametersOffset[j]];
}
}
}
}
else
{
BSplineTransformWeightsType * weightsHelper;
BSplineTransformIndexArrayType *indicesHelper;
if ( threadId > 0 )
{
weightsHelper = &( this->m_ThreaderBSplineTransformWeights[threadId - 1] );
indicesHelper = &( this->m_ThreaderBSplineTransformIndices[threadId - 1] );
}
else
{
weightsHelper = &( this->m_BSplineTransformWeights );
indicesHelper = &( this->m_BSplineTransformIndices );
}
// If not caching values, we invoke the Transform to recompute the
// mapping of the point.
this->m_BSplineTransform->TransformPoint(
this->m_FixedImageSamples[sampleNumber].point,
mappedPoint, *weightsHelper, *indicesHelper, sampleOk);
}
}
if ( sampleOk )
{
// If user provided a mask over the Moving image
if ( m_MovingImageMask )
{
// Check if mapped point is within the support region of the moving image
// mask
sampleOk = sampleOk && m_MovingImageMask->IsInside(mappedPoint);
}
if ( m_InterpolatorIsBSpline )
{
// Check if mapped point inside image buffer
sampleOk = sampleOk && m_BSplineInterpolator->IsInsideBuffer(mappedPoint);
if ( sampleOk )
{
movingImageValue = m_BSplineInterpolator->Evaluate(mappedPoint, threadId);
}
}
else
{
// Check if mapped point inside image buffer
sampleOk = sampleOk && m_Interpolator->IsInsideBuffer(mappedPoint);
if ( sampleOk )
{
movingImageValue = m_Interpolator->Evaluate(mappedPoint);
}
}
}
}
/**
* Transform a point from FixedImage domain to MovingImage domain.
* This function also checks if mapped point is within support region.
*/
template< typename TFixedImage, typename TMovingImage >
void
ImageToImageMetric< TFixedImage, TMovingImage >
::TransformPointWithDerivatives(unsigned int sampleNumber,
MovingImagePointType & mappedPoint,
bool & sampleOk,
double & movingImageValue,
ImageDerivativesType & movingImageGradient,
ThreadIdType threadId) const
{
TransformType *transform;
sampleOk = true;
if ( threadId > 0 )
{
transform = this->m_ThreaderTransform[threadId - 1];
}
else
{
transform = this->m_Transform;
}
if ( !m_TransformIsBSpline )
{
// Use generic transform to compute mapped position
mappedPoint = transform->TransformPoint(m_FixedImageSamples[sampleNumber].point);
sampleOk = true;
}
else
{
if ( this->m_UseCachingOfBSplineWeights )
{
sampleOk = m_WithinBSplineSupportRegionArray[sampleNumber];
if ( sampleOk )
{
// If the transform is BSplineDeformable, we can use the precomputed
// weights and indices to obtained the mapped position
const WeightsValueType *weights =
m_BSplineTransformWeightsArray[sampleNumber];
const IndexValueType *indices =
m_BSplineTransformIndicesArray[sampleNumber];
const ParametersType &Local_Parameters=this->m_Transform->GetParameters();
for ( unsigned int j = 0; j < FixedImageDimension; j++ )
{
mappedPoint[j] = m_BSplinePreTransformPointsArray[sampleNumber][j];
}
for ( unsigned int k = 0; k < m_NumBSplineWeights; k++ )
{
for ( unsigned int j = 0; j < FixedImageDimension; j++ )
{
mappedPoint[j] += weights[k] * Local_Parameters[indices[k]
+ m_BSplineParametersOffset[j]];
}
}
}
}
else
{
BSplineTransformWeightsType * weightsHelper;
BSplineTransformIndexArrayType *indicesHelper;
if ( threadId > 0 )
{
weightsHelper = &( this->m_ThreaderBSplineTransformWeights[threadId - 1] );
indicesHelper = &( this->m_ThreaderBSplineTransformIndices[threadId - 1] );
}
else
{
weightsHelper = &( this->m_BSplineTransformWeights );
indicesHelper = &( this->m_BSplineTransformIndices );
}
// If not caching values, we invoke the Transform to recompute the
// mapping of the point.
this->m_BSplineTransform->TransformPoint(
this->m_FixedImageSamples[sampleNumber].point,
mappedPoint, *weightsHelper, *indicesHelper, sampleOk);
}
}
if ( sampleOk )
{
// If user provided a mask over the Moving image
if ( m_MovingImageMask )
{
// Check if mapped point is within the support region of the moving image
// mask
sampleOk = sampleOk && m_MovingImageMask->IsInside(mappedPoint);
}
if ( m_InterpolatorIsBSpline )
{
// Check if mapped point inside image buffer
sampleOk = sampleOk && m_BSplineInterpolator->IsInsideBuffer(mappedPoint);
if ( sampleOk )
{
this->m_BSplineInterpolator->EvaluateValueAndDerivative(mappedPoint,
movingImageValue,
movingImageGradient,
threadId);
}
}
else
{
// Check if mapped point inside image buffer
sampleOk = sampleOk && m_Interpolator->IsInsideBuffer(mappedPoint);
if ( sampleOk )
{
this->ComputeImageDerivatives(mappedPoint, movingImageGradient, threadId);
movingImageValue = this->m_Interpolator->Evaluate(mappedPoint);
}
}
}
}
/**
* Compute image derivatives using a central difference function
* if we are not using a BSplineInterpolator, which includes
* derivatives.
*/
template< typename TFixedImage, typename TMovingImage >
void
ImageToImageMetric< TFixedImage, TMovingImage >
::ComputeImageDerivatives(const MovingImagePointType & mappedPoint,
ImageDerivativesType & gradient,
ThreadIdType threadId) const
{
if ( m_InterpolatorIsBSpline )
{
// Computed moving image gradient using derivative BSpline kernel.
gradient = m_BSplineInterpolator->EvaluateDerivative(mappedPoint,
threadId);
}
else
{
if ( m_ComputeGradient )
{
ContinuousIndex< double, MovingImageDimension > tempIndex;
m_MovingImage->TransformPhysicalPointToContinuousIndex(mappedPoint,
tempIndex);
MovingImageIndexType mappedIndex;
mappedIndex.CopyWithRound(tempIndex);
gradient = m_GradientImage->GetPixel(mappedIndex);
}
else
{
// if not using the gradient image
gradient = m_DerivativeCalculator->Evaluate(mappedPoint);
}
}
}
template< typename TFixedImage, typename TMovingImage >
void
ImageToImageMetric< TFixedImage, TMovingImage >
::GetValueMultiThreadedPreProcessInitiate(void) const
{
this->SynchronizeTransforms();
m_Threader->SetSingleMethod( GetValueMultiThreadedPreProcess,
(void *)( &m_ThreaderParameter ) );
m_Threader->SingleMethodExecute();
}
template< typename TFixedImage, typename TMovingImage >
void
ImageToImageMetric< TFixedImage, TMovingImage >
::GetValueMultiThreadedInitiate(void) const
{
this->SynchronizeTransforms();
m_Threader->SetSingleMethod( GetValueMultiThreaded,
const_cast< void * >( static_cast< const void * >( &m_ThreaderParameter ) ) );
m_Threader->SingleMethodExecute();
for ( ThreadIdType threadId = 0; threadId < m_NumberOfThreads - 1; threadId++ )
{
this->m_NumberOfPixelsCounted += m_ThreaderNumberOfMovingImageSamples[threadId];
}
}
template< typename TFixedImage, typename TMovingImage >
void
ImageToImageMetric< TFixedImage, TMovingImage >
::GetValueMultiThreadedPostProcessInitiate(void) const
{
m_Threader->SetSingleMethod( GetValueMultiThreadedPostProcess,
const_cast< void * >( static_cast< const void * >( &m_ThreaderParameter ) ) );
m_Threader->SingleMethodExecute();
}
/**
* Get the match Measure
*/
template< typename TFixedImage, typename TMovingImage >
ITK_THREAD_RETURN_TYPE
ImageToImageMetric< TFixedImage, TMovingImage >
::GetValueMultiThreadedPreProcess(void *arg)
{
ThreadIdType threadId;
MultiThreaderParameterType *mtParam;
threadId = ( (MultiThreaderType::ThreadInfoStruct *)( arg ) )->ThreadID;
mtParam = (MultiThreaderParameterType *)
( ( (MultiThreaderType::ThreadInfoStruct *)( arg ) )->UserData );
mtParam->metric->GetValueThreadPreProcess(threadId, false);
return ITK_THREAD_RETURN_VALUE;
}
/**
* Get the match Measure
*/
template< typename TFixedImage, typename TMovingImage >
ITK_THREAD_RETURN_TYPE
ImageToImageMetric< TFixedImage, TMovingImage >
::GetValueMultiThreaded(void *arg)
{
ThreadIdType threadId;
MultiThreaderParameterType *mtParam;
threadId = ( (MultiThreaderType::ThreadInfoStruct *)( arg ) )->ThreadID;
mtParam = (MultiThreaderParameterType *)
( ( (MultiThreaderType::ThreadInfoStruct *)( arg ) )->UserData );
mtParam->metric->GetValueThread(threadId);
return ITK_THREAD_RETURN_VALUE;
}
/**
* Get the match Measure
*/
template< typename TFixedImage, typename TMovingImage >
ITK_THREAD_RETURN_TYPE
ImageToImageMetric< TFixedImage, TMovingImage >
::GetValueMultiThreadedPostProcess(void *arg)
{
ThreadIdType threadId;
MultiThreaderParameterType *mtParam;
threadId = ( (MultiThreaderType::ThreadInfoStruct *)( arg ) )->ThreadID;
mtParam = (MultiThreaderParameterType *)
( ( (MultiThreaderType::ThreadInfoStruct *)( arg ) )->UserData );
mtParam->metric->GetValueThreadPostProcess(threadId, false);
return ITK_THREAD_RETURN_VALUE;
}
template< typename TFixedImage, typename TMovingImage >
void
ImageToImageMetric< TFixedImage, TMovingImage >
::GetValueThread(ThreadIdType threadId) const
{
// Figure out how many samples to process
int chunkSize = m_NumberOfFixedImageSamples / m_NumberOfThreads;
// Skip to this thread's samples to process
unsigned int fixedImageSample = threadId * chunkSize;
if ( threadId == m_NumberOfThreads - 1 )
{
chunkSize = m_NumberOfFixedImageSamples
- ( ( m_NumberOfThreads - 1 )
* chunkSize );
}
if ( m_WithinThreadPreProcess )
{
this->GetValueThreadPreProcess(threadId, true);
}
// Process the samples
int numSamples = 0;
for ( int count = 0; count < chunkSize; ++count, ++fixedImageSample )
{
MovingImagePointType mappedPoint;
bool sampleOk;
double movingImageValue;
// Get moving image value
this->TransformPoint(fixedImageSample, mappedPoint, sampleOk, movingImageValue,
threadId);
if ( sampleOk )
{
// CALL USER FUNCTION
if ( GetValueThreadProcessSample(threadId, fixedImageSample,
mappedPoint, movingImageValue) )
{
++numSamples;
}
}
}
if ( threadId > 0 )
{
m_ThreaderNumberOfMovingImageSamples[threadId - 1] = numSamples;
}
else
{
m_NumberOfPixelsCounted = numSamples;
}
if ( m_WithinThreadPostProcess )
{
this->GetValueThreadPostProcess(threadId, true);
}
}
template< typename TFixedImage, typename TMovingImage >
void
ImageToImageMetric< TFixedImage, TMovingImage >
::GetValueAndDerivativeMultiThreadedPreProcessInitiate(void) const
{
this->SynchronizeTransforms();
m_Threader->SetSingleMethod( GetValueAndDerivativeMultiThreadedPreProcess,
(void *)( &m_ThreaderParameter ) );
m_Threader->SingleMethodExecute();
}
template< typename TFixedImage, typename TMovingImage >
void
ImageToImageMetric< TFixedImage, TMovingImage >
::GetValueAndDerivativeMultiThreadedInitiate(void) const
{
this->SynchronizeTransforms();
m_Threader->SetSingleMethod( GetValueAndDerivativeMultiThreaded,
const_cast< void * >( static_cast< const void * >( &m_ThreaderParameter ) ) );
m_Threader->SingleMethodExecute();
for ( ThreadIdType threadId = 0; threadId < m_NumberOfThreads - 1; threadId++ )
{
this->m_NumberOfPixelsCounted += m_ThreaderNumberOfMovingImageSamples[threadId];
}
}
template< typename TFixedImage, typename TMovingImage >
void
ImageToImageMetric< TFixedImage, TMovingImage >
::GetValueAndDerivativeMultiThreadedPostProcessInitiate(void) const
{
m_Threader->SetSingleMethod( GetValueAndDerivativeMultiThreadedPostProcess,
(void *)( &m_ThreaderParameter ) );
m_Threader->SingleMethodExecute();
}
/**
* Get the match Measure
*/
template< typename TFixedImage, typename TMovingImage >
ITK_THREAD_RETURN_TYPE
ImageToImageMetric< TFixedImage, TMovingImage >
::GetValueAndDerivativeMultiThreadedPreProcess(void *arg)
{
ThreadIdType threadId;
MultiThreaderParameterType *mtParam;
threadId = ( (MultiThreaderType::ThreadInfoStruct *)( arg ) )->ThreadID;
mtParam = (MultiThreaderParameterType *)
( ( (MultiThreaderType::ThreadInfoStruct *)( arg ) )->UserData );
mtParam->metric->GetValueAndDerivativeThreadPreProcess(threadId, false);
return ITK_THREAD_RETURN_VALUE;
}
/**
* Get the match Measure
*/
template< typename TFixedImage, typename TMovingImage >
ITK_THREAD_RETURN_TYPE
ImageToImageMetric< TFixedImage, TMovingImage >
::GetValueAndDerivativeMultiThreaded(void *arg)
{
ThreadIdType threadId;
MultiThreaderParameterType *mtParam;
threadId = ( (MultiThreaderType::ThreadInfoStruct *)( arg ) )->ThreadID;
mtParam = (MultiThreaderParameterType *)
( ( (MultiThreaderType::ThreadInfoStruct *)( arg ) )->UserData );
mtParam->metric->GetValueAndDerivativeThread(threadId);
return ITK_THREAD_RETURN_VALUE;
}
/**
* Get the match Measure
*/
template< typename TFixedImage, typename TMovingImage >
ITK_THREAD_RETURN_TYPE
ImageToImageMetric< TFixedImage, TMovingImage >
::GetValueAndDerivativeMultiThreadedPostProcess(void *arg)
{
ThreadIdType threadId;
MultiThreaderParameterType *mtParam;
threadId = ( (MultiThreaderType::ThreadInfoStruct *)( arg ) )->ThreadID;
mtParam = (MultiThreaderParameterType *)
( ( (MultiThreaderType::ThreadInfoStruct *)( arg ) )->UserData );
mtParam->metric->GetValueAndDerivativeThreadPostProcess(threadId, false);
return ITK_THREAD_RETURN_VALUE;
}
template< typename TFixedImage, typename TMovingImage >
void
ImageToImageMetric< TFixedImage, TMovingImage >
::GetValueAndDerivativeThread(ThreadIdType threadId) const
{
// Figure out how many samples to process
int chunkSize = m_NumberOfFixedImageSamples / m_NumberOfThreads;
// Skip to this thread's samples to process
unsigned int fixedImageSample = threadId * chunkSize;
if ( threadId == m_NumberOfThreads - 1 )
{
chunkSize = m_NumberOfFixedImageSamples
- ( ( m_NumberOfThreads - 1 )
* chunkSize );
}
int numSamples = 0;
if ( m_WithinThreadPreProcess )
{
this->GetValueAndDerivativeThreadPreProcess(threadId, true);
}
// Process the samples
MovingImagePointType mappedPoint;
bool sampleOk;
double movingImageValue;
ImageDerivativesType movingImageGradientValue;
for ( int count = 0; count < chunkSize; ++count, ++fixedImageSample )
{
// Get moving image value
TransformPointWithDerivatives(fixedImageSample, mappedPoint, sampleOk,
movingImageValue, movingImageGradientValue,
threadId);
if ( sampleOk )
{
// CALL USER FUNCTION
if ( this->GetValueAndDerivativeThreadProcessSample(threadId,
fixedImageSample,
mappedPoint,
movingImageValue,
movingImageGradientValue) )
{
++numSamples;
}
}
}
if ( threadId > 0 )
{
m_ThreaderNumberOfMovingImageSamples[threadId - 1] = numSamples;
}
else
{
m_NumberOfPixelsCounted = numSamples;
}
if ( m_WithinThreadPostProcess )
{
this->GetValueAndDerivativeThreadPostProcess(threadId, true);
}
}
/**
* PrintSelf
*/
template< typename TFixedImage, typename TMovingImage >
void
ImageToImageMetric< TFixedImage, TMovingImage >
::PrintSelf(std::ostream & os, Indent indent) const
{
Superclass::PrintSelf(os, indent);
os << indent << "NumberOfFixedImageSamples: ";
os << m_NumberOfFixedImageSamples << std::endl;
os << indent << "FixedImageSamplesIntensityThreshold: "
<< static_cast< typename NumericTraits< FixedImagePixelType >::PrintType >( m_FixedImageSamplesIntensityThreshold )
<< std::endl;
os << indent << "UseFixedImageSamplesIntensityThreshold: ";
os << m_UseFixedImageSamplesIntensityThreshold << std::endl;
if ( m_UseFixedImageIndexes )
{
os << indent << "Use Fixed Image Indexes: True" << std::endl;
os << indent << "Number of Fixed Image Indexes = "
<< m_FixedImageIndexes.size() << std::endl;
}
else
{
os << indent << "Use Fixed Image Indexes: False" << std::endl;
}
if ( m_UseSequentialSampling )
{
os << indent << "Use Sequential Sampling: True" << std::endl;
}
else
{
os << indent << "Use Sequential Sampling: False" << std::endl;
}
os << indent << "UseAllPixels: ";
os << m_UseAllPixels << std::endl;
os << indent << "ReseedIterator: " << m_ReseedIterator << std::endl;
os << indent << "RandomSeed: " << m_RandomSeed << std::endl;
os << indent << "Threader: " << m_Threader << std::endl;
os << indent << "Number of Threads: " << m_NumberOfThreads << std::endl;
os << indent << "ThreaderParameter: " << std::endl;
os << indent << "ThreaderNumberOfMovingImageSamples: " << std::endl;
if ( m_ThreaderNumberOfMovingImageSamples )
{
for ( ThreadIdType i = 0; i < m_NumberOfThreads - 1; i++ )
{
os << " Thread[" << i << "]= " << (unsigned int)m_ThreaderNumberOfMovingImageSamples[i] << std::endl;
}
}
os << indent << "ComputeGradient: "
<< static_cast< typename NumericTraits< bool >::PrintType >( m_ComputeGradient )
<< std::endl;
os << indent << "Moving Image: " << m_MovingImage.GetPointer() << std::endl;
os << indent << "Fixed Image: " << m_FixedImage.GetPointer() << std::endl;
os << indent << "Gradient Image: " << m_GradientImage.GetPointer()
<< std::endl;
os << indent << "Transform: " << m_Transform.GetPointer() << std::endl;
os << indent << "Interpolator: " << m_Interpolator.GetPointer() << std::endl;
os << indent << "FixedImageRegion: " << m_FixedImageRegion << std::endl;
os << indent << "Moving Image Mask: " << m_MovingImageMask.GetPointer()
<< std::endl;
os << indent << "Fixed Image Mask: " << m_FixedImageMask.GetPointer()
<< std::endl;
os << indent << "Number of Moving Image Samples: " << m_NumberOfPixelsCounted
<< std::endl;
os << indent << "UseCachingOfBSplineWeights: ";
os << this->m_UseCachingOfBSplineWeights << std::endl;
}
/** This method can be const because we are not altering the m_ThreaderTransform
* pointer. We are altering the object that m_ThreaderTransform[idx] points at.
* This is allowed under C++ const rules.
*/
template< typename TFixedImage, typename TMovingImage >
void
ImageToImageMetric< TFixedImage, TMovingImage >
::SynchronizeTransforms() const
{
for ( ThreadIdType threadId = 0; threadId < m_NumberOfThreads - 1; threadId++ )
{
/** Set the fixed parameters first. Some transforms have parameters which depend on
the values of the fixed parameters. For instance, the BSplineTransform
checks the grid size (part of the fixed parameters) before setting the parameters. */
this->m_ThreaderTransform[threadId]->SetFixedParameters( this->m_Transform->GetFixedParameters() );
this->m_ThreaderTransform[threadId]->SetParameters( this->m_Transform->GetParameters() );
}
}
} // end namespace itk
#endif
| [
"ruizhi@csail.mit.edu"
] | ruizhi@csail.mit.edu |
ded16192549a60cfed5e80b57b104ca1aefff2a4 | 5ebd5cee801215bc3302fca26dbe534e6992c086 | /blazetest/src/mathtest/hermitianmatrix/ColumnComplexTest.cpp | ee0df1ebb2e36c0eeedc43cf76be2da635420511 | [
"BSD-3-Clause"
] | permissive | mhochsteger/blaze | c66d8cf179deeab4f5bd692001cc917fe23e1811 | fd397e60717c4870d942055496d5b484beac9f1a | refs/heads/master | 2020-09-17T01:56:48.483627 | 2019-11-20T05:40:29 | 2019-11-20T05:41:35 | 223,951,030 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 4,448 | cpp | //=================================================================================================
/*!
// \file src/mathtest/hermitianmatrix/ColumnComplexTest.cpp
// \brief Source file for the HermitianMatrix column complex test
//
// Copyright (C) 2012-2019 Klaus Iglberger - All Rights Reserved
//
// This file is part of the Blaze library. You can redistribute it and/or modify it under
// the terms of the New (Revised) BSD 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 names of the Blaze development group 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 HOLDER 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.
*/
//=================================================================================================
//*************************************************************************************************
// Includes
//*************************************************************************************************
#include <cstdlib>
#include <iostream>
#include <blazetest/mathtest/hermitianmatrix/ColumnComplexTest.h>
#ifdef BLAZE_USE_HPX_THREADS
# include <hpx/hpx_main.hpp>
#endif
namespace blazetest {
namespace mathtest {
namespace hermitianmatrix {
//=================================================================================================
//
// CONSTRUCTORS
//
//=================================================================================================
//*************************************************************************************************
/*!\brief Constructor for the HermitianMatrix column complex test.
//
// \exception std::runtime_error Operation error detected.
*/
ColumnComplexTest::ColumnComplexTest()
{
testAssignment<DHT>();
testAddAssign<DHT>();
testSubAssign<DHT>();
testMultAssign<DHT>();
testAssignment<DOHT>();
testAddAssign<DOHT>();
testSubAssign<DOHT>();
testMultAssign<DOHT>();
testAssignment<SHT>();
testAddAssign<SHT>();
testSubAssign<SHT>();
testMultAssign<SHT>();
testAssignment<SOHT>();
testAddAssign<SOHT>();
testSubAssign<SOHT>();
testMultAssign<SOHT>();
}
//*************************************************************************************************
} // namespace hermitianmatrix
} // namespace mathtest
} // namespace blazetest
//=================================================================================================
//
// MAIN FUNCTION
//
//=================================================================================================
//*************************************************************************************************
int main()
{
std::cout << " Running HermitianMatrix column complex test..." << std::endl;
try
{
RUN_HERMITIANMATRIX_COLUMNCOMPLEX_TEST;
}
catch( std::exception& ex ) {
std::cerr << "\n\n ERROR DETECTED during HermitianMatrix column complex test:\n"
<< ex.what() << "\n";
return EXIT_FAILURE;
}
return EXIT_SUCCESS;
}
//*************************************************************************************************
| [
"klaus.iglberger@gmail.com"
] | klaus.iglberger@gmail.com |
2cc9ba0134c115877e663618f0e899aa53ab952f | f0cadc6e99528a8f74c3a9ada97bbcdcd125e355 | /src/server/gameserver/EffectShutDown.cpp | 4bc222c91dff788e5064a046d403170255eb271c | [] | no_license | najosky/opendarkeden_server | 0878f5a870224024b01c739822f00b072b1e08b9 | 3cb931caa151ff43d26dfb8fc727d268ae6e1409 | refs/heads/master | 2021-06-18T23:22:28.775384 | 2017-06-16T17:31:48 | 2017-06-16T17:31:48 | null | 0 | 0 | null | null | null | null | UHC | C++ | false | false | 6,950 | cpp | //----------------------------------------------------------------------
//
// Filename : EffectShutDown.cpp
// Written by : elca
//
//----------------------------------------------------------------------
// include files
#include "Assert.h"
#include "EffectShutDown.h"
#include "Gpackets/GCSystemMessage.h"
#include "Zone.h"
#include "unistd.h"
#include "signal.h"
#include "DB.h"
#include "Corpse.h"
#include "EventShutdown.h"
#include "ClientManager.h"
#include "ZoneInfoManager.h"
#include "ZonePlayerManager.h"
#include "ZoneGroupManager.h"
#include "StringPool.h"
#include <stdio.h>
//----------------------------------------------------------------------
// constructor
//----------------------------------------------------------------------
EffectShutDown::EffectShutDown ()
throw (Error)
{
__BEGIN_TRY
__END_CATCH
}
//----------------------------------------------------------------------
// constructor
//----------------------------------------------------------------------
EffectShutDown::EffectShutDown (Zone* pZone , ZoneCoord_t x , ZoneCoord_t y , Corpse* pCorpse , Turn_t delay)
throw (Error)
: Effect(pZone,x,y,pCorpse,delay)
{
__BEGIN_TRY
Assert(getZone() != NULL);
Assert(getTarget() != NULL);
__END_CATCH
}
//----------------------------------------------------------------------
// destructor
//----------------------------------------------------------------------
EffectShutDown::~EffectShutDown ()
throw ()
{
__BEGIN_TRY
__END_CATCH
}
void EffectShutDown::affect()
throw(Error)
{
__BEGIN_TRY
Creature* pCreature = dynamic_cast<Creature*>(m_pTarget);
affect(pCreature);
__END_CATCH
}
//----------------------------------------------------------------------
// affect
//----------------------------------------------------------------------
void EffectShutDown::affect(Creature* pCreature)
throw(Error)
{
__BEGIN_TRY
Statement* pStmt = NULL;
Result* pResult = NULL;
Timeval nextTime = getNextTime();
Timeval deadLine = getDeadline();
Turn_t RemainTime = deadLine.tv_sec - nextTime.tv_sec;
/* StringStream msg;
msg << (int)RemainTime << "초 후에 서버가 종료됩니다. 잠시 후 접속해 주시기 바랍니다. "; */
char msg[80];
sprintf( msg, g_pStringPool->c_str( STRID_SERVER_SHUT_DOWN_COUNT_DOWN ),
(int)RemainTime );
GCSystemMessage gcSystemMessage;
gcSystemMessage.setMessage(msg);
setNextTime(m_Delay);
BEGIN_DB
{
pStmt = g_pDatabaseManager->getConnection("DARKEDEN")->createStatement();
pResult = pStmt->executeQuery("SELECT MAX(ZoneGroupID) FROM ZoneGroupInfo");
pResult->next();
BYTE GroupCount = pResult->getInt(1) + 1;
for (int i = 1; i < GroupCount; i++)
{
ZoneGroup* pZoneGroup;
try
{
pZoneGroup = g_pZoneGroupManager->getZoneGroup(i);
}
catch (NoSuchElementException&)
{
SAFE_DELETE(pStmt);
throw Error("Critical Error : ZoneInfoManager에 해당 존그룹이 존재하지 않습니다.");
}
ZonePlayerManager* pZonePlayerManager = pZoneGroup->getZonePlayerManager();
pZonePlayerManager->broadcastPacket(&gcSystemMessage);
}
SAFE_DELETE(pStmt);
}
END_DB(pStmt)
/*
ZoneInfo* pZoneInfo;
for (int i = 1; i < 19; i++) {
try {
pZoneInfo = g_pZoneInfoManager->getZoneInfo(i);
} catch (NoSuchElementException) {
throw Error("Critical Error : ZoneInfoManager에 해당 존이 존재하지 않습니다.");
}
ZoneGroup* pZoneGroup;
try {
pZoneGroup = g_pZoneGroupManager->getZoneGroup(pZoneInfo->getZoneGroupID());
} catch (NoSuchElementException) {
throw Error("Critical Error : ZoneInfoManager에 해당 존그룹이 존재하지 않습니다.");
}
Zone* pZone = pZoneGroup->getZone(i);
pZone->broadcastPacket(&gcSystemMessage);
}
*/
__END_CATCH
}
//----------------------------------------------------------------------
// affect to target
// 이 이펙트는 타일에 종속되지 않으므로, affect()는 호출되지 않는다.
// 왜냐하면, target은 생성자에서 지정되며, 아무런 일도 하지 않기 때문이다.
//----------------------------------------------------------------------
void EffectShutDown::affect (Zone* pZone , ZoneCoord_t x , ZoneCoord_t y , Object* pTarget)
throw (Error)
{
__BEGIN_TRY
throw UnsupportedError();
__END_CATCH
}
//--------------------------------------------------------------------
// unaffect()
//--------------------------------------------------------------------
void EffectShutDown::unaffect()
throw(Error)
{
__BEGIN_TRY
Statement* pStmt = NULL;
Result* pResult = NULL;
// StringStream msg;
// msg << "서버가 종료됩니다.";
GCSystemMessage gcSystemMessage;
gcSystemMessage.setMessage( g_pStringPool->getString( STRID_SERVER_SHUT_DOWN ) );
BEGIN_DB
{
pStmt = g_pDatabaseManager->getConnection("DARKEDEN")->createStatement();
pResult = pStmt->executeQuery("SELECT MAX(ZoneGroupID) FROM ZoneGroupInfo");
pResult->next();
BYTE GroupCount = pResult->getInt(1) + 1;
for (int i = 1; i < GroupCount; i++)
{
ZoneGroup* pZoneGroup;
try
{
pZoneGroup = g_pZoneGroupManager->getZoneGroup(i);
}
catch (NoSuchElementException&)
{
SAFE_DELETE(pStmt);
throw Error("Critical Error : ZoneInfoManager에 해당 존그룹이 존재하지 않습니다.");
}
ZonePlayerManager* pZonePlayerManager = pZoneGroup->getZonePlayerManager();
pZonePlayerManager->broadcastPacket(&gcSystemMessage);
}
SAFE_DELETE(pStmt);
}
END_DB(pStmt)
//kill(getpid() , 9);
EventShutdown* pEventShutdown = new EventShutdown(NULL);
pEventShutdown->setDeadline( 0 );
g_pClientManager->addEvent( pEventShutdown );
__END_CATCH
}
//--------------------------------------------------------------------
// unaffect
//--------------------------------------------------------------------
void EffectShutDown::unaffect(Creature* pCreature)
throw(Error)
{
__BEGIN_TRY
__END_CATCH
}
//----------------------------------------------------------------------
// remove effect from target
//----------------------------------------------------------------------
void EffectShutDown::unaffect (Zone* pZone , ZoneCoord_t x , ZoneCoord_t y , Object* pTarget)
throw (Error)
{
__BEGIN_TRY
__END_CATCH
}
//----------------------------------------------------------------------
// get debug string
//----------------------------------------------------------------------
string EffectShutDown::toString () const
throw ()
{
StringStream msg;
if (m_pZone)
{
msg << "EffectShutDown("
<< "ZoneID:" << (int)m_pZone->getZoneID()
<< ",X:" << (int)getX()
<< ",Y:" << (int)getY();
}
if (m_pTarget)
{
msg << ",Target:" << m_pTarget->toString();
}
else
{
msg << ",Target:NULL";
}
msg << ",Deadline:" << (int)m_Deadline.tv_sec
<< "." << (int)m_Deadline.tv_usec
<< ")";
return msg.toString();
}
| [
"paulomatew@gmail.com"
] | paulomatew@gmail.com |
209549e94312d15ff15b1ca6f535f0d08e9192c8 | c776476e9d06b3779d744641e758ac3a2c15cddc | /examples/litmus/c/run-scripts/tmp_5/MP+dmb.sy+ctrl-wsi-rfi-addr-[fr-rf].c.cbmc_out.cpp | 4ef3c43f680427518e87048d89cfd883a5ea7ed0 | [] | no_license | ashutosh0gupta/llvm_bmc | aaac7961c723ba6f7ffd77a39559e0e52432eade | 0287c4fb180244e6b3c599a9902507f05c8a7234 | refs/heads/master | 2023-08-02T17:14:06.178723 | 2023-07-31T10:46:53 | 2023-07-31T10:46:53 | 143,100,825 | 3 | 4 | null | 2023-05-25T05:50:55 | 2018-08-01T03:47:00 | C++ | UTF-8 | C++ | false | false | 59,974 | cpp | // Global variabls:
// 0:vars:3
// 3:atom_1_X0_1:1
// 4:atom_1_X5_2:1
// 5:atom_1_X7_0:1
// 6:atom_1_X9_1:1
// Local global variabls:
// 0:thr0:1
// 1:thr1:1
// 2:thr2:1
#define ADDRSIZE 7
#define LOCALADDRSIZE 3
#define NTHREAD 4
#define NCONTEXT 5
#define ASSUME(stmt) __CPROVER_assume(stmt)
#define ASSERT(stmt) __CPROVER_assert(stmt, "error")
#define max(a,b) (a>b?a:b)
char __get_rng();
char get_rng( char from, char to ) {
char ret = __get_rng();
ASSUME(ret >= from && ret <= to);
return ret;
}
char get_rng_th( char from, char to ) {
char ret = __get_rng();
ASSUME(ret >= from && ret <= to);
return ret;
}
int main(int argc, char **argv) {
// Declare arrays for intial value version in contexts
int local_mem[LOCALADDRSIZE];
// Dumping initializations
local_mem[0+0] = 0;
local_mem[1+0] = 0;
local_mem[2+0] = 0;
int cstart[NTHREAD];
int creturn[NTHREAD];
// declare arrays for contexts activity
int active[NCONTEXT];
int ctx_used[NCONTEXT];
// declare arrays for intial value version in contexts
int meminit_[ADDRSIZE*NCONTEXT];
#define meminit(x,k) meminit_[(x)*NCONTEXT+k]
int coinit_[ADDRSIZE*NCONTEXT];
#define coinit(x,k) coinit_[(x)*NCONTEXT+k]
int deltainit_[ADDRSIZE*NCONTEXT];
#define deltainit(x,k) deltainit_[(x)*NCONTEXT+k]
// declare arrays for running value version in contexts
int mem_[ADDRSIZE*NCONTEXT];
#define mem(x,k) mem_[(x)*NCONTEXT+k]
int co_[ADDRSIZE*NCONTEXT];
#define co(x,k) co_[(x)*NCONTEXT+k]
int delta_[ADDRSIZE*NCONTEXT];
#define delta(x,k) delta_[(x)*NCONTEXT+k]
// declare arrays for local buffer and observed writes
int buff_[NTHREAD*ADDRSIZE];
#define buff(x,k) buff_[(x)*ADDRSIZE+k]
int pw_[NTHREAD*ADDRSIZE];
#define pw(x,k) pw_[(x)*ADDRSIZE+k]
// declare arrays for context stamps
char cr_[NTHREAD*ADDRSIZE];
#define cr(x,k) cr_[(x)*ADDRSIZE+k]
char iw_[NTHREAD*ADDRSIZE];
#define iw(x,k) iw_[(x)*ADDRSIZE+k]
char cw_[NTHREAD*ADDRSIZE];
#define cw(x,k) cw_[(x)*ADDRSIZE+k]
char cx_[NTHREAD*ADDRSIZE];
#define cx(x,k) cx_[(x)*ADDRSIZE+k]
char is_[NTHREAD*ADDRSIZE];
#define is(x,k) is_[(x)*ADDRSIZE+k]
char cs_[NTHREAD*ADDRSIZE];
#define cs(x,k) cs_[(x)*ADDRSIZE+k]
char crmax_[NTHREAD*ADDRSIZE];
#define crmax(x,k) crmax_[(x)*ADDRSIZE+k]
char sforbid_[ADDRSIZE*NCONTEXT];
#define sforbid(x,k) sforbid_[(x)*NCONTEXT+k]
// declare arrays for synchronizations
int cl[NTHREAD];
int cdy[NTHREAD];
int cds[NTHREAD];
int cdl[NTHREAD];
int cisb[NTHREAD];
int caddr[NTHREAD];
int cctrl[NTHREAD];
int r0= 0;
char creg_r0;
char creg__r0__0_;
int r1= 0;
char creg_r1;
int r2= 0;
char creg_r2;
int r3= 0;
char creg_r3;
int r4= 0;
char creg_r4;
int r5= 0;
char creg_r5;
int r6= 0;
char creg_r6;
char creg__r0__1_;
char creg__r1__2_;
char creg__r5__0_;
char creg__r6__1_;
int r7= 0;
char creg_r7;
int r8= 0;
char creg_r8;
int r9= 0;
char creg_r9;
int r10= 0;
char creg_r10;
int r11= 0;
char creg_r11;
char creg__r11__2_;
int r12= 0;
char creg_r12;
char creg__r12__1_;
int r13= 0;
char creg_r13;
char creg__r13__2_;
int r14= 0;
char creg_r14;
int r15= 0;
char creg_r15;
int r16= 0;
char creg_r16;
int r17= 0;
char creg_r17;
int r18= 0;
char creg_r18;
int r19= 0;
char creg_r19;
int r20= 0;
char creg_r20;
int r21= 0;
char creg_r21;
int r22= 0;
char creg_r22;
int r23= 0;
char creg_r23;
char creg__r23__1_;
int r24= 0;
char creg_r24;
char old_cctrl= 0;
char old_cr= 0;
char old_cdy= 0;
char old_cw= 0;
char new_creg= 0;
buff(0,0) = 0;
pw(0,0) = 0;
cr(0,0) = 0;
iw(0,0) = 0;
cw(0,0) = 0;
cx(0,0) = 0;
is(0,0) = 0;
cs(0,0) = 0;
crmax(0,0) = 0;
buff(0,1) = 0;
pw(0,1) = 0;
cr(0,1) = 0;
iw(0,1) = 0;
cw(0,1) = 0;
cx(0,1) = 0;
is(0,1) = 0;
cs(0,1) = 0;
crmax(0,1) = 0;
buff(0,2) = 0;
pw(0,2) = 0;
cr(0,2) = 0;
iw(0,2) = 0;
cw(0,2) = 0;
cx(0,2) = 0;
is(0,2) = 0;
cs(0,2) = 0;
crmax(0,2) = 0;
buff(0,3) = 0;
pw(0,3) = 0;
cr(0,3) = 0;
iw(0,3) = 0;
cw(0,3) = 0;
cx(0,3) = 0;
is(0,3) = 0;
cs(0,3) = 0;
crmax(0,3) = 0;
buff(0,4) = 0;
pw(0,4) = 0;
cr(0,4) = 0;
iw(0,4) = 0;
cw(0,4) = 0;
cx(0,4) = 0;
is(0,4) = 0;
cs(0,4) = 0;
crmax(0,4) = 0;
buff(0,5) = 0;
pw(0,5) = 0;
cr(0,5) = 0;
iw(0,5) = 0;
cw(0,5) = 0;
cx(0,5) = 0;
is(0,5) = 0;
cs(0,5) = 0;
crmax(0,5) = 0;
buff(0,6) = 0;
pw(0,6) = 0;
cr(0,6) = 0;
iw(0,6) = 0;
cw(0,6) = 0;
cx(0,6) = 0;
is(0,6) = 0;
cs(0,6) = 0;
crmax(0,6) = 0;
cl[0] = 0;
cdy[0] = 0;
cds[0] = 0;
cdl[0] = 0;
cisb[0] = 0;
caddr[0] = 0;
cctrl[0] = 0;
cstart[0] = get_rng(0,NCONTEXT-1);
creturn[0] = get_rng(0,NCONTEXT-1);
buff(1,0) = 0;
pw(1,0) = 0;
cr(1,0) = 0;
iw(1,0) = 0;
cw(1,0) = 0;
cx(1,0) = 0;
is(1,0) = 0;
cs(1,0) = 0;
crmax(1,0) = 0;
buff(1,1) = 0;
pw(1,1) = 0;
cr(1,1) = 0;
iw(1,1) = 0;
cw(1,1) = 0;
cx(1,1) = 0;
is(1,1) = 0;
cs(1,1) = 0;
crmax(1,1) = 0;
buff(1,2) = 0;
pw(1,2) = 0;
cr(1,2) = 0;
iw(1,2) = 0;
cw(1,2) = 0;
cx(1,2) = 0;
is(1,2) = 0;
cs(1,2) = 0;
crmax(1,2) = 0;
buff(1,3) = 0;
pw(1,3) = 0;
cr(1,3) = 0;
iw(1,3) = 0;
cw(1,3) = 0;
cx(1,3) = 0;
is(1,3) = 0;
cs(1,3) = 0;
crmax(1,3) = 0;
buff(1,4) = 0;
pw(1,4) = 0;
cr(1,4) = 0;
iw(1,4) = 0;
cw(1,4) = 0;
cx(1,4) = 0;
is(1,4) = 0;
cs(1,4) = 0;
crmax(1,4) = 0;
buff(1,5) = 0;
pw(1,5) = 0;
cr(1,5) = 0;
iw(1,5) = 0;
cw(1,5) = 0;
cx(1,5) = 0;
is(1,5) = 0;
cs(1,5) = 0;
crmax(1,5) = 0;
buff(1,6) = 0;
pw(1,6) = 0;
cr(1,6) = 0;
iw(1,6) = 0;
cw(1,6) = 0;
cx(1,6) = 0;
is(1,6) = 0;
cs(1,6) = 0;
crmax(1,6) = 0;
cl[1] = 0;
cdy[1] = 0;
cds[1] = 0;
cdl[1] = 0;
cisb[1] = 0;
caddr[1] = 0;
cctrl[1] = 0;
cstart[1] = get_rng(0,NCONTEXT-1);
creturn[1] = get_rng(0,NCONTEXT-1);
buff(2,0) = 0;
pw(2,0) = 0;
cr(2,0) = 0;
iw(2,0) = 0;
cw(2,0) = 0;
cx(2,0) = 0;
is(2,0) = 0;
cs(2,0) = 0;
crmax(2,0) = 0;
buff(2,1) = 0;
pw(2,1) = 0;
cr(2,1) = 0;
iw(2,1) = 0;
cw(2,1) = 0;
cx(2,1) = 0;
is(2,1) = 0;
cs(2,1) = 0;
crmax(2,1) = 0;
buff(2,2) = 0;
pw(2,2) = 0;
cr(2,2) = 0;
iw(2,2) = 0;
cw(2,2) = 0;
cx(2,2) = 0;
is(2,2) = 0;
cs(2,2) = 0;
crmax(2,2) = 0;
buff(2,3) = 0;
pw(2,3) = 0;
cr(2,3) = 0;
iw(2,3) = 0;
cw(2,3) = 0;
cx(2,3) = 0;
is(2,3) = 0;
cs(2,3) = 0;
crmax(2,3) = 0;
buff(2,4) = 0;
pw(2,4) = 0;
cr(2,4) = 0;
iw(2,4) = 0;
cw(2,4) = 0;
cx(2,4) = 0;
is(2,4) = 0;
cs(2,4) = 0;
crmax(2,4) = 0;
buff(2,5) = 0;
pw(2,5) = 0;
cr(2,5) = 0;
iw(2,5) = 0;
cw(2,5) = 0;
cx(2,5) = 0;
is(2,5) = 0;
cs(2,5) = 0;
crmax(2,5) = 0;
buff(2,6) = 0;
pw(2,6) = 0;
cr(2,6) = 0;
iw(2,6) = 0;
cw(2,6) = 0;
cx(2,6) = 0;
is(2,6) = 0;
cs(2,6) = 0;
crmax(2,6) = 0;
cl[2] = 0;
cdy[2] = 0;
cds[2] = 0;
cdl[2] = 0;
cisb[2] = 0;
caddr[2] = 0;
cctrl[2] = 0;
cstart[2] = get_rng(0,NCONTEXT-1);
creturn[2] = get_rng(0,NCONTEXT-1);
buff(3,0) = 0;
pw(3,0) = 0;
cr(3,0) = 0;
iw(3,0) = 0;
cw(3,0) = 0;
cx(3,0) = 0;
is(3,0) = 0;
cs(3,0) = 0;
crmax(3,0) = 0;
buff(3,1) = 0;
pw(3,1) = 0;
cr(3,1) = 0;
iw(3,1) = 0;
cw(3,1) = 0;
cx(3,1) = 0;
is(3,1) = 0;
cs(3,1) = 0;
crmax(3,1) = 0;
buff(3,2) = 0;
pw(3,2) = 0;
cr(3,2) = 0;
iw(3,2) = 0;
cw(3,2) = 0;
cx(3,2) = 0;
is(3,2) = 0;
cs(3,2) = 0;
crmax(3,2) = 0;
buff(3,3) = 0;
pw(3,3) = 0;
cr(3,3) = 0;
iw(3,3) = 0;
cw(3,3) = 0;
cx(3,3) = 0;
is(3,3) = 0;
cs(3,3) = 0;
crmax(3,3) = 0;
buff(3,4) = 0;
pw(3,4) = 0;
cr(3,4) = 0;
iw(3,4) = 0;
cw(3,4) = 0;
cx(3,4) = 0;
is(3,4) = 0;
cs(3,4) = 0;
crmax(3,4) = 0;
buff(3,5) = 0;
pw(3,5) = 0;
cr(3,5) = 0;
iw(3,5) = 0;
cw(3,5) = 0;
cx(3,5) = 0;
is(3,5) = 0;
cs(3,5) = 0;
crmax(3,5) = 0;
buff(3,6) = 0;
pw(3,6) = 0;
cr(3,6) = 0;
iw(3,6) = 0;
cw(3,6) = 0;
cx(3,6) = 0;
is(3,6) = 0;
cs(3,6) = 0;
crmax(3,6) = 0;
cl[3] = 0;
cdy[3] = 0;
cds[3] = 0;
cdl[3] = 0;
cisb[3] = 0;
caddr[3] = 0;
cctrl[3] = 0;
cstart[3] = get_rng(0,NCONTEXT-1);
creturn[3] = get_rng(0,NCONTEXT-1);
// Dumping initializations
mem(0+0,0) = 0;
mem(0+1,0) = 0;
mem(0+2,0) = 0;
mem(3+0,0) = 0;
mem(4+0,0) = 0;
mem(5+0,0) = 0;
mem(6+0,0) = 0;
// Dumping context matching equalities
co(0,0) = 0;
delta(0,0) = -1;
mem(0,1) = meminit(0,1);
co(0,1) = coinit(0,1);
delta(0,1) = deltainit(0,1);
mem(0,2) = meminit(0,2);
co(0,2) = coinit(0,2);
delta(0,2) = deltainit(0,2);
mem(0,3) = meminit(0,3);
co(0,3) = coinit(0,3);
delta(0,3) = deltainit(0,3);
mem(0,4) = meminit(0,4);
co(0,4) = coinit(0,4);
delta(0,4) = deltainit(0,4);
co(1,0) = 0;
delta(1,0) = -1;
mem(1,1) = meminit(1,1);
co(1,1) = coinit(1,1);
delta(1,1) = deltainit(1,1);
mem(1,2) = meminit(1,2);
co(1,2) = coinit(1,2);
delta(1,2) = deltainit(1,2);
mem(1,3) = meminit(1,3);
co(1,3) = coinit(1,3);
delta(1,3) = deltainit(1,3);
mem(1,4) = meminit(1,4);
co(1,4) = coinit(1,4);
delta(1,4) = deltainit(1,4);
co(2,0) = 0;
delta(2,0) = -1;
mem(2,1) = meminit(2,1);
co(2,1) = coinit(2,1);
delta(2,1) = deltainit(2,1);
mem(2,2) = meminit(2,2);
co(2,2) = coinit(2,2);
delta(2,2) = deltainit(2,2);
mem(2,3) = meminit(2,3);
co(2,3) = coinit(2,3);
delta(2,3) = deltainit(2,3);
mem(2,4) = meminit(2,4);
co(2,4) = coinit(2,4);
delta(2,4) = deltainit(2,4);
co(3,0) = 0;
delta(3,0) = -1;
mem(3,1) = meminit(3,1);
co(3,1) = coinit(3,1);
delta(3,1) = deltainit(3,1);
mem(3,2) = meminit(3,2);
co(3,2) = coinit(3,2);
delta(3,2) = deltainit(3,2);
mem(3,3) = meminit(3,3);
co(3,3) = coinit(3,3);
delta(3,3) = deltainit(3,3);
mem(3,4) = meminit(3,4);
co(3,4) = coinit(3,4);
delta(3,4) = deltainit(3,4);
co(4,0) = 0;
delta(4,0) = -1;
mem(4,1) = meminit(4,1);
co(4,1) = coinit(4,1);
delta(4,1) = deltainit(4,1);
mem(4,2) = meminit(4,2);
co(4,2) = coinit(4,2);
delta(4,2) = deltainit(4,2);
mem(4,3) = meminit(4,3);
co(4,3) = coinit(4,3);
delta(4,3) = deltainit(4,3);
mem(4,4) = meminit(4,4);
co(4,4) = coinit(4,4);
delta(4,4) = deltainit(4,4);
co(5,0) = 0;
delta(5,0) = -1;
mem(5,1) = meminit(5,1);
co(5,1) = coinit(5,1);
delta(5,1) = deltainit(5,1);
mem(5,2) = meminit(5,2);
co(5,2) = coinit(5,2);
delta(5,2) = deltainit(5,2);
mem(5,3) = meminit(5,3);
co(5,3) = coinit(5,3);
delta(5,3) = deltainit(5,3);
mem(5,4) = meminit(5,4);
co(5,4) = coinit(5,4);
delta(5,4) = deltainit(5,4);
co(6,0) = 0;
delta(6,0) = -1;
mem(6,1) = meminit(6,1);
co(6,1) = coinit(6,1);
delta(6,1) = deltainit(6,1);
mem(6,2) = meminit(6,2);
co(6,2) = coinit(6,2);
delta(6,2) = deltainit(6,2);
mem(6,3) = meminit(6,3);
co(6,3) = coinit(6,3);
delta(6,3) = deltainit(6,3);
mem(6,4) = meminit(6,4);
co(6,4) = coinit(6,4);
delta(6,4) = deltainit(6,4);
// Dumping thread 1
int ret_thread_1 = 0;
cdy[1] = get_rng(0,NCONTEXT-1);
ASSUME(cdy[1] >= cstart[1]);
T1BLOCK0:
// call void @llvm.dbg.value(metadata i8* %arg, metadata !40, metadata !DIExpression()), !dbg !49
// br label %label_1, !dbg !50
goto T1BLOCK1;
T1BLOCK1:
// call void @llvm.dbg.label(metadata !48), !dbg !51
// call void @llvm.dbg.value(metadata i64* getelementptr inbounds ([3 x i64], [3 x i64]* @vars, i64 0, i64 0), metadata !41, metadata !DIExpression()), !dbg !52
// call void @llvm.dbg.value(metadata i64 2, metadata !44, metadata !DIExpression()), !dbg !52
// store atomic i64 2, i64* getelementptr inbounds ([3 x i64], [3 x i64]* @vars, i64 0, i64 0) monotonic, align 8, !dbg !53
// ST: Guess
iw(1,0) = get_rng(0,NCONTEXT-1);// 1 ASSIGN STIW _l22_c3
old_cw = cw(1,0);
cw(1,0) = get_rng(0,NCONTEXT-1);// 1 ASSIGN STCOM _l22_c3
// Check
ASSUME(active[iw(1,0)] == 1);
ASSUME(active[cw(1,0)] == 1);
ASSUME(sforbid(0,cw(1,0))== 0);
ASSUME(iw(1,0) >= 0);
ASSUME(iw(1,0) >= 0);
ASSUME(cw(1,0) >= iw(1,0));
ASSUME(cw(1,0) >= old_cw);
ASSUME(cw(1,0) >= cr(1,0));
ASSUME(cw(1,0) >= cl[1]);
ASSUME(cw(1,0) >= cisb[1]);
ASSUME(cw(1,0) >= cdy[1]);
ASSUME(cw(1,0) >= cdl[1]);
ASSUME(cw(1,0) >= cds[1]);
ASSUME(cw(1,0) >= cctrl[1]);
ASSUME(cw(1,0) >= caddr[1]);
// Update
caddr[1] = max(caddr[1],0);
buff(1,0) = 2;
mem(0,cw(1,0)) = 2;
co(0,cw(1,0))+=1;
delta(0,cw(1,0)) = -1;
ASSUME(creturn[1] >= cw(1,0));
// call void (...) @dmbsy(), !dbg !54
// dumbsy: Guess
old_cdy = cdy[1];
cdy[1] = get_rng(0,NCONTEXT-1);
// Check
ASSUME(cdy[1] >= old_cdy);
ASSUME(cdy[1] >= cisb[1]);
ASSUME(cdy[1] >= cdl[1]);
ASSUME(cdy[1] >= cds[1]);
ASSUME(cdy[1] >= cctrl[1]);
ASSUME(cdy[1] >= cw(1,0+0));
ASSUME(cdy[1] >= cw(1,0+1));
ASSUME(cdy[1] >= cw(1,0+2));
ASSUME(cdy[1] >= cw(1,3+0));
ASSUME(cdy[1] >= cw(1,4+0));
ASSUME(cdy[1] >= cw(1,5+0));
ASSUME(cdy[1] >= cw(1,6+0));
ASSUME(cdy[1] >= cr(1,0+0));
ASSUME(cdy[1] >= cr(1,0+1));
ASSUME(cdy[1] >= cr(1,0+2));
ASSUME(cdy[1] >= cr(1,3+0));
ASSUME(cdy[1] >= cr(1,4+0));
ASSUME(cdy[1] >= cr(1,5+0));
ASSUME(cdy[1] >= cr(1,6+0));
ASSUME(creturn[1] >= cdy[1]);
// call void @llvm.dbg.value(metadata i64* getelementptr inbounds ([3 x i64], [3 x i64]* @vars, i64 0, i64 1), metadata !45, metadata !DIExpression()), !dbg !55
// call void @llvm.dbg.value(metadata i64 1, metadata !47, metadata !DIExpression()), !dbg !55
// store atomic i64 1, i64* getelementptr inbounds ([3 x i64], [3 x i64]* @vars, i64 0, i64 1) monotonic, align 8, !dbg !56
// ST: Guess
iw(1,0+1*1) = get_rng(0,NCONTEXT-1);// 1 ASSIGN STIW _l24_c3
old_cw = cw(1,0+1*1);
cw(1,0+1*1) = get_rng(0,NCONTEXT-1);// 1 ASSIGN STCOM _l24_c3
// Check
ASSUME(active[iw(1,0+1*1)] == 1);
ASSUME(active[cw(1,0+1*1)] == 1);
ASSUME(sforbid(0+1*1,cw(1,0+1*1))== 0);
ASSUME(iw(1,0+1*1) >= 0);
ASSUME(iw(1,0+1*1) >= 0);
ASSUME(cw(1,0+1*1) >= iw(1,0+1*1));
ASSUME(cw(1,0+1*1) >= old_cw);
ASSUME(cw(1,0+1*1) >= cr(1,0+1*1));
ASSUME(cw(1,0+1*1) >= cl[1]);
ASSUME(cw(1,0+1*1) >= cisb[1]);
ASSUME(cw(1,0+1*1) >= cdy[1]);
ASSUME(cw(1,0+1*1) >= cdl[1]);
ASSUME(cw(1,0+1*1) >= cds[1]);
ASSUME(cw(1,0+1*1) >= cctrl[1]);
ASSUME(cw(1,0+1*1) >= caddr[1]);
// Update
caddr[1] = max(caddr[1],0);
buff(1,0+1*1) = 1;
mem(0+1*1,cw(1,0+1*1)) = 1;
co(0+1*1,cw(1,0+1*1))+=1;
delta(0+1*1,cw(1,0+1*1)) = -1;
ASSUME(creturn[1] >= cw(1,0+1*1));
// ret i8* null, !dbg !57
ret_thread_1 = (- 1);
goto T1BLOCK_END;
T1BLOCK_END:
// Dumping thread 2
int ret_thread_2 = 0;
cdy[2] = get_rng(0,NCONTEXT-1);
ASSUME(cdy[2] >= cstart[2]);
T2BLOCK0:
// call void @llvm.dbg.value(metadata i8* %arg, metadata !60, metadata !DIExpression()), !dbg !90
// br label %label_2, !dbg !72
goto T2BLOCK1;
T2BLOCK1:
// call void @llvm.dbg.label(metadata !88), !dbg !92
// call void @llvm.dbg.value(metadata i64* getelementptr inbounds ([3 x i64], [3 x i64]* @vars, i64 0, i64 1), metadata !62, metadata !DIExpression()), !dbg !93
// %0 = load atomic i64, i64* getelementptr inbounds ([3 x i64], [3 x i64]* @vars, i64 0, i64 1) monotonic, align 8, !dbg !75
// LD: Guess
old_cr = cr(2,0+1*1);
cr(2,0+1*1) = get_rng(0,NCONTEXT-1);// 2 ASSIGN LDCOM _l30_c15
// Check
ASSUME(active[cr(2,0+1*1)] == 2);
ASSUME(cr(2,0+1*1) >= iw(2,0+1*1));
ASSUME(cr(2,0+1*1) >= 0);
ASSUME(cr(2,0+1*1) >= cdy[2]);
ASSUME(cr(2,0+1*1) >= cisb[2]);
ASSUME(cr(2,0+1*1) >= cdl[2]);
ASSUME(cr(2,0+1*1) >= cl[2]);
// Update
creg_r0 = cr(2,0+1*1);
crmax(2,0+1*1) = max(crmax(2,0+1*1),cr(2,0+1*1));
caddr[2] = max(caddr[2],0);
if(cr(2,0+1*1) < cw(2,0+1*1)) {
r0 = buff(2,0+1*1);
ASSUME((!(( (cw(2,0+1*1) < 1) && (1 < crmax(2,0+1*1)) )))||(sforbid(0+1*1,1)> 0));
ASSUME((!(( (cw(2,0+1*1) < 2) && (2 < crmax(2,0+1*1)) )))||(sforbid(0+1*1,2)> 0));
ASSUME((!(( (cw(2,0+1*1) < 3) && (3 < crmax(2,0+1*1)) )))||(sforbid(0+1*1,3)> 0));
ASSUME((!(( (cw(2,0+1*1) < 4) && (4 < crmax(2,0+1*1)) )))||(sforbid(0+1*1,4)> 0));
} else {
if(pw(2,0+1*1) != co(0+1*1,cr(2,0+1*1))) {
ASSUME(cr(2,0+1*1) >= old_cr);
}
pw(2,0+1*1) = co(0+1*1,cr(2,0+1*1));
r0 = mem(0+1*1,cr(2,0+1*1));
}
ASSUME(creturn[2] >= cr(2,0+1*1));
// call void @llvm.dbg.value(metadata i64 %0, metadata !64, metadata !DIExpression()), !dbg !93
// %conv = trunc i64 %0 to i32, !dbg !76
// call void @llvm.dbg.value(metadata i32 %conv, metadata !61, metadata !DIExpression()), !dbg !90
// %tobool = icmp ne i32 %conv, 0, !dbg !77
creg__r0__0_ = max(0,creg_r0);
// br i1 %tobool, label %if.then, label %if.else, !dbg !79
old_cctrl = cctrl[2];
cctrl[2] = get_rng(0,NCONTEXT-1);
ASSUME(cctrl[2] >= old_cctrl);
ASSUME(cctrl[2] >= creg__r0__0_);
if((r0!=0)) {
goto T2BLOCK2;
} else {
goto T2BLOCK3;
}
T2BLOCK2:
// br label %lbl_LC00, !dbg !80
goto T2BLOCK4;
T2BLOCK3:
// br label %lbl_LC00, !dbg !81
goto T2BLOCK4;
T2BLOCK4:
// call void @llvm.dbg.label(metadata !89), !dbg !101
// call void @llvm.dbg.value(metadata i64* getelementptr inbounds ([3 x i64], [3 x i64]* @vars, i64 0, i64 2), metadata !65, metadata !DIExpression()), !dbg !102
// call void @llvm.dbg.value(metadata i64 1, metadata !67, metadata !DIExpression()), !dbg !102
// store atomic i64 1, i64* getelementptr inbounds ([3 x i64], [3 x i64]* @vars, i64 0, i64 2) monotonic, align 8, !dbg !84
// ST: Guess
iw(2,0+2*1) = get_rng(0,NCONTEXT-1);// 2 ASSIGN STIW _l33_c3
old_cw = cw(2,0+2*1);
cw(2,0+2*1) = get_rng(0,NCONTEXT-1);// 2 ASSIGN STCOM _l33_c3
// Check
ASSUME(active[iw(2,0+2*1)] == 2);
ASSUME(active[cw(2,0+2*1)] == 2);
ASSUME(sforbid(0+2*1,cw(2,0+2*1))== 0);
ASSUME(iw(2,0+2*1) >= 0);
ASSUME(iw(2,0+2*1) >= 0);
ASSUME(cw(2,0+2*1) >= iw(2,0+2*1));
ASSUME(cw(2,0+2*1) >= old_cw);
ASSUME(cw(2,0+2*1) >= cr(2,0+2*1));
ASSUME(cw(2,0+2*1) >= cl[2]);
ASSUME(cw(2,0+2*1) >= cisb[2]);
ASSUME(cw(2,0+2*1) >= cdy[2]);
ASSUME(cw(2,0+2*1) >= cdl[2]);
ASSUME(cw(2,0+2*1) >= cds[2]);
ASSUME(cw(2,0+2*1) >= cctrl[2]);
ASSUME(cw(2,0+2*1) >= caddr[2]);
// Update
caddr[2] = max(caddr[2],0);
buff(2,0+2*1) = 1;
mem(0+2*1,cw(2,0+2*1)) = 1;
co(0+2*1,cw(2,0+2*1))+=1;
delta(0+2*1,cw(2,0+2*1)) = -1;
ASSUME(creturn[2] >= cw(2,0+2*1));
// call void @llvm.dbg.value(metadata i64* getelementptr inbounds ([3 x i64], [3 x i64]* @vars, i64 0, i64 2), metadata !68, metadata !DIExpression()), !dbg !104
// call void @llvm.dbg.value(metadata i64 2, metadata !70, metadata !DIExpression()), !dbg !104
// store atomic i64 2, i64* getelementptr inbounds ([3 x i64], [3 x i64]* @vars, i64 0, i64 2) monotonic, align 8, !dbg !86
// ST: Guess
iw(2,0+2*1) = get_rng(0,NCONTEXT-1);// 2 ASSIGN STIW _l34_c3
old_cw = cw(2,0+2*1);
cw(2,0+2*1) = get_rng(0,NCONTEXT-1);// 2 ASSIGN STCOM _l34_c3
// Check
ASSUME(active[iw(2,0+2*1)] == 2);
ASSUME(active[cw(2,0+2*1)] == 2);
ASSUME(sforbid(0+2*1,cw(2,0+2*1))== 0);
ASSUME(iw(2,0+2*1) >= 0);
ASSUME(iw(2,0+2*1) >= 0);
ASSUME(cw(2,0+2*1) >= iw(2,0+2*1));
ASSUME(cw(2,0+2*1) >= old_cw);
ASSUME(cw(2,0+2*1) >= cr(2,0+2*1));
ASSUME(cw(2,0+2*1) >= cl[2]);
ASSUME(cw(2,0+2*1) >= cisb[2]);
ASSUME(cw(2,0+2*1) >= cdy[2]);
ASSUME(cw(2,0+2*1) >= cdl[2]);
ASSUME(cw(2,0+2*1) >= cds[2]);
ASSUME(cw(2,0+2*1) >= cctrl[2]);
ASSUME(cw(2,0+2*1) >= caddr[2]);
// Update
caddr[2] = max(caddr[2],0);
buff(2,0+2*1) = 2;
mem(0+2*1,cw(2,0+2*1)) = 2;
co(0+2*1,cw(2,0+2*1))+=1;
delta(0+2*1,cw(2,0+2*1)) = -1;
ASSUME(creturn[2] >= cw(2,0+2*1));
// call void @llvm.dbg.value(metadata i64* getelementptr inbounds ([3 x i64], [3 x i64]* @vars, i64 0, i64 2), metadata !72, metadata !DIExpression()), !dbg !106
// %1 = load atomic i64, i64* getelementptr inbounds ([3 x i64], [3 x i64]* @vars, i64 0, i64 2) monotonic, align 8, !dbg !88
// LD: Guess
old_cr = cr(2,0+2*1);
cr(2,0+2*1) = get_rng(0,NCONTEXT-1);// 2 ASSIGN LDCOM _l35_c15
// Check
ASSUME(active[cr(2,0+2*1)] == 2);
ASSUME(cr(2,0+2*1) >= iw(2,0+2*1));
ASSUME(cr(2,0+2*1) >= 0);
ASSUME(cr(2,0+2*1) >= cdy[2]);
ASSUME(cr(2,0+2*1) >= cisb[2]);
ASSUME(cr(2,0+2*1) >= cdl[2]);
ASSUME(cr(2,0+2*1) >= cl[2]);
// Update
creg_r1 = cr(2,0+2*1);
crmax(2,0+2*1) = max(crmax(2,0+2*1),cr(2,0+2*1));
caddr[2] = max(caddr[2],0);
if(cr(2,0+2*1) < cw(2,0+2*1)) {
r1 = buff(2,0+2*1);
ASSUME((!(( (cw(2,0+2*1) < 1) && (1 < crmax(2,0+2*1)) )))||(sforbid(0+2*1,1)> 0));
ASSUME((!(( (cw(2,0+2*1) < 2) && (2 < crmax(2,0+2*1)) )))||(sforbid(0+2*1,2)> 0));
ASSUME((!(( (cw(2,0+2*1) < 3) && (3 < crmax(2,0+2*1)) )))||(sforbid(0+2*1,3)> 0));
ASSUME((!(( (cw(2,0+2*1) < 4) && (4 < crmax(2,0+2*1)) )))||(sforbid(0+2*1,4)> 0));
} else {
if(pw(2,0+2*1) != co(0+2*1,cr(2,0+2*1))) {
ASSUME(cr(2,0+2*1) >= old_cr);
}
pw(2,0+2*1) = co(0+2*1,cr(2,0+2*1));
r1 = mem(0+2*1,cr(2,0+2*1));
}
ASSUME(creturn[2] >= cr(2,0+2*1));
// call void @llvm.dbg.value(metadata i64 %1, metadata !74, metadata !DIExpression()), !dbg !106
// %conv6 = trunc i64 %1 to i32, !dbg !89
// call void @llvm.dbg.value(metadata i32 %conv6, metadata !71, metadata !DIExpression()), !dbg !90
// %xor = xor i32 %conv6, %conv6, !dbg !90
creg_r2 = creg_r1;
r2 = r1 ^ r1;
// call void @llvm.dbg.value(metadata i32 %xor, metadata !75, metadata !DIExpression()), !dbg !90
// %add = add nsw i32 0, %xor, !dbg !91
creg_r3 = max(0,creg_r2);
r3 = 0 + r2;
// %idxprom = sext i32 %add to i64, !dbg !91
// %arrayidx = getelementptr inbounds [3 x i64], [3 x i64]* @vars, i64 0, i64 %idxprom, !dbg !91
r4 = 0+r3*1;
creg_r4 = creg_r3;
// call void @llvm.dbg.value(metadata i64* %arrayidx, metadata !77, metadata !DIExpression()), !dbg !111
// %2 = load atomic i64, i64* %arrayidx monotonic, align 8, !dbg !91
// LD: Guess
old_cr = cr(2,r4);
cr(2,r4) = get_rng(0,NCONTEXT-1);// 2 ASSIGN LDCOM _l37_c16
// Check
ASSUME(active[cr(2,r4)] == 2);
ASSUME(cr(2,r4) >= iw(2,r4));
ASSUME(cr(2,r4) >= creg_r4);
ASSUME(cr(2,r4) >= cdy[2]);
ASSUME(cr(2,r4) >= cisb[2]);
ASSUME(cr(2,r4) >= cdl[2]);
ASSUME(cr(2,r4) >= cl[2]);
// Update
creg_r5 = cr(2,r4);
crmax(2,r4) = max(crmax(2,r4),cr(2,r4));
caddr[2] = max(caddr[2],creg_r4);
if(cr(2,r4) < cw(2,r4)) {
r5 = buff(2,r4);
ASSUME((!(( (cw(2,r4) < 1) && (1 < crmax(2,r4)) )))||(sforbid(r4,1)> 0));
ASSUME((!(( (cw(2,r4) < 2) && (2 < crmax(2,r4)) )))||(sforbid(r4,2)> 0));
ASSUME((!(( (cw(2,r4) < 3) && (3 < crmax(2,r4)) )))||(sforbid(r4,3)> 0));
ASSUME((!(( (cw(2,r4) < 4) && (4 < crmax(2,r4)) )))||(sforbid(r4,4)> 0));
} else {
if(pw(2,r4) != co(r4,cr(2,r4))) {
ASSUME(cr(2,r4) >= old_cr);
}
pw(2,r4) = co(r4,cr(2,r4));
r5 = mem(r4,cr(2,r4));
}
ASSUME(creturn[2] >= cr(2,r4));
// call void @llvm.dbg.value(metadata i64 %2, metadata !79, metadata !DIExpression()), !dbg !111
// %conv10 = trunc i64 %2 to i32, !dbg !93
// call void @llvm.dbg.value(metadata i32 %conv10, metadata !76, metadata !DIExpression()), !dbg !90
// call void @llvm.dbg.value(metadata i64* getelementptr inbounds ([3 x i64], [3 x i64]* @vars, i64 0, i64 0), metadata !81, metadata !DIExpression()), !dbg !113
// %3 = load atomic i64, i64* getelementptr inbounds ([3 x i64], [3 x i64]* @vars, i64 0, i64 0) monotonic, align 8, !dbg !95
// LD: Guess
old_cr = cr(2,0);
cr(2,0) = get_rng(0,NCONTEXT-1);// 2 ASSIGN LDCOM _l38_c16
// Check
ASSUME(active[cr(2,0)] == 2);
ASSUME(cr(2,0) >= iw(2,0));
ASSUME(cr(2,0) >= 0);
ASSUME(cr(2,0) >= cdy[2]);
ASSUME(cr(2,0) >= cisb[2]);
ASSUME(cr(2,0) >= cdl[2]);
ASSUME(cr(2,0) >= cl[2]);
// Update
creg_r6 = cr(2,0);
crmax(2,0) = max(crmax(2,0),cr(2,0));
caddr[2] = max(caddr[2],0);
if(cr(2,0) < cw(2,0)) {
r6 = buff(2,0);
ASSUME((!(( (cw(2,0) < 1) && (1 < crmax(2,0)) )))||(sforbid(0,1)> 0));
ASSUME((!(( (cw(2,0) < 2) && (2 < crmax(2,0)) )))||(sforbid(0,2)> 0));
ASSUME((!(( (cw(2,0) < 3) && (3 < crmax(2,0)) )))||(sforbid(0,3)> 0));
ASSUME((!(( (cw(2,0) < 4) && (4 < crmax(2,0)) )))||(sforbid(0,4)> 0));
} else {
if(pw(2,0) != co(0,cr(2,0))) {
ASSUME(cr(2,0) >= old_cr);
}
pw(2,0) = co(0,cr(2,0));
r6 = mem(0,cr(2,0));
}
ASSUME(creturn[2] >= cr(2,0));
// call void @llvm.dbg.value(metadata i64 %3, metadata !83, metadata !DIExpression()), !dbg !113
// %conv14 = trunc i64 %3 to i32, !dbg !96
// call void @llvm.dbg.value(metadata i32 %conv14, metadata !80, metadata !DIExpression()), !dbg !90
// %cmp = icmp eq i32 %conv, 1, !dbg !97
creg__r0__1_ = max(0,creg_r0);
// %conv15 = zext i1 %cmp to i32, !dbg !97
// call void @llvm.dbg.value(metadata i32 %conv15, metadata !84, metadata !DIExpression()), !dbg !90
// store i32 %conv15, i32* @atom_1_X0_1, align 4, !dbg !98, !tbaa !99
// ST: Guess
iw(2,3) = get_rng(0,NCONTEXT-1);// 2 ASSIGN STIW _l40_c15
old_cw = cw(2,3);
cw(2,3) = get_rng(0,NCONTEXT-1);// 2 ASSIGN STCOM _l40_c15
// Check
ASSUME(active[iw(2,3)] == 2);
ASSUME(active[cw(2,3)] == 2);
ASSUME(sforbid(3,cw(2,3))== 0);
ASSUME(iw(2,3) >= creg__r0__1_);
ASSUME(iw(2,3) >= 0);
ASSUME(cw(2,3) >= iw(2,3));
ASSUME(cw(2,3) >= old_cw);
ASSUME(cw(2,3) >= cr(2,3));
ASSUME(cw(2,3) >= cl[2]);
ASSUME(cw(2,3) >= cisb[2]);
ASSUME(cw(2,3) >= cdy[2]);
ASSUME(cw(2,3) >= cdl[2]);
ASSUME(cw(2,3) >= cds[2]);
ASSUME(cw(2,3) >= cctrl[2]);
ASSUME(cw(2,3) >= caddr[2]);
// Update
caddr[2] = max(caddr[2],0);
buff(2,3) = (r0==1);
mem(3,cw(2,3)) = (r0==1);
co(3,cw(2,3))+=1;
delta(3,cw(2,3)) = -1;
ASSUME(creturn[2] >= cw(2,3));
// %cmp16 = icmp eq i32 %conv6, 2, !dbg !103
creg__r1__2_ = max(0,creg_r1);
// %conv17 = zext i1 %cmp16 to i32, !dbg !103
// call void @llvm.dbg.value(metadata i32 %conv17, metadata !85, metadata !DIExpression()), !dbg !90
// store i32 %conv17, i32* @atom_1_X5_2, align 4, !dbg !104, !tbaa !99
// ST: Guess
iw(2,4) = get_rng(0,NCONTEXT-1);// 2 ASSIGN STIW _l42_c15
old_cw = cw(2,4);
cw(2,4) = get_rng(0,NCONTEXT-1);// 2 ASSIGN STCOM _l42_c15
// Check
ASSUME(active[iw(2,4)] == 2);
ASSUME(active[cw(2,4)] == 2);
ASSUME(sforbid(4,cw(2,4))== 0);
ASSUME(iw(2,4) >= creg__r1__2_);
ASSUME(iw(2,4) >= 0);
ASSUME(cw(2,4) >= iw(2,4));
ASSUME(cw(2,4) >= old_cw);
ASSUME(cw(2,4) >= cr(2,4));
ASSUME(cw(2,4) >= cl[2]);
ASSUME(cw(2,4) >= cisb[2]);
ASSUME(cw(2,4) >= cdy[2]);
ASSUME(cw(2,4) >= cdl[2]);
ASSUME(cw(2,4) >= cds[2]);
ASSUME(cw(2,4) >= cctrl[2]);
ASSUME(cw(2,4) >= caddr[2]);
// Update
caddr[2] = max(caddr[2],0);
buff(2,4) = (r1==2);
mem(4,cw(2,4)) = (r1==2);
co(4,cw(2,4))+=1;
delta(4,cw(2,4)) = -1;
ASSUME(creturn[2] >= cw(2,4));
// %cmp18 = icmp eq i32 %conv10, 0, !dbg !105
creg__r5__0_ = max(0,creg_r5);
// %conv19 = zext i1 %cmp18 to i32, !dbg !105
// call void @llvm.dbg.value(metadata i32 %conv19, metadata !86, metadata !DIExpression()), !dbg !90
// store i32 %conv19, i32* @atom_1_X7_0, align 4, !dbg !106, !tbaa !99
// ST: Guess
iw(2,5) = get_rng(0,NCONTEXT-1);// 2 ASSIGN STIW _l44_c15
old_cw = cw(2,5);
cw(2,5) = get_rng(0,NCONTEXT-1);// 2 ASSIGN STCOM _l44_c15
// Check
ASSUME(active[iw(2,5)] == 2);
ASSUME(active[cw(2,5)] == 2);
ASSUME(sforbid(5,cw(2,5))== 0);
ASSUME(iw(2,5) >= creg__r5__0_);
ASSUME(iw(2,5) >= 0);
ASSUME(cw(2,5) >= iw(2,5));
ASSUME(cw(2,5) >= old_cw);
ASSUME(cw(2,5) >= cr(2,5));
ASSUME(cw(2,5) >= cl[2]);
ASSUME(cw(2,5) >= cisb[2]);
ASSUME(cw(2,5) >= cdy[2]);
ASSUME(cw(2,5) >= cdl[2]);
ASSUME(cw(2,5) >= cds[2]);
ASSUME(cw(2,5) >= cctrl[2]);
ASSUME(cw(2,5) >= caddr[2]);
// Update
caddr[2] = max(caddr[2],0);
buff(2,5) = (r5==0);
mem(5,cw(2,5)) = (r5==0);
co(5,cw(2,5))+=1;
delta(5,cw(2,5)) = -1;
ASSUME(creturn[2] >= cw(2,5));
// %cmp20 = icmp eq i32 %conv14, 1, !dbg !107
creg__r6__1_ = max(0,creg_r6);
// %conv21 = zext i1 %cmp20 to i32, !dbg !107
// call void @llvm.dbg.value(metadata i32 %conv21, metadata !87, metadata !DIExpression()), !dbg !90
// store i32 %conv21, i32* @atom_1_X9_1, align 4, !dbg !108, !tbaa !99
// ST: Guess
iw(2,6) = get_rng(0,NCONTEXT-1);// 2 ASSIGN STIW _l46_c15
old_cw = cw(2,6);
cw(2,6) = get_rng(0,NCONTEXT-1);// 2 ASSIGN STCOM _l46_c15
// Check
ASSUME(active[iw(2,6)] == 2);
ASSUME(active[cw(2,6)] == 2);
ASSUME(sforbid(6,cw(2,6))== 0);
ASSUME(iw(2,6) >= creg__r6__1_);
ASSUME(iw(2,6) >= 0);
ASSUME(cw(2,6) >= iw(2,6));
ASSUME(cw(2,6) >= old_cw);
ASSUME(cw(2,6) >= cr(2,6));
ASSUME(cw(2,6) >= cl[2]);
ASSUME(cw(2,6) >= cisb[2]);
ASSUME(cw(2,6) >= cdy[2]);
ASSUME(cw(2,6) >= cdl[2]);
ASSUME(cw(2,6) >= cds[2]);
ASSUME(cw(2,6) >= cctrl[2]);
ASSUME(cw(2,6) >= caddr[2]);
// Update
caddr[2] = max(caddr[2],0);
buff(2,6) = (r6==1);
mem(6,cw(2,6)) = (r6==1);
co(6,cw(2,6))+=1;
delta(6,cw(2,6)) = -1;
ASSUME(creturn[2] >= cw(2,6));
// ret i8* null, !dbg !109
ret_thread_2 = (- 1);
goto T2BLOCK_END;
T2BLOCK_END:
// Dumping thread 3
int ret_thread_3 = 0;
cdy[3] = get_rng(0,NCONTEXT-1);
ASSUME(cdy[3] >= cstart[3]);
T3BLOCK0:
// call void @llvm.dbg.value(metadata i8* %arg, metadata !131, metadata !DIExpression()), !dbg !136
// br label %label_3, !dbg !47
goto T3BLOCK1;
T3BLOCK1:
// call void @llvm.dbg.label(metadata !135), !dbg !138
// call void @llvm.dbg.value(metadata i64* getelementptr inbounds ([3 x i64], [3 x i64]* @vars, i64 0, i64 0), metadata !132, metadata !DIExpression()), !dbg !139
// call void @llvm.dbg.value(metadata i64 1, metadata !134, metadata !DIExpression()), !dbg !139
// store atomic i64 1, i64* getelementptr inbounds ([3 x i64], [3 x i64]* @vars, i64 0, i64 0) monotonic, align 8, !dbg !50
// ST: Guess
iw(3,0) = get_rng(0,NCONTEXT-1);// 3 ASSIGN STIW _l52_c3
old_cw = cw(3,0);
cw(3,0) = get_rng(0,NCONTEXT-1);// 3 ASSIGN STCOM _l52_c3
// Check
ASSUME(active[iw(3,0)] == 3);
ASSUME(active[cw(3,0)] == 3);
ASSUME(sforbid(0,cw(3,0))== 0);
ASSUME(iw(3,0) >= 0);
ASSUME(iw(3,0) >= 0);
ASSUME(cw(3,0) >= iw(3,0));
ASSUME(cw(3,0) >= old_cw);
ASSUME(cw(3,0) >= cr(3,0));
ASSUME(cw(3,0) >= cl[3]);
ASSUME(cw(3,0) >= cisb[3]);
ASSUME(cw(3,0) >= cdy[3]);
ASSUME(cw(3,0) >= cdl[3]);
ASSUME(cw(3,0) >= cds[3]);
ASSUME(cw(3,0) >= cctrl[3]);
ASSUME(cw(3,0) >= caddr[3]);
// Update
caddr[3] = max(caddr[3],0);
buff(3,0) = 1;
mem(0,cw(3,0)) = 1;
co(0,cw(3,0))+=1;
delta(0,cw(3,0)) = -1;
ASSUME(creturn[3] >= cw(3,0));
// ret i8* null, !dbg !51
ret_thread_3 = (- 1);
goto T3BLOCK_END;
T3BLOCK_END:
// Dumping thread 0
int ret_thread_0 = 0;
cdy[0] = get_rng(0,NCONTEXT-1);
ASSUME(cdy[0] >= cstart[0]);
T0BLOCK0:
// %thr0 = alloca i64, align 8
// %thr1 = alloca i64, align 8
// %thr2 = alloca i64, align 8
// call void @llvm.dbg.value(metadata i32 %argc, metadata !149, metadata !DIExpression()), !dbg !191
// call void @llvm.dbg.value(metadata i8** %argv, metadata !150, metadata !DIExpression()), !dbg !191
// %0 = bitcast i64* %thr0 to i8*, !dbg !87
// call void @llvm.lifetime.start.p0i8(i64 8, i8* %0) #7, !dbg !87
// call void @llvm.dbg.declare(metadata i64* %thr0, metadata !151, metadata !DIExpression()), !dbg !193
// %1 = bitcast i64* %thr1 to i8*, !dbg !89
// call void @llvm.lifetime.start.p0i8(i64 8, i8* %1) #7, !dbg !89
// call void @llvm.dbg.declare(metadata i64* %thr1, metadata !155, metadata !DIExpression()), !dbg !195
// %2 = bitcast i64* %thr2 to i8*, !dbg !91
// call void @llvm.lifetime.start.p0i8(i64 8, i8* %2) #7, !dbg !91
// call void @llvm.dbg.declare(metadata i64* %thr2, metadata !156, metadata !DIExpression()), !dbg !197
// call void @llvm.dbg.value(metadata i64* getelementptr inbounds ([3 x i64], [3 x i64]* @vars, i64 0, i64 2), metadata !157, metadata !DIExpression()), !dbg !198
// call void @llvm.dbg.value(metadata i64 0, metadata !159, metadata !DIExpression()), !dbg !198
// store atomic i64 0, i64* getelementptr inbounds ([3 x i64], [3 x i64]* @vars, i64 0, i64 2) monotonic, align 8, !dbg !94
// ST: Guess
iw(0,0+2*1) = get_rng(0,NCONTEXT-1);// 0 ASSIGN STIW _l61_c3
old_cw = cw(0,0+2*1);
cw(0,0+2*1) = get_rng(0,NCONTEXT-1);// 0 ASSIGN STCOM _l61_c3
// Check
ASSUME(active[iw(0,0+2*1)] == 0);
ASSUME(active[cw(0,0+2*1)] == 0);
ASSUME(sforbid(0+2*1,cw(0,0+2*1))== 0);
ASSUME(iw(0,0+2*1) >= 0);
ASSUME(iw(0,0+2*1) >= 0);
ASSUME(cw(0,0+2*1) >= iw(0,0+2*1));
ASSUME(cw(0,0+2*1) >= old_cw);
ASSUME(cw(0,0+2*1) >= cr(0,0+2*1));
ASSUME(cw(0,0+2*1) >= cl[0]);
ASSUME(cw(0,0+2*1) >= cisb[0]);
ASSUME(cw(0,0+2*1) >= cdy[0]);
ASSUME(cw(0,0+2*1) >= cdl[0]);
ASSUME(cw(0,0+2*1) >= cds[0]);
ASSUME(cw(0,0+2*1) >= cctrl[0]);
ASSUME(cw(0,0+2*1) >= caddr[0]);
// Update
caddr[0] = max(caddr[0],0);
buff(0,0+2*1) = 0;
mem(0+2*1,cw(0,0+2*1)) = 0;
co(0+2*1,cw(0,0+2*1))+=1;
delta(0+2*1,cw(0,0+2*1)) = -1;
ASSUME(creturn[0] >= cw(0,0+2*1));
// call void @llvm.dbg.value(metadata i64* getelementptr inbounds ([3 x i64], [3 x i64]* @vars, i64 0, i64 1), metadata !160, metadata !DIExpression()), !dbg !200
// call void @llvm.dbg.value(metadata i64 0, metadata !162, metadata !DIExpression()), !dbg !200
// store atomic i64 0, i64* getelementptr inbounds ([3 x i64], [3 x i64]* @vars, i64 0, i64 1) monotonic, align 8, !dbg !96
// ST: Guess
iw(0,0+1*1) = get_rng(0,NCONTEXT-1);// 0 ASSIGN STIW _l62_c3
old_cw = cw(0,0+1*1);
cw(0,0+1*1) = get_rng(0,NCONTEXT-1);// 0 ASSIGN STCOM _l62_c3
// Check
ASSUME(active[iw(0,0+1*1)] == 0);
ASSUME(active[cw(0,0+1*1)] == 0);
ASSUME(sforbid(0+1*1,cw(0,0+1*1))== 0);
ASSUME(iw(0,0+1*1) >= 0);
ASSUME(iw(0,0+1*1) >= 0);
ASSUME(cw(0,0+1*1) >= iw(0,0+1*1));
ASSUME(cw(0,0+1*1) >= old_cw);
ASSUME(cw(0,0+1*1) >= cr(0,0+1*1));
ASSUME(cw(0,0+1*1) >= cl[0]);
ASSUME(cw(0,0+1*1) >= cisb[0]);
ASSUME(cw(0,0+1*1) >= cdy[0]);
ASSUME(cw(0,0+1*1) >= cdl[0]);
ASSUME(cw(0,0+1*1) >= cds[0]);
ASSUME(cw(0,0+1*1) >= cctrl[0]);
ASSUME(cw(0,0+1*1) >= caddr[0]);
// Update
caddr[0] = max(caddr[0],0);
buff(0,0+1*1) = 0;
mem(0+1*1,cw(0,0+1*1)) = 0;
co(0+1*1,cw(0,0+1*1))+=1;
delta(0+1*1,cw(0,0+1*1)) = -1;
ASSUME(creturn[0] >= cw(0,0+1*1));
// call void @llvm.dbg.value(metadata i64* getelementptr inbounds ([3 x i64], [3 x i64]* @vars, i64 0, i64 0), metadata !163, metadata !DIExpression()), !dbg !202
// call void @llvm.dbg.value(metadata i64 0, metadata !165, metadata !DIExpression()), !dbg !202
// store atomic i64 0, i64* getelementptr inbounds ([3 x i64], [3 x i64]* @vars, i64 0, i64 0) monotonic, align 8, !dbg !98
// ST: Guess
iw(0,0) = get_rng(0,NCONTEXT-1);// 0 ASSIGN STIW _l63_c3
old_cw = cw(0,0);
cw(0,0) = get_rng(0,NCONTEXT-1);// 0 ASSIGN STCOM _l63_c3
// Check
ASSUME(active[iw(0,0)] == 0);
ASSUME(active[cw(0,0)] == 0);
ASSUME(sforbid(0,cw(0,0))== 0);
ASSUME(iw(0,0) >= 0);
ASSUME(iw(0,0) >= 0);
ASSUME(cw(0,0) >= iw(0,0));
ASSUME(cw(0,0) >= old_cw);
ASSUME(cw(0,0) >= cr(0,0));
ASSUME(cw(0,0) >= cl[0]);
ASSUME(cw(0,0) >= cisb[0]);
ASSUME(cw(0,0) >= cdy[0]);
ASSUME(cw(0,0) >= cdl[0]);
ASSUME(cw(0,0) >= cds[0]);
ASSUME(cw(0,0) >= cctrl[0]);
ASSUME(cw(0,0) >= caddr[0]);
// Update
caddr[0] = max(caddr[0],0);
buff(0,0) = 0;
mem(0,cw(0,0)) = 0;
co(0,cw(0,0))+=1;
delta(0,cw(0,0)) = -1;
ASSUME(creturn[0] >= cw(0,0));
// store i32 0, i32* @atom_1_X0_1, align 4, !dbg !99, !tbaa !100
// ST: Guess
iw(0,3) = get_rng(0,NCONTEXT-1);// 0 ASSIGN STIW _l64_c15
old_cw = cw(0,3);
cw(0,3) = get_rng(0,NCONTEXT-1);// 0 ASSIGN STCOM _l64_c15
// Check
ASSUME(active[iw(0,3)] == 0);
ASSUME(active[cw(0,3)] == 0);
ASSUME(sforbid(3,cw(0,3))== 0);
ASSUME(iw(0,3) >= 0);
ASSUME(iw(0,3) >= 0);
ASSUME(cw(0,3) >= iw(0,3));
ASSUME(cw(0,3) >= old_cw);
ASSUME(cw(0,3) >= cr(0,3));
ASSUME(cw(0,3) >= cl[0]);
ASSUME(cw(0,3) >= cisb[0]);
ASSUME(cw(0,3) >= cdy[0]);
ASSUME(cw(0,3) >= cdl[0]);
ASSUME(cw(0,3) >= cds[0]);
ASSUME(cw(0,3) >= cctrl[0]);
ASSUME(cw(0,3) >= caddr[0]);
// Update
caddr[0] = max(caddr[0],0);
buff(0,3) = 0;
mem(3,cw(0,3)) = 0;
co(3,cw(0,3))+=1;
delta(3,cw(0,3)) = -1;
ASSUME(creturn[0] >= cw(0,3));
// store i32 0, i32* @atom_1_X5_2, align 4, !dbg !104, !tbaa !100
// ST: Guess
iw(0,4) = get_rng(0,NCONTEXT-1);// 0 ASSIGN STIW _l65_c15
old_cw = cw(0,4);
cw(0,4) = get_rng(0,NCONTEXT-1);// 0 ASSIGN STCOM _l65_c15
// Check
ASSUME(active[iw(0,4)] == 0);
ASSUME(active[cw(0,4)] == 0);
ASSUME(sforbid(4,cw(0,4))== 0);
ASSUME(iw(0,4) >= 0);
ASSUME(iw(0,4) >= 0);
ASSUME(cw(0,4) >= iw(0,4));
ASSUME(cw(0,4) >= old_cw);
ASSUME(cw(0,4) >= cr(0,4));
ASSUME(cw(0,4) >= cl[0]);
ASSUME(cw(0,4) >= cisb[0]);
ASSUME(cw(0,4) >= cdy[0]);
ASSUME(cw(0,4) >= cdl[0]);
ASSUME(cw(0,4) >= cds[0]);
ASSUME(cw(0,4) >= cctrl[0]);
ASSUME(cw(0,4) >= caddr[0]);
// Update
caddr[0] = max(caddr[0],0);
buff(0,4) = 0;
mem(4,cw(0,4)) = 0;
co(4,cw(0,4))+=1;
delta(4,cw(0,4)) = -1;
ASSUME(creturn[0] >= cw(0,4));
// store i32 0, i32* @atom_1_X7_0, align 4, !dbg !105, !tbaa !100
// ST: Guess
iw(0,5) = get_rng(0,NCONTEXT-1);// 0 ASSIGN STIW _l66_c15
old_cw = cw(0,5);
cw(0,5) = get_rng(0,NCONTEXT-1);// 0 ASSIGN STCOM _l66_c15
// Check
ASSUME(active[iw(0,5)] == 0);
ASSUME(active[cw(0,5)] == 0);
ASSUME(sforbid(5,cw(0,5))== 0);
ASSUME(iw(0,5) >= 0);
ASSUME(iw(0,5) >= 0);
ASSUME(cw(0,5) >= iw(0,5));
ASSUME(cw(0,5) >= old_cw);
ASSUME(cw(0,5) >= cr(0,5));
ASSUME(cw(0,5) >= cl[0]);
ASSUME(cw(0,5) >= cisb[0]);
ASSUME(cw(0,5) >= cdy[0]);
ASSUME(cw(0,5) >= cdl[0]);
ASSUME(cw(0,5) >= cds[0]);
ASSUME(cw(0,5) >= cctrl[0]);
ASSUME(cw(0,5) >= caddr[0]);
// Update
caddr[0] = max(caddr[0],0);
buff(0,5) = 0;
mem(5,cw(0,5)) = 0;
co(5,cw(0,5))+=1;
delta(5,cw(0,5)) = -1;
ASSUME(creturn[0] >= cw(0,5));
// store i32 0, i32* @atom_1_X9_1, align 4, !dbg !106, !tbaa !100
// ST: Guess
iw(0,6) = get_rng(0,NCONTEXT-1);// 0 ASSIGN STIW _l67_c15
old_cw = cw(0,6);
cw(0,6) = get_rng(0,NCONTEXT-1);// 0 ASSIGN STCOM _l67_c15
// Check
ASSUME(active[iw(0,6)] == 0);
ASSUME(active[cw(0,6)] == 0);
ASSUME(sforbid(6,cw(0,6))== 0);
ASSUME(iw(0,6) >= 0);
ASSUME(iw(0,6) >= 0);
ASSUME(cw(0,6) >= iw(0,6));
ASSUME(cw(0,6) >= old_cw);
ASSUME(cw(0,6) >= cr(0,6));
ASSUME(cw(0,6) >= cl[0]);
ASSUME(cw(0,6) >= cisb[0]);
ASSUME(cw(0,6) >= cdy[0]);
ASSUME(cw(0,6) >= cdl[0]);
ASSUME(cw(0,6) >= cds[0]);
ASSUME(cw(0,6) >= cctrl[0]);
ASSUME(cw(0,6) >= caddr[0]);
// Update
caddr[0] = max(caddr[0],0);
buff(0,6) = 0;
mem(6,cw(0,6)) = 0;
co(6,cw(0,6))+=1;
delta(6,cw(0,6)) = -1;
ASSUME(creturn[0] >= cw(0,6));
// %call = call i32 @pthread_create(i64* noundef %thr0, %union.pthread_attr_t* noundef null, i8* (i8*)* noundef @t0, i8* noundef null) #7, !dbg !107
// dumbsy: Guess
old_cdy = cdy[0];
cdy[0] = get_rng(0,NCONTEXT-1);
// Check
ASSUME(cdy[0] >= old_cdy);
ASSUME(cdy[0] >= cisb[0]);
ASSUME(cdy[0] >= cdl[0]);
ASSUME(cdy[0] >= cds[0]);
ASSUME(cdy[0] >= cctrl[0]);
ASSUME(cdy[0] >= cw(0,0+0));
ASSUME(cdy[0] >= cw(0,0+1));
ASSUME(cdy[0] >= cw(0,0+2));
ASSUME(cdy[0] >= cw(0,3+0));
ASSUME(cdy[0] >= cw(0,4+0));
ASSUME(cdy[0] >= cw(0,5+0));
ASSUME(cdy[0] >= cw(0,6+0));
ASSUME(cdy[0] >= cr(0,0+0));
ASSUME(cdy[0] >= cr(0,0+1));
ASSUME(cdy[0] >= cr(0,0+2));
ASSUME(cdy[0] >= cr(0,3+0));
ASSUME(cdy[0] >= cr(0,4+0));
ASSUME(cdy[0] >= cr(0,5+0));
ASSUME(cdy[0] >= cr(0,6+0));
ASSUME(creturn[0] >= cdy[0]);
ASSUME(cstart[1] >= cdy[0]);
// %call5 = call i32 @pthread_create(i64* noundef %thr1, %union.pthread_attr_t* noundef null, i8* (i8*)* noundef @t1, i8* noundef null) #7, !dbg !108
// dumbsy: Guess
old_cdy = cdy[0];
cdy[0] = get_rng(0,NCONTEXT-1);
// Check
ASSUME(cdy[0] >= old_cdy);
ASSUME(cdy[0] >= cisb[0]);
ASSUME(cdy[0] >= cdl[0]);
ASSUME(cdy[0] >= cds[0]);
ASSUME(cdy[0] >= cctrl[0]);
ASSUME(cdy[0] >= cw(0,0+0));
ASSUME(cdy[0] >= cw(0,0+1));
ASSUME(cdy[0] >= cw(0,0+2));
ASSUME(cdy[0] >= cw(0,3+0));
ASSUME(cdy[0] >= cw(0,4+0));
ASSUME(cdy[0] >= cw(0,5+0));
ASSUME(cdy[0] >= cw(0,6+0));
ASSUME(cdy[0] >= cr(0,0+0));
ASSUME(cdy[0] >= cr(0,0+1));
ASSUME(cdy[0] >= cr(0,0+2));
ASSUME(cdy[0] >= cr(0,3+0));
ASSUME(cdy[0] >= cr(0,4+0));
ASSUME(cdy[0] >= cr(0,5+0));
ASSUME(cdy[0] >= cr(0,6+0));
ASSUME(creturn[0] >= cdy[0]);
ASSUME(cstart[2] >= cdy[0]);
// %call6 = call i32 @pthread_create(i64* noundef %thr2, %union.pthread_attr_t* noundef null, i8* (i8*)* noundef @t2, i8* noundef null) #7, !dbg !109
// dumbsy: Guess
old_cdy = cdy[0];
cdy[0] = get_rng(0,NCONTEXT-1);
// Check
ASSUME(cdy[0] >= old_cdy);
ASSUME(cdy[0] >= cisb[0]);
ASSUME(cdy[0] >= cdl[0]);
ASSUME(cdy[0] >= cds[0]);
ASSUME(cdy[0] >= cctrl[0]);
ASSUME(cdy[0] >= cw(0,0+0));
ASSUME(cdy[0] >= cw(0,0+1));
ASSUME(cdy[0] >= cw(0,0+2));
ASSUME(cdy[0] >= cw(0,3+0));
ASSUME(cdy[0] >= cw(0,4+0));
ASSUME(cdy[0] >= cw(0,5+0));
ASSUME(cdy[0] >= cw(0,6+0));
ASSUME(cdy[0] >= cr(0,0+0));
ASSUME(cdy[0] >= cr(0,0+1));
ASSUME(cdy[0] >= cr(0,0+2));
ASSUME(cdy[0] >= cr(0,3+0));
ASSUME(cdy[0] >= cr(0,4+0));
ASSUME(cdy[0] >= cr(0,5+0));
ASSUME(cdy[0] >= cr(0,6+0));
ASSUME(creturn[0] >= cdy[0]);
ASSUME(cstart[3] >= cdy[0]);
// %3 = load i64, i64* %thr0, align 8, !dbg !110, !tbaa !111
r8 = local_mem[0];
// %call7 = call i32 @pthread_join(i64 noundef %3, i8** noundef null), !dbg !113
// dumbsy: Guess
old_cdy = cdy[0];
cdy[0] = get_rng(0,NCONTEXT-1);
// Check
ASSUME(cdy[0] >= old_cdy);
ASSUME(cdy[0] >= cisb[0]);
ASSUME(cdy[0] >= cdl[0]);
ASSUME(cdy[0] >= cds[0]);
ASSUME(cdy[0] >= cctrl[0]);
ASSUME(cdy[0] >= cw(0,0+0));
ASSUME(cdy[0] >= cw(0,0+1));
ASSUME(cdy[0] >= cw(0,0+2));
ASSUME(cdy[0] >= cw(0,3+0));
ASSUME(cdy[0] >= cw(0,4+0));
ASSUME(cdy[0] >= cw(0,5+0));
ASSUME(cdy[0] >= cw(0,6+0));
ASSUME(cdy[0] >= cr(0,0+0));
ASSUME(cdy[0] >= cr(0,0+1));
ASSUME(cdy[0] >= cr(0,0+2));
ASSUME(cdy[0] >= cr(0,3+0));
ASSUME(cdy[0] >= cr(0,4+0));
ASSUME(cdy[0] >= cr(0,5+0));
ASSUME(cdy[0] >= cr(0,6+0));
ASSUME(creturn[0] >= cdy[0]);
ASSUME(cdy[0] >= creturn[1]);
// %4 = load i64, i64* %thr1, align 8, !dbg !114, !tbaa !111
r9 = local_mem[1];
// %call8 = call i32 @pthread_join(i64 noundef %4, i8** noundef null), !dbg !115
// dumbsy: Guess
old_cdy = cdy[0];
cdy[0] = get_rng(0,NCONTEXT-1);
// Check
ASSUME(cdy[0] >= old_cdy);
ASSUME(cdy[0] >= cisb[0]);
ASSUME(cdy[0] >= cdl[0]);
ASSUME(cdy[0] >= cds[0]);
ASSUME(cdy[0] >= cctrl[0]);
ASSUME(cdy[0] >= cw(0,0+0));
ASSUME(cdy[0] >= cw(0,0+1));
ASSUME(cdy[0] >= cw(0,0+2));
ASSUME(cdy[0] >= cw(0,3+0));
ASSUME(cdy[0] >= cw(0,4+0));
ASSUME(cdy[0] >= cw(0,5+0));
ASSUME(cdy[0] >= cw(0,6+0));
ASSUME(cdy[0] >= cr(0,0+0));
ASSUME(cdy[0] >= cr(0,0+1));
ASSUME(cdy[0] >= cr(0,0+2));
ASSUME(cdy[0] >= cr(0,3+0));
ASSUME(cdy[0] >= cr(0,4+0));
ASSUME(cdy[0] >= cr(0,5+0));
ASSUME(cdy[0] >= cr(0,6+0));
ASSUME(creturn[0] >= cdy[0]);
ASSUME(cdy[0] >= creturn[2]);
// %5 = load i64, i64* %thr2, align 8, !dbg !116, !tbaa !111
r10 = local_mem[2];
// %call9 = call i32 @pthread_join(i64 noundef %5, i8** noundef null), !dbg !117
// dumbsy: Guess
old_cdy = cdy[0];
cdy[0] = get_rng(0,NCONTEXT-1);
// Check
ASSUME(cdy[0] >= old_cdy);
ASSUME(cdy[0] >= cisb[0]);
ASSUME(cdy[0] >= cdl[0]);
ASSUME(cdy[0] >= cds[0]);
ASSUME(cdy[0] >= cctrl[0]);
ASSUME(cdy[0] >= cw(0,0+0));
ASSUME(cdy[0] >= cw(0,0+1));
ASSUME(cdy[0] >= cw(0,0+2));
ASSUME(cdy[0] >= cw(0,3+0));
ASSUME(cdy[0] >= cw(0,4+0));
ASSUME(cdy[0] >= cw(0,5+0));
ASSUME(cdy[0] >= cw(0,6+0));
ASSUME(cdy[0] >= cr(0,0+0));
ASSUME(cdy[0] >= cr(0,0+1));
ASSUME(cdy[0] >= cr(0,0+2));
ASSUME(cdy[0] >= cr(0,3+0));
ASSUME(cdy[0] >= cr(0,4+0));
ASSUME(cdy[0] >= cr(0,5+0));
ASSUME(cdy[0] >= cr(0,6+0));
ASSUME(creturn[0] >= cdy[0]);
ASSUME(cdy[0] >= creturn[3]);
// call void @llvm.dbg.value(metadata i64* getelementptr inbounds ([3 x i64], [3 x i64]* @vars, i64 0, i64 0), metadata !167, metadata !DIExpression()), !dbg !219
// %6 = load atomic i64, i64* getelementptr inbounds ([3 x i64], [3 x i64]* @vars, i64 0, i64 0) monotonic, align 8, !dbg !119
// LD: Guess
old_cr = cr(0,0);
cr(0,0) = get_rng(0,NCONTEXT-1);// 0 ASSIGN LDCOM _l77_c13
// Check
ASSUME(active[cr(0,0)] == 0);
ASSUME(cr(0,0) >= iw(0,0));
ASSUME(cr(0,0) >= 0);
ASSUME(cr(0,0) >= cdy[0]);
ASSUME(cr(0,0) >= cisb[0]);
ASSUME(cr(0,0) >= cdl[0]);
ASSUME(cr(0,0) >= cl[0]);
// Update
creg_r11 = cr(0,0);
crmax(0,0) = max(crmax(0,0),cr(0,0));
caddr[0] = max(caddr[0],0);
if(cr(0,0) < cw(0,0)) {
r11 = buff(0,0);
ASSUME((!(( (cw(0,0) < 1) && (1 < crmax(0,0)) )))||(sforbid(0,1)> 0));
ASSUME((!(( (cw(0,0) < 2) && (2 < crmax(0,0)) )))||(sforbid(0,2)> 0));
ASSUME((!(( (cw(0,0) < 3) && (3 < crmax(0,0)) )))||(sforbid(0,3)> 0));
ASSUME((!(( (cw(0,0) < 4) && (4 < crmax(0,0)) )))||(sforbid(0,4)> 0));
} else {
if(pw(0,0) != co(0,cr(0,0))) {
ASSUME(cr(0,0) >= old_cr);
}
pw(0,0) = co(0,cr(0,0));
r11 = mem(0,cr(0,0));
}
ASSUME(creturn[0] >= cr(0,0));
// call void @llvm.dbg.value(metadata i64 %6, metadata !169, metadata !DIExpression()), !dbg !219
// %conv = trunc i64 %6 to i32, !dbg !120
// call void @llvm.dbg.value(metadata i32 %conv, metadata !166, metadata !DIExpression()), !dbg !191
// %cmp = icmp eq i32 %conv, 2, !dbg !121
creg__r11__2_ = max(0,creg_r11);
// %conv10 = zext i1 %cmp to i32, !dbg !121
// call void @llvm.dbg.value(metadata i32 %conv10, metadata !170, metadata !DIExpression()), !dbg !191
// call void @llvm.dbg.value(metadata i64* getelementptr inbounds ([3 x i64], [3 x i64]* @vars, i64 0, i64 1), metadata !172, metadata !DIExpression()), !dbg !223
// %7 = load atomic i64, i64* getelementptr inbounds ([3 x i64], [3 x i64]* @vars, i64 0, i64 1) monotonic, align 8, !dbg !123
// LD: Guess
old_cr = cr(0,0+1*1);
cr(0,0+1*1) = get_rng(0,NCONTEXT-1);// 0 ASSIGN LDCOM _l79_c13
// Check
ASSUME(active[cr(0,0+1*1)] == 0);
ASSUME(cr(0,0+1*1) >= iw(0,0+1*1));
ASSUME(cr(0,0+1*1) >= 0);
ASSUME(cr(0,0+1*1) >= cdy[0]);
ASSUME(cr(0,0+1*1) >= cisb[0]);
ASSUME(cr(0,0+1*1) >= cdl[0]);
ASSUME(cr(0,0+1*1) >= cl[0]);
// Update
creg_r12 = cr(0,0+1*1);
crmax(0,0+1*1) = max(crmax(0,0+1*1),cr(0,0+1*1));
caddr[0] = max(caddr[0],0);
if(cr(0,0+1*1) < cw(0,0+1*1)) {
r12 = buff(0,0+1*1);
ASSUME((!(( (cw(0,0+1*1) < 1) && (1 < crmax(0,0+1*1)) )))||(sforbid(0+1*1,1)> 0));
ASSUME((!(( (cw(0,0+1*1) < 2) && (2 < crmax(0,0+1*1)) )))||(sforbid(0+1*1,2)> 0));
ASSUME((!(( (cw(0,0+1*1) < 3) && (3 < crmax(0,0+1*1)) )))||(sforbid(0+1*1,3)> 0));
ASSUME((!(( (cw(0,0+1*1) < 4) && (4 < crmax(0,0+1*1)) )))||(sforbid(0+1*1,4)> 0));
} else {
if(pw(0,0+1*1) != co(0+1*1,cr(0,0+1*1))) {
ASSUME(cr(0,0+1*1) >= old_cr);
}
pw(0,0+1*1) = co(0+1*1,cr(0,0+1*1));
r12 = mem(0+1*1,cr(0,0+1*1));
}
ASSUME(creturn[0] >= cr(0,0+1*1));
// call void @llvm.dbg.value(metadata i64 %7, metadata !174, metadata !DIExpression()), !dbg !223
// %conv14 = trunc i64 %7 to i32, !dbg !124
// call void @llvm.dbg.value(metadata i32 %conv14, metadata !171, metadata !DIExpression()), !dbg !191
// %cmp15 = icmp eq i32 %conv14, 1, !dbg !125
creg__r12__1_ = max(0,creg_r12);
// %conv16 = zext i1 %cmp15 to i32, !dbg !125
// call void @llvm.dbg.value(metadata i32 %conv16, metadata !175, metadata !DIExpression()), !dbg !191
// call void @llvm.dbg.value(metadata i64* getelementptr inbounds ([3 x i64], [3 x i64]* @vars, i64 0, i64 2), metadata !177, metadata !DIExpression()), !dbg !227
// %8 = load atomic i64, i64* getelementptr inbounds ([3 x i64], [3 x i64]* @vars, i64 0, i64 2) monotonic, align 8, !dbg !127
// LD: Guess
old_cr = cr(0,0+2*1);
cr(0,0+2*1) = get_rng(0,NCONTEXT-1);// 0 ASSIGN LDCOM _l81_c13
// Check
ASSUME(active[cr(0,0+2*1)] == 0);
ASSUME(cr(0,0+2*1) >= iw(0,0+2*1));
ASSUME(cr(0,0+2*1) >= 0);
ASSUME(cr(0,0+2*1) >= cdy[0]);
ASSUME(cr(0,0+2*1) >= cisb[0]);
ASSUME(cr(0,0+2*1) >= cdl[0]);
ASSUME(cr(0,0+2*1) >= cl[0]);
// Update
creg_r13 = cr(0,0+2*1);
crmax(0,0+2*1) = max(crmax(0,0+2*1),cr(0,0+2*1));
caddr[0] = max(caddr[0],0);
if(cr(0,0+2*1) < cw(0,0+2*1)) {
r13 = buff(0,0+2*1);
ASSUME((!(( (cw(0,0+2*1) < 1) && (1 < crmax(0,0+2*1)) )))||(sforbid(0+2*1,1)> 0));
ASSUME((!(( (cw(0,0+2*1) < 2) && (2 < crmax(0,0+2*1)) )))||(sforbid(0+2*1,2)> 0));
ASSUME((!(( (cw(0,0+2*1) < 3) && (3 < crmax(0,0+2*1)) )))||(sforbid(0+2*1,3)> 0));
ASSUME((!(( (cw(0,0+2*1) < 4) && (4 < crmax(0,0+2*1)) )))||(sforbid(0+2*1,4)> 0));
} else {
if(pw(0,0+2*1) != co(0+2*1,cr(0,0+2*1))) {
ASSUME(cr(0,0+2*1) >= old_cr);
}
pw(0,0+2*1) = co(0+2*1,cr(0,0+2*1));
r13 = mem(0+2*1,cr(0,0+2*1));
}
ASSUME(creturn[0] >= cr(0,0+2*1));
// call void @llvm.dbg.value(metadata i64 %8, metadata !179, metadata !DIExpression()), !dbg !227
// %conv20 = trunc i64 %8 to i32, !dbg !128
// call void @llvm.dbg.value(metadata i32 %conv20, metadata !176, metadata !DIExpression()), !dbg !191
// %cmp21 = icmp eq i32 %conv20, 2, !dbg !129
creg__r13__2_ = max(0,creg_r13);
// %conv22 = zext i1 %cmp21 to i32, !dbg !129
// call void @llvm.dbg.value(metadata i32 %conv22, metadata !180, metadata !DIExpression()), !dbg !191
// %9 = load i32, i32* @atom_1_X0_1, align 4, !dbg !130, !tbaa !100
// LD: Guess
old_cr = cr(0,3);
cr(0,3) = get_rng(0,NCONTEXT-1);// 0 ASSIGN LDCOM _l83_c13
// Check
ASSUME(active[cr(0,3)] == 0);
ASSUME(cr(0,3) >= iw(0,3));
ASSUME(cr(0,3) >= 0);
ASSUME(cr(0,3) >= cdy[0]);
ASSUME(cr(0,3) >= cisb[0]);
ASSUME(cr(0,3) >= cdl[0]);
ASSUME(cr(0,3) >= cl[0]);
// Update
creg_r14 = cr(0,3);
crmax(0,3) = max(crmax(0,3),cr(0,3));
caddr[0] = max(caddr[0],0);
if(cr(0,3) < cw(0,3)) {
r14 = buff(0,3);
ASSUME((!(( (cw(0,3) < 1) && (1 < crmax(0,3)) )))||(sforbid(3,1)> 0));
ASSUME((!(( (cw(0,3) < 2) && (2 < crmax(0,3)) )))||(sforbid(3,2)> 0));
ASSUME((!(( (cw(0,3) < 3) && (3 < crmax(0,3)) )))||(sforbid(3,3)> 0));
ASSUME((!(( (cw(0,3) < 4) && (4 < crmax(0,3)) )))||(sforbid(3,4)> 0));
} else {
if(pw(0,3) != co(3,cr(0,3))) {
ASSUME(cr(0,3) >= old_cr);
}
pw(0,3) = co(3,cr(0,3));
r14 = mem(3,cr(0,3));
}
ASSUME(creturn[0] >= cr(0,3));
// call void @llvm.dbg.value(metadata i32 %9, metadata !181, metadata !DIExpression()), !dbg !191
// %10 = load i32, i32* @atom_1_X5_2, align 4, !dbg !131, !tbaa !100
// LD: Guess
old_cr = cr(0,4);
cr(0,4) = get_rng(0,NCONTEXT-1);// 0 ASSIGN LDCOM _l84_c13
// Check
ASSUME(active[cr(0,4)] == 0);
ASSUME(cr(0,4) >= iw(0,4));
ASSUME(cr(0,4) >= 0);
ASSUME(cr(0,4) >= cdy[0]);
ASSUME(cr(0,4) >= cisb[0]);
ASSUME(cr(0,4) >= cdl[0]);
ASSUME(cr(0,4) >= cl[0]);
// Update
creg_r15 = cr(0,4);
crmax(0,4) = max(crmax(0,4),cr(0,4));
caddr[0] = max(caddr[0],0);
if(cr(0,4) < cw(0,4)) {
r15 = buff(0,4);
ASSUME((!(( (cw(0,4) < 1) && (1 < crmax(0,4)) )))||(sforbid(4,1)> 0));
ASSUME((!(( (cw(0,4) < 2) && (2 < crmax(0,4)) )))||(sforbid(4,2)> 0));
ASSUME((!(( (cw(0,4) < 3) && (3 < crmax(0,4)) )))||(sforbid(4,3)> 0));
ASSUME((!(( (cw(0,4) < 4) && (4 < crmax(0,4)) )))||(sforbid(4,4)> 0));
} else {
if(pw(0,4) != co(4,cr(0,4))) {
ASSUME(cr(0,4) >= old_cr);
}
pw(0,4) = co(4,cr(0,4));
r15 = mem(4,cr(0,4));
}
ASSUME(creturn[0] >= cr(0,4));
// call void @llvm.dbg.value(metadata i32 %10, metadata !182, metadata !DIExpression()), !dbg !191
// %11 = load i32, i32* @atom_1_X7_0, align 4, !dbg !132, !tbaa !100
// LD: Guess
old_cr = cr(0,5);
cr(0,5) = get_rng(0,NCONTEXT-1);// 0 ASSIGN LDCOM _l85_c13
// Check
ASSUME(active[cr(0,5)] == 0);
ASSUME(cr(0,5) >= iw(0,5));
ASSUME(cr(0,5) >= 0);
ASSUME(cr(0,5) >= cdy[0]);
ASSUME(cr(0,5) >= cisb[0]);
ASSUME(cr(0,5) >= cdl[0]);
ASSUME(cr(0,5) >= cl[0]);
// Update
creg_r16 = cr(0,5);
crmax(0,5) = max(crmax(0,5),cr(0,5));
caddr[0] = max(caddr[0],0);
if(cr(0,5) < cw(0,5)) {
r16 = buff(0,5);
ASSUME((!(( (cw(0,5) < 1) && (1 < crmax(0,5)) )))||(sforbid(5,1)> 0));
ASSUME((!(( (cw(0,5) < 2) && (2 < crmax(0,5)) )))||(sforbid(5,2)> 0));
ASSUME((!(( (cw(0,5) < 3) && (3 < crmax(0,5)) )))||(sforbid(5,3)> 0));
ASSUME((!(( (cw(0,5) < 4) && (4 < crmax(0,5)) )))||(sforbid(5,4)> 0));
} else {
if(pw(0,5) != co(5,cr(0,5))) {
ASSUME(cr(0,5) >= old_cr);
}
pw(0,5) = co(5,cr(0,5));
r16 = mem(5,cr(0,5));
}
ASSUME(creturn[0] >= cr(0,5));
// call void @llvm.dbg.value(metadata i32 %11, metadata !183, metadata !DIExpression()), !dbg !191
// %12 = load i32, i32* @atom_1_X9_1, align 4, !dbg !133, !tbaa !100
// LD: Guess
old_cr = cr(0,6);
cr(0,6) = get_rng(0,NCONTEXT-1);// 0 ASSIGN LDCOM _l86_c13
// Check
ASSUME(active[cr(0,6)] == 0);
ASSUME(cr(0,6) >= iw(0,6));
ASSUME(cr(0,6) >= 0);
ASSUME(cr(0,6) >= cdy[0]);
ASSUME(cr(0,6) >= cisb[0]);
ASSUME(cr(0,6) >= cdl[0]);
ASSUME(cr(0,6) >= cl[0]);
// Update
creg_r17 = cr(0,6);
crmax(0,6) = max(crmax(0,6),cr(0,6));
caddr[0] = max(caddr[0],0);
if(cr(0,6) < cw(0,6)) {
r17 = buff(0,6);
ASSUME((!(( (cw(0,6) < 1) && (1 < crmax(0,6)) )))||(sforbid(6,1)> 0));
ASSUME((!(( (cw(0,6) < 2) && (2 < crmax(0,6)) )))||(sforbid(6,2)> 0));
ASSUME((!(( (cw(0,6) < 3) && (3 < crmax(0,6)) )))||(sforbid(6,3)> 0));
ASSUME((!(( (cw(0,6) < 4) && (4 < crmax(0,6)) )))||(sforbid(6,4)> 0));
} else {
if(pw(0,6) != co(6,cr(0,6))) {
ASSUME(cr(0,6) >= old_cr);
}
pw(0,6) = co(6,cr(0,6));
r17 = mem(6,cr(0,6));
}
ASSUME(creturn[0] >= cr(0,6));
// call void @llvm.dbg.value(metadata i32 %12, metadata !184, metadata !DIExpression()), !dbg !191
// %and = and i32 %11, %12, !dbg !134
creg_r18 = max(creg_r16,creg_r17);
r18 = r16 & r17;
// call void @llvm.dbg.value(metadata i32 %and, metadata !185, metadata !DIExpression()), !dbg !191
// %and23 = and i32 %10, %and, !dbg !135
creg_r19 = max(creg_r15,creg_r18);
r19 = r15 & r18;
// call void @llvm.dbg.value(metadata i32 %and23, metadata !186, metadata !DIExpression()), !dbg !191
// %and24 = and i32 %9, %and23, !dbg !136
creg_r20 = max(creg_r14,creg_r19);
r20 = r14 & r19;
// call void @llvm.dbg.value(metadata i32 %and24, metadata !187, metadata !DIExpression()), !dbg !191
// %and25 = and i32 %conv22, %and24, !dbg !137
creg_r21 = max(creg__r13__2_,creg_r20);
r21 = (r13==2) & r20;
// call void @llvm.dbg.value(metadata i32 %and25, metadata !188, metadata !DIExpression()), !dbg !191
// %and26 = and i32 %conv16, %and25, !dbg !138
creg_r22 = max(creg__r12__1_,creg_r21);
r22 = (r12==1) & r21;
// call void @llvm.dbg.value(metadata i32 %and26, metadata !189, metadata !DIExpression()), !dbg !191
// %and27 = and i32 %conv10, %and26, !dbg !139
creg_r23 = max(creg__r11__2_,creg_r22);
r23 = (r11==2) & r22;
// call void @llvm.dbg.value(metadata i32 %and27, metadata !190, metadata !DIExpression()), !dbg !191
// %cmp28 = icmp eq i32 %and27, 1, !dbg !140
creg__r23__1_ = max(0,creg_r23);
// br i1 %cmp28, label %if.then, label %if.end, !dbg !142
old_cctrl = cctrl[0];
cctrl[0] = get_rng(0,NCONTEXT-1);
ASSUME(cctrl[0] >= old_cctrl);
ASSUME(cctrl[0] >= creg__r23__1_);
if((r23==1)) {
goto T0BLOCK1;
} else {
goto T0BLOCK2;
}
T0BLOCK1:
// call void @__assert_fail(i8* noundef getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0), i8* noundef getelementptr inbounds ([120 x i8], [120 x i8]* @.str.1, i64 0, i64 0), i32 noundef 93, i8* noundef getelementptr inbounds ([23 x i8], [23 x i8]* @__PRETTY_FUNCTION__.main, i64 0, i64 0)) #8, !dbg !143
// unreachable, !dbg !143
r24 = 1;
goto T0BLOCK_END;
T0BLOCK2:
// %13 = bitcast i64* %thr2 to i8*, !dbg !146
// call void @llvm.lifetime.end.p0i8(i64 8, i8* %13) #7, !dbg !146
// %14 = bitcast i64* %thr1 to i8*, !dbg !146
// call void @llvm.lifetime.end.p0i8(i64 8, i8* %14) #7, !dbg !146
// %15 = bitcast i64* %thr0 to i8*, !dbg !146
// call void @llvm.lifetime.end.p0i8(i64 8, i8* %15) #7, !dbg !146
// ret i32 0, !dbg !147
ret_thread_0 = 0;
goto T0BLOCK_END;
T0BLOCK_END:
ASSUME(meminit(0,1) == mem(0,0));
ASSUME(coinit(0,1) == co(0,0));
ASSUME(deltainit(0,1) == delta(0,0));
ASSUME(meminit(0,2) == mem(0,1));
ASSUME(coinit(0,2) == co(0,1));
ASSUME(deltainit(0,2) == delta(0,1));
ASSUME(meminit(0,3) == mem(0,2));
ASSUME(coinit(0,3) == co(0,2));
ASSUME(deltainit(0,3) == delta(0,2));
ASSUME(meminit(0,4) == mem(0,3));
ASSUME(coinit(0,4) == co(0,3));
ASSUME(deltainit(0,4) == delta(0,3));
ASSUME(meminit(1,1) == mem(1,0));
ASSUME(coinit(1,1) == co(1,0));
ASSUME(deltainit(1,1) == delta(1,0));
ASSUME(meminit(1,2) == mem(1,1));
ASSUME(coinit(1,2) == co(1,1));
ASSUME(deltainit(1,2) == delta(1,1));
ASSUME(meminit(1,3) == mem(1,2));
ASSUME(coinit(1,3) == co(1,2));
ASSUME(deltainit(1,3) == delta(1,2));
ASSUME(meminit(1,4) == mem(1,3));
ASSUME(coinit(1,4) == co(1,3));
ASSUME(deltainit(1,4) == delta(1,3));
ASSUME(meminit(2,1) == mem(2,0));
ASSUME(coinit(2,1) == co(2,0));
ASSUME(deltainit(2,1) == delta(2,0));
ASSUME(meminit(2,2) == mem(2,1));
ASSUME(coinit(2,2) == co(2,1));
ASSUME(deltainit(2,2) == delta(2,1));
ASSUME(meminit(2,3) == mem(2,2));
ASSUME(coinit(2,3) == co(2,2));
ASSUME(deltainit(2,3) == delta(2,2));
ASSUME(meminit(2,4) == mem(2,3));
ASSUME(coinit(2,4) == co(2,3));
ASSUME(deltainit(2,4) == delta(2,3));
ASSUME(meminit(3,1) == mem(3,0));
ASSUME(coinit(3,1) == co(3,0));
ASSUME(deltainit(3,1) == delta(3,0));
ASSUME(meminit(3,2) == mem(3,1));
ASSUME(coinit(3,2) == co(3,1));
ASSUME(deltainit(3,2) == delta(3,1));
ASSUME(meminit(3,3) == mem(3,2));
ASSUME(coinit(3,3) == co(3,2));
ASSUME(deltainit(3,3) == delta(3,2));
ASSUME(meminit(3,4) == mem(3,3));
ASSUME(coinit(3,4) == co(3,3));
ASSUME(deltainit(3,4) == delta(3,3));
ASSUME(meminit(4,1) == mem(4,0));
ASSUME(coinit(4,1) == co(4,0));
ASSUME(deltainit(4,1) == delta(4,0));
ASSUME(meminit(4,2) == mem(4,1));
ASSUME(coinit(4,2) == co(4,1));
ASSUME(deltainit(4,2) == delta(4,1));
ASSUME(meminit(4,3) == mem(4,2));
ASSUME(coinit(4,3) == co(4,2));
ASSUME(deltainit(4,3) == delta(4,2));
ASSUME(meminit(4,4) == mem(4,3));
ASSUME(coinit(4,4) == co(4,3));
ASSUME(deltainit(4,4) == delta(4,3));
ASSUME(meminit(5,1) == mem(5,0));
ASSUME(coinit(5,1) == co(5,0));
ASSUME(deltainit(5,1) == delta(5,0));
ASSUME(meminit(5,2) == mem(5,1));
ASSUME(coinit(5,2) == co(5,1));
ASSUME(deltainit(5,2) == delta(5,1));
ASSUME(meminit(5,3) == mem(5,2));
ASSUME(coinit(5,3) == co(5,2));
ASSUME(deltainit(5,3) == delta(5,2));
ASSUME(meminit(5,4) == mem(5,3));
ASSUME(coinit(5,4) == co(5,3));
ASSUME(deltainit(5,4) == delta(5,3));
ASSUME(meminit(6,1) == mem(6,0));
ASSUME(coinit(6,1) == co(6,0));
ASSUME(deltainit(6,1) == delta(6,0));
ASSUME(meminit(6,2) == mem(6,1));
ASSUME(coinit(6,2) == co(6,1));
ASSUME(deltainit(6,2) == delta(6,1));
ASSUME(meminit(6,3) == mem(6,2));
ASSUME(coinit(6,3) == co(6,2));
ASSUME(deltainit(6,3) == delta(6,2));
ASSUME(meminit(6,4) == mem(6,3));
ASSUME(coinit(6,4) == co(6,3));
ASSUME(deltainit(6,4) == delta(6,3));
ASSERT(r24== 0);
}
| [
"tuan-phong.ngo@it.uu.se"
] | tuan-phong.ngo@it.uu.se |
02842873da74c83c3c841e0c0d04c780dec7488d | ac1685b3d22e3b4b70a0f7744226076ad882fe22 | /fds/prac_11/tempCodeRunnerFile.cpp | 97c7a686943d86a7e04e1d1e403b94854108c728 | [] | no_license | sachin-611/practicals_sem3 | c078679c534eefb1856a725f9f0db70a857ae67b | 8840cd1a5d93ca725c96a2a01584cedd5f23d2e7 | refs/heads/master | 2023-02-16T18:06:57.976738 | 2020-12-16T11:21:46 | 2020-12-16T11:21:46 | 313,246,939 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 634 | cpp | resident)
{
if(head->isPresident)
{
cout<<"President already Exist!!"<<endl;
cout<<"Do you want to add this as member?"<<endl;
char choice;
if(choice=='Y' || choice=='y')
{
add(name,PRN,false,false,head->next);
cout<<"added as member sucessfully!!"<<endl;
return;
}
else
{
return;
}
}
} | [
"shersingh6112000@gmail.com"
] | shersingh6112000@gmail.com |
03c0473ca64ddbf2030b708d368c71c431d7031f | 21da8204bf0e1055edbf844a8026542ff04d163d | /imu_vn_100/src/imu_vn_100.cpp | d9488043e33739eeecb0c5f2bd51179de22137c0 | [
"MIT",
"Apache-2.0"
] | permissive | sagniknitr/sensor_nodes_ROS2 | d9870c222cf6abf17cd2d66369066ff14b0f50f8 | f8991844d8d7acb831810a7f1cfa9e52f5bb5f30 | refs/heads/master | 2018-12-19T18:07:29.965518 | 2018-11-27T13:05:22 | 2018-11-27T13:05:22 | 118,472,919 | 1 | 0 | null | 2018-02-03T10:11:48 | 2018-01-22T15:06:23 | CMake | UTF-8 | C++ | false | false | 18,457 | cpp | /*
* Copyright [2015] [Ke Sun]
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <imu_vn_100/imu_vn_100.h>
#include <geometry_msgs/msg/vector_3_stamped.hpp>
namespace imu_vn_100 {
// LESS HACK IS STILL HACK
ImuVn100* imu_vn_100_ptr;
using geometry_msgs::msg::Vector3Stamped;
using sensor_msgs::msg::Imu;
using sensor_msgs::msg::MagneticField;
using sensor_msgs::msg::FluidPressure;
using sensor_msgs::msg::Temperature;
void RosVector3FromVnVector3(geometry_msgs::msg::Vector3& ros_vec3,
const VnVector3& vn_vec3);
void RosQuaternionFromVnQuaternion(geometry_msgs::msg::Quaternion& ros_quat,
const VnQuaternion& vn_quat);
void AsyncListener(void* sender, VnDeviceCompositeData* data) {
imu_vn_100_ptr->PublishData(*data);
}
constexpr int ImuVn100::kBaseImuRate;
constexpr int ImuVn100::kDefaultImuRate;
constexpr int ImuVn100::kDefaultSyncOutRate;
void ImuVn100::SyncInfo::Update(const unsigned sync_count,
const builtin_interfaces::msg::Time& sync_time) {
if (rate <= 0) return;
if (count != sync_count) {
count = sync_count;
time = sync_time;
}
}
bool ImuVn100::SyncInfo::SyncEnabled() const { return rate > 0; }
void ImuVn100::SyncInfo::FixSyncRate() {
// Check the sync out rate
if (SyncEnabled()) {
if (ImuVn100::kBaseImuRate % rate != 0) {
rate = ImuVn100::kBaseImuRate / (ImuVn100::kBaseImuRate / rate);
ROS_INFO("Set SYNC_OUT_RATE to %d", rate);
}
skip_count =
(std::floor(ImuVn100::kBaseImuRate / static_cast<double>(rate) +
0.5f)) -
1;
if (pulse_width_us > 10000) {
ROS_INFO("Sync out pulse with is over 10ms. Reset to 1ms");
pulse_width_us = 1000;
}
rate_double = rate;
}
ROS_INFO("Sync out rate: %d", rate);
}
ImuVn100::ImuVn100(const ros::NodeHandle& pnh)
: pnh_(pnh),
port_(std::string("/dev/ttyUSB0")),
baudrate_(921600),
frame_id_(std::string("imu")) {
Initialize();
imu_vn_100_ptr = this;
}
ImuVn100::~ImuVn100() { Disconnect(); }
void ImuVn100::FixImuRate() {
if (imu_rate_ <= 0) {
ROS_WARN("Imu rate %d is < 0. Set to %d", imu_rate_, kDefaultImuRate);
imu_rate_ = kDefaultImuRate;
}
if (kBaseImuRate % imu_rate_ != 0) {
int imu_rate_old = imu_rate_;
imu_rate_ = kBaseImuRate / (kBaseImuRate / imu_rate_old);
ROS_WARN("Imu rate %d cannot evenly decimate base rate %d, reset to %d",
imu_rate_old, kBaseImuRate, imu_rate_);
}
}
void ImuVn100::LoadParameters() {
pnh_.param<std::string>("port", port_, std::string("/dev/ttyUSB0"));
pnh_.param<std::string>("frame_id", frame_id_, pnh_.getNamespace());
pnh_.param("baudrate", baudrate_, 115200);
pnh_.param("imu_rate", imu_rate_, kDefaultImuRate);
pnh_.param("enable_mag", enable_mag_, true);
pnh_.param("enable_pres", enable_pres_, true);
pnh_.param("enable_temp", enable_temp_, true);
pnh_.param("enable_rpy", enable_rpy_, false);
pnh_.param("sync_rate", sync_info_.rate, kDefaultSyncOutRate);
pnh_.param("sync_pulse_width_us", sync_info_.pulse_width_us, 1000);
pnh_.param("binary_output", binary_output_, true);
pnh_.param("binary_async_mode", binary_async_mode_,
BINARY_ASYNC_MODE_SERIAL_2);
pnh_.param("imu_compensated", imu_compensated_, false);
pnh_.param("vpe/enable", vpe_enable_, true);
pnh_.param("vpe/heading_mode", vpe_heading_mode_, 1);
pnh_.param("vpe/filtering_mode", vpe_filtering_mode_, 1);
pnh_.param("vpe/tuning_mode", vpe_tuning_mode_, 1);
pnh_.param("vpe/mag_tuning/base_tuning/x", vpe_mag_base_tuning_.c0, 4.0);
pnh_.param("vpe/mag_tuning/base_tuning/y", vpe_mag_base_tuning_.c1, 4.0);
pnh_.param("vpe/mag_tuning/base_tuning/z", vpe_mag_base_tuning_.c2, 4.0);
pnh_.param("vpe/mag_tuning/adaptive_tuning/x", vpe_mag_adaptive_tuning_.c0, 5.0);
pnh_.param("vpe/mag_tuning/adaptive_tuning/y", vpe_mag_adaptive_tuning_.c1, 5.0);
pnh_.param("vpe/mag_tuning/adaptive_tuning/z", vpe_mag_adaptive_tuning_.c2, 5.0);
pnh_.param("vpe/mag_tuning/adaptive_filtering/x", vpe_mag_adaptive_filtering_.c0, 5.5);
pnh_.param("vpe/mag_tuning/adaptive_filtering/y", vpe_mag_adaptive_filtering_.c1, 5.5);
pnh_.param("vpe/mag_tuning/adaptive_filtering/z", vpe_mag_adaptive_filtering_.c2, 5.5);
pnh_.param("vpe/accel_tuning/base_tuning/x", vpe_accel_base_tuning_.c0, 5.0);
pnh_.param("vpe/accel_tuning/base_tuning/y", vpe_accel_base_tuning_.c1, 5.0);
pnh_.param("vpe/accel_tuning/base_tuning/z", vpe_accel_base_tuning_.c2, 5.0);
pnh_.param("vpe/accel_tuning/adaptive_tuning/x", vpe_accel_adaptive_tuning_.c0, 3.0);
pnh_.param("vpe/accel_tuning/adaptive_tuning/y", vpe_accel_adaptive_tuning_.c1, 3.0);
pnh_.param("vpe/accel_tuning/adaptive_tuning/z", vpe_accel_adaptive_tuning_.c2, 3.0);
pnh_.param("vpe/accel_tuning/adaptive_filtering/x", vpe_accel_adaptive_filtering_.c0, 4.0);
pnh_.param("vpe/accel_tuning/adaptive_filtering/y", vpe_accel_adaptive_filtering_.c1, 4.0);
pnh_.param("vpe/accel_tuning/adaptive_filtering/z", vpe_accel_adaptive_filtering_.c2, 4.0);
FixImuRate();
sync_info_.FixSyncRate();
}
void ImuVn100::CreateDiagnosedPublishers() {
imu_rate_double_ = imu_rate_;
pd_imu_.Create<Imu>(pnh_, "imu", updater_, imu_rate_double_);
if (enable_mag_) {
pd_mag_.Create<MagneticField>(pnh_, "magnetic_field", updater_,
imu_rate_double_);
}
if (enable_pres_) {
pd_pres_.Create<FluidPressure>(pnh_, "fluid_pressure", updater_,
imu_rate_double_);
}
if (enable_temp_) {
pd_temp_.Create<Temperature>(pnh_, "temperature", updater_,
imu_rate_double_);
}
if (enable_rpy_) {
pd_rpy_.Create<Vector3Stamped>(pnh_, "rpy", updater_, imu_rate_double_);
}
}
void ImuVn100::Initialize() {
LoadParameters();
ROS_DEBUG("Connecting to device");
VnEnsure(vn100_connect(&imu_, port_.c_str(), 115200));
ros::Duration(0.5).sleep();
ROS_INFO("Connected to device at %s", port_.c_str());
unsigned int old_baudrate;
VnEnsure(vn100_getSerialBaudRate(&imu_, &old_baudrate));
ROS_INFO("Default serial baudrate: %u", old_baudrate);
ROS_INFO("Set serial baudrate to %d", baudrate_);
VnEnsure(vn100_setSerialBaudRate(&imu_, baudrate_, true));
ROS_DEBUG("Disconnecting the device");
vn100_disconnect(&imu_);
ros::Duration(0.5).sleep();
ROS_DEBUG("Reconnecting to device");
VnEnsure(vn100_connect(&imu_, port_.c_str(), baudrate_));
ros::Duration(0.5).sleep();
ROS_INFO("Connected to device at %s", port_.c_str());
VnEnsure(vn100_getSerialBaudRate(&imu_, &old_baudrate));
ROS_INFO("New serial baudrate: %u", old_baudrate);
// Idle the device for intialization
VnEnsure(vn100_pauseAsyncOutputs(&imu_, true));
ROS_INFO("Fetching device info.");
char model_number_buffer[30] = {0};
int hardware_revision = 0;
char serial_number_buffer[30] = {0};
char firmware_version_buffer[30] = {0};
VnEnsure(vn100_getModelNumber(&imu_, model_number_buffer, 30));
ROS_INFO("Model number: %s", model_number_buffer);
VnEnsure(vn100_getHardwareRevision(&imu_, &hardware_revision));
ROS_INFO("Hardware revision: %d", hardware_revision);
VnEnsure(vn100_getSerialNumber(&imu_, serial_number_buffer, 30));
ROS_INFO("Serial number: %s", serial_number_buffer);
VnEnsure(vn100_getFirmwareVersion(&imu_, firmware_version_buffer, 30));
ROS_INFO("Firmware version: %s", firmware_version_buffer);
if (sync_info_.SyncEnabled()) {
ROS_INFO("Set Synchronization Control Register (id:32).");
VnEnsure(vn100_setSynchronizationControl(
&imu_, SYNCINMODE_COUNT, SYNCINEDGE_RISING, 0, SYNCOUTMODE_IMU_START,
SYNCOUTPOLARITY_POSITIVE, sync_info_.skip_count,
sync_info_.pulse_width_us * 1000, true));
if (!binary_output_) {
ROS_INFO("Set Communication Protocol Control Register (id:30).");
VnEnsure(vn100_setCommunicationProtocolControl(
&imu_, SERIALCOUNT_SYNCOUT_COUNT, SERIALSTATUS_OFF, SPICOUNT_NONE,
SPISTATUS_OFF, SERIALCHECKSUM_8BIT, SPICHECKSUM_8BIT, ERRORMODE_SEND,
true));
}
}
uint8_t vpe_enable;
uint8_t vpe_heading_mode;
uint8_t vpe_filtering_mode;
uint8_t vpe_tuning_mode;
VnEnsure(vn100_getVpeControl(&imu_, &vpe_enable, &vpe_heading_mode,
&vpe_filtering_mode, &vpe_tuning_mode));
ROS_INFO("Default VPE enable: %hu", vpe_enable);
ROS_INFO("Default VPE heading mode: %hu", vpe_heading_mode);
ROS_INFO("Default VPE filtering mode: %hu", vpe_filtering_mode);
ROS_INFO("Default VPE tuning mode: %hu", vpe_tuning_mode);
if (vpe_enable != vpe_enable_ ||
vpe_heading_mode != vpe_heading_mode_ ||
vpe_filtering_mode != vpe_filtering_mode_ ||
vpe_tuning_mode != vpe_tuning_mode_) {
vpe_enable = vpe_enable_;
vpe_heading_mode = vpe_heading_mode_;
vpe_filtering_mode = vpe_filtering_mode_;
vpe_tuning_mode = vpe_tuning_mode_;
ROS_INFO("Setting VPE enable: %hu", vpe_enable);
ROS_INFO("Setting VPE heading mode: %hu", vpe_heading_mode);
ROS_INFO("Setting VPE filtering mode: %hu", vpe_filtering_mode);
ROS_INFO("Setting VPE tuning mode: %hu", vpe_tuning_mode);
VnEnsure(vn100_setVpeControl(
&imu_,
vpe_enable,
vpe_heading_mode,
vpe_filtering_mode,
vpe_tuning_mode,
true));
}
if (vpe_enable_) {
ROS_INFO(
"Setting VPE MagnetometerBasicTuning BaseTuning (%f, %f, %f)",
vpe_mag_base_tuning_.c0,
vpe_mag_base_tuning_.c1,
vpe_mag_base_tuning_.c2);
ROS_INFO(
"Setting VPE MagnetometerBasicTuning AdaptiveTuning (%f, %f, %f)",
vpe_mag_adaptive_tuning_.c0,
vpe_mag_adaptive_tuning_.c1,
vpe_mag_adaptive_tuning_.c2);
ROS_INFO(
"Setting VPE MagnetometerBasicTuning AdaptiveFiltering (%f, %f, %f)",
vpe_mag_adaptive_filtering_.c0,
vpe_mag_adaptive_filtering_.c1,
vpe_mag_adaptive_filtering_.c2);
VnEnsure(vn100_setVpeMagnetometerBasicTuning(
&imu_,
vpe_mag_base_tuning_,
vpe_mag_adaptive_tuning_,
vpe_mag_adaptive_filtering_,
true));
ROS_INFO(
"Setting VPE AccelerometerBasicTuning BaseTuning (%f, %f, %f)",
vpe_accel_base_tuning_.c0,
vpe_accel_base_tuning_.c1,
vpe_accel_base_tuning_.c2);
ROS_INFO(
"Setting VPE AccelerometerBasicTuning AdaptiveTuning (%f, %f, %f)",
vpe_accel_adaptive_tuning_.c0,
vpe_accel_adaptive_tuning_.c1,
vpe_accel_adaptive_tuning_.c2);
ROS_INFO(
"Setting VPE AccelerometerBasicTuning AdaptiveFiltering (%f, %f, %f)",
vpe_accel_adaptive_filtering_.c0,
vpe_accel_adaptive_filtering_.c1,
vpe_accel_adaptive_filtering_.c2);
VnEnsure(vn100_setVpeAccelerometerBasicTuning(
&imu_,
vpe_accel_base_tuning_,
vpe_accel_adaptive_tuning_,
vpe_accel_adaptive_filtering_,
true));
}
CreateDiagnosedPublishers();
auto hardware_id = std::string("vn100-") + std::string(model_number_buffer) +
std::string(serial_number_buffer);
updater_.setHardwareID(hardware_id);
}
void ImuVn100::Stream(bool async) {
// Pause the device first
VnEnsure(vn100_pauseAsyncOutputs(&imu_, true));
if (async) {
VnEnsure(vn100_setAsynchronousDataOutputType(&imu_, VNASYNC_OFF, true));
if (binary_output_) {
// Set the binary output data type and data rate
uint16_t grp1 = BG1_QTN | BG1_SYNC_IN_CNT;
std::list<std::string> sgrp1 = {"BG1_QTN", "BG1_SYNC_IN_CNT"};
if (enable_rpy_) {
grp1 |= BG1_YPR;
sgrp1.push_back("BG1_YPR");
}
uint16_t grp3 = BG3_NONE;
std::list<std::string> sgrp3;
uint16_t grp5 = BG5_NONE;
std::list<std::string> sgrp5;
if (imu_compensated_) {
grp1 |= BG1_ACCEL | BG1_ANGULAR_RATE;
sgrp1.push_back("BG1_ACCEL");
sgrp1.push_back("BG1_ANGULAR_RATE");
if (enable_mag_) {
grp3 |= BG3_MAG;
sgrp3.push_back("BG3_MAG");
}
} else {
grp1 |= BG1_IMU;
sgrp1.push_back("BG1_IMU");
if (enable_mag_) {
grp3 |= BG3_UNCOMP_MAG;
sgrp3.push_back("BG3_UNCOMP_MAG");
}
}
if (enable_temp_) {
grp3 |= BG3_TEMP;
sgrp3.push_back("BG3_TEMP");
}
if (enable_pres_) {
grp3 |= BG3_PRES;
sgrp3.push_back("BG3_PRES");
}
if (!sgrp1.empty()) {
std::stringstream ss;
std::copy(
sgrp1.begin(),
sgrp1.end(),
std::ostream_iterator<std::string>(ss, "|")
);
std::string s = ss.str();
s.pop_back();
ROS_INFO("Streaming #1: %s", s.c_str());
}
if (!sgrp3.empty()) {
std::stringstream ss;
std::copy(
sgrp3.begin(),
sgrp3.end(),
std::ostream_iterator<std::string>(ss, "|")
);
std::string s = ss.str();
s.pop_back();
ROS_INFO("Streaming #3: %s", s.c_str());
}
if (!sgrp5.empty()) {
std::stringstream ss;
std::copy(
sgrp5.begin(),
sgrp5.end(),
std::ostream_iterator<std::string>(ss, "|")
);
std::string s = ss.str();
s.pop_back();
ROS_INFO("Streaming #5: %s", s.c_str());
}
VnEnsure(vn100_setBinaryOutput1Configuration(
&imu_,
binary_async_mode_,
kBaseImuRate / imu_rate_,
grp1, grp3, grp5,
true
));
} else {
// Set the ASCII output data type and data rate
// ROS_INFO("Configure the output data type and frequency (id: 6 & 7)");
VnEnsure(vn100_setAsynchronousDataOutputType(&imu_, VNASYNC_VNIMU, true));
}
// Add a callback function for new data event
VnEnsure(vn100_registerAsyncDataReceivedListener(&imu_, &AsyncListener));
ROS_INFO("Setting IMU rate to %d", imu_rate_);
VnEnsure(vn100_setAsynchronousDataOutputFrequency(&imu_, imu_rate_, true));
} else {
// Mute the stream
ROS_DEBUG("Mute the device");
VnEnsure(vn100_setAsynchronousDataOutputType(&imu_, VNASYNC_OFF, true));
// Remove the callback function for new data event
VnEnsure(vn100_unregisterAsyncDataReceivedListener(&imu_, &AsyncListener));
}
// Resume the device
VnEnsure(vn100_resumeAsyncOutputs(&imu_, true));
}
void ImuVn100::Resume(bool need_reply) {
vn100_resumeAsyncOutputs(&imu_, need_reply);
}
void ImuVn100::Idle(bool need_reply) {
vn100_pauseAsyncOutputs(&imu_, need_reply);
}
void ImuVn100::Disconnect() {
// TODO: why reset the device?
vn100_reset(&imu_);
vn100_disconnect(&imu_);
}
void ImuVn100::PublishData(const VnDeviceCompositeData& data) {
sensor_msgs::msg::Imu imu_msg;
imu_msg.header.stamp = imu_vn_100::getROSTimeNow();
imu_msg.header.frame_id = frame_id_;
if (imu_compensated_) {
RosVector3FromVnVector3(imu_msg.linear_acceleration, data.acceleration);
RosVector3FromVnVector3(imu_msg.angular_velocity, data.angularRate);
} else {
// NOTE: The IMU angular velocity and linear acceleration outputs are
// swapped. And also why are they different?
RosVector3FromVnVector3(imu_msg.angular_velocity,
data.accelerationUncompensated);
RosVector3FromVnVector3(imu_msg.linear_acceleration,
data.angularRateUncompensated);
}
if (binary_output_) {
RosQuaternionFromVnQuaternion(imu_msg.orientation, data.quaternion);
}
pd_imu_.Publish(imu_msg);
if (enable_rpy_) {
geometry_msgs::msg::Vector3Stamped rpy_msg;
rpy_msg.header= imu_msg.header;
rpy_msg.vector.z = data.ypr.yaw * M_PI/180.0;
rpy_msg.vector.y = data.ypr.pitch * M_PI/180.0;
rpy_msg.vector.x = data.ypr.roll * M_PI/180.0;
pd_rpy_.Publish(rpy_msg);
}
if (enable_mag_) {
sensor_msgs::msg::MagneticField mag_msg;
mag_msg.header = imu_msg.header;
RosVector3FromVnVector3(mag_msg.magnetic_field, data.magnetic);
pd_mag_.Publish(mag_msg);
}
if (enable_pres_) {
sensor_msgs::msg::FluidPressure pres_msg;
pres_msg.header = imu_msg.header;
pres_msg.fluid_pressure = data.pressure;
pd_pres_.Publish(pres_msg);
}
if (enable_temp_) {
sensor_msgs::msg::Temperature temp_msg;
temp_msg.header = imu_msg.header;
temp_msg.temperature = data.temperature;
pd_temp_.Publish(temp_msg);
}
sync_info_.Update(data.syncInCnt, imu_msg.header.stamp);
updater_.update();
}
void VnEnsure(const VnErrorCode& error_code) {
if (error_code == VNERR_NO_ERROR) return;
switch (error_code) {
case VNERR_UNKNOWN_ERROR:
throw std::runtime_error("VN: Unknown error");
case VNERR_NOT_IMPLEMENTED:
throw std::runtime_error("VN: Not implemented");
case VNERR_TIMEOUT:
ROS_WARN("Opertation time out");
break;
case VNERR_SENSOR_INVALID_PARAMETER:
ROS_WARN("VN: Sensor invalid paramter");
break;
case VNERR_INVALID_VALUE:
ROS_WARN("VN: Invalid value");
break;
case VNERR_FILE_NOT_FOUND:
ROS_WARN("VN: File not found");
break;
case VNERR_NOT_CONNECTED:
throw std::runtime_error("VN: not connected");
case VNERR_PERMISSION_DENIED:
throw std::runtime_error("VN: Permission denied");
default:
ROS_WARN("Unhandled error type");
}
}
void RosVector3FromVnVector3(geometry_msgs::msg::Vector3& ros_vec3,
const VnVector3& vn_vec3) {
ros_vec3.x = vn_vec3.c0;
ros_vec3.y = vn_vec3.c1;
ros_vec3.z = vn_vec3.c2;
}
void RosQuaternionFromVnQuaternion(geometry_msgs::msg::Quaternion& ros_quat,
const VnQuaternion& vn_quat) {
ros_quat.x = vn_quat.x;
ros_quat.y = vn_quat.y;
ros_quat.z = vn_quat.z;
ros_quat.w = vn_quat.w;
}
} // namespace imu_vn_100
| [
"sbasu4@visteon.com"
] | sbasu4@visteon.com |
eb7c9d14cc23947e1388d5cf42f4ebc61a657fce | d83e76f5440e67df1581c822c3ae54e43b71cdf5 | /third_party/blink/renderer/core/layout/ng/inline/ng_line_box_fragment_builder.h | 498e42ea454b9c29a97eafe33ab604f2d9b7e74c | [
"BSD-2-Clause",
"LGPL-2.1-only",
"LGPL-2.0-only",
"LGPL-2.0-or-later",
"LicenseRef-scancode-warranty-disclaimer",
"GPL-1.0-or-later",
"GPL-2.0-only",
"LicenseRef-scancode-other-copyleft",
"BSD-3-Clause",
"MIT",
"Apache-2.0"
] | permissive | Abhik1998/chromium | cbc7ee4020fd1f1430db69f39593106da87632dc | 67e4e691e38bb788c891c2bfb5ce4da1ed86b0dd | refs/heads/master | 2023-03-20T08:42:16.199668 | 2019-10-01T07:20:09 | 2019-10-01T07:20:09 | 212,037,122 | 1 | 0 | BSD-3-Clause | 2019-10-01T07:30:28 | 2019-10-01T07:30:27 | null | UTF-8 | C++ | false | false | 10,517 | h | // Copyright 2017 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef NGLineBoxFragmentBuilder_h
#define NGLineBoxFragmentBuilder_h
#include "third_party/blink/renderer/core/layout/geometry/logical_offset.h"
#include "third_party/blink/renderer/core/layout/ng/inline/ng_inline_break_token.h"
#include "third_party/blink/renderer/core/layout/ng/inline/ng_inline_node.h"
#include "third_party/blink/renderer/core/layout/ng/inline/ng_line_height_metrics.h"
#include "third_party/blink/renderer/core/layout/ng/inline/ng_physical_line_box_fragment.h"
#include "third_party/blink/renderer/core/layout/ng/inline/ng_physical_text_fragment.h"
#include "third_party/blink/renderer/core/layout/ng/ng_container_fragment_builder.h"
#include "third_party/blink/renderer/core/layout/ng/ng_layout_result.h"
#include "third_party/blink/renderer/core/layout/ng/ng_physical_container_fragment.h"
#include "third_party/blink/renderer/core/layout/ng/ng_positioned_float.h"
#include "third_party/blink/renderer/platform/wtf/allocator/allocator.h"
namespace blink {
class ComputedStyle;
class NGInlineBreakToken;
class CORE_EXPORT NGLineBoxFragmentBuilder final
: public NGContainerFragmentBuilder {
STACK_ALLOCATED();
public:
NGLineBoxFragmentBuilder(NGInlineNode node,
scoped_refptr<const ComputedStyle> style,
const NGConstraintSpace* space,
WritingMode writing_mode,
TextDirection)
: NGContainerFragmentBuilder(node,
style,
space,
writing_mode,
TextDirection::kLtr),
line_box_type_(NGPhysicalLineBoxFragment::kNormalLineBox),
base_direction_(TextDirection::kLtr) {}
void Reset();
LayoutUnit LineHeight() const {
return metrics_.LineHeight().ClampNegativeToZero();
}
void SetInlineSize(LayoutUnit inline_size) {
size_.inline_size = inline_size;
}
void SetHangInlineSize(LayoutUnit hang_inline_size) {
hang_inline_size_ = hang_inline_size;
}
// Mark this line box is an "empty" line box. See NGLineBoxType.
void SetIsEmptyLineBox();
const NGLineHeightMetrics& Metrics() const { return metrics_; }
void SetMetrics(const NGLineHeightMetrics& metrics) { metrics_ = metrics; }
void SetBaseDirection(TextDirection direction) {
base_direction_ = direction;
}
// Set the break token for the fragment to build.
// A finished break token will be attached if not set.
void SetBreakToken(scoped_refptr<NGInlineBreakToken> break_token) {
break_token_ = std::move(break_token);
}
// A data struct to keep NGLayoutResult or fragment until the box tree
// structures and child offsets are finalized.
struct Child {
DISALLOW_NEW();
scoped_refptr<const NGLayoutResult> layout_result;
scoped_refptr<const NGPhysicalTextFragment> fragment;
LayoutObject* out_of_flow_positioned_box = nullptr;
LayoutObject* unpositioned_float = nullptr;
// The offset of the border box, initially in this child coordinate system.
// |ComputeInlinePositions()| converts it to the offset within the line box.
LogicalOffset offset;
// The offset of a positioned float wrt. the root BFC. This should only be
// set for positioned floats.
NGBfcOffset bfc_offset;
// The inline size of the margin box.
LayoutUnit inline_size;
LayoutUnit margin_line_left;
// The index of |box_data_list_|, used in |PrepareForReorder()| and
// |UpdateAfterReorder()| to track children of boxes across BiDi reorder.
unsigned box_data_index = 0;
// For an inline box, shows the number of descendant |Child|ren, including
// empty ones. Includes itself, so 1 means no descendants. 0 if not an
// inline box. Available only after |CreateBoxFragments()|.
unsigned children_count = 0;
UBiDiLevel bidi_level = 0xff;
// The current text direction for OOF positioned items.
TextDirection container_direction = TextDirection::kLtr;
// Empty constructor needed for |resize()|.
Child() = default;
// Create a placeholder. A placeholder does not have a fragment nor a bidi
// level.
Child(LogicalOffset offset) : offset(offset) {}
// Crete a bidi control. A bidi control does not have a fragment, but has
// bidi level and affects bidi reordering.
Child(UBiDiLevel bidi_level) : bidi_level(bidi_level) {}
// Create an in-flow |NGLayoutResult|.
Child(scoped_refptr<const NGLayoutResult> layout_result,
LogicalOffset offset,
LayoutUnit inline_size,
UBiDiLevel bidi_level)
: layout_result(std::move(layout_result)),
offset(offset),
inline_size(inline_size),
bidi_level(bidi_level) {}
// Create an in-flow |NGPhysicalTextFragment|.
Child(scoped_refptr<const NGPhysicalTextFragment> fragment,
LogicalOffset offset,
LayoutUnit inline_size,
UBiDiLevel bidi_level)
: fragment(std::move(fragment)),
offset(offset),
inline_size(inline_size),
bidi_level(bidi_level) {}
Child(scoped_refptr<const NGPhysicalTextFragment> fragment,
LayoutUnit block_offset,
LayoutUnit inline_size,
UBiDiLevel bidi_level)
: fragment(std::move(fragment)),
offset({LayoutUnit(), block_offset}),
inline_size(inline_size),
bidi_level(bidi_level) {}
// Create an out-of-flow positioned object.
Child(LayoutObject* out_of_flow_positioned_box,
UBiDiLevel bidi_level,
TextDirection container_direction)
: out_of_flow_positioned_box(out_of_flow_positioned_box),
bidi_level(bidi_level),
container_direction(container_direction) {}
// Create an unpositioned float.
Child(LayoutObject* unpositioned_float, UBiDiLevel bidi_level)
: unpositioned_float(unpositioned_float), bidi_level(bidi_level) {}
// Create a positioned float.
Child(scoped_refptr<const NGLayoutResult> layout_result,
NGBfcOffset bfc_offset,
UBiDiLevel bidi_level)
: layout_result(std::move(layout_result)),
bfc_offset(bfc_offset),
bidi_level(bidi_level) {}
bool HasInFlowFragment() const {
if (fragment)
return true;
if (layout_result && !layout_result->PhysicalFragment().IsFloating())
return true;
return false;
}
bool HasOutOfFlowFragment() const { return out_of_flow_positioned_box; }
bool HasFragment() const {
return HasInFlowFragment() || HasOutOfFlowFragment();
}
bool HasBidiLevel() const { return bidi_level != 0xff; }
bool IsPlaceholder() const { return !HasFragment() && !HasBidiLevel(); }
const NGPhysicalFragment* PhysicalFragment() const {
if (layout_result)
return &layout_result->PhysicalFragment();
return fragment.get();
}
};
// A vector of Child.
// Unlike the fragment builder, chlidren are mutable.
// Callers can add to the fragment builder in a batch once finalized.
class ChildList {
STACK_ALLOCATED();
public:
ChildList() = default;
void operator=(ChildList&& other) {
children_ = std::move(other.children_);
}
Child& operator[](wtf_size_t i) { return children_[i]; }
const Child& operator[](wtf_size_t i) const { return children_[i]; }
wtf_size_t size() const { return children_.size(); }
bool IsEmpty() const { return children_.IsEmpty(); }
void ReserveInitialCapacity(unsigned capacity) {
children_.ReserveInitialCapacity(capacity);
}
void clear() { children_.resize(0); }
void resize(wtf_size_t size) { children_.resize(size); }
using iterator = Vector<Child, 16>::iterator;
iterator begin() { return children_.begin(); }
iterator end() { return children_.end(); }
using const_iterator = Vector<Child, 16>::const_iterator;
const_iterator begin() const { return children_.begin(); }
const_iterator end() const { return children_.end(); }
using reverse_iterator = Vector<Child, 16>::reverse_iterator;
reverse_iterator rbegin() { return children_.rbegin(); }
reverse_iterator rend() { return children_.rend(); }
using const_reverse_iterator = Vector<Child, 16>::const_reverse_iterator;
const_reverse_iterator rbegin() const { return children_.rbegin(); }
const_reverse_iterator rend() const { return children_.rend(); }
Child* FirstInFlowChild();
Child* LastInFlowChild();
// Add a child. Accepts all constructor arguments for |Child|.
template <class... Args>
void AddChild(Args&&... args) {
children_.emplace_back(std::forward<Args>(args)...);
}
void InsertChild(unsigned index);
void InsertChild(unsigned index,
scoped_refptr<const NGLayoutResult> layout_result,
const LogicalOffset& offset,
LayoutUnit inline_size,
UBiDiLevel bidi_level) {
children_.insert(index, Child{std::move(layout_result), offset,
inline_size, bidi_level});
}
void MoveInInlineDirection(LayoutUnit);
void MoveInInlineDirection(LayoutUnit, unsigned start, unsigned end);
void MoveInBlockDirection(LayoutUnit);
void MoveInBlockDirection(LayoutUnit, unsigned start, unsigned end);
private:
Vector<Child, 16> children_;
};
// Add all items in ChildList. Skips null Child if any.
void AddChildren(ChildList&);
// Add only out-of-flow items in ChildList. TODO(kojii): When |NGFragmentItem|
// is on, all objects should go to |NGFragmentItems| but OOF still uses
// fragments to propagate while in transition.
void AddOutOfFlowChildren(ChildList&);
// Creates the fragment. Can only be called once.
scoped_refptr<const NGLayoutResult> ToLineBoxFragment();
private:
NGLineHeightMetrics metrics_;
LayoutUnit hang_inline_size_;
NGPhysicalLineBoxFragment::NGLineBoxType line_box_type_;
TextDirection base_direction_;
friend class NGLayoutResult;
friend class NGPhysicalLineBoxFragment;
DISALLOW_COPY_AND_ASSIGN(NGLineBoxFragmentBuilder);
};
} // namespace blink
WTF_ALLOW_MOVE_INIT_AND_COMPARE_WITH_MEM_FUNCTIONS(
blink::NGLineBoxFragmentBuilder::Child)
#endif // NGLineBoxFragmentBuilder
| [
"commit-bot@chromium.org"
] | commit-bot@chromium.org |
e444495ab290f3e7aed9eddf6da1d876015b4d74 | ad273708d98b1f73b3855cc4317bca2e56456d15 | /aws-cpp-sdk-apigatewayv2/source/model/DeleteApiMappingRequest.cpp | deba1dd37305b159928e9fe12289f9ba33cf0538 | [
"MIT",
"Apache-2.0",
"JSON"
] | permissive | novaquark/aws-sdk-cpp | b390f2e29f86f629f9efcf41c4990169b91f4f47 | a0969508545bec9ae2864c9e1e2bb9aff109f90c | refs/heads/master | 2022-08-28T18:28:12.742810 | 2020-05-27T15:46:18 | 2020-05-27T15:46:18 | 267,351,721 | 1 | 0 | Apache-2.0 | 2020-05-27T15:08:16 | 2020-05-27T15:08:15 | null | UTF-8 | C++ | false | false | 1,023 | cpp | /*
* Copyright 2010-2017 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
#include <aws/apigatewayv2/model/DeleteApiMappingRequest.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <utility>
using namespace Aws::ApiGatewayV2::Model;
using namespace Aws::Utils::Json;
using namespace Aws::Utils;
DeleteApiMappingRequest::DeleteApiMappingRequest() :
m_apiMappingIdHasBeenSet(false),
m_domainNameHasBeenSet(false)
{
}
Aws::String DeleteApiMappingRequest::SerializePayload() const
{
return {};
}
| [
"aws-sdk-cpp-automation@github.com"
] | aws-sdk-cpp-automation@github.com |
d1c88d1593bd6c6d921f2051cf27b99d06fc6284 | ac93fb93538d31c0f5ce6f51474a78de21e1bd56 | /AgendaDigital/moc_mainwindow.cpp | 95ebebbea36b07ab8beca7a1d7bd02811977fb25 | [] | no_license | IgorNascAlves/Estruturas-de-Dados-CC4651-Trabalho-da-Disciplina | dc83928d5ab74bc26eac0d5af5a8f4bed077055a | 2ce416cb9a12c3cc52b194ea395f90f554ad5cf9 | refs/heads/master | 2021-04-06T19:29:20.026496 | 2018-04-07T19:27:39 | 2018-04-07T19:27:39 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 4,708 | cpp | /****************************************************************************
** Meta object code from reading C++ file 'mainwindow.h'
**
** Created by: The Qt Meta Object Compiler version 67 (Qt 5.10.0)
**
** WARNING! All changes made in this file will be lost!
*****************************************************************************/
#include "mainwindow.h"
#include <QtCore/qbytearray.h>
#include <QtCore/qmetatype.h>
#if !defined(Q_MOC_OUTPUT_REVISION)
#error "The header file 'mainwindow.h' doesn't include <QObject>."
#elif Q_MOC_OUTPUT_REVISION != 67
#error "This file was generated using the moc from 5.10.0. It"
#error "cannot be used with the include files from this version of Qt."
#error "(The moc has changed too much.)"
#endif
QT_BEGIN_MOC_NAMESPACE
QT_WARNING_PUSH
QT_WARNING_DISABLE_DEPRECATED
struct qt_meta_stringdata_MainWindow_t {
QByteArrayData data[10];
char stringdata0[172];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
qptrdiff(offsetof(qt_meta_stringdata_MainWindow_t, stringdata0) + ofs \
- idx * sizeof(QByteArrayData)) \
)
static const qt_meta_stringdata_MainWindow_t qt_meta_stringdata_MainWindow = {
{
QT_MOC_LITERAL(0, 0, 10), // "MainWindow"
QT_MOC_LITERAL(1, 11, 20), // "on_btnEntrar_clicked"
QT_MOC_LITERAL(2, 32, 0), // ""
QT_MOC_LITERAL(3, 33, 22), // "on_btnCadastro_clicked"
QT_MOC_LITERAL(4, 56, 20), // "on_btnSalvar_clicked"
QT_MOC_LITERAL(5, 77, 18), // "on_btnSair_clicked"
QT_MOC_LITERAL(6, 96, 20), // "on_btnBuscar_clicked"
QT_MOC_LITERAL(7, 117, 21), // "on_btnDeletar_clicked"
QT_MOC_LITERAL(8, 139, 26), // "on_tblExibir_doubleClicked"
QT_MOC_LITERAL(9, 166, 5) // "index"
},
"MainWindow\0on_btnEntrar_clicked\0\0"
"on_btnCadastro_clicked\0on_btnSalvar_clicked\0"
"on_btnSair_clicked\0on_btnBuscar_clicked\0"
"on_btnDeletar_clicked\0on_tblExibir_doubleClicked\0"
"index"
};
#undef QT_MOC_LITERAL
static const uint qt_meta_data_MainWindow[] = {
// content:
7, // revision
0, // classname
0, 0, // classinfo
7, 14, // methods
0, 0, // properties
0, 0, // enums/sets
0, 0, // constructors
0, // flags
0, // signalCount
// slots: name, argc, parameters, tag, flags
1, 0, 49, 2, 0x08 /* Private */,
3, 0, 50, 2, 0x08 /* Private */,
4, 0, 51, 2, 0x08 /* Private */,
5, 0, 52, 2, 0x08 /* Private */,
6, 0, 53, 2, 0x08 /* Private */,
7, 0, 54, 2, 0x08 /* Private */,
8, 1, 55, 2, 0x08 /* Private */,
// slots: parameters
QMetaType::Void,
QMetaType::Void,
QMetaType::Void,
QMetaType::Void,
QMetaType::Void,
QMetaType::Void,
QMetaType::Void, QMetaType::QModelIndex, 9,
0 // eod
};
void MainWindow::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
if (_c == QMetaObject::InvokeMetaMethod) {
MainWindow *_t = static_cast<MainWindow *>(_o);
Q_UNUSED(_t)
switch (_id) {
case 0: _t->on_btnEntrar_clicked(); break;
case 1: _t->on_btnCadastro_clicked(); break;
case 2: _t->on_btnSalvar_clicked(); break;
case 3: _t->on_btnSair_clicked(); break;
case 4: _t->on_btnBuscar_clicked(); break;
case 5: _t->on_btnDeletar_clicked(); break;
case 6: _t->on_tblExibir_doubleClicked((*reinterpret_cast< const QModelIndex(*)>(_a[1]))); break;
default: ;
}
}
}
const QMetaObject MainWindow::staticMetaObject = {
{ &QMainWindow::staticMetaObject, qt_meta_stringdata_MainWindow.data,
qt_meta_data_MainWindow, qt_static_metacall, nullptr, nullptr}
};
const QMetaObject *MainWindow::metaObject() const
{
return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}
void *MainWindow::qt_metacast(const char *_clname)
{
if (!_clname) return nullptr;
if (!strcmp(_clname, qt_meta_stringdata_MainWindow.stringdata0))
return static_cast<void*>(this);
return QMainWindow::qt_metacast(_clname);
}
int MainWindow::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QMainWindow::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
if (_c == QMetaObject::InvokeMetaMethod) {
if (_id < 7)
qt_static_metacall(this, _c, _id, _a);
_id -= 7;
} else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
if (_id < 7)
*reinterpret_cast<int*>(_a[0]) = -1;
_id -= 7;
}
return _id;
}
QT_WARNING_POP
QT_END_MOC_NAMESPACE
| [
"igor_flipe@hotmail.com"
] | igor_flipe@hotmail.com |
55368d15034f48f62d8a5a886fa39d572d9fbd00 | 93d9a07bd4e7acea1eab75abd3035c3324179416 | /GroupCSDI/GroupCSDI/LinkedList.h | 07235f45714763e1ff3a9ac1ad3b1b6003e3acd2 | [] | no_license | zakbowring/GroupCSDI | f42c01ac604f71c4acb8bfefe47321a86315db09 | 49faf18a722fff196846e592afe3c64e3dc1cb63 | refs/heads/master | 2020-03-13T14:20:25.266627 | 2018-04-28T20:53:52 | 2018-04-28T20:53:52 | 131,152,908 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 382 | h | #pragma once
#include "Node.h"
#include <iostream>
#include <string>
class LinkedList
{
public:
LinkedList(void) { head = NULL; }
~LinkedList(void);
void sort();
bool IsEmpty() { return head == NULL; }
Node* InsertNode(int index, string x[21]);
int FindNode(string x[21]);
int StartUp();
int DeleteNode(string x[21]);
void DisplayList(void);
private:
Node * head;
};
| [
"32679007+JakeWestcott@users.noreply.github.com"
] | 32679007+JakeWestcott@users.noreply.github.com |
df1d94e5042a20269cf86dbd8456848b2faf21aa | 055db09068cb9674fbef3bbc3ac31bcc873e5a21 | /src/utils/Tools/Math/TableCalculator.hpp | 7ef3870efe63907f0774ad9b91c65075386f7f14 | [
"Apache-2.0"
] | permissive | zy4kamu/Coda | 691b91f04bb37d2dd1510f934414516d242a9564 | db18b4960f13781b30a6d3663046ddb7c5b98e49 | refs/heads/master | 2021-07-13T17:34:31.144099 | 2020-10-03T18:42:39 | 2020-10-03T18:42:39 | 74,915,770 | 64 | 13 | null | 2017-03-28T09:44:21 | 2016-11-27T21:35:27 | C++ | UTF-8 | C++ | false | false | 2,262 | hpp | /**
*
* .. invisible:
* _ _ _____ _ _____ _____
*
* | | | | ___| | | ___/ ___|
*
* | | | | |__ | | | |__ \ `--.
*
* | | | | __|| | | __| `--. \
*
* \ \_/ / |___| |___| |___/\__/ /
*
* \___/\____/\_____|____/\____/
*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
* http://www.apache.org/licenses/LICENSE-2.0
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License
*
*/
#include <functional>
#include <memory>
namespace Tools
{
template<class InputType = double, class OutputType = double>
class TableCalculator
{
public:
TableCalculator(const std::function<OutputType(InputType)>& funct,
InputType start, InputType end, InputType step);
OutputType Get(InputType input);
private:
InputType start;
InputType end;
InputType step;
unordered_map<size_t, OutputType> table;
};
template<class InputType, class OutputType>
TableCalculator<InputType, OutputType>::TableCalculator(
const std::function<OutputType(InputType)>& funct,
InputType start, InputType end, InputType step)
: start(start), end(end), step(step)
{
size_t enumerator = 0;
for (InputType iter = start; iter < end; iter += step)
{
table[enumerator++] = funct(iter);
}
}
template<class InputType, class OutputType>
OutputType TableCalculator<InputType, OutputType>::Get(InputType input)
{
if (input < start) {
return table[0]; }
else if (input >= end) {
return table[table.size() - 1];
} else {
size_t index = static_cast<size_t>((input - start) / step);
return table[index];
}
}
}
| [
"m.kudinov@samsung.com"
] | m.kudinov@samsung.com |
f937ef0b51b734c7a03ab4f93e1a38184374767a | b19b6840cdc9192419501b5fa33af4c61c7d7ff6 | /PCA9685_driver/PCA9685/PCA9685.h | 5ec7fc9c1afbe5a0eff052fdf2db33cd22e60af4 | [] | no_license | Sietsewer/spInDP | 138b9d5cdbb5f7126e4e7e807a05ecc6c5b315a0 | a864d2f14b7bc12f5442486581e05edcce2da85d | refs/heads/master | 2021-05-27T09:48:01.417930 | 2014-06-19T18:08:35 | 2014-06-19T18:08:35 | 19,025,145 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,635 | h | /*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*
* Name : PCA9685.h
* Original Author : Georgi Todorov
* Edited by : Tord Wessman
* Version :
* Created on : Nov 22, 2013
*
* Copyright © 2012 Georgi Todorov <terahz@geodar.com>
*/
#ifndef _PCA9685_H
#define _PCA9685_H
#include <inttypes.h>
// Register Definitions
#define MODE1 0x00 //Mode register 1
#define MODE2 0x01 //Mode register 2
#define SUBADR1 0x02 //I2C-bus subaddress 1
#define SUBADR2 0x03 //I2C-bus subaddress 2
#define SUBADR3 0x04 //I2C-bus subaddress 3
#define ALLCALLADR 0x05 //LED All Call I2C-bus address
#define LED0 0x6 //LED0 start register
#define LED0_ON_L 0x6 //LED0 output and brightness control byte 0
#define LED0_ON_H 0x7 //LED0 output and brightness control byte 1
#define LED0_OFF_L 0x8 //LED0 output and brightness control byte 2
#define LED0_OFF_H 0x9 //LED0 output and brightness control byte 3
#define LED_MULTIPLYER 4 // For the other 15 channels
#define ALLLED_ON_L 0xFA //load all the LEDn_ON registers, byte 0 (turn 0-7 channels on)
#define ALLLED_ON_H 0xFB //load all the LEDn_ON registers, byte 1 (turn 8-15 channels on)
#define ALLLED_OFF_L 0xFC //load all the LEDn_OFF registers, byte 0 (turn 0-7 channels off)
#define ALLLED_OFF_H 0xFD //load all the LEDn_OFF registers, byte 1 (turn 8-15 channels off)
#define PRE_SCALE 0xFE //prescaler for output frequency
#define CLOCK_FREQ 25000000.0 //25MHz default osc clock
#define BUFFER_SIZE 0x08 //1 byte buffer
//! Main class that exports features for PCA9685 chip
class PCA9685 {
public:
PCA9685();
void init(int,int);
virtual ~PCA9685();
void reset(void);
void setPWMFreq(int);
void setPWM(uint8_t, int, int);
void setPWM(uint8_t, int);
private:
int _i2caddr;
int _i2cbus;
char busfile[64];
uint8_t dataBuffer[BUFFER_SIZE];
uint8_t read_byte(int, uint8_t);
void write_byte(int, uint8_t, uint8_t);
int openfd();
};
#endif
| [
"sietsewer@gmail.com"
] | sietsewer@gmail.com |
f5ff4c100febf61e85a0fd0984fc12ec0853390c | ba256920e8a016ad63822648f82dfed7e6f60c78 | /src/cryptonote_core/cryptonote_stat_info.h | 4edbf535c9087363295e70617b1a991ab981ac00 | [
"BSD-3-Clause"
] | permissive | Dash2-Dev/Dash2 | e464e0c1cce84bf52ff1febc4de17fa357c5117d | 916e7d5ce67b4023645a7ce3a064142e17038010 | refs/heads/master | 2021-05-08T19:49:05.107771 | 2018-01-12T09:00:18 | 2018-01-12T09:00:18 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,224 | h | // Copyright (c) 2016-2017, SUMOKOIN, (forked from) The Monero Project
//
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without modification, are
// permitted provided that the following conditions are met:
//
// 1. Redistributions of source code must retain the above copyright notice, this list of
// conditions and the following disclaimer.
//
// 2. Redistributions in binary form must reproduce the above copyright notice, this list
// of conditions and the following disclaimer in the documentation and/or other
// materials provided with the distribution.
//
// 3. Neither the name of the copyright holder 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 HOLDER 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.
//
// Parts of this file are originally copyright (c) 2012-2013 The Cryptonote developers
#pragma once
#include "serialization/keyvalue_serialization.h"
namespace cryptonote
{
struct core_stat_info
{
uint64_t tx_pool_size;
uint64_t blockchain_height;
uint64_t mining_speed;
uint64_t alternative_blocks;
std::string top_block_id_str;
BEGIN_KV_SERIALIZE_MAP()
KV_SERIALIZE(tx_pool_size)
KV_SERIALIZE(blockchain_height)
KV_SERIALIZE(mining_speed)
KV_SERIALIZE(alternative_blocks)
KV_SERIALIZE(top_block_id_str)
END_KV_SERIALIZE_MAP()
};
}
| [
"sumoshi.tanaka@gmail.com"
] | sumoshi.tanaka@gmail.com |
617ed8a84467a3ee1e9fbe728c7f9bf991385f3c | 464b180fbdb249ddb472b1e2b54d6b9b15f2e2ca | /Ejercicios de parciales/1 Parcial/CH01_6_250116_24500468.cpp | 8246dcbee2babbe3dbeb211be49900b384092a23 | [] | no_license | Andydiaz12/Estructura-de-Datos-con-Muratalla | a8f765a4998474e263b9217e066e2310e3eb2b8e | e2d6a59e7428c80135531525ce5d9c0a0a5afd45 | refs/heads/master | 2021-01-21T10:42:10.199163 | 2017-05-18T14:56:10 | 2017-05-18T14:56:10 | 91,705,488 | 0 | 0 | null | null | null | null | ISO-8859-1 | C++ | false | false | 770 | cpp | /* José Andrés Díaz Escobar
25 de Enero del 2016
Escribe un programa que pida tres números y que escriba si son los tres iguales, si hay dos iguales o si son los tres distintos*/
#include <stdio.h>
#include <cstdlib>
int main(){
float arr[2];
printf("Ingrese 3 numeros a evaluar\n");
scanf("%f %f %f", &arr[0], &arr[1], &arr[2]);
if(arr[0] == arr[1] && arr[0] == arr[2]){
printf("Los tres numeros que has escrito son iguales\n");
}else{
if ((arr[0] != arr[1] && arr[0] == arr[2]) || (arr[0] != arr[2] && arr[0] == arr[1]) || (arr[1] == arr[2] && arr[1] != arr[0]))
printf("Has escrito uno de los numeros dos veces\n");
else
printf("Los tres números que has escrito son distintos\n");
}
system ("PAUSE");
return 0;
}
| [
"noreply@github.com"
] | Andydiaz12.noreply@github.com |
16627f85222c1f10fe25e03e8c345e1ff22d1869 | 1487d94a390603c93b5c26cad55adfdc177d1657 | /Source/GameService/UI/GsUIHUD.h | 6d8f7b9e5f19709faea1bc4df14e6c227f8b4944 | [
"MIT"
] | permissive | BaekTaehyun/T1Project | d9520f99b0d3f973ef18875e5ee1d1686103c040 | d7d98c7cfc88e57513631124c32dfee8794307db | refs/heads/master | 2020-04-01T09:27:04.900622 | 2019-06-25T05:22:10 | 2019-06-25T05:22:10 | 153,075,452 | 3 | 2 | null | null | null | null | UTF-8 | C++ | false | false | 449 | h | // Fill out your copyright notice in the Description page of Project Settings.
#pragma once
#include "CoreMinimal.h"
#include "UI/GsUIWidgetBase.h"
#include "GsUIHUD.generated.h"
/**
*
*/
UCLASS()
class GAMESERVICE_API UGsUIHUD : public UGsUIWidgetBase
{
GENERATED_BODY()
public:
virtual int32 GetManagedDefaultZOrder() const override { return 1; }
virtual EGsUIHideFlags GetHideFlagType() const { return EGsUIHideFlags::UI_HIDE_HUD; }
};
| [
"dyjchoung@naver.com"
] | dyjchoung@naver.com |
68ff31c72e57f07b83edf6512592a65a670b4b18 | 17883f75b816c84b67f512ca41493bfb8915f7f1 | /src/tritonsort/mapreduce/functions/map/PassThroughMapFunction.h | ac62699278cd8596e31cd96a2c9ba4ce57e4f267 | [
"BSD-3-Clause",
"LicenseRef-scancode-unknown-license-reference"
] | permissive | alexras/themis_tritonsort | ff5c1c44e11c0c5a711e3f886ac5bd80e5102f3b | cd1f6dbf93978471de1d0beb4b026625787edd9c | refs/heads/master | 2022-09-30T20:56:42.009833 | 2017-11-02T20:45:37 | 2017-11-02T20:45:37 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 311 | h | #ifndef MAPRED_PASS_THROUGH_MAP_FUNCTION_H
#define MAPRED_PASS_THROUGH_MAP_FUNCTION_H
#include "mapreduce/functions/map/MapFunction.h"
class PassThroughMapFunction : public MapFunction {
public:
void map(KeyValuePair& kvPair, KVPairWriterInterface& writer);
};
#endif // MAPRED_PASS_THROUGH_MAP_FUNCTION_H
| [
"mconley@cs.ucsd.edu"
] | mconley@cs.ucsd.edu |
0765288d010f79b205c069c5618ad9ccb199df2e | c0376f9eb4eb1adf2db5aff3d25abc3576d0241b | /src/plugins/aggregator/regexpmatchermanager.cpp | 95892fb66572f3584d8eb36929680e0a84b07383 | [
"BSL-1.0"
] | permissive | ROOAARR/leechcraft | 0179e6f1e7c0b7afbfcce60cb810d61bd558b163 | 14bc859ca750598b77abdc8b2d5b9647c281d9b3 | refs/heads/master | 2021-01-17T22:08:16.273024 | 2013-08-05T12:28:45 | 2013-08-05T12:28:45 | 2,217,574 | 1 | 0 | null | 2013-01-19T15:32:47 | 2011-08-16T18:55:44 | C++ | UTF-8 | C++ | false | false | 10,064 | cpp | /**********************************************************************
* LeechCraft - modular cross-platform feature rich internet client.
* Copyright (C) 2006-2013 Georg Rudoy
*
* Boost Software License - Version 1.0 - August 17th, 2003
*
* Permission is hereby granted, free of charge, to any person or organization
* obtaining a copy of the software and accompanying documentation covered by
* this license (the "Software") to use, reproduce, display, distribute,
* execute, and transmit the Software, and to prepare derivative works of the
* Software, and to permit third-parties to whom the Software is furnished to
* do so, all subject to the following:
*
* The copyright notices in the Software and this entire statement, including
* the above license grant, this restriction and the following disclaimer,
* must be included in all copies of the Software, in whole or in part, and
* all derivative works of the Software, unless such copies or derivative
* works are solely in the form of machine-executable object code generated by
* a source language processor.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
* SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
* FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
* DEALINGS IN THE SOFTWARE.
**********************************************************************/
#include "regexpmatchermanager.h"
#include <algorithm>
#include <functional>
#include <iterator>
#include <stdexcept>
#include <QTimer>
#include <QtDebug>
#include <QSettings>
#include <QUrl>
#include <QCoreApplication>
#include <util/util.h>
#include "item.h"
namespace LeechCraft
{
namespace Aggregator
{
RegexpMatcherManager::RegexpItem::RegexpItem (const QString& title,
const QString& body)
: Title_ (title)
, Body_ (body)
{
}
bool RegexpMatcherManager::RegexpItem::operator== (const RegexpMatcherManager::RegexpItem& other) const
{
return Title_ == other.Title_ &&
Body_ == other.Body_;
}
bool RegexpMatcherManager::RegexpItem::IsEqual (const QString& str) const
{
return Title_ == str;
}
QByteArray RegexpMatcherManager::RegexpItem::Serialize () const
{
QByteArray result;
{
QDataStream out (&result, QIODevice::WriteOnly);
int version = 1;
out << version << Title_ << Body_;
}
return result;
}
void RegexpMatcherManager::RegexpItem::Deserialize (const QByteArray& data)
{
QDataStream in (data);
int version = 0;
in >> version;
if (version == 1)
in >> Title_ >> Body_;
else
throw std::runtime_error ("Unknown version");
}
RegexpMatcherManager::RegexpMatcherManager ()
: SaveScheduled_ (false)
{
ItemHeaders_ << tr ("Title matcher") << tr ("Body extractor");
RestoreSettings ();
}
RegexpMatcherManager& RegexpMatcherManager::Instance ()
{
static RegexpMatcherManager inst;
return inst;
}
RegexpMatcherManager::~RegexpMatcherManager ()
{
}
void RegexpMatcherManager::Release ()
{
saveSettings ();
}
namespace
{
inline bool IsRegexpValid (const QString& rx)
{
return QRegExp (rx).isValid ();
}
};
void RegexpMatcherManager::Add (const QString& title, const QString& body)
{
if (!IsRegexpValid (title) || !IsRegexpValid (body))
throw Malformed ("Regexp is malformed");
auto found = std::find_if (Items_.begin (), Items_.end (),
[&title] (const RegexpItem& ri) { return ri.IsEqual (title); });
if (found != Items_.end ())
throw AlreadyExists ("Regexp user tries to add already exists in the RegexpMatcherManager");
beginInsertRows (QModelIndex (), rowCount (), rowCount ());
Items_.push_back (RegexpItem (title, body));
endInsertRows ();
ScheduleSave ();
}
void RegexpMatcherManager::Remove (const QString& title)
{
auto found = std::find_if (Items_.begin (), Items_.end (),
[&title] (const RegexpItem& ri) { return ri.IsEqual (title); });
if (found == Items_.end ())
throw NotFound ("Regexp user tried to remove doesn't exist in the RegexpMatcherManager");
int dst = std::distance (Items_.begin (), found);
beginRemoveRows (QModelIndex (), dst, dst);
Items_.erase (found);
endRemoveRows ();
ScheduleSave ();
}
void RegexpMatcherManager::Remove (const QModelIndex& index)
{
items_t::iterator begin = Items_.begin ();
std::advance (begin, index.row ());
beginRemoveRows (QModelIndex (), index.row (), index.row ());
Items_.erase (begin);
endRemoveRows ();
ScheduleSave ();
}
void RegexpMatcherManager::Modify (const QString& title, const QString& newBody)
{
if (!IsRegexpValid (title) || !IsRegexpValid (newBody))
throw Malformed ("Regexp is malformed");
auto found = std::find_if (Items_.begin (), Items_.end (),
[&title] (const RegexpItem& ri) { return ri.IsEqual (title); });
if (found == Items_.end ())
throw NotFound ("Regexp user tried to modify doesn't exist in the RegexpMatcherManager");
found->Body_ = newBody;
int dst = std::distance (Items_.begin (), found);
emit dataChanged (index (dst, 1), index (dst, 1));
ScheduleSave ();
}
RegexpMatcherManager::titlebody_t RegexpMatcherManager::GetTitleBody (const QModelIndex& index) const
{
titlebody_t result;
if (index.row () >= static_cast<int> (Items_.size ()))
return result;
result.first = Items_ [index.row ()].Title_;
result.second = Items_ [index.row ()].Body_;
return result;
}
namespace
{
struct HandleBody : public std::unary_function<RegexpMatcherManager::RegexpItem, void>
{
const Item_ptr& Item_;
QStringList Links_;
HandleBody (const Item_ptr& item)
: Item_ (item)
{
}
void operator() (const RegexpMatcherManager::RegexpItem& item)
{
QString rxs = item.Body_;
bool link = false;
if (rxs.startsWith ("\\link"))
{
rxs = rxs.right (rxs.size () - 5);
link = true;
}
QRegExp ib (rxs, Qt::CaseInsensitive, QRegExp::RegExp2);
if (link)
{
if (rxs.isEmpty () || ib.indexIn (Item_->Link_) != -1)
Links_ << Item_->Link_;
for (QList<Enclosure>::const_iterator i = Item_->Enclosures_.begin (),
end = Item_->Enclosures_.end (); i != end; ++i)
if (rxs.isEmpty () || ib.indexIn (i->URL_) != -1)
Links_ << i->URL_;
}
else if (!link && ib.indexIn (Item_->Description_) != -1)
Links_ << ib.cap (0);
}
QStringList GetLinks ()
{
std::sort (Links_.begin (), Links_.end ());
QStringList result;
std::unique_copy (Links_.begin (), Links_.end (),
std::back_inserter (result));
return result;
}
};
};
void RegexpMatcherManager::HandleItem (const Item_ptr& item) const
{
std::deque<RegexpItem> matchingTitles;
std::copy_if (Items_.begin (), Items_.end (),
std::back_inserter (matchingTitles),
[item] (const RegexpItem& ri)
{ return QRegExp (ri.Title_).exactMatch (item->Title_); });
QStringList links = std::for_each (matchingTitles.begin (),
matchingTitles.end (),
HandleBody (item)).GetLinks ();
for (QStringList::const_iterator i = links.begin (),
end = links.end (); i != end; ++i)
{
LeechCraft::Entity e;
QUrl url (*i);
if (url.isValid ())
e.Entity_ = url;
else
e.Entity_ = *i;
emit gotLink (e);
}
}
int RegexpMatcherManager::columnCount (const QModelIndex&) const
{
return ItemHeaders_.size ();
}
QVariant RegexpMatcherManager::data (const QModelIndex& index, int role) const
{
if (!index.isValid () || index.row () >= rowCount () || role != Qt::DisplayRole)
return QVariant ();
items_t::const_iterator pointer = Items_.begin ();
std::advance (pointer, index.row ());
switch (index.column ())
{
case 0:
return pointer->Title_;
case 1:
return pointer->Body_;
default:
return QVariant ();
}
}
Qt::ItemFlags RegexpMatcherManager::flags (const QModelIndex&) const
{
return Qt::ItemIsEnabled | Qt::ItemIsSelectable;
}
QVariant RegexpMatcherManager::headerData (int column, Qt::Orientation orient, int role) const
{
if (orient == Qt::Horizontal && role == Qt::DisplayRole)
return ItemHeaders_.at (column);
else
return QVariant ();
}
QModelIndex RegexpMatcherManager::index (int row, int column, const QModelIndex& parent) const
{
if (!hasIndex (row, column, parent))
return QModelIndex ();
return createIndex (row, column);
}
QModelIndex RegexpMatcherManager::parent (const QModelIndex&) const
{
return QModelIndex ();
}
int RegexpMatcherManager::rowCount (const QModelIndex& parent) const
{
return parent.isValid () ? 0 : Items_.size ();
}
void RegexpMatcherManager::saveSettings () const
{
QSettings settings (QCoreApplication::organizationName (),
QCoreApplication::applicationName () + "_Aggregator");
settings.beginWriteArray ("RegexpMatcher");
settings.remove ("");
int i = 0;
std::for_each (Items_.begin (), Items_.end (),
[&settings, &i] (const RegexpItem& ri)
{
settings.setArrayIndex (i++);
settings.setValue ("Item", ri.Serialize ());
});
settings.endArray ();
SaveScheduled_ = false;
}
void RegexpMatcherManager::RestoreSettings ()
{
QSettings settings (QCoreApplication::organizationName (),
QCoreApplication::applicationName () + "_Aggregator");
int size = settings.beginReadArray ("RegexpMatcher");
for (int i = 0; i < size; ++i)
{
settings.setArrayIndex (i);
QByteArray data = settings.value ("Item").toByteArray ();
RegexpItem item;
try
{
item.Deserialize (data);
}
catch (const std::runtime_error& e)
{
qWarning () << Q_FUNC_INFO << e.what ();
continue;
}
Items_.push_back (item);
}
settings.endArray ();
}
void RegexpMatcherManager::ScheduleSave ()
{
if (SaveScheduled_)
return;
QTimer::singleShot (100, this, SLOT (saveSettings ()));
SaveScheduled_ = true;
}
}
}
| [
"0xd34df00d@gmail.com"
] | 0xd34df00d@gmail.com |
f0215bf367d7f930931e19f0df2623ebffec2a02 | 091afb7001e86146209397ea362da70ffd63a916 | /inst/include/nt2/include/functions/is_not_less_equal.hpp | dfd238cec34ad2dfae19735ca084afe245b4f1a4 | [] | no_license | RcppCore/RcppNT2 | f156b58c08863243f259d1e609c9a7a8cf669990 | cd7e548daa2d679b6ccebe19744b9a36f1e9139c | refs/heads/master | 2021-01-10T16:15:16.861239 | 2016-02-02T22:18:25 | 2016-02-02T22:18:25 | 50,460,545 | 15 | 1 | null | 2019-11-15T22:08:50 | 2016-01-26T21:29:34 | C++ | UTF-8 | C++ | false | false | 197 | hpp | #ifndef NT2_INCLUDE_FUNCTIONS_IS_NOT_LESS_EQUAL_HPP_INCLUDED
#define NT2_INCLUDE_FUNCTIONS_IS_NOT_LESS_EQUAL_HPP_INCLUDED
#include <nt2/predicates/include/functions/is_not_less_equal.hpp>
#endif
| [
"kevinushey@gmail.com"
] | kevinushey@gmail.com |
30e201a069fff95255d7d655f26ca5992e256874 | 69a9bfd7f0d44a05c8ef07d2cbaed7d62d911a3c | /libs/vision/src/vision/AngleDetect.cpp | dbd7858482502b920f81611e866bb6fb66baafa4 | [] | no_license | AnaWhatever16/thesis_visionfordrone | 5834c81c03c8f99626901b86191c0d968b127135 | 601f8f297b824132e97496616055c1ed0fb05a5b | refs/heads/master | 2022-11-13T22:32:46.474866 | 2020-06-30T18:27:03 | 2020-06-30T18:27:03 | 267,156,343 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 6,483 | cpp | #include <vision/AngleDetect.h>
typedef Eigen::Matrix<float, 2, 3> Matrix2x3;
AngleDetect::AngleDetect(cv::Mat &_frame, std::vector<cv::Vec4i> &_vec){
initFrame_ = _frame;
vecInit_=_vec;
}
float AngleDetect::detect(std::vector<cv::Vec4i> &_vec, cv::Mat &_frame){
float ang_w = 0;
float bestScore = 1e5;
//cv::Mat modif(_frame.rows,_frame.cols, CV_64F);
cv::Mat blended;
for(size_t i=0; i < vecInit_.size(); i++){
cv::Vec4i ref;
ref = vecInit_[i];
cv::Vec2f vr(ref[2],ref[3]); //reference vector
for (size_t j=0; j < _vec.size(); j++){
cv::Vec4i obj = _vec[j];
cv::Vec2f vo(obj[2],obj[3]); //objects vector
float ang = (atan2(vr[1], vr[0]) - atan2(vo[1], vo[0]))*180/M_PI; // REF considered static.
cv::Point center = cv::Point(_frame.cols/2, _frame.rows/2);
float scale =1;
cv::Mat rot_mat = getRotationMatrix2D( center, -ang, scale ); //we give the opposite angle because the matrix is opposite (see openCV doc)
rot_mat.convertTo(rot_mat, CV_32F);
cv::Mat mod_frame;
cv::warpAffine(_frame, mod_frame, rot_mat, _frame.size());
cv::Mat blend;
addWeighted(initFrame_, 0.3, mod_frame, 0.5, 0.0, blend);
float score = lineComparison(rot_mat, vecInit_, _vec, blend);
cv::putText(blend, std::to_string(score), cv::Point(10,100), cv::FONT_HERSHEY_PLAIN,2,cv::Scalar(255,255,255));
std::stringstream ss;
ss << "img_" << i << "_" << j << ".jpg";
if (score < bestScore){
bestScore = score;
//modif=mod_frame; //debug
//blended=blend; //debug
ang_w=ang;
}
}
}
return ang_w;
}
float AngleDetect::lineComparison(cv::Mat &_T, std::vector<cv::Vec4i> &vecInit_, std::vector<cv::Vec4i> &_vec, cv::Mat &_blend){
std::vector<Match> matches(_vec.size());
std::vector<cv::Vec4i> rotatedObj(_vec.size());
for(size_t i=0; i < _vec.size(); i++){
cv::Mat p1 = cv::Mat(3,1,_T.type());
p1.at<float>(0) = _vec[i][0];
p1.at<float>(1) = _vec[i][1];
p1.at<float>(2) = 1.0f;
cv::Mat v = cv::Mat(2,1,_T.type());
v.at<float>(0) = _vec[i][2];
v.at<float>(1) = _vec[i][3];
cv::Mat rp1 = _T*p1;
cv::Mat rotMatrix = _T(cv::Rect(0,0,2,2));
cv::Mat rv = rotMatrix*v;
cv::Vec4i robj( rp1.at<float>(0), rp1.at<float>(1),
rv.at<float>(0), rv.at<float>(1));
rotatedObj[i] = robj;
}
for(size_t i=0; i < _vec.size(); i++){
float minScore = 1e5;
for (size_t j=0; j < vecInit_.size(); j++){
cv::Vec4i nref = vecInit_[j];
float actualScore = scoreCalc(nref, rotatedObj[i]);
// std::cout << actualScore << "\t";
if (actualScore < minScore){
matches[i].id_line = j;
matches[i].flag_eval = 0; //flag to evaluate later
matches[i].score = actualScore;
minScore = actualScore;
} //min score for each ref line
}
}
return scoreSelection(matches); //see if there are not repeated object lines and add scores
}
cv::Vec3f AngleDetect::lineCalc (cv::Vec4i _vec){
float m, y, n;
if (_vec[2] == 0){ //vertical line
m = 1;
y = 0;
n = _vec[0];
}
else{ //any other line
m = _vec[3]/_vec[2];
y = 1;
n = _vec[1]-m*_vec[0];
}
return cv::Vec3f(m,y,n);
}
float AngleDetect::scoreCalc(cv::Vec4i &_ref, cv::Vec4i &_obj){
cv::Vec3f rectRef = lineCalc(_ref);
cv::Vec2f vr(_ref[2],_ref[3]); //objects vector
cv::Vec3f rectObj = lineCalc(_obj);
cv::Vec2f vo(_obj[2],_obj[3]); //objects vector
Matrix2x3 Ab;
Eigen::Matrix2f As;
Ab << -rectRef[0], rectRef[1], rectRef[2],
-rectObj[0], rectObj[1], rectObj[2];
As << -rectRef[0], rectRef[1],
-rectObj[0], rectObj[1];
Eigen::FullPivLU<Matrix2x3> evalB(Ab);
evalB.setThreshold(1e-5);
Eigen::FullPivLU<Eigen::Matrix2f> evalS(As);
evalS.setThreshold(1e-5);
float ang, scoredist;
if (evalB.rank() == evalS.rank()){
if (evalB.rank() == 2){ //they intersect
scoredist = 0;
// std::cout << "vo: " << vo << std::endl;
// std::cout << "vr " << vr << std::endl;
ang = atan2(vo[1], vo[0]) - atan2(vr[1], vr[0]);
//normalize it to the range [0, 2 π):
//if (ang < 0) { ang += 2 * M_PI; }
ang=ang/M_PI; //normalized angle between [0,1]
}
else if(evalB.rank() == 1){ //they are the same line
ang = 0;
scoredist = 0;
}
else std::cout << "Something went terribly wrong" << std::endl;
}
else{ //they are parallel
ang = 0;
float dist = distanceCalc(_ref, _obj);
// scoredist = 1 - 1/exp(dist); //dist=0 scoredist = 0; dist = inf scoredist = 1;
scoredist = dist/initFrame_.cols; // 666
}
return (fabs(ang) + scoredist); //number should be between [0, 1] because one of them is always 0
}
float AngleDetect::scoreSelection(std::vector<Match> &_scores){
float sumScore=0;
float data = 0;
for (size_t i = 0; i < _scores.size(); i++){
if (_scores[i].flag_eval == 0){
sumScore+=_scores[i].score;
data++;
}
}
if (data==0){
std::cout << "No score" << std::endl; //for debug
return 1e5;
}
else if (data < 4){
//std::cout << "Not enough matches" << std::endl; //for debug
return 1e5;
}
else{
return sumScore/data;
}
}
float AngleDetect::distanceCalc(cv::Vec4i &_ref, cv::Vec4i &_obj){
cv::Vec2f pointRef = {_ref[0], _ref[1]};
cv::Vec2f pointObj = {_obj[0], _obj[1]};
float norm = sqrt(_ref[2]*_ref[2] + _ref[3]*_ref[3]);
cv::Vec2f lineDirection = {_ref[2]/norm, _ref[3]/norm};
float aux = (pointObj[0]-pointRef[0])*lineDirection[1] - (pointObj[1]-pointRef[1])*lineDirection[0];
float mu = aux/(lineDirection[0]*lineDirection[0] + lineDirection[1]*lineDirection[1]);
float dist = sqrt(mu*lineDirection[1]*mu*lineDirection[1] + mu*lineDirection[0]*mu*lineDirection[0]);
return dist;
} | [
"anacasadofauli@gmail.com"
] | anacasadofauli@gmail.com |
0ffb6438501ac93a5608a11eae9d738bd05b8de0 | a23da36e8549d0946258d39b435a53dfac0b704c | /uva longest common subsequence (shafayat rules).cpp | e91668ff85fe00d037945d689beb969f02469ed4 | [] | no_license | FathemaSmrity123/uva | 1734a9ff67612badeb37cf33808adbaecbafc03c | 1845b5b170ab802daa675df2605b8720dff22ca4 | refs/heads/master | 2021-05-14T04:25:17.789903 | 2018-09-07T05:16:25 | 2018-09-07T05:16:25 | 116,643,304 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 676 | cpp | #include<bits/stdc++.h>
using namespace std;
#define MAXC 1000
string A,B;
int lenA,lenB;
int dp[MAXC][MAXC];
bool visited[MAXC][MAXC];
int calcLCS(int i,int j)
{
if(A[i]=='\0' or B[j]=='\0') return 0;
if(visited[i][j])return dp[i][j];
int ans=0;
if(A[i]==B[j]) ans=1+calcLCS(i+1,j+1);
else
{
int val1=calcLCS(i+1,j);
int val2=calcLCS(i,j+1);
ans=max(val1,val2);
}
visited[i][j]=1;
dp[i][j]=ans;
return dp[i][j];
}
int main() {
while(getline(cin,A)){
getline(cin,B);
lenA=A.length();
lenB=B.length();
printf("%d\n",calcLCS(0,0));
memset(dp,0,sizeof dp);
memset(visited,0,sizeof visited);
}
return 0;
}
| [
"noreply@github.com"
] | FathemaSmrity123.noreply@github.com |
ed91dd72a0a6f3cca947e10a4c99e2d68942edf8 | 4207d276f0edafed1197d919beeaf36a5bf0cb98 | /Source/Support/Value.cpp | a0dada1181ca9c88c1843ce0d1f70638d5cbfa46 | [
"MIT"
] | permissive | zyz120/Dorothy-SSR | b742083d92b1971110f30991dfdd230933f89b39 | d5c417ba27d676fc6bcb475ee44c30e4aa8d856c | refs/heads/master | 2021-01-19T14:43:03.421461 | 2017-04-13T08:26:12 | 2017-04-13T08:26:12 | 86,802,145 | 1 | 0 | null | 2017-03-31T09:27:03 | 2017-03-31T09:27:03 | null | UTF-8 | C++ | false | false | 1,201 | cpp | /* Copyright (c) 2017 Jin Li, http://www.luvfight.me
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 "Const/Header.h"
#include "Support/Value.h"
NS_DOROTHY_BEGIN
const Ref<Values> Values::None;
NS_DOROTHY_END
| [
"dragon-fly@qq.com"
] | dragon-fly@qq.com |
86de5831eeb93c24cc6b00226fc264657fe92f65 | 344be5840be33108d6f703ed05d8952fb16f63f1 | /opt/result-propagation/ResultPropagation.cpp | d4f40e0ef0a56fede3d52d72d041a4f496af7d86 | [
"MIT"
] | permissive | jsjxsy/redex | 4ebfaf46534c7d18f6a9f9ebfd74288f9ea347d3 | 1fe1f97ea0b70cfa0768d9bbdf4d5e585c766cab | refs/heads/master | 2020-09-02T08:01:39.757308 | 2019-11-01T22:03:31 | 2019-11-01T22:05:18 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 21,231 | cpp | /*
* Copyright (c) Facebook, Inc. and its affiliates.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*/
#include "ResultPropagation.h"
#include <vector>
#include "BaseIRAnalyzer.h"
#include "ConstantAbstractDomain.h"
#include "ControlFlow.h"
#include "IRCode.h"
#include "IRInstruction.h"
#include "PatriciaTreeMapAbstractEnvironment.h"
#include "Resolver.h"
#include "Walkers.h"
using namespace sparta;
namespace {
constexpr const char* METRIC_METHODS_WHICH_RETURN_PARAMETER =
"num_methods_which_return_parameters";
constexpr const char* METRIC_ERASED_MOVE_RESULTS = "num_erased_move_results";
constexpr const char* METRIC_PATCHED_MOVE_RESULTS = "num_patched_move_results";
constexpr const char* METRIC_UNVERIFIABLE_MOVE_RESULTS =
"num_unverifiable_move_results";
constexpr const char* METRIC_METHODS_WHICH_RETURN_PARAMETER_ITERATIONS =
"num_methods_which_return_parameters_iterations";
constexpr const ParamIndex WIDE_HIGH = 1 << 31;
void patch_move_result_to_move(IRInstruction* move_result_inst, uint16_t reg) {
const auto op = move_result_inst->opcode();
move_result_inst->set_opcode(opcode::move_result_to_move(op));
move_result_inst->set_srcs_size(1);
move_result_inst->set_src(0, reg);
}
const DexType* get_param_type(bool is_static,
const DexMethodRef* method,
ParamIndex param_index) {
if (!is_static && param_index-- == 0) {
return method->get_class();
}
const auto args = method->get_proto()->get_args()->get_type_list();
return args[param_index];
}
using register_t = ir_analyzer::register_t;
using namespace ir_analyzer;
using ParamDomain = sparta::ConstantAbstractDomain<ParamIndex>;
/**
* For each register that holds an reference to a param
* keeps track of the param index.
**/
using ParamDomainEnvironment =
sparta::PatriciaTreeMapAbstractEnvironment<register_t, ParamDomain>;
// We use this special register to denote the value that is being returned.
register_t RETURN_VALUE = RESULT_REGISTER - 1;
bool isNotHigh(ParamDomain domain) {
auto const constant = domain.get_constant();
return !constant || (((*constant) & WIDE_HIGH) == 0);
}
ParamDomain makeHigh(ParamDomain domain) {
always_assert(isNotHigh(domain));
auto const constant = domain.get_constant();
return constant ? ParamDomain((*constant) | WIDE_HIGH) : domain;
}
class Analyzer final : public BaseIRAnalyzer<ParamDomainEnvironment> {
public:
Analyzer(cfg::ControlFlowGraph& cfg,
const ReturnParamResolver& resolver,
const std::unordered_map<const DexMethod*, ParamIndex>&
methods_which_return_parameter)
: BaseIRAnalyzer(cfg),
m_resolver(resolver),
m_methods_which_return_parameter(methods_which_return_parameter),
m_load_param_map(get_load_param_map(cfg)) {
MonotonicFixpointIterator::run(ParamDomainEnvironment::top());
}
void analyze_instruction(
IRInstruction* insn,
ParamDomainEnvironment* current_state) const override {
// While the special registers RESULT_REGISTER and RETURN_VALUE do not
// participate in possible wide low and high register splitting, all
// other registers should be accessed through the following two helper
// functions to ensure that wide values are properly handled.
const auto get_current_state_at = [&](register_t reg, bool wide) {
const auto low = current_state->get(reg);
if (!wide) {
return isNotHigh(low) ? low : ParamDomain::top();
}
const auto high = current_state->get(reg + 1);
return (isNotHigh(low) && makeHigh(low) == high) ? low
: ParamDomain::top();
};
const auto set_current_state_at = [&](register_t reg, bool wide,
ParamDomain value) {
always_assert(isNotHigh(value));
current_state->set(reg, value);
if (wide) {
current_state->set(reg + 1, makeHigh(value));
}
};
const auto default_case = [&]() {
// If we get here, reset destination.
if (insn->has_dest()) {
set_current_state_at(insn->dest(), insn->dest_is_wide(),
ParamDomain::top());
} else if (insn->has_move_result_any()) {
current_state->set(RESULT_REGISTER, ParamDomain::top());
}
};
switch (insn->opcode()) {
case OPCODE_RETURN:
case OPCODE_RETURN_OBJECT:
case OPCODE_RETURN_WIDE: {
const auto value =
get_current_state_at(insn->src(0), insn->src_is_wide(0));
current_state->set(RETURN_VALUE, value);
break;
}
case OPCODE_MOVE:
case OPCODE_MOVE_OBJECT:
case OPCODE_MOVE_WIDE: {
const auto value =
get_current_state_at(insn->src(0), insn->src_is_wide(0));
set_current_state_at(insn->dest(), insn->dest_is_wide(), value);
break;
}
case IOPCODE_MOVE_RESULT_PSEUDO:
case IOPCODE_MOVE_RESULT_PSEUDO_OBJECT:
case IOPCODE_MOVE_RESULT_PSEUDO_WIDE:
case OPCODE_MOVE_RESULT:
case OPCODE_MOVE_RESULT_OBJECT:
case OPCODE_MOVE_RESULT_WIDE: {
const auto value = current_state->get(RESULT_REGISTER);
set_current_state_at(insn->dest(), insn->dest_is_wide(), value);
break;
}
case IOPCODE_LOAD_PARAM:
case IOPCODE_LOAD_PARAM_OBJECT:
case IOPCODE_LOAD_PARAM_WIDE: {
const auto param_index = m_load_param_map.at(insn);
const auto value = ParamDomain(param_index);
set_current_state_at(insn->dest(), insn->dest_is_wide(), value);
break;
}
case OPCODE_CHECK_CAST: {
// We track check cast like a move; this gives us the maximum information
// across various call chains. Only when we are about to actually patch
// the code we check whether such patching is verifiable.
const auto value =
get_current_state_at(insn->src(0), insn->src_is_wide(0));
current_state->set(RESULT_REGISTER, value);
break;
}
case OPCODE_INVOKE_DIRECT:
case OPCODE_INVOKE_VIRTUAL:
case OPCODE_INVOKE_STATIC:
case OPCODE_INVOKE_INTERFACE:
case OPCODE_INVOKE_SUPER: {
// Avoid call resolution if all srcs are top anyway.
bool all_top = true;
for (size_t i = 0; i < insn->srcs_size(); i++) {
const auto param_value =
get_current_state_at(insn->src(i), insn->src_is_wide(i));
if (!param_value.is_top()) {
all_top = false;
break;
}
}
if (all_top) {
default_case();
break;
}
// TODO(perf): call resolution is quite expensive; figure out
// beforehand if the result of this invoke instruction can ever flow
// to a return instruction; if not, skip this
const auto param_index = m_resolver.get_return_param_index(
insn, m_methods_which_return_parameter, m_resolved_refs);
if (!param_index) {
default_case();
break;
}
const auto param_value = get_current_state_at(
insn->src(*param_index), insn->src_is_wide(*param_index));
current_state->set(RESULT_REGISTER, param_value);
break;
}
default: {
default_case();
break;
}
}
}
private:
const ReturnParamResolver& m_resolver;
const std::unordered_map<const DexMethod*, ParamIndex>&
m_methods_which_return_parameter;
const std::unordered_map<const IRInstruction*, ParamIndex> m_load_param_map;
mutable MethodRefCache m_resolved_refs;
};
} // namespace
////////////////////////////////////////////////////////////////////////////////
const std::unordered_map<const IRInstruction*, ParamIndex> get_load_param_map(
cfg::ControlFlowGraph& cfg) {
std::unordered_map<const IRInstruction*, ParamIndex> map;
const auto param_insns = InstructionIterable(cfg.get_param_instructions());
ParamIndex index = 0;
for (auto it = param_insns.begin(); it != param_insns.end(); it++) {
const auto insn = it->insn;
always_assert(opcode::is_load_param(insn->opcode()));
map.insert({insn, index++});
}
return map;
}
const boost::optional<ParamIndex> ReturnParamResolver::get_return_param_index(
IRInstruction* insn,
const std::unordered_map<const DexMethod*, ParamIndex>&
methods_which_return_parameter,
MethodRefCache& resolved_refs) const {
always_assert(is_invoke(insn->opcode()));
const auto method = insn->get_method();
const auto proto = method->get_proto();
if (proto->is_void()) {
// No point in doing any further analysis
return boost::none;
}
const auto opcode = insn->opcode();
if (opcode == OPCODE_INVOKE_VIRTUAL && returns_receiver(method)) {
return 0;
}
const auto callee =
resolve_method(method, opcode_to_search(insn), resolved_refs);
if (callee == nullptr) {
return boost::none;
}
ParamDomain param = ParamDomain::bottom();
if (is_abstract(callee)) {
always_assert(opcode == OPCODE_INVOKE_VIRTUAL ||
opcode == OPCODE_INVOKE_INTERFACE);
} else {
const auto& mwrpit = methods_which_return_parameter.find(callee);
if (mwrpit == methods_which_return_parameter.end()) {
return boost::none;
}
param = ParamDomain(mwrpit->second);
}
if (opcode == OPCODE_INVOKE_VIRTUAL || opcode == OPCODE_INVOKE_INTERFACE) {
always_assert(callee->is_virtual());
// Make sure all implementations of this method have the same param index
// Why can_rename_DEPRECATED? To mirror what VirtualRenamer looks at.
if (opcode == OPCODE_INVOKE_INTERFACE &&
(root(callee) || !can_rename_DEPRECATED(callee))) {
// We cannot rule out that there are dynamically added classes, created
// via Proxy.newProxyInstance, that override this method.
// So we assume the worst.
return boost::none;
}
const auto overriding_methods =
method_override_graph::get_overriding_methods(m_graph, callee);
for (auto* overriding : overriding_methods) {
const auto& mwrpit = methods_which_return_parameter.find(overriding);
if (mwrpit == methods_which_return_parameter.end()) {
return boost::none;
}
param.join_with(ParamDomain(mwrpit->second));
if (param.is_top()) {
// Bail out early if possible; it's the common case
return boost::none;
}
}
// TODO: Are we doing something about abstract methods without any overrides
// somewhere?
always_assert(!param.is_bottom() || is_abstract(callee));
}
return param.get_constant();
}
bool ReturnParamResolver::returns_receiver(const DexMethodRef* method) const {
// Hard-coded very special knowledge about certain framework methods
DexType* cls = method->get_class();
// these framework classes implement the "Appendable" interface, with the
// formal return type being the exact class type
if (cls == m_char_buffer_type || cls == m_print_stream_type ||
cls == m_print_writer_type || cls == m_string_buffer_type ||
cls == m_string_builder_type || cls == m_string_writer_type ||
cls == m_writer_type) {
if (method->get_name() == DexString::make_string("append")) {
always_assert(method->get_proto()->get_rtype() == method->get_class());
return true;
}
}
if (cls == m_byte_buffer_type || cls == m_char_buffer_type ||
cls == m_double_buffer_type || cls == m_float_buffer_type ||
cls == m_int_buffer_type || cls == m_long_buffer_type ||
cls == m_short_buffer_type) {
auto name = method->get_name();
if (name == DexString::make_string("compact") ||
name == DexString::make_string("put")) {
always_assert(method->get_proto()->get_rtype() == method->get_class());
return true;
}
}
if (cls == m_byte_buffer_type) {
auto name = method->get_name();
if (name == DexString::make_string("putChar") ||
name == DexString::make_string("putDouble") ||
name == DexString::make_string("putFloat") ||
name == DexString::make_string("putInt") ||
name == DexString::make_string("putLong") ||
name == DexString::make_string("putShort")) {
always_assert(method->get_proto()->get_rtype() == method->get_class());
return true;
}
}
if (cls == m_print_stream_type || cls == m_print_writer_type) {
auto name = method->get_name();
if (name == DexString::make_string("format") ||
name == DexString::make_string("printf")) {
always_assert(method->get_proto()->get_rtype() == method->get_class());
return true;
}
}
if (cls == m_string_buffer_type || cls == m_string_builder_type) {
auto name = method->get_name();
if (name == DexString::make_string("appendCodePoint") ||
name == DexString::make_string("delete") ||
name == DexString::make_string("deleteCharAt") ||
name == DexString::make_string("insert") ||
name == DexString::make_string("replace") ||
name == DexString::make_string("reverse")) {
always_assert(method->get_proto()->get_rtype() == method->get_class());
return true;
}
}
if (method == m_string_to_string_method) {
return true;
}
return false;
}
const boost::optional<ParamIndex> ReturnParamResolver::get_return_param_index(
cfg::ControlFlowGraph& cfg,
const std::unordered_map<const DexMethod*, ParamIndex>&
methods_which_return_parameter) const {
Analyzer analyzer(cfg, *this, methods_which_return_parameter);
auto return_param_index = ParamDomain::bottom();
// join together return values of all blocks which end with a
// return instruction
for (const auto block : cfg.blocks()) {
const auto& last = block->get_last_insn();
if (last == block->end() || !is_return(last->insn->opcode())) {
continue;
}
const auto env = analyzer.get_exit_state_at(block);
const auto block_return_param_index = env.get(RETURN_VALUE);
return_param_index.join_with(block_return_param_index);
}
return return_param_index.get_constant();
}
void ResultPropagation::patch(PassManager& mgr, IRCode* code) {
// turn move-result-... into move instructions if the called method
// is known to always return a particular parameter
// TODO(T35815701): use cfg instead of code
std::vector<IRInstruction*> deletes;
const auto ii = InstructionIterable(code);
for (auto it = ii.begin(); it != ii.end(); it++) {
// do we have a sequence of invoke + move-result instruction?
const auto insn = it->insn;
if (!is_invoke(insn->opcode())) {
continue;
}
const auto next = std::next(it);
if (next == ii.end()) {
continue;
}
const auto peek = next->insn;
if (!opcode::is_move_result(peek->opcode())) {
continue;
}
// do we know the invoked method always returns a particular parameter?
const auto param_index = m_resolver.get_return_param_index(
insn, m_methods_which_return_parameter, m_resolved_refs);
if (!param_index) {
continue;
}
if (!mgr.get_redex_options().verify_none_enabled) {
// Let's check if replacing move-result with a move does not impact
// verifiability.
// TODO(configurability): Introduce a flag whether we care about
// verifiability.
// TODO(effectiveness): We are currently very consersative, only looking
// locally at the proto's param type. Instead, track where the register
// flowing into the invoke instruction was defined, and what its
// statically known type is.
const auto is_static = insn->opcode() == OPCODE_INVOKE_STATIC;
const auto param_type =
get_param_type(is_static, insn->get_method(), *param_index);
const auto rtype = insn->get_method()->get_proto()->get_rtype();
if (!check_cast(param_type, rtype)) {
++m_stats.unverifiable_move_results;
continue;
}
}
// rewrite instruction
const auto source_reg = insn->src(*param_index);
if (peek->dest() == source_reg) {
deletes.push_back(peek);
++m_stats.erased_move_results;
} else {
patch_move_result_to_move(peek, source_reg);
++m_stats.patched_move_results;
}
}
for (auto const instr : deletes) {
code->remove_opcode(instr);
}
}
void ResultPropagationPass::run_pass(DexStoresVector& stores,
ConfigFiles& /* conf */,
PassManager& mgr) {
const auto scope = build_class_scope(stores);
const auto method_override_graph = method_override_graph::build_graph(scope);
ReturnParamResolver resolver(*method_override_graph);
const auto methods_which_return_parameter =
find_methods_which_return_parameter(mgr, scope, resolver);
const auto stats = walk::parallel::reduce_methods<ResultPropagation::Stats>(
scope,
[&](DexMethod* m) {
const auto code = m->get_code();
if (code == nullptr) {
return ResultPropagation::Stats();
}
ResultPropagation rp(methods_which_return_parameter, resolver);
rp.patch(mgr, code);
return rp.get_stats();
},
[](ResultPropagation::Stats a, ResultPropagation::Stats b) {
a.erased_move_results += b.erased_move_results;
a.patched_move_results += b.patched_move_results;
a.unverifiable_move_results += b.unverifiable_move_results;
return a;
});
mgr.incr_metric(METRIC_METHODS_WHICH_RETURN_PARAMETER,
methods_which_return_parameter.size());
mgr.incr_metric(METRIC_ERASED_MOVE_RESULTS, stats.erased_move_results);
mgr.incr_metric(METRIC_PATCHED_MOVE_RESULTS, stats.patched_move_results);
mgr.incr_metric(METRIC_UNVERIFIABLE_MOVE_RESULTS,
stats.unverifiable_move_results);
TRACE(RP, 1,
"result propagation --- potential methods: %d, erased moves: %d, "
"patched moves: %d, "
"unverifiable moves: %d",
methods_which_return_parameter.size(), stats.erased_move_results,
stats.patched_move_results, stats.unverifiable_move_results);
}
const std::unordered_map<const DexMethod*, ParamIndex>
ResultPropagationPass::find_methods_which_return_parameter(
PassManager& mgr, const Scope& scope, const ReturnParamResolver& resolver) {
walk::parallel::code(scope, [](DexMethod* method, IRCode& code) {
const auto proto = method->get_proto();
if (!proto->is_void()) {
// void methods cannot return a parameter, skip expensive analysis
code.build_cfg(/* editable */ true);
}
});
std::unordered_map<const DexMethod*, ParamIndex>
methods_which_return_parameter;
// We iterate a few times to capture chains of method calls that all
// eventually return `this`.
// TODO(perf): Add flag to limit number of iterations
// TODO(perf): For each analyzed method, keep track of the reasons (a set of
// methods) why the call resolution gave up, and use that "dependency"
// information to limit what needs to be processed in subsequent iterations
while (true) {
mgr.incr_metric(METRIC_METHODS_WHICH_RETURN_PARAMETER_ITERATIONS, 1);
const auto next_methods_which_return_parameter =
walk::parallel::reduce_methods<
std::unordered_map<const DexMethod*, ParamIndex>>(
scope,
[&](DexMethod* method) {
std::unordered_map<const DexMethod*, ParamIndex> res;
const auto code = method->get_code();
if (code == nullptr) {
return res;
}
const auto proto = method->get_proto();
if (proto->is_void()) {
// void methods cannot return a parameter, skip expensive
// analysis
return res;
}
const auto mwrpit = methods_which_return_parameter.find(method);
if (mwrpit != methods_which_return_parameter.end()) {
// Short-circuit re-computing for perf
res.insert({method, mwrpit->second});
return res;
}
// TODO(T35815704): Make the cfg const
cfg::ControlFlowGraph& cfg = code->cfg();
const auto return_param_index = resolver.get_return_param_index(
cfg, methods_which_return_parameter);
if (return_param_index) {
res.insert({method, *return_param_index});
}
return res;
},
[](std::unordered_map<const DexMethod*, ParamIndex> a,
std::unordered_map<const DexMethod*, ParamIndex> b) {
a.insert(b.begin(), b.end());
return a;
});
if (next_methods_which_return_parameter.size() ==
methods_which_return_parameter.size()) {
walk::parallel::code(scope, [](DexMethod* method, IRCode& code) {
const auto proto = method->get_proto();
if (!proto->is_void()) {
code.clear_cfg();
}
});
return methods_which_return_parameter;
}
methods_which_return_parameter = next_methods_which_return_parameter;
}
}
static ResultPropagationPass s_pass;
| [
"facebook-github-bot@users.noreply.github.com"
] | facebook-github-bot@users.noreply.github.com |
a1bf463b4b49cb13b2584acdd5acc5fd95beac9a | 812adf695ffc4a4d6a6c7bc99a71d2f2344440cb | /src/chainparams.h | 1a56d1af11f9bc7ef75bd249a9255092a8323041 | [
"MIT"
] | permissive | wincash/Wincashcoin | aad5dad44e92e52872743690e800264ef29af7fc | 388475f047679be33849e6d15f5464007b1338c7 | refs/heads/master | 2020-07-21T07:55:12.588180 | 2020-06-10T17:43:41 | 2020-06-10T17:43:41 | 206,785,762 | 10 | 3 | null | null | null | null | UTF-8 | C++ | false | false | 12,469 | h | // Copyright (c) 2009-2010 Satoshi Nakamoto
// Copyright (c) 2009-2014 The Bitcoin developers
// Copyright (c) 2014-2015 The Dash developers
// Copyright (c) 2015-2019 The WINCASHCOIN developers
// Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
#ifndef BITCOIN_CHAINPARAMS_H
#define BITCOIN_CHAINPARAMS_H
#include "chainparamsbase.h"
#include "checkpoints.h"
#include "primitives/block.h"
#include "protocol.h"
#include "uint256.h"
#include "libzerocoin/Params.h"
#include <vector>
typedef unsigned char MessageStartChars[MESSAGE_START_SIZE];
struct CDNSSeedData {
std::string name, host;
CDNSSeedData(const std::string& strName, const std::string& strHost) : name(strName), host(strHost) {}
};
/**
* CChainParams defines various tweakable parameters of a given instance of the
* WINCASHCOIN system. There are three: the main network on which people trade goods
* and services, the public test network which gets reset from time to time and
* a regression test mode which is intended for private networks only. It has
* minimal difficulty to ensure that blocks can be found instantly.
*/
class CChainParams
{
public:
enum Base58Type {
PUBKEY_ADDRESS,
SCRIPT_ADDRESS,
SECRET_KEY, // BIP16
EXT_PUBLIC_KEY, // BIP32
EXT_SECRET_KEY, // BIP32
EXT_COIN_TYPE, // BIP44
MAX_BASE58_TYPES
};
const uint256& HashGenesisBlock() const { return hashGenesisBlock; }
const MessageStartChars& MessageStart() const { return pchMessageStart; }
const std::vector<unsigned char>& AlertKey() const { return vAlertPubKey; }
int GetDefaultPort() const { return nDefaultPort; }
const uint256& ProofOfWorkLimit() const { return bnProofOfWorkLimit; }
int SubsidyHalvingInterval() const { return nSubsidyHalvingInterval; }
/** Used to check majorities for block version upgrade */
int EnforceBlockUpgradeMajority() const { return nEnforceBlockUpgradeMajority; }
int RejectBlockOutdatedMajority() const { return nRejectBlockOutdatedMajority; }
int ToCheckBlockUpgradeMajority() const { return nToCheckBlockUpgradeMajority; }
int MaxReorganizationDepth() const { return nMaxReorganizationDepth; }
/** Used if GenerateBitcoins is called with a negative number of threads */
int DefaultMinerThreads() const { return nMinerThreads; }
const CBlock& GenesisBlock() const { return genesis; }
/** Make miner wait to have peers to avoid wasting work */
bool MiningRequiresPeers() const { return fMiningRequiresPeers; }
/** Headers first syncing is disabled */
bool HeadersFirstSyncingActive() const { return fHeadersFirstSyncingActive; };
/** Default value for -checkmempool and -checkblockindex argument */
bool DefaultConsistencyChecks() const { return fDefaultConsistencyChecks; }
/** Allow mining of a min-difficulty block */
bool AllowMinDifficultyBlocks() const { return fAllowMinDifficultyBlocks; }
/** Skip proof-of-work check: allow mining of any difficulty block */
bool SkipProofOfWorkCheck() const { return fSkipProofOfWorkCheck; }
/** Make standard checks */
bool RequireStandard() const { return fRequireStandard; }
int64_t TargetSpacing() const { return nTargetSpacing; }
/** returns the coinbase maturity **/
int COINBASE_MATURITY() const { return nMaturity; }
/** returns the coinstake maturity (min depth required) **/
int COINSTAKE_MIN_DEPTH() const { return nStakeMinDepth; }
bool HasStakeMinAgeOrDepth(const int contextHeight, const uint32_t contextTime, const int utxoFromBlockHeight, const uint32_t utxoFromBlockTime) const;
/** returns the max future time (and drift in seconds) allowed for a block in the future **/
int FutureBlockTimeDrift(const bool isPoS) const { return isPoS ? nFutureTimeDriftPoS : nFutureTimeDriftPoW; }
uint32_t MaxFutureBlockTime(uint32_t time, const bool isPoS) const { return time + FutureBlockTimeDrift(isPoS); }
CAmount MaxMoneyOut() const { return nMaxMoneyOut; }
/** The masternode count that we will allow the see-saw reward payments to be off by */
int MasternodeCountDrift() const { return nMasternodeCountDrift; }
/** Make miner stop after a block is found. In RPC, don't return until nGenProcLimit blocks are generated */
bool MineBlocksOnDemand() const { return fMineBlocksOnDemand; }
/** In the future use NetworkIDString() for RPC fields */
bool TestnetToBeDeprecatedFieldRPC() const { return fTestnetToBeDeprecatedFieldRPC; }
/** Return the BIP70 network string (main, test or regtest) */
std::string NetworkIDString() const { return strNetworkID; }
const std::vector<CDNSSeedData>& DNSSeeds() const { return vSeeds; }
const std::vector<unsigned char>& Base58Prefix(Base58Type type) const { return base58Prefixes[type]; }
const std::vector<CAddress>& FixedSeeds() const { return vFixedSeeds; }
virtual const Checkpoints::CCheckpointData& Checkpoints() const = 0;
int PoolMaxTransactions() const { return nPoolMaxTransactions; }
bool ZeroCoinEnabled() const { return fZeroCoinEnabled; }
/** Return the number of blocks in a budget cycle */
int GetBudgetCycleBlocks() const { return nBudgetCycleBlocks; }
int64_t GetProposalEstablishmentTime() const { return nProposalEstablishmentTime; }
/** Spork key and Masternode Handling **/
std::string SporkKey() const { return strSporkKey; }
std::string SporkKeyOld() const { return strSporkKeyOld; }
int64_t NewSporkStart() const { return nEnforceNewSporkKey; }
int64_t RejectOldSporkKey() const { return nRejectOldSporkKey; }
std::string ObfuscationPoolDummyAddress() const { return strObfuscationPoolDummyAddress; }
int64_t StartMasternodePayments() const { return nStartMasternodePayments; }
int64_t Budget_Fee_Confirmations() const { return nBudget_Fee_Confirmations; }
bool fZeroCoinEnabled;
CBaseChainParams::Network NetworkID() const { return networkID; }
/** Zerocoin **/
std::string Zerocoin_Modulus() const { return zerocoinModulus; }
libzerocoin::ZerocoinParams* Zerocoin_Params(bool useModulusV1) const;
int Zerocoin_MaxSpendsPerTransaction() const { return nMaxZerocoinSpendsPerTransaction; }
int Zerocoin_MaxPublicSpendsPerTransaction() const { return nMaxZerocoinPublicSpendsPerTransaction; }
CAmount Zerocoin_MintFee() const { return nMinZerocoinMintFee; }
int Zerocoin_MintRequiredConfirmations() const { return nMintRequiredConfirmations; }
int Zerocoin_RequiredAccumulation() const { return nRequiredAccumulation; }
int Zerocoin_DefaultSpendSecurity() const { return nDefaultSecurityLevel; }
int Zerocoin_HeaderVersion() const { return nZerocoinHeaderVersion; }
int Zerocoin_RequiredStakeDepth() const { return nZerocoinRequiredStakeDepth; }
/** Height or Time Based Activations **/
int ModifierUpgradeBlock() const { return nModifierUpdateBlock; }
int LAST_POW_BLOCK() const { return nLastPOWBlock; }
int WincashCoinBadBlockTime() const { return nWincashCoinBadBlockTime; }
int WincashCoinBadBlocknBits() const { return nWincashCoinBadBlocknBits; }
int Zerocoin_StartHeight() const { return nZerocoinStartHeight; }
int Zerocoin_Block_EnforceSerialRange() const { return nBlockEnforceSerialRange; }
int Zerocoin_Block_RecalculateAccumulators() const { return nBlockRecalculateAccumulators; }
int Zerocoin_Block_FirstFraudulent() const { return nBlockFirstFraudulent; }
int Zerocoin_Block_LastGoodCheckpoint() const { return nBlockLastGoodCheckpoint; }
int Zerocoin_StartTime() const { return nZerocoinStartTime; }
int Block_Enforce_Invalid() const { return nBlockEnforceInvalidUTXO; }
int Zerocoin_Block_V2_Start() const { return nBlockZerocoinV2; }
bool IsStakeModifierV2(const int nHeight) const { return nHeight >= nBlockStakeModifierlV2; }
// fake serial attack
int Zerocoin_Block_EndFakeSerial() const { return nFakeSerialBlockheightEnd; }
CAmount GetSupplyBeforeFakeSerial() const { return nSupplyBeforeFakeSerial; }
int Zerocoin_Block_Double_Accumulated() const { return nBlockDoubleAccumulated; }
CAmount InvalidAmountFiltered() const { return nInvalidAmountFiltered; };
int Zerocoin_Block_Public_Spend_Enabled() const { return nPublicZCSpends; }
protected:
CChainParams() {}
uint256 hashGenesisBlock;
MessageStartChars pchMessageStart;
//! Raw pub key bytes for the broadcast alert signing key.
std::vector<unsigned char> vAlertPubKey;
int nDefaultPort;
uint256 bnProofOfWorkLimit;
int nMaxReorganizationDepth;
int nSubsidyHalvingInterval;
int nEnforceBlockUpgradeMajority;
int nRejectBlockOutdatedMajority;
int nToCheckBlockUpgradeMajority;
int64_t nTargetSpacing;
int nLastPOWBlock;
int64_t nWincashCoinBadBlockTime;
unsigned int nWincashCoinBadBlocknBits;
int nMasternodeCountDrift;
int nMaturity;
int nStakeMinDepth;
int nFutureTimeDriftPoW;
int nFutureTimeDriftPoS;
int nModifierUpdateBlock;
CAmount nMaxMoneyOut;
int nMinerThreads;
std::vector<CDNSSeedData> vSeeds;
std::vector<unsigned char> base58Prefixes[MAX_BASE58_TYPES];
CBaseChainParams::Network networkID;
std::string strNetworkID;
CBlock genesis;
std::vector<CAddress> vFixedSeeds;
bool fMiningRequiresPeers;
bool fAllowMinDifficultyBlocks;
bool fDefaultConsistencyChecks;
bool fRequireStandard;
bool fMineBlocksOnDemand;
bool fSkipProofOfWorkCheck;
bool fTestnetToBeDeprecatedFieldRPC;
bool fHeadersFirstSyncingActive;
int nPoolMaxTransactions;
int nBudgetCycleBlocks;
std::string strSporkKey;
std::string strSporkKeyOld;
int64_t nEnforceNewSporkKey;
int64_t nRejectOldSporkKey;
std::string strObfuscationPoolDummyAddress;
int64_t nStartMasternodePayments;
std::string zerocoinModulus;
int nMaxZerocoinSpendsPerTransaction;
int nMaxZerocoinPublicSpendsPerTransaction;
CAmount nMinZerocoinMintFee;
CAmount nInvalidAmountFiltered;
int nMintRequiredConfirmations;
int nRequiredAccumulation;
int nDefaultSecurityLevel;
int nZerocoinHeaderVersion;
int64_t nBudget_Fee_Confirmations;
int nZerocoinStartHeight;
int nZerocoinStartTime;
int nZerocoinRequiredStakeDepth;
int64_t nProposalEstablishmentTime;
int nBlockEnforceSerialRange;
int nBlockRecalculateAccumulators;
int nBlockFirstFraudulent;
int nBlockLastGoodCheckpoint;
int nBlockEnforceInvalidUTXO;
int nBlockZerocoinV2;
int nBlockDoubleAccumulated;
int nPublicZCSpends;
int nBlockStakeModifierlV2;
// fake serial attack
int nFakeSerialBlockheightEnd = 0;
CAmount nSupplyBeforeFakeSerial = 0;
};
/**
* Modifiable parameters interface is used by test cases to adapt the parameters in order
* to test specific features more easily. Test cases should always restore the previous
* values after finalization.
*/
class CModifiableParams
{
public:
//! Published setters to allow changing values in unit test cases
virtual void setSubsidyHalvingInterval(int anSubsidyHalvingInterval) = 0;
virtual void setEnforceBlockUpgradeMajority(int anEnforceBlockUpgradeMajority) = 0;
virtual void setRejectBlockOutdatedMajority(int anRejectBlockOutdatedMajority) = 0;
virtual void setToCheckBlockUpgradeMajority(int anToCheckBlockUpgradeMajority) = 0;
virtual void setDefaultConsistencyChecks(bool aDefaultConsistencyChecks) = 0;
virtual void setAllowMinDifficultyBlocks(bool aAllowMinDifficultyBlocks) = 0;
virtual void setSkipProofOfWorkCheck(bool aSkipProofOfWorkCheck) = 0;
};
/**
* Return the currently selected parameters. This won't change after app startup
* outside of the unit tests.
*/
const CChainParams& Params();
/** Return parameters for the given network. */
CChainParams& Params(CBaseChainParams::Network network);
/** Get modifiable network parameters (UNITTEST only) */
CModifiableParams* ModifiableParams();
/** Sets the params returned by Params() to those for the given network. */
void SelectParams(CBaseChainParams::Network network);
/**
* Looks for -regtest or -testnet and then calls SelectParams as appropriate.
* Returns false if an invalid combination is given.
*/
bool SelectParamsFromCommandLine();
#endif // BITCOIN_CHAINPARAMS_H
| [
"52337058+wincash@users.noreply.github.com"
] | 52337058+wincash@users.noreply.github.com |
9b5d407aa19be4c5cc4d00fb1a95cd5e57dad413 | f9960bc0ce63c7373e28921bf9875daf99bcf740 | /DesignPattern/DesignPattern/Iterator/DinerMenu.h | 0a9dc519554b2b7bb12e16a90aca72ddc570a061 | [] | no_license | dangdang1250/LearnCPP | 5bd0ce6cb5121194475b824570edb13a3de1d141 | c9a7994dd688439c4debe57ebc80fa5b01014570 | refs/heads/master | 2021-06-23T17:41:02.107892 | 2021-01-25T15:21:50 | 2021-01-25T15:21:50 | 176,996,845 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 235 | h | #pragma once
// Different aproach
#include "MenuItem.h"
#include <array>
#include <string>
class DinerMenu
{
public:
static const int MAX_ITEMS = 6;
private:
int numberOfItems = 0;
std::array<MenuItem, MAX_ITEMS> m_MenuItems;
};
| [
"jcheng6@ra.rockwell.com"
] | jcheng6@ra.rockwell.com |
3d760f396f4d99381ac37552c70c3ab2ce7c50db | 34f3488ec4f0755286fbbca18dcbf9d23d45e405 | /AnimaEngine/AnimaFreeListAllocator.h | 5d242e583c678d4235cad849e2931afca4637eac | [] | no_license | zillemarco/Anima_Old | 3b7a558e15f5f11642c515c4b71114f42b98b6b4 | 910dc6c389bd8f34923d6530cd35d14bc7e8f8b1 | refs/heads/master | 2020-12-13T19:13:30.230363 | 2016-02-20T13:13:59 | 2016-02-20T13:13:59 | 25,968,811 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,635 | h | //
// AnimaFreeListAllocator.h
// Anima
//
// Created by Marco Zille on 16/11/14.
//
//
#ifndef __Anima__AnimaFreeListAllocator__
#define __Anima__AnimaFreeListAllocator__
#include "AnimaEngineCore.h"
#include "AnimaTypes.h"
#include "AnimaAllocator.h"
BEGIN_ANIMA_ENGINE_NAMESPACE
class ANIMA_ENGINE_EXPORT AnimaFreeListAllocator : public AnimaAllocator
{
public:
AnimaFreeListAllocator(ASizeT size, void* start);
~AnimaFreeListAllocator();
void* Allocate(ASizeT size, AU8 alignment) override;
void Deallocate(void* p) override;
private:
struct AnimaFreeListAllocationHeader
{
ASizeT size;
AU8 adjustment;
};
struct AnimaFreeListAllocatorFreeBlock
{
ASizeT size;
AnimaFreeListAllocatorFreeBlock* next;
};
AnimaFreeListAllocator(const AnimaFreeListAllocator&); //Prevent copies because it might cause errors
AnimaFreeListAllocator& operator=(const AnimaFreeListAllocator&);
AnimaFreeListAllocatorFreeBlock* _freeBlocks;
};
BEGIN_ANIMA_ALLOCATOR_NAMESPACE
{
inline AnimaFreeListAllocator* NewAnimaFreeListAllocator(ASizeT size, AnimaAllocator& allocator)
{
void* p = allocator.Allocate(size + sizeof(AnimaFreeListAllocator), ANIMA_ENGINE_ALIGN_OF(AnimaFreeListAllocator));
return new (p) AnimaFreeListAllocator(size, AnimaPointerMath::add(p, sizeof(AnimaFreeListAllocator)));
}
inline void DeleteAnimaFreeListAllocator(AnimaFreeListAllocator& freeListAllocator, AnimaAllocator& allocator)
{
freeListAllocator.~AnimaFreeListAllocator();
allocator.Deallocate(&freeListAllocator);
}
}
END_ANIMA_ENGINE_NAMESPACE
#endif /* defined(__Anima__AnimaFreeListAllocator__) */
| [
"marco.zille@gmail.com"
] | marco.zille@gmail.com |
77ef9895a53dc62a57bf2989e18f8d4dfb9fdfc8 | 656398653ff60467d3b8b36e039d71ade1884e55 | /Classes/Screens/Popups/UnlockLevel.h | 82e7ee0038f2646349cb7b42e6bd9203192e160f | [] | no_license | imclab/project-birds | 920a6bd48a1fced99340099f0ffba91c099f21f5 | 5fc0faeb25e43b8fa981a377f826f942d1f1d7f6 | refs/heads/master | 2020-05-29T12:30:47.956564 | 2014-01-30T16:23:42 | 2014-01-30T16:23:49 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,701 | h | #ifndef CONST_UNLOCKLEVEL_H
#define CONST_UNLOCKLEVEL_H
#include "Popup.h"
class UnlockLevel : public Popup
{
protected:
// ===========================================================
// Inner Classes
// ===========================================================
// ===========================================================
// Constants
// ===========================================================
// ===========================================================
// Fields
// ===========================================================
Entity* mKey;
Button* mUnlockButton;
Text* mPriceText;
EntityManager* mLights;
bool action;
// ===========================================================
// Constructors
// ===========================================================
UnlockLevel(CCNode* pParent);
// ===========================================================
// Methods
// ===========================================================
// ===========================================================
// Override Methods
// ===========================================================
private:
// ===========================================================
// Inner Classes
// ===========================================================
// ===========================================================
// Constants
// ===========================================================
// ===========================================================
// Fields
// ===========================================================
// ===========================================================
// Constructors
// ===========================================================
// ===========================================================
// Methods
// ===========================================================
// ===========================================================
// Override Methods
// ===========================================================
public:
// ===========================================================
// Inner Classes
// ===========================================================
// ===========================================================
// Constants
// ===========================================================
// ===========================================================
// Fields
// ===========================================================
// ===========================================================
// Constructors
// ===========================================================
static UnlockLevel* create(CCNode* pParent);
~UnlockLevel();
// ===========================================================
// Methods
// ===========================================================
// ===========================================================
// Override Methods
// ===========================================================
virtual void update(float pDeltaTime);
virtual void hide();
virtual void show();
virtual void onShow();
virtual void onHide();
void onTouchButtonsCallback(const int pAction, const int pID);
};
#endif | [
"igor.mats@yandex.ru"
] | igor.mats@yandex.ru |
53a4c833f7365e37dab43e4f78823413e3002a29 | 89f0311995963140963bfd91445ec94b0d847e82 | /04_Code-Organisation-Templates/03. Parser/PrintUtils.h | dc9879749c655dbbf1910214f4ac0fcf8017bea4 | [] | no_license | PlVasilev/C-Plus-Plus | bbe213883295462d012e91a1326711aadd7136f1 | 000e9bc3462dcade76c61803ec7f34eff18e3e14 | refs/heads/main | 2023-04-17T13:09:06.744109 | 2021-04-24T07:52:12 | 2021-04-24T07:52:12 | 347,322,798 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 328 | h |
#ifndef CPP_ADVANCED_PRINTUTILS_H
#define CPP_ADVANCED_PRINTUTILS_H
#include <iostream>
#include <sstream>
#include <vector>
template<typename T>
void printVector(std::vector<T> container) {
for (auto& i : container) {
std::cout << i << " ";
}
std::cout << std::endl;
}
#endif //CPP_ADVANCED_PRINTUTILS_H | [
"pvvasilev2013@gmail.com"
] | pvvasilev2013@gmail.com |
d4e8b6dac991b759ce6efbbff1ad706ef26a765a | f6fca6c43ad746c45c8321541178eb02e2cb555e | /2c/level0/Prof-UI/Include/extcmdmanager.h | ffff1f68443d5c085395d091706db33a08838338 | [] | no_license | Asakra/alterplast | da271c590b32767953f09266fed1569831aa78cb | 682e1c2d2f4246183e9b8284d8cf2dbc14f6e228 | refs/heads/master | 2023-06-22T04:16:34.924155 | 2021-07-16T06:20:20 | 2021-07-16T06:20:20 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 21,721 | h | // This is part of the Professional User Interface Suite library.
// Copyright (C) 2001-2003 FOSS Software, Inc.
// All rights reserved.
//
// http://www.prof-uis.com
// http://www.fossware.com
// mailto:foss@fossware.com
//
// This source code can be used, modified and redistributed
// under the terms of the license agreement that is included
// in the Professional User Interface Suite package.
//
// Warranties and Disclaimers:
// THIS SOFTWARE IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND
// INCLUDING, BUT NOT LIMITED TO, WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
// IN NO EVENT WILL FOSS SOFTWARE INC. BE LIABLE FOR ANY DIRECT,
// INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES,
// INCLUDING DAMAGES FOR LOSS OF PROFITS, LOSS OR INACCURACY OF DATA,
// INCURRED BY ANY PERSON FROM SUCH PERSON'S USAGE OF THIS SOFTWARE
// EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
#if (!defined __ExtCmdManager_H)
#define __ExtCmdManager_H
#if (!defined __EXT_MFC_DEF_H)
#include <ExtMfcDef.h>
#endif // __EXT_MFC_DEF_H
#if (!defined __EXT_CMD_ICON_H)
#include <ExtCmdIcon.h>
#endif
#if (!defined __AFXMT_H__)
#include <AfxMt.h>
#endif
#if (!defined __AFXTEMPL_H__)
#include <AfxTempl.h>
#endif
// max text size
#define __MAX_UI_ITEM_TEXT (1024)
// mdi menu list commands
#define __ID_MDIWNDLIST_COUNT 9
#define __ID_MDIWNDLIST_FIRST AFX_IDM_FIRST_MDICHILD
#define __ID_MDIWNDLIST_LAST (__ID_MDIWNDLIST_FIRST+__ID_MDIWNDLIST_COUNT-1)
#define __ID_MDIWND_DLGWINDOWS (__ID_MDIWNDLIST_LAST+1)
#define __MFCEXT_DEF_RARELY_USED_PERCENT 10
class CExtCmdIcon;
class CExtCmdItem;
class CExtCmdItemUI;
class CExtCmdProfile;
class CExtCmdManager;
/////////////////////////////////////////////////////////////////////////////
// CExtCmdItem
// command item class
class __PROF_UIS_API CExtCmdItem
{
public:
enum e_state_t // state flags
{
STATE_ENABLED = 0x00000000,
STATE_DISABLED = 0x00000001,
STATE_CHECK = 0x00000002,
STATE_RADIO = 0x00000004,
STATE_INDETERMINATE = 0x00000008,
STATE_BASICCMDPROP = 0x00000010,
STATE_FORCE_RARELY = 0x00000020,
STATE_MENUBAR_TMP = 0x00000040,
STATE_CUSTOM_TOOLBAR = 0x00000080,
STATE_DYNAMIC_POPUP = 0x00000100,
STATE_PERSISTENT_ICON = 0x00000200,
STATE_USER_DEFINDED_21 = 0x00000400,
STATE_USER_DEFINDED_20 = 0x00000800,
STATE_USER_DEFINDED_19 = 0x00001000,
STATE_USER_DEFINDED_18 = 0x00002000,
STATE_USER_DEFINDED_17 = 0x00004000,
STATE_USER_DEFINDED_16 = 0x00008000,
STATE_USER_DEFINDED_15 = 0x00010000,
STATE_USER_DEFINDED_14 = 0x00020000,
STATE_USER_DEFINDED_13 = 0x00040000,
STATE_USER_DEFINDED_12 = 0x00080000,
STATE_USER_DEFINDED_11 = 0x00100000,
STATE_USER_DEFINDED_10 = 0x00200000,
STATE_USER_DEFINDED_09 = 0x00400000,
STATE_USER_DEFINDED_08 = 0x00800000,
STATE_USER_DEFINDED_07 = 0x01000000,
STATE_USER_DEFINDED_06 = 0x02000000,
STATE_USER_DEFINDED_05 = 0x04000000,
STATE_USER_DEFINDED_04 = 0x08000000,
STATE_USER_DEFINDED_03 = 0x10000000,
STATE_USER_DEFINDED_02 = 0x20000000,
STATE_USER_DEFINDED_01 = 0x40000000,
STATE_USER_DEFINDED_00 = 0x80000000,
}; // enum e_state_t
CExtCmdProfile * m_pProfile;
UINT m_nCmdID;
int m_nIconIdx;
DWORD m_dwStateFlags;
CString
m_sMenuText,m_sToolbarText,
m_sTipTool,m_sTipStatus,
m_sAccelText
;
LPARAM m_nLParamUserData;
protected:
UINT m_nUsageTickCount;
virtual void AssignFromOther( const CExtCmdItem & other );
virtual void ReplaceFromOtherNonEmpty( const CExtCmdItem & other );
virtual void AnalyzeGlobalUsageOverflow();
public:
// construction/destruction/assignment
CExtCmdItem(
UINT nCmdID = IDC_STATIC
);
CExtCmdItem( const CExtCmdItem & other );
virtual ~CExtCmdItem();
CExtCmdItem & operator=( const CExtCmdItem & other );
//clean tips
virtual void TipsClean();
// load tips
virtual bool TipsLoad();
// upload more full parameters from other
virtual void UpdateMoreExact( const CExtCmdItem & other );
// state retrieve/update
virtual void StateSetBasic( bool bOn = true )
{
if( bOn )
m_dwStateFlags |= STATE_BASICCMDPROP;
else
m_dwStateFlags &= ~STATE_BASICCMDPROP;
}
virtual bool StateIsBasic() const;
virtual bool StateIsRarelyUsed() const;
virtual void StateForceRarely( bool bOn = true )
{
if( bOn )
m_dwStateFlags |= STATE_FORCE_RARELY;
else
m_dwStateFlags &= ~STATE_FORCE_RARELY;
}
virtual bool StateIsForceRarely() const;
virtual void StateEnable( bool bOn = true )
{
if( bOn )
m_dwStateFlags &= ~STATE_DISABLED;
else
m_dwStateFlags |= STATE_DISABLED;
}
virtual bool StateIsEnable() const
{
bool bOn =
(m_dwStateFlags&STATE_DISABLED)
? false : true;
return bOn;
}
virtual void StateSetCheck( bool bOn = true )
{
m_dwStateFlags &=
~(STATE_RADIO|STATE_CHECK|STATE_INDETERMINATE);
if( bOn )
m_dwStateFlags |= STATE_CHECK;
}
virtual bool StateGetCheck() const
{
bool bOn =
(m_dwStateFlags&STATE_CHECK)
? true : false;
return bOn;
}
virtual void StateSetRadio( bool bOn = true )
{
m_dwStateFlags &=
~(STATE_RADIO|STATE_CHECK|STATE_INDETERMINATE);
if( bOn )
m_dwStateFlags |= STATE_RADIO;
}
virtual bool StateGetRadio() const
{
bool bOn =
(m_dwStateFlags&STATE_RADIO)
? true : false;
return bOn;
}
virtual void StateSetIndeterminate( bool bOn = true )
{
m_dwStateFlags &=
~(STATE_RADIO|STATE_CHECK|STATE_INDETERMINATE);
if( bOn )
m_dwStateFlags |= STATE_INDETERMINATE;
}
virtual bool StateGetIndeterminate() const
{
bool bIndeterminate =
(m_dwStateFlags&STATE_INDETERMINATE)
? true : false;
return bIndeterminate;
}
virtual void StateSetMenubarTemp( bool bOn = true )
{
m_dwStateFlags &= ~(STATE_MENUBAR_TMP);
if( bOn )
m_dwStateFlags |= STATE_MENUBAR_TMP;
}
virtual bool StateIsMenubarTemp() const
{
bool bOn =
(m_dwStateFlags&STATE_MENUBAR_TMP)
? true : false;
return bOn;
}
virtual void StateSetCustomToolbar( bool bOn = true )
{
m_dwStateFlags &= ~(STATE_CUSTOM_TOOLBAR);
if( bOn )
m_dwStateFlags |= STATE_CUSTOM_TOOLBAR;
}
virtual bool StateIsCustomToolbar() const
{
bool bOn =
(m_dwStateFlags&STATE_CUSTOM_TOOLBAR)
? true : false;
return bOn;
}
virtual void StateSetDynamicPopup( bool bOn = true )
{
m_dwStateFlags &= ~(STATE_DYNAMIC_POPUP);
if( bOn )
m_dwStateFlags |= STATE_DYNAMIC_POPUP;
}
virtual bool StateIsDynamicPopup() const
{
bool bOn =
(m_dwStateFlags&STATE_DYNAMIC_POPUP)
? true : false;
return bOn;
}
virtual void StateSetPersistentIcon( bool bOn = true )
{
m_dwStateFlags &= ~(STATE_PERSISTENT_ICON);
if( bOn )
m_dwStateFlags |= STATE_PERSISTENT_ICON;
}
virtual bool StateIsPersistentIcon() const
{
bool bOn =
(m_dwStateFlags&STATE_PERSISTENT_ICON)
? true : false;
return bOn;
}
// update command UI
virtual bool DoUpdateCmdUI(
CCmdTarget * pCmdTarget,
UINT nIndex = 0
);
// deliver to window
virtual bool Deliver(
HWND hWndCmdTarget,
bool bSend = false
);
virtual bool Deliver(
CWnd * pWndCmdTarget,
bool bSend = false
);
virtual bool Deliver(
CControlBar * pWndCmdSource,
bool bSend = false
);
// usage statistics
virtual UINT GetUsageTickCount() const;
virtual UINT GetUsagePercent() const;
virtual void IncrementUsageCount();
virtual UINT GetProfileTickCount() const;
virtual UINT GetProfileRarelyPercent() const;
virtual void SetProfileRarelyPercent(
UINT nRarelyPercent
);
virtual void OnSysColorChange();
virtual void OnSettingChange(
UINT uFlags,
LPCTSTR lpszSection
);
virtual void OnDisplayChange(
INT nDepthBPP,
CPoint ptSizes
);
virtual void OnThemeChanged(
WPARAM wParam,
LPARAM lParam
);
// get the text for toolbars list box in a customize form
virtual CString OnGetToolBarCustomizeName();
// get the command name for display in
// the customize from's category command list
virtual CString OnGetCustomizeScriptName();
protected:
virtual bool OnQueryStateSerializationNecessity() const;
friend class CExtCmdManager;
friend class CExtCmdProfile;
}; // class CExtCmdItem
/////////////////////////////////////////////////////////////////////////////
// CExtCmdItemUI
// command UI update class
class __PROF_UIS_API CExtCmdItemUI : public CCmdUI
{
CExtCmdItem * m_pCmd;
public:
CExtCmdItemUI(
CExtCmdItem * pCmd,
int nIndexMax = 0
);
// operations to do in ON_UPDATE_COMMAND_UI
virtual void Enable(
BOOL bOn = TRUE
);
virtual void SetCheck(
int nCheck = 1 // 0, 1 or 2 (indeterminate)
);
virtual void SetRadio(
BOOL bOn = TRUE
);
virtual void SetText(
LPCTSTR lpszText
);
}; // class CExtCmdItemUI
/////////////////////////////////////////////////////////////////////////////
// CExtCmdProfile
// command profile class
class __PROF_UIS_API CExtCmdProfile
{
public:
typedef struct tag_MFC_TOOLBAR_RESOURCE_DATA
{
WORD wVersion;
WORD wWidth;
WORD wHeight;
WORD wItemCount;
WORD * items()
{
ASSERT( this != NULL );
return (LPWORD)( this + 1 );
}
} MFC_TOOLBAR_RESOURCE_DATA, * LP_MFC_TOOLBAR_RESOURCE_DATA;
class __PROF_UIS_API MFC_TOOLBAR_LOADER
{
LPUINT m_pCommands, m_pButtons;
INT m_nCountCommands, m_nCountButtons;
COLORREF m_clrBmpTransparent;
CBitmap m_bmp;
CSize m_sizeButton;
WORD m_nVersion;
public:
MFC_TOOLBAR_LOADER(
HINSTANCE hInstResourceCommands,
HRSRC hRsrcCommands,
HINSTANCE hInstResourceBitmap,
HRSRC hRsrcCommandsBitmap,
COLORREF clrBmpTransparent = RGB(192,192,192)
);
~MFC_TOOLBAR_LOADER();
WORD GetVersion() const;
INT IsEmpty() const;
INT GetCommandCount() const;
INT GetButtonCount() const;
COLORREF GetTransparentColor() const;
UINT GetCommandIdAt( INT nCommandIdx ) const;
UINT GetButtonIdAt( INT nButtonIdx ) const;
UINT ExtractButtonData(
INT nButtonIdx,
CExtCmdIcon & icon
) const;
void GetCmdArray(
LPUINT * ppCmdArray,
LPINT pCmdCount = NULL
) const;
}; // class MFC_TOOLBAR_LOADER
CString m_sName;
UINT m_nRarelyPercent; // values 0..100
UINT m_nTotalTickCount;
typedef
CMap < UINT, UINT, CExtCmdItem *, CExtCmdItem * >
cmd_container_t;
typedef
CArray < CExtCmdIcon *, CExtCmdIcon * >
icon_container_t;
cmd_container_t m_cmds;
icon_container_t m_icons;
LPARAM m_nLParamUserData;
CExtCmdProfile(
LPCTSTR sName = NULL
);
CExtCmdProfile(
const CExtCmdProfile & other
);
virtual ~CExtCmdProfile();
CExtCmdProfile & operator=(
const CExtCmdProfile & other
);
// setup single command
virtual bool CmdSetup(
const CExtCmdItem & _cmd,
bool bReplaceOld = false, // but force set images anywhere if was empty
bool * pbWasAddedNew = NULL
);
// remove single command
virtual bool CmdRemove(
UINT nCmdID,
bool * pbWasRemoved = NULL
);
// remove all commands by state mask
virtual void CmdRemoveByMask(
DWORD dwMask,
bool bAllBitsOnly = false
);
// alloc command
virtual CExtCmdItem * CmdAllocPtr(
UINT nCmdID = 0 // 0 means any free in avail range
);
// get command
virtual CExtCmdItem * CmdGetPtr(
UINT nCmdID
);
// assign icon to command
virtual bool CmdSetIcon(
UINT nCmdID,
HICON hIcon, // if NULL - remove
bool bCopyIcon = true
);
// get command icon (if command and its icon exist)
virtual CExtCmdIcon * CmdGetIconPtr(
UINT nCmdID
);
// is command registered
virtual bool CmdIsRegistered(
UINT nCmdID
);
// update commands collection from menu handle
virtual bool UpdateFromMenu(
HMENU hMenu,
bool bReplaceOld = false,
bool bRecursive = true,
bool bLoadTips = true
);
// update commands collection from menu resurce
virtual bool UpdateFromMenu(
UINT nResourceID,
bool bReplaceOld = false,
bool bLoadTips = true
);
// update commands collection from toolbar wnd
virtual bool UpdateFromToolBar(
CToolBar & bar,
bool bReplaceOld = false, // but force set images anywhere if was empty
bool bLoadTips = true
);
// update commands collection from toolbar resource
virtual bool UpdateFromToolBar(
LPCTSTR strResourceID,
LPUINT * ppCmdArray = NULL,
LPINT pCmdCount = NULL,
bool bReplaceOld = false, // but force set images anywhere if was empty
bool bLoadTips = true,
COLORREF clrBmpTransparent = RGB(192,192,192)
);
// set list of commands (up to (UINT)0) as basic or non basic
virtual bool SetBasicCommands(
UINT * pCommands,
bool bOn = true
);
// save/load command manager state
virtual bool SerializeState(
LPCTSTR sSectionNameCompany, // under HKEY_CURRENT_USER\Software
LPCTSTR sSectionNameProduct, // under HKEY_CURRENT_USER\Software\%sSectionNameCompany%
bool bSave
);
virtual bool SerializeState(
CArchive & ar
);
virtual void OnSysColorChange();
virtual void OnSettingChange(
UINT uFlags,
LPCTSTR lpszSection
);
virtual void OnDisplayChange(
INT nDepthBPP,
CPoint ptSizes
);
virtual void OnThemeChanged(
WPARAM wParam,
LPARAM lParam
);
protected:
virtual void AssignFromOther(
const CExtCmdProfile & other
);
void _RemoveAllCmdsImpl();
void _RemoveAllIconsImpl();
virtual CExtCmdItem * OnCreateCmdItem( const CExtCmdItem & _cmd );
}; // class CExtCmdProfile
/////////////////////////////////////////////////////////////////////////////
// CExtCmdManager
// command manager class
class __PROF_UIS_API CExtCmdManager
{
public:
// for compatibility with old versions
typedef CExtCmdIcon icon_t;
typedef CExtCmdItem cmd_t;
typedef CExtCmdItemUI cmd_ui_t;
typedef CExtCmdProfile cmd_profile_t;
static inline bool IsCommand(UINT nCmdID)
{
//if( ((INT)nCmdID) <= 0 )
if( nCmdID == 0
|| ((INT)nCmdID) <= ((INT)(-1))
)
return false;
return true;
}
static inline bool IsSystemCommand( UINT nCmd )
{
bool bSystemCommand =
(nCmd >= 0xF000 && nCmd < 0xF1F0) ?
true : false;
return bSystemCommand;
}
static inline bool IsAfxOleCommand( UINT nCmd )
{
if( ID_OLE_VERB_FIRST <= nCmd
&& nCmd <= ID_OLE_VERB_LAST
)
return true;
return false;
}
static inline bool IsAfxMdiWindowsCommand( UINT nCmd )
{
if( ( __ID_MDIWNDLIST_FIRST <= nCmd
&& nCmd <= __ID_MDIWNDLIST_LAST )
|| nCmd == __ID_MDIWND_DLGWINDOWS
)
return true;
return false;
}
static inline bool IsAfxFileMruCommand( UINT nCmd )
{
if( ID_FILE_MRU_FIRST <= nCmd
&& nCmd <= ID_FILE_MRU_LAST
)
return true;
return false;
}
static inline bool IsForceBasicCommand( UINT nCmd )
{
if( IsAfxMdiWindowsCommand( nCmd )
|| IsAfxFileMruCommand( nCmd )
|| IsSystemCommand( nCmd )
|| IsAfxOleCommand( nCmd )
)
return true;
return false;
}
static inline bool IsForceRarelyCommand( UINT nCmd )
{
nCmd;
return false;
}
static inline bool IsCommandNeedsSpecUpdate( UINT nCmd )
{
if( IsSystemCommand( nCmd )
|| IsAfxMdiWindowsCommand( nCmd )
)
return true;
return false;
}
static bool g_bDisableCmdIfNoHandler;
private:
typedef
CMapStringToPtr
profile_container_t;
profile_container_t m_profiles;
typedef
CMap< HWND, HWND, CExtCmdProfile *, CExtCmdProfile *& >
profile_wnd_container_t;
profile_wnd_container_t m_profile_wnds;
void _RemoveAllProfilesImpl()
{
POSITION pos = m_profiles.GetStartPosition();
for( ; pos != NULL; )
{
CString sProfileName;
CExtCmdProfile * pProfile = NULL;
m_profiles.GetNextAssoc( pos, sProfileName, (void *&)pProfile );
ASSERT( pProfile != NULL );
delete pProfile;
} // for( ; pos != NULL; )
m_profiles.RemoveAll();
m_profile_wnds.RemoveAll();
}
CCriticalSection m_cs;
public:
// global auto-pointer class for CExtCmdManager
class __PROF_UIS_API CExtCmdManagerAutoPtr
{
CExtCmdManager * m_pCmdManager;
static volatile DWORD g_dwVersion;
public:
CExtCmdManagerAutoPtr();
~CExtCmdManagerAutoPtr();
// command maneger instance access
CExtCmdManager * operator->();
// Prof-UIS version info
static DWORD GetVersionDWORD(
bool bForSerialization = false
);
static LPCTSTR GetVersionString(
CString & strBuff,
TCHAR tchrSeparator = _T('.')
);
void OnSysColorChange(
CWnd * pWndNotifySrc
);
void OnSettingChange(
CWnd * pWndNotifySrc,
UINT uFlags,
LPCTSTR lpszSection
);
void OnDisplayChange(
CWnd * pWndNotifySrc,
INT nDepthBPP,
CPoint ptSizes
);
void OnThemeChanged(
CWnd * pWndNotifySrc,
WPARAM wParam,
LPARAM lParam
);
}; // class CExtCmdManagerAutoPtr
public:
// construction/destruction
CExtCmdManager();
~CExtCmdManager();
public:
#define __EXTMFC_DEF_PROFILE_NAME _T("default")
// setup single profile
bool ProfileSetup(
LPCTSTR sProfileName = NULL,
HWND hProfileWnd = NULL,
CExtCmdProfile * pNewProfileInstance = NULL
);
// get profile
CExtCmdProfile * ProfileGetPtr(
LPCTSTR sProfileName = NULL
);
// setup profile window
bool ProfileWndAdd(
LPCTSTR sProfileName,
HWND hProfileWnd
);
// remove profile window
bool ProfileWndRemove(
HWND hProfileWnd
);
// get profile name for window
LPCTSTR ProfileNameFromWnd(
HWND hWnd
);
// setup single command
bool CmdSetup(
LPCTSTR sProfileName,
const CExtCmdItem & _cmd,
bool bReplaceOld = false, // but force set images anywhere if was empty
bool * pbWasAddedNew = NULL
);
// remove single command
bool CmdRemove(
LPCTSTR sProfileName,
UINT nCmdID,
bool * pbWasRemoved = NULL
);
// remove all commands by state mask
bool CmdRemoveByMask(
LPCTSTR sProfileName,
DWORD dwMask,
bool bAllBitsOnly = false
);
// get command
CExtCmdItem * CmdGetPtr(
LPCTSTR sProfileName,
UINT nCmdID
);
// alloc command
CExtCmdItem * CmdAllocPtr(
LPCTSTR sProfileName,
UINT nCmdID = 0 // 0 means any free in avail range
);
// is command registered
bool CmdIsRegistered(
LPCTSTR sProfileName,
UINT nCmdID
);
// assign icon to command
bool CmdSetIcon(
LPCTSTR sProfileName,
UINT nCmdID,
HICON hIcon, // if NULL - remove
bool bCopyIcon = true
);
// get command icon (if command and its icon exist)
CExtCmdIcon * CmdGetIconPtr(
LPCTSTR sProfileName,
UINT nCmdID
);
// get command hIcon
HICON CmdGetHICON(
LPCTSTR sProfileName,
UINT nCmdID
)
{
CExtCmdIcon * pIcon =
CmdGetIconPtr(sProfileName,nCmdID);
if( pIcon == NULL )
return NULL;
ASSERT( !(pIcon->IsEmpty()) );
HICON hIcon = (*pIcon);
ASSERT( hIcon != NULL );
return hIcon;
}
// update commands collection from menu handle
bool UpdateFromMenu(
LPCTSTR sProfileName,
HMENU hMenu,
bool bReplaceOld = false,
bool bRecursive = true,
bool bLoadTips = true
);
// update commands collection from menu resurce
bool UpdateFromMenu(
LPCTSTR sProfileName,
UINT nResourceID,
bool bReplaceOld = false,
bool bLoadTips = true
);
// update commands collection from toolbar wnd
bool UpdateFromToolBar(
LPCTSTR sProfileName,
CToolBar & bar,
bool bReplaceOld = false, // but force set images anywhere if was empty
bool bLoadTips = true
);
// update commands collection from toolbar resource
bool UpdateFromToolBar(
LPCTSTR sProfileName,
UINT nResourceID,
LPUINT * ppCmdArray = NULL,
LPINT pCmdCount = NULL,
bool bReplaceOld = false, // but force set images anywhere if was empty
bool bLoadTips = true,
COLORREF clrBmpTransparent = RGB(192,192,192)
);
bool UpdateFromToolBar(
LPCTSTR sProfileName,
LPCTSTR strResourceID,
LPUINT * ppCmdArray = NULL,
LPINT pCmdCount = NULL,
bool bReplaceOld = false, // but force set images anywhere if was empty
bool bLoadTips = true,
COLORREF clrBmpTransparent = RGB(192,192,192)
);
// set list of commands (up to (UINT)0) as basic or non basic
bool SetBasicCommands(
LPCTSTR sProfileName,
UINT * pCommands,
bool bOn = true
);
// save/load command manager state
bool SerializeState(
LPCTSTR sProfileName,
LPCTSTR sSectionNameCompany, // under HKEY_CURRENT_USER\Software
LPCTSTR sSectionNameProduct, // under HKEY_CURRENT_USER\Software\%sSectionNameCompany%
bool bSave
);
bool SerializeState(
LPCTSTR sProfileName,
CArchive & ar
);
static bool FileObjToRegistry(
CFile & _file,
LPCTSTR sRegKeyPath
);
static bool FileObjFromRegistry(
CFile & _file,
LPCTSTR sRegKeyPath
);
static CString GetSubSystemRegKeyPath(
LPCTSTR sSubSystemName,
LPCTSTR sProfileName,
LPCTSTR sSectionNameCompany, // under HKEY_CURRENT_USER\Software
LPCTSTR sSectionNameProduct // under HKEY_CURRENT_USER\Software\%sSectionNameCompany%
);
virtual void OnSysColorChange();
virtual void OnSettingChange(
UINT uFlags,
LPCTSTR lpszSection
);
virtual void OnDisplayChange(
INT nDepthBPP,
CPoint ptSizes
);
virtual void OnThemeChanged(
WPARAM wParam,
LPARAM lParam
);
friend class CExtCmdItem;
friend class CExtCmdProfile;
}; // class CExtCmdManager
extern __PROF_UIS_API CExtCmdManager::CExtCmdManagerAutoPtr g_CmdManager;
#endif // __ExtCmdManager_H
| [
"trdmval@gmail.com"
] | trdmval@gmail.com |
2fae5eae4e4ac480ced50aa5566aaaae5ee6bc40 | d1cee40adee73afdbce5b3582bbe4761b595c4e1 | /back/RtmpLivePushSDK/boost/boost/units/physical_dimensions/velocity.hpp | b80807650bdbab72a95b708a7181131c64f596fc | [
"BSL-1.0"
] | permissive | RickyJun/live_plugin | de6fb4fa8ef9f76fffd51e2e51262fb63cea44cb | e4472570eac0d9f388ccac6ee513935488d9577e | refs/heads/master | 2023-05-08T01:49:52.951207 | 2021-05-30T14:09:38 | 2021-05-30T14:09:38 | 345,919,594 | 2 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 877 | hpp | // Boost.Units - A C++ library for zero-overhead dimensional analysis and
// unit/quantity manipulation and conversion
//
// Copyright (C) 2003-2008 Matthias Christian Schabel
// Copyright (C) 2008 Steven Watanabe
//
// Distributed under the Boost Software License, Version 1.0. (See
// accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#ifndef BOOST_UNITS_VELOCITY_DERIVED_DIMENSION_HPP
#define BOOST_UNITS_VELOCITY_DERIVED_DIMENSION_HPP
#include "derived_dimension.hpp"
#include "length.hpp"
#include "time.hpp"
namespace boost {
namespace units {
/// derived dimension for velocity : L T^-1
typedef derived_dimension<length_base_dimension,1,
time_base_dimension,-1>::type velocity_dimension;
} // namespace units
} // namespace boost
#endif // BOOST_UNITS_VELOCITY_DERIVED_DIMENSION_HPP
| [
"wenwenjun@weeget.cn"
] | wenwenjun@weeget.cn |
61e03edd9d78cc2308fb069e8289c8e49173a7e1 | 45ca2a12a9f6be20f1442cbe7922b27b9311899a | /h/ser/SerMemOutputSource.h | 7e424faaf88177298ae6ae3c0082d648a0d4dd56 | [
"LicenseRef-scancode-unknown-license-reference",
"Apache-2.0"
] | permissive | LoganDing/cslib | 669ce63d97daf681df9f45389df5a2c762c6339c | 3401fc6516e6952f01a13bb7de999c79a0937154 | refs/heads/master | 2020-12-24T13:29:31.181275 | 2015-06-03T19:32:52 | 2015-06-03T19:32:52 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 4,241 | h | #ifndef SerMemOutputSource_H_LOADED
#define SerMemOutputSource_H_LOADED
// [
// $ SerMemOutputSource.h
//
// Copyright 2011 Chris Sanchez
//
// 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.
// ====================================================================
//
// Copyright (c) 1998-2001 Chris Sanchez. All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions
// are met:
//
// 1. Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//
//
// THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED 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 CHRIS SANCHEZ OR
// ITS 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.
// ====================================================================
//
// This software consists of voluntary contributions made by Chris Sanchez.
// Portions of other open source software were used in the creation of this
// software. Header files for work based on other source bears the
// orininator copyright.
//
// Author: Chris Sanchez
//
// RCS:
// $Revision: 2.0 $
// $Author: $
// $Date: $
// ?
// Contents: SerMemOutputSource class
//
// Purpose:
//
// Usage Notes:
// Provide a memory-based implementation of a serialization source
//
//
// ?
// ! Changes History
// $Header: $
//
// ]
#include <strstream>
#include <cslib.h>
#include <ser/iSerOutputSource.h>
class EXPORT_DLL SerMemOutputSource : public iSerOutputSource
{
public:
/**
Construct with a buffer that will grow dynamically.
The buffer is owned by the SerMemOutputSource object
*/
SerMemOutputSource();
/**
Preallocate a buffer of maxBytes in size. The buffer is
owned by the SerMemOutputSource object
@param preAllocSz the size to preallocate
*/
SerMemOutputSource(const size_t preAllocSz);
virtual ~SerMemOutputSource();
/**
getOutputStream
Returns a new stream suitable for writing out
data. Any such existing source will be overwritten
with any new data output to the stream
@return std::ostream reference to an output stream
*/
std::ostream& getOutputStream() { return _out; }
/**
Return the current size of the stream
*/
virtual size_t getSize();
/**
return the start of the buffer
*/
virtual const char* getBuff();
protected:
// if the object owns the buffer, then these two
// data members track the buffer size and pointer
char* _buff;
bool _owns;
std::ostrstream _out;
private:
// Unimplemented standard methods
SerMemOutputSource(const SerMemOutputSource&);
SerMemOutputSource& operator=(const SerMemOutputSource&);
};
// SerMemOutputSource_H_LOADED
#endif
| [
"sanchez.chris@gmail.com"
] | sanchez.chris@gmail.com |
35d088493d95fb09cdc99f8a2e5fda7985b0774d | e1bf912ad17091fc1bc92cd63e5dcc23eb930853 | /UE4_Project/Physics_In_UE4/ChronoPhysicsDemo/Plugins/ChronoPhysics/Source/ChronoPhysics/Include/blaze-2.2/blaze/math/Vector.h | 93d73cf02285d9af29962795f051365a45972784 | [
"BSD-3-Clause"
] | permissive | CGJiaxiLiu/MyPortfolio | da35fba3044fb04c74672d6c35f43ccd838ec353 | 637ac7c4398e08e363a0189abd87acc5f375625c | refs/heads/master | 2020-07-31T01:45:51.902508 | 2020-06-10T02:32:34 | 2020-06-10T02:32:34 | 210,438,097 | 5 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 8,184 | h | //=================================================================================================
/*!
// \file blaze/math/Vector.h
// \brief Header file for all basic Vector functionality
//
// Copyright (C) 2013 Klaus Iglberger - All Rights Reserved
//
// This file is part of the Blaze library. You can redistribute it and/or modify it under
// the terms of the New (Revised) BSD 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 names of the Blaze development group 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 HOLDER 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 _BLAZE_MATH_VECTOR_H_
#define _BLAZE_MATH_VECTOR_H_
//*************************************************************************************************
// Includes
//*************************************************************************************************
#include <iomanip>
#include <ostream>
#include <blaze/math/expressions/Vector.h>
#include <blaze/math/traits/MultTrait.h>
#include <blaze/math/TransposeFlag.h>
namespace blaze {
//=================================================================================================
//
// GLOBAL OPERATORS
//
//=================================================================================================
//*************************************************************************************************
/*!\name Vector operators */
//@{
template< typename T1, typename T2 >
inline const typename MultTrait<typename T1::ElementType,typename T2::ElementType>::Type
operator,( const Vector<T1,false>& lhs, const Vector<T2,false>& rhs );
template< typename T1, typename T2 >
inline const typename MultTrait<typename T1::ElementType,typename T2::ElementType>::Type
operator,( const Vector<T1,false>& lhs, const Vector<T2,true>& rhs );
template< typename T1, typename T2 >
inline const typename MultTrait<typename T1::ElementType,typename T2::ElementType>::Type
operator,( const Vector<T1,true>& lhs, const Vector<T2,false>& rhs );
template< typename T1, typename T2 >
inline const typename MultTrait<typename T1::ElementType,typename T2::ElementType>::Type
operator,( const Vector<T1,true>& lhs, const Vector<T2,true>& rhs );
template< typename VT, bool TF >
inline std::ostream& operator<<( std::ostream& os, const Vector<VT,TF>& dv );
//@}
//*************************************************************************************************
//*************************************************************************************************
/*!\brief Multiplication operator for the scalar product (inner product) of two vectors
// (\f$ s=(\vec{a},\vec{b}) \f$).
// \ingroup vector
//
// \param lhs The left-hand side vector for the inner product.
// \param rhs The right-hand side vector for the inner product.
// \return The scalar product.
*/
template< typename T1 // Type of the left-hand side vector
, typename T2 > // Type of the right-hand side vector
inline const typename MultTrait<typename T1::ElementType,typename T2::ElementType>::Type
operator,( const Vector<T1,false>& lhs, const Vector<T2,false>& rhs )
{
return trans(~lhs) * (~rhs);
}
//*************************************************************************************************
//*************************************************************************************************
/*!\brief Multiplication operator for the scalar product (inner product) of two vectors
// (\f$ s=(\vec{a},\vec{b}) \f$).
// \ingroup vector
//
// \param lhs The left-hand side vector for the inner product.
// \param rhs The right-hand side vector for the inner product.
// \return The scalar product.
*/
template< typename T1 // Type of the left-hand side vector
, typename T2 > // Type of the right-hand side vector
inline const typename MultTrait<typename T1::ElementType,typename T2::ElementType>::Type
operator,( const Vector<T1,false>& lhs, const Vector<T2,true>& rhs )
{
return trans(~lhs) * trans(~rhs);
}
//*************************************************************************************************
//*************************************************************************************************
/*!\brief Multiplication operator for the scalar product (inner product) of two vectors
// (\f$ s=(\vec{a},\vec{b}) \f$).
// \ingroup vector
//
// \param lhs The left-hand side vector for the inner product.
// \param rhs The right-hand side vector for the inner product.
// \return The scalar product.
*/
template< typename T1 // Type of the left-hand side vector
, typename T2 > // Type of the right-hand side vector
inline const typename MultTrait<typename T1::ElementType,typename T2::ElementType>::Type
operator,( const Vector<T1,true>& lhs, const Vector<T2,false>& rhs )
{
return (~lhs) * (~rhs);
}
//*************************************************************************************************
//*************************************************************************************************
/*!\brief Multiplication operator for the scalar product (inner product) of two vectors
// (\f$ s=(\vec{a},\vec{b}) \f$).
// \ingroup vector
//
// \param lhs The left-hand side vector for the inner product.
// \param rhs The right-hand side vector for the inner product.
// \return The scalar product.
*/
template< typename T1 // Type of the left-hand side vector
, typename T2 > // Type of the right-hand side vector
inline const typename MultTrait<typename T1::ElementType,typename T2::ElementType>::Type
operator,( const Vector<T1,true>& lhs, const Vector<T2,true>& rhs )
{
return (~lhs) * trans(~rhs);
}
//*************************************************************************************************
//*************************************************************************************************
/*!\brief Global output operator for dense and sparse vectors.
// \ingroup vector
//
// \param os Reference to the output stream.
// \param v Reference to a constant vector object.
// \return Reference to the output stream.
*/
template< typename VT // Type of the vector
, bool TF > // Transpose flag
inline std::ostream& operator<<( std::ostream& os, const Vector<VT,TF>& v )
{
if( (~v).size() == 0UL ) {
os << "( )\n";
}
else if( TF == rowVector ) {
os << "(";
for( size_t i=0UL; i<(~v).size(); ++i )
os << " " << (~v)[i];
os << " )\n";
}
else {
for( size_t i=0UL; i<(~v).size(); ++i )
os << "( " << std::setw( 11UL ) << (~v)[i] << " )\n";
}
return os;
}
//*************************************************************************************************
} // namespace blaze
#endif
| [
"jliu807@gatech.edu"
] | jliu807@gatech.edu |
965d7bc655b8f8506721126957cbca3a74f1c663 | 37f3465cf2d52da8fca171fa3d6208d45101cb90 | /qsrc/CQSVGFeDiffuseLighting.cpp | 85d6e166fbd8824c9fdcc9762de3ac0dc863b240 | [
"MIT"
] | permissive | colinw7/CSVG | d9197e376c7339feb754a243093379edc6c57bd9 | fbc51f2969d2aa69f74b9ddb640a6aca976b5354 | refs/heads/master | 2023-01-24T06:17:45.500884 | 2023-01-22T23:27:50 | 2023-01-22T23:27:50 | 10,599,851 | 8 | 3 | null | null | null | null | UTF-8 | C++ | false | false | 897 | cpp | #include <CQSVGFeDiffuseLighting.h>
#include <CQUtil.h>
#include <CQSVG.h>
#include <CQPropertyTree.h>
CQSVGFeDiffuseLighting::
CQSVGFeDiffuseLighting(CQSVG *svg) :
CQSVGObject(svg, this), CSVGFeDiffuseLighting(*svg)
{
}
QColor
CQSVGFeDiffuseLighting::
getLightingColor() const
{
return CQUtil::toQColor(CSVGFeDiffuseLighting::getLightingColor().getValue().rgba());
}
void
CQSVGFeDiffuseLighting::
setLightingColor(const QColor &c)
{
CSVGColor color(CQUtil::colorToRGBA(c));
CSVGFeDiffuseLighting::setLightingColor(Color(color));
}
void
CQSVGFeDiffuseLighting::
addProperties(CQPropertyTree *propTree, const std::string &name)
{
CQSVGObject::addProperties(propTree, name);
QString objName = name.c_str();
propTree->addProperty(objName, this, "lightingColor");
propTree->addProperty(objName, this, "surfaceScale");
propTree->addProperty(objName, this, "diffuseConstant");
}
| [
"colinw@nc.rr.com"
] | colinw@nc.rr.com |
f0ded9dca6576b1aaf1dd854f7eef2ce2a8d2641 | b7f3edb5b7c62174bed808079c3b21fb9ea51d52 | /third_party/blink/renderer/modules/launch/launch_params.cc | a02768ab8ee28a7d51768403fe0498b6e38b04a6 | [
"LGPL-2.0-or-later",
"GPL-1.0-or-later",
"MIT",
"Apache-2.0",
"LicenseRef-scancode-warranty-disclaimer",
"LGPL-2.1-only",
"GPL-2.0-only",
"LGPL-2.0-only",
"BSD-2-Clause",
"LicenseRef-scancode-other-copyleft",
"BSD-3-Clause"
] | permissive | otcshare/chromium-src | 26a7372773b53b236784c51677c566dc0ad839e4 | 64bee65c921db7e78e25d08f1e98da2668b57be5 | refs/heads/webml | 2023-03-21T03:20:15.377034 | 2020-11-16T01:40:14 | 2020-11-16T01:40:14 | 209,262,645 | 18 | 21 | BSD-3-Clause | 2023-03-23T06:20:07 | 2019-09-18T08:52:07 | null | UTF-8 | C++ | false | false | 690 | cc | // Copyright 2019 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file
#include "third_party/blink/renderer/modules/launch/launch_params.h"
#include "third_party/blink/renderer/modules/native_file_system/native_file_system_handle.h"
#include "third_party/blink/renderer/platform/heap/visitor.h"
namespace blink {
LaunchParams::LaunchParams(HeapVector<Member<NativeFileSystemHandle>> files)
: files_(files) {}
LaunchParams::~LaunchParams() = default;
void LaunchParams::Trace(Visitor* visitor) const {
visitor->Trace(files_);
ScriptWrappable::Trace(visitor);
}
} // namespace blink
| [
"commit-bot@chromium.org"
] | commit-bot@chromium.org |
df8610ef97dfc6c94889e42df42b7e6bd9e5e9eb | 92ada3eabb986350da3f4919a1d75c71a170854d | /autoupdate/common/3rd/boost/mpl/front_inserter.hpp | 6b96357a5aac3b8b2c534e077be9e591e4811735 | [] | no_license | jjzhang166/autoupdate | 126e52be7d610fe121b615c0998af69dcbe70104 | 7a54996619f03b0febd762c007d5de0c85045a31 | refs/heads/master | 2021-05-05T20:09:44.330623 | 2015-08-27T08:57:52 | 2015-08-27T08:57:52 | 103,895,533 | 0 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 771 | hpp |
#ifndef BOOST_MPL_FRONT_INSERTER_HPP_INCLUDED
#define BOOST_MPL_FRONT_INSERTER_HPP_INCLUDED
// Copyright Aleksey Gurtovoy 2003-2004
// Copyright David Abrahams 2003-2004
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// See http://www.boost.org/libs/mpl for documentation.
// $Source: /repo/3rd/boost/mpl/front_inserter.hpp,v $
// $Date: 2010/04/29 03:06:03 $
// $Revision: 1.1.1.1 $
#include <boost/mpl/push_front.hpp>
#include <boost/mpl/inserter.hpp>
namespace boost { namespace mpl {
template<
typename Sequence
>
struct front_inserter
: inserter< Sequence,push_front<> >
{
};
}}
#endif // BOOST_MPL_FRONT_INSERTER_HPP_INCLUDED
| [
"269221745@qq.com"
] | 269221745@qq.com |
2695c9a8f373998261cf1c4f53ac85a3ce2b07c8 | 9c482f655ed47825144b1518f767633e8c1f75c8 | /src/read_svmlight.cpp | 9b8f705b1af0a80141a5f856c515d45d2a571bb4 | [] | no_license | Sandy4321/sparsio | d6f6b96f8688f75a0f88fa6649b5576651ed4e65 | a2f5f465b8582d741655b0925d6407103ff86c6c | refs/heads/master | 2020-03-17T04:50:18.365281 | 2017-06-29T05:37:31 | 2017-06-29T05:37:31 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,865 | cpp | #include <Rcpp.h>
#include <vector>
#include <string>
#include <fstream>
using namespace Rcpp;
// Reads a sparse matrix from a SVMlight compatible file
// [[Rcpp::export]]
List read_svmlight_cpp(Rcpp::String filename, int zero_based = 1) {
int index_start_with = 0;
if(!zero_based) index_start_with = 1;
std::vector<int> col_indices;
std::vector<int> pointers;
std::vector<double> x_values;
std::vector<double> y_values;
std::ifstream inputFile(filename.get_cstring());
std::string line;
int nrow = 0;
int ncol = 0;
int pointer_counter = 0;
// foreach line
while (!inputFile.eof()) {
std::getline(inputFile, line);
std::istringstream tokenStream( line );
std::string token;
pointers.push_back(pointer_counter);
// first token = target value
std::getline(tokenStream, token, ' ');
// check eof - case for last line
if(!tokenStream.eof()) {
double target;
sscanf(token.c_str(), "%lf", &target);
y_values.push_back(target);
nrow++;
}
// foreach token (id:value) in line
while (!tokenStream.eof()) {
std::getline(tokenStream, token, ' ');
int id;
double value;
sscanf(token.c_str(), "%d:%lf", &id, &value);
// case when indices start from 1
id = id - index_start_with;
ncol = std::max(id, ncol);
x_values.push_back(value);
col_indices.push_back(id);
pointer_counter++;
}
}
ncol++;
S4 x("dgRMatrix");
x.slot("p") = wrap(pointers);
x.slot("j") = wrap(col_indices);
x.slot("x") = wrap(x_values);
x.slot("factors") = List::create();
x.slot("Dim") = IntegerVector::create(nrow, ncol);
x.slot("Dimnames") = List::create(R_NilValue, R_NilValue);
return List::create(
_["x"] = x,
_["y"] = Rcpp::wrap(y_values)
) ;
}
| [
"selivanov.dmitriy@gmail.com"
] | selivanov.dmitriy@gmail.com |
452f30cd6b920cc97dba894c466c592f61e1feba | c1997c40bd02dc0b38c8f5999d2d60c32b4deed9 | /test_temp_sensor/test_temp_sensor.ino | 3f85290b6388f8a77eee52ad66c4f368f16be69e | [] | no_license | Engelweiss/EmbeddedGit | 884dce8f12bae4c363d3497086acdbf0a6cb087c | 630b961f0e4c197263179dcc3b5ad25acbae2c19 | refs/heads/master | 2021-01-19T09:20:50.075391 | 2017-04-16T18:54:18 | 2017-04-16T18:54:18 | 82,097,272 | 0 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 775 | ino | #include <OneWire.h>
#include <DallasTemperature.h>
#include <LiquidCrystal.h>
// Assign to pin 10 of your Arduino to the DS18B20
#define ONE_WIRE_BUS 9
// Create a onewire instanace
OneWire oneWire(ONE_WIRE_BUS);
// Declare a DS18B20 Instance and assing the OneWire reference to it.
DallasTemperature sensors(&oneWire);
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);
void setup(void)
{
// Start serial port
Serial.begin(9600);
//Start the DallasTemperature Library
sensors.begin();
lcd.begin(20,4);
}
void loop(void)
{
lcd.setCursor(0, 0);
sensors.requestTemperatures(); // Tell the DS18B20 to get make a measurement
lcd.print("Water Temp: ");
lcd.setCursor(0, 1);
lcd.print(sensors.getTempFByIndex(0),4);
lcd.print("F");
delay(1000);
}
| [
"noreply@github.com"
] | Engelweiss.noreply@github.com |
27da82676e0a0577b02ccbcf2030dca00a277309 | 38c10c01007624cd2056884f25e0d6ab85442194 | /chrome/browser/ui/views/passwords/manage_passwords_icon_views.cc | aa847dbeb442e796eed455fff961c9cc9176d5a8 | [
"BSD-3-Clause"
] | permissive | zenoalbisser/chromium | 6ecf37b6c030c84f1b26282bc4ef95769c62a9b2 | e71f21b9b4b9b839f5093301974a45545dad2691 | refs/heads/master | 2022-12-25T14:23:18.568575 | 2016-07-14T21:49:52 | 2016-07-23T08:02:51 | 63,980,627 | 0 | 2 | BSD-3-Clause | 2022-12-12T12:43:41 | 2016-07-22T20:14:04 | null | UTF-8 | C++ | false | false | 3,310 | cc | // Copyright 2013 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "chrome/browser/ui/views/passwords/manage_passwords_icon_views.h"
#include "chrome/app/chrome_command_ids.h"
#include "chrome/browser/command_updater.h"
#include "chrome/browser/ui/passwords/manage_passwords_ui_controller.h"
#include "chrome/browser/ui/views/passwords/manage_passwords_bubble_view.h"
#include "chrome/grit/generated_resources.h"
#include "components/password_manager/core/common/password_manager_ui.h"
#include "ui/base/l10n/l10n_util.h"
#include "ui/base/resource/resource_bundle.h"
#include "ui/gfx/vector_icons_public.h"
ManagePasswordsIconViews::ManagePasswordsIconViews(CommandUpdater* updater)
: BubbleIconView(updater, IDC_MANAGE_PASSWORDS_FOR_PAGE),
state_(password_manager::ui::INACTIVE_STATE) {
SetFocusable(true);
UpdateUiForState();
}
ManagePasswordsIconViews::~ManagePasswordsIconViews() {}
void ManagePasswordsIconViews::SetActive(bool active) {
SetActiveInternal(active);
}
void ManagePasswordsIconViews::SetState(password_manager::ui::State state) {
if (state_ == state)
return;
// If there is an opened bubble for the current icon it should go away.
if (active())
ManagePasswordsBubbleView::CloseBubble();
state_ = state;
UpdateUiForState();
}
void ManagePasswordsIconViews::UpdateUiForState() {
if (state_ == password_manager::ui::INACTIVE_STATE) {
SetVisible(false);
return;
}
SetTooltipText(l10n_util::GetStringUTF16(
state_ == password_manager::ui::PENDING_PASSWORD_STATE
? IDS_PASSWORD_MANAGER_TOOLTIP_SAVE
: IDS_PASSWORD_MANAGER_TOOLTIP_MANAGE));
SetVisible(true);
// We may be about to automatically pop up a ManagePasswordsBubbleView.
// Force layout of the icon's parent now; the bubble will be incorrectly
// positioned otherwise, as the icon won't have been drawn into position.
parent()->Layout();
}
void ManagePasswordsIconViews::OnExecuting(
BubbleIconView::ExecuteSource source) {}
bool ManagePasswordsIconViews::OnMousePressed(const ui::MouseEvent& event) {
bool result = BubbleIconView::OnMousePressed(event);
if (IsBubbleShowing())
ManagePasswordsBubbleView::CloseBubble();
return result;
}
bool ManagePasswordsIconViews::OnKeyPressed(const ui::KeyEvent& event) {
// Space is always ignored because otherwise the bubble appears with the
// default button down. Releasing the space is equivalent to clicking this
// button.
if (event.key_code() == ui::VKEY_SPACE)
return true;
if (event.key_code() == ui::VKEY_RETURN && active()) {
// If the icon is active, it should transfer its focus to the bubble.
// If it still somehow got this key event, the bubble shouldn't be reopened.
return true;
}
return BubbleIconView::OnKeyPressed(event);
}
views::BubbleDelegateView* ManagePasswordsIconViews::GetBubble() const {
return ManagePasswordsBubbleView::manage_password_bubble();
}
gfx::VectorIconId ManagePasswordsIconViews::GetVectorIcon() const {
return gfx::VectorIconId::AUTOLOGIN;
}
void ManagePasswordsIconViews::AboutToRequestFocusFromTabTraversal(
bool reverse) {
if (active())
ManagePasswordsBubbleView::ActivateBubble();
}
| [
"zeno.albisser@hemispherian.com"
] | zeno.albisser@hemispherian.com |
0121d8f52000a1a92ec6031b5852887bafee3df1 | d12ef5f7472ad8ef90410f7232ba52620314263f | /baekjoon/트라이/5670.cpp | b01a540d0b726e29ff657decf253d80122fadaf8 | [] | no_license | b-chae/AlgorithmStudy | 34c1af96058c29caae49c0692a21bdc190adac7f | d5d2f01bcfbff56f23c05b1238d3b060169b732f | refs/heads/master | 2023-08-04T04:08:34.051246 | 2021-09-12T00:15:49 | 2021-09-12T00:15:49 | 257,220,705 | 0 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 1,674 | cpp | #include <iostream>
using namespace std;
int N;
class Tree
{
public:
bool isEnd = false;
Tree *next[26];
int nextcount = 0;
int count = 0;
~Tree()
{
for (int i = 0; i < 26; i++)
if (next[i] != NULL)
delete next[i];
}
};
class TrieTree
{
public:
Tree *root = new Tree();
void insert(string str)
{
Tree *current = root;
for (int i = 0; i < str.length(); i++)
{
int index = str[i] - 'a';
if (current->next[index] == NULL)
{
current->next[index] = new Tree();
current->nextcount++;
}
current = current->next[index];
current->count++;
}
current->isEnd = true;
}
int dfs(Tree *current)
{
int res = 0;
for (int i = 0; i < 26; i++)
{
if (current->next[i] != NULL)
{
if (current->isEnd || current->nextcount != 1 || current == root)
{
res += current->next[i]->count;
}
res += dfs(current->next[i]);
}
}
return res;
}
int ans()
{
int res = dfs(root);
return res;
}
~TrieTree()
{
delete root;
}
};
int main()
{
ios::sync_with_stdio(0);
cin.tie(0);
while (cin >> N)
{
TrieTree trieTree;
for (int i = 0; i < N; i++)
{
string str;
cin >> str;
trieTree.insert(str);
}
printf("%.2f\n", (double)trieTree.ans() / N);
}
return 0;
}
| [
"noreply@github.com"
] | b-chae.noreply@github.com |
9602fde26203aad91c4fb0db1c3ea7c249c430de | b6cbc4c3df5b1460b1217c25cd095d9b661f714f | /module_0/draft/ex01/includes/Contact.class.hpp | 23bd34d88e83b5aeff71087eed5e9331ffd03164 | [] | no_license | Bressack/CPP-piscine | dd28a64c5ebfbadbd99c88fe542e14e3a5963127 | 1d27f9ccaa53eb5671a1ee28b637b243722294a7 | refs/heads/master | 2023-06-16T23:50:42.526171 | 2021-07-13T15:30:01 | 2021-07-13T15:30:01 | 380,235,881 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,498 | hpp | /* ************************************************************************** */
/* */
/* ::: :::::::: */
/* Contact.class.hpp :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: tharchen <tharchen@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2021/06/17 15:33:57 by tharchen #+# #+# */
/* Updated: 2021/06/30 15:15:05 by tharchen ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef CONTACT_CLASS_HPP
# define CONTACT_CLASS_HPP
# include <dispatcher.hpp>
class Contact
{
protected:
// PROTECTED MEMBERS ATRIBUTE : PROMA
// PROTECTED MEMBERS FUNCTION : PROMF
private:
// PRIVATE MEMBERS ATRIBUTE : PRIMA
std::string _first_name;
std::string _last_name;
std::string _nickname;
std::string _phone_number;
std::string _darkest_secret;
// PRIVATE MEMBERS FUNCTION : PRIMF
public:
// CONSTRUCTOR / DESTRUCTOR : CD
Contact(void); // constructor
Contact(std::string _first_name, std::string _last_name, std::string _nickname, std::string _phone_number, std::string _darkest_secret); // constructor
Contact(const Contact &src); // constructor by copy
virtual ~Contact(void); // destructor
// OVERLOADED OPERATORS : OVOP
// Contact &operator=(const Contact &rhs);
// GETTERS / SETTERS : GS
void set__darkest_secret(std::string _darkest_secret);
std::string get__darkest_secret(void) const;
void set__phone_number(std::string _phone_number);
std::string get__phone_number(void) const;
void set__nickname(std::string _nickname);
std::string get__nickname(void) const;
void set__last_name(std::string _last_name);
std::string get__last_name(void) const;
void set__first_name(std::string _first_name);
std::string get__first_name(void) const;
// PUBLIC MEMBERS ATTRIBUTE : PUMA
// PUBLIC MEMBERS FUNCTION : PUMF
static void print_column_names(void);
void print(void) const;
void print_short(int id) const;
};
std::ostream &operator<<(std::ostream &o, const Contact &i);
#endif
| [
"tharchen@student.42.fr"
] | tharchen@student.42.fr |
8a6ab5248be2ca51c014b0fe447c9c4c299728e9 | 3053224b13725aca71afcf0c2476ec9163299af8 | /HoppChris CSCI 222 - Lab 1 PokerLab/hand.h | e513e3fbb214ba6561545c35547ca88aed4cf9f3 | [] | no_license | chrishopp12/Palomar-CSCI-222 | 463a5fc94059476f2239811193ca5ab819565199 | 1af0a6ba2ac4aa1a36c8d6a3a690dd8c5a5f2667 | refs/heads/master | 2020-04-12T06:02:11.718421 | 2018-12-19T19:00:26 | 2018-12-19T19:00:26 | 162,340,444 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 374 | h | /*
* game1.cpp
* Chris Hopp - 010809627
* v. 03.02.2018
*
*/
#ifndef _HAND_H
#define _HAND_H
#include "card.h"
#include "deck.h"
class Hand {
friend class Game2;
private:
Card hand[5]; //Declarations
int pairs; //Variables
int flushes;
public:
bool isFlush(); //Public functions
bool isPair();
};
#endif
| [
"noreply@github.com"
] | chrishopp12.noreply@github.com |
6c8566bbef4ae5a2cfb060a3028b1ec614f9e8bb | 5c133d148e129a9947b0d2877117b262f12b907d | /graphic.cpp | 892e92095aaa9e662c01aca8119093ab44b10c15 | [] | no_license | HoratioPrime/Integral_3_Ways-CourseWork | 59c7d0a4a2e43f6bf53ce013d64f768529e59fe8 | 4c67651e37cdf45c55111f5eb673b31bef531dd4 | refs/heads/master | 2020-09-05T07:58:17.571444 | 2019-11-18T17:31:52 | 2019-11-18T17:31:52 | 210,185,523 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,805 | cpp | #include "graphic.h"
Graphic::Graphic()
{
chart = new QChart();
chartView = new QChartView(chart);
axisX = new QValueAxis();
axisY = new QValueAxis();
axisX->setTitleText("X");
axisY->setTitleText("Y");
setAxis(axisX);
setAxis(axisY);
/*
axisX = new QValueAxis();
axisX->setGridLineVisible(false);
axisX->setTitleText("X");
axisX->setTitleBrush(QBrush(QColor().fromRgb(155,155,155)));
axisY = new QValueAxis();
axisY->setGridLineVisible(false);
axisY->setTitleText("Y");
axisY->setTitleBrush(QBrush(QColor().fromRgb(155,155,155)));
*/
chart->legend()->hide();
chart->addAxis(axisX, Qt::AlignBottom);
chart->addAxis(axisY, Qt::AlignLeft);
chartView->setRenderHint(QPainter::Antialiasing);
}
void Graphic::addSeries(QLineSeries *series)
{
chart->setBackgroundBrush(QBrush(QColor().fromRgb(37,37,37)));
chartView->setBackgroundBrush(QBrush(QColor().fromRgb(37,37,37)));
chart->addSeries(series);
series->attachAxis(axisX);
series->attachAxis(axisY);
}
void Graphic::setAxis(QValueAxis* axis)
{
axis->setGridLineVisible(false);
axis->setTitleBrush(QBrush(QColor().fromRgb(155,155,155)));
axis->setLabelsBrush(QBrush(QColor().fromRgb(155,155,155)));
}
void Graphic::show()
{
chartView->show();
}
auto Graphic::getAxisX() const {return axisX;}
auto Graphic::getAxisY() const {return axisY;}
void Graphic::settleDownAxis()
{
delete axisX;
delete axisY;
axisX = new QValueAxis();
axisY = new QValueAxis();
axisX->setTitleText("X");
axisY->setTitleText("Y");
setAxis(axisX);
setAxis(axisY);
chart->addAxis(axisX, Qt::AlignBottom);
chart->addAxis(axisY, Qt::AlignLeft);
}
QChartView* Graphic::getChartView() {return chartView;}
| [
"samohin.work@gmail.com"
] | samohin.work@gmail.com |
a71cb738e412cfea4bdf8c0b8ec49a768698b4fc | 8c680e33978eadacbb2d39f672d9918de3ad068f | /src/light.cpp | b55cb5a471d1d247ad74a3da6724b81b0fe702e5 | [
"MIT"
] | permissive | Nakeib/RonClient | 9b319acc3102a7566af24bdc49087da1f4c4217b | 9e816c580ec2a6f1b15fdefd8e15ad62647ca29f | refs/heads/main | 2023-01-01T11:56:00.894283 | 2020-10-28T13:56:40 | 2020-10-28T14:11:19 | 308,030,092 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 14,502 | cpp | /* -------------------------------------------------------------------------- */
/* ------------- RonClient --- Oficial client for RonOTS servers ------------ */
/* -------------------------------------------------------------------------- */
#include "light.h"
#include "allocator.h"
#include "creature.h"
#include "distance.h"
#include "item.h"
#include "magiceffect.h"
#include "map.h"
#include "logger.h"
#include "tools.h"
// ---- Light ---- //
Light::Light(unsigned char color, unsigned char level) {
this->color = color;
this->level = level;
}
Light::~Light() { }
// ---- StaticItemLight ---- //
StaticItemLight::StaticItemLight(Item* item, unsigned char color, unsigned char level) : Light(color, level) {
this->item = item;
Lights::AddStaticLight(this);
}
StaticItemLight::~StaticItemLight() {
Lights::RemoveStaticLight(this);
}
// ---- StaticMagicEffectLight ---- //
StaticMagicEffectLight::StaticMagicEffectLight(MagicEffect* magicEffect, unsigned char color, unsigned char level) : Light(color, level) {
this->magicEffect = magicEffect;
Lights::AddStaticLight(this);
}
StaticMagicEffectLight::~StaticMagicEffectLight() {
Lights::RemoveStaticLight(this);
}
// ---- DynamicCreatureLight ---- //
DynamicCreatureLight::DynamicCreatureLight(Creature* creature, unsigned char color, unsigned char level) : Light(color, level) {
this->creature = creature;
Lights::AddDynamicLight(this);
}
DynamicCreatureLight::~DynamicCreatureLight() {
Lights::RemoveDynamicLight(this);
}
// ---- DynamicDistanceLight ---- //
DynamicDistanceLight::DynamicDistanceLight(Distance* distance, unsigned char color, unsigned char level) : Light(color, level) {
this->distance = distance;
Lights::AddDynamicLight(this);
}
DynamicDistanceLight::~DynamicDistanceLight() {
Lights::RemoveDynamicLight(this);
}
// ---- Lights ---- //
unsigned char Lights::globalColor;
unsigned char Lights::globalLevel;
LightMap Lights::staticMap;
LightMap Lights::dynamicMap;
LightsList Lights::staticLights;
LightsList Lights::dynamicLights;
MUTEX Lights::lockLights;
void Lights::SetGlobalColor(unsigned char color) {
LOCKCLASS lockClass(lockLights);
globalColor = color;
}
unsigned char Lights::GetGlobalColor() {
LOCKCLASS lockClass(lockLights);
return globalColor;
}
void Lights::SetGlobalLevel(unsigned char level) {
LOCKCLASS lockClass(lockLights);
globalLevel = level;
}
unsigned char Lights::GetGlobalLevel() {
LOCKCLASS lockClass(lockLights);
return globalLevel;
}
void Lights::AddStaticLight(Light* light) {
LOCKCLASS lockClass(lockLights);
LightsList::iterator it = std::find(staticLights.begin(), staticLights.end(), light);
if (it == staticLights.end())
staticLights.push_back(light);
else
Logger::AddLog("Lights::AddStaticLight()", "Static light already on list!", LOG_ERROR);
}
void Lights::RemoveStaticLight(Light* light) {
LOCKCLASS lockClass(lockLights);
LightsList::iterator it = std::find(staticLights.begin(), staticLights.end(), light);
if (it != staticLights.end())
staticLights.erase(it);
else
Logger::AddLog("Lights::RemoveStaticLight()", "Static light not on list!", LOG_ERROR);
}
void Lights::AddDynamicLight(Light* light) {
LOCKCLASS lockClass(lockLights);
LightsList::iterator it = std::find(dynamicLights.begin(), dynamicLights.end(), light);
if (it == dynamicLights.end())
dynamicLights.push_back(light);
else
Logger::AddLog("Lights::AddDynamicLight()", "Dynamic light already on list!", LOG_ERROR);
}
void Lights::RemoveDynamicLight(Light* light) {
LOCKCLASS lockClass(lockLights);
LightsList::iterator it = std::find(dynamicLights.begin(), dynamicLights.end(), light);
if (it != dynamicLights.end())
dynamicLights.erase(it);
else
Logger::AddLog("Lights::RemoveDynamicLight()", "Dynamic light not on list!", LOG_ERROR);
}
int Lights::GetStaticLightsCount() {
LOCKCLASS lockClass(lockLights);
return staticLights.size();
}
int Lights::GetDynamicLightsCount() {
LOCKCLASS lockClass(lockLights);
return dynamicLights.size();
}
void Lights::UpdateStaticLightMap(Map* map) {
LOCKCLASS lockClass1(Map::lockMap);
LOCKCLASS lockClass2(Tile::lockTile);
LOCKCLASS lockClass3(lockLights);
if (Game::adminOptions.fullLight)
return;
memset(&staticMap, 0, 19 * 15 * 3);
if (!map) {
Logger::AddLog("Lights::UpdateStaticLightMap()", "Pointer to map is NULL!", LOG_WARNING);
return;
}
Position corner = map->GetCorner();
POINT pointZ = map->GetZ();
unsigned char z_from = pointZ.x;
unsigned char z_to = pointZ.y;
for (int z = z_from; z >= z_to; z--) {
int offset = z - corner.z;
LightsList::iterator it = staticLights.begin();
for (it; it != staticLights.end(); it++) {
Light* light = *it;
StaticItemLight* itemLight = dynamic_cast<StaticItemLight*>(light);
StaticMagicEffectLight* magicEffectLight = dynamic_cast<StaticMagicEffectLight*>(light);
Position pos;
if (itemLight && itemLight->item) pos = itemLight->item->pos;
else if (magicEffectLight && magicEffectLight->magicEffect) pos = magicEffectLight->magicEffect->pos;
if (light && pos.z == z) {
COLOR color = ConvertColorSTD(light->color);
unsigned char radius = light->level;
int lx = pos.x - corner.x + offset + 1;
int ly = pos.y - corner.y + offset + 1;
for (int x = lx - radius; x <= lx + radius; x++)
for (int y = ly - radius; y <= ly + radius; y++) {
if (map->IsHiddenTile(x, y, z, z_to)) {
staticMap[x][y][0] = 0;
staticMap[x][y][1] = 0;
staticMap[x][y][2] = 0;
continue;
}
if (x >= 0 && x < 19 && y >= 0 && y < 15) {
float dist;
dist = ((float)radius - sqrt(pow(x - lx, 2) + pow(y - ly, 2))) / 6.0f;
if (dist < 0.0f) dist = 0.0f;
else if (dist > 1.0f) dist = 1.0f;
int r = (int)(255.0f * dist * color.red);
int g = (int)(255.0f * dist * color.green);
int b = (int)(255.0f * dist * color.blue);
r = std::max(r, (int)staticMap[x][y][0]);
g = std::max(g, (int)staticMap[x][y][1]);
b = std::max(b, (int)staticMap[x][y][2]);
staticMap[x][y][0] = (unsigned char)r;
staticMap[x][y][1] = (unsigned char)g;
staticMap[x][y][2] = (unsigned char)b;
}
}
}
}
}
}
void Lights::UpdateDynamicLightMap(Map* map) {
LOCKCLASS lockClass1(Map::lockMap);
LOCKCLASS lockClass2(Tile::lockTile);
LOCKCLASS lockClass3(lockLights);
if (Game::adminOptions.fullLight)
return;
memset(&dynamicMap, 0, 19 * 15 * 3);
if (!map) {
Logger::AddLog("Lights::UpdateDynamicLightMap()", "Pointer to map is NULL!", LOG_WARNING);
return;
}
Position corner = map->GetCorner();
POINT pointZ = map->GetZ();
unsigned char z_from = pointZ.x;
unsigned char z_to = pointZ.y;
for (int z = z_from; z >= z_to; z--) {
int offset = z - corner.z;
LightsList::iterator it = dynamicLights.begin();
for (it; it != dynamicLights.end(); it++) {
Light* light = *it;
DynamicCreatureLight* creatureLight = dynamic_cast<DynamicCreatureLight*>(light);
DynamicDistanceLight* distanceLight = dynamic_cast<DynamicDistanceLight*>(light);
Position pos;
if (creatureLight && creatureLight->creature) pos = creatureLight->creature->pos;
else if (distanceLight && distanceLight->distance) pos = distanceLight->distance->pos;
if (light && pos.z == z) {
COLOR color = ConvertColorSTD(light->color);
unsigned char radius = light->level;
float px = 0.0f;
float py = 0.0f;
if (creatureLight) {
Creature* creature = creatureLight->creature;
if (creature->newPos == Position(0, 0, 0)) {
px = 32.0f * (creature->pos.x - creature->oldPos.x) * creature->GetStep();
py = 32.0f * (creature->pos.y - creature->oldPos.y) * creature->GetStep();
}
else {
px = 32.0f * (creature->newPos.x - creature->pos.x) * (1.0f - creature->GetStep());
py = 32.0f * (creature->newPos.y - creature->pos.y) * (1.0f - creature->GetStep());
}
}
else if (distanceLight) {
Distance* distance = distanceLight->distance;
int dx = (distance->newPos.x - distance->pos.x);
int dy = (distance->newPos.y - distance->pos.y);
float step = 1.0f - (float)(distance->GetMaxLiveTime() - distance->GetLiveTime()) / distance->GetMaxLiveTime();
px = 32.0f * ((float)(distance->pos.x - pos.x) + (float)dx * step);
py = 32.0f * ((float)(distance->pos.y - pos.y) + (float)dy * step);
}
float _lx = ((float)(pos.x - corner.x + offset + 1) * 32 + px);
float _ly = ((float)(pos.y - corner.y + offset + 1) * 32 + py);
int lx = (int)(_lx / 32);
int ly = (int)(_ly / 32);
float lx_off = (float)lx - (_lx / 32);
float ly_off = (float)ly - (_ly / 32);
int startX = lx - radius - 1;
int startY = ly - radius - 1;
int stopX = lx + radius + 1;
int stopY = ly + radius + 1;
if (startX < 0) startX = 0;
if (startY < 0) startY = 0;
if (stopX > 18) stopX = 18;
if (stopY > 14) stopY = 14;
for (int x = startX; x <= stopX; x++)
for (int y = startY; y <= stopY; y++) {
if (map->IsHiddenTile(x, y, z, z_to)) {
dynamicMap[x][y][0] = 0;
dynamicMap[x][y][1] = 0;
dynamicMap[x][y][2] = 0;
continue;
}
if (x >= 0 && x < 19 && y >= 0 && y < 15) {
float dist;
if (radius == 255)
dist = 1.0f;
else {
dist = ((float)radius - sqrt(pow((float)(x - lx) + lx_off, 2) + pow((float)(y - ly) + ly_off, 2))) / 6.0f;
if (dist < 0.0f) dist = 0.0f;
else if (dist > 1.0f) dist = 1.0f;
}
int r = (int)(255.0f * dist * color.red);
int g = (int)(255.0f * dist * color.green);
int b = (int)(255.0f * dist * color.blue);
r = std::max(r, (int)dynamicMap[x][y][0]);
g = std::max(g, (int)dynamicMap[x][y][1]);
b = std::max(b, (int)dynamicMap[x][y][2]);
dynamicMap[x][y][0] = (unsigned char)r;
dynamicMap[x][y][1] = (unsigned char)g;
dynamicMap[x][y][2] = (unsigned char)b;
}
}
}
}
}
}
void Lights::PrintLightMap(AD2D_Window* gfx, unsigned char z, float x, float y, float width, float height) {
LOCKCLASS lockClass(lockLights);
if (Game::adminOptions.fullLight)
return;
float ratio = (float)Game::options.ambientLight / 100;
int gR = (int)(ratio * 255);
int gG = (int)(ratio * 255);
int gB = (int)(ratio * 255);
if (z <= 7) {
COLOR global = ConvertColorSTD(globalColor);
gR = (int)(global.red * globalLevel * (1.0f - ratio) + ratio * 255);
gG = (int)(global.green * globalLevel * (1.0f - ratio) + ratio * 255);
gB = (int)(global.blue * globalLevel * (1.0f - ratio) + ratio * 255);
}
LightMap printMap;
for (int a = 0; a < 19; a++)
for (int b = 0; b < 15; b++) {
int cr = std::max(gR, (int)staticMap[a][b][0]);
int cg = std::max(gG, (int)staticMap[a][b][1]);
int cb = std::max(gB, (int)staticMap[a][b][2]);
cr = std::max(cr, (int)dynamicMap[a][b][0]);
cg = std::max(cg, (int)dynamicMap[a][b][1]);
cb = std::max(cb, (int)dynamicMap[a][b][2]);
printMap[a][b][0] = cr;
printMap[a][b][1] = cg;
printMap[a][b][2] = cb;
}
x -= width / 2;
y -= height / 2;
AD2D_Window::SetBlendFunc(BLEND_ZERO, BLEND_SRCCOLOR);
if (AD2D_Window::_mode == API_OPENGL) {
glDisable(GL_TEXTURE_2D);
glBegin(GL_QUADS);
for (int lx = 0; lx < 19 - 1; lx++)
for (int ly = 0; ly < 15 - 1; ly++) {
AD2D_Window::SetColor((float)printMap[lx][ly][0] / 255, (float)printMap[lx][ly][1] / 255, (float)printMap[lx][ly][2] / 255); glVertex2f(x + width * lx, y + height * ly);
AD2D_Window::SetColor((float)printMap[lx+1][ly][0] / 255, (float)printMap[lx+1][ly][1] / 255, (float)printMap[lx+1][ly][2] / 255); glVertex2f(x + width * lx + width, y + height * ly);
AD2D_Window::SetColor((float)printMap[lx+1][ly+1][0] / 255, (float)printMap[lx+1][ly+1][1] / 255, (float)printMap[lx+1][ly+1][2] / 255); glVertex2f(x + width * lx + width, y + height * ly + height);
AD2D_Window::SetColor((float)printMap[lx][ly+1][0] / 255, (float)printMap[lx][ly+1][1] / 255, (float)printMap[lx][ly+1][2] / 255); glVertex2f(x + width * lx, y + height * ly + height);
}
glEnd();
glEnable(GL_TEXTURE_2D);
}
else if (AD2D_Window::_mode == API_DIRECT3D) {
LPDIRECT3DDEVICE9 D3DDev = gfx->GetD3DDEV();
LPDIRECT3DVERTEXBUFFER9 D3DVB = gfx->GetD3DVB();
D3DDev->SetTexture(0, NULL);
COLOR currentColor = gfx->GetColor();
AD2D_Viewport currentViewport = gfx->GetCurrentViewport();
D3DCUSTOMVERTEX* pVertices;
D3DVB->Lock(0, (18 * 14) * 6 * sizeof(D3DCUSTOMVERTEX), (void**)&pVertices, 0);
int vNum = 0;
for (int lx = 0; lx < 19 - 1; lx++)
for (int ly = 0; ly < 15 - 1; ly++) {
pVertices[vNum++] = {currentViewport.startX + x + width * lx, currentViewport.startY + y + height * ly, 0.0f, 1.0f, D3DCOLOR_COLORVALUE((float)printMap[lx][ly][0] / 255, (float)printMap[lx][ly][1] / 255, (float)printMap[lx][ly][2] / 255, currentColor.alpha), 0.0f, 0.0f };
pVertices[vNum++] = {currentViewport.startX + x + width * lx + width, currentViewport.startY + y + height * ly, 0.0f, 1.0f, D3DCOLOR_COLORVALUE((float)printMap[lx+1][ly][0] / 255, (float)printMap[lx+1][ly][1] / 255, (float)printMap[lx+1][ly][2] / 255, currentColor.alpha), 0.0f, 0.0f };
pVertices[vNum++] = {currentViewport.startX + x + width * lx + width, currentViewport.startY + y + height * ly + height, 0.0f, 1.0f, D3DCOLOR_COLORVALUE((float)printMap[lx+1][ly+1][0] / 255, (float)printMap[lx+1][ly+1][1] / 255, (float)printMap[lx+1][ly+1][2] / 255, currentColor.alpha), 0.0f, 0.0f };
pVertices[vNum++] = {currentViewport.startX + x + width * lx, currentViewport.startY + y + height * ly, 0.0f, 1.0f, D3DCOLOR_COLORVALUE((float)printMap[lx][ly][0] / 255, (float)printMap[lx][ly][1] / 255, (float)printMap[lx][ly][2] / 255, currentColor.alpha), 0.0f, 0.0f };
pVertices[vNum++] = {currentViewport.startX + x + width * lx + width, currentViewport.startY + y + height * ly + height, 0.0f, 1.0f, D3DCOLOR_COLORVALUE((float)printMap[lx+1][ly+1][0] / 255, (float)printMap[lx+1][ly+1][1] / 255, (float)printMap[lx+1][ly+1][2] / 255, currentColor.alpha), 0.0f, 0.0f };
pVertices[vNum++] = {currentViewport.startX + x + width * lx, currentViewport.startY + y + height * ly + height, 0.0f, 1.0f, D3DCOLOR_COLORVALUE((float)printMap[lx][ly+1][0] / 255, (float)printMap[lx][ly+1][1] / 255, (float)printMap[lx][ly+1][2] / 255, currentColor.alpha), 0.0f, 0.0f };
}
D3DVB->Unlock();
D3DDev->DrawPrimitive(D3DPT_TRIANGLELIST, 0, vNum / 3);
}
AD2D_Window::SetBlendFunc(BLEND_SRCALPHA, BLEND_INVSRCALPHA);
}
| [
"czupryna.adam@gmail.com"
] | czupryna.adam@gmail.com |
87629e8b44d177f7ef08b97468d00144b569c868 | 3162f4403c90d190a5b014c1a07a37b649facf8a | /src/managers/font_manager.cpp | 255234ef62f383dcd26fd3b5a31d554078c8a84b | [] | no_license | bdajeje/Mario | e1fae57f54f55250095e319c4ddb6e59c992fcf7 | 435e73015e2430e663227a0fe7eb8074f5259fa1 | refs/heads/master | 2021-01-25T04:02:40.584574 | 2015-10-06T18:39:38 | 2015-10-06T18:39:38 | 42,530,572 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,091 | cpp | #include "font_manager.hpp"
#include "utils/filesystem/directory.hpp"
namespace font {
std::unique_ptr<FontManager> FontManager::_instance;
void FontManager::init(const std::string& font_directory)
{
if( _instance )
return;
_instance.reset( new FontManager(font_directory) );
}
FontManager::FontManager(const std::string& font_directory)
: _directory { utils::ensureDirectoryEndCopy(font_directory) }
{}
const sf::Font& FontManager::get(const std::string& font_file_path)
{
FontManager& instance = FontManager::instance();
// Find font
auto found_it = instance._fonts.find(font_file_path);
// Found, return it
if( found_it != instance._fonts.end() )
return found_it->second;
// Not already loaded, so load it then return it
return instance.loadFont(font_file_path);
}
const sf::Font& FontManager::loadFont(const std::string& font_file_path)
{
// Load font
sf::Font& font = _fonts[font_file_path];
if( !font.loadFromFile( _directory + font_file_path ) )
throw std::invalid_argument {"Can't load font: " + font_file_path};
return font;
}
}
| [
"jeremy.gousse@gmail.com"
] | jeremy.gousse@gmail.com |
011e03d5d2ce4af168f68938a6f8e4c3c7d8b758 | 904e33c8dc12cf527ad29ca51dee53339d2a0cb3 | /arduinos_comms good/sketch_dec12a/sketch_dec12a.ino | 49525879648421353c267d61edfe89c3cb9fa6dc | [] | no_license | DonHaul/SCDTR-Distributed-Lighting-Control | bddf1f5376c223b0c59e5b65eebe6c0d6e16dfbf | 4400e26df22138b1650c85e6d239d37f575e0b6c | refs/heads/master | 2021-10-11T00:00:54.049490 | 2019-01-19T13:13:15 | 2019-01-19T13:13:15 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 28,042 | ino | #include <Wire.h>
#define analogPin 1
#define n_iter 25
#define tamluxs 7
//Resistencia do circuito do LDR
#define r1 10000.0
#define rh 0.01
#define ZERO 200
long int lastMeasure = 0;
//ultimos 5 valores de luxs
float last_luxs[tamluxs];
unsigned long sampInterval = 10000; //10 milisecs
float declive = 0;
float lux_max = 0.0;
float lux_min = 0.0;
float K1, K2, Kp = 0.1, Ki = 38, b = 0.5, y, e , p, u, y_ant = 0, i_ant = 0, e_ant = 0, integ = 0;
float kself, kmutuo;
int ledpin = 9;
int raspberry_add = 100;
float luxs = 3;
int estado = 0;
float ref = 20.0;
//valor que se se encontrar a 1 quer dizer que não é preciso enviar a mesnagem para o rapberry
int central = 0;
int arduinos[1];
byte end_consensus[2] = {'z', 0};
int pin_verif = 2;
int address, address_aux;
long temp;
int flag = 0;
int flag_arduinos = 0;
int flag_cons = 0;
bool on = 0;
float ext_illum = 0;
float min_best[n_iter];
byte buffer[3] ;
byte serverMSG[4];
byte request[4];
//vetor de chars recebidos
byte inData[10];
byte inData1[10];
//System
float k11 = 0.67, k12 = 0.18, k21 = 0.01, k22 = 0.04;
float L1 = 30, o1 = 0, L2 = 30, o2 = 0;
float K[][2] = {{k11, k12}, {k21, k22}};
float L[][1] = {{L1}, {L2}};
float o[][1] = {{o1}, {o2}};
//Cost function
float c1 = 1, c2 = 1;
float c[] = {c1, c2};
float q1 = 1.0, q2 = 1.0;
float Q[][2] = {{q1, 0}, {0, q2}};
//Consensus variables
float rho = 0.15;
//node 1
float d1[] = {0, 0};
float d1_av[] = {0, 0};
float d_copy[] = {0, 0};
float y1[] = {0, 0};
float k1[] = {k11, k12};
//necessário? i think so
//node 2
float d2[] = {0, 0};
float d2_av[] = {0, 0};
float y2[] = {0, 0};
float k2[] = {k21, k22};
void setup()
{
Serial.begin(250000); // start serial for output
inData[0] = 42;
inData1[0] = 42;
inData1[1] = '\0';
inData[1] = '\0';
// define os endereços do arduino segundo o estado do pin
// define initial message to send to other arduinos
//esta linha passa a ser desnecessaria pois os valores dos k,L e o vão ser lidos/definidos
if (digitalRead(pin_verif) == HIGH)
{
address = 2;
address_aux = 1;
k11 = k22;
k12 = k21;
L1 = L2;
o1 = o2;
}
else
{
address = 1;
address_aux = 2;
}
K1 = Kp * b;
K2 = Kp * Ki * sampInterval / 2000000;
// formato da mensagem será '#-address-mensagetosend'it is currently used 1 byte per item, the mensage to send can be changed to type of data -value, or if it is knowned only the values
//aquando de receber a mesagem tranformar o valor de byte em inteiro int(buffer[2])
buffer[0] = '%';
buffer[1] = '0' + address;
buffer[2] = 123;
serverMSG[0] = '$';
serverMSG[2] = address;
Wire.begin(address); // join i2c bus (address optional for master)
Wire.onReceive(receiveEvent); // register event
Wire.beginTransmission(address_aux); // transmit to device
Wire.write("O");
Wire.endTransmission(); // stop transmitting
//Serial.println("SentData");
//example of how it should be read the message
//Serial.println(int(buffer[2]));
/*//inicializar o vector que contem valores lidos pelos ldr
for (int i=1;i<15;i++)
{
delay(35);
shift_left(calc_luxs( analogRead(analogPin)));
}*/
}
void loop()
{
if (flag > 0)
{
if (flag == 1)
{
Wire.beginTransmission(address_aux); // transmit to device #8
Wire.write("R"); // sends five bytes
Wire.endTransmission(); // stop transmitting
Serial.println("SentData");
calibrar1();
// start the consensus from the address 1
if (address == 1)
{
Serial.println("please w8 a few seconds for the consensus to be operational");
iteracao();
}
on = 1;
flag = 0;
} else if (flag == 2)
{
calibrar1();
// start the consensus from the address 1
if (address == 1)
{
Serial.println("please w8 a few seconds for the consensus to be operational");
iteracao();
//define tempo qd controlo acaba
//unsigned long endTime = micros();
}
on = 1;
flag = 0;
}
}
if (on)
{
unsigned long startTime = micros();
//transmit(buffer,address_aux);
//read messages that occur in the serial port
SerialInputs();
//define start time
// prob this is not the final example becuase we might need check the messages to send to the server and the consensus
if (flag == 3 && flag_cons == 0)
{
// Serial.println("data info");
if (inData[2] == ZERO)
inData[2] = 0;
if (inData[4] == ZERO)
inData[4] = 0;
// Serial.println("valores de d da iteração anterior");
//Serial.println(int(inData[1]));
// Serial.println(float(int(inData[2])/100));
//Serial.println(int(inData[1]));
//Serial.println(int(inData[4])/100);
/*
Serial.println("anterior");
Serial.println(d_copy[0]);
Serial.println("novo ");
Serial.println(inData[1] + inData[2] / 100.0);*/
if( (abs(d_copy[0]- (inData[1] +inData[2] / 100)) <1) && (abs(d_copy[1] - (inData[3] + inData[4] / 100))<1) && (d_copy[0]!=0)) || iter_cons == max_iter)
//if (int(d_copy[0]) - int(inData[1]) == 0 && int(d_copy[1]) - int(inData[3] == 0) && d_copy[0] != 0)
{
Serial.println("end consensus");
transmit(end_consensus, address_aux, 2);
flag_cons = 1;
flag = 0;
} else
{
iter_cons++;
/*
Serial.println("anterioir");
Serial.println(d_copy[0]);
Serial.println(d_copy[1]);*/
d_copy[0] = int(inData[1]) + int(inData[2]) / 100;
d_copy[1] = int(inData[3]) + int(inData[4]) / 100;
iteracao();
flag = 0;
/*
Serial.println("novo");
Serial.println(d_copy[0]);
Serial.println(d_copy[1]);*/
}
}
if (flag_cons )
{
startTime = micros();
controlo(L1);
if ( flag_arduinos == 4)
{
flag_arduinos = 0;
if (char(inData1[1]) == 's')
{
Serial.print("set room occupattion: ");
Serial.println(inData1[2]-'a');
if (estado != (inData1[2] - 'a'))
{
estado = inData1[2] - 'a' ;
if (estado == 1)
L1 = lux_max;
else
L1 = lux_min;
// indica ao programa que deverá ser recalculado o consensus enviar mensagem
flag_cons = 0;
flag = 0;
iteracao();
Serial.println("b4");
Serial.println(estado);
return;
}
} else {
switch (char(inData1[2]))
{
case 'o':
{
serverMSG[1] = 'o';
if (estado == 1)
serverMSG[3] = estado;
else
serverMSG[3] = ZERO;
serverMSG[4] = 0;
break;
}
//lower bound not sure what this is
case 'L':
{
serverMSG[1] = 'L';
serverMSG[3] = L1;
serverMSG[4] = 0;
break;
}
// background illuminace
case 'O':
{
serverMSG[1] = 'O';
serverMSG[3] = int(o1);
serverMSG[4] = int((o1-int(o1))*100);
serverMSG[4] = 0;
break;
}
//illuminace control referece
case 'r':
{
serverMSG[1] = 'L';
serverMSG[3] = int(L1);
serverMSG[4] = int((L1-int(L1))*100);
serverMSG[5] = 0;
break;
}
}
// confirmar o tamanho das coisas
//100 DUMMY ADDRESS for the rasp1 to sniff
transmit(serverMSG, address_aux, 12);
Serial.println(serverMSG[3]);
}
}
// confirmar o tamanho das coisas
//transmit(serverMSG,other_address,);
//measured luminance
unsigned long endTime = micros();
delayMicroseconds((sampInterval - (endTime - startTime)) / 2);
luxs = calc_luxs(analogRead(analogPin));
serverMSG[1] = '1';
serverMSG[3] = int(luxs);
serverMSG[4] = int((luxs - int(luxs)) * 100);
serverMSG[5] = 0;//parece fixe por um 0 no fim pq acaba a leitura NULL
transmit(serverMSG, address_aux, 6);
//espera o tempo necessario para passar 1 sampling interval
delayMicroseconds((sampInterval - (endTime - startTime)) / 2);
//duty cycle in percentage
serverMSG[1] = 'd';
serverMSG[3] = int(d_copy[address - 1]);
serverMSG[4] = int((d_copy[address - 1] - int(d_copy[address - 1])) * 100);
serverMSG[5] = 0;
transmit(serverMSG, address_aux, 6);
}
}
}
//função que calcula o valor de luxs
float calc_luxs(int val)
{
float R2;
float luxs;
float tensao;
//converte de 0-1023 para 0-5V
tensao = (5 * val) / 1023.0;
//equacao do divisor de tensao para obter resistencia R2
R2 = ((r1 * 5) / tensao) - r1;
//uso de reta logaritmica para converter de R para lux
luxs = ((log10(R2) - 4.8451) / -0.7186);
//luxs = ((log10(R2) - 4.5533) / -3.1576);
luxs = pow(10, luxs);
if (address == 2)
return 17 * luxs;
return 2 * luxs;
}
//verifica se arduino nao esta a mandar muita informação há algum tempo
//função que calibra ambos os leds dos arduinos
void calibrar()
{
if (address == 1)
{
digitalWrite(ledpin, HIGH);
}
else
{
digitalWrite(ledpin, LOW);
}
delay(5000);
Serial.println(calc_luxs(analogRead(analogPin)));
if ( address == 2)
{
digitalWrite(ledpin, HIGH);
}
else
{
digitalWrite(ledpin, LOW);
}
delay(5000);
Serial.println(calc_luxs(analogRead(analogPin)));
}
// function that executes whenever data is received from master
// this function is registered as an event, see setup()
void receiveEvent(int howMany)
{
int index = 1;
int start = 0;
//string de data recebida
String input;
byte aux = 42;
byte garbage;
while (Wire.available() > 0) { // loop through all but the last
if (aux == '$')
{
garbage = Wire.read();
continue;
}
if (start == 0)
{
aux = Wire.read(); //Read a character
start = 1;
continue;
}
if (aux == '#')
{
inData1[index] = Wire.read();
index++; // Increment where to write next
inData1[index] = '\0'; // Null terminate the string
}
else
{
inData[index] = Wire.read();
index++; // Increment where to write next
inData[index] = '\0'; // Null terminate the string
}
}
//Serial.println("ReceivedData");
//Serial.println(inData);
//Serial.println(index);
// Serial.println(size(howMany))
if (aux == 'O')
{ //se recebi um O, reenvio um R e calibro
Serial.println("O");
flag = 1;
}
else if (aux == 'R')
{
Serial.println("R");
flag = 2;
}
// significa que o consensus do outro nó acabou e que este device deverá ser os novos comandos e calcular novos valores
else if (aux == '%')
{
flag = 3;
flag_cons=0;
}
// significa que este arduino deverá enviar informação para o raspberry
else if (aux == '#')
{
//achoq ue é melhor separar as flags para não interromper o consensus
flag_arduinos = 4;
// Serial.println("indata ")
/*
for (int i = 0; i < 10; i++)
{
inData1[i] = inData[i];
}*/
// inData[1] = 'l';
// Serial.println(inData1[1]);
} else if (aux == 'z')
{
flag = 0;
flag_cons = 1;
}
//significa que este é o arduino que esta a receber os valor totais para fazer a soma T potencia conforto e n me lembro o que é mais
/* else if (inData[0] == '$')
{
//flag_calc = 1 ;
}*/
}
void calibrar1()
{
Serial.println("CalibFunc");
analogWrite(ledpin, 0);
delay(200);
analogWrite(ledpin, 255);
delay(200);
analogWrite(ledpin, 0);
delay(200);
if (address == 1)
{
analogWrite(ledpin, 255);
}
else
{
analogWrite(ledpin, 0);
}
delay(500);
if (address == 1)
{
kself = (calc_luxs(analogRead(analogPin))) / 100.0;
Serial.print("valor de luxs calculado: ");
Serial.println(calc_luxs(analogRead(analogPin)));
Serial.println(analogRead(analogPin));
}
else
{
kmutuo = (calc_luxs(analogRead(analogPin))) / 100.0;
Serial.print("valor de luxs calculado: ");
Serial.println(calc_luxs(analogRead(analogPin)));
Serial.println(analogRead(analogPin));
}
delay(500);
if (address == 2)
{
analogWrite(ledpin, 255);
}
else
{
analogWrite(ledpin, 0);
}
delay(500);
if (address == 2)
{
kself = (calc_luxs(analogRead(analogPin))) / 100.0;
Serial.print("valor de luxs calculado: ");
Serial.println(calc_luxs(analogRead(analogPin)));
Serial.println(analogRead(analogPin));
}
else
{
kmutuo = (calc_luxs(analogRead(analogPin))) / 100.0;
Serial.print("valor de luxs calculado: ");
Serial.println(calc_luxs(analogRead(analogPin)));
Serial.println(analogRead(analogPin));
}
delay(500);
analogWrite(ledpin, 0);
delay(500);
o1 = calc_luxs(analogRead(analogPin));
Serial.println(kself);
Serial.println(kmutuo);
k11 = kself;
declive = 255 / (k11 * 100);
k12 = kmutuo;
Serial.println(k11);
Serial.println(k12);
Serial.println(k11+k12);
Serial.println(200*(k11+k12));
Serial.println((200*(k11+k12))/3);
//lux_max = 170 / declive;
//lux_min = 85 / declive;
//achei que se notava pouco a diferenca na luminusidade por isso repensei nos limites
lux_max = (300 *(k11+k12))/4;
lux_min = (100 *(k11+k12))/4;
Serial.println(lux_max);
Serial.println(lux_min);
L1 = lux_min;
}
void iteracao()
{
float z11, z12;
float mini = 0;
//node 1
float d11_best = -1;
float d12_best = -1;
float min_best_1 = 100000;
float sol_unconstrained = 1, sol_boundary_linear = 1, sol_boundary_0 = 1, sol_boundary_100 = 1;
float sol_linear_0 = 1, sol_linear_100 = 1;
/*
if(address == 2)
{
// node2_change(y[1],y[0]);
float temp;
temp = y1[0];
y1[0] = y1[1];
y1[1] = temp;
temp = d1_av[0];
d1_av[0] = d1_av[1];
d1_av[1] = temp;
// node2_change(d1_av[1],d1_av[0]);
}
*/
/*
Serial.print(d1_av[0]);
Serial.print(" ");
Serial.println(d1_av[1]);
Serial.print(y1[0]);
Serial.print(" ");
Serial.println(y1[1]);*/
z11 = -c1 - y1[0] + rho * d1_av[0];
z12 = -y1[1] + rho * d1_av[1];
/*
Serial.print(z11);
Serial.print(" ");
Serial.println(z12);
*/
float u1 = o1 - L1;
float u2 = 0;
float u3 = 100;
float p11 = 1 / (rho + q1);
float p12 = 1 / rho;
float n = k11 * k11 * p11 + k12 * k12 * p12;
float w1 = -k11 * p11 * z11 - k12 * z12 * p12;
float w2 = -z11 * p11;
float w3 = z11 * p11;
//compute unconstrained minimum
float d11u = p11 * z11;
float d12u = p12 * z12;
//guardar valores
float best_d11[50];
float best_d12[50] ;
//check feasibility of unconstrained minimum using local constraints
if (d11u < 0)
{
sol_unconstrained = 0;
}
if (d11u > 100)
{
sol_unconstrained = 0;
}
if (k11 * d11u + k12 * d12u < L1 - o1)
{
sol_unconstrained = 0;
}
//compute function value and if best store new optimum
if (sol_unconstrained)
{
mini = 0.5 * q1 * sq(d11u) + c1 * d11u + y1[0] * (d11u - d1_av[0]) + y1[1] * (d12u - d1_av[1]) + rho / 2 * sq(d11u - d1_av[0]) + rho / 2 * sq(d12u - d1_av[1]);
if (mini < min_best_1)
{
d11_best = d11u;
d12_best = d12u;
min_best_1 = mini;
}
}
/*
Serial.print("unconstrained value : ");
Serial.print(mini);
Serial.println(d11_best);
*/
//compute minimum constrained to linear boundary
float d11bl = p11 * z11 + p11 * k11 / n * (w1 - u1);
float d12bl = p12 * z12 + p12 * k12 / n * (w1 - u1);
//check feasibility of minimum constrained to linear boundary
if (d11bl < 0)
{
sol_boundary_linear = 0;
}
if (d11bl > 100)
{
sol_boundary_linear = 0;
}
//compute function value and if best store new optimum
if (sol_boundary_linear)
{
mini = 0.5 * q1 * sq(d11bl) + c1 * d11bl + y1[0] * (d11bl - d1_av[0]) + y1[1] * (d12bl - d1_av[1]) + rho / 2 * sq(d11bl - d1_av[0]) + rho / 2 * sq(d12bl - d1_av[1]);
if (mini < min_best_1)
{
d11_best = d11bl;
d12_best = d12bl;
min_best_1 = mini;
}
}
// Serial.print("boundary_linear: ");
// Serial.print(mini);
//Serial.println(d11_best);
//compute minimum constrained to boundary
float d11b0 = 0;
float d12b0 = p12 * z12;
//check feasibility of minimum constrained to 0 boundary
//aqui alguma coisa estranha
if (d11b0 > 100)
{
sol_boundary_0 = 0;
}
if (k11 * d11b0 + k12 * d12b0 < L1 - o1)
{
sol_boundary_0 = 0;
}
//compute function value and if the best store new optimum
if (sol_boundary_0)
{
mini = 0.5 * q1 * sq(d11b0) + c1 * d11b0 + y1[0] * (d11b0 - d1_av[0]) + y1[1] * (d12b0 - d1_av[2]) + rho / 2 * sq(d11b0 - d1_av[0]) + rho / 2 * sq(d12b0 - d1_av[1]);
if (mini < min_best_1)
{
d11_best = d11b0;
d12_best = d12b0;
min_best_1 = mini;
}
}
//Serial.print("min_boundary: ");
// Serial.print(mini);
// Serial.println(d11_best);
//compute minimum constrained to 100 boundary
float d11b100 = 100;
float d12b100 = p12 * z12;
//check feasibility of minimum constrained to 100 boundary
if (d11b0 < 0)
{
sol_boundary_100 = 0;
}
if (k11 * d11b100 + k12 * d12b100 < L1 - o1)
{
sol_boundary_100 = 0;
}
//compute function value and if best store new optimum
if (sol_boundary_100)
{
mini = 0.5 * q1 * sq(d11b100) + c1 * d11b100 + y1[0] * (d11b100 - d1_av[0]) + y1[1] * (d12b100 - d1_av[1]) + rho / 2 * sq(d11b100 - d1_av[0]) + rho / 2 * sq(d12b100 - d1_av[1]);
if (mini < min_best_1)
{
d11_best = d11b100;
d12_best = d12b100;
min_best_1 = mini;
}
}
//Serial.print("min_boundary100: ");
//Serial.print(mini);
//Serial.println(d11_best);
//compute minimum constrained to linear and zero boundary
float common = (rho + q1) / ((rho + q1) * n - k11 * k11); //ou float?
float det1 = common;
float det2 = -k11 * common;
float det3 = det2;
float det4 = n * (rho + q1) * common;
float x1 = det1 * w1 + det2 * w2;
float x2 = det3 * w1 + det4 * w2;
float v1 = det1 * u1 + det2 * u2; //u2 = 0 so this can be simplified
float v2 = det3 * u1 + det4 * u2; //u2 = 0 so this can be simplified
float d11l0 = p11 * z11 + p11 * k11 * (x1 - v1) + p11 * (x2 - v2);
float d12l0 = p12 * z12 + p12 * k12 * (x1 - v1);
//check feasibility
if (d11l0 > 100)
{
sol_linear_0 = 0;
}
//compute function value and if best store new optimum
if (sol_linear_0)
{
mini = 0.5 * q1 * sq(d11l0) + c1 * d11l0 + y1[0] * (d11l0 - d1_av[0]) + y1[1] * (d12l0 - d1_av[1]) + rho / 2 * sq(d11l0 - d1_av[0]) + rho / 2 * sq(d12l0 - d1_av[1]);
// Serial.print("valmin_linear_0: ");
//Serial.println(mini);
if (mini < min_best_1)
{
d11_best = d11l0;
d12_best = d12l0;
min_best_1 = mini;
}
}
//Serial.print("min_linear_0: ");
//Serial.print(mini);
//Serial.println(d11_best);
//compute minimum constrained to linear and 100 boundary
common = (rho + q1) / ((rho + q1) * n - k11 * k11); //ou float?
det1 = common;
det2 = k11 * common;
det3 = det2;
det4 = n * (rho + q1) * common;
x1 = det1 * w1 + det2 * w3;
x2 = det3 * w1 + det4 * w3;
v1 = det1 * u1 + det2 * u3;
v2 = det3 * u1 + det4 * u3;
float d11l100 = p11 * z11 + p11 * k11 * (x1 - v1) - p11 * (x2 - v2);
float d12l100 = p12 * z12 + p12 * k12 * (x1 - v1);
//check feasibility
if (d11l100 < 0)
{
sol_linear_100 = 0;
}
//compute function value and if best store new optimum
if (sol_linear_100)
{
float mini = 0.5 * q1 * sq(d11l100) + c1 * d11l100 + y1[0] * (d11l100 - d1_av[0]) + y1[1] * (d12l100 - d1_av[1]) + rho / 2 * sq(d11l100 - d1_av[0]) + rho / 2 * sq(d12l100 - d1_av[1]);
if (mini < min_best_1)
{
d11_best = d11u;
d12_best = d12u;
min_best_1 = mini;
}
}
//Serial.print("min_linear_100");
//Serial.print(mini);
// Serial.println(d11_best);
//store data and save for next cycle
//best_d11[i] = d11_best;
//best_d12[i] = d12_best;
float d1[] = {};
d1[0] = d11_best;
d1[1] = d12_best;
/*
if(address == 2)
{
// node2_change(y[1],y[0]);
// node2_change(d1_av[1],d1_av[0]);
temp = y1[1];
y1[1] = y1[2];
y1[2] = temp;
temp = d1_av[1];
d1_av[1] = d1_av[2];
d1_av[2] = temp;
}*/
//compute average with available knowledge
d1_av[0] = (d1[0] + d_copy[0]) / 2;
d1_av[1] = (d1[1] + d_copy[1]) / 2;
//update local lagrangian
y1[0] = y1[0] + rho * (d1[0] - d1_av[0]);
y1[1] = y1[1] + rho * (d1[1] - d1_av[1]);
//send node 1 solution to neighboors
//d1_copy = d1;
//dunno if this works
// Serial.print(y1[0]);
// Serial.print(" y1/2 ");
//Serial.println(y1[1]);
//Serial.print(d1_av[0]);
//Serial.print(" d1_av ");
//Serial.println(d1_av[1]);
d_copy[0] = d1[0];
d_copy[1] = d1[1];
//mensagem a enviar é o d1_copy cada um dos nós processará de forma diferente
//os valores de d1 vêem em float por isso o que vou fazer é transformar esse valor em dois bytes 16-> 65536 valor maximo transmitido
// o que vamos fazer aqui é usar os 5 digitos que temos para representar em que vamos ter 2 para parte inteira e 2 decimal
// a outra hipotese é usar 255 e usar apenas uma casa decimal mas acho mal não suficiente
buffer[1] = int(d1[1]);
buffer[2] = int((d1[1] - int(d1[1])) * 100);
/*Serial.print("valor float ");
Serial.println(buffer[2]);*/
if (buffer[2] == 0)
{
buffer[2] = ZERO;
}
buffer[3] = int(d1[0]);
buffer[4] = int((d1[0] - int(d1[0])) * 100);
if (buffer[4] == 0)
{
buffer[4] = ZERO;
}
buffer[5] = 0;
//set's up the mensage to send to the other node
// Serial.println("data calculate, results presented below: will take 3-4s to reach other device informations that follows is whole value, int part decimal part");
// Serial.println("self");
//Serial.println(d1[0]);
// Serial.println(buffer[1]);
//Serial.println(buffer[2]);
// Serial.println("other");
// Serial.println(d1[1]);
// Serial.println(buffer[3]);
// Serial.println(buffer[4]);
//analogWrite(ledpin, d1[0]);
// Serial.print("leitura de luxs actuais ");
// Serial.println(calc_luxs(analogRead(analogPin)));
//delay(200);
//transmitir a informação necessária para que o outro arduino comele um novo ciclo do consensus
transmit(buffer, address_aux, 6);
}
void transmit(byte * message, int address_dest, int tamanho)
{
Wire.beginTransmission(address_dest); // transmit to device #8
Wire.write(message, tamanho); // sends five bytes
Wire.endTransmission(); // stop transmitting
//Serial.println("SentData");
}
void SerialInputs()
{
int index = 0;
//string de data recebida
String input;
//vetor de chars recebidos
char rpiData[10] = "";
//se utilizador escreveu algo
if (Serial.available() > 0)
{
//le o que o utilizador escreveu
while (Serial.available() > 0)
{
if (index < 9) // One less than the size of the array
{
rpiData[index] = Serial.read(); //Read a character
index++; // Increment where to write next
rpiData[index] = '\0'; // Null terminate the string
}
}
//converte vetor de chars em string
input = String(rpiData);
switch (rpiData[0])
{
case 'g':
{
request[0] = '#';
request[1] = address;//address à qual todos os arduinos devem responder para que se faça os calculo de totais
request[2] = rpiData[1];
Serial.println(rpiData[1]);
request[3] = 0;
if (address == rpiData[2] - 'a')
{
flag_arduinos = 4;
for (int i = 0; i < 10; i++)
inData1[i] = request[i];
} else
{
Serial.println("msg to onther arduino g case");
transmit(request, rpiData[2] - 'a', 4);
}
break;
}
case 's':
{
request[0] = '#';
request[1] = 's';
request[2] = rpiData[1];
request[3] = 0;
if (address == rpiData[2] - 'a')
{
flag_arduinos = 4;
for (int i = 0; i < 10; i++)
inData1[i] = request[i];
} else
transmit(request, rpiData[2] - 'a', 4);
break;
}
case 'r':
{
delay(1000);
Serial.println("we are goint to reset the system pls w8 a few seconds whiel recalibration occcurs");
Wire.beginTransmission(address_aux); // transmit to device
Wire.write("O");
Wire.endTransmission();
// verificar
flag = 2;
on = 0;
}
}
}
}
void recta_luxs()
{
analogWrite(ledpin, 200);
delay(1000);
float luxs = 0;
luxs = calc_luxs(analogRead(analogPin));
/*Serial.print(calc_luxs(analogRead(analogPin)));
Serial.print(' ');
Serial.println(200); */
declive = 200 / luxs;
//Serial.println(declive);
delay(1000);
}
void shift_left(float current_luxs)
{
last_luxs[lastMeasure % tamluxs] = current_luxs;
lastMeasure++;
}
//função que calcula a média dos luxs
float average()
{
float somatodos = 0;
int i;
//soma todos os valores
for (i = 0; i < tamluxs; i++)
{
somatodos += last_luxs[i];
}
//retorna a média
return somatodos / tamluxs;
}
//funcao onde e controlado a luminosidade do led atraves de feedforward e feedback (com antiwindup)
void controlo(float reference)
{
float usat = 0;
float wind;
float pwm;
//lê pino e obtem luxs
shift_left(calc_luxs( analogRead(analogPin)));
//faz a media dos ultimos lux
y = average();
//calcula erro em relacao a referencia ilum_min
e = reference - y;
//obtem parte proporcional
p = K1 * reference - Kp * y;
//obtem parte integral
integ = i_ant + K2 * (e + e_ant);
//descobre valor led
u = p + integ;
//parte do windud
usat = u;
/*
if (u > lookUp[255])
{
usat = lookUp[255];
}else if (u< lookUp[0])
{
usat = lookUp[0];
}*/
if (u > 255 / declive)
{
usat = 255 / declive;
} else if (u < 0)
{
usat = 0;
}
//apenas e diferentde de 0 se estiver saturado
wind = usat - u;
//adicionar a proxima iteracao integradora o anti windup para o sistema nao integrar bue
integ += wind * K2 * 1.5;
//procura valor na lookup table
// pwm = search (u);
// pwm = declive * u ;
/*
//write to pin pwm, if feedforward is on add that as well
if (FFD == true)
//analogWrite(led, search(reference + u));
analogWrite(led, declive * (reference + u));
else
analogWrite(led, pwm);*/
//write to pin pwm, if feedforward is on add that as well
pwm = (declive * u) + d1[0] * 255 / 100;
if (pwm < 0)
pwm = 0;
if (pwm > 255)
pwm = 255;
analogWrite(ledpin, pwm);
//faz set das variaveis para o proximo loop
y_ant = y;
i_ant = integ;
e_ant = e;
//prints pedidos pelo prof
//Serial.print(reference);
// Serial.print(" ; ");
//Serial.println(average());
// Serial.print(" ; ");
/*//if (FFD == true)
// Serial.print(((search(reference+u))/255)* 100);
//Serial.print(((declive*(reference+u))/255)* 100);
//else
Serial.print((pwm/255)* 100);
Serial.println(" %");
Serial.println(u);*/
//Serial.print("pwmvalue : ");
//Serial.println(pwm);
}
| [
"jpedroboavida@hotmail.com"
] | jpedroboavida@hotmail.com |
ce243f97d65a313aec1514b752e0c6148e3ca7fe | 5456502f97627278cbd6e16d002d50f1de3da7bb | /cc/layers/draw_properties.h | 26f226d74904384954996bcf95aa25213d676f64 | [
"BSD-3-Clause"
] | permissive | TrellixVulnTeam/Chromium_7C66 | 72d108a413909eb3bd36c73a6c2f98de1573b6e5 | c8649ab2a0f5a747369ed50351209a42f59672ee | refs/heads/master | 2023-03-16T12:51:40.231959 | 2017-12-20T10:38:26 | 2017-12-20T10:38:26 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,108 | h | // Copyright 2012 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef CC_LAYERS_DRAW_PROPERTIES_H_
#define CC_LAYERS_DRAW_PROPERTIES_H_
#include <stddef.h>
#include <memory>
#include "cc/trees/occlusion.h"
#include "ui/gfx/geometry/rect.h"
#include "ui/gfx/transform.h"
namespace cc {
// Container for properties that layers need to compute before they can be
// drawn.
struct CC_EXPORT DrawProperties {
DrawProperties();
~DrawProperties();
// Transforms objects from content space to target surface space, where
// this layer would be drawn.
gfx::Transform target_space_transform;
// Transforms objects from content space to screen space (viewport space).
gfx::Transform screen_space_transform;
// Known occlusion above the layer mapped to the content space of the layer.
Occlusion occlusion_in_content_space;
// DrawProperties::opacity may be different than LayerImpl::opacity,
// particularly in the case when a RenderSurface re-parents the layer's
// opacity, or when opacity is compounded by the hierarchy.
float opacity;
// xxx_is_animating flags are used to indicate whether the DrawProperties
// are actually meaningful on the main thread. When the properties are
// animating, the main thread may not have the same values that are used
// to draw.
bool screen_space_transform_is_animating;
// True if the layer needs to be clipped by clip_rect.
bool is_clipped;
// This rect is a bounding box around what part of the layer is visible, in
// the layer's coordinate space.
gfx::Rect visible_layer_rect;
// In target surface space, the rect that encloses the clipped, drawable
// content of the layer.
gfx::Rect drawable_content_rect;
// In target surface space, the original rect that clipped this layer. This
// value is used to avoid unnecessarily changing GL scissor state.
gfx::Rect clip_rect;
};
} // namespace cc
#endif // CC_LAYERS_DRAW_PROPERTIES_H_
| [
"lixiaodonglove7@aliyun.com"
] | lixiaodonglove7@aliyun.com |
ef42d6e397ceee9e070c71efe4f34ed81e6767d8 | 637e9521c59327f93ca40e76c7d293f2abeb8592 | /Domain/User_Accounts/UserList.h | 67e047fc20b41f28f5a78be9ec5d39c15ee233c5 | [] | no_license | priyankasharma6/Schedule-Management-System | 4927ab875e871d9c3bed4806804e954e6de04f8c | cde4f6b27bb798c3e88576c3dad8ac0f40a6a8fb | refs/heads/master | 2022-11-15T23:35:03.742066 | 2020-06-29T22:25:32 | 2020-06-29T22:25:32 | 275,938,874 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 918 | h | #pragma once
#include <iostream>
#include <vector>
#include <set> //???
#include <map>
#include "AuthenticationAndAccountHandler.h"
#include "EmployeeAccount.h"
namespace Domain::User_Accounts
{
//A class that represents a list of users
class UserList : public Domain::User_Accounts::AuthenticationAndAccountHandler
{
public:
using AuthenticationAndAccountHandler::AuthenticationAndAccountHandler;
UserList();
virtual ~UserList() {}
int authenticate(std::string username, std::string password) override;
std::map<std::string, EmployeeAccount> getEmployeeList();
void addEmployee(std::string newUsername, EmployeeAccount newEmployee) override;
void deleteEmployee(std::string employeeName) override;
void printEmployeeList() override;
Domain::Notifications::NotificationList* getEmpNotes(std::string username) override;
private:
std::map<std::string, EmployeeAccount> employeeList;
};
}
| [
"p6.priyankasharma@gmail.com"
] | p6.priyankasharma@gmail.com |
a7fe97b2c10f004ab959aa846cfbf2ffd90578e6 | 792ad26fd812df30bf9a4cc286cca43b87986685 | /水/POJ 1068 Parencodings 水.cpp | f78093bcd7859614513c11f10a814c1f20891448 | [] | no_license | Clqsin45/acmrec | 39fbf6e02bb0c1414c05ad7c79bdfbc95dc26bf6 | 745b341f2e73d6b1dcf305ef466a3ed3df2e65cc | refs/heads/master | 2020-06-18T23:44:21.083754 | 2016-11-28T05:10:44 | 2016-11-28T05:10:44 | 74,934,363 | 0 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 754 | cpp | #include <iostream>
#include <stack>
#include <stdio.h>
using namespace std;
int a[44], c[22];
stack<int> s;
int main(void)
{
int t, now, n, i, top;
cin>>t;
while(t--)
{
cin>>n;
for( i = 1; i <= n; i++) cin>>c[i];
now = 1; top = 0;
for(i = 1; i <= 2 * n;)
{
while(i - now + 1 <= c[now])
a[i ++ ] = 0;
a[i++] = 1; now++;
}
for(i = 1; i <= 2 * n; i++)
{
if(!a[i]) s.push(i);
else
{
int st = s.top();
s.pop();
printf("%d%c",(i - st + 1) / 2, i != 2 * n ? ' ' : '\n');
}
}
}
return 0;
}
| [
"someway.bit@gmail.com"
] | someway.bit@gmail.com |
bbec4d9b66d395540d60d533268ffb6f26cf996b | 9d48363a6125dce5a5def1ac148c4a5bd678ae3b | /Sourcecode/private/mx/core/elements/Sign.h | 922e3ec66e510b2e8c5da53e82f1b42f0d4d4d7f | [
"MIT"
] | permissive | rphaeh/mx | 4cac321c5b55ce657e07e2e6ed01f0d8cd045757 | cdf1c97c5ebffaa81de5db77cfc6d2b06b9a94fb | refs/heads/master | 2021-10-26T00:36:24.084974 | 2019-04-09T00:11:04 | 2019-04-09T00:11:04 | 198,191,333 | 2 | 0 | null | 2019-07-22T09:30:20 | 2019-07-22T09:30:20 | null | UTF-8 | C++ | false | false | 1,403 | h | // MusicXML Class Library
// Copyright (c) by Matthew James Briggs
// Distributed under the MIT License
#pragma once
#include "mx/core/ForwardDeclare.h"
#include "mx/core/ElementInterface.h"
#include "mx/core/Enums.h"
#include <iosfwd>
#include <memory>
#include <vector>
namespace mx
{
namespace core
{
MX_FORWARD_DECLARE_ELEMENT( Sign )
inline SignPtr makeSign() { return std::make_shared<Sign>(); }
inline SignPtr makeSign( const ClefSign& value ) { return std::make_shared<Sign>( value ); }
inline SignPtr makeSign( ClefSign&& value ) { return std::make_shared<Sign>( std::move( value ) ); }
class Sign : public ElementInterface
{
public:
Sign();
Sign( const ClefSign& value );
virtual bool hasAttributes() const;
virtual bool hasContents() const;
virtual std::ostream& streamAttributes( std::ostream& os ) const;
virtual std::ostream& streamName( std::ostream& os ) const;
virtual std::ostream& streamContents( std::ostream& os, const int indentLevel, bool& isOneLineOnly ) const;
ClefSign getValue() const;
void setValue( const ClefSign& value );
private:
virtual bool fromXElementImpl( std::ostream& message, xml::XElement& xelement );
private:
ClefSign myValue;
};
}
}
| [
"matthew.james.briggs@gmail.com"
] | matthew.james.briggs@gmail.com |
fd95dc9da5d85a1ebaa0e7c1beee6e9b54692bb7 | 3a9d2216e91fe6b374866d697c108a79ebfc79d8 | /spj/172c.cpp | 812638eab1630b283fee56b1ab2ce0e25169d612 | [] | no_license | UllioBra/Duipai | 3b65d0766d07273221ec3cfb4014be37bcc89c6d | 1c768ca586b0659840e35a42b8ec8a8486ec7e06 | refs/heads/master | 2020-04-02T02:58:26.535831 | 2018-11-03T01:26:08 | 2018-11-03T01:26:08 | 153,938,816 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,211 | cpp | #include <algorithm>
#include <iostream>
#include <cstring>
#include <cstdio>
#include <cmath>
#include <queue>
#include <stack>
#include <list>
#include <set>
#include <map>
#define ll long long
#define ull unsigned long long
#define ci const int&
#define cl const long long&
#define cul const unsigned long long&
#define io_f std::ios::sync_with_stdio(false)
using namespace std;
int n, m, k;
int arr[10010];
string a;
int main() {
cin >> n >> m >> k;
for (int i = 1; i <= m; i++)
cin >> arr[i];
cin >> a;
if (a[0] == '-') {
cout << 1;
return 0;
}
int sum = 0;
int le = a.size();
for (int i = 1; i <= m; i++)
if (a[m-1] == '0') {
cout << -1;
return 0;
}
for (int i = 1; i <= le; i++)
if (a[i-1] == '1') {
sum++;
if (sum > k) {
cout << -1;
return 0;
}
for (int j = i + 1; j <= le; j++)
if (a[j-1] == '1') {
if (a[(i|j)-1] == '0') {
cout << -1;
return 0;
}
}
}
cout << 1;
return 0;
} | [
"3131367211@qq.com"
] | 3131367211@qq.com |
3dc541ad7cd1ebfafbc747ef8e52d9aa8c9775e6 | 108c2b4b662962786d1f727831251790d8d38162 | /src/somadicom/Dicom/MonochromeImage.h | 91cbd256cf6ea8e8692c4b244e99c22af758529d | [
"LicenseRef-scancode-cecill-b-en"
] | permissive | brainvisa/soma-io | 105adbaccc5f06d6773ee894f30baec35c48a403 | d22e9d27f6e0696e234a6e33f7fbd9fa4620adc1 | refs/heads/master | 2023-08-04T18:46:57.728163 | 2023-07-28T16:53:08 | 2023-07-28T16:53:08 | 155,413,952 | 3 | 4 | NOASSERTION | 2023-07-28T16:53:09 | 2018-10-30T15:55:17 | C++ | UTF-8 | C++ | false | false | 537 | h | #ifndef _MonochromeImage_h_
#define _MonochromeImage_h_
#ifdef SOMA_IO_DICOM
#include <soma-io/Dicom/ImagePixel.h>
#else
#include <Dicom/ImagePixel.h>
#endif
namespace dcm
{
template < typename T >
class MonochromeImage : public ImagePixel
{
public:
MonochromeImage( DicomProxy& proxy );
void fill( Parameters& parameters,
OffsetParameters& offsetParameters,
void* imagePtr,
int32_t z,
int32_t t,
int32_t inputSlice = 0 );
};
}
#endif
| [
"FPoupon@users.noreply.github.com"
] | FPoupon@users.noreply.github.com |
5d4cc1a933a6c9c879c4ce845017a2fdda88e8b7 | 9f730bf91dc97735ebc3941d53743a44743c4b91 | /LexicalAnalyzer.cpp | 4d20daf00e470474ab488a78d62762578921d862 | [] | no_license | dot-operator/ISPCompiler | 562c24c56b564900ce3af067758a0881c79f22c1 | 733fc6ddb190b6610c96feba82ddb20d57d0cf0b | refs/heads/master | 2020-04-15T20:06:11.380161 | 2020-03-11T06:18:35 | 2020-03-11T06:18:35 | 164,979,206 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 6,597 | cpp | //
// LexicalAnalyzer.cpp
// ISPCompiler
//
// Created by Sullivan Boyd on 1/9/19.
// Copyright © 2019 Sullivan Boyd. All rights reserved.
//
#include "LexicalAnalyzer.hpp"
#include <iostream>
#include <fstream>
#include <set>
const std::set<string> keywords = {
"auto", "break", "case", "char", "const", "continue", "default",
"do", "double", "else", "enum", "extern", "float", "for", "goto",
"if", "inline", "int", "long", "register", "restrict", "return",
"short", "signed", "sizeof", "static", "struct", "switch", "typedef", "union",
"unsigned", "void", "volatile", "while", "_Alignas", "_Alignof", "_Atomic",
"_Bool", "_Complex", "_Generic", "_Imaginary", "_Noreturn", "_Static_assert", "_Thread_local"
};
const std::set<string> punctuators = {
"[", "]", "(", ")", "{", "}", ".", "->",
"++", "--", "&", "*", "+", "-", "~", "!",
"/", "%", "<<", ">>", "<", ">", "<=", ">=", "==", "!=", "^", "|", "&&", "||",
"?", ":", ";", "...",
"=", "*=", "+=", "-=", "/=", "%=", "<<=", ">>=", "^=", "&=", "|=",
",", "#", "##",
"<:", ":>", "<%", "%>", "%:", "%:%:"
};
void LexicalAnalyzer::loadFile(const string& filePath) {
std::ifstream file(filePath);
if(!file){
std::cout << "Unable to open " << filePath << "\n";
exit(-1);
}
string line;
while(std::getline(file, line)){
// Strip single-line comments before starting anything else
if(line.find("//") != line.npos){
line = line.substr(0, line.find("//"));
}
source += line + "\n";
}
file.close();
sourcePos = source.begin();
}
char LexicalAnalyzer::nextChar(){
lastColumn = curColumn;
lastPos = sourcePos;
if(sourcePos != source.end()){
if((*sourcePos) == '\n'){
lastLine = curLine++;
curColumn = 0;
}
else ++curColumn;
return *sourcePos++;
}
else return '\0';
}
char LexicalAnalyzer::curChar(){
if(sourcePos != source.end())
return *sourcePos;
else return '\0';
}
bool LexicalAnalyzer::hasNext(){
while(sourcePos != source.end() && iswspace(*sourcePos)){
nextChar();
}
if(sourcePos != source.end()){
return true;
}
return false;
}
void LexicalAnalyzer::backOne(){
curLine = lastLine;
curColumn = lastColumn;
sourcePos = lastPos;
}
Token LexicalAnalyzer::makeNumber(){
string str;
bool hadDecimal = false;
for(char c = nextChar(); isNumberChar(c); c=nextChar()){
str += c;
if(c == '.'){
if(!hadDecimal){
hadDecimal = true;
continue;
}
else {
error("Expected a digit in float constant.", getCurrent());
}
}
}
backOne();
Token tok;
Constant constant;
if(hadDecimal){
constant.type = Constant::Float;
constant.attribute = std::stof(str);
}
else {
constant.type = Constant::Int;
constant.attribute = std::stoi(str);
}
tok.type = Token::Tok_Constant;
tok.attribute = constant;
return tok;
}
Token LexicalAnalyzer::makeChar(){
nextChar();
char c = nextChar();
if(c == '\'')
error("Expected an alphanumeric character in char constant.", getCurrent());
Token token;
token.type = Token::Tok_Constant;
Constant constant;
constant.type = Constant::Char;
constant.attribute = c;
token.attribute = constant;
if(nextChar() != '\'')
error("Closing single quote expected at end of char constant.", getCurrent());
return token;
}
Token LexicalAnalyzer::makeString(){
string str;
nextChar();
for(char c = nextChar(); c != '"'; c = nextChar()){
if(c == '\n'){
error("String literal may not contain newline (use \n instead).", getCurrent());
}
str += c;
}
Token token;
token.type = Token::Tok_String;
token.attribute = str;
return token;
}
bool LexicalAnalyzer::isIdentifierChar(char c){
if(isalnum(c) || c == '_')
return true;
return false;
}
bool LexicalAnalyzer::isPunctuatorChar(char c){
if(isIdentifierChar(c) || iswspace(c))
return false;
return true;
}
Token LexicalAnalyzer::makeIdentifier(){
// Build attribute
string str;
for(char c = nextChar(); isIdentifierChar(c); c = nextChar()){
str += c;
if(!isIdentifierChar(curChar()))
break;
}
Token tok;
tok.attribute = str;
// Check if it's a keyword
if(keywords.find(str) != keywords.end()){
tok.type = Token::Tok_Keyword;
return tok;
}
tok.type = Token::Tok_Identifier;
return tok;
}
bool LexicalAnalyzer::isPunctuatorValid(const string &s){
if(punctuators.find(s) != punctuators.end())
return true;
return false;
}
Token LexicalAnalyzer::makePunctuator(){
string str;
str += nextChar();
for(char c = curChar(); isPunctuatorChar(c) && isPunctuatorValid(str + c); c = nextChar()){
str += c;
}
Token token;
token.attribute = str;
token.type = Token::Tok_Punctuator;
if(punctuators.find(str) != punctuators.end()){
return token;
}
// We get here if nothing else worked.
error(str + " is not a recognized token.", getCurrent());
exit(-1);
}
Token LexicalAnalyzer::getCurrent(){
return current;
}
Token LexicalAnalyzer::getNext(){
Token t;
t.posSource = (unsigned)std::distance(source.begin(), sourcePos);
if(!hasNext())
return Token();
char c =curChar();
while(iswspace(c)){
nextChar();
c = curChar();
}
if(c == '\0'){
return Token();
}
// Numeric constant
else if(isdigit(c)){
t = makeNumber();
}
// String literal
else if(c == '"'){
t = makeString();
}
else if(c == ('\'')){
t = makeChar();
}
// Try keywords and identifiers.
else if(isalpha(c) || c == '_')
t = makeIdentifier();
// Finally, try to find a punctuator.
else t = makePunctuator();
t.posLine = curLine;
t.posColumn = curColumn;
current = t;
return t;
}
void LexicalAnalyzer::error(const string &msg, Token token){
std::cerr << "Error: " << msg << "\nAt line ";
std::cerr << token.posLine << ", " << token.posColumn << std::endl;
exit(-1);
}
LexicalAnalyzer::LexicalAnalyzer() {
}
LexicalAnalyzer::~LexicalAnalyzer(){
}
| [
"sullivan.h.boyd9@gmail.com"
] | sullivan.h.boyd9@gmail.com |
d0fc5eed784c5200911b17f45d7d4cd8ae8722f9 | 3b04925b4271fe921020cff037b86e4a5a2ae649 | /windows_embedded_ce_6_r3_170331/WINCE600/PRIVATE/TEST/NET/NDIS/NDT/LIB/objectlist.h | dc1f0bdd0abd343429b6b361e4560ad8ad4b5e86 | [] | no_license | fanzcsoft/windows_embedded_ce_6_r3_170331 | e3a4d11bf2356630a937cbc2b7b4e25d2717000e | eccf906d61a36431d3a37fb146a5d04c5f4057a2 | refs/heads/master | 2022-12-27T17:14:39.430205 | 2020-09-28T20:09:22 | 2020-09-28T20:09:22 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,360 | h | //
// Copyright (c) Microsoft Corporation. All rights reserved.
//
//
// Use of this source code is subject to the terms of the Microsoft shared
// source or premium shared source license agreement under which you licensed
// this source code. If you did not accept the terms of the license agreement,
// you are not authorized to use this source code. For the terms of the license,
// please see the license agreement between you and Microsoft or, if applicable,
// see the SOURCE.RTF on your install media or the root of your tools installation.
// THE SOURCE CODE IS PROVIDED "AS IS", WITH NO WARRANTIES.
//
#ifndef __OBJECT_LIST_H
#define __OBJECT_LIST_H
//------------------------------------------------------------------------------
#include "Object.h"
//------------------------------------------------------------------------------
class CObjectList
{
private:
CObject* m_pHead;
CObject* m_pTail;
CRITICAL_SECTION m_cs;
public:
CObjectList();
~CObjectList();
void AddTail(CObject *pObject);
void AddHead(CObject *pObject);
CObject *GetHead();
CObject *GetNext(CObject *pObject);
void Remove(CObject *pObject);
void EnterCriticalSection();
void LeaveCriticalSection();
};
//------------------------------------------------------------------------------
#endif
| [
"benjamin.barratt@icloud.com"
] | benjamin.barratt@icloud.com |
7f81235d7e6dfae8def71be6bfaeb3f36a114f61 | 2f5f33ee1b3d2f61275b778632a5ff0c74293be8 | /Projects/Editor/Source/Editor/Space/Scene/CSpaceScene.h | 7c3b457a684681d95e30597bfa72da0763e9e8c0 | [
"MIT"
] | permissive | brucelevis/skylicht-engine | 69ae84838a7931dab3c205ee54a567176504ef99 | db9b28dbe022ea9b25a327813721408bd2eebb4f | refs/heads/master | 2023-04-04T16:37:19.277275 | 2021-04-06T17:05:24 | 2021-04-06T17:05:24 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,385 | h | /*
!@
MIT License
CopyRight (c) 2020 Skylicht Technology CO., LTD
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.
This file is part of the "Skylicht Engine".
https://github.com/skylicht-lab/skylicht-engine
!#
*/
#pragma once
#include "SkylichtEngine.h"
#include "Editor/Space/CSpace.h"
namespace Skylicht
{
namespace Editor
{
class CSpaceScene : public CSpace
{
protected:
CScene* m_scene;
CCamera* m_editorCamera;
IRenderPipeline* m_renderRP;
CGameObject* m_gridPlane;
bool m_leftMouseDown;
bool m_rightMouseDown;
bool m_middleMouseDown;
float m_mouseX;
float m_mouseY;
public:
CSpaceScene(GUI::CWindow* window, CEditor* editor);
virtual ~CSpaceScene();
void initDefaultScene();
virtual void onResize(float w, float h);
virtual void onRender(GUI::CBase* base);
virtual void onMouseMoved(GUI::CBase* base, float x, float y, float deltaX, float deltaY);
virtual void onLeftMouseClick(GUI::CBase* base, float x, float y, bool down);
virtual void onRightMouseClick(GUI::CBase* base, float x, float y, bool down);
virtual void onMiddleMouseClick(GUI::CBase* base, float x, float y, bool down);
virtual void onMouseWheeled(GUI::CBase* base, int wheel);
virtual void update();
bool isEditorObject(CGameObject* object);
protected:
void postMouseEventToScene(EMOUSE_INPUT_EVENT eventType, float x, float y);
};
}
} | [
"hongduc.pr@gmail.com"
] | hongduc.pr@gmail.com |
6f20605c6e994eb11c26e6c2dcdba70e7b998384 | 3ce9d794dae46e35b3ebbbd179438a27a3d985a0 | /CodeChef/December Challenge/WATSCORE.cpp | 474f13d89fffcfb342f251fc81bf705208ba22d2 | [] | no_license | samirharry/Programacion-Competitiva | e87a8d97859237f70ea19b965678e53a66a9bbb0 | df2e5d367c325959a5e086ce59bb87b8a1fdb90c | refs/heads/master | 2021-07-17T07:43:05.398525 | 2020-08-16T20:35:12 | 2020-08-16T20:35:12 | 197,270,076 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 556 | cpp | #include <bits/stdc++.h>
#define debug(x) cout << #x << " => " << x << endl;
#define debugArray(x, n) \
for (ll i = 0; i < n; i++) \
cout << #x << "[" << i << " => " << x[i] << endl;
using namespace std;
typedef long long ll;
int main()
{
ll t;
cin >> t;
while (t--)
{
ll n;
cin >> n;
ll answ = 0;
ll scores[11] = {0};
while (n--)
{
ll p, s;
cin >> p >> s;
scores[p - 1] = max(scores[p - 1], s);
}
for (ll i = 0; i < 8; i++)
answ += scores[i];
cout << answ << endl;
}
return 0;
} | [
"shuamanp@uni.pe"
] | shuamanp@uni.pe |
9bd0961f21643484fddae37e17ac65989e3c759f | 7c756503671c172f52ce687ed412f2347b00ed43 | /hog/laplacian.h | aa0b9c6efce90bb86aa0353ff0f572775b0c91a4 | [] | no_license | gaoooyuk/APCS | 0f1a0362c4fa097d34801fc5a4df4c0dba8174b4 | 81e9ba97f040c12c4e25fb388eb5c0912c356b45 | refs/heads/master | 2021-01-13T02:08:00.717464 | 2014-09-04T07:47:51 | 2014-09-04T07:47:51 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 348 | h | #ifndef LAPLACIAN_H
#define LAPLACIAN_H
#include <QObject>
#include <opencv2/imgproc/imgproc.hpp>
class Laplacian : public QObject
{
Q_OBJECT
public:
explicit Laplacian(QObject *parent = 0);
cv::Mat compute(cv::Mat &src);
private:
int m_kernel_size;
int m_scale;
int m_delta;
int m_ddepth;
};
#endif // LAPLACIAN_H
| [
"chuckgao.cg@gmail.com"
] | chuckgao.cg@gmail.com |
e3ead9843d359d19bba1171bd22754fb5216aa6d | c9132c7334e757ed600d5c5964add531ac257c34 | /ADSL/Assignment1.cpp | f57b760c645899cf2982bb9c430082565539cf01 | [] | no_license | nikhil16kulkarni/SPPU-SEM4-Computer-Engineering | 13c36e99a3041b3a19520e6f8b5baac388b7ec69 | 23385526edf2938d3b3173d153675e2bc3126324 | refs/heads/master | 2022-05-24T05:41:53.705206 | 2020-04-29T16:09:38 | 2020-04-29T16:09:38 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 13,382 | cpp | //============================================================================
// Name : Assignment1.cpp
// Author : Nikhil Kulkarni
// Version :
// Copyright : Your copyright notice
// Description : Hello World in C++, Ansi-style
//============================================================================
#include <iostream>
#include<bits/stdc++.h>
#define MAX 100
using namespace std;
class Node{
int data;
Node* lchild;
Node* rchild;
friend class Tree;
// friend class Tree;
friend class Queue;
friend class Stack;
public:
Node(){
data=0;
lchild=rchild=NULL;
}
Node(int x){
data=x;
lchild=rchild=NULL;
}
};
class Stack
{
int top;
Node *data[MAX];
public:
Stack()
{ top=-1; }
void push(Node *p)
{
if(!full())
data[++top]=p;
else
cout<<"Full\n";
}
Node *pop()
{
if(!empty())
return data[top--];
else
return NULL;
}
bool empty()
{
if(top==-1)
return true;
return false;
}
bool full()
{
if(top==MAX-1)
return true;
return false;
}
};
class Queue
{
Node *data[MAX];
int front,rear;
public:
Queue()
{
front=rear=-1;
}
void push(Node*);
Node * pop();
bool empty();
bool full();
Node* first();
};
void Queue::push(Node *p)
{
if(!full())
{
if(empty())
{
front=0;
}
rear=(rear+1)%MAX;
data[rear]=p;
}
}
Node * Queue::pop()
{
if(!empty())
{
Node *p=data[front];
if(front==rear)
{
front=rear=-1;
}
else
{
front=(front+1)%MAX;
}
return p;
}
else
return NULL;
}
bool Queue::empty()
{
if(rear==-1)
return 1;
return 0;
}
bool Queue::full()
{
if(front==(rear+1)%MAX)
return 1;
return 0;
}
Node* Queue::first()
{
return data[front];
}
class Tree{
Node *root;
public:
Tree(){
root=NULL;
}
void createnr();//Non-Recursive(Not Completed) ----> Completed
Node* creater();//Recursive
// Node* insert(Node*);
void inorderr(Node*);//Recursive
void preorderr(Node*);//Recursive
void postorderr(Node*);//Recursive
Node* get_root();
void set_root();
void inordernr();//Non Recursive
void preordernr();//Non Recursive
void postordernr();//Non Recursive
void deletenode(Node*);
Node* copy(Node*);
void operator=(Tree &);
int equality(Node*,Node*);//Not Completed ----> Completed
void create_mirror(Tree);
Node* mirror(Node*,Node*);
int internalnodes(Node*);//Not Completed ----> Completed
int leafnodes(Node*);//Not Completed ----> Completed
void print();//Not Completed ----> Completed
};
void Tree::deletenode(Node *p){
if(p!=NULL){
deletenode(p->lchild);
deletenode(p->rchild);
delete(p);
}
}
void Tree::createnr()
{
Queue obj;
Node *p=NULL;
int x;
if(root==NULL)
{
cout<<"Enter Data or -1 to STOP\n";
cin>>x;
if(x==-1)
return;
root=new Node(x);
obj.push(root);
}
p=root;
while(!obj.empty())
{
p=obj.pop();
cout<<"Enter Left of "<<p->data<<" OR -1 \n";
cin>>x;
if(x!=-1)
{
p->lchild=new Node(x);
obj.push(p->lchild);
}
cout<<"Enter Right of "<<p->data<<" OR -1 \n";
cin>>x;
if(x!=-1)
{
p->rchild=new Node(x);
obj.push(p->rchild);
}
}//end of while
}
void Tree::preordernr()
{
cout<<"PREORDER TRAVERSAL\n";
Stack S;
Node *p=root;
S.push(p);
while(!S.empty())
{
p=S.pop();
cout<<p->data<<"\t";
if(p->rchild!=NULL)
S.push(p->rchild);
if(p->lchild!=NULL)
S.push(p->lchild);
}
cout<<"\n";
}
void Tree::inordernr()
{
cout<<"INORDER TRAVERSAL\n";
Stack S;
Node *p=root;
while(p!=NULL)
{
S.push(p);
p=p->lchild;
}
while(!S.empty())
{
p=S.pop();
cout<<p->data<<"\t";
p=p->rchild;
while(p!=NULL)
{
S.push(p);
p=p->lchild;
}
}
cout<<"\n";
}
void Tree::postordernr()
{
cout<<"POSTORDER TRAVERSAL\n";
Stack S1,S2;
Node *p=root;
S1.push(p);
while(!S1.empty())
{
p=S1.pop();
S2.push(p);
if(p->lchild!=NULL)
S1.push(p->lchild);
if(p->rchild!=NULL)
S1.push(p->rchild);
}
while(!S2.empty())
{
p=S2.pop();
cout<<p->data<<"\t";
}
cout<<"\n";
}
/*void Tree::createnr(){
queue q;
Node* t;
int x;
cout<<"\nEnter root ";
cin>>x;
root=new Node(x);
q.push(root);
while(!q.isempty())
{
t=q.pop();
cout<<"Enter left data of "<<t->data<<" or -1 for exit ";
cin>>x;
if(x!=-1)
{
t->lchild=new Node(x);
q.push(t->lchild);
}
cout<<"Enter right data of "<<t->data<<" or -1 for exit ";
cin>>x;
if(x!=-1)
{
t->rchild=new Node(x);
q.push(t->rchild);
}
}
}*/
Node* Tree::creater(){
int x;
cout<<"Enter data else enter -1\n";
cin>>x;
if(x==-1){ return NULL; }
else{
Node* p=new Node(x);
p->data=x;
cout<<"Enter data of left child of "<<x<<endl;;
p->lchild=creater();
cout<<"Enter data of right child of"<<x<<endl;
p->rchild=creater();
return p;
}
}
void Tree::set_root(){
root=creater();
}
Node* Tree::get_root(){
return root;
}
//Node* Tree::insert(Node* t,int x){
// Node* p;
// int lr;
// if(t==NULL){
// p=new Node(x);
// return p;
// }
// else{
// cout<<"Where do you want to insert on left or right(l/r)\n";
// cin>>lr;
// if(lr=='l'||lr=='L') t->lchild=insert(t->lchild,x);
// else t->rchild=insert(t->rchild,x);
// return t;
// }
//}
//Node* Tree::insert(Node* root)
//{
// Node* p = new Node(x);
// Node* r = root;
// Node* y = NULL;
//
// while (r != NULL) {
//
// y = r;
// if (x < r->x)
// r = r->lchild;
// else
// r = r->rchild;
// }
//
//
// if (y == NULL)
// y = new Node;
//
// else if (x < y->x)
// y->lchild = new Node;
//
//
// else
// y->rchild = new Node;
//
//
// return y;
//}
void Tree::inorderr(Node* t){
if(t!=NULL){
inorderr(t->lchild);
cout<<t->data<<"\t";
inorderr(t-> rchild);
}
}
void Tree::preorderr(Node* t){
if(t!=NULL){
cout<<t->data<<"\t";
preorderr(t->lchild);
preorderr(t->rchild);
}
}
void Tree::postorderr(Node* t){
if(t!=NULL){
postorderr(t->lchild);
postorderr(t->rchild);
cout<<t->data<<"\t";
}
}
/*void Tree::inordernr(Node* t){
stack a;
Node* p=root;
while(1)
{
while(p!=NULL)
{
a.push(p);
p=p->lchild;
}
if(a.isempty())
return;
p=a.pop();
cout<<p->data<<"\t";
p=p->rchild;
}
}
void Tree::preordernr(Node* t){
stack a;
Node* p=root;
while(1)
{
while(p!=NULL)
{
cout<<p->data<<"\t";
if(p->rchild!=NULL)
a.push(p->rchild);
p=p->lchild;
}
if(a.isempty())
return;
p=a.pop();
}
}
void Tree::postordernr(Node* t){
stack a;
stack b;
Node* p=root;
Node *k,*l;
a.push(p);
while(!a.isempty())
{
k=a.pop();
b.push(k);
if(k->lchild!=NULL)
a.push(k->lchild);
if(k->rchild!=NULL)
a.push(k->rchild);
}
while(!b.isempty())
{
l=b.pop();
cout<<l->data<<"\t";
}
}*/
Node* Tree::copy(Node*t){
Node* n;
n=NULL;
if(t!=NULL){
n=new Node(t->data);
n->lchild=copy(t->lchild);
n->rchild=copy(t->rchild);
}
return n;
}
void Tree::operator=(Tree &t){
root=copy(t.root);
}
/*void Tree::leafnodes(Node* p)
{
if(!p)
return;
if(!p->lchild && !p->rchild)
{
cout<<p->data<<" ";
return;
}
if(p->lchild)
leafnodes(p->lchild);
if(p->rchild)
leafnodes(p->rchild);
}*/
void Tree::print(){
int c;
cout<<"Internal Nodes is/are\n";
c=internalnodes(root);
cout<<"\nNo.of Internal Nodes is/are "<<c<<"\n";
cout<<"\nLeaf Nodes is/are\n";
c=leafnodes(root);
cout<<"\nNo.of Leaf Nodes is/are "<<c<<"\n";
}
int Tree::internalnodes(Node* p)
{ //cout<<"Internal Nodes are\n";
if(p==NULL)
return 0;
if(p->lchild==NULL&&p->rchild==NULL)
return 0;
else
{
int l,r;
cout<<p->data<<" ";
l=internalnodes(p->lchild);
r=internalnodes(p->rchild);
return 1+l+r;
}
}
int Tree::leafnodes(Node* p){
if(p==NULL)
return 0;
if(p->lchild==NULL&&p->rchild==NULL)
{
cout<<p->data<<" ";
return 1;
}
else
{
return leafnodes(p->lchild)+leafnodes(p->rchild);
}
}
void Tree::create_mirror(Tree T)
{
root=mirror(root,T.root);
}
Node* Tree::mirror(Node* p,Node *q)
{
if(q==NULL)
return NULL;
else
{
p=new Node(q->data);
p->lchild=mirror(p->lchild,q->rchild);
p->rchild=mirror(p->rchild,q->lchild);
return p;
}
}
int Tree::equality(Node* p,Node* q)
{
if(q==NULL&&p==NULL)
{
return true;
}
if(p==NULL||q==NULL)
{
return false;
}
Queue q1,q2;
q1.push(q);
q2.push(p);
while(!q1.empty()&&!q2.empty())
{
Node* n1=q1.first();
Node* n2=q2.first();
if(n1->data!=n2->data)
{
return false;
}
q1.pop();
q2.pop();
if(n1->lchild&&n2->lchild)
{
q1.push(n1->lchild);
q2.push(n2->lchild);
}
else if(n1->lchild||n2->lchild)
{
return false;
}
if(n1->rchild&&n2->rchild)
{
q1.push(n1->rchild);
q2.push(n2->rchild);
}
else if(n1->rchild||n2->rchild)
{
return false;
}
}
return true;
}
/*Node* Tree::copy(Node* t)
{
Node* temp;
temp=NULL;
if(t!=NULL)
{
temp=new Node(t->data);
temp->lchild=copy(t->lchild);
temp->rchild=copy(t->rchild);
}
return temp;
}
void Tree::operator = (Tree t)
{
root=copy(t.root);
}*/
int main() {
int a;
char yn;
Tree t,t1,obj,obj1,obj2,Mir;
Node *l,*p;
// Node* p=new Node();
do{
cout<<"1.Enter Tree Recursive\n2.Enter Tree Non-Recursive\n3.Delete All Nodes\n4.Copy the given tree\n5.Find Mirror Image\n6.Find Internal & Leaf Nodes\n7.Check if given tree is equal or not\n";
cin>>a;
switch(a){
case 1: t.set_root();
p=t.get_root();
cout<<"Inorder Traversal :"<<endl;
t.inorderr(p);
cout<<endl;
cout<<"Preorder Traversal :"<<endl;
t.preorderr(p);
cout<<endl;
cout<<"Postorder Traversal :"<<endl;
t.postorderr(p);
cout<<endl;
break;
/*case 2: p=t.get_root();
t.inorderr(p);
break;
case 3: p=t.get_root();
t.preorderr(p);
break;
case 4: p=t.get_root();
t.postorderr(p);
break;*/
case 2: t.createnr();
t.inordernr();
t.preordernr();
t.postordernr();
break;
/* case 6: t.inordernr(p);
break;
case 7: t.preordernr(p);
break;
case 8: t.postordernr(p);
break; */
case 3: cout<<"Deleting all the nodes\n";
t.deletenode(p);
break;
case 4:cout<<"Copying.....\n";
t1=t;
cout<<"Tree Copied\nNow Printing the copied Tree using Inorder Traversal\n";
t1.inorderr(p);
break;
case 5:
cout<<"Mirror Image of Tree is\n";
Mir.create_mirror(t);
Mir.inordernr();
Mir.preordernr();
Mir.postordernr();
break;
/* case 6:cout<<"Find Leaf Nodes";
p=obj.get_root();
obj.leafnodes(p);
cout<<endl;
break; */
case 6://cout<<"Find Internal Nodes";
p=t.get_root();
t.print();
break;
case 7: cout<<"Enter First Tree\n";
obj.set_root();
l=obj.get_root();
cout<<"Enter Second Tree\n";
obj1.set_root();
p=obj1.get_root();
if(obj2.equality(l,p))
cout<<"\nBoth trees are equal ";
else
cout<<"\nBoth trees are not equal ";
break;
default: cout<<"Incorrect choice entered :\n";
}
cout<<"\nDo you want to continue(y/n)? ";
cin>>yn;
}while(yn=='y'||yn=='Y');
}
/* INORDER NON-RECURSIVE ALGO
1
/ \
2 3
/ \
4 5
Step 1 Creates an empty stack: S = NULL
Step 2 sets current as address of root: current -> 1
Step 3 Pushes the current node and set current = current->left until current is NULL
current -> 1
push 1: Stack S -> 1
current -> 2
push 2: Stack S -> 2, 1
current -> 4
push 4: Stack S -> 4, 2, 1
current = NULL
Step 4 pops from S
a) Pop 4: Stack S -> 2, 1
b) print "4"
c) current = NULL (right of 4) and go to step 3
Since current is NULL step 3 doesn't do anything.
Step 4 pops again.
a) Pop 2: Stack S -> 1
b) print "2"
c) current -> 5 (right of 2) and go to step 3
Step 3 pushes 5 to stack and makes current NULL
Stack S -> 5, 1
current = NULL
Step 4 pops from S
a) Pop 5: Stack S -> 1
b) print "5"
c) current = NULL (right of 5) and go to step 3
Since current is NULL step 3 doesn't do anything
Step 4 pops again.
a) Pop 1: Stack S -> NULL
b) print "1"
c) current -> 3 (right of 5)
Step 3 pushes 3 to stack and makes current NULL
Stack S -> 3
current = NULL
Step 4 pops from S
a) Pop 3: Stack S -> NULL
b) print "3"
c) current = NULL (right of 3)
Traversal is done now as stack S is empty and current is NULL.
*/
/* PREORDER NON-RECURSIVE ALGO
1) Create an empty stack nodeStack and push root node to stack.
2) Do following while nodeStack is not empty.
….a) Pop an item from stack and print it.
….b) Push right child of popped item to stack
….c) Push left child of popped item to stack
*/
/* POSTORDER NON-RECURSIVE ALGO
1.1 Create an empty stack
2.1 Do following while root is not NULL
a) Push root's right child and then root to stack.
b) Set root as root's left child.
2.2 Pop an item from stack and set it as root.
a) If the popped item has a right child and the right child
is at top of stack, then remove the right child from stack,
push the root back and set root as root's right child.
b) Else print root's data and set root as NULL.
2.3 Repeat steps 2.1 and 2.2 while stack is not empty.
*/
| [
"noreply@github.com"
] | nikhil16kulkarni.noreply@github.com |
2b40294407441051cac6baf9469b2f3dd3e25bf2 | 2935ad7aa5ea981ad4e961f4c50a1d11094e33c0 | /examples/NodeMCU_mqtt_DHT11/NodeMCU_mqtt_DHT11.ino | 1be80947fbf6ce8cb5020883b5a322bbe3e1c386 | [] | no_license | yvesniyo/arduino | 9e7bf3bf60043169cbb710b993bb82c3371f3ab2 | be05ab9846d17a83f928a31cca77dcecf735bde0 | refs/heads/master | 2020-04-23T04:37:28.319213 | 2019-02-15T05:24:59 | 2019-02-15T05:24:59 | 170,913,161 | 2 | 0 | null | 2019-02-15T18:53:47 | 2019-02-15T18:53:47 | null | UTF-8 | C++ | false | false | 4,199 | ino | /*
Basic ESP8266 MQTT example
This sketch demonstrates the capabilities of the pubsub library in combination
with the ESP8266 board/library.
It connects to an MQTT server then:
- publishes "hello world" to the topic "outTopic" every two seconds
- subscribes to the topic "inTopic", printing out any messages
it receives. NB - it assumes the received payloads are strings not binary
- If the first character of the topic "inTopic" is an 1, switch ON the ESP Led,
else switch it off
It will reconnect to the server if the connection is lost using a blocking
reconnect function. See the 'mqtt_reconnect_nonblocking' example for how to
achieve the same result without blocking the main loop.
To install the ESP8266 board, (using Arduino 1.6.4+):
- Add the following 3rd party board manager under "File -> Preferences -> Additional Boards Manager URLs":
http://arduino.esp8266.com/stable/package_esp8266com_index.json
- Open the "Tools -> Board -> Board Manager" and click install for the ESP8266"
- Select your ESP8266 in "Tools -> Board"
*/
#include <ESP8266WiFi.h>
#include <PubSubClient.h>
#include "DHT.h"
#define DHTPIN 12 // NodeMCU pin D6 connected to DHT11 pin Data
#define DHTTYPE DHT11 // DHT 11
DHT dht(DHTPIN, DHTTYPE, 15);
// Update these with values suitable for your network.
const char* ssid = "Kuo";
const char* password = "0972211921";
//const char* mqtt_server = "broker.mqtt-dashboard.com";
const char* mqtt_server = "192.168.0.12";
const char* outTopic = "NTOUEE-AIOT";
const char* inTopic = "NTOUEE-AIOT";
WiFiClient espClient;
PubSubClient client(espClient);
long lastMsg = 0;
char msg[50];
int value = 0;
void setup_wifi() {
delay(10);
// We start by connecting to a WiFi network
Serial.println();
Serial.print("Connecting to ");
Serial.println(ssid);
WiFi.begin(ssid, password);
while (WiFi.status() != WL_CONNECTED) {
delay(500);
Serial.print(".");
}
randomSeed(micros());
Serial.println("");
Serial.println("WiFi connected");
Serial.println("IP address: ");
Serial.println(WiFi.localIP());
}
void callback(char* topic, byte* payload, unsigned int length) {
Serial.print("Message arrived [");
Serial.print(topic);
Serial.print("] ");
for (int i = 0; i < length; i++) {
Serial.print((char)payload[i]);
}
Serial.println();
// Switch on the LED if an 1 was received as first character
if ((char)payload[0] == '1') {
digitalWrite(BUILTIN_LED, LOW); // Turn the LED on (Note that LOW is the voltage level
// but actually the LED is on; this is because
// it is acive low on the ESP-01)
} else {
digitalWrite(BUILTIN_LED, HIGH); // Turn the LED off by making the voltage HIGH
}
}
void reconnect() {
// Loop until we're reconnected
while (!client.connected()) {
Serial.print("Attempting MQTT connection...");
// Create a random client ID
String clientId = "ESP8266Client-";
clientId += String(random(0xffff), HEX);
// Attempt to connect
if (client.connect(clientId.c_str())) {
Serial.println("connected");
// Once connected, publish an announcement...
client.publish(outTopic, "DHT11 reporting");
// ... and resubscribe
client.subscribe(inTopic);
} else {
Serial.print("failed, rc=");
Serial.print(client.state());
Serial.println(" try again in 5 seconds");
// Wait 5 seconds before retrying
delay(5000);
}
}
}
void setup() {
pinMode(BUILTIN_LED, OUTPUT); // Initialize the BUILTIN_LED pin as an output
Serial.begin(115200);
dht.begin();
delay(10);
setup_wifi();
client.setServer(mqtt_server, 1883);
client.setCallback(callback);
}
void loop() {
if (!client.connected()) {
reconnect();
}
client.loop();
long now = millis();
if (now - lastMsg > 2000) {
lastMsg = now;
++value;
float h = dht.readHumidity();
float t = dht.readTemperature();
char h_str[6];
char t_str[6];
sprintf(msg, "Temp=%s, Humidity=%s", dtostrf(t, 4, 2, t_str), dtostrf(h, 4, 2, h_str));
Serial.print("Publish message: ");
Serial.println(msg);
client.publish(outTopic, msg);
delay(1000);
}
}
| [
"noreply@github.com"
] | yvesniyo.noreply@github.com |
7694716bb00a3cdcda9da0f26442a850b9a4fb3e | 47c222923048b6afe534a8de89d92d8821cb8d28 | /ComS327GameProject/GameProject/object.cpp | 3850b362b9178200fc5b6f5fa4c0756d4483cdfb | [] | no_license | Henry-Kansanback/ComS2019 | 83e0024d913181ef578762777cbb82f8eed3af4a | 95253a901cd1e477217ef8a3fa2436a89c46d432 | refs/heads/main | 2023-04-08T10:26:02.167117 | 2021-04-15T15:05:44 | 2021-04-15T15:05:44 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,353 | cpp | #include <vector>
#include <cstring>
#include "object.h"
#include "dungeon.h"
#include "utils.h"
object::object(object_description &o, pair_t p, object *next) :
name(o.get_name()),
description(o.get_description()),
type(o.get_type()),
color(o.get_color()),
damage(o.get_damage()),
hit(o.get_hit().roll()),
dodge(o.get_dodge().roll()),
defence(o.get_defence().roll()),
weight(o.get_weight().roll()),
speed(o.get_speed().roll()),
attribute(o.get_attribute().roll()),
value(o.get_value().roll()),
seen(false),
next(next),
od(o)
{
position[dim_x] = p[dim_x];
position[dim_y] = p[dim_y];
od.generate();
}
object::~object()
{
od.destroy();
if (next) {
delete next;
}
}
void gen_object(dungeon *d)
{
object *o;
uint32_t room;
pair_t p;
std::vector<object_description> &v = d->object_descriptions;
int i;
do {
i = rand_range(0, v.size() - 1);
} while (!v[i].can_be_generated() || !v[i].pass_rarity_roll());
room = rand_range(0, d->num_rooms - 1);
do {
p[dim_y] = rand_range(d->rooms[room].position[dim_y],
(d->rooms[room].position[dim_y] +
d->rooms[room].size[dim_y] - 1));
p[dim_x] = rand_range(d->rooms[room].position[dim_x],
(d->rooms[room].position[dim_x] +
d->rooms[room].size[dim_x] - 1));
} while (mappair(p) > ter_stairs);
o = new object(v[i], p, d->objmap[p[dim_y]][p[dim_x]]);
d->objmap[p[dim_y]][p[dim_x]] = o;
}
void gen_objects(dungeon *d)
{
uint32_t i;
memset(d->objmap, 0, sizeof (d->objmap));
for (i = 0; i < d->max_objects; i++) {
gen_object(d);
}
d->num_objects = d->max_objects;
}
char object::get_symbol()
{
return next ? '&' : object_symbol[type];
}
uint32_t object::get_color()
{
return color;
}
const char *object::get_name()
{
return name.c_str();
}
const char *object::get_descr()
{
return description.c_str();
}
int32_t object::get_speed()
{
return speed;
}
int32_t object::roll_dice()
{
return damage.roll();
}
void destroy_objects(dungeon *d)
{
uint32_t y, x;
for (y = 0; y < DUNGEON_Y; y++) {
for (x = 0; x < DUNGEON_X; x++) {
if (d->objmap[y][x]) {
delete d->objmap[y][x];
d->objmap[y][x] = 0;
}
}
}
}
int32_t object::get_type()
{
return type;
}
| [
"noreply@github.com"
] | Henry-Kansanback.noreply@github.com |
85b54180458d1dcb95da58d5419a7cf2fb419740 | 5dfa67f7dfa12c2c7bb473cfab37ac370fa37923 | /HW3/main.cpp | 95e981c07ff121e5c04457d1145b9f128fec126e | [] | no_license | qulu622/AOOP | 24bff7fe5a0de961d1a37a021a4964ddb5a30e2c | e1e81dcc60cccb4a83fe9fe1166f32d62de23351 | refs/heads/master | 2020-05-04T21:42:29.509489 | 2019-04-04T14:32:36 | 2019-04-04T14:32:36 | 179,485,592 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,374 | cpp | #include <iostream>
#include "Complex.h"
using std::cout;
using std::endl;
int main() {
Complex a(77, 66.3);
Complex b(a);
int i = 1;
cout << i++ << ": (" << a.Real() << ',' << a.Imag() << ')' << endl;
cout << i++ << ": " << b << endl;
cout << i++ << ": " << Norm(b) << endl;
cout << i++ << ": " << b.Norm() << endl;
cout << i++ << ": " << Abs(b) << endl;
cout << i++ << ": " << b.Abs() << endl;
cout << i++ << ": " << Arg(b) << endl;
cout << i++ << ": " << b.Arg() << endl;
a = Complex(12, 33.2);
cout << i++ << ": " << a << endl;
cout << i++ << ": " << 1+a << endl;
cout << i++ << ": " << a++ << endl;
cout << i++ << ": " << ++a << endl;
b = a.Polar(5.6, 1.8);
cout << i++ << ": " << a << endl;
cout << i++ << ": " << b << endl;
b = Polar(6.5, 8.1);
cout << i++ << ": " << b << endl;
cout << i++ << ": " << a+b << endl;
cout << i++ << ": " << a-b << endl;
cout << i++ << ": " << a*b << endl;
cout << i++ << ": " << a/b << endl;
a /= b;
cout << i++ << ": " << a << endl;
a /= Complex(4, 3);
cout << i++ << ": " << a << endl;
a *= b;
cout << i++ << ": " << a << endl;
a *= Polar(5.1, 5.1);
cout << i++ << ": " << a << endl;
a += b;
b -= a;
cout << i++ << ": " << b << endl;
if (!(a == b))
cout << i++ << ": " << "OK" << endl;
if (a != b)
cout << i++ << ": " << "OK" << endl;
}
| [
"noreply@github.com"
] | qulu622.noreply@github.com |
6173e844d60297cfe92e4e6967709a45aa123832 | 33a0017a1dbbe3d0c8d2aff9c206ec71a705b6e8 | /cf_118B.cpp | 9751c53b0772d918caa5ed84e96132db494f4b98 | [] | no_license | JunGuoCS/Codeforce-Practise | a6f5e3dee26f13d6e56e73de3e96276a27324dfa | 79bdcdd66931e5bd3cf75febcc402b3ea01e919d | refs/heads/master | 2020-06-04T16:06:25.013157 | 2019-07-03T15:35:17 | 2019-07-03T15:35:17 | 192,095,873 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 355 | cpp | #include<iostream>
using namespace std;
int main(){
int n;
cin>>n;
for(int i=0;i<=2*n;i++){
int row=i<=n?i:2*n-i;
int num=0;
for(int j=0;j<=n+row;j++){
if(j!=0){
cout<<" ";
}
if(j>=n-row&&j<n){
cout<<num++;
}
else if(j>=n&&j<=n+row){
cout<<num--;
}
else{
cout<<" ";
}
}
cout<<endl;
}
return 0;
} | [
"332730268@qq.com"
] | 332730268@qq.com |
9de85a3b85d2820b644ac8d31ad7513709380a06 | 23970cd9aa85c9931c9825a2e1c68352d50e779d | /math.cpp | 7c5b3d2a463b455497fab4b4816ce6a8db0c4649 | [] | no_license | maque/cpp-learning | 2745f6d362c3960b13dad8f0b89c90aeea4fdf91 | 9bc4aec0c62130c59b1846ec36960c3bd25fefbf | refs/heads/master | 2021-01-10T07:54:17.525384 | 2015-12-23T14:54:02 | 2015-12-23T14:54:02 | 48,388,784 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 293 | cpp | #include <iostream>
#include <math.h>
#include <cstdio>
using namespace std;
int main(){
pow(2,3);
sqrt(25);
exp(10); //e^10
log(10); //log_e
log10(10);
ceil(2.5); //3
floor(2.5); //2
fmod(2.5,2.1); //return remainder of float naturalNumbers
abs(-1); //==1
return 0;
}
| [
"marcinmakowski@konto.pl"
] | marcinmakowski@konto.pl |
2a99454bb9f0bae25f52b9f417892c6e6f497f5f | 7c64360b6e32f8576344048db7b9938ea722dedd | /optickscore/tests/MockSensorAngularEfficiencyTableTest.cc | 6c109fb17ace931160e8a2f528130ea190d61ef3 | [
"Apache-2.0"
] | permissive | recepkandemir/opticks | 4be08a9243c3e0abe82eca77be70178e6384e555 | 523387f7593676bab58de22d22049e650de3f5c3 | refs/heads/master | 2023-01-24T16:55:04.131498 | 2020-12-04T20:25:09 | 2020-12-04T20:25:09 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 594 | cc | #include "OPTICKS_LOG.hh"
#include "NPY.hpp"
#include "MockSensorAngularEfficiencyTable.hh"
int main(int argc, char** argv)
{
OPTICKS_LOG(argc, argv);
unsigned num_sensor_cat = 1 ;
unsigned num_theta_steps = 180 ; // height
unsigned num_phi_steps = 360 ; // width
NPY<float>* tab = MockSensorAngularEfficiencyTable::Make(num_sensor_cat, num_theta_steps, num_phi_steps);
const char* path = "$TMP/optickscore/tests/MockSensorAngularEfficiencyTableTest.npy" ;
LOG(info) << " save to " << path ;
tab->save(path);
tab->dump();
return 0 ;
}
| [
"simoncblyth@gmail.com"
] | simoncblyth@gmail.com |
655741eaa71b0cf40d9404e40574e6a62a3ade76 | f161c76d158a33415da21607d6098811e97a9d93 | /src/AppExceptions/Exceptions/NotImplementedError.cpp | 361832f03e1a0b9b40c50d9b295f99b87ed57d1d | [] | no_license | iamandrii/telegram-bot | 72f88b4454a2e981509188ba08d978b8961fdc0c | ea6412f6ad3190eef0b1b3e5d09c04e347bfa36c | refs/heads/master | 2020-09-19T20:27:47.994774 | 2019-11-26T21:49:17 | 2019-11-26T21:49:17 | 224,289,685 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 149 | cpp | #include "../Exceptions.h"
using namespace App::Exceptions;
NotImplementedError::NotImplementedError(){
this->msg = (char*)"Not implemented";
} | [
"andry.if.com@gmail.com"
] | andry.if.com@gmail.com |
37b5664103017b3d1e2e8b38be797e346a2483aa | 54cca39cd1cf7f62b001c8a4d64dcc3d29e3cb4e | /PekoModel/PekoEngine/PekoEngineNet/AssemblyInfo.cpp | 749c8aee0775e233300fed8392930f180939d17b | [] | no_license | hamling-ling/NumericalResearches | d2487c2566c24ba3dc674e7e17f1745c1020d542 | a824357d7650d3ed86220f1315ee37e577285a7d | refs/heads/master | 2021-01-25T08:36:58.455319 | 2015-04-22T15:17:21 | 2015-04-22T15:17:21 | 7,775,139 | 0 | 0 | null | null | null | null | SHIFT_JIS | C++ | false | false | 1,414 | cpp | #include "stdafx.h"
using namespace System;
using namespace System::Reflection;
using namespace System::Runtime::CompilerServices;
using namespace System::Runtime::InteropServices;
using namespace System::Security::Permissions;
//
// アセンブリに関する一般情報は以下の属性セットをとおして制御されます。
// アセンブリに関連付けられている情報を変更するには、
// これらの属性値を変更してください。
//
[assembly:AssemblyTitleAttribute("PekoEngineNet")];
[assembly:AssemblyDescriptionAttribute("")];
[assembly:AssemblyConfigurationAttribute("")];
[assembly:AssemblyCompanyAttribute("")];
[assembly:AssemblyProductAttribute("PekoEngineNet")];
[assembly:AssemblyCopyrightAttribute("Copyright (c) 2013")];
[assembly:AssemblyTrademarkAttribute("")];
[assembly:AssemblyCultureAttribute("")];
//
// アセンブリのバージョン情報は、以下の 4 つの値で構成されています:
//
// Major Version
// Minor Version
// Build Number
// Revision
//
// すべての値を指定するか、下のように '*' を使ってリビジョンおよびビルド番号を
// 既定値にすることができます:
[assembly:AssemblyVersionAttribute("1.0.*")];
[assembly:ComVisible(false)];
[assembly:CLSCompliantAttribute(true)];
[assembly:SecurityPermission(SecurityAction::RequestMinimum, UnmanagedCode = true)];
| [
"tacobell@gj9.so-net.ne.jp"
] | tacobell@gj9.so-net.ne.jp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.