blob_id stringlengths 40 40 | directory_id stringlengths 40 40 | path stringlengths 3 264 | content_id stringlengths 40 40 | detected_licenses listlengths 0 85 | license_type stringclasses 2 values | repo_name stringlengths 5 140 | snapshot_id stringlengths 40 40 | revision_id stringlengths 40 40 | branch_name stringclasses 905 values | visit_date timestamp[us]date 2015-08-09 11:21:18 2023-09-06 10:45:07 | revision_date timestamp[us]date 1997-09-14 05:04:47 2023-09-17 19:19:19 | committer_date timestamp[us]date 1997-09-14 05:04:47 2023-09-06 06:22:19 | github_id int64 3.89k 681M ⌀ | star_events_count int64 0 209k | fork_events_count int64 0 110k | gha_license_id stringclasses 22 values | gha_event_created_at timestamp[us]date 2012-06-07 00:51:45 2023-09-14 21:58:39 ⌀ | gha_created_at timestamp[us]date 2008-03-27 23:40:48 2023-08-21 23:17:38 ⌀ | gha_language stringclasses 141 values | src_encoding stringclasses 34 values | language stringclasses 1 value | is_vendor bool 1 class | is_generated bool 2 classes | length_bytes int64 3 10.4M | extension stringclasses 115 values | content stringlengths 3 10.4M | authors listlengths 1 1 | author_id stringlengths 0 158 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
bd7ba8597209563de38c009d59c5c3b6c07727c4 | 2ee949a4acaf752d1484ace8b4db4df1eef3efa9 | /ass4/server/Server.cpp | 140b097bc4f2d39c9f3b720bcad25b17f1bfecb9 | [] | no_license | afekaoh/Anomaly-Detector-AP1 | ade0f1fab782f79dcaa64b5eb14893ab953f049d | ebc2ac9f14145035d39e9db9e1026116d68986eb | refs/heads/master | 2023-04-07T00:32:31.978682 | 2021-04-17T19:19:00 | 2021-04-17T19:19:00 | 304,866,653 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,069 | cpp | /*
* Author: Adam Shapira; 3160044809
*/
#include "Server.h"
#include <thread>
#include <netdb.h>
Server::Server(int port) noexcept(false): socket_fd(-1) {
// setting up the server socket
struct sockaddr_in serverAdress{};
socket_fd = socket(AF_INET, SOCK_STREAM, 0);
if (socket_fd < 0) {
throw ("socket\n");
}
// setting up the ip
hostent* record = gethostbyname("localhost");
auto* address = (in_addr*) record->h_addr;
string ip_address = inet_ntoa(*address);
serverAdress.sin_family = AF_INET;
serverAdress.sin_port = htons(port);
if (inet_aton(ip_address.c_str(), &serverAdress.sin_addr) == 0) {
throw ("IP Address is not valid\n");
}
// binding the socket to the ip
if (bind(socket_fd, (const sockaddr*) &serverAdress, sizeof(serverAdress)) < 0)
throw ("Call to bind() failed\n");
}
void Server::start(ClientHandler &ch) noexcept(false) {
// creating a new thread for the listening
t = std::unique_ptr<std::thread>(new thread(&Server::startServer, this, std::ref(ch)));
}
void Server::startServer(ClientHandler &ch) const noexcept(false) {
// Listen for new connections
if (listen(socket_fd, 1) < 0) {
throw ("Error when listening to new connections\n");
}
// setting the timeout for 1 sec
struct timeval timeout{.tv_sec = 1, .tv_usec =0};
// setting up the socket
int client_socket_fd;
struct sockaddr_in clientAddress{};
socklen_t clientAddressLength = sizeof(clientAddress);
size_t timeLen = sizeof(timeout);
while (true) {
// starting the timout
if (setsockopt(socket_fd, SOL_SOCKET, SO_RCVTIMEO, (char*) &timeout, timeLen) < 0)
throw ("setsockopt failed\n");
client_socket_fd = accept(socket_fd, (sockaddr*) &clientAddress, &clientAddressLength);
if (client_socket_fd == -1) {
if (errno == EAGAIN || errno == EWOULDBLOCK)
//we got timeout
break;
else
throw "Error in accept\n";
}
// creating a new thread for every client
thread(&ClientHandler::handle, &ch, client_socket_fd).detach();
}
}
void Server::stop() {
t->join(); // do not delete this!
}
Server::~Server() {
}
| [
"50743751+afekaoh@users.noreply.github.com"
] | 50743751+afekaoh@users.noreply.github.com |
92a22f7be396fe88e37e1364e85918126aa7e497 | 99441588c7d6159064d9ce2b94d3743a37f85d33 | /xsens_ros_mti_driver/lib/xspublic/xscontroller/xsscanner.h | 0dead4fe10b69c345aca79ae1a27df2b0e09da96 | [
"BSD-2-Clause"
] | permissive | YZT1997/robolab_project | 2786f8983c4b02040da316cdd2c8f9bb73e2dd4c | a7edb588d3145356566e9dcc37b03f7429bcb7d6 | refs/heads/master | 2023-09-02T21:28:01.280464 | 2021-10-14T02:06:35 | 2021-10-14T02:06:35 | 369,128,037 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 11,692 | h |
// Copyright (c) 2003-2021 Xsens Technologies B.V. or subsidiaries worldwide.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without modification,
// are permitted provided that the following conditions are met:
//
// 1. Redistributions of source code must retain the above copyright notice,
// this list of conditions, and the following disclaimer.
//
// 2. Redistributions in binary form must reproduce the above copyright notice,
// this list of conditions, and the following disclaimer in the documentation
// and/or other materials provided with the distribution.
//
// 3. Neither the names of the copyright holders nor the names of their 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 HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
// OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
// HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY OR
// TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.THE LAWS OF THE NETHERLANDS
// SHALL BE EXCLUSIVELY APPLICABLE AND ANY DISPUTES SHALL BE FINALLY SETTLED UNDER THE RULES
// OF ARBITRATION OF THE INTERNATIONAL CHAMBER OF COMMERCE IN THE HAGUE BY ONE OR MORE
// ARBITRATORS APPOINTED IN ACCORDANCE WITH SAID RULES.
//
// Copyright (c) 2003-2021 Xsens Technologies B.V. or subsidiaries worldwide.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without modification,
// are permitted provided that the following conditions are met:
//
// 1. Redistributions of source code must retain the above copyright notice,
// this list of conditions, and the following disclaimer.
//
// 2. Redistributions in binary form must reproduce the above copyright notice,
// this list of conditions, and the following disclaimer in the documentation
// and/or other materials provided with the distribution.
//
// 3. Neither the names of the copyright holders nor the names of their 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 HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
// OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
// HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY OR
// TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.THE LAWS OF THE NETHERLANDS
// SHALL BE EXCLUSIVELY APPLICABLE AND ANY DISPUTES SHALL BE FINALLY SETTLED UNDER THE RULES
// OF ARBITRATION OF THE INTERNATIONAL CHAMBER OF COMMERCE IN THE HAGUE BY ONE OR MORE
// ARBITRATORS APPOINTED IN ACCORDANCE WITH SAID RULES.
//
#ifndef XSSCANNER_H
#define XSSCANNER_H
#include "xscontrollerconfig.h"
#include <xstypes/xsbaud.h>
//AUTO namespace xstypes {
struct XsPortInfoArray;
//AUTO }
//AUTO namespace xscontroller {
struct XsUsbHubInfo;
//AUTO }
#ifdef __cplusplus
#include <xstypes/xsportinfoarray.h>
#include <xstypes/xsintarray.h>
#include <xstypes/xsstringarray.h>
#include "xsusbhubinfo.h"
#include <xstypes/xsstring.h>
#include <sstream>
extern "C" {
#endif
struct XsPortInfo;
//! \brief Defines the callback type that can be supplied to XsScanner_setScanLogCallback
typedef void (*XsScanLogCallbackFunc)(struct XsString const*);
XDA_DLL_API void XsScanner_scanPorts(struct XsPortInfoArray* ports, XsBaudRate baudrate, int singleScanTimeout, int ignoreNonXsensDevices, int detectRs485);
XDA_DLL_API int XsScanner_scanPort(struct XsPortInfo* port, XsBaudRate baudrate, int singleScanTimeout, int detectRs485);
XDA_DLL_API void XsScanner_enumerateSerialPorts(struct XsPortInfoArray* ports, int ignoreNonXsensDevices);
XDA_DLL_API void XsScanner_filterResponsiveDevices(struct XsPortInfoArray* ports, XsBaudRate baudrate, int singleScanTimeout, int detectRs485);
XDA_DLL_API void XsScanner_enumerateUsbDevices(struct XsPortInfoArray* ports);
XDA_DLL_API void XsScanner_scanUsbHub(struct XsUsbHubInfo* hub, const struct XsPortInfo* port);
XDA_DLL_API void XsScanner_enumerateNetworkDevices(struct XsPortInfoArray* ports);
XDA_DLL_API void XsScanner_abortScan(void);
XDA_DLL_API void XsScanner_setScanLogCallback(XsScanLogCallbackFunc cb);
#ifdef __cplusplus
} // extern "C"
class XsScanner {
public:
/*! \brief Scan all ports for Xsens devices.
\param[in] baudrate The baudrate to scan at. When set to XBR_Invalid, all known baudrates are scanned.
\param[in] singleScanTimeout The timeout of a scan of a single port at a single baud rate in ms.
\param[in] ignoreNonXsensDevices When true (the default), only Xsens devices are returned. Otherwise other devices that comply with the Xsens message protocol will also be returned.
\param[in] detectRs485 Enable more extended scan to detect rs485 devices
\returns The list of detected ports.
\sa XsScanner_scanPorts
*/
static inline XsPortInfoArray scanPorts(XsBaudRate baudrate = XBR_Invalid, int singleScanTimeout = 100, bool ignoreNonXsensDevices = true, bool detectRs485 = false)
{
XsPortInfoArray ports;
XsScanner_scanPorts(&ports, baudrate, singleScanTimeout, ignoreNonXsensDevices?1:0, detectRs485?1:0);
return ports;
}
//! \copydoc XsScanner_scanPort
static inline bool XSNOCOMEXPORT scanPort(XsPortInfo& port, XsBaudRate baudrate = XBR_Invalid, int singleScanTimeout = 100, bool detectRs485 = false)
{
return 0 != XsScanner_scanPort(&port, baudrate, singleScanTimeout, detectRs485?1:0);
}
/*! \brief Scan a single port for Xsens devices.
\param[in] portName The name of the port to scan.
\param[in] baudrate The baudrate to scan at. When set to XBR_Invalid, all known baudrates are scanned.
\param[in] singleScanTimeout The timeout of a scan at a single baud rate in ms.
\param[in] detectRs485 Enable more extended scan to detect rs485 devices
\returns An XsPortInfo structure with the results of the scan.
\sa XsScanner_scanPort
*/
static inline XsPortInfo scanPort(const XsString& portName, XsBaudRate baudrate = XBR_Invalid, int singleScanTimeout = 100, bool detectRs485 = false)
{
XsPortInfo pi(portName, baudrate);
if (scanPort(pi, baudrate, singleScanTimeout, detectRs485))
return pi;
return XsPortInfo();
}
/*! \brief Scan a list of Com ports for Xsens devices.
\param[in] portList The list of port names to scan.
\param[in] portLinesOptionsList The list of hardware flow control options for the ports to scan.
\param[in] baudrate The baudrate to scan at. When set to XBR_Invalid, all known baudrates are scanned.
\param[in] singleScanTimeout The timeout of a scan at a single baud rate in ms.
\returns An array of XsPortInfo structures with the results of the scan.
\sa XsScanner_scanCOMPortList
*/
static inline XsPortInfoArray scanComPortList(const XsStringArray& portList, const XsIntArray& portLinesOptionsList = XsIntArray(), XsBaudRate baudrate = XBR_Invalid, int singleScanTimeout = 100)
{
XsPortInfoArray pInfoArray;
if (!portLinesOptionsList.empty() && (portLinesOptionsList.size() != portList.size()))
return pInfoArray;
for (XsIntArray::size_type idxPort = 0; idxPort < portList.size(); ++idxPort)
{
const XsPortLinesOptions portLinesOptions = portLinesOptionsList.empty() ? XPLO_All_Ignore : static_cast<XsPortLinesOptions>(portLinesOptionsList[idxPort]);
XsPortInfo portInfo(portList[idxPort], baudrate, portLinesOptions);
if (scanPort(portInfo, baudrate, singleScanTimeout, (portLinesOptions == XPLO_All_Clear))) // XPLO_All_Clear == both RTS/DTR to 0 (RS485).
pInfoArray.push_back(portInfo);
}
return pInfoArray;
}
/*! \brief List all serial ports without scanning
\param ignoreNonXsensDevices When true (the default), only Xsens ports are returned.
\returns The list of detected ports.
*/
static inline XsPortInfoArray enumerateSerialPorts(bool ignoreNonXsensDevices = true)
{
XsPortInfoArray ports;
XsScanner_enumerateSerialPorts(&ports, ignoreNonXsensDevices?1:0);
return ports;
}
/*! \brief Scan the supplied ports for Xsens devices.
\details This function does not modify the input list as opposed to XsScanner_filterResponsiveDevices
\param[in] ports The list of ports to scan.
\param[in] baudrate The baudrate to scan at. When set to XBR_Invalid, all known baudrates are scanned.
\param[in] singleScanTimeout The timeout of a scan of a single port at a single baud rate in ms.
\param[in] detectRs485 Enable more extended scan to detect rs485 devices
\returns The list of ports that have responsive devices on them.
\sa XsScanner_filterResponsiveDevices
*/
static inline XsPortInfoArray filterResponsiveDevices(const XsPortInfoArray& ports, XsBaudRate baudrate = XBR_Invalid, int singleScanTimeout = 100, bool detectRs485 = false)
{
XsPortInfoArray filtered(ports);
XsScanner_filterResponsiveDevices(&filtered, baudrate, singleScanTimeout, detectRs485?1:0);
return filtered;
}
/*! \brief List all compatible USB ports without scanning.
\returns The list of detected usb devices.
\sa XsScanner_enumerateUsbDevices
*/
static inline XsPortInfoArray enumerateUsbDevices(void)
{
XsPortInfoArray ports;
XsScanner_enumerateUsbDevices(&ports);
return ports;
}
/*! \brief Determine the USB hub that \a port is attached to
\param port The port for which to determine the USB hub.
\returns The identifier of the hub that \a port is attached to.
\sa XsScanner_scanUsbHub
*/
static inline XsUsbHubInfo scanUsbHub(const XsPortInfo& port)
{
XsUsbHubInfo hub;
XsScanner_scanUsbHub(&hub, &port);
return hub;
}
/*! \brief List all compatible network devices without scanning.
\returns The list of detected network services.
\sa XsScanner_enumerateNetworkDevices
*/
static inline XsPortInfoArray enumerateNetworkDevices(void)
{
XsPortInfoArray ports;
XsScanner_enumerateNetworkDevices(&ports);
return ports;
}
/*! \brief Abort the currently running port scan(s)
\sa XsScanner_abortScan
*/
static inline void abortScan(void)
{
XsScanner_abortScan();
}
/*! \brief Set a callback function for scan log progress and problem reporting
\details When set, any scan will use the provided callback function to report progress and failures.
Normal operation is not affected, so all return values for the scan functions remain valid.
\param cb The callback function to use. When set to NULL, no callbacks will be generated.
\sa XsScanner_setScanLogCallback
*/
static inline void XSNOCOMEXPORT setScanLogCallback(XsScanLogCallbackFunc cb)
{
XsScanner_setScanLogCallback(cb);
}
};
#endif
#endif
| [
"yangzt_0943@163.com"
] | yangzt_0943@163.com |
a0b2162a30a468ca1cf81448e8cf23bc6918f69c | 872095f6ca1d7f252a1a3cb90ad73e84f01345a2 | /mediatek/proprietary/hardware/mtkcam/middleware/common/include/v3/utils/streaminfo/IStreamInfoSetControl.h | c9c9ec50e3fc219616abcf99783ba9e1564d49d3 | [] | no_license | colinovski/mt8163-vendor | 724c49a47e1fa64540efe210d26e72c883ee591d | 2006b5183be2fac6a82eff7d9ed09c2633acafcc | refs/heads/master | 2020-07-04T12:39:09.679221 | 2018-01-20T09:11:52 | 2018-01-20T09:11:52 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 13,078 | h | /* Copyright Statement:
*
* This software/firmware and related documentation ("MediaTek Software") are
* protected under relevant copyright laws. The information contained herein is
* confidential and proprietary to MediaTek Inc. and/or its licensors. Without
* the prior written permission of MediaTek inc. and/or its licensors, any
* reproduction, modification, use or disclosure of MediaTek Software, and
* information contained herein, in whole or in part, shall be strictly
* prohibited.
*
* MediaTek Inc. (C) 2010. All rights reserved.
*
* BY OPENING THIS FILE, RECEIVER HEREBY UNEQUIVOCALLY ACKNOWLEDGES AND AGREES
* THAT THE SOFTWARE/FIRMWARE AND ITS DOCUMENTATIONS ("MEDIATEK SOFTWARE")
* RECEIVED FROM MEDIATEK AND/OR ITS REPRESENTATIVES ARE PROVIDED TO RECEIVER
* ON AN "AS-IS" BASIS ONLY. MEDIATEK EXPRESSLY DISCLAIMS ANY AND ALL
* WARRANTIES, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED
* WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR
* NONINFRINGEMENT. NEITHER DOES MEDIATEK PROVIDE ANY WARRANTY WHATSOEVER WITH
* RESPECT TO THE SOFTWARE OF ANY THIRD PARTY WHICH MAY BE USED BY,
* INCORPORATED IN, OR SUPPLIED WITH THE MEDIATEK SOFTWARE, AND RECEIVER AGREES
* TO LOOK ONLY TO SUCH THIRD PARTY FOR ANY WARRANTY CLAIM RELATING THERETO.
* RECEIVER EXPRESSLY ACKNOWLEDGES THAT IT IS RECEIVER'S SOLE RESPONSIBILITY TO
* OBTAIN FROM ANY THIRD PARTY ALL PROPER LICENSES CONTAINED IN MEDIATEK
* SOFTWARE. MEDIATEK SHALL ALSO NOT BE RESPONSIBLE FOR ANY MEDIATEK SOFTWARE
* RELEASES MADE TO RECEIVER'S SPECIFICATION OR TO CONFORM TO A PARTICULAR
* STANDARD OR OPEN FORUM. RECEIVER'S SOLE AND EXCLUSIVE REMEDY AND MEDIATEK'S
* ENTIRE AND CUMULATIVE LIABILITY WITH RESPECT TO THE MEDIATEK SOFTWARE
* RELEASED HEREUNDER WILL BE, AT MEDIATEK'S OPTION, TO REVISE OR REPLACE THE
* MEDIATEK SOFTWARE AT ISSUE, OR REFUND ANY SOFTWARE LICENSE FEES OR SERVICE
* CHARGE PAID BY RECEIVER TO MEDIATEK FOR SUCH MEDIATEK SOFTWARE AT ISSUE.
*
* The following software/firmware and/or related documentation ("MediaTek
* Software") have been modified by MediaTek Inc. All revisions are subject to
* any receiver's applicable license agreements with MediaTek Inc.
*/
#ifndef _MTK_HARDWARE_INCLUDE_MTKCAM_V3_UTILS_STREAMINFO_ISTREAMINFOSETCONTROL_H_
#define _MTK_HARDWARE_INCLUDE_MTKCAM_V3_UTILS_STREAMINFO_ISTREAMINFOSETCONTROL_H_
//
#include <utils/KeyedVector.h>
#include <v3/stream/IStreamInfo.h>
/******************************************************************************
*
******************************************************************************/
namespace NSCam {
namespace v3 {
namespace Utils {
/**
* An interface of stream info set control.
*/
class SimpleStreamInfoSetControl
: public virtual IStreamInfoSet
{
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// Definitions.
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
public: ////
template <class IStreamInfoT>
struct Map
: public IMap<IStreamInfoT>
, public android::KeyedVector<StreamId_T, android::sp<IStreamInfoT> >
{
public: ////
typedef android::KeyedVector<StreamId_T, android::sp<IStreamInfoT> >
ParentT;
typedef typename ParentT::key_type key_type;
typedef typename ParentT::value_type value_type;
public: //// Operations.
virtual size_t size() const
{
return ParentT::size();
}
virtual ssize_t indexOfKey(StreamId_T id) const
{
return ParentT::indexOfKey(id);
}
virtual android::sp<IStreamInfoT> valueFor(StreamId_T id) const
{
return ParentT::valueFor(id);
}
virtual android::sp<IStreamInfoT> valueAt(size_t index) const
{
return ParentT::valueAt(index);
}
ssize_t addStream(value_type const& p)
{
return ParentT::add(p->getStreamId(), p);
}
};
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// Implementations.
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
protected: //// Data Members.
android::sp<Map<IMetaStreamInfo> > mpMeta;
android::sp<Map<IImageStreamInfo> > mpImage;
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// Interface.
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
public: //// Operations.
SimpleStreamInfoSetControl()
: mpMeta(new Map<IMetaStreamInfo>)
, mpImage(new Map<IImageStreamInfo>)
{
}
virtual Map<IMetaStreamInfo> const& getMeta() const { return *mpMeta; }
virtual Map<IImageStreamInfo>const& getImage()const { return *mpImage; }
virtual Map<IMetaStreamInfo>& editMeta() { return *mpMeta; }
virtual Map<IImageStreamInfo>& editImage() { return *mpImage; }
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// IStreamInfoSet Interface.
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
public: //// Operations.
#define _IMPLEMENT_(_type_) \
virtual android::sp<IMap<I##_type_##StreamInfo> > \
get##_type_##InfoMap() const { return mp##_type_; } \
\
virtual size_t \
get##_type_##InfoNum() const { return mp##_type_->size(); } \
\
virtual android::sp<I##_type_##StreamInfo> \
get##_type_##InfoFor(StreamId_T id) const { return mp##_type_->valueFor(id); } \
\
virtual android::sp<I##_type_##StreamInfo> \
get##_type_##InfoAt(size_t index) const { return mp##_type_->valueAt(index); }
_IMPLEMENT_(Meta)
_IMPLEMENT_(Image)
#undef _IMPLEMENT_
};
/**
* An interface of stream info set control.
*/
class IStreamInfoSetControl
: public IStreamInfoSet
{
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// IStreamInfoSetControl Interface.
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
public: //// Definitions.
template <class IStreamInfoT>
struct Map
: public android::KeyedVector<StreamId_T, android::sp<IStreamInfoT> >
{
public: ////
typedef android::KeyedVector<StreamId_T, android::sp<IStreamInfoT> >
ParentT;
typedef typename ParentT::key_type key_type;
typedef typename ParentT::value_type value_type;
public: //// Operations.
ssize_t addStream(value_type const& p)
{
return ParentT::add(p->getStreamId(), p);
}
};
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// Implementations.
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
protected: //// Definitions.
template <class IStreamInfoT>
struct Set
: public IMap<IStreamInfoT>
{
typedef Map<IStreamInfoT> MapT;
MapT mApp;
MapT mHal;
size_t size() const
{
return mApp.size() + mHal.size();
}
virtual ssize_t indexOfKey(StreamId_T id) const
{
ssize_t index = 0;
if ( 0 <= (index = mApp.indexOfKey(id)) ) return index;
if ( 0 <= (index = mHal.indexOfKey(id)) ) return index + mApp.size();
return NAME_NOT_FOUND;
}
virtual android::sp<IStreamInfoT> valueFor(StreamId_T id) const
{
ssize_t index = 0;
if ( 0 <= (index = mApp.indexOfKey(id)) ) return mApp.valueAt(index);
if ( 0 <= (index = mHal.indexOfKey(id)) ) return mHal.valueAt(index);
return NULL;
}
virtual android::sp<IStreamInfoT> valueAt(size_t index) const
{
if ( mApp.size() > index ) return mApp.valueAt(index);
index -= mApp.size();
if ( mHal.size() > index ) return mHal.valueAt(index);
return NULL;
}
};
protected: //// Data Members.
android::sp<Set<IMetaStreamInfo> > mpSetMeta;
android::sp<Set<IImageStreamInfo> > mpSetImage;
protected: //// Operations.
IStreamInfoSetControl()
: mpSetMeta(new Set<IMetaStreamInfo>)
, mpSetImage(new Set<IImageStreamInfo>)
{}
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// IStreamInfoSetControl Interface.
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
public: //// Operations.
static IStreamInfoSetControl* create() { return new IStreamInfoSetControl; }
virtual Map<IMetaStreamInfo> const& getAppMeta() const { return mpSetMeta->mApp; }
virtual Map<IMetaStreamInfo> const& getHalMeta() const { return mpSetMeta->mHal; }
virtual Map<IImageStreamInfo>const& getAppImage()const { return mpSetImage->mApp; }
virtual Map<IImageStreamInfo>const& getHalImage()const { return mpSetImage->mHal; }
virtual Map<IMetaStreamInfo>& editAppMeta() { return mpSetMeta->mApp; }
virtual Map<IMetaStreamInfo>& editHalMeta() { return mpSetMeta->mHal; }
virtual Map<IImageStreamInfo>& editAppImage() { return mpSetImage->mApp; }
virtual Map<IImageStreamInfo>& editHalImage() { return mpSetImage->mHal; }
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// IStreamInfoSet Interface.
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
public: //// Operations.
#define _IMPLEMENT_(_type_) \
virtual android::sp<IMap<I##_type_##StreamInfo> > \
get##_type_##InfoMap() const { return mpSet##_type_; } \
\
virtual size_t \
get##_type_##InfoNum() const { return mpSet##_type_->size(); } \
\
virtual android::sp<I##_type_##StreamInfo> \
get##_type_##InfoFor(StreamId_T id) const { return mpSet##_type_->valueFor(id); } \
\
virtual android::sp<I##_type_##StreamInfo> \
get##_type_##InfoAt(size_t index) const { return mpSet##_type_->valueAt(index); }
_IMPLEMENT_(Meta) // IMetaStreamInfo, mAppMeta, mHalMeta
_IMPLEMENT_(Image) //IImageStreamInfo, mAppImage, mHalImage
#undef _IMPLEMENT_
};
/******************************************************************************
*
******************************************************************************/
}; //namespace Utils
}; //namespace v3
}; //namespace NSCam
#endif //_MTK_HARDWARE_INCLUDE_MTKCAM_V3_UTILS_STREAMINFO_ISTREAMINFOSETCONTROL_H_
| [
"peishengguo@yydrobot.com"
] | peishengguo@yydrobot.com |
af61b662e334a89d8cf1a3998d9cfb5493379851 | 338f43cebbc5876dbb0fb97f2fae0cd4445ac956 | /c++程序设计作业11/concrete_subject3.h | 8bd39b68b9507e4ebe012b1dc17c3a86941d0003 | [] | no_license | LongJinhe-coder/cplusplus | 09fa92b53598d071bde28f9ad73b2f146395061c | 87e636b69c776cdae219fd0520eedede46021327 | refs/heads/master | 2020-09-22T01:49:18.064270 | 2020-08-02T08:28:51 | 2020-08-02T08:28:51 | 225,007,947 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 316 | h | #pragma once
#include"subject.h"
#include"concreteState3.h"
#include<string>
using std::string;
class concreteSubject3 :public subject {
public:
concreteSubject3(const string & name,const concreteState3 s=NULL) :subject(name) {}
state* getState() const {
return _state;
}
void setState(state *s) { _state = s;
}
}; | [
"[909642437@qq.com]"
] | [909642437@qq.com] |
b22e5480efddcbdfe3e8e9b75e9acf09b2a2e69a | a4fb3c4abaa5f774ae222dc7ede7f57cc1fb3b70 | /iOS/SMarket/Unity/Classes/Native/Il2CppCompilerCalculateTypeValues_3Table.cpp | 87c99bbc862c735b4dd7806d92aa0d23755e9bb2 | [] | no_license | vanessaaleung/SMarket | dbffe7a04f821f788fedda4e0f788e4e8cf95126 | fa139dc7d370824ad7a86fe902a474e6f1205731 | refs/heads/master | 2022-11-01T08:47:20.022983 | 2020-06-21T23:33:34 | 2020-06-21T23:33:34 | 205,718,090 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 333,146 | cpp | #include "il2cpp-config.h"
#ifndef _MSC_VER
# include <alloca.h>
#else
# include <malloc.h>
#endif
#include <cstring>
#include <string.h>
#include <stdio.h>
#include <cmath>
#include <limits>
#include <assert.h>
#include <stdint.h>
#include "il2cpp-class-internals.h"
#include "codegen/il2cpp-codegen.h"
#include "il2cpp-object-internals.h"
// System.AssemblyLoadEventArgs
struct AssemblyLoadEventArgs_t51DAAB04039C3B2D8C3FBF65C13441BC6C6A7AE8;
// System.AssemblyLoadEventHandler
struct AssemblyLoadEventHandler_t53F8340027F9EE67E8A22E7D8C1A3770345153C9;
// System.AsyncCallback
struct AsyncCallback_t3F3DA3BEDAEE81DD1D24125DF8EB30E85EE14DA4;
// System.AttributeUsageAttribute
struct AttributeUsageAttribute_t1B765F643562D0CD97D0B6B34D121C6AD9CE2388;
// System.ByteMatcher
struct ByteMatcher_tB199BDD35E2575B84D9FDED34954705653D241DC;
// System.Byte[]
struct ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821;
// System.Char
struct Char_tBF22D9FC341BE970735250BB6FF1A4A92BBA58B9;
// System.Char[]
struct CharU5BU5D_t4CC6ABF0AD71BEC97E3C2F1E9C5677E46D3A75C2;
// System.Collections.Generic.Dictionary`2<System.String,System.Object>
struct Dictionary_2_t9140A71329927AE4FD0F3CF4D4D66668EBE151EA;
// System.Collections.Generic.Dictionary`2<System.Type,System.AttributeUsageAttribute>
struct Dictionary_2_t10ABF562FF47B327563169FBB750047BF1341236;
// System.Collections.Generic.List`1<System.ModifierSpec>
struct List_1_tFD995FD9C5961BB4B415EE63B297C4B19643A3C2;
// System.Collections.Generic.List`1<System.String>
struct List_1_tE8032E48C661C350FF9550E9063D595C0AB25CD3;
// System.Collections.Generic.List`1<System.TypeIdentifier>
struct List_1_tB8129EB4ADDDECD38E3E178F0A902C921B575166;
// System.Collections.Generic.List`1<System.TypeSpec>
struct List_1_t8C8BF378AAB72B34B6EE63F686877AE7290ECFBA;
// System.Collections.Hashtable
struct Hashtable_t978F65B8006C8F5504B286526AEC6608FF983FC9;
// System.Console/InternalCancelHandler
struct InternalCancelHandler_t2DD134D8150B67E2F9FAD1BC2E6BE92EED57968A;
// System.Console/WindowsConsole/WindowsCancelHandler
struct WindowsCancelHandler_t1D05BCFB512603DCF87A126FE9969F1D876B9B51;
// System.ConsoleCancelEventHandler
struct ConsoleCancelEventHandler_t6F3B5D9C55C25FF6B53EFEDA9150EFE807311EB4;
// System.Delegate
struct Delegate_t;
// System.DelegateData
struct DelegateData_t1BF9F691B56DAE5F8C28C5E084FDE94F15F27BBE;
// System.Delegate[]
struct DelegateU5BU5D_tDFCDEE2A6322F96C0FE49AF47E9ADB8C4B294E86;
// System.EventHandler
struct EventHandler_t2B84E745E28BA26C49C4E99A387FC3B534D1110C;
// System.EventHandler`1<System.Runtime.ExceptionServices.FirstChanceExceptionEventArgs>
struct EventHandler_1_t1E35ED2E29145994C6C03E57601C6D48C61083FF;
// System.Globalization.NumberFormatInfo
struct NumberFormatInfo_tFDF57037EBC5BC833D0A53EF0327B805994860A8;
// System.IAsyncResult
struct IAsyncResult_t8E194308510B375B42432981AE5E7488C458D598;
// System.IConsoleDriver
struct IConsoleDriver_t484163236D7810E338FC3D246EDF2DCAC42C0E37;
// System.IO.CStreamWriter
struct CStreamWriter_t6B662CA496662AF63D81722DCA99094893C80450;
// System.IO.StreamReader
struct StreamReader_t62E68063760DCD2FC036AE132DE69C24B7ED001E;
// System.IO.TextReader
struct TextReader_t7DF8314B601D202ECFEDF623093A87BFDAB58D0A;
// System.IO.TextWriter
struct TextWriter_t92451D929322093838C41489883D5B2D7ABAF3F0;
// System.Int32
struct Int32_t585191389E07734F19F3156FF88FB3EF4800D102;
// System.Int32[]
struct Int32U5BU5D_t2B9E4FDDDB9F0A00EC0AC631BA2DA915EB1ECF83;
// System.Int64
struct Int64_t7A386C2FF7B0280A0F516992401DDFCF0FF7B436;
// System.MonoTypeInfo
struct MonoTypeInfo_t9A65BA5324D14FDFEB7644EEE6E1BDF74B8A393D;
// System.OperatingSystem
struct OperatingSystem_tBB05846D5AA6960FFEB42C59E5FE359255C2BE83;
// System.ParameterizedStrings/FormatParam[]
struct FormatParamU5BU5D_t2F95A3C5AF726E75A42BC28843BAD579B62199B5;
// System.ParameterizedStrings/LowLevelStack
struct LowLevelStack_tAED9B2A5CEC7125CF57BEE067AC399CEE3510EC2;
// System.Reflection.Assembly
struct Assembly_t;
// System.Reflection.Binder
struct Binder_t4D5CB06963501D32847C057B57157D6DC49CA759;
// System.Reflection.MemberFilter
struct MemberFilter_t25C1BD92C42BE94426E300787C13C452CB89B381;
// System.Reflection.MethodBase
struct MethodBase_t;
// System.Reflection.MethodInfo
struct MethodInfo_t;
// System.Reflection.MonoCMethod
struct MonoCMethod_tFB85687BEF8202F8B3E77FE24BCC2E400EA4FC61;
// System.Reflection.RuntimeConstructorInfo
struct RuntimeConstructorInfo_tF21A59967629968D0BE5D0DAF677662824E9629D;
// System.ResolveEventArgs
struct ResolveEventArgs_t116CF9DB06BCFEB8933CEAD4A35389A7CA9EB75D;
// System.ResolveEventHandler
struct ResolveEventHandler_t045C469BEA8B632FA99FE8867C921BA8DAE0BEE5;
// System.String
struct String_t;
// System.String[]
struct StringU5BU5D_t933FB07893230EA91C40FF900D5400665E87B14E;
// System.TermInfoReader
struct TermInfoReader_tCAABF3484E6F0AA298F809766C52CA9DC4E6C55C;
// System.Text.Encoding
struct Encoding_t7837A3C0F55EAE0E3959A53C6D6E88B113ED78A4;
// System.TimeZoneInfo
struct TimeZoneInfo_t46EF9BAEAA787846F1A1EC419BE75CFEFAFF6777;
// System.Type
struct Type_t;
// System.TypeIdentifier
struct TypeIdentifier_tEF8C0B5CA8B33CD2A732C822D0B9BD62B8DA2F12;
// System.Type[]
struct TypeU5BU5D_t7FE623A666B49176DE123306221193E888A12F5F;
// System.UInt64
struct UInt64_tA02DF3B59C8FC4A849BD207DA11038CC64E4CB4E;
// System.UnhandledExceptionEventArgs
struct UnhandledExceptionEventArgs_t39DD47D43B0D764FE2C9847FBE760031FBEA0FD1;
// System.UnhandledExceptionEventHandler
struct UnhandledExceptionEventHandler_tB0DFF05ABF7A3A234C87D4F7A71F98E9AB2D91DE;
// System.Version
struct Version_tDBE6876C59B6F56D4F8CAA03851177ABC6FE0DFD;
// System.Void
struct Void_t22962CB4C05B1D89B55A6E1139F0E87A90987017;
struct Delegate_t_marshaled_com;
struct Delegate_t_marshaled_pinvoke;
#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 APPDOMAINSETUP_T80DF2915BB100D4BD515920B49C959E9FA451306_H
#define APPDOMAINSETUP_T80DF2915BB100D4BD515920B49C959E9FA451306_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.AppDomainSetup
struct AppDomainSetup_t80DF2915BB100D4BD515920B49C959E9FA451306 : public RuntimeObject
{
public:
// System.String System.AppDomainSetup::application_base
String_t* ___application_base_0;
// System.String System.AppDomainSetup::application_name
String_t* ___application_name_1;
// System.String System.AppDomainSetup::cache_path
String_t* ___cache_path_2;
// System.String System.AppDomainSetup::configuration_file
String_t* ___configuration_file_3;
// System.String System.AppDomainSetup::dynamic_base
String_t* ___dynamic_base_4;
// System.String System.AppDomainSetup::license_file
String_t* ___license_file_5;
// System.String System.AppDomainSetup::private_bin_path
String_t* ___private_bin_path_6;
// System.String System.AppDomainSetup::private_bin_path_probe
String_t* ___private_bin_path_probe_7;
// System.String System.AppDomainSetup::shadow_copy_directories
String_t* ___shadow_copy_directories_8;
// System.String System.AppDomainSetup::shadow_copy_files
String_t* ___shadow_copy_files_9;
// System.Boolean System.AppDomainSetup::publisher_policy
bool ___publisher_policy_10;
// System.Boolean System.AppDomainSetup::path_changed
bool ___path_changed_11;
// System.Int32 System.AppDomainSetup::loader_optimization
int32_t ___loader_optimization_12;
// System.Boolean System.AppDomainSetup::disallow_binding_redirects
bool ___disallow_binding_redirects_13;
// System.Boolean System.AppDomainSetup::disallow_code_downloads
bool ___disallow_code_downloads_14;
// System.Object System.AppDomainSetup::_activationArguments
RuntimeObject * ____activationArguments_15;
// System.Object System.AppDomainSetup::domain_initializer
RuntimeObject * ___domain_initializer_16;
// System.Object System.AppDomainSetup::application_trust
RuntimeObject * ___application_trust_17;
// System.String[] System.AppDomainSetup::domain_initializer_args
StringU5BU5D_t933FB07893230EA91C40FF900D5400665E87B14E* ___domain_initializer_args_18;
// System.Boolean System.AppDomainSetup::disallow_appbase_probe
bool ___disallow_appbase_probe_19;
// System.Byte[] System.AppDomainSetup::configuration_bytes
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* ___configuration_bytes_20;
// System.Byte[] System.AppDomainSetup::serialized_non_primitives
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* ___serialized_non_primitives_21;
// System.String System.AppDomainSetup::<TargetFrameworkName>k__BackingField
String_t* ___U3CTargetFrameworkNameU3Ek__BackingField_22;
public:
inline static int32_t get_offset_of_application_base_0() { return static_cast<int32_t>(offsetof(AppDomainSetup_t80DF2915BB100D4BD515920B49C959E9FA451306, ___application_base_0)); }
inline String_t* get_application_base_0() const { return ___application_base_0; }
inline String_t** get_address_of_application_base_0() { return &___application_base_0; }
inline void set_application_base_0(String_t* value)
{
___application_base_0 = value;
Il2CppCodeGenWriteBarrier((&___application_base_0), value);
}
inline static int32_t get_offset_of_application_name_1() { return static_cast<int32_t>(offsetof(AppDomainSetup_t80DF2915BB100D4BD515920B49C959E9FA451306, ___application_name_1)); }
inline String_t* get_application_name_1() const { return ___application_name_1; }
inline String_t** get_address_of_application_name_1() { return &___application_name_1; }
inline void set_application_name_1(String_t* value)
{
___application_name_1 = value;
Il2CppCodeGenWriteBarrier((&___application_name_1), value);
}
inline static int32_t get_offset_of_cache_path_2() { return static_cast<int32_t>(offsetof(AppDomainSetup_t80DF2915BB100D4BD515920B49C959E9FA451306, ___cache_path_2)); }
inline String_t* get_cache_path_2() const { return ___cache_path_2; }
inline String_t** get_address_of_cache_path_2() { return &___cache_path_2; }
inline void set_cache_path_2(String_t* value)
{
___cache_path_2 = value;
Il2CppCodeGenWriteBarrier((&___cache_path_2), value);
}
inline static int32_t get_offset_of_configuration_file_3() { return static_cast<int32_t>(offsetof(AppDomainSetup_t80DF2915BB100D4BD515920B49C959E9FA451306, ___configuration_file_3)); }
inline String_t* get_configuration_file_3() const { return ___configuration_file_3; }
inline String_t** get_address_of_configuration_file_3() { return &___configuration_file_3; }
inline void set_configuration_file_3(String_t* value)
{
___configuration_file_3 = value;
Il2CppCodeGenWriteBarrier((&___configuration_file_3), value);
}
inline static int32_t get_offset_of_dynamic_base_4() { return static_cast<int32_t>(offsetof(AppDomainSetup_t80DF2915BB100D4BD515920B49C959E9FA451306, ___dynamic_base_4)); }
inline String_t* get_dynamic_base_4() const { return ___dynamic_base_4; }
inline String_t** get_address_of_dynamic_base_4() { return &___dynamic_base_4; }
inline void set_dynamic_base_4(String_t* value)
{
___dynamic_base_4 = value;
Il2CppCodeGenWriteBarrier((&___dynamic_base_4), value);
}
inline static int32_t get_offset_of_license_file_5() { return static_cast<int32_t>(offsetof(AppDomainSetup_t80DF2915BB100D4BD515920B49C959E9FA451306, ___license_file_5)); }
inline String_t* get_license_file_5() const { return ___license_file_5; }
inline String_t** get_address_of_license_file_5() { return &___license_file_5; }
inline void set_license_file_5(String_t* value)
{
___license_file_5 = value;
Il2CppCodeGenWriteBarrier((&___license_file_5), value);
}
inline static int32_t get_offset_of_private_bin_path_6() { return static_cast<int32_t>(offsetof(AppDomainSetup_t80DF2915BB100D4BD515920B49C959E9FA451306, ___private_bin_path_6)); }
inline String_t* get_private_bin_path_6() const { return ___private_bin_path_6; }
inline String_t** get_address_of_private_bin_path_6() { return &___private_bin_path_6; }
inline void set_private_bin_path_6(String_t* value)
{
___private_bin_path_6 = value;
Il2CppCodeGenWriteBarrier((&___private_bin_path_6), value);
}
inline static int32_t get_offset_of_private_bin_path_probe_7() { return static_cast<int32_t>(offsetof(AppDomainSetup_t80DF2915BB100D4BD515920B49C959E9FA451306, ___private_bin_path_probe_7)); }
inline String_t* get_private_bin_path_probe_7() const { return ___private_bin_path_probe_7; }
inline String_t** get_address_of_private_bin_path_probe_7() { return &___private_bin_path_probe_7; }
inline void set_private_bin_path_probe_7(String_t* value)
{
___private_bin_path_probe_7 = value;
Il2CppCodeGenWriteBarrier((&___private_bin_path_probe_7), value);
}
inline static int32_t get_offset_of_shadow_copy_directories_8() { return static_cast<int32_t>(offsetof(AppDomainSetup_t80DF2915BB100D4BD515920B49C959E9FA451306, ___shadow_copy_directories_8)); }
inline String_t* get_shadow_copy_directories_8() const { return ___shadow_copy_directories_8; }
inline String_t** get_address_of_shadow_copy_directories_8() { return &___shadow_copy_directories_8; }
inline void set_shadow_copy_directories_8(String_t* value)
{
___shadow_copy_directories_8 = value;
Il2CppCodeGenWriteBarrier((&___shadow_copy_directories_8), value);
}
inline static int32_t get_offset_of_shadow_copy_files_9() { return static_cast<int32_t>(offsetof(AppDomainSetup_t80DF2915BB100D4BD515920B49C959E9FA451306, ___shadow_copy_files_9)); }
inline String_t* get_shadow_copy_files_9() const { return ___shadow_copy_files_9; }
inline String_t** get_address_of_shadow_copy_files_9() { return &___shadow_copy_files_9; }
inline void set_shadow_copy_files_9(String_t* value)
{
___shadow_copy_files_9 = value;
Il2CppCodeGenWriteBarrier((&___shadow_copy_files_9), value);
}
inline static int32_t get_offset_of_publisher_policy_10() { return static_cast<int32_t>(offsetof(AppDomainSetup_t80DF2915BB100D4BD515920B49C959E9FA451306, ___publisher_policy_10)); }
inline bool get_publisher_policy_10() const { return ___publisher_policy_10; }
inline bool* get_address_of_publisher_policy_10() { return &___publisher_policy_10; }
inline void set_publisher_policy_10(bool value)
{
___publisher_policy_10 = value;
}
inline static int32_t get_offset_of_path_changed_11() { return static_cast<int32_t>(offsetof(AppDomainSetup_t80DF2915BB100D4BD515920B49C959E9FA451306, ___path_changed_11)); }
inline bool get_path_changed_11() const { return ___path_changed_11; }
inline bool* get_address_of_path_changed_11() { return &___path_changed_11; }
inline void set_path_changed_11(bool value)
{
___path_changed_11 = value;
}
inline static int32_t get_offset_of_loader_optimization_12() { return static_cast<int32_t>(offsetof(AppDomainSetup_t80DF2915BB100D4BD515920B49C959E9FA451306, ___loader_optimization_12)); }
inline int32_t get_loader_optimization_12() const { return ___loader_optimization_12; }
inline int32_t* get_address_of_loader_optimization_12() { return &___loader_optimization_12; }
inline void set_loader_optimization_12(int32_t value)
{
___loader_optimization_12 = value;
}
inline static int32_t get_offset_of_disallow_binding_redirects_13() { return static_cast<int32_t>(offsetof(AppDomainSetup_t80DF2915BB100D4BD515920B49C959E9FA451306, ___disallow_binding_redirects_13)); }
inline bool get_disallow_binding_redirects_13() const { return ___disallow_binding_redirects_13; }
inline bool* get_address_of_disallow_binding_redirects_13() { return &___disallow_binding_redirects_13; }
inline void set_disallow_binding_redirects_13(bool value)
{
___disallow_binding_redirects_13 = value;
}
inline static int32_t get_offset_of_disallow_code_downloads_14() { return static_cast<int32_t>(offsetof(AppDomainSetup_t80DF2915BB100D4BD515920B49C959E9FA451306, ___disallow_code_downloads_14)); }
inline bool get_disallow_code_downloads_14() const { return ___disallow_code_downloads_14; }
inline bool* get_address_of_disallow_code_downloads_14() { return &___disallow_code_downloads_14; }
inline void set_disallow_code_downloads_14(bool value)
{
___disallow_code_downloads_14 = value;
}
inline static int32_t get_offset_of__activationArguments_15() { return static_cast<int32_t>(offsetof(AppDomainSetup_t80DF2915BB100D4BD515920B49C959E9FA451306, ____activationArguments_15)); }
inline RuntimeObject * get__activationArguments_15() const { return ____activationArguments_15; }
inline RuntimeObject ** get_address_of__activationArguments_15() { return &____activationArguments_15; }
inline void set__activationArguments_15(RuntimeObject * value)
{
____activationArguments_15 = value;
Il2CppCodeGenWriteBarrier((&____activationArguments_15), value);
}
inline static int32_t get_offset_of_domain_initializer_16() { return static_cast<int32_t>(offsetof(AppDomainSetup_t80DF2915BB100D4BD515920B49C959E9FA451306, ___domain_initializer_16)); }
inline RuntimeObject * get_domain_initializer_16() const { return ___domain_initializer_16; }
inline RuntimeObject ** get_address_of_domain_initializer_16() { return &___domain_initializer_16; }
inline void set_domain_initializer_16(RuntimeObject * value)
{
___domain_initializer_16 = value;
Il2CppCodeGenWriteBarrier((&___domain_initializer_16), value);
}
inline static int32_t get_offset_of_application_trust_17() { return static_cast<int32_t>(offsetof(AppDomainSetup_t80DF2915BB100D4BD515920B49C959E9FA451306, ___application_trust_17)); }
inline RuntimeObject * get_application_trust_17() const { return ___application_trust_17; }
inline RuntimeObject ** get_address_of_application_trust_17() { return &___application_trust_17; }
inline void set_application_trust_17(RuntimeObject * value)
{
___application_trust_17 = value;
Il2CppCodeGenWriteBarrier((&___application_trust_17), value);
}
inline static int32_t get_offset_of_domain_initializer_args_18() { return static_cast<int32_t>(offsetof(AppDomainSetup_t80DF2915BB100D4BD515920B49C959E9FA451306, ___domain_initializer_args_18)); }
inline StringU5BU5D_t933FB07893230EA91C40FF900D5400665E87B14E* get_domain_initializer_args_18() const { return ___domain_initializer_args_18; }
inline StringU5BU5D_t933FB07893230EA91C40FF900D5400665E87B14E** get_address_of_domain_initializer_args_18() { return &___domain_initializer_args_18; }
inline void set_domain_initializer_args_18(StringU5BU5D_t933FB07893230EA91C40FF900D5400665E87B14E* value)
{
___domain_initializer_args_18 = value;
Il2CppCodeGenWriteBarrier((&___domain_initializer_args_18), value);
}
inline static int32_t get_offset_of_disallow_appbase_probe_19() { return static_cast<int32_t>(offsetof(AppDomainSetup_t80DF2915BB100D4BD515920B49C959E9FA451306, ___disallow_appbase_probe_19)); }
inline bool get_disallow_appbase_probe_19() const { return ___disallow_appbase_probe_19; }
inline bool* get_address_of_disallow_appbase_probe_19() { return &___disallow_appbase_probe_19; }
inline void set_disallow_appbase_probe_19(bool value)
{
___disallow_appbase_probe_19 = value;
}
inline static int32_t get_offset_of_configuration_bytes_20() { return static_cast<int32_t>(offsetof(AppDomainSetup_t80DF2915BB100D4BD515920B49C959E9FA451306, ___configuration_bytes_20)); }
inline ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* get_configuration_bytes_20() const { return ___configuration_bytes_20; }
inline ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821** get_address_of_configuration_bytes_20() { return &___configuration_bytes_20; }
inline void set_configuration_bytes_20(ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* value)
{
___configuration_bytes_20 = value;
Il2CppCodeGenWriteBarrier((&___configuration_bytes_20), value);
}
inline static int32_t get_offset_of_serialized_non_primitives_21() { return static_cast<int32_t>(offsetof(AppDomainSetup_t80DF2915BB100D4BD515920B49C959E9FA451306, ___serialized_non_primitives_21)); }
inline ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* get_serialized_non_primitives_21() const { return ___serialized_non_primitives_21; }
inline ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821** get_address_of_serialized_non_primitives_21() { return &___serialized_non_primitives_21; }
inline void set_serialized_non_primitives_21(ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* value)
{
___serialized_non_primitives_21 = value;
Il2CppCodeGenWriteBarrier((&___serialized_non_primitives_21), value);
}
inline static int32_t get_offset_of_U3CTargetFrameworkNameU3Ek__BackingField_22() { return static_cast<int32_t>(offsetof(AppDomainSetup_t80DF2915BB100D4BD515920B49C959E9FA451306, ___U3CTargetFrameworkNameU3Ek__BackingField_22)); }
inline String_t* get_U3CTargetFrameworkNameU3Ek__BackingField_22() const { return ___U3CTargetFrameworkNameU3Ek__BackingField_22; }
inline String_t** get_address_of_U3CTargetFrameworkNameU3Ek__BackingField_22() { return &___U3CTargetFrameworkNameU3Ek__BackingField_22; }
inline void set_U3CTargetFrameworkNameU3Ek__BackingField_22(String_t* value)
{
___U3CTargetFrameworkNameU3Ek__BackingField_22 = value;
Il2CppCodeGenWriteBarrier((&___U3CTargetFrameworkNameU3Ek__BackingField_22), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
// Native definition for P/Invoke marshalling of System.AppDomainSetup
struct AppDomainSetup_t80DF2915BB100D4BD515920B49C959E9FA451306_marshaled_pinvoke
{
char* ___application_base_0;
char* ___application_name_1;
char* ___cache_path_2;
char* ___configuration_file_3;
char* ___dynamic_base_4;
char* ___license_file_5;
char* ___private_bin_path_6;
char* ___private_bin_path_probe_7;
char* ___shadow_copy_directories_8;
char* ___shadow_copy_files_9;
int32_t ___publisher_policy_10;
int32_t ___path_changed_11;
int32_t ___loader_optimization_12;
int32_t ___disallow_binding_redirects_13;
int32_t ___disallow_code_downloads_14;
Il2CppIUnknown* ____activationArguments_15;
Il2CppIUnknown* ___domain_initializer_16;
Il2CppIUnknown* ___application_trust_17;
char** ___domain_initializer_args_18;
int32_t ___disallow_appbase_probe_19;
uint8_t* ___configuration_bytes_20;
uint8_t* ___serialized_non_primitives_21;
char* ___U3CTargetFrameworkNameU3Ek__BackingField_22;
};
// Native definition for COM marshalling of System.AppDomainSetup
struct AppDomainSetup_t80DF2915BB100D4BD515920B49C959E9FA451306_marshaled_com
{
Il2CppChar* ___application_base_0;
Il2CppChar* ___application_name_1;
Il2CppChar* ___cache_path_2;
Il2CppChar* ___configuration_file_3;
Il2CppChar* ___dynamic_base_4;
Il2CppChar* ___license_file_5;
Il2CppChar* ___private_bin_path_6;
Il2CppChar* ___private_bin_path_probe_7;
Il2CppChar* ___shadow_copy_directories_8;
Il2CppChar* ___shadow_copy_files_9;
int32_t ___publisher_policy_10;
int32_t ___path_changed_11;
int32_t ___loader_optimization_12;
int32_t ___disallow_binding_redirects_13;
int32_t ___disallow_code_downloads_14;
Il2CppIUnknown* ____activationArguments_15;
Il2CppIUnknown* ___domain_initializer_16;
Il2CppIUnknown* ___application_trust_17;
Il2CppChar** ___domain_initializer_args_18;
int32_t ___disallow_appbase_probe_19;
uint8_t* ___configuration_bytes_20;
uint8_t* ___serialized_non_primitives_21;
Il2CppChar* ___U3CTargetFrameworkNameU3Ek__BackingField_22;
};
#endif // APPDOMAINSETUP_T80DF2915BB100D4BD515920B49C959E9FA451306_H
#ifndef ARRAYSPEC_TF374BB8994F7190916C6F14C7EA8FE6EFE017970_H
#define ARRAYSPEC_TF374BB8994F7190916C6F14C7EA8FE6EFE017970_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.ArraySpec
struct ArraySpec_tF374BB8994F7190916C6F14C7EA8FE6EFE017970 : public RuntimeObject
{
public:
// System.Int32 System.ArraySpec::dimensions
int32_t ___dimensions_0;
// System.Boolean System.ArraySpec::bound
bool ___bound_1;
public:
inline static int32_t get_offset_of_dimensions_0() { return static_cast<int32_t>(offsetof(ArraySpec_tF374BB8994F7190916C6F14C7EA8FE6EFE017970, ___dimensions_0)); }
inline int32_t get_dimensions_0() const { return ___dimensions_0; }
inline int32_t* get_address_of_dimensions_0() { return &___dimensions_0; }
inline void set_dimensions_0(int32_t value)
{
___dimensions_0 = value;
}
inline static int32_t get_offset_of_bound_1() { return static_cast<int32_t>(offsetof(ArraySpec_tF374BB8994F7190916C6F14C7EA8FE6EFE017970, ___bound_1)); }
inline bool get_bound_1() const { return ___bound_1; }
inline bool* get_address_of_bound_1() { return &___bound_1; }
inline void set_bound_1(bool value)
{
___bound_1 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // ARRAYSPEC_TF374BB8994F7190916C6F14C7EA8FE6EFE017970_H
#ifndef BYTEMATCHER_TB199BDD35E2575B84D9FDED34954705653D241DC_H
#define BYTEMATCHER_TB199BDD35E2575B84D9FDED34954705653D241DC_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.ByteMatcher
struct ByteMatcher_tB199BDD35E2575B84D9FDED34954705653D241DC : public RuntimeObject
{
public:
// System.Collections.Hashtable System.ByteMatcher::map
Hashtable_t978F65B8006C8F5504B286526AEC6608FF983FC9 * ___map_0;
// System.Collections.Hashtable System.ByteMatcher::starts
Hashtable_t978F65B8006C8F5504B286526AEC6608FF983FC9 * ___starts_1;
public:
inline static int32_t get_offset_of_map_0() { return static_cast<int32_t>(offsetof(ByteMatcher_tB199BDD35E2575B84D9FDED34954705653D241DC, ___map_0)); }
inline Hashtable_t978F65B8006C8F5504B286526AEC6608FF983FC9 * get_map_0() const { return ___map_0; }
inline Hashtable_t978F65B8006C8F5504B286526AEC6608FF983FC9 ** get_address_of_map_0() { return &___map_0; }
inline void set_map_0(Hashtable_t978F65B8006C8F5504B286526AEC6608FF983FC9 * value)
{
___map_0 = value;
Il2CppCodeGenWriteBarrier((&___map_0), value);
}
inline static int32_t get_offset_of_starts_1() { return static_cast<int32_t>(offsetof(ByteMatcher_tB199BDD35E2575B84D9FDED34954705653D241DC, ___starts_1)); }
inline Hashtable_t978F65B8006C8F5504B286526AEC6608FF983FC9 * get_starts_1() const { return ___starts_1; }
inline Hashtable_t978F65B8006C8F5504B286526AEC6608FF983FC9 ** get_address_of_starts_1() { return &___starts_1; }
inline void set_starts_1(Hashtable_t978F65B8006C8F5504B286526AEC6608FF983FC9 * value)
{
___starts_1 = value;
Il2CppCodeGenWriteBarrier((&___starts_1), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // BYTEMATCHER_TB199BDD35E2575B84D9FDED34954705653D241DC_H
#ifndef CLRCONFIG_T79EBAFC5FBCAC675B35CB93391030FABCA9A7B45_H
#define CLRCONFIG_T79EBAFC5FBCAC675B35CB93391030FABCA9A7B45_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.CLRConfig
struct CLRConfig_t79EBAFC5FBCAC675B35CB93391030FABCA9A7B45 : public RuntimeObject
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // CLRCONFIG_T79EBAFC5FBCAC675B35CB93391030FABCA9A7B45_H
#ifndef COMPATIBILITYSWITCHES_TC541F9F5404925C97741A0628E9B6D26C40CFA91_H
#define COMPATIBILITYSWITCHES_TC541F9F5404925C97741A0628E9B6D26C40CFA91_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.CompatibilitySwitches
struct CompatibilitySwitches_tC541F9F5404925C97741A0628E9B6D26C40CFA91 : public RuntimeObject
{
public:
public:
};
struct CompatibilitySwitches_tC541F9F5404925C97741A0628E9B6D26C40CFA91_StaticFields
{
public:
// System.Boolean System.CompatibilitySwitches::IsAppEarlierThanSilverlight4
bool ___IsAppEarlierThanSilverlight4_0;
// System.Boolean System.CompatibilitySwitches::IsAppEarlierThanWindowsPhone8
bool ___IsAppEarlierThanWindowsPhone8_1;
public:
inline static int32_t get_offset_of_IsAppEarlierThanSilverlight4_0() { return static_cast<int32_t>(offsetof(CompatibilitySwitches_tC541F9F5404925C97741A0628E9B6D26C40CFA91_StaticFields, ___IsAppEarlierThanSilverlight4_0)); }
inline bool get_IsAppEarlierThanSilverlight4_0() const { return ___IsAppEarlierThanSilverlight4_0; }
inline bool* get_address_of_IsAppEarlierThanSilverlight4_0() { return &___IsAppEarlierThanSilverlight4_0; }
inline void set_IsAppEarlierThanSilverlight4_0(bool value)
{
___IsAppEarlierThanSilverlight4_0 = value;
}
inline static int32_t get_offset_of_IsAppEarlierThanWindowsPhone8_1() { return static_cast<int32_t>(offsetof(CompatibilitySwitches_tC541F9F5404925C97741A0628E9B6D26C40CFA91_StaticFields, ___IsAppEarlierThanWindowsPhone8_1)); }
inline bool get_IsAppEarlierThanWindowsPhone8_1() const { return ___IsAppEarlierThanWindowsPhone8_1; }
inline bool* get_address_of_IsAppEarlierThanWindowsPhone8_1() { return &___IsAppEarlierThanWindowsPhone8_1; }
inline void set_IsAppEarlierThanWindowsPhone8_1(bool value)
{
___IsAppEarlierThanWindowsPhone8_1 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // COMPATIBILITYSWITCHES_TC541F9F5404925C97741A0628E9B6D26C40CFA91_H
#ifndef CONSOLE_T5C8E87BA271B0DECA837A3BF9093AC3560DB3D5D_H
#define CONSOLE_T5C8E87BA271B0DECA837A3BF9093AC3560DB3D5D_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Console
struct Console_t5C8E87BA271B0DECA837A3BF9093AC3560DB3D5D : public RuntimeObject
{
public:
public:
};
struct Console_t5C8E87BA271B0DECA837A3BF9093AC3560DB3D5D_StaticFields
{
public:
// System.IO.TextWriter System.Console::stdout
TextWriter_t92451D929322093838C41489883D5B2D7ABAF3F0 * ___stdout_0;
// System.IO.TextWriter System.Console::stderr
TextWriter_t92451D929322093838C41489883D5B2D7ABAF3F0 * ___stderr_1;
// System.IO.TextReader System.Console::stdin
TextReader_t7DF8314B601D202ECFEDF623093A87BFDAB58D0A * ___stdin_2;
// System.Text.Encoding System.Console::inputEncoding
Encoding_t7837A3C0F55EAE0E3959A53C6D6E88B113ED78A4 * ___inputEncoding_3;
// System.Text.Encoding System.Console::outputEncoding
Encoding_t7837A3C0F55EAE0E3959A53C6D6E88B113ED78A4 * ___outputEncoding_4;
// System.ConsoleCancelEventHandler System.Console::cancel_event
ConsoleCancelEventHandler_t6F3B5D9C55C25FF6B53EFEDA9150EFE807311EB4 * ___cancel_event_5;
// System.Console_InternalCancelHandler System.Console::cancel_handler
InternalCancelHandler_t2DD134D8150B67E2F9FAD1BC2E6BE92EED57968A * ___cancel_handler_6;
public:
inline static int32_t get_offset_of_stdout_0() { return static_cast<int32_t>(offsetof(Console_t5C8E87BA271B0DECA837A3BF9093AC3560DB3D5D_StaticFields, ___stdout_0)); }
inline TextWriter_t92451D929322093838C41489883D5B2D7ABAF3F0 * get_stdout_0() const { return ___stdout_0; }
inline TextWriter_t92451D929322093838C41489883D5B2D7ABAF3F0 ** get_address_of_stdout_0() { return &___stdout_0; }
inline void set_stdout_0(TextWriter_t92451D929322093838C41489883D5B2D7ABAF3F0 * value)
{
___stdout_0 = value;
Il2CppCodeGenWriteBarrier((&___stdout_0), value);
}
inline static int32_t get_offset_of_stderr_1() { return static_cast<int32_t>(offsetof(Console_t5C8E87BA271B0DECA837A3BF9093AC3560DB3D5D_StaticFields, ___stderr_1)); }
inline TextWriter_t92451D929322093838C41489883D5B2D7ABAF3F0 * get_stderr_1() const { return ___stderr_1; }
inline TextWriter_t92451D929322093838C41489883D5B2D7ABAF3F0 ** get_address_of_stderr_1() { return &___stderr_1; }
inline void set_stderr_1(TextWriter_t92451D929322093838C41489883D5B2D7ABAF3F0 * value)
{
___stderr_1 = value;
Il2CppCodeGenWriteBarrier((&___stderr_1), value);
}
inline static int32_t get_offset_of_stdin_2() { return static_cast<int32_t>(offsetof(Console_t5C8E87BA271B0DECA837A3BF9093AC3560DB3D5D_StaticFields, ___stdin_2)); }
inline TextReader_t7DF8314B601D202ECFEDF623093A87BFDAB58D0A * get_stdin_2() const { return ___stdin_2; }
inline TextReader_t7DF8314B601D202ECFEDF623093A87BFDAB58D0A ** get_address_of_stdin_2() { return &___stdin_2; }
inline void set_stdin_2(TextReader_t7DF8314B601D202ECFEDF623093A87BFDAB58D0A * value)
{
___stdin_2 = value;
Il2CppCodeGenWriteBarrier((&___stdin_2), value);
}
inline static int32_t get_offset_of_inputEncoding_3() { return static_cast<int32_t>(offsetof(Console_t5C8E87BA271B0DECA837A3BF9093AC3560DB3D5D_StaticFields, ___inputEncoding_3)); }
inline Encoding_t7837A3C0F55EAE0E3959A53C6D6E88B113ED78A4 * get_inputEncoding_3() const { return ___inputEncoding_3; }
inline Encoding_t7837A3C0F55EAE0E3959A53C6D6E88B113ED78A4 ** get_address_of_inputEncoding_3() { return &___inputEncoding_3; }
inline void set_inputEncoding_3(Encoding_t7837A3C0F55EAE0E3959A53C6D6E88B113ED78A4 * value)
{
___inputEncoding_3 = value;
Il2CppCodeGenWriteBarrier((&___inputEncoding_3), value);
}
inline static int32_t get_offset_of_outputEncoding_4() { return static_cast<int32_t>(offsetof(Console_t5C8E87BA271B0DECA837A3BF9093AC3560DB3D5D_StaticFields, ___outputEncoding_4)); }
inline Encoding_t7837A3C0F55EAE0E3959A53C6D6E88B113ED78A4 * get_outputEncoding_4() const { return ___outputEncoding_4; }
inline Encoding_t7837A3C0F55EAE0E3959A53C6D6E88B113ED78A4 ** get_address_of_outputEncoding_4() { return &___outputEncoding_4; }
inline void set_outputEncoding_4(Encoding_t7837A3C0F55EAE0E3959A53C6D6E88B113ED78A4 * value)
{
___outputEncoding_4 = value;
Il2CppCodeGenWriteBarrier((&___outputEncoding_4), value);
}
inline static int32_t get_offset_of_cancel_event_5() { return static_cast<int32_t>(offsetof(Console_t5C8E87BA271B0DECA837A3BF9093AC3560DB3D5D_StaticFields, ___cancel_event_5)); }
inline ConsoleCancelEventHandler_t6F3B5D9C55C25FF6B53EFEDA9150EFE807311EB4 * get_cancel_event_5() const { return ___cancel_event_5; }
inline ConsoleCancelEventHandler_t6F3B5D9C55C25FF6B53EFEDA9150EFE807311EB4 ** get_address_of_cancel_event_5() { return &___cancel_event_5; }
inline void set_cancel_event_5(ConsoleCancelEventHandler_t6F3B5D9C55C25FF6B53EFEDA9150EFE807311EB4 * value)
{
___cancel_event_5 = value;
Il2CppCodeGenWriteBarrier((&___cancel_event_5), value);
}
inline static int32_t get_offset_of_cancel_handler_6() { return static_cast<int32_t>(offsetof(Console_t5C8E87BA271B0DECA837A3BF9093AC3560DB3D5D_StaticFields, ___cancel_handler_6)); }
inline InternalCancelHandler_t2DD134D8150B67E2F9FAD1BC2E6BE92EED57968A * get_cancel_handler_6() const { return ___cancel_handler_6; }
inline InternalCancelHandler_t2DD134D8150B67E2F9FAD1BC2E6BE92EED57968A ** get_address_of_cancel_handler_6() { return &___cancel_handler_6; }
inline void set_cancel_handler_6(InternalCancelHandler_t2DD134D8150B67E2F9FAD1BC2E6BE92EED57968A * value)
{
___cancel_handler_6 = value;
Il2CppCodeGenWriteBarrier((&___cancel_handler_6), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // CONSOLE_T5C8E87BA271B0DECA837A3BF9093AC3560DB3D5D_H
#ifndef WINDOWSCONSOLE_TE2543F6EAD1001D1F2DE2CC0A5495048EED8C21B_H
#define WINDOWSCONSOLE_TE2543F6EAD1001D1F2DE2CC0A5495048EED8C21B_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Console_WindowsConsole
struct WindowsConsole_tE2543F6EAD1001D1F2DE2CC0A5495048EED8C21B : public RuntimeObject
{
public:
public:
};
struct WindowsConsole_tE2543F6EAD1001D1F2DE2CC0A5495048EED8C21B_StaticFields
{
public:
// System.Boolean System.Console_WindowsConsole::ctrlHandlerAdded
bool ___ctrlHandlerAdded_0;
// System.Console_WindowsConsole_WindowsCancelHandler System.Console_WindowsConsole::cancelHandler
WindowsCancelHandler_t1D05BCFB512603DCF87A126FE9969F1D876B9B51 * ___cancelHandler_1;
public:
inline static int32_t get_offset_of_ctrlHandlerAdded_0() { return static_cast<int32_t>(offsetof(WindowsConsole_tE2543F6EAD1001D1F2DE2CC0A5495048EED8C21B_StaticFields, ___ctrlHandlerAdded_0)); }
inline bool get_ctrlHandlerAdded_0() const { return ___ctrlHandlerAdded_0; }
inline bool* get_address_of_ctrlHandlerAdded_0() { return &___ctrlHandlerAdded_0; }
inline void set_ctrlHandlerAdded_0(bool value)
{
___ctrlHandlerAdded_0 = value;
}
inline static int32_t get_offset_of_cancelHandler_1() { return static_cast<int32_t>(offsetof(WindowsConsole_tE2543F6EAD1001D1F2DE2CC0A5495048EED8C21B_StaticFields, ___cancelHandler_1)); }
inline WindowsCancelHandler_t1D05BCFB512603DCF87A126FE9969F1D876B9B51 * get_cancelHandler_1() const { return ___cancelHandler_1; }
inline WindowsCancelHandler_t1D05BCFB512603DCF87A126FE9969F1D876B9B51 ** get_address_of_cancelHandler_1() { return &___cancelHandler_1; }
inline void set_cancelHandler_1(WindowsCancelHandler_t1D05BCFB512603DCF87A126FE9969F1D876B9B51 * value)
{
___cancelHandler_1 = value;
Il2CppCodeGenWriteBarrier((&___cancelHandler_1), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // WINDOWSCONSOLE_TE2543F6EAD1001D1F2DE2CC0A5495048EED8C21B_H
#ifndef CONSOLEDRIVER_T4F24DB42600CA82912181D5D312902B8BEFEE101_H
#define CONSOLEDRIVER_T4F24DB42600CA82912181D5D312902B8BEFEE101_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.ConsoleDriver
struct ConsoleDriver_t4F24DB42600CA82912181D5D312902B8BEFEE101 : public RuntimeObject
{
public:
public:
};
struct ConsoleDriver_t4F24DB42600CA82912181D5D312902B8BEFEE101_StaticFields
{
public:
// System.IConsoleDriver System.ConsoleDriver::driver
RuntimeObject* ___driver_0;
// System.Boolean System.ConsoleDriver::is_console
bool ___is_console_1;
// System.Boolean System.ConsoleDriver::called_isatty
bool ___called_isatty_2;
public:
inline static int32_t get_offset_of_driver_0() { return static_cast<int32_t>(offsetof(ConsoleDriver_t4F24DB42600CA82912181D5D312902B8BEFEE101_StaticFields, ___driver_0)); }
inline RuntimeObject* get_driver_0() const { return ___driver_0; }
inline RuntimeObject** get_address_of_driver_0() { return &___driver_0; }
inline void set_driver_0(RuntimeObject* value)
{
___driver_0 = value;
Il2CppCodeGenWriteBarrier((&___driver_0), value);
}
inline static int32_t get_offset_of_is_console_1() { return static_cast<int32_t>(offsetof(ConsoleDriver_t4F24DB42600CA82912181D5D312902B8BEFEE101_StaticFields, ___is_console_1)); }
inline bool get_is_console_1() const { return ___is_console_1; }
inline bool* get_address_of_is_console_1() { return &___is_console_1; }
inline void set_is_console_1(bool value)
{
___is_console_1 = value;
}
inline static int32_t get_offset_of_called_isatty_2() { return static_cast<int32_t>(offsetof(ConsoleDriver_t4F24DB42600CA82912181D5D312902B8BEFEE101_StaticFields, ___called_isatty_2)); }
inline bool get_called_isatty_2() const { return ___called_isatty_2; }
inline bool* get_address_of_called_isatty_2() { return &___called_isatty_2; }
inline void set_called_isatty_2(bool value)
{
___called_isatty_2 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // CONSOLEDRIVER_T4F24DB42600CA82912181D5D312902B8BEFEE101_H
#ifndef DELEGATEDATA_T1BF9F691B56DAE5F8C28C5E084FDE94F15F27BBE_H
#define DELEGATEDATA_T1BF9F691B56DAE5F8C28C5E084FDE94F15F27BBE_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.DelegateData
struct DelegateData_t1BF9F691B56DAE5F8C28C5E084FDE94F15F27BBE : public RuntimeObject
{
public:
// System.Type System.DelegateData::target_type
Type_t * ___target_type_0;
// System.String System.DelegateData::method_name
String_t* ___method_name_1;
// System.Boolean System.DelegateData::curried_first_arg
bool ___curried_first_arg_2;
public:
inline static int32_t get_offset_of_target_type_0() { return static_cast<int32_t>(offsetof(DelegateData_t1BF9F691B56DAE5F8C28C5E084FDE94F15F27BBE, ___target_type_0)); }
inline Type_t * get_target_type_0() const { return ___target_type_0; }
inline Type_t ** get_address_of_target_type_0() { return &___target_type_0; }
inline void set_target_type_0(Type_t * value)
{
___target_type_0 = value;
Il2CppCodeGenWriteBarrier((&___target_type_0), value);
}
inline static int32_t get_offset_of_method_name_1() { return static_cast<int32_t>(offsetof(DelegateData_t1BF9F691B56DAE5F8C28C5E084FDE94F15F27BBE, ___method_name_1)); }
inline String_t* get_method_name_1() const { return ___method_name_1; }
inline String_t** get_address_of_method_name_1() { return &___method_name_1; }
inline void set_method_name_1(String_t* value)
{
___method_name_1 = value;
Il2CppCodeGenWriteBarrier((&___method_name_1), value);
}
inline static int32_t get_offset_of_curried_first_arg_2() { return static_cast<int32_t>(offsetof(DelegateData_t1BF9F691B56DAE5F8C28C5E084FDE94F15F27BBE, ___curried_first_arg_2)); }
inline bool get_curried_first_arg_2() const { return ___curried_first_arg_2; }
inline bool* get_address_of_curried_first_arg_2() { return &___curried_first_arg_2; }
inline void set_curried_first_arg_2(bool value)
{
___curried_first_arg_2 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // DELEGATEDATA_T1BF9F691B56DAE5F8C28C5E084FDE94F15F27BBE_H
#ifndef DELEGATESERIALIZATIONHOLDER_TC720FD99D3C1B05B7558EF694ED42E57E64DD671_H
#define DELEGATESERIALIZATIONHOLDER_TC720FD99D3C1B05B7558EF694ED42E57E64DD671_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.DelegateSerializationHolder
struct DelegateSerializationHolder_tC720FD99D3C1B05B7558EF694ED42E57E64DD671 : public RuntimeObject
{
public:
// System.Delegate System.DelegateSerializationHolder::_delegate
Delegate_t * ____delegate_0;
public:
inline static int32_t get_offset_of__delegate_0() { return static_cast<int32_t>(offsetof(DelegateSerializationHolder_tC720FD99D3C1B05B7558EF694ED42E57E64DD671, ____delegate_0)); }
inline Delegate_t * get__delegate_0() const { return ____delegate_0; }
inline Delegate_t ** get_address_of__delegate_0() { return &____delegate_0; }
inline void set__delegate_0(Delegate_t * value)
{
____delegate_0 = value;
Il2CppCodeGenWriteBarrier((&____delegate_0), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // DELEGATESERIALIZATIONHOLDER_TC720FD99D3C1B05B7558EF694ED42E57E64DD671_H
#ifndef DELEGATEENTRY_T2B3E5D8EF7A65CB12A8EF7621B40DC704402E88E_H
#define DELEGATEENTRY_T2B3E5D8EF7A65CB12A8EF7621B40DC704402E88E_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.DelegateSerializationHolder_DelegateEntry
struct DelegateEntry_t2B3E5D8EF7A65CB12A8EF7621B40DC704402E88E : public RuntimeObject
{
public:
// System.String System.DelegateSerializationHolder_DelegateEntry::type
String_t* ___type_0;
// System.String System.DelegateSerializationHolder_DelegateEntry::assembly
String_t* ___assembly_1;
// System.Object System.DelegateSerializationHolder_DelegateEntry::target
RuntimeObject * ___target_2;
// System.String System.DelegateSerializationHolder_DelegateEntry::targetTypeAssembly
String_t* ___targetTypeAssembly_3;
// System.String System.DelegateSerializationHolder_DelegateEntry::targetTypeName
String_t* ___targetTypeName_4;
// System.String System.DelegateSerializationHolder_DelegateEntry::methodName
String_t* ___methodName_5;
// System.DelegateSerializationHolder_DelegateEntry System.DelegateSerializationHolder_DelegateEntry::delegateEntry
DelegateEntry_t2B3E5D8EF7A65CB12A8EF7621B40DC704402E88E * ___delegateEntry_6;
public:
inline static int32_t get_offset_of_type_0() { return static_cast<int32_t>(offsetof(DelegateEntry_t2B3E5D8EF7A65CB12A8EF7621B40DC704402E88E, ___type_0)); }
inline String_t* get_type_0() const { return ___type_0; }
inline String_t** get_address_of_type_0() { return &___type_0; }
inline void set_type_0(String_t* value)
{
___type_0 = value;
Il2CppCodeGenWriteBarrier((&___type_0), value);
}
inline static int32_t get_offset_of_assembly_1() { return static_cast<int32_t>(offsetof(DelegateEntry_t2B3E5D8EF7A65CB12A8EF7621B40DC704402E88E, ___assembly_1)); }
inline String_t* get_assembly_1() const { return ___assembly_1; }
inline String_t** get_address_of_assembly_1() { return &___assembly_1; }
inline void set_assembly_1(String_t* value)
{
___assembly_1 = value;
Il2CppCodeGenWriteBarrier((&___assembly_1), value);
}
inline static int32_t get_offset_of_target_2() { return static_cast<int32_t>(offsetof(DelegateEntry_t2B3E5D8EF7A65CB12A8EF7621B40DC704402E88E, ___target_2)); }
inline RuntimeObject * get_target_2() const { return ___target_2; }
inline RuntimeObject ** get_address_of_target_2() { return &___target_2; }
inline void set_target_2(RuntimeObject * value)
{
___target_2 = value;
Il2CppCodeGenWriteBarrier((&___target_2), value);
}
inline static int32_t get_offset_of_targetTypeAssembly_3() { return static_cast<int32_t>(offsetof(DelegateEntry_t2B3E5D8EF7A65CB12A8EF7621B40DC704402E88E, ___targetTypeAssembly_3)); }
inline String_t* get_targetTypeAssembly_3() const { return ___targetTypeAssembly_3; }
inline String_t** get_address_of_targetTypeAssembly_3() { return &___targetTypeAssembly_3; }
inline void set_targetTypeAssembly_3(String_t* value)
{
___targetTypeAssembly_3 = value;
Il2CppCodeGenWriteBarrier((&___targetTypeAssembly_3), value);
}
inline static int32_t get_offset_of_targetTypeName_4() { return static_cast<int32_t>(offsetof(DelegateEntry_t2B3E5D8EF7A65CB12A8EF7621B40DC704402E88E, ___targetTypeName_4)); }
inline String_t* get_targetTypeName_4() const { return ___targetTypeName_4; }
inline String_t** get_address_of_targetTypeName_4() { return &___targetTypeName_4; }
inline void set_targetTypeName_4(String_t* value)
{
___targetTypeName_4 = value;
Il2CppCodeGenWriteBarrier((&___targetTypeName_4), value);
}
inline static int32_t get_offset_of_methodName_5() { return static_cast<int32_t>(offsetof(DelegateEntry_t2B3E5D8EF7A65CB12A8EF7621B40DC704402E88E, ___methodName_5)); }
inline String_t* get_methodName_5() const { return ___methodName_5; }
inline String_t** get_address_of_methodName_5() { return &___methodName_5; }
inline void set_methodName_5(String_t* value)
{
___methodName_5 = value;
Il2CppCodeGenWriteBarrier((&___methodName_5), value);
}
inline static int32_t get_offset_of_delegateEntry_6() { return static_cast<int32_t>(offsetof(DelegateEntry_t2B3E5D8EF7A65CB12A8EF7621B40DC704402E88E, ___delegateEntry_6)); }
inline DelegateEntry_t2B3E5D8EF7A65CB12A8EF7621B40DC704402E88E * get_delegateEntry_6() const { return ___delegateEntry_6; }
inline DelegateEntry_t2B3E5D8EF7A65CB12A8EF7621B40DC704402E88E ** get_address_of_delegateEntry_6() { return &___delegateEntry_6; }
inline void set_delegateEntry_6(DelegateEntry_t2B3E5D8EF7A65CB12A8EF7621B40DC704402E88E * value)
{
___delegateEntry_6 = value;
Il2CppCodeGenWriteBarrier((&___delegateEntry_6), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // DELEGATEENTRY_T2B3E5D8EF7A65CB12A8EF7621B40DC704402E88E_H
#ifndef ENVIRONMENT_TC93BF7477A1AEA39D05EDFEBAFF62EE5353FF806_H
#define ENVIRONMENT_TC93BF7477A1AEA39D05EDFEBAFF62EE5353FF806_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Environment
struct Environment_tC93BF7477A1AEA39D05EDFEBAFF62EE5353FF806 : public RuntimeObject
{
public:
public:
};
struct Environment_tC93BF7477A1AEA39D05EDFEBAFF62EE5353FF806_StaticFields
{
public:
// System.String System.Environment::nl
String_t* ___nl_1;
// System.OperatingSystem System.Environment::os
OperatingSystem_tBB05846D5AA6960FFEB42C59E5FE359255C2BE83 * ___os_2;
public:
inline static int32_t get_offset_of_nl_1() { return static_cast<int32_t>(offsetof(Environment_tC93BF7477A1AEA39D05EDFEBAFF62EE5353FF806_StaticFields, ___nl_1)); }
inline String_t* get_nl_1() const { return ___nl_1; }
inline String_t** get_address_of_nl_1() { return &___nl_1; }
inline void set_nl_1(String_t* value)
{
___nl_1 = value;
Il2CppCodeGenWriteBarrier((&___nl_1), value);
}
inline static int32_t get_offset_of_os_2() { return static_cast<int32_t>(offsetof(Environment_tC93BF7477A1AEA39D05EDFEBAFF62EE5353FF806_StaticFields, ___os_2)); }
inline OperatingSystem_tBB05846D5AA6960FFEB42C59E5FE359255C2BE83 * get_os_2() const { return ___os_2; }
inline OperatingSystem_tBB05846D5AA6960FFEB42C59E5FE359255C2BE83 ** get_address_of_os_2() { return &___os_2; }
inline void set_os_2(OperatingSystem_tBB05846D5AA6960FFEB42C59E5FE359255C2BE83 * value)
{
___os_2 = value;
Il2CppCodeGenWriteBarrier((&___os_2), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // ENVIRONMENT_TC93BF7477A1AEA39D05EDFEBAFF62EE5353FF806_H
#ifndef EVENTARGS_T8E6CA180BE0E56674C6407011A94BAF7C757352E_H
#define EVENTARGS_T8E6CA180BE0E56674C6407011A94BAF7C757352E_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.EventArgs
struct EventArgs_t8E6CA180BE0E56674C6407011A94BAF7C757352E : public RuntimeObject
{
public:
public:
};
struct EventArgs_t8E6CA180BE0E56674C6407011A94BAF7C757352E_StaticFields
{
public:
// System.EventArgs System.EventArgs::Empty
EventArgs_t8E6CA180BE0E56674C6407011A94BAF7C757352E * ___Empty_0;
public:
inline static int32_t get_offset_of_Empty_0() { return static_cast<int32_t>(offsetof(EventArgs_t8E6CA180BE0E56674C6407011A94BAF7C757352E_StaticFields, ___Empty_0)); }
inline EventArgs_t8E6CA180BE0E56674C6407011A94BAF7C757352E * get_Empty_0() const { return ___Empty_0; }
inline EventArgs_t8E6CA180BE0E56674C6407011A94BAF7C757352E ** get_address_of_Empty_0() { return &___Empty_0; }
inline void set_Empty_0(EventArgs_t8E6CA180BE0E56674C6407011A94BAF7C757352E * value)
{
___Empty_0 = value;
Il2CppCodeGenWriteBarrier((&___Empty_0), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // EVENTARGS_T8E6CA180BE0E56674C6407011A94BAF7C757352E_H
#ifndef KNOWNTERMINALS_TC33732356694467E5C41300FDB5A86143590F1AE_H
#define KNOWNTERMINALS_TC33732356694467E5C41300FDB5A86143590F1AE_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.KnownTerminals
struct KnownTerminals_tC33732356694467E5C41300FDB5A86143590F1AE : public RuntimeObject
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // KNOWNTERMINALS_TC33732356694467E5C41300FDB5A86143590F1AE_H
#ifndef MARSHALBYREFOBJECT_TC4577953D0A44D0AB8597CFA868E01C858B1C9AF_H
#define MARSHALBYREFOBJECT_TC4577953D0A44D0AB8597CFA868E01C858B1C9AF_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.MarshalByRefObject
struct MarshalByRefObject_tC4577953D0A44D0AB8597CFA868E01C858B1C9AF : public RuntimeObject
{
public:
// System.Object System.MarshalByRefObject::_identity
RuntimeObject * ____identity_0;
public:
inline static int32_t get_offset_of__identity_0() { return static_cast<int32_t>(offsetof(MarshalByRefObject_tC4577953D0A44D0AB8597CFA868E01C858B1C9AF, ____identity_0)); }
inline RuntimeObject * get__identity_0() const { return ____identity_0; }
inline RuntimeObject ** get_address_of__identity_0() { return &____identity_0; }
inline void set__identity_0(RuntimeObject * value)
{
____identity_0 = value;
Il2CppCodeGenWriteBarrier((&____identity_0), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
// Native definition for P/Invoke marshalling of System.MarshalByRefObject
struct MarshalByRefObject_tC4577953D0A44D0AB8597CFA868E01C858B1C9AF_marshaled_pinvoke
{
Il2CppIUnknown* ____identity_0;
};
// Native definition for COM marshalling of System.MarshalByRefObject
struct MarshalByRefObject_tC4577953D0A44D0AB8597CFA868E01C858B1C9AF_marshaled_com
{
Il2CppIUnknown* ____identity_0;
};
#endif // MARSHALBYREFOBJECT_TC4577953D0A44D0AB8597CFA868E01C858B1C9AF_H
#ifndef MONOCUSTOMATTRS_T9E88BD614E6A34BF71106F71D0524DBA27E7FA98_H
#define MONOCUSTOMATTRS_T9E88BD614E6A34BF71106F71D0524DBA27E7FA98_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.MonoCustomAttrs
struct MonoCustomAttrs_t9E88BD614E6A34BF71106F71D0524DBA27E7FA98 : public RuntimeObject
{
public:
public:
};
struct MonoCustomAttrs_t9E88BD614E6A34BF71106F71D0524DBA27E7FA98_StaticFields
{
public:
// System.Reflection.Assembly System.MonoCustomAttrs::corlib
Assembly_t * ___corlib_0;
// System.AttributeUsageAttribute System.MonoCustomAttrs::DefaultAttributeUsage
AttributeUsageAttribute_t1B765F643562D0CD97D0B6B34D121C6AD9CE2388 * ___DefaultAttributeUsage_2;
public:
inline static int32_t get_offset_of_corlib_0() { return static_cast<int32_t>(offsetof(MonoCustomAttrs_t9E88BD614E6A34BF71106F71D0524DBA27E7FA98_StaticFields, ___corlib_0)); }
inline Assembly_t * get_corlib_0() const { return ___corlib_0; }
inline Assembly_t ** get_address_of_corlib_0() { return &___corlib_0; }
inline void set_corlib_0(Assembly_t * value)
{
___corlib_0 = value;
Il2CppCodeGenWriteBarrier((&___corlib_0), value);
}
inline static int32_t get_offset_of_DefaultAttributeUsage_2() { return static_cast<int32_t>(offsetof(MonoCustomAttrs_t9E88BD614E6A34BF71106F71D0524DBA27E7FA98_StaticFields, ___DefaultAttributeUsage_2)); }
inline AttributeUsageAttribute_t1B765F643562D0CD97D0B6B34D121C6AD9CE2388 * get_DefaultAttributeUsage_2() const { return ___DefaultAttributeUsage_2; }
inline AttributeUsageAttribute_t1B765F643562D0CD97D0B6B34D121C6AD9CE2388 ** get_address_of_DefaultAttributeUsage_2() { return &___DefaultAttributeUsage_2; }
inline void set_DefaultAttributeUsage_2(AttributeUsageAttribute_t1B765F643562D0CD97D0B6B34D121C6AD9CE2388 * value)
{
___DefaultAttributeUsage_2 = value;
Il2CppCodeGenWriteBarrier((&___DefaultAttributeUsage_2), value);
}
};
struct MonoCustomAttrs_t9E88BD614E6A34BF71106F71D0524DBA27E7FA98_ThreadStaticFields
{
public:
// System.Collections.Generic.Dictionary`2<System.Type,System.AttributeUsageAttribute> System.MonoCustomAttrs::usage_cache
Dictionary_2_t10ABF562FF47B327563169FBB750047BF1341236 * ___usage_cache_1;
public:
inline static int32_t get_offset_of_usage_cache_1() { return static_cast<int32_t>(offsetof(MonoCustomAttrs_t9E88BD614E6A34BF71106F71D0524DBA27E7FA98_ThreadStaticFields, ___usage_cache_1)); }
inline Dictionary_2_t10ABF562FF47B327563169FBB750047BF1341236 * get_usage_cache_1() const { return ___usage_cache_1; }
inline Dictionary_2_t10ABF562FF47B327563169FBB750047BF1341236 ** get_address_of_usage_cache_1() { return &___usage_cache_1; }
inline void set_usage_cache_1(Dictionary_2_t10ABF562FF47B327563169FBB750047BF1341236 * value)
{
___usage_cache_1 = value;
Il2CppCodeGenWriteBarrier((&___usage_cache_1), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // MONOCUSTOMATTRS_T9E88BD614E6A34BF71106F71D0524DBA27E7FA98_H
#ifndef ATTRIBUTEINFO_T03612660D52EF536A548174E3C1CC246B848E91A_H
#define ATTRIBUTEINFO_T03612660D52EF536A548174E3C1CC246B848E91A_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.MonoCustomAttrs_AttributeInfo
struct AttributeInfo_t03612660D52EF536A548174E3C1CC246B848E91A : public RuntimeObject
{
public:
// System.AttributeUsageAttribute System.MonoCustomAttrs_AttributeInfo::_usage
AttributeUsageAttribute_t1B765F643562D0CD97D0B6B34D121C6AD9CE2388 * ____usage_0;
// System.Int32 System.MonoCustomAttrs_AttributeInfo::_inheritanceLevel
int32_t ____inheritanceLevel_1;
public:
inline static int32_t get_offset_of__usage_0() { return static_cast<int32_t>(offsetof(AttributeInfo_t03612660D52EF536A548174E3C1CC246B848E91A, ____usage_0)); }
inline AttributeUsageAttribute_t1B765F643562D0CD97D0B6B34D121C6AD9CE2388 * get__usage_0() const { return ____usage_0; }
inline AttributeUsageAttribute_t1B765F643562D0CD97D0B6B34D121C6AD9CE2388 ** get_address_of__usage_0() { return &____usage_0; }
inline void set__usage_0(AttributeUsageAttribute_t1B765F643562D0CD97D0B6B34D121C6AD9CE2388 * value)
{
____usage_0 = value;
Il2CppCodeGenWriteBarrier((&____usage_0), value);
}
inline static int32_t get_offset_of__inheritanceLevel_1() { return static_cast<int32_t>(offsetof(AttributeInfo_t03612660D52EF536A548174E3C1CC246B848E91A, ____inheritanceLevel_1)); }
inline int32_t get__inheritanceLevel_1() const { return ____inheritanceLevel_1; }
inline int32_t* get_address_of__inheritanceLevel_1() { return &____inheritanceLevel_1; }
inline void set__inheritanceLevel_1(int32_t value)
{
____inheritanceLevel_1 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // ATTRIBUTEINFO_T03612660D52EF536A548174E3C1CC246B848E91A_H
#ifndef MONOLISTITEM_TF9FE02BB3D5D8507333C93F1AF79B60901947A64_H
#define MONOLISTITEM_TF9FE02BB3D5D8507333C93F1AF79B60901947A64_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.MonoListItem
struct MonoListItem_tF9FE02BB3D5D8507333C93F1AF79B60901947A64 : public RuntimeObject
{
public:
// System.MonoListItem System.MonoListItem::next
MonoListItem_tF9FE02BB3D5D8507333C93F1AF79B60901947A64 * ___next_0;
// System.Object System.MonoListItem::data
RuntimeObject * ___data_1;
public:
inline static int32_t get_offset_of_next_0() { return static_cast<int32_t>(offsetof(MonoListItem_tF9FE02BB3D5D8507333C93F1AF79B60901947A64, ___next_0)); }
inline MonoListItem_tF9FE02BB3D5D8507333C93F1AF79B60901947A64 * get_next_0() const { return ___next_0; }
inline MonoListItem_tF9FE02BB3D5D8507333C93F1AF79B60901947A64 ** get_address_of_next_0() { return &___next_0; }
inline void set_next_0(MonoListItem_tF9FE02BB3D5D8507333C93F1AF79B60901947A64 * value)
{
___next_0 = value;
Il2CppCodeGenWriteBarrier((&___next_0), value);
}
inline static int32_t get_offset_of_data_1() { return static_cast<int32_t>(offsetof(MonoListItem_tF9FE02BB3D5D8507333C93F1AF79B60901947A64, ___data_1)); }
inline RuntimeObject * get_data_1() const { return ___data_1; }
inline RuntimeObject ** get_address_of_data_1() { return &___data_1; }
inline void set_data_1(RuntimeObject * value)
{
___data_1 = value;
Il2CppCodeGenWriteBarrier((&___data_1), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // MONOLISTITEM_TF9FE02BB3D5D8507333C93F1AF79B60901947A64_H
#ifndef MONOTYPEINFO_T9A65BA5324D14FDFEB7644EEE6E1BDF74B8A393D_H
#define MONOTYPEINFO_T9A65BA5324D14FDFEB7644EEE6E1BDF74B8A393D_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.MonoTypeInfo
struct MonoTypeInfo_t9A65BA5324D14FDFEB7644EEE6E1BDF74B8A393D : public RuntimeObject
{
public:
// System.String System.MonoTypeInfo::full_name
String_t* ___full_name_0;
// System.Reflection.MonoCMethod System.MonoTypeInfo::default_ctor
MonoCMethod_tFB85687BEF8202F8B3E77FE24BCC2E400EA4FC61 * ___default_ctor_1;
public:
inline static int32_t get_offset_of_full_name_0() { return static_cast<int32_t>(offsetof(MonoTypeInfo_t9A65BA5324D14FDFEB7644EEE6E1BDF74B8A393D, ___full_name_0)); }
inline String_t* get_full_name_0() const { return ___full_name_0; }
inline String_t** get_address_of_full_name_0() { return &___full_name_0; }
inline void set_full_name_0(String_t* value)
{
___full_name_0 = value;
Il2CppCodeGenWriteBarrier((&___full_name_0), value);
}
inline static int32_t get_offset_of_default_ctor_1() { return static_cast<int32_t>(offsetof(MonoTypeInfo_t9A65BA5324D14FDFEB7644EEE6E1BDF74B8A393D, ___default_ctor_1)); }
inline MonoCMethod_tFB85687BEF8202F8B3E77FE24BCC2E400EA4FC61 * get_default_ctor_1() const { return ___default_ctor_1; }
inline MonoCMethod_tFB85687BEF8202F8B3E77FE24BCC2E400EA4FC61 ** get_address_of_default_ctor_1() { return &___default_ctor_1; }
inline void set_default_ctor_1(MonoCMethod_tFB85687BEF8202F8B3E77FE24BCC2E400EA4FC61 * value)
{
___default_ctor_1 = value;
Il2CppCodeGenWriteBarrier((&___default_ctor_1), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
// Native definition for P/Invoke marshalling of System.MonoTypeInfo
struct MonoTypeInfo_t9A65BA5324D14FDFEB7644EEE6E1BDF74B8A393D_marshaled_pinvoke
{
char* ___full_name_0;
MonoCMethod_tFB85687BEF8202F8B3E77FE24BCC2E400EA4FC61 * ___default_ctor_1;
};
// Native definition for COM marshalling of System.MonoTypeInfo
struct MonoTypeInfo_t9A65BA5324D14FDFEB7644EEE6E1BDF74B8A393D_marshaled_com
{
Il2CppChar* ___full_name_0;
MonoCMethod_tFB85687BEF8202F8B3E77FE24BCC2E400EA4FC61 * ___default_ctor_1;
};
#endif // MONOTYPEINFO_T9A65BA5324D14FDFEB7644EEE6E1BDF74B8A393D_H
#ifndef NULLABLE_T07CA5C3F88F56004BCB589DD7580798C66874C44_H
#define NULLABLE_T07CA5C3F88F56004BCB589DD7580798C66874C44_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Nullable
struct Nullable_t07CA5C3F88F56004BCB589DD7580798C66874C44 : public RuntimeObject
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // NULLABLE_T07CA5C3F88F56004BCB589DD7580798C66874C44_H
#ifndef NUMBERFORMATTER_T73E68FC7EA017E5EEB4AB92AF2FD959466D1A4BC_H
#define NUMBERFORMATTER_T73E68FC7EA017E5EEB4AB92AF2FD959466D1A4BC_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.NumberFormatter
struct NumberFormatter_t73E68FC7EA017E5EEB4AB92AF2FD959466D1A4BC : public RuntimeObject
{
public:
// System.Globalization.NumberFormatInfo System.NumberFormatter::_nfi
NumberFormatInfo_tFDF57037EBC5BC833D0A53EF0327B805994860A8 * ____nfi_6;
// System.Char[] System.NumberFormatter::_cbuf
CharU5BU5D_t4CC6ABF0AD71BEC97E3C2F1E9C5677E46D3A75C2* ____cbuf_7;
// System.Boolean System.NumberFormatter::_NaN
bool ____NaN_8;
// System.Boolean System.NumberFormatter::_infinity
bool ____infinity_9;
// System.Boolean System.NumberFormatter::_isCustomFormat
bool ____isCustomFormat_10;
// System.Boolean System.NumberFormatter::_specifierIsUpper
bool ____specifierIsUpper_11;
// System.Boolean System.NumberFormatter::_positive
bool ____positive_12;
// System.Char System.NumberFormatter::_specifier
Il2CppChar ____specifier_13;
// System.Int32 System.NumberFormatter::_precision
int32_t ____precision_14;
// System.Int32 System.NumberFormatter::_defPrecision
int32_t ____defPrecision_15;
// System.Int32 System.NumberFormatter::_digitsLen
int32_t ____digitsLen_16;
// System.Int32 System.NumberFormatter::_offset
int32_t ____offset_17;
// System.Int32 System.NumberFormatter::_decPointPos
int32_t ____decPointPos_18;
// System.UInt32 System.NumberFormatter::_val1
uint32_t ____val1_19;
// System.UInt32 System.NumberFormatter::_val2
uint32_t ____val2_20;
// System.UInt32 System.NumberFormatter::_val3
uint32_t ____val3_21;
// System.UInt32 System.NumberFormatter::_val4
uint32_t ____val4_22;
// System.Int32 System.NumberFormatter::_ind
int32_t ____ind_23;
public:
inline static int32_t get_offset_of__nfi_6() { return static_cast<int32_t>(offsetof(NumberFormatter_t73E68FC7EA017E5EEB4AB92AF2FD959466D1A4BC, ____nfi_6)); }
inline NumberFormatInfo_tFDF57037EBC5BC833D0A53EF0327B805994860A8 * get__nfi_6() const { return ____nfi_6; }
inline NumberFormatInfo_tFDF57037EBC5BC833D0A53EF0327B805994860A8 ** get_address_of__nfi_6() { return &____nfi_6; }
inline void set__nfi_6(NumberFormatInfo_tFDF57037EBC5BC833D0A53EF0327B805994860A8 * value)
{
____nfi_6 = value;
Il2CppCodeGenWriteBarrier((&____nfi_6), value);
}
inline static int32_t get_offset_of__cbuf_7() { return static_cast<int32_t>(offsetof(NumberFormatter_t73E68FC7EA017E5EEB4AB92AF2FD959466D1A4BC, ____cbuf_7)); }
inline CharU5BU5D_t4CC6ABF0AD71BEC97E3C2F1E9C5677E46D3A75C2* get__cbuf_7() const { return ____cbuf_7; }
inline CharU5BU5D_t4CC6ABF0AD71BEC97E3C2F1E9C5677E46D3A75C2** get_address_of__cbuf_7() { return &____cbuf_7; }
inline void set__cbuf_7(CharU5BU5D_t4CC6ABF0AD71BEC97E3C2F1E9C5677E46D3A75C2* value)
{
____cbuf_7 = value;
Il2CppCodeGenWriteBarrier((&____cbuf_7), value);
}
inline static int32_t get_offset_of__NaN_8() { return static_cast<int32_t>(offsetof(NumberFormatter_t73E68FC7EA017E5EEB4AB92AF2FD959466D1A4BC, ____NaN_8)); }
inline bool get__NaN_8() const { return ____NaN_8; }
inline bool* get_address_of__NaN_8() { return &____NaN_8; }
inline void set__NaN_8(bool value)
{
____NaN_8 = value;
}
inline static int32_t get_offset_of__infinity_9() { return static_cast<int32_t>(offsetof(NumberFormatter_t73E68FC7EA017E5EEB4AB92AF2FD959466D1A4BC, ____infinity_9)); }
inline bool get__infinity_9() const { return ____infinity_9; }
inline bool* get_address_of__infinity_9() { return &____infinity_9; }
inline void set__infinity_9(bool value)
{
____infinity_9 = value;
}
inline static int32_t get_offset_of__isCustomFormat_10() { return static_cast<int32_t>(offsetof(NumberFormatter_t73E68FC7EA017E5EEB4AB92AF2FD959466D1A4BC, ____isCustomFormat_10)); }
inline bool get__isCustomFormat_10() const { return ____isCustomFormat_10; }
inline bool* get_address_of__isCustomFormat_10() { return &____isCustomFormat_10; }
inline void set__isCustomFormat_10(bool value)
{
____isCustomFormat_10 = value;
}
inline static int32_t get_offset_of__specifierIsUpper_11() { return static_cast<int32_t>(offsetof(NumberFormatter_t73E68FC7EA017E5EEB4AB92AF2FD959466D1A4BC, ____specifierIsUpper_11)); }
inline bool get__specifierIsUpper_11() const { return ____specifierIsUpper_11; }
inline bool* get_address_of__specifierIsUpper_11() { return &____specifierIsUpper_11; }
inline void set__specifierIsUpper_11(bool value)
{
____specifierIsUpper_11 = value;
}
inline static int32_t get_offset_of__positive_12() { return static_cast<int32_t>(offsetof(NumberFormatter_t73E68FC7EA017E5EEB4AB92AF2FD959466D1A4BC, ____positive_12)); }
inline bool get__positive_12() const { return ____positive_12; }
inline bool* get_address_of__positive_12() { return &____positive_12; }
inline void set__positive_12(bool value)
{
____positive_12 = value;
}
inline static int32_t get_offset_of__specifier_13() { return static_cast<int32_t>(offsetof(NumberFormatter_t73E68FC7EA017E5EEB4AB92AF2FD959466D1A4BC, ____specifier_13)); }
inline Il2CppChar get__specifier_13() const { return ____specifier_13; }
inline Il2CppChar* get_address_of__specifier_13() { return &____specifier_13; }
inline void set__specifier_13(Il2CppChar value)
{
____specifier_13 = value;
}
inline static int32_t get_offset_of__precision_14() { return static_cast<int32_t>(offsetof(NumberFormatter_t73E68FC7EA017E5EEB4AB92AF2FD959466D1A4BC, ____precision_14)); }
inline int32_t get__precision_14() const { return ____precision_14; }
inline int32_t* get_address_of__precision_14() { return &____precision_14; }
inline void set__precision_14(int32_t value)
{
____precision_14 = value;
}
inline static int32_t get_offset_of__defPrecision_15() { return static_cast<int32_t>(offsetof(NumberFormatter_t73E68FC7EA017E5EEB4AB92AF2FD959466D1A4BC, ____defPrecision_15)); }
inline int32_t get__defPrecision_15() const { return ____defPrecision_15; }
inline int32_t* get_address_of__defPrecision_15() { return &____defPrecision_15; }
inline void set__defPrecision_15(int32_t value)
{
____defPrecision_15 = value;
}
inline static int32_t get_offset_of__digitsLen_16() { return static_cast<int32_t>(offsetof(NumberFormatter_t73E68FC7EA017E5EEB4AB92AF2FD959466D1A4BC, ____digitsLen_16)); }
inline int32_t get__digitsLen_16() const { return ____digitsLen_16; }
inline int32_t* get_address_of__digitsLen_16() { return &____digitsLen_16; }
inline void set__digitsLen_16(int32_t value)
{
____digitsLen_16 = value;
}
inline static int32_t get_offset_of__offset_17() { return static_cast<int32_t>(offsetof(NumberFormatter_t73E68FC7EA017E5EEB4AB92AF2FD959466D1A4BC, ____offset_17)); }
inline int32_t get__offset_17() const { return ____offset_17; }
inline int32_t* get_address_of__offset_17() { return &____offset_17; }
inline void set__offset_17(int32_t value)
{
____offset_17 = value;
}
inline static int32_t get_offset_of__decPointPos_18() { return static_cast<int32_t>(offsetof(NumberFormatter_t73E68FC7EA017E5EEB4AB92AF2FD959466D1A4BC, ____decPointPos_18)); }
inline int32_t get__decPointPos_18() const { return ____decPointPos_18; }
inline int32_t* get_address_of__decPointPos_18() { return &____decPointPos_18; }
inline void set__decPointPos_18(int32_t value)
{
____decPointPos_18 = value;
}
inline static int32_t get_offset_of__val1_19() { return static_cast<int32_t>(offsetof(NumberFormatter_t73E68FC7EA017E5EEB4AB92AF2FD959466D1A4BC, ____val1_19)); }
inline uint32_t get__val1_19() const { return ____val1_19; }
inline uint32_t* get_address_of__val1_19() { return &____val1_19; }
inline void set__val1_19(uint32_t value)
{
____val1_19 = value;
}
inline static int32_t get_offset_of__val2_20() { return static_cast<int32_t>(offsetof(NumberFormatter_t73E68FC7EA017E5EEB4AB92AF2FD959466D1A4BC, ____val2_20)); }
inline uint32_t get__val2_20() const { return ____val2_20; }
inline uint32_t* get_address_of__val2_20() { return &____val2_20; }
inline void set__val2_20(uint32_t value)
{
____val2_20 = value;
}
inline static int32_t get_offset_of__val3_21() { return static_cast<int32_t>(offsetof(NumberFormatter_t73E68FC7EA017E5EEB4AB92AF2FD959466D1A4BC, ____val3_21)); }
inline uint32_t get__val3_21() const { return ____val3_21; }
inline uint32_t* get_address_of__val3_21() { return &____val3_21; }
inline void set__val3_21(uint32_t value)
{
____val3_21 = value;
}
inline static int32_t get_offset_of__val4_22() { return static_cast<int32_t>(offsetof(NumberFormatter_t73E68FC7EA017E5EEB4AB92AF2FD959466D1A4BC, ____val4_22)); }
inline uint32_t get__val4_22() const { return ____val4_22; }
inline uint32_t* get_address_of__val4_22() { return &____val4_22; }
inline void set__val4_22(uint32_t value)
{
____val4_22 = value;
}
inline static int32_t get_offset_of__ind_23() { return static_cast<int32_t>(offsetof(NumberFormatter_t73E68FC7EA017E5EEB4AB92AF2FD959466D1A4BC, ____ind_23)); }
inline int32_t get__ind_23() const { return ____ind_23; }
inline int32_t* get_address_of__ind_23() { return &____ind_23; }
inline void set__ind_23(int32_t value)
{
____ind_23 = value;
}
};
struct NumberFormatter_t73E68FC7EA017E5EEB4AB92AF2FD959466D1A4BC_StaticFields
{
public:
// System.UInt64* System.NumberFormatter::MantissaBitsTable
uint64_t* ___MantissaBitsTable_0;
// System.Int32* System.NumberFormatter::TensExponentTable
int32_t* ___TensExponentTable_1;
// System.Char* System.NumberFormatter::DigitLowerTable
Il2CppChar* ___DigitLowerTable_2;
// System.Char* System.NumberFormatter::DigitUpperTable
Il2CppChar* ___DigitUpperTable_3;
// System.Int64* System.NumberFormatter::TenPowersList
int64_t* ___TenPowersList_4;
// System.Int32* System.NumberFormatter::DecHexDigits
int32_t* ___DecHexDigits_5;
public:
inline static int32_t get_offset_of_MantissaBitsTable_0() { return static_cast<int32_t>(offsetof(NumberFormatter_t73E68FC7EA017E5EEB4AB92AF2FD959466D1A4BC_StaticFields, ___MantissaBitsTable_0)); }
inline uint64_t* get_MantissaBitsTable_0() const { return ___MantissaBitsTable_0; }
inline uint64_t** get_address_of_MantissaBitsTable_0() { return &___MantissaBitsTable_0; }
inline void set_MantissaBitsTable_0(uint64_t* value)
{
___MantissaBitsTable_0 = value;
}
inline static int32_t get_offset_of_TensExponentTable_1() { return static_cast<int32_t>(offsetof(NumberFormatter_t73E68FC7EA017E5EEB4AB92AF2FD959466D1A4BC_StaticFields, ___TensExponentTable_1)); }
inline int32_t* get_TensExponentTable_1() const { return ___TensExponentTable_1; }
inline int32_t** get_address_of_TensExponentTable_1() { return &___TensExponentTable_1; }
inline void set_TensExponentTable_1(int32_t* value)
{
___TensExponentTable_1 = value;
}
inline static int32_t get_offset_of_DigitLowerTable_2() { return static_cast<int32_t>(offsetof(NumberFormatter_t73E68FC7EA017E5EEB4AB92AF2FD959466D1A4BC_StaticFields, ___DigitLowerTable_2)); }
inline Il2CppChar* get_DigitLowerTable_2() const { return ___DigitLowerTable_2; }
inline Il2CppChar** get_address_of_DigitLowerTable_2() { return &___DigitLowerTable_2; }
inline void set_DigitLowerTable_2(Il2CppChar* value)
{
___DigitLowerTable_2 = value;
}
inline static int32_t get_offset_of_DigitUpperTable_3() { return static_cast<int32_t>(offsetof(NumberFormatter_t73E68FC7EA017E5EEB4AB92AF2FD959466D1A4BC_StaticFields, ___DigitUpperTable_3)); }
inline Il2CppChar* get_DigitUpperTable_3() const { return ___DigitUpperTable_3; }
inline Il2CppChar** get_address_of_DigitUpperTable_3() { return &___DigitUpperTable_3; }
inline void set_DigitUpperTable_3(Il2CppChar* value)
{
___DigitUpperTable_3 = value;
}
inline static int32_t get_offset_of_TenPowersList_4() { return static_cast<int32_t>(offsetof(NumberFormatter_t73E68FC7EA017E5EEB4AB92AF2FD959466D1A4BC_StaticFields, ___TenPowersList_4)); }
inline int64_t* get_TenPowersList_4() const { return ___TenPowersList_4; }
inline int64_t** get_address_of_TenPowersList_4() { return &___TenPowersList_4; }
inline void set_TenPowersList_4(int64_t* value)
{
___TenPowersList_4 = value;
}
inline static int32_t get_offset_of_DecHexDigits_5() { return static_cast<int32_t>(offsetof(NumberFormatter_t73E68FC7EA017E5EEB4AB92AF2FD959466D1A4BC_StaticFields, ___DecHexDigits_5)); }
inline int32_t* get_DecHexDigits_5() const { return ___DecHexDigits_5; }
inline int32_t** get_address_of_DecHexDigits_5() { return &___DecHexDigits_5; }
inline void set_DecHexDigits_5(int32_t* value)
{
___DecHexDigits_5 = value;
}
};
struct NumberFormatter_t73E68FC7EA017E5EEB4AB92AF2FD959466D1A4BC_ThreadStaticFields
{
public:
// System.NumberFormatter System.NumberFormatter::threadNumberFormatter
NumberFormatter_t73E68FC7EA017E5EEB4AB92AF2FD959466D1A4BC * ___threadNumberFormatter_24;
// System.NumberFormatter System.NumberFormatter::userFormatProvider
NumberFormatter_t73E68FC7EA017E5EEB4AB92AF2FD959466D1A4BC * ___userFormatProvider_25;
public:
inline static int32_t get_offset_of_threadNumberFormatter_24() { return static_cast<int32_t>(offsetof(NumberFormatter_t73E68FC7EA017E5EEB4AB92AF2FD959466D1A4BC_ThreadStaticFields, ___threadNumberFormatter_24)); }
inline NumberFormatter_t73E68FC7EA017E5EEB4AB92AF2FD959466D1A4BC * get_threadNumberFormatter_24() const { return ___threadNumberFormatter_24; }
inline NumberFormatter_t73E68FC7EA017E5EEB4AB92AF2FD959466D1A4BC ** get_address_of_threadNumberFormatter_24() { return &___threadNumberFormatter_24; }
inline void set_threadNumberFormatter_24(NumberFormatter_t73E68FC7EA017E5EEB4AB92AF2FD959466D1A4BC * value)
{
___threadNumberFormatter_24 = value;
Il2CppCodeGenWriteBarrier((&___threadNumberFormatter_24), value);
}
inline static int32_t get_offset_of_userFormatProvider_25() { return static_cast<int32_t>(offsetof(NumberFormatter_t73E68FC7EA017E5EEB4AB92AF2FD959466D1A4BC_ThreadStaticFields, ___userFormatProvider_25)); }
inline NumberFormatter_t73E68FC7EA017E5EEB4AB92AF2FD959466D1A4BC * get_userFormatProvider_25() const { return ___userFormatProvider_25; }
inline NumberFormatter_t73E68FC7EA017E5EEB4AB92AF2FD959466D1A4BC ** get_address_of_userFormatProvider_25() { return &___userFormatProvider_25; }
inline void set_userFormatProvider_25(NumberFormatter_t73E68FC7EA017E5EEB4AB92AF2FD959466D1A4BC * value)
{
___userFormatProvider_25 = value;
Il2CppCodeGenWriteBarrier((&___userFormatProvider_25), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // NUMBERFORMATTER_T73E68FC7EA017E5EEB4AB92AF2FD959466D1A4BC_H
#ifndef CUSTOMINFO_T3C5397567D3BBF326ED9C3D9680AE658DE4612E1_H
#define CUSTOMINFO_T3C5397567D3BBF326ED9C3D9680AE658DE4612E1_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.NumberFormatter_CustomInfo
struct CustomInfo_t3C5397567D3BBF326ED9C3D9680AE658DE4612E1 : public RuntimeObject
{
public:
// System.Boolean System.NumberFormatter_CustomInfo::UseGroup
bool ___UseGroup_0;
// System.Int32 System.NumberFormatter_CustomInfo::DecimalDigits
int32_t ___DecimalDigits_1;
// System.Int32 System.NumberFormatter_CustomInfo::DecimalPointPos
int32_t ___DecimalPointPos_2;
// System.Int32 System.NumberFormatter_CustomInfo::DecimalTailSharpDigits
int32_t ___DecimalTailSharpDigits_3;
// System.Int32 System.NumberFormatter_CustomInfo::IntegerDigits
int32_t ___IntegerDigits_4;
// System.Int32 System.NumberFormatter_CustomInfo::IntegerHeadSharpDigits
int32_t ___IntegerHeadSharpDigits_5;
// System.Int32 System.NumberFormatter_CustomInfo::IntegerHeadPos
int32_t ___IntegerHeadPos_6;
// System.Boolean System.NumberFormatter_CustomInfo::UseExponent
bool ___UseExponent_7;
// System.Int32 System.NumberFormatter_CustomInfo::ExponentDigits
int32_t ___ExponentDigits_8;
// System.Int32 System.NumberFormatter_CustomInfo::ExponentTailSharpDigits
int32_t ___ExponentTailSharpDigits_9;
// System.Boolean System.NumberFormatter_CustomInfo::ExponentNegativeSignOnly
bool ___ExponentNegativeSignOnly_10;
// System.Int32 System.NumberFormatter_CustomInfo::DividePlaces
int32_t ___DividePlaces_11;
// System.Int32 System.NumberFormatter_CustomInfo::Percents
int32_t ___Percents_12;
// System.Int32 System.NumberFormatter_CustomInfo::Permilles
int32_t ___Permilles_13;
public:
inline static int32_t get_offset_of_UseGroup_0() { return static_cast<int32_t>(offsetof(CustomInfo_t3C5397567D3BBF326ED9C3D9680AE658DE4612E1, ___UseGroup_0)); }
inline bool get_UseGroup_0() const { return ___UseGroup_0; }
inline bool* get_address_of_UseGroup_0() { return &___UseGroup_0; }
inline void set_UseGroup_0(bool value)
{
___UseGroup_0 = value;
}
inline static int32_t get_offset_of_DecimalDigits_1() { return static_cast<int32_t>(offsetof(CustomInfo_t3C5397567D3BBF326ED9C3D9680AE658DE4612E1, ___DecimalDigits_1)); }
inline int32_t get_DecimalDigits_1() const { return ___DecimalDigits_1; }
inline int32_t* get_address_of_DecimalDigits_1() { return &___DecimalDigits_1; }
inline void set_DecimalDigits_1(int32_t value)
{
___DecimalDigits_1 = value;
}
inline static int32_t get_offset_of_DecimalPointPos_2() { return static_cast<int32_t>(offsetof(CustomInfo_t3C5397567D3BBF326ED9C3D9680AE658DE4612E1, ___DecimalPointPos_2)); }
inline int32_t get_DecimalPointPos_2() const { return ___DecimalPointPos_2; }
inline int32_t* get_address_of_DecimalPointPos_2() { return &___DecimalPointPos_2; }
inline void set_DecimalPointPos_2(int32_t value)
{
___DecimalPointPos_2 = value;
}
inline static int32_t get_offset_of_DecimalTailSharpDigits_3() { return static_cast<int32_t>(offsetof(CustomInfo_t3C5397567D3BBF326ED9C3D9680AE658DE4612E1, ___DecimalTailSharpDigits_3)); }
inline int32_t get_DecimalTailSharpDigits_3() const { return ___DecimalTailSharpDigits_3; }
inline int32_t* get_address_of_DecimalTailSharpDigits_3() { return &___DecimalTailSharpDigits_3; }
inline void set_DecimalTailSharpDigits_3(int32_t value)
{
___DecimalTailSharpDigits_3 = value;
}
inline static int32_t get_offset_of_IntegerDigits_4() { return static_cast<int32_t>(offsetof(CustomInfo_t3C5397567D3BBF326ED9C3D9680AE658DE4612E1, ___IntegerDigits_4)); }
inline int32_t get_IntegerDigits_4() const { return ___IntegerDigits_4; }
inline int32_t* get_address_of_IntegerDigits_4() { return &___IntegerDigits_4; }
inline void set_IntegerDigits_4(int32_t value)
{
___IntegerDigits_4 = value;
}
inline static int32_t get_offset_of_IntegerHeadSharpDigits_5() { return static_cast<int32_t>(offsetof(CustomInfo_t3C5397567D3BBF326ED9C3D9680AE658DE4612E1, ___IntegerHeadSharpDigits_5)); }
inline int32_t get_IntegerHeadSharpDigits_5() const { return ___IntegerHeadSharpDigits_5; }
inline int32_t* get_address_of_IntegerHeadSharpDigits_5() { return &___IntegerHeadSharpDigits_5; }
inline void set_IntegerHeadSharpDigits_5(int32_t value)
{
___IntegerHeadSharpDigits_5 = value;
}
inline static int32_t get_offset_of_IntegerHeadPos_6() { return static_cast<int32_t>(offsetof(CustomInfo_t3C5397567D3BBF326ED9C3D9680AE658DE4612E1, ___IntegerHeadPos_6)); }
inline int32_t get_IntegerHeadPos_6() const { return ___IntegerHeadPos_6; }
inline int32_t* get_address_of_IntegerHeadPos_6() { return &___IntegerHeadPos_6; }
inline void set_IntegerHeadPos_6(int32_t value)
{
___IntegerHeadPos_6 = value;
}
inline static int32_t get_offset_of_UseExponent_7() { return static_cast<int32_t>(offsetof(CustomInfo_t3C5397567D3BBF326ED9C3D9680AE658DE4612E1, ___UseExponent_7)); }
inline bool get_UseExponent_7() const { return ___UseExponent_7; }
inline bool* get_address_of_UseExponent_7() { return &___UseExponent_7; }
inline void set_UseExponent_7(bool value)
{
___UseExponent_7 = value;
}
inline static int32_t get_offset_of_ExponentDigits_8() { return static_cast<int32_t>(offsetof(CustomInfo_t3C5397567D3BBF326ED9C3D9680AE658DE4612E1, ___ExponentDigits_8)); }
inline int32_t get_ExponentDigits_8() const { return ___ExponentDigits_8; }
inline int32_t* get_address_of_ExponentDigits_8() { return &___ExponentDigits_8; }
inline void set_ExponentDigits_8(int32_t value)
{
___ExponentDigits_8 = value;
}
inline static int32_t get_offset_of_ExponentTailSharpDigits_9() { return static_cast<int32_t>(offsetof(CustomInfo_t3C5397567D3BBF326ED9C3D9680AE658DE4612E1, ___ExponentTailSharpDigits_9)); }
inline int32_t get_ExponentTailSharpDigits_9() const { return ___ExponentTailSharpDigits_9; }
inline int32_t* get_address_of_ExponentTailSharpDigits_9() { return &___ExponentTailSharpDigits_9; }
inline void set_ExponentTailSharpDigits_9(int32_t value)
{
___ExponentTailSharpDigits_9 = value;
}
inline static int32_t get_offset_of_ExponentNegativeSignOnly_10() { return static_cast<int32_t>(offsetof(CustomInfo_t3C5397567D3BBF326ED9C3D9680AE658DE4612E1, ___ExponentNegativeSignOnly_10)); }
inline bool get_ExponentNegativeSignOnly_10() const { return ___ExponentNegativeSignOnly_10; }
inline bool* get_address_of_ExponentNegativeSignOnly_10() { return &___ExponentNegativeSignOnly_10; }
inline void set_ExponentNegativeSignOnly_10(bool value)
{
___ExponentNegativeSignOnly_10 = value;
}
inline static int32_t get_offset_of_DividePlaces_11() { return static_cast<int32_t>(offsetof(CustomInfo_t3C5397567D3BBF326ED9C3D9680AE658DE4612E1, ___DividePlaces_11)); }
inline int32_t get_DividePlaces_11() const { return ___DividePlaces_11; }
inline int32_t* get_address_of_DividePlaces_11() { return &___DividePlaces_11; }
inline void set_DividePlaces_11(int32_t value)
{
___DividePlaces_11 = value;
}
inline static int32_t get_offset_of_Percents_12() { return static_cast<int32_t>(offsetof(CustomInfo_t3C5397567D3BBF326ED9C3D9680AE658DE4612E1, ___Percents_12)); }
inline int32_t get_Percents_12() const { return ___Percents_12; }
inline int32_t* get_address_of_Percents_12() { return &___Percents_12; }
inline void set_Percents_12(int32_t value)
{
___Percents_12 = value;
}
inline static int32_t get_offset_of_Permilles_13() { return static_cast<int32_t>(offsetof(CustomInfo_t3C5397567D3BBF326ED9C3D9680AE658DE4612E1, ___Permilles_13)); }
inline int32_t get_Permilles_13() const { return ___Permilles_13; }
inline int32_t* get_address_of_Permilles_13() { return &___Permilles_13; }
inline void set_Permilles_13(int32_t value)
{
___Permilles_13 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // CUSTOMINFO_T3C5397567D3BBF326ED9C3D9680AE658DE4612E1_H
#ifndef PARAMETERIZEDSTRINGS_T495ED7291D56B901CAA1F10EC25739C3C99DC923_H
#define PARAMETERIZEDSTRINGS_T495ED7291D56B901CAA1F10EC25739C3C99DC923_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.ParameterizedStrings
struct ParameterizedStrings_t495ED7291D56B901CAA1F10EC25739C3C99DC923 : public RuntimeObject
{
public:
public:
};
struct ParameterizedStrings_t495ED7291D56B901CAA1F10EC25739C3C99DC923_ThreadStaticFields
{
public:
// System.ParameterizedStrings_LowLevelStack System.ParameterizedStrings::_cachedStack
LowLevelStack_tAED9B2A5CEC7125CF57BEE067AC399CEE3510EC2 * ____cachedStack_0;
public:
inline static int32_t get_offset_of__cachedStack_0() { return static_cast<int32_t>(offsetof(ParameterizedStrings_t495ED7291D56B901CAA1F10EC25739C3C99DC923_ThreadStaticFields, ____cachedStack_0)); }
inline LowLevelStack_tAED9B2A5CEC7125CF57BEE067AC399CEE3510EC2 * get__cachedStack_0() const { return ____cachedStack_0; }
inline LowLevelStack_tAED9B2A5CEC7125CF57BEE067AC399CEE3510EC2 ** get_address_of__cachedStack_0() { return &____cachedStack_0; }
inline void set__cachedStack_0(LowLevelStack_tAED9B2A5CEC7125CF57BEE067AC399CEE3510EC2 * value)
{
____cachedStack_0 = value;
Il2CppCodeGenWriteBarrier((&____cachedStack_0), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // PARAMETERIZEDSTRINGS_T495ED7291D56B901CAA1F10EC25739C3C99DC923_H
#ifndef LOWLEVELSTACK_TAED9B2A5CEC7125CF57BEE067AC399CEE3510EC2_H
#define LOWLEVELSTACK_TAED9B2A5CEC7125CF57BEE067AC399CEE3510EC2_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.ParameterizedStrings_LowLevelStack
struct LowLevelStack_tAED9B2A5CEC7125CF57BEE067AC399CEE3510EC2 : public RuntimeObject
{
public:
// System.ParameterizedStrings_FormatParam[] System.ParameterizedStrings_LowLevelStack::_arr
FormatParamU5BU5D_t2F95A3C5AF726E75A42BC28843BAD579B62199B5* ____arr_0;
// System.Int32 System.ParameterizedStrings_LowLevelStack::_count
int32_t ____count_1;
public:
inline static int32_t get_offset_of__arr_0() { return static_cast<int32_t>(offsetof(LowLevelStack_tAED9B2A5CEC7125CF57BEE067AC399CEE3510EC2, ____arr_0)); }
inline FormatParamU5BU5D_t2F95A3C5AF726E75A42BC28843BAD579B62199B5* get__arr_0() const { return ____arr_0; }
inline FormatParamU5BU5D_t2F95A3C5AF726E75A42BC28843BAD579B62199B5** get_address_of__arr_0() { return &____arr_0; }
inline void set__arr_0(FormatParamU5BU5D_t2F95A3C5AF726E75A42BC28843BAD579B62199B5* value)
{
____arr_0 = value;
Il2CppCodeGenWriteBarrier((&____arr_0), value);
}
inline static int32_t get_offset_of__count_1() { return static_cast<int32_t>(offsetof(LowLevelStack_tAED9B2A5CEC7125CF57BEE067AC399CEE3510EC2, ____count_1)); }
inline int32_t get__count_1() const { return ____count_1; }
inline int32_t* get_address_of__count_1() { return &____count_1; }
inline void set__count_1(int32_t value)
{
____count_1 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // LOWLEVELSTACK_TAED9B2A5CEC7125CF57BEE067AC399CEE3510EC2_H
#ifndef PARSENUMBERS_TFCD9612B791F297E13D1D622F88219D9D471331A_H
#define PARSENUMBERS_TFCD9612B791F297E13D1D622F88219D9D471331A_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.ParseNumbers
struct ParseNumbers_tFCD9612B791F297E13D1D622F88219D9D471331A : public RuntimeObject
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // PARSENUMBERS_TFCD9612B791F297E13D1D622F88219D9D471331A_H
#ifndef POINTERSPEC_TBCE1666DC24EC6E4E5376FEC214499984EC26892_H
#define POINTERSPEC_TBCE1666DC24EC6E4E5376FEC214499984EC26892_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.PointerSpec
struct PointerSpec_tBCE1666DC24EC6E4E5376FEC214499984EC26892 : public RuntimeObject
{
public:
// System.Int32 System.PointerSpec::pointer_level
int32_t ___pointer_level_0;
public:
inline static int32_t get_offset_of_pointer_level_0() { return static_cast<int32_t>(offsetof(PointerSpec_tBCE1666DC24EC6E4E5376FEC214499984EC26892, ___pointer_level_0)); }
inline int32_t get_pointer_level_0() const { return ___pointer_level_0; }
inline int32_t* get_address_of_pointer_level_0() { return &___pointer_level_0; }
inline void set_pointer_level_0(int32_t value)
{
___pointer_level_0 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // POINTERSPEC_TBCE1666DC24EC6E4E5376FEC214499984EC26892_H
#ifndef MEMBERINFO_T_H
#define MEMBERINFO_T_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Reflection.MemberInfo
struct MemberInfo_t : public RuntimeObject
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // MEMBERINFO_T_H
#ifndef TERMINFOREADER_TCAABF3484E6F0AA298F809766C52CA9DC4E6C55C_H
#define TERMINFOREADER_TCAABF3484E6F0AA298F809766C52CA9DC4E6C55C_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.TermInfoReader
struct TermInfoReader_tCAABF3484E6F0AA298F809766C52CA9DC4E6C55C : public RuntimeObject
{
public:
// System.Int16 System.TermInfoReader::boolSize
int16_t ___boolSize_0;
// System.Int16 System.TermInfoReader::numSize
int16_t ___numSize_1;
// System.Int16 System.TermInfoReader::strOffsets
int16_t ___strOffsets_2;
// System.Byte[] System.TermInfoReader::buffer
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* ___buffer_3;
// System.Int32 System.TermInfoReader::booleansOffset
int32_t ___booleansOffset_4;
public:
inline static int32_t get_offset_of_boolSize_0() { return static_cast<int32_t>(offsetof(TermInfoReader_tCAABF3484E6F0AA298F809766C52CA9DC4E6C55C, ___boolSize_0)); }
inline int16_t get_boolSize_0() const { return ___boolSize_0; }
inline int16_t* get_address_of_boolSize_0() { return &___boolSize_0; }
inline void set_boolSize_0(int16_t value)
{
___boolSize_0 = value;
}
inline static int32_t get_offset_of_numSize_1() { return static_cast<int32_t>(offsetof(TermInfoReader_tCAABF3484E6F0AA298F809766C52CA9DC4E6C55C, ___numSize_1)); }
inline int16_t get_numSize_1() const { return ___numSize_1; }
inline int16_t* get_address_of_numSize_1() { return &___numSize_1; }
inline void set_numSize_1(int16_t value)
{
___numSize_1 = value;
}
inline static int32_t get_offset_of_strOffsets_2() { return static_cast<int32_t>(offsetof(TermInfoReader_tCAABF3484E6F0AA298F809766C52CA9DC4E6C55C, ___strOffsets_2)); }
inline int16_t get_strOffsets_2() const { return ___strOffsets_2; }
inline int16_t* get_address_of_strOffsets_2() { return &___strOffsets_2; }
inline void set_strOffsets_2(int16_t value)
{
___strOffsets_2 = value;
}
inline static int32_t get_offset_of_buffer_3() { return static_cast<int32_t>(offsetof(TermInfoReader_tCAABF3484E6F0AA298F809766C52CA9DC4E6C55C, ___buffer_3)); }
inline ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* get_buffer_3() const { return ___buffer_3; }
inline ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821** get_address_of_buffer_3() { return &___buffer_3; }
inline void set_buffer_3(ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* value)
{
___buffer_3 = value;
Il2CppCodeGenWriteBarrier((&___buffer_3), value);
}
inline static int32_t get_offset_of_booleansOffset_4() { return static_cast<int32_t>(offsetof(TermInfoReader_tCAABF3484E6F0AA298F809766C52CA9DC4E6C55C, ___booleansOffset_4)); }
inline int32_t get_booleansOffset_4() const { return ___booleansOffset_4; }
inline int32_t* get_address_of_booleansOffset_4() { return &___booleansOffset_4; }
inline void set_booleansOffset_4(int32_t value)
{
___booleansOffset_4 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // TERMINFOREADER_TCAABF3484E6F0AA298F809766C52CA9DC4E6C55C_H
#ifndef TIMETYPE_T1E0366D2FDDE13B93F6DFD1A2FB8645B76E9DDA9_H
#define TIMETYPE_T1E0366D2FDDE13B93F6DFD1A2FB8645B76E9DDA9_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.TimeType
struct TimeType_t1E0366D2FDDE13B93F6DFD1A2FB8645B76E9DDA9 : public RuntimeObject
{
public:
// System.Int32 System.TimeType::Offset
int32_t ___Offset_0;
// System.Boolean System.TimeType::IsDst
bool ___IsDst_1;
// System.String System.TimeType::Name
String_t* ___Name_2;
public:
inline static int32_t get_offset_of_Offset_0() { return static_cast<int32_t>(offsetof(TimeType_t1E0366D2FDDE13B93F6DFD1A2FB8645B76E9DDA9, ___Offset_0)); }
inline int32_t get_Offset_0() const { return ___Offset_0; }
inline int32_t* get_address_of_Offset_0() { return &___Offset_0; }
inline void set_Offset_0(int32_t value)
{
___Offset_0 = value;
}
inline static int32_t get_offset_of_IsDst_1() { return static_cast<int32_t>(offsetof(TimeType_t1E0366D2FDDE13B93F6DFD1A2FB8645B76E9DDA9, ___IsDst_1)); }
inline bool get_IsDst_1() const { return ___IsDst_1; }
inline bool* get_address_of_IsDst_1() { return &___IsDst_1; }
inline void set_IsDst_1(bool value)
{
___IsDst_1 = value;
}
inline static int32_t get_offset_of_Name_2() { return static_cast<int32_t>(offsetof(TimeType_t1E0366D2FDDE13B93F6DFD1A2FB8645B76E9DDA9, ___Name_2)); }
inline String_t* get_Name_2() const { return ___Name_2; }
inline String_t** get_address_of_Name_2() { return &___Name_2; }
inline void set_Name_2(String_t* value)
{
___Name_2 = value;
Il2CppCodeGenWriteBarrier((&___Name_2), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // TIMETYPE_T1E0366D2FDDE13B93F6DFD1A2FB8645B76E9DDA9_H
#ifndef TIMEZONE_TA2DF435DA1A379978B885F0872A93774666B7454_H
#define TIMEZONE_TA2DF435DA1A379978B885F0872A93774666B7454_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.TimeZone
struct TimeZone_tA2DF435DA1A379978B885F0872A93774666B7454 : public RuntimeObject
{
public:
public:
};
struct TimeZone_tA2DF435DA1A379978B885F0872A93774666B7454_StaticFields
{
public:
// System.Object System.TimeZone::tz_lock
RuntimeObject * ___tz_lock_0;
public:
inline static int32_t get_offset_of_tz_lock_0() { return static_cast<int32_t>(offsetof(TimeZone_tA2DF435DA1A379978B885F0872A93774666B7454_StaticFields, ___tz_lock_0)); }
inline RuntimeObject * get_tz_lock_0() const { return ___tz_lock_0; }
inline RuntimeObject ** get_address_of_tz_lock_0() { return &___tz_lock_0; }
inline void set_tz_lock_0(RuntimeObject * value)
{
___tz_lock_0 = value;
Il2CppCodeGenWriteBarrier((&___tz_lock_0), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // TIMEZONE_TA2DF435DA1A379978B885F0872A93774666B7454_H
#ifndef TYPEIDENTIFIERS_TBC5BC4024D376DCB779D877A1616CF4D7DB809E6_H
#define TYPEIDENTIFIERS_TBC5BC4024D376DCB779D877A1616CF4D7DB809E6_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.TypeIdentifiers
struct TypeIdentifiers_tBC5BC4024D376DCB779D877A1616CF4D7DB809E6 : public RuntimeObject
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // TYPEIDENTIFIERS_TBC5BC4024D376DCB779D877A1616CF4D7DB809E6_H
#ifndef TYPENAMEPARSER_TBEF78C9D6AEC3DE5E2993F6EDC24C06F7B713741_H
#define TYPENAMEPARSER_TBEF78C9D6AEC3DE5E2993F6EDC24C06F7B713741_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.TypeNameParser
struct TypeNameParser_tBEF78C9D6AEC3DE5E2993F6EDC24C06F7B713741 : public RuntimeObject
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // TYPENAMEPARSER_TBEF78C9D6AEC3DE5E2993F6EDC24C06F7B713741_H
#ifndef TYPENAMES_T59FBD5EB0A62A2B3A8178016670631D61DEE00F9_H
#define TYPENAMES_T59FBD5EB0A62A2B3A8178016670631D61DEE00F9_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.TypeNames
struct TypeNames_t59FBD5EB0A62A2B3A8178016670631D61DEE00F9 : public RuntimeObject
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // TYPENAMES_T59FBD5EB0A62A2B3A8178016670631D61DEE00F9_H
#ifndef ATYPENAME_T8FD4A465E3C2846D11FEAE25ED5BF3D67FF94421_H
#define ATYPENAME_T8FD4A465E3C2846D11FEAE25ED5BF3D67FF94421_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.TypeNames_ATypeName
struct ATypeName_t8FD4A465E3C2846D11FEAE25ED5BF3D67FF94421 : public RuntimeObject
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // ATYPENAME_T8FD4A465E3C2846D11FEAE25ED5BF3D67FF94421_H
#ifndef TYPESPEC_T943289F7C537252144A22588159B36C6B6759A7F_H
#define TYPESPEC_T943289F7C537252144A22588159B36C6B6759A7F_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.TypeSpec
struct TypeSpec_t943289F7C537252144A22588159B36C6B6759A7F : public RuntimeObject
{
public:
// System.TypeIdentifier System.TypeSpec::name
RuntimeObject* ___name_0;
// System.String System.TypeSpec::assembly_name
String_t* ___assembly_name_1;
// System.Collections.Generic.List`1<System.TypeIdentifier> System.TypeSpec::nested
List_1_tB8129EB4ADDDECD38E3E178F0A902C921B575166 * ___nested_2;
// System.Collections.Generic.List`1<System.TypeSpec> System.TypeSpec::generic_params
List_1_t8C8BF378AAB72B34B6EE63F686877AE7290ECFBA * ___generic_params_3;
// System.Collections.Generic.List`1<System.ModifierSpec> System.TypeSpec::modifier_spec
List_1_tFD995FD9C5961BB4B415EE63B297C4B19643A3C2 * ___modifier_spec_4;
// System.Boolean System.TypeSpec::is_byref
bool ___is_byref_5;
// System.String System.TypeSpec::display_fullname
String_t* ___display_fullname_6;
public:
inline static int32_t get_offset_of_name_0() { return static_cast<int32_t>(offsetof(TypeSpec_t943289F7C537252144A22588159B36C6B6759A7F, ___name_0)); }
inline RuntimeObject* get_name_0() const { return ___name_0; }
inline RuntimeObject** get_address_of_name_0() { return &___name_0; }
inline void set_name_0(RuntimeObject* value)
{
___name_0 = value;
Il2CppCodeGenWriteBarrier((&___name_0), value);
}
inline static int32_t get_offset_of_assembly_name_1() { return static_cast<int32_t>(offsetof(TypeSpec_t943289F7C537252144A22588159B36C6B6759A7F, ___assembly_name_1)); }
inline String_t* get_assembly_name_1() const { return ___assembly_name_1; }
inline String_t** get_address_of_assembly_name_1() { return &___assembly_name_1; }
inline void set_assembly_name_1(String_t* value)
{
___assembly_name_1 = value;
Il2CppCodeGenWriteBarrier((&___assembly_name_1), value);
}
inline static int32_t get_offset_of_nested_2() { return static_cast<int32_t>(offsetof(TypeSpec_t943289F7C537252144A22588159B36C6B6759A7F, ___nested_2)); }
inline List_1_tB8129EB4ADDDECD38E3E178F0A902C921B575166 * get_nested_2() const { return ___nested_2; }
inline List_1_tB8129EB4ADDDECD38E3E178F0A902C921B575166 ** get_address_of_nested_2() { return &___nested_2; }
inline void set_nested_2(List_1_tB8129EB4ADDDECD38E3E178F0A902C921B575166 * value)
{
___nested_2 = value;
Il2CppCodeGenWriteBarrier((&___nested_2), value);
}
inline static int32_t get_offset_of_generic_params_3() { return static_cast<int32_t>(offsetof(TypeSpec_t943289F7C537252144A22588159B36C6B6759A7F, ___generic_params_3)); }
inline List_1_t8C8BF378AAB72B34B6EE63F686877AE7290ECFBA * get_generic_params_3() const { return ___generic_params_3; }
inline List_1_t8C8BF378AAB72B34B6EE63F686877AE7290ECFBA ** get_address_of_generic_params_3() { return &___generic_params_3; }
inline void set_generic_params_3(List_1_t8C8BF378AAB72B34B6EE63F686877AE7290ECFBA * value)
{
___generic_params_3 = value;
Il2CppCodeGenWriteBarrier((&___generic_params_3), value);
}
inline static int32_t get_offset_of_modifier_spec_4() { return static_cast<int32_t>(offsetof(TypeSpec_t943289F7C537252144A22588159B36C6B6759A7F, ___modifier_spec_4)); }
inline List_1_tFD995FD9C5961BB4B415EE63B297C4B19643A3C2 * get_modifier_spec_4() const { return ___modifier_spec_4; }
inline List_1_tFD995FD9C5961BB4B415EE63B297C4B19643A3C2 ** get_address_of_modifier_spec_4() { return &___modifier_spec_4; }
inline void set_modifier_spec_4(List_1_tFD995FD9C5961BB4B415EE63B297C4B19643A3C2 * value)
{
___modifier_spec_4 = value;
Il2CppCodeGenWriteBarrier((&___modifier_spec_4), value);
}
inline static int32_t get_offset_of_is_byref_5() { return static_cast<int32_t>(offsetof(TypeSpec_t943289F7C537252144A22588159B36C6B6759A7F, ___is_byref_5)); }
inline bool get_is_byref_5() const { return ___is_byref_5; }
inline bool* get_address_of_is_byref_5() { return &___is_byref_5; }
inline void set_is_byref_5(bool value)
{
___is_byref_5 = value;
}
inline static int32_t get_offset_of_display_fullname_6() { return static_cast<int32_t>(offsetof(TypeSpec_t943289F7C537252144A22588159B36C6B6759A7F, ___display_fullname_6)); }
inline String_t* get_display_fullname_6() const { return ___display_fullname_6; }
inline String_t** get_address_of_display_fullname_6() { return &___display_fullname_6; }
inline void set_display_fullname_6(String_t* value)
{
___display_fullname_6 = value;
Il2CppCodeGenWriteBarrier((&___display_fullname_6), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // TYPESPEC_T943289F7C537252144A22588159B36C6B6759A7F_H
#ifndef UNITYSERIALIZATIONHOLDER_T6B17ABB985ACD3F8D9F9E3C146DEA5F730E1CEAC_H
#define UNITYSERIALIZATIONHOLDER_T6B17ABB985ACD3F8D9F9E3C146DEA5F730E1CEAC_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.UnitySerializationHolder
struct UnitySerializationHolder_t6B17ABB985ACD3F8D9F9E3C146DEA5F730E1CEAC : public RuntimeObject
{
public:
// System.Type[] System.UnitySerializationHolder::m_instantiation
TypeU5BU5D_t7FE623A666B49176DE123306221193E888A12F5F* ___m_instantiation_0;
// System.Int32[] System.UnitySerializationHolder::m_elementTypes
Int32U5BU5D_t2B9E4FDDDB9F0A00EC0AC631BA2DA915EB1ECF83* ___m_elementTypes_1;
// System.Int32 System.UnitySerializationHolder::m_genericParameterPosition
int32_t ___m_genericParameterPosition_2;
// System.Type System.UnitySerializationHolder::m_declaringType
Type_t * ___m_declaringType_3;
// System.Reflection.MethodBase System.UnitySerializationHolder::m_declaringMethod
MethodBase_t * ___m_declaringMethod_4;
// System.String System.UnitySerializationHolder::m_data
String_t* ___m_data_5;
// System.String System.UnitySerializationHolder::m_assemblyName
String_t* ___m_assemblyName_6;
// System.Int32 System.UnitySerializationHolder::m_unityType
int32_t ___m_unityType_7;
public:
inline static int32_t get_offset_of_m_instantiation_0() { return static_cast<int32_t>(offsetof(UnitySerializationHolder_t6B17ABB985ACD3F8D9F9E3C146DEA5F730E1CEAC, ___m_instantiation_0)); }
inline TypeU5BU5D_t7FE623A666B49176DE123306221193E888A12F5F* get_m_instantiation_0() const { return ___m_instantiation_0; }
inline TypeU5BU5D_t7FE623A666B49176DE123306221193E888A12F5F** get_address_of_m_instantiation_0() { return &___m_instantiation_0; }
inline void set_m_instantiation_0(TypeU5BU5D_t7FE623A666B49176DE123306221193E888A12F5F* value)
{
___m_instantiation_0 = value;
Il2CppCodeGenWriteBarrier((&___m_instantiation_0), value);
}
inline static int32_t get_offset_of_m_elementTypes_1() { return static_cast<int32_t>(offsetof(UnitySerializationHolder_t6B17ABB985ACD3F8D9F9E3C146DEA5F730E1CEAC, ___m_elementTypes_1)); }
inline Int32U5BU5D_t2B9E4FDDDB9F0A00EC0AC631BA2DA915EB1ECF83* get_m_elementTypes_1() const { return ___m_elementTypes_1; }
inline Int32U5BU5D_t2B9E4FDDDB9F0A00EC0AC631BA2DA915EB1ECF83** get_address_of_m_elementTypes_1() { return &___m_elementTypes_1; }
inline void set_m_elementTypes_1(Int32U5BU5D_t2B9E4FDDDB9F0A00EC0AC631BA2DA915EB1ECF83* value)
{
___m_elementTypes_1 = value;
Il2CppCodeGenWriteBarrier((&___m_elementTypes_1), value);
}
inline static int32_t get_offset_of_m_genericParameterPosition_2() { return static_cast<int32_t>(offsetof(UnitySerializationHolder_t6B17ABB985ACD3F8D9F9E3C146DEA5F730E1CEAC, ___m_genericParameterPosition_2)); }
inline int32_t get_m_genericParameterPosition_2() const { return ___m_genericParameterPosition_2; }
inline int32_t* get_address_of_m_genericParameterPosition_2() { return &___m_genericParameterPosition_2; }
inline void set_m_genericParameterPosition_2(int32_t value)
{
___m_genericParameterPosition_2 = value;
}
inline static int32_t get_offset_of_m_declaringType_3() { return static_cast<int32_t>(offsetof(UnitySerializationHolder_t6B17ABB985ACD3F8D9F9E3C146DEA5F730E1CEAC, ___m_declaringType_3)); }
inline Type_t * get_m_declaringType_3() const { return ___m_declaringType_3; }
inline Type_t ** get_address_of_m_declaringType_3() { return &___m_declaringType_3; }
inline void set_m_declaringType_3(Type_t * value)
{
___m_declaringType_3 = value;
Il2CppCodeGenWriteBarrier((&___m_declaringType_3), value);
}
inline static int32_t get_offset_of_m_declaringMethod_4() { return static_cast<int32_t>(offsetof(UnitySerializationHolder_t6B17ABB985ACD3F8D9F9E3C146DEA5F730E1CEAC, ___m_declaringMethod_4)); }
inline MethodBase_t * get_m_declaringMethod_4() const { return ___m_declaringMethod_4; }
inline MethodBase_t ** get_address_of_m_declaringMethod_4() { return &___m_declaringMethod_4; }
inline void set_m_declaringMethod_4(MethodBase_t * value)
{
___m_declaringMethod_4 = value;
Il2CppCodeGenWriteBarrier((&___m_declaringMethod_4), value);
}
inline static int32_t get_offset_of_m_data_5() { return static_cast<int32_t>(offsetof(UnitySerializationHolder_t6B17ABB985ACD3F8D9F9E3C146DEA5F730E1CEAC, ___m_data_5)); }
inline String_t* get_m_data_5() const { return ___m_data_5; }
inline String_t** get_address_of_m_data_5() { return &___m_data_5; }
inline void set_m_data_5(String_t* value)
{
___m_data_5 = value;
Il2CppCodeGenWriteBarrier((&___m_data_5), value);
}
inline static int32_t get_offset_of_m_assemblyName_6() { return static_cast<int32_t>(offsetof(UnitySerializationHolder_t6B17ABB985ACD3F8D9F9E3C146DEA5F730E1CEAC, ___m_assemblyName_6)); }
inline String_t* get_m_assemblyName_6() const { return ___m_assemblyName_6; }
inline String_t** get_address_of_m_assemblyName_6() { return &___m_assemblyName_6; }
inline void set_m_assemblyName_6(String_t* value)
{
___m_assemblyName_6 = value;
Il2CppCodeGenWriteBarrier((&___m_assemblyName_6), value);
}
inline static int32_t get_offset_of_m_unityType_7() { return static_cast<int32_t>(offsetof(UnitySerializationHolder_t6B17ABB985ACD3F8D9F9E3C146DEA5F730E1CEAC, ___m_unityType_7)); }
inline int32_t get_m_unityType_7() const { return ___m_unityType_7; }
inline int32_t* get_address_of_m_unityType_7() { return &___m_unityType_7; }
inline void set_m_unityType_7(int32_t value)
{
___m_unityType_7 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // UNITYSERIALIZATIONHOLDER_T6B17ABB985ACD3F8D9F9E3C146DEA5F730E1CEAC_H
#ifndef VALUETYPE_T4D0C27076F7C36E76190FB3328E232BCB1CD1FFF_H
#define VALUETYPE_T4D0C27076F7C36E76190FB3328E232BCB1CD1FFF_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.ValueType
struct ValueType_t4D0C27076F7C36E76190FB3328E232BCB1CD1FFF : public RuntimeObject
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
// Native definition for P/Invoke marshalling of System.ValueType
struct ValueType_t4D0C27076F7C36E76190FB3328E232BCB1CD1FFF_marshaled_pinvoke
{
};
// Native definition for COM marshalling of System.ValueType
struct ValueType_t4D0C27076F7C36E76190FB3328E232BCB1CD1FFF_marshaled_com
{
};
#endif // VALUETYPE_T4D0C27076F7C36E76190FB3328E232BCB1CD1FFF_H
#ifndef VERSION_TDBE6876C59B6F56D4F8CAA03851177ABC6FE0DFD_H
#define VERSION_TDBE6876C59B6F56D4F8CAA03851177ABC6FE0DFD_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Version
struct Version_tDBE6876C59B6F56D4F8CAA03851177ABC6FE0DFD : public RuntimeObject
{
public:
// System.Int32 System.Version::_Major
int32_t ____Major_0;
// System.Int32 System.Version::_Minor
int32_t ____Minor_1;
// System.Int32 System.Version::_Build
int32_t ____Build_2;
// System.Int32 System.Version::_Revision
int32_t ____Revision_3;
public:
inline static int32_t get_offset_of__Major_0() { return static_cast<int32_t>(offsetof(Version_tDBE6876C59B6F56D4F8CAA03851177ABC6FE0DFD, ____Major_0)); }
inline int32_t get__Major_0() const { return ____Major_0; }
inline int32_t* get_address_of__Major_0() { return &____Major_0; }
inline void set__Major_0(int32_t value)
{
____Major_0 = value;
}
inline static int32_t get_offset_of__Minor_1() { return static_cast<int32_t>(offsetof(Version_tDBE6876C59B6F56D4F8CAA03851177ABC6FE0DFD, ____Minor_1)); }
inline int32_t get__Minor_1() const { return ____Minor_1; }
inline int32_t* get_address_of__Minor_1() { return &____Minor_1; }
inline void set__Minor_1(int32_t value)
{
____Minor_1 = value;
}
inline static int32_t get_offset_of__Build_2() { return static_cast<int32_t>(offsetof(Version_tDBE6876C59B6F56D4F8CAA03851177ABC6FE0DFD, ____Build_2)); }
inline int32_t get__Build_2() const { return ____Build_2; }
inline int32_t* get_address_of__Build_2() { return &____Build_2; }
inline void set__Build_2(int32_t value)
{
____Build_2 = value;
}
inline static int32_t get_offset_of__Revision_3() { return static_cast<int32_t>(offsetof(Version_tDBE6876C59B6F56D4F8CAA03851177ABC6FE0DFD, ____Revision_3)); }
inline int32_t get__Revision_3() const { return ____Revision_3; }
inline int32_t* get_address_of__Revision_3() { return &____Revision_3; }
inline void set__Revision_3(int32_t value)
{
____Revision_3 = value;
}
};
struct Version_tDBE6876C59B6F56D4F8CAA03851177ABC6FE0DFD_StaticFields
{
public:
// System.Char[] System.Version::SeparatorsArray
CharU5BU5D_t4CC6ABF0AD71BEC97E3C2F1E9C5677E46D3A75C2* ___SeparatorsArray_4;
public:
inline static int32_t get_offset_of_SeparatorsArray_4() { return static_cast<int32_t>(offsetof(Version_tDBE6876C59B6F56D4F8CAA03851177ABC6FE0DFD_StaticFields, ___SeparatorsArray_4)); }
inline CharU5BU5D_t4CC6ABF0AD71BEC97E3C2F1E9C5677E46D3A75C2* get_SeparatorsArray_4() const { return ___SeparatorsArray_4; }
inline CharU5BU5D_t4CC6ABF0AD71BEC97E3C2F1E9C5677E46D3A75C2** get_address_of_SeparatorsArray_4() { return &___SeparatorsArray_4; }
inline void set_SeparatorsArray_4(CharU5BU5D_t4CC6ABF0AD71BEC97E3C2F1E9C5677E46D3A75C2* value)
{
___SeparatorsArray_4 = value;
Il2CppCodeGenWriteBarrier((&___SeparatorsArray_4), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // VERSION_TDBE6876C59B6F56D4F8CAA03851177ABC6FE0DFD_H
#ifndef __COMOBJECT_T7C4C78B18A827C344A9826ECC7FCC40B7F6FD77C_H
#define __COMOBJECT_T7C4C78B18A827C344A9826ECC7FCC40B7F6FD77C_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.__ComObject
struct __ComObject_t7C4C78B18A827C344A9826ECC7FCC40B7F6FD77C : public RuntimeObject
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // __COMOBJECT_T7C4C78B18A827C344A9826ECC7FCC40B7F6FD77C_H
#ifndef ASSEMBLYLOADEVENTARGS_T51DAAB04039C3B2D8C3FBF65C13441BC6C6A7AE8_H
#define ASSEMBLYLOADEVENTARGS_T51DAAB04039C3B2D8C3FBF65C13441BC6C6A7AE8_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.AssemblyLoadEventArgs
struct AssemblyLoadEventArgs_t51DAAB04039C3B2D8C3FBF65C13441BC6C6A7AE8 : public EventArgs_t8E6CA180BE0E56674C6407011A94BAF7C757352E
{
public:
// System.Reflection.Assembly System.AssemblyLoadEventArgs::m_loadedAssembly
Assembly_t * ___m_loadedAssembly_1;
public:
inline static int32_t get_offset_of_m_loadedAssembly_1() { return static_cast<int32_t>(offsetof(AssemblyLoadEventArgs_t51DAAB04039C3B2D8C3FBF65C13441BC6C6A7AE8, ___m_loadedAssembly_1)); }
inline Assembly_t * get_m_loadedAssembly_1() const { return ___m_loadedAssembly_1; }
inline Assembly_t ** get_address_of_m_loadedAssembly_1() { return &___m_loadedAssembly_1; }
inline void set_m_loadedAssembly_1(Assembly_t * value)
{
___m_loadedAssembly_1 = value;
Il2CppCodeGenWriteBarrier((&___m_loadedAssembly_1), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // ASSEMBLYLOADEVENTARGS_T51DAAB04039C3B2D8C3FBF65C13441BC6C6A7AE8_H
#ifndef COORD_T6CEFF682745DD47B1B4DA3ED268C0933021AC34A_H
#define COORD_T6CEFF682745DD47B1B4DA3ED268C0933021AC34A_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Coord
struct Coord_t6CEFF682745DD47B1B4DA3ED268C0933021AC34A
{
public:
// System.Int16 System.Coord::X
int16_t ___X_0;
// System.Int16 System.Coord::Y
int16_t ___Y_1;
public:
inline static int32_t get_offset_of_X_0() { return static_cast<int32_t>(offsetof(Coord_t6CEFF682745DD47B1B4DA3ED268C0933021AC34A, ___X_0)); }
inline int16_t get_X_0() const { return ___X_0; }
inline int16_t* get_address_of_X_0() { return &___X_0; }
inline void set_X_0(int16_t value)
{
___X_0 = value;
}
inline static int32_t get_offset_of_Y_1() { return static_cast<int32_t>(offsetof(Coord_t6CEFF682745DD47B1B4DA3ED268C0933021AC34A, ___Y_1)); }
inline int16_t get_Y_1() const { return ___Y_1; }
inline int16_t* get_address_of_Y_1() { return &___Y_1; }
inline void set_Y_1(int16_t value)
{
___Y_1 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // COORD_T6CEFF682745DD47B1B4DA3ED268C0933021AC34A_H
#ifndef CURRENTSYSTEMTIMEZONE_T7689B8BF1C4A474BD3CFA5B8E89FA84A53D44171_H
#define CURRENTSYSTEMTIMEZONE_T7689B8BF1C4A474BD3CFA5B8E89FA84A53D44171_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.CurrentSystemTimeZone
struct CurrentSystemTimeZone_t7689B8BF1C4A474BD3CFA5B8E89FA84A53D44171 : public TimeZone_tA2DF435DA1A379978B885F0872A93774666B7454
{
public:
// System.TimeZoneInfo System.CurrentSystemTimeZone::LocalTimeZone
TimeZoneInfo_t46EF9BAEAA787846F1A1EC419BE75CFEFAFF6777 * ___LocalTimeZone_1;
public:
inline static int32_t get_offset_of_LocalTimeZone_1() { return static_cast<int32_t>(offsetof(CurrentSystemTimeZone_t7689B8BF1C4A474BD3CFA5B8E89FA84A53D44171, ___LocalTimeZone_1)); }
inline TimeZoneInfo_t46EF9BAEAA787846F1A1EC419BE75CFEFAFF6777 * get_LocalTimeZone_1() const { return ___LocalTimeZone_1; }
inline TimeZoneInfo_t46EF9BAEAA787846F1A1EC419BE75CFEFAFF6777 ** get_address_of_LocalTimeZone_1() { return &___LocalTimeZone_1; }
inline void set_LocalTimeZone_1(TimeZoneInfo_t46EF9BAEAA787846F1A1EC419BE75CFEFAFF6777 * value)
{
___LocalTimeZone_1 = value;
Il2CppCodeGenWriteBarrier((&___LocalTimeZone_1), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // CURRENTSYSTEMTIMEZONE_T7689B8BF1C4A474BD3CFA5B8E89FA84A53D44171_H
#ifndef ENUM_T2AF27C02B8653AE29442467390005ABC74D8F521_H
#define ENUM_T2AF27C02B8653AE29442467390005ABC74D8F521_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Enum
struct Enum_t2AF27C02B8653AE29442467390005ABC74D8F521 : public ValueType_t4D0C27076F7C36E76190FB3328E232BCB1CD1FFF
{
public:
public:
};
struct Enum_t2AF27C02B8653AE29442467390005ABC74D8F521_StaticFields
{
public:
// System.Char[] System.Enum::enumSeperatorCharArray
CharU5BU5D_t4CC6ABF0AD71BEC97E3C2F1E9C5677E46D3A75C2* ___enumSeperatorCharArray_0;
public:
inline static int32_t get_offset_of_enumSeperatorCharArray_0() { return static_cast<int32_t>(offsetof(Enum_t2AF27C02B8653AE29442467390005ABC74D8F521_StaticFields, ___enumSeperatorCharArray_0)); }
inline CharU5BU5D_t4CC6ABF0AD71BEC97E3C2F1E9C5677E46D3A75C2* get_enumSeperatorCharArray_0() const { return ___enumSeperatorCharArray_0; }
inline CharU5BU5D_t4CC6ABF0AD71BEC97E3C2F1E9C5677E46D3A75C2** get_address_of_enumSeperatorCharArray_0() { return &___enumSeperatorCharArray_0; }
inline void set_enumSeperatorCharArray_0(CharU5BU5D_t4CC6ABF0AD71BEC97E3C2F1E9C5677E46D3A75C2* value)
{
___enumSeperatorCharArray_0 = value;
Il2CppCodeGenWriteBarrier((&___enumSeperatorCharArray_0), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
// Native definition for P/Invoke marshalling of System.Enum
struct Enum_t2AF27C02B8653AE29442467390005ABC74D8F521_marshaled_pinvoke
{
};
// Native definition for COM marshalling of System.Enum
struct Enum_t2AF27C02B8653AE29442467390005ABC74D8F521_marshaled_com
{
};
#endif // ENUM_T2AF27C02B8653AE29442467390005ABC74D8F521_H
#ifndef INPUTRECORD_TAB007C739F339BE208F3C4796B53E9044ADF0A78_H
#define INPUTRECORD_TAB007C739F339BE208F3C4796B53E9044ADF0A78_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.InputRecord
struct InputRecord_tAB007C739F339BE208F3C4796B53E9044ADF0A78
{
public:
// System.Int16 System.InputRecord::EventType
int16_t ___EventType_0;
// System.Boolean System.InputRecord::KeyDown
bool ___KeyDown_1;
// System.Int16 System.InputRecord::RepeatCount
int16_t ___RepeatCount_2;
// System.Int16 System.InputRecord::VirtualKeyCode
int16_t ___VirtualKeyCode_3;
// System.Int16 System.InputRecord::VirtualScanCode
int16_t ___VirtualScanCode_4;
// System.Char System.InputRecord::Character
Il2CppChar ___Character_5;
// System.Int32 System.InputRecord::ControlKeyState
int32_t ___ControlKeyState_6;
// System.Int32 System.InputRecord::pad1
int32_t ___pad1_7;
// System.Boolean System.InputRecord::pad2
bool ___pad2_8;
public:
inline static int32_t get_offset_of_EventType_0() { return static_cast<int32_t>(offsetof(InputRecord_tAB007C739F339BE208F3C4796B53E9044ADF0A78, ___EventType_0)); }
inline int16_t get_EventType_0() const { return ___EventType_0; }
inline int16_t* get_address_of_EventType_0() { return &___EventType_0; }
inline void set_EventType_0(int16_t value)
{
___EventType_0 = value;
}
inline static int32_t get_offset_of_KeyDown_1() { return static_cast<int32_t>(offsetof(InputRecord_tAB007C739F339BE208F3C4796B53E9044ADF0A78, ___KeyDown_1)); }
inline bool get_KeyDown_1() const { return ___KeyDown_1; }
inline bool* get_address_of_KeyDown_1() { return &___KeyDown_1; }
inline void set_KeyDown_1(bool value)
{
___KeyDown_1 = value;
}
inline static int32_t get_offset_of_RepeatCount_2() { return static_cast<int32_t>(offsetof(InputRecord_tAB007C739F339BE208F3C4796B53E9044ADF0A78, ___RepeatCount_2)); }
inline int16_t get_RepeatCount_2() const { return ___RepeatCount_2; }
inline int16_t* get_address_of_RepeatCount_2() { return &___RepeatCount_2; }
inline void set_RepeatCount_2(int16_t value)
{
___RepeatCount_2 = value;
}
inline static int32_t get_offset_of_VirtualKeyCode_3() { return static_cast<int32_t>(offsetof(InputRecord_tAB007C739F339BE208F3C4796B53E9044ADF0A78, ___VirtualKeyCode_3)); }
inline int16_t get_VirtualKeyCode_3() const { return ___VirtualKeyCode_3; }
inline int16_t* get_address_of_VirtualKeyCode_3() { return &___VirtualKeyCode_3; }
inline void set_VirtualKeyCode_3(int16_t value)
{
___VirtualKeyCode_3 = value;
}
inline static int32_t get_offset_of_VirtualScanCode_4() { return static_cast<int32_t>(offsetof(InputRecord_tAB007C739F339BE208F3C4796B53E9044ADF0A78, ___VirtualScanCode_4)); }
inline int16_t get_VirtualScanCode_4() const { return ___VirtualScanCode_4; }
inline int16_t* get_address_of_VirtualScanCode_4() { return &___VirtualScanCode_4; }
inline void set_VirtualScanCode_4(int16_t value)
{
___VirtualScanCode_4 = value;
}
inline static int32_t get_offset_of_Character_5() { return static_cast<int32_t>(offsetof(InputRecord_tAB007C739F339BE208F3C4796B53E9044ADF0A78, ___Character_5)); }
inline Il2CppChar get_Character_5() const { return ___Character_5; }
inline Il2CppChar* get_address_of_Character_5() { return &___Character_5; }
inline void set_Character_5(Il2CppChar value)
{
___Character_5 = value;
}
inline static int32_t get_offset_of_ControlKeyState_6() { return static_cast<int32_t>(offsetof(InputRecord_tAB007C739F339BE208F3C4796B53E9044ADF0A78, ___ControlKeyState_6)); }
inline int32_t get_ControlKeyState_6() const { return ___ControlKeyState_6; }
inline int32_t* get_address_of_ControlKeyState_6() { return &___ControlKeyState_6; }
inline void set_ControlKeyState_6(int32_t value)
{
___ControlKeyState_6 = value;
}
inline static int32_t get_offset_of_pad1_7() { return static_cast<int32_t>(offsetof(InputRecord_tAB007C739F339BE208F3C4796B53E9044ADF0A78, ___pad1_7)); }
inline int32_t get_pad1_7() const { return ___pad1_7; }
inline int32_t* get_address_of_pad1_7() { return &___pad1_7; }
inline void set_pad1_7(int32_t value)
{
___pad1_7 = value;
}
inline static int32_t get_offset_of_pad2_8() { return static_cast<int32_t>(offsetof(InputRecord_tAB007C739F339BE208F3C4796B53E9044ADF0A78, ___pad2_8)); }
inline bool get_pad2_8() const { return ___pad2_8; }
inline bool* get_address_of_pad2_8() { return &___pad2_8; }
inline void set_pad2_8(bool value)
{
___pad2_8 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
// Native definition for P/Invoke marshalling of System.InputRecord
struct InputRecord_tAB007C739F339BE208F3C4796B53E9044ADF0A78_marshaled_pinvoke
{
int16_t ___EventType_0;
int32_t ___KeyDown_1;
int16_t ___RepeatCount_2;
int16_t ___VirtualKeyCode_3;
int16_t ___VirtualScanCode_4;
uint8_t ___Character_5;
int32_t ___ControlKeyState_6;
int32_t ___pad1_7;
int32_t ___pad2_8;
};
// Native definition for COM marshalling of System.InputRecord
struct InputRecord_tAB007C739F339BE208F3C4796B53E9044ADF0A78_marshaled_com
{
int16_t ___EventType_0;
int32_t ___KeyDown_1;
int16_t ___RepeatCount_2;
int16_t ___VirtualKeyCode_3;
int16_t ___VirtualScanCode_4;
uint8_t ___Character_5;
int32_t ___ControlKeyState_6;
int32_t ___pad1_7;
int32_t ___pad2_8;
};
#endif // INPUTRECORD_TAB007C739F339BE208F3C4796B53E9044ADF0A78_H
#ifndef INT32_T585191389E07734F19F3156FF88FB3EF4800D102_H
#define INT32_T585191389E07734F19F3156FF88FB3EF4800D102_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Int32
struct Int32_t585191389E07734F19F3156FF88FB3EF4800D102
{
public:
// System.Int32 System.Int32::m_value
int32_t ___m_value_0;
public:
inline static int32_t get_offset_of_m_value_0() { return static_cast<int32_t>(offsetof(Int32_t585191389E07734F19F3156FF88FB3EF4800D102, ___m_value_0)); }
inline int32_t get_m_value_0() const { return ___m_value_0; }
inline int32_t* get_address_of_m_value_0() { return &___m_value_0; }
inline void set_m_value_0(int32_t value)
{
___m_value_0 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // INT32_T585191389E07734F19F3156FF88FB3EF4800D102_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 FORMATPARAM_T1901DD0E7CD1B3A17B09040A6E2FCA5307328800_H
#define FORMATPARAM_T1901DD0E7CD1B3A17B09040A6E2FCA5307328800_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.ParameterizedStrings_FormatParam
struct FormatParam_t1901DD0E7CD1B3A17B09040A6E2FCA5307328800
{
public:
// System.Int32 System.ParameterizedStrings_FormatParam::_int32
int32_t ____int32_0;
// System.String System.ParameterizedStrings_FormatParam::_string
String_t* ____string_1;
public:
inline static int32_t get_offset_of__int32_0() { return static_cast<int32_t>(offsetof(FormatParam_t1901DD0E7CD1B3A17B09040A6E2FCA5307328800, ____int32_0)); }
inline int32_t get__int32_0() const { return ____int32_0; }
inline int32_t* get_address_of__int32_0() { return &____int32_0; }
inline void set__int32_0(int32_t value)
{
____int32_0 = value;
}
inline static int32_t get_offset_of__string_1() { return static_cast<int32_t>(offsetof(FormatParam_t1901DD0E7CD1B3A17B09040A6E2FCA5307328800, ____string_1)); }
inline String_t* get__string_1() const { return ____string_1; }
inline String_t** get_address_of__string_1() { return &____string_1; }
inline void set__string_1(String_t* value)
{
____string_1 = value;
Il2CppCodeGenWriteBarrier((&____string_1), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
// Native definition for P/Invoke marshalling of System.ParameterizedStrings/FormatParam
struct FormatParam_t1901DD0E7CD1B3A17B09040A6E2FCA5307328800_marshaled_pinvoke
{
int32_t ____int32_0;
char* ____string_1;
};
// Native definition for COM marshalling of System.ParameterizedStrings/FormatParam
struct FormatParam_t1901DD0E7CD1B3A17B09040A6E2FCA5307328800_marshaled_com
{
int32_t ____int32_0;
Il2CppChar* ____string_1;
};
#endif // FORMATPARAM_T1901DD0E7CD1B3A17B09040A6E2FCA5307328800_H
#ifndef RESOLVEEVENTARGS_T116CF9DB06BCFEB8933CEAD4A35389A7CA9EB75D_H
#define RESOLVEEVENTARGS_T116CF9DB06BCFEB8933CEAD4A35389A7CA9EB75D_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.ResolveEventArgs
struct ResolveEventArgs_t116CF9DB06BCFEB8933CEAD4A35389A7CA9EB75D : public EventArgs_t8E6CA180BE0E56674C6407011A94BAF7C757352E
{
public:
// System.String System.ResolveEventArgs::m_Name
String_t* ___m_Name_1;
// System.Reflection.Assembly System.ResolveEventArgs::m_Requesting
Assembly_t * ___m_Requesting_2;
public:
inline static int32_t get_offset_of_m_Name_1() { return static_cast<int32_t>(offsetof(ResolveEventArgs_t116CF9DB06BCFEB8933CEAD4A35389A7CA9EB75D, ___m_Name_1)); }
inline String_t* get_m_Name_1() const { return ___m_Name_1; }
inline String_t** get_address_of_m_Name_1() { return &___m_Name_1; }
inline void set_m_Name_1(String_t* value)
{
___m_Name_1 = value;
Il2CppCodeGenWriteBarrier((&___m_Name_1), value);
}
inline static int32_t get_offset_of_m_Requesting_2() { return static_cast<int32_t>(offsetof(ResolveEventArgs_t116CF9DB06BCFEB8933CEAD4A35389A7CA9EB75D, ___m_Requesting_2)); }
inline Assembly_t * get_m_Requesting_2() const { return ___m_Requesting_2; }
inline Assembly_t ** get_address_of_m_Requesting_2() { return &___m_Requesting_2; }
inline void set_m_Requesting_2(Assembly_t * value)
{
___m_Requesting_2 = value;
Il2CppCodeGenWriteBarrier((&___m_Requesting_2), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // RESOLVEEVENTARGS_T116CF9DB06BCFEB8933CEAD4A35389A7CA9EB75D_H
#ifndef GCHANDLE_T39FAEE3EA592432C93B574A31DD83B87F1847DE3_H
#define GCHANDLE_T39FAEE3EA592432C93B574A31DD83B87F1847DE3_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Runtime.InteropServices.GCHandle
struct GCHandle_t39FAEE3EA592432C93B574A31DD83B87F1847DE3
{
public:
// System.Int32 System.Runtime.InteropServices.GCHandle::handle
int32_t ___handle_0;
public:
inline static int32_t get_offset_of_handle_0() { return static_cast<int32_t>(offsetof(GCHandle_t39FAEE3EA592432C93B574A31DD83B87F1847DE3, ___handle_0)); }
inline int32_t get_handle_0() const { return ___handle_0; }
inline int32_t* get_address_of_handle_0() { return &___handle_0; }
inline void set_handle_0(int32_t value)
{
___handle_0 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // GCHANDLE_T39FAEE3EA592432C93B574A31DD83B87F1847DE3_H
#ifndef SMALLRECT_T18C271B0FF660F6ED4EC6D99B26C4D35F51CA532_H
#define SMALLRECT_T18C271B0FF660F6ED4EC6D99B26C4D35F51CA532_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.SmallRect
struct SmallRect_t18C271B0FF660F6ED4EC6D99B26C4D35F51CA532
{
public:
// System.Int16 System.SmallRect::Left
int16_t ___Left_0;
// System.Int16 System.SmallRect::Top
int16_t ___Top_1;
// System.Int16 System.SmallRect::Right
int16_t ___Right_2;
// System.Int16 System.SmallRect::Bottom
int16_t ___Bottom_3;
public:
inline static int32_t get_offset_of_Left_0() { return static_cast<int32_t>(offsetof(SmallRect_t18C271B0FF660F6ED4EC6D99B26C4D35F51CA532, ___Left_0)); }
inline int16_t get_Left_0() const { return ___Left_0; }
inline int16_t* get_address_of_Left_0() { return &___Left_0; }
inline void set_Left_0(int16_t value)
{
___Left_0 = value;
}
inline static int32_t get_offset_of_Top_1() { return static_cast<int32_t>(offsetof(SmallRect_t18C271B0FF660F6ED4EC6D99B26C4D35F51CA532, ___Top_1)); }
inline int16_t get_Top_1() const { return ___Top_1; }
inline int16_t* get_address_of_Top_1() { return &___Top_1; }
inline void set_Top_1(int16_t value)
{
___Top_1 = value;
}
inline static int32_t get_offset_of_Right_2() { return static_cast<int32_t>(offsetof(SmallRect_t18C271B0FF660F6ED4EC6D99B26C4D35F51CA532, ___Right_2)); }
inline int16_t get_Right_2() const { return ___Right_2; }
inline int16_t* get_address_of_Right_2() { return &___Right_2; }
inline void set_Right_2(int16_t value)
{
___Right_2 = value;
}
inline static int32_t get_offset_of_Bottom_3() { return static_cast<int32_t>(offsetof(SmallRect_t18C271B0FF660F6ED4EC6D99B26C4D35F51CA532, ___Bottom_3)); }
inline int16_t get_Bottom_3() const { return ___Bottom_3; }
inline int16_t* get_address_of_Bottom_3() { return &___Bottom_3; }
inline void set_Bottom_3(int16_t value)
{
___Bottom_3 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // SMALLRECT_T18C271B0FF660F6ED4EC6D99B26C4D35F51CA532_H
#ifndef DISPLAY_T0222D7CB4CF0F85131FC5E26328FE94E0A27F5E5_H
#define DISPLAY_T0222D7CB4CF0F85131FC5E26328FE94E0A27F5E5_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.TypeIdentifiers_Display
struct Display_t0222D7CB4CF0F85131FC5E26328FE94E0A27F5E5 : public ATypeName_t8FD4A465E3C2846D11FEAE25ED5BF3D67FF94421
{
public:
// System.String System.TypeIdentifiers_Display::displayName
String_t* ___displayName_0;
// System.String System.TypeIdentifiers_Display::internal_name
String_t* ___internal_name_1;
public:
inline static int32_t get_offset_of_displayName_0() { return static_cast<int32_t>(offsetof(Display_t0222D7CB4CF0F85131FC5E26328FE94E0A27F5E5, ___displayName_0)); }
inline String_t* get_displayName_0() const { return ___displayName_0; }
inline String_t** get_address_of_displayName_0() { return &___displayName_0; }
inline void set_displayName_0(String_t* value)
{
___displayName_0 = value;
Il2CppCodeGenWriteBarrier((&___displayName_0), value);
}
inline static int32_t get_offset_of_internal_name_1() { return static_cast<int32_t>(offsetof(Display_t0222D7CB4CF0F85131FC5E26328FE94E0A27F5E5, ___internal_name_1)); }
inline String_t* get_internal_name_1() const { return ___internal_name_1; }
inline String_t** get_address_of_internal_name_1() { return &___internal_name_1; }
inline void set_internal_name_1(String_t* value)
{
___internal_name_1 = value;
Il2CppCodeGenWriteBarrier((&___internal_name_1), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // DISPLAY_T0222D7CB4CF0F85131FC5E26328FE94E0A27F5E5_H
#ifndef UINTPTR_T_H
#define UINTPTR_T_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.UIntPtr
struct UIntPtr_t
{
public:
// System.Void* System.UIntPtr::_pointer
void* ____pointer_1;
public:
inline static int32_t get_offset_of__pointer_1() { return static_cast<int32_t>(offsetof(UIntPtr_t, ____pointer_1)); }
inline void* get__pointer_1() const { return ____pointer_1; }
inline void** get_address_of__pointer_1() { return &____pointer_1; }
inline void set__pointer_1(void* value)
{
____pointer_1 = value;
}
};
struct UIntPtr_t_StaticFields
{
public:
// System.UIntPtr System.UIntPtr::Zero
uintptr_t ___Zero_0;
public:
inline static int32_t get_offset_of_Zero_0() { return static_cast<int32_t>(offsetof(UIntPtr_t_StaticFields, ___Zero_0)); }
inline uintptr_t get_Zero_0() const { return ___Zero_0; }
inline uintptr_t* get_address_of_Zero_0() { return &___Zero_0; }
inline void set_Zero_0(uintptr_t value)
{
___Zero_0 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // UINTPTR_T_H
#ifndef UNSAFECHARBUFFER_T99F0962CE65E71C4BA612D5434276C51AC33AF0C_H
#define UNSAFECHARBUFFER_T99F0962CE65E71C4BA612D5434276C51AC33AF0C_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.UnSafeCharBuffer
struct UnSafeCharBuffer_t99F0962CE65E71C4BA612D5434276C51AC33AF0C
{
public:
// System.Char* System.UnSafeCharBuffer::m_buffer
Il2CppChar* ___m_buffer_0;
// System.Int32 System.UnSafeCharBuffer::m_totalSize
int32_t ___m_totalSize_1;
// System.Int32 System.UnSafeCharBuffer::m_length
int32_t ___m_length_2;
public:
inline static int32_t get_offset_of_m_buffer_0() { return static_cast<int32_t>(offsetof(UnSafeCharBuffer_t99F0962CE65E71C4BA612D5434276C51AC33AF0C, ___m_buffer_0)); }
inline Il2CppChar* get_m_buffer_0() const { return ___m_buffer_0; }
inline Il2CppChar** get_address_of_m_buffer_0() { return &___m_buffer_0; }
inline void set_m_buffer_0(Il2CppChar* value)
{
___m_buffer_0 = value;
}
inline static int32_t get_offset_of_m_totalSize_1() { return static_cast<int32_t>(offsetof(UnSafeCharBuffer_t99F0962CE65E71C4BA612D5434276C51AC33AF0C, ___m_totalSize_1)); }
inline int32_t get_m_totalSize_1() const { return ___m_totalSize_1; }
inline int32_t* get_address_of_m_totalSize_1() { return &___m_totalSize_1; }
inline void set_m_totalSize_1(int32_t value)
{
___m_totalSize_1 = value;
}
inline static int32_t get_offset_of_m_length_2() { return static_cast<int32_t>(offsetof(UnSafeCharBuffer_t99F0962CE65E71C4BA612D5434276C51AC33AF0C, ___m_length_2)); }
inline int32_t get_m_length_2() const { return ___m_length_2; }
inline int32_t* get_address_of_m_length_2() { return &___m_length_2; }
inline void set_m_length_2(int32_t value)
{
___m_length_2 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
// Native definition for P/Invoke marshalling of System.UnSafeCharBuffer
struct UnSafeCharBuffer_t99F0962CE65E71C4BA612D5434276C51AC33AF0C_marshaled_pinvoke
{
Il2CppChar* ___m_buffer_0;
int32_t ___m_totalSize_1;
int32_t ___m_length_2;
};
// Native definition for COM marshalling of System.UnSafeCharBuffer
struct UnSafeCharBuffer_t99F0962CE65E71C4BA612D5434276C51AC33AF0C_marshaled_com
{
Il2CppChar* ___m_buffer_0;
int32_t ___m_totalSize_1;
int32_t ___m_length_2;
};
#endif // UNSAFECHARBUFFER_T99F0962CE65E71C4BA612D5434276C51AC33AF0C_H
#ifndef UNHANDLEDEXCEPTIONEVENTARGS_T39DD47D43B0D764FE2C9847FBE760031FBEA0FD1_H
#define UNHANDLEDEXCEPTIONEVENTARGS_T39DD47D43B0D764FE2C9847FBE760031FBEA0FD1_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.UnhandledExceptionEventArgs
struct UnhandledExceptionEventArgs_t39DD47D43B0D764FE2C9847FBE760031FBEA0FD1 : public EventArgs_t8E6CA180BE0E56674C6407011A94BAF7C757352E
{
public:
// System.Object System.UnhandledExceptionEventArgs::_Exception
RuntimeObject * ____Exception_1;
// System.Boolean System.UnhandledExceptionEventArgs::_IsTerminating
bool ____IsTerminating_2;
public:
inline static int32_t get_offset_of__Exception_1() { return static_cast<int32_t>(offsetof(UnhandledExceptionEventArgs_t39DD47D43B0D764FE2C9847FBE760031FBEA0FD1, ____Exception_1)); }
inline RuntimeObject * get__Exception_1() const { return ____Exception_1; }
inline RuntimeObject ** get_address_of__Exception_1() { return &____Exception_1; }
inline void set__Exception_1(RuntimeObject * value)
{
____Exception_1 = value;
Il2CppCodeGenWriteBarrier((&____Exception_1), value);
}
inline static int32_t get_offset_of__IsTerminating_2() { return static_cast<int32_t>(offsetof(UnhandledExceptionEventArgs_t39DD47D43B0D764FE2C9847FBE760031FBEA0FD1, ____IsTerminating_2)); }
inline bool get__IsTerminating_2() const { return ____IsTerminating_2; }
inline bool* get_address_of__IsTerminating_2() { return &____IsTerminating_2; }
inline void set__IsTerminating_2(bool value)
{
____IsTerminating_2 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // UNHANDLEDEXCEPTIONEVENTARGS_T39DD47D43B0D764FE2C9847FBE760031FBEA0FD1_H
#ifndef VOID_T22962CB4C05B1D89B55A6E1139F0E87A90987017_H
#define VOID_T22962CB4C05B1D89B55A6E1139F0E87A90987017_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void
struct Void_t22962CB4C05B1D89B55A6E1139F0E87A90987017
{
public:
union
{
struct
{
};
uint8_t Void_t22962CB4C05B1D89B55A6E1139F0E87A90987017__padding[1];
};
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // VOID_T22962CB4C05B1D89B55A6E1139F0E87A90987017_H
#ifndef APPDOMAIN_T1B59572328F60585904DF52A59FE47CF5B5FFFF8_H
#define APPDOMAIN_T1B59572328F60585904DF52A59FE47CF5B5FFFF8_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.AppDomain
struct AppDomain_t1B59572328F60585904DF52A59FE47CF5B5FFFF8 : public MarshalByRefObject_tC4577953D0A44D0AB8597CFA868E01C858B1C9AF
{
public:
// System.IntPtr System.AppDomain::_mono_app_domain
intptr_t ____mono_app_domain_1;
// System.Object System.AppDomain::_evidence
RuntimeObject * ____evidence_6;
// System.Object System.AppDomain::_granted
RuntimeObject * ____granted_7;
// System.Int32 System.AppDomain::_principalPolicy
int32_t ____principalPolicy_8;
// System.AssemblyLoadEventHandler System.AppDomain::AssemblyLoad
AssemblyLoadEventHandler_t53F8340027F9EE67E8A22E7D8C1A3770345153C9 * ___AssemblyLoad_11;
// System.ResolveEventHandler System.AppDomain::AssemblyResolve
ResolveEventHandler_t045C469BEA8B632FA99FE8867C921BA8DAE0BEE5 * ___AssemblyResolve_12;
// System.EventHandler System.AppDomain::DomainUnload
EventHandler_t2B84E745E28BA26C49C4E99A387FC3B534D1110C * ___DomainUnload_13;
// System.EventHandler System.AppDomain::ProcessExit
EventHandler_t2B84E745E28BA26C49C4E99A387FC3B534D1110C * ___ProcessExit_14;
// System.ResolveEventHandler System.AppDomain::ResourceResolve
ResolveEventHandler_t045C469BEA8B632FA99FE8867C921BA8DAE0BEE5 * ___ResourceResolve_15;
// System.ResolveEventHandler System.AppDomain::TypeResolve
ResolveEventHandler_t045C469BEA8B632FA99FE8867C921BA8DAE0BEE5 * ___TypeResolve_16;
// System.UnhandledExceptionEventHandler System.AppDomain::UnhandledException
UnhandledExceptionEventHandler_tB0DFF05ABF7A3A234C87D4F7A71F98E9AB2D91DE * ___UnhandledException_17;
// System.EventHandler`1<System.Runtime.ExceptionServices.FirstChanceExceptionEventArgs> System.AppDomain::FirstChanceException
EventHandler_1_t1E35ED2E29145994C6C03E57601C6D48C61083FF * ___FirstChanceException_18;
// System.Object System.AppDomain::_domain_manager
RuntimeObject * ____domain_manager_19;
// System.ResolveEventHandler System.AppDomain::ReflectionOnlyAssemblyResolve
ResolveEventHandler_t045C469BEA8B632FA99FE8867C921BA8DAE0BEE5 * ___ReflectionOnlyAssemblyResolve_20;
// System.Object System.AppDomain::_activation
RuntimeObject * ____activation_21;
// System.Object System.AppDomain::_applicationIdentity
RuntimeObject * ____applicationIdentity_22;
// System.Collections.Generic.List`1<System.String> System.AppDomain::compatibility_switch
List_1_tE8032E48C661C350FF9550E9063D595C0AB25CD3 * ___compatibility_switch_23;
public:
inline static int32_t get_offset_of__mono_app_domain_1() { return static_cast<int32_t>(offsetof(AppDomain_t1B59572328F60585904DF52A59FE47CF5B5FFFF8, ____mono_app_domain_1)); }
inline intptr_t get__mono_app_domain_1() const { return ____mono_app_domain_1; }
inline intptr_t* get_address_of__mono_app_domain_1() { return &____mono_app_domain_1; }
inline void set__mono_app_domain_1(intptr_t value)
{
____mono_app_domain_1 = value;
}
inline static int32_t get_offset_of__evidence_6() { return static_cast<int32_t>(offsetof(AppDomain_t1B59572328F60585904DF52A59FE47CF5B5FFFF8, ____evidence_6)); }
inline RuntimeObject * get__evidence_6() const { return ____evidence_6; }
inline RuntimeObject ** get_address_of__evidence_6() { return &____evidence_6; }
inline void set__evidence_6(RuntimeObject * value)
{
____evidence_6 = value;
Il2CppCodeGenWriteBarrier((&____evidence_6), value);
}
inline static int32_t get_offset_of__granted_7() { return static_cast<int32_t>(offsetof(AppDomain_t1B59572328F60585904DF52A59FE47CF5B5FFFF8, ____granted_7)); }
inline RuntimeObject * get__granted_7() const { return ____granted_7; }
inline RuntimeObject ** get_address_of__granted_7() { return &____granted_7; }
inline void set__granted_7(RuntimeObject * value)
{
____granted_7 = value;
Il2CppCodeGenWriteBarrier((&____granted_7), value);
}
inline static int32_t get_offset_of__principalPolicy_8() { return static_cast<int32_t>(offsetof(AppDomain_t1B59572328F60585904DF52A59FE47CF5B5FFFF8, ____principalPolicy_8)); }
inline int32_t get__principalPolicy_8() const { return ____principalPolicy_8; }
inline int32_t* get_address_of__principalPolicy_8() { return &____principalPolicy_8; }
inline void set__principalPolicy_8(int32_t value)
{
____principalPolicy_8 = value;
}
inline static int32_t get_offset_of_AssemblyLoad_11() { return static_cast<int32_t>(offsetof(AppDomain_t1B59572328F60585904DF52A59FE47CF5B5FFFF8, ___AssemblyLoad_11)); }
inline AssemblyLoadEventHandler_t53F8340027F9EE67E8A22E7D8C1A3770345153C9 * get_AssemblyLoad_11() const { return ___AssemblyLoad_11; }
inline AssemblyLoadEventHandler_t53F8340027F9EE67E8A22E7D8C1A3770345153C9 ** get_address_of_AssemblyLoad_11() { return &___AssemblyLoad_11; }
inline void set_AssemblyLoad_11(AssemblyLoadEventHandler_t53F8340027F9EE67E8A22E7D8C1A3770345153C9 * value)
{
___AssemblyLoad_11 = value;
Il2CppCodeGenWriteBarrier((&___AssemblyLoad_11), value);
}
inline static int32_t get_offset_of_AssemblyResolve_12() { return static_cast<int32_t>(offsetof(AppDomain_t1B59572328F60585904DF52A59FE47CF5B5FFFF8, ___AssemblyResolve_12)); }
inline ResolveEventHandler_t045C469BEA8B632FA99FE8867C921BA8DAE0BEE5 * get_AssemblyResolve_12() const { return ___AssemblyResolve_12; }
inline ResolveEventHandler_t045C469BEA8B632FA99FE8867C921BA8DAE0BEE5 ** get_address_of_AssemblyResolve_12() { return &___AssemblyResolve_12; }
inline void set_AssemblyResolve_12(ResolveEventHandler_t045C469BEA8B632FA99FE8867C921BA8DAE0BEE5 * value)
{
___AssemblyResolve_12 = value;
Il2CppCodeGenWriteBarrier((&___AssemblyResolve_12), value);
}
inline static int32_t get_offset_of_DomainUnload_13() { return static_cast<int32_t>(offsetof(AppDomain_t1B59572328F60585904DF52A59FE47CF5B5FFFF8, ___DomainUnload_13)); }
inline EventHandler_t2B84E745E28BA26C49C4E99A387FC3B534D1110C * get_DomainUnload_13() const { return ___DomainUnload_13; }
inline EventHandler_t2B84E745E28BA26C49C4E99A387FC3B534D1110C ** get_address_of_DomainUnload_13() { return &___DomainUnload_13; }
inline void set_DomainUnload_13(EventHandler_t2B84E745E28BA26C49C4E99A387FC3B534D1110C * value)
{
___DomainUnload_13 = value;
Il2CppCodeGenWriteBarrier((&___DomainUnload_13), value);
}
inline static int32_t get_offset_of_ProcessExit_14() { return static_cast<int32_t>(offsetof(AppDomain_t1B59572328F60585904DF52A59FE47CF5B5FFFF8, ___ProcessExit_14)); }
inline EventHandler_t2B84E745E28BA26C49C4E99A387FC3B534D1110C * get_ProcessExit_14() const { return ___ProcessExit_14; }
inline EventHandler_t2B84E745E28BA26C49C4E99A387FC3B534D1110C ** get_address_of_ProcessExit_14() { return &___ProcessExit_14; }
inline void set_ProcessExit_14(EventHandler_t2B84E745E28BA26C49C4E99A387FC3B534D1110C * value)
{
___ProcessExit_14 = value;
Il2CppCodeGenWriteBarrier((&___ProcessExit_14), value);
}
inline static int32_t get_offset_of_ResourceResolve_15() { return static_cast<int32_t>(offsetof(AppDomain_t1B59572328F60585904DF52A59FE47CF5B5FFFF8, ___ResourceResolve_15)); }
inline ResolveEventHandler_t045C469BEA8B632FA99FE8867C921BA8DAE0BEE5 * get_ResourceResolve_15() const { return ___ResourceResolve_15; }
inline ResolveEventHandler_t045C469BEA8B632FA99FE8867C921BA8DAE0BEE5 ** get_address_of_ResourceResolve_15() { return &___ResourceResolve_15; }
inline void set_ResourceResolve_15(ResolveEventHandler_t045C469BEA8B632FA99FE8867C921BA8DAE0BEE5 * value)
{
___ResourceResolve_15 = value;
Il2CppCodeGenWriteBarrier((&___ResourceResolve_15), value);
}
inline static int32_t get_offset_of_TypeResolve_16() { return static_cast<int32_t>(offsetof(AppDomain_t1B59572328F60585904DF52A59FE47CF5B5FFFF8, ___TypeResolve_16)); }
inline ResolveEventHandler_t045C469BEA8B632FA99FE8867C921BA8DAE0BEE5 * get_TypeResolve_16() const { return ___TypeResolve_16; }
inline ResolveEventHandler_t045C469BEA8B632FA99FE8867C921BA8DAE0BEE5 ** get_address_of_TypeResolve_16() { return &___TypeResolve_16; }
inline void set_TypeResolve_16(ResolveEventHandler_t045C469BEA8B632FA99FE8867C921BA8DAE0BEE5 * value)
{
___TypeResolve_16 = value;
Il2CppCodeGenWriteBarrier((&___TypeResolve_16), value);
}
inline static int32_t get_offset_of_UnhandledException_17() { return static_cast<int32_t>(offsetof(AppDomain_t1B59572328F60585904DF52A59FE47CF5B5FFFF8, ___UnhandledException_17)); }
inline UnhandledExceptionEventHandler_tB0DFF05ABF7A3A234C87D4F7A71F98E9AB2D91DE * get_UnhandledException_17() const { return ___UnhandledException_17; }
inline UnhandledExceptionEventHandler_tB0DFF05ABF7A3A234C87D4F7A71F98E9AB2D91DE ** get_address_of_UnhandledException_17() { return &___UnhandledException_17; }
inline void set_UnhandledException_17(UnhandledExceptionEventHandler_tB0DFF05ABF7A3A234C87D4F7A71F98E9AB2D91DE * value)
{
___UnhandledException_17 = value;
Il2CppCodeGenWriteBarrier((&___UnhandledException_17), value);
}
inline static int32_t get_offset_of_FirstChanceException_18() { return static_cast<int32_t>(offsetof(AppDomain_t1B59572328F60585904DF52A59FE47CF5B5FFFF8, ___FirstChanceException_18)); }
inline EventHandler_1_t1E35ED2E29145994C6C03E57601C6D48C61083FF * get_FirstChanceException_18() const { return ___FirstChanceException_18; }
inline EventHandler_1_t1E35ED2E29145994C6C03E57601C6D48C61083FF ** get_address_of_FirstChanceException_18() { return &___FirstChanceException_18; }
inline void set_FirstChanceException_18(EventHandler_1_t1E35ED2E29145994C6C03E57601C6D48C61083FF * value)
{
___FirstChanceException_18 = value;
Il2CppCodeGenWriteBarrier((&___FirstChanceException_18), value);
}
inline static int32_t get_offset_of__domain_manager_19() { return static_cast<int32_t>(offsetof(AppDomain_t1B59572328F60585904DF52A59FE47CF5B5FFFF8, ____domain_manager_19)); }
inline RuntimeObject * get__domain_manager_19() const { return ____domain_manager_19; }
inline RuntimeObject ** get_address_of__domain_manager_19() { return &____domain_manager_19; }
inline void set__domain_manager_19(RuntimeObject * value)
{
____domain_manager_19 = value;
Il2CppCodeGenWriteBarrier((&____domain_manager_19), value);
}
inline static int32_t get_offset_of_ReflectionOnlyAssemblyResolve_20() { return static_cast<int32_t>(offsetof(AppDomain_t1B59572328F60585904DF52A59FE47CF5B5FFFF8, ___ReflectionOnlyAssemblyResolve_20)); }
inline ResolveEventHandler_t045C469BEA8B632FA99FE8867C921BA8DAE0BEE5 * get_ReflectionOnlyAssemblyResolve_20() const { return ___ReflectionOnlyAssemblyResolve_20; }
inline ResolveEventHandler_t045C469BEA8B632FA99FE8867C921BA8DAE0BEE5 ** get_address_of_ReflectionOnlyAssemblyResolve_20() { return &___ReflectionOnlyAssemblyResolve_20; }
inline void set_ReflectionOnlyAssemblyResolve_20(ResolveEventHandler_t045C469BEA8B632FA99FE8867C921BA8DAE0BEE5 * value)
{
___ReflectionOnlyAssemblyResolve_20 = value;
Il2CppCodeGenWriteBarrier((&___ReflectionOnlyAssemblyResolve_20), value);
}
inline static int32_t get_offset_of__activation_21() { return static_cast<int32_t>(offsetof(AppDomain_t1B59572328F60585904DF52A59FE47CF5B5FFFF8, ____activation_21)); }
inline RuntimeObject * get__activation_21() const { return ____activation_21; }
inline RuntimeObject ** get_address_of__activation_21() { return &____activation_21; }
inline void set__activation_21(RuntimeObject * value)
{
____activation_21 = value;
Il2CppCodeGenWriteBarrier((&____activation_21), value);
}
inline static int32_t get_offset_of__applicationIdentity_22() { return static_cast<int32_t>(offsetof(AppDomain_t1B59572328F60585904DF52A59FE47CF5B5FFFF8, ____applicationIdentity_22)); }
inline RuntimeObject * get__applicationIdentity_22() const { return ____applicationIdentity_22; }
inline RuntimeObject ** get_address_of__applicationIdentity_22() { return &____applicationIdentity_22; }
inline void set__applicationIdentity_22(RuntimeObject * value)
{
____applicationIdentity_22 = value;
Il2CppCodeGenWriteBarrier((&____applicationIdentity_22), value);
}
inline static int32_t get_offset_of_compatibility_switch_23() { return static_cast<int32_t>(offsetof(AppDomain_t1B59572328F60585904DF52A59FE47CF5B5FFFF8, ___compatibility_switch_23)); }
inline List_1_tE8032E48C661C350FF9550E9063D595C0AB25CD3 * get_compatibility_switch_23() const { return ___compatibility_switch_23; }
inline List_1_tE8032E48C661C350FF9550E9063D595C0AB25CD3 ** get_address_of_compatibility_switch_23() { return &___compatibility_switch_23; }
inline void set_compatibility_switch_23(List_1_tE8032E48C661C350FF9550E9063D595C0AB25CD3 * value)
{
___compatibility_switch_23 = value;
Il2CppCodeGenWriteBarrier((&___compatibility_switch_23), value);
}
};
struct AppDomain_t1B59572328F60585904DF52A59FE47CF5B5FFFF8_StaticFields
{
public:
// System.String System.AppDomain::_process_guid
String_t* ____process_guid_2;
// System.AppDomain System.AppDomain::default_domain
AppDomain_t1B59572328F60585904DF52A59FE47CF5B5FFFF8 * ___default_domain_10;
public:
inline static int32_t get_offset_of__process_guid_2() { return static_cast<int32_t>(offsetof(AppDomain_t1B59572328F60585904DF52A59FE47CF5B5FFFF8_StaticFields, ____process_guid_2)); }
inline String_t* get__process_guid_2() const { return ____process_guid_2; }
inline String_t** get_address_of__process_guid_2() { return &____process_guid_2; }
inline void set__process_guid_2(String_t* value)
{
____process_guid_2 = value;
Il2CppCodeGenWriteBarrier((&____process_guid_2), value);
}
inline static int32_t get_offset_of_default_domain_10() { return static_cast<int32_t>(offsetof(AppDomain_t1B59572328F60585904DF52A59FE47CF5B5FFFF8_StaticFields, ___default_domain_10)); }
inline AppDomain_t1B59572328F60585904DF52A59FE47CF5B5FFFF8 * get_default_domain_10() const { return ___default_domain_10; }
inline AppDomain_t1B59572328F60585904DF52A59FE47CF5B5FFFF8 ** get_address_of_default_domain_10() { return &___default_domain_10; }
inline void set_default_domain_10(AppDomain_t1B59572328F60585904DF52A59FE47CF5B5FFFF8 * value)
{
___default_domain_10 = value;
Il2CppCodeGenWriteBarrier((&___default_domain_10), value);
}
};
struct AppDomain_t1B59572328F60585904DF52A59FE47CF5B5FFFF8_ThreadStaticFields
{
public:
// System.Collections.Generic.Dictionary`2<System.String,System.Object> System.AppDomain::type_resolve_in_progress
Dictionary_2_t9140A71329927AE4FD0F3CF4D4D66668EBE151EA * ___type_resolve_in_progress_3;
// System.Collections.Generic.Dictionary`2<System.String,System.Object> System.AppDomain::assembly_resolve_in_progress
Dictionary_2_t9140A71329927AE4FD0F3CF4D4D66668EBE151EA * ___assembly_resolve_in_progress_4;
// System.Collections.Generic.Dictionary`2<System.String,System.Object> System.AppDomain::assembly_resolve_in_progress_refonly
Dictionary_2_t9140A71329927AE4FD0F3CF4D4D66668EBE151EA * ___assembly_resolve_in_progress_refonly_5;
// System.Object System.AppDomain::_principal
RuntimeObject * ____principal_9;
public:
inline static int32_t get_offset_of_type_resolve_in_progress_3() { return static_cast<int32_t>(offsetof(AppDomain_t1B59572328F60585904DF52A59FE47CF5B5FFFF8_ThreadStaticFields, ___type_resolve_in_progress_3)); }
inline Dictionary_2_t9140A71329927AE4FD0F3CF4D4D66668EBE151EA * get_type_resolve_in_progress_3() const { return ___type_resolve_in_progress_3; }
inline Dictionary_2_t9140A71329927AE4FD0F3CF4D4D66668EBE151EA ** get_address_of_type_resolve_in_progress_3() { return &___type_resolve_in_progress_3; }
inline void set_type_resolve_in_progress_3(Dictionary_2_t9140A71329927AE4FD0F3CF4D4D66668EBE151EA * value)
{
___type_resolve_in_progress_3 = value;
Il2CppCodeGenWriteBarrier((&___type_resolve_in_progress_3), value);
}
inline static int32_t get_offset_of_assembly_resolve_in_progress_4() { return static_cast<int32_t>(offsetof(AppDomain_t1B59572328F60585904DF52A59FE47CF5B5FFFF8_ThreadStaticFields, ___assembly_resolve_in_progress_4)); }
inline Dictionary_2_t9140A71329927AE4FD0F3CF4D4D66668EBE151EA * get_assembly_resolve_in_progress_4() const { return ___assembly_resolve_in_progress_4; }
inline Dictionary_2_t9140A71329927AE4FD0F3CF4D4D66668EBE151EA ** get_address_of_assembly_resolve_in_progress_4() { return &___assembly_resolve_in_progress_4; }
inline void set_assembly_resolve_in_progress_4(Dictionary_2_t9140A71329927AE4FD0F3CF4D4D66668EBE151EA * value)
{
___assembly_resolve_in_progress_4 = value;
Il2CppCodeGenWriteBarrier((&___assembly_resolve_in_progress_4), value);
}
inline static int32_t get_offset_of_assembly_resolve_in_progress_refonly_5() { return static_cast<int32_t>(offsetof(AppDomain_t1B59572328F60585904DF52A59FE47CF5B5FFFF8_ThreadStaticFields, ___assembly_resolve_in_progress_refonly_5)); }
inline Dictionary_2_t9140A71329927AE4FD0F3CF4D4D66668EBE151EA * get_assembly_resolve_in_progress_refonly_5() const { return ___assembly_resolve_in_progress_refonly_5; }
inline Dictionary_2_t9140A71329927AE4FD0F3CF4D4D66668EBE151EA ** get_address_of_assembly_resolve_in_progress_refonly_5() { return &___assembly_resolve_in_progress_refonly_5; }
inline void set_assembly_resolve_in_progress_refonly_5(Dictionary_2_t9140A71329927AE4FD0F3CF4D4D66668EBE151EA * value)
{
___assembly_resolve_in_progress_refonly_5 = value;
Il2CppCodeGenWriteBarrier((&___assembly_resolve_in_progress_refonly_5), value);
}
inline static int32_t get_offset_of__principal_9() { return static_cast<int32_t>(offsetof(AppDomain_t1B59572328F60585904DF52A59FE47CF5B5FFFF8_ThreadStaticFields, ____principal_9)); }
inline RuntimeObject * get__principal_9() const { return ____principal_9; }
inline RuntimeObject ** get_address_of__principal_9() { return &____principal_9; }
inline void set__principal_9(RuntimeObject * value)
{
____principal_9 = value;
Il2CppCodeGenWriteBarrier((&____principal_9), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
// Native definition for P/Invoke marshalling of System.AppDomain
struct AppDomain_t1B59572328F60585904DF52A59FE47CF5B5FFFF8_marshaled_pinvoke : public MarshalByRefObject_tC4577953D0A44D0AB8597CFA868E01C858B1C9AF_marshaled_pinvoke
{
intptr_t ____mono_app_domain_1;
Il2CppIUnknown* ____evidence_6;
Il2CppIUnknown* ____granted_7;
int32_t ____principalPolicy_8;
Il2CppMethodPointer ___AssemblyLoad_11;
Il2CppMethodPointer ___AssemblyResolve_12;
Il2CppMethodPointer ___DomainUnload_13;
Il2CppMethodPointer ___ProcessExit_14;
Il2CppMethodPointer ___ResourceResolve_15;
Il2CppMethodPointer ___TypeResolve_16;
Il2CppMethodPointer ___UnhandledException_17;
Il2CppMethodPointer ___FirstChanceException_18;
Il2CppIUnknown* ____domain_manager_19;
Il2CppMethodPointer ___ReflectionOnlyAssemblyResolve_20;
Il2CppIUnknown* ____activation_21;
Il2CppIUnknown* ____applicationIdentity_22;
List_1_tE8032E48C661C350FF9550E9063D595C0AB25CD3 * ___compatibility_switch_23;
};
// Native definition for COM marshalling of System.AppDomain
struct AppDomain_t1B59572328F60585904DF52A59FE47CF5B5FFFF8_marshaled_com : public MarshalByRefObject_tC4577953D0A44D0AB8597CFA868E01C858B1C9AF_marshaled_com
{
intptr_t ____mono_app_domain_1;
Il2CppIUnknown* ____evidence_6;
Il2CppIUnknown* ____granted_7;
int32_t ____principalPolicy_8;
Il2CppMethodPointer ___AssemblyLoad_11;
Il2CppMethodPointer ___AssemblyResolve_12;
Il2CppMethodPointer ___DomainUnload_13;
Il2CppMethodPointer ___ProcessExit_14;
Il2CppMethodPointer ___ResourceResolve_15;
Il2CppMethodPointer ___TypeResolve_16;
Il2CppMethodPointer ___UnhandledException_17;
Il2CppMethodPointer ___FirstChanceException_18;
Il2CppIUnknown* ____domain_manager_19;
Il2CppMethodPointer ___ReflectionOnlyAssemblyResolve_20;
Il2CppIUnknown* ____activation_21;
Il2CppIUnknown* ____applicationIdentity_22;
List_1_tE8032E48C661C350FF9550E9063D595C0AB25CD3 * ___compatibility_switch_23;
};
#endif // APPDOMAIN_T1B59572328F60585904DF52A59FE47CF5B5FFFF8_H
#ifndef ARGITERATOR_TCF0D2A1A1BD140821E37286E2D7AC6267479F855_H
#define ARGITERATOR_TCF0D2A1A1BD140821E37286E2D7AC6267479F855_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.ArgIterator
struct ArgIterator_tCF0D2A1A1BD140821E37286E2D7AC6267479F855
{
public:
// System.IntPtr System.ArgIterator::sig
intptr_t ___sig_0;
// System.IntPtr System.ArgIterator::args
intptr_t ___args_1;
// System.Int32 System.ArgIterator::next_arg
int32_t ___next_arg_2;
// System.Int32 System.ArgIterator::num_args
int32_t ___num_args_3;
public:
inline static int32_t get_offset_of_sig_0() { return static_cast<int32_t>(offsetof(ArgIterator_tCF0D2A1A1BD140821E37286E2D7AC6267479F855, ___sig_0)); }
inline intptr_t get_sig_0() const { return ___sig_0; }
inline intptr_t* get_address_of_sig_0() { return &___sig_0; }
inline void set_sig_0(intptr_t value)
{
___sig_0 = value;
}
inline static int32_t get_offset_of_args_1() { return static_cast<int32_t>(offsetof(ArgIterator_tCF0D2A1A1BD140821E37286E2D7AC6267479F855, ___args_1)); }
inline intptr_t get_args_1() const { return ___args_1; }
inline intptr_t* get_address_of_args_1() { return &___args_1; }
inline void set_args_1(intptr_t value)
{
___args_1 = value;
}
inline static int32_t get_offset_of_next_arg_2() { return static_cast<int32_t>(offsetof(ArgIterator_tCF0D2A1A1BD140821E37286E2D7AC6267479F855, ___next_arg_2)); }
inline int32_t get_next_arg_2() const { return ___next_arg_2; }
inline int32_t* get_address_of_next_arg_2() { return &___next_arg_2; }
inline void set_next_arg_2(int32_t value)
{
___next_arg_2 = value;
}
inline static int32_t get_offset_of_num_args_3() { return static_cast<int32_t>(offsetof(ArgIterator_tCF0D2A1A1BD140821E37286E2D7AC6267479F855, ___num_args_3)); }
inline int32_t get_num_args_3() const { return ___num_args_3; }
inline int32_t* get_address_of_num_args_3() { return &___num_args_3; }
inline void set_num_args_3(int32_t value)
{
___num_args_3 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // ARGITERATOR_TCF0D2A1A1BD140821E37286E2D7AC6267479F855_H
#ifndef BRECORD_TDDC5F1A5DC569C234C6141FCBA5F8DE8293BC601_H
#define BRECORD_TDDC5F1A5DC569C234C6141FCBA5F8DE8293BC601_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.BRECORD
struct BRECORD_tDDC5F1A5DC569C234C6141FCBA5F8DE8293BC601
{
public:
// System.IntPtr System.BRECORD::pvRecord
intptr_t ___pvRecord_0;
// System.IntPtr System.BRECORD::pRecInfo
intptr_t ___pRecInfo_1;
public:
inline static int32_t get_offset_of_pvRecord_0() { return static_cast<int32_t>(offsetof(BRECORD_tDDC5F1A5DC569C234C6141FCBA5F8DE8293BC601, ___pvRecord_0)); }
inline intptr_t get_pvRecord_0() const { return ___pvRecord_0; }
inline intptr_t* get_address_of_pvRecord_0() { return &___pvRecord_0; }
inline void set_pvRecord_0(intptr_t value)
{
___pvRecord_0 = value;
}
inline static int32_t get_offset_of_pRecInfo_1() { return static_cast<int32_t>(offsetof(BRECORD_tDDC5F1A5DC569C234C6141FCBA5F8DE8293BC601, ___pRecInfo_1)); }
inline intptr_t get_pRecInfo_1() const { return ___pRecInfo_1; }
inline intptr_t* get_address_of_pRecInfo_1() { return &___pRecInfo_1; }
inline void set_pRecInfo_1(intptr_t value)
{
___pRecInfo_1 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // BRECORD_TDDC5F1A5DC569C234C6141FCBA5F8DE8293BC601_H
#ifndef BYTEENUM_T406C975039F6312CDE58A265A6ECFD861F8C06CD_H
#define BYTEENUM_T406C975039F6312CDE58A265A6ECFD861F8C06CD_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.ByteEnum
struct ByteEnum_t406C975039F6312CDE58A265A6ECFD861F8C06CD
{
public:
// System.Byte System.ByteEnum::value__
uint8_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(ByteEnum_t406C975039F6312CDE58A265A6ECFD861F8C06CD, ___value___2)); }
inline uint8_t get_value___2() const { return ___value___2; }
inline uint8_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(uint8_t value)
{
___value___2 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // BYTEENUM_T406C975039F6312CDE58A265A6ECFD861F8C06CD_H
#ifndef ASSEMBLYHASHALGORITHM_T31E4F1BC642CF668706C9D0FBD9DFDF5EE01CEB9_H
#define ASSEMBLYHASHALGORITHM_T31E4F1BC642CF668706C9D0FBD9DFDF5EE01CEB9_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Configuration.Assemblies.AssemblyHashAlgorithm
struct AssemblyHashAlgorithm_t31E4F1BC642CF668706C9D0FBD9DFDF5EE01CEB9
{
public:
// System.Int32 System.Configuration.Assemblies.AssemblyHashAlgorithm::value__
int32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(AssemblyHashAlgorithm_t31E4F1BC642CF668706C9D0FBD9DFDF5EE01CEB9, ___value___2)); }
inline int32_t get_value___2() const { return ___value___2; }
inline int32_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(int32_t value)
{
___value___2 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // ASSEMBLYHASHALGORITHM_T31E4F1BC642CF668706C9D0FBD9DFDF5EE01CEB9_H
#ifndef CONSOLECOLOR_T2E01225594844040BE12231E6A14F85FCB78C597_H
#define CONSOLECOLOR_T2E01225594844040BE12231E6A14F85FCB78C597_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.ConsoleColor
struct ConsoleColor_t2E01225594844040BE12231E6A14F85FCB78C597
{
public:
// System.Int32 System.ConsoleColor::value__
int32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(ConsoleColor_t2E01225594844040BE12231E6A14F85FCB78C597, ___value___2)); }
inline int32_t get_value___2() const { return ___value___2; }
inline int32_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(int32_t value)
{
___value___2 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // CONSOLECOLOR_T2E01225594844040BE12231E6A14F85FCB78C597_H
#ifndef CONSOLEKEY_T0196714F06D59B40580F7B85EA2663D81394682C_H
#define CONSOLEKEY_T0196714F06D59B40580F7B85EA2663D81394682C_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.ConsoleKey
struct ConsoleKey_t0196714F06D59B40580F7B85EA2663D81394682C
{
public:
// System.Int32 System.ConsoleKey::value__
int32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(ConsoleKey_t0196714F06D59B40580F7B85EA2663D81394682C, ___value___2)); }
inline int32_t get_value___2() const { return ___value___2; }
inline int32_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(int32_t value)
{
___value___2 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // CONSOLEKEY_T0196714F06D59B40580F7B85EA2663D81394682C_H
#ifndef CONSOLEMODIFIERS_TCB55098B71E4DCCEE972B1056E64D1B8AB9EAB34_H
#define CONSOLEMODIFIERS_TCB55098B71E4DCCEE972B1056E64D1B8AB9EAB34_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.ConsoleModifiers
struct ConsoleModifiers_tCB55098B71E4DCCEE972B1056E64D1B8AB9EAB34
{
public:
// System.Int32 System.ConsoleModifiers::value__
int32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(ConsoleModifiers_tCB55098B71E4DCCEE972B1056E64D1B8AB9EAB34, ___value___2)); }
inline int32_t get_value___2() const { return ___value___2; }
inline int32_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(int32_t value)
{
___value___2 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // CONSOLEMODIFIERS_TCB55098B71E4DCCEE972B1056E64D1B8AB9EAB34_H
#ifndef CONSOLESCREENBUFFERINFO_TA8045B7C44EF25956D3B0847F24465E9CF18954F_H
#define CONSOLESCREENBUFFERINFO_TA8045B7C44EF25956D3B0847F24465E9CF18954F_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.ConsoleScreenBufferInfo
struct ConsoleScreenBufferInfo_tA8045B7C44EF25956D3B0847F24465E9CF18954F
{
public:
// System.Coord System.ConsoleScreenBufferInfo::Size
Coord_t6CEFF682745DD47B1B4DA3ED268C0933021AC34A ___Size_0;
// System.Coord System.ConsoleScreenBufferInfo::CursorPosition
Coord_t6CEFF682745DD47B1B4DA3ED268C0933021AC34A ___CursorPosition_1;
// System.Int16 System.ConsoleScreenBufferInfo::Attribute
int16_t ___Attribute_2;
// System.SmallRect System.ConsoleScreenBufferInfo::Window
SmallRect_t18C271B0FF660F6ED4EC6D99B26C4D35F51CA532 ___Window_3;
// System.Coord System.ConsoleScreenBufferInfo::MaxWindowSize
Coord_t6CEFF682745DD47B1B4DA3ED268C0933021AC34A ___MaxWindowSize_4;
public:
inline static int32_t get_offset_of_Size_0() { return static_cast<int32_t>(offsetof(ConsoleScreenBufferInfo_tA8045B7C44EF25956D3B0847F24465E9CF18954F, ___Size_0)); }
inline Coord_t6CEFF682745DD47B1B4DA3ED268C0933021AC34A get_Size_0() const { return ___Size_0; }
inline Coord_t6CEFF682745DD47B1B4DA3ED268C0933021AC34A * get_address_of_Size_0() { return &___Size_0; }
inline void set_Size_0(Coord_t6CEFF682745DD47B1B4DA3ED268C0933021AC34A value)
{
___Size_0 = value;
}
inline static int32_t get_offset_of_CursorPosition_1() { return static_cast<int32_t>(offsetof(ConsoleScreenBufferInfo_tA8045B7C44EF25956D3B0847F24465E9CF18954F, ___CursorPosition_1)); }
inline Coord_t6CEFF682745DD47B1B4DA3ED268C0933021AC34A get_CursorPosition_1() const { return ___CursorPosition_1; }
inline Coord_t6CEFF682745DD47B1B4DA3ED268C0933021AC34A * get_address_of_CursorPosition_1() { return &___CursorPosition_1; }
inline void set_CursorPosition_1(Coord_t6CEFF682745DD47B1B4DA3ED268C0933021AC34A value)
{
___CursorPosition_1 = value;
}
inline static int32_t get_offset_of_Attribute_2() { return static_cast<int32_t>(offsetof(ConsoleScreenBufferInfo_tA8045B7C44EF25956D3B0847F24465E9CF18954F, ___Attribute_2)); }
inline int16_t get_Attribute_2() const { return ___Attribute_2; }
inline int16_t* get_address_of_Attribute_2() { return &___Attribute_2; }
inline void set_Attribute_2(int16_t value)
{
___Attribute_2 = value;
}
inline static int32_t get_offset_of_Window_3() { return static_cast<int32_t>(offsetof(ConsoleScreenBufferInfo_tA8045B7C44EF25956D3B0847F24465E9CF18954F, ___Window_3)); }
inline SmallRect_t18C271B0FF660F6ED4EC6D99B26C4D35F51CA532 get_Window_3() const { return ___Window_3; }
inline SmallRect_t18C271B0FF660F6ED4EC6D99B26C4D35F51CA532 * get_address_of_Window_3() { return &___Window_3; }
inline void set_Window_3(SmallRect_t18C271B0FF660F6ED4EC6D99B26C4D35F51CA532 value)
{
___Window_3 = value;
}
inline static int32_t get_offset_of_MaxWindowSize_4() { return static_cast<int32_t>(offsetof(ConsoleScreenBufferInfo_tA8045B7C44EF25956D3B0847F24465E9CF18954F, ___MaxWindowSize_4)); }
inline Coord_t6CEFF682745DD47B1B4DA3ED268C0933021AC34A get_MaxWindowSize_4() const { return ___MaxWindowSize_4; }
inline Coord_t6CEFF682745DD47B1B4DA3ED268C0933021AC34A * get_address_of_MaxWindowSize_4() { return &___MaxWindowSize_4; }
inline void set_MaxWindowSize_4(Coord_t6CEFF682745DD47B1B4DA3ED268C0933021AC34A value)
{
___MaxWindowSize_4 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // CONSOLESCREENBUFFERINFO_TA8045B7C44EF25956D3B0847F24465E9CF18954F_H
#ifndef DELEGATE_T_H
#define DELEGATE_T_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Delegate
struct Delegate_t : public RuntimeObject
{
public:
// System.IntPtr System.Delegate::method_ptr
Il2CppMethodPointer ___method_ptr_0;
// System.IntPtr System.Delegate::invoke_impl
intptr_t ___invoke_impl_1;
// System.Object System.Delegate::m_target
RuntimeObject * ___m_target_2;
// System.IntPtr System.Delegate::method
intptr_t ___method_3;
// System.IntPtr System.Delegate::delegate_trampoline
intptr_t ___delegate_trampoline_4;
// System.IntPtr System.Delegate::extra_arg
intptr_t ___extra_arg_5;
// System.IntPtr System.Delegate::method_code
intptr_t ___method_code_6;
// System.Reflection.MethodInfo System.Delegate::method_info
MethodInfo_t * ___method_info_7;
// System.Reflection.MethodInfo System.Delegate::original_method_info
MethodInfo_t * ___original_method_info_8;
// System.DelegateData System.Delegate::data
DelegateData_t1BF9F691B56DAE5F8C28C5E084FDE94F15F27BBE * ___data_9;
// System.Boolean System.Delegate::method_is_virtual
bool ___method_is_virtual_10;
public:
inline static int32_t get_offset_of_method_ptr_0() { return static_cast<int32_t>(offsetof(Delegate_t, ___method_ptr_0)); }
inline Il2CppMethodPointer get_method_ptr_0() const { return ___method_ptr_0; }
inline Il2CppMethodPointer* get_address_of_method_ptr_0() { return &___method_ptr_0; }
inline void set_method_ptr_0(Il2CppMethodPointer value)
{
___method_ptr_0 = value;
}
inline static int32_t get_offset_of_invoke_impl_1() { return static_cast<int32_t>(offsetof(Delegate_t, ___invoke_impl_1)); }
inline intptr_t get_invoke_impl_1() const { return ___invoke_impl_1; }
inline intptr_t* get_address_of_invoke_impl_1() { return &___invoke_impl_1; }
inline void set_invoke_impl_1(intptr_t value)
{
___invoke_impl_1 = value;
}
inline static int32_t get_offset_of_m_target_2() { return static_cast<int32_t>(offsetof(Delegate_t, ___m_target_2)); }
inline RuntimeObject * get_m_target_2() const { return ___m_target_2; }
inline RuntimeObject ** get_address_of_m_target_2() { return &___m_target_2; }
inline void set_m_target_2(RuntimeObject * value)
{
___m_target_2 = value;
Il2CppCodeGenWriteBarrier((&___m_target_2), value);
}
inline static int32_t get_offset_of_method_3() { return static_cast<int32_t>(offsetof(Delegate_t, ___method_3)); }
inline intptr_t get_method_3() const { return ___method_3; }
inline intptr_t* get_address_of_method_3() { return &___method_3; }
inline void set_method_3(intptr_t value)
{
___method_3 = value;
}
inline static int32_t get_offset_of_delegate_trampoline_4() { return static_cast<int32_t>(offsetof(Delegate_t, ___delegate_trampoline_4)); }
inline intptr_t get_delegate_trampoline_4() const { return ___delegate_trampoline_4; }
inline intptr_t* get_address_of_delegate_trampoline_4() { return &___delegate_trampoline_4; }
inline void set_delegate_trampoline_4(intptr_t value)
{
___delegate_trampoline_4 = value;
}
inline static int32_t get_offset_of_extra_arg_5() { return static_cast<int32_t>(offsetof(Delegate_t, ___extra_arg_5)); }
inline intptr_t get_extra_arg_5() const { return ___extra_arg_5; }
inline intptr_t* get_address_of_extra_arg_5() { return &___extra_arg_5; }
inline void set_extra_arg_5(intptr_t value)
{
___extra_arg_5 = value;
}
inline static int32_t get_offset_of_method_code_6() { return static_cast<int32_t>(offsetof(Delegate_t, ___method_code_6)); }
inline intptr_t get_method_code_6() const { return ___method_code_6; }
inline intptr_t* get_address_of_method_code_6() { return &___method_code_6; }
inline void set_method_code_6(intptr_t value)
{
___method_code_6 = value;
}
inline static int32_t get_offset_of_method_info_7() { return static_cast<int32_t>(offsetof(Delegate_t, ___method_info_7)); }
inline MethodInfo_t * get_method_info_7() const { return ___method_info_7; }
inline MethodInfo_t ** get_address_of_method_info_7() { return &___method_info_7; }
inline void set_method_info_7(MethodInfo_t * value)
{
___method_info_7 = value;
Il2CppCodeGenWriteBarrier((&___method_info_7), value);
}
inline static int32_t get_offset_of_original_method_info_8() { return static_cast<int32_t>(offsetof(Delegate_t, ___original_method_info_8)); }
inline MethodInfo_t * get_original_method_info_8() const { return ___original_method_info_8; }
inline MethodInfo_t ** get_address_of_original_method_info_8() { return &___original_method_info_8; }
inline void set_original_method_info_8(MethodInfo_t * value)
{
___original_method_info_8 = value;
Il2CppCodeGenWriteBarrier((&___original_method_info_8), value);
}
inline static int32_t get_offset_of_data_9() { return static_cast<int32_t>(offsetof(Delegate_t, ___data_9)); }
inline DelegateData_t1BF9F691B56DAE5F8C28C5E084FDE94F15F27BBE * get_data_9() const { return ___data_9; }
inline DelegateData_t1BF9F691B56DAE5F8C28C5E084FDE94F15F27BBE ** get_address_of_data_9() { return &___data_9; }
inline void set_data_9(DelegateData_t1BF9F691B56DAE5F8C28C5E084FDE94F15F27BBE * value)
{
___data_9 = value;
Il2CppCodeGenWriteBarrier((&___data_9), value);
}
inline static int32_t get_offset_of_method_is_virtual_10() { return static_cast<int32_t>(offsetof(Delegate_t, ___method_is_virtual_10)); }
inline bool get_method_is_virtual_10() const { return ___method_is_virtual_10; }
inline bool* get_address_of_method_is_virtual_10() { return &___method_is_virtual_10; }
inline void set_method_is_virtual_10(bool value)
{
___method_is_virtual_10 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
// Native definition for P/Invoke marshalling of System.Delegate
struct Delegate_t_marshaled_pinvoke
{
intptr_t ___method_ptr_0;
intptr_t ___invoke_impl_1;
Il2CppIUnknown* ___m_target_2;
intptr_t ___method_3;
intptr_t ___delegate_trampoline_4;
intptr_t ___extra_arg_5;
intptr_t ___method_code_6;
MethodInfo_t * ___method_info_7;
MethodInfo_t * ___original_method_info_8;
DelegateData_t1BF9F691B56DAE5F8C28C5E084FDE94F15F27BBE * ___data_9;
int32_t ___method_is_virtual_10;
};
// Native definition for COM marshalling of System.Delegate
struct Delegate_t_marshaled_com
{
intptr_t ___method_ptr_0;
intptr_t ___invoke_impl_1;
Il2CppIUnknown* ___m_target_2;
intptr_t ___method_3;
intptr_t ___delegate_trampoline_4;
intptr_t ___extra_arg_5;
intptr_t ___method_code_6;
MethodInfo_t * ___method_info_7;
MethodInfo_t * ___original_method_info_8;
DelegateData_t1BF9F691B56DAE5F8C28C5E084FDE94F15F27BBE * ___data_9;
int32_t ___method_is_virtual_10;
};
#endif // DELEGATE_T_H
#ifndef SPECIALFOLDER_T5A2C2AE97BD6C2DF95061C8904B2225228AC9BA0_H
#define SPECIALFOLDER_T5A2C2AE97BD6C2DF95061C8904B2225228AC9BA0_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Environment_SpecialFolder
struct SpecialFolder_t5A2C2AE97BD6C2DF95061C8904B2225228AC9BA0
{
public:
// System.Int32 System.Environment_SpecialFolder::value__
int32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(SpecialFolder_t5A2C2AE97BD6C2DF95061C8904B2225228AC9BA0, ___value___2)); }
inline int32_t get_value___2() const { return ___value___2; }
inline int32_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(int32_t value)
{
___value___2 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // SPECIALFOLDER_T5A2C2AE97BD6C2DF95061C8904B2225228AC9BA0_H
#ifndef SPECIALFOLDEROPTION_TAF2DB60F447738C1E46C3D5660A0CBB0F4480470_H
#define SPECIALFOLDEROPTION_TAF2DB60F447738C1E46C3D5660A0CBB0F4480470_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Environment_SpecialFolderOption
struct SpecialFolderOption_tAF2DB60F447738C1E46C3D5660A0CBB0F4480470
{
public:
// System.Int32 System.Environment_SpecialFolderOption::value__
int32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(SpecialFolderOption_tAF2DB60F447738C1E46C3D5660A0CBB0F4480470, ___value___2)); }
inline int32_t get_value___2() const { return ___value___2; }
inline int32_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(int32_t value)
{
___value___2 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // SPECIALFOLDEROPTION_TAF2DB60F447738C1E46C3D5660A0CBB0F4480470_H
#ifndef HANDLES_TC13FB0F0810977450CE811097C1B15BCF5E4CAD7_H
#define HANDLES_TC13FB0F0810977450CE811097C1B15BCF5E4CAD7_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Handles
struct Handles_tC13FB0F0810977450CE811097C1B15BCF5E4CAD7
{
public:
// System.Int32 System.Handles::value__
int32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(Handles_tC13FB0F0810977450CE811097C1B15BCF5E4CAD7, ___value___2)); }
inline int32_t get_value___2() const { return ___value___2; }
inline int32_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(int32_t value)
{
___value___2 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // HANDLES_TC13FB0F0810977450CE811097C1B15BCF5E4CAD7_H
#ifndef INT16ENUM_TF03C0C5772A892EB552607A1C0DEF122A930BE80_H
#define INT16ENUM_TF03C0C5772A892EB552607A1C0DEF122A930BE80_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Int16Enum
struct Int16Enum_tF03C0C5772A892EB552607A1C0DEF122A930BE80
{
public:
// System.Int16 System.Int16Enum::value__
int16_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(Int16Enum_tF03C0C5772A892EB552607A1C0DEF122A930BE80, ___value___2)); }
inline int16_t get_value___2() const { return ___value___2; }
inline int16_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(int16_t value)
{
___value___2 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // INT16ENUM_TF03C0C5772A892EB552607A1C0DEF122A930BE80_H
#ifndef INT32ENUM_T6312CE4586C17FE2E2E513D2E7655B574F10FDCD_H
#define INT32ENUM_T6312CE4586C17FE2E2E513D2E7655B574F10FDCD_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Int32Enum
struct Int32Enum_t6312CE4586C17FE2E2E513D2E7655B574F10FDCD
{
public:
// System.Int32 System.Int32Enum::value__
int32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(Int32Enum_t6312CE4586C17FE2E2E513D2E7655B574F10FDCD, ___value___2)); }
inline int32_t get_value___2() const { return ___value___2; }
inline int32_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(int32_t value)
{
___value___2 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // INT32ENUM_T6312CE4586C17FE2E2E513D2E7655B574F10FDCD_H
#ifndef INT64ENUM_T7DD4BDEADB660E726D94B249B352C2E2ABC1E580_H
#define INT64ENUM_T7DD4BDEADB660E726D94B249B352C2E2ABC1E580_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Int64Enum
struct Int64Enum_t7DD4BDEADB660E726D94B249B352C2E2ABC1E580
{
public:
// System.Int64 System.Int64Enum::value__
int64_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(Int64Enum_t7DD4BDEADB660E726D94B249B352C2E2ABC1E580, ___value___2)); }
inline int64_t get_value___2() const { return ___value___2; }
inline int64_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(int64_t value)
{
___value___2 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // INT64ENUM_T7DD4BDEADB660E726D94B249B352C2E2ABC1E580_H
#ifndef MONOASYNCCALL_T5D4F895C7FEF7A36A60AFD3C64078A86BAF681FD_H
#define MONOASYNCCALL_T5D4F895C7FEF7A36A60AFD3C64078A86BAF681FD_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.MonoAsyncCall
struct MonoAsyncCall_t5D4F895C7FEF7A36A60AFD3C64078A86BAF681FD : public RuntimeObject
{
public:
// System.Object System.MonoAsyncCall::msg
RuntimeObject * ___msg_0;
// System.IntPtr System.MonoAsyncCall::cb_method
intptr_t ___cb_method_1;
// System.Object System.MonoAsyncCall::cb_target
RuntimeObject * ___cb_target_2;
// System.Object System.MonoAsyncCall::state
RuntimeObject * ___state_3;
// System.Object System.MonoAsyncCall::res
RuntimeObject * ___res_4;
// System.Object System.MonoAsyncCall::out_args
RuntimeObject * ___out_args_5;
public:
inline static int32_t get_offset_of_msg_0() { return static_cast<int32_t>(offsetof(MonoAsyncCall_t5D4F895C7FEF7A36A60AFD3C64078A86BAF681FD, ___msg_0)); }
inline RuntimeObject * get_msg_0() const { return ___msg_0; }
inline RuntimeObject ** get_address_of_msg_0() { return &___msg_0; }
inline void set_msg_0(RuntimeObject * value)
{
___msg_0 = value;
Il2CppCodeGenWriteBarrier((&___msg_0), value);
}
inline static int32_t get_offset_of_cb_method_1() { return static_cast<int32_t>(offsetof(MonoAsyncCall_t5D4F895C7FEF7A36A60AFD3C64078A86BAF681FD, ___cb_method_1)); }
inline intptr_t get_cb_method_1() const { return ___cb_method_1; }
inline intptr_t* get_address_of_cb_method_1() { return &___cb_method_1; }
inline void set_cb_method_1(intptr_t value)
{
___cb_method_1 = value;
}
inline static int32_t get_offset_of_cb_target_2() { return static_cast<int32_t>(offsetof(MonoAsyncCall_t5D4F895C7FEF7A36A60AFD3C64078A86BAF681FD, ___cb_target_2)); }
inline RuntimeObject * get_cb_target_2() const { return ___cb_target_2; }
inline RuntimeObject ** get_address_of_cb_target_2() { return &___cb_target_2; }
inline void set_cb_target_2(RuntimeObject * value)
{
___cb_target_2 = value;
Il2CppCodeGenWriteBarrier((&___cb_target_2), value);
}
inline static int32_t get_offset_of_state_3() { return static_cast<int32_t>(offsetof(MonoAsyncCall_t5D4F895C7FEF7A36A60AFD3C64078A86BAF681FD, ___state_3)); }
inline RuntimeObject * get_state_3() const { return ___state_3; }
inline RuntimeObject ** get_address_of_state_3() { return &___state_3; }
inline void set_state_3(RuntimeObject * value)
{
___state_3 = value;
Il2CppCodeGenWriteBarrier((&___state_3), value);
}
inline static int32_t get_offset_of_res_4() { return static_cast<int32_t>(offsetof(MonoAsyncCall_t5D4F895C7FEF7A36A60AFD3C64078A86BAF681FD, ___res_4)); }
inline RuntimeObject * get_res_4() const { return ___res_4; }
inline RuntimeObject ** get_address_of_res_4() { return &___res_4; }
inline void set_res_4(RuntimeObject * value)
{
___res_4 = value;
Il2CppCodeGenWriteBarrier((&___res_4), value);
}
inline static int32_t get_offset_of_out_args_5() { return static_cast<int32_t>(offsetof(MonoAsyncCall_t5D4F895C7FEF7A36A60AFD3C64078A86BAF681FD, ___out_args_5)); }
inline RuntimeObject * get_out_args_5() const { return ___out_args_5; }
inline RuntimeObject ** get_address_of_out_args_5() { return &___out_args_5; }
inline void set_out_args_5(RuntimeObject * value)
{
___out_args_5 = value;
Il2CppCodeGenWriteBarrier((&___out_args_5), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
// Native definition for P/Invoke marshalling of System.MonoAsyncCall
struct MonoAsyncCall_t5D4F895C7FEF7A36A60AFD3C64078A86BAF681FD_marshaled_pinvoke
{
Il2CppIUnknown* ___msg_0;
intptr_t ___cb_method_1;
Il2CppIUnknown* ___cb_target_2;
Il2CppIUnknown* ___state_3;
Il2CppIUnknown* ___res_4;
Il2CppIUnknown* ___out_args_5;
};
// Native definition for COM marshalling of System.MonoAsyncCall
struct MonoAsyncCall_t5D4F895C7FEF7A36A60AFD3C64078A86BAF681FD_marshaled_com
{
Il2CppIUnknown* ___msg_0;
intptr_t ___cb_method_1;
Il2CppIUnknown* ___cb_target_2;
Il2CppIUnknown* ___state_3;
Il2CppIUnknown* ___res_4;
Il2CppIUnknown* ___out_args_5;
};
#endif // MONOASYNCCALL_T5D4F895C7FEF7A36A60AFD3C64078A86BAF681FD_H
#ifndef PLATFORMID_T7969561D329B66D3E609C70CA506A519E06F2776_H
#define PLATFORMID_T7969561D329B66D3E609C70CA506A519E06F2776_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.PlatformID
struct PlatformID_t7969561D329B66D3E609C70CA506A519E06F2776
{
public:
// System.Int32 System.PlatformID::value__
int32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(PlatformID_t7969561D329B66D3E609C70CA506A519E06F2776, ___value___2)); }
inline int32_t get_value___2() const { return ___value___2; }
inline int32_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(int32_t value)
{
___value___2 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // PLATFORMID_T7969561D329B66D3E609C70CA506A519E06F2776_H
#ifndef BINDINGFLAGS_TE35C91D046E63A1B92BB9AB909FCF9DA84379ED0_H
#define BINDINGFLAGS_TE35C91D046E63A1B92BB9AB909FCF9DA84379ED0_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Reflection.BindingFlags
struct BindingFlags_tE35C91D046E63A1B92BB9AB909FCF9DA84379ED0
{
public:
// System.Int32 System.Reflection.BindingFlags::value__
int32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(BindingFlags_tE35C91D046E63A1B92BB9AB909FCF9DA84379ED0, ___value___2)); }
inline int32_t get_value___2() const { return ___value___2; }
inline int32_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(int32_t value)
{
___value___2 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // BINDINGFLAGS_TE35C91D046E63A1B92BB9AB909FCF9DA84379ED0_H
#ifndef RUNTIMEARGUMENTHANDLE_T6118B2666F632AA0A554B476D9A447ACDBF08C46_H
#define RUNTIMEARGUMENTHANDLE_T6118B2666F632AA0A554B476D9A447ACDBF08C46_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.RuntimeArgumentHandle
struct RuntimeArgumentHandle_t6118B2666F632AA0A554B476D9A447ACDBF08C46
{
public:
// System.IntPtr System.RuntimeArgumentHandle::args
intptr_t ___args_0;
public:
inline static int32_t get_offset_of_args_0() { return static_cast<int32_t>(offsetof(RuntimeArgumentHandle_t6118B2666F632AA0A554B476D9A447ACDBF08C46, ___args_0)); }
inline intptr_t get_args_0() const { return ___args_0; }
inline intptr_t* get_address_of_args_0() { return &___args_0; }
inline void set_args_0(intptr_t value)
{
___args_0 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // RUNTIMEARGUMENTHANDLE_T6118B2666F632AA0A554B476D9A447ACDBF08C46_H
#ifndef RUNTIMEFIELDHANDLE_T844BDF00E8E6FE69D9AEAA7657F09018B864F4EF_H
#define RUNTIMEFIELDHANDLE_T844BDF00E8E6FE69D9AEAA7657F09018B864F4EF_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.RuntimeFieldHandle
struct RuntimeFieldHandle_t844BDF00E8E6FE69D9AEAA7657F09018B864F4EF
{
public:
// System.IntPtr System.RuntimeFieldHandle::value
intptr_t ___value_0;
public:
inline static int32_t get_offset_of_value_0() { return static_cast<int32_t>(offsetof(RuntimeFieldHandle_t844BDF00E8E6FE69D9AEAA7657F09018B864F4EF, ___value_0)); }
inline intptr_t get_value_0() const { return ___value_0; }
inline intptr_t* get_address_of_value_0() { return &___value_0; }
inline void set_value_0(intptr_t value)
{
___value_0 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // RUNTIMEFIELDHANDLE_T844BDF00E8E6FE69D9AEAA7657F09018B864F4EF_H
#ifndef RUNTIMEMETHODHANDLE_T85058E06EFF8AE085FAB91CE2B9E28E7F6FAE33F_H
#define RUNTIMEMETHODHANDLE_T85058E06EFF8AE085FAB91CE2B9E28E7F6FAE33F_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.RuntimeMethodHandle
struct RuntimeMethodHandle_t85058E06EFF8AE085FAB91CE2B9E28E7F6FAE33F
{
public:
// System.IntPtr System.RuntimeMethodHandle::value
intptr_t ___value_0;
public:
inline static int32_t get_offset_of_value_0() { return static_cast<int32_t>(offsetof(RuntimeMethodHandle_t85058E06EFF8AE085FAB91CE2B9E28E7F6FAE33F, ___value_0)); }
inline intptr_t get_value_0() const { return ___value_0; }
inline intptr_t* get_address_of_value_0() { return &___value_0; }
inline void set_value_0(intptr_t value)
{
___value_0 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // RUNTIMEMETHODHANDLE_T85058E06EFF8AE085FAB91CE2B9E28E7F6FAE33F_H
#ifndef RUNTIMETYPEHANDLE_T7B542280A22F0EC4EAC2061C29178845847A8B2D_H
#define RUNTIMETYPEHANDLE_T7B542280A22F0EC4EAC2061C29178845847A8B2D_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.RuntimeTypeHandle
struct RuntimeTypeHandle_t7B542280A22F0EC4EAC2061C29178845847A8B2D
{
public:
// System.IntPtr System.RuntimeTypeHandle::value
intptr_t ___value_0;
public:
inline static int32_t get_offset_of_value_0() { return static_cast<int32_t>(offsetof(RuntimeTypeHandle_t7B542280A22F0EC4EAC2061C29178845847A8B2D, ___value_0)); }
inline intptr_t get_value_0() const { return ___value_0; }
inline intptr_t* get_address_of_value_0() { return &___value_0; }
inline void set_value_0(intptr_t value)
{
___value_0 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // RUNTIMETYPEHANDLE_T7B542280A22F0EC4EAC2061C29178845847A8B2D_H
#ifndef SBYTEENUM_T0EC157A9E311E27D76141202576E15FA4E83E0EE_H
#define SBYTEENUM_T0EC157A9E311E27D76141202576E15FA4E83E0EE_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.SByteEnum
struct SByteEnum_t0EC157A9E311E27D76141202576E15FA4E83E0EE
{
public:
// System.SByte System.SByteEnum::value__
int8_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(SByteEnum_t0EC157A9E311E27D76141202576E15FA4E83E0EE, ___value___2)); }
inline int8_t get_value___2() const { return ___value___2; }
inline int8_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(int8_t value)
{
___value___2 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // SBYTEENUM_T0EC157A9E311E27D76141202576E15FA4E83E0EE_H
#ifndef STRINGCOMPARISON_T02BAA95468CE9E91115C604577611FDF58FEDCF0_H
#define STRINGCOMPARISON_T02BAA95468CE9E91115C604577611FDF58FEDCF0_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.StringComparison
struct StringComparison_t02BAA95468CE9E91115C604577611FDF58FEDCF0
{
public:
// System.Int32 System.StringComparison::value__
int32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(StringComparison_t02BAA95468CE9E91115C604577611FDF58FEDCF0, ___value___2)); }
inline int32_t get_value___2() const { return ___value___2; }
inline int32_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(int32_t value)
{
___value___2 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // STRINGCOMPARISON_T02BAA95468CE9E91115C604577611FDF58FEDCF0_H
#ifndef TERMINFONUMBERS_TE17C1E4A28232B0A786FAB261BD41BA350DF230B_H
#define TERMINFONUMBERS_TE17C1E4A28232B0A786FAB261BD41BA350DF230B_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.TermInfoNumbers
struct TermInfoNumbers_tE17C1E4A28232B0A786FAB261BD41BA350DF230B
{
public:
// System.Int32 System.TermInfoNumbers::value__
int32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(TermInfoNumbers_tE17C1E4A28232B0A786FAB261BD41BA350DF230B, ___value___2)); }
inline int32_t get_value___2() const { return ___value___2; }
inline int32_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(int32_t value)
{
___value___2 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // TERMINFONUMBERS_TE17C1E4A28232B0A786FAB261BD41BA350DF230B_H
#ifndef TERMINFOSTRINGS_TA50FD6AB2B4EFB66E90CD563942E0A664FD6022F_H
#define TERMINFOSTRINGS_TA50FD6AB2B4EFB66E90CD563942E0A664FD6022F_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.TermInfoStrings
struct TermInfoStrings_tA50FD6AB2B4EFB66E90CD563942E0A664FD6022F
{
public:
// System.Int32 System.TermInfoStrings::value__
int32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(TermInfoStrings_tA50FD6AB2B4EFB66E90CD563942E0A664FD6022F, ___value___2)); }
inline int32_t get_value___2() const { return ___value___2; }
inline int32_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(int32_t value)
{
___value___2 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // TERMINFOSTRINGS_TA50FD6AB2B4EFB66E90CD563942E0A664FD6022F_H
#ifndef TYPECODE_T03ED52F888000DAF40C550C434F29F39A23D61C6_H
#define TYPECODE_T03ED52F888000DAF40C550C434F29F39A23D61C6_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.TypeCode
struct TypeCode_t03ED52F888000DAF40C550C434F29F39A23D61C6
{
public:
// System.Int32 System.TypeCode::value__
int32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(TypeCode_t03ED52F888000DAF40C550C434F29F39A23D61C6, ___value___2)); }
inline int32_t get_value___2() const { return ___value___2; }
inline int32_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(int32_t value)
{
___value___2 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // TYPECODE_T03ED52F888000DAF40C550C434F29F39A23D61C6_H
#ifndef DISPLAYNAMEFORMAT_TFEA54E2FCA44D62D61CCCE98E4F02DE2D186DF47_H
#define DISPLAYNAMEFORMAT_TFEA54E2FCA44D62D61CCCE98E4F02DE2D186DF47_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.TypeSpec_DisplayNameFormat
struct DisplayNameFormat_tFEA54E2FCA44D62D61CCCE98E4F02DE2D186DF47
{
public:
// System.Int32 System.TypeSpec_DisplayNameFormat::value__
int32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(DisplayNameFormat_tFEA54E2FCA44D62D61CCCE98E4F02DE2D186DF47, ___value___2)); }
inline int32_t get_value___2() const { return ___value___2; }
inline int32_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(int32_t value)
{
___value___2 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // DISPLAYNAMEFORMAT_TFEA54E2FCA44D62D61CCCE98E4F02DE2D186DF47_H
#ifndef UINT16ENUM_TB3380938EFBC6B524E2C8143A7982637F0EA4456_H
#define UINT16ENUM_TB3380938EFBC6B524E2C8143A7982637F0EA4456_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.UInt16Enum
struct UInt16Enum_tB3380938EFBC6B524E2C8143A7982637F0EA4456
{
public:
// System.UInt16 System.UInt16Enum::value__
uint16_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(UInt16Enum_tB3380938EFBC6B524E2C8143A7982637F0EA4456, ___value___2)); }
inline uint16_t get_value___2() const { return ___value___2; }
inline uint16_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(uint16_t value)
{
___value___2 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // UINT16ENUM_TB3380938EFBC6B524E2C8143A7982637F0EA4456_H
#ifndef UINT32ENUM_TE44175EB3151A633676D60A642EDA3BD5C6760DA_H
#define UINT32ENUM_TE44175EB3151A633676D60A642EDA3BD5C6760DA_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.UInt32Enum
struct UInt32Enum_tE44175EB3151A633676D60A642EDA3BD5C6760DA
{
public:
// System.UInt32 System.UInt32Enum::value__
uint32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(UInt32Enum_tE44175EB3151A633676D60A642EDA3BD5C6760DA, ___value___2)); }
inline uint32_t get_value___2() const { return ___value___2; }
inline uint32_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(uint32_t value)
{
___value___2 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // UINT32ENUM_TE44175EB3151A633676D60A642EDA3BD5C6760DA_H
#ifndef UINT64ENUM_TEAD217F175F60689A664303784384DEF759D24C8_H
#define UINT64ENUM_TEAD217F175F60689A664303784384DEF759D24C8_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.UInt64Enum
struct UInt64Enum_tEAD217F175F60689A664303784384DEF759D24C8
{
public:
// System.UInt64 System.UInt64Enum::value__
uint64_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(UInt64Enum_tEAD217F175F60689A664303784384DEF759D24C8, ___value___2)); }
inline uint64_t get_value___2() const { return ___value___2; }
inline uint64_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(uint64_t value)
{
___value___2 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // UINT64ENUM_TEAD217F175F60689A664303784384DEF759D24C8_H
#ifndef PARSEFAILUREKIND_T0E37E87ACF3E01D5D2846A114AE9247C2C7DC3E8_H
#define PARSEFAILUREKIND_T0E37E87ACF3E01D5D2846A114AE9247C2C7DC3E8_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Version_ParseFailureKind
struct ParseFailureKind_t0E37E87ACF3E01D5D2846A114AE9247C2C7DC3E8
{
public:
// System.Int32 System.Version_ParseFailureKind::value__
int32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(ParseFailureKind_t0E37E87ACF3E01D5D2846A114AE9247C2C7DC3E8, ___value___2)); }
inline int32_t get_value___2() const { return ___value___2; }
inline int32_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(int32_t value)
{
___value___2 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // PARSEFAILUREKIND_T0E37E87ACF3E01D5D2846A114AE9247C2C7DC3E8_H
#ifndef WEAKREFERENCE_T0495CC81CD6403E662B7700B802443F6F730E39D_H
#define WEAKREFERENCE_T0495CC81CD6403E662B7700B802443F6F730E39D_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.WeakReference
struct WeakReference_t0495CC81CD6403E662B7700B802443F6F730E39D : public RuntimeObject
{
public:
// System.Boolean System.WeakReference::isLongReference
bool ___isLongReference_0;
// System.Runtime.InteropServices.GCHandle System.WeakReference::gcHandle
GCHandle_t39FAEE3EA592432C93B574A31DD83B87F1847DE3 ___gcHandle_1;
public:
inline static int32_t get_offset_of_isLongReference_0() { return static_cast<int32_t>(offsetof(WeakReference_t0495CC81CD6403E662B7700B802443F6F730E39D, ___isLongReference_0)); }
inline bool get_isLongReference_0() const { return ___isLongReference_0; }
inline bool* get_address_of_isLongReference_0() { return &___isLongReference_0; }
inline void set_isLongReference_0(bool value)
{
___isLongReference_0 = value;
}
inline static int32_t get_offset_of_gcHandle_1() { return static_cast<int32_t>(offsetof(WeakReference_t0495CC81CD6403E662B7700B802443F6F730E39D, ___gcHandle_1)); }
inline GCHandle_t39FAEE3EA592432C93B574A31DD83B87F1847DE3 get_gcHandle_1() const { return ___gcHandle_1; }
inline GCHandle_t39FAEE3EA592432C93B574A31DD83B87F1847DE3 * get_address_of_gcHandle_1() { return &___gcHandle_1; }
inline void set_gcHandle_1(GCHandle_t39FAEE3EA592432C93B574A31DD83B87F1847DE3 value)
{
___gcHandle_1 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // WEAKREFERENCE_T0495CC81CD6403E662B7700B802443F6F730E39D_H
#ifndef WINDOWSCONSOLEDRIVER_T953AB92956013BD3ED7E260FEC4944E603008B42_H
#define WINDOWSCONSOLEDRIVER_T953AB92956013BD3ED7E260FEC4944E603008B42_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.WindowsConsoleDriver
struct WindowsConsoleDriver_t953AB92956013BD3ED7E260FEC4944E603008B42 : public RuntimeObject
{
public:
// System.IntPtr System.WindowsConsoleDriver::inputHandle
intptr_t ___inputHandle_0;
// System.IntPtr System.WindowsConsoleDriver::outputHandle
intptr_t ___outputHandle_1;
// System.Int16 System.WindowsConsoleDriver::defaultAttribute
int16_t ___defaultAttribute_2;
public:
inline static int32_t get_offset_of_inputHandle_0() { return static_cast<int32_t>(offsetof(WindowsConsoleDriver_t953AB92956013BD3ED7E260FEC4944E603008B42, ___inputHandle_0)); }
inline intptr_t get_inputHandle_0() const { return ___inputHandle_0; }
inline intptr_t* get_address_of_inputHandle_0() { return &___inputHandle_0; }
inline void set_inputHandle_0(intptr_t value)
{
___inputHandle_0 = value;
}
inline static int32_t get_offset_of_outputHandle_1() { return static_cast<int32_t>(offsetof(WindowsConsoleDriver_t953AB92956013BD3ED7E260FEC4944E603008B42, ___outputHandle_1)); }
inline intptr_t get_outputHandle_1() const { return ___outputHandle_1; }
inline intptr_t* get_address_of_outputHandle_1() { return &___outputHandle_1; }
inline void set_outputHandle_1(intptr_t value)
{
___outputHandle_1 = value;
}
inline static int32_t get_offset_of_defaultAttribute_2() { return static_cast<int32_t>(offsetof(WindowsConsoleDriver_t953AB92956013BD3ED7E260FEC4944E603008B42, ___defaultAttribute_2)); }
inline int16_t get_defaultAttribute_2() const { return ___defaultAttribute_2; }
inline int16_t* get_address_of_defaultAttribute_2() { return &___defaultAttribute_2; }
inline void set_defaultAttribute_2(int16_t value)
{
___defaultAttribute_2 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // WINDOWSCONSOLEDRIVER_T953AB92956013BD3ED7E260FEC4944E603008B42_H
#ifndef CONSOLEKEYINFO_T5BE3CE05E8258CDB5404256E96AF7C22BC5DE768_H
#define CONSOLEKEYINFO_T5BE3CE05E8258CDB5404256E96AF7C22BC5DE768_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.ConsoleKeyInfo
struct ConsoleKeyInfo_t5BE3CE05E8258CDB5404256E96AF7C22BC5DE768
{
public:
// System.Char System.ConsoleKeyInfo::_keyChar
Il2CppChar ____keyChar_0;
// System.ConsoleKey System.ConsoleKeyInfo::_key
int32_t ____key_1;
// System.ConsoleModifiers System.ConsoleKeyInfo::_mods
int32_t ____mods_2;
public:
inline static int32_t get_offset_of__keyChar_0() { return static_cast<int32_t>(offsetof(ConsoleKeyInfo_t5BE3CE05E8258CDB5404256E96AF7C22BC5DE768, ____keyChar_0)); }
inline Il2CppChar get__keyChar_0() const { return ____keyChar_0; }
inline Il2CppChar* get_address_of__keyChar_0() { return &____keyChar_0; }
inline void set__keyChar_0(Il2CppChar value)
{
____keyChar_0 = value;
}
inline static int32_t get_offset_of__key_1() { return static_cast<int32_t>(offsetof(ConsoleKeyInfo_t5BE3CE05E8258CDB5404256E96AF7C22BC5DE768, ____key_1)); }
inline int32_t get__key_1() const { return ____key_1; }
inline int32_t* get_address_of__key_1() { return &____key_1; }
inline void set__key_1(int32_t value)
{
____key_1 = value;
}
inline static int32_t get_offset_of__mods_2() { return static_cast<int32_t>(offsetof(ConsoleKeyInfo_t5BE3CE05E8258CDB5404256E96AF7C22BC5DE768, ____mods_2)); }
inline int32_t get__mods_2() const { return ____mods_2; }
inline int32_t* get_address_of__mods_2() { return &____mods_2; }
inline void set__mods_2(int32_t value)
{
____mods_2 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
// Native definition for P/Invoke marshalling of System.ConsoleKeyInfo
struct ConsoleKeyInfo_t5BE3CE05E8258CDB5404256E96AF7C22BC5DE768_marshaled_pinvoke
{
uint8_t ____keyChar_0;
int32_t ____key_1;
int32_t ____mods_2;
};
// Native definition for COM marshalling of System.ConsoleKeyInfo
struct ConsoleKeyInfo_t5BE3CE05E8258CDB5404256E96AF7C22BC5DE768_marshaled_com
{
uint8_t ____keyChar_0;
int32_t ____key_1;
int32_t ____mods_2;
};
#endif // CONSOLEKEYINFO_T5BE3CE05E8258CDB5404256E96AF7C22BC5DE768_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_t
{
public:
// System.Delegate[] System.MulticastDelegate::delegates
DelegateU5BU5D_tDFCDEE2A6322F96C0FE49AF47E9ADB8C4B294E86* ___delegates_11;
public:
inline static int32_t get_offset_of_delegates_11() { return static_cast<int32_t>(offsetof(MulticastDelegate_t, ___delegates_11)); }
inline DelegateU5BU5D_tDFCDEE2A6322F96C0FE49AF47E9ADB8C4B294E86* get_delegates_11() const { return ___delegates_11; }
inline DelegateU5BU5D_tDFCDEE2A6322F96C0FE49AF47E9ADB8C4B294E86** get_address_of_delegates_11() { return &___delegates_11; }
inline void set_delegates_11(DelegateU5BU5D_tDFCDEE2A6322F96C0FE49AF47E9ADB8C4B294E86* value)
{
___delegates_11 = value;
Il2CppCodeGenWriteBarrier((&___delegates_11), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
// Native definition for P/Invoke marshalling of System.MulticastDelegate
struct MulticastDelegate_t_marshaled_pinvoke : public Delegate_t_marshaled_pinvoke
{
Delegate_t_marshaled_pinvoke** ___delegates_11;
};
// Native definition for COM marshalling of System.MulticastDelegate
struct MulticastDelegate_t_marshaled_com : public Delegate_t_marshaled_com
{
Delegate_t_marshaled_com** ___delegates_11;
};
#endif // MULTICASTDELEGATE_T_H
#ifndef OPERATINGSYSTEM_TBB05846D5AA6960FFEB42C59E5FE359255C2BE83_H
#define OPERATINGSYSTEM_TBB05846D5AA6960FFEB42C59E5FE359255C2BE83_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.OperatingSystem
struct OperatingSystem_tBB05846D5AA6960FFEB42C59E5FE359255C2BE83 : public RuntimeObject
{
public:
// System.PlatformID System.OperatingSystem::_platform
int32_t ____platform_0;
// System.Version System.OperatingSystem::_version
Version_tDBE6876C59B6F56D4F8CAA03851177ABC6FE0DFD * ____version_1;
// System.String System.OperatingSystem::_servicePack
String_t* ____servicePack_2;
public:
inline static int32_t get_offset_of__platform_0() { return static_cast<int32_t>(offsetof(OperatingSystem_tBB05846D5AA6960FFEB42C59E5FE359255C2BE83, ____platform_0)); }
inline int32_t get__platform_0() const { return ____platform_0; }
inline int32_t* get_address_of__platform_0() { return &____platform_0; }
inline void set__platform_0(int32_t value)
{
____platform_0 = value;
}
inline static int32_t get_offset_of__version_1() { return static_cast<int32_t>(offsetof(OperatingSystem_tBB05846D5AA6960FFEB42C59E5FE359255C2BE83, ____version_1)); }
inline Version_tDBE6876C59B6F56D4F8CAA03851177ABC6FE0DFD * get__version_1() const { return ____version_1; }
inline Version_tDBE6876C59B6F56D4F8CAA03851177ABC6FE0DFD ** get_address_of__version_1() { return &____version_1; }
inline void set__version_1(Version_tDBE6876C59B6F56D4F8CAA03851177ABC6FE0DFD * value)
{
____version_1 = value;
Il2CppCodeGenWriteBarrier((&____version_1), value);
}
inline static int32_t get_offset_of__servicePack_2() { return static_cast<int32_t>(offsetof(OperatingSystem_tBB05846D5AA6960FFEB42C59E5FE359255C2BE83, ____servicePack_2)); }
inline String_t* get__servicePack_2() const { return ____servicePack_2; }
inline String_t** get_address_of__servicePack_2() { return &____servicePack_2; }
inline void set__servicePack_2(String_t* value)
{
____servicePack_2 = value;
Il2CppCodeGenWriteBarrier((&____servicePack_2), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // OPERATINGSYSTEM_TBB05846D5AA6960FFEB42C59E5FE359255C2BE83_H
#ifndef TERMINFODRIVER_T9D1F8B74E923C24C63FBE861B6DDCE7CF05A3653_H
#define TERMINFODRIVER_T9D1F8B74E923C24C63FBE861B6DDCE7CF05A3653_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.TermInfoDriver
struct TermInfoDriver_t9D1F8B74E923C24C63FBE861B6DDCE7CF05A3653 : public RuntimeObject
{
public:
// System.TermInfoReader System.TermInfoDriver::reader
TermInfoReader_tCAABF3484E6F0AA298F809766C52CA9DC4E6C55C * ___reader_3;
// System.Int32 System.TermInfoDriver::cursorLeft
int32_t ___cursorLeft_4;
// System.Int32 System.TermInfoDriver::cursorTop
int32_t ___cursorTop_5;
// System.String System.TermInfoDriver::title
String_t* ___title_6;
// System.String System.TermInfoDriver::titleFormat
String_t* ___titleFormat_7;
// System.Boolean System.TermInfoDriver::cursorVisible
bool ___cursorVisible_8;
// System.String System.TermInfoDriver::csrVisible
String_t* ___csrVisible_9;
// System.String System.TermInfoDriver::csrInvisible
String_t* ___csrInvisible_10;
// System.String System.TermInfoDriver::clear
String_t* ___clear_11;
// System.String System.TermInfoDriver::bell
String_t* ___bell_12;
// System.String System.TermInfoDriver::term
String_t* ___term_13;
// System.IO.StreamReader System.TermInfoDriver::stdin
StreamReader_t62E68063760DCD2FC036AE132DE69C24B7ED001E * ___stdin_14;
// System.IO.CStreamWriter System.TermInfoDriver::stdout
CStreamWriter_t6B662CA496662AF63D81722DCA99094893C80450 * ___stdout_15;
// System.Int32 System.TermInfoDriver::windowWidth
int32_t ___windowWidth_16;
// System.Int32 System.TermInfoDriver::windowHeight
int32_t ___windowHeight_17;
// System.Int32 System.TermInfoDriver::bufferHeight
int32_t ___bufferHeight_18;
// System.Int32 System.TermInfoDriver::bufferWidth
int32_t ___bufferWidth_19;
// System.Char[] System.TermInfoDriver::buffer
CharU5BU5D_t4CC6ABF0AD71BEC97E3C2F1E9C5677E46D3A75C2* ___buffer_20;
// System.Int32 System.TermInfoDriver::readpos
int32_t ___readpos_21;
// System.Int32 System.TermInfoDriver::writepos
int32_t ___writepos_22;
// System.String System.TermInfoDriver::keypadXmit
String_t* ___keypadXmit_23;
// System.String System.TermInfoDriver::keypadLocal
String_t* ___keypadLocal_24;
// System.Boolean System.TermInfoDriver::inited
bool ___inited_25;
// System.Object System.TermInfoDriver::initLock
RuntimeObject * ___initLock_26;
// System.Boolean System.TermInfoDriver::initKeys
bool ___initKeys_27;
// System.String System.TermInfoDriver::origPair
String_t* ___origPair_28;
// System.String System.TermInfoDriver::origColors
String_t* ___origColors_29;
// System.String System.TermInfoDriver::cursorAddress
String_t* ___cursorAddress_30;
// System.ConsoleColor System.TermInfoDriver::fgcolor
int32_t ___fgcolor_31;
// System.String System.TermInfoDriver::setfgcolor
String_t* ___setfgcolor_32;
// System.String System.TermInfoDriver::setbgcolor
String_t* ___setbgcolor_33;
// System.Int32 System.TermInfoDriver::maxColors
int32_t ___maxColors_34;
// System.Boolean System.TermInfoDriver::noGetPosition
bool ___noGetPosition_35;
// System.Collections.Hashtable System.TermInfoDriver::keymap
Hashtable_t978F65B8006C8F5504B286526AEC6608FF983FC9 * ___keymap_36;
// System.ByteMatcher System.TermInfoDriver::rootmap
ByteMatcher_tB199BDD35E2575B84D9FDED34954705653D241DC * ___rootmap_37;
// System.Int32 System.TermInfoDriver::rl_startx
int32_t ___rl_startx_38;
// System.Int32 System.TermInfoDriver::rl_starty
int32_t ___rl_starty_39;
// System.Byte[] System.TermInfoDriver::control_characters
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* ___control_characters_40;
// System.Char[] System.TermInfoDriver::echobuf
CharU5BU5D_t4CC6ABF0AD71BEC97E3C2F1E9C5677E46D3A75C2* ___echobuf_42;
// System.Int32 System.TermInfoDriver::echon
int32_t ___echon_43;
public:
inline static int32_t get_offset_of_reader_3() { return static_cast<int32_t>(offsetof(TermInfoDriver_t9D1F8B74E923C24C63FBE861B6DDCE7CF05A3653, ___reader_3)); }
inline TermInfoReader_tCAABF3484E6F0AA298F809766C52CA9DC4E6C55C * get_reader_3() const { return ___reader_3; }
inline TermInfoReader_tCAABF3484E6F0AA298F809766C52CA9DC4E6C55C ** get_address_of_reader_3() { return &___reader_3; }
inline void set_reader_3(TermInfoReader_tCAABF3484E6F0AA298F809766C52CA9DC4E6C55C * value)
{
___reader_3 = value;
Il2CppCodeGenWriteBarrier((&___reader_3), value);
}
inline static int32_t get_offset_of_cursorLeft_4() { return static_cast<int32_t>(offsetof(TermInfoDriver_t9D1F8B74E923C24C63FBE861B6DDCE7CF05A3653, ___cursorLeft_4)); }
inline int32_t get_cursorLeft_4() const { return ___cursorLeft_4; }
inline int32_t* get_address_of_cursorLeft_4() { return &___cursorLeft_4; }
inline void set_cursorLeft_4(int32_t value)
{
___cursorLeft_4 = value;
}
inline static int32_t get_offset_of_cursorTop_5() { return static_cast<int32_t>(offsetof(TermInfoDriver_t9D1F8B74E923C24C63FBE861B6DDCE7CF05A3653, ___cursorTop_5)); }
inline int32_t get_cursorTop_5() const { return ___cursorTop_5; }
inline int32_t* get_address_of_cursorTop_5() { return &___cursorTop_5; }
inline void set_cursorTop_5(int32_t value)
{
___cursorTop_5 = value;
}
inline static int32_t get_offset_of_title_6() { return static_cast<int32_t>(offsetof(TermInfoDriver_t9D1F8B74E923C24C63FBE861B6DDCE7CF05A3653, ___title_6)); }
inline String_t* get_title_6() const { return ___title_6; }
inline String_t** get_address_of_title_6() { return &___title_6; }
inline void set_title_6(String_t* value)
{
___title_6 = value;
Il2CppCodeGenWriteBarrier((&___title_6), value);
}
inline static int32_t get_offset_of_titleFormat_7() { return static_cast<int32_t>(offsetof(TermInfoDriver_t9D1F8B74E923C24C63FBE861B6DDCE7CF05A3653, ___titleFormat_7)); }
inline String_t* get_titleFormat_7() const { return ___titleFormat_7; }
inline String_t** get_address_of_titleFormat_7() { return &___titleFormat_7; }
inline void set_titleFormat_7(String_t* value)
{
___titleFormat_7 = value;
Il2CppCodeGenWriteBarrier((&___titleFormat_7), value);
}
inline static int32_t get_offset_of_cursorVisible_8() { return static_cast<int32_t>(offsetof(TermInfoDriver_t9D1F8B74E923C24C63FBE861B6DDCE7CF05A3653, ___cursorVisible_8)); }
inline bool get_cursorVisible_8() const { return ___cursorVisible_8; }
inline bool* get_address_of_cursorVisible_8() { return &___cursorVisible_8; }
inline void set_cursorVisible_8(bool value)
{
___cursorVisible_8 = value;
}
inline static int32_t get_offset_of_csrVisible_9() { return static_cast<int32_t>(offsetof(TermInfoDriver_t9D1F8B74E923C24C63FBE861B6DDCE7CF05A3653, ___csrVisible_9)); }
inline String_t* get_csrVisible_9() const { return ___csrVisible_9; }
inline String_t** get_address_of_csrVisible_9() { return &___csrVisible_9; }
inline void set_csrVisible_9(String_t* value)
{
___csrVisible_9 = value;
Il2CppCodeGenWriteBarrier((&___csrVisible_9), value);
}
inline static int32_t get_offset_of_csrInvisible_10() { return static_cast<int32_t>(offsetof(TermInfoDriver_t9D1F8B74E923C24C63FBE861B6DDCE7CF05A3653, ___csrInvisible_10)); }
inline String_t* get_csrInvisible_10() const { return ___csrInvisible_10; }
inline String_t** get_address_of_csrInvisible_10() { return &___csrInvisible_10; }
inline void set_csrInvisible_10(String_t* value)
{
___csrInvisible_10 = value;
Il2CppCodeGenWriteBarrier((&___csrInvisible_10), value);
}
inline static int32_t get_offset_of_clear_11() { return static_cast<int32_t>(offsetof(TermInfoDriver_t9D1F8B74E923C24C63FBE861B6DDCE7CF05A3653, ___clear_11)); }
inline String_t* get_clear_11() const { return ___clear_11; }
inline String_t** get_address_of_clear_11() { return &___clear_11; }
inline void set_clear_11(String_t* value)
{
___clear_11 = value;
Il2CppCodeGenWriteBarrier((&___clear_11), value);
}
inline static int32_t get_offset_of_bell_12() { return static_cast<int32_t>(offsetof(TermInfoDriver_t9D1F8B74E923C24C63FBE861B6DDCE7CF05A3653, ___bell_12)); }
inline String_t* get_bell_12() const { return ___bell_12; }
inline String_t** get_address_of_bell_12() { return &___bell_12; }
inline void set_bell_12(String_t* value)
{
___bell_12 = value;
Il2CppCodeGenWriteBarrier((&___bell_12), value);
}
inline static int32_t get_offset_of_term_13() { return static_cast<int32_t>(offsetof(TermInfoDriver_t9D1F8B74E923C24C63FBE861B6DDCE7CF05A3653, ___term_13)); }
inline String_t* get_term_13() const { return ___term_13; }
inline String_t** get_address_of_term_13() { return &___term_13; }
inline void set_term_13(String_t* value)
{
___term_13 = value;
Il2CppCodeGenWriteBarrier((&___term_13), value);
}
inline static int32_t get_offset_of_stdin_14() { return static_cast<int32_t>(offsetof(TermInfoDriver_t9D1F8B74E923C24C63FBE861B6DDCE7CF05A3653, ___stdin_14)); }
inline StreamReader_t62E68063760DCD2FC036AE132DE69C24B7ED001E * get_stdin_14() const { return ___stdin_14; }
inline StreamReader_t62E68063760DCD2FC036AE132DE69C24B7ED001E ** get_address_of_stdin_14() { return &___stdin_14; }
inline void set_stdin_14(StreamReader_t62E68063760DCD2FC036AE132DE69C24B7ED001E * value)
{
___stdin_14 = value;
Il2CppCodeGenWriteBarrier((&___stdin_14), value);
}
inline static int32_t get_offset_of_stdout_15() { return static_cast<int32_t>(offsetof(TermInfoDriver_t9D1F8B74E923C24C63FBE861B6DDCE7CF05A3653, ___stdout_15)); }
inline CStreamWriter_t6B662CA496662AF63D81722DCA99094893C80450 * get_stdout_15() const { return ___stdout_15; }
inline CStreamWriter_t6B662CA496662AF63D81722DCA99094893C80450 ** get_address_of_stdout_15() { return &___stdout_15; }
inline void set_stdout_15(CStreamWriter_t6B662CA496662AF63D81722DCA99094893C80450 * value)
{
___stdout_15 = value;
Il2CppCodeGenWriteBarrier((&___stdout_15), value);
}
inline static int32_t get_offset_of_windowWidth_16() { return static_cast<int32_t>(offsetof(TermInfoDriver_t9D1F8B74E923C24C63FBE861B6DDCE7CF05A3653, ___windowWidth_16)); }
inline int32_t get_windowWidth_16() const { return ___windowWidth_16; }
inline int32_t* get_address_of_windowWidth_16() { return &___windowWidth_16; }
inline void set_windowWidth_16(int32_t value)
{
___windowWidth_16 = value;
}
inline static int32_t get_offset_of_windowHeight_17() { return static_cast<int32_t>(offsetof(TermInfoDriver_t9D1F8B74E923C24C63FBE861B6DDCE7CF05A3653, ___windowHeight_17)); }
inline int32_t get_windowHeight_17() const { return ___windowHeight_17; }
inline int32_t* get_address_of_windowHeight_17() { return &___windowHeight_17; }
inline void set_windowHeight_17(int32_t value)
{
___windowHeight_17 = value;
}
inline static int32_t get_offset_of_bufferHeight_18() { return static_cast<int32_t>(offsetof(TermInfoDriver_t9D1F8B74E923C24C63FBE861B6DDCE7CF05A3653, ___bufferHeight_18)); }
inline int32_t get_bufferHeight_18() const { return ___bufferHeight_18; }
inline int32_t* get_address_of_bufferHeight_18() { return &___bufferHeight_18; }
inline void set_bufferHeight_18(int32_t value)
{
___bufferHeight_18 = value;
}
inline static int32_t get_offset_of_bufferWidth_19() { return static_cast<int32_t>(offsetof(TermInfoDriver_t9D1F8B74E923C24C63FBE861B6DDCE7CF05A3653, ___bufferWidth_19)); }
inline int32_t get_bufferWidth_19() const { return ___bufferWidth_19; }
inline int32_t* get_address_of_bufferWidth_19() { return &___bufferWidth_19; }
inline void set_bufferWidth_19(int32_t value)
{
___bufferWidth_19 = value;
}
inline static int32_t get_offset_of_buffer_20() { return static_cast<int32_t>(offsetof(TermInfoDriver_t9D1F8B74E923C24C63FBE861B6DDCE7CF05A3653, ___buffer_20)); }
inline CharU5BU5D_t4CC6ABF0AD71BEC97E3C2F1E9C5677E46D3A75C2* get_buffer_20() const { return ___buffer_20; }
inline CharU5BU5D_t4CC6ABF0AD71BEC97E3C2F1E9C5677E46D3A75C2** get_address_of_buffer_20() { return &___buffer_20; }
inline void set_buffer_20(CharU5BU5D_t4CC6ABF0AD71BEC97E3C2F1E9C5677E46D3A75C2* value)
{
___buffer_20 = value;
Il2CppCodeGenWriteBarrier((&___buffer_20), value);
}
inline static int32_t get_offset_of_readpos_21() { return static_cast<int32_t>(offsetof(TermInfoDriver_t9D1F8B74E923C24C63FBE861B6DDCE7CF05A3653, ___readpos_21)); }
inline int32_t get_readpos_21() const { return ___readpos_21; }
inline int32_t* get_address_of_readpos_21() { return &___readpos_21; }
inline void set_readpos_21(int32_t value)
{
___readpos_21 = value;
}
inline static int32_t get_offset_of_writepos_22() { return static_cast<int32_t>(offsetof(TermInfoDriver_t9D1F8B74E923C24C63FBE861B6DDCE7CF05A3653, ___writepos_22)); }
inline int32_t get_writepos_22() const { return ___writepos_22; }
inline int32_t* get_address_of_writepos_22() { return &___writepos_22; }
inline void set_writepos_22(int32_t value)
{
___writepos_22 = value;
}
inline static int32_t get_offset_of_keypadXmit_23() { return static_cast<int32_t>(offsetof(TermInfoDriver_t9D1F8B74E923C24C63FBE861B6DDCE7CF05A3653, ___keypadXmit_23)); }
inline String_t* get_keypadXmit_23() const { return ___keypadXmit_23; }
inline String_t** get_address_of_keypadXmit_23() { return &___keypadXmit_23; }
inline void set_keypadXmit_23(String_t* value)
{
___keypadXmit_23 = value;
Il2CppCodeGenWriteBarrier((&___keypadXmit_23), value);
}
inline static int32_t get_offset_of_keypadLocal_24() { return static_cast<int32_t>(offsetof(TermInfoDriver_t9D1F8B74E923C24C63FBE861B6DDCE7CF05A3653, ___keypadLocal_24)); }
inline String_t* get_keypadLocal_24() const { return ___keypadLocal_24; }
inline String_t** get_address_of_keypadLocal_24() { return &___keypadLocal_24; }
inline void set_keypadLocal_24(String_t* value)
{
___keypadLocal_24 = value;
Il2CppCodeGenWriteBarrier((&___keypadLocal_24), value);
}
inline static int32_t get_offset_of_inited_25() { return static_cast<int32_t>(offsetof(TermInfoDriver_t9D1F8B74E923C24C63FBE861B6DDCE7CF05A3653, ___inited_25)); }
inline bool get_inited_25() const { return ___inited_25; }
inline bool* get_address_of_inited_25() { return &___inited_25; }
inline void set_inited_25(bool value)
{
___inited_25 = value;
}
inline static int32_t get_offset_of_initLock_26() { return static_cast<int32_t>(offsetof(TermInfoDriver_t9D1F8B74E923C24C63FBE861B6DDCE7CF05A3653, ___initLock_26)); }
inline RuntimeObject * get_initLock_26() const { return ___initLock_26; }
inline RuntimeObject ** get_address_of_initLock_26() { return &___initLock_26; }
inline void set_initLock_26(RuntimeObject * value)
{
___initLock_26 = value;
Il2CppCodeGenWriteBarrier((&___initLock_26), value);
}
inline static int32_t get_offset_of_initKeys_27() { return static_cast<int32_t>(offsetof(TermInfoDriver_t9D1F8B74E923C24C63FBE861B6DDCE7CF05A3653, ___initKeys_27)); }
inline bool get_initKeys_27() const { return ___initKeys_27; }
inline bool* get_address_of_initKeys_27() { return &___initKeys_27; }
inline void set_initKeys_27(bool value)
{
___initKeys_27 = value;
}
inline static int32_t get_offset_of_origPair_28() { return static_cast<int32_t>(offsetof(TermInfoDriver_t9D1F8B74E923C24C63FBE861B6DDCE7CF05A3653, ___origPair_28)); }
inline String_t* get_origPair_28() const { return ___origPair_28; }
inline String_t** get_address_of_origPair_28() { return &___origPair_28; }
inline void set_origPair_28(String_t* value)
{
___origPair_28 = value;
Il2CppCodeGenWriteBarrier((&___origPair_28), value);
}
inline static int32_t get_offset_of_origColors_29() { return static_cast<int32_t>(offsetof(TermInfoDriver_t9D1F8B74E923C24C63FBE861B6DDCE7CF05A3653, ___origColors_29)); }
inline String_t* get_origColors_29() const { return ___origColors_29; }
inline String_t** get_address_of_origColors_29() { return &___origColors_29; }
inline void set_origColors_29(String_t* value)
{
___origColors_29 = value;
Il2CppCodeGenWriteBarrier((&___origColors_29), value);
}
inline static int32_t get_offset_of_cursorAddress_30() { return static_cast<int32_t>(offsetof(TermInfoDriver_t9D1F8B74E923C24C63FBE861B6DDCE7CF05A3653, ___cursorAddress_30)); }
inline String_t* get_cursorAddress_30() const { return ___cursorAddress_30; }
inline String_t** get_address_of_cursorAddress_30() { return &___cursorAddress_30; }
inline void set_cursorAddress_30(String_t* value)
{
___cursorAddress_30 = value;
Il2CppCodeGenWriteBarrier((&___cursorAddress_30), value);
}
inline static int32_t get_offset_of_fgcolor_31() { return static_cast<int32_t>(offsetof(TermInfoDriver_t9D1F8B74E923C24C63FBE861B6DDCE7CF05A3653, ___fgcolor_31)); }
inline int32_t get_fgcolor_31() const { return ___fgcolor_31; }
inline int32_t* get_address_of_fgcolor_31() { return &___fgcolor_31; }
inline void set_fgcolor_31(int32_t value)
{
___fgcolor_31 = value;
}
inline static int32_t get_offset_of_setfgcolor_32() { return static_cast<int32_t>(offsetof(TermInfoDriver_t9D1F8B74E923C24C63FBE861B6DDCE7CF05A3653, ___setfgcolor_32)); }
inline String_t* get_setfgcolor_32() const { return ___setfgcolor_32; }
inline String_t** get_address_of_setfgcolor_32() { return &___setfgcolor_32; }
inline void set_setfgcolor_32(String_t* value)
{
___setfgcolor_32 = value;
Il2CppCodeGenWriteBarrier((&___setfgcolor_32), value);
}
inline static int32_t get_offset_of_setbgcolor_33() { return static_cast<int32_t>(offsetof(TermInfoDriver_t9D1F8B74E923C24C63FBE861B6DDCE7CF05A3653, ___setbgcolor_33)); }
inline String_t* get_setbgcolor_33() const { return ___setbgcolor_33; }
inline String_t** get_address_of_setbgcolor_33() { return &___setbgcolor_33; }
inline void set_setbgcolor_33(String_t* value)
{
___setbgcolor_33 = value;
Il2CppCodeGenWriteBarrier((&___setbgcolor_33), value);
}
inline static int32_t get_offset_of_maxColors_34() { return static_cast<int32_t>(offsetof(TermInfoDriver_t9D1F8B74E923C24C63FBE861B6DDCE7CF05A3653, ___maxColors_34)); }
inline int32_t get_maxColors_34() const { return ___maxColors_34; }
inline int32_t* get_address_of_maxColors_34() { return &___maxColors_34; }
inline void set_maxColors_34(int32_t value)
{
___maxColors_34 = value;
}
inline static int32_t get_offset_of_noGetPosition_35() { return static_cast<int32_t>(offsetof(TermInfoDriver_t9D1F8B74E923C24C63FBE861B6DDCE7CF05A3653, ___noGetPosition_35)); }
inline bool get_noGetPosition_35() const { return ___noGetPosition_35; }
inline bool* get_address_of_noGetPosition_35() { return &___noGetPosition_35; }
inline void set_noGetPosition_35(bool value)
{
___noGetPosition_35 = value;
}
inline static int32_t get_offset_of_keymap_36() { return static_cast<int32_t>(offsetof(TermInfoDriver_t9D1F8B74E923C24C63FBE861B6DDCE7CF05A3653, ___keymap_36)); }
inline Hashtable_t978F65B8006C8F5504B286526AEC6608FF983FC9 * get_keymap_36() const { return ___keymap_36; }
inline Hashtable_t978F65B8006C8F5504B286526AEC6608FF983FC9 ** get_address_of_keymap_36() { return &___keymap_36; }
inline void set_keymap_36(Hashtable_t978F65B8006C8F5504B286526AEC6608FF983FC9 * value)
{
___keymap_36 = value;
Il2CppCodeGenWriteBarrier((&___keymap_36), value);
}
inline static int32_t get_offset_of_rootmap_37() { return static_cast<int32_t>(offsetof(TermInfoDriver_t9D1F8B74E923C24C63FBE861B6DDCE7CF05A3653, ___rootmap_37)); }
inline ByteMatcher_tB199BDD35E2575B84D9FDED34954705653D241DC * get_rootmap_37() const { return ___rootmap_37; }
inline ByteMatcher_tB199BDD35E2575B84D9FDED34954705653D241DC ** get_address_of_rootmap_37() { return &___rootmap_37; }
inline void set_rootmap_37(ByteMatcher_tB199BDD35E2575B84D9FDED34954705653D241DC * value)
{
___rootmap_37 = value;
Il2CppCodeGenWriteBarrier((&___rootmap_37), value);
}
inline static int32_t get_offset_of_rl_startx_38() { return static_cast<int32_t>(offsetof(TermInfoDriver_t9D1F8B74E923C24C63FBE861B6DDCE7CF05A3653, ___rl_startx_38)); }
inline int32_t get_rl_startx_38() const { return ___rl_startx_38; }
inline int32_t* get_address_of_rl_startx_38() { return &___rl_startx_38; }
inline void set_rl_startx_38(int32_t value)
{
___rl_startx_38 = value;
}
inline static int32_t get_offset_of_rl_starty_39() { return static_cast<int32_t>(offsetof(TermInfoDriver_t9D1F8B74E923C24C63FBE861B6DDCE7CF05A3653, ___rl_starty_39)); }
inline int32_t get_rl_starty_39() const { return ___rl_starty_39; }
inline int32_t* get_address_of_rl_starty_39() { return &___rl_starty_39; }
inline void set_rl_starty_39(int32_t value)
{
___rl_starty_39 = value;
}
inline static int32_t get_offset_of_control_characters_40() { return static_cast<int32_t>(offsetof(TermInfoDriver_t9D1F8B74E923C24C63FBE861B6DDCE7CF05A3653, ___control_characters_40)); }
inline ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* get_control_characters_40() const { return ___control_characters_40; }
inline ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821** get_address_of_control_characters_40() { return &___control_characters_40; }
inline void set_control_characters_40(ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* value)
{
___control_characters_40 = value;
Il2CppCodeGenWriteBarrier((&___control_characters_40), value);
}
inline static int32_t get_offset_of_echobuf_42() { return static_cast<int32_t>(offsetof(TermInfoDriver_t9D1F8B74E923C24C63FBE861B6DDCE7CF05A3653, ___echobuf_42)); }
inline CharU5BU5D_t4CC6ABF0AD71BEC97E3C2F1E9C5677E46D3A75C2* get_echobuf_42() const { return ___echobuf_42; }
inline CharU5BU5D_t4CC6ABF0AD71BEC97E3C2F1E9C5677E46D3A75C2** get_address_of_echobuf_42() { return &___echobuf_42; }
inline void set_echobuf_42(CharU5BU5D_t4CC6ABF0AD71BEC97E3C2F1E9C5677E46D3A75C2* value)
{
___echobuf_42 = value;
Il2CppCodeGenWriteBarrier((&___echobuf_42), value);
}
inline static int32_t get_offset_of_echon_43() { return static_cast<int32_t>(offsetof(TermInfoDriver_t9D1F8B74E923C24C63FBE861B6DDCE7CF05A3653, ___echon_43)); }
inline int32_t get_echon_43() const { return ___echon_43; }
inline int32_t* get_address_of_echon_43() { return &___echon_43; }
inline void set_echon_43(int32_t value)
{
___echon_43 = value;
}
};
struct TermInfoDriver_t9D1F8B74E923C24C63FBE861B6DDCE7CF05A3653_StaticFields
{
public:
// System.Int32* System.TermInfoDriver::native_terminal_size
int32_t* ___native_terminal_size_0;
// System.Int32 System.TermInfoDriver::terminal_size
int32_t ___terminal_size_1;
// System.String[] System.TermInfoDriver::locations
StringU5BU5D_t933FB07893230EA91C40FF900D5400665E87B14E* ___locations_2;
// System.Int32[] System.TermInfoDriver::_consoleColorToAnsiCode
Int32U5BU5D_t2B9E4FDDDB9F0A00EC0AC631BA2DA915EB1ECF83* ____consoleColorToAnsiCode_41;
public:
inline static int32_t get_offset_of_native_terminal_size_0() { return static_cast<int32_t>(offsetof(TermInfoDriver_t9D1F8B74E923C24C63FBE861B6DDCE7CF05A3653_StaticFields, ___native_terminal_size_0)); }
inline int32_t* get_native_terminal_size_0() const { return ___native_terminal_size_0; }
inline int32_t** get_address_of_native_terminal_size_0() { return &___native_terminal_size_0; }
inline void set_native_terminal_size_0(int32_t* value)
{
___native_terminal_size_0 = value;
}
inline static int32_t get_offset_of_terminal_size_1() { return static_cast<int32_t>(offsetof(TermInfoDriver_t9D1F8B74E923C24C63FBE861B6DDCE7CF05A3653_StaticFields, ___terminal_size_1)); }
inline int32_t get_terminal_size_1() const { return ___terminal_size_1; }
inline int32_t* get_address_of_terminal_size_1() { return &___terminal_size_1; }
inline void set_terminal_size_1(int32_t value)
{
___terminal_size_1 = value;
}
inline static int32_t get_offset_of_locations_2() { return static_cast<int32_t>(offsetof(TermInfoDriver_t9D1F8B74E923C24C63FBE861B6DDCE7CF05A3653_StaticFields, ___locations_2)); }
inline StringU5BU5D_t933FB07893230EA91C40FF900D5400665E87B14E* get_locations_2() const { return ___locations_2; }
inline StringU5BU5D_t933FB07893230EA91C40FF900D5400665E87B14E** get_address_of_locations_2() { return &___locations_2; }
inline void set_locations_2(StringU5BU5D_t933FB07893230EA91C40FF900D5400665E87B14E* value)
{
___locations_2 = value;
Il2CppCodeGenWriteBarrier((&___locations_2), value);
}
inline static int32_t get_offset_of__consoleColorToAnsiCode_41() { return static_cast<int32_t>(offsetof(TermInfoDriver_t9D1F8B74E923C24C63FBE861B6DDCE7CF05A3653_StaticFields, ____consoleColorToAnsiCode_41)); }
inline Int32U5BU5D_t2B9E4FDDDB9F0A00EC0AC631BA2DA915EB1ECF83* get__consoleColorToAnsiCode_41() const { return ____consoleColorToAnsiCode_41; }
inline Int32U5BU5D_t2B9E4FDDDB9F0A00EC0AC631BA2DA915EB1ECF83** get_address_of__consoleColorToAnsiCode_41() { return &____consoleColorToAnsiCode_41; }
inline void set__consoleColorToAnsiCode_41(Int32U5BU5D_t2B9E4FDDDB9F0A00EC0AC631BA2DA915EB1ECF83* value)
{
____consoleColorToAnsiCode_41 = value;
Il2CppCodeGenWriteBarrier((&____consoleColorToAnsiCode_41), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // TERMINFODRIVER_T9D1F8B74E923C24C63FBE861B6DDCE7CF05A3653_H
#ifndef TYPE_T_H
#define TYPE_T_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Type
struct Type_t : public MemberInfo_t
{
public:
// System.RuntimeTypeHandle System.Type::_impl
RuntimeTypeHandle_t7B542280A22F0EC4EAC2061C29178845847A8B2D ____impl_9;
public:
inline static int32_t get_offset_of__impl_9() { return static_cast<int32_t>(offsetof(Type_t, ____impl_9)); }
inline RuntimeTypeHandle_t7B542280A22F0EC4EAC2061C29178845847A8B2D get__impl_9() const { return ____impl_9; }
inline RuntimeTypeHandle_t7B542280A22F0EC4EAC2061C29178845847A8B2D * get_address_of__impl_9() { return &____impl_9; }
inline void set__impl_9(RuntimeTypeHandle_t7B542280A22F0EC4EAC2061C29178845847A8B2D value)
{
____impl_9 = value;
}
};
struct Type_t_StaticFields
{
public:
// System.Reflection.MemberFilter System.Type::FilterAttribute
MemberFilter_t25C1BD92C42BE94426E300787C13C452CB89B381 * ___FilterAttribute_0;
// System.Reflection.MemberFilter System.Type::FilterName
MemberFilter_t25C1BD92C42BE94426E300787C13C452CB89B381 * ___FilterName_1;
// System.Reflection.MemberFilter System.Type::FilterNameIgnoreCase
MemberFilter_t25C1BD92C42BE94426E300787C13C452CB89B381 * ___FilterNameIgnoreCase_2;
// System.Object System.Type::Missing
RuntimeObject * ___Missing_3;
// System.Char System.Type::Delimiter
Il2CppChar ___Delimiter_4;
// System.Type[] System.Type::EmptyTypes
TypeU5BU5D_t7FE623A666B49176DE123306221193E888A12F5F* ___EmptyTypes_5;
// System.Reflection.Binder System.Type::defaultBinder
Binder_t4D5CB06963501D32847C057B57157D6DC49CA759 * ___defaultBinder_6;
public:
inline static int32_t get_offset_of_FilterAttribute_0() { return static_cast<int32_t>(offsetof(Type_t_StaticFields, ___FilterAttribute_0)); }
inline MemberFilter_t25C1BD92C42BE94426E300787C13C452CB89B381 * get_FilterAttribute_0() const { return ___FilterAttribute_0; }
inline MemberFilter_t25C1BD92C42BE94426E300787C13C452CB89B381 ** get_address_of_FilterAttribute_0() { return &___FilterAttribute_0; }
inline void set_FilterAttribute_0(MemberFilter_t25C1BD92C42BE94426E300787C13C452CB89B381 * value)
{
___FilterAttribute_0 = value;
Il2CppCodeGenWriteBarrier((&___FilterAttribute_0), value);
}
inline static int32_t get_offset_of_FilterName_1() { return static_cast<int32_t>(offsetof(Type_t_StaticFields, ___FilterName_1)); }
inline MemberFilter_t25C1BD92C42BE94426E300787C13C452CB89B381 * get_FilterName_1() const { return ___FilterName_1; }
inline MemberFilter_t25C1BD92C42BE94426E300787C13C452CB89B381 ** get_address_of_FilterName_1() { return &___FilterName_1; }
inline void set_FilterName_1(MemberFilter_t25C1BD92C42BE94426E300787C13C452CB89B381 * value)
{
___FilterName_1 = value;
Il2CppCodeGenWriteBarrier((&___FilterName_1), value);
}
inline static int32_t get_offset_of_FilterNameIgnoreCase_2() { return static_cast<int32_t>(offsetof(Type_t_StaticFields, ___FilterNameIgnoreCase_2)); }
inline MemberFilter_t25C1BD92C42BE94426E300787C13C452CB89B381 * get_FilterNameIgnoreCase_2() const { return ___FilterNameIgnoreCase_2; }
inline MemberFilter_t25C1BD92C42BE94426E300787C13C452CB89B381 ** get_address_of_FilterNameIgnoreCase_2() { return &___FilterNameIgnoreCase_2; }
inline void set_FilterNameIgnoreCase_2(MemberFilter_t25C1BD92C42BE94426E300787C13C452CB89B381 * value)
{
___FilterNameIgnoreCase_2 = value;
Il2CppCodeGenWriteBarrier((&___FilterNameIgnoreCase_2), value);
}
inline static int32_t get_offset_of_Missing_3() { return static_cast<int32_t>(offsetof(Type_t_StaticFields, ___Missing_3)); }
inline RuntimeObject * get_Missing_3() const { return ___Missing_3; }
inline RuntimeObject ** get_address_of_Missing_3() { return &___Missing_3; }
inline void set_Missing_3(RuntimeObject * value)
{
___Missing_3 = value;
Il2CppCodeGenWriteBarrier((&___Missing_3), value);
}
inline static int32_t get_offset_of_Delimiter_4() { return static_cast<int32_t>(offsetof(Type_t_StaticFields, ___Delimiter_4)); }
inline Il2CppChar get_Delimiter_4() const { return ___Delimiter_4; }
inline Il2CppChar* get_address_of_Delimiter_4() { return &___Delimiter_4; }
inline void set_Delimiter_4(Il2CppChar value)
{
___Delimiter_4 = value;
}
inline static int32_t get_offset_of_EmptyTypes_5() { return static_cast<int32_t>(offsetof(Type_t_StaticFields, ___EmptyTypes_5)); }
inline TypeU5BU5D_t7FE623A666B49176DE123306221193E888A12F5F* get_EmptyTypes_5() const { return ___EmptyTypes_5; }
inline TypeU5BU5D_t7FE623A666B49176DE123306221193E888A12F5F** get_address_of_EmptyTypes_5() { return &___EmptyTypes_5; }
inline void set_EmptyTypes_5(TypeU5BU5D_t7FE623A666B49176DE123306221193E888A12F5F* value)
{
___EmptyTypes_5 = value;
Il2CppCodeGenWriteBarrier((&___EmptyTypes_5), value);
}
inline static int32_t get_offset_of_defaultBinder_6() { return static_cast<int32_t>(offsetof(Type_t_StaticFields, ___defaultBinder_6)); }
inline Binder_t4D5CB06963501D32847C057B57157D6DC49CA759 * get_defaultBinder_6() const { return ___defaultBinder_6; }
inline Binder_t4D5CB06963501D32847C057B57157D6DC49CA759 ** get_address_of_defaultBinder_6() { return &___defaultBinder_6; }
inline void set_defaultBinder_6(Binder_t4D5CB06963501D32847C057B57157D6DC49CA759 * value)
{
___defaultBinder_6 = value;
Il2CppCodeGenWriteBarrier((&___defaultBinder_6), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // TYPE_T_H
#ifndef VARIANT_TBC94A369178CDE161E918F24FD18166A3DC58C18_H
#define VARIANT_TBC94A369178CDE161E918F24FD18166A3DC58C18_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Variant
struct Variant_tBC94A369178CDE161E918F24FD18166A3DC58C18
{
public:
union
{
#pragma pack(push, tp, 1)
struct
{
// System.Int16 System.Variant::vt
int16_t ___vt_0;
};
#pragma pack(pop, tp)
struct
{
int16_t ___vt_0_forAlignmentOnly;
};
#pragma pack(push, tp, 1)
struct
{
char ___wReserved1_1_OffsetPadding[2];
// System.UInt16 System.Variant::wReserved1
uint16_t ___wReserved1_1;
};
#pragma pack(pop, tp)
struct
{
char ___wReserved1_1_OffsetPadding_forAlignmentOnly[2];
uint16_t ___wReserved1_1_forAlignmentOnly;
};
#pragma pack(push, tp, 1)
struct
{
char ___wReserved2_2_OffsetPadding[4];
// System.UInt16 System.Variant::wReserved2
uint16_t ___wReserved2_2;
};
#pragma pack(pop, tp)
struct
{
char ___wReserved2_2_OffsetPadding_forAlignmentOnly[4];
uint16_t ___wReserved2_2_forAlignmentOnly;
};
#pragma pack(push, tp, 1)
struct
{
char ___wReserved3_3_OffsetPadding[6];
// System.UInt16 System.Variant::wReserved3
uint16_t ___wReserved3_3;
};
#pragma pack(pop, tp)
struct
{
char ___wReserved3_3_OffsetPadding_forAlignmentOnly[6];
uint16_t ___wReserved3_3_forAlignmentOnly;
};
#pragma pack(push, tp, 1)
struct
{
char ___llVal_4_OffsetPadding[8];
// System.Int64 System.Variant::llVal
int64_t ___llVal_4;
};
#pragma pack(pop, tp)
struct
{
char ___llVal_4_OffsetPadding_forAlignmentOnly[8];
int64_t ___llVal_4_forAlignmentOnly;
};
#pragma pack(push, tp, 1)
struct
{
char ___lVal_5_OffsetPadding[8];
// System.Int32 System.Variant::lVal
int32_t ___lVal_5;
};
#pragma pack(pop, tp)
struct
{
char ___lVal_5_OffsetPadding_forAlignmentOnly[8];
int32_t ___lVal_5_forAlignmentOnly;
};
#pragma pack(push, tp, 1)
struct
{
char ___bVal_6_OffsetPadding[8];
// System.Byte System.Variant::bVal
uint8_t ___bVal_6;
};
#pragma pack(pop, tp)
struct
{
char ___bVal_6_OffsetPadding_forAlignmentOnly[8];
uint8_t ___bVal_6_forAlignmentOnly;
};
#pragma pack(push, tp, 1)
struct
{
char ___iVal_7_OffsetPadding[8];
// System.Int16 System.Variant::iVal
int16_t ___iVal_7;
};
#pragma pack(pop, tp)
struct
{
char ___iVal_7_OffsetPadding_forAlignmentOnly[8];
int16_t ___iVal_7_forAlignmentOnly;
};
#pragma pack(push, tp, 1)
struct
{
char ___fltVal_8_OffsetPadding[8];
// System.Single System.Variant::fltVal
float ___fltVal_8;
};
#pragma pack(pop, tp)
struct
{
char ___fltVal_8_OffsetPadding_forAlignmentOnly[8];
float ___fltVal_8_forAlignmentOnly;
};
#pragma pack(push, tp, 1)
struct
{
char ___dblVal_9_OffsetPadding[8];
// System.Double System.Variant::dblVal
double ___dblVal_9;
};
#pragma pack(pop, tp)
struct
{
char ___dblVal_9_OffsetPadding_forAlignmentOnly[8];
double ___dblVal_9_forAlignmentOnly;
};
#pragma pack(push, tp, 1)
struct
{
char ___boolVal_10_OffsetPadding[8];
// System.Int16 System.Variant::boolVal
int16_t ___boolVal_10;
};
#pragma pack(pop, tp)
struct
{
char ___boolVal_10_OffsetPadding_forAlignmentOnly[8];
int16_t ___boolVal_10_forAlignmentOnly;
};
#pragma pack(push, tp, 1)
struct
{
char ___bstrVal_11_OffsetPadding[8];
// System.IntPtr System.Variant::bstrVal
intptr_t ___bstrVal_11;
};
#pragma pack(pop, tp)
struct
{
char ___bstrVal_11_OffsetPadding_forAlignmentOnly[8];
intptr_t ___bstrVal_11_forAlignmentOnly;
};
#pragma pack(push, tp, 1)
struct
{
char ___cVal_12_OffsetPadding[8];
// System.SByte System.Variant::cVal
int8_t ___cVal_12;
};
#pragma pack(pop, tp)
struct
{
char ___cVal_12_OffsetPadding_forAlignmentOnly[8];
int8_t ___cVal_12_forAlignmentOnly;
};
#pragma pack(push, tp, 1)
struct
{
char ___uiVal_13_OffsetPadding[8];
// System.UInt16 System.Variant::uiVal
uint16_t ___uiVal_13;
};
#pragma pack(pop, tp)
struct
{
char ___uiVal_13_OffsetPadding_forAlignmentOnly[8];
uint16_t ___uiVal_13_forAlignmentOnly;
};
#pragma pack(push, tp, 1)
struct
{
char ___ulVal_14_OffsetPadding[8];
// System.UInt32 System.Variant::ulVal
uint32_t ___ulVal_14;
};
#pragma pack(pop, tp)
struct
{
char ___ulVal_14_OffsetPadding_forAlignmentOnly[8];
uint32_t ___ulVal_14_forAlignmentOnly;
};
#pragma pack(push, tp, 1)
struct
{
char ___ullVal_15_OffsetPadding[8];
// System.UInt64 System.Variant::ullVal
uint64_t ___ullVal_15;
};
#pragma pack(pop, tp)
struct
{
char ___ullVal_15_OffsetPadding_forAlignmentOnly[8];
uint64_t ___ullVal_15_forAlignmentOnly;
};
#pragma pack(push, tp, 1)
struct
{
char ___intVal_16_OffsetPadding[8];
// System.Int32 System.Variant::intVal
int32_t ___intVal_16;
};
#pragma pack(pop, tp)
struct
{
char ___intVal_16_OffsetPadding_forAlignmentOnly[8];
int32_t ___intVal_16_forAlignmentOnly;
};
#pragma pack(push, tp, 1)
struct
{
char ___uintVal_17_OffsetPadding[8];
// System.UInt32 System.Variant::uintVal
uint32_t ___uintVal_17;
};
#pragma pack(pop, tp)
struct
{
char ___uintVal_17_OffsetPadding_forAlignmentOnly[8];
uint32_t ___uintVal_17_forAlignmentOnly;
};
#pragma pack(push, tp, 1)
struct
{
char ___pdispVal_18_OffsetPadding[8];
// System.IntPtr System.Variant::pdispVal
intptr_t ___pdispVal_18;
};
#pragma pack(pop, tp)
struct
{
char ___pdispVal_18_OffsetPadding_forAlignmentOnly[8];
intptr_t ___pdispVal_18_forAlignmentOnly;
};
#pragma pack(push, tp, 1)
struct
{
char ___bRecord_19_OffsetPadding[8];
// System.BRECORD System.Variant::bRecord
BRECORD_tDDC5F1A5DC569C234C6141FCBA5F8DE8293BC601 ___bRecord_19;
};
#pragma pack(pop, tp)
struct
{
char ___bRecord_19_OffsetPadding_forAlignmentOnly[8];
BRECORD_tDDC5F1A5DC569C234C6141FCBA5F8DE8293BC601 ___bRecord_19_forAlignmentOnly;
};
};
public:
inline static int32_t get_offset_of_vt_0() { return static_cast<int32_t>(offsetof(Variant_tBC94A369178CDE161E918F24FD18166A3DC58C18, ___vt_0)); }
inline int16_t get_vt_0() const { return ___vt_0; }
inline int16_t* get_address_of_vt_0() { return &___vt_0; }
inline void set_vt_0(int16_t value)
{
___vt_0 = value;
}
inline static int32_t get_offset_of_wReserved1_1() { return static_cast<int32_t>(offsetof(Variant_tBC94A369178CDE161E918F24FD18166A3DC58C18, ___wReserved1_1)); }
inline uint16_t get_wReserved1_1() const { return ___wReserved1_1; }
inline uint16_t* get_address_of_wReserved1_1() { return &___wReserved1_1; }
inline void set_wReserved1_1(uint16_t value)
{
___wReserved1_1 = value;
}
inline static int32_t get_offset_of_wReserved2_2() { return static_cast<int32_t>(offsetof(Variant_tBC94A369178CDE161E918F24FD18166A3DC58C18, ___wReserved2_2)); }
inline uint16_t get_wReserved2_2() const { return ___wReserved2_2; }
inline uint16_t* get_address_of_wReserved2_2() { return &___wReserved2_2; }
inline void set_wReserved2_2(uint16_t value)
{
___wReserved2_2 = value;
}
inline static int32_t get_offset_of_wReserved3_3() { return static_cast<int32_t>(offsetof(Variant_tBC94A369178CDE161E918F24FD18166A3DC58C18, ___wReserved3_3)); }
inline uint16_t get_wReserved3_3() const { return ___wReserved3_3; }
inline uint16_t* get_address_of_wReserved3_3() { return &___wReserved3_3; }
inline void set_wReserved3_3(uint16_t value)
{
___wReserved3_3 = value;
}
inline static int32_t get_offset_of_llVal_4() { return static_cast<int32_t>(offsetof(Variant_tBC94A369178CDE161E918F24FD18166A3DC58C18, ___llVal_4)); }
inline int64_t get_llVal_4() const { return ___llVal_4; }
inline int64_t* get_address_of_llVal_4() { return &___llVal_4; }
inline void set_llVal_4(int64_t value)
{
___llVal_4 = value;
}
inline static int32_t get_offset_of_lVal_5() { return static_cast<int32_t>(offsetof(Variant_tBC94A369178CDE161E918F24FD18166A3DC58C18, ___lVal_5)); }
inline int32_t get_lVal_5() const { return ___lVal_5; }
inline int32_t* get_address_of_lVal_5() { return &___lVal_5; }
inline void set_lVal_5(int32_t value)
{
___lVal_5 = value;
}
inline static int32_t get_offset_of_bVal_6() { return static_cast<int32_t>(offsetof(Variant_tBC94A369178CDE161E918F24FD18166A3DC58C18, ___bVal_6)); }
inline uint8_t get_bVal_6() const { return ___bVal_6; }
inline uint8_t* get_address_of_bVal_6() { return &___bVal_6; }
inline void set_bVal_6(uint8_t value)
{
___bVal_6 = value;
}
inline static int32_t get_offset_of_iVal_7() { return static_cast<int32_t>(offsetof(Variant_tBC94A369178CDE161E918F24FD18166A3DC58C18, ___iVal_7)); }
inline int16_t get_iVal_7() const { return ___iVal_7; }
inline int16_t* get_address_of_iVal_7() { return &___iVal_7; }
inline void set_iVal_7(int16_t value)
{
___iVal_7 = value;
}
inline static int32_t get_offset_of_fltVal_8() { return static_cast<int32_t>(offsetof(Variant_tBC94A369178CDE161E918F24FD18166A3DC58C18, ___fltVal_8)); }
inline float get_fltVal_8() const { return ___fltVal_8; }
inline float* get_address_of_fltVal_8() { return &___fltVal_8; }
inline void set_fltVal_8(float value)
{
___fltVal_8 = value;
}
inline static int32_t get_offset_of_dblVal_9() { return static_cast<int32_t>(offsetof(Variant_tBC94A369178CDE161E918F24FD18166A3DC58C18, ___dblVal_9)); }
inline double get_dblVal_9() const { return ___dblVal_9; }
inline double* get_address_of_dblVal_9() { return &___dblVal_9; }
inline void set_dblVal_9(double value)
{
___dblVal_9 = value;
}
inline static int32_t get_offset_of_boolVal_10() { return static_cast<int32_t>(offsetof(Variant_tBC94A369178CDE161E918F24FD18166A3DC58C18, ___boolVal_10)); }
inline int16_t get_boolVal_10() const { return ___boolVal_10; }
inline int16_t* get_address_of_boolVal_10() { return &___boolVal_10; }
inline void set_boolVal_10(int16_t value)
{
___boolVal_10 = value;
}
inline static int32_t get_offset_of_bstrVal_11() { return static_cast<int32_t>(offsetof(Variant_tBC94A369178CDE161E918F24FD18166A3DC58C18, ___bstrVal_11)); }
inline intptr_t get_bstrVal_11() const { return ___bstrVal_11; }
inline intptr_t* get_address_of_bstrVal_11() { return &___bstrVal_11; }
inline void set_bstrVal_11(intptr_t value)
{
___bstrVal_11 = value;
}
inline static int32_t get_offset_of_cVal_12() { return static_cast<int32_t>(offsetof(Variant_tBC94A369178CDE161E918F24FD18166A3DC58C18, ___cVal_12)); }
inline int8_t get_cVal_12() const { return ___cVal_12; }
inline int8_t* get_address_of_cVal_12() { return &___cVal_12; }
inline void set_cVal_12(int8_t value)
{
___cVal_12 = value;
}
inline static int32_t get_offset_of_uiVal_13() { return static_cast<int32_t>(offsetof(Variant_tBC94A369178CDE161E918F24FD18166A3DC58C18, ___uiVal_13)); }
inline uint16_t get_uiVal_13() const { return ___uiVal_13; }
inline uint16_t* get_address_of_uiVal_13() { return &___uiVal_13; }
inline void set_uiVal_13(uint16_t value)
{
___uiVal_13 = value;
}
inline static int32_t get_offset_of_ulVal_14() { return static_cast<int32_t>(offsetof(Variant_tBC94A369178CDE161E918F24FD18166A3DC58C18, ___ulVal_14)); }
inline uint32_t get_ulVal_14() const { return ___ulVal_14; }
inline uint32_t* get_address_of_ulVal_14() { return &___ulVal_14; }
inline void set_ulVal_14(uint32_t value)
{
___ulVal_14 = value;
}
inline static int32_t get_offset_of_ullVal_15() { return static_cast<int32_t>(offsetof(Variant_tBC94A369178CDE161E918F24FD18166A3DC58C18, ___ullVal_15)); }
inline uint64_t get_ullVal_15() const { return ___ullVal_15; }
inline uint64_t* get_address_of_ullVal_15() { return &___ullVal_15; }
inline void set_ullVal_15(uint64_t value)
{
___ullVal_15 = value;
}
inline static int32_t get_offset_of_intVal_16() { return static_cast<int32_t>(offsetof(Variant_tBC94A369178CDE161E918F24FD18166A3DC58C18, ___intVal_16)); }
inline int32_t get_intVal_16() const { return ___intVal_16; }
inline int32_t* get_address_of_intVal_16() { return &___intVal_16; }
inline void set_intVal_16(int32_t value)
{
___intVal_16 = value;
}
inline static int32_t get_offset_of_uintVal_17() { return static_cast<int32_t>(offsetof(Variant_tBC94A369178CDE161E918F24FD18166A3DC58C18, ___uintVal_17)); }
inline uint32_t get_uintVal_17() const { return ___uintVal_17; }
inline uint32_t* get_address_of_uintVal_17() { return &___uintVal_17; }
inline void set_uintVal_17(uint32_t value)
{
___uintVal_17 = value;
}
inline static int32_t get_offset_of_pdispVal_18() { return static_cast<int32_t>(offsetof(Variant_tBC94A369178CDE161E918F24FD18166A3DC58C18, ___pdispVal_18)); }
inline intptr_t get_pdispVal_18() const { return ___pdispVal_18; }
inline intptr_t* get_address_of_pdispVal_18() { return &___pdispVal_18; }
inline void set_pdispVal_18(intptr_t value)
{
___pdispVal_18 = value;
}
inline static int32_t get_offset_of_bRecord_19() { return static_cast<int32_t>(offsetof(Variant_tBC94A369178CDE161E918F24FD18166A3DC58C18, ___bRecord_19)); }
inline BRECORD_tDDC5F1A5DC569C234C6141FCBA5F8DE8293BC601 get_bRecord_19() const { return ___bRecord_19; }
inline BRECORD_tDDC5F1A5DC569C234C6141FCBA5F8DE8293BC601 * get_address_of_bRecord_19() { return &___bRecord_19; }
inline void set_bRecord_19(BRECORD_tDDC5F1A5DC569C234C6141FCBA5F8DE8293BC601 value)
{
___bRecord_19 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // VARIANT_TBC94A369178CDE161E918F24FD18166A3DC58C18_H
#ifndef VERSIONRESULT_TA97F3FDF3CF3FF5D0E43768C08D1C4D4568E88CE_H
#define VERSIONRESULT_TA97F3FDF3CF3FF5D0E43768C08D1C4D4568E88CE_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Version_VersionResult
struct VersionResult_tA97F3FDF3CF3FF5D0E43768C08D1C4D4568E88CE
{
public:
// System.Version System.Version_VersionResult::m_parsedVersion
Version_tDBE6876C59B6F56D4F8CAA03851177ABC6FE0DFD * ___m_parsedVersion_0;
// System.Version_ParseFailureKind System.Version_VersionResult::m_failure
int32_t ___m_failure_1;
// System.String System.Version_VersionResult::m_exceptionArgument
String_t* ___m_exceptionArgument_2;
// System.String System.Version_VersionResult::m_argumentName
String_t* ___m_argumentName_3;
// System.Boolean System.Version_VersionResult::m_canThrow
bool ___m_canThrow_4;
public:
inline static int32_t get_offset_of_m_parsedVersion_0() { return static_cast<int32_t>(offsetof(VersionResult_tA97F3FDF3CF3FF5D0E43768C08D1C4D4568E88CE, ___m_parsedVersion_0)); }
inline Version_tDBE6876C59B6F56D4F8CAA03851177ABC6FE0DFD * get_m_parsedVersion_0() const { return ___m_parsedVersion_0; }
inline Version_tDBE6876C59B6F56D4F8CAA03851177ABC6FE0DFD ** get_address_of_m_parsedVersion_0() { return &___m_parsedVersion_0; }
inline void set_m_parsedVersion_0(Version_tDBE6876C59B6F56D4F8CAA03851177ABC6FE0DFD * value)
{
___m_parsedVersion_0 = value;
Il2CppCodeGenWriteBarrier((&___m_parsedVersion_0), value);
}
inline static int32_t get_offset_of_m_failure_1() { return static_cast<int32_t>(offsetof(VersionResult_tA97F3FDF3CF3FF5D0E43768C08D1C4D4568E88CE, ___m_failure_1)); }
inline int32_t get_m_failure_1() const { return ___m_failure_1; }
inline int32_t* get_address_of_m_failure_1() { return &___m_failure_1; }
inline void set_m_failure_1(int32_t value)
{
___m_failure_1 = value;
}
inline static int32_t get_offset_of_m_exceptionArgument_2() { return static_cast<int32_t>(offsetof(VersionResult_tA97F3FDF3CF3FF5D0E43768C08D1C4D4568E88CE, ___m_exceptionArgument_2)); }
inline String_t* get_m_exceptionArgument_2() const { return ___m_exceptionArgument_2; }
inline String_t** get_address_of_m_exceptionArgument_2() { return &___m_exceptionArgument_2; }
inline void set_m_exceptionArgument_2(String_t* value)
{
___m_exceptionArgument_2 = value;
Il2CppCodeGenWriteBarrier((&___m_exceptionArgument_2), value);
}
inline static int32_t get_offset_of_m_argumentName_3() { return static_cast<int32_t>(offsetof(VersionResult_tA97F3FDF3CF3FF5D0E43768C08D1C4D4568E88CE, ___m_argumentName_3)); }
inline String_t* get_m_argumentName_3() const { return ___m_argumentName_3; }
inline String_t** get_address_of_m_argumentName_3() { return &___m_argumentName_3; }
inline void set_m_argumentName_3(String_t* value)
{
___m_argumentName_3 = value;
Il2CppCodeGenWriteBarrier((&___m_argumentName_3), value);
}
inline static int32_t get_offset_of_m_canThrow_4() { return static_cast<int32_t>(offsetof(VersionResult_tA97F3FDF3CF3FF5D0E43768C08D1C4D4568E88CE, ___m_canThrow_4)); }
inline bool get_m_canThrow_4() const { return ___m_canThrow_4; }
inline bool* get_address_of_m_canThrow_4() { return &___m_canThrow_4; }
inline void set_m_canThrow_4(bool value)
{
___m_canThrow_4 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
// Native definition for P/Invoke marshalling of System.Version/VersionResult
struct VersionResult_tA97F3FDF3CF3FF5D0E43768C08D1C4D4568E88CE_marshaled_pinvoke
{
Version_tDBE6876C59B6F56D4F8CAA03851177ABC6FE0DFD * ___m_parsedVersion_0;
int32_t ___m_failure_1;
char* ___m_exceptionArgument_2;
char* ___m_argumentName_3;
int32_t ___m_canThrow_4;
};
// Native definition for COM marshalling of System.Version/VersionResult
struct VersionResult_tA97F3FDF3CF3FF5D0E43768C08D1C4D4568E88CE_marshaled_com
{
Version_tDBE6876C59B6F56D4F8CAA03851177ABC6FE0DFD * ___m_parsedVersion_0;
int32_t ___m_failure_1;
Il2CppChar* ___m_exceptionArgument_2;
Il2CppChar* ___m_argumentName_3;
int32_t ___m_canThrow_4;
};
#endif // VERSIONRESULT_TA97F3FDF3CF3FF5D0E43768C08D1C4D4568E88CE_H
#ifndef ASSEMBLYLOADEVENTHANDLER_T53F8340027F9EE67E8A22E7D8C1A3770345153C9_H
#define ASSEMBLYLOADEVENTHANDLER_T53F8340027F9EE67E8A22E7D8C1A3770345153C9_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.AssemblyLoadEventHandler
struct AssemblyLoadEventHandler_t53F8340027F9EE67E8A22E7D8C1A3770345153C9 : public MulticastDelegate_t
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // ASSEMBLYLOADEVENTHANDLER_T53F8340027F9EE67E8A22E7D8C1A3770345153C9_H
#ifndef INTERNALCANCELHANDLER_T2DD134D8150B67E2F9FAD1BC2E6BE92EED57968A_H
#define INTERNALCANCELHANDLER_T2DD134D8150B67E2F9FAD1BC2E6BE92EED57968A_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Console_InternalCancelHandler
struct InternalCancelHandler_t2DD134D8150B67E2F9FAD1BC2E6BE92EED57968A : public MulticastDelegate_t
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // INTERNALCANCELHANDLER_T2DD134D8150B67E2F9FAD1BC2E6BE92EED57968A_H
#ifndef WINDOWSCANCELHANDLER_T1D05BCFB512603DCF87A126FE9969F1D876B9B51_H
#define WINDOWSCANCELHANDLER_T1D05BCFB512603DCF87A126FE9969F1D876B9B51_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Console_WindowsConsole_WindowsCancelHandler
struct WindowsCancelHandler_t1D05BCFB512603DCF87A126FE9969F1D876B9B51 : public MulticastDelegate_t
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // WINDOWSCANCELHANDLER_T1D05BCFB512603DCF87A126FE9969F1D876B9B51_H
#ifndef NULLCONSOLEDRIVER_T4608D1A2E1195946C2945E3459E15364CF4EC43D_H
#define NULLCONSOLEDRIVER_T4608D1A2E1195946C2945E3459E15364CF4EC43D_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.NullConsoleDriver
struct NullConsoleDriver_t4608D1A2E1195946C2945E3459E15364CF4EC43D : public RuntimeObject
{
public:
public:
};
struct NullConsoleDriver_t4608D1A2E1195946C2945E3459E15364CF4EC43D_StaticFields
{
public:
// System.ConsoleKeyInfo System.NullConsoleDriver::EmptyConsoleKeyInfo
ConsoleKeyInfo_t5BE3CE05E8258CDB5404256E96AF7C22BC5DE768 ___EmptyConsoleKeyInfo_0;
public:
inline static int32_t get_offset_of_EmptyConsoleKeyInfo_0() { return static_cast<int32_t>(offsetof(NullConsoleDriver_t4608D1A2E1195946C2945E3459E15364CF4EC43D_StaticFields, ___EmptyConsoleKeyInfo_0)); }
inline ConsoleKeyInfo_t5BE3CE05E8258CDB5404256E96AF7C22BC5DE768 get_EmptyConsoleKeyInfo_0() const { return ___EmptyConsoleKeyInfo_0; }
inline ConsoleKeyInfo_t5BE3CE05E8258CDB5404256E96AF7C22BC5DE768 * get_address_of_EmptyConsoleKeyInfo_0() { return &___EmptyConsoleKeyInfo_0; }
inline void set_EmptyConsoleKeyInfo_0(ConsoleKeyInfo_t5BE3CE05E8258CDB5404256E96AF7C22BC5DE768 value)
{
___EmptyConsoleKeyInfo_0 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // NULLCONSOLEDRIVER_T4608D1A2E1195946C2945E3459E15364CF4EC43D_H
#ifndef TYPEINFO_T9D6F65801A41B97F36138B15FD270A1550DBB3FC_H
#define TYPEINFO_T9D6F65801A41B97F36138B15FD270A1550DBB3FC_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Reflection.TypeInfo
struct TypeInfo_t9D6F65801A41B97F36138B15FD270A1550DBB3FC : public Type_t
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // TYPEINFO_T9D6F65801A41B97F36138B15FD270A1550DBB3FC_H
#ifndef RESOLVEEVENTHANDLER_T045C469BEA8B632FA99FE8867C921BA8DAE0BEE5_H
#define RESOLVEEVENTHANDLER_T045C469BEA8B632FA99FE8867C921BA8DAE0BEE5_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.ResolveEventHandler
struct ResolveEventHandler_t045C469BEA8B632FA99FE8867C921BA8DAE0BEE5 : public MulticastDelegate_t
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // RESOLVEEVENTHANDLER_T045C469BEA8B632FA99FE8867C921BA8DAE0BEE5_H
#ifndef UNHANDLEDEXCEPTIONEVENTHANDLER_TB0DFF05ABF7A3A234C87D4F7A71F98E9AB2D91DE_H
#define UNHANDLEDEXCEPTIONEVENTHANDLER_TB0DFF05ABF7A3A234C87D4F7A71F98E9AB2D91DE_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.UnhandledExceptionEventHandler
struct UnhandledExceptionEventHandler_tB0DFF05ABF7A3A234C87D4F7A71F98E9AB2D91DE : public MulticastDelegate_t
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // UNHANDLEDEXCEPTIONEVENTHANDLER_TB0DFF05ABF7A3A234C87D4F7A71F98E9AB2D91DE_H
#ifndef RUNTIMETYPE_T40F13BCEAD97478C72C4B40BFDC2A220161CDB8F_H
#define RUNTIMETYPE_T40F13BCEAD97478C72C4B40BFDC2A220161CDB8F_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.RuntimeType
struct RuntimeType_t40F13BCEAD97478C72C4B40BFDC2A220161CDB8F : public TypeInfo_t9D6F65801A41B97F36138B15FD270A1550DBB3FC
{
public:
// System.MonoTypeInfo System.RuntimeType::type_info
MonoTypeInfo_t9A65BA5324D14FDFEB7644EEE6E1BDF74B8A393D * ___type_info_26;
// System.Object System.RuntimeType::GenericCache
RuntimeObject * ___GenericCache_27;
// System.Reflection.RuntimeConstructorInfo System.RuntimeType::m_serializationCtor
RuntimeConstructorInfo_tF21A59967629968D0BE5D0DAF677662824E9629D * ___m_serializationCtor_28;
public:
inline static int32_t get_offset_of_type_info_26() { return static_cast<int32_t>(offsetof(RuntimeType_t40F13BCEAD97478C72C4B40BFDC2A220161CDB8F, ___type_info_26)); }
inline MonoTypeInfo_t9A65BA5324D14FDFEB7644EEE6E1BDF74B8A393D * get_type_info_26() const { return ___type_info_26; }
inline MonoTypeInfo_t9A65BA5324D14FDFEB7644EEE6E1BDF74B8A393D ** get_address_of_type_info_26() { return &___type_info_26; }
inline void set_type_info_26(MonoTypeInfo_t9A65BA5324D14FDFEB7644EEE6E1BDF74B8A393D * value)
{
___type_info_26 = value;
Il2CppCodeGenWriteBarrier((&___type_info_26), value);
}
inline static int32_t get_offset_of_GenericCache_27() { return static_cast<int32_t>(offsetof(RuntimeType_t40F13BCEAD97478C72C4B40BFDC2A220161CDB8F, ___GenericCache_27)); }
inline RuntimeObject * get_GenericCache_27() const { return ___GenericCache_27; }
inline RuntimeObject ** get_address_of_GenericCache_27() { return &___GenericCache_27; }
inline void set_GenericCache_27(RuntimeObject * value)
{
___GenericCache_27 = value;
Il2CppCodeGenWriteBarrier((&___GenericCache_27), value);
}
inline static int32_t get_offset_of_m_serializationCtor_28() { return static_cast<int32_t>(offsetof(RuntimeType_t40F13BCEAD97478C72C4B40BFDC2A220161CDB8F, ___m_serializationCtor_28)); }
inline RuntimeConstructorInfo_tF21A59967629968D0BE5D0DAF677662824E9629D * get_m_serializationCtor_28() const { return ___m_serializationCtor_28; }
inline RuntimeConstructorInfo_tF21A59967629968D0BE5D0DAF677662824E9629D ** get_address_of_m_serializationCtor_28() { return &___m_serializationCtor_28; }
inline void set_m_serializationCtor_28(RuntimeConstructorInfo_tF21A59967629968D0BE5D0DAF677662824E9629D * value)
{
___m_serializationCtor_28 = value;
Il2CppCodeGenWriteBarrier((&___m_serializationCtor_28), value);
}
};
struct RuntimeType_t40F13BCEAD97478C72C4B40BFDC2A220161CDB8F_StaticFields
{
public:
// System.RuntimeType System.RuntimeType::ValueType
RuntimeType_t40F13BCEAD97478C72C4B40BFDC2A220161CDB8F * ___ValueType_10;
// System.RuntimeType System.RuntimeType::EnumType
RuntimeType_t40F13BCEAD97478C72C4B40BFDC2A220161CDB8F * ___EnumType_11;
// System.RuntimeType System.RuntimeType::ObjectType
RuntimeType_t40F13BCEAD97478C72C4B40BFDC2A220161CDB8F * ___ObjectType_12;
// System.RuntimeType System.RuntimeType::StringType
RuntimeType_t40F13BCEAD97478C72C4B40BFDC2A220161CDB8F * ___StringType_13;
// System.RuntimeType System.RuntimeType::DelegateType
RuntimeType_t40F13BCEAD97478C72C4B40BFDC2A220161CDB8F * ___DelegateType_14;
// System.Type[] System.RuntimeType::s_SICtorParamTypes
TypeU5BU5D_t7FE623A666B49176DE123306221193E888A12F5F* ___s_SICtorParamTypes_15;
// System.RuntimeType System.RuntimeType::s_typedRef
RuntimeType_t40F13BCEAD97478C72C4B40BFDC2A220161CDB8F * ___s_typedRef_25;
public:
inline static int32_t get_offset_of_ValueType_10() { return static_cast<int32_t>(offsetof(RuntimeType_t40F13BCEAD97478C72C4B40BFDC2A220161CDB8F_StaticFields, ___ValueType_10)); }
inline RuntimeType_t40F13BCEAD97478C72C4B40BFDC2A220161CDB8F * get_ValueType_10() const { return ___ValueType_10; }
inline RuntimeType_t40F13BCEAD97478C72C4B40BFDC2A220161CDB8F ** get_address_of_ValueType_10() { return &___ValueType_10; }
inline void set_ValueType_10(RuntimeType_t40F13BCEAD97478C72C4B40BFDC2A220161CDB8F * value)
{
___ValueType_10 = value;
Il2CppCodeGenWriteBarrier((&___ValueType_10), value);
}
inline static int32_t get_offset_of_EnumType_11() { return static_cast<int32_t>(offsetof(RuntimeType_t40F13BCEAD97478C72C4B40BFDC2A220161CDB8F_StaticFields, ___EnumType_11)); }
inline RuntimeType_t40F13BCEAD97478C72C4B40BFDC2A220161CDB8F * get_EnumType_11() const { return ___EnumType_11; }
inline RuntimeType_t40F13BCEAD97478C72C4B40BFDC2A220161CDB8F ** get_address_of_EnumType_11() { return &___EnumType_11; }
inline void set_EnumType_11(RuntimeType_t40F13BCEAD97478C72C4B40BFDC2A220161CDB8F * value)
{
___EnumType_11 = value;
Il2CppCodeGenWriteBarrier((&___EnumType_11), value);
}
inline static int32_t get_offset_of_ObjectType_12() { return static_cast<int32_t>(offsetof(RuntimeType_t40F13BCEAD97478C72C4B40BFDC2A220161CDB8F_StaticFields, ___ObjectType_12)); }
inline RuntimeType_t40F13BCEAD97478C72C4B40BFDC2A220161CDB8F * get_ObjectType_12() const { return ___ObjectType_12; }
inline RuntimeType_t40F13BCEAD97478C72C4B40BFDC2A220161CDB8F ** get_address_of_ObjectType_12() { return &___ObjectType_12; }
inline void set_ObjectType_12(RuntimeType_t40F13BCEAD97478C72C4B40BFDC2A220161CDB8F * value)
{
___ObjectType_12 = value;
Il2CppCodeGenWriteBarrier((&___ObjectType_12), value);
}
inline static int32_t get_offset_of_StringType_13() { return static_cast<int32_t>(offsetof(RuntimeType_t40F13BCEAD97478C72C4B40BFDC2A220161CDB8F_StaticFields, ___StringType_13)); }
inline RuntimeType_t40F13BCEAD97478C72C4B40BFDC2A220161CDB8F * get_StringType_13() const { return ___StringType_13; }
inline RuntimeType_t40F13BCEAD97478C72C4B40BFDC2A220161CDB8F ** get_address_of_StringType_13() { return &___StringType_13; }
inline void set_StringType_13(RuntimeType_t40F13BCEAD97478C72C4B40BFDC2A220161CDB8F * value)
{
___StringType_13 = value;
Il2CppCodeGenWriteBarrier((&___StringType_13), value);
}
inline static int32_t get_offset_of_DelegateType_14() { return static_cast<int32_t>(offsetof(RuntimeType_t40F13BCEAD97478C72C4B40BFDC2A220161CDB8F_StaticFields, ___DelegateType_14)); }
inline RuntimeType_t40F13BCEAD97478C72C4B40BFDC2A220161CDB8F * get_DelegateType_14() const { return ___DelegateType_14; }
inline RuntimeType_t40F13BCEAD97478C72C4B40BFDC2A220161CDB8F ** get_address_of_DelegateType_14() { return &___DelegateType_14; }
inline void set_DelegateType_14(RuntimeType_t40F13BCEAD97478C72C4B40BFDC2A220161CDB8F * value)
{
___DelegateType_14 = value;
Il2CppCodeGenWriteBarrier((&___DelegateType_14), value);
}
inline static int32_t get_offset_of_s_SICtorParamTypes_15() { return static_cast<int32_t>(offsetof(RuntimeType_t40F13BCEAD97478C72C4B40BFDC2A220161CDB8F_StaticFields, ___s_SICtorParamTypes_15)); }
inline TypeU5BU5D_t7FE623A666B49176DE123306221193E888A12F5F* get_s_SICtorParamTypes_15() const { return ___s_SICtorParamTypes_15; }
inline TypeU5BU5D_t7FE623A666B49176DE123306221193E888A12F5F** get_address_of_s_SICtorParamTypes_15() { return &___s_SICtorParamTypes_15; }
inline void set_s_SICtorParamTypes_15(TypeU5BU5D_t7FE623A666B49176DE123306221193E888A12F5F* value)
{
___s_SICtorParamTypes_15 = value;
Il2CppCodeGenWriteBarrier((&___s_SICtorParamTypes_15), value);
}
inline static int32_t get_offset_of_s_typedRef_25() { return static_cast<int32_t>(offsetof(RuntimeType_t40F13BCEAD97478C72C4B40BFDC2A220161CDB8F_StaticFields, ___s_typedRef_25)); }
inline RuntimeType_t40F13BCEAD97478C72C4B40BFDC2A220161CDB8F * get_s_typedRef_25() const { return ___s_typedRef_25; }
inline RuntimeType_t40F13BCEAD97478C72C4B40BFDC2A220161CDB8F ** get_address_of_s_typedRef_25() { return &___s_typedRef_25; }
inline void set_s_typedRef_25(RuntimeType_t40F13BCEAD97478C72C4B40BFDC2A220161CDB8F * value)
{
___s_typedRef_25 = value;
Il2CppCodeGenWriteBarrier((&___s_typedRef_25), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // RUNTIMETYPE_T40F13BCEAD97478C72C4B40BFDC2A220161CDB8F_H
#ifndef MONOTYPE_T_H
#define MONOTYPE_T_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.MonoType
struct MonoType_t : public RuntimeType_t40F13BCEAD97478C72C4B40BFDC2A220161CDB8F
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // MONOTYPE_T_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize300 = { sizeof (UnhandledExceptionEventArgs_t39DD47D43B0D764FE2C9847FBE760031FBEA0FD1), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable300[2] =
{
UnhandledExceptionEventArgs_t39DD47D43B0D764FE2C9847FBE760031FBEA0FD1::get_offset_of__Exception_1(),
UnhandledExceptionEventArgs_t39DD47D43B0D764FE2C9847FBE760031FBEA0FD1::get_offset_of__IsTerminating_2(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize301 = { sizeof (UnhandledExceptionEventHandler_tB0DFF05ABF7A3A234C87D4F7A71F98E9AB2D91DE), sizeof(Il2CppMethodPointer), 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize302 = { sizeof (UnitySerializationHolder_t6B17ABB985ACD3F8D9F9E3C146DEA5F730E1CEAC), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable302[8] =
{
UnitySerializationHolder_t6B17ABB985ACD3F8D9F9E3C146DEA5F730E1CEAC::get_offset_of_m_instantiation_0(),
UnitySerializationHolder_t6B17ABB985ACD3F8D9F9E3C146DEA5F730E1CEAC::get_offset_of_m_elementTypes_1(),
UnitySerializationHolder_t6B17ABB985ACD3F8D9F9E3C146DEA5F730E1CEAC::get_offset_of_m_genericParameterPosition_2(),
UnitySerializationHolder_t6B17ABB985ACD3F8D9F9E3C146DEA5F730E1CEAC::get_offset_of_m_declaringType_3(),
UnitySerializationHolder_t6B17ABB985ACD3F8D9F9E3C146DEA5F730E1CEAC::get_offset_of_m_declaringMethod_4(),
UnitySerializationHolder_t6B17ABB985ACD3F8D9F9E3C146DEA5F730E1CEAC::get_offset_of_m_data_5(),
UnitySerializationHolder_t6B17ABB985ACD3F8D9F9E3C146DEA5F730E1CEAC::get_offset_of_m_assemblyName_6(),
UnitySerializationHolder_t6B17ABB985ACD3F8D9F9E3C146DEA5F730E1CEAC::get_offset_of_m_unityType_7(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize303 = { sizeof (UnSafeCharBuffer_t99F0962CE65E71C4BA612D5434276C51AC33AF0C)+ sizeof (RuntimeObject), sizeof(UnSafeCharBuffer_t99F0962CE65E71C4BA612D5434276C51AC33AF0C_marshaled_pinvoke), 0, 0 };
extern const int32_t g_FieldOffsetTable303[3] =
{
UnSafeCharBuffer_t99F0962CE65E71C4BA612D5434276C51AC33AF0C::get_offset_of_m_buffer_0() + static_cast<int32_t>(sizeof(RuntimeObject)),
UnSafeCharBuffer_t99F0962CE65E71C4BA612D5434276C51AC33AF0C::get_offset_of_m_totalSize_1() + static_cast<int32_t>(sizeof(RuntimeObject)),
UnSafeCharBuffer_t99F0962CE65E71C4BA612D5434276C51AC33AF0C::get_offset_of_m_length_2() + static_cast<int32_t>(sizeof(RuntimeObject)),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize304 = { sizeof (Version_tDBE6876C59B6F56D4F8CAA03851177ABC6FE0DFD), -1, sizeof(Version_tDBE6876C59B6F56D4F8CAA03851177ABC6FE0DFD_StaticFields), 0 };
extern const int32_t g_FieldOffsetTable304[6] =
{
Version_tDBE6876C59B6F56D4F8CAA03851177ABC6FE0DFD::get_offset_of__Major_0(),
Version_tDBE6876C59B6F56D4F8CAA03851177ABC6FE0DFD::get_offset_of__Minor_1(),
Version_tDBE6876C59B6F56D4F8CAA03851177ABC6FE0DFD::get_offset_of__Build_2(),
Version_tDBE6876C59B6F56D4F8CAA03851177ABC6FE0DFD::get_offset_of__Revision_3(),
Version_tDBE6876C59B6F56D4F8CAA03851177ABC6FE0DFD_StaticFields::get_offset_of_SeparatorsArray_4(),
0,
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize305 = { sizeof (ParseFailureKind_t0E37E87ACF3E01D5D2846A114AE9247C2C7DC3E8)+ sizeof (RuntimeObject), sizeof(int32_t), 0, 0 };
extern const int32_t g_FieldOffsetTable305[5] =
{
ParseFailureKind_t0E37E87ACF3E01D5D2846A114AE9247C2C7DC3E8::get_offset_of_value___2() + static_cast<int32_t>(sizeof(RuntimeObject)),
0,
0,
0,
0,
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize306 = { sizeof (VersionResult_tA97F3FDF3CF3FF5D0E43768C08D1C4D4568E88CE)+ sizeof (RuntimeObject), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable306[5] =
{
VersionResult_tA97F3FDF3CF3FF5D0E43768C08D1C4D4568E88CE::get_offset_of_m_parsedVersion_0() + static_cast<int32_t>(sizeof(RuntimeObject)),
VersionResult_tA97F3FDF3CF3FF5D0E43768C08D1C4D4568E88CE::get_offset_of_m_failure_1() + static_cast<int32_t>(sizeof(RuntimeObject)),
VersionResult_tA97F3FDF3CF3FF5D0E43768C08D1C4D4568E88CE::get_offset_of_m_exceptionArgument_2() + static_cast<int32_t>(sizeof(RuntimeObject)),
VersionResult_tA97F3FDF3CF3FF5D0E43768C08D1C4D4568E88CE::get_offset_of_m_argumentName_3() + static_cast<int32_t>(sizeof(RuntimeObject)),
VersionResult_tA97F3FDF3CF3FF5D0E43768C08D1C4D4568E88CE::get_offset_of_m_canThrow_4() + static_cast<int32_t>(sizeof(RuntimeObject)),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize307 = { sizeof (AppDomain_t1B59572328F60585904DF52A59FE47CF5B5FFFF8), -1, sizeof(AppDomain_t1B59572328F60585904DF52A59FE47CF5B5FFFF8_StaticFields), sizeof(AppDomain_t1B59572328F60585904DF52A59FE47CF5B5FFFF8_ThreadStaticFields) };
extern const int32_t g_FieldOffsetTable307[23] =
{
AppDomain_t1B59572328F60585904DF52A59FE47CF5B5FFFF8::get_offset_of__mono_app_domain_1(),
AppDomain_t1B59572328F60585904DF52A59FE47CF5B5FFFF8_StaticFields::get_offset_of__process_guid_2(),
AppDomain_t1B59572328F60585904DF52A59FE47CF5B5FFFF8_ThreadStaticFields::get_offset_of_type_resolve_in_progress_3() | THREAD_LOCAL_STATIC_MASK,
AppDomain_t1B59572328F60585904DF52A59FE47CF5B5FFFF8_ThreadStaticFields::get_offset_of_assembly_resolve_in_progress_4() | THREAD_LOCAL_STATIC_MASK,
AppDomain_t1B59572328F60585904DF52A59FE47CF5B5FFFF8_ThreadStaticFields::get_offset_of_assembly_resolve_in_progress_refonly_5() | THREAD_LOCAL_STATIC_MASK,
AppDomain_t1B59572328F60585904DF52A59FE47CF5B5FFFF8::get_offset_of__evidence_6(),
AppDomain_t1B59572328F60585904DF52A59FE47CF5B5FFFF8::get_offset_of__granted_7(),
AppDomain_t1B59572328F60585904DF52A59FE47CF5B5FFFF8::get_offset_of__principalPolicy_8(),
AppDomain_t1B59572328F60585904DF52A59FE47CF5B5FFFF8_ThreadStaticFields::get_offset_of__principal_9() | THREAD_LOCAL_STATIC_MASK,
AppDomain_t1B59572328F60585904DF52A59FE47CF5B5FFFF8_StaticFields::get_offset_of_default_domain_10(),
AppDomain_t1B59572328F60585904DF52A59FE47CF5B5FFFF8::get_offset_of_AssemblyLoad_11(),
AppDomain_t1B59572328F60585904DF52A59FE47CF5B5FFFF8::get_offset_of_AssemblyResolve_12(),
AppDomain_t1B59572328F60585904DF52A59FE47CF5B5FFFF8::get_offset_of_DomainUnload_13(),
AppDomain_t1B59572328F60585904DF52A59FE47CF5B5FFFF8::get_offset_of_ProcessExit_14(),
AppDomain_t1B59572328F60585904DF52A59FE47CF5B5FFFF8::get_offset_of_ResourceResolve_15(),
AppDomain_t1B59572328F60585904DF52A59FE47CF5B5FFFF8::get_offset_of_TypeResolve_16(),
AppDomain_t1B59572328F60585904DF52A59FE47CF5B5FFFF8::get_offset_of_UnhandledException_17(),
AppDomain_t1B59572328F60585904DF52A59FE47CF5B5FFFF8::get_offset_of_FirstChanceException_18(),
AppDomain_t1B59572328F60585904DF52A59FE47CF5B5FFFF8::get_offset_of__domain_manager_19(),
AppDomain_t1B59572328F60585904DF52A59FE47CF5B5FFFF8::get_offset_of_ReflectionOnlyAssemblyResolve_20(),
AppDomain_t1B59572328F60585904DF52A59FE47CF5B5FFFF8::get_offset_of__activation_21(),
AppDomain_t1B59572328F60585904DF52A59FE47CF5B5FFFF8::get_offset_of__applicationIdentity_22(),
AppDomain_t1B59572328F60585904DF52A59FE47CF5B5FFFF8::get_offset_of_compatibility_switch_23(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize308 = { sizeof (CLRConfig_t79EBAFC5FBCAC675B35CB93391030FABCA9A7B45), -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize309 = { sizeof (CompatibilitySwitches_tC541F9F5404925C97741A0628E9B6D26C40CFA91), -1, sizeof(CompatibilitySwitches_tC541F9F5404925C97741A0628E9B6D26C40CFA91_StaticFields), 0 };
extern const int32_t g_FieldOffsetTable309[2] =
{
CompatibilitySwitches_tC541F9F5404925C97741A0628E9B6D26C40CFA91_StaticFields::get_offset_of_IsAppEarlierThanSilverlight4_0(),
CompatibilitySwitches_tC541F9F5404925C97741A0628E9B6D26C40CFA91_StaticFields::get_offset_of_IsAppEarlierThanWindowsPhone8_1(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize310 = { sizeof (Environment_tC93BF7477A1AEA39D05EDFEBAFF62EE5353FF806), -1, sizeof(Environment_tC93BF7477A1AEA39D05EDFEBAFF62EE5353FF806_StaticFields), 0 };
extern const int32_t g_FieldOffsetTable310[3] =
{
0,
Environment_tC93BF7477A1AEA39D05EDFEBAFF62EE5353FF806_StaticFields::get_offset_of_nl_1(),
Environment_tC93BF7477A1AEA39D05EDFEBAFF62EE5353FF806_StaticFields::get_offset_of_os_2(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize311 = { sizeof (SpecialFolder_t5A2C2AE97BD6C2DF95061C8904B2225228AC9BA0)+ sizeof (RuntimeObject), sizeof(int32_t), 0, 0 };
extern const int32_t g_FieldOffsetTable311[48] =
{
SpecialFolder_t5A2C2AE97BD6C2DF95061C8904B2225228AC9BA0::get_offset_of_value___2() + static_cast<int32_t>(sizeof(RuntimeObject)),
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize312 = { sizeof (SpecialFolderOption_tAF2DB60F447738C1E46C3D5660A0CBB0F4480470)+ sizeof (RuntimeObject), sizeof(int32_t), 0, 0 };
extern const int32_t g_FieldOffsetTable312[4] =
{
SpecialFolderOption_tAF2DB60F447738C1E46C3D5660A0CBB0F4480470::get_offset_of_value___2() + static_cast<int32_t>(sizeof(RuntimeObject)),
0,
0,
0,
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize313 = { sizeof (ParseNumbers_tFCD9612B791F297E13D1D622F88219D9D471331A), -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize314 = { sizeof (MonoTypeInfo_t9A65BA5324D14FDFEB7644EEE6E1BDF74B8A393D), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable314[2] =
{
MonoTypeInfo_t9A65BA5324D14FDFEB7644EEE6E1BDF74B8A393D::get_offset_of_full_name_0(),
MonoTypeInfo_t9A65BA5324D14FDFEB7644EEE6E1BDF74B8A393D::get_offset_of_default_ctor_1(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize315 = { sizeof (TypeNameParser_tBEF78C9D6AEC3DE5E2993F6EDC24C06F7B713741), -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize316 = { sizeof (AppDomainSetup_t80DF2915BB100D4BD515920B49C959E9FA451306), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable316[23] =
{
AppDomainSetup_t80DF2915BB100D4BD515920B49C959E9FA451306::get_offset_of_application_base_0(),
AppDomainSetup_t80DF2915BB100D4BD515920B49C959E9FA451306::get_offset_of_application_name_1(),
AppDomainSetup_t80DF2915BB100D4BD515920B49C959E9FA451306::get_offset_of_cache_path_2(),
AppDomainSetup_t80DF2915BB100D4BD515920B49C959E9FA451306::get_offset_of_configuration_file_3(),
AppDomainSetup_t80DF2915BB100D4BD515920B49C959E9FA451306::get_offset_of_dynamic_base_4(),
AppDomainSetup_t80DF2915BB100D4BD515920B49C959E9FA451306::get_offset_of_license_file_5(),
AppDomainSetup_t80DF2915BB100D4BD515920B49C959E9FA451306::get_offset_of_private_bin_path_6(),
AppDomainSetup_t80DF2915BB100D4BD515920B49C959E9FA451306::get_offset_of_private_bin_path_probe_7(),
AppDomainSetup_t80DF2915BB100D4BD515920B49C959E9FA451306::get_offset_of_shadow_copy_directories_8(),
AppDomainSetup_t80DF2915BB100D4BD515920B49C959E9FA451306::get_offset_of_shadow_copy_files_9(),
AppDomainSetup_t80DF2915BB100D4BD515920B49C959E9FA451306::get_offset_of_publisher_policy_10(),
AppDomainSetup_t80DF2915BB100D4BD515920B49C959E9FA451306::get_offset_of_path_changed_11(),
AppDomainSetup_t80DF2915BB100D4BD515920B49C959E9FA451306::get_offset_of_loader_optimization_12(),
AppDomainSetup_t80DF2915BB100D4BD515920B49C959E9FA451306::get_offset_of_disallow_binding_redirects_13(),
AppDomainSetup_t80DF2915BB100D4BD515920B49C959E9FA451306::get_offset_of_disallow_code_downloads_14(),
AppDomainSetup_t80DF2915BB100D4BD515920B49C959E9FA451306::get_offset_of__activationArguments_15(),
AppDomainSetup_t80DF2915BB100D4BD515920B49C959E9FA451306::get_offset_of_domain_initializer_16(),
AppDomainSetup_t80DF2915BB100D4BD515920B49C959E9FA451306::get_offset_of_application_trust_17(),
AppDomainSetup_t80DF2915BB100D4BD515920B49C959E9FA451306::get_offset_of_domain_initializer_args_18(),
AppDomainSetup_t80DF2915BB100D4BD515920B49C959E9FA451306::get_offset_of_disallow_appbase_probe_19(),
AppDomainSetup_t80DF2915BB100D4BD515920B49C959E9FA451306::get_offset_of_configuration_bytes_20(),
AppDomainSetup_t80DF2915BB100D4BD515920B49C959E9FA451306::get_offset_of_serialized_non_primitives_21(),
AppDomainSetup_t80DF2915BB100D4BD515920B49C959E9FA451306::get_offset_of_U3CTargetFrameworkNameU3Ek__BackingField_22(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize317 = { sizeof (ArgIterator_tCF0D2A1A1BD140821E37286E2D7AC6267479F855)+ sizeof (RuntimeObject), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable317[4] =
{
ArgIterator_tCF0D2A1A1BD140821E37286E2D7AC6267479F855::get_offset_of_sig_0() + static_cast<int32_t>(sizeof(RuntimeObject)),
ArgIterator_tCF0D2A1A1BD140821E37286E2D7AC6267479F855::get_offset_of_args_1() + static_cast<int32_t>(sizeof(RuntimeObject)),
ArgIterator_tCF0D2A1A1BD140821E37286E2D7AC6267479F855::get_offset_of_next_arg_2() + static_cast<int32_t>(sizeof(RuntimeObject)),
ArgIterator_tCF0D2A1A1BD140821E37286E2D7AC6267479F855::get_offset_of_num_args_3() + static_cast<int32_t>(sizeof(RuntimeObject)),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize318 = { sizeof (AssemblyLoadEventArgs_t51DAAB04039C3B2D8C3FBF65C13441BC6C6A7AE8), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable318[1] =
{
AssemblyLoadEventArgs_t51DAAB04039C3B2D8C3FBF65C13441BC6C6A7AE8::get_offset_of_m_loadedAssembly_1(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize319 = { sizeof (AssemblyLoadEventHandler_t53F8340027F9EE67E8A22E7D8C1A3770345153C9), sizeof(Il2CppMethodPointer), 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize320 = { sizeof (Console_t5C8E87BA271B0DECA837A3BF9093AC3560DB3D5D), -1, sizeof(Console_t5C8E87BA271B0DECA837A3BF9093AC3560DB3D5D_StaticFields), 0 };
extern const int32_t g_FieldOffsetTable320[7] =
{
Console_t5C8E87BA271B0DECA837A3BF9093AC3560DB3D5D_StaticFields::get_offset_of_stdout_0(),
Console_t5C8E87BA271B0DECA837A3BF9093AC3560DB3D5D_StaticFields::get_offset_of_stderr_1(),
Console_t5C8E87BA271B0DECA837A3BF9093AC3560DB3D5D_StaticFields::get_offset_of_stdin_2(),
Console_t5C8E87BA271B0DECA837A3BF9093AC3560DB3D5D_StaticFields::get_offset_of_inputEncoding_3(),
Console_t5C8E87BA271B0DECA837A3BF9093AC3560DB3D5D_StaticFields::get_offset_of_outputEncoding_4(),
Console_t5C8E87BA271B0DECA837A3BF9093AC3560DB3D5D_StaticFields::get_offset_of_cancel_event_5(),
Console_t5C8E87BA271B0DECA837A3BF9093AC3560DB3D5D_StaticFields::get_offset_of_cancel_handler_6(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize321 = { sizeof (WindowsConsole_tE2543F6EAD1001D1F2DE2CC0A5495048EED8C21B), -1, sizeof(WindowsConsole_tE2543F6EAD1001D1F2DE2CC0A5495048EED8C21B_StaticFields), 0 };
extern const int32_t g_FieldOffsetTable321[2] =
{
WindowsConsole_tE2543F6EAD1001D1F2DE2CC0A5495048EED8C21B_StaticFields::get_offset_of_ctrlHandlerAdded_0(),
WindowsConsole_tE2543F6EAD1001D1F2DE2CC0A5495048EED8C21B_StaticFields::get_offset_of_cancelHandler_1(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize322 = { sizeof (WindowsCancelHandler_t1D05BCFB512603DCF87A126FE9969F1D876B9B51), sizeof(Il2CppMethodPointer), 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize323 = { sizeof (InternalCancelHandler_t2DD134D8150B67E2F9FAD1BC2E6BE92EED57968A), sizeof(Il2CppMethodPointer), 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize324 = { sizeof (ConsoleDriver_t4F24DB42600CA82912181D5D312902B8BEFEE101), -1, sizeof(ConsoleDriver_t4F24DB42600CA82912181D5D312902B8BEFEE101_StaticFields), 0 };
extern const int32_t g_FieldOffsetTable324[3] =
{
ConsoleDriver_t4F24DB42600CA82912181D5D312902B8BEFEE101_StaticFields::get_offset_of_driver_0(),
ConsoleDriver_t4F24DB42600CA82912181D5D312902B8BEFEE101_StaticFields::get_offset_of_is_console_1(),
ConsoleDriver_t4F24DB42600CA82912181D5D312902B8BEFEE101_StaticFields::get_offset_of_called_isatty_2(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize325 = { sizeof (DelegateData_t1BF9F691B56DAE5F8C28C5E084FDE94F15F27BBE), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable325[3] =
{
DelegateData_t1BF9F691B56DAE5F8C28C5E084FDE94F15F27BBE::get_offset_of_target_type_0(),
DelegateData_t1BF9F691B56DAE5F8C28C5E084FDE94F15F27BBE::get_offset_of_method_name_1(),
DelegateData_t1BF9F691B56DAE5F8C28C5E084FDE94F15F27BBE::get_offset_of_curried_first_arg_2(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize326 = { sizeof (Delegate_t), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable326[11] =
{
Delegate_t::get_offset_of_method_ptr_0(),
Delegate_t::get_offset_of_invoke_impl_1(),
Delegate_t::get_offset_of_m_target_2(),
Delegate_t::get_offset_of_method_3(),
Delegate_t::get_offset_of_delegate_trampoline_4(),
Delegate_t::get_offset_of_extra_arg_5(),
Delegate_t::get_offset_of_method_code_6(),
Delegate_t::get_offset_of_method_info_7(),
Delegate_t::get_offset_of_original_method_info_8(),
Delegate_t::get_offset_of_data_9(),
Delegate_t::get_offset_of_method_is_virtual_10(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize327 = { sizeof (DelegateSerializationHolder_tC720FD99D3C1B05B7558EF694ED42E57E64DD671), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable327[1] =
{
DelegateSerializationHolder_tC720FD99D3C1B05B7558EF694ED42E57E64DD671::get_offset_of__delegate_0(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize328 = { sizeof (DelegateEntry_t2B3E5D8EF7A65CB12A8EF7621B40DC704402E88E), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable328[7] =
{
DelegateEntry_t2B3E5D8EF7A65CB12A8EF7621B40DC704402E88E::get_offset_of_type_0(),
DelegateEntry_t2B3E5D8EF7A65CB12A8EF7621B40DC704402E88E::get_offset_of_assembly_1(),
DelegateEntry_t2B3E5D8EF7A65CB12A8EF7621B40DC704402E88E::get_offset_of_target_2(),
DelegateEntry_t2B3E5D8EF7A65CB12A8EF7621B40DC704402E88E::get_offset_of_targetTypeAssembly_3(),
DelegateEntry_t2B3E5D8EF7A65CB12A8EF7621B40DC704402E88E::get_offset_of_targetTypeName_4(),
DelegateEntry_t2B3E5D8EF7A65CB12A8EF7621B40DC704402E88E::get_offset_of_methodName_5(),
DelegateEntry_t2B3E5D8EF7A65CB12A8EF7621B40DC704402E88E::get_offset_of_delegateEntry_6(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize329 = { 0, 0, 0, 0 };
extern const int32_t g_FieldOffsetTable329[1] =
{
0,
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize330 = { sizeof (SByteEnum_t0EC157A9E311E27D76141202576E15FA4E83E0EE)+ sizeof (RuntimeObject), sizeof(int8_t), 0, 0 };
extern const int32_t g_FieldOffsetTable330[1] =
{
SByteEnum_t0EC157A9E311E27D76141202576E15FA4E83E0EE::get_offset_of_value___2() + static_cast<int32_t>(sizeof(RuntimeObject)),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize331 = { sizeof (Int16Enum_tF03C0C5772A892EB552607A1C0DEF122A930BE80)+ sizeof (RuntimeObject), sizeof(int16_t), 0, 0 };
extern const int32_t g_FieldOffsetTable331[1] =
{
Int16Enum_tF03C0C5772A892EB552607A1C0DEF122A930BE80::get_offset_of_value___2() + static_cast<int32_t>(sizeof(RuntimeObject)),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize332 = { sizeof (Int32Enum_t6312CE4586C17FE2E2E513D2E7655B574F10FDCD)+ sizeof (RuntimeObject), sizeof(int32_t), 0, 0 };
extern const int32_t g_FieldOffsetTable332[1] =
{
Int32Enum_t6312CE4586C17FE2E2E513D2E7655B574F10FDCD::get_offset_of_value___2() + static_cast<int32_t>(sizeof(RuntimeObject)),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize333 = { sizeof (Int64Enum_t7DD4BDEADB660E726D94B249B352C2E2ABC1E580)+ sizeof (RuntimeObject), sizeof(int64_t), 0, 0 };
extern const int32_t g_FieldOffsetTable333[1] =
{
Int64Enum_t7DD4BDEADB660E726D94B249B352C2E2ABC1E580::get_offset_of_value___2() + static_cast<int32_t>(sizeof(RuntimeObject)),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize334 = { sizeof (ByteEnum_t406C975039F6312CDE58A265A6ECFD861F8C06CD)+ sizeof (RuntimeObject), sizeof(uint8_t), 0, 0 };
extern const int32_t g_FieldOffsetTable334[1] =
{
ByteEnum_t406C975039F6312CDE58A265A6ECFD861F8C06CD::get_offset_of_value___2() + static_cast<int32_t>(sizeof(RuntimeObject)),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize335 = { sizeof (UInt16Enum_tB3380938EFBC6B524E2C8143A7982637F0EA4456)+ sizeof (RuntimeObject), sizeof(uint16_t), 0, 0 };
extern const int32_t g_FieldOffsetTable335[1] =
{
UInt16Enum_tB3380938EFBC6B524E2C8143A7982637F0EA4456::get_offset_of_value___2() + static_cast<int32_t>(sizeof(RuntimeObject)),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize336 = { sizeof (UInt32Enum_tE44175EB3151A633676D60A642EDA3BD5C6760DA)+ sizeof (RuntimeObject), sizeof(uint32_t), 0, 0 };
extern const int32_t g_FieldOffsetTable336[1] =
{
UInt32Enum_tE44175EB3151A633676D60A642EDA3BD5C6760DA::get_offset_of_value___2() + static_cast<int32_t>(sizeof(RuntimeObject)),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize337 = { sizeof (UInt64Enum_tEAD217F175F60689A664303784384DEF759D24C8)+ sizeof (RuntimeObject), sizeof(uint64_t), 0, 0 };
extern const int32_t g_FieldOffsetTable337[1] =
{
UInt64Enum_tEAD217F175F60689A664303784384DEF759D24C8::get_offset_of_value___2() + static_cast<int32_t>(sizeof(RuntimeObject)),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize338 = { 0, -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize339 = { sizeof (IntPtr_t)+ sizeof (RuntimeObject), sizeof(intptr_t), sizeof(IntPtr_t_StaticFields), 0 };
extern const int32_t g_FieldOffsetTable339[2] =
{
IntPtr_t::get_offset_of_m_value_0() + static_cast<int32_t>(sizeof(RuntimeObject)),
IntPtr_t_StaticFields::get_offset_of_Zero_1(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize340 = { sizeof (KnownTerminals_tC33732356694467E5C41300FDB5A86143590F1AE), -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize341 = { sizeof (MarshalByRefObject_tC4577953D0A44D0AB8597CFA868E01C858B1C9AF), sizeof(MarshalByRefObject_tC4577953D0A44D0AB8597CFA868E01C858B1C9AF_marshaled_pinvoke), 0, 0 };
extern const int32_t g_FieldOffsetTable341[1] =
{
MarshalByRefObject_tC4577953D0A44D0AB8597CFA868E01C858B1C9AF::get_offset_of__identity_0(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize342 = { sizeof (MonoAsyncCall_t5D4F895C7FEF7A36A60AFD3C64078A86BAF681FD), sizeof(MonoAsyncCall_t5D4F895C7FEF7A36A60AFD3C64078A86BAF681FD_marshaled_pinvoke), 0, 0 };
extern const int32_t g_FieldOffsetTable342[6] =
{
MonoAsyncCall_t5D4F895C7FEF7A36A60AFD3C64078A86BAF681FD::get_offset_of_msg_0(),
MonoAsyncCall_t5D4F895C7FEF7A36A60AFD3C64078A86BAF681FD::get_offset_of_cb_method_1(),
MonoAsyncCall_t5D4F895C7FEF7A36A60AFD3C64078A86BAF681FD::get_offset_of_cb_target_2(),
MonoAsyncCall_t5D4F895C7FEF7A36A60AFD3C64078A86BAF681FD::get_offset_of_state_3(),
MonoAsyncCall_t5D4F895C7FEF7A36A60AFD3C64078A86BAF681FD::get_offset_of_res_4(),
MonoAsyncCall_t5D4F895C7FEF7A36A60AFD3C64078A86BAF681FD::get_offset_of_out_args_5(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize343 = { sizeof (MonoCustomAttrs_t9E88BD614E6A34BF71106F71D0524DBA27E7FA98), -1, sizeof(MonoCustomAttrs_t9E88BD614E6A34BF71106F71D0524DBA27E7FA98_StaticFields), sizeof(MonoCustomAttrs_t9E88BD614E6A34BF71106F71D0524DBA27E7FA98_ThreadStaticFields) };
extern const int32_t g_FieldOffsetTable343[3] =
{
MonoCustomAttrs_t9E88BD614E6A34BF71106F71D0524DBA27E7FA98_StaticFields::get_offset_of_corlib_0(),
MonoCustomAttrs_t9E88BD614E6A34BF71106F71D0524DBA27E7FA98_ThreadStaticFields::get_offset_of_usage_cache_1() | THREAD_LOCAL_STATIC_MASK,
MonoCustomAttrs_t9E88BD614E6A34BF71106F71D0524DBA27E7FA98_StaticFields::get_offset_of_DefaultAttributeUsage_2(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize344 = { sizeof (AttributeInfo_t03612660D52EF536A548174E3C1CC246B848E91A), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable344[2] =
{
AttributeInfo_t03612660D52EF536A548174E3C1CC246B848E91A::get_offset_of__usage_0(),
AttributeInfo_t03612660D52EF536A548174E3C1CC246B848E91A::get_offset_of__inheritanceLevel_1(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize345 = { sizeof (MonoListItem_tF9FE02BB3D5D8507333C93F1AF79B60901947A64), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable345[2] =
{
MonoListItem_tF9FE02BB3D5D8507333C93F1AF79B60901947A64::get_offset_of_next_0(),
MonoListItem_tF9FE02BB3D5D8507333C93F1AF79B60901947A64::get_offset_of_data_1(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize346 = { sizeof (MonoType_t), -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize347 = { sizeof (MulticastDelegate_t), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable347[1] =
{
MulticastDelegate_t::get_offset_of_delegates_11(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize348 = { sizeof (NullConsoleDriver_t4608D1A2E1195946C2945E3459E15364CF4EC43D), -1, sizeof(NullConsoleDriver_t4608D1A2E1195946C2945E3459E15364CF4EC43D_StaticFields), 0 };
extern const int32_t g_FieldOffsetTable348[1] =
{
NullConsoleDriver_t4608D1A2E1195946C2945E3459E15364CF4EC43D_StaticFields::get_offset_of_EmptyConsoleKeyInfo_0(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize349 = { sizeof (Nullable_t07CA5C3F88F56004BCB589DD7580798C66874C44), -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize350 = { 0, 0, 0, 0 };
extern const int32_t g_FieldOffsetTable350[2] =
{
0,
0,
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize351 = { sizeof (NumberFormatter_t73E68FC7EA017E5EEB4AB92AF2FD959466D1A4BC), -1, sizeof(NumberFormatter_t73E68FC7EA017E5EEB4AB92AF2FD959466D1A4BC_StaticFields), sizeof(NumberFormatter_t73E68FC7EA017E5EEB4AB92AF2FD959466D1A4BC_ThreadStaticFields) };
extern const int32_t g_FieldOffsetTable351[26] =
{
NumberFormatter_t73E68FC7EA017E5EEB4AB92AF2FD959466D1A4BC_StaticFields::get_offset_of_MantissaBitsTable_0(),
NumberFormatter_t73E68FC7EA017E5EEB4AB92AF2FD959466D1A4BC_StaticFields::get_offset_of_TensExponentTable_1(),
NumberFormatter_t73E68FC7EA017E5EEB4AB92AF2FD959466D1A4BC_StaticFields::get_offset_of_DigitLowerTable_2(),
NumberFormatter_t73E68FC7EA017E5EEB4AB92AF2FD959466D1A4BC_StaticFields::get_offset_of_DigitUpperTable_3(),
NumberFormatter_t73E68FC7EA017E5EEB4AB92AF2FD959466D1A4BC_StaticFields::get_offset_of_TenPowersList_4(),
NumberFormatter_t73E68FC7EA017E5EEB4AB92AF2FD959466D1A4BC_StaticFields::get_offset_of_DecHexDigits_5(),
NumberFormatter_t73E68FC7EA017E5EEB4AB92AF2FD959466D1A4BC::get_offset_of__nfi_6(),
NumberFormatter_t73E68FC7EA017E5EEB4AB92AF2FD959466D1A4BC::get_offset_of__cbuf_7(),
NumberFormatter_t73E68FC7EA017E5EEB4AB92AF2FD959466D1A4BC::get_offset_of__NaN_8(),
NumberFormatter_t73E68FC7EA017E5EEB4AB92AF2FD959466D1A4BC::get_offset_of__infinity_9(),
NumberFormatter_t73E68FC7EA017E5EEB4AB92AF2FD959466D1A4BC::get_offset_of__isCustomFormat_10(),
NumberFormatter_t73E68FC7EA017E5EEB4AB92AF2FD959466D1A4BC::get_offset_of__specifierIsUpper_11(),
NumberFormatter_t73E68FC7EA017E5EEB4AB92AF2FD959466D1A4BC::get_offset_of__positive_12(),
NumberFormatter_t73E68FC7EA017E5EEB4AB92AF2FD959466D1A4BC::get_offset_of__specifier_13(),
NumberFormatter_t73E68FC7EA017E5EEB4AB92AF2FD959466D1A4BC::get_offset_of__precision_14(),
NumberFormatter_t73E68FC7EA017E5EEB4AB92AF2FD959466D1A4BC::get_offset_of__defPrecision_15(),
NumberFormatter_t73E68FC7EA017E5EEB4AB92AF2FD959466D1A4BC::get_offset_of__digitsLen_16(),
NumberFormatter_t73E68FC7EA017E5EEB4AB92AF2FD959466D1A4BC::get_offset_of__offset_17(),
NumberFormatter_t73E68FC7EA017E5EEB4AB92AF2FD959466D1A4BC::get_offset_of__decPointPos_18(),
NumberFormatter_t73E68FC7EA017E5EEB4AB92AF2FD959466D1A4BC::get_offset_of__val1_19(),
NumberFormatter_t73E68FC7EA017E5EEB4AB92AF2FD959466D1A4BC::get_offset_of__val2_20(),
NumberFormatter_t73E68FC7EA017E5EEB4AB92AF2FD959466D1A4BC::get_offset_of__val3_21(),
NumberFormatter_t73E68FC7EA017E5EEB4AB92AF2FD959466D1A4BC::get_offset_of__val4_22(),
NumberFormatter_t73E68FC7EA017E5EEB4AB92AF2FD959466D1A4BC::get_offset_of__ind_23(),
NumberFormatter_t73E68FC7EA017E5EEB4AB92AF2FD959466D1A4BC_ThreadStaticFields::get_offset_of_threadNumberFormatter_24() | THREAD_LOCAL_STATIC_MASK,
NumberFormatter_t73E68FC7EA017E5EEB4AB92AF2FD959466D1A4BC_ThreadStaticFields::get_offset_of_userFormatProvider_25() | THREAD_LOCAL_STATIC_MASK,
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize352 = { sizeof (CustomInfo_t3C5397567D3BBF326ED9C3D9680AE658DE4612E1), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable352[14] =
{
CustomInfo_t3C5397567D3BBF326ED9C3D9680AE658DE4612E1::get_offset_of_UseGroup_0(),
CustomInfo_t3C5397567D3BBF326ED9C3D9680AE658DE4612E1::get_offset_of_DecimalDigits_1(),
CustomInfo_t3C5397567D3BBF326ED9C3D9680AE658DE4612E1::get_offset_of_DecimalPointPos_2(),
CustomInfo_t3C5397567D3BBF326ED9C3D9680AE658DE4612E1::get_offset_of_DecimalTailSharpDigits_3(),
CustomInfo_t3C5397567D3BBF326ED9C3D9680AE658DE4612E1::get_offset_of_IntegerDigits_4(),
CustomInfo_t3C5397567D3BBF326ED9C3D9680AE658DE4612E1::get_offset_of_IntegerHeadSharpDigits_5(),
CustomInfo_t3C5397567D3BBF326ED9C3D9680AE658DE4612E1::get_offset_of_IntegerHeadPos_6(),
CustomInfo_t3C5397567D3BBF326ED9C3D9680AE658DE4612E1::get_offset_of_UseExponent_7(),
CustomInfo_t3C5397567D3BBF326ED9C3D9680AE658DE4612E1::get_offset_of_ExponentDigits_8(),
CustomInfo_t3C5397567D3BBF326ED9C3D9680AE658DE4612E1::get_offset_of_ExponentTailSharpDigits_9(),
CustomInfo_t3C5397567D3BBF326ED9C3D9680AE658DE4612E1::get_offset_of_ExponentNegativeSignOnly_10(),
CustomInfo_t3C5397567D3BBF326ED9C3D9680AE658DE4612E1::get_offset_of_DividePlaces_11(),
CustomInfo_t3C5397567D3BBF326ED9C3D9680AE658DE4612E1::get_offset_of_Percents_12(),
CustomInfo_t3C5397567D3BBF326ED9C3D9680AE658DE4612E1::get_offset_of_Permilles_13(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize353 = { sizeof (RuntimeObject), -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize354 = { sizeof (OperatingSystem_tBB05846D5AA6960FFEB42C59E5FE359255C2BE83), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable354[3] =
{
OperatingSystem_tBB05846D5AA6960FFEB42C59E5FE359255C2BE83::get_offset_of__platform_0(),
OperatingSystem_tBB05846D5AA6960FFEB42C59E5FE359255C2BE83::get_offset_of__version_1(),
OperatingSystem_tBB05846D5AA6960FFEB42C59E5FE359255C2BE83::get_offset_of__servicePack_2(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize355 = { sizeof (PlatformID_t7969561D329B66D3E609C70CA506A519E06F2776)+ sizeof (RuntimeObject), sizeof(int32_t), 0, 0 };
extern const int32_t g_FieldOffsetTable355[8] =
{
PlatformID_t7969561D329B66D3E609C70CA506A519E06F2776::get_offset_of_value___2() + static_cast<int32_t>(sizeof(RuntimeObject)),
0,
0,
0,
0,
0,
0,
0,
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize356 = { sizeof (ResolveEventArgs_t116CF9DB06BCFEB8933CEAD4A35389A7CA9EB75D), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable356[2] =
{
ResolveEventArgs_t116CF9DB06BCFEB8933CEAD4A35389A7CA9EB75D::get_offset_of_m_Name_1(),
ResolveEventArgs_t116CF9DB06BCFEB8933CEAD4A35389A7CA9EB75D::get_offset_of_m_Requesting_2(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize357 = { sizeof (ResolveEventHandler_t045C469BEA8B632FA99FE8867C921BA8DAE0BEE5), sizeof(Il2CppMethodPointer), 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize358 = { sizeof (RuntimeArgumentHandle_t6118B2666F632AA0A554B476D9A447ACDBF08C46)+ sizeof (RuntimeObject), sizeof(RuntimeArgumentHandle_t6118B2666F632AA0A554B476D9A447ACDBF08C46 ), 0, 0 };
extern const int32_t g_FieldOffsetTable358[1] =
{
RuntimeArgumentHandle_t6118B2666F632AA0A554B476D9A447ACDBF08C46::get_offset_of_args_0() + static_cast<int32_t>(sizeof(RuntimeObject)),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize359 = { sizeof (RuntimeFieldHandle_t844BDF00E8E6FE69D9AEAA7657F09018B864F4EF)+ sizeof (RuntimeObject), sizeof(RuntimeFieldHandle_t844BDF00E8E6FE69D9AEAA7657F09018B864F4EF ), 0, 0 };
extern const int32_t g_FieldOffsetTable359[1] =
{
RuntimeFieldHandle_t844BDF00E8E6FE69D9AEAA7657F09018B864F4EF::get_offset_of_value_0() + static_cast<int32_t>(sizeof(RuntimeObject)),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize360 = { sizeof (RuntimeMethodHandle_t85058E06EFF8AE085FAB91CE2B9E28E7F6FAE33F)+ sizeof (RuntimeObject), sizeof(RuntimeMethodHandle_t85058E06EFF8AE085FAB91CE2B9E28E7F6FAE33F ), 0, 0 };
extern const int32_t g_FieldOffsetTable360[1] =
{
RuntimeMethodHandle_t85058E06EFF8AE085FAB91CE2B9E28E7F6FAE33F::get_offset_of_value_0() + static_cast<int32_t>(sizeof(RuntimeObject)),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize361 = { sizeof (RuntimeTypeHandle_t7B542280A22F0EC4EAC2061C29178845847A8B2D)+ sizeof (RuntimeObject), sizeof(RuntimeTypeHandle_t7B542280A22F0EC4EAC2061C29178845847A8B2D ), 0, 0 };
extern const int32_t g_FieldOffsetTable361[1] =
{
RuntimeTypeHandle_t7B542280A22F0EC4EAC2061C29178845847A8B2D::get_offset_of_value_0() + static_cast<int32_t>(sizeof(RuntimeObject)),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize362 = { sizeof (StringComparison_t02BAA95468CE9E91115C604577611FDF58FEDCF0)+ sizeof (RuntimeObject), sizeof(int32_t), 0, 0 };
extern const int32_t g_FieldOffsetTable362[7] =
{
StringComparison_t02BAA95468CE9E91115C604577611FDF58FEDCF0::get_offset_of_value___2() + static_cast<int32_t>(sizeof(RuntimeObject)),
0,
0,
0,
0,
0,
0,
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize363 = { sizeof (TermInfoDriver_t9D1F8B74E923C24C63FBE861B6DDCE7CF05A3653), -1, sizeof(TermInfoDriver_t9D1F8B74E923C24C63FBE861B6DDCE7CF05A3653_StaticFields), 0 };
extern const int32_t g_FieldOffsetTable363[44] =
{
TermInfoDriver_t9D1F8B74E923C24C63FBE861B6DDCE7CF05A3653_StaticFields::get_offset_of_native_terminal_size_0(),
TermInfoDriver_t9D1F8B74E923C24C63FBE861B6DDCE7CF05A3653_StaticFields::get_offset_of_terminal_size_1(),
TermInfoDriver_t9D1F8B74E923C24C63FBE861B6DDCE7CF05A3653_StaticFields::get_offset_of_locations_2(),
TermInfoDriver_t9D1F8B74E923C24C63FBE861B6DDCE7CF05A3653::get_offset_of_reader_3(),
TermInfoDriver_t9D1F8B74E923C24C63FBE861B6DDCE7CF05A3653::get_offset_of_cursorLeft_4(),
TermInfoDriver_t9D1F8B74E923C24C63FBE861B6DDCE7CF05A3653::get_offset_of_cursorTop_5(),
TermInfoDriver_t9D1F8B74E923C24C63FBE861B6DDCE7CF05A3653::get_offset_of_title_6(),
TermInfoDriver_t9D1F8B74E923C24C63FBE861B6DDCE7CF05A3653::get_offset_of_titleFormat_7(),
TermInfoDriver_t9D1F8B74E923C24C63FBE861B6DDCE7CF05A3653::get_offset_of_cursorVisible_8(),
TermInfoDriver_t9D1F8B74E923C24C63FBE861B6DDCE7CF05A3653::get_offset_of_csrVisible_9(),
TermInfoDriver_t9D1F8B74E923C24C63FBE861B6DDCE7CF05A3653::get_offset_of_csrInvisible_10(),
TermInfoDriver_t9D1F8B74E923C24C63FBE861B6DDCE7CF05A3653::get_offset_of_clear_11(),
TermInfoDriver_t9D1F8B74E923C24C63FBE861B6DDCE7CF05A3653::get_offset_of_bell_12(),
TermInfoDriver_t9D1F8B74E923C24C63FBE861B6DDCE7CF05A3653::get_offset_of_term_13(),
TermInfoDriver_t9D1F8B74E923C24C63FBE861B6DDCE7CF05A3653::get_offset_of_stdin_14(),
TermInfoDriver_t9D1F8B74E923C24C63FBE861B6DDCE7CF05A3653::get_offset_of_stdout_15(),
TermInfoDriver_t9D1F8B74E923C24C63FBE861B6DDCE7CF05A3653::get_offset_of_windowWidth_16(),
TermInfoDriver_t9D1F8B74E923C24C63FBE861B6DDCE7CF05A3653::get_offset_of_windowHeight_17(),
TermInfoDriver_t9D1F8B74E923C24C63FBE861B6DDCE7CF05A3653::get_offset_of_bufferHeight_18(),
TermInfoDriver_t9D1F8B74E923C24C63FBE861B6DDCE7CF05A3653::get_offset_of_bufferWidth_19(),
TermInfoDriver_t9D1F8B74E923C24C63FBE861B6DDCE7CF05A3653::get_offset_of_buffer_20(),
TermInfoDriver_t9D1F8B74E923C24C63FBE861B6DDCE7CF05A3653::get_offset_of_readpos_21(),
TermInfoDriver_t9D1F8B74E923C24C63FBE861B6DDCE7CF05A3653::get_offset_of_writepos_22(),
TermInfoDriver_t9D1F8B74E923C24C63FBE861B6DDCE7CF05A3653::get_offset_of_keypadXmit_23(),
TermInfoDriver_t9D1F8B74E923C24C63FBE861B6DDCE7CF05A3653::get_offset_of_keypadLocal_24(),
TermInfoDriver_t9D1F8B74E923C24C63FBE861B6DDCE7CF05A3653::get_offset_of_inited_25(),
TermInfoDriver_t9D1F8B74E923C24C63FBE861B6DDCE7CF05A3653::get_offset_of_initLock_26(),
TermInfoDriver_t9D1F8B74E923C24C63FBE861B6DDCE7CF05A3653::get_offset_of_initKeys_27(),
TermInfoDriver_t9D1F8B74E923C24C63FBE861B6DDCE7CF05A3653::get_offset_of_origPair_28(),
TermInfoDriver_t9D1F8B74E923C24C63FBE861B6DDCE7CF05A3653::get_offset_of_origColors_29(),
TermInfoDriver_t9D1F8B74E923C24C63FBE861B6DDCE7CF05A3653::get_offset_of_cursorAddress_30(),
TermInfoDriver_t9D1F8B74E923C24C63FBE861B6DDCE7CF05A3653::get_offset_of_fgcolor_31(),
TermInfoDriver_t9D1F8B74E923C24C63FBE861B6DDCE7CF05A3653::get_offset_of_setfgcolor_32(),
TermInfoDriver_t9D1F8B74E923C24C63FBE861B6DDCE7CF05A3653::get_offset_of_setbgcolor_33(),
TermInfoDriver_t9D1F8B74E923C24C63FBE861B6DDCE7CF05A3653::get_offset_of_maxColors_34(),
TermInfoDriver_t9D1F8B74E923C24C63FBE861B6DDCE7CF05A3653::get_offset_of_noGetPosition_35(),
TermInfoDriver_t9D1F8B74E923C24C63FBE861B6DDCE7CF05A3653::get_offset_of_keymap_36(),
TermInfoDriver_t9D1F8B74E923C24C63FBE861B6DDCE7CF05A3653::get_offset_of_rootmap_37(),
TermInfoDriver_t9D1F8B74E923C24C63FBE861B6DDCE7CF05A3653::get_offset_of_rl_startx_38(),
TermInfoDriver_t9D1F8B74E923C24C63FBE861B6DDCE7CF05A3653::get_offset_of_rl_starty_39(),
TermInfoDriver_t9D1F8B74E923C24C63FBE861B6DDCE7CF05A3653::get_offset_of_control_characters_40(),
TermInfoDriver_t9D1F8B74E923C24C63FBE861B6DDCE7CF05A3653_StaticFields::get_offset_of__consoleColorToAnsiCode_41(),
TermInfoDriver_t9D1F8B74E923C24C63FBE861B6DDCE7CF05A3653::get_offset_of_echobuf_42(),
TermInfoDriver_t9D1F8B74E923C24C63FBE861B6DDCE7CF05A3653::get_offset_of_echon_43(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize364 = { sizeof (ParameterizedStrings_t495ED7291D56B901CAA1F10EC25739C3C99DC923), -1, 0, sizeof(ParameterizedStrings_t495ED7291D56B901CAA1F10EC25739C3C99DC923_ThreadStaticFields) };
extern const int32_t g_FieldOffsetTable364[1] =
{
ParameterizedStrings_t495ED7291D56B901CAA1F10EC25739C3C99DC923_ThreadStaticFields::get_offset_of__cachedStack_0() | THREAD_LOCAL_STATIC_MASK,
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize365 = { sizeof (FormatParam_t1901DD0E7CD1B3A17B09040A6E2FCA5307328800)+ sizeof (RuntimeObject), sizeof(FormatParam_t1901DD0E7CD1B3A17B09040A6E2FCA5307328800_marshaled_pinvoke), 0, 0 };
extern const int32_t g_FieldOffsetTable365[2] =
{
FormatParam_t1901DD0E7CD1B3A17B09040A6E2FCA5307328800::get_offset_of__int32_0() + static_cast<int32_t>(sizeof(RuntimeObject)),
FormatParam_t1901DD0E7CD1B3A17B09040A6E2FCA5307328800::get_offset_of__string_1() + static_cast<int32_t>(sizeof(RuntimeObject)),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize366 = { sizeof (LowLevelStack_tAED9B2A5CEC7125CF57BEE067AC399CEE3510EC2), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable366[2] =
{
LowLevelStack_tAED9B2A5CEC7125CF57BEE067AC399CEE3510EC2::get_offset_of__arr_0(),
LowLevelStack_tAED9B2A5CEC7125CF57BEE067AC399CEE3510EC2::get_offset_of__count_1(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize367 = { sizeof (ByteMatcher_tB199BDD35E2575B84D9FDED34954705653D241DC), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable367[2] =
{
ByteMatcher_tB199BDD35E2575B84D9FDED34954705653D241DC::get_offset_of_map_0(),
ByteMatcher_tB199BDD35E2575B84D9FDED34954705653D241DC::get_offset_of_starts_1(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize368 = { sizeof (TermInfoNumbers_tE17C1E4A28232B0A786FAB261BD41BA350DF230B)+ sizeof (RuntimeObject), sizeof(int32_t), 0, 0 };
extern const int32_t g_FieldOffsetTable368[35] =
{
TermInfoNumbers_tE17C1E4A28232B0A786FAB261BD41BA350DF230B::get_offset_of_value___2() + static_cast<int32_t>(sizeof(RuntimeObject)),
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize369 = { sizeof (TermInfoReader_tCAABF3484E6F0AA298F809766C52CA9DC4E6C55C), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable369[5] =
{
TermInfoReader_tCAABF3484E6F0AA298F809766C52CA9DC4E6C55C::get_offset_of_boolSize_0(),
TermInfoReader_tCAABF3484E6F0AA298F809766C52CA9DC4E6C55C::get_offset_of_numSize_1(),
TermInfoReader_tCAABF3484E6F0AA298F809766C52CA9DC4E6C55C::get_offset_of_strOffsets_2(),
TermInfoReader_tCAABF3484E6F0AA298F809766C52CA9DC4E6C55C::get_offset_of_buffer_3(),
TermInfoReader_tCAABF3484E6F0AA298F809766C52CA9DC4E6C55C::get_offset_of_booleansOffset_4(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize370 = { sizeof (TermInfoStrings_tA50FD6AB2B4EFB66E90CD563942E0A664FD6022F)+ sizeof (RuntimeObject), sizeof(int32_t), 0, 0 };
extern const int32_t g_FieldOffsetTable370[396] =
{
TermInfoStrings_tA50FD6AB2B4EFB66E90CD563942E0A664FD6022F::get_offset_of_value___2() + static_cast<int32_t>(sizeof(RuntimeObject)),
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize371 = { sizeof (TimeZone_tA2DF435DA1A379978B885F0872A93774666B7454), -1, sizeof(TimeZone_tA2DF435DA1A379978B885F0872A93774666B7454_StaticFields), 0 };
extern const int32_t g_FieldOffsetTable371[1] =
{
TimeZone_tA2DF435DA1A379978B885F0872A93774666B7454_StaticFields::get_offset_of_tz_lock_0(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize372 = { sizeof (CurrentSystemTimeZone_t7689B8BF1C4A474BD3CFA5B8E89FA84A53D44171), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable372[1] =
{
CurrentSystemTimeZone_t7689B8BF1C4A474BD3CFA5B8E89FA84A53D44171::get_offset_of_LocalTimeZone_1(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize373 = { sizeof (TimeType_t1E0366D2FDDE13B93F6DFD1A2FB8645B76E9DDA9), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable373[3] =
{
TimeType_t1E0366D2FDDE13B93F6DFD1A2FB8645B76E9DDA9::get_offset_of_Offset_0(),
TimeType_t1E0366D2FDDE13B93F6DFD1A2FB8645B76E9DDA9::get_offset_of_IsDst_1(),
TimeType_t1E0366D2FDDE13B93F6DFD1A2FB8645B76E9DDA9::get_offset_of_Name_2(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize374 = { sizeof (TypeCode_t03ED52F888000DAF40C550C434F29F39A23D61C6)+ sizeof (RuntimeObject), sizeof(int32_t), 0, 0 };
extern const int32_t g_FieldOffsetTable374[19] =
{
TypeCode_t03ED52F888000DAF40C550C434F29F39A23D61C6::get_offset_of_value___2() + static_cast<int32_t>(sizeof(RuntimeObject)),
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize375 = { 0, -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize376 = { 0, -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize377 = { sizeof (TypeNames_t59FBD5EB0A62A2B3A8178016670631D61DEE00F9), -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize378 = { sizeof (ATypeName_t8FD4A465E3C2846D11FEAE25ED5BF3D67FF94421), -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize379 = { sizeof (TypeIdentifiers_tBC5BC4024D376DCB779D877A1616CF4D7DB809E6), -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize380 = { sizeof (Display_t0222D7CB4CF0F85131FC5E26328FE94E0A27F5E5), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable380[2] =
{
Display_t0222D7CB4CF0F85131FC5E26328FE94E0A27F5E5::get_offset_of_displayName_0(),
Display_t0222D7CB4CF0F85131FC5E26328FE94E0A27F5E5::get_offset_of_internal_name_1(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize381 = { 0, -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize382 = { sizeof (ArraySpec_tF374BB8994F7190916C6F14C7EA8FE6EFE017970), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable382[2] =
{
ArraySpec_tF374BB8994F7190916C6F14C7EA8FE6EFE017970::get_offset_of_dimensions_0(),
ArraySpec_tF374BB8994F7190916C6F14C7EA8FE6EFE017970::get_offset_of_bound_1(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize383 = { sizeof (PointerSpec_tBCE1666DC24EC6E4E5376FEC214499984EC26892), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable383[1] =
{
PointerSpec_tBCE1666DC24EC6E4E5376FEC214499984EC26892::get_offset_of_pointer_level_0(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize384 = { sizeof (TypeSpec_t943289F7C537252144A22588159B36C6B6759A7F), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable384[7] =
{
TypeSpec_t943289F7C537252144A22588159B36C6B6759A7F::get_offset_of_name_0(),
TypeSpec_t943289F7C537252144A22588159B36C6B6759A7F::get_offset_of_assembly_name_1(),
TypeSpec_t943289F7C537252144A22588159B36C6B6759A7F::get_offset_of_nested_2(),
TypeSpec_t943289F7C537252144A22588159B36C6B6759A7F::get_offset_of_generic_params_3(),
TypeSpec_t943289F7C537252144A22588159B36C6B6759A7F::get_offset_of_modifier_spec_4(),
TypeSpec_t943289F7C537252144A22588159B36C6B6759A7F::get_offset_of_is_byref_5(),
TypeSpec_t943289F7C537252144A22588159B36C6B6759A7F::get_offset_of_display_fullname_6(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize385 = { sizeof (DisplayNameFormat_tFEA54E2FCA44D62D61CCCE98E4F02DE2D186DF47)+ sizeof (RuntimeObject), sizeof(int32_t), 0, 0 };
extern const int32_t g_FieldOffsetTable385[4] =
{
DisplayNameFormat_tFEA54E2FCA44D62D61CCCE98E4F02DE2D186DF47::get_offset_of_value___2() + static_cast<int32_t>(sizeof(RuntimeObject)),
0,
0,
0,
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize386 = { sizeof (UIntPtr_t)+ sizeof (RuntimeObject), sizeof(uintptr_t), sizeof(UIntPtr_t_StaticFields), 0 };
extern const int32_t g_FieldOffsetTable386[2] =
{
UIntPtr_t_StaticFields::get_offset_of_Zero_0(),
UIntPtr_t::get_offset_of__pointer_1() + static_cast<int32_t>(sizeof(RuntimeObject)),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize387 = { sizeof (ValueType_t4D0C27076F7C36E76190FB3328E232BCB1CD1FFF), sizeof(ValueType_t4D0C27076F7C36E76190FB3328E232BCB1CD1FFF_marshaled_pinvoke), 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize388 = { sizeof (Variant_tBC94A369178CDE161E918F24FD18166A3DC58C18)+ sizeof (RuntimeObject), sizeof(Variant_tBC94A369178CDE161E918F24FD18166A3DC58C18 ), 0, 0 };
extern const int32_t g_FieldOffsetTable388[20] =
{
Variant_tBC94A369178CDE161E918F24FD18166A3DC58C18::get_offset_of_vt_0() + static_cast<int32_t>(sizeof(RuntimeObject)),
Variant_tBC94A369178CDE161E918F24FD18166A3DC58C18::get_offset_of_wReserved1_1() + static_cast<int32_t>(sizeof(RuntimeObject)),
Variant_tBC94A369178CDE161E918F24FD18166A3DC58C18::get_offset_of_wReserved2_2() + static_cast<int32_t>(sizeof(RuntimeObject)),
Variant_tBC94A369178CDE161E918F24FD18166A3DC58C18::get_offset_of_wReserved3_3() + static_cast<int32_t>(sizeof(RuntimeObject)),
Variant_tBC94A369178CDE161E918F24FD18166A3DC58C18::get_offset_of_llVal_4() + static_cast<int32_t>(sizeof(RuntimeObject)),
Variant_tBC94A369178CDE161E918F24FD18166A3DC58C18::get_offset_of_lVal_5() + static_cast<int32_t>(sizeof(RuntimeObject)),
Variant_tBC94A369178CDE161E918F24FD18166A3DC58C18::get_offset_of_bVal_6() + static_cast<int32_t>(sizeof(RuntimeObject)),
Variant_tBC94A369178CDE161E918F24FD18166A3DC58C18::get_offset_of_iVal_7() + static_cast<int32_t>(sizeof(RuntimeObject)),
Variant_tBC94A369178CDE161E918F24FD18166A3DC58C18::get_offset_of_fltVal_8() + static_cast<int32_t>(sizeof(RuntimeObject)),
Variant_tBC94A369178CDE161E918F24FD18166A3DC58C18::get_offset_of_dblVal_9() + static_cast<int32_t>(sizeof(RuntimeObject)),
Variant_tBC94A369178CDE161E918F24FD18166A3DC58C18::get_offset_of_boolVal_10() + static_cast<int32_t>(sizeof(RuntimeObject)),
Variant_tBC94A369178CDE161E918F24FD18166A3DC58C18::get_offset_of_bstrVal_11() + static_cast<int32_t>(sizeof(RuntimeObject)),
Variant_tBC94A369178CDE161E918F24FD18166A3DC58C18::get_offset_of_cVal_12() + static_cast<int32_t>(sizeof(RuntimeObject)),
Variant_tBC94A369178CDE161E918F24FD18166A3DC58C18::get_offset_of_uiVal_13() + static_cast<int32_t>(sizeof(RuntimeObject)),
Variant_tBC94A369178CDE161E918F24FD18166A3DC58C18::get_offset_of_ulVal_14() + static_cast<int32_t>(sizeof(RuntimeObject)),
Variant_tBC94A369178CDE161E918F24FD18166A3DC58C18::get_offset_of_ullVal_15() + static_cast<int32_t>(sizeof(RuntimeObject)),
Variant_tBC94A369178CDE161E918F24FD18166A3DC58C18::get_offset_of_intVal_16() + static_cast<int32_t>(sizeof(RuntimeObject)),
Variant_tBC94A369178CDE161E918F24FD18166A3DC58C18::get_offset_of_uintVal_17() + static_cast<int32_t>(sizeof(RuntimeObject)),
Variant_tBC94A369178CDE161E918F24FD18166A3DC58C18::get_offset_of_pdispVal_18() + static_cast<int32_t>(sizeof(RuntimeObject)),
Variant_tBC94A369178CDE161E918F24FD18166A3DC58C18::get_offset_of_bRecord_19() + static_cast<int32_t>(sizeof(RuntimeObject)),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize389 = { sizeof (BRECORD_tDDC5F1A5DC569C234C6141FCBA5F8DE8293BC601)+ sizeof (RuntimeObject), sizeof(BRECORD_tDDC5F1A5DC569C234C6141FCBA5F8DE8293BC601 ), 0, 0 };
extern const int32_t g_FieldOffsetTable389[2] =
{
BRECORD_tDDC5F1A5DC569C234C6141FCBA5F8DE8293BC601::get_offset_of_pvRecord_0() + static_cast<int32_t>(sizeof(RuntimeObject)),
BRECORD_tDDC5F1A5DC569C234C6141FCBA5F8DE8293BC601::get_offset_of_pRecInfo_1() + static_cast<int32_t>(sizeof(RuntimeObject)),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize390 = { sizeof (Void_t22962CB4C05B1D89B55A6E1139F0E87A90987017)+ sizeof (RuntimeObject), 1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize391 = { sizeof (WeakReference_t0495CC81CD6403E662B7700B802443F6F730E39D), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable391[2] =
{
WeakReference_t0495CC81CD6403E662B7700B802443F6F730E39D::get_offset_of_isLongReference_0(),
WeakReference_t0495CC81CD6403E662B7700B802443F6F730E39D::get_offset_of_gcHandle_1(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize392 = { sizeof (InputRecord_tAB007C739F339BE208F3C4796B53E9044ADF0A78)+ sizeof (RuntimeObject), sizeof(InputRecord_tAB007C739F339BE208F3C4796B53E9044ADF0A78_marshaled_pinvoke), 0, 0 };
extern const int32_t g_FieldOffsetTable392[9] =
{
InputRecord_tAB007C739F339BE208F3C4796B53E9044ADF0A78::get_offset_of_EventType_0() + static_cast<int32_t>(sizeof(RuntimeObject)),
InputRecord_tAB007C739F339BE208F3C4796B53E9044ADF0A78::get_offset_of_KeyDown_1() + static_cast<int32_t>(sizeof(RuntimeObject)),
InputRecord_tAB007C739F339BE208F3C4796B53E9044ADF0A78::get_offset_of_RepeatCount_2() + static_cast<int32_t>(sizeof(RuntimeObject)),
InputRecord_tAB007C739F339BE208F3C4796B53E9044ADF0A78::get_offset_of_VirtualKeyCode_3() + static_cast<int32_t>(sizeof(RuntimeObject)),
InputRecord_tAB007C739F339BE208F3C4796B53E9044ADF0A78::get_offset_of_VirtualScanCode_4() + static_cast<int32_t>(sizeof(RuntimeObject)),
InputRecord_tAB007C739F339BE208F3C4796B53E9044ADF0A78::get_offset_of_Character_5() + static_cast<int32_t>(sizeof(RuntimeObject)),
InputRecord_tAB007C739F339BE208F3C4796B53E9044ADF0A78::get_offset_of_ControlKeyState_6() + static_cast<int32_t>(sizeof(RuntimeObject)),
InputRecord_tAB007C739F339BE208F3C4796B53E9044ADF0A78::get_offset_of_pad1_7() + static_cast<int32_t>(sizeof(RuntimeObject)),
InputRecord_tAB007C739F339BE208F3C4796B53E9044ADF0A78::get_offset_of_pad2_8() + static_cast<int32_t>(sizeof(RuntimeObject)),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize393 = { sizeof (Coord_t6CEFF682745DD47B1B4DA3ED268C0933021AC34A)+ sizeof (RuntimeObject), sizeof(Coord_t6CEFF682745DD47B1B4DA3ED268C0933021AC34A ), 0, 0 };
extern const int32_t g_FieldOffsetTable393[2] =
{
Coord_t6CEFF682745DD47B1B4DA3ED268C0933021AC34A::get_offset_of_X_0() + static_cast<int32_t>(sizeof(RuntimeObject)),
Coord_t6CEFF682745DD47B1B4DA3ED268C0933021AC34A::get_offset_of_Y_1() + static_cast<int32_t>(sizeof(RuntimeObject)),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize394 = { sizeof (SmallRect_t18C271B0FF660F6ED4EC6D99B26C4D35F51CA532)+ sizeof (RuntimeObject), sizeof(SmallRect_t18C271B0FF660F6ED4EC6D99B26C4D35F51CA532 ), 0, 0 };
extern const int32_t g_FieldOffsetTable394[4] =
{
SmallRect_t18C271B0FF660F6ED4EC6D99B26C4D35F51CA532::get_offset_of_Left_0() + static_cast<int32_t>(sizeof(RuntimeObject)),
SmallRect_t18C271B0FF660F6ED4EC6D99B26C4D35F51CA532::get_offset_of_Top_1() + static_cast<int32_t>(sizeof(RuntimeObject)),
SmallRect_t18C271B0FF660F6ED4EC6D99B26C4D35F51CA532::get_offset_of_Right_2() + static_cast<int32_t>(sizeof(RuntimeObject)),
SmallRect_t18C271B0FF660F6ED4EC6D99B26C4D35F51CA532::get_offset_of_Bottom_3() + static_cast<int32_t>(sizeof(RuntimeObject)),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize395 = { sizeof (ConsoleScreenBufferInfo_tA8045B7C44EF25956D3B0847F24465E9CF18954F)+ sizeof (RuntimeObject), sizeof(ConsoleScreenBufferInfo_tA8045B7C44EF25956D3B0847F24465E9CF18954F ), 0, 0 };
extern const int32_t g_FieldOffsetTable395[5] =
{
ConsoleScreenBufferInfo_tA8045B7C44EF25956D3B0847F24465E9CF18954F::get_offset_of_Size_0() + static_cast<int32_t>(sizeof(RuntimeObject)),
ConsoleScreenBufferInfo_tA8045B7C44EF25956D3B0847F24465E9CF18954F::get_offset_of_CursorPosition_1() + static_cast<int32_t>(sizeof(RuntimeObject)),
ConsoleScreenBufferInfo_tA8045B7C44EF25956D3B0847F24465E9CF18954F::get_offset_of_Attribute_2() + static_cast<int32_t>(sizeof(RuntimeObject)),
ConsoleScreenBufferInfo_tA8045B7C44EF25956D3B0847F24465E9CF18954F::get_offset_of_Window_3() + static_cast<int32_t>(sizeof(RuntimeObject)),
ConsoleScreenBufferInfo_tA8045B7C44EF25956D3B0847F24465E9CF18954F::get_offset_of_MaxWindowSize_4() + static_cast<int32_t>(sizeof(RuntimeObject)),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize396 = { sizeof (Handles_tC13FB0F0810977450CE811097C1B15BCF5E4CAD7)+ sizeof (RuntimeObject), sizeof(int32_t), 0, 0 };
extern const int32_t g_FieldOffsetTable396[4] =
{
Handles_tC13FB0F0810977450CE811097C1B15BCF5E4CAD7::get_offset_of_value___2() + static_cast<int32_t>(sizeof(RuntimeObject)),
0,
0,
0,
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize397 = { sizeof (WindowsConsoleDriver_t953AB92956013BD3ED7E260FEC4944E603008B42), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable397[3] =
{
WindowsConsoleDriver_t953AB92956013BD3ED7E260FEC4944E603008B42::get_offset_of_inputHandle_0(),
WindowsConsoleDriver_t953AB92956013BD3ED7E260FEC4944E603008B42::get_offset_of_outputHandle_1(),
WindowsConsoleDriver_t953AB92956013BD3ED7E260FEC4944E603008B42::get_offset_of_defaultAttribute_2(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize398 = { sizeof (__ComObject_t7C4C78B18A827C344A9826ECC7FCC40B7F6FD77C), -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize399 = { sizeof (AssemblyHashAlgorithm_t31E4F1BC642CF668706C9D0FBD9DFDF5EE01CEB9)+ sizeof (RuntimeObject), sizeof(int32_t), 0, 0 };
extern const int32_t g_FieldOffsetTable399[7] =
{
AssemblyHashAlgorithm_t31E4F1BC642CF668706C9D0FBD9DFDF5EE01CEB9::get_offset_of_value___2() + static_cast<int32_t>(sizeof(RuntimeObject)),
0,
0,
0,
0,
0,
0,
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
| [
"leungkachiiiii@gmail.com"
] | leungkachiiiii@gmail.com |
98c52b8e605ccf1d5c4173847ef2fec5f804ea0e | ab2c6c1488074011d42a144e5c68fa8c6ad43bcf | /cforces/631B.cc | e33d3f1c371ef1e531517d562441ceb806859a96 | [] | no_license | mtszkw/contests | 491883aa9f596e6dbd213049baee3a5c58d4a492 | 5b66d26be114fe12e5c1bc102ae4c3bafbc764e9 | refs/heads/master | 2021-07-09T07:55:05.221632 | 2017-10-08T20:11:24 | 2017-10-08T20:11:24 | 101,620,189 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 801 | cc | #include <bits/stdc++.h>
using namespace std;
#define iosync ios_base::sync_with_stdio(0)
struct Cell {
int layer, colour;
Cell() { layer=0; colour=0; }
};
int main() {
iosync;
Cell rows[5001], cols[5001];
int n, m, queries, q_type, q_cells, q_colour;
cin >> n >> m >> queries;
for(int query=1; query<=queries; ++query) {
cin >> q_type >> q_cells >> q_colour;
if(q_type == 1) { //paint row 'q_cells' with 'q_colour'
rows[q_cells].layer = query;
rows[q_cells].colour = q_colour;
}
else { //paint col 'q_cells' with 'q_colour'
cols[q_cells].layer = query;
cols[q_cells].colour = q_colour;
}
}
for(int i=1; i<=n; ++i) {
for(int j=1; j<=m; ++j) {
cout << (rows[i].layer > cols[j].layer ? rows[i].colour :cols[j].colour) << " \n"[j==m];
}
}
return 0;
}
| [
"kwasniak.mateusz@gmail.com"
] | kwasniak.mateusz@gmail.com |
20ffccd87e36baed4935962d63866943700ddcf8 | de6128d5e4221677aef571a876df8b53a08b5cd3 | /windows/pp/04-trianglePerspective/trianglePerspective.cpp | 620e9a404096f3956e64936e2794e6bee7035bd0 | [] | no_license | ssijonson/realTimeRendering | 2d97fa7a20d94aae460a8496283247c1c5ad962f | d0a37138dbf8a618976ac292ee35e67382499601 | refs/heads/master | 2023-03-16T19:48:29.889647 | 2018-10-16T19:35:58 | 2018-10-16T19:35:58 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 15,885 | cpp | #include <windows.h>
#include <stdio.h>
#include <gl/glew.h>
#include <gl/gl.h>
#include "resources/resource.h"
#include "vmath.h"
HWND hWnd = NULL;
HDC hdc = NULL;
HGLRC hrc = NULL;
DWORD dwStyle;
WINDOWPLACEMENT wpPrev = { sizeof(WINDOWPLACEMENT) };
RECT windowRect = {0, 0, 800, 600};
bool isFullscreen = false;
bool isActive = false;
bool isEscapeKeyPressed = false;
enum
{
CG_ATTRIBUTE_VERTEX_POSITION = 0,
CG_ATTRIBUTE_COLOR,
CG_ATTRIBUTE_NORMAL,
CG_ATTRIBUTE_TEXTURE,
};
GLuint vertexShaderObject = 0;
GLuint fragmentShaderObject = 0;
GLuint shaderProgramObject = 0;
GLuint vao = 0;
GLuint vbo = 0;
GLuint mvpUniform = 0;
vmath::mat4 perspectiveProjectionMatrix;
FILE *logFile = NULL;
LRESULT CALLBACK WndProc(HWND hWnd, UINT iMessage, WPARAM wParam, LPARAM lParam);
void initialize(void);
void listExtensions(void);
void initializeVertexShader(void);
void initializeFragmentShader(void);
void initializeShaderProgram(void);
void initializeBuffers(void);
void cleanUp(void);
void display(void);
void resize(int width, int height);
void toggleFullscreen(HWND hWnd, bool isFullscreen);
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInsatnce, LPSTR lpszCmdLine, int nCmdShow)
{
WNDCLASSEX wndClassEx;
MSG message;
TCHAR szApplicationTitle[] = TEXT("CG - PP - Triangle Perspective");
TCHAR szApplicationClassName[] = TEXT("RTR_OPENGL_PP_TRIANGLE_PERSPECTIVE");
bool done = false;
if (fopen_s(&logFile, "debug.log", "w") != 0)
{
MessageBox(NULL, TEXT("Unable to open log file."), TEXT("Error"), MB_OK | MB_TOPMOST | MB_ICONSTOP);
exit(EXIT_FAILURE);
}
fprintf(logFile, "---------- CG: OpenGL Debug Logs Start ----------\n");
fflush(logFile);
wndClassEx.cbSize = sizeof(WNDCLASSEX);
wndClassEx.style = CS_HREDRAW | CS_VREDRAW | CS_OWNDC;
wndClassEx.cbClsExtra = 0;
wndClassEx.cbWndExtra = 0;
wndClassEx.lpfnWndProc = WndProc;
wndClassEx.hInstance = hInstance;
wndClassEx.hIcon = LoadIcon(hInstance, MAKEINTRESOURCE(CP_ICON));
wndClassEx.hIconSm = LoadIcon(hInstance, MAKEINTRESOURCE(CP_ICON_SMALL));
wndClassEx.hCursor = LoadCursor(NULL, IDC_ARROW);
wndClassEx.hbrBackground = (HBRUSH)GetStockObject(BLACK_BRUSH);
wndClassEx.lpszClassName = szApplicationClassName;
wndClassEx.lpszMenuName = NULL;
if(!RegisterClassEx(&wndClassEx))
{
MessageBox(NULL, TEXT("Cannot register class."), TEXT("Error"), MB_OK | MB_ICONERROR);
exit(EXIT_FAILURE);
}
DWORD styleExtra = WS_EX_APPWINDOW;
dwStyle = WS_OVERLAPPEDWINDOW | WS_CLIPCHILDREN | WS_CLIPSIBLINGS | WS_VISIBLE;
hWnd = CreateWindowEx(styleExtra,
szApplicationClassName,
szApplicationTitle,
dwStyle,
windowRect.left,
windowRect.top,
windowRect.right - windowRect.left,
windowRect.bottom - windowRect.top,
NULL,
NULL,
hInstance,
NULL);
if(!hWnd)
{
MessageBox(NULL, TEXT("Cannot create windows."), TEXT("Error"), MB_OK | MB_ICONERROR);
exit(EXIT_FAILURE);
}
initialize();
ShowWindow(hWnd, nCmdShow);
UpdateWindow(hWnd);
SetForegroundWindow(hWnd);
SetFocus(hWnd);
while(!done)
{
if(PeekMessage(&message, NULL, 0, 0, PM_REMOVE))
{
if(message.message == WM_QUIT)
{
done = true;
}
else
{
TranslateMessage(&message);
DispatchMessage(&message);
}
}
else
{
if(isActive)
{
if(isEscapeKeyPressed)
{
done = true;
}
else
{
display();
}
}
}
}
cleanUp();
fprintf(logFile, "---------- CG: OpenGL Debug Logs End ----------\n");
fflush(logFile);
fclose(logFile);
return (int)message.wParam;
}
LRESULT CALLBACK WndProc(HWND hWnd, UINT iMessage, WPARAM wParam, LPARAM lParam)
{
HDC hdc;
RECT rect;
switch(iMessage)
{
case WM_ACTIVATE:
isActive = (HIWORD(wParam) == 0);
break;
case WM_SIZE:
resize(LOWORD(lParam), HIWORD(lParam));
break;
case WM_KEYDOWN:
switch(wParam)
{
case VK_ESCAPE:
isEscapeKeyPressed = true;
break;
// 0x46 is hex value for key 'F' or 'f'
case 0x46:
isFullscreen = !isFullscreen;
toggleFullscreen(hWnd, isFullscreen);
break;
default:
break;
}
break;
case WM_CHAR:
switch(wParam)
{
default:
break;
}
break;
case WM_LBUTTONDOWN:
break;
case WM_DESTROY:
PostQuitMessage(0);
break;
default:
break;
}
return DefWindowProc(hWnd, iMessage, wParam, lParam);
}
void initialize(void)
{
PIXELFORMATDESCRIPTOR pfd;
int pixelFormatIndex = 0;
ZeroMemory(&pfd, sizeof(PIXELFORMATDESCRIPTOR));
pfd.nSize = sizeof(PIXELFORMATDESCRIPTOR);
pfd.nVersion = 1;
pfd.dwFlags = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER;
pfd.iPixelType = PFD_TYPE_RGBA;
pfd.cColorBits = 32;
pfd.cRedBits = 8;
pfd.cGreenBits = 8;
pfd.cBlueBits = 8;
pfd.cAlphaBits = 8;
pfd.cDepthBits = 32;
hdc = GetDC(hWnd);
pixelFormatIndex = ChoosePixelFormat(hdc, &pfd);
if(pixelFormatIndex == 0)
{
ReleaseDC(hWnd, hdc);
hdc = NULL;
}
if(!SetPixelFormat(hdc, pixelFormatIndex, &pfd))
{
ReleaseDC(hWnd, hdc);
hdc = NULL;
}
hrc = wglCreateContext(hdc);
if(hrc == NULL)
{
ReleaseDC(hWnd, hdc);
hdc = NULL;
}
if(!wglMakeCurrent(hdc, hrc))
{
wglDeleteContext(hrc);
hrc = NULL;
ReleaseDC(hWnd, hdc);
hdc = NULL;
}
GLenum glewError = glewInit();
if (glewError != GLEW_OK)
{
fprintf(logFile, "Cannot initialize GLEW, Error: %d", glewError);
fflush(logFile);
cleanUp();
exit(EXIT_FAILURE);
}
listExtensions();
// Initialize the shaders and shader program object.
initializeVertexShader();
initializeFragmentShader();
initializeShaderProgram();
initializeBuffers();
glClearColor(0.0f, 0.0f, 1.0f, 1.0f);
glClearDepth(1.0f);
glEnable(GL_DEPTH_TEST);
glEnable(GL_CULL_FACE);
glDepthFunc(GL_LEQUAL);
glShadeModel(GL_SMOOTH);
glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
perspectiveProjectionMatrix = vmath::mat4::identity();
// This is required for DirectX
resize(windowRect.right - windowRect.left, windowRect.bottom - windowRect.top);
}
void listExtensions()
{
GLint extensionCount = 0;
glGetIntegerv(GL_NUM_EXTENSIONS, &extensionCount);
fprintf(logFile, "Number of extensions: %d\n", extensionCount);
fflush(logFile);
for(int counter = 0; counter < extensionCount; ++counter)
{
fprintf(logFile, "%d] Extension name: %s\n", counter + 1, (const char*)glGetStringi(GL_EXTENSIONS, counter));
fflush(logFile);
}
}
void initializeVertexShader()
{
vertexShaderObject = glCreateShader(GL_VERTEX_SHADER);
const GLchar *vertexShaderCode = "#version 450 core" \
"\n" \
"in vec4 vertexPosition;" \
"uniform mat4 mvpMatrix;" \
"\n" \
"void main(void)" \
"{" \
" gl_Position = mvpMatrix * vertexPosition;" \
"}";
glShaderSource(vertexShaderObject, 1, (const char**)&vertexShaderCode, NULL);
glCompileShader(vertexShaderObject);
GLint infoLogLength = 0;
GLint shaderCompileStatus = 0;
char *infoLog = NULL;
glGetShaderiv(vertexShaderObject, GL_COMPILE_STATUS, &shaderCompileStatus);
if(shaderCompileStatus == GL_FALSE)
{
glGetShaderiv(vertexShaderObject, GL_INFO_LOG_LENGTH, &infoLogLength);
if(infoLogLength > 0)
{
infoLog = (char *)malloc(infoLogLength);
if(infoLog != NULL)
{
GLsizei written = 0;
glGetShaderInfoLog(vertexShaderObject, infoLogLength, &written, infoLog);
fprintf(logFile, "CG: Vertex shader compilation log: %s\n", infoLog);
free(infoLog);
cleanUp();
exit(EXIT_FAILURE);
}
}
}
}
void initializeFragmentShader()
{
fragmentShaderObject = glCreateShader(GL_FRAGMENT_SHADER);
const GLchar *fragmentShaderCode = "#version 450 core" \
"\n" \
"out vec4 fragmentColor;" \
"\n" \
"void main(void)" \
"{" \
" fragmentColor = vec4(1.0, 1.0, 1.0, 1.0);" \
"}";
glShaderSource(fragmentShaderObject, 1, (const char**)&fragmentShaderCode, NULL);
glCompileShader(fragmentShaderObject);
GLint infoLogLength = 0;
GLint shaderCompileStatus = 0;
char *infoLog = NULL;
glGetShaderiv(fragmentShaderObject, GL_COMPILE_STATUS, &shaderCompileStatus);
if(shaderCompileStatus == GL_FALSE)
{
glGetShaderiv(fragmentShaderObject, GL_INFO_LOG_LENGTH, &infoLogLength);
if(infoLogLength > 0)
{
infoLog = (char *)malloc(infoLogLength);
if(infoLog != NULL)
{
GLsizei written = 0;
glGetShaderInfoLog(fragmentShaderObject, infoLogLength, &written, infoLog);
fprintf(logFile, "CG: Fragment shader compilation log: %s\n", infoLog);
free(infoLog);
cleanUp();
exit(EXIT_FAILURE);
}
}
}
}
void initializeShaderProgram()
{
shaderProgramObject = glCreateProgram();
glAttachShader(shaderProgramObject, vertexShaderObject);
glAttachShader(shaderProgramObject, fragmentShaderObject);
// Bind the position attribute location before linking.
glBindAttribLocation(shaderProgramObject, CG_ATTRIBUTE_VERTEX_POSITION, "vertexPosition");
// Now link and check for error.
glLinkProgram(shaderProgramObject);
GLint infoLogLength = 0;
GLint shaderProgramLinkStatus = 0;
char *infoLog = NULL;
glGetProgramiv(shaderProgramObject, GL_LINK_STATUS, &shaderProgramLinkStatus);
if(shaderProgramLinkStatus == GL_FALSE)
{
glGetProgramiv(shaderProgramObject, GL_INFO_LOG_LENGTH, &infoLogLength);
if(infoLogLength > 0)
{
infoLog = (char *)malloc(infoLogLength);
if(infoLog != NULL)
{
GLsizei written = 0;
glGetProgramInfoLog(shaderProgramObject, infoLogLength, &written, infoLog);
fprintf(logFile, "CG: Shader program link log: %s\n", infoLog);
free(infoLog);
cleanUp();
exit(EXIT_FAILURE);
}
}
}
// After linking get the value of MVP uniform location from the shader program.
mvpUniform = glGetUniformLocation(shaderProgramObject, "mvpMatrix");
}
void initializeBuffers()
{
const GLfloat triangleVertices[] = {
0.0f, 1.0f, 0.0f,
-1.0f, -1.0f, 0.0f,
1.0f, -1.0f, 0.0f
};
glGenVertexArrays(1, &vao);
glBindVertexArray(vao);
glGenBuffers(1, &vbo);
glBindBuffer(GL_ARRAY_BUFFER, vbo);
glBufferData(GL_ARRAY_BUFFER, sizeof(triangleVertices), triangleVertices, GL_STATIC_DRAW);
glVertexAttribPointer(CG_ATTRIBUTE_VERTEX_POSITION, 3, GL_FLOAT, GL_FALSE, 0, NULL);
glEnableVertexAttribArray(CG_ATTRIBUTE_VERTEX_POSITION);
glBindBuffer(GL_ARRAY_BUFFER, 0);
glBindVertexArray(0);
}
void display(void)
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
glUseProgram(shaderProgramObject);
vmath::mat4 modelViewMatrix = vmath::mat4::identity();
vmath::mat4 modelViewProjectionMatrix = vmath::mat4::identity();
// Translate the modal view matrix.
modelViewMatrix = vmath::translate(0.0f, 0.0f, -6.0f);
// Multiply modelViewMatrix and perspectiveProjectionMatrix to get modelViewProjectionMatrix
// Oder of multiplication is very important projectionMatrix * modelMatrix * viewMatrix
// As we have model and view matrix combined, we just have to multiply projectionMatrix and modelViewMatrix
modelViewProjectionMatrix = perspectiveProjectionMatrix * modelViewMatrix;
// Pass modelViewProjectionMatrix to vertex shader in 'mvpMatrix' variable defined in shader.
glUniformMatrix4fv(mvpUniform, 1, GL_FALSE, modelViewProjectionMatrix);
// Now bind the VAO to which we want to use
glBindVertexArray(vao);
// Draw the triangle
// 3 is number of vertices in the array i.e. element count in triangleVertices divide by 3 (x, y, z) component
glDrawArrays(GL_TRIANGLES, 0, 3);
// unbind the vao
glBindVertexArray(0);
glUseProgram(0);
SwapBuffers(hdc);
}
void resize(int width, int height)
{
if(height == 0)
{
height = 1;
}
glViewport(0, 0, (GLsizei)width, (GLsizei)height);
perspectiveProjectionMatrix = vmath::perspective(45.0f, (GLfloat)width / (GLfloat)height, 1.0f, 100.0f);
}
void toggleFullscreen(HWND hWnd, bool isFullscreen)
{
MONITORINFO monitorInfo;
dwStyle = GetWindowLong(hWnd, GWL_STYLE);
if(isFullscreen)
{
if(dwStyle & WS_OVERLAPPEDWINDOW)
{
monitorInfo = { sizeof(MONITORINFO) };
if(GetWindowPlacement(hWnd, &wpPrev) && GetMonitorInfo(MonitorFromWindow(hWnd, MONITORINFOF_PRIMARY), &monitorInfo))
{
SetWindowLong(hWnd, GWL_STYLE, dwStyle & ~WS_OVERLAPPEDWINDOW);
SetWindowPos(hWnd, HWND_TOP, monitorInfo.rcMonitor.left, monitorInfo.rcMonitor.top, monitorInfo.rcMonitor.right - monitorInfo.rcMonitor.left, monitorInfo.rcMonitor.bottom - monitorInfo.rcMonitor.top, SWP_NOZORDER | SWP_FRAMECHANGED);
}
}
ShowCursor(FALSE);
}
else
{
SetWindowLong(hWnd, GWL_STYLE, dwStyle | WS_OVERLAPPEDWINDOW);
SetWindowPlacement(hWnd, &wpPrev);
SetWindowPos(hWnd, HWND_TOP, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOOWNERZORDER | SWP_NOZORDER | SWP_FRAMECHANGED);
ShowCursor(TRUE);
}
}
void cleanUp(void)
{
if(isFullscreen)
{
dwStyle = GetWindowLong(hWnd, GWL_STYLE);
SetWindowLong(hWnd, GWL_STYLE, dwStyle | WS_OVERLAPPEDWINDOW);
SetWindowPlacement(hWnd, &wpPrev);
SetWindowPos(hWnd, HWND_TOP, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOOWNERZORDER | SWP_NOZORDER | SWP_FRAMECHANGED);
ShowCursor(TRUE);
}
if(vao)
{
glDeleteVertexArrays(1, &vao);
vao = 0;
}
if(vbo)
{
glDeleteBuffers(1, &vbo);
vbo = 0;
}
if(shaderProgramObject)
{
if(vertexShaderObject)
{
glDetachShader(shaderProgramObject, vertexShaderObject);
}
if(fragmentShaderObject)
{
glDetachShader(shaderProgramObject, fragmentShaderObject);
}
}
if(vertexShaderObject)
{
glDeleteShader(vertexShaderObject);
vertexShaderObject = 0;
}
if(fragmentShaderObject)
{
glDeleteShader(fragmentShaderObject);
fragmentShaderObject = 0;
}
if(shaderProgramObject)
{
glDeleteProgram(shaderProgramObject);
shaderProgramObject = 0;
}
glUseProgram(0);
wglMakeCurrent(NULL, NULL);
wglDeleteContext(hrc);
hrc = NULL;
ReleaseDC(hWnd, hdc);
hdc = NULL;
DestroyWindow(hWnd);
hWnd = NULL;
}
| [
"projectchetan07@gmail.com"
] | projectchetan07@gmail.com |
31445175d9276ad79aa652d8b9470ea07bea8e5a | d1166bb82217de1cd9a6d3d26db0a5c9943ba443 | /src/main.cpp | ada71638bc0ff8c86767ec4db85b0e6cc6460b93 | [] | no_license | Kuba-Wi/Szablon-uklad-rownan | 9da48770ea2fb91ecc4be6fbbc2bf4192a9e9db7 | 89b7dd011203bcac9ae25a3859068c1dfb633983 | refs/heads/master | 2022-06-08T03:29:16.535588 | 2020-05-07T17:49:35 | 2020-05-07T17:49:35 | 257,581,216 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,018 | cpp | #include <iostream>
#include "SWektor.hh"
#include "SMacierz.hh"
#include "SUkladRownanLiniowych.hh"
#include "LZespolona.hh"
#include "rozmiar.h"
using namespace std;
template<typename Typ, int Rozmiar>
void uklad_rownan() {
SMacierz<Typ, Rozmiar> A;
SWektor<Typ, Rozmiar> b;
SWektor<Typ, Rozmiar> Wynik;
SWektor<Typ, Rozmiar> blad;
SUkladRownanLiniowych<Typ, Rozmiar> UklRown;
cin >> UklRown;
cout << UklRown;
A = UklRown.getMac();
b = UklRown.getWek();
Wynik = UklRown.policz_wynik();
cout << "Rozwiązanie x = (x1, x2, x3, x4, x5):\n\n\t";
cout << Wynik << endl;
blad = A * Wynik - b;
cout << "Wektor błędu Ax-b: ";
cout << blad << endl;
cout << "Dlugosc wektora błędu |Ax-b|: ";
cout << blad.dlugosc() << endl;
}
int main() {
char rodzaj_ukl;
cin >> rodzaj_ukl;
if(rodzaj_ukl == 'r')
uklad_rownan<double, ROZMIAR>();
else if(rodzaj_ukl == 'z')
uklad_rownan<LZespolona, ROZMIAR>();
else
cout << "Zły identyfikator układu.\n";
}
| [
"winczukjakub@gmail.com"
] | winczukjakub@gmail.com |
c316695368aabf5ebe7eec5b137c151a49550ee7 | 3fa1397b95e38fb04dac5e009d70c292deff09a9 | /BaiTap_KTLT_0081_08/BaiTap_KTLT_0081_08.h | 80b2683e901394a1f07d4d2ff0e94c38d03804d0 | [] | no_license | nguyennhattruong96/BiboTraining_BaiTap_KTLT_Thay_NTTMKhang | 61b396de5dc88cdad0021036c7db332eec26b5f3 | 1cac487672de9d3c881a8afdc410434a5042c128 | refs/heads/master | 2021-01-16T18:47:05.754323 | 2017-10-13T11:15:01 | 2017-10-13T11:15:01 | 100,113,344 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 229 | h | #ifndef __BaiTap_KTLT_0081_08_H__
#define __BaiTap_KTLT_0081_08_H__
#include <iostream>
#include <string>
using namespace std;
#pragma once
int Input(string sMessage);
void Sum(int x);
#endif // !__BaiTap_KTLT_0081_08_H__
| [
"nguyennhattruong96@outlook.com.vn"
] | nguyennhattruong96@outlook.com.vn |
dadf9d3cdde723a05b32aebbb5e4e148cdbebfd7 | 974389431527e451ce83049b11cd3dc42780108d | /phase_1/example/montague/variants/unpatched/src/mtl.cpp | 99edd1ad9d1482002978e8a61e24b534e807af86 | [
"LicenseRef-scancode-unknown-license-reference",
"MIT"
] | permissive | cromulencellc/chess-aces | 21d8e70c8d9853a922ca0c90ffdd2c79ba390fb0 | 8ea5b0d75ddbf45fd74a7b8c5ca03fc4955eba8b | refs/heads/main | 2023-05-24T01:13:07.917910 | 2022-11-02T00:56:52 | 2022-11-02T00:56:52 | 351,277,450 | 7 | 2 | null | null | null | null | UTF-8 | C++ | false | false | 2,068 | cpp | #include "logger.hpp"
#include "mtl.hpp"
using namespace mtl;
using hpt = std::shared_ptr<context::Hash>;
using spt = std::shared_ptr<context::Scalar>;
hpt hhh() { return std::make_shared<context::Hash>(); }
spt sss(std::string v) { return std::make_shared<context::Scalar>(v); }
std::shared_ptr<Context> mtl::make_context(Uuid tx_id, Request rq) {
hpt txn = hhh();
txn->insert_or_assign("id", sss(to_string(tx_id)));
hpt req = hhh();
for (request::Header h : rq.headers) {
req->insert_or_assign(h.first, sss(h.second));
}
req->insert_or_assign("_method", sss(to_string(rq.method)));
req->insert_or_assign("_target", sss(to_string(rq.target)));
req->insert_or_assign("_version", sss(to_string(rq.version)));
req->insert_or_assign("_client_address", sss(to_string(rq.client_address)));
hpt ctx = hhh();
ctx->insert_or_assign("transaction", txn);
ctx->insert_or_assign("request", req);
LLL.info() << txn->inspect();
return ctx;
}
std::shared_ptr<Context> mtl::fake_context() {
hpt txn = hhh();
(*txn)["id"] = sss(to_string(Uuid{}));
hpt req = hhh();
req->insert_or_assign(
"Accept",
sss("text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8"));
req->insert_or_assign("Accept-Encoding", sss("gzip, deflate"));
req->insert_or_assign("Accept-Language", sss("en-US,en;q=0.5"));
req->insert_or_assign("Cache-Control", sss("max-age=0"));
req->insert_or_assign("Connection", sss("keep-alive"));
req->insert_or_assign("Host", sss("localhost:32768"));
req->insert_or_assign("Upgrade-Insecure-Requests", sss("1"));
req->insert_or_assign("User-Agent",
sss("Mozilla/5.0 (Macintosh; Intel Mac OS X 10.14; "
"rv:69.0) Gecko/20100101 Firefox/69.0"));
req->insert_or_assign("_method", sss("GET"));
req->insert_or_assign("_target", sss("/asdf"));
req->insert_or_assign("_version", sss("HTTP/1.1"));
hpt ctx = hhh();
ctx->insert_or_assign("transaction", txn);
ctx->insert_or_assign("request", req);
LLL.info() << ctx->inspect();
return ctx;
}
| [
"bk@cromulence.com"
] | bk@cromulence.com |
966e150cb7e7551bb5c655dd5159784d1b9da6b4 | fb6d70a911d49440a056019acccd0434e7779eea | /Shake_Engine/src/Platform/OpenGL/OpenGLShader.cpp | 8c566eb1d9eb470f2086ee5703202bc5b95c9486 | [] | no_license | PizzaCutter/Shake_Engine_CPP | b29b566df369fa4eaad3cdbe08da916ff50caef1 | 9d479fd9ec600e4b271489c82ae4dd38b1666a34 | refs/heads/master | 2022-12-25T10:58:05.192374 | 2020-10-11T11:47:57 | 2020-10-11T11:47:57 | 268,881,248 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 7,809 | cpp | #include "sepch.h"
#include "OpenGLShader.h"
#include <fstream>
#include <vector>
#include "glad/glad.h"
#include "glm/gtc/type_ptr.hpp"
namespace Shake
{
OpenGLShader::OpenGLShader(const SString& filePath)
{
const SString fileAsString = ReadFile(filePath);
const std::unordered_map<GLenum, SString> processedData = PreProcess(fileAsString);
Compile(processedData);
// Contents/Shaders/Texture.glsl extract name from this
const size_t lastSlash = filePath.find_last_of("/");
const size_t lastDot = filePath.find_last_of(".");
const size_t beginIndex = lastSlash + 1;
m_name = filePath.substr(beginIndex, lastDot - beginIndex);
}
OpenGLShader::~OpenGLShader()
{
glDeleteProgram(m_ShaderId);
}
void OpenGLShader::Bind() const
{
glUseProgram(m_ShaderId);
}
void OpenGLShader::Unbind() const
{
glUseProgram(0);
}
void OpenGLShader::UploadUniformInt(const SString& name, const int value)
{
GLint uniformLocation = glGetUniformLocation(m_ShaderId, name.c_str());
glUniform1i(uniformLocation, value);
}
void OpenGLShader::UploadUniformIntArray(const SString& name, int* values, uint32_t size)
{
GLint uniformLocation = glGetUniformLocation(m_ShaderId, name.c_str());
glUniform1iv(uniformLocation, size, values);
}
void OpenGLShader::UploadUniformMat3(const SString& name, const SMat3& matrix)
{
GLint uniformLocation = glGetUniformLocation(m_ShaderId, name.c_str());
glUniformMatrix3fv(uniformLocation, 1, GL_FALSE, glm::value_ptr(matrix));
}
void OpenGLShader::UploadUniformMat4(const SString& name, const SMat4& matrix)
{
GLint uniformLocation = glGetUniformLocation(m_ShaderId, name.c_str());
glUniformMatrix4fv(uniformLocation, 1, GL_FALSE, glm::value_ptr(matrix));
}
void OpenGLShader::UploadUniformFloat(const SString& name, float value)
{
GLint uniformLocation = glGetUniformLocation(m_ShaderId, name.c_str());
glUniform1f(uniformLocation, value);
}
void OpenGLShader::UploadUniformFloat2(const SString& name, const SVector2& data)
{
GLint uniformLocation = glGetUniformLocation(m_ShaderId, name.c_str());
glUniform2f(uniformLocation, data.x, data.y);
}
void OpenGLShader::UploadUniformFloat3(const SString& name, const SVector3& data)
{
GLint uniformLocation = glGetUniformLocation(m_ShaderId, name.c_str());
glUniform3f(uniformLocation, data.x, data.y, data.z);
}
void OpenGLShader::UploadUniformFloat4(const SString& name, const SVector4& vector)
{
GLint uniformLocation = glGetUniformLocation(m_ShaderId, name.c_str());
glUniform4f(uniformLocation, vector.x, vector.y, vector.z, vector.w);
}
SString OpenGLShader::ReadFile(const SString& filePath)
{
SString result;
std::ifstream in(filePath, std::ios::in | std::ios::binary);
if(in)
{
in.seekg(0, std::ios::end);
result.resize(in.tellg());
in.seekg(0, std::ios::beg);
in.read(&result[0], result.size());
in.close();
}else
{
SE_ENGINE_LOG(LogVerbosity::Error, "Could not open file '{0}'", filePath);
}
return result;
}
GLenum OpenGLShader::GetShaderTypeFromString(const SString& shaderTypeAsString)
{
if(shaderTypeAsString == "vertex")
{
return GL_VERTEX_SHADER;
}
if(shaderTypeAsString == "fragment" || shaderTypeAsString == "pixel")
{
return GL_FRAGMENT_SHADER;
}
return GL_VERTEX_SHADER;
}
std::unordered_map<GLenum, SString> OpenGLShader::PreProcess(const SString& source)
{
std::unordered_map<GLenum, SString> thing = {};
const SString typeThing = "#type";
size_t index = 0;
while(index != SString::npos)
{
const SString::size_type foundIndex = source.find(typeThing, index) + typeThing.length();
const SString::size_type endOfTypeIndex = source.find("\r", index);
const SString::size_type nextShaderIndex = source.find(typeThing, endOfTypeIndex);
SString shaderTypeString = source.substr(foundIndex + 1, endOfTypeIndex - (foundIndex + 1));
const SString shaderSource = source.substr(endOfTypeIndex, nextShaderIndex - endOfTypeIndex);
const GLenum shaderType = GetShaderTypeFromString(shaderTypeString);
//TODO[rsmekens]: check shader types
thing.emplace(shaderType, shaderSource);
index = nextShaderIndex;
}
return thing;
}
void OpenGLShader::Compile(std::unordered_map<GLenum, SString> input)
{
GLuint program = glCreateProgram();
std::vector<GLuint> openGLShaders;
openGLShaders.reserve(input.size());
for (auto& shaderInput: input)
{
// Create an empty vertex shader handle
const GLuint openGLShader = glCreateShader(shaderInput.first);
openGLShaders.push_back(openGLShader);
// Send the vertex shader source code to GL
// Note that SString's .c_str is NULL character terminated.
const GLchar* source = shaderInput.second.c_str();
glShaderSource(openGLShader, 1, &source, 0);
// Compile the vertex shader
glCompileShader(openGLShader);
GLint isCompiled = 0;
glGetShaderiv(openGLShader, GL_COMPILE_STATUS, &isCompiled);
if(isCompiled == GL_FALSE)
{
GLint maxLength = 0;
glGetShaderiv(openGLShader, GL_INFO_LOG_LENGTH, &maxLength);
// The maxLength includes the NULL character
std::vector<GLchar> infoLog(maxLength);
glGetShaderInfoLog(openGLShader, maxLength, &maxLength, &infoLog[0]);
// We don't need the shader anymore.
glDeleteShader(openGLShader);
SE_ENGINE_LOG(LogVerbosity::Error,"{0}", infoLog.data());
SE_CORE_ASSERT(false, "Vertex shader compilation failure!");
return;
}
}
// Only initialize this once compilation has succeeded
m_ShaderId = program;
// Attach our shaders to our program
for (auto& element : openGLShaders)
{
glAttachShader(program, element);
}
// Link our program
glLinkProgram(program);
// Note the different functions here: glGetProgram* instead of glGetOpenGLShader*.
GLint isLinked = 0;
glGetProgramiv(program, GL_LINK_STATUS, (int*)&isLinked);
if (isLinked == GL_FALSE)
{
GLint maxLength = 0;
glGetProgramiv(program, GL_INFO_LOG_LENGTH, &maxLength);
// The maxLength includes the NULL character
std::vector<GLchar> infoLog(maxLength);
glGetProgramInfoLog(program, maxLength, &maxLength, &infoLog[0]);
// We don't need the program anymore.
glDeleteProgram(program);
// Don't leak shaders either.
for (auto& element : openGLShaders)
{
glDeleteShader(element);
}
SE_ENGINE_LOG(LogVerbosity::Error,"{0}", infoLog.data());
SE_CORE_ASSERT(false, "OpenGLShader link failure!");
return;
}
// Always detach shaders after a successful link.
for (auto& element : openGLShaders)
{
glDetachShader(program, element);
}
}
}
| [
"robin.smekens.930@gmail.com"
] | robin.smekens.930@gmail.com |
ef5aa19bb57b0e99c1ca8291579368778456229f | 7a0cf4e53c690f092c94f4c711919d70f0c03630 | /src/armed/DocumentContainer.cpp | bf4e71fbad89ccccda5d93b29764d3f09231132e | [
"MIT"
] | permissive | retrodump/wme | d4d6718eabd285bc59473c0911055d83e8a9052d | 54cf8905091736aef0a35fe6d3e05b818441f3c8 | refs/heads/master | 2021-09-21T02:19:06.317073 | 2012-07-08T16:09:56 | 2012-07-08T16:09:56 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 5,605 | cpp | // This file is part of Wintermute Engine
// For conditions of distribution and use, see copyright notice in license.txt
#include "StdAfx.h"
#include "DocumentContainer.h"
#include "MainWindow.h"
#include "Navigator.h"
#include "PropWindow.h"
#include "WmeWidget.h"
#include "DocumentView.h"
#include "ActionManager.h"
#include "DocumentView.h"
#include "CanCloseDialog.h"
// temp
#include "DocScript.h"
#include "DocScene.h"
namespace Armed
{
//////////////////////////////////////////////////////////////////////////
DocumentContainer::DocumentContainer(MainWindow* parent) : QWidget(parent)
{
QVBoxLayout* vboxLayout = new QVBoxLayout(this);
vboxLayout->setMargin(0);
m_TabWidget = new QTabWidget(this);
#ifdef Q_OS_MAC
m_TabWidget->setDocumentMode(true);
#endif
m_TabWidget->setMovable(true);
vboxLayout->addWidget(m_TabWidget);
connect(m_TabWidget, SIGNAL(currentChanged(int)), this, SLOT(OnDocumentChanged(int)));
// close button
QToolButton* m_TabCloseButton = new QToolButton(this);
m_TabCloseButton->setEnabled(true);
m_TabCloseButton->setAutoRaise(true);
m_TabCloseButton->setToolTip(tr("Close"));
m_TabCloseButton->setIcon(QIcon(":/icons/close.png"));
m_TabWidget->setCornerWidget(m_TabCloseButton, Qt::TopRightCorner);
connect(m_TabCloseButton, SIGNAL(clicked()), this, SLOT(OnCloseTab()));
connect(m_TabWidget, SIGNAL(tabCloseRequested(int)), this, SLOT(OnCloseTab(int)));
new QShortcut(QKeySequence::Close, this, SLOT(OnCloseTab()));
// context menu
QTabBar* tabBar = m_TabWidget->findChild<QTabBar*>();
if (tabBar)
{
tabBar->setContextMenuPolicy(Qt::CustomContextMenu);
connect(tabBar, SIGNAL(customContextMenuRequested(QPoint)), this, SLOT(OnTabMenu(QPoint)));
}
}
//////////////////////////////////////////////////////////////////////////
DocumentContainer::~DocumentContainer()
{
}
//////////////////////////////////////////////////////////////////////////
void DocumentContainer::AddDocumentView(DocumentView* doc, bool activate)
{
int index = m_TabWidget->addTab(doc, doc->GetTitle());
m_TabWidget->setCurrentIndex(index);
connect(doc, SIGNAL(TitleChanged(QString, QString)), this, SLOT(OnTitleChanged(QString, QString)));
doc->OnDocumentAdded();
}
//////////////////////////////////////////////////////////////////////////
void DocumentContainer::OnDocumentChanged(int index)
{
MainWindow::GetInstance()->GetNavigator()->SetNavigator(NULL);
MainWindow::GetInstance()->GetPropWindow()->ClearProperties();
DocumentView* doc = qobject_cast<DocumentView*>(m_TabWidget->widget(index));
ActionManager::GetInstance()->SetContextObject(ActionContext::CONTEXT_DOC, doc);
if (doc) doc->OnActivate();
}
//////////////////////////////////////////////////////////////////////////
void DocumentContainer::OnTitleChanged(const QString& title, const QString& desc)
{
int index = m_TabWidget->indexOf(qobject_cast<QWidget*>(sender()));
if (index >= 0)
{
m_TabWidget->setTabText(index, title);
m_TabWidget->setTabToolTip(index, desc);
}
}
//////////////////////////////////////////////////////////////////////////
void DocumentContainer::OnCloseTab()
{
OnCloseTab(m_TabWidget->currentIndex());
}
//////////////////////////////////////////////////////////////////////////
void DocumentContainer::OnCloseTab(int index)
{
DocumentView* doc = qobject_cast<DocumentView*>(m_TabWidget->widget(index));
if (!doc) return;
if (CanClose(doc))
{
m_TabWidget->removeTab(m_TabWidget->indexOf(doc));
QTimer::singleShot(0, doc, SLOT(deleteLater()));
}
}
//////////////////////////////////////////////////////////////////////////
bool DocumentContainer::CanClose(DocumentView* singleDoc)
{
QList<DocumentView*> dirtyDocs;
if (singleDoc)
{
if (singleDoc->IsDirty()) dirtyDocs.append(singleDoc);
}
else
{
for (int i = 0; i < m_TabWidget->count(); i++)
{
DocumentView* doc = qobject_cast<DocumentView*>(m_TabWidget->widget(i));
if (doc && doc->IsDirty()) dirtyDocs.append(doc);
}
}
if (dirtyDocs.empty()) return true;
CanCloseDialog dlg(this);
qforeach (DocumentView* doc, dirtyDocs)
{
dlg.AddFile(doc->GetTitle(false));
}
if (!dlg.exec()) return false;
if (dlg.GetSave())
{
qforeach (DocumentView* doc, dirtyDocs)
{
if (!doc->Save()) return false;
}
}
return true;
}
//////////////////////////////////////////////////////////////////////////
void DocumentContainer::OnTabMenu(QPoint point)
{
QTabBar* tabBar = m_TabWidget->findChild<QTabBar*>();
if (!tabBar) return;
// find the tab / document we clicked
DocumentView* doc = NULL;
for (int i = 0; i < tabBar->count(); ++i)
{
if (tabBar->tabRect(i).contains(point))
{
doc = qobject_cast<DocumentView*>(m_TabWidget->widget(i));
break;
}
}
if (!doc) return;
QMenu menu(QLatin1String(""), tabBar);
QAction* closeTab = menu.addAction(tr("Close"));
QAction* pickedAction = menu.exec(tabBar->mapToGlobal(point));
if (pickedAction == closeTab)
{
OnCloseTab(m_TabWidget->indexOf(doc));
}
}
//////////////////////////////////////////////////////////////////////////
void DocumentContainer::TestData()
{
// temp
DocScene* scene = new DocScene(this);
scene->BuildActions();
//scene->Load("F:\\aaa.scene");
AddDocumentView(scene);
DocScript* doc = new DocScript(this);
doc->BuildActions();
doc->Load("../data/test.script");
AddDocumentView(doc);
m_TabWidget->setCurrentIndex(0);
}
} // namespace Armed
| [
"Jan Nedoma@JNML.cust.nbox.cz"
] | Jan Nedoma@JNML.cust.nbox.cz |
1371fd5fade49f3fec4110fc543dc977595fca2e | 55ea2dcfa28691a058bf6e9b40dabc4cc7b895a8 | /library/tree/treeCentroidDecompositionSolverDivideAndConquer_XorDistance.h | 494ab63784741923bacccf8b4f6bc40aaf660257 | [
"Unlicense"
] | permissive | yoonki-song/algorithm_study | 02dba9904dec9b15b0cf78440d0b3add93da2380 | ff98b083f8b4468afabc7dfe0a415c6e7c556f93 | refs/heads/master | 2023-02-06T11:55:16.945032 | 2020-12-15T13:33:12 | 2020-12-15T13:33:12 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 5,516 | h | #pragma once
// https://www.codechef.com/problems/MOVCOIN2
struct TreeCentroidDecompositionSolverDivideAndConquer_XorDistance {
struct BitSetSimple64 {
static int ctz(unsigned long long x) {
#if defined(_M_X64)
return int(_tzcnt_u64(x));
#elif defined(__GNUC__)
return __builtin_ctzll(x);
#else
if ((x >> 32) != 0)
return int(_tzcnt_u32(unsigned(x >> 32)));
else
return 32 + int(_tzcnt_u32(unsigned(x)));
#endif
}
int N;
vector<unsigned long long> values;
BitSetSimple64() {
}
explicit BitSetSimple64(int n) {
init(n);
}
void init(int n) {
N = n;
values = vector<unsigned long long>((N + 63) >> 6);
}
BitSetSimple64& flip(int pos) {
int idx = pos >> 6;
int off = pos & 0x3f;
values[idx] ^= 1ull << off;
return *this;
}
};
int N;
vector<vector<int>> edges;
vector<bool> values; //
// find a center node in a tree
vector<int> treeLevel;
vector<int> treeSize;
vector<bool> ctMarked;
int currTime;
vector<pair<int, int>> visitTime;
vector<int> timeToNode;
vector<int> answer;
void init(int N) {
this->N = N;
edges = vector<vector<int>>(N);
values = vector<bool>(N);
treeLevel = vector<int>(N);
treeSize = vector<int>(N);
ctMarked = vector<bool>(N);
//---
currTime = 0;
visitTime = vector<pair<int, int>>(N);
timeToNode = vector<int>(N);
answer = vector<int>(N);
}
void addEdge(int u, int v) {
edges[u].push_back(v);
edges[v].push_back(u);
}
void setValue(int u, bool enable) {
values[u] = enable;
}
//---
// O(N*(logN)^2)
void solve() {
dfsSize(0, -1);
dfsSolve(0, -1);
}
private:
static int clz(int x) {
if (!x)
return 32;
#ifndef __GNUC__
return int(_lzcnt_u32((unsigned)x));
#else
return __builtin_clz((unsigned)x);
#endif
}
int dfsDist(int u, int parent, int depth, BitSetSimple64& all) {
if (values[u])
all.flip(depth);
treeSize[u] = 1;
treeLevel[u] = depth;
timeToNode[currTime] = u;
visitTime[u].first = currTime++;
int res = depth;
for (int v : edges[u]) {
if (v != parent && !ctMarked[v]) {
res = max(res, dfsDist(v, u, depth + 1, all));
treeSize[u] += treeSize[v];
}
}
visitTime[u].second = currTime;
return res;
}
void apply(int u, int parent, int size, int baseDepth = 0) {
BitSetSimple64 all(size + baseDepth);
currTime = 0;
int maxDepth = dfsDist(u, parent, baseDepth, all);
int logH = 32 - clz(maxDepth * 2); // max distance = maxDepth * 2
int cnt = 0;
int xxor = 0;
vector<vector<int>> dist(logH);
for (int i = 0; i < logH; i++)
dist[i].resize(1 << i);
for (int j = 0, k = 0; j <= maxDepth; j += 64, k++) {
auto bits = all.values[k];
while (bits) {
int idx = j + BitSetSimple64::ctz(bits);
cnt++;
for (int k = 0, msb = 1; k < logH; k++, msb <<= 1) {
dist[k][idx & (msb - 1)] ^= msb;
xxor ^= idx & msb;
}
bits &= bits - 1;
}
}
answer[u] ^= xxor;
if (cnt > 0) {
vector<int> X;
X.push_back(xxor);
for (int v : edges[u]) {
if (ctMarked[v])
continue;
for (int t = visitTime[v].first; t < visitTime[v].second; t++) {
int vt = timeToNode[t];
int d = treeLevel[vt] - baseDepth;
if (d >= X.size()) {
for (int i = 0, size = 1; i < logH; i++, size <<= 1)
xxor ^= dist[i][(size - d) & (size - 1)];
X.push_back(xxor);
}
answer[vt] ^= X[d];
}
}
}
}
void dfsSolve(int u, int parent) {
int size = treeSize[u];
int root = findCentroid(u, parent, size);
if (parent >= 0)
apply(u, parent, size, 2); // subtract
u = root;
apply(u, -1, size, 0); // add
ctMarked[u] = true;
for (int v : edges[u]) {
if (!ctMarked[v])
dfsSolve(v, u);
}
}
//--- centroid
void dfsSize(int u, int parent) {
treeSize[u] = 1;
for (int v : edges[u]) {
if (v != parent && !ctMarked[v]) {
dfsSize(v, u);
treeSize[u] += treeSize[v];
}
}
}
int findCentroid(int u, int parent, int size) {
bool isMajor = true;
for (int v : edges[u]) {
if (v == parent || ctMarked[v])
continue;
int res = findCentroid(v, u, size);
if (res != -1)
return res;
if (treeSize[v] + treeSize[v] > size)
isMajor = false;
}
if (isMajor && 2 * (size - treeSize[u]) <= size)
return u;
return -1;
}
};
| [
"youngman.ro@gmail.com"
] | youngman.ro@gmail.com |
954499c20a5c34e0e24febfebb2dbe1109dc9452 | 0bc4186fee113a3c9e740f47a82ddb79b8dbe7ad | /Weekly Assignments/Week3/Angry Birds Progress/src/SlingShot.h | fd68aa7b648be6046283300b32f15df8bfdd1c6c | [] | no_license | uhhgoat/AngryBirdsPrototype | 8080db3f2115eff777c9a93b81c13c47dc9934ba | 4c7ba585386da70a0fe3f6f2ceb9589828f5e184 | refs/heads/master | 2020-12-28T14:41:41.463088 | 2020-02-05T05:33:51 | 2020-02-05T05:33:51 | 238,374,827 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 320 | h | #pragma once
#include "Includes.h"
class SlingShot : public MultiFixtureObject
{
private:
GameObject2D * slingRight;
GameObject2D* slingLeft;
public:
SlingShot(float x, float y, float rot, b2World &world, bool showDebugShape = false);
~SlingShot() = default;
void Update();
void UpdateRubber(GameObject2D* go);
}; | [
"matyas@fenyves.net"
] | matyas@fenyves.net |
5318b72a7012b3aa62d5bf03ab56cefc6fa61b10 | 475e044ac657779d4a76f83ec7f7b6a73c589f2b | /level.h | 5e100c093d3a25877362b75e19e1de5473c06aab | [] | no_license | 1nikhil9/mage | 6d87a93a7f616037b67073abcdad650f3b5711b2 | a429a3cd93dd82c05281d142e2c29741305519d1 | refs/heads/master | 2021-01-19T00:52:40.005918 | 2020-09-21T04:44:01 | 2020-09-21T04:44:01 | 73,276,286 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 538 | h | #ifndef LEVEL_H
#define LEVEL_H
#include <vector>
#include <glad/glad.h>
#include <glm/glm.hpp>
#include "entity.h"
#include "sprite_renderer.h"
#include "resource_manager.h"
class Level
{
public:
std::vector<Entity> Destructible, Enchanted;
GLuint Cleared, Remaining, Tries;
Level() { }
void Load(const GLchar *file, GLuint levelWidth, GLuint levelHeight);
void Draw(SpriteRenderer &renderer);
private:
void init(std::vector<std::vector<GLuint>> tileData, GLuint levelWidth, GLuint levelHeight);
};
#endif
| [
"1nikhil9@gmail.com"
] | 1nikhil9@gmail.com |
f472ce617416b8873ec71429471dfc93d4070f24 | 94d91fcfdc8e8726dd1014d55b72a14b7b641413 | /Sensitivity Study/AA10 LP-102 PIE1/headers/Model.h | 6168815982c1f8dd009a6c6dfecc510ca5bd76ed | [] | no_license | nicriz/dose-model-root | aeb510800d27e4bafc6215dfcfa6dd197f561daa | 3e6f986a1b23ac21106bf801840776dfa263a3c3 | refs/heads/master | 2022-03-22T17:06:32.665394 | 2019-12-02T10:07:10 | 2019-12-02T10:07:10 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 269 | h | #ifndef MODEL_H
#define MODEL_H
#include "Dispersion.h"
#include <vector>
class Model{
public:
Model( vector<double> , bool = false);
double getFinal_dose();
private:
vector<double> par;
double final_dose;
};
#endif
| [
"nrizzi95@gmail.com"
] | nrizzi95@gmail.com |
4fd9bc30e2d78da208beae2b50985800a5a6f86f | 6ac8f056ab6efaf854b8d7798e6a44e07b061dcc | /CvGameCoreDLL/CvTacticalAnalysisMap.cpp | 6f73898c1f9e8b1b11728695393eb4e951076d5d | [] | no_license | DelnarErsike/Civ5-Artificial-Unintelligence-DLL | b8587deb33735c38104aa0d7b9f38b2f57a3db32 | 1add515c01838e743e94c1c1c0cb1cfbe569e097 | refs/heads/master | 2020-06-04T23:05:06.522287 | 2015-01-09T06:53:57 | 2015-01-09T06:53:57 | 25,795,041 | 25 | 10 | null | null | null | null | WINDOWS-1252 | C++ | false | false | 35,208 | cpp | /* -------------------------------------------------------------------------------------------------------
© 1991-2012 Take-Two Interactive Software and its subsidiaries. Developed by Firaxis Games.
Sid Meier's Civilization V, Civ, Civilization, 2K Games, Firaxis Games, Take-Two Interactive Software
and their respective logos are all trademarks of Take-Two interactive Software, Inc.
All other marks and trademarks are the property of their respective owners.
All rights reserved.
------------------------------------------------------------------------------------------------------- */
#include "CvGameCoreDLLPCH.h"
#include "CvGameCoreUtils.h"
#include "CvTacticalAnalysisMap.h"
#include "CvMilitaryAI.h"
#include "cvStopWatch.h"
#include "CvDiplomacyAI.h"
#include "LintFree.h"
//=====================================
// CvTacticalAnalysisCell
//=====================================
/// Constructor
CvTacticalAnalysisCell::CvTacticalAnalysisCell(void):
m_pEnemyMilitary(NULL),
m_pEnemyCivilian(NULL),
m_pNeutralMilitary(NULL),
m_pNeutralCivilian(NULL),
m_pFriendlyMilitary(NULL),
m_pFriendlyCivilian(NULL),
m_iDefenseModifier(0),
m_iDeploymentScore(0),
m_eTargetType(AI_TACTICAL_TARGET_NONE),
m_iDominanceZoneID(-1)
{
Clear();
}
/// Reinitialize data
void CvTacticalAnalysisCell::Clear()
{
ClearFlags();
m_pEnemyMilitary = NULL;
m_pEnemyCivilian = NULL;
m_pNeutralMilitary = NULL;
m_pNeutralCivilian = NULL;
m_pFriendlyMilitary = NULL;
m_pFriendlyCivilian = NULL;
m_iDefenseModifier = 0;
m_iDeploymentScore = 0;
m_eTargetType = AI_TACTICAL_TARGET_NONE;
m_iDominanceZoneID = -1;
}
bool CvTacticalAnalysisCell::CanUseForOperationGathering()
{
if (IsImpassableTerrain() || IsImpassableTerritory() || GetEnemyMilitaryUnit() || GetNeutralMilitaryUnit() || GetNeutralCivilianUnit() || IsFriendlyTurnEndTile() || IsEnemyCity() || IsNeutralCity())
{
return false;
}
return true;
}
bool CvTacticalAnalysisCell::CanUseForOperationGatheringCheckWater(bool bWater)
{
if (bWater != IsWater() || IsImpassableTerrain() || IsImpassableTerritory() || GetEnemyMilitaryUnit() || GetNeutralMilitaryUnit() || GetNeutralCivilianUnit() || IsFriendlyTurnEndTile() || IsEnemyCity() || IsNeutralCity())
{
return false;
}
return true;
}
//=====================================
// CvTacticalDominanceZone
//=====================================
/// Constructor
CvTacticalDominanceZone::CvTacticalDominanceZone(void)
{
m_iDominanceZoneID = -1;
m_eTerritoryType = TACTICAL_TERRITORY_NONE;
m_eDominanceFlag = TACTICAL_DOMINANCE_NO_UNITS_PRESENT;
m_eOwner = NO_PLAYER;
m_iCityID = -1;
m_iAreaID = 0;
m_iFriendlyStrength = 0;
m_iEnemyStrength = 0;
m_iFriendlyRangedStrength = 0;
m_iEnemyRangedStrength = 0;
m_iFriendlyUnitCount = 0;
m_iEnemyUnitCount = 0;
m_iFriendlyRangedUnitCount = 0;
m_iEnemyRangedUnitCount = 0;
m_iZoneValue = 0;
m_iRangeClosestEnemyUnit = MAX_INT;
m_bIsWater = false;
m_bIsNavalInvasion = false;
m_pTempZoneCenter = NULL;
}
/// Retrieve city controlling this zone
CvCity *CvTacticalDominanceZone::GetClosestCity() const
{
if (m_eOwner != NO_PLAYER)
{
return GET_PLAYER(m_eOwner).getCity(m_iCityID);
}
return NULL;
}
/// Set city controlling this zone
void CvTacticalDominanceZone::SetClosestCity(CvCity *pCity)
{
if (pCity != NULL)
{
m_iCityID = pCity->GetID();
}
else
{
m_iCityID = -1;
}
}
/// Retrieve distance in hexes of closest enemy to center of this zone
int CvTacticalDominanceZone::GetRangeClosestEnemyUnit() const
{
return m_iRangeClosestEnemyUnit;
}
/// Set distance in hexes of closest enemy to center of this zone
void CvTacticalDominanceZone::SetRangeClosestEnemyUnit(int iRange)
{
m_iRangeClosestEnemyUnit = iRange;
}
/// Mix ownership of zone and who is dominant to get a unique classification for the zone
TacticalMoveZoneType CvTacticalDominanceZone::GetZoneType() const
{
if (m_eTerritoryType == TACTICAL_TERRITORY_FRIENDLY)
{
if (m_eDominanceFlag == TACTICAL_DOMINANCE_FRIENDLY)
{
return AI_TACTICAL_MOVE_ZONE_FRIENDLY_WINNING;
}
else if (m_eDominanceFlag == TACTICAL_DOMINANCE_EVEN)
{
return AI_TACTICAL_MOVE_ZONE_FRIENDLY_EVEN;
}
else
{
return AI_TACTICAL_MOVE_ZONE_FRIENDLY_LOSING;
}
}
else if (m_eTerritoryType == TACTICAL_TERRITORY_ENEMY)
{
if (m_eDominanceFlag == TACTICAL_DOMINANCE_FRIENDLY)
{
return AI_TACTICAL_MOVE_ZONE_ENEMY_WINNING;
}
else if (m_eDominanceFlag == TACTICAL_DOMINANCE_EVEN)
{
return AI_TACTICAL_MOVE_ZONE_ENEMY_EVEN;
}
else
{
return AI_TACTICAL_MOVE_ZONE_ENEMY_LOSING;
}
}
else
{
return AI_TACTICAL_MOVE_ZONE_UNOWNED;
}
}
//=====================================
// CvTacticalAnalysisMap
//=====================================
/// Constructor
CvTacticalAnalysisMap::CvTacticalAnalysisMap(void) :
m_pPlots(NULL),
m_iDominancePercentage(25),
m_iUnitStrengthMultiplier(5),
m_iTacticalRange(8),
m_iTempZoneRadius(5),
m_iBestFriendlyRange(0),
m_bIgnoreLOS(false),
m_pPlayer(NULL),
m_iNumPlots(0)
{
m_bIsBuilt = false;
m_iTurnBuilt = -1;
m_bAtWar = false;
m_DominanceZones.clear();
}
/// Destructor
CvTacticalAnalysisMap::~CvTacticalAnalysisMap(void)
{
SAFE_DELETE_ARRAY(m_pPlots);
}
/// Initialize
void CvTacticalAnalysisMap::Init(int iNumPlots)
{
// Time building of these maps
AI_PERF("AI-perf-tact.csv", "CvTacticalAnalysisMap::Init()" );
if (m_pPlots)
{
SAFE_DELETE_ARRAY(m_pPlots);
}
m_pPlots = FNEW(CvTacticalAnalysisCell[iNumPlots], c_eCiv5GameplayDLL, 0);
m_iNumPlots = iNumPlots;
m_iDominancePercentage = GC.getAI_TACTICAL_MAP_DOMINANCE_PERCENTAGE();
m_iTacticalRange = GC.getAI_TACTICAL_RECRUIT_RANGE();
m_iUnitStrengthMultiplier = GC.getAI_TACTICAL_MAP_UNIT_STRENGTH_MULTIPLIER() * m_iTacticalRange;
m_iTempZoneRadius = GC.getAI_TACTICAL_MAP_TEMP_ZONE_RADIUS();
}
/// Fill the map with data for this AI player's turn
void CvTacticalAnalysisMap::RefreshDataForNextPlayer(CvPlayer *pPlayer)
{
if (m_pPlots)
{
if (pPlayer != m_pPlayer || m_iTurnBuilt < GC.getGame().getGameTurn())
{
m_pPlayer = pPlayer;
m_iTurnBuilt = GC.getGame().getGameTurn();
// Time building of these maps
AI_PERF_FORMAT("AI-perf.csv", ("Tactical Analysis Map, Turn %d, %s", GC.getGame().getGameTurn(), m_pPlayer->getCivilizationShortDescription()) );
m_bIsBuilt = false;
// AI civs build this map every turn
//if (!m_pPlayer->isHuman() && !m_pPlayer->isBarbarian())
if (!m_pPlayer->isBarbarian())
{
m_DominanceZones.clear();
AddTemporaryZones();
for (int iI = 0; iI < GC.getMap().numPlots(); iI++)
{
CvAssertMsg((iI < m_iNumPlots), "Plot to be accessed exceeds allocation!");
CvPlot *pPlot = GC.getMap().plotByIndexUnchecked(iI);
if (pPlot == NULL)
{
// Erase this cell
m_pPlots[iI].Clear();
}
else
{
if (PopulateCell(iI, pPlot))
{
AddToDominanceZones(iI, &m_pPlots[iI]);
}
}
}
CalculateMilitaryStrengths();
PrioritizeZones();
LogZones();
BuildEnemyUnitList();
MarkCellsNearEnemy();
m_bIsBuilt = true;
}
}
}
}
// Find all our enemies (combat units)
void CvTacticalAnalysisMap::BuildEnemyUnitList()
{
CvTacticalAnalysisEnemy enemy;
m_EnemyUnits.clear();
for (int iPlayer = 0; iPlayer < MAX_PLAYERS; iPlayer++)
{
const PlayerTypes ePlayer = (PlayerTypes)iPlayer;
CvPlayer &kPlayer = GET_PLAYER(ePlayer);
const TeamTypes eTeam = kPlayer.getTeam();
// for each opposing civ
if (kPlayer.isAlive() && GET_TEAM(eTeam).isAtWar(m_pPlayer->getTeam()))
{
int iLoop;
CvUnit* pLoopUnit = NULL;
for (pLoopUnit = kPlayer.firstUnit(&iLoop); pLoopUnit != NULL; pLoopUnit = kPlayer.nextUnit(&iLoop))
{
// Make sure this unit can attack
if (pLoopUnit->IsCanAttack())
{
m_EnemyUnits.push_back(pLoopUnit);
}
}
}
}
}
// Indicate the plots we might want to move to that the enemy can attack
void CvTacticalAnalysisMap::MarkCellsNearEnemy()
{
int iDistance;
// Look at every cell on the map
for (int iI = 0; iI < GC.getMap().numPlots(); iI++)
{
bool bMarkedIt = false; // Set true once we've found one that enemy can move past (worst case)
CvPlot *pPlot = GC.getMap().plotByIndexUnchecked(iI);
if (m_pPlots[iI].IsRevealed() && !m_pPlots[iI].IsImpassableTerrain() && !m_pPlots[iI].IsImpassableTerritory())
{
// Friendly cities always safe
if (!m_pPlots[iI].IsFriendlyCity())
{
if (!pPlot->isVisibleToEnemyTeam(m_pPlayer->getTeam()))
{
m_pPlots[iI].SetNotVisibleToEnemy(true);
}
else
{
for (unsigned int iUnitIndex = 0; iUnitIndex < m_EnemyUnits.size() && !bMarkedIt; iUnitIndex++)
{
CvUnit *pUnit = m_EnemyUnits[iUnitIndex];
if (pUnit->getArea() == pPlot->getArea())
{
// Distance check before hitting pathfinder
iDistance = plotDistance(pUnit->getX(), pUnit->getY(), pPlot->getX(), pPlot->getY());
if (iDistance == 0)
{
m_pPlots[iI].SetSubjectToAttack(true);
m_pPlots[iI].SetEnemyCanMovePast(true);
bMarkedIt = true;
}
// TEMPORARY OPTIMIZATION: Assumes can't use roads or RR
else if (iDistance <= pUnit->baseMoves())
{
int iTurnsToReach;
iTurnsToReach = TurnsToReachTarget(pUnit, pPlot, true /*bReusePaths*/, true /*bIgnoreUnits*/); // Its ok to reuse paths because when ignoring units, we don't use the tactical analysis map (which we are building)
if (iTurnsToReach <= 1)
{
m_pPlots[iI].SetSubjectToAttack(true);
}
if (iTurnsToReach == 0)
{
m_pPlots[iI].SetEnemyCanMovePast(true);
bMarkedIt = true;
}
}
}
}
// Check adjacent plots for enemy citadels
if (!m_pPlots[iI].IsSubjectToAttack())
{
CvPlot *pAdjacentPlot;
for (int jJ = 0; jJ < NUM_DIRECTION_TYPES; jJ++)
{
pAdjacentPlot = plotDirection(pPlot->getX(), pPlot->getY(), ((DirectionTypes)jJ));
if (pAdjacentPlot != NULL && pAdjacentPlot->getOwner() != NO_PLAYER)
{
if (atWar(m_pPlayer->getTeam(), GET_PLAYER(pAdjacentPlot->getOwner()).getTeam()))
{
ImprovementTypes eImprovement = pAdjacentPlot->getImprovementType();
if (eImprovement != NO_IMPROVEMENT && GC.getImprovementInfo(eImprovement)->GetNearbyEnemyDamage() > 0)
{
m_pPlots[iI].SetSubjectToAttack(true);
break;
}
}
}
}
}
}
}
}
}
}
// Clear all dynamic data flags from the map
void CvTacticalAnalysisMap::ClearDynamicFlags()
{
for (int iI = 0; iI < GC.getMap().numPlots(); iI++)
{
// Erase this cell
m_pPlots[iI].SetWithinRangeOfTarget(false);
m_pPlots[iI].SetHelpsProvidesFlankBonus(false);
m_pPlots[iI].SetSafeForDeployment(false);
m_pPlots[iI].SetDeploymentScore(0);
}
}
// Mark cells we can use to bomb a specific target
void CvTacticalAnalysisMap::SetTargetBombardCells(CvPlot *pTarget, int iRange, bool bIgnoreLOS)
{
int iDX, iDY;
CvPlot *pLoopPlot;
int iPlotIndex;
int iPlotDistance;
for (iDX = -(iRange); iDX <= iRange; iDX++)
{
for (iDY = -(iRange); iDY <= iRange; iDY++)
{
pLoopPlot = plotXY(pTarget->getX(), pTarget->getY(), iDX, iDY);
if (pLoopPlot != NULL)
{
iPlotDistance = plotDistance(pLoopPlot->getX(), pLoopPlot->getY(), pTarget->getX(), pTarget->getY());
if (iPlotDistance > 0 && iPlotDistance <= iRange)
{
iPlotIndex = GC.getMap().plotNum(pLoopPlot->getX(), pLoopPlot->getY());
if (m_pPlots[iPlotIndex].IsRevealed() && !m_pPlots[iPlotIndex].IsImpassableTerrain() && !m_pPlots[iPlotIndex].IsImpassableTerritory())
{
if (!m_pPlots[iPlotIndex].IsEnemyCity() && !m_pPlots[iPlotIndex].IsNeutralCity())
{
if (bIgnoreLOS || pLoopPlot->canSeePlot(pTarget, m_pPlayer->getTeam(), iRange, NO_DIRECTION))
{
m_pPlots[iPlotIndex].SetWithinRangeOfTarget(true);
}
}
}
}
}
}
}
}
// Mark cells we can use to bomb a specific target
void CvTacticalAnalysisMap::SetTargetFlankBonusCells(CvPlot *pTarget)
{
CvPlot *pLoopPlot;
int iPlotIndex;
// No flank attacks on units at sea (where all combat is bombards)
if (pTarget->isWater())
{
return;
}
for (int iI = 0; iI < NUM_DIRECTION_TYPES; iI++)
{
pLoopPlot = plotDirection(pTarget->getX(), pTarget->getY(), ((DirectionTypes)iI));
if (pLoopPlot != NULL)
{
iPlotIndex = GC.getMap().plotNum(pLoopPlot->getX(), pLoopPlot->getY());
if (m_pPlots[iPlotIndex].IsRevealed() && !m_pPlots[iPlotIndex].IsImpassableTerrain() && !m_pPlots[iPlotIndex].IsImpassableTerritory())
{
if (!m_pPlots[iPlotIndex].IsFriendlyCity() && !m_pPlots[iPlotIndex].IsEnemyCity() && !m_pPlots[iPlotIndex].IsNeutralCity())
{
if (!m_pPlots[iPlotIndex].IsFriendlyTurnEndTile() && m_pPlots[iPlotIndex].GetEnemyMilitaryUnit() == NULL)
{
m_pPlots[iPlotIndex].SetHelpsProvidesFlankBonus(true);
}
}
}
}
}
}
// PRIVATE FUNCTIONS
/// Add in any temporary dominance zones from tactical AI
void CvTacticalAnalysisMap::AddTemporaryZones()
{
CvTemporaryZone *pZone;
CvTacticalAI *pTacticalAI = m_pPlayer->GetTacticalAI();
if (pTacticalAI)
{
pTacticalAI->DropObsoleteZones();
pZone = pTacticalAI->GetFirstTemporaryZone();
while (pZone)
{
// Can't be a city zone (which is just used to boost priority but not establish a new zone)
if (pZone->GetTargetType() != AI_TACTICAL_TARGET_CITY)
{
CvPlot *pPlot = GC.getMap().plot(pZone->GetX(), pZone->GetY());
if (pPlot)
{
CvTacticalDominanceZone newZone;
newZone.SetDominanceZoneID(m_DominanceZones.size());
newZone.SetTerritoryType(TACTICAL_TERRITORY_TEMP_ZONE);
newZone.SetOwner(NO_PLAYER);
newZone.SetAreaID(pPlot->getArea());
newZone.SetWater(pPlot->isWater());
newZone.SetTempZoneCenter(pPlot);
newZone.SetNavalInvasion(pZone->IsNavalInvasion());
m_DominanceZones.push_back(newZone);
}
}
pZone = pTacticalAI->GetNextTemporaryZone();
}
}
}
/// Update data for a cell: returns whether or not to add to dominance zones
bool CvTacticalAnalysisMap::PopulateCell(int iIndex, CvPlot *pPlot)
{
CvUnit *pLoopUnit;
int iUnitLoop;
CvTacticalAnalysisCell &cell = m_pPlots[iIndex];
cell.Clear();
cell.SetRevealed(pPlot->isRevealed(m_pPlayer->getTeam()));
cell.SetVisible(pPlot->isVisible(m_pPlayer->getTeam()));
cell.SetImpassableTerrain(pPlot->isImpassable());
cell.SetWater(pPlot->isWater());
cell.SetOcean(pPlot->isWater() && !pPlot->isShallowWater());
bool bImpassableTerritory = false;
if (pPlot->isOwned())
{
TeamTypes eMyTeam = m_pPlayer->getTeam();
TeamTypes ePlotTeam = pPlot->getTeam();
if (eMyTeam != ePlotTeam && !GET_TEAM(eMyTeam).isAtWar(ePlotTeam) && !GET_TEAM(ePlotTeam).IsAllowsOpenBordersToTeam(eMyTeam))
{
bImpassableTerritory = true;
}
else if (pPlot->isCity())
{
if (pPlot->getOwner() == m_pPlayer->GetID())
{
cell.SetFriendlyCity(true);
}
else if (GET_TEAM(eMyTeam).isAtWar(ePlotTeam))
{
cell.SetEnemyCity(true);
}
else
{
cell.SetNeutralCity(true);
}
}
if (m_pPlayer->GetID() == pPlot->getOwner())
{
cell.SetOwnTerritory(true);
}
if (GET_TEAM(eMyTeam).isFriendlyTerritory(ePlotTeam))
{
cell.SetFriendlyTerritory(true);
}
if (GET_TEAM(ePlotTeam).isAtWar(ePlotTeam))
{
cell.SetEnemyTerritory(true);
}
}
else
{
cell.SetUnclaimedTerritory(true);
}
cell.SetImpassableTerritory(bImpassableTerritory);
cell.SetDefenseModifier(pPlot->defenseModifier(NO_TEAM, true));
if (pPlot->getNumUnits() > 0)
{
for (iUnitLoop = 0; iUnitLoop < pPlot->getNumUnits(); iUnitLoop++)
{
pLoopUnit = pPlot->getUnitByIndex(iUnitLoop);
if(!pLoopUnit) continue;
if (pLoopUnit->getOwner() == m_pPlayer->GetID())
{
if (pLoopUnit->IsCombatUnit())
{
// CvAssertMsg(!cell.GetFriendlyMilitaryUnit(), "Two friendly military units in a hex, please show Ed and send save.");
cell.SetFriendlyMilitaryUnit(pLoopUnit);
}
else
{
// CvAssertMsg(!cell.GetFriendlyCivilianUnit(), "Two friendly civilian units in a hex, please show Ed and send save.");
cell.SetFriendlyCivilianUnit(pLoopUnit);
}
}
else if (pLoopUnit->isEnemy(m_pPlayer->getTeam()))
{
if (pLoopUnit->IsCombatUnit())
{
// CvAssertMsg(!cell.GetEnemyMilitaryUnit(), "Two enemy military units in a hex, please show Ed and send save.");
cell.SetEnemyMilitaryUnit(pLoopUnit);
}
else
{
// CvAssertMsg(!cell.GetEnemyCivilianUnit(), "Two enemy civilian units in a hex, please show Ed and send save.");
cell.SetEnemyCivilianUnit(pLoopUnit);
}
}
else
{
if (pLoopUnit->IsCombatUnit())
{
// CvAssertMsg(!cell.GetNeutralMilitaryUnit(), "Two neutral military units in a hex, please show Ed and send save.");
cell.SetNeutralMilitaryUnit(pLoopUnit);
}
else
{
// CvAssertMsg(!cell.GetNeutralCivilianUnit(), "Two neutral civilian units in a hex, please show Ed and send save.");
cell.SetNeutralCivilianUnit(pLoopUnit);
}
}
}
}
// Figure out whether or not to add this to a dominance zone
bool bAdd = true;
if (cell.IsImpassableTerrain() || cell.IsImpassableTerritory() || !cell.IsRevealed())
{
bAdd = false;
}
return bAdd;
}
/// Add data for this cell into dominance zone information
void CvTacticalAnalysisMap::AddToDominanceZones(int iIndex, CvTacticalAnalysisCell *pCell)
{
CvPlot *pPlot = GC.getMap().plotByIndex(iIndex);
// Compute zone data for this cell
m_TempZone.SetAreaID(pPlot->getArea());
m_TempZone.SetOwner(pPlot->getOwner());
m_TempZone.SetWater(pPlot->isWater());
if (!pPlot->isOwned())
{
m_TempZone.SetTerritoryType(TACTICAL_TERRITORY_NO_OWNER);
}
else if (pPlot->getTeam() == m_pPlayer->getTeam())
{
m_TempZone.SetTerritoryType(TACTICAL_TERRITORY_FRIENDLY);
}
else if (GET_TEAM(m_pPlayer->getTeam()).isAtWar(pPlot->getTeam()))
{
m_TempZone.SetTerritoryType(TACTICAL_TERRITORY_ENEMY);
}
else
{
m_TempZone.SetTerritoryType(TACTICAL_TERRITORY_NEUTRAL);
}
m_TempZone.SetClosestCity(NULL);
if (m_TempZone.GetTerritoryType() == TACTICAL_TERRITORY_ENEMY ||
m_TempZone.GetTerritoryType() == TACTICAL_TERRITORY_NEUTRAL ||
m_TempZone.GetTerritoryType() == TACTICAL_TERRITORY_FRIENDLY)
{
int iLoop;
int iBestDistance = MAX_INT;
CvCity *pBestCity = NULL;
for (CvCity *pLoopCity = GET_PLAYER(m_TempZone.GetOwner()).firstCity(&iLoop); pLoopCity != NULL; pLoopCity = GET_PLAYER(m_TempZone.GetOwner()).nextCity(&iLoop))
{
int iDistance = plotDistance(pLoopCity->getX(), pLoopCity->getY(), pPlot->getX(), pPlot->getY());
if (iDistance < iBestDistance)
{
iBestDistance = iDistance;
pBestCity = pLoopCity;
}
}
if (pBestCity != NULL)
{
m_TempZone.SetClosestCity(pBestCity);
}
}
// Now see if we already have a matching zone
CvTacticalDominanceZone *pZone = FindExistingZone(pPlot);
if (!pZone)
{
// Data populated, now add to vector
m_TempZone.SetDominanceZoneID(m_DominanceZones.size());
m_DominanceZones.push_back(m_TempZone);
pZone = &m_DominanceZones[m_DominanceZones.size() - 1];
}
// If this isn't owned territory, update zone with military strength info
if (pZone->GetTerritoryType() == TACTICAL_TERRITORY_NO_OWNER ||
pZone->GetTerritoryType() == TACTICAL_TERRITORY_TEMP_ZONE)
{
CvUnit *pFriendlyUnit = pCell->GetFriendlyMilitaryUnit();
if (pFriendlyUnit)
{
if (pFriendlyUnit->getDomainType() == DOMAIN_AIR ||
(pFriendlyUnit->getDomainType() == DOMAIN_LAND && !pZone->IsWater()) ||
(pFriendlyUnit->getDomainType() == DOMAIN_SEA && pZone->IsWater()))
{
int iStrength = pFriendlyUnit->GetBaseCombatStrengthConsideringDamage();
if (iStrength == 0 && pFriendlyUnit->isEmbarked() && !pZone->IsWater())
{
iStrength = pFriendlyUnit->GetBaseCombatStrength(true);
}
pZone->AddFriendlyStrength(iStrength * m_iUnitStrengthMultiplier);
pZone->AddFriendlyRangedStrength(pFriendlyUnit->GetMaxRangedCombatStrength(NULL, /*pCity*/ NULL, true, true));
if (pFriendlyUnit->GetRange() > GetBestFriendlyRange())
{
SetBestFriendlyRange(pFriendlyUnit->GetRange());
}
if (pFriendlyUnit->IsRangeAttackIgnoreLOS())
{
SetIgnoreLOS(true);
}
pZone->AddFriendlyUnitCount(1);
if (pFriendlyUnit->isRanged())
{
pZone->AddFriendlyRangedUnitCount(1);
}
}
}
CvUnit *pEnemyUnit = pCell->GetEnemyMilitaryUnit();
if (pEnemyUnit)
{
if (pEnemyUnit->getDomainType() == DOMAIN_AIR ||
(pEnemyUnit->getDomainType() == DOMAIN_LAND && !pZone->IsWater()) ||
(pEnemyUnit->getDomainType() == DOMAIN_SEA && pZone->IsWater()))
{
int iStrength = pEnemyUnit->GetBaseCombatStrengthConsideringDamage();
if (iStrength == 0 && pEnemyUnit->isEmbarked() && !pZone->IsWater())
{
iStrength = pEnemyUnit->GetBaseCombatStrength(true);
}
pZone->AddEnemyStrength(iStrength * m_iUnitStrengthMultiplier);
pZone->AddEnemyRangedStrength(pEnemyUnit->GetMaxRangedCombatStrength(NULL, /*pCity*/ NULL, true, true));
pZone->AddEnemyUnitCount(1);
if (pEnemyUnit->isRanged())
{
pZone->AddEnemyRangedUnitCount(1);
}
}
}
}
// Set zone for this cell
pCell->SetDominanceZone(pZone->GetDominanceZoneID());
}
/// Calculate military presences in each owned dominance zone
void CvTacticalAnalysisMap::CalculateMilitaryStrengths()
{
// Loop through the dominance zones
CvTacticalDominanceZone *pZone;
CvCity *pClosestCity = NULL;
int iDistance;
int iMultiplier;
int iLoop;
CvUnit* pLoopUnit;
TeamTypes eTeam;
eTeam = m_pPlayer->getTeam();
for (unsigned int iI = 0; iI < m_DominanceZones.size(); iI++)
{
pZone = &m_DominanceZones[iI];
if (pZone->GetTerritoryType() != TACTICAL_TERRITORY_NO_OWNER)
{
pClosestCity = pZone->GetClosestCity();
if (pClosestCity)
{
// Start with strength of the city itself
int iStrength = pClosestCity->getStrengthValue() * m_iTacticalRange;
if (pZone->GetTerritoryType() == TACTICAL_TERRITORY_FRIENDLY)
{
pZone->AddFriendlyStrength(iStrength);
pZone->AddFriendlyRangedStrength(pClosestCity->getStrengthValue());
}
else
{
pZone->AddEnemyStrength(iStrength);
pZone->AddEnemyRangedStrength(pClosestCity->getStrengthValue());
}
// Loop through all of OUR units first
for (pLoopUnit = m_pPlayer->firstUnit(&iLoop); pLoopUnit != NULL; pLoopUnit = m_pPlayer->nextUnit(&iLoop))
{
if (pLoopUnit->IsCombatUnit())
{
if (pLoopUnit->getDomainType() == DOMAIN_AIR ||
(pLoopUnit->getDomainType() == DOMAIN_LAND && !pZone->IsWater()) ||
(pLoopUnit->getDomainType() == DOMAIN_SEA && pZone->IsWater()))
{
iDistance = plotDistance(pLoopUnit->getX(), pLoopUnit->getY(), pClosestCity->getX(), pClosestCity->getY());
iMultiplier = (m_iTacticalRange + 1 - iDistance);
if (iMultiplier > 0)
{
int iUnitStrength = pLoopUnit->GetBaseCombatStrengthConsideringDamage();
if (iUnitStrength == 0 && pLoopUnit->isEmbarked() && !pZone->IsWater())
{
iUnitStrength = pLoopUnit->GetBaseCombatStrength(true);
}
pZone->AddFriendlyStrength(iUnitStrength * iMultiplier * m_iUnitStrengthMultiplier);
pZone->AddFriendlyRangedStrength(pLoopUnit->GetMaxRangedCombatStrength(NULL, /*pCity*/ NULL, true, true));
if (pLoopUnit->GetRange() > GetBestFriendlyRange())
{
SetBestFriendlyRange(pLoopUnit->GetRange());
}
if (pLoopUnit->IsRangeAttackIgnoreLOS())
{
SetIgnoreLOS(true);
}
pZone->AddFriendlyUnitCount(1);
if (pLoopUnit->isRanged())
{
pZone->AddFriendlyRangedUnitCount(1);
}
}
}
}
}
// Repeat for all visible enemy units (or adjacent to visible)
for (int iPlayerLoop = 0; iPlayerLoop < MAX_CIV_PLAYERS; iPlayerLoop++)
{
CvPlayer &kPlayer = GET_PLAYER((PlayerTypes) iPlayerLoop);
if (GET_TEAM(eTeam).isAtWar(kPlayer.getTeam()))
{
for (pLoopUnit = kPlayer.firstUnit(&iLoop); pLoopUnit != NULL; pLoopUnit = kPlayer.nextUnit(&iLoop))
{
if (pLoopUnit->IsCombatUnit())
{
if (pLoopUnit->getDomainType() == DOMAIN_AIR ||
(pLoopUnit->getDomainType() == DOMAIN_LAND && !pZone->IsWater()) ||
(pLoopUnit->getDomainType() == DOMAIN_SEA && pZone->IsWater()))
{
CvPlot *pPlot;
pPlot = pLoopUnit->plot();
if (pPlot)
{
if (pPlot->isVisible(eTeam) || pPlot->isAdjacentVisible(eTeam))
{
iDistance = plotDistance(pLoopUnit->getX(), pLoopUnit->getY(), pClosestCity->getX(), pClosestCity->getY());
iMultiplier = (m_iTacticalRange + 1 - iDistance);
if (iMultiplier > 0)
{
int iUnitStrength = pLoopUnit->GetBaseCombatStrengthConsideringDamage();
if (iUnitStrength == 0 && pLoopUnit->isEmbarked() && !pZone->IsWater())
{
iUnitStrength = pLoopUnit->GetBaseCombatStrength(true);
}
pZone->AddEnemyStrength(iUnitStrength * iMultiplier * m_iUnitStrengthMultiplier);
pZone->AddEnemyRangedStrength(pLoopUnit->GetMaxRangedCombatStrength(NULL, /*pCity*/ NULL, true, true));
pZone->AddEnemyUnitCount(1);
if (iDistance < pZone->GetRangeClosestEnemyUnit())
{
pZone->SetRangeClosestEnemyUnit(iDistance);
}
if (pLoopUnit->isRanged())
{
pZone->AddEnemyRangedUnitCount(1);
}
}
}
}
}
}
}
}
}
}
}
}
}
/// Establish order of zone processing for the turn
void CvTacticalAnalysisMap::PrioritizeZones()
{
// Loop through the dominance zones
CvTacticalDominanceZone *pZone;
int iBaseValue;
int iMultiplier;
CvCity *pClosestCity = NULL;
for (unsigned int iI = 0; iI < m_DominanceZones.size(); iI++)
{
// Find the zone and compute dominance here
pZone = &m_DominanceZones[iI];
eTacticalDominanceFlags eDominance = ComputeDominance(pZone);
// Establish a base value for the region
iBaseValue = 1;
// Temporary zone?
if (pZone->GetTerritoryType() == TACTICAL_TERRITORY_TEMP_ZONE)
{
iMultiplier = 200;
}
else
{
pClosestCity = pZone->GetClosestCity();
if (pClosestCity)
{
iBaseValue += pZone->GetClosestCity()->getPopulation();
if (pClosestCity->isCapital())
{
iBaseValue *= 2;
}
// How damaged is this city?
int iDamage = pClosestCity->getDamage();
if (iDamage > 0)
{
iBaseValue *= ((iDamage + 2)/ 2);
}
if (m_pPlayer->GetTacticalAI()->IsTemporaryZoneCity(pClosestCity))
{
iBaseValue *= 3;
}
}
if (!pZone->IsWater())
{
iBaseValue *= 8;
}
// Now compute a multiplier based on current conditions here
iMultiplier = 1;
if (eDominance == TACTICAL_DOMINANCE_ENEMY)
{
if (pZone->GetTerritoryType() == TACTICAL_TERRITORY_ENEMY)
{
iMultiplier = 2;
}
else if (pZone->GetTerritoryType() == TACTICAL_TERRITORY_FRIENDLY)
{
iMultiplier = 4;
}
}
else if (eDominance == TACTICAL_DOMINANCE_EVEN)
{
if (pZone->GetTerritoryType() == TACTICAL_TERRITORY_ENEMY)
{
iMultiplier = 3;
}
else if (pZone->GetTerritoryType() == TACTICAL_TERRITORY_FRIENDLY)
{
iMultiplier = 3;
}
}
else if (eDominance == TACTICAL_DOMINANCE_FRIENDLY)
{
if (pZone->GetTerritoryType() == TACTICAL_TERRITORY_ENEMY)
{
iMultiplier = 4;
}
else if (pZone->GetTerritoryType() == TACTICAL_TERRITORY_FRIENDLY)
{
iMultiplier = 1;
}
}
if (!m_pPlayer->isMinorCiv())
{
if (m_pPlayer->GetDiplomacyAI()->GetStateAllWars() == STATE_ALL_WARS_WINNING)
{
if (pZone->GetTerritoryType() == TACTICAL_TERRITORY_ENEMY)
{
iMultiplier *= 2;
}
}
else if (m_pPlayer->GetDiplomacyAI()->GetStateAllWars() == STATE_ALL_WARS_LOSING)
{
if (pZone->GetTerritoryType() == TACTICAL_TERRITORY_FRIENDLY)
{
iMultiplier *= 4;
}
}
}
}
// Save off the value for this zone
if ((iBaseValue * iMultiplier) <= 0)
{
FAssertMsg((iBaseValue * iMultiplier) > 0, "Invalid Dominance Zone Value");
}
pZone->SetDominanceZoneValue(iBaseValue * iMultiplier);
}
std::stable_sort(m_DominanceZones.begin(), m_DominanceZones.end());
}
/// Log dominance zone data
void CvTacticalAnalysisMap::LogZones()
{
if (GC.getLogging() && GC.getAILogging())
{
CvString szLogMsg;
CvTacticalDominanceZone *pZone;
for (unsigned int iI = 0; iI < m_DominanceZones.size(); iI++)
{
pZone = &m_DominanceZones[iI];
// Log all zones with at least some unit present
// if (pZone->GetDominanceFlag() != TACTICAL_DOMINANCE_NO_UNITS_PRESENT && pZone->GetDominanceFlag() != TACTICAL_DOMINANCE_NOT_VISIBLE)
// {
szLogMsg.Format("Zone ID: %d, Area ID: %d, Value: %d, FRIENDLY Str: %d (%d), Ranged: %d (%d), ENEMY Str: %d (%d), Ranged: %d (%d), Closest Enemy: %d",
pZone->GetDominanceZoneID(), pZone->GetAreaID(), pZone->GetDominanceZoneValue(),
pZone->GetFriendlyStrength(), pZone->GetFriendlyUnitCount(), pZone->GetFriendlyRangedStrength(), pZone->GetFriendlyRangedUnitCount(),
pZone->GetEnemyStrength(), pZone->GetEnemyUnitCount(), pZone->GetEnemyRangedStrength(), pZone->GetEnemyRangedUnitCount(), pZone->GetRangeClosestEnemyUnit());
if (pZone->GetDominanceFlag() == TACTICAL_DOMINANCE_FRIENDLY)
{
szLogMsg += ", Friendly";
}
else if (pZone->GetDominanceFlag() == TACTICAL_DOMINANCE_ENEMY)
{
szLogMsg += ", Enemy";
}
else if (pZone->GetDominanceFlag() == TACTICAL_DOMINANCE_EVEN)
{
szLogMsg += ", Even";
}
else if (pZone->GetDominanceFlag() == TACTICAL_DOMINANCE_NO_UNITS_PRESENT)
{
szLogMsg += ", No Units";
}
else if (pZone->GetDominanceFlag() == TACTICAL_DOMINANCE_NOT_VISIBLE)
{
szLogMsg += ", Not Visible";
}
if (pZone->IsWater())
{
szLogMsg += ", Water";
}
else
{
szLogMsg += ", Land";
}
if (pZone->GetTerritoryType() == TACTICAL_TERRITORY_TEMP_ZONE)
{
szLogMsg += ", Temporary Zone";
}
else if (pZone->GetClosestCity())
{
szLogMsg += ", " + pZone->GetClosestCity()->getName();
}
m_pPlayer->GetTacticalAI()->LogTacticalMessage(szLogMsg, true /*bSkipLogDominanceZone*/);
// }
}
}
}
/// Can this cell go in an existing dominance zone?
CvTacticalDominanceZone *CvTacticalAnalysisMap::FindExistingZone(CvPlot *pPlot)
{
CvTacticalDominanceZone *pZone;
for (unsigned int iI = 0; iI < m_DominanceZones.size(); iI++)
{
pZone = &m_DominanceZones[iI];
// If this is a temporary zone, matches if unowned and close enough
if ((pZone->GetTerritoryType() == TACTICAL_TERRITORY_TEMP_ZONE) &&
(m_TempZone.GetTerritoryType() == TACTICAL_TERRITORY_NO_OWNER || m_TempZone.GetTerritoryType() == TACTICAL_TERRITORY_NEUTRAL) &&
(plotDistance(pPlot->getX(), pPlot->getY(), pZone->GetTempZoneCenter()->getX(), pZone->GetTempZoneCenter()->getY()) <= m_iTempZoneRadius))
{
return pZone;
}
// If not friendly or enemy, just 1 zone per area
if ((pZone->GetTerritoryType() == TACTICAL_TERRITORY_NO_OWNER || pZone->GetTerritoryType() == TACTICAL_TERRITORY_NEUTRAL) &&
(m_TempZone.GetTerritoryType() == TACTICAL_TERRITORY_NO_OWNER || m_TempZone.GetTerritoryType() == TACTICAL_TERRITORY_NEUTRAL))
{
if (pZone->GetAreaID() == m_TempZone.GetAreaID())
{
return pZone;
}
}
// Otherwise everything needs to match
if (pZone->GetTerritoryType() == m_TempZone.GetTerritoryType() &&
pZone->GetOwner() == m_TempZone.GetOwner() &&
pZone->GetAreaID() == m_TempZone.GetAreaID() &&
pZone->GetClosestCity() == m_TempZone.GetClosestCity())
{
return pZone;
}
}
return NULL;
}
/// Retrieve a dominance zone
CvTacticalDominanceZone *CvTacticalAnalysisMap::GetZone(int iIndex)
{
if(iIndex < 0 || iIndex >= (int)m_DominanceZones.size())
return 0;
return &m_DominanceZones[iIndex];
}
/// Retrieve a dominance zone by closest city
CvTacticalDominanceZone *CvTacticalAnalysisMap::GetZoneByCity(CvCity *pCity, bool bWater)
{
CvTacticalDominanceZone *pZone;
for (int iI = 0; iI < GetNumZones(); iI++)
{
pZone = GetZone(iI);
if (pZone->GetClosestCity() == pCity && pZone->IsWater() == bWater)
{
return pZone;
}
}
return NULL;
}
// Is this plot in dangerous territory?
bool CvTacticalAnalysisMap::IsInEnemyDominatedZone(CvPlot *pPlot)
{
CvTacticalAnalysisCell *pCell;
int iPlotIndex;
CvTacticalDominanceZone *pZone;
iPlotIndex = GC.getMap().plotNum(pPlot->getX(), pPlot->getY());
pCell = GetCell(iPlotIndex);
for (int iI = 0; iI < GetNumZones(); iI++)
{
pZone = GetZone(iI);
if (pZone->GetDominanceZoneID() == pCell->GetDominanceZone())
{
return (pZone->GetDominanceFlag() == TACTICAL_DOMINANCE_ENEMY || pZone->GetDominanceFlag() == TACTICAL_DOMINANCE_NOT_VISIBLE);
}
}
return false;
}
/// Who is dominant in this one zone?
eTacticalDominanceFlags CvTacticalAnalysisMap::ComputeDominance(CvTacticalDominanceZone *pZone)
{
bool bTempZone = false;
if (pZone->GetClosestCity())
{
bTempZone = m_pPlayer->GetTacticalAI()->IsTemporaryZoneCity(pZone->GetClosestCity());
}
// Look at ratio of friendly to enemy strength
if (pZone->GetFriendlyStrength() + pZone->GetEnemyStrength() <= 0)
{
pZone->SetDominanceFlag(TACTICAL_DOMINANCE_NO_UNITS_PRESENT);
}
// Enemy zone that we can't see (that isn't one of our temporary targets?
else if (pZone->GetTerritoryType() == TACTICAL_TERRITORY_ENEMY && !(pZone->GetClosestCity()->plot())->isVisible(m_pPlayer->getTeam()) && !bTempZone)
{
pZone->SetDominanceFlag(TACTICAL_DOMINANCE_NOT_VISIBLE);
}
else
{
bool bEnemyCanSeeOurCity = false;
if (pZone->GetTerritoryType() == TACTICAL_TERRITORY_FRIENDLY)
{
for (int iI = 0; iI < MAX_PLAYERS; iI++)
{
CvPlayerAI& kPlayer = GET_PLAYER((PlayerTypes)iI);
if (kPlayer.isAlive())
{
TeamTypes eOtherTeam = kPlayer.getTeam();
if (eOtherTeam != m_pPlayer->getTeam())
{
if (GET_TEAM(eOtherTeam).isAtWar(m_pPlayer->getTeam()))
{
if (pZone->GetClosestCity()->plot()->isVisible(eOtherTeam))
{
bEnemyCanSeeOurCity = true;
break;
}
}
}
}
}
}
if (pZone->GetTerritoryType() == TACTICAL_TERRITORY_FRIENDLY && !bEnemyCanSeeOurCity)
{
pZone->SetDominanceFlag(TACTICAL_DOMINANCE_NOT_VISIBLE);
}
// Otherwise compute it by strength
else if (pZone->GetEnemyStrength() <= 0)
{
pZone->SetDominanceFlag(TACTICAL_DOMINANCE_FRIENDLY);
}
else
{
int iRatio = (pZone->GetFriendlyStrength() * 100) / pZone->GetEnemyStrength();
if (iRatio > 100 + m_iDominancePercentage)
{
pZone->SetDominanceFlag(TACTICAL_DOMINANCE_FRIENDLY);
}
else if (iRatio < 100 - m_iDominancePercentage)
{
pZone->SetDominanceFlag(TACTICAL_DOMINANCE_ENEMY);
}
else
{
pZone->SetDominanceFlag(TACTICAL_DOMINANCE_EVEN);
}
}
}
return pZone->GetDominanceFlag();
}
| [
"delnar.ersike@gmail.com"
] | delnar.ersike@gmail.com |
c49d8af418d00a8bb71ba1ac7703af326aa98e3b | 74b5d3fa626c83846a5d2890671859bcbe9c3947 | /MathWiz/source/Bootloader.cxx | e11d32edc957ad8faa5a63d52de29556050a39aa | [] | no_license | yash101/MathWiz | fc4181f72cd9680cc1b24643b0e5bd26ac2988fa | 0ad35166c7043f6410be7942058e5caa4837a103 | refs/heads/master | 2021-01-10T21:11:58.746629 | 2015-04-30T03:45:56 | 2015-04-30T03:45:56 | 25,278,914 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 726 | cxx | #include "../include/Bootloader.hxx"
void boot::generate_file_list()
{
if(!ramfs::stat_file(FILECACHE_LOCATION))
{
if(DETAILED_DEBUG)
{
std::cout << "Warning: Unable to stat filecache.dat!" << std::endl;
}
}
std::stringstream str;
str << ramfs::read_file(FILECACHE_LOCATION);
std::string buffer;
std::vector<std::string> file_locations;
while(std::getline(str, buffer))
{
file_locations.push_back(buffer);
}
ramfs::filesystem.cache_list(file_locations);
return;
}
void boot::boot()
{
std::thread(generate_file_list).detach();
global::MathWizServer.set_listening_port(SERVER_PORT);
global::MathWizServer.start_async();
}
| [
"dlodha@pvlearners.net"
] | dlodha@pvlearners.net |
3afdd21aab3c52577df1163a5807da47421e48fd | bd3013a1d6612a5e11ee75db70d65b394d87bbf0 | /src/ukf.cpp | 5f7b2db4fd109917d4221251f4b2f47abeaaa04d | [
"MIT"
] | permissive | jtwolak/CarND-Unscented-Kalman-Filter | 9fac3e1dec49365ea391b5b48a980401e2209e5a | 2bb63b3bc69bbe78ca4bdf705680eb8bb2d4ddc9 | refs/heads/master | 2020-03-25T19:12:56.369976 | 2018-08-08T21:57:25 | 2018-08-08T21:57:25 | 144,070,983 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 12,620 | cpp | #include "ukf.h"
#include "Eigen/Dense"
#include <iostream>
using namespace std;
using Eigen::MatrixXd;
using Eigen::VectorXd;
using std::vector;
/**
* Initializes Unscented Kalman filter
* This is scaffolding, do not modify
*/
UKF::UKF() {
// if this is false, laser measurements will be ignored (except during init)
use_laser_ = true;
// if this is false, radar measurements will be ignored (except during init)
use_radar_ = true;
// initial state vector
x_ = VectorXd(5);
// initial covariance matrix
P_ = MatrixXd(5, 5);
// Process noise standard deviation longitudinal acceleration in m/s^2
std_a_ = 3; // 30;
// Process noise standard deviation yaw acceleration in rad/s^2
std_yawdd_ = 3; // 30;
//DO NOT MODIFY measurement noise values below these are provided by the sensor manufacturer.
// Laser measurement noise standard deviation position1 in m
std_laspx_ = 0.15;
// Laser measurement noise standard deviation position2 in m
std_laspy_ = 0.15;
// Radar measurement noise standard deviation radius in m
std_radr_ = 0.3;
// Radar measurement noise standard deviation angle in rad
std_radphi_ = 0.03;
// Radar measurement noise standard deviation radius change in m/s
std_radrd_ = 0.3;
//DO NOT MODIFY measurement noise values above these are provided by the sensor manufacturer.
/**
TODO:
Complete the initialization. See ukf.h for other member properties.
Hint: one or more values initialized above might be wildly off...
*/
n_x_ = 5; //set state dimension
n_aug_ = 7; //set augmented dimension
lambda_ = 3 - n_aug_; //define spreading parameter
Xsig_pred_ = MatrixXd(n_x_, 2 * n_aug_ + 1); //allocate matrix for predicted sigma points
weights_ = VectorXd(2 * n_aug_ + 1); //allocate vector for weights
//calculate weights for Radar update
float w = 1 / (2 * (lambda_ + n_aug_));
weights_.fill(w);
w = lambda_ / (lambda_ + n_aug_);
weights_(0) = w;
// For Lidar update
H_ = MatrixXd(2, 5);
H_ << 1, 0, 0, 0, 0,
0, 1, 0, 0, 0;
R_ = MatrixXd(2, 2);
R_ << std_laspx_* std_laspx_, 0,
0, std_laspy_*std_laspy_;
}
UKF::~UKF() {}
/**
* @param {MeasurementPackage} meas_package The latest measurement data of
* either radar or laser.
*/
void UKF::ProcessMeasurement(MeasurementPackage meas_package) {
/**
TODO:
Complete this function! Make sure you switch between lidar and radar
measurements.
*/
if (((meas_package.sensor_type_ == MeasurementPackage::RADAR) && !use_radar_) ||
((meas_package.sensor_type_ == MeasurementPackage::LASER) && !use_laser_))
{
/* this is need to prevent the main() routine from crashing because it tries to
* read data from "x_" that may not have been initialized.
*/
if (!is_initialized_)
{
x_ << 1, 1, 1, 1, 1;
}
return;
}
/* Sanity check. We need to re-init when we want to switch between Datatset1
* and Dataset2 or if we want to Restart the current Dataset
* without re-launching the application
*/
if (time_us_ != 0)
{
if (time_us_ > meas_package.timestamp_)
{
is_initialized_ = 0;
}
else
{
float diff = (meas_package.timestamp_ - time_us_) / 1000000.0;
if (diff > 1000000)
{
is_initialized_ = 0;
}
}
}
/*****************************************************************************
* Initialization
****************************************************************************/
if (!is_initialized_)
{
/**
TODO:
* Initialize the state ekf_.x_ with the first measurement.
* Create the covariance matrix.
* Remember: you'll need to convert radar from polar to cartesian coordinates.
*/
//step_ = 0;
// first measurement
cout << "UKF: " << endl;
// init state
x_ << 1, 1, 1, 1, 1;
// init matrix P
P_ << 0.2, 0, 0, 0, 0,
0, 0.2, 0, 0, 0,
0, 0, 0.4, 0, 0,
0, 0, 0, 0.2, 0,
0, 0, 0, 0, 0.2;
time_us_ = meas_package.timestamp_;
if (meas_package.sensor_type_ == MeasurementPackage::RADAR)
{
/**
Convert radar from polar to cartesian coordinates and initialize state.
*/
float ro = meas_package.raw_measurements_[0];
float phi = meas_package.raw_measurements_[1];
float rho_dot = meas_package.raw_measurements_[2];
float px = ro * cos(phi);
float py = ro * sin(phi);
x_ << px, py, rho_dot, 0, 0;
}
else if (meas_package.sensor_type_ == MeasurementPackage::LASER)
{
/**
Initialize state.
*/
float px = meas_package.raw_measurements_[0];
float py = meas_package.raw_measurements_[1];
x_ << px, py, 0, 0, 0;
}
// done initializing, no need to predict or update
is_initialized_ = true;
return;
}
/*****************************************************************************
* Prediction
****************************************************************************/
// 1. compute the time elapsed between the current and previous measurements
float dt = (meas_package.timestamp_ - time_us_) / 1000000.0; //dt - expressed in seconds
time_us_ = meas_package.timestamp_;
//2. Call the Unscented Kalman Filter prediction function
Prediction(dt);
/*****************************************************************************
* Update
****************************************************************************/
if (meas_package.sensor_type_ == MeasurementPackage::RADAR)
{
/*
* Radar updates
*/
UpdateRadar(meas_package);
}
else
{
/*
* Laser updates
*/
UpdateLidar(meas_package);
}
// print the output
// cout << "x_ = " << ekf_.x_ << endl;
// cout << "P_ = " << ekf_.P_ << endl;
//step_++;
}
/**
* Predicts sigma points, the state, and the state covariance matrix.
* @param {double} delta_t the change in time (in seconds) between the last
* measurement and this one.
*/
void UKF::Prediction(double delta_t) {
/**
TODO:
Complete this function! Estimate the object's location. Modify the state
vector, x_. Predict sigma points, the state, and the state covariance matrix.
*/
/*======================================
*=== 1. Generate Sigma Points ====
*======================================*/
/*
* 1.1 create augmented mean vector
*/
VectorXd x_aug = VectorXd(n_aug_);
x_aug.fill(0.0);
x_aug.head(n_x_) = x_;
/*
* 1.2 create augmented state covariance
*/
MatrixXd P_aug = MatrixXd(n_aug_, n_aug_);
P_aug.fill(0.0);
P_aug.topLeftCorner(n_x_, n_x_) = P_;
P_aug(n_x_, n_x_) = std_a_ * std_a_;
P_aug(n_x_ + 1, n_x_ + 1) = std_yawdd_ * std_yawdd_;
/*
* 1.3 create square root matrix
*/
MatrixXd A = P_aug.llt().matrixL();
/*
* 1.4 create augmented sigma points matrix
*/
MatrixXd Xsig_aug = MatrixXd(n_aug_, 2 * n_aug_ + 1);
Xsig_aug.col(0) = x_aug;
for (int i = 0; i < n_aug_; i++)
{
Xsig_aug.col(i + 1) = x_aug + sqrt(lambda_ + n_aug_) * A.col(i);
Xsig_aug.col(i + 1 + n_aug_) = x_aug - sqrt(lambda_ + n_aug_) * A.col(i);
}
/*====================================
*=== 2. Predict Sigma Points ====
*====================================*/
/*
* 2.1 calculate Predicted Sigma Points. Each column is one sigma point.
*/
VectorXd x = VectorXd(n_aug_);
VectorXd x_pred = VectorXd(n_x_);
double delta_t2 = delta_t * delta_t;
for (int i = 0; i < (2 * n_aug_ + 1); i++)
{
x = Xsig_aug.col(i);
if (x(4) == 0.0)
{
x_pred(0) = x(0) + (x(2)*cos(x(3))*delta_t) + (0.5*delta_t2*cos(x(3))*x(5));
x_pred(1) = x(1) + (x(2)*sin(x(3))*delta_t) + (0.5*delta_t2*sin(x(3))*x(5));
x_pred(2) = x(2) + 0 + (delta_t*x(5));
x_pred(3) = x(3) + (x(4)*delta_t) + (0.5*delta_t2*x(6));
x_pred(4) = x(4) + 0 + (delta_t*x(6));
}
else
{
x_pred(0) = x(0) + (x(2) / x(4))*(sin(x(3) + x(4)*delta_t) - sin(x(3))) + (0.5*delta_t2*cos(x(3))*x(5));
x_pred(1) = x(1) + (x(2) / x(4))*(-cos(x(3) + x(4)*delta_t) + cos(x(3))) + (0.5*delta_t2*sin(x(3))*x(5));
x_pred(2) = x(2) + 0 + (delta_t*x(5));
x_pred(3) = x(3) + (x(4)*delta_t) + (0.5*delta_t2*x(6));
x_pred(4) = x(4) + 0 + (delta_t*x(6));
}
Xsig_pred_.col(i) = x_pred;
}
/*============================================
*=== 3. Predict Mean and Covariance ====
*============================================*/
/*
* 3.1 calculate predict state mean
*/
x_.fill(0.0);
for (int i = 0; i < 1 + (2 * n_aug_); i++)
{
x_ = x_ + weights_(i)*Xsig_pred_.col(i);
}
/*
* 3.2 calculate predict state covariance matrix
*/
VectorXd tmp;
P_.fill(0.0);
for (int i = 0; i < 1 + (2 * n_aug_); i++)
{
tmp = (Xsig_pred_.col(i) - x_);
while (tmp(3)> M_PI) tmp(3) -= 2.*M_PI;
while (tmp(3)<-M_PI) tmp(3) += 2.*M_PI;
P_ += weights_(i) * tmp * tmp.transpose();
}
}
/**
* Updates the state and the state covariance matrix using a laser measurement.
* @param {MeasurementPackage} meas_package
*/
void UKF::UpdateLidar(MeasurementPackage meas_package) {
/**
TODO:
Complete this function! Use lidar data to update the belief about the object's
position. Modify the state vector, x_, and covariance, P_.
You'll also need to calculate the lidar NIS.
*/
int n_z = 2;
VectorXd z = VectorXd(n_z);
z(0) = meas_package.raw_measurements_(0);
z(1) = meas_package.raw_measurements_(1);
VectorXd z_pred = H_ * x_;
VectorXd y = z - z_pred;
MatrixXd Ht = H_.transpose();
MatrixXd S = H_ * P_ * Ht + R_;
MatrixXd Si = S.inverse();
MatrixXd PHt = P_ * Ht;
MatrixXd K = PHt * Si;
//new estimate
x_ = x_ + (K * y);
long x_size = x_.size();
MatrixXd I = MatrixXd::Identity(x_size, x_size);
P_ = (I - K * H_) * P_;
}
/**
* Updates the state and the state covariance matrix using a radar measurement.
* @param {MeasurementPackage} meas_package
*/
void UKF::UpdateRadar(MeasurementPackage meas_package) {
/**
TODO:
Complete this function! Use radar data to update the belief about the object's
position. Modify the state vector, x_, and covariance, P_.
You'll also need to calculate the radar NIS.
*/
/*====================================
*=== 1. Predict Measurement ===
*===================================*/
/*
* 1.1 create matrix for sigma points in measurement space
*/
int n_z = 3; //set measurement dimension, radar can measure r, phi, and r_dot
MatrixXd Zsig = MatrixXd(n_z, 2 * n_aug_ + 1);
/*
* 1.2 transform sigma points into measurement space
*/
VectorXd x;
VectorXd z_tmp = VectorXd(3);
for (int i = 0; i < 2 * n_aug_ + 1; i++)
{
x = Xsig_pred_.col(i);
z_tmp(0) = sqrt(x(0)*x(0) + x(1)*x(1));
z_tmp(1) = atan2(x(1), x(0));
z_tmp(2) = (x(0)*cos(x(3))*x(2) + x(1)*sin(x(3))*x(2)) / z_tmp(0);
Zsig.col(i) = z_tmp;
}
/*
* 1.3. calculate mean predicted measurement
*/
VectorXd z_pred = VectorXd(n_z);
z_pred.fill(0.0);
for (int i = 0; i < 2 * n_aug_ + 1; i++)
{
z_pred += weights_(i)*Zsig.col(i);
}
/*
* 1.4 calculate innovation covariance matrix S
*/
MatrixXd S = MatrixXd(n_z, n_z);
VectorXd z_diff;
S.fill(0.0);
for (int i = 0; i < 2 * n_aug_ + 1; i++)
{
z_diff = Zsig.col(i) - z_pred;
//angle normalization
while (z_diff(1)> M_PI) z_diff(1) -= 2.*M_PI;
while (z_diff(1)<-M_PI) z_diff(1) += 2.*M_PI;
S += weights_(i)*z_diff*z_diff.transpose();
}
/*
* 1.5 add measurement noise covariance matrix
*/
MatrixXd R = MatrixXd(n_z, n_z);
R << std_radr_ * std_radr_, 0, 0,
0, std_radphi_*std_radphi_, 0,
0, 0, std_radrd_*std_radrd_;
S = S + R;
/*==============================
*=== 2. Update State ===
*==============================*/
/*
* 2.1 calculate cross correlation matrix
*/
MatrixXd Tc = MatrixXd(n_x_, n_z);
VectorXd x_diff;
Tc.fill(0.0);
for (int i = 0; i < 2 * n_aug_ + 1; i++)
{
x_diff = Xsig_pred_.col(i) - x_;
//angle normalization
while (x_diff(3)> M_PI) x_diff(3) -= 2.*M_PI;
while (x_diff(3)<-M_PI) x_diff(3) += 2.*M_PI;
z_diff = Zsig.col(i) - z_pred;
//angle normalization
while (z_diff(1)> M_PI) z_diff(1) -= 2.*M_PI;
while (z_diff(1)<-M_PI) z_diff(1) += 2.*M_PI;
Tc += weights_(i) * x_diff * z_diff.transpose();
}
/*
* 2.2 calculate Kalman gain K;
*/
MatrixXd K = Tc * S.inverse();
/*
* 2.3 update state mean and covariance matrix
*/
VectorXd z = VectorXd(3);
z(0) = meas_package.raw_measurements_(0);
z(1) = meas_package.raw_measurements_(1);
z(2) = meas_package.raw_measurements_(2);
z_diff = z - z_pred;
while (z_diff(1)> M_PI) z_diff(1) -= 2.*M_PI;
while (z_diff(1)<-M_PI) z_diff(1) += 2.*M_PI;
x_ = x_ + K * z_diff;
P_ = P_ - K * S*K.transpose();
}
| [
"jtwolak@yahoo.com"
] | jtwolak@yahoo.com |
72bb61e96126f9beffb90b0dd14fcbff5d30e6d3 | 3fa73b42bbac046eece9ce395eefd0a6d0c02779 | /HackerRank/cpp/stl/vector-sort/main.cpp | c0cb8c32aae60115f7688b34069d29d9df66c58f | [] | no_license | edwinkepler/beats-and-pieces | 6589387e881a1ac38fb908d5256bcf9e03b0e9e1 | 1649e569f51901b74f7f49e7e3288ef84b8879a8 | refs/heads/master | 2021-01-15T10:58:09.156069 | 2018-07-23T17:22:00 | 2018-07-23T17:22:00 | 99,605,068 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 419 | cpp | #include <cmath>
#include <cstdio>
#include <vector>
#include <iostream>
#include <algorithm>
using namespace std;
int main() {
int size;
vector<int> v;
cin >> size;
for(int i = 0; i < size; i++) {
int number;
cin >> number;
v.push_back(number);
}
sort(v.begin(), v.end());
for(int i = 0; i < size; i++) {
cout << v[i] << " ";
}
return 0;
}
| [
"edwinkepler@protonmail.com"
] | edwinkepler@protonmail.com |
5416d43407c85209f8215aa4933637db22abbc3e | 9ff35738af78a2a93741f33eeb639d22db461c5f | /.build/Android-Debug/include/app/Experimental.Http.Internal.DateUtil.h | 0f79fe8e211c7fcde3d8be9b61439e0216e70bac | [] | no_license | shingyho4/FuseProject-Minerals | aca37fbeb733974c1f97b1b0c954f4f660399154 | 643b15996e0fa540efca271b1d56cfd8736e7456 | refs/heads/master | 2016-09-06T11:19:06.904784 | 2015-06-15T09:28:09 | 2015-06-15T09:28:09 | 37,452,199 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 534 | h | // This file was generated based on 'C:\ProgramData\Uno\Packages\Experimental.Http\0.1.0\Internal\$.uno'.
// WARNING: Changes might be lost if you edit this file directly.
#ifndef __APP_EXPERIMENTAL_HTTP_INTERNAL_DATE_UTIL_H__
#define __APP_EXPERIMENTAL_HTTP_INTERNAL_DATE_UTIL_H__
#include <Uno/Uno.h>
namespace app {
namespace Experimental {
namespace Http {
namespace Internal {
struct DateUtil__uType : ::uClassType
{
};
DateUtil__uType* DateUtil__typeof();
int DateUtil__get_TimestampNow(::uStatic* __this);
}}}}
#endif
| [
"hyl.hsy@gmail.com"
] | hyl.hsy@gmail.com |
6cfea740f4c51474f6f11f08413e3699aa90b916 | b8d457b9ce160911e6eba460e69c72d9d31ed260 | /ArxRle/Snoop/ArxRleUiTdmIdMap.cpp | 3c536bb8e70b4beb45d0c0c0e0589ba2084ff5e5 | [] | no_license | inbei/AutoDesk-ArxRle-2018 | b91659a34a73727987513356bfcd1bff9fe09ee3 | 3c8d4a34f586467685c0f9bce7c3693233e43308 | refs/heads/master | 2023-01-19T08:27:38.231533 | 2020-11-25T00:52:13 | 2020-11-25T00:52:13 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,789 | cpp | //
//////////////////////////////////////////////////////////////////////////////
//
// Copyright 2017 Autodesk, Inc. All rights reserved.
//
// Use of this software is subject to the terms of the Autodesk license
// agreement provided at the time of installation or download, or which
// otherwise accompanies this software in either electronic or hard copy form.
//
//////////////////////////////////////////////////////////////////////////////
//
#include "StdAfx.h"
#if defined(_DEBUG) && !defined(AC_FULL_DEBUG)
#error _DEBUG should not be defined except in internal Adesk debug builds
#endif
#include "ArxRleUiTdmIdMap.h"
#include "ArxRleUiTdcIdMap.h"
#include "ArxRle.h"
#include "AcadUtils/ArxRleSelSet.h"
#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif
/****************************************************************************
**
** ArxRleUiTdmIdMap::ArxRleUiTdmIdMap
**
** **jma
**
*************************************/
ArxRleUiTdmIdMap::ArxRleUiTdmIdMap(AcDbIdMapping* idMap, CWnd* parent, const TCHAR* winTitle)
: CAcUiTabMainDialog(ArxRleUiTdmIdMap::IDD, parent, ArxRleApp::getApp()->dllInstance())
{
SetDialogName(_T("ArxRle-IdMap"));
if (winTitle != NULL)
m_winTitle = winTitle;
m_tdcIdMap = new ArxRleUiTdcIdMap(idMap);
//{{AFX_DATA_INIT(ArxRleUiTdmIdMap)
//}}AFX_DATA_INIT
}
/****************************************************************************
**
** ArxRleUiTdmIdMap::~ArxRleUiTdmIdMap
**
** **jma
**
*************************************/
ArxRleUiTdmIdMap::~ArxRleUiTdmIdMap()
{
delete m_tdcIdMap;
}
/****************************************************************************
**
** ArxRleUiTdmIdMap::DoDataExchange
**
** **jma
**
*************************************/
void
ArxRleUiTdmIdMap::DoDataExchange(CDataExchange* pDX)
{
CAcUiTabMainDialog::DoDataExchange(pDX);
//{{AFX_DATA_MAP(ArxRleUiTdmIdMap)
DDX_Control(pDX, ARXRLE_IDMAP_TAB, m_tabCtrl);
//}}AFX_DATA_MAP
}
/////////////////////////////////////////////////////////////////////////////
// ArxRleUiTdmIdMap message map
BEGIN_MESSAGE_MAP(ArxRleUiTdmIdMap, CAcUiTabMainDialog)
//{{AFX_MSG_MAP(ArxRleUiTdmIdMap)
//}}AFX_MSG_MAP
END_MESSAGE_MAP()
/////////////////////////////////////////////////////////////////////////////
// ArxRleUiTdmIdMap message handlers
/****************************************************************************
**
** ArxRleUiTdmIdMap::OnInitDialog
**
** **jma
**
*************************************/
BOOL
ArxRleUiTdmIdMap::OnInitDialog()
{
CAcUiTabMainDialog::OnInitDialog();
if (m_winTitle.IsEmpty() == FALSE)
SetWindowText(m_winTitle);
SetAcadTabPointer(&m_tabCtrl);
AddTab(0, _T("Id Mapping"), ArxRleUiTdcIdMap::IDD, m_tdcIdMap);
return TRUE;
}
| [
"fb19801101@126.com"
] | fb19801101@126.com |
227820ffb8de0967fa1d187ff9f3803907b8abcb | ec8ad01c26cdb5218ad70e8c73d139856b4753b7 | /include/raptor-lite/utils/status.h | e1e745a6d20875704a55ab644692f51297b4e4d2 | [
"Apache-2.0"
] | permissive | shadow-yuan/raptor-lite | 6458a78bdcdec7ed4eaaba0629c496e21d75e47d | b5e3c558b8ff4657ecdf298ff7ffe39ff5be7822 | refs/heads/master | 2023-03-26T21:38:57.092999 | 2021-03-23T02:32:26 | 2021-03-23T02:32:26 | 333,269,167 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,010 | h | /*
*
* Copyright (c) 2020 The Raptor Authors. All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
#ifndef __RAPTOR_LITE_UTILS_STATUS__
#define __RAPTOR_LITE_UTILS_STATUS__
#include <stdlib.h>
#include <string>
#include "raptor-lite/utils/ref_counted.h"
#include "raptor-lite/utils/slice.h"
#ifdef __cplusplus
extern "C" {
#endif
int raptor_asprintf(char **strp, const char *format, ...);
#ifdef __cplusplus
}
#endif
namespace raptor {
class Status final : public RefCounted<Status, NonPolymorphicRefCount> {
public:
Status();
Status(const std::string &msg);
Status(int err_code, const std::string &err_msg);
Status(const Status &oth);
Status &operator=(const Status &oth);
Status(Status &&other);
Status &operator=(Status &&other);
~Status() = default;
bool IsOK() const;
int ErrorCode() const;
std::string ToString() const;
void AppendMessage(const std::string &msg);
bool operator==(const Status &other) const;
bool operator!=(const Status &other) const;
private:
// 0: no error
int _error_code;
Slice _message;
friend RefCountedPtr<Status> MakeStatusFromStaticString(const char *msg);
friend RefCountedPtr<Status> MakeStatusFromPosixError(const char *api);
#ifdef _WIN32
friend RefCountedPtr<Status> MakeStatusFromWindowsError(int err, const char *api);
#endif
};
RefCountedPtr<Status> MakeStatusFromStaticString(const char *msg);
RefCountedPtr<Status> MakeStatusFromPosixError(const char *api);
#ifdef _WIN32
RefCountedPtr<Status> MakeStatusFromWindowsError(int err, const char *api);
#endif
template <typename... Args>
inline RefCountedPtr<Status> MakeStatusFromFormat(Args &&... args) {
char *message = nullptr;
raptor_asprintf(&message, std::forward<Args>(args)...);
if (!message) {
return nullptr;
}
RefCountedPtr<Status> obj = MakeRefCounted<Status>(message);
free(message);
return obj;
}
} // namespace raptor
#define RAPTOR_POSIX_ERROR(api_name) raptor::MakeStatusFromPosixError(api_name)
#define RAPTOR_ERROR_FROM_STATIC_STRING(message) raptor::MakeStatusFromStaticString(message)
#define RAPTOR_ERROR_FROM_FORMAT(FMT, ...) raptor::MakeStatusFromFormat(FMT, ##__VA_ARGS__)
#ifdef _WIN32
#define RAPTOR_WINDOWS_ERROR(err, api_name) raptor::MakeStatusFromWindowsError(err, api_name)
#endif
using raptor_error = raptor::RefCountedPtr<raptor::Status>;
#define RAPTOR_ERROR_NONE nullptr
#endif // __RAPTOR_LITE_UTILS_STATUS__
| [
"1092421495@qq.com"
] | 1092421495@qq.com |
eb4ecd85060a960bb03d9da036655e9bba307904 | 387549ab27d89668e656771a19c09637612d57ed | /DRGLib UE project/Source/FSDEngine/Private/CSGSDFInstanceComponent.cpp | 03f7c9f27d92d98ea9b85001bcb3c91bf8b130c9 | [
"MIT"
] | permissive | SamsDRGMods/DRGLib | 3b7285488ef98b7b22ab4e00fec64a4c3fb6a30a | 76f17bc76dd376f0d0aa09400ac8cb4daad34ade | refs/heads/main | 2023-07-03T10:37:47.196444 | 2023-04-07T23:18:54 | 2023-04-07T23:18:54 | 383,509,787 | 16 | 5 | MIT | 2023-04-07T23:18:55 | 2021-07-06T15:08:14 | C++ | UTF-8 | C++ | false | false | 96 | cpp | #include "CSGSDFInstanceComponent.h"
UCSGSDFInstanceComponent::UCSGSDFInstanceComponent() {
}
| [
"samamstar@gmail.com"
] | samamstar@gmail.com |
1db9dae1185e687c5d1dc4815d0036a21c2a8785 | c8d8d5335803d36549cafd55bb7c691e0bcf51fb | /2do-cuatrimestre/ejercicios/archivos-binarios/ej1/ej1/main.cpp | 2a56dab6701e962015df4b2c84d08fbc6033c907 | [] | no_license | NicoAcosta/utn-ayed | fb7b7f9a065b37b40fac543f3cc2d09ac9362917 | d38dc7e64e4e8aed837dfdd4e191f950b8b4c925 | refs/heads/main | 2023-02-19T01:03:01.808002 | 2021-01-19T22:24:08 | 2021-01-19T22:24:08 | 306,265,257 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 974 | cpp | #include <iostream>
#include <stdio.h>
#include <stdlib.h>
using namespace std;
int main() {
FILE *f;
int nVal;
float val;
f = fopen("archivo1.jaja", "wb");
if (f) {
cout << "Ingrese cantidad de valores: " << endl;
cin >> nVal;
for (int i = 0; i < nVal; i++) {
cout << endl << endl << "Ingrese valor nº " << i << ": " << endl ;
cin >> val;
fwrite(&val, sizeof(float), 1, f);
}
fclose(f);
f = fopen("archivo1.jaja", "rb");
cout << endl << endl << endl <<
"Valores ingresados: " << endl << endl;
for (int i = 0; i < nVal; i++) {
fread(&val, sizeof(float), 1, f);
cout << "Valor nº " << i << ": " << val << endl;
}
fclose(f);
} else
cout << "Error al abrir el archivo." << endl;
return 0;
}
| [
"nicacosta@est.frba.utn.edu.ar"
] | nicacosta@est.frba.utn.edu.ar |
33e556bff44b58bff3d3234e3f16c57b13dd1d7d | ba3abe659d1939b7425693f1c59c34e193987973 | /src/applicationui.cpp | 32bd356dca303ce8d0dddd5d1a63a87f299be0d0 | [] | no_license | rileyBloomfield/Pokedex | 8ad284ea0c78dcb76f6bfff986f979580327f2fe | 10f48129d59358e03d5fefc447c9ed1519d141f2 | refs/heads/master | 2016-09-06T15:33:09.293066 | 2014-09-21T17:52:30 | 2014-09-21T17:52:30 | 24,298,262 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 5,131 | cpp | #include "applicationui.h"
#include <bb/cascades/Application>
#include <bb/cascades/QmlDocument>
#include <bb/cascades/AbstractPane>
#include <bb/cascades/DropDown>
#include <bb/cascades/RadioGroup>
#include <bb/cascades/Label>
#include <bb/cascades/ListView>
#include <iostream>
#include "pokemonlist.h"
using namespace bb::cascades;
using std::cerr;
using std::endl;
const QString ENG = "9";
const QString JAP = "1";
ApplicationUI::ApplicationUI(bb::cascades::Application *app) :QObject(app), m_pokemonList(0)
{
// Create scene document from main.qml asset, the parent is set
// to ensure the document gets destroyed properly at shut down.
QmlDocument *qml = QmlDocument::create("asset:///main.qml").parent(this);
// Create root object for the UI
m_root = qml->createRootObject<AbstractPane>();
// Set the handle for the "pokedex" object from QML
qml->setContextProperty("pokedex", this);
// Create the "model" to store data about pokemon
m_pokemonList = new PokemonList(this);
qml->setContextProperty("pokemon_list", m_pokemonList);
//Create array of pokemon the size of the number of pokemon in the pokemon types
m_pokemonList->setNumberPokemon(m_pokemonList->assignPokemonNumber());
m_pokemonList->all_pokemon = new Pokemon[m_pokemonList->getNumberPokemon()];
// Populate radio buttons for language settings
RadioGroup *radio(0); // A pointer to hold the RadioGroup UI object
// Search the root QML object for a control named "pokemon_types"
radio = m_root->findChild<RadioGroup *>("pokedex_languages");
//Access setPokedexLanguages function from PokemonList class to set languages on language menu
m_pokemonList->assignPokedexLanguages();
//Populate buttons
if (radio) // did we succeed in getting a pointer to the radio button UI control?
{
for (int i(0); i<10; i++)
{
if (i==0 && m_pokemonList->getLanguage()==JAP) //if starting on japanese, make selected
radio->add(Option::create().text(m_pokemonList->m_pokedex_languages.at(i)).value(1).selected(true));
if (i==8 && m_pokemonList->getLanguage()==ENG) //if starting on english, make selected
radio->add(Option::create().text("English").value(9).selected(true));
if (i==7 && m_pokemonList->getLanguage()==JAP)
radio->add(Option::create().text("English").value(9));
else
radio->add(Option::create().text(m_pokemonList->m_pokedex_languages.at(i)).value(i+1)); // Add another option
}
}
// Set created root object as the application scene
app->setScene(m_root);
}
void ApplicationUI::typeSelected(int type) {
cerr << "In typeSelected() with " << "type=" << type << endl;
ListView *pokeList(0);
pokeList = m_root->findChild<ListView*>(); //Selects the Listview
pokeList->resetDataModel(); //unloads the data
m_pokemonList->setTypeId(type);
pokeList->setDataModel(m_pokemonList); //reloads the data
//m_pokemonList->m_list_size = m_pokemonList->m_temp_list.length();
Label *status(0); // A pointer to hold the Label UI object
// Search the root QML object for a control named "status"
status = m_root->findChild<Label *>("pokedex_status");
if (status)
{ // did we succeed in getting a pointer to the Label UI control?
// Yes. Now set the text as appropriate
status->setText( QString("Found %1 Pok").arg(m_pokemonList->childCount(QVariantList())) +QChar(0x0E9)+QString("mon") );
}
else
{
cerr << "failed to find status " << endl;
}
}
void ApplicationUI::languageSelected(int language) {
cerr << "In languageSelected() with " << "language=" << language << endl;
QString out = QString::number(language); //convert language int to a string
m_pokemonList->setLanguage(out); //assign to pokemonList language member variable
ListView *pokeList(0);
pokeList = m_root->findChild<ListView*>(); //Selects the Listview
pokeList->resetDataModel(); //unloads the data
m_pokemonList->setListInit(true); //assure complete repopulation
pokeList->setDataModel(m_pokemonList); //reloads the data
initDropdown(); //call to empty and repopulate dropdown
}
void ApplicationUI::initDropdown() {
// Populate the dropdown list of types
DropDown *dropDown(0); // pointer to hold the DropDown UI object
// Search the root QML object for a control named "pokemon_types"
dropDown = m_root->findChild<DropDown *>("pokemon_types");
//remove all elements from dropdown
dropDown->removeAll();
//call assignTypes function from PokemonList class to assign types with selected language
m_pokemonList->assignPokedexTypes();
//repopulate dropdown menu with chaged types
if (dropDown)
{
if (m_pokemonList->getLanguage()==JAP) //if language is japanese
{
QString all_types = QString::fromLocal8Bit("すべてのタイプ")+" [All Types]";
dropDown->add(Option::create().text(all_types).value(-1).selected(true)); //change all types to japanese
}
else
dropDown->add(Option::create().text("All Types").value(-1).selected(true));
for (int i(0); i<18; i++)
{
dropDown->add(Option::create().text(m_pokemonList->m_pokedex_types[i]).value(i+1));
}
}
}
| [
"riley.bloomfield@gmail.com"
] | riley.bloomfield@gmail.com |
d32158b890cdd74768e12d5a020fa14339133169 | ea91bffc446ca53e5942a571c2f7090310376c9d | /src/utils/Compression.cpp | a1b5333e8680303f4e6bc3b3bac85e42749d1712 | [] | no_license | macro-l/polarphp | f7b1dc4b609f1aae23b4618fc1176b8c26531722 | f6608c4dc26add94e61684ed0edd3d5c7e86e768 | refs/heads/master | 2022-07-21T23:37:02.237733 | 2019-08-15T10:32:06 | 2019-08-15T10:32:06 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 4,011 | cpp | // This source file is part of the polarphp.org open source project
//
// Copyright (c) 2017 - 2019 polarphp software foundation
// Copyright (c) 2017 - 2019 zzu_softboy <zzu_softboy@163.com>
// Licensed under Apache License v2.0 with Runtime Library Exception
//
// See https://polarphp.org/LICENSE.txt for license information
// See https://polarphp.org/CONTRIBUTORS.txt for the list of polarphp project authors
//
// Created by polarboy on 2018/07/03.
#include "polarphp/utils/Compression.h"
#include "polarphp/basic/adt/SmallVector.h"
#include "polarphp/basic/adt/StringRef.h"
#include "polarphp/utils/Error.h"
#include "polarphp/utils/ErrorHandling.h"
#if defined(POLAR_ENABLE_ZLIB) && defined(HAVE_ZLIB_H)
#include <zlib.h>
#endif
namespace polar {
namespace utils {
namespace zlib {
#if defined(POLAR_ENABLE_ZLIB) && defined(HAVE_LIBZ)
namespace {
Error create_error(StringRef error)
{
return make_error<StringError>(error, inconvertible_error_code());
}
StringRef convert_zlib_code_to_string(int code)
{
switch (code) {
case Z_MEM_ERROR:
return "zlib error: Z_MEM_ERROR";
case Z_BUF_ERROR:
return "zlib error: Z_BUF_ERROR";
case Z_STREAM_ERROR:
return "zlib error: Z_STREAM_ERROR";
case Z_DATA_ERROR:
return "zlib error: Z_DATA_ERROR";
case Z_OK:
default:
polar_unreachable("unknown or unexpected zlib status code");
}
}
} // anonymous namespace
bool is_available()
{
return true;
}
Error compress(StringRef inputBuffer,
SmallVectorImpl<char> &compressedBuffer,
int level)
{
unsigned long compressedSize = ::compressBound(inputBuffer.getSize());
compressedBuffer.resize(compressedSize);
int res =
::compress2((Bytef *)compressedBuffer.getData(), &compressedSize,
(const Bytef *)inputBuffer.getData(), inputBuffer.size(), level);
// Tell MemorySanitizer that zlib output buffer is fully initialized.
// This avoids a false report when running LLVM with uninstrumented ZLib.
__msan_unpoison(compressedBuffer.getData(), compressedSize);
compressedBuffer.setSize(compressedSize);
return res ? create_error(convert_zlib_code_to_string(res)) : Error::getSuccess();
}
Error uncompress(StringRef inputBuffer, char *uncompressedBuffer,
size_t &uncompressedSize)
{
int res =
::uncompress((Bytef *)uncompressedBuffer, (uLongf *)&uncompressedSize,
(const Bytef *)inputBuffer.getData(), inputBuffer.getSize());
// Tell MemorySanitizer that zlib output buffer is fully initialized.
// This avoids a false report when running LLVM with uninstrumented ZLib.
__msan_unpoison(uncompressedBuffer, uncompressedSize);
return res ? create_error(convert_zlib_code_to_string(res)) : Error::getSuccess();
}
Error uncompress(StringRef inputBuffer,
SmallVectorImpl<char> &uncompressedBuffer,
size_t uncompressedSize)
{
uncompressedBuffer.resize(uncompressedSize);
Error error =
uncompress(inputBuffer, uncompressedBuffer.getData(), uncompressedSize);
uncompressedBuffer.resize(uncompressedSize);
return error;
}
uint32_t crc32(StringRef buffer)
{
return ::crc32(0, (const Bytef *)buffer.getData(), buffer.getSize());
}
#else
bool is_available()
{
return false;
}
Error compress(StringRef inputBuffer,
SmallVectorImpl<char> &compressedBuffer,
int level)
{
polar_unreachable("zlib::compress is unavailable");
}
Error uncompress(StringRef inputBuffer, char *uncompressedBuffer,
size_t &uncompressedSize)
{
polar_unreachable("zlib::uncompress is unavailable");
}
Error uncompress(StringRef inputBuffer,
SmallVectorImpl<char> &uncompressedBuffer,
size_t uncompressedSize)
{
polar_unreachable("zlib::uncompress is unavailable");
}
uint32_t crc32(StringRef buffer)
{
polar_unreachable("zlib::crc32 is unavailable");
}
#endif
} // zlib
} // utils
} // polar
| [
"zzu_softboy@163.com"
] | zzu_softboy@163.com |
5ca440bb1f1b765d6a90d0a8743a60c14e240e60 | 5cd42fee97a2aa76f9d1ab1d1e69739efaff4257 | /2.4.1/c.h | efdc6f60432d59249bb2d841bf824e2be5a1ddd0 | [] | no_license | dgholz/dragon | f8c6dc7827639c4559f0c6be1ca1c23756cd69c3 | 2ccca119565a12f15f220cb284d98810b93add31 | refs/heads/master | 2021-01-19T06:10:57.820804 | 2014-11-04T07:27:22 | 2014-11-04T07:27:22 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 203 | h | #ifndef C_H
#define C_H
#include "icharstream.h"
struct c {
c(icharstream& ics) : _ics(ics) {};
void S();
void operator() () { S(); };
private:
c();
icharstream _ics;
};
#endif
| [
"dgholz@gmail.com"
] | dgholz@gmail.com |
1b5a61b940db274e64dfcb2524ffd992c34470c8 | 3b69a62bebfa385549dd245e85a32ca64be35288 | /src/pipe_linux.cpp | 51705bb4d4f2eeec30bd22f1f26f70e51d5e01ee | [
"BSD-2-Clause"
] | permissive | ricky26/netlib | 29c045c78da48e153ce330f19d61d323cd924e93 | f4d86475220ae32f0ab25e83fb8dc004f5f1af60 | refs/heads/master | 2016-09-06T06:52:00.990375 | 2012-10-19T20:21:43 | 2012-10-19T20:21:43 | 4,078,861 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 4,413 | cpp | #include "netlib/pipe.h"
#include "netlib/socket.h"
#include "netlib_linux.h"
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <unistd.h>
#include <iostream>
#include <cstring>
namespace netlib
{
//
// pipe_internal
//
struct pipe_internal: public ref_counted
{
int fd;
aio_struct aio;
pipe_internal(int _fd=-1)
{
fd = _fd;
}
~pipe_internal()
{
if(fd != -1)
::close(fd);
}
static inline pipe_internal *get(void *_ptr)
{
return static_cast<pipe_internal*>(_ptr);
}
};
//
// pipe
//
pipe::pipe()
{
mInternal = nullptr;
}
pipe::pipe(int _handle)
{
pipe_internal *pi = new pipe_internal(_handle);
if(_handle != -1)
pi->aio.make_nonblocking(_handle);
mInternal = pi;
}
pipe::pipe(pipe const& _p)
{
pipe_internal *pi = pipe_internal::get(_p.mInternal);
pi->acquire();
mInternal = pi;
}
pipe::pipe(pipe &&_p)
{
pipe_internal *pi = pipe_internal::get(_p.mInternal);
_p.mInternal = nullptr;
mInternal = pi;
}
pipe::~pipe()
{
if(pipe_internal *pi = pipe_internal::get(mInternal))
pi->release();
}
bool pipe::valid() const
{
return pipe_internal::get(mInternal)->fd != -1;
}
int pipe::handle() const
{
return pipe_internal::get(mInternal)->fd;
}
int pipe::release()
{
pipe_internal *pi = pipe_internal::get(mInternal);
int hdl = pi->fd;
pi->fd = -1;
return hdl;
}
bool pipe::open(std::string const& _pipe)
{
pipe_internal *pi = pipe_internal::get(mInternal);
if(pi->fd != -1)
return false;
int fd = ::socket(AF_UNIX, SOCK_STREAM, 0);
if(fd == -1)
return false;
sockaddr_un addr;
addr.sun_family = AF_UNIX;
std::strcpy(addr.sun_path, _pipe.c_str());
pi->aio.make_nonblocking(fd);
int len = sizeof(addr.sun_family) + _pipe.length();
pi->aio.begin_out();
int ret = connect(fd, (sockaddr*)&addr, len);
if(ret == -1 && errno == EAGAIN)
{
uthread::current()->suspend();
ret = connect(fd, (sockaddr*)&addr, len);
}
pi->aio.end_out();
if(ret < 0)
{
::close(fd);
return false;
}
pi->fd = fd;
return true;
}
bool pipe::create(std::string const& _pipe)
{
pipe_internal *pi = pipe_internal::get(mInternal);
if(pi->fd != -1)
return false;
int fd = ::socket(AF_UNIX, SOCK_STREAM, 0);
if(fd == -1)
return false;
sockaddr_un addr;
addr.sun_family = AF_UNIX;
std::strcpy(addr.sun_path, _pipe.c_str());
int len = sizeof(addr.sun_family) + _pipe.length();
int ret = bind(fd, (sockaddr*)&addr, len);
if(ret < 0)
{
::close(fd);
return false;
}
ret = ::listen(fd, 5);
if(ret < 0)
{
::close(fd);
return false;
}
pi->aio.make_nonblocking(fd);
pi->fd = fd;
return true;
}
pipe pipe::accept()
{
pipe_internal *pi = pipe_internal::get(mInternal);
if(pi->fd == -1)
return pipe();
sockaddr_un addr;
socklen_t len = sizeof(addr);
pi->aio.begin_in();
int ret = ::accept(pi->fd, (sockaddr*)&addr, &len);
if(ret < 0 && errno == EAGAIN)
{
uthread::current()->suspend();
ret = ::accept(pi->fd, (sockaddr*)&addr, &len);
}
pi->aio.end_in();
if(ret == -1)
{
close();
return pipe();
}
return std::move(pipe(ret));
}
void pipe::close()
{
pipe_internal *pi = pipe_internal::get(mInternal);
if(pi->fd == -1)
return;
::close(pi->fd);
pi->fd = -1;
}
size_t pipe::read(void *_buffer, size_t _amt)
{
pipe_internal *pi = pipe_internal::get(mInternal);
if(pi->fd == -1)
return 0;
pi->aio.begin_in();
int ret = ::read(pi->fd, _buffer, _amt);
if(ret < 0 && errno == EAGAIN)
{
uthread::current()->suspend();
ret = ::read(pi->fd, _buffer, _amt);
}
pi->aio.end_in();
if(ret < 0)
{
close();
return 0;
}
return ret;
}
size_t pipe::write(const void *_buffer, size_t _amt)
{
pipe_internal *pi = pipe_internal::get(mInternal);
if(pi->fd == -1)
return 0;
pi->aio.begin_out();
int ret = ::write(pi->fd, _buffer, _amt);
if(ret < 0 && errno == EAGAIN)
{
uthread::current()->suspend();
ret = ::write(pi->fd, _buffer, _amt);
}
pi->aio.end_out();
if(ret < 0)
{
close();
return 0;
}
return ret;
}
socket pipe::read()
{
return socket(); // TODO: Write this.
}
bool pipe::write(socket &_sock)
{
return false; // TODO: Write zis.
}
bool pipe::init()
{
return true;
}
void pipe::think()
{
}
void pipe::shutdown()
{
}
}
| [
"rickytaylor26@gmail.com"
] | rickytaylor26@gmail.com |
ed91dc9743fd6060b9aa112070f571b4c4f0569b | 8ec65a759d3efc75fe770cb380427c2e496c8581 | /common.hpp | f4994bafbf7791f65b16738d50b82ba8439f9e2a | [] | no_license | kamindustries/branchbits | c769343ed8a0d322cb94b27b4b5d617ac0d3a948 | 19499181cb3f36d149f03b580d56d5db55796dec | refs/heads/master | 2021-01-22T14:46:54.806290 | 2016-02-02T05:59:38 | 2016-02-02T05:59:38 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,724 | hpp | #pragma once
#include "allocore/io/al_App.hpp"
using namespace al;
using namespace std;
// #define LEAF_COUNT 2200 // number of leaves
#define LEAF_COUNT 6000 // number of leaves
#define STEPS 30 // number of iterations
#define NUM_VTX 200000 // max number of verts in tree mesh
#define MAX_LEAVES 20000
///////////////////////////////////////////////////////////////////////
// S T A T E C L A S S
///////////////////////////////////////////////////////////////////////
struct State {
double eyeSeparation, nearClip, farClip;
double t; // simulation time
int frame_num;
unsigned n; // "frame" number
float focalLength;
Pose pose; // for navigation
Color backgroundColor;
// bool timeToggle;
bool drawLeaves;
bool drawBranches;
bool drawGround;
bool toggleFog;
Vec3f leafPos[MAX_LEAVES]; //240000
Color leafColor[MAX_LEAVES]; //240000
int refreshLeaves;
int refreshTree;
// treePos is main thing being drawn in graphics.cpp
Vec3f treePos[NUM_VTX]; //600000
Color treeColor[NUM_VTX]; //600000
int pSize;
int cSize;
int currentLeafSize;
double audioGain; //8
float f[LEAF_COUNT]; //8800
void print() {
cout << "printin stuff from state!" << endl;
}
};
void InitState(State* state){
state->currentLeafSize = LEAF_COUNT;
state->n = 0;
state->frame_num = 0;
state->nearClip = 0.1;
state->farClip = 1000;
state->focalLength = 6.f;
state->eyeSeparation = 0.06;
state->backgroundColor = Color(0.1, 1);
state->audioGain = 0.0;
state->drawLeaves = true;
state->drawBranches = false;
state->drawGround = true;
state->toggleFog = true;
} | [
"younkeehong@gmail.com"
] | younkeehong@gmail.com |
32a03cc2ce0efbcbbc3cf81b0de3446d46aa2c92 | d786675f274b98fd3fbf88e90748f50967374fce | /RayTracer/Disk.cpp | b61c08a3a3a28bbbb2ee0ec754a463d9e3f05ebc | [] | no_license | sufian-latif/raytracer | e9235b8ad625c73fba87783e8c6dee9de77195b6 | 5e18c78acfc50e06eb2cdf9940fa1a9f382d718f | refs/heads/master | 2021-05-30T19:19:28.804462 | 2014-03-07T20:05:11 | 2014-03-07T20:05:11 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 358 | cpp | //
// Disk.cpp
// RayTracing
//
// Created by Sufian Latif on 1/24/14.
//
//
#include "Disk.h"
Disk::Disk(Vector c, Vector normal, double r) : Plane(c, normal)
{
radius = r;
}
double Disk::getIntersection(Ray ray)
{
double t = Plane::getIntersection(ray);
Vector p = ray.origin + t * ray.dir;
return (p - pp).mag() > radius ? -1 : t;
}
| [
"sufianlatif@Sufians-Macbook-Pro.local"
] | sufianlatif@Sufians-Macbook-Pro.local |
3438d324de2cf33a2337ce2d6bf4917116c10859 | 190e25c81214b329a131ecf4df7bf1d54c455466 | /src/serversocketutil.cc | 1d18ff98055f30d3ef2c2687c1741ccd21bac4fc | [
"MIT"
] | permissive | connectiblutz/bcLib | a5fa1c0da063f6616a76aef42445318386275003 | 2227677b165809940d51977c34e4745f64217c6a | refs/heads/main | 2022-11-26T01:44:51.695266 | 2020-07-03T15:47:48 | 2020-07-03T15:47:48 | 273,704,089 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,070 | cc | #include "bcl/serversocketutil.h"
#include "bcl/logutil.h"
#include "bcl/stringutil.h"
#ifdef _WIN32
#include "winsock2.h"
#include "ws2tcpip.h"
#else
#include <arpa/inet.h>
#include <unistd.h>
#define closesocket ::close
#endif
namespace bcl {
#ifdef _WIN32
#define inet_pton InetPtonA
ServerSocket::WSAInit::WSAInit() {
WSADATA wsaData;
WSAStartup(MAKEWORD(2, 2), &wsaData);
}
ServerSocket::WSAInit::~WSAInit() {
WSACleanup();
}
#endif
ServerSocket::ServerSocket(int type, const SocketAddress& addr) : sock(0), listening(false) {
#ifdef _WIN32
static WSAInit wsaInit;
#endif
LogUtil::Debug()<<"listening socket on "<<addr.toString();
sock = socket(addr.family(), type, 0);
if (0!=bind(sock,addr.getSockaddr(), addr.getSockaddrSize())) {
LogUtil::Debug()<<"failed to find to "<<addr.toString() << ", error "<<errno;
} else {
listening=true;
}
}
void ServerSocket::close() {
if (sock) {
closesocket(sock);
sock=0;
}
}
ServerSocket::~ServerSocket() {
close();
}
UdpServerSocket::UdpServerSocket(const SocketAddress& addr) : ServerSocket(SOCK_DGRAM, addr) {
}
UdpServerSocket::~UdpServerSocket() {
}
uint16_t UdpServerSocket::ReadPacket(SocketAddress& address, char* buffer, uint16_t maxPacketSize) {
struct sockaddr src_addr;
socklen_t src_len = sizeof src_addr;
ssize_t read = recvfrom(sock, buffer, maxPacketSize, 0, &src_addr, &src_len);
if (read == -1) {
listening=false;
return 0;
}
address = SocketAddress(&src_addr);
return read;
}
void UdpServerSocket::WritePacket(const SocketAddress& dest, char* data, uint16_t size) {
ssize_t written = sendto(sock,data,size,0,dest.getSockaddr(),dest.getSockaddrSize());
if (written!=size) {
LogUtil::Debug()<<"failed to write "<<size<<" bytes, error "<<errno;
}
}
std::shared_ptr<ServerSocket> ServerSocketUtil::Create(const std::string& protocol, const SocketAddress& addr) {
if (protocol=="udp") return std::dynamic_pointer_cast<ServerSocket>(std::make_shared<UdpServerSocket>(addr));
return std::shared_ptr<ServerSocket>();
}
}
| [
"blutz@connectify.me"
] | blutz@connectify.me |
21c5f0f1ca564d82ce26119de16608d0c659dee8 | acf95a387c72d857bfd4a34f1d3d3a3da7ad1c60 | /src/decoder/fec.h | 1b4e1f76613121fcc5a96052bf99cee004dc52a8 | [] | no_license | chemeris/wimax-scanner | dbe88d62dd2cdb4878abcd3afe10ce649784ec46 | 4511153da9b6d3293f79a4f02e9e43cd02d3d030 | refs/heads/master | 2021-01-25T00:16:08.989294 | 2012-04-13T18:34:52 | 2012-04-13T18:34:52 | 32,218,510 | 4 | 3 | null | null | null | null | WINDOWS-1252 | C++ | false | false | 7,876 | h | /****************************************************************************/
/*! \file fec.h
\brief FEC decoder
\author Iliya Voronov, iliya.voronov@gmail.com
\version 0.1
FEC decoder of convolutional code, convolutional turbo code, LDPC code etc.
implements IEEE Std 802.16-2009, 8.4.9.2 Encoding
*/
/*****************************************************************************/
/*****************************************************************************
Copyright (C) 2011 Iliya Voronov
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301
USA
*****************************************************************************/
#ifndef _FEC_H_
#define _FEC_H_
#include "comdefs.h"
#include "global.h"
#include "baseop.h"
#include "turbo.h"
class Fec {
public:
/*****************************************************************************
Static constant external variables and external types
*****************************************************************************/
/******************************************************************************
External functions
******************************************************************************/
Fec( FecType fec, //!< FEC type
FecRate rate, //!< FEC rate
ModulType modul, //!< modulation
int slotSz, //!< slot size in data bits
int numSlot ); //!< number of slots
~Fec();
//! Decode soft bits, return number of output bits or zero if not output produced
int decod( uint8 * pBit, //!< output bits, length slotSz * concatenation size
const float * pSbit ); //!< input softbits, length slotSz / FEC rate
private:
/*****************************************************************************
Static constant internal variables and internal types
*****************************************************************************/
static const int maxBlockSz = maxConcSz*symPerSlot*3; //!< max block size, including CTC 1/3
static const int ccMemLen = 7; //!< CC memory length including input bit = K
static const int ccNumStat = 0x01UL<<(ccMemLen-1); //!< CC number of state of viterbi decoder = m
static const int ccNumGen = 2; //!< CC number of generator polynomials = output bits per input bit = n
static const int ctcForbidNum = 7; //!< CTC forbidden number of slots in block
static const int ctcNumSblock = 6; //!< CTC number of subblock
//! Convolutional code internal structure
struct Cc {
int aOut0[ccNumStat]; //!< output symbols for 0 input bit, MSB is 0-th generator polinom
int aState0[ccNumStat]; //!< next state for 0 input bit, LSB is odlest bit in register
int aOut1[ccNumStat]; //!< output symbols for 1 input bit, MSB is 0-th generator polinom
int aState1[ccNumStat]; //!< next state for 1 input bit, LSB is odlest bit in register
float prev_section[ccNumStat];
float next_section[ccNumStat];
int prev_bit[ccNumStat*(maxConcSz*symPerSlot + symPerSlot/2)];
int prev_state[ccNumStat*(maxConcSz*symPerSlot + symPerSlot/2)];
float rec_array[ccNumGen];
float metric_c[1<<ccNumGen];
};
//! CTC Subblock interleaver params
struct CtcSblkIntlvParam {
int m;
int J;
};
static const CtcSblkIntlvParam aCtcSblkIntlvParamTbl[maxConcSz]; //!< CTC Subblock interleaver params table Table 505—Parameters for the subblock interleavers
//! CTC inter-component interleaver
struct CtcIntIntlvParam {
ModulType modul; //!< modulation
FecRate rate; //!< FEC rate
int numSlot; //!< number of slot
int aP[4]; //!< params
};
static const CtcIntIntlvParam aCtcIntIntlvParamTbl[]; //!< CTC inter-component interleaver Table 502—CTC channel coding per modulation
//! Convolutional turbo code internal structure
struct Ctc {
int aaSblockIntlv[maxConcSz][maxBlockSz/ctcNumSblock]; //!< subblock interleaver table 8.4.9.2.3.4.2 Subblock interleaving
const CtcIntIntlvParam * pIntIntlvParam; //!< pointer to first CTC inter-component interleaver params of specified rate and modulation
Turbo * pTurbo; //!< CTC decoder
};
static const int aCcGenPol[]; //!< Convolutional code generator polynomials
static const int aaCcConcSz[MODUL_NUM][FEC_RATE_NUM]; //!< CC slot concatination size, Table 493—Encoding slot concatenation for different allocations and modulations
static const int aaCtcConcSz[MODUL_NUM][FEC_RATE_NUM]; //!< CTC slot concatination size, Table 501—Encoding slot concatenation for different rates in CTC
/*****************************************************************************
Internal variables
*****************************************************************************/
FecType fec; //!< FEC type
FecRate rate; //!< FEC rate
ModulType modul; //!< modulation
int slotSz; //!< slot size in data bits
int sbitSz; //!< slot size in softbits
int slotCntr; //!< slot counter in block
int blockCntr; //!< block counter in burst
// concatenation params
bool isEqBlock; //!< all block equal length, otherwise 2 last block is different length
int numBlock; //!< number of blocks in burst
int normNumSlot; //!< normal number of slots in block, equal blocks or not 2 last blocks of nonequal blocks
int beflNumSlot; //!< block before last number of slots in block
int lastNumSlot; //!< last block number of slots in block
float aSbit[maxBlockSz]; //!< block of concatenated slots buffer
Cc cc; //!< convolutional code internal data
Ctc ctc; //!< convolutional turbo code internal data
/******************************************************************************
Internal functions
******************************************************************************/
//! Init concatenation params
void initConcat( int numSlot ); //!< number of slots in burst
//! Init convolutional code
void initCc( int numGen, //!< number of generator polynomials = output bits per input bit
const int * pGenPol ); //!< generator polynomials
//! Decode convolutional code, return number of output bits of zero if not output produced
void decCc( uint8 * pBit, //!< output bits
const float * pSbit, //!< input softbits
int numSlot ); //!< number of slot in current concatenation block
//! Delete convolutional code
void deleteCtc();
//! Init convolutional turbo code
void initCtc();
//! Init post CTC interleaver
void initCtcIntlv();
//! Decode convolutional turbo code, return number of output bits of zero if not output produced
void decCtc( uint8 * pBit, //!< output bits
const float * pSbit, //!< input softbits
int numSlot ); //!< number of slot in current concatenation block
//! Deinterleave convolutional turbo code, return softbits in A B Y1 W1 Y2 W2 sequence
void intlvCtc( float * pSbit, //!< input/output softbits
int numSlot ); //!< number of slot in current concatenation block
//! Delete convolutional turbo code
void deleteCc();
};
#endif //#ifndef _FEC_H_
| [
"iliya.voronov@gmail.com"
] | iliya.voronov@gmail.com |
a17995455d7c644d5553fabc2ccc1843aab2f074 | 397f89a526c77c5e565e428076ec3c268e8e815d | /bildmischer/src/testApp.h | 9272fb76bfc8c954ff702fde0df690d152e783d3 | [] | no_license | fiezi/hfsTools | 1b05ccee8cd3c8c9eb676ad196f0c66a4bbe9560 | 497797a66566c53161f63101e82d160f2a77896b | refs/heads/master | 2021-01-23T03:53:31.845493 | 2014-05-11T01:42:21 | 2014-05-11T01:42:21 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,459 | h | #ifndef _TEST_APP
#define _TEST_APP
#include "ofxOpenCv.h"
#include "ofMain.h"
#include "msbOFCore.h"
#include "actor.h"
#include "basicButton.h"
#include "textInputButton.h"
#include "assignButton.h"
#include "sliderButton.h"
#define SCREENRESX 1366+1280
#define SCREENRESY 768
struct actorID;
struct memberID;
class testApp : public ofBaseApp, public Actor{
public:
testApp();
virtual ~testApp();
void setup();
void update();
void draw();
void keyPressed(int key);
void keyReleased(int key);
void mouseMoved(int x, int y );
void mouseDragged(int x, int y, int button);
void mousePressed(int x, int y, int button);
void mouseReleased(int x, int y, int button);
void windowResized(int w, int h);
//from msbOFCore
void msbSetup();
void interfaceSetup();
void registerProperties();
void trigger(Actor* other);
void loadSettings();
void drawText();
string linebreak(string text);
ofVideoGrabber vidGrabberOne;
ofVideoGrabber vidGrabberTwo;
ofVideoGrabber vidGrabberThree;
ofVideoPlayer apolloMovie;
unsigned char * videoInverted;
ofTexture videoTextureOne;
ofTexture videoTextureTwo;
ofTexture videoTextureThree;
int camWidth;
int camHeight;
int selectedCam;
int projectorPos;
BasicButton* myBut;
ofTrueTypeFont myFont;
string theText;
};
#endif
| [
"friedrich@moviesandbox.net"
] | friedrich@moviesandbox.net |
5ac4765777c778525e8754681c0bc9efb57fc931 | 5a2349399fa9d57c6e8cc6e0f7226d683391a362 | /src/qt/qtwebkit/Source/WebCore/svg/SVGEllipseElement.h | a3c8e435a6ba60b7415c317bfc73c81d368ceefb | [
"BSD-2-Clause",
"LGPL-2.1-only",
"LGPL-2.0-only",
"BSD-3-Clause"
] | permissive | aharthcock/phantomjs | e70f3c379dcada720ec8abde3f7c09a24808154c | 7d7f2c862347fbc7215c849e790290b2e07bab7c | refs/heads/master | 2023-03-18T04:58:32.428562 | 2023-03-14T05:52:52 | 2023-03-14T05:52:52 | 24,828,890 | 0 | 0 | BSD-3-Clause | 2023-03-14T05:52:53 | 2014-10-05T23:38:56 | C++ | UTF-8 | C++ | false | false | 2,300 | h | /*
* Copyright (C) 2004, 2005, 2006, 2008 Nikolas Zimmermann <zimmermann@kde.org>
* Copyright (C) 2004, 2005, 2006 Rob Buis <buis@kde.org>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public License
* along with this library; see the file COPYING.LIB. If not, write to
* the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
* Boston, MA 02110-1301, USA.
*/
#ifndef SVGEllipseElement_h
#define SVGEllipseElement_h
#if ENABLE(SVG)
#include "SVGAnimatedBoolean.h"
#include "SVGAnimatedLength.h"
#include "SVGExternalResourcesRequired.h"
#include "SVGGraphicsElement.h"
namespace WebCore {
class SVGEllipseElement FINAL : public SVGGraphicsElement,
public SVGExternalResourcesRequired {
public:
static PassRefPtr<SVGEllipseElement> create(const QualifiedName&, Document*);
private:
SVGEllipseElement(const QualifiedName&, Document*);
virtual bool isValid() const { return SVGTests::isValid(); }
virtual bool supportsFocus() const OVERRIDE { return true; }
bool isSupportedAttribute(const QualifiedName&);
virtual void parseAttribute(const QualifiedName&, const AtomicString&) OVERRIDE;
virtual void svgAttributeChanged(const QualifiedName&);
virtual bool selfHasRelativeLengths() const;
virtual RenderObject* createRenderer(RenderArena*, RenderStyle*) OVERRIDE;
BEGIN_DECLARE_ANIMATED_PROPERTIES(SVGEllipseElement)
DECLARE_ANIMATED_LENGTH(Cx, cx)
DECLARE_ANIMATED_LENGTH(Cy, cy)
DECLARE_ANIMATED_LENGTH(Rx, rx)
DECLARE_ANIMATED_LENGTH(Ry, ry)
DECLARE_ANIMATED_BOOLEAN(ExternalResourcesRequired, externalResourcesRequired)
END_DECLARE_ANIMATED_PROPERTIES
};
} // namespace WebCore
#endif // ENABLE(SVG)
#endif
| [
"ariya.hidayat@gmail.com"
] | ariya.hidayat@gmail.com |
e2c02fe03755ac463b5257b979b3702d7336ae24 | d14ffa7a58ac5f6661ba8dc9503ed7340aad017f | /jetpack/src/codegen/NodeTraverser.h | ebfd48c2b52dc6d9ecf1c8afd5a1ec4b00385dd8 | [
"MIT"
] | permissive | prpr2012/jetpack.js | 59e4dd510f743d3a100b27b4ad0b514bd63217d4 | 3ec5fdf9e423539ec57217753735423e5ac23666 | refs/heads/master | 2023-09-02T17:56:40.316795 | 2021-11-23T02:46:24 | 2021-11-23T02:48:06 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 8,333 | h | /* Generated by Ruby Script! */
#pragma once
#include "parser/SyntaxNodes.h"
namespace jetpack {
class NodeTraverser {
public:
NodeTraverser() = default;
void TraverseNode(SyntaxNode& node);
virtual void Traverse(ArrayExpression& node) {}
virtual void Traverse(ArrayPattern& node) {}
virtual void Traverse(ArrowFunctionExpression& node) {}
virtual void Traverse(AssignmentExpression& node) {}
virtual void Traverse(AssignmentPattern& node) {}
virtual void Traverse(AwaitExpression& node) {}
virtual void Traverse(BinaryExpression& node) {}
virtual void Traverse(BlockStatement& node) {}
virtual void Traverse(BreakStatement& node) {}
virtual void Traverse(CallExpression& node) {}
virtual void Traverse(CatchClause& node) {}
virtual void Traverse(ClassBody& node) {}
virtual void Traverse(ClassDeclaration& node) {}
virtual void Traverse(ClassExpression& node) {}
virtual void Traverse(ConditionalExpression& node) {}
virtual void Traverse(ContinueStatement& node) {}
virtual void Traverse(DebuggerStatement& node) {}
virtual void Traverse(Directive& node) {}
virtual void Traverse(DoWhileStatement& node) {}
virtual void Traverse(EmptyStatement& node) {}
virtual void Traverse(ExportAllDeclaration& node) {}
virtual void Traverse(ExportDefaultDeclaration& node) {}
virtual void Traverse(ExportNamedDeclaration& node) {}
virtual void Traverse(ExportSpecifier& node) {}
virtual void Traverse(ExpressionStatement& node) {}
virtual void Traverse(ForInStatement& node) {}
virtual void Traverse(ForOfStatement& node) {}
virtual void Traverse(ForStatement& node) {}
virtual void Traverse(FunctionDeclaration& node) {}
virtual void Traverse(FunctionExpression& node) {}
virtual void Traverse(Identifier& node) {}
virtual void Traverse(IfStatement& node) {}
virtual void Traverse(Import& node) {}
virtual void Traverse(ImportDeclaration& node) {}
virtual void Traverse(ImportDefaultSpecifier& node) {}
virtual void Traverse(ImportNamespaceSpecifier& node) {}
virtual void Traverse(ImportSpecifier& node) {}
virtual void Traverse(LabeledStatement& node) {}
virtual void Traverse(Literal& node) {}
virtual void Traverse(MetaProperty& node) {}
virtual void Traverse(MethodDefinition& node) {}
virtual void Traverse(Module& node) {}
virtual void Traverse(NewExpression& node) {}
virtual void Traverse(ObjectExpression& node) {}
virtual void Traverse(ObjectPattern& node) {}
virtual void Traverse(Property& node) {}
virtual void Traverse(RegexLiteral& node) {}
virtual void Traverse(RestElement& node) {}
virtual void Traverse(ReturnStatement& node) {}
virtual void Traverse(Script& node) {}
virtual void Traverse(SequenceExpression& node) {}
virtual void Traverse(SpreadElement& node) {}
virtual void Traverse(MemberExpression& node) {}
virtual void Traverse(Super& node) {}
virtual void Traverse(SwitchCase& node) {}
virtual void Traverse(SwitchStatement& node) {}
virtual void Traverse(TaggedTemplateExpression& node) {}
virtual void Traverse(TemplateElement& node) {}
virtual void Traverse(TemplateLiteral& node) {}
virtual void Traverse(ThisExpression& node) {}
virtual void Traverse(ThrowStatement& node) {}
virtual void Traverse(TryStatement& node) {}
virtual void Traverse(UnaryExpression& node) {}
virtual void Traverse(UpdateExpression& node) {}
virtual void Traverse(VariableDeclaration& node) {}
virtual void Traverse(VariableDeclarator& node) {}
virtual void Traverse(WhileStatement& node) {}
virtual void Traverse(WithStatement& node) {}
virtual void Traverse(YieldExpression& node) {}
virtual void Traverse(ArrowParameterPlaceHolder& node) {}
virtual void Traverse(JSXClosingElement& node) {}
virtual void Traverse(JSXElement& node) {}
virtual void Traverse(JSXEmptyExpression& node) {}
virtual void Traverse(JSXExpressionContainer& node) {}
virtual void Traverse(JSXIdentifier& node) {}
virtual void Traverse(JSXMemberExpression& node) {}
virtual void Traverse(JSXAttribute& node) {}
virtual void Traverse(JSXNamespacedName& node) {}
virtual void Traverse(JSXOpeningElement& node) {}
virtual void Traverse(JSXSpreadAttribute& node) {}
virtual void Traverse(JSXText& node) {}
virtual void Traverse(TSParameterProperty& node) {}
virtual void Traverse(TSDeclareFunction& node) {}
virtual void Traverse(TSDeclareMethod& node) {}
virtual void Traverse(TSQualifiedName& node) {}
virtual void Traverse(TSCallSignatureDeclaration& node) {}
virtual void Traverse(TSConstructSignatureDeclaration& node) {}
virtual void Traverse(TSPropertySignature& node) {}
virtual void Traverse(TSMethodSignature& node) {}
virtual void Traverse(TSIndexSignature& node) {}
virtual void Traverse(TSAnyKeyword& node) {}
virtual void Traverse(TSBooleanKeyword& node) {}
virtual void Traverse(TSBigIntKeyword& node) {}
virtual void Traverse(TSNeverKeyword& node) {}
virtual void Traverse(TSNullKeyword& node) {}
virtual void Traverse(TSNumberKeyword& node) {}
virtual void Traverse(TSObjectKeyword& node) {}
virtual void Traverse(TSStringKeyword& node) {}
virtual void Traverse(TSSymbolKeyword& node) {}
virtual void Traverse(TSUndefinedKeyword& node) {}
virtual void Traverse(TSUnknownKeyword& node) {}
virtual void Traverse(TSVoidKeyword& node) {}
virtual void Traverse(TSThisType& node) {}
virtual void Traverse(TSFunctionType& node) {}
virtual void Traverse(TSConstructorType& node) {}
virtual void Traverse(TSTypeReference& node) {}
virtual void Traverse(TSTypePredicate& node) {}
virtual void Traverse(TSTypeQuery& node) {}
virtual void Traverse(TSTypeLiteral& node) {}
virtual void Traverse(TSArrayType& node) {}
virtual void Traverse(TSTupleType& node) {}
virtual void Traverse(TSOptionalType& node) {}
virtual void Traverse(TSRestType& node) {}
virtual void Traverse(TSUnionType& node) {}
virtual void Traverse(TSIntersectionType& node) {}
virtual void Traverse(TSConditionalType& node) {}
virtual void Traverse(TSInferType& node) {}
virtual void Traverse(TSParenthesizedType& node) {}
virtual void Traverse(TSTypeOperator& node) {}
virtual void Traverse(TSIndexedAccessType& node) {}
virtual void Traverse(TSMappedType& node) {}
virtual void Traverse(TSLiteralType& node) {}
virtual void Traverse(TSExpressionWithTypeArguments& node) {}
virtual void Traverse(TSInterfaceDeclaration& node) {}
virtual void Traverse(TSInterfaceBody& node) {}
virtual void Traverse(TSTypeAliasDeclaration& node) {}
virtual void Traverse(TSAsExpression& node) {}
virtual void Traverse(TSTypeAssertion& node) {}
virtual void Traverse(TSEnumDeclaration& node) {}
virtual void Traverse(TSEnumMember& node) {}
virtual void Traverse(TSModuleDeclaration& node) {}
virtual void Traverse(TSModuleBlock& node) {}
virtual void Traverse(TSImportType& node) {}
virtual void Traverse(TSImportEqualsDeclaration& node) {}
virtual void Traverse(TSExternalModuleReference& node) {}
virtual void Traverse(TSNonNullExpression& node) {}
virtual void Traverse(TSExportAssignment& node) {}
virtual void Traverse(TSNamespaceExportDeclaration& node) {}
virtual void Traverse(TSTypeAnnotation& node) {}
virtual void Traverse(TSTypeParameterInstantiation& node) {}
virtual void Traverse(TSTypeParameterDeclaration& node) {}
virtual void Traverse(TSTypeParameter& node) {}
virtual ~NodeTraverser() = default;
};
}
| [
"okcdz@diverse.space"
] | okcdz@diverse.space |
3553222a4ae49a1232cc82c9881d5029f22f9f51 | 0d9f235cf7f4829214d9379711381e5de2db216f | /src/map.h | 41ad06311cb095f4e7d829f3dfe944bbba2c74ad | [] | no_license | bentglasstube/ld35 | c27d179c87a9ba792ec3f3ac8042af0e94e4132b | a41648a46ec631feca5a2af824e505c1f6488ba7 | refs/heads/master | 2016-09-14T04:30:38.758580 | 2016-05-03T14:23:36 | 2016-05-03T14:23:36 | 56,364,447 | 0 | 1 | null | 2016-04-24T15:51:59 | 2016-04-16T03:53:32 | C++ | UTF-8 | C++ | false | false | 1,227 | h | #pragma once
#include <memory>
#include <vector>
#include "graphics.h"
#include "rect.h"
#include "sign.h"
#include "spritemap.h"
#include "text.h"
class Map {
public:
struct Tile {
char c;
bool obstruction;
float friction;
float top, left, right, bottom;
};
Map();
void load(std::string file);
void draw(Graphics& graphics, int x_offset, int y_offset);
void update(Rect player);
void push_tile(Map::Tile tile, float dx);
Tile tile_at(float x, float y);
Tile collision(Rect box, float dx, float dy);
int pixel_width() { return width * 16; }
int pixel_height() { return height * 16; }
int player_x() { return start_x * 16 - 8; }
int player_y() { return start_y * 16 + 16; }
std::string current_level() { return name; }
std::string next_level() { return next; }
std::string background() { return bg; }
private:
typedef std::vector<std::shared_ptr<Sign>> SignSet;
SpriteMap tileset;
Text text;
int height, width;
int start_x, start_y;
char tiles[128][1024];
std::string name, next, bg;
Tile tile(int x, int y);
Tile check_tile_range(int x1, int x2, int y1, int y2);
SignSet signs;
};
| [
"alan@eatabrick.org"
] | alan@eatabrick.org |
48fef59eafa0f95c149b4f60025dc9b6301f898c | dc0208a9963e2bb76517b92b1f35029f07c249e0 | /Model code/bfs_nhp.cpp | f2466be315f1c0db5b45be1cce228ae77bbbc971 | [] | no_license | basvanopheusden/fourinarow | fc39ff1e921a63c0a109519f9b26161e179578bc | d276900ccee7890e9195db592b7fef7c1d39ae54 | refs/heads/master | 2023-01-11T13:30:52.542395 | 2023-01-02T16:13:15 | 2023-01-02T16:13:15 | 242,221,537 | 4 | 4 | null | null | null | null | UTF-8 | C++ | false | false | 1,398 | cpp | #include "bfs_nhp.h"
#define BLACK_WINS 4*BOARD_WIDTH
#define WHITE_WINS -4*BOARD_WIDTH
#define DRAW 0
using namespace bfs;
nhp_node::nhp_node(board bstart,double v,bool p,int d){
b=bstart;
depth=d;
player=p;
child=NULL;
parent=NULL;
best=NULL;
Nchildren=0;
iteration=-1;
m=0;
if(b.black_has_won())
pess=opt=BLACK_WINS-depth,val=10000.0;
else if(b.is_full())
pess=opt=0,val=0.0;
else val=v,pess=0,opt=BLACK_WINS-depth-1;
}
void nhp_node::get_opt(){
opt=(player==BLACK?0:BLACK_WINS);
for(unsigned int i=0;i<Nchildren;i++)
update_opt(child[i]);
}
void nhp_node::get_pess(){
pess=(player==BLACK?0:BLACK_WINS);
for(unsigned int i=0;i<Nchildren;i++)
update_pess(child[i]);
}
void nhp_node::expand(vector<zet> candidate,int n){
Nchildren=candidate.size();
if(Nchildren>0){
iteration = n;
child=new node*[Nchildren];
for(unsigned int i=0;i<Nchildren;i++){
if(player==BLACK)
child[i]=new nhp_node(b+candidate[i],val+candidate[i].val,!player,depth+1);
else child[i]=new nhp_node(b+candidate[i],val-candidate[i].val,!player,depth+1);
child[i]->parent=this;
child[i]->m=candidate[i].zet_id;
}
get_opt();
get_pess();
get_val();
if(determined())
get_best_determined();
if(parent)
parent->backpropagate(this);
}
}
| [
"svo@PSY-19BY1941A6.pu.win.princeton.edu"
] | svo@PSY-19BY1941A6.pu.win.princeton.edu |
d9e9e827a4164e2d5ac805a228fbb34717f417f7 | ab10d257aa2bbdbced58fded27cb0acb694376e5 | /Personal projects/p009.cpp | 5dc6927248961cf32e1ca5bb9fa5b88c5fa5fdb5 | [] | no_license | DuniPls/DanielCastello | 1d8d9d96f5bb7c1c926b43d8e29e08935a463d1b | 8dec02041b9e545a22568773f48eea681504e1d9 | refs/heads/master | 2021-01-24T13:19:11.723621 | 2019-09-12T17:07:51 | 2019-09-12T17:07:51 | 123,167,008 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,371 | cpp | /******************************************************************************
Online C++ Compiler.
Code, Compile, Run and Debug C++ program online.
Write your code in this editor and press "Run" button to compile and execute it.
*******************************************************************************/
/*
A Pythagorean triplet is a set of three natural numbers, a < b < c, for which,
a2 + b2 = c2
For example, 32 + 42 = 9 + 16 = 25 = 52.
There exists exactly one Pythagorean triplet for which a + b + c = 1000.
Find the product abc.
*/
#include <iostream>
#include <math.h>
void evenTest(){
int a;
int b;
int c;
int j = 0;
int k = 0;
for (int i = 2; i < 50; i=i+2) {
j += (i - 1);
k = j + 2;
if(i + j + k == 1000){std::cout<<(i*j*k)<<'\n';}
}
}
void oddTest(){
int a;
int b;
int c;
int j = 0;
int k = 0;
for (int i = 1; i < 50; i=i+2) {
j += (i + 1);
k = j + 1;
if(i + j + k == 1000){std::cout<<(i*j*k)<<'\n';}
}
}
void fullTest() {
int a, b, c;
for (int i = 1; i < 500; i++) {
for (int j = i + 1; j < 500; j++) {
int k = (1000 - i - j);
if (i*i + j*j == k*k) {std::cout<<i<<" "<<j<<" "<<k<<": "<<(i*j*k)<<'\n';}
}
}
}
int main()
{
//evenTest();
//oddTest();
fullTest();
std::cout << "No results." << '\n';
return 0;
}
| [
"dcastello@enti.cat"
] | dcastello@enti.cat |
f64cdb2666d36bc5c66c0b49618c49907c1d6d49 | f32b14aeac2969ac99ea65703d5b98ebd0a4684f | /mihttp/timewrap.h | caa17e7743fd04683f14f7ac36e3d06ccd63674d | [] | no_license | Justxu/micode | 64dfe6c3b5313c1406c3f766643805b784f2010f | 4dd761c231ff37a8020ca32195749f036eb5e53b | refs/heads/master | 2020-04-01T08:09:12.690137 | 2014-12-30T08:57:49 | 2014-12-30T08:57:49 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 773 | h | #pragma once
#include <sys/types.h>
#include <time.h>
#include <sys/time.h>
#include "safe_time.h"
class timee
{
// _msecs:
timeval _tv;
public:
timee() { _tv.tv_sec = 0; _tv.tv_usec = 0; }
timee &operator=(const timee &rhs) { _tv = rhs._tv; }
long long operator -(const timee &rhs)
{
return (_tv.tv_sec - rhs._tv.tv_sec) * 1000000 + _tv.tv_usec - rhs._tv.tv_usec;
}
static timee now()
{
timee t;
safe_gettimeofday(&(t._tv), 0);
return t;
}
};
class time_impl
{
int64_t rdc;
public:
long long operator -(const time_impl &rhs) {};
private:
static int get_rdtsc()
{
asm("rdtsc");
}
static int64_t rdtsc(void)
{
int i, j;
asm volatile ("rdtsc" : "=a"(i), "=d"(j) : );
return ((unsigned int64_t)j<<32) + (int64_t)i;
}
};
class date
{
};
| [
"wanfei@localhost.localdomain"
] | wanfei@localhost.localdomain |
ac55be0fcd43d049f628e05dbf448e2dbc7c6a05 | 41b4adb10cc86338d85db6636900168f55e7ff18 | /aws-cpp-sdk-config/source/model/Evaluation.cpp | 03a1e8c10dd92acb93f47448051508fb37a77b9d | [
"JSON",
"MIT",
"Apache-2.0"
] | permissive | totalkyos/AWS | 1c9ac30206ef6cf8ca38d2c3d1496fa9c15e5e80 | 7cb444814e938f3df59530ea4ebe8e19b9418793 | refs/heads/master | 2021-01-20T20:42:09.978428 | 2016-07-16T00:03:49 | 2016-07-16T00:03:49 | 63,465,708 | 1 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 3,073 | cpp | /*
* Copyright 2010-2016 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
#include <aws/config/model/Evaluation.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <utility>
using namespace Aws::Utils::Json;
using namespace Aws::Utils;
namespace Aws
{
namespace ConfigService
{
namespace Model
{
Evaluation::Evaluation() :
m_complianceResourceTypeHasBeenSet(false),
m_complianceResourceIdHasBeenSet(false),
m_complianceTypeHasBeenSet(false),
m_annotationHasBeenSet(false),
m_orderingTimestampHasBeenSet(false)
{
}
Evaluation::Evaluation(const JsonValue& jsonValue) :
m_complianceResourceTypeHasBeenSet(false),
m_complianceResourceIdHasBeenSet(false),
m_complianceTypeHasBeenSet(false),
m_annotationHasBeenSet(false),
m_orderingTimestampHasBeenSet(false)
{
*this = jsonValue;
}
Evaluation& Evaluation::operator =(const JsonValue& jsonValue)
{
if(jsonValue.ValueExists("ComplianceResourceType"))
{
m_complianceResourceType = jsonValue.GetString("ComplianceResourceType");
m_complianceResourceTypeHasBeenSet = true;
}
if(jsonValue.ValueExists("ComplianceResourceId"))
{
m_complianceResourceId = jsonValue.GetString("ComplianceResourceId");
m_complianceResourceIdHasBeenSet = true;
}
if(jsonValue.ValueExists("ComplianceType"))
{
m_complianceType = ComplianceTypeMapper::GetComplianceTypeForName(jsonValue.GetString("ComplianceType"));
m_complianceTypeHasBeenSet = true;
}
if(jsonValue.ValueExists("Annotation"))
{
m_annotation = jsonValue.GetString("Annotation");
m_annotationHasBeenSet = true;
}
if(jsonValue.ValueExists("OrderingTimestamp"))
{
m_orderingTimestamp = jsonValue.GetDouble("OrderingTimestamp");
m_orderingTimestampHasBeenSet = true;
}
return *this;
}
JsonValue Evaluation::Jsonize() const
{
JsonValue payload;
if(m_complianceResourceTypeHasBeenSet)
{
payload.WithString("ComplianceResourceType", m_complianceResourceType);
}
if(m_complianceResourceIdHasBeenSet)
{
payload.WithString("ComplianceResourceId", m_complianceResourceId);
}
if(m_complianceTypeHasBeenSet)
{
payload.WithString("ComplianceType", ComplianceTypeMapper::GetNameForComplianceType(m_complianceType));
}
if(m_annotationHasBeenSet)
{
payload.WithString("Annotation", m_annotation);
}
if(m_orderingTimestampHasBeenSet)
{
payload.WithDouble("OrderingTimestamp", m_orderingTimestamp.SecondsWithMSPrecision());
}
return payload;
}
} // namespace Model
} // namespace ConfigService
} // namespace Aws | [
"henso@amazon.com"
] | henso@amazon.com |
1d9bfb169e1d7a53fb8dee47b5933e5c6deed3f3 | 70668b85b4946bb23e918db1b4a68a54910d9b36 | /codingblocks/Divid and Conquer/EKO.cpp | 556080f13aeb7f149f89ff32fee31e475a9886d4 | [] | no_license | Ishaan29/fuzzy-chainsaw-algo | 397e9feddca2a25902081a9d9316923c151779f1 | b4fa1f69721f5fe53745303879f9c8ff2c1a8e79 | refs/heads/master | 2021-06-25T00:26:34.720087 | 2021-02-28T08:24:52 | 2021-02-28T08:24:52 | 201,107,127 | 3 | 0 | null | 2021-02-28T08:24:52 | 2019-08-07T18:34:25 | C++ | UTF-8 | C++ | false | false | 1,188 | cpp | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define lli long long int
void c_p_c()
{
ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
#ifndef ONLINE_JUDGE
freopen("/Users/ishan/Desktop/fuzzy-chainsaw-algo/input.txt", "r", stdin);
freopen("/Users/ishan/Desktop/fuzzy-chainsaw-algo/output.txt", "w", stdout);
#endif
}
bool isPossible(vector<lli> &arr, lli n, lli k, lli mid){
lli cnt = 0;
for(int i = 0; i < n; i++){
if(arr[i] >= mid) {
cnt += abs(mid-arr[i]);
}
}
if(cnt < k){
return false;
}else {
return true;
}
}
int main(){
c_p_c();
ll int n; cin>>n;
ll int k; cin>>k;
vector<ll int> arr;
ll int m = INT_MIN;
for(int i = 0; i < n; i++){
ll int t; cin>>t;
arr.push_back(t);
if(t >= m){
m = t;
}
}
ll int s = 0; ll int e = m;
ll int ans = 0;
while(s <= e){
ll int mid = s+(e-s)/2;
bool p = isPossible(arr,n,k,mid);
if(p){
ans = mid;
s = mid + 1;
}else{
e = mid - 1;
}
}
cout<<ans<<endl;
return 0;
}
| [
"bajpaiishan@yahoo.in"
] | bajpaiishan@yahoo.in |
b7273eb3f0b33b01339f584e15ad96a9e602b51f | e20907553af94eb08b4422ac876c5862c214954c | /2 knapsack/cpp/solvers/greedy.hpp | 3a3e4519ca30dc995f58ccf3419a8bf2afcd1a2c | [] | no_license | pooyad359/discrete-optim | 74756e9fe923698716e95f4e4c4cbb12e8a38e30 | cf848fde53951c651c12882ece3d1bb8146403bf | refs/heads/master | 2023-07-08T18:01:16.668841 | 2021-08-15T09:27:37 | 2021-08-15T09:27:37 | 297,077,541 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 344 | hpp | #ifndef _GREEDY
#define _GREEDY
#include <vector>
#include <algorithm>
#include <iterator>
#include <string>
#include <sstream>
#include <iostream>
#include "../utils/utils.hpp"
#include <stdlib.h>
#include <random>
#include <ctime>
#include "../knapsack.hpp"
using std::cout;
using std::endl;
std::vector<bool> greedySolver(Knapsack);
#endif | [
"pooya.darvehei@gmail.com"
] | pooya.darvehei@gmail.com |
a5c435919ca25cb1126785b5139d98899c9a9887 | 3ad968797a01a4e4b9a87e2200eeb3fb47bf269a | /Advanced MFC Programming/Chap3/3.4/Spw/MainFrm.h | f418c5e7270ad63d67b2a36979303556fe9e97bb | [] | no_license | LittleDrogon/MFC-Examples | 403641a1ae9b90e67fe242da3af6d9285698f10b | 1d8b5d19033409cd89da3aba3ec1695802c89a7a | refs/heads/main | 2023-03-20T22:53:02.590825 | 2020-12-31T09:56:37 | 2020-12-31T09:56:37 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 960 | h | #if !defined(AFX_MAINFRM_H__D3F202D6_FC3A_11D0_9C9A_444553540000__INCLUDED_)
#define AFX_MAINFRM_H__D3F202D6_FC3A_11D0_9C9A_444553540000__INCLUDED_
#if _MSC_VER >= 1000
#pragma once
#endif
#include "SpWnd.h"
class CMainFrame : public CFrameWnd
{
protected:
CMainFrame();
DECLARE_DYNCREATE(CMainFrame)
protected:
MCSplitterWnd m_wndSp;
public:
//{{AFX_VIRTUAL(CMainFrame)
public:
virtual BOOL OnCreateClient(LPCREATESTRUCT lpcs, CCreateContext* pContext);
virtual BOOL PreCreateWindow(CREATESTRUCT& cs);
//}}AFX_VIRTUAL
public:
virtual ~CMainFrame();
#ifdef _DEBUG
virtual void AssertValid() const;
virtual void Dump(CDumpContext& dc) const;
#endif
protected:
CStatusBar m_wndStatusBar;
CToolBar m_wndToolBar;
//{{AFX_MSG(CMainFrame)
afx_msg int OnCreate(LPCREATESTRUCT lpCreateStruct);
//}}AFX_MSG
DECLARE_MESSAGE_MAP()
};
//{{AFX_INSERT_LOCATION}}
#endif // !defined(AFX_MAINFRM_H__D3F202D6_FC3A_11D0_9C9A_444553540000__INCLUDED_)
| [
"pkedpekr@gmail.com"
] | pkedpekr@gmail.com |
705c8c74b2ed612dfc5b282dfdd813ef54b1094a | aac6dfe8cb2e289b85aa2bbed56a47b29da59738 | /src/SporadicServer.cpp | ca8ef2512504e0432fda4c1c5fe43342369295e3 | [
"BSD-4-Clause-UC"
] | permissive | saulopz/rtsim | dfc589d173ed3b0edcb03a1b17b05f184dbcbd7c | fe506cf6015db40daf7c63b9d03883b491c4fb06 | refs/heads/master | 2023-05-23T09:04:42.977258 | 2021-06-08T21:53:03 | 2021-06-08T21:53:03 | 375,132,324 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 217 | cpp | #include "SporadicServer.h"
SporadicServer::SporadicServer()
{
ThState = IDLE;
TState = IDLE;
state = SUSPENDED;
BEGIN = 0;
END = 0;
tr = 0;
tf = -1;
te = 0;
tb = 0;
}
SporadicServer::~SporadicServer()
{
}
| [
"saulopz@gmail.com"
] | saulopz@gmail.com |
edc38ccb935f6ce1e7f9350d388514807583e65e | fce86a5cb364e3c46a8a8009b1bc4f3441038156 | /student.cpp | c6204a13fb4d66dd2a904e9d8b8b9250f13f8c21 | [] | no_license | chenqing-xin/studentObject | ff1cfd97b769a80f8f41ae5f7f6a7b7c0fd089b1 | 86d6dc99c024ac118a5d45c236e0faa5721e5ecb | refs/heads/master | 2023-05-22T19:14:46.958464 | 2021-06-02T16:11:15 | 2021-06-02T16:11:15 | 373,228,983 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 243 | cpp | #ifndef Student_H_
#define Student_H_
#include<string>
class Student
{
private :
String name;
int age;
int GPA;
public :
student();
Student(string n,int a,int G);
~Student();
string getName();
int getAge();
int getGPA();
}
| [
"1506322647@qq.com"
] | 1506322647@qq.com |
a03fa8627844de5c80f4b02aea05260c88fed54f | fd6ba461ff7746a5d152576930add08ebfcbb975 | /tests/ErrorTests.cc | f1ae1fbf41abc4a91ac286c518c1a3f1329807ec | [
"Zlib"
] | permissive | rbdl/rbdl | 658d3b07e420642dd9c9b1106daff24fd43e526f | cbd9371ce822eeea1f0a880d57f71a4c60bc9b8a | refs/heads/master | 2023-07-06T02:54:35.529726 | 2023-06-25T11:11:42 | 2023-06-25T11:11:42 | 208,891,294 | 449 | 141 | NOASSERTION | 2023-09-13T16:09:26 | 2019-09-16T20:24:46 | C++ | UTF-8 | C++ | false | false | 3,179 | cc | #include "rbdl/Logging.h"
#include "rbdl/rbdl_errors.h"
#include <iostream>
#include <exception>
#include "rbdl_tests.h"
using namespace RigidBodyDynamics::Errors;
// Test if each error type can be catched by Base Class
TEST_CASE ( __FILE__"_BaseClassCatch", "" )
{
//RBDLError
try {
throw RBDLError("Test RBDLError");
} catch (RBDLError &err) {
CHECK(true);
} catch (std::exception &e) {
CHECK(false);
}
//RBDLInvalidParameterError
try {
throw RBDLInvalidParameterError("Test RBDLInvalidParameterError");
} catch (RBDLError &err) {
CHECK(true);
} catch (std::exception &e) {
CHECK(false);
}
//RBDLSizeMismatchError
try {
throw RBDLSizeMismatchError("Test RBDLSizeMismatchError");
} catch (RBDLError &err) {
CHECK(true);
} catch (std::exception &e) {
CHECK(false);
}
//RBDLDofMismatchError
try {
throw RBDLDofMismatchError("Test RBDLDofMismatchError");
} catch (RBDLError &err) {
CHECK(true);
} catch (std::exception &e) {
CHECK(false);
}
//RBDLMissingImplementationError
try {
throw RBDLMissingImplementationError("Test RBDLMissingImplementationError");
} catch (RBDLError &err) {
CHECK(true);
} catch (std::exception &e) {
CHECK(false);
}
//RBDLInvalidFileError
try {
throw RBDLInvalidFileError("Test RBDLInvalidFileError");
} catch (RBDLError &err) {
CHECK(true);
} catch (std::exception &e) {
CHECK(false);
}
//RBDLFileParseError
try {
throw RBDLFileParseError("Test RBDLFileParseError");
} catch (RBDLFileParseError &err) {
CHECK(true);
} catch (std::exception &e) {
CHECK(false);
}
}
// Tests to check catching each error type
TEST_CASE (__FILE__"_RBDLInvalidParameterErrorTest", "" )
{
try {
throw RBDLInvalidParameterError("Test RBDLInvalidParameterError");
} catch (RBDLInvalidParameterError &err) {
CHECK(true);
} catch (std::exception &e) {
CHECK(false);
}
}
TEST_CASE (__FILE__"_RBDLSizeMismatchErrorTest", "" )
{
try {
throw RBDLSizeMismatchError("Test RBDLSizeMismatchError");
} catch (RBDLSizeMismatchError &err) {
CHECK(true);
} catch (std::exception &e) {
CHECK(false);
}
}
TEST_CASE (__FILE__"_RBDLDofMismatchErrorTest", "" )
{
try {
throw RBDLDofMismatchError("Test RBDLDofMismatchError");
} catch (RBDLDofMismatchError &err) {
CHECK(true);
} catch (std::exception &e) {
CHECK(false);
}
}
TEST_CASE (__FILE__"_RBDLMissingImplementationErrorTest", "")
{
try {
throw RBDLMissingImplementationError("Test RBDLMissingImplementationError");
} catch (RBDLMissingImplementationError &err) {
CHECK(true);
} catch (std::exception &e) {
CHECK(false);
}
}
TEST_CASE (__FILE__"_RBDLInvalidFileErrorTest", "")
{
try {
throw RBDLInvalidFileError("Test RBDLInvalidFileError");
} catch (RBDLInvalidFileError &err) {
CHECK(true);
} catch (std::exception &e) {
CHECK(false);
}
}
TEST_CASE (__FILE__"_RBDLFileParseErrorTest", "" )
{
try {
throw RBDLFileParseError("Test RBDLFileParseError");
} catch (RBDLFileParseError &err) {
CHECK(true);
} catch (std::exception &e) {
CHECK(false);
}
}
| [
"judge@felixrichter.tech"
] | judge@felixrichter.tech |
02321d0a6256c2f555951d0c03842bdc5f02d85a | e0f583d286706699da99bc631a31e3f4f2078965 | /solutions/0773. Sliding Puzzle/0773.cpp | f079a0a0f87cfe05dc2b4a079c420c560c659029 | [] | no_license | T353007/LeetCode-1 | 4f002d1885358e8beec0c3d59a1549c4c9f0e06d | 026713cb8fa25f52851e1432cd71a5518504e3e0 | refs/heads/main | 2023-02-15T17:03:49.726291 | 2021-01-12T10:12:25 | 2021-01-12T10:12:25 | 328,920,320 | 0 | 0 | null | 2021-01-12T08:29:55 | 2021-01-12T08:29:55 | null | UTF-8 | C++ | false | false | 1,264 | cpp | class Solution {
public:
int slidingPuzzle(vector<vector<int>>& board) {
constexpr int m = 2;
constexpr int n = 3;
const vector<int> dirs{0, 1, 0, -1, 0};
const string goal = "123450";
int steps = 0;
string start;
// hash 2D vector to string
for (int i = 0; i < m; ++i)
for (int j = 0; j < n; ++j)
start += '0' + board[i][j];
if (start == goal)
return 0;
queue<string> q{{start}};
unordered_set<string> seen{start};
while (!q.empty()) {
++steps;
for (int size = q.size(); size > 0; --size) {
string s = q.front();
q.pop();
const int zeroIndex = s.find('0');
const int i = zeroIndex / n;
const int j = zeroIndex % n;
for (int k = 0; k < 4; ++k) {
const int x = i + dirs[k];
const int y = j + dirs[k + 1];
if (x < 0 || x == m || y < 0 || y == n)
continue;
const int swappedIndex = x * n + y;
swap(s[zeroIndex], s[swappedIndex]);
if (s == goal)
return steps;
if (!seen.count(s)) {
q.push(s);
seen.insert(s);
}
swap(s[zeroIndex], s[swappedIndex]);
}
}
}
return -1;
}
}; | [
"walkccray@gmail.com"
] | walkccray@gmail.com |
5e812e8328b957ed1443d544b977bad1f58494da | 657b85a8e705b49c67a7cda9776beaa2e649f6a4 | /capter6/ex6.5.4/ex6.5.4/main.cpp | d153a323fdf3f591ec700f7b1c4323bb5525f985 | [] | no_license | longjiezhong/leaning_openCV3 | cce94604c692dbaf9c5202843653829337a1f75b | 906661ba1b7ef7cb30c4c2ca626de805ac893e2d | refs/heads/master | 2021-01-02T08:12:36.910312 | 2017-08-31T12:56:49 | 2017-08-31T12:56:49 | 98,952,364 | 0 | 0 | null | null | null | null | GB18030 | C++ | false | false | 4,071 | cpp | #include "opencv2/imgproc/imgproc.hpp"
#include "opencv2/highgui/highgui.hpp"
#include <iostream>
using namespace cv;
using namespace std;
Mat g_srcImage, g_dstImage, g_grayImage, g_maskImage;
int g_nFillMode = 1;
int g_nLowDifference = 20, g_nUpDifference = 20;
int g_nConnectivity = 4;
int g_bIsColor = true;
bool g_bUseMask = false;
int g_nNewMackVal = 255;
static void onMouse(int event, int x, int y, int, void*)
{
if(event != CV_EVENT_LBUTTONDOWN)
return;
Point seed = Point(x, y);
int LowDifference = g_nFillMode == 0 ? 0 : g_nLowDifference;
int UpDifference = g_nFillMode == 0 ? 0 : g_nUpDifference;
int flags = g_nConnectivity + (g_nNewMackVal << 8) + (g_nFillMode
== 1 ? CV_FLOODFILL_FIXED_RANGE : 0);
int b = (unsigned)theRNG() & 255; //产生的新像素颜色是随机的
int g = (unsigned)theRNG() & 255;
int r = (unsigned)theRNG() & 255;
Rect ccomp;
Scalar newVal = g_bIsColor ? Scalar(b,g,r) : Scalar(r*0.299 + g*0.587
+b*0.114);
Mat dst = g_bIsColor ? g_dstImage : g_grayImage;
int area;
if( g_bUseMask )
{
threshold(g_maskImage, g_maskImage, 1, 128, CV_THRESH_BINARY);
area = floodFill(dst, //被处理的图像
g_maskImage, //掩膜；
seed, //漫水填充算法的起点
newVal, //像素被填充的值
&ccomp, //设置重绘区域最小边界矩形区域
Scalar(LowDifference, LowDifference, LowDifference), //重绘区域负差最大值
Scalar(UpDifference, UpDifference, UpDifference), //重绘区域正查最大值
flags); //操作标志符
imshow( "mask", g_maskImage );
}
else
{
area = floodFill(dst, seed, newVal, &ccomp, Scalar(LowDifference, LowDifference, LowDifference),
Scalar(UpDifference, UpDifference, UpDifference), flags);
}
imshow("效果图", dst);
cout << area << "个像素被重绘\n" << endl;
}
int main(int argc, char** argv)
{
g_srcImage = imread("1.png", 1);
if( !g_srcImage.data )
cout << "读取图片错误！" << endl;
g_srcImage.copyTo(g_dstImage);
cvtColor(g_srcImage, g_grayImage, COLOR_RGB2GRAY);
g_maskImage.create(g_srcImage.rows+2, g_srcImage.cols+2, CV_8UC1);
namedWindow("效果图", CV_WINDOW_AUTOSIZE);
createTrackbar("负差最大值", "效果图", &g_nLowDifference, 255, 0);
createTrackbar("正差最大值", "效果图", &g_nUpDifference, 255, 0);
setMouseCallback("效果图", onMouse, 0);
while(1)
{
imshow("效果图", g_bIsColor ? g_dstImage : g_grayImage);
char c = waitKey(0);
if( c == 27 )
{
cout << "程序退出......\n";
break;
}
switch( c )
{
case '1':
if( g_bIsColor )
{
//cout << "键盘“1”被按下，切换彩色/灰度模式" << endl;
cvtColor(g_srcImage, g_grayImage, COLOR_RGB2GRAY);
g_maskImage = Scalar::all(0);
g_bIsColor = false;
}
else
{
g_srcImage.copyTo(g_dstImage);
g_maskImage = Scalar::all(0);
g_bIsColor = true;
}
break;
//按键2被按下，显示/隐藏掩模窗口
case '2' :
if(g_bUseMask)
{
destroyWindow("mask");
g_bUseMask = false;
}
else
{
namedWindow("mask", 0);
g_maskImage = Scalar::all(0);
imshow("mask", g_maskImage);
g_bUseMask = true;
}
break;
case '3':
cout << "按键3被按下，恢复原始图像" << endl;
g_srcImage.copyTo(g_dstImage);
cvtColor(g_dstImage, g_grayImage, COLOR_RGB2GRAY);
g_maskImage = Scalar::all(0);
break;
case '4':
cout << "按键4被按下，使用空范围的漫水填充" << endl;
g_nFillMode = 0;
break;
case '5':
cout << "按键5被按下，使用渐变、固定范围的漫水填充" << endl;
g_nFillMode = 1;
break;
case '6':
cout << "按键6被按下，使用渐变、浮动范围的漫水填充" << endl;
g_nFillMode = 2;
break;
case '7':
cout << "按键7被按下，操作标志位的低8位使用4位的连接模式" << endl;
g_nConnectivity = 4;
break;
case '8':
cout << "按键8被按下，操作标志位的低8位使用8位的链接模式" << endl;
g_nConnectivity = 8;
break;
}
}
return 0;
} | [
"30586750+longjiezhong@users.noreply.github.com"
] | 30586750+longjiezhong@users.noreply.github.com |
0ea5fdd771e04fa0d24d8dee4e4d570f130e2667 | 0014fb5ce4aa3a6f460128bb646a3c3cfe81eb9e | /testdata/15/10/src/node7.cpp | 8d9a2e2f638fda566113954b7b7688ccbe109029 | [] | no_license | yps158/randomGraph | c1fa9c531b11bb935d112d1c9e510b5c02921df2 | 68f9e2e5b0bed1f04095642ee6924a68c0768f0c | refs/heads/master | 2021-09-05T05:32:45.210171 | 2018-01-24T11:23:06 | 2018-01-24T11:23:06 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,428 | cpp |
#include "ros/ros.h"
#include "std_msgs/String.h"
#include "unistd.h"
#include <sstream>
#include <random>
std::random_device rd;
std::mt19937 gen(rd());
std::normal_distribution<> d(0.028334, 0.005);
class Node7{
public:
Node7(){
sub_2_7_flag = 0;
sub_2_7 = n.subscribe("topic_2_7", 1, &Node7::middlemanCallback2,this);
sub_3_7_flag = 0;
sub_3_7 = n.subscribe("topic_3_7", 1, &Node7::middlemanCallback3,this);
sub_4_7_flag = 0;
sub_4_7 = n.subscribe("topic_4_7", 1, &Node7::middlemanCallback4,this);
pub_7_11 = n.advertise<std_msgs::String>("topic_7_11", 1);
pub_7_8 = n.advertise<std_msgs::String>("topic_7_8", 1);
}
void middlemanCallback2(const std_msgs::String::ConstPtr& msg){
if(sub_3_7_flag == 1 && sub_4_7_flag == 1 && true){
usleep(d(gen)*1000000);
ROS_INFO("I'm node7 last from node2, intercepted: [%s]", msg->data.c_str());
pub_7_11.publish(msg);
pub_7_8.publish(msg);
sub_3_7_flag = 0;
sub_4_7_flag = 0;
}
else{
ROS_INFO("I'm node7, from node2 intercepted: [%s]", msg->data.c_str());
sub_2_7_flag = 1;
}
}
void middlemanCallback3(const std_msgs::String::ConstPtr& msg){
if(sub_2_7_flag == 1 && sub_4_7_flag == 1 && true){
usleep(d(gen)*1000000);
ROS_INFO("I'm node7 last from node3, intercepted: [%s]", msg->data.c_str());
pub_7_11.publish(msg);
pub_7_8.publish(msg);
sub_2_7_flag = 0;
sub_4_7_flag = 0;
}
else{
ROS_INFO("I'm node7, from node3 intercepted: [%s]", msg->data.c_str());
sub_3_7_flag = 1;
}
}
void middlemanCallback4(const std_msgs::String::ConstPtr& msg){
if(sub_2_7_flag == 1 && sub_3_7_flag == 1 && true){
usleep(d(gen)*1000000);
ROS_INFO("I'm node7 last from node4, intercepted: [%s]", msg->data.c_str());
pub_7_11.publish(msg);
pub_7_8.publish(msg);
sub_2_7_flag = 0;
sub_3_7_flag = 0;
}
else{
ROS_INFO("I'm node7, from node4 intercepted: [%s]", msg->data.c_str());
sub_4_7_flag = 1;
}
}
private:
ros::NodeHandle n;
ros::Publisher pub_7_11;
ros::Publisher pub_7_8;
int sub_2_7_flag;
ros::Subscriber sub_2_7;
int sub_3_7_flag;
ros::Subscriber sub_3_7;
int sub_4_7_flag;
ros::Subscriber sub_4_7;
};
int main(int argc, char **argv){
ros::init(argc, argv, "node7");
Node7 node7;
ros::spin();
return 0;
}
| [
"sasaki@thinkingreed.co.jp"
] | sasaki@thinkingreed.co.jp |
805772a50fe73e2a29788c2b33618ccc4c4b2fb1 | a8dead89e139e09733d559175293a5d3b2aef56c | /external/include/ogremain/OgreRenderQueueSortingGrouping.h | 62c84abb1eff3924b9b65f7c7e3a8e35091622bb | [
"MIT"
] | permissive | riyanhax/Demi3D | 4f3a48e6d76462a998b1b08935b37d8019815474 | 73e684168bd39b894f448779d41fab600ba9b150 | refs/heads/master | 2021-12-04T06:24:26.642316 | 2015-01-29T22:06:00 | 2015-01-29T22:06:00 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 25,347 | h | /*
-----------------------------------------------------------------------------
This source file is part of OGRE
(Object-oriented Graphics Rendering Engine)
For the latest info, see http://www.ogre3d.org/
Copyright (c) 2000-2014 Torus Knot Software Ltd
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
-----------------------------------------------------------------------------
*/
#ifndef __RenderQueueSortingGrouping_H__
#define __RenderQueueSortingGrouping_H__
// Precompiler options
#include "OgrePrerequisites.h"
#include "OgrePass.h"
#include "OgreRadixSort.h"
namespace Ogre {
/** \addtogroup Core
* @{
*/
/** \addtogroup RenderSystem
* @{
*/
/** Struct associating a single Pass with a single Renderable.
This is used to for objects sorted by depth and thus not
grouped by pass.
*/
struct RenderablePass
{
/// Pointer to the Renderable details
Renderable* renderable;
/// Pointer to the Pass
Pass* pass;
RenderablePass(Renderable* rend, Pass* p) :renderable(rend), pass(p) {}
};
/** Visitor interface for items in a QueuedRenderableCollection.
@remarks
Those wishing to iterate over the items in a
QueuedRenderableCollection should implement this visitor pattern,
since internal organisation of the collection depends on the
sorting method in use.
*/
class _OgreExport QueuedRenderableVisitor
{
public:
QueuedRenderableVisitor() {}
virtual ~QueuedRenderableVisitor() {}
/** Called when visiting a RenderablePass, i.e. items in a
sorted collection where items are not grouped by pass.
@remarks
If this is called, neither of the other 2 visit methods
will be called.
*/
virtual void visit(RenderablePass* rp) = 0;
/* When visiting a collection grouped by pass, this is
called when the grouping pass changes.
@remarks
If this method is called, the RenderablePass visit
method will not be called for this collection. The
Renderable visit method will be called for each item
underneath the pass grouping level.
@return True to continue, false to skip the Renderables underneath
*/
virtual bool visit(const Pass* p) = 0;
/** Visit method called once per Renderable on a grouped
collection.
@remarks
If this method is called, the RenderablePass visit
method will not be called for this collection.
*/
virtual void visit(Renderable* r) = 0;
};
/** Lowest level collection of renderables.
@remarks
To iterate over items in this collection, you must call
the accept method and supply a QueuedRenderableVisitor.
The order of the iteration, and whether that iteration is
over a RenderablePass list or a 2-level grouped list which
causes a visit call at the Pass level, and a call for each
Renderable underneath.
*/
class _OgreExport QueuedRenderableCollection : public RenderQueueAlloc
{
public:
/** Organisation modes required for this collection.
@remarks
This affects the internal placement of the items added to this collection;
if only one type of sorting / grouping is to be required, then renderables
can be stored only once, whilst if multiple types are going to be needed
then internally there will be multiple organisations. Changing the organisation
needs to be done when the collection is empty.
*/
enum OrganisationMode
{
/// Group by pass
OM_PASS_GROUP = 1,
/// Sort descending camera distance
OM_SORT_DESCENDING = 2,
/** Sort ascending camera distance
Note value overlaps with descending since both use same sort
*/
OM_SORT_ASCENDING = 6
};
protected:
/// Comparator to order pass groups
struct PassGroupLess
{
bool _OgreExport operator()(const Pass* a, const Pass* b) const
{
// Sort by passHash, which is pass, then texture unit changes
uint32 hasha = a->getHash();
uint32 hashb = b->getHash();
if (hasha == hashb)
{
// Must differentTransparentQueueItemLessiate by pointer incase 2 passes end up with the same hash
return a < b;
}
else
{
return hasha < hashb;
}
}
};
/// Comparator to order objects by descending camera distance
struct DepthSortDescendingLess
{
const Camera* camera;
DepthSortDescendingLess(const Camera* cam)
: camera(cam)
{
}
bool _OgreExport operator()(const RenderablePass& a, const RenderablePass& b) const
{
if (a.renderable == b.renderable)
{
// Same renderable, sort by pass hash
return a.pass->getHash() < b.pass->getHash();
}
else
{
// Different renderables, sort by depth
Real adepth = a.renderable->getSquaredViewDepth(camera);
Real bdepth = b.renderable->getSquaredViewDepth(camera);
if (Math::RealEqual(adepth, bdepth))
{
// Must return deterministic result, doesn't matter what
return a.pass < b.pass;
}
else
{
// Sort DESCENDING by depth (i.e. far objects first)
return (adepth > bdepth);
}
}
}
};
/** Vector of RenderablePass objects, this is built on the assumption that
vectors only ever increase in size, so even if we do clear() the memory stays
allocated, ie fast */
typedef vector<RenderablePass>::type RenderablePassList;
typedef vector<Renderable*>::type RenderableList;
/** Map of pass to renderable lists, this is a grouping by pass. */
typedef map<Pass*, RenderableList*, PassGroupLess>::type PassGroupRenderableMap;
/// Functor for accessing sort value 1 for radix sort (Pass)
struct RadixSortFunctorPass
{
uint32 operator()(const RenderablePass& p) const
{
return p.pass->getHash();
}
};
/// Radix sorter for accessing sort value 1 (Pass)
static RadixSort<RenderablePassList, RenderablePass, uint32> msRadixSorter1;
/// Functor for descending sort value 2 for radix sort (distance)
struct RadixSortFunctorDistance
{
const Camera* camera;
RadixSortFunctorDistance(const Camera* cam)
: camera(cam)
{
}
float operator()(const RenderablePass& p) const
{
// Sort DESCENDING by depth (ie far objects first), use negative distance
// here because radix sorter always dealing with accessing sort
return static_cast<float>(- p.renderable->getSquaredViewDepth(camera));
}
};
/// Radix sorter for sort value 2 (distance)
static RadixSort<RenderablePassList, RenderablePass, float> msRadixSorter2;
/// Bitmask of the organisation modes requested
uint8 mOrganisationMode;
/// Grouped
PassGroupRenderableMap mGrouped;
/// Sorted descending (can iterate backwards to get ascending)
RenderablePassList mSortedDescending;
/// Internal visitor implementation
void acceptVisitorGrouped(QueuedRenderableVisitor* visitor) const;
/// Internal visitor implementation
void acceptVisitorDescending(QueuedRenderableVisitor* visitor) const;
/// Internal visitor implementation
void acceptVisitorAscending(QueuedRenderableVisitor* visitor) const;
public:
QueuedRenderableCollection();
~QueuedRenderableCollection();
/// Empty the collection
void clear(void);
/** Remove the group entry (if any) for a given Pass.
@remarks
To be used when a pass is destroyed, such that any
grouping level for it becomes useless.
*/
void removePassGroup(Pass* p);
/** Reset the organisation modes required for this collection.
@remarks
You can only do this when the collection is empty.
@see OrganisationMode
*/
void resetOrganisationModes(void)
{
mOrganisationMode = 0;
}
/** Add a required sorting / grouping mode to this collection when next used.
@remarks
You can only do this when the collection is empty.
@see OrganisationMode
*/
void addOrganisationMode(OrganisationMode om)
{
mOrganisationMode |= om;
}
/// Add a renderable to the collection using a given pass
void addRenderable(Pass* pass, Renderable* rend);
/** Perform any sorting that is required on this collection.
@param cam The camera
*/
void sort(const Camera* cam);
/** Accept a visitor over the collection contents.
@param visitor Visitor class which should be called back
@param om The organisation mode which you want to iterate over.
Note that this must have been included in an addOrganisationMode
call before any renderables were added.
*/
void acceptVisitor(QueuedRenderableVisitor* visitor, OrganisationMode om) const;
/** Merge renderable collection.
*/
void merge( const QueuedRenderableCollection& rhs );
};
/** Collection of renderables by priority.
@remarks
This class simply groups renderables for rendering. All the
renderables contained in this class are destined for the same
RenderQueueGroup (coarse groupings like those between the main
scene and overlays) and have the same priority (fine groupings
for detailed overlap control).
@par
This class can order solid renderables by a number of criteria;
it can optimise them into groups based on pass to reduce render
state changes, or can sort them by ascending or descending view
depth. Transparent objects are always ordered by descending depth.
@par
To iterate over items in the collections held by this object
you should retrieve the collection in use (e.g. solids, solids with
no shadows, transparents) and use the accept() method, providing
a class implementing QueuedRenderableVisitor.
*/
class _OgreExport RenderPriorityGroup : public RenderQueueAlloc
{
protected:
/// Parent queue group
RenderQueueGroup* mParent;
bool mSplitPassesByLightingType;
bool mSplitNoShadowPasses;
bool mShadowCastersNotReceivers;
/// Solid pass list, used when no shadows, modulative shadows, or ambient passes for additive
QueuedRenderableCollection mSolidsBasic;
/// Solid per-light pass list, used with additive shadows
QueuedRenderableCollection mSolidsDiffuseSpecular;
/// Solid decal (texture) pass list, used with additive shadows
QueuedRenderableCollection mSolidsDecal;
/// Solid pass list, used when shadows are enabled but shadow receive is turned off for these passes
QueuedRenderableCollection mSolidsNoShadowReceive;
/// Unsorted transparent list
QueuedRenderableCollection mTransparentsUnsorted;
/// Transparent list
QueuedRenderableCollection mTransparents;
/// remove a pass entry from all collections
void removePassEntry(Pass* p);
/// Internal method for adding a solid renderable
void addSolidRenderable(Technique* pTech, Renderable* rend, bool toNoShadowMap);
/// Internal method for adding a solid renderable
void addSolidRenderableSplitByLightType(Technique* pTech, Renderable* rend);
/// Internal method for adding an unsorted transparent renderable
void addUnsortedTransparentRenderable(Technique* pTech, Renderable* rend);
/// Internal method for adding a transparent renderable
void addTransparentRenderable(Technique* pTech, Renderable* rend);
public:
RenderPriorityGroup(RenderQueueGroup* parent,
bool splitPassesByLightingType,
bool splitNoShadowPasses,
bool shadowCastersNotReceivers);
~RenderPriorityGroup() { }
/** Get the collection of basic solids currently queued, this includes
all solids when there are no shadows, or all solids which have shadow
receiving enabled when using modulative shadows, or all ambient passes
of solids which have shadow receive enabled for additive shadows. */
const QueuedRenderableCollection& getSolidsBasic(void) const
{ return mSolidsBasic; }
/** Get the collection of solids currently queued per light (only applicable in
additive shadow modes). */
const QueuedRenderableCollection& getSolidsDiffuseSpecular(void) const
{ return mSolidsDiffuseSpecular; }
/** Get the collection of solids currently queued for decal passes (only
applicable in additive shadow modes). */
const QueuedRenderableCollection& getSolidsDecal(void) const
{ return mSolidsDecal; }
/** Get the collection of solids for which shadow receipt is disabled (only
applicable when shadows are enabled). */
const QueuedRenderableCollection& getSolidsNoShadowReceive(void) const
{ return mSolidsNoShadowReceive; }
/** Get the collection of transparent objects currently queued */
const QueuedRenderableCollection& getTransparentsUnsorted(void) const
{ return mTransparentsUnsorted; }
/** Get the collection of transparent objects currently queued */
const QueuedRenderableCollection& getTransparents(void) const
{ return mTransparents; }
/** Reset the organisation modes required for the solids in this group.
@remarks
You can only do this when the group is empty, i.e. after clearing the
queue.
@see QueuedRenderableCollection::OrganisationMode
*/
void resetOrganisationModes(void);
/** Add a required sorting / grouping mode for the solids in this group.
@remarks
You can only do this when the group is empty, i.e. after clearing the
queue.
@see QueuedRenderableCollection::OrganisationMode
*/
void addOrganisationMode(QueuedRenderableCollection::OrganisationMode om);
/** Set the sorting / grouping mode for the solids in this group to the default.
@remarks
You can only do this when the group is empty, i.e. after clearing the
queue.
@see QueuedRenderableCollection::OrganisationMode
*/
void defaultOrganisationMode(void);
/** Add a renderable to this group. */
void addRenderable(Renderable* pRend, Technique* pTech);
/** Sorts the objects which have been added to the queue; transparent objects by their
depth in relation to the passed in Camera. */
void sort(const Camera* cam);
/** Clears this group of renderables.
*/
void clear(void);
/** Sets whether or not the queue will split passes by their lighting type,
ie ambient, per-light and decal.
*/
void setSplitPassesByLightingType(bool split)
{
mSplitPassesByLightingType = split;
}
/** Sets whether or not passes which have shadow receive disabled should
be separated.
*/
void setSplitNoShadowPasses(bool split)
{
mSplitNoShadowPasses = split;
}
/** Sets whether or not objects which cast shadows should be treated as
never receiving shadows.
*/
void setShadowCastersCannotBeReceivers(bool ind)
{
mShadowCastersNotReceivers = ind;
}
/** Merge group of renderables.
*/
void merge( const RenderPriorityGroup* rhs );
};
/** A grouping level underneath RenderQueue which groups renderables
to be issued at coarsely the same time to the renderer.
@remarks
Each instance of this class itself hold RenderPriorityGroup instances,
which are the groupings of renderables by priority for fine control
of ordering (not required for most instances).
*/
class _OgreExport RenderQueueGroup : public RenderQueueAlloc
{
public:
typedef map<ushort, RenderPriorityGroup*, std::less<ushort> >::type PriorityMap;
typedef MapIterator<PriorityMap> PriorityMapIterator;
typedef ConstMapIterator<PriorityMap> ConstPriorityMapIterator;
protected:
RenderQueue* mParent;
bool mSplitPassesByLightingType;
bool mSplitNoShadowPasses;
bool mShadowCastersNotReceivers;
/// Map of RenderPriorityGroup objects
PriorityMap mPriorityGroups;
/// Whether shadows are enabled for this queue
bool mShadowsEnabled;
/// Bitmask of the organisation modes requested (for new priority groups)
uint8 mOrganisationMode;
public:
RenderQueueGroup(RenderQueue* parent,
bool splitPassesByLightingType,
bool splitNoShadowPasses,
bool shadowCastersNotReceivers)
: mParent(parent)
, mSplitPassesByLightingType(splitPassesByLightingType)
, mSplitNoShadowPasses(splitNoShadowPasses)
, mShadowCastersNotReceivers(shadowCastersNotReceivers)
, mShadowsEnabled(true)
, mOrganisationMode(0)
{
}
~RenderQueueGroup() {
// destroy contents now
PriorityMap::iterator i;
for (i = mPriorityGroups.begin(); i != mPriorityGroups.end(); ++i)
{
OGRE_DELETE i->second;
}
}
/** Get an iterator for browsing through child contents. */
PriorityMapIterator getIterator(void)
{
return PriorityMapIterator(mPriorityGroups.begin(), mPriorityGroups.end());
}
/** Get a const iterator for browsing through child contents. */
ConstPriorityMapIterator getIterator(void) const
{
return ConstPriorityMapIterator(mPriorityGroups.begin(), mPriorityGroups.end());
}
/** Add a renderable to this group, with the given priority. */
void addRenderable(Renderable* pRend, Technique* pTech, ushort priority)
{
// Check if priority group is there
PriorityMap::iterator i = mPriorityGroups.find(priority);
RenderPriorityGroup* pPriorityGrp;
if (i == mPriorityGroups.end())
{
// Missing, create
pPriorityGrp = OGRE_NEW RenderPriorityGroup(this,
mSplitPassesByLightingType,
mSplitNoShadowPasses,
mShadowCastersNotReceivers);
if (mOrganisationMode)
{
pPriorityGrp->resetOrganisationModes();
pPriorityGrp->addOrganisationMode((QueuedRenderableCollection::OrganisationMode)mOrganisationMode);
}
mPriorityGroups.insert(PriorityMap::value_type(priority, pPriorityGrp));
}
else
{
pPriorityGrp = i->second;
}
// Add
pPriorityGrp->addRenderable(pRend, pTech);
}
/** Clears this group of renderables.
@param destroy
If false, doesn't delete any priority groups, just empties them. Saves on
memory deallocations since the chances are roughly the same kinds of
renderables are going to be sent to the queue again next time. If
true, completely destroys.
*/
void clear(bool destroy = false)
{
PriorityMap::iterator i, iend;
iend = mPriorityGroups.end();
for (i = mPriorityGroups.begin(); i != iend; ++i)
{
if (destroy)
OGRE_DELETE i->second;
else
i->second->clear();
}
if (destroy)
mPriorityGroups.clear();
}
/** Indicate whether a given queue group will be doing any
shadow setup.
@remarks
This method allows you to inform the queue about a queue group, and to
indicate whether this group will require shadow processing of any sort.
In order to preserve rendering order, OGRE has to treat queue groups
as very separate elements of the scene, and this can result in it
having to duplicate shadow setup for each group. Therefore, if you
know that a group which you are using will never need shadows, you
should preregister the group using this method in order to improve
the performance.
*/
void setShadowsEnabled(bool enabled) { mShadowsEnabled = enabled; }
/** Are shadows enabled for this queue? */
bool getShadowsEnabled(void) const { return mShadowsEnabled; }
/** Sets whether or not the queue will split passes by their lighting type,
ie ambient, per-light and decal.
*/
void setSplitPassesByLightingType(bool split)
{
mSplitPassesByLightingType = split;
PriorityMap::iterator i, iend;
iend = mPriorityGroups.end();
for (i = mPriorityGroups.begin(); i != iend; ++i)
{
i->second->setSplitPassesByLightingType(split);
}
}
/** Sets whether or not the queue will split passes which have shadow receive
turned off (in their parent material), which is needed when certain shadow
techniques are used.
*/
void setSplitNoShadowPasses(bool split)
{
mSplitNoShadowPasses = split;
PriorityMap::iterator i, iend;
iend = mPriorityGroups.end();
for (i = mPriorityGroups.begin(); i != iend; ++i)
{
i->second->setSplitNoShadowPasses(split);
}
}
/** Sets whether or not objects which cast shadows should be treated as
never receiving shadows.
*/
void setShadowCastersCannotBeReceivers(bool ind)
{
mShadowCastersNotReceivers = ind;
PriorityMap::iterator i, iend;
iend = mPriorityGroups.end();
for (i = mPriorityGroups.begin(); i != iend; ++i)
{
i->second->setShadowCastersCannotBeReceivers(ind);
}
}
/** Reset the organisation modes required for the solids in this group.
@remarks
You can only do this when the group is empty, ie after clearing the
queue.
@see QueuedRenderableCollection::OrganisationMode
*/
void resetOrganisationModes(void)
{
mOrganisationMode = 0;
PriorityMap::iterator i, iend;
iend = mPriorityGroups.end();
for (i = mPriorityGroups.begin(); i != iend; ++i)
{
i->second->resetOrganisationModes();
}
}
/** Add a required sorting / grouping mode for the solids in this group.
@remarks
You can only do this when the group is empty, ie after clearing the
queue.
@see QueuedRenderableCollection::OrganisationMode
*/
void addOrganisationMode(QueuedRenderableCollection::OrganisationMode om)
{
mOrganisationMode |= om;
PriorityMap::iterator i, iend;
iend = mPriorityGroups.end();
for (i = mPriorityGroups.begin(); i != iend; ++i)
{
i->second->addOrganisationMode(om);
}
}
/** Setthe sorting / grouping mode for the solids in this group to the default.
@remarks
You can only do this when the group is empty, ie after clearing the
queue.
@see QueuedRenderableCollection::OrganisationMode
*/
void defaultOrganisationMode(void)
{
mOrganisationMode = 0;
PriorityMap::iterator i, iend;
iend = mPriorityGroups.end();
for (i = mPriorityGroups.begin(); i != iend; ++i)
{
i->second->defaultOrganisationMode();
}
}
/** Merge group of renderables.
*/
void merge( const RenderQueueGroup* rhs )
{
ConstPriorityMapIterator it = rhs->getIterator();
while( it.hasMoreElements() )
{
ushort priority = it.peekNextKey();
RenderPriorityGroup* pSrcPriorityGrp = it.getNext();
RenderPriorityGroup* pDstPriorityGrp;
// Check if priority group is there
PriorityMap::iterator i = mPriorityGroups.find(priority);
if (i == mPriorityGroups.end())
{
// Missing, create
pDstPriorityGrp = OGRE_NEW RenderPriorityGroup(this,
mSplitPassesByLightingType,
mSplitNoShadowPasses,
mShadowCastersNotReceivers);
if (mOrganisationMode)
{
pDstPriorityGrp->resetOrganisationModes();
pDstPriorityGrp->addOrganisationMode((QueuedRenderableCollection::OrganisationMode)mOrganisationMode);
}
mPriorityGroups.insert(PriorityMap::value_type(priority, pDstPriorityGrp));
}
else
{
pDstPriorityGrp = i->second;
}
// merge
pDstPriorityGrp->merge( pSrcPriorityGrp );
}
}
};
/** @} */
/** @} */
}
#endif
| [
"demiwangya@gmail.com"
] | demiwangya@gmail.com |
4c75a64c9a7e1efe791b20d23c72c3981f5f78f6 | 0428c3b8086f12ebbc6de7967ee4437934e2146d | /device/src/tsc2046_interface.cpp | ed7ea5e343a462c7e1332980e4a6aa4fa133fcd1 | [] | no_license | cornway/stm32f4-dcmi-probe | e5cf112f83b09ea0d4af23660c12e78b101504e6 | 9cc677bdb092949d1212ec1fc831b7db3e485fbd | refs/heads/master | 2020-04-28T03:16:52.112141 | 2019-03-11T05:23:51 | 2019-03-11T05:23:51 | 174,930,315 | 2 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,530 | cpp | #include "tsc2046.h"
#include "main.h"
#include "gpio.h"
gpio::gpio_dsc tsc_busy_pin_dsc = {GPIOD, GPIO_PIN_3};
gpio::gpio_dsc tsc_pen_pin_dsc = {GPIOD, GPIO_PIN_2};
gpio::gpio_dsc tsc_sel_pin_dsc = {GPIOG, GPIO_PIN_15};
void tsc2046Drv::ll_init (bool it_ena)
{
__GPIOD_CLK_ENABLE();
__GPIOG_CLK_ENABLE();
gpio::init(tsc_busy_pin_dsc, GPIO_MODE_INPUT, GPIO_PULLUP, GPIO_SPEED_HIGH);
gpio::init(tsc_sel_pin_dsc, GPIO_MODE_OUTPUT_PP, GPIO_PULLUP, GPIO_SPEED_HIGH);
gpio::init(tsc_pen_pin_dsc, GPIO_MODE_IT_FALLING, GPIO_PULLUP, GPIO_SPEED_HIGH);
if (it_ena) {
HAL_NVIC_SetPriority(EXTI2_IRQn, 2, 0);
HAL_NVIC_EnableIRQ(EXTI2_IRQn);
}
}
void tsc2046Drv::ll_sel (bool sel)
{
gpio::pin_set(tsc_sel_pin_dsc, sel);
}
bool tsc2046Drv::ll_busy ()
{
return gpio::pin_read(tsc_busy_pin_dsc);
}
uint8_t tsc2046Drv::ll_rw (uint8_t data)
{
while ((SPI1->SR & SPI_FLAG_TXE) == 0){}
*(__IO uint8_t *)&SPI1->DR = data;
while ((SPI1->SR & SPI_FLAG_RXNE) == 0){}
return *(__IO uint8_t *)&SPI1->DR;
}
#include "fgpu.h"
#include "gui.h"
extern FontArray fontArray;
static GuiEngine<color_t, range_t, COLOR_WHITE> *tsc2046_engine;
static GContentPane<color_t, range_t, COLOR_WHITE> *tsc2046_pane;
FG_Rect fgRect = {0, 0, TFT_WIDTH, TFT_HEIGHT};
int tsc2046_frame_buffer_open ()
{
tsc2046_engine = new GuiEngine<color_t, range_t, COLOR_WHITE>(fontArray.font_mono, (color_t *)FRAME_MEMORY_BASE, 0, 0, TFT_WIDTH, TFT_HEIGHT);
if (tsc2046_engine == nullptr) {
return -1;
}
tsc2046_pane = tsc2046_engine->newContentPane(0, 0, TFT_WIDTH, TFT_HEIGHT);
if (tsc2046_pane == nullptr) {
delete tsc2046_engine;
return -1;
}
return 0;
}
void tsc2046_frame_buffer_close ()
{
delete tsc2046_engine;
}
void tsc2046_frame_buffer_safe_clear ()
{
tsc2046_pane->fill(COLOR_WHITE);
gpu_update(fgRect);
gpu_wait();
}
void tsc2046_frame_buffer_safe_circle_fill (int x, int y, int r)
{
Box<range_t> box = {(range_t)x, (range_t)y, (range_t)r, (range_t)r};
tsc2046_pane->getGraphic()->circleFilled(box, (float)r, COLOR_GREEN);
gpu_update(fgRect);
gpu_wait();
}
void tsc2046_frame_buffer_safe_draw_string (char * str, int x, int y)
{
Box<range_t> box = {(range_t)x, (range_t)y, TFT_WIDTH, 30};
tsc2046_pane->getGraphic()->drawString(box, str, 0xf800);
gpu_update(fgRect);
gpu_wait();
}
| [
"romanpustobayev@gmail.com"
] | romanpustobayev@gmail.com |
f045c87f6cb90bf1927b4fb8bc1098ed7edc851d | ac227cc22d5f5364e5d029a2cef83816a6954590 | /applications/physbam/physbam-lib/Public_Library/PhysBAM_Geometry/Grids_RLE_Interpolation_Collidable/LINEAR_INTERPOLATION_COLLIDABLE_CELL_RLE.h | 246f100b03147f88d06ac65cb8a4068a65ef6ae4 | [
"BSD-3-Clause"
] | permissive | schinmayee/nimbus | 597185bc8bac91a2480466cebc8b337f5d96bd2e | 170cd15e24a7a88243a6ea80aabadc0fc0e6e177 | refs/heads/master | 2020-03-11T11:42:39.262834 | 2018-04-18T01:28:23 | 2018-04-18T01:28:23 | 129,976,755 | 0 | 0 | BSD-3-Clause | 2018-04-17T23:33:23 | 2018-04-17T23:33:23 | null | UTF-8 | C++ | false | false | 5,502 | h | //#####################################################################
// Copyright 2004-2005, Ron Fedkiw, Geoffrey Irving, Frank Losasso, Andrew Selle, Tamar Shinar.
// This file is part of PhysBAM whose distribution is governed by the license contained in the accompanying file PHYSBAM_COPYRIGHT.txt.
//#####################################################################
// Class LINEAR_INTERPOLATION_COLLIDABLE_RLE
//#####################################################################
#ifndef COMPILE_WITHOUT_RLE_SUPPORT
#ifndef __LINEAR_INTERPOLATION_COLLIDABLE_CELL_RLE__
#define __LINEAR_INTERPOLATION_COLLIDABLE_CELL_RLE__
#include <PhysBAM_Tools/Interpolation/LINEAR_INTERPOLATION.h>
#include <PhysBAM_Geometry/Grids_RLE_Collisions/GRID_BASED_COLLISION_GEOMETRY_RLE.h>
namespace PhysBAM{
template<class T_GRID,class T2>
class LINEAR_INTERPOLATION_COLLIDABLE_CELL_RLE:public INTERPOLATION_RLE<T_GRID,T2>
{
typedef typename T_GRID::VECTOR_T TV;typedef typename TV::SCALAR T;typedef typename T_GRID::BLOCK T_BLOCK;
typedef typename COLLISION_GEOMETRY_COLLECTION_POLICY<T_GRID>::GRID_BASED_COLLISION_GEOMETRY T_GRID_BASED_COLLISION_GEOMETRY;
typedef typename INTERPOLATION_POLICY<T_GRID>::LINEAR_INTERPOLATION_MAC_HELPER T_LINEAR_INTERPOLATION_MAC_HELPER;
public:
const T_GRID_BASED_COLLISION_GEOMETRY& body_list;
const ARRAY<bool>* cell_valid_value_mask;
T2 default_cell_replacement_value;
bool extrapolate_to_invalid_cell_values;
LINEAR_INTERPOLATION_RLE<T_GRID,T2> interpolation;
LINEAR_INTERPOLATION_COLLIDABLE_CELL_RLE(const T_GRID_BASED_COLLISION_GEOMETRY& body_list_input,const ARRAY<bool>* cell_valid_value_mask_input,const T2& default_cell_replacement_value_input,
const bool extrapolate_to_invalid_cell_values_input=true)
:body_list(body_list_input),cell_valid_value_mask(cell_valid_value_mask_input),default_cell_replacement_value(default_cell_replacement_value_input),
extrapolate_to_invalid_cell_values(extrapolate_to_invalid_cell_values_input)
{}
void Set_Default_Replacement_Value(const T2& default_cell_replacement_value_input)
{default_cell_replacement_value=default_cell_replacement_value_input;}
T2 From_Block_Cell(const T_BLOCK& block,const ARRAY<T2>& u,const TV& X) const PHYSBAM_OVERRIDE
{bool interpolation_valid;return From_Block_Cell(block,u,X,interpolation_valid);}
T2 From_Block_Cell(const T_BLOCK& block,const ARRAY<T2>& u,const TV& X,bool& interpolation_valid) const
{assert(block.Inside(X));
if(!body_list.Occupied_Block(block)){interpolation_valid=true;return T_LINEAR_INTERPOLATION_MAC_HELPER::Interpolate_Cell(block,u,X);}
COLLISION_GEOMETRY_ID body_id;int aggregate_id;
if(body_list.Inside_Any_Simplex_Of_Any_Body(block,X,body_id,aggregate_id))
return Invalid_Value_Replacement(u,X,block,X,body_id,aggregate_id,interpolation_valid);
int valid_mask=0;T2 values[T_GRID::number_of_cells_per_block];
for(int k=0;k<T_GRID::number_of_cells_per_block;k++)
values[k]=Trace_And_Get_Value(block,u,X,k,valid_mask,1<<k);
if(extrapolate_to_invalid_cell_values) Extrapolate_To_Invalid_Values(u,X,block,values,valid_mask);
interpolation_valid=(valid_mask!=0);
return LINEAR_INTERPOLATION<T,T2>::Linear(values,(X-block.Minimum_Corner())*block.grid.uniform_grid.one_over_dX);}
protected:
T2 Trace_And_Get_Value(const T_BLOCK& block,const ARRAY<T2>& u,const TV& X,const int cell_in_block,int& valid_mask,const int mask_value=0) const
{TV intersection_point;COLLISION_GEOMETRY_ID body_id;int aggregate_id;
assert(cell_valid_value_mask);
int cell=block.Cell(cell_in_block);
if(body_list.Cell_Center_Intersection(block,cell_in_block,X,body_id,aggregate_id,intersection_point) || !(*cell_valid_value_mask)(cell))
return default_cell_replacement_value;
else{valid_mask|=mask_value;return u(cell);}}
virtual T2 Invalid_Value_Replacement(const ARRAY<T2>& u,const TV& X,const T_BLOCK& block,const TV& intersection_point,
const COLLISION_GEOMETRY_ID body_id,const int aggregate_id,bool& valid,const T ray_t_max=0) const
{valid=false;return default_cell_replacement_value;}
void Extrapolate_To_Invalid_Values(const ARRAY<T2>& u,const TV& X,const T_BLOCK& block,T2 values[T_GRID::number_of_cells_per_block],int& valid_mask) const
{static const int all_valid_mask=(1<<T_GRID::number_of_cells_per_block)-1,neighbor_mask=T_GRID::number_of_cells_per_block-1;
if(valid_mask==0) for(int t=0;t<T_GRID::number_of_cells_per_block;t++)values[t]=default_cell_replacement_value;
else if(valid_mask!=all_valid_mask){ // not everything is valid
for(int t=0;t<T_GRID::number_of_cells_per_block;t++)if(!(valid_mask&(1<<t))){
int ring;
for(ring=1;ring<T_GRID::dimension;ring++){ // one ring in 2d, one and then two ring in 3d
int ring_mask=ring==2?neighbor_mask:0;
T2 sum=T2();int count=0;
for(int n=0;n<T_GRID::dimension;n++){
int neighbor=t^(1<<n)^ring_mask;
if(valid_mask&(1<<neighbor)){count++;sum+=values[neighbor];}}
if(count>0){values[t]=sum/(T)count;break;}} // average valid ring neighbors
if(ring==T_GRID::dimension) values[t]=values[t^neighbor_mask];} // final ring (must be valid because valid_mask!=0)
valid_mask=all_valid_mask;}}
//#####################################################################
};
}
#endif
#endif
| [
"quhang@stanford.edu"
] | quhang@stanford.edu |
d5abc0db8e03c630bea178123ab0013434141f2c | 98157b3124db71ca0ffe4e77060f25503aa7617f | /codechef/sept16/chmtdv.cpp | dd718764d7fa3d37f947ab499b4264c3684933dc | [] | no_license | wiwitrifai/competitive-programming | c4130004cd32ae857a7a1e8d670484e236073741 | f4b0044182f1d9280841c01e7eca4ad882875bca | refs/heads/master | 2022-10-24T05:31:46.176752 | 2022-09-02T07:08:05 | 2022-09-02T07:08:35 | 59,357,984 | 37 | 4 | null | null | null | null | UTF-8 | C++ | false | false | 3,399 | cpp | #include <bits/stdc++.h>
using namespace std;
const int N = 505;
const long long inf = 1e9 * N * N + 5;
int a[N][N], n, p;
int h[N], v[N], ansh[N], ansv[N];
long long ans;
long long sumh[N][N], sumv[N][N];
long long sum[N];
int main() {
ans = 1e17;
int t = 17;
scanf("%d %d", &n, &p);
p--;
for (int i = 0; i < n; i++) {
sumh[i][0] = 0;
for (int j = 0; j < n; j++) {
scanf("%d", a[i]+j);
sumh[i][j+1] = sumh[i][j] + a[i][j];
}
}
for (int i = 0; i < n; i++) {
sumv[0][i];
for (int j = 0; j < n; j++) {
sumv[j+1][i] = sumv[j][i] + a[j][i];
}
}
for (int i = 0; i <= p; i++)
h[i] = i+1;
h[p] = n;
v[p] = n;
while (t--) {
long long lo = 0, hi = inf;
while (lo < hi) {
long long mid = (lo + hi) >> 1;
for (int i = 0; i <= p; i++)
sum[i] = 0;
int iv = 0;
bool ok = true;
for (int i = 0; i < n; i++) {
bool reset = false;
for (int j = 0; j <= p; j++) {
sum[j] += sumh[i][h[j]] - sumh[i][j ? h[j-1] : 0];
if (sum[j] > mid) {
reset = true;
}
}
if (reset) {
for (int j = 0; j <= p; j++) {
sum[j] = sumh[i][h[j]] - sumh[i][j ? h[j-1] : 0];
if (sum[j] > mid)
ok = false;
}
v[iv++] = i-1;
}
if (iv >= p) {
ok = false;
break;
}
}
if (ok)
hi = mid;
else
lo = mid + 1;
}
if (ans > lo) {
cerr << lo << endl;
ans = lo;
for (int i = 0; i <= p; i++) {
ansv[i] = v[i];
cerr << v[i] << " ";
}
for (int i = 0; i <= p; i++) {
ansh[i] = h[i];
cerr << h[i] << " ";
}
cerr << endl;
}
cerr << lo << " ";
lo = 0, hi = inf;
while (lo < hi) {
long long mid = (lo + hi) >> 1;
for (int i = 0; i <= p; i++)
sum[i] = 0;
int ih = 0;
bool ok = true;
for (int i = 0; i < n; i++) {
bool reset = false;
for (int j = 0; j <= p; j++) {
sum[j] += sumv[v[j]][i] - sumv[j ? v[j-1] : 0][i];
if (sum[j] > mid) {
reset = true;
}
}
if (reset) {
for (int j = 0; j <= p; j++) {
sum[j] = sumv[v[j]][i] - sumv[j ? v[j-1] : 0][i];
if (sum[j] > mid)
ok = false;
}
h[ih++] = i-1;
}
if (ih >= p) {
ok = false;
break;
}
}
if (ok)
hi = mid;
else
lo = mid + 1;
}
cerr << lo << endl;
if (ans > lo) {
cerr << lo << endl;
ans = lo;
for (int i = 0; i <= p; i++) {
ansv[i] = v[i];
cerr << v[i] << " ";
}
for (int i = 0; i <= p; i++) {
ansh[i] = h[i];
cerr << h[i] << " ";
}
cerr << endl;
}
}
memcpy(h, ansh, sizeof h);
memcpy(v, ansv, sizeof v);
h[0] = max(h[0], 1);
v[0] = max(v[0], 1);
for (int i = 1; i <= p; i++) {
h[i] = max(h[i], h[i-1] + 1);
v[i] = max(v[i], v[i-1] + 1);
}
h[p] = v[p] = n;
for (int i = p-1; i >= 0; i--) {
h[i] = min(h[i], h[i+1]-1);
v[i] = min(v[i], v[i+1]-1);
}
for (int i = 0; i < p; i++)
printf("%d ", h[i]);
printf("\n");
for (int i = 0; i < p; i++)
printf("%d ", v[i]);
printf("\n");
return 0;
} | [
"wiwitrifai@gmail.com"
] | wiwitrifai@gmail.com |
85d9242ca1dcf96409fabdb2c8110d62fd786032 | 90d253b075c47054ab1d6bf6206f37e810330068 | /CALICO/2022_fall/3/3.cpp | a5b2dde8de7ea39a02e8b1aca015251f4123283f | [
"MIT"
] | permissive | eyangch/competitive-programming | 45684aa804cbcde1999010332627228ac1ac4ef8 | de9bb192c604a3dfbdd4c2757e478e7265516c9c | refs/heads/master | 2023-07-10T08:59:25.674500 | 2023-06-25T09:30:43 | 2023-06-25T09:30:43 | 178,763,969 | 22 | 8 | null | null | null | null | UTF-8 | C++ | false | false | 523 | cpp | #include <bits/stdc++.h>
#define endl '\n'
#define eat cin
#define moo cout
#define int long long
using namespace std;
int T, W, O, B, OW, BO, BW;
int cost(int x, int y, int a, int b){
return x * a + y * b;
}
int32_t main(){
eat.tie(0) -> sync_with_stdio(0);
eat >> T;
while(T--){
eat >> W >> O >> B >> OW >> BO >> BW;
OW = min(OW, BO + BW);
BO = min(BO, OW + BW);
BW = min(BW, OW + BO);
int ans = 1e15;
ans = min({cost(O, B, OW, BW), cost(W, O, BW, BO), cost(W, B, OW, BO)});
moo << ans << endl;
}
} | [
"eyangch@gmail.com"
] | eyangch@gmail.com |
cc46adbbddc0d30f0d9c0ac6541108aafee955fb | a6f42311df3830117e9590e446b105db78fdbd3a | /src/framework/gui/Window.hpp | 4386fce6b57184b359ba1899e1e22aac488d6762 | [] | no_license | wellsoftware/temporal-lightfield-reconstruction | a4009b9da01b93d6d77a4d0d6830c49e0d4e225f | 8d0988b5660ba0e53d65e887a51e220dcbc985ca | refs/heads/master | 2021-01-17T23:49:05.544012 | 2011-09-25T10:47:49 | 2011-09-25T10:47:49 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 9,902 | hpp | /*
* Copyright (c) 2009-2011, NVIDIA Corporation
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* * Neither the name of NVIDIA Corporation nor the
* names of its contributors may be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#pragma once
#include "base/Array.hpp"
#include "base/String.hpp"
#include "base/Math.hpp"
#include "base/Hash.hpp"
#include "gui/Keys.hpp"
#include "base/DLLImports.hpp"
#include "gpu/GLContext.hpp"
namespace FW
{
//------------------------------------------------------------------------
class Window
{
public:
//------------------------------------------------------------------------
enum EventType
{
EventType_AddListener, /* Listener has been added to a window. */
EventType_RemoveListener, /* Listener has been removed from a window. */
EventType_Close, /* User has tried to close the window. */
EventType_Resize, /* The window has been resized. */
EventType_KeyDown, /* User has pressed a key (or mouse button). */
EventType_KeyUp, /* User has released a key (or mouse button). */
EventType_Char, /* User has typed a character. */
EventType_Mouse, /* User has moved the mouse. */
EventType_Paint, /* Window contents need to be painted. */
EventType_PrePaint, /* Before processing EventType_Paint. */
EventType_PostPaint, /* After processing EventType_Paint. */
};
//------------------------------------------------------------------------
struct Event
{
EventType type;
String key; /* Empty unless EventType_KeyDown or EventType_KeyUp. */
S32 keyUnicode; /* 0 unless EventType_KeyDown or EventType_KeyUp or if special key. */
S32 chr; /* Zero unless EventType_Text. */
bool mouseKnown; /* Unchanged unless EventType_Mouse. */
Vec2i mousePos; /* Unchanged unless EventType_Mouse. */
Vec2i mouseDelta; /* Zero unless EventType_Mouse. */
bool mouseDragging; /* One or more mouse buttons are down. */
Window* window;
};
//------------------------------------------------------------------------
class Listener
{
public:
Listener (void) {}
virtual ~Listener (void) {}
virtual bool handleEvent (const Event& ev) = 0;
};
//------------------------------------------------------------------------
public:
Window (void);
~Window (void);
void setTitle (const String& title);
void setSize (const Vec2i& size);
Vec2i getSize (void) const;
void setVisible (bool visible);
bool isVisible (void) const { return m_isVisible; }
void setFullScreen (bool isFull);
bool isFullScreen (void) const { return m_isFullScreen; }
void toggleFullScreen (void) { setFullScreen(!isFullScreen()); }
void realize (void);
void setGLConfig (const GLContext::Config& config);
const GLContext::Config& getGLConfig (void) const { return m_glConfig; }
GLContext* getGL (void); // also makes the context current
void repaint (void);
void repaintNow (void);
void requestClose (void);
void addListener (Listener* listener);
void removeListener (Listener* listener);
void removeListeners (void);
bool isKeyDown (const String& key) const { return m_keysDown.contains(key); }
bool isMouseKnown (void) const { return m_mouseKnown; }
bool isMouseDragging (void) const { return (m_mouseDragCount != 0); }
const Vec2i& getMousePos (void) const { return m_mousePos; }
void showMessageDialog (const String& title, const String& text);
String showFileDialog (const String& title, bool save, const String& filters = "", const String& initialDir = "", bool forceInitialDir = false); // filters = "ext:Title,foo;bar:Title"
String showFileLoadDialog (const String& title, const String& filters = "", const String& initialDir = "", bool forceInitialDir = false) { return showFileDialog(title, false, filters, initialDir, forceInitialDir); }
String showFileSaveDialog (const String& title, const String& filters = "", const String& initialDir = "", bool forceInitialDir = false) { return showFileDialog(title, true, filters, initialDir, forceInitialDir); }
void showModalMessage (const String& msg);
static void staticInit (void);
static void staticDeinit (void);
static HWND createHWND (void);
static UPTR setWindowLong (HWND hwnd, int idx, UPTR value);
static int getNumOpen (void) { return (s_inited) ? s_open->getSize() : 0; }
static void realizeAll (void);
static void pollMessages (void);
private:
Event createSimpleEvent (EventType type) { return createGenericEvent(type, "", 0, m_mouseKnown, m_mousePos); }
Event createKeyEvent (bool down, const String& key) { return createGenericEvent((down) ? EventType_KeyDown : EventType_KeyUp, key, 0, m_mouseKnown, m_mousePos); }
Event createCharEvent (S32 chr) { return createGenericEvent(EventType_Char, "", chr, m_mouseKnown, m_mousePos); }
Event createMouseEvent (bool mouseKnown, const Vec2i& mousePos) { return createGenericEvent(EventType_Mouse, "", 0, mouseKnown, mousePos); }
Event createGenericEvent (EventType type, const String& key, S32 chr, bool mouseKnown, const Vec2i& mousePos);
void postEvent (const Event& ev);
void create (void);
void destroy (void);
void recreate (void);
static LRESULT CALLBACK staticWindowProc (HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
LRESULT windowProc (UINT uMsg, WPARAM wParam, LPARAM lParam);
private:
Window (const Window&); // forbidden
Window& operator= (const Window&); // forbidden
private:
static bool s_inited;
static Array<Window*>* s_open;
static bool s_ignoreRepaint; // Prevents re-entering repaintNow() on Win32 or OpenGL failure.
HWND m_hwnd;
HDC m_hdc;
GLContext::Config m_glConfig;
bool m_glConfigDirty;
GLContext* m_gl;
bool m_isRealized;
bool m_isVisible;
Array<Listener*> m_listeners;
String m_title;
bool m_isFullScreen;
Vec2i m_pendingSize;
DWORD m_origStyle;
RECT m_origRect;
Set<String> m_keysDown;
bool m_pendingKeyFlush;
bool m_mouseKnown;
Vec2i m_mousePos;
S32 m_mouseDragCount;
S32 m_mouseWheelAcc;
Vec2i m_prevSize;
};
//------------------------------------------------------------------------
}
| [
"jiawen@csail.mit.edu"
] | jiawen@csail.mit.edu |
31403548c56ba7ae4b56d75895189671d3844327 | 6526a8b50dd4914678ced85d01feb7223f59825a | /application/filesystem/linux-fs-wrapper/source/llist.cpp | 935c87352799a7cf7e4ccf0756819eb6822be07d | [] | no_license | jcyuan78/filesystem_model_checking | e43cde33ba50a85c15da09a93aa99a698bd663e3 | 3665701e652c7e174f319d8e20000298c980caec | refs/heads/master | 2023-04-09T12:35:38.000062 | 2023-03-19T04:46:05 | 2023-03-19T04:46:05 | 200,018,811 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,868 | cpp | ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#include "pch.h"
// SPDX-License-Identifier: GPL-2.0-only
/*
* Lock-less NULL terminated single linked list
*
* The basic atomic operation of this list is cmpxchg on long. On
* architectures that don't have NMI-safe cmpxchg implementation, the
* list can NOT be used in NMI handlers. So code that uses the list in
* an NMI handler should depend on CONFIG_ARCH_HAVE_NMI_SAFE_CMPXCHG.
*
* Copyright 2010,2011 Intel Corp.
* Author: Huang Ying <ying.huang@intel.com>
*/
//#include <linux/kernel.h>
//#include <linux/export.h>
#include "../include/linux_comm.h"
#include "../include/llist.h"
/**
* llist_add_batch - add several linked entries in batch
* @new_first: first entry in batch to be added
* @new_last: last entry in batch to be added
* @head: the head for your lock-less list
*
* Return whether list is empty before adding.
*/
bool llist_add_batch(llist_node *new_first, llist_node *new_last, llist_head *head)
{
llist_node *first;
do
{
// new_last->next = first = READ_ONCE(head->first);
new_last->next = first = head->first;
}
// while (cmpxchg(&head->first, first, new_first) != first);
while (InterlockedCompareExchangePointer((PVOID*)(&head->first), new_first, first) != first);
return !first;
}
#if 0
/**
* llist_del_first - delete the first entry of lock-less list
* @head: the head for your lock-less list
*
* If list is empty, return NULL, otherwise, return the first entry
* deleted, this is the newest added one.
*
* Only one llist_del_first user can be used simultaneously with
* multiple llist_add users without lock. Because otherwise
* llist_del_first, llist_add, llist_add (or llist_del_all, llist_add,
* llist_add) sequence in another user may change @head->first->next,
* but keep @head->first. If multiple consumers are needed, please
* use llist_del_all or use lock between consumers.
*/
struct llist_node *llist_del_first(struct llist_head *head)
{
struct llist_node *entry, *old_entry, *next;
entry = smp_load_acquire(&head->first);
for (;;) {
if (entry == NULL)
return NULL;
old_entry = entry;
next = READ_ONCE(entry->next);
entry = cmpxchg(&head->first, old_entry, next);
if (entry == old_entry)
break;
}
return entry;
}
EXPORT_SYMBOL_GPL(llist_del_first);
/**
* llist_reverse_order - reverse order of a llist chain
* @head: first item of the list to be reversed
*
* Reverse the order of a chain of llist entries and return the
* new first entry.
*/
struct llist_node *llist_reverse_order(struct llist_node *head)
{
struct llist_node *new_head = NULL;
while (head) {
struct llist_node *tmp = head;
head = head->next;
tmp->next = new_head;
new_head = tmp;
}
return new_head;
}
EXPORT_SYMBOL_GPL(llist_reverse_order);
#endif | [
"bytekiller1978@hotmail.com"
] | bytekiller1978@hotmail.com |
0e1125153b5c40b9fd4710301bdbcd6d9e9192a9 | bc6c37cf0469c6b2778707b76227558b3a040718 | /UVA/UVA-Q11413-Fill_the_Containers.cpp | 67b137e4fadbb2e6c2823a879f9dc47d9fa3bb0a | [] | no_license | zeroplusone/AlgorithmPractice | 241530a5c989f6321543f7bd07a393c405cdf2e6 | 7fe9182d943bc2066f7fd31cc05096be79dc12cb | refs/heads/master | 2022-01-28T21:57:04.393943 | 2022-01-26T13:46:43 | 2022-01-26T13:46:43 | 84,074,414 | 2 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 753 | cpp | #include<iostream>
#include<cstdlib>
#include<cstdio>
using namespace std;
#define MAX 1010
long long int milk[MAX];
int n,m;
bool canbe(int num)
{
long long int sum=0;
int c=0;
for(int i=0;i<n;++i)
{
if(sum<=num)
sum+=milk[i];
else
{
sum=0;
c++;
}
}
if(c<=m)
return true;
else
return false;
}
int main()
{
while(scanf("%d %d",&n,&m)!=EOF)
{
for(int i=0;i<n;++i)
scanf("%lld",&milk[i]);
long long int left=0,right=0;
for(int i=0;i<n;++i)
{
right+=milk[i];
if(milk[i]>left)
left=milk[i];
}
int mid;
do
{
mid=(left+right)/2;
if(canbe(mid))
right=mid;
else
left=mid+1;
}while(left<right);
}
return 0;
} | [
"a711186@gmail.com"
] | a711186@gmail.com |
ae0a07a12d5b477a2b6feb9f0dc2a56a8ea2fc18 | 986959b15d763745518085bdb5106daeb4e0b41d | /Volume - 4 (400 - 434)/419 - Middle Number(s).cpp | 963611096ff74fd426bebf739c3d0889a698aa91 | [] | no_license | Md-Sabbir-Ahmed/Outsbook | a19d314b481d5f2e57478c98b0fe50d08781310c | e3b2c54517de3badff96f96d99d1592db7286513 | refs/heads/master | 2022-11-07T06:43:37.955730 | 2020-06-26T20:32:03 | 2020-06-26T20:32:03 | 267,264,610 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 274 | cpp | #include<bits/stdc++.h>
using namespace std;
int main()
{
long long n;
while(cin>>n)
{
if(n%2==1)
{
cout<<(n/2)+1<<"\n";
}
else
{
cout<<(n/2)<<" "<<(n/2)+1<<"\n";
}
}
return 0;
}
| [
"sabbir106706@gmail.com"
] | sabbir106706@gmail.com |
54d1379e178a242636fd23d2a3a0419b5b00a2af | 20698f2460bc8a4d21442cc5d4eac8cca15c105a | /ElDorito/Source/Patches/Hf2pExperimental.cpp | 38c7bf183c8bbde557efa491181538a5b311ebe2 | [] | no_license | num0005/ElDorito | 957318d00dba4c92c2696256700f4acfe48481ec | 5c00f797b557dbe112472a20f236bbf5fcc16371 | refs/heads/master | 2020-12-02T08:09:35.602887 | 2017-07-08T19:52:56 | 2017-07-08T19:54:47 | 96,777,515 | 3 | 0 | null | 2017-07-10T12:56:59 | 2017-07-10T12:56:59 | null | UTF-8 | C++ | false | false | 7,094 | cpp | #pragma once
#include "Hf2pExperimental.hpp"
#include "../Blam/BlamInput.hpp"
#include "../Modules/ModuleSettings.hpp"
#include "../Modules/ModuleServer.hpp"
#include "../ElDorito.hpp"
#include "../Patches/Ui.hpp"
#include "../Patches/Core.hpp"
#include "../Patches/Armor.hpp"
#include "../Web/Ui/ScreenLayer.hpp"
#include "../Web/Ui/WebTimer.hpp"
#include "../ElDorito.hpp"
#include "../Blam/BlamPlayers.hpp"
#include "../Blam/BlamTime.hpp"
namespace
{
void Hf2pInitHook();
void Hf2pShutdownHook();
void Hf2pTickHook();
void Hf2pLoadPreferencesHook();
void UI_StartMenuScreenWidget_OnDataItemSelectedHook();
void OnMapLoaded(const char *mapPath);
}
namespace Patches
{
void Hf2pExperimental::ApplyAll()
{
Hook(0x200630, Hf2pInitHook).Apply();
// we no longer have sound_config.ps
Patch(0x04858, { 0x90, 0x90 }).Apply();
// skip over vfiles_plugin load
Patch(0x010F1121, { 0xE9 }).Apply();
// skip anti-cheat, watermark, account stuff
Patch(0x200732, { 0xEB }).Apply();
Hook(0x200790, Hf2pShutdownHook).Apply();
Hook(0x105F0D, Hf2pTickHook, HookFlags::IsCall).Apply();
Hook(0x10CB01, Hf2pLoadPreferencesHook, HookFlags::IsCall).Apply();
Hook(0x6F740E, UI_StartMenuScreenWidget_OnDataItemSelectedHook).Apply();
Patches::Core::OnMapLoaded(OnMapLoaded);
}
}
namespace
{
using namespace Blam::Input;
const auto UI_ScreenWidget_Close = (void(__thiscall *)(void *thisptr, int a2))(0x00AB2830);
const auto UI_ScreenManager_GetScreenWidget = (void* (__thiscall *)(void *thisptr, int a2, uint32_t nameId))(0x00AAB550);
const auto UI_ScreenManager_AnyActiveScreens = (bool(__thiscall *)(void *thisptr, int a2))(0x00AAA970);
const auto UI_GetScreenManager = (void*(*)())(0x00AAD930);
void Hf2pInitHook()
{
*(uint32_t*)0x50CCB3C = 0;
*(uint32_t*)0x244ED28 = 0;
// InitSoundSystem
((void(*)())(0x64E190))();
}
void Hf2pShutdownHook()
{
// ShutdownSoundSystem
((void(*)())(0x652EE0))();
}
void SystemMenu()
{
static auto IsMainMenu = (bool(*)())(0x531E90);
if (IsMainMenu())
return;
auto uiStartAction = Blam::Input::GetActionState(eGameActionUiStart);
if (!(uiStartAction->Flags & eActionStateFlagsHandled) && uiStartAction->Ticks == 1)
{
auto screenManager = (void*)0x05260F34;
if (!UI_ScreenManager_AnyActiveScreens(screenManager, 0))
{
uiStartAction->Flags |= eActionStateFlagsHandled;
Patches::Ui::ShowDialog(0x10084, 0, 4, 0x1000C);
}
}
}
int GetSecondsRemainingUntilPlayerSpawn()
{
auto playerIndex = Blam::Players::GetLocalPlayer(0);
const auto player = Blam::Players::GetPlayers().Get(Blam::Players::GetLocalPlayer(0));
return player ? Pointer(player)(0x2CBC).Read<int32_t>() : 0;
}
void Hf2pTickHook()
{
static auto InPrematchState = (bool(*)(char state))(0x005523A0);
static auto UpdatePreMatchCamera = (bool(*)())(0x72D580);
static auto InitMpDirector = (void(*)())(0x0072D560);
static auto IsMapLoading = (bool(*)())(0x005670E0);
static auto IsMainMenu = (bool(*)())(0x00531E90);
static auto s_MatchStarted = false;
static auto s_TimerStarted = false;
static auto s_TimerLastTicked = 0;
auto secondsUntilPlayerSpawn = GetSecondsRemainingUntilPlayerSpawn();
// update pre-match camera
if (InPrematchState(4))
{
if (!s_TimerStarted && secondsUntilPlayerSpawn > 0)
{
s_TimerStarted = true;
s_TimerLastTicked = Blam::Time::GetGameTicks();
Web::Ui::WebTimer::Start("startTimer", secondsUntilPlayerSpawn);
}
s_MatchStarted = UpdatePreMatchCamera();
}
else if (s_MatchStarted)
{
InitMpDirector();
s_MatchStarted = false;
}
else
{
if (!s_TimerStarted && secondsUntilPlayerSpawn > 0)
{
s_TimerStarted = true;
s_TimerLastTicked = Blam::Time::GetGameTicks();
Web::Ui::WebTimer::Start("respawnTimer", secondsUntilPlayerSpawn);
}
}
if (s_TimerStarted)
{
static auto s_LastTimerValue = 0;
auto secondsUntilSpawn = GetSecondsRemainingUntilPlayerSpawn();
if (secondsUntilSpawn != s_LastTimerValue)
{
s_LastTimerValue = secondsUntilSpawn;
s_TimerLastTicked = Blam::Time::GetGameTicks();
Web::Ui::WebTimer::Update(secondsUntilSpawn);
if (secondsUntilSpawn <= 0)
{
s_TimerStarted = false;
Web::Ui::WebTimer::End();
}
}
// TODO: find a better game ended indication
if (IsMapLoading())
{
s_TimerStarted = false;
Web::Ui::WebTimer::End();
}
}
if (!IsMapLoading())
{
if (IsMainMenu())
{
// armour customizations on mainmenu
Patches::Armor::UpdateUiPlayerModelArmor();
}
else
{
// pause menu
SystemMenu();
}
}
}
void CloseScreen(void* screenManager, uint32_t id)
{
const auto screen = UI_ScreenManager_GetScreenWidget(screenManager, 4, id);
if (screen)
UI_ScreenWidget_Close(screen, 0);
}
bool StartMenu_OnDataItemSelected(uint32_t nameId)
{
switch (nameId)
{
case 0x4055: // control_settings
CloseScreen(UI_GetScreenManager(), 0x10084);
Web::Ui::ScreenLayer::Show("settings", "{}");
return true;
}
return false;
}
__declspec(naked) void UI_StartMenuScreenWidget_OnDataItemSelectedHook()
{
__asm
{
push[ebp - 4]
call StartMenu_OnDataItemSelected
test al, al
jz DEFAULT
add esp, 4
xor eax, eax
pop ebx
mov esp, ebp
pop ebp
retn 0x10
DEFAULT:
mov eax, 0xAF7436
jmp eax
}
}
uint32_t LevelStringToInt(const std::string& value)
{
return value == "low" ? 0 : value == "medium" ? 1 : 2;
}
void Hf2pLoadPreferencesHook()
{
static auto Hf2pLoadPreferences = (void(*)())(0x50C830);
Hf2pLoadPreferences();
auto preferencesPtr = ElDorito::GetMainTls(0x18)[0];
if (!preferencesPtr)
return;
auto& moduleSettings = Modules::ModuleSettings::Instance();
int screenResolutionWidth, screenResolutionHeight;
moduleSettings.GetScreenResolution(&screenResolutionWidth, &screenResolutionHeight);
// a step towards eliminating the need preferences.dat at least for settings
preferencesPtr(0x41BCC).Write<uint32_t>(moduleSettings.VarFullscreen->ValueInt);
preferencesPtr(0x41C50).Write<uint32_t>(moduleSettings.VarMasterVolume->ValueInt);
preferencesPtr(0x41C58).Write<uint32_t>(moduleSettings.VarMusicVolume->ValueInt);
preferencesPtr(0x41C54).Write<uint32_t>(moduleSettings.VarSfxVolume->ValueInt);
preferencesPtr(0x41BE0).Write<uint32_t>(screenResolutionWidth);
preferencesPtr(0x41BE4).Write<uint32_t>(screenResolutionHeight);
}
void OnMapLoaded(const char* map)
{
const auto soundSystemPtr = (uint8_t**)(0x018BC9C8);
if (!soundSystemPtr)
return;
const auto& mapStr = std::string(map);
const std::string mainmenu("mainmenu");
if (mapStr.length() >= mainmenu.length() && std::equal(mainmenu.rbegin(), mainmenu.rend(), mapStr.rbegin()))
{
// play main menu music from wigl
static auto PlayMainMenuMusic = (void(__thiscall *)(void *thisptr))(0xAD5820);
PlayMainMenuMusic((void*)0x5255A0C);
// mute ambient sounds on the maim menu
*(float*)((*soundSystemPtr) + 0x44) = 0.0f;
}
else
{
*(float*)((*soundSystemPtr) + 0x44) = 1.0f;
}
}
}
| [
"unk0x4@gmail.com"
] | unk0x4@gmail.com |
bd7fd36186b469d971926691f6e6e02c581cb4c6 | 584ca4da32b0e70a2702b5b16222d3d9475cd63a | /src/netfulfilledman.h | ada8bc07c78d28d517e5f9e0c30fc0a15060d869 | [
"MIT"
] | permissive | IluminumProject/iluminum | d87e14cbeb0873fc7b1e42968cb039ecf2b4e03d | 9685edf64161c66205c89ee72d711b0144733735 | refs/heads/master | 2020-03-10T08:55:36.095447 | 2018-04-21T15:56:18 | 2018-04-21T15:56:18 | 128,815,453 | 0 | 0 | MIT | 2018-04-12T07:00:53 | 2018-04-09T18:19:59 | C++ | UTF-8 | C++ | false | false | 1,536 | h | // Copyright (c) 2014-2017 The Iluminum Core developers
// Distributed under the MIT/X11 software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
#ifndef NETFULFILLEDMAN_H
#define NETFULFILLEDMAN_H
#include "netbase.h"
#include "protocol.h"
#include "serialize.h"
#include "sync.h"
class CNetFulfilledRequestManager;
extern CNetFulfilledRequestManager netfulfilledman;
// Fulfilled requests are used to prevent nodes from asking for the same data on sync
// and from being banned for doing so too often.
class CNetFulfilledRequestManager
{
private:
typedef std::map<std::string, int64_t> fulfilledreqmapentry_t;
typedef std::map<CNetAddr, fulfilledreqmapentry_t> fulfilledreqmap_t;
//keep track of what node has/was asked for and when
fulfilledreqmap_t mapFulfilledRequests;
CCriticalSection cs_mapFulfilledRequests;
public:
CNetFulfilledRequestManager() {}
ADD_SERIALIZE_METHODS;
template <typename Stream, typename Operation>
inline void SerializationOp(Stream& s, Operation ser_action, int nType, int nVersion) {
LOCK(cs_mapFulfilledRequests);
READWRITE(mapFulfilledRequests);
}
void AddFulfilledRequest(CAddress addr, std::string strRequest); // expire after 1 hour by default
bool HasFulfilledRequest(CAddress addr, std::string strRequest);
void RemoveFulfilledRequest(CAddress addr, std::string strRequest);
void CheckAndRemove();
void Clear();
std::string ToString() const;
};
#endif
| [
"4mindsmine@gmail.com"
] | 4mindsmine@gmail.com |
aa9b1555fbe4b3079b3499e5409c00a1c27e1c41 | d607fa153791e1c37e22e5ae4f3732cc329327ff | /src/CCondition.cpp | 99ebe751c746444501a97575404360afe4d703c2 | [] | no_license | qiubin2016/ThreadPool | e611c0b11d442e8b918178bdd75ca65ec9fc47a6 | 4ecb6960d2d29a30270259ae89a5720543a905a2 | refs/heads/master | 2020-03-21T00:34:26.061601 | 2018-06-19T17:17:43 | 2018-06-19T17:17:43 | 137,899,188 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,012 | cpp | /*
* CCondition.cpp
*
* Created on: 2017年2月16日
* Author: qb
*/
#include "CCondition.h"
CCondition::CCondition()
{
CondCreate(&m_Cond);
}
CCondition::~CCondition()
{
CondDestroy(&m_Cond);
}
void CCondition::Wait(CMutex &Mutex)
{
CondWait(&m_Cond, &Mutex.GetMutex());
}
void CCondition::Wait(CMutex &Mutex, unsigned int uiMs)
{
struct timespec Tsp;
maketimeout(&Tsp, uiMs);
CondTimedWait(&m_Cond, &Mutex.GetMutex(), &Tsp);
}
void CCondition::Signal()
{
CondSignal(&m_Cond);
}
void CCondition::BroadCast()
{
CondBroadCast(&m_Cond);
}
void CCondition::maketimeout(struct timespec *pTsp, unsigned int ulMs)
{
struct timeval now;
//get the current time
gettimeofday(&now, NULL);
// gettimeofday(&now);
pTsp->tv_sec = now.tv_sec;
//usec to nsec
pTsp->tv_nsec = now.tv_usec * 1000;
//add the offset to get timeout valude
pTsp->tv_nsec += (ulMs % 1000) * 1000000L;
pTsp->tv_sec += (ulMs / 1000) + (pTsp->tv_nsec / 1000000000L);
pTsp->tv_nsec = pTsp->tv_nsec % 1000000000L;
}
| [
"cust@custVBOX.(none)"
] | cust@custVBOX.(none) |
701c91da7b4a6c3351b8b092935358885cab2d0b | 1ae9432cbb3a2ddf1327eb75c60cf87ab19b7a8f | /HYPlayer/video_player/demux/DemuxLooper.cpp | b17e36089ec09ec4df00d5f908055c7db7df1b6c | [] | no_license | chongbo2013/IOS_HYPlayer | 4652e93866d63e385c85866daf3da7aeb165d290 | 027787c2e21c1e086e4fe0eecedc9346da1054ce | refs/heads/master | 2022-04-04T06:35:24.587702 | 2020-03-01T07:58:42 | 2020-03-01T07:58:42 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,229 | cpp | //
// DemuxLooper.cpp
// HYPlayer
//
// Created by templechen on 2020/2/21.
// Copyright © 2020 templechen. All rights reserved.
//
#include "DemuxLooper.hpp"
#include "FFVideoDemux.h"
DemuxLooper::DemuxLooper(circle_av_packet_queue *queue, bool isAudio) {
this->queue = queue;
this->isAudio = isAudio;
}
DemuxLooper::~DemuxLooper() {
}
void DemuxLooper::handleMessage(Looper::LooperMessage *msg) {
switch (msg->what) {
case kMsgDemuxCreated: {
if (demux == nullptr) {
demux = new FFVideoDemux();
demux->packetQueue = queue;
}
demux->init((const char *) msg->obj);
demux->isDemuxing = true;
demux->start();
break;
};
case kMsgDemuxSeek: {
demux->seek((long) msg->obj);
break;
}
case kMsgDemuxRelease: {
demux->release();
quit();
break;
}
default: {
break;
}
}
}
long DemuxLooper::getTotalDuration() {
if (demux != nullptr) {
return static_cast<long>(demux->totalDuration);
}
return 0L;
}
void DemuxLooper::pthreadExit() {
delete this;
}
| [
"weichen@narvii.com"
] | weichen@narvii.com |
7cf91c0ca889bc477bb4303982479d57c50146a9 | c238d370c8259897b8c3b95a12c81e4d8691de64 | /src/rx/material/loader.h | 4b3ea393f1bd9bfa0e8926497e7d11ff1c70b162 | [
"MIT"
] | permissive | ttvd/rex | 4f66966166c422b7c7c356e764bdff3fcf11e800 | bfe49a11e255e7be9e739641924adad2fd82a861 | refs/heads/main | 2022-11-25T23:04:23.994615 | 2020-08-04T13:55:55 | 2020-08-04T13:55:55 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,591 | h | #ifndef RX_MATERIAL_LOADER_H
#define RX_MATERIAL_LOADER_H
#include "rx/core/vector.h"
#include "rx/core/map.h"
#include "rx/math/transform.h"
#include "rx/material/texture.h"
namespace Rx {
struct JSON;
struct Stream;
}
namespace Rx::Material {
struct Loader {
RX_MARK_NO_COPY(Loader);
Loader(Memory::Allocator& _allocator);
Loader(Loader&& loader_);
void operator=(Loader&& loader_);
bool load(Stream* _stream);
bool load(const String& _file_name);
bool parse(const JSON& _definition);
constexpr Memory::Allocator& allocator() const;
Vector<Texture>&& textures();
String&& name();
bool alpha_test() const;
bool has_alpha() const;
bool no_compress() const;
Float32 roughness() const;
Float32 metalness() const;
const Optional<Math::Transform>& transform() const &;
private:
template<typename... Ts>
bool error(const char* _format, Ts&&... _arguments) const;
template<typename... Ts>
void log(Log::Level _level, const char* _format, Ts&&... _arguments) const;
void write_log(Log::Level _level, String&& message_) const;
bool parse_textures(const JSON& _textures);
enum {
k_alpha_test = 1 << 0,
k_has_alpha = 1 << 1,
k_no_compress = 1 << 2
};
Memory::Allocator* m_allocator;
Vector<Texture> m_textures;
String m_name;
Uint32 m_flags;
Float32 m_roughness;
Float32 m_metalness;
Optional<Math::Transform> m_transform;
};
RX_HINT_FORCE_INLINE constexpr Memory::Allocator& Loader::allocator() const {
return *m_allocator;
}
inline Vector<Texture>&& Loader::textures() {
return Utility::move(m_textures);
}
inline String&& Loader::name() {
return Utility::move(m_name);
}
inline bool Loader::alpha_test() const {
return m_flags & k_alpha_test;
}
inline bool Loader::has_alpha() const {
return m_flags & k_has_alpha;
}
inline bool Loader::no_compress() const {
return m_flags & k_no_compress;
}
inline Float32 Loader::roughness() const {
return m_roughness;
}
inline Float32 Loader::metalness() const {
return m_metalness;
}
inline const Optional<Math::Transform>& Loader::transform() const & {
return m_transform;
}
template<typename... Ts>
inline bool Loader::error(const char* _format, Ts&&... _arguments) const {
log(Log::Level::k_error, _format, Utility::forward<Ts>(_arguments)...);
return false;
}
template<typename... Ts>
inline void Loader::log(Log::Level _level, const char* _format,
Ts&&... _arguments) const
{
write_log(_level, String::format(_format, Utility::forward<Ts>(_arguments)...));
}
} // namespace rx::material
#endif // RX_MATERIAL_LOADER_H
| [
"weilercdale@gmail.com"
] | weilercdale@gmail.com |
c69ec2b6a19738255961cb7e94cb9b3d5a333362 | cf95c635a115d2c5f0f8b2c15ea3cc8061a34887 | /TwilveQt/twqcell.h | fde2bbf12fe60edd177548605b1f356b907caaaa | [
"CC-BY-3.0"
] | permissive | degarashi/TwilveQt | 49c9cc7247e32cec15e6764f2298a09c3d5e383d | bb98c29487f1088cce71063a4cafc7cd8ab58610 | refs/heads/master | 2020-12-24T12:01:57.598744 | 2013-03-14T12:00:25 | 2013-04-04T01:43:52 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,429 | h | #ifndef TWQCELL_H
#define TWQCELL_H
#include <QString>
#include <QLabel>
#include <cstdint>
#include <memory>
#include "common.h"
class QFrame;
class QPixmap;
class QMouseEvent;
class QHBoxLayout;
class QVBoxLayout;
// QLabelにクリック検知を追加
class CLabel : public QLabel {
Q_OBJECT
uint64_t _id; //!< TweetID 又は UserID
protected:
void mousePressEvent(QMouseEvent *e);
signals:
void clickedUser(UserID id, bool bR);
void clickedTweet(TweetID id, bool bR);
public:
explicit CLabel(uint64_t id);
};
class TwqCell;
class TwqTL;
//! TwqCellの装飾チェック
class IFCellChecker {
public:
virtual ~IFCellChecker() {}
virtual bool check(const TwqTL& tl, TweetID id) const = 0;
};
//! TwqCellの装飾
class IFCellDecorator {
public:
virtual ~IFCellDecorator() {}
virtual void modify(const TwqTL& tl, TwqCell& cell) const = 0;
virtual void unmodify(const TwqTL& tl, TwqCell& cell) const = 0;
};
//! CheckFlag + Decorator
class CellMod {
typedef std::unique_ptr<IFCellChecker> UPCheck;
typedef std::unique_ptr<IFCellDecorator> UPDeco;
QString _name;
uint32_t _priority;
UPCheck _checker;
UPDeco _deco;
public:
CellMod(CellMod&& c);
//! chkとdecoの所有権を持つ
CellMod(const QString& name, uint32_t prio, IFCellChecker* chk, IFCellDecorator* deco);
//! 条件判定の後に装飾
void checkAndModify(const TwqTL& tl, TwqCell& cell) const;
void unModify(const TwqTL& tl, TwqCell& cell) const;
void swap(CellMod& c) noexcept;
uint32_t getPrio() const;
};
namespace std {
template <>
inline void swap<CellMod>(CellMod& c0, CellMod& c1) {
c0.swap(c1);
}
}
#define DEF_CCHECK(Name) class Name : public IFCellChecker { \
public: \
bool check(const TwqTL& tl, TweetID id) const override; \
};
// HomeTLとSearchTLでは判定方法が異なる
//! 他人のRT
DEF_CCHECK(CcRT)
//! 自分のFav
DEF_CCHECK(CcMyFav)
//! 自分のRT
DEF_CCHECK(CcMyRT)
//! 選択中かどうか
DEF_CCHECK(CcSelect)
//! バックグラウンドを単色で装飾
class CdColor : public IFCellDecorator {
QColor _colorBG,
_colorText;
public:
CdColor(QColor colBG=QColor(), QColor colText=QColor()): _colorBG(colBG), _colorText(colText) {}
void modify(const TwqTL& tl, TwqCell& cell) const override;
void unmodify(const TwqTL& tl, TwqCell& cell) const override;
};
//! バーにアイコンを置く装飾
class CdIcon : public IFCellDecorator {
private:
QPixmap _icon;
QString _name;
public:
CdIcon(const QPixmap& p, const QString& name);
void modify(const TwqTL& tl, TwqCell& cell) const override;
void unmodify(const TwqTL& tl, TwqCell& cell) const override;
};
//! TwqTweetを表示するクラス
class TwqCell : public QFrame {
Q_OBJECT
QHBoxLayout *_loIconTw,
*_loSub,
*_loTray;
QVBoxLayout* _loMainSub;
TweetID _twID;
// user icon
CLabel *_lbIcon;
QLabel *_lbTweet,
*_lbScreen_name, *_lbName,
*_lbSource, *_lbDate;
// for Fav/RT icons
QFrame* _frIcon;
SPVoid _spVoid;
protected:
void mousePressEvent(QMouseEvent *e);
signals:
void clicked(TweetID twID, bool bR);
void userClicked(UserID uid, bool bR);
public:
explicit TwqCell(TweetID twID, QWidget* parent=nullptr);
void setTweet(TweetID twID);
TweetID id() const;
int cellHeight(int w) const;
QVBoxLayout* boxLayout();
QHBoxLayout* iconTray();
void applyMods(const TwqTL& tl, const std::vector<CellMod>& mods);
};
#endif // TWQCELL_H
| [
"slice013@gmail.com"
] | slice013@gmail.com |
d47f91d2fef49bc32288a1a8c03ea07ccd455bdf | 4b73a36745e969cf9d222c111d1baa39cb3d254a | /test/autogen/smp@list@pop_front.cpp | 48566830624f309dec745af16159adca7697bfa0 | [
"MIT"
] | permissive | Ornito/jln.mp | f3cc94e7b34523d40777171c5d38fdb2c817287e | 9553e3d3bc6424f8cfc4e550fdab5ec94d97594e | refs/heads/master | 2023-05-05T02:51:29.101364 | 2021-05-22T22:40:31 | 2021-05-22T22:40:31 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 41 | cpp | #include "jln/mp/smp/list/pop_front.hpp"
| [
"jonathan.poelen@gmail.com"
] | jonathan.poelen@gmail.com |
1a756112dae5c81756c6b2af2024c894ef4fdf51 | efe782244cba07b683c4ac92df3fd029d538fe5f | /src/pow.cpp | 8a6e01178d3c3136518ccaf5f70109819d05838a | [
"MIT"
] | permissive | Kimax89/wallet-unofficial | 9fc248f40156e5f49f6cc14cb7e862149883909b | 70dfb876366eba4cb5d38d5274f7f1617ae742db | refs/heads/master | 2023-02-19T08:16:55.213287 | 2021-01-24T14:08:27 | 2021-01-24T14:08:27 | 332,015,826 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 12,003 | cpp | // Copyright (c) 2009-2010 Satoshi Nakamoto
// Copyright (c) 2009-2016 The Bitcoin Core developers
// Copyright (c) 2017 The Bitcoin developers
// Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
#include "pow.h"
#include "arith_uint256.h"
#include "chain.h"
#include "primitives/block.h"
#include "uint256.h"
#include "util.h"
/**
* Compute the next required proof of work using the legacy Bitcoin difficulty
* adjustement + Emergency Difficulty Adjustement (EDA).
*/
static uint32_t GetNextEDAWorkRequired(const CBlockIndex *pindexPrev,
const CBlockHeader *pblock,
const Consensus::Params ¶ms) {
// Only change once per difficulty adjustment interval
uint32_t nHeight = pindexPrev->nHeight + 1;
if (nHeight % params.DifficultyAdjustmentInterval() == 0) {
// Go back by what we want to be 14 days worth of blocks
assert(nHeight >= params.DifficultyAdjustmentInterval());
uint32_t nHeightFirst = nHeight - params.DifficultyAdjustmentInterval();
const CBlockIndex *pindexFirst = pindexPrev->GetAncestor(nHeightFirst);
assert(pindexFirst);
return CalculateNextWorkRequired(pindexPrev,
pindexFirst->GetBlockTime(), params);
}
const uint32_t nProofOfWorkLimit =
UintToArith256(params.powLimit).GetCompact();
if (params.fPowAllowMinDifficultyBlocks) {
// Special difficulty rule for tnet:
// If the new block's timestamp is more than 2* 10 minutes then allow
// mining of a min-difficulty block.
if (pblock->GetBlockTime() >
pindexPrev->GetBlockTime() + 2 * params.nPowTargetSpacing) {
return nProofOfWorkLimit;
}
// Return the last non-special-min-difficulty-rules-block
const CBlockIndex *pindex = pindexPrev;
while (pindex->pprev &&
pindex->nHeight % params.DifficultyAdjustmentInterval() != 0 &&
pindex->nBits == nProofOfWorkLimit) {
pindex = pindex->pprev;
}
return pindex->nBits;
}
// We can't go bellow the minimum, so early bail.
uint32_t nBits = pindexPrev->nBits;
if (nBits == nProofOfWorkLimit) {
return nProofOfWorkLimit;
}
// If producing the last 6 block took less than 12h, we keep the same
// difficulty.
const CBlockIndex *pindex6 = pindexPrev->GetAncestor(nHeight - 7);
assert(pindex6);
int64_t mtp6blocks =
pindexPrev->GetMedianTimePast() - pindex6->GetMedianTimePast();
if (mtp6blocks < 12 * 3600) {
return nBits;
}
// If producing the last 6 block took more than 12h, increase the difficulty
// target by 1/4 (which reduces the difficulty by 20%). This ensure the
// chain do not get stuck in case we lose hashrate abruptly.
arith_uint256 nPow;
nPow.SetCompact(nBits);
nPow += (nPow >> 2);
// Make sure we do not go bellow allowed values.
const arith_uint256 bnPowLimit = UintToArith256(params.powLimit);
if (nPow > bnPowLimit) nPow = bnPowLimit;
return nPow.GetCompact();
}
uint32_t GetNextWorkRequired(const CBlockIndex *pindexPrev,
const CBlockHeader *pblock,
const Consensus::Params ¶ms) {
const int nHeight = pindexPrev->nHeight;
// Genesis block
if (pindexPrev == nullptr) {
return UintToArith256(params.powLimit).GetCompact();
}
// Special rule for tnet for first 150 blocks
if (params.fPowAllowMinDifficultyBlocks && nHeight <= 150) {
return 0x201fffff;
}
// Special rule for regtest: we never retarget.
if (params.fPowNoRetargeting) {
return pindexPrev->nBits;
}
if (pindexPrev->GetMedianTimePast() >= params.coreHardForkActivationTime) {
// Get around fork difficulty from Sha256 to Blake2b
// (836750 and up + 1 >= 836751) && (836751 through 836760) < 836751 + 10)
if (((nHeight + 1) >= params.powBlake2Height) &&
((nHeight + 1) < (params.powBlake2Height + 10))) {
return 0x1b0ffff0;
}
// Get around high difficulty from plugging 0x21 version block exploit
// If (915000 and up >= 915000) && (915000 through 915034) < 915000 + 35)
// if previous height between 915000 and 915034 next height target 1b013833
if ((nHeight >= params.plug0x21ExploitHeight) &&
(nHeight < (params.plug0x21ExploitHeight + 35))) {
return 0x1b013833;
}
return GetNextCoreWorkRequired(pindexPrev, pblock, params);
}
return GetNextEDAWorkRequired(pindexPrev, pblock, params);
}
uint32_t CalculateNextWorkRequired(const CBlockIndex *pindexPrev,
int64_t nFirstBlockTime,
const Consensus::Params ¶ms) {
if (params.fPowNoRetargeting) {
return pindexPrev->nBits;
}
// Limit adjustment step
int64_t nActualTimespan = pindexPrev->GetBlockTime() - nFirstBlockTime;
if (nActualTimespan < params.nPowTargetTimespan / 4) {
nActualTimespan = params.nPowTargetTimespan / 4;
}
if (nActualTimespan > params.nPowTargetTimespan * 4) {
nActualTimespan = params.nPowTargetTimespan * 4;
}
// Retarget
const arith_uint256 bnPowLimit = UintToArith256(params.powLimit);
arith_uint256 bnNew;
bnNew.SetCompact(pindexPrev->nBits);
bnNew *= nActualTimespan;
bnNew /= params.nPowTargetTimespan;
if (bnNew > bnPowLimit) bnNew = bnPowLimit;
return bnNew.GetCompact();
}
bool CheckProofOfWork(uint256 hash, uint32_t nBits,
const Consensus::Params ¶ms) {
bool fNegative;
bool fOverflow;
arith_uint256 bnTarget;
bnTarget.SetCompact(nBits, &fNegative, &fOverflow);
// Check range
if (fNegative || bnTarget == 0 || fOverflow ||
bnTarget > UintToArith256(params.powLimit)) {
return false;
}
// Check proof of work matches claimed amount
if (UintToArith256(hash) > bnTarget) {
return false;
}
return true;
}
/**
* Compute the a target based on the work done between 2 blocks and the time
* required to produce that work.
*/
static arith_uint256 ComputeTarget(const CBlockIndex *pindexFirst,
const CBlockIndex *pindexLast,
const Consensus::Params ¶ms) {
assert(pindexLast->nHeight > pindexFirst->nHeight);
/**
* From the total work done and the time it took to produce that much work,
* we can deduce how much work we expect to be produced in the targeted time
* between blocks.
*/
arith_uint256 work = pindexLast->nChainWork - pindexFirst->nChainWork;
// In order to avoid difficulty cliffs, we bound the amplitude of the
// adjustment we are going to do.
assert(pindexLast->nTime > pindexFirst->nTime);
int64_t nActualTimespan = pindexLast->nTime - pindexFirst->nTime;
// Don't dampen the DAA adjustments on mainnet after 1-min fork
if (pindexLast->nHeight < params.oneMinuteBlockHeight) {
work *= params.nPowTargetSpacing;
if (nActualTimespan > 288 * params.nPowTargetSpacing) {
nActualTimespan = 288 * params.nPowTargetSpacing;
} else if (nActualTimespan < 72 * params.nPowTargetSpacing) {
nActualTimespan = 72 * params.nPowTargetSpacing;
}
} else {
const CBlockIndex *pindex5 = pindexLast->GetAncestor(pindexLast->nHeight - 5);
assert(pindex5);
int64_t nActualTimespan5 = pindexLast->nTime - pindex5->nTime;
int64_t nAdjustedSpacing = params.nPowTargetSpacingOneMinute;
// If 5 blocks happened slower than 3x expected, target 100% faster next block.
// ie. 5 blocks took >= 15-min
if (nActualTimespan5 >= (5 * 3 * params.nPowTargetSpacingOneMinute)) {
nAdjustedSpacing /= 2;
// Else if 5 blocks happened faster than 3x expected, target 50% slower next.
// ie. 5 blocks took <= 1-min 40-sec
} else if (nActualTimespan5 <= ( 5 / 3 * params.nPowTargetSpacingOneMinute)) {
nAdjustedSpacing *= 2;
}
work *= nAdjustedSpacing;
}
work /= nActualTimespan;
/**
* We need to compute T = (2^256 / W) - 1 but 2^256 doesn't fit in 256 bits.
* By expressing 1 as W / W, we get (2^256 - W) / W, and we can compute
* 2^256 - W as the complement of W.
*/
return (-work) / work;
}
/**
* To reduce the impact of timestamp manipulation, we select the block we are
* basing our computation on via a median of 3.
*/
static const CBlockIndex *GetSuitableBlock(const CBlockIndex *pindex) {
assert(pindex->nHeight >= 3);
/**
* In order to avoid a block is a very skewed timestamp to have too much
* influence, we select the median of the 3 top most blocks as a starting
* point.
*/
const CBlockIndex *blocks[3];
blocks[2] = pindex;
blocks[1] = pindex->pprev;
blocks[0] = blocks[1]->pprev;
// Sorting network.
if (blocks[0]->nTime > blocks[2]->nTime) {
std::swap(blocks[0], blocks[2]);
}
if (blocks[0]->nTime > blocks[1]->nTime) {
std::swap(blocks[0], blocks[1]);
}
if (blocks[1]->nTime > blocks[2]->nTime) {
std::swap(blocks[1], blocks[2]);
}
// We should have our candidate in the middle now.
return blocks[1];
}
/**
* Compute the next required proof of work using a 144-period or 30-period
* weighted average of the estimated hashrate per block.
*
* Using a weighted average ensure that the timestamp parameter cancels out in
* most of the calculation - except for the timestamp of the first and last
* block. Because timestamps are the least trustworthy information we have as
* input, this ensures the algorithm is more resistant to malicious inputs.+
*/
uint32_t GetNextCoreWorkRequired(const CBlockIndex *pindexPrev,
const CBlockHeader *pblock,
const Consensus::Params ¶ms) {
// Factor Target Spacing and difficulty adjustment based on 144 or 30 period DAA
const int nHeight = pindexPrev->nHeight;
int64_t nPowTargetSpacing = params.nPowTargetSpacing;
uint32_t nDAAPeriods = 144;
if (nHeight > params.oneMinuteBlockHeight) {
nPowTargetSpacing = params.nPowTargetSpacingOneMinute;
nDAAPeriods = 30;
}
// This cannot handle the genesis block and early blocks in general.
assert(pindexPrev);
// Get the last suitable block of the difficulty interval.
const CBlockIndex *pindexLast = GetSuitableBlock(pindexPrev);
assert(pindexLast);
// Get the first suitable block of the difficulty interval.
uint32_t nHeightFirst = nHeight - nDAAPeriods;
const CBlockIndex *pindexFirst =
GetSuitableBlock(pindexPrev->GetAncestor(nHeightFirst));
assert(pindexFirst);
// Special difficulty rule for tnet:
// If the last 30 blocks took 4 hours on tnet instead of 30-min,
// then allow mining of a min-difficulty block.
int64_t nActualThirtyBlocksDurationSeconds =
pindexLast->GetBlockTime() - pindexFirst->GetBlockTime();
if (params.fPowAllowMinDifficultyBlocks &&
(nActualThirtyBlocksDurationSeconds >
pindexLast->GetBlockTime() + 240 * nPowTargetSpacing)) {
return UintToArith256(params.powLimit).GetCompact();
}
// Compute the target based on time and work done during the interval.
const arith_uint256 nextTarget =
ComputeTarget(pindexFirst, pindexLast, params);
const arith_uint256 powLimit = UintToArith256(params.powLimit);
if (nextTarget > powLimit) {
return powLimit.GetCompact();
}
return nextTarget.GetCompact();
}
| [
"klauskirkeby@hotmail.com"
] | klauskirkeby@hotmail.com |
0e63998fb56cf1e0c322a7022ce80906fbac61af | 2cf838b54b556987cfc49f42935f8aa7563ea1f4 | /aws-cpp-sdk-quicksight/include/aws/quicksight/model/UpdateDataSetPermissionsResult.h | 004dff739191eaad0064de88293354ed59b78780 | [
"MIT",
"Apache-2.0",
"JSON"
] | permissive | QPC-database/aws-sdk-cpp | d11e9f0ff6958c64e793c87a49f1e034813dac32 | 9f83105f7e07fe04380232981ab073c247d6fc85 | refs/heads/main | 2023-06-14T17:41:04.817304 | 2021-07-09T20:28:20 | 2021-07-09T20:28:20 | 384,714,703 | 1 | 0 | Apache-2.0 | 2021-07-10T14:16:41 | 2021-07-10T14:16:41 | null | UTF-8 | C++ | false | false | 5,572 | h | /**
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
* SPDX-License-Identifier: Apache-2.0.
*/
#pragma once
#include <aws/quicksight/QuickSight_EXPORTS.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <utility>
namespace Aws
{
template<typename RESULT_TYPE>
class AmazonWebServiceResult;
namespace Utils
{
namespace Json
{
class JsonValue;
} // namespace Json
} // namespace Utils
namespace QuickSight
{
namespace Model
{
class AWS_QUICKSIGHT_API UpdateDataSetPermissionsResult
{
public:
UpdateDataSetPermissionsResult();
UpdateDataSetPermissionsResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
UpdateDataSetPermissionsResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
/**
* <p>The Amazon Resource Name (ARN) of the dataset.</p>
*/
inline const Aws::String& GetDataSetArn() const{ return m_dataSetArn; }
/**
* <p>The Amazon Resource Name (ARN) of the dataset.</p>
*/
inline void SetDataSetArn(const Aws::String& value) { m_dataSetArn = value; }
/**
* <p>The Amazon Resource Name (ARN) of the dataset.</p>
*/
inline void SetDataSetArn(Aws::String&& value) { m_dataSetArn = std::move(value); }
/**
* <p>The Amazon Resource Name (ARN) of the dataset.</p>
*/
inline void SetDataSetArn(const char* value) { m_dataSetArn.assign(value); }
/**
* <p>The Amazon Resource Name (ARN) of the dataset.</p>
*/
inline UpdateDataSetPermissionsResult& WithDataSetArn(const Aws::String& value) { SetDataSetArn(value); return *this;}
/**
* <p>The Amazon Resource Name (ARN) of the dataset.</p>
*/
inline UpdateDataSetPermissionsResult& WithDataSetArn(Aws::String&& value) { SetDataSetArn(std::move(value)); return *this;}
/**
* <p>The Amazon Resource Name (ARN) of the dataset.</p>
*/
inline UpdateDataSetPermissionsResult& WithDataSetArn(const char* value) { SetDataSetArn(value); return *this;}
/**
* <p>The ID for the dataset whose permissions you want to update. This ID is
* unique per AWS Region for each AWS account.</p>
*/
inline const Aws::String& GetDataSetId() const{ return m_dataSetId; }
/**
* <p>The ID for the dataset whose permissions you want to update. This ID is
* unique per AWS Region for each AWS account.</p>
*/
inline void SetDataSetId(const Aws::String& value) { m_dataSetId = value; }
/**
* <p>The ID for the dataset whose permissions you want to update. This ID is
* unique per AWS Region for each AWS account.</p>
*/
inline void SetDataSetId(Aws::String&& value) { m_dataSetId = std::move(value); }
/**
* <p>The ID for the dataset whose permissions you want to update. This ID is
* unique per AWS Region for each AWS account.</p>
*/
inline void SetDataSetId(const char* value) { m_dataSetId.assign(value); }
/**
* <p>The ID for the dataset whose permissions you want to update. This ID is
* unique per AWS Region for each AWS account.</p>
*/
inline UpdateDataSetPermissionsResult& WithDataSetId(const Aws::String& value) { SetDataSetId(value); return *this;}
/**
* <p>The ID for the dataset whose permissions you want to update. This ID is
* unique per AWS Region for each AWS account.</p>
*/
inline UpdateDataSetPermissionsResult& WithDataSetId(Aws::String&& value) { SetDataSetId(std::move(value)); return *this;}
/**
* <p>The ID for the dataset whose permissions you want to update. This ID is
* unique per AWS Region for each AWS account.</p>
*/
inline UpdateDataSetPermissionsResult& WithDataSetId(const char* value) { SetDataSetId(value); return *this;}
/**
* <p>The AWS request ID for this operation.</p>
*/
inline const Aws::String& GetRequestId() const{ return m_requestId; }
/**
* <p>The AWS request ID for this operation.</p>
*/
inline void SetRequestId(const Aws::String& value) { m_requestId = value; }
/**
* <p>The AWS request ID for this operation.</p>
*/
inline void SetRequestId(Aws::String&& value) { m_requestId = std::move(value); }
/**
* <p>The AWS request ID for this operation.</p>
*/
inline void SetRequestId(const char* value) { m_requestId.assign(value); }
/**
* <p>The AWS request ID for this operation.</p>
*/
inline UpdateDataSetPermissionsResult& WithRequestId(const Aws::String& value) { SetRequestId(value); return *this;}
/**
* <p>The AWS request ID for this operation.</p>
*/
inline UpdateDataSetPermissionsResult& WithRequestId(Aws::String&& value) { SetRequestId(std::move(value)); return *this;}
/**
* <p>The AWS request ID for this operation.</p>
*/
inline UpdateDataSetPermissionsResult& WithRequestId(const char* value) { SetRequestId(value); return *this;}
/**
* <p>The HTTP status of the request.</p>
*/
inline int GetStatus() const{ return m_status; }
/**
* <p>The HTTP status of the request.</p>
*/
inline void SetStatus(int value) { m_status = value; }
/**
* <p>The HTTP status of the request.</p>
*/
inline UpdateDataSetPermissionsResult& WithStatus(int value) { SetStatus(value); return *this;}
private:
Aws::String m_dataSetArn;
Aws::String m_dataSetId;
Aws::String m_requestId;
int m_status;
};
} // namespace Model
} // namespace QuickSight
} // namespace Aws
| [
"aws-sdk-cpp-automation@github.com"
] | aws-sdk-cpp-automation@github.com |
5a66f045efaca9f00d4706d5f1c6ab050aefbdf2 | 13a39681376455c8f47d40084a64265c6bc71d65 | /动态规划+/矩阵连乘问题/1.cpp | 2e64eba5036128c7d774d776d433b518452031eb | [] | no_license | Jonathan-Jiang/Algorithm | f85bbef96c82861f26d0383ef069761f40b125de | 5dc6af8d7854d3ea2ad60237bcc1f21652c728fa | refs/heads/master | 2021-05-28T11:40:19.002992 | 2015-01-07T06:34:34 | 2015-01-07T06:34:34 | null | 0 | 0 | null | null | null | null | GB18030 | C++ | false | false | 1,762 | cpp | #include <iostream>
using namespace std;
const int cnt = 5;
// A1 A2 A3 A4 A5
// 30 * 15
// 15 * 25
// 25 * 5
// 5 * 10
// 10 * 20
// p0 p1 p2 p3 p4 p5
int p[cnt + 1] = { 30, 15, 25, 5, 10, 20 };
// 递归实现
int less(int i, int j) {
if (i == j) return 0;
int min = less(i, i) + less(i + 1, j) + p[i - 1] * p[i] * p[j];
for (int k = i + 1; k < j; ++k) {
int t = less(i, k) + less(k + 1, j) + p[i - 1] * p[k] * p[j];
if (min > t) min = t;
}
return min;
}
// 非递归实现
int v[cnt + 1][cnt + 1];
// 通过 kmap 可以找出计算顺序
int kmap[cnt + 1][cnt + 1];
void less() {
memset(v, 0, sizeof(v));
memset(kmap, 0, sizeof(kmap));
for (int i = cnt; i >= 1; --i) {
for (int j = 1; j <= cnt; ++j) {
if (i >= j) v[i][j] = 0;
else {
v[i][j] = v[i][i] + v[i + 1][j] + p[i - 1] * p[i] * p[j];
kmap[i][j] = i;
for (int k = i + 1; k < j; ++k) {
int t = v[i][k] + v[k + 1][j] + p[i - 1] * p[k] * p[j];
if (v[i][j] > t) {
v[i][j] = t;
kmap[i][j] = k;
}
}
}
}
}
}
// print order
void DPMatrixChain(int i, int j, int s[][cnt + 1]) {
if (i != j) {
DPMatrixChain(i, s[i][j], s);
DPMatrixChain(s[i][j] + 1, j, s);
printf("A[%d : %d]: broken: A[%d : %d] and A[%d : %d]\n", i, j, i, s[i][j], s[i][j] + 1, j);
}
}
int main(int argc, const char* argv[]) {
// cout << less(1, 5) << endl;
less();
cout << v[1][cnt] << endl;
#define DEBUG
#ifdef DEBUG
for (int i = 1; i <= cnt; ++i) {
for (int j = 1; j <= cnt; ++j) {
cout << v[i][j] << "\t";
if (j == cnt) cout << endl;
}
}
cout << endl;
for (i = 1; i <= cnt; ++i) {
for (int j = 1; j <= cnt; ++j) {
cout << kmap[i][j] << "\t";
if (j == cnt) cout << endl;
}
}
#endif
DPMatrixChain(1, 5, kmap);
return 0;
}
| [
"daishengdong@gmail.com"
] | daishengdong@gmail.com |
0eac78e3a9d4e85cada41bac8bdb334540061c6b | 15417ed67cfdfa56e30c53031305d0fc0e01e838 | /mango/math/vector128_int16x8.hpp | a87464a38f0fd588ffa9a8e4b40a1376c1b37e3b | [] | no_license | atkurtul/VulkanSample | 84bbfe37655139fe7d8076fb4fa491fda6a7c254 | f320ed7863f48564669f5415f4f4f0e57c576ae2 | refs/heads/master | 2023-02-24T03:13:08.369897 | 2020-07-14T07:55:21 | 2020-07-14T07:55:21 | 279,509,861 | 10 | 2 | null | null | null | null | UTF-8 | C++ | false | false | 8,913 | hpp | /*
MANGO Multimedia Development Platform
Copyright (C) 2012-2020 Twilight Finland 3D Oy Ltd. All rights reserved.
*/
#pragma once
#include "vector.hpp"
namespace mango
{
template <>
struct Vector<s16, 8>
{
using VectorType = simd::s16x8;
using ScalarType = s16;
enum { VectorSize = 8 };
VectorType m;
ScalarType& operator [] (size_t index)
{
assert(index < VectorSize);
return data()[index];
}
ScalarType operator [] (size_t index) const
{
assert(index < VectorSize);
return data()[index];
}
ScalarType* data()
{
return reinterpret_cast<ScalarType *>(this);
}
const ScalarType* data() const
{
return reinterpret_cast<const ScalarType *>(this);
}
explicit Vector() {}
Vector(s16 s)
: m(simd::s16x8_set(s))
{
}
Vector(s16 s0, s16 s1, s16 s2, s16 s3, s16 s4, s16 s5, s16 s6, s16 s7)
: m(simd::s16x8_set(s0, s1, s2, s3, s4, s5, s6, s7))
{
}
Vector(simd::s16x8 v)
: m(v)
{
}
template <typename T, int I>
Vector& operator = (const ScalarAccessor<ScalarType, T, I>& accessor)
{
*this = ScalarType(accessor);
return *this;
}
Vector(const Vector& v) = default;
Vector& operator = (const Vector& v)
{
m = v.m;
return *this;
}
Vector& operator = (simd::s16x8 v)
{
m = v;
return *this;
}
Vector& operator = (s16 s)
{
m = simd::s16x8_set(s);
return *this;
}
operator simd::s16x8 () const
{
return m;
}
#ifdef int128_is_hardware_vector
operator simd::s16x8::vector () const
{
return m.data;
}
#endif
};
template <>
inline Vector<s16, 8> load_low<s16, 8>(const s16 *source)
{
return simd::s16x8_load_low(source);
}
static inline void store_low(s16 *dest, Vector<s16, 8> v)
{
simd::s16x8_store_low(dest, v);
}
static inline const Vector<s16, 8> operator + (Vector<s16, 8> v)
{
return v;
}
static inline Vector<s16, 8> operator - (Vector<s16, 8> v)
{
return simd::neg(v);
}
static inline Vector<s16, 8>& operator += (Vector<s16, 8>& a, Vector<s16, 8> b)
{
a = simd::add(a, b);
return a;
}
static inline Vector<s16, 8>& operator -= (Vector<s16, 8>& a, Vector<s16, 8> b)
{
a = simd::sub(a, b);
return a;
}
static inline Vector<s16, 8> operator + (Vector<s16, 8> a, Vector<s16, 8> b)
{
return simd::add(a, b);
}
static inline Vector<s16, 8> operator - (Vector<s16, 8> a, Vector<s16, 8> b)
{
return simd::sub(a, b);
}
static inline Vector<s16, 8> unpacklo(Vector<s16, 8> a, Vector<s16, 8> b)
{
return simd::unpacklo(a, b);
}
static inline Vector<s16, 8> unpackhi(Vector<s16, 8> a, Vector<s16, 8> b)
{
return simd::unpackhi(a, b);
}
static inline Vector<s16, 8> abs(Vector<s16, 8> a)
{
return simd::abs(a);
}
static inline Vector<s16, 8> abs(Vector<s16, 8> a, mask16x8 mask)
{
return simd::abs(a, mask);
}
static inline Vector<s16, 8> abs(Vector<s16, 8> a, mask16x8 mask, Vector<s16, 8> value)
{
return simd::abs(a, mask, value);
}
static inline Vector<s16, 8> add(Vector<s16, 8> a, Vector<s16, 8> b, mask16x8 mask)
{
return simd::add(a, b, mask);
}
static inline Vector<s16, 8> add(Vector<s16, 8> a, Vector<s16, 8> b, mask16x8 mask, Vector<s16, 8> value)
{
return simd::add(a, b, mask, value);
}
static inline Vector<s16, 8> sub(Vector<s16, 8> a, Vector<s16, 8> b, mask16x8 mask)
{
return simd::sub(a, b, mask);
}
static inline Vector<s16, 8> sub(Vector<s16, 8> a, Vector<s16, 8> b, mask16x8 mask, Vector<s16, 8> value)
{
return simd::sub(a, b, mask, value);
}
static inline Vector<s16, 8> adds(Vector<s16, 8> a, Vector<s16, 8> b)
{
return simd::adds(a, b);
}
static inline Vector<s16, 8> adds(Vector<s16, 8> a, Vector<s16, 8> b, mask16x8 mask)
{
return simd::adds(a, b, mask);
}
static inline Vector<s16, 8> adds(Vector<s16, 8> a, Vector<s16, 8> b, mask16x8 mask, Vector<s16, 8> value)
{
return simd::adds(a, b, mask, value);
}
static inline Vector<s16, 8> subs(Vector<s16, 8> a, Vector<s16, 8> b)
{
return simd::subs(a, b);
}
static inline Vector<s16, 8> subs(Vector<s16, 8> a, Vector<s16, 8> b, mask16x8 mask)
{
return simd::subs(a, b, mask);
}
static inline Vector<s16, 8> subs(Vector<s16, 8> a, Vector<s16, 8> b, mask16x8 mask, Vector<s16, 8> value)
{
return simd::subs(a, b, mask, value);
}
static inline Vector<s16, 8> hadd(Vector<s16, 8> a, Vector<s16, 8> b)
{
return simd::hadd(a, b);
}
static inline Vector<s16, 8> hsub(Vector<s16, 8> a, Vector<s16, 8> b)
{
return simd::hsub(a, b);
}
static inline Vector<s16, 8> hadds(Vector<s16, 8> a, Vector<s16, 8> b)
{
return simd::hadds(a, b);
}
static inline Vector<s16, 8> hsubs(Vector<s16, 8> a, Vector<s16, 8> b)
{
return simd::hsubs(a, b);
}
static inline Vector<s16, 8> min(Vector<s16, 8> a, Vector<s16, 8> b)
{
return simd::min(a, b);
}
static inline Vector<s16, 8> min(Vector<s16, 8> a, Vector<s16, 8> b, mask16x8 mask)
{
return simd::min(a, b, mask);
}
static inline Vector<s16, 8> min(Vector<s16, 8> a, Vector<s16, 8> b, mask16x8 mask, Vector<s16, 8> value)
{
return simd::min(a, b, mask, value);
}
static inline Vector<s16, 8> max(Vector<s16, 8> a, Vector<s16, 8> b)
{
return simd::max(a, b);
}
static inline Vector<s16, 8> max(Vector<s16, 8> a, Vector<s16, 8> b, mask16x8 mask)
{
return simd::max(a, b, mask);
}
static inline Vector<s16, 8> max(Vector<s16, 8> a, Vector<s16, 8> b, mask16x8 mask, Vector<s16, 8> value)
{
return simd::max(a, b, mask, value);
}
static inline Vector<s16, 8> clamp(Vector<s16, 8> a, Vector<s16, 8> low, Vector<s16, 8> high)
{
return simd::clamp(a, low, high);
}
// ------------------------------------------------------------------
// bitwise operators
// ------------------------------------------------------------------
static inline Vector<s16, 8> nand(Vector<s16, 8> a, Vector<s16, 8> b)
{
return simd::bitwise_nand(a, b);
}
static inline Vector<s16, 8> operator & (Vector<s16, 8> a, Vector<s16, 8> b)
{
return simd::bitwise_and(a, b);
}
static inline Vector<s16, 8> operator | (Vector<s16, 8> a, Vector<s16, 8> b)
{
return simd::bitwise_or(a, b);
}
static inline Vector<s16, 8> operator ^ (Vector<s16, 8> a, Vector<s16, 8> b)
{
return simd::bitwise_xor(a, b);
}
static inline Vector<s16, 8> operator ~ (Vector<s16, 8> a)
{
return simd::bitwise_not(a);
}
// ------------------------------------------------------------------
// compare / select
// ------------------------------------------------------------------
static inline mask16x8 operator > (Vector<s16, 8> a, Vector<s16, 8> b)
{
return simd::compare_gt(a, b);
}
static inline mask16x8 operator >= (Vector<s16, 8> a, Vector<s16, 8> b)
{
return simd::compare_ge(a, b);
}
static inline mask16x8 operator < (Vector<s16, 8> a, Vector<s16, 8> b)
{
return simd::compare_lt(a, b);
}
static inline mask16x8 operator <= (Vector<s16, 8> a, Vector<s16, 8> b)
{
return simd::compare_le(a, b);
}
static inline mask16x8 operator == (Vector<s16, 8> a, Vector<s16, 8> b)
{
return simd::compare_eq(a, b);
}
static inline mask16x8 operator != (Vector<s16, 8> a, Vector<s16, 8> b)
{
return simd::compare_neq(a, b);
}
static inline Vector<s16, 8> select(mask16x8 mask, Vector<s16, 8> a, Vector<s16, 8> b)
{
return simd::select(mask, a, b);
}
// ------------------------------------------------------------------
// shift
// ------------------------------------------------------------------
static inline Vector<s16, 8> operator << (Vector<s16, 8> a, int b)
{
return simd::sll(a, b);
}
static inline Vector<s16, 8> operator >> (Vector<s16, 8> a, int b)
{
return simd::sra(a, b);
}
} // namespace mango
| [
"atilkurtulmus@gmail.com"
] | atilkurtulmus@gmail.com |
433f644cbb125c01b117cfe36956fa5ab6d18b85 | a4e65095b88e3d7765d56e37923954bc41c4fc43 | /tomita/config/clearnames.cxx | a46e0d66b8fe42f898ba293200032cb4363f9e58 | [] | no_license | Rosdex/rest-category-classificator | 8ffd61dadccd50c6ae846aa06779f8b4923c98fe | 32d23c57ec11970d867935a414f97d4d312c161e | refs/heads/master | 2021-04-15T16:51:32.235505 | 2018-04-02T10:01:31 | 2018-04-02T10:01:31 | 126,369,543 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 220 | cxx | #encoding "utf-8"
#GRAMMAR_ROOT S
S -> Adj interp (ProductName.AdjForName) Noun interp (ProductName.Name);
S -> Noun interp (ProductName.Name) Adj interp (ProductName.AdjForName);
S -> Noun interp (ProductName.Name);
| [
"azheleznov88@gmail.com"
] | azheleznov88@gmail.com |
c89a22d2587ef8a5715cd30a8e5cabd40e9cceba | 8075a04ad4d2e8119da438394978c50259b856c2 | /src/kernel.cpp | 342e228da8dc65214979d87afa64839cad6c0e65 | [
"MIT"
] | permissive | coriumplatform/corium | 56c29109118708a8cd3cf36b9aa2deb49ef4ee06 | 4b1faabdcde7383221af51d7655c0ebdc8b17f77 | refs/heads/master | 2020-03-22T15:50:17.789212 | 2018-07-10T12:41:24 | 2018-07-10T12:41:24 | 140,282,543 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 19,606 | cpp | /* @flow */
// Copyright (c) 2012-2013 The PPCoin developers
// Copyright (c) 2015-2017 The PIVX developers
// Copyright (c) 2017 The Corium developers
// Distributed under the MIT/X11 software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
#include <boost/assign/list_of.hpp>
#include <boost/lexical_cast.hpp>
#include "db.h"
#include "kernel.h"
#include "script/interpreter.h"
#include "timedata.h"
#include "util.h"
using namespace std;
bool fTestNet = false; //Params().NetworkID() == CBaseChainParams::TESTNET;
// Modifier interval: time to elapse before new modifier is computed
// Set to 3-hour for production network and 20-minute for test network
unsigned int nModifierInterval;
int nStakeTargetSpacing = 60;
unsigned int getIntervalVersion(bool fTestNet)
{
if (fTestNet)
return MODIFIER_INTERVAL_TESTNET;
else
return MODIFIER_INTERVAL;
}
// Hard checkpoints of stake modifiers to ensure they are deterministic
static std::map<int, unsigned int> mapStakeModifierCheckpoints =
boost::assign::map_list_of(0, 0xfd11f4e7u);
// Get time weight
int64_t GetWeight(int64_t nIntervalBeginning, int64_t nIntervalEnd)
{
return nIntervalEnd - nIntervalBeginning - nStakeMinAge;
}
// Get the last stake modifier and its generation time from a given block
static bool GetLastStakeModifier(const CBlockIndex* pindex, uint64_t& nStakeModifier, int64_t& nModifierTime)
{
if (!pindex)
return error("GetLastStakeModifier: null pindex");
while (pindex && pindex->pprev && !pindex->GeneratedStakeModifier())
pindex = pindex->pprev;
if (!pindex->GeneratedStakeModifier())
return error("GetLastStakeModifier: no generation at genesis block");
nStakeModifier = pindex->nStakeModifier;
nModifierTime = pindex->GetBlockTime();
return true;
}
// Get selection interval section (in seconds)
static int64_t GetStakeModifierSelectionIntervalSection(int nSection)
{
assert(nSection >= 0 && nSection < 64);
int64_t a = getIntervalVersion(fTestNet) * 63 / (63 + ((63 - nSection) * (MODIFIER_INTERVAL_RATIO - 1)));
return a;
}
// Get stake modifier selection interval (in seconds)
static int64_t GetStakeModifierSelectionInterval()
{
int64_t nSelectionInterval = 0;
for (int nSection = 0; nSection < 64; nSection++) {
nSelectionInterval += GetStakeModifierSelectionIntervalSection(nSection);
}
return nSelectionInterval;
}
// select a block from the candidate blocks in vSortedByTimestamp, excluding
// already selected blocks in vSelectedBlocks, and with timestamp up to
// nSelectionIntervalStop.
static bool SelectBlockFromCandidates(
vector<pair<int64_t, uint256> >& vSortedByTimestamp,
map<uint256, const CBlockIndex*>& mapSelectedBlocks,
int64_t nSelectionIntervalStop,
uint64_t nStakeModifierPrev,
const CBlockIndex** pindexSelected)
{
bool fModifierV2 = false;
bool fFirstRun = true;
bool fSelected = false;
uint256 hashBest = 0;
*pindexSelected = (const CBlockIndex*)0;
BOOST_FOREACH (const PAIRTYPE(int64_t, uint256) & item, vSortedByTimestamp) {
if (!mapBlockIndex.count(item.second))
return error("SelectBlockFromCandidates: failed to find block index for candidate block %s", item.second.ToString().c_str());
const CBlockIndex* pindex = mapBlockIndex[item.second];
if (fSelected && pindex->GetBlockTime() > nSelectionIntervalStop)
break;
//if the lowest block height (vSortedByTimestamp[0]) is >= switch height, use new modifier calc
if (fFirstRun){
fModifierV2 = pindex->nHeight >= Params().ModifierUpgradeBlock();
fFirstRun = false;
}
if (mapSelectedBlocks.count(pindex->GetBlockHash()) > 0)
continue;
// compute the selection hash by hashing an input that is unique to that block
uint256 hashProof;
if(fModifierV2)
hashProof = pindex->GetBlockHash();
else
hashProof = pindex->IsProofOfStake() ? 0 : pindex->GetBlockHash();
CDataStream ss(SER_GETHASH, 0);
ss << hashProof << nStakeModifierPrev;
uint256 hashSelection = Hash(ss.begin(), ss.end());
// the selection hash is divided by 2**32 so that proof-of-stake block
// is always favored over proof-of-work block. this is to preserve
// the energy efficiency property
if (pindex->IsProofOfStake())
hashSelection >>= 32;
if (fSelected && hashSelection < hashBest) {
hashBest = hashSelection;
*pindexSelected = (const CBlockIndex*)pindex;
} else if (!fSelected) {
fSelected = true;
hashBest = hashSelection;
*pindexSelected = (const CBlockIndex*)pindex;
}
}
if (GetBoolArg("-printstakemodifier", false))
LogPrintf("SelectBlockFromCandidates: selection hash=%s\n", hashBest.ToString().c_str());
return fSelected;
}
// Stake Modifier (hash modifier of proof-of-stake):
// The purpose of stake modifier is to prevent a txout (coin) owner from
// computing future proof-of-stake generated by this txout at the time
// of transaction confirmation. To meet kernel protocol, the txout
// must hash with a future stake modifier to generate the proof.
// Stake modifier consists of bits each of which is contributed from a
// selected block of a given block group in the past.
// The selection of a block is based on a hash of the block's proof-hash and
// the previous stake modifier.
// Stake modifier is recomputed at a fixed time interval instead of every
// block. This is to make it difficult for an attacker to gain control of
// additional bits in the stake modifier, even after generating a chain of
// blocks.
bool ComputeNextStakeModifier(const CBlockIndex* pindexPrev, uint64_t& nStakeModifier, bool& fGeneratedStakeModifier)
{
nStakeModifier = 0;
fGeneratedStakeModifier = false;
if (!pindexPrev) {
fGeneratedStakeModifier = true;
return true; // genesis block's modifier is 0
}
if (pindexPrev->nHeight == 0) {
//Give a stake modifier to the first block
fGeneratedStakeModifier = true;
nStakeModifier = uint64_t("stakemodifier");
return true;
}
// First find current stake modifier and its generation block time
// if it's not old enough, return the same stake modifier
int64_t nModifierTime = 0;
if (!GetLastStakeModifier(pindexPrev, nStakeModifier, nModifierTime))
return error("ComputeNextStakeModifier: unable to get last modifier");
if (GetBoolArg("-printstakemodifier", false))
LogPrintf("ComputeNextStakeModifier: prev modifier= %s time=%s\n", boost::lexical_cast<std::string>(nStakeModifier).c_str(), DateTimeStrFormat("%Y-%m-%d %H:%M:%S", nModifierTime).c_str());
if (nModifierTime / getIntervalVersion(fTestNet) >= pindexPrev->GetBlockTime() / getIntervalVersion(fTestNet))
return true;
// Sort candidate blocks by timestamp
vector<pair<int64_t, uint256> > vSortedByTimestamp;
vSortedByTimestamp.reserve(64 * getIntervalVersion(fTestNet) / nStakeTargetSpacing);
int64_t nSelectionInterval = GetStakeModifierSelectionInterval();
int64_t nSelectionIntervalStart = (pindexPrev->GetBlockTime() / getIntervalVersion(fTestNet)) * getIntervalVersion(fTestNet) - nSelectionInterval;
const CBlockIndex* pindex = pindexPrev;
while (pindex && pindex->GetBlockTime() >= nSelectionIntervalStart) {
vSortedByTimestamp.push_back(make_pair(pindex->GetBlockTime(), pindex->GetBlockHash()));
pindex = pindex->pprev;
}
int nHeightFirstCandidate = pindex ? (pindex->nHeight + 1) : 0;
reverse(vSortedByTimestamp.begin(), vSortedByTimestamp.end());
sort(vSortedByTimestamp.begin(), vSortedByTimestamp.end());
// Select 64 blocks from candidate blocks to generate stake modifier
uint64_t nStakeModifierNew = 0;
int64_t nSelectionIntervalStop = nSelectionIntervalStart;
map<uint256, const CBlockIndex*> mapSelectedBlocks;
for (int nRound = 0; nRound < min(64, (int)vSortedByTimestamp.size()); nRound++) {
// add an interval section to the current selection round
nSelectionIntervalStop += GetStakeModifierSelectionIntervalSection(nRound);
// select a block from the candidates of current round
if (!SelectBlockFromCandidates(vSortedByTimestamp, mapSelectedBlocks, nSelectionIntervalStop, nStakeModifier, &pindex))
return error("ComputeNextStakeModifier: unable to select block at round %d", nRound);
// write the entropy bit of the selected block
nStakeModifierNew |= (((uint64_t)pindex->GetStakeEntropyBit()) << nRound);
// add the selected block from candidates to selected list
mapSelectedBlocks.insert(make_pair(pindex->GetBlockHash(), pindex));
if (fDebug || GetBoolArg("-printstakemodifier", false))
LogPrintf("ComputeNextStakeModifier: selected round %d stop=%s height=%d bit=%d\n",
nRound, DateTimeStrFormat("%Y-%m-%d %H:%M:%S", nSelectionIntervalStop).c_str(), pindex->nHeight, pindex->GetStakeEntropyBit());
}
// Print selection map for visualization of the selected blocks
if (fDebug || GetBoolArg("-printstakemodifier", false)) {
string strSelectionMap = "";
// '-' indicates proof-of-work blocks not selected
strSelectionMap.insert(0, pindexPrev->nHeight - nHeightFirstCandidate + 1, '-');
pindex = pindexPrev;
while (pindex && pindex->nHeight >= nHeightFirstCandidate) {
// '=' indicates proof-of-stake blocks not selected
if (pindex->IsProofOfStake())
strSelectionMap.replace(pindex->nHeight - nHeightFirstCandidate, 1, "=");
pindex = pindex->pprev;
}
BOOST_FOREACH (const PAIRTYPE(uint256, const CBlockIndex*) & item, mapSelectedBlocks) {
// 'S' indicates selected proof-of-stake blocks
// 'W' indicates selected proof-of-work blocks
strSelectionMap.replace(item.second->nHeight - nHeightFirstCandidate, 1, item.second->IsProofOfStake() ? "S" : "W");
}
LogPrintf("ComputeNextStakeModifier: selection height [%d, %d] map %s\n", nHeightFirstCandidate, pindexPrev->nHeight, strSelectionMap.c_str());
}
if (fDebug || GetBoolArg("-printstakemodifier", false)) {
LogPrintf("ComputeNextStakeModifier: new modifier=%s time=%s\n", boost::lexical_cast<std::string>(nStakeModifierNew).c_str(), DateTimeStrFormat("%Y-%m-%d %H:%M:%S", pindexPrev->GetBlockTime()).c_str());
}
nStakeModifier = nStakeModifierNew;
fGeneratedStakeModifier = true;
return true;
}
// The stake modifier used to hash for a stake kernel is chosen as the stake
// modifier about a selection interval later than the coin generating the kernel
bool GetKernelStakeModifier(uint256 hashBlockFrom, uint64_t& nStakeModifier, int& nStakeModifierHeight, int64_t& nStakeModifierTime, bool fPrintProofOfStake)
{
nStakeModifier = 0;
if (!mapBlockIndex.count(hashBlockFrom))
return error("GetKernelStakeModifier() : block not indexed");
const CBlockIndex* pindexFrom = mapBlockIndex[hashBlockFrom];
nStakeModifierHeight = pindexFrom->nHeight;
nStakeModifierTime = pindexFrom->GetBlockTime();
int64_t nStakeModifierSelectionInterval = GetStakeModifierSelectionInterval();
const CBlockIndex* pindex = pindexFrom;
CBlockIndex* pindexNext = chainActive[pindexFrom->nHeight + 1];
// loop to find the stake modifier later by a selection interval
while (nStakeModifierTime < pindexFrom->GetBlockTime() + nStakeModifierSelectionInterval) {
if (!pindexNext) {
// Should never happen
return error("Null pindexNext\n");
}
pindex = pindexNext;
pindexNext = chainActive[pindexNext->nHeight + 1];
if (pindex->GeneratedStakeModifier()) {
nStakeModifierHeight = pindex->nHeight;
nStakeModifierTime = pindex->GetBlockTime();
}
}
nStakeModifier = pindex->nStakeModifier;
return true;
}
uint256 stakeHash(unsigned int nTimeTx, CDataStream ss, unsigned int prevoutIndex, uint256 prevoutHash, unsigned int nTimeBlockFrom)
{
//Corium will hash in the transaction hash and the index number in order to make sure each hash is unique
ss << nTimeBlockFrom << prevoutIndex << prevoutHash << nTimeTx;
return Hash(ss.begin(), ss.end());
}
//test hash vs target
bool stakeTargetHit(uint256 hashProofOfStake, int64_t nValueIn, uint256 bnTargetPerCoinDay)
{
//get the stake weight - weight is equal to coin amount
uint256 bnCoinDayWeight = uint256(nValueIn) / 100;
// Now check if proof-of-stake hash meets target protocol
return (uint256(hashProofOfStake) < bnCoinDayWeight * bnTargetPerCoinDay);
}
//instead of looping outside and reinitializing variables many times, we will give a nTimeTx and also search interval so that we can do all the hashing here
bool CheckStakeKernelHash(unsigned int nBits, const CBlock blockFrom, const CTransaction txPrev, const COutPoint prevout, unsigned int& nTimeTx, unsigned int nHashDrift, bool fCheck, uint256& hashProofOfStake, bool fPrintProofOfStake)
{
//assign new variables to make it easier to read
int64_t nValueIn = txPrev.vout[prevout.n].nValue;
unsigned int nTimeBlockFrom = blockFrom.GetBlockTime();
if (nTimeTx < nTimeBlockFrom) // Transaction timestamp violation
return error("CheckStakeKernelHash() : nTime violation");
if (nTimeBlockFrom + nStakeMinAge > nTimeTx) // Min age requirement
return error("CheckStakeKernelHash() : min age violation - nTimeBlockFrom=%d nStakeMinAge=%d nTimeTx=%d", nTimeBlockFrom, nStakeMinAge, nTimeTx);
//grab difficulty
uint256 bnTargetPerCoinDay;
bnTargetPerCoinDay.SetCompact(nBits);
//grab stake modifier
uint64_t nStakeModifier = 0;
int nStakeModifierHeight = 0;
int64_t nStakeModifierTime = 0;
if (!GetKernelStakeModifier(blockFrom.GetHash(), nStakeModifier, nStakeModifierHeight, nStakeModifierTime, fPrintProofOfStake)) {
LogPrintf("CheckStakeKernelHash(): failed to get kernel stake modifier \n");
return false;
}
//create data stream once instead of repeating it in the loop
CDataStream ss(SER_GETHASH, 0);
ss << nStakeModifier;
//if wallet is simply checking to make sure a hash is valid
if (fCheck) {
hashProofOfStake = stakeHash(nTimeTx, ss, prevout.n, prevout.hash, nTimeBlockFrom);
return stakeTargetHit(hashProofOfStake, nValueIn, bnTargetPerCoinDay);
}
bool fSuccess = false;
unsigned int nTryTime = 0;
unsigned int i;
int nHeightStart = chainActive.Height();
for (i = 0; i < (nHashDrift); i++) //iterate the hashing
{
//new block came in, move on
if (chainActive.Height() != nHeightStart)
break;
//hash this iteration
nTryTime = nTimeTx + nHashDrift - i;
hashProofOfStake = stakeHash(nTryTime, ss, prevout.n, prevout.hash, nTimeBlockFrom);
// if stake hash does not meet the target then continue to next iteration
if (!stakeTargetHit(hashProofOfStake, nValueIn, bnTargetPerCoinDay))
continue;
fSuccess = true; // if we make it this far then we have successfully created a stake hash
nTimeTx = nTryTime;
if (fDebug || fPrintProofOfStake) {
LogPrintf("CheckStakeKernelHash() : using modifier %s at height=%d timestamp=%s for block from height=%d timestamp=%s\n",
boost::lexical_cast<std::string>(nStakeModifier).c_str(), nStakeModifierHeight,
DateTimeStrFormat("%Y-%m-%d %H:%M:%S", nStakeModifierTime).c_str(),
mapBlockIndex[blockFrom.GetHash()]->nHeight,
DateTimeStrFormat("%Y-%m-%d %H:%M:%S", blockFrom.GetBlockTime()).c_str());
LogPrintf("CheckStakeKernelHash() : pass protocol=%s modifier=%s nTimeBlockFrom=%u prevoutHash=%s nTimeTxPrev=%u nPrevout=%u nTimeTx=%u hashProof=%s\n",
"0.3",
boost::lexical_cast<std::string>(nStakeModifier).c_str(),
nTimeBlockFrom, prevout.hash.ToString().c_str(), nTimeBlockFrom, prevout.n, nTryTime,
hashProofOfStake.ToString().c_str());
}
break;
}
mapHashedBlocks.clear();
mapHashedBlocks[chainActive.Tip()->nHeight] = GetTime(); //store a time stamp of when we last hashed on this block
return fSuccess;
}
// Check kernel hash target and coinstake signature
bool CheckProofOfStake(const CBlock block, uint256& hashProofOfStake)
{
const CTransaction tx = block.vtx[1];
if (!tx.IsCoinStake())
return error("CheckProofOfStake() : called on non-coinstake %s", tx.GetHash().ToString().c_str());
// Kernel (input 0) must match the stake hash target per coin age (nBits)
const CTxIn& txin = tx.vin[0];
// First try finding the previous transaction in database
uint256 hashBlock;
CTransaction txPrev;
if (!GetTransaction(txin.prevout.hash, txPrev, hashBlock, true))
return error("CheckProofOfStake() : INFO: read txPrev failed");
//verify signature and script
if (!VerifyScript(txin.scriptSig, txPrev.vout[txin.prevout.n].scriptPubKey, STANDARD_SCRIPT_VERIFY_FLAGS, TransactionSignatureChecker(&tx, 0)))
return error("CheckProofOfStake() : VerifySignature failed on coinstake %s", tx.GetHash().ToString().c_str());
CBlockIndex* pindex = NULL;
BlockMap::iterator it = mapBlockIndex.find(hashBlock);
if (it != mapBlockIndex.end())
pindex = it->second;
else
return error("CheckProofOfStake() : read block failed");
// Read block header
CBlock blockprev;
if (!ReadBlockFromDisk(blockprev, pindex->GetBlockPos()))
return error("CheckProofOfStake(): INFO: failed to find block");
unsigned int nInterval = 0;
unsigned int nTime = block.nTime;
if (!CheckStakeKernelHash(block.nBits, blockprev, txPrev, txin.prevout, nTime, nInterval, true, hashProofOfStake, fDebug))
return error("CheckProofOfStake() : INFO: check kernel failed on coinstake %s, hashProof=%s \n", tx.GetHash().ToString().c_str(), hashProofOfStake.ToString().c_str()); // may occur during initial download or if behind on block chain sync
return true;
}
// Check whether the coinstake timestamp meets protocol
bool CheckCoinStakeTimestamp(int64_t nTimeBlock, int64_t nTimeTx)
{
// v0.3 protocol
return (nTimeBlock == nTimeTx);
}
// Get stake modifier checksum
unsigned int GetStakeModifierChecksum(const CBlockIndex* pindex)
{
assert(pindex->pprev || pindex->GetBlockHash() == Params().HashGenesisBlock());
// Hash previous checksum with flags, hashProofOfStake and nStakeModifier
CDataStream ss(SER_GETHASH, 0);
if (pindex->pprev)
ss << pindex->pprev->nStakeModifierChecksum;
ss << pindex->nFlags << pindex->hashProofOfStake << pindex->nStakeModifier;
uint256 hashChecksum = Hash(ss.begin(), ss.end());
hashChecksum >>= (256 - 32);
return hashChecksum.Get64();
}
// Check stake modifier hard checkpoints
bool CheckStakeModifierCheckpoints(int nHeight, unsigned int nStakeModifierChecksum)
{
if (fTestNet) return true; // Testnet has no checkpoints
if (mapStakeModifierCheckpoints.count(nHeight)) {
return nStakeModifierChecksum == mapStakeModifierCheckpoints[nHeight];
}
return true;
}
| [
"coriumplatform@gmail.com"
] | coriumplatform@gmail.com |
3fdf59cf801d57f6d94fd89ef79e10a2f46ca2d5 | eaf5c173ec669b26c95f7babad40306f2c7ea459 | /abc092/arc093_b.cpp | 47154d74ddd515c941a3824cbc5dcc20314cbc9d | [] | no_license | rikuTanide/atcoder_endeavor | 657cc3ba7fbf361355376a014e3e49317fe96def | 6b5dc43474d5183d8eecb8cb13bf45087c7ed195 | refs/heads/master | 2023-02-02T11:49:06.679743 | 2020-12-21T04:51:10 | 2020-12-21T04:51:10 | 318,676,396 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,026 | cpp | #include <bits/stdc++.h>
#include <cmath>
using namespace std;
#define rep(i, n) for (ll i = 0; i < (n); ++i)
//#define rep(i, n) for (int i = 0; i < (n); ++i)
#define sz(x) ll(x.size())
typedef long long ll;
//typedef pair<int, int> P;
typedef pair<ll, ll> P;
//const double INF = 1e10;
const ll INF = 10e15;
const ll MINF = -10e10;
//const int INF = INT_MAX;
#define cmin(x, y) x = min(x, y)
#define cmax(x, y) x = max(x, y)
//ifstream myfile("C:\\Users\\riku\\Downloads\\0_00.txt");
//ofstream outfile("log.txt");
//outfile << setw(6) << setfill('0') << prefecture << setw(6) << setfill('0') << rank << endl;
// std::cout << std::bitset<8>(9);
typedef priority_queue<P, vector<P>, greater<P>> PQ_ASK;
const int mod = 1000000007;
int main() {
int a, b;
cin >> a >> b;
int width = 95; //100 * 100;
int cells = width * (width / 5);
vector<bool> whites(cells, true);
vector<bool> blacks(cells, false);
for (int i = 1; i < a; i++) {
blacks[i * 2] = true;
}
for (int i = 1; i < b; i++) {
whites[i * 2] = false;
}
reverse(blacks.begin(), blacks.end());
cout << ((width / 5) * 2 * 2) << ' ' << width + 2 << endl;
for (int i = 0; i < cells; i++) {
if (i % width == 0) {
for (int j = 0; j < width + 2; j++) {
cout << '.';
}
cout << endl;
cout << '.';
}
if (whites[i] == true) {
cout << '.';
} else {
cout << '#';
}
if (i % width == width - 1) {
cout << '.' << endl;
}
}
for (int i = 0; i < cells; i++) {
if (i % width == 0) {
cout << '#';
}
if (blacks[i] == true) {
cout << '.';
} else {
cout << '#';
}
if (i % width == width - 1) {
cout << '#' << endl;
for (int j = 0; j < width + 2; j++) {
cout << '#';
}
cout << endl;
}
}
} | [
"riku@tanide.net"
] | riku@tanide.net |
345f7235edb1008869df8d5f597889e93e53934a | 8aa4728c495add431d18af6cca44450fd0e4b6cf | /2d ball game/PhysicsAspect.h | 96ca41788f64d60cd1bb0b8d1a5bf36c607e6bcc | [
"MIT"
] | permissive | DennisWandschura/GravBall | bf315ab1ad56dddd9e298cb1976b2d9693ff8d45 | f140e304368ce1bfb9a8750c5a5c68ceac4c24bd | refs/heads/master | 2021-01-10T18:05:13.938902 | 2016-01-05T20:20:52 | 2016-01-05T20:20:52 | 49,087,114 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,638 | h | #pragma once
struct Manifold;
struct Circle128C;
struct GravityWell;
class LevelFile;
namespace Physics
{
struct DynamicCircle;
}
#include <gamelib/PhysicsAspectBase.h>
#include <vxLib/Container/array.h>
#include <vxLib/Allocator/LinearAllocator.h>
#include <gamelib/DebugAllocator.h>
#include <gamelib/AABB.h>
struct OnCollisionCallbackData
{
__m128 dir;
PhysicsComponent* c0;
PhysicsComponent* c1;
};
class PhysicsAspect : public PhysicsAspectBase
{
OnCollisionCallbackSignature m_onCollisionCallback;
vx::array<PhysicsComponent, DebugAllocatorPhysics<Allocator::MainAllocator>> m_dynamicCircleComponents;
vx::array<GravityArea, DebugAllocatorPhysics<Allocator::MainAllocator>> m_gravityAreas;
vx::array<GravityWell, DebugAllocatorEntity<Allocator::MainAllocator>> m_gravityWells;
vx::array<Circle128C, DebugAllocatorPhysics<Allocator::MainAllocator>> m_staticCircles;
vx::array<PhysicsComponent, DebugAllocatorPhysics<Allocator::MainAllocator>> m_staticCircleComponents;
vx::array<AABB128, DebugAllocatorPhysics<Allocator::MainAllocator>> m_staticRects;
vx::array<PhysicsComponent, DebugAllocatorPhysics<Allocator::MainAllocator>> m_staticRectComponents;
vx::LinearAllocator m_frameAllocator;
vx::array<PhysicsComponent, DebugAllocatorPhysics<Allocator::MainAllocator>> m_tmpDynamicCircleComponents;
void accumulateForces(f32 dt);
void verlet(f32 dt);
void generateCollisions(const vx::array<Physics::DynamicCircle, vx::DelegateAllocator<vx::LinearAllocator>> &dynamicCircles, vx::array<Manifold, vx::DelegateAllocator<vx::LinearAllocator>>* manifolds);
void resolveCollisions(const __m128 &dtSquared, const __m128 &invDtSquared, const vx::array<Manifold, vx::DelegateAllocator<vx::LinearAllocator>> &manifolds,
vx::array<OnCollisionCallbackData, vx::DelegateAllocator<vx::LinearAllocator>>* callbackData);
void reset();
void loadLevel(const LevelFile &level);
public:
PhysicsAspect();
~PhysicsAspect();
bool initialize(const PhysicsAspectBaseDesc &desc) override;
void shutdow(Allocator::MainAllocator* allocator) override;
void update(f32 dt) override;
PhysicsComponent* updateComponent(const PhysicsComponent &old) override;
PhysicsComponent* addStaticShape(const vx::float2a &p, f32 radius, f32 restitution, void* userData) override;
PhysicsComponent* addStaticShape(const vx::float2a &p, const vx::float2a &halfDim, f32 restitution, void* userData) override;
PhysicsComponent* addDynamicShape(const vx::float2a &p, f32 radius, f32 mass, f32 restitution, void* userData) override;
GravityArea* getGravityArea(size_t i) override;
void handleEvent(const Event::Event &evt) override;
}; | [
"dennis.wandschura@gmx.de"
] | dennis.wandschura@gmx.de |
a279eb3245152b0511b126dc1904bbf229ed6d31 | 49e125a9e43d22706cea8f304e88c96dd20197ae | /Codeforces/equalizing by division.cpp | 34bfa5236880ba240919255301d5587cffd167ba | [] | no_license | tahsinsoha/Problem-solving- | b0382b7afa539715dafb1fbc40666e4051b5f7db | 7049dcc7ab9e4a59977787c2e9052055bff560a8 | refs/heads/master | 2023-01-06T02:35:56.822736 | 2020-11-04T12:15:43 | 2020-11-04T12:15:43 | 280,789,760 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 644 | cpp | #include<bits/stdc++.h>
using namespace std;
int main(){
int n,k,a,cnt;
vector<int>v;
cin>>n>>k;
for(int i=0;i<n;i++){
cin>>a;
v.push_back(a);
}
sort(v.begin(),v.end());
long long ans = 2e9;
for(int x=0;x<200001;x++){
cnt = 0;
long long now =0;
// long long int st=0;
for(int i=0;i<n && cnt<k;i++){
if(v[i]<x) continue;
else if(v[i]==x) cnt++;
else {
long long st=0;
int tmp = v[i];
while(tmp>x) tmp=tmp/2,st++;
if(tmp==x) now = now+st, cnt++;
}
}
if (cnt==k)
ans = min(ans,now);
}
cout<<ans<<endl;
return 0;
}
| [
"soha97368@gmail.com"
] | soha97368@gmail.com |
3f88760e8246435d2068e4dc9092b3ed9091b662 | a81c07a5663d967c432a61d0b4a09de5187be87b | /components/viz/common/features.h | 337dd335e4387c52960d1339bbd58dd85e824780 | [
"BSD-3-Clause"
] | permissive | junxuezheng/chromium | c401dec07f19878501801c9e9205a703e8643031 | 381ce9d478b684e0df5d149f59350e3bc634dad3 | refs/heads/master | 2023-02-28T17:07:31.342118 | 2019-09-03T01:42:42 | 2019-09-03T01:42:42 | 205,967,014 | 2 | 0 | BSD-3-Clause | 2019-09-03T01:48:23 | 2019-09-03T01:48:23 | null | UTF-8 | C++ | false | false | 1,085 | h | // Copyright 2017 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef COMPONENTS_VIZ_COMMON_FEATURES_H_
#define COMPONENTS_VIZ_COMMON_FEATURES_H_
#include "components/viz/common/viz_common_export.h"
#include "base/feature_list.h"
namespace features {
VIZ_COMMON_EXPORT extern const base::Feature kEnableVizHitTestSurfaceLayer;
VIZ_COMMON_EXPORT extern const base::Feature kUseSkiaForGLReadback;
VIZ_COMMON_EXPORT extern const base::Feature kUseSkiaRenderer;
VIZ_COMMON_EXPORT extern const base::Feature kRecordSkPicture;
VIZ_COMMON_EXPORT extern const base::Feature kVizDisplayCompositor;
VIZ_COMMON_EXPORT bool IsVizDisplayCompositorEnabled();
VIZ_COMMON_EXPORT bool IsVizHitTestingDebugEnabled();
VIZ_COMMON_EXPORT bool IsVizHitTestingSurfaceLayerEnabled();
VIZ_COMMON_EXPORT bool IsUsingSkiaForGLReadback();
VIZ_COMMON_EXPORT bool IsUsingSkiaRenderer();
VIZ_COMMON_EXPORT bool IsRecordingSkPicture();
} // namespace features
#endif // COMPONENTS_VIZ_COMMON_FEATURES_H_
| [
"commit-bot@chromium.org"
] | commit-bot@chromium.org |
d0d21b70fb50eee3236a0a62ed0a435365987373 | 7850eebcf9cf39c3ad05a3a09ea849a8a47e36a7 | /Hardware/Node/ID/ID.ino | 109c65dd8120d3d714e4551b4c4a2a0117b540b6 | [] | no_license | a84926601/Smart-Keeper | 440c3dbec39b28042dc5e4aa76b742ae88b25086 | e296597a3bda27484b36f4f4ec2d8431b030592d | refs/heads/master | 2020-03-22T01:31:21.671560 | 2018-09-15T07:29:33 | 2018-09-15T07:29:33 | 139,310,734 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 360 | ino | void setup() {
// put your setup code here, to run once:
uint32_t checksum = 0;
for(uint16_t u = 0; u < 2048; u++)
{
checksum += * ( (byte *) u );//checksum += the byte number u in the ram
}
Serial.begin(115200);
Serial.println(checksum , HEX);
}
void loop() {
// put your main code here, to run repeatedly:
Serial.println("Hello!");
}
| [
"jojo.5653@gmail.com"
] | jojo.5653@gmail.com |
19be914743febea00dcac1f24d1787910de0f8a0 | 0961819a5fe995ba0265d4a050f82551e2bf0663 | /Projects/proj4/card.cpp | 6f4879c564c8dafb185207670d6b61da104cf6a3 | [] | no_license | marinnaricke/CMSC202 | 2a98be3fccc2edcad587b55cf8ab0943134c9ed2 | b538e5fad266c940738a56f61f1b453c9555ae61 | refs/heads/master | 2021-05-05T05:06:52.177654 | 2018-01-24T22:01:12 | 2018-01-24T22:01:12 | 118,662,608 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,376 | cpp | /* File: card.cpp
Project: CMSC 202 Project 4, Spring 2016
Author: Marinna Ricketts-Uy
Date: 4/21/16
Section: 17
E-mail: pd12778@umbc.edu
CMSC 202 Computer Science II
Spring 2016 Project 4
This file has the implemenation of the Card class.
*/
#include <iostream>
#include <sstream>
#include <string>
using namespace std ;
#include "card.h"
#include "player.h"
#include "game.h"
// default constructor
//
Card::Card() {
m_suit = Invalid ;
m_points = 0 ;
}
Card::Card(unsigned int s, unsigned int p) {
if (s > Spades) { // sanity check
s = Invalid ;
}
m_suit = s ;
if (p > Ace || p == 1) { // sanity check
p = 0 ;
}
m_points = p ;
}
Card::~Card() {
// no dynamically allocated parts
}
unsigned int Card::getPoints() {
return m_points ;
}
unsigned int Card::getSuit() {
return m_suit ;
}
string Card::toString() {
ostringstream oss ;
switch ( m_points ) {
case 2 : case 3 : case 4 :
case 5 : case 6 : case 7 :
case 8 : case 9 : case 10 :
oss << m_points ;
break ;
case Jack:
oss << "Jack" ;
break ;
case Queen:
oss << "Queen" ;
break ;
case King:
oss << "King" ;
break ;
case Ace:
oss << "Ace" ;
break ;
default :
oss << "INVALID" ;
}
switch ( m_suit ) {
case Clubs :
oss << " of Clubs" ;
break ;
case Diamonds :
oss << " of Diamonds" ;
break ;
case Hearts :
oss << " of Hearts" ;
break ;
case Spades :
oss << " of Spades" ;
break ;
default :
oss << "of INVALID SUIT\n" ;
}
return oss.str() ;
}
// Can we play this card right now?
// Override for action cards!
//
bool Card::playable(Game *gptr) {
if ( m_suit == gptr->currentSuit() ) // matches suit?
return true ;
if ( m_points == gptr->currentPoints() ) // matches point value?
return true ;
return false ;
}
// Normal cards don't do anything to the players.
// Action cards can make the player do something
// (e.g., draw cards).
//
void Card::showPlayerToCard(Player *pptr) {
return ;
}
// Not much to do for normal cards. Just set the
// suit and point values.
// Action cards can override to do more.
// Note: pptr points to the player who played this card.
//
void Card::playCard(Game *gptr, Player *pptr) {
gptr->setSuit(m_suit) ;
gptr->setPoints(m_points) ;
return ;
}
| [
"pd12778@umbc.edu"
] | pd12778@umbc.edu |
aee43a25137bc556ef9ca6129a17ca6f60064846 | aedb5d78cbe6acaf9becea0ea7b43c46a9584f5e | /framework/base/selfwidget/treemode/rtreemodel.h | c62cdb90c0428d84a5b06053729844ad379e9743 | [] | no_license | wey580231/Framewrok | 60a922d4cc868b0d0b7f87a529eab2724ca3c18f | 1050b079997a975dcc7b64e1bfa5eb8acb72d8c4 | refs/heads/develop | 2023-03-15T04:36:18.608430 | 2021-03-23T14:30:51 | 2021-03-23T14:30:51 | 326,935,482 | 0 | 1 | null | 2021-03-23T14:30:52 | 2021-01-05T08:31:30 | C++ | UTF-8 | C++ | false | false | 2,519 | h | /*!
* @brief 通用树据模型
* @details
* @author wey
* @version 1.0
* @date 2018.12.25
* @warning
* @copyright NanJing RenGu.
* @note
*/
#ifndef NAVIGATEMODEL_H
#define NAVIGATEMODEL_H
#include <QAbstractItemModel>
#include "../../base_global.h"
namespace Base {
/*!
* @brief 单个树节点
* @warning 创建节点时一定要设置节点的parentNode信息
*/
struct TreeNode{
TreeNode():parentNode(NULL),nodeLevel(0),nodeData(NULL),nodeChecked(false){}
int childIndex() const{
if (parentNode)
return parentNode->nodes.indexOf(const_cast<TreeNode*>(this));
return 0;
}
int nodeId;
QString nodeName;
int nodeLevel; /*!< 树节点类型 （自定义类型,自行转换成需要的数据类型） >*/
bool nodeChecked; /*!< 是否被勾选(二级功能节点有效) */
void * nodeData; /*!< 节点绑定的数据 */
TreeNode * parentNode;
QList<TreeNode *> nodes;
};
class BASESHARED_EXPORT RTreeModel : public QAbstractItemModel
{
Q_OBJECT
public:
explicit RTreeModel(QObject *parent = Q_NULLPTR);
~RTreeModel();
QVariant data(const QModelIndex &index, int role) const Q_DECL_OVERRIDE;
bool setData(const QModelIndex &index, const QVariant &value, int role = Qt::EditRole)Q_DECL_OVERRIDE;
QVariant headerData(int section, Qt::Orientation orientation,int role = Qt::DisplayRole) const Q_DECL_OVERRIDE;
QModelIndex parent(const QModelIndex &index) const Q_DECL_OVERRIDE;
QModelIndex index(int row, int column,const QModelIndex &parent = QModelIndex()) const Q_DECL_OVERRIDE;
Qt::ItemFlags flags(const QModelIndex &index) const Q_DECL_OVERRIDE;
int rowCount(const QModelIndex &parent = QModelIndex()) const Q_DECL_OVERRIDE;
int columnCount(const QModelIndex &parent = QModelIndex()) const Q_DECL_OVERRIDE;
QModelIndex parentIndexFromNode(TreeNode * node);
QModelIndex indexFromNode(TreeNode* node);
void refreshModel();
void setHeaderData(QStringList headList);
void addRootNode(TreeNode *node);
void removeRootNode(TreeNode *node);
int rootNodeSize();
void clearModel();
void setVirtualRootNode(TreeNode * node);
TreeNode *virtualTreeRootNode(){return rootNode;}
protected:
TreeNode * rootNode; /*!< 虚拟根节点，不参与显示 */
QStringList headList; /*!< 头信息节点 */
};
} //namespace Base
#endif // NAVIGATEMODEL_H
| [
"407859345@qq.com"
] | 407859345@qq.com |
cb7fbe3c44d888eb3570bb9f5b31049e30138ea6 | 39c1673b3bb230861d2b42bad8d0fbd899d3f4fa | /Contest3/Bai4.cpp | faea58304069a5af5162fe433cb8df406df3f68e | [] | no_license | trickstarcandina/CTDL | 69b9b205f1b792cce9db894520d4b1a4c0ad9a4a | 5ab3e7e8be6f1a6e2f26e9de880495383d95dd84 | refs/heads/master | 2022-12-28T05:36:00.146268 | 2020-10-17T08:51:39 | 2020-10-17T08:51:39 | 304,835,997 | 5 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,700 | cpp | #include<bits/stdc++.h>
using namespace std;
const int MOD=1000000007;
void nhap(int n,int a[]){
for(int i=0;i<n;i++){
cin>>a[i];
}
}
long long xuly(int n, int a[]) {
sort(a, a + n);
long long x = 0, y = 0;
for (int i = 0; i < n; i++) {
if (i%2==1)
x = x*10 + a[i];
else
y = y*10 + a[i];
}
return x + y;
}
main(){
int t; cin>>t;
while (t--){
int n; cin>>n;
int a[n];
nhap(n,a);
cout<<xuly(n,a)<<endl;
}
}
/*
Trickstar Candina
_,add8ba,
,d888888888b,
d8888888888888b _,ad8ba,_
d888888888888888) ,d888888888b,
I8888888888888888 _________ ,8888888888888b
__________`Y88888888888888P"""""""""""baaa,__ ,888888888888888,
,adP"""""""""""9888888888P""^ ^""Y8888888888888888I
,a8"^ ,d888P"888P^ ^"Y8888888888P'
,a8^ ,d8888' ^Y8888888P'
a88' ,d8888P' I88P"^
,d88' d88888P' "b,
,d88' d888888' `b,
,d88' d888888I `b,
d88I ,8888888' ___ `b,
,888' d8888888 ,d88888b, ____ `b,
d888 ,8888888I d88888888b, ,d8888b, `b
,8888 I8888888I d8888888888I ,88888888b 8,
I8888 88888888b d88888888888' 8888888888b 8I
d8886 888888888 Y888888888P' Y8888888888, ,8b
88888b I88888888b `Y8888888^ `Y888888888I d88,
Y88888b `888888888b, `""""^ `Y8888888P' d888I
`888888b 88888888888b, `Y8888P^ d88888
Y888888b ,8888888888888ba,_ _______ `""^ ,d888888
I8888888b, ,888888888888888888ba,_ d88888888b ,ad8888888I
`888888888b, I8888888888888888888888b, ^"Y888P"^ ____.,ad88888888888I
88888888888b,`888888888888888888888888b, "" ad888888888888888888888'
8888888888888698888888888888888888888888b_,ad88ba,_,d88888888888888888888888
88888888888888888888888888888888888888888b,`"""^ d8888888888888888888888888I
8888888888888888888888888888888888888888888baaad888888888888888888888888888'
Y8888888888888888888888888888888888888888888888888888888888888888888888888P
I888888888888888888888888888888888888888888888P^ ^Y8888888888888888888888'
`Y88888888888888888P88888888888888888888888888' ^88888888888888888888I
`Y8888888888888888 `8888888888888888888888888 8888888888888888888P'
`Y888888888888888 `888888888888888888888888, ,888888888888888888P'
`Y88888888888888b `88888888888888888888888I I888888888888888888'
"Y8888888888888b `8888888888888888888888I I88888888888888888'
"Y88888888888P `888888888888888888888b d8888888888888888'
^""""""""^ `Y88888888888888888888, 888888888888888P'
"8888888888888888888b, Y888888888888P^
`Y888888888888888888b `Y8888888P"^
"Y8888888888888888P `""""^
`"YY88888888888P'
^""""""""'
*/ | [
"61593963+rinnegan101220@users.noreply.github.com"
] | 61593963+rinnegan101220@users.noreply.github.com |
514ed427753c5ee8efbbc7131fa0e9af0c9a0ad9 | 2be43a52f811e7e225acc81bfa0b922c8bfacc6d | /src/Constraints.cpp | c1ef44b7827fb615e646c0ef0b8ea85dd5fe87e8 | [] | no_license | mxgrey/RobotKin | bf790c32b263588b7c276f97fa80b620d3de161c | 19cfa0d3e2cd0d01fa75b455f7a7bbe99bdbe39a | refs/heads/master | 2021-01-20T23:27:00.997256 | 2017-03-27T20:49:59 | 2017-03-27T20:49:59 | 10,727,792 | 0 | 0 | null | 2013-07-20T05:17:57 | 2013-06-17T00:59:31 | C++ | UTF-8 | C++ | false | false | 2,574 | cpp |
#include "Robot.h"
#include "Constraints.h"
#include <time.h>
using namespace RobotKin;
using namespace Eigen;
using namespace std;
Constraints::Constraints()
: performNullSpaceTask(false),
hasRestingValues(false),
maxIterations(500),
dampingConstant(0.05),
finalTransform(TRANSFORM::Identity()),
convergenceTolerance(0.001),
performErrorClamp(true),
translationClamp(0.2),
rotationClamp(0.15),
customErrorClamp(false),
useIterativeJacobianSeed(true),
maxAttempts(3),
rotationScale(0.01),
performDeltaClamp(true),
deltaClamp(5*M_PI/180),
wrapToJointLimits(true),
wrapSolutionToJointLimits(true)
{
}
Constraints &Constraints::Defaults()
{
Constraints* constraints = new Constraints;
return *constraints;
}
void Constraints::restingValues(VectorXd newRestingValues)
{
performNullSpaceTask = true;
hasRestingValues = true;
restingValues_ = newRestingValues;
}
VectorXd& Constraints::restingValues() { return restingValues_; }
bool Constraints::nullComplete()
{
if(!performNullSpaceTask)
return true;
else
return nullComplete_;
}
VectorXd Constraints::nullSpaceTask(Robot& robot, const MatrixXd& J, const std::vector<size_t> &indices,
const VectorXd& values)
{
VectorXd nullTask = values;
nullTask.setZero();
nullComplete_ = true;
return nullTask;
}
void Constraints::errorClamp(Robot &robot, const std::vector<size_t> &indices, SCREW &error)
{
}
void Constraints::iterativeJacobianSeed(Robot& robot, size_t attemptNumber,
const std::vector<size_t> &indices, Eigen::VectorXd &values)
{
if( attemptNumber == 0 )
{
// wrapToJointLimits = true;
return;
}
else if( attemptNumber == 1 && hasRestingValues
&& values.size() == restingValues_.size() )
for(int i=0; i<values.size(); i++)
values(i) = restingValues_(i);
// else if( attemptNumber == 2 )
// {
// wrapToJointLimits = false;
// robot.imposeLimits = false;
// for(int i=0; i<values.size(); i++)
// values(i) = 0;
// }
else
{
int resolution = 1000;
int randVal = rand();
for(int i=0; i<values.size(); i++)
values(i) = ((double)(randVal%resolution))/((double)resolution-1)
*(robot.joint(indices[i]).max() - robot.joint(indices[i]).min())
+ robot.joint(indices[i]).min();
}
}
| [
"mxgrey@gatech.edu"
] | mxgrey@gatech.edu |
a8934f0f54d27d0984b686ba16009058584516ff | e9f0138f349251bdb17ada746ca37726ecc6e29b | /geometry.h | 3411d805ad2e8d4ab0e0b5225af5ea817e23bbd1 | [] | no_license | sylwiaZon/raytracer | 753c0b1cc9c9817b7882f600fe35ad3ac869195f | eaf5bbcf7250b8e8c57982e845535eb0b8ddff74 | refs/heads/master | 2020-03-19T16:58:03.845081 | 2018-07-10T22:35:16 | 2018-07-10T22:35:16 | 136,738,504 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,654 | h | #ifndef __GEOMETRY_H
#define __GEOMETRY_H
#include <iostream>
#include <cmath>
using namespace std;
class Point{
public:
float x,y,z;
Point();
Point(float _x, float _y, float _z);
};
class Vector{
public:
float x,y,z;
Vector();
Vector(float _x, float _y, float _z);
Vector(Point start, Point ending);
Vector operator+( const Vector &v) const;
Vector operator-(const Vector &v) const;
Vector operator*(const float &f) const;
float dot(const Vector &v) const;
Vector vectorProduct(const Vector & v) const;
void normalize();
void setLength(float d);
float getLength() const;
};
Point translate(const Point &p, const Vector &v);
float distanceFromPlane(const Point &p1, const float &A,const float &B,const float &C,const float &D);
bool onPlane(const Point &p, const float &A,const float &B,const float &C,const float &D);
float pointsDistance(const Point &p1,const Point &p2);
class Colour {
public:
float x,y,z;
Colour ();
Colour (float _x,float _y,float _z);
Colour operator+(const Colour &c);
Colour operator*(const float &c);
Colour operator*(const Colour &c);
};
class Object{
public:
Colour colour;
Point center;
Colour emissionColour;
float transparency,reflection;
virtual bool intersect(const Point &origin,const Vector &direction,float &t0, float &t1)=0;
virtual Vector getNormalVector(const Point &hit)=0;
};
class Sphere:public Object{
public:
float radius;
Sphere();
Sphere(const Point &c, const float &rad, const Colour &col,const Colour &emc,const float & tran,const float & relf);
virtual bool intersect(const Point &origin,const Vector &direction,float &t0, float &t1);
virtual Vector getNormalVector(const Point &hit);
};
class Plane:public Object{
Vector normalVector;
public:
Plane();
Plane(const Point &p,const Vector &v,const Colour &col,const Colour &emc);
virtual bool intersect(const Point &origin,const Vector &direction,float &t0, float &t1);
virtual Vector getNormalVector(const Point &hit);
};
class Cylinder:public Object{
Vector heightVector;
Vector baseVector;
Point closerPoint(const Vector &v1,const Vector &v2,const Point &origin);
float intersectBase(const Point &origin,const Vector &direction,const Point ¢);
public:
Cylinder();
Cylinder(const Point &p, const Vector &vh,const Vector &vp,const Colour &col,const Colour &em);
virtual bool intersect(const Point &origin,const Vector &direction,float &t0, float &t1);
virtual Vector getNormalVector(const Point &hit);
};
class Cone:public Object {
Vector heightVector;
float alfa;
float height;
float intersectBase(const Point &origin,const Vector &direction);
public:
Cone();
Cone(const Point &p, const Vector &vh,const float& a,const float&h,const Colour &col,const Colour &em);
virtual bool intersect(const Point &origin,const Vector &direction,float &t0, float &t1);
virtual Vector getNormalVector(const Point &hit);
};
class Cube:public Object {
Vector a,b,c;
float height;
float intersectOnPlane(const Point &origin,const Vector &direction,Vector a,Vector b,Vector c);
public:
Cube();
Cube(const Point &p, const Vector &a,const Vector &b,float h,const Colour &col,const Colour &em);
virtual bool intersect(const Point &origin,const Vector &direction,float &t0, float &t1);
virtual Vector getNormalVector(const Point &hit);
};
class Space{
Object **objects;
int objectsCount;
public:
Space(int n);
~Space();
void addObject(Object *obj);
Object* getObject(int i) const;
int getSize() const;
};
#endif
| [
"sylwia.zon@gmail.com"
] | sylwia.zon@gmail.com |
a2ce31d7483c3c0c72b486f3ff373bd98d942fef | c6edda04814ffb23df750ce23b81169ec35c0057 | /GameEditor/DefaultShaders.h | e7224169680d34d7e4f16fd7bfd5adcadcc15e07 | [] | no_license | wlodarczykbart/SunEngine | 91d755cca91ca04ef91879ccfd11500f884e5066 | 04200f084653e88ba332bb260b6964996f35f5a0 | refs/heads/master | 2023-06-07T02:33:20.668913 | 2021-07-03T17:31:38 | 2021-07-03T17:31:38 | 315,081,186 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 58 | h | #pragma once
#include "Types.h"
namespace SunEngine
{
} | [
"bartwlodarczyk92@gmail.com"
] | bartwlodarczyk92@gmail.com |
499e15d2a484da02ff68d7a22c7a5a0d2962abc6 | 0ba2ebb2042fae43162c246888ec666bbfe0fb6f | /Digital_simulation/Generators.cpp | b31e2591501a917fee98a3e64a101d48c60219fc | [] | no_license | PawelKozminskiPoznan/Digital_simulation | b8f063d668e869621dbcfec444b7d2ddd56b6f80 | a79ec1837178d451a840a61c0e32a0ee2ca4058f | refs/heads/master | 2022-06-04T08:21:05.467486 | 2020-04-27T14:33:59 | 2020-04-27T14:33:59 | 258,534,373 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,977 | cpp | #include "pch.h"
#include "Generators.h"
#include <iostream>
using namespace std;
double Generators::generateGrain()
{
int h =abs(grain / q);
grain = a * (grain - q * h) - r * h;
if (grain < 0)
grain = grain + m;
return grain;
}
double Generators::uniform()
{
grain = grain * a % m;
return abs(static_cast<double>(grain)/m);
}
int Generators::generateUniform(const int min,const int max)
{
return (int)uniform()*(max - min) + min;
}
int Generators::generateNormal(int average, double var)
{
double k = 0;
for(int i=0;i<12;i++)
{
k += uniform();
}
k = k - 6;
k = sqrt(var)*k + average;
return (int)k;
}
int Generators::generateExponentinal(double lambda)
{
lambda = 1 / lambda;
return (int)(-(1.0 / lambda)*log(uniform()));
}
int Generators::generateGeometric(double average)
{
int k = 1;
/*
while (uniform()>average)
{
++k;
}
return k;
*/
while (true)
{
if (uniform() > average)
{
k++;
continue;
}
break;
}
return k;
}
/*
void Generators::testGenerateExponentinal(double lambda,int samples)
{
double average = 0;
int result;
lambda = 1 / lambda;
cout << "Start Test Exponential Generator." << endl;
for (int i = 0; i < samples; ++i) {
result = -1 / lambda * log(uniform());
stat->saveStatsToFile(result, "exponential.xls");
average = average + result;
}
cout << "average : " << average / samples << endl;
}
void Generators::testGenerateGeometric(double w,int samples)
{
cout << "Start Test Geometric Generator." << endl;
double ave = 0;
int result;
for (auto i = 0; i < samples; ++i) {
result = 1;
while (true)
{
if (uniform() > w)
{
result++;
continue;
}
break;
}
stat->saveStatsToFile(result, "geometric.xls");
ave = ave + result;
}
cout << "w : " << 1 / (ave / samples) << endl;
cout << "average : " << double(ave / samples) << endl;
}
void Generators::testGenerateNormal(const double e, const double ew, const int samples)
{
cout << "Start Test Normal Generator." << endl;
double average = 0;
int result;
for (auto i = 0; i < samples; ++i)
{
result = 0;
double temp = 0;
for (auto index = 0; index < 12; index++)
{
temp += uniform();
}
temp -= 6.0;
result= temp * ew + e;
stat->saveStatsToFile(result, "normal.xls");
average = average + result;
}
cout << "average : " << average / samples << endl;
}
void Generators::testGenerateUniform(int min, int max,int samples)
{
double average = 0;
double numberUniform = 0;
cout << "Start Test Uniform Generator." << endl;
generateGrain();
for (auto i = 0; i < samples; ++i)
{
numberUniform = min + (max - min) * uniform();
stat->saveStatsToFile(numberUniform, "uniform.xls");
average = average + numberUniform;
}
cout << "average : " << average / samples << endl;
}
*/
Generators::Generators()//Statistics *s :stat(s)
{
m = 2147483647;
a = 16807;
q = 127773;
r = 2836;
grain = 1179;
}
Generators::~Generators()
{
}
| [
"pawel.kozminski.poznan@gmai.com"
] | pawel.kozminski.poznan@gmai.com |
1aa689eed40c534f035c430b3ee9a2b3e47b9e8f | 7980a127f0591ee1dc9a3fc00cf775eac1c4923a | /layers/Sequential.cpp | 55594ce388d984d0b10fa1c3855cc023230cceea | [] | no_license | ValenYamamoto/DeepLearningFramework | 90de76aa10d523bf9d48e85cde11e1c122ba648d | 242076f429d5dc31d522b22e2bb958103d3a77f8 | refs/heads/master | 2023-02-01T10:37:42.592837 | 2020-12-21T22:34:55 | 2020-12-21T22:34:55 | 316,268,063 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,090 | cpp | #include "../Tensor.hpp"
#include "Layer.hpp"
#include "Sequential.hpp"
Sequential::Sequential( int numLayers, Layer** layers ) : numLayers{numLayers}, layers{new Layer*[numLayers]}, intermediates{new Tensor[ numLayers ]} {
int i;
for( i=0; i<numLayers; i++ ) {
this->layers[i] = layers[i];
}
parameters = new Tensor*[numLayers];
for( i=0; i<numLayers; i++ ) {
this->parameters[i] = layers[i]->getParameters()[0];
}
}
Sequential::~Sequential() {
delete[] layers;
delete[] intermediates;
delete[] parameters;
}
void Sequential::add( Layer *newLayer ) {
numLayers++;
Layer** newLayers = new Layer*[numLayers];
int i;
for( i=0; i<numLayers-1; i++ ) {
newLayers[i] = layers[i];
}
delete[] layers;
layers = newLayers;
}
Tensor Sequential::forward( Tensor& input ) {
Tensor result = layers[0]->forward( input );
if( numLayers == 1 ) {
return result;
}
intermediates[0] = result;
int i;
for( i=0; i<numLayers-2; i++ ) {
intermediates[i+1] = layers[i+1]->forward( intermediates[0] );
}
return layers[ numLayers-1 ]->forward( intermediates[ numLayers-2 ] );
}
| [
"valenryamamoto@gmail.com"
] | valenryamamoto@gmail.com |
e199a87e1361c92d076d95693bdaca056a455d9c | b5648642fd2e05589cab760a909ce1dc38556d5d | /touchGFX/TGFX-Framework-include/touchgfx/Bitmap.hpp | 10cea0476bce70fe8cf349f5227eede8c34227fd | [] | no_license | sunklCoin/MCU | 862c8f8ee48872b3fc703d54c2d76bbb74cca1a4 | 9cc7a45fae3b18821c722f78d901034086ccc98c | refs/heads/master | 2021-07-14T00:58:51.259827 | 2017-10-16T14:12:55 | 2017-10-16T14:12:55 | 105,020,651 | 0 | 0 | null | 2017-10-16T14:12:56 | 2017-09-27T13:19:03 | C++ | UTF-8 | C++ | false | false | 19,329 | hpp | /******************************************************************************
*
* @brief This file is part of the TouchGFX 4.8.0 evaluation distribution.
*
* @author Draupner Graphics A/S <http://www.touchgfx.com>
*
******************************************************************************
*
* @section Copyright
*
* Copyright (C) 2014-2016 Draupner Graphics A/S <http://www.touchgfx.com>.
* All rights reserved.
*
* TouchGFX is protected by international copyright laws and the knowledge of
* this source code may not be used to write a similar product. This file may
* only be used in accordance with a license and should not be re-
* distributed in any way without the prior permission of Draupner Graphics.
*
* This is licensed software for evaluation use, any use must strictly comply
* with the evaluation license agreement provided with delivery of the
* TouchGFX software.
*
* The evaluation license agreement can be seen on www.touchgfx.com
*
* @section Disclaimer
*
* DISCLAIMER OF WARRANTY/LIMITATION OF REMEDIES: Draupner Graphics A/S has
* no obligation to support this software. Draupner Graphics A/S is providing
* the software "AS IS", with no express or implied warranties of any kind,
* including, but not limited to, any implied warranties of merchantability
* or fitness for any particular purpose or warranties against infringement
* of any proprietary rights of a third party.
*
* Draupner Graphics A/S can not be held liable for any consequential,
* incidental, or special damages, or any other relief, or for any claim by
* any third party, arising from your use of this software.
*
*****************************************************************************/
#ifndef BITMAP_HPP
#define BITMAP_HPP
#include <cassert>
#include <touchgfx/hal/Types.hpp>
#ifdef __ARMCC_VERSION
// Keil compiler issues irrelevant warning relating to missing ctor initialization for BitmapData.
#pragma diag_suppress 368
#endif
namespace touchgfx
{
/**
* @typedef uint16_t BitmapId
*
* @brief This type shall be used by the application to define unique IDs for all bitmaps in the
* system. The application shall define bitmap IDs in the range [0, number of bitmaps -
* 1].
*/
typedef uint16_t BitmapId;
const BitmapId BITMAP_ANIMATION_STORAGE = 0xFFFEU; ///< A virtual id representing animation storage.
const BitmapId BITMAP_INVALID = 0xFFFFU; ///< Define the bitmapId if an invalid bitmap
class BitmapData;
/**
* @class Bitmap Bitmap.hpp touchgfx/Bitmap.hpp
*
* @brief This class provides a proxy object for a bitmap image.
*
* This class provides a proxy object for a bitmap image stored in the application
* specific bitmap database. The proxy provides access to the raw bitmap data as well as
* metadata.
*/
class Bitmap
{
public:
/**
* @enum BitmapFormat
*
* @brief Data of a bitmap can be stored in the following formats.
*
* Data of a bitmap can be stored in the following formats.
*/
enum BitmapFormat
{
RGB565, ///< 16-bit, 5 bits for red, 6 bits for green, 5 bits for blue, no alpha channel
RGB888, ///< 24-bit, 8 bits for each of red, green and blue, no alpha channel
ARGB8888, ///< 32-bit, 8 bits for each of red, green, blue and alpha channel
BW, ///< 1-bit, black / white, no alpha channel
BW_RLE, ///< 1-bit, black / white, no alpha channel compressed with horizontal RLE
GRAY2, ///< 2-bit grayscale
GRAY4 ///< 4.bit grayscale
};
/**
* @struct BitmapData Bitmap.hpp touchgfx/Bitmap.hpp
*
* @brief Data of a bitmap.
*
* Data of a bitmap.
*/
struct BitmapData
{
const uint8_t* const data; ///< The data of this bitmap
const uint8_t* const alphaData; ///< The data of the alpha channel (contains 0 if no alpha channel exist)
const uint16_t width; ///< The width of the bitmap
const uint16_t height; ///< The height of the bitmap
const uint16_t solidRect_x; ///< The x coordinate of the maximum solid rectangle of the bitmap
const uint16_t solidRect_y; ///< The y coordinate of the maximum solid rectangle of the bitmap
const uint16_t solidRect_width; ///< The width of the maximum solid rectangle of the bitmap
const uint16_t solidRect_height : 13; ///< The height of the maximum solid rectangle of the bitmap
const uint8_t format : 3; ///< Determine the format of the data
};
/**
* @struct DynamicBitmapData Bitmap.hpp touchgfx/Bitmap.hpp
*
* @brief Data of a dynamic bitmap.
*
* Data of a dynamic bitmap.
*/
struct DynamicBitmapData
{
Rect solid; ///< The solidRect of this bitmap
uint16_t width; ///< The width of the bitmap
uint16_t height; ///< The height of the bitmap
uint16_t format; ///< Determine the format of the data
uint8_t inuse; ///< zero if not in use
uint8_t alpha; ///< true if separate alpha for 565 format (always false)
};
/**
* @struct CacheTableEntry Bitmap.hpp touchgfx/Bitmap.hpp
*
* @brief Cache bookkeeping.
*
* Cache bookkeeping.
*/
struct CacheTableEntry
{
uint8_t* data; ///< Pointer to location of image data for this bitmap in the cache. 0 if bitmap not cached.
};
/**
* @fn explicit Bitmap::Bitmap(const BitmapId id = BITMAP_INVALID)
*
* @brief Creates and binds a Bitmap instance to the corresponding entry in the BitmapData
* array.
*
* Creates and binds a Bitmap instance to the corresponding entry in the BitmapData
* array.
*
* @param id The unique bitmap identifier.
*/
explicit Bitmap(const BitmapId id = BITMAP_INVALID) : bitmapId(id)
{
}
/**
* @fn BitmapId Bitmap::getId() const
*
* @brief Gets the id of this Bitmap.
*
* Gets the id of this Bitmap.
*
* @return The id of this Bitmap.
*/
BitmapId getId() const
{
assert(bitmaps != 0 && "Bitmap database has not been initialized.");
return bitmapId;
}
/**
* @fn const uint8_t* Bitmap::getData() const;
*
* @brief Gets a pointer to the Bitmap data.
*
* Gets a pointer to the Bitmap data.
*
* @note If this bitmap is cached, it will return the cached version of bitmap data.
*
* @return A pointer to the raw bitmap data.
*/
const uint8_t* getData() const;
/**
* @fn const uint8_t* Bitmap::getAlphaData() const;
*
* @brief Gets a pointer to the alpha data, if present in the bitmap.
*
* Gets a pointer to the alpha data, if present in the bitmap.
*
* @note If this bitmap is cached, it will return the cached version of alpha data for this
* bitmap.
*
* @return A pointer to the raw alpha channel data. If no alpha channel exist 0 is returned.
*/
const uint8_t* getAlphaData() const;
/**
* @fn BitmapFormat Bitmap::getFormat() const;
*
* @brief Gets the format of how the bitmap is stored.
*
* Gets the format of how the bitmap is stored.
*
* @return The format of how the bitmap data is stored.
*/
BitmapFormat getFormat() const;
/**
* @fn uint16_t Bitmap::getWidth() const
*
* @brief Gets the width of the Bitmap in pixels.
*
* Gets the width of the Bitmap in pixels.
*
* @return The bitmap width in pixels.
*/
uint16_t getWidth() const;
/**
* @fn uint16_t Bitmap::getHeight() const
*
* @brief Gets the height of the Bitmap in pixels.
*
* Gets the height of the Bitmap in pixels.
*
* @return The bitmap height in pixels.
*/
uint16_t getHeight() const;
/**
* @fn Rect Bitmap::getRect() const
*
* @brief Gets the rectangle describing the dimensions of the Bitmap.
*
* Gets the rectangle describing the dimensions of the Bitmap.
*
* @return a Rect describing the dimensions of this bitmap.
*/
Rect getRect() const
{
return Rect(0, 0, getWidth(), getHeight());
}
/**
* @fn bool Bitmap::isAlphaPerPixel() const
*
* @brief Query if this object has an alpha channel.
*
* Query if this object has an alpha channel.
*
* @return True if the bitmap contains an alpha channel (an alpha value for each pixel)
*/
bool isAlphaPerPixel() const
{
assert(bitmaps != 0 && "Bitmap database has not been initialized.");
return ((bitmaps != 0) && (bitmapId < numberOfBitmaps)) ? (bitmaps[bitmapId].alphaData != 0) : false;
}
/**
* @fn Rect Bitmap::getSolidRect() const
*
* @brief Gets the largest solid rectangle in the bitmap.
*
* Gets the largest solid, i.e. not transparent, rectangle in the bitmap.
*
* @return The maximum solid rectangle of the bitmap.
*/
Rect getSolidRect() const;
/**
* @fn bool Bitmap::hasTransparentPixels() const
*
* @brief Query if this object has transparent pixels.
*
* @return True if this bitmap has transparent pixels.
*/
bool hasTransparentPixels() const;
/**
* @fn static void Bitmap::registerBitmapDatabase(const BitmapData* data, const uint16_t n, uint16_t* cachep = 0, uint32_t csize = 0);
*
* @brief Registers an array of bitmaps.
*
* Registers an array of bitmaps. All Bitmap instances are bound to this database.
*
* @param data A reference to the BitmapData storage array.
* @param n The number of bitmaps in the array.
* @param [in,out] cachep (Optional) Pointer to memory region in which bitmap data can be
* cached.
* @param csize Size of cache memory region in bytes (0 if unused)
* @param numberOfDynamicBitmaps Number of dynamic bitmaps to be allowed in the cache.
*/
static void registerBitmapDatabase(const BitmapData* data, const uint16_t n, uint16_t* cachep = 0, uint32_t csize = 0,
uint32_t numberOfDynamicBitmaps = 0);
/**
* @fn static bool Bitmap::cache(BitmapId id);
*
* @brief Cache this bitmap into RAM.
*
* Cache this bitmap into unused RAM in the bitmap cache.
*
* @note A memory region large enough to hold this bitmap must be configured and a large
* enough part of it must be available. Caching of a bitmap may involve a
* defragmentation of the bitmap cache. See TouchGFX documentation for details on
* caching.
*
* @param id The id of the bitmap to cache.
*
* @return true if caching went well, false otherwise.
*
* @see registerBitmapDatabase
*/
static bool cache(BitmapId id);
/**
* @fn static bool Bitmap::cacheReplaceBitmap(BitmapId out, BitmapId in);
*
* @brief Replace a bitmap in RAM with another Bitmap.
*
* Replace a bitmap in RAM with another Bitmap. The Bitmaps must have same size.
*
* @param out The id of the bitmap to remove from the cache.
* @param in The id of the bitmap to cache.
*
* @return true if the replacement went well, false otherwise.
*/
static bool cacheReplaceBitmap(BitmapId out, BitmapId in);
/**
* @fn static bool Bitmap::cacheRemoveBitmap(BitmapId id);
*
* @brief Remove this bitmap from the RAM cache.
*
* Remove this bitmap from the RAM cache.
*
* @note The bitmap will be removed from the RAM cache. Unless the bitmap is otherwise stored
* in (slow) RAM it can not be drawn anymore and must be cached again before use. The
* RAM freed can be used for caching of another bitmap. See TouchGFX documentation for
* details on caching.
*
* @param id The id of the bitmap to cache.
*
* @return true if bitmap was found and removed, false otherwise.
*
* @see registerBitmapDatabase
*/
static bool cacheRemoveBitmap(BitmapId id);
/**
* @fn static uint8_t* Bitmap::cacheGetAddress(BitmapId id);
*
* @brief Get address of cache buffer for this bitmap
*
* Get address of cache buffer for this bitmap. Note: The address is only valid
* until next Bitmap::cache() call.
*
* @param id The id of the bitmap in cache.
*
* @return Address if bitmap was found, zero otherwise.
*/
static uint8_t* cacheGetAddress(BitmapId id);
/**
* @fn static bool Bitmap::cacheIsCached(BitmapId id);
*
* @brief Check if the Bitmap is cached.
*
* Check if the Bitmap is cached.
*
* @param id The id of the bitmap.
*
* @return true if bitmap is cached.
*/
static bool cacheIsCached(BitmapId id);
/**
* @fn static bool Bitmap::cacheAll();
*
* @brief Cache all bitmaps from the Bitmap Database into RAM.
*
* Cache all bitmaps from the Bitmap Database into RAM.
*
* @note A memory region large enough to hold all bitmaps must be configured. See TouchGFX
* documentation for details on caching.
*
* @return True if all bitmaps where cached.
*
* @see cache.
*/
static bool cacheAll();
/**
* @fn static void Bitmap::clearCache();
*
* @brief Clears the cached bitmaps from RAM.
*
* Clears the cached bitmaps from RAM.
*/
static void clearCache();
/**
* @fn static BitmapId Bitmap::dynamicBitmapCreate(const uint16_t width, const uint16_t height, BitmapFormat format);
*
* @brief Create a dynamic bitmap.
*
* Create a dynamic bitmap.
*
* @param width Width of the bitmap.
* @param height Height of the bitmap.
* @param format Bitmap format of the bitmap.
*
* @return BitmapId of the new bitmap or BITMAP_INVALID if memory full.
*
* @note Creation of a new dynamic bitmap may cause existing dynamic bitmaps to be moved in
* memory. Do not rely on bitmap memory addresses of dynamic bitmaps obtained from
* dynamicBitmapGetAddress() to be valid across calls to dynamicBitmapCreate().
*
* @see dynamicBitmapAddress
*/
static BitmapId dynamicBitmapCreate(const uint16_t width, const uint16_t height, BitmapFormat format);
/**
* @fn static bool Bitmap::dynamicBitmapDelete(BitmapId id);
*
* @brief Delete a dynamic bitmap.
*
* Delete a dynamic bitmap.
*
* @param id The BitmapId of the dynamic bitmap.
*
* @return true if it succeeds, false if it fails.
*/
static bool dynamicBitmapDelete(BitmapId id);
/**
* @fn static uint8_t* Bitmap::dynamicBitmapGetAddress(BitmapId id);
*
* @brief Get the address of the dynamic bitmap data.
*
* Get the address of the dynamic bitmap data. It is important that the address of a
* dynamic bitmap is not stored elsewhere as a dynamic bitmap may be moved in memory
* when other bitmaps are added and removed. Only store the BitmapId and ask for the
* address of the bitmap data when needed.
*
* @param id The BitmapId of the dynamic bitmap.
*
* @return null if it fails, else an uint8_t*.
*
* @note The address of a dynamic bitmap may change when other dynamic bitmaps are added and
* removed. Never store the address of dynamic images, only store the BitmapId as that
* will not change.
*/
static uint8_t* dynamicBitmapGetAddress(BitmapId id);
/**
* @fn static bool Bitmap::dynamicBitmapSetSolidRect(BitmapId id, const Rect& solidRect);
*
* @brief Set the solid rectangle of a dynamic bitmap
*
* Set the solid rectangle of a dynamic bitmap. Only relevant for RGBA8888 bitmaps.
* The solid part of the bitmap is drawn faster than the transparent parts.
*
* @param id The identifier.
* @param solidRect The solid rectangle.
*
* @return true if it succeeds, false if it fails.
*/
static bool dynamicBitmapSetSolidRect(BitmapId id, const Rect& solidRect);
/**
* @fn bool Bitmap::operator==(const Bitmap& other) const
*
* @brief Equality operator.
*
* Equality operator.
*
* @param other The bitmap to compare with.
*
* @return True if this bitmap has the same id as the other bitmap.
*/
bool operator==(const Bitmap& other) const
{
return (bitmapId == other.bitmapId);
}
/**
* @fn bool Bitmap::operator!=(const Bitmap& other) const
*
* @brief Inequality operator.
*
* Inequality operator.
*
* @param other The bitmap to compare with.
*
* @return True if this bitmap has a different id than the other bitmap.
*/
bool operator!=(const Bitmap& other) const
{
return !(*this == other);
}
/**
* @fn static void Bitmap::setCache(uint16_t* cachep, uint32_t csize, uint32_t numberOfDynamicBitmaps = 0);
*
* @brief Register a memory region in which bitmap data can be cached.
*
* Register a memory region in which bitmap data can be cached.
*
* @param [in,out] cachep Pointer to memory region in which bitmap data can be cached.
* @param csize Size of cache memory region in bytes.
* @param numberOfDynamicBitmaps Number of dynamic bitmaps to be allowed in the cache.
*/
static void setCache(uint16_t* cachep, uint32_t csize, uint32_t numberOfDynamicBitmaps = 0);
private:
/**
* @fn static void Bitmap::compactCache();
*
* @brief Compact the bitmap cache to get continuous free memory on top.
*
* Compact the bitmap cache to get continuous free memory on top.
*
* @note This method is called by Bitmap::cache when required.
*/
static void compactCache();
static uint32_t getSizeOfBitmap(BitmapId id);
static bool copyBitmapToCache(BitmapId id, uint8_t* const dst);
BitmapId bitmapId;
static const BitmapData* bitmaps;
static DynamicBitmapData* dynBitmaps;
static CacheTableEntry* cacheTable; //address of allocation point cache
static BitmapId* allocationTable; //order of allocations in cache
static uint8_t* nextFreeData;
static uint16_t nextAllocationIndex;
static uint32_t memoryRemaining;
static uint32_t totalMemory;
static uint16_t numberOfBitmaps;
static uint16_t numberOfDynamicBitmaps;
static uint16_t uncachedCount; //uncached images, sort of ...
};
} // namespace touchgfx
#endif // BITMAP_HPP
| [
"sunkl.coin@gmail.com"
] | sunkl.coin@gmail.com |
0610ff251dd4e3630fd3b8c2c434352716dec069 | 9332137e23a3dcb56804371cf1580f1fd988c1aa | /stk/stk/random/wells512_generator.hpp | 8cef569497b70e0373090ec002759a19a77fad41 | [
"BSL-1.0"
] | permissive | brandon-kohn/simulation_toolkit | 5c590030a6b46b1722d3e1417505118e04f4f1c6 | 8a772f336701d0cdc66d386c4e0927325089b10a | refs/heads/master | 2023-09-01T15:37:02.517027 | 2023-08-16T15:17:55 | 2023-08-16T15:17:55 | 85,863,362 | 0 | 1 | null | 2018-05-09T15:45:58 | 2017-03-22T18:37:51 | C++ | UTF-8 | C++ | false | false | 2,055 | hpp | //
//! Copyright © 2018
// Chris Lomont (Public Domain)
//! Brandon Kohn (Wrapper and interfaces).
//
// Distributed under the Boost Software License, Version 1.0. (See
// accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Implementation from Chris Lomont: Lomont_PRNG_2008.pdf which is public domain.
// http://lomont.org/Math/Papers/2008/Lomont_PRNG_2008.pdf
//
#ifndef STK_WELLS512_GENERATOR_HPP
#define STK_WELLS512_GENERATOR_HPP
#pragma once
#include <geometrix/utility/assert.hpp>
#include <array>
#include <random>
#include <cstdint>
namespace stk {
class wells512_generator
{
public:
wells512_generator(unsigned int seed = 42)
{
this->seed(seed);
}
using result_type = std::uint32_t;
static BOOST_CONSTEXPR result_type min BOOST_PREVENT_MACRO_SUBSTITUTION (){ return 0; }
static BOOST_CONSTEXPR result_type max BOOST_PREVENT_MACRO_SUBSTITUTION (){ return (std::numeric_limits<result_type>::max)(); }
BOOST_FORCEINLINE result_type operator()()
{
std::uint32_t a = m_state[m_index];
std::uint32_t c = m_state[(m_index+13)&15];
std::uint32_t b = a^c^(a<<16)^(c<<15);
c = m_state[(m_index+9)&15];
c ^= (c>>11);
a = m_state[m_index] = b^c;
std::uint32_t d = a^((a<<5)&0xDA442D24UL);
m_index = (m_index + 15)&15;
a = m_state[m_index];
m_state[m_index] = a^b^d^(a<<2)^(b<<18)^(c<<28);
auto r = m_state[m_index];
GEOMETRIX_ASSERT(r >= (wells512_generator::min)() && r <= (wells512_generator::max)());
return r;
}
void seed(unsigned int seed = 42)
{
std::seed_seq seq{seed};
seq.generate(m_state.begin(), m_state.end());
}
private:
std::array<std::uint32_t, 16> m_state;
unsigned int m_index{0};
};
}//! stk;
#endif//! STK_WELLS512_GENERATOR_HPP
| [
"blkohn@hotmail.com"
] | blkohn@hotmail.com |
c08db44d8285af28c4c596c0dc89d4ca82b07c9f | 32a78ca8eb756114b38032b74a4e3a2f74a757a0 | /src/gpu/shader_lsq.hh | cfe4cc5a69eb33eb8d3255378b9a40f2947a58fa | [] | no_license | DesignSpaceExplore/gem5-gpu | b0e45b2f5164b7ec0afd837b3f3f3ecd4de9832f | 1960a6488d9671110b53184fc64051f7fe755bde | refs/heads/master | 2020-12-25T22:48:12.319776 | 2014-04-28T02:26:46 | 2014-04-28T02:26:46 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 16 | hh | shader_lsq_lf.hh | [
"vinay@Blackpearl.(none)"
] | vinay@Blackpearl.(none) |
6963aec4d277dc5c3b4de4930f508207da54c008 | 4a2224e862e7d3325c2437e023290d317b686636 | /security/permission-utils/src/main/cpp/ezbake_serialization.cpp | 6f8c4337d28ad3a2e479614ca4d2dcfcb5ef501b | [
"Apache-2.0"
] | permissive | ezbake/ezbake-common-cpp | b5b0ea1021e307db3e68e747b8dd8e06514d7fbd | 871e3947b1279a249607e71e05c2d31b6ef4079c | refs/heads/master | 2021-01-01T20:01:21.718923 | 2015-03-03T21:18:25 | 2015-03-03T21:19:03 | 31,560,584 | 0 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 4,026 | cpp | /* Copyright (C) 2013-2015 Computer Sciences Corporation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License. */
#include "ezbake_serialization.hpp"
#include "ezbake_serialization.h"
#include <memory>
#include "EzBakeBase_types.h"
#include "exception_to_error_string.hpp"
using std::unique_ptr;
using ezbake::base::thrift::AdvancedMarkings;
using ezbake::base::thrift::Authorizations;
using ezbake::base::thrift::EzSecurityToken;
using ezbake::base::thrift::PlatformObjectVisibilities;
using ezbake::base::thrift::Visibility;
using ezbake::deserialize_thrift;
visibility_handle_t *ezbake_deserialize_visibility_binary(
const uint8_t * const visibility_binary,
size_t visibility_binary_length,
char **error) {
EXCEPTION_TO_ERROR_STRING(NULL, {
unique_ptr<Visibility> vis{new Visibility()};
deserialize_thrift(
visibility_binary, visibility_binary_length, *vis);
return vis.release();
})
}
visibility_handle_t *ezbake_deserialize_visibility_base64(
const char * const visibility_base64,
char **error) {
EXCEPTION_TO_ERROR_STRING(NULL, {
unique_ptr<Visibility> vis{new Visibility()};
deserialize_thrift(visibility_base64, *vis);
return vis.release();
})
}
void ezbake_visibility_handle_free(visibility_handle_t *handle) {
delete static_cast<Visibility *>(handle);
}
authorizations_handle_t *ezbake_deserialize_authorizations_binary(
const uint8_t * const authorizations_binary,
size_t authorizations_binary_length,
char **error) {
EXCEPTION_TO_ERROR_STRING(NULL, {
unique_ptr<Authorizations> auths{new Authorizations()};
deserialize_thrift(
authorizations_binary, authorizations_binary_length, *auths);
return auths.release();
})
}
authorizations_handle_t *ezbake_deserialize_authorizations_base64(
const char * const authorizations_base64,
char **error) {
EXCEPTION_TO_ERROR_STRING(NULL, {
unique_ptr<Authorizations> auths{new Authorizations()};
deserialize_thrift(authorizations_base64, *auths);
return auths.release();
})
}
void ezbake_authorizations_handle_free(authorizations_handle_t *handle) {
delete static_cast<Authorizations *>(handle);
}
token_handle_t *ezbake_deserialize_token_binary(
const uint8_t * const token_binary,
size_t token_binary_length,
char **error) {
EXCEPTION_TO_ERROR_STRING(NULL, {
unique_ptr<EzSecurityToken> token{new EzSecurityToken()};
deserialize_thrift(token_binary, token_binary_length, *token);
return token.release();
})
}
token_handle_t *ezbake_deserialize_token_base64(
const char * const token_base64,
char **error) {
EXCEPTION_TO_ERROR_STRING(NULL, {
unique_ptr<EzSecurityToken> token{new EzSecurityToken()};
deserialize_thrift(token_base64, *token);
return token.release();
})
}
void ezbake_token_handle_free(token_handle_t *handle) {
delete static_cast<EzSecurityToken *>(handle);
}
authorizations_handle_t *ezbake_get_authorizations_from_token(
const token_handle_t *token_handle,
char **error) {
EXCEPTION_TO_ERROR_STRING(NULL, {
const EzSecurityToken *token =
static_cast<const EzSecurityToken *>(token_handle);
unique_ptr<Authorizations> auths{new Authorizations(
token->authorizations)};
return auths.release();
})
}
| [
"jhastings@42six.com"
] | jhastings@42six.com |
63754e1282a4af915b5b0dd8a31a13cb7d01a774 | db48761fc3cb0f8c702c5e66dbd4b683172e53cc | /euler40.cpp | 84d8865fe758f2d806670a3b3a1ad064ec7ce084 | [] | no_license | subrataduttauit/Project_Euler | 15e0e6e1dd3182c35fd1833d6ece826c96a2db98 | 9e9b17d6a7d07db23cb7749689bfdfeb0836e09d | refs/heads/master | 2020-04-21T00:37:00.450263 | 2015-08-24T18:59:45 | 2015-08-24T18:59:45 | 40,826,511 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 694 | cpp | /*
* Solution to Project Euler problem 40
* by Subrata Dutta
*
* University Institute of Technology, Burdwan University
* Dept. of Information Technology
* https://github.com/subrataduttauit
* https://in.linkedin.com/in/subrataduttauit
*/
#include <stdio.h>
#include <math.h>
int main(void)
{
int nth = 1;
int i;
int d[7], l;
int p = 1;
for (i = 1, l = 0; l < 7; i++) {
int digits = log10(i)+1;
int j;
for (j = 0; j < digits; j++, nth++) {
if (nth == pow(10, l)) {
d[l++] = (i / (int)pow(10, digits-j-1)) % 10; /* retrieve i's j-th digit */
}
}
}
for (i = 0; i < l; i++) {
p *= d[i];
}
printf("%d\n", p);
return 0;
}
| [
"subrataduttauit@gmail.com"
] | subrataduttauit@gmail.com |
1c38da3804637a7fccdc558037369ea3416c9496 | 8c540a482bdf6217c3f72aebf8a13966a6b48dbe | /containers/_tuple.cpp | aac69ee69b1c4327203d92aaad37bb1d9ecda5bd | [] | no_license | eyupgurel/workbench | 6633d131fac470ed981bcd193684b28948af1af6 | 4af3e71444f96a8ccff6bf594867daca48f2119e | refs/heads/master | 2020-04-21T16:17:29.864851 | 2019-10-16T19:45:30 | 2019-10-16T19:45:30 | 169,695,934 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,747 | cpp | //
// Created by egl on 6/13/19.
//
#include "_tuple.h"
using namespace containers;
std::tuple<int,int,int> rotate(std::tuple<int,int,int> t)
{
return tuple{std::get<2>(t),std::get<0>(t),std::get<1>(t)};
}
void drive_tuple() {
int i =1;
int j=2;
double d=1.2;
_tuple<int,int,double> _t1{i,j,d};
_tuple<int,int,double> _t12{1,1,1.2};
vector<int> vec{1,2,3};
_tuple<vector<int>,int,double, int, char,const char*,string,std::vector<int>> t3 {vector<int>{1,2,3}, i,1.1, 42, 'a',"ass","am",vec};
auto _tt = containers::__make_tuple(vector<int>{1,2,3}, i,1.1, 42, 'a',"ass","am",vec);
string s = "Hello";
vector<int> v = {1,22,3,4,5};
auto x = make_tuple(s,v,1.2);
Tuple<double , int, char> t1 {1.1, 42, 'a'};
cout << t1 << "\n";
cout << Tuple<double ,int,int,int>{1.2,3,5,7} << "\n";
cout << Tuple<double ,int,int>{1.2,3,5} << "\n";
cout << Tuple<double ,int>{1.2,3} << "\n";
cout << Tuple<double>{1.2} << "\n";
cout << Tuple<>{} << "\n";
auto xxx = Tuple{1.2,3,'x',1223};
cout << "{ " // write { 1.1, 42, a }
<< get<0>(t1) << ", "
<< get<1>(t1) << ", "
<< get<2>(t1) << " }\n";
auto xx = get<0>(t1); // xx is a double
get<2>(t1)='b';
cout << t1 << "\n";
const Tuple<double , int, char> t2 {1.1, 42, 'a'};
//get<2>(t2) = 'b';// error : t2 is const
char cc = get<2>(t2);
array<int,7>a={1,2,3,5,8,13,25};
auto x1=get<5>(a);// 13
auto x2 = a[5];// 13
auto sz = tuple_size<decltype(a)>::value;// 7
typename tuple_element<5,decltype(a)>::type x3 = 13;// x3 is an int
tuple<int,int,int>t3ints{3,5,8};
auto rotatedexp=rotate(t3ints);
auto rotatedimp=rotate({6,8,9});
} | [
"eyupgurel@gmail.com"
] | eyupgurel@gmail.com |
ccc04ae9bdab9b918a746dcc593fbcdceae1198e | b932134deff2e82f984c267c26b47ce74c521ef5 | /leetcode/1462. Course Schedule IV.cpp | 815a7da74838c438371a5fd20195b7bf483ec816 | [
"MIT"
] | permissive | chamow97/Interview-Prep | db234e0df0bfa6b3358d73ac187d6a132fa14595 | 9ce13afef6090b1604f72bf5f80a6e1df65be24f | refs/heads/master | 2022-11-06T07:06:54.705258 | 2020-06-21T07:29:14 | 2020-06-21T07:29:14 | 112,472,858 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,168 | cpp | class Solution {
public:
void dfs(int u, int v, vector< vector<int> > &adj, bool &possible, vector<bool> &visited) {
visited[u] = true;
if(u == v) {
possible = true;
}
for(auto i : adj[u]) {
if(!visited[i]) {
dfs(i, v, adj, possible, visited);
}
}
}
vector<bool> checkIfPrerequisite(int n, vector<vector<int>>& prerequisites, vector<vector<int>>& queries) {
vector<bool> visited(n, false);
vector< vector<int> > adj(n);
for(auto i : prerequisites) {
adj[i[0]].push_back(i[1]);
}
vector<bool> ans;
map<pair<int, int>, bool> ms;
for(auto i : queries) {
int u = i[0];
int v = i[1];
bool possible = false;
if(ms.find({u, v}) != ms.end()) {
possible = ms[{u, v}];
} else {
fill(visited.begin(), visited.end(), false);
dfs(u, v, adj, possible, visited);
}
ms[{u, v}] = possible;
ans.push_back(ms[{u, v}]);
}
return ans;
}
};
| [
"16441513+chamow97@users.noreply.github.com"
] | 16441513+chamow97@users.noreply.github.com |
be46126bb0292b53b23f46210c558a3b5edc7a92 | 3c3b480709b13db0603465de9f6ae0b1e9e46a91 | /D3D11_App/D3D11_App/Chapter13_Instancing and Culling/RenderStates.h | cfab003a77072ecaed04ddedf563903e16480803 | [] | no_license | skyvoid123/D3D11 | 6aa6aad03f79519390e855c16b9a2e0853b9beb1 | 5cee13cfb7612cb31f93e9c3787c12e5fe6cfbbd | refs/heads/master | 2020-12-07T11:49:17.747309 | 2017-04-28T02:20:30 | 2017-04-28T02:20:30 | 66,762,534 | 2 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 625 | h | #pragma once
#include "d3dUtil.h"
class RenderStates
{
public:
static void InitAll(ID3D11Device* device);
static void DestroyAll();
// Rasterizer states
static ID3D11RasterizerState* WireframeRS;
static ID3D11RasterizerState* NoCullRS;
static ID3D11RasterizerState* CullClockwiseRS;
// Blend states
static ID3D11BlendState* AlphaToCoverageBS;
static ID3D11BlendState* TransparentBS;
static ID3D11BlendState* NoRenderTargetWritesBS;
// Depth/stencil states
static ID3D11DepthStencilState* MarkMirrorDSS;
static ID3D11DepthStencilState* DrawReflectionDSS;
static ID3D11DepthStencilState* NoDoubleBlendDSS;
}; | [
"skyvoid@qq.com"
] | skyvoid@qq.com |
e3272df82eec09c1101ed967e9363894dd0bcc29 | ff92645b83f7e344cbf6f1938e0750634c234484 | /src/sensor_data/loop_pose.cpp | 5508a407a15f1dd8abe6f49ad52619789b1bb6bd | [] | no_license | leidali/lidar_localization | c8507109cc288e11a5bce96d0d0c05cbef8660cf | d7589bed13e85cdc09fbe36597432239c7b01ff7 | refs/heads/master | 2023-04-08T21:43:36.206233 | 2021-04-22T08:18:06 | 2021-04-22T08:18:06 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 301 | cpp | //
// Created by zlc on 2021/4/20.
//
#include "lidar_localization/sensor_data/loop_pose.hpp"
namespace lidar_localization
{
Eigen::Quaternionf LoopPose::GetQuaternion()
{
Eigen::Quaternionf q;
q = pose.block<3,3>(0,0); // 使用旋转矩阵直接给四元数赋值
return q;
}
}
| [
"2731275645@qq.com"
] | 2731275645@qq.com |
9af9cb94715cf7a36cd969bf492a57804027aca7 | 16240579ec9afe943ef9888ed6a161700e69b47e | /main.cpp | 13012b271ea635b7da6ad043c85e96a1a4e0c4df | [] | no_license | Artjxm/CppProjects | 876cae3c7c304db75daba4921701218a43e84e07 | 42365877ffc562caf3c7bc852b246fd72ff941e9 | refs/heads/master | 2022-12-22T02:13:32.275931 | 2020-09-22T09:08:42 | 2020-09-22T09:08:42 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,833 | cpp | #include <iostream>
#include <stack>
#include <algorithm>
#include <cmath>
bool isOperator(char c) {
return c == '+' || c == '-' || c == '*' || c == '/' || c == '^';
}
bool isOperand(char c) {
return isdigit(c);
}
int precedence (char c) {
if (c == '^')
return 3;
else if (c == '*' || c == '/')
return 2;
else if (c == '-' || c == '+')
return 1;
else
return -1;
}
std::string infixToPrefix(std::stack<char> stack, std::string infix) {
std::string prefix;
reverse(infix.begin(), infix.end());
for (auto i = 0; i < infix.length(); ++i) {
if (infix[i] == '(')
infix[i] = ')';
else if (infix[i] == ')')
infix[i] = '(';
}
for (auto i = 0; i < infix.length(); ++i) {
if (isOperand(infix[i]))
prefix += infix[i];
else if (infix[i] == '(')
stack.push(infix[i]);
else if (infix[i] == ')') {
while (stack.top() != '(' && !stack.empty()) {
prefix += stack.top();
stack.pop();
}
if (stack.top() == '(')
stack.pop();
}
else if (isOperator(infix[i])) {
if (stack.empty())
stack.push(infix[i]);
else {
if (precedence(infix[i]) > precedence(stack.top()))
stack.push(infix[i]);
else if ((precedence(infix[i]) == precedence(stack.top())) && infix[i] == '^') {
while ((precedence(infix[i]) == precedence(stack.top())) && infix[i] == '^') {
prefix += stack.top();
stack.pop();
}
stack.push(infix[i]);
}
else if (precedence(infix[i]) == precedence(stack.top()))
stack.push(infix[i]);
else {
while (!stack.empty() && precedence(infix[i]) < precedence(stack.top())) {
prefix += stack.top();
stack.pop();
}
stack.push(infix[i]);
}
}
}
}
while (!stack.empty()) {
prefix += stack.top();
stack.pop();
}
std::reverse(prefix.begin(), prefix.end());
return prefix;
}
int evaluatePrefix(std::string expr) {
std::stack<int> stack;
for (auto j = expr.length(); j >= 0; --j) {
if (isOperand(expr[j]))
stack.push(expr[j] - '0');
else {
int operand1 = stack.top();
stack.pop();
int operand2 = stack.top();
stack.pop();
switch (expr[j]) {
case '+':
stack.push(operand1 + operand2);
break;
case '-':
stack.push(operand1 - operand2);
break;
case '*':
stack.push(operand1 * operand2);
break;
case '/':
stack.push(operand1 / operand2);
break;
case '^':
stack.push(pow(operand1, operand2));
break;
default:
break;
}
}
}
return stack.top();
}
int main() {
std::string infix, prefix;
std::cout << "Enter your infix expression, please: ";
std::cin >> infix;
std::stack <char> stack;
prefix = infixToPrefix(stack, infix);
std::cout << "\nYour expression but in prefix style: " << prefix;
std::cout << "\nThe evaluated result is: " << evaluatePrefix(prefix);
}
| [
"Shadonspass1"
] | Shadonspass1 |
ae2710955e94e72f6edca7295e96e49a7808aa59 | cadb83f173998f3221cca0aee713fbb722fb7822 | /urg_timelapse_4/src/urgTimelapse.cpp | 2170edadf1faa4cbfcfe53869b8fa6f55c948d8c | [] | no_license | bensnell/urg-videography | b6d58be10cd2ee52e0ebf44e74fd7b677b89ff07 | 79611f9109497c00753261dd2c1ba72e914f317d | refs/heads/master | 2016-08-11T21:31:46.843383 | 2016-01-30T16:44:06 | 2016-01-30T16:44:06 | 50,728,978 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 17,313 | cpp | //
// urgTimelapse.cpp
// urg_timelapse_3
//
// Created by Ben Snell on 1/17/16.
//
//
// repeated scans are typically within 15 ms (but make this interval a little bigger)
#include "urgTimelapse.h"
urgTimelapse::urgTimelapse() {
timelapseControls.setName("Timelapse Setup");
timelapseControls.add(alignmentA.set("Frame Align Angle", -3.5, -10., 10.));
timelapseControls.add(startRotateX.set("Start X Rotation", 0, -180, 180));
timelapseControls.add(startRotateY.set("Start Y Rotation", 0, -180, 180));
timelapseControls.add(startRotateZ.set("Start Z Rotation", 0, -180, 180));
cam.setFarClip(15000);
}
// -----------------------------------------------------------------------
// load csv file into ofFile
void urgTimelapse::loadFile(string fileName) {
// CSV file placed in bin/data folder with TXY format
ofFile file(fileName);
cout << "Loading file " + fileName << endl;
// alt loading operations?
// file = ofFile(fileName);
// file.open(ofToDataPath(fileName), ofFile::ReadOnly, false);
if (!file.exists()) ofLogError("The file " + fileName + " is missing");
// load buffer with the file
buffer = file.readToBuffer();
cout << "File successfully read to buffer" << endl;
// alt loading operations?
// ofBuffer buffer(filePath);
// buffer = ofBufferFromFile(ofToDataPath(filePath));
// ofBufferToFile(ofToDataPath(fileName), buffer);
// buffer = ofBuffer(file);
// ofBuffer buffer(file);
}
// -----------------------------------------------------------------------
void urgTimelapse::findFrames(float speed, float periodSize, float startPeriod) {
// reset markers
frames.clear();
// nScans = -1;
long thisScanNumber = 0;
frame thisFrame;
thisFrame.startTime = -1; // start (zero) condition
// holds the current time sought after (to be >=)
long searchTime = long(startPeriod * periodSize / speed * 1000.); // ms
// loop through all lines to find the frames
for (ofBuffer::Line it = buffer.getLines().begin(), end = buffer.getLines().end(); it != end; ++it) {
string line = *it;
if (line.empty()) {
cout << "Empty line found. Stopping at scan # " << thisScanNumber << endl;
// nScans = thisScanNumber;
break;
}
// get time now
line.resize((int)line.find_first_of(','));
long timeNow = long(ofToDouble(line)); // ms
// check if timeNow is greater than searchTime
if (timeNow >= searchTime) {
// new frame is found, so store existing frame (unless it's the zeroth frame)
if (thisFrame.startTime != -1) {
// update its length
thisFrame.length = thisScanNumber - thisFrame.start;
// add it to the frame vector
frames.push_back(thisFrame);
}
// create a new frame with starting values
thisFrame.start = thisScanNumber;
thisFrame.startTime = float(timeNow / 1000.);
// update the search time
searchTime = long((startPeriod + frames.size() + 1) * periodSize / speed * 1000.);
}
// increment the scan number
thisScanNumber++;
}
cout << frames.size() << " frames have been found." << endl;
// if (nScans == -1) nScans = thisScanNumber
// print all frame info
// cout << "*** BEGIN ALL FRAME DATA ***" << endl;
// cout << "#" << "\t" << "start" << "\t" << "length" << "\t" << "startTime" << endl;
// for (long i = 0, end = frames.size(); i < end; i++) {
// cout << i << "\t" << frames[i].start << "\t" << frames[i].length << "\t" << frames[i].startTime << endl;
// }
// cout << "*** END ALL FRAME DATA ***" << endl;
}
// -----------------------------------------------------------------------
// fill mesh with the first capture
// scans are spaced out according to the speed of the rotations (degrees/sec; default = 225/64) and the timestamp of each step
// each period is 180 degrees since we're recording both sides of the lidar every scan
void urgTimelapse::fillFirstFrame(float speed, float periodSize, bool bClockwise, float alignmentAngle, float startPeriod) {
// clear mesh for good measure
firstFrame.clear();
// ------------------------------------
// ------- FIND SCANS IN FRAME --------
// ------------------------------------
// holds first time (in seconds)
float timeZero;
// interval of interest of the scans
long frameStart = -1;
long frameLength = -1;
// find max interval within which to search one period
float overfillAmt = 1.25;
long maxSearchInterval = long(periodSize * 1/speed * 10. * overfillAmt); // overfillAmt times ideal number of scans in one frame
// start and stop times to search for
float startTime = startPeriod * periodSize / speed * 1000.;
float stopTime = (startPeriod * periodSize + periodSize) / speed * 1000.;
// For the first frame, find the start and stop scans
// Note: last line may be empty
long thisScanNumber = 0;
for (ofBuffer::Line it = buffer.getLines().begin(), end = buffer.getLines().end(); it != end; ++it) {
// get the first number (time) in this line
string line = *it;
if (line.empty()) {
cout << "Skipping empty line" << endl;
// increment counter here?
continue;
}
line.resize((int)line.find_first_of(','));
float timeNow = ofToFloat(line); // in milliseconds
// cout << timeNow << endl;
// check if this scan is the start of the frame so long as it has not yet been found
if (frameStart == -1) {
if (timeNow >= startTime) {
frameStart = thisScanNumber;
timeZero = timeNow / 1000.;
}
}
// check if it's the end of the interval
if (frameStart != -1) {
if (timeNow >= stopTime) {
frameLength = thisScanNumber - frameStart;
break;
}
}
// increment the counter
thisScanNumber++;
if (thisScanNumber > frameStart + maxSearchInterval) {
cout << "Couldn't find end of first frame. Try increasing search interval." << endl;
break;
}
}
// ------------------------------------
// --------- FILL FIRST FRAME ---------
// ------------------------------------
// reset counter
thisScanNumber = 0;
// add all scans to the mesh
ofBuffer::Line it = buffer.getLines().begin();
advance(it, frameStart);
ofBuffer::Line end = buffer.getLines().begin();
advance(end, frameStart + frameLength);
for (it; it != end; ++it) {
// get this line and split up the measurements
string line = *it;
if (line.empty()) {
cout << "Skipping empty line" << endl;
continue;
}
vector<string> values = ofSplitString(line, ",");
// get timeNow
float timeNow = ofToFloat(values[0]) / 1000. - timeZero; // in seconds
// put all the points in a scan in the mesh
for (int i = minIndex; i < maxIndex; i++) {
// find the x and y coordinates
float px = ofToFloat(values[2 * i + 1]);
float py = ofToFloat(values[2 * i + 2]);
// find the vector to this point
ofVec3f thisPoint(px, py, 0.);
// remove points too close
double sqDist = thisPoint.distanceSquared(ofVec3f(0.,0.,0.));
if (sqDist < minSqDist2Cam) continue;
// rotate this point 90 degrees about the z axis to orient it upwards
thisPoint.rotate(90., ofVec3f(0., 0., 1.));
// apply the alignment angle stretch or compression to realign the two chuncks
float alignmentFactor = (float)i / 682. * alignmentAngle;
thisPoint.rotate(alignmentFactor, ofVec3f(0., 0., 1.));
// rotate this point about the y axis an amount proportional to this scanNumber and the number of scans in this frame (since this changes)
float rotationAmt = (float)thisScanNumber / (float)frameLength * periodSize;
// cout << rotationAmt << endl;
// if clockwise is true, rotate in negative direction
if (bClockwise) rotationAmt *= -1.;
thisPoint.rotate(rotationAmt, ofVec3f(0., 1., 0.));
// add the point to the mesh with a color
firstFrame.addVertex(thisPoint);
firstFrame.addColor(ofFloatColor(1.));
}
thisScanNumber++;
}
}
// ---------------------------------------------------------------------
// graphs 360 degree panorama
// slide is the rotation here
void urgTimelapse::drawFirstFrame() {
// cam.begin();
ofPushMatrix();
// rotate the original frame
ofRotate(startRotateX, 1, 0, 0);
ofRotate(startRotateY, 0, 1, 0);
ofRotate(startRotateZ, 0, 0, 1);
firstFrame.drawVertices();
ofPopMatrix();
// cam.end();
}
// ---------------------------------------------------------------------
void urgTimelapse::reset() {
frameNum = 0;
}
// ---------------------------------------------------------------------
void urgTimelapse::run(float speed, float periodSize, bool bClockwise, float alignmentAngle, float startPeriod) {
// exit function if frame number is -1
if (frameNum == -1) return;
// reset frame (MUST DO THIS)
renderedFrame.clear();
// ------------------------------------
// ------------ FILL FRAME ------------
// ------------------------------------
// reset counter
int scanNum = 0;
// add scans to the mesh as dictated by the frames
ofBuffer::Line it = buffer.getLines().begin();
advance(it, frames[frameNum].start);
ofBuffer::Line end = buffer.getLines().end();
for (it, end; it != end; ++it) {
// get line
string line = *it;
vector<string> values = ofSplitString(line, ",");
// put all the points in a scan in the mesh
for (int i = minIndex; i < maxIndex; i++) {
// find the x and y coordinates
float px = ofToFloat(values[2 * i + 1]);
float py = ofToFloat(values[2 * i + 2]);
// find the vector to this point
ofVec3f thisPoint(px, py, 0.);
// remove points too close
double sqDist = thisPoint.distanceSquared(ofVec3f(0.,0.,0.));
if (sqDist < minSqDist2Cam) continue;
// rotate this point 90 degrees about the z axis to orient it upwards
thisPoint.rotate(90., ofVec3f(0., 0., 1.));
// apply the alignment angle stretch or compression to realign the two chuncks
float alignmentFactor = (float)i / 682. * alignmentAngle;
thisPoint.rotate(alignmentFactor, ofVec3f(0., 0., 1.));
// rotate this point about the y axis an amount proportional to this scanNumber and the number of scans in this frame (since this changes)
float rotationAmt = (float)scanNum / (float)frames[frameNum].length * periodSize;
// if clockwise is true, rotate in negative direction
if (bClockwise) rotationAmt *= -1.;
// if period is 180 and frame is odd, rotate 180 degrees
if ((int)periodSize == 180 && (frameNum % 2)) rotationAmt += 180.;
thisPoint.rotate(rotationAmt, ofVec3f(0., 1., 0.));
// add the point to the mesh with a color
renderedFrame.addVertex(thisPoint);
renderedFrame.addColor(ofFloatColor(1.));
}
scanNum++;
if (scanNum >= frames[frameNum].length) break;
}
cout << "rendered frame # " << frameNum << endl;
// increment the frame number
frameNum++;
if (frameNum >= frames.size()) {
// stop running this operation
frameNum = -1;
}
// NOW RENDER
ofPushMatrix();
// rotate the original frame
ofRotate(startRotateX, 1, 0, 0);
ofRotate(startRotateY, 0, 1, 0);
ofRotate(startRotateZ, 0, 0, 1);
renderedFrame.drawVertices();
ofPopMatrix();
// SAVE IMAGE
ofSaveFrame();
}
// ---------------------------------------------------------------------
//void urgTimelapse::render() {
//
// ofPushMatrix();
//
// // rotate the original frame
// ofRotate(startRotateX, 1, 0, 0);
// ofRotate(startRotateY, 0, 1, 0);
// ofRotate(startRotateZ, 0, 0, 1);
//
// renderedFrame.drawVertices();
//
// ofPopMatrix();
//
// ofSaveFrame();
//}
// ---------------------------------------------------------------------
// fill mesh with a spherical capture
// scans are spaced out according to the speed of the rotations (degrees/sec; default = 225/64) and the timestamp of each step
// each period is 180 degrees since we're recording both sides of the lidar every scan
//void urgDisplay::fillPointMeshTXYSpherical(float speed, float period, bool bClockwise, float startingPeriod, float numPeriods, float alignmentAngle) {
//
// // clear the mesh
// pointMesh.clear();
//
// // if either variable is -1, set it to default or max
// if (startingPeriod == -1.) startingPeriod = 0;
// if (numPeriods == -1.) numPeriods = 99999.;
//
//
//
// // set time zero
// float timeZero;
//
// // interval of interest of the scans
// int startIndex = -1;
// int endIndex = -1;
//
// // first, find the starting points and ending points for the sphere
// for (int i = 0; i < nScans; i++) {
//
// // find the current time
// float timeNow = csv.getFloat(i, 0) / 1000.; // in seconds
//
// // check if this scan is the start of the interval of interest so long as it has not yet been found
// if (startIndex == -1) {
// if ((timeNow * speed) >= (startingPeriod * period)) {
// startIndex = i;
// timeZero = timeNow;
// }
// }
//
// // check if it's the end of the interval
// if (startIndex != -1) {
// if ((timeNow * speed) >= ((startingPeriod + numPeriods) * period)) {
// endIndex = i;
// break;
// }
// }
// }
//
// // if endIndex wasn't assigned, assign it to the total number of scans
// if (endIndex == -1) endIndex = nScans;
//
// // ------------------------------------------
// // ---------- FILL THE POINT MESH -----------
// // ------------------------------------------
//
// // for every scan within the interval, add it to the mesh
// for (int i = startIndex; i < endIndex; i++) {
//
// // get the current time
// float timeNow = csv.getFloat(i, 0) / 1000. - timeZero;
//
// // put all the points in a scan in the mesh
// for (int j = minIndex; j < maxIndex; j++) { // NOTE: I've been doing this wrong (i.e. wrong order of operations... this is why there are so many points at zero, zero)... it's right here now
//
// // find the x and y coordinates
// float px = csv.getFloat(i, 2 * j + 1);
// float py = csv.getFloat(i, 2 * j + 2);
//
// // find the vector to this point
// ofVec3f thisPoint(px, py, 0.);
//
//
//
// // remove points too close
// double sqDist = thisPoint.distanceSquared(ofVec3f(0.,0.,0.));
//
// // cout << sqDist << endl;
//
// if (sqDist < minSqDist2Cam) continue;
//
//
// // if (px < 100. && py < 100.) continue;
//
// // rotate this point 90 degrees about the z axis to orient it upwards
// thisPoint.rotate(90., ofVec3f(0., 0., 1.));
//
// // apply the alignment angle stretch or compression to realign the two chuncks
// float alignmentFactor = (float)j / 682. * alignmentAngle;
// thisPoint.rotate(alignmentFactor, ofVec3f(0., 0., 1.));
//
// // rotate the point about the y axis an amount proportional to the elapsed time and the speed
// float rotationAmt = timeNow * speed;
// // if clockwise is true, rotate in negative direction
// if (bClockwise) rotationAmt *= -1.;
// thisPoint.rotate(rotationAmt, ofVec3f(0., 1., 0.));
//
// // add the point to the mesh with a color
// pointMesh.addVertex(thisPoint);
// pointMesh.addColor(ofFloatColor(1.));
// }
// }
//}
| [
"bensnellstudio@gmail.com"
] | bensnellstudio@gmail.com |
0f4b9001ab469ce5954dfee5527c28cd842c65b2 | da64f2caeedea6c2889621c4c4bbb9ec812b6ba7 | /include/MemoryMap.hpp | 1589a2d24c9bee5c4abbe59ddff4b3f60d89f7cf | [] | no_license | FelixWeichselgartner/GameBoy-Classic-Emulator | cce53440844eeee098b3b5c31f5a8a71487c500e | 495a00f8389af39700dd7d3e436b151921210ff8 | refs/heads/master | 2021-07-13T07:19:32.846441 | 2020-06-23T17:18:29 | 2020-06-23T17:18:29 | 173,909,929 | 4 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,924 | hpp | #ifndef MEMORYMAP_HPP_
#define MEMORYMAP_HPP_
//----------------------------------------------------------------------------------------------
// Memory Map:
#define ADDR_ROM_0 0x0000 // 16KB ROM Bank 00 (in cartridge, fixed at bank 00)
#define ADDR_ROM_1 0x4000 // 16KB ROM Bank 01...NN (in cartridge, witchable bank number)
#define ADDR_VRAM_T_S 0x8000 // VRAM: Tiles and Sprites
#define ADDR_VRAM_T_A 0x9000 // VRAM: Tiles Alt
#define ADDR_VRAM_T_M_1 0x9800 // VRAM: Tilemap 1
#define ADDR_VRAM_T_M_2 0x9C00 // VRAM: Tilemap 2
#define ADDR_EXT_RAM 0xA000 // 8KB External RAM (in cartridge, switchable bank, if any)
#define ADDR_INT_RAM_1 0xC000 // 4KB Work RAM Bank 0 (WRAM)
#define ADDR_INT_RAM_2 0xD000 // 4KB Work RAM Bank 1 (WRAM) (switchable bank 1-7 in CGB Mode)
#define ADDR_ECHO 0xE000 // Same as C000-DDFF (ECHO) (typically not used)
#define ADDR_OAM 0xFE00 // Sprite Attribute Table (OAM) (Can't change during screen redraw)
#define ADDR_UNUSABLE 0xFEA0 // Not Usable
#define ADDR_IO 0xFF00 // I/O Ports
#define ADDR_DIV_REG 0xFF04 // divider register state
#define ADDR_TIMA 0xFF05 // current state if the timer counting
#define ADDR_TMA 0xFF06 // timer is reset to this value after overflow
#define ADDR_TMC 0xFF07 // timer control
#define ADDR_INTR_REQ 0xFF0F // Interupt Request Register
#define ADDR_HRAM 0xFF80 // High RAM (HRAM) (Stack)
#define ADDR_INTR_EN 0xFFFF // Interupt Enable Register
//----------------------------------------------------------------------------------------------
// Size of memory regions.
const int VRAM_SIZE = ADDR_EXT_RAM - ADDR_VRAM_T_S;
const int ECHO_SIZE = ADDR_OAM - ADDR_ECHO;
const int OAM_SIZE = ADDR_UNUSABLE - ADDR_OAM;
const int IO_SIZE = ADDR_HRAM - ADDR_IO;
const int HRAM_SIZE = ADDR_INTR_EN - ADDR_HRAM;
//----------------------------------------------------------------------------------------------
#endif | [
"felix.weichselgartner@t-online.de"
] | felix.weichselgartner@t-online.de |
bac7d413b69ea52afdfdb46d988f20d34df1befc | 21a7244cc28c301bb38e40208ed0ca70f77c604b | /TJU/1131 - The Circumference of the Circle.cpp | 5d6618efaeed6f905967e1c6d300b11a358b0c66 | [] | no_license | jhtan/Online-Judge-Solutions | fc18efb8d8310bd06edb96c4b2ea0ac0dc79aae5 | 7c2d870affda103d57ecd6f0820b9e6fe5c58928 | refs/heads/master | 2020-12-03T05:10:33.420297 | 2013-09-10T20:21:03 | 2013-09-10T20:21:03 | 15,348,130 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 645 | cpp | #include <iostream>
#include <iomanip>
#include <cmath>
#define PI 3.141592653589793
using namespace std;
int main(){
freopen("in.txt","r",stdin);
freopen("out.txt","w",stdout);
double x1,y1,x2,y2,x3,y3;
double a,b,c,S,R;
while(cin>>x1>>y1>>x2>>y2>>x3>>y3){
a=sqrt((x1-x2)*(x1-x2)+(y1-y2)*(y1-y2));
b=sqrt((x2-x3)*(x2-x3)+(y2-y3)*(y2-y3));
c=sqrt((x3-x1)*(x3-x1)+(y3-y1)*(y3-y1));
S=0.5*fabs(x1*y2+x2*y3+x3*y1-y1*x2-y2*x3-y3*x1);
R=a*b*c/(4*S);
cout<<fixed<<setprecision(2)<<2*PI*R<<endl;
}
return 0;
}
| [
"marioyc@marioyc-laptop.(none)"
] | marioyc@marioyc-laptop.(none) |
fb8a216ef702f2c85e3126ef8f79eb8b934b9af5 | bc90e70ee2139b034c65a5755395ff55faac87d0 | /libs/algorithm/test/pop_heap.cpp | 52f0ee211adbf01b6ecfcee2b0e028a7746ec030 | [
"BSL-1.0"
] | permissive | Manu343726/Sprout | 0a8e2d090dbede6f469f6b875d217716d0200bf7 | feac3f52c785deb0e5e6cd70c8b4960095b064be | refs/heads/master | 2021-01-21T07:20:16.742204 | 2015-05-28T04:11:39 | 2015-05-28T04:11:39 | 37,670,169 | 0 | 1 | null | 2015-06-18T16:09:41 | 2015-06-18T16:09:41 | null | UTF-8 | C++ | false | false | 2,286 | cpp | /*=============================================================================
Copyright (c) 2011-2015 Bolero MURAKAMI
https://github.com/bolero-MURAKAMI/Sprout
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
=============================================================================*/
#ifndef SPROUT_LIBS_ALGORITHM_TEST_POP_HEAP_CPP
#define SPROUT_LIBS_ALGORITHM_TEST_POP_HEAP_CPP
#include <sprout/algorithm/pop_heap.hpp>
#include <sprout/array.hpp>
#include <sprout/sub_array.hpp>
#include <sprout/container.hpp>
#include <testspr/tools.hpp>
namespace testspr {
static void algorithm_pop_heap_test() {
using namespace sprout;
{
SPROUT_STATIC_CONSTEXPR auto arr1 = array<int, 10>{{10, 8, 9, 6, 7, 5, 3, 1, 2, 4}};
// pop heap
{
SPROUT_STATIC_CONSTEXPR auto heap = sprout::pop_heap(
arr1
);
TESTSPR_BOTH_ASSERT(testspr::equal(
heap,
array<int, 10>{{9, 8, 5, 6, 7, 4, 3, 1, 2, 10}}
));
}
{
SPROUT_STATIC_CONSTEXPR auto heap = sprout::fit::pop_heap(
arr1
);
TESTSPR_BOTH_ASSERT(testspr::equal(
heap,
array<int, 9>{{9, 8, 5, 6, 7, 4, 3, 1, 2}}
));
}
// pop heap
// from sub range
{
SPROUT_STATIC_CONSTEXPR auto heap = sprout::pop_heap(
sprout::sub(arr1, 2, 10)
);
TESTSPR_BOTH_ASSERT(testspr::equal(
heap,
array<int, 8>{{7, 6, 4, 5, 3, 1, 2, 9}}
));
TESTSPR_BOTH_ASSERT(testspr::equal(
sprout::get_internal(heap),
array<int, 10>{{10, 8, 7, 6, 4, 5, 3, 1, 2, 9}}
));
}
{
SPROUT_STATIC_CONSTEXPR auto heap = sprout::fit::pop_heap(
sprout::sub(arr1, 2, 10)
);
TESTSPR_BOTH_ASSERT(testspr::equal(
heap,
array<int, 7>{{7, 6, 4, 5, 3, 1, 2}}
));
TESTSPR_BOTH_ASSERT(testspr::equal(
sprout::get_internal(heap),
array<int, 10>{{10, 8, 7, 6, 4, 5, 3, 1, 2, 9}}
));
}
}
}
} // namespace testspr
#ifndef TESTSPR_CPP_INCLUDE
# define TESTSPR_TEST_FUNCTION testspr::algorithm_pop_heap_test
# include <testspr/include_main.hpp>
#endif
#endif // #ifndef SPROUT_LIBS_ALGORITHM_TEST_POP_HEAP_CPP
| [
"bolero.murakami@gmail.com"
] | bolero.murakami@gmail.com |
74261dfff6080f2f42a2eb66226059a098b1228e | e54b9ff5eaf41ab13d156430554077f133b1be06 | /leetcode2134/leetcode2134_2.cpp | 6b64f3bbc855501f464e127bfa517ff62dd0dce8 | [] | no_license | allpasscool/leetcodes | bb0bd1391d5201baad214e5b4f8089dfe9c782b0 | 4fd81b4cf9382890cadc6bf8def721cc25eb9949 | refs/heads/master | 2022-05-21T11:34:06.958063 | 2022-03-24T08:57:41 | 2022-03-24T08:57:41 | 163,725,766 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,361 | cpp | class Solution
{
public:
int minSwaps(vector<int> &nums)
{
int totalOnes = 0, curOnesInWindow = 0, onesInWindow = 0, n = nums.size();
for (int i = 0; i < n; i++)
if (nums[i] == 1)
totalOnes++;
int left = 0;
for (int right = 0; right < n * 2 && left < n; right++)
{
left = right - totalOnes;
// right >= totalOnes means that the window size is as big as totalOnes
// so we need to move left
// why need to do "nums[left % n]"? consider [0, 0]
// when right = 3, totalOnes = 0
// 3 - 0 = 0 => nums[3 % n]
if (right >= totalOnes && nums[left % n] == 1)
curOnesInWindow--;
if (nums[right % n] == 1)
curOnesInWindow++;
onesInWindow = max(curOnesInWindow, onesInWindow);
}
return totalOnes - onesInWindow;
}
};
// Runtime: 96 ms, faster than 88.03% of C++ online submissions for Minimum Swaps to Group All 1's Together II.
// Memory Usage: 80.5 MB, less than 52.47% of C++ online submissions for Minimum Swaps to Group All 1's Together II.// time complexity: O(n)
// space complexity: O(1)
// https://leetcode.com/problems/minimum-swaps-to-group-all-1s-together-ii/discuss/1676865/Python3-Java-C%2B%2B-Easy-Sliding-Window-O(n) | [
"a82012844013@yahoo.com.tw"
] | a82012844013@yahoo.com.tw |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.