text
stringlengths 8
6.88M
|
|---|
#include<iostream>
#include<vector>
#include<unordered_map>
using namespace std;
// https://leetcode-cn.com/problems/two-sum/
vector<int> twoSum(vector<int>& nums, int target) {
unordered_map<int, int> hash;
vector<int> ret;
for (int i=0; i<nums.size(); ++i)
{
int findNum = target - nums[i];
if (hash.find(findNum) != hash.end())
{
ret.push_back(hash[findNum]);
ret.push_back(i);
return ret;
}
hash[nums[i]] = i; // 一边find前者一边加入hash
}
return ret;
}
/* 简单的hash题，查找hash[target-nums[i]]即可 */
|
/***************************************************************************
Copyright (c) 1999-2003 Apple Computer, Inc. All Rights Reserved.
2010-2020 DADI ORISTAR TECHNOLOGY DEVELOPMENT(BEIJING)CO.,LTD
FileName: QTSSFile.cpp
Description: Class QTSSFile definition .
Comment: copy from Darwin Streaming Server 5.5.5
Author: taoyunxing@dadimedia.com
Version: v1.0.0.1
CreateDate: 2010-08-16
LastUpdate: 2010-08-16
****************************************************************************/
#include "QTSSFile.h"
#include "QTSServerInterface.h"
//sAttributes[] definition,
//refer to QTSSDictionary.cpp line 829, and QTSSFile.cpp line 78
//参考QTSS_FileObjectAttributes in QTSS.h
QTSSAttrInfoDict::AttrInfo QTSSFile::sAttributes[] =
{ /*fields: fAttrName, fFuncPtr, fAttrDataType, fAttrPermission */
/* 0 */ { "qtssFlObjStream", NULL, qtssAttrDataTypeQTSS_StreamRef, qtssAttrModeRead | qtssAttrModePreempSafe },
/* 1 */ { "qtssFlObjFileSysModuleName", NULL, qtssAttrDataTypeCharArray, qtssAttrModeRead | qtssAttrModePreempSafe },//处理这个文件对象的文件系统模块名称
/* 2 */ { "qtssFlObjLength", NULL, qtssAttrDataTypeUInt64, qtssAttrModeRead | qtssAttrModePreempSafe | qtssAttrModeWrite },
/* 3 */ { "qtssFlObjPosition", NULL, qtssAttrDataTypeUInt64, qtssAttrModeRead | qtssAttrModePreempSafe },
/* 4 */ { "qtssFlObjModDate", NULL, qtssAttrDataTypeUInt64, qtssAttrModeRead | qtssAttrModePreempSafe | qtssAttrModeWrite }
};
void QTSSFile::Initialize()
{
for (UInt32 x = 0; x < qtssFlObjNumParams; x++)
QTSSDictionaryMap::GetMap(QTSSDictionaryMap::kFileDictIndex)->
SetAttribute(x, sAttributes[x].fAttrName, sAttributes[x].fFuncPtr, sAttributes[x].fAttrDataType, sAttributes[x].fAttrPermission);
}
// CONSTRUCTOR
QTSSFile::QTSSFile()
: QTSSDictionary(QTSSDictionaryMap::GetMap(QTSSDictionaryMap::kFileDictIndex)),
fModule(NULL),
fPosition(0),
fLength(0),
fModDate(0)
{
fThisPtr = this;
//
// The stream is just a pointer to this thing
this->SetVal(qtssFlObjStream, &fThisPtr, sizeof(fThisPtr));
this->SetVal(qtssFlObjLength, &fLength, sizeof(fLength));
this->SetVal(qtssFlObjPosition, &fPosition, sizeof(fPosition));
this->SetVal(qtssFlObjModDate, &fModDate, sizeof(fModDate));
}
//
// OPEN and CLOSE
//
/* 以给定标志打开给定路径的媒体文件，并设置执行该打开角色的模块 */
QTSS_Error QTSSFile::Open(char* inPath, QTSS_OpenFileFlags inFlags)
{
//
// Because this is a role being executed from inside a callback, we need to
// make sure that QTSS_RequestEvent will not work.
Task* curTask = NULL;
QTSS_ModuleState* theState = (QTSS_ModuleState*)OSThread::GetMainThreadData();
if (OSThread::GetCurrent() != NULL)
theState = (QTSS_ModuleState*)OSThread::GetCurrent()->GetThreadData();
if (theState != NULL)
curTask = theState->curTask;
QTSS_RoleParams theParams;
theParams.openFileParams.inPath = inPath;
theParams.openFileParams.inFlags = inFlags;
theParams.openFileParams.inFileObject = this;
QTSS_Error theErr = QTSS_FileNotFound;
UInt32 x = 0;
for ( ; x < QTSServerInterface::GetNumModulesInRole(QTSSModule::kOpenFilePreProcessRole); x++)
{
theErr = QTSServerInterface::GetModule(QTSSModule::kOpenFilePreProcessRole, x)->CallDispatch(QTSS_OpenFilePreProcess_Role, &theParams);
if (theErr != QTSS_FileNotFound)
{
fModule = QTSServerInterface::GetModule(QTSSModule::kOpenFilePreProcessRole, x);
break;
}
}
if (theErr == QTSS_FileNotFound)
{
// None of the prepreprocessors claimed this file. Invoke the default file handler
if (QTSServerInterface::GetNumModulesInRole(QTSSModule::kOpenFileRole) > 0)
{
fModule = QTSServerInterface::GetModule(QTSSModule::kOpenFileRole, 0);
theErr = QTSServerInterface::GetModule(QTSSModule::kOpenFileRole, 0)->CallDispatch(QTSS_OpenFile_Role, &theParams);
}
}
//
// Reset the curTask to what it was before this role started
if (theState != NULL)
theState->curTask = curTask;
return theErr;
}
/* 调用指定模块关闭文件对象 */
void QTSSFile::Close()
{
Assert(fModule != NULL);
QTSS_RoleParams theParams;
theParams.closeFileParams.inFileObject = this;
(void)fModule->CallDispatch(QTSS_CloseFile_Role, &theParams);
}
//
// IMPLEMENTATION OF STREAM FUNCTIONS.
/* 调用注册QTSS_ReadFile_Role的模块去读取当前文件对象中的数据到指定缓存,并返回实际读取数据的长度 */
QTSS_Error QTSSFile::Read(void* ioBuffer, UInt32 inBufLen, UInt32* outLengthRead)
{
Assert(fModule != NULL);
UInt32 theLenRead = 0;
//
// Invoke the owning QTSS API module. Setup a param block to do so.
QTSS_RoleParams theParams;
theParams.readFileParams.inFileObject = this;
theParams.readFileParams.inFilePosition = fPosition;
theParams.readFileParams.ioBuffer = ioBuffer;
theParams.readFileParams.inBufLen = inBufLen;
theParams.readFileParams.outLenRead = &theLenRead;
QTSS_Error theErr = fModule->CallDispatch(QTSS_ReadFile_Role, &theParams);
fPosition += theLenRead;
if (outLengthRead != NULL)
*outLengthRead = theLenRead;
return theErr;
}
/* 查询当前文件对象的文件长度,并确保指定的位置没有文件长度,设置入参为fPosition */
QTSS_Error QTSSFile::Seek(UInt64 inNewPosition)
{
UInt64* theFileLength = NULL;
UInt32 theParamLength = 0;
//查询当前文件对象的文件长度
(void)this->GetValuePtr(qtssFlObjLength, 0, (void**)&theFileLength, &theParamLength);
if (theParamLength != sizeof(UInt64))
return QTSS_RequestFailed;
//检查入参合法性
if (inNewPosition > *theFileLength)
return QTSS_RequestFailed;
//设置文件对象指针的当前位置
fPosition = inNewPosition;
return QTSS_NoErr;
}
/* 调用注册QTSS_AdviseFile_Role的模块,通知文件系统模块流的指定部分很快将会被读取 */
QTSS_Error QTSSFile::Advise(UInt64 inPosition, UInt32 inAdviseSize)
{
Assert(fModule != NULL);
//
// Invoke the owning QTSS API module. Setup a param block to do so.
QTSS_RoleParams theParams;
theParams.adviseFileParams.inFileObject = this;
theParams.adviseFileParams.inPosition = inPosition;//即将被读取的部分的起始点(相对于流的起始位置的字节偏移量)
theParams.adviseFileParams.inSize = inAdviseSize;//即将被读取的部分的字节长度
return fModule->CallDispatch(QTSS_AdviseFile_Role, &theParams);
}
/* 调用注册QTSS_RequestEventFile_Role的模块,请求当指定事件发生时得到通知 */
QTSS_Error QTSSFile::RequestEvent(QTSS_EventType inEventMask)
{
Assert(fModule != NULL);
//
// Invoke the owning QTSS API module. Setup a param block to do so.
QTSS_RoleParams theParams;
theParams.reqEventFileParams.inFileObject = this;
theParams.reqEventFileParams.inEventMask = inEventMask;
return fModule->CallDispatch(QTSS_RequestEventFile_Role, &theParams);
}
|
//###############################################################################################
// Project :: ACTeaM Classic 0.97d
// GameServer:: 0.96.40
// Company :: Advanced CoderZ MU DevelopmenT © 2013
// Revised :: 17/01/2014
// Coded :: Mr.Haziel Developer
//###############################################################################################
#include "StdAfx.h"
GOBJATTACK pObjAttack;
void ReadygObjAttack()
{
AttackConfigs();
func.HookThis((DWORD)&gObjAttackEX, 0x00405E7A);
}
void AttackConfigs()
{
pObjAttack.A_NonPK = GetPrivateProfileIntA("PVPSystem", "NonPVP", 0, CFG_PVPSystem);
pObjAttack.A_NonGM = GetPrivateProfileIntA("Fixes", "GMDamage", 0, CFG_PVPSystem);
pObjAttack.A_AltoReset = GetPrivateProfileIntA("ResetSystem", "Automatic", 0, CFG_PVPSystem);
pObjAttack.A_Attack = GetPrivateProfileIntA("PVPSystem", "Switch", 0, CFG_PVPSystem);
pObjAttack.A_Lorencia = GetPrivateProfileIntA("PVPSystem", "Lorencia", 1, CFG_PVPSystem);
pObjAttack.A_Dungeon = GetPrivateProfileIntA("PVPSystem", "Dungeon", 1, CFG_PVPSystem);
pObjAttack.A_Davias = GetPrivateProfileIntA("PVPSystem", "Devias", 1, CFG_PVPSystem);
pObjAttack.A_Noria = GetPrivateProfileIntA("PVPSystem", "Noria", 1, CFG_PVPSystem);
pObjAttack.A_LostTower = GetPrivateProfileIntA("PVPSystem", "Losttower", 1, CFG_PVPSystem);
pObjAttack.A_Stadium = GetPrivateProfileIntA("PVPSystem", "Stadium", 1, CFG_PVPSystem);
pObjAttack.A_Atlans = GetPrivateProfileIntA("PVPSystem", "Atlans", 1, CFG_PVPSystem);
pObjAttack.A_Tarkan = GetPrivateProfileIntA("PVPSystem", "Tarkan", 1, CFG_PVPSystem);
pObjAttack.A_Icarus = GetPrivateProfileIntA("PVPSystem", "Icarus", 1, CFG_PVPSystem);
/*
pObjAttack.A_New17 = GetPrivateProfileIntA("PVPSystem", "NewMap17", 1, CFG_PVPSystem);
pObjAttack.A_New18 = GetPrivateProfileIntA("PVPSystem", "NewMap18", 1, CFG_PVPSystem);
pObjAttack.A_New19 = GetPrivateProfileIntA("PVPSystem", "NewMap19", 1, CFG_PVPSystem);
pObjAttack.A_New20 = GetPrivateProfileIntA("PVPSystem", "NewMap20", 1, CFG_PVPSystem);
pObjAttack.A_New21 = GetPrivateProfileIntA("PVPSystem", "NewMap21", 1, CFG_PVPSystem);
pObjAttack.A_New22 = GetPrivateProfileIntA("PVPSystem", "NewMap22", 1, CFG_PVPSystem);
pObjAttack.A_New23 = GetPrivateProfileIntA("PVPSystem", "NewMap23", 1, CFG_PVPSystem);
pObjAttack.A_New24 = GetPrivateProfileIntA("PVPSystem", "NewMap24", 1, CFG_PVPSystem);
*/
}
bool gObjAttackEX(OBJECTSTRUCT* lpObj, OBJECTSTRUCT* lpTargetObj, void * lpMagic, BOOL magicsend, BYTE MSBFlag, int AttackDamage)
{
if (lpTargetObj->Type == OBJECT_MONSTER)
{
////////////////////////////////////////
//-- BOSS MEDUSA DROP JEWEL //
////////////////////////////////////////
srand(static_cast<int>(time(NULL)));
int MedusaRand = (rand() % 100);
if (eMedusa.IsMedusa != 0)
{
if (lpTargetObj->Class == 49)
{
if (MedusaRand > 96)
{
ChatTargetSend(lpTargetObj, "Oh Não! Perdi uma bless", lpObj->m_Index);
ItemSerialCreateSend(lpObj->m_Index, lpObj->MapNumber, lpObj->X, lpObj->Y, ITEMGET(14, 13), 0, 0, 0, 0, 0, -1, 0);
}
if (MedusaRand > 97)
{
ChatTargetSend(lpTargetObj, "Oh Não! ,Perdi uma Soul", lpObj->m_Index);
ItemSerialCreateSend(lpObj->m_Index, lpObj->MapNumber, lpObj->X, lpObj->Y, ITEMGET(14, 14), 0, 0, 0, 0, 0, -1, 0);
}
if (MedusaRand > 95)
{
ChatTargetSend(lpTargetObj, "Oh Não! ,Perdi uma chaos", lpObj->m_Index);
ItemSerialCreateSend(lpObj->m_Index, lpObj->MapNumber, lpObj->X, lpObj->Y, ITEMGET(12, 15), 0, 0, 0, 0, 0, -1, 0);
}
}
}
if (pObjAttack.A_AltoReset != 0)
{
if (epObj[lpObj->m_Index].m_Vip == 0 && lpObj->Level >= pReset.LevelRequiredtoResetNrl)
{
ResetSystemExecult(lpObj->m_Index); //-- ReseteSystem.CPP
return true;
}
if (epObj[lpObj->m_Index].m_Vip == 1 && lpObj->Level >= pReset.LevelRequiredtoResetVIP_1)
{
ResetSystemExecult(lpObj->m_Index); //-- ReseteSystem.CPP
return true;
}
if (epObj[lpObj->m_Index].m_Vip == 2 && lpObj->Level >= pReset.LevelRequiredtoResetVIP_2)
{
ResetSystemExecult(lpObj->m_Index); //-- ReseteSystem.CPP
return true;
}
if (epObj[lpObj->m_Index].m_Vip == 3 && lpObj->Level >= pReset.LevelRequiredtoResetVIP_3)
{
ResetSystemExecult(lpObj->m_Index); //-- ReseteSystem.CPP
return true;
}
}
}
//===================================================
//-- Gens System
//===================================================
if (pGens.ISGENS != FALSE)
{
if (GensDisplay(lpObj, lpTargetObj, lpMagic, magicsend, MSBFlag, AttackDamage) != true)
{
return true;
}
}
if (lpObj->Type == OBJECT_USER && lpTargetObj->Type == OBJECT_USER)
{
//=========================================================
//-- Fix Room Non PK
//=========================================================
if (pObjAttack.A_NonPK != 0)
{
return true;
}
//=========================================================
//--Duel System NO PVP
//=========================================================
if (DuelSystem.ISDUEL != 0)
{
if (lpObj->MapNumber == DuelSystem.Duel_Map && epObj[lpObj->m_Index].m_Duel_PVP == FALSE)
{
return true;
}
if (lpTargetObj->MapNumber == DuelSystem.Duel_Map && epObj[lpTargetObj->m_Index].m_Duel_PVP == FALSE)
{
return true;
}
}
//=========================================================
//-- Fix Bug Dino
//=========================================================
short Type = lpObj->pInventory[8].m_Type;
if (!((Type >= ITEMGET(13, 0) && Type <= ITEMGET(13, 5)) || Type == ITEMGET(13, 37)))
{
GCInventoryItemDeleteSend(lpObj->m_Index, 8, 0);
}
//=========================================================
//-- Fix Kinighth Bug Far Attack
//=========================================================
/* if(lpObj->Class == CLASS_KNIGHT && pAntiHacker.IsTsHacker != FALSE )
{
int X = lpObj->X - lpTargetObj->X;
int Y = lpObj->Y - lpTargetObj->Y;
int Distance = X + Y / 2;
if( Distance > 2 || Distance < - 1)
{
//GCDamageSend(lpObj->m_Index,lpTargetObj->m_Index, 0, 0, 0, 0);
return true;
}
}
//=========================================================
//-- Zumbi Hack Bug
//=========================================================
if(lpObj->DieRegen != 0 || lpTargetObj->DieRegen != 0 )
{
//GCDamageSend(lpObj->m_Index,lpTargetObj->m_Index, 0, 0, 0, 0); // MISS
//AntiHackerLog(lpObj->m_Index,"Was using Zumbi Hack Bug!");
return true;
}
//=========================================================
//-- Game Master no PVP
//=========================================================
if(lpObj->Authority > 1 && pObjAttack.A_NonGM != 0 )
{
GCDamageSend(lpObj->m_Index,lpTargetObj->m_Index, 0, 0, 0, 0);
return true;
}
//=========================================================
//-- Speed Hacker
//=========================================================
if(epObj[lpObj->m_Index].BlockAttack != 0 )
{
GCDamageSend(lpObj->m_Index,lpTargetObj->m_Index, 0, 0, 0, 0);
return true;
} */
//=========================================================
//-- Map PVP System
//=========================================================
if (pObjAttack.A_Attack != 0)
{
if (lpObj->MapNumber == 0 && pObjAttack.A_Lorencia == 0)
{
MsgOutput(lpObj->m_Index, "%s PVP está desativado neste mapa ", lpObj->Name);
return true;
}
if (lpObj->MapNumber == 1 && pObjAttack.A_Dungeon == 0)
{
MsgOutput(lpObj->m_Index, "%s PVP está desativado neste mapa ", lpObj->Name);
return true;
}
if (lpObj->MapNumber == 2 && pObjAttack.A_Davias == 0)
{
MsgOutput(lpObj->m_Index, "%s PVP está desativado neste mapa ", lpObj->Name);
return true;
}
if (lpObj->MapNumber == 3 && pObjAttack.A_Noria == 0)
{
MsgOutput(lpObj->m_Index, "%s PVP está desativado neste mapa ", lpObj->Name);
return true;
}
if (lpObj->MapNumber == 4 && pObjAttack.A_LostTower == 0)
{
MsgOutput(lpObj->m_Index, "%s PVP está desativado neste mapa ", lpObj->Name);
return true;
}
if (lpObj->MapNumber == 6 && pObjAttack.A_Stadium == 0)
{
MsgOutput(lpObj->m_Index, "%s PVP está desativado neste mapa ", lpObj->Name);
return true;
}
if (lpObj->MapNumber == 7 && pObjAttack.A_Atlans == 0)
{
MsgOutput(lpObj->m_Index, "%s PVP está desativado neste mapa ", lpObj->Name);
return true;
}
if (lpObj->MapNumber == 8 && pObjAttack.A_Tarkan == 0)
{
MsgOutput(lpObj->m_Index, "%s PVP está desativado neste mapa ", lpObj->Name);
return true;
}
if (lpObj->MapNumber == 9 && pObjAttack.A_Icarus == 0)
{
MsgOutput(lpObj->m_Index, "%s PVP está desativado neste mapa ", lpObj->Name);
return true;
}
//=========================================================
// New maps
//=========================================================
if (lpObj->MapNumber == 17 && pObjAttack.A_New17 == 0)
{
MsgOutput(lpObj->m_Index, "%s PVP está desativado neste mapa ", lpObj->Name);
return true;
}
if (lpObj->MapNumber == 18 && pObjAttack.A_New18 == 0)
{
MsgOutput(lpObj->m_Index, "%s PVP está desativado neste mapa ", lpObj->Name);
return true;
}
if (lpObj->MapNumber == 19 && pObjAttack.A_New19 == 0)
{
GCServerMsgStringSend("PVP está desativado neste mapa!", lpObj->m_Index, 1);
return true;
}
if (lpObj->MapNumber == 20 && pObjAttack.A_New20 == 0)
{
MsgOutput(lpObj->m_Index, "%s PVP está desativado neste mapa ", lpObj->Name);
return true;
}
if (lpObj->MapNumber == 21 && pObjAttack.A_New21 == 0)
{
MsgOutput(lpObj->m_Index, "%s PVP está desativado neste mapa ", lpObj->Name);
return true;
}
if (lpObj->MapNumber == 22 && pObjAttack.A_New22 == 0)
{
MsgOutput(lpObj->m_Index, "%s PVP está desativado neste mapa ", lpObj->Name);
return true;
}
if (lpObj->MapNumber == 23 && pObjAttack.A_New23 == 0)
{
MsgOutput(lpObj->m_Index, "%s PVP está desativado neste mapa ", lpObj->Name);
return true;
}
if (lpObj->MapNumber == 24 && pObjAttack.A_New24 == 0)
{
MsgOutput(lpObj->m_Index, "%s PVP está desativado neste mapa ", lpObj->Name);
return true;
}
}
}
gObjAttack(lpObj, lpTargetObj, lpMagic, magicsend, MSBFlag, AttackDamage);
return false;
}
|
class Solution {
public:
int characterReplacement(string s, int k) { // 双指针
int n = s.length();
//int num[26];
vector<int> num(26); // 用这样的一个数组计算各个单词的频次
int left = 0, right = 0, maxlen = 0; // 初始化
while (right < n) {
num[s[right] - 'A']++; // 右指针遇到一个单词，就记录这个单词的频次。这个方法挺好的
maxlen = max(maxlen, num[s[right] - 'A']); // 留下最大数量的单词数
if (right - left + 1 - maxlen > k) { // 这个判断很好，表明可更改的数量和非主流单词数量的大小关系
num[s[left] - 'A']--; // 如果超过了更改限额，那么左边的指针要移动了。如果要移动，要释放这个单词的频次
left++; // 左指针移动
}
right++; // 右指针日常移动
}
return right - left; // 返回长度
}
};
// reference https://leetcode-cn.com/problems/longest-repeating-character-replacement/solution/ti-huan-hou-de-zui-chang-zhong-fu-zi-fu-n6aza/
// 问题： 为什么不能用int num[26]? 链接： https://leetcode-cn.com/problems/longest-repeating-character-replacement/solution/ti-huan-hou-de-zui-chang-zhong-fu-zi-fu-n6aza/773269/
|
#ifndef TREELEAFTEST_H
#define TREELEAFTEST_H
#include "test.h"
#include "../treelist.h"
class TreeLeafTest: public Test
{
public:
bool test();
char * getName();
};
#endif // TREELEAFTEST_H
|
#include <bits/stdc++.h>
#define rep(i,n) for (int i = 0; i < (n); ++i)
#define ok() puts(ok?"Yes":"No");
#define chmax(x,y) x = max(x,y)
#define chmin(x,y) x = min(x,y)
using namespace std;
using ll = long long;
using vi = vector<int>;
using ii = pair<int, int>;
using vvi = vector<vi>;
using vii = vector<ii>;
using gt = greater<int>;
using minq = priority_queue<int, vector<int>, gt>;
using P = pair<ll,ll>;
const ll LINF = 1e18L + 1;
const int INF = 1e9 + 1;
//clang++ -std=c++11 -stdlib=libc++
int ans = 0;
ll k;
vector<ll> a, b;
ll get_a(int i)
{
if (a.size() - 1 - i >= 0)
return a[a.size() - 1 - i];
return LINF;
}
ll get_b(int i)
{
if (b.size() - 1 - i >= 0)
return b[b.size() - 1 - i];
return LINF;
}
int f(int i, int j, ll sum=0)
{
ll na = get_a(i);
ll nb = get_b(j);
if (min(na, nb) + sum > k) return 0;
if (na == nb) {
if (na == LINF) return 0;
return 1 + max(f(i + 1, j, sum + na), f(i, j + 1, sum + nb));
}
if (na < nb) {
return 1 + f(i + 1, j, sum + na);
}
else {
return 1 + f(i, j + 1, sum + nb);
}
}
int main() {
ll n,m; cin >> n>> m>>k;
a.resize(n);
b.resize(m);
rep(i,n) {
cin >> a[i];
}
rep(i,m) {
cin >> b[i];
}
reverse(a.begin(), a.end());
reverse(b.begin(), b.end());
cout << f(0,0) << endl;
return 0;
}
|
/**
* 搜狗笔试题
*/
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <assert.h>
#include <string.h>
int encode(const void* raw_in, void* raw_out, uint32_t password, size_t len)
{
const uint8_t* in = (const uint8_t*)raw_in;
uint8_t* out = (uint8_t*)raw_out;
uint32_t seed = password ^ 0xfc7a297cu;
for (size_t i = 0 ; i < len; ++i) {
uint8_t a = ( in[i] ^ seed ) >> 4;
uint8_t b = ( ( ((uint32_t)in[i]) << 19 ) ^ seed ) >> (19-4);
a &= 15;
b &= 240;
a = 15 & ( a ^ (b << 3));
out[i] = a | b;
seed = ((seed ^ in[i]) * 144123481 + in[i]);
}
}
int decode(const void* raw_in, void* raw_out, uint32_t password, size_t len)
{
const uint8_t* in = (const uint8_t*)raw_in;
uint8_t* out = (uint8_t*)raw_out;
uint32_t seed = password ^ 0xfc7a297cu;
for (size_t i = 0 ; i < len; ++i) {
// 请在此处补全代码
uint8_t a = 15 & in[i];
uint8_t b = 240 & in[i];
a = (a << 4) ^ seed & 240;
b = ((((uint32_t)b) << 15) ^ seed) >> 19;
b = b & 15;
out[i] = a | b;
seed = ((seed ^ out[i]) * 144123481 + out[i]);
}
}
int main()
{
const uint8_t buf1[] = {0x2d, 0x1e, 0xd8, 0x9c, 0x72, 0x3f, 0x9c, 0x78, 0xb4, 0xdc, 0xe8, 0x0e, 0x08, 0x56, 0xf6, 0x9b, 0xb2, 0x92, 0x40, 0xad, 0x89, 0xf6, 0xda, 0xcf, 0xef, 0x64, 0x13, 0x3c, 0xee, 0x00, 0x8e, 0xa0, 0x3f, 0xb4, 0x0f, 0x6b, 0xda, 0x3b, 0x7e, 0x72, };
uint8_t buf2[100] = {};
const uint32_t password = 0xab7786eu;
const size_t len = sizeof(buf1);
decode(buf1, buf2, password, len);
printf("%s\n", buf2);
}
|
// Filename: dnaStorage.cxx
// Created by: shochet (29Mar00)
//
////////////////////////////////////////////////////////////////////
#include "dnaStorage.h"
#include <deque>
DNAStorage::WorkingSuitPath *DNAStorage::WorkingSuitPath::_deleted_chain = (DNAStorage::WorkingSuitPath *)NULL;
////////////////////////////////////////////////////////////////////
// Function: Constructor
// Access: Public
// Description:
////////////////////////////////////////////////////////////////////
DNAStorage::DNAStorage() {
}
////////////////////////////////////////////////////////////////////
// Function: print_node_storage
// Access: Public
// Description: Print out the key/pointer pairs
////////////////////////////////////////////////////////////////////
void DNAStorage::print_node_storage() const {
std::cout << "Model Pool Nodes" << std::endl;
for(NodeMap::const_iterator i = _node_map.begin();
i != _node_map.end();
++i) {
std::cout << "\t(" << (*i).first << " " << (*i).second << ") " << std::endl;
}
std::cout << "Hood Nodes" << std::endl;
for(NodeMap::const_iterator h = _hood_node_map.begin();
h != _hood_node_map.end();
++h) {
std::cout << "\t(" << (*h).first << " " << (*h).second << ") " << std::endl;
}
std::cout << "Place Nodes" << std::endl;
for(NodeMap::const_iterator p = _place_node_map.begin();
p != _place_node_map.end();
++p) {
std::cout << "\t(" << (*p).first << " " << (*p).second << ") " << std::endl;
}
}
////////////////////////////////////////////////////////////////////
// Function: print_texture_storage
// Access: Public
// Description: Print out the key/pointer pairs
////////////////////////////////////////////////////////////////////
void DNAStorage::print_texture_storage() const {
for(TextureMap::const_iterator i = _texture_map.begin();
i != _texture_map.end();
++i) {
std::cout << "\t(" << (*i).first << " " << (*i).second << ") " << std::endl;
}
}
////////////////////////////////////////////////////////////////////
// Function: print_font_storage
// Access: Public
// Description: Print out the key/pointer pairs
////////////////////////////////////////////////////////////////////
void DNAStorage::print_font_storage() const {
for(FontMap::const_iterator i = _font_map.begin();
i != _font_map.end();
++i) {
std::cout << "\t(" << (*i).first << " " << (*i).second << ") " << std::endl;
}
}
////////////////////////////////////////////////////////////////////
// Function: print_suit_point_storage
// Access: Public
// Description: Print out the key/pointer pairs
////////////////////////////////////////////////////////////////////
void DNAStorage::print_suit_point_storage() const {
std::cout << "Suit points" << std::endl;
for(SuitPointVector::const_iterator i = _suit_point_vector.begin();
i != _suit_point_vector.end();
++i) {
// To output the actual point, we need to dereference the PointerTo
std::cout << "\t" << *(*i) << std::endl;
}
std::cout << "Suit edges" << std::endl;
for(SuitStartPointMap::const_iterator si = _suit_start_point_map.begin();
si != _suit_start_point_map.end();
++si) {
std::cout << "\tIndex: " << (*si).first << std::endl;
for(SuitEdgeVector::const_iterator evi = ((*si).second).begin();
evi != ((*si).second).end();
++evi) {
// To output the actual edge, we need to dereference the PointerTo
std::cout << "\t Edge: " << *((*evi)) << std::endl;
}
}
}
////////////////////////////////////////////////////////////////////
// Function: print_battle_cell_storage
// Access: Public
// Description: Print out the battle cells
////////////////////////////////////////////////////////////////////
void DNAStorage::print_battle_cell_storage() const {
for(BattleCellVector::const_iterator i = _battle_cell_vector.begin();
i != _battle_cell_vector.end();
++i) {
// To output the actual battle cell, we need to dereference the PointerTo
std::cout << "Battle cell: " << *(*i) << std::endl;
}
}
////////////////////////////////////////////////////////////////////
// Function: store_texture
// Access: Public
// Description: Store a texture pointer in the texture map
////////////////////////////////////////////////////////////////////
void DNAStorage::store_texture(const std::string &code_string, PT(Texture) texture) {
nassertv(texture != (Texture *)NULL);
// Assume all these textures are mipmap. Actually it should
// match the textures.txa, but how do I know what is in there?
// Note: take these out when we have a better solution for getting
// and setting these parameters
texture->set_minfilter(SamplerState::FT_linear_mipmap_linear);
texture->set_magfilter(SamplerState::FT_linear);
texture->set_anisotropic_degree(4);
_texture_map[code_string] = texture;
}
////////////////////////////////////////////////////////////////////
// Function: store_font
// Access: Public
// Description: Store a font pointer in the font map
////////////////////////////////////////////////////////////////////
void DNAStorage::store_font(const std::string &code_string, PT(TextFont) font) {
nassertv(font != (TextFont *)NULL);
_font_map[code_string] = font;
}
////////////////////////////////////////////////////////////////////
// Function: store_suit_point
// Access: Public
// Description: Store a point in the suit point map. If that pos
// already exists, return the existing point, otherwise
// create a new point and store that.
////////////////////////////////////////////////////////////////////
PT(DNASuitPoint) DNAStorage::store_suit_point(DNASuitPoint::DNASuitPointType type,
LPoint3f pos) {
for(SuitPointVector::const_iterator i = _suit_point_vector.begin();
i != _suit_point_vector.end();
++i) {
// See if this point pos is close enough to the pos passed in
PT(DNASuitPoint) point = (*i);
// Do not check the type anymore
// if ((type == point->get_point_type()) &&
if (pos.almost_equal(point->get_pos(), 0.9)) {
// Found it, return the existing point
return point;
}
}
// If we got here, we did not find the point in the map
// Create a new one
int index = get_highest_suit_point_index() + 1;
PT(DNASuitPoint) point = new DNASuitPoint(index, type, pos);
// Ok, now actually store the point
store_suit_point(point);
return point;
}
////////////////////////////////////////////////////////////////////
// Function: store_suit_point
// Access: Public
// Description: Store a suit point in the suit point map
////////////////////////////////////////////////////////////////////
int DNAStorage::store_suit_point(PT(DNASuitPoint) point) {
nassertr(point != (DNASuitPoint *)NULL, -1);
_suit_point_vector.push_back(point);
// NOTE: perhaps this should check to make sure there is
// not one there already
_suit_point_map[point->get_index()] = point;
return point->get_index();
}
int DNAStorage::get_highest_suit_point_index() {
int highest = -1;
int index = 0;
// Iterate all the suit points looking for the highest index
for(SuitPointVector::const_iterator i = _suit_point_vector.begin();
i != _suit_point_vector.end();
++i) {
index = (*i)->get_index();
if (index > highest) {
highest = index;
}
}
return highest;
}
////////////////////////////////////////////////////////////////////
// Function: fix_coincident_suit_points
// Access: Public
// Description: Runs through the list of suit points fixing
// any points that are coincident by deleting the
// duplicates and patching up the effected edges
////////////////////////////////////////////////////////////////////
int DNAStorage::fix_coincident_suit_points() {
int num_repeats = 0;
PT(DNASuitPoint) point1;
PT(DNASuitPoint) point2;
// Iterate over the point vector. With each point in the vector, check
// every other point to see if they are "almost_equal"
// Note: this will double report them
for(SuitPointVector::const_iterator i = _suit_point_vector.begin();
i != _suit_point_vector.end();
++i) {
point1 = (*i);
for(SuitPointVector::const_iterator ii = _suit_point_vector.begin();
ii != _suit_point_vector.end();
++ii) {
point2 = (*ii);
// Do not count being almost equal to yourself
if ((point1 != point2) &&
(point1->get_pos().almost_equal(point2->get_pos(), 0.9))) {
dna_cat.info() << "found coincident points: " << point1->get_index() << ": " << point1->get_point_type()
<< ", " << point2->get_index() << ": " << point2->get_point_type() << std::endl;
// TODO:
// remove from the SuitPointMap
// remove from the SuitStartPointMap
// remove edges in dnaStorage that contain this point
// remove edges in any visgroups that contain this point
num_repeats++;
}
}
}
// Return the number of matches we found
dna_cat.debug() << "fixed " << num_repeats << " suit points" << std::endl;
return num_repeats;
}
////////////////////////////////////////////////////////////////////
// Function: delete_unused_suit_points
// Access: Public
// Description: Runs through the list of suit points deleting
// any points that are not on any edges.
// This is computationally expensive, but it is only run
// when we save the dna in the editor, not at run time.
////////////////////////////////////////////////////////////////////
int DNAStorage::delete_unused_suit_points() {
int num_deleted = 0;
int used = 0;
PT(DNASuitPoint) point;
PT(DNASuitEdge) edge;
// Iterate over all the suit points
for(SuitPointVector::iterator i = _suit_point_vector.begin();
i != _suit_point_vector.end();
++i) {
point = (*i);
used = 0;
// First, try to find this start_index in the map
SuitStartPointMap::const_iterator si = _suit_start_point_map.find(point->get_index());
if (si != _suit_start_point_map.end()) {
// It is being used, so do not delete it.
used = 1;
// Go on to the next point.
continue;
}
// Check all the edges in all the vis groups to see if we use this point
for(VisGroupVectorAI::const_iterator vi = _vis_group_vector.begin();
vi != _vis_group_vector.end();
++vi) {
int num_suit_edges = (*vi)->get_num_suit_edges();
for (int e=0; e < num_suit_edges; e++) {
edge = (*vi)->get_suit_edge(e);
if ((point == edge->get_start_point()) ||
(point == edge->get_end_point())) {
// This point is used, stop looking
used = 1;
break;
}
}
if (used) {
break;
}
}
if (!used) {
// Delete the point from the suit point vector
dna_cat.info() << "deleting unused point " << *point << std::endl;
_suit_point_vector.erase(i--);
num_deleted++;
}
}
// Return the number of matches we found
dna_cat.debug() << "deleted " << num_deleted << " suit points" << std::endl;
return num_deleted;
}
////////////////////////////////////////////////////////////////////
// Function: remove_suit_point
// Access: Public
// Description: Remove a suit point from the suit point map
// Returns the number of points removed (0 or 1)
////////////////////////////////////////////////////////////////////
int DNAStorage::remove_suit_point(PT(DNASuitPoint) point) {
nassertr(point != (DNASuitPoint *)NULL, 0);
int result = 0;
PT(DNASuitEdge) edge;
// Iterate over all the start points
for(SuitStartPointMap::iterator si = _suit_start_point_map.begin();
si != _suit_start_point_map.end();
++si) {
// For each start point, iterate over the edges that use that start point
for(SuitEdgeVector::iterator evi = (*si).second.begin();
evi != (*si).second.end();
++evi) {
edge = (*evi);
// See if this point is in this edge. If it is, remove the edge
if ((point == edge->get_start_point()) ||
(point == edge->get_end_point())) {
dna_cat.warning() << "removing edge containing point " << *(edge) << std::endl;
// Erase this edge from this vector, decrementing the iterator
// so we do not invalidate it when erasing an element it was pointing to
(*si).second.erase(evi--);
// remove the edge from any vis groups that contain it
for(VisGroupVectorAI::iterator vi = _vis_group_vector.begin();
vi != _vis_group_vector.end();
++vi) {
if ((*vi)->remove_suit_edge(edge)) {
dna_cat.debug() << "removed edge from vis group " << (*vi)->get_name() << std::endl;
}
}
}
}
}
// Erase the point from the suit start point map
result += _suit_start_point_map.erase(point->get_index());
// Erase the point from the suit point vector
SuitPointVector::iterator pi = find(_suit_point_vector.begin(),
_suit_point_vector.end(),
point);
if (pi != _suit_point_vector.end()) {
_suit_point_vector.erase(pi);
result += 1;
}
return result;
}
////////////////////////////////////////////////////////////////////
// Function: store_block_number
// Access: Public
// Description: Store a block and zone
////////////////////////////////////////////////////////////////////
void DNAStorage::store_block_number(const std::string& block, const std::string& zone_id) {
nassertv(!block.empty());
nassertv(!zone_id.empty());
// Get the block number (e.g. in "tb22:blah_blah" the block number is "22").
std::string block_num = block.substr(2, block.find(':')-2);
_block_map[atoi(block_num.c_str())]=atoi(zone_id.c_str());
}
////////////////////////////////////////////////////////////////////
// Function: get_zone_from_block_number
// Access: Public
// Description:
////////////////////////////////////////////////////////////////////
int DNAStorage::get_zone_from_block_number(int block_number) const {
// Try to find this code in the map
BlockToZoneMap::const_iterator i = _block_map.find(block_number);
if (i == _block_map.end()) {
dna_cat.error()
<< "block number: " << block_number << " not found in map" << std::endl;
return 0;
}
return (*i).second;
}
////////////////////////////////////////////////////////////////////
// Function: get_num_block_number
// Access: Public
// Description: Ask how many block numbers
////////////////////////////////////////////////////////////////////
int DNAStorage::get_num_block_numbers() const {
return _block_map.size();
}
////////////////////////////////////////////////////////////////////
// Function: get_block_number_at
// Access: Public
// Description: Get key at index
////////////////////////////////////////////////////////////////////
int DNAStorage::get_block_number_at(uint index) const {
nassertr(index < _block_map.size(), 0);
uint current = 0;
// Loop over the map entries:
for(BlockToZoneMap::const_iterator it = _block_map.begin();
it != _block_map.end();
++it) {
if (index == current) {
nassertr((*it).first != 0, 0);
return (*it).first;
}
current++;
}
dna_cat.error()
<< "DNAStorage::get_block_number_at index not found, returning 0"
<< std::endl;
return 0;
}
////////////////////////////////////////////////////////////////////
// Function: store_block_door_pos_hpr
// Access: Public
// Description: Store a block and zone
////////////////////////////////////////////////////////////////////
void DNAStorage::store_block_door_pos_hpr(const std::string& block,
const LPoint3f& pos,
const LPoint3f& hpr) {
nassertv(!block.empty());
_block_door_pos_hpr_map[atoi(block.c_str())]=PosHpr(pos, hpr);
}
////////////////////////////////////////////////////////////////////
// Function: get_door_pos_hpr_from_block_number
// Access: Public
// Description:
////////////////////////////////////////////////////////////////////
const PosHpr& DNAStorage::get_door_pos_hpr_from_block_number(int block_number) const {
// Try to find this code in the map
BlockToPosHprMap::const_iterator i = _block_door_pos_hpr_map.find(block_number);
if (i == _block_door_pos_hpr_map.end()) {
dna_cat.error()
<< "block number: " << block_number << " not found in map" << std::endl;
static PosHpr blank;
return blank;
}
return (*i).second;
}
////////////////////////////////////////////////////////////////////
// Function: get_num_block_door_pos_hprs
// Access: Public
// Description: Ask how many block numbers
////////////////////////////////////////////////////////////////////
int DNAStorage::get_num_block_door_pos_hprs() const {
return _block_door_pos_hpr_map.size();
}
////////////////////////////////////////////////////////////////////
// Function: get_door_pos_hpr_block_at
// Access: Public
// Description: Get key at index
////////////////////////////////////////////////////////////////////
int DNAStorage::get_door_pos_hpr_block_at(uint index) const {
nassertr(index < _block_door_pos_hpr_map.size(), 0);
uint current = 0;
// Loop over the map entries:
for(BlockToPosHprMap::const_iterator it = _block_door_pos_hpr_map.begin();
it != _block_door_pos_hpr_map.end();
++it) {
if (index == current) {
nassertr((*it).first != 0, 0);
return (*it).first;
}
current++;
}
dna_cat.error()
<< "DNAStorage::get_door_pos_hpr_block_at index not found, returning 0"
<< std::endl;
return 0;
}
////////////////////////////////////////////////////////////////////
// Function: store_block_sign_transform
// Access: Public
// Description: Store a block and zone
////////////////////////////////////////////////////////////////////
void DNAStorage::store_block_sign_transform(const std::string& block,
const LMatrix4f& mat) {
nassertv(!block.empty());
_block_sign_transform_map[atoi(block.c_str())]=mat;
}
////////////////////////////////////////////////////////////////////
// Function: get_sign_transform_from_block_number
// Access: Public
// Description:
////////////////////////////////////////////////////////////////////
const LMatrix4f& DNAStorage::get_sign_transform_from_block_number(int block_number) const {
// Try to find this code in the map
BlockToTransformMap::const_iterator i = _block_sign_transform_map.find(block_number);
if (i == _block_sign_transform_map.end()) {
dna_cat.error()
<< "block number: " << block_number << " not found in map" << std::endl;
return LMatrix4f::ident_mat();
}
return (*i).second;
}
////////////////////////////////////////////////////////////////////
// Function: get_num_block_sign_transforms
// Access: Public
// Description: Ask how many block numbers
////////////////////////////////////////////////////////////////////
int DNAStorage::get_num_block_sign_transforms() const {
return _block_sign_transform_map.size();
}
////////////////////////////////////////////////////////////////////
// Function: get_sign_transform_block_at
// Access: Public
// Description: Get key at index
////////////////////////////////////////////////////////////////////
int DNAStorage::get_sign_transform_block_at(uint index) const {
nassertr(index < _block_sign_transform_map.size(), 0);
uint current = 0;
// Loop over the map entries:
for(BlockToTransformMap::const_iterator it = _block_sign_transform_map.begin();
it != _block_sign_transform_map.end();
++it) {
if (index == current) {
nassertr((*it).first != 0, 0);
return (*it).first;
}
current++;
}
dna_cat.error()
<< "DNAStorage::get_sign_transform_block_at index not found, returning 0"
<< std::endl;
return 0;
}
////////////////////////////////////////////////////////////////////
// Function: store_block_title
// Access: Public
// Description: Store a block and zone
////////////////////////////////////////////////////////////////////
void DNAStorage::store_block_title(const std::string& block,
const std::string& title) {
nassertv(!block.empty());
_block_title_map[atoi(block.c_str())]=title;
}
////////////////////////////////////////////////////////////////////
// Function: get_title_from_block_number
// Access: Public
// Description:
////////////////////////////////////////////////////////////////////
std::string DNAStorage::get_title_from_block_number(int block_number) const {
// Try to find this code in the map
BlockToTitleMap::const_iterator i = _block_title_map.find(block_number);
if (i == _block_title_map.end()) {
dna_cat.error()
<< "block number: " << block_number << " not found in title map" << std::endl;
return "";
}
return (*i).second;
}
////////////////////////////////////////////////////////////////////
// Function: store_block_article
// Access: Public
// Description: Store a block and zone
////////////////////////////////////////////////////////////////////
void DNAStorage::store_block_article(const std::string& block,
const std::string& article) {
nassertv(!block.empty());
_block_article_map[atoi(block.c_str())]=article;
}
////////////////////////////////////////////////////////////////////
// Function: get_article_from_block_number
// Access: Public
// Description:
////////////////////////////////////////////////////////////////////
std::string DNAStorage::get_article_from_block_number(int block_number) const {
// Try to find this code in the map
BlockToArticleMap::const_iterator i = _block_article_map.find(block_number);
if (i == _block_article_map.end()) {
dna_cat.error()
<< "block number: " << block_number << " not found in article map" << std::endl;
return "";
}
return (*i).second;
}
////////////////////////////////////////////////////////////////////
// Function: store_block_building_type
// Access: Public
// Description: Store a block and zone
////////////////////////////////////////////////////////////////////
void DNAStorage::
store_block_building_type(const std::string& block, const std::string& type) {
nassertv(!block.empty());
// Get the block number (e.g. in "tb22:blah_blah" the block number is "22").
std::string block_num = block.substr(2, block.find(':')-2);
dna_cat.debug()
<< "block: " << block << "blocknum: " << block_num << " type:" << type << std::endl;
_block_building_type_map[atoi(block_num.c_str())]=type;
}
////////////////////////////////////////////////////////////////////
// Function: get_block_building_type
// Access: Public
// Description:
////////////////////////////////////////////////////////////////////
std::string DNAStorage::get_block_building_type(int block_number) const {
// Try to find this code in the map
BlockToBuildingTypeMap::const_iterator i = _block_building_type_map.find(block_number);
// If it is not found, consider it false
if (i == _block_building_type_map.end()) {
dna_cat.debug()
<< "block number: " << block_number << " not found in building type map" << std::endl;
return "";
}
return (*i).second;
}
////////////////////////////////////////////////////////////////////
// Function: get_num_block_titles
// Access: Public
// Description: Ask how many block numbers
////////////////////////////////////////////////////////////////////
int DNAStorage::get_num_block_titles() const {
return _block_title_map.size();
}
////////////////////////////////////////////////////////////////////
// Function: get_title_block_at
// Access: Public
// Description: Get key at index
////////////////////////////////////////////////////////////////////
int DNAStorage::get_title_block_at(uint index) const {
nassertr(index < _block_title_map.size(), 0);
uint current = 0;
// Loop over the map entries:
for(BlockToTitleMap::const_iterator it = _block_title_map.begin();
it != _block_title_map.end();
++it) {
if (index == current) {
nassertr((*it).first != 0, 0);
return (*it).first;
}
current++;
}
dna_cat.error()
<< "DNAStorage::get_title_block_at index not found, returning 0"
<< std::endl;
return 0;
}
////////////////////////////////////////////////////////////////////
// Function: store_battle_cell
// Access: Public
// Description: Store a battle cell in the battle cell vector
////////////////////////////////////////////////////////////////////
void DNAStorage::store_battle_cell(PT(DNABattleCell) cell) {
nassertv(cell != (DNABattleCell *)NULL);
_battle_cell_vector.push_back(cell);
}
////////////////////////////////////////////////////////////////////
// Function: remove_battle_cell
// Access: Public
// Description: Remove a battle cell from the battle cell vector
////////////////////////////////////////////////////////////////////
int DNAStorage::remove_battle_cell(PT(DNABattleCell) cell) {
nassertr(cell != (DNABattleCell *)NULL, -1);
BattleCellVector::iterator i = find(_battle_cell_vector.begin(),
_battle_cell_vector.end(),
cell);
if (i == _battle_cell_vector.end()) {
// Could not find this cell
return 0;
};
_battle_cell_vector.erase(i);
return 1;
}
////////////////////////////////////////////////////////////////////
// Function: store_suit_edge
// Access: Public
// Description: Store a suit edge represented by the start and end
// indexes in the suit start point map. These indexes
// better be stored in the suit_point_vector already
////////////////////////////////////////////////////////////////////
PT(DNASuitEdge) DNAStorage::store_suit_edge(int start_index,
int end_index,
std::string zone_id) {
PT(DNASuitPoint) start_point = get_suit_point_with_index(start_index);
nassertr(start_point != (DNASuitPoint *)NULL, (DNASuitEdge *)NULL);
PT(DNASuitPoint) end_point = get_suit_point_with_index(end_index);
nassertr(end_point != (DNASuitPoint *)NULL, (DNASuitEdge *)NULL);
// Make a brand new edge from start to end in zone_id
PT(DNASuitEdge) edge = new DNASuitEdge(start_point,
end_point,
zone_id);
// Now store that edge for real
return store_suit_edge(edge);
}
////////////////////////////////////////////////////////////////////
// Function: store_suit_edge
// Access: Public
// Description: Store a suit edge in the suit start point map,
// listed under the index of the start point
////////////////////////////////////////////////////////////////////
PT(DNASuitEdge) DNAStorage::store_suit_edge(PT(DNASuitEdge) edge) {
nassertr(edge != (DNASuitEdge *)NULL, (DNASuitEdge *)NULL);
if (edge->get_start_point() == edge->get_end_point()) {
// Don't add degenerate edges.
return edge;
}
int start_index = edge->get_start_point()->get_index();
SuitEdgeVector &sev = _suit_start_point_map[start_index];
// Make sure the edge isn't already there first.
SuitEdgeVector::iterator ei;
for (ei = sev.begin(); ei != sev.end(); ++ei) {
if (*(*ei) == *edge) {
return (*ei);
}
}
sev.push_back(edge);
return edge;
}
////////////////////////////////////////////////////////////////////
// Function: remove_suit_edge
// Access: Public
// Description: Removes a suit edge from the map
////////////////////////////////////////////////////////////////////
int DNAStorage::remove_suit_edge(PT(DNASuitEdge) edge) {
nassertr(edge != (DNASuitEdge *)NULL, -1);
int found = 0;
// Try to find this start_index in the map
int start_index = edge->get_start_point()->get_index();
SuitStartPointMap::iterator i = _suit_start_point_map.find(start_index);
// If we did not find it, there is nothing to remove
if (i != _suit_start_point_map.end()) {
SuitEdgeVector::iterator ei = find((*i).second.begin(),
(*i).second.end(),
edge);
if (ei != (*i).second.end()) {
// Erase him out of our vector
dna_cat.debug() << "removed edge from suit edge vector" << std::endl;
(*i).second.erase(ei);
found = 1;
}
}
// remove the edge from any vis groups that contain it
for(VisGroupVectorAI::const_iterator vi = _vis_group_vector.begin();
vi != _vis_group_vector.end();
++vi) {
if ((*vi)->remove_suit_edge(edge)) {
dna_cat.debug() << "removed edge from vis group " << (*vi)->get_name() << std::endl;
}
}
return found;
}
////////////////////////////////////////////////////////////////////
// Function: find_texture
// Access: Public
// Description: A convenient interface if you only know the codes
// by name, not by number
////////////////////////////////////////////////////////////////////
PT(Texture) DNAStorage::find_texture(const std::string &dna_string) const {
// Try to find this code in the map
TextureMap::const_iterator i = _texture_map.find(dna_string);
if (i == _texture_map.end()) {
dna_cat.error()
<< "texture: " << dna_string << " not found in map" << std::endl;
return (Texture *)NULL;
}
return (*i).second;
}
////////////////////////////////////////////////////////////////////
// Function: find_node
// Access: Public
// Description: A convenient interface if you only know the codes
// by name, not by number
////////////////////////////////////////////////////////////////////
NodePath DNAStorage::find_node(const std::string &dna_string) const {
// Try to find this code in the map
NodeMap::const_iterator i = _node_map.find(dna_string);
if (i == _node_map.end()) {
// Then try to find this code in the hood node map
i = _hood_node_map.find(dna_string);
if (i == _hood_node_map.end()) {
// Then try to find this code in the place node map
i = _place_node_map.find(dna_string);
if (i == _place_node_map.end()) {
dna_cat.debug()
<< "node: " << dna_string
<< " not found in pool, hood, or place map, returning empty NodePath" << std::endl;
return NodePath();
}
}
}
return (*i).second;
}
////////////////////////////////////////////////////////////////////
// Function: find_node
// Access: Public
// Description: A convenient interface if you only know the codes
// by name, not by number
////////////////////////////////////////////////////////////////////
PT(TextFont) DNAStorage::find_font(const std::string &dna_string) const {
// Try to find this code in the map
FontMap::const_iterator i = _font_map.find(dna_string);
if (i == _font_map.end()) {
dna_cat.error()
<< "font: " << dna_string << " not found in map" << std::endl;
return (TextFont *)NULL;
}
return (*i).second;
}
////////////////////////////////////////////////////////////////////
// Function: store_catalog_string
// Access: Public
// Description: Add a string
////////////////////////////////////////////////////////////////////
void DNAStorage::store_catalog_string(const std::string &catalog_string, const std::string &dna_string) {
// Try to find this catalog in the map
CodeCatalog::iterator i = _code_catalog.find(catalog_string);
// If we did not find it, put a new CodeSet at this new catalog
if (i == _code_catalog.end()) {
CodeSet cs;
cs.insert(dna_string);
_code_catalog[catalog_string] = cs;
} else {
// If we did find the catalog string in the catalog, see if the specified dna string is already in the code map
CodeSet::iterator csi = ((*i).second).find(dna_string);
if (csi == ((*i).second).end()) {
// Not in the code vector, add it
((*i).second).insert(dna_string);
return;
}
}
return;
}
////////////////////////////////////////////////////////////////////
// Function: get_num_catalog_codes
// Access: Public
// Description: Return the number of entries in this catalog
// Return -1 if the catalog is not found
////////////////////////////////////////////////////////////////////
int DNAStorage::get_num_catalog_codes(const std::string &catalog_string) const {
// Try to find this catalog in the map
CodeCatalog::const_iterator i = _code_catalog.find(catalog_string);
// If we did not find it just return -1
if (i == _code_catalog.end()) {
return -1;
} else {
// If we did find it, return the size of is
return (*i).second.size();
}
}
////////////////////////////////////////////////////////////////////
// Function: get_catalog_code
// Access: Public
// Description: Return the number of entries in this catalog
// Return empty string if the catalog is not found
////////////////////////////////////////////////////////////////////
std::string DNAStorage::get_catalog_code(const std::string &catalog_string, int index) const {
// Try to find this catalog in the map
CodeCatalog::const_iterator i = _code_catalog.find(catalog_string);
// If we did not find it just return an empty string
if (i == _code_catalog.end()) {
return "";
} else {
// If we did find it, return the string
// Loop over the items in this category to get to the desired item
int count = 0;
for(CodeSet::const_iterator csi = ((*i).second).begin();
csi != ((*i).second).end();
++csi) {
if (count == index) {
return (*csi);
}
count++;
}
return "";
}
}
////////////////////////////////////////////////////////////////////
// Function: print_catalog
// Access: Public
// Description: print the catalog
////////////////////////////////////////////////////////////////////
void DNAStorage::print_catalog() const {
std::cout << "Category" << std::endl;
// Loop over the categories
for(CodeCatalog::const_iterator i = _code_catalog.begin();
i != _code_catalog.end();
++i) {
std::cout << "Category: " << (*i).first << std::endl;
// Loop over the items in this category
for(CodeSet::const_iterator csi = ((*i).second).begin();
csi != ((*i).second).end();
++csi) {
std::cout << "\t" << (*csi) << std::endl;
}
}
}
////////////////////////////////////////////////////////////////////
// Function: store_DNAGroup
// Access: Public
// Description: store a DNAGroup at the node path pointer
////////////////////////////////////////////////////////////////////
void DNAStorage::store_DNAGroup(PT(PandaNode) rr, PT(DNAGroup) group) {
nassertv(rr != (PandaNode *)NULL);
nassertv(group != (DNAGroup *)NULL);
// Return the group
_n2group_map[rr] = group;
}
////////////////////////////////////////////////////////////////////
// Function: find_DNAGroup
// Access: Public
// Description: find a DNAGroup at the node path pointer
////////////////////////////////////////////////////////////////////
PT(DNAGroup) DNAStorage::find_DNAGroup(PT(PandaNode) rr) const {
nassertr(rr != (PandaNode *)NULL, (DNAGroup *)NULL);
// Try to find this group in the map
Node2GroupMap::const_iterator i = _n2group_map.find(rr);
if (i == _n2group_map.end()) {
dna_cat.debug()
<< "PandaNode not found in Node2GroupMap" << std::endl;
return (DNAGroup *)NULL;
}
nassertr((*i).second != (DNAGroup *)NULL, (DNAGroup *)NULL);
return (*i).second;
}
////////////////////////////////////////////////////////////////////
// Function: find_PandaNode
// Access: Public
// Description: find a PandaNode at the DNAGroup
////////////////////////////////////////////////////////////////////
PT(PandaNode) DNAStorage::find_PandaNode(PT(DNAGroup) group) const {
nassertr(group != (DNAGroup *)NULL, (PandaNode *)NULL);
// Since the node relations are actually the keys in this map, we
// loop over all the entries, looking to see if the value (i.second)
// matches the group passed in. If it does we return the key (i.first)
// Note that it is possible for the map to contain multiple group values
// that are the same, but this application should not do that. We simply
// return the first one that matches
for(Node2GroupMap::const_iterator i = _n2group_map.begin();
i != _n2group_map.end();
++i) {
if (group == (*i).second) {
return (*i).first;
}
}
// Ok, now look in the vis group map and see if it is in there
for(Node2VisGroupMap::const_iterator vi = _n2visgroup_map.begin();
vi != _n2visgroup_map.end();
++vi) {
if (group == (DNAGroup *)(*vi).second) {
return (*vi).first;
}
}
// If you got here, you did not find it
dna_cat.error()
<< "DNAStorage::find_PandaNode: DNAGroup <"
<< group->get_name() << " type: " << group->get_type()
<< "> not found in Node2GroupMap or Node2VisGroupMap" << std::endl;
return (PandaNode *)NULL;
}
////////////////////////////////////////////////////////////////////
// Function: remove_DNAGroup
// Access: Public
// Description: remove the DNAGroup pointed to by rr from the map
// It also removes all children of the dnaGroup.
// Returns the total number of DNAGroups removed.
////////////////////////////////////////////////////////////////////
int DNAStorage::remove_DNAGroup(PT(PandaNode) rr) {
nassertr((rr != (PandaNode *)NULL), 0);
// Recursively remove all children of this DNAGroup
PT(DNAGroup) group = find_DNAGroup(rr);
if (group == (DNAGroup *)NULL) {
dna_cat.warning()
<< "Render relation did not point to any DNAGroups in the storage" << std::endl;
return 0;
} else {
return remove_DNAGroup(group);
}
}
////////////////////////////////////////////////////////////////////
// Function: remove_DNAGroup
// Access: Public
// Description: remove the DNAGroup from the map
// It also removes all children of the dnaGroup.
// Returns the total number of DNAGroups removed.
////////////////////////////////////////////////////////////////////
int DNAStorage::remove_DNAGroup(PT(DNAGroup) group) {
int num_removed = 0;
PT(PandaNode) rr = find_PandaNode(group);
if (rr != (PandaNode *)NULL) {
num_removed += _n2group_map.erase(rr);
}
// Recursively remove all children of this DNAGroup
int num_children = group->get_num_children();
for (int i=0; i < num_children; i++) {
PT(DNAGroup) child = group->at(i);
num_removed += remove_DNAGroup(child);
}
return num_removed;
}
////////////////////////////////////////////////////////////////////
// Function: find_DNAVisGroup
// Access: Public
// Description: find a DNAVisGroup at the node path pointer
////////////////////////////////////////////////////////////////////
PT(DNAVisGroup) DNAStorage::find_DNAVisGroup(PT(PandaNode) rr) const {
nassertr(rr != (PandaNode *)NULL, (DNAVisGroup *)NULL);
// Try to find this code in the map
Node2VisGroupMap::const_iterator i = _n2visgroup_map.find(rr);
if (i == _n2visgroup_map.end()) {
dna_cat.error()
<< "DNAStorage::find_DNAVisGroup: NodePath not found in Node2VisGroupMap" << std::endl;
return (DNAVisGroup *)NULL;
}
nassertr((*i).second != (DNAVisGroup *)NULL, (DNAVisGroup *)NULL);
return (*i).second;
}
////////////////////////////////////////////////////////////////////
// Function: get_DNAVisGroup
// Access: Public
// Description: Return the ith vis group in our storage
////////////////////////////////////////////////////////////////////
PT(DNAVisGroup) DNAStorage::get_DNAVisGroup(uint i) const {
nassertr(i < _n2visgroup_map.size(), (DNAVisGroup *)NULL);
uint current = 0;
// Loop over the vis groups
for(Node2VisGroupMap::const_iterator it = _n2visgroup_map.begin();
it != _n2visgroup_map.end();
++it) {
if (i == current) {
nassertr((*it).first != (PandaNode *)NULL, (DNAVisGroup *)NULL);
return (*it).second;
}
current++;
}
dna_cat.error()
<< "DNAStorage::get_DNAVisGroup: vis group not found, returning NULL"
<< std::endl;
return (DNAVisGroup *)NULL;
}
////////////////////////////////////////////////////////////////////
// Function: get_num_visibles_in_DNAVisGroup
// Access: Public
// Description: Ask how many visibles there are in this visgroup
////////////////////////////////////////////////////////////////////
int DNAStorage::get_num_visibles_in_DNAVisGroup(uint i) const {
PT(DNAVisGroup) group;
group = get_DNAVisGroup(i);
if (group != (DNAVisGroup *)NULL) {
return group->get_num_visibles();
}
else {
dna_cat.error()
<< "DNAStorage::get_num_visibles_in_DNAVisGroup: vis group not found"
<< " returning -1" << std::endl;
return -1;
}
}
////////////////////////////////////////////////////////////////////
// Function: get_DNAVisGroup_name
// Access: Public
// Description: Ask for the name of the nth DNAVisGroup in the map
////////////////////////////////////////////////////////////////////
std::string DNAStorage::get_DNAVisGroup_name(uint i) const {
PT(DNAVisGroup) group;
group = get_DNAVisGroup(i);
if (group != (DNAVisGroup *)NULL) {
return group->get_name();
}
else {
dna_cat.error()
<< "DNAStorage::get_DNAVisGroup_name: vis group not found,"
<< " returning empty string" << std::endl;
return "";
}
}
////////////////////////////////////////////////////////////////////
// Function: get_visible_name
// Access: Public
// Description: Ask for the name of the nth visible in the nth DNAVisGroup
////////////////////////////////////////////////////////////////////
std::string DNAStorage::get_visible_name(uint visgroup_index, uint visible_index) const {
PT(DNAVisGroup) group;
group = get_DNAVisGroup(visgroup_index);
if (group != (DNAVisGroup *)NULL) {
return group->get_visible_name(visible_index);
}
else {
dna_cat.error()
<< "DNAStorage::get_num_visibles_in_DNAVisGroup: vis group not found,"
<< " returning empty string" << std::endl;
return "";
}
}
////////////////////////////////////////////////////////////////////
// Function: store_DNAVisGroupAI
// Access: Public
// Description: store a DNAVisGroup in a vector so the AI can
// retrieve it without traversing the DNA
////////////////////////////////////////////////////////////////////
void DNAStorage::store_DNAVisGroupAI(PT(DNAVisGroup) vis_group) {
nassertv(vis_group != (DNAVisGroup *)NULL);
_vis_group_vector.push_back(vis_group);
}
////////////////////////////////////////////////////////////////////
// Function: get_PandaNode_at
// Access: Public
// Description: return the ith NodePath
////////////////////////////////////////////////////////////////////
PT(PandaNode) DNAStorage::get_PandaNode_at(uint i) const {
nassertr(i < _n2group_map.size(), (PandaNode *)NULL);
uint current = 0;
// Loop over the PandaNodes
for(Node2GroupMap::const_iterator it = _n2group_map.begin();
it != _n2group_map.end();
++it) {
if (i == current) {
nassertr((*it).first != (PandaNode *)NULL, (PandaNode *)NULL);
return (*it).first;
}
current++;
}
dna_cat.error()
<< "DNAStorage::get_PandaNode_at PandaNode not found, returning NULL"
<< std::endl;
return (PandaNode *)NULL;
}
void DNAStorage::print_PandaNodes() const {
// Loop over the PandaNodes
for(Node2GroupMap::const_iterator it = _n2group_map.begin();
it != _n2group_map.end();
++it) {
std::cout << "PandaNode " << (void *)(*it).first
<< " DNAGroup " << (void *)(*it).second
<< " " << ((*it).second)->get_name() << std::endl;
}
// Don't forget the vis groups
for(Node2VisGroupMap::const_iterator vit = _n2visgroup_map.begin();
vit != _n2visgroup_map.end();
++vit) {
std::cout << "PandaNode " << (void *)(*vit).first
<< " DNAVisGroup " << (void *)(*vit).second
<< " " << ((*vit).second)->get_name() << std::endl;
}
}
////////////////////////////////////////////////////////////////////
// Function: get_suit_edge
// Access: Public
// Description: Ask for the edge that connects these two points
////////////////////////////////////////////////////////////////////
PT(DNASuitEdge) DNAStorage::get_suit_edge(int start_index, int end_index) const {
// Look in the start point map for this start index
SuitStartPointMap::const_iterator i = _suit_start_point_map.find(start_index);
if (i == _suit_start_point_map.end()) {
dna_cat.error()
<< "DNASuitStartPoint index: " << start_index
<< " not found in map" << std::endl;
return (DNASuitEdge *)NULL;
} else {
// Ok, found the start index, lets see if it connects directly to
// the end index. Find the end index in the edge vector associated
// with this start index
for(SuitEdgeVector::const_iterator evi = ((*i).second).begin();
evi != ((*i).second).end();
++evi) {
if (end_index == (*evi)->get_end_point()->get_index()) {
// Found it, return the edge
return (*evi);
}
}
// Did not find the end point connected to this start point
dna_cat.error()
<< "DNASuitStartPoint start index: " << start_index
<< " not connected to end index: " << end_index << std::endl;
return (DNASuitEdge *)NULL;
}
}
////////////////////////////////////////////////////////////////////
// Function: get_suit_edge_zone
// Access: Public
// Description: Ask for the zone that this edge is in
// Returns -1 if there is no edge between these points
////////////////////////////////////////////////////////////////////
std::string DNAStorage::get_suit_edge_zone(int start_index, int end_index) const {
// First find the edge that connects these two points
PT(DNASuitEdge) edge = get_suit_edge(start_index, end_index);
// Make sure the edge is valid, if not, return empty string
nassertr(edge != (DNASuitEdge *)NULL, "");
// Return the zone this edge thinks it is in
return edge->get_zone_id();
}
////////////////////////////////////////////////////////////////////
// Function: get_suit_travel_time
// Access: Public
// Description: Ask how long in seconds it will take a suit to walk
// from the start point to the end point if he is
// walking this constant rate in units/second
// If there is not connection, return -1.0
////////////////////////////////////////////////////////////////////
float DNAStorage::get_suit_edge_travel_time(int start_index,
int end_index,
float rate) const {
// Make sure the rate is a positive number
nassertr(rate > 0.0, -1.0);
// Find the edge that connects these two points
PT(DNASuitEdge) edge = get_suit_edge(start_index, end_index);
// Make sure the edge is valid, if not, return -1.0
nassertr(edge != (DNASuitEdge *)NULL, -1.0);
// Find the distance between the two points
float distance = length(edge->get_end_point()->get_pos() - edge->get_start_point()->get_pos());
// Compute the time
float time = (distance / rate);
return time;
}
////////////////////////////////////////////////////////////////////
// Function: get_suit_path
// Access: Public
// Description: Find a valid path from start to end for a suit to
// walk on given all the points and edges that are
// loaded in the current branch
// To make this easy, the SuitStartPointMap is organized
// as a map of points to edge lists that that point starts
// {
// start_point1 { edge1 edge2 edge3 }
// start_point2 { edge4 edge5 }
// start_point3 { edge6 edge7 edge8 }
// }
////////////////////////////////////////////////////////////////////
PT(DNASuitPath) DNAStorage::
get_suit_path(const DNASuitPoint *start_point, const DNASuitPoint *end_point,
int min_length, int max_length) const {
if (start_point->get_graph_id() != end_point->get_graph_id()) {
if (dna_cat.is_debug()) {
dna_cat.debug()
<< "Not looking for path between disconnected points "
<< (*start_point) << " and " << (*end_point) << ".\n";
}
return NULL;
}
if (dna_cat.is_debug()) {
dna_cat.debug()
<< "get_suit_path: About to look for path from "
<< (*start_point)
<< " to " << (*end_point)
<< " min_length = " << min_length << ", max_length = "
<< max_length << "\n";
}
PT(DNASuitPath) path =
get_suit_path_breadth_first(start_point, end_point, min_length, max_length);
if (path != (DNASuitPath *)NULL) {
if (dna_cat.is_debug()) {
dna_cat.debug()
<< "get_suit_path: Path from " << (*start_point)
<< " to " << (*end_point) << " is "
<< (*path) << std::endl;
dna_cat.debug()
<< "get_suit_path: Path contains " << path->get_num_points()
<< " points " << std::endl;
}
} else {
dna_cat.warning()
<< "get_suit_path: could not find path" << std::endl
<< " from: " << (*start_point) << std::endl
<< " to: " << (*end_point) << std::endl;
}
return path;
}
////////////////////////////////////////////////////////////////////
// Function: get_adjacent_points
// Access: Public
// Description: Returns all of the points adjacent to the indicated
// point. The result is returned as a DNASuitPath, even
// though it's not actually a path; it's just a set of
// points.
////////////////////////////////////////////////////////////////////
PT(DNASuitPath) DNAStorage::
get_adjacent_points(PT(DNASuitPoint) start_point) const {
PT(DNASuitPath) path = new DNASuitPath();
int current_point_index = start_point->get_index();
SuitStartPointMap::const_iterator si =
_suit_start_point_map.find(current_point_index);
if (si == _suit_start_point_map.end()) {
return path;
}
// Get each edge connecting to the current point.
SuitEdgeVector edge_list = (*si).second;
for(SuitEdgeVector::const_iterator evi = edge_list.begin();
evi != edge_list.end(); ++evi) {
PT(DNASuitEdge) edge = (*evi);
PT(DNASuitPoint) end_point = edge->get_end_point();
path->add_point(end_point->get_index());
}
return path;
}
////////////////////////////////////////////////////////////////////
// Function: discover_continuity
// Access: Public
// Description: This should be called once the DNA file has been read
// and the set of suit points is complete. It walks
// through the points and discovers which points are
// connected to each other and which are not. Each
// group of suit points that can be reached from each
// other are assigned a unique graph_id number, which
// has no other meaning. The return value is the number
// of disconnected graphs we have.
////////////////////////////////////////////////////////////////////
int DNAStorage::
discover_continuity() {
int graph_id = 0;
SuitPointVector::iterator vi;
for (vi = _suit_point_vector.begin(); vi != _suit_point_vector.end(); ++vi) {
DNASuitPoint *point = (*vi);
if (point->get_graph_id() == 0) {
graph_id++;
// Recursively discover all the points that are connected to
// point, and identify them all with graph_id.
r_discover_connections(point, graph_id);
}
}
return graph_id;
}
////////////////////////////////////////////////////////////////////
// Function: r_discover_connections
// Access: Private
// Description: Called by discover_continuity() recursively find all
// the points that are connected to the indicated point.
////////////////////////////////////////////////////////////////////
void DNAStorage::
r_discover_connections(DNASuitPoint *point, int graph_id) {
if (point->get_graph_id() != 0) {
if (point->get_graph_id() != graph_id) {
dna_cat.warning()
<< *point << " is connected to graph only one-way.\n";
}
return;
}
point->set_graph_id(graph_id);
int point_index = point->get_index();
SuitStartPointMap::const_iterator si =
_suit_start_point_map.find(point_index);
if (si == _suit_start_point_map.end()) {
dna_cat.warning()
<< "Could not find point " << point_index << " in map.\n";
} else {
const SuitEdgeVector &edge_list = (*si).second;
for(SuitEdgeVector::const_iterator evi = edge_list.begin();
evi != edge_list.end();
++evi) {
DNASuitEdge *edge = (*evi);
r_discover_connections(edge->get_end_point(), graph_id);
}
}
}
PT(DNASuitPath) DNAStorage::
get_suit_path_breadth_first(const DNASuitPoint *start_point,
const DNASuitPoint *end_point,
int min_length, int max_length) const {
// Perform a breadth-first traversal of the connected suit points to
// try to find the shortest path from start_point to end_point that
// is at least min_length points long (and not longer than
// max_length).
// To performing a breadth-first traversal, you must first generate
// all the paths of length 1, then all the paths of length 2, then
// all the paths of length 3, etc. You must keep around all the
// paths of each generation until you have generated all the paths
// of the next generation (or found a solution).
// We use the WorkingSuitPath nested class to generate these paths
// with a minimal overhead. Each instance of a WorkingSuitPath
// object represents one step in a path. A linked list of
// WorkingSuitPath objects represents one complete path under
// consideration. This "path" is defined by the _next_in_path
// member of WorkingSuitPath; traversing through these pointers in
// reverse order gives the original path.
// Each generation of the search requires storing several of these
// paths, in no particular order. We store this set of paths as a
// linked chain of pointers to the heads of the individual paths;
// these are traversed by walking through the _next_in_chain
// members. That is, each WorkingSuitPath object pointed to by the
// _next_in_chain member represents the head of a different path,
// which may then be traversed along the _next_in_path member.
// Finally, for efficient memory management, we don't actually free
// these WorkingSuitPath objects; instead, they get added to a
// deleted chain, which is a linked list defined by the
// _next_deleted member.
// Start with one path on the queue that has only the start point.
PT(WorkingSuitPath) chain = new WorkingSuitPath(start_point->get_index());
int length = 1;
// First, generate all the paths from start_point that contain at
// least (min_length - 1) steps. In this pass, we may visit points
// multiple times and thus generate looping paths.
while (length < min_length - 1) {
++length;
if (dna_cat.is_debug()) {
// Count up the number of paths on the chain for debug output.
int num_paths = 0;
for (WorkingSuitPath *p = chain;
p != (WorkingSuitPath *)NULL;
p = p->_next_in_chain) {
num_paths++;
}
dna_cat.debug()
<< "Generating from " << num_paths << " paths of length " << length
<< "\n";
}
generate_next_suit_path_chain(chain);
}
// Now, we're ready to start looking for an actual solution.
// Generate all the paths that contain min_length steps and more.
// From now on, we stop considering loops, since looping won't take
// us closer to a solution, and it just increases our search time.
pset<int> visited_points;
while (length < max_length && chain != (WorkingSuitPath *)NULL) {
++length;
if (dna_cat.is_debug()) {
// Count up the number of paths on the chain for debug output.
int num_paths = 0;
for (WorkingSuitPath *p = chain;
p != (WorkingSuitPath *)NULL;
p = p->_next_in_chain) {
num_paths++;
}
dna_cat.debug()
<< "Considering " << num_paths << " paths of length " << length
<< "\n";
}
if (consider_next_suit_path_chain(chain, end_point, visited_points)) {
// We found a solution!
PT(DNASuitPath) path = new DNASuitPath(length);
chain->get_path(path);
return path;
}
}
// No solution could be found within the prescribed length.
return NULL;
}
void DNAStorage::
generate_next_suit_path_chain(PT(DNAStorage::WorkingSuitPath) &chain) const {
// Make a complete pass through the chain of working paths given in
// chain. At this point, we are not looking for a solution; we are
// just looking to see where we can go from the current point(s).
PT(WorkingSuitPath) next_chain = NULL;
PT(WorkingSuitPath) current_path = chain;
while (current_path != (WorkingSuitPath *)NULL) {
PT(WorkingSuitPath) next_path = current_path->_next_in_chain;
current_path->_next_in_chain = (WorkingSuitPath *)NULL;
int current_point_index = current_path->get_point_index();
if (dna_cat.is_spam()) {
dna_cat.spam()
<< "Generating next path: [ ";
current_path->output(dna_cat.spam(false));
dna_cat.spam(false)
<< " ]\n";
}
// Some edges are incorrectly given backwards in the dna files
// (along with their correct forwards listing). To detect and
// avoid these, we must ensure they do not take us back to the
// previous point in the path.
int prev_point_index = -1;
if (current_path->_next_in_path != (WorkingSuitPath *)NULL) {
prev_point_index = current_path->_next_in_path->get_point_index();
}
// Try to find this current point index in the map
SuitStartPointMap::const_iterator si =
_suit_start_point_map.find(current_point_index);
if (si == _suit_start_point_map.end()) {
dna_cat.warning()
<< "Could not find point " << current_point_index << " in map.\n";
} else {
// Look over each edge connecting to current point index
const SuitEdgeVector &edge_list = (*si).second;
for(SuitEdgeVector::const_iterator evi = edge_list.begin();
evi != edge_list.end();
++evi) {
DNASuitEdge *edge = (*evi);
int next_point_index = edge->get_end_point()->get_index();
if (dna_cat.is_spam()) {
dna_cat.spam()
<< "get_suit_path_breadth_first: Examining edge: "
<< (*edge) << std::endl;
}
// We don't step off the street points unless it is onto our
// final, solution point.
if (!edge->get_end_point()->is_terminal()) {
if (next_point_index == current_point_index ||
next_point_index == prev_point_index) {
dna_cat.warning()
<< "Invalid edge detected in dna: " << (*edge) << "\n";
} else {
// Extend the path by the current point and save it on the
// new chain.
PT(WorkingSuitPath) new_path =
new WorkingSuitPath(current_path, next_point_index);
new_path->_next_in_chain = next_chain;
next_chain = new_path;
}
} else if (dna_cat.is_spam()) {
dna_cat.spam()
<< "Rejected edge, not street point.\n";
}
}
}
current_path = next_path;
}
chain = next_chain;
}
bool DNAStorage::
consider_next_suit_path_chain(PT(DNAStorage::WorkingSuitPath) &chain,
const DNASuitPoint *end_point,
pset<int> visited_points) const {
// As above, but this time in addition to generating the next chain,
// we also look for a solution along the way. If one is found,
// returns true and set chain to the single found path. Otherwise,
// returns false and set chain to the next chain of paths generated.
PT(WorkingSuitPath) next_chain = NULL;
PT(WorkingSuitPath) current_path = chain;
while (current_path != (WorkingSuitPath *)NULL) {
PT(WorkingSuitPath) next_path = current_path->_next_in_chain;
current_path->_next_in_chain = (WorkingSuitPath *)NULL;
int current_point_index = current_path->get_point_index();
if (dna_cat.is_spam()) {
dna_cat.spam()
<< "Considering path: [ ";
current_path->output(dna_cat.spam(false));
dna_cat.spam(false)
<< " ]\n";
}
// Some edges are incorrectly given backwards in the dna files
// (along with their correct forwards listing). To detect and
// avoid these, we must ensure they do not take us back to the
// previous point in the path.
int prev_point_index = -1;
if (current_path->_next_in_path != (WorkingSuitPath *)NULL) {
prev_point_index = current_path->_next_in_path->get_point_index();
}
// Try to find this current point index in the map
SuitStartPointMap::const_iterator si =
_suit_start_point_map.find(current_point_index);
if (si == _suit_start_point_map.end()) {
dna_cat.warning()
<< "Could not find point " << current_point_index << " in map.\n";
} else {
// Look over each edge connecting to current point index
const SuitEdgeVector &edge_list = (*si).second;
for(SuitEdgeVector::const_iterator evi = edge_list.begin();
evi != edge_list.end();
++evi) {
DNASuitEdge *edge = (*evi);
int next_point_index = edge->get_end_point()->get_index();
if (dna_cat.is_spam()) {
dna_cat.spam()
<< "get_suit_path_breadth_first: Examining edge: "
<< (*edge) << std::endl;
}
// See if this is the one we are looking for
if (next_point_index == end_point->get_index()) {
// Add this final point
PT(WorkingSuitPath) new_path =
new WorkingSuitPath(current_path, next_point_index);
if (dna_cat.is_debug()) {
dna_cat.debug()
<< "Found solution:\n";
new_path->write(dna_cat.debug(false));
}
chain = new_path;
return true;
}
// We don't step off the street points unless it is onto our
// final, solution point.
if (!edge->get_end_point()->is_terminal()) {
if (next_point_index == current_point_index ||
next_point_index == prev_point_index) {
dna_cat.warning()
<< "Invalid edge detected in dna: " << (*edge) << "\n";
} else {
// Record that we have now visited this new point.
if (visited_points.insert(next_point_index).second) {
// Extend the path by the current point and save it on the
// new chain.
PT(WorkingSuitPath) new_path =
new WorkingSuitPath(current_path, next_point_index);
new_path->_next_in_chain = next_chain;
next_chain = new_path;
} else if (dna_cat.is_spam()) {
dna_cat.spam()
<< "Rejected edge, already visited " << next_point_index
<< ".\n";
}
}
} else if (dna_cat.is_spam()) {
dna_cat.spam()
<< "Rejected edge, not street point.\n";
}
}
}
current_path = next_path;
}
// All paths on the chain evaluated, and no solutions found. Carry on.
chain = next_chain;
return false;
}
////////////////////////////////////////////////////////////////////
// Function: get_block
// Access: Public
// Description: Get the block number as a string from the building
// name.
////////////////////////////////////////////////////////////////////
std::string DNAStorage::get_block(const std::string& name) const {
// The block number is in the parent name, between "tb" and ":"
// (e.g. "tb22:blah_blah").
size_t pos=name.find(':');
std::string block=name.substr(2, pos-2);
return block;
}
////////////////////////////////////////////////////////////////////
// Function: fixup
// Access: Public
// Description: Do any processing here before we write the file
// to cleanup or fixup the dna storage
////////////////////////////////////////////////////////////////////
void DNAStorage::fixup() {
// First, fix any coincident suit points
delete_unused_suit_points();
fix_coincident_suit_points();
}
////////////////////////////////////////////////////////////////////
// Function: write
// Access: Public
// Description: Write out to the dna file whatever the storage
// feels it needs to. For instance, the suit points.
////////////////////////////////////////////////////////////////////
void DNAStorage::write(std::ostream &out, int indent_level) const {
for(SuitPointVector::const_iterator i = _suit_point_vector.begin();
i != _suit_point_vector.end();
++i) {
(*i)->write(out, indent_level);
}
}
////////////////////////////////////////////////////////////////////
// Function: DNAStorage::WorkingSuitPath::get_path
// Access: Public
// Description: Converts the temporary WorkingSuitPath construct to a
// DNASuitPath object by recursively filling the
// indicated path up with each element, one at a time.
////////////////////////////////////////////////////////////////////
void DNAStorage::WorkingSuitPath::
get_path(DNASuitPath *path) const {
if (_next_in_path != (WorkingSuitPath *)NULL) {
_next_in_path->get_path(path);
}
path->add_point(get_point_index());
}
////////////////////////////////////////////////////////////////////
// Function: DNAStorage::WorkingSuitPath::output
// Access: Public
// Description:
////////////////////////////////////////////////////////////////////
void DNAStorage::WorkingSuitPath::
output(std::ostream &out) const {
if (_next_in_path != (WorkingSuitPath *)NULL) {
_next_in_path->output(out);
out << " " << get_point_index();
} else {
out << get_point_index();
}
}
////////////////////////////////////////////////////////////////////
// Function: DNAStorage::WorkingSuitPath::write
// Access: Public
// Description:
////////////////////////////////////////////////////////////////////
void DNAStorage::WorkingSuitPath::
write(std::ostream &out) const {
out << "[ ";
output(out);
out << " ]\n";
}
|
#ifndef GRABDRAGSCROLL_H
#define GRABDRAGSCROLL_H
#include <QtGui>
#include <QtCore>
#include <QtWebKit>
#include <QtGlobal>
class QObject;
class QTimerEvent;
class QEvent;
class QBasicTimer;
class QTimer;
class QWebView;
class QWebFrame;
class QString;
class QMouseEvent;
class QCursor;
struct ScrollData;
class GrabDragScroll : public QObject
{
Q_OBJECT
public:
explicit GrabDragScroll(QObject *parent = 0);
void installWidget(QWebView* widget, bool withoutBars = true);
bool eventFilter(QObject * obj, QEvent * event);
void timerEvent(QTimerEvent * event);
private:
QPoint scrollOffset(const QWebView* widget) const;
void setScrollOffset(QWebView* widget, const QPoint& p);
QPoint deaccelerate(const QPoint& speed, const int a=1, const int maxVal=64);
QBasicTimer* timer;
ScrollData* data;
};
#endif // GRABDRAGSCROLL_H
|
#pragma once
/* boost */
#include <boost/log/common.hpp>
#include <boost/log/attributes.hpp>
#include <boost/log/utility/setup/common_attributes.hpp>
#include <boost/log/utility/setup/from_settings.hpp>
#include <boost/log/utility/setup/from_stream.hpp>
#include <boost/log/utility/setup/formatter_parser.hpp>
#include <boost/log/utility/setup/filter_parser.hpp>
/* uscxml */
#include "uscxml/interpreter/LoggingImpl.h"
/* app */
#include "boost_logger_severity.h"
#include "UscxmlCLibCallbacks.h"
// Global logger declaration
typedef boost::log::sources::severity_logger_mt<SysLogSeverity> logger_t;
BOOST_LOG_INLINE_GLOBAL_LOGGER_DEFAULT(g_LOGGER, logger_t);
#define CLOG(VAL) BOOST_LOG_SEV(g_LOGGER::get(), SysLogSeverity::sl##VAL)
namespace uscxml {
class CLibLogger : public LoggerImpl {
private:
static SysLogSeverity UscxmlLogNamesToBoost(LogSeverity severity);
const bool _enabled;
const void *_ScxmlBase;
const OnInterpreterLog _OnInterpreterLog;
void *_OnInterpreterLogUser;
public:
CLibLogger(bool enabled, const void *AScxmlBase, const OnInterpreterLog AOnInterpreterLog, void *AUser);
virtual ~CLibLogger() {};
virtual std::shared_ptr<LoggerImpl> create() override;
virtual void log(LogSeverity severity, const Event& event) override;
virtual void log(LogSeverity severity, const Data& data) override;
virtual void log(LogSeverity severity, const std::string& message) override;
};
}
|
#pragma once
#include "Matrix.hh"
#include <cmath>
class Matrix3D : public Matrix<double,3>
{
public:
/**
* @brief Construct a new Matrix3D object
* Calculates the matrix of rotation.
* (Didn't really want to make new .cpp file
* for this one constructor.)
*
* @param angle rotation angle
*/
Matrix3D(double angle)
{
data[0][0] = cos(angle);
data[0][1] = sin(angle);
data[0][2] = 0;
data[1][0] = -sin(angle);
data[1][1] = cos(angle);
data[1][2] = 0;
data[2][0] = 0;
data[2][1] = 0;
data[2][2] = 1;
}
};
|
/**
* LAB WEEK 4: SHAPES
* CS3210
* @author Dennis Droese
* @date March 28, 2018
* @file line.cpp
*/
#include "shape.h"
line::line(double x0, double y0, double z0,
double x1, double y1, double z1){
p2 = new matrix(4,1);
(*p1)[0][0] = x0;
(*p1)[1][0] = y0;
(*p1)[2][0] = z0;
(*p1)[3][0] = 1.0;
(*p2)[0][0] = x1;
(*p2)[1][0] = y1;
(*p2)[2][0] = z1;
(*p2)[3][0] = 1.0;
}
line::line(double x0, double y0, double z0,
double x1, double y1, double z1,
unsigned int col){
p2 = new matrix(4,1);
(*p1)[0][0] = x0;
(*p1)[1][0] = y0;
(*p1)[2][0] = z0;
(*p1)[3][0] = 1.0;
(*p2)[0][0] = x1;
(*p2)[1][0] = y1;
(*p2)[2][0] = z1;
(*p2)[3][0] = 1.0;
color = col;
}
line::~line(){
delete p2;
}
line& line::operator=(const line& from){
delete p2;
p2 = from.p2;
return *this;
}
void line::draw(GraphicsContext* gc){
gc->setColor(color);
gc->drawLine((int)(*p1)[0][0],(int)(*p1)[1][0],(int)(*p2)[0][0],(int)(*p2)[1][0]);
}
void line::draw(GraphicsContext* gc, viewcontext* vc){
matrix t1(4,4);
matrix t2(4,4);
t1 = vc->applyTransform(*p1);
t2 = vc->applyTransform(*p2);
gc->setColor(color);
gc->drawLine((int)t1[0][0],(int)t1[1][0],(int)t2[0][0],(int)t2[1][0]);
}
std::ostream& line::out(std::ostream& output){
output << "LINE\t" << color << "\t"
<< (*p1)[0][0] << ' '
<< (*p1)[1][0] << ' '
<< (*p1)[2][0] << ' '
<< (*p1)[3][0] << "\t"
<< (*p2)[0][0] << ' '
<< (*p2)[1][0] << ' '
<< (*p2)[2][0] << ' '
<< (*p2)[3][0] << '\n';
return output;
}
void line::in(std::istream& input){
std::string garbage;
input>>garbage>>color>>
(*p1)[0][0]>>(*p1)[1][0]>>(*p1)[2][0]>>(*p1)[3][0]>>
(*p2)[0][0]>>(*p2)[1][0]>>(*p2)[2][0]>>(*p2)[3][0];
}
line* line::clone(){
line* output = new line((*p1)[0][0],(*p1)[1][0],(*p1)[2][0],
(*p2)[0][0],(*p2)[1][0],(*p2)[2][0],
color);
return output;
}
|
#ifndef __FILE_OUTPUT__
#define __FILE_OUTPUT__
#include "pfade_default.h"
#include COMMON_SPEZ(logging_spez.h)
#include "typen.h"
#define pclear() {ps_impl("\033[2J\033[H");}
#define pl() {pbegin(); pl_impl();}
#define ps(x) {pbegin(); ps_impl(x); pend();}
#define vps(...) {pbegin(); vps_impl(__VA_ARGS__); pend();}
#define pv(x) {pbegin(); ps_impl(#x); ps_impl("="); p_var(x); ps_impl(" ");pend();}
#define pvhex(x) {pbegin(); ps_impl(#x); ps_impl("="); p_varhex(x); ps_impl(" ");pend();}
#define pbl(b, l) {pbegin(); ps_impl(#b); ps_impl("="); pend(); pbegin(); printBytes(b,l); pend();}
#define pb(x) {pbegin(); ps_impl(#x); ps_impl("="); pl; printBytes(reinterpret_cast<byte8 const *>(&t), sizeof(t)); pend();}
#define CHECK(x) Common::checkfunction(x, #x, __FILE__, __LINE__)
#define ASSERT(x) if(false==CHECK(x)){ exit 1; }
namespace Common
{
inline bool checkfunction(bool expression, char const *expressionstr, char const *file, int const line)
{
if (false == expression)
{
SEND_CHECK_FAILED();
ps_impl(file); ps_impl(", l"); p_var(line); ps_impl(":"); ps_impl(expressionstr); ps_impl(" failed"); pl_impl();
}
return expression;
}
} // Common
#endif
|
// Using sizeof operator for different variables.
#include <iostream>
using namespace std;
int main(){
int array[ 20 ];
int *ptr; //= array;
cout << " integer = " << sizeof( int ) << endl;
cout << " double = " << sizeof( double ) << endl;
cout << " float = " << sizeof( float ) << endl;
cout << " char = " << sizeof( char ) << endl;
cout << " short = " << sizeof( short ) << endl;
cout << " long = " << sizeof( long ) << endl;
cout << " long double = " << sizeof( long double ) << endl;
cout << " int array = " << sizeof( array ) << endl;
cout << " pointer = " << sizeof( ptr ) << endl;
// In the int type variable returns 4 byte in memory and array's size of bytes
// returns 80, also this is showing this array includes 80 / 4 = 20 elements.
cout << " number of array's element = " << sizeof( array ) / sizeof( int );
return 0;
}
|
#ifndef FASTCG_VULKAN_DESCRIPTOR_SET_H
#define FASTCG_VULKAN_DESCRIPTOR_SET_H
#ifdef FASTCG_VULKAN
#include <FastCG/Graphics/Vulkan/Vulkan.h>
#include <FastCG/Graphics/Vulkan/VulkanTexture.h>
#include <FastCG/Graphics/Vulkan/VulkanBuffer.h>
#include <vector>
#include <cstdint>
namespace FastCG
{
struct VulkanDescriptorSetLayoutBinding
{
uint32_t binding{~0u};
VkDescriptorType type;
VkShaderStageFlags stageFlags;
};
using VulkanDescriptorSetLayout = std::vector<VulkanDescriptorSetLayoutBinding>;
struct VulkanDescriptorSetBinding
{
union
{
const VulkanBuffer *pBuffer;
const VulkanTexture *pTexture;
};
};
using VulkanDescriptorSet = std::vector<VulkanDescriptorSetBinding>;
using VulkanPipelineLayoutDescription = std::vector<VulkanDescriptorSetLayout>;
}
#endif
#endif
|
// SenderSocket.h
// CSCE 463-500
// Luke Grammer
// 11/12/19
#pragma once
class SenderSocket
{
HANDLE statsHandle, workerHandle;
struct Properties* properties;
BOOLEAN connected = false;
DWORD nextSequenceNum = 0;
/* GetServerInfo does a forward lookup on the destination host string if necessary
* and populates it's internal server information with the result. Called in Open().
* Returns code 0 to indicate success or 3 if the target hostname does not have an
* entry in DNS. */
WORD GetServerInfo(CONST CHAR* destination, WORD port);
public:
/* Constructor initializes WinSock and sets up a UDP socket for RDP.
* In addition, the server also starts a timer for the life of the
* SenderSocket object. calls exit() if socket creation is unsuccessful. */
SenderSocket(Properties* p);
/* Basic destructor for SenderSocket cleans up socket and WinSock. */
~SenderSocket();
/* Open() calls GetServerInfo() to populate internal server information and then creates a handshake
* packet and attempts to send it to the corresponding server. If un-acknowledged, it will retransmit
* this packet up to MAX_SYN_ATTEMPS times (by default 3). Open() will set the retransmission
* timeout for future communication with the server to a constant scale of the handshake RTT.
* Returns 0 to indicate success or a positive number to indicate failure. */
WORD Open(CONST CHAR* destination, WORD port, DWORD senderWindow, struct LinkProperties* lp);
/* Attempts to send a single packet to the connected server. This is the externally facing
* Send() function and therefore requires a previously successful call to Open().
* Returns 0 to indicate success or a positive number for failure. */
WORD Send(CONST CHAR* message, INT messageSize, INT messageType = DATA_TYPE);
/* Closes connection to the current server. Sends a connection termination packet and waits
* for an acknowledgement using the RTO calculated in the call to Open(). Returns 0 to
* indicate success or a positive number for failure.*/
WORD Close(DOUBLE& elapsedTime);
};
|
#include <iostream>
#include <vector>
#include <deque>
#include <stack>
#include <limits>
#include "priority_queue.h"
using namespace std;
namespace Matrix {
struct Node {
int Id;
Node *Prev;
int Value;
int Sum;
Node(int id, int value):Id(id),Value(value)
{
Prev = nullptr;
Sum = numeric_limits<int>::max();
}
};
struct NodeComparator
{
bool operator()(Node* lhs, Node* rhs)
{
return lhs->Sum > rhs->Sum;
}
};
int Rows;
int Cols;
vector<vector<Node> > G;
void Read()
{
cin >> Rows;
cin >> Cols;
G = vector<vector<Node> >(Rows*Cols, vector<Node>());
auto rowBuffer = deque<int>();
for(int r=0; r<Rows; r++) {
for(int c=0; c<Cols; c++) {
auto current = r*(Cols)+c;
auto left = current - 1;
auto top = current - Cols;
int val;
cin >> val;
if( c > 0 ) {
G[current].push_back(Node(left, rowBuffer.back()));
G[left].push_back(Node(current, val));
}
if( rowBuffer.size() >= Cols ) {
G[current].push_back(Node(top, rowBuffer.front()));
G[top].push_back(Node(current, val));
rowBuffer.pop_front();
}
rowBuffer.push_back(val);
}
}
// Make the sum to cell 0,0 - 0
G[1][0].Sum = 0;
G[Cols][0].Sum = 0;
// Calculate the first sums
G[0][0].Sum = G[0][0].Value + G[1][0].Value;
G[0][1].Sum = G[0][1].Value + G[1][0].Value;
}
void PrintPath(Node* node)
{
int length = 0;
auto path = stack<int>();
while( node != nullptr ) {
path.push( node->Value );
length += node->Value;
node = node->Prev;
}
path.push(G[1][0].Value);
length += G[1][0].Value;
cout << "Length: " << length << endl;
cout << "Path: ";
while(path.size() > 0) {
cout << path.top() << ' ';
path.pop();
}
cout << endl;
}
void CalculateShortestPath()
{
auto q = PriorityQueue<Node*, NodeComparator>();
q.Push(&G[0][0]);
q.Push(&G[0][1]);
Node* node;
while( q.Size() > 0 ) {
node = q.Pop();
if(node->Id == Rows*Cols-1) {
break;
}
for( auto child_it = G[node->Id].begin(); child_it != G[node->Id].end(); child_it++) {
if(node->Sum+child_it->Value < child_it->Sum) {
child_it->Sum = node->Sum+child_it->Value;
child_it->Prev = node;
if( !q.TryDecreaseKey(&(*child_it))) {
q.Push(&(*child_it));
}
}
}
}
PrintPath(node);
}
}
int main()
{
Matrix::Read();
Matrix::CalculateShortestPath();
return 0;
}
|
#include<iostream>
using namespace std;
template<typename T>
T maximum(T a, T b){
return (a > b) ? a : b;
}
//the above tempalte can't handle strings -- so we have a specialization for it
template<> //shows its specialization
char* maximum<char*>(char * a, char * b){
return strcmp(a,b)>0 ? a : b;
}
int main(){
int a_int = 10, b_int = 11;
double a_double = 1.18, b_double = 1.13;
char* a_str= str("aaa"),b_str = "aab";
cout<<"integer maximum is="<< maximum(a_int,b_int) <<endl;//call the int max through template
cout<<"double maximum is="<< maximum(a_double,b_double) <<endl; // call the double max through template
cout<<"string maximum is="<< maximum(a_str,b_str) <<endl; // call the specialized str max through template
}
|
#include "classes.hpp"
player::player(string n) {
name = n;
deck = new DeckBuilder(); //whole deck
property = new DeckBuilder(); //hand for green cards, provinces for black
deck->createDynastyDeck();
deck->createFateDeck();
Stronghold_card = new Stronghold("Ashina Castle");
army = new list<Personality*>();
holdings = new list<Holding*>();
}
player::~player() {
delete property;
delete deck;
delete Stronghold_card;
this->get_holdings()->remove(Stronghold_card);
list<Personality*>::iterator it;
list<Holding*>::iterator it2;
it = army->begin();
it2 = holdings->begin();
while (army->empty() == 0 && it != army->end()){ //delete army
Personality *p = *it;
delete p;
army->remove((*it));
it = army->begin();
}
while (holdings->empty() == 0 && it2 != holdings->end()){ //delete holdings
Holding* h = *it2;
delete h;
holdings->remove((*it2));
it2 = holdings->begin();
}
delete army;
delete holdings;
}
void player::untapEverything() { //all the cards become untapped, army, holdings
list<Personality*>::iterator pr;
list<Holding*>::iterator hld;
vector<GreenCard*>::iterator inv;
for (pr = this->get_army()->begin(); this->get_army()->empty() == 0 &&
pr != this->get_army()->end(); pr++) {
for (inv = (*pr)->get_inventory()->begin(); (*pr)->get_inventory()->empty() == 0
&& inv != (*pr)->get_inventory()->end(); inv++) {
(*inv)->untap(); //followers and equipment of the army
}
(*pr)->untap();
}
for (hld = this->get_holdings()->begin(); this->get_holdings()->empty() == 0 &&
hld != this->get_holdings()->end(); hld++) {
(*hld)->untap();
}
}
void player::Print_Holdings() { //bought holdings
list<Holding*>* hld;
list<Holding*>::iterator it;
hld = this->get_holdings();
if (hld->empty())
cout << "No holdings" << endl;
else {
cout << "HOLDINGS" << endl;
for (it = hld->begin(); it != hld->end(); it++) {
(*it)->print_card();
cout << endl;
}
}
}
void player::printPersonalities() { //army, bought, untapped personalities, without inventory
list<Personality*>::iterator prs;
int i = 0;
if (this->get_army()->empty() == 0) { //army exists
cout << "UNTAPPED PERSONALITIES" << endl;
for (prs = this->get_army()->begin(); prs != this->get_army()->end(); prs++) {
if ((*prs)->getistapped() == 0) {
cout << "No " << ++i << endl;
(*prs)->print_card();
cout << endl;
}
}
}
}
void player::Print_Arena() { //army
list<Personality*>* blc;
vector<GreenCard*>* grn;
list<Personality*>::iterator it;
vector<GreenCard*>::iterator it2;
blc = this->get_army();
if (blc->empty())
cout << "Empty Arena" << endl;
else {
cout << "ARENA" << endl; //army
for (it = blc->begin(); it != blc->end(); it++) {
(*it)->print_card();
cout << endl;
grn = (*it)->get_inventory(); //with followers and items is exists
for (it2 = grn->begin(); it2 != grn->end() && grn->empty() == 0; it2++) {
(*it2)->print_card();
cout << endl;
}
}
}
}
void player::Load_into_Battle(list<Personality*>* battle) {
int ans = -1, i = 0;
while (ans != 0) {
list<Personality*>::iterator pers = this->get_army()->begin();
if (this->get_army()->empty()) {
cout << "No personalities for selection. " << endl;
cout << "Press 0 to continue." << endl;
cin >> ans;
if (ans == 0)
return;
}
else {
this->printPersonalities(); //prints untapped personalities
i = 0;
cout << "Enter your selection (Press 0 to end this procedure): ";
cin >> ans;
if (ans == 0)
return;
while (1) {
while ((*pers)->getistapped() == 1)
pers++;
if (++i == ans) { //found the selected personality
battle->push_back(*pers); //goes in the army for the battle
this->get_army()->erase(pers); //not in player's army anymore
break;
}
else pers++;
}
}
}
}
void player::Lose_all_Army_in_Battle(list<Personality*>* lost_army) {
list<Personality*>::iterator loser;
vector<GreenCard*>::iterator grn;
if (lost_army->empty())
return; //no army to be destroyed
loser = lost_army->begin();
grn = (*loser)->get_inventory()->begin();
while (lost_army->empty() == 0 && loser != lost_army->end()) {
while (grn != (*loser)->get_inventory()->end() && (*loser)->get_inventory()->empty() == 0) {
GreenCard* gr = *grn;
delete gr;
(*loser)->get_inventory()->erase(grn);
grn = (*loser)->get_inventory()->begin();
}
(*loser)->get_inventory()->clear();
Personality* p = *loser;
delete p;
lost_army->remove(*loser);
loser = lost_army->begin();
} //destroy the army
lost_army->clear();
}
Gameboard::Gameboard() {
players.push_back(new player("Pavlos"));
players.push_back(new player("Eftychia"));
}
Gameboard::~Gameboard() {
vector<player*>::iterator it;
it = players.begin();
while (players.empty() == 0 && it != players.end()) {
player* pl = *it;
delete pl;
players.erase(it);
it = players.begin();
}
}
void Gameboard::initializehands() {
vector<player*>::iterator it;
DeckBuilder* temp, * temp2;
Stronghold* init;
for (it = players.begin(); it != players.end(); it++) {
temp = (*it)->get_property();
temp2 = (*it)->get_deck();
init = (*it)->get_stronghold_card();
temp->drawFateCard(temp2);
temp->drawFateCard(temp2);//2 cards out of max 6
list<BlackCard*>* prov = temp->get_provinces();
for (int i = 0; i < 4; i++)
temp->drawDynastyCard(temp2, 1); //the rest 4 cards, not revealed
(*it)->get_holdings()->push_back(init); //stronghold at lists with holdings
(*it)->set_honour((*it)->get_stronghold_card()->Starting_Honour);
(*it)->set_money((*it)->get_stronghold_card()->get_Harvest());
}
this->sort_players(); //determines the turn of play
}
void Gameboard::sort_players() {
int i, j, n = players.size();
player* b;
player** a = players.data();
for (i = 0; i < n - 1; i++) {
for (j = 0; j < n - i - 1; j++) {
if (a[j]->get_honour() < a[j + 1]->get_honour()) {
b = a[j];
a[j] = a[j + 1];
a[j + 1] = b;
}
}
}
}
bool Gameboard::checkWinningCondition() {
vector<player*>::iterator it;
DeckBuilder* temp;
it = players.begin();
while ( players.empty() == 0 && it != players.end()) {
temp = (*it)->get_property();
if (temp->get_provinces()->empty()) {
cout << (*it)->get_name() << " lost the game." << endl;
player* pl = *it;
delete pl;
players.erase(it);
it = players.begin();
}
else {
it++;
}
}
if (players.size() == 1) {
it = players.begin();
cout << (*it)->get_name() << " won the game." << endl;
return 1;
}
return 0;
}
void Gameboard::starting_phase() { //as described in exercise
vector<player*>::iterator it;
DeckBuilder* temp;
for (it = players.begin(); it != players.end(); it++) {
cout << "PLAYER: " << (*it)->get_name() << endl;
temp = (*it)->get_property();
(*it)->untapEverything(); //untap army, holdings
temp->drawFateCard((*it)->get_deck()); //pick a green card from fate deck
temp->Reveal_provinces();
temp->printHand();
temp->printProvinces();
}
}
void Gameboard::equip_phase() {
vector<player*>::iterator it;
list <Personality*>* cards;
list <Personality*>::iterator it2;
int bans = -1, gans = -1, ans, i = 0;
char an;
for (it = players.begin(); it != players.end(); it++) {
GreenCard* bought = NULL;
list <Personality*>* cards = (*it)->get_army();
bans = -1;
while (bans != 0 && !cards->empty()) { //if army exists
cout << (*it)->get_name() << "'s TURN" << endl;
i = 0;
cards = (*it)->get_army();
for (it2 = cards->begin(); it2 != cards->end(); it2++) {
cout << "No " << ++i << endl;
(*it2)->print_card(); //print army
cout << endl;
}
cout << "Choose which black card to load. Enter 0 to end this phase." << endl;
cin >> bans; //this black card will be equiped next if a green is bought
if (bans == 0) break;
ans = -1;
while (ans != 0) {
(*it)->get_property()->printHand(); //print green cards on hand
cout << "Choose which green card to buy. Enter 0 not to buy." << endl;
cin >> ans;
if (ans == 0) {
cout << "No Green Card was bought." << endl;
break;
}
bought = (*it)->get_property()->BuyFateCard(ans, (*it)->get_holdings(), (*it)->get_money());
if (bought != NULL) {
it2 = cards->begin();
i = 1;
while (i != bans) { //find the black card
i++;
it2++;
}
Personality* npc = *it2; //loaded card from army
vector<GreenCard*>* equips = npc->get_inventory();
if (equips->size() < MAX_EQUIPS && (npc->get_honour() >= (bought)->get_MinimumHonor())) {
equips->push_back(bought);
(*it)->get_property()->get_hand()->remove(bought); //delete later
cout << "Do you want to upgrade the green card? Press y" << endl;
cin >> an;
if (an == 'y' && (*it)->see_money() > (bought)->get_efcost()) {
(*it)->set_money((*it)->see_money() - (bought)->get_efcost());
(bought)->upgrade(); //upgrade the card
}
}
}
}
}
}
}
void Gameboard::battle_phase() {
vector<player*>::iterator it, it2;
int i, ans, damage = 0, defense = 0, result, province_def;
list<Personality*>* atk = new list<Personality*>(), * def = new list<Personality*>();
list<Personality*>::iterator tempatk, tempdef;
list<BlackCard*>::iterator prov;
BlackCard* target = NULL;
player* attacker, * defender;
vector<GreenCard*>::iterator grn;
for (it = players.begin(); it != players.end(); it++) {
if (!(*it)->get_army()->empty()) { //if the player has army
i = 0, damage = 0, defense = 0;
attacker = *it; //player who attacks
cout << attacker->get_name() << " select which player you want to attack:" << endl;
for (it2 = players.begin(); it2 != players.end(); it2++) {
if (it != it2) { //cannot attack themrselves
cout << ++i << ". " << (*it2)->get_name() << endl;
}
}
cin >> ans;
it2 = players.begin();
if (it == it2) //cannot attack themselves
it2++;
for (i = 1; i < ans; i++) { //find the above chosen player to attack
it2++;
if (it == it2)
it2++;
}
defender = *it2; //player who defends
defender->get_property()->printProvinces();
cout << attacker->get_name() << " select which province you want to attack: " << endl;
cin >> ans; //selects a province
prov = defender->get_property()->get_provinces()->begin();
for (int k = 1; k < ans; k++)
prov++;
target = *prov;
cout << "Attacker " << (attacker)->get_name() << " choose which personalities to attack with from the below: " << endl;
attacker->Load_into_Battle(atk);
cout << "Defender " << (defender)->get_name() << " choose which personalities to defend with from the below: " << endl;
defender->Load_into_Battle(def);
for (tempatk = atk->begin(); tempatk != atk->end() && atk->empty() == 0; tempatk++) {
damage += (*tempatk)->get_attpower();
}
for (tempdef = def->begin(); tempdef != def->end() && def->empty() == 0; tempdef++) {
defense += (*tempdef)->get_defpower();
}
province_def = defender->get_stronghold_card()->InitialDefense;
result = damage - defense - province_def;
if (result > province_def) {
cout << attacker->get_name() << " attacker destoyed a province." << endl;
defender->Lose_all_Army_in_Battle(def);
BlackCard* tar = target;
delete tar;
defender->get_property()->get_provinces()->remove(target);
}
else {
if (result < 0) { //attack < defence
cout << defender->get_name() << " defender won" << endl;
attacker->Lose_all_Army_in_Battle(atk);
consequences(def, result);
}
else if (result == 0) { //attack == defence
cout << "Tie" << endl;
defender->Lose_all_Army_in_Battle(def);
attacker->Lose_all_Army_in_Battle(atk);
}
else { //attack > defence
cout << attacker->get_name() << " attacker won" << endl;
defender->Lose_all_Army_in_Battle(def);
consequences(atk, result);
}
}
//load troops back to army
for (tempatk = atk->begin(); atk->empty() == 0 && tempatk != atk->end(); tempatk++)
attacker->get_army()->push_back(*tempatk);
for (tempdef = def->begin(); def->empty() == 0 && tempdef != def->end(); tempdef++)
defender->get_army()->push_back(*tempdef);
atk->clear();
def->clear();
}
}
//delete target;
delete atk;
delete def;
}
void consequences(list<Personality*>* troops, int key) {
list<Personality*>::iterator temp;
vector<GreenCard*>::iterator eqp;
bool tapped = false;
int att = 0;
if (key > 0) { //attack > defence
tapped = true;
}
else { //attack < defence
key = -key;
}
if (troops->empty()) //no army exists any more
return;
temp = troops->begin();
eqp = (*temp)->get_inventory()->begin();
while (temp != troops->end() && troops->empty() == 0 && att < key) {
while (eqp != (*temp)->get_inventory()->end() &&
(*temp)->get_inventory()->empty() == 0 && att < key) {
if ((*eqp)->getType() == FOLLOWER) {
att += (*eqp)->get_AttackBonus();
GreenCard* g = *eqp;
delete g;
(*temp)->get_inventory()->erase(eqp);
eqp = (*temp)->get_inventory()->begin();
}
else {
eqp++;
}
}
att += (*temp)->get_Attack();
if ((*temp)->get_inventory()->empty() == 0)
(*temp)->get_inventory()->clear(); //items have to be deleted too
Personality* p = *temp;
delete p;
troops->remove(*temp);
temp = troops->begin();
}
if (troops->empty())
return;
for (temp = troops->begin(); temp != troops->end() && troops->empty() == 0; temp++) {
for (eqp = (*temp)->get_inventory()->begin(); eqp != (*temp)->get_inventory()->end()
&& (*temp)->get_inventory()->empty() == 0; eqp++) {
if (tapped) { //attack > defence
if ((*eqp)->getType() == FOLLOWER)
(*eqp)->tap();
}
if ((*eqp)->getType() == ITEM) {
((Item*)(*eqp))->desharpen();
if (((Item*)*eqp)->get_durability() == 0) {
GreenCard* g = *eqp;
delete g;
(*temp)->get_inventory()->erase(eqp);
}
}
}
(*temp)->shame();
if (tapped) { //attack > defence
(*temp)->tap();
}
if ((*temp)->get_honour() == 0) {
(*temp)->print_card();
cout << endl << "Performed Seppuku" << endl;
Personality* p = *temp;
delete p;
troops->remove(*temp);
}
}
}
void Gameboard::economy_phase() {
vector<player*>::iterator it;
BlackCard* blc = NULL;
Holding* hld;
int ans;
for (it = players.begin(); it != players.end(); it++) {
ans = -1;
while (ans != 0) {
//the cards are revealed already from starting phase
cout << "PLAYER: " << (*it)->get_name() << endl;
(*it)->get_property()->print_revealed_provinces();
cout << "Choose which black card to buy. Enter 0 to end this phase" << endl;
cin >> ans;
if (ans == 0) continue; //go to the next player
blc = (*it)->get_property()->BuyDynastyCard(ans, (*it)->get_army(), (*it)->get_holdings(), (*it)->get_money());
if (blc != NULL) { //a black card was bought
(*it)->get_property()->drawDynastyCard((*it)->get_deck(), 0); //replace the card, new card not revealed
if (blc->getType() == HOLDING) { //check if a connection is possible
hld = (Holding*)(blc);
//(*it)->create_chain(hld, (*it)->get_holdings(), hld->get_harvest());
hld->set_chain((*it)->get_holdings()/*, hld->get_harvest()*/);
}
}
}
}
}
void Gameboard::final_phase() {
this->discardSurplusFateCards(); //throw away additial cards
vector<player*>::iterator it;
list<Holding*>* blc;
list<Holding*>::iterator it2;
for (it = players.begin(); it != players.end(); it++) {
blc = (*it)->get_holdings();
cout << "PLAYER: " << (*it)->get_name() << endl;
(*it)->get_property()->printHand();
cout << "PLAYER: " << (*it)->get_name() << endl;
(*it)->get_property()->printProvinces();
for (it2 = blc->begin(); it2 != blc->end(); it2++) { //add the money from the holdings
if ((!(*it2)->getistapped()) && (*it2)->getType() == HOLDING) {
(*it)->get_money() += (*it2)->get_Harvest();
}
}
cout << "PLAYER: " << (*it)->get_name() << endl;
(*it)->Print_Holdings();
cout << "PLAYER: " << (*it)->get_name() << endl;
(*it)->Print_Arena();
}
cout << endl;
this->print_Game_Statistics();
}
void Gameboard::discardSurplusFateCards() {
vector<player*>::iterator it;
for (it = players.begin(); it != players.end(); it++) {
list<GreenCard*>* hand = (*it)->get_property()->get_hand();
if (hand->size() > 6) { //more than 6 green cards on hand
int i;
(*it)->get_property()->printHand();
cout << "PLAYER: " << (*it)->get_name() << endl;
cout << "Choose which card to abandon" << endl;
cin >> i;
list<GreenCard*>::iterator it2 = hand->begin();
for (int k = 1; k < i; k++)
it2++;
GreenCard* gr = *it2;
delete gr;
hand->remove(*it2); //being removed from hand and from gameboard
}
}
}
void Gameboard::print_Game_Statistics() {
vector<player*>::iterator it;
list<Personality*>* prs;
list<Personality*>::iterator it1;
int att = 0, def = 0;
for (it = players.begin(); it != players.end(); it++) {
int i = 0;
prs = (*it)->get_army();
if (prs->empty()) {
cout << "PLAYER: " << (*it)->get_name() << endl;
cout << "No army" << endl;
}
else {
int att = 0, def = 0;
cout << "PLAYER: " << (*it)->get_name() << endl;
cout << "GAME STATISTICS: " << endl;
for (it1 = prs->begin(); it1 != prs->end(); it1++) {
att += (*it1)->get_attpower();
def += (*it1)->get_defpower();
}
cout << "Total attack: " << att << endl;
cout << "Total defense: " << def << endl;
}
cout << "Money: " << (*it)->get_money() << endl << endl;
}
}
|
#ifndef __DECORATOR_H__
#define __DECORATOR_H__
#include "Component.h"
#include <memory>
class Decorator : public Component
{
public:
Decorator(std::shared_ptr<Component> component);
virtual const std::string product() override;
virtual const int price() override;
private:
std::shared_ptr<Component> m_component;
};
#endif // __DECORATOR_H__
|
#include <cstdlib>
#include <cstdio>
#include <string>
#include <unistd.h>
#include <sys/wait.h>
int main(int argc, char *argv[])
{
FILE *log;
FILE *out;
FILE *err;
FILE *exc;
log = fopen("sys.log", "w");
out = fopen("out.log", "w");
err = fopen("err.log", "w");
exc = fopen("exc.log", "w");
// no path to script
if (argc < 2)
{
fprintf(log, "ERROR: app name not given\n");
printf("ERROR: app name not given\n");
exit(1);
}
// concatenate all arguments to 'path-string'
// ./ + app_name + [args]
std::string temp = "./";
for (unsigned int i = 0; i < argc - 1; ++i)
temp += std::string(argv[i + 1]) + " ";
// remove extra space from end
temp.erase(temp.length() - 1);
const char *path = temp.c_str();
// separate pipes for stdout and stderr
int out_pipe[2], err_pipe[2];
if (pipe(out_pipe) < 0 || pipe(err_pipe) < 0)
{
fprintf(log, "ERROR: FD\n");
printf("ERROR: FD\n");
exit(1);
}
// fork the process
int STATUS;
pid_t pid = fork();
// child
if (pid == 0)
{
close(out_pipe[0]);
close(err_pipe[0]);
dup2(out_pipe[1], 1);
dup2(err_pipe[1], 2);
close(out_pipe[1]);
close(err_pipe[1]);
// run the script
STATUS = system(path);
return WEXITSTATUS(STATUS);
}
// parent
else
{
waitpid(pid, &STATUS, 0);
}
STATUS = WEXITSTATUS(STATUS);
close(out_pipe[1]);
close(err_pipe[1]);
// read collected data
char buff_out[1024], buff_err[1024];
buff_out[read(out_pipe[0], buff_out, sizeof(buff_out))] = '\0';
buff_err[read(err_pipe[0], buff_err, sizeof(buff_err))] = '\0';
// print received stdout
fprintf(out, "%s", buff_out);
printf("%s", buff_out);
// print received stderr
fprintf(err, "%s", buff_err);
printf("%s", buff_err);
// print received exit code
fprintf(exc, "exit code: %d\n", STATUS);
printf("exit code: %d\n", STATUS);
// close files
fclose(log);
fclose(out);
fclose(err);
fclose(exc);
exit(0);
}
|
/*Author: Mehmed Esad AKÇAM
150190725
*/
#pragma once
#include "Faction.h"
class Dwarves : public Faction{ //Public derivation
public:
Dwarves():Faction(){}; //Default constructor
Dwarves(string name , int numberOfUnits, int attackPoint, int healthPoint, int regen);//Constroctur with parameters
//Expected functions
void PerformAttack();
void ReceiveAttack(int unit, double attackPoint, string attacking);
int PurchaseArmors(int);
int PurchaseWeapons(int);
void Print() const;
//Returns faction type
string getFaction(){return "Dwarves";};
};
|
#include <bits/stdc++.h>
using namespace std;
#define endl '\n'
#define print(v) for(auto x:v){cout<<x<<" ";}cout<<endl;
void solve(string ip,string op,vector<string> &v){
if(ip.length()==0){
v.push_back(op);
return;
}
for(int i=0;i<ip.length();i++){
string op1 = op;
swap(ip[0],ip[i]);
op1 += ip[0];
solve(ip.substr(1,ip.length()), op1, v);
}
}
int main(){
int n;
cin>>n;
while(n--){
string ip;
cin>>ip;
string op="";
vector<string> v;
solve(ip,op,v);
sort(v.begin(),v.end());
print(v);
}
return 0;
}
|
#include "tlsf.h"
#include <string>
using namespace std;
namespace dosk {
class allocator {
private:
string hash;
tlsf_t heap;
size_t size;
public:
allocator(string& hash, void* pool, size_t size);
void* get_heap();
size_t get_heap_size();
void* malloc(size_t size);
void* align(size_t align, size_t bytes);
void* realloc(void* ptr, size_t size);
void free(void* ptr);
~allocator();
};
}
|
#include <bits/stdc++.h>
using namespace std;
class Solution
{
public:
vector<int> handleExtremeCase(int size)
{
vector<int> ans(size + 1, 0);
ans[0] = 1;
return ans;
}
vector<int> plusOne(vector<int> &digits)
{
int i = digits.size() - 1;
while (i >= 0)
{
digits[i]++;
digits[i] %= 10;
if (i == 0 && digits[i] == 0)
return handleExtremeCase(digits.size());
if (digits[i] != 0)
break;
i--;
}
return digits;
}
};
|
#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 "il2cpp-class-internals.h"
#include "codegen/il2cpp-codegen.h"
#include "il2cpp-object-internals.h"
// Vuforia.GuideViewRenderingBehaviour
struct GuideViewRenderingBehaviour_t333084580;
// Thinksquirrel.Fluvio.Internal.ObjectModel.IFluidSolver
struct IFluidSolver_t2299467746;
// Thinksquirrel.Fluvio.Internal.Solvers.SolverDataInternal
struct SolverDataInternal_t3200118405;
// Vuforia.VuforiaBehaviour
struct VuforiaBehaviour_t2151848540;
// System.Func`2<Vuforia.TrackableBehaviour,System.Boolean>
struct Func_2_t2413074071;
// System.Func`2<Vuforia.ImageTargetBehaviour,System.Boolean>
struct Func_2_t1895999181;
// UnityEngine.Texture
struct Texture_t3661962703;
// Vuforia.DataSet
struct DataSet_t3286034874;
// System.String
struct String_t;
// Vuforia.ARController
struct ARController_t116632334;
// System.Int32[]
struct Int32U5BU5D_t385246372;
// Thinksquirrel.Fluvio.Internal.Threading.ParallelAction
struct ParallelAction_t3477057985;
// Thinksquirrel.Fluvio.Internal.TimerGroup
struct TimerGroup_t1675067946;
// Thinksquirrel.Fluvio.FluidBase
struct FluidBase_t2442071467;
// System.Collections.Generic.List`1<Thinksquirrel.Fluvio.FluidBase>
struct List_1_t3914146209;
// Thinksquirrel.Fluvio.Internal.Solvers.SmoothingKernel
struct SmoothingKernel_t2173549093;
// Thinksquirrel.Fluvio.FluvioComputeShader
struct FluvioComputeShader_t2551470295;
// Thinksquirrel.Fluvio.Internal.SolverParticleDelegate
struct SolverParticleDelegate_t4224278369;
// Thinksquirrel.Fluvio.Internal.SolverParticlePairDelegate
struct SolverParticlePairDelegate_t2332887997;
// System.Action`1<Thinksquirrel.Fluvio.Internal.Solvers.FluidSolver>
struct Action_1_t3318095593;
// System.Comparison`1<Thinksquirrel.Fluvio.FluidBase>
struct Comparison_1_t2217002646;
// Vuforia.VuforiaConfiguration/VideoBackgroundConfiguration
struct VideoBackgroundConfiguration_t3392414655;
// Vuforia.VideoBackgroundDefaultProvider
struct VideoBackgroundDefaultProvider_t2109766439;
// System.Collections.Generic.List`1<Vuforia.AValidatableVideoBackgroundConfigProperty>
struct List_1_t2580163155;
// Thinksquirrel.Fluvio.Internal.Threading.FluvioThreadPool
struct FluvioThreadPool_t2773119480;
// Thinksquirrel.Fluvio.Internal.Threading.IInterlocked
struct IInterlocked_t829943562;
// System.Void
struct Void_t1185182177;
// System.Char[]
struct CharU5BU5D_t3528271667;
// Vuforia.IExtendedTracking
struct IExtendedTracking_t3078834738;
// Vuforia.ITargetSize
struct ITargetSize_t197627644;
// Vuforia.Image
struct Image_t745056343;
// System.ComponentModel.PropertyChangedEventHandler
struct PropertyChangedEventHandler_t3836340606;
// System.Reflection.MethodInfo
struct MethodInfo_t;
// System.DelegateData
struct DelegateData_t1677132599;
// Thinksquirrel.Fluvio.Internal.Threading.LockFreeRingBuffer`1<Thinksquirrel.Fluvio.Internal.Threading.FluvioThreadPool/Task>
struct LockFreeRingBuffer_1_t9929710;
// Thinksquirrel.Fluvio.Internal.Threading.IThread[]
struct IThreadU5BU5D_t347840266;
// Thinksquirrel.Fluvio.Internal.Threading.IThreadHandler
struct IThreadHandler_t2446361027;
// UnityEngine.Shader
struct Shader_t4151988712;
// UnityEngine.GameObject[]
struct GameObjectU5BU5D_t3328599146;
// System.Single[]
struct SingleU5BU5D_t1444911251;
// System.Action
struct Action_t1264377477;
// Vuforia.VideoBackgroundBehaviour
struct VideoBackgroundBehaviour_t1552899074;
// Vuforia.BackgroundPlaneBehaviour
struct BackgroundPlaneBehaviour_t3333547397;
// Thinksquirrel.Fluvio.Internal.Solvers.FluidData[]
struct FluidDataU5BU5D_t408108260;
// Thinksquirrel.Fluvio.Internal.Solvers.FluidParticle[]
struct FluidParticleU5BU5D_t687312282;
// Thinksquirrel.Fluvio.Internal.Solvers.IndexGrid
struct IndexGrid_t759839143;
// Thinksquirrel.Fluvio.Internal.FluvioComputeBuffer`1<Thinksquirrel.Fluvio.Internal.Solvers.FluidData>
struct FluvioComputeBuffer_1_t3020680417;
// Thinksquirrel.Fluvio.Internal.FluvioComputeBuffer`1<Thinksquirrel.Fluvio.Internal.Solvers.FluidParticle>
struct FluvioComputeBuffer_1_t4054810083;
// Thinksquirrel.Fluvio.Internal.FluvioComputeBuffer`1<System.UInt32>
struct FluvioComputeBuffer_1_t1667966562;
// Thinksquirrel.Fluvio.Internal.FluvioComputeBuffer`1<System.Int32>
struct FluvioComputeBuffer_1_t2058850337;
// Vuforia.DigitalEyewearARController/SerializableViewerParameters
struct SerializableViewerParameters_t2043332680;
// UnityEngine.Transform
struct Transform_t3600365921;
// UnityEngine.Camera
struct Camera_t4157153871;
// Vuforia.VuforiaARController
struct VuforiaARController_t1876945237;
// Vuforia.VRDeviceController
struct VRDeviceController_t3863472269;
// System.Collections.Generic.Dictionary`2<UnityEngine.Camera/StereoscopicEye,UnityEngine.Matrix4x4>
struct Dictionary_2_t738209647;
// System.Collections.Generic.Dictionary`2<UnityEngine.Camera/StereoscopicEye,System.Single>
struct Dictionary_2_t317574578;
// Vuforia.IBoundingBox
struct IBoundingBox_t2252428598;
// System.Collections.Generic.Dictionary`2<System.Int32,Vuforia.GuideView>
struct Dictionary_2_t3700162136;
// System.IAsyncResult
struct IAsyncResult_t767004451;
// System.AsyncCallback
struct AsyncCallback_t3962456242;
// Vuforia.StereoProjMatrixStore
struct StereoProjMatrixStore_t888524276;
// System.Collections.Generic.Dictionary`2<UnityEngine.Camera/StereoscopicEye,UnityEngine.Vector2>
struct Dictionary_2_t1076537327;
// Vuforia.ModelTargetBehaviour
struct ModelTargetBehaviour_t712978329;
// Vuforia.GuideView
struct GuideView_t516481509;
// System.Collections.IEnumerator
struct IEnumerator_t1853284238;
// UnityEngine.GameObject
struct GameObject_t1113636619;
// UnityEngine.Texture2D
struct Texture2D_t3840446185;
// System.Action`2<Thinksquirrel.Fluvio.FluvioMonoBehaviourBase,System.Boolean>
struct Action_2_t1004908951;
// UnityEngine.GUIStyle
struct GUIStyle_t3956901511;
// Vuforia.Trackable
struct Trackable_t2451999991;
// System.Collections.Generic.List`1<Vuforia.ITrackableEventHandler>
struct List_1_t2968050330;
// Vuforia.Anchor
struct Anchor_t3861090447;
// Thinksquirrel.Fluvio.Internal.FluvioComputeBufferBase[]
struct FluvioComputeBufferBaseU5BU5D_t3891016598;
// System.Array[]
struct ArrayU5BU5D_t2896390326;
// System.Converter`2<UnityEngine.Keyframe,Thinksquirrel.Fluvio.Internal.Keyframe>
struct Converter_2_t3479950270;
// UnityEngine.UI.Text
struct Text_t1901882714;
// Thinksquirrel.Fluvio.FluvioMinMaxCurve
struct FluvioMinMaxCurve_t1877352570;
// UnityEngine.ParticleSystem
struct ParticleSystem_t1800779281;
// Thinksquirrel.Fluvio.Plugins.PhaseChange/PhaseChangeData[]
struct PhaseChangeDataU5BU5D_t3004711667;
// Thinksquirrel.Fluvio.FluvioMinMaxGradient
struct FluvioMinMaxGradient_t1663705874;
#ifndef U3CMODULEU3E_T692745551_H
#define U3CMODULEU3E_T692745551_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// <Module>
struct U3CModuleU3E_t692745551
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // U3CMODULEU3E_T692745551_H
#ifndef RUNTIMEOBJECT_H
#define RUNTIMEOBJECT_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Object
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // RUNTIMEOBJECT_H
#ifndef UNITYCOMPONENTEXTENSIONS_T3737347336_H
#define UNITYCOMPONENTEXTENSIONS_T3737347336_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// Vuforia.UnityComponentExtensions
struct UnityComponentExtensions_t3737347336 : public RuntimeObject
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // UNITYCOMPONENTEXTENSIONS_T3737347336_H
#ifndef ANDROIDDATASETS_T3742019579_H
#define ANDROIDDATASETS_T3742019579_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// Vuforia.AndroidDatasets
struct AndroidDatasets_t3742019579 : public RuntimeObject
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // ANDROIDDATASETS_T3742019579_H
#ifndef ANDROIDUNITYPLAYER_T2737599080_H
#define ANDROIDUNITYPLAYER_T2737599080_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// Vuforia.AndroidUnityPlayer
struct AndroidUnityPlayer_t2737599080 : public RuntimeObject
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // ANDROIDUNITYPLAYER_T2737599080_H
#ifndef DEVICE_T64880687_H
#define DEVICE_T64880687_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// Vuforia.Device
struct Device_t64880687 : public RuntimeObject
{
public:
public:
};
struct Device_t64880687_StaticFields
{
public:
// Vuforia.Device Vuforia.Device::mInstance
Device_t64880687 * ___mInstance_0;
public:
inline static int32_t get_offset_of_mInstance_0() { return static_cast<int32_t>(offsetof(Device_t64880687_StaticFields, ___mInstance_0)); }
inline Device_t64880687 * get_mInstance_0() const { return ___mInstance_0; }
inline Device_t64880687 ** get_address_of_mInstance_0() { return &___mInstance_0; }
inline void set_mInstance_0(Device_t64880687 * value)
{
___mInstance_0 = value;
Il2CppCodeGenWriteBarrier((&___mInstance_0), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // DEVICE_T64880687_H
#ifndef U3CSETCHILDOFVUFORIAANCHORU3ED__22_T1825058655_H
#define U3CSETCHILDOFVUFORIAANCHORU3ED__22_T1825058655_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// Vuforia.GuideViewRenderingBehaviour/<SetChildOfVuforiaAnchor>d__22
struct U3CSetChildOfVuforiaAnchorU3Ed__22_t1825058655 : public RuntimeObject
{
public:
// System.Int32 Vuforia.GuideViewRenderingBehaviour/<SetChildOfVuforiaAnchor>d__22::<>1__state
int32_t ___U3CU3E1__state_0;
// System.Object Vuforia.GuideViewRenderingBehaviour/<SetChildOfVuforiaAnchor>d__22::<>2__current
RuntimeObject * ___U3CU3E2__current_1;
// Vuforia.GuideViewRenderingBehaviour Vuforia.GuideViewRenderingBehaviour/<SetChildOfVuforiaAnchor>d__22::<>4__this
GuideViewRenderingBehaviour_t333084580 * ___U3CU3E4__this_2;
public:
inline static int32_t get_offset_of_U3CU3E1__state_0() { return static_cast<int32_t>(offsetof(U3CSetChildOfVuforiaAnchorU3Ed__22_t1825058655, ___U3CU3E1__state_0)); }
inline int32_t get_U3CU3E1__state_0() const { return ___U3CU3E1__state_0; }
inline int32_t* get_address_of_U3CU3E1__state_0() { return &___U3CU3E1__state_0; }
inline void set_U3CU3E1__state_0(int32_t value)
{
___U3CU3E1__state_0 = value;
}
inline static int32_t get_offset_of_U3CU3E2__current_1() { return static_cast<int32_t>(offsetof(U3CSetChildOfVuforiaAnchorU3Ed__22_t1825058655, ___U3CU3E2__current_1)); }
inline RuntimeObject * get_U3CU3E2__current_1() const { return ___U3CU3E2__current_1; }
inline RuntimeObject ** get_address_of_U3CU3E2__current_1() { return &___U3CU3E2__current_1; }
inline void set_U3CU3E2__current_1(RuntimeObject * value)
{
___U3CU3E2__current_1 = value;
Il2CppCodeGenWriteBarrier((&___U3CU3E2__current_1), value);
}
inline static int32_t get_offset_of_U3CU3E4__this_2() { return static_cast<int32_t>(offsetof(U3CSetChildOfVuforiaAnchorU3Ed__22_t1825058655, ___U3CU3E4__this_2)); }
inline GuideViewRenderingBehaviour_t333084580 * get_U3CU3E4__this_2() const { return ___U3CU3E4__this_2; }
inline GuideViewRenderingBehaviour_t333084580 ** get_address_of_U3CU3E4__this_2() { return &___U3CU3E4__this_2; }
inline void set_U3CU3E4__this_2(GuideViewRenderingBehaviour_t333084580 * value)
{
___U3CU3E4__this_2 = value;
Il2CppCodeGenWriteBarrier((&___U3CU3E4__this_2), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // U3CSETCHILDOFVUFORIAANCHORU3ED__22_T1825058655_H
#ifndef PLATFORMRUNTIMEINITIALIZATION_T3141452252_H
#define PLATFORMRUNTIMEINITIALIZATION_T3141452252_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// Vuforia.PlatformRuntimeInitialization
struct PlatformRuntimeInitialization_t3141452252 : public RuntimeObject
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // PLATFORMRUNTIMEINITIALIZATION_T3141452252_H
#ifndef PLAYMODEUNITYPLAYER_T3763348594_H
#define PLAYMODEUNITYPLAYER_T3763348594_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// Vuforia.PlayModeUnityPlayer
struct PlayModeUnityPlayer_t3763348594 : public RuntimeObject
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // PLAYMODEUNITYPLAYER_T3763348594_H
#ifndef SOLVERDATA_T3372117984_H
#define SOLVERDATA_T3372117984_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// Thinksquirrel.Fluvio.Plugins.SolverData
struct SolverData_t3372117984 : public RuntimeObject
{
public:
// Thinksquirrel.Fluvio.Internal.ObjectModel.IFluidSolver Thinksquirrel.Fluvio.Plugins.SolverData::m_InternalSolver
RuntimeObject* ___m_InternalSolver_1;
// Thinksquirrel.Fluvio.Internal.Solvers.SolverDataInternal Thinksquirrel.Fluvio.Plugins.SolverData::fluvio
SolverDataInternal_t3200118405 * ___fluvio_2;
public:
inline static int32_t get_offset_of_m_InternalSolver_1() { return static_cast<int32_t>(offsetof(SolverData_t3372117984, ___m_InternalSolver_1)); }
inline RuntimeObject* get_m_InternalSolver_1() const { return ___m_InternalSolver_1; }
inline RuntimeObject** get_address_of_m_InternalSolver_1() { return &___m_InternalSolver_1; }
inline void set_m_InternalSolver_1(RuntimeObject* value)
{
___m_InternalSolver_1 = value;
Il2CppCodeGenWriteBarrier((&___m_InternalSolver_1), value);
}
inline static int32_t get_offset_of_fluvio_2() { return static_cast<int32_t>(offsetof(SolverData_t3372117984, ___fluvio_2)); }
inline SolverDataInternal_t3200118405 * get_fluvio_2() const { return ___fluvio_2; }
inline SolverDataInternal_t3200118405 ** get_address_of_fluvio_2() { return &___fluvio_2; }
inline void set_fluvio_2(SolverDataInternal_t3200118405 * value)
{
___fluvio_2 = value;
Il2CppCodeGenWriteBarrier((&___fluvio_2), value);
}
};
struct SolverData_t3372117984_ThreadStaticFields
{
public:
// System.Int32 Thinksquirrel.Fluvio.Plugins.SolverData::s_CurrentIndex
int32_t ___s_CurrentIndex_0;
public:
inline static int32_t get_offset_of_s_CurrentIndex_0() { return static_cast<int32_t>(offsetof(SolverData_t3372117984_ThreadStaticFields, ___s_CurrentIndex_0)); }
inline int32_t get_s_CurrentIndex_0() const { return ___s_CurrentIndex_0; }
inline int32_t* get_address_of_s_CurrentIndex_0() { return &___s_CurrentIndex_0; }
inline void set_s_CurrentIndex_0(int32_t value)
{
___s_CurrentIndex_0 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // SOLVERDATA_T3372117984_H
#ifndef ARCONTROLLER_T116632334_H
#define ARCONTROLLER_T116632334_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// Vuforia.ARController
struct ARController_t116632334 : public RuntimeObject
{
public:
// Vuforia.VuforiaBehaviour Vuforia.ARController::mVuforiaBehaviour
VuforiaBehaviour_t2151848540 * ___mVuforiaBehaviour_0;
public:
inline static int32_t get_offset_of_mVuforiaBehaviour_0() { return static_cast<int32_t>(offsetof(ARController_t116632334, ___mVuforiaBehaviour_0)); }
inline VuforiaBehaviour_t2151848540 * get_mVuforiaBehaviour_0() const { return ___mVuforiaBehaviour_0; }
inline VuforiaBehaviour_t2151848540 ** get_address_of_mVuforiaBehaviour_0() { return &___mVuforiaBehaviour_0; }
inline void set_mVuforiaBehaviour_0(VuforiaBehaviour_t2151848540 * value)
{
___mVuforiaBehaviour_0 = value;
Il2CppCodeGenWriteBarrier((&___mVuforiaBehaviour_0), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // ARCONTROLLER_T116632334_H
#ifndef U3CU3EC_T2220019719_H
#define U3CU3EC_T2220019719_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// Vuforia.PositionalPlayModeDeviceTrackerImpl/<>c
struct U3CU3Ec_t2220019719 : public RuntimeObject
{
public:
public:
};
struct U3CU3Ec_t2220019719_StaticFields
{
public:
// Vuforia.PositionalPlayModeDeviceTrackerImpl/<>c Vuforia.PositionalPlayModeDeviceTrackerImpl/<>c::<>9
U3CU3Ec_t2220019719 * ___U3CU3E9_0;
// System.Func`2<Vuforia.TrackableBehaviour,System.Boolean> Vuforia.PositionalPlayModeDeviceTrackerImpl/<>c::<>9__14_0
Func_2_t2413074071 * ___U3CU3E9__14_0_1;
// System.Func`2<Vuforia.ImageTargetBehaviour,System.Boolean> Vuforia.PositionalPlayModeDeviceTrackerImpl/<>c::<>9__14_1
Func_2_t1895999181 * ___U3CU3E9__14_1_2;
public:
inline static int32_t get_offset_of_U3CU3E9_0() { return static_cast<int32_t>(offsetof(U3CU3Ec_t2220019719_StaticFields, ___U3CU3E9_0)); }
inline U3CU3Ec_t2220019719 * get_U3CU3E9_0() const { return ___U3CU3E9_0; }
inline U3CU3Ec_t2220019719 ** get_address_of_U3CU3E9_0() { return &___U3CU3E9_0; }
inline void set_U3CU3E9_0(U3CU3Ec_t2220019719 * value)
{
___U3CU3E9_0 = value;
Il2CppCodeGenWriteBarrier((&___U3CU3E9_0), value);
}
inline static int32_t get_offset_of_U3CU3E9__14_0_1() { return static_cast<int32_t>(offsetof(U3CU3Ec_t2220019719_StaticFields, ___U3CU3E9__14_0_1)); }
inline Func_2_t2413074071 * get_U3CU3E9__14_0_1() const { return ___U3CU3E9__14_0_1; }
inline Func_2_t2413074071 ** get_address_of_U3CU3E9__14_0_1() { return &___U3CU3E9__14_0_1; }
inline void set_U3CU3E9__14_0_1(Func_2_t2413074071 * value)
{
___U3CU3E9__14_0_1 = value;
Il2CppCodeGenWriteBarrier((&___U3CU3E9__14_0_1), value);
}
inline static int32_t get_offset_of_U3CU3E9__14_1_2() { return static_cast<int32_t>(offsetof(U3CU3Ec_t2220019719_StaticFields, ___U3CU3E9__14_1_2)); }
inline Func_2_t1895999181 * get_U3CU3E9__14_1_2() const { return ___U3CU3E9__14_1_2; }
inline Func_2_t1895999181 ** get_address_of_U3CU3E9__14_1_2() { return &___U3CU3E9__14_1_2; }
inline void set_U3CU3E9__14_1_2(Func_2_t1895999181 * value)
{
___U3CU3E9__14_1_2 = value;
Il2CppCodeGenWriteBarrier((&___U3CU3E9__14_1_2), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // U3CU3EC_T2220019719_H
#ifndef STATICWEBCAMTEXADAPTOR_T4059221982_H
#define STATICWEBCAMTEXADAPTOR_T4059221982_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// Vuforia.StaticWebCamTexAdaptor
struct StaticWebCamTexAdaptor_t4059221982 : public RuntimeObject
{
public:
// UnityEngine.Texture Vuforia.StaticWebCamTexAdaptor::<Texture>k__BackingField
Texture_t3661962703 * ___U3CTextureU3Ek__BackingField_0;
public:
inline static int32_t get_offset_of_U3CTextureU3Ek__BackingField_0() { return static_cast<int32_t>(offsetof(StaticWebCamTexAdaptor_t4059221982, ___U3CTextureU3Ek__BackingField_0)); }
inline Texture_t3661962703 * get_U3CTextureU3Ek__BackingField_0() const { return ___U3CTextureU3Ek__BackingField_0; }
inline Texture_t3661962703 ** get_address_of_U3CTextureU3Ek__BackingField_0() { return &___U3CTextureU3Ek__BackingField_0; }
inline void set_U3CTextureU3Ek__BackingField_0(Texture_t3661962703 * value)
{
___U3CTextureU3Ek__BackingField_0 = value;
Il2CppCodeGenWriteBarrier((&___U3CTextureU3Ek__BackingField_0), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // STATICWEBCAMTEXADAPTOR_T4059221982_H
#ifndef DISABLEDEXTENDEDTRACKINGIMPL_T4193346383_H
#define DISABLEDEXTENDEDTRACKINGIMPL_T4193346383_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// Vuforia.DisabledExtendedTrackingImpl
struct DisabledExtendedTrackingImpl_t4193346383 : public RuntimeObject
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // DISABLEDEXTENDEDTRACKINGIMPL_T4193346383_H
#ifndef MODELTARGETBOUNDINGBOXIMPL_T1878120817_H
#define MODELTARGETBOUNDINGBOXIMPL_T1878120817_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// Vuforia.ModelTargetBoundingBoxImpl
struct ModelTargetBoundingBoxImpl_t1878120817 : public RuntimeObject
{
public:
// Vuforia.DataSet Vuforia.ModelTargetBoundingBoxImpl::mDataSet
DataSet_t3286034874 * ___mDataSet_0;
// System.String Vuforia.ModelTargetBoundingBoxImpl::mName
String_t* ___mName_1;
public:
inline static int32_t get_offset_of_mDataSet_0() { return static_cast<int32_t>(offsetof(ModelTargetBoundingBoxImpl_t1878120817, ___mDataSet_0)); }
inline DataSet_t3286034874 * get_mDataSet_0() const { return ___mDataSet_0; }
inline DataSet_t3286034874 ** get_address_of_mDataSet_0() { return &___mDataSet_0; }
inline void set_mDataSet_0(DataSet_t3286034874 * value)
{
___mDataSet_0 = value;
Il2CppCodeGenWriteBarrier((&___mDataSet_0), value);
}
inline static int32_t get_offset_of_mName_1() { return static_cast<int32_t>(offsetof(ModelTargetBoundingBoxImpl_t1878120817, ___mName_1)); }
inline String_t* get_mName_1() const { return ___mName_1; }
inline String_t** get_address_of_mName_1() { return &___mName_1; }
inline void set_mName_1(String_t* value)
{
___mName_1 = value;
Il2CppCodeGenWriteBarrier((&___mName_1), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // MODELTARGETBOUNDINGBOXIMPL_T1878120817_H
#ifndef VALUETYPE_T3640485471_H
#define VALUETYPE_T3640485471_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.ValueType
struct ValueType_t3640485471 : public RuntimeObject
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
// Native definition for P/Invoke marshalling of System.ValueType
struct ValueType_t3640485471_marshaled_pinvoke
{
};
// Native definition for COM marshalling of System.ValueType
struct ValueType_t3640485471_marshaled_com
{
};
#endif // VALUETYPE_T3640485471_H
#ifndef WSAUNITYPLAYER_T3135728299_H
#define WSAUNITYPLAYER_T3135728299_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// Vuforia.WSAUnityPlayer
struct WSAUnityPlayer_t3135728299 : public RuntimeObject
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // WSAUNITYPLAYER_T3135728299_H
#ifndef SOLVERUTILITY_T1140880853_H
#define SOLVERUTILITY_T1140880853_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// Thinksquirrel.Fluvio.Internal.Solvers.SolverUtility
struct SolverUtility_t1140880853 : public RuntimeObject
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // SOLVERUTILITY_T1140880853_H
#ifndef SMOOTHINGKERNEL_T2173549093_H
#define SMOOTHINGKERNEL_T2173549093_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// Thinksquirrel.Fluvio.Internal.Solvers.SmoothingKernel
struct SmoothingKernel_t2173549093 : public RuntimeObject
{
public:
// System.Single Thinksquirrel.Fluvio.Internal.Solvers.SmoothingKernel::factor
float ___factor_0;
// System.Single Thinksquirrel.Fluvio.Internal.Solvers.SmoothingKernel::kernelSize
float ___kernelSize_1;
// System.Single Thinksquirrel.Fluvio.Internal.Solvers.SmoothingKernel::kernelSize3
float ___kernelSize3_2;
// System.Single Thinksquirrel.Fluvio.Internal.Solvers.SmoothingKernel::kernelSize6
float ___kernelSize6_3;
// System.Single Thinksquirrel.Fluvio.Internal.Solvers.SmoothingKernel::kernelSize9
float ___kernelSize9_4;
// System.Single Thinksquirrel.Fluvio.Internal.Solvers.SmoothingKernel::kernelSizeSq
float ___kernelSizeSq_5;
public:
inline static int32_t get_offset_of_factor_0() { return static_cast<int32_t>(offsetof(SmoothingKernel_t2173549093, ___factor_0)); }
inline float get_factor_0() const { return ___factor_0; }
inline float* get_address_of_factor_0() { return &___factor_0; }
inline void set_factor_0(float value)
{
___factor_0 = value;
}
inline static int32_t get_offset_of_kernelSize_1() { return static_cast<int32_t>(offsetof(SmoothingKernel_t2173549093, ___kernelSize_1)); }
inline float get_kernelSize_1() const { return ___kernelSize_1; }
inline float* get_address_of_kernelSize_1() { return &___kernelSize_1; }
inline void set_kernelSize_1(float value)
{
___kernelSize_1 = value;
}
inline static int32_t get_offset_of_kernelSize3_2() { return static_cast<int32_t>(offsetof(SmoothingKernel_t2173549093, ___kernelSize3_2)); }
inline float get_kernelSize3_2() const { return ___kernelSize3_2; }
inline float* get_address_of_kernelSize3_2() { return &___kernelSize3_2; }
inline void set_kernelSize3_2(float value)
{
___kernelSize3_2 = value;
}
inline static int32_t get_offset_of_kernelSize6_3() { return static_cast<int32_t>(offsetof(SmoothingKernel_t2173549093, ___kernelSize6_3)); }
inline float get_kernelSize6_3() const { return ___kernelSize6_3; }
inline float* get_address_of_kernelSize6_3() { return &___kernelSize6_3; }
inline void set_kernelSize6_3(float value)
{
___kernelSize6_3 = value;
}
inline static int32_t get_offset_of_kernelSize9_4() { return static_cast<int32_t>(offsetof(SmoothingKernel_t2173549093, ___kernelSize9_4)); }
inline float get_kernelSize9_4() const { return ___kernelSize9_4; }
inline float* get_address_of_kernelSize9_4() { return &___kernelSize9_4; }
inline void set_kernelSize9_4(float value)
{
___kernelSize9_4 = value;
}
inline static int32_t get_offset_of_kernelSizeSq_5() { return static_cast<int32_t>(offsetof(SmoothingKernel_t2173549093, ___kernelSizeSq_5)); }
inline float get_kernelSizeSq_5() const { return ___kernelSizeSq_5; }
inline float* get_address_of_kernelSizeSq_5() { return &___kernelSizeSq_5; }
inline void set_kernelSizeSq_5(float value)
{
___kernelSizeSq_5 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // SMOOTHINGKERNEL_T2173549093_H
#ifndef U3CU3EC__DISPLAYCLASS11_0_T2669575632_H
#define U3CU3EC__DISPLAYCLASS11_0_T2669575632_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// Vuforia.ARController/<>c__DisplayClass11_0
struct U3CU3Ec__DisplayClass11_0_t2669575632 : public RuntimeObject
{
public:
// Vuforia.ARController Vuforia.ARController/<>c__DisplayClass11_0::controller
ARController_t116632334 * ___controller_0;
public:
inline static int32_t get_offset_of_controller_0() { return static_cast<int32_t>(offsetof(U3CU3Ec__DisplayClass11_0_t2669575632, ___controller_0)); }
inline ARController_t116632334 * get_controller_0() const { return ___controller_0; }
inline ARController_t116632334 ** get_address_of_controller_0() { return &___controller_0; }
inline void set_controller_0(ARController_t116632334 * value)
{
___controller_0 = value;
Il2CppCodeGenWriteBarrier((&___controller_0), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // U3CU3EC__DISPLAYCLASS11_0_T2669575632_H
#ifndef INDEXGRID_T759839143_H
#define INDEXGRID_T759839143_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// Thinksquirrel.Fluvio.Internal.Solvers.IndexGrid
struct IndexGrid_t759839143 : public RuntimeObject
{
public:
// System.Int32[] Thinksquirrel.Fluvio.Internal.Solvers.IndexGrid::m_Grid
Int32U5BU5D_t385246372* ___m_Grid_0;
// System.Single Thinksquirrel.Fluvio.Internal.Solvers.IndexGrid::m_CellSpace
float ___m_CellSpace_1;
// Thinksquirrel.Fluvio.Internal.Threading.ParallelAction Thinksquirrel.Fluvio.Internal.Solvers.IndexGrid::s_DoClearDel
ParallelAction_t3477057985 * ___s_DoClearDel_3;
public:
inline static int32_t get_offset_of_m_Grid_0() { return static_cast<int32_t>(offsetof(IndexGrid_t759839143, ___m_Grid_0)); }
inline Int32U5BU5D_t385246372* get_m_Grid_0() const { return ___m_Grid_0; }
inline Int32U5BU5D_t385246372** get_address_of_m_Grid_0() { return &___m_Grid_0; }
inline void set_m_Grid_0(Int32U5BU5D_t385246372* value)
{
___m_Grid_0 = value;
Il2CppCodeGenWriteBarrier((&___m_Grid_0), value);
}
inline static int32_t get_offset_of_m_CellSpace_1() { return static_cast<int32_t>(offsetof(IndexGrid_t759839143, ___m_CellSpace_1)); }
inline float get_m_CellSpace_1() const { return ___m_CellSpace_1; }
inline float* get_address_of_m_CellSpace_1() { return &___m_CellSpace_1; }
inline void set_m_CellSpace_1(float value)
{
___m_CellSpace_1 = value;
}
inline static int32_t get_offset_of_s_DoClearDel_3() { return static_cast<int32_t>(offsetof(IndexGrid_t759839143, ___s_DoClearDel_3)); }
inline ParallelAction_t3477057985 * get_s_DoClearDel_3() const { return ___s_DoClearDel_3; }
inline ParallelAction_t3477057985 ** get_address_of_s_DoClearDel_3() { return &___s_DoClearDel_3; }
inline void set_s_DoClearDel_3(ParallelAction_t3477057985 * value)
{
___s_DoClearDel_3 = value;
Il2CppCodeGenWriteBarrier((&___s_DoClearDel_3), value);
}
};
struct IndexGrid_t759839143_StaticFields
{
public:
// System.Int32[] Thinksquirrel.Fluvio.Internal.Solvers.IndexGrid::s_Clear
Int32U5BU5D_t385246372* ___s_Clear_2;
public:
inline static int32_t get_offset_of_s_Clear_2() { return static_cast<int32_t>(offsetof(IndexGrid_t759839143_StaticFields, ___s_Clear_2)); }
inline Int32U5BU5D_t385246372* get_s_Clear_2() const { return ___s_Clear_2; }
inline Int32U5BU5D_t385246372** get_address_of_s_Clear_2() { return &___s_Clear_2; }
inline void set_s_Clear_2(Int32U5BU5D_t385246372* value)
{
___s_Clear_2 = value;
Il2CppCodeGenWriteBarrier((&___s_Clear_2), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // INDEXGRID_T759839143_H
#ifndef FLUIDSOLVER_T3145627998_H
#define FLUIDSOLVER_T3145627998_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// Thinksquirrel.Fluvio.Internal.Solvers.FluidSolver
struct FluidSolver_t3145627998 : public RuntimeObject
{
public:
// Thinksquirrel.Fluvio.Internal.TimerGroup Thinksquirrel.Fluvio.Internal.Solvers.FluidSolver::m_Timers
TimerGroup_t1675067946 * ___m_Timers_0;
// Thinksquirrel.Fluvio.FluidBase Thinksquirrel.Fluvio.Internal.Solvers.FluidSolver::m_RootFluid
FluidBase_t2442071467 * ___m_RootFluid_1;
// System.Collections.Generic.List`1<Thinksquirrel.Fluvio.FluidBase> Thinksquirrel.Fluvio.Internal.Solvers.FluidSolver::m_Fluids
List_1_t3914146209 * ___m_Fluids_2;
// Thinksquirrel.Fluvio.Internal.Solvers.SmoothingKernel Thinksquirrel.Fluvio.Internal.Solvers.FluidSolver::Poly6
SmoothingKernel_t2173549093 * ___Poly6_3;
// Thinksquirrel.Fluvio.Internal.Solvers.SmoothingKernel Thinksquirrel.Fluvio.Internal.Solvers.FluidSolver::Spiky
SmoothingKernel_t2173549093 * ___Spiky_4;
// Thinksquirrel.Fluvio.Internal.Solvers.SmoothingKernel Thinksquirrel.Fluvio.Internal.Solvers.FluidSolver::Viscosity
SmoothingKernel_t2173549093 * ___Viscosity_5;
// Thinksquirrel.Fluvio.FluvioComputeShader Thinksquirrel.Fluvio.Internal.Solvers.FluidSolver::m_ComputeShader
FluvioComputeShader_t2551470295 * ___m_ComputeShader_6;
// System.Int32 Thinksquirrel.Fluvio.Internal.Solvers.FluidSolver::m_SolverBoundaryTexture
int32_t ___m_SolverBoundaryTexture_7;
// System.Int32 Thinksquirrel.Fluvio.Internal.Solvers.FluidSolver::m_SolverIndexGridClear
int32_t ___m_SolverIndexGridClear_8;
// System.Int32 Thinksquirrel.Fluvio.Internal.Solvers.FluidSolver::m_SolverIndexGridAdd
int32_t ___m_SolverIndexGridAdd_9;
// System.Int32 Thinksquirrel.Fluvio.Internal.Solvers.FluidSolver::m_SolverNeighborSearchGrid2D
int32_t ___m_SolverNeighborSearchGrid2D_10;
// System.Int32 Thinksquirrel.Fluvio.Internal.Solvers.FluidSolver::m_SolverNeighborSearchGrid3D
int32_t ___m_SolverNeighborSearchGrid3D_11;
// System.Int32 Thinksquirrel.Fluvio.Internal.Solvers.FluidSolver::m_SolverNeighborSearch2D
int32_t ___m_SolverNeighborSearch2D_12;
// System.Int32 Thinksquirrel.Fluvio.Internal.Solvers.FluidSolver::m_SolverNeighborSearch3D
int32_t ___m_SolverNeighborSearch3D_13;
// System.Int32 Thinksquirrel.Fluvio.Internal.Solvers.FluidSolver::m_SolverDensityPressure
int32_t ___m_SolverDensityPressure_14;
// System.Int32 Thinksquirrel.Fluvio.Internal.Solvers.FluidSolver::m_SolverNormal
int32_t ___m_SolverNormal_15;
// System.Int32 Thinksquirrel.Fluvio.Internal.Solvers.FluidSolver::m_SolverForces
int32_t ___m_SolverForces_16;
// System.Int32 Thinksquirrel.Fluvio.Internal.Solvers.FluidSolver::m_SolverBoundaryForces
int32_t ___m_SolverBoundaryForces_17;
// System.Int32 Thinksquirrel.Fluvio.Internal.Solvers.FluidSolver::m_SolverTurbulence
int32_t ___m_SolverTurbulence_18;
// System.Int32 Thinksquirrel.Fluvio.Internal.Solvers.FluidSolver::m_SolverExternalForces
int32_t ___m_SolverExternalForces_19;
// System.Int32 Thinksquirrel.Fluvio.Internal.Solvers.FluidSolver::m_SolverConstraints
int32_t ___m_SolverConstraints_20;
// Thinksquirrel.Fluvio.Internal.Threading.ParallelAction Thinksquirrel.Fluvio.Internal.Solvers.FluidSolver::m_SolverIndexGridAddDel
ParallelAction_t3477057985 * ___m_SolverIndexGridAddDel_21;
// Thinksquirrel.Fluvio.Internal.Threading.ParallelAction Thinksquirrel.Fluvio.Internal.Solvers.FluidSolver::m_SolverNeighborSearchGrid2DDel
ParallelAction_t3477057985 * ___m_SolverNeighborSearchGrid2DDel_22;
// Thinksquirrel.Fluvio.Internal.Threading.ParallelAction Thinksquirrel.Fluvio.Internal.Solvers.FluidSolver::m_SolverNeighborSearchGrid3DDel
ParallelAction_t3477057985 * ___m_SolverNeighborSearchGrid3DDel_23;
// Thinksquirrel.Fluvio.Internal.Threading.ParallelAction Thinksquirrel.Fluvio.Internal.Solvers.FluidSolver::m_SolverNeighborSearch2DDel
ParallelAction_t3477057985 * ___m_SolverNeighborSearch2DDel_24;
// Thinksquirrel.Fluvio.Internal.Threading.ParallelAction Thinksquirrel.Fluvio.Internal.Solvers.FluidSolver::m_SolverNeighborSearch3DDel
ParallelAction_t3477057985 * ___m_SolverNeighborSearch3DDel_25;
// Thinksquirrel.Fluvio.Internal.Threading.ParallelAction Thinksquirrel.Fluvio.Internal.Solvers.FluidSolver::m_SolverDensityPressureDel
ParallelAction_t3477057985 * ___m_SolverDensityPressureDel_26;
// Thinksquirrel.Fluvio.Internal.Threading.ParallelAction Thinksquirrel.Fluvio.Internal.Solvers.FluidSolver::m_SolverNormalDel
ParallelAction_t3477057985 * ___m_SolverNormalDel_27;
// Thinksquirrel.Fluvio.Internal.Threading.ParallelAction Thinksquirrel.Fluvio.Internal.Solvers.FluidSolver::m_SolverForcesDel
ParallelAction_t3477057985 * ___m_SolverForcesDel_28;
// Thinksquirrel.Fluvio.Internal.Threading.ParallelAction Thinksquirrel.Fluvio.Internal.Solvers.FluidSolver::m_SolverBoundaryForcesDel
ParallelAction_t3477057985 * ___m_SolverBoundaryForcesDel_29;
// Thinksquirrel.Fluvio.Internal.Threading.ParallelAction Thinksquirrel.Fluvio.Internal.Solvers.FluidSolver::m_SolverTurbulenceDel
ParallelAction_t3477057985 * ___m_SolverTurbulenceDel_30;
// Thinksquirrel.Fluvio.Internal.Threading.ParallelAction Thinksquirrel.Fluvio.Internal.Solvers.FluidSolver::m_SolverExternalForcesDel
ParallelAction_t3477057985 * ___m_SolverExternalForcesDel_31;
// Thinksquirrel.Fluvio.Internal.Threading.ParallelAction Thinksquirrel.Fluvio.Internal.Solvers.FluidSolver::m_SolverConstraintsDel
ParallelAction_t3477057985 * ___m_SolverConstraintsDel_32;
// Thinksquirrel.Fluvio.Internal.Threading.ParallelAction Thinksquirrel.Fluvio.Internal.Solvers.FluidSolver::m_DoForEachParticleDynamicDel
ParallelAction_t3477057985 * ___m_DoForEachParticleDynamicDel_33;
// Thinksquirrel.Fluvio.Internal.Threading.ParallelAction Thinksquirrel.Fluvio.Internal.Solvers.FluidSolver::m_DoForEachParticleDel
ParallelAction_t3477057985 * ___m_DoForEachParticleDel_34;
// Thinksquirrel.Fluvio.Internal.Threading.ParallelAction Thinksquirrel.Fluvio.Internal.Solvers.FluidSolver::m_DoForEachParticleAllDel
ParallelAction_t3477057985 * ___m_DoForEachParticleAllDel_35;
// Thinksquirrel.Fluvio.Internal.Threading.ParallelAction Thinksquirrel.Fluvio.Internal.Solvers.FluidSolver::m_DoForEachParticleBoundaryDel
ParallelAction_t3477057985 * ___m_DoForEachParticleBoundaryDel_36;
// Thinksquirrel.Fluvio.Internal.Threading.ParallelAction Thinksquirrel.Fluvio.Internal.Solvers.FluidSolver::m_DoForEachParticlePairDel
ParallelAction_t3477057985 * ___m_DoForEachParticlePairDel_37;
// Thinksquirrel.Fluvio.Internal.SolverParticleDelegate Thinksquirrel.Fluvio.Internal.Solvers.FluidSolver::m_CurrentParticleDel
SolverParticleDelegate_t4224278369 * ___m_CurrentParticleDel_38;
// Thinksquirrel.Fluvio.Internal.SolverParticlePairDelegate Thinksquirrel.Fluvio.Internal.Solvers.FluidSolver::m_CurrentParticlePairDel
SolverParticlePairDelegate_t2332887997 * ___m_CurrentParticlePairDel_39;
// System.Boolean Thinksquirrel.Fluvio.Internal.Solvers.FluidSolver::m_ComputeShouldSync
bool ___m_ComputeShouldSync_40;
// Thinksquirrel.Fluvio.Internal.Solvers.SolverDataInternal Thinksquirrel.Fluvio.Internal.Solvers.FluidSolver::fluvio
SolverDataInternal_t3200118405 * ___fluvio_41;
// System.Int32 Thinksquirrel.Fluvio.Internal.Solvers.FluidSolver::m_SolverTimer
int32_t ___m_SolverTimer_42;
// System.Int32 Thinksquirrel.Fluvio.Internal.Solvers.FluidSolver::m_PluginsTimer
int32_t ___m_PluginsTimer_43;
// System.Boolean Thinksquirrel.Fluvio.Internal.Solvers.FluidSolver::m_IsMobilePlatform
bool ___m_IsMobilePlatform_44;
// System.Boolean Thinksquirrel.Fluvio.Internal.Solvers.FluidSolver::<canUseFastIntegrationPath>k__BackingField
bool ___U3CcanUseFastIntegrationPathU3Ek__BackingField_46;
public:
inline static int32_t get_offset_of_m_Timers_0() { return static_cast<int32_t>(offsetof(FluidSolver_t3145627998, ___m_Timers_0)); }
inline TimerGroup_t1675067946 * get_m_Timers_0() const { return ___m_Timers_0; }
inline TimerGroup_t1675067946 ** get_address_of_m_Timers_0() { return &___m_Timers_0; }
inline void set_m_Timers_0(TimerGroup_t1675067946 * value)
{
___m_Timers_0 = value;
Il2CppCodeGenWriteBarrier((&___m_Timers_0), value);
}
inline static int32_t get_offset_of_m_RootFluid_1() { return static_cast<int32_t>(offsetof(FluidSolver_t3145627998, ___m_RootFluid_1)); }
inline FluidBase_t2442071467 * get_m_RootFluid_1() const { return ___m_RootFluid_1; }
inline FluidBase_t2442071467 ** get_address_of_m_RootFluid_1() { return &___m_RootFluid_1; }
inline void set_m_RootFluid_1(FluidBase_t2442071467 * value)
{
___m_RootFluid_1 = value;
Il2CppCodeGenWriteBarrier((&___m_RootFluid_1), value);
}
inline static int32_t get_offset_of_m_Fluids_2() { return static_cast<int32_t>(offsetof(FluidSolver_t3145627998, ___m_Fluids_2)); }
inline List_1_t3914146209 * get_m_Fluids_2() const { return ___m_Fluids_2; }
inline List_1_t3914146209 ** get_address_of_m_Fluids_2() { return &___m_Fluids_2; }
inline void set_m_Fluids_2(List_1_t3914146209 * value)
{
___m_Fluids_2 = value;
Il2CppCodeGenWriteBarrier((&___m_Fluids_2), value);
}
inline static int32_t get_offset_of_Poly6_3() { return static_cast<int32_t>(offsetof(FluidSolver_t3145627998, ___Poly6_3)); }
inline SmoothingKernel_t2173549093 * get_Poly6_3() const { return ___Poly6_3; }
inline SmoothingKernel_t2173549093 ** get_address_of_Poly6_3() { return &___Poly6_3; }
inline void set_Poly6_3(SmoothingKernel_t2173549093 * value)
{
___Poly6_3 = value;
Il2CppCodeGenWriteBarrier((&___Poly6_3), value);
}
inline static int32_t get_offset_of_Spiky_4() { return static_cast<int32_t>(offsetof(FluidSolver_t3145627998, ___Spiky_4)); }
inline SmoothingKernel_t2173549093 * get_Spiky_4() const { return ___Spiky_4; }
inline SmoothingKernel_t2173549093 ** get_address_of_Spiky_4() { return &___Spiky_4; }
inline void set_Spiky_4(SmoothingKernel_t2173549093 * value)
{
___Spiky_4 = value;
Il2CppCodeGenWriteBarrier((&___Spiky_4), value);
}
inline static int32_t get_offset_of_Viscosity_5() { return static_cast<int32_t>(offsetof(FluidSolver_t3145627998, ___Viscosity_5)); }
inline SmoothingKernel_t2173549093 * get_Viscosity_5() const { return ___Viscosity_5; }
inline SmoothingKernel_t2173549093 ** get_address_of_Viscosity_5() { return &___Viscosity_5; }
inline void set_Viscosity_5(SmoothingKernel_t2173549093 * value)
{
___Viscosity_5 = value;
Il2CppCodeGenWriteBarrier((&___Viscosity_5), value);
}
inline static int32_t get_offset_of_m_ComputeShader_6() { return static_cast<int32_t>(offsetof(FluidSolver_t3145627998, ___m_ComputeShader_6)); }
inline FluvioComputeShader_t2551470295 * get_m_ComputeShader_6() const { return ___m_ComputeShader_6; }
inline FluvioComputeShader_t2551470295 ** get_address_of_m_ComputeShader_6() { return &___m_ComputeShader_6; }
inline void set_m_ComputeShader_6(FluvioComputeShader_t2551470295 * value)
{
___m_ComputeShader_6 = value;
Il2CppCodeGenWriteBarrier((&___m_ComputeShader_6), value);
}
inline static int32_t get_offset_of_m_SolverBoundaryTexture_7() { return static_cast<int32_t>(offsetof(FluidSolver_t3145627998, ___m_SolverBoundaryTexture_7)); }
inline int32_t get_m_SolverBoundaryTexture_7() const { return ___m_SolverBoundaryTexture_7; }
inline int32_t* get_address_of_m_SolverBoundaryTexture_7() { return &___m_SolverBoundaryTexture_7; }
inline void set_m_SolverBoundaryTexture_7(int32_t value)
{
___m_SolverBoundaryTexture_7 = value;
}
inline static int32_t get_offset_of_m_SolverIndexGridClear_8() { return static_cast<int32_t>(offsetof(FluidSolver_t3145627998, ___m_SolverIndexGridClear_8)); }
inline int32_t get_m_SolverIndexGridClear_8() const { return ___m_SolverIndexGridClear_8; }
inline int32_t* get_address_of_m_SolverIndexGridClear_8() { return &___m_SolverIndexGridClear_8; }
inline void set_m_SolverIndexGridClear_8(int32_t value)
{
___m_SolverIndexGridClear_8 = value;
}
inline static int32_t get_offset_of_m_SolverIndexGridAdd_9() { return static_cast<int32_t>(offsetof(FluidSolver_t3145627998, ___m_SolverIndexGridAdd_9)); }
inline int32_t get_m_SolverIndexGridAdd_9() const { return ___m_SolverIndexGridAdd_9; }
inline int32_t* get_address_of_m_SolverIndexGridAdd_9() { return &___m_SolverIndexGridAdd_9; }
inline void set_m_SolverIndexGridAdd_9(int32_t value)
{
___m_SolverIndexGridAdd_9 = value;
}
inline static int32_t get_offset_of_m_SolverNeighborSearchGrid2D_10() { return static_cast<int32_t>(offsetof(FluidSolver_t3145627998, ___m_SolverNeighborSearchGrid2D_10)); }
inline int32_t get_m_SolverNeighborSearchGrid2D_10() const { return ___m_SolverNeighborSearchGrid2D_10; }
inline int32_t* get_address_of_m_SolverNeighborSearchGrid2D_10() { return &___m_SolverNeighborSearchGrid2D_10; }
inline void set_m_SolverNeighborSearchGrid2D_10(int32_t value)
{
___m_SolverNeighborSearchGrid2D_10 = value;
}
inline static int32_t get_offset_of_m_SolverNeighborSearchGrid3D_11() { return static_cast<int32_t>(offsetof(FluidSolver_t3145627998, ___m_SolverNeighborSearchGrid3D_11)); }
inline int32_t get_m_SolverNeighborSearchGrid3D_11() const { return ___m_SolverNeighborSearchGrid3D_11; }
inline int32_t* get_address_of_m_SolverNeighborSearchGrid3D_11() { return &___m_SolverNeighborSearchGrid3D_11; }
inline void set_m_SolverNeighborSearchGrid3D_11(int32_t value)
{
___m_SolverNeighborSearchGrid3D_11 = value;
}
inline static int32_t get_offset_of_m_SolverNeighborSearch2D_12() { return static_cast<int32_t>(offsetof(FluidSolver_t3145627998, ___m_SolverNeighborSearch2D_12)); }
inline int32_t get_m_SolverNeighborSearch2D_12() const { return ___m_SolverNeighborSearch2D_12; }
inline int32_t* get_address_of_m_SolverNeighborSearch2D_12() { return &___m_SolverNeighborSearch2D_12; }
inline void set_m_SolverNeighborSearch2D_12(int32_t value)
{
___m_SolverNeighborSearch2D_12 = value;
}
inline static int32_t get_offset_of_m_SolverNeighborSearch3D_13() { return static_cast<int32_t>(offsetof(FluidSolver_t3145627998, ___m_SolverNeighborSearch3D_13)); }
inline int32_t get_m_SolverNeighborSearch3D_13() const { return ___m_SolverNeighborSearch3D_13; }
inline int32_t* get_address_of_m_SolverNeighborSearch3D_13() { return &___m_SolverNeighborSearch3D_13; }
inline void set_m_SolverNeighborSearch3D_13(int32_t value)
{
___m_SolverNeighborSearch3D_13 = value;
}
inline static int32_t get_offset_of_m_SolverDensityPressure_14() { return static_cast<int32_t>(offsetof(FluidSolver_t3145627998, ___m_SolverDensityPressure_14)); }
inline int32_t get_m_SolverDensityPressure_14() const { return ___m_SolverDensityPressure_14; }
inline int32_t* get_address_of_m_SolverDensityPressure_14() { return &___m_SolverDensityPressure_14; }
inline void set_m_SolverDensityPressure_14(int32_t value)
{
___m_SolverDensityPressure_14 = value;
}
inline static int32_t get_offset_of_m_SolverNormal_15() { return static_cast<int32_t>(offsetof(FluidSolver_t3145627998, ___m_SolverNormal_15)); }
inline int32_t get_m_SolverNormal_15() const { return ___m_SolverNormal_15; }
inline int32_t* get_address_of_m_SolverNormal_15() { return &___m_SolverNormal_15; }
inline void set_m_SolverNormal_15(int32_t value)
{
___m_SolverNormal_15 = value;
}
inline static int32_t get_offset_of_m_SolverForces_16() { return static_cast<int32_t>(offsetof(FluidSolver_t3145627998, ___m_SolverForces_16)); }
inline int32_t get_m_SolverForces_16() const { return ___m_SolverForces_16; }
inline int32_t* get_address_of_m_SolverForces_16() { return &___m_SolverForces_16; }
inline void set_m_SolverForces_16(int32_t value)
{
___m_SolverForces_16 = value;
}
inline static int32_t get_offset_of_m_SolverBoundaryForces_17() { return static_cast<int32_t>(offsetof(FluidSolver_t3145627998, ___m_SolverBoundaryForces_17)); }
inline int32_t get_m_SolverBoundaryForces_17() const { return ___m_SolverBoundaryForces_17; }
inline int32_t* get_address_of_m_SolverBoundaryForces_17() { return &___m_SolverBoundaryForces_17; }
inline void set_m_SolverBoundaryForces_17(int32_t value)
{
___m_SolverBoundaryForces_17 = value;
}
inline static int32_t get_offset_of_m_SolverTurbulence_18() { return static_cast<int32_t>(offsetof(FluidSolver_t3145627998, ___m_SolverTurbulence_18)); }
inline int32_t get_m_SolverTurbulence_18() const { return ___m_SolverTurbulence_18; }
inline int32_t* get_address_of_m_SolverTurbulence_18() { return &___m_SolverTurbulence_18; }
inline void set_m_SolverTurbulence_18(int32_t value)
{
___m_SolverTurbulence_18 = value;
}
inline static int32_t get_offset_of_m_SolverExternalForces_19() { return static_cast<int32_t>(offsetof(FluidSolver_t3145627998, ___m_SolverExternalForces_19)); }
inline int32_t get_m_SolverExternalForces_19() const { return ___m_SolverExternalForces_19; }
inline int32_t* get_address_of_m_SolverExternalForces_19() { return &___m_SolverExternalForces_19; }
inline void set_m_SolverExternalForces_19(int32_t value)
{
___m_SolverExternalForces_19 = value;
}
inline static int32_t get_offset_of_m_SolverConstraints_20() { return static_cast<int32_t>(offsetof(FluidSolver_t3145627998, ___m_SolverConstraints_20)); }
inline int32_t get_m_SolverConstraints_20() const { return ___m_SolverConstraints_20; }
inline int32_t* get_address_of_m_SolverConstraints_20() { return &___m_SolverConstraints_20; }
inline void set_m_SolverConstraints_20(int32_t value)
{
___m_SolverConstraints_20 = value;
}
inline static int32_t get_offset_of_m_SolverIndexGridAddDel_21() { return static_cast<int32_t>(offsetof(FluidSolver_t3145627998, ___m_SolverIndexGridAddDel_21)); }
inline ParallelAction_t3477057985 * get_m_SolverIndexGridAddDel_21() const { return ___m_SolverIndexGridAddDel_21; }
inline ParallelAction_t3477057985 ** get_address_of_m_SolverIndexGridAddDel_21() { return &___m_SolverIndexGridAddDel_21; }
inline void set_m_SolverIndexGridAddDel_21(ParallelAction_t3477057985 * value)
{
___m_SolverIndexGridAddDel_21 = value;
Il2CppCodeGenWriteBarrier((&___m_SolverIndexGridAddDel_21), value);
}
inline static int32_t get_offset_of_m_SolverNeighborSearchGrid2DDel_22() { return static_cast<int32_t>(offsetof(FluidSolver_t3145627998, ___m_SolverNeighborSearchGrid2DDel_22)); }
inline ParallelAction_t3477057985 * get_m_SolverNeighborSearchGrid2DDel_22() const { return ___m_SolverNeighborSearchGrid2DDel_22; }
inline ParallelAction_t3477057985 ** get_address_of_m_SolverNeighborSearchGrid2DDel_22() { return &___m_SolverNeighborSearchGrid2DDel_22; }
inline void set_m_SolverNeighborSearchGrid2DDel_22(ParallelAction_t3477057985 * value)
{
___m_SolverNeighborSearchGrid2DDel_22 = value;
Il2CppCodeGenWriteBarrier((&___m_SolverNeighborSearchGrid2DDel_22), value);
}
inline static int32_t get_offset_of_m_SolverNeighborSearchGrid3DDel_23() { return static_cast<int32_t>(offsetof(FluidSolver_t3145627998, ___m_SolverNeighborSearchGrid3DDel_23)); }
inline ParallelAction_t3477057985 * get_m_SolverNeighborSearchGrid3DDel_23() const { return ___m_SolverNeighborSearchGrid3DDel_23; }
inline ParallelAction_t3477057985 ** get_address_of_m_SolverNeighborSearchGrid3DDel_23() { return &___m_SolverNeighborSearchGrid3DDel_23; }
inline void set_m_SolverNeighborSearchGrid3DDel_23(ParallelAction_t3477057985 * value)
{
___m_SolverNeighborSearchGrid3DDel_23 = value;
Il2CppCodeGenWriteBarrier((&___m_SolverNeighborSearchGrid3DDel_23), value);
}
inline static int32_t get_offset_of_m_SolverNeighborSearch2DDel_24() { return static_cast<int32_t>(offsetof(FluidSolver_t3145627998, ___m_SolverNeighborSearch2DDel_24)); }
inline ParallelAction_t3477057985 * get_m_SolverNeighborSearch2DDel_24() const { return ___m_SolverNeighborSearch2DDel_24; }
inline ParallelAction_t3477057985 ** get_address_of_m_SolverNeighborSearch2DDel_24() { return &___m_SolverNeighborSearch2DDel_24; }
inline void set_m_SolverNeighborSearch2DDel_24(ParallelAction_t3477057985 * value)
{
___m_SolverNeighborSearch2DDel_24 = value;
Il2CppCodeGenWriteBarrier((&___m_SolverNeighborSearch2DDel_24), value);
}
inline static int32_t get_offset_of_m_SolverNeighborSearch3DDel_25() { return static_cast<int32_t>(offsetof(FluidSolver_t3145627998, ___m_SolverNeighborSearch3DDel_25)); }
inline ParallelAction_t3477057985 * get_m_SolverNeighborSearch3DDel_25() const { return ___m_SolverNeighborSearch3DDel_25; }
inline ParallelAction_t3477057985 ** get_address_of_m_SolverNeighborSearch3DDel_25() { return &___m_SolverNeighborSearch3DDel_25; }
inline void set_m_SolverNeighborSearch3DDel_25(ParallelAction_t3477057985 * value)
{
___m_SolverNeighborSearch3DDel_25 = value;
Il2CppCodeGenWriteBarrier((&___m_SolverNeighborSearch3DDel_25), value);
}
inline static int32_t get_offset_of_m_SolverDensityPressureDel_26() { return static_cast<int32_t>(offsetof(FluidSolver_t3145627998, ___m_SolverDensityPressureDel_26)); }
inline ParallelAction_t3477057985 * get_m_SolverDensityPressureDel_26() const { return ___m_SolverDensityPressureDel_26; }
inline ParallelAction_t3477057985 ** get_address_of_m_SolverDensityPressureDel_26() { return &___m_SolverDensityPressureDel_26; }
inline void set_m_SolverDensityPressureDel_26(ParallelAction_t3477057985 * value)
{
___m_SolverDensityPressureDel_26 = value;
Il2CppCodeGenWriteBarrier((&___m_SolverDensityPressureDel_26), value);
}
inline static int32_t get_offset_of_m_SolverNormalDel_27() { return static_cast<int32_t>(offsetof(FluidSolver_t3145627998, ___m_SolverNormalDel_27)); }
inline ParallelAction_t3477057985 * get_m_SolverNormalDel_27() const { return ___m_SolverNormalDel_27; }
inline ParallelAction_t3477057985 ** get_address_of_m_SolverNormalDel_27() { return &___m_SolverNormalDel_27; }
inline void set_m_SolverNormalDel_27(ParallelAction_t3477057985 * value)
{
___m_SolverNormalDel_27 = value;
Il2CppCodeGenWriteBarrier((&___m_SolverNormalDel_27), value);
}
inline static int32_t get_offset_of_m_SolverForcesDel_28() { return static_cast<int32_t>(offsetof(FluidSolver_t3145627998, ___m_SolverForcesDel_28)); }
inline ParallelAction_t3477057985 * get_m_SolverForcesDel_28() const { return ___m_SolverForcesDel_28; }
inline ParallelAction_t3477057985 ** get_address_of_m_SolverForcesDel_28() { return &___m_SolverForcesDel_28; }
inline void set_m_SolverForcesDel_28(ParallelAction_t3477057985 * value)
{
___m_SolverForcesDel_28 = value;
Il2CppCodeGenWriteBarrier((&___m_SolverForcesDel_28), value);
}
inline static int32_t get_offset_of_m_SolverBoundaryForcesDel_29() { return static_cast<int32_t>(offsetof(FluidSolver_t3145627998, ___m_SolverBoundaryForcesDel_29)); }
inline ParallelAction_t3477057985 * get_m_SolverBoundaryForcesDel_29() const { return ___m_SolverBoundaryForcesDel_29; }
inline ParallelAction_t3477057985 ** get_address_of_m_SolverBoundaryForcesDel_29() { return &___m_SolverBoundaryForcesDel_29; }
inline void set_m_SolverBoundaryForcesDel_29(ParallelAction_t3477057985 * value)
{
___m_SolverBoundaryForcesDel_29 = value;
Il2CppCodeGenWriteBarrier((&___m_SolverBoundaryForcesDel_29), value);
}
inline static int32_t get_offset_of_m_SolverTurbulenceDel_30() { return static_cast<int32_t>(offsetof(FluidSolver_t3145627998, ___m_SolverTurbulenceDel_30)); }
inline ParallelAction_t3477057985 * get_m_SolverTurbulenceDel_30() const { return ___m_SolverTurbulenceDel_30; }
inline ParallelAction_t3477057985 ** get_address_of_m_SolverTurbulenceDel_30() { return &___m_SolverTurbulenceDel_30; }
inline void set_m_SolverTurbulenceDel_30(ParallelAction_t3477057985 * value)
{
___m_SolverTurbulenceDel_30 = value;
Il2CppCodeGenWriteBarrier((&___m_SolverTurbulenceDel_30), value);
}
inline static int32_t get_offset_of_m_SolverExternalForcesDel_31() { return static_cast<int32_t>(offsetof(FluidSolver_t3145627998, ___m_SolverExternalForcesDel_31)); }
inline ParallelAction_t3477057985 * get_m_SolverExternalForcesDel_31() const { return ___m_SolverExternalForcesDel_31; }
inline ParallelAction_t3477057985 ** get_address_of_m_SolverExternalForcesDel_31() { return &___m_SolverExternalForcesDel_31; }
inline void set_m_SolverExternalForcesDel_31(ParallelAction_t3477057985 * value)
{
___m_SolverExternalForcesDel_31 = value;
Il2CppCodeGenWriteBarrier((&___m_SolverExternalForcesDel_31), value);
}
inline static int32_t get_offset_of_m_SolverConstraintsDel_32() { return static_cast<int32_t>(offsetof(FluidSolver_t3145627998, ___m_SolverConstraintsDel_32)); }
inline ParallelAction_t3477057985 * get_m_SolverConstraintsDel_32() const { return ___m_SolverConstraintsDel_32; }
inline ParallelAction_t3477057985 ** get_address_of_m_SolverConstraintsDel_32() { return &___m_SolverConstraintsDel_32; }
inline void set_m_SolverConstraintsDel_32(ParallelAction_t3477057985 * value)
{
___m_SolverConstraintsDel_32 = value;
Il2CppCodeGenWriteBarrier((&___m_SolverConstraintsDel_32), value);
}
inline static int32_t get_offset_of_m_DoForEachParticleDynamicDel_33() { return static_cast<int32_t>(offsetof(FluidSolver_t3145627998, ___m_DoForEachParticleDynamicDel_33)); }
inline ParallelAction_t3477057985 * get_m_DoForEachParticleDynamicDel_33() const { return ___m_DoForEachParticleDynamicDel_33; }
inline ParallelAction_t3477057985 ** get_address_of_m_DoForEachParticleDynamicDel_33() { return &___m_DoForEachParticleDynamicDel_33; }
inline void set_m_DoForEachParticleDynamicDel_33(ParallelAction_t3477057985 * value)
{
___m_DoForEachParticleDynamicDel_33 = value;
Il2CppCodeGenWriteBarrier((&___m_DoForEachParticleDynamicDel_33), value);
}
inline static int32_t get_offset_of_m_DoForEachParticleDel_34() { return static_cast<int32_t>(offsetof(FluidSolver_t3145627998, ___m_DoForEachParticleDel_34)); }
inline ParallelAction_t3477057985 * get_m_DoForEachParticleDel_34() const { return ___m_DoForEachParticleDel_34; }
inline ParallelAction_t3477057985 ** get_address_of_m_DoForEachParticleDel_34() { return &___m_DoForEachParticleDel_34; }
inline void set_m_DoForEachParticleDel_34(ParallelAction_t3477057985 * value)
{
___m_DoForEachParticleDel_34 = value;
Il2CppCodeGenWriteBarrier((&___m_DoForEachParticleDel_34), value);
}
inline static int32_t get_offset_of_m_DoForEachParticleAllDel_35() { return static_cast<int32_t>(offsetof(FluidSolver_t3145627998, ___m_DoForEachParticleAllDel_35)); }
inline ParallelAction_t3477057985 * get_m_DoForEachParticleAllDel_35() const { return ___m_DoForEachParticleAllDel_35; }
inline ParallelAction_t3477057985 ** get_address_of_m_DoForEachParticleAllDel_35() { return &___m_DoForEachParticleAllDel_35; }
inline void set_m_DoForEachParticleAllDel_35(ParallelAction_t3477057985 * value)
{
___m_DoForEachParticleAllDel_35 = value;
Il2CppCodeGenWriteBarrier((&___m_DoForEachParticleAllDel_35), value);
}
inline static int32_t get_offset_of_m_DoForEachParticleBoundaryDel_36() { return static_cast<int32_t>(offsetof(FluidSolver_t3145627998, ___m_DoForEachParticleBoundaryDel_36)); }
inline ParallelAction_t3477057985 * get_m_DoForEachParticleBoundaryDel_36() const { return ___m_DoForEachParticleBoundaryDel_36; }
inline ParallelAction_t3477057985 ** get_address_of_m_DoForEachParticleBoundaryDel_36() { return &___m_DoForEachParticleBoundaryDel_36; }
inline void set_m_DoForEachParticleBoundaryDel_36(ParallelAction_t3477057985 * value)
{
___m_DoForEachParticleBoundaryDel_36 = value;
Il2CppCodeGenWriteBarrier((&___m_DoForEachParticleBoundaryDel_36), value);
}
inline static int32_t get_offset_of_m_DoForEachParticlePairDel_37() { return static_cast<int32_t>(offsetof(FluidSolver_t3145627998, ___m_DoForEachParticlePairDel_37)); }
inline ParallelAction_t3477057985 * get_m_DoForEachParticlePairDel_37() const { return ___m_DoForEachParticlePairDel_37; }
inline ParallelAction_t3477057985 ** get_address_of_m_DoForEachParticlePairDel_37() { return &___m_DoForEachParticlePairDel_37; }
inline void set_m_DoForEachParticlePairDel_37(ParallelAction_t3477057985 * value)
{
___m_DoForEachParticlePairDel_37 = value;
Il2CppCodeGenWriteBarrier((&___m_DoForEachParticlePairDel_37), value);
}
inline static int32_t get_offset_of_m_CurrentParticleDel_38() { return static_cast<int32_t>(offsetof(FluidSolver_t3145627998, ___m_CurrentParticleDel_38)); }
inline SolverParticleDelegate_t4224278369 * get_m_CurrentParticleDel_38() const { return ___m_CurrentParticleDel_38; }
inline SolverParticleDelegate_t4224278369 ** get_address_of_m_CurrentParticleDel_38() { return &___m_CurrentParticleDel_38; }
inline void set_m_CurrentParticleDel_38(SolverParticleDelegate_t4224278369 * value)
{
___m_CurrentParticleDel_38 = value;
Il2CppCodeGenWriteBarrier((&___m_CurrentParticleDel_38), value);
}
inline static int32_t get_offset_of_m_CurrentParticlePairDel_39() { return static_cast<int32_t>(offsetof(FluidSolver_t3145627998, ___m_CurrentParticlePairDel_39)); }
inline SolverParticlePairDelegate_t2332887997 * get_m_CurrentParticlePairDel_39() const { return ___m_CurrentParticlePairDel_39; }
inline SolverParticlePairDelegate_t2332887997 ** get_address_of_m_CurrentParticlePairDel_39() { return &___m_CurrentParticlePairDel_39; }
inline void set_m_CurrentParticlePairDel_39(SolverParticlePairDelegate_t2332887997 * value)
{
___m_CurrentParticlePairDel_39 = value;
Il2CppCodeGenWriteBarrier((&___m_CurrentParticlePairDel_39), value);
}
inline static int32_t get_offset_of_m_ComputeShouldSync_40() { return static_cast<int32_t>(offsetof(FluidSolver_t3145627998, ___m_ComputeShouldSync_40)); }
inline bool get_m_ComputeShouldSync_40() const { return ___m_ComputeShouldSync_40; }
inline bool* get_address_of_m_ComputeShouldSync_40() { return &___m_ComputeShouldSync_40; }
inline void set_m_ComputeShouldSync_40(bool value)
{
___m_ComputeShouldSync_40 = value;
}
inline static int32_t get_offset_of_fluvio_41() { return static_cast<int32_t>(offsetof(FluidSolver_t3145627998, ___fluvio_41)); }
inline SolverDataInternal_t3200118405 * get_fluvio_41() const { return ___fluvio_41; }
inline SolverDataInternal_t3200118405 ** get_address_of_fluvio_41() { return &___fluvio_41; }
inline void set_fluvio_41(SolverDataInternal_t3200118405 * value)
{
___fluvio_41 = value;
Il2CppCodeGenWriteBarrier((&___fluvio_41), value);
}
inline static int32_t get_offset_of_m_SolverTimer_42() { return static_cast<int32_t>(offsetof(FluidSolver_t3145627998, ___m_SolverTimer_42)); }
inline int32_t get_m_SolverTimer_42() const { return ___m_SolverTimer_42; }
inline int32_t* get_address_of_m_SolverTimer_42() { return &___m_SolverTimer_42; }
inline void set_m_SolverTimer_42(int32_t value)
{
___m_SolverTimer_42 = value;
}
inline static int32_t get_offset_of_m_PluginsTimer_43() { return static_cast<int32_t>(offsetof(FluidSolver_t3145627998, ___m_PluginsTimer_43)); }
inline int32_t get_m_PluginsTimer_43() const { return ___m_PluginsTimer_43; }
inline int32_t* get_address_of_m_PluginsTimer_43() { return &___m_PluginsTimer_43; }
inline void set_m_PluginsTimer_43(int32_t value)
{
___m_PluginsTimer_43 = value;
}
inline static int32_t get_offset_of_m_IsMobilePlatform_44() { return static_cast<int32_t>(offsetof(FluidSolver_t3145627998, ___m_IsMobilePlatform_44)); }
inline bool get_m_IsMobilePlatform_44() const { return ___m_IsMobilePlatform_44; }
inline bool* get_address_of_m_IsMobilePlatform_44() { return &___m_IsMobilePlatform_44; }
inline void set_m_IsMobilePlatform_44(bool value)
{
___m_IsMobilePlatform_44 = value;
}
inline static int32_t get_offset_of_U3CcanUseFastIntegrationPathU3Ek__BackingField_46() { return static_cast<int32_t>(offsetof(FluidSolver_t3145627998, ___U3CcanUseFastIntegrationPathU3Ek__BackingField_46)); }
inline bool get_U3CcanUseFastIntegrationPathU3Ek__BackingField_46() const { return ___U3CcanUseFastIntegrationPathU3Ek__BackingField_46; }
inline bool* get_address_of_U3CcanUseFastIntegrationPathU3Ek__BackingField_46() { return &___U3CcanUseFastIntegrationPathU3Ek__BackingField_46; }
inline void set_U3CcanUseFastIntegrationPathU3Ek__BackingField_46(bool value)
{
___U3CcanUseFastIntegrationPathU3Ek__BackingField_46 = value;
}
};
struct FluidSolver_t3145627998_StaticFields
{
public:
// System.Action`1<Thinksquirrel.Fluvio.Internal.Solvers.FluidSolver> Thinksquirrel.Fluvio.Internal.Solvers.FluidSolver::_onPostSolve
Action_1_t3318095593 * ____onPostSolve_45;
// System.Comparison`1<Thinksquirrel.Fluvio.FluidBase> Thinksquirrel.Fluvio.Internal.Solvers.FluidSolver::<>f__am$cache2F
Comparison_1_t2217002646 * ___U3CU3Ef__amU24cache2F_47;
public:
inline static int32_t get_offset_of__onPostSolve_45() { return static_cast<int32_t>(offsetof(FluidSolver_t3145627998_StaticFields, ____onPostSolve_45)); }
inline Action_1_t3318095593 * get__onPostSolve_45() const { return ____onPostSolve_45; }
inline Action_1_t3318095593 ** get_address_of__onPostSolve_45() { return &____onPostSolve_45; }
inline void set__onPostSolve_45(Action_1_t3318095593 * value)
{
____onPostSolve_45 = value;
Il2CppCodeGenWriteBarrier((&____onPostSolve_45), value);
}
inline static int32_t get_offset_of_U3CU3Ef__amU24cache2F_47() { return static_cast<int32_t>(offsetof(FluidSolver_t3145627998_StaticFields, ___U3CU3Ef__amU24cache2F_47)); }
inline Comparison_1_t2217002646 * get_U3CU3Ef__amU24cache2F_47() const { return ___U3CU3Ef__amU24cache2F_47; }
inline Comparison_1_t2217002646 ** get_address_of_U3CU3Ef__amU24cache2F_47() { return &___U3CU3Ef__amU24cache2F_47; }
inline void set_U3CU3Ef__amU24cache2F_47(Comparison_1_t2217002646 * value)
{
___U3CU3Ef__amU24cache2F_47 = value;
Il2CppCodeGenWriteBarrier((&___U3CU3Ef__amU24cache2F_47), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // FLUIDSOLVER_T3145627998_H
#ifndef AVALIDATABLEVIDEOBACKGROUNDCONFIGPROPERTY_T1108088413_H
#define AVALIDATABLEVIDEOBACKGROUNDCONFIGPROPERTY_T1108088413_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// Vuforia.AValidatableVideoBackgroundConfigProperty
struct AValidatableVideoBackgroundConfigProperty_t1108088413 : public RuntimeObject
{
public:
// Vuforia.VuforiaConfiguration/VideoBackgroundConfiguration Vuforia.AValidatableVideoBackgroundConfigProperty::Config
VideoBackgroundConfiguration_t3392414655 * ___Config_0;
// Vuforia.VideoBackgroundDefaultProvider Vuforia.AValidatableVideoBackgroundConfigProperty::DefaultProvider
VideoBackgroundDefaultProvider_t2109766439 * ___DefaultProvider_1;
public:
inline static int32_t get_offset_of_Config_0() { return static_cast<int32_t>(offsetof(AValidatableVideoBackgroundConfigProperty_t1108088413, ___Config_0)); }
inline VideoBackgroundConfiguration_t3392414655 * get_Config_0() const { return ___Config_0; }
inline VideoBackgroundConfiguration_t3392414655 ** get_address_of_Config_0() { return &___Config_0; }
inline void set_Config_0(VideoBackgroundConfiguration_t3392414655 * value)
{
___Config_0 = value;
Il2CppCodeGenWriteBarrier((&___Config_0), value);
}
inline static int32_t get_offset_of_DefaultProvider_1() { return static_cast<int32_t>(offsetof(AValidatableVideoBackgroundConfigProperty_t1108088413, ___DefaultProvider_1)); }
inline VideoBackgroundDefaultProvider_t2109766439 * get_DefaultProvider_1() const { return ___DefaultProvider_1; }
inline VideoBackgroundDefaultProvider_t2109766439 ** get_address_of_DefaultProvider_1() { return &___DefaultProvider_1; }
inline void set_DefaultProvider_1(VideoBackgroundDefaultProvider_t2109766439 * value)
{
___DefaultProvider_1 = value;
Il2CppCodeGenWriteBarrier((&___DefaultProvider_1), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // AVALIDATABLEVIDEOBACKGROUNDCONFIGPROPERTY_T1108088413_H
#ifndef TRACKABLEIMPL_T3595316917_H
#define TRACKABLEIMPL_T3595316917_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// Vuforia.TrackableImpl
struct TrackableImpl_t3595316917 : public RuntimeObject
{
public:
// System.String Vuforia.TrackableImpl::<Name>k__BackingField
String_t* ___U3CNameU3Ek__BackingField_0;
// System.Int32 Vuforia.TrackableImpl::<ID>k__BackingField
int32_t ___U3CIDU3Ek__BackingField_1;
public:
inline static int32_t get_offset_of_U3CNameU3Ek__BackingField_0() { return static_cast<int32_t>(offsetof(TrackableImpl_t3595316917, ___U3CNameU3Ek__BackingField_0)); }
inline String_t* get_U3CNameU3Ek__BackingField_0() const { return ___U3CNameU3Ek__BackingField_0; }
inline String_t** get_address_of_U3CNameU3Ek__BackingField_0() { return &___U3CNameU3Ek__BackingField_0; }
inline void set_U3CNameU3Ek__BackingField_0(String_t* value)
{
___U3CNameU3Ek__BackingField_0 = value;
Il2CppCodeGenWriteBarrier((&___U3CNameU3Ek__BackingField_0), value);
}
inline static int32_t get_offset_of_U3CIDU3Ek__BackingField_1() { return static_cast<int32_t>(offsetof(TrackableImpl_t3595316917, ___U3CIDU3Ek__BackingField_1)); }
inline int32_t get_U3CIDU3Ek__BackingField_1() const { return ___U3CIDU3Ek__BackingField_1; }
inline int32_t* get_address_of_U3CIDU3Ek__BackingField_1() { return &___U3CIDU3Ek__BackingField_1; }
inline void set_U3CIDU3Ek__BackingField_1(int32_t value)
{
___U3CIDU3Ek__BackingField_1 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // TRACKABLEIMPL_T3595316917_H
#ifndef VIDEOBACKGROUNDCONFIGVALIDATOR_T1958892045_H
#define VIDEOBACKGROUNDCONFIGVALIDATOR_T1958892045_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// Vuforia.VideoBackgroundConfigValidator
struct VideoBackgroundConfigValidator_t1958892045 : public RuntimeObject
{
public:
// System.Collections.Generic.List`1<Vuforia.AValidatableVideoBackgroundConfigProperty> Vuforia.VideoBackgroundConfigValidator::mValidatableProperties
List_1_t2580163155 * ___mValidatableProperties_0;
public:
inline static int32_t get_offset_of_mValidatableProperties_0() { return static_cast<int32_t>(offsetof(VideoBackgroundConfigValidator_t1958892045, ___mValidatableProperties_0)); }
inline List_1_t2580163155 * get_mValidatableProperties_0() const { return ___mValidatableProperties_0; }
inline List_1_t2580163155 ** get_address_of_mValidatableProperties_0() { return &___mValidatableProperties_0; }
inline void set_mValidatableProperties_0(List_1_t2580163155 * value)
{
___mValidatableProperties_0 = value;
Il2CppCodeGenWriteBarrier((&___mValidatableProperties_0), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // VIDEOBACKGROUNDCONFIGVALIDATOR_T1958892045_H
#ifndef U3CSHOWGUIDEVIEWAFTERU3ED__21_T948075969_H
#define U3CSHOWGUIDEVIEWAFTERU3ED__21_T948075969_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// Vuforia.GuideViewRenderingBehaviour/<ShowGuideViewAfter>d__21
struct U3CShowGuideViewAfterU3Ed__21_t948075969 : public RuntimeObject
{
public:
// System.Int32 Vuforia.GuideViewRenderingBehaviour/<ShowGuideViewAfter>d__21::<>1__state
int32_t ___U3CU3E1__state_0;
// System.Object Vuforia.GuideViewRenderingBehaviour/<ShowGuideViewAfter>d__21::<>2__current
RuntimeObject * ___U3CU3E2__current_1;
// System.Single Vuforia.GuideViewRenderingBehaviour/<ShowGuideViewAfter>d__21::seconds
float ___seconds_2;
// Vuforia.GuideViewRenderingBehaviour Vuforia.GuideViewRenderingBehaviour/<ShowGuideViewAfter>d__21::<>4__this
GuideViewRenderingBehaviour_t333084580 * ___U3CU3E4__this_3;
public:
inline static int32_t get_offset_of_U3CU3E1__state_0() { return static_cast<int32_t>(offsetof(U3CShowGuideViewAfterU3Ed__21_t948075969, ___U3CU3E1__state_0)); }
inline int32_t get_U3CU3E1__state_0() const { return ___U3CU3E1__state_0; }
inline int32_t* get_address_of_U3CU3E1__state_0() { return &___U3CU3E1__state_0; }
inline void set_U3CU3E1__state_0(int32_t value)
{
___U3CU3E1__state_0 = value;
}
inline static int32_t get_offset_of_U3CU3E2__current_1() { return static_cast<int32_t>(offsetof(U3CShowGuideViewAfterU3Ed__21_t948075969, ___U3CU3E2__current_1)); }
inline RuntimeObject * get_U3CU3E2__current_1() const { return ___U3CU3E2__current_1; }
inline RuntimeObject ** get_address_of_U3CU3E2__current_1() { return &___U3CU3E2__current_1; }
inline void set_U3CU3E2__current_1(RuntimeObject * value)
{
___U3CU3E2__current_1 = value;
Il2CppCodeGenWriteBarrier((&___U3CU3E2__current_1), value);
}
inline static int32_t get_offset_of_seconds_2() { return static_cast<int32_t>(offsetof(U3CShowGuideViewAfterU3Ed__21_t948075969, ___seconds_2)); }
inline float get_seconds_2() const { return ___seconds_2; }
inline float* get_address_of_seconds_2() { return &___seconds_2; }
inline void set_seconds_2(float value)
{
___seconds_2 = value;
}
inline static int32_t get_offset_of_U3CU3E4__this_3() { return static_cast<int32_t>(offsetof(U3CShowGuideViewAfterU3Ed__21_t948075969, ___U3CU3E4__this_3)); }
inline GuideViewRenderingBehaviour_t333084580 * get_U3CU3E4__this_3() const { return ___U3CU3E4__this_3; }
inline GuideViewRenderingBehaviour_t333084580 ** get_address_of_U3CU3E4__this_3() { return &___U3CU3E4__this_3; }
inline void set_U3CU3E4__this_3(GuideViewRenderingBehaviour_t333084580 * value)
{
___U3CU3E4__this_3 = value;
Il2CppCodeGenWriteBarrier((&___U3CU3E4__this_3), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // U3CSHOWGUIDEVIEWAFTERU3ED__21_T948075969_H
#ifndef PARALLEL_T1515900394_H
#define PARALLEL_T1515900394_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// Thinksquirrel.Fluvio.Internal.Threading.Parallel
struct Parallel_t1515900394 : public RuntimeObject
{
public:
public:
};
struct Parallel_t1515900394_StaticFields
{
public:
// Thinksquirrel.Fluvio.Internal.Threading.FluvioThreadPool Thinksquirrel.Fluvio.Internal.Threading.Parallel::_threadPool
FluvioThreadPool_t2773119480 * ____threadPool_0;
// Thinksquirrel.Fluvio.Internal.Threading.IInterlocked Thinksquirrel.Fluvio.Internal.Threading.Parallel::_interlocked
RuntimeObject* ____interlocked_1;
public:
inline static int32_t get_offset_of__threadPool_0() { return static_cast<int32_t>(offsetof(Parallel_t1515900394_StaticFields, ____threadPool_0)); }
inline FluvioThreadPool_t2773119480 * get__threadPool_0() const { return ____threadPool_0; }
inline FluvioThreadPool_t2773119480 ** get_address_of__threadPool_0() { return &____threadPool_0; }
inline void set__threadPool_0(FluvioThreadPool_t2773119480 * value)
{
____threadPool_0 = value;
Il2CppCodeGenWriteBarrier((&____threadPool_0), value);
}
inline static int32_t get_offset_of__interlocked_1() { return static_cast<int32_t>(offsetof(Parallel_t1515900394_StaticFields, ____interlocked_1)); }
inline RuntimeObject* get__interlocked_1() const { return ____interlocked_1; }
inline RuntimeObject** get_address_of__interlocked_1() { return &____interlocked_1; }
inline void set__interlocked_1(RuntimeObject* value)
{
____interlocked_1 = value;
Il2CppCodeGenWriteBarrier((&____interlocked_1), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // PARALLEL_T1515900394_H
#ifndef VIDEOBACKGROUNDDEFAULTPROVIDER_T2109766439_H
#define VIDEOBACKGROUNDDEFAULTPROVIDER_T2109766439_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// Vuforia.VideoBackgroundDefaultProvider
struct VideoBackgroundDefaultProvider_t2109766439 : public RuntimeObject
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // VIDEOBACKGROUNDDEFAULTPROVIDER_T2109766439_H
#ifndef TRACKER_T2709586299_H
#define TRACKER_T2709586299_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// Vuforia.Tracker
struct Tracker_t2709586299 : public RuntimeObject
{
public:
// System.Boolean Vuforia.Tracker::<IsActive>k__BackingField
bool ___U3CIsActiveU3Ek__BackingField_0;
public:
inline static int32_t get_offset_of_U3CIsActiveU3Ek__BackingField_0() { return static_cast<int32_t>(offsetof(Tracker_t2709586299, ___U3CIsActiveU3Ek__BackingField_0)); }
inline bool get_U3CIsActiveU3Ek__BackingField_0() const { return ___U3CIsActiveU3Ek__BackingField_0; }
inline bool* get_address_of_U3CIsActiveU3Ek__BackingField_0() { return &___U3CIsActiveU3Ek__BackingField_0; }
inline void set_U3CIsActiveU3Ek__BackingField_0(bool value)
{
___U3CIsActiveU3Ek__BackingField_0 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // TRACKER_T2709586299_H
#ifndef U3CU3EC__DISPLAYCLASS2_0_T1369985473_H
#define U3CU3EC__DISPLAYCLASS2_0_T1369985473_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// Vuforia.VideoBackgroundConfigValidator/<>c__DisplayClass2_0
struct U3CU3Ec__DisplayClass2_0_t1369985473 : public RuntimeObject
{
public:
// System.Boolean Vuforia.VideoBackgroundConfigValidator/<>c__DisplayClass2_0::res
bool ___res_0;
public:
inline static int32_t get_offset_of_res_0() { return static_cast<int32_t>(offsetof(U3CU3Ec__DisplayClass2_0_t1369985473, ___res_0)); }
inline bool get_res_0() const { return ___res_0; }
inline bool* get_address_of_res_0() { return &___res_0; }
inline void set_res_0(bool value)
{
___res_0 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // U3CU3EC__DISPLAYCLASS2_0_T1369985473_H
#ifndef FLUVIOTIMESTEP_T3427387132_H
#define FLUVIOTIMESTEP_T3427387132_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// Thinksquirrel.Fluvio.FluvioTimeStep
struct FluvioTimeStep_t3427387132
{
public:
// System.Single Thinksquirrel.Fluvio.FluvioTimeStep::deltaTime
float ___deltaTime_0;
// System.Single Thinksquirrel.Fluvio.FluvioTimeStep::dtIter
float ___dtIter_1;
// System.Single Thinksquirrel.Fluvio.FluvioTimeStep::invDt
float ___invDt_2;
// System.Single Thinksquirrel.Fluvio.FluvioTimeStep::solverIterations
float ___solverIterations_3;
public:
inline static int32_t get_offset_of_deltaTime_0() { return static_cast<int32_t>(offsetof(FluvioTimeStep_t3427387132, ___deltaTime_0)); }
inline float get_deltaTime_0() const { return ___deltaTime_0; }
inline float* get_address_of_deltaTime_0() { return &___deltaTime_0; }
inline void set_deltaTime_0(float value)
{
___deltaTime_0 = value;
}
inline static int32_t get_offset_of_dtIter_1() { return static_cast<int32_t>(offsetof(FluvioTimeStep_t3427387132, ___dtIter_1)); }
inline float get_dtIter_1() const { return ___dtIter_1; }
inline float* get_address_of_dtIter_1() { return &___dtIter_1; }
inline void set_dtIter_1(float value)
{
___dtIter_1 = value;
}
inline static int32_t get_offset_of_invDt_2() { return static_cast<int32_t>(offsetof(FluvioTimeStep_t3427387132, ___invDt_2)); }
inline float get_invDt_2() const { return ___invDt_2; }
inline float* get_address_of_invDt_2() { return &___invDt_2; }
inline void set_invDt_2(float value)
{
___invDt_2 = value;
}
inline static int32_t get_offset_of_solverIterations_3() { return static_cast<int32_t>(offsetof(FluvioTimeStep_t3427387132, ___solverIterations_3)); }
inline float get_solverIterations_3() const { return ___solverIterations_3; }
inline float* get_address_of_solverIterations_3() { return &___solverIterations_3; }
inline void set_solverIterations_3(float value)
{
___solverIterations_3 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // FLUVIOTIMESTEP_T3427387132_H
#ifndef VECTOR2_T2156229523_H
#define VECTOR2_T2156229523_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// UnityEngine.Vector2
struct Vector2_t2156229523
{
public:
// System.Single UnityEngine.Vector2::x
float ___x_0;
// System.Single UnityEngine.Vector2::y
float ___y_1;
public:
inline static int32_t get_offset_of_x_0() { return static_cast<int32_t>(offsetof(Vector2_t2156229523, ___x_0)); }
inline float get_x_0() const { return ___x_0; }
inline float* get_address_of_x_0() { return &___x_0; }
inline void set_x_0(float value)
{
___x_0 = value;
}
inline static int32_t get_offset_of_y_1() { return static_cast<int32_t>(offsetof(Vector2_t2156229523, ___y_1)); }
inline float get_y_1() const { return ___y_1; }
inline float* get_address_of_y_1() { return &___y_1; }
inline void set_y_1(float value)
{
___y_1 = value;
}
};
struct Vector2_t2156229523_StaticFields
{
public:
// UnityEngine.Vector2 UnityEngine.Vector2::zeroVector
Vector2_t2156229523 ___zeroVector_2;
// UnityEngine.Vector2 UnityEngine.Vector2::oneVector
Vector2_t2156229523 ___oneVector_3;
// UnityEngine.Vector2 UnityEngine.Vector2::upVector
Vector2_t2156229523 ___upVector_4;
// UnityEngine.Vector2 UnityEngine.Vector2::downVector
Vector2_t2156229523 ___downVector_5;
// UnityEngine.Vector2 UnityEngine.Vector2::leftVector
Vector2_t2156229523 ___leftVector_6;
// UnityEngine.Vector2 UnityEngine.Vector2::rightVector
Vector2_t2156229523 ___rightVector_7;
// UnityEngine.Vector2 UnityEngine.Vector2::positiveInfinityVector
Vector2_t2156229523 ___positiveInfinityVector_8;
// UnityEngine.Vector2 UnityEngine.Vector2::negativeInfinityVector
Vector2_t2156229523 ___negativeInfinityVector_9;
public:
inline static int32_t get_offset_of_zeroVector_2() { return static_cast<int32_t>(offsetof(Vector2_t2156229523_StaticFields, ___zeroVector_2)); }
inline Vector2_t2156229523 get_zeroVector_2() const { return ___zeroVector_2; }
inline Vector2_t2156229523 * get_address_of_zeroVector_2() { return &___zeroVector_2; }
inline void set_zeroVector_2(Vector2_t2156229523 value)
{
___zeroVector_2 = value;
}
inline static int32_t get_offset_of_oneVector_3() { return static_cast<int32_t>(offsetof(Vector2_t2156229523_StaticFields, ___oneVector_3)); }
inline Vector2_t2156229523 get_oneVector_3() const { return ___oneVector_3; }
inline Vector2_t2156229523 * get_address_of_oneVector_3() { return &___oneVector_3; }
inline void set_oneVector_3(Vector2_t2156229523 value)
{
___oneVector_3 = value;
}
inline static int32_t get_offset_of_upVector_4() { return static_cast<int32_t>(offsetof(Vector2_t2156229523_StaticFields, ___upVector_4)); }
inline Vector2_t2156229523 get_upVector_4() const { return ___upVector_4; }
inline Vector2_t2156229523 * get_address_of_upVector_4() { return &___upVector_4; }
inline void set_upVector_4(Vector2_t2156229523 value)
{
___upVector_4 = value;
}
inline static int32_t get_offset_of_downVector_5() { return static_cast<int32_t>(offsetof(Vector2_t2156229523_StaticFields, ___downVector_5)); }
inline Vector2_t2156229523 get_downVector_5() const { return ___downVector_5; }
inline Vector2_t2156229523 * get_address_of_downVector_5() { return &___downVector_5; }
inline void set_downVector_5(Vector2_t2156229523 value)
{
___downVector_5 = value;
}
inline static int32_t get_offset_of_leftVector_6() { return static_cast<int32_t>(offsetof(Vector2_t2156229523_StaticFields, ___leftVector_6)); }
inline Vector2_t2156229523 get_leftVector_6() const { return ___leftVector_6; }
inline Vector2_t2156229523 * get_address_of_leftVector_6() { return &___leftVector_6; }
inline void set_leftVector_6(Vector2_t2156229523 value)
{
___leftVector_6 = value;
}
inline static int32_t get_offset_of_rightVector_7() { return static_cast<int32_t>(offsetof(Vector2_t2156229523_StaticFields, ___rightVector_7)); }
inline Vector2_t2156229523 get_rightVector_7() const { return ___rightVector_7; }
inline Vector2_t2156229523 * get_address_of_rightVector_7() { return &___rightVector_7; }
inline void set_rightVector_7(Vector2_t2156229523 value)
{
___rightVector_7 = value;
}
inline static int32_t get_offset_of_positiveInfinityVector_8() { return static_cast<int32_t>(offsetof(Vector2_t2156229523_StaticFields, ___positiveInfinityVector_8)); }
inline Vector2_t2156229523 get_positiveInfinityVector_8() const { return ___positiveInfinityVector_8; }
inline Vector2_t2156229523 * get_address_of_positiveInfinityVector_8() { return &___positiveInfinityVector_8; }
inline void set_positiveInfinityVector_8(Vector2_t2156229523 value)
{
___positiveInfinityVector_8 = value;
}
inline static int32_t get_offset_of_negativeInfinityVector_9() { return static_cast<int32_t>(offsetof(Vector2_t2156229523_StaticFields, ___negativeInfinityVector_9)); }
inline Vector2_t2156229523 get_negativeInfinityVector_9() const { return ___negativeInfinityVector_9; }
inline Vector2_t2156229523 * get_address_of_negativeInfinityVector_9() { return &___negativeInfinityVector_9; }
inline void set_negativeInfinityVector_9(Vector2_t2156229523 value)
{
___negativeInfinityVector_9 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // VECTOR2_T2156229523_H
#ifndef VECTOR3_T3722313464_H
#define VECTOR3_T3722313464_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// UnityEngine.Vector3
struct Vector3_t3722313464
{
public:
// System.Single UnityEngine.Vector3::x
float ___x_1;
// System.Single UnityEngine.Vector3::y
float ___y_2;
// System.Single UnityEngine.Vector3::z
float ___z_3;
public:
inline static int32_t get_offset_of_x_1() { return static_cast<int32_t>(offsetof(Vector3_t3722313464, ___x_1)); }
inline float get_x_1() const { return ___x_1; }
inline float* get_address_of_x_1() { return &___x_1; }
inline void set_x_1(float value)
{
___x_1 = value;
}
inline static int32_t get_offset_of_y_2() { return static_cast<int32_t>(offsetof(Vector3_t3722313464, ___y_2)); }
inline float get_y_2() const { return ___y_2; }
inline float* get_address_of_y_2() { return &___y_2; }
inline void set_y_2(float value)
{
___y_2 = value;
}
inline static int32_t get_offset_of_z_3() { return static_cast<int32_t>(offsetof(Vector3_t3722313464, ___z_3)); }
inline float get_z_3() const { return ___z_3; }
inline float* get_address_of_z_3() { return &___z_3; }
inline void set_z_3(float value)
{
___z_3 = value;
}
};
struct Vector3_t3722313464_StaticFields
{
public:
// UnityEngine.Vector3 UnityEngine.Vector3::zeroVector
Vector3_t3722313464 ___zeroVector_4;
// UnityEngine.Vector3 UnityEngine.Vector3::oneVector
Vector3_t3722313464 ___oneVector_5;
// UnityEngine.Vector3 UnityEngine.Vector3::upVector
Vector3_t3722313464 ___upVector_6;
// UnityEngine.Vector3 UnityEngine.Vector3::downVector
Vector3_t3722313464 ___downVector_7;
// UnityEngine.Vector3 UnityEngine.Vector3::leftVector
Vector3_t3722313464 ___leftVector_8;
// UnityEngine.Vector3 UnityEngine.Vector3::rightVector
Vector3_t3722313464 ___rightVector_9;
// UnityEngine.Vector3 UnityEngine.Vector3::forwardVector
Vector3_t3722313464 ___forwardVector_10;
// UnityEngine.Vector3 UnityEngine.Vector3::backVector
Vector3_t3722313464 ___backVector_11;
// UnityEngine.Vector3 UnityEngine.Vector3::positiveInfinityVector
Vector3_t3722313464 ___positiveInfinityVector_12;
// UnityEngine.Vector3 UnityEngine.Vector3::negativeInfinityVector
Vector3_t3722313464 ___negativeInfinityVector_13;
public:
inline static int32_t get_offset_of_zeroVector_4() { return static_cast<int32_t>(offsetof(Vector3_t3722313464_StaticFields, ___zeroVector_4)); }
inline Vector3_t3722313464 get_zeroVector_4() const { return ___zeroVector_4; }
inline Vector3_t3722313464 * get_address_of_zeroVector_4() { return &___zeroVector_4; }
inline void set_zeroVector_4(Vector3_t3722313464 value)
{
___zeroVector_4 = value;
}
inline static int32_t get_offset_of_oneVector_5() { return static_cast<int32_t>(offsetof(Vector3_t3722313464_StaticFields, ___oneVector_5)); }
inline Vector3_t3722313464 get_oneVector_5() const { return ___oneVector_5; }
inline Vector3_t3722313464 * get_address_of_oneVector_5() { return &___oneVector_5; }
inline void set_oneVector_5(Vector3_t3722313464 value)
{
___oneVector_5 = value;
}
inline static int32_t get_offset_of_upVector_6() { return static_cast<int32_t>(offsetof(Vector3_t3722313464_StaticFields, ___upVector_6)); }
inline Vector3_t3722313464 get_upVector_6() const { return ___upVector_6; }
inline Vector3_t3722313464 * get_address_of_upVector_6() { return &___upVector_6; }
inline void set_upVector_6(Vector3_t3722313464 value)
{
___upVector_6 = value;
}
inline static int32_t get_offset_of_downVector_7() { return static_cast<int32_t>(offsetof(Vector3_t3722313464_StaticFields, ___downVector_7)); }
inline Vector3_t3722313464 get_downVector_7() const { return ___downVector_7; }
inline Vector3_t3722313464 * get_address_of_downVector_7() { return &___downVector_7; }
inline void set_downVector_7(Vector3_t3722313464 value)
{
___downVector_7 = value;
}
inline static int32_t get_offset_of_leftVector_8() { return static_cast<int32_t>(offsetof(Vector3_t3722313464_StaticFields, ___leftVector_8)); }
inline Vector3_t3722313464 get_leftVector_8() const { return ___leftVector_8; }
inline Vector3_t3722313464 * get_address_of_leftVector_8() { return &___leftVector_8; }
inline void set_leftVector_8(Vector3_t3722313464 value)
{
___leftVector_8 = value;
}
inline static int32_t get_offset_of_rightVector_9() { return static_cast<int32_t>(offsetof(Vector3_t3722313464_StaticFields, ___rightVector_9)); }
inline Vector3_t3722313464 get_rightVector_9() const { return ___rightVector_9; }
inline Vector3_t3722313464 * get_address_of_rightVector_9() { return &___rightVector_9; }
inline void set_rightVector_9(Vector3_t3722313464 value)
{
___rightVector_9 = value;
}
inline static int32_t get_offset_of_forwardVector_10() { return static_cast<int32_t>(offsetof(Vector3_t3722313464_StaticFields, ___forwardVector_10)); }
inline Vector3_t3722313464 get_forwardVector_10() const { return ___forwardVector_10; }
inline Vector3_t3722313464 * get_address_of_forwardVector_10() { return &___forwardVector_10; }
inline void set_forwardVector_10(Vector3_t3722313464 value)
{
___forwardVector_10 = value;
}
inline static int32_t get_offset_of_backVector_11() { return static_cast<int32_t>(offsetof(Vector3_t3722313464_StaticFields, ___backVector_11)); }
inline Vector3_t3722313464 get_backVector_11() const { return ___backVector_11; }
inline Vector3_t3722313464 * get_address_of_backVector_11() { return &___backVector_11; }
inline void set_backVector_11(Vector3_t3722313464 value)
{
___backVector_11 = value;
}
inline static int32_t get_offset_of_positiveInfinityVector_12() { return static_cast<int32_t>(offsetof(Vector3_t3722313464_StaticFields, ___positiveInfinityVector_12)); }
inline Vector3_t3722313464 get_positiveInfinityVector_12() const { return ___positiveInfinityVector_12; }
inline Vector3_t3722313464 * get_address_of_positiveInfinityVector_12() { return &___positiveInfinityVector_12; }
inline void set_positiveInfinityVector_12(Vector3_t3722313464 value)
{
___positiveInfinityVector_12 = value;
}
inline static int32_t get_offset_of_negativeInfinityVector_13() { return static_cast<int32_t>(offsetof(Vector3_t3722313464_StaticFields, ___negativeInfinityVector_13)); }
inline Vector3_t3722313464 get_negativeInfinityVector_13() const { return ___negativeInfinityVector_13; }
inline Vector3_t3722313464 * get_address_of_negativeInfinityVector_13() { return &___negativeInfinityVector_13; }
inline void set_negativeInfinityVector_13(Vector3_t3722313464 value)
{
___negativeInfinityVector_13 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // VECTOR3_T3722313464_H
#ifndef MATTESHADERPROPERTY_T20537457_H
#define MATTESHADERPROPERTY_T20537457_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// Vuforia.MatteShaderProperty
struct MatteShaderProperty_t20537457 : public AValidatableVideoBackgroundConfigProperty_t1108088413
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // MATTESHADERPROPERTY_T20537457_H
#ifndef INT32_T2950945753_H
#define INT32_T2950945753_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Int32
struct Int32_t2950945753
{
public:
// System.Int32 System.Int32::m_value
int32_t ___m_value_2;
public:
inline static int32_t get_offset_of_m_value_2() { return static_cast<int32_t>(offsetof(Int32_t2950945753, ___m_value_2)); }
inline int32_t get_m_value_2() const { return ___m_value_2; }
inline int32_t* get_address_of_m_value_2() { return &___m_value_2; }
inline void set_m_value_2(int32_t value)
{
___m_value_2 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // INT32_T2950945753_H
#ifndef VECTOR4_T3319028937_H
#define VECTOR4_T3319028937_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// UnityEngine.Vector4
struct Vector4_t3319028937
{
public:
// System.Single UnityEngine.Vector4::x
float ___x_1;
// System.Single UnityEngine.Vector4::y
float ___y_2;
// System.Single UnityEngine.Vector4::z
float ___z_3;
// System.Single UnityEngine.Vector4::w
float ___w_4;
public:
inline static int32_t get_offset_of_x_1() { return static_cast<int32_t>(offsetof(Vector4_t3319028937, ___x_1)); }
inline float get_x_1() const { return ___x_1; }
inline float* get_address_of_x_1() { return &___x_1; }
inline void set_x_1(float value)
{
___x_1 = value;
}
inline static int32_t get_offset_of_y_2() { return static_cast<int32_t>(offsetof(Vector4_t3319028937, ___y_2)); }
inline float get_y_2() const { return ___y_2; }
inline float* get_address_of_y_2() { return &___y_2; }
inline void set_y_2(float value)
{
___y_2 = value;
}
inline static int32_t get_offset_of_z_3() { return static_cast<int32_t>(offsetof(Vector4_t3319028937, ___z_3)); }
inline float get_z_3() const { return ___z_3; }
inline float* get_address_of_z_3() { return &___z_3; }
inline void set_z_3(float value)
{
___z_3 = value;
}
inline static int32_t get_offset_of_w_4() { return static_cast<int32_t>(offsetof(Vector4_t3319028937, ___w_4)); }
inline float get_w_4() const { return ___w_4; }
inline float* get_address_of_w_4() { return &___w_4; }
inline void set_w_4(float value)
{
___w_4 = value;
}
};
struct Vector4_t3319028937_StaticFields
{
public:
// UnityEngine.Vector4 UnityEngine.Vector4::zeroVector
Vector4_t3319028937 ___zeroVector_5;
// UnityEngine.Vector4 UnityEngine.Vector4::oneVector
Vector4_t3319028937 ___oneVector_6;
// UnityEngine.Vector4 UnityEngine.Vector4::positiveInfinityVector
Vector4_t3319028937 ___positiveInfinityVector_7;
// UnityEngine.Vector4 UnityEngine.Vector4::negativeInfinityVector
Vector4_t3319028937 ___negativeInfinityVector_8;
public:
inline static int32_t get_offset_of_zeroVector_5() { return static_cast<int32_t>(offsetof(Vector4_t3319028937_StaticFields, ___zeroVector_5)); }
inline Vector4_t3319028937 get_zeroVector_5() const { return ___zeroVector_5; }
inline Vector4_t3319028937 * get_address_of_zeroVector_5() { return &___zeroVector_5; }
inline void set_zeroVector_5(Vector4_t3319028937 value)
{
___zeroVector_5 = value;
}
inline static int32_t get_offset_of_oneVector_6() { return static_cast<int32_t>(offsetof(Vector4_t3319028937_StaticFields, ___oneVector_6)); }
inline Vector4_t3319028937 get_oneVector_6() const { return ___oneVector_6; }
inline Vector4_t3319028937 * get_address_of_oneVector_6() { return &___oneVector_6; }
inline void set_oneVector_6(Vector4_t3319028937 value)
{
___oneVector_6 = value;
}
inline static int32_t get_offset_of_positiveInfinityVector_7() { return static_cast<int32_t>(offsetof(Vector4_t3319028937_StaticFields, ___positiveInfinityVector_7)); }
inline Vector4_t3319028937 get_positiveInfinityVector_7() const { return ___positiveInfinityVector_7; }
inline Vector4_t3319028937 * get_address_of_positiveInfinityVector_7() { return &___positiveInfinityVector_7; }
inline void set_positiveInfinityVector_7(Vector4_t3319028937 value)
{
___positiveInfinityVector_7 = value;
}
inline static int32_t get_offset_of_negativeInfinityVector_8() { return static_cast<int32_t>(offsetof(Vector4_t3319028937_StaticFields, ___negativeInfinityVector_8)); }
inline Vector4_t3319028937 get_negativeInfinityVector_8() const { return ___negativeInfinityVector_8; }
inline Vector4_t3319028937 * get_address_of_negativeInfinityVector_8() { return &___negativeInfinityVector_8; }
inline void set_negativeInfinityVector_8(Vector4_t3319028937 value)
{
___negativeInfinityVector_8 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // VECTOR4_T3319028937_H
#ifndef EYEWEARDEVICE_T3223385723_H
#define EYEWEARDEVICE_T3223385723_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// Vuforia.EyewearDevice
struct EyewearDevice_t3223385723 : public Device_t64880687
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // EYEWEARDEVICE_T3223385723_H
#ifndef VIDEOBACKGROUNDSHADERPROPERTY_T2141633175_H
#define VIDEOBACKGROUNDSHADERPROPERTY_T2141633175_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// Vuforia.VideoBackgroundShaderProperty
struct VideoBackgroundShaderProperty_t2141633175 : public AValidatableVideoBackgroundConfigProperty_t1108088413
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // VIDEOBACKGROUNDSHADERPROPERTY_T2141633175_H
#ifndef NUMDIVISIONSPROPERTY_T690697662_H
#define NUMDIVISIONSPROPERTY_T690697662_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// Vuforia.NumDivisionsProperty
struct NumDivisionsProperty_t690697662 : public AValidatableVideoBackgroundConfigProperty_t1108088413
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // NUMDIVISIONSPROPERTY_T690697662_H
#ifndef ILLUMINATIONDATA_T3332404395_H
#define ILLUMINATIONDATA_T3332404395_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// Vuforia.TrackerData/IlluminationData
#pragma pack(push, tp, 1)
struct IlluminationData_t3332404395
{
public:
// System.Single Vuforia.TrackerData/IlluminationData::ambientIntensity
float ___ambientIntensity_0;
// System.Single Vuforia.TrackerData/IlluminationData::ambientColorTemperature
float ___ambientColorTemperature_1;
public:
inline static int32_t get_offset_of_ambientIntensity_0() { return static_cast<int32_t>(offsetof(IlluminationData_t3332404395, ___ambientIntensity_0)); }
inline float get_ambientIntensity_0() const { return ___ambientIntensity_0; }
inline float* get_address_of_ambientIntensity_0() { return &___ambientIntensity_0; }
inline void set_ambientIntensity_0(float value)
{
___ambientIntensity_0 = value;
}
inline static int32_t get_offset_of_ambientColorTemperature_1() { return static_cast<int32_t>(offsetof(IlluminationData_t3332404395, ___ambientColorTemperature_1)); }
inline float get_ambientColorTemperature_1() const { return ___ambientColorTemperature_1; }
inline float* get_address_of_ambientColorTemperature_1() { return &___ambientColorTemperature_1; }
inline void set_ambientColorTemperature_1(float value)
{
___ambientColorTemperature_1 = value;
}
};
#pragma pack(pop, tp)
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // ILLUMINATIONDATA_T3332404395_H
#ifndef DEVICETRACKER_T2315692373_H
#define DEVICETRACKER_T2315692373_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// Vuforia.DeviceTracker
struct DeviceTracker_t2315692373 : public Tracker_t2709586299
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // DEVICETRACKER_T2315692373_H
#ifndef INTPTR_T_H
#define INTPTR_T_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// 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;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // INTPTR_T_H
#ifndef SPIKYKERNEL_T887830178_H
#define SPIKYKERNEL_T887830178_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// Thinksquirrel.Fluvio.Internal.Solvers.SpikyKernel
struct SpikyKernel_t887830178 : public SmoothingKernel_t2173549093
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // SPIKYKERNEL_T887830178_H
#ifndef VISCOSITYKERNEL_T39108085_H
#define VISCOSITYKERNEL_T39108085_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// Thinksquirrel.Fluvio.Internal.Solvers.ViscosityKernel
struct ViscosityKernel_t39108085 : public SmoothingKernel_t2173549093
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // VISCOSITYKERNEL_T39108085_H
#ifndef TASK_T450454083_H
#define TASK_T450454083_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// Thinksquirrel.Fluvio.Internal.Threading.FluvioThreadPool/Task
struct Task_t450454083
{
public:
// System.Int32 Thinksquirrel.Fluvio.Internal.Threading.FluvioThreadPool/Task::StartIndex
int32_t ___StartIndex_0;
// System.Int32 Thinksquirrel.Fluvio.Internal.Threading.FluvioThreadPool/Task::EndIndex
int32_t ___EndIndex_1;
// Thinksquirrel.Fluvio.Internal.Threading.ParallelAction Thinksquirrel.Fluvio.Internal.Threading.FluvioThreadPool/Task::action
ParallelAction_t3477057985 * ___action_2;
public:
inline static int32_t get_offset_of_StartIndex_0() { return static_cast<int32_t>(offsetof(Task_t450454083, ___StartIndex_0)); }
inline int32_t get_StartIndex_0() const { return ___StartIndex_0; }
inline int32_t* get_address_of_StartIndex_0() { return &___StartIndex_0; }
inline void set_StartIndex_0(int32_t value)
{
___StartIndex_0 = value;
}
inline static int32_t get_offset_of_EndIndex_1() { return static_cast<int32_t>(offsetof(Task_t450454083, ___EndIndex_1)); }
inline int32_t get_EndIndex_1() const { return ___EndIndex_1; }
inline int32_t* get_address_of_EndIndex_1() { return &___EndIndex_1; }
inline void set_EndIndex_1(int32_t value)
{
___EndIndex_1 = value;
}
inline static int32_t get_offset_of_action_2() { return static_cast<int32_t>(offsetof(Task_t450454083, ___action_2)); }
inline ParallelAction_t3477057985 * get_action_2() const { return ___action_2; }
inline ParallelAction_t3477057985 ** get_address_of_action_2() { return &___action_2; }
inline void set_action_2(ParallelAction_t3477057985 * value)
{
___action_2 = value;
Il2CppCodeGenWriteBarrier((&___action_2), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
// Native definition for P/Invoke marshalling of Thinksquirrel.Fluvio.Internal.Threading.FluvioThreadPool/Task
struct Task_t450454083_marshaled_pinvoke
{
int32_t ___StartIndex_0;
int32_t ___EndIndex_1;
Il2CppMethodPointer ___action_2;
};
// Native definition for COM marshalling of Thinksquirrel.Fluvio.Internal.Threading.FluvioThreadPool/Task
struct Task_t450454083_marshaled_com
{
int32_t ___StartIndex_0;
int32_t ___EndIndex_1;
Il2CppMethodPointer ___action_2;
};
#endif // TASK_T450454083_H
#ifndef POLY6KERNEL_T3858493335_H
#define POLY6KERNEL_T3858493335_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// Thinksquirrel.Fluvio.Internal.Solvers.Poly6Kernel
struct Poly6Kernel_t3858493335 : public SmoothingKernel_t2173549093
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // POLY6KERNEL_T3858493335_H
#ifndef ENUM_T4135868527_H
#define ENUM_T4135868527_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Enum
struct Enum_t4135868527 : public ValueType_t3640485471
{
public:
public:
};
struct Enum_t4135868527_StaticFields
{
public:
// System.Char[] System.Enum::split_char
CharU5BU5D_t3528271667* ___split_char_0;
public:
inline static int32_t get_offset_of_split_char_0() { return static_cast<int32_t>(offsetof(Enum_t4135868527_StaticFields, ___split_char_0)); }
inline CharU5BU5D_t3528271667* get_split_char_0() const { return ___split_char_0; }
inline CharU5BU5D_t3528271667** get_address_of_split_char_0() { return &___split_char_0; }
inline void set_split_char_0(CharU5BU5D_t3528271667* value)
{
___split_char_0 = value;
Il2CppCodeGenWriteBarrier((&___split_char_0), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
// Native definition for P/Invoke marshalling of System.Enum
struct Enum_t4135868527_marshaled_pinvoke
{
};
// Native definition for COM marshalling of System.Enum
struct Enum_t4135868527_marshaled_com
{
};
#endif // ENUM_T4135868527_H
#ifndef OBJECTTARGETIMPL_T3614635090_H
#define OBJECTTARGETIMPL_T3614635090_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// Vuforia.ObjectTargetImpl
struct ObjectTargetImpl_t3614635090 : public TrackableImpl_t3595316917
{
public:
// Vuforia.IExtendedTracking Vuforia.ObjectTargetImpl::mExtTrackingImpl
RuntimeObject* ___mExtTrackingImpl_2;
// Vuforia.ITargetSize Vuforia.ObjectTargetImpl::mTargetSizeImpl
RuntimeObject* ___mTargetSizeImpl_3;
public:
inline static int32_t get_offset_of_mExtTrackingImpl_2() { return static_cast<int32_t>(offsetof(ObjectTargetImpl_t3614635090, ___mExtTrackingImpl_2)); }
inline RuntimeObject* get_mExtTrackingImpl_2() const { return ___mExtTrackingImpl_2; }
inline RuntimeObject** get_address_of_mExtTrackingImpl_2() { return &___mExtTrackingImpl_2; }
inline void set_mExtTrackingImpl_2(RuntimeObject* value)
{
___mExtTrackingImpl_2 = value;
Il2CppCodeGenWriteBarrier((&___mExtTrackingImpl_2), value);
}
inline static int32_t get_offset_of_mTargetSizeImpl_3() { return static_cast<int32_t>(offsetof(ObjectTargetImpl_t3614635090, ___mTargetSizeImpl_3)); }
inline RuntimeObject* get_mTargetSizeImpl_3() const { return ___mTargetSizeImpl_3; }
inline RuntimeObject** get_address_of_mTargetSizeImpl_3() { return &___mTargetSizeImpl_3; }
inline void set_mTargetSizeImpl_3(RuntimeObject* value)
{
___mTargetSizeImpl_3 = value;
Il2CppCodeGenWriteBarrier((&___mTargetSizeImpl_3), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // OBJECTTARGETIMPL_T3614635090_H
#ifndef INT4_T93086280_H
#define INT4_T93086280_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// Thinksquirrel.Fluvio.Internal.Solvers.int4
#pragma pack(push, tp, 1)
struct int4_t93086280
{
public:
// System.Int32 Thinksquirrel.Fluvio.Internal.Solvers.int4::x
int32_t ___x_0;
// System.Int32 Thinksquirrel.Fluvio.Internal.Solvers.int4::y
int32_t ___y_1;
// System.Int32 Thinksquirrel.Fluvio.Internal.Solvers.int4::z
int32_t ___z_2;
// System.Int32 Thinksquirrel.Fluvio.Internal.Solvers.int4::w
int32_t ___w_3;
public:
inline static int32_t get_offset_of_x_0() { return static_cast<int32_t>(offsetof(int4_t93086280, ___x_0)); }
inline int32_t get_x_0() const { return ___x_0; }
inline int32_t* get_address_of_x_0() { return &___x_0; }
inline void set_x_0(int32_t value)
{
___x_0 = value;
}
inline static int32_t get_offset_of_y_1() { return static_cast<int32_t>(offsetof(int4_t93086280, ___y_1)); }
inline int32_t get_y_1() const { return ___y_1; }
inline int32_t* get_address_of_y_1() { return &___y_1; }
inline void set_y_1(int32_t value)
{
___y_1 = value;
}
inline static int32_t get_offset_of_z_2() { return static_cast<int32_t>(offsetof(int4_t93086280, ___z_2)); }
inline int32_t get_z_2() const { return ___z_2; }
inline int32_t* get_address_of_z_2() { return &___z_2; }
inline void set_z_2(int32_t value)
{
___z_2 = value;
}
inline static int32_t get_offset_of_w_3() { return static_cast<int32_t>(offsetof(int4_t93086280, ___w_3)); }
inline int32_t get_w_3() const { return ___w_3; }
inline int32_t* get_address_of_w_3() { return &___w_3; }
inline void set_w_3(int32_t value)
{
___w_3 = value;
}
};
#pragma pack(pop, tp)
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // INT4_T93086280_H
#ifndef RECT_T2360479859_H
#define RECT_T2360479859_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// UnityEngine.Rect
struct Rect_t2360479859
{
public:
// System.Single UnityEngine.Rect::m_XMin
float ___m_XMin_0;
// System.Single UnityEngine.Rect::m_YMin
float ___m_YMin_1;
// System.Single UnityEngine.Rect::m_Width
float ___m_Width_2;
// System.Single UnityEngine.Rect::m_Height
float ___m_Height_3;
public:
inline static int32_t get_offset_of_m_XMin_0() { return static_cast<int32_t>(offsetof(Rect_t2360479859, ___m_XMin_0)); }
inline float get_m_XMin_0() const { return ___m_XMin_0; }
inline float* get_address_of_m_XMin_0() { return &___m_XMin_0; }
inline void set_m_XMin_0(float value)
{
___m_XMin_0 = value;
}
inline static int32_t get_offset_of_m_YMin_1() { return static_cast<int32_t>(offsetof(Rect_t2360479859, ___m_YMin_1)); }
inline float get_m_YMin_1() const { return ___m_YMin_1; }
inline float* get_address_of_m_YMin_1() { return &___m_YMin_1; }
inline void set_m_YMin_1(float value)
{
___m_YMin_1 = value;
}
inline static int32_t get_offset_of_m_Width_2() { return static_cast<int32_t>(offsetof(Rect_t2360479859, ___m_Width_2)); }
inline float get_m_Width_2() const { return ___m_Width_2; }
inline float* get_address_of_m_Width_2() { return &___m_Width_2; }
inline void set_m_Width_2(float value)
{
___m_Width_2 = value;
}
inline static int32_t get_offset_of_m_Height_3() { return static_cast<int32_t>(offsetof(Rect_t2360479859, ___m_Height_3)); }
inline float get_m_Height_3() const { return ___m_Height_3; }
inline float* get_address_of_m_Height_3() { return &___m_Height_3; }
inline void set_m_Height_3(float value)
{
___m_Height_3 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // RECT_T2360479859_H
#ifndef MATRIX4X4_T1817901843_H
#define MATRIX4X4_T1817901843_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// UnityEngine.Matrix4x4
struct Matrix4x4_t1817901843
{
public:
// System.Single UnityEngine.Matrix4x4::m00
float ___m00_0;
// System.Single UnityEngine.Matrix4x4::m10
float ___m10_1;
// System.Single UnityEngine.Matrix4x4::m20
float ___m20_2;
// System.Single UnityEngine.Matrix4x4::m30
float ___m30_3;
// System.Single UnityEngine.Matrix4x4::m01
float ___m01_4;
// System.Single UnityEngine.Matrix4x4::m11
float ___m11_5;
// System.Single UnityEngine.Matrix4x4::m21
float ___m21_6;
// System.Single UnityEngine.Matrix4x4::m31
float ___m31_7;
// System.Single UnityEngine.Matrix4x4::m02
float ___m02_8;
// System.Single UnityEngine.Matrix4x4::m12
float ___m12_9;
// System.Single UnityEngine.Matrix4x4::m22
float ___m22_10;
// System.Single UnityEngine.Matrix4x4::m32
float ___m32_11;
// System.Single UnityEngine.Matrix4x4::m03
float ___m03_12;
// System.Single UnityEngine.Matrix4x4::m13
float ___m13_13;
// System.Single UnityEngine.Matrix4x4::m23
float ___m23_14;
// System.Single UnityEngine.Matrix4x4::m33
float ___m33_15;
public:
inline static int32_t get_offset_of_m00_0() { return static_cast<int32_t>(offsetof(Matrix4x4_t1817901843, ___m00_0)); }
inline float get_m00_0() const { return ___m00_0; }
inline float* get_address_of_m00_0() { return &___m00_0; }
inline void set_m00_0(float value)
{
___m00_0 = value;
}
inline static int32_t get_offset_of_m10_1() { return static_cast<int32_t>(offsetof(Matrix4x4_t1817901843, ___m10_1)); }
inline float get_m10_1() const { return ___m10_1; }
inline float* get_address_of_m10_1() { return &___m10_1; }
inline void set_m10_1(float value)
{
___m10_1 = value;
}
inline static int32_t get_offset_of_m20_2() { return static_cast<int32_t>(offsetof(Matrix4x4_t1817901843, ___m20_2)); }
inline float get_m20_2() const { return ___m20_2; }
inline float* get_address_of_m20_2() { return &___m20_2; }
inline void set_m20_2(float value)
{
___m20_2 = value;
}
inline static int32_t get_offset_of_m30_3() { return static_cast<int32_t>(offsetof(Matrix4x4_t1817901843, ___m30_3)); }
inline float get_m30_3() const { return ___m30_3; }
inline float* get_address_of_m30_3() { return &___m30_3; }
inline void set_m30_3(float value)
{
___m30_3 = value;
}
inline static int32_t get_offset_of_m01_4() { return static_cast<int32_t>(offsetof(Matrix4x4_t1817901843, ___m01_4)); }
inline float get_m01_4() const { return ___m01_4; }
inline float* get_address_of_m01_4() { return &___m01_4; }
inline void set_m01_4(float value)
{
___m01_4 = value;
}
inline static int32_t get_offset_of_m11_5() { return static_cast<int32_t>(offsetof(Matrix4x4_t1817901843, ___m11_5)); }
inline float get_m11_5() const { return ___m11_5; }
inline float* get_address_of_m11_5() { return &___m11_5; }
inline void set_m11_5(float value)
{
___m11_5 = value;
}
inline static int32_t get_offset_of_m21_6() { return static_cast<int32_t>(offsetof(Matrix4x4_t1817901843, ___m21_6)); }
inline float get_m21_6() const { return ___m21_6; }
inline float* get_address_of_m21_6() { return &___m21_6; }
inline void set_m21_6(float value)
{
___m21_6 = value;
}
inline static int32_t get_offset_of_m31_7() { return static_cast<int32_t>(offsetof(Matrix4x4_t1817901843, ___m31_7)); }
inline float get_m31_7() const { return ___m31_7; }
inline float* get_address_of_m31_7() { return &___m31_7; }
inline void set_m31_7(float value)
{
___m31_7 = value;
}
inline static int32_t get_offset_of_m02_8() { return static_cast<int32_t>(offsetof(Matrix4x4_t1817901843, ___m02_8)); }
inline float get_m02_8() const { return ___m02_8; }
inline float* get_address_of_m02_8() { return &___m02_8; }
inline void set_m02_8(float value)
{
___m02_8 = value;
}
inline static int32_t get_offset_of_m12_9() { return static_cast<int32_t>(offsetof(Matrix4x4_t1817901843, ___m12_9)); }
inline float get_m12_9() const { return ___m12_9; }
inline float* get_address_of_m12_9() { return &___m12_9; }
inline void set_m12_9(float value)
{
___m12_9 = value;
}
inline static int32_t get_offset_of_m22_10() { return static_cast<int32_t>(offsetof(Matrix4x4_t1817901843, ___m22_10)); }
inline float get_m22_10() const { return ___m22_10; }
inline float* get_address_of_m22_10() { return &___m22_10; }
inline void set_m22_10(float value)
{
___m22_10 = value;
}
inline static int32_t get_offset_of_m32_11() { return static_cast<int32_t>(offsetof(Matrix4x4_t1817901843, ___m32_11)); }
inline float get_m32_11() const { return ___m32_11; }
inline float* get_address_of_m32_11() { return &___m32_11; }
inline void set_m32_11(float value)
{
___m32_11 = value;
}
inline static int32_t get_offset_of_m03_12() { return static_cast<int32_t>(offsetof(Matrix4x4_t1817901843, ___m03_12)); }
inline float get_m03_12() const { return ___m03_12; }
inline float* get_address_of_m03_12() { return &___m03_12; }
inline void set_m03_12(float value)
{
___m03_12 = value;
}
inline static int32_t get_offset_of_m13_13() { return static_cast<int32_t>(offsetof(Matrix4x4_t1817901843, ___m13_13)); }
inline float get_m13_13() const { return ___m13_13; }
inline float* get_address_of_m13_13() { return &___m13_13; }
inline void set_m13_13(float value)
{
___m13_13 = value;
}
inline static int32_t get_offset_of_m23_14() { return static_cast<int32_t>(offsetof(Matrix4x4_t1817901843, ___m23_14)); }
inline float get_m23_14() const { return ___m23_14; }
inline float* get_address_of_m23_14() { return &___m23_14; }
inline void set_m23_14(float value)
{
___m23_14 = value;
}
inline static int32_t get_offset_of_m33_15() { return static_cast<int32_t>(offsetof(Matrix4x4_t1817901843, ___m33_15)); }
inline float get_m33_15() const { return ___m33_15; }
inline float* get_address_of_m33_15() { return &___m33_15; }
inline void set_m33_15(float value)
{
___m33_15 = value;
}
};
struct Matrix4x4_t1817901843_StaticFields
{
public:
// UnityEngine.Matrix4x4 UnityEngine.Matrix4x4::zeroMatrix
Matrix4x4_t1817901843 ___zeroMatrix_16;
// UnityEngine.Matrix4x4 UnityEngine.Matrix4x4::identityMatrix
Matrix4x4_t1817901843 ___identityMatrix_17;
public:
inline static int32_t get_offset_of_zeroMatrix_16() { return static_cast<int32_t>(offsetof(Matrix4x4_t1817901843_StaticFields, ___zeroMatrix_16)); }
inline Matrix4x4_t1817901843 get_zeroMatrix_16() const { return ___zeroMatrix_16; }
inline Matrix4x4_t1817901843 * get_address_of_zeroMatrix_16() { return &___zeroMatrix_16; }
inline void set_zeroMatrix_16(Matrix4x4_t1817901843 value)
{
___zeroMatrix_16 = value;
}
inline static int32_t get_offset_of_identityMatrix_17() { return static_cast<int32_t>(offsetof(Matrix4x4_t1817901843_StaticFields, ___identityMatrix_17)); }
inline Matrix4x4_t1817901843 get_identityMatrix_17() const { return ___identityMatrix_17; }
inline Matrix4x4_t1817901843 * get_address_of_identityMatrix_17() { return &___identityMatrix_17; }
inline void set_identityMatrix_17(Matrix4x4_t1817901843 value)
{
___identityMatrix_17 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // MATRIX4X4_T1817901843_H
#ifndef VOID_T1185182177_H
#define VOID_T1185182177_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void
struct Void_t1185182177
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // VOID_T1185182177_H
#ifndef CAMERADEVICEMODE_T2478715656_H
#define CAMERADEVICEMODE_T2478715656_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// Vuforia.CameraDevice/CameraDeviceMode
struct CameraDeviceMode_t2478715656
{
public:
// System.Int32 Vuforia.CameraDevice/CameraDeviceMode::value__
int32_t ___value___1;
public:
inline static int32_t get_offset_of_value___1() { return static_cast<int32_t>(offsetof(CameraDeviceMode_t2478715656, ___value___1)); }
inline int32_t get_value___1() const { return ___value___1; }
inline int32_t* get_address_of_value___1() { return &___value___1; }
inline void set_value___1(int32_t value)
{
___value___1 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // CAMERADEVICEMODE_T2478715656_H
#ifndef GUIDEVIEW_T516481509_H
#define GUIDEVIEW_T516481509_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// Vuforia.GuideView
struct GuideView_t516481509 : public RuntimeObject
{
public:
// Vuforia.Image Vuforia.GuideView::<Image>k__BackingField
Image_t745056343 * ___U3CImageU3Ek__BackingField_0;
// System.IntPtr Vuforia.GuideView::mInstancePtr
intptr_t ___mInstancePtr_1;
// UnityEngine.Matrix4x4 Vuforia.GuideView::mPose
Matrix4x4_t1817901843 ___mPose_2;
// System.ComponentModel.PropertyChangedEventHandler Vuforia.GuideView::PropertyChanged
PropertyChangedEventHandler_t3836340606 * ___PropertyChanged_3;
public:
inline static int32_t get_offset_of_U3CImageU3Ek__BackingField_0() { return static_cast<int32_t>(offsetof(GuideView_t516481509, ___U3CImageU3Ek__BackingField_0)); }
inline Image_t745056343 * get_U3CImageU3Ek__BackingField_0() const { return ___U3CImageU3Ek__BackingField_0; }
inline Image_t745056343 ** get_address_of_U3CImageU3Ek__BackingField_0() { return &___U3CImageU3Ek__BackingField_0; }
inline void set_U3CImageU3Ek__BackingField_0(Image_t745056343 * value)
{
___U3CImageU3Ek__BackingField_0 = value;
Il2CppCodeGenWriteBarrier((&___U3CImageU3Ek__BackingField_0), value);
}
inline static int32_t get_offset_of_mInstancePtr_1() { return static_cast<int32_t>(offsetof(GuideView_t516481509, ___mInstancePtr_1)); }
inline intptr_t get_mInstancePtr_1() const { return ___mInstancePtr_1; }
inline intptr_t* get_address_of_mInstancePtr_1() { return &___mInstancePtr_1; }
inline void set_mInstancePtr_1(intptr_t value)
{
___mInstancePtr_1 = value;
}
inline static int32_t get_offset_of_mPose_2() { return static_cast<int32_t>(offsetof(GuideView_t516481509, ___mPose_2)); }
inline Matrix4x4_t1817901843 get_mPose_2() const { return ___mPose_2; }
inline Matrix4x4_t1817901843 * get_address_of_mPose_2() { return &___mPose_2; }
inline void set_mPose_2(Matrix4x4_t1817901843 value)
{
___mPose_2 = value;
}
inline static int32_t get_offset_of_PropertyChanged_3() { return static_cast<int32_t>(offsetof(GuideView_t516481509, ___PropertyChanged_3)); }
inline PropertyChangedEventHandler_t3836340606 * get_PropertyChanged_3() const { return ___PropertyChanged_3; }
inline PropertyChangedEventHandler_t3836340606 ** get_address_of_PropertyChanged_3() { return &___PropertyChanged_3; }
inline void set_PropertyChanged_3(PropertyChangedEventHandler_t3836340606 * value)
{
___PropertyChanged_3 = value;
Il2CppCodeGenWriteBarrier((&___PropertyChanged_3), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // GUIDEVIEW_T516481509_H
#ifndef ALIGNMENTTYPE_T1920855420_H
#define ALIGNMENTTYPE_T1920855420_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// Vuforia.EyewearDevice/EyewearCalibrationReading/AlignmentType
struct AlignmentType_t1920855420
{
public:
// System.Int32 Vuforia.EyewearDevice/EyewearCalibrationReading/AlignmentType::value__
int32_t ___value___1;
public:
inline static int32_t get_offset_of_value___1() { return static_cast<int32_t>(offsetof(AlignmentType_t1920855420, ___value___1)); }
inline int32_t get_value___1() const { return ___value___1; }
inline int32_t* get_address_of_value___1() { return &___value___1; }
inline void set_value___1(int32_t value)
{
___value___1 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // ALIGNMENTTYPE_T1920855420_H
#ifndef EYEID_T263427581_H
#define EYEID_T263427581_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// Vuforia.EyewearDevice/EyeID
struct EyeID_t263427581
{
public:
// System.Int32 Vuforia.EyewearDevice/EyeID::value__
int32_t ___value___1;
public:
inline static int32_t get_offset_of_value___1() { return static_cast<int32_t>(offsetof(EyeID_t263427581, ___value___1)); }
inline int32_t get_value___1() const { return ___value___1; }
inline int32_t* get_address_of_value___1() { return &___value___1; }
inline void set_value___1(int32_t value)
{
___value___1 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // EYEID_T263427581_H
#ifndef VIDEOBACKGROUNDREFLECTION_T736962841_H
#define VIDEOBACKGROUNDREFLECTION_T736962841_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// Vuforia.VuforiaRenderer/VideoBackgroundReflection
struct VideoBackgroundReflection_t736962841
{
public:
// System.Int32 Vuforia.VuforiaRenderer/VideoBackgroundReflection::value__
int32_t ___value___1;
public:
inline static int32_t get_offset_of_value___1() { return static_cast<int32_t>(offsetof(VideoBackgroundReflection_t736962841, ___value___1)); }
inline int32_t get_value___1() const { return ___value___1; }
inline int32_t* get_address_of_value___1() { return &___value___1; }
inline void set_value___1(int32_t value)
{
___value___1 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // VIDEOBACKGROUNDREFLECTION_T736962841_H
#ifndef STATUS_T1100905814_H
#define STATUS_T1100905814_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// Vuforia.TrackableBehaviour/Status
struct Status_t1100905814
{
public:
// System.Int32 Vuforia.TrackableBehaviour/Status::value__
int32_t ___value___1;
public:
inline static int32_t get_offset_of_value___1() { return static_cast<int32_t>(offsetof(Status_t1100905814, ___value___1)); }
inline int32_t get_value___1() const { return ___value___1; }
inline int32_t* get_address_of_value___1() { return &___value___1; }
inline void set_value___1(int32_t value)
{
___value___1 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // STATUS_T1100905814_H
#ifndef FLUIDEFFECTORFORCETYPE_T3117094636_H
#define FLUIDEFFECTORFORCETYPE_T3117094636_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// Thinksquirrel.Fluvio.FluidEffectorForceType
struct FluidEffectorForceType_t3117094636
{
public:
// System.Int32 Thinksquirrel.Fluvio.FluidEffectorForceType::value__
int32_t ___value___1;
public:
inline static int32_t get_offset_of_value___1() { return static_cast<int32_t>(offsetof(FluidEffectorForceType_t3117094636, ___value___1)); }
inline int32_t get_value___1() const { return ___value___1; }
inline int32_t* get_address_of_value___1() { return &___value___1; }
inline void set_value___1(int32_t value)
{
___value___1 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // FLUIDEFFECTORFORCETYPE_T3117094636_H
#ifndef FLUIDEFFECTORDECAYTYPE_T1364242417_H
#define FLUIDEFFECTORDECAYTYPE_T1364242417_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// Thinksquirrel.Fluvio.FluidEffectorDecayType
struct FluidEffectorDecayType_t1364242417
{
public:
// System.Int32 Thinksquirrel.Fluvio.FluidEffectorDecayType::value__
int32_t ___value___1;
public:
inline static int32_t get_offset_of_value___1() { return static_cast<int32_t>(offsetof(FluidEffectorDecayType_t1364242417, ___value___1)); }
inline int32_t get_value___1() const { return ___value___1; }
inline int32_t* get_address_of_value___1() { return &___value___1; }
inline void set_value___1(int32_t value)
{
___value___1 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // FLUIDEFFECTORDECAYTYPE_T1364242417_H
#ifndef COMPUTEAPI_T3251413269_H
#define COMPUTEAPI_T3251413269_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// Thinksquirrel.Fluvio.ComputeAPI
struct ComputeAPI_t3251413269
{
public:
// System.Int32 Thinksquirrel.Fluvio.ComputeAPI::value__
int32_t ___value___1;
public:
inline static int32_t get_offset_of_value___1() { return static_cast<int32_t>(offsetof(ComputeAPI_t3251413269, ___value___1)); }
inline int32_t get_value___1() const { return ___value___1; }
inline int32_t* get_address_of_value___1() { return &___value___1; }
inline void set_value___1(int32_t value)
{
___value___1 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // COMPUTEAPI_T3251413269_H
#ifndef SCREENORIENTATION_T1705519499_H
#define SCREENORIENTATION_T1705519499_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// UnityEngine.ScreenOrientation
struct ScreenOrientation_t1705519499
{
public:
// System.Int32 UnityEngine.ScreenOrientation::value__
int32_t ___value___1;
public:
inline static int32_t get_offset_of_value___1() { return static_cast<int32_t>(offsetof(ScreenOrientation_t1705519499, ___value___1)); }
inline int32_t get_value___1() const { return ___value___1; }
inline int32_t* get_address_of_value___1() { return &___value___1; }
inline void set_value___1(int32_t value)
{
___value___1 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // SCREENORIENTATION_T1705519499_H
#ifndef WORLDCENTERMODE_T3672819471_H
#define WORLDCENTERMODE_T3672819471_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// Vuforia.VuforiaARController/WorldCenterMode
struct WorldCenterMode_t3672819471
{
public:
// System.Int32 Vuforia.VuforiaARController/WorldCenterMode::value__
int32_t ___value___1;
public:
inline static int32_t get_offset_of_value___1() { return static_cast<int32_t>(offsetof(WorldCenterMode_t3672819471, ___value___1)); }
inline int32_t get_value___1() const { return ___value___1; }
inline int32_t* get_address_of_value___1() { return &___value___1; }
inline void set_value___1(int32_t value)
{
___value___1 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // WORLDCENTERMODE_T3672819471_H
#ifndef VIEWERBUTTONTYPE_T3221680132_H
#define VIEWERBUTTONTYPE_T3221680132_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// Vuforia.ViewerButtonType
struct ViewerButtonType_t3221680132
{
public:
// System.Int32 Vuforia.ViewerButtonType::value__
int32_t ___value___1;
public:
inline static int32_t get_offset_of_value___1() { return static_cast<int32_t>(offsetof(ViewerButtonType_t3221680132, ___value___1)); }
inline int32_t get_value___1() const { return ___value___1; }
inline int32_t* get_address_of_value___1() { return &___value___1; }
inline void set_value___1(int32_t value)
{
___value___1 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // VIEWERBUTTONTYPE_T3221680132_H
#ifndef VIEWERTRAYALIGNMENT_T2810797062_H
#define VIEWERTRAYALIGNMENT_T2810797062_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// Vuforia.ViewerTrayAlignment
struct ViewerTrayAlignment_t2810797062
{
public:
// System.Int32 Vuforia.ViewerTrayAlignment::value__
int32_t ___value___1;
public:
inline static int32_t get_offset_of_value___1() { return static_cast<int32_t>(offsetof(ViewerTrayAlignment_t2810797062, ___value___1)); }
inline int32_t get_value___1() const { return ___value___1; }
inline int32_t* get_address_of_value___1() { return &___value___1; }
inline void set_value___1(int32_t value)
{
___value___1 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // VIEWERTRAYALIGNMENT_T2810797062_H
#ifndef GUIDEVIEWDISPLAYMODE_T3044577557_H
#define GUIDEVIEWDISPLAYMODE_T3044577557_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// Vuforia.ModelTargetBehaviour/GuideViewDisplayMode
struct GuideViewDisplayMode_t3044577557
{
public:
// System.Int32 Vuforia.ModelTargetBehaviour/GuideViewDisplayMode::value__
int32_t ___value___1;
public:
inline static int32_t get_offset_of_value___1() { return static_cast<int32_t>(offsetof(GuideViewDisplayMode_t3044577557, ___value___1)); }
inline int32_t get_value___1() const { return ___value___1; }
inline int32_t* get_address_of_value___1() { return &___value___1; }
inline void set_value___1(int32_t value)
{
___value___1 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // GUIDEVIEWDISPLAYMODE_T3044577557_H
#ifndef DEPTHTEXTUREMODE_T4161834719_H
#define DEPTHTEXTUREMODE_T4161834719_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// UnityEngine.DepthTextureMode
struct DepthTextureMode_t4161834719
{
public:
// System.Int32 UnityEngine.DepthTextureMode::value__
int32_t ___value___1;
public:
inline static int32_t get_offset_of_value___1() { return static_cast<int32_t>(offsetof(DepthTextureMode_t4161834719, ___value___1)); }
inline int32_t get_value___1() const { return ___value___1; }
inline int32_t* get_address_of_value___1() { return &___value___1; }
inline void set_value___1(int32_t value)
{
___value___1 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // DEPTHTEXTUREMODE_T4161834719_H
#ifndef DATASETOBJECTTARGETIMPL_T2835536742_H
#define DATASETOBJECTTARGETIMPL_T2835536742_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// Vuforia.DataSetObjectTargetImpl
struct DataSetObjectTargetImpl_t2835536742 : public ObjectTargetImpl_t3614635090
{
public:
// Vuforia.DataSet Vuforia.DataSetObjectTargetImpl::mDataSet
DataSet_t3286034874 * ___mDataSet_4;
public:
inline static int32_t get_offset_of_mDataSet_4() { return static_cast<int32_t>(offsetof(DataSetObjectTargetImpl_t2835536742, ___mDataSet_4)); }
inline DataSet_t3286034874 * get_mDataSet_4() const { return ___mDataSet_4; }
inline DataSet_t3286034874 ** get_address_of_mDataSet_4() { return &___mDataSet_4; }
inline void set_mDataSet_4(DataSet_t3286034874 * value)
{
___mDataSet_4 = value;
Il2CppCodeGenWriteBarrier((&___mDataSet_4), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // DATASETOBJECTTARGETIMPL_T2835536742_H
#ifndef DELEGATE_T1188392813_H
#define DELEGATE_T1188392813_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Delegate
struct Delegate_t1188392813 : 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::method_code
intptr_t ___method_code_5;
// System.Reflection.MethodInfo System.Delegate::method_info
MethodInfo_t * ___method_info_6;
// System.Reflection.MethodInfo System.Delegate::original_method_info
MethodInfo_t * ___original_method_info_7;
// System.DelegateData System.Delegate::data
DelegateData_t1677132599 * ___data_8;
public:
inline static int32_t get_offset_of_method_ptr_0() { return static_cast<int32_t>(offsetof(Delegate_t1188392813, ___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_t1188392813, ___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_t1188392813, ___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((&___m_target_2), value);
}
inline static int32_t get_offset_of_method_3() { return static_cast<int32_t>(offsetof(Delegate_t1188392813, ___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_t1188392813, ___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_method_code_5() { return static_cast<int32_t>(offsetof(Delegate_t1188392813, ___method_code_5)); }
inline intptr_t get_method_code_5() const { return ___method_code_5; }
inline intptr_t* get_address_of_method_code_5() { return &___method_code_5; }
inline void set_method_code_5(intptr_t value)
{
___method_code_5 = value;
}
inline static int32_t get_offset_of_method_info_6() { return static_cast<int32_t>(offsetof(Delegate_t1188392813, ___method_info_6)); }
inline MethodInfo_t * get_method_info_6() const { return ___method_info_6; }
inline MethodInfo_t ** get_address_of_method_info_6() { return &___method_info_6; }
inline void set_method_info_6(MethodInfo_t * value)
{
___method_info_6 = value;
Il2CppCodeGenWriteBarrier((&___method_info_6), value);
}
inline static int32_t get_offset_of_original_method_info_7() { return static_cast<int32_t>(offsetof(Delegate_t1188392813, ___original_method_info_7)); }
inline MethodInfo_t * get_original_method_info_7() const { return ___original_method_info_7; }
inline MethodInfo_t ** get_address_of_original_method_info_7() { return &___original_method_info_7; }
inline void set_original_method_info_7(MethodInfo_t * value)
{
___original_method_info_7 = value;
Il2CppCodeGenWriteBarrier((&___original_method_info_7), value);
}
inline static int32_t get_offset_of_data_8() { return static_cast<int32_t>(offsetof(Delegate_t1188392813, ___data_8)); }
inline DelegateData_t1677132599 * get_data_8() const { return ___data_8; }
inline DelegateData_t1677132599 ** get_address_of_data_8() { return &___data_8; }
inline void set_data_8(DelegateData_t1677132599 * value)
{
___data_8 = value;
Il2CppCodeGenWriteBarrier((&___data_8), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // DELEGATE_T1188392813_H
#ifndef FLUIDEFFECTORFORCEAXIS_T3079702749_H
#define FLUIDEFFECTORFORCEAXIS_T3079702749_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// Thinksquirrel.Fluvio.FluidEffectorForceAxis
struct FluidEffectorForceAxis_t3079702749
{
public:
// System.Int32 Thinksquirrel.Fluvio.FluidEffectorForceAxis::value__
int32_t ___value___1;
public:
inline static int32_t get_offset_of_value___1() { return static_cast<int32_t>(offsetof(FluidEffectorForceAxis_t3079702749, ___value___1)); }
inline int32_t get_value___1() const { return ___value___1; }
inline int32_t* get_address_of_value___1() { return &___value___1; }
inline void set_value___1(int32_t value)
{
___value___1 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // FLUIDEFFECTORFORCEAXIS_T3079702749_H
#ifndef FLUIDPARTICLE_T651938203_H
#define FLUIDPARTICLE_T651938203_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// Thinksquirrel.Fluvio.Internal.Solvers.FluidParticle
#pragma pack(push, tp, 1)
struct FluidParticle_t651938203
{
public:
// UnityEngine.Vector4 Thinksquirrel.Fluvio.Internal.Solvers.FluidParticle::position
Vector4_t3319028937 ___position_0;
// UnityEngine.Vector4 Thinksquirrel.Fluvio.Internal.Solvers.FluidParticle::velocity
Vector4_t3319028937 ___velocity_1;
// UnityEngine.Vector4 Thinksquirrel.Fluvio.Internal.Solvers.FluidParticle::color
Vector4_t3319028937 ___color_2;
// UnityEngine.Vector4 Thinksquirrel.Fluvio.Internal.Solvers.FluidParticle::vorticityTurbulence
Vector4_t3319028937 ___vorticityTurbulence_3;
// UnityEngine.Vector4 Thinksquirrel.Fluvio.Internal.Solvers.FluidParticle::lifetime
Vector4_t3319028937 ___lifetime_4;
// Thinksquirrel.Fluvio.Internal.Solvers.int4 Thinksquirrel.Fluvio.Internal.Solvers.FluidParticle::id
int4_t93086280 ___id_5;
// UnityEngine.Vector4 Thinksquirrel.Fluvio.Internal.Solvers.FluidParticle::force
Vector4_t3319028937 ___force_6;
// UnityEngine.Vector4 Thinksquirrel.Fluvio.Internal.Solvers.FluidParticle::normal
Vector4_t3319028937 ___normal_7;
// UnityEngine.Vector4 Thinksquirrel.Fluvio.Internal.Solvers.FluidParticle::densityPressure
Vector4_t3319028937 ___densityPressure_8;
public:
inline static int32_t get_offset_of_position_0() { return static_cast<int32_t>(offsetof(FluidParticle_t651938203, ___position_0)); }
inline Vector4_t3319028937 get_position_0() const { return ___position_0; }
inline Vector4_t3319028937 * get_address_of_position_0() { return &___position_0; }
inline void set_position_0(Vector4_t3319028937 value)
{
___position_0 = value;
}
inline static int32_t get_offset_of_velocity_1() { return static_cast<int32_t>(offsetof(FluidParticle_t651938203, ___velocity_1)); }
inline Vector4_t3319028937 get_velocity_1() const { return ___velocity_1; }
inline Vector4_t3319028937 * get_address_of_velocity_1() { return &___velocity_1; }
inline void set_velocity_1(Vector4_t3319028937 value)
{
___velocity_1 = value;
}
inline static int32_t get_offset_of_color_2() { return static_cast<int32_t>(offsetof(FluidParticle_t651938203, ___color_2)); }
inline Vector4_t3319028937 get_color_2() const { return ___color_2; }
inline Vector4_t3319028937 * get_address_of_color_2() { return &___color_2; }
inline void set_color_2(Vector4_t3319028937 value)
{
___color_2 = value;
}
inline static int32_t get_offset_of_vorticityTurbulence_3() { return static_cast<int32_t>(offsetof(FluidParticle_t651938203, ___vorticityTurbulence_3)); }
inline Vector4_t3319028937 get_vorticityTurbulence_3() const { return ___vorticityTurbulence_3; }
inline Vector4_t3319028937 * get_address_of_vorticityTurbulence_3() { return &___vorticityTurbulence_3; }
inline void set_vorticityTurbulence_3(Vector4_t3319028937 value)
{
___vorticityTurbulence_3 = value;
}
inline static int32_t get_offset_of_lifetime_4() { return static_cast<int32_t>(offsetof(FluidParticle_t651938203, ___lifetime_4)); }
inline Vector4_t3319028937 get_lifetime_4() const { return ___lifetime_4; }
inline Vector4_t3319028937 * get_address_of_lifetime_4() { return &___lifetime_4; }
inline void set_lifetime_4(Vector4_t3319028937 value)
{
___lifetime_4 = value;
}
inline static int32_t get_offset_of_id_5() { return static_cast<int32_t>(offsetof(FluidParticle_t651938203, ___id_5)); }
inline int4_t93086280 get_id_5() const { return ___id_5; }
inline int4_t93086280 * get_address_of_id_5() { return &___id_5; }
inline void set_id_5(int4_t93086280 value)
{
___id_5 = value;
}
inline static int32_t get_offset_of_force_6() { return static_cast<int32_t>(offsetof(FluidParticle_t651938203, ___force_6)); }
inline Vector4_t3319028937 get_force_6() const { return ___force_6; }
inline Vector4_t3319028937 * get_address_of_force_6() { return &___force_6; }
inline void set_force_6(Vector4_t3319028937 value)
{
___force_6 = value;
}
inline static int32_t get_offset_of_normal_7() { return static_cast<int32_t>(offsetof(FluidParticle_t651938203, ___normal_7)); }
inline Vector4_t3319028937 get_normal_7() const { return ___normal_7; }
inline Vector4_t3319028937 * get_address_of_normal_7() { return &___normal_7; }
inline void set_normal_7(Vector4_t3319028937 value)
{
___normal_7 = value;
}
inline static int32_t get_offset_of_densityPressure_8() { return static_cast<int32_t>(offsetof(FluidParticle_t651938203, ___densityPressure_8)); }
inline Vector4_t3319028937 get_densityPressure_8() const { return ___densityPressure_8; }
inline Vector4_t3319028937 * get_address_of_densityPressure_8() { return &___densityPressure_8; }
inline void set_densityPressure_8(Vector4_t3319028937 value)
{
___densityPressure_8 = value;
}
};
#pragma pack(pop, tp)
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // FLUIDPARTICLE_T651938203_H
#ifndef FLUVIOTHREADPOOL_T2773119480_H
#define FLUVIOTHREADPOOL_T2773119480_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// Thinksquirrel.Fluvio.Internal.Threading.FluvioThreadPool
struct FluvioThreadPool_t2773119480 : public RuntimeObject
{
public:
// Thinksquirrel.Fluvio.Internal.Threading.LockFreeRingBuffer`1<Thinksquirrel.Fluvio.Internal.Threading.FluvioThreadPool/Task> Thinksquirrel.Fluvio.Internal.Threading.FluvioThreadPool::_queue
LockFreeRingBuffer_1_t9929710 * ____queue_0;
// Thinksquirrel.Fluvio.Internal.Threading.IThread[] Thinksquirrel.Fluvio.Internal.Threading.FluvioThreadPool::_workerThreads
IThreadU5BU5D_t347840266* ____workerThreads_1;
// System.Int32 Thinksquirrel.Fluvio.Internal.Threading.FluvioThreadPool::_totalThreadCount
int32_t ____totalThreadCount_2;
// System.Int32 Thinksquirrel.Fluvio.Internal.Threading.FluvioThreadPool::_maxTaskCount
int32_t ____maxTaskCount_3;
// System.Int32 modreq(System.Runtime.CompilerServices.IsVolatile) Thinksquirrel.Fluvio.Internal.Threading.FluvioThreadPool::_tasksCompleted
int32_t ____tasksCompleted_4;
// System.Int32 Thinksquirrel.Fluvio.Internal.Threading.FluvioThreadPool::_taskCount
int32_t ____taskCount_5;
// System.Boolean Thinksquirrel.Fluvio.Internal.Threading.FluvioThreadPool::_isStarted
bool ____isStarted_6;
// System.Boolean Thinksquirrel.Fluvio.Internal.Threading.FluvioThreadPool::_isFinished
bool ____isFinished_7;
// System.Boolean Thinksquirrel.Fluvio.Internal.Threading.FluvioThreadPool::_shouldStopThreads
bool ____shouldStopThreads_8;
// System.Boolean Thinksquirrel.Fluvio.Internal.Threading.FluvioThreadPool::_disposed
bool ____disposed_9;
// Thinksquirrel.Fluvio.Internal.Threading.IInterlocked Thinksquirrel.Fluvio.Internal.Threading.FluvioThreadPool::_interlocked
RuntimeObject* ____interlocked_10;
// Thinksquirrel.Fluvio.Internal.Threading.IThreadHandler Thinksquirrel.Fluvio.Internal.Threading.FluvioThreadPool::_threadHandler
RuntimeObject* ____threadHandler_11;
public:
inline static int32_t get_offset_of__queue_0() { return static_cast<int32_t>(offsetof(FluvioThreadPool_t2773119480, ____queue_0)); }
inline LockFreeRingBuffer_1_t9929710 * get__queue_0() const { return ____queue_0; }
inline LockFreeRingBuffer_1_t9929710 ** get_address_of__queue_0() { return &____queue_0; }
inline void set__queue_0(LockFreeRingBuffer_1_t9929710 * value)
{
____queue_0 = value;
Il2CppCodeGenWriteBarrier((&____queue_0), value);
}
inline static int32_t get_offset_of__workerThreads_1() { return static_cast<int32_t>(offsetof(FluvioThreadPool_t2773119480, ____workerThreads_1)); }
inline IThreadU5BU5D_t347840266* get__workerThreads_1() const { return ____workerThreads_1; }
inline IThreadU5BU5D_t347840266** get_address_of__workerThreads_1() { return &____workerThreads_1; }
inline void set__workerThreads_1(IThreadU5BU5D_t347840266* value)
{
____workerThreads_1 = value;
Il2CppCodeGenWriteBarrier((&____workerThreads_1), value);
}
inline static int32_t get_offset_of__totalThreadCount_2() { return static_cast<int32_t>(offsetof(FluvioThreadPool_t2773119480, ____totalThreadCount_2)); }
inline int32_t get__totalThreadCount_2() const { return ____totalThreadCount_2; }
inline int32_t* get_address_of__totalThreadCount_2() { return &____totalThreadCount_2; }
inline void set__totalThreadCount_2(int32_t value)
{
____totalThreadCount_2 = value;
}
inline static int32_t get_offset_of__maxTaskCount_3() { return static_cast<int32_t>(offsetof(FluvioThreadPool_t2773119480, ____maxTaskCount_3)); }
inline int32_t get__maxTaskCount_3() const { return ____maxTaskCount_3; }
inline int32_t* get_address_of__maxTaskCount_3() { return &____maxTaskCount_3; }
inline void set__maxTaskCount_3(int32_t value)
{
____maxTaskCount_3 = value;
}
inline static int32_t get_offset_of__tasksCompleted_4() { return static_cast<int32_t>(offsetof(FluvioThreadPool_t2773119480, ____tasksCompleted_4)); }
inline int32_t get__tasksCompleted_4() const { return ____tasksCompleted_4; }
inline int32_t* get_address_of__tasksCompleted_4() { return &____tasksCompleted_4; }
inline void set__tasksCompleted_4(int32_t value)
{
____tasksCompleted_4 = value;
}
inline static int32_t get_offset_of__taskCount_5() { return static_cast<int32_t>(offsetof(FluvioThreadPool_t2773119480, ____taskCount_5)); }
inline int32_t get__taskCount_5() const { return ____taskCount_5; }
inline int32_t* get_address_of__taskCount_5() { return &____taskCount_5; }
inline void set__taskCount_5(int32_t value)
{
____taskCount_5 = value;
}
inline static int32_t get_offset_of__isStarted_6() { return static_cast<int32_t>(offsetof(FluvioThreadPool_t2773119480, ____isStarted_6)); }
inline bool get__isStarted_6() const { return ____isStarted_6; }
inline bool* get_address_of__isStarted_6() { return &____isStarted_6; }
inline void set__isStarted_6(bool value)
{
____isStarted_6 = value;
}
inline static int32_t get_offset_of__isFinished_7() { return static_cast<int32_t>(offsetof(FluvioThreadPool_t2773119480, ____isFinished_7)); }
inline bool get__isFinished_7() const { return ____isFinished_7; }
inline bool* get_address_of__isFinished_7() { return &____isFinished_7; }
inline void set__isFinished_7(bool value)
{
____isFinished_7 = value;
}
inline static int32_t get_offset_of__shouldStopThreads_8() { return static_cast<int32_t>(offsetof(FluvioThreadPool_t2773119480, ____shouldStopThreads_8)); }
inline bool get__shouldStopThreads_8() const { return ____shouldStopThreads_8; }
inline bool* get_address_of__shouldStopThreads_8() { return &____shouldStopThreads_8; }
inline void set__shouldStopThreads_8(bool value)
{
____shouldStopThreads_8 = value;
}
inline static int32_t get_offset_of__disposed_9() { return static_cast<int32_t>(offsetof(FluvioThreadPool_t2773119480, ____disposed_9)); }
inline bool get__disposed_9() const { return ____disposed_9; }
inline bool* get_address_of__disposed_9() { return &____disposed_9; }
inline void set__disposed_9(bool value)
{
____disposed_9 = value;
}
inline static int32_t get_offset_of__interlocked_10() { return static_cast<int32_t>(offsetof(FluvioThreadPool_t2773119480, ____interlocked_10)); }
inline RuntimeObject* get__interlocked_10() const { return ____interlocked_10; }
inline RuntimeObject** get_address_of__interlocked_10() { return &____interlocked_10; }
inline void set__interlocked_10(RuntimeObject* value)
{
____interlocked_10 = value;
Il2CppCodeGenWriteBarrier((&____interlocked_10), value);
}
inline static int32_t get_offset_of__threadHandler_11() { return static_cast<int32_t>(offsetof(FluvioThreadPool_t2773119480, ____threadHandler_11)); }
inline RuntimeObject* get__threadHandler_11() const { return ____threadHandler_11; }
inline RuntimeObject** get_address_of__threadHandler_11() { return &____threadHandler_11; }
inline void set__threadHandler_11(RuntimeObject* value)
{
____threadHandler_11 = value;
Il2CppCodeGenWriteBarrier((&____threadHandler_11), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // FLUVIOTHREADPOOL_T2773119480_H
#ifndef PLANESHIDEEXCESSAREACLIPPING_T1460129200_H
#define PLANESHIDEEXCESSAREACLIPPING_T1460129200_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// Vuforia.PlanesHideExcessAreaClipping
struct PlanesHideExcessAreaClipping_t1460129200 : public RuntimeObject
{
public:
// UnityEngine.Shader Vuforia.PlanesHideExcessAreaClipping::mMatteShader
Shader_t4151988712 * ___mMatteShader_1;
// UnityEngine.GameObject[] Vuforia.PlanesHideExcessAreaClipping::mClippingPlanes
GameObjectU5BU5D_t3328599146* ___mClippingPlanes_2;
// System.Boolean Vuforia.PlanesHideExcessAreaClipping::mPlanesActivated
bool ___mPlanesActivated_3;
// UnityEngine.Vector2 Vuforia.PlanesHideExcessAreaClipping::mClippingScale
Vector2_t2156229523 ___mClippingScale_4;
public:
inline static int32_t get_offset_of_mMatteShader_1() { return static_cast<int32_t>(offsetof(PlanesHideExcessAreaClipping_t1460129200, ___mMatteShader_1)); }
inline Shader_t4151988712 * get_mMatteShader_1() const { return ___mMatteShader_1; }
inline Shader_t4151988712 ** get_address_of_mMatteShader_1() { return &___mMatteShader_1; }
inline void set_mMatteShader_1(Shader_t4151988712 * value)
{
___mMatteShader_1 = value;
Il2CppCodeGenWriteBarrier((&___mMatteShader_1), value);
}
inline static int32_t get_offset_of_mClippingPlanes_2() { return static_cast<int32_t>(offsetof(PlanesHideExcessAreaClipping_t1460129200, ___mClippingPlanes_2)); }
inline GameObjectU5BU5D_t3328599146* get_mClippingPlanes_2() const { return ___mClippingPlanes_2; }
inline GameObjectU5BU5D_t3328599146** get_address_of_mClippingPlanes_2() { return &___mClippingPlanes_2; }
inline void set_mClippingPlanes_2(GameObjectU5BU5D_t3328599146* value)
{
___mClippingPlanes_2 = value;
Il2CppCodeGenWriteBarrier((&___mClippingPlanes_2), value);
}
inline static int32_t get_offset_of_mPlanesActivated_3() { return static_cast<int32_t>(offsetof(PlanesHideExcessAreaClipping_t1460129200, ___mPlanesActivated_3)); }
inline bool get_mPlanesActivated_3() const { return ___mPlanesActivated_3; }
inline bool* get_address_of_mPlanesActivated_3() { return &___mPlanesActivated_3; }
inline void set_mPlanesActivated_3(bool value)
{
___mPlanesActivated_3 = value;
}
inline static int32_t get_offset_of_mClippingScale_4() { return static_cast<int32_t>(offsetof(PlanesHideExcessAreaClipping_t1460129200, ___mClippingScale_4)); }
inline Vector2_t2156229523 get_mClippingScale_4() const { return ___mClippingScale_4; }
inline Vector2_t2156229523 * get_address_of_mClippingScale_4() { return &___mClippingScale_4; }
inline void set_mClippingScale_4(Vector2_t2156229523 value)
{
___mClippingScale_4 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // PLANESHIDEEXCESSAREACLIPPING_T1460129200_H
#ifndef VUFORIANATIVEEXTENDEDTRACKINGIMPL_T571837481_H
#define VUFORIANATIVEEXTENDEDTRACKINGIMPL_T571837481_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// Vuforia.VuforiaNativeExtendedTrackingImpl
struct VuforiaNativeExtendedTrackingImpl_t571837481 : public RuntimeObject
{
public:
// System.Int32 Vuforia.VuforiaNativeExtendedTrackingImpl::mId
int32_t ___mId_0;
// System.IntPtr Vuforia.VuforiaNativeExtendedTrackingImpl::mDataSetPtr
intptr_t ___mDataSetPtr_1;
public:
inline static int32_t get_offset_of_mId_0() { return static_cast<int32_t>(offsetof(VuforiaNativeExtendedTrackingImpl_t571837481, ___mId_0)); }
inline int32_t get_mId_0() const { return ___mId_0; }
inline int32_t* get_address_of_mId_0() { return &___mId_0; }
inline void set_mId_0(int32_t value)
{
___mId_0 = value;
}
inline static int32_t get_offset_of_mDataSetPtr_1() { return static_cast<int32_t>(offsetof(VuforiaNativeExtendedTrackingImpl_t571837481, ___mDataSetPtr_1)); }
inline intptr_t get_mDataSetPtr_1() const { return ___mDataSetPtr_1; }
inline intptr_t* get_address_of_mDataSetPtr_1() { return &___mDataSetPtr_1; }
inline void set_mDataSetPtr_1(intptr_t value)
{
___mDataSetPtr_1 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // VUFORIANATIVEEXTENDEDTRACKINGIMPL_T571837481_H
#ifndef DATASETEXTENDEDTRACKINGIMPL_T3413727792_H
#define DATASETEXTENDEDTRACKINGIMPL_T3413727792_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// Vuforia.DataSetExtendedTrackingImpl
struct DataSetExtendedTrackingImpl_t3413727792 : public RuntimeObject
{
public:
// System.Int32 Vuforia.DataSetExtendedTrackingImpl::mId
int32_t ___mId_0;
// System.IntPtr Vuforia.DataSetExtendedTrackingImpl::mDataSetPtr
intptr_t ___mDataSetPtr_1;
public:
inline static int32_t get_offset_of_mId_0() { return static_cast<int32_t>(offsetof(DataSetExtendedTrackingImpl_t3413727792, ___mId_0)); }
inline int32_t get_mId_0() const { return ___mId_0; }
inline int32_t* get_address_of_mId_0() { return &___mId_0; }
inline void set_mId_0(int32_t value)
{
___mId_0 = value;
}
inline static int32_t get_offset_of_mDataSetPtr_1() { return static_cast<int32_t>(offsetof(DataSetExtendedTrackingImpl_t3413727792, ___mDataSetPtr_1)); }
inline intptr_t get_mDataSetPtr_1() const { return ___mDataSetPtr_1; }
inline intptr_t* get_address_of_mDataSetPtr_1() { return &___mDataSetPtr_1; }
inline void set_mDataSetPtr_1(intptr_t value)
{
___mDataSetPtr_1 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // DATASETEXTENDEDTRACKINGIMPL_T3413727792_H
#ifndef COMPARISONTYPE_T4142182662_H
#define COMPARISONTYPE_T4142182662_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// Thinksquirrel.Fluvio.Plugins.PhaseChange/ComparisonType
struct ComparisonType_t4142182662
{
public:
// System.Int32 Thinksquirrel.Fluvio.Plugins.PhaseChange/ComparisonType::value__
int32_t ___value___1;
public:
inline static int32_t get_offset_of_value___1() { return static_cast<int32_t>(offsetof(ComparisonType_t4142182662, ___value___1)); }
inline int32_t get_value___1() const { return ___value___1; }
inline int32_t* get_address_of_value___1() { return &___value___1; }
inline void set_value___1(int32_t value)
{
___value___1 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // COMPARISONTYPE_T4142182662_H
#ifndef POSITIONALDEVICETRACKER_T656722001_H
#define POSITIONALDEVICETRACKER_T656722001_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// Vuforia.PositionalDeviceTracker
struct PositionalDeviceTracker_t656722001 : public DeviceTracker_t2315692373
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // POSITIONALDEVICETRACKER_T656722001_H
#ifndef PHASECHANGEDATA_T3151312502_H
#define PHASECHANGEDATA_T3151312502_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// Thinksquirrel.Fluvio.Plugins.PhaseChange/PhaseChangeData
struct PhaseChangeData_t3151312502
{
public:
// UnityEngine.Vector4 Thinksquirrel.Fluvio.Plugins.PhaseChange/PhaseChangeData::emitPosition
Vector4_t3319028937 ___emitPosition_0;
// UnityEngine.Vector4 Thinksquirrel.Fluvio.Plugins.PhaseChange/PhaseChangeData::emitVelocity
Vector4_t3319028937 ___emitVelocity_1;
// UnityEngine.Vector4 Thinksquirrel.Fluvio.Plugins.PhaseChange/PhaseChangeData::pluginParams
Vector4_t3319028937 ___pluginParams_2;
public:
inline static int32_t get_offset_of_emitPosition_0() { return static_cast<int32_t>(offsetof(PhaseChangeData_t3151312502, ___emitPosition_0)); }
inline Vector4_t3319028937 get_emitPosition_0() const { return ___emitPosition_0; }
inline Vector4_t3319028937 * get_address_of_emitPosition_0() { return &___emitPosition_0; }
inline void set_emitPosition_0(Vector4_t3319028937 value)
{
___emitPosition_0 = value;
}
inline static int32_t get_offset_of_emitVelocity_1() { return static_cast<int32_t>(offsetof(PhaseChangeData_t3151312502, ___emitVelocity_1)); }
inline Vector4_t3319028937 get_emitVelocity_1() const { return ___emitVelocity_1; }
inline Vector4_t3319028937 * get_address_of_emitVelocity_1() { return &___emitVelocity_1; }
inline void set_emitVelocity_1(Vector4_t3319028937 value)
{
___emitVelocity_1 = value;
}
inline static int32_t get_offset_of_pluginParams_2() { return static_cast<int32_t>(offsetof(PhaseChangeData_t3151312502, ___pluginParams_2)); }
inline Vector4_t3319028937 get_pluginParams_2() const { return ___pluginParams_2; }
inline Vector4_t3319028937 * get_address_of_pluginParams_2() { return &___pluginParams_2; }
inline void set_pluginParams_2(Vector4_t3319028937 value)
{
___pluginParams_2 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // PHASECHANGEDATA_T3151312502_H
#ifndef ILLUMINATIONMANAGER_T3960931838_H
#define ILLUMINATIONMANAGER_T3960931838_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// Vuforia.IlluminationManager
struct IlluminationManager_t3960931838 : public RuntimeObject
{
public:
// Vuforia.TrackerData/IlluminationData Vuforia.IlluminationManager::mIlluminationData
IlluminationData_t3332404395 ___mIlluminationData_1;
public:
inline static int32_t get_offset_of_mIlluminationData_1() { return static_cast<int32_t>(offsetof(IlluminationManager_t3960931838, ___mIlluminationData_1)); }
inline IlluminationData_t3332404395 get_mIlluminationData_1() const { return ___mIlluminationData_1; }
inline IlluminationData_t3332404395 * get_address_of_mIlluminationData_1() { return &___mIlluminationData_1; }
inline void set_mIlluminationData_1(IlluminationData_t3332404395 value)
{
___mIlluminationData_1 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // ILLUMINATIONMANAGER_T3960931838_H
#ifndef FLUIDEFFECTORDATA_T883069132_H
#define FLUIDEFFECTORDATA_T883069132_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// Thinksquirrel.Fluvio.Plugins.Effectors.FluidEffector/FluidEffectorData
struct FluidEffectorData_t883069132
{
public:
// UnityEngine.Matrix4x4 Thinksquirrel.Fluvio.Plugins.Effectors.FluidEffector/FluidEffectorData::worldToLocalMatrix
Matrix4x4_t1817901843 ___worldToLocalMatrix_0;
// UnityEngine.Vector4 Thinksquirrel.Fluvio.Plugins.Effectors.FluidEffector/FluidEffectorData::position
Vector4_t3319028937 ___position_1;
// UnityEngine.Vector4 Thinksquirrel.Fluvio.Plugins.Effectors.FluidEffector/FluidEffectorData::worldPosition
Vector4_t3319028937 ___worldPosition_2;
// UnityEngine.Vector4 Thinksquirrel.Fluvio.Plugins.Effectors.FluidEffector/FluidEffectorData::extents
Vector4_t3319028937 ___extents_3;
// UnityEngine.Vector4 Thinksquirrel.Fluvio.Plugins.Effectors.FluidEffector/FluidEffectorData::decayParams
Vector4_t3319028937 ___decayParams_4;
// UnityEngine.Vector4 Thinksquirrel.Fluvio.Plugins.Effectors.FluidEffector/FluidEffectorData::forceDirection
Vector4_t3319028937 ___forceDirection_5;
// System.Single Thinksquirrel.Fluvio.Plugins.Effectors.FluidEffector/FluidEffectorData::effectorRange
float ___effectorRange_6;
// System.Single Thinksquirrel.Fluvio.Plugins.Effectors.FluidEffector/FluidEffectorData::unused0
float ___unused0_7;
// System.Single Thinksquirrel.Fluvio.Plugins.Effectors.FluidEffector/FluidEffectorData::unused1
float ___unused1_8;
// System.Single Thinksquirrel.Fluvio.Plugins.Effectors.FluidEffector/FluidEffectorData::unused2
float ___unused2_9;
public:
inline static int32_t get_offset_of_worldToLocalMatrix_0() { return static_cast<int32_t>(offsetof(FluidEffectorData_t883069132, ___worldToLocalMatrix_0)); }
inline Matrix4x4_t1817901843 get_worldToLocalMatrix_0() const { return ___worldToLocalMatrix_0; }
inline Matrix4x4_t1817901843 * get_address_of_worldToLocalMatrix_0() { return &___worldToLocalMatrix_0; }
inline void set_worldToLocalMatrix_0(Matrix4x4_t1817901843 value)
{
___worldToLocalMatrix_0 = value;
}
inline static int32_t get_offset_of_position_1() { return static_cast<int32_t>(offsetof(FluidEffectorData_t883069132, ___position_1)); }
inline Vector4_t3319028937 get_position_1() const { return ___position_1; }
inline Vector4_t3319028937 * get_address_of_position_1() { return &___position_1; }
inline void set_position_1(Vector4_t3319028937 value)
{
___position_1 = value;
}
inline static int32_t get_offset_of_worldPosition_2() { return static_cast<int32_t>(offsetof(FluidEffectorData_t883069132, ___worldPosition_2)); }
inline Vector4_t3319028937 get_worldPosition_2() const { return ___worldPosition_2; }
inline Vector4_t3319028937 * get_address_of_worldPosition_2() { return &___worldPosition_2; }
inline void set_worldPosition_2(Vector4_t3319028937 value)
{
___worldPosition_2 = value;
}
inline static int32_t get_offset_of_extents_3() { return static_cast<int32_t>(offsetof(FluidEffectorData_t883069132, ___extents_3)); }
inline Vector4_t3319028937 get_extents_3() const { return ___extents_3; }
inline Vector4_t3319028937 * get_address_of_extents_3() { return &___extents_3; }
inline void set_extents_3(Vector4_t3319028937 value)
{
___extents_3 = value;
}
inline static int32_t get_offset_of_decayParams_4() { return static_cast<int32_t>(offsetof(FluidEffectorData_t883069132, ___decayParams_4)); }
inline Vector4_t3319028937 get_decayParams_4() const { return ___decayParams_4; }
inline Vector4_t3319028937 * get_address_of_decayParams_4() { return &___decayParams_4; }
inline void set_decayParams_4(Vector4_t3319028937 value)
{
___decayParams_4 = value;
}
inline static int32_t get_offset_of_forceDirection_5() { return static_cast<int32_t>(offsetof(FluidEffectorData_t883069132, ___forceDirection_5)); }
inline Vector4_t3319028937 get_forceDirection_5() const { return ___forceDirection_5; }
inline Vector4_t3319028937 * get_address_of_forceDirection_5() { return &___forceDirection_5; }
inline void set_forceDirection_5(Vector4_t3319028937 value)
{
___forceDirection_5 = value;
}
inline static int32_t get_offset_of_effectorRange_6() { return static_cast<int32_t>(offsetof(FluidEffectorData_t883069132, ___effectorRange_6)); }
inline float get_effectorRange_6() const { return ___effectorRange_6; }
inline float* get_address_of_effectorRange_6() { return &___effectorRange_6; }
inline void set_effectorRange_6(float value)
{
___effectorRange_6 = value;
}
inline static int32_t get_offset_of_unused0_7() { return static_cast<int32_t>(offsetof(FluidEffectorData_t883069132, ___unused0_7)); }
inline float get_unused0_7() const { return ___unused0_7; }
inline float* get_address_of_unused0_7() { return &___unused0_7; }
inline void set_unused0_7(float value)
{
___unused0_7 = value;
}
inline static int32_t get_offset_of_unused1_8() { return static_cast<int32_t>(offsetof(FluidEffectorData_t883069132, ___unused1_8)); }
inline float get_unused1_8() const { return ___unused1_8; }
inline float* get_address_of_unused1_8() { return &___unused1_8; }
inline void set_unused1_8(float value)
{
___unused1_8 = value;
}
inline static int32_t get_offset_of_unused2_9() { return static_cast<int32_t>(offsetof(FluidEffectorData_t883069132, ___unused2_9)); }
inline float get_unused2_9() const { return ___unused2_9; }
inline float* get_address_of_unused2_9() { return &___unused2_9; }
inline void set_unused2_9(float value)
{
___unused2_9 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // FLUIDEFFECTORDATA_T883069132_H
#ifndef PLANEPOS_T1459879262_H
#define PLANEPOS_T1459879262_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// Vuforia.PlanesHideExcessAreaClipping/PlanePos
struct PlanePos_t1459879262
{
public:
// System.Int32 Vuforia.PlanesHideExcessAreaClipping/PlanePos::value__
int32_t ___value___1;
public:
inline static int32_t get_offset_of_value___1() { return static_cast<int32_t>(offsetof(PlanePos_t1459879262, ___value___1)); }
inline int32_t get_value___1() const { return ___value___1; }
inline int32_t* get_address_of_value___1() { return &___value___1; }
inline void set_value___1(int32_t value)
{
___value___1 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // PLANEPOS_T1459879262_H
#ifndef SEETHROUGHCONFIGURATION_T568665021_H
#define SEETHROUGHCONFIGURATION_T568665021_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// Vuforia.DigitalEyewearARController/SeeThroughConfiguration
struct SeeThroughConfiguration_t568665021
{
public:
// System.Int32 Vuforia.DigitalEyewearARController/SeeThroughConfiguration::value__
int32_t ___value___1;
public:
inline static int32_t get_offset_of_value___1() { return static_cast<int32_t>(offsetof(SeeThroughConfiguration_t568665021, ___value___1)); }
inline int32_t get_value___1() const { return ___value___1; }
inline int32_t* get_address_of_value___1() { return &___value___1; }
inline void set_value___1(int32_t value)
{
___value___1 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // SEETHROUGHCONFIGURATION_T568665021_H
#ifndef STEREOFRAMEWORK_T3144873991_H
#define STEREOFRAMEWORK_T3144873991_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// Vuforia.DigitalEyewearARController/StereoFramework
struct StereoFramework_t3144873991
{
public:
// System.Int32 Vuforia.DigitalEyewearARController/StereoFramework::value__
int32_t ___value___1;
public:
inline static int32_t get_offset_of_value___1() { return static_cast<int32_t>(offsetof(StereoFramework_t3144873991, ___value___1)); }
inline int32_t get_value___1() const { return ___value___1; }
inline int32_t* get_address_of_value___1() { return &___value___1; }
inline void set_value___1(int32_t value)
{
___value___1 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // STEREOFRAMEWORK_T3144873991_H
#ifndef EYEWEARTYPE_T2277580470_H
#define EYEWEARTYPE_T2277580470_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// Vuforia.DigitalEyewearARController/EyewearType
struct EyewearType_t2277580470
{
public:
// System.Int32 Vuforia.DigitalEyewearARController/EyewearType::value__
int32_t ___value___1;
public:
inline static int32_t get_offset_of_value___1() { return static_cast<int32_t>(offsetof(EyewearType_t2277580470, ___value___1)); }
inline int32_t get_value___1() const { return ___value___1; }
inline int32_t* get_address_of_value___1() { return &___value___1; }
inline void set_value___1(int32_t value)
{
___value___1 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // EYEWEARTYPE_T2277580470_H
#ifndef OBJECT_T631007953_H
#define OBJECT_T631007953_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// UnityEngine.Object
struct Object_t631007953 : public RuntimeObject
{
public:
// System.IntPtr UnityEngine.Object::m_CachedPtr
intptr_t ___m_CachedPtr_0;
public:
inline static int32_t get_offset_of_m_CachedPtr_0() { return static_cast<int32_t>(offsetof(Object_t631007953, ___m_CachedPtr_0)); }
inline intptr_t get_m_CachedPtr_0() const { return ___m_CachedPtr_0; }
inline intptr_t* get_address_of_m_CachedPtr_0() { return &___m_CachedPtr_0; }
inline void set_m_CachedPtr_0(intptr_t value)
{
___m_CachedPtr_0 = value;
}
};
struct Object_t631007953_StaticFields
{
public:
// System.Int32 UnityEngine.Object::OffsetOfInstanceIDInCPlusPlusObject
int32_t ___OffsetOfInstanceIDInCPlusPlusObject_1;
public:
inline static int32_t get_offset_of_OffsetOfInstanceIDInCPlusPlusObject_1() { return static_cast<int32_t>(offsetof(Object_t631007953_StaticFields, ___OffsetOfInstanceIDInCPlusPlusObject_1)); }
inline int32_t get_OffsetOfInstanceIDInCPlusPlusObject_1() const { return ___OffsetOfInstanceIDInCPlusPlusObject_1; }
inline int32_t* get_address_of_OffsetOfInstanceIDInCPlusPlusObject_1() { return &___OffsetOfInstanceIDInCPlusPlusObject_1; }
inline void set_OffsetOfInstanceIDInCPlusPlusObject_1(int32_t value)
{
___OffsetOfInstanceIDInCPlusPlusObject_1 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
// Native definition for P/Invoke marshalling of UnityEngine.Object
struct Object_t631007953_marshaled_pinvoke
{
intptr_t ___m_CachedPtr_0;
};
// Native definition for COM marshalling of UnityEngine.Object
struct Object_t631007953_marshaled_com
{
intptr_t ___m_CachedPtr_0;
};
#endif // OBJECT_T631007953_H
#ifndef FLUIDDATA_T3912775833_H
#define FLUIDDATA_T3912775833_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// Thinksquirrel.Fluvio.Internal.Solvers.FluidData
#pragma pack(push, tp, 1)
struct FluidData_t3912775833
{
public:
// UnityEngine.Vector4 Thinksquirrel.Fluvio.Internal.Solvers.FluidData::gravity
Vector4_t3319028937 ___gravity_0;
// System.Single Thinksquirrel.Fluvio.Internal.Solvers.FluidData::initialDensity
float ___initialDensity_1;
// System.Single Thinksquirrel.Fluvio.Internal.Solvers.FluidData::minimumDensity
float ___minimumDensity_2;
// System.Single Thinksquirrel.Fluvio.Internal.Solvers.FluidData::particleMass
float ___particleMass_3;
// System.Single Thinksquirrel.Fluvio.Internal.Solvers.FluidData::viscosity
float ___viscosity_4;
// System.Single Thinksquirrel.Fluvio.Internal.Solvers.FluidData::turbulence
float ___turbulence_5;
// System.Single Thinksquirrel.Fluvio.Internal.Solvers.FluidData::surfaceTension
float ___surfaceTension_6;
// System.Single Thinksquirrel.Fluvio.Internal.Solvers.FluidData::gasConstant
float ___gasConstant_7;
// System.Single Thinksquirrel.Fluvio.Internal.Solvers.FluidData::buoyancyCoefficient
float ___buoyancyCoefficient_8;
public:
inline static int32_t get_offset_of_gravity_0() { return static_cast<int32_t>(offsetof(FluidData_t3912775833, ___gravity_0)); }
inline Vector4_t3319028937 get_gravity_0() const { return ___gravity_0; }
inline Vector4_t3319028937 * get_address_of_gravity_0() { return &___gravity_0; }
inline void set_gravity_0(Vector4_t3319028937 value)
{
___gravity_0 = value;
}
inline static int32_t get_offset_of_initialDensity_1() { return static_cast<int32_t>(offsetof(FluidData_t3912775833, ___initialDensity_1)); }
inline float get_initialDensity_1() const { return ___initialDensity_1; }
inline float* get_address_of_initialDensity_1() { return &___initialDensity_1; }
inline void set_initialDensity_1(float value)
{
___initialDensity_1 = value;
}
inline static int32_t get_offset_of_minimumDensity_2() { return static_cast<int32_t>(offsetof(FluidData_t3912775833, ___minimumDensity_2)); }
inline float get_minimumDensity_2() const { return ___minimumDensity_2; }
inline float* get_address_of_minimumDensity_2() { return &___minimumDensity_2; }
inline void set_minimumDensity_2(float value)
{
___minimumDensity_2 = value;
}
inline static int32_t get_offset_of_particleMass_3() { return static_cast<int32_t>(offsetof(FluidData_t3912775833, ___particleMass_3)); }
inline float get_particleMass_3() const { return ___particleMass_3; }
inline float* get_address_of_particleMass_3() { return &___particleMass_3; }
inline void set_particleMass_3(float value)
{
___particleMass_3 = value;
}
inline static int32_t get_offset_of_viscosity_4() { return static_cast<int32_t>(offsetof(FluidData_t3912775833, ___viscosity_4)); }
inline float get_viscosity_4() const { return ___viscosity_4; }
inline float* get_address_of_viscosity_4() { return &___viscosity_4; }
inline void set_viscosity_4(float value)
{
___viscosity_4 = value;
}
inline static int32_t get_offset_of_turbulence_5() { return static_cast<int32_t>(offsetof(FluidData_t3912775833, ___turbulence_5)); }
inline float get_turbulence_5() const { return ___turbulence_5; }
inline float* get_address_of_turbulence_5() { return &___turbulence_5; }
inline void set_turbulence_5(float value)
{
___turbulence_5 = value;
}
inline static int32_t get_offset_of_surfaceTension_6() { return static_cast<int32_t>(offsetof(FluidData_t3912775833, ___surfaceTension_6)); }
inline float get_surfaceTension_6() const { return ___surfaceTension_6; }
inline float* get_address_of_surfaceTension_6() { return &___surfaceTension_6; }
inline void set_surfaceTension_6(float value)
{
___surfaceTension_6 = value;
}
inline static int32_t get_offset_of_gasConstant_7() { return static_cast<int32_t>(offsetof(FluidData_t3912775833, ___gasConstant_7)); }
inline float get_gasConstant_7() const { return ___gasConstant_7; }
inline float* get_address_of_gasConstant_7() { return &___gasConstant_7; }
inline void set_gasConstant_7(float value)
{
___gasConstant_7 = value;
}
inline static int32_t get_offset_of_buoyancyCoefficient_8() { return static_cast<int32_t>(offsetof(FluidData_t3912775833, ___buoyancyCoefficient_8)); }
inline float get_buoyancyCoefficient_8() const { return ___buoyancyCoefficient_8; }
inline float* get_address_of_buoyancyCoefficient_8() { return &___buoyancyCoefficient_8; }
inline void set_buoyancyCoefficient_8(float value)
{
___buoyancyCoefficient_8 = value;
}
};
#pragma pack(pop, tp)
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // FLUIDDATA_T3912775833_H
#ifndef MODE_T2291249183_H
#define MODE_T2291249183_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// Vuforia.StereoProjMatrixStore/Mode
struct Mode_t2291249183
{
public:
// System.Int32 Vuforia.StereoProjMatrixStore/Mode::value__
int32_t ___value___1;
public:
inline static int32_t get_offset_of_value___1() { return static_cast<int32_t>(offsetof(Mode_t2291249183, ___value___1)); }
inline int32_t get_value___1() const { return ___value___1; }
inline int32_t* get_address_of_value___1() { return &___value___1; }
inline void set_value___1(int32_t value)
{
___value___1 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // MODE_T2291249183_H
#ifndef IOSUNITYPLAYER_T2555589894_H
#define IOSUNITYPLAYER_T2555589894_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// Vuforia.IOSUnityPlayer
struct IOSUnityPlayer_t2555589894 : public RuntimeObject
{
public:
// UnityEngine.ScreenOrientation Vuforia.IOSUnityPlayer::mScreenOrientation
int32_t ___mScreenOrientation_0;
public:
inline static int32_t get_offset_of_mScreenOrientation_0() { return static_cast<int32_t>(offsetof(IOSUnityPlayer_t2555589894, ___mScreenOrientation_0)); }
inline int32_t get_mScreenOrientation_0() const { return ___mScreenOrientation_0; }
inline int32_t* get_address_of_mScreenOrientation_0() { return &___mScreenOrientation_0; }
inline void set_mScreenOrientation_0(int32_t value)
{
___mScreenOrientation_0 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // IOSUNITYPLAYER_T2555589894_H
#ifndef EYEWEARCALIBRATIONREADING_T664929988_H
#define EYEWEARCALIBRATIONREADING_T664929988_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// Vuforia.EyewearDevice/EyewearCalibrationReading
struct EyewearCalibrationReading_t664929988
{
public:
// System.Single[] Vuforia.EyewearDevice/EyewearCalibrationReading::pose
SingleU5BU5D_t1444911251* ___pose_0;
// System.Single Vuforia.EyewearDevice/EyewearCalibrationReading::scale
float ___scale_1;
// System.Single Vuforia.EyewearDevice/EyewearCalibrationReading::centerX
float ___centerX_2;
// System.Single Vuforia.EyewearDevice/EyewearCalibrationReading::centerY
float ___centerY_3;
// Vuforia.EyewearDevice/EyewearCalibrationReading/AlignmentType Vuforia.EyewearDevice/EyewearCalibrationReading::type
int32_t ___type_4;
public:
inline static int32_t get_offset_of_pose_0() { return static_cast<int32_t>(offsetof(EyewearCalibrationReading_t664929988, ___pose_0)); }
inline SingleU5BU5D_t1444911251* get_pose_0() const { return ___pose_0; }
inline SingleU5BU5D_t1444911251** get_address_of_pose_0() { return &___pose_0; }
inline void set_pose_0(SingleU5BU5D_t1444911251* value)
{
___pose_0 = value;
Il2CppCodeGenWriteBarrier((&___pose_0), value);
}
inline static int32_t get_offset_of_scale_1() { return static_cast<int32_t>(offsetof(EyewearCalibrationReading_t664929988, ___scale_1)); }
inline float get_scale_1() const { return ___scale_1; }
inline float* get_address_of_scale_1() { return &___scale_1; }
inline void set_scale_1(float value)
{
___scale_1 = value;
}
inline static int32_t get_offset_of_centerX_2() { return static_cast<int32_t>(offsetof(EyewearCalibrationReading_t664929988, ___centerX_2)); }
inline float get_centerX_2() const { return ___centerX_2; }
inline float* get_address_of_centerX_2() { return &___centerX_2; }
inline void set_centerX_2(float value)
{
___centerX_2 = value;
}
inline static int32_t get_offset_of_centerY_3() { return static_cast<int32_t>(offsetof(EyewearCalibrationReading_t664929988, ___centerY_3)); }
inline float get_centerY_3() const { return ___centerY_3; }
inline float* get_address_of_centerY_3() { return &___centerY_3; }
inline void set_centerY_3(float value)
{
___centerY_3 = value;
}
inline static int32_t get_offset_of_type_4() { return static_cast<int32_t>(offsetof(EyewearCalibrationReading_t664929988, ___type_4)); }
inline int32_t get_type_4() const { return ___type_4; }
inline int32_t* get_address_of_type_4() { return &___type_4; }
inline void set_type_4(int32_t value)
{
___type_4 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
// Native definition for P/Invoke marshalling of Vuforia.EyewearDevice/EyewearCalibrationReading
struct EyewearCalibrationReading_t664929988_marshaled_pinvoke
{
float* ___pose_0;
float ___scale_1;
float ___centerX_2;
float ___centerY_3;
int32_t ___type_4;
};
// Native definition for COM marshalling of Vuforia.EyewearDevice/EyewearCalibrationReading
struct EyewearCalibrationReading_t664929988_marshaled_com
{
float* ___pose_0;
float ___scale_1;
float ___centerX_2;
float ___centerY_3;
int32_t ___type_4;
};
#endif // EYEWEARCALIBRATIONREADING_T664929988_H
#ifndef POSITIONALDEVICETRACKERIMPL_T1314438186_H
#define POSITIONALDEVICETRACKERIMPL_T1314438186_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// Vuforia.PositionalDeviceTrackerImpl
struct PositionalDeviceTrackerImpl_t1314438186 : public PositionalDeviceTracker_t656722001
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // POSITIONALDEVICETRACKERIMPL_T1314438186_H
#ifndef COMPONENT_T1923634451_H
#define COMPONENT_T1923634451_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// UnityEngine.Component
struct Component_t1923634451 : public Object_t631007953
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // COMPONENT_T1923634451_H
#ifndef BASECAMERACONFIGURATION_T3118151474_H
#define BASECAMERACONFIGURATION_T3118151474_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// Vuforia.BaseCameraConfiguration
struct BaseCameraConfiguration_t3118151474 : public RuntimeObject
{
public:
// Vuforia.CameraDevice/CameraDeviceMode Vuforia.BaseCameraConfiguration::mCameraDeviceMode
int32_t ___mCameraDeviceMode_0;
// Vuforia.VuforiaRenderer/VideoBackgroundReflection Vuforia.BaseCameraConfiguration::mLastVideoBackGroundMirroredFromSDK
int32_t ___mLastVideoBackGroundMirroredFromSDK_1;
// System.Action Vuforia.BaseCameraConfiguration::mOnVideoBackgroundConfigChanged
Action_t1264377477 * ___mOnVideoBackgroundConfigChanged_2;
// Vuforia.VideoBackgroundBehaviour Vuforia.BaseCameraConfiguration::mVideoBackgroundBehaviour
VideoBackgroundBehaviour_t1552899074 * ___mVideoBackgroundBehaviour_3;
// UnityEngine.Rect Vuforia.BaseCameraConfiguration::mVideoBackgroundViewportRect
Rect_t2360479859 ___mVideoBackgroundViewportRect_4;
// System.Boolean Vuforia.BaseCameraConfiguration::mRenderVideoBackground
bool ___mRenderVideoBackground_5;
// UnityEngine.ScreenOrientation Vuforia.BaseCameraConfiguration::mProjectionOrientation
int32_t ___mProjectionOrientation_6;
// Vuforia.VuforiaRenderer/VideoBackgroundReflection Vuforia.BaseCameraConfiguration::mInitialReflection
int32_t ___mInitialReflection_7;
// Vuforia.BackgroundPlaneBehaviour Vuforia.BaseCameraConfiguration::mBackgroundPlaneBehaviour
BackgroundPlaneBehaviour_t3333547397 * ___mBackgroundPlaneBehaviour_8;
// System.Boolean Vuforia.BaseCameraConfiguration::mCameraParameterChanged
bool ___mCameraParameterChanged_9;
public:
inline static int32_t get_offset_of_mCameraDeviceMode_0() { return static_cast<int32_t>(offsetof(BaseCameraConfiguration_t3118151474, ___mCameraDeviceMode_0)); }
inline int32_t get_mCameraDeviceMode_0() const { return ___mCameraDeviceMode_0; }
inline int32_t* get_address_of_mCameraDeviceMode_0() { return &___mCameraDeviceMode_0; }
inline void set_mCameraDeviceMode_0(int32_t value)
{
___mCameraDeviceMode_0 = value;
}
inline static int32_t get_offset_of_mLastVideoBackGroundMirroredFromSDK_1() { return static_cast<int32_t>(offsetof(BaseCameraConfiguration_t3118151474, ___mLastVideoBackGroundMirroredFromSDK_1)); }
inline int32_t get_mLastVideoBackGroundMirroredFromSDK_1() const { return ___mLastVideoBackGroundMirroredFromSDK_1; }
inline int32_t* get_address_of_mLastVideoBackGroundMirroredFromSDK_1() { return &___mLastVideoBackGroundMirroredFromSDK_1; }
inline void set_mLastVideoBackGroundMirroredFromSDK_1(int32_t value)
{
___mLastVideoBackGroundMirroredFromSDK_1 = value;
}
inline static int32_t get_offset_of_mOnVideoBackgroundConfigChanged_2() { return static_cast<int32_t>(offsetof(BaseCameraConfiguration_t3118151474, ___mOnVideoBackgroundConfigChanged_2)); }
inline Action_t1264377477 * get_mOnVideoBackgroundConfigChanged_2() const { return ___mOnVideoBackgroundConfigChanged_2; }
inline Action_t1264377477 ** get_address_of_mOnVideoBackgroundConfigChanged_2() { return &___mOnVideoBackgroundConfigChanged_2; }
inline void set_mOnVideoBackgroundConfigChanged_2(Action_t1264377477 * value)
{
___mOnVideoBackgroundConfigChanged_2 = value;
Il2CppCodeGenWriteBarrier((&___mOnVideoBackgroundConfigChanged_2), value);
}
inline static int32_t get_offset_of_mVideoBackgroundBehaviour_3() { return static_cast<int32_t>(offsetof(BaseCameraConfiguration_t3118151474, ___mVideoBackgroundBehaviour_3)); }
inline VideoBackgroundBehaviour_t1552899074 * get_mVideoBackgroundBehaviour_3() const { return ___mVideoBackgroundBehaviour_3; }
inline VideoBackgroundBehaviour_t1552899074 ** get_address_of_mVideoBackgroundBehaviour_3() { return &___mVideoBackgroundBehaviour_3; }
inline void set_mVideoBackgroundBehaviour_3(VideoBackgroundBehaviour_t1552899074 * value)
{
___mVideoBackgroundBehaviour_3 = value;
Il2CppCodeGenWriteBarrier((&___mVideoBackgroundBehaviour_3), value);
}
inline static int32_t get_offset_of_mVideoBackgroundViewportRect_4() { return static_cast<int32_t>(offsetof(BaseCameraConfiguration_t3118151474, ___mVideoBackgroundViewportRect_4)); }
inline Rect_t2360479859 get_mVideoBackgroundViewportRect_4() const { return ___mVideoBackgroundViewportRect_4; }
inline Rect_t2360479859 * get_address_of_mVideoBackgroundViewportRect_4() { return &___mVideoBackgroundViewportRect_4; }
inline void set_mVideoBackgroundViewportRect_4(Rect_t2360479859 value)
{
___mVideoBackgroundViewportRect_4 = value;
}
inline static int32_t get_offset_of_mRenderVideoBackground_5() { return static_cast<int32_t>(offsetof(BaseCameraConfiguration_t3118151474, ___mRenderVideoBackground_5)); }
inline bool get_mRenderVideoBackground_5() const { return ___mRenderVideoBackground_5; }
inline bool* get_address_of_mRenderVideoBackground_5() { return &___mRenderVideoBackground_5; }
inline void set_mRenderVideoBackground_5(bool value)
{
___mRenderVideoBackground_5 = value;
}
inline static int32_t get_offset_of_mProjectionOrientation_6() { return static_cast<int32_t>(offsetof(BaseCameraConfiguration_t3118151474, ___mProjectionOrientation_6)); }
inline int32_t get_mProjectionOrientation_6() const { return ___mProjectionOrientation_6; }
inline int32_t* get_address_of_mProjectionOrientation_6() { return &___mProjectionOrientation_6; }
inline void set_mProjectionOrientation_6(int32_t value)
{
___mProjectionOrientation_6 = value;
}
inline static int32_t get_offset_of_mInitialReflection_7() { return static_cast<int32_t>(offsetof(BaseCameraConfiguration_t3118151474, ___mInitialReflection_7)); }
inline int32_t get_mInitialReflection_7() const { return ___mInitialReflection_7; }
inline int32_t* get_address_of_mInitialReflection_7() { return &___mInitialReflection_7; }
inline void set_mInitialReflection_7(int32_t value)
{
___mInitialReflection_7 = value;
}
inline static int32_t get_offset_of_mBackgroundPlaneBehaviour_8() { return static_cast<int32_t>(offsetof(BaseCameraConfiguration_t3118151474, ___mBackgroundPlaneBehaviour_8)); }
inline BackgroundPlaneBehaviour_t3333547397 * get_mBackgroundPlaneBehaviour_8() const { return ___mBackgroundPlaneBehaviour_8; }
inline BackgroundPlaneBehaviour_t3333547397 ** get_address_of_mBackgroundPlaneBehaviour_8() { return &___mBackgroundPlaneBehaviour_8; }
inline void set_mBackgroundPlaneBehaviour_8(BackgroundPlaneBehaviour_t3333547397 * value)
{
___mBackgroundPlaneBehaviour_8 = value;
Il2CppCodeGenWriteBarrier((&___mBackgroundPlaneBehaviour_8), value);
}
inline static int32_t get_offset_of_mCameraParameterChanged_9() { return static_cast<int32_t>(offsetof(BaseCameraConfiguration_t3118151474, ___mCameraParameterChanged_9)); }
inline bool get_mCameraParameterChanged_9() const { return ___mCameraParameterChanged_9; }
inline bool* get_address_of_mCameraParameterChanged_9() { return &___mCameraParameterChanged_9; }
inline void set_mCameraParameterChanged_9(bool value)
{
___mCameraParameterChanged_9 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // BASECAMERACONFIGURATION_T3118151474_H
#ifndef SERIALIZABLEVIEWERPARAMETERS_T2043332680_H
#define SERIALIZABLEVIEWERPARAMETERS_T2043332680_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// Vuforia.DigitalEyewearARController/SerializableViewerParameters
struct SerializableViewerParameters_t2043332680 : public RuntimeObject
{
public:
// System.Single Vuforia.DigitalEyewearARController/SerializableViewerParameters::Version
float ___Version_0;
// System.String Vuforia.DigitalEyewearARController/SerializableViewerParameters::Name
String_t* ___Name_1;
// System.String Vuforia.DigitalEyewearARController/SerializableViewerParameters::Manufacturer
String_t* ___Manufacturer_2;
// Vuforia.ViewerButtonType Vuforia.DigitalEyewearARController/SerializableViewerParameters::ButtonType
int32_t ___ButtonType_3;
// System.Single Vuforia.DigitalEyewearARController/SerializableViewerParameters::ScreenToLensDistance
float ___ScreenToLensDistance_4;
// System.Single Vuforia.DigitalEyewearARController/SerializableViewerParameters::InterLensDistance
float ___InterLensDistance_5;
// Vuforia.ViewerTrayAlignment Vuforia.DigitalEyewearARController/SerializableViewerParameters::TrayAlignment
int32_t ___TrayAlignment_6;
// System.Single Vuforia.DigitalEyewearARController/SerializableViewerParameters::LensCenterToTrayDistance
float ___LensCenterToTrayDistance_7;
// UnityEngine.Vector2 Vuforia.DigitalEyewearARController/SerializableViewerParameters::DistortionCoefficients
Vector2_t2156229523 ___DistortionCoefficients_8;
// UnityEngine.Vector4 Vuforia.DigitalEyewearARController/SerializableViewerParameters::FieldOfView
Vector4_t3319028937 ___FieldOfView_9;
// System.Boolean Vuforia.DigitalEyewearARController/SerializableViewerParameters::ContainsMagnet
bool ___ContainsMagnet_10;
public:
inline static int32_t get_offset_of_Version_0() { return static_cast<int32_t>(offsetof(SerializableViewerParameters_t2043332680, ___Version_0)); }
inline float get_Version_0() const { return ___Version_0; }
inline float* get_address_of_Version_0() { return &___Version_0; }
inline void set_Version_0(float value)
{
___Version_0 = value;
}
inline static int32_t get_offset_of_Name_1() { return static_cast<int32_t>(offsetof(SerializableViewerParameters_t2043332680, ___Name_1)); }
inline String_t* get_Name_1() const { return ___Name_1; }
inline String_t** get_address_of_Name_1() { return &___Name_1; }
inline void set_Name_1(String_t* value)
{
___Name_1 = value;
Il2CppCodeGenWriteBarrier((&___Name_1), value);
}
inline static int32_t get_offset_of_Manufacturer_2() { return static_cast<int32_t>(offsetof(SerializableViewerParameters_t2043332680, ___Manufacturer_2)); }
inline String_t* get_Manufacturer_2() const { return ___Manufacturer_2; }
inline String_t** get_address_of_Manufacturer_2() { return &___Manufacturer_2; }
inline void set_Manufacturer_2(String_t* value)
{
___Manufacturer_2 = value;
Il2CppCodeGenWriteBarrier((&___Manufacturer_2), value);
}
inline static int32_t get_offset_of_ButtonType_3() { return static_cast<int32_t>(offsetof(SerializableViewerParameters_t2043332680, ___ButtonType_3)); }
inline int32_t get_ButtonType_3() const { return ___ButtonType_3; }
inline int32_t* get_address_of_ButtonType_3() { return &___ButtonType_3; }
inline void set_ButtonType_3(int32_t value)
{
___ButtonType_3 = value;
}
inline static int32_t get_offset_of_ScreenToLensDistance_4() { return static_cast<int32_t>(offsetof(SerializableViewerParameters_t2043332680, ___ScreenToLensDistance_4)); }
inline float get_ScreenToLensDistance_4() const { return ___ScreenToLensDistance_4; }
inline float* get_address_of_ScreenToLensDistance_4() { return &___ScreenToLensDistance_4; }
inline void set_ScreenToLensDistance_4(float value)
{
___ScreenToLensDistance_4 = value;
}
inline static int32_t get_offset_of_InterLensDistance_5() { return static_cast<int32_t>(offsetof(SerializableViewerParameters_t2043332680, ___InterLensDistance_5)); }
inline float get_InterLensDistance_5() const { return ___InterLensDistance_5; }
inline float* get_address_of_InterLensDistance_5() { return &___InterLensDistance_5; }
inline void set_InterLensDistance_5(float value)
{
___InterLensDistance_5 = value;
}
inline static int32_t get_offset_of_TrayAlignment_6() { return static_cast<int32_t>(offsetof(SerializableViewerParameters_t2043332680, ___TrayAlignment_6)); }
inline int32_t get_TrayAlignment_6() const { return ___TrayAlignment_6; }
inline int32_t* get_address_of_TrayAlignment_6() { return &___TrayAlignment_6; }
inline void set_TrayAlignment_6(int32_t value)
{
___TrayAlignment_6 = value;
}
inline static int32_t get_offset_of_LensCenterToTrayDistance_7() { return static_cast<int32_t>(offsetof(SerializableViewerParameters_t2043332680, ___LensCenterToTrayDistance_7)); }
inline float get_LensCenterToTrayDistance_7() const { return ___LensCenterToTrayDistance_7; }
inline float* get_address_of_LensCenterToTrayDistance_7() { return &___LensCenterToTrayDistance_7; }
inline void set_LensCenterToTrayDistance_7(float value)
{
___LensCenterToTrayDistance_7 = value;
}
inline static int32_t get_offset_of_DistortionCoefficients_8() { return static_cast<int32_t>(offsetof(SerializableViewerParameters_t2043332680, ___DistortionCoefficients_8)); }
inline Vector2_t2156229523 get_DistortionCoefficients_8() const { return ___DistortionCoefficients_8; }
inline Vector2_t2156229523 * get_address_of_DistortionCoefficients_8() { return &___DistortionCoefficients_8; }
inline void set_DistortionCoefficients_8(Vector2_t2156229523 value)
{
___DistortionCoefficients_8 = value;
}
inline static int32_t get_offset_of_FieldOfView_9() { return static_cast<int32_t>(offsetof(SerializableViewerParameters_t2043332680, ___FieldOfView_9)); }
inline Vector4_t3319028937 get_FieldOfView_9() const { return ___FieldOfView_9; }
inline Vector4_t3319028937 * get_address_of_FieldOfView_9() { return &___FieldOfView_9; }
inline void set_FieldOfView_9(Vector4_t3319028937 value)
{
___FieldOfView_9 = value;
}
inline static int32_t get_offset_of_ContainsMagnet_10() { return static_cast<int32_t>(offsetof(SerializableViewerParameters_t2043332680, ___ContainsMagnet_10)); }
inline bool get_ContainsMagnet_10() const { return ___ContainsMagnet_10; }
inline bool* get_address_of_ContainsMagnet_10() { return &___ContainsMagnet_10; }
inline void set_ContainsMagnet_10(bool value)
{
___ContainsMagnet_10 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // SERIALIZABLEVIEWERPARAMETERS_T2043332680_H
#ifndef POSITIONALPLAYMODEDEVICETRACKERIMPL_T1348222404_H
#define POSITIONALPLAYMODEDEVICETRACKERIMPL_T1348222404_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// Vuforia.PositionalPlayModeDeviceTrackerImpl
struct PositionalPlayModeDeviceTrackerImpl_t1348222404 : public PositionalDeviceTracker_t656722001
{
public:
// System.Int32 Vuforia.PositionalPlayModeDeviceTrackerImpl::mTrackableId
int32_t ___mTrackableId_3;
// Vuforia.DataSet Vuforia.PositionalPlayModeDeviceTrackerImpl::mEmulatorDataset
DataSet_t3286034874 * ___mEmulatorDataset_4;
// UnityEngine.Vector3 Vuforia.PositionalPlayModeDeviceTrackerImpl::<Position>k__BackingField
Vector3_t3722313464 ___U3CPositionU3Ek__BackingField_5;
// UnityEngine.Vector3 Vuforia.PositionalPlayModeDeviceTrackerImpl::<Rotation>k__BackingField
Vector3_t3722313464 ___U3CRotationU3Ek__BackingField_6;
public:
inline static int32_t get_offset_of_mTrackableId_3() { return static_cast<int32_t>(offsetof(PositionalPlayModeDeviceTrackerImpl_t1348222404, ___mTrackableId_3)); }
inline int32_t get_mTrackableId_3() const { return ___mTrackableId_3; }
inline int32_t* get_address_of_mTrackableId_3() { return &___mTrackableId_3; }
inline void set_mTrackableId_3(int32_t value)
{
___mTrackableId_3 = value;
}
inline static int32_t get_offset_of_mEmulatorDataset_4() { return static_cast<int32_t>(offsetof(PositionalPlayModeDeviceTrackerImpl_t1348222404, ___mEmulatorDataset_4)); }
inline DataSet_t3286034874 * get_mEmulatorDataset_4() const { return ___mEmulatorDataset_4; }
inline DataSet_t3286034874 ** get_address_of_mEmulatorDataset_4() { return &___mEmulatorDataset_4; }
inline void set_mEmulatorDataset_4(DataSet_t3286034874 * value)
{
___mEmulatorDataset_4 = value;
Il2CppCodeGenWriteBarrier((&___mEmulatorDataset_4), value);
}
inline static int32_t get_offset_of_U3CPositionU3Ek__BackingField_5() { return static_cast<int32_t>(offsetof(PositionalPlayModeDeviceTrackerImpl_t1348222404, ___U3CPositionU3Ek__BackingField_5)); }
inline Vector3_t3722313464 get_U3CPositionU3Ek__BackingField_5() const { return ___U3CPositionU3Ek__BackingField_5; }
inline Vector3_t3722313464 * get_address_of_U3CPositionU3Ek__BackingField_5() { return &___U3CPositionU3Ek__BackingField_5; }
inline void set_U3CPositionU3Ek__BackingField_5(Vector3_t3722313464 value)
{
___U3CPositionU3Ek__BackingField_5 = value;
}
inline static int32_t get_offset_of_U3CRotationU3Ek__BackingField_6() { return static_cast<int32_t>(offsetof(PositionalPlayModeDeviceTrackerImpl_t1348222404, ___U3CRotationU3Ek__BackingField_6)); }
inline Vector3_t3722313464 get_U3CRotationU3Ek__BackingField_6() const { return ___U3CRotationU3Ek__BackingField_6; }
inline Vector3_t3722313464 * get_address_of_U3CRotationU3Ek__BackingField_6() { return &___U3CRotationU3Ek__BackingField_6; }
inline void set_U3CRotationU3Ek__BackingField_6(Vector3_t3722313464 value)
{
___U3CRotationU3Ek__BackingField_6 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // POSITIONALPLAYMODEDEVICETRACKERIMPL_T1348222404_H
#ifndef SOLVERDATAINTERNAL_T3200118405_H
#define SOLVERDATAINTERNAL_T3200118405_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// Thinksquirrel.Fluvio.Internal.Solvers.SolverDataInternal
struct SolverDataInternal_t3200118405 : public RuntimeObject
{
public:
// Thinksquirrel.Fluvio.Internal.Solvers.int4 Thinksquirrel.Fluvio.Internal.Solvers.SolverDataInternal::_Count
int4_t93086280 ____Count_0;
// System.Int32 Thinksquirrel.Fluvio.Internal.Solvers.SolverDataInternal::_Stride
int32_t ____Stride_1;
// UnityEngine.Vector4 Thinksquirrel.Fluvio.Internal.Solvers.SolverDataInternal::_Time
Vector4_t3319028937 ____Time_2;
// UnityEngine.Vector4 Thinksquirrel.Fluvio.Internal.Solvers.SolverDataInternal::_KernelSize
Vector4_t3319028937 ____KernelSize_3;
// UnityEngine.Vector4 Thinksquirrel.Fluvio.Internal.Solvers.SolverDataInternal::_KernelFactors
Vector4_t3319028937 ____KernelFactors_4;
// System.Boolean Thinksquirrel.Fluvio.Internal.Solvers.SolverDataInternal::_fluidChanged
bool ____fluidChanged_5;
// System.Boolean Thinksquirrel.Fluvio.Internal.Solvers.SolverDataInternal::_boundaryParticlesChanged
bool ____boundaryParticlesChanged_6;
// Thinksquirrel.Fluvio.ComputeAPI Thinksquirrel.Fluvio.Internal.Solvers.SolverDataInternal::_computeAPI
int32_t ____computeAPI_7;
// Thinksquirrel.Fluvio.Internal.Solvers.FluidData[] Thinksquirrel.Fluvio.Internal.Solvers.SolverDataInternal::_Fluid
FluidDataU5BU5D_t408108260* ____Fluid_8;
// Thinksquirrel.Fluvio.Internal.Solvers.FluidParticle[] Thinksquirrel.Fluvio.Internal.Solvers.SolverDataInternal::_Particle
FluidParticleU5BU5D_t687312282* ____Particle_9;
// Thinksquirrel.Fluvio.Internal.Solvers.FluidParticle[] Thinksquirrel.Fluvio.Internal.Solvers.SolverDataInternal::_BoundaryParticle
FluidParticleU5BU5D_t687312282* ____BoundaryParticle_10;
// Thinksquirrel.Fluvio.Internal.Solvers.IndexGrid Thinksquirrel.Fluvio.Internal.Solvers.SolverDataInternal::_IndexGrid
IndexGrid_t759839143 * ____IndexGrid_11;
// System.Int32[] Thinksquirrel.Fluvio.Internal.Solvers.SolverDataInternal::_Neighbors
Int32U5BU5D_t385246372* ____Neighbors_12;
// Thinksquirrel.Fluvio.Internal.FluvioComputeBuffer`1<Thinksquirrel.Fluvio.Internal.Solvers.FluidData> Thinksquirrel.Fluvio.Internal.Solvers.SolverDataInternal::_fluidCB
FluvioComputeBuffer_1_t3020680417 * ____fluidCB_13;
// Thinksquirrel.Fluvio.Internal.FluvioComputeBuffer`1<Thinksquirrel.Fluvio.Internal.Solvers.FluidParticle> Thinksquirrel.Fluvio.Internal.Solvers.SolverDataInternal::_particleCB
FluvioComputeBuffer_1_t4054810083 * ____particleCB_14;
// Thinksquirrel.Fluvio.Internal.FluvioComputeBuffer`1<Thinksquirrel.Fluvio.Internal.Solvers.FluidParticle> Thinksquirrel.Fluvio.Internal.Solvers.SolverDataInternal::_boundaryParticleCB
FluvioComputeBuffer_1_t4054810083 * ____boundaryParticleCB_15;
// Thinksquirrel.Fluvio.Internal.FluvioComputeBuffer`1<System.UInt32> Thinksquirrel.Fluvio.Internal.Solvers.SolverDataInternal::_indexGridCB
FluvioComputeBuffer_1_t1667966562 * ____indexGridCB_16;
// Thinksquirrel.Fluvio.Internal.FluvioComputeBuffer`1<System.Int32> Thinksquirrel.Fluvio.Internal.Solvers.SolverDataInternal::_neighborsCB
FluvioComputeBuffer_1_t2058850337 * ____neighborsCB_17;
public:
inline static int32_t get_offset_of__Count_0() { return static_cast<int32_t>(offsetof(SolverDataInternal_t3200118405, ____Count_0)); }
inline int4_t93086280 get__Count_0() const { return ____Count_0; }
inline int4_t93086280 * get_address_of__Count_0() { return &____Count_0; }
inline void set__Count_0(int4_t93086280 value)
{
____Count_0 = value;
}
inline static int32_t get_offset_of__Stride_1() { return static_cast<int32_t>(offsetof(SolverDataInternal_t3200118405, ____Stride_1)); }
inline int32_t get__Stride_1() const { return ____Stride_1; }
inline int32_t* get_address_of__Stride_1() { return &____Stride_1; }
inline void set__Stride_1(int32_t value)
{
____Stride_1 = value;
}
inline static int32_t get_offset_of__Time_2() { return static_cast<int32_t>(offsetof(SolverDataInternal_t3200118405, ____Time_2)); }
inline Vector4_t3319028937 get__Time_2() const { return ____Time_2; }
inline Vector4_t3319028937 * get_address_of__Time_2() { return &____Time_2; }
inline void set__Time_2(Vector4_t3319028937 value)
{
____Time_2 = value;
}
inline static int32_t get_offset_of__KernelSize_3() { return static_cast<int32_t>(offsetof(SolverDataInternal_t3200118405, ____KernelSize_3)); }
inline Vector4_t3319028937 get__KernelSize_3() const { return ____KernelSize_3; }
inline Vector4_t3319028937 * get_address_of__KernelSize_3() { return &____KernelSize_3; }
inline void set__KernelSize_3(Vector4_t3319028937 value)
{
____KernelSize_3 = value;
}
inline static int32_t get_offset_of__KernelFactors_4() { return static_cast<int32_t>(offsetof(SolverDataInternal_t3200118405, ____KernelFactors_4)); }
inline Vector4_t3319028937 get__KernelFactors_4() const { return ____KernelFactors_4; }
inline Vector4_t3319028937 * get_address_of__KernelFactors_4() { return &____KernelFactors_4; }
inline void set__KernelFactors_4(Vector4_t3319028937 value)
{
____KernelFactors_4 = value;
}
inline static int32_t get_offset_of__fluidChanged_5() { return static_cast<int32_t>(offsetof(SolverDataInternal_t3200118405, ____fluidChanged_5)); }
inline bool get__fluidChanged_5() const { return ____fluidChanged_5; }
inline bool* get_address_of__fluidChanged_5() { return &____fluidChanged_5; }
inline void set__fluidChanged_5(bool value)
{
____fluidChanged_5 = value;
}
inline static int32_t get_offset_of__boundaryParticlesChanged_6() { return static_cast<int32_t>(offsetof(SolverDataInternal_t3200118405, ____boundaryParticlesChanged_6)); }
inline bool get__boundaryParticlesChanged_6() const { return ____boundaryParticlesChanged_6; }
inline bool* get_address_of__boundaryParticlesChanged_6() { return &____boundaryParticlesChanged_6; }
inline void set__boundaryParticlesChanged_6(bool value)
{
____boundaryParticlesChanged_6 = value;
}
inline static int32_t get_offset_of__computeAPI_7() { return static_cast<int32_t>(offsetof(SolverDataInternal_t3200118405, ____computeAPI_7)); }
inline int32_t get__computeAPI_7() const { return ____computeAPI_7; }
inline int32_t* get_address_of__computeAPI_7() { return &____computeAPI_7; }
inline void set__computeAPI_7(int32_t value)
{
____computeAPI_7 = value;
}
inline static int32_t get_offset_of__Fluid_8() { return static_cast<int32_t>(offsetof(SolverDataInternal_t3200118405, ____Fluid_8)); }
inline FluidDataU5BU5D_t408108260* get__Fluid_8() const { return ____Fluid_8; }
inline FluidDataU5BU5D_t408108260** get_address_of__Fluid_8() { return &____Fluid_8; }
inline void set__Fluid_8(FluidDataU5BU5D_t408108260* value)
{
____Fluid_8 = value;
Il2CppCodeGenWriteBarrier((&____Fluid_8), value);
}
inline static int32_t get_offset_of__Particle_9() { return static_cast<int32_t>(offsetof(SolverDataInternal_t3200118405, ____Particle_9)); }
inline FluidParticleU5BU5D_t687312282* get__Particle_9() const { return ____Particle_9; }
inline FluidParticleU5BU5D_t687312282** get_address_of__Particle_9() { return &____Particle_9; }
inline void set__Particle_9(FluidParticleU5BU5D_t687312282* value)
{
____Particle_9 = value;
Il2CppCodeGenWriteBarrier((&____Particle_9), value);
}
inline static int32_t get_offset_of__BoundaryParticle_10() { return static_cast<int32_t>(offsetof(SolverDataInternal_t3200118405, ____BoundaryParticle_10)); }
inline FluidParticleU5BU5D_t687312282* get__BoundaryParticle_10() const { return ____BoundaryParticle_10; }
inline FluidParticleU5BU5D_t687312282** get_address_of__BoundaryParticle_10() { return &____BoundaryParticle_10; }
inline void set__BoundaryParticle_10(FluidParticleU5BU5D_t687312282* value)
{
____BoundaryParticle_10 = value;
Il2CppCodeGenWriteBarrier((&____BoundaryParticle_10), value);
}
inline static int32_t get_offset_of__IndexGrid_11() { return static_cast<int32_t>(offsetof(SolverDataInternal_t3200118405, ____IndexGrid_11)); }
inline IndexGrid_t759839143 * get__IndexGrid_11() const { return ____IndexGrid_11; }
inline IndexGrid_t759839143 ** get_address_of__IndexGrid_11() { return &____IndexGrid_11; }
inline void set__IndexGrid_11(IndexGrid_t759839143 * value)
{
____IndexGrid_11 = value;
Il2CppCodeGenWriteBarrier((&____IndexGrid_11), value);
}
inline static int32_t get_offset_of__Neighbors_12() { return static_cast<int32_t>(offsetof(SolverDataInternal_t3200118405, ____Neighbors_12)); }
inline Int32U5BU5D_t385246372* get__Neighbors_12() const { return ____Neighbors_12; }
inline Int32U5BU5D_t385246372** get_address_of__Neighbors_12() { return &____Neighbors_12; }
inline void set__Neighbors_12(Int32U5BU5D_t385246372* value)
{
____Neighbors_12 = value;
Il2CppCodeGenWriteBarrier((&____Neighbors_12), value);
}
inline static int32_t get_offset_of__fluidCB_13() { return static_cast<int32_t>(offsetof(SolverDataInternal_t3200118405, ____fluidCB_13)); }
inline FluvioComputeBuffer_1_t3020680417 * get__fluidCB_13() const { return ____fluidCB_13; }
inline FluvioComputeBuffer_1_t3020680417 ** get_address_of__fluidCB_13() { return &____fluidCB_13; }
inline void set__fluidCB_13(FluvioComputeBuffer_1_t3020680417 * value)
{
____fluidCB_13 = value;
Il2CppCodeGenWriteBarrier((&____fluidCB_13), value);
}
inline static int32_t get_offset_of__particleCB_14() { return static_cast<int32_t>(offsetof(SolverDataInternal_t3200118405, ____particleCB_14)); }
inline FluvioComputeBuffer_1_t4054810083 * get__particleCB_14() const { return ____particleCB_14; }
inline FluvioComputeBuffer_1_t4054810083 ** get_address_of__particleCB_14() { return &____particleCB_14; }
inline void set__particleCB_14(FluvioComputeBuffer_1_t4054810083 * value)
{
____particleCB_14 = value;
Il2CppCodeGenWriteBarrier((&____particleCB_14), value);
}
inline static int32_t get_offset_of__boundaryParticleCB_15() { return static_cast<int32_t>(offsetof(SolverDataInternal_t3200118405, ____boundaryParticleCB_15)); }
inline FluvioComputeBuffer_1_t4054810083 * get__boundaryParticleCB_15() const { return ____boundaryParticleCB_15; }
inline FluvioComputeBuffer_1_t4054810083 ** get_address_of__boundaryParticleCB_15() { return &____boundaryParticleCB_15; }
inline void set__boundaryParticleCB_15(FluvioComputeBuffer_1_t4054810083 * value)
{
____boundaryParticleCB_15 = value;
Il2CppCodeGenWriteBarrier((&____boundaryParticleCB_15), value);
}
inline static int32_t get_offset_of__indexGridCB_16() { return static_cast<int32_t>(offsetof(SolverDataInternal_t3200118405, ____indexGridCB_16)); }
inline FluvioComputeBuffer_1_t1667966562 * get__indexGridCB_16() const { return ____indexGridCB_16; }
inline FluvioComputeBuffer_1_t1667966562 ** get_address_of__indexGridCB_16() { return &____indexGridCB_16; }
inline void set__indexGridCB_16(FluvioComputeBuffer_1_t1667966562 * value)
{
____indexGridCB_16 = value;
Il2CppCodeGenWriteBarrier((&____indexGridCB_16), value);
}
inline static int32_t get_offset_of__neighborsCB_17() { return static_cast<int32_t>(offsetof(SolverDataInternal_t3200118405, ____neighborsCB_17)); }
inline FluvioComputeBuffer_1_t2058850337 * get__neighborsCB_17() const { return ____neighborsCB_17; }
inline FluvioComputeBuffer_1_t2058850337 ** get_address_of__neighborsCB_17() { return &____neighborsCB_17; }
inline void set__neighborsCB_17(FluvioComputeBuffer_1_t2058850337 * value)
{
____neighborsCB_17 = value;
Il2CppCodeGenWriteBarrier((&____neighborsCB_17), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // SOLVERDATAINTERNAL_T3200118405_H
#ifndef DIGITALEYEWEARARCONTROLLER_T1054226036_H
#define DIGITALEYEWEARARCONTROLLER_T1054226036_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// Vuforia.DigitalEyewearARController
struct DigitalEyewearARController_t1054226036 : public ARController_t116632334
{
public:
// System.Single Vuforia.DigitalEyewearARController::mCameraOffset
float ___mCameraOffset_6;
// System.Int32 Vuforia.DigitalEyewearARController::mDistortionRenderingLayer
int32_t ___mDistortionRenderingLayer_7;
// Vuforia.DigitalEyewearARController/EyewearType Vuforia.DigitalEyewearARController::mEyewearType
int32_t ___mEyewearType_8;
// Vuforia.DigitalEyewearARController/StereoFramework Vuforia.DigitalEyewearARController::mStereoFramework
int32_t ___mStereoFramework_9;
// Vuforia.DigitalEyewearARController/SeeThroughConfiguration Vuforia.DigitalEyewearARController::mSeeThroughConfiguration
int32_t ___mSeeThroughConfiguration_10;
// System.String Vuforia.DigitalEyewearARController::mViewerName
String_t* ___mViewerName_11;
// System.String Vuforia.DigitalEyewearARController::mViewerManufacturer
String_t* ___mViewerManufacturer_12;
// System.Boolean Vuforia.DigitalEyewearARController::mUseCustomViewer
bool ___mUseCustomViewer_13;
// Vuforia.DigitalEyewearARController/SerializableViewerParameters Vuforia.DigitalEyewearARController::mCustomViewer
SerializableViewerParameters_t2043332680 * ___mCustomViewer_14;
// UnityEngine.Transform Vuforia.DigitalEyewearARController::mCentralAnchorPoint
Transform_t3600365921 * ___mCentralAnchorPoint_15;
// UnityEngine.Camera Vuforia.DigitalEyewearARController::mPrimaryCamera
Camera_t4157153871 * ___mPrimaryCamera_16;
// Vuforia.VuforiaARController Vuforia.DigitalEyewearARController::mVuforiaBehaviour
VuforiaARController_t1876945237 * ___mVuforiaBehaviour_17;
// System.Boolean Vuforia.DigitalEyewearARController::mSetFocusPlaneAutomatically
bool ___mSetFocusPlaneAutomatically_18;
// Vuforia.VRDeviceController Vuforia.DigitalEyewearARController::mVRDeviceController
VRDeviceController_t3863472269 * ___mVRDeviceController_19;
public:
inline static int32_t get_offset_of_mCameraOffset_6() { return static_cast<int32_t>(offsetof(DigitalEyewearARController_t1054226036, ___mCameraOffset_6)); }
inline float get_mCameraOffset_6() const { return ___mCameraOffset_6; }
inline float* get_address_of_mCameraOffset_6() { return &___mCameraOffset_6; }
inline void set_mCameraOffset_6(float value)
{
___mCameraOffset_6 = value;
}
inline static int32_t get_offset_of_mDistortionRenderingLayer_7() { return static_cast<int32_t>(offsetof(DigitalEyewearARController_t1054226036, ___mDistortionRenderingLayer_7)); }
inline int32_t get_mDistortionRenderingLayer_7() const { return ___mDistortionRenderingLayer_7; }
inline int32_t* get_address_of_mDistortionRenderingLayer_7() { return &___mDistortionRenderingLayer_7; }
inline void set_mDistortionRenderingLayer_7(int32_t value)
{
___mDistortionRenderingLayer_7 = value;
}
inline static int32_t get_offset_of_mEyewearType_8() { return static_cast<int32_t>(offsetof(DigitalEyewearARController_t1054226036, ___mEyewearType_8)); }
inline int32_t get_mEyewearType_8() const { return ___mEyewearType_8; }
inline int32_t* get_address_of_mEyewearType_8() { return &___mEyewearType_8; }
inline void set_mEyewearType_8(int32_t value)
{
___mEyewearType_8 = value;
}
inline static int32_t get_offset_of_mStereoFramework_9() { return static_cast<int32_t>(offsetof(DigitalEyewearARController_t1054226036, ___mStereoFramework_9)); }
inline int32_t get_mStereoFramework_9() const { return ___mStereoFramework_9; }
inline int32_t* get_address_of_mStereoFramework_9() { return &___mStereoFramework_9; }
inline void set_mStereoFramework_9(int32_t value)
{
___mStereoFramework_9 = value;
}
inline static int32_t get_offset_of_mSeeThroughConfiguration_10() { return static_cast<int32_t>(offsetof(DigitalEyewearARController_t1054226036, ___mSeeThroughConfiguration_10)); }
inline int32_t get_mSeeThroughConfiguration_10() const { return ___mSeeThroughConfiguration_10; }
inline int32_t* get_address_of_mSeeThroughConfiguration_10() { return &___mSeeThroughConfiguration_10; }
inline void set_mSeeThroughConfiguration_10(int32_t value)
{
___mSeeThroughConfiguration_10 = value;
}
inline static int32_t get_offset_of_mViewerName_11() { return static_cast<int32_t>(offsetof(DigitalEyewearARController_t1054226036, ___mViewerName_11)); }
inline String_t* get_mViewerName_11() const { return ___mViewerName_11; }
inline String_t** get_address_of_mViewerName_11() { return &___mViewerName_11; }
inline void set_mViewerName_11(String_t* value)
{
___mViewerName_11 = value;
Il2CppCodeGenWriteBarrier((&___mViewerName_11), value);
}
inline static int32_t get_offset_of_mViewerManufacturer_12() { return static_cast<int32_t>(offsetof(DigitalEyewearARController_t1054226036, ___mViewerManufacturer_12)); }
inline String_t* get_mViewerManufacturer_12() const { return ___mViewerManufacturer_12; }
inline String_t** get_address_of_mViewerManufacturer_12() { return &___mViewerManufacturer_12; }
inline void set_mViewerManufacturer_12(String_t* value)
{
___mViewerManufacturer_12 = value;
Il2CppCodeGenWriteBarrier((&___mViewerManufacturer_12), value);
}
inline static int32_t get_offset_of_mUseCustomViewer_13() { return static_cast<int32_t>(offsetof(DigitalEyewearARController_t1054226036, ___mUseCustomViewer_13)); }
inline bool get_mUseCustomViewer_13() const { return ___mUseCustomViewer_13; }
inline bool* get_address_of_mUseCustomViewer_13() { return &___mUseCustomViewer_13; }
inline void set_mUseCustomViewer_13(bool value)
{
___mUseCustomViewer_13 = value;
}
inline static int32_t get_offset_of_mCustomViewer_14() { return static_cast<int32_t>(offsetof(DigitalEyewearARController_t1054226036, ___mCustomViewer_14)); }
inline SerializableViewerParameters_t2043332680 * get_mCustomViewer_14() const { return ___mCustomViewer_14; }
inline SerializableViewerParameters_t2043332680 ** get_address_of_mCustomViewer_14() { return &___mCustomViewer_14; }
inline void set_mCustomViewer_14(SerializableViewerParameters_t2043332680 * value)
{
___mCustomViewer_14 = value;
Il2CppCodeGenWriteBarrier((&___mCustomViewer_14), value);
}
inline static int32_t get_offset_of_mCentralAnchorPoint_15() { return static_cast<int32_t>(offsetof(DigitalEyewearARController_t1054226036, ___mCentralAnchorPoint_15)); }
inline Transform_t3600365921 * get_mCentralAnchorPoint_15() const { return ___mCentralAnchorPoint_15; }
inline Transform_t3600365921 ** get_address_of_mCentralAnchorPoint_15() { return &___mCentralAnchorPoint_15; }
inline void set_mCentralAnchorPoint_15(Transform_t3600365921 * value)
{
___mCentralAnchorPoint_15 = value;
Il2CppCodeGenWriteBarrier((&___mCentralAnchorPoint_15), value);
}
inline static int32_t get_offset_of_mPrimaryCamera_16() { return static_cast<int32_t>(offsetof(DigitalEyewearARController_t1054226036, ___mPrimaryCamera_16)); }
inline Camera_t4157153871 * get_mPrimaryCamera_16() const { return ___mPrimaryCamera_16; }
inline Camera_t4157153871 ** get_address_of_mPrimaryCamera_16() { return &___mPrimaryCamera_16; }
inline void set_mPrimaryCamera_16(Camera_t4157153871 * value)
{
___mPrimaryCamera_16 = value;
Il2CppCodeGenWriteBarrier((&___mPrimaryCamera_16), value);
}
inline static int32_t get_offset_of_mVuforiaBehaviour_17() { return static_cast<int32_t>(offsetof(DigitalEyewearARController_t1054226036, ___mVuforiaBehaviour_17)); }
inline VuforiaARController_t1876945237 * get_mVuforiaBehaviour_17() const { return ___mVuforiaBehaviour_17; }
inline VuforiaARController_t1876945237 ** get_address_of_mVuforiaBehaviour_17() { return &___mVuforiaBehaviour_17; }
inline void set_mVuforiaBehaviour_17(VuforiaARController_t1876945237 * value)
{
___mVuforiaBehaviour_17 = value;
Il2CppCodeGenWriteBarrier((&___mVuforiaBehaviour_17), value);
}
inline static int32_t get_offset_of_mSetFocusPlaneAutomatically_18() { return static_cast<int32_t>(offsetof(DigitalEyewearARController_t1054226036, ___mSetFocusPlaneAutomatically_18)); }
inline bool get_mSetFocusPlaneAutomatically_18() const { return ___mSetFocusPlaneAutomatically_18; }
inline bool* get_address_of_mSetFocusPlaneAutomatically_18() { return &___mSetFocusPlaneAutomatically_18; }
inline void set_mSetFocusPlaneAutomatically_18(bool value)
{
___mSetFocusPlaneAutomatically_18 = value;
}
inline static int32_t get_offset_of_mVRDeviceController_19() { return static_cast<int32_t>(offsetof(DigitalEyewearARController_t1054226036, ___mVRDeviceController_19)); }
inline VRDeviceController_t3863472269 * get_mVRDeviceController_19() const { return ___mVRDeviceController_19; }
inline VRDeviceController_t3863472269 ** get_address_of_mVRDeviceController_19() { return &___mVRDeviceController_19; }
inline void set_mVRDeviceController_19(VRDeviceController_t3863472269 * value)
{
___mVRDeviceController_19 = value;
Il2CppCodeGenWriteBarrier((&___mVRDeviceController_19), value);
}
};
struct DigitalEyewearARController_t1054226036_StaticFields
{
public:
// Vuforia.DigitalEyewearARController Vuforia.DigitalEyewearARController::mInstance
DigitalEyewearARController_t1054226036 * ___mInstance_20;
// System.Object Vuforia.DigitalEyewearARController::mPadlock
RuntimeObject * ___mPadlock_21;
public:
inline static int32_t get_offset_of_mInstance_20() { return static_cast<int32_t>(offsetof(DigitalEyewearARController_t1054226036_StaticFields, ___mInstance_20)); }
inline DigitalEyewearARController_t1054226036 * get_mInstance_20() const { return ___mInstance_20; }
inline DigitalEyewearARController_t1054226036 ** get_address_of_mInstance_20() { return &___mInstance_20; }
inline void set_mInstance_20(DigitalEyewearARController_t1054226036 * value)
{
___mInstance_20 = value;
Il2CppCodeGenWriteBarrier((&___mInstance_20), value);
}
inline static int32_t get_offset_of_mPadlock_21() { return static_cast<int32_t>(offsetof(DigitalEyewearARController_t1054226036_StaticFields, ___mPadlock_21)); }
inline RuntimeObject * get_mPadlock_21() const { return ___mPadlock_21; }
inline RuntimeObject ** get_address_of_mPadlock_21() { return &___mPadlock_21; }
inline void set_mPadlock_21(RuntimeObject * value)
{
___mPadlock_21 = value;
Il2CppCodeGenWriteBarrier((&___mPadlock_21), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // DIGITALEYEWEARARCONTROLLER_T1054226036_H
#ifndef MULTICASTDELEGATE_T_H
#define MULTICASTDELEGATE_T_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.MulticastDelegate
struct MulticastDelegate_t : public Delegate_t1188392813
{
public:
// System.MulticastDelegate System.MulticastDelegate::prev
MulticastDelegate_t * ___prev_9;
// System.MulticastDelegate System.MulticastDelegate::kpm_next
MulticastDelegate_t * ___kpm_next_10;
public:
inline static int32_t get_offset_of_prev_9() { return static_cast<int32_t>(offsetof(MulticastDelegate_t, ___prev_9)); }
inline MulticastDelegate_t * get_prev_9() const { return ___prev_9; }
inline MulticastDelegate_t ** get_address_of_prev_9() { return &___prev_9; }
inline void set_prev_9(MulticastDelegate_t * value)
{
___prev_9 = value;
Il2CppCodeGenWriteBarrier((&___prev_9), value);
}
inline static int32_t get_offset_of_kpm_next_10() { return static_cast<int32_t>(offsetof(MulticastDelegate_t, ___kpm_next_10)); }
inline MulticastDelegate_t * get_kpm_next_10() const { return ___kpm_next_10; }
inline MulticastDelegate_t ** get_address_of_kpm_next_10() { return &___kpm_next_10; }
inline void set_kpm_next_10(MulticastDelegate_t * value)
{
___kpm_next_10 = value;
Il2CppCodeGenWriteBarrier((&___kpm_next_10), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // MULTICASTDELEGATE_T_H
#ifndef STEREOPROJMATRIXSTORE_T888524276_H
#define STEREOPROJMATRIXSTORE_T888524276_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// Vuforia.StereoProjMatrixStore
struct StereoProjMatrixStore_t888524276 : public RuntimeObject
{
public:
// UnityEngine.Camera Vuforia.StereoProjMatrixStore::mCamera
Camera_t4157153871 * ___mCamera_0;
// System.Collections.Generic.Dictionary`2<UnityEngine.Camera/StereoscopicEye,UnityEngine.Matrix4x4> Vuforia.StereoProjMatrixStore::mProjectionMatrices
Dictionary_2_t738209647 * ___mProjectionMatrices_1;
// System.Collections.Generic.Dictionary`2<UnityEngine.Camera/StereoscopicEye,System.Single> Vuforia.StereoProjMatrixStore::mAppliedVerticalFoVs
Dictionary_2_t317574578 * ___mAppliedVerticalFoVs_2;
// System.Collections.Generic.Dictionary`2<UnityEngine.Camera/StereoscopicEye,System.Single> Vuforia.StereoProjMatrixStore::mCurrentVerticalFoVs
Dictionary_2_t317574578 * ___mCurrentVerticalFoVs_3;
// UnityEngine.Matrix4x4 Vuforia.StereoProjMatrixStore::mSharedCullingProjectionMatrix
Matrix4x4_t1817901843 ___mSharedCullingProjectionMatrix_4;
// UnityEngine.Matrix4x4 Vuforia.StereoProjMatrixStore::mSharedCullingViewMatrix
Matrix4x4_t1817901843 ___mSharedCullingViewMatrix_5;
// UnityEngine.Matrix4x4 Vuforia.StereoProjMatrixStore::mLeftEyeOffsetMatrix
Matrix4x4_t1817901843 ___mLeftEyeOffsetMatrix_6;
// UnityEngine.Matrix4x4 Vuforia.StereoProjMatrixStore::mRightEyeOffsetMatrix
Matrix4x4_t1817901843 ___mRightEyeOffsetMatrix_7;
// Vuforia.StereoProjMatrixStore/Mode Vuforia.StereoProjMatrixStore::mMode
int32_t ___mMode_8;
public:
inline static int32_t get_offset_of_mCamera_0() { return static_cast<int32_t>(offsetof(StereoProjMatrixStore_t888524276, ___mCamera_0)); }
inline Camera_t4157153871 * get_mCamera_0() const { return ___mCamera_0; }
inline Camera_t4157153871 ** get_address_of_mCamera_0() { return &___mCamera_0; }
inline void set_mCamera_0(Camera_t4157153871 * value)
{
___mCamera_0 = value;
Il2CppCodeGenWriteBarrier((&___mCamera_0), value);
}
inline static int32_t get_offset_of_mProjectionMatrices_1() { return static_cast<int32_t>(offsetof(StereoProjMatrixStore_t888524276, ___mProjectionMatrices_1)); }
inline Dictionary_2_t738209647 * get_mProjectionMatrices_1() const { return ___mProjectionMatrices_1; }
inline Dictionary_2_t738209647 ** get_address_of_mProjectionMatrices_1() { return &___mProjectionMatrices_1; }
inline void set_mProjectionMatrices_1(Dictionary_2_t738209647 * value)
{
___mProjectionMatrices_1 = value;
Il2CppCodeGenWriteBarrier((&___mProjectionMatrices_1), value);
}
inline static int32_t get_offset_of_mAppliedVerticalFoVs_2() { return static_cast<int32_t>(offsetof(StereoProjMatrixStore_t888524276, ___mAppliedVerticalFoVs_2)); }
inline Dictionary_2_t317574578 * get_mAppliedVerticalFoVs_2() const { return ___mAppliedVerticalFoVs_2; }
inline Dictionary_2_t317574578 ** get_address_of_mAppliedVerticalFoVs_2() { return &___mAppliedVerticalFoVs_2; }
inline void set_mAppliedVerticalFoVs_2(Dictionary_2_t317574578 * value)
{
___mAppliedVerticalFoVs_2 = value;
Il2CppCodeGenWriteBarrier((&___mAppliedVerticalFoVs_2), value);
}
inline static int32_t get_offset_of_mCurrentVerticalFoVs_3() { return static_cast<int32_t>(offsetof(StereoProjMatrixStore_t888524276, ___mCurrentVerticalFoVs_3)); }
inline Dictionary_2_t317574578 * get_mCurrentVerticalFoVs_3() const { return ___mCurrentVerticalFoVs_3; }
inline Dictionary_2_t317574578 ** get_address_of_mCurrentVerticalFoVs_3() { return &___mCurrentVerticalFoVs_3; }
inline void set_mCurrentVerticalFoVs_3(Dictionary_2_t317574578 * value)
{
___mCurrentVerticalFoVs_3 = value;
Il2CppCodeGenWriteBarrier((&___mCurrentVerticalFoVs_3), value);
}
inline static int32_t get_offset_of_mSharedCullingProjectionMatrix_4() { return static_cast<int32_t>(offsetof(StereoProjMatrixStore_t888524276, ___mSharedCullingProjectionMatrix_4)); }
inline Matrix4x4_t1817901843 get_mSharedCullingProjectionMatrix_4() const { return ___mSharedCullingProjectionMatrix_4; }
inline Matrix4x4_t1817901843 * get_address_of_mSharedCullingProjectionMatrix_4() { return &___mSharedCullingProjectionMatrix_4; }
inline void set_mSharedCullingProjectionMatrix_4(Matrix4x4_t1817901843 value)
{
___mSharedCullingProjectionMatrix_4 = value;
}
inline static int32_t get_offset_of_mSharedCullingViewMatrix_5() { return static_cast<int32_t>(offsetof(StereoProjMatrixStore_t888524276, ___mSharedCullingViewMatrix_5)); }
inline Matrix4x4_t1817901843 get_mSharedCullingViewMatrix_5() const { return ___mSharedCullingViewMatrix_5; }
inline Matrix4x4_t1817901843 * get_address_of_mSharedCullingViewMatrix_5() { return &___mSharedCullingViewMatrix_5; }
inline void set_mSharedCullingViewMatrix_5(Matrix4x4_t1817901843 value)
{
___mSharedCullingViewMatrix_5 = value;
}
inline static int32_t get_offset_of_mLeftEyeOffsetMatrix_6() { return static_cast<int32_t>(offsetof(StereoProjMatrixStore_t888524276, ___mLeftEyeOffsetMatrix_6)); }
inline Matrix4x4_t1817901843 get_mLeftEyeOffsetMatrix_6() const { return ___mLeftEyeOffsetMatrix_6; }
inline Matrix4x4_t1817901843 * get_address_of_mLeftEyeOffsetMatrix_6() { return &___mLeftEyeOffsetMatrix_6; }
inline void set_mLeftEyeOffsetMatrix_6(Matrix4x4_t1817901843 value)
{
___mLeftEyeOffsetMatrix_6 = value;
}
inline static int32_t get_offset_of_mRightEyeOffsetMatrix_7() { return static_cast<int32_t>(offsetof(StereoProjMatrixStore_t888524276, ___mRightEyeOffsetMatrix_7)); }
inline Matrix4x4_t1817901843 get_mRightEyeOffsetMatrix_7() const { return ___mRightEyeOffsetMatrix_7; }
inline Matrix4x4_t1817901843 * get_address_of_mRightEyeOffsetMatrix_7() { return &___mRightEyeOffsetMatrix_7; }
inline void set_mRightEyeOffsetMatrix_7(Matrix4x4_t1817901843 value)
{
___mRightEyeOffsetMatrix_7 = value;
}
inline static int32_t get_offset_of_mMode_8() { return static_cast<int32_t>(offsetof(StereoProjMatrixStore_t888524276, ___mMode_8)); }
inline int32_t get_mMode_8() const { return ___mMode_8; }
inline int32_t* get_address_of_mMode_8() { return &___mMode_8; }
inline void set_mMode_8(int32_t value)
{
___mMode_8 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // STEREOPROJMATRIXSTORE_T888524276_H
#ifndef MODELTARGETIMPL_T417568536_H
#define MODELTARGETIMPL_T417568536_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// Vuforia.ModelTargetImpl
struct ModelTargetImpl_t417568536 : public DataSetObjectTargetImpl_t2835536742
{
public:
// Vuforia.IBoundingBox Vuforia.ModelTargetImpl::mBoundingBoxImpl
RuntimeObject* ___mBoundingBoxImpl_5;
// System.Collections.Generic.Dictionary`2<System.Int32,Vuforia.GuideView> Vuforia.ModelTargetImpl::mLoadedGuideViews
Dictionary_2_t3700162136 * ___mLoadedGuideViews_6;
public:
inline static int32_t get_offset_of_mBoundingBoxImpl_5() { return static_cast<int32_t>(offsetof(ModelTargetImpl_t417568536, ___mBoundingBoxImpl_5)); }
inline RuntimeObject* get_mBoundingBoxImpl_5() const { return ___mBoundingBoxImpl_5; }
inline RuntimeObject** get_address_of_mBoundingBoxImpl_5() { return &___mBoundingBoxImpl_5; }
inline void set_mBoundingBoxImpl_5(RuntimeObject* value)
{
___mBoundingBoxImpl_5 = value;
Il2CppCodeGenWriteBarrier((&___mBoundingBoxImpl_5), value);
}
inline static int32_t get_offset_of_mLoadedGuideViews_6() { return static_cast<int32_t>(offsetof(ModelTargetImpl_t417568536, ___mLoadedGuideViews_6)); }
inline Dictionary_2_t3700162136 * get_mLoadedGuideViews_6() const { return ___mLoadedGuideViews_6; }
inline Dictionary_2_t3700162136 ** get_address_of_mLoadedGuideViews_6() { return &___mLoadedGuideViews_6; }
inline void set_mLoadedGuideViews_6(Dictionary_2_t3700162136 * value)
{
___mLoadedGuideViews_6 = value;
Il2CppCodeGenWriteBarrier((&___mLoadedGuideViews_6), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // MODELTARGETIMPL_T417568536_H
#ifndef SOLVERPARTICLEDELEGATE_T4224278369_H
#define SOLVERPARTICLEDELEGATE_T4224278369_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// Thinksquirrel.Fluvio.Internal.SolverParticleDelegate
struct SolverParticleDelegate_t4224278369 : public MulticastDelegate_t
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // SOLVERPARTICLEDELEGATE_T4224278369_H
#ifndef BEHAVIOUR_T1437897464_H
#define BEHAVIOUR_T1437897464_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// UnityEngine.Behaviour
struct Behaviour_t1437897464 : public Component_t1923634451
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // BEHAVIOUR_T1437897464_H
#ifndef SOLVERPARTICLEPAIRDELEGATE_T2332887997_H
#define SOLVERPARTICLEPAIRDELEGATE_T2332887997_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// Thinksquirrel.Fluvio.Internal.SolverParticlePairDelegate
struct SolverParticlePairDelegate_t2332887997 : public MulticastDelegate_t
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // SOLVERPARTICLEPAIRDELEGATE_T2332887997_H
#ifndef PARALLELACTION_T3477057985_H
#define PARALLELACTION_T3477057985_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// Thinksquirrel.Fluvio.Internal.Threading.ParallelAction
struct ParallelAction_t3477057985 : public MulticastDelegate_t
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // PARALLELACTION_T3477057985_H
#ifndef VRDEVICECAMERACONFIGURATION_T3015543037_H
#define VRDEVICECAMERACONFIGURATION_T3015543037_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// Vuforia.VRDeviceCameraConfiguration
struct VRDeviceCameraConfiguration_t3015543037 : public BaseCameraConfiguration_t3118151474
{
public:
// UnityEngine.Camera Vuforia.VRDeviceCameraConfiguration::mCamera
Camera_t4157153871 * ___mCamera_11;
// Vuforia.StereoProjMatrixStore Vuforia.VRDeviceCameraConfiguration::mMatrixStore
StereoProjMatrixStore_t888524276 * ___mMatrixStore_12;
// UnityEngine.Matrix4x4 Vuforia.VRDeviceCameraConfiguration::mLeftMatrixUsedForVBPlacement
Matrix4x4_t1817901843 ___mLeftMatrixUsedForVBPlacement_13;
// System.Single Vuforia.VRDeviceCameraConfiguration::mLastAppliedNearClipPlane
float ___mLastAppliedNearClipPlane_14;
// System.Single Vuforia.VRDeviceCameraConfiguration::mLastAppliedFarClipPlane
float ___mLastAppliedFarClipPlane_15;
// System.Single Vuforia.VRDeviceCameraConfiguration::mMaxDepthForVideoBackground
float ___mMaxDepthForVideoBackground_16;
// System.Single Vuforia.VRDeviceCameraConfiguration::mMinDepthForVideoBackground
float ___mMinDepthForVideoBackground_17;
// System.Int32 Vuforia.VRDeviceCameraConfiguration::mScreenWidth
int32_t ___mScreenWidth_18;
// System.Int32 Vuforia.VRDeviceCameraConfiguration::mScreenHeight
int32_t ___mScreenHeight_19;
// System.Single Vuforia.VRDeviceCameraConfiguration::mStereoDepth
float ___mStereoDepth_20;
// System.Boolean Vuforia.VRDeviceCameraConfiguration::mResetMatrix
bool ___mResetMatrix_21;
// System.Collections.Generic.Dictionary`2<UnityEngine.Camera/StereoscopicEye,UnityEngine.Vector2> Vuforia.VRDeviceCameraConfiguration::mVuforiaFrustumSkew
Dictionary_2_t1076537327 * ___mVuforiaFrustumSkew_22;
// System.Collections.Generic.Dictionary`2<UnityEngine.Camera/StereoscopicEye,UnityEngine.Vector2> Vuforia.VRDeviceCameraConfiguration::mCenterToEyeAxis
Dictionary_2_t1076537327 * ___mCenterToEyeAxis_23;
// Vuforia.VRDeviceController Vuforia.VRDeviceCameraConfiguration::mVrDeviceController
VRDeviceController_t3863472269 * ___mVrDeviceController_24;
public:
inline static int32_t get_offset_of_mCamera_11() { return static_cast<int32_t>(offsetof(VRDeviceCameraConfiguration_t3015543037, ___mCamera_11)); }
inline Camera_t4157153871 * get_mCamera_11() const { return ___mCamera_11; }
inline Camera_t4157153871 ** get_address_of_mCamera_11() { return &___mCamera_11; }
inline void set_mCamera_11(Camera_t4157153871 * value)
{
___mCamera_11 = value;
Il2CppCodeGenWriteBarrier((&___mCamera_11), value);
}
inline static int32_t get_offset_of_mMatrixStore_12() { return static_cast<int32_t>(offsetof(VRDeviceCameraConfiguration_t3015543037, ___mMatrixStore_12)); }
inline StereoProjMatrixStore_t888524276 * get_mMatrixStore_12() const { return ___mMatrixStore_12; }
inline StereoProjMatrixStore_t888524276 ** get_address_of_mMatrixStore_12() { return &___mMatrixStore_12; }
inline void set_mMatrixStore_12(StereoProjMatrixStore_t888524276 * value)
{
___mMatrixStore_12 = value;
Il2CppCodeGenWriteBarrier((&___mMatrixStore_12), value);
}
inline static int32_t get_offset_of_mLeftMatrixUsedForVBPlacement_13() { return static_cast<int32_t>(offsetof(VRDeviceCameraConfiguration_t3015543037, ___mLeftMatrixUsedForVBPlacement_13)); }
inline Matrix4x4_t1817901843 get_mLeftMatrixUsedForVBPlacement_13() const { return ___mLeftMatrixUsedForVBPlacement_13; }
inline Matrix4x4_t1817901843 * get_address_of_mLeftMatrixUsedForVBPlacement_13() { return &___mLeftMatrixUsedForVBPlacement_13; }
inline void set_mLeftMatrixUsedForVBPlacement_13(Matrix4x4_t1817901843 value)
{
___mLeftMatrixUsedForVBPlacement_13 = value;
}
inline static int32_t get_offset_of_mLastAppliedNearClipPlane_14() { return static_cast<int32_t>(offsetof(VRDeviceCameraConfiguration_t3015543037, ___mLastAppliedNearClipPlane_14)); }
inline float get_mLastAppliedNearClipPlane_14() const { return ___mLastAppliedNearClipPlane_14; }
inline float* get_address_of_mLastAppliedNearClipPlane_14() { return &___mLastAppliedNearClipPlane_14; }
inline void set_mLastAppliedNearClipPlane_14(float value)
{
___mLastAppliedNearClipPlane_14 = value;
}
inline static int32_t get_offset_of_mLastAppliedFarClipPlane_15() { return static_cast<int32_t>(offsetof(VRDeviceCameraConfiguration_t3015543037, ___mLastAppliedFarClipPlane_15)); }
inline float get_mLastAppliedFarClipPlane_15() const { return ___mLastAppliedFarClipPlane_15; }
inline float* get_address_of_mLastAppliedFarClipPlane_15() { return &___mLastAppliedFarClipPlane_15; }
inline void set_mLastAppliedFarClipPlane_15(float value)
{
___mLastAppliedFarClipPlane_15 = value;
}
inline static int32_t get_offset_of_mMaxDepthForVideoBackground_16() { return static_cast<int32_t>(offsetof(VRDeviceCameraConfiguration_t3015543037, ___mMaxDepthForVideoBackground_16)); }
inline float get_mMaxDepthForVideoBackground_16() const { return ___mMaxDepthForVideoBackground_16; }
inline float* get_address_of_mMaxDepthForVideoBackground_16() { return &___mMaxDepthForVideoBackground_16; }
inline void set_mMaxDepthForVideoBackground_16(float value)
{
___mMaxDepthForVideoBackground_16 = value;
}
inline static int32_t get_offset_of_mMinDepthForVideoBackground_17() { return static_cast<int32_t>(offsetof(VRDeviceCameraConfiguration_t3015543037, ___mMinDepthForVideoBackground_17)); }
inline float get_mMinDepthForVideoBackground_17() const { return ___mMinDepthForVideoBackground_17; }
inline float* get_address_of_mMinDepthForVideoBackground_17() { return &___mMinDepthForVideoBackground_17; }
inline void set_mMinDepthForVideoBackground_17(float value)
{
___mMinDepthForVideoBackground_17 = value;
}
inline static int32_t get_offset_of_mScreenWidth_18() { return static_cast<int32_t>(offsetof(VRDeviceCameraConfiguration_t3015543037, ___mScreenWidth_18)); }
inline int32_t get_mScreenWidth_18() const { return ___mScreenWidth_18; }
inline int32_t* get_address_of_mScreenWidth_18() { return &___mScreenWidth_18; }
inline void set_mScreenWidth_18(int32_t value)
{
___mScreenWidth_18 = value;
}
inline static int32_t get_offset_of_mScreenHeight_19() { return static_cast<int32_t>(offsetof(VRDeviceCameraConfiguration_t3015543037, ___mScreenHeight_19)); }
inline int32_t get_mScreenHeight_19() const { return ___mScreenHeight_19; }
inline int32_t* get_address_of_mScreenHeight_19() { return &___mScreenHeight_19; }
inline void set_mScreenHeight_19(int32_t value)
{
___mScreenHeight_19 = value;
}
inline static int32_t get_offset_of_mStereoDepth_20() { return static_cast<int32_t>(offsetof(VRDeviceCameraConfiguration_t3015543037, ___mStereoDepth_20)); }
inline float get_mStereoDepth_20() const { return ___mStereoDepth_20; }
inline float* get_address_of_mStereoDepth_20() { return &___mStereoDepth_20; }
inline void set_mStereoDepth_20(float value)
{
___mStereoDepth_20 = value;
}
inline static int32_t get_offset_of_mResetMatrix_21() { return static_cast<int32_t>(offsetof(VRDeviceCameraConfiguration_t3015543037, ___mResetMatrix_21)); }
inline bool get_mResetMatrix_21() const { return ___mResetMatrix_21; }
inline bool* get_address_of_mResetMatrix_21() { return &___mResetMatrix_21; }
inline void set_mResetMatrix_21(bool value)
{
___mResetMatrix_21 = value;
}
inline static int32_t get_offset_of_mVuforiaFrustumSkew_22() { return static_cast<int32_t>(offsetof(VRDeviceCameraConfiguration_t3015543037, ___mVuforiaFrustumSkew_22)); }
inline Dictionary_2_t1076537327 * get_mVuforiaFrustumSkew_22() const { return ___mVuforiaFrustumSkew_22; }
inline Dictionary_2_t1076537327 ** get_address_of_mVuforiaFrustumSkew_22() { return &___mVuforiaFrustumSkew_22; }
inline void set_mVuforiaFrustumSkew_22(Dictionary_2_t1076537327 * value)
{
___mVuforiaFrustumSkew_22 = value;
Il2CppCodeGenWriteBarrier((&___mVuforiaFrustumSkew_22), value);
}
inline static int32_t get_offset_of_mCenterToEyeAxis_23() { return static_cast<int32_t>(offsetof(VRDeviceCameraConfiguration_t3015543037, ___mCenterToEyeAxis_23)); }
inline Dictionary_2_t1076537327 * get_mCenterToEyeAxis_23() const { return ___mCenterToEyeAxis_23; }
inline Dictionary_2_t1076537327 ** get_address_of_mCenterToEyeAxis_23() { return &___mCenterToEyeAxis_23; }
inline void set_mCenterToEyeAxis_23(Dictionary_2_t1076537327 * value)
{
___mCenterToEyeAxis_23 = value;
Il2CppCodeGenWriteBarrier((&___mCenterToEyeAxis_23), value);
}
inline static int32_t get_offset_of_mVrDeviceController_24() { return static_cast<int32_t>(offsetof(VRDeviceCameraConfiguration_t3015543037, ___mVrDeviceController_24)); }
inline VRDeviceController_t3863472269 * get_mVrDeviceController_24() const { return ___mVrDeviceController_24; }
inline VRDeviceController_t3863472269 ** get_address_of_mVrDeviceController_24() { return &___mVrDeviceController_24; }
inline void set_mVrDeviceController_24(VRDeviceController_t3863472269 * value)
{
___mVrDeviceController_24 = value;
Il2CppCodeGenWriteBarrier((&___mVrDeviceController_24), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // VRDEVICECAMERACONFIGURATION_T3015543037_H
#ifndef VUFORIAVRDEVICECAMERACONFIGURATION_T3308462389_H
#define VUFORIAVRDEVICECAMERACONFIGURATION_T3308462389_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// Vuforia.VuforiaVRDeviceCameraConfiguration
struct VuforiaVRDeviceCameraConfiguration_t3308462389 : public VRDeviceCameraConfiguration_t3015543037
{
public:
// System.Single Vuforia.VuforiaVRDeviceCameraConfiguration::mStereoOffset
float ___mStereoOffset_26;
// System.Boolean Vuforia.VuforiaVRDeviceCameraConfiguration::mDelayedVideoBackgroundEnabledChanged
bool ___mDelayedVideoBackgroundEnabledChanged_27;
public:
inline static int32_t get_offset_of_mStereoOffset_26() { return static_cast<int32_t>(offsetof(VuforiaVRDeviceCameraConfiguration_t3308462389, ___mStereoOffset_26)); }
inline float get_mStereoOffset_26() const { return ___mStereoOffset_26; }
inline float* get_address_of_mStereoOffset_26() { return &___mStereoOffset_26; }
inline void set_mStereoOffset_26(float value)
{
___mStereoOffset_26 = value;
}
inline static int32_t get_offset_of_mDelayedVideoBackgroundEnabledChanged_27() { return static_cast<int32_t>(offsetof(VuforiaVRDeviceCameraConfiguration_t3308462389, ___mDelayedVideoBackgroundEnabledChanged_27)); }
inline bool get_mDelayedVideoBackgroundEnabledChanged_27() const { return ___mDelayedVideoBackgroundEnabledChanged_27; }
inline bool* get_address_of_mDelayedVideoBackgroundEnabledChanged_27() { return &___mDelayedVideoBackgroundEnabledChanged_27; }
inline void set_mDelayedVideoBackgroundEnabledChanged_27(bool value)
{
___mDelayedVideoBackgroundEnabledChanged_27 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // VUFORIAVRDEVICECAMERACONFIGURATION_T3308462389_H
#ifndef MONOBEHAVIOUR_T3962482529_H
#define MONOBEHAVIOUR_T3962482529_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// UnityEngine.MonoBehaviour
struct MonoBehaviour_t3962482529 : public Behaviour_t1437897464
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // MONOBEHAVIOUR_T3962482529_H
#ifndef EXTERNALVRDEVICECAMERACONFIGURATION_T152468891_H
#define EXTERNALVRDEVICECAMERACONFIGURATION_T152468891_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// Vuforia.ExternalVRDeviceCameraConfiguration
struct ExternalVRDeviceCameraConfiguration_t152468891 : public VRDeviceCameraConfiguration_t3015543037
{
public:
// Vuforia.VuforiaARController/WorldCenterMode Vuforia.ExternalVRDeviceCameraConfiguration::mLastWorldCenterMode
int32_t ___mLastWorldCenterMode_26;
public:
inline static int32_t get_offset_of_mLastWorldCenterMode_26() { return static_cast<int32_t>(offsetof(ExternalVRDeviceCameraConfiguration_t152468891, ___mLastWorldCenterMode_26)); }
inline int32_t get_mLastWorldCenterMode_26() const { return ___mLastWorldCenterMode_26; }
inline int32_t* get_address_of_mLastWorldCenterMode_26() { return &___mLastWorldCenterMode_26; }
inline void set_mLastWorldCenterMode_26(int32_t value)
{
___mLastWorldCenterMode_26 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // EXTERNALVRDEVICECAMERACONFIGURATION_T152468891_H
#ifndef DEFAULTINITIALIZATIONERRORHANDLERPLACEHOLDER_T270221276_H
#define DEFAULTINITIALIZATIONERRORHANDLERPLACEHOLDER_T270221276_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// DefaultInitializationErrorHandlerPlaceHolder
struct DefaultInitializationErrorHandlerPlaceHolder_t270221276 : public MonoBehaviour_t3962482529
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // DEFAULTINITIALIZATIONERRORHANDLERPLACEHOLDER_T270221276_H
#ifndef GUIDEVIEWCAMERABEHAVIOUR_T721959276_H
#define GUIDEVIEWCAMERABEHAVIOUR_T721959276_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// Vuforia.GuideViewCameraBehaviour
struct GuideViewCameraBehaviour_t721959276 : public MonoBehaviour_t3962482529
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // GUIDEVIEWCAMERABEHAVIOUR_T721959276_H
#ifndef GUIDEVIEWRENDERINGBEHAVIOUR_T333084580_H
#define GUIDEVIEWRENDERINGBEHAVIOUR_T333084580_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// Vuforia.GuideViewRenderingBehaviour
struct GuideViewRenderingBehaviour_t333084580 : public MonoBehaviour_t3962482529
{
public:
// System.Single Vuforia.GuideViewRenderingBehaviour::guideReappearanceDelay
float ___guideReappearanceDelay_2;
// Vuforia.ModelTargetBehaviour Vuforia.GuideViewRenderingBehaviour::mTrackedTarget
ModelTargetBehaviour_t712978329 * ___mTrackedTarget_5;
// Vuforia.ModelTargetBehaviour/GuideViewDisplayMode Vuforia.GuideViewRenderingBehaviour::mGuideViewDisplayMode
int32_t ___mGuideViewDisplayMode_6;
// Vuforia.GuideView Vuforia.GuideViewRenderingBehaviour::mGuideView
GuideView_t516481509 * ___mGuideView_7;
// System.Boolean Vuforia.GuideViewRenderingBehaviour::mGuideViewInitialized
bool ___mGuideViewInitialized_8;
// System.Collections.IEnumerator Vuforia.GuideViewRenderingBehaviour::mShowGuideViewCoroutine
RuntimeObject* ___mShowGuideViewCoroutine_9;
// UnityEngine.GameObject Vuforia.GuideViewRenderingBehaviour::mGuideViewGameObject
GameObject_t1113636619 * ___mGuideViewGameObject_10;
// System.Boolean Vuforia.GuideViewRenderingBehaviour::mGuideViewShown
bool ___mGuideViewShown_11;
// UnityEngine.DepthTextureMode Vuforia.GuideViewRenderingBehaviour::mPrevDepthTextureMode
int32_t ___mPrevDepthTextureMode_12;
public:
inline static int32_t get_offset_of_guideReappearanceDelay_2() { return static_cast<int32_t>(offsetof(GuideViewRenderingBehaviour_t333084580, ___guideReappearanceDelay_2)); }
inline float get_guideReappearanceDelay_2() const { return ___guideReappearanceDelay_2; }
inline float* get_address_of_guideReappearanceDelay_2() { return &___guideReappearanceDelay_2; }
inline void set_guideReappearanceDelay_2(float value)
{
___guideReappearanceDelay_2 = value;
}
inline static int32_t get_offset_of_mTrackedTarget_5() { return static_cast<int32_t>(offsetof(GuideViewRenderingBehaviour_t333084580, ___mTrackedTarget_5)); }
inline ModelTargetBehaviour_t712978329 * get_mTrackedTarget_5() const { return ___mTrackedTarget_5; }
inline ModelTargetBehaviour_t712978329 ** get_address_of_mTrackedTarget_5() { return &___mTrackedTarget_5; }
inline void set_mTrackedTarget_5(ModelTargetBehaviour_t712978329 * value)
{
___mTrackedTarget_5 = value;
Il2CppCodeGenWriteBarrier((&___mTrackedTarget_5), value);
}
inline static int32_t get_offset_of_mGuideViewDisplayMode_6() { return static_cast<int32_t>(offsetof(GuideViewRenderingBehaviour_t333084580, ___mGuideViewDisplayMode_6)); }
inline int32_t get_mGuideViewDisplayMode_6() const { return ___mGuideViewDisplayMode_6; }
inline int32_t* get_address_of_mGuideViewDisplayMode_6() { return &___mGuideViewDisplayMode_6; }
inline void set_mGuideViewDisplayMode_6(int32_t value)
{
___mGuideViewDisplayMode_6 = value;
}
inline static int32_t get_offset_of_mGuideView_7() { return static_cast<int32_t>(offsetof(GuideViewRenderingBehaviour_t333084580, ___mGuideView_7)); }
inline GuideView_t516481509 * get_mGuideView_7() const { return ___mGuideView_7; }
inline GuideView_t516481509 ** get_address_of_mGuideView_7() { return &___mGuideView_7; }
inline void set_mGuideView_7(GuideView_t516481509 * value)
{
___mGuideView_7 = value;
Il2CppCodeGenWriteBarrier((&___mGuideView_7), value);
}
inline static int32_t get_offset_of_mGuideViewInitialized_8() { return static_cast<int32_t>(offsetof(GuideViewRenderingBehaviour_t333084580, ___mGuideViewInitialized_8)); }
inline bool get_mGuideViewInitialized_8() const { return ___mGuideViewInitialized_8; }
inline bool* get_address_of_mGuideViewInitialized_8() { return &___mGuideViewInitialized_8; }
inline void set_mGuideViewInitialized_8(bool value)
{
___mGuideViewInitialized_8 = value;
}
inline static int32_t get_offset_of_mShowGuideViewCoroutine_9() { return static_cast<int32_t>(offsetof(GuideViewRenderingBehaviour_t333084580, ___mShowGuideViewCoroutine_9)); }
inline RuntimeObject* get_mShowGuideViewCoroutine_9() const { return ___mShowGuideViewCoroutine_9; }
inline RuntimeObject** get_address_of_mShowGuideViewCoroutine_9() { return &___mShowGuideViewCoroutine_9; }
inline void set_mShowGuideViewCoroutine_9(RuntimeObject* value)
{
___mShowGuideViewCoroutine_9 = value;
Il2CppCodeGenWriteBarrier((&___mShowGuideViewCoroutine_9), value);
}
inline static int32_t get_offset_of_mGuideViewGameObject_10() { return static_cast<int32_t>(offsetof(GuideViewRenderingBehaviour_t333084580, ___mGuideViewGameObject_10)); }
inline GameObject_t1113636619 * get_mGuideViewGameObject_10() const { return ___mGuideViewGameObject_10; }
inline GameObject_t1113636619 ** get_address_of_mGuideViewGameObject_10() { return &___mGuideViewGameObject_10; }
inline void set_mGuideViewGameObject_10(GameObject_t1113636619 * value)
{
___mGuideViewGameObject_10 = value;
Il2CppCodeGenWriteBarrier((&___mGuideViewGameObject_10), value);
}
inline static int32_t get_offset_of_mGuideViewShown_11() { return static_cast<int32_t>(offsetof(GuideViewRenderingBehaviour_t333084580, ___mGuideViewShown_11)); }
inline bool get_mGuideViewShown_11() const { return ___mGuideViewShown_11; }
inline bool* get_address_of_mGuideViewShown_11() { return &___mGuideViewShown_11; }
inline void set_mGuideViewShown_11(bool value)
{
___mGuideViewShown_11 = value;
}
inline static int32_t get_offset_of_mPrevDepthTextureMode_12() { return static_cast<int32_t>(offsetof(GuideViewRenderingBehaviour_t333084580, ___mPrevDepthTextureMode_12)); }
inline int32_t get_mPrevDepthTextureMode_12() const { return ___mPrevDepthTextureMode_12; }
inline int32_t* get_address_of_mPrevDepthTextureMode_12() { return &___mPrevDepthTextureMode_12; }
inline void set_mPrevDepthTextureMode_12(int32_t value)
{
___mPrevDepthTextureMode_12 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // GUIDEVIEWRENDERINGBEHAVIOUR_T333084580_H
#ifndef GUIDEVIEW3DBEHAVIOUR_T1129627381_H
#define GUIDEVIEW3DBEHAVIOUR_T1129627381_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// Vuforia.GuideView3DBehaviour
struct GuideView3DBehaviour_t1129627381 : public MonoBehaviour_t3962482529
{
public:
// Vuforia.GuideView Vuforia.GuideView3DBehaviour::mCurrentGuideView
GuideView_t516481509 * ___mCurrentGuideView_2;
public:
inline static int32_t get_offset_of_mCurrentGuideView_2() { return static_cast<int32_t>(offsetof(GuideView3DBehaviour_t1129627381, ___mCurrentGuideView_2)); }
inline GuideView_t516481509 * get_mCurrentGuideView_2() const { return ___mCurrentGuideView_2; }
inline GuideView_t516481509 ** get_address_of_mCurrentGuideView_2() { return &___mCurrentGuideView_2; }
inline void set_mCurrentGuideView_2(GuideView_t516481509 * value)
{
___mCurrentGuideView_2 = value;
Il2CppCodeGenWriteBarrier((&___mCurrentGuideView_2), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // GUIDEVIEW3DBEHAVIOUR_T1129627381_H
#ifndef GUIDEVIEW2DBEHAVIOUR_T1196801781_H
#define GUIDEVIEW2DBEHAVIOUR_T1196801781_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// Vuforia.GuideView2DBehaviour
struct GuideView2DBehaviour_t1196801781 : public MonoBehaviour_t3962482529
{
public:
// System.Single Vuforia.GuideView2DBehaviour::mCameraAspect
float ___mCameraAspect_2;
// System.Single Vuforia.GuideView2DBehaviour::mCameraFOV
float ___mCameraFOV_3;
// System.Single Vuforia.GuideView2DBehaviour::mCameraNearPlane
float ___mCameraNearPlane_4;
// UnityEngine.Texture2D Vuforia.GuideView2DBehaviour::mGuideViewTexture
Texture2D_t3840446185 * ___mGuideViewTexture_5;
public:
inline static int32_t get_offset_of_mCameraAspect_2() { return static_cast<int32_t>(offsetof(GuideView2DBehaviour_t1196801781, ___mCameraAspect_2)); }
inline float get_mCameraAspect_2() const { return ___mCameraAspect_2; }
inline float* get_address_of_mCameraAspect_2() { return &___mCameraAspect_2; }
inline void set_mCameraAspect_2(float value)
{
___mCameraAspect_2 = value;
}
inline static int32_t get_offset_of_mCameraFOV_3() { return static_cast<int32_t>(offsetof(GuideView2DBehaviour_t1196801781, ___mCameraFOV_3)); }
inline float get_mCameraFOV_3() const { return ___mCameraFOV_3; }
inline float* get_address_of_mCameraFOV_3() { return &___mCameraFOV_3; }
inline void set_mCameraFOV_3(float value)
{
___mCameraFOV_3 = value;
}
inline static int32_t get_offset_of_mCameraNearPlane_4() { return static_cast<int32_t>(offsetof(GuideView2DBehaviour_t1196801781, ___mCameraNearPlane_4)); }
inline float get_mCameraNearPlane_4() const { return ___mCameraNearPlane_4; }
inline float* get_address_of_mCameraNearPlane_4() { return &___mCameraNearPlane_4; }
inline void set_mCameraNearPlane_4(float value)
{
___mCameraNearPlane_4 = value;
}
inline static int32_t get_offset_of_mGuideViewTexture_5() { return static_cast<int32_t>(offsetof(GuideView2DBehaviour_t1196801781, ___mGuideViewTexture_5)); }
inline Texture2D_t3840446185 * get_mGuideViewTexture_5() const { return ___mGuideViewTexture_5; }
inline Texture2D_t3840446185 ** get_address_of_mGuideViewTexture_5() { return &___mGuideViewTexture_5; }
inline void set_mGuideViewTexture_5(Texture2D_t3840446185 * value)
{
___mGuideViewTexture_5 = value;
Il2CppCodeGenWriteBarrier((&___mGuideViewTexture_5), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // GUIDEVIEW2DBEHAVIOUR_T1196801781_H
#ifndef FLUVIOMONOBEHAVIOURBASE_T869152428_H
#define FLUVIOMONOBEHAVIOURBASE_T869152428_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// Thinksquirrel.Fluvio.FluvioMonoBehaviourBase
struct FluvioMonoBehaviourBase_t869152428 : public MonoBehaviour_t3962482529
{
public:
// System.Boolean Thinksquirrel.Fluvio.FluvioMonoBehaviourBase::m_CreatedObj
bool ___m_CreatedObj_2;
// System.Boolean Thinksquirrel.Fluvio.FluvioMonoBehaviourBase::m_DestroyedObj
bool ___m_DestroyedObj_3;
// System.Boolean Thinksquirrel.Fluvio.FluvioMonoBehaviourBase::m_EditorFoldout
bool ___m_EditorFoldout_4;
public:
inline static int32_t get_offset_of_m_CreatedObj_2() { return static_cast<int32_t>(offsetof(FluvioMonoBehaviourBase_t869152428, ___m_CreatedObj_2)); }
inline bool get_m_CreatedObj_2() const { return ___m_CreatedObj_2; }
inline bool* get_address_of_m_CreatedObj_2() { return &___m_CreatedObj_2; }
inline void set_m_CreatedObj_2(bool value)
{
___m_CreatedObj_2 = value;
}
inline static int32_t get_offset_of_m_DestroyedObj_3() { return static_cast<int32_t>(offsetof(FluvioMonoBehaviourBase_t869152428, ___m_DestroyedObj_3)); }
inline bool get_m_DestroyedObj_3() const { return ___m_DestroyedObj_3; }
inline bool* get_address_of_m_DestroyedObj_3() { return &___m_DestroyedObj_3; }
inline void set_m_DestroyedObj_3(bool value)
{
___m_DestroyedObj_3 = value;
}
inline static int32_t get_offset_of_m_EditorFoldout_4() { return static_cast<int32_t>(offsetof(FluvioMonoBehaviourBase_t869152428, ___m_EditorFoldout_4)); }
inline bool get_m_EditorFoldout_4() const { return ___m_EditorFoldout_4; }
inline bool* get_address_of_m_EditorFoldout_4() { return &___m_EditorFoldout_4; }
inline void set_m_EditorFoldout_4(bool value)
{
___m_EditorFoldout_4 = value;
}
};
struct FluvioMonoBehaviourBase_t869152428_StaticFields
{
public:
// System.Action`2<Thinksquirrel.Fluvio.FluvioMonoBehaviourBase,System.Boolean> Thinksquirrel.Fluvio.FluvioMonoBehaviourBase::_onCreateDestroy
Action_2_t1004908951 * ____onCreateDestroy_5;
public:
inline static int32_t get_offset_of__onCreateDestroy_5() { return static_cast<int32_t>(offsetof(FluvioMonoBehaviourBase_t869152428_StaticFields, ____onCreateDestroy_5)); }
inline Action_2_t1004908951 * get__onCreateDestroy_5() const { return ____onCreateDestroy_5; }
inline Action_2_t1004908951 ** get_address_of__onCreateDestroy_5() { return &____onCreateDestroy_5; }
inline void set__onCreateDestroy_5(Action_2_t1004908951 * value)
{
____onCreateDestroy_5 = value;
Il2CppCodeGenWriteBarrier((&____onCreateDestroy_5), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // FLUVIOMONOBEHAVIOURBASE_T869152428_H
#ifndef DEFAULTINITIALIZATIONERRORHANDLERINTERNAL_T2721934644_H
#define DEFAULTINITIALIZATIONERRORHANDLERINTERNAL_T2721934644_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// DefaultInitializationErrorHandlerInternal
struct DefaultInitializationErrorHandlerInternal_t2721934644 : public MonoBehaviour_t3962482529
{
public:
// System.String DefaultInitializationErrorHandlerInternal::mErrorText
String_t* ___mErrorText_2;
// System.Boolean DefaultInitializationErrorHandlerInternal::mErrorOccurred
bool ___mErrorOccurred_3;
// UnityEngine.GUIStyle DefaultInitializationErrorHandlerInternal::bodyStyle
GUIStyle_t3956901511 * ___bodyStyle_5;
// UnityEngine.GUIStyle DefaultInitializationErrorHandlerInternal::headerStyle
GUIStyle_t3956901511 * ___headerStyle_6;
// UnityEngine.GUIStyle DefaultInitializationErrorHandlerInternal::footerStyle
GUIStyle_t3956901511 * ___footerStyle_7;
// UnityEngine.Texture2D DefaultInitializationErrorHandlerInternal::bodyTexture
Texture2D_t3840446185 * ___bodyTexture_8;
// UnityEngine.Texture2D DefaultInitializationErrorHandlerInternal::headerTexture
Texture2D_t3840446185 * ___headerTexture_9;
// UnityEngine.Texture2D DefaultInitializationErrorHandlerInternal::footerTexture
Texture2D_t3840446185 * ___footerTexture_10;
public:
inline static int32_t get_offset_of_mErrorText_2() { return static_cast<int32_t>(offsetof(DefaultInitializationErrorHandlerInternal_t2721934644, ___mErrorText_2)); }
inline String_t* get_mErrorText_2() const { return ___mErrorText_2; }
inline String_t** get_address_of_mErrorText_2() { return &___mErrorText_2; }
inline void set_mErrorText_2(String_t* value)
{
___mErrorText_2 = value;
Il2CppCodeGenWriteBarrier((&___mErrorText_2), value);
}
inline static int32_t get_offset_of_mErrorOccurred_3() { return static_cast<int32_t>(offsetof(DefaultInitializationErrorHandlerInternal_t2721934644, ___mErrorOccurred_3)); }
inline bool get_mErrorOccurred_3() const { return ___mErrorOccurred_3; }
inline bool* get_address_of_mErrorOccurred_3() { return &___mErrorOccurred_3; }
inline void set_mErrorOccurred_3(bool value)
{
___mErrorOccurred_3 = value;
}
inline static int32_t get_offset_of_bodyStyle_5() { return static_cast<int32_t>(offsetof(DefaultInitializationErrorHandlerInternal_t2721934644, ___bodyStyle_5)); }
inline GUIStyle_t3956901511 * get_bodyStyle_5() const { return ___bodyStyle_5; }
inline GUIStyle_t3956901511 ** get_address_of_bodyStyle_5() { return &___bodyStyle_5; }
inline void set_bodyStyle_5(GUIStyle_t3956901511 * value)
{
___bodyStyle_5 = value;
Il2CppCodeGenWriteBarrier((&___bodyStyle_5), value);
}
inline static int32_t get_offset_of_headerStyle_6() { return static_cast<int32_t>(offsetof(DefaultInitializationErrorHandlerInternal_t2721934644, ___headerStyle_6)); }
inline GUIStyle_t3956901511 * get_headerStyle_6() const { return ___headerStyle_6; }
inline GUIStyle_t3956901511 ** get_address_of_headerStyle_6() { return &___headerStyle_6; }
inline void set_headerStyle_6(GUIStyle_t3956901511 * value)
{
___headerStyle_6 = value;
Il2CppCodeGenWriteBarrier((&___headerStyle_6), value);
}
inline static int32_t get_offset_of_footerStyle_7() { return static_cast<int32_t>(offsetof(DefaultInitializationErrorHandlerInternal_t2721934644, ___footerStyle_7)); }
inline GUIStyle_t3956901511 * get_footerStyle_7() const { return ___footerStyle_7; }
inline GUIStyle_t3956901511 ** get_address_of_footerStyle_7() { return &___footerStyle_7; }
inline void set_footerStyle_7(GUIStyle_t3956901511 * value)
{
___footerStyle_7 = value;
Il2CppCodeGenWriteBarrier((&___footerStyle_7), value);
}
inline static int32_t get_offset_of_bodyTexture_8() { return static_cast<int32_t>(offsetof(DefaultInitializationErrorHandlerInternal_t2721934644, ___bodyTexture_8)); }
inline Texture2D_t3840446185 * get_bodyTexture_8() const { return ___bodyTexture_8; }
inline Texture2D_t3840446185 ** get_address_of_bodyTexture_8() { return &___bodyTexture_8; }
inline void set_bodyTexture_8(Texture2D_t3840446185 * value)
{
___bodyTexture_8 = value;
Il2CppCodeGenWriteBarrier((&___bodyTexture_8), value);
}
inline static int32_t get_offset_of_headerTexture_9() { return static_cast<int32_t>(offsetof(DefaultInitializationErrorHandlerInternal_t2721934644, ___headerTexture_9)); }
inline Texture2D_t3840446185 * get_headerTexture_9() const { return ___headerTexture_9; }
inline Texture2D_t3840446185 ** get_address_of_headerTexture_9() { return &___headerTexture_9; }
inline void set_headerTexture_9(Texture2D_t3840446185 * value)
{
___headerTexture_9 = value;
Il2CppCodeGenWriteBarrier((&___headerTexture_9), value);
}
inline static int32_t get_offset_of_footerTexture_10() { return static_cast<int32_t>(offsetof(DefaultInitializationErrorHandlerInternal_t2721934644, ___footerTexture_10)); }
inline Texture2D_t3840446185 * get_footerTexture_10() const { return ___footerTexture_10; }
inline Texture2D_t3840446185 ** get_address_of_footerTexture_10() { return &___footerTexture_10; }
inline void set_footerTexture_10(Texture2D_t3840446185 * value)
{
___footerTexture_10 = value;
Il2CppCodeGenWriteBarrier((&___footerTexture_10), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // DEFAULTINITIALIZATIONERRORHANDLERINTERNAL_T2721934644_H
#ifndef DEFAULTTRACKABLEBEHAVIOURPLACEHOLDER_T3249521055_H
#define DEFAULTTRACKABLEBEHAVIOURPLACEHOLDER_T3249521055_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// DefaultTrackableBehaviourPlaceholder
struct DefaultTrackableBehaviourPlaceholder_t3249521055 : public MonoBehaviour_t3962482529
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // DEFAULTTRACKABLEBEHAVIOURPLACEHOLDER_T3249521055_H
#ifndef TRACKABLEBEHAVIOUR_T1113559212_H
#define TRACKABLEBEHAVIOUR_T1113559212_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// Vuforia.TrackableBehaviour
struct TrackableBehaviour_t1113559212 : public MonoBehaviour_t3962482529
{
public:
// System.Double Vuforia.TrackableBehaviour::<TimeStamp>k__BackingField
double ___U3CTimeStampU3Ek__BackingField_2;
// System.String Vuforia.TrackableBehaviour::mTrackableName
String_t* ___mTrackableName_3;
// System.Boolean Vuforia.TrackableBehaviour::mPreserveChildSize
bool ___mPreserveChildSize_4;
// System.Boolean Vuforia.TrackableBehaviour::mInitializedInEditor
bool ___mInitializedInEditor_5;
// UnityEngine.Vector3 Vuforia.TrackableBehaviour::mPreviousScale
Vector3_t3722313464 ___mPreviousScale_6;
// Vuforia.TrackableBehaviour/Status Vuforia.TrackableBehaviour::mStatus
int32_t ___mStatus_7;
// Vuforia.Trackable Vuforia.TrackableBehaviour::mTrackable
RuntimeObject* ___mTrackable_8;
// System.Collections.Generic.List`1<Vuforia.ITrackableEventHandler> Vuforia.TrackableBehaviour::mTrackableEventHandlers
List_1_t2968050330 * ___mTrackableEventHandlers_9;
public:
inline static int32_t get_offset_of_U3CTimeStampU3Ek__BackingField_2() { return static_cast<int32_t>(offsetof(TrackableBehaviour_t1113559212, ___U3CTimeStampU3Ek__BackingField_2)); }
inline double get_U3CTimeStampU3Ek__BackingField_2() const { return ___U3CTimeStampU3Ek__BackingField_2; }
inline double* get_address_of_U3CTimeStampU3Ek__BackingField_2() { return &___U3CTimeStampU3Ek__BackingField_2; }
inline void set_U3CTimeStampU3Ek__BackingField_2(double value)
{
___U3CTimeStampU3Ek__BackingField_2 = value;
}
inline static int32_t get_offset_of_mTrackableName_3() { return static_cast<int32_t>(offsetof(TrackableBehaviour_t1113559212, ___mTrackableName_3)); }
inline String_t* get_mTrackableName_3() const { return ___mTrackableName_3; }
inline String_t** get_address_of_mTrackableName_3() { return &___mTrackableName_3; }
inline void set_mTrackableName_3(String_t* value)
{
___mTrackableName_3 = value;
Il2CppCodeGenWriteBarrier((&___mTrackableName_3), value);
}
inline static int32_t get_offset_of_mPreserveChildSize_4() { return static_cast<int32_t>(offsetof(TrackableBehaviour_t1113559212, ___mPreserveChildSize_4)); }
inline bool get_mPreserveChildSize_4() const { return ___mPreserveChildSize_4; }
inline bool* get_address_of_mPreserveChildSize_4() { return &___mPreserveChildSize_4; }
inline void set_mPreserveChildSize_4(bool value)
{
___mPreserveChildSize_4 = value;
}
inline static int32_t get_offset_of_mInitializedInEditor_5() { return static_cast<int32_t>(offsetof(TrackableBehaviour_t1113559212, ___mInitializedInEditor_5)); }
inline bool get_mInitializedInEditor_5() const { return ___mInitializedInEditor_5; }
inline bool* get_address_of_mInitializedInEditor_5() { return &___mInitializedInEditor_5; }
inline void set_mInitializedInEditor_5(bool value)
{
___mInitializedInEditor_5 = value;
}
inline static int32_t get_offset_of_mPreviousScale_6() { return static_cast<int32_t>(offsetof(TrackableBehaviour_t1113559212, ___mPreviousScale_6)); }
inline Vector3_t3722313464 get_mPreviousScale_6() const { return ___mPreviousScale_6; }
inline Vector3_t3722313464 * get_address_of_mPreviousScale_6() { return &___mPreviousScale_6; }
inline void set_mPreviousScale_6(Vector3_t3722313464 value)
{
___mPreviousScale_6 = value;
}
inline static int32_t get_offset_of_mStatus_7() { return static_cast<int32_t>(offsetof(TrackableBehaviour_t1113559212, ___mStatus_7)); }
inline int32_t get_mStatus_7() const { return ___mStatus_7; }
inline int32_t* get_address_of_mStatus_7() { return &___mStatus_7; }
inline void set_mStatus_7(int32_t value)
{
___mStatus_7 = value;
}
inline static int32_t get_offset_of_mTrackable_8() { return static_cast<int32_t>(offsetof(TrackableBehaviour_t1113559212, ___mTrackable_8)); }
inline RuntimeObject* get_mTrackable_8() const { return ___mTrackable_8; }
inline RuntimeObject** get_address_of_mTrackable_8() { return &___mTrackable_8; }
inline void set_mTrackable_8(RuntimeObject* value)
{
___mTrackable_8 = value;
Il2CppCodeGenWriteBarrier((&___mTrackable_8), value);
}
inline static int32_t get_offset_of_mTrackableEventHandlers_9() { return static_cast<int32_t>(offsetof(TrackableBehaviour_t1113559212, ___mTrackableEventHandlers_9)); }
inline List_1_t2968050330 * get_mTrackableEventHandlers_9() const { return ___mTrackableEventHandlers_9; }
inline List_1_t2968050330 ** get_address_of_mTrackableEventHandlers_9() { return &___mTrackableEventHandlers_9; }
inline void set_mTrackableEventHandlers_9(List_1_t2968050330 * value)
{
___mTrackableEventHandlers_9 = value;
Il2CppCodeGenWriteBarrier((&___mTrackableEventHandlers_9), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // TRACKABLEBEHAVIOUR_T1113559212_H
#ifndef ANCHORBEHAVIOUR_T2000812465_H
#define ANCHORBEHAVIOUR_T2000812465_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// Vuforia.AnchorBehaviour
struct AnchorBehaviour_t2000812465 : public TrackableBehaviour_t1113559212
{
public:
// Vuforia.Anchor Vuforia.AnchorBehaviour::mAnchor
RuntimeObject* ___mAnchor_11;
public:
inline static int32_t get_offset_of_mAnchor_11() { return static_cast<int32_t>(offsetof(AnchorBehaviour_t2000812465, ___mAnchor_11)); }
inline RuntimeObject* get_mAnchor_11() const { return ___mAnchor_11; }
inline RuntimeObject** get_address_of_mAnchor_11() { return &___mAnchor_11; }
inline void set_mAnchor_11(RuntimeObject* value)
{
___mAnchor_11 = value;
Il2CppCodeGenWriteBarrier((&___mAnchor_11), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // ANCHORBEHAVIOUR_T2000812465_H
#ifndef FLUIDPLUGIN_T2696458681_H
#define FLUIDPLUGIN_T2696458681_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// Thinksquirrel.Fluvio.Plugins.FluidPlugin
struct FluidPlugin_t2696458681 : public FluvioMonoBehaviourBase_t869152428
{
public:
// Thinksquirrel.Fluvio.FluidBase Thinksquirrel.Fluvio.Plugins.FluidPlugin::m_Fluid
FluidBase_t2442071467 * ___m_Fluid_7;
// System.Int32 Thinksquirrel.Fluvio.Plugins.FluidPlugin::m_Weight
int32_t ___m_Weight_8;
// System.Boolean Thinksquirrel.Fluvio.Plugins.FluidPlugin::m_MonoScriptInitialized
bool ___m_MonoScriptInitialized_9;
// System.Int32 Thinksquirrel.Fluvio.Plugins.FluidPlugin::_pluginID
int32_t ____pluginID_10;
// System.Boolean Thinksquirrel.Fluvio.Plugins.FluidPlugin::m_ResetWeight
bool ___m_ResetWeight_11;
public:
inline static int32_t get_offset_of_m_Fluid_7() { return static_cast<int32_t>(offsetof(FluidPlugin_t2696458681, ___m_Fluid_7)); }
inline FluidBase_t2442071467 * get_m_Fluid_7() const { return ___m_Fluid_7; }
inline FluidBase_t2442071467 ** get_address_of_m_Fluid_7() { return &___m_Fluid_7; }
inline void set_m_Fluid_7(FluidBase_t2442071467 * value)
{
___m_Fluid_7 = value;
Il2CppCodeGenWriteBarrier((&___m_Fluid_7), value);
}
inline static int32_t get_offset_of_m_Weight_8() { return static_cast<int32_t>(offsetof(FluidPlugin_t2696458681, ___m_Weight_8)); }
inline int32_t get_m_Weight_8() const { return ___m_Weight_8; }
inline int32_t* get_address_of_m_Weight_8() { return &___m_Weight_8; }
inline void set_m_Weight_8(int32_t value)
{
___m_Weight_8 = value;
}
inline static int32_t get_offset_of_m_MonoScriptInitialized_9() { return static_cast<int32_t>(offsetof(FluidPlugin_t2696458681, ___m_MonoScriptInitialized_9)); }
inline bool get_m_MonoScriptInitialized_9() const { return ___m_MonoScriptInitialized_9; }
inline bool* get_address_of_m_MonoScriptInitialized_9() { return &___m_MonoScriptInitialized_9; }
inline void set_m_MonoScriptInitialized_9(bool value)
{
___m_MonoScriptInitialized_9 = value;
}
inline static int32_t get_offset_of__pluginID_10() { return static_cast<int32_t>(offsetof(FluidPlugin_t2696458681, ____pluginID_10)); }
inline int32_t get__pluginID_10() const { return ____pluginID_10; }
inline int32_t* get_address_of__pluginID_10() { return &____pluginID_10; }
inline void set__pluginID_10(int32_t value)
{
____pluginID_10 = value;
}
inline static int32_t get_offset_of_m_ResetWeight_11() { return static_cast<int32_t>(offsetof(FluidPlugin_t2696458681, ___m_ResetWeight_11)); }
inline bool get_m_ResetWeight_11() const { return ___m_ResetWeight_11; }
inline bool* get_address_of_m_ResetWeight_11() { return &___m_ResetWeight_11; }
inline void set_m_ResetWeight_11(bool value)
{
___m_ResetWeight_11 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // FLUIDPLUGIN_T2696458681_H
#ifndef FLUIDPARALLELPLUGIN_T3366117264_H
#define FLUIDPARALLELPLUGIN_T3366117264_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// Thinksquirrel.Fluvio.Plugins.FluidParallelPlugin
struct FluidParallelPlugin_t3366117264 : public FluidPlugin_t2696458681
{
public:
// System.Boolean Thinksquirrel.Fluvio.Plugins.FluidParallelPlugin::m_IncludeFluidGroup
bool ___m_IncludeFluidGroup_12;
// System.Boolean Thinksquirrel.Fluvio.Plugins.FluidParallelPlugin::m_RunAcceleratedOnly
bool ___m_RunAcceleratedOnly_13;
// Thinksquirrel.Fluvio.FluvioComputeShader Thinksquirrel.Fluvio.Plugins.FluidParallelPlugin::m_ComputeShader
FluvioComputeShader_t2551470295 * ___m_ComputeShader_14;
// System.Int32 Thinksquirrel.Fluvio.Plugins.FluidParallelPlugin::m_ComputeShaderKernelIndex
int32_t ___m_ComputeShaderKernelIndex_15;
// System.Boolean Thinksquirrel.Fluvio.Plugins.FluidParallelPlugin::m_IsValidComputePlugin
bool ___m_IsValidComputePlugin_16;
// System.Boolean Thinksquirrel.Fluvio.Plugins.FluidParallelPlugin::m_ShouldUpdate
bool ___m_ShouldUpdate_17;
// System.Int32 Thinksquirrel.Fluvio.Plugins.FluidParallelPlugin::m_Timer
int32_t ___m_Timer_18;
// Thinksquirrel.Fluvio.Internal.FluvioComputeBufferBase[] Thinksquirrel.Fluvio.Plugins.FluidParallelPlugin::m_PluginBuffers
FluvioComputeBufferBaseU5BU5D_t3891016598* ___m_PluginBuffers_19;
// System.Array[] Thinksquirrel.Fluvio.Plugins.FluidParallelPlugin::m_BufferValueCache
ArrayU5BU5D_t2896390326* ___m_BufferValueCache_20;
public:
inline static int32_t get_offset_of_m_IncludeFluidGroup_12() { return static_cast<int32_t>(offsetof(FluidParallelPlugin_t3366117264, ___m_IncludeFluidGroup_12)); }
inline bool get_m_IncludeFluidGroup_12() const { return ___m_IncludeFluidGroup_12; }
inline bool* get_address_of_m_IncludeFluidGroup_12() { return &___m_IncludeFluidGroup_12; }
inline void set_m_IncludeFluidGroup_12(bool value)
{
___m_IncludeFluidGroup_12 = value;
}
inline static int32_t get_offset_of_m_RunAcceleratedOnly_13() { return static_cast<int32_t>(offsetof(FluidParallelPlugin_t3366117264, ___m_RunAcceleratedOnly_13)); }
inline bool get_m_RunAcceleratedOnly_13() const { return ___m_RunAcceleratedOnly_13; }
inline bool* get_address_of_m_RunAcceleratedOnly_13() { return &___m_RunAcceleratedOnly_13; }
inline void set_m_RunAcceleratedOnly_13(bool value)
{
___m_RunAcceleratedOnly_13 = value;
}
inline static int32_t get_offset_of_m_ComputeShader_14() { return static_cast<int32_t>(offsetof(FluidParallelPlugin_t3366117264, ___m_ComputeShader_14)); }
inline FluvioComputeShader_t2551470295 * get_m_ComputeShader_14() const { return ___m_ComputeShader_14; }
inline FluvioComputeShader_t2551470295 ** get_address_of_m_ComputeShader_14() { return &___m_ComputeShader_14; }
inline void set_m_ComputeShader_14(FluvioComputeShader_t2551470295 * value)
{
___m_ComputeShader_14 = value;
Il2CppCodeGenWriteBarrier((&___m_ComputeShader_14), value);
}
inline static int32_t get_offset_of_m_ComputeShaderKernelIndex_15() { return static_cast<int32_t>(offsetof(FluidParallelPlugin_t3366117264, ___m_ComputeShaderKernelIndex_15)); }
inline int32_t get_m_ComputeShaderKernelIndex_15() const { return ___m_ComputeShaderKernelIndex_15; }
inline int32_t* get_address_of_m_ComputeShaderKernelIndex_15() { return &___m_ComputeShaderKernelIndex_15; }
inline void set_m_ComputeShaderKernelIndex_15(int32_t value)
{
___m_ComputeShaderKernelIndex_15 = value;
}
inline static int32_t get_offset_of_m_IsValidComputePlugin_16() { return static_cast<int32_t>(offsetof(FluidParallelPlugin_t3366117264, ___m_IsValidComputePlugin_16)); }
inline bool get_m_IsValidComputePlugin_16() const { return ___m_IsValidComputePlugin_16; }
inline bool* get_address_of_m_IsValidComputePlugin_16() { return &___m_IsValidComputePlugin_16; }
inline void set_m_IsValidComputePlugin_16(bool value)
{
___m_IsValidComputePlugin_16 = value;
}
inline static int32_t get_offset_of_m_ShouldUpdate_17() { return static_cast<int32_t>(offsetof(FluidParallelPlugin_t3366117264, ___m_ShouldUpdate_17)); }
inline bool get_m_ShouldUpdate_17() const { return ___m_ShouldUpdate_17; }
inline bool* get_address_of_m_ShouldUpdate_17() { return &___m_ShouldUpdate_17; }
inline void set_m_ShouldUpdate_17(bool value)
{
___m_ShouldUpdate_17 = value;
}
inline static int32_t get_offset_of_m_Timer_18() { return static_cast<int32_t>(offsetof(FluidParallelPlugin_t3366117264, ___m_Timer_18)); }
inline int32_t get_m_Timer_18() const { return ___m_Timer_18; }
inline int32_t* get_address_of_m_Timer_18() { return &___m_Timer_18; }
inline void set_m_Timer_18(int32_t value)
{
___m_Timer_18 = value;
}
inline static int32_t get_offset_of_m_PluginBuffers_19() { return static_cast<int32_t>(offsetof(FluidParallelPlugin_t3366117264, ___m_PluginBuffers_19)); }
inline FluvioComputeBufferBaseU5BU5D_t3891016598* get_m_PluginBuffers_19() const { return ___m_PluginBuffers_19; }
inline FluvioComputeBufferBaseU5BU5D_t3891016598** get_address_of_m_PluginBuffers_19() { return &___m_PluginBuffers_19; }
inline void set_m_PluginBuffers_19(FluvioComputeBufferBaseU5BU5D_t3891016598* value)
{
___m_PluginBuffers_19 = value;
Il2CppCodeGenWriteBarrier((&___m_PluginBuffers_19), value);
}
inline static int32_t get_offset_of_m_BufferValueCache_20() { return static_cast<int32_t>(offsetof(FluidParallelPlugin_t3366117264, ___m_BufferValueCache_20)); }
inline ArrayU5BU5D_t2896390326* get_m_BufferValueCache_20() const { return ___m_BufferValueCache_20; }
inline ArrayU5BU5D_t2896390326** get_address_of_m_BufferValueCache_20() { return &___m_BufferValueCache_20; }
inline void set_m_BufferValueCache_20(ArrayU5BU5D_t2896390326* value)
{
___m_BufferValueCache_20 = value;
Il2CppCodeGenWriteBarrier((&___m_BufferValueCache_20), value);
}
};
struct FluidParallelPlugin_t3366117264_StaticFields
{
public:
// System.Converter`2<UnityEngine.Keyframe,Thinksquirrel.Fluvio.Internal.Keyframe> Thinksquirrel.Fluvio.Plugins.FluidParallelPlugin::<>f__am$cache9
Converter_2_t3479950270 * ___U3CU3Ef__amU24cache9_21;
// System.Converter`2<UnityEngine.Keyframe,Thinksquirrel.Fluvio.Internal.Keyframe> Thinksquirrel.Fluvio.Plugins.FluidParallelPlugin::<>f__am$cacheA
Converter_2_t3479950270 * ___U3CU3Ef__amU24cacheA_22;
public:
inline static int32_t get_offset_of_U3CU3Ef__amU24cache9_21() { return static_cast<int32_t>(offsetof(FluidParallelPlugin_t3366117264_StaticFields, ___U3CU3Ef__amU24cache9_21)); }
inline Converter_2_t3479950270 * get_U3CU3Ef__amU24cache9_21() const { return ___U3CU3Ef__amU24cache9_21; }
inline Converter_2_t3479950270 ** get_address_of_U3CU3Ef__amU24cache9_21() { return &___U3CU3Ef__amU24cache9_21; }
inline void set_U3CU3Ef__amU24cache9_21(Converter_2_t3479950270 * value)
{
___U3CU3Ef__amU24cache9_21 = value;
Il2CppCodeGenWriteBarrier((&___U3CU3Ef__amU24cache9_21), value);
}
inline static int32_t get_offset_of_U3CU3Ef__amU24cacheA_22() { return static_cast<int32_t>(offsetof(FluidParallelPlugin_t3366117264_StaticFields, ___U3CU3Ef__amU24cacheA_22)); }
inline Converter_2_t3479950270 * get_U3CU3Ef__amU24cacheA_22() const { return ___U3CU3Ef__amU24cacheA_22; }
inline Converter_2_t3479950270 ** get_address_of_U3CU3Ef__amU24cacheA_22() { return &___U3CU3Ef__amU24cacheA_22; }
inline void set_U3CU3Ef__amU24cacheA_22(Converter_2_t3479950270 * value)
{
___U3CU3Ef__amU24cacheA_22 = value;
Il2CppCodeGenWriteBarrier((&___U3CU3Ef__amU24cacheA_22), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // FLUIDPARALLELPLUGIN_T3366117264_H
#ifndef FLUIDDEBUG_T1986102106_H
#define FLUIDDEBUG_T1986102106_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// Thinksquirrel.Fluvio.Plugins.FluidDebug
struct FluidDebug_t1986102106 : public FluidPlugin_t2696458681
{
public:
// UnityEngine.UI.Text Thinksquirrel.Fluvio.Plugins.FluidDebug::m_DebugText
Text_t1901882714 * ___m_DebugText_12;
// System.Single Thinksquirrel.Fluvio.Plugins.FluidDebug::m_UpdateInterval
float ___m_UpdateInterval_13;
// UnityEngine.UI.Text Thinksquirrel.Fluvio.Plugins.FluidDebug::m_AutoGeneratedText
Text_t1901882714 * ___m_AutoGeneratedText_14;
// System.Double Thinksquirrel.Fluvio.Plugins.FluidDebug::m_TimeLeft
double ___m_TimeLeft_15;
// System.Double Thinksquirrel.Fluvio.Plugins.FluidDebug::m_AccumulatorSolverTime
double ___m_AccumulatorSolverTime_16;
// System.Double Thinksquirrel.Fluvio.Plugins.FluidDebug::m_AccumulatorGPUPluginsTime
double ___m_AccumulatorGPUPluginsTime_17;
// System.Double Thinksquirrel.Fluvio.Plugins.FluidDebug::m_AccumulatorPluginsTime
double ___m_AccumulatorPluginsTime_18;
// System.Double Thinksquirrel.Fluvio.Plugins.FluidDebug::m_AccumulatorOverheadTime
double ___m_AccumulatorOverheadTime_19;
// System.Double Thinksquirrel.Fluvio.Plugins.FluidDebug::m_AccumulatorTotalTime
double ___m_AccumulatorTotalTime_20;
// System.Double Thinksquirrel.Fluvio.Plugins.FluidDebug::m_SolverTime
double ___m_SolverTime_21;
// System.Double Thinksquirrel.Fluvio.Plugins.FluidDebug::m_GPUPluginsTime
double ___m_GPUPluginsTime_22;
// System.Double Thinksquirrel.Fluvio.Plugins.FluidDebug::m_PluginsTime
double ___m_PluginsTime_23;
// System.Double Thinksquirrel.Fluvio.Plugins.FluidDebug::m_OverheadTime
double ___m_OverheadTime_24;
// System.Double Thinksquirrel.Fluvio.Plugins.FluidDebug::m_TotalTime
double ___m_TotalTime_25;
// System.Double Thinksquirrel.Fluvio.Plugins.FluidDebug::m_LastTime
double ___m_LastTime_26;
// System.Int32 Thinksquirrel.Fluvio.Plugins.FluidDebug::m_Frames
int32_t ___m_Frames_27;
public:
inline static int32_t get_offset_of_m_DebugText_12() { return static_cast<int32_t>(offsetof(FluidDebug_t1986102106, ___m_DebugText_12)); }
inline Text_t1901882714 * get_m_DebugText_12() const { return ___m_DebugText_12; }
inline Text_t1901882714 ** get_address_of_m_DebugText_12() { return &___m_DebugText_12; }
inline void set_m_DebugText_12(Text_t1901882714 * value)
{
___m_DebugText_12 = value;
Il2CppCodeGenWriteBarrier((&___m_DebugText_12), value);
}
inline static int32_t get_offset_of_m_UpdateInterval_13() { return static_cast<int32_t>(offsetof(FluidDebug_t1986102106, ___m_UpdateInterval_13)); }
inline float get_m_UpdateInterval_13() const { return ___m_UpdateInterval_13; }
inline float* get_address_of_m_UpdateInterval_13() { return &___m_UpdateInterval_13; }
inline void set_m_UpdateInterval_13(float value)
{
___m_UpdateInterval_13 = value;
}
inline static int32_t get_offset_of_m_AutoGeneratedText_14() { return static_cast<int32_t>(offsetof(FluidDebug_t1986102106, ___m_AutoGeneratedText_14)); }
inline Text_t1901882714 * get_m_AutoGeneratedText_14() const { return ___m_AutoGeneratedText_14; }
inline Text_t1901882714 ** get_address_of_m_AutoGeneratedText_14() { return &___m_AutoGeneratedText_14; }
inline void set_m_AutoGeneratedText_14(Text_t1901882714 * value)
{
___m_AutoGeneratedText_14 = value;
Il2CppCodeGenWriteBarrier((&___m_AutoGeneratedText_14), value);
}
inline static int32_t get_offset_of_m_TimeLeft_15() { return static_cast<int32_t>(offsetof(FluidDebug_t1986102106, ___m_TimeLeft_15)); }
inline double get_m_TimeLeft_15() const { return ___m_TimeLeft_15; }
inline double* get_address_of_m_TimeLeft_15() { return &___m_TimeLeft_15; }
inline void set_m_TimeLeft_15(double value)
{
___m_TimeLeft_15 = value;
}
inline static int32_t get_offset_of_m_AccumulatorSolverTime_16() { return static_cast<int32_t>(offsetof(FluidDebug_t1986102106, ___m_AccumulatorSolverTime_16)); }
inline double get_m_AccumulatorSolverTime_16() const { return ___m_AccumulatorSolverTime_16; }
inline double* get_address_of_m_AccumulatorSolverTime_16() { return &___m_AccumulatorSolverTime_16; }
inline void set_m_AccumulatorSolverTime_16(double value)
{
___m_AccumulatorSolverTime_16 = value;
}
inline static int32_t get_offset_of_m_AccumulatorGPUPluginsTime_17() { return static_cast<int32_t>(offsetof(FluidDebug_t1986102106, ___m_AccumulatorGPUPluginsTime_17)); }
inline double get_m_AccumulatorGPUPluginsTime_17() const { return ___m_AccumulatorGPUPluginsTime_17; }
inline double* get_address_of_m_AccumulatorGPUPluginsTime_17() { return &___m_AccumulatorGPUPluginsTime_17; }
inline void set_m_AccumulatorGPUPluginsTime_17(double value)
{
___m_AccumulatorGPUPluginsTime_17 = value;
}
inline static int32_t get_offset_of_m_AccumulatorPluginsTime_18() { return static_cast<int32_t>(offsetof(FluidDebug_t1986102106, ___m_AccumulatorPluginsTime_18)); }
inline double get_m_AccumulatorPluginsTime_18() const { return ___m_AccumulatorPluginsTime_18; }
inline double* get_address_of_m_AccumulatorPluginsTime_18() { return &___m_AccumulatorPluginsTime_18; }
inline void set_m_AccumulatorPluginsTime_18(double value)
{
___m_AccumulatorPluginsTime_18 = value;
}
inline static int32_t get_offset_of_m_AccumulatorOverheadTime_19() { return static_cast<int32_t>(offsetof(FluidDebug_t1986102106, ___m_AccumulatorOverheadTime_19)); }
inline double get_m_AccumulatorOverheadTime_19() const { return ___m_AccumulatorOverheadTime_19; }
inline double* get_address_of_m_AccumulatorOverheadTime_19() { return &___m_AccumulatorOverheadTime_19; }
inline void set_m_AccumulatorOverheadTime_19(double value)
{
___m_AccumulatorOverheadTime_19 = value;
}
inline static int32_t get_offset_of_m_AccumulatorTotalTime_20() { return static_cast<int32_t>(offsetof(FluidDebug_t1986102106, ___m_AccumulatorTotalTime_20)); }
inline double get_m_AccumulatorTotalTime_20() const { return ___m_AccumulatorTotalTime_20; }
inline double* get_address_of_m_AccumulatorTotalTime_20() { return &___m_AccumulatorTotalTime_20; }
inline void set_m_AccumulatorTotalTime_20(double value)
{
___m_AccumulatorTotalTime_20 = value;
}
inline static int32_t get_offset_of_m_SolverTime_21() { return static_cast<int32_t>(offsetof(FluidDebug_t1986102106, ___m_SolverTime_21)); }
inline double get_m_SolverTime_21() const { return ___m_SolverTime_21; }
inline double* get_address_of_m_SolverTime_21() { return &___m_SolverTime_21; }
inline void set_m_SolverTime_21(double value)
{
___m_SolverTime_21 = value;
}
inline static int32_t get_offset_of_m_GPUPluginsTime_22() { return static_cast<int32_t>(offsetof(FluidDebug_t1986102106, ___m_GPUPluginsTime_22)); }
inline double get_m_GPUPluginsTime_22() const { return ___m_GPUPluginsTime_22; }
inline double* get_address_of_m_GPUPluginsTime_22() { return &___m_GPUPluginsTime_22; }
inline void set_m_GPUPluginsTime_22(double value)
{
___m_GPUPluginsTime_22 = value;
}
inline static int32_t get_offset_of_m_PluginsTime_23() { return static_cast<int32_t>(offsetof(FluidDebug_t1986102106, ___m_PluginsTime_23)); }
inline double get_m_PluginsTime_23() const { return ___m_PluginsTime_23; }
inline double* get_address_of_m_PluginsTime_23() { return &___m_PluginsTime_23; }
inline void set_m_PluginsTime_23(double value)
{
___m_PluginsTime_23 = value;
}
inline static int32_t get_offset_of_m_OverheadTime_24() { return static_cast<int32_t>(offsetof(FluidDebug_t1986102106, ___m_OverheadTime_24)); }
inline double get_m_OverheadTime_24() const { return ___m_OverheadTime_24; }
inline double* get_address_of_m_OverheadTime_24() { return &___m_OverheadTime_24; }
inline void set_m_OverheadTime_24(double value)
{
___m_OverheadTime_24 = value;
}
inline static int32_t get_offset_of_m_TotalTime_25() { return static_cast<int32_t>(offsetof(FluidDebug_t1986102106, ___m_TotalTime_25)); }
inline double get_m_TotalTime_25() const { return ___m_TotalTime_25; }
inline double* get_address_of_m_TotalTime_25() { return &___m_TotalTime_25; }
inline void set_m_TotalTime_25(double value)
{
___m_TotalTime_25 = value;
}
inline static int32_t get_offset_of_m_LastTime_26() { return static_cast<int32_t>(offsetof(FluidDebug_t1986102106, ___m_LastTime_26)); }
inline double get_m_LastTime_26() const { return ___m_LastTime_26; }
inline double* get_address_of_m_LastTime_26() { return &___m_LastTime_26; }
inline void set_m_LastTime_26(double value)
{
___m_LastTime_26 = value;
}
inline static int32_t get_offset_of_m_Frames_27() { return static_cast<int32_t>(offsetof(FluidDebug_t1986102106, ___m_Frames_27)); }
inline int32_t get_m_Frames_27() const { return ___m_Frames_27; }
inline int32_t* get_address_of_m_Frames_27() { return &___m_Frames_27; }
inline void set_m_Frames_27(int32_t value)
{
___m_Frames_27 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // FLUIDDEBUG_T1986102106_H
#ifndef FLUIDPARTICLEPLUGIN_T2087845768_H
#define FLUIDPARTICLEPLUGIN_T2087845768_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// Thinksquirrel.Fluvio.Plugins.FluidParticlePlugin
struct FluidParticlePlugin_t2087845768 : public FluidParallelPlugin_t3366117264
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // FLUIDPARTICLEPLUGIN_T2087845768_H
#ifndef FLUIDPARTICLEPAIRPLUGIN_T2917011702_H
#define FLUIDPARTICLEPAIRPLUGIN_T2917011702_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// Thinksquirrel.Fluvio.Plugins.FluidParticlePairPlugin
struct FluidParticlePairPlugin_t2917011702 : public FluidParallelPlugin_t3366117264
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // FLUIDPARTICLEPAIRPLUGIN_T2917011702_H
#ifndef SIZEBYDENSITY_T240071710_H
#define SIZEBYDENSITY_T240071710_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// Thinksquirrel.Fluvio.Plugins.SizeByDensity
struct SizeByDensity_t240071710 : public FluidParticlePlugin_t2087845768
{
public:
// Thinksquirrel.Fluvio.FluvioMinMaxCurve Thinksquirrel.Fluvio.Plugins.SizeByDensity::m_Size
FluvioMinMaxCurve_t1877352570 * ___m_Size_23;
// UnityEngine.Vector2 Thinksquirrel.Fluvio.Plugins.SizeByDensity::m_Range
Vector2_t2156229523 ___m_Range_24;
// System.Single Thinksquirrel.Fluvio.Plugins.SizeByDensity::m_Smoothing
float ___m_Smoothing_25;
public:
inline static int32_t get_offset_of_m_Size_23() { return static_cast<int32_t>(offsetof(SizeByDensity_t240071710, ___m_Size_23)); }
inline FluvioMinMaxCurve_t1877352570 * get_m_Size_23() const { return ___m_Size_23; }
inline FluvioMinMaxCurve_t1877352570 ** get_address_of_m_Size_23() { return &___m_Size_23; }
inline void set_m_Size_23(FluvioMinMaxCurve_t1877352570 * value)
{
___m_Size_23 = value;
Il2CppCodeGenWriteBarrier((&___m_Size_23), value);
}
inline static int32_t get_offset_of_m_Range_24() { return static_cast<int32_t>(offsetof(SizeByDensity_t240071710, ___m_Range_24)); }
inline Vector2_t2156229523 get_m_Range_24() const { return ___m_Range_24; }
inline Vector2_t2156229523 * get_address_of_m_Range_24() { return &___m_Range_24; }
inline void set_m_Range_24(Vector2_t2156229523 value)
{
___m_Range_24 = value;
}
inline static int32_t get_offset_of_m_Smoothing_25() { return static_cast<int32_t>(offsetof(SizeByDensity_t240071710, ___m_Smoothing_25)); }
inline float get_m_Smoothing_25() const { return ___m_Smoothing_25; }
inline float* get_address_of_m_Smoothing_25() { return &___m_Smoothing_25; }
inline void set_m_Smoothing_25(float value)
{
___m_Smoothing_25 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // SIZEBYDENSITY_T240071710_H
#ifndef PHASECHANGE_T1879784979_H
#define PHASECHANGE_T1879784979_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// Thinksquirrel.Fluvio.Plugins.PhaseChange
struct PhaseChange_t1879784979 : public FluidParticlePlugin_t2087845768
{
public:
// UnityEngine.ParticleSystem Thinksquirrel.Fluvio.Plugins.PhaseChange::m_OtherParticleSystem
ParticleSystem_t1800779281 * ___m_OtherParticleSystem_23;
// Thinksquirrel.Fluvio.Plugins.PhaseChange/ComparisonType Thinksquirrel.Fluvio.Plugins.PhaseChange::m_ComparisonType
int32_t ___m_ComparisonType_24;
// System.Single Thinksquirrel.Fluvio.Plugins.PhaseChange::m_DensityThreshold
float ___m_DensityThreshold_25;
// Thinksquirrel.Fluvio.Plugins.PhaseChange/PhaseChangeData[] Thinksquirrel.Fluvio.Plugins.PhaseChange::m_PhaseChangeData
PhaseChangeDataU5BU5D_t3004711667* ___m_PhaseChangeData_26;
// UnityEngine.Vector3 Thinksquirrel.Fluvio.Plugins.PhaseChange::m_Gravity
Vector3_t3722313464 ___m_Gravity_27;
// Thinksquirrel.Fluvio.FluvioTimeStep Thinksquirrel.Fluvio.Plugins.PhaseChange::m_TimeStep
FluvioTimeStep_t3427387132 ___m_TimeStep_28;
// System.Int32 Thinksquirrel.Fluvio.Plugins.PhaseChange::m_Count
int32_t ___m_Count_29;
// System.Single Thinksquirrel.Fluvio.Plugins.PhaseChange::m_SimulationScale
float ___m_SimulationScale_30;
public:
inline static int32_t get_offset_of_m_OtherParticleSystem_23() { return static_cast<int32_t>(offsetof(PhaseChange_t1879784979, ___m_OtherParticleSystem_23)); }
inline ParticleSystem_t1800779281 * get_m_OtherParticleSystem_23() const { return ___m_OtherParticleSystem_23; }
inline ParticleSystem_t1800779281 ** get_address_of_m_OtherParticleSystem_23() { return &___m_OtherParticleSystem_23; }
inline void set_m_OtherParticleSystem_23(ParticleSystem_t1800779281 * value)
{
___m_OtherParticleSystem_23 = value;
Il2CppCodeGenWriteBarrier((&___m_OtherParticleSystem_23), value);
}
inline static int32_t get_offset_of_m_ComparisonType_24() { return static_cast<int32_t>(offsetof(PhaseChange_t1879784979, ___m_ComparisonType_24)); }
inline int32_t get_m_ComparisonType_24() const { return ___m_ComparisonType_24; }
inline int32_t* get_address_of_m_ComparisonType_24() { return &___m_ComparisonType_24; }
inline void set_m_ComparisonType_24(int32_t value)
{
___m_ComparisonType_24 = value;
}
inline static int32_t get_offset_of_m_DensityThreshold_25() { return static_cast<int32_t>(offsetof(PhaseChange_t1879784979, ___m_DensityThreshold_25)); }
inline float get_m_DensityThreshold_25() const { return ___m_DensityThreshold_25; }
inline float* get_address_of_m_DensityThreshold_25() { return &___m_DensityThreshold_25; }
inline void set_m_DensityThreshold_25(float value)
{
___m_DensityThreshold_25 = value;
}
inline static int32_t get_offset_of_m_PhaseChangeData_26() { return static_cast<int32_t>(offsetof(PhaseChange_t1879784979, ___m_PhaseChangeData_26)); }
inline PhaseChangeDataU5BU5D_t3004711667* get_m_PhaseChangeData_26() const { return ___m_PhaseChangeData_26; }
inline PhaseChangeDataU5BU5D_t3004711667** get_address_of_m_PhaseChangeData_26() { return &___m_PhaseChangeData_26; }
inline void set_m_PhaseChangeData_26(PhaseChangeDataU5BU5D_t3004711667* value)
{
___m_PhaseChangeData_26 = value;
Il2CppCodeGenWriteBarrier((&___m_PhaseChangeData_26), value);
}
inline static int32_t get_offset_of_m_Gravity_27() { return static_cast<int32_t>(offsetof(PhaseChange_t1879784979, ___m_Gravity_27)); }
inline Vector3_t3722313464 get_m_Gravity_27() const { return ___m_Gravity_27; }
inline Vector3_t3722313464 * get_address_of_m_Gravity_27() { return &___m_Gravity_27; }
inline void set_m_Gravity_27(Vector3_t3722313464 value)
{
___m_Gravity_27 = value;
}
inline static int32_t get_offset_of_m_TimeStep_28() { return static_cast<int32_t>(offsetof(PhaseChange_t1879784979, ___m_TimeStep_28)); }
inline FluvioTimeStep_t3427387132 get_m_TimeStep_28() const { return ___m_TimeStep_28; }
inline FluvioTimeStep_t3427387132 * get_address_of_m_TimeStep_28() { return &___m_TimeStep_28; }
inline void set_m_TimeStep_28(FluvioTimeStep_t3427387132 value)
{
___m_TimeStep_28 = value;
}
inline static int32_t get_offset_of_m_Count_29() { return static_cast<int32_t>(offsetof(PhaseChange_t1879784979, ___m_Count_29)); }
inline int32_t get_m_Count_29() const { return ___m_Count_29; }
inline int32_t* get_address_of_m_Count_29() { return &___m_Count_29; }
inline void set_m_Count_29(int32_t value)
{
___m_Count_29 = value;
}
inline static int32_t get_offset_of_m_SimulationScale_30() { return static_cast<int32_t>(offsetof(PhaseChange_t1879784979, ___m_SimulationScale_30)); }
inline float get_m_SimulationScale_30() const { return ___m_SimulationScale_30; }
inline float* get_address_of_m_SimulationScale_30() { return &___m_SimulationScale_30; }
inline void set_m_SimulationScale_30(float value)
{
___m_SimulationScale_30 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // PHASECHANGE_T1879784979_H
#ifndef FLUIDEFFECTOR_T2260861129_H
#define FLUIDEFFECTOR_T2260861129_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// Thinksquirrel.Fluvio.Plugins.Effectors.FluidEffector
struct FluidEffector_t2260861129 : public FluidParticlePlugin_t2087845768
{
public:
// System.Boolean Thinksquirrel.Fluvio.Plugins.Effectors.FluidEffector::m_AllowBufferReadback
bool ___m_AllowBufferReadback_23;
// Thinksquirrel.Fluvio.FluidEffectorForceType Thinksquirrel.Fluvio.Plugins.Effectors.FluidEffector::m_ForceType
int32_t ___m_ForceType_24;
// Thinksquirrel.Fluvio.FluidEffectorForceAxis Thinksquirrel.Fluvio.Plugins.Effectors.FluidEffector::m_ForceAxis
int32_t ___m_ForceAxis_25;
// Thinksquirrel.Fluvio.FluvioMinMaxCurve Thinksquirrel.Fluvio.Plugins.Effectors.FluidEffector::m_Force
FluvioMinMaxCurve_t1877352570 * ___m_Force_26;
// Thinksquirrel.Fluvio.FluvioMinMaxCurve Thinksquirrel.Fluvio.Plugins.Effectors.FluidEffector::m_Vorticity
FluvioMinMaxCurve_t1877352570 * ___m_Vorticity_27;
// System.Single Thinksquirrel.Fluvio.Plugins.Effectors.FluidEffector::m_EffectorRange
float ___m_EffectorRange_28;
// Thinksquirrel.Fluvio.FluidEffectorDecayType Thinksquirrel.Fluvio.Plugins.Effectors.FluidEffector::m_DecayType
int32_t ___m_DecayType_29;
// System.Single Thinksquirrel.Fluvio.Plugins.Effectors.FluidEffector::m_Decay
float ___m_Decay_30;
// System.Single Thinksquirrel.Fluvio.Plugins.Effectors.FluidEffector::m_DecayJitter
float ___m_DecayJitter_31;
// UnityEngine.Vector3 Thinksquirrel.Fluvio.Plugins.Effectors.FluidEffector::m_Position
Vector3_t3722313464 ___m_Position_32;
// UnityEngine.Matrix4x4 Thinksquirrel.Fluvio.Plugins.Effectors.FluidEffector::_worldToLocalMatrix
Matrix4x4_t1817901843 ____worldToLocalMatrix_33;
// UnityEngine.Matrix4x4 Thinksquirrel.Fluvio.Plugins.Effectors.FluidEffector::_localToWorldMatrix
Matrix4x4_t1817901843 ____localToWorldMatrix_34;
// UnityEngine.Vector4 Thinksquirrel.Fluvio.Plugins.Effectors.FluidEffector::_decayParams
Vector4_t3319028937 ____decayParams_35;
// UnityEngine.Vector4 Thinksquirrel.Fluvio.Plugins.Effectors.FluidEffector::_forceDirection
Vector4_t3319028937 ____forceDirection_36;
// System.Int32 Thinksquirrel.Fluvio.Plugins.Effectors.FluidEffector::_particlesInEffector
int32_t ____particlesInEffector_37;
public:
inline static int32_t get_offset_of_m_AllowBufferReadback_23() { return static_cast<int32_t>(offsetof(FluidEffector_t2260861129, ___m_AllowBufferReadback_23)); }
inline bool get_m_AllowBufferReadback_23() const { return ___m_AllowBufferReadback_23; }
inline bool* get_address_of_m_AllowBufferReadback_23() { return &___m_AllowBufferReadback_23; }
inline void set_m_AllowBufferReadback_23(bool value)
{
___m_AllowBufferReadback_23 = value;
}
inline static int32_t get_offset_of_m_ForceType_24() { return static_cast<int32_t>(offsetof(FluidEffector_t2260861129, ___m_ForceType_24)); }
inline int32_t get_m_ForceType_24() const { return ___m_ForceType_24; }
inline int32_t* get_address_of_m_ForceType_24() { return &___m_ForceType_24; }
inline void set_m_ForceType_24(int32_t value)
{
___m_ForceType_24 = value;
}
inline static int32_t get_offset_of_m_ForceAxis_25() { return static_cast<int32_t>(offsetof(FluidEffector_t2260861129, ___m_ForceAxis_25)); }
inline int32_t get_m_ForceAxis_25() const { return ___m_ForceAxis_25; }
inline int32_t* get_address_of_m_ForceAxis_25() { return &___m_ForceAxis_25; }
inline void set_m_ForceAxis_25(int32_t value)
{
___m_ForceAxis_25 = value;
}
inline static int32_t get_offset_of_m_Force_26() { return static_cast<int32_t>(offsetof(FluidEffector_t2260861129, ___m_Force_26)); }
inline FluvioMinMaxCurve_t1877352570 * get_m_Force_26() const { return ___m_Force_26; }
inline FluvioMinMaxCurve_t1877352570 ** get_address_of_m_Force_26() { return &___m_Force_26; }
inline void set_m_Force_26(FluvioMinMaxCurve_t1877352570 * value)
{
___m_Force_26 = value;
Il2CppCodeGenWriteBarrier((&___m_Force_26), value);
}
inline static int32_t get_offset_of_m_Vorticity_27() { return static_cast<int32_t>(offsetof(FluidEffector_t2260861129, ___m_Vorticity_27)); }
inline FluvioMinMaxCurve_t1877352570 * get_m_Vorticity_27() const { return ___m_Vorticity_27; }
inline FluvioMinMaxCurve_t1877352570 ** get_address_of_m_Vorticity_27() { return &___m_Vorticity_27; }
inline void set_m_Vorticity_27(FluvioMinMaxCurve_t1877352570 * value)
{
___m_Vorticity_27 = value;
Il2CppCodeGenWriteBarrier((&___m_Vorticity_27), value);
}
inline static int32_t get_offset_of_m_EffectorRange_28() { return static_cast<int32_t>(offsetof(FluidEffector_t2260861129, ___m_EffectorRange_28)); }
inline float get_m_EffectorRange_28() const { return ___m_EffectorRange_28; }
inline float* get_address_of_m_EffectorRange_28() { return &___m_EffectorRange_28; }
inline void set_m_EffectorRange_28(float value)
{
___m_EffectorRange_28 = value;
}
inline static int32_t get_offset_of_m_DecayType_29() { return static_cast<int32_t>(offsetof(FluidEffector_t2260861129, ___m_DecayType_29)); }
inline int32_t get_m_DecayType_29() const { return ___m_DecayType_29; }
inline int32_t* get_address_of_m_DecayType_29() { return &___m_DecayType_29; }
inline void set_m_DecayType_29(int32_t value)
{
___m_DecayType_29 = value;
}
inline static int32_t get_offset_of_m_Decay_30() { return static_cast<int32_t>(offsetof(FluidEffector_t2260861129, ___m_Decay_30)); }
inline float get_m_Decay_30() const { return ___m_Decay_30; }
inline float* get_address_of_m_Decay_30() { return &___m_Decay_30; }
inline void set_m_Decay_30(float value)
{
___m_Decay_30 = value;
}
inline static int32_t get_offset_of_m_DecayJitter_31() { return static_cast<int32_t>(offsetof(FluidEffector_t2260861129, ___m_DecayJitter_31)); }
inline float get_m_DecayJitter_31() const { return ___m_DecayJitter_31; }
inline float* get_address_of_m_DecayJitter_31() { return &___m_DecayJitter_31; }
inline void set_m_DecayJitter_31(float value)
{
___m_DecayJitter_31 = value;
}
inline static int32_t get_offset_of_m_Position_32() { return static_cast<int32_t>(offsetof(FluidEffector_t2260861129, ___m_Position_32)); }
inline Vector3_t3722313464 get_m_Position_32() const { return ___m_Position_32; }
inline Vector3_t3722313464 * get_address_of_m_Position_32() { return &___m_Position_32; }
inline void set_m_Position_32(Vector3_t3722313464 value)
{
___m_Position_32 = value;
}
inline static int32_t get_offset_of__worldToLocalMatrix_33() { return static_cast<int32_t>(offsetof(FluidEffector_t2260861129, ____worldToLocalMatrix_33)); }
inline Matrix4x4_t1817901843 get__worldToLocalMatrix_33() const { return ____worldToLocalMatrix_33; }
inline Matrix4x4_t1817901843 * get_address_of__worldToLocalMatrix_33() { return &____worldToLocalMatrix_33; }
inline void set__worldToLocalMatrix_33(Matrix4x4_t1817901843 value)
{
____worldToLocalMatrix_33 = value;
}
inline static int32_t get_offset_of__localToWorldMatrix_34() { return static_cast<int32_t>(offsetof(FluidEffector_t2260861129, ____localToWorldMatrix_34)); }
inline Matrix4x4_t1817901843 get__localToWorldMatrix_34() const { return ____localToWorldMatrix_34; }
inline Matrix4x4_t1817901843 * get_address_of__localToWorldMatrix_34() { return &____localToWorldMatrix_34; }
inline void set__localToWorldMatrix_34(Matrix4x4_t1817901843 value)
{
____localToWorldMatrix_34 = value;
}
inline static int32_t get_offset_of__decayParams_35() { return static_cast<int32_t>(offsetof(FluidEffector_t2260861129, ____decayParams_35)); }
inline Vector4_t3319028937 get__decayParams_35() const { return ____decayParams_35; }
inline Vector4_t3319028937 * get_address_of__decayParams_35() { return &____decayParams_35; }
inline void set__decayParams_35(Vector4_t3319028937 value)
{
____decayParams_35 = value;
}
inline static int32_t get_offset_of__forceDirection_36() { return static_cast<int32_t>(offsetof(FluidEffector_t2260861129, ____forceDirection_36)); }
inline Vector4_t3319028937 get__forceDirection_36() const { return ____forceDirection_36; }
inline Vector4_t3319028937 * get_address_of__forceDirection_36() { return &____forceDirection_36; }
inline void set__forceDirection_36(Vector4_t3319028937 value)
{
____forceDirection_36 = value;
}
inline static int32_t get_offset_of__particlesInEffector_37() { return static_cast<int32_t>(offsetof(FluidEffector_t2260861129, ____particlesInEffector_37)); }
inline int32_t get__particlesInEffector_37() const { return ____particlesInEffector_37; }
inline int32_t* get_address_of__particlesInEffector_37() { return &____particlesInEffector_37; }
inline void set__particlesInEffector_37(int32_t value)
{
____particlesInEffector_37 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // FLUIDEFFECTOR_T2260861129_H
#ifndef COLORBYDENSITY_T1246500786_H
#define COLORBYDENSITY_T1246500786_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// Thinksquirrel.Fluvio.Plugins.ColorByDensity
struct ColorByDensity_t1246500786 : public FluidParticlePlugin_t2087845768
{
public:
// Thinksquirrel.Fluvio.FluvioMinMaxGradient Thinksquirrel.Fluvio.Plugins.ColorByDensity::m_Color
FluvioMinMaxGradient_t1663705874 * ___m_Color_23;
// UnityEngine.Vector2 Thinksquirrel.Fluvio.Plugins.ColorByDensity::m_Range
Vector2_t2156229523 ___m_Range_24;
// System.Single Thinksquirrel.Fluvio.Plugins.ColorByDensity::m_Smoothing
float ___m_Smoothing_25;
public:
inline static int32_t get_offset_of_m_Color_23() { return static_cast<int32_t>(offsetof(ColorByDensity_t1246500786, ___m_Color_23)); }
inline FluvioMinMaxGradient_t1663705874 * get_m_Color_23() const { return ___m_Color_23; }
inline FluvioMinMaxGradient_t1663705874 ** get_address_of_m_Color_23() { return &___m_Color_23; }
inline void set_m_Color_23(FluvioMinMaxGradient_t1663705874 * value)
{
___m_Color_23 = value;
Il2CppCodeGenWriteBarrier((&___m_Color_23), value);
}
inline static int32_t get_offset_of_m_Range_24() { return static_cast<int32_t>(offsetof(ColorByDensity_t1246500786, ___m_Range_24)); }
inline Vector2_t2156229523 get_m_Range_24() const { return ___m_Range_24; }
inline Vector2_t2156229523 * get_address_of_m_Range_24() { return &___m_Range_24; }
inline void set_m_Range_24(Vector2_t2156229523 value)
{
___m_Range_24 = value;
}
inline static int32_t get_offset_of_m_Smoothing_25() { return static_cast<int32_t>(offsetof(ColorByDensity_t1246500786, ___m_Smoothing_25)); }
inline float get_m_Smoothing_25() const { return ___m_Smoothing_25; }
inline float* get_address_of_m_Smoothing_25() { return &___m_Smoothing_25; }
inline void set_m_Smoothing_25(float value)
{
___m_Smoothing_25 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // COLORBYDENSITY_T1246500786_H
#ifndef FLUIDELLIPSOIDEFFECTOR_T2896179852_H
#define FLUIDELLIPSOIDEFFECTOR_T2896179852_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// Thinksquirrel.Fluvio.Plugins.Effectors.FluidEllipsoidEffector
struct FluidEllipsoidEffector_t2896179852 : public FluidEffector_t2260861129
{
public:
// UnityEngine.Vector3 Thinksquirrel.Fluvio.Plugins.Effectors.FluidEllipsoidEffector::m_Dimensions
Vector3_t3722313464 ___m_Dimensions_38;
public:
inline static int32_t get_offset_of_m_Dimensions_38() { return static_cast<int32_t>(offsetof(FluidEllipsoidEffector_t2896179852, ___m_Dimensions_38)); }
inline Vector3_t3722313464 get_m_Dimensions_38() const { return ___m_Dimensions_38; }
inline Vector3_t3722313464 * get_address_of_m_Dimensions_38() { return &___m_Dimensions_38; }
inline void set_m_Dimensions_38(Vector3_t3722313464 value)
{
___m_Dimensions_38 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // FLUIDELLIPSOIDEFFECTOR_T2896179852_H
#ifndef FLUIDPOINTEFFECTOR_T2498546057_H
#define FLUIDPOINTEFFECTOR_T2498546057_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// Thinksquirrel.Fluvio.Plugins.Effectors.FluidPointEffector
struct FluidPointEffector_t2498546057 : public FluidEffector_t2260861129
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // FLUIDPOINTEFFECTOR_T2498546057_H
#ifndef FLUIDCUBEEFFECTOR_T1949128119_H
#define FLUIDCUBEEFFECTOR_T1949128119_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// Thinksquirrel.Fluvio.Plugins.Effectors.FluidCubeEffector
struct FluidCubeEffector_t1949128119 : public FluidEffector_t2260861129
{
public:
// UnityEngine.Vector3 Thinksquirrel.Fluvio.Plugins.Effectors.FluidCubeEffector::m_Dimensions
Vector3_t3722313464 ___m_Dimensions_38;
public:
inline static int32_t get_offset_of_m_Dimensions_38() { return static_cast<int32_t>(offsetof(FluidCubeEffector_t1949128119, ___m_Dimensions_38)); }
inline Vector3_t3722313464 get_m_Dimensions_38() const { return ___m_Dimensions_38; }
inline Vector3_t3722313464 * get_address_of_m_Dimensions_38() { return &___m_Dimensions_38; }
inline void set_m_Dimensions_38(Vector3_t3722313464 value)
{
___m_Dimensions_38 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // FLUIDCUBEEFFECTOR_T1949128119_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2100 = { 0, -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2101 = { 0, -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2102 = { sizeof (int4_t93086280)+ sizeof (RuntimeObject), sizeof(int4_t93086280 ), 0, 0 };
extern const int32_t g_FieldOffsetTable2102[4] =
{
int4_t93086280::get_offset_of_x_0() + static_cast<int32_t>(sizeof(RuntimeObject)),
int4_t93086280::get_offset_of_y_1() + static_cast<int32_t>(sizeof(RuntimeObject)),
int4_t93086280::get_offset_of_z_2() + static_cast<int32_t>(sizeof(RuntimeObject)),
int4_t93086280::get_offset_of_w_3() + static_cast<int32_t>(sizeof(RuntimeObject)),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2103 = { sizeof (FluidData_t3912775833)+ sizeof (RuntimeObject), sizeof(FluidData_t3912775833 ), 0, 0 };
extern const int32_t g_FieldOffsetTable2103[9] =
{
FluidData_t3912775833::get_offset_of_gravity_0() + static_cast<int32_t>(sizeof(RuntimeObject)),
FluidData_t3912775833::get_offset_of_initialDensity_1() + static_cast<int32_t>(sizeof(RuntimeObject)),
FluidData_t3912775833::get_offset_of_minimumDensity_2() + static_cast<int32_t>(sizeof(RuntimeObject)),
FluidData_t3912775833::get_offset_of_particleMass_3() + static_cast<int32_t>(sizeof(RuntimeObject)),
FluidData_t3912775833::get_offset_of_viscosity_4() + static_cast<int32_t>(sizeof(RuntimeObject)),
FluidData_t3912775833::get_offset_of_turbulence_5() + static_cast<int32_t>(sizeof(RuntimeObject)),
FluidData_t3912775833::get_offset_of_surfaceTension_6() + static_cast<int32_t>(sizeof(RuntimeObject)),
FluidData_t3912775833::get_offset_of_gasConstant_7() + static_cast<int32_t>(sizeof(RuntimeObject)),
FluidData_t3912775833::get_offset_of_buoyancyCoefficient_8() + static_cast<int32_t>(sizeof(RuntimeObject)),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2104 = { sizeof (FluidParticle_t651938203)+ sizeof (RuntimeObject), sizeof(FluidParticle_t651938203 ), 0, 0 };
extern const int32_t g_FieldOffsetTable2104[9] =
{
FluidParticle_t651938203::get_offset_of_position_0() + static_cast<int32_t>(sizeof(RuntimeObject)),
FluidParticle_t651938203::get_offset_of_velocity_1() + static_cast<int32_t>(sizeof(RuntimeObject)),
FluidParticle_t651938203::get_offset_of_color_2() + static_cast<int32_t>(sizeof(RuntimeObject)),
FluidParticle_t651938203::get_offset_of_vorticityTurbulence_3() + static_cast<int32_t>(sizeof(RuntimeObject)),
FluidParticle_t651938203::get_offset_of_lifetime_4() + static_cast<int32_t>(sizeof(RuntimeObject)),
FluidParticle_t651938203::get_offset_of_id_5() + static_cast<int32_t>(sizeof(RuntimeObject)),
FluidParticle_t651938203::get_offset_of_force_6() + static_cast<int32_t>(sizeof(RuntimeObject)),
FluidParticle_t651938203::get_offset_of_normal_7() + static_cast<int32_t>(sizeof(RuntimeObject)),
FluidParticle_t651938203::get_offset_of_densityPressure_8() + static_cast<int32_t>(sizeof(RuntimeObject)),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2105 = { sizeof (SolverDataInternal_t3200118405), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable2105[18] =
{
SolverDataInternal_t3200118405::get_offset_of__Count_0(),
SolverDataInternal_t3200118405::get_offset_of__Stride_1(),
SolverDataInternal_t3200118405::get_offset_of__Time_2(),
SolverDataInternal_t3200118405::get_offset_of__KernelSize_3(),
SolverDataInternal_t3200118405::get_offset_of__KernelFactors_4(),
SolverDataInternal_t3200118405::get_offset_of__fluidChanged_5(),
SolverDataInternal_t3200118405::get_offset_of__boundaryParticlesChanged_6(),
SolverDataInternal_t3200118405::get_offset_of__computeAPI_7(),
SolverDataInternal_t3200118405::get_offset_of__Fluid_8(),
SolverDataInternal_t3200118405::get_offset_of__Particle_9(),
SolverDataInternal_t3200118405::get_offset_of__BoundaryParticle_10(),
SolverDataInternal_t3200118405::get_offset_of__IndexGrid_11(),
SolverDataInternal_t3200118405::get_offset_of__Neighbors_12(),
SolverDataInternal_t3200118405::get_offset_of__fluidCB_13(),
SolverDataInternal_t3200118405::get_offset_of__particleCB_14(),
SolverDataInternal_t3200118405::get_offset_of__boundaryParticleCB_15(),
SolverDataInternal_t3200118405::get_offset_of__indexGridCB_16(),
SolverDataInternal_t3200118405::get_offset_of__neighborsCB_17(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2106 = { sizeof (FluidSolver_t3145627998), -1, sizeof(FluidSolver_t3145627998_StaticFields), 0 };
extern const int32_t g_FieldOffsetTable2106[48] =
{
FluidSolver_t3145627998::get_offset_of_m_Timers_0(),
FluidSolver_t3145627998::get_offset_of_m_RootFluid_1(),
FluidSolver_t3145627998::get_offset_of_m_Fluids_2(),
FluidSolver_t3145627998::get_offset_of_Poly6_3(),
FluidSolver_t3145627998::get_offset_of_Spiky_4(),
FluidSolver_t3145627998::get_offset_of_Viscosity_5(),
FluidSolver_t3145627998::get_offset_of_m_ComputeShader_6(),
FluidSolver_t3145627998::get_offset_of_m_SolverBoundaryTexture_7(),
FluidSolver_t3145627998::get_offset_of_m_SolverIndexGridClear_8(),
FluidSolver_t3145627998::get_offset_of_m_SolverIndexGridAdd_9(),
FluidSolver_t3145627998::get_offset_of_m_SolverNeighborSearchGrid2D_10(),
FluidSolver_t3145627998::get_offset_of_m_SolverNeighborSearchGrid3D_11(),
FluidSolver_t3145627998::get_offset_of_m_SolverNeighborSearch2D_12(),
FluidSolver_t3145627998::get_offset_of_m_SolverNeighborSearch3D_13(),
FluidSolver_t3145627998::get_offset_of_m_SolverDensityPressure_14(),
FluidSolver_t3145627998::get_offset_of_m_SolverNormal_15(),
FluidSolver_t3145627998::get_offset_of_m_SolverForces_16(),
FluidSolver_t3145627998::get_offset_of_m_SolverBoundaryForces_17(),
FluidSolver_t3145627998::get_offset_of_m_SolverTurbulence_18(),
FluidSolver_t3145627998::get_offset_of_m_SolverExternalForces_19(),
FluidSolver_t3145627998::get_offset_of_m_SolverConstraints_20(),
FluidSolver_t3145627998::get_offset_of_m_SolverIndexGridAddDel_21(),
FluidSolver_t3145627998::get_offset_of_m_SolverNeighborSearchGrid2DDel_22(),
FluidSolver_t3145627998::get_offset_of_m_SolverNeighborSearchGrid3DDel_23(),
FluidSolver_t3145627998::get_offset_of_m_SolverNeighborSearch2DDel_24(),
FluidSolver_t3145627998::get_offset_of_m_SolverNeighborSearch3DDel_25(),
FluidSolver_t3145627998::get_offset_of_m_SolverDensityPressureDel_26(),
FluidSolver_t3145627998::get_offset_of_m_SolverNormalDel_27(),
FluidSolver_t3145627998::get_offset_of_m_SolverForcesDel_28(),
FluidSolver_t3145627998::get_offset_of_m_SolverBoundaryForcesDel_29(),
FluidSolver_t3145627998::get_offset_of_m_SolverTurbulenceDel_30(),
FluidSolver_t3145627998::get_offset_of_m_SolverExternalForcesDel_31(),
FluidSolver_t3145627998::get_offset_of_m_SolverConstraintsDel_32(),
FluidSolver_t3145627998::get_offset_of_m_DoForEachParticleDynamicDel_33(),
FluidSolver_t3145627998::get_offset_of_m_DoForEachParticleDel_34(),
FluidSolver_t3145627998::get_offset_of_m_DoForEachParticleAllDel_35(),
FluidSolver_t3145627998::get_offset_of_m_DoForEachParticleBoundaryDel_36(),
FluidSolver_t3145627998::get_offset_of_m_DoForEachParticlePairDel_37(),
FluidSolver_t3145627998::get_offset_of_m_CurrentParticleDel_38(),
FluidSolver_t3145627998::get_offset_of_m_CurrentParticlePairDel_39(),
FluidSolver_t3145627998::get_offset_of_m_ComputeShouldSync_40(),
FluidSolver_t3145627998::get_offset_of_fluvio_41(),
FluidSolver_t3145627998::get_offset_of_m_SolverTimer_42(),
FluidSolver_t3145627998::get_offset_of_m_PluginsTimer_43(),
FluidSolver_t3145627998::get_offset_of_m_IsMobilePlatform_44(),
FluidSolver_t3145627998_StaticFields::get_offset_of__onPostSolve_45(),
FluidSolver_t3145627998::get_offset_of_U3CcanUseFastIntegrationPathU3Ek__BackingField_46(),
FluidSolver_t3145627998_StaticFields::get_offset_of_U3CU3Ef__amU24cache2F_47(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2107 = { sizeof (IndexGrid_t759839143), -1, sizeof(IndexGrid_t759839143_StaticFields), 0 };
extern const int32_t g_FieldOffsetTable2107[4] =
{
IndexGrid_t759839143::get_offset_of_m_Grid_0(),
IndexGrid_t759839143::get_offset_of_m_CellSpace_1(),
IndexGrid_t759839143_StaticFields::get_offset_of_s_Clear_2(),
IndexGrid_t759839143::get_offset_of_s_DoClearDel_3(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2108 = { sizeof (Poly6Kernel_t3858493335), -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2109 = { sizeof (SmoothingKernel_t2173549093), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable2109[6] =
{
SmoothingKernel_t2173549093::get_offset_of_factor_0(),
SmoothingKernel_t2173549093::get_offset_of_kernelSize_1(),
SmoothingKernel_t2173549093::get_offset_of_kernelSize3_2(),
SmoothingKernel_t2173549093::get_offset_of_kernelSize6_3(),
SmoothingKernel_t2173549093::get_offset_of_kernelSize9_4(),
SmoothingKernel_t2173549093::get_offset_of_kernelSizeSq_5(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2110 = { sizeof (SolverUtility_t1140880853), -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2111 = { sizeof (SpikyKernel_t887830178), -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2112 = { sizeof (ViscosityKernel_t39108085), -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2113 = { sizeof (FluvioThreadPool_t2773119480), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable2113[12] =
{
FluvioThreadPool_t2773119480::get_offset_of__queue_0(),
FluvioThreadPool_t2773119480::get_offset_of__workerThreads_1(),
FluvioThreadPool_t2773119480::get_offset_of__totalThreadCount_2(),
FluvioThreadPool_t2773119480::get_offset_of__maxTaskCount_3(),
FluvioThreadPool_t2773119480::get_offset_of__tasksCompleted_4(),
FluvioThreadPool_t2773119480::get_offset_of__taskCount_5(),
FluvioThreadPool_t2773119480::get_offset_of__isStarted_6(),
FluvioThreadPool_t2773119480::get_offset_of__isFinished_7(),
FluvioThreadPool_t2773119480::get_offset_of__shouldStopThreads_8(),
FluvioThreadPool_t2773119480::get_offset_of__disposed_9(),
FluvioThreadPool_t2773119480::get_offset_of__interlocked_10(),
FluvioThreadPool_t2773119480::get_offset_of__threadHandler_11(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2114 = { sizeof (Task_t450454083)+ sizeof (RuntimeObject), sizeof(Task_t450454083_marshaled_pinvoke), 0, 0 };
extern const int32_t g_FieldOffsetTable2114[3] =
{
Task_t450454083::get_offset_of_StartIndex_0() + static_cast<int32_t>(sizeof(RuntimeObject)),
Task_t450454083::get_offset_of_EndIndex_1() + static_cast<int32_t>(sizeof(RuntimeObject)),
Task_t450454083::get_offset_of_action_2() + static_cast<int32_t>(sizeof(RuntimeObject)),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2115 = { 0, -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2116 = { 0, -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2117 = { 0, -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2118 = { 0, -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2119 = { 0, 0, 0, 0 };
extern const int32_t g_FieldOffsetTable2119[14] =
{
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2120 = { 0, 0, 0, 0 };
extern const int32_t g_FieldOffsetTable2120[1] =
{
0,
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2121 = { sizeof (Parallel_t1515900394), -1, sizeof(Parallel_t1515900394_StaticFields), 0 };
extern const int32_t g_FieldOffsetTable2121[2] =
{
Parallel_t1515900394_StaticFields::get_offset_of__threadPool_0(),
Parallel_t1515900394_StaticFields::get_offset_of__interlocked_1(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2122 = { sizeof (ColorByDensity_t1246500786), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable2122[3] =
{
ColorByDensity_t1246500786::get_offset_of_m_Color_23(),
ColorByDensity_t1246500786::get_offset_of_m_Range_24(),
ColorByDensity_t1246500786::get_offset_of_m_Smoothing_25(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2123 = { sizeof (FluidDebug_t1986102106), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable2123[16] =
{
FluidDebug_t1986102106::get_offset_of_m_DebugText_12(),
FluidDebug_t1986102106::get_offset_of_m_UpdateInterval_13(),
FluidDebug_t1986102106::get_offset_of_m_AutoGeneratedText_14(),
FluidDebug_t1986102106::get_offset_of_m_TimeLeft_15(),
FluidDebug_t1986102106::get_offset_of_m_AccumulatorSolverTime_16(),
FluidDebug_t1986102106::get_offset_of_m_AccumulatorGPUPluginsTime_17(),
FluidDebug_t1986102106::get_offset_of_m_AccumulatorPluginsTime_18(),
FluidDebug_t1986102106::get_offset_of_m_AccumulatorOverheadTime_19(),
FluidDebug_t1986102106::get_offset_of_m_AccumulatorTotalTime_20(),
FluidDebug_t1986102106::get_offset_of_m_SolverTime_21(),
FluidDebug_t1986102106::get_offset_of_m_GPUPluginsTime_22(),
FluidDebug_t1986102106::get_offset_of_m_PluginsTime_23(),
FluidDebug_t1986102106::get_offset_of_m_OverheadTime_24(),
FluidDebug_t1986102106::get_offset_of_m_TotalTime_25(),
FluidDebug_t1986102106::get_offset_of_m_LastTime_26(),
FluidDebug_t1986102106::get_offset_of_m_Frames_27(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2124 = { sizeof (FluidParallelPlugin_t3366117264), -1, sizeof(FluidParallelPlugin_t3366117264_StaticFields), 0 };
extern const int32_t g_FieldOffsetTable2124[11] =
{
FluidParallelPlugin_t3366117264::get_offset_of_m_IncludeFluidGroup_12(),
FluidParallelPlugin_t3366117264::get_offset_of_m_RunAcceleratedOnly_13(),
FluidParallelPlugin_t3366117264::get_offset_of_m_ComputeShader_14(),
FluidParallelPlugin_t3366117264::get_offset_of_m_ComputeShaderKernelIndex_15(),
FluidParallelPlugin_t3366117264::get_offset_of_m_IsValidComputePlugin_16(),
FluidParallelPlugin_t3366117264::get_offset_of_m_ShouldUpdate_17(),
FluidParallelPlugin_t3366117264::get_offset_of_m_Timer_18(),
FluidParallelPlugin_t3366117264::get_offset_of_m_PluginBuffers_19(),
FluidParallelPlugin_t3366117264::get_offset_of_m_BufferValueCache_20(),
FluidParallelPlugin_t3366117264_StaticFields::get_offset_of_U3CU3Ef__amU24cache9_21(),
FluidParallelPlugin_t3366117264_StaticFields::get_offset_of_U3CU3Ef__amU24cacheA_22(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2125 = { sizeof (FluidParticlePairPlugin_t2917011702), -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2126 = { sizeof (FluidParticlePlugin_t2087845768), -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2127 = { sizeof (FluidPlugin_t2696458681), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable2127[6] =
{
0,
FluidPlugin_t2696458681::get_offset_of_m_Fluid_7(),
FluidPlugin_t2696458681::get_offset_of_m_Weight_8(),
FluidPlugin_t2696458681::get_offset_of_m_MonoScriptInitialized_9(),
FluidPlugin_t2696458681::get_offset_of__pluginID_10(),
FluidPlugin_t2696458681::get_offset_of_m_ResetWeight_11(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2128 = { sizeof (PhaseChange_t1879784979), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable2128[8] =
{
PhaseChange_t1879784979::get_offset_of_m_OtherParticleSystem_23(),
PhaseChange_t1879784979::get_offset_of_m_ComparisonType_24(),
PhaseChange_t1879784979::get_offset_of_m_DensityThreshold_25(),
PhaseChange_t1879784979::get_offset_of_m_PhaseChangeData_26(),
PhaseChange_t1879784979::get_offset_of_m_Gravity_27(),
PhaseChange_t1879784979::get_offset_of_m_TimeStep_28(),
PhaseChange_t1879784979::get_offset_of_m_Count_29(),
PhaseChange_t1879784979::get_offset_of_m_SimulationScale_30(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2129 = { sizeof (ComparisonType_t4142182662)+ sizeof (RuntimeObject), sizeof(int32_t), 0, 0 };
extern const int32_t g_FieldOffsetTable2129[3] =
{
ComparisonType_t4142182662::get_offset_of_value___1() + static_cast<int32_t>(sizeof(RuntimeObject)),
0,
0,
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2130 = { sizeof (PhaseChangeData_t3151312502)+ sizeof (RuntimeObject), sizeof(PhaseChangeData_t3151312502 ), 0, 0 };
extern const int32_t g_FieldOffsetTable2130[3] =
{
PhaseChangeData_t3151312502::get_offset_of_emitPosition_0() + static_cast<int32_t>(sizeof(RuntimeObject)),
PhaseChangeData_t3151312502::get_offset_of_emitVelocity_1() + static_cast<int32_t>(sizeof(RuntimeObject)),
PhaseChangeData_t3151312502::get_offset_of_pluginParams_2() + static_cast<int32_t>(sizeof(RuntimeObject)),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2131 = { sizeof (SizeByDensity_t240071710), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable2131[3] =
{
SizeByDensity_t240071710::get_offset_of_m_Size_23(),
SizeByDensity_t240071710::get_offset_of_m_Range_24(),
SizeByDensity_t240071710::get_offset_of_m_Smoothing_25(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2132 = { sizeof (SolverData_t3372117984), -1, 0, sizeof(SolverData_t3372117984_ThreadStaticFields) };
extern const int32_t g_FieldOffsetTable2132[3] =
{
THREAD_STATIC_FIELD_OFFSET,
SolverData_t3372117984::get_offset_of_m_InternalSolver_1(),
SolverData_t3372117984::get_offset_of_fluvio_2(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2133 = { sizeof (FluidCubeEffector_t1949128119), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable2133[1] =
{
FluidCubeEffector_t1949128119::get_offset_of_m_Dimensions_38(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2134 = { sizeof (FluidEffector_t2260861129), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable2134[15] =
{
FluidEffector_t2260861129::get_offset_of_m_AllowBufferReadback_23(),
FluidEffector_t2260861129::get_offset_of_m_ForceType_24(),
FluidEffector_t2260861129::get_offset_of_m_ForceAxis_25(),
FluidEffector_t2260861129::get_offset_of_m_Force_26(),
FluidEffector_t2260861129::get_offset_of_m_Vorticity_27(),
FluidEffector_t2260861129::get_offset_of_m_EffectorRange_28(),
FluidEffector_t2260861129::get_offset_of_m_DecayType_29(),
FluidEffector_t2260861129::get_offset_of_m_Decay_30(),
FluidEffector_t2260861129::get_offset_of_m_DecayJitter_31(),
FluidEffector_t2260861129::get_offset_of_m_Position_32(),
FluidEffector_t2260861129::get_offset_of__worldToLocalMatrix_33(),
FluidEffector_t2260861129::get_offset_of__localToWorldMatrix_34(),
FluidEffector_t2260861129::get_offset_of__decayParams_35(),
FluidEffector_t2260861129::get_offset_of__forceDirection_36(),
FluidEffector_t2260861129::get_offset_of__particlesInEffector_37(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2135 = { sizeof (FluidEffectorData_t883069132)+ sizeof (RuntimeObject), sizeof(FluidEffectorData_t883069132 ), 0, 0 };
extern const int32_t g_FieldOffsetTable2135[10] =
{
FluidEffectorData_t883069132::get_offset_of_worldToLocalMatrix_0() + static_cast<int32_t>(sizeof(RuntimeObject)),
FluidEffectorData_t883069132::get_offset_of_position_1() + static_cast<int32_t>(sizeof(RuntimeObject)),
FluidEffectorData_t883069132::get_offset_of_worldPosition_2() + static_cast<int32_t>(sizeof(RuntimeObject)),
FluidEffectorData_t883069132::get_offset_of_extents_3() + static_cast<int32_t>(sizeof(RuntimeObject)),
FluidEffectorData_t883069132::get_offset_of_decayParams_4() + static_cast<int32_t>(sizeof(RuntimeObject)),
FluidEffectorData_t883069132::get_offset_of_forceDirection_5() + static_cast<int32_t>(sizeof(RuntimeObject)),
FluidEffectorData_t883069132::get_offset_of_effectorRange_6() + static_cast<int32_t>(sizeof(RuntimeObject)),
FluidEffectorData_t883069132::get_offset_of_unused0_7() + static_cast<int32_t>(sizeof(RuntimeObject)),
FluidEffectorData_t883069132::get_offset_of_unused1_8() + static_cast<int32_t>(sizeof(RuntimeObject)),
FluidEffectorData_t883069132::get_offset_of_unused2_9() + static_cast<int32_t>(sizeof(RuntimeObject)),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2136 = { sizeof (FluidEllipsoidEffector_t2896179852), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable2136[1] =
{
FluidEllipsoidEffector_t2896179852::get_offset_of_m_Dimensions_38(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2137 = { sizeof (FluidPointEffector_t2498546057), -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2138 = { sizeof (SolverParticleDelegate_t4224278369), sizeof(Il2CppMethodPointer), 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2139 = { sizeof (SolverParticlePairDelegate_t2332887997), sizeof(Il2CppMethodPointer), 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2140 = { sizeof (ParallelAction_t3477057985), sizeof(Il2CppMethodPointer), 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2141 = { sizeof (U3CModuleU3E_t692745551), -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2142 = { sizeof (DefaultInitializationErrorHandlerInternal_t2721934644), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable2142[9] =
{
DefaultInitializationErrorHandlerInternal_t2721934644::get_offset_of_mErrorText_2(),
DefaultInitializationErrorHandlerInternal_t2721934644::get_offset_of_mErrorOccurred_3(),
0,
DefaultInitializationErrorHandlerInternal_t2721934644::get_offset_of_bodyStyle_5(),
DefaultInitializationErrorHandlerInternal_t2721934644::get_offset_of_headerStyle_6(),
DefaultInitializationErrorHandlerInternal_t2721934644::get_offset_of_footerStyle_7(),
DefaultInitializationErrorHandlerInternal_t2721934644::get_offset_of_bodyTexture_8(),
DefaultInitializationErrorHandlerInternal_t2721934644::get_offset_of_headerTexture_9(),
DefaultInitializationErrorHandlerInternal_t2721934644::get_offset_of_footerTexture_10(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2143 = { sizeof (DefaultInitializationErrorHandlerPlaceHolder_t270221276), -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2144 = { sizeof (DefaultTrackableBehaviourPlaceholder_t3249521055), -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2145 = { sizeof (ARController_t116632334), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable2145[1] =
{
ARController_t116632334::get_offset_of_mVuforiaBehaviour_0(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2146 = { sizeof (U3CU3Ec__DisplayClass11_0_t2669575632), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable2146[1] =
{
U3CU3Ec__DisplayClass11_0_t2669575632::get_offset_of_controller_0(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2147 = { sizeof (IlluminationManager_t3960931838), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable2147[2] =
{
0,
IlluminationManager_t3960931838::get_offset_of_mIlluminationData_1(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2148 = { 0, -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2149 = { 0, -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2150 = { sizeof (PositionalDeviceTrackerImpl_t1314438186), -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2151 = { sizeof (PositionalPlayModeDeviceTrackerImpl_t1348222404), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable2151[6] =
{
0,
0,
PositionalPlayModeDeviceTrackerImpl_t1348222404::get_offset_of_mTrackableId_3(),
PositionalPlayModeDeviceTrackerImpl_t1348222404::get_offset_of_mEmulatorDataset_4(),
PositionalPlayModeDeviceTrackerImpl_t1348222404::get_offset_of_U3CPositionU3Ek__BackingField_5(),
PositionalPlayModeDeviceTrackerImpl_t1348222404::get_offset_of_U3CRotationU3Ek__BackingField_6(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2152 = { sizeof (U3CU3Ec_t2220019719), -1, sizeof(U3CU3Ec_t2220019719_StaticFields), 0 };
extern const int32_t g_FieldOffsetTable2152[3] =
{
U3CU3Ec_t2220019719_StaticFields::get_offset_of_U3CU3E9_0(),
U3CU3Ec_t2220019719_StaticFields::get_offset_of_U3CU3E9__14_0_1(),
U3CU3Ec_t2220019719_StaticFields::get_offset_of_U3CU3E9__14_1_2(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2153 = { sizeof (PositionalDeviceTracker_t656722001), -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2154 = { sizeof (StaticWebCamTexAdaptor_t4059221982), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable2154[1] =
{
StaticWebCamTexAdaptor_t4059221982::get_offset_of_U3CTextureU3Ek__BackingField_0(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2155 = { sizeof (AnchorBehaviour_t2000812465), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable2155[2] =
{
0,
AnchorBehaviour_t2000812465::get_offset_of_mAnchor_11(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2156 = { sizeof (GuideViewCameraBehaviour_t721959276), -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2157 = { sizeof (DataSetExtendedTrackingImpl_t3413727792), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable2157[2] =
{
DataSetExtendedTrackingImpl_t3413727792::get_offset_of_mId_0(),
DataSetExtendedTrackingImpl_t3413727792::get_offset_of_mDataSetPtr_1(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2158 = { sizeof (DisabledExtendedTrackingImpl_t4193346383), -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2159 = { sizeof (ModelTargetBoundingBoxImpl_t1878120817), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable2159[2] =
{
ModelTargetBoundingBoxImpl_t1878120817::get_offset_of_mDataSet_0(),
ModelTargetBoundingBoxImpl_t1878120817::get_offset_of_mName_1(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2160 = { sizeof (VuforiaNativeExtendedTrackingImpl_t571837481), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable2160[2] =
{
VuforiaNativeExtendedTrackingImpl_t571837481::get_offset_of_mId_0(),
VuforiaNativeExtendedTrackingImpl_t571837481::get_offset_of_mDataSetPtr_1(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2161 = { sizeof (AndroidDatasets_t3742019579), -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2162 = { sizeof (AndroidUnityPlayer_t2737599080), -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2163 = { sizeof (IOSUnityPlayer_t2555589894), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable2163[1] =
{
IOSUnityPlayer_t2555589894::get_offset_of_mScreenOrientation_0(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2164 = { sizeof (PlatformRuntimeInitialization_t3141452252), -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2165 = { sizeof (PlayModeUnityPlayer_t3763348594), -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2166 = { sizeof (WSAUnityPlayer_t3135728299), -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2167 = { sizeof (VideoBackgroundDefaultProvider_t2109766439), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable2167[3] =
{
0,
0,
0,
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2168 = { sizeof (PlanesHideExcessAreaClipping_t1460129200), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable2168[5] =
{
0,
PlanesHideExcessAreaClipping_t1460129200::get_offset_of_mMatteShader_1(),
PlanesHideExcessAreaClipping_t1460129200::get_offset_of_mClippingPlanes_2(),
PlanesHideExcessAreaClipping_t1460129200::get_offset_of_mPlanesActivated_3(),
PlanesHideExcessAreaClipping_t1460129200::get_offset_of_mClippingScale_4(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2169 = { sizeof (PlanePos_t1459879262)+ sizeof (RuntimeObject), sizeof(int32_t), 0, 0 };
extern const int32_t g_FieldOffsetTable2169[5] =
{
PlanePos_t1459879262::get_offset_of_value___1() + static_cast<int32_t>(sizeof(RuntimeObject)),
0,
0,
0,
0,
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2170 = { sizeof (VuforiaVRDeviceCameraConfiguration_t3308462389), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable2170[3] =
{
0,
VuforiaVRDeviceCameraConfiguration_t3308462389::get_offset_of_mStereoOffset_26(),
VuforiaVRDeviceCameraConfiguration_t3308462389::get_offset_of_mDelayedVideoBackgroundEnabledChanged_27(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2171 = { 0, -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2172 = { sizeof (StereoProjMatrixStore_t888524276), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable2172[9] =
{
StereoProjMatrixStore_t888524276::get_offset_of_mCamera_0(),
StereoProjMatrixStore_t888524276::get_offset_of_mProjectionMatrices_1(),
StereoProjMatrixStore_t888524276::get_offset_of_mAppliedVerticalFoVs_2(),
StereoProjMatrixStore_t888524276::get_offset_of_mCurrentVerticalFoVs_3(),
StereoProjMatrixStore_t888524276::get_offset_of_mSharedCullingProjectionMatrix_4(),
StereoProjMatrixStore_t888524276::get_offset_of_mSharedCullingViewMatrix_5(),
StereoProjMatrixStore_t888524276::get_offset_of_mLeftEyeOffsetMatrix_6(),
StereoProjMatrixStore_t888524276::get_offset_of_mRightEyeOffsetMatrix_7(),
StereoProjMatrixStore_t888524276::get_offset_of_mMode_8(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2173 = { sizeof (Mode_t2291249183)+ sizeof (RuntimeObject), sizeof(int32_t), 0, 0 };
extern const int32_t g_FieldOffsetTable2173[3] =
{
Mode_t2291249183::get_offset_of_value___1() + static_cast<int32_t>(sizeof(RuntimeObject)),
0,
0,
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2174 = { sizeof (ExternalVRDeviceCameraConfiguration_t152468891), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable2174[2] =
{
0,
ExternalVRDeviceCameraConfiguration_t152468891::get_offset_of_mLastWorldCenterMode_26(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2175 = { sizeof (VRDeviceCameraConfiguration_t3015543037), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable2175[15] =
{
0,
VRDeviceCameraConfiguration_t3015543037::get_offset_of_mCamera_11(),
VRDeviceCameraConfiguration_t3015543037::get_offset_of_mMatrixStore_12(),
VRDeviceCameraConfiguration_t3015543037::get_offset_of_mLeftMatrixUsedForVBPlacement_13(),
VRDeviceCameraConfiguration_t3015543037::get_offset_of_mLastAppliedNearClipPlane_14(),
VRDeviceCameraConfiguration_t3015543037::get_offset_of_mLastAppliedFarClipPlane_15(),
VRDeviceCameraConfiguration_t3015543037::get_offset_of_mMaxDepthForVideoBackground_16(),
VRDeviceCameraConfiguration_t3015543037::get_offset_of_mMinDepthForVideoBackground_17(),
VRDeviceCameraConfiguration_t3015543037::get_offset_of_mScreenWidth_18(),
VRDeviceCameraConfiguration_t3015543037::get_offset_of_mScreenHeight_19(),
VRDeviceCameraConfiguration_t3015543037::get_offset_of_mStereoDepth_20(),
VRDeviceCameraConfiguration_t3015543037::get_offset_of_mResetMatrix_21(),
VRDeviceCameraConfiguration_t3015543037::get_offset_of_mVuforiaFrustumSkew_22(),
VRDeviceCameraConfiguration_t3015543037::get_offset_of_mCenterToEyeAxis_23(),
VRDeviceCameraConfiguration_t3015543037::get_offset_of_mVrDeviceController_24(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2176 = { sizeof (DigitalEyewearARController_t1054226036), -1, sizeof(DigitalEyewearARController_t1054226036_StaticFields), 0 };
extern const int32_t g_FieldOffsetTable2176[21] =
{
0,
0,
0,
0,
0,
DigitalEyewearARController_t1054226036::get_offset_of_mCameraOffset_6(),
DigitalEyewearARController_t1054226036::get_offset_of_mDistortionRenderingLayer_7(),
DigitalEyewearARController_t1054226036::get_offset_of_mEyewearType_8(),
DigitalEyewearARController_t1054226036::get_offset_of_mStereoFramework_9(),
DigitalEyewearARController_t1054226036::get_offset_of_mSeeThroughConfiguration_10(),
DigitalEyewearARController_t1054226036::get_offset_of_mViewerName_11(),
DigitalEyewearARController_t1054226036::get_offset_of_mViewerManufacturer_12(),
DigitalEyewearARController_t1054226036::get_offset_of_mUseCustomViewer_13(),
DigitalEyewearARController_t1054226036::get_offset_of_mCustomViewer_14(),
DigitalEyewearARController_t1054226036::get_offset_of_mCentralAnchorPoint_15(),
DigitalEyewearARController_t1054226036::get_offset_of_mPrimaryCamera_16(),
DigitalEyewearARController_t1054226036::get_offset_of_mVuforiaBehaviour_17(),
DigitalEyewearARController_t1054226036::get_offset_of_mSetFocusPlaneAutomatically_18(),
DigitalEyewearARController_t1054226036::get_offset_of_mVRDeviceController_19(),
DigitalEyewearARController_t1054226036_StaticFields::get_offset_of_mInstance_20(),
DigitalEyewearARController_t1054226036_StaticFields::get_offset_of_mPadlock_21(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2177 = { sizeof (EyewearType_t2277580470)+ sizeof (RuntimeObject), sizeof(int32_t), 0, 0 };
extern const int32_t g_FieldOffsetTable2177[4] =
{
EyewearType_t2277580470::get_offset_of_value___1() + static_cast<int32_t>(sizeof(RuntimeObject)),
0,
0,
0,
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2178 = { sizeof (StereoFramework_t3144873991)+ sizeof (RuntimeObject), sizeof(int32_t), 0, 0 };
extern const int32_t g_FieldOffsetTable2178[3] =
{
StereoFramework_t3144873991::get_offset_of_value___1() + static_cast<int32_t>(sizeof(RuntimeObject)),
0,
0,
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2179 = { sizeof (SeeThroughConfiguration_t568665021)+ sizeof (RuntimeObject), sizeof(int32_t), 0, 0 };
extern const int32_t g_FieldOffsetTable2179[3] =
{
SeeThroughConfiguration_t568665021::get_offset_of_value___1() + static_cast<int32_t>(sizeof(RuntimeObject)),
0,
0,
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2180 = { sizeof (SerializableViewerParameters_t2043332680), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable2180[11] =
{
SerializableViewerParameters_t2043332680::get_offset_of_Version_0(),
SerializableViewerParameters_t2043332680::get_offset_of_Name_1(),
SerializableViewerParameters_t2043332680::get_offset_of_Manufacturer_2(),
SerializableViewerParameters_t2043332680::get_offset_of_ButtonType_3(),
SerializableViewerParameters_t2043332680::get_offset_of_ScreenToLensDistance_4(),
SerializableViewerParameters_t2043332680::get_offset_of_InterLensDistance_5(),
SerializableViewerParameters_t2043332680::get_offset_of_TrayAlignment_6(),
SerializableViewerParameters_t2043332680::get_offset_of_LensCenterToTrayDistance_7(),
SerializableViewerParameters_t2043332680::get_offset_of_DistortionCoefficients_8(),
SerializableViewerParameters_t2043332680::get_offset_of_FieldOfView_9(),
SerializableViewerParameters_t2043332680::get_offset_of_ContainsMagnet_10(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2181 = { sizeof (UnityComponentExtensions_t3737347336), -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2182 = { sizeof (AValidatableVideoBackgroundConfigProperty_t1108088413), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable2182[2] =
{
AValidatableVideoBackgroundConfigProperty_t1108088413::get_offset_of_Config_0(),
AValidatableVideoBackgroundConfigProperty_t1108088413::get_offset_of_DefaultProvider_1(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2183 = { sizeof (MatteShaderProperty_t20537457), -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2184 = { sizeof (NumDivisionsProperty_t690697662), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable2184[1] =
{
0,
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2185 = { sizeof (VideoBackgroundConfigValidator_t1958892045), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable2185[1] =
{
VideoBackgroundConfigValidator_t1958892045::get_offset_of_mValidatableProperties_0(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2186 = { sizeof (U3CU3Ec__DisplayClass2_0_t1369985473), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable2186[1] =
{
U3CU3Ec__DisplayClass2_0_t1369985473::get_offset_of_res_0(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2187 = { sizeof (VideoBackgroundShaderProperty_t2141633175), -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2188 = { sizeof (EyewearDevice_t3223385723), -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2189 = { sizeof (EyeID_t263427581)+ sizeof (RuntimeObject), sizeof(int32_t), 0, 0 };
extern const int32_t g_FieldOffsetTable2189[4] =
{
EyeID_t263427581::get_offset_of_value___1() + static_cast<int32_t>(sizeof(RuntimeObject)),
0,
0,
0,
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2190 = { sizeof (EyewearCalibrationReading_t664929988)+ sizeof (RuntimeObject), sizeof(EyewearCalibrationReading_t664929988_marshaled_pinvoke), 0, 0 };
extern const int32_t g_FieldOffsetTable2190[5] =
{
EyewearCalibrationReading_t664929988::get_offset_of_pose_0() + static_cast<int32_t>(sizeof(RuntimeObject)),
EyewearCalibrationReading_t664929988::get_offset_of_scale_1() + static_cast<int32_t>(sizeof(RuntimeObject)),
EyewearCalibrationReading_t664929988::get_offset_of_centerX_2() + static_cast<int32_t>(sizeof(RuntimeObject)),
EyewearCalibrationReading_t664929988::get_offset_of_centerY_3() + static_cast<int32_t>(sizeof(RuntimeObject)),
EyewearCalibrationReading_t664929988::get_offset_of_type_4() + static_cast<int32_t>(sizeof(RuntimeObject)),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2191 = { sizeof (AlignmentType_t1920855420)+ sizeof (RuntimeObject), sizeof(int32_t), 0, 0 };
extern const int32_t g_FieldOffsetTable2191[4] =
{
AlignmentType_t1920855420::get_offset_of_value___1() + static_cast<int32_t>(sizeof(RuntimeObject)),
0,
0,
0,
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2192 = { sizeof (GuideView_t516481509), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable2192[4] =
{
GuideView_t516481509::get_offset_of_U3CImageU3Ek__BackingField_0(),
GuideView_t516481509::get_offset_of_mInstancePtr_1(),
GuideView_t516481509::get_offset_of_mPose_2(),
GuideView_t516481509::get_offset_of_PropertyChanged_3(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2193 = { sizeof (GuideView2DBehaviour_t1196801781), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable2193[4] =
{
GuideView2DBehaviour_t1196801781::get_offset_of_mCameraAspect_2(),
GuideView2DBehaviour_t1196801781::get_offset_of_mCameraFOV_3(),
GuideView2DBehaviour_t1196801781::get_offset_of_mCameraNearPlane_4(),
GuideView2DBehaviour_t1196801781::get_offset_of_mGuideViewTexture_5(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2194 = { sizeof (GuideView3DBehaviour_t1129627381), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable2194[1] =
{
GuideView3DBehaviour_t1129627381::get_offset_of_mCurrentGuideView_2(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2195 = { sizeof (GuideViewRenderingBehaviour_t333084580), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable2195[11] =
{
GuideViewRenderingBehaviour_t333084580::get_offset_of_guideReappearanceDelay_2(),
0,
0,
GuideViewRenderingBehaviour_t333084580::get_offset_of_mTrackedTarget_5(),
GuideViewRenderingBehaviour_t333084580::get_offset_of_mGuideViewDisplayMode_6(),
GuideViewRenderingBehaviour_t333084580::get_offset_of_mGuideView_7(),
GuideViewRenderingBehaviour_t333084580::get_offset_of_mGuideViewInitialized_8(),
GuideViewRenderingBehaviour_t333084580::get_offset_of_mShowGuideViewCoroutine_9(),
GuideViewRenderingBehaviour_t333084580::get_offset_of_mGuideViewGameObject_10(),
GuideViewRenderingBehaviour_t333084580::get_offset_of_mGuideViewShown_11(),
GuideViewRenderingBehaviour_t333084580::get_offset_of_mPrevDepthTextureMode_12(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2196 = { sizeof (U3CShowGuideViewAfterU3Ed__21_t948075969), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable2196[4] =
{
U3CShowGuideViewAfterU3Ed__21_t948075969::get_offset_of_U3CU3E1__state_0(),
U3CShowGuideViewAfterU3Ed__21_t948075969::get_offset_of_U3CU3E2__current_1(),
U3CShowGuideViewAfterU3Ed__21_t948075969::get_offset_of_seconds_2(),
U3CShowGuideViewAfterU3Ed__21_t948075969::get_offset_of_U3CU3E4__this_3(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2197 = { sizeof (U3CSetChildOfVuforiaAnchorU3Ed__22_t1825058655), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable2197[3] =
{
U3CSetChildOfVuforiaAnchorU3Ed__22_t1825058655::get_offset_of_U3CU3E1__state_0(),
U3CSetChildOfVuforiaAnchorU3Ed__22_t1825058655::get_offset_of_U3CU3E2__current_1(),
U3CSetChildOfVuforiaAnchorU3Ed__22_t1825058655::get_offset_of_U3CU3E4__this_2(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2198 = { 0, -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2199 = { sizeof (ModelTargetImpl_t417568536), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable2199[2] =
{
ModelTargetImpl_t417568536::get_offset_of_mBoundingBoxImpl_5(),
ModelTargetImpl_t417568536::get_offset_of_mLoadedGuideViews_6(),
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
|
#include <Arduino.h>
#include <Wire.h>
#include <Adafruit_NeoPixel.h>
class VRCLED : public Adafruit_NeoPixel
{
public:
VRCLED(uint8_t pin, uint8_t num_pixels, neoPixelType t = NEO_GRBW);
void show_temp_color(uint32_t seconds);
void set_temp_color_target(uint8_t white, uint8_t red, uint8_t green, uint8_t blue);
void set_base_color_target(uint8_t white, uint8_t red, uint8_t green, uint8_t blue);
void set_strip_color(void);
void run(void);
//uint32_t get_strip_color(void);
//uint8_t get_red_channel(void);
//uint8_t get_green_channel(void);
//uint8_t get_blue_channel(void);
//uint8_t get_white_channel(void);
private:
//uint8_t rgbw[4] = {0};
uint32_t current_color = 0;
uint32_t temp_color = 0;
uint32_t base_color = 0;
uint32_t temp_start = 0;
uint32_t temp_duration = 0;
uint32_t last_strip_show = 0;
bool needs_color_update = false;
bool temp_running = false;
};
|
#include "aulibdefs.h"
#include "auudp.h"
AuUdp::AuUdp(QHash<quint16 , QVector<qint16> > &plcData,QObject *parent) : QObject(parent),
plcRawData(plcData)
{
}
|
#ifndef SMART_TEMPERATURE_TEMPERATURESENSORMOCK_H
#define SMART_TEMPERATURE_TEMPERATURESENSORMOCK_H
#include "gmock/gmock.h"
#include "TemperatureSensor.h"
class TemperatureSensorMock: public TemperatureSensor {
public:
TemperatureSensorMock() : TemperatureSensor(210){}
MOCK_METHOD(double, readTemperature, ());
};
#endif //SMART_TEMPERATURE_TEMPERATURESENSORMOCK_H
|
// MartixManipulation.cpp : 定义控制台应用程序的入口点。
//
//#include <iostream>
//#include "Matrix.hpp"
//#include <windows.h>
//#include <string>
//#include <fstream>
//using namespace GPSDCurriculumDesign;
//int main()
//{
// std::string dataPath = "..\\data\\";
// std::string filename = "Matrix.txt";
// std::ifstream fin(dataPath + filename);
// std::string oneLineOfFile;
// int rows = 0;
// int cols = 0;
// Matrix<double> matrix;
// while (!fin.eof()) {
// std::getline(fin, oneLineOfFile);
// if (std::strcmp(oneLineOfFile.c_str(), "MATRIXROW") == 0) {
// std::getline(fin, oneLineOfFile);
// sscanf(oneLineOfFile.c_str(), "%d", &rows);
// }
// else if (std::strcmp(oneLineOfFile.c_str(), "MATRIXCOL") == 0) {
// std::getline(fin, oneLineOfFile);
// sscanf(oneLineOfFile.c_str(), "%d", &cols);
// }
// else if (std::strcmp(oneLineOfFile.c_str(), "MATRIXDATA") == 0) {
// if (rows == 0 || cols == 0) {
// std::cout << "File Format wrong" << std::endl;
// return -1;
// }
// matrix = Matrix<double>(rows, cols);
// //Matrix<double> matrix(rows, cols);
// for (int i = 0; i < rows * cols; i++) {
// fin >> oneLineOfFile;
// double oneData = 0;
// sscanf(oneLineOfFile.c_str(), "%lf", &oneData);
// matrix.ChangeElement(i / rows, i % rows, oneData);
// }
// break;
// }
// }
// fin.close();
//
// std::cout << matrix << std::endl;
//
// system("pause");
// return 0;
//}
|
// github.com/andy489
#include <iostream>
#include <cmath>
using namespace std;
int res = 0;
int checkRecursive(int N, int X, int start, int K) {
if (X == 0)
++res;
int r = (int) floor(pow(N, 1.0 / K));
for (int i = start + 1; i <= r; i++) {
int a = X - (int) pow(i, K);
if (a >= 0) checkRecursive(N, X - (int) pow(i, K), i, K);
}
return res;
}
int check(int N, int K) {
return checkRecursive(N, N, 0, K);
}
int main() {
int N, K;
cin >> N >> K;
return cout << (check(N, K)), 0;
}
|
/*LocalNodeStore.h
LocalNodeStore
copyright Vixac Ltd. All Rights Reserved
*/
#ifndef INCLUDED_LOCALNODESTORE
#define INCLUDED_LOCALNODESTORE
#include "Node.h"
#include "AsyncFunctor.h"
#include "NodeStoreAsync.h"
namespace vixac
{
namespace ina
{
class LocalNodeStore;
}
}
/**
A local node store map, but iwth the async interface. mostly for testing.
*/
class vixac::ina::LocalNodeStore : public vixac::ina::NodeStoreAsync
{
public:
void newNode(vixac::inout::NodeType, NodeIdFunc f);
void addTie(vixac::inout::NodeId nodeId, vixac::inout::Tie tie, DoneFunc f);
void removeTie(vixac::inout::NodeId nodeId, vixac::inout::Tie tie, DoneFunc f);
void injectNode(vixac::inout::Node const& n, DoneFunc f);
LocalNodeStore();
~LocalNodeStore(){}
void setStringMeta( vixac::inout::NodeId, std::string const& key, std::string const& value, DoneFunc f);
void setIntMeta(vixac::inout::NodeId, std::string const& key, int64_t value, DoneFunc f);
void setFloatMeta(vixac::inout::NodeId, std::string const& key, double value, DoneFunc f);
void getStringMeta(vixac::inout::NodeId, std::string const& key, StringFunc f);
void getIntMeta(vixac::inout::NodeId, std::string const& key, IntFunc f);
void getFloatMeta(vixac::inout::NodeId, std::string const& key, FloatFunc f);
void getPrimary(vixac::inout::NodeId, vixac::inout::TieType type, NodeIdFunc f);
void getActiveTies(vixac::inout::NodeId, vixac::inout::TieType type, NodeIdVecFunc f);
//void getSequence(SequenceRequest, NodeIdVecFunc f);
//TODO wheres nqlmeta at? ffs indeed. Maybe I should write a legit async sql implementation instead of these hacks...
//TODO how am i gna implenet that in here
void incSequence(vixac::inout::NodeId nodeId, vixac::inout::NodeId target, vixac::inout::TieType seqName, int64_t inc, bool additive, DoneFunc f);
void subscribeToNode(vixac::inout::NodeId); // does it need a donefunc? dont see why.
private:
void getNode(vixac::inout::NodeId nodeId, NodePtrFunc f);//TODO should be private but i need it for sort
// bool sort(vixac::inout::NodeId lhs, vixac::inout::NodeId rhs);
std::map<vixac::inout::NodeId, vixac::inout::Node> nodeMap_;
};
#endif
|
#include <stdio.h>
#include <math.h>
int main()
{
double pi=0.0,n=1.0,term=1.0;
while(term>=1e-6)
{
pi=pi+term;
n=n+2;
term=1/(n*n);
}
pi=sqrt(pi*8);
printf("pi=%10.8f\n",pi);
return 0;
}
|
You have selected GOA as your Travel Destination
Name Of The Customer :pranjal
Total Members :3
Residintial Address :mumbai
Area Pin Code :456009
Customer's Contact No.:2147483647
|
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode(int x) : val(x), left(NULL), right(NULL) {}
* };
*/
class Solution {
public:
vector<int> postorderTraversal(TreeNode* root) {
stack<TreeNode*> nodes;
stack<int> vals;
vector<int> res;
if(root){
nodes.push(root);
}
while(!nodes.empty()){
TreeNode* node = nodes.top();
nodes.pop();
vals.push(node->val);
if(node->left){
nodes.push(node->left);
}
if(node->right){
nodes.push(node->right);
}
}
while(!vals.empty()){
res.push_back( vals.top() );
vals.pop();
}
return res;
}
};
|
#include <gtest/gtest.h>
#include "CppLinq.h"
#include "TestUtils.h"
TEST(Any, ThreeInts)
{
std::vector<int> src = { 1, 2, 3 };
auto rng = CppLinq::From(src);
EXPECT_TRUE(rng.Any());
EXPECT_TRUE(rng.Any([](int a) { return a == 1; }));
EXPECT_TRUE(rng.Any([](int a) { return a == 2; }));
EXPECT_TRUE(rng.Any([](int a) { return a == 3; }));
EXPECT_TRUE(rng.Any([](int a) { return a > 1; }));
EXPECT_TRUE(rng.Any([](int a) { return a < 3; }));
EXPECT_TRUE(rng.Any([](int a) { return a != 2; }));
EXPECT_FALSE(rng.Any([](int a) { return a == 0; }));
EXPECT_FALSE(rng.Any([](int a) { return a == 4; }));
EXPECT_FALSE(rng.Any([](int a) { return a < 1; }));
EXPECT_FALSE(rng.Any([](int a) { return a > 3; }));
}
|
#ifndef MAINWINDOW_H
#define MAINWINDOW_H
#include <QMainWindow>
#include <QListWidgetItem>
#include <QTime>
#include "UscxmlCLib.h"
namespace Ui {
class MainWindow;
}
class MainWindow : public QMainWindow
{
Q_OBJECT
public:
explicit MainWindow(QWidget *parent = 0);
~MainWindow();
public slots:
void Log(const QString &sMsg, const int iSeverity);
void InterpreterStopped(QListWidgetItem *item, const bool pass);
private slots:
void on_btnStop_clicked();
void on_btnStart_clicked();
void on_btnReset_clicked();
private:
Ui::MainWindow *ui;
UsclibInterpreter *_interpreter = nullptr;
enum TestState {
tsSuccess,
tsError,
tsStarted,
tsUnknown,
tsManual,
tsMAXSIZE
};
QIcon _icon[tsMAXSIZE];
QTime _elapsed;
void interpreterStartNext();
void setItemState(QListWidgetItem *item, const TestState state);
};
Q_DECLARE_METATYPE(QListWidgetItem*)
Q_DECLARE_METATYPE(MainWindow*)
#endif // MAINWINDOW_H
|
#ifndef __CLineMatchList
#define __CLineMatchList
// 注意:可存储的线段对数量大于实际参与匹配运算的数量
#define MAX_LINE_MATCH_COUNT 10 // 最多可参与最小二乘匹配的直线段数量
#include <vector>
#include "LineMatchPair.h"
#include "CoorTransEquations.h"
using namespace std;
///////////////////////////////////////////////////////////////////////////////
// "CLineMatchList"类的定义。
class CLineMatchList : public vector<CLineMatchPair>
{
private:
static float m_fDistErrTab[5];
static int m_nScoreTab[5];
public:
CTransform m_Trans;
static CCoorTransEquations m_LineEquations;
public:
CLineMatchList() {}
// 取得表中匹配对的数量
int GetCount() {return (int)size();}
// 为匹配表设置坐标变换关系
void SetTransform(const CTransform& _trans) { m_Trans = _trans; }
// 取得坐标变换关系
CTransform& GetTransform() { return m_Trans; }
// 将一个匹配对加入到匹配表中
bool Add(const CLineMatchPair& Pair);
// 在一个匹配表中查找一个匹配对
int Search(const CLineMatchPair& Pair);
// 根据所提供的局部直线段在匹配表中查找其对应的匹配对
int SearchByLocalLine(const CLine& ln);
// 根据所提供的世界直线段在匹配表中查找其对应的匹配对
int SearchByWorldLine(const CLine& ln);
// 对匹配表中那些非”一对一“匹配的项进行移除
void Filter(bool bDeleteParallel = false);
void CreateAllOptions(vector<CLineMatchList>* pLineList);
int FindBestMatchList(vector<CLineMatchList>* pLineList);
int ApplicablePairCount();
// 判断是否匹配表中的所有匹配对都是平行线
bool AllParallel();
// 生成关于所有线段匹配对的最小二乘数据
bool CreateLeastSquareData(CCoorTransEquations* pLsm);
// 根据匹配表计算两个直线集合之间的坐标变换关系
bool FindTransform();
// 计算匹配程度参数
int EvaluateTransform(CTransform& Transform, float* fAverageErr, float* pMatchingScore);
#ifdef _MSC_VER
void Dump();
#endif
};
#endif
|
/*
Copyright (c) 2005-2023, University of Oxford.
All rights reserved.
University of Oxford means the Chancellor, Masters and Scholars of the
University of Oxford, having an administrative office at Wellington
Square, Oxford OX1 2JD, UK.
This file is part of Chaste.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright notice,
this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation
and/or other materials provided with the distribution.
* Neither the name of the University of Oxford 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 ABSTRACTHDF5CONVERTER_HPP_
#define ABSTRACTHDF5CONVERTER_HPP_
#include <string>
#include "AbstractTetrahedralMesh.hpp"
#include "OutputFileHandler.hpp"
#include "Hdf5DataReader.hpp"
/**
* The derived children of this class convert output from Hdf5 format to
* a range of other formats for postprocessing.
*/
template<unsigned ELEMENT_DIM, unsigned SPACE_DIM>
class AbstractHdf5Converter
{
private:
/**
* Have a look in the HDF5 file and generate a list of the datasets that it contains.
*
* @param rH5Folder The directory the h5 file is in.
* @param rFileName The name of the h5 file.
*/
void GenerateListOfDatasets(const FileFinder& rH5Folder, const std::string& rFileName);
protected:
/** Folder that the h5 file to convert resides in */
const FileFinder& mrH5Folder;
/** Pointer to reader of the dataset to be converted. */
boost::shared_ptr<Hdf5DataReader> mpReader;
/** Number of variables to output. Read from the reader. */
unsigned mNumVariables;
/** Base name for the files: [basename].vtu, [basename].dat etc.*/
std::string mFileBaseName;
/**
* The datasets that we are working with.
*
* 'Data' is a special case and handled slightly
* differently as all variables use the same 'time'.
*/
std::vector<std::string> mDatasetNames;
/**
* The index of the dataset that is currently open.
*/
unsigned mOpenDatasetIndex;
/** Pointer to a mesh. */
AbstractTetrahedralMesh<ELEMENT_DIM,SPACE_DIM>* mpMesh;
/** Initialised as the directory in which to store the results. */
OutputFileHandler* mpOutputFileHandler;
/**
* Get the subdirectory in which the converted output is stored,
* relative to the input directory.
*/
std::string mRelativeSubdirectory;
/**
* The precision with which to write files:
* that is, the number of digits to use in numerical output.
*/
unsigned mPrecision;
/**
* Close the existing dataset and open a new one.
*
* This method deletes the existing mpDataReader, and opens a new one for the new dataset.
*
* @return whether a new dataset is open, false if we have run out of them.
*/
bool MoveOntoNextDataset();
public:
/**
* Constructor, which does the conversion and writes the .info file.
*
* @note This method is collective, and must be called by all processes.
*
* @param rInputDirectory The input directory, where the .h5 file to post-process is.
* @param rFileBaseName The base name of the data file.
* @param pMesh Pointer to the mesh.
* @param rSubdirectoryName Name for the output directory to be created (relative to inputDirectory).
* @param precision The number of digits to use in numerical output to file.
*/
AbstractHdf5Converter(const FileFinder& rInputDirectory,
const std::string& rFileBaseName,
AbstractTetrahedralMesh<ELEMENT_DIM,SPACE_DIM>* pMesh,
const std::string& rSubdirectoryName,
unsigned precision);
/**
* Wrtie the unlimited dimension information to file.
*/
void WriteInfoFile();
/**
* Destructor.
*/
~AbstractHdf5Converter();
/**
* @return the relative path of the sub-directory in which the converted output is stored.
*/
std::string GetSubdirectory();
};
#endif /*ABSTRACTHDF5CONVERTER_HPP_*/
|
#include <iostream>
//using namespace std;
class Vector
{
private:
double i;
double j;
double k;
public:
Vector();
Vector(double _i, double _j, double _k)
{
i = _i;
j = _j;
k = _k;
}
void echo(const Vector& v)
{
std::cout<<v.i<<","<<v.j<<","<<v.k<<std::endl;
}
//Some other functionality...
};
Vector operator+(const Vector& p1, const Vector& p2)
{
Vector temp(p1);
temp += p2;
return temp;
}
int main()
{
Vector a(11.0,22.0,33.0),b(1.0,2.0,3.0),c(0,0,0);
c = a+b;
c.echo(c);
std::cin.get();
return 0;
}
|
#ifndef _TRIPLEBIT_H_
#define _TRIPLEBIT_H_
#include <string>
#include <iostream>
#include <sstream>
#include <fstream>
#include <map>
#include <vector>
#include <set>
#include <stdlib.h>
#include <stdio.h>
#include <malloc.h>
#include <math.h>
#include <sys/time.h>
#include <stack>
#include <tr1/memory>
//#include <hash_map>
using namespace std;
//using namespace __gnu_cxx;
//#include <boost/thread/thread.hpp>
#include <boost/thread/mutex.hpp>
#include <boost/bind.hpp>
#include <boost/function.hpp>
#include <boost/shared_ptr.hpp>
#include "MessageEngine.h"
#define DEBUG
#define MYDEBUG
#define RESULT_TIME
#define PATTERN_TIME
#define TOTAL_TIME
//#define TTDEBUG
#define PRINT_BUFFERSIZE
#define xflag 63
#define LOCK_TIME
template<class T> string toStr(T tmp)
{
stringstream ss;
ss << tmp;
return ss.str();
}
const int openMP_thread_num = 1;
//bitmap settings
const unsigned int INIT_PAGE_COUNT = 1024;
const unsigned int INCREMENT_PAGE_COUNT = 1024;
const unsigned int CHUNK_SIZE = 16;
//uri settings
const unsigned int URI_INIT_PAGE_COUNT = 256;
const unsigned int URI_INCREMENT_PAGE_COUNT = 256;
//reification settings
const unsigned int REIFICATION_INIT_PAGE_COUNT = 2;
const unsigned int REIFICATION_INCREMENT_PAGE_COUNT = 2;
//column buffer settings
const unsigned int COLUMN_BUFFER_INIT_PAGE_COUNT = 2;
const unsigned int COLUMN_BUFFER_INCREMENT_PAGE_COUNT = 2;
//URI statistics buffer settings
const unsigned int STATISTICS_BUFFER_INIT_PAGE_COUNT = 1;
const unsigned int STATISTICS_BUFFER_INCREMENT_PAGE_COUNT = 1;
//entity buffer settings
const unsigned int ENTITY_BUFFER_INIT_PAGE_COUNT = 1;
const unsigned int ENTITY_BUFFER_INCREMENT_PAGE_COUNT = 2;
//temp buffer settings
const unsigned int TEMPMMAPBUFFER_INIT_PAGE = 1000;
const unsigned int TEMPBUFFER_INIT_PAGE_COUNT = 1;
const unsigned int TEMPMMAP_INIT_PAGE_COUNT = 1;
const unsigned int INCREMENT_TEMPMMAP_PAGE_COUNT = 1;
//hash index
const unsigned int HASH_RANGE = 200;
const unsigned int HASH_CAPACITY = 100000 / HASH_RANGE;
const unsigned int HASH_CAPACITY_INCREASE = 100000 / HASH_RANGE;
const unsigned int SECONDARY_HASH_RANGE = 10;
const unsigned int SECONDARY_HASH_CAPACITY = 100000 / SECONDARY_HASH_RANGE;
const unsigned int SECONDARY_HASH_CAPACITY_INCREASE = 100000 / SECONDARY_HASH_RANGE;
extern char* DATABASE_PATH;
//thread pool
const unsigned int WORKERNUM = 1;
// const unsigned int WORK_THREAD_NUMBER = 8; //should be 2^n;
const unsigned int WORK_THREAD_NUMBER = 1; //should be 2^n;
//const unsigned int WORK_THREAD_NUMBER = 8;
const unsigned int PARTITION_THREAD_NUMBER = 1;
//const unsigned int PARTITION_THREAD_NUMBER = 6;
const unsigned int CHUNK_THREAD_NUMBER = 1;
const unsigned int TEST_THREAD_NUMBER = 16;
// const unsigned int CHUNK_THREAD_NUMBER = 2;
// const unsigned int CHUNK_THREAD_NUMBER = 1;
enum Status {
OK = 1,
NOT_FIND = -1,
OUT_OF_MEMORY = -5,
PTR_IS_FULL = -11,
PTR_IS_NOT_FULL = -10,
CHUNK_IS_FULL = -21,
CHUNK_IS_NOT_FULL = -20,
PREDICATE_NOT_BE_FINDED = -30,
CHARBUFFER_IS_FULL = -40,
CHARBUFFER_IS_NOT_FULL = -41,
URI_NOT_FOUND = -50,
URI_FOUND = -51,
PREDICATE_FILE_NOT_FOUND = -60,
PREDICATE_FILE_END = -61,
REIFICATION_NOT_FOUND,
FINISH_WIRITE,
FINISH_READ,
ERROR,
SUBJECTID_NOT_FOUND,
OBJECTID_NOT_FOUND,
COLUMNNO_NOT_FOUND,
BUFFER_NOT_FOUND,
ENTITY_NOT_INCLUDED,
NO_HIT,
NOT_OPENED, // file was not previously opened
END_OF_FILE, // read beyond end of file or no space to extend file
LOCK_ERROR, // file is used by another program
NO_MEMORY,
URID_NOT_FOUND ,
ALREADY_EXISTS,
NOT_FOUND,
CREATE_FAILURE,
NOT_SUPPORT,
ID_NOT_MATCH,
ERROR_UNKOWN,
BUFFER_MODIFIED,
NULL_RESULT,
TOO_MUCH,
ERR
};
//join shape of patterns within a join variable.
enum JoinShape{
STAR,
CHAIN
};
enum EntityType
{
PREDICATE = 1 << 0,
SUBJECT = 1 << 1,
OBJECT = 1 << 2,
DEFAULT = -1
};
typedef long long int64;
typedef unsigned char word;
typedef word* word_prt;
typedef word_prt bitVector_ptr;
typedef unsigned int ID;
typedef unsigned int TripleNodeID;
typedef unsigned SOType;
typedef unsigned int SOID;
typedef unsigned int PID;
typedef bool status;
typedef short COMPRESS_UNIT;
typedef unsigned int uint;
typedef unsigned char uchar;
typedef unsigned short ushort;
typedef unsigned long long ulonglong;
typedef long long longlong;
typedef size_t OffsetType;
typedef size_t HashCodeType;
extern const ID INVALID_ID;
#define BITVECTOR_INITIAL_SIZE 100
#define BITVECTOR_INCREASE_SIZE 100
#define BITMAP_INITIAL_SIZE 100
#define BITMAP_INCREASE_SIZE 30
#define BUFFER_SIZE 1024
//#define DEBUG 1
#ifndef NULL
#define NULL 0
#endif
//something about shared memory
#define MAXTRANSNUM 1023
#define MAXTASKNUMWP 100
#define MAXRESULTNUM 10
#define MAXCHUNKTASK 50
//#define PRINT_RESULT 1
//#define TEST_TIME 1
#define WORD_SIZE (sizeof(word))
inline unsigned char Length_2_Type(unsigned char xLen, unsigned char yLen) {
return (xLen - 1) * 4 + yLen;
}
//
inline unsigned char Type_2_Length(unsigned char type) {
return (type - 1) / 4 + (type - 1) % 4 + 2;
}
inline void Type_2_Length(unsigned char type, unsigned char& xLen, unsigned char& yLen)
{
xLen = (type - 1) / 4 + 1;
yLen = (type - 1) % 4 + 1;
}
struct LengthString {
const char * str;
uint length;
void dump(FILE * file) {
for (uint i = 0; i < length; i++)
fputc(str[i], file);
}
LengthString() :
str(NULL), length(0) {
}
LengthString(const char * str) {
this->str = str;
this->length = strlen(str);
}
LengthString(const char * str, uint length) {
this->str = str;
this->length = length;
}
LengthString(const std::string & rhs) :
str(rhs.c_str()), length(rhs.length()) {
}
bool equals(LengthString * rhs) {
if (length != rhs->length)
return false;
for (uint i = 0; i < length; i++)
if (str[i] != rhs->str[i])
return false;
return true;
}
bool equals(const char * str, uint length) {
if (this->length != length)
return false;
for (uint i = 0; i < length; i++)
if (this->str[i] != str[i])
return false;
return true;
}
bool equals(const char * str) {
if(length != strlen(str))
return false;
for (uint i = 0; i < length; i++)
if (this->str[i] != str[i])
return false;
return str[length] == 0;
}
bool copyTo(char * buff, uint bufflen) {
if (length < bufflen) {
for (uint i = 0; i < length; i++)
buff[i] = str[i];
buff[length] = 0;
return true;
}
return false;
}
};
struct TripleNode {
ID subject, predicate, object;
// Which of the three values are constants?
bool constSubject, constPredicate, constObject;
enum Op {
FINDSBYPO,
FINDOBYSP,
FINDPBYSO,
FINDSBYP,
FINDOBYP,
FINDPBYS,
FINDPBYO,
FINDSBYO,
FINDOBYS,
FINDS,
FINDP,
FINDO,
NOOP,
FINDSPBYO,
FINDSOBYP,
FINDPOBYS,
FINDPSBYO,
FINDOSBYP,
FINDOPBYS,
FINDSOBYNONE,
FINDOSBYNONE
};
TripleNodeID tripleNodeID;
/// define the first scan operator
Op scanOperation;
int selectivity;
// vector<JoinVariableNodeID,int> varHeight;
vector<pair<int,int> > varHeight;
// Is there an implicit join edge to another TripleNode?
TripleNode() {
subject = 0;
predicate = 0;
object = 0;
constSubject = 0;
constPredicate = 0;
constObject = 0;
tripleNodeID = 0;
scanOperation = TripleNode::FINDP;
selectivity = -1;
}
TripleNode(const TripleNode &orig)
{
subject = orig.subject;
predicate= orig.predicate;
object = orig.object;
constSubject = orig.constSubject;
constPredicate = orig.constPredicate;
constObject = orig.constObject;
tripleNodeID = orig.tripleNodeID;
scanOperation = orig.scanOperation;
selectivity = orig.selectivity;
varHeight = orig.varHeight;
}
TripleNode& operator=(const TripleNode& orig)
{
subject = orig.subject;
predicate= orig.predicate;
object = orig.object;
constSubject = orig.constSubject;
constPredicate = orig.constPredicate;
constObject = orig.constObject;
tripleNodeID = orig.tripleNodeID;
scanOperation = orig.scanOperation;
selectivity = orig.selectivity;
varHeight = orig.varHeight;
return *this;
}
//TripleNode 排序算法
bool operator<(const TripleNode& other) const
{
return selectivity < other.selectivity ;
}
bool static idSort(const TripleNode & a,const TripleNode & b){
return a.tripleNodeID < b.tripleNodeID;
}
//
};
inline uint64_t getTicks(){
timeval t;
gettimeofday(&t, 0);
return static_cast<uint64_t>(t.tv_sec)*1000 + (t.tv_usec/1000);
}
#endif // _TRIPLEBIT_H_
|
#include <iostream>
#include <fstream>
#include "JSONReader.h"
JSONReader::JSONReader()
{
}
JSONReader::~JSONReader()
{
}
/*
Name: LoadJSONFileLevel
Params: A String representing the name of the JSON file
A referenced rapidjson::Document to load the json information into.
Returns: A bool representing whether or not the json file successfully loaded.
*/
//https://github.com/miloyip/rapidjson/blob/master/example/tutorial/tutorial.cpp tutorial
bool JSONReader::LoadJSONFileLevel(std::string fileName)
{
std::ifstream file;
file.open(fileName, std::ifstream::binary); //open the input file
if (!file.is_open()){ //file not found
cocos2d::log("Error: JSON File not found");
return false;
}
std::stringstream strStream;
strStream << file.rdbuf(); //read the file
std::string jsonStr = strStream.str(); //str holds the content of the file
if (this->document.Parse(jsonStr.c_str()).HasParseError()){ // Parse JSON string into DOM.
cocos2d::log("Error: JSON File could not be parsed into document");
return false;
}
if (!this->document.IsObject()){ // Parse JSON string into DOM.
cocos2d::log("Error: JSON document is not object");
return false;
}
return true;
}
|
//sort()的第三个参数不填，则默认按照从小到大的顺序排列
#include<stdio.h>
#include<algorithm>
using namespace std;
int main(){
int a[]={2,5,89,55,67};
for(int i=0;i<5;i++)
printf("%d ",a[i]);
printf("\n");
sort(a,a+5);//不加compare参数的话就是默认从小到大排列
for(int i=0;i<5;i++)
printf("%d ",a[i]);
printf("\n");
return 0;
}
|
#include <iostream>
#include <vector>
using namespace std;
int k,n;
void gen(vector<int> s, int prev) {
if (s.size() == k) {
for (int i = 0; i < k; i++) {
cout << s[i] << " ";
}
cout << "\n";
return;
}
for (int i = k - s.size(); i < prev; i++) {
vector<int> a = s;
a.push_back(i);
gen(a, i);
}
}
int main() {
ios_base::sync_with_stdio(false); cin.tie(NULL);
cin >> k >> n;
gen({}, n + 1);
return 0;
}
|
#include "Pony.hpp"
Pony::Pony(std::string nam, int wei, std::string col) : name(nam), weight(wei), colour(col) {
std::cout << "Pony created" << std::endl;
return;
}
Pony::~Pony(void) {
std::cout << "Pony destroyed" << std::endl;
}
void Pony::sayHello()
{
std::cout << "Hi, my name is " << this->name << " and I am a " << this->colour << " Pony and I weigh "
<< this->weight << " Kilograms" << std::endl;
}
|
// CkCharset.h: interface for the CkCharset class.
//
//////////////////////////////////////////////////////////////////////
// This header is generated.
#ifndef _CkCharset_H
#define _CkCharset_H
#include "chilkatDefs.h"
#include "CkString.h"
#include "CkMultiByteBase.h"
class CkByteData;
#ifndef __sun__
#pragma pack (push, 8)
#endif
// CLASS: CkCharset
class CkCharset : public CkMultiByteBase
{
private:
// Don't allow assignment or copying these objects.
CkCharset(const CkCharset &);
CkCharset &operator=(const CkCharset &);
public:
CkCharset(void);
virtual ~CkCharset(void);
static CkCharset *createNew(void);
void inject(void *impl);
// May be called when finished with the object to free/dispose of any
// internal resources held by the object.
void dispose(void);
// BEGIN PUBLIC INTERFACE
// ----------------------
// Properties
// ----------------------
void get_AltToCharset(CkString &str);
const char *altToCharset(void);
void put_AltToCharset(const char *newVal);
int get_ErrorAction(void);
void put_ErrorAction(int newVal);
void get_FromCharset(CkString &str);
const char *fromCharset(void);
void put_FromCharset(const char *newVal);
void get_LastInputAsHex(CkString &str);
const char *lastInputAsHex(void);
void get_LastInputAsQP(CkString &str);
const char *lastInputAsQP(void);
void get_LastOutputAsHex(CkString &str);
const char *lastOutputAsHex(void);
void get_LastOutputAsQP(CkString &str);
const char *lastOutputAsQP(void);
bool get_SaveLast(void);
void put_SaveLast(bool newVal);
void get_ToCharset(CkString &str);
const char *toCharset(void);
void put_ToCharset(const char *newVal);
// ----------------------
// Methods
// ----------------------
int CharsetToCodePage(const char *charsetName);
bool CodePageToCharset(int codePage, CkString &outCharset);
const char *codePageToCharset(int codePage);
bool ConvertData(const CkByteData &inData, CkByteData &outData);
bool ConvertFile(const char *srcPath, const char *destPath);
bool ConvertFileNoPreamble(const char *srcPath, const char *destPath);
bool ConvertFromUtf16(const CkByteData &uniData, CkByteData &outMbData);
bool ConvertHtml(const CkByteData &htmlIn, CkByteData &outHtml);
bool ConvertHtmlFile(const char *srcPath, const char *destPath);
bool ConvertToUtf16(const CkByteData &mbData, CkByteData &outUniData);
bool EntityEncodeDec(const char *inStr, CkString &outStr);
const char *entityEncodeDec(const char *inStr);
bool EntityEncodeHex(const char *inStr, CkString &outStr);
const char *entityEncodeHex(const char *inStr);
bool GetHtmlCharset(const CkByteData &htmlData, CkString &outCharset);
const char *getHtmlCharset(const CkByteData &htmlData);
const char *htmlCharset(const CkByteData &htmlData);
bool GetHtmlFileCharset(const char *htmlPath, CkString &outCharset);
const char *getHtmlFileCharset(const char *htmlPath);
const char *htmlFileCharset(const char *htmlPath);
bool HtmlDecodeToStr(const char *str, CkString &outStr);
const char *htmlDecodeToStr(const char *str);
bool HtmlEntityDecode(const CkByteData &inData, CkByteData &outData);
bool HtmlEntityDecodeFile(const char *srcPath, const char *destPath);
bool IsUnlocked(void);
bool LowerCase(const char *inStr, CkString &outStr);
const char *lowerCase(const char *inStr);
bool ReadFile(const char *path, CkByteData &outData);
bool ReadFileToString(const char *path, const char *srcCharset, CkString &outStr);
const char *readFileToString(const char *path, const char *srcCharset);
void SetErrorBytes(const unsigned char *pByteData, unsigned long szByteData);
void SetErrorString(const char *str, const char *charset);
bool UnlockComponent(const char *unlockCode);
bool UpperCase(const char *inStr, CkString &outStr);
const char *upperCase(const char *inStr);
bool UrlDecodeStr(const char *inStr, CkString &outStr);
const char *urlDecodeStr(const char *inStr);
bool VerifyData(const char *charset, const CkByteData &charData);
bool VerifyFile(const char *charset, const char *path);
bool WriteFile(const char *path, const CkByteData &dataBuf);
bool WriteStringToFile(const char *str, const char *path, const char *charset);
// END PUBLIC INTERFACE
};
#ifndef __sun__
#pragma pack (pop)
#endif
#endif
|
#include "HighScore.h"
HighScore::HS::HS()
{
_HS = new list<score>();
}
HighScore::HS::~HS()
{
delete _HS;
}
void HighScore::HS::addHS(const int point, const string name)
{
score add;
add.point = point;
add.name = name;
_HS->push_back(add);
_HS->sort();
}
void HighScore::HS::getMin(int &point, string &name)
{
name = _HS->back().name;
point = _HS->back().point;
}
void HighScore::HS::getMax(int &point, string &name)
{
name = _HS->front().name;
point = _HS->front().point;
}
int HighScore::HS::getCant()
{
return _HS->size();
}
bool HighScore::HS::getScore(const int pos, int & point, string & name)
{
if ((int)_HS->size() < pos)
return false;
list<score>::iterator it = _HS->begin();
advance(it, pos);
name = it->name;
point = it->point;
return true;
}
void HighScore::HS::clearScore()
{
_HS->clear();
}
list<int>* HighScore::HS::getPoints()
{
list<int>* listPoints = new list<int>();
for (list<score>::iterator it = _HS->begin(); it != _HS->end(); ++it) {
listPoints->push_back(it->point);
}
return listPoints;
}
list<string>* HighScore::HS::getNames()
{
list<string>* listPoints = new list<string>();
for (list<score>::iterator it = _HS->begin(); it != _HS->end(); ++it) {
listPoints->push_back(it->name);
}
return listPoints;
}
|
//! Bismillahi-Rahamanirahim.
/** ========================================**
** @Author: Md. Abu Farhad ( RUET, CSE'15)
** @Category:
/** ========================================**/
#include<bits/stdc++.h>
#include<stdio.h>
using namespace std;
#define ll long long
#define scl(n) scanf("%lld", &n)
#define scf(n) scanf("%lf", &n)
#define pfl(x) printf("%lld\n",x)
#define md 10000007
#define pb push_back
#define fr(i,n) for (ll i=0;i<n;i++)
#define fr1(i,n) for(ll i=1;i<=n;i++)
string s;
pair<ll,ll> p[200005];
stack<ll>st;
int main()
{
ll m,n,t,b,c,d,i,j,k,x,y,z,l,q,r;
ll cnt=0,ans=0;
scl(n);
fr(i,n)
{
cin>>x;
p[i]=make_pair(x,i);
}
cin>>s;
sort(p,p+n);
j=0;
fr(i,s.size())
{
if(s[i]=='0')
{
cout<<p[j].second +1 <<" ", st.push(p[j].second ),j++;
}
else
{
cout<<st.top()+1<<" ", st.pop();
}
}
return 0;
}
/// Using priority queue
/*
int main()
{
ll m,n,i,k,l,v=0,x;
string s;
cin>>n;
ll a[n];
map<int ,int > mp;
priority_queue<int>q;
for(i=0; i<n; i++)
{
cin>>a[i];
mp[a[i]]=i+1;
}
sort(a,a+n);
cin>>s;
for(i=0; i<2*n; i++)
{
if(s[i]=='0')
{
printf("%d ",mp[a[v]]);
q.push(a[v]);
v++;
}
else
{
x=q.top();
printf("%d ",mp[x]);
q.pop();
}
}
return 0;
}
*/
|
#include<iostream>
#include<algorithm>
using namespace std;
int main()
{
long long int t,arr[100000],arra[100000],i,n,c = 0,d = 0;
cin>>t;
while(t--)
{
cin>>n;
for(i = 0;i < n;++i)
{
cin>>arr[i];
arra[i] = arr[i];
}
sort(arr,arr+n);
sort(arra,arra+n);
reverse(arra,arra+n);
for(i = 0;i < n;++i)
{
if(i%2==0)
{
cout<<arr[c]<<" ";
++c;
}
else
{
cout<<arra[d]<<" ";
++d;
}
}
cout<<endl;
c = 0;
d = 0;
}
return 0;
}
|
#pragma once
#include <unordered_map>
#include <array>
#include <tudocomp/compressors/lz_common/factorid_t.hpp>
namespace tdc {namespace lz_pointer_jumping {
static constexpr bool PRINT_DEBUG_TRANSITIONS = false;
template<typename pj_trie_t>
class PointerJumping: public pj_trie_t {
using jump_buffer_handle = typename pj_trie_t::jump_buffer_handle;
public:
using lz_state_t = typename pj_trie_t::lz_state_t;
using traverse_state_t = typename pj_trie_t::traverse_state_t;
using factorid_t = lz_common::factorid_t;
inline PointerJumping(lz_state_t& lz_state, size_t jump_width):
pj_trie_t(jump_width),
m_lz_state(lz_state),
m_jump_width(jump_width),
m_jump_buffer_handle(this->get_working_buffer())
{}
inline uliteral_t& jump_buffer(size_t i) {
DCHECK_LT(i, m_jump_width);
return this->get_buffer(m_jump_buffer_handle)[i];
}
inline uliteral_t const& jump_buffer(size_t i) const {
DCHECK_LT(i, m_jump_width);
return this->get_buffer(m_jump_buffer_handle)[i];
}
inline factorid_t jump_buffer_parent_node() const {
return this->get_parent_node(m_jump_buffer_handle);
}
inline size_t jump_buffer_size() const {
return m_jump_buffer_size;
}
struct action_t {
bool m_was_full;
typename pj_trie_t::result_t m_result;
inline bool buffer_full_and_found() const {
return m_was_full && m_result.found();
}
inline bool buffer_full_and_not_found() const {
return m_was_full && (!m_result.found());
}
inline traverse_state_t traverse_state() const {
DCHECK(buffer_full_and_found());
return m_result.get();
}
};
inline action_t on_insert_char(uliteral_t c) {
DCHECK_LT(m_jump_buffer_size, m_jump_width);
jump_buffer(m_jump_buffer_size) = c;
m_jump_buffer_size++;
if(jump_buffer_full()) {
auto entry = find_jump_buffer();
if (entry.found()) {
debug_transition(std::cout, entry.get(), false);
}
return action_t { true, entry };
} else {
debug_open_transition(std::cout);
return action_t { false, typename pj_trie_t::result_t() };
}
}
inline void shift_buffer(size_t elements) {
factorid_t parent_node = current_lz_node_id();
size_t remaining = m_jump_width - elements;
for(size_t i = 0; i < remaining; i++) {
jump_buffer(i) = jump_buffer(i + elements);
}
m_jump_buffer_size -= elements;
this->set_parent_node(m_jump_buffer_handle, parent_node);
debug_open_transition(std::cout);
}
inline void reset_buffer() {
factorid_t parent_node = current_lz_node_id();
m_jump_buffer_size = 0;
this->set_parent_node(m_jump_buffer_handle, parent_node);
debug_open_transition(std::cout);
}
inline bool jump_buffer_full() const {
return m_jump_width == m_jump_buffer_size;
}
inline auto find_jump_buffer() const {
return this->find(m_jump_buffer_handle);
}
inline void insert_jump_buffer(traverse_state_t const& val) {
debug_transition(std::cout, val, true);
this->insert(m_jump_buffer_handle, val);
}
// DEBUG printing function
inline void debug_print_buffer(std::ostream& out, jump_buffer_handle const& handle, size_t size) const {
if (!PRINT_DEBUG_TRANSITIONS) return;
for(size_t i = 0; i < size; i++) {
out << this->get_buffer(handle)[i];
}
}
inline void debug_print_buffer(std::ostream& out) const {
if (!PRINT_DEBUG_TRANSITIONS) return;
debug_print_buffer(out, m_jump_buffer_handle, m_jump_buffer_size);
}
inline void debug_open_transition(std::ostream& out) const {
if (!PRINT_DEBUG_TRANSITIONS) return;
factorid_t parent_node = jump_buffer_parent_node();
out << "(" << parent_node << ") -[";
debug_print_buffer(out);
out << "..." << std::endl;
}
inline void debug_transition(std::ostream& out, traverse_state_t const& to, bool is_new) const {
if (!PRINT_DEBUG_TRANSITIONS) return;
factorid_t parent_node = jump_buffer_parent_node();
out << "(" << parent_node << ") -[";
debug_print_buffer(out);
out << "]-> (" << m_lz_state.get_node(to).id() << ")" ;
if (is_new) {
out << "*";
}
out << std::endl;
}
private:
lz_state_t& m_lz_state;
size_t m_jump_width;
jump_buffer_handle m_jump_buffer_handle;
size_t m_jump_buffer_size = 0;
inline factorid_t current_lz_node_id() const {
return m_lz_state.get_node(m_lz_state.get_traverse_state()).id();
}
};
}}
|
#include "logger.h"
static const char* LoggerLevelStrings[kLogLevels] = {
[kLogDebug] = "D",
[kLogInfo] = "I",
[kLogError] = "E",
[kLogFatal] = "F",
};
void Logger::Printf(LoggerLevel level, const char* format, ...) {
va_list args;
va_start(args, format);
FormatMessage(level, format, args);
Write(msg_buffer_);
}
void Logger::Write(const char* msg) {
printf("%s", msg);
}
void Logger::FormatMessage(LoggerLevel level, const char* format, va_list args) {
uint64_t ticks = get_absolute_time();
int milliseconds = ticks % 1000;
int seconds = ticks / 1000;
int minutes = seconds / 60;
int hours = minutes / 60;
char tmp_buffer[MSG_SIZE] = "";
if ((level < kLogLevels) && (level > kLogDebug)) {
snprintf(tmp_buffer, MSG_SIZE, "%.2d:%.2d:%2d.%.3d %s: %s\n", hours,
minutes,
seconds,
milliseconds,
LoggerLevelStrings[level],
format);
}
vsnprintf(msg_buffer_, MSG_SIZE, tmp_buffer, args);
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX_INT = std::numeric_limits<int>::max();
const int MIN_INT = std::numeric_limits<int>::min();
const int INF = 1000000000;
const int NEG_INF = -1000000000;
#define max(a,b)(a>b?a:b)
#define min(a,b)(a<b?a:b)
#define MEM(arr,val)memset(arr,val, sizeof arr)
#define PI acos(0)*2.0
#define eps 1.0e-9
#define are_equal(a,b)fabs(a-b)<eps
#define LS(b)(b& (-b)) // Least significant bit
#define DEG_to_RAD(a)((a*PI)/180.0) // convert to radians
typedef long long ll;
typedef pair<int,int> ii;
typedef pair<int,char> ic;
typedef pair<long,char> lc;
typedef vector<int> vi;
typedef vector<ii> vii;
int gcd(int a,int b){return b == 0 ? a : gcd(b,a%b);}
int lcm(int a,int b){return a*(b/gcd(a,b));}
int g[4002][4002];
int rec = INF;
int main(){
int n, m, a, b;
cin >> n >> m;
MEM(g, 0);
vii edges;
vi degree(n, 0);
for (int i = 0; i < m; i++) {
cin >> a >> b;
a--; b--;
edges.push_back(ii(a, b));
g[a][b] = 1;
g[b][a] = 1;
degree[a]++;
degree[b]++;
}
for (int i = 0; i < edges.size(); i++) {
ii tmp = edges[i];
a = tmp.first;
b = tmp.second;
for (int j = 0; j < n; j++) {
if (g[a][j] == 0 || g[b][j] == 0)
continue;
rec = min(rec, degree[a] + degree[b] + degree[j]);
}
}
if (rec == INF)
cout << -1 << endl;
else cout << rec - 6 << endl;
return 0;
}
|
// Fill out your copyright notice in the Description page of Project Settings.
#pragma once
#include "CoreMinimal.h"
#include "GameFramework/Character.h"
#include "BasicBot.generated.h"
class UUI_DamageDisplay;
UCLASS()
class THIRDPERSONSHOOTER_API ABasicBot : public ACharacter
{
GENERATED_BODY()
private:
UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = Mesh, meta = (AllowPrivateAccess = "true"))
class UDamageBulletDisplayComponent* DamageBulletDisplay;
UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = Mesh, meta = (AllowPrivateAccess = "true"))
class UHealthAndDamageComponent* HealthAndDamage;
public:
ABasicBot(const class FObjectInitializer& PCIP);
};
|
// OpenIGTLinkRemote MRML includes
#include "vtkMRMLOpenIGTLinkRemoteNode.h"
// VTK includes
#include <vtkObjectFactory.h>
vtkMRMLNodeNewMacro(vtkMRMLOpenIGTLinkRemoteNode);
// ----------------------------------------------------------------------------
vtkMRMLOpenIGTLinkRemoteNode::vtkMRMLOpenIGTLinkRemoteNode()
{
}
// ----------------------------------------------------------------------------
vtkMRMLOpenIGTLinkRemoteNode::~vtkMRMLOpenIGTLinkRemoteNode()
{
}
// ----------------------------------------------------------------------------
void vtkMRMLOpenIGTLinkRemoteNode::WriteXML(ostream& of, int nIndent)
{
Superclass::WriteXML(of, nIndent); // This will take care of referenced nodes
}
// ----------------------------------------------------------------------------
void vtkMRMLOpenIGTLinkRemoteNode::ReadXMLAttributes(const char** atts)
{
Superclass::ReadXMLAttributes(atts); // This will take care of referenced nodes
}
// ----------------------------------------------------------------------------
void vtkMRMLOpenIGTLinkRemoteNode::Copy(vtkMRMLNode* anode)
{
Superclass::Copy(anode); // This will take care of referenced nodes
}
// ----------------------------------------------------------------------------
void vtkMRMLOpenIGTLinkRemoteNode::PrintSelf(ostream& os, vtkIndent indent)
{
vtkMRMLNode::PrintSelf(os, indent);
}
|
template <class T>
void swapp(T &a,T &b); // template prototype
template <class T>
void swapp(T &a,T &b){ // function template definition
T temp;
temp = a;
a = b;
b = temp;
}
// 对于给定的函数名,可以有非末班函数,模板函数和显示具体化末班函数以及它们的重载版本
// 显示具体化的原型和定义应以 template<>打头,并通过名称类指出类型
// 具体化优先于常规末班,非模板函数优先于具体化和常规模板
struct job
{
char name[40];
double salary;
int floor;
};
void swap(job &, job &); // non template function prototype
// template <> void swap<job>(job&,job&);
|
#include "cinder/app/App.h"
#include "cinder/app/RendererGl.h"
#include "cinder/gl/gl.h"
#include "cinder/CameraUi.h"
#include "sp/BVH.h"
using namespace ci;
using namespace ci::app;
using namespace std;
// Basic Triangle Class
// The BVH class needs to have access to 3 functions; getBounds, getCentroid and intersect
class Triangle {
public:
Triangle( const vec3 &a, const vec3 &b, const vec3 &c ) : mVertices( { a, b, c } ), mBounds( min( a, min( b, c ) ), max( a, max( b, c ) ) ), mCentroid( ( a + b + c ) / 3.0f ) {}
ci::AxisAlignedBox getBounds() const { return mBounds; }
vec3 getCentroid() const { return mCentroid; }
bool intersect( const Ray& r, float* dist ) const { return r.calcTriangleIntersection( mVertices[0], mVertices[1], mVertices[2], dist ); }
vec3 getA() const { return mVertices[0]; }
vec3 getB() const { return mVertices[1]; }
vec3 getC() const { return mVertices[2]; }
protected:
AxisAlignedBox mBounds;
vec3 mCentroid;
array<vec3,3> mVertices;
};
// If the class doesn't provide those functions you can specialize BVHObjectTraits to specify your own
//namespace SpacePartitioning { namespace details {
// template<>
// class BVHObjectTraits<Triangle> {
// public:
// static bool intersect( const Triangle &t, const Ray& r, float* dist ) { return r.calcTriangleIntersection( t.getA(), t.getB(), t.getC(), dist ); }
// };
//} }
class RayCastingApp : public App {
public:
void setup() override;
void draw() override;
CameraPersp mCamera;
CameraUi mCameraUi;
gl::BatchRef mTeapot;
vector<Triangle> mTriangles;
sp::BVH<Triangle> mBvh;
};
void RayCastingApp::setup()
{
// setup the camera and ui
mCamera = CameraPersp( getWindowWidth(), getWindowHeight(), 50.0f, 0.01f, 10.0f );
mCameraUi = CameraUi( &mCamera, getWindow() );
mCamera.lookAt( vec3( 1.0f ), vec3( 0.0f ) );
// create a teapot with roughly a million triangles
TriMesh mesh = geom::Teapot().subdivisions( 128 );
mTeapot = gl::Batch::create( mesh, gl::getStockShader( gl::ShaderDef().color().lambert() ) );
// store the triangles in a vector so we can use them with the bounding volume hierarchy
for( size_t i = 0; i < mesh.getNumTriangles(); ++i ) {
vec3 a, b, c;
mesh.getTriangleVertices( i, &a, &b, &c );
mTriangles.push_back( Triangle( a, b, c ) );
}
// create the bounding volume hierarchy
mBvh = sp::BVH<Triangle>( &mTriangles );
}
void RayCastingApp::draw()
{
// clear the screen and set the matrics
gl::clear( Color::gray( 0.6f ) );
gl::setMatrices( mCamera );
// render the teapot
gl::ScopedDepth scopedDepth( true );
mTeapot->draw();
// cast a ray from the mouse position
auto mousePos = clamp( vec2( getMousePos() - getWindowPos() ), vec2( 0.0f ), vec2( getWindowSize() ) );
auto ray = mCamera.generateRay( mousePos, getWindowSize() );
sp::BVH<Triangle>::RaycastResult result;
Timer timer( true );
bool hit = mBvh.raycast( ray, &result );
timer.stop();
// if there's a hit draw the triangle at the intersection
if( hit ) {
gl::ScopedDepth scopedDepth( false );
gl::ScopedColor scopedColor( ColorA::black() );
gl::VertBatch triangle;
triangle.begin( GL_LINE_LOOP );
triangle.vertex( result.getObject()->getA() );
triangle.vertex( result.getObject()->getB() );
triangle.vertex( result.getObject()->getC() );
triangle.end();
triangle.draw();
}
// get timing avg on 30 frames
static int framesAvg = 0;
static float timeAvg = 0.0f, timeAcc = 0.0f;
if( ++framesAvg > 30 ) {
timeAvg = timeAcc / 30.0f;
timeAcc = framesAvg = 0;
}
timeAcc += timer.getSeconds();
getWindow()->setTitle( "RayCasting " + to_string( timeAvg * 1000.0 ) + "ms " );
}
CINDER_APP( RayCastingApp, RendererGl( RendererGl::Options().msaa( 8 ) ) )
|
#ifndef _MAT4_H_
#define _MAT4_H_
#pragma once
#include "math\mathfunctions.h"
#include "math\matrix\vec\vec2.h"
#include "math\matrix\vec\vec3.h"
#include "math\matrix\vec\vec4.h"
namespace bne
{
namespace math
{
struct mat4
{
union
{
float elements[4 * 4];
vec4f columns[4];
};
mat4();
mat4(float d);
static mat4 identity();
mat4& multiply(const mat4& other);
friend mat4 operator*(mat4 left, const mat4& right);
mat4& operator*=(const mat4& other);
static mat4 orthographic(float left, float right, float bottom, float top, float near, float far);
static mat4 perspective(float fov, float aspectRatio, float near, float far);
static mat4 translation(const vec3f& translation);
static mat4 rotation(float angle, const vec3f& axis);
static mat4 scale(const vec3f& scale);
};
}
}
#endif
|
/**********************************************************
* License: The MIT License
* https://www.github.com/doc97/TxtAdv/blob/master/LICENSE
**********************************************************/
#pragma once
#include <string>
namespace txt
{
/* Interface: ResponseHandler
* Used to implement response handling for text input.
*/
class ResponseHandler
{
public:
virtual ~ResponseHandler() {}
/* Function: HandleInput
*
* Parameters:
*
* input - The input to handle
*/
inline void HandleInput(const std::string& input)
{
HandleInputImpl(input);
}
/* Function: Matches
*
* Parameters:
*
* input - Input to check for match
*/
inline bool Matches(const std::string& input)
{
return MatchesImpl(input);
}
private:
virtual void HandleInputImpl(const std::string& input) = 0;
virtual bool MatchesImpl(const std::string& input) = 0;
};
} // namespace txt
|
#include "graph.h"
#include <utility>
#include <iostream>
using namespace std;
Graph::Graph(int point_number){
this->n=point_number;
this->line=0;
memset(dat,0,MAX*MAX);
}
bool Graph::isEmpty(){
return n?false:true;
}
bool Graph::addline(pair<int,int>lines){
this->dat[lines.first][lines.second]=1;
return true;
}
bool Graph::deleteline(pair<int,int>lines){
this->dat[lines.first][lines.second]=0;
return true;
}
void Graph::display(){
for (int i=0;i<this->n;i++)
{
for (int j=0;j<this->n;j++){
cout<<" "<<dat[i][j];
}
cout<<endl;
}
}
|
#include <iostream>
#include <math.h>
#include <conio.h>
using namespace std;
class Perhitungan {
friend ostream& operator<<(ostream&, Perhitungan&);
friend istream& operator>>(istream&, Perhitungan&);
public:
float rata();
float STD();
private:
long sqrt(int n) { return(n*n); }
int n;
int A[20];
};
istream& operator>>(istream& in, Perhitungan& a)
{
cout<<"+++++++++WELCOME+++++++++"<<endl;
cout << "Masukan Banyaknya data : ";
cin >> a.n;
for (int i = 0; i < a.n; i++)
{
cout << "Masukkan data ke- " << i+1 << " = ";
cin >> a.A[i];
}
return in;
}
float Perhitungan::rata()
{
float total=0;
for (int i = 0; i<n; i++) total = total + A[i];
return(total/n);
}
float Perhitungan::STD ()
{ float rerata = rata();
float jumlah=0.0;
for (int i = 0; i<n; i++)
jumlah = jumlah + sqrt(A[i] - rerata);
return(sqrt (jumlah/(n-1)));
}
ostream& operator<<(ostream& out, Perhitungan& a) {
cout << "Rata-rata dari " << a.n;
cout<< " bilangan adalah : " << a.rata() << endl;
cout << "Standar deviasi= " << a.STD()<<endl;
cout<<"+++++++THANK YOU++++++++";
return out;
}
int main() {
Perhitungan run;
cin >> run;
cout << run;
return 0;
}
|
/*
SH_User.cpp
*/
#include "qdebug.h"
#include "include\SH_User.h"
/*
Constructor
*/
SH_User::SH_User()
: QObject()
{
}
SH_User::SH_User(QString username, QString password, QString access)
: QObject()
{
}
/*
Destructor
*/
SH_User::~SH_User()
{
}
/*
isLoggedIn()
returns state of loggedIn
*/
bool SH_User::isLoggedIn()
{
return loggedIn;
}
/*
setLoggedIn()
sets loggedIn bool
*/
void SH_User::setLoggedIn(bool state)
{
loggedIn = state;
}
/*
setUsername
*/
void SH_User::setUsername(QString username)
{
userName = username;
}
/*
setAccess
*/
void SH_User::setAccess(QString access)
{
userAccess = access;
}
/*
getUsername
*/
QString SH_User::getUsername()
{
return userName;
}
QString SH_User::getAccess()
{
return userAccess;
}
|
#ifndef CIRCLE_H
#define CIRCLE_H
#include <iostream>
#include <QMainWindow>
#include <QColor>
#include <QPainter>
#include <QPixmap>
#include <QPen>
#include "figure.h"
using namespace std;
class circle:public figure
{
private:
int r;
public:
circle(int x_=0,int y_=0,int r_=0);
~circle();
void draw(QPainter * painter);
};
#endif // CIRCLE_H
|
/*
Copyright (c) 2013-2014 Sam Hardeman
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
*/
#pragma once
#include "Platforms.h"
#include "Threading.h"
#include <vector>
#include "ClientContainer.h"
/*
ICECAT Networking v2.0
class NetworkControl:
This class is the main interface for all networking activities (Internally).
Caution advised.
*/
#define CONNECTION_BACKLOG 8
namespace IceNet
{
typedef unsigned short CLIENT_ID;
// Prototypes
class Client;
class ClientProxy;
class Packet;
class PacketHandler;
void ReceiveID( Packet* pack );
void AddRemoteClient( Packet* pack );
void RemoveRemoteClient( Packet* pack );
class NetworkControl
{
public:
// TCP is always on, UDP is enabled by default
enum Flags
{
// Protocols
PROTOCOL_TCP = 0,
PROTOCOL_UDP = 1,
// Handler settings
HANDLER_ASYNC = 0, // Packet handling is done asynchronously. Users are expected to make opcode functions threadsafe.
HANDLER_SYNC = 2, // Packet handling is invoked by the user. Opcode functions run in the same thread HandlePackets() was called from.
// Client Management
VENDOR_MODE = 4 // Clients will not know about the existence of other clients (via ClientProxy).
};
// Error codes in case things fail
enum ErrorCodes
{
ERROR_NONE,
ERROR_SOCKET_FAIL_TCP,
ERROR_SOCKET_FAIL_UDP,
ERROR_BIND_FAIL_TCP,
ERROR_BIND_FAIL_UDP,
ERROR_ALREADY_INIT,
ERROR_LISTEN_FAIL_TCP,
ERROR_WSA
};
static NetworkControl* GetSingleton( void );
unsigned int GetFlags( void );
public:
// Initialization functions
static ErrorCodes InitializeServer( const char* listenPort, Flags enabledProtocols = (Flags) ( PROTOCOL_TCP | PROTOCOL_UDP ) );
static ErrorCodes InitializeClient( const char* destinationPort, const char* ipAddress, Flags enabledProtocols = (Flags) ( PROTOCOL_TCP | PROTOCOL_UDP ) );
// Destructor and deinitialization function
~NetworkControl( void );
static void Deinitialize( void );
PacketHandler* GetPacketHandler( void );
// TCP sending of packages, for sending to server and client respectively. Only use one of these. Overrides packet UDP flag.
int SendToServerTCP( Packet* packetToSend, bool deletePacket = true, int flags = 0 );
int SendToClientTCP( CLIENT_ID privateID, Packet* packetToSend, bool deletePacket = true, int wsaFlags = 0 );
// UDP sending of packages, for sending to server and client respectively. Only use one of these.
int SendToServerUDP( Packet* packetToSend, bool deletePacket = true, int flags = 0 );
int SendToClientUDP( CLIENT_ID privateID, Packet* packetToSend, bool deletePacket = true, int wsaFlags = 0 );
// Broadcasting of packages to all clients. For UDP sending, packet must specify this explicitly.
void BroadcastToAll( Packet* packetToSend );
// Client list operations
Client* AddClient( CLIENT_ID publicId, CLIENT_ID privateId = 0, bool local = false, SOCKET socket = 0 );
void RemoveClient( CLIENT_ID publicId, CLIENT_ID privateId = 0 );
// Clientproxy list operations
ClientProxy* AddClientProxy( CLIENT_ID publicId );
void RemoveClientProxy( CLIENT_ID publicId );
// Set ID's
void SetPublicId( CLIENT_ID id );
void SetPrivateId( CLIENT_ID id );
// Flags
int ConnectToHost( void );
Event m_StopRequestedEvent;
Thread* m_NetworkThread;
Client* m_LocalClient;
// Client containment
std::vector< ClientContainer > m_ClientIds;
std::vector< ClientContainer > m_ClientProxyIds;
Client* m_PublicIdClientMap[USHRT_MAX];
Client* m_PrivateIdClientMap[USHRT_MAX];
ClientProxy* m_PublicIdClientProxyMap[USHRT_MAX];
SOCKET m_SocketTCP, m_SocketUDP;
static Event* m_RecycleConnection;
private:
// Connection information
addrinfo* m_MyAddrInfoTCP, *m_MyAddrInfoUDP;
#ifdef _WIN32
WSADATA m_WSAData;
#endif
Flags m_Flags;
// Packet handler for HANDLER_SYNC
PacketHandler* m_PacketHandler;
Mutex m_ClientAccessMutex;
protected:
static NetworkControl* m_Singleton;
static int m_InitCount;
friend THREAD_FUNC ListenerEntry( void* ptr );
friend class Broadcaster;
friend class UDPReceiver;
friend class PacketSender;
friend class PacketReceiver;
friend class PacketHandler;
private:
friend void ReceiveID( Packet* pack );
friend void AddRemoteClient( Packet* pack );
friend void RemoveRemoteClient( Packet* pack );
private:
// Protection against copying and assignment by overriding the copy constructor,
// and overloading the assignment operator. Thanks for the tip Juul.
NetworkControl( void );
NetworkControl( const NetworkControl& netInstance );
const NetworkControl& operator=( const NetworkControl& netInstance );
};
// Extern entrypoints for every scenario
extern THREAD_FUNC ServerEntry( void* ptr );
extern THREAD_FUNC ClientEntry( void* ptr );
extern THREAD_FUNC BroadcastEntry( void* ptr );
extern THREAD_FUNC ListenerEntry( void* ptr );
extern unsigned short RandomID( void );
};
|
#ifndef BINARYTREE_H
#define BINARYTREE_H
#include <QCoreApplication>
#include <iostream>
#include <queue>
///BinaryTree
///шаблон класса бинарного дерева, помимо стандартных методов работы с бинарными деревьями
///предоставляет функции обхода дерева
template <class T> class BinaryTree
{
protected:
BinaryTree *LinkFather, *LinkLeft, *LinkRight;//указатели на предка, левое и правое поддеревья
T Key;//ключ дерева
BinaryTree();//конструктор без присваивания ключа, необходим некоторым наследникам, когда значение ключа
//не известно заранее
public:
//методы сеттеры
BinaryTree(T value);//основной конструктор, создает дерево из единственного элемента
void DeleteSubtrees();//процедура рекурсивного вызова деструкторов для всех поддеревьев
bool AddLeftSon(BinaryTree *son);//добавление левого поддерева к дереву
bool AddRightSon(BinaryTree *son);//добавление правого поддерева к дереву
void SetKey(T value);//присваивает дереву новый ключ
//методы обхода дерева
//возвращают указатель на очередь, заполненную ключами в порядке обхода дерева
//статичные, работают с пустыми деревьями
static std::queue<T> *UpDownRevision(BinaryTree *thisTree,bool queueExists=false);//
static std::queue<T> *DownUpRevision(BinaryTree *thisTree,bool queueExists=false);//
static std::queue<T> *LeftRightRevision(BinaryTree *thisTree,bool queueExists=false);//
//деструктор
virtual ~BinaryTree()
{
if(LinkFather)//если дерево не корневое
{ //удаление ссылки на себя у предка
if(IsLeftSon())
{
LinkFather->LinkLeft=NULL;
}
else
{
LinkFather->LinkRight=NULL;
}
}
DeleteSubtrees();//даление поддеревьев
}
//признаки дерева
bool IsLeaf();//дерево - лист (не имеет поддеревьев)
bool IsRoot();//дерево - корневое (не имеет предка)
bool HasRightSon();//обладает непустым правым поддеревом
bool HasLeftSon();//обладает непустым правым поддеревом
bool IsLeftSon();//является левым поддеревом
//методы-геттеры
BinaryTree *GetLeftSon();//получение указателя на левого сына
BinaryTree *GetRightSon();//получение указателя на правого сына
BinaryTree *GetFather();//получение указателя на отца
BinaryTree *GetBrother();//получение указателя на брата
BinaryTree *GetRoot();//получение корневого дерева
T GetKey();//получение ключа дерева
int Height(int level=0);//измерение высоты поддерева, level - высота текущего дерева
};
///получение ключа дерева
template <class T> T BinaryTree<T>::GetKey()
{
return this->Key;
}
///установка ключа дерева
///value - новое значение ключа
template <class T> void BinaryTree<T>::SetKey(T value)
{
this->Key=value;
}
///получение указателя на предка дерева
template <class T> typename BinaryTree<T>::BinaryTree *BinaryTree<T>::GetFather()
{
return this->LinkFather;
}
///получение указателя на брата дерева
template <class T> typename BinaryTree<T>::BinaryTree *BinaryTree<T>::GetBrother()
{
if(this->LinkFather)//если дерево - не корневое
{
BinaryTree *leftSonOfFather=this->LinkFather->LinkLeft;//получение указателя на левое поддерево предка
//если этот указатель указывает на текущее дерево - вернуть его, иначе вернуть указатель на правое поддерево предка
return leftSonOfFather==this ? this->LinkFather->LinkRight:leftSonOfFather;
}
else
{
return NULL;//у корневого дерева нет братьев
}
}
///возвращает указатель на правое поддерево
template <class T> typename BinaryTree<T>::BinaryTree *BinaryTree<T>::GetRightSon()
{
return this->LinkRight;
}
///возвращает указатель на левое поддерево
template <class T> typename BinaryTree<T>::BinaryTree *BinaryTree<T>::GetLeftSon()
{
return this->LinkLeft;
}
///возвращает указатель на корневое дерево
template <class T> typename BinaryTree<T>::BinaryTree *BinaryTree<T>::GetRoot()
{
BinaryTree* returnRoot=this;
while(returnRoot->LinkFather)
{
returnRoot=returnRoot->LinkFather;
}
return returnRoot;
}
/// служебный конструктор без немедленного добавления ключа
/// используется потомками в тех случаях, когда необходимо знать топологию дерева
/// до вычисления ключа
template <class T> BinaryTree<T>::BinaryTree()
{
this->LinkFather=NULL;
this->LinkLeft=NULL;
this->LinkRight=NULL;
}
/// стандартный конструктор, создает дерево из одного листа
/// value - значение ключа
template <class T> BinaryTree<T>::BinaryTree(T value)
{
this->LinkFather=NULL;
this->LinkLeft=NULL;
this->LinkRight=NULL;
this->Key=value;
}
///удаляет поддеревья дерева
template <class T> void BinaryTree<T>::DeleteSubtrees()
{
//если они существуют, вызываются их деструкторы
if(LinkRight)
{
delete LinkRight;
}
if(LinkLeft)
{
delete LinkLeft;
}
}
///проверка, является ли дерево листом
template <class T> bool BinaryTree<T>::IsLeaf()
{
return this->LinkRight==NULL && this->LinkLeft==NULL;
}
///проверка, является ли дерево корневым (если ли предок)
template <class T> bool BinaryTree<T>::IsRoot()
{
return this->LinkFather==NULL;
}
///проверка, является ли дерево левым поддеревом предка
template <class T> bool BinaryTree<T>::IsLeftSon()
{
if(LinkFather)
{
return LinkFather->LinkLeft==this;
}
else
{
return false;//корневое дерево - ничей сын
}
}
///проверка существования непустого правого поддерева
template <class T> bool BinaryTree<T>::HasRightSon()
{
return this->LinkRight!=NULL;
}
///проверка существования непустого левого поддерева
template <class T> bool BinaryTree<T>::HasLeftSon()
{
return this->LinkLeft!=NULL;
}
///добавление левого поддерева к дереву
/// son - указатель на добавляемое дерево
/// возвращает true если добавление было успешно
/// добавление может не произойти, если левый сын - непустое поддерево
template <class T> bool BinaryTree<T>::AddLeftSon(BinaryTree<T> *son)
{
if (this->LinkLeft!=NULL)//если левое поддерево непустое
{
return false;//отказ от добавления
}
else
{ //иначе слинковать предка и сына
this->LinkLeft=son;
son->LinkFather=this;
return true;
}
}
///добавление левого поддерева к дереву
/// son - указатель на добавляемое дерево
/// возвращает true если добавление было успешно
/// добавление может не произойти, если левый сын - непустое поддерево
/// симметричен методу AddLeftSon
template <class T> bool BinaryTree<T>::AddRightSon(BinaryTree<T> *son)
{
if (this->LinkRight!=NULL)
{
return false;
}
else
{
this->LinkRight=son;
son->LinkFather=this;
return true;
}
}
///получение высоты дерева
/// параметр level - текущая высота дерева относительно корня (дерева, вызвавшего метод, не абсолютного корня)
/// по умолчанию равен 0
template <class T> int BinaryTree<T>::Height(int level)
{
level++;//дерево выросло на единицу
if(IsLeaf())//если дерево - лист
{
return level;//вернуть текущую высоту
}
else//иначе
{
int leftSubtreeHeight=0,rightSubtreeHeight=0;//предположим, что высоты поддеревьев нулевые
if(LinkLeft)//если есть левое поддерево
{
leftSubtreeHeight=this->LinkLeft->Height(level);//вычислить его высоту относительно корня
}
if(LinkRight)//если есть правое поддерево
{
rightSubtreeHeight=this->LinkRight->Height(level);//вычислить его высоту относительно корня
}
//сравнить высоты левого и правого поддеревьев и вернуть большую как высоту всего дерева
return leftSubtreeHeight>rightSubtreeHeight?leftSubtreeHeight:rightSubtreeHeight;
}
}
///обходит дерево сверху вниз
/// thisTree указатель на исследуемое дерево
/// queueExists - служебный параметр, служит для индикации того, что процедура создала очередь
/// должен всегда быть равен нулю (как запретить пользователю изменять параметр?)
/// возвращает указатель на очередь
/// удаление этой очереди лежит на пользователе
/// для пустого дерева вернет пустую очередь
template <class T> std::queue<T> *BinaryTree<T>::UpDownRevision(BinaryTree *thisTree, bool queueExists)
{
static std::queue<T> *returnQueue;//указатель на возвращаемую очередь
if(!queueExists)//если очереди не существует
{
returnQueue=new std::queue<T>;//создать очередь
queueExists=true;//установить флаг существования очереди
}
if(thisTree)//если дерево непустое
{
returnQueue->push(thisTree->Key);//добавить ключ дерева в очередь
UpDownRevision(thisTree->LinkLeft,queueExists);//добавить все ключи левого поддерева в очередь
UpDownRevision(thisTree->LinkRight,queueExists);//добавить все ключи правого поддерева в очередь
}
return returnQueue;//вернуть очередь
}
///обходит дерево снизу вверх
/// thisTree указатель на исследуемое дерево
/// queueExists - служебный параметр, служит для индикации того, что процедура создала очередь
/// должен всегда быть равен нулю (как запретить пользователю изменять параметр?)
/// возвращает указатель на очередь
/// удаление этой очереди лежит на пользователе
/// для пустого дерева вернет пустую очередь
/// идентичен UpDownRevision, за исключением момента добавления ключа дерева в очередь
template <class T> std::queue<T> *BinaryTree<T>::DownUpRevision(BinaryTree *thisTree, bool queueExists)
{
{
static std::queue<T> *returnQueue;
if(!queueExists)
{
returnQueue=new std::queue<T>;
queueExists=true;
}
if(thisTree)
{
DownUpRevision(thisTree->LinkLeft,queueExists);
DownUpRevision(thisTree->LinkRight,queueExists);
returnQueue->push(thisTree->Key);
}
return returnQueue;
}
}
///обходит дерево сверху вниз
/// thisTree указатель на исследуемое дерево
/// queueExists - служебный параметр, служит для индикации того, что процедура создала очередь
/// должен всегда быть равен нулю (как запретить пользователю изменять параметр?)
/// возвращает указатель на очередь
/// удаление этой очереди лежит на пользователе
/// для пустого дерева вернет пустую очередь
/// /// идентичен UpDownRevision, за исключением момента добавления ключа дерева в очередь
template <class T> std::queue<T> *BinaryTree<T>::LeftRightRevision(BinaryTree *thisTree, bool queueExists)
{
{
static std::queue<T> *returnQueue;
if(!queueExists)
{
returnQueue=new std::queue<T>;
queueExists=true;
}
if(thisTree)
{
LeftRightRevision(thisTree->LinkLeft,queueExists);
returnQueue->push(thisTree->GetKey());
LeftRightRevision(thisTree->LinkRight,queueExists);
}
return returnQueue;
}
}
#endif // BINARYTREE_H
|
#include <iostream>
#include <vector>
#include <string>
#include <sstream>
#include <algorithm>
using namespace std;
void printn(char ch, int n) {
while (n--)
cout << ch;
}
void hrule(const vector<int> &col_width) {
for (int w: col_width) {
cout << "$";
printn('-', w);
}
cout << "$\n";
}
int main() {
string line;
getline(cin, line);
int n = stoi(line);
vector<vector<string>> table;
vector<int> col_width;
for (int i = 0; i < n; i++) {
getline(cin, line);
istringstream sin(line);
vector<string> row;
string cell;
while (getline(sin, cell, ',')) {
row.push_back(cell);
}
if (line.back() == ',')
row.push_back("");
if (line != "") {
if (col_width.empty())
col_width.assign(row.size(), 0);
for (int j = 0; j < row.size(); j++)
col_width[j] = max(col_width[j], (int)row[j].size());
}
table.push_back(row);
}
if (col_width.size() == 0)
col_width = {0};
hrule(col_width);
for (int i = 0; i < n; i++) {
if (table[i].size() == 0)
table[i].assign(col_width.size(), "");
printf("|");
for (int j = 0; j < table[i].size(); j++) {
bool num = true;
for (char ch: table[i][j])
if (ch < '0' || ch > '9')
num = false;
if (num) {
printn(' ', col_width[j] - table[i][j].size());
cout << table[i][j];
} else {
cout << table[i][j];
printn(' ', col_width[j] - table[i][j].size());
}
cout << "|";
}
cout << "\n";
hrule(col_width);
}
}
|
#include <iostream>
#include <map>
class Flyweight
{
public:
virtual ~Flyweight() {}
virtual void operation() = 0;
// ...
};
class UnsharedConcreteFlyweight : public Flyweight
{
public:
UnsharedConcreteFlyweight(const int intrinsic_state) : state(intrinsic_state) {}
~UnsharedConcreteFlyweight() {}
void operation()
{
std::cout << "Unshared Flyweight with state " << state << std::endl;
}
private:
int state;
};
class ConcreteFlyweight : public Flyweight
{
public:
ConcreteFlyweight(const int all_state) : state(all_state) {}
~ConcreteFlyweight() {}
void operation()
{
std::cout << "Concrete Flyweight with state " << state << std::endl;
}
private:
int state;
};
class FlyweightFactory
{
public:
~FlyweightFactory()
{
for (auto it = flies.begin(); it != flies.end(); it++)
{
delete it->second;
}
flies.clear();
}
Flyweight *getFlyweight(const int key)
{
if (flies.find(key) != flies.end())
{
return flies[key];
}
Flyweight *fly = new ConcreteFlyweight(key);
flies.insert(std::pair<int, Flyweight *>(key, fly));
return fly;
}
private:
std::map<int, Flyweight *> flies;
};
int main()
{
FlyweightFactory *factory = new FlyweightFactory;
factory->getFlyweight(1)->operation();
factory->getFlyweight(2)->operation();
delete factory;
return 0;
}
|
#include "jugador.h"
namespace Juego {
void actualizarJugador() {
}
void dibujarJugador() {
}
}
|
class Solution {
public:
bool canPlaceFlowers(vector<int>& flowerbed, int n) { // 贪心算法 贪心在于放尽可能多的花，比较花的数量和n的大小。
int flowers = 0;
if (flowerbed.size() == 0) return 0;
for (int i = 0; i < flowerbed.size(); i += 2) { // 两个格子进行跳跃 这是因为一个格子确定有花之后，下一个一定是0。这样一来，下一朵花需要在离
// 当前花儿2个单位的距离下才可以栽种。
if (flowerbed[i] == 0) { // 如果当前位置没有花
if (i == flowerbed.size() - 1 || flowerbed[i + 1] == 0) { // 判断，如果是最后一个格子了，那么就种一朵花，这个时候后面没有格子了；或者下一个是没有花的，可以种一朵
// 不用判断前面的格子，这是因为之前移动单位是2，前面的格子已经检查过了，确认是没有花的。
flowers++;
}
else i++; // 如果这个格子的下一个位置有花，那么这个格子不能种花。这个时候位置i转移到下一个格子，准备i += 2，直接在有花的位置跳两格，查看下一个位置。
}
}
return flowers >= n; // 比较最多能种的花数量和n的大小，如果n更小，显然可以种下。
}
};
// reference https://leetcode-cn.com/problems/can-place-flowers/solution/qi-si-miao-jie-by-heroding-h7m0/
|
#include <bits/stdc++.h>
using namespace std;
int main()
{ stack <int> arr;
char st[100100],nd[100100];
cin>>st>>nd;
int n1=strlen(st),n2=strlen(nd),n;
if(st[0]=='0')cout<<nd; //ไม่จำเป็น
else{
if(n1>=n2)
{n=n2;
int j=n1-1,s=0;
for(int i=n-1;i>=0;i--)
{
arr.push((st[j]+nd[i]-96+s)%10);
//cout<<st[j]<<" "<<nd[i]<<" "<<(st[j]+nd[i]-96+s)%10<<"\n";
s=(st[j]+nd[i]-96+s)/10;
j--;
}
for(int i=j;i>=0;i--)
{
arr.push((st[i]-48+s)%10);
s=(st[i]-48+s)/10;
}
if(s!=0) arr.push(s);
while(!arr.empty())
{
cout<<arr.top();
arr.pop();
}
}
else
{
n=n1;
int j=n2-1,s=0;
for(int i=n-1;i>=0;i--)
{
arr.push((st[i]+nd[j]-96+s)%10);
//cout<<st[j]<<" "<<nd[i]<<" "<<(st[j]+nd[i]-96+s)%10<<"\n";
s=(st[i]+nd[j]-96+s)/10;
j--;
}
for(int i=j;i>=0;i--)
{
arr.push((nd[i]-48+s)%10);
s=(nd[i]-48+s)/10;
}
if(s!=0) arr.push(s);
while(!arr.empty())
{
cout<<arr.top();
arr.pop();
}
}}
return 0;
}
|
#include <ResetDetector.h> //prefer this works more reliable than doubleResetDetector
//#include <DoubleResetDetector.h>
#include <wifi.h> //refactored out WiFiManager
#include <utils.h> //utilities functions
// Dependency Graph
// |-- <ResetDetector> 1.0.3
// | |-- <EEPROM> 1.0
// |-- <DNSServer> 1.1.1
// | |-- <ESP8266WiFi> 1.0
// |-- <ESP8266WebServer> 1.0
// | |-- <ESP8266WiFi> 1.0
// |-- <ESP8266WiFi> 1.0
// |-- <WifiManager> 0.15.0
// | |-- <DNSServer> 1.1.1
// | | |-- <ESP8266WiFi> 1.0
// | |-- <ESP8266WebServer> 1.0
// | | |-- <ESP8266WiFi> 1.0
// | |-- <ESP8266WiFi> 1.0
#define PORT 80
ESP8266WebServer server(PORT); //listening server
void handleRoot(); // function prototypes for HTTP handlers
void handleON();
void handleOFF();
void handle404();
//const char MAIN_page[] PROGMEM = R"=====(<html><body>Ciclk to turn <a href="\on">LED ON</a><br>Ciclk to turn <a href="\off">LED OFF</a><br></body></html>)=====";
//RAW String does not work and causes esp8266 to crash :(
const char MAIN_page[] = "<html><body>Click to turn\
<a href=\"on\">LED ON</a>\
<br>Click to turn \
<a href=\"off\">LED OFF</a>\
<br></body></html>";
const int PIN_LED = 2;
void handleRoot() {
Serial.println("/");
blinkLED(500, 10, PIN_LED);
String s = MAIN_page;
server.send(200, "text/html", s);
}
void handleON() {
Serial.println("LED on page");
blinkLED(500, 5, PIN_LED);
server.send(200, "text/html", "<b>ON action</b>");
}
void handleOFF() {
Serial.println("LED off page");
blinkLED(10, 5, PIN_LED);
server.send(200, "text/html", "<b>OFF action</b>");
}
void handle404(){
blinkLED(100, 10, PIN_LED);
server.send(404, "text/plain", "404: Not found");
}
void setup() {
int resetCounter = ResetDetector::execute(2000); //capture number of resets during 2 seconds
Serial.begin(115200);
setupWifi(resetCounter);
// //WiFiManager
// //Local intialization. Once its business is done, there is no need to keep it around
// WiFiManager wifiManager;
// //default is true print a lot of debug info under *WM
// wifiManager.setDebugOutput(false);
// //WiFi.printDiag(Serial);
// //reset Wifi settings or initial setup
// //only when reset buttons pressed 2 times or more
// if (resetCounter >= 2) {
// wifiManager.resetSettings();
// //twice to indicate in setup mode
// blinkLED(500, 2, PIN_LED);
// Serial.println("wifi: entering setup mode");
// //set the AP's name for you to connect and configure
// wifiManager.autoConnect("ap");
// //wifiManager.startConfigPortal(); //I don't know what this actually do
// Serial.println("wifi: entering Config Portal");
// }
// else { //enter running mode
// Serial.println("wifi: press reset twice to setup Wifi");
// }
if (WiFi.status()==WL_CONNECTED) {
Serial.print("wifi: local ip-> ");
Serial.println(WiFi.localIP());
server.on("/", handleRoot);
server.on("/on", handleON);
server.on("/off", handleOFF);
server.onNotFound(handle404);
server.begin();
Serial.println("http: HTTP server started");
}
}
void loop() {
server.handleClient();
}
|
/*
ID: hjl11841
TASK: palsquare
LANG: C++
*/
#include<bits/stdc++.h>
using namespace std;
int b;
int a[1000];
char g[12]={'A','B','C','D','E','F','G','H','I','J','K','L'};
bool check(int x){
int st=1,tail=1;
while(x!=0){
a[tail]=x%b;
x=x/b;
tail++;
}
tail--;
for(int i=1;i<=(tail+1)/2;i++){
if(a[i]!=a[tail+1-i]){
st=0;
break;
}
}
if(st==1) return true;
else return false;
}
void shuchu(int x){
int tail=1;
while(x!=0){
a[tail]=x%b;
x=x/b;
tail++;
}
tail--;
for(int i=tail;i>=1;i--){
if(a[i]<=9) cout<<a[i];
else cout<<g[a[i]-10];
}
}
int main() {
freopen("palsquare.in","r",stdin);
freopen("palsquare.out","w",stdout);
cin>>b;
for(int i=1;i<=300;i++){
if(check(i*i)){
shuchu(i);
cout<<' ';
shuchu(i*i);
cout<<endl;
}
}
return 0;
}
|
/*************************************************************************
> File Name : ItsDatabase.h
> Author : YangShuai
> Created Time: 2016年08月19日 星期五 12时35分53秒
> Description :
************************************************************************/
#ifndef ITSDATABASE_H
#define ITSDATABASE_H
#include<string>
#include"sqlite3.h"
#include"../utils/common.h"
#include"../data/Itsdata.h"
#include"../primitive/PrimitiveTools.h"
using std::string;
class Database{
public:
Database();
Database(sqlite3*);
~Database();
protected:
sqlite3* db;
};
/**
* @_get_cmh_state() : 获取CMH当前状态值
* @_get_max_cmh() : 获取当前最大CMH值
* @_insert_cmh() : 插入新的CMH，同时将状态设置为INIT
* @_update_cmh_state() : 更新CMH状态
*/
class DB_CmhState : public Database{
friend int CmhState_callback(void*, int, char**, char**);
public:
DB_CmhState() = default;
DB_CmhState(sqlite3*);
void init(sqlite3*);
public:
int _get_cmh_state(CMH cmh, Cmh_State& state);
int _get_max_cmh(CMH& cmh);
int _insert_cmh(CMH cmh);
int _update_cmh_state(CMH cmh, Cmh_State state);
int _delete(CMH&);
private:
CMH max_cmh;
int cmh_state;
};
/**
* @_get_cmh_content() : 获取CMH绑定的内容
* @_update_cmh_content() : 更新CMH绑定的内容
*/
class DB_CmhContent : public Database{
friend int CmhContent_callback(void*, int, char**, char**);
public:
DB_CmhContent() = default;
DB_CmhContent(sqlite3*);
void init(sqlite3*);
public:
int _get_cmh_content(CMH cmh, Data* pub_key, Data* pri_key, HashedId8* certid8);
int _update_cmh_content(CMH cmh, Data* pub_key, Data* pri_key, HashedId8* certid8);
int _delete(CMH&);
private:
Data public_key;
Data private_key;
Data certificate_id8;
};
/**
* @_get_id() : 获取证书相关ID，包括Certid8、Certid10、CrlID等,传入参数可以是Certid8或者Certid10
* @_search_cert() : 查询该证书是否存在, 返回值：-1-出错 0-不存在 1-存在
* @_get_cert_info() : 获取证书相关信息
* @_get_cert_data() : 获取证书
* @_insert_cert() : 插入证书
* @_update_cert_info() : 更新证书信息
*/
class DB_CertInfo : public Database{
friend int CertInfo_callback(void*, int, char**, char**);
friend int CertInfo_callback_search_cert(void*, int, char**, char**);
public:
DB_CertInfo() = default;
DB_CertInfo(sqlite3*);
void init(sqlite3*);
public:
int _get_id(HashedId8* certid8, CertId10* certid10, CertInfo& cert_info);
int _search_cert(HashedId8& certid8);
int _search_cert(CertId10& certid10);
int _get_cert_info(HashedId8& certid8, CertInfo& cert_info);
int _get_cert_data(HashedId8& certid8, Data& cert_data);
int _insert_cert(CertInfo& cert_info, Data& cert_data);
int _update_cert_info(HashedId8& certid8, bool* trust_anchor, bool* verified, bool* revocation);
int _delete(HashedId8&);
private:
Data _certid8;
Data _certid10;
int _cert_type;
bool _trust_anchor;
bool _verified;
bool _revocation;
Data _expiry;
Data _crl_id;
Data _certificate;
bool search_cert;
};
/**
* @_get_crl_info() : 获取CRL相关信息，一般是获取CRL证书表的表名，以及相关时间
* @_insert_crl() : 插入一份CRL信息，同时创建一张CRL证书列表
* @_search_cert() : 查询证书是否存在, 返回值：-1-出错 0-不存在 1-存在
* @_insert_cert() : 插入证书
*/
class DB_Crl : public Database{
friend int Crl_callback(void*, int, char**, char**);
friend int Crl_callback_search_cert(void*, int, char**, char**);
public:
DB_Crl() = default;
DB_Crl(sqlite3*);
void init(sqlite3*);
public:
int _get_crl_info(HashedId8& crl_id, CrlInfo& crl_info);
int _insert_crl(HashedId8& crl_id, CrlInfo& crl_info);
int _search_cert(string& table_name, CertId10& certid10);
int _insert_cert(string& table_name, CertId10& certid10, Time32* expiry);
int _delete(HashedId8&);
private:
Data crlid;
int crl_type;
Data series;
Data serial;
Data start_period;
Data issue_date;
Data next_crl;
string crl_list_name;
bool search_cert;
};
#endif
|
// EagleControllerTest.cpp : Defines the entry point for the console application.
//
#define _CRT_SECURE_NO_WARNINGS
#include "stdafx.h"
#include <iostream>
using namespace std;
#include "String.h"
//#define AssertEqual(a, b) {if (!(a == b)) cout << "Failed " << __FUNCTION__ << ". Expected, received: >" << a << "< != >" << b << "<" << endl;}
#define AssertEqual(a, b) {if (!(a == b)) cout << "Failed " << __FUNCTION__ << ". Expected, received: " << a << " != " << b << "" << endl;}
//#define AssertEqual(a, b) {if (!(a == b)) __debugbreak;}
#include "PersistentStorageTest.h"
#include "IAnimationTest.h"
#include "AnimationAlternateTest.h"
#include "CommandTest.h"
#include "AnimationBlendTest.h"
#include "AnimationColorRotateTest.h"
#include "AnimationSetChunkTest.h"
#include "AnimationFlashDecayTest.h"
#include "AnimationRandomFlashTest.h"
#include "AnimationCommandsTest.h"
#include "AnimationIndividualTest.h"
#include "TokenizerTest.h"
int main()
{
PersistentStorageTest::Test();
IAnimationTest::Test();
AnimationAlternateTest::Test();
CommandTest::Test();
AnimationBlendTest::Test();
AnimationColorRotateTest::Test();
AnimationFlashDecayTest::Test();
AnimationSetChunkTest::Test();
AnimationRandomFlashTest::Test();
AnimationCommandsTest::Test();
AnimationIndividualTest::Test();
TokenizerTest::Test();
return 0;
}
|
#include "euler_cmp.hpp"
double **calculate(compendulum cmp) {
double T = 2 * PI*sqrt(cmp.L / cmp.g);
double dt = (double)T / N * 8;
double **calculations = new double*[N];
for (int i = 0; i < N; i++) {
calculations[i] = new double[3];
}
calculations[0][0] = 0; // time column
calculations[0][1] = cmp.angle0; // angle column
calculations[0][2] = cmp.velocity; // deriv angle column
for (int i = 1; i < N; i++) {
calculations[i][0] = calculations[i - 1][0] + dt;
calculations[i][2] = calculations[i - 1][2] - (cmp.g / cmp.L * sin(calculations[i - 1][1]) + cmp.friction / cmp.m *calculations[i - 1][2])* dt; // ???
calculations[i][1] = calculations[i][2] * dt + calculations[i - 1][1];
}
return calculations;
}
double accuracy_period(double **calcs, compendulum cmp) {
double T_analytics = 2 * PI*sqrt(cmp.L / cmp.g);
double T_calculated = 0;
double time1_max = 0, time2_max = 0;
int i = 1;
while ( (time2_max == 0) ) {
if (calcs[i - 1][1]<calcs[i][1] && calcs[i][1]>calcs[i + 1][1]) {
if (time1_max == 0) {
time1_max = calcs[i][0];
}
else {
time2_max = calcs[i][0];
}
}
i++;
}
return T_analytics - (time2_max - time1_max);
}
|
#ifndef SYSTEM_H
#define SYSTEM_H
#include <opencv2/opencv.hpp>
#include "Engine.h"
#include <stdio.h>
#include <stdint.h>
#include <string.h>
class System {
public:
cv::Mat image;
Engine eng;
uint32_t portno;
char* host;
System();
void setImage(cv::Mat& obj);
cv::Mat getImage();
void setEngine(Engine& obj);
};
#endif
|
#include "Linklist.h"
#include<iostream>
using namespace std;
int main(){
Linklist<int> ll;
int ch = 0;
char loop = 1;
int data;
int pos;
while(loop){
cout<<"Menu:\n1.AddBegin\n2.AddEnd\n3.DeleteBegin\n4.DeleteEnd\n5.Display\n6.Size\n7.Reverse\n8.AddAtPos\n9.DeleteAtPos\n10.ReverseList\n11.Exit\n";
cin>>ch;
switch(ch){
case 1:
cout<<"Enter Element : \n";
cin>>data;
ll.AddBegin(data);
break;
case 2:
cout<<"Enter Element : \n";
cin>>data;
ll.AddEnd(data);
break;
case 3:
ll.DeleteBegin();
cout<<"Deleted...";
break;
case 4:
ll.DeleteEnd();
break;
case 5:
ll.Display();
break;
case 6:
cout<<ll.size()<<"\n";
break;
case 7:
ll.Reverse(ll.getHead());
break;
case 8:
cout<<"Enter Pos and data:\n";
cin>>pos>>data;
ll.AddAtPos(pos,data);
break;
case 9:
cout<<"Enter Pos : \n";
cin>>pos;
ll.DeleteAtPos(pos);
break;
case 10:
// ll.ReverseList(ll.getHead());
break;
case 11:
loop = 0;
break;
default:
cout<<"Enter correct choice...";
}
}
return 0;
}
|
#pragma once
#include "fp_camera.h"
class FloatingCamera : public FPCamera {
public:
FloatingCamera(float32 fov, float32 width, float32 height) : FPCamera(fov, width, height) {}
void MoveUp(float32 amount) {
Translate(up * amount);
}
};
|
#include "Texture.h"
bool Texture::load( string file )
{
bool result = false;
SDL_Surface* img = IMG_Load( file.c_str() );
if( img )
{
glGenTextures( 1, &mID );
glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA, img->w, img->h, 0, GL_RGBA, GL_UNSIGNED_BYTE, img->pixels );
mWidth = img->w;
mHeight = img->h;
SDL_FreeSurface( img );
}
return result;
}
void Texture::unload()
{
if( mID > 0 )
glDeleteTextures( 1, &mID );
mWidth = mHeight = 0;
}
Texture& Texture::operator=( const Texture& ref )
{
mID = ref.mID;
mWidth = ref.mWidth;
mHeight = ref.mHeight;
return *this;
}
Texture::Texture( const Texture& ref )
: mID( ref.mID ), mWidth( ref.mWidth ), mHeight( ref.mHeight )
{
}
Texture::Texture()
: mID( 0 ), mWidth( 0 ), mHeight( 0 )
{
}
Texture::~Texture()
{
}
|
// -*- C++ -*-
//
// Copyright (C) 1998, 1999, 2000, 2002 Los Alamos National Laboratory,
// Copyright (C) 1998, 1999, 2000, 2002 CodeSourcery, LLC
//
// This file is part of FreePOOMA.
//
// FreePOOMA is free software; you can redistribute it and/or modify it
// under the terms of the Expat license.
//
// 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 Expat
// license for more details.
//
// You should have received a copy of the Expat license along with
// FreePOOMA; see the file LICENSE.
//
//-----------------------------------------------------------------------------
// Class:
// Pooma::MetaTokenIterator
//-----------------------------------------------------------------------------
/** @file
* @ingroup IO
* @brief
* MetaTokenIterator is a helper class designed to efficiently parse
* a line from the "DiscField" .meta file.
*/
#ifndef POOMA_IO_METATOKENITERATOR_H
#define POOMA_IO_METATOKENITERATOR_H
#include <string>
namespace Pooma {
/**
* MetaTokenIterator is a helper class designed to efficiently parse
* a line from the "DiscField" .meta file. MetaTokenIterator views
* each line as having the form:
*
* word0 [=] word1 word2 word3 [#comment]
*
* where the words are separated by whitespace. The iterator returns
* the sequence of words only, ignoring the '=' and any comments.
*/
// I don't inherit from std::iterator here because VC++'s iterator
// class is badly screwed up. Instead I just typedef things
// directly.
class MetaTokenIterator
{
public:
//-------------------------------------------------------------------------
// Typedefs
//-------------------------------------------------------------------------
// Iterator requirements
typedef std::input_iterator_tag iterator_category;
typedef std::string value_type;
typedef long difference_type;
typedef std::string* pointer;
typedef std::string& reference;
// Convenience
typedef std::string::size_type Size_t;
//-------------------------------------------------------------------------
// Constructors
//-------------------------------------------------------------------------
MetaTokenIterator()
: line_m(std::string("")), begIdx_m(std::string::npos)
{ }
MetaTokenIterator(const std::string &line)
: line_m(line), begIdx_m(0), endIdx_m(0), firstWord_m(true)
{
token_m.reserve(32);
// Advance to the first word.
next();
}
MetaTokenIterator(const MetaTokenIterator &model)
: line_m(model.line_m),
begIdx_m(model.begIdx_m),
endIdx_m(model.endIdx_m),
firstWord_m(model.firstWord_m)
{
token_m.reserve(32);
}
//-------------------------------------------------------------------------
// Iterator interface
//-------------------------------------------------------------------------
inline const std::string &operator*() const
{
token_m = line_m.substr(begIdx_m, endIdx_m - begIdx_m);
return token_m;
}
inline const std::string *operator->() const
{
token_m = line_m.substr(begIdx_m, endIdx_m - begIdx_m);
return &token_m;
}
inline MetaTokenIterator &operator++()
{
if (firstWord_m) skipEquals();
firstWord_m = false;
next();
return *this;
}
inline MetaTokenIterator operator++(int)
{
MetaTokenIterator tmp(*this);
if (firstWord_m) skipEquals();
firstWord_m = false;
next();
return tmp;
}
inline bool operator==(const MetaTokenIterator &iter) const
{
// We don't actually check that we're in the same string as this
// would complicate comparison to the end iterator.
if (iter.begIdx_m == std::string::npos)
return begIdx_m == std::string::npos;
else
return (begIdx_m == iter.begIdx_m && endIdx_m == iter.endIdx_m);
}
inline bool operator!=(const MetaTokenIterator &iter) const
{
return !operator==(iter);
}
private:
//-------------------------------------------------------------------------
// Utility functions
//-------------------------------------------------------------------------
void skipEquals();
void next();
//-------------------------------------------------------------------------
// Data
//-------------------------------------------------------------------------
const std::string &line_m;
Size_t begIdx_m;
Size_t endIdx_m;
// String used to store token - needed to implement operator->()
// and operator*(). Mutable since these are const member
// functions.
mutable std::string token_m;
// Are we in the first word? Used to handle the optional '=' after
// the "keyword".
bool firstWord_m;
};
} // namespace Pooma
#endif // POOMA_IO_METATOKENITERATOR_H
// ACL:rcsinfo
// ----------------------------------------------------------------------
// $RCSfile: MetaTokenIterator.h,v $ $Author: richard $
// $Revision: 1.3 $ $Date: 2004/11/01 18:16:52 $
// ----------------------------------------------------------------------
// ACL:rcsinfo
|
#include "test_util.h"
void TEST_RM_7(const string &tableName)
{
// Functions Tested
// 1. Reorganize Page **
// Insert tuples into one page, reorganize that page,
// and use the same tids to read data. The results should
// be the same as before. Will check code as well.
cout << "****In Test Case 7****" << endl;
RID rid;
int tupleSize = 0;
int numTuples = 5;
void *tuple;
void *returnedData = malloc(100);
int sizes[numTuples];
RID rids[numTuples];
vector<char *> tuples;
RC rc = 0;
for(int i = 0; i < numTuples; i++)
{
tuple = malloc(100);
// Test Insert Tuple
float height = (float)i;
prepareTuple(6, "Tester", 20+i, height, 123, tuple, &tupleSize);
rc = rm->insertTuple(tableName, tuple, rid);
assert(rc == success);
tuples.push_back((char *)tuple);
sizes[i] = tupleSize;
rids[i] = rid;
if (i > 0) {
// Since we are inserting 5 tiny tuples into an empty table where the page size is 4kb, all the 5 tuples should be on the first page.
assert(rids[i - 1].pageNum == rids[i].pageNum);
}
cout << rid.pageNum << endl;
}
cout << "After Insertion!" << endl;
int pageid = rid.pageNum;
rc = rm->reorganizePage(tableName, pageid);
assert(rc == success);
// Print out the tuples one by one
int i = 0;
for (i = 0; i < numTuples; i++)
{
rc = rm->readTuple(tableName, rids[i], returnedData);
assert(rc == success);
printTuple(returnedData, tupleSize);
//if any of the tuples are not the same as what we entered them to be ... there is a problem with the reorganization.
if (memcmp(tuples[i], returnedData, sizes[i]) != 0)
{
cout << "****Test case 7 failed****" << endl << endl;
break;
}
}
if(i == numTuples)
{
cout << "****Test case 7 passed****" << endl << endl;
}
// Delete Table
rc = rm->deleteTable(tableName);
assert(rc == success);
free(returnedData);
for(i = 0; i < numTuples; i++)
{
free(tuples[i]);
}
return;
}
int main(int argc, char* argv[])
{
(void)argv;
if(argc > 1)
{
cout << "Attach debugger and press enter to continue.\n";
getchar();
}
cout << endl << "Test Reorganize Page .." << endl;
// Reorganize Page
TEST_RM_7("tbl_employee2");
return 0;
}
|
#ifndef MYGRAPHICSSCENE_H
#define MYGRAPHICSSCENE_H
#include <QGraphicsScene>
#include "scenestates.h"
class MyGraphicsScene: public QGraphicsScene
{
Q_OBJECT
public:
MyGraphicsScene(QObject *parent);
void setSceneRect(qreal x, qreal y, qreal w, qreal h);
void setSceneState(SceneState iscenestate);
public slots:
void UpdateScen();
signals:
void mouseLeftScene();
void leftButtonMousePress(const QPointF &point);
// QGraphicsScene interface
protected:
void drawBackground(QPainter * painter, const QRectF & rect ) override;
void mousePressEvent(QGraphicsSceneMouseEvent *event) override;
// QObject interface
public:
bool event(QEvent *event) override;
void setSceneMouseEnent(bool ievent);
private:
SceneState _scenestate{SceneState::NormalState};
};
#endif // MYGRAPHICSSCENE_H
|
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode() : val(0), next(nullptr) {}
* ListNode(int x) : val(x), next(nullptr) {}
* ListNode(int x, ListNode *next) : val(x), next(next) {}
* };
*/
class Solution {
public:
ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
int n1,n2,carry=0,temp;
ListNode *head=new ListNode(0), *res=head;
while(l1||l2||carry)
{
if(l1){
n1=l1->val;
l1=l1->next;
}
else
n1=0;
if(l2)
{
n2=l2->val;
l2=l2->next;
}
else
n2=0;
temp=n1+n2+carry;
res->next=new ListNode(temp%10);
res=res->next;
carry=temp/10;
}
return head->next;
}
};
|
#include <iostream>
#include <cmath>
using namespace std;
//this function test if number is prime. It returns 1 if it's prime
int isprime (int num)
{
if (num == 1) return 0;
if (num == 2) return 1;
for (int i = 2; i <= sqrt(num); i++)
{
if (num % i == 0) return 0;
}
}
//this function return number of prime factors
int factors (int a)
{
int amount = 0;
if (isprime(a)) return 1;
if (a%2==0)
{
amount = 1;
a = a/2;
}
for (int i=3;i<=a;i=i+2) {
if(isprime(i) && a%i==0)
{amount++;
a=a/i;}
}
return amount;
}
int main()
{
for (int i=1;i<=10000000;i++) {
if(factors(i)==4 && factors(i+1)==4 && factors(i+2)==4 && factors(i+3)==4)
{
cout << i << " and " << i+1 << " and " << i+2 << " and " << i+3 << endl;
break;
}
}
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
int main()
{
string s,s1;
cin>>s>>s1;
int sz=s.size(), sz1=s1.size();
if(s==s1)cout<<s<<endl;
else cout<<1<<endl;
}
|
#include <iostream>
#include "List.h"
enum Color {
Black, Red, DoubleBlack
};
template<typename TKey, typename TValue>
class Map {
private:
class Node {
public:
TKey key;
TValue value;
Color color;
Node *parent, *left, *right;
Node() = default;
// Default color is Red, node isn't linked
explicit Node(TKey key, TValue val, Node *nil) : key(key), value(val), color(Color::Red),
parent(nullptr), left(nil), right(nil) {};
// Constructor with parent and color specified
Node(TKey key, TValue val, Node *nil, Color color) : key(key), value(val), color(color),
parent(nullptr), left(nil), right(nil) {};
// --------- Auxiliary methods -----------------
Node *get_grandpa() {
auto parent = this->parent;
if (!parent || !parent->parent)
return nullptr;
auto grandpa = parent->parent;
return grandpa;
}
Node *get_uncle() {
auto grandpa = this->get_grandpa();
// If nodes parent is a right child, return left child
if (grandpa->right == this->parent)
return grandpa->left;
else
return grandpa->right;
}
// ---------------------------------------------
};
void clear(Node *node) {
if (node == nullptr || node == nil)
return;
clear(node->left);
clear(node->right);
delete node;
node = nil;
if (node->left != nil)
node->left = nil;
if (node->right != nil)
node->right = nil;
}
Node *bst_find(const TKey &key, bool insertion = false) {
auto node = this->root;
auto prev = node;
while (node && node != this->nil && node->key != key) {
prev = node;
if (key > node->key)
node = node->right;
else
node = node->left;
}
// If node with this key exist, return it (deletion use-case)
if (node != this->nil) {
if (!insertion) {
return node;
} else {
if (node && node->key == key)
throw std::out_of_range("Duplicate key");
else
throw std::out_of_range("Invalid key");
}
} else {
if (insertion)
return prev;
else
throw std::out_of_range("Invalid key");
}
}
Node *bst_successor(Node *node) {
node = node->right;
while (node->left != nil)
node = node->left;
return node;
}
Node *left_rotation(Node *node) {
auto new_node = new Node(node->key, node->value, nil);
if (node->left != nil && node->right->left != nil)
new_node->right = node->right->left;
new_node->left = node->left;
new_node->color = node->color;
node->key = node->right->key;
node->value = node->right->value;
node->left = new_node;
if (new_node->left)
new_node->left->parent = new_node;
if (new_node->right)
new_node->right->parent = new_node;
new_node->parent = node;
if (node->right && node->right->right)
node->right = node->right->right;
else
node->right = nil;
if (node->right)
node->right->parent = node;
return new_node;
}
Node *right_rotation(Node *node) {
auto new_node = new Node(node->key, node->value, nil);
if (node->left != nil && node->left->right != nil)
new_node->left = node->left->right;
new_node->right = node->right;
new_node->color = node->color;
node->key = node->left->key;
node->value = node->left->value;
node->right = new_node;
if (new_node->left)
new_node->left->parent = new_node;
if (new_node->right)
new_node->right->parent = new_node;
new_node->parent = node;
if (node->left && node->left->left)
node->left = node->left->left;
else
node->left = nil;
if (node->left)
node->left->parent = node;
return new_node;
}
void resolve_insert_violations(Node *node) {
while (node->parent->color == Color::Red && node->color == Color::Red) {
auto grandpa = node->get_grandpa();
auto uncle = node->get_uncle();
// If parent is a left child of grandparent
if (grandpa->left == node->parent) {
if (uncle->color == Color::Red) {
node->parent->color = Color::Black;
uncle->color = Color::Black;
grandpa->color = Color::Red;
if (grandpa != root)
node = grandpa;
else
break;
} else if (node == grandpa->left->right) {
// If uncle's color is black or it's null and path is LEFT-RIGHT
node = left_rotation(node->parent);
} else {
grandpa->color = Color::Red;
node = right_rotation(grandpa);
node->parent->color = Color::Black;
if (grandpa != root)
node = grandpa;
else
break;
}
} else {
// If parent is a right child of grandparent
if (uncle->color == Color::Red) {
node->parent->color = Color::Black;
uncle->color = Color::Black;
grandpa->color = Color::Red;
if (grandpa != root)
node = grandpa;
else
break;
} else if (node == grandpa->right->left)
node = right_rotation(node->parent);
else {
grandpa->color = Color::Red;
node = left_rotation(grandpa);
node->parent->color = Color::Black;
if (grandpa != root)
node = grandpa;
else
break;
}
}
}
root->color = Color::Black;
}
void remove_with_fix(Node *node) {
if (node == root) {
delete root;
root = nullptr;
return;
}
// Simple case
if (node->color == Color::Red || node->left->color == Color::Red || node->right->color == Color::Red) {
// Choose left child if it exists, else choose right child
auto child = node->left != nil ? node->left : node->right;
// Remove node
if (node == node->parent->left) {
node->parent->left = child;
if (child != nil)
child->parent = node->parent;
child->color = Color::Black;
delete node;
} else {
node->parent->right = child;
if (child != nil)
child->parent = node->parent;
child->color = Color::Black;
delete node;
}
}
// Cases with black node
else {
Node *sibling = nullptr;
Node *parent = nullptr;
Node *ptr = node;
ptr->color = Color::DoubleBlack;
while (ptr != root && ptr->color == Color::DoubleBlack) {
parent = ptr->parent;
// If double-black node is a left child
if (ptr == parent->left) {
sibling = parent->right;
// If sibling's color is red
if (sibling->color == Color::Red) {
sibling->color = Color::Black;
parent->color = Color::Red;
left_rotation(parent);
}
// If sibling's color is black
else {
if (sibling->left->color == Color::Black && sibling->right->color == Color::Black) {
sibling->color = Color::Red;
if (parent->color == Color::Red)
parent->color = Color::Black;
else
parent->color = Color::DoubleBlack;
ptr = parent;
} else {
if (sibling->right->color == Color::Black) {
sibling->left->color = Color::Black;
sibling->color = Color::Red;
right_rotation(sibling);
sibling = parent->right;
}
sibling->color = parent->color;
parent->color = Color::Black;
sibling->right->color = Color::Black;
left_rotation(parent);
break;
}
}
}
// If double-black node is a right child
else {
sibling = parent->left;
// If sibling's color is red
if (sibling->color == Color::Red) {
sibling->color = Color::Black;
parent->color = Color::Red;
right_rotation(parent);
}
// If sibling's color is black
else {
// and both its children are black, recolor
if (sibling->left->color == Color::Black && sibling->right->color == Color::Black) {
sibling->color = Color::Red;
if (parent->color == Color::Red)
parent->color = Color::Black;
else
parent->color = Color::DoubleBlack;
ptr = parent;
}
// else, when at least one of its children is red, rotate
else {
if (sibling->left->color == Color::Black) {
sibling->right->color = Color::Black;
sibling->color = Color::Red;
left_rotation(sibling);
sibling = parent->left;
}
sibling->color = parent->color;
parent->color = Color::Black;
sibling->left->color = Color::Black;
right_rotation(parent);
break;
}
}
}
}
if (node == node->parent->left)
node->parent->left = nil;
else
node->parent->right = nil;
delete node;
root->color = Color::Black;
}
}
// Map private fields
Node *root;
Node *nil;
public:
Map() : root(nullptr), nil(new Node()) {
nil->left = nil;
nil->right = nil;
};
void insert(const TKey &key, TValue value) {
auto new_node = new Node(key, value, nil);
// If tree is empty
if (root == nullptr) {
root = new_node;
root->color = Color::Black;
} else {
// Find a place for a node violating RB-tree properties
auto parent = this->bst_find(key, true);
if (new_node->key > parent->key)
parent->right = new_node;
else
parent->left = new_node;
new_node->parent = parent;
resolve_insert_violations(new_node);
}
}
void remove(const TKey &key) {
// Find node to remove
auto node = this->bst_find(key);
if (node == nullptr || node == nil)
return;
if (node->left != nil && node->right == nil) {
// Case when node has only left child
node->key = node->left->key;
node->value = node->left->value;
// Select child for removal
node = node->left;
} else if (node->right != nil && node->left == nil) {
// Case when node has only right child
node->key = node->right->key;
node->value = node->right->value;
// Select child for removal
node = node->right;
} else if (node->left != nil && node->right != nil) {
// Case when node has both children
auto successor = this->bst_successor(node);
node->key = successor->key;
node->value = successor->value;
node = successor;
}
remove_with_fix(node);
}
void set(const TKey &key, TValue value) {
auto node = bst_find(key);
node->value = value;
}
TValue find(const TKey &key) {
auto node = bst_find(key);
if (node == nullptr)
throw std::out_of_range("Key doesn't exist");
if (node->key == key)
return node->value;
else {
if (node->left == node) {
if (node->left->key == key)
return node->left->value;
} else {
if (node->right->key == key)
return node->right->value;
}
}
}
TValue operator[](const TKey &key) {
return find(key);
}
void clear() {
clear(root);
root = nullptr;
}
List<TKey> get_keys() {
List<TKey> keys_list;
if (root) {
auto node = root;
List<Node *> stack;
stack.push_front(node);
while (!stack.isEmpty()) {
node = stack.at(0);
stack.pop_front();
keys_list.push_back(node->key);
if (node->right != nil)
stack.push_front(node->right);
if (node->left != nil)
stack.push_front(node->left);
}
}
return keys_list;
}
List<TValue> get_values() {
List<TValue> values_list;
if (root) {
auto node = root;
List<Node *> stack;
stack.push_front(node);
while (!stack.isEmpty()) {
node = stack.at(0);
stack.pop_front();
values_list.push_back(node->value);
if (node->right != nil)
stack.push_front(node->right);
if (node->left != nil)
stack.push_front(node->left);
}
}
return values_list;
}
void print() {
std::cout << '{';
if (root) {
auto node = root;
List<Node *> stack;
stack.push_front(node);
while (!stack.isEmpty()) {
node = stack.at(0);
if (node != root)
std::cout << ", ";
stack.pop_front();
std::cout << node->key << ": " << node->value;
if (node->right != nil)
stack.push_front(node->right);
if (node->left != nil)
stack.push_front(node->left);
}
}
std::cout << '}' << std::endl;
}
};
|
/*
* SPDX-FileCopyrightText: (C) 2017-2022 Matthias Fehring <mf@huessenbergnetz.de>
* SPDX-License-Identifier: BSD-3-Clause
*/
#ifndef CUTELYSTVALIDATORDIGITS_H
#define CUTELYSTVALIDATORDIGITS_H
#include "validatorrule.h"
#include <Cutelyst/cutelyst_global.h>
namespace Cutelyst {
class ValidatorDigitsPrivate;
/*!
* \ingroup plugins-utils-validator-rules
* \class ValidatorDigits validatordigits.h <Cutelyst/Plugins/Utils/validatordigits.h>
* \brief Checks for digits only with optional length check.
*
* The \a field under validation must only contain digits with an optional exact \a length. If length is set to a value lower
* or equal to \c 0, the length check will not be performed. The input digits will not be interpreted as numeric values
* but as a string. So the length is not meant to test for an exact numeric value but for the string length.
*
* \note Unless \link Validator::validate() validation\endlink is started with \link Validator::NoTrimming NoTrimming\endlink,
* whitespaces will be removed from the beginning and the end of the input value before validation.
* If the \a field's value is empty or if the \a field is missing in the input data, the validation will succeed without
* performing the validation itself. Use one of the \link ValidatorRequired required validators \endlink to require the
* field to be present and not empty.
*
* \sa Validator for general usage of validators.
*
* \sa ValidatorDigitsBetween
*/
class CUTELYST_PLUGIN_UTILS_VALIDATOR_EXPORT ValidatorDigits : public ValidatorRule
{
public:
/*!
* \brief Constructs a new digits validator.
* \param field Name of the input field to validate.
* \param length Exact length of the digits, defaults to \c -1. A value lower \c 1 disables the length check. Should be either an int to directly specify the length or the name
* of an input field or \link Context::stash() Stash \endlink key containing the length constraint.
* \param messages Custom error messages if validation fails.
* \param defValKey \link Context::stash() Stash \endlink key containing a default value if input field is empty. This value will \b NOT be validated.
*/
ValidatorDigits(const QString &field, const QVariant &length = -1, const ValidatorMessages &messages = ValidatorMessages(), const QString &defValKey = QString());
/*!
* \brief Deconstructs the digits validator.
*/
~ValidatorDigits() override;
/*!
* \ingroup plugins-utils-validator-rules
* \brief Returns \c true if \a value only contains digits.
*
* Note that this function will return \c true for an empty \a value if the \a length check is disabled.
*
* \param value The value to validate as it is.
* \param length Exact length of the digits, defaults to \c -1. A value lower \c 1 disables the length check.
* \return \c true if the \a value only contains digits
*/
static bool validate(const QString &value, int length = -1);
protected:
/*!
* \brief Performs the validation and returns the result.
*
* If validation succeeded, ValidatorReturnType::value will contain the input parameter value as QString.
*/
ValidatorReturnType validate(Context *c, const ParamsMultiMap ¶ms) const override;
/*!
* \brief Returns a generic error if validation failed.
*
* \a errorData will contain \c 0, if \a length is greater than \c 0 and does not match the field value length, \a errorData will contain \c 1.
*/
QString genericValidationError(Context *c, const QVariant &errorData = QVariant()) const override;
private:
Q_DECLARE_PRIVATE(ValidatorDigits)
Q_DISABLE_COPY(ValidatorDigits)
};
} // namespace Cutelyst
#endif // CUTELYSTVALIDATORDIGITS_H
|
#include "player.h"
#include <cmath>
#include "gameobjects/level/level.h"
inline double dist_sq(double x1, double y1, double x2, double y2) {
return (x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2);
}
//calculates the angle opposite c in a triangle with sides a, b, and c
inline double calculate_angle_SSS(double a, double b, double c){
//Use Law of cosines to get cos(C) and acos to get C
if (c > a + b){
printf("%f greater than %f+%f\n", c, a, b);
}
return acos((a*a + b*b - (c * c))/(2*a*b));
}
Player::Player(double start_x, double start_y, PlayerInfo a_info) : info(a_info), state(start_x, start_y) {
current_time = 0;
AnimationState frames_init[] = {
{
{30, -30},
{20, 0},
},
{
{20, -20},
{30, 30},
},
{
{0, 0},
{90, 0},
},
{
{-20, 20},
{60, 0},
},
{
{-30, 30},
{0, 20},
},
{
{-20, 20},
{30, 30},
},
{
{0, 0},
{0, 90},
},
{
{20, -20},
{0, 60},
},
};
AnimationState kick_frames_init[] = {
{
{-80, 0},
{30, 0},
},
{
{-85, 0},
{2, 0},
},
};
frames = std::vector<AnimationState>(std::begin(frames_init), std::end(frames_init));
kick_frames = std::vector<AnimationState>(std::begin(kick_frames_init), std::end(kick_frames_init));
}
void Player::start_kick() {
state.kick_ticks_left = KICK_ANIMATION_TIME;
double dist_to_forward_back = fmod(current_time - 0.86 + 8, 8);
double dist_to_backward_back = fmod(current_time - 3.5 + 8, 8);
double dist_to_forward_front = fmod(-current_time + 0.86 + 8, 8);
double dist_to_backward_front = fmod(-current_time + 3.5 + 8, 8);
double min_distance = std::min(dist_to_forward_back, std::min(dist_to_forward_front, std::min(dist_to_backward_front, dist_to_backward_back)));
if (dist_to_forward_front == min_distance) {
state.kick_foot = 0;
} else if (dist_to_forward_back == min_distance) {
state.kick_foot = 0;
} else if (dist_to_backward_front == min_distance) {
state.kick_foot = 1;
} else if (dist_to_backward_back == min_distance) {
state.kick_foot = 1;
}
}
AnimationState Player::get_interpolated_frame() const {
AnimationState current_frame = frames[(int) (current_time) % frames.size()];
AnimationState next_frame = frames[(int) (current_time + 1) % frames.size()];
double ratio = current_time - floor(current_time);
AnimationState interpolated = {
{current_frame.hip_angle[0] * (1 - ratio) + next_frame.hip_angle[0] * ratio, current_frame.hip_angle[1] * (1 - ratio) + next_frame.hip_angle[1] * ratio},
{current_frame.knee_angle[0] * (1 - ratio) + next_frame.knee_angle[0] * ratio, current_frame.knee_angle[1] * (1 - ratio) + next_frame.knee_angle[1] * ratio},
};
if (state.kick_ticks_left != 0) {
double index_within_kick = (KICK_ANIMATION_TIME - state.kick_ticks_left)/6.0;
AnimationState current_frame;
AnimationState next_frame;
if ((int)index_within_kick == 0) {
current_frame = interpolated;
if (state.kick_foot != 0) {
current_frame = {
{current_frame.hip_angle[1], current_frame.hip_angle[0]},
{current_frame.knee_angle[1] , current_frame.knee_angle[0]},
};
}
} else {
current_frame = kick_frames[(int) (index_within_kick - 1)];
}
if ((int)index_within_kick == 2) {
next_frame = interpolated;
if (state.kick_foot != 0) {
next_frame = {
{next_frame.hip_angle[1], next_frame.hip_angle[0]},
{next_frame.knee_angle[1] , next_frame.knee_angle[0]},
};
}
} else {
next_frame = kick_frames[(int) (index_within_kick)];
}
double ratio = index_within_kick - floor(index_within_kick);
interpolated.hip_angle[state.kick_foot] =
current_frame.hip_angle[0] * (1 - ratio) + next_frame.hip_angle[0] * ratio;
interpolated.knee_angle[state.kick_foot] =
current_frame.knee_angle[0] * (1 - ratio) + next_frame.knee_angle[0] * ratio;
interpolated.hip_angle[1 - state.kick_foot] =
current_frame.hip_angle[1] * (1 - ratio) + next_frame.hip_angle[1] * ratio;
interpolated.knee_angle[1 - state.kick_foot] =
current_frame.knee_angle[1] * (1 - ratio) + next_frame.knee_angle[1] * ratio;
}
return interpolated;
}
void Player::update(){
if (state.dx == 0 || !state.grounded) {
double dist_to_forward_back = fmod(current_time - 0.86 + 8, 8);
double dist_to_backward_back = fmod(current_time - 3.5 + 8, 8);
double dist_to_forward_front = fmod(-current_time + 0.86 + 8, 8);
double dist_to_backward_front = fmod(-current_time + 3.5 + 8, 8);
double min_distance = std::min(dist_to_forward_back, std::min(dist_to_forward_front, std::min(dist_to_backward_front, dist_to_backward_back)));
if (dist_to_forward_front == min_distance) {
current_time = std::min(fmod(current_time + 0.5 + 8, 8), 0.86);
} else if (dist_to_forward_back == min_distance) {
current_time = std::max(fmod(current_time - 0.5 + 8, 8), 0.86);
} else if (dist_to_backward_front == min_distance) {
current_time = std::min(fmod(current_time + 0.5 + 8, 8), 3.5);
} else if (dist_to_backward_back == min_distance) {
current_time = std::max(fmod(current_time - 0.5 + 8, 8), 3.5);
}
} else {
current_time = fmod((current_time + state.dx * (is_facing_right() ? 1 : -1) * 0.10) + 8, 8);
last_time_diff = state.dx * (is_facing_right() ? 1 : -1) * 0.10;
}
if (state.invincibility_ticks_left > 0) {
state.invincibility_ticks_left--;
}
}
bool Player::is_facing_right() const {
return fabs(state.gun_angle) < M_PI / 2;
}
void Player::draw_laser(RenderList& list, const Level& level) const {
double dx = cos(state.gun_angle);
double dy = sin(state.gun_angle);
Point pos = get_barrel_position();
double x = pos.x;
double y = pos.y;
double time = level.get_first_intersection(x, y, dx, dy);
list.add_line("laser", x, y, x + dx * time, y + dy * time);
}
Point Player::get_barrel_position() const {
double scaled_gun_angle = is_facing_right() ? state.gun_angle : (M_PI - state.gun_angle);
Point pos = state.gun->get_barrel_position(scaled_gun_angle);
if (!is_facing_right()) {
pos.x *= -1;
}
return pos.offset(state.pos.location());
}
std::vector<std::unique_ptr<Bullet>> Player::spawn_bullets() const {
double scaled_gun_angle = is_facing_right() ? state.gun_angle : (M_PI - state.gun_angle);
auto bullets = state.gun->spawn_bullets(scaled_gun_angle);
for (auto& bullet : bullets) {
if (!is_facing_right()) {
bullet->pos.x *= -1;
}
bullet->pos.x += state.pos.x;
bullet->pos.y += state.pos.y;
bullet->angle += state.gun_angle;
}
return bullets;
}
//RENDERING CONSTANTS
//ONLY USED IN RENDERING METHODS
const double arm_y_offset = -55 * ASSET_SCALE;
const double upper_arm_length = 32*ASSET_SCALE;
const double upper_arm_radius = 8*ASSET_SCALE;
const double lower_arm_length = 32*ASSET_SCALE;
const double lower_arm_radius = 5*ASSET_SCALE;
const double upper_leg_length = 40*ASSET_SCALE;
const double upper_leg_radius = 10*ASSET_SCALE;
const double lower_leg_length = 36*ASSET_SCALE;
const double lower_leg_radius = 8*ASSET_SCALE;
const double head_x_offset = 7 * ASSET_SCALE;
const double head_y_offset = -97 * ASSET_SCALE;
const double shoulder_x_offset = -2 * ASSET_SCALE;
const double shoulder_y_offset = -55 * ASSET_SCALE;
const double shoulder_angle_offset = 0;//M_PI / 2 + - 0.2;
const double shoulder_angle_coef = 1.0;
const double torso_y_offset = -40 * ASSET_SCALE;
void Player::render(RenderList& list) const {
if (state.is_dead && state.ticks_until_spawn < DEATH_INVISIBLE_TIME) {
return;
}
list.push();
AnimationState interpolated = get_interpolated_frame();
ArmState arms;
double scaled_gun_angle = is_facing_right() ? state.gun_angle : (M_PI - state.gun_angle);
double posX = state.pos.x;
double posY = state.pos.y;
double grip1_x = state.gun->grip1_x(scaled_gun_angle);
double grip1_y = state.gun->grip1_y(scaled_gun_angle);
double dist_to_grip1 = sqrt(dist_sq(grip1_x, grip1_y, 0, arm_y_offset));
//Law of cosines
arms.extra_angle[0] = -calculate_angle_SSS(upper_arm_length, lower_arm_length + lower_arm_radius, dist_to_grip1);
arms.needed_angle[0] = atan2(grip1_y - arm_y_offset, grip1_x) + calculate_angle_SSS(dist_to_grip1, upper_arm_length, lower_arm_length + lower_arm_radius);
double grip2_x = state.gun->grip2_x(scaled_gun_angle);
double grip2_y = state.gun->grip2_y(scaled_gun_angle);
double dist_to_grip2 = sqrt(dist_sq(grip2_x, grip2_y, 0, arm_y_offset));
arms.extra_angle[1] = -calculate_angle_SSS(upper_arm_length, lower_arm_length + lower_arm_radius, dist_to_grip2);
arms.needed_angle[1] = atan2(grip2_y - arm_y_offset, grip2_x) + calculate_angle_SSS(dist_to_grip2, upper_arm_length, lower_arm_length + lower_arm_radius);
const char* head = nullptr;
const char* shoulder = nullptr;
switch (info.color) {
case PlayerColor::RED:
head = "red-head";
shoulder = "red-shoulder";
break;
case PlayerColor::YELLOW:
head = "yellow-head";
shoulder = "yellow-shoulder";
break;
case PlayerColor::BLUE:
head = "blue-head";
shoulder = "blue-shoulder";
break;
case PlayerColor::GREEN:
head = "green-head";
shoulder = "green-shoulder";
break;
}
list.translate(posX, posY);
list.set_z(10);
draw_health(list);
if (state.is_dead) {
double angle = M_PI / 2.0 * (1.0 - ((state.ticks_until_spawn - DEATH_INVISIBLE_TIME) / (float)DEATH_ANIMATION_TIME));
list.translate(0, 30);
list.rotate(angle);
list.translate(0, -30);
}
if (!is_facing_right()) {
list.scale(-1, 1);
}
if (state.invincibility_ticks_left > 0) {
Rectangle shield_rect = list.get_image_dimensions("shield");
list.add_rect("shield", shield_rect.offset(0, -2));
}
//BACK LEG
draw_leg(0, list, interpolated);
//BACK ARM
draw_arm(1, list, arms);
if (!state.gun->in_front()) {
state.gun->render_aim(list, scaled_gun_angle);
}
//FRONT LEG
draw_leg(1, list, interpolated);
//TORSO
list.add_scaled_image("torso-main", 0, torso_y_offset, ASSET_SCALE, true);
//FACE
list.add_scaled_image(head, head_x_offset, head_y_offset, ASSET_SCALE, true);
//JETPACK
list.add_image("black", -18, -20, 8, 24);
list.add_image(get_color_name(info.color), -16, -2 + -16 * state.fuel_left, 4, 20 * state.fuel_left);
if (state.boosting) {
list.add_image("fire", -17.5, 4);
}
//GUN
if (state.gun->in_front()) {
state.gun->render_aim(list, scaled_gun_angle);
}
//FRONT ARM
draw_arm(0, list, arms);
// //SHOULDER
list.translate(shoulder_x_offset, shoulder_y_offset);
list.rotate(shoulder_angle_coef * arms.needed_angle[1] + shoulder_angle_offset);
list.add_scaled_image(shoulder, 0, 0, ASSET_SCALE, true);
//FIX THAT STUFF
list.pop();
}
void Player::draw_health(RenderList &list) const {
list.add_image("black", -20, -62, 40, 8);
list.add_image("black", -18, -60, 36, 4);
double fire_damage_to_inflict = FIRE_DMG_PER_TICK * state.ticks_fire_left;
double eventual_health = std::max(0.0, state.health - fire_damage_to_inflict);
double health = std::max(0.0, state.health);
list.add_image("orange", -18, -60, 36 * health / MAX_HEALTH, 4);
list.add_image(get_color_name(info.color), -18, -60, 36 * eventual_health / MAX_HEALTH, 4);
}
void Player::draw_leg(int leg, RenderList &list, AnimationState interpolated) const {
list.push();
//OUTLINE
list.rotate(interpolated.hip_angle[leg] * M_PI/180);
list.translate(0, upper_leg_length);
list.rotate(interpolated.knee_angle[leg] * M_PI/180);
list.add_scaled_image("boot", 2.5, lower_leg_length + 5, ASSET_SCALE, true);
list.add_scaled_image("leg-lower-outline", 0, (lower_leg_length - lower_leg_radius)/2, ASSET_SCALE, true);
list.rotate(-interpolated.knee_angle[leg] * M_PI/180);
list.translate(0, -upper_leg_length);
list.add_scaled_image("leg-upper-outline", 0, (upper_leg_length - upper_leg_radius)/2, ASSET_SCALE, true);
//FILL
list.translate(0, upper_leg_length);
list.rotate(interpolated.knee_angle[leg] * M_PI/180);
list.add_scaled_image("leg-lower-fill", 0, (lower_leg_length - lower_leg_radius)/2, ASSET_SCALE, true);
list.rotate(-interpolated.knee_angle[leg] * M_PI/180);
list.translate(0, -upper_leg_length);
list.add_scaled_image("leg-upper-fill", 0, (upper_leg_length - upper_leg_radius)/2, ASSET_SCALE, true);
list.pop();
}
void Player::draw_arm(int arm, RenderList& list, ArmState arms) const{
double shoulder_angle = arms.needed_angle[arm];
{
list.push();
list.translate(0, arm_y_offset);
list.rotate(-M_PI / 2);
list.rotate(shoulder_angle);
list.add_scaled_image("arm-upper-outline", 0, (upper_arm_length - upper_arm_radius)/2, ASSET_SCALE, true);
list.translate(0, upper_arm_length);
list.rotate(M_PI - arms.extra_angle[arm]);
list.add_scaled_image("hand", 0, lower_arm_length + 2 * lower_arm_radius, ASSET_SCALE, true);
list.add_scaled_image("arm-lower-outline", 0, (lower_arm_length + lower_arm_radius)/2, ASSET_SCALE, true);
list.pop();
}
{
list.push();
list.translate(0, arm_y_offset);
list.rotate(-M_PI / 2);
list.rotate(shoulder_angle);
list.add_scaled_image("arm-upper-fill", 0, (upper_arm_length - upper_arm_radius)/2, ASSET_SCALE, true);
list.add_image("black", -2.5, -2.5, 5, 5);
list.translate(0, upper_arm_length);
list.rotate(M_PI - arms.extra_angle[arm]);
list.add_scaled_image("arm-lower-fill", 0, (lower_arm_length + lower_arm_radius)/2, ASSET_SCALE, true);
list.pop();
}
}
void Player::render_crown(RenderList& list) const {
if (state.is_dead && state.ticks_until_spawn < DEATH_INVISIBLE_TIME) {
return;
}
list.push();
double posX = state.pos.x;
double posY = state.pos.y;
list.translate(posX, posY);
list.set_z(10);
list.add_scaled_image("crown", 0, -68, ASSET_SCALE, true);
list.pop();
}
void Player::set_gun(std::unique_ptr<Gun> gun) {
state.gun = std::move(gun);
state.ammo_left = state.gun->initial_ammo();
state.ticks_till_next_bullet = state.gun->ticks_between_shots();
}
|
// C++ for the Windows Runtime vv1.0.170303.6
// Copyright (c) 2017 Microsoft Corporation. All rights reserved.
#pragma once
#include "Windows.UI.Core.Preview.2.h"
WINRT_EXPORT namespace winrt {
namespace Windows::UI::Core::Preview {
struct WINRT_EBO SystemNavigationCloseRequestedPreviewEventArgs :
Windows::UI::Core::Preview::ISystemNavigationCloseRequestedPreviewEventArgs
{
SystemNavigationCloseRequestedPreviewEventArgs(std::nullptr_t) noexcept {}
};
struct WINRT_EBO SystemNavigationManagerPreview :
Windows::UI::Core::Preview::ISystemNavigationManagerPreview
{
SystemNavigationManagerPreview(std::nullptr_t) noexcept {}
static Windows::UI::Core::Preview::SystemNavigationManagerPreview GetForCurrentView();
};
}
}
|
/**
* @file CellFunctor.h
*
* @date 22 Jan 2018
* @author tchipevn
*/
#pragma once
#include "autopas/cells/SortedCellView.h"
#include "autopas/iterators/SingleCellIterator.h"
#include "autopas/options/DataLayoutOption.h"
#include "autopas/utils/ExceptionHandler.h"
namespace autopas {
namespace internal {
/**
* A cell functor. This functor is build from the normal Functor of the template
* type ParticleFunctor. It is an internal object to handle interactions between
* two cells of particles.
* @todo: currently always used newton3!
* @tparam Particle
* @tparam ParticleCell
* @tparam ParticleFunctor the functor which
* @tparam DataLayout the DataLayout to be used
* @tparam useNewton3
* @tparam bidirectional if no newton3 is used processCellPair(cell1, cell2) should also handle processCellPair(cell2,
* cell1)
*/
template <class Particle, class ParticleCell, class ParticleFunctor, DataLayoutOption DataLayout,
bool useNewton3 = true, bool bidirectional = true>
class CellFunctor {
public:
/**
* The constructor of CellFunctor.
* @param f The particlefunctor which should be used for the interaction.
* @param cutoff Cutoff radius. This parameter is only relevant for optimization (sorting). If no parameter is given,
* an infinite cutoff radius is used which results in no optimization by sorting.
*/
explicit CellFunctor(ParticleFunctor *f, const double cutoff = std::numeric_limits<double>::max())
: _functor(f), _cutoff(cutoff) {}
/**
* Process the interactions inside one cell.
* @param cell all pairwise interactions of particles inside this cell are
* calculated
*/
void processCell(ParticleCell &cell);
/**
* Process the interactions between the particles of cell1 with particles of cell2.
* @param cell1
* @param cell2
* @param r Normalized vector connecting centers of cell1 and cell2. If no parameter is given, a default value is used
* which is always applicable.
*/
void processCellPair(ParticleCell &cell1, ParticleCell &cell2, const std::array<double, 3> &r = {1., 0., 0.});
private:
/**
* Applies the functor to all particle pairs exploiting newtons third law of
* motion.
* @param cell
*/
void processCellAoSN3(ParticleCell &cell);
/**
* Applies the functor to all particle pairs without exploiting newtons third
* law of motion.
* @param cell
*/
void processCellAoSNoN3(ParticleCell &cell);
/**
* Applies the functor to all particle pairs between cell1 and cell2
* exploiting newtons third law of motion.
* @param cell1
* @param cell2
* @param r normalized vector connecting centers of cell1 and cell2
*/
void processCellPairAoSN3(ParticleCell &cell1, ParticleCell &cell2, const std::array<double, 3> &r);
/**
* Applies the functor to all particle pairs between cell1 and cell2
* without exploiting newtons third law of motion.
* @param cell1
* @param cell2
* @param r normalized vector connecting centers of cell1 and cell2
*/
void processCellPairAoSNoN3(ParticleCell &cell1, ParticleCell &cell2, const std::array<double, 3> &r);
void processCellPairSoAN3(ParticleCell &cell1, ParticleCell &cell2);
void processCellPairSoANoN3(ParticleCell &cell1, ParticleCell &cell2);
void processCellPairCudaNoN3(ParticleCell &cell1, ParticleCell &cell2);
void processCellPairCudaN3(ParticleCell &cell1, ParticleCell &cell2);
void processCellSoAN3(ParticleCell &cell);
void processCellSoANoN3(ParticleCell &cell);
void processCellCudaNoN3(ParticleCell &cell);
void processCellCudaN3(ParticleCell &cell);
ParticleFunctor *_functor;
const double _cutoff;
/**
* Min. number of particles to start sorting.
*/
constexpr static unsigned long _startSorting = 8;
};
template <class Particle, class ParticleCell, class ParticleFunctor, DataLayoutOption DataLayout, bool useNewton3,
bool bidirectional>
void CellFunctor<Particle, ParticleCell, ParticleFunctor, DataLayout, useNewton3, bidirectional>::processCell(
ParticleCell &cell) {
if ((DataLayout == DataLayoutOption::soa && cell._particleSoABuffer.getNumParticles() == 0) ||
(DataLayout == DataLayoutOption::aos && cell.numParticles() == 0)) {
return;
}
switch (DataLayout) {
case DataLayoutOption::aos:
if (useNewton3) {
processCellAoSN3(cell);
} else {
processCellAoSNoN3(cell);
}
break;
case DataLayoutOption::soa:
if (useNewton3) {
processCellSoAN3(cell);
} else {
processCellSoANoN3(cell);
}
break;
case DataLayoutOption::cuda:
if (useNewton3) {
processCellCudaN3(cell);
} else {
processCellCudaNoN3(cell);
}
break;
}
}
template <class Particle, class ParticleCell, class ParticleFunctor, DataLayoutOption DataLayout, bool useNewton3,
bool bidirectional>
void CellFunctor<Particle, ParticleCell, ParticleFunctor, DataLayout, useNewton3, bidirectional>::processCellPair(
ParticleCell &cell1, ParticleCell &cell2, const std::array<double, 3> &r) {
if ((DataLayout == DataLayoutOption::soa &&
(cell1._particleSoABuffer.getNumParticles() == 0 || cell2._particleSoABuffer.getNumParticles() == 0)) ||
(DataLayout == DataLayoutOption::aos && (cell1.numParticles() == 0 || cell2.numParticles() == 0))) {
return;
}
switch (DataLayout) {
case DataLayoutOption::aos:
if (useNewton3) {
processCellPairAoSN3(cell1, cell2, r);
} else {
processCellPairAoSNoN3(cell1, cell2, r);
}
break;
case DataLayoutOption::soa:
if (useNewton3) {
processCellPairSoAN3(cell1, cell2);
} else {
processCellPairSoANoN3(cell1, cell2);
}
break;
case DataLayoutOption::cuda:
if (useNewton3) {
processCellPairCudaN3(cell1, cell2);
} else {
processCellPairCudaNoN3(cell1, cell2);
}
break;
}
}
template <class Particle, class ParticleCell, class ParticleFunctor, DataLayoutOption DataLayout, bool useNewton3,
bool bidirectional>
void CellFunctor<Particle, ParticleCell, ParticleFunctor, DataLayout, useNewton3, bidirectional>::processCellAoSN3(
ParticleCell &cell) {
if (cell.numParticles() > _startSorting) {
SortedCellView<Particle, ParticleCell> cellSorted(cell, ArrayMath::normalize(std::array<double, 3>{1.0, 1.0, 1.0}));
auto outer = cellSorted._particles.begin();
for (; outer != cellSorted._particles.end(); ++outer) {
Particle &p1 = *outer->second;
auto inner = outer;
++inner;
for (; inner != cellSorted._particles.end(); ++inner) {
if (std::abs(outer->first - inner->first) > _cutoff) {
break;
}
Particle &p2 = *inner->second;
_functor->AoSFunctor(p1, p2, true);
}
}
} else {
auto outer = getStaticCellIter(cell);
for (; outer.isValid(); ++outer) {
Particle &p1 = *outer;
auto inner = outer;
++inner;
for (; inner.isValid(); ++inner) {
Particle &p2 = *inner;
_functor->AoSFunctor(p1, p2, true);
}
}
}
}
template <class Particle, class ParticleCell, class ParticleFunctor, DataLayoutOption DataLayout, bool useNewton3,
bool bidirectional>
void CellFunctor<Particle, ParticleCell, ParticleFunctor, DataLayout, useNewton3, bidirectional>::processCellAoSNoN3(
ParticleCell &cell) {
if (cell.numParticles() > _startSorting) {
SortedCellView<Particle, ParticleCell> cellSorted(cell, ArrayMath::normalize(std::array<double, 3>{1.0, 1.0, 1.0}));
auto outer = cellSorted._particles.begin();
auto innerStart = outer;
for (; outer != cellSorted._particles.end(); ++outer) {
Particle &p1 = *outer->second;
// loop over everything until outer
auto inner = innerStart;
for (; inner != outer; ++inner) {
Particle &p2 = *inner->second;
_functor->AoSFunctor(p1, p2, false);
}
// skip over the outer one
++inner;
// loop over everything after outer
for (; inner != cellSorted._particles.end(); ++inner) {
if (std::abs(outer->first - inner->first) > _cutoff) {
break;
}
Particle &p2 = *inner->second;
_functor->AoSFunctor(p1, p2, false);
}
}
} else {
auto outer = getStaticCellIter(cell);
auto innerStart = outer;
for (; outer.isValid(); ++outer) {
Particle &p1 = *outer;
// loop over everything until outer
auto inner = innerStart;
for (; inner != outer; ++inner) {
Particle &p2 = *inner;
_functor->AoSFunctor(p1, p2, false);
}
// skip over the outer one
++inner;
// loop over everything after outer
for (; inner.isValid(); ++inner) {
Particle &p2 = *inner;
_functor->AoSFunctor(p1, p2, false);
}
}
}
}
template <class Particle, class ParticleCell, class ParticleFunctor, DataLayoutOption DataLayout, bool useNewton3,
bool bidirectional>
void CellFunctor<Particle, ParticleCell, ParticleFunctor, DataLayout, useNewton3, bidirectional>::processCellPairAoSN3(
ParticleCell &cell1, ParticleCell &cell2, const std::array<double, 3> &r) {
if (cell1.numParticles() + cell2.numParticles() > _startSorting) {
SortedCellView<Particle, ParticleCell> baseSorted(cell1, r);
SortedCellView<Particle, ParticleCell> outerSorted(cell2, r);
for (auto &outer : baseSorted._particles) {
Particle &p1 = *outer.second;
for (auto &inner : outerSorted._particles) {
if (std::abs(outer.first - inner.first) > _cutoff) {
break;
}
Particle &p2 = *inner.second;
_functor->AoSFunctor(p1, p2, true);
}
}
} else {
auto outer = getStaticCellIter(cell1);
auto innerStart = getStaticCellIter(cell2);
for (; outer.isValid(); ++outer) {
Particle &p1 = *outer;
for (auto inner = innerStart; inner.isValid(); ++inner) {
Particle &p2 = *inner;
_functor->AoSFunctor(p1, p2, true);
}
}
}
}
template <class Particle, class ParticleCell, class ParticleFunctor, DataLayoutOption DataLayout, bool useNewton3,
bool bidirectional>
void CellFunctor<Particle, ParticleCell, ParticleFunctor, DataLayout, useNewton3,
bidirectional>::processCellPairAoSNoN3(ParticleCell &cell1, ParticleCell &cell2,
const std::array<double, 3> &r) {
if (cell1.numParticles() + cell2.numParticles() > _startSorting) {
SortedCellView<Particle, ParticleCell> baseSorted(cell1, r);
SortedCellView<Particle, ParticleCell> outerSorted(cell2, r);
for (auto &outer : baseSorted._particles) {
Particle &p1 = *outer.second;
for (auto &inner : outerSorted._particles) {
if (std::abs(outer.first - inner.first) > _cutoff) {
break;
}
Particle &p2 = *inner.second;
_functor->AoSFunctor(p1, p2, false);
if (bidirectional) _functor->AoSFunctor(p2, p1, false);
}
}
} else {
auto innerStart = getStaticCellIter(cell2);
for (auto outer = cell1.begin(); outer.isValid(); ++outer) {
Particle &p1 = *outer;
for (auto inner = innerStart; inner.isValid(); ++inner) {
Particle &p2 = *inner;
_functor->AoSFunctor(p1, p2, false);
if (bidirectional) _functor->AoSFunctor(p2, p1, false);
}
}
}
}
template <class Particle, class ParticleCell, class ParticleFunctor, DataLayoutOption DataLayout, bool useNewton3,
bool bidirectional>
void CellFunctor<Particle, ParticleCell, ParticleFunctor, DataLayout, useNewton3, bidirectional>::processCellPairSoAN3(
ParticleCell &cell1, ParticleCell &cell2) {
_functor->SoAFunctor(cell1._particleSoABuffer, cell2._particleSoABuffer, true);
}
template <class Particle, class ParticleCell, class ParticleFunctor, DataLayoutOption DataLayout, bool useNewton3,
bool bidirectional>
void CellFunctor<Particle, ParticleCell, ParticleFunctor, DataLayout, useNewton3,
bidirectional>::processCellPairSoANoN3(ParticleCell &cell1, ParticleCell &cell2) {
_functor->SoAFunctor(cell1._particleSoABuffer, cell2._particleSoABuffer, false);
if (bidirectional) _functor->SoAFunctor(cell2._particleSoABuffer, cell1._particleSoABuffer, false);
}
template <class Particle, class ParticleCell, class ParticleFunctor, DataLayoutOption DataLayout, bool useNewton3,
bool bidirectional>
void CellFunctor<Particle, ParticleCell, ParticleFunctor, DataLayout, useNewton3, bidirectional>::processCellSoAN3(
ParticleCell &cell) {
_functor->SoAFunctor(cell._particleSoABuffer, true);
}
template <class Particle, class ParticleCell, class ParticleFunctor, DataLayoutOption DataLayout, bool useNewton3,
bool bidirectional>
void CellFunctor<Particle, ParticleCell, ParticleFunctor, DataLayout, useNewton3, bidirectional>::processCellSoANoN3(
ParticleCell &cell) {
_functor->SoAFunctor(cell._particleSoABuffer, false); // the functor has to enable this...
}
template <class Particle, class ParticleCell, class ParticleFunctor, DataLayoutOption DataLayout, bool useNewton3,
bool bidirectional>
void CellFunctor<Particle, ParticleCell, ParticleFunctor, DataLayout, useNewton3,
bidirectional>::processCellPairCudaNoN3(ParticleCell &cell1, ParticleCell &cell2) {
_functor->CudaFunctor(cell1._particleSoABufferDevice, cell2._particleSoABufferDevice, false);
if (bidirectional) _functor->CudaFunctor(cell2._particleSoABufferDevice, cell1._particleSoABufferDevice, false);
}
template <class Particle, class ParticleCell, class ParticleFunctor, DataLayoutOption DataLayout, bool useNewton3,
bool bidirectional>
void CellFunctor<Particle, ParticleCell, ParticleFunctor, DataLayout, useNewton3, bidirectional>::processCellCudaNoN3(
ParticleCell &cell) {
_functor->CudaFunctor(cell._particleSoABufferDevice, false);
}
template <class Particle, class ParticleCell, class ParticleFunctor, DataLayoutOption DataLayout, bool useNewton3,
bool bidirectional>
void CellFunctor<Particle, ParticleCell, ParticleFunctor, DataLayout, useNewton3, bidirectional>::processCellPairCudaN3(
ParticleCell &cell1, ParticleCell &cell2) {
_functor->CudaFunctor(cell1._particleSoABufferDevice, cell2._particleSoABufferDevice, true);
}
template <class Particle, class ParticleCell, class ParticleFunctor, DataLayoutOption DataLayout, bool useNewton3,
bool bidirectional>
void CellFunctor<Particle, ParticleCell, ParticleFunctor, DataLayout, useNewton3, bidirectional>::processCellCudaN3(
ParticleCell &cell) {
_functor->CudaFunctor(cell._particleSoABufferDevice, true);
}
} // namespace internal
} // namespace autopas
|
#include <bits/stdc++.h>
#include <cassert>
#define rep(i, N) for (int i = 0; i < (N); ++i)
#define rep2(i, a, b) for (ll i = a; i <= b; ++i)
#define rep3(i, a, b) for (ll i = a; i >= b; --i)
#define pb push_back
#define eb emplace_back
#define fi first
#define se second
#define all(c) begin(c), end(c)
#define ok() puts(ok ? "Yes" : "No");
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> bool chmin(T &a, const T &b) {
if (a > b) {
a = b;
return true;
}
return false;
}
using namespace std;
using ll = long long;
using vi = vector<int>;
using vll = vector<ll>;
using ii = pair<int, int>;
using vvi = vector<vi>;
using vii = vector<ii>;
using gt = greater<int>;
using minq = priority_queue<int, vector<int>, gt>;
using P = pair<ll, ll>;
const ll LINF = 1e18L + 1;
const int INF = 1e9 + 1;
// clang++ -std=c++11 -stdlib=libc++
int main() {
int n;
cin >> n;
vi a(n);
rep(i, n) cin >> a[i];
map<int, int> mp1;
map<int, int> mp2;
rep(i, n) {
if (i & 1) {
mp2[a[i]]++;
} else
mp1[a[i]]++;
}
int mx11 = 0;
int mx12 = 0;
int mxNum1 = -1;
int mx21 = 0;
int mx22 = 0;
int mxNum2 = -1;
for (auto num : mp1) {
if (mx11 <= num.se) {
mxNum1 = num.fi;
mx12 = mx11;
mx11 = num.se;
}
}
for (auto num : mp2) {
if (mx21 <= num.se) {
mxNum2 = num.fi;
mx22 = mx21;
mx21 = num.se;
}
}
int ans = n;
if (mxNum1 == mxNum2) {
chmin(ans, n - mx11 - mx22);
chmin(ans, n - mx12 - mx21);
} else {
ans -= mx11 + mx21;
}
cout << mxNum1 << " " << mxNum2 << endl;
cout << mx11 << " " << mx12 << endl;
cout << mx21 << " " << mx22 << endl;
cout << ans << endl;
return 0;
}
|
#include <fstream>
#include <string>
class VisPromelaAST
{
public:
VisPromelaAST(SgProject *proj);
void generate(std::string filename);
protected:
SgProject * proj;
};
|
/*
* UAE - The Un*x Amiga Emulator
*
* Pro-Wizard glue code
*
* Copyright 2004 Toni Wilen
*/
#include "sysconfig.h"
#include "sysdeps.h"
#ifdef PROWIZARD
#include "options.h"
#include "uae/io.h"
#include "memory.h"
#include "uae/seh.h"
#include "moduleripper.h"
#include "gui.h"
#include "uae.h"
static int got, canceled;
static void mc (uae_u8 *d, uaecptr s, int size)
{
int i;
for (i = 0; i < size; i++)
d[i] = get_byte (s++);
}
#ifdef _WIN32
static LONG WINAPI ExceptionFilter (struct _EXCEPTION_POINTERS * pExceptionPointers, DWORD ec)
{
return EXCEPTION_EXECUTE_HANDLER;
}
#endif
void moduleripper (void)
{
int size;
uae_u8 *buf, *p;
size = currprefs.chipmem.size;
for (int i = 0; i < MAX_RAM_BOARDS; i++) {
size += currprefs.fastmem[i].size;
size += currprefs.z3fastmem[i].size;
}
size += currprefs.bogomem.size;
size += currprefs.mbresmem_low.size;
size += currprefs.mbresmem_high.size;
buf = p = xmalloc (uae_u8, size);
if (!buf)
return;
memcpy (p, chipmem_bank.baseaddr, currprefs.chipmem.size);
p += currprefs.chipmem.size;
for (int i = 0; i < MAX_RAM_BOARDS; i++) {
mc (p, fastmem_bank[i].start, currprefs.fastmem[i].size);
p += currprefs.fastmem[i].size;
}
mc (p, bogomem_bank.start, currprefs.bogomem.size);
p += currprefs.bogomem.size;
mc (p, a3000lmem_bank.start, currprefs.mbresmem_low.size);
p += currprefs.mbresmem_low.size;
mc (p, a3000hmem_bank.start, currprefs.mbresmem_high.size);
p += currprefs.mbresmem_high.size;
for (int i = 0; i < MAX_RAM_BOARDS; i++) {
mc (p, z3fastmem_bank[i].start, currprefs.z3fastmem[i].size);
p += currprefs.z3fastmem[i].size;
}
got = 0;
canceled = 0;
#ifdef _WIN32
__try {
#endif
prowizard_search (buf, size);
#ifdef _WIN32
} __except(ExceptionFilter (GetExceptionInformation (), GetExceptionCode ())) {
write_log (_T("prowizard scan crashed\n"));
}
#endif
if (!got)
notify_user (NUMSG_MODRIP_NOTFOUND);
else if (!canceled)
notify_user (NUMSG_MODRIP_FINISHED);
xfree (buf);
}
static void namesplit(TCHAR *s)
{
int l;
l = uaetcslen(s) - 1;
while (l >= 0) {
if (s[l] == '.')
s[l] = 0;
if (s[l] == '\\' || s[l] == '/' || s[l] == ':' || s[l] == '?') {
l++;
break;
}
l--;
}
if (l > 0)
memmove(s, s + l, (uaetcslen(s + l) + 1) * sizeof (TCHAR));
}
static void moduleripper_filename(const char *aname, TCHAR *out, bool fullpath)
{
TCHAR tmp[MAX_DPATH];
TCHAR img[MAX_DPATH];
TCHAR *name;
fetch_ripperpath(tmp, sizeof tmp / sizeof(TCHAR));
img[0] = 0;
if (currprefs.floppyslots[0].dfxtype >= 0)
_tcscpy(img, currprefs.floppyslots[0].df);
else if (currprefs.cdslots[0].inuse)
_tcscpy(img, currprefs.cdslots[0].name);
if (img[0]) {
namesplit(img);
_tcscat(img, _T("_"));
}
name = au(aname);
if (!fullpath)
tmp[0] = 0;
_stprintf(out, _T("%s%s%s"), tmp, img, name);
xfree(name);
}
extern "C"
{
FILE *moduleripper_fopen (const char *aname, const char *amode)
{
TCHAR outname[MAX_DPATH];
TCHAR *mode;
FILE *f;
moduleripper_filename(aname, outname, true);
mode = au (amode);
f = uae_tfopen (outname, mode);
xfree (mode);
return f;
}
FILE *moduleripper2_fopen (const char *name, const char *mode, const char *aid, int addr, int size)
{
TCHAR msg[MAX_DPATH], msg2[MAX_DPATH];
TCHAR outname[MAX_DPATH];
TCHAR *id;
int ret;
if (canceled)
return NULL;
got++;
translate_message (NUMSG_MODRIP_SAVE, msg);
moduleripper_filename(name, outname, false);
id = au (aid);
_stprintf (msg2, msg, id, addr, size, outname);
ret = gui_message_multibutton (2, msg2);
xfree (id);
if (ret < 0)
canceled = 1;
if (ret < 0 || ret != 1)
return NULL;
return moduleripper_fopen (name, mode);
}
void pw_write_log (const char *format,...)
{
}
}
#else
FILE *moduleripper_fopen (const char *name, const char *mode)
{
return NULL;
}
FILE *moduleripper2_fopen (const char *name, const char *mode, const char *id)
{
return NULL;
}
#endif
|
#include <stdio.h>
#include <stdlib.h>
#include <GL/glut.h>
#include <math.h>
#define janela_altura 600
#define janela_largura 800
#define PI 3.14159
float transX[] = { 0, 0 };
float l[] = { -150, 150 };
void display(void);
void tela(GLsizei w, GLsizei h);
void MouseClick(int button, int state, int x, int y);
int main(int argc, char** argv) {
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
glutInitWindowSize(janela_largura, janela_altura);
glutInitWindowPosition(100, 100);
glutCreateWindow("joguinho1");
glutReshapeFunc(tela);
glutDisplayFunc(display);
glutMouseFunc(MouseClick);
glutMainLoop();
return(0);
}
void MouseClick(int button, int state, int x, int y){
int pos = 0;
if (button == GLUT_LEFT_BUTTON) {
if (x > 400) {
l[1] -= 5;
}
else {
l[0] += 5;
}
}
pos = l[1] - l[0];
if (pos < 0) {
pos *= -1;
}
if (pos <= 100) {
l[0] = -400;
l[1] = 400;
}
glutPostRedisplay();
}
void bola() {
GLfloat circ_pnt = 100;
GLfloat ang, raioX = 50.0f, raioY = 50.0f;
glBegin(GL_POLYGON);
for (int i = 0; i < circ_pnt; i++) {
ang = (2 * PI * i) / circ_pnt;
glVertex2f(cos(ang) * raioX, sin(ang) * raioY);
}
glEnd();
}
void linha() {
glBegin(GL_LINES);
glVertex2f(l[0], 0);
glVertex2f(l[1], 0);
glEnd();
}
void desenhar() {
glPushMatrix();
glTranslatef(l[0], 0, 0);
glColor3f(0, 0, 0);
bola();
glPopMatrix();
glPushMatrix();
glTranslatef(l[1], 0, 0);
glColor3f(1, 1, 1);
bola();
glPopMatrix();
glLineWidth(3.0f);
glColor3f(1, 0, 0);
linha();
}
void display() {
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glClearColor(0.04, 0.325, 0.75, 1);
glClear(GL_COLOR_BUFFER_BIT);
glTranslatef(janela_largura / 2, janela_altura / 2, 0.0f);
glViewport(0, 0, janela_largura, janela_altura);
desenhar();
glFlush();
}
void tela(GLsizei w, GLsizei h) {
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluOrtho2D(0, janela_largura, 0, janela_altura);
glMatrixMode(GL_MODELVIEW);
}
|
/*
* Copyright 2016-2017 Flatiron Institute, Simons Foundation
*
* 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 "remotereadmda.h"
#include "diskreadmda.h"
#include <QStringList>
#include <QDir>
#include <QDateTime>
#include <mlnetwork.h>
#include <mda32.h>
#include <diskreadmda32.h>
#include "cachemanager.h"
#include "mlcommon.h"
#define REMOTE_READ_MDA_CHUNK_SIZE 5e5
struct RemoteReadMdaInfo {
RemoteReadMdaInfo()
{
N1 = N2 = N3 = 0;
}
int N1, N2, N3;
QString checksum;
QDateTime file_last_modified;
};
class RemoteReadMdaPrivate {
public:
RemoteReadMda* q;
QString m_path;
RemoteReadMdaInfo m_info;
bool m_reshaped;
bool m_info_downloaded;
QString m_remote_datatype;
int m_download_chunk_size;
bool m_download_failed; //don't make excessive calls. Once we failed, that's it.
void construct_and_clear();
void copy_from(const RemoteReadMda& other);
void download_info_if_needed();
QString download_chunk_at_index(int ii);
};
RemoteReadMda::RemoteReadMda(const QString& path)
{
d = new RemoteReadMdaPrivate;
d->q = this;
d->construct_and_clear();
this->setPath(path);
}
RemoteReadMda::RemoteReadMda(const RemoteReadMda& other)
{
d = new RemoteReadMdaPrivate;
d->q = this;
d = new RemoteReadMdaPrivate;
d->q = this;
d->copy_from(other);
}
void RemoteReadMda::operator=(const RemoteReadMda& other)
{
d->copy_from(other);
}
RemoteReadMda::~RemoteReadMda()
{
delete d;
}
void RemoteReadMda::setRemoteDataType(QString dtype)
{
d->m_remote_datatype = dtype;
}
void RemoteReadMda::setDownloadChunkSize(int size)
{
d->m_download_chunk_size = size;
}
int RemoteReadMda::downloadChunkSize()
{
return d->m_download_chunk_size;
}
void RemoteReadMda::setPath(const QString& file_path)
{
d->construct_and_clear();
d->m_path = file_path;
}
QString RemoteReadMda::makePath() const
{
return d->m_path;
}
bool RemoteReadMda::reshape(int N1b, int N2b, int N3b)
{
if (this->N1() * this->N2() * this->N3() != N1b * N2b * N3b)
return false;
d->download_info_if_needed();
d->m_info.N1 = N1b;
d->m_info.N2 = N2b;
d->m_info.N3 = N3b;
d->m_reshaped = true;
return true;
}
int RemoteReadMda::N1() const
{
d->download_info_if_needed();
return d->m_info.N1;
}
int RemoteReadMda::N2() const
{
d->download_info_if_needed();
return d->m_info.N2;
}
int RemoteReadMda::N3() const
{
d->download_info_if_needed();
return d->m_info.N3;
}
QDateTime RemoteReadMda::fileLastModified() const
{
d->download_info_if_needed();
return d->m_info.file_last_modified;
}
QString format_num(double num_entries)
{
if (num_entries <= 500)
return QString("%1").arg(num_entries);
if (num_entries < 1000 * 1e3)
return QString("%1K").arg(num_entries / 1e3, 0, 'f', 2);
if (num_entries < 1000 * 1e6)
return QString("%1M").arg(num_entries / 1e6, 0, 'f', 2);
return QString("%1G").arg(num_entries / 1e9, 0, 'f', 2);
}
bool RemoteReadMda::readChunk(Mda& X, int i, int size) const
{
if (d->m_download_failed) {
//don't make excessive calls... once we fail, that's it.
return false;
}
//double size_mb = size * datatype_size * 1.0 / 1e6;
//TaskProgress task(TaskProgress::Download, "Downloading array chunk");
//if (size_mb > 0.5) {
// task.setLabel(QString("Downloading array chunk: %1 MB").arg(size_mb));
//}
//read a chunk of the remote array considered as a 1D array
TaskProgress task(TaskProgress::Download, QString("Downloading %1 numbers - %2 (%3x%4x%5)").arg(format_num(size)).arg(d->m_remote_datatype).arg(N1()).arg(N2()).arg(N3()));
task.log() << "Reading chunk:" << this->makePath() << i << size;
X.allocate(size, 1); //allocate the output array
double* Xptr = X.dataPtr(); //pointer to the output data
int ii1 = i; //start index of the remote array
int ii2 = i + size - 1; //end index of the remote array
int jj1 = ii1 / d->m_download_chunk_size; //start chunk index of the remote array
int jj2 = ii2 / d->m_download_chunk_size; //end chunk index of the remote array
if (jj1 == jj2) { //in this case there is only one chunk we need to worry about
task.setProgress(0.2);
QString fname = d->download_chunk_at_index(jj1); //download the single chunk
if (fname.isEmpty()) {
//task.error("fname is empty");
if (!MLUtil::threadInterruptRequested()) {
TaskProgress errtask("Download chunk at index");
errtask.log() << QString("m_remote_data_type = %1, download chunk size = %2").arg(d->m_remote_datatype).arg(d->m_download_chunk_size);
errtask.log() << d->m_path;
errtask.error() << QString("Failed to download chunk at index %1 *").arg(jj1);
d->m_download_failed = true;
}
return false;
}
DiskReadMda A(fname);
A.readChunk(X, ii1 - jj1 * d->m_download_chunk_size, size); //starting reading at the offset of ii1 relative to the start index of the chunk
return true;
}
else {
for (int jj = jj1; jj <= jj2; jj++) { //otherwise we need to step through the chunks
task.setProgress((jj - jj1 + 0.5) / (jj2 - jj1 + 1));
if (MLUtil::threadInterruptRequested()) {
//X = Mda(); //maybe it's better to return the right size.
//task.error("Halted");
return false;
}
QString fname = d->download_chunk_at_index(jj); //download the chunk at index jj
if (fname.isEmpty()) {
//task.error("fname is empty *");
return false;
}
DiskReadMda A(fname);
if (jj == jj1) { //case 1/3, this is the first chunk
Mda tmp;
int size0 = (jj1 + 1) * d->m_download_chunk_size - ii1; //the size is going to be the difference between ii1 and the start index of the next chunk
A.readChunk(tmp, ii1 - jj1 * d->m_download_chunk_size, size0); //again we start reading at the offset of ii1 relative to the start index of the chunk
double* tmp_ptr = tmp.dataPtr(); //copy the data directly from tmp_ptr to Xptr
const int b = 0;
std::copy(tmp_ptr, tmp_ptr + size0, Xptr + b);
// for (int a = 0; a < size0; a++) {
// Xptr[b] = tmp_ptr[a];
// b++;
// }
}
else if (jj == jj2) { //case 2/3, this is the last chunk
Mda tmp;
int size0 = ii2 + 1 - jj2 * d->m_download_chunk_size; //the size is going to be the difference between the start index of the last chunk and ii2+1
A.readChunk(tmp, 0, size0); //we start reading at position zero
double* tmp_ptr = tmp.dataPtr();
//copy the data to the last part of X
const int b = size - size0;
std::copy(tmp_ptr, tmp_ptr + size0, Xptr + b);
// for (int a = 0; a < size0; a++) {
// Xptr[b] = tmp_ptr[a];
// b++;
// }
}
/*
///this was the old code, which was wrong!!!!!!!!! -- fixed on 5/16/2016
else if (jj == jj2) {
Mda tmp;
int size0 = ii2 + 1 - jj2 * d->m_download_chunk_size;
A.readChunk(tmp, d->m_download_chunk_size - size0, size0);
double* tmp_ptr = tmp.dataPtr();
int b = jj2 * d->m_download_chunk_size - ii1;
for (int a = 0; a < size0; a++) {
Xptr[b] = tmp_ptr[a];
b++;
}
}
*/
else { //case 3/3, this is a middle chunk
Mda tmp;
A.readChunk(tmp, 0, d->m_download_chunk_size); //read the entire chunk, because we'll use it all
double* tmp_ptr = tmp.dataPtr();
int b = jj * d->m_download_chunk_size - ii1; //we start writing at the offset between the start index of the chunk and the start index
std::copy(tmp_ptr, tmp_ptr + d->m_download_chunk_size, Xptr + b);
// for (int a = 0; a < d->m_download_chunk_size; a++) {
// Xptr[b] = tmp_ptr[a];
// b++;
// }
}
}
return true;
}
}
bool RemoteReadMda::readChunk32(Mda32& X, int i, int size) const
{
if (d->m_download_failed) {
//don't make excessive calls... once we fail, that's it.
return false;
}
//double size_mb = size * datatype_size * 1.0 / 1e6;
//TaskProgress task(TaskProgress::Download, "Downloading array chunk");
//if (size_mb > 0.5) {
// task.setLabel(QString("Downloading array chunk: %1 MB").arg(size_mb));
//}
//read a chunk of the remote array considered as a 1D array
TaskProgress task(TaskProgress::Download, QString("Downloading %1 numbers -- %2 (%3x%4x%5)").arg(format_num(size)).arg(d->m_remote_datatype).arg(N1()).arg(N2()).arg(N3()));
task.log(this->makePath());
X.allocate(size, 1); //allocate the output array
dtype32* Xptr = X.dataPtr(); //pointer to the output data
int ii1 = i; //start index of the remote array
int ii2 = i + size - 1; //end index of the remote array
int jj1 = ii1 / d->m_download_chunk_size; //start chunk index of the remote array
int jj2 = ii2 / d->m_download_chunk_size; //end chunk index of the remote array
if (jj1 == jj2) { //in this case there is only one chunk we need to worry about
task.setProgress(0.2);
QString fname = d->download_chunk_at_index(jj1); //download the single chunk
if (fname.isEmpty()) {
//task.error("fname is empty");
if (!MLUtil::threadInterruptRequested()) {
TaskProgress errtask("Download chunk at index");
errtask.log(QString("m_remote_data_type = %1, download chunk size = %2").arg(d->m_remote_datatype).arg(d->m_download_chunk_size));
errtask.log(d->m_path);
errtask.error(QString("Failed to download chunk at index %1 -").arg(jj1));
d->m_download_failed = true;
}
return false;
}
DiskReadMda32 A(fname);
A.readChunk(X, ii1 - jj1 * d->m_download_chunk_size, size); //starting reading at the offset of ii1 relative to the start index of the chunk
return true;
}
else {
for (int jj = jj1; jj <= jj2; jj++) { //otherwise we need to step through the chunks
task.setProgress((jj - jj1 + 0.5) / (jj2 - jj1 + 1));
if (MLUtil::threadInterruptRequested()) {
//X = Mda32(); //maybe it's better to return the right size.
//task.error("Halted");
return false;
}
QString fname = d->download_chunk_at_index(jj); //download the chunk at index jj
if (fname.isEmpty()) {
//task.error("fname is empty *");
return false;
}
DiskReadMda32 A(fname);
if (jj == jj1) { //case 1/3, this is the first chunk
Mda32 tmp;
int size0 = (jj1 + 1) * d->m_download_chunk_size - ii1; //the size is going to be the difference between ii1 and the start index of the next chunk
A.readChunk(tmp, ii1 - jj1 * d->m_download_chunk_size, size0); //again we start reading at the offset of ii1 relative to the start index of the chunk
dtype32* tmp_ptr = tmp.dataPtr(); //copy the data directly from tmp_ptr to Xptr
std::copy(tmp_ptr, tmp_ptr + size0, Xptr);
// int b = 0;
// for (int a = 0; a < size0; a++) {
// Xptr[b] = tmp_ptr[a];
// b++;
// }
}
else if (jj == jj2) { //case 2/3, this is the last chunk
Mda32 tmp;
int size0 = ii2 + 1 - jj2 * d->m_download_chunk_size; //the size is going to be the difference between the start index of the last chunk and ii2+1
A.readChunk(tmp, 0, size0); //we start reading at position zero
dtype32* tmp_ptr = tmp.dataPtr();
//copy the data to the last part of X
int b = size - size0;
std::copy(tmp_ptr, tmp_ptr + size0, Xptr + b);
// for (int a = 0; a < size0; a++) {
// Xptr[b] = tmp_ptr[a];
// b++;
// }
}
/*
///this was the old code, which was wrong!!!!!!!!! -- fixed on 5/16/2016
else if (jj == jj2) {
Mda32 tmp;
int size0 = ii2 + 1 - jj2 * d->m_download_chunk_size;
A.readChunk(tmp, d->m_download_chunk_size - size0, size0);
dtype32* tmp_ptr = tmp.dataPtr();
int b = jj2 * d->m_download_chunk_size - ii1;
for (int a = 0; a < size0; a++) {
Xptr[b] = tmp_ptr[a];
b++;
}
}
*/
else { //case 3/3, this is a middle chunk
Mda32 tmp;
A.readChunk(tmp, 0, d->m_download_chunk_size); //read the entire chunk, because we'll use it all
dtype32* tmp_ptr = tmp.dataPtr();
//const int b = jj * d->m_download_chunk_size - ii1; //we start writing at the offset between the start index of the chunk and the start index
std::copy(tmp_ptr, tmp_ptr + d->m_download_chunk_size, Xptr);
// for (int a = 0; a < d->m_download_chunk_size; a++) {
// Xptr[b] = tmp_ptr[a];
// b++;
// }
}
}
return true;
}
}
void RemoteReadMdaPrivate::construct_and_clear()
{
this->m_download_chunk_size = REMOTE_READ_MDA_CHUNK_SIZE;
this->m_download_failed = false;
this->m_info = RemoteReadMdaInfo();
this->m_info_downloaded = false;
this->m_path = "";
/// TODO (LOW) use enum instead of string "float64", "float32", etc
this->m_remote_datatype = "float64";
this->m_reshaped = false;
}
void RemoteReadMdaPrivate::copy_from(const RemoteReadMda& other)
{
this->m_download_chunk_size = other.d->m_download_chunk_size;
this->m_download_failed = other.d->m_download_failed;
this->m_info = other.d->m_info;
this->m_info_downloaded = other.d->m_info_downloaded;
this->m_path = other.d->m_path;
this->m_remote_datatype = other.d->m_remote_datatype;
this->m_reshaped = other.d->m_reshaped;
}
void RemoteReadMdaPrivate::download_info_if_needed()
{
if (m_info_downloaded)
return;
//if (in_gui_thread()) {
// qCritical() << "Cannot call download_info_if_needed from within the GUI thread!";
// exit(-1);
//}
m_info_downloaded = true;
//QString url=file_url_for_remote_path(m_path);
QString url = m_path;
QString url2 = url + "?a=info&output=text";
QString txt = MLNetwork::httpGetTextSync(url2);
QStringList lines = txt.split("\n");
QStringList sizes = lines.value(0).split(",");
m_info.N1 = sizes.value(0).toLong();
m_info.N2 = sizes.value(1).toLong();
m_info.N3 = sizes.value(2).toLong();
m_info.checksum = lines.value(1);
m_info.file_last_modified = QDateTime::fromMSecsSinceEpoch(lines.value(2).toLong());
}
void unquantize8(Mda& X, double minval, double maxval);
QString RemoteReadMdaPrivate::download_chunk_at_index(int ii)
{
TaskProgress task(QString("Download chunk at index %1 ---").arg(ii));
download_info_if_needed();
int Ntot = m_info.N1 * m_info.N2 * m_info.N3;
int size = m_download_chunk_size;
if (ii * m_download_chunk_size + size > Ntot) {
size = Ntot - ii * m_download_chunk_size;
}
if (size <= 0) {
task.log() << m_info.N1 << m_info.N2 << m_info.N3 << Ntot << m_download_chunk_size << ii;
task.error() << "Size is:" << size;
return "";
}
if (m_info.checksum.isEmpty()) {
task.error() << "Info checksum is empty";
return "";
}
QString file_name = m_info.checksum + "-" + QString("%1-%2").arg(m_download_chunk_size).arg(ii);
QString fname = CacheManager::globalInstance()->makeLocalFile(file_name, CacheManager::ShortTerm);
if (QFile::exists(fname))
return fname;
QString url = m_path;
QString url0 = url + QString("?a=readChunk&output=text&index=%1&size=%2&datatype=%3").arg((int)(ii * m_download_chunk_size)).arg(size).arg(m_remote_datatype);
QString binary_url = MLNetwork::httpGetTextSync(url0).trimmed();
if (binary_url.isEmpty())
return "";
//the following is ugly
int ind = m_path.indexOf("/mdaserver");
if (ind > 0) {
binary_url = m_path.mid(0, ind) + "/mdaserver/" + binary_url;
}
task.log() << "binary_url:" << binary_url;
QString tmp_mda_fname = MLNetwork::httpGetBinaryFileSync(binary_url);
if (tmp_mda_fname.isEmpty())
return "";
DiskReadMda tmp(tmp_mda_fname);
if (tmp.totalSize() != size) {
task.error() << "Unexpected total size problem: " << tmp.totalSize() << size;
qWarning() << "Unexpected total size problem: " << tmp.totalSize() << size;
QFile::remove(tmp_mda_fname);
return "";
}
if (m_remote_datatype == "float32_q8") {
QString dynamic_range_fname = MLNetwork::httpGetBinaryFileSync(binary_url + ".q8");
if (dynamic_range_fname.isEmpty()) {
qWarning() << "problem downloading .q8 file: " + binary_url + ".q8";
task.error() << "problem downloading .q8 file: " + binary_url + ".q8";
return "";
}
Mda dynamic_range(dynamic_range_fname);
if (dynamic_range.totalSize() != 2) {
qWarning() << QString("Problem in .q8 file. Unexpected size %1: ").arg(dynamic_range.totalSize()) + binary_url + ".q8";
task.error() << QString("Problem in .q8 file. Unexpected size %1: ").arg(dynamic_range.totalSize()) + binary_url + ".q8";
return "";
}
Mda chunk(tmp_mda_fname);
unquantize8(chunk, dynamic_range.value(0), dynamic_range.value(1));
if (!chunk.write32(fname)) {
QFile::remove(tmp_mda_fname);
qWarning() << "Unable to write file: " + fname;
task.error() << "Unable to write file: " + fname;
return "";
}
QFile::remove(tmp_mda_fname);
}
else {
if (!QFile::rename(tmp_mda_fname, fname)) {
QFile::remove(tmp_mda_fname);
qWarning() << "Unable to rename file: " << tmp_mda_fname << fname;
task.error() << "Unable to rename file: " << tmp_mda_fname << fname;
return "";
}
}
return fname;
}
void unit_test_remote_read_mda()
{
QString url = "http://localhost:8000/firings.mda";
RemoteReadMda X(url);
Mda chunk;
X.readChunk(chunk, 0, 100);
for (int j = 0; j < 10; j++) {
qDebug().noquote() << j << chunk.value(j); // unit_test
}
}
#include "diskreadmda.h"
void unit_test_remote_read_mda_2(const QString& path)
{
// run this test by calling
// > mountainview unit_test remotereadmda2
DiskReadMda X(path);
for (int j = 0; j < 20; j++) {
printf("%d: ", j);
for (int i = 0; i < X.N1(); i++) {
printf("%g, ", X.value(i, j));
}
printf("\n");
}
}
void unquantize8(Mda& X, double minval, double maxval)
{
int N = X.totalSize();
double* Xptr = X.dataPtr();
for (int i = 0; i < N; i++) {
Xptr[i] = minval + (Xptr[i] / 255) * (maxval - minval);
}
}
|
#include "model.h"
const unsigned char intonly_quant_tflite_model[] = {
0x20, 0x00, 0x00, 0x00, 0x54, 0x46, 0x4c, 0x33, 0x00, 0x00, 0x00, 0x00,
0x14, 0x00, 0x20, 0x00, 0x1c, 0x00, 0x18, 0x00, 0x14, 0x00, 0x10, 0x00,
0x0c, 0x00, 0x00, 0x00, 0x08, 0x00, 0x04, 0x00, 0x14, 0x00, 0x00, 0x00,
0x1c, 0x00, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00, 0x4c, 0x00, 0x00, 0x00,
0xa8, 0x2e, 0x00, 0x00, 0xb8, 0x2e, 0x00, 0x00, 0x2c, 0x46, 0x00, 0x00,
0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
0x0c, 0x00, 0x00, 0x00, 0x08, 0x00, 0x0c, 0x00, 0x08, 0x00, 0x04, 0x00,
0x08, 0x00, 0x00, 0x00, 0x1f, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
0x13, 0x00, 0x00, 0x00, 0x6d, 0x69, 0x6e, 0x5f, 0x72, 0x75, 0x6e, 0x74,
0x69, 0x6d, 0x65, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x00,
0x20, 0x00, 0x00, 0x00, 0x58, 0x2e, 0x00, 0x00, 0x50, 0x2e, 0x00, 0x00,
0x3c, 0x2e, 0x00, 0x00, 0x28, 0x2e, 0x00, 0x00, 0x14, 0x2e, 0x00, 0x00,
0x00, 0x2e, 0x00, 0x00, 0xec, 0x2d, 0x00, 0x00, 0xd4, 0x2d, 0x00, 0x00,
0x7c, 0x2d, 0x00, 0x00, 0x4c, 0x2d, 0x00, 0x00, 0xbc, 0x28, 0x00, 0x00,
0x6c, 0x28, 0x00, 0x00, 0x5c, 0x16, 0x00, 0x00, 0xcc, 0x15, 0x00, 0x00,
0xbc, 0x00, 0x00, 0x00, 0x9c, 0x00, 0x00, 0x00, 0x94, 0x00, 0x00, 0x00,
0x8c, 0x00, 0x00, 0x00, 0x84, 0x00, 0x00, 0x00, 0x7c, 0x00, 0x00, 0x00,
0x74, 0x00, 0x00, 0x00, 0x6c, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00,
0x5c, 0x00, 0x00, 0x00, 0x54, 0x00, 0x00, 0x00, 0x4c, 0x00, 0x00, 0x00,
0x44, 0x00, 0x00, 0x00, 0x3c, 0x00, 0x00, 0x00, 0x34, 0x00, 0x00, 0x00,
0x2c, 0x00, 0x00, 0x00, 0x24, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
0x16, 0xcf, 0xff, 0xff, 0x04, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00,
0x31, 0x2e, 0x31, 0x34, 0x2e, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x7c, 0xbb, 0xff, 0xff, 0x80, 0xbb, 0xff, 0xff,
0x84, 0xbb, 0xff, 0xff, 0x88, 0xbb, 0xff, 0xff, 0x8c, 0xbb, 0xff, 0xff,
0x90, 0xbb, 0xff, 0xff, 0x94, 0xbb, 0xff, 0xff, 0x98, 0xbb, 0xff, 0xff,
0x9c, 0xbb, 0xff, 0xff, 0xa0, 0xbb, 0xff, 0xff, 0xa4, 0xbb, 0xff, 0xff,
0xa8, 0xbb, 0xff, 0xff, 0xac, 0xbb, 0xff, 0xff, 0xb0, 0xbb, 0xff, 0xff,
0xb4, 0xbb, 0xff, 0xff, 0x6e, 0xcf, 0xff, 0xff, 0x04, 0x00, 0x00, 0x00,
0x10, 0x00, 0x00, 0x00, 0xae, 0xfe, 0xff, 0xff, 0xa0, 0x02, 0x00, 0x00,
0x45, 0x00, 0x00, 0x00, 0xf7, 0xfe, 0xff, 0xff, 0x8a, 0xcf, 0xff, 0xff,
0x04, 0x00, 0x00, 0x00, 0x00, 0x15, 0x00, 0x00, 0x03, 0x05, 0xf8, 0xf5,
0x0a, 0xfe, 0x03, 0xfc, 0x01, 0xfb, 0x11, 0x03, 0xf1, 0x07, 0x07, 0xec,
0xf6, 0x0c, 0xff, 0x08, 0x11, 0x04, 0x13, 0xef, 0xfe, 0xfe, 0x0d, 0xfd,
0x07, 0xfa, 0xfe, 0x03, 0xf9, 0x00, 0x01, 0xe5, 0xf0, 0x11, 0xf9, 0x08,
0xfc, 0x04, 0xee, 0x0f, 0x11, 0xff, 0x09, 0x0e, 0x06, 0xcf, 0xfc, 0xfa,
0xf6, 0x0a, 0xfe, 0x04, 0xf9, 0xfe, 0xfe, 0xf6, 0xf6, 0x05, 0xf2, 0xf7,
0x1c, 0x0c, 0xec, 0xf7, 0x14, 0xef, 0x1d, 0x05, 0x09, 0x0f, 0xb2, 0xfe,
0xea, 0x1d, 0x05, 0xf7, 0x03, 0xea, 0x0f, 0xe9, 0x11, 0xf9, 0xf8, 0xfc,
0x07, 0xf2, 0x19, 0x15, 0x11, 0x05, 0x04, 0xec, 0xfb, 0xff, 0xf1, 0xc8,
0x00, 0xf8, 0xfa, 0xf2, 0x02, 0xfb, 0xd0, 0xe6, 0xe9, 0xef, 0xed, 0x09,
0x04, 0xde, 0xf4, 0xde, 0xf8, 0xfd, 0x04, 0xeb, 0x06, 0xfb, 0x02, 0xf4,
0xf5, 0xfa, 0xf2, 0xe3, 0x0d, 0xfc, 0xd8, 0xf8, 0xe4, 0xf4, 0xdf, 0xe0,
0xfb, 0xf5, 0xc3, 0xf2, 0xe5, 0xf0, 0xf4, 0xf0, 0xf3, 0xfd, 0xe2, 0x14,
0xe0, 0xea, 0xf3, 0xd7, 0xf7, 0xf4, 0x03, 0xe2, 0xe9, 0xee, 0xeb, 0xfc,
0xe5, 0xe0, 0xf1, 0xef, 0xeb, 0xf3, 0x0a, 0xdc, 0xcd, 0xcd, 0xfc, 0xd4,
0xf8, 0xf4, 0xd9, 0xef, 0xe5, 0xef, 0xf3, 0xf3, 0xfb, 0xf5, 0xe1, 0xf9,
0xf7, 0x07, 0xda, 0xe4, 0xee, 0xea, 0xed, 0xf3, 0xf9, 0x00, 0x0c, 0x07,
0x11, 0xef, 0xfa, 0xf9, 0x00, 0xf9, 0x05, 0xf8, 0xf9, 0x07, 0x08, 0x02,
0x10, 0x06, 0x05, 0xfb, 0x0c, 0x08, 0xf6, 0xff, 0xf7, 0x08, 0x06, 0x08,
0x08, 0xef, 0x0d, 0xff, 0x07, 0xfc, 0x0d, 0xda, 0x02, 0x0e, 0xfe, 0xfe,
0xf3, 0x07, 0xff, 0x13, 0xf0, 0xf6, 0xfe, 0x18, 0x01, 0xd9, 0xf2, 0xeb,
0x04, 0x00, 0xfb, 0x0f, 0xf7, 0xed, 0xf8, 0xfc, 0x06, 0x05, 0xf3, 0xf6,
0x17, 0x1e, 0xfb, 0xe1, 0x14, 0xfd, 0x2b, 0x0b, 0x2d, 0x07, 0xdd, 0xf9,
0xf9, 0x12, 0x34, 0xf7, 0x18, 0xf5, 0x0f, 0xeb, 0x17, 0x0e, 0x10, 0x11,
0x0f, 0x07, 0x0c, 0x23, 0x11, 0x0f, 0x08, 0xea, 0xf8, 0x0a, 0xf3, 0xea,
0xfc, 0xf2, 0x19, 0x14, 0x10, 0xf3, 0xd4, 0x0d, 0xd3, 0x09, 0x17, 0xf5,
0xf9, 0xef, 0x08, 0xc9, 0xee, 0xf2, 0xef, 0xfd, 0xee, 0xe6, 0x04, 0xf5,
0xf4, 0xe8, 0xeb, 0xf1, 0xf3, 0xfb, 0xd7, 0x02, 0xf9, 0xe2, 0xee, 0xe6,
0xfa, 0x02, 0xd2, 0xfe, 0xe2, 0x02, 0xfb, 0xf7, 0xeb, 0x06, 0xf4, 0x07,
0xe5, 0x00, 0xe5, 0xfc, 0xf1, 0xf2, 0xf3, 0xe4, 0xf0, 0xee, 0xdf, 0xf7,
0x02, 0xd5, 0xe7, 0xea, 0xf6, 0xe3, 0xee, 0xe8, 0xf1, 0xec, 0xe6, 0xf0,
0x00, 0x02, 0xe8, 0xef, 0xe3, 0xf0, 0xed, 0xf8, 0xf6, 0xe6, 0xe5, 0x01,
0xeb, 0xe5, 0xe3, 0xee, 0xea, 0xda, 0xf1, 0xf3, 0x0e, 0x02, 0xf4, 0x0c,
0x06, 0xf9, 0x02, 0x04, 0x04, 0x08, 0xfa, 0xf8, 0x02, 0x14, 0xfe, 0xfc,
0xf7, 0x00, 0x01, 0xfd, 0x05, 0x01, 0x0d, 0xfb, 0x07, 0x0b, 0x0a, 0x08,
0x0c, 0xfa, 0x0c, 0xf9, 0xef, 0xf1, 0x0d, 0xff, 0x05, 0xef, 0x10, 0x01,
0x04, 0x11, 0xec, 0x04, 0x06, 0xfb, 0x01, 0x07, 0x0f, 0xef, 0x03, 0x07,
0x00, 0x05, 0xf2, 0x02, 0x00, 0xf2, 0x01, 0x03, 0x0f, 0x05, 0xf3, 0xf1,
0x1d, 0x10, 0xf8, 0xe6, 0xfc, 0x02, 0x0f, 0xf9, 0x10, 0x0c, 0xdc, 0x1c,
0xed, 0x18, 0x11, 0x0e, 0x0e, 0xee, 0x0e, 0xec, 0x0f, 0x15, 0x09, 0x0b,
0x16, 0xfd, 0x1f, 0x07, 0x28, 0x07, 0x08, 0xf1, 0xf3, 0x1c, 0xe5, 0xd8,
0xfd, 0xfe, 0xf2, 0xf2, 0x09, 0xf7, 0xcd, 0x05, 0xe7, 0xfc, 0xf4, 0x02,
0xf4, 0xd2, 0x13, 0xdc, 0xea, 0xfc, 0xef, 0xf3, 0xe8, 0xf1, 0xfa, 0xf9,
0xee, 0xe8, 0xe6, 0xe3, 0xeb, 0xf2, 0xda, 0x02, 0x06, 0xe7, 0xf4, 0xdf,
0xee, 0xfb, 0xdb, 0xf4, 0xe2, 0xf3, 0xf3, 0xf7, 0xfd, 0x12, 0xe3, 0x0c,
0xfb, 0xe2, 0xf1, 0xe0, 0xea, 0xfd, 0x05, 0xf1, 0x06, 0xff, 0xde, 0xfc,
0xed, 0xe4, 0xf2, 0xf4, 0xe9, 0xeb, 0xe8, 0xf1, 0xea, 0xf3, 0xec, 0xf2,
0xe0, 0xe7, 0xe4, 0xea, 0xe9, 0x00, 0xe0, 0xee, 0xf5, 0xeb, 0xd4, 0xea,
0xeb, 0xe5, 0xd2, 0xe2, 0xdd, 0xde, 0xed, 0xfd, 0xff, 0x04, 0xf9, 0xfb,
0x04, 0xfe, 0x03, 0x05, 0x04, 0x00, 0x00, 0xf7, 0xf8, 0x05, 0xfa, 0x00,
0x03, 0x0e, 0x04, 0xfa, 0xff, 0x0a, 0x04, 0xfd, 0xff, 0xfd, 0x09, 0x00,
0x10, 0xfc, 0x09, 0xf5, 0x00, 0xff, 0x0a, 0xee, 0x0a, 0xf1, 0xeb, 0x04,
0x00, 0x04, 0xfa, 0xff, 0xf9, 0xf4, 0x0c, 0x03, 0xf0, 0xec, 0x04, 0xe8,
0x05, 0xfa, 0x04, 0x0f, 0x04, 0xfd, 0xfd, 0x04, 0xfb, 0xf3, 0xf5, 0xfb,
0x1c, 0x0c, 0xf0, 0x0e, 0x01, 0x00, 0xee, 0x1b, 0x03, 0xf3, 0xda, 0xeb,
0xfe, 0x09, 0x11, 0xfa, 0x0d, 0xd9, 0x06, 0xff, 0x12, 0x0b, 0x0d, 0x18,
0x0e, 0xf5, 0x12, 0x10, 0x0e, 0x01, 0x14, 0xe7, 0xf2, 0x0f, 0x10, 0xda,
0x0e, 0xec, 0xfc, 0x13, 0x0a, 0xf6, 0xe8, 0x05, 0xff, 0x0c, 0x01, 0x0c,
0xef, 0xd5, 0x00, 0xd6, 0xf7, 0xf9, 0x08, 0xf5, 0xff, 0xed, 0x00, 0xfa,
0xf0, 0x0b, 0xf8, 0xf0, 0xff, 0x0e, 0xe1, 0x04, 0xf7, 0xf2, 0xfc, 0xf6,
0x19, 0x0b, 0xee, 0x0f, 0xd6, 0x1d, 0xf7, 0xf4, 0xf4, 0x09, 0xf7, 0x21,
0xf9, 0x06, 0xfd, 0xd8, 0xff, 0xe7, 0xff, 0xe0, 0x09, 0xef, 0xee, 0x01,
0xf3, 0xe0, 0xf3, 0xff, 0xf7, 0xd9, 0xf6, 0xf7, 0xfe, 0xd3, 0xec, 0xdc,
0xdd, 0x06, 0xfa, 0xef, 0xed, 0xfe, 0xed, 0x05, 0xef, 0xf5, 0xe8, 0xfc,
0xfa, 0xee, 0xe8, 0xe5, 0xe6, 0xe3, 0xf5, 0xef, 0xfa, 0x02, 0xf9, 0xfe,
0x02, 0xf9, 0xe8, 0xfe, 0x04, 0xff, 0x09, 0x03, 0x03, 0x09, 0x02, 0xf8,
0x0a, 0xfa, 0x0d, 0x01, 0x0c, 0x02, 0xff, 0x00, 0x01, 0x0b, 0x00, 0x00,
0x0b, 0x0b, 0x04, 0x01, 0xfb, 0xff, 0x06, 0xef, 0xf6, 0xfb, 0x02, 0xff,
0x02, 0xf9, 0x07, 0x12, 0x0d, 0xfc, 0xfe, 0x00, 0x00, 0xf0, 0x02, 0xe2,
0xf6, 0x14, 0xff, 0x09, 0x09, 0xf9, 0xf7, 0x07, 0xfb, 0xf6, 0xf2, 0xf9,
0x00, 0x16, 0x1e, 0xec, 0x1f, 0xee, 0xf3, 0xff, 0x00, 0x00, 0xf1, 0x0d,
0xe0, 0x1a, 0xfa, 0xfa, 0xf2, 0xdd, 0x20, 0xd4, 0x04, 0x08, 0xf2, 0x12,
0x0e, 0xec, 0x0a, 0xfe, 0x17, 0xf6, 0x13, 0xf9, 0x00, 0x00, 0x05, 0xe4,
0x0d, 0x01, 0xf9, 0x0e, 0x03, 0xfc, 0xdb, 0x13, 0xf8, 0xee, 0x04, 0x21,
0x0d, 0xda, 0x0a, 0xd0, 0xf7, 0x00, 0xf4, 0x26, 0xe8, 0xfa, 0x01, 0x05,
0x06, 0x00, 0xfc, 0xef, 0xff, 0x12, 0xe7, 0xff, 0x03, 0xdf, 0xf4, 0xe8,
0x18, 0x0a, 0xd7, 0x02, 0xd7, 0x1f, 0xfb, 0xf6, 0x16, 0x0a, 0xfc, 0xf2,
0x01, 0x06, 0xfd, 0xe8, 0x09, 0xf6, 0x14, 0xfe, 0xf3, 0x0e, 0x00, 0xeb,
0xf3, 0xe4, 0xfc, 0x00, 0xf0, 0xdc, 0xe7, 0xee, 0xe4, 0xd2, 0xf3, 0xee,
0xe8, 0x1b, 0xfa, 0xe2, 0xf8, 0x00, 0xd8, 0x09, 0xee, 0x0a, 0xf0, 0xf2,
0xff, 0xeb, 0xf8, 0xe0, 0xf8, 0xe1, 0xf8, 0xee, 0x0d, 0x06, 0xfd, 0xf9,
0x07, 0x0d, 0xf3, 0x00, 0x0b, 0x00, 0x05, 0x0a, 0x12, 0x04, 0x09, 0xf3,
0x0f, 0xfe, 0xf8, 0x08, 0x06, 0x08, 0xf1, 0x08, 0x0e, 0x09, 0x08, 0x0b,
0x07, 0x00, 0x00, 0x08, 0x09, 0xfa, 0xf0, 0x03, 0xf6, 0x04, 0x0a, 0x07,
0x05, 0x02, 0xf2, 0x02, 0xeb, 0x01, 0x07, 0x02, 0x02, 0xeb, 0x00, 0xe4,
0x0a, 0xfb, 0x02, 0xf8, 0xf4, 0x0e, 0x00, 0x05, 0xfd, 0xf9, 0x01, 0xf5,
0x1c, 0x0b, 0xe2, 0xf0, 0x04, 0xe6, 0xfa, 0x14, 0x1c, 0x05, 0xe0, 0xfa,
0xe4, 0x1c, 0xf8, 0x0e, 0x06, 0xe7, 0x00, 0xe8, 0xf4, 0x15, 0x05, 0xfc,
0xf8, 0xf7, 0x04, 0xfa, 0xf8, 0xfe, 0x05, 0xf4, 0xed, 0xfc, 0xfc, 0xeb,
0x02, 0xee, 0x1f, 0x0c, 0xf1, 0xf5, 0xef, 0xfc, 0xe9, 0xe4, 0xf2, 0x0a,
0xf1, 0xe5, 0x18, 0xf4, 0xf9, 0x00, 0xfb, 0x00, 0xfe, 0xe6, 0x00, 0x07,
0xf2, 0xf1, 0xf4, 0xf9, 0x04, 0x11, 0xf9, 0xfa, 0xfc, 0xfb, 0x04, 0xf4,
0x0d, 0x08, 0xdf, 0xf6, 0xdf, 0x1d, 0xf3, 0xf7, 0x06, 0x18, 0xf7, 0xf1,
0xf4, 0x05, 0xe6, 0xfb, 0x07, 0xd8, 0xfb, 0xec, 0x0e, 0xf5, 0x01, 0xfa,
0xfb, 0xe9, 0xf9, 0x0e, 0xf1, 0xe8, 0xf7, 0xf3, 0xe6, 0xea, 0x02, 0xe5,
0xe1, 0xf5, 0xe7, 0xda, 0xe9, 0x01, 0xde, 0xeb, 0xf1, 0xd8, 0xf4, 0xfd,
0xfc, 0xde, 0xec, 0xd3, 0xf1, 0xf5, 0xfb, 0xe8, 0xf7, 0x09, 0xff, 0x0a,
0x0d, 0x00, 0xeb, 0xff, 0xfd, 0xfa, 0x15, 0xf1, 0x00, 0x05, 0x00, 0xf7,
0xf6, 0x02, 0xf2, 0xf7, 0xff, 0x02, 0x02, 0xf9, 0x00, 0xe7, 0xf6, 0x08,
0x04, 0x07, 0x0a, 0xfa, 0xe9, 0xfe, 0xf9, 0xf5, 0x01, 0x07, 0xf8, 0x02,
0x05, 0x03, 0x0a, 0x0f, 0xe6, 0xef, 0xfc, 0xfd, 0x07, 0xdd, 0xf8, 0xdf,
0xf3, 0xfe, 0x0d, 0x06, 0xfa, 0xdd, 0xf8, 0x0c, 0x13, 0xeb, 0x05, 0xf4,
0x40, 0x06, 0xfa, 0xf0, 0xfd, 0xeb, 0x0f, 0xf5, 0x07, 0x01, 0x07, 0xf7,
0xd1, 0x24, 0x2b, 0x05, 0xf4, 0xf5, 0x0a, 0xd5, 0x0c, 0x08, 0x0a, 0xf5,
0x07, 0xe5, 0x17, 0x05, 0xf7, 0xea, 0x17, 0xf4, 0xf3, 0xe3, 0x0a, 0xeb,
0xfb, 0xe3, 0x04, 0x07, 0xff, 0xeb, 0xf3, 0x07, 0xf0, 0x0f, 0x03, 0x0c,
0xf9, 0xd1, 0x07, 0xd6, 0xda, 0xe6, 0xf4, 0x06, 0xf5, 0xf2, 0xfe, 0xf9,
0x00, 0xe3, 0xf8, 0xe1, 0x03, 0x18, 0x02, 0xf8, 0x10, 0xf3, 0xf5, 0xe0,
0x0f, 0xe8, 0xf7, 0xe7, 0xd8, 0x1c, 0xf9, 0xf4, 0xea, 0x08, 0xe2, 0xf5,
0xf1, 0x06, 0xe8, 0xff, 0x11, 0xfb, 0x16, 0xf0, 0xf2, 0xe8, 0xf7, 0xef,
0xe7, 0xcb, 0xf3, 0x00, 0xf1, 0xd1, 0xff, 0xdc, 0xd8, 0xdf, 0xf4, 0xce,
0xed, 0xed, 0xeb, 0xfd, 0xde, 0xfe, 0xe9, 0xfb, 0xfb, 0xed, 0xfc, 0xf9,
0xf2, 0xf3, 0xeb, 0xeb, 0xf2, 0xee, 0xee, 0xee, 0xf7, 0xff, 0xf2, 0x10,
0x0e, 0x06, 0x03, 0xfd, 0x0d, 0x02, 0x0f, 0x09, 0xf5, 0x10, 0x05, 0x06,
0x01, 0x0c, 0xf7, 0x07, 0x0d, 0x0e, 0x02, 0x04, 0x06, 0x0d, 0x0f, 0x11,
0x0a, 0x07, 0x11, 0x0f, 0xe9, 0xec, 0xf2, 0xd7, 0xe9, 0xeb, 0xd9, 0xe9,
0xe3, 0xea, 0xec, 0xea, 0xf7, 0xe7, 0xee, 0xea, 0xe4, 0xf9, 0xe6, 0xf5,
0xde, 0xe2, 0xe7, 0xe7, 0x03, 0xef, 0xe8, 0xdf, 0xf5, 0xfa, 0xdb, 0xf8,
0xd9, 0xce, 0xe3, 0x10, 0xd3, 0xf7, 0xba, 0xb6, 0xc9, 0xea, 0x2b, 0x94,
0x03, 0xe5, 0xe5, 0xab, 0xaf, 0x3f, 0xb1, 0x21, 0xec, 0xea, 0xd6, 0xb2,
0xfb, 0xf8, 0xe1, 0xcc, 0xe1, 0xed, 0xea, 0x24, 0xfb, 0x9e, 0x05, 0x15,
0xe6, 0x0b, 0x98, 0xc8, 0xe4, 0xf2, 0x01, 0xc5, 0xf2, 0xa3, 0xc2, 0x90,
0xb3, 0x32, 0xae, 0x14, 0xe8, 0xdc, 0xe6, 0xa9, 0xe4, 0xef, 0xed, 0xc9,
0xca, 0xf6, 0xe7, 0x28, 0xf3, 0xd1, 0xef, 0xe6, 0xe7, 0xf5, 0xc7, 0xcc,
0xc7, 0x01, 0x11, 0xee, 0x04, 0xe2, 0x02, 0xc2, 0xd6, 0x09, 0xd7, 0xd7,
0xf0, 0xfa, 0x05, 0xe7, 0xef, 0xfd, 0xf5, 0xed, 0xf9, 0xe9, 0xee, 0x02,
0xeb, 0x06, 0xf3, 0xe6, 0x00, 0x11, 0xfe, 0x0d, 0xe2, 0x0c, 0x0b, 0xf5,
0x19, 0xec, 0xf3, 0x03, 0xea, 0xf0, 0x0d, 0xf1, 0xec, 0xf8, 0x01, 0x07,
0xf6, 0x0a, 0xf8, 0xf6, 0xd9, 0xf8, 0xe7, 0x02, 0x07, 0xfd, 0x06, 0x04,
0x09, 0xfc, 0x05, 0x06, 0xff, 0xff, 0x0b, 0x0a, 0x09, 0x09, 0x03, 0xf4,
0x02, 0xfb, 0x0c, 0x08, 0x07, 0xff, 0x09, 0x01, 0xff, 0xf0, 0x02, 0x06,
0xf8, 0xfe, 0x07, 0xfe, 0x0b, 0xfb, 0xda, 0xee, 0xf6, 0xee, 0xeb, 0xe5,
0xf4, 0xf3, 0xd8, 0xfa, 0xf2, 0xf2, 0xec, 0xdf, 0xe5, 0xfe, 0xe6, 0x12,
0xee, 0xf2, 0xf7, 0xec, 0xfa, 0x04, 0xfb, 0xf7, 0xf4, 0xe2, 0xf2, 0x02,
0xde, 0xbe, 0xe4, 0x1f, 0xcf, 0xe1, 0xbe, 0xb7, 0xde, 0xec, 0x23, 0xa0,
0x19, 0xfc, 0xc6, 0xaa, 0xb4, 0x4d, 0xd8, 0x28, 0xdb, 0xdd, 0xfb, 0xb2,
0x06, 0x02, 0xfc, 0xd1, 0xda, 0xe6, 0xdd, 0x08, 0xf7, 0xa6, 0xf3, 0x1b,
0xa9, 0xfd, 0xb8, 0x8e, 0xbb, 0x07, 0x0b, 0xa8, 0x12, 0x9c, 0xb7, 0xd0,
0xd4, 0x01, 0xa6, 0x19, 0xce, 0xd4, 0xe3, 0xbd, 0xfe, 0x05, 0xd8, 0xf4,
0xec, 0xff, 0xf8, 0x08, 0xfb, 0xc9, 0xfa, 0xfa, 0xe6, 0xf7, 0xe6, 0xfc,
0xd7, 0x03, 0x17, 0xfb, 0xfd, 0xce, 0xd3, 0xed, 0xf9, 0xf5, 0xee, 0xe7,
0xd6, 0xfc, 0xea, 0xce, 0xf3, 0x00, 0xf7, 0xfc, 0xeb, 0x07, 0xf4, 0xf3,
0xed, 0x0b, 0xfa, 0xd9, 0xf7, 0x1b, 0x0e, 0x30, 0xe8, 0x09, 0x0f, 0x0c,
0x0f, 0xd2, 0xf7, 0xf4, 0x00, 0xfb, 0x15, 0xfd, 0xf9, 0xfc, 0xff, 0x0d,
0xf8, 0x17, 0x04, 0xee, 0xf2, 0x12, 0xf2, 0xff, 0x05, 0x00, 0xf7, 0x18,
0x0b, 0x01, 0x06, 0xfa, 0x01, 0x0b, 0x04, 0x04, 0x0c, 0x09, 0x07, 0xfe,
0x00, 0x14, 0xfe, 0x02, 0x16, 0x12, 0x01, 0x08, 0x00, 0x0c, 0x04, 0x01,
0x08, 0xfa, 0x13, 0x00, 0xf7, 0xf7, 0xfd, 0xf0, 0xfc, 0xf6, 0xc9, 0xe8,
0xe6, 0x00, 0xf8, 0xe2, 0x10, 0xee, 0xf7, 0xe2, 0xf6, 0x05, 0xfe, 0x0d,
0xe6, 0xec, 0xf7, 0xe9, 0x09, 0x05, 0xe8, 0xf2, 0xf8, 0xfa, 0xe8, 0x03,
0xe4, 0xcc, 0xdf, 0x1b, 0xf2, 0xf4, 0xd9, 0xa4, 0xfa, 0xf4, 0x32, 0xb1,
0x10, 0xeb, 0xc4, 0xa5, 0xdd, 0x2c, 0xc1, 0x2f, 0xf0, 0xe0, 0xeb, 0xca,
0xf7, 0x0c, 0xef, 0xd1, 0xd5, 0xf1, 0xef, 0x21, 0x01, 0x81, 0xe7, 0x25,
0xd6, 0x0d, 0xb9, 0xc8, 0xdf, 0x0e, 0x23, 0x98, 0x16, 0xb9, 0xae, 0xb0,
0xe5, 0x14, 0xd1, 0x0e, 0xea, 0xe1, 0xe6, 0xd6, 0xfd, 0x00, 0xe6, 0xec,
0xea, 0xfb, 0xf7, 0x08, 0xff, 0xdb, 0x01, 0x07, 0xf3, 0x0e, 0xfb, 0x12,
0xf4, 0x02, 0x02, 0xf8, 0xf9, 0xcb, 0xdd, 0xfb, 0xd6, 0x02, 0xf7, 0xfb,
0xed, 0xea, 0xf7, 0xf2, 0x04, 0x03, 0xeb, 0xec, 0xf8, 0x07, 0x07, 0xf5,
0xf7, 0x07, 0x09, 0xe6, 0xf1, 0x03, 0x0b, 0xf8, 0xf9, 0x07, 0xeb, 0x0b,
0x22, 0xee, 0xf9, 0xf9, 0xfc, 0x06, 0x06, 0x0c, 0x09, 0x06, 0xf6, 0x01,
0x05, 0x11, 0xf5, 0xfe, 0x00, 0xfc, 0x01, 0xfe, 0x08, 0x0a, 0xfc, 0x0a,
0x0c, 0x08, 0x02, 0x16, 0xfe, 0x09, 0x0d, 0xf7, 0xfe, 0x14, 0x07, 0xfe,
0x0b, 0x13, 0x07, 0x08, 0x0c, 0xfc, 0x01, 0x02, 0x18, 0x01, 0x10, 0xfe,
0x09, 0x11, 0x07, 0x06, 0xe7, 0x01, 0xde, 0xf7, 0x03, 0x03, 0xf3, 0x03,
0xf9, 0x07, 0xec, 0x06, 0x01, 0xe6, 0xfc, 0xfe, 0x0f, 0x0b, 0xff, 0x08,
0x07, 0x01, 0xf6, 0xed, 0x00, 0xf3, 0xf0, 0xf4, 0xf9, 0xfd, 0xf3, 0x00,
0x00, 0xe3, 0xfb, 0x17, 0xda, 0xdb, 0xba, 0xb4, 0xf3, 0xf4, 0x0c, 0xad,
0x05, 0xfa, 0xdb, 0xdc, 0xe9, 0x37, 0xc8, 0x1b, 0x05, 0xfc, 0x08, 0xa5,
0x0e, 0x04, 0x07, 0xdb, 0xfa, 0xfe, 0x09, 0x23, 0xf9, 0xb5, 0xf5, 0x1c,
0xef, 0xff, 0xfd, 0xde, 0xdf, 0xf9, 0x12, 0xd5, 0x12, 0xb9, 0xd7, 0xdc,
0xd6, 0x16, 0xc7, 0x0c, 0xeb, 0xe4, 0xe9, 0xd4, 0xe5, 0xfd, 0xdf, 0xd5,
0xea, 0xf7, 0xef, 0x10, 0xfd, 0xf5, 0xf5, 0xfb, 0xd1, 0xfd, 0xf5, 0x0d,
0xe8, 0xf3, 0x04, 0xf0, 0x00, 0xd7, 0xe5, 0xf5, 0xf6, 0xeb, 0xfe, 0xf6,
0x02, 0x01, 0xef, 0xf4, 0xfb, 0x10, 0xe6, 0x00, 0x03, 0xf4, 0x02, 0x04,
0xf7, 0x07, 0xf8, 0xfb, 0x01, 0x05, 0x05, 0x1f, 0xf2, 0x0a, 0xfc, 0x26,
0x2e, 0xf8, 0xf9, 0x15, 0xfa, 0x02, 0x0a, 0xe8, 0x01, 0x02, 0x01, 0x0a,
0x18, 0x16, 0xf4, 0xfd, 0xf7, 0xfe, 0xf9, 0x01, 0x03, 0x01, 0x0a, 0x0e,
0x00, 0xfb, 0x09, 0xff, 0x11, 0xfd, 0x06, 0x06, 0x01, 0x0c, 0x0d, 0x15,
0x05, 0x0b, 0xff, 0x06, 0x0f, 0x0b, 0x0b, 0x09, 0x02, 0x0a, 0x0e, 0x0f,
0x0c, 0xfe, 0x0f, 0x06, 0xfc, 0x0e, 0x00, 0xf2, 0x05, 0x0b, 0xf1, 0x05,
0xef, 0x10, 0xef, 0x19, 0xf7, 0xf3, 0xec, 0x0a, 0xef, 0x02, 0x0b, 0x16,
0xf3, 0xfd, 0x16, 0xf8, 0xf4, 0x12, 0x03, 0xf6, 0xee, 0x01, 0x08, 0xfc,
0x17, 0xee, 0xfd, 0x2a, 0xef, 0xeb, 0xd8, 0xc7, 0x10, 0xf4, 0x0e, 0xa3,
0x28, 0xfe, 0xeb, 0xd1, 0xf0, 0x36, 0xd0, 0x1f, 0xf9, 0xfc, 0x02, 0xbc,
0x09, 0x0d, 0xfb, 0xdd, 0xe9, 0xf2, 0xf2, 0x20, 0xf0, 0x87, 0xf6, 0x0c,
0xd2, 0xfd, 0xd7, 0xb9, 0xc3, 0xfd, 0x28, 0xd2, 0x17, 0xba, 0xd7, 0xb9,
0xe8, 0x2c, 0xd7, 0x0b, 0xe4, 0xf0, 0x07, 0xb8, 0xfb, 0x0f, 0xeb, 0xeb,
0xf0, 0xfe, 0xf5, 0x18, 0xfe, 0xf1, 0x01, 0xf6, 0xdc, 0x0a, 0xe6, 0xed,
0xf0, 0x04, 0x0c, 0xf5, 0x17, 0x02, 0xf4, 0xfd, 0x00, 0x0c, 0x06, 0xff,
0xfe, 0x09, 0xfe, 0xff, 0xea, 0xfe, 0x04, 0xf0, 0xef, 0x00, 0x04, 0x0d,
0xfe, 0xfe, 0xfe, 0xe1, 0x02, 0x01, 0x04, 0x11, 0xfd, 0x11, 0x01, 0x11,
0x12, 0xf2, 0x1c, 0x06, 0xf8, 0x0d, 0x12, 0xf7, 0xf3, 0x0b, 0x02, 0x08,
0x0d, 0x30, 0xfd, 0xf3, 0xfa, 0x00, 0xea, 0xf7, 0x0c, 0x01, 0x1b, 0x02,
0xfe, 0xf7, 0xfb, 0x05, 0x0d, 0x09, 0x12, 0x0a, 0x07, 0x07, 0x05, 0x09,
0x10, 0x00, 0x02, 0x02, 0x0f, 0xfe, 0x0d, 0x11, 0x01, 0x01, 0x09, 0x00,
0x11, 0xf8, 0x0b, 0x0a, 0xf1, 0xfb, 0x0f, 0xf4, 0xfc, 0x0a, 0xfd, 0xff,
0xfe, 0x0b, 0xff, 0x07, 0xf9, 0xec, 0xf9, 0x00, 0xf5, 0xf1, 0xfc, 0xf8,
0xe5, 0x0a, 0xf1, 0xea, 0xfd, 0xed, 0x07, 0xfe, 0xf4, 0xfe, 0xef, 0xf6,
0xec, 0xe7, 0xf1, 0x28, 0xef, 0xe7, 0xf8, 0xd7, 0xfe, 0xf1, 0x09, 0xc2,
0x1f, 0x09, 0xd9, 0xd1, 0xea, 0x3b, 0xd3, 0x21, 0x08, 0xff, 0xf8, 0xcf,
0x00, 0x15, 0x04, 0xf3, 0xde, 0x02, 0x09, 0x19, 0xef, 0xb8, 0xe2, 0x09,
0xc7, 0xef, 0xd1, 0xbe, 0xf7, 0xf9, 0x15, 0xb7, 0xfa, 0xf0, 0xc9, 0xe3,
0xeb, 0x0b, 0xce, 0x09, 0xfa, 0xed, 0xfc, 0xf7, 0xfe, 0x03, 0xdc, 0xf4,
0xef, 0xf1, 0xdd, 0x02, 0xfc, 0xec, 0xf3, 0x05, 0x04, 0x0d, 0xfb, 0xfb,
0xf9, 0xf9, 0x15, 0xf8, 0x22, 0xdf, 0xf6, 0xff, 0xfb, 0xea, 0xfc, 0xf3,
0xf7, 0x03, 0x01, 0x04, 0xf8, 0x0d, 0xf6, 0xf0, 0xf5, 0x06, 0x01, 0xff,
0xf8, 0x1b, 0xfb, 0xdf, 0x05, 0x00, 0xf0, 0x20, 0x00, 0x10, 0xf1, 0x0d,
0x14, 0xfd, 0x03, 0xfb, 0xfc, 0xf7, 0x25, 0xe7, 0x05, 0xf5, 0xfe, 0x0b,
0x03, 0x18, 0xfe, 0x0a, 0x05, 0x20, 0xf7, 0x04, 0x01, 0xff, 0x00, 0x09,
0x05, 0x1b, 0x02, 0xf6, 0x08, 0xf2, 0x11, 0xf6, 0xf2, 0x0c, 0x03, 0xfa,
0xfe, 0x03, 0x01, 0x03, 0x09, 0x09, 0x09, 0x0c, 0xfa, 0xf4, 0xfa, 0x00,
0x0a, 0x26, 0x15, 0xfa, 0xe7, 0xeb, 0xcc, 0xf8, 0xea, 0xed, 0x11, 0xf4,
0xff, 0x00, 0xf6, 0xef, 0x0a, 0x01, 0xfa, 0xda, 0xe9, 0x0a, 0xf6, 0xf9,
0xea, 0xf9, 0xe5, 0xf4, 0x02, 0x0c, 0xf3, 0xe2, 0xe4, 0xe4, 0xe0, 0xf4,
0xec, 0xcf, 0xf5, 0x23, 0xd1, 0xf1, 0xab, 0xef, 0xe1, 0xf5, 0xeb, 0xbc,
0x29, 0xf0, 0xd9, 0xcf, 0xce, 0x1b, 0xad, 0x13, 0xf4, 0xf4, 0xe9, 0xd8,
0xf2, 0x1d, 0xe3, 0xe3, 0xd9, 0x00, 0xf4, 0x0d, 0xff, 0xc2, 0xfc, 0xf3,
0xd1, 0x12, 0xf6, 0xd4, 0xdf, 0x03, 0xfe, 0xb6, 0x0b, 0xad, 0xbb, 0xda,
0xec, 0x11, 0xd5, 0x0f, 0xef, 0xff, 0xfe, 0xc2, 0xf0, 0x14, 0xf2, 0xf4,
0xf2, 0x0c, 0xff, 0x04, 0xff, 0xf4, 0xfa, 0xe6, 0xe6, 0x0a, 0x02, 0x3e,
0x09, 0x16, 0xf4, 0xf5, 0x21, 0xf6, 0xf7, 0xfe, 0x07, 0xef, 0xfd, 0x03,
0x05, 0xf8, 0xfc, 0x0a, 0xf0, 0x1a, 0xfb, 0xf5, 0xf4, 0x07, 0x04, 0x05,
0x0b, 0x2b, 0x0a, 0xfc, 0xfe, 0x1b, 0x0d, 0x18, 0xfd, 0x0b, 0x08, 0x1d,
0x1b, 0x1e, 0x0e, 0x0b, 0xfd, 0x2d, 0x27, 0x14, 0x07, 0x1c, 0xfa, 0x00,
0x07, 0x1d, 0x05, 0x08, 0xf1, 0x07, 0x02, 0x10, 0xf6, 0xe2, 0xff, 0xfb,
0xd9, 0xee, 0xe9, 0xea, 0xce, 0xe9, 0xe1, 0xe7, 0xef, 0xd3, 0xe3, 0xf8,
0xf8, 0xfa, 0xe7, 0xf9, 0xd0, 0xe2, 0xdf, 0xf6, 0x03, 0xf5, 0xe2, 0xef,
0xed, 0xee, 0xfc, 0x07, 0x13, 0xe7, 0x17, 0xff, 0xfb, 0x0b, 0xfc, 0x0e,
0xef, 0x00, 0x16, 0x0b, 0x09, 0xe5, 0x05, 0x07, 0x02, 0xf3, 0xff, 0x06,
0x02, 0x04, 0x11, 0xfb, 0x0d, 0x07, 0xf3, 0x0f, 0x05, 0xfc, 0x0a, 0x07,
0x0d, 0x21, 0x1f, 0x08, 0x14, 0x18, 0xfc, 0x1f, 0x04, 0x10, 0x38, 0x0f,
0x15, 0x12, 0x0d, 0x0e, 0x25, 0x11, 0x0b, 0x09, 0x10, 0x19, 0x02, 0x13,
0x03, 0x11, 0x17, 0x16, 0xf2, 0x0a, 0x16, 0x17, 0x05, 0x0f, 0x15, 0x25,
0x0f, 0xff, 0x26, 0x26, 0x0e, 0x06, 0x31, 0x1a, 0x17, 0x18, 0x1f, 0x13,
0x0e, 0x20, 0x1c, 0x22, 0x18, 0x15, 0x0b, 0x10, 0x08, 0x1d, 0x09, 0x1c,
0x21, 0x08, 0x0c, 0x0d, 0x0a, 0x0b, 0x21, 0x11, 0x18, 0x29, 0x22, 0x1c,
0x10, 0x0e, 0x30, 0x14, 0x28, 0x0b, 0x14, 0x2e, 0x17, 0xf8, 0x2c, 0x07,
0x13, 0x13, 0x09, 0x18, 0x03, 0x11, 0x04, 0x1e, 0x1f, 0x25, 0x1f, 0x01,
0x19, 0x14, 0x24, 0x11, 0x08, 0x10, 0xfc, 0x05, 0x38, 0x2b, 0x12, 0x28,
0x04, 0x26, 0x1d, 0x11, 0x15, 0x11, 0x0e, 0x18, 0x0b, 0x1b, 0x0c, 0x0f,
0x1d, 0x0e, 0x10, 0x1f, 0x16, 0x1a, 0x12, 0x09, 0xed, 0xf0, 0x01, 0xf9,
0xed, 0x04, 0xff, 0xf7, 0xf9, 0xf1, 0xe0, 0x05, 0xfe, 0xe3, 0xd6, 0xed,
0xf8, 0xfe, 0xec, 0x12, 0xed, 0xf8, 0xfc, 0x07, 0xf3, 0x0a, 0xee, 0xf8,
0xf8, 0xff, 0xee, 0x08, 0xf1, 0x02, 0x01, 0x07, 0x07, 0x06, 0x16, 0x12,
0xfa, 0x06, 0x16, 0x01, 0x18, 0xeb, 0xfd, 0xfd, 0xfc, 0xf9, 0xfc, 0x11,
0x02, 0x00, 0x05, 0xfe, 0x05, 0x20, 0xf8, 0xfe, 0xfe, 0xee, 0x03, 0x0d,
0x02, 0x01, 0x22, 0x08, 0x10, 0x01, 0xf6, 0x14, 0x06, 0x0f, 0x05, 0x0e,
0xfd, 0x03, 0xf7, 0x0b, 0x0b, 0x07, 0x0c, 0x1c, 0x18, 0x0d, 0x08, 0x04,
0x06, 0x0f, 0x11, 0x07, 0x17, 0xfd, 0x08, 0x0b, 0x10, 0x09, 0x0d, 0x13,
0x25, 0xfe, 0xfc, 0x07, 0x19, 0x0d, 0x0f, 0x14, 0x02, 0x0d, 0x02, 0x04,
0x20, 0x0b, 0x12, 0x30, 0x1d, 0x20, 0x1b, 0x0c, 0x27, 0x1a, 0x0e, 0x1b,
0x29, 0x10, 0x1f, 0x07, 0x11, 0x1b, 0x24, 0x04, 0x18, 0x1e, 0x19, 0x1c,
0x15, 0x02, 0x02, 0x07, 0x16, 0x0f, 0x0f, 0x18, 0x19, 0x0f, 0x1e, 0x00,
0x16, 0x13, 0x14, 0x1b, 0xfc, 0x13, 0x1b, 0x25, 0x0f, 0x13, 0x01, 0x11,
0x0e, 0x2e, 0x1c, 0x18, 0x0d, 0x24, 0x1c, 0x10, 0x1c, 0x13, 0x03, 0x1c,
0x03, 0x05, 0x11, 0x0f, 0x22, 0xfe, 0x16, 0x1d, 0x06, 0x17, 0x0d, 0x14,
0x08, 0x14, 0x12, 0x1d, 0x0e, 0x15, 0x07, 0x19, 0xfe, 0xce, 0xf6, 0x00,
0xfb, 0xf2, 0xe8, 0xf5, 0xdd, 0xf4, 0xe5, 0xef, 0xfa, 0xe6, 0xe0, 0x02,
0xfb, 0x06, 0xfe, 0x0a, 0xee, 0xfc, 0xf5, 0xfa, 0x0e, 0xfd, 0xdf, 0x03,
0xf6, 0xf4, 0xec, 0xff, 0xfc, 0xf7, 0x0c, 0xf5, 0x08, 0x10, 0xf0, 0x00,
0x05, 0x02, 0x2d, 0x0f, 0x00, 0xe4, 0x13, 0x07, 0x03, 0xfc, 0x04, 0x06,
0x0d, 0x00, 0xf0, 0x06, 0xfa, 0x07, 0xf3, 0xff, 0xfb, 0xff, 0x1a, 0xfe,
0x13, 0x11, 0x16, 0xfb, 0x08, 0x09, 0x07, 0x15, 0x0b, 0x0e, 0x21, 0x01,
0x17, 0x04, 0xfb, 0x0e, 0x11, 0x0d, 0x14, 0x00, 0x10, 0x08, 0x03, 0x18,
0x0c, 0x1c, 0xf6, 0xfe, 0x0c, 0x1c, 0x04, 0x0e, 0x0d, 0x13, 0x2b, 0x21,
0x16, 0x05, 0x00, 0x0d, 0x17, 0x03, 0x22, 0xfe, 0x1c, 0x10, 0x18, 0x19,
0x14, 0x2e, 0x0e, 0x28, 0x18, 0x08, 0x18, 0x0a, 0x1a, 0x13, 0x12, 0x13,
0x1a, 0x05, 0x0f, 0x19, 0xfe, 0x0a, 0x27, 0x0a, 0x0f, 0x1e, 0x13, 0x1a,
0x09, 0x03, 0x1a, 0x08, 0x0d, 0x04, 0x1c, 0x0d, 0x07, 0xf1, 0x24, 0x0f,
0x13, 0x13, 0xff, 0x1b, 0xfe, 0x0e, 0x11, 0x22, 0x05, 0x0c, 0x0c, 0x05,
0x03, 0x2a, 0x13, 0x18, 0x16, 0x2d, 0x10, 0xfa, 0x18, 0x0d, 0x06, 0x17,
0x1e, 0x22, 0x2b, 0x15, 0x24, 0x08, 0x27, 0x0e, 0x18, 0x14, 0x15, 0x18,
0x07, 0x15, 0x29, 0x20, 0x27, 0x08, 0x00, 0x11, 0xe5, 0xd9, 0x06, 0xf8,
0xea, 0xd6, 0xea, 0xfc, 0xe0, 0xed, 0xe0, 0x03, 0x11, 0xd1, 0xe3, 0xf9,
0xeb, 0xf2, 0x01, 0x05, 0xec, 0xf6, 0xf6, 0xff, 0xf2, 0xf6, 0xdd, 0x07,
0xee, 0xf6, 0xfa, 0x04, 0xf6, 0xfb, 0x08, 0xfa, 0xf9, 0xfd, 0xff, 0x0b,
0x0c, 0x08, 0x1f, 0x04, 0xff, 0xd8, 0x02, 0x02, 0x07, 0xff, 0xfe, 0x0c,
0xf8, 0x04, 0x06, 0x0f, 0xf9, 0x02, 0x03, 0x02, 0x03, 0x04, 0xf5, 0x16,
0xe6, 0x0b, 0x0d, 0xf0, 0x12, 0x17, 0x2c, 0x07, 0x06, 0x18, 0x27, 0x10,
0xf8, 0x04, 0x11, 0x15, 0x02, 0x09, 0x17, 0xf7, 0xfd, 0x01, 0xf0, 0x0f,
0x03, 0x13, 0x04, 0xff, 0x09, 0x05, 0x0e, 0x09, 0x11, 0x01, 0xf6, 0x22,
0x11, 0x19, 0x0c, 0x00, 0x08, 0x11, 0xfd, 0x0b, 0xf4, 0x09, 0x10, 0xff,
0x17, 0x30, 0x0c, 0x08, 0x0b, 0x0d, 0x0f, 0x05, 0x15, 0x0c, 0x24, 0x1b,
0x18, 0xf7, 0x12, 0x1f, 0x07, 0xfc, 0x10, 0x10, 0x03, 0x0c, 0x0b, 0x0a,
0x01, 0x01, 0x1b, 0xfe, 0x1d, 0xe9, 0x16, 0x16, 0x12, 0xfc, 0x0a, 0xe2,
0x10, 0x11, 0x04, 0x19, 0x09, 0x0e, 0x07, 0x1d, 0x09, 0x10, 0x02, 0x04,
0x13, 0x1d, 0x04, 0x0a, 0x00, 0x16, 0x0f, 0x08, 0x11, 0x20, 0x24, 0x12,
0x0b, 0x01, 0x0d, 0x10, 0x22, 0x07, 0x1c, 0x07, 0x1c, 0x14, 0x14, 0x01,
0xf8, 0x06, 0x0c, 0x23, 0x0d, 0x04, 0x04, 0x07, 0xf4, 0xed, 0xfc, 0x06,
0xd8, 0xfe, 0xff, 0x05, 0xfa, 0x00, 0xea, 0xec, 0xff, 0xd2, 0xf5, 0x05,
0xf7, 0xfb, 0xed, 0x16, 0xe2, 0x00, 0xfb, 0xf5, 0xe8, 0x07, 0xe0, 0xfa,
0xdb, 0xff, 0xfc, 0xf9, 0xf3, 0xf9, 0x00, 0xfc, 0x00, 0x17, 0xf1, 0x0e,
0x0f, 0xf6, 0x00, 0xf5, 0x11, 0xd7, 0xf6, 0x01, 0x0a, 0xfa, 0xff, 0x07,
0xfb, 0xfc, 0x02, 0x0a, 0xf5, 0x05, 0xfd, 0x03, 0xf0, 0xf5, 0x1a, 0x00,
0xfe, 0x07, 0xec, 0xf9, 0xff, 0x19, 0x0a, 0x0b, 0x11, 0x11, 0x14, 0x0b,
0x1a, 0xf8, 0x0b, 0x20, 0x15, 0x0f, 0xf5, 0x1b, 0x0b, 0x0a, 0x16, 0x0a,
0xf7, 0x06, 0xf7, 0x09, 0x03, 0xfe, 0xfd, 0x18, 0xf3, 0x14, 0x09, 0x1b,
0x0c, 0xf6, 0x06, 0x06, 0x04, 0x14, 0x26, 0xf7, 0x03, 0x1d, 0x03, 0xf8,
0x0f, 0x25, 0x0e, 0x22, 0x1a, 0x01, 0x07, 0xf3, 0x10, 0x07, 0x10, 0xfc,
0xfa, 0x07, 0x13, 0x07, 0xf6, 0xf9, 0x15, 0x11, 0x03, 0x1a, 0x0b, 0x1a,
0x07, 0x01, 0x05, 0x08, 0x06, 0xde, 0x0c, 0x14, 0x0b, 0x0b, 0x05, 0x0b,
0x09, 0x0a, 0xf3, 0x17, 0xfd, 0x04, 0xf7, 0x0a, 0x00, 0x05, 0x02, 0x03,
0xfa, 0x12, 0x08, 0x04, 0x0f, 0x35, 0x20, 0x09, 0x1b, 0x2b, 0x26, 0x19,
0x1e, 0xf5, 0x01, 0x07, 0x1e, 0xf1, 0x26, 0x06, 0x19, 0x03, 0x0d, 0x0f,
0x0e, 0x18, 0xfe, 0x16, 0x03, 0x16, 0x0d, 0x02, 0xe6, 0xdb, 0x04, 0x05,
0xeb, 0xdf, 0x06, 0x00, 0xe6, 0xf3, 0xe5, 0xe7, 0xed, 0xc9, 0xf3, 0xf0,
0x05, 0xfe, 0xf9, 0x06, 0xe5, 0xf2, 0xf4, 0xf6, 0xf7, 0x07, 0xd5, 0xf8,
0xef, 0xf3, 0xfa, 0x04, 0xe7, 0x0e, 0x04, 0xfe, 0x11, 0x05, 0xd4, 0x04,
0xf7, 0x05, 0x05, 0x0f, 0x17, 0xe5, 0xf2, 0x0e, 0xff, 0xf4, 0x03, 0x00,
0xf9, 0xf9, 0xf8, 0x0d, 0xe9, 0x09, 0xfc, 0xfb, 0xfb, 0x01, 0x0f, 0x01,
0x06, 0x18, 0x22, 0x0f, 0x0a, 0x24, 0x18, 0x09, 0x05, 0x0b, 0x21, 0x19,
0x0b, 0xf3, 0x14, 0xfb, 0x12, 0x11, 0x17, 0x14, 0x11, 0x0a, 0x02, 0x0b,
0x06, 0xfb, 0x0d, 0x07, 0x24, 0x14, 0x07, 0x04, 0x08, 0x0e, 0x0b, 0x15,
0x0d, 0x0d, 0x03, 0x14, 0x20, 0x0d, 0x24, 0x14, 0xff, 0x0b, 0x13, 0x0b,
0x1e, 0x06, 0x0c, 0x1a, 0x21, 0x08, 0x02, 0x00, 0x13, 0x1f, 0x13, 0x0c,
0x0e, 0x16, 0x10, 0x17, 0x0f, 0x00, 0x20, 0xf0, 0x1a, 0xfd, 0x03, 0x14,
0xfa, 0xf7, 0x24, 0x04, 0x27, 0xf5, 0x0b, 0x16, 0x06, 0xfd, 0x18, 0x12,
0x12, 0x06, 0x11, 0x10, 0x04, 0x1c, 0x01, 0x10, 0x09, 0x0b, 0x0e, 0x0b,
0x01, 0x17, 0x03, 0x01, 0x1a, 0x0d, 0x13, 0x13, 0x18, 0x12, 0x17, 0x13,
0x0f, 0x08, 0x1c, 0x1c, 0x17, 0xf4, 0x12, 0x2b, 0x14, 0x05, 0x0c, 0x0f,
0x0b, 0x0e, 0x09, 0x23, 0x03, 0x18, 0x0a, 0x0f, 0xe0, 0xdb, 0xed, 0x00,
0xeb, 0xff, 0x00, 0xed, 0xe6, 0xe1, 0xbe, 0xe5, 0x0c, 0xc5, 0xdc, 0xfc,
0xe7, 0x22, 0xf1, 0x21, 0xf6, 0xe7, 0xff, 0x04, 0xf7, 0x19, 0xd3, 0xfe,
0xe7, 0xe9, 0xed, 0xfa, 0xef, 0xeb, 0x0c, 0xfb, 0x0a, 0x06, 0x07, 0x01,
0xf3, 0x02, 0x09, 0x0c, 0x2b, 0xa3, 0xf6, 0x09, 0x1a, 0x0d, 0x0c, 0x1e,
0xfd, 0xff, 0x0b, 0x07, 0xe7, 0x2b, 0xd0, 0xfe, 0xe8, 0x10, 0x02, 0x12,
0xc9, 0x16, 0x0b, 0xf7, 0x17, 0x1a, 0x03, 0x1d, 0x01, 0x00, 0x03, 0x22,
0x20, 0xe6, 0x03, 0x1b, 0x19, 0x1a, 0x1d, 0x24, 0x0f, 0x10, 0xfe, 0x15,
0x10, 0x33, 0x12, 0x08, 0x11, 0x07, 0xf9, 0x00, 0x15, 0x24, 0x10, 0x0e,
0x11, 0x13, 0xfd, 0x0f, 0x0e, 0x03, 0x15, 0x09, 0x2a, 0x04, 0x16, 0x07,
0x13, 0x26, 0x10, 0x14, 0x11, 0x15, 0x11, 0x0e, 0x01, 0x32, 0x0b, 0x17,
0x14, 0x0c, 0x02, 0x02, 0x01, 0xf7, 0x14, 0x14, 0xf7, 0x23, 0x11, 0x0b,
0x00, 0x04, 0x08, 0x0c, 0x27, 0xfc, 0x0f, 0x11, 0x0c, 0x08, 0x16, 0x18,
0x12, 0x06, 0x07, 0x07, 0x08, 0x17, 0xfb, 0x1b, 0x0b, 0x12, 0x06, 0x00,
0x19, 0x1c, 0x09, 0x08, 0x0e, 0x11, 0x05, 0xfa, 0x11, 0x1a, 0xf0, 0x24,
0x0c, 0x1c, 0x10, 0x0c, 0x1a, 0xfe, 0x19, 0x09, 0x1f, 0x12, 0x0a, 0x14,
0x0d, 0xee, 0x0a, 0x18, 0x1c, 0x23, 0x0a, 0x0e, 0xfa, 0x02, 0x13, 0xf4,
0x01, 0x07, 0x03, 0x01, 0x09, 0xff, 0xef, 0x16, 0x0e, 0xea, 0x00, 0x0d,
0x0c, 0xf1, 0xf9, 0xe5, 0xf7, 0x05, 0xfa, 0x14, 0x05, 0x02, 0xf3, 0xfd,
0xff, 0xff, 0xf5, 0x02, 0x18, 0x0c, 0xfa, 0x2c, 0x18, 0xf1, 0x0d, 0xfc,
0x0c, 0x07, 0xf1, 0xec, 0xf8, 0x16, 0x14, 0xeb, 0x14, 0x1f, 0xfc, 0x16,
0x11, 0x06, 0xfe, 0xfd, 0x09, 0x10, 0x1b, 0x0b, 0x13, 0x07, 0x1a, 0x10,
0xca, 0xd7, 0xf0, 0xb3, 0xe3, 0xdf, 0xdb, 0xdc, 0xcd, 0xe0, 0xee, 0xcf,
0xe3, 0xb2, 0xcc, 0xca, 0xcc, 0xca, 0xd4, 0xd6, 0xd0, 0xd9, 0xd2, 0xe3,
0xe7, 0xcb, 0xc9, 0xdd, 0xda, 0xde, 0xd7, 0xd9, 0xd0, 0xed, 0xe1, 0x0d,
0xf7, 0xf7, 0xd4, 0xd6, 0xcf, 0xf3, 0xfb, 0xcd, 0xef, 0xf4, 0xe3, 0xf4,
0xdd, 0xeb, 0xd7, 0x0b, 0xdb, 0xec, 0xd5, 0xdb, 0xf2, 0xf4, 0xe5, 0xed,
0xe9, 0xe2, 0xef, 0xf6, 0xde, 0xe4, 0xf4, 0x0a, 0xe4, 0xfc, 0xe3, 0xe8,
0xe7, 0xec, 0x0b, 0xcc, 0xeb, 0xe6, 0xd8, 0xd4, 0xd4, 0xf2, 0xf1, 0xfb,
0xe7, 0xfa, 0xe8, 0xf0, 0x00, 0xeb, 0xf6, 0xf7, 0xea, 0xea, 0xf3, 0xe9,
0xec, 0xf2, 0xf7, 0xe4, 0xef, 0xef, 0xec, 0xf3, 0xe2, 0xf5, 0xdf, 0xfa,
0xe4, 0xe7, 0xf3, 0x02, 0xe7, 0xf3, 0xf0, 0xf7, 0x03, 0xf1, 0xfd, 0xff,
0xf4, 0xe0, 0xf3, 0xe4, 0xf2, 0xf0, 0x05, 0xe9, 0xeb, 0x04, 0x00, 0xfc,
0xfd, 0x04, 0x15, 0x01, 0x08, 0x08, 0xf4, 0x07, 0x0e, 0xea, 0xf3, 0x02,
0x08, 0xec, 0xfb, 0xfb, 0x08, 0x01, 0xfb, 0x09, 0xf7, 0x0a, 0xef, 0xfe,
0x02, 0x08, 0xfa, 0xfd, 0x11, 0x0c, 0xf1, 0x24, 0x00, 0xeb, 0xf5, 0xe8,
0x09, 0x01, 0x05, 0xee, 0xed, 0x13, 0x06, 0xf9, 0xff, 0x21, 0x0a, 0x13,
0x15, 0x12, 0x11, 0xfd, 0x18, 0xf5, 0x12, 0x00, 0x0a, 0x08, 0x19, 0x05,
0xdd, 0xcd, 0xe0, 0xab, 0xe8, 0xdf, 0xe2, 0xe9, 0xda, 0xe1, 0xd6, 0xf6,
0xc6, 0xc8, 0xd0, 0xe5, 0xe6, 0xc8, 0xd4, 0xc8, 0xbe, 0xd2, 0xee, 0xc7,
0xe9, 0xd9, 0xd7, 0xdb, 0xd9, 0xdf, 0xd7, 0xe4, 0xdc, 0xe6, 0xee, 0x0d,
0xdf, 0xe2, 0xea, 0xd6, 0xea, 0xd8, 0x05, 0xda, 0xf6, 0xfa, 0xe3, 0xe0,
0xd4, 0xf0, 0xc6, 0x06, 0xf5, 0xd4, 0xeb, 0xe0, 0xee, 0xdb, 0xe7, 0xee,
0xf1, 0xea, 0xe7, 0xf1, 0xd9, 0xd5, 0xf2, 0x0c, 0xe6, 0xed, 0xe8, 0xd8,
0xdb, 0xd8, 0x19, 0xed, 0xf8, 0xc9, 0xde, 0xec, 0xd2, 0x06, 0xd1, 0x08,
0xfc, 0xe1, 0xe7, 0xf1, 0xe7, 0xe4, 0xe0, 0xf0, 0xeb, 0xee, 0x00, 0xff,
0xf6, 0xe5, 0x06, 0x00, 0xdf, 0xff, 0xf5, 0x12, 0xe6, 0xf8, 0x1f, 0x06,
0xe8, 0xfa, 0xf6, 0xf1, 0xf1, 0xfe, 0xfa, 0xf0, 0x00, 0xf3, 0xf9, 0xfc,
0x04, 0xe5, 0xe8, 0xf7, 0xf0, 0xfb, 0x11, 0x05, 0xff, 0x03, 0x04, 0xf9,
0xfa, 0x10, 0x0e, 0x05, 0xf7, 0x11, 0x05, 0x07, 0xfd, 0xf0, 0x00, 0x08,
0xf8, 0xfd, 0xfa, 0x0c, 0xfa, 0xef, 0xf9, 0x09, 0xf2, 0xf9, 0xfe, 0x0a,
0x00, 0x0c, 0xeb, 0x00, 0x04, 0x0d, 0xfb, 0x0e, 0x0d, 0xee, 0x05, 0xfe,
0x10, 0x07, 0x05, 0xf8, 0xf7, 0x10, 0x0a, 0xf9, 0xfb, 0x14, 0x0f, 0x06,
0x13, 0xf9, 0x18, 0xfc, 0x12, 0xf7, 0x05, 0xfe, 0x11, 0xfc, 0x1d, 0x02,
0xf0, 0xd5, 0xe5, 0xb8, 0xd9, 0x0a, 0x02, 0xf7, 0xce, 0xe8, 0xdd, 0xf2,
0xea, 0xc3, 0xfc, 0xde, 0xe7, 0xc6, 0xdd, 0xb2, 0xd6, 0xd4, 0xcd, 0xec,
0xe3, 0xe5, 0xcf, 0xdb, 0xcc, 0xdd, 0xea, 0xd3, 0xec, 0xf0, 0xf2, 0x02,
0xe1, 0xe3, 0xe9, 0xe7, 0xef, 0xdf, 0xe8, 0xf2, 0xdf, 0x13, 0xe0, 0xdd,
0xe3, 0xdf, 0xe4, 0x1b, 0xe8, 0xe8, 0xf1, 0xc9, 0x0d, 0xe0, 0xe7, 0xdb,
0xe4, 0xeb, 0xf8, 0xee, 0xee, 0xf0, 0xf5, 0x11, 0xf9, 0xf8, 0xf6, 0xd5,
0xd3, 0xef, 0x08, 0xe5, 0xeb, 0xe5, 0xea, 0xd6, 0xe4, 0xec, 0xdf, 0xef,
0xf5, 0xf0, 0xf9, 0xf2, 0xf9, 0xf0, 0xf7, 0xe5, 0xf5, 0xe3, 0xff, 0x02,
0xe6, 0xe7, 0x07, 0xf0, 0xf5, 0xff, 0xeb, 0x1a, 0xe6, 0xf2, 0x17, 0x04,
0xe0, 0xf1, 0xd9, 0xfc, 0xf2, 0xef, 0xfc, 0xf2, 0xf2, 0xf9, 0xf4, 0xe5,
0xfb, 0xf5, 0xed, 0x02, 0xff, 0xf6, 0x09, 0xdd, 0xee, 0x03, 0x05, 0xfb,
0x09, 0x0f, 0x09, 0x0b, 0x03, 0xfe, 0xfb, 0xff, 0x06, 0x00, 0xf4, 0x0a,
0x06, 0x00, 0x0d, 0xe6, 0xef, 0xfd, 0xfd, 0x08, 0xfa, 0x0a, 0xf4, 0x00,
0xfb, 0x0f, 0xfb, 0x04, 0x1d, 0x08, 0xf8, 0x24, 0x09, 0xef, 0x15, 0xf1,
0xff, 0x00, 0xee, 0xf0, 0xe5, 0x1a, 0x0b, 0xea, 0x08, 0x11, 0x12, 0x1e,
0x0d, 0x0e, 0x0b, 0x07, 0x15, 0x02, 0x09, 0x01, 0x06, 0x08, 0x10, 0x00,
0xde, 0xe2, 0xda, 0xc6, 0xf1, 0xf4, 0xfe, 0xf7, 0xc9, 0xe9, 0xe4, 0xf8,
0xe4, 0xd4, 0xd0, 0xed, 0xe0, 0xc3, 0xf1, 0xbd, 0xd6, 0xce, 0xe3, 0xd8,
0xf1, 0xd5, 0xd3, 0xe3, 0xe6, 0xf5, 0xdb, 0xe1, 0xef, 0x03, 0xf6, 0xf1,
0xd4, 0xfa, 0xdf, 0xde, 0xf3, 0xe3, 0xf1, 0xe6, 0xf7, 0x06, 0xec, 0xe3,
0xcf, 0x08, 0xeb, 0x15, 0xf0, 0xe5, 0xe4, 0xed, 0xf2, 0xfe, 0xf0, 0xd5,
0xe4, 0xef, 0xf6, 0xe5, 0xed, 0xc7, 0x01, 0xf0, 0xdc, 0xef, 0xde, 0xec,
0xda, 0xfe, 0x14, 0xde, 0xea, 0xe6, 0xf7, 0xd8, 0xf7, 0x09, 0xe5, 0xff,
0xec, 0xf1, 0xe0, 0xde, 0xfc, 0xf3, 0xe8, 0xfa, 0xf2, 0xdf, 0x07, 0xf4,
0x00, 0xdb, 0x06, 0xe6, 0xec, 0xeb, 0xff, 0x02, 0xed, 0xed, 0x0b, 0xf0,
0xe2, 0xe2, 0xff, 0x06, 0xfc, 0xef, 0x0c, 0xe4, 0xfa, 0xf9, 0x02, 0x00,
0xec, 0xee, 0xe5, 0xfa, 0x03, 0xf6, 0x03, 0xe5, 0xf6, 0x00, 0x00, 0xf5,
0xf5, 0x00, 0x04, 0x04, 0xfd, 0xf7, 0xf4, 0x02, 0x08, 0xef, 0xfb, 0x0b,
0x06, 0xe7, 0x03, 0x06, 0xf9, 0xf5, 0x0d, 0x08, 0x04, 0x0a, 0xfe, 0xff,
0xff, 0x00, 0xf7, 0xf9, 0x15, 0x08, 0xe4, 0x0c, 0xfb, 0xe2, 0x06, 0xf5,
0x0d, 0xfb, 0x02, 0x03, 0xf9, 0xff, 0x02, 0xec, 0xfe, 0x07, 0x07, 0x0c,
0x14, 0x0d, 0xf4, 0xf6, 0x15, 0xfc, 0x06, 0x0b, 0x07, 0xff, 0x05, 0x03,
0xe7, 0xd2, 0xfc, 0xcc, 0xdb, 0xf4, 0xeb, 0xe5, 0xe2, 0xeb, 0xd3, 0xf8,
0xdf, 0xdc, 0xe2, 0xf8, 0xe6, 0xcc, 0xe9, 0xce, 0xe4, 0xdd, 0xe3, 0xe4,
0xd7, 0xe3, 0xca, 0xe0, 0xe1, 0xd9, 0xdf, 0xe5, 0xf8, 0xec, 0xeb, 0x0b,
0xed, 0xf8, 0xef, 0xd7, 0xf3, 0xf9, 0xea, 0xde, 0xe3, 0x08, 0xfa, 0xf1,
0xec, 0xee, 0xfc, 0x03, 0xe9, 0xf4, 0xe8, 0xda, 0x04, 0xe7, 0xee, 0xe7,
0xeb, 0xee, 0xf1, 0xeb, 0xd3, 0xe7, 0xf2, 0x0b, 0xdd, 0xff, 0xed, 0xf6,
0xe7, 0xd3, 0x14, 0xde, 0xe9, 0xd2, 0xd4, 0xd4, 0xd1, 0xf7, 0xd8, 0xf8,
0xf9, 0xfb, 0xf0, 0xe2, 0xf5, 0xe5, 0xf1, 0xe9, 0xed, 0xed, 0x04, 0xf0,
0xf3, 0xf7, 0xf9, 0xf2, 0xe7, 0xf5, 0xea, 0x11, 0xed, 0xdd, 0x0e, 0xfa,
0xf7, 0xe6, 0xed, 0xef, 0x03, 0xee, 0x02, 0xec, 0xfd, 0x04, 0x06, 0xef,
0xf6, 0xe4, 0xfd, 0xf9, 0xf5, 0xf1, 0x09, 0x01, 0xfa, 0x0b, 0x07, 0xf4,
0xfb, 0x04, 0x24, 0x07, 0xfc, 0x0c, 0xee, 0x0e, 0x07, 0xf0, 0x09, 0x09,
0x05, 0xe9, 0xfe, 0xf3, 0xf3, 0xf5, 0x06, 0x03, 0x06, 0x00, 0xf5, 0x03,
0xff, 0xf7, 0xf0, 0x08, 0x0d, 0x05, 0xea, 0x06, 0x10, 0xe7, 0xf5, 0xf2,
0x06, 0xf0, 0xf9, 0xe9, 0xf5, 0x14, 0x04, 0xed, 0xff, 0x17, 0x06, 0x22,
0x18, 0xfb, 0xf9, 0x06, 0x08, 0x00, 0x11, 0x07, 0x11, 0x00, 0x04, 0x00,
0xc6, 0xe2, 0xe3, 0xb8, 0xec, 0xfe, 0xec, 0xdf, 0xd6, 0xe4, 0xfc, 0x03,
0xd8, 0xcb, 0xcb, 0xf7, 0xd8, 0xb5, 0xdf, 0xc2, 0xcd, 0xdf, 0xed, 0xf8,
0xef, 0xe5, 0xe6, 0xf2, 0xe1, 0xeb, 0xd4, 0xdb, 0xeb, 0xe6, 0xdb, 0xf7,
0xe6, 0xfa, 0xe0, 0xf3, 0xdf, 0xe4, 0xeb, 0xe6, 0xf7, 0x01, 0xec, 0xdd,
0xdb, 0xf0, 0xe4, 0xed, 0x00, 0xf2, 0xe1, 0xdb, 0xe9, 0xf4, 0xfc, 0xcc,
0xd9, 0xf7, 0xeb, 0xe3, 0xd8, 0xc2, 0xf7, 0x16, 0xd7, 0xe5, 0xd4, 0xef,
0xcb, 0xe6, 0x06, 0xde, 0xee, 0xd9, 0xd5, 0xe4, 0xe2, 0xde, 0xdc, 0x1d,
0xf1, 0xf5, 0xfc, 0xdc, 0xf2, 0xe7, 0xec, 0xed, 0xd8, 0xeb, 0xe8, 0xf0,
0xe0, 0xea, 0xfc, 0x1d, 0xdd, 0xf7, 0xe5, 0x07, 0xf5, 0xe9, 0xfe, 0x10,
0xe3, 0xe7, 0xf7, 0xf0, 0xfb, 0xef, 0xf1, 0xfb, 0xf2, 0xeb, 0xf8, 0xde,
0x02, 0xf4, 0xda, 0x04, 0xec, 0xd8, 0x0b, 0x02, 0xfc, 0x0a, 0x03, 0xf0,
0x02, 0x03, 0x05, 0x06, 0x0a, 0x0f, 0xec, 0x22, 0x12, 0xeb, 0x11, 0x17,
0x0f, 0xeb, 0x02, 0x03, 0x0a, 0x07, 0x07, 0xf6, 0x02, 0xff, 0x08, 0x09,
0xf6, 0xf4, 0xea, 0x01, 0x2f, 0x0b, 0xfd, 0x1b, 0x0c, 0xf6, 0xed, 0xfd,
0x15, 0x0e, 0xfb, 0xe7, 0xe5, 0x1c, 0x06, 0xf2, 0xe8, 0x24, 0xfe, 0x20,
0x0e, 0x0b, 0xf4, 0x1b, 0x06, 0xe0, 0x0e, 0xf7, 0x06, 0xf9, 0x0e, 0xfd,
0xca, 0xcb, 0xe2, 0xcd, 0xe7, 0xf3, 0xf7, 0xe6, 0xde, 0xf5, 0x15, 0x00,
0xec, 0xc9, 0xe4, 0x01, 0xe7, 0xd3, 0xe2, 0xf6, 0xea, 0xd6, 0xe7, 0xe5,
0xe3, 0xeb, 0xcd, 0xe2, 0xd7, 0xee, 0xe8, 0xd1, 0x06, 0x0a, 0xf4, 0x09,
0xf4, 0xf0, 0xe0, 0xe5, 0xe6, 0xe3, 0xf3, 0xeb, 0xf9, 0xf2, 0xe1, 0xe8,
0xf4, 0xf8, 0xe6, 0x17, 0xfb, 0xdf, 0xf7, 0xf1, 0xfe, 0xed, 0xf9, 0xed,
0xe9, 0xe9, 0x03, 0xf0, 0xdb, 0xdd, 0xfb, 0xf7, 0xf5, 0xdc, 0xef, 0x04,
0xd9, 0xec, 0x08, 0xfa, 0xf2, 0xe6, 0xdd, 0xe3, 0xe5, 0xe6, 0xeb, 0x13,
0xef, 0xe8, 0xf5, 0xee, 0xf4, 0xfb, 0xe7, 0xfc, 0xf8, 0xeb, 0xf5, 0xfd,
0xe8, 0x0d, 0xf5, 0xf3, 0xf2, 0x01, 0xe7, 0x0d, 0xf4, 0xe8, 0x11, 0x11,
0xe3, 0xf6, 0xd8, 0xf5, 0xe3, 0xe7, 0xe3, 0xf6, 0xf2, 0xef, 0xf9, 0xfb,
0x02, 0xf1, 0xf7, 0xf3, 0xf4, 0xfd, 0x04, 0x05, 0x96, 0xe4, 0xff, 0xff,
0x04, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x95, 0xfe, 0xff, 0xff,
0xd7, 0x02, 0x00, 0x00, 0x2e, 0xfa, 0xff, 0xff, 0x97, 0x02, 0x00, 0x00,
0xb7, 0x00, 0x00, 0x00, 0x8d, 0x01, 0x00, 0x00, 0x20, 0x02, 0x00, 0x00,
0x3f, 0x05, 0x00, 0x00, 0x83, 0xff, 0xff, 0xff, 0x1e, 0x03, 0x00, 0x00,
0x6a, 0x05, 0x00, 0x00, 0xf5, 0x01, 0x00, 0x00, 0x9f, 0x07, 0x00, 0x00,
0xac, 0x02, 0x00, 0x00, 0x21, 0x01, 0x00, 0x00, 0xec, 0x01, 0x00, 0x00,
0x0d, 0xff, 0xff, 0xff, 0xfc, 0x03, 0x00, 0x00, 0xf8, 0x01, 0x00, 0x00,
0x4e, 0x03, 0x00, 0x00, 0x9c, 0xfc, 0xff, 0xff, 0xf3, 0xfe, 0xff, 0xff,
0x65, 0xf7, 0xff, 0xff, 0xce, 0x01, 0x00, 0x00, 0x1d, 0xfe, 0xff, 0xff,
0xda, 0x07, 0x00, 0x00, 0x45, 0xfe, 0xff, 0xff, 0x73, 0xfc, 0xff, 0xff,
0x1a, 0xfc, 0xff, 0xff, 0xbb, 0x00, 0x00, 0x00, 0x3c, 0xff, 0xff, 0xff,
0x23, 0x05, 0x00, 0x00, 0x22, 0xe5, 0xff, 0xff, 0x04, 0x00, 0x00, 0x00,
0x00, 0x12, 0x00, 0x00, 0xf9, 0xf7, 0xeb, 0x27, 0x09, 0xc0, 0xcc, 0xd9,
0x44, 0x0b, 0x14, 0x12, 0x10, 0xe3, 0xe6, 0x38, 0xec, 0xfc, 0xde, 0xc4,
0x02, 0xe1, 0x43, 0x9f, 0xb9, 0xc9, 0xbe, 0xfe, 0xdd, 0x0d, 0x06, 0xf2,
0x31, 0x94, 0x81, 0x0f, 0xaa, 0xd2, 0x0e, 0xd1, 0x2c, 0xe3, 0x9e, 0x0a,
0xbb, 0xe3, 0xce, 0xd4, 0x43, 0x2a, 0xf3, 0x0a, 0x04, 0x37, 0x12, 0xd8,
0xd6, 0x1e, 0xca, 0x41, 0x31, 0x37, 0x06, 0x00, 0xfe, 0xbb, 0xc5, 0x1b,
0x11, 0xe4, 0xd6, 0xe2, 0x14, 0xe1, 0xe4, 0xb6, 0x28, 0x18, 0x24, 0x2c,
0x78, 0xd2, 0xbf, 0xb4, 0xdb, 0xba, 0x25, 0x40, 0x34, 0xfe, 0x2b, 0xf8,
0x23, 0x1f, 0xac, 0x02, 0xf9, 0x1c, 0xf5, 0xda, 0x1a, 0xfa, 0xd2, 0xe6,
0xef, 0xf5, 0x13, 0x25, 0x10, 0x20, 0x60, 0xf7, 0x02, 0xc3, 0xd1, 0x10,
0xf3, 0xa2, 0x0a, 0xd6, 0xdf, 0xe4, 0xff, 0xe3, 0x33, 0x15, 0xdb, 0x10,
0x4f, 0xc3, 0xf2, 0xef, 0xfb, 0xa0, 0x32, 0xe8, 0x1a, 0xc8, 0x0d, 0x09,
0x0f, 0x04, 0x84, 0x0d, 0x2f, 0xd2, 0xd1, 0x35, 0x38, 0x4b, 0xfc, 0xee,
0x28, 0xfd, 0xd0, 0x56, 0xda, 0xfe, 0x37, 0x66, 0xfa, 0xad, 0xd0, 0xf7,
0x16, 0x20, 0x2f, 0xfe, 0x34, 0x28, 0xda, 0x2d, 0xdb, 0x62, 0x76, 0x2a,
0x01, 0xd1, 0xbd, 0xc4, 0xe6, 0x44, 0x27, 0xfe, 0x51, 0x54, 0xe8, 0x58,
0xdb, 0x20, 0xec, 0xdc, 0x12, 0xfd, 0x05, 0xf8, 0x3f, 0xd4, 0x09, 0x1e,
0x61, 0x07, 0x00, 0x32, 0xe9, 0x48, 0xf3, 0x7f, 0xf7, 0xa9, 0x04, 0xd1,
0xfe, 0x8f, 0x05, 0xf3, 0x2c, 0x47, 0x21, 0xeb, 0x62, 0x30, 0x31, 0x14,
0xfa, 0xb7, 0xbd, 0x07, 0x0a, 0x58, 0xa0, 0xe2, 0x34, 0xf0, 0x40, 0x1a,
0xda, 0x03, 0x05, 0xdb, 0x3c, 0xb5, 0xb3, 0x3a, 0x18, 0xa6, 0x3d, 0xf4,
0x0f, 0x34, 0xf9, 0xfe, 0x54, 0xd5, 0xf2, 0xdc, 0x50, 0xa7, 0xc0, 0xde,
0xf7, 0x08, 0xb0, 0xfa, 0x29, 0xcc, 0xd4, 0x55, 0xf8, 0xed, 0xcf, 0xed,
0x12, 0xa8, 0xbe, 0x2a, 0xfc, 0xfc, 0x38, 0x28, 0x53, 0xbc, 0x13, 0xf3,
0xca, 0xc5, 0xd7, 0xda, 0x02, 0x11, 0x04, 0xeb, 0x10, 0xd6, 0x16, 0x2c,
0x4f, 0xe8, 0x06, 0xcb, 0x2c, 0xe1, 0xd3, 0x0b, 0x17, 0x0c, 0x00, 0x14,
0x0f, 0xb0, 0xc6, 0x0f, 0xfa, 0xe2, 0xdb, 0x1a, 0x31, 0x06, 0xd4, 0xf6,
0x2c, 0xd0, 0x40, 0x7f, 0x3e, 0xcd, 0x69, 0x75, 0x43, 0xca, 0x14, 0x18,
0x17, 0x26, 0x2c, 0x3d, 0x3b, 0x1f, 0x04, 0xf5, 0xe2, 0xf0, 0x1a, 0xfd,
0xce, 0xf0, 0xed, 0xf7, 0xde, 0x25, 0xe0, 0xfd, 0x0d, 0xdb, 0x17, 0x1a,
0x12, 0xc0, 0x01, 0x23, 0x08, 0xab, 0xf7, 0xcc, 0xc5, 0xdc, 0xee, 0x00,
0xed, 0xea, 0xf8, 0x29, 0x1a, 0x2c, 0x11, 0x04, 0x09, 0x18, 0x48, 0x45,
0x08, 0x22, 0x5a, 0xf5, 0x0e, 0xd1, 0x0f, 0x0e, 0xef, 0xb9, 0x26, 0x3b,
0xf6, 0xee, 0xe4, 0x08, 0xf8, 0x2c, 0xe0, 0x00, 0xed, 0x16, 0xc6, 0xe7,
0xc6, 0xd0, 0xbe, 0xf2, 0xda, 0xf5, 0xc4, 0x0f, 0xd0, 0xf7, 0xa0, 0xdf,
0xfc, 0x16, 0xd1, 0x47, 0x2d, 0x12, 0xfa, 0x06, 0xff, 0x30, 0xda, 0x32,
0x13, 0x0d, 0xf2, 0xff, 0xfe, 0x57, 0x11, 0xd7, 0x35, 0xde, 0xfa, 0xbb,
0x13, 0xf6, 0xe0, 0x16, 0x09, 0x2d, 0x3e, 0xf8, 0xc0, 0x79, 0x02, 0xb8,
0xb8, 0xdd, 0xe3, 0xb0, 0xcc, 0xeb, 0xd4, 0xc4, 0xf9, 0xde, 0xed, 0x0e,
0x02, 0x63, 0x7f, 0xc0, 0xd7, 0xd2, 0x30, 0xd7, 0xb0, 0xbe, 0xec, 0xf4,
0xad, 0xc8, 0xd0, 0xa3, 0xf0, 0x4a, 0x05, 0x22, 0x30, 0x3b, 0xff, 0xf6,
0xf6, 0x48, 0xfe, 0xe5, 0x14, 0xc0, 0xfb, 0x1d, 0x0c, 0x36, 0x05, 0xfb,
0xf1, 0xd2, 0x11, 0xb4, 0xdb, 0xc9, 0xd5, 0xee, 0xd8, 0xca, 0xf4, 0xcd,
0xf0, 0x54, 0x3f, 0xe2, 0xf7, 0xf2, 0xcf, 0x1f, 0x00, 0xac, 0xe9, 0xf1,
0xea, 0xc7, 0xc8, 0xf7, 0xf6, 0x27, 0xfa, 0x24, 0x52, 0x1b, 0x02, 0xe1,
0xe8, 0xf1, 0xf6, 0x17, 0x03, 0xe9, 0x0f, 0x0a, 0xc5, 0xf0, 0x2d, 0xd6,
0xed, 0xe0, 0xd7, 0xdb, 0xeb, 0x12, 0xe7, 0xaa, 0x19, 0xdc, 0xc1, 0xc4,
0xd1, 0x26, 0x4e, 0xed, 0xae, 0xe5, 0xf7, 0x1a, 0xeb, 0xad, 0xd2, 0x2e,
0xff, 0xc2, 0xdc, 0x03, 0x1e, 0xcb, 0xde, 0xf5, 0x22, 0x0a, 0x37, 0xfe,
0x17, 0xf3, 0xe8, 0xe5, 0x12, 0xcd, 0x35, 0x2c, 0x1c, 0xad, 0xb4, 0xc0,
0x01, 0xcb, 0x2e, 0x12, 0xe2, 0xec, 0x16, 0x40, 0x23, 0x2a, 0x2f, 0x29,
0x1b, 0xd4, 0x87, 0x39, 0x58, 0xc3, 0x6a, 0x7d, 0x7c, 0x22, 0x09, 0x1e,
0xea, 0x22, 0xd1, 0x28, 0x3d, 0xef, 0x20, 0x04, 0xf3, 0x04, 0xf6, 0xff,
0x0b, 0x20, 0x0d, 0x05, 0x01, 0x4e, 0x29, 0x28, 0xd4, 0xce, 0xf0, 0xfd,
0xd6, 0xea, 0xed, 0x9b, 0xc6, 0xcf, 0x0d, 0x1e, 0x0f, 0x10, 0xd6, 0x0f,
0xf6, 0xad, 0x0f, 0xfd, 0xe6, 0x01, 0x2f, 0x76, 0xfb, 0x3d, 0x18, 0xe5,
0x11, 0x13, 0xd0, 0xf1, 0x29, 0xfa, 0xef, 0xf6, 0x0e, 0x05, 0x3e, 0x01,
0xe7, 0xeb, 0x1e, 0xf2, 0x19, 0x1b, 0x26, 0xb0, 0xc1, 0xe9, 0xd0, 0xe6,
0xc1, 0x07, 0xcc, 0x0a, 0x07, 0x30, 0x04, 0x06, 0x20, 0x1f, 0xec, 0x02,
0x0f, 0xad, 0xd9, 0xfb, 0x2f, 0x04, 0x14, 0x3b, 0x7f, 0xd6, 0x3a, 0x0e,
0xf1, 0xfc, 0x8f, 0x3c, 0x06, 0xc5, 0x0c, 0x04, 0x00, 0xcc, 0x6d, 0x37,
0xdd, 0xac, 0xd3, 0xf6, 0xde, 0x19, 0x20, 0xfe, 0x05, 0x16, 0xfc, 0xfc,
0x00, 0x0e, 0x25, 0x7e, 0xdd, 0x01, 0x34, 0x6c, 0xdf, 0x3a, 0xd5, 0x32,
0x1a, 0xef, 0xfb, 0x31, 0x5b, 0x7f, 0x18, 0xe6, 0x36, 0x56, 0xf2, 0xe0,
0x1f, 0xf8, 0x30, 0x2f, 0x1b, 0xe3, 0xcc, 0xe5, 0x2b, 0xa8, 0x59, 0x53,
0x23, 0xb2, 0xd3, 0xe4, 0x11, 0xe3, 0xae, 0xd0, 0x01, 0xde, 0x01, 0x9a,
0x40, 0xe2, 0xf4, 0x13, 0xda, 0x0d, 0x07, 0x14, 0x1b, 0x32, 0xed, 0xc7,
0xcc, 0x8a, 0x25, 0x41, 0x2f, 0x11, 0xcb, 0x1d, 0x00, 0xea, 0x1f, 0xf0,
0x2d, 0xf2, 0xe5, 0x30, 0xfa, 0x0d, 0xf7, 0x46, 0xe9, 0xc3, 0xfb, 0xff,
0xe8, 0xa8, 0x13, 0x41, 0xca, 0xde, 0xc5, 0xcd, 0x1b, 0xbe, 0x31, 0x26,
0xec, 0x32, 0xca, 0x43, 0xd9, 0xbd, 0xff, 0x05, 0x02, 0x05, 0xdf, 0x38,
0xb2, 0xb5, 0x28, 0xe0, 0x24, 0xd4, 0xfc, 0xd7, 0x0d, 0x05, 0x05, 0xde,
0x0a, 0xff, 0xcb, 0xbc, 0x0e, 0xa9, 0x04, 0xf9, 0x0e, 0xdc, 0xe0, 0x11,
0xf1, 0x0e, 0xe0, 0x2f, 0xd2, 0x42, 0xed, 0x1b, 0x38, 0xb3, 0xac, 0x0e,
0xf2, 0xcf, 0xcf, 0xe0, 0x39, 0xce, 0xce, 0xe0, 0xba, 0xfb, 0xd3, 0xe0,
0x18, 0xd6, 0x20, 0xff, 0xf5, 0x3b, 0x10, 0x04, 0xea, 0x5a, 0x7f, 0x50,
0x2b, 0x42, 0x08, 0xbb, 0xfc, 0xce, 0xd8, 0x5c, 0xcf, 0x27, 0xdf, 0x13,
0x0d, 0xcd, 0x1e, 0x3c, 0x34, 0xa4, 0xfb, 0xe6, 0xfc, 0xef, 0xde, 0x39,
0x0e, 0xd6, 0xea, 0x0a, 0x58, 0xaa, 0xce, 0xe3, 0xac, 0x1a, 0xb7, 0xc8,
0x12, 0x9b, 0xca, 0xe2, 0x1c, 0x72, 0x0a, 0xec, 0x33, 0x04, 0x04, 0x0d,
0xcf, 0x31, 0x5a, 0x37, 0x08, 0xde, 0xc6, 0xf1, 0xff, 0xe3, 0xc6, 0x1b,
0x39, 0x11, 0x0e, 0xfd, 0x01, 0xac, 0x2c, 0x4b, 0xeb, 0x9e, 0xe5, 0xe5,
0xf7, 0xbb, 0xf3, 0xfc, 0xf7, 0xce, 0x1d, 0x10, 0x03, 0xe4, 0xa7, 0xa7,
0xf0, 0xf0, 0x10, 0xb3, 0x15, 0x32, 0x13, 0x04, 0x1a, 0xdc, 0x21, 0xe3,
0x26, 0x1f, 0xef, 0x1c, 0xd4, 0xd1, 0xe6, 0xdb, 0x1e, 0xf0, 0x11, 0x39,
0x35, 0xdb, 0xd2, 0x17, 0xcb, 0xe4, 0xff, 0xd3, 0x06, 0xcc, 0xf0, 0x19,
0x3c, 0xa9, 0xf3, 0xf4, 0xcc, 0xe2, 0xf4, 0xbb, 0xc2, 0xb9, 0xe3, 0xff,
0x1f, 0x88, 0x10, 0x2a, 0x18, 0x1e, 0xc5, 0xa9, 0x3f, 0x20, 0x30, 0x4b,
0x1f, 0x74, 0x7f, 0x6b, 0x31, 0xbd, 0xb8, 0x17, 0xd3, 0xe1, 0xbf, 0xeb,
0x17, 0x14, 0x2a, 0x09, 0xb8, 0x08, 0xf2, 0xee, 0xb1, 0xc8, 0xcd, 0xc9,
0xe1, 0xe8, 0xf5, 0xdd, 0x42, 0x08, 0x05, 0xfa, 0xec, 0x02, 0xd2, 0x01,
0x0f, 0x9a, 0xc3, 0x02, 0x2c, 0x1a, 0x35, 0x0c, 0x07, 0x1a, 0x31, 0x57,
0x00, 0x36, 0xe2, 0xd4, 0xf6, 0x05, 0xb6, 0x07, 0xb6, 0xd5, 0x23, 0xfd,
0xe2, 0xfe, 0xcb, 0xf3, 0x00, 0x15, 0xef, 0xd3, 0x3b, 0xc5, 0x9c, 0xd3,
0x15, 0xba, 0xf7, 0xd6, 0x2d, 0xe8, 0xe9, 0x35, 0xdb, 0xcb, 0xaf, 0xe1,
0x5d, 0xae, 0xbb, 0x07, 0x35, 0xb9, 0xd0, 0x16, 0xf6, 0x1e, 0xd6, 0x1a,
0xf7, 0x0d, 0xd1, 0xf3, 0x1f, 0xc0, 0xe7, 0x32, 0x2e, 0xfa, 0x35, 0x0d,
0x27, 0x50, 0x59, 0x1b, 0xf3, 0x32, 0xea, 0x25, 0x31, 0x05, 0x19, 0xfb,
0xee, 0x0c, 0x0a, 0xde, 0xff, 0x10, 0xf6, 0x1a, 0x12, 0x38, 0x27, 0xd4,
0xed, 0x81, 0xc8, 0xcb, 0x0d, 0xec, 0xde, 0x0c, 0x05, 0xc0, 0xea, 0x37,
0x9f, 0xe7, 0xb6, 0xec, 0xd4, 0xe8, 0x10, 0xfe, 0x01, 0xcc, 0x0f, 0x01,
0x0a, 0x1b, 0x39, 0x44, 0x77, 0x2c, 0x11, 0xea, 0x0e, 0xc7, 0x01, 0x0a,
0x19, 0xf4, 0xd7, 0x09, 0x0a, 0x32, 0x0d, 0xf9, 0x2e, 0xf9, 0x2d, 0x12,
0x30, 0xcd, 0xaf, 0x98, 0x26, 0x92, 0xcc, 0xc9, 0x10, 0x2c, 0xca, 0x06,
0xd5, 0x07, 0xe1, 0x99, 0xe1, 0x21, 0x4d, 0xc7, 0x19, 0x32, 0x05, 0xe4,
0x0a, 0x4c, 0x0f, 0x39, 0xdf, 0x4b, 0x6b, 0x29, 0x27, 0xbe, 0x0e, 0xd8,
0xbf, 0xd7, 0xcc, 0xa4, 0xec, 0x41, 0xb8, 0xf4, 0xfa, 0x0a, 0xbd, 0xfc,
0xdc, 0xeb, 0xef, 0x20, 0xe8, 0x89, 0xe7, 0x04, 0x2d, 0xe0, 0xae, 0xde,
0x0b, 0x19, 0x0d, 0xdf, 0x18, 0x01, 0xe6, 0xff, 0xfa, 0xe7, 0xd8, 0x4f,
0x38, 0xb2, 0x11, 0xfa, 0x02, 0xff, 0xfb, 0xda, 0x33, 0xf8, 0x2e, 0xbf,
0x2f, 0xfd, 0x0f, 0xb5, 0xf6, 0xd0, 0x1a, 0x1f, 0x20, 0xfa, 0x20, 0xec,
0xde, 0xef, 0xdb, 0xeb, 0xb8, 0x10, 0xd1, 0x28, 0xc4, 0xfe, 0x91, 0x07,
0xa4, 0x18, 0x21, 0x25, 0xe7, 0x1c, 0xce, 0x33, 0x31, 0xe0, 0x02, 0x23,
0xf6, 0xe4, 0x1e, 0x1c, 0x0c, 0xe0, 0xd8, 0x20, 0xfe, 0xcf, 0x01, 0x39,
0xf3, 0x22, 0xd8, 0x14, 0x4f, 0x0b, 0x3b, 0x35, 0xd7, 0xf4, 0x00, 0xc2,
0xa9, 0xba, 0x81, 0xf8, 0x42, 0xa8, 0xf8, 0xb2, 0xb1, 0xf0, 0xf8, 0xff,
0x17, 0x14, 0xc6, 0x1f, 0x00, 0xb4, 0xcf, 0x30, 0xbb, 0xf7, 0xdd, 0x31,
0xd2, 0xd1, 0xc6, 0xf8, 0xd8, 0xf1, 0x9b, 0xa4, 0xed, 0xd2, 0x0c, 0xf2,
0x0d, 0xe6, 0xf8, 0xe6, 0x13, 0x1d, 0xdd, 0xf8, 0xd4, 0x22, 0x01, 0xed,
0x24, 0xe4, 0xcd, 0xc5, 0xf7, 0xbb, 0xe4, 0xff, 0xf6, 0x35, 0xb8, 0xfc,
0xd8, 0xf6, 0xfa, 0xca, 0xcf, 0x16, 0x5f, 0xc2, 0x05, 0xf2, 0xe4, 0x05,
0xa6, 0xf4, 0xa7, 0xd4, 0x05, 0x97, 0xef, 0xc8, 0xe4, 0xfe, 0x2f, 0x1e,
0x18, 0x3a, 0xf4, 0x06, 0x45, 0x33, 0xda, 0x07, 0xf5, 0x2b, 0x43, 0x28,
0x2c, 0xfb, 0x94, 0xf9, 0xd8, 0xe7, 0xd8, 0x05, 0x13, 0xf3, 0x02, 0xe7,
0xcd, 0xe5, 0xc9, 0x09, 0xae, 0x2b, 0x49, 0xc1, 0xe3, 0x20, 0xc2, 0xe4,
0x81, 0xc1, 0xd5, 0xee, 0xfc, 0xcb, 0x18, 0xa8, 0x17, 0x33, 0x3e, 0xd6,
0x2e, 0x3d, 0x15, 0x06, 0xfd, 0x1a, 0x2f, 0xcb, 0xe7, 0xe3, 0x22, 0x1b,
0x15, 0xd5, 0x11, 0xee, 0xb0, 0xe9, 0x17, 0xe5, 0x04, 0xe8, 0xc3, 0xda,
0xe0, 0xf8, 0xaf, 0x24, 0x91, 0x6d, 0x57, 0xe0, 0xc9, 0xe7, 0x02, 0xa8,
0x82, 0x99, 0xdc, 0x8e, 0xf8, 0x9e, 0xd1, 0xe0, 0xd4, 0x46, 0x28, 0x0d,
0x0f, 0x1c, 0xf5, 0xe8, 0xf1, 0x0f, 0x21, 0x2b, 0xf4, 0x0b, 0x1f, 0xd4,
0x01, 0xd3, 0xc2, 0xe1, 0x05, 0xe4, 0xe0, 0x20, 0x21, 0xe6, 0xf3, 0xcd,
0xd2, 0xdd, 0xf2, 0xea, 0x29, 0xeb, 0x0c, 0x40, 0xce, 0xf2, 0xf5, 0x57,
0x35, 0xf1, 0xdc, 0xf8, 0xf2, 0xf9, 0xed, 0x1a, 0x50, 0xbf, 0xb6, 0xd8,
0xed, 0xf4, 0xb9, 0x26, 0x7f, 0xe8, 0xef, 0x49, 0xef, 0x23, 0xf7, 0xd0,
0x25, 0xcc, 0x19, 0x10, 0x35, 0x26, 0x13, 0xe7, 0x0e, 0x24, 0x48, 0x04,
0xf6, 0x3a, 0x36, 0x17, 0xfd, 0xbe, 0x19, 0xf7, 0x14, 0x07, 0x57, 0x3f,
0xe3, 0xe9, 0xed, 0x3e, 0xd8, 0x2c, 0xf5, 0x00, 0x2c, 0xb3, 0xc9, 0xdb,
0xf7, 0xc1, 0xd3, 0xf2, 0x0f, 0xbb, 0x3d, 0xbf, 0x11, 0xec, 0xaf, 0xed,
0x11, 0xaa, 0x09, 0x23, 0x09, 0x10, 0x3d, 0x27, 0x3f, 0x2c, 0x5e, 0x46,
0xda, 0x2d, 0x53, 0x47, 0xea, 0x9c, 0xd0, 0x18, 0xdd, 0xec, 0xeb, 0xde,
0xf9, 0x1c, 0xf0, 0xf8, 0xeb, 0x16, 0x08, 0x06, 0x31, 0xc4, 0xea, 0xe3,
0x1a, 0xa2, 0xca, 0x24, 0x58, 0x12, 0xca, 0xcb, 0x20, 0xf1, 0xd2, 0x15,
0x4d, 0xbc, 0xe8, 0x3a, 0xf9, 0xe5, 0x10, 0xc7, 0xd8, 0x0c, 0xf4, 0x32,
0xf8, 0xf0, 0x15, 0xf7, 0xc3, 0x73, 0x31, 0xf9, 0xa6, 0x08, 0x15, 0x0a,
0xb3, 0xb8, 0xda, 0x98, 0xe5, 0x97, 0xc9, 0xd6, 0xba, 0xde, 0x41, 0x16,
0xe5, 0x0b, 0xd5, 0xe7, 0x81, 0xfb, 0xe2, 0xf8, 0xeb, 0xfd, 0x11, 0xf2,
0xa0, 0x17, 0x39, 0x33, 0x47, 0x9c, 0xfb, 0xe1, 0xf0, 0xee, 0x04, 0x02,
0x36, 0x04, 0xef, 0x22, 0x08, 0x51, 0x16, 0x61, 0xf1, 0x03, 0x68, 0x28,
0x9c, 0xd9, 0xd3, 0xd7, 0xf3, 0x02, 0xdd, 0x8b, 0xf3, 0xfe, 0xfc, 0x12,
0x2d, 0xd0, 0x05, 0x1b, 0x15, 0xca, 0xdf, 0xd6, 0xf5, 0x06, 0x1e, 0x0e,
0x06, 0xcd, 0x3d, 0x0e, 0x4b, 0x36, 0x58, 0xe0, 0xf1, 0x1a, 0xf3, 0x3b,
0x21, 0x1e, 0x5d, 0x40, 0x21, 0x42, 0x62, 0x50, 0xed, 0x0a, 0x31, 0xf6,
0x0a, 0xc4, 0xc9, 0x1c, 0x1a, 0xe9, 0x28, 0x03, 0xf4, 0xfe, 0x1a, 0xfc,
0x0c, 0xa4, 0x1d, 0x1f, 0xc3, 0xe7, 0xbc, 0xd0, 0x05, 0x45, 0x15, 0xeb,
0x15, 0x31, 0x31, 0x6c, 0x66, 0x25, 0xf6, 0x1f, 0x2e, 0x1b, 0x4e, 0x0e,
0x1b, 0x20, 0x2d, 0x2d, 0x3d, 0xd8, 0xf0, 0xd9, 0x57, 0x21, 0xf4, 0xe5,
0xf8, 0x3d, 0x31, 0x19, 0x2f, 0xf4, 0x28, 0x10, 0xd3, 0x02, 0x0e, 0x84,
0x8b, 0xfc, 0x10, 0xb8, 0xeb, 0x11, 0xf0, 0xdd, 0xc8, 0xd8, 0x08, 0xbb,
0xf0, 0xd7, 0x07, 0xe7, 0x1d, 0xd0, 0xfb, 0x07, 0x41, 0xfa, 0x07, 0x1b,
0xba, 0xf1, 0x81, 0x24, 0x2b, 0xc6, 0xd6, 0x05, 0x19, 0x5d, 0xcf, 0xd0,
0x31, 0x08, 0x40, 0x40, 0x69, 0x6b, 0x32, 0x2c, 0x0a, 0xb0, 0xad, 0xde,
0xc9, 0xb8, 0x07, 0xc0, 0x02, 0xe4, 0xb7, 0xda, 0xfa, 0xbc, 0x92, 0xb4,
0x32, 0xdc, 0xba, 0x1c, 0xc3, 0xeb, 0xf5, 0x96, 0x11, 0xd6, 0x08, 0x04,
0xb8, 0x1d, 0xa3, 0xfc, 0xdc, 0xd1, 0x49, 0xc0, 0x2c, 0x0d, 0x25, 0xed,
0x0e, 0x42, 0x40, 0x2b, 0xf0, 0x20, 0x1b, 0x2a, 0xcb, 0x82, 0xb8, 0xbd,
0xf0, 0xe1, 0xd9, 0x1c, 0x08, 0xf4, 0xcf, 0xf7, 0xc7, 0xdf, 0x13, 0xde,
0x2b, 0xbc, 0xb7, 0xc1, 0x38, 0x2f, 0x20, 0xea, 0xf6, 0xc4, 0xd2, 0xe8,
0xab, 0xcf, 0x17, 0x26, 0xe4, 0xe6, 0xd5, 0xfa, 0x0f, 0x01, 0xd2, 0x15,
0x2f, 0x37, 0x21, 0x10, 0x0a, 0x2b, 0x07, 0x46, 0xf2, 0xc9, 0xfe, 0x14,
0xca, 0x92, 0x0f, 0x0a, 0x71, 0x0c, 0x08, 0x03, 0xf4, 0xd1, 0x00, 0x12,
0x06, 0x8e, 0x8b, 0xe6, 0xdc, 0xfb, 0xff, 0x81, 0x12, 0x32, 0x20, 0x44,
0xe3, 0x1b, 0xee, 0x45, 0xe2, 0xff, 0x0d, 0x1a, 0xf3, 0x32, 0xb7, 0x1a,
0xc0, 0x1b, 0xd6, 0xcd, 0x39, 0xec, 0xd4, 0x3b, 0x5f, 0x20, 0xd4, 0xb7,
0xf0, 0x01, 0xf6, 0xcf, 0x17, 0xca, 0xec, 0x50, 0x4e, 0x2a, 0xfc, 0x44,
0x12, 0xa4, 0xe8, 0xa7, 0x15, 0x29, 0xa9, 0x3b, 0x1f, 0x22, 0xdd, 0x05,
0xc0, 0xef, 0xe0, 0x1b, 0x05, 0xc2, 0x2d, 0x43, 0xfb, 0x06, 0x26, 0xf2,
0xf3, 0x0b, 0x19, 0x24, 0x07, 0x31, 0x08, 0xed, 0x34, 0xea, 0xe6, 0xf3,
0xd4, 0xbd, 0x24, 0xc3, 0x3a, 0x27, 0x21, 0x1b, 0xe0, 0x35, 0xe9, 0xde,
0x1e, 0xaa, 0xeb, 0xd7, 0x11, 0x09, 0x09, 0xf5, 0x11, 0xe1, 0xcc, 0xd9,
0x11, 0x14, 0x0e, 0xcb, 0x34, 0xd8, 0xed, 0xd6, 0x20, 0xcc, 0xdc, 0x24,
0x4e, 0xcb, 0xe7, 0x23, 0xce, 0xe8, 0xce, 0xcd, 0x27, 0x9f, 0xe4, 0x02,
0xed, 0xca, 0xdf, 0xf8, 0xf7, 0xca, 0x1c, 0x0e, 0xdd, 0x39, 0x9b, 0x30,
0x2f, 0xb1, 0xe9, 0xf9, 0x1c, 0x1a, 0xb7, 0x09, 0x60, 0x2d, 0x5b, 0x3d,
0x36, 0xf7, 0x56, 0x38, 0x0b, 0xc6, 0x0f, 0x37, 0xd6, 0xee, 0x35, 0x26,
0x29, 0xec, 0x10, 0x00, 0xd3, 0xe8, 0xfd, 0xe9, 0x31, 0xa3, 0x00, 0xf5,
0xdc, 0xaa, 0xed, 0x59, 0x11, 0xc5, 0xd6, 0x4a, 0xbe, 0xe0, 0xea, 0xbc,
0x09, 0xb7, 0x4b, 0x24, 0x16, 0x5a, 0xfa, 0xd3, 0xde, 0x50, 0x50, 0x22,
0x33, 0x01, 0x48, 0x11, 0x33, 0xb9, 0x0d, 0xf7, 0xff, 0xc9, 0x10, 0xe9,
0x23, 0xc2, 0xea, 0xe8, 0x11, 0x2f, 0xbd, 0xed, 0x0e, 0xbc, 0xbf, 0xed,
0x07, 0x81, 0x05, 0xd4, 0x49, 0x10, 0xa6, 0xb0, 0x05, 0x2b, 0xaa, 0x0f,
0x2d, 0xd6, 0x0b, 0x06, 0x25, 0x3c, 0xdd, 0xfd, 0x10, 0xf3, 0xdb, 0x4b,
0x00, 0xfe, 0x2e, 0x3b, 0xde, 0xf0, 0x23, 0x31, 0x07, 0x1c, 0xfb, 0x57,
0x2b, 0x13, 0x0b, 0xea, 0x13, 0x50, 0x07, 0xf9, 0xf0, 0xb3, 0xb9, 0x2f,
0x31, 0xef, 0x22, 0x08, 0x46, 0xf4, 0xf7, 0x22, 0x15, 0x18, 0xb6, 0xeb,
0x2d, 0x81, 0xea, 0x2b, 0xfb, 0x1f, 0xe8, 0x44, 0xfa, 0x28, 0x17, 0x0c,
0x0e, 0x30, 0x42, 0x53, 0x38, 0x2f, 0xe3, 0x26, 0x1b, 0xe4, 0x25, 0xeb,
0x4a, 0xd3, 0xed, 0xe9, 0x0a, 0xd3, 0x20, 0xd8, 0xf8, 0xfd, 0xfb, 0x02,
0x21, 0xf1, 0xc5, 0xff, 0xcc, 0xd6, 0x23, 0xf8, 0xf6, 0x1d, 0x19, 0x0b,
0x06, 0xb7, 0xb9, 0xe9, 0x28, 0xcd, 0xdc, 0xcb, 0x0c, 0x41, 0x1a, 0x44,
0x15, 0x58, 0x18, 0x0d, 0x10, 0x0a, 0xe0, 0x25, 0x0d, 0x40, 0xd4, 0xfc,
0xf9, 0x19, 0x1d, 0xf0, 0x06, 0xed, 0x36, 0xfa, 0x39, 0xc2, 0xce, 0xd4,
0x04, 0xea, 0xe5, 0xd4, 0xd9, 0xda, 0xb9, 0x19, 0xaf, 0xe0, 0x2e, 0x0d,
0x05, 0x17, 0xa7, 0x12, 0xf9, 0x01, 0xd9, 0xbf, 0xfc, 0xe8, 0xf9, 0x05,
0x1a, 0x77, 0x0f, 0xee, 0x23, 0x0f, 0x0d, 0x02, 0x19, 0x2a, 0xff, 0xf4,
0x17, 0x23, 0xf7, 0x1f, 0x1a, 0xfa, 0x16, 0xfe, 0xb2, 0x3f, 0x2e, 0xe5,
0xd2, 0xf9, 0x12, 0xdb, 0xe0, 0xee, 0xfb, 0xde, 0xff, 0xd3, 0xed, 0xe9,
0xb6, 0x6a, 0x56, 0xe2, 0x9f, 0xb6, 0xe5, 0xf3, 0xbb, 0x98, 0xb1, 0x90,
0x92, 0xa8, 0x9f, 0xce, 0x1f, 0x20, 0x10, 0x1a, 0x0a, 0xf9, 0xff, 0x06,
0x14, 0x11, 0x1c, 0xf8, 0x0a, 0x18, 0x09, 0x1c, 0xeb, 0x37, 0x40, 0xba,
0x03, 0xf9, 0xdc, 0xbe, 0xd7, 0xe6, 0xf0, 0x13, 0xe0, 0xd5, 0x36, 0xdf,
0xa0, 0x42, 0x6c, 0x99, 0xab, 0xb3, 0x10, 0xbe, 0x8c, 0xa6, 0xb8, 0xab,
0xbc, 0xd0, 0x90, 0xbd, 0xff, 0x1c, 0x0d, 0x06, 0x1e, 0x13, 0x01, 0xd6,
0xeb, 0x22, 0x0c, 0x11, 0x07, 0x0c, 0x25, 0x11, 0xc8, 0x51, 0x36, 0xca,
0xd1, 0x17, 0xdb, 0xbf, 0xde, 0x14, 0x0e, 0xf5, 0xe1, 0xe8, 0x2a, 0x0f,
0xb3, 0x3f, 0x5a, 0xc8, 0xdb, 0xa5, 0xc6, 0xe8, 0xab, 0x8f, 0xbd, 0xb3,
0xcf, 0x81, 0xaa, 0xa1, 0xfb, 0xd7, 0xcd, 0x30, 0x16, 0xdb, 0x38, 0xf2,
0x30, 0x06, 0xf6, 0x13, 0xfa, 0x46, 0xf9, 0xfa, 0x2f, 0x09, 0xbc, 0x12,
0xd5, 0xf6, 0xc9, 0xca, 0x1b, 0xff, 0xfb, 0x26, 0xf6, 0x06, 0xd9, 0xdf,
0x44, 0x81, 0x89, 0xfc, 0x0c, 0xb6, 0x63, 0xf1, 0x68, 0x08, 0x0f, 0x18,
0xc9, 0x2c, 0x08, 0x4f, 0x2b, 0xee, 0x0a, 0xfb, 0xf9, 0xec, 0xda, 0x70,
0x16, 0xf5, 0x2c, 0xf0, 0x09, 0x2c, 0x2c, 0xea, 0x2f, 0xbb, 0xbc, 0xd8,
0xf9, 0xf5, 0x0e, 0x02, 0x07, 0xf6, 0xc1, 0x4f, 0xfe, 0x18, 0xd6, 0x09,
0x35, 0xa9, 0xdf, 0xbd, 0xcd, 0xf8, 0xf0, 0x01, 0xf7, 0xda, 0xdc, 0x1e,
0xd8, 0xf6, 0xaf, 0x31, 0xfe, 0xdc, 0x11, 0x07, 0x11, 0x21, 0xd7, 0x0e,
0xfb, 0x15, 0x1e, 0xff, 0xf5, 0xff, 0xf0, 0x0d, 0x3d, 0xe5, 0x1d, 0x15,
0x1e, 0xfc, 0xe2, 0xe0, 0x0a, 0xc3, 0x1f, 0xf2, 0xeb, 0x20, 0x0b, 0x2b,
0x30, 0xcf, 0xc6, 0xd1, 0xfa, 0x0e, 0x0d, 0xdc, 0x22, 0x27, 0xd9, 0x08,
0xfd, 0x07, 0xfb, 0xd1, 0xf1, 0x3c, 0x29, 0xd4, 0xe8, 0x04, 0xf3, 0x04,
0x1c, 0xd9, 0x08, 0x12, 0x0a, 0x0a, 0x15, 0xfe, 0xc9, 0x0a, 0x14, 0xce,
0xf1, 0x31, 0xd1, 0xbe, 0xd8, 0x04, 0xee, 0xdd, 0x20, 0xf8, 0x1d, 0xef,
0xf2, 0x71, 0x53, 0xc5, 0x0a, 0xbd, 0x1e, 0xdf, 0xd8, 0xce, 0xc3, 0xe3,
0xcb, 0xcc, 0xee, 0xd9, 0xe7, 0x2f, 0x0a, 0x2f, 0x02, 0xf9, 0x0b, 0x22,
0x15, 0x0e, 0x13, 0x07, 0x23, 0x25, 0x0c, 0x00, 0xc4, 0x54, 0x39, 0xfa,
0xe3, 0x09, 0xef, 0x15, 0xe7, 0xf9, 0x01, 0xd5, 0xfc, 0x08, 0x33, 0x1f,
0xc6, 0x36, 0x7f, 0xc5, 0xfb, 0x02, 0xf3, 0xd8, 0xb4, 0xb7, 0xc7, 0xd5,
0xe4, 0xe4, 0xb8, 0x06, 0x1e, 0x38, 0x15, 0x2e, 0x3a, 0xe1, 0xe3, 0x1c,
0x1a, 0xf2, 0x1b, 0x17, 0x2a, 0xf5, 0x18, 0x06, 0xe9, 0x63, 0x3a, 0xc5,
0x07, 0x3c, 0xf2, 0xc4, 0xf2, 0xd9, 0x0b, 0xec, 0x11, 0xda, 0x07, 0xff,
0xa6, 0x53, 0x33, 0xf3, 0xe1, 0x01, 0xe4, 0xe1, 0xb3, 0xdc, 0xe9, 0xba,
0xed, 0xcb, 0xc8, 0xbb, 0xe4, 0x3c, 0x53, 0x4f, 0x1e, 0x1b, 0xe1, 0x21,
0x15, 0x00, 0x1e, 0xfa, 0xdb, 0x21, 0x77, 0x47, 0xd6, 0xe7, 0xb7, 0xff,
0x28, 0x07, 0xfb, 0xe9, 0xc6, 0xe0, 0xb3, 0xf8, 0xf6, 0xbb, 0x0a, 0x0b,
0xe5, 0xde, 0xa2, 0x21, 0x4f, 0xdb, 0x02, 0x3a, 0xc3, 0x21, 0x0d, 0x0e,
0x16, 0x25, 0xf0, 0xed, 0x27, 0xdf, 0x33, 0x11, 0x3a, 0x2a, 0x26, 0x3b,
0xb4, 0x4e, 0xe9, 0x13, 0x6e, 0xff, 0x30, 0x16, 0xb2, 0xb7, 0xf6, 0xef,
0x33, 0xe7, 0x18, 0x8f, 0xef, 0xbf, 0xe1, 0x02, 0xbb, 0xea, 0x07, 0xd7,
0x42, 0xa1, 0xb7, 0x02, 0x04, 0xe5, 0x4b, 0x4a, 0x06, 0x0a, 0x22, 0x06,
0xfb, 0x39, 0xd2, 0xcf, 0x15, 0xf3, 0xe1, 0xee, 0x21, 0x7f, 0x41, 0x29,
0x20, 0x29, 0x5a, 0x35, 0x50, 0xf3, 0x27, 0x42, 0xd2, 0xc8, 0xbc, 0xfb,
0x1c, 0xe1, 0x1d, 0xdd, 0xd5, 0xf4, 0xf2, 0xd9, 0xd3, 0xe5, 0x14, 0x20,
0x43, 0x98, 0xe0, 0x0f, 0x07, 0x89, 0x29, 0xf4, 0x2e, 0xcd, 0xa9, 0x58,
0x0c, 0x25, 0xe0, 0x3d, 0xf6, 0xbd, 0x00, 0x26, 0x44, 0x4d, 0x20, 0xcd,
0x05, 0x57, 0x2a, 0x11, 0x2f, 0x23, 0x2e, 0x37, 0xf6, 0x20, 0xd4, 0xb6,
0xf3, 0x02, 0x38, 0x20, 0x30, 0x48, 0xda, 0x11, 0xd6, 0xc8, 0x28, 0x2f,
0x38, 0xed, 0xc0, 0xc1, 0xe4, 0xe8, 0x16, 0xcf, 0x08, 0xff, 0xcc, 0x2d,
0x17, 0x26, 0xe9, 0xf4, 0x0d, 0xf0, 0xee, 0x47, 0x0f, 0x3e, 0x11, 0xc4,
0xe9, 0x02, 0xef, 0xe3, 0x12, 0xdd, 0x59, 0x29, 0xfc, 0xaf, 0x0a, 0xfc,
0xfe, 0x12, 0x22, 0xda, 0x17, 0xf9, 0xce, 0xef, 0xd6, 0xce, 0xf6, 0xe5,
0x38, 0x81, 0xc3, 0xe8, 0xd9, 0xd6, 0xee, 0x18, 0xf2, 0x0e, 0xfd, 0x58,
0xf4, 0xe4, 0xc7, 0x14, 0xc3, 0xf2, 0x12, 0xfe, 0x5b, 0xcb, 0x1d, 0xc7,
0xa9, 0xb5, 0x21, 0x29, 0x1a, 0x45, 0xe9, 0xf7, 0x15, 0x10, 0xb7, 0xda,
0x13, 0xd2, 0xcf, 0x95, 0xae, 0x20, 0x22, 0xfb, 0xea, 0xc0, 0x15, 0xb8,
0x34, 0xa1, 0x0c, 0x90, 0xff, 0x8c, 0x08, 0x05, 0xe7, 0x08, 0xc7, 0xed,
0xd6, 0x39, 0x89, 0xf0, 0xb3, 0x19, 0x42, 0x68, 0x16, 0xa7, 0x2a, 0xb4,
0x09, 0x06, 0xcc, 0xfe, 0xac, 0xec, 0x34, 0x44, 0xd3, 0xcf, 0x1a, 0xf5,
0xf4, 0xb6, 0x37, 0x02, 0x27, 0xd8, 0x2a, 0x97, 0x34, 0xae, 0xf9, 0x09,
0xe4, 0x98, 0x25, 0xee, 0x05, 0x4c, 0x0c, 0x30, 0x30, 0x0a, 0xcb, 0x27,
0xe4, 0x45, 0xb9, 0x33, 0xd0, 0xf1, 0xc3, 0x30, 0xe4, 0xd6, 0xdb, 0xef,
0x45, 0x09, 0x97, 0xbf, 0x52, 0x54, 0xe8, 0xc3, 0xe8, 0x29, 0xfd, 0x9e,
0xac, 0xe9, 0x32, 0x9f, 0x28, 0xcd, 0x81, 0x95, 0x09, 0xc7, 0x96, 0x33,
0x19, 0xb7, 0xcf, 0x39, 0xaf, 0xd8, 0xf9, 0x68, 0xc8, 0xfd, 0x93, 0xc7,
0xe9, 0xe7, 0xec, 0xe5, 0x21, 0x2a, 0x36, 0x2d, 0x0b, 0xdd, 0x14, 0xe0,
0x51, 0xbe, 0x25, 0x54, 0x19, 0x68, 0x4f, 0x0c, 0x5a, 0xe8, 0x42, 0x94,
0xf9, 0x46, 0x95, 0xe8, 0xe7, 0xbf, 0xcf, 0x0e, 0xcf, 0x22, 0xec, 0x49,
0x1d, 0xc1, 0xef, 0x22, 0xda, 0xd2, 0x4d, 0x0b, 0x98, 0x9d, 0xd8, 0x6b,
0x39, 0xbd, 0xa9, 0xea, 0x2a, 0x12, 0xea, 0xe5, 0xec, 0x0b, 0x09, 0xd5,
0x27, 0x0b, 0x1a, 0x2e, 0x1d, 0xcf, 0x10, 0x05, 0xeb, 0xd2, 0xd0, 0xf9,
0xd2, 0xf7, 0x2e, 0xfa, 0x27, 0xed, 0xc2, 0x07, 0x11, 0xf5, 0xcc, 0xe2,
0x52, 0x9e, 0x2b, 0x20, 0xf4, 0xdb, 0xfe, 0x4b, 0x27, 0xf9, 0x04, 0x39,
0x3d, 0x28, 0x09, 0x40, 0xf1, 0xfd, 0xe2, 0xdb, 0x1a, 0x20, 0x05, 0x2c,
0x1d, 0xf2, 0x0d, 0xfc, 0xf8, 0x15, 0x2c, 0xff, 0xeb, 0xc5, 0xda, 0xff,
0xdf, 0x9a, 0xbf, 0xe1, 0xf5, 0xbe, 0xf8, 0xe5, 0xc8, 0x0b, 0xfc, 0xf5,
0x24, 0xe2, 0xaf, 0x0a, 0x1a, 0xe7, 0x59, 0x3b, 0x4b, 0x23, 0x3e, 0x43,
0x3f, 0x03, 0xc0, 0x2a, 0xfe, 0x0a, 0x24, 0xfa, 0xe1, 0xdf, 0xcc, 0xe6,
0xe2, 0x24, 0xd1, 0x07, 0xe7, 0x20, 0xd8, 0xeb, 0x02, 0xa0, 0xdf, 0x08,
0x28, 0xe4, 0xe4, 0xe0, 0xf5, 0xd2, 0xd5, 0x2c, 0xff, 0x08, 0xf0, 0xd4,
0x39, 0x97, 0xc0, 0x1d, 0x28, 0xf0, 0x13, 0xfe, 0x4f, 0x32, 0x7f, 0x2e,
0x1f, 0x47, 0x41, 0x2b, 0x13, 0x0b, 0xe1, 0xdd, 0xd8, 0xb5, 0x1d, 0xc0,
0x31, 0xf4, 0xc7, 0x3e, 0xc5, 0xe6, 0x0b, 0xe1, 0xe3, 0x09, 0x1f, 0xf8,
0xe7, 0xc8, 0xb5, 0xc4, 0x13, 0xf3, 0x03, 0xde, 0xdd, 0xcb, 0xeb, 0xcb,
0x04, 0xa8, 0x02, 0xa3, 0xc3, 0xff, 0xc9, 0x0a, 0xa7, 0xb4, 0x08, 0xe6,
0xba, 0xb9, 0x81, 0xc7, 0x28, 0x17, 0xd5, 0xe2, 0x03, 0x1d, 0xa0, 0xba,
0xe2, 0x14, 0xc6, 0x25, 0x17, 0xbb, 0x02, 0xd2, 0xed, 0xb7, 0x29, 0xe1,
0x14, 0x93, 0x3c, 0x3f, 0xda, 0xd6, 0xc4, 0xcd, 0x0f, 0xb4, 0x31, 0x1f,
0x95, 0x32, 0xf8, 0x9b, 0x99, 0xd8, 0x36, 0xde, 0xda, 0x17, 0xd6, 0xdb,
0xd5, 0x4f, 0x0f, 0xda, 0xd1, 0x36, 0xcf, 0x14, 0xcd, 0xf1, 0xb5, 0x94,
0x1c, 0xcc, 0x4c, 0xb5, 0x3c, 0xd8, 0x1c, 0xd6, 0xdc, 0x18, 0xfe, 0xf3,
0xc5, 0xea, 0x28, 0xbc, 0xc4, 0x03, 0xef, 0xaf, 0xc7, 0x0d, 0xcc, 0x16,
0xb6, 0xee, 0x32, 0x13, 0xea, 0xf4, 0x24, 0x14, 0xd9, 0x36, 0xc0, 0xf8,
0x23, 0x58, 0x65, 0xf3, 0x9f, 0x0e, 0xe4, 0xcd, 0xe0, 0xa7, 0xfe, 0xa4,
0xd1, 0x9a, 0x9a, 0xd1, 0xad, 0xc2, 0x30, 0x94, 0x9f, 0xcb, 0x31, 0xd2,
0xde, 0x8e, 0xd8, 0x16, 0xc2, 0x93, 0xba, 0xa5, 0xd6, 0xca, 0xf5, 0xad,
0xc4, 0xe0, 0xd7, 0xb4, 0x2d, 0x20, 0x03, 0x34, 0xf1, 0xd8, 0x0c, 0xb1,
0xe6, 0x32, 0xb4, 0x00, 0x2f, 0xef, 0x26, 0xd6, 0x05, 0x41, 0xe7, 0x28,
0x03, 0xdc, 0xfa, 0x02, 0x20, 0x1c, 0xee, 0xfe, 0x1d, 0x4a, 0x0f, 0x29,
0x12, 0x02, 0xb9, 0x02, 0xc9, 0xf1, 0x16, 0x02, 0x00, 0x14, 0x51, 0xfb,
0xc3, 0x02, 0xf5, 0x51, 0xe2, 0xd7, 0xdd, 0x5c, 0x3e, 0x00, 0x0f, 0x22,
0xec, 0xfd, 0xfe, 0x16, 0xe7, 0xf8, 0x03, 0x7f, 0xe2, 0xc6, 0xe9, 0x2e,
0x17, 0xba, 0x2f, 0x0f, 0x49, 0x00, 0x52, 0x0b, 0xc8, 0x35, 0x16, 0xa4,
0xe2, 0x3f, 0x14, 0x1f, 0xd1, 0xff, 0xce, 0x24, 0xc2, 0x13, 0x05, 0xd0,
0x1e, 0x40, 0x1b, 0x5a, 0xc3, 0xe2, 0x34, 0x4a, 0xe4, 0x0b, 0x0c, 0x09,
0x03, 0x4f, 0xd2, 0xec, 0x4a, 0x0f, 0x0f, 0x20, 0x2b, 0xba, 0x0a, 0xba,
0x37, 0x4c, 0x7f, 0xda, 0x06, 0x19, 0x2a, 0x3b, 0xe5, 0xde, 0xb6, 0xd4,
0xc8, 0xe2, 0xc3, 0xe8, 0x04, 0x05, 0xf1, 0xea, 0xce, 0xdf, 0xcf, 0x0f,
0x02, 0xe8, 0xd5, 0xc3, 0xdd, 0xfb, 0xcf, 0xce, 0x0f, 0xd5, 0x2e, 0x06,
0xf4, 0x00, 0x4f, 0x1e, 0xc3, 0x11, 0x1a, 0x06, 0x18, 0x22, 0x26, 0xc9,
0xe2, 0xff, 0x01, 0x3d, 0x47, 0xc8, 0x53, 0xe2, 0x31, 0xe8, 0x08, 0xe4,
0xd8, 0xfe, 0xee, 0xea, 0xde, 0xcb, 0x12, 0x17, 0x9e, 0xcf, 0xe5, 0xdf,
0x1c, 0x9c, 0xb3, 0x29, 0xfc, 0xe2, 0xd4, 0xe8, 0xf4, 0x10, 0xe4, 0xf6,
0xc8, 0xec, 0xf6, 0x00, 0xd5, 0xfc, 0x21, 0x36, 0xfe, 0x15, 0x18, 0x1a,
0xed, 0xf8, 0x27, 0xe9, 0x14, 0x0c, 0xf1, 0x67, 0x1e, 0xe6, 0x04, 0xb4,
0x13, 0xf0, 0xec, 0xed, 0x06, 0xf5, 0xd3, 0xc1, 0x1e, 0x09, 0xdb, 0x02,
0xfb, 0xbe, 0x12, 0xc3, 0x13, 0x8c, 0x23, 0x0a, 0xfe, 0x07, 0xea, 0x1a,
0xc4, 0xeb, 0xab, 0xea, 0xe6, 0xed, 0xc9, 0x42, 0x0d, 0xe3, 0xee, 0x15,
0x25, 0xff, 0x32, 0xfc, 0xe4, 0x36, 0xe7, 0x39, 0xf6, 0xd9, 0x22, 0xde,
0xf7, 0x03, 0xeb, 0xf7, 0xf4, 0x2a, 0x05, 0xd9, 0x05, 0x0b, 0x15, 0xf1,
0x35, 0xca, 0xff, 0x44, 0xf0, 0xf6, 0x36, 0x42, 0x21, 0x23, 0xd3, 0x14,
0x19, 0x40, 0x2e, 0x10, 0x0d, 0xe0, 0xcd, 0xe1, 0x17, 0xd6, 0x14, 0x06,
0xfc, 0x09, 0x2c, 0x28, 0x21, 0x09, 0x19, 0x13, 0xef, 0xc3, 0x00, 0x0c,
0xd8, 0x1a, 0xee, 0x24, 0x10, 0xe2, 0xc8, 0x18, 0x23, 0x31, 0x2b, 0x16,
0x2d, 0x99, 0xd2, 0x0c, 0xf5, 0xdb, 0xfc, 0x1e, 0x4f, 0x04, 0xbf, 0x3d,
0x0a, 0xe6, 0xf2, 0xc6, 0xf6, 0xf8, 0xea, 0x0f, 0xee, 0x0c, 0xe3, 0xf1,
0x1b, 0x0d, 0xf8, 0x01, 0x29, 0x2d, 0x06, 0xd9, 0xdf, 0xba, 0x03, 0xab,
0xf0, 0xc5, 0x10, 0x08, 0xe5, 0xe5, 0x07, 0x01, 0x14, 0x1a, 0x15, 0xe1,
0x08, 0x81, 0x16, 0x1f, 0xca, 0xd8, 0x3f, 0xe9, 0x32, 0x0e, 0x37, 0xfe,
0x27, 0x20, 0xce, 0x18, 0x24, 0x29, 0x4a, 0x23, 0x31, 0x35, 0x1f, 0xbc,
0x2c, 0x46, 0x47, 0x02, 0x1a, 0xe4, 0x2a, 0x36, 0xe5, 0x86, 0xf2, 0x48,
0xec, 0x20, 0xbd, 0xc5, 0xcb, 0x0e, 0xb5, 0xde, 0xc9, 0x2b, 0xcd, 0xe2,
0x4e, 0x83, 0x04, 0xd8, 0x64, 0x0a, 0x07, 0x18, 0x68, 0x23, 0x15, 0x5f,
0xcc, 0x77, 0xca, 0xf8, 0xd2, 0x44, 0xd3, 0xf7, 0x43, 0x17, 0xfd, 0x2f,
0x02, 0xcd, 0x2e, 0x28, 0x75, 0xb4, 0x55, 0x4a, 0xd4, 0x8c, 0xc3, 0x25,
0x19, 0x22, 0xd7, 0xc9, 0x1c, 0xf8, 0x1e, 0xce, 0x1b, 0x10, 0xbe, 0xb5,
0x37, 0xdc, 0xa0, 0x49, 0xed, 0x01, 0x08, 0x1d, 0x3a, 0xe8, 0xe0, 0x2f,
0xd4, 0x0f, 0xa7, 0x30, 0x07, 0xc8, 0x00, 0x6a, 0x52, 0xf0, 0xd3, 0xcb,
0xe2, 0x17, 0x1b, 0x03, 0x34, 0x16, 0x39, 0x30, 0x11, 0xa1, 0xc4, 0xa3,
0x55, 0xc6, 0xb6, 0xcd, 0xe7, 0x31, 0x1c, 0xd4, 0xf9, 0x38, 0xca, 0x24,
0x32, 0xaa, 0xd6, 0x14, 0x2b, 0x81, 0x2b, 0xee, 0x0e, 0xc3, 0x13, 0x36,
0xe6, 0xb5, 0xa5, 0x3e, 0xa5, 0x9b, 0xc2, 0x4b, 0x32, 0xdc, 0xba, 0xf7,
0x8d, 0xe6, 0xa6, 0x15, 0x2c, 0xf0, 0x3f, 0x2d, 0x3f, 0xef, 0x06, 0xf1,
0xcb, 0x54, 0xa6, 0xbf, 0x95, 0x32, 0x26, 0x6b, 0xe8, 0xae, 0x20, 0xe7,
0xff, 0xca, 0x0a, 0xf2, 0x08, 0xdd, 0x02, 0x51, 0xd6, 0xe5, 0x03, 0xb1,
0x1f, 0xbd, 0xea, 0x04, 0xe7, 0xd8, 0xcd, 0x23, 0x01, 0x13, 0x2d, 0x34,
0x19, 0x06, 0x29, 0x4f, 0x1b, 0x9f, 0xf7, 0xc8, 0xaa, 0xce, 0x0c, 0xb3,
0x38, 0xc0, 0x49, 0x16, 0x00, 0x0d, 0x37, 0x81, 0xcd, 0x1b, 0xf7, 0xe1,
0xf1, 0xdc, 0xad, 0x16, 0xb9, 0xe2, 0xc0, 0x94, 0xc6, 0x21, 0x1b, 0x05,
0xcf, 0xc3, 0x36, 0x39, 0x14, 0x0e, 0xb4, 0x23, 0x4e, 0xf6, 0xe1, 0x2d,
0x0c, 0x1b, 0xe7, 0x18, 0x24, 0x18, 0xe6, 0x00, 0x25, 0xdb, 0xac, 0x1f,
0xa1, 0x94, 0x1e, 0xf3, 0xad, 0x03, 0x1b, 0xeb, 0x01, 0xc1, 0x2d, 0x1b,
0xc2, 0xf7, 0xdd, 0xc6, 0x44, 0xc6, 0xbf, 0xd6, 0xbe, 0x3d, 0xfe, 0xa7,
0x02, 0xea, 0xce, 0xee, 0xe9, 0x24, 0x11, 0x15, 0x2d, 0xf8, 0xfb, 0xe3,
0xe2, 0x41, 0x01, 0x3d, 0xf1, 0x18, 0x46, 0xfe, 0xe1, 0xd3, 0x1c, 0xd9,
0xe0, 0xd0, 0xe5, 0xa3, 0xf0, 0xca, 0xee, 0x08, 0xf7, 0x08, 0xd7, 0x1a,
0x23, 0xbe, 0xa1, 0xd9, 0xc7, 0x81, 0x23, 0x0f, 0xc8, 0xf7, 0x10, 0x18,
0x02, 0x2f, 0xf9, 0xdd, 0x18, 0x04, 0x47, 0xf8, 0x1e, 0xeb, 0x2c, 0x28,
0xbc, 0xd3, 0x43, 0xfb, 0x2a, 0xf6, 0x42, 0x24, 0xe6, 0xda, 0xc7, 0xb8,
0xfe, 0xc0, 0xe4, 0xdf, 0xf9, 0x2a, 0xc1, 0xce, 0x17, 0xbc, 0x3b, 0x1c,
0x33, 0xe8, 0x13, 0x0c, 0xef, 0xa6, 0x37, 0x6e, 0x3a, 0x16, 0xf4, 0xd6,
0x20, 0x2d, 0xaa, 0xe0, 0x07, 0x1e, 0x21, 0xff, 0x1e, 0x3e, 0x19, 0x19,
0xbd, 0x05, 0xf2, 0x3e, 0x16, 0x07, 0x09, 0x42, 0xfd, 0x14, 0x10, 0xae,
0xed, 0x03, 0xe5, 0xef, 0xc6, 0x1f, 0xd4, 0xcf, 0x02, 0xbc, 0x15, 0x02,
0x2c, 0xf8, 0x00, 0x36, 0xe1, 0xa8, 0x30, 0x12, 0xff, 0xce, 0xf2, 0x05,
0xdc, 0xf6, 0xfe, 0x24, 0xd6, 0x54, 0x32, 0xef, 0xee, 0xd3, 0xee, 0x04,
0xe1, 0xdd, 0xf8, 0x0e, 0x0e, 0x10, 0xd6, 0x22, 0xfe, 0x4f, 0xfa, 0xc4,
0x0b, 0xff, 0x15, 0x1b, 0xd3, 0xe2, 0xf8, 0x01, 0xc9, 0xbc, 0xbd, 0x07,
0xce, 0x42, 0x69, 0xbb, 0x23, 0xd0, 0x03, 0xc0, 0x08, 0x0b, 0xe4, 0xf1,
0x00, 0xa5, 0x17, 0xeb, 0xfe, 0x5b, 0xe5, 0x14, 0xda, 0xfb, 0xe9, 0xfe,
0xf3, 0xe0, 0x3a, 0xcf, 0x40, 0xc4, 0x08, 0xfc, 0xdb, 0x47, 0x19, 0x03,
0xfa, 0xb9, 0x30, 0x0e, 0xaa, 0x0c, 0x05, 0xcb, 0xc5, 0x0b, 0xf7, 0x10,
0xf1, 0x55, 0x3d, 0xba, 0xbb, 0x0c, 0xd2, 0xf4, 0xc7, 0xd4, 0xb7, 0xe3,
0xe3, 0x0d, 0x27, 0xda, 0xdb, 0x70, 0x1f, 0x19, 0xe5, 0x11, 0xf4, 0x13,
0xed, 0x16, 0xda, 0x10, 0xfd, 0x15, 0xf5, 0xcb, 0xcd, 0x25, 0xdb, 0xfc,
0xe4, 0x28, 0xed, 0xff, 0xbe, 0x04, 0xea, 0x07, 0xd1, 0xa3, 0x11, 0xf7,
0x99, 0x7f, 0x56, 0xfc, 0xbb, 0x00, 0xbb, 0xed, 0xba, 0x01, 0xbe, 0xe1,
0xda, 0xc0, 0xdf, 0xe1, 0x2e, 0xf7, 0xff, 0xff, 0x04, 0x00, 0x00, 0x00,
0x40, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x0d, 0x03, 0x00, 0x00,
0x42, 0x03, 0x00, 0x00, 0x18, 0xf6, 0xff, 0xff, 0x06, 0xfc, 0xff, 0xff,
0xcf, 0x00, 0x00, 0x00, 0xc8, 0xfe, 0xff, 0xff, 0x37, 0xf6, 0xff, 0xff,
0x45, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00,
0xf6, 0x00, 0x00, 0x00, 0x58, 0xff, 0xff, 0xff, 0xaf, 0x00, 0x00, 0x00,
0x24, 0x00, 0x00, 0x00, 0x5c, 0x00, 0x00, 0x00, 0x7a, 0xf7, 0xff, 0xff,
0x04, 0x00, 0x00, 0x00, 0x80, 0x04, 0x00, 0x00, 0x26, 0xc7, 0xe5, 0x1e,
0xd1, 0xa0, 0x04, 0xcd, 0x18, 0xef, 0xe2, 0x3a, 0xd2, 0xdd, 0xe7, 0x0f,
0x02, 0x30, 0xec, 0x3a, 0xf8, 0x92, 0xc9, 0xec, 0xe0, 0x28, 0xdd, 0x37,
0xdb, 0xac, 0xfd, 0xc2, 0xdb, 0x19, 0x11, 0x19, 0xf4, 0xbd, 0xd5, 0xb5,
0x2d, 0x1d, 0xd5, 0x16, 0xb2, 0x81, 0xf6, 0x15, 0x1e, 0xde, 0x0d, 0x3e,
0xba, 0xd8, 0x0f, 0xd0, 0xfe, 0xb5, 0xcb, 0xe3, 0xad, 0xdb, 0xe8, 0x0a,
0x35, 0x06, 0x02, 0x2a, 0x17, 0x8d, 0xf6, 0xde, 0xc5, 0x0c, 0xe6, 0xab,
0x34, 0x05, 0xdd, 0x09, 0xa7, 0xec, 0xdc, 0xd9, 0xfe, 0xd2, 0xcc, 0x2e,
0xc7, 0x9c, 0xc3, 0x81, 0xdb, 0xf1, 0xc8, 0xba, 0xf3, 0xa4, 0xe9, 0xd5,
0x18, 0xec, 0xe8, 0x0a, 0x94, 0x9c, 0xe4, 0xc6, 0x08, 0xe8, 0xfa, 0x13,
0xbf, 0xc6, 0xc3, 0x9d, 0xd1, 0xfe, 0xd5, 0xf1, 0xb7, 0xad, 0xe1, 0x02,
0xc1, 0xbe, 0x1a, 0x02, 0xc9, 0xfc, 0x1e, 0xbe, 0xea, 0x2e, 0x0b, 0xda,
0xa1, 0x91, 0x09, 0xa7, 0x27, 0x2c, 0xd5, 0xdb, 0xed, 0xfa, 0x3f, 0x0e,
0xf6, 0xf1, 0xe5, 0xd9, 0x9c, 0x13, 0xf7, 0xe4, 0x3d, 0xee, 0x11, 0x49,
0xba, 0x9e, 0x2b, 0xcd, 0xc1, 0xa5, 0xc1, 0xb8, 0xa1, 0xa5, 0x58, 0xb0,
0xfe, 0x18, 0x12, 0x27, 0xa5, 0x14, 0x43, 0x02, 0xdf, 0xf7, 0x37, 0x41,
0x9b, 0xcb, 0x08, 0xaa, 0x0e, 0xd7, 0xf1, 0xfa, 0xe6, 0xa8, 0x39, 0xa0,
0xdd, 0x0d, 0x39, 0x40, 0xcd, 0xc8, 0x22, 0xb5, 0xe3, 0xbb, 0xbe, 0x4f,
0x96, 0xac, 0xcd, 0x81, 0xff, 0xf6, 0x1a, 0x0c, 0x66, 0xbb, 0xd2, 0x47,
0x10, 0x34, 0x09, 0x0d, 0x3a, 0xde, 0xc5, 0xf6, 0xd9, 0x06, 0x3f, 0xd0,
0x37, 0x0c, 0x44, 0x3d, 0x7f, 0xe5, 0x4b, 0xe2, 0x26, 0xf6, 0x10, 0xc7,
0x4f, 0x69, 0xf5, 0xd3, 0xb9, 0xbe, 0xe9, 0x3f, 0xea, 0x13, 0xd2, 0x05,
0xb6, 0x32, 0x36, 0xa5, 0x64, 0xdc, 0x3f, 0x35, 0xd8, 0x5e, 0x19, 0xd3,
0x41, 0x03, 0x31, 0x24, 0x37, 0x24, 0x3e, 0x01, 0x23, 0xe2, 0xc7, 0xa5,
0x20, 0x01, 0x01, 0x09, 0x14, 0xe9, 0xec, 0xe7, 0x3c, 0xa2, 0x5c, 0xff,
0x39, 0x13, 0xfc, 0x07, 0xcb, 0x09, 0x0c, 0x1e, 0x05, 0xfa, 0x26, 0xa8,
0xf2, 0xd3, 0xe9, 0x01, 0xc9, 0xa1, 0x26, 0x2f, 0x0c, 0x32, 0x3d, 0x1c,
0xd1, 0xb0, 0x2c, 0x0d, 0x48, 0xd7, 0x12, 0x34, 0x1d, 0x81, 0xde, 0xcf,
0x14, 0xf9, 0x1f, 0xa3, 0x18, 0xbf, 0x47, 0x4b, 0x3a, 0x51, 0x06, 0x2e,
0xeb, 0x8a, 0x1a, 0xc9, 0xdd, 0x13, 0xe3, 0xf5, 0x1a, 0xd1, 0xed, 0xc6,
0xff, 0x3f, 0xef, 0xc2, 0x57, 0x8c, 0xb6, 0xfb, 0x36, 0x2a, 0x31, 0x37,
0x0b, 0x1c, 0xf8, 0xfc, 0xe7, 0x0d, 0xff, 0x02, 0xd4, 0x0e, 0xda, 0x02,
0xcf, 0xc4, 0xb4, 0xdd, 0x03, 0xa2, 0xfd, 0xdf, 0xdc, 0xff, 0x7f, 0xed,
0xfd, 0xf2, 0x19, 0x1d, 0xe5, 0xd8, 0xe1, 0xf7, 0x00, 0xdb, 0x14, 0x04,
0xf1, 0xa4, 0xff, 0xde, 0xcf, 0xfc, 0xd3, 0x13, 0x46, 0x15, 0x15, 0x12,
0x27, 0x01, 0x24, 0xd8, 0xf9, 0xfa, 0x0a, 0xe1, 0x11, 0xda, 0xf7, 0x1c,
0xcb, 0xdc, 0xd4, 0xed, 0xce, 0x0e, 0x19, 0xb9, 0xd4, 0x0b, 0xde, 0x15,
0x18, 0x3b, 0xf9, 0xf6, 0xdc, 0x19, 0x3b, 0xc3, 0x17, 0xf3, 0x58, 0x24,
0xde, 0xf8, 0x4b, 0x07, 0x47, 0x5f, 0x30, 0xf8, 0xca, 0xfd, 0x35, 0xbb,
0xd4, 0xfe, 0xe1, 0x1d, 0x13, 0xaf, 0x20, 0xee, 0xc6, 0x03, 0x2b, 0x21,
0x1e, 0x0d, 0xc1, 0xec, 0xcb, 0xcd, 0xf4, 0xc7, 0x2c, 0xe5, 0xd1, 0xe0,
0xcb, 0x81, 0xaf, 0xd9, 0x24, 0xbe, 0xd6, 0x1d, 0x0f, 0xe5, 0x24, 0xf9,
0xd8, 0x1a, 0xb7, 0xd3, 0x27, 0xb7, 0xf1, 0xff, 0x03, 0x12, 0x37, 0xed,
0xa9, 0x68, 0x6f, 0x34, 0x0b, 0xda, 0xf4, 0x04, 0x0e, 0x0f, 0x31, 0x04,
0xf8, 0x2e, 0xde, 0x3d, 0x68, 0x4e, 0x34, 0x2d, 0x37, 0xb7, 0xe1, 0x23,
0x1d, 0x2c, 0x38, 0xcf, 0x2f, 0xce, 0xc8, 0x3b, 0xf4, 0x34, 0x27, 0xfa,
0x31, 0x2f, 0x37, 0x21, 0xdb, 0x3e, 0x57, 0x73, 0x27, 0xc5, 0xe9, 0xe1,
0xf8, 0x56, 0xee, 0xaf, 0xb3, 0xcd, 0xdd, 0xb5, 0xaf, 0x2e, 0xf5, 0xea,
0xb5, 0x28, 0x02, 0x6f, 0x08, 0x01, 0x7f, 0x58, 0x2f, 0xfa, 0xf1, 0x03,
0xc3, 0xe1, 0xee, 0xdc, 0xe2, 0x32, 0xe1, 0x3b, 0xd3, 0x8f, 0x1f, 0xb6,
0x09, 0xee, 0xc9, 0x7f, 0xfc, 0x19, 0xea, 0xf3, 0x45, 0xe5, 0xd5, 0x22,
0xdb, 0xd2, 0x0e, 0xba, 0x44, 0x26, 0xf3, 0x2d, 0x10, 0xcb, 0x27, 0xbe,
0x03, 0x50, 0xdc, 0x27, 0x4d, 0xab, 0xfc, 0xe2, 0x04, 0xf2, 0x09, 0x23,
0x0b, 0xfd, 0xef, 0xb7, 0xd6, 0x08, 0x0e, 0xe6, 0xe8, 0xb0, 0xef, 0x1f,
0xf7, 0xdf, 0xce, 0x2f, 0x15, 0xd2, 0x22, 0x26, 0x6f, 0xf5, 0x4a, 0xf2,
0x51, 0xbc, 0x11, 0xe3, 0xc1, 0x1e, 0x04, 0xe6, 0x01, 0x83, 0xe4, 0xd6,
0x16, 0xed, 0xfd, 0xca, 0xc2, 0x90, 0xb9, 0x25, 0x0f, 0xcc, 0xeb, 0x3e,
0x2b, 0xb1, 0xc4, 0x31, 0x1a, 0x02, 0xa8, 0xd2, 0x19, 0x81, 0xb2, 0xc9,
0x01, 0x06, 0xff, 0x13, 0xd1, 0xd9, 0xb5, 0xf4, 0x21, 0x37, 0x53, 0x15,
0x2b, 0x8d, 0x08, 0x11, 0x20, 0xd2, 0xc9, 0x18, 0x10, 0xe0, 0xc6, 0x07,
0x0c, 0xf9, 0x38, 0xd9, 0xe3, 0xa0, 0xf0, 0x33, 0xf0, 0x29, 0x45, 0x32,
0x01, 0x29, 0x03, 0x37, 0xff, 0xee, 0x11, 0xe0, 0x31, 0xe3, 0x37, 0xcc,
0xd4, 0x26, 0xfc, 0xe9, 0xfa, 0xcc, 0x15, 0xd2, 0x7f, 0x1b, 0x5c, 0xdb,
0xea, 0xff, 0xf2, 0xee, 0xef, 0x10, 0xd4, 0x10, 0xaa, 0x03, 0x29, 0xee,
0xe6, 0x28, 0xf3, 0xbd, 0x02, 0xc4, 0xf0, 0xdd, 0xd7, 0x2c, 0x17, 0xdf,
0x28, 0xfb, 0xd3, 0x4a, 0xcf, 0xe0, 0xb8, 0xf6, 0xc1, 0xb9, 0xd6, 0xa7,
0xd7, 0x02, 0xd0, 0x25, 0x10, 0x9d, 0x10, 0x30, 0x3a, 0x2c, 0x3a, 0xbf,
0x2c, 0xae, 0xd9, 0xe1, 0x28, 0xc4, 0xda, 0x3d, 0xf1, 0xc6, 0x0c, 0x31,
0x1b, 0xe2, 0x12, 0xf2, 0x3c, 0xda, 0xb4, 0x2b, 0xaf, 0xfb, 0x22, 0xee,
0x1e, 0x0d, 0x30, 0xef, 0x08, 0x37, 0xd0, 0x2e, 0xc9, 0xce, 0x0a, 0xbe,
0x14, 0xcb, 0xc6, 0x03, 0x15, 0xba, 0xc2, 0x3c, 0xc5, 0x4d, 0x3a, 0x02,
0xe4, 0xad, 0xe8, 0x11, 0x1c, 0xe3, 0xf9, 0x1e, 0xd3, 0xb2, 0x29, 0xd3,
0xe0, 0x24, 0xfd, 0x0a, 0x21, 0x81, 0x24, 0xd4, 0x3a, 0x0a, 0x07, 0x0b,
0xe4, 0xda, 0xf4, 0x1e, 0x06, 0x04, 0xca, 0x01, 0xf4, 0x14, 0x2c, 0x29,
0x28, 0xc2, 0xec, 0x24, 0x07, 0xae, 0xf6, 0xe0, 0x07, 0xf2, 0x23, 0x0d,
0x26, 0xa9, 0xfd, 0xa5, 0xff, 0xf8, 0x25, 0x0a, 0x03, 0xe7, 0xb2, 0xeb,
0xe6, 0xc3, 0x23, 0xf8, 0xb1, 0x16, 0x0b, 0xee, 0x0a, 0x1d, 0xec, 0x38,
0x30, 0x81, 0xe8, 0xff, 0xcc, 0xc8, 0xc6, 0xfa, 0xf6, 0xc5, 0xed, 0xbb,
0xb5, 0xe1, 0xdb, 0xd2, 0x20, 0xe6, 0xfd, 0xee, 0x33, 0xbb, 0x26, 0xe8,
0x51, 0xed, 0xea, 0xb0, 0x3a, 0x31, 0x1a, 0x02, 0x44, 0xdd, 0x0a, 0xc3,
0xed, 0x30, 0xd1, 0x0a, 0x58, 0x88, 0x1a, 0x74, 0x5f, 0xd5, 0x61, 0x5b,
0x29, 0xac, 0x08, 0x9c, 0x14, 0x15, 0x97, 0x37, 0x56, 0x81, 0xba, 0x01,
0xa3, 0x50, 0x0e, 0x00, 0x07, 0xeb, 0xfc, 0xe2, 0xac, 0xd7, 0x41, 0xf2,
0x2e, 0xd7, 0x27, 0xc9, 0x34, 0x19, 0xe5, 0x68, 0x10, 0xec, 0xed, 0xf1,
0x22, 0xdf, 0x4f, 0x21, 0x59, 0xc8, 0xc2, 0x46, 0xba, 0x71, 0x44, 0x17,
0x47, 0xcb, 0xeb, 0xd0, 0xde, 0xd2, 0x19, 0x01, 0x10, 0xe0, 0x0b, 0x23,
0xef, 0xc9, 0x0c, 0xde, 0x29, 0x0f, 0xc2, 0x1b, 0x2a, 0xf3, 0x1d, 0xde,
0x7f, 0xdd, 0x0e, 0x58, 0x03, 0xcc, 0x22, 0x12, 0x0b, 0xf3, 0x36, 0xf3,
0xc0, 0xd5, 0xc4, 0xe9, 0xd4, 0x18, 0xa4, 0xd8, 0x0b, 0x57, 0xf1, 0xe9,
0xe9, 0xc5, 0x1a, 0xec, 0x0a, 0xcc, 0xd0, 0x13, 0xf4, 0xfc, 0xd1, 0x02,
0xd0, 0xeb, 0x0e, 0x0b, 0x0c, 0xca, 0xe1, 0x0d, 0x37, 0xde, 0x39, 0xdd,
0x5b, 0x81, 0x3a, 0xc6, 0x19, 0xfd, 0xde, 0x43, 0xd0, 0xb9, 0xc3, 0xe8,
0xd4, 0x15, 0xa8, 0xe6, 0x12, 0xcf, 0xb3, 0xd0, 0x69, 0xf8, 0xf1, 0x45,
0xec, 0xe3, 0x4c, 0x20, 0x53, 0xe0, 0xee, 0xff, 0xca, 0xad, 0xf0, 0xbc,
0x10, 0xe0, 0x52, 0x5d, 0x34, 0x4f, 0x52, 0x3d, 0xf4, 0x46, 0x3c, 0x99,
0x5d, 0xb5, 0x11, 0xe1, 0xd6, 0xe1, 0x27, 0x3c, 0xb9, 0x1c, 0x28, 0xc6,
0xf0, 0xf5, 0xa9, 0xf0, 0xf9, 0xce, 0xf9, 0x7d, 0x06, 0xfc, 0xff, 0xff,
0x04, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x1c, 0x00, 0x00, 0x00, 0x7b, 0xff, 0xff, 0xff, 0x10, 0x00, 0x00, 0x00,
0x6f, 0xff, 0xff, 0xff, 0xd9, 0xf1, 0xff, 0xff, 0xe9, 0xfd, 0xff, 0xff,
0xd3, 0xfe, 0xff, 0xff, 0x32, 0xfc, 0xff, 0xff, 0x04, 0x00, 0x00, 0x00,
0x48, 0x00, 0x00, 0x00, 0x6d, 0x1c, 0x31, 0x18, 0xcf, 0x71, 0x7f, 0xd8,
0x77, 0x55, 0x19, 0x12, 0x7f, 0x1b, 0x05, 0x5e, 0x3a, 0x23, 0x0f, 0xd0,
0x2d, 0x6b, 0x93, 0x48, 0x56, 0x81, 0x0f, 0x0c, 0xfc, 0x7f, 0x63, 0xdc,
0x6d, 0x33, 0x63, 0xea, 0xe6, 0xf8, 0x3e, 0x69, 0xdb, 0xd7, 0x7f, 0xa3,
0xbd, 0xdc, 0xe5, 0x42, 0x4a, 0x7f, 0x53, 0x01, 0x15, 0x7c, 0xf2, 0x81,
0xec, 0x68, 0x14, 0x73, 0xd4, 0x21, 0xad, 0x12, 0x66, 0x81, 0xae, 0x31,
0xe7, 0x91, 0xde, 0x25, 0x86, 0xfc, 0xff, 0xff, 0x04, 0x00, 0x00, 0x00,
0x08, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x40, 0x05, 0x00, 0x00,
0x9a, 0xfc, 0xff, 0xff, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
0x01, 0x00, 0x00, 0x00, 0xaa, 0xfc, 0xff, 0xff, 0x04, 0x00, 0x00, 0x00,
0x04, 0x00, 0x00, 0x00, 0x2a, 0x00, 0x00, 0x00, 0xba, 0xfc, 0xff, 0xff,
0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x31, 0x00, 0x00, 0x00,
0xca, 0xfc, 0xff, 0xff, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
0x01, 0x00, 0x00, 0x00, 0xda, 0xfc, 0xff, 0xff, 0x04, 0x00, 0x00, 0x00,
0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x34, 0xe9, 0xff, 0xff,
0x38, 0xe9, 0xff, 0xff, 0x0f, 0x00, 0x00, 0x00, 0x4d, 0x4c, 0x49, 0x52,
0x20, 0x43, 0x6f, 0x6e, 0x76, 0x65, 0x72, 0x74, 0x65, 0x64, 0x2e, 0x00,
0x01, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0e, 0x00,
0x18, 0x00, 0x14, 0x00, 0x10, 0x00, 0x0c, 0x00, 0x08, 0x00, 0x04, 0x00,
0x0e, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00,
0xbc, 0x03, 0x00, 0x00, 0xc0, 0x03, 0x00, 0x00, 0xc4, 0x03, 0x00, 0x00,
0x04, 0x00, 0x00, 0x00, 0x6d, 0x61, 0x69, 0x6e, 0x00, 0x00, 0x00, 0x00,
0x0f, 0x00, 0x00, 0x00, 0x84, 0x03, 0x00, 0x00, 0x3c, 0x03, 0x00, 0x00,
0xdc, 0x02, 0x00, 0x00, 0x94, 0x02, 0x00, 0x00, 0x6c, 0x02, 0x00, 0x00,
0x10, 0x02, 0x00, 0x00, 0xc0, 0x01, 0x00, 0x00, 0x7c, 0x01, 0x00, 0x00,
0x3c, 0x01, 0x00, 0x00, 0xf8, 0x00, 0x00, 0x00, 0xb8, 0x00, 0x00, 0x00,
0x90, 0x00, 0x00, 0x00, 0x58, 0x00, 0x00, 0x00, 0x24, 0x00, 0x00, 0x00,
0x04, 0x00, 0x00, 0x00, 0xc2, 0xfc, 0xff, 0xff, 0x08, 0x00, 0x00, 0x00,
0x0c, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00,
0x01, 0x00, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00, 0x26, 0xfd, 0xff, 0xff,
0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x09, 0x14, 0x00, 0x00, 0x00,
0x18, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0xb6, 0xfd, 0xff, 0xff,
0x00, 0x00, 0x80, 0x3f, 0x01, 0x00, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00,
0x01, 0x00, 0x00, 0x00, 0x1b, 0x00, 0x00, 0x00, 0x56, 0xfd, 0xff, 0xff,
0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x10, 0x00, 0x00, 0x00,
0x14, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x30, 0xea, 0xff, 0xff,
0x01, 0x00, 0x00, 0x00, 0x1b, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
0x1a, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00,
0x4a, 0xfe, 0xff, 0xff, 0x0c, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00,
0x04, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x1a, 0x00, 0x00, 0x00,
0x02, 0x00, 0x00, 0x00, 0x19, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00,
0xae, 0xfd, 0xff, 0xff, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05,
0x20, 0x00, 0x00, 0x00, 0x24, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00,
0x06, 0xff, 0xff, 0xff, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
0x19, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00,
0xea, 0xfd, 0xff, 0xff, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
0x1c, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00,
0xf8, 0xfe, 0xff, 0xff, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00,
0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00,
0x03, 0x00, 0x00, 0x00, 0x17, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00,
0x0c, 0x00, 0x00, 0x00, 0x2a, 0xfe, 0xff, 0xff, 0x14, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x05, 0x20, 0x00, 0x00, 0x00, 0x24, 0x00, 0x00, 0x00,
0x06, 0x00, 0x00, 0x00, 0x82, 0xff, 0xff, 0xff, 0x02, 0x00, 0x00, 0x00,
0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
0x01, 0x00, 0x00, 0x00, 0x17, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
0x16, 0x00, 0x00, 0x00, 0x66, 0xfe, 0xff, 0xff, 0x14, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x01, 0x1c, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00,
0x05, 0x00, 0x00, 0x00, 0x74, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x01,
0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
0x16, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x15, 0x00, 0x00, 0x00,
0x09, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0xa6, 0xfe, 0xff, 0xff,
0x24, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x30, 0x00, 0x00, 0x00,
0x34, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0e, 0x00,
0x14, 0x00, 0x00, 0x00, 0x10, 0x00, 0x0c, 0x00, 0x08, 0x00, 0x04, 0x00,
0x0e, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
0x15, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00,
0xf2, 0xfe, 0xff, 0xff, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
0x28, 0x00, 0x00, 0x00, 0x2c, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00,
0x0c, 0x00, 0x10, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x08, 0x00, 0x07, 0x00,
0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00,
0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00,
0x03, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00,
0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x10, 0x00, 0x0c, 0x00,
0x08, 0x00, 0x04, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00,
0x10, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
0x13, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00,
0x12, 0x00, 0x00, 0x00, 0x6e, 0xff, 0xff, 0xff, 0x1c, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x3b, 0x1c, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00,
0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x08, 0x00, 0x04, 0x00,
0x06, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
0x12, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00,
0x03, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00,
0xb2, 0xff, 0xff, 0xff, 0x24, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20,
0x24, 0x00, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
0x00, 0x00, 0x0e, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x04, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
0x01, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
0x10, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x1a, 0x00, 0x14, 0x00,
0x10, 0x00, 0x0c, 0x00, 0x0b, 0x00, 0x04, 0x00, 0x0e, 0x00, 0x00, 0x00,
0x1c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x37, 0x1c, 0x00, 0x00, 0x00,
0x20, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00,
0x08, 0x00, 0x07, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02,
0x01, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x0c, 0x00, 0x00, 0x00,
0x08, 0x00, 0x04, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00,
0x0c, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00,
0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
0x1d, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x1e, 0x00, 0x00, 0x00, 0x0c, 0x13, 0x00, 0x00, 0xa0, 0x12, 0x00, 0x00,
0x38, 0x12, 0x00, 0x00, 0xec, 0x11, 0x00, 0x00, 0xa0, 0x11, 0x00, 0x00,
0x54, 0x11, 0x00, 0x00, 0x0c, 0x11, 0x00, 0x00, 0x44, 0x10, 0x00, 0x00,
0x70, 0x0f, 0x00, 0x00, 0x4c, 0x0e, 0x00, 0x00, 0x18, 0x0d, 0x00, 0x00,
0x34, 0x0b, 0x00, 0x00, 0x40, 0x09, 0x00, 0x00, 0xd4, 0x08, 0x00, 0x00,
0x58, 0x08, 0x00, 0x00, 0xec, 0x07, 0x00, 0x00, 0xa4, 0x07, 0x00, 0x00,
0x58, 0x07, 0x00, 0x00, 0x08, 0x07, 0x00, 0x00, 0x7c, 0x06, 0x00, 0x00,
0x90, 0x05, 0x00, 0x00, 0xfc, 0x04, 0x00, 0x00, 0x08, 0x04, 0x00, 0x00,
0x74, 0x03, 0x00, 0x00, 0x80, 0x02, 0x00, 0x00, 0xec, 0x01, 0x00, 0x00,
0x70, 0x01, 0x00, 0x00, 0xdc, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00,
0x04, 0x00, 0x00, 0x00, 0x80, 0xed, 0xff, 0xff, 0x18, 0x00, 0x00, 0x00,
0x20, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x03, 0x44, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
0xff, 0xff, 0xff, 0xff, 0x04, 0x00, 0x00, 0x00, 0x6c, 0xed, 0xff, 0xff,
0x08, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x3b, 0x08, 0x00, 0x00, 0x00,
0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x00, 0x00, 0x00, 0x00,
0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
0xe8, 0xed, 0xff, 0xff, 0x18, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00,
0x40, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x09,
0x44, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff,
0x04, 0x00, 0x00, 0x00, 0xd4, 0xed, 0xff, 0xff, 0x08, 0x00, 0x00, 0x00,
0x14, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x80, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
0x00, 0x00, 0x80, 0x3b, 0x09, 0x00, 0x00, 0x00, 0x49, 0x64, 0x65, 0x6e,
0x74, 0x69, 0x74, 0x79, 0x31, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x50, 0xee, 0xff, 0xff,
0x18, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00,
0x1c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x09, 0x6c, 0x00, 0x00, 0x00,
0x02, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x04, 0x00, 0x00, 0x00,
0x3c, 0xee, 0xff, 0xff, 0x08, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00,
0x01, 0x00, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x9e, 0xa7, 0x91, 0x3e,
0x32, 0x00, 0x00, 0x00, 0x73, 0x65, 0x71, 0x75, 0x65, 0x6e, 0x74, 0x69,
0x61, 0x6c, 0x2f, 0x79, 0x5f, 0x70, 0x72, 0x65, 0x64, 0x2f, 0x4d, 0x61,
0x74, 0x4d, 0x75, 0x6c, 0x3b, 0x73, 0x65, 0x71, 0x75, 0x65, 0x6e, 0x74,
0x69, 0x61, 0x6c, 0x2f, 0x79, 0x5f, 0x70, 0x72, 0x65, 0x64, 0x2f, 0x42,
0x69, 0x61, 0x73, 0x41, 0x64, 0x64, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0xe0, 0xee, 0xff, 0xff,
0x18, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00,
0x1b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x09, 0x54, 0x00, 0x00, 0x00,
0x02, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x40, 0x05, 0x00, 0x00,
0xcc, 0xee, 0xff, 0xff, 0x08, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00,
0x01, 0x00, 0x00, 0x00, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0xd3, 0x72, 0x35, 0x3d,
0x1a, 0x00, 0x00, 0x00, 0x73, 0x65, 0x71, 0x75, 0x65, 0x6e, 0x74, 0x69,
0x61, 0x6c, 0x2f, 0x66, 0x6c, 0x61, 0x74, 0x74, 0x65, 0x6e, 0x2f, 0x52,
0x65, 0x73, 0x68, 0x61, 0x70, 0x65, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
0x01, 0x00, 0x00, 0x00, 0x40, 0x05, 0x00, 0x00, 0x58, 0xef, 0xff, 0xff,
0x18, 0x00, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00, 0x48, 0x00, 0x00, 0x00,
0x1a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x09, 0x64, 0x00, 0x00, 0x00,
0x04, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x07, 0x00, 0x00, 0x00,
0x06, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x4c, 0xef, 0xff, 0xff,
0x08, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00,
0x01, 0x00, 0x00, 0x00, 0xd3, 0x72, 0x35, 0x3d, 0x22, 0x00, 0x00, 0x00,
0x73, 0x65, 0x71, 0x75, 0x65, 0x6e, 0x74, 0x69, 0x61, 0x6c, 0x2f, 0x6d,
0x61, 0x78, 0x5f, 0x70, 0x6f, 0x6f, 0x6c, 0x69, 0x6e, 0x67, 0x32, 0x64,
0x5f, 0x32, 0x2f, 0x4d, 0x61, 0x78, 0x50, 0x6f, 0x6f, 0x6c, 0x00, 0x00,
0x04, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00,
0x06, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0xe8, 0xef, 0xff, 0xff,
0x18, 0x00, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00, 0x48, 0x00, 0x00, 0x00,
0x19, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x09, 0xc4, 0x00, 0x00, 0x00,
0x04, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x0d, 0x00, 0x00, 0x00,
0x0b, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0xdc, 0xef, 0xff, 0xff,
0x08, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00,
0x01, 0x00, 0x00, 0x00, 0xd3, 0x72, 0x35, 0x3d, 0x83, 0x00, 0x00, 0x00,
0x73, 0x65, 0x71, 0x75, 0x65, 0x6e, 0x74, 0x69, 0x61, 0x6c, 0x2f, 0x63,
0x6f, 0x6e, 0x76, 0x32, 0x64, 0x5f, 0x32, 0x2f, 0x52, 0x65, 0x6c, 0x75,
0x3b, 0x73, 0x65, 0x71, 0x75, 0x65, 0x6e, 0x74, 0x69, 0x61, 0x6c, 0x2f,
0x63, 0x6f, 0x6e, 0x76, 0x32, 0x64, 0x5f, 0x32, 0x2f, 0x42, 0x69, 0x61,
0x73, 0x41, 0x64, 0x64, 0x3b, 0x73, 0x65, 0x71, 0x75, 0x65, 0x6e, 0x74,
0x69, 0x61, 0x6c, 0x2f, 0x63, 0x6f, 0x6e, 0x76, 0x32, 0x64, 0x5f, 0x32,
0x2f, 0x43, 0x6f, 0x6e, 0x76, 0x32, 0x44, 0x3b, 0x73, 0x65, 0x71, 0x75,
0x65, 0x6e, 0x74, 0x69, 0x61, 0x6c, 0x2f, 0x63, 0x6f, 0x6e, 0x76, 0x32,
0x64, 0x5f, 0x32, 0x2f, 0x42, 0x69, 0x61, 0x73, 0x41, 0x64, 0x64, 0x2f,
0x52, 0x65, 0x61, 0x64, 0x56, 0x61, 0x72, 0x69, 0x61, 0x62, 0x6c, 0x65,
0x4f, 0x70, 0x2f, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x00,
0x04, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00,
0x0b, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0xd8, 0xf0, 0xff, 0xff,
0x18, 0x00, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00, 0x48, 0x00, 0x00, 0x00,
0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x09, 0x64, 0x00, 0x00, 0x00,
0x04, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x0d, 0x00, 0x00, 0x00,
0x0b, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0xcc, 0xf0, 0xff, 0xff,
0x08, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00,
0x01, 0x00, 0x00, 0x00, 0x59, 0x27, 0x11, 0x3d, 0x22, 0x00, 0x00, 0x00,
0x73, 0x65, 0x71, 0x75, 0x65, 0x6e, 0x74, 0x69, 0x61, 0x6c, 0x2f, 0x6d,
0x61, 0x78, 0x5f, 0x70, 0x6f, 0x6f, 0x6c, 0x69, 0x6e, 0x67, 0x32, 0x64,
0x5f, 0x31, 0x2f, 0x4d, 0x61, 0x78, 0x50, 0x6f, 0x6f, 0x6c, 0x00, 0x00,
0x04, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00,
0x0b, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x68, 0xf1, 0xff, 0xff,
0x18, 0x00, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00, 0x48, 0x00, 0x00, 0x00,
0x17, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x09, 0xc4, 0x00, 0x00, 0x00,
0x04, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x19, 0x00, 0x00, 0x00,
0x15, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x5c, 0xf1, 0xff, 0xff,
0x08, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00,
0x01, 0x00, 0x00, 0x00, 0x59, 0x27, 0x11, 0x3d, 0x83, 0x00, 0x00, 0x00,
0x73, 0x65, 0x71, 0x75, 0x65, 0x6e, 0x74, 0x69, 0x61, 0x6c, 0x2f, 0x63,
0x6f, 0x6e, 0x76, 0x32, 0x64, 0x5f, 0x31, 0x2f, 0x52, 0x65, 0x6c, 0x75,
0x3b, 0x73, 0x65, 0x71, 0x75, 0x65, 0x6e, 0x74, 0x69, 0x61, 0x6c, 0x2f,
0x63, 0x6f, 0x6e, 0x76, 0x32, 0x64, 0x5f, 0x31, 0x2f, 0x42, 0x69, 0x61,
0x73, 0x41, 0x64, 0x64, 0x3b, 0x73, 0x65, 0x71, 0x75, 0x65, 0x6e, 0x74,
0x69, 0x61, 0x6c, 0x2f, 0x63, 0x6f, 0x6e, 0x76, 0x32, 0x64, 0x5f, 0x31,
0x2f, 0x43, 0x6f, 0x6e, 0x76, 0x32, 0x44, 0x3b, 0x73, 0x65, 0x71, 0x75,
0x65, 0x6e, 0x74, 0x69, 0x61, 0x6c, 0x2f, 0x63, 0x6f, 0x6e, 0x76, 0x32,
0x64, 0x5f, 0x31, 0x2f, 0x42, 0x69, 0x61, 0x73, 0x41, 0x64, 0x64, 0x2f,
0x52, 0x65, 0x61, 0x64, 0x56, 0x61, 0x72, 0x69, 0x61, 0x62, 0x6c, 0x65,
0x4f, 0x70, 0x2f, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x00,
0x04, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x19, 0x00, 0x00, 0x00,
0x15, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x58, 0xf2, 0xff, 0xff,
0x18, 0x00, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00, 0x48, 0x00, 0x00, 0x00,
0x16, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x09, 0x64, 0x00, 0x00, 0x00,
0x04, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x19, 0x00, 0x00, 0x00,
0x15, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x4c, 0xf2, 0xff, 0xff,
0x08, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00,
0x01, 0x00, 0x00, 0x00, 0x62, 0x1d, 0xf7, 0x3c, 0x20, 0x00, 0x00, 0x00,
0x73, 0x65, 0x71, 0x75, 0x65, 0x6e, 0x74, 0x69, 0x61, 0x6c, 0x2f, 0x6d,
0x61, 0x78, 0x5f, 0x70, 0x6f, 0x6f, 0x6c, 0x69, 0x6e, 0x67, 0x32, 0x64,
0x2f, 0x4d, 0x61, 0x78, 0x50, 0x6f, 0x6f, 0x6c, 0x00, 0x00, 0x00, 0x00,
0x04, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x19, 0x00, 0x00, 0x00,
0x15, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0xe8, 0xf2, 0xff, 0xff,
0x18, 0x00, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00, 0x48, 0x00, 0x00, 0x00,
0x15, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x09, 0xbc, 0x00, 0x00, 0x00,
0x04, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x31, 0x00, 0x00, 0x00,
0x2a, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0xdc, 0xf2, 0xff, 0xff,
0x08, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00,
0x01, 0x00, 0x00, 0x00, 0x62, 0x1d, 0xf7, 0x3c, 0x7b, 0x00, 0x00, 0x00,
0x73, 0x65, 0x71, 0x75, 0x65, 0x6e, 0x74, 0x69, 0x61, 0x6c, 0x2f, 0x63,
0x6f, 0x6e, 0x76, 0x32, 0x64, 0x2f, 0x52, 0x65, 0x6c, 0x75, 0x3b, 0x73,
0x65, 0x71, 0x75, 0x65, 0x6e, 0x74, 0x69, 0x61, 0x6c, 0x2f, 0x63, 0x6f,
0x6e, 0x76, 0x32, 0x64, 0x2f, 0x42, 0x69, 0x61, 0x73, 0x41, 0x64, 0x64,
0x3b, 0x73, 0x65, 0x71, 0x75, 0x65, 0x6e, 0x74, 0x69, 0x61, 0x6c, 0x2f,
0x63, 0x6f, 0x6e, 0x76, 0x32, 0x64, 0x2f, 0x43, 0x6f, 0x6e, 0x76, 0x32,
0x44, 0x3b, 0x73, 0x65, 0x71, 0x75, 0x65, 0x6e, 0x74, 0x69, 0x61, 0x6c,
0x2f, 0x63, 0x6f, 0x6e, 0x76, 0x32, 0x64, 0x2f, 0x42, 0x69, 0x61, 0x73,
0x41, 0x64, 0x64, 0x2f, 0x52, 0x65, 0x61, 0x64, 0x56, 0x61, 0x72, 0x69,
0x61, 0x62, 0x6c, 0x65, 0x4f, 0x70, 0x2f, 0x72, 0x65, 0x73, 0x6f, 0x75,
0x72, 0x63, 0x65, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
0x31, 0x00, 0x00, 0x00, 0x2a, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00,
0xd0, 0xf3, 0xff, 0xff, 0x18, 0x00, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00,
0x48, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x09,
0x5c, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff,
0x31, 0x00, 0x00, 0x00, 0x2a, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
0xc4, 0xf3, 0xff, 0xff, 0x08, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00,
0x01, 0x00, 0x00, 0x00, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x0d, 0x5a, 0x59, 0x3d,
0x1a, 0x00, 0x00, 0x00, 0x73, 0x65, 0x71, 0x75, 0x65, 0x6e, 0x74, 0x69,
0x61, 0x6c, 0x2f, 0x72, 0x65, 0x73, 0x68, 0x61, 0x70, 0x65, 0x2f, 0x52,
0x65, 0x73, 0x68, 0x61, 0x70, 0x65, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
0x01, 0x00, 0x00, 0x00, 0x31, 0x00, 0x00, 0x00, 0x2a, 0x00, 0x00, 0x00,
0x01, 0x00, 0x00, 0x00, 0xba, 0xf4, 0xff, 0xff, 0x14, 0x00, 0x00, 0x00,
0x14, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02,
0x30, 0x00, 0x00, 0x00, 0xac, 0xf4, 0xff, 0xff, 0x20, 0x00, 0x00, 0x00,
0x73, 0x65, 0x71, 0x75, 0x65, 0x6e, 0x74, 0x69, 0x61, 0x6c, 0x2f, 0x72,
0x65, 0x73, 0x68, 0x61, 0x70, 0x65, 0x2f, 0x52, 0x65, 0x73, 0x68, 0x61,
0x70, 0x65, 0x2f, 0x73, 0x68, 0x61, 0x70, 0x65, 0x00, 0x00, 0x00, 0x00,
0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x06, 0xf5, 0xff, 0xff,
0x14, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x02, 0x30, 0x00, 0x00, 0x00, 0xf8, 0xf4, 0xff, 0xff,
0x20, 0x00, 0x00, 0x00, 0x73, 0x65, 0x71, 0x75, 0x65, 0x6e, 0x74, 0x69,
0x61, 0x6c, 0x2f, 0x72, 0x65, 0x73, 0x68, 0x61, 0x70, 0x65, 0x2f, 0x73,
0x74, 0x72, 0x69, 0x64, 0x65, 0x64, 0x5f, 0x73, 0x6c, 0x69, 0x63, 0x65,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x4e, 0xf5, 0xff, 0xff,
0x14, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x02, 0x28, 0x00, 0x00, 0x00, 0x40, 0xf5, 0xff, 0xff,
0x18, 0x00, 0x00, 0x00, 0x73, 0x65, 0x71, 0x75, 0x65, 0x6e, 0x74, 0x69,
0x61, 0x6c, 0x2f, 0x72, 0x65, 0x73, 0x68, 0x61, 0x70, 0x65, 0x2f, 0x53,
0x68, 0x61, 0x70, 0x65, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
0x02, 0x00, 0x00, 0x00, 0x30, 0xf5, 0xff, 0xff, 0x18, 0x00, 0x00, 0x00,
0x20, 0x00, 0x00, 0x00, 0x3c, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x09, 0x44, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
0xff, 0xff, 0xff, 0xff, 0x0a, 0x08, 0x00, 0x00, 0x1c, 0xf5, 0xff, 0xff,
0x08, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x01, 0x00, 0x00, 0x00,
0x0d, 0x5a, 0x59, 0x3d, 0x0c, 0x00, 0x00, 0x00, 0x74, 0x66, 0x6c, 0x2e,
0x71, 0x75, 0x61, 0x6e, 0x74, 0x69, 0x7a, 0x65, 0x00, 0x00, 0x00, 0x00,
0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x0a, 0x08, 0x00, 0x00,
0xfa, 0xf5, 0xff, 0xff, 0x14, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00,
0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x5c, 0x00, 0x00, 0x00,
0x74, 0xf5, 0xff, 0xff, 0x08, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00,
0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x01, 0x00, 0x00, 0x00, 0x78, 0x04, 0x6e, 0x39, 0x31, 0x00, 0x00, 0x00,
0x73, 0x65, 0x71, 0x75, 0x65, 0x6e, 0x74, 0x69, 0x61, 0x6c, 0x2f, 0x79,
0x5f, 0x70, 0x72, 0x65, 0x64, 0x2f, 0x42, 0x69, 0x61, 0x73, 0x41, 0x64,
0x64, 0x2f, 0x52, 0x65, 0x61, 0x64, 0x56, 0x61, 0x72, 0x69, 0x61, 0x62,
0x6c, 0x65, 0x4f, 0x70, 0x2f, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63,
0x65, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
0x72, 0xf6, 0xff, 0xff, 0x14, 0x00, 0x00, 0x00, 0x34, 0x00, 0x00, 0x00,
0x0e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x09, 0x48, 0x00, 0x00, 0x00,
0xec, 0xf5, 0xff, 0xff, 0x08, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00,
0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0xd9, 0xe7, 0xa7, 0x3b,
0x18, 0x00, 0x00, 0x00, 0x73, 0x65, 0x71, 0x75, 0x65, 0x6e, 0x74, 0x69,
0x61, 0x6c, 0x2f, 0x79, 0x5f, 0x70, 0x72, 0x65, 0x64, 0x2f, 0x4d, 0x61,
0x74, 0x4d, 0x75, 0x6c, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
0x04, 0x00, 0x00, 0x00, 0x40, 0x05, 0x00, 0x00, 0xda, 0xf6, 0xff, 0xff,
0x14, 0x00, 0x00, 0x00, 0xa8, 0x01, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x02, 0xd4, 0x01, 0x00, 0x00, 0x54, 0xf6, 0xff, 0xff,
0x08, 0x00, 0x00, 0x00, 0x0c, 0x01, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00,
0xcf, 0xc5, 0xa3, 0x38, 0xca, 0x35, 0x83, 0x38, 0x9d, 0x1c, 0xa7, 0x38,
0x07, 0x9f, 0xbc, 0x38, 0x7f, 0x85, 0xa0, 0x38, 0xb3, 0x58, 0x92, 0x38,
0xdf, 0xbb, 0x96, 0x38, 0xd2, 0xcd, 0x8a, 0x38, 0xa7, 0xcf, 0x8c, 0x38,
0x9b, 0xaf, 0x8d, 0x38, 0x1a, 0x55, 0xbd, 0x38, 0x2f, 0xcb, 0xab, 0x38,
0x15, 0xdb, 0x9c, 0x38, 0xd7, 0x9f, 0x96, 0x38, 0xee, 0x54, 0x95, 0x38,
0xd8, 0x22, 0x9d, 0x38, 0x0c, 0x9a, 0xa4, 0x38, 0xc2, 0x37, 0x06, 0x39,
0x7c, 0x53, 0xa4, 0x38, 0x7a, 0xb9, 0xf0, 0x38, 0xef, 0xcf, 0x8a, 0x38,
0x7c, 0x41, 0x88, 0x38, 0x95, 0x5b, 0x52, 0x38, 0x55, 0x82, 0xc9, 0x38,
0x86, 0x6d, 0x6c, 0x38, 0x0e, 0x08, 0x83, 0x38, 0x49, 0x49, 0x9c, 0x38,
0xa4, 0xe4, 0xa9, 0x38, 0x05, 0x8d, 0x84, 0x38, 0x3a, 0x03, 0x6c, 0x38,
0x7b, 0x34, 0xa7, 0x38, 0x4f, 0xc3, 0xa7, 0x38, 0x33, 0x00, 0x00, 0x00,
0x73, 0x65, 0x71, 0x75, 0x65, 0x6e, 0x74, 0x69, 0x61, 0x6c, 0x2f, 0x63,
0x6f, 0x6e, 0x76, 0x32, 0x64, 0x5f, 0x32, 0x2f, 0x42, 0x69, 0x61, 0x73,
0x41, 0x64, 0x64, 0x2f, 0x52, 0x65, 0x61, 0x64, 0x56, 0x61, 0x72, 0x69,
0x61, 0x62, 0x6c, 0x65, 0x4f, 0x70, 0x2f, 0x72, 0x65, 0x73, 0x6f, 0x75,
0x72, 0x63, 0x65, 0x00, 0x01, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00,
0xca, 0xf8, 0xff, 0xff, 0x14, 0x00, 0x00, 0x00, 0xa4, 0x01, 0x00, 0x00,
0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x09, 0xb8, 0x01, 0x00, 0x00,
0x44, 0xf8, 0xff, 0xff, 0x08, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00,
0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00,
0x2e, 0x6b, 0x10, 0x3b, 0x8e, 0x68, 0xe7, 0x3a, 0xf7, 0x5c, 0x13, 0x3b,
0xa7, 0x54, 0x26, 0x3b, 0x3a, 0x8d, 0x0d, 0x3b, 0x44, 0x0d, 0x01, 0x3b,
0xb5, 0xeb, 0x04, 0x3b, 0x25, 0xcd, 0xf4, 0x3a, 0x5d, 0x57, 0xf8, 0x3a,
0x56, 0xe2, 0xf9, 0x3a, 0x36, 0xf5, 0x26, 0x3b, 0xe5, 0x7d, 0x17, 0x3b,
0xb6, 0x51, 0x0a, 0x3b, 0xfd, 0xd2, 0x04, 0x3b, 0x2f, 0xaf, 0x03, 0x3b,
0xfe, 0x90, 0x0a, 0x3b, 0x56, 0x26, 0x11, 0x3b, 0x82, 0xb6, 0x6c, 0x3b,
0x1d, 0xe8, 0x10, 0x3b, 0xd1, 0x46, 0x54, 0x3b, 0xde, 0xd0, 0xf4, 0x3a,
0xa6, 0x4e, 0xf0, 0x3a, 0x9c, 0x7f, 0xb9, 0x3a, 0x0f, 0xb2, 0x31, 0x3b,
0xda, 0x7c, 0xd0, 0x3a, 0xe5, 0x17, 0xe7, 0x3a, 0x25, 0xd1, 0x09, 0x3b,
0xd9, 0xd0, 0x15, 0x3b, 0xe4, 0xc5, 0xe9, 0x3a, 0x1e, 0x1f, 0xd0, 0x3a,
0x03, 0x72, 0x13, 0x3b, 0xf6, 0xef, 0x13, 0x3b, 0x1a, 0x00, 0x00, 0x00,
0x73, 0x65, 0x71, 0x75, 0x65, 0x6e, 0x74, 0x69, 0x61, 0x6c, 0x2f, 0x63,
0x6f, 0x6e, 0x76, 0x32, 0x64, 0x5f, 0x32, 0x2f, 0x43, 0x6f, 0x6e, 0x76,
0x32, 0x44, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00,
0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00,
0xaa, 0xfa, 0xff, 0xff, 0x14, 0x00, 0x00, 0x00, 0xe8, 0x00, 0x00, 0x00,
0x0b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x14, 0x01, 0x00, 0x00,
0x24, 0xfa, 0xff, 0xff, 0x08, 0x00, 0x00, 0x00, 0x8c, 0x00, 0x00, 0x00,
0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x5f, 0x69, 0xbd, 0x38,
0x68, 0xc3, 0xc3, 0x38, 0xb4, 0x14, 0x9c, 0x38, 0x12, 0x8f, 0x82, 0x38,
0x91, 0x96, 0x8c, 0x38, 0x1e, 0xd6, 0xc1, 0x38, 0x2c, 0xa6, 0xa4, 0x38,
0x2b, 0xd9, 0x87, 0x38, 0xcc, 0x75, 0xb7, 0x38, 0x9b, 0xcf, 0xa2, 0x38,
0x22, 0xef, 0xad, 0x38, 0x52, 0x49, 0xb0, 0x38, 0xe6, 0xbe, 0xbc, 0x38,
0x31, 0xcf, 0x7c, 0x38, 0x33, 0xe1, 0xab, 0x38, 0xf2, 0x70, 0x79, 0x38,
0x33, 0x00, 0x00, 0x00, 0x73, 0x65, 0x71, 0x75, 0x65, 0x6e, 0x74, 0x69,
0x61, 0x6c, 0x2f, 0x63, 0x6f, 0x6e, 0x76, 0x32, 0x64, 0x5f, 0x31, 0x2f,
0x42, 0x69, 0x61, 0x73, 0x41, 0x64, 0x64, 0x2f, 0x52, 0x65, 0x61, 0x64,
0x56, 0x61, 0x72, 0x69, 0x61, 0x62, 0x6c, 0x65, 0x4f, 0x70, 0x2f, 0x72,
0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x00, 0x01, 0x00, 0x00, 0x00,
0x10, 0x00, 0x00, 0x00, 0xda, 0xfb, 0xff, 0xff, 0x14, 0x00, 0x00, 0x00,
0xe4, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x09,
0xf8, 0x00, 0x00, 0x00, 0x54, 0xfb, 0xff, 0xff, 0x08, 0x00, 0x00, 0x00,
0x88, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0xd9, 0x38, 0x44, 0x3b,
0x59, 0xcd, 0x4a, 0x3b, 0x61, 0xb1, 0x21, 0x3b, 0xd3, 0x40, 0x07, 0x3b,
0xa3, 0xa4, 0x11, 0x3b, 0x53, 0xce, 0x48, 0x3b, 0xb8, 0x91, 0x2a, 0x3b,
0x9c, 0xbb, 0x0c, 0x3b, 0x7e, 0x0e, 0x3e, 0x3b, 0x3b, 0xaa, 0x28, 0x3b,
0x25, 0x30, 0x34, 0x3b, 0xfc, 0x9f, 0x36, 0x3b, 0x3f, 0x88, 0x43, 0x3b,
0x1d, 0xf3, 0x02, 0x3b, 0x4d, 0x0f, 0x32, 0x3b, 0x7d, 0x34, 0x01, 0x3b,
0x1a, 0x00, 0x00, 0x00, 0x73, 0x65, 0x71, 0x75, 0x65, 0x6e, 0x74, 0x69,
0x61, 0x6c, 0x2f, 0x63, 0x6f, 0x6e, 0x76, 0x32, 0x64, 0x5f, 0x31, 0x2f,
0x43, 0x6f, 0x6e, 0x76, 0x32, 0x44, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
0x10, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
0x08, 0x00, 0x00, 0x00, 0xfa, 0xfc, 0xff, 0xff, 0x14, 0x00, 0x00, 0x00,
0x88, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02,
0xb4, 0x00, 0x00, 0x00, 0x74, 0xfc, 0xff, 0xff, 0x08, 0x00, 0x00, 0x00,
0x4c, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0xe6, 0x5d, 0xf6, 0x38,
0x6e, 0x71, 0xca, 0x38, 0xf0, 0x20, 0xfd, 0x38, 0xed, 0xae, 0x19, 0x39,
0x69, 0xf9, 0xdb, 0x38, 0x3a, 0x67, 0xfc, 0x38, 0x05, 0x6d, 0xd6, 0x38,
0x10, 0xc9, 0x1f, 0x39, 0x31, 0x00, 0x00, 0x00, 0x73, 0x65, 0x71, 0x75,
0x65, 0x6e, 0x74, 0x69, 0x61, 0x6c, 0x2f, 0x63, 0x6f, 0x6e, 0x76, 0x32,
0x64, 0x2f, 0x42, 0x69, 0x61, 0x73, 0x41, 0x64, 0x64, 0x2f, 0x52, 0x65,
0x61, 0x64, 0x56, 0x61, 0x72, 0x69, 0x61, 0x62, 0x6c, 0x65, 0x4f, 0x70,
0x2f, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x00, 0x00, 0x00,
0x01, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0xca, 0xfd, 0xff, 0xff,
0x14, 0x00, 0x00, 0x00, 0x88, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x09, 0x9c, 0x00, 0x00, 0x00, 0x44, 0xfd, 0xff, 0xff,
0x08, 0x00, 0x00, 0x00, 0x4c, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00,
0x50, 0x16, 0x11, 0x3b, 0xbb, 0x70, 0xee, 0x3a, 0xbc, 0x11, 0x15, 0x3b,
0xa8, 0x02, 0x35, 0x3b, 0x5e, 0x8b, 0x01, 0x3b, 0x5e, 0xa4, 0x14, 0x3b,
0xc8, 0x8d, 0xfc, 0x3a, 0x91, 0x32, 0x3c, 0x3b, 0x18, 0x00, 0x00, 0x00,
0x73, 0x65, 0x71, 0x75, 0x65, 0x6e, 0x74, 0x69, 0x61, 0x6c, 0x2f, 0x63,
0x6f, 0x6e, 0x76, 0x32, 0x64, 0x2f, 0x43, 0x6f, 0x6e, 0x76, 0x32, 0x44,
0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00,
0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
0x8e, 0xfe, 0xff, 0xff, 0x14, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00,
0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x28, 0x00, 0x00, 0x00,
0x80, 0xfe, 0xff, 0xff, 0x18, 0x00, 0x00, 0x00, 0x73, 0x65, 0x71, 0x75,
0x65, 0x6e, 0x74, 0x69, 0x61, 0x6c, 0x2f, 0x66, 0x6c, 0x61, 0x74, 0x74,
0x65, 0x6e, 0x2f, 0x43, 0x6f, 0x6e, 0x73, 0x74, 0x00, 0x00, 0x00, 0x00,
0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0xd2, 0xfe, 0xff, 0xff,
0x14, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x02, 0x30, 0x00, 0x00, 0x00, 0xc4, 0xfe, 0xff, 0xff,
0x22, 0x00, 0x00, 0x00, 0x73, 0x65, 0x71, 0x75, 0x65, 0x6e, 0x74, 0x69,
0x61, 0x6c, 0x2f, 0x72, 0x65, 0x73, 0x68, 0x61, 0x70, 0x65, 0x2f, 0x52,
0x65, 0x73, 0x68, 0x61, 0x70, 0x65, 0x2f, 0x73, 0x68, 0x61, 0x70, 0x65,
0x2f, 0x33, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1a, 0xff, 0xff, 0xff,
0x14, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x02, 0x30, 0x00, 0x00, 0x00, 0x0c, 0xff, 0xff, 0xff,
0x22, 0x00, 0x00, 0x00, 0x73, 0x65, 0x71, 0x75, 0x65, 0x6e, 0x74, 0x69,
0x61, 0x6c, 0x2f, 0x72, 0x65, 0x73, 0x68, 0x61, 0x70, 0x65, 0x2f, 0x52,
0x65, 0x73, 0x68, 0x61, 0x70, 0x65, 0x2f, 0x73, 0x68, 0x61, 0x70, 0x65,
0x2f, 0x32, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x62, 0xff, 0xff, 0xff,
0x14, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x02, 0x30, 0x00, 0x00, 0x00, 0x54, 0xff, 0xff, 0xff,
0x22, 0x00, 0x00, 0x00, 0x73, 0x65, 0x71, 0x75, 0x65, 0x6e, 0x74, 0x69,
0x61, 0x6c, 0x2f, 0x72, 0x65, 0x73, 0x68, 0x61, 0x70, 0x65, 0x2f, 0x52,
0x65, 0x73, 0x68, 0x61, 0x70, 0x65, 0x2f, 0x73, 0x68, 0x61, 0x70, 0x65,
0x2f, 0x31, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xaa, 0xff, 0xff, 0xff,
0x14, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x02, 0x38, 0x00, 0x00, 0x00, 0x9c, 0xff, 0xff, 0xff,
0x28, 0x00, 0x00, 0x00, 0x73, 0x65, 0x71, 0x75, 0x65, 0x6e, 0x74, 0x69,
0x61, 0x6c, 0x2f, 0x72, 0x65, 0x73, 0x68, 0x61, 0x70, 0x65, 0x2f, 0x73,
0x74, 0x72, 0x69, 0x64, 0x65, 0x64, 0x5f, 0x73, 0x6c, 0x69, 0x63, 0x65,
0x2f, 0x73, 0x74, 0x61, 0x63, 0x6b, 0x5f, 0x31, 0x00, 0x00, 0x00, 0x00,
0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0e, 0x00,
0x18, 0x00, 0x14, 0x00, 0x13, 0x00, 0x0c, 0x00, 0x08, 0x00, 0x04, 0x00,
0x0e, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00,
0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x38, 0x00, 0x00, 0x00,
0x04, 0x00, 0x04, 0x00, 0x04, 0x00, 0x00, 0x00, 0x26, 0x00, 0x00, 0x00,
0x73, 0x65, 0x71, 0x75, 0x65, 0x6e, 0x74, 0x69, 0x61, 0x6c, 0x2f, 0x72,
0x65, 0x73, 0x68, 0x61, 0x70, 0x65, 0x2f, 0x73, 0x74, 0x72, 0x69, 0x64,
0x65, 0x64, 0x5f, 0x73, 0x6c, 0x69, 0x63, 0x65, 0x2f, 0x73, 0x74, 0x61,
0x63, 0x6b, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
0x14, 0x00, 0x1c, 0x00, 0x18, 0x00, 0x17, 0x00, 0x10, 0x00, 0x0c, 0x00,
0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x14, 0x00, 0x00, 0x00,
0x18, 0x00, 0x00, 0x00, 0x2c, 0x00, 0x00, 0x00, 0x4c, 0x00, 0x00, 0x00,
0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x54, 0x00, 0x00, 0x00,
0x02, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x0a, 0x08, 0x00, 0x00,
0x0c, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x04, 0x00,
0x0c, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00,
0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x0d, 0x5a, 0x59, 0x3d,
0x0d, 0x00, 0x00, 0x00, 0x72, 0x65, 0x73, 0x68, 0x61, 0x70, 0x65, 0x5f,
0x69, 0x6e, 0x70, 0x75, 0x74, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
0x01, 0x00, 0x00, 0x00, 0x0a, 0x08, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00,
0xac, 0x00, 0x00, 0x00, 0x90, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00,
0x70, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x4c, 0x00, 0x00, 0x00,
0x2c, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
0xd0, 0xff, 0xff, 0xff, 0x19, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x19, 0xe0, 0xff, 0xff, 0xff, 0x09, 0x00, 0x00, 0x00,
0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x09, 0xf0, 0xff, 0xff, 0xff,
0x11, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x11,
0x0c, 0x00, 0x10, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x08, 0x00, 0x04, 0x00,
0x0c, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x03, 0xd0, 0xff, 0xff, 0xff, 0x16, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x16, 0xdc, 0xff, 0xff, 0xff, 0x53, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x53, 0xe8, 0xff, 0xff, 0xff, 0x2d, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x2d, 0xf4, 0xff, 0xff, 0xff, 0x4d, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x4d, 0x0c, 0x00, 0x0c, 0x00, 0x0b, 0x00, 0x00, 0x00,
0x00, 0x00, 0x04, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x72, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x72
};
const int intonly_quant_tflite_model_len = 18208;
|
/*
// Created by: Jacob Cassady
// Date Created: 10/9/2016
// Last Updated: 10/12/2016
*/
/* Problem Statement
Write a program to evaluate a postfix expression
*/
#include <string>
#include <iostream>
#include <stack>
#include <sstream>
using namespace std;
int charToInt(char input){
int output;
output = input - '0';
return output;
}
void displayStack(stack<int> stk){
cout << "stack = ";
for(unsigned i = 0; i<=stk.size(); i++){
cout << stk.top() << " ";
stk.pop();
}
cout << endl;
}
int evaluatePostfix(string input){
int output = 0;
string testString = "";
int num1=0,num2=0;
stack<int> stk;
int total = 0;
for(unsigned i = 0; i < input.length(); i++){
if(input[i] == '*' || input[i] == '+' || input[i] == '/' || input[i] == '-'){
cout << input[i] << endl;
displayStack(stk);
num1 = stk.top();
stk.pop();
num2 = stk.top();
stk.pop();
cout << "num1: " << num1 << endl;
cout << "num2: " << num2 << endl;
if(input[i] == '*'){
total = num1 * num2;
}
if(input[i] == '+'){
total = num1 + num2;
}
if(input[i] == '-'){
total = num2 - num1;
}
if(input[i] == '/'){
total = num2 / num1;
}
stk.push(total);
cout << "total: " << total << endl;
} else if (input[i] == ' '){
} else {
cout << input[i] << endl;
stk.push(charToInt(input[i]));
}
}
return total;
}
int main (void) {
string testString = "5 6 7 * + 3 - 4 * 3 + 4 * ";
int testint = 0;
testint = evaluatePostfix(testString);
cout << testint << endl;
cout << testint << endl;
return 0;
}
|
#include <iostream>
using namespace std;
int main() {
char a;
cout << "소문자 입력 : ";
cin >> a;
cout << a << "는 " << (int)(a - 'a') << "번째 영어 소문자";
}
|
#include "StdAfx.h"
#include "_FaceRecognizer.h"
std::vector<IplImage *> _FaceRecognizer::_faces;
std::vector<int> _FaceRecognizer::id;
CvSize _FaceRecognizer::imgsize;
int _FaceRecognizer::nEigens;
IplImage ** _FaceRecognizer::eigenVectArr;
CvMat * _FaceRecognizer::eigenValMat;
IplImage * _FaceRecognizer::pAvgTrainImg;
CvMat * _FaceRecognizer::projectedTrainFaceMat;
double _FaceRecognizer::threshold;
CvMat * _FaceRecognizer::personNumTruthMat;
int _FaceRecognizer::nPersons = 0;
void _FaceRecognizer::add(std::vector<IplImage *> person_face, int person_id)
{
IplImage **sized = new IplImage *[person_face.size()];
for (int i = 0 ; i < person_face.size() ; i++)
sized[i] = cvCreateImage(imgsize, IPL_DEPTH_8U, 3);
IplImage **gray = new IplImage *[person_face.size()];
for (int i = 0 ; i < person_face.size() ; i++)
gray[i] = cvCreateImage(imgsize,IPL_DEPTH_8U,1);
for(int i = 0 ; i < person_face.size() ; i++)
{
cvResize(person_face[i], sized[i], CV_INTER_LINEAR);
cvCvtColor(sized[i], gray[i], CV_BGR2GRAY);
cvEqualizeHist(gray[i],gray[i]);
_faces.push_back(gray[i]);
id.push_back(person_id);
}
nPersons ++;
}
void _FaceRecognizer::learn()
{
IplImage **face_arr = vectorToCArr();
int j = _faces.size();
int i;
CvTermCriteria calcLimit;
nEigens = _faces.size() - 1;
eigenVectArr = new IplImage *[nEigens];
for (i = 0 ; i < nEigens ; i++)
eigenVectArr[i] = cvCreateImage(imgsize, IPL_DEPTH_32F, 1);
eigenValMat = cvCreateMat(1, nEigens, CV_32FC1);
pAvgTrainImg = cvCreateImage(imgsize,IPL_DEPTH_32F, 1);
calcLimit = cvTermCriteria(CV_TERMCRIT_ITER, nEigens, 1);
personNumTruthMat = cvCreateMat(1, _faces.size() , CV_32SC1);
for(int i = 0 ; i < _faces.size() ; i++)
{
*(personNumTruthMat->data.i + i) = id[i];
}
cvCalcEigenObjects(_faces.size(),
(void *)face_arr,
(void *)eigenVectArr,
CV_EIGOBJ_NO_CALLBACK,
0,
0,
&calcLimit,
pAvgTrainImg,
eigenValMat->data.fl);
projectedTrainFaceMat = cvCreateMat(_faces.size(), nEigens, CV_32FC1);
for(i = 0 ; i < _faces.size() ; i++)
{
cvEigenDecomposite(
face_arr[i],
nEigens,
eigenVectArr,
0, 0,
pAvgTrainImg,
projectedTrainFaceMat->data.fl + i * nEigens);
}
}
IplImage **_FaceRecognizer::vectorToCArr()
{
IplImage **res = new IplImage *[_faces.size()];
for(int i = 0 ; i < _faces.size() ; i++)
{
res[i] = _faces[i];
}
return res;
}
int _FaceRecognizer::predict(IplImage *face)
{
IplImage *sized = cvCreateImage(imgsize, IPL_DEPTH_8U, 3);
IplImage *enhanced = cvCreateImage(imgsize, IPL_DEPTH_8U, 1);
cvShowImage("tt", face);
cvWaitKey();
cvResize(face, sized, CV_INTER_LINEAR);
cvCvtColor(sized, enhanced, CV_BGR2GRAY);
cvEqualizeHist(enhanced ,enhanced);
float *projectedTestFace;
projectedTestFace = (float *)cvAlloc(nEigens * sizeof(float));
int iNearest, nearest, truth;
cvEigenDecomposite(
enhanced,
nEigens,
eigenVectArr,
0, 0,
pAvgTrainImg,
projectedTestFace);
iNearest = findNearestNeighbor(projectedTestFace);
if(iNearest != -13)
return id[iNearest];
else
return -13;
}
int _FaceRecognizer::findNearestNeighbor(float * _projectedTestFace)
{
double leastDistSq = DBL_MAX;
int i, iTrain, iNearest;
for(iTrain = 0; iTrain < _faces.size(); iTrain++)
{
double distSq = 0;
for(i = 0 ; i < nEigens ; i++)
{
float d_i =
_projectedTestFace[i] -
projectedTrainFaceMat->data.fl[iTrain * nEigens + i];
distSq += d_i * d_i / eigenValMat->data.fl[i];
}
if(distSq <= leastDistSq)
{
leastDistSq = distSq;
iNearest = iTrain;
}
}
if (leastDistSq > threshold)
return -13; // the person is not known
else
return iNearest; // the person is known and his\her id is in iNearest
}
void _FaceRecognizer::save()
{
std::ofstream file("perosnIDs.dat");
CreateDirectoryA((LPCSTR)"pics", 0);
for (System::Int32 i = 0; i < id.size(); i++)
{
std::string path = "pics\\";
std::string temp;
_String::MarshalString(i.ToString(), temp);
path += temp + ".jpg";
cvSaveImage(path.c_str(), _faces[i]);
file << path << " " << id[i] << std::endl;
}
file.close();
}
void _FaceRecognizer::load()
{
imgsize.width = 92;
imgsize.height = 112;
threshold = 0.75;
std::ifstream file("perosnIDs.dat");
std::vector<IplImage *> paths;
std::vector<int> _ids;
System::Windows::Forms::MessageBox::Show("this is");
while(!file.eof())
{
int personId;
std::string imgPath;
file >> imgPath >> personId;
if(imgPath == "")
break;
paths.push_back(cvLoadImage(imgPath.c_str()));
_ids.push_back(personId);
}
addPersonFromFile(paths,_ids);
}
void _FaceRecognizer::addPersonFromFile(std::vector<IplImage *> _pics, std::vector<int> _ids)
{
if(_pics.size() == 0)
return;
std::vector<IplImage *>imgs;
int _id;
_id = _ids[0];
imgs.push_back(_pics[0]);
for(int i = 1; i < _pics.size(); i++)
{
if(_ids[i] == _id)
{
imgs.push_back(_pics[i]);
}
else
{
add(imgs, _id);
imgs.clear();
_id = _ids[i];
imgs.push_back(_pics[i]);
}
}
if (_pics.size() != 0)
{
add(imgs, _id);
imgs.clear();
}
}
|
/***************************************************************************
Copyright (c) 2020 Philip Fortier
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
***************************************************************************/
#pragma once
#include "Vocab99x.h"
#include "CompileInterfaces.h"
#include <unordered_map>
#include "Task.h"
#include "TokenDatabase.h"
class SCIClassBrowserNode;
class ISCIPropertyBag;
class AutoCompleteChoice;
struct ReloadScriptPayload;
class ITaskStatus;
enum class AutoCompleteSourceType;
namespace sci
{
class Script;
class MethodDefinition;
class ClassProperty;
class ClassDefinition;
class PropertyValue;
class ProcedureDefinition;
class VariableDecl;
}
class DependencyTracker;
//
// SCIClassBrowser
//
//
//
// Usage: AddScript's to it.
//
class SCIClassBrowser : public ICompileLog
{
public:
SCIClassBrowser(DependencyTracker &dependencyTracker);
~SCIClassBrowser();
void SetClassBrowserEvents(IClassBrowserEvents *pEvents);
// See my comments in the implementations
// These functions do not require using the lock.
std::unique_ptr<std::vector<sci::MethodDefinition*>> CreateMethodArray(const std::string &strObject, sci::Script *pScript = nullptr) const;
std::unique_ptr<std::vector<sci::ClassProperty*>> CreatePropertyArray(const std::string &strObject, sci::Script *pScript = nullptr, PCTSTR pszSuper = nullptr) const;
std::unique_ptr<std::vector<std::string>> CreatePropertyNameArray(const std::string &strObject, sci::Script *pScript = nullptr, PCTSTR pszSuper = nullptr) const;
std::unique_ptr<std::vector<std::string>> CreateSubSpeciesArray(const std::string &species);
std::vector<std::string> GetDirectSubclasses(const std::string &species);
//
// This operators similarly to GlobalLock/Unlock. Before calling any functions here,
// call Lock or TryLock, and make sure to call Unlock at the end (and don't hold on to
// any internal references you got back from the class browser!). This isn't very
// robust, but it is more performant than making copies of everything we hand out.
//
void Lock() const; // Blocks until it gets a lock.
bool TryLock() const; // Tries to get a lock for this thread
void Unlock() const; // Releases lock.
bool HasLock() const;
bool ReLoadFromSources(ITaskStatus &task);
void ReLoadFromCompiled(ITaskStatus &task);
void ReloadScript(const std::string &fullPath);
void TriggerReloadScript(const std::string &fullPath);
// The remaining public functions should only be called if within a lock, as they return
// information internal to this class.
const SCIClassBrowserNode *GetRoot(size_t i) const;
size_t GetNumRoots() const;
const sci::Script *GetLKGScript(WORD wScriptNumber);
const sci::Script *GetLKGScript(std::string fullPath);
const std::vector<std::unique_ptr<sci::VariableDecl>> *GetMainGlobals() const;
const std::vector<std::string> &GetKernelNames() const;
const std::vector<sci::ProcedureDefinition*> &GetPublicProcedures();
const std::vector<sci::ClassDefinition*> &GetAllClasses();
const std::vector<sci::Script*> &GetHeaders();
const SelectorTable &GetSelectorNames();
bool IsSubClassOf(PCTSTR pszClass, PCTSTR pszSuper);
void ResolveValue(WORD wScript, const sci::PropertyValue &In, sci::PropertyValue &Out);
bool ResolveValue(const sci::Script *pScript, const std::string &strValue, sci::PropertyValue &Out) const;
WORD GetScriptNumberHelper(sci::Script *pScript) const;
WORD GetScriptNumberHelperConst(const sci::Script *pScript, bool tryResolve = true) const;
bool GetPropertyValue(PCTSTR pszName, const sci::ClassDefinition *pClass, WORD *pw);
bool GetProperty(PCTSTR pszName, const sci::ClassDefinition *pClass, sci::PropertyValue &Out);
bool GetPropertyValue(PCTSTR pszName, ISCIPropertyBag *pBag, const sci::ClassDefinition *pClass, WORD *pw);
void GetAutoCompleteChoices(const std::string &prefix, AutoCompleteSourceType sourceTypes, std::vector<AutoCompleteChoice> &choices);
const sci::ClassDefinition *LookUpClass(const std::string &className) const;
std::unique_ptr<sci::Script> _LoadScript(PCTSTR pszPath);
void TriggerCustomIncludeCompile(std::string name);
sci::Script *GetCustomHeader(std::string name);
// Error reporting.
void ReportResult(const CompileResult &result);
void ClearErrors();
std::vector<CompileResult> GetErrors();
int HasErrors(); // 0: no erors, 1: errors, -1: unknown
void ExitSchedulerAndReset();
void OnOpenGame(SCIVersion version);
std::string GetRoomClassName();
void GetSyntaxHighlightClasses(std::unordered_set<std::string> &classes) const;
void GetSyntaxHighlightProcOrKernels(std::unordered_set<std::string> &procs) const;
private:
struct DefineValueCache
{
DefineValueCache() = default;
DefineValueCache(uint16_t value, IntegerFlags flags) : value(value), flags(flags) {}
uint16_t value;
IntegerFlags flags;
};
typedef std::unordered_map<std::string, std::unique_ptr<SCIClassBrowserNode>> class_map;
typedef std::unordered_map<WORD, std::vector<sci::ClassDefinition*>> instance_map;
typedef std::unordered_map<std::string, std::unique_ptr<sci::Script>> script_map;
typedef std::unordered_map<std::string, DefineValueCache> define_map;
typedef std::unordered_map<std::string, WORD> word_map;
void _AssertScriptsValid();
bool _CreateClassTree(ITaskStatus &task);
void _AddToClassTree(sci::Script& script);
bool _AddFileName(std::string fullPath, bool fReplace = false);
void _RemoveAllRelatedData(sci::Script *pScript);
void _AddHeaders();
void _AddHeader(PCTSTR pszHeaderPath);
void _CacheHeaderDefines();
void _AddInstanceToMap(sci::Script& script, sci::ClassDefinition *pClass);
void _AddSubclassesToArray(std::vector<std::string> &pArray, SCIClassBrowserNode *pBrowserInfo);
void _MaybeGenerateAutoCompleteTree();
const std::vector<sci::ProcedureDefinition*> &_GetPublicProcedures();
const std::vector<std::unique_ptr<sci::VariableDecl>> *_GetMainGlobals() const;
SCIVersion _version;
// This maps strings to SCIClassBrowserNode. e.g. gEgo to it's node in the tree
class_map _classMap;
TokenDatabase _aclist;
AutoCompleteSourceType _invalidAutoCompleteSources;
// Use a separate mutex for these, since potential for lock contention is low.
mutable std::mutex _mutexSyntaxHighlight;
std::unordered_set<std::string> _procsSyntaxHighlight;
std::unordered_set<std::string> _classesSyntaxHighlight;
// This maps script numbers to arrays of instances within them.
instance_map _instanceMap;
// This is an array of all instances, for use in the hierarchy tree.
std::vector<std::unique_ptr<SCIClassBrowserNode>> _instances;
// This is a list of script OMs
std::vector<std::unique_ptr<sci::Script>> _scripts;
std::vector<sci::Script*> _headers; // Note: _headers's pointers are owned by _headerMap
script_map _headerMap;
define_map _headerDefines; // Note: defines are owned by the _headerMap.
// This maps filenames to scriptnumbers.
word_map _filenameToScriptNumber;
struct TimeAndHeader
{
TimeAndHeader();
TimeAndHeader(FILETIME ft, std::unique_ptr<sci::Script> header);
TimeAndHeader(TimeAndHeader &&src);
TimeAndHeader &operator=(TimeAndHeader &&src);
TimeAndHeader(const TimeAndHeader &src) = delete;
TimeAndHeader &operator=(const TimeAndHeader &src) = delete;
FILETIME ft;
std::unique_ptr<sci::Script> header;
};
std::unordered_map<std::string, TimeAndHeader> _customHeaderMap;
// Cache;
const sci::Script *_pLKGScript;
WORD _wLKG;
bool _fPublicProceduresValid;
std::vector<sci::ProcedureDefinition*> _publicProcedures; // These store the pointers, but don't own them (perf)
bool _fPublicClassesValid;
std::vector<sci::ClassDefinition*> _allClasses;
// These are the files we look at
bool fFoundRoot;
std::vector<std::string> strRootNames; // We can have multiple roots, apparently.
const std::vector<std::string> &_kernelNames;
KernelTable _kernelNamesResource;
SelectorTable _selectorNames;
// Error reporting - protected by g_csErrorReport
std::vector<CompileResult> _errors;
mutable std::recursive_mutex _mutexClassBrowser;
mutable volatile int _fCBLocked;
mutable std::mutex _mutexErrorReport;
bool _fAbortBrowseInfoGeneration;
IClassBrowserEvents *_pEvents;
std::unique_ptr<BackgroundScheduler<ReloadScriptPayload>> _scheduler;
DependencyTracker &_dependencyTracker;
// A bit of a hack
std::string _roomClassName;
};
//
// Some helpers.
//
class ClassBrowserLock
{
public:
ClassBrowserLock(SCIClassBrowser &browser) : _browser(browser), _fLock(false), _fDidSomething(false) {}
~ClassBrowserLock()
{
ASSERT(_fDidSomething);
if (_fLock)
{
_browser.Unlock();
}
}
bool TryLock()
{
_fDidSomething = true;
_fLock = _browser.TryLock();
return _fLock;
}
void Lock()
{
_fDidSomething = true;
_browser.Lock();
_fLock = true;
}
private:
SCIClassBrowser &_browser;
bool _fLock;
bool _fDidSomething;
};
|
/*
Copyright (c) 2005-2023, University of Oxford.
All rights reserved.
University of Oxford means the Chancellor, Masters and Scholars of the
University of Oxford, having an administrative office at Wellington
Square, Oxford OX1 2JD, UK.
This file is part of Chaste.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright notice,
this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation
and/or other materials provided with the distribution.
* Neither the name of the University of Oxford 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 TESTCELLWISEDATAGRADIENT_HPP_
#define TESTCELLWISEDATAGRADIENT_HPP_
#include <cxxtest/TestSuite.h>
#include "CheckpointArchiveTypes.hpp"
#include <fstream>
#include "MeshBasedCellPopulationWithGhostNodes.hpp"
#include "CellwiseDataGradient.hpp"
#include "CellsGenerator.hpp"
#include "FixedG1GenerationalCellCycleModel.hpp"
#include "AbstractCellBasedTestSuite.hpp"
#include "TrianglesMeshReader.hpp"
#include "PetscSetupAndFinalize.hpp"
/**
* This class contains tests for methods on the class CellwiseDataGradient.
*/
class TestCellwiseDataGradient : public AbstractCellBasedTestSuite
{
public:
void TestCellwiseDataGradientVerySmallMesh()
{
// Create a simple mesh
TrianglesMeshReader<2,2> mesh_reader("mesh/test/data/square_2_elements");
MutableMesh<2,2> mesh;
mesh.ConstructFromMeshReader(mesh_reader);
// Create a cell population
std::vector<CellPtr> cells;
CellsGenerator<FixedG1GenerationalCellCycleModel, 2> cells_generator;
cells_generator.GenerateBasic(cells, mesh.GetNumNodes());
MeshBasedCellPopulation<2> cell_population(mesh, cells);
// Set up data: C(x,y) = x^2
for (unsigned i=0; i<mesh.GetNumNodes(); i++)
{
double x = mesh.GetNode(i)->rGetLocation()[0];
CellPtr p_cell = cell_population.GetCellUsingLocationIndex(mesh.GetNode(i)->GetIndex());
p_cell->GetCellData()->SetItem("x^2", x*x);
}
CellwiseDataGradient<2> gradient;
gradient.SetupGradients(cell_population, "x^2");
// With the algorithm being used, the numerical gradient is (1,0)
// for each of the nodes
for (unsigned i=0; i<mesh.GetNumNodes(); i++)
{
TS_ASSERT_DELTA(gradient.rGetGradient(i)(0), 1.0, 1e-9);
TS_ASSERT_DELTA(gradient.rGetGradient(i)(1), 0.0, 1e-9);
}
}
void TestCellwiseDataGradientFineMesh()
{
// Create a mesh: [0,2]x[0,2]
TrianglesMeshReader<2,2> mesh_reader("mesh/test/data/square_4096_elements");
MutableMesh<2,2> mesh;
mesh.ConstructFromMeshReader(mesh_reader);
// Create a cell population
std::vector<CellPtr> cells;
CellsGenerator<FixedG1GenerationalCellCycleModel, 2> cells_generator;
cells_generator.GenerateBasic(cells, mesh.GetNumNodes());
MeshBasedCellPopulation<2> cell_population(mesh, cells);
//////////////////////////////////
// C(x,y) = const
//////////////////////////////////
cell_population.SetDataOnAllCells("const", 1.0);
CellwiseDataGradient<2> gradient;
gradient.SetupGradients(cell_population, "const");
// Check gradient
for (unsigned i=0; i<mesh.GetNumNodes(); i++)
{
TS_ASSERT_DELTA(gradient.rGetGradient(i)(0), 0.0, 1e-9);
TS_ASSERT_DELTA(gradient.rGetGradient(i)(1), 0.0, 1e-9);
}
//////////////////////////////////
// Combined setup for
// C(x,y) = x-y
// and
// C(x,y) = x^2 - y^2
//////////////////////////////////
for (unsigned i=0; i<mesh.GetNumNodes(); i++)
{
double x = mesh.GetNode(i)->rGetLocation()[0];
double y = mesh.GetNode(i)->rGetLocation()[1];
CellPtr p_cell = cell_population.GetCellUsingLocationIndex(mesh.GetNode(i)->GetIndex());
p_cell->GetCellData()->SetItem("x-y", x-y);
p_cell->GetCellData()->SetItem("x^2 - y^2", x*x - y*y);
}
// Check gradient
gradient.SetupGradients(cell_population, "x-y");
for (unsigned i=0; i<mesh.GetNumNodes(); i++)
{
TS_ASSERT_DELTA(gradient.rGetGradient(i)(0), 1.0, 1e-9);
TS_ASSERT_DELTA(gradient.rGetGradient(i)(1), -1.0, 1e-9);
}
// Check gradient - here there is some numerical error
gradient.SetupGradients(cell_population, "x^2 - y^2");
for (unsigned i=0; i<mesh.GetNumNodes(); i++)
{
double x = mesh.GetNode(i)->rGetLocation()[0];
double y = mesh.GetNode(i)->rGetLocation()[1];
double tol = 0.3;
if (x==0 || x==2 || y==0 || y==2) //ie on boundary
{
tol = 0.6;
}
TS_ASSERT_DELTA(gradient.rGetGradient(i)(0), 2*x, tol);
TS_ASSERT_DELTA(gradient.rGetGradient(i)(1), -2*y, tol);
}
}
///\todo uncomment this test or remove it
// void TestCellwiseDataGradientWithGhostNodes()
// {
// // Create a mesh: [0,2]x[0,2]
// TrianglesMeshReader<2,2> mesh_reader("mesh/test/data/square_4096_elements");
// MutableMesh<2,2> mesh;
// mesh.ConstructFromMeshReader(mesh_reader);
//
// // Set boundary nodes to be ghost nodes, interior nodes to be cells
// std::vector<unsigned> cell_location_indices;
// for (unsigned i=0; i<mesh.GetNumNodes(); i++)
// {
// if (!(mesh.GetNode(i)->IsBoundaryNode()))
// {
// cell_location_indices.push_back(i);
// }
// }
//
// // Set up cells
// std::vector<CellPtr> cells;
// CellsGenerator<FixedG1GenerationalCellCycleModel, 2> cells_generator;
// cells_generator.GenerateBasic(cells, cell_location_indices.size());
//
// // Create a cell population
// MeshBasedCellPopulationWithGhostNodes<2> cell_population(mesh, cells, cell_location_indices);
//
// // Create an instance of CellwiseData and associate it with the cell population
// CellwiseData<2>* p_data = CellwiseData<2>::Instance();
// p_data->SetPopulationAndNumVars(&cell_population, 1);
//
// //////////////////////////////////
// // C(x,y) = x^2 - y^2
// //////////////////////////////////
// for (unsigned i=0; i<mesh.GetNumNodes(); i++)
// {
// double x = mesh.GetNode(i)->rGetLocation()[0];
// double y = mesh.GetNode(i)->rGetLocation()[1];
// if (mesh.GetNode(i)->IsBoundaryNode())
// {
// p_data->SetValue(DBL_MAX, mesh.GetNode(i)->GetIndex());
// }
// else
// {
// p_data->SetValue(x*x - y*y, mesh.GetNode(i)->GetIndex());
// }
// }
//
// // Check gradient - here there is some numerical error
//
// // The corner nodes are special because they have no adjacent real elements
// CellwiseDataGradient<2> gradient;
// gradient.SetupGradients(cell_population);
// for (unsigned i=0; i<mesh.GetNumNodes(); i++)
// {
// double x = mesh.GetNode(i)->rGetLocation()[0];
// double y = mesh.GetNode(i)->rGetLocation()[1];
//
// if (!(mesh.GetNode(i)->IsBoundaryNode())) // i.e. not ghost
// {
// int x_corner = 0;
//
// // Work out if on left or right
// if (x == 0.03125)
// {
// x_corner = -1;
// }
// if (x == 1.96875)
// {
// x_corner = 1;
// }
// int y_corner=0;
//
// // Work out if on top or bottom
// if (y == 0.03125)
// {
// y_corner = -1;
// }
// if (y == 1.96875)
// {
// y_corner = 1;
// }
//
// switch (x_corner*y_corner)
// {
// case 1: // bottom left or top right
// TS_ASSERT_DELTA(gradient.rGetGradient(i)(0), 0.0, 1e-9);
// TS_ASSERT_DELTA(gradient.rGetGradient(i)(1), 0.0, 1e-9);
// break;
// case -1: // bottom right or top left
// TS_ASSERT_DELTA(gradient.rGetGradient(i)(0), 2.0, 1e-9);
// TS_ASSERT_DELTA(gradient.rGetGradient(i)(1), -2.0, 1e-9);
// break;
// case 0: // otherwise
// TS_ASSERT_DELTA(gradient.rGetGradient(i)(0), 2*x, 0.3);
// TS_ASSERT_DELTA(gradient.rGetGradient(i)(1), -2*y, 0.3);
// break;
// default:
// break;
// }
// }
// }
//
// CellwiseData<2>::Destroy();
// }
};
#endif /*TESTCELLWISEDATAGRADIENT_HPP_*/
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.