text
stringlengths 8
6.88M
|
|---|
/*
* Copyright (c) Meta Platforms, Inc. and affiliates.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*/
#pragma once
#include <cstddef>
#include <cstdint>
namespace quic {
using PacketNum = uint64_t;
/**
* Returns a decoded packet number by using the expectedNextPacketNum to
* search for the most probable packet number that could satisfy that condition.
*/
PacketNum decodePacketNumber(
uint64_t encodedPacketNum,
size_t packetNumBytes,
PacketNum expectedNextPacketNum);
struct PacketNumEncodingResult {
PacketNum result;
// This is packet number length in bytes
size_t length;
PacketNumEncodingResult(PacketNum resultIn, size_t lengthIn);
};
PacketNumEncodingResult encodePacketNumber(
PacketNum packetNum,
PacketNum largestAckedPacketNum);
} // namespace quic
|
/*!
* @author Nicholas Kidd
*/
#include "wali/wpds/LinkedTrans.hpp"
#include "wali/wpds/Config.hpp"
namespace wali
{
namespace wpds
{
LinkedTrans::LinkedTrans( wali_key_t from,
wali_key_t stack,
wali_key_t to,
const sem_elem_t & se,
Config *config_
) : Trans(from,stack,to,se),config(config_) {}
LinkedTrans::~LinkedTrans() {}
} // namespace wpds
} // namespace wali
|
template <typename T,int n> struct Mat{
T a[n][n];
Mat(){memset(a,0,sizeof(a));}
void unit(){
for(int i=0;i<n;i++)a[i][i]=1;
}
Mat& operator*=(const Mat<T,n>&b){
Mat<T,n> t;
for(int i=0;i<n;i++)
for(int k=0;k<n;k++)
if(a[i][k])for(int j=0;j<n;j++){
t.a[i][j]+=a[i][k]*b.a[k][j];
}
*this=t; return *this;
}
Mat pow(ll k)const{
Mat<T,n> r,p=*this;
r.unit();
for(;k;k>>=1,p*=p) if(k&1) r*=p;
return r;
}
};
|
/*
Crayfish - A collection of tools for TUFLOW and other hydraulic modelling packages
Copyright (C) 2016 Lutra Consulting
info at lutraconsulting dot co dot uk
Lutra Consulting
23 Chestnut Close
Burgess Hill
West Sussex
RH15 8HN
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
#include "crayfish_e3t.h"
#include <QPointF>
#include <QVector2D>
bool E3T_physicalToBarycentric(QPointF pA, QPointF pB, QPointF pC, QPointF pP, double& lam1, double& lam2, double& lam3)
{
if (pA == pB || pA == pC || pB == pC)
return false; // this is not a valid triangle!
// Compute vectors
QVector2D v0( pC - pA );
QVector2D v1( pB - pA );
QVector2D v2( pP - pA );
// Compute dot products
double dot00 = QVector2D::dotProduct(v0, v0);
double dot01 = QVector2D::dotProduct(v0, v1);
double dot02 = QVector2D::dotProduct(v0, v2);
double dot11 = QVector2D::dotProduct(v1, v1);
double dot12 = QVector2D::dotProduct(v1, v2);
// Compute barycentric coordinates
double invDenom = 1.0 / (dot00 * dot11 - dot01 * dot01);
lam1 = (dot11 * dot02 - dot01 * dot12) * invDenom;
lam2 = (dot00 * dot12 - dot01 * dot02) * invDenom;
lam3 = 1.0 - lam1 - lam2;
// Return if POI is outside triangle
if( (lam1 < 0) || (lam2 < 0) || (lam3 < 0) ){
return false;
}
return true;
}
void E3T_centroid(QPointF pA, QPointF pB, QPointF pC, double& cx, double& cy)
{
cx = (pA.x() + pB.x() + pC.x())/3.;
cy = (pA.y() + pB.y() + pC.y())/3.;
}
|
/* -*- Mode: c++; tab-width: 4; indent-tabs-mode: t; c-basic-offset: 4 -*-
**
** Copyright (C) 1995-2005 Opera Software AS. All rights reserved.
**
** This file is part of the Opera web browser. It may not be distributed
** under any circumstances.
**
*/
#ifndef DOM_SVGELEM_H
#define DOM_SVGELEM_H
#ifdef SVG_DOM
#include "modules/dom/src/domcore/element.h"
#include "modules/dom/src/domsvg/domsvgobject.h"
#include "modules/dom/src/domsvg/domsvgenum.h"
#include "modules/dom/src/domcore/domtokenlist.h"
#include "modules/svg/svg_dominterfaces.h"
/** The DOM element of an SVG element.
*/
class DOM_SVGElement
: public DOM_Element
{
protected:
DOM_SVGElement(DOM_SVGElementInterface ifs) : ifs(ifs), object_store(NULL) {}
DOM_SVGElementInterface ifs;
DOM_SVGObjectStore* object_store;
DOM_SVGLocation location;
#ifdef SVG_FULL_11
ES_GetState GetAnimatedEnumeration(OpAtom property_name, ES_Value* value, ES_Runtime* origining_runtime);
ES_GetState GetAnimatedLength(OpAtom property_name, ES_Value* value, ES_Runtime* origining_runtime);
ES_GetState GetAnimatedList(SVGDOMItemType listtype, OpAtom property_name, ES_Value* value, ES_Runtime* origining_runtime);
ES_GetState GetAnimatedNumber(OpAtom property_name, ES_Value* value, ES_Runtime* origining_runtime);
ES_GetState GetAnimatedString(OpAtom property_name, ES_Value* value, ES_Runtime* origining_runtime);
ES_GetState GetAnimatedNumberOptionalNumber(OpAtom property_name, ES_Value* value, ES_Runtime* origining_runtime, UINT32 idx);
ES_GetState GetAnimatedAngle(OpAtom property_name, ES_Value* value, ES_Runtime* origining_runtime);
ES_GetState GetAnimatedPreserveAspectRatio(OpAtom property_name, ES_Value* value, ES_Runtime* origining_runtime);
ES_GetState GetAnimatedValue(OpAtom property_name, SVGDOMItemType item_type, ES_Value* value, ES_Runtime* origining_runtime);
ES_GetState GetPointList(OpAtom property_name, ES_Value* value, ES_Runtime* origining_runtime);
ES_GetState GetViewport(OpAtom property_name, ES_Value* value, ES_Runtime* origining_runtime);
ES_GetState GetPathSegList(OpAtom property_name, ES_Value* value, ES_Runtime* origining_runtime);
ES_GetState GetStringList(OpAtom property_name, ES_Value* value, ES_Runtime* origining_runtime);
ES_GetState GetInstanceRoot(OpAtom property_name, ES_Value* value, ES_Runtime* origining_runtime);
ES_GetState GetViewportElement(OpAtom property_name, ES_Value* value, ES_Runtime* origining_runtime);
ES_GetState GetStringAttribute(OpAtom property_name, ES_Value* value);
enum FrameEnvironmentType { FRAME_DOCUMENT, FRAME_WINDOW };
ES_GetState GetFrameEnvironment(ES_Value* value, FrameEnvironmentType type, DOM_Runtime *origining_runtime);
#endif // SVG_FULL_11
#if defined(SVG_TINY_12) || defined(SVG_FULL_11)
ES_GetState GetCurrentTranslate(OpAtom property_name, ES_Value* valye, ES_Runtime* origining_runtime);
ES_PutState SetStringAttribute(OpAtom property_name, ES_Value *value, ES_Runtime *origining_runtime);
#endif // SVG_TINY_12 || SVG_FULL_11
public:
/** If you change the number of items in the DOM_SVGElement::element_spec array this value should be changed also. **/
enum { DOM_SVG_ELEMENT_COUNT =
#if defined(SVG_TINY_12) || defined(SVG_FULL_11)
35
#endif // SVG_TINY_12 || SVG_FULL_11
#ifdef SVG_FULL_11
+ 32
#endif
#ifdef SVG_TINY_12
+ 4
#endif // SVG_TINY_12
+1 // for sentinel
};
virtual ~DOM_SVGElement();
static OP_STATUS Make(DOM_SVGElement *&element, HTML_Element *html_element, DOM_EnvironmentImpl *environment);
static OP_STATUS CreateElement(DOM_SVGElement *&element, DOM_Node *reference, const uni_char *name);
static void ConstructDOMImplementationSVGElementObjectL(ES_Object *element, DOM_SVGElementInterface ifs, DOM_Runtime *runtime);
virtual OP_STATUS GetBoundingClientRect(DOM_Object *&object);
virtual OP_STATUS GetClientRects(DOM_ClientRectList *&object);
virtual ES_GetState GetName(OpAtom property_name, ES_Value* value, ES_Runtime* origining_runtime);
virtual ES_PutState PutName(OpAtom property_name, ES_Value* value, ES_Runtime* origining_runtime);
virtual void DOMChangeRuntime(DOM_Runtime *new_runtime);
virtual BOOL IsA(int type) { return type == DOM_TYPE_SVG_ELEMENT || DOM_Element::IsA(type); }
virtual void GCTraceSpecial(BOOL via_tree);
static void PutConstructorsL(DOM_Object* target);
static void InitializeConstructorsTableL(OpString8HashTable<DOM_ConstructorInformation> *table);
static ES_Object *CreateConstructorL(DOM_Runtime *runtime, DOM_Object *target, unsigned id);
#ifdef SVG_FULL_11
// Text methods
DOM_DECLARE_FUNCTION(getNumberOfChars);
DOM_DECLARE_FUNCTION(getComputedTextLength);
DOM_DECLARE_FUNCTION(getSubStringLength);
DOM_DECLARE_FUNCTION(getStartPositionOfChar);
DOM_DECLARE_FUNCTION(getEndPositionOfChar);
DOM_DECLARE_FUNCTION(getExtentOfChar);
DOM_DECLARE_FUNCTION(getRotationOfChar);
DOM_DECLARE_FUNCTION(getCharNumAtPosition);
DOM_DECLARE_FUNCTION(selectSubString);
// Path methods
DOM_DECLARE_FUNCTION(getTotalLength);
DOM_DECLARE_FUNCTION(getPointAtLength);
DOM_DECLARE_FUNCTION(getPathSegAtLength);
DOM_DECLARE_FUNCTION_WITH_DATA(createSVGPathSeg);
// getSVGDocument
DOM_DECLARE_FUNCTION(getSVGDocument);
#endif // SVG_FULL_11
#if defined(SVG_TINY_12) || defined(SVG_FULL_11)
// Locatable methods
DOM_DECLARE_FUNCTION_WITH_DATA(getBBox);
DOM_DECLARE_FUNCTION(getScreenCTM);
#endif // SVG_TINY_12 || SVG_FULL_11
#ifdef SVG_FULL_11
DOM_DECLARE_FUNCTION(getCTM);
DOM_DECLARE_FUNCTION(getTransformToElement);
// Stylable methods
DOM_DECLARE_FUNCTION(getPresentationAttribute);
#endif // SVG_FULL_11
#if defined(SVG_TINY_12) || defined(SVG_FULL_11)
// ElementTimeControl
DOM_DECLARE_FUNCTION_WITH_DATA(beginElement);
DOM_DECLARE_FUNCTION_WITH_DATA(endElement);
#endif // SVG_TINY_12 || SVG_FULL_11
#ifdef SVG_FULL_11
DOM_DECLARE_FUNCTION(getStartTime);
DOM_DECLARE_FUNCTION(getSimpleDuration);
// Filter methods
DOM_DECLARE_FUNCTION(setFilterRes);
// Gaussian Blur methods
DOM_DECLARE_FUNCTION(setStdDeviation);
// Marker methods
DOM_DECLARE_FUNCTION(setOrientToAuto);
DOM_DECLARE_FUNCTION(setOrientToAngle);
DOM_DECLARE_FUNCTION(hasExtension);
#endif // SVG_FULL_11
#ifdef SVG_TINY_12
// SVGT12 uDOM TraitAccess
DOM_DECLARE_FUNCTION_WITH_DATA(setObjectTrait);
DOM_DECLARE_FUNCTION_WITH_DATA(getObjectTrait);
#endif // SVG_TINY_12
#if defined(SVG_TINY_12) || defined(SVG_FULL_11)
DOM_DECLARE_FUNCTION_WITH_DATA(createSVGObject);
DOM_DECLARE_FUNCTION(pauseAnimations);
DOM_DECLARE_FUNCTION(unpauseAnimations);
DOM_DECLARE_FUNCTION(animationsPaused);
DOM_DECLARE_FUNCTION_WITH_DATA(getCurrentTime);
DOM_DECLARE_FUNCTION(setCurrentTime);
#endif // SVG_TINY_12 || SVG_FULL_11
#ifdef SVG_FULL_11
DOM_DECLARE_FUNCTION(suspendRedraw);
DOM_DECLARE_FUNCTION(unsuspendRedraw);
DOM_DECLARE_FUNCTION(unsuspendRedrawAll);
DOM_DECLARE_FUNCTION(forceRedraw);
DOM_DECLARE_FUNCTION_WITH_DATA(testIntersection);
DOM_DECLARE_FUNCTION(deselectAll);
DOM_DECLARE_FUNCTION(getComputedStyle);
#endif // SVG_FULL_11
#ifdef SVG_TINY_12
// SVGT 1.2 uDOM
DOM_DECLARE_FUNCTION(setFocus);
DOM_DECLARE_FUNCTION(moveFocus);
DOM_DECLARE_FUNCTION(getCurrentFocusedObject);
#endif // SVG_TINY_12
};
class DOM_SVGElement_Prototype
: public DOM_Object
{
private:
static void ConstructL(ES_Object *object, DOM_Runtime::SVGElementPrototype prototype, DOM_SVGElementInterface ifs, DOM_Runtime *runtime);
public:
static OP_STATUS Construct(ES_Object *object, DOM_Runtime::SVGElementPrototype prototype, DOM_SVGElementInterface ifs, DOM_Runtime *runtime);
};
/*
* Implements
*
* Animated objects:
* SVGAnimatedString
* SVGAnimatedEnumeration
* SVGAnimatedNumber
* SVGAnimatedLength
* SVGAnimatedPreserveAspectRatio
* SVGAnimatedRect
* SVGAnimatedAngle
*
* Animated lists:
* SVGAnimatedPointList
* SVGAnimatedNumberList
* SVGAnimatedLengthList
* SVGAnimatedTransformList
* SVGAnimatedMatrixList
*
*/
class DOM_SVGAnimatedValue : public DOM_Object
{
public:
virtual ~DOM_SVGAnimatedValue();
static OP_STATUS Make(DOM_SVGAnimatedValue *&anim_val, SVGDOMAnimatedValue* svg_val,
const char* name, DOM_SVGLocation location, DOM_EnvironmentImpl *environment);
virtual ES_GetState GetName(OpAtom property_name, ES_Value* value, ES_Runtime* origining_runtime);
virtual ES_PutState PutName(OpAtom property_name, ES_Value* value, ES_Runtime* origining_runtime);
virtual void DOMChangeRuntime(DOM_Runtime *new_runtime);
virtual BOOL IsA(int type) { return type == DOM_TYPE_SVG_ANIMATED_VALUE || DOM_Object::IsA(type); }
virtual void GCTrace();
BOOL IsValid() { return location.IsValid(); }
protected:
DOM_SVGAnimatedValue() : base_object(NULL), anim_object(NULL), svg_value(NULL) {}
DOM_SVGAnimatedValue(const DOM_SVGAnimatedValue&) : DOM_Object() {}
DOM_Object* base_object;
DOM_Object* anim_object;
DOM_SVGLocation location;
SVGDOMAnimatedValue* svg_value;
};
#endif // SVG_DOM
#endif // DOM_SVGELEM_H
|
// Outreachy: ceph - radosgw-admin application
// Boost::program_options demo
#include <boost/program_options.hpp>
#include <iostream>
#include "commands.h"
namespace po = boost::program_options;
int main( int argc, char** argv )
{
po::options_description desc("options");
int user_id;
std::string email;
std::string display_name;
desc.add_options()
("help,h", "display help")
("uid", po::value<int>(), "user id")
("email", po::value(&email), "email")
("display-name", po::value(&display_name), "display name")
;
const Command* operation = NULL;
std::string current;
std::string previous;
po::variables_map vm;
try {
// Use argv directly to obtain the commands (usually 2 commands, can be 1)
int argv_index = 1;
while(argv_index < argc && !operation){
// Leave "--" options for boost
if(std::string(argv[argv_index]).find("--") == 0){
//argv_index++;
//continue;
break;
}
else { // First command string (Command.cmd)
if(previous.empty()){
for(const auto& command : commands) {
if(argv[argv_index] == command.cmd){
previous = std::string(argv[argv_index]);
if(command.action.empty())
operation = &command;
}
}
if(previous.empty()){
throw po::unknown_option(argv[argv_index]);
}
}
else { // Second command string (Command.action)
for(const auto& command : commands) {
if(previous == command.cmd && argv[argv_index] == command.action){
operation = &command;
}
}
if(!operation){
throw po::unknown_option(argv[argv_index]);
}
}
}
argv_index++;
}
// Error: second command string missing
if(!previous.empty() && !operation) {
std::vector<std::string> alternatives;
for(const auto& command : commands) {
if(previous == command.cmd){
alternatives.push_back(command.action);
}
}
throw po::ambiguous_option(alternatives);
}
po::store(po::parse_command_line(argc, argv, desc), vm);
po::notify(vm);
if (vm.count("help")) {
std::cout << "usage: radosgw-admin <cmd> [options...]" << std::endl;
for(const auto& it : commands) {
std::cout << it;
}
std::cout << desc;
}
// Option Handlers
if(vm.count("uid")) {
user_id = vm["uid"].as<int>();
std::cout << "uid: " << user_id << std::endl;
}
if(vm.count("email")) {
std::cout << "email: " << email << std::endl;
}
if(vm.count("display-name")) {
std::cout << "display name: " << display_name << std::endl;
}
// Command Handlers
// TODO: verify that the correct options were passed
// possible to eliminate switch? function pointers?
if(operation) {
switch(operation->id){
case OPT_USER_CREATE:
std::cout << "user created with uid " << user_id << ", display name "
<< display_name << " and email " << email << std::endl;
break;
case OPT_USER_INFO:
std::cout << "user info for uid " << user_id << std::endl;
break;
case OPT_USER_DELETE:
std::cout << "user deleted with uid " << user_id << std::endl;
break;
default:
break;
}
std::cout << operation->cmd
<< (operation->action.empty() ? "" : " " + operation->action )
<< " complete." << std::endl;
}
} catch ( const boost::program_options::error& e ) {
std::cerr << e.what() << std::endl;
std::cout << "usage: radosgw-admin <cmd> [options...]" << std::endl;
for(const auto& it : commands) {
std::cout << it;
}
std::cout << desc << std::endl;
}
}
|
// Created on: 1992-02-20
// Created by: Remy GILET
// Copyright (c) 1992-1999 Matra Datavision
// Copyright (c) 1999-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#ifndef _Geom2dGcc_FunctionTanCuPnt_HeaderFile
#define _Geom2dGcc_FunctionTanCuPnt_HeaderFile
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <Geom2dAdaptor_Curve.hxx>
#include <gp_Pnt2d.hxx>
#include <math_FunctionWithDerivative.hxx>
//! This abstract class describes a Function of 1 Variable
//! used to find a line tangent to a curve and passing
//! through a point.
class Geom2dGcc_FunctionTanCuPnt : public math_FunctionWithDerivative
{
public:
DEFINE_STANDARD_ALLOC
Standard_EXPORT Geom2dGcc_FunctionTanCuPnt(const Geom2dAdaptor_Curve& C, const gp_Pnt2d& Point);
//! Computes the value of the function F for the variable X.
//! It returns True if the computation is successfully done,
//! False otherwise.
Standard_EXPORT Standard_Boolean Value (const Standard_Real X, Standard_Real& F);
//! Computes the derivative of the function F for the variable X.
//! It returns True if the computation is successfully done,
//! False otherwise.
Standard_EXPORT Standard_Boolean Derivative (const Standard_Real X, Standard_Real& Deriv);
//! Computes the value and the derivative of the function F
//! for the variable X.
//! It returns True if the computation is successfully done,
//! False otherwise.
Standard_EXPORT Standard_Boolean Values (const Standard_Real X, Standard_Real& F, Standard_Real& Deriv);
protected:
private:
Geom2dAdaptor_Curve TheCurv;
gp_Pnt2d ThePoint;
};
#endif // _Geom2dGcc_FunctionTanCuPnt_HeaderFile
|
#include<iostream>
#include<string>
#include<fstream>
using namespace std;
string readFile( void );
int lenMessage;
int * matchCharToIndex(string s,string alphabet);
string matchIndexToChar(int *encryptMessage, string alphabet);
int * memoryAllocation( int len );
string cleanString( string alphabet );
void writeF( string encryptVig);
int main( void ){
string encryptText, decryptText,alphabet,posibleKey;
int *key, *encrypt, *decrypt;
cout << "Ingresa el nombre del texto crifrado: ";
encryptText = readFile();
cout << "Ingresa el nombre del texto decifrado: ";
decryptText = readFile();
cout << "Ingresa el nombre del alfabeto: ";
alphabet = readFile();
alphabet = cleanString(alphabet);
lenMessage = encryptText.length();
encrypt = matchCharToIndex(encryptText,alphabet);
decrypt = matchCharToIndex(decryptText,alphabet);
key = memoryAllocation(lenMessage);
for (int i = 0; i < lenMessage; i++)
key[i] = (encrypt[i]-decrypt[i] < 0)
? (alphabet.length() - ( (decrypt[i]-encrypt[i])%alphabet.length()) )
: (encrypt[i]-decrypt[i])% alphabet.length();
posibleKey = matchIndexToChar(key,alphabet);
writeF(posibleKey);
}
string readFile( void ){
string nameFile;
cin >> nameFile;
ifstream file( nameFile.c_str() );
string line;
string message;
if(file.fail())
cerr << "Error, Can't open the file" << nameFile << endl;
else
while( !file.eof() ){
getline(file, line);
message += line;
}
file.close();
return message;
}
void writeF( string encryptVig){
ofstream file;
file.open( "Posiblellave.txt" );
file << encryptVig;
file.close();
}
int * matchCharToIndex(string s,string alphabet){
int *auxS = memoryAllocation( s.length() );
for(int i = 0; i < s.length() ; i++)
auxS[i]= alphabet.find(s[i]);
return auxS;
}
string matchIndexToChar(int *encryptMessage, string alphabet){
string auxEncryptMessages;
int position;
for ( int i = 0; i < lenMessage ; i++ ){
position = encryptMessage[i];
auxEncryptMessages += alphabet[position];
}
return auxEncryptMessages;
}
string cleanString( string alphabet ){
string auxAlphabet;
for (int i =0; i < alphabet.size() ; i++)
if ( alphabet[i] != 32)
auxAlphabet += alphabet[i];
return auxAlphabet;
}
int * memoryAllocation( int len ) {
int *memory;
memory = (int *)malloc(len*sizeof(int) );
if( memory == NULL ) {
perror("Error, Can't reserve memory");
exit(EXIT_FAILURE);
}
return memory;
}
|
#include "VertexBuffer.h"
#include "Debug.h"
#include <iostream>
VertexBuffer::VertexBuffer(const void* data, unsigned int size){
GLCall(glGenBuffers(1, &m_RendererID));
GLCall(glBindBuffer(GL_ARRAY_BUFFER, m_RendererID));
GLCall(glBufferData(GL_ARRAY_BUFFER, size, data, GL_STATIC_DRAW));
}
VertexBuffer::VertexBuffer(std::vector<Vertex>& vertices)
{
GLCall(glGenBuffers(1, &m_RendererID));
GLCall(glBindBuffer(GL_ARRAY_BUFFER, m_RendererID));
GLCall(glBufferData(GL_ARRAY_BUFFER, vertices.size() * sizeof(Vertex), vertices.data(), GL_STATIC_DRAW));
}
VertexBuffer::~VertexBuffer(){
GLCall(glDeleteBuffers(1, &m_RendererID));
}
void VertexBuffer::Bind() const {
GLCall(glBindBuffer(GL_ARRAY_BUFFER, m_RendererID));
}
void VertexBuffer::Unbind() const {
GLCall(glBindBuffer(GL_ARRAY_BUFFER, 0));
}
|
#include <iostream>
#include <cstdio>
#include <cstring>
#include <math.h>
#define pi acos(-1.0)
using namespace std;
const int maxn = 10000 + 5;
int main() {
int t,n,f;
cin >> t;
while(t --) {
cin >> n >> f;
f ++;
int r;
double a[maxn];
double mid;
double max = 0, s = 0;
for(int i = 1; i <= n; i ++) {
cin >> r;
a[i] = pi * r * r;
s += a[i];
if(max <= a[i])
max = a[i];
}
double l1 = max / f; // 最多分得披萨数
double l2 = s / f; // 最少分得披萨数
while(l2 - l1 >= 1e-5) {
int cnt = 0;
mid = (l1 + l2) / 2;
for(int i = 0;i < n; i++) {
cnt = cnt + (int)(a[i] / mid);
}
if(cnt < f) {
l2 = mid;
}else
l1 = mid;
}
printf("%.4lf\n", mid);
}
return 0;
}
#include <iostream>
#include <cstdio>
#include <cstring>
#include <math.h>
using namespace std;
const int maxn = 10000 + 5;
const double INF = 100000;
int n, R, t, f, k;
double L[maxn];
bool check(double x) {
int sum = 0;
for(int i = 0; i < n; i ++) {
num += (int) (L [i] / x);
}
return num >= k;
}
int main() {
scanf("%d", &t);
while(t --) {
cin >> n >> f;
for(int i = 0; i < n; i ++) {
cin >> R;
}
double l = 0, r = INF, mid;
}
return 0;
}
|
//https://projecteuler.net/problem=3
//https://www.tutorialspoint.com/c-program-for-find-the-largest-prime-factor-of-a-number
#include <iostream>
using namespace std;
int largestPrimeFactor(long int n)
{
long int div=3, ans = 0, maxFact;
while(n!=0) {
if(n % div !=0)
div = div + 2;
else {
maxFact = n;
n = n / div;
if(n == 1) {
return maxFact;
ans = 1;
break;
}
}
}
return -1;
}
int main() {
long int n=600851475143;
cout<<largestPrimeFactor(n);
return 0;
}
|
#pragma once
#include "..\Common\Pch.h"
#include "..\Graphic\Direct3D.h"
#pragma region D3D11_INPUT_ELEMENT_DESC 커스터마이징 구조체 정의
namespace inputlayout
{
typedef struct INPUT_LAYOUT_TYPE_0
{
D3DXVECTOR3 Pos;
static const D3D11_INPUT_ELEMENT_DESC sElementDesc[];
static const UINT sElementCount;
} IL_Pos;
typedef struct INPUT_LAYOUT_TYPE_1
{
D3DXVECTOR3 Pos;
D3DXVECTOR2 Tex;
static const D3D11_INPUT_ELEMENT_DESC sElementDesc[];
static const UINT sElementCount;
} IL_PosTex;
typedef struct INPUT_LAYOUT_TYPE_2
{
D3DXVECTOR3 Pos;
D3DXVECTOR2 Tex;
D3DXVECTOR3 Nor;
static const D3D11_INPUT_ELEMENT_DESC sElementDesc[];
static const UINT sElementCount;
} IL_PosTexNor;
typedef struct INPUT_LAYOUT_TYPE_3
{
D3DXVECTOR3 Pos;
D3DXVECTOR2 Tex;
D3DXVECTOR3 Nor;
D3DXVECTOR3 Tan;
D3DXVECTOR3 BiN;
static const D3D11_INPUT_ELEMENT_DESC sElementDesc[];
static const UINT sElementCount;
} IL_PosTexNorTanBiN;
typedef struct INPUT_LAYOUT_TYPE_4
{
D3DXMATRIX World;
static const D3D11_INPUT_ELEMENT_DESC sElementDesc[];
static const UINT sElementCount;
} IL_PosInst;
typedef struct INPUT_LAYOUT_TYPE_5
{
D3DXMATRIX World;
static const D3D11_INPUT_ELEMENT_DESC sElementDesc[];
static const UINT sElementCount;
} IL_PosTexInst;
typedef struct INPUT_LAYOUT_TYPE_EXTRA_0
{
D3DXVECTOR3 Pos;
D3DXVECTOR3 Tex;
static const D3D11_INPUT_ELEMENT_DESC sElementDesc[];
static const UINT sElementCount;
} IL_Extra_0; // Trapezoid
}
using namespace inputlayout;
#pragma endregion
class InputLayout
{
public:
bool CheckInstanced();
bool CheckTessellated();
ID3D11Buffer* GetVertexBuffer();
ID3D11Buffer* GetIndexBuffer();
ID3D11Buffer* GetInstanceBuffer();
UINT GetVertexCount();
UINT GetIndexCount();
UINT GetInstanceCount();
UINT GetDrawCount();
UINT GetInputLayoutSize();
UINT GetInputLayoutInstanceSize();
void SetPosition(FLOAT x, FLOAT y, FLOAT z);
protected:
struct WorldBufferData
{
D3DXMATRIX World;
};
D3DXMATRIX mWorld; // 인스턴싱은 사용x
ID3D11Buffer* mWorldBuffer;
bool mInstanced;
bool mTessellated;
ID3D11Buffer* mVertexBuffer;
ID3D11Buffer* mIndexBuffer;
ID3D11Buffer* mInstanceBuffer;
UINT mVertexCount;
UINT mIndexCount;
UINT mInstanceCount;
UINT mDrawCount;
UINT mInputLayoutSize; // Strides
UINT mInputLayoutInstanceSize;
vector<IL_PosTexNor> mTempData;
InputLayout();
virtual ~InputLayout();
//virtual void Update(FLOAT delta) = 0;
//virtual void InitializeData() = 0;
virtual void InitializeBuffer() = 0;
void GetInputLayoutFromFile(wstring meshName, FLOAT scale = 1.0F);
void SetWorldBuffer();
virtual void SetBuffer() = 0;
};
|
#include <bits/stdc++.h>
using namespace std;
struct elephant{
int weight;
int IQ;
int ID;
}Eloa[1005];
bool compare(elephant e1,elephant e2)
{
return e1.weight < e2.weight ;
}
int lis[1005];
vector<int>sol_set;
int LIS_N_2(int n)
{
for(int a=0;a<n;a++)
{
lis[a] = 1;
}
int mx = 0;
for(int a = 0;a<n;a++)
{
for(int b=0;b<a;b++)
{
int iqA = Eloa[a].IQ ; int iqB = Eloa[b].IQ ;
int wtA = Eloa[a].weight ; int wtB = Eloa[b].weight ;
if( iqB > iqA && wtA > wtB )
lis[a] = max( lis[b] + 1 , lis[a] );
}
mx = max(mx,lis[a]);
}
return mx;
}
int main()
{
int idx = 0;
int tmp,tmp2;
while(scanf("%d %d",&tmp,&tmp2)==2)
{
Eloa[idx].ID = idx;
Eloa[idx].weight = tmp;
Eloa[idx].IQ = tmp2;
idx++;
}
sort(Eloa,Eloa+idx,compare);
/*
for(int a=0;a<idx;a++)
{
cout<<Eloa[a].weight<<" "<<Eloa[a].IQ<<endl;
}
*/
int mx = LIS_N_2(idx);
int mx_ = mx;
//Final solution printer
for(int x = idx -1 ; x>=0;x--)
{
if(lis[x] == mx)
{
sol_set.push_back(x);
mx--;
}
}
reverse(sol_set.begin(),sol_set.end());
cout<<mx_<<endl;
for(int a=0;a<sol_set.size();a++)
cout<<Eloa[ sol_set[a] ].ID + 1 <<endl;
return 0;
}
|
#include "GlobalStats.h"
int GlobalStats::wallWidth = 1;
int GlobalStats::gridStep = 1;
int GlobalStats::connRadius = 4;
int GlobalStats::oldPanelIndex = 1;
int GlobalStats::propertyPanelIndex = 3;
bool GlobalStats::isShowingConnections = false;
UtilitiesGrid* GlobalStats::propertyPanelHolder=nullptr;
QGraphicsScene* GlobalStats::scene = nullptr;
QPoint GlobalStats::mousePosition(0,0);
UtilityPanelWidget* GlobalStats::leftMenuPanel=nullptr;
QString GlobalStats::doorIcon="";
QString GlobalStats::windowIcon="";
QString GlobalStats::furnitureIcon = "";
bool GlobalStats::togglePropertyStatus = false;
GlobalStats::SceneOperationType GlobalStats::currentOperation = GlobalStats::SceneOperationType::NONE;
int GlobalStats::GetWallWidth()
{
return GlobalStats::wallWidth;
}
void GlobalStats::SetWallWidth(int width)
{
GlobalStats::wallWidth = width;
}
int GlobalStats::GetGridStep()
{
return GlobalStats::gridStep;
}
void GlobalStats::SetGridStep(int step)
{
GlobalStats::gridStep = step;
}
int GlobalStats::GetConnRadius()
{
return GlobalStats::connRadius;
}
void GlobalStats::SetConnRadius(int radius)
{
GlobalStats::connRadius = radius;
}
QGraphicsScene* GlobalStats::GetGraphicsScene()
{
return GlobalStats::scene;
}
void GlobalStats::SetGraphicsScene(QGraphicsScene* scene)
{
GlobalStats::scene = scene;
}
bool GlobalStats::GetIsShowingConnections()
{
return GlobalStats::isShowingConnections;
}
void GlobalStats::SetIsShowingConnections(bool val)
{
GlobalStats::isShowingConnections = val;
}
void GlobalStats::SetPropertyPanelHolder(UtilitiesGrid* uGrid)
{
GlobalStats::propertyPanelHolder = uGrid;
}
UtilitiesGrid* GlobalStats::GetPropertyPanelHolder()
{
return GlobalStats::propertyPanelHolder;
}
void GlobalStats::SetOldPanelIndex(int idx)
{
GlobalStats::oldPanelIndex = idx;
}
int GlobalStats::GetOldPanelIndex()
{
return GlobalStats::oldPanelIndex;
}
void GlobalStats::SetPropertyPanelIndex(int idx)
{
GlobalStats::propertyPanelIndex = idx;
}
int GlobalStats::GetPropertyPanelIndex()
{
return GlobalStats::propertyPanelIndex;
}
void GlobalStats::SetLeftMenuPanel(UtilityPanelWidget* panel)
{
GlobalStats::leftMenuPanel = panel;
}
void GlobalStats::SetDoorIcon(QString path)
{
GlobalStats::doorIcon = path;
}
QString GlobalStats::GetDoorIcon()
{
return GlobalStats::doorIcon;
}
void GlobalStats::SetWindowIcon(QString path)
{
GlobalStats::windowIcon = path;
}
QString GlobalStats::GetWindowIcon()
{
return GlobalStats::windowIcon;
}
bool GlobalStats::GetTogglePropertyStatus()
{
return GlobalStats::togglePropertyStatus;
}
void GlobalStats::ExportProject()
{
if (scene->views().size() > 0)
{
QString fileName = QFileDialog::getSaveFileName(scene->views().front(), "Save image", QDir::currentPath()+QString("Project.png"), "PNG (*.png);;JPEG (*.JPEG)");
if (!fileName.isNull())
{
QPixmap pixMap = scene->views().front()->grab();
pixMap.save(fileName);
}
}
else
{
std::cout << "Cannot export project, view not found";
}
}
void GlobalStats::ClearScene()
{
ToggleOffPropertyMenu();
QMessageBox msgBox;
msgBox.setText("Are you sure you want to clear the scene?");
msgBox.setStandardButtons(QMessageBox::Ok | QMessageBox::Cancel);
msgBox.setDefaultButton(QMessageBox::Cancel);
int ret = msgBox.exec();
if(ret==QMessageBox::Ok)
{
while (scene->items().size() > 0)
{
QGraphicsItem* item = scene->items().front();
scene->removeItem(item);
}
}
}
void GlobalStats::SetFurnitureIcon(QString path)
{
GlobalStats::furnitureIcon = path;
}
QString GlobalStats::GetFurnitureIcon()
{
return GlobalStats::furnitureIcon;
}
GlobalStats::SceneOperationType GlobalStats::GetOperationType()
{
return GlobalStats::currentOperation;
}
void GlobalStats::SetOperationType(SceneOperationType op)
{
GlobalStats::currentOperation = op;
if(op!=SceneOperationType::INSERT_FURNITURE)
{
GlobalStats::furnitureIcon = "";
}
}
void GlobalStats::ToggleOnPropertyMenu(QWidget* propertyWidget)
{
GlobalStats::leftMenuPanel->setCurrentIndex(GlobalStats::propertyPanelIndex);
GlobalStats::togglePropertyStatus = true;
if(propertyWidget!=nullptr)
{
propertyPanelHolder->AddWidget(propertyWidget);
}
}
void GlobalStats::ToggleOffPropertyMenu()
{
GlobalStats::leftMenuPanel->setCurrentIndex(GlobalStats::oldPanelIndex);
GlobalStats::togglePropertyStatus = false;
propertyPanelHolder->ClearWidgets();
}
|
#include <iostream>
#include <vector>
#include <utility>
#include <cmath>
#include <algorithm>
#include <iomanip>
#define MAX 1001
using namespace std;
int n, m;
double minCost = 0;
pair<int, int> planet[MAX];
class Tunnel{
public:
int i, j;
double weight;
Tunnel(int i, int j, double w)
:i(i), j(j), weight(w) {}
bool operator < (const Tunnel &t) const {
return weight < t.weight;
}
};
vector<Tunnel> tunnel;
int vRoot[MAX] = {0, };
double getDist(pair<int, int> plA, pair<int, int> plB){
return sqrt(pow(plA.first-plB.first,2)+pow(plA.second-plB.second,2));
}
int findRoot(int v){
if(vRoot[v] == v) return v;
return vRoot[v] = findRoot(vRoot[v]);
}
int main(){
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n >> m;
for(int i = 1; i <= n; i++){
int a, b;
cin >> a >> b;
planet[i] = make_pair(a, b);
vRoot[i] = i;
}
for(int i = 1; i <= n-1; i++){
for(int j = i+1; j <= n; j++){
tunnel.push_back(Tunnel(i, j, getDist(planet[i], planet[j])));
}
}
while(m--){
int connectedA, connectedB;
cin >> connectedA >> connectedB;
vRoot[findRoot(connectedB)] = findRoot(connectedA);
}
sort(tunnel.begin(), tunnel.end());
for(Tunnel t : tunnel){
int rootI = findRoot(t.i);
int rootJ = findRoot(t.j);
if(rootI != rootJ){
minCost += t.weight;
vRoot[rootJ] = rootI;
}
}
cout << fixed;
cout.precision(2);
cout << minCost << endl;
return 0;
}
|
#include<iostream>
using namespace std;
int main()
{
int test, m, n, i;
cin>>test;
for(i=0; i<test; i++)
{
cin>>m>>n;
if(m>n)
cout<<"1\n";
else
{
if(n%m==0)
cout<<(n/m)*4-1<<endl;
else
cout<<(n/m+1)*4-1<<endl;
}
}
}
|
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <ctype.h>
#define MAX_ARGUMENTS 256
#ifndef NULL
#define NULL 0
#endif
#define FREE(X) if(X) free((void*)X)
//static int variable for exit status of proccess
static int status = 0;
//a struct for commands
typedef struct cmdLine
{
char * const arguments[MAX_ARGUMENTS]; /* command line arguments (arg 0 is the command)*/
int argCount; /* number of arguments */
char blocking; /* boolean indicating blocking/non-blocking */
int idx; /* index of current command in the chain of cmdLines (0 for the first) */
struct cmdLine *next; /* next cmdLine in chain */
} cmdLine;
//a function that copy the given string with memory allocation
static char *strClone(const char *source)
{
char* clone = (char*)malloc(strlen(source) + 1);
strcpy(clone, source);
return clone;
}
//passing on spaces
static int isEmpty(const char *str)
{
if (!str)
return 1;
while (*str)
if (!isspace(*(str++)))
return 0;
return 1;
}
//a function that manipulates the enviromental variables
static cmdLine *envVariables(cmdLine *pCmdLine){
//passing on each argument
for(int i = 0; i < pCmdLine->argCount; i++){
char *str = pCmdLine->arguments[i];
char *_str = (char*)malloc(1);
int place = 0;
_str[place] = '\0';
//passing on the string
for(unsigned j = 0; j < strlen(str); j++){
//switching '~' as the first letter to home
if (j == 0 && str[j] == '~'){
char *tmp = getenv("HOME");
char* res = NULL;
if (tmp != NULL) {
res = strClone(tmp);
}else{
res = strClone("");
}
if(res != NULL){
_str = (char*)realloc(_str,place + strlen(res) +1 );
strcat(_str, res);
}
place+=strlen(res);
FREE(res);
}
//checking for '$' and then a correct continuity
else if (str[j] == '$' && j < strlen(str) - 1 && (str[j+1] != '$')){
//'$?' case - switching to the status
if(str[j+1] == '?'){
char tmp[10];
sprintf(tmp, "%d", status);
_str = (char*)realloc(_str,place + strlen(tmp) + 2 );
strcat(_str, tmp);
place+=strlen(tmp);
j++;
}
//normal '$VAR'
else if(isalpha(str[j+1])){
unsigned k;
for(k=j+2;k<strlen(str) && (isalnum(str[k]) || str[k] == '_' );k++);
//from j+1 to k = var
char *replacement = (char*)malloc(k-j);
memcpy(replacement, &str[j+1], k-j-1);
replacement[k-j] = '\0';
char *tmp = getenv(replacement);
char* res = NULL;
//checking if there is VAR, if not setting as ""
if (tmp != NULL) {
res = strClone(tmp);
}else{
res = strClone("");
}
FREE(replacement);
if(res != NULL){
_str = (char*)realloc(_str,place + strlen(res) +1 );
strcat(_str, res);
}
j = k - 1;
place+=strlen(res);
FREE(res);
}
}
//copying the current char
else{
_str = (char*)realloc(_str, strlen(_str) + 1);
_str[place] = str[j];
_str[place + 1] = '\0';
place++;
}
}
//setting the new string after changes to the argument
FREE((pCmdLine->arguments)[i]);
((char**)pCmdLine->arguments)[i] = _str;
}
return pCmdLine;
}
//parsing the line by white spaces
static cmdLine *parseSingleCmdLine(const char *strLine)
{
char const *delimiter = " ";
char *line, *result;
if (isEmpty(strLine))
return NULL;
cmdLine* pCmdLine = (cmdLine*)malloc( sizeof(cmdLine) ) ;
memset(pCmdLine, 0, sizeof(cmdLine));
line = strClone(strLine);
result = strtok( line, delimiter);
while( result && pCmdLine->argCount < MAX_ARGUMENTS-1) {
((char**)pCmdLine->arguments)[pCmdLine->argCount++] = strClone(result);
result = strtok ( NULL, delimiter);
}
FREE(line);
return pCmdLine;
}
//checking the line and parsing it
static cmdLine* _parseCmdLines(char *line)
{
cmdLine *pCmdLine;
if (isEmpty(line))
return NULL;
pCmdLine = parseSingleCmdLine(line);
if (!pCmdLine)
return NULL;
return pCmdLine;
}
//Parses a given string to arguments, returns NULL if there is nothing to parse
inline static cmdLine *parseCmdLines(const char *strLine)
{
char* line, *ampersand;
cmdLine *head, *last;
int idx = 0;
if (isEmpty(strLine))
return NULL;
line = strClone(strLine);
if (line[strlen(line)-1] == '\n')
line[strlen(line)-1] = 0;
//checking for &(background proccess)
ampersand = strchr( line, '&');
if (ampersand)
*(ampersand) = 0;
if ( (last = head = _parseCmdLines(line)) )
{
while (last->next)
last = last->next;
last->blocking = ampersand? 0:1;
}
for (last = head; last; last = last->next)
last->idx = idx++;
FREE(line);
//checking for enviromntal vars
head = envVariables(head);
return head;
}
//Free parsed line
static void freeCmdLines(cmdLine *pCmdLine)
{
int i;
if (!pCmdLine)
return;
for (i=0; i<pCmdLine->argCount; ++i)
FREE(pCmdLine->arguments[i]);
if (pCmdLine->next)
freeCmdLines(pCmdLine->next);
FREE(pCmdLine);
}
|
// Created by: Julia GERASIMOVA
// Copyright (c) 2015 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#ifndef _BlendFunc_ConstThroatInv_HeaderFile
#define _BlendFunc_ConstThroatInv_HeaderFile
#include <Adaptor3d_Surface.hxx>
#include <BlendFunc_GenChamfInv.hxx>
#include <math_Vector.hxx>
class math_Matrix;
//! Class for a function used to compute a ConstThroat chamfer on a surface's boundary
class BlendFunc_ConstThroatInv : public BlendFunc_GenChamfInv
{
public:
DEFINE_STANDARD_ALLOC
Standard_EXPORT BlendFunc_ConstThroatInv(const Handle(Adaptor3d_Surface)& S1, const Handle(Adaptor3d_Surface)& S2, const Handle(Adaptor3d_Curve)& C);
Standard_EXPORT Standard_Boolean IsSolution (const math_Vector& Sol, const Standard_Real Tol) Standard_OVERRIDE;
//! computes the values <F> of the Functions for the
//! variable <X>.
//! Returns True if the computation was done successfully,
//! False otherwise.
Standard_EXPORT Standard_Boolean Value (const math_Vector& X, math_Vector& F) Standard_OVERRIDE;
//! returns the values <D> of the derivatives for the
//! variable <X>.
//! Returns True if the computation was done successfully,
//! False otherwise.
Standard_EXPORT Standard_Boolean Derivatives (const math_Vector& X, math_Matrix& D) Standard_OVERRIDE;
using Blend_FuncInv::Set;
Standard_EXPORT virtual void Set (const Standard_Real theThroat,
const Standard_Real,
const Standard_Integer Choix) Standard_OVERRIDE;
protected:
Standard_Real Throat;
Standard_Real param;
Standard_Real sign1;
Standard_Real sign2;
gp_Pnt ptgui;
gp_Vec nplan;
Standard_Real normtg;
Standard_Real theD;
gp_Vec d1gui;
gp_Vec d2gui;
gp_Pnt pts1;
gp_Pnt pts2;
gp_Vec d1u1;
gp_Vec d1v1;
gp_Vec d1u2;
gp_Vec d1v2;
private:
};
#endif // _BlendFunc_ConstThroatInv_HeaderFile
|
#include <iostream>
#include <chrono>
#include <vector>
#include "opencv2/opencv.hpp"
#include "package_bgs/lb/LBMixtureOfGaussians.h"
using namespace std;
using namespace cv;
using namespace std::chrono;
typedef high_resolution_clock clk;
int main(int argc, char **argv) {
VideoCapture cap("../peds/video.avi");
if(!cap.isOpened()){
cout << "Cannot open video file!" << endl;
return -1;
}
IBGS *bgs = new LBMixtureOfGaussians();
Mat frame;
namedWindow("Frame",1);
int index=0;
vector<int> times(100);
int frame_count = 0;
while(true){
clk::time_point t1 = clk::now();
cap >> frame;
frame_count++;
if(frame.rows <= 0){
break;
}else if(frame_count > 170){
break;
}
GaussianBlur(frame, frame, cv::Size(3, 3), 0);
Mat mask, bkgmodel;
bgs->process(frame, mask, bkgmodel);
erode(mask, mask, Mat());
Mat element = getStructuringElement(cv::MORPH_RECT,
cv::Size(7, 7),
cv::Point(3,3) );
dilate(mask, mask, element);
erode(mask, mask, Mat());
cvtColor(mask, mask, CV_BGR2GRAY);
std::vector<std::vector<cv::Point>> contours;
findContours(mask,contours,CV_RETR_EXTERNAL,CV_CHAIN_APPROX_SIMPLE);
for (size_t idx = 0; idx < contours.size(); idx++) {
cv::Rect rec= cv::boundingRect(contours[idx]);
if(rec.height>10){
cv::rectangle(frame, rec, cv::Scalar(0,255,0));
}
}
imshow("Frame", frame);
clk::time_point t2 = clk::now();
times[index] = (int)duration_cast<milliseconds>( t2 - t1 ).count();
index++;
int k = waitKey(80)&0xFF;
if(k == 'q' || k == 27) {
break;
} else if(k =='s') {
std::cout << frame_count<< std::endl;
imwrite("../results/foreground_lbmog.jpg", mask);
imwrite("../results/trackers.jpg", frame);
}else if(k =='p') {
while(true){
int k2 = waitKey(80)&0xFF;
if(k2=='p'){
break;
}
}
}
}
int sum=0 ,mean=0;
for(int i = 0; i<=index; i++)
sum+=times[i];
mean = sum/(index+1);
cout << "Tempo médio de processamento: " << mean << endl;
return 0;
}
|
//http://bailian.openjudge.cn/practice/2002/
#include <iostream>
#include <vector>
#include <set>
#include <algorithm>
using namespace std;
struct Point
{
int x;
int y;
Point(int tempX, int tempY) :x(tempX), y(tempY)
{
}
};
bool operator < (Point q, Point w)
{
if (q.x != w.x) return q.x > w.x;
else return q.y > w.y;
}
bool operator == (Point q, Point w)
{
if (q.x == w.x&& q.y == w.y) return true;
return false;
}
int main()
{
int n;
std::vector<int> t;
while (1)
{
scanf("%d", &n);
int cnt = 0;
if (n == 0)
{
break;
}
std::set<Point> v;
for (int i = 0; i < n; i++)
{
int x, y;
scanf("%d%d", &x, &y);
//Point tempPoint(x, y);
v.emplace(x, y);
}
for (auto itI = v.begin(); itI != v.end(); itI++)
{
auto itJ = itI;
itJ++;
for (; itJ != v.end(); itJ++)
{
Point vRightTop((*itI).x + (-(*itJ).y + (*itI).y), (*itI).y + ((*itJ).x - (*itI).x));
Point vRightBottom((*itJ).x + (-(*itJ).y + (*itI).y), (*itJ).y + ((*itJ).x - (*itI).x));
Point vLeftTop((*itI).x - (-(*itJ).y + (*itI).y), (*itI).y - ((*itJ).x - (*itI).x));
Point vLeftBottom((*itJ).x - (-(*itJ).y + (*itI).y), (*itJ).y - ((*itJ).x - (*itI).x));
//auto findRightTopResult = std::find(v.begin(), v.end(), vRightTop);
//auto findRightBottomResult = std::find(v.begin(), v.end(), vRightBottom);
/*auto findRightTopResult = v.find(vRightTop);
auto findRightBottomResult = v.find(vRightBottom);*/
//¶¼ÕÒµ½ÁË
if (v.count(vRightTop)==1 && v.count(vRightBottom) == 1)
{
cnt++;
}
//auto findLeftTopResult = std::find(v.begin(), v.end(), vLeftTop);
//auto findLeftBottomResult = std::find(v.begin(), v.end(), vLeftBottom);
/*auto findLeftTopResult = v.find(vLeftTop);
auto findLeftBottomResult = v.find(vLeftBottom);*/
if (v.count(vLeftTop) == 1 && v.count(vLeftBottom) == 1)
{
cnt++;
}
}
}
t.push_back(cnt / 4);
}
for (int i = 0; i < t.size(); i++)
{
std::cout << t[i] << std::endl;
}
return 0;
}
|
/*****************************************************************************
* *
* OpenNI 2.x Alpha *
* Copyright (C) 2012 PrimeSense Ltd. *
* *
* This file is part of OpenNI. *
* *
* 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 ONIDRIVERAPI_H
#define ONIDRIVERAPI_H
#include "OniPlatform.h"
#include "OniCTypes.h"
#include "OniCProperties.h"
#include "OniDriverTypes.h"
#include <stdarg.h>
namespace oni { namespace driver {
class DeviceBase;
class StreamBase;
typedef void (ONI_CALLBACK_TYPE* DeviceConnectedCallback)(const OniDeviceInfo*, void* pCookie);
typedef void (ONI_CALLBACK_TYPE* DeviceDisconnectedCallback)(const OniDeviceInfo*, void* pCookie);
typedef void (ONI_CALLBACK_TYPE* DeviceStateChangedCallback)(const OniDeviceInfo* deviceId, int errorState, void* pCookie);
typedef void (ONI_CALLBACK_TYPE* NewFrameCallback)(StreamBase* streamId, OniFrame*, void* pCookie);
typedef void (ONI_CALLBACK_TYPE* PropertyChangedCallback)(void* sender, int propertyId, const void* data, int dataSize, void* pCookie);
class StreamServices : public OniStreamServices
{
public:
int getDefaultRequiredFrameSize()
{
return OniStreamServices::getDefaultRequiredFrameSize(streamServices);
}
OniFrame* acquireFrame()
{
return OniStreamServices::acquireFrame(streamServices);
}
void addFrameRef(OniFrame* pFrame)
{
OniStreamServices::addFrameRef(streamServices, pFrame);
}
void releaseFrame(OniFrame* pFrame)
{
OniStreamServices::releaseFrame(streamServices, pFrame);
}
};
class StreamBase
{
public:
StreamBase() : m_newFrameCallback(NULL), m_propertyChangedCallback(NULL) {}
virtual ~StreamBase() {}
virtual void setServices(StreamServices* pStreamServices) { m_pServices = pStreamServices; }
virtual OniStatus setProperty(int /*propertyId*/, const void* /*data*/, int /*dataSize*/) {return ONI_STATUS_NOT_IMPLEMENTED;}
virtual OniStatus getProperty(int /*propertyId*/, void* /*data*/, int* /*pDataSize*/) {return ONI_STATUS_NOT_IMPLEMENTED;}
virtual OniBool isPropertySupported(int /*propertyId*/) {return FALSE;}
virtual OniStatus invoke(int /*commandId*/, void* /*data*/, int /*dataSize*/) {return ONI_STATUS_NOT_IMPLEMENTED;}
virtual OniBool isCommandSupported(int /*commandId*/) {return FALSE;}
virtual int getRequiredFrameSize() { return getServices().getDefaultRequiredFrameSize(); }
virtual OniStatus start() = 0;
virtual void stop() = 0;
virtual void setNewFrameCallback(NewFrameCallback handler, void* pCookie) { m_newFrameCallback = handler; m_newFrameCallbackCookie = pCookie; }
virtual void setPropertyChangedCallback(PropertyChangedCallback handler, void* pCookie) { m_propertyChangedCallback = handler; m_propertyChangedCookie = pCookie; }
virtual void notifyAllProperties() { return; }
virtual OniStatus convertDepthToColorCoordinates(StreamBase* /*colorStream*/, int /*depthX*/, int /*depthY*/, OniDepthPixel /*depthZ*/, int* /*pColorX*/, int* /*pColorY*/) { return ONI_STATUS_NOT_SUPPORTED; }
virtual OniStatus convertC2DCoordinates(int /*depthX*/, int /*depthY*/, OniDepthPixel /*depthZ*/, int* /*pColorX*/, int* /*pColorY*/) { return ONI_STATUS_NOT_SUPPORTED; }
virtual OniStatus convertD2CCoordinates(int /*depthX*/, int /*depthY*/, OniDepthPixel /*depthZ*/, int* /*pColorX*/, int* /*pColorY*/) { return ONI_STATUS_NOT_SUPPORTED; }
protected:
void raiseNewFrame(OniFrame* pFrame) { (*m_newFrameCallback)(this, pFrame, m_newFrameCallbackCookie); }
void raisePropertyChanged(int propertyId, const void* data, int dataSize) { (*m_propertyChangedCallback)(this, propertyId, data, dataSize, m_propertyChangedCookie); }
StreamServices& getServices() { return *m_pServices; }
private:
StreamServices* m_pServices;
NewFrameCallback m_newFrameCallback;
void* m_newFrameCallbackCookie;
PropertyChangedCallback m_propertyChangedCallback;
void* m_propertyChangedCookie;
};
class DeviceBase
{
public:
DeviceBase() {}
virtual ~DeviceBase() {}
virtual OniStatus getSensorInfoList(OniSensorInfo** pSensorInfos, int* numSensors) = 0;
virtual StreamBase* createStream(OniSensorType) = 0;
virtual void destroyStream(StreamBase* pStream) = 0;
virtual OniStatus setProperty(int /*propertyId*/, const void* /*data*/, int /*dataSize*/) {return ONI_STATUS_NOT_IMPLEMENTED;}
virtual OniStatus getProperty(int /*propertyId*/, void* /*data*/, int* /*pDataSize*/) {return ONI_STATUS_NOT_IMPLEMENTED;}
virtual OniBool isPropertySupported(int /*propertyId*/) {return FALSE;}
virtual OniStatus invoke(int /*commandId*/, void* /*data*/, int /*dataSize*/) {return ONI_STATUS_NOT_IMPLEMENTED;}
virtual OniBool isCommandSupported(int /*commandId*/) {return FALSE;}
virtual OniStatus tryManualTrigger() {return ONI_STATUS_OK;}
virtual void setPropertyChangedCallback(PropertyChangedCallback handler, void* pCookie) { m_propertyChangedCallback = handler; m_propertyChangedCookie = pCookie; }
virtual void notifyAllProperties() { return; }
virtual OniBool isImageRegistrationModeSupported(OniImageRegistrationMode mode) { return (mode == ONI_IMAGE_REGISTRATION_OFF); }
protected:
void raisePropertyChanged(int propertyId, const void* data, int dataSize) { (*m_propertyChangedCallback)(this, propertyId, data, dataSize, m_propertyChangedCookie); }
private:
PropertyChangedCallback m_propertyChangedCallback;
void* m_propertyChangedCookie;
};
class DriverServices
{
public:
DriverServices(OniDriverServices* pDriverServices) : m_pDriverServices(pDriverServices) {}
void errorLoggerAppend(const char* format, ...)
{
va_list args;
va_start(args, format);
m_pDriverServices->errorLoggerAppend(m_pDriverServices->driverServices, format, args);
va_end(args);
}
void errorLoggerClear()
{
m_pDriverServices->errorLoggerClear(m_pDriverServices->driverServices);
}
void log(int severity, const char* file, int line, const char* mask, const char* message)
{
m_pDriverServices->log(m_pDriverServices->driverServices, severity, file, line, mask, message);
}
private:
OniDriverServices* m_pDriverServices;
};
class DriverBase
{
public:
DriverBase(OniDriverServices* pDriverServices) : m_services(pDriverServices)
{}
virtual ~DriverBase() {}
virtual OniStatus initialize(DeviceConnectedCallback connectedCallback, DeviceDisconnectedCallback disconnectedCallback, DeviceStateChangedCallback deviceStateChangedCallback, void* pCookie)
{
m_deviceConnectedEvent = connectedCallback;
m_deviceDisconnectedEvent = disconnectedCallback;
m_deviceStateChangedEvent = deviceStateChangedCallback;
m_pCookie = pCookie;
return ONI_STATUS_OK;
}
virtual DeviceBase* deviceOpen(const char* uri, const char* mode, OniStatus& status) = 0;
virtual void deviceClose(DeviceBase* pDevice) = 0;
virtual void shutdown() = 0;
virtual OniStatus tryDevice(const char* /*uri*/) { return ONI_STATUS_ERROR;}
virtual void* enableFrameSync(StreamBase** /*pStreams*/, int /*streamCount*/) { return NULL; }
virtual void disableFrameSync(void* /*frameSyncGroup*/) {}
#ifdef FREE_SELINUX
virtual void SetUsbParam(int fd, const char* usbpath){}
#endif
protected:
void deviceConnected(const OniDeviceInfo* pInfo) { (m_deviceConnectedEvent)(pInfo, m_pCookie); }
void deviceDisconnected(const OniDeviceInfo* pInfo) { (m_deviceDisconnectedEvent)(pInfo, m_pCookie); }
void deviceStateChanged(const OniDeviceInfo* pInfo, int errorState) { (m_deviceStateChangedEvent)(pInfo, errorState, m_pCookie); }
DriverServices& getServices() { return m_services; }
private:
DeviceConnectedCallback m_deviceConnectedEvent;
DeviceDisconnectedCallback m_deviceDisconnectedEvent;
DeviceStateChangedCallback m_deviceStateChangedEvent;
void* m_pCookie;
DriverServices m_services;
};
}} // oni::driver
#define ONI_EXPORT_DRIVER_BASE(DriverClass) \
\
oni::driver::DriverBase* g_pDriver = NULL; \
\
/* As Driver */ \
ONI_C_API_EXPORT void oniDriverCreate(OniDriverServices* driverServices) { \
g_pDriver = XN_NEW(DriverClass, driverServices); \
} \
ONI_C_API_EXPORT void oniDriverDestroy() \
{ \
g_pDriver->shutdown(); \
XN_DELETE(g_pDriver); g_pDriver = NULL; \
} \
ONI_C_API_EXPORT OniStatus oniDriverInitialize(oni::driver::DeviceConnectedCallback deviceConnectedCallback, \
oni::driver::DeviceDisconnectedCallback deviceDisconnectedCallback, \
oni::driver::DeviceStateChangedCallback deviceStateChangedCallback, \
void* pCookie) \
{ \
return g_pDriver->initialize(deviceConnectedCallback, deviceDisconnectedCallback, deviceStateChangedCallback, pCookie); \
} \
\
ONI_C_API_EXPORT OniStatus oniDriverTryDevice(const char* uri) \
{ \
return g_pDriver->tryDevice(uri); \
} \
\
/* As Device */ \
ONI_C_API_EXPORT oni::driver::DeviceBase* oniDriverDeviceOpen(const char* uri, const char* mode, OniStatus& status) \
{ \
return g_pDriver->deviceOpen(uri, mode, status); \
} \
ONI_C_API_EXPORT void oniDriverDeviceClose(oni::driver::DeviceBase* pDevice) \
{ \
g_pDriver->deviceClose(pDevice); \
} \
\
ONI_C_API_EXPORT OniStatus oniDriverDeviceGetSensorInfoList(oni::driver::DeviceBase* pDevice, OniSensorInfo** pSensorInfos, \
int* numSensors) \
{ \
return pDevice->getSensorInfoList(pSensorInfos, numSensors); \
} \
\
ONI_C_API_EXPORT oni::driver::StreamBase* oniDriverDeviceCreateStream(oni::driver::DeviceBase* pDevice, \
OniSensorType sensorType) \
{ \
return pDevice->createStream(sensorType); \
} \
\
ONI_C_API_EXPORT void oniDriverDeviceDestroyStream(oni::driver::DeviceBase* pDevice, oni::driver::StreamBase* pStream) \
{ \
return pDevice->destroyStream(pStream); \
} \
\
ONI_C_API_EXPORT OniStatus oniDriverDeviceSetProperty(oni::driver::DeviceBase* pDevice, int propertyId, \
const void* data, int dataSize) \
{ \
return pDevice->setProperty(propertyId, data, dataSize); \
} \
ONI_C_API_EXPORT OniStatus oniDriverDeviceGetProperty(oni::driver::DeviceBase* pDevice, int propertyId, \
void* data, int* pDataSize) \
{ \
return pDevice->getProperty(propertyId, data, pDataSize); \
} \
ONI_C_API_EXPORT OniBool oniDriverDeviceIsPropertySupported(oni::driver::DeviceBase* pDevice, int propertyId) \
{ \
return pDevice->isPropertySupported(propertyId); \
} \
ONI_C_API_EXPORT void oniDriverDeviceSetPropertyChangedCallback(oni::driver::DeviceBase* pDevice, \
oni::driver::PropertyChangedCallback handler, void* pCookie) \
{ \
pDevice->setPropertyChangedCallback(handler, pCookie); \
} \
ONI_C_API_EXPORT void oniDriverDeviceNotifyAllProperties(oni::driver::DeviceBase* pDevice) \
{ \
pDevice->notifyAllProperties(); \
} \
ONI_C_API_EXPORT OniStatus oniDriverDeviceInvoke(oni::driver::DeviceBase* pDevice, int commandId, \
void* data, int dataSize) \
{ \
return pDevice->invoke(commandId, data, dataSize); \
} \
ONI_C_API_EXPORT OniBool oniDriverDeviceIsCommandSupported(oni::driver::DeviceBase* pDevice, int commandId) \
{ \
return pDevice->isCommandSupported(commandId); \
} \
ONI_C_API_EXPORT OniStatus oniDriverDeviceTryManualTrigger(oni::driver::DeviceBase* pDevice) \
{ \
return pDevice->tryManualTrigger(); \
} \
ONI_C_API_EXPORT OniBool oniDriverDeviceIsImageRegistrationModeSupported(oni::driver::DeviceBase* pDevice, \
OniImageRegistrationMode mode) \
{ \
return pDevice->isImageRegistrationModeSupported(mode); \
} \
\
/* As Stream */ \
ONI_C_API_EXPORT void oniDriverStreamSetServices(oni::driver::StreamBase* pStream, OniStreamServices* pServices) \
{ \
pStream->setServices((oni::driver::StreamServices*)pServices); \
} \
\
ONI_C_API_EXPORT OniStatus oniDriverStreamSetProperty(oni::driver::StreamBase* pStream, int propertyId, \
const void* data, int dataSize) \
{ \
return pStream->setProperty(propertyId, data, dataSize); \
} \
ONI_C_API_EXPORT OniStatus oniDriverStreamGetProperty(oni::driver::StreamBase* pStream, int propertyId, void* data, \
int* pDataSize) \
{ \
return pStream->getProperty(propertyId, data, pDataSize); \
} \
ONI_C_API_EXPORT OniBool oniDriverStreamIsPropertySupported(oni::driver::StreamBase* pStream, int propertyId) \
{ \
return pStream->isPropertySupported(propertyId); \
} \
ONI_C_API_EXPORT void oniDriverStreamSetPropertyChangedCallback(oni::driver::StreamBase* pStream, \
oni::driver::PropertyChangedCallback handler, void* pCookie) \
{ \
pStream->setPropertyChangedCallback(handler, pCookie); \
} \
ONI_C_API_EXPORT void oniDriverStreamNotifyAllProperties(oni::driver::StreamBase* pStream) \
{ \
pStream->notifyAllProperties(); \
} \
ONI_C_API_EXPORT OniStatus oniDriverStreamInvoke(oni::driver::StreamBase* pStream, int commandId, \
void* data, int dataSize) \
{ \
return pStream->invoke(commandId, data, dataSize); \
} \
ONI_C_API_EXPORT OniBool oniDriverStreamIsCommandSupported(oni::driver::StreamBase* pStream, int commandId) \
{ \
return pStream->isCommandSupported(commandId); \
} \
\
ONI_C_API_EXPORT OniStatus oniDriverStreamStart(oni::driver::StreamBase* pStream) \
{ \
return pStream->start(); \
} \
ONI_C_API_EXPORT void oniDriverStreamStop(oni::driver::StreamBase* pStream) \
{ \
pStream->stop(); \
} \
\
ONI_C_API_EXPORT int oniDriverStreamGetRequiredFrameSize(oni::driver::StreamBase* pStream) \
{ \
return pStream->getRequiredFrameSize(); \
} \
\
ONI_C_API_EXPORT void oniDriverStreamSetNewFrameCallback(oni::driver::StreamBase* pStream, \
oni::driver::NewFrameCallback handler, void* pCookie) \
{ \
pStream->setNewFrameCallback(handler, pCookie); \
} \
\
ONI_C_API_EXPORT OniStatus oniDriverStreamConvertDepthToColorCoordinates(oni::driver::StreamBase* pDepthStream, \
oni::driver::StreamBase* pColorStream, int depthX, int depthY, OniDepthPixel depthZ, int* pColorX, int* pColorY) \
{ \
return pDepthStream->convertDepthToColorCoordinates(pColorStream, depthX, depthY, depthZ, pColorX, pColorY); \
} \
\
ONI_C_API_EXPORT OniStatus oniDriverStreamConvertC2DCoordinates(oni::driver::StreamBase* pDepthStream, \
int colorX, int colorY, OniDepthPixel depthZ, int* pDepthX, int* pDepthY) \
{ \
return pDepthStream->convertC2DCoordinates(colorX, colorY, depthZ, pDepthX, pDepthY); \
} \
\
ONI_C_API_EXPORT OniStatus oniDriverStreamConvertD2CCoordinates(oni::driver::StreamBase* pDepthStream, \
int colorX, int colorY, OniDepthPixel depthZ, int* pDepthX, int* pDepthY) \
{ \
return pDepthStream->convertD2CCoordinates(colorX, colorY, depthZ, pDepthX, pDepthY); \
} \
\
ONI_C_API_EXPORT void* oniDriverEnableFrameSync(oni::driver::StreamBase** pStreams, int streamCount) \
{ \
return g_pDriver->enableFrameSync(pStreams, streamCount); \
} \
\
ONI_C_API_EXPORT void oniDriverDisableFrameSync(void* frameSyncGroup) \
{ \
return g_pDriver->disableFrameSync(frameSyncGroup); \
} \
#ifdef FREE_SELINUX
#define ONI_EXPORT_DRIVER(DriverClass) ONI_EXPORT_DRIVER_BASE(DriverClass) \
ONI_C_API_EXPORT void oniDriverSetUsbParam(int fd, const char* usbpath) \
{ \
return g_pDriver->SetUsbParam(fd,usbpath); \
}
#else
#define ONI_EXPORT_DRIVER(DriverClass) ONI_EXPORT_DRIVER_BASE(DriverClass)
#endif
#endif // ONIDRIVERAPI_H
|
#include<iostream>
using namespace std;
const int MAX=10;
class queue
{
private:
int arr[MAX];
int front, rear;
public:
queue();
void add(int item);
int del();
};
queue::queue()
{
front=rear=-1;
}
void queue::add(int item)
{
if(rear==MAX-1)
{
cout<<"\nQueue is full";
return;
}
rear++;
arr[rear]=item;
if(front==-1)
front =0;
}
int queue::del()
{
if(front==-1)
{
cout<<"\nQueue is empty";
return NULL;
}
int item = arr[front];
arr[front]=NULL;
if(front==rear)
front= rear=-1;
else
front++;
return item;
}
int main()
{
int n;
queue q;
for(int i=0; i<11; i++)
{
q.add(i+1);
}
for(int i=0; i<11; i++)
{
cout<<q.del()<<"\n";
}
}
|
#include "uishader.h"
UiShader::UiShader(const std::string &vertexFile, const std::string &fragmentFile) :
AbstractShader(vertexFile, fragmentFile)
{
getUniforms();
}
void UiShader::loadProjectionMatrix(const Matrix4 &matrix)
{
loadMatrix(_locationProjectionMatrix, matrix);
}
void UiShader::getUniforms()
{
useProgram();
auto locationProjectionMatrix = glGetUniformLocation(_id, "projectionMatrix");
if (locationProjectionMatrix == -1) {
throw std::runtime_error("Unable to get uniform location: projectionMatrix");
}
_locationProjectionMatrix = static_cast<GLuint>(locationProjectionMatrix);
}
|
#include "machine.h"
Machine::Machine( std::string name, Vector dim ){
this->name = name;
this->dimensions = dim;
}
void Machine::set_tool_position( const Vector &pos ){
this->position = pos;
}
Vector Machine::get_tool_position( ){
return this->position;
}
Vector Machine::get_dimensions(){
}
std::string& Machine::get_name(){
}
|
#include<bits/stdc++.h>
using namespace std;
class Student{
public:
int rno;
private:
int age;
public:
int getAgeRno(){
return age;
}
void setAgeRno(int a,int b){
age = a;
rno = b;
}
void display(){
cout << age << " " << rno << endl;
}
};
int main(){
Student s1;
Student* s2 = new Student;
s1.setAgeRno(20,101);
s2->setAgeRno(25,102);
s1.display();
s2->display();
return 0;
}
|
//Gameboard.h
#include"Grid.h"
template <typename T>
class Gameboard : public Grid<T>
{
public:
Gameboard(int inWidth=Grid<T>::kDefaultWidth,int inHeight=Grid<T>::kDefaultHeight);
void move(int xSrc,int ySrc,int xDest,int yDest);
} ;
template <typename T>
Gameboard<T>::Gameboard(int inWidth,int inHeight):Grid<T>(inWidth,inHeight)
{
}
template <typename T>
void Gameboard<T>::move(int xSrc,int ySrc,int xDest,int yDest)
{
this->mCells[xDest][yDest]=this->mCells[xSrc][ySrc];
this->mCells[xSrc][ySrc]=T();//zero-initialize the source cell.
}
Gameboard<ChessPiece> chessBoard;
ChessPiece pawn;
chessBoard.setElementAt(0,0,pawn);
chessBoard.move(0,0,0,1);
|
/* -*- Mode: c++; tab-width: 4; indent-tabs-mode: t; c-basic-offset: 4; c-file-style:"stroustrup" -*-
*
* Copyright (C) 1995-2010 Opera Software AS. All rights reserved.
*
* This file is part of the Opera web browser. It may not be distributed
* under any circumstances.
*
* @author Anders Karlsson (pugo)
*/
#ifndef VEGAOPPRINTERBACKEND_H
#define VEGAOPPRINTERBACKEND_H
#ifdef VEGA_POSTSCRIPT_PRINTING
/** @short Abstraction of platform printer integration and PostScript printing.
*
* Since the VEGAOpPrinterController, different from the OpPrinterControllers,
* should not be dependent on platform code an abstraction for the platform
* printing functionality is needed. This includes things like showing a printing
* dialog, providing information about selected paper size, margins, scaling,
* and of course the actual print operation (sending the PostScript job to printer).
*
* This class has to be subclassed in the platform code to provide the necessary
* print functionality.
*/
class VEGAOpPrinterBackend
{
public:
/** Create new VEGAOpPrinterBackend object
* @param new_printerbackend (output) Will be set to the new
* VEGAOpPrinterBackend object, unless an error value is returned.
*/
static OP_STATUS Create(VEGAOpPrinterBackend** new_printerbackend);
virtual ~VEGAOpPrinterBackend() {}
/** Initiate the printer backend */
virtual OP_STATUS Init() = 0;
/** Prepare a printing operation.
* Display printer dialog if needed and do other necessary platform preparations.
*/
virtual OP_STATUS PreparePrinting() = 0;
/** Get the printer resolution - DPI
* @param horizontal will be set to printer horizontal resolution.
* @param vertical will be set to printer vertical resolution.
* @return OpStatus::OK if values were successfully set, otherwise OpStatus::ERR.
*/
virtual OP_STATUS GetPrinterResolution(UINT16& horizontal, UINT16& vertical) = 0;
/** Get the print job scaling
* @param scale will be set to the scaling of the print job (normal is 100 for 100%).
* @return OpStatus::OK if value was successfully set, otherwise OpStatus::ERR.
*/
virtual OP_STATUS GetPrintScale(UINT32& scale) = 0;
/** Get the print job paper size in inches
* Since inches are commonly used in printer metrics (72 dpi, etc) we use them here.
* @param width will be set to the paper width for the print job.
* @param height will be set to the paper height for the print job.
* @return OpStatus::OK if values were successfully set, otherwise OpStatus::ERR.
*/
virtual OP_STATUS GetPaperSize(double& width, double& height) = 0;
/** Get the print job margins in inches
* Since inches are commonly used in printer metrics (72 dpi, etc) we use them here.
* @param top will be set to the top margin of the print job.
* @param left will be set to the left margin of the print job.
* @param bottom will be set to the bottom margin of the print job.
* @param right will be set to the right margin of the print job.
* @return OpStatus::OK if values were successfully set, otherwise OpStatus::ERR.
*/
virtual OP_STATUS GetMargins(double& top, double& left, double& bottom, double& right) = 0;
/** Returns true if only selection should be printed.
* @return the state
*/
virtual bool GetPrintSelectionOnly() = 0;
/** Print a file with the prepared settings.
* The Print function should at least support PostScript files.
* @param print_file file to print.
* @param print_job_name a name of the print job. This can be used to identify the print job in platform print interfaces.
* @return OpStatus::OK if the print job was successfully started, otherwise OpStatus::ERR.
*/
virtual OP_STATUS Print(class OpFile& print_file, OpString& print_job_name) = 0;
/** Return boolean telling if a numbered page shuould be printed or not.
* To support printing of selected pages and ranges of pages this function should
* return true if given page number is within the selection of pages that should be printed.
* @param page_number page number to check printing for.
* @return true if page should be printed, false if page should be omitted.
*/
virtual bool PageShouldBePrinted(int page_number) = 0;
};
#endif // VEGA_POSTSCRIPT_PRINTING
#endif // VEGAOPPRINTERBACKEND_H
|
// Created on: 1995-03-06
// Created by: Laurent PAINNOT
// Copyright (c) 1995-1999 Matra Datavision
// Copyright (c) 1999-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#ifndef _Poly_Triangle_HeaderFile
#define _Poly_Triangle_HeaderFile
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <Standard_Integer.hxx>
#include <Standard_OutOfRange.hxx>
//! Describes a component triangle of a triangulation (Poly_Triangulation object).
//! A Triangle is defined by a triplet of nodes within [1, Poly_Triangulation::NbNodes()] range.
//! Each node is an index in the table of nodes specific to an existing
//! triangulation of a shape, and represents a point on the surface.
class Poly_Triangle
{
public:
DEFINE_STANDARD_ALLOC
//! Constructs a triangle and sets all indices to zero.
Poly_Triangle() { myNodes[0] = myNodes[1] = myNodes[2] = 0; }
//! Constructs a triangle and sets its three indices,
//! where these node values are indices in the table of nodes specific to an existing triangulation of a shape.
Poly_Triangle (const Standard_Integer theN1, const Standard_Integer theN2, const Standard_Integer theN3)
{
myNodes[0] = theN1;
myNodes[1] = theN2;
myNodes[2] = theN3;
}
//! Sets the value of the three nodes of this triangle.
void Set (const Standard_Integer theN1, const Standard_Integer theN2, const Standard_Integer theN3)
{
myNodes[0] = theN1;
myNodes[1] = theN2;
myNodes[2] = theN3;
}
//! Sets the value of node with specified index of this triangle.
//! Raises Standard_OutOfRange if index is not in 1,2,3
void Set (const Standard_Integer theIndex, const Standard_Integer theNode)
{
Standard_OutOfRange_Raise_if(theIndex < 1 || theIndex > 3, "Poly_Triangle::Set(), invalid index");
myNodes[theIndex - 1] = theNode;
}
//! Returns the node indices of this triangle.
void Get (Standard_Integer& theN1, Standard_Integer& theN2, Standard_Integer& theN3) const
{
theN1 = myNodes[0];
theN2 = myNodes[1];
theN3 = myNodes[2];
}
//! Get the node of given Index.
//! Raises OutOfRange from Standard if Index is not in 1,2,3
Standard_Integer Value (const Standard_Integer theIndex) const
{
Standard_OutOfRange_Raise_if(theIndex < 1 || theIndex > 3, "Poly_Triangle::Value(), invalid index");
return myNodes[theIndex - 1];
}
Standard_Integer operator() (const Standard_Integer Index) const { return Value(Index); }
//! Get the node of given Index.
//! Raises OutOfRange if Index is not in 1,2,3
Standard_Integer& ChangeValue (const Standard_Integer theIndex)
{
Standard_OutOfRange_Raise_if(theIndex < 1 || theIndex > 3, "Poly_Triangle::ChangeValue(), invalid index");
return myNodes[theIndex - 1];
}
Standard_Integer& operator() (const Standard_Integer Index) { return ChangeValue(Index); }
protected:
Standard_Integer myNodes[3];
};
#endif // _Poly_Triangle_HeaderFile
|
/* -*- Mode: c++; tab-width: 4; indent-tabs-mode: t; c-basic-offset: 4 -*-
**
** Copyright (C) 2005 Opera Software AS. All rights reserved.
**
** This file is part of the Opera web browser. It may not be distributed
** under any circumstances.
*/
#ifndef SVG_FILTER_TRAVERSAL_OBJECT_H
#define SVG_FILTER_TRAVERSAL_OBJECT_H
#if defined(SVG_SUPPORT) && defined(SVG_SUPPORT_FILTERS)
#include "modules/svg/src/SVGTraverse.h"
class SVGFilterNode;
class SVGFilter;
struct SVGLightSource;
class SVGFilterTraversalObject : public SVGTraversalObject
{
public:
SVGFilterTraversalObject(SVGChildIterator* child_iterator, SVGFilter* filter) :
SVGTraversalObject(child_iterator), m_filter(filter) {}
virtual ~SVGFilterTraversalObject() {}
virtual OP_STATUS HandleFilterPrimitive(SVGElementInfo& info);
private:
void CreateFeImage(HTML_Element* feimage_element, const SVGRect& feimage_region,
SVGDocumentContext* doc_ctx, SVGElementResolver* resolver,
SVGPaintNode*& paint_node);
void GetLightSource(HTML_Element* elm, SVGLightSource& light);
OP_STATUS GetFilterPrimitiveRegion(HTML_Element* prim_element, SVGRect& region);
SVGFilterNode* LookupInput(HTML_Element* elm, Markup::AttrType input_attr);
OP_STATUS PushNode(SVGString* result_name, SVGFilterNode* filter_node);
// Result destinations
OpVector<SVGString> m_res_store;
SVGFilter* m_filter;
};
#endif // SVG_SUPPORT && SVG_SUPPORT_FILTERS
#endif // SVG_FILTER_TRAVERSAL_OBJECT_H
|
#pragma once
#include <iostream>
#include <string>
#include <fstream>
class CodeWriter
{
public:
CodeWriter();
void setFileName(std::string fileName);
std::string outputFileName;
std::string fileName;
std::string functionName;
std::ofstream outputFile;
int labelNum;
int start;
void writeInit();
void writeArithmetic(std::string command);
void writePushPop(std::string cmmd, std::string segment, int index);
void writeLabel(std::string label);
void writeGoTo(std::string label);
void writeIf(std::string label);
void writeCall(std::string funcName, int numArgs);
void writeFunction(std::string functName, int numLocals);
void setReturn(int input);
void getReturn(int input);
void writeReturn();
void incrStack();
void decrStack();
void Close();
~CodeWriter();
};
|
#include<cstdio>
using namespace std;
int n,m;
int a[1000010];
int b[1000010];
int c[1000010];
int lowbit(int x)
{
return x&(-x);
}
void add(int x,int y,int n)
{
for(int i=x;i<=n;i+=lowbit(i))
c[i]+=y;
}
int find(int x)
{
int sum=0;
for(int i=x;i>0;i-=lowbit(i))
sum+=c[i];
return sum;
}
int main()
{
scanf("%d%d",&n,&m);
for(int i=1;i<=n;i++)
{
scanf("%d",&a[i]);
b[i]=a[i]-a[i-1];
add(i,b[i],n);
}
for(int i=1;i<=m;i++)
{
int q,x,y,k;
scanf("%d",&q);
if(q==1)
{
scanf("%d%d%d",&x,&y,&k);
b[x]+=k , b[y+1]+=k;
add(x,k,n);
add(y+1,-k,n);
}
else
{
scanf("%d",&x);
int ans=find(x);
printf("%d\n",ans);
}
}
}
|
//============================================================================
// Name : String.cpp
// Author :
// Version :
// Copyright : Your copyright notice
// Description : Hello World in C++, Ansi-style
//============================================================================
#include<iostream>
using namespace std;
int main(void){
//read string from keyboard
// string str;
// getline(cin,str);
// cout<<str<<endl;
//read string from keyboard
// cin>>str;
// cout<<str<<endl;
//length()
// string str1="string";
// cout<<str1.length();
//push_back and pop_back
// string str="monu";
// cout<<str<<endl;
// str.push_back('x');
// cout<<str<<endl;
// str.pop_back();
// cout<<str<<endl;
//iterate by iterators
// string str="monu kumar";
// string::iterator it;
// for( it=str.begin();it!=str.end();it++){
//
// cout<<*it;
// }
//
// cout<<endl;
//
// for( auto it=str.begin();it!=str.end();it++){
//
// cout<<*it;
// }
// cout<<endl;
//
// for(auto it=str.rbegin();it!=str.rend();it++){
// cout<<*it;
// }
//accessing element
// string str="akumar";
// cout<<str.at(3)<<endl;
// cout<<str[3]<<endl;
//insert chars
// string str1="abcd";
// str1.insert(str1.begin(),'q');
// cout<<str1<<endl;
//
// string str2="abcd";
// str2.insert(3,3,'q');
// cout<<str2<<endl;
//
// string str3="abc";
// str3.insert(str3.begin(),3,'q');
// cout<<str3<<endl;
//insert c string
// string str4="abcd";
// str4.insert(2,"xyz");
// cout<<str4<<endl;
//
// string str5="abcd";
// str5.insert(2,"xyz",1);
// cout<<str5<<endl;
//erase
// string str="abcde";
// str.erase(2);
// cout<<str<<endl;
//
// string str1="abcde";
// str1.erase(str1.begin()+2);
// cout<<str1<<endl;
//
// string str2="abcde";
// str2.erase(str2.begin(),str2.begin()+2);
// cout<<str2<<endl;
}
|
// Created on: 2015-08-10
// Created by: Irina KRYLOVA
// Copyright (c) 2015 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#ifndef _StepDimTol_GeoTolAndGeoTolWthDatRef_HeaderFile
#define _StepDimTol_GeoTolAndGeoTolWthDatRef_HeaderFile
#include <Standard.hxx>
#include <Standard_Type.hxx>
#include <StepDimTol_GeometricTolerance.hxx>
#include <StepDimTol_GeometricToleranceType.hxx>
class StepDimTol_GeometricToleranceTarget;
class StepDimTol_GeometricToleranceWithDatumReference;
class TCollection_HAsciiString;
class StepBasic_MeasureWithUnit;
class StepRepr_ShapeAspect;
class StepDimTol_GeoTolAndGeoTolWthDatRef;
DEFINE_STANDARD_HANDLE(StepDimTol_GeoTolAndGeoTolWthDatRef, StepDimTol_GeometricTolerance)
class StepDimTol_GeoTolAndGeoTolWthDatRef : public StepDimTol_GeometricTolerance
{
public:
Standard_EXPORT StepDimTol_GeoTolAndGeoTolWthDatRef();
Standard_EXPORT void Init (const Handle(TCollection_HAsciiString)& theName,
const Handle(TCollection_HAsciiString)& theDescription,
const Handle(StepBasic_MeasureWithUnit)& theMagnitude,
const Handle(StepRepr_ShapeAspect)& theTolerancedShapeAspect,
const Handle(StepDimTol_GeometricToleranceWithDatumReference)& theGTWDR,
const StepDimTol_GeometricToleranceType theType);
Standard_EXPORT void Init (const Handle(TCollection_HAsciiString)& aName,
const Handle(TCollection_HAsciiString)& aDescription,
const Handle(StepBasic_MeasureWithUnit)& aMagnitude,
const StepDimTol_GeometricToleranceTarget& aTolerancedShapeAspect,
const Handle(StepDimTol_GeometricToleranceWithDatumReference)& aGTWDR,
const StepDimTol_GeometricToleranceType theType);
inline void SetGeometricToleranceWithDatumReference (const Handle(StepDimTol_GeometricToleranceWithDatumReference)& theGTWDR){
myGeometricToleranceWithDatumReference = theGTWDR;
}
inline Handle(StepDimTol_GeometricToleranceWithDatumReference) GetGeometricToleranceWithDatumReference() const {
return myGeometricToleranceWithDatumReference;
}
inline void SetGeometricToleranceType (const StepDimTol_GeometricToleranceType theType){
myToleranceType = theType;
}
StepDimTol_GeometricToleranceType GetToleranceType() const {
return myToleranceType;
}
DEFINE_STANDARD_RTTIEXT(StepDimTol_GeoTolAndGeoTolWthDatRef,StepDimTol_GeometricTolerance)
private:
Handle(StepDimTol_GeometricToleranceWithDatumReference) myGeometricToleranceWithDatumReference;
StepDimTol_GeometricToleranceType myToleranceType;
};
#endif // _StepDimTol_GeoTolAndGeoTolWthDatRef_HeaderFile
|
#include "shaderprogram.h"
#include <fstream>
#include <sstream>
#include <iostream>
using std::cerr;
using std::endl;
namespace PLUGraphicsLib {
ShaderProgram::ShaderProgram() : programID(0), linked(false) { }
ShaderProgram::~ShaderProgram() {
if(programID == 0) return;
// Query the number of attached shaders
GLint numShaders = 0;
glGetProgramiv(programID, GL_ATTACHED_SHADERS, &numShaders);
// Get the shader names
GLuint * shaderNames = new GLuint[numShaders];
glGetAttachedShaders(programID, numShaders, NULL, shaderNames);
// Delete the shaders
for (int i = 0; i < numShaders; i++)
glDeleteShader(shaderNames[i]);
// Delete the program
glDeleteProgram (programID);
delete[] shaderNames;
}
void ShaderProgram::use() {
if( programID != 0 && linked )
glUseProgram(programID);
}
void ShaderProgram::compile(const char * vShaderCode, const char * fShaderCode) {
// Create the shader objects
GLuint vert = glCreateShader(GL_VERTEX_SHADER);
GLuint frag = glCreateShader(GL_FRAGMENT_SHADER);
// Load the shader source
glShaderSource(vert, 1, &vShaderCode, NULL);
glShaderSource(frag, 1, &fShaderCode, NULL);
// Compile
glCompileShader(vert);
if (!checkCompilationStatus(vert)) {
glDeleteShader(vert);
glDeleteShader(frag);
throw ShaderCompilationError("Failed to compile vertex shader.");
}
glCompileShader(frag);
if (!checkCompilationStatus(frag)) {
glDeleteShader(vert);
glDeleteShader(frag);
throw ShaderCompilationError("Failed to compile fragment shader.");
}
// Create the program object
programID = glCreateProgram();
glAttachShader(programID, vert);
glAttachShader(programID, frag);
}
void ShaderProgram::setUniform(const char *name, const glm::mat4 & m) {
GLint location = glGetUniformLocation(programID, name);
glUniformMatrix4fv(location, 1, GL_FALSE, &m[0][0]);
}
void ShaderProgram::setUniform(const char * name, const glm::vec3 & value ) {
GLint location = glGetUniformLocation(programID, name);
glUniform3f(location, value.x, value.y, value.z);
}
void ShaderProgram::setUniform(const char * name, float value ) {
GLint location = glGetUniformLocation(programID, name);
glUniform1f(location, value);
}
void ShaderProgram::setUniform(const char * name, int value ) {
GLint location = glGetUniformLocation(programID, name);
glUniform1i(location, value);
}
void ShaderProgram::compileFromFile(const char *vShaderFileName, const char * fShaderFileName) {
string vShaderCode, fShaderCode;
loadFile(vShaderFileName, vShaderCode);
loadFile(fShaderFileName, fShaderCode);
compile(vShaderCode.c_str(), fShaderCode.c_str());
}
void ShaderProgram::bindAttribLocation(GLuint index, const char * attribName ) {
glBindAttribLocation(programID, index, attribName);
}
void ShaderProgram::link() {
if( programID != 0 ) {
glLinkProgram( programID );
checkLinkStatus();
linked = true;
}
}
void ShaderProgram::loadFile( const char * fName, string &result ) {
std::ifstream inFile(fName);
if (!inFile) throw ShaderCompilationError("Shader file not found.");
std::stringstream code;
code << inFile.rdbuf();
inFile.close();
result = code.str();
}
bool ShaderProgram::checkCompilationStatus( GLuint shaderID )
{
GLint status, logLen;
GLchar *log;
glGetShaderiv(shaderID, GL_COMPILE_STATUS, &status);
if( GL_TRUE == status ) return true;
glGetShaderiv(shaderID, GL_INFO_LOG_LENGTH, &logLen);
log = new GLchar[ logLen ];
glGetShaderInfoLog(shaderID, logLen, NULL, log);
cerr << "Failed to compile shader" << endl;
cerr << log << endl;
delete [] log;
return false;
}
bool ShaderProgram::checkLinkStatus( )
{
GLint status, logLen;
GLchar *log;
glGetProgramiv(programID, GL_LINK_STATUS, &status);
if( GL_TRUE == status ) return true;
glGetProgramiv(programID, GL_INFO_LOG_LENGTH, &logLen);
log = new GLchar[ logLen ];
glGetProgramInfoLog(programID, logLen, NULL, log);
cerr << "Failed to link shader" << endl;
cerr << log << endl;
delete [] log;
return false;
}
} /* namespace PLUGraphicsLib */
|
#ifndef _GAME_SCENE_
#define _GAME_SCENE_
#include "cocos2d.h"
#include "extensions/cocos-ext.h"
#include "cocostudio/CocoStudio.h"
#include "ui/CocosGUI.h"
#include "AppGlobal.h"
#include "Ball.h"
#include "Player.h"
#include "FootBallCommon.h"
#include "HomePlayer.h"
#include "CustomPlayer.h"
#include "PlayGroundFullLayer.h"
#include "GameFSM.h"
USING_NS_CC;
USING_NS_CC_EXT;
#define INIT_PLAYER(__NUM__,__STARTPOSTION__,__HOMEREGION__) \
auto home_player##__NUM__ = HomePlayer::create(__NUM__); \
home_player##__NUM__->setGround(m_playGround->getBoundingBox()); \
home_player##__NUM__->setStartPosition(__STARTPOSTION__); \
home_player##__NUM__->setHomeRegion(__HOMEREGION__); \
home_player##__NUM__->setSpeed(2); \
home_player##__NUM__->setColor(Color3B::RED); \
home_player##__NUM__->initAnimate(); \
_homeTeam->addObject(home_player##__NUM__); \
m_playGround->addChild(home_player##__NUM__); \
#define INIT_PLAYER_CUSTOM(__NUM__,__STARTPOSTION__,__HOMEREGION__) \
auto custom_player##__NUM__ = CustomPlayer::create(__NUM__); \
custom_player##__NUM__->setGround(m_playGround->getBoundingBox()); \
custom_player##__NUM__->setStartPosition(__STARTPOSTION__); \
custom_player##__NUM__->setHomeRegion(__HOMEREGION__); \
custom_player##__NUM__->setSpeed(2); \
custom_player##__NUM__->setColor(Color3B::BLUE); \
custom_player##__NUM__->initAnimate(); \
_customTeam->addObject(custom_player##__NUM__); \
m_playGround->addChild(custom_player##__NUM__); \
using namespace ui;
using namespace cocostudio;
enum GameStatus
{
//½ø¹¥
Attack,
//·ÀÊØ
Defensive,
//ÆËÇò
SaveBall
};
class GameScene : public cocos2d::Layer
{
private:
Player *m_onBallPlayer;
Layout *m_playGround;
PlayGroundFullLayer *m_playGroundFull;
ui::ScrollView *m_scrollView;
Armature *m_camra;
GameFSM *m_gameFSM;
public:
GameScene();
virtual ~GameScene();
// there's no 'id' in cpp, so we recommend returning the class instance pointer
static cocos2d::Scene* createScene();
// Here's a difference. Method 'init' in cocos2d-x returns bool, instead of returning 'id' in cocos2d-iphone
virtual bool init();
// implement the "static create()" method manually
CREATE_FUNC(GameScene);
CC_SYNTHESIZE(CCArray*, _homeTeam, HomeTeam);
CC_SYNTHESIZE(CCArray*, _customTeam, CustomTeam);
CC_SYNTHESIZE(Ball*, _ball, Ball);
CC_SYNTHESIZE(GameStatus, _gameStatus, GameStatus);
GameFSM* getGameFSM();
void runBegin(Vec2 point);
void runOnBall();
bool isRunFinish();
void runFinish();
void passBegin(Vec2 point);
void passBall();
bool isPassFinish();
void passFinish();
void receiveBegin();
void receiveBall();
bool isReceiveFinish();
void receiveFinish();
bool isFinishAction();
void updateGame(float dt);
void btnTouch1(Ref* sender, TouchEventType type);
void btnTouch2(Ref* sender, TouchEventType type);
void showCheckMenu();
void hideCheckMenu();
};
#endif
|
// Created on: 1991-09-05
// Created by: NW,JPB,CAL
// Copyright (c) 1991-1999 Matra Datavision
// Copyright (c) 1999-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#ifndef _Graphic3d_StructureManager_HeaderFile
#define _Graphic3d_StructureManager_HeaderFile
#include <Aspect_GenId.hxx>
#include <Graphic3d_CView.hxx>
#include <Graphic3d_MapOfObject.hxx>
#include <Graphic3d_MapOfStructure.hxx>
#include <Graphic3d_ViewAffinity.hxx>
#include <Graphic3d_ZLayerId.hxx>
#include <Graphic3d_ZLayerSettings.hxx>
#include <Standard_Transient.hxx>
#include <NCollection_IndexedMap.hxx>
#include <Standard.hxx>
#include <Standard_Integer.hxx>
#include <Standard_Type.hxx>
#include <TColStd_Array2OfReal.hxx>
typedef NCollection_IndexedMap<Graphic3d_CView*> Graphic3d_IndexedMapOfView;
class Graphic3d_GraphicDriver;
class Graphic3d_Structure;
class Graphic3d_DataStructureManager;
//! This class allows the definition of a manager to
//! which the graphic objects are associated.
//! It allows them to be globally manipulated.
//! It defines the global attributes.
//! Keywords: Structure, Structure Manager, Update Mode,
//! Destroy, Highlight, Visible
class Graphic3d_StructureManager : public Standard_Transient
{
friend class Graphic3d_Structure;
DEFINE_STANDARD_RTTIEXT(Graphic3d_StructureManager, Standard_Transient)
public:
//! Initializes the ViewManager.
//! Currently creating of more than 100 viewer instances
//! is not supported and leads to InitializationError and
//! initialization failure.
//! This limitation might be addressed in some future OCCT releases.
//! Warning: Raises InitialisationError if the initialization
//! of the ViewManager failed.
Standard_EXPORT Graphic3d_StructureManager (const Handle(Graphic3d_GraphicDriver)& theDriver);
//! Deletes the manager <me>.
Standard_EXPORT ~Graphic3d_StructureManager();
//! Invalidates bounding box of specified ZLayerId.
Standard_EXPORT virtual void Update (const Graphic3d_ZLayerId theLayerId = Graphic3d_ZLayerId_UNKNOWN) const;
//! Deletes and erases the 3D structure manager.
Standard_EXPORT virtual void Remove();
//! Erases all the structures.
Standard_EXPORT virtual void Erase();
//! Returns the set of structures displayed in
//! visualiser <me>.
Standard_EXPORT void DisplayedStructures (Graphic3d_MapOfStructure& SG) const;
//! Returns the set of highlighted structures
//! in a visualiser <me>.
Standard_EXPORT void HighlightedStructures (Graphic3d_MapOfStructure& SG) const;
//! Forces a new construction of the structure.
//! if <theStructure> is displayed and TOS_COMPUTED.
Standard_EXPORT virtual void ReCompute (const Handle(Graphic3d_Structure)& theStructure);
//! Forces a new construction of the structure.
//! if <theStructure> is displayed in <theProjector> and TOS_COMPUTED.
Standard_EXPORT virtual void ReCompute (const Handle(Graphic3d_Structure)& theStructure, const Handle(Graphic3d_DataStructureManager)& theProjector);
//! Clears the structure.
Standard_EXPORT virtual void Clear (Graphic3d_Structure* theStructure, const Standard_Boolean theWithDestruction);
//! Connects the structures.
Standard_EXPORT virtual void Connect (const Graphic3d_Structure* theMother,
const Graphic3d_Structure* theDaughter);
//! Disconnects the structures.
Standard_EXPORT virtual void Disconnect (const Graphic3d_Structure* theMother,
const Graphic3d_Structure* theDaughter);
//! Display the structure.
Standard_EXPORT virtual void Display (const Handle(Graphic3d_Structure)& theStructure);
//! Erases the structure.
Standard_EXPORT virtual void Erase (const Handle(Graphic3d_Structure)& theStructure);
//! Highlights the structure.
Standard_EXPORT virtual void Highlight (const Handle(Graphic3d_Structure)& theStructure);
//! Transforms the structure.
Standard_EXPORT virtual void SetTransform (const Handle(Graphic3d_Structure)& theStructure, const Handle(TopLoc_Datum3D)& theTrsf);
//! Changes the display priority of the structure <AStructure>.
Standard_EXPORT virtual void ChangeDisplayPriority (const Handle(Graphic3d_Structure)& theStructure,
const Graphic3d_DisplayPriority theOldPriority,
const Graphic3d_DisplayPriority theNewPriority);
//! Change Z layer for structure. The Z layer mechanism allows to display structures in higher
//! layers in overlay of structures in lower layers.
Standard_EXPORT virtual void ChangeZLayer (const Handle(Graphic3d_Structure)& theStructure, const Graphic3d_ZLayerId theLayerId);
//! Returns the graphic driver of <me>.
Standard_EXPORT const Handle(Graphic3d_GraphicDriver)& GraphicDriver() const;
//! Attaches the view to this structure manager and sets its identification number within the manager.
Standard_EXPORT Standard_Integer Identification (Graphic3d_CView* theView);
//! Detach the view from this structure manager and release its identification.
Standard_EXPORT void UnIdentification (Graphic3d_CView* theView);
//! Returns the group of views defined in the structure manager.
Standard_EXPORT const Graphic3d_IndexedMapOfView& DefinedViews() const;
//! Returns the theoretical maximum number of definable views in the manager.
//! Warning: It's not possible to accept an infinite number of definable views because each
//! view must have an identification and we have different managers.
Standard_EXPORT Standard_Integer MaxNumOfViews() const;
//! Returns the structure with the identification number <AId>.
Standard_EXPORT virtual Handle(Graphic3d_Structure) Identification (const Standard_Integer AId) const;
//! Suppress the highlighting on the structure <AStructure>.
Standard_EXPORT virtual void UnHighlight (const Handle(Graphic3d_Structure)& AStructure);
//! Suppresses the highlighting on all the structures in <me>.
Standard_EXPORT virtual void UnHighlight();
//! Recomputes all structures in the manager.
//! Resets Device Lost flag.
Standard_EXPORT void RecomputeStructures();
//! Recomputes all structures from theStructures.
Standard_EXPORT void RecomputeStructures (const NCollection_Map<Graphic3d_Structure*>& theStructures);
Standard_EXPORT void RegisterObject (const Handle(Standard_Transient)& theObject,
const Handle(Graphic3d_ViewAffinity)& theAffinity);
Standard_EXPORT void UnregisterObject (const Handle(Standard_Transient)& theObject);
Standard_EXPORT const Handle(Graphic3d_ViewAffinity)& ObjectAffinity (const Handle(Standard_Transient)& theObject) const;
//! Returns TRUE if Device Lost flag has been set and presentation data should be reuploaded onto graphics driver.
Standard_Boolean IsDeviceLost() const { return myDeviceLostFlag; }
//! Sets Device Lost flag.
void SetDeviceLost() { myDeviceLostFlag = Standard_True; }
//! Dumps the content of me into the stream
Standard_EXPORT void DumpJson (Standard_OStream& theOStream, Standard_Integer theDepth = -1) const;
protected:
//! Returns the number of structures displayed in
//! visualizer <me>.
//! Returns the structure displayed in visualizer <me>.
Standard_EXPORT Standard_Integer NumberOfDisplayedStructures() const;
protected:
Aspect_GenId myViewGenId;
Graphic3d_MapOfStructure myDisplayedStructure;
Graphic3d_MapOfStructure myHighlightedStructure;
Graphic3d_MapOfObject myRegisteredObjects;
Handle(Graphic3d_GraphicDriver) myGraphicDriver;
Graphic3d_IndexedMapOfView myDefinedViews;
Standard_Boolean myDeviceLostFlag;
};
DEFINE_STANDARD_HANDLE(Graphic3d_StructureManager, Standard_Transient)
#endif // _Graphic3d_StructureManager_HeaderFile
|
//算法：模拟
//按照题目要求模拟即可
//详见注释
#include<cstdio>
#include<map>
using namespace std;
int n,m;
int a[100010];
map <int,int> s;//map存获得的奖数
int main()
{
scanf("%d%d",&n,&m);
for(int i=1;i<=n;i++)//输入获得第一种奖的人
{
scanf("%d",&a[i]);
s[a[i]]++;//累加
}
for(int j=1;j<=m;j++)// 输入获得第二种奖的人
{
int x;
scanf("%d",&x);
s[x]++;//累加
}
for(int i=1;i<=n;i++)//找到获得两种奖的人
if(s[a[i]]==2)
printf("%d ",a[i]);
}
/*
//二分查找法
//先输入数据
//再将b数组升序排列
//再在b数组中二分查找a数组中的每一个元素
//能找到则答案加一
#include<cstdio>
#include<algorithm>
using namespace std;
int n,m;
int a[100010],b[100010];
bool search(int k)// 二分查找
{
int l=1,r=m;
while(l<=r)
{
int mid=(l+r)/2;
if(b[mid]>k) r=mid-1;
if(b[mid]<k) l=mid+1;
if(b[mid]==k) return 1;
}
return 0;
}
int main()
{
scanf("%d%d",&n,&m);
for(int i=1;i<=n;i++)//输入
scanf("%d",&a[i]);
for(int j=1;j<=m;j++)
scanf("%d",&b[j]);
sort(b+1,b+m+1);//排序
for(int i=1;i<=n;i++)//查找
if(search(a[i]))
printf("%d ",a[i]);
}
*/
|
#ifndef VORTICITY_H
#define VORTICITY_H
#include <algorithm>
#include "interpolation.h"
#include "lsm.h"
#include "defs.h"
#include "geometry.h"
struct line_index
{
int begin;
int end;
line_index() : begin(0), end(0) {}
line_index(int a, int b) : begin(a), end(b) {}
};
struct vorticity_result
{
scut cut;
int vec_count;
double a_priori_error;
double itp_accuracy;
double msd;
double angle;
double _dV_dn;
double approx_line_alpha;
double approx_line_alpha_left;
double approx_line_alpha_right;
double approx_line_accuracy;
double approx_line_average;
double approx_line_msd;
int itp_step_count;
double itp_step_size;
vorticity_result() : vec_count(0), a_priori_error(1.0), itp_accuracy(0.0), msd(0.0), angle(0.0), _dV_dn(0.0), approx_line_alpha(0.0), approx_line_alpha_left(0.0),
approx_line_alpha_right(0.0), approx_line_accuracy(0.0), approx_line_average(0.0), approx_line_msd(0.0),
itp_step_count(0), itp_step_size(0.0) {}
vorticity_result(vec v, double width) : cut(v, width, 0.0, 0.0), vec_count(0), a_priori_error(1.0), itp_accuracy(0.0), msd(0.0), angle(0.0), _dV_dn(0.0),
approx_line_alpha(0.0), approx_line_alpha_left(0.0),
approx_line_alpha_right(0.0), approx_line_accuracy(0.0), approx_line_average(0.0), approx_line_msd(0.0),
itp_step_count(0), itp_step_size(0.0) {}
vorticity_result(vec v, double width, double itp_itv, double weight_coef, int _vec_count) : cut(v, width, itp_itv, weight_coef), vec_count(_vec_count), a_priori_error(1.0),
itp_accuracy(0.0), msd(0.0), angle(0.0), _dV_dn(0.0),
approx_line_alpha(0.0), approx_line_alpha_left(0.0),
approx_line_alpha_right(0.0), approx_line_accuracy(0.0), approx_line_average(0.0), approx_line_msd(0.0),
itp_step_count(0), itp_step_size(0.0) {}
vorticity_result(vec v, double width, double itp_itv, double weight_coef, int _vec_count, double apr_err, double itp_acc, double _msd, double _angle, double dVn,
double apl_alpha, double apl_alphal, double apl_alphar, double apl_acc, double apl_avr, double apl_msd, int isc, double iss) :
cut(v, width, itp_itv, weight_coef), vec_count(_vec_count), a_priori_error(apr_err), itp_accuracy(itp_acc), msd(_msd), angle(_angle), _dV_dn(dVn),
approx_line_alpha(apl_alpha), approx_line_alpha_left(apl_alphal), approx_line_alpha_right(apl_alphar),
approx_line_accuracy(apl_acc), approx_line_average(apl_avr), approx_line_msd(apl_msd), itp_step_count(isc), itp_step_size(iss) {}
static string header()
{
char str[200];
sprintf(str, "longitude1 latitude1 longitude2 latitude2 cut_width itp_itv weight_K vecs apr_err itp_acc itp_MSD angle -dV/dn alpha left right\t cut_len steps step_size");
return string(str);
}
string toString()
{
char str[220];
memset(str, 0, sizeof(str));
sprintf(str, "%2f %2f %2f %2f %2f %2f %2f %d %2f %2f %2f %2f %2f %2f %2f %2f\t%2f %d %2f", cut.start.x, cut.start.y, cut.end.x, cut.end.y,
cut.width, cut.itp_interval, cut.weight_coef, vec_count, a_priori_error, itp_accuracy, msd, angle, _dV_dn, approx_line_alpha, approx_line_alpha_left,
approx_line_alpha_right, /*approx_line_accuracy, approx_line_average, approx_line_msd,*/ cut.v().length_m(), itp_step_count, itp_step_size);
return string(str);
}
};
class Vorticity
{
scut cut;
int calc_index;
int sub_index;
vector <movement> mvn;
string filename(string prefix);
string subfilename(string prefix);
void find_extremum(vecs &vs, vector <line_index> &idx, vecs &crd);
void output_graphic_info(vector <int> &idx, vecs &pnc, vecs &itp, point begin, point end, int start_idx, int end_idx, double *apr_err);
public:
Vorticity(vector <movement> &m);
~Vorticity();
void set_cut(scut _cut);
void set_fl_segment(vec v);
// void calc_prnd();
string get_result_header();
void calculate(vector <vorticity_result> &result);
};
string Vorticity::filename(string prefix)
{
char str[30];
sprintf(str, "%s%d.%s", prefix.c_str(), calc_index, GLANCE_VECTOR_FILE_EXTENSION);
return string(str);
}
string Vorticity::subfilename(string prefix)
{
char str[30];
sprintf(str, "%s%d_%d.%s", prefix.c_str(), calc_index, sub_index, GLANCE_VECTOR_FILE_EXTENSION);
return string(str);
}
void Vorticity::find_extremum(vecs &vs, vector <line_index> &idx, vecs &crd)
{
if (vs.size() == 0) return;
line_index li;
li.begin = 0;
if (vs.size() < 2) return;
vec vextreme;
int ext_count = 0;
double prev_level = vs[0].length();
int prev_grad = sign_(vs[1].length() - vs[0].length());
vector <double> gradient;
for (int i = 2; i < vs.size(); ++i)
{
int cur_grad = sign_(vs[i].length() - vs[i - 1].length());
if (cur_grad * prev_grad < 0)
{
vextreme = vec(vs[i - 1]);
// ext_ind.push_back(i - 1);
li.end = i - 1;
idx.push_back(li);
crd.push_back(vec(vs[li.begin].start, vs[li.end].start));
li.begin = i - 1;
gradient.push_back(vs[i - 1].length() - prev_level);
prev_level = vs[i - 1].length();
prev_grad = cur_grad;
}
}
li.end = vs.size() - 1;
idx.push_back(li);
crd.push_back(vec(vs[li.begin].start, vs[li.end].start));
}
void Vorticity::output_graphic_info(vector <int> &idx, vecs &pnc, vecs &itp, point begin, point end, int start_idx, int end_idx, double *apr_err)
{
ofstream fnc, fpnc, fitp;
fnc.open(subfilename(NORMAL_COMPONENT_FILENAME_PREFIX).c_str());
fpnc.open(subfilename(PROJECTION_FILENAME_PREFIX).c_str());
fitp.open(subfilename(INTERPOLATION_FILENAME_PREFIX).c_str());
Line ct(begin, end);
*apr_err = 0.0;
int count = 0;
for (int i = 0; i < pnc.size(); ++i)
if (ct.contains(pnc[i].start))
{
fnc << ct.normal_component(mvn[idx[i]].v).toGlanceFormat(NORM_COMP_COLOR);
fpnc << pnc[i].toGlanceFormat(NORM_COMP_PROJ_COLOR);
*apr_err += mvn[idx[i]].error;
++count;
}
*apr_err /= count;
for (int i = start_idx; i <= end_idx; ++i)
fitp << itp[i].toGlanceFormat(INTERPOLATION_COLOR);
fnc << ct.interval().toGlanceFormat(CUT_COLOR);
fpnc << ct.interval().toGlanceFormat(CUT_COLOR);
fitp << ct.interval().toGlanceFormat(CUT_COLOR);
fnc.close();
fpnc.close();
fitp.close();
}
Vorticity::Vorticity(vector <movement> &m) : calc_index(0), sub_index(0), mvn(m)
{
flog.open("log.txt");
}
Vorticity::~Vorticity()
{
flog.close();
}
void Vorticity::set_cut(scut _cut)
{
cut = _cut;
if (cut.width == -1) cut.width = BREADTH_SEARCH_RADIUS;
}
/*void Vorticity::calc_prnd()
{
point m = fl_segment.middle();
Line fl_line(fl_segment);
fl_prnd = fl_line.perpendicular(m, BREADTH_SEARCH_RADIUS);
}*/
void Vorticity::calculate(vector <vorticity_result> &result)
{
++calc_index;
sub_index = 0;
Line flp_line(cut.v());
vecs vs;
vector <int> idx;
Border border(cut.v());
flog << "-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|- Cut #" << calc_index << " -|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-\n";
ofstream fnc;
ofstream fpnc;
fnc.open(filename(NORMAL_COMPONENT_FILENAME_PREFIX).c_str());
fpnc.open(filename(PROJECTION_FILENAME_PREFIX).c_str());
double sum_S = 0.0, sum_V = 0.0;
vector <string> slog;
for (int i = 0; i < mvn.size(); ++i)
{
if (/*fls_line.contains_projection(mvn[i].v.start) &&*/ flp_line.contains_projection(mvn[i].v.start) &&
(flp_line.distance_to(mvn[i].v.start) < deg2LS(cut.width)) && mvn[i].velocity > 0.00001)
{
vec nc_proj = flp_line.normal_component_projection(mvn[i].v);
vs.push_back(nc_proj);
idx.push_back(i);
fnc << flp_line.normal_component(mvn[i].v).toGlanceFormat(NORM_COMP_COLOR);
fpnc << nc_proj.toGlanceFormat(NORM_COMP_PROJ_COLOR);
border.refresh(nc_proj.start);
slog.push_back(mvn[i].toString());
sum_S += mvn[i].v.length_m();
sum_V += mvn[i].velocity;
}
}
fnc << border.get_border().toGlanceFormat(CUT_COLOR);
fpnc << border.get_border().toGlanceFormat(CUT_COLOR);
fnc.close();
fpnc.close();
if (vs.size() == 0)
{
flog << "Favorable vectors are not found!\n\n";
vorticity_result vort_res(flp_line.interval(), cut.width);
return result.push_back(vort_res);
}
Line cut_line(border.get_border());
flog << "Cut coordinates are\t" << vec::header() << endl;
flog << "\t\t\t" << cut_line.interval().toStr() << endl;
flog << " coefficients are\t" << cut_line.toString() << endl;
flog << vs.size() << " vectors are found:\n";
flog << movement::header() << endl;
copy(slog.begin(), slog.end(), ostream_iterator<string>(flog, "\n"));
double *itp_step_size = new double(0.0);
Interpolation itp(border.get_border(), vs, calc_index, cut.itp_interval, cut.weight_coef);
vecs ivs = itp.take(vs.size() * 5, itp_step_size);
flog << "As a result of the interpolation " << ivs.size() << " vectors are received.\n";
ofstream fitp;
fitp.open(filename(INTERPOLATION_FILENAME_PREFIX).c_str());
for (int i = 0; i < ivs.size(); ++i)
fitp << ivs[i].toGlanceFormat(INTERPOLATION_COLOR);
fitp << border.get_border().toGlanceFormat(CUT_COLOR);
fitp.close();
vector <line_index> ext_ind;
vecs lc;
find_extremum(ivs, ext_ind, lc);
if (lc.size() > 0)
{
lc[0].start = border.get_border().start;
lc[lc.size() - 1].end = border.get_border().end;
if (lc.size() > 1)
{
flog << lc.size() - 1 << " extremum " << ((lc.size() > 2) ? "are" : "is") << " found:\n";
flog << point::header() << endl;
for (int i = 1; i < lc.size(); ++i)
flog << lc[i].start.toStr() << endl;
}
}
ofstream fal;
fal.open(filename(APPROX_LINE_PREFIX).c_str());
fal << border.get_border().toGlanceFormat(CUT_COLOR);
// double K = mvn[idx[0]].v.length_m() / mvn[idx[0]].velocity;
double T = sum_S / sum_V;
flog << "T = " << T << " seconds\n\n";
Least_Squares_Method lsm_orig(vs);
Least_Squares_Method lsm_itp(ivs);
for (int i = 0; i < ext_ind.size(); ++i)
{
++sub_index;
flog << "------------------------Piece #" << sub_index << "---------------------------------------\n";
double *lsm_err = new double(0.0);
double *lsm_avr = new double(0.0);
double *lsm_msd = new double(0.0);
double *alpha = new double(0.0);
double *alpha_left = new double(0.0);
double *alpha_right = new double (0.0);
flog << "Regression line:\talpha\t\tleft\tright\n";
Line l = lsm_itp.calculate(lc[i], lsm_err, lsm_avr, lsm_msd, alpha, alpha_left, alpha_right);
flog << "\tinterpolation\t" << *alpha << " " << *alpha_left << " " << *alpha_right << endl;
// Line l = lsm_orig.calculate(lc[i], lsm_err, lsm_avr, lsm_msd, alpha, alpha_left, alpha_right);
// flog << "\toriginal\t" << *alpha << " " << *alpha_left << " " << *alpha_right << endl;
flog << "Regression line coefficients are " << l.toString() << endl;
Line gl(vec(ivs[ext_ind[i].begin].start, ivs[ext_ind[i].end].start));
l.set_bounds(gl);
// li.set_bounds(gl);
flog << "After setting bounds regression line\n" <<
" coordinates are\t" << vec::header() << endl <<
"\t\t\t" << l.interval().toStr() << endl /*<<
" coefficients are\t" << l.toString() << endl << endl*/;
point p1 = gl.projection(l.start());
double d1 = l.start().distance_to_m(p1);
point p2 = gl.projection(l.end());
double d2 = l.end().distance_to_m(p2);
double V1 = d1 / T;
double V2 = d2 / T;
flog << "Vorticity calculate\n";
flog << "V1 = " << V1 << " V2 = " << V2 << endl;
double dn = p1.distance_to_m(p2);
flog << "dn = " << dn << endl;
double Vn = - fabs(V1 - V2) / dn;
flog << "-dV/dn = " << Vn << endl << endl;
ofstream fsubal;
fsubal.open(subfilename(APPROX_LINE_PREFIX).c_str());
fsubal << l.interval().toGlanceFormat(APPROX_LINE_COLOR, 3, NO_ANCHOR);
// fal << li.interval().toGlanceFormat(INTERPOLATION_COLOR, 3, "NO_ANCHOR");
fsubal.close();
fal << l.interval().toGlanceFormat(APPROX_LINE_COLOR, 3, NO_ANCHOR);
double angle = l.angle(cut.v());
// double diff = tan(angle);
double diff = angle;
double *itp_acc = new double(0.0);
double *msd = new double(0.0);
int *point_count = new int(0);
itp.calc_accuracy(itp_acc, msd, point_count, lc[i].start, lc[i].end);
if (*point_count < 3)
{
result.push_back(vorticity_result(vec(lc[i].start, lc[i].end), cut.width, itp.get_interval(), itp.get_weight_coef(), *point_count));
continue;
}
double *apr_err = new double(0.0);
output_graphic_info(idx, vs, ivs, lc[i].start, lc[i].end, ext_ind[i].begin, ext_ind[i].end, apr_err);
int itp_step_count = ext_ind[i].end - ext_ind[i].begin;
vorticity_result vort_res(vec(lc[i].start, lc[i].end), cut.width, itp.get_interval(), itp.get_weight_coef(), *point_count, *apr_err, *itp_acc, *msd, diff,
Vn, *alpha, *alpha_left, *alpha_right, *lsm_err, *lsm_avr, *lsm_msd, itp_step_count, *itp_step_size);
result.push_back(vort_res);
}
fal.close();
}
#endif // VORTICITY_H
|
/* ***** BEGIN LICENSE BLOCK *****
* FW4SPL - Copyright (C) IRCAD, 2012-2013.
* Distributed under the terms of the GNU Lesser General Public License (LGPL) as
* published by the Free Software Foundation.
* ****** END LICENSE BLOCK ****** */
#include <boost/foreach.hpp>
// fwComEd
#include <fwComEd/Dictionary.hpp>
// fwTools
#include <fwTools/ClassRegistrar.hpp>
#include <fwData/PointList.hpp>
// gdcmIO
#include "gdcmIO/writer/DicomGlobalWriterManager.hpp"
#include "gdcmIO/DicomInstance.hpp"
#include "gdcmIO/writer/DicomPatientWriter.hpp"
#include "gdcmIO/writer/DicomStudyWriter.hpp"
#include "gdcmIO/writer/DicomSeriesWriter.hpp"
#include "gdcmIO/writer/DicomImageWriterManager.hpp"
#include "gdcmIO/writer/DicomSRWriterManager.hpp"
#include "gdcmIO/writer/DicomRTWriterManager.hpp"
REGISTER_BINDING_BYCLASSNAME( ::fwDataIO::writer::IObjectWriter , ::gdcmIO::writer::DicomGlobalWriterManager, ::gdcmIO::writer::DicomGlobalWriterManager );
namespace gdcmIO
{
namespace writer
{
//------------------------------------------------------------------------------
DicomGlobalWriterManager::DicomGlobalWriterManager():
::fwData::location::enableFolder< ::fwDataIO::writer::IObjectWriter >(this),
m_patientID(1)
{
SLM_TRACE_FUNC();
}
//------------------------------------------------------------------------------
DicomGlobalWriterManager::~DicomGlobalWriterManager()
{
SLM_TRACE_FUNC();
}
//------------------------------------------------------------------------------
void DicomGlobalWriterManager::write() throw(::fwTools::Failed)
{
::fwData::Patient::sptr patient = this->getConcreteObject();
SLM_ASSERT("fwData::Patient not instanced", patient);
// Initialization of common variables
::boost::shared_ptr< DicomInstance > dicomInstance = ::boost::shared_ptr< DicomInstance >( new DicomInstance );
DicomPatientWriter patientWriter; // Insert general patient module in a data set
DicomStudyWriter studyWriter; // Insert general study module in a data set
DicomSeriesWriter seriesWriter; // Insert general series module in a data set
::gdcm::DataSet gDsPatient, gDsStudy, gDsSeries;// Create data set in the view to copy it
std::string patientPath;
std::string studyPath; // Can be different with patientPath if there are more than one study
std::string seriesPath; // Can be different with studyPath if there are more than one series
unsigned int studyID = 1; // Use to make new study directory
unsigned int seriesID = 1; // Use to make new series directory and to set parameter of DicomSeriesWriter
bool makeNewStudyDir = false; // Flag to make new directory
bool makeNewSeriesDir = false;
//***** Handle patient *****//
patientWriter.setObject(patient);
// Make a new directory
patientPath = this->getFolder().string() + "/patient_" + ::fwTools::getString< unsigned int >(m_patientID);
::boost::filesystem::create_directory( patientPath );
this->setFolder( patientPath );
// Write patient data in a data set
patientWriter.write(gDsPatient);
//***** Handle studies *****//
studyPath = patientPath; // Copy of the parent folder path
if (patient->getNumberOfStudies() > 1)
{// If there are more than one study, one folder will be create for each study
makeNewStudyDir = true;
}
BOOST_FOREACH(::fwData::Study::sptr study, patient->getStudies())
{
// In order to avoid to remove all study information in data set (with patient + study data),
// we copy patient data set in the view to have a data set without study information.
gDsStudy = gDsPatient; // Copy of the parent data set
studyWriter.setObject( study );
// Make a new directory for each study
if (makeNewStudyDir)
{
studyPath = patientPath + "/study_" + ::fwTools::getString< unsigned int >(studyID++);
::boost::filesystem::create_directory( studyPath );
}
studyWriter.setDicomInstance( dicomInstance );
studyWriter.setStudyID(studyID++);
// Write study data in a data set
studyWriter.write(gDsStudy);
//***** Handle acquisitions *****//
seriesPath = studyPath; // Copy of the parent folder path
if (study->getNumberOfAcquisitions() > 1)
{
makeNewSeriesDir = true;
}
// FIXME : If the user duplicate an acquisition, both will be written with the same series UID in two different folders.
// This is an issue for document SR which must infers from one series. In this case, if each copy has comment
// (landmark, distance), two documents SR will be generated for the same series.
// In addition, SR reader will just read the first document SR.
BOOST_FOREACH(::fwData::Acquisition::sptr series, study->getAcquisitions())
{
::boost::shared_ptr< DicomInstance > dicomSerieInstance = ::boost::shared_ptr< DicomInstance >( new DicomInstance(*dicomInstance) );
gDsSeries = gDsStudy; // Copy of the parent data set
seriesWriter.setObject( series );
// Make a new directory for each series
if (makeNewSeriesDir)
{
seriesPath = studyPath + "/series_" + ::fwTools::getString< unsigned int >(seriesID);
::boost::filesystem::create_directory( seriesPath );
}
seriesWriter.setDicomInstance( dicomSerieInstance );
seriesWriter.setSeriesID(seriesID++);
// Write series data in a data set
seriesWriter.write(gDsSeries);
//***** Handle content of acquisition *****//
if (hasImage(series))
{
dicomSerieInstance->setIsMultiFrame( false ); // Define image writing policy
//***** Handle image content *****//
{
DicomImageWriterManager imageManager;
imageManager.setObject( series );
imageManager.setDicomInstance( dicomSerieInstance );
// Write an image from a data set which contains patient, study and series data.
// DICOM image file(s) will be written in seriesPath
imageManager.write(gDsSeries, seriesPath);
}
//***** Handle SR and RT content *****//
//NOTE : those contents depend on an image
if (hasDocumentSR(series))
{
DicomSRWriterManager docSRManager;
docSRManager.setObject( series->getImage() );
docSRManager.setDicomInstance( dicomSerieInstance );
try
{
docSRManager.write(gDsSeries, seriesPath);
}
catch(::fwTools::Failed & e)
{
OSLM_ERROR(e.what());
}
}
if (hasDocumentRT(series))
{
DicomRTWriterManager docRTManager;
docRTManager.setObject( series );
docRTManager.setDicomInstance( dicomSerieInstance );
try
{
docRTManager.write(gDsSeries, seriesPath);
}
catch(::fwTools::Failed & e)
{
OSLM_ERROR(e.what());
}
}
}
else
{
throw ::fwTools::Failed("Nothing to save");
}
}
}
}
//------------------------------------------------------------------------------
bool DicomGlobalWriterManager::hasImage( ::fwData::Acquisition::csptr a_series ) const
{
return ( (a_series->getImage() != 0) ? true : false );
}
//------------------------------------------------------------------------------
bool DicomGlobalWriterManager::hasDocumentSR( ::fwData::Acquisition::csptr a_series ) const
{
fwData::Image::csptr image = a_series->getImage();
assert(image != 0);
::fwData::PointList::sptr pl;
pl = image->getField< ::fwData::PointList >( fwComEd::Dictionary::m_imageLandmarksId );
// Check if image has landmark and distance
return ( (pl && pl->getPoints().size() > 0)
|| image->getField( fwComEd::Dictionary::m_imageDistancesId ) );
}
//------------------------------------------------------------------------------
bool DicomGlobalWriterManager::hasDocumentRT( ::fwData::Acquisition::csptr a_series ) const
{
// Check number of reconstruction
return (a_series->getNumberOfReconstructions() > 0);
}
//------------------------------------------------------------------------------
std::string DicomGlobalWriterManager::extension()
{
return std::string("");
};
//------------------------------------------------------------------------------
void DicomGlobalWriterManager::setPatientID(const unsigned int a_id)
{
m_patientID = a_id;
}
} // namespace writer
} // namespace gdcmIO
|
#pragma once
#include"Behaviour.h"
#include"Agent.h"
class EvadeBehaviour : public Behaviour
{
public:
EvadeBehaviour();
virtual ~EvadeBehaviour();
virtual vector2 Update(Agent* agent, float deltaTime);
virtual float GetWeight() { return weight; };
void SetTarget(Agent* agent) { m_target = agent; }
private:
Agent* m_target;
float fleeSpeed = 40;
float weight = 2;
};
|
/**
* A Lpf2Hub basic example to connect a hub, set the led color and the name of the hub
*
* (c) Copyright 2019 - Cornelius Munz
* Released under MIT License
*
*/
#include "Lpf2Hub.h"
#define GREEN_LED_PIN 13
#define RED_LED_PIN 12
// create a hub instance
Lpf2Hub myHub;
bool isLedOn=false;
void buttonNotification(bool isPressed) {
if (isPressed) {
if (isLedOn) {
digitalWrite(GREEN_LED_PIN, LOW);
isLedOn=false;
} else {
digitalWrite(GREEN_LED_PIN, HIGH);
isLedOn=true;
}
}
}
void setup() {
pinMode(GREEN_LED_PIN, OUTPUT);
pinMode(RED_LED_PIN, OUTPUT);
Serial.begin(115200);
myHub.init(); // initalize the lpf2hub instance
myHub.registerButtonCallback(buttonNotification);
}
// main loop
void loop() {
// connect flow. Search for BLE services and try to connect if the uuid of the hub is found
if (myHub.isConnecting()) {
myHub.connectHub();
if (myHub.isConnected()) {
Serial.println("Connected to HUB");
} else {
Serial.println("Failed to connect to HUB");
}
}
// if connected, you can set the name of the hub, the led color and shut it down
if (myHub.isConnected()) {
char hubName[] = "myLpf2Hub";
myHub.setHubName(hubName);
myHub.setLedColor(GREEN);
delay(1000);
myHub.setLedColor(RED);
delay(5000);
myHub.shutDownHub();
}
} // End of loop
|
// Wire Slave Receiver
// by Nicholas Zambetti <http://www.zambetti.com>
// Demonstrates use of the Wire library
// Receives data as an I2C/TWI slave device
// Refer to the "Wire Master Writer" example for use with this
// Created 29 March 2006
// This example code is in the public domain.
#include <Wire.h>
int lastCommand = 0;
String lastCoord = "";
void setup()
{
Wire.begin(4); // join i2c bus with address #4
Wire.onReceive(receiveEvent); // register event
Wire.onRequest(requestEvent);
Serial.begin(9600); // start serial for output
Serial.print("* * * READY * * * \n");
}
void loop()
{
delay(100);
}
void receiveEvent(int byteCount){
int number = 0;
int state = 0;
//Serial.print(byteCount);
if(byteCount == 1){
while(Wire.available()) {
number = Wire.read();
if(number == 1){
Serial.print("POWER ON \n");
lastCommand = number;
}
if(number == 2){
Serial.print("POWER OFF \n");
lastCommand = number;
}
if(number == 3){
Serial.print("COORDINATE RECEIVED \n");
lastCommand = number;
}
}
}
if(byteCount > 20){
while (1 < Wire.available()) { // loop through all but the last
int c = Wire.read(); // receive byte as a character
lastCoord += c;
//Serial.print(c); // print the character
}
int x = Wire.read(); // receive byte as an integer
lastCoord += x;
if(lastCoord
Serial.print(lastCoord);
Serial.print("\n");
lastCommand = 3;
}
}
void requestEvent(){
switch (lastCommand) {
case 1:
Wire.write("Starting up.... ");
break;
case 2:
Wire.write("Shutting down...");
break;
case 3:
Wire.write("Coord. received!");
break;
default:
Serial.print(lastCommand);
Serial.print("\n");
Wire.write("READY ");
break;
}
}
|
/**
* Copyright (c) 2015, Timothy Stack
*
* 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 Timothy Stack 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 REGENTS 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 REGENTS 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.
*
* @file shlex.resolver.hh
*/
#ifndef lnav_shlex_resolver_hh
#define lnav_shlex_resolver_hh
#include <map>
#include <string>
#include <vector>
#include "base/intern_string.hh"
#include "base/types.hh"
#include "fmt/format.h"
#include "mapbox/variant.hpp"
using scoped_value_t = mapbox::util::
variant<std::string, string_fragment, int64_t, double, null_value_t>;
namespace fmt {
template<>
struct formatter<scoped_value_t> : formatter<std::string> {
template<typename FormatContext>
auto format(const scoped_value_t& sv, FormatContext& ctx) const
{
auto retval
= sv.match([](std::string str) { return str; },
[](string_fragment sf) { return sf.to_string(); },
[](null_value_t) { return std::string("<NULL>"); },
[](int64_t value) { return fmt::to_string(value); },
[](double value) { return fmt::to_string(value); });
return fmt::formatter<std::string>::format(retval, ctx);
}
};
} // namespace fmt
class scoped_resolver {
public:
scoped_resolver(
std::initializer_list<const std::map<std::string, scoped_value_t>*> l)
{
this->sr_stack.insert(this->sr_stack.end(), l.begin(), l.end());
}
using const_iterator
= std::map<std::string, scoped_value_t>::const_iterator;
const_iterator find(const std::string& str) const
{
const_iterator retval;
for (const auto* scope : this->sr_stack) {
if ((retval = scope->find(str)) != scope->end()) {
return retval;
}
}
return this->end();
}
const_iterator end() const { return this->sr_stack.back()->end(); }
std::vector<const std::map<std::string, scoped_value_t>*> sr_stack;
};
#endif
|
/***************************************************************************
* Copyright (c) 2021, Thorsten Beier * *
* Copyright (c) 2021, QuantStack *
* *
* Distributed under the terms of the BSD 3-Clause License. *
* *
* The full license is in the file LICENSE, distributed with this software. *
****************************************************************************/
#include "sol/sol.hpp"
#include <iostream>
namespace xlua
{
void add_ilua_module(sol::state_view & lua){
std::string script = R""""(
ilua = {
display = { _version = "0.1.0" ,
detail = {}
},
widgets = {
detail = {}
},
canvas = {
color = {},
detail = {}
},
config = {
printer = "pprint",
auto_print = true
},
detail = {},
json = {
detail = {}
},
time = {
detail = {}
}
}
)"""";
sol::protected_function_result code_result = lua.safe_script(script, &sol::script_pass_on_error);
if (!code_result.valid()) {
sol::error err = code_result;
std::cerr << "failed to load string-based script into the program for xextend" << err.what() << std::endl;
throw std::runtime_error(err.what());
}
}
void extend(sol::state_view & lua)
{
add_ilua_module(lua);
}
}
|
//
// Persona.cpp
// Tarea5Ejercicio4
//
// Created by Daniel on 13/11/14.
// Copyright (c) 2014 Gotomo. All rights reserved.
//
#include "Persona.h"
Persona::Persona(){
nombre =apellidoM = apellidoP = sexo = "vacio";
edad = fechaFallecido = 0;
muerto = true;
}
Persona::Persona(int i){
std::cout<<"Nombre: ";
std::cin>>nombre;
std::cout<<"Apellido Paterno: ";
std::cin>>apellidoP;
std::cout<<"Apellido Materno: ";
std::cin>>apellidoM;
std::cout<<"Sexo: ";
std::cin>>sexo;
std::cout<<"Edad: ";
std::cin>>edad;
fechaFallecido = NULL;
muerto = false;
}
void Persona::Matar(){
std::cout<<"Fecha de muerte: ";
std::cin>>fechaFallecido;
muerto = true;
}
void Persona::imprimir(){
std::cout<< nombre << " " << apellidoP << " " << apellidoM << std::endl;
std::cout<< "Edad: " << edad << "Sexo: " << sexo;
if (muerto) {
std::cout<<"Fallecido en: " << fechaFallecido<<std::endl;
}
std::cout<<std::endl;
}
int Persona::getFechaF(){
return fechaFallecido;
}
std::string& Persona::getNombre(){
return nombre;
}
std::string& Persona::getApellidoP(){
return apellidoP;
}
std::string& Persona::getApellidoM(){
return apellidoM;
}
bool Persona::getMuerto(){
return muerto;
}
bool Persona::operator<(int ano){
return (fechaFallecido != 0 && fechaFallecido < ano);
}
bool Persona::operator ==(Persona & p){
if (p.nombre == nombre && p.apellidoP == apellidoP && p.apellidoM == apellidoM) {
return true;
}
return false;
}
std::ostream & operator <<(std::ostream & os, Persona & p){
if(p.muerto){
os << "+ ";
}
os << p.nombre << " " << p.apellidoP[0] << ". " << p.apellidoM[0] << ".";
return os;
}
|
#pragma once
#include "proto/processor.hpp"
#include "proto/ss_base.pb.h"
#include "net/client.hpp"
#include "net/conn.hpp"
namespace ps = proto::ss;
namespace nora {
template <typename T, typename U = net::CONN>
class server_process : public proto::processor<server_process<T, U>, ps::base>,
public enable_shared_from_this<server_process<T, U>> {
public:
server_process(const shared_ptr<service_thread>& st, const shared_ptr<net::client<U>>& ncl, const shared_ptr<U>& c) :
st_(st), ncl_(ncl), conn_(c) {
server_process_ = make_shared<T>(conn_->name());
}
static void static_init() {
server_process::register_proto_handler(ps::s2s_register_rsp::descriptor(), &server_process<T, U>::process_register_rsp);
T::static_init();
}
void process_msg(const shared_ptr<net::recvstream>& msg) {
st_->async_call(
[this, self = this->shared_from_this(), msg] {
ps::base ss_msg;
ASSERT(ss_msg.ParseFromIstream(msg.get()));
TLOG << *this << " process msg\n" << ss_msg.DebugString();
if (this->has_handler(this, &ss_msg)) {
this->process(this, &ss_msg);
} else {
server_process_->process(server_process_.get(), &ss_msg);
}
});
}
void stop() {
st_->async_call(
[this, self = this->shared_from_this()] {
if (stop_cb_ && conn_) {
stop_cb_(conn_, this->shared_from_this());
}
if (ncl_ && conn_) {
ncl_->disconnect(conn_);
conn_.reset();
ncl_.reset();
}
stop_cb_ = nullptr;
register_done_cb_ = nullptr;
});
}
void send_msg(const ps::base& msg) {
ASSERT(st_);
st_->async_call(
[this, self = this->shared_from_this(), msg] {
TLOG << *this << " send " << msg.DebugString();
auto ss = make_shared<net::sendstream>();
msg.SerializeToOstream(ss.get());
ncl_->send(conn_, ss);
});
}
friend ostream& operator<<(ostream& os, const server_process<T, U>& cp) {
return os << *cp.server_process_;
}
int id() const {
ASSERT(server_process_);
return server_process_->id();
}
const shared_ptr<U> conn() const {
ASSERT(conn_);
return conn_;
}
function<void()> register_done_cb_;
function<void(const shared_ptr<U>&, const shared_ptr<server_process<T, U>>&)> stop_cb_;
private:
void process_register_rsp(const ps::base *msg) {
ASSERT(st_->check_in_thread());
ILOG << *this << " register done";
const auto& rsp = msg->GetExtension(ps::s2s_register_rsp::srr);
server_process_->set_id(rsp.id());
ASSERT(register_done_cb_);
register_done_cb_();
server_process_->on_register_done();
}
shared_ptr<service_thread> st_;
shared_ptr<net::client<U>> ncl_;
shared_ptr<U> conn_;
shared_ptr<T> server_process_;
};
}
|
// Copyright 1998-2014 Epic Games, Inc. All Rights Reserved.
#include "FPSpaceInvaders.h"
#include "FPSpaceInvadersGameMode.h"
#include "FPSpaceInvadersHUD.h"
AFPSpaceInvadersGameMode::AFPSpaceInvadersGameMode(const class FPostConstructInitializeProperties& PCIP)
: Super(PCIP)
{
// set default pawn class to our Blueprinted character
static ConstructorHelpers::FObjectFinder<UBlueprint> PlayerPawnObject(TEXT("/Game/Blueprints/MyCharacter"));
if (PlayerPawnObject.Object != NULL)
{
DefaultPawnClass = (UClass*)PlayerPawnObject.Object->GeneratedClass;
}
// use our custom HUD class
HUDClass = AFPSpaceInvadersHUD::StaticClass();
}
|
//
// Bench_CIFAR100.hpp
// GA
//
// Created by Tom den Ottelander on 29/01/2020.
// Copyright © 2020 Tom den Ottelander. All rights reserved.
//
#ifndef Bench_CIFAR100_hpp
#define Bench_CIFAR100_hpp
#include <stdio.h>
#include "Bench_CIFAR_base.hpp"
#include <algorithm>
class Bench_CIFAR100 : public Bench_CIFAR_base {
public:
Bench_CIFAR100(int problemSize, bool genotypeChecking, bool MO = false);
bool MO = false;
// For normalizing the MMACs objective
float minMMACs = 21.54;
float maxMMACs = 239.51;
std::vector<float> evaluate (Individual &ind) override;
std::vector<float> getFitness (std::vector<int> encoding) override;
void display() override;
std::string id() override;
FitnessFunction* clone() const override;
ProblemType* getProblemType();
};
#endif /* Bench_CIFAR100_hpp */
|
/*
* To change this license header, choose License Headers in Project Properties.
* To change this template file, choose Tools | Templates
* and open the template in the editor.
*/
/*
* File: Config.cpp
* Author: frankiezafe
*
* Created on June 12, 2016, 11:18 PM
*/
#include "Config.h"
static Config * _config = nullptr;
Config * Config::get() {
if ( _config == nullptr ) {
_config = new Config();
}
return _config;
}
Config::Config( ) {
name = "undefined";
names_filter = "";
verbose = false;
enable_osc = true;
broadcast_port = 20000;
osc_port = 23000;
heartbeat_millis = 5000;
max_delay_millis = 20000;
cam_width = 160;
cam_height = 120;
threshold = 85;
}
Config::~Config( ) {
}
|
#include <ros/ros.h>
#include <laser_assembler/AssembleScans2.h>
#include <pcl/PCLPointCloud2.h>
#include <pcl/common/common.h>
#include <pcl/common/io.h>
#include <pcl/point_cloud.h>
#include <pcl/point_types.h>
#include <pcl_conversions/pcl_conversions.h>
#include <pcl_ros/point_cloud.h>
#include <sensor_msgs/PointCloud2.h>
//-----------------
#include <math.h>
#include <algorithm> // std::max
#include <cmath>
#include <fstream>
#include <iostream>
//---------------------
using namespace laser_assembler;
// using namespace pcl;
class CloudAssemb
{
public:
// publicadores
CloudAssemb();
// int writeCount;
pcl::PointCloud<pcl::PointXYZ> RoadRec, acum_cloud;
// Filter the cloud based on recieved data
void loop_function();
private:
ros::NodeHandle nh_;
ros::Publisher pub_cloudAcum;
pcl::PointCloud<pcl::PointXYZ> CloudXYZ_LD0, CloudXYZ_LD1, CloudXYZ_LD2, CloudXYZ_LD3;
sensor_msgs::PointCloud2 CloudMsg_Acum;
pcl::PointCloud<pcl::PointXYZ> Inter1, Inter2;
void getCloudsFromSensors();
};
CloudAssemb::CloudAssemb()
{
pub_cloudAcum = nh_.advertise<sensor_msgs::PointCloud2>("Cloud_Acum", 100);
}
void CloudAssemb::loop_function()
{
getCloudsFromSensors();
pcl::toROSMsg(RoadRec, CloudMsg_Acum);
pub_cloudAcum.publish(CloudMsg_Acum);
}
void CloudAssemb::getCloudsFromSensors()
{
//----------Assemble_0-------------------------------------
ros::service::waitForService("assemble_scans0");
ros::ServiceClient client_0 = nh_.serviceClient<AssembleScans2>("assemble_scans0");
AssembleScans2 srv_0;
srv_0.request.begin = ros::Time(0, 0);
srv_0.request.end = ros::Time::now();
if (client_0.call(srv_0))
{
// pub_cloud0.publish(srv.response.cloud);
pcl::fromROSMsg(srv_0.response.cloud, CloudXYZ_LD0);
}
else
{
printf("Service call failed\n");
}
//----------Assemble_1-------------------------------------
ros::service::waitForService("assemble_scans1");
ros::ServiceClient client_1 = nh_.serviceClient<AssembleScans2>("assemble_scans1");
AssembleScans2 srv_1;
srv_1.request.begin = ros::Time(0, 0);
srv_1.request.end = ros::Time::now();
if (client_1.call(srv_1))
{
// pub_cloud0.publish(srv.response.cloud);
pcl::fromROSMsg(srv_1.response.cloud, CloudXYZ_LD1);
}
else
{
printf("Service call failed\n");
}
//----------Assemble_2-------------------------------------
ros::service::waitForService("assemble_scans2_");
ros::ServiceClient client_2 = nh_.serviceClient<AssembleScans2>("assemble_scans2_");
AssembleScans2 srv_2;
srv_2.request.begin = ros::Time(0, 0);
srv_2.request.end = ros::Time::now();
if (client_2.call(srv_2))
{
// pub_cloud0.publish(srv_2.response.cloud);
pcl::fromROSMsg(srv_2.response.cloud, CloudXYZ_LD2);
}
else
{
printf("Service call failed\n");
}
//----------Assemble_3-------------------------------------
ros::service::waitForService("assemble_scans3");
ros::ServiceClient client_3 = nh_.serviceClient<AssembleScans2>("assemble_scans3");
AssembleScans2 srv_3;
srv_3.request.begin = ros::Time(0, 0);
srv_3.request.end = ros::Time::now();
if (client_3.call(srv_3))
{
// pub_cloud3.publish(srv3.response.cloud);
pcl::fromROSMsg(srv_3.response.cloud, CloudXYZ_LD3);
}
else
printf("Service call failed\n");
//------------------Assemble all an publish---------------
Inter1 = CloudXYZ_LD0 + CloudXYZ_LD1; // 1-2 | first 2
Inter2 = CloudXYZ_LD2 + CloudXYZ_LD3; // 3-4 | last 2
RoadRec = Inter1 + Inter2; // all clouds
// pcl::PointXYZ minPt, maxPt;
// pcl::getMinMax3D(Inter1, minPt, maxPt);
// // ROS_INFO("Minim:%f Maxim:%f", minPt.z, maxPt.z);
// /*trying to set total cloud*/
// if (acum_cloud.points.size() == 0)
// {
// acum_cloud = RoadRec;
// }
// else
// {
// acum_cloud = acum_cloud + RoadRec;
// }
}
int main(int argc, char **argv)
{
ros::init(argc, argv, "CloudAssemb");
CloudAssemb reconstruct;
ros::Rate rate(50);
while (ros::ok())
{
reconstruct.loop_function();
ros::spinOnce();
rate.sleep();
}
// if ((acum_cloud.points.size() != 0))
// {
// writeCount++;
// char filename[100];
// sprintf(filename, "/media/daniela/Dados/pcd_files/test_%d.pcd", writeCount);
// // pcl::io::savePCDFileASCII(filename, acum_cloud);
// // pcl::io::savePCDFile("thisisatest.pcd", acum_cloud, true);
// // ROS_INFO("Saved %lu points in point cloud", acum_cloud.points.size());
// }
return 0;
}
|
#include "opencv2/opencv.hpp"
#include <iostream>
#include <fstream>
using namespace std;
using namespace cv;
int main(int argc, char** argv){
VideoCapture cap("video0.avi");
if(!cap.isOpened()){
cout << "Cannot open the camera!" << endl;
return -1;
}
Mat frame;
while(true){
cap >> frame;
if(frame.rows > 0){
cout << "processing" << endl;
Scalar mean = cv::mean(frame);
ofstream myfile;
myfile.open ("meanbrightlevel.csv", ios::app);
myfile << mean[0] << "," << mean[1] << "," << mean[2] << std::endl;
myfile.close();
}else{
cout << "stoped" << endl;
break;
}
}
}
|
//-------------------------------------------------------------------------------------------------------
// Copyright (C) Microsoft. All rights reserved.
// Licensed under the MIT license. See LICENSE.txt file in the project root for full license information.
//-------------------------------------------------------------------------------------------------------
#if 0
//-------------------------------------------------------------------------------------------------------
// Copyright (C) Microsoft. All rights reserved.
// Licensed under the MIT license. See LICENSE.txt file in the project root for full license information.
//-------------------------------------------------------------------------------------------------------
"use strict";
// Core intl lib
(function (EngineInterface, InitType) {
var platform = EngineInterface.Intl;
// allow unit tests to disable caching behavior for testing convenience but have this always `true` in real scenarios
platform.useCaches = true;
if (platform.localeLookupCache === undefined) {
platform.localeLookupCache = new platform.Map();
}
if (platform.localeBestFitCache === undefined) {
platform.localeBestFitCache = new platform.Map();
}
// determine what backing library we are using
// making these vars in JS allows us to more change how we
// determine the backing library
let isPlatformUsingICU = !platform.winglob;
let isPlatformUsingWinGlob = platform.winglob;
// constants
const NOT_FOUND = "NOT_FOUND";
// Built-Ins
var setPrototype = platform.builtInSetPrototype;
var getArrayLength = platform.builtInGetArrayLength;
var callInstanceFunc = platform.builtInCallInstanceFunction;
var Boolean = platform.Boolean;
var Object = platform.Object;
var RegExp = platform.RegExp;
var Number = platform.Number;
var String = platform.String;
var Date = platform.Date;
var Error = platform.Error;
var Map = platform.Map;
var RaiseAssert = platform.raiseAssert;
var Math = setPrototype({
abs: platform.builtInMathAbs,
floor: platform.builtInMathFloor,
max: platform.builtInMathMax,
pow: platform.builtInMathPow
}, null);
var ObjectGetPrototypeOf = platform.builtInJavascriptObjectEntryGetPrototypeOf;
var ObjectIsExtensible = platform.builtInJavascriptObjectEntryIsExtensible;
var ObjectGetOwnPropertyNames = platform.builtInJavascriptObjectEntryGetOwnPropertyNames;
var ObjectInstanceHasOwnProperty = platform.builtInJavascriptObjectEntryHasOwnProperty;
// Because we don't keep track of the attributes object, and neither does the internals of Object.defineProperty;
// We don't need to restore it's prototype.
var _objectDefineProperty = platform.builtInJavascriptObjectEntryDefineProperty;
var ObjectDefineProperty = function (obj, prop, attributes) {
_objectDefineProperty(obj, prop, setPrototype(attributes, null));
};
var ArrayInstanceForEach = platform.builtInJavascriptArrayEntryForEach;
var ArrayInstanceIndexOf = platform.builtInJavascriptArrayEntryIndexOf;
var ArrayInstancePush = platform.builtInJavascriptArrayEntryPush;
var ArrayInstanceJoin = platform.builtInJavascriptArrayEntryJoin;
var FunctionInstanceBind = platform.builtInJavascriptFunctionEntryBind;
var DateInstanceGetDate = platform.builtInJavascriptDateEntryGetDate;
var DateNow = platform.builtInJavascriptDateEntryNow;
var StringInstanceReplace = platform.builtInJavascriptStringEntryReplace;
var StringInstanceToLowerCase = platform.builtInJavascriptStringEntryToLowerCase;
var StringInstanceToUpperCase = platform.builtInJavascriptStringEntryToUpperCase;
var ObjectPrototype = ObjectGetPrototypeOf({});
var isFinite = platform.builtInGlobalObjectEntryIsFinite;
var isNaN = platform.builtInGlobalObjectEntryIsNaN;
let __defaultLocale = undefined;
const GetDefaultLocale = function () {
if (__defaultLocale && platform.useCaches) {
return __defaultLocale;
}
const locale = platform.getDefaultLocale();
if (!locale) {
// if the system locale is undefined/null/empty string, we have to
// do something or else we will crash
__defaultLocale = "en";
} else {
__defaultLocale = locale;
}
return __defaultLocale;
};
let CreateDateTimeFormat = function (dateTimeFormat, condition) {
let retVal = platform.createDateTimeFormat(dateTimeFormat, condition);
if (retVal === null) {
// TODO (doilij): remove this fallback when implemented under ICU
dateTimeFormat.__numberingSystem = "";
dateTimeFormat.__patternStrings = [
"{month.a}{day.b}{hour.c}{minute.d}{second.e}",
"" // another entry for fun
]
}
// no return value
};
let IsWellFormedLanguageTag = function (langTag) {
let retVal = platform.isWellFormedLanguageTag(langTag);
if (retVal === null) {
if (!LANG_TAG_RE) {
InitializeLangTagREs();
}
let match = platform.builtInRegexMatch(langTag, LANG_TAG_RE);
return !!match;
} else {
return retVal;
}
};
var forEachIfPresent = function (obj, length, func) {
let current = 0;
while (current < length) {
if (current in obj) {
func(obj[current]);
}
current++;
}
};
// A helper function that is meant to rethrow SOE and OOM exceptions allowing them to propagate.
var throwExIfOOMOrSOE = function (ex) {
if (ex.number === -2146828260 || ex.number === -2146828281) {
throw ex;
}
};
var tagPublicFunction = function (name, f) {
return platform.tagPublicLibraryCode(f, name);
};
var resolveLocaleBestFit = function (locale, defaultLocale) {
var resolvedLocale = platform.localeBestFitCache.get(locale);
if (resolvedLocale === undefined) {
resolvedLocale = platform.resolveLocaleBestFit(locale);
if (resolvedLocale === null) {
if (!LANG_TAG_BASE_RE) {
InitializeLangTagREs();
}
let match = platform.builtInRegexMatch(locale, LANG_TAG_BASE_RE);
resolvedLocale = match[1] + (match[2] ? ('-' + match[2]) : '') + (match[3] ? ('-' + match[3]) : '');
}
// If resolvedLocale is undefined, cache that we got undefined
// so we don't try to resolve for `locale` in future.
platform.localeBestFitCache.set(locale, resolvedLocale === undefined ? NOT_FOUND : resolvedLocale);
} else if (resolvedLocale === NOT_FOUND) {
resolvedLocale = undefined;
}
if (defaultLocale === locale) {
return resolvedLocale;
} else if (defaultLocale === resolvedLocale) {
return undefined;
} else {
return resolvedLocale;
}
}
var resolveLocaleLookup = function (localeWithoutSubtags) {
let resolvedLocale = platform.localeLookupCache.get(localeWithoutSubtags);
if (resolvedLocale === undefined) {
resolvedLocale = platform.resolveLocaleLookup(localeWithoutSubtags);
if (resolvedLocale === null) {
if (!LANG_TAG_BASE_RE) {
InitializeLangTagREs();
}
let match = platform.builtInRegexMatch(localeWithoutSubtags, LANG_TAG_BASE_RE);
// match: [1] language; [2] script; [3] region (e.g. en-Latn-US)
resolvedLocale = match[1]
+ (match[2] ? ('-' + match[2]) : '')
+ (match[3] ? ('-' + match[3]) : '');
}
// If resolvedLocale is undefined, cache that we got undefined
// so we don't try to resolve for `locale` in future.
platform.localeLookupCache.set(localeWithoutSubtags, resolvedLocale === undefined ? NOT_FOUND : resolvedLocale);
} else if (resolvedLocale === NOT_FOUND) {
resolvedLocale = undefined;
}
return resolvedLocale;
}
var getExtensionSubtags = function (locale) {
if (!LANG_TAG_EXT_RE) {
InitializeLangTagREs();
}
const match = platform.builtInRegexMatch(locale, LANG_TAG_EXT_RE);
if (!match) {
return undefined;
}
// Note: extensions are /((${extension})-)*/ and are made up of \\b(?:${singleton}(?:-${alphanum}{2,8})+)\\b
// where the ${alphanum}{2,8} fields are of the form `${key}-${value}`.
// TODO (doilij): return an array of `${key}-${value}` pairs
// REVIEW (doilij): leading - might mean we need to filter: // ss.match(rr)[4].split('-').filter((x)=>!!x)
// In that case:
// TODO StringInstanceSplit
// TODO ArrayInstanceFilter
// let extSubtags = ArrayInstanceFilter(extensionsString.split('-'), (x)=>!!x);
const extSubtags = match[0].split('-').filter((x) => !!x);
// REVIEW (doilij): performance (testing for str[0]==='-' and using the string after that or updating the regex might be faster)
return extSubtags;
}
var resolveLocaleHelper = function (locale, fitter, extensionFilter, defaultLocale) {
var subTags = platform.getExtensions(locale);
if (subTags === null) {
// platform.getExtensions returns null to indicate fallback to JS implementation
subTags = getExtensionSubtags(locale);
}
if (subTags) {
callInstanceFunc(ArrayInstanceForEach, subTags, function (subTag) {
locale = callInstanceFunc(StringInstanceReplace, locale, "-" + subTag, "");
});
}
// Instead of using replace, we will match two groups, one capturing, one not. The non capturing group just strips away -u if present.
// We are substituting for the function replace; which will only make a change if /-u$/ was found (-u at the end of the line)
// And because match will return null if we don't match entire sequence, we are using the two groups stated above.
locale = platform.builtInRegexMatch(locale, /(.*?)(?:-u)?$/)[1];
var resolved = fitter(locale, defaultLocale);
if (extensionFilter !== undefined) { // Filter to expected sub-tags
var filtered = [];
callInstanceFunc(ArrayInstanceForEach, subTags, (function (subTag) {
var parts = platform.builtInRegexMatch(subTag, /([^-]*)-?(.*)?/); // [0] entire thing; [1] key; [2] value
var key = parts[1];
if (callInstanceFunc(ArrayInstanceIndexOf, extensionFilter, key) !== -1) {
callInstanceFunc(ArrayInstancePush, filtered, subTag);
}
}));
subTags = filtered;
}
// As long as we are using the JS version of getExtensions on ICU, "u" will be considered an extension
// of a locale like "de-u-co-phonebk"
// Thus, we can't add the -u- ourselves here
const withoutSubTags = resolved;
if (resolved) {
if (subTags && getArrayLength(subTags) > 0) {
if (isPlatformUsingICU) {
resolved += "-";
} else {
resolved += "-u-";
}
}
resolved += callInstanceFunc(ArrayInstanceJoin, subTags, "-");
} else {
resolved = undefined;
}
return setPrototype({
locale: resolved,
subTags: subTags,
localeWithoutSubtags: withoutSubTags
}, null);
}
var resolveLocales = function (givenLocales, matcher, extensionFilter, defaultLocaleFunc) {
var fitter = matcher === "lookup" ? resolveLocaleLookup : resolveLocaleBestFit;
var length = getArrayLength(givenLocales);
var defaultLocale = defaultLocaleFunc();
length = length !== undefined ? length : 0;
for (var i = 0; i < length; i++) {
var resolved = resolveLocaleHelper(givenLocales[i], fitter, extensionFilter, defaultLocale);
if (resolved.locale !== undefined) {
return resolved;
}
}
return resolveLocaleHelper(defaultLocale, fitter, undefined, defaultLocale);
}
// get just the language-script-region from the default locale
let __strippedDefaultLocale = undefined;
var strippedDefaultLocale = function () {
if (__strippedDefaultLocale) {
return __strippedDefaultLocale;
}
if (isPlatformUsingICU) {
if (!LANG_TAG_BASE_RE) {
InitializeLangTagREs();
}
const def = GetDefaultLocale();
const match = platform.builtInRegexMatch(def, LANG_TAG_BASE_RE);
if (match) {
// strip extensions by matching only the base
__strippedDefaultLocale = match[0];
} else {
__strippedDefaultLocale = def;
}
} else {
// the only thing to strip off of a WinGlob locale is the collation,
// which comes after the underscore
__strippedDefaultLocale = platform.builtInRegexMatch(GetDefaultLocale(), /([^_]*).*/)[1];
}
return __strippedDefaultLocale;
};
var Internal = (function () {
return setPrototype({
ToObject: function (o) {
if (o === null) {
platform.raiseNeedObject();
}
return o !== undefined ? Object(o) : undefined;
},
ToString: function (s) {
return s !== undefined ? String(s) : undefined;
},
ToNumber: function (n) {
return n === undefined ? NaN : Number(n);
},
ToLogicalBoolean: function (v) {
return v !== undefined ? Boolean(v) : undefined;
},
ToUint32: function (n) {
var num = Number(n),
ret = 0;
if (!isNaN(num) && isFinite(num)) {
ret = Math.abs(num % Math.pow(2, 32));
}
return ret;
},
HasProperty: function (o, p) {
// Walk the prototype chain
while (o) {
if (callInstanceFunc(ObjectInstanceHasOwnProperty, o, p)) {
return true;
}
o = ObjectGetPrototypeOf(o);
}
}
}, null)
})();
// Internal ops implemented in JS:
function GetOption(options, property, type, values, fallback) {
let value = options[property];
if (value !== undefined) {
if (type == "boolean") {
value = Internal.ToLogicalBoolean(value);
}
if (type == "string") {
value = Internal.ToString(value);
}
if (type == "number") {
value = Internal.ToNumber(value);
}
if (values !== undefined && callInstanceFunc(ArrayInstanceIndexOf, values, value) == -1) {
platform.raiseOptionValueOutOfRange_3(String(value), String(property), "['" + callInstanceFunc(ArrayInstanceJoin, values, "', '") + "']");
}
return value;
}
return fallback;
}
function GetNumberOption(options, property, minimum, maximum, fallback) {
const rawValue = options[property];
if (typeof rawValue !== 'undefined') {
const formattedValue = Internal.ToNumber(rawValue);
if (isNaN(formattedValue) || formattedValue < minimum || formattedValue > maximum) {
platform.raiseOptionValueOutOfRange_3(String(rawValue), String(property), "[" + minimum + " - " + maximum + "]");
}
return Math.floor(formattedValue);
} else {
return fallback;
}
}
let CURRENCY_CODE_RE;
function InitializeCurrencyRegExp() {
CURRENCY_CODE_RE = /^[A-Z]{3}$/i;
}
let LANG_TAG_BASE_RE; // language[-script[-region]]
let LANG_TAG_EXT_RE; // extension part (variant, extension, privateuse)
let LANG_TAG_RE; // full syntax of language tags (including privateuse and grandfathered)
function InitializeLangTagREs() {
// Language Tag Syntax as described in RFC 5646 #section-2.1
// Note: All language tags are comprised only of ASCII characters (makes our job easy here)
// Note: Language tags in canonical form have case conventions, but language tags are case-insensitive for our purposes
// Note: The ABNF syntax used in RFC 5646 #section-2.1 uses the following numeric quantifier conventions:
// - (Parentheses) are used for grouping
// - PRODUCTION => exactly 1 of PRODUCTION /PRODUCTION/
// - [PRODUCTION] => 0 or 1 of PRODUCTION /(PRODUCTION)?/
// - #PRODUCTION => exactly # of PRODUCTION /(PRODUCTION){#}/
// - a*bPRODUCTION (where a and b are optional)
// - *PRODUCTION => any number of PRODUCTION /(PRODUCTION)*/
// - 1*PRODUCTION => 1 or more of PRODUCTION /(PRODUCTION)+/
// - #*PRODUCTION => # or more of PRODUCTION /(PRODUCTION){#,}/
// - *#PRODUCTION => 0 to # (inclusive) of PRODUCTION /(PRODUCTION){,#}/ or /(PRODUCTION){0,#}/
// - a*bPRODUCTION => a to b (inclusive) of PRODUCTION /(PRODUCTION){a,b}/
const ALPHA = "[A-Z]";
const DIGIT = "[0-9]";
const alphanum = `(?:${ALPHA}|${DIGIT})`;
const regular = "\\b(?:art-lojban|cel-gaulish|no-bok|no-nyn|zh-guoyu|zh-hakka|zh-min|zh-min-nan|zh-xiang)\\b";
const irregular = "\\b(?:en-GB-oed|i-ami|i-bnn|i-default|i-enochian|i-hak|i-klingon|i-lux|i-mingo" +
"|i-navajo|i-pwn|i-tao|i-tay|i-tsu|sgn-BE-FR|sgn-BE-NL|sgn-CH-DE)\\b";
const grandfathered = `\\b(?:${regular}|${irregular})\\b`;
const privateuse = `\\b(?:x(?:-${alphanum}{1,8}\\b)+)\\b`; // privateuse = "x" 1*("-" (1*8alphanum))
const singleton = `\\b(?:${DIGIT}|[A-WY-Z])\\b`; // singleton ~= alphanum except for 'x' ; (paraphrased)
const extension = `\\b(?:${singleton}(?:-${alphanum}{2,8})+)\\b`; // extension = singleton 1*("-" (2*8alphanum))
const variant = `\\b(?:${alphanum}{5,8}|${DIGIT}${alphanum}{3})\\b`; // variant = 5*8alphanum / (DIGIT 3alphanum)
const region = `\\b(?:${ALPHA}{2}|${DIGIT}{3})\\b`; // region = 2ALPHA / 3DIGIT
const script = `\\b(?:${ALPHA}{4})\\b`; // script = 4ALPHA
const extlang = `\\b(?:${ALPHA}{3}\\b(?:-${ALPHA}{3}){0,2})\\b`; // extlang = 3ALPHA *2("-" 3ALPHA)
const language = '\\b(?:' + // language =
`${ALPHA}{2,3}` + // 2*3ALPHA ; shortest ISO 639 code
`\\b(?:-${extlang})?` + // ["-" extlang] ; sometimes followed by extended language subtags
// `|${ALPHA}{4}` + // / 4ALPHA ; or reserved for future use
// `|${ALPHA}{5,8}` + // / 5*8ALPHA ; or registered language subtag
`|${ALPHA}{4,8}` + // ~/ 4*8ALPHA ; (paraphrased: combined previous two lines)
')\\b';
// below: ${language}, ${script}, and ${region} are wrapped in parens because matching groups are useful for replacement
const LANG_TAG_BASE = `\\b(${language})\\b` + // langtag = language
`\\b(?:-(${script}))?\\b` + // ["-" script]
`\\b(?:-(${region}))?\\b` ; // ["-" region]
const LANG_TAG_EXT = `\\b(?:-${variant})*\\b` + // *("-" variant)
`\\b((?:-${extension})*)\\b` + // *("-" extension)
`\\b(?:-${privateuse})?\\b` ; // ["-" privateuse]
const langtag = `\\b${LANG_TAG_BASE}\\b${LANG_TAG_EXT}\\b`;
const LANG_TAG = `\\b(?:${langtag}|${privateuse}|${grandfathered})\\b`; // Language-Tag = ...
LANG_TAG_BASE_RE = new RegExp(LANG_TAG_BASE, 'i'); // [1] language; [2] script; [3] region
LANG_TAG_EXT_RE = new RegExp(LANG_TAG_EXT, 'i'); // [1] extensions /((${extension})-)*/
LANG_TAG_RE = new RegExp(LANG_TAG, 'i'); // [1] language; [2] script; [3] region; [4] extensions
}
function IsWellFormedCurrencyCode(code) {
code = Internal.ToString(code);
if (!CURRENCY_CODE_RE) {
InitializeCurrencyRegExp();
}
return platform.builtInRegexMatch(code, CURRENCY_CODE_RE) !== null;
}
// Make sure locales is an array, remove duplicate locales, make sure each locale is valid, and canonicalize each.
function CanonicalizeLocaleList(locales) {
if (typeof locales === 'undefined') {
return [];
}
if (typeof locales === 'string') {
locales = [locales];
}
locales = Internal.ToObject(locales);
const length = Internal.ToUint32(locales.length);
// TODO: Use sets here to prevent duplicates
let seen = [];
forEachIfPresent(locales, length, function (locale) {
if ((typeof locale !== 'string' && typeof locale !== 'object') || locale === null) {
platform.raiseNeedObjectOrString("Locale");
}
let tag = Internal.ToString(locale);
if (!IsWellFormedLanguageTag(tag)) {
platform.raiseLocaleNotWellFormed(String(tag));
}
tag = platform.normalizeLanguageTag(tag);
if (tag !== undefined && callInstanceFunc(ArrayInstanceIndexOf, seen, tag) === -1) {
callInstanceFunc(ArrayInstancePush, seen, tag);
}
});
return seen;
}
function LookupSupportedLocales(requestedLocales, fitter, defaultLocale) {
var subset = [];
var count = 0;
callInstanceFunc(ArrayInstanceForEach, requestedLocales, function (locale) {
try {
var resolved = resolveLocaleHelper(locale, fitter, undefined, defaultLocale);
if (resolved.locale) {
ObjectDefineProperty(subset, count, { value: resolved.locale, writable: false, configurable: false, enumerable: true });
count = count + 1;
}
} catch (ex) {
throwExIfOOMOrSOE(ex);
// Expecting an error (other than OOM or SOE), same as fitter returning undefined
}
});
ObjectDefineProperty(subset, "length", { value: count, writable: false, configurable: false });
return subset;
}
var supportedLocalesOfWrapper = function (that, functionName, locales, options) {
if (that === null || that === undefined) {
platform.raiseNotAConstructor(functionName);
}
var hiddenObj = platform.getHiddenObject(that);
if (!hiddenObj || hiddenObj.isValid !== "Valid") {
platform.raiseNotAConstructor(functionName);
}
return supportedLocalesOf(locales, options);
}
var canonicalizeLocaleListWrapper = function (that, functionName, locales) {
if (that === null || that === undefined) {
platform.raiseNotAConstructor(functionName);
}
var hiddenObj = platform.getHiddenObject(that);
if (!hiddenObj || hiddenObj.isValid !== "Valid") {
platform.raiseNotAConstructor(functionName);
}
return CanonicalizeLocaleList(locales);
}
// Shared among all the constructors
var supportedLocalesOf = function (locales, options) {
var matcher;
locales = CanonicalizeLocaleList(locales);
if (typeof options !== 'undefined') {
matcher = options.localeMatcher;
if (typeof matcher !== 'undefined') {
matcher = Internal.ToString(matcher);
if (matcher !== 'lookup' && matcher !== 'best fit') {
platform.raiseOptionValueOutOfRange_3(String(matcher), "localeMatcher", "['best fit', 'lookup']");
}
}
}
if (typeof matcher === 'undefined' || matcher === 'best fit') {
return LookupSupportedLocales(locales, resolveLocaleBestFit, platform.normalizeLanguageTag(strippedDefaultLocale()));
} else {
return LookupSupportedLocales(locales, resolveLocaleLookup, strippedDefaultLocale());
}
};
const intlStaticMethodThisArg = setPrototype({}, null);
platform.setHiddenObject(intlStaticMethodThisArg, setPrototype({ isValid: "Valid" }, null));
// We wrap these functions so that we can define the correct name for this function for each Intl constructor,
// which allows us to display the correct error message for each Intl type.
const collator_supportedLocalesOf_name = "Intl.Collator.supportedLocalesOf";
const collator_supportedLocalesOf = callInstanceFunc(FunctionInstanceBind, tagPublicFunction(collator_supportedLocalesOf_name,
function collator_supportedLocalesOf_dummyName(locales) {
const options = arguments.length < 2 ? undefined : arguments[1];
return supportedLocalesOfWrapper(this, collator_supportedLocalesOf_name, locales, options);
}), intlStaticMethodThisArg);
const numberFormat_supportedLocalesOf_name = "Intl.NumberFormat.supportedLocalesOf";
const numberFormat_supportedLocalesOf = callInstanceFunc(FunctionInstanceBind, tagPublicFunction(numberFormat_supportedLocalesOf_name,
function numberFormat_supportedLocalesOf_dummyName(locales) {
const options = arguments.length < 2 ? undefined : arguments[1];
return supportedLocalesOfWrapper(this, numberFormat_supportedLocalesOf_name, locales, options);
}), intlStaticMethodThisArg);
const dateTimeFormat_supportedLocalesOf_name = "Intl.DateTimeFormat.supportedLocalesOf";
const dateTimeFormat_supportedLocalesOf = callInstanceFunc(FunctionInstanceBind, tagPublicFunction(dateTimeFormat_supportedLocalesOf_name,
function dateTimeFormat_supportedLocalesOf_dummyName(locales) {
const options = arguments.length < 2 ? undefined : arguments[1];
return supportedLocalesOfWrapper(this, dateTimeFormat_supportedLocalesOf_name, locales, options);
}), intlStaticMethodThisArg);
const getCanonicalLocales_name = "Intl.getCanonicalLocales";
const getCanonicalLocales = callInstanceFunc(FunctionInstanceBind, tagPublicFunction(getCanonicalLocales_name,
function getCanonicalLocales_dummyName(locales) {
return canonicalizeLocaleListWrapper(this, getCanonicalLocales_name, locales);
}), intlStaticMethodThisArg);
// TODO: Bound functions get the "bound" prefix by default, so we need to remove it.
// When https://github.com/Microsoft/ChakraCore/issues/637 is fixed and we have a way
// to make built-in functions non-constructible, we can remove the call to
// Function.prototype.bind (i.e. FunctionInstanceBind) and just rely on tagging instead of setting the "name" manually.
ObjectDefineProperty(collator_supportedLocalesOf, 'name', { value: 'supportedLocalesOf' });
ObjectDefineProperty(numberFormat_supportedLocalesOf, 'name', { value: 'supportedLocalesOf' });
ObjectDefineProperty(dateTimeFormat_supportedLocalesOf, 'name', { value: 'supportedLocalesOf' });
ObjectDefineProperty(getCanonicalLocales, 'name', { value: 'getCanonicalLocales' });
// If an empty string is encountered for the value of the property; that means that is by default.
// So in the case of zh-TW; "default" and "stroke" are the same.
// This list was discussed with AnBorod, AnGlass and SureshJa.
var localesAcceptingCollationValues = setPrototype({
"es-ES": setPrototype({ "trad": "tradnl" }, null),
"lv-LV": setPrototype({ "trad": "tradnl" }, null),
"de-DE": setPrototype({ "phonebk": "phoneb" }, null),
"ja-JP": setPrototype({ "unihan": "radstr" }, null),
// We believe "pronun" means "pronunciation"
"zh-TW": setPrototype({ "phonetic": "pronun", "unihan": "radstr", "stroke": "" }, null),
"zh-HK": setPrototype({ "unihan": "radstr", "stroke": "" }, null),
"zh-MO": setPrototype({ "unihan": "radstr", "stroke": "" }, null),
"zh-CN": setPrototype({ "stroke": "stroke", "pinyin": "" }, null),
"zh-SG": setPrototype({ "stroke": "stroke", "pinyin": "" }, null)
// The following locales are supported by Windows; however, no BCP47 equivalent collation values were found for these.
// In future releases; this list (plus most of the Collator implementation) will be changed/removed as the platform support is expected to change.
// "hu-HU": ["technl"],
// "ka-GE": ["modern"],
// "x-IV": ["mathan"]
}, null);
// reverses the keys and values in each locale's sub-object in localesAcceptingCollationValues
// localesAcceptingCollationValues[locale][key] = value -> reverseLocalesAcceptingCollationValues[locale][value] = key
var reverseLocalesAcceptingCollationValues = (function () {
const toReturn = setPrototype({}, null);
callInstanceFunc(ArrayInstanceForEach, ObjectGetOwnPropertyNames(localesAcceptingCollationValues), function (locale) {
const collationValuesForLocale = localesAcceptingCollationValues[locale];
const reversedCollationValues = setPrototype({}, null);
callInstanceFunc(ArrayInstanceForEach, ObjectGetOwnPropertyNames(collationValuesForLocale), function (collation) {
const windowsTag = collationValuesForLocale[collation];
if (windowsTag !== "") {
reversedCollationValues[windowsTag] = collation;
}
});
toReturn[locale] = reversedCollationValues;
});
return toReturn;
}());
// mappedDefaultLocale will get the default locale and update any deprecated
// collation/sort order values it may use
let __mappedDefaultLocale = undefined;
var mappedDefaultLocale = function () {
if (__mappedDefaultLocale && platform.useCaches) {
return __mappedDefaultLocale;
}
let locale = undefined;
let collation = undefined;
if (isPlatformUsingICU) {
// ICU's getDefaultLocale() will return a valid BCP-47/RFC 5646 langtag
locale = GetDefaultLocale();
const match = platform.builtInRegexMatch(locale, /-u(?:-[^\-][^\-]?-[^\-]+)*-co-([^\-]+).*/);
if (match) {
// if the system default locale had a collation, strip it for now
// we will add the collation back later in this function
collation = match[1];
locale = callInstanceFunc(StringInstanceReplace, locale, `-co-${collation}`, "");
}
} else {
// Windows' getDefaultLocale() will return a RFC4646 langtag
const parts = platform.builtInRegexMatch(GetDefaultLocale(), /([^_]*)_?(.+)?/);
locale = parts[1];
collation = parts[2];
}
if (collation === undefined) {
__mappedDefaultLocale = locale;
return __mappedDefaultLocale;
}
// we stripped the -co-collation or _collation above, so this function adds it back
const createLocaleCollationString = function (finalLocale, finalCollation) {
if (isPlatformUsingICU) {
return `${finalLocale}-co-${finalCollation}`;
} else {
return `${finalLocale}-u-co-${finalCollation}`;
}
};
const collationMapForLocale = reverseLocalesAcceptingCollationValues[locale];
if (collationMapForLocale === undefined) {
// Assume the system wouldn't give us back a bad collation value
__mappedDefaultLocale = createLocaleCollationString(locale, collation);
return __mappedDefaultLocale;
}
const mappedCollation = collationMapForLocale[collation];
if (mappedCollation !== undefined) {
__mappedDefaultLocale = createLocaleCollationString(locale, mappedCollation);
} else {
__mappedDefaultLocale = createLocaleCollationString(locale, collation);
}
return __mappedDefaultLocale;
};
// Intl.Collator, String.prototype.localeCompare
var Collator = (function () {
if (InitType === 'Intl' || InitType === 'String') {
function InitializeCollator(collator, localeList, options) {
if (typeof collator != "object") {
platform.raiseNeedObject();
}
if (callInstanceFunc(ObjectInstanceHasOwnProperty, collator, '__initializedIntlObject') && collator.__initializedIntlObject) {
platform.raiseObjectIsAlreadyInitialized("Collator", "Collator");
}
collator.__initializedIntlObject = true;
// Extract options
if (typeof options === 'undefined') {
options = setPrototype({}, null);
} else {
options = Internal.ToObject(options);
}
var matcher = GetOption(options, "localeMatcher", "string", ["lookup", "best fit"], "best fit");
var usage = GetOption(options, "usage", "string", ["sort", "search"], "sort");
var sensitivity = GetOption(options, "sensitivity", "string", ["base", "accent", "case", "variant"], undefined);
var ignorePunctuation = GetOption(options, "ignorePunctuation", "boolean", undefined, false);
var caseFirst = GetOption(options, "caseFirst", "string", ["upper", "lower", "false"], undefined);
var numeric = GetOption(options, "numeric", "boolean", [true, false], undefined);
// Deal with the locales and extensions
localeList = CanonicalizeLocaleList(localeList);
var resolvedLocaleInfo = resolveLocales(localeList, matcher, undefined, mappedDefaultLocale);
var collation = "default";
var resolvedLocaleLookup = resolveLocaleLookup(resolvedLocaleInfo.localeWithoutSubtags);
var collationAugmentedLocale = resolvedLocaleLookup;
if (resolvedLocaleInfo.subTags) {
callInstanceFunc(ArrayInstanceForEach, resolvedLocaleInfo.subTags, function (subTag) {
var parts = platform.builtInRegexMatch(subTag, /([^-]*)-?(.*)?/); // [0] entire thing; [1] key; [2] value
var key = parts[1];
var value = parts[2] === "" ? undefined : parts[2];
if (key === "kf" && caseFirst === undefined) {
caseFirst = GetOption(setPrototype({ caseFirst: value }, null), "caseFirst", "string", ["upper", "lower", "false"], undefined);
} else if (key === "kn" && numeric === undefined) {
if (value !== undefined) {
numeric = Internal.ToLogicalBoolean(callInstanceFunc(StringInstanceToLowerCase, value) === "true");
} else {
numeric = true;
}
} else if (key === "co" && value !== undefined && value !== "default" && value !== "search" && value !== "sort" && value !== "standard") {
// Ignore these collation values as they shouldn't have any impact
collation = value;
}
});
}
if (collation !== "default") {
var accepedCollationForLocale = localesAcceptingCollationValues[collationAugmentedLocale];
var windowsCollation = "";
if (accepedCollationForLocale !== undefined && (windowsCollation = accepedCollationForLocale[collation]) !== undefined) {
if (windowsCollation !== "") {
collationAugmentedLocale = collationAugmentedLocale + "_" + windowsCollation;
}
}
else {
collation = "default";
}
}
// Correct options if need be.
if (caseFirst === undefined) {
try {
var num = platform.compareString('A', 'a', resolvedLocaleLookup, undefined, undefined, undefined);
} catch (e) {
// Rethrow OOM or SOE
throwExIfOOMOrSOE(e);
// Otherwise, Generic message to cover the exception throw from the CompareStringEx api.
// The platform's exception is also generic and in most if not all cases specifies that "a" argument is invalid.
// We have no other information from the platform on the cause of the exception.
platform.raiseOptionValueOutOfRange();
}
if (num === 0) {
caseFirst = 'false';
} else if (num === -1) {
caseFirst = 'upper';
} else {
caseFirst = 'lower';
}
}
if (sensitivity === undefined) {
sensitivity = "variant";
}
if (numeric === undefined) {
numeric = false;
}
// Set the options on the object
collator.__matcher = matcher;
collator.__locale = resolvedLocaleInfo.localeWithoutSubtags;
collator.__localeForCompare = collationAugmentedLocale;
collator.__usage = usage;
collator.__sensitivity = sensitivity;
collator.__ignorePunctuation = ignorePunctuation;
collator.__caseFirst = caseFirst;
collator.__numeric = numeric;
collator.__collation = collation;
collator.__initializedCollator = true;
}
platform.registerBuiltInFunction(tagPublicFunction("String.prototype.localeCompare", function () {
var that = arguments[0];
if (this === undefined || this === null) {
platform.raiseThis_NullOrUndefined("String.prototype.localeCompare");
}
else if (that === null) {
platform.raiseNeedObject();
}
// ToString must be called on this/that argument before we do any other operation, as other operations in InitializeCollator may also be observable
var thisArg = String(this);
var that = String(that);
var stateObject = setPrototype({}, null);
InitializeCollator(stateObject, arguments[1], arguments[2]);
return Number(platform.compareString(thisArg, that, stateObject.__localeForCompare, stateObject.__sensitivity, stateObject.__ignorePunctuation, stateObject.__numeric));
}), 4);
if (InitType === 'Intl') {
function Collator() {
// The function should have length of 0, hence we are getting arguments this way.
// While it's true that we could just do e.g. arguments[0] and get undefined if it is not present,
// that makes assumptions that the JIT must check. This pattern is marginally more efficient.
var locales = undefined;
var options = undefined;
if (arguments.length >= 1) locales = arguments[0];
if (arguments.length >= 2) options = arguments[1];
if (this === Intl || this === undefined) {
return new Collator(locales, options);
}
var obj = Internal.ToObject(this);
if (!ObjectIsExtensible(obj)) {
platform.raiseObjectIsNonExtensible("Collator");
}
// Use the hidden object to store data
var hiddenObject = platform.getHiddenObject(obj);
if (hiddenObject === undefined) {
hiddenObject = setPrototype({}, null);
platform.setHiddenObject(obj, hiddenObject);
}
InitializeCollator(hiddenObject, locales, options);
// Add the bound compare
hiddenObject.__boundCompare = callInstanceFunc(FunctionInstanceBind, compare, obj);
delete hiddenObject.__boundCompare.name;
return obj;
}
tagPublicFunction("Intl.Collator", Collator);
function compare(a, b) {
if (typeof this !== 'object') {
platform.raiseNeedObjectOfType("Collator.prototype.compare", "Collator");
}
var hiddenObject = platform.getHiddenObject(this);
if (hiddenObject === undefined || !hiddenObject.__initializedCollator) {
platform.raiseNeedObjectOfType("Collator.prototype.compare", "Collator");
}
a = String(a);
b = String(b);
return Number(platform.compareString(a, b, hiddenObject.__localeForCompare, hiddenObject.__sensitivity, hiddenObject.__ignorePunctuation, hiddenObject.__numeric));
}
tagPublicFunction("Intl.Collator.prototype.compare", compare);
ObjectDefineProperty(Collator, 'supportedLocalesOf', { value: collator_supportedLocalesOf, writable: true, configurable: true });
ObjectDefineProperty(Collator, 'prototype', { value: new Collator(), writable: false, enumerable: false, configurable: false });
setPrototype(Collator.prototype, Object.prototype);
ObjectDefineProperty(Collator.prototype, 'constructor', { value: Collator, writable: true, enumerable: false, configurable: true });
ObjectDefineProperty(Collator.prototype, 'resolvedOptions', {
value: function resolvedOptions() {
if (typeof this !== 'object') {
platform.raiseNeedObjectOfType("Collator.prototype.resolvedOptions", "Collator");
}
var hiddenObject = platform.getHiddenObject(this);
if (hiddenObject === undefined || !hiddenObject.__initializedCollator) {
platform.raiseNeedObjectOfType("Collator.prototype.resolvedOptions", "Collator");
}
return {
locale: hiddenObject.__locale,
usage: hiddenObject.__usage,
sensitivity: hiddenObject.__sensitivity,
ignorePunctuation: hiddenObject.__ignorePunctuation,
collation: hiddenObject.__collation, // "co" unicode extension
numeric: hiddenObject.__numeric, // "ka" unicode extension TODO: Determine if this is supported (doesn't have to be)
caseFirst: hiddenObject.__caseFirst // "kf" unicode extension TODO: Determine if this is supported (doesn't have to be)
}
}, writable: true, enumerable: false, configurable: true
});
ObjectDefineProperty(Collator.prototype, 'compare', {
get: tagPublicFunction('get compare', function () {
if (typeof this !== 'object') {
platform.raiseNeedObjectOfType("Collator.prototype.compare", "Collator");
}
var hiddenObject = platform.getHiddenObject(this);
if (hiddenObject === undefined || !hiddenObject.__initializedCollator) {
platform.raiseNeedObjectOfType("Collator.prototype.compare", "Collator");
}
return hiddenObject.__boundCompare;
}), enumerable: false, configurable: true
});
return Collator;
}
}
// 'Init.Collator' not defined if reached here. Return 'undefined'
return undefined;
})();
// Intl.NumberFormat, Number.prototype.toLocaleString
var NumberFormat = (function () {
// Keep these "enums" in sync with lib/Runtime/PlatformAgnostic/Intl.h
const NumberFormatStyle = setPrototype({
DEFAULT: 0, // "decimal" is the default
DECIMAL: 0, // Intl.NumberFormat(locale, { style: "decimal" }); // aka in our code as "number"
PERCENT: 1, // Intl.NumberFormat(locale, { style: "percent" });
CURRENCY: 2, // Intl.NumberFormat(locale, { style: "currency", ... });
MAX: 3
}, null);
const NumberFormatCurrencyDisplay = setPrototype({
DEFAULT: 0, // "symbol" is the default
SYMBOL: 0, // Intl.NumberFormat(locale, { style: "currency", currencyDisplay: "symbol" }); // e.g. "$" or "US$" depeding on locale
CODE: 1, // Intl.NumberFormat(locale, { style: "currency", currencyDisplay: "code" }); // e.g. "USD"
NAME: 2, // Intl.NumberFormat(locale, { style: "currency", currencyDisplay: "name" }); // e.g. "US dollar"
MAX: 3
}, null);
if (InitType === 'Intl' || InitType === 'Number') {
function InitializeNumberFormat(numberFormat, localeList, options) {
if (typeof numberFormat != "object") {
platform.raiseNeedObject();
}
if (callInstanceFunc(ObjectInstanceHasOwnProperty, numberFormat, '__initializedIntlObject') && numberFormat.__initializedIntlObject) {
platform.raiseObjectIsAlreadyInitialized("NumberFormat", "NumberFormat");
}
numberFormat.__initializedIntlObject = true;
// Extract options
if (typeof options === 'undefined') {
options = setPrototype({}, null);
} else {
options = Internal.ToObject(options);
}
var matcher = GetOption(options, "localeMatcher", "string", ["lookup", "best fit"], "best fit");
var style = GetOption(options, "style", "string", ["decimal", "percent", "currency"], "decimal");
var formatterToUse = NumberFormatStyle.DECIMAL; // DEFAULT
if (style === 'percent') {
formatterToUse = NumberFormatStyle.PERCENT;
} else if (style === 'currency') {
formatterToUse = NumberFormatStyle.CURRENCY;
}
var currency = GetOption(options, "currency", "string", undefined, undefined);
var currencyDisplay = GetOption(options, 'currencyDisplay', 'string', ['code', 'symbol', 'name'], 'symbol');
var currencyDigits = undefined;
var minimumIntegerDigits = GetNumberOption(options, 'minimumIntegerDigits', 1, 21, 1);
var minimumFractionDigits = undefined;
var maximumFractionDigits = undefined;
var maximumFractionDigitsDefault = undefined;
var minimumSignificantDigits = options.minimumSignificantDigits;
var maximumSignificantDigits = options.maximumSignificantDigits;
if (typeof minimumSignificantDigits !== 'undefined' || typeof maximumSignificantDigits !== 'undefined') {
minimumSignificantDigits = GetNumberOption(options, 'minimumSignificantDigits', 1, 21, 1);
maximumSignificantDigits = GetNumberOption(options, 'maximumSignificantDigits', minimumSignificantDigits, 21, 21);
}
var useGrouping = GetOption(options, 'useGrouping', 'boolean', undefined, true);
// Deal with the locales and extensions
localeList = CanonicalizeLocaleList(localeList);
var resolvedLocaleInfo = resolveLocales(localeList, matcher, ["nu"], strippedDefaultLocale);
// Correct the options if necessary
if (typeof currency !== 'undefined' && !IsWellFormedCurrencyCode(currency)) {
platform.raiseInvalidCurrencyCode(String(currency));
}
if (style === "currency") {
if (typeof currency === 'undefined') {
platform.raiseMissingCurrencyCode();
}
currency = callInstanceFunc(StringInstanceToUpperCase, currency);
try {
currencyDigits = platform.currencyDigits(currency);
} catch (e) {
throwExIfOOMOrSOE(e);
platform.raiseInvalidCurrencyCode(String(currency));
}
minimumFractionDigits = GetNumberOption(options, 'minimumFractionDigits', 0, 20, currencyDigits);
maximumFractionDigitsDefault = Math.max(currencyDigits, minimumFractionDigits);
} else {
currency = undefined;
currencyDisplay = undefined;
minimumFractionDigits = GetNumberOption(options, 'minimumFractionDigits', 0, 20, 0);
if (style === "percent") {
maximumFractionDigitsDefault = Math.max(minimumFractionDigits, 0);
} else {
maximumFractionDigitsDefault = Math.max(minimumFractionDigits, 3)
}
}
maximumFractionDigits = GetNumberOption(options, 'maximumFractionDigits', minimumFractionDigits, 20, maximumFractionDigitsDefault);
// Set the options on the object
numberFormat.__localeMatcher = matcher;
numberFormat.__locale = resolvedLocaleInfo.locale;
numberFormat.__style = style;
if (currency !== undefined) {
numberFormat.__currency = currency;
}
if (currencyDisplay !== undefined) {
numberFormat.__currencyDisplay = currencyDisplay;
numberFormat.__currencyDisplayToUse = NumberFormatCurrencyDisplay.DEFAULT;
if (currencyDisplay === "symbol") {
numberFormat.__currencyDisplayToUse = NumberFormatCurrencyDisplay.SYMBOL;
} else if (currencyDisplay === "code") {
numberFormat.__currencyDisplayToUse = NumberFormatCurrencyDisplay.CODE;
} else if (currencyDisplay === "name") {
numberFormat.__currencyDisplayToUse = NumberFormatCurrencyDisplay.NAME;
}
}
numberFormat.__minimumIntegerDigits = minimumIntegerDigits;
numberFormat.__minimumFractionDigits = minimumFractionDigits;
numberFormat.__maximumFractionDigits = maximumFractionDigits;
if (maximumSignificantDigits !== undefined) {
numberFormat.__minimumSignificantDigits = minimumSignificantDigits;
numberFormat.__maximumSignificantDigits = maximumSignificantDigits;
}
numberFormat.__formatterToUse = formatterToUse;
numberFormat.__useGrouping = useGrouping;
try {
// Cache api instance and update numbering system on the object
platform.cacheNumberFormat(numberFormat);
} catch (e) {
throwExIfOOMOrSOE(e);
// Generic message to cover the exception throw from the platform.
// The platform's exception is also generic and in most if not all cases specifies that "a" argument is invalid.
// We have no other information from the platform on the cause of the exception.
platform.raiseOptionValueOutOfRange();
}
if (!numberFormat.__numberingSystem) {
numberFormat.__numberingSystem = "latn"; // assume Latin numerals by default
}
numberFormat.__numberingSystem = callInstanceFunc(StringInstanceToLowerCase, numberFormat.__numberingSystem);
numberFormat.__initializedNumberFormat = true;
}
platform.registerBuiltInFunction(tagPublicFunction("Number.prototype.toLocaleString", function () {
if ((typeof this) !== 'number' && !(this instanceof Number)) {
platform.raiseNeedObjectOfType("Number.prototype.toLocaleString", "Number");
}
var stateObject = setPrototype({}, null);
InitializeNumberFormat(stateObject, arguments[0], arguments[1]);
var n = Internal.ToNumber(this);
// Need to special case the '-0' case to format as 0 instead of -0.
return String(platform.formatNumber(n === -0 ? 0 : n, stateObject));
}), 3);
if (InitType === 'Intl') {
function NumberFormat() {
// The function should have length of 0, hence we are getting arguments this way.
// While it's true that we could just do e.g. arguments[0] and get undefined if it is not present,
// that makes assumptions that the JIT must check. This pattern is marginally more efficient.
let locales = undefined;
let options = undefined;
if (arguments.length >= 1) locales = arguments[0];
if (arguments.length >= 2) options = arguments[1];
if (this === Intl || this === undefined) {
return new NumberFormat(locales, options);
}
let obj = Internal.ToObject(this);
if (!ObjectIsExtensible(obj)) {
platform.raiseObjectIsNonExtensible("NumberFormat");
}
// Use the hidden object to store data
let hiddenObject = platform.getHiddenObject(obj);
if (hiddenObject === undefined) {
hiddenObject = setPrototype({}, null);
platform.setHiddenObject(obj, hiddenObject);
}
InitializeNumberFormat(hiddenObject, locales, options);
hiddenObject.__boundFormat = callInstanceFunc(FunctionInstanceBind, format, obj)
delete hiddenObject.__boundFormat.name;
return obj;
}
tagPublicFunction("Intl.NumberFormat", NumberFormat);
function format(n) {
n = Internal.ToNumber(n);
if (typeof this !== 'object') {
platform.raiseNeedObjectOfType("NumberFormat.prototype.format", "NumberFormat");
}
var hiddenObject = platform.getHiddenObject(this);
if (hiddenObject === undefined || !hiddenObject.__initializedNumberFormat) {
platform.raiseNeedObjectOfType("NumberFormat.prototype.format", "NumberFormat");
}
// Need to special case the '-0' case to format as 0 instead of -0.
return String(platform.formatNumber(n === -0 ? 0 : n, hiddenObject));
}
tagPublicFunction("Intl.NumberFormat.prototype.format", format);
ObjectDefineProperty(NumberFormat, 'supportedLocalesOf', { value: numberFormat_supportedLocalesOf, writable: true, configurable: true });
var options = ['locale', 'numberingSystem', 'style', 'currency', 'currencyDisplay', 'minimumIntegerDigits',
'minimumFractionDigits', 'maximumFractionDigits', 'minimumSignificantDigits', 'maximumSignificantDigits',
'useGrouping'];
ObjectDefineProperty(NumberFormat, 'prototype', { value: new NumberFormat(), writable: false, enumerable: false, configurable: false });
setPrototype(NumberFormat.prototype, Object.prototype);
ObjectDefineProperty(NumberFormat.prototype, 'constructor', { value: NumberFormat, writable: true, enumerable: false, configurable: true });
ObjectDefineProperty(NumberFormat.prototype, 'resolvedOptions', {
value: function resolvedOptions() {
if (typeof this !== 'object') {
platform.raiseNeedObjectOfType("NumberFormat.prototype.resolvedOptions", "NumberFormat");
}
var hiddenObject = platform.getHiddenObject(this);
if (hiddenObject === undefined || !hiddenObject.__initializedNumberFormat) {
platform.raiseNeedObjectOfType("NumberFormat.prototype.resolvedOptions", "NumberFormat");
}
var resolvedOptions = setPrototype({}, null);
callInstanceFunc(ArrayInstanceForEach, options, function (option) {
if (typeof hiddenObject['__' + option] !== 'undefined') {
resolvedOptions[option] = hiddenObject['__' + option];
}
});
return setPrototype(resolvedOptions, {});
}, writable: true, enumerable: false, configurable: true
});
ObjectDefineProperty(NumberFormat.prototype, 'format', {
get: tagPublicFunction('get format', function () {
if (typeof this !== 'object') {
platform.raiseNeedObjectOfType("NumberFormat.prototype.format", "NumberFormat");
}
var hiddenObject = platform.getHiddenObject(this);
if (hiddenObject === undefined || !hiddenObject.__initializedNumberFormat) {
platform.raiseNeedObjectOfType("NumberFormat.prototype.format", "NumberFormat");
}
return hiddenObject.__boundFormat;
}), enumerable: false, configurable: true
});
return NumberFormat;
}
}
// 'Init.NumberFormat' not defined if reached here. Return 'undefined'
return undefined;
})();
// Intl.DateTimeFormat, Date.prototype.toLocaleString, Date.prototype.toLocaleDateString, Date.prototype.toLocaleTimeString
var DateTimeFormat = (function () {
if (InitType === 'Intl' || InitType === 'Date') {
function ToDateTimeOptions(options, required, defaults) {
if (options === undefined) {
options = setPrototype({}, null);
} else {
options = Internal.ToObject(options);
}
var needDefaults = true;
if (required === "date" || required === "any") {
if (options.weekday !== undefined || options.year !== undefined || options.month !== undefined || options.day !== undefined) {
needDefaults = false;
}
}
if (required === "time" || required === "any") {
if (options.hour !== undefined || options.minute !== undefined || options.second !== undefined) {
needDefaults = false;
}
}
if (needDefaults && (defaults === "date" || defaults === "all")) {
ObjectDefineProperty(options, "year", {
value: "numeric", writable: true,
enumerable: true, configurable: true
});
ObjectDefineProperty(options, "month", {
value: "numeric", writable: true,
enumerable: true, configurable: true
});
ObjectDefineProperty(options, "day", {
value: "numeric", writable: true,
enumerable: true, configurable: true
});
}
if (needDefaults && (defaults === "time" || defaults === "all")) {
ObjectDefineProperty(options, "hour", {
value: "numeric", writable: true,
enumerable: true, configurable: true
});
ObjectDefineProperty(options, "minute", {
value: "numeric", writable: true,
enumerable: true, configurable: true
});
ObjectDefineProperty(options, "second", {
value: "numeric", writable: true,
enumerable: true, configurable: true
});
}
return options;
}
// Currently you cannot format date pieces and time pieces together, so this builds up a format template for each separately.
function EcmaOptionsToWindowsTemplate(options) {
var template = [];
if (options.weekday) {
if (options.weekday === 'narrow' || options.weekday === 'short') {
callInstanceFunc(ArrayInstancePush, template, 'dayofweek.abbreviated');
} else if (options.weekday === 'long') {
callInstanceFunc(ArrayInstancePush, template, 'dayofweek.full');
}
}
// TODO: Era not supported
if (options.year) {
if (options.year === '2-digit') {
callInstanceFunc(ArrayInstancePush, template, 'year.abbreviated');
} else if (options.year === 'numeric') {
callInstanceFunc(ArrayInstancePush, template, 'year.full');
}
}
if (options.month) {
if (options.month === '2-digit' || options.month === 'numeric') {
callInstanceFunc(ArrayInstancePush, template, 'month.numeric')
} else if (options.month === 'short' || options.month === 'narrow') {
callInstanceFunc(ArrayInstancePush, template, 'month.abbreviated');
} else if (options.month === 'long') {
callInstanceFunc(ArrayInstancePush, template, 'month.full');
}
}
if (options.day) {
callInstanceFunc(ArrayInstancePush, template, 'day');
}
if (options.timeZoneName) {
if (options.timeZoneName === "short") {
callInstanceFunc(ArrayInstancePush, template, 'timezone.abbreviated');
} else if (options.timeZoneName === "long") {
callInstanceFunc(ArrayInstancePush, template, 'timezone.full');
}
}
callInstanceFunc(ArrayInstanceForEach, ['hour', 'minute', 'second'], function (opt) {
if (options[opt]) {
callInstanceFunc(ArrayInstancePush, template, opt);
}
});
// TODO: Timezone Name not supported.
return getArrayLength(template) > 0 ? callInstanceFunc(ArrayInstanceJoin, template, ' ') : undefined;
}
var WindowsToEcmaCalendarMap = {
'GregorianCalendar': 'gregory',
'HebrewCalendar': 'hebrew',
'HijriCalendar': 'islamic',
'JapaneseCalendar': 'japanese',
'JulianCalendar': 'julian',
'KoreanCalendar': 'korean',
'UmAlQuraCalendar': 'islamic-civil',
'ThaiCalendar': 'thai',
'TaiwanCalendar': 'taiwan'
};
function WindowsToEcmaCalendar(calendar) {
if (typeof calendar === 'undefined') {
return '';
}
return WindowsToEcmaCalendarMap[calendar] || 'gregory';
}
// Certain formats have similar patterns on both ecma and windows; will use helper methods for them
function correctWeekdayEraMonthPattern(patternString, userValue, searchParam) {
// parts[1] is either dayofweek.solo, dayofweek, era or month; parts[2] is either abbreviated or full
var parts = platform.builtInRegexMatch(patternString, RegExp("{(" + searchParam + "(?:\\.solo)?)\\.([a-z]*)(?:\\([0-9]\\))?}"));
// If this happens that means windows removed the specific pattern (which isn't expected; but better be safe)
if (parts === null) {
RaiseAssert(new Error("Error when correcting windows returned weekday/Era/Month pattern; regex returned null. \nInput was: '" + patternString + "'\nRegex: '" + "{(" + searchParam + "(\\.solo)?)\\.([a-z]*)(\\([0-9]\\))?}'"));
return patternString;
}
if (parts[2] !== "full" && userValue === "long") {
return callInstanceFunc(StringInstanceReplace, patternString, parts[0], "{" + parts[1] + "." + "full" + "}");
} else if (userValue !== "long") {
return callInstanceFunc(StringInstanceReplace, patternString, parts[0], "{" + parts[1] + "." + (userValue === "short" ? "abbreviated" : "abbreviated(1)") + "}");
}
return patternString;
}
function correctDayHourMinuteSecondMonthPattern(patternString, userValue, searchParam) {
// parts[1] is either month, day, hour, minute, or second
// REVIEW (doilij) is it even possible to have a '.solo' (i.e. /(?:\\.solo)?/ ) in the above cases?
var parts = platform.builtInRegexMatch(patternString, RegExp("{(" + searchParam + ")(?:\\.solo)?\\.([a-z]*)(?:\\([0-9]\\))?}"));
if (parts === null) {
RaiseAssert(new Error("Error when correcting windows returned day/hour/minute/second/month pattern; regex returned null. \nInput was: '" + patternString + "'\nRegex: '" + "{(" + searchParam + "(\\.solo)?)\\.([a-z]*)(\\([0-9]\\))?}'"));
return patternString;
}
// Only correct the 2 digit; unless part[2] isn't integer
if (userValue === "2-digit") {
return callInstanceFunc(StringInstanceReplace, patternString, parts[0], "{" + parts[1] + ".integer(2)}");
} else if (parts[2] !== "integer") {
return callInstanceFunc(StringInstanceReplace, patternString, parts[0], "{" + parts[1] + ".integer}");
}
return patternString;
}
// Perhaps the level of validation that we have might not be required for this method
function updatePatternStrings(patternString, dateTimeFormat) {
if (dateTimeFormat.__weekday !== undefined) {
patternString = correctWeekdayEraMonthPattern(patternString, dateTimeFormat.__weekday, "dayofweek");
}
if (dateTimeFormat.__era !== undefined) {
// This is commented because not all options are supported for locales that do have era;
// In addition, we can't force era to be part of a locale using templates.
// patternString = correctWeekdayEraMonthPattern(patternString, dateTimeFormat.__era, "era", 2);
}
if (dateTimeFormat.__year === "2-digit") {
var parts = platform.builtInRegexMatch(patternString, /\{year\.[a-z]*(\([0-9]\))?\}/);
if (parts === null) {
RaiseAssert(new Error("Error when correcting windows returned year; regex returned null"));
} else {
patternString = callInstanceFunc(StringInstanceReplace, patternString, parts[0], "{year.abbreviated(2)}");
}
} else if (dateTimeFormat.__year === "full") {
var parts = platform.builtInRegexMatch(patternString, /\{year\.[a-z]*(\([0-9]\))?\}/);
if (parts === null) {
RaiseAssert(new Error("Error when correcting windows returned year; regex returned null"));
} else {
patternString = callInstanceFunc(StringInstanceReplace, patternString, parts[0], "{year.full}");
}
}
// Month partially overlaps with weekday/month; unless it's 2-digit or numeric in which case it overlaps with day/hour/minute/second
if (dateTimeFormat.__month !== undefined && dateTimeFormat.__month !== "2-digit" && dateTimeFormat.__month !== "numeric") {
patternString = correctWeekdayEraMonthPattern(patternString, dateTimeFormat.__month, "month");
} else if (dateTimeFormat.__month !== undefined) {
patternString = correctDayHourMinuteSecondMonthPattern(patternString, dateTimeFormat.__month, "month");
}
if (dateTimeFormat.__day !== undefined) {
patternString = correctDayHourMinuteSecondMonthPattern(patternString, dateTimeFormat.__day, "day");
}
if (dateTimeFormat.__hour !== undefined) {
patternString = correctDayHourMinuteSecondMonthPattern(patternString, dateTimeFormat.__hour, "hour");
}
if (dateTimeFormat.__minute !== undefined) {
patternString = correctDayHourMinuteSecondMonthPattern(patternString, dateTimeFormat.__minute, "minute");
}
if (dateTimeFormat.__second !== undefined) {
patternString = correctDayHourMinuteSecondMonthPattern(patternString, dateTimeFormat.__second, "second");
}
if (dateTimeFormat.__timeZoneName !== undefined) {
patternString = correctWeekdayEraMonthPattern(patternString, dateTimeFormat.__timeZoneName, "timezone");
}
return patternString;
}
function InitializeDateTimeFormat(dateTimeFormat, localeList, options) {
if (typeof dateTimeFormat != "object") {
platform.raiseNeedObject();
}
if (callInstanceFunc(ObjectInstanceHasOwnProperty, dateTimeFormat, '__initializedIntlObject') && dateTimeFormat.__initializedIntlObject) {
platform.raiseObjectIsAlreadyInitialized("DateTimeFormat", "DateTimeFormat");
}
dateTimeFormat.__initializedIntlObject = true;
// Extract the options
options = ToDateTimeOptions(options, "any", "date");
var matcher = GetOption(options, "localeMatcher", "string", ["lookup", "best fit"], "best fit");
var timeZone = GetOption(options, "timeZone", "string", undefined, undefined);
if (timeZone !== undefined) {
timeZone = platform.validateAndCanonicalizeTimeZone(timeZone);
} else {
timeZone = platform.getDefaultTimeZone();
}
if (timeZone === undefined) {
platform.raiseOptionValueOutOfRange();
}
// Format options
var weekday = GetOption(options, "weekday", "string", ['narrow', 'short', 'long'], undefined);
var era = GetOption(options, "era", "string", ['narrow', 'short', 'long'], undefined);
var year = GetOption(options, "year", "string", ['2-digit', 'numeric'], undefined);
var month = GetOption(options, "month", "string", ['2-digit', 'numeric', 'narrow', 'short', 'long'], undefined);
var day = GetOption(options, "day", "string", ['2-digit', 'numeric'], undefined);
var hour = GetOption(options, "hour", "string", ['2-digit', 'numeric'], undefined);
var minute = GetOption(options, "minute", "string", ['2-digit', 'numeric'], undefined);
var second = GetOption(options, "second", "string", ['2-digit', 'numeric'], undefined);
var timeZoneName = GetOption(options, "timeZoneName", "string", ['short', 'long'], undefined);
var hour12 = hour ? GetOption(options, "hour12", "boolean", undefined, undefined) : undefined;
var formatMatcher = GetOption(options, "formatMatcher", "string", ["basic", "best fit"], "best fit");
var windowsClock = hour12 !== undefined ? (hour12 ? "12HourClock" : "24HourClock") : undefined;
var templateString = EcmaOptionsToWindowsTemplate(setPrototype({
weekday: weekday,
era: era,
year: year,
month: month,
day: day,
hour: hour,
minute: minute,
second: second,
timeZoneName: timeZoneName
}, null));
// Deal with the locale
localeList = CanonicalizeLocaleList(localeList);
var resolvedLocaleInfo = resolveLocales(localeList, matcher, ["nu", "ca"], strippedDefaultLocale);
// Assign the options
dateTimeFormat.__matcher = matcher;
dateTimeFormat.__timeZone = timeZone;
dateTimeFormat.__locale = resolvedLocaleInfo.locale;
// Format options
dateTimeFormat.__weekday = weekday;
dateTimeFormat.__era = era;
dateTimeFormat.__year = year;
dateTimeFormat.__month = month;
dateTimeFormat.__day = day;
dateTimeFormat.__hour = hour;
dateTimeFormat.__minute = minute;
dateTimeFormat.__second = second;
dateTimeFormat.__timeZoneName = timeZoneName;
dateTimeFormat.__hour12 = hour12;
dateTimeFormat.__formatMatcher = formatMatcher;
dateTimeFormat.__windowsClock = windowsClock;
dateTimeFormat.__templateString = templateString;
/*
* NOTE:
* Pattern string's are position-sensitive; while templates are not.
* If we specify {hour.integer(2)}:{minute.integer(2)} pattern string; we will always format as HH:mm.
* On the other hand, template strings don't give as fine granularity for options; and the platform decides how long month.abbreviated should be.
* Therefore, we have to create using template strings; and then change the .abbreivated/.integer values to have correct digits count if necessary.
* Thus, this results in this redundant looking code to create dateTimeFormat twice.
*/
var errorThrown = false;
try {
// Create the DateTimeFormatter to extract pattern strings
CreateDateTimeFormat(dateTimeFormat, false);
} catch (e) {
// Rethrow SOE or OOM
throwExIfOOMOrSOE(e);
// We won't throw for the first exception, but assume the template strings were rejected.
// Instead, we will try to fall back to default template strings.
var defaultOptions = ToDateTimeOptions(options, "none", "all");
dateTimeFormat.__templateString = EcmaOptionsToWindowsTemplate(defaultOptions, null);
errorThrown = true;
}
if (!errorThrown) {
// Update the pattern strings
dateTimeFormat.__templateString = updatePatternStrings(dateTimeFormat.__patternStrings[0], dateTimeFormat);
}
try {
// Cache the date time formatter
CreateDateTimeFormat(dateTimeFormat, true);
} catch (e) {
// Rethrow SOE or OOM
throwExIfOOMOrSOE(e);
// Otherwise, Generic message to cover the exception throw from the platform.
// The platform's exception is also generic and in most if not all cases specifies that "a" argument is invalid.
// We have no other information from the platform on the cause of the exception.
platform.raiseOptionValueOutOfRange();
}
// Correct the api's updated
dateTimeFormat.__calendar = WindowsToEcmaCalendar(dateTimeFormat.__windowsCalendar);
dateTimeFormat.__numberingSystem = callInstanceFunc(StringInstanceToLowerCase, dateTimeFormat.__numberingSystem);
if (dateTimeFormat.__hour !== undefined) {
dateTimeFormat.__hour12 = dateTimeFormat.__windowsClock === "12HourClock";
}
dateTimeFormat.__initializedDateTimeFormat = true;
}
platform.registerBuiltInFunction(tagPublicFunction("Date.prototype.toLocaleString", function () {
if (typeof this !== 'object' || !(this instanceof Date)) {
platform.raiseNeedObjectOfType("Date.prototype.toLocaleString", "Date");
}
var value = callInstanceFunc(DateInstanceGetDate, new Date(this));
if (isNaN(value) || !isFinite(value)) {
return "Invalid Date";
}
var stateObject = setPrototype({}, null);
InitializeDateTimeFormat(stateObject, arguments[0], ToDateTimeOptions(arguments[1], "any", "all"));
return String(platform.formatDateTime(Internal.ToNumber(this), stateObject));
}), 0);
platform.registerBuiltInFunction(tagPublicFunction("Date.prototype.toLocaleDateString", function () {
if (typeof this !== 'object' || !(this instanceof Date)) {
platform.raiseNeedObjectOfType("Date.prototype.toLocaleDateString", "Date");
}
var value = callInstanceFunc(DateInstanceGetDate, new Date(this));
if (isNaN(value) || !isFinite(value)) {
return "Invalid Date";
}
var stateObject = setPrototype({}, null);
InitializeDateTimeFormat(stateObject, arguments[0], ToDateTimeOptions(arguments[1], "date", "date"));
return String(platform.formatDateTime(Internal.ToNumber(this), stateObject));
}), 1);
platform.registerBuiltInFunction(tagPublicFunction("Date.prototype.toLocaleTimeString", function () {
if (typeof this !== 'object' || !(this instanceof Date)) {
platform.raiseNeedObjectOfType("Date.prototype.toLocaleTimeString", "Date");
}
var value = callInstanceFunc(DateInstanceGetDate, new Date(this));
if (isNaN(value) || !isFinite(value)) {
return "Invalid Date";
}
var stateObject = setPrototype({}, null);
InitializeDateTimeFormat(stateObject, arguments[0], ToDateTimeOptions(arguments[1], "time", "time"));
return String(platform.formatDateTime(Internal.ToNumber(this), stateObject));
}), 2);
if (InitType === 'Intl') {
function DateTimeFormat() {
// The function should have length of 0, hence we are getting arguments this way.
// While it's true that we could just do e.g. arguments[0] and get undefined if it is not present,
// that makes assumptions that the JIT must check. This pattern is marginally more efficient.
var locales = undefined;
var options = undefined;
if (arguments.length >= 1) locales = arguments[0];
if (arguments.length >= 2) options = arguments[1];
if (this === Intl || this === undefined) {
return new DateTimeFormat(locales, options);
}
var obj = Internal.ToObject(this);
if (!ObjectIsExtensible(obj)) {
platform.raiseObjectIsNonExtensible("DateTimeFormat");
}
// Use the hidden object to store data
var hiddenObject = platform.getHiddenObject(obj);
if (hiddenObject === undefined) {
hiddenObject = setPrototype({}, null);
platform.setHiddenObject(obj, hiddenObject);
}
InitializeDateTimeFormat(hiddenObject, locales, options);
hiddenObject.__boundFormat = callInstanceFunc(FunctionInstanceBind, format, obj);
delete hiddenObject.__boundFormat.name;
return obj;
}
tagPublicFunction("Intl.DateTimeFormat", DateTimeFormat);
function format() {
if (typeof this !== 'object') {
platform.raiseNeedObjectOfType("DateTimeFormat.prototype.format", "DateTimeFormat");
}
var hiddenObject = platform.getHiddenObject(this);
if (hiddenObject === undefined || !hiddenObject.__initializedDateTimeFormat) {
platform.raiseNeedObjectOfType("DateTimeFormat.prototype.format", "DateTimeFormat");
}
if (arguments.length >= 1) {
if (isNaN(arguments[0]) || !isFinite(arguments[0])) {
platform.raiseInvalidDate();
}
return String(platform.formatDateTime(Internal.ToNumber(arguments[0]), hiddenObject));
}
return String(platform.formatDateTime(DateNow(), hiddenObject));
}
tagPublicFunction("Intl.DateTimeFormat.prototype.format", format);
DateTimeFormat.__relevantExtensionKeys = ['ca', 'nu'];
ObjectDefineProperty(DateTimeFormat, 'prototype', { value: new DateTimeFormat(), writable: false, enumerable: false, configurable: false });
setPrototype(DateTimeFormat.prototype, Object.prototype);
ObjectDefineProperty(DateTimeFormat.prototype, 'constructor', { value: DateTimeFormat, writable: true, enumerable: false, configurable: true });
ObjectDefineProperty(DateTimeFormat.prototype, 'format', {
get: tagPublicFunction('get format', function () {
if (typeof this !== 'object') {
platform.raiseNeedObjectOfType("DateTimeFormat.prototype.format", "DateTimeFormat");
}
var hiddenObject = platform.getHiddenObject(this);
if (hiddenObject === undefined || !hiddenObject.__initializedDateTimeFormat) {
platform.raiseNeedObjectOfType("DateTimeFormat.prototype.format", "DateTimeFormat");
}
return hiddenObject.__boundFormat;
}), enumerable: false, configurable: true
});
ObjectDefineProperty(DateTimeFormat.prototype, 'resolvedOptions', {
value: function resolvedOptions() {
if (typeof this !== 'object') {
platform.raiseNeedObjectOfType("DateTimeFormat.prototype.resolvedOptions", "DateTimeFormat");
}
var hiddenObject = platform.getHiddenObject(this);
if (hiddenObject === undefined || !hiddenObject.__initializedDateTimeFormat) {
platform.raiseNeedObjectOfType("DateTimeFormat.prototype.resolvedOptions", "DateTimeFormat");
}
var temp = setPrototype({
locale: hiddenObject.__locale,
calendar: hiddenObject.__calendar, // ca unicode extension
numberingSystem: hiddenObject.__numberingSystem, // nu unicode extension
timeZone: hiddenObject.__timeZone,
hour12: hiddenObject.__hour12,
weekday: hiddenObject.__weekday,
era: hiddenObject.__era,
year: hiddenObject.__year,
month: hiddenObject.__month,
day: hiddenObject.__day,
hour: hiddenObject.__hour,
minute: hiddenObject.__minute,
second: hiddenObject.__second,
timeZoneName: hiddenObject.__timeZoneName
}, null)
var options = setPrototype({}, null);
callInstanceFunc(ArrayInstanceForEach, ObjectGetOwnPropertyNames(temp), function (prop) {
if ((temp[prop] !== undefined || prop === 'timeZone') && callInstanceFunc(ObjectInstanceHasOwnProperty, hiddenObject, "__" + prop)) {
options[prop] = temp[prop];
}
}, hiddenObject);
return setPrototype(options, Object.prototype);
}, writable: true, enumerable: false, configurable: true
});
ObjectDefineProperty(DateTimeFormat, 'supportedLocalesOf', { value: dateTimeFormat_supportedLocalesOf, writable: true, configurable: true });
return DateTimeFormat;
}
}
// 'Init.DateTimeFormat' not defined if reached here. Return 'undefined'
return undefined;
})();
// Initialize Intl properties only if needed
if (InitType === 'Intl') {
ObjectDefineProperty(Intl, "Collator", { value: Collator, writable: true, enumerable: false, configurable: true });
ObjectDefineProperty(Intl, "NumberFormat", { value: NumberFormat, writable: true, enumerable: false, configurable: true });
ObjectDefineProperty(Intl, "DateTimeFormat", { value: DateTimeFormat, writable: true, enumerable: false, configurable: true });
ObjectDefineProperty(Intl, "getCanonicalLocales", { value: getCanonicalLocales, writable: true, enumerable: false, configurable: true });
}
});
#endif
namespace Js
{
const char Library_Bytecode_Intl[] = {
/* 00000000 */ 0x43, 0x68, 0x42, 0x63, 0x3D, 0xE6, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
/* 00000010 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0xFE, 0xD7, 0x02, 0x00, 0xFF,
/* 00000020 */ 0x20, 0x63, 0x01, 0x00, 0xFF, 0x20, 0x63, 0x01, 0x00, 0x35, 0x00, 0x00, 0x00, 0x12, 0x32, 0x00,
/* 00000030 */ 0x00, 0xA6, 0x4D, 0x00, 0x00, 0xFE, 0x6F, 0x01, 0x68, 0x07, 0x00, 0x00, 0x00, 0x80, 0x07, 0x00,
/* 00000040 */ 0x00, 0x00, 0x96, 0x07, 0x00, 0x00, 0x01, 0xAA, 0x07, 0x00, 0x00, 0x00, 0xB2, 0x07, 0x00, 0x00,
/* 00000050 */ 0x00, 0xBE, 0x07, 0x00, 0x00, 0x00, 0xC6, 0x07, 0x00, 0x00, 0x00, 0xCE, 0x07, 0x00, 0x00, 0x00,
/* 00000060 */ 0xDE, 0x07, 0x00, 0x00, 0x00, 0xEA, 0x07, 0x00, 0x00, 0x00, 0x2C, 0x08, 0x00, 0x00, 0x00, 0x76,
/* 00000070 */ 0x08, 0x00, 0x00, 0x00, 0xC4, 0x08, 0x00, 0x00, 0x00, 0xF6, 0x08, 0x00, 0x00, 0x00, 0x00, 0x09,
/* 00000080 */ 0x00, 0x00, 0x00, 0x0C, 0x09, 0x00, 0x00, 0x00, 0x32, 0x09, 0x00, 0x00, 0x00, 0x5A, 0x09, 0x00,
/* 00000090 */ 0x00, 0x01, 0x66, 0x09, 0x00, 0x00, 0x01, 0x70, 0x09, 0x00, 0x00, 0x00, 0x7E, 0x09, 0x00, 0x00,
/* 000000A0 */ 0x01, 0x8A, 0x09, 0x00, 0x00, 0x01, 0x96, 0x09, 0x00, 0x00, 0x01, 0xA6, 0x09, 0x00, 0x00, 0x00,
/* 000000B0 */ 0xB4, 0x09, 0x00, 0x00, 0x01, 0xC0, 0x09, 0x00, 0x00, 0x01, 0xCE, 0x09, 0x00, 0x00, 0x00, 0xDC,
/* 000000C0 */ 0x09, 0x00, 0x00, 0x01, 0xE8, 0x09, 0x00, 0x00, 0x01, 0xFA, 0x09, 0x00, 0x00, 0x00, 0x08, 0x0A,
/* 000000D0 */ 0x00, 0x00, 0x01, 0x16, 0x0A, 0x00, 0x00, 0x00, 0x18, 0x0A, 0x00, 0x00, 0x01, 0x24, 0x0A, 0x00,
/* 000000E0 */ 0x00, 0x01, 0x30, 0x0A, 0x00, 0x00, 0x01, 0x3C, 0x0A, 0x00, 0x00, 0x01, 0x4A, 0x0A, 0x00, 0x00,
/* 000000F0 */ 0x01, 0x56, 0x0A, 0x00, 0x00, 0x00, 0x60, 0x0A, 0x00, 0x00, 0x00, 0x72, 0x0A, 0x00, 0x00, 0x00,
/* 00000100 */ 0x84, 0x0A, 0x00, 0x00, 0x00, 0x9A, 0x0A, 0x00, 0x00, 0x00, 0xB4, 0x0A, 0x00, 0x00, 0x00, 0xCE,
/* 00000110 */ 0x0A, 0x00, 0x00, 0x00, 0xEC, 0x0A, 0x00, 0x00, 0x01, 0x00, 0x0B, 0x00, 0x00, 0x01, 0x24, 0x0B,
/* 00000120 */ 0x00, 0x00, 0x01, 0x4A, 0x0B, 0x00, 0x00, 0x01, 0x5E, 0x0B, 0x00, 0x00, 0x01, 0x7E, 0x0B, 0x00,
/* 00000130 */ 0x00, 0x01, 0xB0, 0x0B, 0x00, 0x00, 0x01, 0xDA, 0x0B, 0x00, 0x00, 0x01, 0x0C, 0x0C, 0x00, 0x00,
/* 00000140 */ 0x01, 0x3A, 0x0C, 0x00, 0x00, 0x01, 0x68, 0x0C, 0x00, 0x00, 0x01, 0x7A, 0x0C, 0x00, 0x00, 0x01,
/* 00000150 */ 0x94, 0x0C, 0x00, 0x00, 0x01, 0xB2, 0x0C, 0x00, 0x00, 0x01, 0xD4, 0x0C, 0x00, 0x00, 0x01, 0xEC,
/* 00000160 */ 0x0C, 0x00, 0x00, 0x01, 0x16, 0x0D, 0x00, 0x00, 0x01, 0x3C, 0x0D, 0x00, 0x00, 0x01, 0x70, 0x0D,
/* 00000170 */ 0x00, 0x00, 0x01, 0xAA, 0x0D, 0x00, 0x00, 0x01, 0xD6, 0x0D, 0x00, 0x00, 0x01, 0x00, 0x0E, 0x00,
/* 00000180 */ 0x00, 0x01, 0x2A, 0x0E, 0x00, 0x00, 0x01, 0x54, 0x0E, 0x00, 0x00, 0x01, 0x78, 0x0E, 0x00, 0x00,
/* 00000190 */ 0x01, 0x9C, 0x0E, 0x00, 0x00, 0x01, 0xC6, 0x0E, 0x00, 0x00, 0x01, 0xEE, 0x0E, 0x00, 0x00, 0x01,
/* 000001A0 */ 0xFE, 0x0E, 0x00, 0x00, 0x01, 0x2A, 0x0F, 0x00, 0x00, 0x01, 0x5E, 0x0F, 0x00, 0x00, 0x01, 0x92,
/* 000001B0 */ 0x0F, 0x00, 0x00, 0x01, 0xB4, 0x0F, 0x00, 0x00, 0x01, 0xD8, 0x0F, 0x00, 0x00, 0x01, 0xFC, 0x0F,
/* 000001C0 */ 0x00, 0x00, 0x01, 0x24, 0x10, 0x00, 0x00, 0x01, 0x4C, 0x10, 0x00, 0x00, 0x01, 0x6A, 0x10, 0x00,
/* 000001D0 */ 0x00, 0x01, 0x96, 0x10, 0x00, 0x00, 0x01, 0xA8, 0x10, 0x00, 0x00, 0x01, 0xDC, 0x10, 0x00, 0x00,
/* 000001E0 */ 0x01, 0x18, 0x11, 0x00, 0x00, 0x01, 0x58, 0x11, 0x00, 0x00, 0x01, 0xA6, 0x11, 0x00, 0x00, 0x01,
/* 000001F0 */ 0xCE, 0x11, 0x00, 0x00, 0x01, 0xE0, 0x11, 0x00, 0x00, 0x01, 0x06, 0x12, 0x00, 0x00, 0x01, 0x26,
/* 00000200 */ 0x12, 0x00, 0x00, 0x01, 0x48, 0x12, 0x00, 0x00, 0x01, 0x72, 0x12, 0x00, 0x00, 0x01, 0xA2, 0x12,
/* 00000210 */ 0x00, 0x00, 0x01, 0xD2, 0x12, 0x00, 0x00, 0x01, 0xF4, 0x12, 0x00, 0x00, 0x01, 0x16, 0x13, 0x00,
/* 00000220 */ 0x00, 0x01, 0x36, 0x13, 0x00, 0x00, 0x01, 0x4E, 0x13, 0x00, 0x00, 0x01, 0x90, 0x13, 0x00, 0x00,
/* 00000230 */ 0x01, 0xC8, 0x13, 0x00, 0x00, 0x01, 0x12, 0x14, 0x00, 0x00, 0x01, 0x52, 0x14, 0x00, 0x00, 0x01,
/* 00000240 */ 0xA0, 0x14, 0x00, 0x00, 0x01, 0xE4, 0x14, 0x00, 0x00, 0x01, 0x16, 0x15, 0x00, 0x00, 0x01, 0x42,
/* 00000250 */ 0x15, 0x00, 0x00, 0x00, 0x48, 0x15, 0x00, 0x00, 0x00, 0xA2, 0x15, 0x00, 0x00, 0x00, 0xCC, 0x15,
/* 00000260 */ 0x00, 0x00, 0x00, 0xD0, 0x15, 0x00, 0x00, 0x00, 0xF8, 0x15, 0x00, 0x00, 0x00, 0x00, 0x16, 0x00,
/* 00000270 */ 0x00, 0x00, 0x0E, 0x16, 0x00, 0x00, 0x00, 0x1E, 0x16, 0x00, 0x00, 0x00, 0x48, 0x16, 0x00, 0x00,
/* 00000280 */ 0x01, 0x5A, 0x16, 0x00, 0x00, 0x01, 0x7A, 0x16, 0x00, 0x00, 0x00, 0x96, 0x16, 0x00, 0x00, 0x00,
/* 00000290 */ 0xB4, 0x16, 0x00, 0x00, 0x00, 0xC2, 0x16, 0x00, 0x00, 0x00, 0xD6, 0x16, 0x00, 0x00, 0x01, 0xE8,
/* 000002A0 */ 0x16, 0x00, 0x00, 0x00, 0xFA, 0x16, 0x00, 0x00, 0x00, 0x0C, 0x17, 0x00, 0x00, 0x00, 0x2E, 0x17,
/* 000002B0 */ 0x00, 0x00, 0x00, 0x40, 0x17, 0x00, 0x00, 0x01, 0x58, 0x17, 0x00, 0x00, 0x00, 0x68, 0x17, 0x00,
/* 000002C0 */ 0x00, 0x00, 0x76, 0x17, 0x00, 0x00, 0x00, 0x84, 0x17, 0x00, 0x00, 0x00, 0x8A, 0x17, 0x00, 0x00,
/* 000002D0 */ 0x00, 0x94, 0x17, 0x00, 0x00, 0x00, 0x9A, 0x17, 0x00, 0x00, 0x00, 0xAE, 0x17, 0x00, 0x00, 0x00,
/* 000002E0 */ 0xB2, 0x17, 0x00, 0x00, 0x00, 0xBA, 0x17, 0x00, 0x00, 0x00, 0xBE, 0x17, 0x00, 0x00, 0x00, 0xD4,
/* 000002F0 */ 0x17, 0x00, 0x00, 0x00, 0xE0, 0x17, 0x00, 0x00, 0x00, 0xEC, 0x17, 0x00, 0x00, 0x00, 0xF4, 0x17,
/* 00000300 */ 0x00, 0x00, 0x00, 0xF8, 0x17, 0x00, 0x00, 0x00, 0xFC, 0x17, 0x00, 0x00, 0x00, 0xB0, 0x18, 0x00,
/* 00000310 */ 0x00, 0x00, 0x4C, 0x19, 0x00, 0x00, 0x00, 0xD2, 0x19, 0x00, 0x00, 0x00, 0xDE, 0x19, 0x00, 0x00,
/* 00000320 */ 0x00, 0xE6, 0x19, 0x00, 0x00, 0x00, 0xFC, 0x19, 0x00, 0x00, 0x00, 0x16, 0x1A, 0x00, 0x00, 0x00,
/* 00000330 */ 0x30, 0x1A, 0x00, 0x00, 0x00, 0x3A, 0x1A, 0x00, 0x00, 0x00, 0x50, 0x1A, 0x00, 0x00, 0x00, 0x5E,
/* 00000340 */ 0x1A, 0x00, 0x00, 0x00, 0x6C, 0x1A, 0x00, 0x00, 0x00, 0x76, 0x1A, 0x00, 0x00, 0x00, 0x84, 0x1A,
/* 00000350 */ 0x00, 0x00, 0x00, 0x98, 0x1A, 0x00, 0x00, 0x00, 0xB2, 0x1A, 0x00, 0x00, 0x00, 0xBE, 0x1A, 0x00,
/* 00000360 */ 0x00, 0x00, 0xCC, 0x1A, 0x00, 0x00, 0x00, 0xD2, 0x1A, 0x00, 0x00, 0x00, 0xDE, 0x1A, 0x00, 0x00,
/* 00000370 */ 0x00, 0xE6, 0x1A, 0x00, 0x00, 0x00, 0xF6, 0x1A, 0x00, 0x00, 0x00, 0x02, 0x1B, 0x00, 0x00, 0x00,
/* 00000380 */ 0x0C, 0x1B, 0x00, 0x00, 0x00, 0x1C, 0x1B, 0x00, 0x00, 0x00, 0x28, 0x1B, 0x00, 0x00, 0x00, 0x32,
/* 00000390 */ 0x1B, 0x00, 0x00, 0x00, 0x38, 0x1B, 0x00, 0x00, 0x00, 0x3C, 0x1B, 0x00, 0x00, 0x01, 0x46, 0x1B,
/* 000003A0 */ 0x00, 0x00, 0x00, 0x54, 0x1B, 0x00, 0x00, 0x00, 0x62, 0x1B, 0x00, 0x00, 0x00, 0x70, 0x1B, 0x00,
/* 000003B0 */ 0x00, 0x01, 0x7E, 0x1B, 0x00, 0x00, 0x01, 0x8A, 0x1B, 0x00, 0x00, 0x01, 0x98, 0x1B, 0x00, 0x00,
/* 000003C0 */ 0x01, 0xB4, 0x1B, 0x00, 0x00, 0x00, 0xC6, 0x1B, 0x00, 0x00, 0x00, 0xE2, 0x1B, 0x00, 0x00, 0x00,
/* 000003D0 */ 0x10, 0x1C, 0x00, 0x00, 0x00, 0x5C, 0x1C, 0x00, 0x00, 0x00, 0xB0, 0x1C, 0x00, 0x00, 0x00, 0x08,
/* 000003E0 */ 0x1D, 0x00, 0x00, 0x00, 0x44, 0x1D, 0x00, 0x00, 0x01, 0x56, 0x1D, 0x00, 0x00, 0x01, 0x88, 0x1D,
/* 000003F0 */ 0x00, 0x00, 0x01, 0xB8, 0x1D, 0x00, 0x00, 0x00, 0xC2, 0x1D, 0x00, 0x00, 0x00, 0x14, 0x1E, 0x00,
/* 00000400 */ 0x00, 0x00, 0x32, 0x1E, 0x00, 0x00, 0x00, 0x6A, 0x1E, 0x00, 0x00, 0x00, 0x78, 0x1E, 0x00, 0x00,
/* 00000410 */ 0x00, 0x86, 0x1E, 0x00, 0x00, 0x00, 0xC4, 0x1E, 0x00, 0x00, 0x00, 0xE0, 0x1E, 0x00, 0x00, 0x00,
/* 00000420 */ 0x20, 0x1F, 0x00, 0x00, 0x00, 0x34, 0x1F, 0x00, 0x00, 0x00, 0x4C, 0x1F, 0x00, 0x00, 0x00, 0x6C,
/* 00000430 */ 0x1F, 0x00, 0x00, 0x00, 0x7C, 0x1F, 0x00, 0x00, 0x00, 0x84, 0x1F, 0x00, 0x00, 0x00, 0x9C, 0x1F,
/* 00000440 */ 0x00, 0x00, 0x01, 0xC2, 0x1F, 0x00, 0x00, 0x00, 0xF2, 0x1F, 0x00, 0x00, 0x01, 0xFE, 0x1F, 0x00,
/* 00000450 */ 0x00, 0x00, 0x08, 0x20, 0x00, 0x00, 0x00, 0x16, 0x20, 0x00, 0x00, 0x00, 0x2E, 0x20, 0x00, 0x00,
/* 00000460 */ 0x00, 0x38, 0x20, 0x00, 0x00, 0x00, 0x46, 0x20, 0x00, 0x00, 0x00, 0x50, 0x20, 0x00, 0x00, 0x00,
/* 00000470 */ 0x60, 0x20, 0x00, 0x00, 0x00, 0x84, 0x20, 0x00, 0x00, 0x01, 0x98, 0x20, 0x00, 0x00, 0x00, 0xA4,
/* 00000480 */ 0x20, 0x00, 0x00, 0x00, 0xB0, 0x20, 0x00, 0x00, 0x00, 0xBC, 0x20, 0x00, 0x00, 0x00, 0xCC, 0x20,
/* 00000490 */ 0x00, 0x00, 0x00, 0xDC, 0x20, 0x00, 0x00, 0x00, 0xE0, 0x20, 0x00, 0x00, 0x00, 0xE4, 0x20, 0x00,
/* 000004A0 */ 0x00, 0x00, 0xE8, 0x20, 0x00, 0x00, 0x01, 0xFC, 0x20, 0x00, 0x00, 0x00, 0x02, 0x21, 0x00, 0x00,
/* 000004B0 */ 0x00, 0x08, 0x21, 0x00, 0x00, 0x00, 0x12, 0x21, 0x00, 0x00, 0x00, 0x18, 0x21, 0x00, 0x00, 0x00,
/* 000004C0 */ 0x2A, 0x21, 0x00, 0x00, 0x00, 0x60, 0x21, 0x00, 0x00, 0x00, 0xA6, 0x21, 0x00, 0x00, 0x01, 0xB6,
/* 000004D0 */ 0x21, 0x00, 0x00, 0x01, 0xC6, 0x21, 0x00, 0x00, 0x01, 0xD6, 0x21, 0x00, 0x00, 0x01, 0xE8, 0x21,
/* 000004E0 */ 0x00, 0x00, 0x01, 0xF0, 0x21, 0x00, 0x00, 0x01, 0xFE, 0x21, 0x00, 0x00, 0x01, 0x08, 0x22, 0x00,
/* 000004F0 */ 0x00, 0x01, 0x12, 0x22, 0x00, 0x00, 0x00, 0x20, 0x22, 0x00, 0x00, 0x00, 0x60, 0x22, 0x00, 0x00,
/* 00000500 */ 0x00, 0x84, 0x22, 0x00, 0x00, 0x00, 0xCA, 0x22, 0x00, 0x00, 0x00, 0xEA, 0x22, 0x00, 0x00, 0x00,
/* 00000510 */ 0xF6, 0x22, 0x00, 0x00, 0x00, 0x08, 0x23, 0x00, 0x00, 0x00, 0x28, 0x23, 0x00, 0x00, 0x00, 0x52,
/* 00000520 */ 0x23, 0x00, 0x00, 0x00, 0x7E, 0x23, 0x00, 0x00, 0x00, 0xAA, 0x23, 0x00, 0x00, 0x00, 0xDC, 0x23,
/* 00000530 */ 0x00, 0x00, 0x00, 0x0E, 0x24, 0x00, 0x00, 0x00, 0x26, 0x24, 0x00, 0x00, 0x00, 0x34, 0x24, 0x00,
/* 00000540 */ 0x00, 0x00, 0x4A, 0x24, 0x00, 0x00, 0x01, 0x6E, 0x24, 0x00, 0x00, 0x01, 0xA6, 0x24, 0x00, 0x00,
/* 00000550 */ 0x01, 0xD4, 0x24, 0x00, 0x00, 0x00, 0xE4, 0x24, 0x00, 0x00, 0x00, 0xF4, 0x24, 0x00, 0x00, 0x00,
/* 00000560 */ 0xFE, 0x24, 0x00, 0x00, 0x00, 0x0C, 0x25, 0x00, 0x00, 0x00, 0x12, 0x25, 0x00, 0x00, 0x00, 0x1C,
/* 00000570 */ 0x25, 0x00, 0x00, 0x01, 0x3C, 0x25, 0x00, 0x00, 0x00, 0x78, 0x25, 0x00, 0x00, 0x00, 0xC6, 0x25,
/* 00000580 */ 0x00, 0x00, 0x01, 0xE0, 0x25, 0x00, 0x00, 0x00, 0xE6, 0x25, 0x00, 0x00, 0x00, 0xF0, 0x25, 0x00,
/* 00000590 */ 0x00, 0x01, 0x14, 0x26, 0x00, 0x00, 0x00, 0x24, 0x26, 0x00, 0x00, 0x01, 0x42, 0x26, 0x00, 0x00,
/* 000005A0 */ 0x00, 0x50, 0x26, 0x00, 0x00, 0x01, 0x6C, 0x26, 0x00, 0x00, 0x00, 0x7C, 0x26, 0x00, 0x00, 0x01,
/* 000005B0 */ 0x9E, 0x26, 0x00, 0x00, 0x00, 0xB0, 0x26, 0x00, 0x00, 0x01, 0xCE, 0x26, 0x00, 0x00, 0x00, 0xDC,
/* 000005C0 */ 0x26, 0x00, 0x00, 0x01, 0xFA, 0x26, 0x00, 0x00, 0x00, 0x08, 0x27, 0x00, 0x00, 0x01, 0x2A, 0x27,
/* 000005D0 */ 0x00, 0x00, 0x00, 0x46, 0x27, 0x00, 0x00, 0x01, 0x60, 0x27, 0x00, 0x00, 0x00, 0x6A, 0x27, 0x00,
/* 000005E0 */ 0x00, 0x01, 0x88, 0x27, 0x00, 0x00, 0x00, 0x96, 0x27, 0x00, 0x00, 0x00, 0xD2, 0x27, 0x00, 0x00,
/* 000005F0 */ 0x00, 0x16, 0x28, 0x00, 0x00, 0x00, 0x5A, 0x28, 0x00, 0x00, 0x00, 0x82, 0x28, 0x00, 0x00, 0x00,
/* 00000600 */ 0xCC, 0x28, 0x00, 0x00, 0x00, 0xD2, 0x28, 0x00, 0x00, 0x01, 0x04, 0x29, 0x00, 0x00, 0x01, 0x28,
/* 00000610 */ 0x29, 0x00, 0x00, 0x01, 0x62, 0x29, 0x00, 0x00, 0x01, 0x8E, 0x29, 0x00, 0x00, 0x01, 0xCA, 0x29,
/* 00000620 */ 0x00, 0x00, 0x01, 0x18, 0x2A, 0x00, 0x00, 0x01, 0x42, 0x2A, 0x00, 0x00, 0x01, 0x74, 0x2A, 0x00,
/* 00000630 */ 0x00, 0x00, 0x7E, 0x2A, 0x00, 0x00, 0x00, 0x86, 0x2A, 0x00, 0x00, 0x00, 0x90, 0x2A, 0x00, 0x00,
/* 00000640 */ 0x00, 0x98, 0x2A, 0x00, 0x00, 0x00, 0xA2, 0x2A, 0x00, 0x00, 0x00, 0xAE, 0x2A, 0x00, 0x00, 0x00,
/* 00000650 */ 0xB6, 0x2A, 0x00, 0x00, 0x00, 0xC0, 0x2A, 0x00, 0x00, 0x00, 0xCE, 0x2A, 0x00, 0x00, 0x00, 0xDC,
/* 00000660 */ 0x2A, 0x00, 0x00, 0x00, 0xEA, 0x2A, 0x00, 0x00, 0x00, 0xF6, 0x2A, 0x00, 0x00, 0x00, 0x22, 0x2B,
/* 00000670 */ 0x00, 0x00, 0x00, 0x2C, 0x2B, 0x00, 0x00, 0x00, 0x4A, 0x2B, 0x00, 0x00, 0x00, 0x5A, 0x2B, 0x00,
/* 00000680 */ 0x00, 0x00, 0x7C, 0x2B, 0x00, 0x00, 0x00, 0x90, 0x2B, 0x00, 0x00, 0x00, 0xAC, 0x2B, 0x00, 0x00,
/* 00000690 */ 0x00, 0xD0, 0x2B, 0x00, 0x00, 0x00, 0xE6, 0x2B, 0x00, 0x00, 0x00, 0x10, 0x2C, 0x00, 0x00, 0x00,
/* 000006A0 */ 0x2C, 0x2C, 0x00, 0x00, 0x00, 0x30, 0x2C, 0x00, 0x00, 0x01, 0x42, 0x2C, 0x00, 0x00, 0x00, 0x48,
/* 000006B0 */ 0x2C, 0x00, 0x00, 0x00, 0x94, 0x2C, 0x00, 0x00, 0x00, 0x5E, 0x2D, 0x00, 0x00, 0x00, 0x74, 0x2D,
/* 000006C0 */ 0x00, 0x00, 0x00, 0xBA, 0x2D, 0x00, 0x00, 0x00, 0xC4, 0x2D, 0x00, 0x00, 0x00, 0xC8, 0x2D, 0x00,
/* 000006D0 */ 0x00, 0x00, 0xCC, 0x2D, 0x00, 0x00, 0x00, 0xD0, 0x2D, 0x00, 0x00, 0x00, 0xE8, 0x2D, 0x00, 0x00,
/* 000006E0 */ 0x00, 0x06, 0x2E, 0x00, 0x00, 0x00, 0x52, 0x2E, 0x00, 0x00, 0x00, 0x32, 0x2F, 0x00, 0x00, 0x00,
/* 000006F0 */ 0x4C, 0x2F, 0x00, 0x00, 0x00, 0x5C, 0x2F, 0x00, 0x00, 0x00, 0x70, 0x2F, 0x00, 0x00, 0x00, 0x84,
/* 00000700 */ 0x2F, 0x00, 0x00, 0x00, 0x06, 0x30, 0x00, 0x00, 0x00, 0x32, 0x30, 0x00, 0x00, 0x00, 0x4A, 0x30,
/* 00000710 */ 0x00, 0x00, 0x00, 0x5C, 0x30, 0x00, 0x00, 0x00, 0x96, 0x30, 0x00, 0x00, 0x00, 0xA8, 0x30, 0x00,
/* 00000720 */ 0x00, 0x00, 0xB8, 0x30, 0x00, 0x00, 0x00, 0xC0, 0x30, 0x00, 0x00, 0x00, 0xDA, 0x30, 0x00, 0x00,
/* 00000730 */ 0x00, 0xE8, 0x30, 0x00, 0x00, 0x00, 0x04, 0x31, 0x00, 0x00, 0x00, 0x10, 0x31, 0x00, 0x00, 0x00,
/* 00000740 */ 0x28, 0x31, 0x00, 0x00, 0x00, 0x40, 0x31, 0x00, 0x00, 0x00, 0x4A, 0x31, 0x00, 0x00, 0x00, 0x64,
/* 00000750 */ 0x31, 0x00, 0x00, 0x00, 0xA4, 0x31, 0x00, 0x00, 0x00, 0xF6, 0x31, 0x00, 0x00, 0x00, 0x08, 0x32,
/* 00000760 */ 0x00, 0x00, 0x01, 0x12, 0x32, 0x00, 0x00, 0x00, 0x47, 0x00, 0x6C, 0x00, 0x6F, 0x00, 0x62, 0x00,
/* 00000770 */ 0x61, 0x00, 0x6C, 0x00, 0x20, 0x00, 0x63, 0x00, 0x6F, 0x00, 0x64, 0x00, 0x65, 0x00, 0x00, 0x00,
/* 00000780 */ 0x75, 0x00, 0x73, 0x00, 0x65, 0x00, 0x20, 0x00, 0x73, 0x00, 0x74, 0x00, 0x72, 0x00, 0x69, 0x00,
/* 00000790 */ 0x63, 0x00, 0x74, 0x00, 0x00, 0x00, 0x4E, 0x00, 0x4F, 0x00, 0x54, 0x00, 0x5F, 0x00, 0x46, 0x00,
/* 000007A0 */ 0x4F, 0x00, 0x55, 0x00, 0x4E, 0x00, 0x44, 0x00, 0x00, 0x00, 0x61, 0x00, 0x62, 0x00, 0x73, 0x00,
/* 000007B0 */ 0x00, 0x00, 0x66, 0x00, 0x6C, 0x00, 0x6F, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x00, 0x00, 0x6D, 0x00,
/* 000007C0 */ 0x61, 0x00, 0x78, 0x00, 0x00, 0x00, 0x70, 0x00, 0x6F, 0x00, 0x77, 0x00, 0x00, 0x00, 0x69, 0x00,
/* 000007D0 */ 0x73, 0x00, 0x56, 0x00, 0x61, 0x00, 0x6C, 0x00, 0x69, 0x00, 0x64, 0x00, 0x00, 0x00, 0x56, 0x00,
/* 000007E0 */ 0x61, 0x00, 0x6C, 0x00, 0x69, 0x00, 0x64, 0x00, 0x00, 0x00, 0x49, 0x00, 0x6E, 0x00, 0x74, 0x00,
/* 000007F0 */ 0x6C, 0x00, 0x2E, 0x00, 0x43, 0x00, 0x6F, 0x00, 0x6C, 0x00, 0x6C, 0x00, 0x61, 0x00, 0x74, 0x00,
/* 00000800 */ 0x6F, 0x00, 0x72, 0x00, 0x2E, 0x00, 0x73, 0x00, 0x75, 0x00, 0x70, 0x00, 0x70, 0x00, 0x6F, 0x00,
/* 00000810 */ 0x72, 0x00, 0x74, 0x00, 0x65, 0x00, 0x64, 0x00, 0x4C, 0x00, 0x6F, 0x00, 0x63, 0x00, 0x61, 0x00,
/* 00000820 */ 0x6C, 0x00, 0x65, 0x00, 0x73, 0x00, 0x4F, 0x00, 0x66, 0x00, 0x00, 0x00, 0x49, 0x00, 0x6E, 0x00,
/* 00000830 */ 0x74, 0x00, 0x6C, 0x00, 0x2E, 0x00, 0x4E, 0x00, 0x75, 0x00, 0x6D, 0x00, 0x62, 0x00, 0x65, 0x00,
/* 00000840 */ 0x72, 0x00, 0x46, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x6D, 0x00, 0x61, 0x00, 0x74, 0x00, 0x2E, 0x00,
/* 00000850 */ 0x73, 0x00, 0x75, 0x00, 0x70, 0x00, 0x70, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x74, 0x00, 0x65, 0x00,
/* 00000860 */ 0x64, 0x00, 0x4C, 0x00, 0x6F, 0x00, 0x63, 0x00, 0x61, 0x00, 0x6C, 0x00, 0x65, 0x00, 0x73, 0x00,
/* 00000870 */ 0x4F, 0x00, 0x66, 0x00, 0x00, 0x00, 0x49, 0x00, 0x6E, 0x00, 0x74, 0x00, 0x6C, 0x00, 0x2E, 0x00,
/* 00000880 */ 0x44, 0x00, 0x61, 0x00, 0x74, 0x00, 0x65, 0x00, 0x54, 0x00, 0x69, 0x00, 0x6D, 0x00, 0x65, 0x00,
/* 00000890 */ 0x46, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x6D, 0x00, 0x61, 0x00, 0x74, 0x00, 0x2E, 0x00, 0x73, 0x00,
/* 000008A0 */ 0x75, 0x00, 0x70, 0x00, 0x70, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x74, 0x00, 0x65, 0x00, 0x64, 0x00,
/* 000008B0 */ 0x4C, 0x00, 0x6F, 0x00, 0x63, 0x00, 0x61, 0x00, 0x6C, 0x00, 0x65, 0x00, 0x73, 0x00, 0x4F, 0x00,
/* 000008C0 */ 0x66, 0x00, 0x00, 0x00, 0x49, 0x00, 0x6E, 0x00, 0x74, 0x00, 0x6C, 0x00, 0x2E, 0x00, 0x67, 0x00,
/* 000008D0 */ 0x65, 0x00, 0x74, 0x00, 0x43, 0x00, 0x61, 0x00, 0x6E, 0x00, 0x6F, 0x00, 0x6E, 0x00, 0x69, 0x00,
/* 000008E0 */ 0x63, 0x00, 0x61, 0x00, 0x6C, 0x00, 0x4C, 0x00, 0x6F, 0x00, 0x63, 0x00, 0x61, 0x00, 0x6C, 0x00,
/* 000008F0 */ 0x65, 0x00, 0x73, 0x00, 0x00, 0x00, 0x6E, 0x00, 0x61, 0x00, 0x6D, 0x00, 0x65, 0x00, 0x00, 0x00,
/* 00000900 */ 0x76, 0x00, 0x61, 0x00, 0x6C, 0x00, 0x75, 0x00, 0x65, 0x00, 0x00, 0x00, 0x73, 0x00, 0x75, 0x00,
/* 00000910 */ 0x70, 0x00, 0x70, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x74, 0x00, 0x65, 0x00, 0x64, 0x00, 0x4C, 0x00,
/* 00000920 */ 0x6F, 0x00, 0x63, 0x00, 0x61, 0x00, 0x6C, 0x00, 0x65, 0x00, 0x73, 0x00, 0x4F, 0x00, 0x66, 0x00,
/* 00000930 */ 0x00, 0x00, 0x67, 0x00, 0x65, 0x00, 0x74, 0x00, 0x43, 0x00, 0x61, 0x00, 0x6E, 0x00, 0x6F, 0x00,
/* 00000940 */ 0x6E, 0x00, 0x69, 0x00, 0x63, 0x00, 0x61, 0x00, 0x6C, 0x00, 0x4C, 0x00, 0x6F, 0x00, 0x63, 0x00,
/* 00000950 */ 0x61, 0x00, 0x6C, 0x00, 0x65, 0x00, 0x73, 0x00, 0x00, 0x00, 0x65, 0x00, 0x73, 0x00, 0x2D, 0x00,
/* 00000960 */ 0x45, 0x00, 0x53, 0x00, 0x00, 0x00, 0x74, 0x00, 0x72, 0x00, 0x61, 0x00, 0x64, 0x00, 0x00, 0x00,
/* 00000970 */ 0x74, 0x00, 0x72, 0x00, 0x61, 0x00, 0x64, 0x00, 0x6E, 0x00, 0x6C, 0x00, 0x00, 0x00, 0x6C, 0x00,
/* 00000980 */ 0x76, 0x00, 0x2D, 0x00, 0x4C, 0x00, 0x56, 0x00, 0x00, 0x00, 0x64, 0x00, 0x65, 0x00, 0x2D, 0x00,
/* 00000990 */ 0x44, 0x00, 0x45, 0x00, 0x00, 0x00, 0x70, 0x00, 0x68, 0x00, 0x6F, 0x00, 0x6E, 0x00, 0x65, 0x00,
/* 000009A0 */ 0x62, 0x00, 0x6B, 0x00, 0x00, 0x00, 0x70, 0x00, 0x68, 0x00, 0x6F, 0x00, 0x6E, 0x00, 0x65, 0x00,
/* 000009B0 */ 0x62, 0x00, 0x00, 0x00, 0x6A, 0x00, 0x61, 0x00, 0x2D, 0x00, 0x4A, 0x00, 0x50, 0x00, 0x00, 0x00,
/* 000009C0 */ 0x75, 0x00, 0x6E, 0x00, 0x69, 0x00, 0x68, 0x00, 0x61, 0x00, 0x6E, 0x00, 0x00, 0x00, 0x72, 0x00,
/* 000009D0 */ 0x61, 0x00, 0x64, 0x00, 0x73, 0x00, 0x74, 0x00, 0x72, 0x00, 0x00, 0x00, 0x7A, 0x00, 0x68, 0x00,
/* 000009E0 */ 0x2D, 0x00, 0x54, 0x00, 0x57, 0x00, 0x00, 0x00, 0x70, 0x00, 0x68, 0x00, 0x6F, 0x00, 0x6E, 0x00,
/* 000009F0 */ 0x65, 0x00, 0x74, 0x00, 0x69, 0x00, 0x63, 0x00, 0x00, 0x00, 0x70, 0x00, 0x72, 0x00, 0x6F, 0x00,
/* 00000A00 */ 0x6E, 0x00, 0x75, 0x00, 0x6E, 0x00, 0x00, 0x00, 0x73, 0x00, 0x74, 0x00, 0x72, 0x00, 0x6F, 0x00,
/* 00000A10 */ 0x6B, 0x00, 0x65, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7A, 0x00, 0x68, 0x00, 0x2D, 0x00, 0x48, 0x00,
/* 00000A20 */ 0x4B, 0x00, 0x00, 0x00, 0x7A, 0x00, 0x68, 0x00, 0x2D, 0x00, 0x4D, 0x00, 0x4F, 0x00, 0x00, 0x00,
/* 00000A30 */ 0x7A, 0x00, 0x68, 0x00, 0x2D, 0x00, 0x43, 0x00, 0x4E, 0x00, 0x00, 0x00, 0x70, 0x00, 0x69, 0x00,
/* 00000A40 */ 0x6E, 0x00, 0x79, 0x00, 0x69, 0x00, 0x6E, 0x00, 0x00, 0x00, 0x7A, 0x00, 0x68, 0x00, 0x2D, 0x00,
/* 00000A50 */ 0x53, 0x00, 0x47, 0x00, 0x00, 0x00, 0x49, 0x00, 0x6E, 0x00, 0x74, 0x00, 0x6C, 0x00, 0x00, 0x00,
/* 00000A60 */ 0x43, 0x00, 0x6F, 0x00, 0x6C, 0x00, 0x6C, 0x00, 0x61, 0x00, 0x74, 0x00, 0x6F, 0x00, 0x72, 0x00,
/* 00000A70 */ 0x00, 0x00, 0x77, 0x00, 0x72, 0x00, 0x69, 0x00, 0x74, 0x00, 0x61, 0x00, 0x62, 0x00, 0x6C, 0x00,
/* 00000A80 */ 0x65, 0x00, 0x00, 0x00, 0x65, 0x00, 0x6E, 0x00, 0x75, 0x00, 0x6D, 0x00, 0x65, 0x00, 0x72, 0x00,
/* 00000A90 */ 0x61, 0x00, 0x62, 0x00, 0x6C, 0x00, 0x65, 0x00, 0x00, 0x00, 0x63, 0x00, 0x6F, 0x00, 0x6E, 0x00,
/* 00000AA0 */ 0x66, 0x00, 0x69, 0x00, 0x67, 0x00, 0x75, 0x00, 0x72, 0x00, 0x61, 0x00, 0x62, 0x00, 0x6C, 0x00,
/* 00000AB0 */ 0x65, 0x00, 0x00, 0x00, 0x4E, 0x00, 0x75, 0x00, 0x6D, 0x00, 0x62, 0x00, 0x65, 0x00, 0x72, 0x00,
/* 00000AC0 */ 0x46, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x6D, 0x00, 0x61, 0x00, 0x74, 0x00, 0x00, 0x00, 0x44, 0x00,
/* 00000AD0 */ 0x61, 0x00, 0x74, 0x00, 0x65, 0x00, 0x54, 0x00, 0x69, 0x00, 0x6D, 0x00, 0x65, 0x00, 0x46, 0x00,
/* 00000AE0 */ 0x6F, 0x00, 0x72, 0x00, 0x6D, 0x00, 0x61, 0x00, 0x74, 0x00, 0x00, 0x00, 0x75, 0x00, 0x73, 0x00,
/* 00000AF0 */ 0x65, 0x00, 0x43, 0x00, 0x61, 0x00, 0x63, 0x00, 0x68, 0x00, 0x65, 0x00, 0x73, 0x00, 0x00, 0x00,
/* 00000B00 */ 0x6C, 0x00, 0x6F, 0x00, 0x63, 0x00, 0x61, 0x00, 0x6C, 0x00, 0x65, 0x00, 0x4C, 0x00, 0x6F, 0x00,
/* 00000B10 */ 0x6F, 0x00, 0x6B, 0x00, 0x75, 0x00, 0x70, 0x00, 0x43, 0x00, 0x61, 0x00, 0x63, 0x00, 0x68, 0x00,
/* 00000B20 */ 0x65, 0x00, 0x00, 0x00, 0x6C, 0x00, 0x6F, 0x00, 0x63, 0x00, 0x61, 0x00, 0x6C, 0x00, 0x65, 0x00,
/* 00000B30 */ 0x42, 0x00, 0x65, 0x00, 0x73, 0x00, 0x74, 0x00, 0x46, 0x00, 0x69, 0x00, 0x74, 0x00, 0x43, 0x00,
/* 00000B40 */ 0x61, 0x00, 0x63, 0x00, 0x68, 0x00, 0x65, 0x00, 0x00, 0x00, 0x47, 0x00, 0x65, 0x00, 0x74, 0x00,
/* 00000B50 */ 0x4F, 0x00, 0x70, 0x00, 0x74, 0x00, 0x69, 0x00, 0x6F, 0x00, 0x6E, 0x00, 0x00, 0x00, 0x47, 0x00,
/* 00000B60 */ 0x65, 0x00, 0x74, 0x00, 0x4E, 0x00, 0x75, 0x00, 0x6D, 0x00, 0x62, 0x00, 0x65, 0x00, 0x72, 0x00,
/* 00000B70 */ 0x4F, 0x00, 0x70, 0x00, 0x74, 0x00, 0x69, 0x00, 0x6F, 0x00, 0x6E, 0x00, 0x00, 0x00, 0x49, 0x00,
/* 00000B80 */ 0x6E, 0x00, 0x69, 0x00, 0x74, 0x00, 0x69, 0x00, 0x61, 0x00, 0x6C, 0x00, 0x69, 0x00, 0x7A, 0x00,
/* 00000B90 */ 0x65, 0x00, 0x43, 0x00, 0x75, 0x00, 0x72, 0x00, 0x72, 0x00, 0x65, 0x00, 0x6E, 0x00, 0x63, 0x00,
/* 00000BA0 */ 0x79, 0x00, 0x52, 0x00, 0x65, 0x00, 0x67, 0x00, 0x45, 0x00, 0x78, 0x00, 0x70, 0x00, 0x00, 0x00,
/* 00000BB0 */ 0x49, 0x00, 0x6E, 0x00, 0x69, 0x00, 0x74, 0x00, 0x69, 0x00, 0x61, 0x00, 0x6C, 0x00, 0x69, 0x00,
/* 00000BC0 */ 0x7A, 0x00, 0x65, 0x00, 0x4C, 0x00, 0x61, 0x00, 0x6E, 0x00, 0x67, 0x00, 0x54, 0x00, 0x61, 0x00,
/* 00000BD0 */ 0x67, 0x00, 0x52, 0x00, 0x45, 0x00, 0x73, 0x00, 0x00, 0x00, 0x49, 0x00, 0x73, 0x00, 0x57, 0x00,
/* 00000BE0 */ 0x65, 0x00, 0x6C, 0x00, 0x6C, 0x00, 0x46, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x6D, 0x00, 0x65, 0x00,
/* 00000BF0 */ 0x64, 0x00, 0x43, 0x00, 0x75, 0x00, 0x72, 0x00, 0x72, 0x00, 0x65, 0x00, 0x6E, 0x00, 0x63, 0x00,
/* 00000C00 */ 0x79, 0x00, 0x43, 0x00, 0x6F, 0x00, 0x64, 0x00, 0x65, 0x00, 0x00, 0x00, 0x43, 0x00, 0x61, 0x00,
/* 00000C10 */ 0x6E, 0x00, 0x6F, 0x00, 0x6E, 0x00, 0x69, 0x00, 0x63, 0x00, 0x61, 0x00, 0x6C, 0x00, 0x69, 0x00,
/* 00000C20 */ 0x7A, 0x00, 0x65, 0x00, 0x4C, 0x00, 0x6F, 0x00, 0x63, 0x00, 0x61, 0x00, 0x6C, 0x00, 0x65, 0x00,
/* 00000C30 */ 0x4C, 0x00, 0x69, 0x00, 0x73, 0x00, 0x74, 0x00, 0x00, 0x00, 0x4C, 0x00, 0x6F, 0x00, 0x6F, 0x00,
/* 00000C40 */ 0x6B, 0x00, 0x75, 0x00, 0x70, 0x00, 0x53, 0x00, 0x75, 0x00, 0x70, 0x00, 0x70, 0x00, 0x6F, 0x00,
/* 00000C50 */ 0x72, 0x00, 0x74, 0x00, 0x65, 0x00, 0x64, 0x00, 0x4C, 0x00, 0x6F, 0x00, 0x63, 0x00, 0x61, 0x00,
/* 00000C60 */ 0x6C, 0x00, 0x65, 0x00, 0x73, 0x00, 0x00, 0x00, 0x70, 0x00, 0x6C, 0x00, 0x61, 0x00, 0x74, 0x00,
/* 00000C70 */ 0x66, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x6D, 0x00, 0x00, 0x00, 0x73, 0x00, 0x65, 0x00, 0x74, 0x00,
/* 00000C80 */ 0x50, 0x00, 0x72, 0x00, 0x6F, 0x00, 0x74, 0x00, 0x6F, 0x00, 0x74, 0x00, 0x79, 0x00, 0x70, 0x00,
/* 00000C90 */ 0x65, 0x00, 0x00, 0x00, 0x67, 0x00, 0x65, 0x00, 0x74, 0x00, 0x41, 0x00, 0x72, 0x00, 0x72, 0x00,
/* 00000CA0 */ 0x61, 0x00, 0x79, 0x00, 0x4C, 0x00, 0x65, 0x00, 0x6E, 0x00, 0x67, 0x00, 0x74, 0x00, 0x68, 0x00,
/* 00000CB0 */ 0x00, 0x00, 0x63, 0x00, 0x61, 0x00, 0x6C, 0x00, 0x6C, 0x00, 0x49, 0x00, 0x6E, 0x00, 0x73, 0x00,
/* 00000CC0 */ 0x74, 0x00, 0x61, 0x00, 0x6E, 0x00, 0x63, 0x00, 0x65, 0x00, 0x46, 0x00, 0x75, 0x00, 0x6E, 0x00,
/* 00000CD0 */ 0x63, 0x00, 0x00, 0x00, 0x52, 0x00, 0x61, 0x00, 0x69, 0x00, 0x73, 0x00, 0x65, 0x00, 0x41, 0x00,
/* 00000CE0 */ 0x73, 0x00, 0x73, 0x00, 0x65, 0x00, 0x72, 0x00, 0x74, 0x00, 0x00, 0x00, 0x4F, 0x00, 0x62, 0x00,
/* 00000CF0 */ 0x6A, 0x00, 0x65, 0x00, 0x63, 0x00, 0x74, 0x00, 0x47, 0x00, 0x65, 0x00, 0x74, 0x00, 0x50, 0x00,
/* 00000D00 */ 0x72, 0x00, 0x6F, 0x00, 0x74, 0x00, 0x6F, 0x00, 0x74, 0x00, 0x79, 0x00, 0x70, 0x00, 0x65, 0x00,
/* 00000D10 */ 0x4F, 0x00, 0x66, 0x00, 0x00, 0x00, 0x4F, 0x00, 0x62, 0x00, 0x6A, 0x00, 0x65, 0x00, 0x63, 0x00,
/* 00000D20 */ 0x74, 0x00, 0x49, 0x00, 0x73, 0x00, 0x45, 0x00, 0x78, 0x00, 0x74, 0x00, 0x65, 0x00, 0x6E, 0x00,
/* 00000D30 */ 0x73, 0x00, 0x69, 0x00, 0x62, 0x00, 0x6C, 0x00, 0x65, 0x00, 0x00, 0x00, 0x4F, 0x00, 0x62, 0x00,
/* 00000D40 */ 0x6A, 0x00, 0x65, 0x00, 0x63, 0x00, 0x74, 0x00, 0x47, 0x00, 0x65, 0x00, 0x74, 0x00, 0x4F, 0x00,
/* 00000D50 */ 0x77, 0x00, 0x6E, 0x00, 0x50, 0x00, 0x72, 0x00, 0x6F, 0x00, 0x70, 0x00, 0x65, 0x00, 0x72, 0x00,
/* 00000D60 */ 0x74, 0x00, 0x79, 0x00, 0x4E, 0x00, 0x61, 0x00, 0x6D, 0x00, 0x65, 0x00, 0x73, 0x00, 0x00, 0x00,
/* 00000D70 */ 0x4F, 0x00, 0x62, 0x00, 0x6A, 0x00, 0x65, 0x00, 0x63, 0x00, 0x74, 0x00, 0x49, 0x00, 0x6E, 0x00,
/* 00000D80 */ 0x73, 0x00, 0x74, 0x00, 0x61, 0x00, 0x6E, 0x00, 0x63, 0x00, 0x65, 0x00, 0x48, 0x00, 0x61, 0x00,
/* 00000D90 */ 0x73, 0x00, 0x4F, 0x00, 0x77, 0x00, 0x6E, 0x00, 0x50, 0x00, 0x72, 0x00, 0x6F, 0x00, 0x70, 0x00,
/* 00000DA0 */ 0x65, 0x00, 0x72, 0x00, 0x74, 0x00, 0x79, 0x00, 0x00, 0x00, 0x5F, 0x00, 0x6F, 0x00, 0x62, 0x00,
/* 00000DB0 */ 0x6A, 0x00, 0x65, 0x00, 0x63, 0x00, 0x74, 0x00, 0x44, 0x00, 0x65, 0x00, 0x66, 0x00, 0x69, 0x00,
/* 00000DC0 */ 0x6E, 0x00, 0x65, 0x00, 0x50, 0x00, 0x72, 0x00, 0x6F, 0x00, 0x70, 0x00, 0x65, 0x00, 0x72, 0x00,
/* 00000DD0 */ 0x74, 0x00, 0x79, 0x00, 0x00, 0x00, 0x4F, 0x00, 0x62, 0x00, 0x6A, 0x00, 0x65, 0x00, 0x63, 0x00,
/* 00000DE0 */ 0x74, 0x00, 0x44, 0x00, 0x65, 0x00, 0x66, 0x00, 0x69, 0x00, 0x6E, 0x00, 0x65, 0x00, 0x50, 0x00,
/* 00000DF0 */ 0x72, 0x00, 0x6F, 0x00, 0x70, 0x00, 0x65, 0x00, 0x72, 0x00, 0x74, 0x00, 0x79, 0x00, 0x00, 0x00,
/* 00000E00 */ 0x41, 0x00, 0x72, 0x00, 0x72, 0x00, 0x61, 0x00, 0x79, 0x00, 0x49, 0x00, 0x6E, 0x00, 0x73, 0x00,
/* 00000E10 */ 0x74, 0x00, 0x61, 0x00, 0x6E, 0x00, 0x63, 0x00, 0x65, 0x00, 0x46, 0x00, 0x6F, 0x00, 0x72, 0x00,
/* 00000E20 */ 0x45, 0x00, 0x61, 0x00, 0x63, 0x00, 0x68, 0x00, 0x00, 0x00, 0x41, 0x00, 0x72, 0x00, 0x72, 0x00,
/* 00000E30 */ 0x61, 0x00, 0x79, 0x00, 0x49, 0x00, 0x6E, 0x00, 0x73, 0x00, 0x74, 0x00, 0x61, 0x00, 0x6E, 0x00,
/* 00000E40 */ 0x63, 0x00, 0x65, 0x00, 0x49, 0x00, 0x6E, 0x00, 0x64, 0x00, 0x65, 0x00, 0x78, 0x00, 0x4F, 0x00,
/* 00000E50 */ 0x66, 0x00, 0x00, 0x00, 0x41, 0x00, 0x72, 0x00, 0x72, 0x00, 0x61, 0x00, 0x79, 0x00, 0x49, 0x00,
/* 00000E60 */ 0x6E, 0x00, 0x73, 0x00, 0x74, 0x00, 0x61, 0x00, 0x6E, 0x00, 0x63, 0x00, 0x65, 0x00, 0x50, 0x00,
/* 00000E70 */ 0x75, 0x00, 0x73, 0x00, 0x68, 0x00, 0x00, 0x00, 0x41, 0x00, 0x72, 0x00, 0x72, 0x00, 0x61, 0x00,
/* 00000E80 */ 0x79, 0x00, 0x49, 0x00, 0x6E, 0x00, 0x73, 0x00, 0x74, 0x00, 0x61, 0x00, 0x6E, 0x00, 0x63, 0x00,
/* 00000E90 */ 0x65, 0x00, 0x4A, 0x00, 0x6F, 0x00, 0x69, 0x00, 0x6E, 0x00, 0x00, 0x00, 0x46, 0x00, 0x75, 0x00,
/* 00000EA0 */ 0x6E, 0x00, 0x63, 0x00, 0x74, 0x00, 0x69, 0x00, 0x6F, 0x00, 0x6E, 0x00, 0x49, 0x00, 0x6E, 0x00,
/* 00000EB0 */ 0x73, 0x00, 0x74, 0x00, 0x61, 0x00, 0x6E, 0x00, 0x63, 0x00, 0x65, 0x00, 0x42, 0x00, 0x69, 0x00,
/* 00000EC0 */ 0x6E, 0x00, 0x64, 0x00, 0x00, 0x00, 0x44, 0x00, 0x61, 0x00, 0x74, 0x00, 0x65, 0x00, 0x49, 0x00,
/* 00000ED0 */ 0x6E, 0x00, 0x73, 0x00, 0x74, 0x00, 0x61, 0x00, 0x6E, 0x00, 0x63, 0x00, 0x65, 0x00, 0x47, 0x00,
/* 00000EE0 */ 0x65, 0x00, 0x74, 0x00, 0x44, 0x00, 0x61, 0x00, 0x74, 0x00, 0x65, 0x00, 0x00, 0x00, 0x44, 0x00,
/* 00000EF0 */ 0x61, 0x00, 0x74, 0x00, 0x65, 0x00, 0x4E, 0x00, 0x6F, 0x00, 0x77, 0x00, 0x00, 0x00, 0x53, 0x00,
/* 00000F00 */ 0x74, 0x00, 0x72, 0x00, 0x69, 0x00, 0x6E, 0x00, 0x67, 0x00, 0x49, 0x00, 0x6E, 0x00, 0x73, 0x00,
/* 00000F10 */ 0x74, 0x00, 0x61, 0x00, 0x6E, 0x00, 0x63, 0x00, 0x65, 0x00, 0x52, 0x00, 0x65, 0x00, 0x70, 0x00,
/* 00000F20 */ 0x6C, 0x00, 0x61, 0x00, 0x63, 0x00, 0x65, 0x00, 0x00, 0x00, 0x53, 0x00, 0x74, 0x00, 0x72, 0x00,
/* 00000F30 */ 0x69, 0x00, 0x6E, 0x00, 0x67, 0x00, 0x49, 0x00, 0x6E, 0x00, 0x73, 0x00, 0x74, 0x00, 0x61, 0x00,
/* 00000F40 */ 0x6E, 0x00, 0x63, 0x00, 0x65, 0x00, 0x54, 0x00, 0x6F, 0x00, 0x4C, 0x00, 0x6F, 0x00, 0x77, 0x00,
/* 00000F50 */ 0x65, 0x00, 0x72, 0x00, 0x43, 0x00, 0x61, 0x00, 0x73, 0x00, 0x65, 0x00, 0x00, 0x00, 0x53, 0x00,
/* 00000F60 */ 0x74, 0x00, 0x72, 0x00, 0x69, 0x00, 0x6E, 0x00, 0x67, 0x00, 0x49, 0x00, 0x6E, 0x00, 0x73, 0x00,
/* 00000F70 */ 0x74, 0x00, 0x61, 0x00, 0x6E, 0x00, 0x63, 0x00, 0x65, 0x00, 0x54, 0x00, 0x6F, 0x00, 0x55, 0x00,
/* 00000F80 */ 0x70, 0x00, 0x70, 0x00, 0x65, 0x00, 0x72, 0x00, 0x43, 0x00, 0x61, 0x00, 0x73, 0x00, 0x65, 0x00,
/* 00000F90 */ 0x00, 0x00, 0x66, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x45, 0x00, 0x61, 0x00, 0x63, 0x00, 0x68, 0x00,
/* 00000FA0 */ 0x49, 0x00, 0x66, 0x00, 0x50, 0x00, 0x72, 0x00, 0x65, 0x00, 0x73, 0x00, 0x65, 0x00, 0x6E, 0x00,
/* 00000FB0 */ 0x74, 0x00, 0x00, 0x00, 0x74, 0x00, 0x68, 0x00, 0x72, 0x00, 0x6F, 0x00, 0x77, 0x00, 0x45, 0x00,
/* 00000FC0 */ 0x78, 0x00, 0x49, 0x00, 0x66, 0x00, 0x4F, 0x00, 0x4F, 0x00, 0x4D, 0x00, 0x4F, 0x00, 0x72, 0x00,
/* 00000FD0 */ 0x53, 0x00, 0x4F, 0x00, 0x45, 0x00, 0x00, 0x00, 0x74, 0x00, 0x61, 0x00, 0x67, 0x00, 0x50, 0x00,
/* 00000FE0 */ 0x75, 0x00, 0x62, 0x00, 0x6C, 0x00, 0x69, 0x00, 0x63, 0x00, 0x46, 0x00, 0x75, 0x00, 0x6E, 0x00,
/* 00000FF0 */ 0x63, 0x00, 0x74, 0x00, 0x69, 0x00, 0x6F, 0x00, 0x6E, 0x00, 0x00, 0x00, 0x67, 0x00, 0x65, 0x00,
/* 00001000 */ 0x74, 0x00, 0x45, 0x00, 0x78, 0x00, 0x74, 0x00, 0x65, 0x00, 0x6E, 0x00, 0x73, 0x00, 0x69, 0x00,
/* 00001010 */ 0x6F, 0x00, 0x6E, 0x00, 0x53, 0x00, 0x75, 0x00, 0x62, 0x00, 0x74, 0x00, 0x61, 0x00, 0x67, 0x00,
/* 00001020 */ 0x73, 0x00, 0x00, 0x00, 0x72, 0x00, 0x65, 0x00, 0x73, 0x00, 0x6F, 0x00, 0x6C, 0x00, 0x76, 0x00,
/* 00001030 */ 0x65, 0x00, 0x4C, 0x00, 0x6F, 0x00, 0x63, 0x00, 0x61, 0x00, 0x6C, 0x00, 0x65, 0x00, 0x48, 0x00,
/* 00001040 */ 0x65, 0x00, 0x6C, 0x00, 0x70, 0x00, 0x65, 0x00, 0x72, 0x00, 0x00, 0x00, 0x72, 0x00, 0x65, 0x00,
/* 00001050 */ 0x73, 0x00, 0x6F, 0x00, 0x6C, 0x00, 0x76, 0x00, 0x65, 0x00, 0x4C, 0x00, 0x6F, 0x00, 0x63, 0x00,
/* 00001060 */ 0x61, 0x00, 0x6C, 0x00, 0x65, 0x00, 0x73, 0x00, 0x00, 0x00, 0x73, 0x00, 0x74, 0x00, 0x72, 0x00,
/* 00001070 */ 0x69, 0x00, 0x70, 0x00, 0x70, 0x00, 0x65, 0x00, 0x64, 0x00, 0x44, 0x00, 0x65, 0x00, 0x66, 0x00,
/* 00001080 */ 0x61, 0x00, 0x75, 0x00, 0x6C, 0x00, 0x74, 0x00, 0x4C, 0x00, 0x6F, 0x00, 0x63, 0x00, 0x61, 0x00,
/* 00001090 */ 0x6C, 0x00, 0x65, 0x00, 0x00, 0x00, 0x49, 0x00, 0x6E, 0x00, 0x74, 0x00, 0x65, 0x00, 0x72, 0x00,
/* 000010A0 */ 0x6E, 0x00, 0x61, 0x00, 0x6C, 0x00, 0x00, 0x00, 0x73, 0x00, 0x75, 0x00, 0x70, 0x00, 0x70, 0x00,
/* 000010B0 */ 0x6F, 0x00, 0x72, 0x00, 0x74, 0x00, 0x65, 0x00, 0x64, 0x00, 0x4C, 0x00, 0x6F, 0x00, 0x63, 0x00,
/* 000010C0 */ 0x61, 0x00, 0x6C, 0x00, 0x65, 0x00, 0x73, 0x00, 0x4F, 0x00, 0x66, 0x00, 0x57, 0x00, 0x72, 0x00,
/* 000010D0 */ 0x61, 0x00, 0x70, 0x00, 0x70, 0x00, 0x65, 0x00, 0x72, 0x00, 0x00, 0x00, 0x63, 0x00, 0x61, 0x00,
/* 000010E0 */ 0x6E, 0x00, 0x6F, 0x00, 0x6E, 0x00, 0x69, 0x00, 0x63, 0x00, 0x61, 0x00, 0x6C, 0x00, 0x69, 0x00,
/* 000010F0 */ 0x7A, 0x00, 0x65, 0x00, 0x4C, 0x00, 0x6F, 0x00, 0x63, 0x00, 0x61, 0x00, 0x6C, 0x00, 0x65, 0x00,
/* 00001100 */ 0x4C, 0x00, 0x69, 0x00, 0x73, 0x00, 0x74, 0x00, 0x57, 0x00, 0x72, 0x00, 0x61, 0x00, 0x70, 0x00,
/* 00001110 */ 0x70, 0x00, 0x65, 0x00, 0x72, 0x00, 0x00, 0x00, 0x6C, 0x00, 0x6F, 0x00, 0x63, 0x00, 0x61, 0x00,
/* 00001120 */ 0x6C, 0x00, 0x65, 0x00, 0x73, 0x00, 0x41, 0x00, 0x63, 0x00, 0x63, 0x00, 0x65, 0x00, 0x70, 0x00,
/* 00001130 */ 0x74, 0x00, 0x69, 0x00, 0x6E, 0x00, 0x67, 0x00, 0x43, 0x00, 0x6F, 0x00, 0x6C, 0x00, 0x6C, 0x00,
/* 00001140 */ 0x61, 0x00, 0x74, 0x00, 0x69, 0x00, 0x6F, 0x00, 0x6E, 0x00, 0x56, 0x00, 0x61, 0x00, 0x6C, 0x00,
/* 00001150 */ 0x75, 0x00, 0x65, 0x00, 0x73, 0x00, 0x00, 0x00, 0x72, 0x00, 0x65, 0x00, 0x76, 0x00, 0x65, 0x00,
/* 00001160 */ 0x72, 0x00, 0x73, 0x00, 0x65, 0x00, 0x4C, 0x00, 0x6F, 0x00, 0x63, 0x00, 0x61, 0x00, 0x6C, 0x00,
/* 00001170 */ 0x65, 0x00, 0x73, 0x00, 0x41, 0x00, 0x63, 0x00, 0x63, 0x00, 0x65, 0x00, 0x70, 0x00, 0x74, 0x00,
/* 00001180 */ 0x69, 0x00, 0x6E, 0x00, 0x67, 0x00, 0x43, 0x00, 0x6F, 0x00, 0x6C, 0x00, 0x6C, 0x00, 0x61, 0x00,
/* 00001190 */ 0x74, 0x00, 0x69, 0x00, 0x6F, 0x00, 0x6E, 0x00, 0x56, 0x00, 0x61, 0x00, 0x6C, 0x00, 0x75, 0x00,
/* 000011A0 */ 0x65, 0x00, 0x73, 0x00, 0x00, 0x00, 0x6D, 0x00, 0x61, 0x00, 0x70, 0x00, 0x70, 0x00, 0x65, 0x00,
/* 000011B0 */ 0x64, 0x00, 0x44, 0x00, 0x65, 0x00, 0x66, 0x00, 0x61, 0x00, 0x75, 0x00, 0x6C, 0x00, 0x74, 0x00,
/* 000011C0 */ 0x4C, 0x00, 0x6F, 0x00, 0x63, 0x00, 0x61, 0x00, 0x6C, 0x00, 0x65, 0x00, 0x00, 0x00, 0x49, 0x00,
/* 000011D0 */ 0x6E, 0x00, 0x69, 0x00, 0x74, 0x00, 0x54, 0x00, 0x79, 0x00, 0x70, 0x00, 0x65, 0x00, 0x00, 0x00,
/* 000011E0 */ 0x69, 0x00, 0x73, 0x00, 0x50, 0x00, 0x6C, 0x00, 0x61, 0x00, 0x74, 0x00, 0x66, 0x00, 0x6F, 0x00,
/* 000011F0 */ 0x72, 0x00, 0x6D, 0x00, 0x55, 0x00, 0x73, 0x00, 0x69, 0x00, 0x6E, 0x00, 0x67, 0x00, 0x49, 0x00,
/* 00001200 */ 0x43, 0x00, 0x55, 0x00, 0x00, 0x00, 0x5F, 0x00, 0x5F, 0x00, 0x64, 0x00, 0x65, 0x00, 0x66, 0x00,
/* 00001210 */ 0x61, 0x00, 0x75, 0x00, 0x6C, 0x00, 0x74, 0x00, 0x4C, 0x00, 0x6F, 0x00, 0x63, 0x00, 0x61, 0x00,
/* 00001220 */ 0x6C, 0x00, 0x65, 0x00, 0x00, 0x00, 0x47, 0x00, 0x65, 0x00, 0x74, 0x00, 0x44, 0x00, 0x65, 0x00,
/* 00001230 */ 0x66, 0x00, 0x61, 0x00, 0x75, 0x00, 0x6C, 0x00, 0x74, 0x00, 0x4C, 0x00, 0x6F, 0x00, 0x63, 0x00,
/* 00001240 */ 0x61, 0x00, 0x6C, 0x00, 0x65, 0x00, 0x00, 0x00, 0x43, 0x00, 0x72, 0x00, 0x65, 0x00, 0x61, 0x00,
/* 00001250 */ 0x74, 0x00, 0x65, 0x00, 0x44, 0x00, 0x61, 0x00, 0x74, 0x00, 0x65, 0x00, 0x54, 0x00, 0x69, 0x00,
/* 00001260 */ 0x6D, 0x00, 0x65, 0x00, 0x46, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x6D, 0x00, 0x61, 0x00, 0x74, 0x00,
/* 00001270 */ 0x00, 0x00, 0x49, 0x00, 0x73, 0x00, 0x57, 0x00, 0x65, 0x00, 0x6C, 0x00, 0x6C, 0x00, 0x46, 0x00,
/* 00001280 */ 0x6F, 0x00, 0x72, 0x00, 0x6D, 0x00, 0x65, 0x00, 0x64, 0x00, 0x4C, 0x00, 0x61, 0x00, 0x6E, 0x00,
/* 00001290 */ 0x67, 0x00, 0x75, 0x00, 0x61, 0x00, 0x67, 0x00, 0x65, 0x00, 0x54, 0x00, 0x61, 0x00, 0x67, 0x00,
/* 000012A0 */ 0x00, 0x00, 0x5F, 0x00, 0x5F, 0x00, 0x73, 0x00, 0x74, 0x00, 0x72, 0x00, 0x69, 0x00, 0x70, 0x00,
/* 000012B0 */ 0x70, 0x00, 0x65, 0x00, 0x64, 0x00, 0x44, 0x00, 0x65, 0x00, 0x66, 0x00, 0x61, 0x00, 0x75, 0x00,
/* 000012C0 */ 0x6C, 0x00, 0x74, 0x00, 0x4C, 0x00, 0x6F, 0x00, 0x63, 0x00, 0x61, 0x00, 0x6C, 0x00, 0x65, 0x00,
/* 000012D0 */ 0x00, 0x00, 0x43, 0x00, 0x55, 0x00, 0x52, 0x00, 0x52, 0x00, 0x45, 0x00, 0x4E, 0x00, 0x43, 0x00,
/* 000012E0 */ 0x59, 0x00, 0x5F, 0x00, 0x43, 0x00, 0x4F, 0x00, 0x44, 0x00, 0x45, 0x00, 0x5F, 0x00, 0x52, 0x00,
/* 000012F0 */ 0x45, 0x00, 0x00, 0x00, 0x4C, 0x00, 0x41, 0x00, 0x4E, 0x00, 0x47, 0x00, 0x5F, 0x00, 0x54, 0x00,
/* 00001300 */ 0x41, 0x00, 0x47, 0x00, 0x5F, 0x00, 0x42, 0x00, 0x41, 0x00, 0x53, 0x00, 0x45, 0x00, 0x5F, 0x00,
/* 00001310 */ 0x52, 0x00, 0x45, 0x00, 0x00, 0x00, 0x4C, 0x00, 0x41, 0x00, 0x4E, 0x00, 0x47, 0x00, 0x5F, 0x00,
/* 00001320 */ 0x54, 0x00, 0x41, 0x00, 0x47, 0x00, 0x5F, 0x00, 0x45, 0x00, 0x58, 0x00, 0x54, 0x00, 0x5F, 0x00,
/* 00001330 */ 0x52, 0x00, 0x45, 0x00, 0x00, 0x00, 0x4C, 0x00, 0x41, 0x00, 0x4E, 0x00, 0x47, 0x00, 0x5F, 0x00,
/* 00001340 */ 0x54, 0x00, 0x41, 0x00, 0x47, 0x00, 0x5F, 0x00, 0x52, 0x00, 0x45, 0x00, 0x00, 0x00, 0x63, 0x00,
/* 00001350 */ 0x6F, 0x00, 0x6C, 0x00, 0x6C, 0x00, 0x61, 0x00, 0x74, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x5F, 0x00,
/* 00001360 */ 0x73, 0x00, 0x75, 0x00, 0x70, 0x00, 0x70, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x74, 0x00, 0x65, 0x00,
/* 00001370 */ 0x64, 0x00, 0x4C, 0x00, 0x6F, 0x00, 0x63, 0x00, 0x61, 0x00, 0x6C, 0x00, 0x65, 0x00, 0x73, 0x00,
/* 00001380 */ 0x4F, 0x00, 0x66, 0x00, 0x5F, 0x00, 0x6E, 0x00, 0x61, 0x00, 0x6D, 0x00, 0x65, 0x00, 0x00, 0x00,
/* 00001390 */ 0x63, 0x00, 0x6F, 0x00, 0x6C, 0x00, 0x6C, 0x00, 0x61, 0x00, 0x74, 0x00, 0x6F, 0x00, 0x72, 0x00,
/* 000013A0 */ 0x5F, 0x00, 0x73, 0x00, 0x75, 0x00, 0x70, 0x00, 0x70, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x74, 0x00,
/* 000013B0 */ 0x65, 0x00, 0x64, 0x00, 0x4C, 0x00, 0x6F, 0x00, 0x63, 0x00, 0x61, 0x00, 0x6C, 0x00, 0x65, 0x00,
/* 000013C0 */ 0x73, 0x00, 0x4F, 0x00, 0x66, 0x00, 0x00, 0x00, 0x6E, 0x00, 0x75, 0x00, 0x6D, 0x00, 0x62, 0x00,
/* 000013D0 */ 0x65, 0x00, 0x72, 0x00, 0x46, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x6D, 0x00, 0x61, 0x00, 0x74, 0x00,
/* 000013E0 */ 0x5F, 0x00, 0x73, 0x00, 0x75, 0x00, 0x70, 0x00, 0x70, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x74, 0x00,
/* 000013F0 */ 0x65, 0x00, 0x64, 0x00, 0x4C, 0x00, 0x6F, 0x00, 0x63, 0x00, 0x61, 0x00, 0x6C, 0x00, 0x65, 0x00,
/* 00001400 */ 0x73, 0x00, 0x4F, 0x00, 0x66, 0x00, 0x5F, 0x00, 0x6E, 0x00, 0x61, 0x00, 0x6D, 0x00, 0x65, 0x00,
/* 00001410 */ 0x00, 0x00, 0x6E, 0x00, 0x75, 0x00, 0x6D, 0x00, 0x62, 0x00, 0x65, 0x00, 0x72, 0x00, 0x46, 0x00,
/* 00001420 */ 0x6F, 0x00, 0x72, 0x00, 0x6D, 0x00, 0x61, 0x00, 0x74, 0x00, 0x5F, 0x00, 0x73, 0x00, 0x75, 0x00,
/* 00001430 */ 0x70, 0x00, 0x70, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x74, 0x00, 0x65, 0x00, 0x64, 0x00, 0x4C, 0x00,
/* 00001440 */ 0x6F, 0x00, 0x63, 0x00, 0x61, 0x00, 0x6C, 0x00, 0x65, 0x00, 0x73, 0x00, 0x4F, 0x00, 0x66, 0x00,
/* 00001450 */ 0x00, 0x00, 0x64, 0x00, 0x61, 0x00, 0x74, 0x00, 0x65, 0x00, 0x54, 0x00, 0x69, 0x00, 0x6D, 0x00,
/* 00001460 */ 0x65, 0x00, 0x46, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x6D, 0x00, 0x61, 0x00, 0x74, 0x00, 0x5F, 0x00,
/* 00001470 */ 0x73, 0x00, 0x75, 0x00, 0x70, 0x00, 0x70, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x74, 0x00, 0x65, 0x00,
/* 00001480 */ 0x64, 0x00, 0x4C, 0x00, 0x6F, 0x00, 0x63, 0x00, 0x61, 0x00, 0x6C, 0x00, 0x65, 0x00, 0x73, 0x00,
/* 00001490 */ 0x4F, 0x00, 0x66, 0x00, 0x5F, 0x00, 0x6E, 0x00, 0x61, 0x00, 0x6D, 0x00, 0x65, 0x00, 0x00, 0x00,
/* 000014A0 */ 0x64, 0x00, 0x61, 0x00, 0x74, 0x00, 0x65, 0x00, 0x54, 0x00, 0x69, 0x00, 0x6D, 0x00, 0x65, 0x00,
/* 000014B0 */ 0x46, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x6D, 0x00, 0x61, 0x00, 0x74, 0x00, 0x5F, 0x00, 0x73, 0x00,
/* 000014C0 */ 0x75, 0x00, 0x70, 0x00, 0x70, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x74, 0x00, 0x65, 0x00, 0x64, 0x00,
/* 000014D0 */ 0x4C, 0x00, 0x6F, 0x00, 0x63, 0x00, 0x61, 0x00, 0x6C, 0x00, 0x65, 0x00, 0x73, 0x00, 0x4F, 0x00,
/* 000014E0 */ 0x66, 0x00, 0x00, 0x00, 0x67, 0x00, 0x65, 0x00, 0x74, 0x00, 0x43, 0x00, 0x61, 0x00, 0x6E, 0x00,
/* 000014F0 */ 0x6F, 0x00, 0x6E, 0x00, 0x69, 0x00, 0x63, 0x00, 0x61, 0x00, 0x6C, 0x00, 0x4C, 0x00, 0x6F, 0x00,
/* 00001500 */ 0x63, 0x00, 0x61, 0x00, 0x6C, 0x00, 0x65, 0x00, 0x73, 0x00, 0x5F, 0x00, 0x6E, 0x00, 0x61, 0x00,
/* 00001510 */ 0x6D, 0x00, 0x65, 0x00, 0x00, 0x00, 0x5F, 0x00, 0x5F, 0x00, 0x6D, 0x00, 0x61, 0x00, 0x70, 0x00,
/* 00001520 */ 0x70, 0x00, 0x65, 0x00, 0x64, 0x00, 0x44, 0x00, 0x65, 0x00, 0x66, 0x00, 0x61, 0x00, 0x75, 0x00,
/* 00001530 */ 0x6C, 0x00, 0x74, 0x00, 0x4C, 0x00, 0x6F, 0x00, 0x63, 0x00, 0x61, 0x00, 0x6C, 0x00, 0x65, 0x00,
/* 00001540 */ 0x00, 0x00, 0x65, 0x00, 0x6E, 0x00, 0x00, 0x00, 0x7B, 0x00, 0x6D, 0x00, 0x6F, 0x00, 0x6E, 0x00,
/* 00001550 */ 0x74, 0x00, 0x68, 0x00, 0x2E, 0x00, 0x61, 0x00, 0x7D, 0x00, 0x7B, 0x00, 0x64, 0x00, 0x61, 0x00,
/* 00001560 */ 0x79, 0x00, 0x2E, 0x00, 0x62, 0x00, 0x7D, 0x00, 0x7B, 0x00, 0x68, 0x00, 0x6F, 0x00, 0x75, 0x00,
/* 00001570 */ 0x72, 0x00, 0x2E, 0x00, 0x63, 0x00, 0x7D, 0x00, 0x7B, 0x00, 0x6D, 0x00, 0x69, 0x00, 0x6E, 0x00,
/* 00001580 */ 0x75, 0x00, 0x74, 0x00, 0x65, 0x00, 0x2E, 0x00, 0x64, 0x00, 0x7D, 0x00, 0x7B, 0x00, 0x73, 0x00,
/* 00001590 */ 0x65, 0x00, 0x63, 0x00, 0x6F, 0x00, 0x6E, 0x00, 0x64, 0x00, 0x2E, 0x00, 0x65, 0x00, 0x7D, 0x00,
/* 000015A0 */ 0x00, 0x00, 0x72, 0x00, 0x65, 0x00, 0x73, 0x00, 0x6F, 0x00, 0x6C, 0x00, 0x76, 0x00, 0x65, 0x00,
/* 000015B0 */ 0x4C, 0x00, 0x6F, 0x00, 0x63, 0x00, 0x61, 0x00, 0x6C, 0x00, 0x65, 0x00, 0x42, 0x00, 0x65, 0x00,
/* 000015C0 */ 0x73, 0x00, 0x74, 0x00, 0x46, 0x00, 0x69, 0x00, 0x74, 0x00, 0x00, 0x00, 0x2D, 0x00, 0x00, 0x00,
/* 000015D0 */ 0x72, 0x00, 0x65, 0x00, 0x73, 0x00, 0x6F, 0x00, 0x6C, 0x00, 0x76, 0x00, 0x65, 0x00, 0x4C, 0x00,
/* 000015E0 */ 0x6F, 0x00, 0x63, 0x00, 0x61, 0x00, 0x6C, 0x00, 0x65, 0x00, 0x4C, 0x00, 0x6F, 0x00, 0x6F, 0x00,
/* 000015F0 */ 0x6B, 0x00, 0x75, 0x00, 0x70, 0x00, 0x00, 0x00, 0x2D, 0x00, 0x75, 0x00, 0x2D, 0x00, 0x00, 0x00,
/* 00001600 */ 0x6C, 0x00, 0x6F, 0x00, 0x63, 0x00, 0x61, 0x00, 0x6C, 0x00, 0x65, 0x00, 0x00, 0x00, 0x73, 0x00,
/* 00001610 */ 0x75, 0x00, 0x62, 0x00, 0x54, 0x00, 0x61, 0x00, 0x67, 0x00, 0x73, 0x00, 0x00, 0x00, 0x6C, 0x00,
/* 00001620 */ 0x6F, 0x00, 0x63, 0x00, 0x61, 0x00, 0x6C, 0x00, 0x65, 0x00, 0x57, 0x00, 0x69, 0x00, 0x74, 0x00,
/* 00001630 */ 0x68, 0x00, 0x6F, 0x00, 0x75, 0x00, 0x74, 0x00, 0x53, 0x00, 0x75, 0x00, 0x62, 0x00, 0x74, 0x00,
/* 00001640 */ 0x61, 0x00, 0x67, 0x00, 0x73, 0x00, 0x00, 0x00, 0x66, 0x00, 0x69, 0x00, 0x6C, 0x00, 0x74, 0x00,
/* 00001650 */ 0x65, 0x00, 0x72, 0x00, 0x65, 0x00, 0x64, 0x00, 0x00, 0x00, 0x65, 0x00, 0x78, 0x00, 0x74, 0x00,
/* 00001660 */ 0x65, 0x00, 0x6E, 0x00, 0x73, 0x00, 0x69, 0x00, 0x6F, 0x00, 0x6E, 0x00, 0x46, 0x00, 0x69, 0x00,
/* 00001670 */ 0x6C, 0x00, 0x74, 0x00, 0x65, 0x00, 0x72, 0x00, 0x00, 0x00, 0x28, 0x00, 0x2E, 0x00, 0x2A, 0x00,
/* 00001680 */ 0x3F, 0x00, 0x29, 0x00, 0x28, 0x00, 0x3F, 0x00, 0x3A, 0x00, 0x2D, 0x00, 0x75, 0x00, 0x29, 0x00,
/* 00001690 */ 0x3F, 0x00, 0x24, 0x00, 0x00, 0x00, 0x28, 0x00, 0x5B, 0x00, 0x5E, 0x00, 0x2D, 0x00, 0x5D, 0x00,
/* 000016A0 */ 0x2A, 0x00, 0x29, 0x00, 0x2D, 0x00, 0x3F, 0x00, 0x28, 0x00, 0x2E, 0x00, 0x2A, 0x00, 0x29, 0x00,
/* 000016B0 */ 0x3F, 0x00, 0x00, 0x00, 0x6C, 0x00, 0x6F, 0x00, 0x6F, 0x00, 0x6B, 0x00, 0x75, 0x00, 0x70, 0x00,
/* 000016C0 */ 0x00, 0x00, 0x28, 0x00, 0x5B, 0x00, 0x5E, 0x00, 0x5F, 0x00, 0x5D, 0x00, 0x2A, 0x00, 0x29, 0x00,
/* 000016D0 */ 0x2E, 0x00, 0x2A, 0x00, 0x00, 0x00, 0x54, 0x00, 0x6F, 0x00, 0x4F, 0x00, 0x62, 0x00, 0x6A, 0x00,
/* 000016E0 */ 0x65, 0x00, 0x63, 0x00, 0x74, 0x00, 0x00, 0x00, 0x54, 0x00, 0x6F, 0x00, 0x53, 0x00, 0x74, 0x00,
/* 000016F0 */ 0x72, 0x00, 0x69, 0x00, 0x6E, 0x00, 0x67, 0x00, 0x00, 0x00, 0x54, 0x00, 0x6F, 0x00, 0x4E, 0x00,
/* 00001700 */ 0x75, 0x00, 0x6D, 0x00, 0x62, 0x00, 0x65, 0x00, 0x72, 0x00, 0x00, 0x00, 0x54, 0x00, 0x6F, 0x00,
/* 00001710 */ 0x4C, 0x00, 0x6F, 0x00, 0x67, 0x00, 0x69, 0x00, 0x63, 0x00, 0x61, 0x00, 0x6C, 0x00, 0x42, 0x00,
/* 00001720 */ 0x6F, 0x00, 0x6F, 0x00, 0x6C, 0x00, 0x65, 0x00, 0x61, 0x00, 0x6E, 0x00, 0x00, 0x00, 0x54, 0x00,
/* 00001730 */ 0x6F, 0x00, 0x55, 0x00, 0x69, 0x00, 0x6E, 0x00, 0x74, 0x00, 0x33, 0x00, 0x32, 0x00, 0x00, 0x00,
/* 00001740 */ 0x48, 0x00, 0x61, 0x00, 0x73, 0x00, 0x50, 0x00, 0x72, 0x00, 0x6F, 0x00, 0x70, 0x00, 0x65, 0x00,
/* 00001750 */ 0x72, 0x00, 0x74, 0x00, 0x79, 0x00, 0x00, 0x00, 0x62, 0x00, 0x6F, 0x00, 0x6F, 0x00, 0x6C, 0x00,
/* 00001760 */ 0x65, 0x00, 0x61, 0x00, 0x6E, 0x00, 0x00, 0x00, 0x73, 0x00, 0x74, 0x00, 0x72, 0x00, 0x69, 0x00,
/* 00001770 */ 0x6E, 0x00, 0x67, 0x00, 0x00, 0x00, 0x6E, 0x00, 0x75, 0x00, 0x6D, 0x00, 0x62, 0x00, 0x65, 0x00,
/* 00001780 */ 0x72, 0x00, 0x00, 0x00, 0x5B, 0x00, 0x27, 0x00, 0x00, 0x00, 0x27, 0x00, 0x2C, 0x00, 0x20, 0x00,
/* 00001790 */ 0x27, 0x00, 0x00, 0x00, 0x27, 0x00, 0x5D, 0x00, 0x00, 0x00, 0x75, 0x00, 0x6E, 0x00, 0x64, 0x00,
/* 000017A0 */ 0x65, 0x00, 0x66, 0x00, 0x69, 0x00, 0x6E, 0x00, 0x65, 0x00, 0x64, 0x00, 0x00, 0x00, 0x5B, 0x00,
/* 000017B0 */ 0x00, 0x00, 0x20, 0x00, 0x2D, 0x00, 0x20, 0x00, 0x00, 0x00, 0x5D, 0x00, 0x00, 0x00, 0x5E, 0x00,
/* 000017C0 */ 0x5B, 0x00, 0x41, 0x00, 0x2D, 0x00, 0x5A, 0x00, 0x5D, 0x00, 0x7B, 0x00, 0x33, 0x00, 0x7D, 0x00,
/* 000017D0 */ 0x24, 0x00, 0x00, 0x00, 0x5B, 0x00, 0x41, 0x00, 0x2D, 0x00, 0x5A, 0x00, 0x5D, 0x00, 0x00, 0x00,
/* 000017E0 */ 0x5B, 0x00, 0x30, 0x00, 0x2D, 0x00, 0x39, 0x00, 0x5D, 0x00, 0x00, 0x00, 0x28, 0x00, 0x3F, 0x00,
/* 000017F0 */ 0x3A, 0x00, 0x00, 0x00, 0x7C, 0x00, 0x00, 0x00, 0x29, 0x00, 0x00, 0x00, 0x5C, 0x00, 0x62, 0x00,
/* 00001800 */ 0x28, 0x00, 0x3F, 0x00, 0x3A, 0x00, 0x61, 0x00, 0x72, 0x00, 0x74, 0x00, 0x2D, 0x00, 0x6C, 0x00,
/* 00001810 */ 0x6F, 0x00, 0x6A, 0x00, 0x62, 0x00, 0x61, 0x00, 0x6E, 0x00, 0x7C, 0x00, 0x63, 0x00, 0x65, 0x00,
/* 00001820 */ 0x6C, 0x00, 0x2D, 0x00, 0x67, 0x00, 0x61, 0x00, 0x75, 0x00, 0x6C, 0x00, 0x69, 0x00, 0x73, 0x00,
/* 00001830 */ 0x68, 0x00, 0x7C, 0x00, 0x6E, 0x00, 0x6F, 0x00, 0x2D, 0x00, 0x62, 0x00, 0x6F, 0x00, 0x6B, 0x00,
/* 00001840 */ 0x7C, 0x00, 0x6E, 0x00, 0x6F, 0x00, 0x2D, 0x00, 0x6E, 0x00, 0x79, 0x00, 0x6E, 0x00, 0x7C, 0x00,
/* 00001850 */ 0x7A, 0x00, 0x68, 0x00, 0x2D, 0x00, 0x67, 0x00, 0x75, 0x00, 0x6F, 0x00, 0x79, 0x00, 0x75, 0x00,
/* 00001860 */ 0x7C, 0x00, 0x7A, 0x00, 0x68, 0x00, 0x2D, 0x00, 0x68, 0x00, 0x61, 0x00, 0x6B, 0x00, 0x6B, 0x00,
/* 00001870 */ 0x61, 0x00, 0x7C, 0x00, 0x7A, 0x00, 0x68, 0x00, 0x2D, 0x00, 0x6D, 0x00, 0x69, 0x00, 0x6E, 0x00,
/* 00001880 */ 0x7C, 0x00, 0x7A, 0x00, 0x68, 0x00, 0x2D, 0x00, 0x6D, 0x00, 0x69, 0x00, 0x6E, 0x00, 0x2D, 0x00,
/* 00001890 */ 0x6E, 0x00, 0x61, 0x00, 0x6E, 0x00, 0x7C, 0x00, 0x7A, 0x00, 0x68, 0x00, 0x2D, 0x00, 0x78, 0x00,
/* 000018A0 */ 0x69, 0x00, 0x61, 0x00, 0x6E, 0x00, 0x67, 0x00, 0x29, 0x00, 0x5C, 0x00, 0x62, 0x00, 0x00, 0x00,
/* 000018B0 */ 0x5C, 0x00, 0x62, 0x00, 0x28, 0x00, 0x3F, 0x00, 0x3A, 0x00, 0x65, 0x00, 0x6E, 0x00, 0x2D, 0x00,
/* 000018C0 */ 0x47, 0x00, 0x42, 0x00, 0x2D, 0x00, 0x6F, 0x00, 0x65, 0x00, 0x64, 0x00, 0x7C, 0x00, 0x69, 0x00,
/* 000018D0 */ 0x2D, 0x00, 0x61, 0x00, 0x6D, 0x00, 0x69, 0x00, 0x7C, 0x00, 0x69, 0x00, 0x2D, 0x00, 0x62, 0x00,
/* 000018E0 */ 0x6E, 0x00, 0x6E, 0x00, 0x7C, 0x00, 0x69, 0x00, 0x2D, 0x00, 0x64, 0x00, 0x65, 0x00, 0x66, 0x00,
/* 000018F0 */ 0x61, 0x00, 0x75, 0x00, 0x6C, 0x00, 0x74, 0x00, 0x7C, 0x00, 0x69, 0x00, 0x2D, 0x00, 0x65, 0x00,
/* 00001900 */ 0x6E, 0x00, 0x6F, 0x00, 0x63, 0x00, 0x68, 0x00, 0x69, 0x00, 0x61, 0x00, 0x6E, 0x00, 0x7C, 0x00,
/* 00001910 */ 0x69, 0x00, 0x2D, 0x00, 0x68, 0x00, 0x61, 0x00, 0x6B, 0x00, 0x7C, 0x00, 0x69, 0x00, 0x2D, 0x00,
/* 00001920 */ 0x6B, 0x00, 0x6C, 0x00, 0x69, 0x00, 0x6E, 0x00, 0x67, 0x00, 0x6F, 0x00, 0x6E, 0x00, 0x7C, 0x00,
/* 00001930 */ 0x69, 0x00, 0x2D, 0x00, 0x6C, 0x00, 0x75, 0x00, 0x78, 0x00, 0x7C, 0x00, 0x69, 0x00, 0x2D, 0x00,
/* 00001940 */ 0x6D, 0x00, 0x69, 0x00, 0x6E, 0x00, 0x67, 0x00, 0x6F, 0x00, 0x00, 0x00, 0x7C, 0x00, 0x69, 0x00,
/* 00001950 */ 0x2D, 0x00, 0x6E, 0x00, 0x61, 0x00, 0x76, 0x00, 0x61, 0x00, 0x6A, 0x00, 0x6F, 0x00, 0x7C, 0x00,
/* 00001960 */ 0x69, 0x00, 0x2D, 0x00, 0x70, 0x00, 0x77, 0x00, 0x6E, 0x00, 0x7C, 0x00, 0x69, 0x00, 0x2D, 0x00,
/* 00001970 */ 0x74, 0x00, 0x61, 0x00, 0x6F, 0x00, 0x7C, 0x00, 0x69, 0x00, 0x2D, 0x00, 0x74, 0x00, 0x61, 0x00,
/* 00001980 */ 0x79, 0x00, 0x7C, 0x00, 0x69, 0x00, 0x2D, 0x00, 0x74, 0x00, 0x73, 0x00, 0x75, 0x00, 0x7C, 0x00,
/* 00001990 */ 0x73, 0x00, 0x67, 0x00, 0x6E, 0x00, 0x2D, 0x00, 0x42, 0x00, 0x45, 0x00, 0x2D, 0x00, 0x46, 0x00,
/* 000019A0 */ 0x52, 0x00, 0x7C, 0x00, 0x73, 0x00, 0x67, 0x00, 0x6E, 0x00, 0x2D, 0x00, 0x42, 0x00, 0x45, 0x00,
/* 000019B0 */ 0x2D, 0x00, 0x4E, 0x00, 0x4C, 0x00, 0x7C, 0x00, 0x73, 0x00, 0x67, 0x00, 0x6E, 0x00, 0x2D, 0x00,
/* 000019C0 */ 0x43, 0x00, 0x48, 0x00, 0x2D, 0x00, 0x44, 0x00, 0x45, 0x00, 0x29, 0x00, 0x5C, 0x00, 0x62, 0x00,
/* 000019D0 */ 0x00, 0x00, 0x5C, 0x00, 0x62, 0x00, 0x28, 0x00, 0x3F, 0x00, 0x3A, 0x00, 0x00, 0x00, 0x29, 0x00,
/* 000019E0 */ 0x5C, 0x00, 0x62, 0x00, 0x00, 0x00, 0x5C, 0x00, 0x62, 0x00, 0x28, 0x00, 0x3F, 0x00, 0x3A, 0x00,
/* 000019F0 */ 0x78, 0x00, 0x28, 0x00, 0x3F, 0x00, 0x3A, 0x00, 0x2D, 0x00, 0x00, 0x00, 0x7B, 0x00, 0x31, 0x00,
/* 00001A00 */ 0x2C, 0x00, 0x38, 0x00, 0x7D, 0x00, 0x5C, 0x00, 0x62, 0x00, 0x29, 0x00, 0x2B, 0x00, 0x29, 0x00,
/* 00001A10 */ 0x5C, 0x00, 0x62, 0x00, 0x00, 0x00, 0x7C, 0x00, 0x5B, 0x00, 0x41, 0x00, 0x2D, 0x00, 0x57, 0x00,
/* 00001A20 */ 0x59, 0x00, 0x2D, 0x00, 0x5A, 0x00, 0x5D, 0x00, 0x29, 0x00, 0x5C, 0x00, 0x62, 0x00, 0x00, 0x00,
/* 00001A30 */ 0x28, 0x00, 0x3F, 0x00, 0x3A, 0x00, 0x2D, 0x00, 0x00, 0x00, 0x7B, 0x00, 0x32, 0x00, 0x2C, 0x00,
/* 00001A40 */ 0x38, 0x00, 0x7D, 0x00, 0x29, 0x00, 0x2B, 0x00, 0x29, 0x00, 0x5C, 0x00, 0x62, 0x00, 0x00, 0x00,
/* 00001A50 */ 0x7B, 0x00, 0x35, 0x00, 0x2C, 0x00, 0x38, 0x00, 0x7D, 0x00, 0x7C, 0x00, 0x00, 0x00, 0x7B, 0x00,
/* 00001A60 */ 0x33, 0x00, 0x7D, 0x00, 0x29, 0x00, 0x5C, 0x00, 0x62, 0x00, 0x00, 0x00, 0x7B, 0x00, 0x32, 0x00,
/* 00001A70 */ 0x7D, 0x00, 0x7C, 0x00, 0x00, 0x00, 0x7B, 0x00, 0x34, 0x00, 0x7D, 0x00, 0x29, 0x00, 0x5C, 0x00,
/* 00001A80 */ 0x62, 0x00, 0x00, 0x00, 0x7B, 0x00, 0x33, 0x00, 0x7D, 0x00, 0x5C, 0x00, 0x62, 0x00, 0x28, 0x00,
/* 00001A90 */ 0x3F, 0x00, 0x3A, 0x00, 0x2D, 0x00, 0x00, 0x00, 0x7B, 0x00, 0x33, 0x00, 0x7D, 0x00, 0x29, 0x00,
/* 00001AA0 */ 0x7B, 0x00, 0x30, 0x00, 0x2C, 0x00, 0x32, 0x00, 0x7D, 0x00, 0x29, 0x00, 0x5C, 0x00, 0x62, 0x00,
/* 00001AB0 */ 0x00, 0x00, 0x7B, 0x00, 0x32, 0x00, 0x2C, 0x00, 0x33, 0x00, 0x7D, 0x00, 0x00, 0x00, 0x5C, 0x00,
/* 00001AC0 */ 0x62, 0x00, 0x28, 0x00, 0x3F, 0x00, 0x3A, 0x00, 0x2D, 0x00, 0x00, 0x00, 0x29, 0x00, 0x3F, 0x00,
/* 00001AD0 */ 0x00, 0x00, 0x7B, 0x00, 0x34, 0x00, 0x2C, 0x00, 0x38, 0x00, 0x7D, 0x00, 0x00, 0x00, 0x5C, 0x00,
/* 00001AE0 */ 0x62, 0x00, 0x28, 0x00, 0x00, 0x00, 0x5C, 0x00, 0x62, 0x00, 0x28, 0x00, 0x3F, 0x00, 0x3A, 0x00,
/* 00001AF0 */ 0x2D, 0x00, 0x28, 0x00, 0x00, 0x00, 0x29, 0x00, 0x29, 0x00, 0x3F, 0x00, 0x5C, 0x00, 0x62, 0x00,
/* 00001B00 */ 0x00, 0x00, 0x29, 0x00, 0x2A, 0x00, 0x5C, 0x00, 0x62, 0x00, 0x00, 0x00, 0x5C, 0x00, 0x62, 0x00,
/* 00001B10 */ 0x28, 0x00, 0x28, 0x00, 0x3F, 0x00, 0x3A, 0x00, 0x2D, 0x00, 0x00, 0x00, 0x29, 0x00, 0x2A, 0x00,
/* 00001B20 */ 0x29, 0x00, 0x5C, 0x00, 0x62, 0x00, 0x00, 0x00, 0x29, 0x00, 0x3F, 0x00, 0x5C, 0x00, 0x62, 0x00,
/* 00001B30 */ 0x00, 0x00, 0x5C, 0x00, 0x62, 0x00, 0x00, 0x00, 0x69, 0x00, 0x00, 0x00, 0x73, 0x00, 0x65, 0x00,
/* 00001B40 */ 0x65, 0x00, 0x6E, 0x00, 0x00, 0x00, 0x6F, 0x00, 0x62, 0x00, 0x6A, 0x00, 0x65, 0x00, 0x63, 0x00,
/* 00001B50 */ 0x74, 0x00, 0x00, 0x00, 0x4C, 0x00, 0x6F, 0x00, 0x63, 0x00, 0x61, 0x00, 0x6C, 0x00, 0x65, 0x00,
/* 00001B60 */ 0x00, 0x00, 0x6C, 0x00, 0x65, 0x00, 0x6E, 0x00, 0x67, 0x00, 0x74, 0x00, 0x68, 0x00, 0x00, 0x00,
/* 00001B70 */ 0x73, 0x00, 0x75, 0x00, 0x62, 0x00, 0x73, 0x00, 0x65, 0x00, 0x74, 0x00, 0x00, 0x00, 0x63, 0x00,
/* 00001B80 */ 0x6F, 0x00, 0x75, 0x00, 0x6E, 0x00, 0x74, 0x00, 0x00, 0x00, 0x66, 0x00, 0x69, 0x00, 0x74, 0x00,
/* 00001B90 */ 0x74, 0x00, 0x65, 0x00, 0x72, 0x00, 0x00, 0x00, 0x64, 0x00, 0x65, 0x00, 0x66, 0x00, 0x61, 0x00,
/* 00001BA0 */ 0x75, 0x00, 0x6C, 0x00, 0x74, 0x00, 0x4C, 0x00, 0x6F, 0x00, 0x63, 0x00, 0x61, 0x00, 0x6C, 0x00,
/* 00001BB0 */ 0x65, 0x00, 0x00, 0x00, 0x62, 0x00, 0x65, 0x00, 0x73, 0x00, 0x74, 0x00, 0x20, 0x00, 0x66, 0x00,
/* 00001BC0 */ 0x69, 0x00, 0x74, 0x00, 0x00, 0x00, 0x6C, 0x00, 0x6F, 0x00, 0x63, 0x00, 0x61, 0x00, 0x6C, 0x00,
/* 00001BD0 */ 0x65, 0x00, 0x4D, 0x00, 0x61, 0x00, 0x74, 0x00, 0x63, 0x00, 0x68, 0x00, 0x65, 0x00, 0x72, 0x00,
/* 00001BE0 */ 0x00, 0x00, 0x5B, 0x00, 0x27, 0x00, 0x62, 0x00, 0x65, 0x00, 0x73, 0x00, 0x74, 0x00, 0x20, 0x00,
/* 00001BF0 */ 0x66, 0x00, 0x69, 0x00, 0x74, 0x00, 0x27, 0x00, 0x2C, 0x00, 0x20, 0x00, 0x27, 0x00, 0x6C, 0x00,
/* 00001C00 */ 0x6F, 0x00, 0x6F, 0x00, 0x6B, 0x00, 0x75, 0x00, 0x70, 0x00, 0x27, 0x00, 0x5D, 0x00, 0x00, 0x00,
/* 00001C10 */ 0x63, 0x00, 0x6F, 0x00, 0x6C, 0x00, 0x6C, 0x00, 0x61, 0x00, 0x74, 0x00, 0x6F, 0x00, 0x72, 0x00,
/* 00001C20 */ 0x5F, 0x00, 0x73, 0x00, 0x75, 0x00, 0x70, 0x00, 0x70, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x74, 0x00,
/* 00001C30 */ 0x65, 0x00, 0x64, 0x00, 0x4C, 0x00, 0x6F, 0x00, 0x63, 0x00, 0x61, 0x00, 0x6C, 0x00, 0x65, 0x00,
/* 00001C40 */ 0x73, 0x00, 0x4F, 0x00, 0x66, 0x00, 0x5F, 0x00, 0x64, 0x00, 0x75, 0x00, 0x6D, 0x00, 0x6D, 0x00,
/* 00001C50 */ 0x79, 0x00, 0x4E, 0x00, 0x61, 0x00, 0x6D, 0x00, 0x65, 0x00, 0x00, 0x00, 0x6E, 0x00, 0x75, 0x00,
/* 00001C60 */ 0x6D, 0x00, 0x62, 0x00, 0x65, 0x00, 0x72, 0x00, 0x46, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x6D, 0x00,
/* 00001C70 */ 0x61, 0x00, 0x74, 0x00, 0x5F, 0x00, 0x73, 0x00, 0x75, 0x00, 0x70, 0x00, 0x70, 0x00, 0x6F, 0x00,
/* 00001C80 */ 0x72, 0x00, 0x74, 0x00, 0x65, 0x00, 0x64, 0x00, 0x4C, 0x00, 0x6F, 0x00, 0x63, 0x00, 0x61, 0x00,
/* 00001C90 */ 0x6C, 0x00, 0x65, 0x00, 0x73, 0x00, 0x4F, 0x00, 0x66, 0x00, 0x5F, 0x00, 0x64, 0x00, 0x75, 0x00,
/* 00001CA0 */ 0x6D, 0x00, 0x6D, 0x00, 0x79, 0x00, 0x4E, 0x00, 0x61, 0x00, 0x6D, 0x00, 0x65, 0x00, 0x00, 0x00,
/* 00001CB0 */ 0x64, 0x00, 0x61, 0x00, 0x74, 0x00, 0x65, 0x00, 0x54, 0x00, 0x69, 0x00, 0x6D, 0x00, 0x65, 0x00,
/* 00001CC0 */ 0x46, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x6D, 0x00, 0x61, 0x00, 0x74, 0x00, 0x5F, 0x00, 0x73, 0x00,
/* 00001CD0 */ 0x75, 0x00, 0x70, 0x00, 0x70, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x74, 0x00, 0x65, 0x00, 0x64, 0x00,
/* 00001CE0 */ 0x4C, 0x00, 0x6F, 0x00, 0x63, 0x00, 0x61, 0x00, 0x6C, 0x00, 0x65, 0x00, 0x73, 0x00, 0x4F, 0x00,
/* 00001CF0 */ 0x66, 0x00, 0x5F, 0x00, 0x64, 0x00, 0x75, 0x00, 0x6D, 0x00, 0x6D, 0x00, 0x79, 0x00, 0x4E, 0x00,
/* 00001D00 */ 0x61, 0x00, 0x6D, 0x00, 0x65, 0x00, 0x00, 0x00, 0x67, 0x00, 0x65, 0x00, 0x74, 0x00, 0x43, 0x00,
/* 00001D10 */ 0x61, 0x00, 0x6E, 0x00, 0x6F, 0x00, 0x6E, 0x00, 0x69, 0x00, 0x63, 0x00, 0x61, 0x00, 0x6C, 0x00,
/* 00001D20 */ 0x4C, 0x00, 0x6F, 0x00, 0x63, 0x00, 0x61, 0x00, 0x6C, 0x00, 0x65, 0x00, 0x73, 0x00, 0x5F, 0x00,
/* 00001D30 */ 0x64, 0x00, 0x75, 0x00, 0x6D, 0x00, 0x6D, 0x00, 0x79, 0x00, 0x4E, 0x00, 0x61, 0x00, 0x6D, 0x00,
/* 00001D40 */ 0x65, 0x00, 0x00, 0x00, 0x74, 0x00, 0x6F, 0x00, 0x52, 0x00, 0x65, 0x00, 0x74, 0x00, 0x75, 0x00,
/* 00001D50 */ 0x72, 0x00, 0x6E, 0x00, 0x00, 0x00, 0x63, 0x00, 0x6F, 0x00, 0x6C, 0x00, 0x6C, 0x00, 0x61, 0x00,
/* 00001D60 */ 0x74, 0x00, 0x69, 0x00, 0x6F, 0x00, 0x6E, 0x00, 0x56, 0x00, 0x61, 0x00, 0x6C, 0x00, 0x75, 0x00,
/* 00001D70 */ 0x65, 0x00, 0x73, 0x00, 0x46, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x4C, 0x00, 0x6F, 0x00, 0x63, 0x00,
/* 00001D80 */ 0x61, 0x00, 0x6C, 0x00, 0x65, 0x00, 0x00, 0x00, 0x72, 0x00, 0x65, 0x00, 0x76, 0x00, 0x65, 0x00,
/* 00001D90 */ 0x72, 0x00, 0x73, 0x00, 0x65, 0x00, 0x64, 0x00, 0x43, 0x00, 0x6F, 0x00, 0x6C, 0x00, 0x6C, 0x00,
/* 00001DA0 */ 0x61, 0x00, 0x74, 0x00, 0x69, 0x00, 0x6F, 0x00, 0x6E, 0x00, 0x56, 0x00, 0x61, 0x00, 0x6C, 0x00,
/* 00001DB0 */ 0x75, 0x00, 0x65, 0x00, 0x73, 0x00, 0x00, 0x00, 0x2D, 0x00, 0x63, 0x00, 0x6F, 0x00, 0x2D, 0x00,
/* 00001DC0 */ 0x00, 0x00, 0x2D, 0x00, 0x75, 0x00, 0x28, 0x00, 0x3F, 0x00, 0x3A, 0x00, 0x2D, 0x00, 0x5B, 0x00,
/* 00001DD0 */ 0x5E, 0x00, 0x5C, 0x00, 0x2D, 0x00, 0x5D, 0x00, 0x5B, 0x00, 0x5E, 0x00, 0x5C, 0x00, 0x2D, 0x00,
/* 00001DE0 */ 0x5D, 0x00, 0x3F, 0x00, 0x2D, 0x00, 0x5B, 0x00, 0x5E, 0x00, 0x5C, 0x00, 0x2D, 0x00, 0x5D, 0x00,
/* 00001DF0 */ 0x2B, 0x00, 0x29, 0x00, 0x2A, 0x00, 0x2D, 0x00, 0x63, 0x00, 0x6F, 0x00, 0x2D, 0x00, 0x28, 0x00,
/* 00001E00 */ 0x5B, 0x00, 0x5E, 0x00, 0x5C, 0x00, 0x2D, 0x00, 0x5D, 0x00, 0x2B, 0x00, 0x29, 0x00, 0x2E, 0x00,
/* 00001E10 */ 0x2A, 0x00, 0x00, 0x00, 0x28, 0x00, 0x5B, 0x00, 0x5E, 0x00, 0x5F, 0x00, 0x5D, 0x00, 0x2A, 0x00,
/* 00001E20 */ 0x29, 0x00, 0x5F, 0x00, 0x3F, 0x00, 0x28, 0x00, 0x2E, 0x00, 0x2B, 0x00, 0x29, 0x00, 0x3F, 0x00,
/* 00001E30 */ 0x00, 0x00, 0x63, 0x00, 0x72, 0x00, 0x65, 0x00, 0x61, 0x00, 0x74, 0x00, 0x65, 0x00, 0x4C, 0x00,
/* 00001E40 */ 0x6F, 0x00, 0x63, 0x00, 0x61, 0x00, 0x6C, 0x00, 0x65, 0x00, 0x43, 0x00, 0x6F, 0x00, 0x6C, 0x00,
/* 00001E50 */ 0x6C, 0x00, 0x61, 0x00, 0x74, 0x00, 0x69, 0x00, 0x6F, 0x00, 0x6E, 0x00, 0x53, 0x00, 0x74, 0x00,
/* 00001E60 */ 0x72, 0x00, 0x69, 0x00, 0x6E, 0x00, 0x67, 0x00, 0x00, 0x00, 0x2D, 0x00, 0x75, 0x00, 0x2D, 0x00,
/* 00001E70 */ 0x63, 0x00, 0x6F, 0x00, 0x2D, 0x00, 0x00, 0x00, 0x53, 0x00, 0x74, 0x00, 0x72, 0x00, 0x69, 0x00,
/* 00001E80 */ 0x6E, 0x00, 0x67, 0x00, 0x00, 0x00, 0x53, 0x00, 0x74, 0x00, 0x72, 0x00, 0x69, 0x00, 0x6E, 0x00,
/* 00001E90 */ 0x67, 0x00, 0x2E, 0x00, 0x70, 0x00, 0x72, 0x00, 0x6F, 0x00, 0x74, 0x00, 0x6F, 0x00, 0x74, 0x00,
/* 00001EA0 */ 0x79, 0x00, 0x70, 0x00, 0x65, 0x00, 0x2E, 0x00, 0x6C, 0x00, 0x6F, 0x00, 0x63, 0x00, 0x61, 0x00,
/* 00001EB0 */ 0x6C, 0x00, 0x65, 0x00, 0x43, 0x00, 0x6F, 0x00, 0x6D, 0x00, 0x70, 0x00, 0x61, 0x00, 0x72, 0x00,
/* 00001EC0 */ 0x65, 0x00, 0x00, 0x00, 0x49, 0x00, 0x6E, 0x00, 0x74, 0x00, 0x6C, 0x00, 0x2E, 0x00, 0x43, 0x00,
/* 00001ED0 */ 0x6F, 0x00, 0x6C, 0x00, 0x6C, 0x00, 0x61, 0x00, 0x74, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x00, 0x00,
/* 00001EE0 */ 0x49, 0x00, 0x6E, 0x00, 0x74, 0x00, 0x6C, 0x00, 0x2E, 0x00, 0x43, 0x00, 0x6F, 0x00, 0x6C, 0x00,
/* 00001EF0 */ 0x6C, 0x00, 0x61, 0x00, 0x74, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x2E, 0x00, 0x70, 0x00, 0x72, 0x00,
/* 00001F00 */ 0x6F, 0x00, 0x74, 0x00, 0x6F, 0x00, 0x74, 0x00, 0x79, 0x00, 0x70, 0x00, 0x65, 0x00, 0x2E, 0x00,
/* 00001F10 */ 0x63, 0x00, 0x6F, 0x00, 0x6D, 0x00, 0x70, 0x00, 0x61, 0x00, 0x72, 0x00, 0x65, 0x00, 0x00, 0x00,
/* 00001F20 */ 0x70, 0x00, 0x72, 0x00, 0x6F, 0x00, 0x74, 0x00, 0x6F, 0x00, 0x74, 0x00, 0x79, 0x00, 0x70, 0x00,
/* 00001F30 */ 0x65, 0x00, 0x00, 0x00, 0x63, 0x00, 0x6F, 0x00, 0x6E, 0x00, 0x73, 0x00, 0x74, 0x00, 0x72, 0x00,
/* 00001F40 */ 0x75, 0x00, 0x63, 0x00, 0x74, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x00, 0x00, 0x72, 0x00, 0x65, 0x00,
/* 00001F50 */ 0x73, 0x00, 0x6F, 0x00, 0x6C, 0x00, 0x76, 0x00, 0x65, 0x00, 0x64, 0x00, 0x4F, 0x00, 0x70, 0x00,
/* 00001F60 */ 0x74, 0x00, 0x69, 0x00, 0x6F, 0x00, 0x6E, 0x00, 0x73, 0x00, 0x00, 0x00, 0x63, 0x00, 0x6F, 0x00,
/* 00001F70 */ 0x6D, 0x00, 0x70, 0x00, 0x61, 0x00, 0x72, 0x00, 0x65, 0x00, 0x00, 0x00, 0x67, 0x00, 0x65, 0x00,
/* 00001F80 */ 0x74, 0x00, 0x00, 0x00, 0x67, 0x00, 0x65, 0x00, 0x74, 0x00, 0x20, 0x00, 0x63, 0x00, 0x6F, 0x00,
/* 00001F90 */ 0x6D, 0x00, 0x70, 0x00, 0x61, 0x00, 0x72, 0x00, 0x65, 0x00, 0x00, 0x00, 0x49, 0x00, 0x6E, 0x00,
/* 00001FA0 */ 0x69, 0x00, 0x74, 0x00, 0x69, 0x00, 0x61, 0x00, 0x6C, 0x00, 0x69, 0x00, 0x7A, 0x00, 0x65, 0x00,
/* 00001FB0 */ 0x43, 0x00, 0x6F, 0x00, 0x6C, 0x00, 0x6C, 0x00, 0x61, 0x00, 0x74, 0x00, 0x6F, 0x00, 0x72, 0x00,
/* 00001FC0 */ 0x00, 0x00, 0x5F, 0x00, 0x5F, 0x00, 0x69, 0x00, 0x6E, 0x00, 0x69, 0x00, 0x74, 0x00, 0x69, 0x00,
/* 00001FD0 */ 0x61, 0x00, 0x6C, 0x00, 0x69, 0x00, 0x7A, 0x00, 0x65, 0x00, 0x64, 0x00, 0x49, 0x00, 0x6E, 0x00,
/* 00001FE0 */ 0x74, 0x00, 0x6C, 0x00, 0x4F, 0x00, 0x62, 0x00, 0x6A, 0x00, 0x65, 0x00, 0x63, 0x00, 0x74, 0x00,
/* 00001FF0 */ 0x00, 0x00, 0x75, 0x00, 0x73, 0x00, 0x61, 0x00, 0x67, 0x00, 0x65, 0x00, 0x00, 0x00, 0x73, 0x00,
/* 00002000 */ 0x6F, 0x00, 0x72, 0x00, 0x74, 0x00, 0x00, 0x00, 0x73, 0x00, 0x65, 0x00, 0x61, 0x00, 0x72, 0x00,
/* 00002010 */ 0x63, 0x00, 0x68, 0x00, 0x00, 0x00, 0x73, 0x00, 0x65, 0x00, 0x6E, 0x00, 0x73, 0x00, 0x69, 0x00,
/* 00002020 */ 0x74, 0x00, 0x69, 0x00, 0x76, 0x00, 0x69, 0x00, 0x74, 0x00, 0x79, 0x00, 0x00, 0x00, 0x62, 0x00,
/* 00002030 */ 0x61, 0x00, 0x73, 0x00, 0x65, 0x00, 0x00, 0x00, 0x61, 0x00, 0x63, 0x00, 0x63, 0x00, 0x65, 0x00,
/* 00002040 */ 0x6E, 0x00, 0x74, 0x00, 0x00, 0x00, 0x63, 0x00, 0x61, 0x00, 0x73, 0x00, 0x65, 0x00, 0x00, 0x00,
/* 00002050 */ 0x76, 0x00, 0x61, 0x00, 0x72, 0x00, 0x69, 0x00, 0x61, 0x00, 0x6E, 0x00, 0x74, 0x00, 0x00, 0x00,
/* 00002060 */ 0x69, 0x00, 0x67, 0x00, 0x6E, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x65, 0x00, 0x50, 0x00, 0x75, 0x00,
/* 00002070 */ 0x6E, 0x00, 0x63, 0x00, 0x74, 0x00, 0x75, 0x00, 0x61, 0x00, 0x74, 0x00, 0x69, 0x00, 0x6F, 0x00,
/* 00002080 */ 0x6E, 0x00, 0x00, 0x00, 0x63, 0x00, 0x61, 0x00, 0x73, 0x00, 0x65, 0x00, 0x46, 0x00, 0x69, 0x00,
/* 00002090 */ 0x72, 0x00, 0x73, 0x00, 0x74, 0x00, 0x00, 0x00, 0x75, 0x00, 0x70, 0x00, 0x70, 0x00, 0x65, 0x00,
/* 000020A0 */ 0x72, 0x00, 0x00, 0x00, 0x6C, 0x00, 0x6F, 0x00, 0x77, 0x00, 0x65, 0x00, 0x72, 0x00, 0x00, 0x00,
/* 000020B0 */ 0x66, 0x00, 0x61, 0x00, 0x6C, 0x00, 0x73, 0x00, 0x65, 0x00, 0x00, 0x00, 0x6E, 0x00, 0x75, 0x00,
/* 000020C0 */ 0x6D, 0x00, 0x65, 0x00, 0x72, 0x00, 0x69, 0x00, 0x63, 0x00, 0x00, 0x00, 0x64, 0x00, 0x65, 0x00,
/* 000020D0 */ 0x66, 0x00, 0x61, 0x00, 0x75, 0x00, 0x6C, 0x00, 0x74, 0x00, 0x00, 0x00, 0x5F, 0x00, 0x00, 0x00,
/* 000020E0 */ 0x41, 0x00, 0x00, 0x00, 0x61, 0x00, 0x00, 0x00, 0x63, 0x00, 0x6F, 0x00, 0x6C, 0x00, 0x6C, 0x00,
/* 000020F0 */ 0x61, 0x00, 0x74, 0x00, 0x69, 0x00, 0x6F, 0x00, 0x6E, 0x00, 0x00, 0x00, 0x6B, 0x00, 0x66, 0x00,
/* 00002100 */ 0x00, 0x00, 0x6B, 0x00, 0x6E, 0x00, 0x00, 0x00, 0x74, 0x00, 0x72, 0x00, 0x75, 0x00, 0x65, 0x00,
/* 00002110 */ 0x00, 0x00, 0x63, 0x00, 0x6F, 0x00, 0x00, 0x00, 0x73, 0x00, 0x74, 0x00, 0x61, 0x00, 0x6E, 0x00,
/* 00002120 */ 0x64, 0x00, 0x61, 0x00, 0x72, 0x00, 0x64, 0x00, 0x00, 0x00, 0x43, 0x00, 0x6F, 0x00, 0x6C, 0x00,
/* 00002130 */ 0x6C, 0x00, 0x61, 0x00, 0x74, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x2E, 0x00, 0x70, 0x00, 0x72, 0x00,
/* 00002140 */ 0x6F, 0x00, 0x74, 0x00, 0x6F, 0x00, 0x74, 0x00, 0x79, 0x00, 0x70, 0x00, 0x65, 0x00, 0x2E, 0x00,
/* 00002150 */ 0x63, 0x00, 0x6F, 0x00, 0x6D, 0x00, 0x70, 0x00, 0x61, 0x00, 0x72, 0x00, 0x65, 0x00, 0x00, 0x00,
/* 00002160 */ 0x43, 0x00, 0x6F, 0x00, 0x6C, 0x00, 0x6C, 0x00, 0x61, 0x00, 0x74, 0x00, 0x6F, 0x00, 0x72, 0x00,
/* 00002170 */ 0x2E, 0x00, 0x70, 0x00, 0x72, 0x00, 0x6F, 0x00, 0x74, 0x00, 0x6F, 0x00, 0x74, 0x00, 0x79, 0x00,
/* 00002180 */ 0x70, 0x00, 0x65, 0x00, 0x2E, 0x00, 0x72, 0x00, 0x65, 0x00, 0x73, 0x00, 0x6F, 0x00, 0x6C, 0x00,
/* 00002190 */ 0x76, 0x00, 0x65, 0x00, 0x64, 0x00, 0x4F, 0x00, 0x70, 0x00, 0x74, 0x00, 0x69, 0x00, 0x6F, 0x00,
/* 000021A0 */ 0x6E, 0x00, 0x73, 0x00, 0x00, 0x00, 0x44, 0x00, 0x45, 0x00, 0x46, 0x00, 0x41, 0x00, 0x55, 0x00,
/* 000021B0 */ 0x4C, 0x00, 0x54, 0x00, 0x00, 0x00, 0x44, 0x00, 0x45, 0x00, 0x43, 0x00, 0x49, 0x00, 0x4D, 0x00,
/* 000021C0 */ 0x41, 0x00, 0x4C, 0x00, 0x00, 0x00, 0x50, 0x00, 0x45, 0x00, 0x52, 0x00, 0x43, 0x00, 0x45, 0x00,
/* 000021D0 */ 0x4E, 0x00, 0x54, 0x00, 0x00, 0x00, 0x43, 0x00, 0x55, 0x00, 0x52, 0x00, 0x52, 0x00, 0x45, 0x00,
/* 000021E0 */ 0x4E, 0x00, 0x43, 0x00, 0x59, 0x00, 0x00, 0x00, 0x4D, 0x00, 0x41, 0x00, 0x58, 0x00, 0x00, 0x00,
/* 000021F0 */ 0x53, 0x00, 0x59, 0x00, 0x4D, 0x00, 0x42, 0x00, 0x4F, 0x00, 0x4C, 0x00, 0x00, 0x00, 0x43, 0x00,
/* 00002200 */ 0x4F, 0x00, 0x44, 0x00, 0x45, 0x00, 0x00, 0x00, 0x4E, 0x00, 0x41, 0x00, 0x4D, 0x00, 0x45, 0x00,
/* 00002210 */ 0x00, 0x00, 0x4E, 0x00, 0x75, 0x00, 0x6D, 0x00, 0x62, 0x00, 0x65, 0x00, 0x72, 0x00, 0x00, 0x00,
/* 00002220 */ 0x4E, 0x00, 0x75, 0x00, 0x6D, 0x00, 0x62, 0x00, 0x65, 0x00, 0x72, 0x00, 0x2E, 0x00, 0x70, 0x00,
/* 00002230 */ 0x72, 0x00, 0x6F, 0x00, 0x74, 0x00, 0x6F, 0x00, 0x74, 0x00, 0x79, 0x00, 0x70, 0x00, 0x65, 0x00,
/* 00002240 */ 0x2E, 0x00, 0x74, 0x00, 0x6F, 0x00, 0x4C, 0x00, 0x6F, 0x00, 0x63, 0x00, 0x61, 0x00, 0x6C, 0x00,
/* 00002250 */ 0x65, 0x00, 0x53, 0x00, 0x74, 0x00, 0x72, 0x00, 0x69, 0x00, 0x6E, 0x00, 0x67, 0x00, 0x00, 0x00,
/* 00002260 */ 0x49, 0x00, 0x6E, 0x00, 0x74, 0x00, 0x6C, 0x00, 0x2E, 0x00, 0x4E, 0x00, 0x75, 0x00, 0x6D, 0x00,
/* 00002270 */ 0x62, 0x00, 0x65, 0x00, 0x72, 0x00, 0x46, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x6D, 0x00, 0x61, 0x00,
/* 00002280 */ 0x74, 0x00, 0x00, 0x00, 0x49, 0x00, 0x6E, 0x00, 0x74, 0x00, 0x6C, 0x00, 0x2E, 0x00, 0x4E, 0x00,
/* 00002290 */ 0x75, 0x00, 0x6D, 0x00, 0x62, 0x00, 0x65, 0x00, 0x72, 0x00, 0x46, 0x00, 0x6F, 0x00, 0x72, 0x00,
/* 000022A0 */ 0x6D, 0x00, 0x61, 0x00, 0x74, 0x00, 0x2E, 0x00, 0x70, 0x00, 0x72, 0x00, 0x6F, 0x00, 0x74, 0x00,
/* 000022B0 */ 0x6F, 0x00, 0x74, 0x00, 0x79, 0x00, 0x70, 0x00, 0x65, 0x00, 0x2E, 0x00, 0x66, 0x00, 0x6F, 0x00,
/* 000022C0 */ 0x72, 0x00, 0x6D, 0x00, 0x61, 0x00, 0x74, 0x00, 0x00, 0x00, 0x6E, 0x00, 0x75, 0x00, 0x6D, 0x00,
/* 000022D0 */ 0x62, 0x00, 0x65, 0x00, 0x72, 0x00, 0x69, 0x00, 0x6E, 0x00, 0x67, 0x00, 0x53, 0x00, 0x79, 0x00,
/* 000022E0 */ 0x73, 0x00, 0x74, 0x00, 0x65, 0x00, 0x6D, 0x00, 0x00, 0x00, 0x73, 0x00, 0x74, 0x00, 0x79, 0x00,
/* 000022F0 */ 0x6C, 0x00, 0x65, 0x00, 0x00, 0x00, 0x63, 0x00, 0x75, 0x00, 0x72, 0x00, 0x72, 0x00, 0x65, 0x00,
/* 00002300 */ 0x6E, 0x00, 0x63, 0x00, 0x79, 0x00, 0x00, 0x00, 0x63, 0x00, 0x75, 0x00, 0x72, 0x00, 0x72, 0x00,
/* 00002310 */ 0x65, 0x00, 0x6E, 0x00, 0x63, 0x00, 0x79, 0x00, 0x44, 0x00, 0x69, 0x00, 0x73, 0x00, 0x70, 0x00,
/* 00002320 */ 0x6C, 0x00, 0x61, 0x00, 0x79, 0x00, 0x00, 0x00, 0x6D, 0x00, 0x69, 0x00, 0x6E, 0x00, 0x69, 0x00,
/* 00002330 */ 0x6D, 0x00, 0x75, 0x00, 0x6D, 0x00, 0x49, 0x00, 0x6E, 0x00, 0x74, 0x00, 0x65, 0x00, 0x67, 0x00,
/* 00002340 */ 0x65, 0x00, 0x72, 0x00, 0x44, 0x00, 0x69, 0x00, 0x67, 0x00, 0x69, 0x00, 0x74, 0x00, 0x73, 0x00,
/* 00002350 */ 0x00, 0x00, 0x6D, 0x00, 0x69, 0x00, 0x6E, 0x00, 0x69, 0x00, 0x6D, 0x00, 0x75, 0x00, 0x6D, 0x00,
/* 00002360 */ 0x46, 0x00, 0x72, 0x00, 0x61, 0x00, 0x63, 0x00, 0x74, 0x00, 0x69, 0x00, 0x6F, 0x00, 0x6E, 0x00,
/* 00002370 */ 0x44, 0x00, 0x69, 0x00, 0x67, 0x00, 0x69, 0x00, 0x74, 0x00, 0x73, 0x00, 0x00, 0x00, 0x6D, 0x00,
/* 00002380 */ 0x61, 0x00, 0x78, 0x00, 0x69, 0x00, 0x6D, 0x00, 0x75, 0x00, 0x6D, 0x00, 0x46, 0x00, 0x72, 0x00,
/* 00002390 */ 0x61, 0x00, 0x63, 0x00, 0x74, 0x00, 0x69, 0x00, 0x6F, 0x00, 0x6E, 0x00, 0x44, 0x00, 0x69, 0x00,
/* 000023A0 */ 0x67, 0x00, 0x69, 0x00, 0x74, 0x00, 0x73, 0x00, 0x00, 0x00, 0x6D, 0x00, 0x69, 0x00, 0x6E, 0x00,
/* 000023B0 */ 0x69, 0x00, 0x6D, 0x00, 0x75, 0x00, 0x6D, 0x00, 0x53, 0x00, 0x69, 0x00, 0x67, 0x00, 0x6E, 0x00,
/* 000023C0 */ 0x69, 0x00, 0x66, 0x00, 0x69, 0x00, 0x63, 0x00, 0x61, 0x00, 0x6E, 0x00, 0x74, 0x00, 0x44, 0x00,
/* 000023D0 */ 0x69, 0x00, 0x67, 0x00, 0x69, 0x00, 0x74, 0x00, 0x73, 0x00, 0x00, 0x00, 0x6D, 0x00, 0x61, 0x00,
/* 000023E0 */ 0x78, 0x00, 0x69, 0x00, 0x6D, 0x00, 0x75, 0x00, 0x6D, 0x00, 0x53, 0x00, 0x69, 0x00, 0x67, 0x00,
/* 000023F0 */ 0x6E, 0x00, 0x69, 0x00, 0x66, 0x00, 0x69, 0x00, 0x63, 0x00, 0x61, 0x00, 0x6E, 0x00, 0x74, 0x00,
/* 00002400 */ 0x44, 0x00, 0x69, 0x00, 0x67, 0x00, 0x69, 0x00, 0x74, 0x00, 0x73, 0x00, 0x00, 0x00, 0x75, 0x00,
/* 00002410 */ 0x73, 0x00, 0x65, 0x00, 0x47, 0x00, 0x72, 0x00, 0x6F, 0x00, 0x75, 0x00, 0x70, 0x00, 0x69, 0x00,
/* 00002420 */ 0x6E, 0x00, 0x67, 0x00, 0x00, 0x00, 0x66, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x6D, 0x00, 0x61, 0x00,
/* 00002430 */ 0x74, 0x00, 0x00, 0x00, 0x67, 0x00, 0x65, 0x00, 0x74, 0x00, 0x20, 0x00, 0x66, 0x00, 0x6F, 0x00,
/* 00002440 */ 0x72, 0x00, 0x6D, 0x00, 0x61, 0x00, 0x74, 0x00, 0x00, 0x00, 0x4E, 0x00, 0x75, 0x00, 0x6D, 0x00,
/* 00002450 */ 0x62, 0x00, 0x65, 0x00, 0x72, 0x00, 0x46, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x6D, 0x00, 0x61, 0x00,
/* 00002460 */ 0x74, 0x00, 0x53, 0x00, 0x74, 0x00, 0x79, 0x00, 0x6C, 0x00, 0x65, 0x00, 0x00, 0x00, 0x4E, 0x00,
/* 00002470 */ 0x75, 0x00, 0x6D, 0x00, 0x62, 0x00, 0x65, 0x00, 0x72, 0x00, 0x46, 0x00, 0x6F, 0x00, 0x72, 0x00,
/* 00002480 */ 0x6D, 0x00, 0x61, 0x00, 0x74, 0x00, 0x43, 0x00, 0x75, 0x00, 0x72, 0x00, 0x72, 0x00, 0x65, 0x00,
/* 00002490 */ 0x6E, 0x00, 0x63, 0x00, 0x79, 0x00, 0x44, 0x00, 0x69, 0x00, 0x73, 0x00, 0x70, 0x00, 0x6C, 0x00,
/* 000024A0 */ 0x61, 0x00, 0x79, 0x00, 0x00, 0x00, 0x49, 0x00, 0x6E, 0x00, 0x69, 0x00, 0x74, 0x00, 0x69, 0x00,
/* 000024B0 */ 0x61, 0x00, 0x6C, 0x00, 0x69, 0x00, 0x7A, 0x00, 0x65, 0x00, 0x4E, 0x00, 0x75, 0x00, 0x6D, 0x00,
/* 000024C0 */ 0x62, 0x00, 0x65, 0x00, 0x72, 0x00, 0x46, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x6D, 0x00, 0x61, 0x00,
/* 000024D0 */ 0x74, 0x00, 0x00, 0x00, 0x64, 0x00, 0x65, 0x00, 0x63, 0x00, 0x69, 0x00, 0x6D, 0x00, 0x61, 0x00,
/* 000024E0 */ 0x6C, 0x00, 0x00, 0x00, 0x70, 0x00, 0x65, 0x00, 0x72, 0x00, 0x63, 0x00, 0x65, 0x00, 0x6E, 0x00,
/* 000024F0 */ 0x74, 0x00, 0x00, 0x00, 0x63, 0x00, 0x6F, 0x00, 0x64, 0x00, 0x65, 0x00, 0x00, 0x00, 0x73, 0x00,
/* 00002500 */ 0x79, 0x00, 0x6D, 0x00, 0x62, 0x00, 0x6F, 0x00, 0x6C, 0x00, 0x00, 0x00, 0x6E, 0x00, 0x75, 0x00,
/* 00002510 */ 0x00, 0x00, 0x6C, 0x00, 0x61, 0x00, 0x74, 0x00, 0x6E, 0x00, 0x00, 0x00, 0x5F, 0x00, 0x5F, 0x00,
/* 00002520 */ 0x6C, 0x00, 0x6F, 0x00, 0x63, 0x00, 0x61, 0x00, 0x6C, 0x00, 0x65, 0x00, 0x4D, 0x00, 0x61, 0x00,
/* 00002530 */ 0x74, 0x00, 0x63, 0x00, 0x68, 0x00, 0x65, 0x00, 0x72, 0x00, 0x00, 0x00, 0x4E, 0x00, 0x75, 0x00,
/* 00002540 */ 0x6D, 0x00, 0x62, 0x00, 0x65, 0x00, 0x72, 0x00, 0x46, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x6D, 0x00,
/* 00002550 */ 0x61, 0x00, 0x74, 0x00, 0x2E, 0x00, 0x70, 0x00, 0x72, 0x00, 0x6F, 0x00, 0x74, 0x00, 0x6F, 0x00,
/* 00002560 */ 0x74, 0x00, 0x79, 0x00, 0x70, 0x00, 0x65, 0x00, 0x2E, 0x00, 0x66, 0x00, 0x6F, 0x00, 0x72, 0x00,
/* 00002570 */ 0x6D, 0x00, 0x61, 0x00, 0x74, 0x00, 0x00, 0x00, 0x4E, 0x00, 0x75, 0x00, 0x6D, 0x00, 0x62, 0x00,
/* 00002580 */ 0x65, 0x00, 0x72, 0x00, 0x46, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x6D, 0x00, 0x61, 0x00, 0x74, 0x00,
/* 00002590 */ 0x2E, 0x00, 0x70, 0x00, 0x72, 0x00, 0x6F, 0x00, 0x74, 0x00, 0x6F, 0x00, 0x74, 0x00, 0x79, 0x00,
/* 000025A0 */ 0x70, 0x00, 0x65, 0x00, 0x2E, 0x00, 0x72, 0x00, 0x65, 0x00, 0x73, 0x00, 0x6F, 0x00, 0x6C, 0x00,
/* 000025B0 */ 0x76, 0x00, 0x65, 0x00, 0x64, 0x00, 0x4F, 0x00, 0x70, 0x00, 0x74, 0x00, 0x69, 0x00, 0x6F, 0x00,
/* 000025C0 */ 0x6E, 0x00, 0x73, 0x00, 0x00, 0x00, 0x68, 0x00, 0x69, 0x00, 0x64, 0x00, 0x64, 0x00, 0x65, 0x00,
/* 000025D0 */ 0x6E, 0x00, 0x4F, 0x00, 0x62, 0x00, 0x6A, 0x00, 0x65, 0x00, 0x63, 0x00, 0x74, 0x00, 0x00, 0x00,
/* 000025E0 */ 0x5F, 0x00, 0x5F, 0x00, 0x00, 0x00, 0x44, 0x00, 0x61, 0x00, 0x74, 0x00, 0x65, 0x00, 0x00, 0x00,
/* 000025F0 */ 0x47, 0x00, 0x72, 0x00, 0x65, 0x00, 0x67, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x69, 0x00, 0x61, 0x00,
/* 00002600 */ 0x6E, 0x00, 0x43, 0x00, 0x61, 0x00, 0x6C, 0x00, 0x65, 0x00, 0x6E, 0x00, 0x64, 0x00, 0x61, 0x00,
/* 00002610 */ 0x72, 0x00, 0x00, 0x00, 0x67, 0x00, 0x72, 0x00, 0x65, 0x00, 0x67, 0x00, 0x6F, 0x00, 0x72, 0x00,
/* 00002620 */ 0x79, 0x00, 0x00, 0x00, 0x48, 0x00, 0x65, 0x00, 0x62, 0x00, 0x72, 0x00, 0x65, 0x00, 0x77, 0x00,
/* 00002630 */ 0x43, 0x00, 0x61, 0x00, 0x6C, 0x00, 0x65, 0x00, 0x6E, 0x00, 0x64, 0x00, 0x61, 0x00, 0x72, 0x00,
/* 00002640 */ 0x00, 0x00, 0x68, 0x00, 0x65, 0x00, 0x62, 0x00, 0x72, 0x00, 0x65, 0x00, 0x77, 0x00, 0x00, 0x00,
/* 00002650 */ 0x48, 0x00, 0x69, 0x00, 0x6A, 0x00, 0x72, 0x00, 0x69, 0x00, 0x43, 0x00, 0x61, 0x00, 0x6C, 0x00,
/* 00002660 */ 0x65, 0x00, 0x6E, 0x00, 0x64, 0x00, 0x61, 0x00, 0x72, 0x00, 0x00, 0x00, 0x69, 0x00, 0x73, 0x00,
/* 00002670 */ 0x6C, 0x00, 0x61, 0x00, 0x6D, 0x00, 0x69, 0x00, 0x63, 0x00, 0x00, 0x00, 0x4A, 0x00, 0x61, 0x00,
/* 00002680 */ 0x70, 0x00, 0x61, 0x00, 0x6E, 0x00, 0x65, 0x00, 0x73, 0x00, 0x65, 0x00, 0x43, 0x00, 0x61, 0x00,
/* 00002690 */ 0x6C, 0x00, 0x65, 0x00, 0x6E, 0x00, 0x64, 0x00, 0x61, 0x00, 0x72, 0x00, 0x00, 0x00, 0x6A, 0x00,
/* 000026A0 */ 0x61, 0x00, 0x70, 0x00, 0x61, 0x00, 0x6E, 0x00, 0x65, 0x00, 0x73, 0x00, 0x65, 0x00, 0x00, 0x00,
/* 000026B0 */ 0x4A, 0x00, 0x75, 0x00, 0x6C, 0x00, 0x69, 0x00, 0x61, 0x00, 0x6E, 0x00, 0x43, 0x00, 0x61, 0x00,
/* 000026C0 */ 0x6C, 0x00, 0x65, 0x00, 0x6E, 0x00, 0x64, 0x00, 0x61, 0x00, 0x72, 0x00, 0x00, 0x00, 0x6A, 0x00,
/* 000026D0 */ 0x75, 0x00, 0x6C, 0x00, 0x69, 0x00, 0x61, 0x00, 0x6E, 0x00, 0x00, 0x00, 0x4B, 0x00, 0x6F, 0x00,
/* 000026E0 */ 0x72, 0x00, 0x65, 0x00, 0x61, 0x00, 0x6E, 0x00, 0x43, 0x00, 0x61, 0x00, 0x6C, 0x00, 0x65, 0x00,
/* 000026F0 */ 0x6E, 0x00, 0x64, 0x00, 0x61, 0x00, 0x72, 0x00, 0x00, 0x00, 0x6B, 0x00, 0x6F, 0x00, 0x72, 0x00,
/* 00002700 */ 0x65, 0x00, 0x61, 0x00, 0x6E, 0x00, 0x00, 0x00, 0x55, 0x00, 0x6D, 0x00, 0x41, 0x00, 0x6C, 0x00,
/* 00002710 */ 0x51, 0x00, 0x75, 0x00, 0x72, 0x00, 0x61, 0x00, 0x43, 0x00, 0x61, 0x00, 0x6C, 0x00, 0x65, 0x00,
/* 00002720 */ 0x6E, 0x00, 0x64, 0x00, 0x61, 0x00, 0x72, 0x00, 0x00, 0x00, 0x69, 0x00, 0x73, 0x00, 0x6C, 0x00,
/* 00002730 */ 0x61, 0x00, 0x6D, 0x00, 0x69, 0x00, 0x63, 0x00, 0x2D, 0x00, 0x63, 0x00, 0x69, 0x00, 0x76, 0x00,
/* 00002740 */ 0x69, 0x00, 0x6C, 0x00, 0x00, 0x00, 0x54, 0x00, 0x68, 0x00, 0x61, 0x00, 0x69, 0x00, 0x43, 0x00,
/* 00002750 */ 0x61, 0x00, 0x6C, 0x00, 0x65, 0x00, 0x6E, 0x00, 0x64, 0x00, 0x61, 0x00, 0x72, 0x00, 0x00, 0x00,
/* 00002760 */ 0x74, 0x00, 0x68, 0x00, 0x61, 0x00, 0x69, 0x00, 0x00, 0x00, 0x54, 0x00, 0x61, 0x00, 0x69, 0x00,
/* 00002770 */ 0x77, 0x00, 0x61, 0x00, 0x6E, 0x00, 0x43, 0x00, 0x61, 0x00, 0x6C, 0x00, 0x65, 0x00, 0x6E, 0x00,
/* 00002780 */ 0x64, 0x00, 0x61, 0x00, 0x72, 0x00, 0x00, 0x00, 0x74, 0x00, 0x61, 0x00, 0x69, 0x00, 0x77, 0x00,
/* 00002790 */ 0x61, 0x00, 0x6E, 0x00, 0x00, 0x00, 0x44, 0x00, 0x61, 0x00, 0x74, 0x00, 0x65, 0x00, 0x2E, 0x00,
/* 000027A0 */ 0x70, 0x00, 0x72, 0x00, 0x6F, 0x00, 0x74, 0x00, 0x6F, 0x00, 0x74, 0x00, 0x79, 0x00, 0x70, 0x00,
/* 000027B0 */ 0x65, 0x00, 0x2E, 0x00, 0x74, 0x00, 0x6F, 0x00, 0x4C, 0x00, 0x6F, 0x00, 0x63, 0x00, 0x61, 0x00,
/* 000027C0 */ 0x6C, 0x00, 0x65, 0x00, 0x53, 0x00, 0x74, 0x00, 0x72, 0x00, 0x69, 0x00, 0x6E, 0x00, 0x67, 0x00,
/* 000027D0 */ 0x00, 0x00, 0x44, 0x00, 0x61, 0x00, 0x74, 0x00, 0x65, 0x00, 0x2E, 0x00, 0x70, 0x00, 0x72, 0x00,
/* 000027E0 */ 0x6F, 0x00, 0x74, 0x00, 0x6F, 0x00, 0x74, 0x00, 0x79, 0x00, 0x70, 0x00, 0x65, 0x00, 0x2E, 0x00,
/* 000027F0 */ 0x74, 0x00, 0x6F, 0x00, 0x4C, 0x00, 0x6F, 0x00, 0x63, 0x00, 0x61, 0x00, 0x6C, 0x00, 0x65, 0x00,
/* 00002800 */ 0x44, 0x00, 0x61, 0x00, 0x74, 0x00, 0x65, 0x00, 0x53, 0x00, 0x74, 0x00, 0x72, 0x00, 0x69, 0x00,
/* 00002810 */ 0x6E, 0x00, 0x67, 0x00, 0x00, 0x00, 0x44, 0x00, 0x61, 0x00, 0x74, 0x00, 0x65, 0x00, 0x2E, 0x00,
/* 00002820 */ 0x70, 0x00, 0x72, 0x00, 0x6F, 0x00, 0x74, 0x00, 0x6F, 0x00, 0x74, 0x00, 0x79, 0x00, 0x70, 0x00,
/* 00002830 */ 0x65, 0x00, 0x2E, 0x00, 0x74, 0x00, 0x6F, 0x00, 0x4C, 0x00, 0x6F, 0x00, 0x63, 0x00, 0x61, 0x00,
/* 00002840 */ 0x6C, 0x00, 0x65, 0x00, 0x54, 0x00, 0x69, 0x00, 0x6D, 0x00, 0x65, 0x00, 0x53, 0x00, 0x74, 0x00,
/* 00002850 */ 0x72, 0x00, 0x69, 0x00, 0x6E, 0x00, 0x67, 0x00, 0x00, 0x00, 0x49, 0x00, 0x6E, 0x00, 0x74, 0x00,
/* 00002860 */ 0x6C, 0x00, 0x2E, 0x00, 0x44, 0x00, 0x61, 0x00, 0x74, 0x00, 0x65, 0x00, 0x54, 0x00, 0x69, 0x00,
/* 00002870 */ 0x6D, 0x00, 0x65, 0x00, 0x46, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x6D, 0x00, 0x61, 0x00, 0x74, 0x00,
/* 00002880 */ 0x00, 0x00, 0x49, 0x00, 0x6E, 0x00, 0x74, 0x00, 0x6C, 0x00, 0x2E, 0x00, 0x44, 0x00, 0x61, 0x00,
/* 00002890 */ 0x74, 0x00, 0x65, 0x00, 0x54, 0x00, 0x69, 0x00, 0x6D, 0x00, 0x65, 0x00, 0x46, 0x00, 0x6F, 0x00,
/* 000028A0 */ 0x72, 0x00, 0x6D, 0x00, 0x61, 0x00, 0x74, 0x00, 0x2E, 0x00, 0x70, 0x00, 0x72, 0x00, 0x6F, 0x00,
/* 000028B0 */ 0x74, 0x00, 0x6F, 0x00, 0x74, 0x00, 0x79, 0x00, 0x70, 0x00, 0x65, 0x00, 0x2E, 0x00, 0x66, 0x00,
/* 000028C0 */ 0x6F, 0x00, 0x72, 0x00, 0x6D, 0x00, 0x61, 0x00, 0x74, 0x00, 0x00, 0x00, 0x63, 0x00, 0x61, 0x00,
/* 000028D0 */ 0x00, 0x00, 0x57, 0x00, 0x69, 0x00, 0x6E, 0x00, 0x64, 0x00, 0x6F, 0x00, 0x77, 0x00, 0x73, 0x00,
/* 000028E0 */ 0x54, 0x00, 0x6F, 0x00, 0x45, 0x00, 0x63, 0x00, 0x6D, 0x00, 0x61, 0x00, 0x43, 0x00, 0x61, 0x00,
/* 000028F0 */ 0x6C, 0x00, 0x65, 0x00, 0x6E, 0x00, 0x64, 0x00, 0x61, 0x00, 0x72, 0x00, 0x4D, 0x00, 0x61, 0x00,
/* 00002900 */ 0x70, 0x00, 0x00, 0x00, 0x54, 0x00, 0x6F, 0x00, 0x44, 0x00, 0x61, 0x00, 0x74, 0x00, 0x65, 0x00,
/* 00002910 */ 0x54, 0x00, 0x69, 0x00, 0x6D, 0x00, 0x65, 0x00, 0x4F, 0x00, 0x70, 0x00, 0x74, 0x00, 0x69, 0x00,
/* 00002920 */ 0x6F, 0x00, 0x6E, 0x00, 0x73, 0x00, 0x00, 0x00, 0x45, 0x00, 0x63, 0x00, 0x6D, 0x00, 0x61, 0x00,
/* 00002930 */ 0x4F, 0x00, 0x70, 0x00, 0x74, 0x00, 0x69, 0x00, 0x6F, 0x00, 0x6E, 0x00, 0x73, 0x00, 0x54, 0x00,
/* 00002940 */ 0x6F, 0x00, 0x57, 0x00, 0x69, 0x00, 0x6E, 0x00, 0x64, 0x00, 0x6F, 0x00, 0x77, 0x00, 0x73, 0x00,
/* 00002950 */ 0x54, 0x00, 0x65, 0x00, 0x6D, 0x00, 0x70, 0x00, 0x6C, 0x00, 0x61, 0x00, 0x74, 0x00, 0x65, 0x00,
/* 00002960 */ 0x00, 0x00, 0x57, 0x00, 0x69, 0x00, 0x6E, 0x00, 0x64, 0x00, 0x6F, 0x00, 0x77, 0x00, 0x73, 0x00,
/* 00002970 */ 0x54, 0x00, 0x6F, 0x00, 0x45, 0x00, 0x63, 0x00, 0x6D, 0x00, 0x61, 0x00, 0x43, 0x00, 0x61, 0x00,
/* 00002980 */ 0x6C, 0x00, 0x65, 0x00, 0x6E, 0x00, 0x64, 0x00, 0x61, 0x00, 0x72, 0x00, 0x00, 0x00, 0x63, 0x00,
/* 00002990 */ 0x6F, 0x00, 0x72, 0x00, 0x72, 0x00, 0x65, 0x00, 0x63, 0x00, 0x74, 0x00, 0x57, 0x00, 0x65, 0x00,
/* 000029A0 */ 0x65, 0x00, 0x6B, 0x00, 0x64, 0x00, 0x61, 0x00, 0x79, 0x00, 0x45, 0x00, 0x72, 0x00, 0x61, 0x00,
/* 000029B0 */ 0x4D, 0x00, 0x6F, 0x00, 0x6E, 0x00, 0x74, 0x00, 0x68, 0x00, 0x50, 0x00, 0x61, 0x00, 0x74, 0x00,
/* 000029C0 */ 0x74, 0x00, 0x65, 0x00, 0x72, 0x00, 0x6E, 0x00, 0x00, 0x00, 0x63, 0x00, 0x6F, 0x00, 0x72, 0x00,
/* 000029D0 */ 0x72, 0x00, 0x65, 0x00, 0x63, 0x00, 0x74, 0x00, 0x44, 0x00, 0x61, 0x00, 0x79, 0x00, 0x48, 0x00,
/* 000029E0 */ 0x6F, 0x00, 0x75, 0x00, 0x72, 0x00, 0x4D, 0x00, 0x69, 0x00, 0x6E, 0x00, 0x75, 0x00, 0x74, 0x00,
/* 000029F0 */ 0x65, 0x00, 0x53, 0x00, 0x65, 0x00, 0x63, 0x00, 0x6F, 0x00, 0x6E, 0x00, 0x64, 0x00, 0x4D, 0x00,
/* 00002A00 */ 0x6F, 0x00, 0x6E, 0x00, 0x74, 0x00, 0x68, 0x00, 0x50, 0x00, 0x61, 0x00, 0x74, 0x00, 0x74, 0x00,
/* 00002A10 */ 0x65, 0x00, 0x72, 0x00, 0x6E, 0x00, 0x00, 0x00, 0x75, 0x00, 0x70, 0x00, 0x64, 0x00, 0x61, 0x00,
/* 00002A20 */ 0x74, 0x00, 0x65, 0x00, 0x50, 0x00, 0x61, 0x00, 0x74, 0x00, 0x74, 0x00, 0x65, 0x00, 0x72, 0x00,
/* 00002A30 */ 0x6E, 0x00, 0x53, 0x00, 0x74, 0x00, 0x72, 0x00, 0x69, 0x00, 0x6E, 0x00, 0x67, 0x00, 0x73, 0x00,
/* 00002A40 */ 0x00, 0x00, 0x49, 0x00, 0x6E, 0x00, 0x69, 0x00, 0x74, 0x00, 0x69, 0x00, 0x61, 0x00, 0x6C, 0x00,
/* 00002A50 */ 0x69, 0x00, 0x7A, 0x00, 0x65, 0x00, 0x44, 0x00, 0x61, 0x00, 0x74, 0x00, 0x65, 0x00, 0x54, 0x00,
/* 00002A60 */ 0x69, 0x00, 0x6D, 0x00, 0x65, 0x00, 0x46, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x6D, 0x00, 0x61, 0x00,
/* 00002A70 */ 0x74, 0x00, 0x00, 0x00, 0x64, 0x00, 0x61, 0x00, 0x74, 0x00, 0x65, 0x00, 0x00, 0x00, 0x61, 0x00,
/* 00002A80 */ 0x6E, 0x00, 0x79, 0x00, 0x00, 0x00, 0x74, 0x00, 0x69, 0x00, 0x6D, 0x00, 0x65, 0x00, 0x00, 0x00,
/* 00002A90 */ 0x61, 0x00, 0x6C, 0x00, 0x6C, 0x00, 0x00, 0x00, 0x79, 0x00, 0x65, 0x00, 0x61, 0x00, 0x72, 0x00,
/* 00002AA0 */ 0x00, 0x00, 0x6D, 0x00, 0x6F, 0x00, 0x6E, 0x00, 0x74, 0x00, 0x68, 0x00, 0x00, 0x00, 0x64, 0x00,
/* 00002AB0 */ 0x61, 0x00, 0x79, 0x00, 0x00, 0x00, 0x68, 0x00, 0x6F, 0x00, 0x75, 0x00, 0x72, 0x00, 0x00, 0x00,
/* 00002AC0 */ 0x6D, 0x00, 0x69, 0x00, 0x6E, 0x00, 0x75, 0x00, 0x74, 0x00, 0x65, 0x00, 0x00, 0x00, 0x73, 0x00,
/* 00002AD0 */ 0x65, 0x00, 0x63, 0x00, 0x6F, 0x00, 0x6E, 0x00, 0x64, 0x00, 0x00, 0x00, 0x6E, 0x00, 0x61, 0x00,
/* 00002AE0 */ 0x72, 0x00, 0x72, 0x00, 0x6F, 0x00, 0x77, 0x00, 0x00, 0x00, 0x73, 0x00, 0x68, 0x00, 0x6F, 0x00,
/* 00002AF0 */ 0x72, 0x00, 0x74, 0x00, 0x00, 0x00, 0x64, 0x00, 0x61, 0x00, 0x79, 0x00, 0x6F, 0x00, 0x66, 0x00,
/* 00002B00 */ 0x77, 0x00, 0x65, 0x00, 0x65, 0x00, 0x6B, 0x00, 0x2E, 0x00, 0x61, 0x00, 0x62, 0x00, 0x62, 0x00,
/* 00002B10 */ 0x72, 0x00, 0x65, 0x00, 0x76, 0x00, 0x69, 0x00, 0x61, 0x00, 0x74, 0x00, 0x65, 0x00, 0x64, 0x00,
/* 00002B20 */ 0x00, 0x00, 0x6C, 0x00, 0x6F, 0x00, 0x6E, 0x00, 0x67, 0x00, 0x00, 0x00, 0x64, 0x00, 0x61, 0x00,
/* 00002B30 */ 0x79, 0x00, 0x6F, 0x00, 0x66, 0x00, 0x77, 0x00, 0x65, 0x00, 0x65, 0x00, 0x6B, 0x00, 0x2E, 0x00,
/* 00002B40 */ 0x66, 0x00, 0x75, 0x00, 0x6C, 0x00, 0x6C, 0x00, 0x00, 0x00, 0x32, 0x00, 0x2D, 0x00, 0x64, 0x00,
/* 00002B50 */ 0x69, 0x00, 0x67, 0x00, 0x69, 0x00, 0x74, 0x00, 0x00, 0x00, 0x79, 0x00, 0x65, 0x00, 0x61, 0x00,
/* 00002B60 */ 0x72, 0x00, 0x2E, 0x00, 0x61, 0x00, 0x62, 0x00, 0x62, 0x00, 0x72, 0x00, 0x65, 0x00, 0x76, 0x00,
/* 00002B70 */ 0x69, 0x00, 0x61, 0x00, 0x74, 0x00, 0x65, 0x00, 0x64, 0x00, 0x00, 0x00, 0x79, 0x00, 0x65, 0x00,
/* 00002B80 */ 0x61, 0x00, 0x72, 0x00, 0x2E, 0x00, 0x66, 0x00, 0x75, 0x00, 0x6C, 0x00, 0x6C, 0x00, 0x00, 0x00,
/* 00002B90 */ 0x6D, 0x00, 0x6F, 0x00, 0x6E, 0x00, 0x74, 0x00, 0x68, 0x00, 0x2E, 0x00, 0x6E, 0x00, 0x75, 0x00,
/* 00002BA0 */ 0x6D, 0x00, 0x65, 0x00, 0x72, 0x00, 0x69, 0x00, 0x63, 0x00, 0x00, 0x00, 0x6D, 0x00, 0x6F, 0x00,
/* 00002BB0 */ 0x6E, 0x00, 0x74, 0x00, 0x68, 0x00, 0x2E, 0x00, 0x61, 0x00, 0x62, 0x00, 0x62, 0x00, 0x72, 0x00,
/* 00002BC0 */ 0x65, 0x00, 0x76, 0x00, 0x69, 0x00, 0x61, 0x00, 0x74, 0x00, 0x65, 0x00, 0x64, 0x00, 0x00, 0x00,
/* 00002BD0 */ 0x6D, 0x00, 0x6F, 0x00, 0x6E, 0x00, 0x74, 0x00, 0x68, 0x00, 0x2E, 0x00, 0x66, 0x00, 0x75, 0x00,
/* 00002BE0 */ 0x6C, 0x00, 0x6C, 0x00, 0x00, 0x00, 0x74, 0x00, 0x69, 0x00, 0x6D, 0x00, 0x65, 0x00, 0x7A, 0x00,
/* 00002BF0 */ 0x6F, 0x00, 0x6E, 0x00, 0x65, 0x00, 0x2E, 0x00, 0x61, 0x00, 0x62, 0x00, 0x62, 0x00, 0x72, 0x00,
/* 00002C00 */ 0x65, 0x00, 0x76, 0x00, 0x69, 0x00, 0x61, 0x00, 0x74, 0x00, 0x65, 0x00, 0x64, 0x00, 0x00, 0x00,
/* 00002C10 */ 0x74, 0x00, 0x69, 0x00, 0x6D, 0x00, 0x65, 0x00, 0x7A, 0x00, 0x6F, 0x00, 0x6E, 0x00, 0x65, 0x00,
/* 00002C20 */ 0x2E, 0x00, 0x66, 0x00, 0x75, 0x00, 0x6C, 0x00, 0x6C, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00,
/* 00002C30 */ 0x74, 0x00, 0x65, 0x00, 0x6D, 0x00, 0x70, 0x00, 0x6C, 0x00, 0x61, 0x00, 0x74, 0x00, 0x65, 0x00,
/* 00002C40 */ 0x00, 0x00, 0x7B, 0x00, 0x28, 0x00, 0x00, 0x00, 0x28, 0x00, 0x3F, 0x00, 0x3A, 0x00, 0x5C, 0x00,
/* 00002C50 */ 0x2E, 0x00, 0x73, 0x00, 0x6F, 0x00, 0x6C, 0x00, 0x6F, 0x00, 0x29, 0x00, 0x3F, 0x00, 0x29, 0x00,
/* 00002C60 */ 0x5C, 0x00, 0x2E, 0x00, 0x28, 0x00, 0x5B, 0x00, 0x61, 0x00, 0x2D, 0x00, 0x7A, 0x00, 0x5D, 0x00,
/* 00002C70 */ 0x2A, 0x00, 0x29, 0x00, 0x28, 0x00, 0x3F, 0x00, 0x3A, 0x00, 0x5C, 0x00, 0x28, 0x00, 0x5B, 0x00,
/* 00002C80 */ 0x30, 0x00, 0x2D, 0x00, 0x39, 0x00, 0x5D, 0x00, 0x5C, 0x00, 0x29, 0x00, 0x29, 0x00, 0x3F, 0x00,
/* 00002C90 */ 0x7D, 0x00, 0x00, 0x00, 0x45, 0x00, 0x72, 0x00, 0x72, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x20, 0x00,
/* 00002CA0 */ 0x77, 0x00, 0x68, 0x00, 0x65, 0x00, 0x6E, 0x00, 0x20, 0x00, 0x63, 0x00, 0x6F, 0x00, 0x72, 0x00,
/* 00002CB0 */ 0x72, 0x00, 0x65, 0x00, 0x63, 0x00, 0x74, 0x00, 0x69, 0x00, 0x6E, 0x00, 0x67, 0x00, 0x20, 0x00,
/* 00002CC0 */ 0x77, 0x00, 0x69, 0x00, 0x6E, 0x00, 0x64, 0x00, 0x6F, 0x00, 0x77, 0x00, 0x73, 0x00, 0x20, 0x00,
/* 00002CD0 */ 0x72, 0x00, 0x65, 0x00, 0x74, 0x00, 0x75, 0x00, 0x72, 0x00, 0x6E, 0x00, 0x65, 0x00, 0x64, 0x00,
/* 00002CE0 */ 0x20, 0x00, 0x77, 0x00, 0x65, 0x00, 0x65, 0x00, 0x6B, 0x00, 0x64, 0x00, 0x61, 0x00, 0x79, 0x00,
/* 00002CF0 */ 0x2F, 0x00, 0x45, 0x00, 0x72, 0x00, 0x61, 0x00, 0x2F, 0x00, 0x4D, 0x00, 0x6F, 0x00, 0x6E, 0x00,
/* 00002D00 */ 0x74, 0x00, 0x68, 0x00, 0x20, 0x00, 0x70, 0x00, 0x61, 0x00, 0x74, 0x00, 0x74, 0x00, 0x65, 0x00,
/* 00002D10 */ 0x72, 0x00, 0x6E, 0x00, 0x3B, 0x00, 0x20, 0x00, 0x72, 0x00, 0x65, 0x00, 0x67, 0x00, 0x65, 0x00,
/* 00002D20 */ 0x78, 0x00, 0x20, 0x00, 0x72, 0x00, 0x65, 0x00, 0x74, 0x00, 0x75, 0x00, 0x72, 0x00, 0x6E, 0x00,
/* 00002D30 */ 0x65, 0x00, 0x64, 0x00, 0x20, 0x00, 0x6E, 0x00, 0x75, 0x00, 0x6C, 0x00, 0x6C, 0x00, 0x2E, 0x00,
/* 00002D40 */ 0x20, 0x00, 0x0A, 0x00, 0x49, 0x00, 0x6E, 0x00, 0x70, 0x00, 0x75, 0x00, 0x74, 0x00, 0x20, 0x00,
/* 00002D50 */ 0x77, 0x00, 0x61, 0x00, 0x73, 0x00, 0x3A, 0x00, 0x20, 0x00, 0x27, 0x00, 0x00, 0x00, 0x27, 0x00,
/* 00002D60 */ 0x0A, 0x00, 0x52, 0x00, 0x65, 0x00, 0x67, 0x00, 0x65, 0x00, 0x78, 0x00, 0x3A, 0x00, 0x20, 0x00,
/* 00002D70 */ 0x27, 0x00, 0x00, 0x00, 0x28, 0x00, 0x5C, 0x00, 0x2E, 0x00, 0x73, 0x00, 0x6F, 0x00, 0x6C, 0x00,
/* 00002D80 */ 0x6F, 0x00, 0x29, 0x00, 0x3F, 0x00, 0x29, 0x00, 0x5C, 0x00, 0x2E, 0x00, 0x28, 0x00, 0x5B, 0x00,
/* 00002D90 */ 0x61, 0x00, 0x2D, 0x00, 0x7A, 0x00, 0x5D, 0x00, 0x2A, 0x00, 0x29, 0x00, 0x28, 0x00, 0x5C, 0x00,
/* 00002DA0 */ 0x28, 0x00, 0x5B, 0x00, 0x30, 0x00, 0x2D, 0x00, 0x39, 0x00, 0x5D, 0x00, 0x5C, 0x00, 0x29, 0x00,
/* 00002DB0 */ 0x29, 0x00, 0x3F, 0x00, 0x7D, 0x00, 0x27, 0x00, 0x00, 0x00, 0x66, 0x00, 0x75, 0x00, 0x6C, 0x00,
/* 00002DC0 */ 0x6C, 0x00, 0x00, 0x00, 0x7B, 0x00, 0x00, 0x00, 0x2E, 0x00, 0x00, 0x00, 0x7D, 0x00, 0x00, 0x00,
/* 00002DD0 */ 0x61, 0x00, 0x62, 0x00, 0x62, 0x00, 0x72, 0x00, 0x65, 0x00, 0x76, 0x00, 0x69, 0x00, 0x61, 0x00,
/* 00002DE0 */ 0x74, 0x00, 0x65, 0x00, 0x64, 0x00, 0x00, 0x00, 0x61, 0x00, 0x62, 0x00, 0x62, 0x00, 0x72, 0x00,
/* 00002DF0 */ 0x65, 0x00, 0x76, 0x00, 0x69, 0x00, 0x61, 0x00, 0x74, 0x00, 0x65, 0x00, 0x64, 0x00, 0x28, 0x00,
/* 00002E00 */ 0x31, 0x00, 0x29, 0x00, 0x00, 0x00, 0x29, 0x00, 0x28, 0x00, 0x3F, 0x00, 0x3A, 0x00, 0x5C, 0x00,
/* 00002E10 */ 0x2E, 0x00, 0x73, 0x00, 0x6F, 0x00, 0x6C, 0x00, 0x6F, 0x00, 0x29, 0x00, 0x3F, 0x00, 0x5C, 0x00,
/* 00002E20 */ 0x2E, 0x00, 0x28, 0x00, 0x5B, 0x00, 0x61, 0x00, 0x2D, 0x00, 0x7A, 0x00, 0x5D, 0x00, 0x2A, 0x00,
/* 00002E30 */ 0x29, 0x00, 0x28, 0x00, 0x3F, 0x00, 0x3A, 0x00, 0x5C, 0x00, 0x28, 0x00, 0x5B, 0x00, 0x30, 0x00,
/* 00002E40 */ 0x2D, 0x00, 0x39, 0x00, 0x5D, 0x00, 0x5C, 0x00, 0x29, 0x00, 0x29, 0x00, 0x3F, 0x00, 0x7D, 0x00,
/* 00002E50 */ 0x00, 0x00, 0x45, 0x00, 0x72, 0x00, 0x72, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x20, 0x00, 0x77, 0x00,
/* 00002E60 */ 0x68, 0x00, 0x65, 0x00, 0x6E, 0x00, 0x20, 0x00, 0x63, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x72, 0x00,
/* 00002E70 */ 0x65, 0x00, 0x63, 0x00, 0x74, 0x00, 0x69, 0x00, 0x6E, 0x00, 0x67, 0x00, 0x20, 0x00, 0x77, 0x00,
/* 00002E80 */ 0x69, 0x00, 0x6E, 0x00, 0x64, 0x00, 0x6F, 0x00, 0x77, 0x00, 0x73, 0x00, 0x20, 0x00, 0x72, 0x00,
/* 00002E90 */ 0x65, 0x00, 0x74, 0x00, 0x75, 0x00, 0x72, 0x00, 0x6E, 0x00, 0x65, 0x00, 0x64, 0x00, 0x20, 0x00,
/* 00002EA0 */ 0x64, 0x00, 0x61, 0x00, 0x79, 0x00, 0x2F, 0x00, 0x68, 0x00, 0x6F, 0x00, 0x75, 0x00, 0x72, 0x00,
/* 00002EB0 */ 0x2F, 0x00, 0x6D, 0x00, 0x69, 0x00, 0x6E, 0x00, 0x75, 0x00, 0x74, 0x00, 0x65, 0x00, 0x2F, 0x00,
/* 00002EC0 */ 0x73, 0x00, 0x65, 0x00, 0x63, 0x00, 0x6F, 0x00, 0x6E, 0x00, 0x64, 0x00, 0x2F, 0x00, 0x6D, 0x00,
/* 00002ED0 */ 0x6F, 0x00, 0x6E, 0x00, 0x74, 0x00, 0x68, 0x00, 0x20, 0x00, 0x70, 0x00, 0x61, 0x00, 0x74, 0x00,
/* 00002EE0 */ 0x74, 0x00, 0x65, 0x00, 0x72, 0x00, 0x6E, 0x00, 0x3B, 0x00, 0x20, 0x00, 0x72, 0x00, 0x65, 0x00,
/* 00002EF0 */ 0x67, 0x00, 0x65, 0x00, 0x78, 0x00, 0x20, 0x00, 0x72, 0x00, 0x65, 0x00, 0x74, 0x00, 0x75, 0x00,
/* 00002F00 */ 0x72, 0x00, 0x6E, 0x00, 0x65, 0x00, 0x64, 0x00, 0x20, 0x00, 0x6E, 0x00, 0x75, 0x00, 0x6C, 0x00,
/* 00002F10 */ 0x6C, 0x00, 0x2E, 0x00, 0x20, 0x00, 0x0A, 0x00, 0x49, 0x00, 0x6E, 0x00, 0x70, 0x00, 0x75, 0x00,
/* 00002F20 */ 0x74, 0x00, 0x20, 0x00, 0x77, 0x00, 0x61, 0x00, 0x73, 0x00, 0x3A, 0x00, 0x20, 0x00, 0x27, 0x00,
/* 00002F30 */ 0x00, 0x00, 0x2E, 0x00, 0x69, 0x00, 0x6E, 0x00, 0x74, 0x00, 0x65, 0x00, 0x67, 0x00, 0x65, 0x00,
/* 00002F40 */ 0x72, 0x00, 0x28, 0x00, 0x32, 0x00, 0x29, 0x00, 0x7D, 0x00, 0x00, 0x00, 0x69, 0x00, 0x6E, 0x00,
/* 00002F50 */ 0x74, 0x00, 0x65, 0x00, 0x67, 0x00, 0x65, 0x00, 0x72, 0x00, 0x00, 0x00, 0x2E, 0x00, 0x69, 0x00,
/* 00002F60 */ 0x6E, 0x00, 0x74, 0x00, 0x65, 0x00, 0x67, 0x00, 0x65, 0x00, 0x72, 0x00, 0x7D, 0x00, 0x00, 0x00,
/* 00002F70 */ 0x64, 0x00, 0x61, 0x00, 0x79, 0x00, 0x6F, 0x00, 0x66, 0x00, 0x77, 0x00, 0x65, 0x00, 0x65, 0x00,
/* 00002F80 */ 0x6B, 0x00, 0x00, 0x00, 0x45, 0x00, 0x72, 0x00, 0x72, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x20, 0x00,
/* 00002F90 */ 0x77, 0x00, 0x68, 0x00, 0x65, 0x00, 0x6E, 0x00, 0x20, 0x00, 0x63, 0x00, 0x6F, 0x00, 0x72, 0x00,
/* 00002FA0 */ 0x72, 0x00, 0x65, 0x00, 0x63, 0x00, 0x74, 0x00, 0x69, 0x00, 0x6E, 0x00, 0x67, 0x00, 0x20, 0x00,
/* 00002FB0 */ 0x77, 0x00, 0x69, 0x00, 0x6E, 0x00, 0x64, 0x00, 0x6F, 0x00, 0x77, 0x00, 0x73, 0x00, 0x20, 0x00,
/* 00002FC0 */ 0x72, 0x00, 0x65, 0x00, 0x74, 0x00, 0x75, 0x00, 0x72, 0x00, 0x6E, 0x00, 0x65, 0x00, 0x64, 0x00,
/* 00002FD0 */ 0x20, 0x00, 0x79, 0x00, 0x65, 0x00, 0x61, 0x00, 0x72, 0x00, 0x3B, 0x00, 0x20, 0x00, 0x72, 0x00,
/* 00002FE0 */ 0x65, 0x00, 0x67, 0x00, 0x65, 0x00, 0x78, 0x00, 0x20, 0x00, 0x72, 0x00, 0x65, 0x00, 0x74, 0x00,
/* 00002FF0 */ 0x75, 0x00, 0x72, 0x00, 0x6E, 0x00, 0x65, 0x00, 0x64, 0x00, 0x20, 0x00, 0x6E, 0x00, 0x75, 0x00,
/* 00003000 */ 0x6C, 0x00, 0x6C, 0x00, 0x00, 0x00, 0x7B, 0x00, 0x79, 0x00, 0x65, 0x00, 0x61, 0x00, 0x72, 0x00,
/* 00003010 */ 0x2E, 0x00, 0x61, 0x00, 0x62, 0x00, 0x62, 0x00, 0x72, 0x00, 0x65, 0x00, 0x76, 0x00, 0x69, 0x00,
/* 00003020 */ 0x61, 0x00, 0x74, 0x00, 0x65, 0x00, 0x64, 0x00, 0x28, 0x00, 0x32, 0x00, 0x29, 0x00, 0x7D, 0x00,
/* 00003030 */ 0x00, 0x00, 0x7B, 0x00, 0x79, 0x00, 0x65, 0x00, 0x61, 0x00, 0x72, 0x00, 0x2E, 0x00, 0x66, 0x00,
/* 00003040 */ 0x75, 0x00, 0x6C, 0x00, 0x6C, 0x00, 0x7D, 0x00, 0x00, 0x00, 0x74, 0x00, 0x69, 0x00, 0x6D, 0x00,
/* 00003050 */ 0x65, 0x00, 0x7A, 0x00, 0x6F, 0x00, 0x6E, 0x00, 0x65, 0x00, 0x00, 0x00, 0x5C, 0x00, 0x7B, 0x00,
/* 00003060 */ 0x79, 0x00, 0x65, 0x00, 0x61, 0x00, 0x72, 0x00, 0x5C, 0x00, 0x2E, 0x00, 0x5B, 0x00, 0x61, 0x00,
/* 00003070 */ 0x2D, 0x00, 0x7A, 0x00, 0x5D, 0x00, 0x2A, 0x00, 0x28, 0x00, 0x5C, 0x00, 0x28, 0x00, 0x5B, 0x00,
/* 00003080 */ 0x30, 0x00, 0x2D, 0x00, 0x39, 0x00, 0x5D, 0x00, 0x5C, 0x00, 0x29, 0x00, 0x29, 0x00, 0x3F, 0x00,
/* 00003090 */ 0x5C, 0x00, 0x7D, 0x00, 0x00, 0x00, 0x74, 0x00, 0x69, 0x00, 0x6D, 0x00, 0x65, 0x00, 0x5A, 0x00,
/* 000030A0 */ 0x6F, 0x00, 0x6E, 0x00, 0x65, 0x00, 0x00, 0x00, 0x77, 0x00, 0x65, 0x00, 0x65, 0x00, 0x6B, 0x00,
/* 000030B0 */ 0x64, 0x00, 0x61, 0x00, 0x79, 0x00, 0x00, 0x00, 0x65, 0x00, 0x72, 0x00, 0x61, 0x00, 0x00, 0x00,
/* 000030C0 */ 0x74, 0x00, 0x69, 0x00, 0x6D, 0x00, 0x65, 0x00, 0x5A, 0x00, 0x6F, 0x00, 0x6E, 0x00, 0x65, 0x00,
/* 000030D0 */ 0x4E, 0x00, 0x61, 0x00, 0x6D, 0x00, 0x65, 0x00, 0x00, 0x00, 0x68, 0x00, 0x6F, 0x00, 0x75, 0x00,
/* 000030E0 */ 0x72, 0x00, 0x31, 0x00, 0x32, 0x00, 0x00, 0x00, 0x66, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x6D, 0x00,
/* 000030F0 */ 0x61, 0x00, 0x74, 0x00, 0x4D, 0x00, 0x61, 0x00, 0x74, 0x00, 0x63, 0x00, 0x68, 0x00, 0x65, 0x00,
/* 00003100 */ 0x72, 0x00, 0x00, 0x00, 0x62, 0x00, 0x61, 0x00, 0x73, 0x00, 0x69, 0x00, 0x63, 0x00, 0x00, 0x00,
/* 00003110 */ 0x31, 0x00, 0x32, 0x00, 0x48, 0x00, 0x6F, 0x00, 0x75, 0x00, 0x72, 0x00, 0x43, 0x00, 0x6C, 0x00,
/* 00003120 */ 0x6F, 0x00, 0x63, 0x00, 0x6B, 0x00, 0x00, 0x00, 0x32, 0x00, 0x34, 0x00, 0x48, 0x00, 0x6F, 0x00,
/* 00003130 */ 0x75, 0x00, 0x72, 0x00, 0x43, 0x00, 0x6C, 0x00, 0x6F, 0x00, 0x63, 0x00, 0x6B, 0x00, 0x00, 0x00,
/* 00003140 */ 0x6E, 0x00, 0x6F, 0x00, 0x6E, 0x00, 0x65, 0x00, 0x00, 0x00, 0x49, 0x00, 0x6E, 0x00, 0x76, 0x00,
/* 00003150 */ 0x61, 0x00, 0x6C, 0x00, 0x69, 0x00, 0x64, 0x00, 0x20, 0x00, 0x44, 0x00, 0x61, 0x00, 0x74, 0x00,
/* 00003160 */ 0x65, 0x00, 0x00, 0x00, 0x44, 0x00, 0x61, 0x00, 0x74, 0x00, 0x65, 0x00, 0x54, 0x00, 0x69, 0x00,
/* 00003170 */ 0x6D, 0x00, 0x65, 0x00, 0x46, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x6D, 0x00, 0x61, 0x00, 0x74, 0x00,
/* 00003180 */ 0x2E, 0x00, 0x70, 0x00, 0x72, 0x00, 0x6F, 0x00, 0x74, 0x00, 0x6F, 0x00, 0x74, 0x00, 0x79, 0x00,
/* 00003190 */ 0x70, 0x00, 0x65, 0x00, 0x2E, 0x00, 0x66, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x6D, 0x00, 0x61, 0x00,
/* 000031A0 */ 0x74, 0x00, 0x00, 0x00, 0x44, 0x00, 0x61, 0x00, 0x74, 0x00, 0x65, 0x00, 0x54, 0x00, 0x69, 0x00,
/* 000031B0 */ 0x6D, 0x00, 0x65, 0x00, 0x46, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x6D, 0x00, 0x61, 0x00, 0x74, 0x00,
/* 000031C0 */ 0x2E, 0x00, 0x70, 0x00, 0x72, 0x00, 0x6F, 0x00, 0x74, 0x00, 0x6F, 0x00, 0x74, 0x00, 0x79, 0x00,
/* 000031D0 */ 0x70, 0x00, 0x65, 0x00, 0x2E, 0x00, 0x72, 0x00, 0x65, 0x00, 0x73, 0x00, 0x6F, 0x00, 0x6C, 0x00,
/* 000031E0 */ 0x76, 0x00, 0x65, 0x00, 0x64, 0x00, 0x4F, 0x00, 0x70, 0x00, 0x74, 0x00, 0x69, 0x00, 0x6F, 0x00,
/* 000031F0 */ 0x6E, 0x00, 0x73, 0x00, 0x00, 0x00, 0x63, 0x00, 0x61, 0x00, 0x6C, 0x00, 0x65, 0x00, 0x6E, 0x00,
/* 00003200 */ 0x64, 0x00, 0x61, 0x00, 0x72, 0x00, 0x00, 0x00, 0x74, 0x00, 0x65, 0x00, 0x6D, 0x00, 0x70, 0x00,
/* 00003210 */ 0x00, 0x00, 0xFE, 0xE4, 0x06, 0x00, 0x00, 0x00, 0x00, 0x6B, 0x00, 0x00, 0x00, 0x9D, 0x00, 0x00,
/* 00003220 */ 0x00, 0x08, 0x01, 0x00, 0x00, 0x73, 0x01, 0x00, 0x00, 0x75, 0x01, 0x00, 0x00, 0x84, 0x01, 0x00,
/* 00003230 */ 0x00, 0x96, 0x01, 0x00, 0x00, 0xBF, 0x01, 0x00, 0x00, 0xE9, 0x01, 0x00, 0x00, 0xEB, 0x01, 0x00,
/* 00003240 */ 0x00, 0x66, 0x02, 0x00, 0x00, 0x86, 0x02, 0x00, 0x00, 0x88, 0x02, 0x00, 0x00, 0xBD, 0x02, 0x00,
/* 00003250 */ 0x00, 0xF7, 0x02, 0x00, 0x00, 0xFE, 0x02, 0x00, 0x00, 0x34, 0x03, 0x00, 0x00, 0x6F, 0x03, 0x00,
/* 00003260 */ 0x00, 0x76, 0x03, 0x00, 0x00, 0x78, 0x03, 0x00, 0x00, 0xAC, 0x03, 0x00, 0x00, 0xEC, 0x03, 0x00,
/* 00003270 */ 0x00, 0x12, 0x04, 0x00, 0x00, 0x43, 0x04, 0x00, 0x00, 0x77, 0x04, 0x00, 0x00, 0x79, 0x04, 0x00,
/* 00003280 */ 0x00, 0x8B, 0x04, 0x00, 0x00, 0xAF, 0x04, 0x00, 0x00, 0xB1, 0x04, 0x00, 0x00, 0xC3, 0x04, 0x00,
/* 00003290 */ 0x00, 0xF9, 0x04, 0x00, 0x00, 0x33, 0x05, 0x00, 0x00, 0x75, 0x05, 0x00, 0x00, 0x77, 0x05, 0x00,
/* 000032A0 */ 0x00, 0x9C, 0x05, 0x00, 0x00, 0xBF, 0x05, 0x00, 0x00, 0xE2, 0x05, 0x00, 0x00, 0x05, 0x06, 0x00,
/* 000032B0 */ 0x00, 0x28, 0x06, 0x00, 0x00, 0x47, 0x06, 0x00, 0x00, 0x68, 0x06, 0x00, 0x00, 0x85, 0x06, 0x00,
/* 000032C0 */ 0x00, 0x87, 0x06, 0x00, 0x00, 0xB4, 0x06, 0x00, 0x00, 0xB6, 0x06, 0x00, 0x00, 0xD5, 0x06, 0x00,
/* 000032D0 */ 0x00, 0xFC, 0x06, 0x00, 0x00, 0x27, 0x07, 0x00, 0x00, 0x4E, 0x07, 0x00, 0x00, 0x74, 0x07, 0x00,
/* 000032E0 */ 0x00, 0x83, 0x07, 0x00, 0x00, 0x85, 0x07, 0x00, 0x00, 0xDA, 0x07, 0x00, 0x00, 0x2B, 0x08, 0x00,
/* 000032F0 */ 0x00, 0x8A, 0x08, 0x00, 0x00, 0xE7, 0x08, 0x00, 0x00, 0x5E, 0x09, 0x00, 0x00, 0x8F, 0x09, 0x00,
/* 00003300 */ 0x00, 0xE5, 0x09, 0x00, 0x00, 0x28, 0x0A, 0x00, 0x00, 0x73, 0x0A, 0x00, 0x00, 0x7B, 0x0A, 0x00,
/* 00003310 */ 0x00, 0x7D, 0x0A, 0x00, 0x00, 0xCA, 0x0A, 0x00, 0x00, 0x17, 0x0B, 0x00, 0x00, 0x5E, 0x0B, 0x00,
/* 00003320 */ 0x00, 0xA5, 0x0B, 0x00, 0x00, 0xA7, 0x0B, 0x00, 0x00, 0xF4, 0x0B, 0x00, 0x00, 0x3F, 0x0C, 0x00,
/* 00003330 */ 0x00, 0x7A, 0x0C, 0x00, 0x00, 0x7C, 0x0C, 0x00, 0x00, 0xCB, 0x0C, 0x00, 0x00, 0x22, 0x0D, 0x00,
/* 00003340 */ 0x00, 0x79, 0x0D, 0x00, 0x00, 0x7B, 0x0D, 0x00, 0x00, 0xB0, 0x0D, 0x00, 0x00, 0xB2, 0x0D, 0x00,
/* 00003350 */ 0x00, 0xF1, 0x0D, 0x00, 0x00, 0x2A, 0x0E, 0x00, 0x00, 0x2C, 0x0E, 0x00, 0x00, 0x52, 0x0E, 0x00,
/* 00003360 */ 0x00, 0x7E, 0x0E, 0x00, 0x00, 0xB4, 0x0E, 0x00, 0x00, 0xD9, 0x0E, 0x00, 0x00, 0xE4, 0x0E, 0x00,
/* 00003370 */ 0x00, 0xE6, 0x0E, 0x00, 0x00, 0x1B, 0x0F, 0x00, 0x00, 0x33, 0x0F, 0x00, 0x00, 0x83, 0x0F, 0x00,
/* 00003380 */ 0x00, 0xB6, 0x0F, 0x00, 0x00, 0xDB, 0x0F, 0x00, 0x00, 0xED, 0x0F, 0x00, 0x00, 0x14, 0x10, 0x00,
/* 00003390 */ 0x00, 0x1F, 0x10, 0x00, 0x00, 0x21, 0x10, 0x00, 0x00, 0x42, 0x10, 0x00, 0x00, 0x4A, 0x10, 0x00,
/* 000033A0 */ 0x00, 0x4C, 0x10, 0x00, 0x00, 0x93, 0x10, 0x00, 0x00, 0xE3, 0x10, 0x00, 0x00, 0x03, 0x11, 0x00,
/* 000033B0 */ 0x00, 0x52, 0x11, 0x00, 0x00, 0x86, 0x11, 0x00, 0x00, 0xB7, 0x11, 0x00, 0x00, 0xF8, 0x11, 0x00,
/* 000033C0 */ 0x00, 0x25, 0x12, 0x00, 0x00, 0x34, 0x12, 0x00, 0x00, 0x3F, 0x12, 0x00, 0x00, 0x5B, 0x12, 0x00,
/* 000033D0 */ 0x00, 0x63, 0x12, 0x00, 0x00, 0x65, 0x12, 0x00, 0x00, 0x9D, 0x12, 0x00, 0x00, 0xDE, 0x12, 0x00,
/* 000033E0 */ 0x00, 0xFE, 0x12, 0x00, 0x00, 0x1F, 0x13, 0x00, 0x00, 0x48, 0x13, 0x00, 0x00, 0x57, 0x13, 0x00,
/* 000033F0 */ 0x00, 0xA2, 0x13, 0x00, 0x00, 0xBF, 0x13, 0x00, 0x00, 0xD1, 0x13, 0x00, 0x00, 0xED, 0x13, 0x00,
/* 00003400 */ 0x00, 0xF8, 0x13, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x02, 0x14, 0x00, 0x00, 0x3D, 0x14, 0x00,
/* 00003410 */ 0x00, 0x57, 0x14, 0x00, 0x00, 0x7B, 0x14, 0x00, 0x00, 0x9E, 0x14, 0x00, 0x00, 0xC3, 0x14, 0x00,
/* 00003420 */ 0x00, 0xD2, 0x14, 0x00, 0x00, 0xEA, 0x14, 0x00, 0x00, 0xF5, 0x14, 0x00, 0x00, 0xFD, 0x14, 0x00,
/* 00003430 */ 0x00, 0xFF, 0x14, 0x00, 0x00, 0x65, 0x15, 0x00, 0x00, 0x92, 0x15, 0x00, 0x00, 0xD9, 0x15, 0x00,
/* 00003440 */ 0x00, 0xF0, 0x15, 0x00, 0x00, 0xFB, 0x15, 0x00, 0x00, 0x03, 0x16, 0x00, 0x00, 0x05, 0x16, 0x00,
/* 00003450 */ 0x00, 0x37, 0x16, 0x00, 0x00, 0x6F, 0x16, 0x00, 0x00, 0x77, 0x16, 0x00, 0x00, 0x79, 0x16, 0x00,
/* 00003460 */ 0x00, 0xBC, 0x16, 0x00, 0x00, 0x03, 0x17, 0x00, 0x00, 0x30, 0x17, 0x00, 0x00, 0x75, 0x17, 0x00,
/* 00003470 */ 0x00, 0xA1, 0x17, 0x00, 0x00, 0xCB, 0x17, 0x00, 0x00, 0xF8, 0x17, 0x00, 0x00, 0x0B, 0x18, 0x00,
/* 00003480 */ 0x00, 0x5E, 0x18, 0x00, 0x00, 0xD4, 0x18, 0x00, 0x00, 0xE3, 0x18, 0x00, 0x00, 0x2F, 0x19, 0x00,
/* 00003490 */ 0x00, 0x72, 0x19, 0x00, 0x00, 0xE3, 0x19, 0x00, 0x00, 0x17, 0x1A, 0x00, 0x00, 0x40, 0x1A, 0x00,
/* 000034A0 */ 0x00, 0x4B, 0x1A, 0x00, 0x00, 0x4D, 0x1A, 0x00, 0x00, 0x76, 0x1A, 0x00, 0x00, 0x9A, 0x1A, 0x00,
/* 000034B0 */ 0x00, 0xD2, 0x1A, 0x00, 0x00, 0xF1, 0x1A, 0x00, 0x00, 0x03, 0x1B, 0x00, 0x00, 0x27, 0x1B, 0x00,
/* 000034C0 */ 0x00, 0x32, 0x1B, 0x00, 0x00, 0x39, 0x1B, 0x00, 0x00, 0x3B, 0x1B, 0x00, 0x00, 0x7C, 0x1B, 0x00,
/* 000034D0 */ 0x00, 0xD0, 0x1B, 0x00, 0x00, 0xFD, 0x1B, 0x00, 0x00, 0x4F, 0x1C, 0x00, 0x00, 0x7B, 0x1C, 0x00,
/* 000034E0 */ 0x00, 0xA5, 0x1C, 0x00, 0x00, 0xD2, 0x1C, 0x00, 0x00, 0xE5, 0x1C, 0x00, 0x00, 0x46, 0x1D, 0x00,
/* 000034F0 */ 0x00, 0x98, 0x1D, 0x00, 0x00, 0xC3, 0x1D, 0x00, 0x00, 0xFD, 0x1D, 0x00, 0x00, 0x38, 0x1E, 0x00,
/* 00003500 */ 0x00, 0x47, 0x1E, 0x00, 0x00, 0x93, 0x1E, 0x00, 0x00, 0xD6, 0x1E, 0x00, 0x00, 0x54, 0x1F, 0x00,
/* 00003510 */ 0x00, 0x88, 0x1F, 0x00, 0x00, 0xB1, 0x1F, 0x00, 0x00, 0xBC, 0x1F, 0x00, 0x00, 0xDC, 0x1F, 0x00,
/* 00003520 */ 0x00, 0xE3, 0x1F, 0x00, 0x00, 0xE5, 0x1F, 0x00, 0x00, 0x18, 0x20, 0x00, 0x00, 0x39, 0x20, 0x00,
/* 00003530 */ 0x00, 0x5E, 0x20, 0x00, 0x00, 0x69, 0x20, 0x00, 0x00, 0x6B, 0x20, 0x00, 0x00, 0xB7, 0x20, 0x00,
/* 00003540 */ 0x00, 0xCE, 0x20, 0x00, 0x00, 0xED, 0x20, 0x00, 0x00, 0xF8, 0x20, 0x00, 0x00, 0xFA, 0x20, 0x00,
/* 00003550 */ 0x00, 0x70, 0x21, 0x00, 0x00, 0xC1, 0x21, 0x00, 0x00, 0x07, 0x22, 0x00, 0x00, 0x09, 0x22, 0x00,
/* 00003560 */ 0x00, 0x7D, 0x22, 0x00, 0x00, 0x97, 0x22, 0x00, 0x00, 0xBC, 0x22, 0x00, 0x00, 0xE1, 0x22, 0x00,
/* 00003570 */ 0x00, 0x3A, 0x23, 0x00, 0x00, 0x7E, 0x23, 0x00, 0x00, 0x08, 0x24, 0x00, 0x00, 0x0A, 0x24, 0x00,
/* 00003580 */ 0x00, 0x26, 0x24, 0x00, 0x00, 0x2D, 0x24, 0x00, 0x00, 0x2F, 0x24, 0x00, 0x00, 0x8A, 0x24, 0x00,
/* 00003590 */ 0x00, 0xC1, 0x24, 0x00, 0x00, 0xE2, 0x24, 0x00, 0x00, 0x40, 0x25, 0x00, 0x00, 0x74, 0x25, 0x00,
/* 000035A0 */ 0x00, 0x7F, 0x25, 0x00, 0x00, 0x81, 0x25, 0x00, 0x00, 0x99, 0x25, 0x00, 0x00, 0xEA, 0x25, 0x00,
/* 000035B0 */ 0x00, 0x47, 0x26, 0x00, 0x00, 0x58, 0x26, 0x00, 0x00, 0x63, 0x26, 0x00, 0x00, 0x65, 0x26, 0x00,
/* 000035C0 */ 0x00, 0xF5, 0x26, 0x00, 0x00, 0x7C, 0x27, 0x00, 0x00, 0xF8, 0x27, 0x00, 0x00, 0x42, 0x28, 0x00,
/* 000035D0 */ 0x00, 0x79, 0x28, 0x00, 0x00, 0x7B, 0x28, 0x00, 0x00, 0xC8, 0x28, 0x00, 0x00, 0xE8, 0x28, 0x00,
/* 000035E0 */ 0x00, 0x3A, 0x29, 0x00, 0x00, 0xB5, 0x29, 0x00, 0x00, 0xDA, 0x29, 0x00, 0x00, 0x36, 0x2A, 0x00,
/* 000035F0 */ 0x00, 0x82, 0x2A, 0x00, 0x00, 0x95, 0x2A, 0x00, 0x00, 0xA7, 0x2A, 0x00, 0x00, 0xC8, 0x2A, 0x00,
/* 00003600 */ 0x00, 0xD3, 0x2A, 0x00, 0x00, 0xD5, 0x2A, 0x00, 0x00, 0x45, 0x2B, 0x00, 0x00, 0x74, 0x2B, 0x00,
/* 00003610 */ 0x00, 0xAA, 0x2B, 0x00, 0x00, 0xD4, 0x2B, 0x00, 0x00, 0xED, 0x2B, 0x00, 0x00, 0x28, 0x2C, 0x00,
/* 00003620 */ 0x00, 0x53, 0x2C, 0x00, 0x00, 0x79, 0x2C, 0x00, 0x00, 0x93, 0x2C, 0x00, 0x00, 0xBB, 0x2C, 0x00,
/* 00003630 */ 0x00, 0xCE, 0x2C, 0x00, 0x00, 0xDD, 0x2C, 0x00, 0x00, 0xDF, 0x2C, 0x00, 0x00, 0x2B, 0x2D, 0x00,
/* 00003640 */ 0x00, 0x3D, 0x2D, 0x00, 0x00, 0x60, 0x2D, 0x00, 0x00, 0x6B, 0x2D, 0x00, 0x00, 0x6D, 0x2D, 0x00,
/* 00003650 */ 0x00, 0x8C, 0x2D, 0x00, 0x00, 0xAB, 0x2D, 0x00, 0x00, 0xCA, 0x2D, 0x00, 0x00, 0xFC, 0x2D, 0x00,
/* 00003660 */ 0x00, 0x0F, 0x2E, 0x00, 0x00, 0x16, 0x2E, 0x00, 0x00, 0x18, 0x2E, 0x00, 0x00, 0x79, 0x2E, 0x00,
/* 00003670 */ 0x00, 0xD2, 0x2E, 0x00, 0x00, 0x06, 0x2F, 0x00, 0x00, 0x08, 0x2F, 0x00, 0x00, 0x3A, 0x2F, 0x00,
/* 00003680 */ 0x00, 0x3C, 0x2F, 0x00, 0x00, 0x71, 0x2F, 0x00, 0x00, 0x9D, 0x2F, 0x00, 0x00, 0x07, 0x30, 0x00,
/* 00003690 */ 0x00, 0x39, 0x30, 0x00, 0x00, 0x5B, 0x30, 0x00, 0x00, 0x6A, 0x30, 0x00, 0x00, 0x75, 0x30, 0x00,
/* 000036A0 */ 0x00, 0xCB, 0x30, 0x00, 0x00, 0xD2, 0x30, 0x00, 0x00, 0xD4, 0x30, 0x00, 0x00, 0x18, 0x31, 0x00,
/* 000036B0 */ 0x00, 0x46, 0x31, 0x00, 0x00, 0x75, 0x31, 0x00, 0x00, 0x9D, 0x31, 0x00, 0x00, 0xCA, 0x31, 0x00,
/* 000036C0 */ 0x00, 0xD5, 0x31, 0x00, 0x00, 0xD7, 0x31, 0x00, 0x00, 0xFA, 0x31, 0x00, 0x00, 0x20, 0x32, 0x00,
/* 000036D0 */ 0x00, 0x49, 0x32, 0x00, 0x00, 0x58, 0x32, 0x00, 0x00, 0x5A, 0x32, 0x00, 0x00, 0x87, 0x32, 0x00,
/* 000036E0 */ 0x00, 0xD5, 0x32, 0x00, 0x00, 0xEF, 0x32, 0x00, 0x00, 0x2E, 0x33, 0x00, 0x00, 0x63, 0x33, 0x00,
/* 000036F0 */ 0x00, 0x79, 0x33, 0x00, 0x00, 0xA9, 0x33, 0x00, 0x00, 0xB8, 0x33, 0x00, 0x00, 0xCA, 0x33, 0x00,
/* 00003700 */ 0x00, 0x1C, 0x34, 0x00, 0x00, 0x4D, 0x34, 0x00, 0x00, 0xB4, 0x34, 0x00, 0x00, 0xBF, 0x34, 0x00,
/* 00003710 */ 0x00, 0xC1, 0x34, 0x00, 0x00, 0xEA, 0x34, 0x00, 0x00, 0xF2, 0x34, 0x00, 0x00, 0xF4, 0x34, 0x00,
/* 00003720 */ 0x00, 0x17, 0x35, 0x00, 0x00, 0x36, 0x35, 0x00, 0x00, 0x5C, 0x35, 0x00, 0x00, 0x7F, 0x35, 0x00,
/* 00003730 */ 0x00, 0xB0, 0x35, 0x00, 0x00, 0xC3, 0x35, 0x00, 0x00, 0x04, 0x36, 0x00, 0x00, 0x14, 0x36, 0x00,
/* 00003740 */ 0x00, 0x16, 0x36, 0x00, 0x00, 0x3C, 0x36, 0x00, 0x00, 0x7D, 0x36, 0x00, 0x00, 0x8D, 0x36, 0x00,
/* 00003750 */ 0x00, 0x8F, 0x36, 0x00, 0x00, 0xB5, 0x36, 0x00, 0x00, 0xF0, 0x36, 0x00, 0x00, 0x00, 0x37, 0x00,
/* 00003760 */ 0x00, 0x02, 0x37, 0x00, 0x00, 0x30, 0x37, 0x00, 0x00, 0x72, 0x37, 0x00, 0x00, 0x82, 0x37, 0x00,
/* 00003770 */ 0x00, 0x84, 0x37, 0x00, 0x00, 0xAA, 0x37, 0x00, 0x00, 0xD0, 0x37, 0x00, 0x00, 0xEE, 0x37, 0x00,
/* 00003780 */ 0x00, 0x23, 0x38, 0x00, 0x00, 0x5F, 0x38, 0x00, 0x00, 0x72, 0x38, 0x00, 0x00, 0x8F, 0x38, 0x00,
/* 00003790 */ 0x00, 0x9F, 0x38, 0x00, 0x00, 0xA1, 0x38, 0x00, 0x00, 0xCD, 0x38, 0x00, 0x00, 0xFA, 0x38, 0x00,
/* 000037A0 */ 0x00, 0x17, 0x39, 0x00, 0x00, 0x68, 0x39, 0x00, 0x00, 0x8E, 0x39, 0x00, 0x00, 0xA5, 0x39, 0x00,
/* 000037B0 */ 0x00, 0xD7, 0x39, 0x00, 0x00, 0xEA, 0x39, 0x00, 0x00, 0xF9, 0x39, 0x00, 0x00, 0x0B, 0x3A, 0x00,
/* 000037C0 */ 0x00, 0x16, 0x3A, 0x00, 0x00, 0x18, 0x3A, 0x00, 0x00, 0x40, 0x3A, 0x00, 0x00, 0x85, 0x3A, 0x00,
/* 000037D0 */ 0x00, 0xAD, 0x3A, 0x00, 0x00, 0xAF, 0x3A, 0x00, 0x00, 0xD3, 0x3A, 0x00, 0x00, 0xF9, 0x3A, 0x00,
/* 000037E0 */ 0x00, 0x34, 0x3B, 0x00, 0x00, 0x43, 0x3B, 0x00, 0x00, 0x45, 0x3B, 0x00, 0x00, 0x6A, 0x3B, 0x00,
/* 000037F0 */ 0x00, 0x9D, 0x3B, 0x00, 0x00, 0xAC, 0x3B, 0x00, 0x00, 0xAE, 0x3B, 0x00, 0x00, 0xD3, 0x3B, 0x00,
/* 00003800 */ 0x00, 0x06, 0x3C, 0x00, 0x00, 0x15, 0x3C, 0x00, 0x00, 0x17, 0x3C, 0x00, 0x00, 0x7F, 0x3C, 0x00,
/* 00003810 */ 0x00, 0x1B, 0x3D, 0x00, 0x00, 0x2A, 0x3D, 0x00, 0x00, 0x2C, 0x3D, 0x00, 0x00, 0x47, 0x3D, 0x00,
/* 00003820 */ 0x00, 0x52, 0x3D, 0x00, 0x00, 0x54, 0x3D, 0x00, 0x00, 0x6E, 0x3D, 0x00, 0x00, 0x75, 0x3D, 0x00,
/* 00003830 */ 0x00, 0x77, 0x3D, 0x00, 0x00, 0xC6, 0x3D, 0x00, 0x00, 0xF3, 0x3D, 0x00, 0x00, 0xF5, 0x3D, 0x00,
/* 00003840 */ 0x00, 0x25, 0x3E, 0x00, 0x00, 0x66, 0x3E, 0x00, 0x00, 0x68, 0x3E, 0x00, 0x00, 0xCA, 0x3E, 0x00,
/* 00003850 */ 0x00, 0x4D, 0x3F, 0x00, 0x00, 0x5C, 0x3F, 0x00, 0x00, 0x5E, 0x3F, 0x00, 0x00, 0x8E, 0x3F, 0x00,
/* 00003860 */ 0x00, 0xA0, 0x3F, 0x00, 0x00, 0xBE, 0x3F, 0x00, 0x00, 0xC9, 0x3F, 0x00, 0x00, 0xD0, 0x3F, 0x00,
/* 00003870 */ 0x00, 0xD2, 0x3F, 0x00, 0x00, 0xED, 0x3F, 0x00, 0x00, 0x18, 0x40, 0x00, 0x00, 0x43, 0x40, 0x00,
/* 00003880 */ 0x00, 0x4A, 0x40, 0x00, 0x00, 0x4C, 0x40, 0x00, 0x00, 0x85, 0x40, 0x00, 0x00, 0xD2, 0x40, 0x00,
/* 00003890 */ 0x00, 0x31, 0x41, 0x00, 0x00, 0x58, 0x41, 0x00, 0x00, 0x9E, 0x41, 0x00, 0x00, 0x03, 0x42, 0x00,
/* 000038A0 */ 0x00, 0x84, 0x42, 0x00, 0x00, 0x86, 0x42, 0x00, 0x00, 0xF9, 0x42, 0x00, 0x00, 0x2B, 0x43, 0x00,
/* 000038B0 */ 0x00, 0x7B, 0x43, 0x00, 0x00, 0xCE, 0x43, 0x00, 0x00, 0x23, 0x44, 0x00, 0x00, 0x5C, 0x44, 0x00,
/* 000038C0 */ 0x00, 0xAF, 0x44, 0x00, 0x00, 0x02, 0x45, 0x00, 0x00, 0x58, 0x45, 0x00, 0x00, 0xC5, 0x45, 0x00,
/* 000038D0 */ 0x00, 0x1C, 0x46, 0x00, 0x00, 0x1E, 0x46, 0x00, 0x00, 0x3E, 0x46, 0x00, 0x00, 0x5E, 0x46, 0x00,
/* 000038E0 */ 0x00, 0x91, 0x46, 0x00, 0x00, 0x93, 0x46, 0x00, 0x00, 0x0B, 0x47, 0x00, 0x00, 0x79, 0x47, 0x00,
/* 000038F0 */ 0x00, 0xCD, 0x47, 0x00, 0x00, 0x11, 0x48, 0x00, 0x00, 0x13, 0x48, 0x00, 0x00, 0x91, 0x48, 0x00,
/* 00003900 */ 0x00, 0x26, 0x49, 0x00, 0x00, 0xAA, 0x49, 0x00, 0x00, 0x2E, 0x4A, 0x00, 0x00, 0xA2, 0x4A, 0x00,
/* 00003910 */ 0x00, 0xA4, 0x4A, 0x00, 0x00, 0x0F, 0x4B, 0x00, 0x00, 0x89, 0x4B, 0x00, 0x00, 0x8B, 0x4B, 0x00,
/* 00003920 */ 0x00, 0xEF, 0x4B, 0x00, 0x00, 0x7F, 0x4C, 0x00, 0x00, 0x29, 0x4D, 0x00, 0x00, 0xBE, 0x4D, 0x00,
/* 00003930 */ 0x00, 0x56, 0x4E, 0x00, 0x00, 0xFB, 0x4E, 0x00, 0x00, 0x10, 0x4F, 0x00, 0x00, 0x12, 0x4F, 0x00,
/* 00003940 */ 0x00, 0x94, 0x4F, 0x00, 0x00, 0x01, 0x50, 0x00, 0x00, 0x72, 0x50, 0x00, 0x00, 0xE3, 0x50, 0x00,
/* 00003950 */ 0x00, 0x56, 0x51, 0x00, 0x00, 0xCB, 0x51, 0x00, 0x00, 0x40, 0x52, 0x00, 0x00, 0x8B, 0x52, 0x00,
/* 00003960 */ 0x00, 0x8D, 0x52, 0x00, 0x00, 0xFB, 0x52, 0x00, 0x00, 0xFD, 0x52, 0x00, 0x00, 0x64, 0x53, 0x00,
/* 00003970 */ 0x00, 0xF0, 0x53, 0x00, 0x00, 0x67, 0x54, 0x00, 0x00, 0x6E, 0x54, 0x00, 0x00, 0x70, 0x54, 0x00,
/* 00003980 */ 0x00, 0x9F, 0x54, 0x00, 0x00, 0xC8, 0x54, 0x00, 0x00, 0xCA, 0x54, 0x00, 0x00, 0xEC, 0x54, 0x00,
/* 00003990 */ 0x00, 0x15, 0x55, 0x00, 0x00, 0x20, 0x55, 0x00, 0x00, 0x22, 0x55, 0x00, 0x00, 0x6F, 0x55, 0x00,
/* 000039A0 */ 0x00, 0x76, 0x55, 0x00, 0x00, 0x78, 0x55, 0x00, 0x00, 0xF0, 0x55, 0x00, 0x00, 0x20, 0x56, 0x00,
/* 000039B0 */ 0x00, 0x4F, 0x56, 0x00, 0x00, 0x67, 0x56, 0x00, 0x00, 0x72, 0x56, 0x00, 0x00, 0x74, 0x56, 0x00,
/* 000039C0 */ 0x00, 0xA0, 0x56, 0x00, 0x00, 0xC2, 0x56, 0x00, 0x00, 0xCD, 0x56, 0x00, 0x00, 0xCF, 0x56, 0x00,
/* 000039D0 */ 0x00, 0xFE, 0x56, 0x00, 0x00, 0x39, 0x57, 0x00, 0x00, 0x3B, 0x57, 0x00, 0x00, 0x71, 0x57, 0x00,
/* 000039E0 */ 0x00, 0x89, 0x57, 0x00, 0x00, 0x8B, 0x57, 0x00, 0x00, 0xCA, 0x57, 0x00, 0x00, 0x2C, 0x58, 0x00,
/* 000039F0 */ 0x00, 0x69, 0x58, 0x00, 0x00, 0x78, 0x58, 0x00, 0x00, 0x7A, 0x58, 0x00, 0x00, 0xAC, 0x58, 0x00,
/* 00003A00 */ 0x00, 0xAE, 0x58, 0x00, 0x00, 0xE0, 0x58, 0x00, 0x00, 0x21, 0x59, 0x00, 0x00, 0x30, 0x59, 0x00,
/* 00003A10 */ 0x00, 0x32, 0x59, 0x00, 0x00, 0x69, 0x59, 0x00, 0x00, 0x6B, 0x59, 0x00, 0x00, 0xCD, 0x59, 0x00,
/* 00003A20 */ 0x00, 0x0E, 0x5A, 0x00, 0x00, 0x1D, 0x5A, 0x00, 0x00, 0x2A, 0x5A, 0x00, 0x00, 0x2C, 0x5A, 0x00,
/* 00003A30 */ 0x00, 0x42, 0x5A, 0x00, 0x00, 0x49, 0x5A, 0x00, 0x00, 0x4B, 0x5A, 0x00, 0x00, 0x9B, 0x5A, 0x00,
/* 00003A40 */ 0x00, 0xB5, 0x5A, 0x00, 0x00, 0xCD, 0x5A, 0x00, 0x00, 0x23, 0x5B, 0x00, 0x00, 0x36, 0x5B, 0x00,
/* 00003A50 */ 0x00, 0x95, 0x5B, 0x00, 0x00, 0xBD, 0x5B, 0x00, 0x00, 0x4B, 0x5C, 0x00, 0x00, 0x73, 0x5C, 0x00,
/* 00003A60 */ 0x00, 0x86, 0x5C, 0x00, 0x00, 0xA2, 0x5C, 0x00, 0x00, 0xCA, 0x5C, 0x00, 0x00, 0x2D, 0x5D, 0x00,
/* 00003A70 */ 0x00, 0x3C, 0x5D, 0x00, 0x00, 0x49, 0x5D, 0x00, 0x00, 0xB2, 0x5D, 0x00, 0x00, 0xCA, 0x5D, 0x00,
/* 00003A80 */ 0x00, 0xD1, 0x5D, 0x00, 0x00, 0xD3, 0x5D, 0x00, 0x00, 0x2A, 0x5E, 0x00, 0x00, 0x5E, 0x5E, 0x00,
/* 00003A90 */ 0x00, 0x98, 0x5E, 0x00, 0x00, 0xA3, 0x5E, 0x00, 0x00, 0xA5, 0x5E, 0x00, 0x00, 0xDE, 0x5E, 0x00,
/* 00003AA0 */ 0x00, 0x1A, 0x5F, 0x00, 0x00, 0x54, 0x5F, 0x00, 0x00, 0x5F, 0x5F, 0x00, 0x00, 0x61, 0x5F, 0x00,
/* 00003AB0 */ 0x00, 0x97, 0x5F, 0x00, 0x00, 0x9E, 0x5F, 0x00, 0x00, 0xA0, 0x5F, 0x00, 0x00, 0xF2, 0x5F, 0x00,
/* 00003AC0 */ 0x00, 0x26, 0x60, 0x00, 0x00, 0x60, 0x60, 0x00, 0x00, 0x6B, 0x60, 0x00, 0x00, 0x6D, 0x60, 0x00,
/* 00003AD0 */ 0x00, 0xA6, 0x60, 0x00, 0x00, 0xE2, 0x60, 0x00, 0x00, 0x1C, 0x61, 0x00, 0x00, 0x27, 0x61, 0x00,
/* 00003AE0 */ 0x00, 0x29, 0x61, 0x00, 0x00, 0x5A, 0x61, 0x00, 0x00, 0x61, 0x61, 0x00, 0x00, 0x63, 0x61, 0x00,
/* 00003AF0 */ 0x00, 0x8D, 0x61, 0x00, 0x00, 0xC9, 0x61, 0x00, 0x00, 0xDF, 0x61, 0x00, 0x00, 0x13, 0x62, 0x00,
/* 00003B00 */ 0x00, 0x15, 0x62, 0x00, 0x00, 0x44, 0x62, 0x00, 0x00, 0x72, 0x62, 0x00, 0x00, 0x74, 0x62, 0x00,
/* 00003B10 */ 0x00, 0xA7, 0x62, 0x00, 0x00, 0xDE, 0x62, 0x00, 0x00, 0xE0, 0x62, 0x00, 0x00, 0x27, 0x63, 0x00,
/* 00003B20 */ 0x00, 0x9F, 0x63, 0x00, 0x00, 0xB2, 0x63, 0x00, 0x00, 0xC1, 0x63, 0x00, 0x00, 0xCC, 0x63, 0x00,
/* 00003B30 */ 0x00, 0xCE, 0x63, 0x00, 0x00, 0x17, 0x64, 0x00, 0x00, 0x9A, 0x64, 0x00, 0x00, 0xAC, 0x64, 0x00,
/* 00003B40 */ 0x00, 0x0F, 0x65, 0x00, 0x00, 0x1A, 0x65, 0x00, 0x00, 0x22, 0x65, 0x00, 0x00, 0x24, 0x65, 0x00,
/* 00003B50 */ 0x00, 0x61, 0x65, 0x00, 0x00, 0xC3, 0x65, 0x00, 0x00, 0xC5, 0x65, 0x00, 0x00, 0x39, 0x66, 0x00,
/* 00003B60 */ 0x00, 0x8A, 0x66, 0x00, 0x00, 0xDC, 0x66, 0x00, 0x00, 0x60, 0x67, 0x00, 0x00, 0xA3, 0x67, 0x00,
/* 00003B70 */ 0x00, 0xF1, 0x67, 0x00, 0x00, 0x5A, 0x68, 0x00, 0x00, 0x81, 0x68, 0x00, 0x00, 0x83, 0x68, 0x00,
/* 00003B80 */ 0x00, 0xDD, 0x68, 0x00, 0x00, 0x69, 0x69, 0x00, 0x00, 0xB0, 0x69, 0x00, 0x00, 0xFE, 0x69, 0x00,
/* 00003B90 */ 0x00, 0x6B, 0x6A, 0x00, 0x00, 0x92, 0x6A, 0x00, 0x00, 0x94, 0x6A, 0x00, 0x00, 0xF2, 0x6A, 0x00,
/* 00003BA0 */ 0x00, 0x82, 0x6B, 0x00, 0x00, 0xCB, 0x6B, 0x00, 0x00, 0x19, 0x6C, 0x00, 0x00, 0x88, 0x6C, 0x00,
/* 00003BB0 */ 0x00, 0xAF, 0x6C, 0x00, 0x00, 0xB1, 0x6C, 0x00, 0x00, 0xF3, 0x6C, 0x00, 0x00, 0x67, 0x6D, 0x00,
/* 00003BC0 */ 0x00, 0xA2, 0x6D, 0x00, 0x00, 0xFE, 0x6D, 0x00, 0x00, 0x25, 0x6E, 0x00, 0x00, 0x27, 0x6E, 0x00,
/* 00003BD0 */ 0x00, 0x81, 0x6E, 0x00, 0x00, 0xDC, 0x6E, 0x00, 0x00, 0x2C, 0x6F, 0x00, 0x00, 0xA9, 0x6F, 0x00,
/* 00003BE0 */ 0x00, 0x0A, 0x70, 0x00, 0x00, 0x6F, 0x70, 0x00, 0x00, 0xD6, 0x70, 0x00, 0x00, 0x30, 0x71, 0x00,
/* 00003BF0 */ 0x00, 0x32, 0x71, 0x00, 0x00, 0x9A, 0x71, 0x00, 0x00, 0xE0, 0x71, 0x00, 0x00, 0x24, 0x72, 0x00,
/* 00003C00 */ 0x00, 0x5E, 0x72, 0x00, 0x00, 0x9A, 0x72, 0x00, 0x00, 0xD6, 0x72, 0x00, 0x00, 0x15, 0x73, 0x00,
/* 00003C10 */ 0x00, 0x53, 0x73, 0x00, 0x00, 0x89, 0x73, 0x00, 0x00, 0xEB, 0x73, 0x00, 0x00, 0x37, 0x74, 0x00,
/* 00003C20 */ 0x00, 0x83, 0x74, 0x00, 0x00, 0xCF, 0x74, 0x00, 0x00, 0x1A, 0x75, 0x00, 0x00, 0x1C, 0x75, 0x00,
/* 00003C30 */ 0x00, 0x9C, 0x75, 0x00, 0x00, 0x38, 0x76, 0x00, 0x00, 0x59, 0x76, 0x00, 0x00, 0x7A, 0x76, 0x00,
/* 00003C40 */ 0x00, 0x99, 0x76, 0x00, 0x00, 0xA8, 0x76, 0x00, 0x00, 0xAA, 0x76, 0x00, 0x00, 0x0E, 0x77, 0x00,
/* 00003C50 */ 0x00, 0x8A, 0x77, 0x00, 0x00, 0xCB, 0x77, 0x00, 0x00, 0xFD, 0x77, 0x00, 0x00, 0x7D, 0x78, 0x00,
/* 00003C60 */ 0x00, 0xD4, 0x78, 0x00, 0x00, 0x19, 0x79, 0x00, 0x00, 0x1B, 0x79, 0x00, 0x00, 0x9B, 0x79, 0x00,
/* 00003C70 */ 0x00, 0xE4, 0x79, 0x00, 0x00, 0x0E, 0x7A, 0x00, 0x00, 0x54, 0x7A, 0x00, 0x00, 0x67, 0x7A, 0x00,
/* 00003C80 */ 0x00, 0x78, 0x7A, 0x00, 0x00, 0x7A, 0x7A, 0x00, 0x00, 0xB3, 0x7A, 0x00, 0x00, 0xC0, 0x7A, 0x00,
/* 00003C90 */ 0x00, 0xDA, 0x7A, 0x00, 0x00, 0xE5, 0x7A, 0x00, 0x00, 0xE7, 0x7A, 0x00, 0x00, 0x39, 0x7B, 0x00,
/* 00003CA0 */ 0x00, 0x68, 0x7B, 0x00, 0x00, 0x94, 0x7B, 0x00, 0x00, 0xC1, 0x7B, 0x00, 0x00, 0xFD, 0x7B, 0x00,
/* 00003CB0 */ 0x00, 0x28, 0x7C, 0x00, 0x00, 0x33, 0x7C, 0x00, 0x00, 0x35, 0x7C, 0x00, 0x00, 0x56, 0x7C, 0x00,
/* 00003CC0 */ 0x00, 0x7A, 0x7C, 0x00, 0x00, 0x9D, 0x7C, 0x00, 0x00, 0xF2, 0x7C, 0x00, 0x00, 0x1C, 0x7D, 0x00,
/* 00003CD0 */ 0x00, 0x87, 0x7D, 0x00, 0x00, 0xA1, 0x7D, 0x00, 0x00, 0xF4, 0x7D, 0x00, 0x00, 0x3E, 0x7E, 0x00,
/* 00003CE0 */ 0x00, 0x65, 0x7E, 0x00, 0x00, 0xC8, 0x7E, 0x00, 0x00, 0xD7, 0x7E, 0x00, 0x00, 0xE9, 0x7E, 0x00,
/* 00003CF0 */ 0x00, 0x33, 0x7F, 0x00, 0x00, 0x90, 0x7F, 0x00, 0x00, 0xB0, 0x7F, 0x00, 0x00, 0xD3, 0x7F, 0x00,
/* 00003D00 */ 0x00, 0xDE, 0x7F, 0x00, 0x00, 0xE0, 0x7F, 0x00, 0x00, 0x08, 0x80, 0x00, 0x00, 0x35, 0x80, 0x00,
/* 00003D10 */ 0x00, 0x60, 0x80, 0x00, 0x00, 0x6B, 0x80, 0x00, 0x00, 0x6D, 0x80, 0x00, 0x00, 0xCA, 0x80, 0x00,
/* 00003D20 */ 0x00, 0x20, 0x81, 0x00, 0x00, 0x47, 0x81, 0x00, 0x00, 0x86, 0x81, 0x00, 0x00, 0x9C, 0x81, 0x00,
/* 00003D30 */ 0x00, 0xDD, 0x81, 0x00, 0x00, 0xEC, 0x81, 0x00, 0x00, 0xF8, 0x81, 0x00, 0x00, 0xFA, 0x81, 0x00,
/* 00003D40 */ 0x00, 0x51, 0x82, 0x00, 0x00, 0x85, 0x82, 0x00, 0x00, 0xD3, 0x82, 0x00, 0x00, 0x28, 0x83, 0x00,
/* 00003D50 */ 0x00, 0x53, 0x83, 0x00, 0x00, 0x5E, 0x83, 0x00, 0x00, 0x60, 0x83, 0x00, 0x00, 0xA3, 0x83, 0x00,
/* 00003D60 */ 0x00, 0xD1, 0x83, 0x00, 0x00, 0x2C, 0x84, 0x00, 0x00, 0x3E, 0x84, 0x00, 0x00, 0x93, 0x84, 0x00,
/* 00003D70 */ 0x00, 0x9E, 0x84, 0x00, 0x00, 0xA0, 0x84, 0x00, 0x00, 0xC7, 0x84, 0x00, 0x00, 0xCF, 0x84, 0x00,
/* 00003D80 */ 0x00, 0xD1, 0x84, 0x00, 0x00, 0x07, 0x85, 0x00, 0x00, 0x2A, 0x85, 0x00, 0x00, 0x2C, 0x85, 0x00,
/* 00003D90 */ 0x00, 0x69, 0x85, 0x00, 0x00, 0x6B, 0x85, 0x00, 0x00, 0xB5, 0x85, 0x00, 0x00, 0xE9, 0x85, 0x00,
/* 00003DA0 */ 0x00, 0x1A, 0x86, 0x00, 0x00, 0x2D, 0x86, 0x00, 0x00, 0x2F, 0x86, 0x00, 0x00, 0xBF, 0x86, 0x00,
/* 00003DB0 */ 0x00, 0x16, 0x87, 0x00, 0x00, 0x29, 0x87, 0x00, 0x00, 0x2B, 0x87, 0x00, 0x00, 0x65, 0x87, 0x00,
/* 00003DC0 */ 0x00, 0x67, 0x87, 0x00, 0x00, 0x8B, 0x87, 0x00, 0x00, 0xC2, 0x87, 0x00, 0x00, 0xF9, 0x87, 0x00,
/* 00003DD0 */ 0x00, 0x13, 0x88, 0x00, 0x00, 0x4E, 0x88, 0x00, 0x00, 0x61, 0x88, 0x00, 0x00, 0x63, 0x88, 0x00,
/* 00003DE0 */ 0x00, 0xD5, 0x88, 0x00, 0x00, 0x35, 0x89, 0x00, 0x00, 0xB7, 0x89, 0x00, 0x00, 0x26, 0x8A, 0x00,
/* 00003DF0 */ 0x00, 0x9A, 0x8A, 0x00, 0x00, 0xFD, 0x8A, 0x00, 0x00, 0xFF, 0x8A, 0x00, 0x00, 0x38, 0x8B, 0x00,
/* 00003E00 */ 0x00, 0x7A, 0x8B, 0x00, 0x00, 0xE9, 0x8B, 0x00, 0x00, 0xEB, 0x8B, 0x00, 0x00, 0x17, 0x8C, 0x00,
/* 00003E10 */ 0x00, 0x81, 0x8C, 0x00, 0x00, 0xC7, 0x8C, 0x00, 0x00, 0xC9, 0x8C, 0x00, 0x00, 0xFC, 0x8C, 0x00,
/* 00003E20 */ 0x00, 0x68, 0x8D, 0x00, 0x00, 0xEB, 0x8D, 0x00, 0x00, 0x18, 0x8E, 0x00, 0x00, 0x65, 0x8E, 0x00,
/* 00003E30 */ 0x00, 0xAD, 0x8E, 0x00, 0x00, 0x4A, 0x8F, 0x00, 0x00, 0x97, 0x8F, 0x00, 0x00, 0xCF, 0x8F, 0x00,
/* 00003E40 */ 0x00, 0x54, 0x90, 0x00, 0x00, 0x7A, 0x90, 0x00, 0x00, 0xAB, 0x90, 0x00, 0x00, 0xCA, 0x90, 0x00,
/* 00003E50 */ 0x00, 0x6E, 0x91, 0x00, 0x00, 0xCE, 0x91, 0x00, 0x00, 0xFE, 0x91, 0x00, 0x00, 0x19, 0x92, 0x00,
/* 00003E60 */ 0x00, 0x32, 0x92, 0x00, 0x00, 0x45, 0x92, 0x00, 0x00, 0x75, 0x92, 0x00, 0x00, 0xE5, 0x92, 0x00,
/* 00003E70 */ 0x00, 0x15, 0x93, 0x00, 0x00, 0xA4, 0x93, 0x00, 0x00, 0xDC, 0x93, 0x00, 0x00, 0x47, 0x94, 0x00,
/* 00003E80 */ 0x00, 0x62, 0x94, 0x00, 0x00, 0x79, 0x94, 0x00, 0x00, 0x95, 0x94, 0x00, 0x00, 0xC5, 0x94, 0x00,
/* 00003E90 */ 0x00, 0xDC, 0x94, 0x00, 0x00, 0xEF, 0x94, 0x00, 0x00, 0xF1, 0x94, 0x00, 0x00, 0x21, 0x95, 0x00,
/* 00003EA0 */ 0x00, 0x51, 0x95, 0x00, 0x00, 0x6C, 0x95, 0x00, 0x00, 0xE8, 0x95, 0x00, 0x00, 0x0B, 0x96, 0x00,
/* 00003EB0 */ 0x00, 0x3A, 0x96, 0x00, 0x00, 0x69, 0x96, 0x00, 0x00, 0x6B, 0x96, 0x00, 0x00, 0xDD, 0x96, 0x00,
/* 00003EC0 */ 0x00, 0x67, 0x97, 0x00, 0x00, 0xD1, 0x97, 0x00, 0x00, 0x11, 0x98, 0x00, 0x00, 0x28, 0x98, 0x00,
/* 00003ED0 */ 0x00, 0x2A, 0x98, 0x00, 0x00, 0x50, 0x98, 0x00, 0x00, 0x7E, 0x98, 0x00, 0x00, 0xAC, 0x98, 0x00,
/* 00003EE0 */ 0x00, 0xDA, 0x98, 0x00, 0x00, 0xF8, 0x98, 0x00, 0x00, 0x26, 0x99, 0x00, 0x00, 0x3D, 0x99, 0x00,
/* 00003EF0 */ 0x00, 0x50, 0x99, 0x00, 0x00, 0x52, 0x99, 0x00, 0x00, 0x84, 0x99, 0x00, 0x00, 0xB2, 0x99, 0x00,
/* 00003F00 */ 0x00, 0xC5, 0x99, 0x00, 0x00, 0xC7, 0x99, 0x00, 0x00, 0xF5, 0x99, 0x00, 0x00, 0x1B, 0x9A, 0x00,
/* 00003F10 */ 0x00, 0x2E, 0x9A, 0x00, 0x00, 0x30, 0x9A, 0x00, 0x00, 0x62, 0x9A, 0x00, 0x00, 0x91, 0x9A, 0x00,
/* 00003F20 */ 0x00, 0xDF, 0x9A, 0x00, 0x00, 0x28, 0x9B, 0x00, 0x00, 0x53, 0x9B, 0x00, 0x00, 0x8A, 0x9B, 0x00,
/* 00003F30 */ 0x00, 0xCD, 0x9B, 0x00, 0x00, 0x00, 0x9C, 0x00, 0x00, 0x2F, 0x9C, 0x00, 0x00, 0x62, 0x9C, 0x00,
/* 00003F40 */ 0x00, 0x9A, 0x9C, 0x00, 0x00, 0xA9, 0x9C, 0x00, 0x00, 0xAB, 0x9C, 0x00, 0x00, 0x1B, 0x9D, 0x00,
/* 00003F50 */ 0x00, 0x45, 0x9D, 0x00, 0x00, 0x81, 0x9D, 0x00, 0x00, 0xDC, 0x9D, 0x00, 0x00, 0xEF, 0x9D, 0x00,
/* 00003F60 */ 0x00, 0x1A, 0x9E, 0x00, 0x00, 0x4B, 0x9E, 0x00, 0x00, 0x5E, 0x9E, 0x00, 0x00, 0x03, 0x9F, 0x00,
/* 00003F70 */ 0x00, 0x30, 0x9F, 0x00, 0x00, 0x5A, 0x9F, 0x00, 0x00, 0x95, 0x9F, 0x00, 0x00, 0xE3, 0x9F, 0x00,
/* 00003F80 */ 0x00, 0x9D, 0xA0, 0x00, 0x00, 0xB2, 0xA0, 0x00, 0x00, 0xB4, 0xA0, 0x00, 0x00, 0xDC, 0xA0, 0x00,
/* 00003F90 */ 0x00, 0xDE, 0xA0, 0x00, 0x00, 0x05, 0xA1, 0x00, 0x00, 0x6C, 0xA1, 0x00, 0x00, 0xE4, 0xA1, 0x00,
/* 00003FA0 */ 0x00, 0x57, 0xA2, 0x00, 0x00, 0x85, 0xA2, 0x00, 0x00, 0xB3, 0xA2, 0x00, 0x00, 0xFB, 0xA2, 0x00,
/* 00003FB0 */ 0x00, 0x43, 0xA3, 0x00, 0x00, 0x45, 0xA3, 0x00, 0x00, 0x85, 0xA3, 0x00, 0x00, 0xC5, 0xA3, 0x00,
/* 00003FC0 */ 0x00, 0xDC, 0xA3, 0x00, 0x00, 0xDE, 0xA3, 0x00, 0x00, 0x16, 0xA4, 0x00, 0x00, 0x4B, 0xA4, 0x00,
/* 00003FD0 */ 0x00, 0x95, 0xA4, 0x00, 0x00, 0xAC, 0xA4, 0x00, 0x00, 0xAE, 0xA4, 0x00, 0x00, 0xEA, 0xA4, 0x00,
/* 00003FE0 */ 0x00, 0x31, 0xA5, 0x00, 0x00, 0x33, 0xA5, 0x00, 0x00, 0x6A, 0xA5, 0x00, 0x00, 0xAA, 0xA5, 0x00,
/* 00003FF0 */ 0x00, 0xF0, 0xA5, 0x00, 0x00, 0x07, 0xA6, 0x00, 0x00, 0x09, 0xA6, 0x00, 0x00, 0x52, 0xA6, 0x00,
/* 00004000 */ 0x00, 0x54, 0xA6, 0x00, 0x00, 0x82, 0xA6, 0x00, 0x00, 0xEB, 0xA6, 0x00, 0x00, 0x29, 0xA7, 0x00,
/* 00004010 */ 0x00, 0x4A, 0xA7, 0x00, 0x00, 0x5D, 0xA7, 0x00, 0x00, 0x9C, 0xA7, 0x00, 0x00, 0x9E, 0xA7, 0x00,
/* 00004020 */ 0x00, 0xC8, 0xA7, 0x00, 0x00, 0xFD, 0xA7, 0x00, 0x00, 0x60, 0xA8, 0x00, 0x00, 0x77, 0xA8, 0x00,
/* 00004030 */ 0x00, 0x79, 0xA8, 0x00, 0x00, 0xC1, 0xA8, 0x00, 0x00, 0x1F, 0xA9, 0x00, 0x00, 0x82, 0xA9, 0x00,
/* 00004040 */ 0x00, 0x99, 0xA9, 0x00, 0x00, 0x9B, 0xA9, 0x00, 0x00, 0xBF, 0xA9, 0x00, 0x00, 0xE3, 0xA9, 0x00,
/* 00004050 */ 0x00, 0xE5, 0xA9, 0x00, 0x00, 0x9E, 0xAA, 0x00, 0x00, 0xB1, 0xAA, 0x00, 0x00, 0x01, 0xAB, 0x00,
/* 00004060 */ 0x00, 0x03, 0xAB, 0x00, 0x00, 0x96, 0xAB, 0x00, 0x00, 0x98, 0xAB, 0x00, 0x00, 0x2A, 0xAC, 0x00,
/* 00004070 */ 0x00, 0x6F, 0xAC, 0x00, 0x00, 0x71, 0xAC, 0x00, 0x00, 0x07, 0xAD, 0x00, 0x00, 0x09, 0xAD, 0x00,
/* 00004080 */ 0x00, 0x58, 0xAD, 0x00, 0x00, 0x91, 0xAD, 0x00, 0x00, 0xCA, 0xAD, 0x00, 0x00, 0x39, 0xAE, 0x00,
/* 00004090 */ 0x00, 0x54, 0xAE, 0x00, 0x00, 0xA0, 0xAE, 0x00, 0x00, 0x02, 0xAF, 0x00, 0x00, 0x71, 0xAF, 0x00,
/* 000040A0 */ 0x00, 0x8C, 0xAF, 0x00, 0x00, 0x8E, 0xAF, 0x00, 0x00, 0xB0, 0xAF, 0x00, 0x00, 0xEC, 0xAF, 0x00,
/* 000040B0 */ 0x00, 0x26, 0xB0, 0x00, 0x00, 0x6C, 0xB0, 0x00, 0x00, 0xBE, 0xB0, 0x00, 0x00, 0x1A, 0xB1, 0x00,
/* 000040C0 */ 0x00, 0xB0, 0xB1, 0x00, 0x00, 0x46, 0xB2, 0x00, 0x00, 0x61, 0xB2, 0x00, 0x00, 0xAF, 0xB2, 0x00,
/* 000040D0 */ 0x00, 0xC4, 0xB2, 0x00, 0x00, 0xC6, 0xB2, 0x00, 0x00, 0x0D, 0xB3, 0x00, 0x00, 0x56, 0xB3, 0x00,
/* 000040E0 */ 0x00, 0x8F, 0xB3, 0x00, 0x00, 0xF6, 0xB3, 0x00, 0x00, 0x11, 0xB4, 0x00, 0x00, 0x13, 0xB4, 0x00,
/* 000040F0 */ 0x00, 0x5F, 0xB4, 0x00, 0x00, 0xC1, 0xB4, 0x00, 0x00, 0x28, 0xB5, 0x00, 0x00, 0x43, 0xB5, 0x00,
/* 00004100 */ 0x00, 0x45, 0xB5, 0x00, 0x00, 0x82, 0xB5, 0x00, 0x00, 0xC1, 0xB5, 0x00, 0x00, 0xD6, 0xB5, 0x00,
/* 00004110 */ 0x00, 0xD8, 0xB5, 0x00, 0x00, 0xFA, 0xB5, 0x00, 0x00, 0x09, 0xB6, 0x00, 0x00, 0x14, 0xB6, 0x00,
/* 00004120 */ 0x00, 0x60, 0xB6, 0x00, 0x00, 0x7B, 0xB6, 0x00, 0x00, 0x86, 0xB6, 0x00, 0x00, 0x88, 0xB6, 0x00,
/* 00004130 */ 0x00, 0xC3, 0xB6, 0x00, 0x00, 0xEA, 0xB6, 0x00, 0x00, 0x3A, 0xB7, 0x00, 0x00, 0x6C, 0xB7, 0x00,
/* 00004140 */ 0x00, 0xA1, 0xB7, 0x00, 0x00, 0x0D, 0xB8, 0x00, 0x00, 0x5A, 0xB8, 0x00, 0x00, 0xAE, 0xB8, 0x00,
/* 00004150 */ 0x00, 0xC2, 0xB8, 0x00, 0x00, 0xD5, 0xB8, 0x00, 0x00, 0x11, 0xB9, 0x00, 0x00, 0x45, 0xB9, 0x00,
/* 00004160 */ 0x00, 0xD5, 0xB9, 0x00, 0x00, 0x47, 0xBA, 0x00, 0x00, 0xBF, 0xBA, 0x00, 0x00, 0xD3, 0xBA, 0x00,
/* 00004170 */ 0x00, 0xE6, 0xBA, 0x00, 0x00, 0xE8, 0xBA, 0x00, 0x00, 0x25, 0xBB, 0x00, 0x00, 0x77, 0xBB, 0x00,
/* 00004180 */ 0x00, 0xAF, 0xBB, 0x00, 0x00, 0xE0, 0xBB, 0x00, 0x00, 0xF3, 0xBB, 0x00, 0x00, 0xF5, 0xBB, 0x00,
/* 00004190 */ 0x00, 0x8D, 0xBC, 0x00, 0x00, 0xEC, 0xBC, 0x00, 0x00, 0xFF, 0xBC, 0x00, 0x00, 0x01, 0xBD, 0x00,
/* 000041A0 */ 0x00, 0x3F, 0xBD, 0x00, 0x00, 0x41, 0xBD, 0x00, 0x00, 0x65, 0xBD, 0x00, 0x00, 0x9C, 0xBD, 0x00,
/* 000041B0 */ 0x00, 0xD3, 0xBD, 0x00, 0x00, 0xED, 0xBD, 0x00, 0x00, 0x28, 0xBE, 0x00, 0x00, 0x3B, 0xBE, 0x00,
/* 000041C0 */ 0x00, 0x3D, 0xBE, 0x00, 0x00, 0xAF, 0xBE, 0x00, 0x00, 0x22, 0xBF, 0x00, 0x00, 0x24, 0xBF, 0x00,
/* 000041D0 */ 0x00, 0x70, 0xBF, 0x00, 0x00, 0x9C, 0xBF, 0x00, 0x00, 0xDD, 0xBF, 0x00, 0x00, 0x11, 0xC0, 0x00,
/* 000041E0 */ 0x00, 0x53, 0xC0, 0x00, 0x00, 0x66, 0xC0, 0x00, 0x00, 0x68, 0xC0, 0x00, 0x00, 0xC8, 0xC0, 0x00,
/* 000041F0 */ 0x00, 0x46, 0xC1, 0x00, 0x00, 0x77, 0xC1, 0x00, 0x00, 0x79, 0xC1, 0x00, 0x00, 0xE1, 0xC1, 0x00,
/* 00004200 */ 0x00, 0x19, 0xC2, 0x00, 0x00, 0x51, 0xC2, 0x00, 0x00, 0x90, 0xC2, 0x00, 0x00, 0x92, 0xC2, 0x00,
/* 00004210 */ 0x00, 0xE4, 0xC2, 0x00, 0x00, 0x36, 0xC3, 0x00, 0x00, 0x38, 0xC3, 0x00, 0x00, 0xB3, 0xC3, 0x00,
/* 00004220 */ 0x00, 0x23, 0xC4, 0x00, 0x00, 0xAB, 0xC4, 0x00, 0x00, 0xBE, 0xC4, 0x00, 0x00, 0xC0, 0xC4, 0x00,
/* 00004230 */ 0x00, 0x22, 0xC5, 0x00, 0x00, 0x24, 0xC5, 0x00, 0x00, 0x5D, 0xC5, 0x00, 0x00, 0x9F, 0xC5, 0x00,
/* 00004240 */ 0x00, 0x0D, 0xC6, 0x00, 0x00, 0x0F, 0xC6, 0x00, 0x00, 0x44, 0xC6, 0x00, 0x00, 0xA3, 0xC6, 0x00,
/* 00004250 */ 0x00, 0xED, 0xC6, 0x00, 0x00, 0x00, 0xC7, 0x00, 0x00, 0x02, 0xC7, 0x00, 0x00, 0x2F, 0xC7, 0x00,
/* 00004260 */ 0x00, 0x6B, 0xC7, 0x00, 0x00, 0xA9, 0xC7, 0x00, 0x00, 0xC0, 0xC7, 0x00, 0x00, 0x17, 0xC8, 0x00,
/* 00004270 */ 0x00, 0x32, 0xC8, 0x00, 0x00, 0x7F, 0xC8, 0x00, 0x00, 0xA2, 0xC8, 0x00, 0x00, 0xD1, 0xC8, 0x00,
/* 00004280 */ 0x00, 0x1F, 0xC9, 0x00, 0x00, 0x36, 0xC9, 0x00, 0x00, 0xAD, 0xC9, 0x00, 0x00, 0x12, 0xCA, 0x00,
/* 00004290 */ 0x00, 0x2C, 0xCA, 0x00, 0x00, 0x57, 0xCA, 0x00, 0x00, 0x89, 0xCA, 0x00, 0x00, 0xF3, 0xCA, 0x00,
/* 000042A0 */ 0x00, 0x23, 0xCB, 0x00, 0x00, 0x7F, 0xCB, 0x00, 0x00, 0x9D, 0xCB, 0x00, 0x00, 0xF8, 0xCB, 0x00,
/* 000042B0 */ 0x00, 0x0F, 0xCC, 0x00, 0x00, 0x22, 0xCC, 0x00, 0x00, 0x24, 0xCC, 0x00, 0x00, 0xB9, 0xCC, 0x00,
/* 000042C0 */ 0x00, 0xBB, 0xCC, 0x00, 0x00, 0xED, 0xCC, 0x00, 0x00, 0x26, 0xCD, 0x00, 0x00, 0x6A, 0xCD, 0x00,
/* 000042D0 */ 0x00, 0x99, 0xCD, 0x00, 0x00, 0x9B, 0xCD, 0x00, 0x00, 0xCA, 0xCD, 0x00, 0x00, 0x03, 0xCE, 0x00,
/* 000042E0 */ 0x00, 0x16, 0xCE, 0x00, 0x00, 0x18, 0xCE, 0x00, 0x00, 0x4E, 0xCE, 0x00, 0x00, 0x95, 0xCE, 0x00,
/* 000042F0 */ 0x00, 0xF5, 0xCE, 0x00, 0x00, 0x2E, 0xCF, 0x00, 0x00, 0x91, 0xCF, 0x00, 0x00, 0xCF, 0xCF, 0x00,
/* 00004300 */ 0x00, 0x30, 0xD0, 0x00, 0x00, 0x6E, 0xD0, 0x00, 0x00, 0xCF, 0xD0, 0x00, 0x00, 0xE6, 0xD0, 0x00,
/* 00004310 */ 0x00, 0xF9, 0xD0, 0x00, 0x00, 0xFB, 0xD0, 0x00, 0x00, 0x48, 0xD1, 0x00, 0x00, 0x97, 0xD1, 0x00,
/* 00004320 */ 0x00, 0xE6, 0xD1, 0x00, 0x00, 0xE8, 0xD1, 0x00, 0x00, 0x27, 0xD2, 0x00, 0x00, 0x80, 0xD2, 0x00,
/* 00004330 */ 0x00, 0xD9, 0xD2, 0x00, 0x00, 0xEC, 0xD2, 0x00, 0x00, 0xEE, 0xD2, 0x00, 0x00, 0x2F, 0xD3, 0x00,
/* 00004340 */ 0x00, 0x6A, 0xD3, 0x00, 0x00, 0x6C, 0xD3, 0x00, 0x00, 0x83, 0xD3, 0x00, 0x00, 0xD8, 0xD3, 0x00,
/* 00004350 */ 0x00, 0x17, 0xD4, 0x00, 0x00, 0x36, 0xD4, 0x00, 0x00, 0x61, 0xD4, 0x00, 0x00, 0xB9, 0xD4, 0x00,
/* 00004360 */ 0x00, 0x3F, 0xD5, 0x00, 0x00, 0xA5, 0xD5, 0x00, 0x00, 0xE1, 0xD5, 0x00, 0x00, 0xF4, 0xD5, 0x00,
/* 00004370 */ 0x00, 0xF6, 0xD5, 0x00, 0x00, 0x2E, 0xD6, 0x00, 0x00, 0x90, 0xD6, 0x00, 0x00, 0xA3, 0xD6, 0x00,
/* 00004380 */ 0x00, 0xA5, 0xD6, 0x00, 0x00, 0x24, 0xD7, 0x00, 0x00, 0x64, 0xD7, 0x00, 0x00, 0x73, 0xD7, 0x00,
/* 00004390 */ 0x00, 0x75, 0xD7, 0x00, 0x00, 0xE6, 0xD7, 0x00, 0x00, 0x36, 0xD8, 0x00, 0x00, 0x98, 0xD8, 0x00,
/* 000043A0 */ 0x00, 0xAB, 0xD8, 0x00, 0x00, 0xAD, 0xD8, 0x00, 0x00, 0xE8, 0xD8, 0x00, 0x00, 0x3A, 0xD9, 0x00,
/* 000043B0 */ 0x00, 0x3C, 0xD9, 0x00, 0x00, 0x6E, 0xD9, 0x00, 0x00, 0xC3, 0xD9, 0x00, 0x00, 0x19, 0xDA, 0x00,
/* 000043C0 */ 0x00, 0x2E, 0xDA, 0x00, 0x00, 0x30, 0xDA, 0x00, 0x00, 0x58, 0xDA, 0x00, 0x00, 0x83, 0xDA, 0x00,
/* 000043D0 */ 0x00, 0xEA, 0xDA, 0x00, 0x00, 0x62, 0xDB, 0x00, 0x00, 0xD5, 0xDB, 0x00, 0x00, 0x03, 0xDC, 0x00,
/* 000043E0 */ 0x00, 0x31, 0xDC, 0x00, 0x00, 0x79, 0xDC, 0x00, 0x00, 0xC1, 0xDC, 0x00, 0x00, 0xC3, 0xDC, 0x00,
/* 000043F0 */ 0x00, 0x03, 0xDD, 0x00, 0x00, 0x47, 0xDD, 0x00, 0x00, 0x5E, 0xDD, 0x00, 0x00, 0x60, 0xDD, 0x00,
/* 00004400 */ 0x00, 0x98, 0xDD, 0x00, 0x00, 0x9A, 0xDD, 0x00, 0x00, 0xCF, 0xDD, 0x00, 0x00, 0x1D, 0xDE, 0x00,
/* 00004410 */ 0x00, 0x34, 0xDE, 0x00, 0x00, 0x36, 0xDE, 0x00, 0x00, 0x72, 0xDE, 0x00, 0x00, 0xB9, 0xDE, 0x00,
/* 00004420 */ 0x00, 0xBB, 0xDE, 0x00, 0x00, 0xF2, 0xDE, 0x00, 0x00, 0x32, 0xDF, 0x00, 0x00, 0x78, 0xDF, 0x00,
/* 00004430 */ 0x00, 0x8F, 0xDF, 0x00, 0x00, 0x91, 0xDF, 0x00, 0x00, 0xDE, 0xDF, 0x00, 0x00, 0xE0, 0xDF, 0x00,
/* 00004440 */ 0x00, 0x46, 0xE0, 0x00, 0x00, 0x83, 0xE0, 0x00, 0x00, 0x85, 0xE0, 0x00, 0x00, 0xA6, 0xE0, 0x00,
/* 00004450 */ 0x00, 0xB9, 0xE0, 0x00, 0x00, 0x00, 0xE1, 0x00, 0x00, 0x02, 0xE1, 0x00, 0x00, 0x28, 0xE1, 0x00,
/* 00004460 */ 0x00, 0x57, 0xE1, 0x00, 0x00, 0x59, 0xE1, 0x00, 0x00, 0x8E, 0xE1, 0x00, 0x00, 0xF8, 0xE1, 0x00,
/* 00004470 */ 0x00, 0x0F, 0xE2, 0x00, 0x00, 0x11, 0xE2, 0x00, 0x00, 0x59, 0xE2, 0x00, 0x00, 0xBB, 0xE2, 0x00,
/* 00004480 */ 0x00, 0x25, 0xE3, 0x00, 0x00, 0x3C, 0xE3, 0x00, 0x00, 0x3E, 0xE3, 0x00, 0x00, 0x97, 0xE3, 0x00,
/* 00004490 */ 0x00, 0xF2, 0xE3, 0x00, 0x00, 0x05, 0xE4, 0x00, 0x00, 0x57, 0xE4, 0x00, 0x00, 0x59, 0xE4, 0x00,
/* 000044A0 */ 0x00, 0xF4, 0xE4, 0x00, 0x00, 0xF6, 0xE4, 0x00, 0x00, 0x73, 0xE5, 0x00, 0x00, 0xF2, 0xE5, 0x00,
/* 000044B0 */ 0x00, 0x17, 0xE6, 0x00, 0x00, 0x19, 0xE6, 0x00, 0x00, 0xB3, 0xE6, 0x00, 0x00, 0xFC, 0xE6, 0x00,
/* 000044C0 */ 0x00, 0x9A, 0xE7, 0x00, 0x00, 0x9C, 0xE7, 0x00, 0x00, 0xEF, 0xE7, 0x00, 0x00, 0x28, 0xE8, 0x00,
/* 000044D0 */ 0x00, 0x61, 0xE8, 0x00, 0x00, 0xD8, 0xE8, 0x00, 0x00, 0xF3, 0xE8, 0x00, 0x00, 0x3F, 0xE9, 0x00,
/* 000044E0 */ 0x00, 0xA5, 0xE9, 0x00, 0x00, 0x1C, 0xEA, 0x00, 0x00, 0x37, 0xEA, 0x00, 0x00, 0x39, 0xEA, 0x00,
/* 000044F0 */ 0x00, 0x80, 0xEA, 0x00, 0x00, 0x82, 0xEA, 0x00, 0x00, 0xDF, 0xEA, 0x00, 0x00, 0x36, 0xEB, 0x00,
/* 00004500 */ 0x00, 0x8E, 0xEB, 0x00, 0x00, 0xAD, 0xEB, 0x00, 0x00, 0xCA, 0xEB, 0x00, 0x00, 0xCC, 0xEB, 0x00,
/* 00004510 */ 0x00, 0x0F, 0xEC, 0x00, 0x00, 0x5D, 0xEC, 0x00, 0x00, 0x72, 0xEC, 0x00, 0x00, 0x74, 0xEC, 0x00,
/* 00004520 */ 0x00, 0xBE, 0xEC, 0x00, 0x00, 0x06, 0xED, 0x00, 0x00, 0x3F, 0xED, 0x00, 0x00, 0xAD, 0xED, 0x00,
/* 00004530 */ 0x00, 0xC8, 0xED, 0x00, 0x00, 0xCA, 0xED, 0x00, 0x00, 0x16, 0xEE, 0x00, 0x00, 0x7C, 0xEE, 0x00,
/* 00004540 */ 0x00, 0xEA, 0xEE, 0x00, 0x00, 0x05, 0xEF, 0x00, 0x00, 0x07, 0xEF, 0x00, 0x00, 0x43, 0xEF, 0x00,
/* 00004550 */ 0x00, 0x82, 0xEF, 0x00, 0x00, 0x97, 0xEF, 0x00, 0x00, 0x99, 0xEF, 0x00, 0x00, 0xBF, 0xEF, 0x00,
/* 00004560 */ 0x00, 0xCE, 0xEF, 0x00, 0x00, 0xD9, 0xEF, 0x00, 0x00, 0x29, 0xF0, 0x00, 0x00, 0x44, 0xF0, 0x00,
/* 00004570 */ 0x00, 0x4F, 0xF0, 0x00, 0x00, 0x51, 0xF0, 0x00, 0x00, 0xD2, 0xF0, 0x00, 0x00, 0xFB, 0xF0, 0x00,
/* 00004580 */ 0x00, 0xFD, 0xF0, 0x00, 0x00, 0x38, 0xF1, 0x00, 0x00, 0x7F, 0xF1, 0x00, 0x00, 0xAD, 0xF1, 0x00,
/* 00004590 */ 0x00, 0xE4, 0xF1, 0x00, 0x00, 0xFE, 0xF1, 0x00, 0x00, 0x39, 0xF2, 0x00, 0x00, 0x4C, 0xF2, 0x00,
/* 000045A0 */ 0x00, 0x4E, 0xF2, 0x00, 0x00, 0x78, 0xF2, 0x00, 0x00, 0xBA, 0xF2, 0x00, 0x00, 0x4E, 0xF3, 0x00,
/* 000045B0 */ 0x00, 0x7D, 0xF3, 0x00, 0x00, 0x94, 0xF3, 0x00, 0x00, 0xA7, 0xF3, 0x00, 0x00, 0xE9, 0xF3, 0x00,
/* 000045C0 */ 0x00, 0x60, 0xF4, 0x00, 0x00, 0x8F, 0xF4, 0x00, 0x00, 0xA6, 0xF4, 0x00, 0x00, 0xB9, 0xF4, 0x00,
/* 000045D0 */ 0x00, 0xBB, 0xF4, 0x00, 0x00, 0x0F, 0xF5, 0x00, 0x00, 0x4C, 0xF5, 0x00, 0x00, 0x87, 0xF5, 0x00,
/* 000045E0 */ 0x00, 0xC5, 0xF5, 0x00, 0x00, 0xDE, 0xF5, 0x00, 0x00, 0x1C, 0xF6, 0x00, 0x00, 0x57, 0xF6, 0x00,
/* 000045F0 */ 0x00, 0x95, 0xF6, 0x00, 0x00, 0xAE, 0xF6, 0x00, 0x00, 0xEA, 0xF6, 0x00, 0x00, 0x25, 0xF7, 0x00,
/* 00004600 */ 0x00, 0x63, 0xF7, 0x00, 0x00, 0x7C, 0xF7, 0x00, 0x00, 0x8F, 0xF7, 0x00, 0x00, 0xE3, 0xF7, 0x00,
/* 00004610 */ 0x00, 0x20, 0xF8, 0x00, 0x00, 0x5B, 0xF8, 0x00, 0x00, 0x99, 0xF8, 0x00, 0x00, 0xB2, 0xF8, 0x00,
/* 00004620 */ 0x00, 0xF1, 0xF8, 0x00, 0x00, 0x2C, 0xF9, 0x00, 0x00, 0x6A, 0xF9, 0x00, 0x00, 0x83, 0xF9, 0x00,
/* 00004630 */ 0x00, 0xC2, 0xF9, 0x00, 0x00, 0xFD, 0xF9, 0x00, 0x00, 0x3B, 0xFA, 0x00, 0x00, 0x54, 0xFA, 0x00,
/* 00004640 */ 0x00, 0x67, 0xFA, 0x00, 0x00, 0x88, 0xFA, 0x00, 0x00, 0x97, 0xFA, 0x00, 0x00, 0x99, 0xFA, 0x00,
/* 00004650 */ 0x00, 0x24, 0xFB, 0x00, 0x00, 0x62, 0xFB, 0x00, 0x00, 0x86, 0xFB, 0x00, 0x00, 0x88, 0xFB, 0x00,
/* 00004660 */ 0x00, 0xB0, 0xFB, 0x00, 0x00, 0x08, 0xFC, 0x00, 0x00, 0x69, 0xFC, 0x00, 0x00, 0xA7, 0xFC, 0x00,
/* 00004670 */ 0x00, 0x01, 0xFD, 0x00, 0x00, 0x18, 0xFD, 0x00, 0x00, 0x2B, 0xFD, 0x00, 0x00, 0x2D, 0xFD, 0x00,
/* 00004680 */ 0x00, 0x59, 0xFD, 0x00, 0x00, 0x7E, 0xFD, 0x00, 0x00, 0xB5, 0xFD, 0x00, 0x00, 0x11, 0xFE, 0x00,
/* 00004690 */ 0x00, 0x4F, 0xFE, 0x00, 0x00, 0xA4, 0xFE, 0x00, 0x00, 0xBB, 0xFE, 0x00, 0x00, 0xCE, 0xFE, 0x00,
/* 000046A0 */ 0x00, 0xD0, 0xFE, 0x00, 0x00, 0xF6, 0xFE, 0x00, 0x00, 0x4D, 0xFF, 0x00, 0x00, 0xA5, 0xFF, 0x00,
/* 000046B0 */ 0x00, 0x00, 0x00, 0x01, 0x00, 0x5D, 0x00, 0x01, 0x00, 0x99, 0x00, 0x01, 0x00, 0xEF, 0x00, 0x01,
/* 000046C0 */ 0x00, 0x06, 0x01, 0x01, 0x00, 0x19, 0x01, 0x01, 0x00, 0x1B, 0x01, 0x01, 0x00, 0x3F, 0x01, 0x01,
/* 000046D0 */ 0x00, 0x8A, 0x01, 0x01, 0x00, 0x9D, 0x01, 0x01, 0x00, 0x9F, 0x01, 0x01, 0x00, 0xCC, 0x01, 0x01,
/* 000046E0 */ 0x00, 0x09, 0x02, 0x01, 0x00, 0x69, 0x02, 0x01, 0x00, 0xAC, 0x02, 0x01, 0x00, 0x05, 0x03, 0x01,
/* 000046F0 */ 0x00, 0x1C, 0x03, 0x01, 0x00, 0x2F, 0x03, 0x01, 0x00, 0x31, 0x03, 0x01, 0x00, 0x98, 0x03, 0x01,
/* 00004700 */ 0x00, 0xC1, 0x03, 0x01, 0x00, 0x0E, 0x04, 0x01, 0x00, 0x25, 0x04, 0x01, 0x00, 0x3A, 0x04, 0x01,
/* 00004710 */ 0x00, 0x3C, 0x04, 0x01, 0x00, 0x73, 0x04, 0x01, 0x00, 0xEA, 0x04, 0x01, 0x00, 0xF9, 0x04, 0x01,
/* 00004720 */ 0x00, 0xFB, 0x04, 0x01, 0x00, 0x29, 0x05, 0x01, 0x00, 0x5A, 0x05, 0x01, 0x00, 0x87, 0x05, 0x01,
/* 00004730 */ 0x00, 0xB4, 0x05, 0x01, 0x00, 0xE5, 0x05, 0x01, 0x00, 0x12, 0x06, 0x01, 0x00, 0x3F, 0x06, 0x01,
/* 00004740 */ 0x00, 0x75, 0x06, 0x01, 0x00, 0x9E, 0x06, 0x01, 0x00, 0xCA, 0x06, 0x01, 0x00, 0xDA, 0x06, 0x01,
/* 00004750 */ 0x00, 0xDC, 0x06, 0x01, 0x00, 0x14, 0x07, 0x01, 0x00, 0x4C, 0x07, 0x01, 0x00, 0x6C, 0x07, 0x01,
/* 00004760 */ 0x00, 0x7F, 0x07, 0x01, 0x00, 0x81, 0x07, 0x01, 0x00, 0xCA, 0x07, 0x01, 0x00, 0xD9, 0x07, 0x01,
/* 00004770 */ 0x00, 0xDB, 0x07, 0x01, 0x00, 0x4C, 0x08, 0x01, 0x00, 0xA9, 0x08, 0x01, 0x00, 0x20, 0x09, 0x01,
/* 00004780 */ 0x00, 0xB2, 0x09, 0x01, 0x00, 0x31, 0x0A, 0x01, 0x00, 0x58, 0x0A, 0x01, 0x00, 0x4E, 0x0B, 0x01,
/* 00004790 */ 0x00, 0x79, 0x0B, 0x01, 0x00, 0x8C, 0x0B, 0x01, 0x00, 0x8E, 0x0B, 0x01, 0x00, 0xD2, 0x0B, 0x01,
/* 000047A0 */ 0x00, 0x55, 0x0C, 0x01, 0x00, 0x89, 0x0C, 0x01, 0x00, 0x40, 0x0D, 0x01, 0x00, 0x53, 0x0D, 0x01,
/* 000047B0 */ 0x00, 0x7A, 0x0D, 0x01, 0x00, 0x89, 0x0D, 0x01, 0x00, 0x8B, 0x0D, 0x01, 0x00, 0xF1, 0x0D, 0x01,
/* 000047C0 */ 0x00, 0x3C, 0x0E, 0x01, 0x00, 0xB1, 0x0E, 0x01, 0x00, 0x43, 0x0F, 0x01, 0x00, 0x6A, 0x0F, 0x01,
/* 000047D0 */ 0x00, 0x6B, 0x10, 0x01, 0x00, 0x96, 0x10, 0x01, 0x00, 0xA9, 0x10, 0x01, 0x00, 0xAB, 0x10, 0x01,
/* 000047E0 */ 0x00, 0xF6, 0x10, 0x01, 0x00, 0x26, 0x11, 0x01, 0x00, 0xA5, 0x11, 0x01, 0x00, 0xDB, 0x11, 0x01,
/* 000047F0 */ 0x00, 0x57, 0x12, 0x01, 0x00, 0x6A, 0x12, 0x01, 0x00, 0x6C, 0x12, 0x01, 0x00, 0x93, 0x12, 0x01,
/* 00004800 */ 0x00, 0xA2, 0x12, 0x01, 0x00, 0xA4, 0x12, 0x01, 0x00, 0x07, 0x13, 0x01, 0x00, 0x53, 0x13, 0x01,
/* 00004810 */ 0x00, 0x92, 0x13, 0x01, 0x00, 0x0C, 0x14, 0x01, 0x00, 0x1F, 0x14, 0x01, 0x00, 0x21, 0x14, 0x01,
/* 00004820 */ 0x00, 0x5C, 0x14, 0x01, 0x00, 0xCA, 0x14, 0x01, 0x00, 0x2A, 0x15, 0x01, 0x00, 0xA0, 0x15, 0x01,
/* 00004830 */ 0x00, 0xB3, 0x15, 0x01, 0x00, 0xB5, 0x15, 0x01, 0x00, 0xF1, 0x15, 0x01, 0x00, 0x5D, 0x16, 0x01,
/* 00004840 */ 0x00, 0x88, 0x16, 0x01, 0x00, 0xFD, 0x16, 0x01, 0x00, 0x1B, 0x17, 0x01, 0x00, 0x9F, 0x17, 0x01,
/* 00004850 */ 0x00, 0xB6, 0x17, 0x01, 0x00, 0xF6, 0x17, 0x01, 0x00, 0x62, 0x18, 0x01, 0x00, 0x8D, 0x18, 0x01,
/* 00004860 */ 0x00, 0x02, 0x19, 0x01, 0x00, 0x20, 0x19, 0x01, 0x00, 0x9A, 0x19, 0x01, 0x00, 0xB1, 0x19, 0x01,
/* 00004870 */ 0x00, 0xC4, 0x19, 0x01, 0x00, 0xC6, 0x19, 0x01, 0x00, 0x5C, 0x1A, 0x01, 0x00, 0xE9, 0x1A, 0x01,
/* 00004880 */ 0x00, 0x5D, 0x1B, 0x01, 0x00, 0xA1, 0x1B, 0x01, 0x00, 0x1E, 0x1C, 0x01, 0x00, 0x31, 0x1C, 0x01,
/* 00004890 */ 0x00, 0x33, 0x1C, 0x01, 0x00, 0x6E, 0x1C, 0x01, 0x00, 0xE7, 0x1C, 0x01, 0x00, 0xFA, 0x1C, 0x01,
/* 000048A0 */ 0x00, 0xFC, 0x1C, 0x01, 0x00, 0x38, 0x1D, 0x01, 0x00, 0xB3, 0x1D, 0x01, 0x00, 0xC6, 0x1D, 0x01,
/* 000048B0 */ 0x00, 0xC8, 0x1D, 0x01, 0x00, 0x06, 0x1E, 0x01, 0x00, 0x85, 0x1E, 0x01, 0x00, 0x98, 0x1E, 0x01,
/* 000048C0 */ 0x00, 0x9A, 0x1E, 0x01, 0x00, 0xD8, 0x1E, 0x01, 0x00, 0x57, 0x1F, 0x01, 0x00, 0x6A, 0x1F, 0x01,
/* 000048D0 */ 0x00, 0x6C, 0x1F, 0x01, 0x00, 0xB0, 0x1F, 0x01, 0x00, 0x2E, 0x20, 0x01, 0x00, 0x41, 0x20, 0x01,
/* 000048E0 */ 0x00, 0x43, 0x20, 0x01, 0x00, 0x6A, 0x20, 0x01, 0x00, 0x79, 0x20, 0x01, 0x00, 0x7B, 0x20, 0x01,
/* 000048F0 */ 0x00, 0xD1, 0x20, 0x01, 0x00, 0x0B, 0x21, 0x01, 0x00, 0x3C, 0x21, 0x01, 0x00, 0x4F, 0x21, 0x01,
/* 00004900 */ 0x00, 0x51, 0x21, 0x01, 0x00, 0xED, 0x21, 0x01, 0x00, 0x50, 0x22, 0x01, 0x00, 0x63, 0x22, 0x01,
/* 00004910 */ 0x00, 0x65, 0x22, 0x01, 0x00, 0xA5, 0x22, 0x01, 0x00, 0xA7, 0x22, 0x01, 0x00, 0xCF, 0x22, 0x01,
/* 00004920 */ 0x00, 0x15, 0x23, 0x01, 0x00, 0x17, 0x23, 0x01, 0x00, 0x89, 0x23, 0x01, 0x00, 0xE9, 0x23, 0x01,
/* 00004930 */ 0x00, 0xEB, 0x23, 0x01, 0x00, 0x1A, 0x24, 0x01, 0x00, 0x6E, 0x24, 0x01, 0x00, 0x88, 0x24, 0x01,
/* 00004940 */ 0x00, 0xC7, 0x24, 0x01, 0x00, 0xDA, 0x24, 0x01, 0x00, 0xDC, 0x24, 0x01, 0x00, 0x0B, 0x25, 0x01,
/* 00004950 */ 0x00, 0x47, 0x25, 0x01, 0x00, 0x5A, 0x25, 0x01, 0x00, 0x5C, 0x25, 0x01, 0x00, 0x7F, 0x25, 0x01,
/* 00004960 */ 0x00, 0xEF, 0x25, 0x01, 0x00, 0x57, 0x26, 0x01, 0x00, 0xBC, 0x26, 0x01, 0x00, 0x3E, 0x27, 0x01,
/* 00004970 */ 0x00, 0xA1, 0x27, 0x01, 0x00, 0x06, 0x28, 0x01, 0x00, 0x6F, 0x28, 0x01, 0x00, 0xD8, 0x28, 0x01,
/* 00004980 */ 0x00, 0x48, 0x29, 0x01, 0x00, 0x4A, 0x29, 0x01, 0x00, 0xBA, 0x29, 0x01, 0x00, 0x31, 0x2A, 0x01,
/* 00004990 */ 0x00, 0x33, 0x2A, 0x01, 0x00, 0xA4, 0x2A, 0x01, 0x00, 0xA6, 0x2A, 0x01, 0x00, 0xF8, 0x2A, 0x01,
/* 000049A0 */ 0x00, 0x1F, 0x2B, 0x01, 0x00, 0x3E, 0x2B, 0x01, 0x00, 0x5F, 0x2B, 0x01, 0x00, 0x82, 0x2B, 0x01,
/* 000049B0 */ 0x00, 0xA1, 0x2B, 0x01, 0x00, 0xC2, 0x2B, 0x01, 0x00, 0xE7, 0x2B, 0x01, 0x00, 0x0C, 0x2C, 0x01,
/* 000049C0 */ 0x00, 0x3C, 0x2C, 0x01, 0x00, 0x58, 0x2C, 0x01, 0x00, 0x5A, 0x2C, 0x01, 0x00, 0x83, 0x2C, 0x01,
/* 000049D0 */ 0x00, 0xC5, 0x2C, 0x01, 0x00, 0x39, 0x2D, 0x01, 0x00, 0x3B, 0x2D, 0x01, 0x00, 0x62, 0x2D, 0x01,
/* 000049E0 */ 0x00, 0x97, 0x2D, 0x01, 0x00, 0xCE, 0x2D, 0x01, 0x00, 0x14, 0x2E, 0x01, 0x00, 0x16, 0x2E, 0x01,
/* 000049F0 */ 0x00, 0x39, 0x2E, 0x01, 0x00, 0x6E, 0x2E, 0x01, 0x00, 0x9B, 0x2E, 0x01, 0x00, 0xCA, 0x2E, 0x01,
/* 00004A00 */ 0x00, 0xFB, 0x2E, 0x01, 0x00, 0x28, 0x2F, 0x01, 0x00, 0x57, 0x2F, 0x01, 0x00, 0x8A, 0x2F, 0x01,
/* 00004A10 */ 0x00, 0xBD, 0x2F, 0x01, 0x00, 0xFC, 0x2F, 0x01, 0x00, 0xFE, 0x2F, 0x01, 0x00, 0x31, 0x30, 0x01,
/* 00004A20 */ 0x00, 0x72, 0x30, 0x01, 0x00, 0xB1, 0x30, 0x01, 0x00, 0xB3, 0x30, 0x01, 0x00, 0xF6, 0x30, 0x01,
/* 00004A30 */ 0x00, 0xF8, 0x30, 0x01, 0x00, 0x0C, 0x31, 0x01, 0x00, 0x26, 0x31, 0x01, 0x00, 0x7C, 0x31, 0x01,
/* 00004A40 */ 0x00, 0xF4, 0x31, 0x01, 0x00, 0x97, 0x32, 0x01, 0x00, 0x3C, 0x33, 0x01, 0x00, 0xA2, 0x33, 0x01,
/* 00004A50 */ 0x00, 0xB7, 0x33, 0x01, 0x00, 0xE1, 0x33, 0x01, 0x00, 0xE3, 0x33, 0x01, 0x00, 0xFA, 0x33, 0x01,
/* 00004A60 */ 0x00, 0x4A, 0x34, 0x01, 0x00, 0x8C, 0x34, 0x01, 0x00, 0xAB, 0x34, 0x01, 0x00, 0xD6, 0x34, 0x01,
/* 00004A70 */ 0x00, 0x01, 0x35, 0x01, 0x00, 0x03, 0x35, 0x01, 0x00, 0x72, 0x35, 0x01, 0x00, 0xC9, 0x35, 0x01,
/* 00004A80 */ 0x00, 0x1E, 0x36, 0x01, 0x00, 0x89, 0x36, 0x01, 0x00, 0xB2, 0x36, 0x01, 0x00, 0xC5, 0x36, 0x01,
/* 00004A90 */ 0x00, 0xC7, 0x36, 0x01, 0x00, 0xEC, 0x36, 0x01, 0x00, 0x1F, 0x37, 0x01, 0x00, 0xA0, 0x37, 0x01,
/* 00004AA0 */ 0x00, 0xB3, 0x37, 0x01, 0x00, 0xB5, 0x37, 0x01, 0x00, 0xCC, 0x37, 0x01, 0x00, 0x02, 0x38, 0x01,
/* 00004AB0 */ 0x00, 0x43, 0x38, 0x01, 0x00, 0x62, 0x38, 0x01, 0x00, 0x8D, 0x38, 0x01, 0x00, 0xB8, 0x38, 0x01,
/* 00004AC0 */ 0x00, 0xBA, 0x38, 0x01, 0x00, 0x1D, 0x39, 0x01, 0x00, 0xA3, 0x39, 0x01, 0x00, 0x09, 0x3A, 0x01,
/* 00004AD0 */ 0x00, 0x45, 0x3A, 0x01, 0x00, 0x58, 0x3A, 0x01, 0x00, 0x5A, 0x3A, 0x01, 0x00, 0x88, 0x3A, 0x01,
/* 00004AE0 */ 0x00, 0xEE, 0x3A, 0x01, 0x00, 0xF0, 0x3A, 0x01, 0x00, 0x73, 0x3B, 0x01, 0x00, 0xAF, 0x3B, 0x01,
/* 00004AF0 */ 0x00, 0x0F, 0x3C, 0x01, 0x00, 0x22, 0x3C, 0x01, 0x00, 0x66, 0x3C, 0x01, 0x00, 0x75, 0x3C, 0x01,
/* 00004B00 */ 0x00, 0x77, 0x3C, 0x01, 0x00, 0xE6, 0x3C, 0x01, 0x00, 0x32, 0x3D, 0x01, 0x00, 0x90, 0x3D, 0x01,
/* 00004B10 */ 0x00, 0xA3, 0x3D, 0x01, 0x00, 0xF7, 0x3D, 0x01, 0x00, 0x30, 0x3E, 0x01, 0x00, 0x5C, 0x3E, 0x01,
/* 00004B20 */ 0x00, 0x6F, 0x3E, 0x01, 0x00, 0xAA, 0x3E, 0x01, 0x00, 0x1F, 0x3F, 0x01, 0x00, 0x7E, 0x3F, 0x01,
/* 00004B30 */ 0x00, 0x93, 0x3F, 0x01, 0x00, 0x95, 0x3F, 0x01, 0x00, 0x08, 0x40, 0x01, 0x00, 0x54, 0x40, 0x01,
/* 00004B40 */ 0x00, 0xB6, 0x40, 0x01, 0x00, 0xC9, 0x40, 0x01, 0x00, 0x1D, 0x41, 0x01, 0x00, 0x56, 0x41, 0x01,
/* 00004B50 */ 0x00, 0x82, 0x41, 0x01, 0x00, 0x95, 0x41, 0x01, 0x00, 0xD0, 0x41, 0x01, 0x00, 0x47, 0x42, 0x01,
/* 00004B60 */ 0x00, 0xA6, 0x42, 0x01, 0x00, 0xBB, 0x42, 0x01, 0x00, 0xBD, 0x42, 0x01, 0x00, 0x30, 0x43, 0x01,
/* 00004B70 */ 0x00, 0x7C, 0x43, 0x01, 0x00, 0xDE, 0x43, 0x01, 0x00, 0xF1, 0x43, 0x01, 0x00, 0x45, 0x44, 0x01,
/* 00004B80 */ 0x00, 0x7E, 0x44, 0x01, 0x00, 0xAA, 0x44, 0x01, 0x00, 0xBD, 0x44, 0x01, 0x00, 0xF8, 0x44, 0x01,
/* 00004B90 */ 0x00, 0x6F, 0x45, 0x01, 0x00, 0xCE, 0x45, 0x01, 0x00, 0xE3, 0x45, 0x01, 0x00, 0xE5, 0x45, 0x01,
/* 00004BA0 */ 0x00, 0x0D, 0x46, 0x01, 0x00, 0x3A, 0x46, 0x01, 0x00, 0xA1, 0x46, 0x01, 0x00, 0x19, 0x47, 0x01,
/* 00004BB0 */ 0x00, 0x8C, 0x47, 0x01, 0x00, 0xBA, 0x47, 0x01, 0x00, 0xE8, 0x47, 0x01, 0x00, 0x30, 0x48, 0x01,
/* 00004BC0 */ 0x00, 0x78, 0x48, 0x01, 0x00, 0x7A, 0x48, 0x01, 0x00, 0xBA, 0x48, 0x01, 0x00, 0x00, 0x49, 0x01,
/* 00004BD0 */ 0x00, 0x17, 0x49, 0x01, 0x00, 0x19, 0x49, 0x01, 0x00, 0x51, 0x49, 0x01, 0x00, 0x86, 0x49, 0x01,
/* 00004BE0 */ 0x00, 0xD6, 0x49, 0x01, 0x00, 0xED, 0x49, 0x01, 0x00, 0xEF, 0x49, 0x01, 0x00, 0x2B, 0x4A, 0x01,
/* 00004BF0 */ 0x00, 0x72, 0x4A, 0x01, 0x00, 0x74, 0x4A, 0x01, 0x00, 0xAB, 0x4A, 0x01, 0x00, 0xEB, 0x4A, 0x01,
/* 00004C00 */ 0x00, 0x31, 0x4B, 0x01, 0x00, 0x48, 0x4B, 0x01, 0x00, 0x4A, 0x4B, 0x01, 0x00, 0x99, 0x4B, 0x01,
/* 00004C10 */ 0x00, 0x9B, 0x4B, 0x01, 0x00, 0x02, 0x4C, 0x01, 0x00, 0x3F, 0x4C, 0x01, 0x00, 0x41, 0x4C, 0x01,
/* 00004C20 */ 0x00, 0x62, 0x4C, 0x01, 0x00, 0x75, 0x4C, 0x01, 0x00, 0xC0, 0x4C, 0x01, 0x00, 0xC2, 0x4C, 0x01,
/* 00004C30 */ 0x00, 0xE7, 0x4C, 0x01, 0x00, 0x1C, 0x4D, 0x01, 0x00, 0x8A, 0x4D, 0x01, 0x00, 0xA1, 0x4D, 0x01,
/* 00004C40 */ 0x00, 0xE9, 0x4D, 0x01, 0x00, 0x4D, 0x4E, 0x01, 0x00, 0xBB, 0x4E, 0x01, 0x00, 0xD2, 0x4E, 0x01,
/* 00004C50 */ 0x00, 0xD4, 0x4E, 0x01, 0x00, 0x06, 0x4F, 0x01, 0x00, 0x55, 0x4F, 0x01, 0x00, 0x8F, 0x4F, 0x01,
/* 00004C60 */ 0x00, 0xAA, 0x4F, 0x01, 0x00, 0x1A, 0x50, 0x01, 0x00, 0x31, 0x50, 0x01, 0x00, 0x33, 0x50, 0x01,
/* 00004C70 */ 0x00, 0x89, 0x50, 0x01, 0x00, 0x9C, 0x50, 0x01, 0x00, 0xF0, 0x50, 0x01, 0x00, 0xF2, 0x50, 0x01,
/* 00004C80 */ 0x00, 0x3A, 0x51, 0x01, 0x00, 0x3C, 0x51, 0x01, 0x00, 0xDA, 0x51, 0x01, 0x00, 0x25, 0x52, 0x01,
/* 00004C90 */ 0x00, 0xC7, 0x52, 0x01, 0x00, 0xC9, 0x52, 0x01, 0x00, 0x15, 0x53, 0x01, 0x00, 0x5D, 0x53, 0x01,
/* 00004CA0 */ 0x00, 0x96, 0x53, 0x01, 0x00, 0x08, 0x54, 0x01, 0x00, 0x23, 0x54, 0x01, 0x00, 0x25, 0x54, 0x01,
/* 00004CB0 */ 0x00, 0x71, 0x54, 0x01, 0x00, 0xD9, 0x54, 0x01, 0x00, 0x4B, 0x55, 0x01, 0x00, 0x66, 0x55, 0x01,
/* 00004CC0 */ 0x00, 0x68, 0x55, 0x01, 0x00, 0xA4, 0x55, 0x01, 0x00, 0xE3, 0x55, 0x01, 0x00, 0xF8, 0x55, 0x01,
/* 00004CD0 */ 0x00, 0xFA, 0x55, 0x01, 0x00, 0x4F, 0x56, 0x01, 0x00, 0x88, 0x56, 0x01, 0x00, 0xC1, 0x56, 0x01,
/* 00004CE0 */ 0x00, 0x3C, 0x57, 0x01, 0x00, 0x57, 0x57, 0x01, 0x00, 0xA3, 0x57, 0x01, 0x00, 0x0B, 0x58, 0x01,
/* 00004CF0 */ 0x00, 0x86, 0x58, 0x01, 0x00, 0xA1, 0x58, 0x01, 0x00, 0xD4, 0x58, 0x01, 0x00, 0x10, 0x59, 0x01,
/* 00004D00 */ 0x00, 0x68, 0x59, 0x01, 0x00, 0xCE, 0x59, 0x01, 0x00, 0x0E, 0x5A, 0x01, 0x00, 0x4A, 0x5A, 0x01,
/* 00004D10 */ 0x00, 0x88, 0x5A, 0x01, 0x00, 0xBE, 0x5A, 0x01, 0x00, 0xF6, 0x5A, 0x01, 0x00, 0x30, 0x5B, 0x01,
/* 00004D20 */ 0x00, 0x66, 0x5B, 0x01, 0x00, 0x9E, 0x5B, 0x01, 0x00, 0xDA, 0x5B, 0x01, 0x00, 0x16, 0x5C, 0x01,
/* 00004D30 */ 0x00, 0x5D, 0x5C, 0x01, 0x00, 0x7F, 0x5C, 0x01, 0x00, 0xBE, 0x5C, 0x01, 0x00, 0x31, 0x5D, 0x01,
/* 00004D40 */ 0x00, 0xD4, 0x5D, 0x01, 0x00, 0x11, 0x5E, 0x01, 0x00, 0x30, 0x5E, 0x01, 0x00, 0x5B, 0x5E, 0x01,
/* 00004D50 */ 0x00, 0xA4, 0x5E, 0x01, 0x00, 0xF2, 0x5E, 0x01, 0x00, 0x07, 0x5F, 0x01, 0x00, 0x09, 0x5F, 0x01,
/* 00004D60 */ 0x00, 0xA8, 0x5F, 0x01, 0x00, 0xAA, 0x5F, 0x01, 0x00, 0xD2, 0x5F, 0x01, 0x00, 0xE1, 0x5F, 0x01,
/* 00004D70 */ 0x00, 0xEC, 0x5F, 0x01, 0x00, 0x3E, 0x60, 0x01, 0x00, 0x59, 0x60, 0x01, 0x00, 0x64, 0x60, 0x01,
/* 00004D80 */ 0x00, 0x66, 0x60, 0x01, 0x00, 0x98, 0x60, 0x01, 0x00, 0xB8, 0x60, 0x01, 0x00, 0x4F, 0x61, 0x01,
/* 00004D90 */ 0x00, 0xE6, 0x61, 0x01, 0x00, 0x7D, 0x62, 0x01, 0x00, 0x14, 0x63, 0x01, 0x00, 0x1B, 0x63, 0x01,
/* 00004DA0 */ 0x00, 0x20, 0x63, 0x01, 0x00, 0x00, 0x4F, 0xB9, 0x0C, 0x00, 0x00, 0x00, 0x04, 0x02, 0xA8, 0x41,
/* 00004DB0 */ 0xC0, 0x00, 0xFE, 0xD7, 0x02, 0x00, 0xFE, 0x75, 0x01, 0x01, 0xFF, 0x00, 0x10, 0x01, 0x00, 0xFE,
/* 00004DC0 */ 0x75, 0x01, 0xFF, 0xAB, 0x61, 0x01, 0x00, 0xFF, 0xAB, 0x61, 0x01, 0x00, 0x40, 0x01, 0x04, 0x04,
/* 00004DD0 */ 0x05, 0x05, 0x03, 0x05, 0xFE, 0xD8, 0x02, 0x0A, 0x09, 0xA8, 0x00, 0xD4, 0x00, 0x04, 0xFA, 0x04,
/* 00004DE0 */ 0x24, 0x00, 0x00, 0x01, 0x07, 0x00, 0x00, 0x00, 0x00, 0xED, 0x4D, 0x00, 0x00, 0xBF, 0x1D, 0x84,
/* 00004DF0 */ 0xE0, 0x89, 0xC6, 0x12, 0x07, 0x01, 0xA2, 0x41, 0xD1, 0x00, 0x01, 0xFE, 0x97, 0x01, 0x21, 0xFF,
/* 00004E00 */ 0x00, 0x10, 0x01, 0x00, 0x03, 0x03, 0xFE, 0x97, 0x01, 0xFF, 0x85, 0x61, 0x01, 0x00, 0xFF, 0x85,
/* 00004E10 */ 0x61, 0x01, 0x00, 0x40, 0x4A, 0x18, 0x30, 0x44, 0x09, 0xFE, 0x36, 0x02, 0xFE, 0x30, 0x02, 0x26,
/* 00004E20 */ 0x0F, 0x44, 0x43, 0x44, 0x44, 0x14, 0x41, 0x42, 0x43, 0x0B, 0x06, 0xFE, 0xD9, 0x02, 0x06, 0xFE,
/* 00004E30 */ 0xDA, 0x02, 0x06, 0xFE, 0xDB, 0x02, 0x06, 0xFE, 0xDC, 0x02, 0x06, 0xFE, 0xDD, 0x02, 0x07, 0x08,
/* 00004E40 */ 0x06, 0xFE, 0xDE, 0x02, 0x05, 0xFE, 0xDF, 0x02, 0x05, 0xFE, 0xE0, 0x02, 0x05, 0xFE, 0xE1, 0x02,
/* 00004E50 */ 0x05, 0xFE, 0xE2, 0x02, 0x05, 0xFE, 0xE3, 0x02, 0x06, 0xFE, 0xE4, 0x02, 0x06, 0xFE, 0xE5, 0x02,
/* 00004E60 */ 0x06, 0xFE, 0xE6, 0x02, 0x05, 0xFE, 0xE7, 0x02, 0x06, 0xFE, 0xE8, 0x02, 0x06, 0xFE, 0xE9, 0x02,
/* 00004E70 */ 0x05, 0xFE, 0xEA, 0x02, 0x06, 0xFE, 0xEB, 0x02, 0x06, 0xFE, 0xEC, 0x02, 0x06, 0xFE, 0xED, 0x02,
/* 00004E80 */ 0x05, 0xFE, 0xEE, 0x02, 0x06, 0xFE, 0xEF, 0x02, 0x06, 0xFE, 0xF0, 0x02, 0x05, 0xFE, 0xF1, 0x02,
/* 00004E90 */ 0x06, 0xFE, 0xF2, 0x02, 0x06, 0xFE, 0xF3, 0x02, 0x05, 0xFE, 0xF4, 0x02, 0x06, 0xFE, 0xF5, 0x02,
/* 00004EA0 */ 0x06, 0xFE, 0xF6, 0x02, 0x06, 0xFE, 0xF7, 0x02, 0x06, 0xFE, 0xF8, 0x02, 0x06, 0xFE, 0xF9, 0x02,
/* 00004EB0 */ 0x06, 0xFE, 0xFA, 0x02, 0x06, 0xFE, 0xFB, 0x02, 0x06, 0xFE, 0xFC, 0x02, 0x06, 0xFE, 0xFD, 0x02,
/* 00004EC0 */ 0x06, 0xFE, 0xFE, 0x02, 0x06, 0xFE, 0xFF, 0x02, 0x0C, 0x06, 0xFE, 0x00, 0x03, 0x06, 0xFE, 0x01,
/* 00004ED0 */ 0x03, 0x06, 0xFE, 0x02, 0x03, 0xFE, 0x04, 0x09, 0x96, 0x38, 0x31, 0xD4, 0x0E, 0x32, 0x96, 0x02,
/* 00004EE0 */ 0x32, 0xD4, 0x0F, 0x33, 0x96, 0x03, 0x33, 0xD4, 0x10, 0x34, 0x96, 0x04, 0x34, 0xD4, 0x11, 0x35,
/* 00004EF0 */ 0x96, 0x05, 0x35, 0xD4, 0x12, 0x36, 0x96, 0x06, 0x36, 0xD4, 0x13, 0x37, 0x96, 0x07, 0x37, 0xD4,
/* 00004F00 */ 0x14, 0x38, 0x96, 0x08, 0x38, 0x4F, 0x39, 0x4F, 0x3C, 0x4F, 0x3D, 0x4F, 0x44, 0x96, 0x39, 0x44,
/* 00004F10 */ 0x4F, 0x44, 0x96, 0x3A, 0x44, 0x4F, 0x44, 0x96, 0x3B, 0x44, 0x4F, 0x44, 0x96, 0x3C, 0x44, 0x4F,
/* 00004F20 */ 0x44, 0x96, 0x3D, 0x44, 0x4F, 0x44, 0x96, 0x3E, 0x44, 0x4F, 0x44, 0x96, 0x3F, 0x44, 0x4F, 0x44,
/* 00004F30 */ 0x96, 0x40, 0x44, 0x4F, 0x44, 0x96, 0x41, 0x44, 0x4F, 0x44, 0x96, 0x42, 0x44, 0x4F, 0x44, 0x96,
/* 00004F40 */ 0x43, 0x44, 0x4F, 0x44, 0x96, 0x44, 0x44, 0x4F, 0x44, 0x96, 0x45, 0x44, 0x4F, 0x44, 0x96, 0x46,
/* 00004F50 */ 0x44, 0x4F, 0x44, 0x96, 0x47, 0x44, 0x4F, 0x44, 0x96, 0x48, 0x44, 0x4F, 0x44, 0x96, 0x49, 0x44,
/* 00004F60 */ 0x4F, 0x44, 0x96, 0x4A, 0x44, 0x4F, 0x44, 0x96, 0x4B, 0x44, 0x62, 0x44, 0x30, 0x00, 0x96, 0x09,
/* 00004F70 */ 0x44, 0x93, 0x09, 0x44, 0x00, 0x00, 0x77, 0x02, 0x44, 0x01, 0x93, 0x09, 0x44, 0x00, 0x00, 0x62,
/* 00004F80 */ 0x44, 0x44, 0x02, 0xA8, 0x45, 0x14, 0x03, 0x00, 0x44, 0x45, 0x09, 0x1F, 0x00, 0x93, 0x09, 0x44,
/* 00004F90 */ 0x00, 0x00, 0x93, 0x09, 0x45, 0x00, 0x00, 0x62, 0x45, 0x45, 0x03, 0x07, 0x01, 0x00, 0xC4, 0x01,
/* 00004FA0 */ 0x45, 0x45, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x77, 0x45, 0x44, 0x04, 0x93, 0x09, 0x44, 0x00,
/* 00004FB0 */ 0x00, 0x62, 0x44, 0x44, 0x05, 0xA8, 0x45, 0x14, 0x03, 0x00, 0x44, 0x45, 0x09, 0x1F, 0x00, 0x93,
/* 00004FC0 */ 0x09, 0x44, 0x00, 0x00, 0x93, 0x09, 0x45, 0x00, 0x00, 0x62, 0x45, 0x45, 0x03, 0x07, 0x01, 0x00,
/* 00004FD0 */ 0xC4, 0x01, 0x45, 0x45, 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x77, 0x45, 0x44, 0x06, 0x93, 0x09,
/* 00004FE0 */ 0x45, 0x00, 0x00, 0x62, 0x45, 0x45, 0x07, 0xAC, 0x44, 0x0F, 0x02, 0x00, 0x45, 0xAB, 0x44, 0x96,
/* 00004FF0 */ 0x39, 0x44, 0x93, 0x09, 0x44, 0x00, 0x00, 0x62, 0x44, 0x44, 0x08, 0x47, 0x39, 0x44, 0x96, 0x3A,
/* 00005000 */ 0x03, 0x93, 0x09, 0x44, 0x00, 0x00, 0x62, 0x44, 0x44, 0x09, 0x96, 0x0A, 0x44, 0x93, 0x09, 0x44,
/* 00005010 */ 0x00, 0x00, 0x62, 0x44, 0x44, 0x0A, 0x96, 0x0B, 0x44, 0x93, 0x09, 0x44, 0x00, 0x00, 0x62, 0x44,
/* 00005020 */ 0x44, 0x0B, 0x96, 0x0C, 0x44, 0x93, 0x09, 0x44, 0x00, 0x00, 0x62, 0x44, 0x44, 0x0C, 0x96, 0x0D,
/* 00005030 */ 0x44, 0x93, 0x09, 0x44, 0x00, 0x00, 0x62, 0x44, 0x44, 0x0D, 0x96, 0x0E, 0x44, 0x93, 0x09, 0x44,
/* 00005040 */ 0x00, 0x00, 0x62, 0x44, 0x44, 0x0E, 0x96, 0x0F, 0x44, 0x93, 0x09, 0x44, 0x00, 0x00, 0x62, 0x44,
/* 00005050 */ 0x44, 0x0F, 0x96, 0x10, 0x44, 0x93, 0x09, 0x44, 0x00, 0x00, 0x62, 0x44, 0x44, 0x10, 0x96, 0x11,
/* 00005060 */ 0x44, 0x93, 0x09, 0x44, 0x00, 0x00, 0x62, 0x44, 0x44, 0x11, 0x96, 0x12, 0x44, 0x93, 0x09, 0x44,
/* 00005070 */ 0x00, 0x00, 0x62, 0x44, 0x44, 0x12, 0x96, 0x13, 0x44, 0x93, 0x09, 0x44, 0x00, 0x00, 0x62, 0x44,
/* 00005080 */ 0x44, 0x13, 0x47, 0x3A, 0x44, 0x93, 0x09, 0x44, 0x00, 0x00, 0x62, 0x44, 0x44, 0x14, 0x96, 0x14,
/* 00005090 */ 0x44, 0x93, 0x0A, 0x44, 0x01, 0x00, 0x07, 0x03, 0x00, 0x5C, 0x00, 0x09, 0xCC, 0x00, 0x00, 0x00,
/* 000050A0 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x45, 0x00, 0x00, 0x00, 0x93, 0x09, 0x46, 0x00, 0x00, 0x62, 0x46,
/* 000050B0 */ 0x46, 0x15, 0x7B, 0x46, 0x45, 0x16, 0x93, 0x09, 0x46, 0x00, 0x00, 0x62, 0x46, 0x46, 0x17, 0x7B,
/* 000050C0 */ 0x46, 0x45, 0x18, 0x93, 0x09, 0x46, 0x00, 0x00, 0x62, 0x46, 0x46, 0x19, 0x7B, 0x46, 0x45, 0x1A,
/* 000050D0 */ 0x93, 0x09, 0x46, 0x00, 0x00, 0x62, 0x46, 0x46, 0x1B, 0x7B, 0x46, 0x45, 0x1C, 0x5C, 0x01, 0x45,
/* 000050E0 */ 0x5D, 0x02, 0x08, 0x02, 0x00, 0xEE, 0x03, 0x44, 0x44, 0x02, 0x00, 0x96, 0x15, 0x44, 0x93, 0x09,
/* 000050F0 */ 0x44, 0x00, 0x00, 0x62, 0x44, 0x44, 0x1D, 0x96, 0x16, 0x44, 0x93, 0x09, 0x44, 0x00, 0x00, 0x62,
/* 00005100 */ 0x44, 0x44, 0x1E, 0x96, 0x17, 0x44, 0x93, 0x09, 0x44, 0x00, 0x00, 0x62, 0x44, 0x44, 0x1F, 0x96,
/* 00005110 */ 0x18, 0x44, 0x93, 0x09, 0x44, 0x00, 0x00, 0x62, 0x44, 0x44, 0x20, 0x96, 0x19, 0x44, 0x93, 0x09,
/* 00005120 */ 0x44, 0x00, 0x00, 0x62, 0x44, 0x44, 0x21, 0x96, 0x1A, 0x44, 0xD4, 0x00, 0x44, 0x96, 0x1B, 0x44,
/* 00005130 */ 0x93, 0x09, 0x44, 0x00, 0x00, 0x62, 0x44, 0x44, 0x22, 0x96, 0x1C, 0x44, 0x93, 0x09, 0x44, 0x00,
/* 00005140 */ 0x00, 0x62, 0x44, 0x44, 0x23, 0x96, 0x1D, 0x44, 0x93, 0x09, 0x44, 0x00, 0x00, 0x62, 0x44, 0x44,
/* 00005150 */ 0x24, 0x96, 0x1E, 0x44, 0x93, 0x09, 0x44, 0x00, 0x00, 0x62, 0x44, 0x44, 0x25, 0x96, 0x1F, 0x44,
/* 00005160 */ 0x93, 0x09, 0x44, 0x00, 0x00, 0x62, 0x44, 0x44, 0x26, 0x96, 0x20, 0x44, 0x93, 0x09, 0x44, 0x00,
/* 00005170 */ 0x00, 0x62, 0x44, 0x44, 0x27, 0x96, 0x21, 0x44, 0x93, 0x09, 0x44, 0x00, 0x00, 0x62, 0x44, 0x44,
/* 00005180 */ 0x28, 0x96, 0x22, 0x44, 0x93, 0x09, 0x44, 0x00, 0x00, 0x62, 0x44, 0x44, 0x29, 0x96, 0x23, 0x44,
/* 00005190 */ 0x93, 0x09, 0x44, 0x00, 0x00, 0x62, 0x44, 0x44, 0x2A, 0x96, 0x24, 0x44, 0x93, 0x09, 0x44, 0x00,
/* 000051A0 */ 0x00, 0x62, 0x44, 0x44, 0x2B, 0x96, 0x25, 0x44, 0x93, 0x16, 0x44, 0x02, 0x00, 0x07, 0x02, 0x00,
/* 000051B0 */ 0x5C, 0x00, 0x09, 0xCB, 0x45, 0x5C, 0x01, 0x45, 0xEE, 0x02, 0x44, 0x44, 0x03, 0x00, 0x47, 0x3B,
/* 000051C0 */ 0x44, 0x93, 0x09, 0x44, 0x00, 0x00, 0x62, 0x44, 0x44, 0x2C, 0x96, 0x26, 0x44, 0x93, 0x09, 0x44,
/* 000051D0 */ 0x00, 0x00, 0x62, 0x44, 0x44, 0x2D, 0x96, 0x27, 0x44, 0xA8, 0x44, 0x96, 0x3B, 0x44, 0xD4, 0x01,
/* 000051E0 */ 0x44, 0x96, 0x3C, 0x44, 0xD4, 0x02, 0x44, 0x96, 0x3D, 0x44, 0xD4, 0x03, 0x44, 0x96, 0x3E, 0x44,
/* 000051F0 */ 0xD4, 0x04, 0x44, 0x96, 0x28, 0x44, 0xD4, 0x05, 0x44, 0x96, 0x29, 0x44, 0xD4, 0x06, 0x44, 0x96,
/* 00005200 */ 0x2A, 0x44, 0xD4, 0x07, 0x44, 0x96, 0x2B, 0x44, 0xD4, 0x08, 0x44, 0x96, 0x2C, 0x44, 0xD4, 0x09,
/* 00005210 */ 0x44, 0x96, 0x2D, 0x44, 0xD4, 0x0A, 0x44, 0x96, 0x2E, 0x44, 0xD4, 0x0B, 0x44, 0x96, 0x2F, 0x44,
/* 00005220 */ 0xA8, 0x44, 0x96, 0x3F, 0x44, 0xD4, 0x0C, 0x44, 0x96, 0x30, 0x44, 0xD4, 0x0D, 0x44, 0x07, 0x01,
/* 00005230 */ 0x00, 0x5C, 0x00, 0x09, 0xEE, 0x01, 0x44, 0x44, 0x04, 0x00, 0x96, 0x31, 0x44, 0xA8, 0x44, 0x96,
/* 00005240 */ 0x40, 0x44, 0xA8, 0x44, 0x96, 0x41, 0x44, 0xA8, 0x44, 0x96, 0x42, 0x44, 0xA8, 0x44, 0x96, 0x43,
/* 00005250 */ 0x44, 0xD4, 0x15, 0x44, 0x96, 0x32, 0x44, 0xD4, 0x16, 0x44, 0x96, 0x33, 0x44, 0xD4, 0x17, 0x44,
/* 00005260 */ 0x96, 0x34, 0x44, 0x93, 0x0A, 0x44, 0x01, 0x00, 0x07, 0x03, 0x00, 0x5C, 0x00, 0x09, 0xCB, 0x45,
/* 00005270 */ 0x5C, 0x01, 0x45, 0x5D, 0x02, 0x08, 0x05, 0x00, 0xEE, 0x03, 0x44, 0x44, 0x05, 0x00, 0x54, 0x3C,
/* 00005280 */ 0x44, 0x93, 0x09, 0x45, 0x00, 0x00, 0x6D, 0x44, 0x45, 0x2E, 0x07, 0x03, 0x00, 0x5C, 0x00, 0x45,
/* 00005290 */ 0x5C, 0x01, 0x3C, 0x93, 0x0A, 0x46, 0x01, 0x00, 0x07, 0x03, 0x00, 0x5C, 0x00, 0x09, 0xCC, 0x18,
/* 000052A0 */ 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x47, 0x00, 0x00, 0x00, 0x7B, 0x0B, 0x47, 0x2F, 0x5C,
/* 000052B0 */ 0x01, 0x47, 0x5D, 0x02, 0x08, 0x07, 0x00, 0xEE, 0x03, 0x46, 0x46, 0x07, 0x00, 0x5C, 0x02, 0x46,
/* 000052C0 */ 0xF2, 0x03, 0xFF, 0x44, 0x2E, 0x00, 0x00, 0x00, 0x06, 0x00, 0x96, 0x44, 0x0C, 0x93, 0x0C, 0x44,
/* 000052D0 */ 0x03, 0x00, 0x07, 0x04, 0x00, 0x5C, 0x00, 0x09, 0x93, 0x20, 0x45, 0x04, 0x00, 0x5C, 0x01, 0x45,
/* 000052E0 */ 0x93, 0x2A, 0x45, 0x05, 0x00, 0x07, 0x03, 0x00, 0x5C, 0x00, 0x09, 0x93, 0x44, 0x46, 0x06, 0x00,
/* 000052F0 */ 0x5C, 0x01, 0x46, 0xD4, 0x18, 0x46, 0x5C, 0x02, 0x46, 0xEE, 0x03, 0x45, 0x45, 0x09, 0x00, 0x5C,
/* 00005300 */ 0x02, 0x45, 0x5C, 0x03, 0x3C, 0xEE, 0x04, 0x44, 0x44, 0x08, 0x00, 0x96, 0x45, 0x44, 0x96, 0x46,
/* 00005310 */ 0x0D, 0x93, 0x0C, 0x44, 0x03, 0x00, 0x07, 0x04, 0x00, 0x5C, 0x00, 0x09, 0x93, 0x20, 0x45, 0x04,
/* 00005320 */ 0x00, 0x5C, 0x01, 0x45, 0x93, 0x2A, 0x45, 0x05, 0x00, 0x07, 0x03, 0x00, 0x5C, 0x00, 0x09, 0x93,
/* 00005330 */ 0x46, 0x46, 0x07, 0x00, 0x5C, 0x01, 0x46, 0xD4, 0x19, 0x46, 0x5C, 0x02, 0x46, 0xEE, 0x03, 0x45,
/* 00005340 */ 0x45, 0x0B, 0x00, 0x5C, 0x02, 0x45, 0x5C, 0x03, 0x3C, 0xEE, 0x04, 0x44, 0x44, 0x0A, 0x00, 0x96,
/* 00005350 */ 0x47, 0x44, 0x96, 0x48, 0x0E, 0x93, 0x0C, 0x44, 0x03, 0x00, 0x07, 0x04, 0x00, 0x5C, 0x00, 0x09,
/* 00005360 */ 0x93, 0x20, 0x45, 0x04, 0x00, 0x5C, 0x01, 0x45, 0x93, 0x2A, 0x45, 0x05, 0x00, 0x07, 0x03, 0x00,
/* 00005370 */ 0x5C, 0x00, 0x09, 0x93, 0x48, 0x46, 0x08, 0x00, 0x5C, 0x01, 0x46, 0xD4, 0x1A, 0x46, 0x5C, 0x02,
/* 00005380 */ 0x46, 0xEE, 0x03, 0x45, 0x45, 0x0D, 0x00, 0x5C, 0x02, 0x45, 0x5C, 0x03, 0x3C, 0xEE, 0x04, 0x44,
/* 00005390 */ 0x44, 0x0C, 0x00, 0x96, 0x49, 0x44, 0x96, 0x4A, 0x0F, 0x93, 0x0C, 0x44, 0x03, 0x00, 0x07, 0x04,
/* 000053A0 */ 0x00, 0x5C, 0x00, 0x09, 0x93, 0x20, 0x45, 0x04, 0x00, 0x5C, 0x01, 0x45, 0x93, 0x2A, 0x45, 0x05,
/* 000053B0 */ 0x00, 0x07, 0x03, 0x00, 0x5C, 0x00, 0x09, 0x93, 0x4A, 0x46, 0x09, 0x00, 0x5C, 0x01, 0x46, 0xD4,
/* 000053C0 */ 0x1B, 0x46, 0x5C, 0x02, 0x46, 0xEE, 0x03, 0x45, 0x45, 0x0F, 0x00, 0x5C, 0x02, 0x45, 0x5C, 0x03,
/* 000053D0 */ 0x3C, 0xEE, 0x04, 0x44, 0x44, 0x0E, 0x00, 0x54, 0x3D, 0x44, 0x93, 0x1B, 0x44, 0x0A, 0x00, 0x07,
/* 000053E0 */ 0x04, 0x00, 0x5C, 0x00, 0x09, 0x93, 0x45, 0x45, 0x0B, 0x00, 0x5C, 0x01, 0x45, 0x5D, 0x02, 0x10,
/* 000053F0 */ 0x10, 0x00, 0xCC, 0x24, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x45, 0x00, 0x00, 0x00, 0x7B,
/* 00005400 */ 0x12, 0x45, 0x30, 0x5C, 0x03, 0x45, 0xEE, 0x04, 0xFF, 0x44, 0x10, 0x00, 0x93, 0x1B, 0x44, 0x0A,
/* 00005410 */ 0x00, 0x07, 0x04, 0x00, 0x5C, 0x00, 0x09, 0x93, 0x47, 0x45, 0x0C, 0x00, 0x5C, 0x01, 0x45, 0x5D,
/* 00005420 */ 0x02, 0x10, 0x11, 0x00, 0xCC, 0x30, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x45, 0x00, 0x00,
/* 00005430 */ 0x00, 0x7B, 0x12, 0x45, 0x30, 0x5C, 0x03, 0x45, 0xEE, 0x04, 0xFF, 0x44, 0x11, 0x00, 0x93, 0x1B,
/* 00005440 */ 0x44, 0x0A, 0x00, 0x07, 0x04, 0x00, 0x5C, 0x00, 0x09, 0x93, 0x49, 0x45, 0x0D, 0x00, 0x5C, 0x01,
/* 00005450 */ 0x45, 0x5D, 0x02, 0x10, 0x12, 0x00, 0xCC, 0x3C, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x45,
/* 00005460 */ 0x00, 0x00, 0x00, 0x7B, 0x12, 0x45, 0x30, 0x5C, 0x03, 0x45, 0xEE, 0x04, 0xFF, 0x44, 0x12, 0x00,
/* 00005470 */ 0x93, 0x1B, 0x44, 0x0A, 0x00, 0x07, 0x04, 0x00, 0x5C, 0x00, 0x09, 0x5C, 0x01, 0x3D, 0x5D, 0x02,
/* 00005480 */ 0x10, 0x13, 0x00, 0xCC, 0x48, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x45, 0x00, 0x00, 0x00,
/* 00005490 */ 0x7B, 0x13, 0x45, 0x30, 0x5C, 0x03, 0x45, 0xEE, 0x04, 0xFF, 0x44, 0x13, 0x00, 0x93, 0x0A, 0x44,
/* 000054A0 */ 0x01, 0x00, 0x07, 0x03, 0x00, 0x5C, 0x00, 0x09, 0xCC, 0x54, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00,
/* 000054B0 */ 0x00, 0x45, 0x00, 0x00, 0x00, 0x93, 0x0A, 0x46, 0x01, 0x00, 0x07, 0x03, 0x00, 0x5C, 0x00, 0x09,
/* 000054C0 */ 0xCC, 0x80, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x47, 0x00, 0x00, 0x00, 0x7B, 0x16, 0x47,
/* 000054D0 */ 0x31, 0x5C, 0x01, 0x47, 0x5D, 0x02, 0x08, 0x15, 0x00, 0xEE, 0x03, 0x46, 0x46, 0x15, 0x00, 0x7B,
/* 000054E0 */ 0x46, 0x45, 0x32, 0x93, 0x0A, 0x46, 0x01, 0x00, 0x07, 0x03, 0x00, 0x5C, 0x00, 0x09, 0xCC, 0x8C,
/* 000054F0 */ 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x47, 0x00, 0x00, 0x00, 0x7B, 0x16, 0x47, 0x31, 0x5C,
/* 00005500 */ 0x01, 0x47, 0x5D, 0x02, 0x08, 0x16, 0x00, 0xEE, 0x03, 0x46, 0x46, 0x16, 0x00, 0x7B, 0x46, 0x45,
/* 00005510 */ 0x33, 0x93, 0x0A, 0x46, 0x01, 0x00, 0x07, 0x03, 0x00, 0x5C, 0x00, 0x09, 0xCC, 0x98, 0x00, 0x00,
/* 00005520 */ 0x00, 0x09, 0x00, 0x00, 0x00, 0x47, 0x00, 0x00, 0x00, 0x7B, 0x1A, 0x47, 0x34, 0x5C, 0x01, 0x47,
/* 00005530 */ 0x5D, 0x02, 0x08, 0x17, 0x00, 0xEE, 0x03, 0x46, 0x46, 0x17, 0x00, 0x7B, 0x46, 0x45, 0x35, 0x93,
/* 00005540 */ 0x0A, 0x46, 0x01, 0x00, 0x07, 0x03, 0x00, 0x5C, 0x00, 0x09, 0xCC, 0xA4, 0x00, 0x00, 0x00, 0x0A,
/* 00005550 */ 0x00, 0x00, 0x00, 0x47, 0x00, 0x00, 0x00, 0x7B, 0x1D, 0x47, 0x36, 0x5C, 0x01, 0x47, 0x5D, 0x02,
/* 00005560 */ 0x08, 0x18, 0x00, 0xEE, 0x03, 0x46, 0x46, 0x18, 0x00, 0x7B, 0x46, 0x45, 0x37, 0x93, 0x0A, 0x46,
/* 00005570 */ 0x01, 0x00, 0x07, 0x03, 0x00, 0x5C, 0x00, 0x09, 0xCC, 0xB0, 0x00, 0x00, 0x00, 0x0B, 0x00, 0x00,
/* 00005580 */ 0x00, 0x47, 0x00, 0x00, 0x00, 0x7B, 0x20, 0x47, 0x38, 0x7B, 0x1D, 0x47, 0x36, 0x7B, 0x22, 0x47,
/* 00005590 */ 0x39, 0x5C, 0x01, 0x47, 0x5D, 0x02, 0x08, 0x19, 0x00, 0xEE, 0x03, 0x46, 0x46, 0x19, 0x00, 0x7B,
/* 000055A0 */ 0x46, 0x45, 0x3A, 0x93, 0x0A, 0x46, 0x01, 0x00, 0x07, 0x03, 0x00, 0x5C, 0x00, 0x09, 0xCC, 0xC4,
/* 000055B0 */ 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x47, 0x00, 0x00, 0x00, 0x7B, 0x1D, 0x47, 0x36, 0x7B,
/* 000055C0 */ 0x22, 0x47, 0x39, 0x5C, 0x01, 0x47, 0x5D, 0x02, 0x08, 0x1A, 0x00, 0xEE, 0x03, 0x46, 0x46, 0x1A,
/* 000055D0 */ 0x00, 0x7B, 0x46, 0x45, 0x3B, 0x93, 0x0A, 0x46, 0x01, 0x00, 0x07, 0x03, 0x00, 0x5C, 0x00, 0x09,
/* 000055E0 */ 0xCC, 0xD4, 0x00, 0x00, 0x00, 0x0D, 0x00, 0x00, 0x00, 0x47, 0x00, 0x00, 0x00, 0x7B, 0x1D, 0x47,
/* 000055F0 */ 0x36, 0x7B, 0x22, 0x47, 0x39, 0x5C, 0x01, 0x47, 0x5D, 0x02, 0x08, 0x1B, 0x00, 0xEE, 0x03, 0x46,
/* 00005600 */ 0x46, 0x1B, 0x00, 0x7B, 0x46, 0x45, 0x3C, 0x93, 0x0A, 0x46, 0x01, 0x00, 0x07, 0x03, 0x00, 0x5C,
/* 00005610 */ 0x00, 0x09, 0xCC, 0xE4, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x47, 0x00, 0x00, 0x00, 0x7B,
/* 00005620 */ 0x21, 0x47, 0x39, 0x7B, 0x22, 0x47, 0x3D, 0x5C, 0x01, 0x47, 0x5D, 0x02, 0x08, 0x1C, 0x00, 0xEE,
/* 00005630 */ 0x03, 0x46, 0x46, 0x1C, 0x00, 0x7B, 0x46, 0x45, 0x3E, 0x93, 0x0A, 0x46, 0x01, 0x00, 0x07, 0x03,
/* 00005640 */ 0x00, 0x5C, 0x00, 0x09, 0xCC, 0xF4, 0x00, 0x00, 0x00, 0x0F, 0x00, 0x00, 0x00, 0x47, 0x00, 0x00,
/* 00005650 */ 0x00, 0x7B, 0x21, 0x47, 0x39, 0x7B, 0x22, 0x47, 0x3D, 0x5C, 0x01, 0x47, 0x5D, 0x02, 0x08, 0x1D,
/* 00005660 */ 0x00, 0xEE, 0x03, 0x46, 0x46, 0x1D, 0x00, 0x7B, 0x46, 0x45, 0x3F, 0x5C, 0x01, 0x45, 0x5D, 0x02,
/* 00005670 */ 0x08, 0x14, 0x00, 0xEE, 0x03, 0x44, 0x44, 0x14, 0x00, 0x96, 0x35, 0x44, 0xD4, 0x1C, 0x44, 0x07,
/* 00005680 */ 0x01, 0x00, 0x5C, 0x00, 0x09, 0xEE, 0x01, 0x44, 0x44, 0x1E, 0x00, 0x96, 0x36, 0x44, 0xA8, 0x44,
/* 00005690 */ 0x96, 0x4B, 0x44, 0xD4, 0x1D, 0x44, 0x96, 0x37, 0x44, 0xD4, 0x1E, 0x44, 0x07, 0x01, 0x00, 0x5C,
/* 000056A0 */ 0x00, 0x09, 0xEE, 0x01, 0x44, 0x44, 0x1F, 0x00, 0x47, 0x3E, 0x44, 0xD4, 0x1F, 0x44, 0x07, 0x01,
/* 000056B0 */ 0x00, 0x5C, 0x00, 0x09, 0xEE, 0x01, 0x44, 0x44, 0x20, 0x00, 0x47, 0x3F, 0x44, 0xD4, 0x20, 0x44,
/* 000056C0 */ 0x07, 0x01, 0x00, 0x5C, 0x00, 0x09, 0xEE, 0x01, 0x44, 0x44, 0x21, 0x00, 0x47, 0x40, 0x44, 0x93,
/* 000056D0 */ 0x38, 0x44, 0x0E, 0x00, 0x14, 0x03, 0x00, 0x44, 0x28, 0x09, 0xFC, 0x00, 0x93, 0x1B, 0x44, 0x0A,
/* 000056E0 */ 0x00, 0x07, 0x04, 0x00, 0x5C, 0x00, 0x09, 0x6B, 0x43, 0x00, 0x00, 0x00, 0x45, 0x5C, 0x01, 0x45,
/* 000056F0 */ 0x5D, 0x02, 0x29, 0x22, 0x00, 0xCC, 0x04, 0x01, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x45, 0x00,
/* 00005700 */ 0x00, 0x00, 0x7B, 0x3E, 0x45, 0x30, 0x7B, 0x02, 0x45, 0x40, 0x7B, 0x2C, 0x45, 0x41, 0x7B, 0x02,
/* 00005710 */ 0x45, 0x42, 0x5C, 0x03, 0x45, 0xEE, 0x04, 0xFF, 0x44, 0x22, 0x00, 0x93, 0x1B, 0x44, 0x0A, 0x00,
/* 00005720 */ 0x07, 0x04, 0x00, 0x5C, 0x00, 0x09, 0x6B, 0x43, 0x00, 0x00, 0x00, 0x45, 0x5C, 0x01, 0x45, 0x5D,
/* 00005730 */ 0x02, 0x2E, 0x23, 0x00, 0xCC, 0x1C, 0x01, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x45, 0x00, 0x00,
/* 00005740 */ 0x00, 0x7B, 0x3F, 0x45, 0x30, 0x7B, 0x02, 0x45, 0x40, 0x7B, 0x2C, 0x45, 0x41, 0x7B, 0x02, 0x45,
/* 00005750 */ 0x42, 0x5C, 0x03, 0x45, 0xEE, 0x04, 0xFF, 0x44, 0x23, 0x00, 0x93, 0x1B, 0x44, 0x0A, 0x00, 0x07,
/* 00005760 */ 0x04, 0x00, 0x5C, 0x00, 0x09, 0x6B, 0x43, 0x00, 0x00, 0x00, 0x45, 0x5C, 0x01, 0x45, 0x5D, 0x02,
/* 00005770 */ 0x2F, 0x24, 0x00, 0xCC, 0x34, 0x01, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x45, 0x00, 0x00, 0x00,
/* 00005780 */ 0x7B, 0x40, 0x45, 0x30, 0x7B, 0x02, 0x45, 0x40, 0x7B, 0x2C, 0x45, 0x41, 0x7B, 0x02, 0x45, 0x42,
/* 00005790 */ 0x5C, 0x03, 0x45, 0xEE, 0x04, 0xFF, 0x44, 0x24, 0x00, 0x93, 0x1B, 0x44, 0x0A, 0x00, 0x07, 0x04,
/* 000057A0 */ 0x00, 0x5C, 0x00, 0x09, 0x6B, 0x43, 0x00, 0x00, 0x00, 0x45, 0x5C, 0x01, 0x45, 0x5D, 0x02, 0x13,
/* 000057B0 */ 0x25, 0x00, 0xCC, 0x4C, 0x01, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x45, 0x00, 0x00, 0x00, 0x7B,
/* 000057C0 */ 0x3D, 0x45, 0x30, 0x7B, 0x02, 0x45, 0x40, 0x7B, 0x2C, 0x45, 0x41, 0x7B, 0x02, 0x45, 0x42, 0x5C,
/* 000057D0 */ 0x03, 0x45, 0xEE, 0x04, 0xFF, 0x44, 0x25, 0x00, 0xA8, 0x00, 0x24, 0x00, 0x14, 0xFE, 0x64, 0x01,
/* 000057E0 */ 0x00, 0x4C, 0x01, 0x00, 0x00, 0x03, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xB4, 0x01, 0x00,
/* 000057F0 */ 0x00, 0xB3, 0x01, 0x00, 0x00, 0xB1, 0x01, 0x00, 0x00, 0xB2, 0x01, 0x00, 0x00, 0x34, 0x01, 0x00,
/* 00005800 */ 0x00, 0x03, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xB4, 0x01, 0x00, 0x00, 0xB3, 0x01, 0x00,
/* 00005810 */ 0x00, 0xB1, 0x01, 0x00, 0x00, 0xB2, 0x01, 0x00, 0x00, 0x1C, 0x01, 0x00, 0x00, 0x03, 0x04, 0x00,
/* 00005820 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0xB4, 0x01, 0x00, 0x00, 0xB3, 0x01, 0x00, 0x00, 0xB1, 0x01, 0x00,
/* 00005830 */ 0x00, 0xB2, 0x01, 0x00, 0x00, 0x04, 0x01, 0x00, 0x00, 0x03, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00,
/* 00005840 */ 0x00, 0xB4, 0x01, 0x00, 0x00, 0xB3, 0x01, 0x00, 0x00, 0xB1, 0x01, 0x00, 0x00, 0xB2, 0x01, 0x00,
/* 00005850 */ 0x00, 0xF4, 0x00, 0x00, 0x00, 0x03, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF5, 0x02, 0x00,
/* 00005860 */ 0x00, 0xFA, 0x02, 0x00, 0x00, 0xE4, 0x00, 0x00, 0x00, 0x03, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00,
/* 00005870 */ 0x00, 0xF5, 0x02, 0x00, 0x00, 0xFA, 0x02, 0x00, 0x00, 0xD4, 0x00, 0x00, 0x00, 0x03, 0x02, 0x00,
/* 00005880 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0xF0, 0x02, 0x00, 0x00, 0xF5, 0x02, 0x00, 0x00, 0xC4, 0x00, 0x00,
/* 00005890 */ 0x00, 0x03, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF0, 0x02, 0x00, 0x00, 0xF5, 0x02, 0x00,
/* 000058A0 */ 0x00, 0xB0, 0x00, 0x00, 0x00, 0x03, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF3, 0x02, 0x00,
/* 000058B0 */ 0x00, 0xF0, 0x02, 0x00, 0x00, 0xF5, 0x02, 0x00, 0x00, 0xA4, 0x00, 0x00, 0x00, 0x03, 0x01, 0x00,
/* 000058C0 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0xF0, 0x02, 0x00, 0x00, 0x98, 0x00, 0x00, 0x00, 0x03, 0x01, 0x00,
/* 000058D0 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0xED, 0x02, 0x00, 0x00, 0x8C, 0x00, 0x00, 0x00, 0x03, 0x01, 0x00,
/* 000058E0 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0xE9, 0x02, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x03, 0x01, 0x00,
/* 000058F0 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0xE9, 0x02, 0x00, 0x00, 0x54, 0x00, 0x00, 0x00, 0x03, 0x09, 0x00,
/* 00005900 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0xE8, 0x02, 0x00, 0x00, 0xEB, 0x02, 0x00, 0x00, 0xEC, 0x02, 0x00,
/* 00005910 */ 0x00, 0xEF, 0x02, 0x00, 0x00, 0xF2, 0x02, 0x00, 0x00, 0xF7, 0x02, 0x00, 0x00, 0xF8, 0x02, 0x00,
/* 00005920 */ 0x00, 0xF9, 0x02, 0x00, 0x00, 0xFB, 0x02, 0x00, 0x00, 0x48, 0x00, 0x00, 0x00, 0x03, 0x01, 0x00,
/* 00005930 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0xB4, 0x01, 0x00, 0x00, 0x3C, 0x00, 0x00, 0x00, 0x03, 0x01, 0x00,
/* 00005940 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0xB4, 0x01, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x03, 0x01, 0x00,
/* 00005950 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0xB4, 0x01, 0x00, 0x00, 0x24, 0x00, 0x00, 0x00, 0x03, 0x01, 0x00,
/* 00005960 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0xB4, 0x01, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x03, 0x01, 0x00,
/* 00005970 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x61, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x04, 0x00,
/* 00005980 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x17, 0x00, 0x00, 0x00, 0x1F, 0x00, 0x00, 0x00, 0x1F, 0x01, 0x00,
/* 00005990 */ 0x00, 0x25, 0x00, 0x00, 0x00, 0xDC, 0xFE, 0x03, 0x03, 0xFE, 0x04, 0x03, 0xF7, 0xFE, 0x04, 0x03,
/* 000059A0 */ 0xFE, 0x05, 0x03, 0xFE, 0x05, 0x03, 0xFE, 0xAA, 0x02, 0xFE, 0xAA, 0x02, 0xFE, 0x35, 0x02, 0xFE,
/* 000059B0 */ 0x36, 0x02, 0xFE, 0x38, 0x02, 0x84, 0xFE, 0x33, 0x01, 0xFE, 0x59, 0x01, 0xFE, 0x2E, 0x01, 0xFE,
/* 000059C0 */ 0x7B, 0x01, 0x95, 0xA8, 0xF7, 0xFE, 0x08, 0x02, 0xFE, 0x3A, 0x02, 0x17, 0xFE, 0x3B, 0x02, 0x1F,
/* 000059D0 */ 0xFE, 0x3C, 0x02, 0xFE, 0x1F, 0x01, 0xFE, 0x3D, 0x02, 0x25, 0xFE, 0x3F, 0x02, 0xFE, 0x40, 0x02,
/* 000059E0 */ 0xFE, 0x41, 0x02, 0xFE, 0x42, 0x02, 0xFE, 0x3E, 0x02, 0xFE, 0x46, 0x02, 0xFE, 0x47, 0x02, 0xFE,
/* 000059F0 */ 0x48, 0x02, 0xFE, 0x49, 0x02, 0xFE, 0x4A, 0x02, 0xFE, 0x4B, 0x02, 0xFE, 0x4C, 0x02, 0xFE, 0x4F,
/* 00005A00 */ 0x02, 0xFE, 0x50, 0x02, 0xFE, 0x51, 0x02, 0xFE, 0x52, 0x02, 0xFE, 0x53, 0x02, 0xFE, 0x34, 0x02,
/* 00005A10 */ 0xFE, 0x61, 0x02, 0xFE, 0xB4, 0x01, 0xFE, 0xE9, 0x02, 0xFE, 0xE8, 0x02, 0xFE, 0xEB, 0x02, 0xFE,
/* 00005A20 */ 0xED, 0x02, 0xFE, 0xEC, 0x02, 0xFE, 0xF0, 0x02, 0xFE, 0xEF, 0x02, 0xFE, 0xF3, 0x02, 0xFE, 0xF5,
/* 00005A30 */ 0x02, 0xFE, 0xF2, 0x02, 0xFE, 0xF7, 0x02, 0xFE, 0xF8, 0x02, 0xFE, 0xFA, 0x02, 0xFE, 0xF9, 0x02,
/* 00005A40 */ 0xFE, 0xFB, 0x02, 0xFE, 0xB3, 0x01, 0xFE, 0xB1, 0x01, 0xFE, 0xB2, 0x01, 0xDC, 0xFE, 0x06, 0x03,
/* 00005A50 */ 0xFE, 0x07, 0x03, 0xFE, 0x08, 0x03, 0xFE, 0x09, 0x03, 0xFE, 0x0A, 0x03, 0xFE, 0x0B, 0x03, 0xFE,
/* 00005A60 */ 0x0C, 0x03, 0xFE, 0x0D, 0x03, 0xFE, 0x0E, 0x03, 0xFE, 0x0F, 0x03, 0xFE, 0x10, 0x03, 0x84, 0xFE,
/* 00005A70 */ 0x33, 0x01, 0xFE, 0x59, 0x01, 0xFE, 0x2E, 0x01, 0xFE, 0x7B, 0x01, 0x95, 0xA8, 0xFE, 0x11, 0x03,
/* 00005A80 */ 0xF8, 0xFE, 0x12, 0x03, 0xFE, 0x13, 0x03, 0xFE, 0x14, 0x03, 0xFE, 0x15, 0x03, 0xFE, 0x16, 0x03,
/* 00005A90 */ 0xFE, 0x17, 0x03, 0xFE, 0x18, 0x03, 0xFE, 0x19, 0x03, 0xFE, 0x1A, 0x03, 0xFE, 0x1B, 0x03, 0xFE,
/* 00005AA0 */ 0x1C, 0x03, 0xFE, 0x1D, 0x03, 0xFE, 0x1E, 0x03, 0xFE, 0x1F, 0x03, 0xFE, 0x20, 0x03, 0xFE, 0x21,
/* 00005AB0 */ 0x03, 0xE1, 0xE4, 0xFE, 0x22, 0x03, 0xFE, 0x23, 0x03, 0xFE, 0x24, 0x03, 0xFE, 0x2A, 0x02, 0xFE,
/* 00005AC0 */ 0x29, 0x02, 0xFE, 0x25, 0x03, 0xFE, 0x26, 0x03, 0xFE, 0x27, 0x03, 0xFE, 0x28, 0x03, 0xFE, 0x29,
/* 00005AD0 */ 0x03, 0xFE, 0x2A, 0x03, 0xFE, 0x2B, 0x03, 0xFE, 0x79, 0x02, 0xFE, 0x2C, 0x03, 0xFE, 0x2D, 0x03,
/* 00005AE0 */ 0xFE, 0x2E, 0x03, 0xFE, 0x2F, 0x03, 0xFE, 0x30, 0x03, 0xFE, 0xD9, 0x02, 0xFE, 0x31, 0x03, 0xFE,
/* 00005AF0 */ 0x32, 0x03, 0xFE, 0x33, 0x03, 0xFE, 0x34, 0x03, 0xFE, 0x35, 0x03, 0xFE, 0x36, 0x03, 0xFE, 0x37,
/* 00005B00 */ 0x03, 0xFE, 0x38, 0x03, 0xFE, 0x39, 0x03, 0xFE, 0x3A, 0x03, 0xFE, 0x3B, 0x03, 0xFE, 0x3C, 0x03,
/* 00005B10 */ 0xFE, 0x3D, 0x03, 0xFE, 0x3E, 0x03, 0xFE, 0x3F, 0x03, 0xFE, 0x40, 0x03, 0xFE, 0x41, 0x03, 0xFE,
/* 00005B20 */ 0xC3, 0x01, 0x5A, 0x92, 0x00, 0x00, 0x00, 0x07, 0x00, 0xA7, 0x00, 0x09, 0x00, 0x22, 0x00, 0x13,
/* 00005B30 */ 0x00, 0x39, 0x00, 0x1F, 0x00, 0x3D, 0x00, 0x13, 0x00, 0x3A, 0x00, 0x1F, 0x00, 0xDA, 0x00, 0x14,
/* 00005B40 */ 0x00, 0x31, 0x00, 0x0C, 0x00, 0x48, 0x00, 0x03, 0x00, 0x38, 0x00, 0x0C, 0x00, 0x36, 0x00, 0x0C,
/* 00005B50 */ 0x00, 0x3A, 0x00, 0x0C, 0x00, 0x44, 0x00, 0x0C, 0x00, 0x25, 0x00, 0x0C, 0x00, 0x23, 0x00, 0x0C,
/* 00005B60 */ 0x00, 0x23, 0x00, 0x0C, 0x00, 0x23, 0x00, 0x0C, 0x00, 0x23, 0x00, 0x0C, 0x00, 0x1F, 0x00, 0x0C,
/* 00005B70 */ 0x00, 0x21, 0x00, 0x0C, 0x00, 0x1F, 0x00, 0x0C, 0x00, 0x2F, 0x00, 0x5D, 0x00, 0xCF, 0x00, 0x0C,
/* 00005B80 */ 0x00, 0x55, 0x00, 0x0C, 0x00, 0x51, 0x00, 0x0C, 0x00, 0x5F, 0x00, 0x0C, 0x00, 0x05, 0x01, 0x0C,
/* 00005B90 */ 0x00, 0x56, 0x00, 0x06, 0x00, 0x98, 0x00, 0x0C, 0x00, 0x4D, 0x00, 0x0C, 0x00, 0x4D, 0x00, 0x0C,
/* 00005BA0 */ 0x00, 0x47, 0x00, 0x0C, 0x00, 0x49, 0x00, 0x0C, 0x00, 0x4D, 0x00, 0x0C, 0x00, 0x4B, 0x00, 0x0C,
/* 00005BB0 */ 0x00, 0x3D, 0x00, 0x0C, 0x00, 0x4F, 0x00, 0x0C, 0x00, 0x57, 0x00, 0x0C, 0x00, 0x59, 0x00, 0x19,
/* 00005BC0 */ 0x00, 0x37, 0x00, 0x0C, 0x00, 0x3F, 0x00, 0x0C, 0x00, 0x3B, 0x00, 0x05, 0x00, 0x26, 0x00, 0x06,
/* 00005BD0 */ 0x00, 0xFA, 0x01, 0x06, 0x00, 0x19, 0x02, 0x06, 0x00, 0x9D, 0x01, 0x06, 0x00, 0x63, 0x01, 0x06,
/* 00005BE0 */ 0x00, 0xA0, 0x00, 0x06, 0x00, 0x74, 0x00, 0x06, 0x00, 0xC2, 0x04, 0x06, 0x00, 0xAA, 0x04, 0x06,
/* 00005BF0 */ 0x00, 0x4A, 0x04, 0x06, 0x00, 0xE9, 0x09, 0x06, 0x00, 0x00, 0x03, 0x05, 0x00, 0x2E, 0x00, 0x06,
/* 00005C00 */ 0x00, 0xAE, 0x03, 0x12, 0x00, 0xDE, 0x0A, 0x05, 0x00, 0x7A, 0x00, 0x05, 0x00, 0x39, 0x00, 0x05,
/* 00005C10 */ 0x00, 0x4D, 0x00, 0x05, 0x00, 0x01, 0x1D, 0x06, 0x00, 0xCD, 0x01, 0x06, 0x00, 0xED, 0x01, 0x06,
/* 00005C20 */ 0x00, 0x97, 0x03, 0x1E, 0x00, 0x3D, 0x00, 0x49, 0x00, 0x29, 0x01, 0x03, 0x00, 0x52, 0x00, 0x41,
/* 00005C30 */ 0x00, 0xA7, 0x01, 0x03, 0x00, 0x5A, 0x00, 0x41, 0x00, 0xB7, 0x01, 0x03, 0x00, 0x5E, 0x00, 0x41,
/* 00005C40 */ 0x00, 0xBF, 0x01, 0x03, 0x00, 0x42, 0x00, 0x41, 0x00, 0xB6, 0x02, 0x32, 0x00, 0x61, 0x00, 0x32,
/* 00005C50 */ 0x00, 0x65, 0x00, 0x32, 0x00, 0x67, 0x00, 0x2D, 0x00, 0x4E, 0x01, 0xDF, 0x01, 0x66, 0x05, 0x12,
/* 00005C60 */ 0x00, 0xDE, 0x03, 0x05, 0x00, 0x2C, 0x00, 0x06, 0x00, 0x73, 0x09, 0x12, 0x00, 0xBC, 0x31, 0x12,
/* 00005C70 */ 0x00, 0x0F, 0x3A, 0x12, 0x00, 0xC6, 0x6F, 0x0D, 0x00, 0x24, 0x00, 0x3F, 0x00, 0x97, 0x00, 0x3F,
/* 00005C80 */ 0x00, 0x97, 0x00, 0x3F, 0x00, 0x97, 0x00, 0x41, 0x00, 0x96, 0x00, 0x00, 0xC9, 0xE5, 0x00, 0x00,
/* 00005C90 */ 0xF7, 0xE4, 0x00, 0x00, 0x4E, 0xE4, 0x00, 0x00, 0x53, 0xE3, 0x00, 0x00, 0xC2, 0xE2, 0x00, 0x00,
/* 00005CA0 */ 0x5A, 0xE2, 0x00, 0x00, 0xF3, 0xE1, 0x00, 0x00, 0xDB, 0xDF, 0x00, 0x00, 0xF2, 0xDD, 0x00, 0x00,
/* 00005CB0 */ 0x98, 0xDC, 0x00, 0x00, 0x8B, 0xD8, 0x00, 0x00, 0x33, 0xD7, 0x00, 0x00, 0xB0, 0xD5, 0x00, 0x00,
/* 00005CC0 */ 0xF4, 0xD0, 0x00, 0x00, 0x13, 0xCF, 0x00, 0x00, 0xAF, 0xCD, 0x00, 0x00, 0x64, 0xCD, 0x00, 0x00,
/* 00005CD0 */ 0xAC, 0xC9, 0x00, 0x00, 0xE1, 0xC8, 0x00, 0x00, 0x0B, 0xC6, 0x00, 0x00, 0x98, 0xC3, 0x00, 0x00,
/* 00005CE0 */ 0x94, 0xC2, 0x00, 0x00, 0x93, 0xC1, 0x00, 0x00, 0xC3, 0xBF, 0x00, 0x00, 0x22, 0xBF, 0x00, 0x00,
/* 00005CF0 */ 0x7D, 0xBE, 0x00, 0x00, 0xD8, 0xBD, 0x00, 0x00, 0x6D, 0xBD, 0x00, 0x00, 0x56, 0xBB, 0x00, 0x00,
/* 00005D00 */ 0x07, 0xB8, 0x00, 0x00, 0x74, 0xA3, 0x00, 0x00, 0x16, 0x8D, 0x00, 0x00, 0x10, 0x5D, 0x00, 0x00,
/* 00005D10 */ 0x3F, 0x5D, 0x8C, 0xE0, 0xA9, 0xD6, 0x92, 0xFE, 0xD9, 0x04, 0x1A, 0xA0, 0x41, 0xD1, 0x00, 0x3E,
/* 00005D20 */ 0xFE, 0xEC, 0xF0, 0x0E, 0xFF, 0x00, 0x10, 0x01, 0x00, 0x01, 0x01, 0xFE, 0xEC, 0xF0, 0xFE, 0x72,
/* 00005D30 */ 0x6F, 0xFE, 0x72, 0x6F, 0x01, 0x13, 0x2F, 0x3B, 0x09, 0xDA, 0xDA, 0x01, 0x10, 0x01, 0x09, 0x11,
/* 00005D40 */ 0x11, 0x11, 0x11, 0x06, 0x02, 0x38, 0x39, 0x3A, 0x3B, 0x06, 0xFE, 0xFC, 0x02, 0x06, 0xFE, 0xE7,
/* 00005D50 */ 0x03, 0x06, 0xFE, 0xE8, 0x03, 0x05, 0xFE, 0xE9, 0x03, 0x06, 0xFE, 0xEA, 0x03, 0x05, 0xFE, 0xEB,
/* 00005D60 */ 0x03, 0x06, 0xFE, 0xEC, 0x03, 0x05, 0xFE, 0xED, 0x03, 0x06, 0xFE, 0xEE, 0x03, 0x05, 0xFE, 0xEF,
/* 00005D70 */ 0x03, 0x06, 0xFE, 0xF0, 0x03, 0x05, 0xFE, 0xF1, 0x03, 0x06, 0xFE, 0xF2, 0x03, 0x05, 0xFE, 0xF3,
/* 00005D80 */ 0x03, 0x06, 0xFE, 0xF4, 0x03, 0x05, 0xFE, 0xF5, 0x03, 0x06, 0xFE, 0xF6, 0x03, 0x05, 0xFE, 0xF7,
/* 00005D90 */ 0x03, 0x06, 0xFE, 0xF8, 0x03, 0x05, 0xFE, 0xF9, 0x03, 0x07, 0x05, 0xFE, 0xFA, 0x03, 0x08, 0x01,
/* 00005DA0 */ 0x00, 0x05, 0xFE, 0xFB, 0x03, 0x01, 0x01, 0x05, 0xFE, 0xFC, 0x03, 0x01, 0x02, 0x05, 0xFE, 0xFD,
/* 00005DB0 */ 0x03, 0x05, 0xFE, 0xFE, 0x03, 0x05, 0xFE, 0xFF, 0x03, 0x05, 0xFE, 0xE0, 0x03, 0x06, 0xFE, 0x9F,
/* 00005DC0 */ 0x03, 0x06, 0xFE, 0xE5, 0x02, 0x06, 0xFE, 0xFE, 0x02, 0x0C, 0x06, 0xFE, 0xFF, 0x02, 0x06, 0xFE,
/* 00005DD0 */ 0x00, 0x03, 0x06, 0xFE, 0xA0, 0x03, 0x0B, 0x06, 0xFE, 0xD7, 0x03, 0x06, 0xFE, 0xA3, 0x03, 0x05,
/* 00005DE0 */ 0xFE, 0xD8, 0x03, 0x06, 0xFE, 0xA1, 0x03, 0x06, 0xFE, 0xE6, 0x02, 0xFE, 0xE3, 0x03, 0xA8, 0x2F,
/* 00005DF0 */ 0xA8, 0x30, 0xA8, 0x31, 0xA8, 0x32, 0xA8, 0x33, 0xA8, 0x34, 0xA8, 0x35, 0xA8, 0x36, 0xA8, 0x37,
/* 00005E00 */ 0x8F, 0x01, 0x38, 0x3D, 0x00, 0x00, 0x14, 0x11, 0x00, 0x3D, 0x02, 0x09, 0x00, 0x00, 0x8F, 0x01,
/* 00005E10 */ 0x38, 0x3D, 0x00, 0x00, 0x14, 0x03, 0x00, 0x3D, 0x03, 0x09, 0xAC, 0x03, 0xDE, 0x00, 0x09, 0x01,
/* 00005E20 */ 0xB8, 0x3D, 0x00, 0x01, 0x50, 0x01, 0x00, 0x2F, 0x3D, 0x95, 0x00, 0x02, 0x2F, 0x01, 0x50, 0x01,
/* 00005E30 */ 0x01, 0x30, 0x3D, 0x95, 0x00, 0x03, 0x30, 0x01, 0x50, 0x01, 0x02, 0x31, 0x3D, 0x95, 0x00, 0x04,
/* 00005E40 */ 0x31, 0x01, 0x50, 0x01, 0x03, 0x32, 0x3D, 0x95, 0x00, 0x05, 0x32, 0x01, 0x50, 0x01, 0x04, 0x33,
/* 00005E50 */ 0x3D, 0x95, 0x00, 0x06, 0x33, 0x01, 0x50, 0x01, 0x05, 0x34, 0x3D, 0x95, 0x00, 0x07, 0x34, 0x01,
/* 00005E60 */ 0x50, 0x01, 0x06, 0x35, 0x3D, 0x95, 0x00, 0x08, 0x35, 0xCC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
/* 00005E70 */ 0x00, 0x00, 0x3D, 0x00, 0x00, 0x00, 0x7B, 0x05, 0x3D, 0x00, 0x7B, 0x07, 0x3D, 0x01, 0x7B, 0x09,
/* 00005E80 */ 0x3D, 0x02, 0x7B, 0x0B, 0x3D, 0x03, 0x7B, 0x0D, 0x3D, 0x04, 0x7B, 0x0F, 0x3D, 0x05, 0x7B, 0x11,
/* 00005E90 */ 0x3D, 0x06, 0x7B, 0x13, 0x3D, 0x07, 0x7B, 0x15, 0x3D, 0x08, 0x96, 0x02, 0x3D, 0x8F, 0x01, 0x09,
/* 00005EA0 */ 0x3E, 0x01, 0x00, 0x6D, 0x3D, 0x3E, 0x09, 0x07, 0x03, 0x00, 0x5C, 0x00, 0x3E, 0x8F, 0x01, 0x2A,
/* 00005EB0 */ 0x3F, 0x02, 0x00, 0x07, 0x03, 0x00, 0x5C, 0x00, 0x18, 0x5D, 0x01, 0x17, 0x01, 0x00, 0xB8, 0x41,
/* 00005EC0 */ 0x00, 0x01, 0x50, 0x01, 0x07, 0x40, 0x41, 0x5C, 0x02, 0x40, 0xEE, 0x03, 0x3F, 0x3F, 0x01, 0x00,
/* 00005ED0 */ 0x5C, 0x01, 0x3F, 0x5D, 0x02, 0x19, 0x00, 0x00, 0xF2, 0x03, 0xFF, 0x3D, 0x09, 0x00, 0x00, 0x00,
/* 00005EE0 */ 0x00, 0x00, 0x8F, 0x01, 0x09, 0x3E, 0x01, 0x00, 0x6D, 0x3D, 0x3E, 0x09, 0x07, 0x03, 0x00, 0x5C,
/* 00005EF0 */ 0x00, 0x3E, 0x8F, 0x01, 0x2A, 0x3F, 0x02, 0x00, 0x07, 0x03, 0x00, 0x5C, 0x00, 0x18, 0x5D, 0x01,
/* 00005F00 */ 0x1A, 0x03, 0x00, 0xB8, 0x41, 0x00, 0x01, 0x50, 0x01, 0x08, 0x40, 0x41, 0x5C, 0x02, 0x40, 0xEE,
/* 00005F10 */ 0x03, 0x3F, 0x3F, 0x03, 0x00, 0x5C, 0x01, 0x3F, 0x5D, 0x02, 0x1B, 0x02, 0x00, 0xF2, 0x03, 0xFF,
/* 00005F20 */ 0x3D, 0x09, 0x00, 0x00, 0x00, 0x02, 0x00, 0x8F, 0x01, 0x09, 0x3E, 0x01, 0x00, 0x6D, 0x3D, 0x3E,
/* 00005F30 */ 0x09, 0x07, 0x03, 0x00, 0x5C, 0x00, 0x3E, 0x8F, 0x01, 0x2A, 0x3F, 0x02, 0x00, 0x07, 0x03, 0x00,
/* 00005F40 */ 0x5C, 0x00, 0x18, 0x5D, 0x01, 0x1C, 0x05, 0x00, 0xB8, 0x41, 0x00, 0x01, 0x50, 0x01, 0x09, 0x40,
/* 00005F50 */ 0x41, 0x5C, 0x02, 0x40, 0xEE, 0x03, 0x3F, 0x3F, 0x05, 0x00, 0x5C, 0x01, 0x3F, 0x5D, 0x02, 0x1D,
/* 00005F60 */ 0x04, 0x00, 0xF2, 0x03, 0xFF, 0x3D, 0x09, 0x00, 0x00, 0x00, 0x04, 0x00, 0x8F, 0x01, 0x38, 0x3D,
/* 00005F70 */ 0x00, 0x00, 0x14, 0x03, 0x00, 0x3D, 0x02, 0x09, 0x4E, 0x02, 0xDE, 0x01, 0x04, 0x02, 0xB8, 0x3D,
/* 00005F80 */ 0x00, 0xB7, 0x01, 0x00, 0x00, 0x00, 0x3D, 0x3D, 0x01, 0x50, 0x01, 0x0A, 0x36, 0x3D, 0x95, 0x01,
/* 00005F90 */ 0x02, 0x36, 0x01, 0x50, 0x01, 0x0B, 0x37, 0x3D, 0x95, 0x01, 0x03, 0x37, 0x8F, 0x01, 0x2A, 0x3D,
/* 00005FA0 */ 0x02, 0x00, 0x07, 0x03, 0x00, 0x5C, 0x00, 0x18, 0x5D, 0x01, 0x1E, 0x06, 0x00, 0x91, 0x01, 0x02,
/* 00005FB0 */ 0x3E, 0x03, 0x00, 0x5C, 0x02, 0x3E, 0xEE, 0x03, 0xFF, 0x3D, 0x06, 0x00, 0x8F, 0x01, 0x2A, 0x3D,
/* 00005FC0 */ 0x02, 0x00, 0x07, 0x03, 0x00, 0x5C, 0x00, 0x18, 0x5D, 0x01, 0x1F, 0x07, 0x00, 0x91, 0x01, 0x03,
/* 00005FD0 */ 0x3E, 0x04, 0x00, 0x5C, 0x02, 0x3E, 0xEE, 0x03, 0xFF, 0x3D, 0x07, 0x00, 0x91, 0x01, 0x02, 0x3D,
/* 00005FE0 */ 0x03, 0x00, 0xCE, 0x3E, 0x02, 0x00, 0x00, 0xA1, 0x00, 0x20, 0x3E, 0xA1, 0x01, 0x21, 0x3E, 0x77,
/* 00005FF0 */ 0x3E, 0x3D, 0x0A, 0x8F, 0x01, 0x1B, 0x3D, 0x05, 0x00, 0x07, 0x04, 0x00, 0x5C, 0x00, 0x18, 0x91,
/* 00006000 */ 0x01, 0x02, 0x3E, 0x03, 0x00, 0x5C, 0x01, 0x3E, 0x5D, 0x02, 0x22, 0x08, 0x00, 0xCC, 0x2C, 0x00,
/* 00006010 */ 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x3E, 0x00, 0x00, 0x00, 0x91, 0x01, 0x02, 0x3F, 0x03, 0x00,
/* 00006020 */ 0x07, 0x01, 0x00, 0xC3, 0x01, 0x3F, 0x3F, 0x09, 0x00, 0x7B, 0x3F, 0x3E, 0x0B, 0x7B, 0x25, 0x3E,
/* 00006030 */ 0x0C, 0x7B, 0x25, 0x3E, 0x0D, 0x7B, 0x25, 0x3E, 0x0E, 0x5C, 0x03, 0x3E, 0xEE, 0x04, 0xFF, 0x3D,
/* 00006040 */ 0x08, 0x00, 0x8F, 0x01, 0x0A, 0x3D, 0x06, 0x00, 0x07, 0x03, 0x00, 0x5C, 0x00, 0x18, 0x91, 0x01,
/* 00006050 */ 0x02, 0x3E, 0x03, 0x00, 0x62, 0x3E, 0x3E, 0x0F, 0x5C, 0x01, 0x3E, 0x8F, 0x01, 0x0E, 0x3E, 0x07,
/* 00006060 */ 0x00, 0x62, 0x3E, 0x3E, 0x0F, 0x5C, 0x02, 0x3E, 0xEE, 0x03, 0xFF, 0x3D, 0x0A, 0x00, 0x8F, 0x01,
/* 00006070 */ 0x1B, 0x3D, 0x05, 0x00, 0x07, 0x04, 0x00, 0x5C, 0x00, 0x18, 0x91, 0x01, 0x02, 0x3E, 0x03, 0x00,
/* 00006080 */ 0x62, 0x3E, 0x3E, 0x0F, 0x5C, 0x01, 0x3E, 0x5D, 0x02, 0x28, 0x0B, 0x00, 0xCC, 0x44, 0x00, 0x00,
/* 00006090 */ 0x00, 0x02, 0x00, 0x00, 0x00, 0x3E, 0x00, 0x00, 0x00, 0x91, 0x01, 0x02, 0x3F, 0x03, 0x00, 0x7B,
/* 000060A0 */ 0x3F, 0x3E, 0x0B, 0x7B, 0x29, 0x3E, 0x0C, 0x7B, 0x25, 0x3E, 0x0D, 0x7B, 0x29, 0x3E, 0x0E, 0x5C,
/* 000060B0 */ 0x03, 0x3E, 0xEE, 0x04, 0xFF, 0x3D, 0x0B, 0x00, 0x8F, 0x01, 0x1B, 0x3D, 0x05, 0x00, 0x07, 0x04,
/* 000060C0 */ 0x00, 0x5C, 0x00, 0x18, 0x91, 0x01, 0x02, 0x3E, 0x03, 0x00, 0x62, 0x3E, 0x3E, 0x0F, 0x5C, 0x01,
/* 000060D0 */ 0x3E, 0x5D, 0x02, 0x2A, 0x0C, 0x00, 0xCC, 0x5C, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x3E,
/* 000060E0 */ 0x00, 0x00, 0x00, 0x8F, 0x01, 0x2A, 0x3F, 0x02, 0x00, 0x07, 0x03, 0x00, 0x5C, 0x00, 0x18, 0x5D,
/* 000060F0 */ 0x01, 0x2C, 0x0D, 0x00, 0xB8, 0x41, 0x00, 0xB7, 0x01, 0x00, 0x00, 0x00, 0x41, 0x41, 0x01, 0x50,
/* 00006100 */ 0x01, 0x0C, 0x40, 0x41, 0x5C, 0x02, 0x40, 0xEE, 0x03, 0x3F, 0x3F, 0x0D, 0x00, 0x7B, 0x3F, 0x3E,
/* 00006110 */ 0x10, 0x7B, 0x25, 0x3E, 0x0D, 0x7B, 0x29, 0x3E, 0x0E, 0x5C, 0x03, 0x3E, 0xEE, 0x04, 0xFF, 0x3D,
/* 00006120 */ 0x0C, 0x00, 0x8F, 0x01, 0x1B, 0x3D, 0x05, 0x00, 0x07, 0x04, 0x00, 0x5C, 0x00, 0x18, 0x91, 0x01,
/* 00006130 */ 0x02, 0x3E, 0x03, 0x00, 0x62, 0x3E, 0x3E, 0x0F, 0x5C, 0x01, 0x3E, 0x5D, 0x02, 0x2D, 0x0E, 0x00,
/* 00006140 */ 0xCC, 0x70, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x3E, 0x00, 0x00, 0x00, 0xB8, 0x40, 0x00,
/* 00006150 */ 0xB7, 0x01, 0x00, 0x00, 0x00, 0x40, 0x40, 0x01, 0x50, 0x01, 0x0D, 0x3F, 0x40, 0x7B, 0x3F, 0x3E,
/* 00006160 */ 0x0B, 0x01, 0x64, 0x01, 0x3F, 0x3E, 0x7B, 0x29, 0x3E, 0x0C, 0x7B, 0x25, 0x3E, 0x0D, 0x7B, 0x29,
/* 00006170 */ 0x3E, 0x0E, 0x5C, 0x03, 0x3E, 0xEE, 0x04, 0xFF, 0x3D, 0x0E, 0x00, 0x8F, 0x01, 0x1B, 0x3D, 0x05,
/* 00006180 */ 0x00, 0x07, 0x04, 0x00, 0x5C, 0x00, 0x18, 0x91, 0x01, 0x02, 0x3E, 0x03, 0x00, 0x5C, 0x01, 0x3E,
/* 00006190 */ 0x5D, 0x02, 0x2E, 0x0F, 0x00, 0xCC, 0x88, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x3E, 0x00,
/* 000061A0 */ 0x00, 0x00, 0x8F, 0x01, 0x49, 0x3F, 0x08, 0x00, 0x4B, 0x3F, 0x7B, 0x3F, 0x3E, 0x0B, 0x7B, 0x29,
/* 000061B0 */ 0x3E, 0x0C, 0x7B, 0x29, 0x3E, 0x0E, 0x5C, 0x03, 0x3E, 0xEE, 0x04, 0xFF, 0x3D, 0x0F, 0x00, 0x91,
/* 000061C0 */ 0x01, 0x02, 0x00, 0x03, 0x00, 0x09, 0x07, 0x00, 0xA8, 0x00, 0x09, 0x02, 0x00, 0xA8, 0x00, 0x24,
/* 000061D0 */ 0x00, 0x06, 0x9C, 0x00, 0x88, 0x00, 0x00, 0x00, 0x03, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
/* 000061E0 */ 0xB4, 0x01, 0x00, 0x00, 0xB3, 0x01, 0x00, 0x00, 0xB2, 0x01, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00,
/* 000061F0 */ 0x03, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xB4, 0x01, 0x00, 0x00, 0xB3, 0x01, 0x00, 0x00,
/* 00006200 */ 0xB1, 0x01, 0x00, 0x00, 0xB2, 0x01, 0x00, 0x00, 0x5C, 0x00, 0x00, 0x00, 0x03, 0x03, 0x00, 0x00,
/* 00006210 */ 0x00, 0x00, 0x00, 0x00, 0xB5, 0x01, 0x00, 0x00, 0xB1, 0x01, 0x00, 0x00, 0xB2, 0x01, 0x00, 0x00,
/* 00006220 */ 0x44, 0x00, 0x00, 0x00, 0x03, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xB4, 0x01, 0x00, 0x00,
/* 00006230 */ 0xB3, 0x01, 0x00, 0x00, 0xB1, 0x01, 0x00, 0x00, 0xB2, 0x01, 0x00, 0x00, 0x2C, 0x00, 0x00, 0x00,
/* 00006240 */ 0x03, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xB4, 0x01, 0x00, 0x00, 0xB3, 0x01, 0x00, 0x00,
/* 00006250 */ 0xB1, 0x01, 0x00, 0x00, 0xB2, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x09, 0x00, 0x00,
/* 00006260 */ 0x00, 0x00, 0x00, 0x00, 0xE8, 0x03, 0x00, 0x00, 0xEA, 0x03, 0x00, 0x00, 0xEC, 0x03, 0x00, 0x00,
/* 00006270 */ 0xEE, 0x03, 0x00, 0x00, 0xF0, 0x03, 0x00, 0x00, 0xF2, 0x03, 0x00, 0x00, 0xF4, 0x03, 0x00, 0x00,
/* 00006280 */ 0xF6, 0x03, 0x00, 0x00, 0xF8, 0x03, 0x00, 0x00, 0xFE, 0xE8, 0x03, 0xFE, 0xEA, 0x03, 0xFE, 0xEC,
/* 00006290 */ 0x03, 0xFE, 0xEE, 0x03, 0xFE, 0xF0, 0x03, 0xFE, 0xF2, 0x03, 0xFE, 0xF4, 0x03, 0xFE, 0xF6, 0x03,
/* 000062A0 */ 0xFE, 0xF8, 0x03, 0xFE, 0x32, 0x02, 0xFE, 0x94, 0x02, 0xFE, 0xB4, 0x01, 0xFE, 0xB3, 0x01, 0xFE,
/* 000062B0 */ 0xB1, 0x01, 0xFE, 0xB2, 0x01, 0xFE, 0x46, 0x01, 0xFE, 0xB5, 0x01, 0xFE, 0x00, 0x04, 0x02, 0x01,
/* 000062C0 */ 0x07, 0x00, 0xFE, 0x01, 0x04, 0x01, 0xFE, 0x02, 0x04, 0x02, 0xFE, 0x03, 0x04, 0x03, 0xFE, 0x04,
/* 000062D0 */ 0x04, 0x04, 0xFE, 0x05, 0x04, 0x05, 0xFE, 0x06, 0x04, 0x06, 0xFE, 0x07, 0x04, 0x02, 0x02, 0x00,
/* 000062E0 */ 0xFE, 0x1B, 0x02, 0x01, 0xFE, 0x1C, 0x02, 0xFE, 0x05, 0xF1, 0x12, 0x12, 0x00, 0x00, 0x00, 0x69,
/* 000062F0 */ 0x00, 0x02, 0x14, 0x34, 0x00, 0x7C, 0x37, 0x45, 0x00, 0x1E, 0x03, 0x45, 0x00, 0x28, 0x03, 0x45,
/* 00006300 */ 0x00, 0x28, 0x03, 0x30, 0x00, 0x94, 0x06, 0x20, 0x00, 0x27, 0x04, 0x20, 0x00, 0x56, 0x00, 0x17,
/* 00006310 */ 0x00, 0x4A, 0x00, 0x4F, 0x00, 0x9E, 0x00, 0x2C, 0x00, 0x4B, 0x00, 0x4A, 0x00, 0xA4, 0x00, 0x6A,
/* 00006320 */ 0x00, 0x31, 0x03, 0x59, 0x00, 0x0F, 0x09, 0x44, 0x00, 0xA1, 0x00, 0x09, 0x00, 0x8C, 0x00, 0x07,
/* 00006330 */ 0x00, 0x17, 0x00, 0x00, 0x0E, 0x89, 0x00, 0x00, 0x1C, 0x84, 0x00, 0x00, 0x9A, 0x83, 0x00, 0x00,
/* 00006340 */ 0xAC, 0x81, 0x00, 0x00, 0xF9, 0x7F, 0x00, 0x00, 0xDE, 0x7B, 0x00, 0x00, 0x34, 0x73, 0x00, 0x00,
/* 00006350 */ 0x2C, 0x71, 0x00, 0x00, 0x28, 0x6F, 0x00, 0x00, 0x24, 0x6D, 0x00, 0x00, 0xDD, 0x6A, 0x00, 0x00,
/* 00006360 */ 0xA6, 0x68, 0x00, 0x00, 0x9C, 0x67, 0x00, 0x00, 0x6C, 0x63, 0x00, 0x00, 0x3F, 0x5D, 0x84, 0xE0,
/* 00006370 */ 0x89, 0xC6, 0x12, 0xFE, 0xB0, 0x06, 0x1B, 0xA0, 0x41, 0xC3, 0x00, 0xFE, 0xA1, 0x03, 0x4D, 0xFF,
/* 00006380 */ 0x6A, 0x56, 0x01, 0x00, 0x01, 0xFF, 0x00, 0x10, 0x01, 0x00, 0x01, 0x01, 0xFF, 0x6A, 0x56, 0x01,
/* 00006390 */ 0x00, 0xFE, 0x4F, 0x08, 0xFE, 0x4F, 0x08, 0x03, 0x07, 0x15, 0x19, 0x09, 0x7A, 0x7A, 0x04, 0x08,
/* 000063A0 */ 0x09, 0x20, 0x20, 0x20, 0x20, 0x01, 0x16, 0x17, 0x18, 0x06, 0xFE, 0x85, 0x03, 0x05, 0xFE, 0x43,
/* 000063B0 */ 0x04, 0x06, 0xFE, 0x02, 0x03, 0x06, 0xFE, 0x48, 0x03, 0x06, 0xFE, 0x44, 0x04, 0x06, 0xFE, 0xCD,
/* 000063C0 */ 0x03, 0x06, 0xFE, 0x37, 0x04, 0x06, 0xFE, 0x3B, 0x04, 0x06, 0xFE, 0x38, 0x04, 0x06, 0xFE, 0x39,
/* 000063D0 */ 0x04, 0x06, 0xFE, 0x0C, 0x04, 0x06, 0xFE, 0x0D, 0x04, 0x06, 0xFE, 0x0E, 0x04, 0x06, 0xFE, 0x0F,
/* 000063E0 */ 0x04, 0x06, 0xFE, 0x10, 0x04, 0x06, 0xFE, 0x11, 0x04, 0x06, 0xFE, 0x3A, 0x04, 0x07, 0x08, 0xFE,
/* 000063F0 */ 0x0A, 0x02, 0x5B, 0x15, 0xB4, 0x15, 0x15, 0x2C, 0x19, 0x15, 0x15, 0x03, 0x00, 0x19, 0x02, 0x09,
/* 00006400 */ 0x24, 0x00, 0x8F, 0x04, 0x09, 0x1A, 0x00, 0x00, 0x6D, 0x19, 0x1A, 0x00, 0x07, 0x03, 0x00, 0x5C,
/* 00006410 */ 0x00, 0x1A, 0x5D, 0x01, 0x03, 0x00, 0x00, 0x5D, 0x02, 0x04, 0x00, 0x00, 0xF2, 0x03, 0xFF, 0x19,
/* 00006420 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x8F, 0x04, 0x09, 0x1A, 0x00, 0x00, 0x6D, 0x19, 0x1A, 0x01,
/* 00006430 */ 0x07, 0x02, 0x00, 0x5C, 0x00, 0x1A, 0x5C, 0x01, 0x15, 0xF2, 0x02, 0x19, 0x19, 0x01, 0x00, 0x00,
/* 00006440 */ 0x00, 0x01, 0x00, 0x96, 0x02, 0x19, 0x93, 0x02, 0x19, 0x01, 0x00, 0xA8, 0x1A, 0x14, 0x13, 0x00,
/* 00006450 */ 0x19, 0x1A, 0x09, 0x00, 0x00, 0x93, 0x02, 0x19, 0x01, 0x00, 0x62, 0x19, 0x19, 0x02, 0x0F, 0x27,
/* 00006460 */ 0x00, 0x19, 0x09, 0x00, 0x00, 0x8F, 0x04, 0x09, 0x1A, 0x00, 0x00, 0x6D, 0x19, 0x1A, 0x00, 0x07,
/* 00006470 */ 0x03, 0x00, 0x5C, 0x00, 0x1A, 0x5D, 0x01, 0x03, 0x02, 0x00, 0x5D, 0x02, 0x04, 0x02, 0x00, 0xF2,
/* 00006480 */ 0x03, 0xFF, 0x19, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x8F, 0x04, 0x0A, 0x19, 0x02, 0x00, 0x07,
/* 00006490 */ 0x03, 0x00, 0x5C, 0x00, 0x14, 0xCC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1A, 0x00,
/* 000064A0 */ 0x00, 0x00, 0x93, 0x02, 0x1B, 0x01, 0x00, 0x62, 0x1B, 0x1B, 0x03, 0x7B, 0x1B, 0x1A, 0x04, 0x93,
/* 000064B0 */ 0x02, 0x1B, 0x01, 0x00, 0x62, 0x1B, 0x1B, 0x05, 0x7B, 0x1B, 0x1A, 0x06, 0x93, 0x02, 0x1B, 0x01,
/* 000064C0 */ 0x00, 0x62, 0x1B, 0x1B, 0x07, 0x7B, 0x1B, 0x1A, 0x08, 0x93, 0x02, 0x1B, 0x01, 0x00, 0x62, 0x1B,
/* 000064D0 */ 0x1B, 0x09, 0x7B, 0x1B, 0x1A, 0x0A, 0x93, 0x02, 0x1B, 0x01, 0x00, 0x62, 0x1B, 0x1B, 0x0B, 0x7B,
/* 000064E0 */ 0x1B, 0x1A, 0x0C, 0x93, 0x02, 0x1B, 0x01, 0x00, 0x62, 0x1B, 0x1B, 0x0D, 0x7B, 0x1B, 0x1A, 0x0E,
/* 000064F0 */ 0x93, 0x02, 0x1B, 0x01, 0x00, 0x62, 0x1B, 0x1B, 0x0F, 0x7B, 0x1B, 0x1A, 0x10, 0x93, 0x02, 0x1B,
/* 00006500 */ 0x01, 0x00, 0x62, 0x1B, 0x1B, 0x11, 0x7B, 0x1B, 0x1A, 0x12, 0x93, 0x02, 0x1B, 0x01, 0x00, 0x62,
/* 00006510 */ 0x1B, 0x1B, 0x13, 0x7B, 0x1B, 0x1A, 0x14, 0x93, 0x02, 0x1B, 0x01, 0x00, 0x62, 0x1B, 0x1B, 0x15,
/* 00006520 */ 0x7B, 0x1B, 0x1A, 0x16, 0x93, 0x02, 0x1B, 0x01, 0x00, 0x62, 0x1B, 0x1B, 0x17, 0x7B, 0x1B, 0x1A,
/* 00006530 */ 0x18, 0x93, 0x02, 0x1B, 0x01, 0x00, 0x62, 0x1B, 0x1B, 0x19, 0x7B, 0x1B, 0x1A, 0x1A, 0x93, 0x02,
/* 00006540 */ 0x1B, 0x01, 0x00, 0x62, 0x1B, 0x1B, 0x1B, 0x7B, 0x1B, 0x1A, 0x1C, 0x93, 0x02, 0x1B, 0x01, 0x00,
/* 00006550 */ 0x62, 0x1B, 0x1B, 0x1D, 0x7B, 0x1B, 0x1A, 0x1E, 0x5C, 0x01, 0x1A, 0x5D, 0x02, 0x13, 0x03, 0x00,
/* 00006560 */ 0xEE, 0x03, 0x19, 0x19, 0x03, 0x00, 0x96, 0x03, 0x19, 0x8F, 0x04, 0x0A, 0x19, 0x02, 0x00, 0x07,
/* 00006570 */ 0x03, 0x00, 0x5C, 0x00, 0x14, 0xCB, 0x1A, 0x5C, 0x01, 0x1A, 0x5D, 0x02, 0x13, 0x04, 0x00, 0xEE,
/* 00006580 */ 0x03, 0x19, 0x19, 0x04, 0x00, 0x96, 0x04, 0x19, 0x8F, 0x04, 0x0C, 0x19, 0x03, 0x00, 0x07, 0x05,
/* 00006590 */ 0x00, 0x5C, 0x00, 0x14, 0x8F, 0x04, 0x1C, 0x1A, 0x04, 0x00, 0x5C, 0x01, 0x1A, 0x8F, 0x04, 0x18,
/* 000065A0 */ 0x1A, 0x05, 0x00, 0x07, 0x02, 0x00, 0x5C, 0x00, 0x14, 0x93, 0x03, 0x1B, 0x06, 0x00, 0x5C, 0x01,
/* 000065B0 */ 0x1B, 0xEE, 0x02, 0x1A, 0x1A, 0x06, 0x00, 0x5C, 0x02, 0x1A, 0xD4, 0x00, 0x1A, 0x5C, 0x03, 0x1A,
/* 000065C0 */ 0x93, 0x02, 0x1A, 0x01, 0x00, 0x5C, 0x04, 0x1A, 0xEE, 0x05, 0xFF, 0x19, 0x05, 0x00, 0x8F, 0x04,
/* 000065D0 */ 0x0A, 0x19, 0x02, 0x00, 0x07, 0x03, 0x00, 0x5C, 0x00, 0x14, 0x93, 0x04, 0x1A, 0x07, 0x00, 0x5C,
/* 000065E0 */ 0x01, 0x1A, 0x8F, 0x04, 0x0E, 0x1A, 0x08, 0x00, 0x62, 0x1A, 0x1A, 0x1F, 0x5C, 0x02, 0x1A, 0xEE,
/* 000065F0 */ 0x03, 0x00, 0x19, 0x07, 0x00, 0x09, 0x02, 0x00, 0xA8, 0x00, 0x24, 0x00, 0x01, 0x40, 0x00, 0x00,
/* 00006600 */ 0x00, 0x00, 0x00, 0x03, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1F, 0x02, 0x00, 0x00, 0x93,
/* 00006610 */ 0x02, 0x00, 0x00, 0x95, 0x02, 0x00, 0x00, 0x83, 0x02, 0x00, 0x00, 0x85, 0x02, 0x00, 0x00, 0x7B,
/* 00006620 */ 0x02, 0x00, 0x00, 0x82, 0x02, 0x00, 0x00, 0x7C, 0x02, 0x00, 0x00, 0x7D, 0x02, 0x00, 0x00, 0x7E,
/* 00006630 */ 0x02, 0x00, 0x00, 0x80, 0x02, 0x00, 0x00, 0x7F, 0x02, 0x00, 0x00, 0x81, 0x02, 0x00, 0x00, 0x84,
/* 00006640 */ 0x02, 0x00, 0x00, 0xFE, 0x67, 0x02, 0xFE, 0x33, 0x02, 0xFE, 0x6C, 0x02, 0xFE, 0x17, 0x02, 0xFE,
/* 00006650 */ 0x1F, 0x02, 0xFE, 0x92, 0x02, 0xFE, 0x93, 0x02, 0xFE, 0x12, 0x02, 0xFE, 0x95, 0x02, 0xFE, 0x8E,
/* 00006660 */ 0x02, 0xFE, 0x83, 0x02, 0xFE, 0x90, 0x02, 0xFE, 0x85, 0x02, 0xFE, 0x86, 0x02, 0xFE, 0x7B, 0x02,
/* 00006670 */ 0xFE, 0x8D, 0x02, 0xFE, 0x82, 0x02, 0xFE, 0x87, 0x02, 0xFE, 0x7C, 0x02, 0xFE, 0x88, 0x02, 0xFE,
/* 00006680 */ 0x7D, 0x02, 0xFE, 0x89, 0x02, 0xFE, 0x7E, 0x02, 0xFE, 0x8B, 0x02, 0xFE, 0x80, 0x02, 0xFE, 0x8A,
/* 00006690 */ 0x02, 0xFE, 0x7F, 0x02, 0xFE, 0x8C, 0x02, 0xFE, 0x81, 0x02, 0xFE, 0x8F, 0x02, 0xFE, 0x84, 0x02,
/* 000066A0 */ 0xFE, 0x46, 0x01, 0xFE, 0xE5, 0x03, 0xFE, 0x45, 0x04, 0xFE, 0xFB, 0x01, 0xFF, 0xA0, 0x56, 0x01,
/* 000066B0 */ 0x00, 0x0A, 0x05, 0x00, 0x00, 0x00, 0x0B, 0x00, 0x3D, 0x00, 0x24, 0x00, 0x92, 0x00, 0x20, 0x00,
/* 000066C0 */ 0x4C, 0x00, 0x1F, 0x00, 0x6C, 0x00, 0x24, 0x00, 0x92, 0x00, 0xE0, 0x00, 0xDE, 0x03, 0x1F, 0x00,
/* 000066D0 */ 0x3F, 0x00, 0x46, 0x00, 0x9D, 0x01, 0x2C, 0x00, 0x45, 0x00, 0x00, 0xDF, 0x66, 0x00, 0x00, 0xBF,
/* 000066E0 */ 0x5C, 0x87, 0x00, 0x00, 0xC4, 0x00, 0xFE, 0xC9, 0x06, 0x60, 0xA2, 0x41, 0xD1, 0x00, 0x4E, 0xFF,
/* 000066F0 */ 0x1E, 0x5D, 0x01, 0x00, 0xFF, 0x00, 0x10, 0x01, 0x00, 0x02, 0x02, 0xFF, 0x1E, 0x5D, 0x01, 0x00,
/* 00006700 */ 0xFE, 0x2B, 0x01, 0xFE, 0x2B, 0x01, 0x41, 0x04, 0x05, 0x07, 0x05, 0x1A, 0x1A, 0x05, 0x02, 0x01,
/* 00006710 */ 0x01, 0x05, 0x06, 0x06, 0xFE, 0x37, 0x04, 0x05, 0xFE, 0xE6, 0x03, 0x08, 0x6C, 0x8F, 0x01, 0x03,
/* 00006720 */ 0x07, 0x00, 0x00, 0x98, 0x07, 0x07, 0x05, 0x00, 0x00, 0xA8, 0x08, 0x15, 0x0B, 0x00, 0x07, 0x08,
/* 00006730 */ 0x09, 0x00, 0x00, 0x14, 0x03, 0x00, 0x05, 0x02, 0x09, 0x4A, 0x00, 0x8F, 0x05, 0x0C, 0x07, 0x01,
/* 00006740 */ 0x00, 0x07, 0x04, 0x00, 0x5C, 0x00, 0x04, 0x8F, 0x05, 0x19, 0x08, 0x02, 0x00, 0x5C, 0x01, 0x08,
/* 00006750 */ 0x8F, 0x01, 0x02, 0x08, 0x03, 0x00, 0x5C, 0x02, 0x08, 0x2F, 0x08, 0x03, 0x05, 0x5C, 0x03, 0x08,
/* 00006760 */ 0xEE, 0x04, 0x07, 0x07, 0x00, 0x00, 0x0F, 0x03, 0x00, 0x07, 0x09, 0x18, 0x00, 0x8F, 0x01, 0x04,
/* 00006770 */ 0x07, 0x04, 0x00, 0x8F, 0x01, 0x03, 0x08, 0x00, 0x00, 0x98, 0x08, 0x08, 0x05, 0x01, 0x00, 0x9D,
/* 00006780 */ 0x08, 0x07, 0x05, 0x00, 0x00, 0xA8, 0x00, 0x24, 0x00, 0xFF, 0x4D, 0x5D, 0x01, 0x00, 0x03, 0x00,
/* 00006790 */ 0x00, 0x00, 0x00, 0x50, 0x00, 0xA7, 0x00, 0x1A, 0x00, 0x54, 0x00, 0x00, 0xBF, 0x5C, 0x84, 0xE0,
/* 000067A0 */ 0x01, 0xC4, 0x00, 0xFE, 0xA1, 0x06, 0x39, 0xA0, 0x41, 0xD1, 0x00, 0x4C, 0xFF, 0x4E, 0x53, 0x01,
/* 000067B0 */ 0x00, 0xFF, 0x00, 0x10, 0x01, 0x00, 0x01, 0x01, 0xFF, 0x4E, 0x53, 0x01, 0x00, 0xFE, 0x6B, 0x02,
/* 000067C0 */ 0xFE, 0x6B, 0x02, 0x01, 0x05, 0x05, 0x08, 0x04, 0x25, 0x24, 0x04, 0x03, 0x01, 0x04, 0x04, 0x04,
/* 000067D0 */ 0x04, 0x07, 0x06, 0xFE, 0x85, 0x03, 0x05, 0xFE, 0x42, 0x04, 0x06, 0xFE, 0x02, 0x03, 0x98, 0x5B,
/* 000067E0 */ 0x05, 0xB4, 0x05, 0x05, 0x2C, 0x08, 0x05, 0x15, 0x03, 0x00, 0x08, 0x02, 0x09, 0x24, 0x00, 0x8F,
/* 000067F0 */ 0x04, 0x09, 0x09, 0x00, 0x00, 0x6D, 0x08, 0x09, 0x00, 0x07, 0x03, 0x00, 0x5C, 0x00, 0x09, 0x5D,
/* 00006800 */ 0x01, 0x03, 0x00, 0x00, 0x5D, 0x02, 0x04, 0x00, 0x00, 0xF2, 0x03, 0xFF, 0x08, 0x00, 0x00, 0x00,
/* 00006810 */ 0x00, 0x00, 0x00, 0x8F, 0x04, 0x09, 0x09, 0x00, 0x00, 0x6D, 0x08, 0x09, 0x01, 0x07, 0x02, 0x00,
/* 00006820 */ 0x5C, 0x00, 0x09, 0x5C, 0x01, 0x05, 0xF2, 0x02, 0x08, 0x08, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
/* 00006830 */ 0x47, 0x06, 0x08, 0xA8, 0x08, 0x14, 0x0E, 0x00, 0x06, 0x08, 0x09, 0x00, 0x00, 0x62, 0x08, 0x06,
/* 00006840 */ 0x02, 0x0F, 0x27, 0x00, 0x08, 0x09, 0x00, 0x00, 0x8F, 0x04, 0x09, 0x09, 0x00, 0x00, 0x6D, 0x08,
/* 00006850 */ 0x09, 0x00, 0x07, 0x03, 0x00, 0x5C, 0x00, 0x09, 0x5D, 0x01, 0x03, 0x02, 0x00, 0x5D, 0x02, 0x04,
/* 00006860 */ 0x02, 0x00, 0xF2, 0x03, 0xFF, 0x08, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x62, 0x00, 0x06, 0x03,
/* 00006870 */ 0x09, 0x02, 0x00, 0xA8, 0x00, 0x24, 0x00, 0xFE, 0x67, 0x02, 0xFE, 0x33, 0x02, 0xFE, 0x6C, 0x02,
/* 00006880 */ 0xFE, 0x78, 0x02, 0xFF, 0x75, 0x53, 0x01, 0x00, 0x07, 0x05, 0x00, 0x00, 0x00, 0x0B, 0x00, 0x3D,
/* 00006890 */ 0x00, 0x24, 0x00, 0x8B, 0x00, 0x20, 0x00, 0x4C, 0x00, 0x15, 0x00, 0x6C, 0x00, 0x24, 0x00, 0x8B,
/* 000068A0 */ 0x00, 0x09, 0x00, 0x38, 0x00, 0x00, 0xBF, 0x5C, 0x85, 0xE0, 0x01, 0xC4, 0x00, 0xFE, 0x86, 0x06,
/* 000068B0 */ 0x10, 0xA1, 0x41, 0xE1, 0x00, 0xFE, 0xD7, 0x03, 0x4B, 0xFF, 0xD2, 0x4C, 0x01, 0x00, 0xFF, 0x00,
/* 000068C0 */ 0x10, 0x01, 0x00, 0x01, 0x01, 0xFF, 0xD2, 0x4C, 0x01, 0x00, 0xFE, 0xC8, 0x03, 0xFE, 0xC8, 0x03,
/* 000068D0 */ 0x03, 0x0A, 0x09, 0x0D, 0x0A, 0x61, 0x60, 0x04, 0x03, 0x0C, 0x06, 0x07, 0x07, 0x07, 0x07, 0x0C,
/* 000068E0 */ 0x07, 0x06, 0xFE, 0x85, 0x03, 0x05, 0xFE, 0x42, 0x04, 0x06, 0xFE, 0x02, 0x03, 0x01, 0x01, 0x01,
/* 000068F0 */ 0x00, 0x08, 0xFE, 0xA2, 0x01, 0xAE, 0x0B, 0x5B, 0x09, 0xB4, 0x09, 0x09, 0x2C, 0x0D, 0x09, 0x15,
/* 00006900 */ 0x03, 0x00, 0x0D, 0x03, 0x09, 0x24, 0x00, 0x8F, 0x04, 0x09, 0x0E, 0x00, 0x00, 0x6D, 0x0D, 0x0E,
/* 00006910 */ 0x00, 0x07, 0x03, 0x00, 0x5C, 0x00, 0x0E, 0x5D, 0x01, 0x04, 0x00, 0x00, 0x5D, 0x02, 0x05, 0x00,
/* 00006920 */ 0x00, 0xF2, 0x03, 0xFF, 0x0D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x8F, 0x04, 0x09, 0x0E, 0x00,
/* 00006930 */ 0x00, 0x6D, 0x0D, 0x0E, 0x01, 0x07, 0x02, 0x00, 0x5C, 0x00, 0x0E, 0x5C, 0x01, 0x09, 0xF2, 0x02,
/* 00006940 */ 0x0D, 0x0D, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x47, 0x0A, 0x0D, 0xA8, 0x0D, 0x14, 0x0E, 0x00,
/* 00006950 */ 0x0A, 0x0D, 0x09, 0x00, 0x00, 0x62, 0x0D, 0x0A, 0x02, 0x0F, 0x27, 0x00, 0x0D, 0x09, 0x00, 0x00,
/* 00006960 */ 0x8F, 0x04, 0x09, 0x0E, 0x00, 0x00, 0x6D, 0x0D, 0x0E, 0x00, 0x07, 0x03, 0x00, 0x5C, 0x00, 0x0E,
/* 00006970 */ 0x5D, 0x01, 0x04, 0x02, 0x00, 0x5D, 0x02, 0x05, 0x02, 0x00, 0xF2, 0x03, 0xFF, 0x0D, 0x00, 0x00,
/* 00006980 */ 0x00, 0x00, 0x02, 0x00, 0x62, 0x0D, 0x0B, 0x03, 0x10, 0x03, 0x00, 0x0D, 0x06, 0x09, 0xB9, 0x00,
/* 00006990 */ 0x8F, 0x04, 0x27, 0x0D, 0x01, 0x00, 0x07, 0x02, 0x00, 0x5C, 0x00, 0x08, 0x98, 0x0E, 0x0B, 0x07,
/* 000069A0 */ 0x00, 0x00, 0x5C, 0x01, 0x0E, 0xEE, 0x02, 0x0D, 0x0D, 0x03, 0x00, 0x0F, 0x25, 0x00, 0x0D, 0x09,
/* 000069B0 */ 0x00, 0x00, 0x8F, 0x04, 0x26, 0x0D, 0x02, 0x00, 0x07, 0x02, 0x00, 0x5C, 0x00, 0x08, 0x98, 0x0E,
/* 000069C0 */ 0x0B, 0x07, 0x01, 0x00, 0x5C, 0x01, 0x0E, 0xEE, 0x02, 0x0D, 0x0D, 0x04, 0x00, 0x0F, 0x1D, 0x00,
/* 000069D0 */ 0x0D, 0x09, 0x00, 0x00, 0x8F, 0x04, 0x09, 0x0E, 0x00, 0x00, 0x6D, 0x0D, 0x0E, 0x04, 0x07, 0x01,
/* 000069E0 */ 0x00, 0x5C, 0x00, 0x0E, 0xF2, 0x01, 0xFF, 0x0D, 0x04, 0x00, 0x00, 0x00, 0x05, 0x00, 0x8F, 0x04,
/* 000069F0 */ 0x11, 0x0D, 0x03, 0x00, 0x07, 0x02, 0x00, 0x5C, 0x00, 0x08, 0x8F, 0x04, 0x09, 0x0F, 0x00, 0x00,
/* 00006A00 */ 0x6D, 0x0E, 0x0F, 0x05, 0x07, 0x03, 0x00, 0x5C, 0x00, 0x0F, 0x8F, 0x04, 0x31, 0x11, 0x04, 0x00,
/* 00006A10 */ 0x6D, 0x10, 0x11, 0x06, 0x07, 0x02, 0x00, 0x5C, 0x00, 0x11, 0x98, 0x12, 0x0B, 0x07, 0x02, 0x00,
/* 00006A20 */ 0x5C, 0x01, 0x12, 0xF2, 0x02, 0x10, 0x10, 0x06, 0x00, 0x00, 0x00, 0x08, 0x00, 0x5C, 0x01, 0x10,
/* 00006A30 */ 0x5C, 0x02, 0x0A, 0xF2, 0x03, 0x0E, 0x0E, 0x05, 0x00, 0x00, 0x00, 0x07, 0x00, 0x5C, 0x01, 0x0E,
/* 00006A40 */ 0xEE, 0x02, 0x00, 0x0D, 0x06, 0x00, 0x09, 0x4C, 0x00, 0x8F, 0x04, 0x11, 0x0D, 0x03, 0x00, 0x07,
/* 00006A50 */ 0x02, 0x00, 0x5C, 0x00, 0x08, 0x8F, 0x04, 0x09, 0x0F, 0x00, 0x00, 0x6D, 0x0E, 0x0F, 0x05, 0x07,
/* 00006A60 */ 0x03, 0x00, 0x5C, 0x00, 0x0F, 0x8F, 0x04, 0x22, 0x10, 0x05, 0x00, 0x07, 0x01, 0x00, 0x5C, 0x00,
/* 00006A70 */ 0x08, 0xEE, 0x01, 0x10, 0x10, 0x0B, 0x00, 0x5C, 0x01, 0x10, 0x5C, 0x02, 0x0A, 0xF2, 0x03, 0x0E,
/* 00006A80 */ 0x0E, 0x05, 0x00, 0x00, 0x00, 0x0A, 0x00, 0x5C, 0x01, 0x0E, 0xEE, 0x02, 0x00, 0x0D, 0x09, 0x00,
/* 00006A90 */ 0x09, 0x02, 0x00, 0xA8, 0x00, 0x24, 0x00, 0xFE, 0x67, 0x02, 0xFE, 0x33, 0x02, 0xFE, 0x6C, 0x02,
/* 00006AA0 */ 0xF1, 0xFE, 0x59, 0x02, 0xFE, 0x31, 0x02, 0xFE, 0x5C, 0x02, 0xFF, 0xFB, 0x4C, 0x01, 0x00, 0x0B,
/* 00006AB0 */ 0x07, 0x00, 0x00, 0x00, 0x0B, 0x00, 0x39, 0x00, 0x24, 0x00, 0x81, 0x00, 0x20, 0x00, 0x48, 0x00,
/* 00006AC0 */ 0x15, 0x00, 0x68, 0x00, 0x24, 0x00, 0x83, 0x00, 0x0C, 0x00, 0x36, 0x00, 0x44, 0x00, 0x53, 0x00,
/* 00006AD0 */ 0x1A, 0x00, 0x51, 0x00, 0x5B, 0x00, 0x85, 0x00, 0x4C, 0x00, 0x52, 0x00, 0x00, 0xBF, 0x5C, 0x85,
/* 00006AE0 */ 0xE0, 0x01, 0xC4, 0x00, 0xFE, 0x63, 0x06, 0x10, 0xA1, 0x41, 0xE1, 0x00, 0xFE, 0x02, 0x03, 0x4A,
/* 00006AF0 */ 0xFF, 0x1D, 0x46, 0x01, 0x00, 0xFF, 0x00, 0x10, 0x01, 0x00, 0x01, 0x01, 0xFF, 0x1D, 0x46, 0x01,
/* 00006B00 */ 0x00, 0xFE, 0x56, 0x06, 0xFE, 0x56, 0x06, 0x03, 0x0A, 0x08, 0x0F, 0x05, 0x67, 0x5E, 0x04, 0x02,
/* 00006B10 */ 0x09, 0x09, 0x08, 0x07, 0x08, 0x08, 0x0E, 0x07, 0x01, 0x01, 0x01, 0x00, 0x01, 0x02, 0x08, 0x06,
/* 00006B20 */ 0xFE, 0x02, 0x03, 0xFE, 0x93, 0x01, 0xAE, 0x0A, 0x5B, 0x0B, 0xB4, 0x0B, 0x0B, 0xA8, 0x0F, 0x47,
/* 00006B30 */ 0x08, 0x0F, 0xA8, 0x0F, 0x47, 0x09, 0x0F, 0x62, 0x0F, 0x0A, 0x00, 0x10, 0x03, 0x00, 0x0F, 0x03,
/* 00006B40 */ 0x09, 0x09, 0x00, 0x98, 0x0F, 0x0A, 0x04, 0x00, 0x00, 0x47, 0x08, 0x0F, 0x62, 0x0F, 0x0A, 0x00,
/* 00006B50 */ 0x10, 0x03, 0x00, 0x0F, 0x05, 0x09, 0x09, 0x00, 0x98, 0x0F, 0x0A, 0x03, 0x01, 0x00, 0x47, 0x09,
/* 00006B60 */ 0x0F, 0x6B, 0x07, 0x00, 0x00, 0x00, 0x0F, 0x14, 0x0D, 0x00, 0x0B, 0x0F, 0x09, 0x00, 0x00, 0xA8,
/* 00006B70 */ 0x0F, 0x14, 0x03, 0x00, 0x0B, 0x0F, 0x09, 0x1A, 0x00, 0x8F, 0x01, 0x02, 0x0F, 0x00, 0x00, 0x4B,
/* 00006B80 */ 0x0F, 0x07, 0x03, 0x00, 0x5C, 0x01, 0x08, 0x5C, 0x02, 0x09, 0xC3, 0x03, 0x00, 0x0F, 0x00, 0x00,
/* 00006B90 */ 0x09, 0x24, 0x01, 0x8F, 0x04, 0x31, 0x10, 0x01, 0x00, 0x6D, 0x0F, 0x10, 0x01, 0x07, 0x02, 0x00,
/* 00006BA0 */ 0x5C, 0x00, 0x10, 0x5C, 0x01, 0x0B, 0xF2, 0x02, 0x0F, 0x0F, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
/* 00006BB0 */ 0x47, 0x0C, 0x0F, 0x8F, 0x04, 0x17, 0x0F, 0x02, 0x00, 0x07, 0x02, 0x00, 0x5C, 0x00, 0x06, 0x5C,
/* 00006BC0 */ 0x01, 0x0C, 0xEE, 0x02, 0x0F, 0x0F, 0x02, 0x00, 0x0F, 0x22, 0x00, 0x0F, 0x09, 0x00, 0x00, 0x8F,
/* 00006BD0 */ 0x04, 0x09, 0x10, 0x03, 0x00, 0x6D, 0x0F, 0x10, 0x02, 0x07, 0x02, 0x00, 0x5C, 0x00, 0x10, 0x5D,
/* 00006BE0 */ 0x01, 0x07, 0x03, 0x00, 0xF2, 0x02, 0xFF, 0x0F, 0x02, 0x00, 0x00, 0x00, 0x03, 0x00, 0x8F, 0x04,
/* 00006BF0 */ 0x09, 0x10, 0x03, 0x00, 0x6D, 0x0F, 0x10, 0x03, 0x07, 0x02, 0x00, 0x5C, 0x00, 0x10, 0x5C, 0x01,
/* 00006C00 */ 0x0C, 0xF2, 0x02, 0x0F, 0x0F, 0x03, 0x00, 0x00, 0x00, 0x04, 0x00, 0x47, 0x0D, 0x0F, 0xA8, 0x0F,
/* 00006C10 */ 0x14, 0x03, 0x00, 0x0D, 0x0F, 0x09, 0x3F, 0x00, 0x8F, 0x04, 0x0A, 0x0F, 0x04, 0x00, 0x07, 0x03,
/* 00006C20 */ 0x00, 0x5C, 0x00, 0x06, 0xCB, 0x10, 0x5C, 0x01, 0x10, 0x5D, 0x02, 0x02, 0x05, 0x00, 0xEE, 0x03,
/* 00006C30 */ 0x0F, 0x0F, 0x05, 0x00, 0x47, 0x0D, 0x0F, 0x8F, 0x04, 0x09, 0x10, 0x03, 0x00, 0x6D, 0x0F, 0x10,
/* 00006C40 */ 0x04, 0x07, 0x03, 0x00, 0x5C, 0x00, 0x10, 0x5C, 0x01, 0x0C, 0x5C, 0x02, 0x0D, 0xF2, 0x03, 0xFF,
/* 00006C50 */ 0x0F, 0x04, 0x00, 0x00, 0x00, 0x06, 0x00, 0x8F, 0x02, 0x08, 0x0F, 0x05, 0x00, 0x4B, 0x0F, 0x07,
/* 00006C60 */ 0x04, 0x00, 0x5C, 0x00, 0x06, 0x5C, 0x01, 0x0D, 0x5C, 0x02, 0x08, 0x5C, 0x03, 0x09, 0xEE, 0x04,
/* 00006C70 */ 0xFF, 0x0F, 0x07, 0x00, 0x47, 0x0F, 0x0D, 0x8F, 0x04, 0x0C, 0x10, 0x06, 0x00, 0x07, 0x04, 0x00,
/* 00006C80 */ 0x5C, 0x00, 0x06, 0x8F, 0x04, 0x20, 0x11, 0x07, 0x00, 0x5C, 0x01, 0x11, 0x8F, 0x01, 0x03, 0x11,
/* 00006C90 */ 0x08, 0x00, 0x4B, 0x11, 0x5C, 0x02, 0x11, 0x5C, 0x03, 0x0C, 0xEE, 0x04, 0x10, 0x10, 0x08, 0x00,
/* 00006CA0 */ 0x77, 0x10, 0x0F, 0x05, 0x62, 0x0F, 0x0D, 0x06, 0x82, 0x0F, 0x0F, 0x29, 0x01, 0xFA, 0x0F, 0x47,
/* 00006CB0 */ 0x00, 0x0C, 0x09, 0x02, 0x00, 0xA8, 0x00, 0x24, 0x00, 0xF1, 0xFE, 0x51, 0x03, 0xFE, 0x66, 0x02,
/* 00006CC0 */ 0xFE, 0x33, 0x02, 0xFE, 0x34, 0x02, 0xFE, 0x78, 0x02, 0xFE, 0x78, 0x02, 0xDC, 0xFF, 0xA0, 0x47,
/* 00006CD0 */ 0x01, 0x00, 0x14, 0x07, 0x00, 0x00, 0x00, 0x05, 0x00, 0x2E, 0x00, 0x05, 0x00, 0x2E, 0x00, 0x0C,
/* 00006CE0 */ 0x00, 0x1B, 0x00, 0x09, 0x00, 0x2D, 0x00, 0x0C, 0x00, 0x1B, 0x00, 0x09, 0x00, 0x2F, 0x00, 0x18,
/* 00006CF0 */ 0x00, 0x44, 0x00, 0x1A, 0x00, 0x5B, 0x00, 0x20, 0x00, 0x38, 0x00, 0x1C, 0x00, 0x39, 0x00, 0x1F,
/* 00006D00 */ 0x00, 0xA1, 0x00, 0x20, 0x00, 0x49, 0x00, 0x0A, 0x00, 0x3B, 0x00, 0x1F, 0x00, 0x40, 0x00, 0x20,
/* 00006D10 */ 0x00, 0x5B, 0x00, 0x1D, 0x00, 0x51, 0x00, 0x30, 0x00, 0x67, 0x00, 0x0B, 0x00, 0x3F, 0x00, 0x08,
/* 00006D20 */ 0x00, 0x1D, 0x00, 0x00, 0xBF, 0x5C, 0x85, 0xE0, 0x03, 0xC4, 0x00, 0xFE, 0x55, 0x06, 0x64, 0xA0,
/* 00006D30 */ 0x41, 0xF1, 0x00, 0x49, 0xFF, 0x21, 0x43, 0x01, 0x00, 0xFF, 0x00, 0x10, 0x01, 0x00, 0x01, 0x01,
/* 00006D40 */ 0xFF, 0x21, 0x43, 0x01, 0x00, 0xFE, 0xBA, 0x02, 0xFE, 0xBA, 0x02, 0x03, 0x0A, 0x0B, 0x10, 0x0A,
/* 00006D50 */ 0x5D, 0x5A, 0x03, 0x02, 0x0B, 0x0B, 0x03, 0x03, 0x03, 0x03, 0x01, 0x0F, 0x07, 0x06, 0xFE, 0x85,
/* 00006D60 */ 0x03, 0x05, 0xFE, 0xFC, 0x03, 0x06, 0xFE, 0xE7, 0x03, 0x08, 0x05, 0xFE, 0x41, 0x04, 0x01, 0x00,
/* 00006D70 */ 0x01, 0x01, 0x05, 0xFE, 0x0A, 0x04, 0xFE, 0x7B, 0x01, 0xAE, 0x0E, 0x5B, 0x0B, 0xB4, 0x0B, 0x0B,
/* 00006D80 */ 0x2C, 0x10, 0x0B, 0x15, 0x15, 0x00, 0x10, 0x03, 0x09, 0x00, 0x00, 0x8F, 0x03, 0x12, 0x10, 0x00,
/* 00006D90 */ 0x00, 0xE1, 0x10, 0x0B, 0x10, 0x00, 0x0F, 0x27, 0x00, 0x10, 0x09, 0x00, 0x00, 0x8F, 0x03, 0x09,
/* 00006DA0 */ 0x11, 0x01, 0x00, 0x6D, 0x10, 0x11, 0x00, 0x07, 0x03, 0x00, 0x5C, 0x00, 0x11, 0x5D, 0x01, 0x04,
/* 00006DB0 */ 0x00, 0x00, 0x5D, 0x02, 0x05, 0x00, 0x00, 0xF2, 0x03, 0xFF, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00,
/* 00006DC0 */ 0x00, 0x8F, 0x03, 0x0C, 0x10, 0x02, 0x00, 0x07, 0x03, 0x00, 0x5C, 0x00, 0x06, 0x8F, 0x03, 0x21,
/* 00006DD0 */ 0x11, 0x03, 0x00, 0x5C, 0x01, 0x11, 0x8F, 0x03, 0x12, 0x11, 0x00, 0x00, 0x07, 0x02, 0x00, 0x5C,
/* 00006DE0 */ 0x01, 0x0B, 0xC3, 0x02, 0x11, 0x11, 0x02, 0x00, 0x5C, 0x02, 0x11, 0xEE, 0x03, 0x10, 0x10, 0x01,
/* 00006DF0 */ 0x00, 0x47, 0x0C, 0x10, 0x8F, 0x03, 0x27, 0x10, 0x04, 0x00, 0x07, 0x02, 0x00, 0x5C, 0x00, 0x06,
/* 00006E00 */ 0x5C, 0x01, 0x0C, 0xEE, 0x02, 0x10, 0x10, 0x03, 0x00, 0x0F, 0x1F, 0x00, 0x10, 0x09, 0x00, 0x00,
/* 00006E10 */ 0x8F, 0x03, 0x26, 0x10, 0x05, 0x00, 0x07, 0x02, 0x00, 0x5C, 0x00, 0x06, 0x5C, 0x01, 0x0C, 0xEE,
/* 00006E20 */ 0x02, 0x10, 0x10, 0x04, 0x00, 0x0F, 0x09, 0x00, 0x10, 0x09, 0x00, 0x00, 0x47, 0x00, 0x07, 0x09,
/* 00006E30 */ 0xC0, 0x00, 0x8F, 0x03, 0x0A, 0x10, 0x06, 0x00, 0x07, 0x03, 0x00, 0x5C, 0x00, 0x06, 0xCB, 0x11,
/* 00006E40 */ 0x5C, 0x01, 0x11, 0x5D, 0x02, 0x02, 0x05, 0x00, 0xEE, 0x03, 0x10, 0x10, 0x05, 0x00, 0x47, 0x0D,
/* 00006E50 */ 0x10, 0x8F, 0x01, 0x08, 0x10, 0x07, 0x00, 0x4B, 0x10, 0x07, 0x04, 0x00, 0x5C, 0x00, 0x06, 0x5C,
/* 00006E60 */ 0x01, 0x0D, 0x98, 0x11, 0x0E, 0x08, 0x00, 0x00, 0x5C, 0x02, 0x11, 0x8F, 0x01, 0x02, 0x11, 0x08,
/* 00006E70 */ 0x00, 0x4B, 0x11, 0x07, 0x04, 0x00, 0x5C, 0x00, 0x06, 0x98, 0x12, 0x0E, 0x09, 0x01, 0x00, 0x5C,
/* 00006E80 */ 0x01, 0x12, 0x5D, 0x02, 0x0A, 0x07, 0x00, 0x5D, 0x03, 0x0A, 0x07, 0x00, 0xEE, 0x04, 0x11, 0x11,
/* 00006E90 */ 0x07, 0x00, 0x5C, 0x03, 0x11, 0xEE, 0x04, 0xFF, 0x10, 0x06, 0x00, 0x8F, 0x03, 0x11, 0x10, 0x09,
/* 00006EA0 */ 0x00, 0x07, 0x02, 0x00, 0x5C, 0x00, 0x06, 0x8F, 0x03, 0x09, 0x12, 0x01, 0x00, 0x6D, 0x11, 0x12,
/* 00006EB0 */ 0x01, 0x07, 0x03, 0x00, 0x5C, 0x00, 0x12, 0x8F, 0x03, 0x31, 0x14, 0x0A, 0x00, 0x6D, 0x13, 0x14,
/* 00006EC0 */ 0x02, 0x07, 0x02, 0x00, 0x5C, 0x00, 0x14, 0x5C, 0x01, 0x0B, 0xF2, 0x02, 0x13, 0x13, 0x02, 0x00,
/* 00006ED0 */ 0x00, 0x00, 0x0A, 0x00, 0x5C, 0x01, 0x13, 0x5C, 0x02, 0x0D, 0xF2, 0x03, 0x11, 0x11, 0x01, 0x00,
/* 00006EE0 */ 0x00, 0x00, 0x09, 0x00, 0x5C, 0x01, 0x11, 0xEE, 0x02, 0x00, 0x10, 0x08, 0x00, 0x09, 0x02, 0x00,
/* 00006EF0 */ 0xA8, 0x00, 0x24, 0x00, 0xFE, 0x67, 0x02, 0xFE, 0x31, 0x02, 0xFE, 0x5C, 0x02, 0xFF, 0x40, 0x43,
/* 00006F00 */ 0x01, 0x00, 0x09, 0x07, 0x00, 0x00, 0x00, 0x1D, 0x00, 0x50, 0x00, 0x24, 0x00, 0x71, 0x00, 0x33,
/* 00006F10 */ 0x00, 0x54, 0x00, 0x38, 0x00, 0x3D, 0x00, 0x06, 0x00, 0x3B, 0x00, 0x1F, 0x00, 0x3B, 0x00, 0x4A,
/* 00006F20 */ 0x00, 0x77, 0x00, 0x57, 0x00, 0x5B, 0x00, 0x00, 0xBF, 0x5C, 0x85, 0xE0, 0x03, 0xC4, 0x00, 0xFE,
/* 00006F30 */ 0x48, 0x06, 0x64, 0xA0, 0x41, 0xF1, 0x00, 0x48, 0xFF, 0xF9, 0x3F, 0x01, 0x00, 0xFF, 0x00, 0x10,
/* 00006F40 */ 0x01, 0x00, 0x01, 0x01, 0xFF, 0xF9, 0x3F, 0x01, 0x00, 0xFE, 0xBA, 0x02, 0xFE, 0xBA, 0x02, 0x03,
/* 00006F50 */ 0x0A, 0x0B, 0x10, 0x0A, 0x5D, 0x5A, 0x03, 0x02, 0x0B, 0x0B, 0x03, 0x03, 0x03, 0x03, 0x01, 0x0F,
/* 00006F60 */ 0x07, 0x06, 0xFE, 0x85, 0x03, 0x05, 0xFE, 0xFB, 0x03, 0x06, 0xFE, 0xE7, 0x03, 0x08, 0x05, 0xFE,
/* 00006F70 */ 0x41, 0x04, 0x01, 0x00, 0x01, 0x01, 0x06, 0xFE, 0x08, 0x04, 0xFE, 0x7B, 0x01, 0xAE, 0x0E, 0x5B,
/* 00006F80 */ 0x0B, 0xB4, 0x0B, 0x0B, 0x2C, 0x10, 0x0B, 0x15, 0x15, 0x00, 0x10, 0x03, 0x09, 0x00, 0x00, 0x8F,
/* 00006F90 */ 0x03, 0x12, 0x10, 0x00, 0x00, 0xE1, 0x10, 0x0B, 0x10, 0x00, 0x0F, 0x27, 0x00, 0x10, 0x09, 0x00,
/* 00006FA0 */ 0x00, 0x8F, 0x03, 0x09, 0x11, 0x01, 0x00, 0x6D, 0x10, 0x11, 0x00, 0x07, 0x03, 0x00, 0x5C, 0x00,
/* 00006FB0 */ 0x11, 0x5D, 0x01, 0x04, 0x00, 0x00, 0x5D, 0x02, 0x05, 0x00, 0x00, 0xF2, 0x03, 0xFF, 0x10, 0x00,
/* 00006FC0 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x8F, 0x03, 0x0C, 0x10, 0x02, 0x00, 0x07, 0x03, 0x00, 0x5C, 0x00,
/* 00006FD0 */ 0x06, 0x8F, 0x03, 0x21, 0x11, 0x03, 0x00, 0x5C, 0x01, 0x11, 0x8F, 0x03, 0x12, 0x11, 0x00, 0x00,
/* 00006FE0 */ 0x07, 0x02, 0x00, 0x5C, 0x01, 0x0B, 0xC3, 0x02, 0x11, 0x11, 0x02, 0x00, 0x5C, 0x02, 0x11, 0xEE,
/* 00006FF0 */ 0x03, 0x10, 0x10, 0x01, 0x00, 0x47, 0x0C, 0x10, 0x8F, 0x03, 0x27, 0x10, 0x04, 0x00, 0x07, 0x02,
/* 00007000 */ 0x00, 0x5C, 0x00, 0x06, 0x5C, 0x01, 0x0C, 0xEE, 0x02, 0x10, 0x10, 0x03, 0x00, 0x0F, 0x1F, 0x00,
/* 00007010 */ 0x10, 0x09, 0x00, 0x00, 0x8F, 0x03, 0x26, 0x10, 0x05, 0x00, 0x07, 0x02, 0x00, 0x5C, 0x00, 0x06,
/* 00007020 */ 0x5C, 0x01, 0x0C, 0xEE, 0x02, 0x10, 0x10, 0x04, 0x00, 0x0F, 0x09, 0x00, 0x10, 0x09, 0x00, 0x00,
/* 00007030 */ 0x47, 0x00, 0x07, 0x09, 0xC0, 0x00, 0x8F, 0x03, 0x0A, 0x10, 0x06, 0x00, 0x07, 0x03, 0x00, 0x5C,
/* 00007040 */ 0x00, 0x06, 0xCB, 0x11, 0x5C, 0x01, 0x11, 0x5D, 0x02, 0x02, 0x05, 0x00, 0xEE, 0x03, 0x10, 0x10,
/* 00007050 */ 0x05, 0x00, 0x47, 0x0D, 0x10, 0x8F, 0x01, 0x08, 0x10, 0x07, 0x00, 0x4B, 0x10, 0x07, 0x04, 0x00,
/* 00007060 */ 0x5C, 0x00, 0x06, 0x5C, 0x01, 0x0D, 0x98, 0x11, 0x0E, 0x08, 0x00, 0x00, 0x5C, 0x02, 0x11, 0x8F,
/* 00007070 */ 0x01, 0x02, 0x11, 0x08, 0x00, 0x4B, 0x11, 0x07, 0x04, 0x00, 0x5C, 0x00, 0x06, 0x98, 0x12, 0x0E,
/* 00007080 */ 0x09, 0x01, 0x00, 0x5C, 0x01, 0x12, 0x5D, 0x02, 0x0A, 0x07, 0x00, 0x5D, 0x03, 0x0A, 0x07, 0x00,
/* 00007090 */ 0xEE, 0x04, 0x11, 0x11, 0x07, 0x00, 0x5C, 0x03, 0x11, 0xEE, 0x04, 0xFF, 0x10, 0x06, 0x00, 0x8F,
/* 000070A0 */ 0x03, 0x11, 0x10, 0x09, 0x00, 0x07, 0x02, 0x00, 0x5C, 0x00, 0x06, 0x8F, 0x03, 0x09, 0x12, 0x01,
/* 000070B0 */ 0x00, 0x6D, 0x11, 0x12, 0x01, 0x07, 0x03, 0x00, 0x5C, 0x00, 0x12, 0x8F, 0x03, 0x31, 0x14, 0x0A,
/* 000070C0 */ 0x00, 0x6D, 0x13, 0x14, 0x02, 0x07, 0x02, 0x00, 0x5C, 0x00, 0x14, 0x5C, 0x01, 0x0B, 0xF2, 0x02,
/* 000070D0 */ 0x13, 0x13, 0x02, 0x00, 0x00, 0x00, 0x0A, 0x00, 0x5C, 0x01, 0x13, 0x5C, 0x02, 0x0D, 0xF2, 0x03,
/* 000070E0 */ 0x11, 0x11, 0x01, 0x00, 0x00, 0x00, 0x09, 0x00, 0x5C, 0x01, 0x11, 0xEE, 0x02, 0x00, 0x10, 0x08,
/* 000070F0 */ 0x00, 0x09, 0x02, 0x00, 0xA8, 0x00, 0x24, 0x00, 0xFE, 0x67, 0x02, 0xFE, 0x31, 0x02, 0xFE, 0x5C,
/* 00007100 */ 0x02, 0xFF, 0x18, 0x40, 0x01, 0x00, 0x09, 0x07, 0x00, 0x00, 0x00, 0x1D, 0x00, 0x50, 0x00, 0x24,
/* 00007110 */ 0x00, 0x71, 0x00, 0x33, 0x00, 0x54, 0x00, 0x38, 0x00, 0x3D, 0x00, 0x06, 0x00, 0x3B, 0x00, 0x1F,
/* 00007120 */ 0x00, 0x3B, 0x00, 0x4A, 0x00, 0x77, 0x00, 0x57, 0x00, 0x5B, 0x00, 0x00, 0xBF, 0x5C, 0x85, 0xE0,
/* 00007130 */ 0x03, 0xC4, 0x00, 0xFE, 0x3B, 0x06, 0x60, 0xA0, 0x41, 0xF1, 0x00, 0x47, 0xFF, 0xD7, 0x3C, 0x01,
/* 00007140 */ 0x00, 0xFF, 0x00, 0x10, 0x01, 0x00, 0x01, 0x01, 0xFF, 0xD7, 0x3C, 0x01, 0x00, 0xFE, 0xB4, 0x02,
/* 00007150 */ 0xFE, 0xB4, 0x02, 0x03, 0x0A, 0x0C, 0x11, 0x0A, 0x5D, 0x5A, 0x03, 0x02, 0x0B, 0x0B, 0x03, 0x03,
/* 00007160 */ 0x03, 0x03, 0x01, 0x10, 0x07, 0x06, 0xFE, 0x85, 0x03, 0x05, 0xFE, 0xFA, 0x03, 0x06, 0xFE, 0xE7,
/* 00007170 */ 0x03, 0x08, 0x05, 0xFE, 0x41, 0x04, 0x01, 0x00, 0x01, 0x01, 0x05, 0xFE, 0x09, 0x04, 0x06, 0xFE,
/* 00007180 */ 0x0B, 0x04, 0xFE, 0x7B, 0x01, 0xAE, 0x0F, 0x5B, 0x0C, 0xB4, 0x0C, 0x0C, 0x2C, 0x11, 0x0C, 0x15,
/* 00007190 */ 0x15, 0x00, 0x11, 0x03, 0x09, 0x00, 0x00, 0x8F, 0x03, 0x12, 0x11, 0x00, 0x00, 0xE1, 0x11, 0x0C,
/* 000071A0 */ 0x11, 0x00, 0x0F, 0x27, 0x00, 0x11, 0x09, 0x00, 0x00, 0x8F, 0x03, 0x09, 0x12, 0x01, 0x00, 0x6D,
/* 000071B0 */ 0x11, 0x12, 0x00, 0x07, 0x03, 0x00, 0x5C, 0x00, 0x12, 0x5D, 0x01, 0x04, 0x00, 0x00, 0x5D, 0x02,
/* 000071C0 */ 0x05, 0x00, 0x00, 0xF2, 0x03, 0xFF, 0x11, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x8F, 0x03, 0x0C,
/* 000071D0 */ 0x11, 0x02, 0x00, 0x07, 0x03, 0x00, 0x5C, 0x00, 0x06, 0x8F, 0x03, 0x21, 0x12, 0x03, 0x00, 0x5C,
/* 000071E0 */ 0x01, 0x12, 0x8F, 0x03, 0x12, 0x12, 0x00, 0x00, 0x07, 0x02, 0x00, 0x5C, 0x01, 0x0C, 0xC3, 0x02,
/* 000071F0 */ 0x12, 0x12, 0x02, 0x00, 0x5C, 0x02, 0x12, 0xEE, 0x03, 0x11, 0x11, 0x01, 0x00, 0x47, 0x0D, 0x11,
/* 00007200 */ 0x8F, 0x03, 0x27, 0x11, 0x04, 0x00, 0x07, 0x02, 0x00, 0x5C, 0x00, 0x06, 0x5C, 0x01, 0x0D, 0xEE,
/* 00007210 */ 0x02, 0x11, 0x11, 0x03, 0x00, 0x0F, 0x1F, 0x00, 0x11, 0x09, 0x00, 0x00, 0x8F, 0x03, 0x26, 0x11,
/* 00007220 */ 0x05, 0x00, 0x07, 0x02, 0x00, 0x5C, 0x00, 0x06, 0x5C, 0x01, 0x0D, 0xEE, 0x02, 0x11, 0x11, 0x04,
/* 00007230 */ 0x00, 0x0F, 0x09, 0x00, 0x11, 0x09, 0x00, 0x00, 0x47, 0x00, 0x07, 0x09, 0xC0, 0x00, 0x8F, 0x03,
/* 00007240 */ 0x0A, 0x11, 0x06, 0x00, 0x07, 0x03, 0x00, 0x5C, 0x00, 0x06, 0xCB, 0x12, 0x5C, 0x01, 0x12, 0x5D,
/* 00007250 */ 0x02, 0x02, 0x05, 0x00, 0xEE, 0x03, 0x11, 0x11, 0x05, 0x00, 0x47, 0x0E, 0x11, 0x8F, 0x01, 0x08,
/* 00007260 */ 0x11, 0x07, 0x00, 0x4B, 0x11, 0x07, 0x04, 0x00, 0x5C, 0x00, 0x06, 0x5C, 0x01, 0x0E, 0x98, 0x12,
/* 00007270 */ 0x0F, 0x08, 0x00, 0x00, 0x5C, 0x02, 0x12, 0x8F, 0x01, 0x02, 0x12, 0x08, 0x00, 0x4B, 0x12, 0x07,
/* 00007280 */ 0x04, 0x00, 0x5C, 0x00, 0x06, 0x98, 0x13, 0x0F, 0x09, 0x01, 0x00, 0x5C, 0x01, 0x13, 0x5D, 0x02,
/* 00007290 */ 0x0A, 0x07, 0x00, 0x5D, 0x03, 0x0B, 0x07, 0x00, 0xEE, 0x04, 0x12, 0x12, 0x07, 0x00, 0x5C, 0x03,
/* 000072A0 */ 0x12, 0xEE, 0x04, 0xFF, 0x11, 0x06, 0x00, 0x8F, 0x03, 0x11, 0x11, 0x09, 0x00, 0x07, 0x02, 0x00,
/* 000072B0 */ 0x5C, 0x00, 0x06, 0x8F, 0x03, 0x09, 0x13, 0x01, 0x00, 0x6D, 0x12, 0x13, 0x01, 0x07, 0x03, 0x00,
/* 000072C0 */ 0x5C, 0x00, 0x13, 0x8F, 0x03, 0x31, 0x15, 0x0A, 0x00, 0x6D, 0x14, 0x15, 0x02, 0x07, 0x02, 0x00,
/* 000072D0 */ 0x5C, 0x00, 0x15, 0x5C, 0x01, 0x0C, 0xF2, 0x02, 0x14, 0x14, 0x02, 0x00, 0x00, 0x00, 0x0A, 0x00,
/* 000072E0 */ 0x5C, 0x01, 0x14, 0x5C, 0x02, 0x0E, 0xF2, 0x03, 0x12, 0x12, 0x01, 0x00, 0x00, 0x00, 0x09, 0x00,
/* 000072F0 */ 0x5C, 0x01, 0x12, 0xEE, 0x02, 0x00, 0x11, 0x08, 0x00, 0x09, 0x02, 0x00, 0xA8, 0x00, 0x24, 0x00,
/* 00007300 */ 0xFE, 0x67, 0x02, 0xFE, 0x31, 0x02, 0xFE, 0x5C, 0x02, 0xFF, 0xF6, 0x3C, 0x01, 0x00, 0x09, 0x07,
/* 00007310 */ 0x00, 0x00, 0x00, 0x1D, 0x00, 0x50, 0x00, 0x24, 0x00, 0x6D, 0x00, 0x33, 0x00, 0x54, 0x00, 0x38,
/* 00007320 */ 0x00, 0x3D, 0x00, 0x06, 0x00, 0x3B, 0x00, 0x1F, 0x00, 0x3B, 0x00, 0x4A, 0x00, 0x75, 0x00, 0x57,
/* 00007330 */ 0x00, 0x5B, 0x00, 0x00, 0xBF, 0x5C, 0xC9, 0xE0, 0x29, 0xD4, 0x10, 0xFE, 0xB6, 0x05, 0x0C, 0xB3,
/* 00007340 */ 0x41, 0xC1, 0x00, 0xFE, 0x07, 0x04, 0x46, 0xFF, 0x87, 0x20, 0x01, 0x00, 0xFF, 0x00, 0x10, 0x01,
/* 00007350 */ 0x00, 0x04, 0x04, 0xFF, 0x87, 0x20, 0x01, 0x00, 0xFE, 0xEC, 0x1B, 0xFE, 0xEC, 0x1B, 0x45, 0x1C,
/* 00007360 */ 0x29, 0x41, 0x07, 0xFE, 0xAA, 0x01, 0xFE, 0x8A, 0x01, 0x03, 0x01, 0x0C, 0x22, 0x0F, 0x2A, 0x2A,
/* 00007370 */ 0x2A, 0x2A, 0x01, 0x01, 0x40, 0x41, 0x06, 0xFE, 0x85, 0x03, 0x06, 0xFE, 0xA6, 0x03, 0x08, 0x06,
/* 00007380 */ 0xFE, 0x02, 0x03, 0x0B, 0x05, 0xFE, 0x09, 0x04, 0x06, 0xFE, 0x08, 0x04, 0x06, 0xFE, 0x8D, 0x03,
/* 00007390 */ 0x06, 0xFE, 0x58, 0x03, 0x05, 0xFE, 0x4F, 0x03, 0x05, 0xFE, 0x8C, 0x03, 0x06, 0xFE, 0x37, 0x04,
/* 000073A0 */ 0x06, 0xFE, 0x38, 0x04, 0x05, 0xFE, 0x12, 0x04, 0x05, 0xFE, 0x13, 0x04, 0x05, 0xFE, 0x15, 0x04,
/* 000073B0 */ 0x06, 0xFE, 0x39, 0x04, 0x06, 0xFE, 0x0C, 0x04, 0x05, 0xFE, 0x17, 0x04, 0x06, 0xFE, 0xB4, 0x03,
/* 000073C0 */ 0x06, 0xFE, 0x0D, 0x04, 0x06, 0xFE, 0x0E, 0x04, 0x06, 0xFE, 0x0F, 0x04, 0x06, 0xFE, 0x10, 0x04,
/* 000073D0 */ 0x06, 0xFE, 0x11, 0x04, 0x06, 0xFE, 0x3A, 0x04, 0x06, 0xFE, 0x3B, 0x04, 0x06, 0xFE, 0x57, 0x03,
/* 000073E0 */ 0x05, 0xFE, 0x3C, 0x04, 0x05, 0xFE, 0x3D, 0x04, 0x05, 0xFE, 0x3E, 0x04, 0x05, 0xFE, 0x3F, 0x04,
/* 000073F0 */ 0x07, 0x05, 0xFE, 0xE0, 0x03, 0x05, 0xFE, 0xFF, 0x03, 0x0C, 0x05, 0xFE, 0x40, 0x04, 0x06, 0xFE,
/* 00007400 */ 0x0B, 0x04, 0x01, 0x00, 0xFE, 0x23, 0x06, 0xA8, 0x3F, 0x2C, 0x42, 0x29, 0x0D, 0x03, 0x00, 0x42,
/* 00007410 */ 0x02, 0x09, 0x16, 0x00, 0x8F, 0x03, 0x09, 0x43, 0x00, 0x00, 0x6D, 0x42, 0x43, 0x00, 0x07, 0x01,
/* 00007420 */ 0x00, 0x5C, 0x00, 0x43, 0xF6, 0x01, 0xFF, 0x42, 0x00, 0x00, 0x8F, 0x03, 0x0C, 0x42, 0x01, 0x00,
/* 00007430 */ 0x07, 0x04, 0x00, 0x5C, 0x00, 0x04, 0x8F, 0x03, 0x19, 0x43, 0x02, 0x00, 0x5C, 0x01, 0x43, 0x5C,
/* 00007440 */ 0x02, 0x29, 0x5C, 0x03, 0x03, 0xF6, 0x04, 0x42, 0x42, 0x01, 0x00, 0x0F, 0x03, 0x00, 0x42, 0x09,
/* 00007450 */ 0x27, 0x00, 0x62, 0x42, 0x29, 0x01, 0x0F, 0x03, 0x00, 0x42, 0x09, 0x1C, 0x00, 0x8F, 0x03, 0x09,
/* 00007460 */ 0x43, 0x00, 0x00, 0x6D, 0x42, 0x43, 0x02, 0x07, 0x03, 0x00, 0x5C, 0x00, 0x43, 0x5C, 0x01, 0x05,
/* 00007470 */ 0x5C, 0x02, 0x05, 0xF6, 0x03, 0xFF, 0x42, 0x02, 0x00, 0x77, 0x06, 0x29, 0x03, 0x8F, 0x01, 0x02,
/* 00007480 */ 0x42, 0x03, 0x00, 0x4B, 0x42, 0x07, 0x04, 0x00, 0x5C, 0x00, 0x04, 0x5C, 0x01, 0x2B, 0x5C, 0x02,
/* 00007490 */ 0x07, 0x5C, 0x03, 0x08, 0xF6, 0x04, 0x42, 0x42, 0x03, 0x00, 0x47, 0x2B, 0x42, 0x8F, 0x03, 0x02,
/* 000074A0 */ 0x42, 0x04, 0x00, 0x07, 0x06, 0x00, 0x5C, 0x00, 0x04, 0x5C, 0x01, 0x2B, 0x5C, 0x02, 0x09, 0x5C,
/* 000074B0 */ 0x03, 0x0A, 0xCE, 0x43, 0x02, 0x00, 0x00, 0xA1, 0x00, 0x0B, 0x43, 0xA1, 0x01, 0x0C, 0x43, 0x5C,
/* 000074C0 */ 0x04, 0x43, 0x5C, 0x05, 0x0C, 0xF6, 0x06, 0x42, 0x42, 0x04, 0x00, 0x47, 0x2E, 0x42, 0x8F, 0x03,
/* 000074D0 */ 0x02, 0x42, 0x04, 0x00, 0x07, 0x06, 0x00, 0x5C, 0x00, 0x04, 0x5C, 0x01, 0x2B, 0x5C, 0x02, 0x0D,
/* 000074E0 */ 0x5C, 0x03, 0x0A, 0xA8, 0x43, 0x5C, 0x04, 0x43, 0xA8, 0x43, 0x5C, 0x05, 0x43, 0xF6, 0x06, 0x42,
/* 000074F0 */ 0x42, 0x05, 0x00, 0x47, 0x2F, 0x42, 0xA8, 0x42, 0x15, 0x03, 0x00, 0x2F, 0x42, 0x09, 0x1F, 0x00,
/* 00007500 */ 0x8F, 0x03, 0x09, 0x43, 0x00, 0x00, 0x6D, 0x42, 0x43, 0x04, 0x07, 0x02, 0x00, 0x5C, 0x00, 0x43,
/* 00007510 */ 0x5C, 0x01, 0x2F, 0xF6, 0x02, 0x42, 0x42, 0x06, 0x00, 0x47, 0x2F, 0x42, 0x09, 0x19, 0x00, 0x8F,
/* 00007520 */ 0x03, 0x09, 0x43, 0x00, 0x00, 0x6D, 0x42, 0x43, 0x05, 0x07, 0x01, 0x00, 0x5C, 0x00, 0x43, 0xF6,
/* 00007530 */ 0x01, 0x42, 0x42, 0x07, 0x00, 0x47, 0x2F, 0x42, 0xA8, 0x42, 0x14, 0x03, 0x00, 0x2F, 0x42, 0x09,
/* 00007540 */ 0x16, 0x00, 0x8F, 0x03, 0x09, 0x43, 0x00, 0x00, 0x6D, 0x42, 0x43, 0x06, 0x07, 0x01, 0x00, 0x5C,
/* 00007550 */ 0x00, 0x43, 0xF6, 0x01, 0xFF, 0x42, 0x08, 0x00, 0x8F, 0x03, 0x02, 0x42, 0x04, 0x00, 0x07, 0x06,
/* 00007560 */ 0x00, 0x5C, 0x00, 0x04, 0x5C, 0x01, 0x2B, 0x5C, 0x02, 0x0E, 0x5C, 0x03, 0x0A, 0xCE, 0x43, 0x03,
/* 00007570 */ 0x01, 0x00, 0xA1, 0x00, 0x0F, 0x43, 0xA1, 0x01, 0x10, 0x43, 0xA1, 0x02, 0x11, 0x43, 0x5C, 0x04,
/* 00007580 */ 0x43, 0xA8, 0x43, 0x5C, 0x05, 0x43, 0xF6, 0x06, 0x42, 0x42, 0x09, 0x00, 0x47, 0x30, 0x42, 0x8F,
/* 00007590 */ 0x03, 0x02, 0x42, 0x04, 0x00, 0x07, 0x06, 0x00, 0x5C, 0x00, 0x04, 0x5C, 0x01, 0x2B, 0x5C, 0x02,
/* 000075A0 */ 0x12, 0x5C, 0x03, 0x0A, 0xCE, 0x43, 0x03, 0x02, 0x00, 0xA1, 0x00, 0x0F, 0x43, 0xA1, 0x01, 0x10,
/* 000075B0 */ 0x43, 0xA1, 0x02, 0x11, 0x43, 0x5C, 0x04, 0x43, 0xA8, 0x43, 0x5C, 0x05, 0x43, 0xF6, 0x06, 0x42,
/* 000075C0 */ 0x42, 0x0A, 0x00, 0x47, 0x31, 0x42, 0x8F, 0x03, 0x02, 0x42, 0x04, 0x00, 0x07, 0x06, 0x00, 0x5C,
/* 000075D0 */ 0x00, 0x04, 0x5C, 0x01, 0x2B, 0x5C, 0x02, 0x13, 0x5C, 0x03, 0x0A, 0xCE, 0x43, 0x02, 0x03, 0x00,
/* 000075E0 */ 0xA1, 0x00, 0x14, 0x43, 0xA1, 0x01, 0x15, 0x43, 0x5C, 0x04, 0x43, 0xA8, 0x43, 0x5C, 0x05, 0x43,
/* 000075F0 */ 0xF6, 0x06, 0x42, 0x42, 0x0B, 0x00, 0x47, 0x32, 0x42, 0x8F, 0x03, 0x02, 0x42, 0x04, 0x00, 0x07,
/* 00007600 */ 0x06, 0x00, 0x5C, 0x00, 0x04, 0x5C, 0x01, 0x2B, 0x5C, 0x02, 0x16, 0x5C, 0x03, 0x0A, 0xCE, 0x43,
/* 00007610 */ 0x05, 0x04, 0x00, 0xA1, 0x00, 0x14, 0x43, 0xA1, 0x01, 0x15, 0x43, 0xA1, 0x02, 0x0F, 0x43, 0xA1,
/* 00007620 */ 0x03, 0x10, 0x43, 0xA1, 0x04, 0x11, 0x43, 0x5C, 0x04, 0x43, 0xA8, 0x43, 0x5C, 0x05, 0x43, 0xF6,
/* 00007630 */ 0x06, 0x42, 0x42, 0x0C, 0x00, 0x47, 0x33, 0x42, 0x8F, 0x03, 0x02, 0x42, 0x04, 0x00, 0x07, 0x06,
/* 00007640 */ 0x00, 0x5C, 0x00, 0x04, 0x5C, 0x01, 0x2B, 0x5C, 0x02, 0x17, 0x5C, 0x03, 0x0A, 0xCE, 0x43, 0x02,
/* 00007650 */ 0x05, 0x00, 0xA1, 0x00, 0x14, 0x43, 0xA1, 0x01, 0x15, 0x43, 0x5C, 0x04, 0x43, 0xA8, 0x43, 0x5C,
/* 00007660 */ 0x05, 0x43, 0xF6, 0x06, 0x42, 0x42, 0x0D, 0x00, 0x47, 0x34, 0x42, 0x8F, 0x03, 0x02, 0x42, 0x04,
/* 00007670 */ 0x00, 0x07, 0x06, 0x00, 0x5C, 0x00, 0x04, 0x5C, 0x01, 0x2B, 0x5C, 0x02, 0x18, 0x5C, 0x03, 0x0A,
/* 00007680 */ 0xCE, 0x43, 0x02, 0x06, 0x00, 0xA1, 0x00, 0x14, 0x43, 0xA1, 0x01, 0x15, 0x43, 0x5C, 0x04, 0x43,
/* 00007690 */ 0xA8, 0x43, 0x5C, 0x05, 0x43, 0xF6, 0x06, 0x42, 0x42, 0x0E, 0x00, 0x47, 0x35, 0x42, 0x8F, 0x03,
/* 000076A0 */ 0x02, 0x42, 0x04, 0x00, 0x07, 0x06, 0x00, 0x5C, 0x00, 0x04, 0x5C, 0x01, 0x2B, 0x5C, 0x02, 0x19,
/* 000076B0 */ 0x5C, 0x03, 0x0A, 0xCE, 0x43, 0x02, 0x07, 0x00, 0xA1, 0x00, 0x14, 0x43, 0xA1, 0x01, 0x15, 0x43,
/* 000076C0 */ 0x5C, 0x04, 0x43, 0xA8, 0x43, 0x5C, 0x05, 0x43, 0xF6, 0x06, 0x42, 0x42, 0x0F, 0x00, 0x47, 0x36,
/* 000076D0 */ 0x42, 0x8F, 0x03, 0x02, 0x42, 0x04, 0x00, 0x07, 0x06, 0x00, 0x5C, 0x00, 0x04, 0x5C, 0x01, 0x2B,
/* 000076E0 */ 0x5C, 0x02, 0x1A, 0x5C, 0x03, 0x0A, 0xCE, 0x43, 0x02, 0x08, 0x00, 0xA1, 0x00, 0x14, 0x43, 0xA1,
/* 000076F0 */ 0x01, 0x15, 0x43, 0x5C, 0x04, 0x43, 0xA8, 0x43, 0x5C, 0x05, 0x43, 0xF6, 0x06, 0x42, 0x42, 0x10,
/* 00007700 */ 0x00, 0x47, 0x37, 0x42, 0x8F, 0x03, 0x02, 0x42, 0x04, 0x00, 0x07, 0x06, 0x00, 0x5C, 0x00, 0x04,
/* 00007710 */ 0x5C, 0x01, 0x2B, 0x5C, 0x02, 0x1B, 0x5C, 0x03, 0x0A, 0xCE, 0x43, 0x02, 0x09, 0x00, 0xA1, 0x00,
/* 00007720 */ 0x10, 0x43, 0xA1, 0x01, 0x11, 0x43, 0x5C, 0x04, 0x43, 0xA8, 0x43, 0x5C, 0x05, 0x43, 0xF6, 0x06,
/* 00007730 */ 0x42, 0x42, 0x11, 0x00, 0x47, 0x38, 0x42, 0x0F, 0x03, 0x00, 0x35, 0x09, 0x2B, 0x00, 0x8F, 0x03,
/* 00007740 */ 0x02, 0x43, 0x04, 0x00, 0x07, 0x06, 0x00, 0x5C, 0x00, 0x04, 0x5C, 0x01, 0x2B, 0x5C, 0x02, 0x1C,
/* 00007750 */ 0x5C, 0x03, 0x1D, 0xA8, 0x44, 0x5C, 0x04, 0x44, 0xA8, 0x44, 0x5C, 0x05, 0x44, 0xF6, 0x06, 0x43,
/* 00007760 */ 0x43, 0x12, 0x00, 0x47, 0x42, 0x43, 0x09, 0x05, 0x00, 0xA8, 0x43, 0x47, 0x42, 0x43, 0x47, 0x39,
/* 00007770 */ 0x42, 0x8F, 0x03, 0x02, 0x42, 0x04, 0x00, 0x07, 0x06, 0x00, 0x5C, 0x00, 0x04, 0x5C, 0x01, 0x2B,
/* 00007780 */ 0x5C, 0x02, 0x1E, 0x5C, 0x03, 0x0A, 0xCE, 0x43, 0x02, 0x0A, 0x00, 0xA1, 0x00, 0x1F, 0x43, 0xA1,
/* 00007790 */ 0x01, 0x0C, 0x43, 0x5C, 0x04, 0x43, 0x5C, 0x05, 0x0C, 0xF6, 0x06, 0x42, 0x42, 0x13, 0x00, 0x47,
/* 000077A0 */ 0x3A, 0x42, 0xA8, 0x42, 0x15, 0x03, 0x00, 0x39, 0x42, 0x09, 0x16, 0x00, 0x0F, 0x03, 0x00, 0x39,
/* 000077B0 */ 0x09, 0x06, 0x00, 0x47, 0x43, 0x20, 0x09, 0x03, 0x00, 0x47, 0x43, 0x21, 0x47, 0x42, 0x43, 0x09,
/* 000077C0 */ 0x05, 0x00, 0xA8, 0x43, 0x47, 0x42, 0x43, 0x47, 0x3B, 0x42, 0x8F, 0x01, 0x03, 0x42, 0x05, 0x00,
/* 000077D0 */ 0x4B, 0x42, 0x07, 0x02, 0x00, 0x5C, 0x00, 0x04, 0x8F, 0x03, 0x0A, 0x43, 0x06, 0x00, 0x07, 0x03,
/* 000077E0 */ 0x00, 0x5C, 0x00, 0x04, 0xCC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x44, 0x00, 0x00,
/* 000077F0 */ 0x00, 0x7B, 0x30, 0x44, 0x07, 0x7B, 0x31, 0x44, 0x08, 0x7B, 0x32, 0x44, 0x09, 0x7B, 0x33, 0x44,
/* 00007800 */ 0x0A, 0x7B, 0x34, 0x44, 0x0B, 0x7B, 0x35, 0x44, 0x0C, 0x7B, 0x36, 0x44, 0x0D, 0x7B, 0x37, 0x44,
/* 00007810 */ 0x0E, 0x7B, 0x38, 0x44, 0x0F, 0x5C, 0x01, 0x44, 0x5C, 0x02, 0x22, 0xF6, 0x03, 0x43, 0x43, 0x14,
/* 00007820 */ 0x00, 0x5C, 0x01, 0x43, 0xF6, 0x02, 0x42, 0x42, 0x15, 0x00, 0x47, 0x3C, 0x42, 0x8F, 0x03, 0x07,
/* 00007830 */ 0x42, 0x07, 0x00, 0x07, 0x02, 0x00, 0x5C, 0x00, 0x04, 0x5C, 0x01, 0x2A, 0xF6, 0x02, 0x42, 0x42,
/* 00007840 */ 0x16, 0x00, 0x47, 0x2A, 0x42, 0x8F, 0x03, 0x2F, 0x42, 0x08, 0x00, 0x07, 0x05, 0x00, 0x5C, 0x00,
/* 00007850 */ 0x04, 0x5C, 0x01, 0x2A, 0x5C, 0x02, 0x2E, 0xCE, 0x43, 0x02, 0x0B, 0x00, 0xA1, 0x00, 0x23, 0x43,
/* 00007860 */ 0xA1, 0x01, 0x24, 0x43, 0x5C, 0x03, 0x43, 0x8F, 0x03, 0x30, 0x43, 0x09, 0x00, 0x5C, 0x04, 0x43,
/* 00007870 */ 0xF6, 0x05, 0x42, 0x42, 0x17, 0x00, 0x47, 0x3D, 0x42, 0x77, 0x2E, 0x29, 0x10, 0x77, 0x2F, 0x29,
/* 00007880 */ 0x11, 0x62, 0x42, 0x3D, 0x12, 0x77, 0x42, 0x29, 0x13, 0x77, 0x30, 0x29, 0x14, 0x77, 0x31, 0x29,
/* 00007890 */ 0x15, 0x77, 0x32, 0x29, 0x16, 0x77, 0x33, 0x29, 0x17, 0x77, 0x34, 0x29, 0x18, 0x77, 0x35, 0x29,
/* 000078A0 */ 0x19, 0x77, 0x36, 0x29, 0x1A, 0x77, 0x37, 0x29, 0x1B, 0x77, 0x38, 0x29, 0x1C, 0x77, 0x39, 0x29,
/* 000078B0 */ 0x1D, 0x77, 0x3A, 0x29, 0x1E, 0x77, 0x3B, 0x29, 0x1F, 0x77, 0x3C, 0x29, 0x20, 0x47, 0x3E, 0x25,
/* 000078C0 */ 0xE5, 0x1E, 0x00, 0x8F, 0x03, 0x3D, 0x42, 0x0A, 0x00, 0x4B, 0x42, 0x07, 0x03, 0x00, 0x5C, 0x00,
/* 000078D0 */ 0x04, 0x5C, 0x01, 0x29, 0x5C, 0x02, 0x25, 0xF6, 0x03, 0xFF, 0x42, 0x18, 0x00, 0xE9, 0x09, 0x5D,
/* 000078E0 */ 0x00, 0xE7, 0x2C, 0x06, 0x8F, 0x03, 0x29, 0x42, 0x0B, 0x00, 0x07, 0x02, 0x00, 0x5C, 0x00, 0x04,
/* 000078F0 */ 0x5C, 0x01, 0x2C, 0xF6, 0x02, 0xFF, 0x42, 0x19, 0x00, 0x8F, 0x01, 0x02, 0x42, 0x03, 0x00, 0x4B,
/* 00007900 */ 0x42, 0x07, 0x04, 0x00, 0x5C, 0x00, 0x04, 0x5C, 0x01, 0x2B, 0x5C, 0x02, 0x26, 0x5C, 0x03, 0x27,
/* 00007910 */ 0xF6, 0x04, 0x42, 0x42, 0x1A, 0x00, 0x47, 0x3F, 0x42, 0x47, 0x42, 0x29, 0x8F, 0x01, 0x03, 0x43,
/* 00007920 */ 0x05, 0x00, 0x4B, 0x43, 0x07, 0x03, 0x00, 0x5C, 0x00, 0x04, 0x5C, 0x01, 0x3F, 0x5C, 0x02, 0x22,
/* 00007930 */ 0xF6, 0x03, 0x43, 0x43, 0x1B, 0x00, 0x77, 0x43, 0x42, 0x21, 0x47, 0x3E, 0x06, 0xE9, 0x0F, 0x2E,
/* 00007940 */ 0x00, 0x3E, 0x09, 0x00, 0x00, 0x47, 0x42, 0x29, 0x8F, 0x01, 0x07, 0x43, 0x0C, 0x00, 0x4B, 0x43,
/* 00007950 */ 0x07, 0x03, 0x00, 0x5C, 0x00, 0x04, 0x62, 0x44, 0x29, 0x22, 0x98, 0x44, 0x44, 0x28, 0x00, 0x00,
/* 00007960 */ 0x5C, 0x01, 0x44, 0x5C, 0x02, 0x29, 0xF6, 0x03, 0x43, 0x43, 0x1C, 0x00, 0x77, 0x43, 0x42, 0x21,
/* 00007970 */ 0xE5, 0x1E, 0x00, 0x8F, 0x03, 0x3D, 0x42, 0x0A, 0x00, 0x4B, 0x42, 0x07, 0x03, 0x00, 0x5C, 0x00,
/* 00007980 */ 0x04, 0x5C, 0x01, 0x29, 0x5C, 0x02, 0x06, 0xF6, 0x03, 0xFF, 0x42, 0x1D, 0x00, 0xE9, 0x09, 0x2F,
/* 00007990 */ 0x00, 0xE7, 0x2D, 0x06, 0x8F, 0x03, 0x29, 0x42, 0x0B, 0x00, 0x07, 0x02, 0x00, 0x5C, 0x00, 0x04,
/* 000079A0 */ 0x5C, 0x01, 0x2D, 0xF6, 0x02, 0xFF, 0x42, 0x1E, 0x00, 0x8F, 0x03, 0x09, 0x43, 0x00, 0x00, 0x6D,
/* 000079B0 */ 0x42, 0x43, 0x06, 0x07, 0x01, 0x00, 0x5C, 0x00, 0x43, 0xF6, 0x01, 0xFF, 0x42, 0x1F, 0x00, 0xE9,
/* 000079C0 */ 0x8F, 0x01, 0x04, 0x42, 0x0D, 0x00, 0x4B, 0x42, 0x07, 0x02, 0x00, 0x5C, 0x00, 0x04, 0x62, 0x43,
/* 000079D0 */ 0x29, 0x23, 0x5C, 0x01, 0x43, 0xF6, 0x02, 0x42, 0x42, 0x20, 0x00, 0x77, 0x42, 0x29, 0x24, 0x47,
/* 000079E0 */ 0x42, 0x29, 0x8F, 0x03, 0x0C, 0x43, 0x01, 0x00, 0x07, 0x03, 0x00, 0x5C, 0x00, 0x04, 0x8F, 0x03,
/* 000079F0 */ 0x24, 0x44, 0x0E, 0x00, 0x5C, 0x01, 0x44, 0x62, 0x44, 0x29, 0x25, 0x5C, 0x02, 0x44, 0xF6, 0x03,
/* 00007A00 */ 0x43, 0x43, 0x21, 0x00, 0x77, 0x43, 0x42, 0x26, 0x62, 0x42, 0x29, 0x27, 0xA8, 0x43, 0x15, 0x03,
/* 00007A10 */ 0x00, 0x42, 0x43, 0x09, 0x0C, 0x00, 0x62, 0x42, 0x29, 0x28, 0x43, 0x42, 0x42, 0x20, 0x77, 0x42,
/* 00007A20 */ 0x29, 0x1D, 0x77, 0x06, 0x29, 0x29, 0xA8, 0x00, 0x24, 0x00, 0x01, 0x2C, 0x00, 0x00, 0x00, 0x00,
/* 00007A30 */ 0x00, 0x03, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7B, 0x02, 0x00, 0x00, 0x82, 0x02, 0x00,
/* 00007A40 */ 0x00, 0x7C, 0x02, 0x00, 0x00, 0x7D, 0x02, 0x00, 0x00, 0x7E, 0x02, 0x00, 0x00, 0x80, 0x02, 0x00,
/* 00007A50 */ 0x00, 0x7F, 0x02, 0x00, 0x00, 0x81, 0x02, 0x00, 0x00, 0x84, 0x02, 0x00, 0x00, 0xFE, 0x55, 0x02,
/* 00007A60 */ 0xFE, 0x6A, 0x02, 0xFE, 0x65, 0x02, 0xFE, 0x6A, 0x02, 0xFE, 0x63, 0x02, 0xFE, 0x64, 0x02, 0xFE,
/* 00007A70 */ 0x5E, 0x02, 0xFE, 0x7B, 0x02, 0xFE, 0x82, 0x02, 0xFE, 0x7C, 0x02, 0xFE, 0x7D, 0x02, 0xFE, 0x7E,
/* 00007A80 */ 0x02, 0xFE, 0x80, 0x02, 0xFE, 0x7F, 0x02, 0xFE, 0x81, 0x02, 0xFE, 0x84, 0x02, 0xFE, 0x6E, 0x02,
/* 00007A90 */ 0xFE, 0x8E, 0x02, 0xFE, 0x1F, 0x02, 0xFE, 0x17, 0x02, 0xFE, 0x86, 0x02, 0xFE, 0x8D, 0x02, 0xFE,
/* 00007AA0 */ 0x87, 0x02, 0xFE, 0x88, 0x02, 0xFE, 0x89, 0x02, 0xFE, 0x8B, 0x02, 0xFE, 0x8A, 0x02, 0xFE, 0x8C,
/* 00007AB0 */ 0x02, 0xFE, 0x8F, 0x02, 0xFE, 0x90, 0x02, 0xFE, 0x91, 0x02, 0xFE, 0x23, 0x02, 0xFE, 0x18, 0x02,
/* 00007AC0 */ 0xFE, 0x18, 0x02, 0xFE, 0x25, 0x02, 0xFE, 0x24, 0x02, 0xFE, 0x92, 0x02, 0xFE, 0x12, 0x02, 0xFE,
/* 00007AD0 */ 0x12, 0x02, 0xFE, 0x8B, 0x02, 0xFE, 0x23, 0x02, 0xFE, 0x6C, 0x02, 0xFF, 0xE1, 0x20, 0x01, 0x00,
/* 00007AE0 */ 0x3F, 0x02, 0x00, 0x00, 0x00, 0x0B, 0x00, 0x3E, 0x00, 0x16, 0x00, 0x42, 0x00, 0x33, 0x00, 0xA0,
/* 00007AF0 */ 0x00, 0x1C, 0x00, 0x74, 0x00, 0x04, 0x00, 0x6A, 0x00, 0x20, 0x00, 0x48, 0x00, 0x31, 0x00, 0x72,
/* 00007B00 */ 0x00, 0x28, 0x00, 0x62, 0x00, 0x0A, 0x00, 0x33, 0x00, 0x1F, 0x00, 0x6E, 0x00, 0x19, 0x00, 0x50,
/* 00007B10 */ 0x00, 0x0A, 0x00, 0x33, 0x00, 0x16, 0x00, 0x70, 0x00, 0x37, 0x00, 0x70, 0x00, 0x37, 0x00, 0x68,
/* 00007B20 */ 0x00, 0x33, 0x00, 0x65, 0x00, 0x3F, 0x00, 0x82, 0x00, 0x33, 0x00, 0x63, 0x00, 0x33, 0x00, 0x65,
/* 00007B30 */ 0x00, 0x33, 0x00, 0x69, 0x00, 0x33, 0x00, 0x69, 0x00, 0x33, 0x00, 0x72, 0x00, 0x3A, 0x00, 0x70,
/* 00007B40 */ 0x00, 0x31, 0x00, 0x79, 0x00, 0x28, 0x00, 0x73, 0x00, 0x63, 0x00, 0xDD, 0x01, 0x18, 0x00, 0x42,
/* 00007B50 */ 0x00, 0x34, 0x00, 0x9D, 0x00, 0x04, 0x00, 0x35, 0x00, 0x04, 0x00, 0x37, 0x00, 0x08, 0x00, 0x6B,
/* 00007B60 */ 0x00, 0x04, 0x00, 0x35, 0x00, 0x04, 0x00, 0x2D, 0x00, 0x04, 0x00, 0x2F, 0x00, 0x04, 0x00, 0x31,
/* 00007B70 */ 0x00, 0x04, 0x00, 0x2D, 0x00, 0x04, 0x00, 0x2F, 0x00, 0x04, 0x00, 0x33, 0x00, 0x04, 0x00, 0x33,
/* 00007B80 */ 0x00, 0x04, 0x00, 0x41, 0x00, 0x04, 0x00, 0x33, 0x00, 0x04, 0x00, 0x41, 0x00, 0x04, 0x00, 0x41,
/* 00007B90 */ 0x00, 0x04, 0x00, 0x04, 0x03, 0x06, 0x00, 0x97, 0x00, 0x20, 0x00, 0x40, 0x00, 0x01, 0x00, 0x4C,
/* 00007BA0 */ 0x00, 0x15, 0x00, 0xF3, 0x00, 0x20, 0x00, 0x55, 0x00, 0x21, 0x00, 0x6B, 0x00, 0x04, 0x00, 0x3A,
/* 00007BB0 */ 0x00, 0x07, 0x00, 0x5C, 0x00, 0x2E, 0x00, 0xE3, 0x00, 0x20, 0x00, 0x3F, 0x00, 0x01, 0x00, 0x4C,
/* 00007BC0 */ 0x00, 0x15, 0x00, 0x7C, 0x01, 0x17, 0x00, 0x7B, 0x00, 0x1F, 0x00, 0x68, 0x00, 0x29, 0x00, 0x83,
/* 00007BD0 */ 0x00, 0x0E, 0x00, 0x40, 0x00, 0x0C, 0x00, 0x6F, 0x00, 0x06, 0x00, 0x40, 0x00, 0x00, 0xBF, 0x5C,
/* 00007BE0 */ 0x85, 0xE0, 0x11, 0xC4, 0x00, 0xFE, 0x7D, 0x05, 0x0C, 0xA3, 0x41, 0xC1, 0x00, 0xFE, 0x06, 0x04,
/* 00007BF0 */ 0x45, 0xFF, 0x13, 0x13, 0x01, 0x00, 0xFF, 0x00, 0x10, 0x01, 0x00, 0x03, 0x03, 0xFF, 0x13, 0x13,
/* 00007C00 */ 0x01, 0x00, 0xFE, 0x64, 0x0D, 0xFE, 0x64, 0x0D, 0x01, 0x07, 0x12, 0x16, 0x06, 0xC8, 0xBB, 0x03,
/* 00007C10 */ 0x02, 0x10, 0x07, 0x0A, 0x0A, 0x0A, 0x0A, 0x02, 0x15, 0x05, 0xFE, 0x31, 0x04, 0x08, 0x05, 0xFE,
/* 00007C20 */ 0x17, 0x04, 0x07, 0x05, 0xFE, 0x32, 0x04, 0x01, 0x00, 0x05, 0xFE, 0x33, 0x04, 0x05, 0xFE, 0x26,
/* 00007C30 */ 0x04, 0x05, 0xFE, 0x34, 0x04, 0x06, 0xFE, 0xB4, 0x03, 0x06, 0xFE, 0x0D, 0x04, 0x06, 0xFE, 0x0E,
/* 00007C40 */ 0x04, 0x06, 0xFE, 0x0F, 0x04, 0x06, 0xFE, 0x10, 0x04, 0x06, 0xFE, 0x11, 0x04, 0x05, 0xFE, 0x35,
/* 00007C50 */ 0x04, 0xFE, 0x02, 0x03, 0xA8, 0x14, 0x62, 0x16, 0x13, 0x00, 0xA8, 0x17, 0x15, 0x03, 0x00, 0x16,
/* 00007C60 */ 0x17, 0x09, 0x26, 0x00, 0x8F, 0x01, 0x05, 0x16, 0x00, 0x00, 0x4B, 0x16, 0x07, 0x04, 0x00, 0x5C,
/* 00007C70 */ 0x00, 0x03, 0x5C, 0x01, 0x12, 0x62, 0x17, 0x13, 0x00, 0x5C, 0x02, 0x17, 0x5D, 0x03, 0x02, 0x00,
/* 00007C80 */ 0x00, 0xEE, 0x04, 0x16, 0x16, 0x00, 0x00, 0x47, 0x12, 0x16, 0x62, 0x16, 0x13, 0x01, 0xA8, 0x17,
/* 00007C90 */ 0x15, 0x03, 0x00, 0x16, 0x17, 0x09, 0x00, 0x00, 0x62, 0x16, 0x13, 0x02, 0x14, 0x03, 0x00, 0x16,
/* 00007CA0 */ 0x04, 0x09, 0x8C, 0x00, 0x8F, 0x03, 0x09, 0x17, 0x01, 0x00, 0x6D, 0x16, 0x17, 0x03, 0x07, 0x03,
/* 00007CB0 */ 0x00, 0x5C, 0x00, 0x17, 0x5C, 0x01, 0x12, 0xE0, 0x18, 0x00, 0x5C, 0x02, 0x18, 0xF2, 0x03, 0x16,
/* 00007CC0 */ 0x16, 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x47, 0x14, 0x16, 0x14, 0x03, 0x00, 0x14, 0x05, 0x09,
/* 00007CD0 */ 0x2C, 0x00, 0x8F, 0x03, 0x14, 0x16, 0x02, 0x00, 0x07, 0x02, 0x00, 0x5C, 0x00, 0x03, 0x8F, 0x03,
/* 00007CE0 */ 0x13, 0x17, 0x03, 0x00, 0x07, 0x02, 0x00, 0x5D, 0x01, 0x06, 0x03, 0x00, 0xC3, 0x02, 0x17, 0x17,
/* 00007CF0 */ 0x03, 0x00, 0x5C, 0x01, 0x17, 0xEE, 0x02, 0xFF, 0x16, 0x02, 0x00, 0x09, 0x2F, 0x00, 0x8F, 0x03,
/* 00007D00 */ 0x0C, 0x16, 0x04, 0x00, 0x07, 0x05, 0x00, 0x5C, 0x00, 0x03, 0x8F, 0x03, 0x23, 0x17, 0x05, 0x00,
/* 00007D10 */ 0x5C, 0x01, 0x17, 0x5C, 0x02, 0x12, 0x98, 0x17, 0x14, 0x07, 0x00, 0x00, 0x5C, 0x03, 0x17, 0x5D,
/* 00007D20 */ 0x04, 0x08, 0x04, 0x00, 0xEE, 0x05, 0x16, 0x16, 0x04, 0x00, 0x47, 0x12, 0x16, 0x09, 0x95, 0x00,
/* 00007D30 */ 0x62, 0x16, 0x13, 0x02, 0x14, 0x03, 0x00, 0x16, 0x09, 0x09, 0x89, 0x00, 0x8F, 0x03, 0x09, 0x17,
/* 00007D40 */ 0x01, 0x00, 0x6D, 0x16, 0x17, 0x03, 0x07, 0x03, 0x00, 0x5C, 0x00, 0x17, 0x5C, 0x01, 0x12, 0xE0,
/* 00007D50 */ 0x18, 0x01, 0x5C, 0x02, 0x18, 0xF2, 0x03, 0x16, 0x16, 0x03, 0x00, 0x00, 0x00, 0x05, 0x00, 0x47,
/* 00007D60 */ 0x14, 0x16, 0x14, 0x03, 0x00, 0x14, 0x05, 0x09, 0x2C, 0x00, 0x8F, 0x03, 0x14, 0x16, 0x02, 0x00,
/* 00007D70 */ 0x07, 0x02, 0x00, 0x5C, 0x00, 0x03, 0x8F, 0x03, 0x13, 0x17, 0x03, 0x00, 0x07, 0x02, 0x00, 0x5D,
/* 00007D80 */ 0x01, 0x06, 0x07, 0x00, 0xC3, 0x02, 0x17, 0x17, 0x07, 0x00, 0x5C, 0x01, 0x17, 0xEE, 0x02, 0xFF,
/* 00007D90 */ 0x16, 0x06, 0x00, 0x09, 0x2F, 0x00, 0x8F, 0x03, 0x0C, 0x16, 0x04, 0x00, 0x07, 0x05, 0x00, 0x5C,
/* 00007DA0 */ 0x00, 0x03, 0x8F, 0x03, 0x23, 0x17, 0x05, 0x00, 0x5C, 0x01, 0x17, 0x5C, 0x02, 0x12, 0x98, 0x17,
/* 00007DB0 */ 0x14, 0x07, 0x01, 0x00, 0x5C, 0x03, 0x17, 0x5D, 0x04, 0x0A, 0x08, 0x00, 0xEE, 0x05, 0x16, 0x16,
/* 00007DC0 */ 0x08, 0x00, 0x47, 0x12, 0x16, 0x62, 0x16, 0x13, 0x04, 0xA8, 0x17, 0x15, 0x03, 0x00, 0x16, 0x17,
/* 00007DD0 */ 0x09, 0x41, 0x00, 0x62, 0x16, 0x13, 0x04, 0x15, 0x03, 0x00, 0x16, 0x04, 0x09, 0x35, 0x00, 0x62,
/* 00007DE0 */ 0x16, 0x13, 0x04, 0x15, 0x03, 0x00, 0x16, 0x0B, 0x09, 0x29, 0x00, 0x8F, 0x01, 0x05, 0x16, 0x00,
/* 00007DF0 */ 0x00, 0x4B, 0x16, 0x07, 0x04, 0x00, 0x5C, 0x00, 0x03, 0x5C, 0x01, 0x12, 0x62, 0x17, 0x13, 0x04,
/* 00007E00 */ 0x5C, 0x02, 0x17, 0x5D, 0x03, 0x0C, 0x09, 0x00, 0xEE, 0x04, 0x16, 0x16, 0x09, 0x00, 0x47, 0x12,
/* 00007E10 */ 0x16, 0x09, 0x34, 0x00, 0x62, 0x16, 0x13, 0x04, 0xA8, 0x17, 0x15, 0x03, 0x00, 0x16, 0x17, 0x09,
/* 00007E20 */ 0x26, 0x00, 0x8F, 0x01, 0x06, 0x16, 0x06, 0x00, 0x4B, 0x16, 0x07, 0x04, 0x00, 0x5C, 0x00, 0x03,
/* 00007E30 */ 0x5C, 0x01, 0x12, 0x62, 0x17, 0x13, 0x04, 0x5C, 0x02, 0x17, 0x5D, 0x03, 0x0C, 0x0A, 0x00, 0xEE,
/* 00007E40 */ 0x04, 0x16, 0x16, 0x0A, 0x00, 0x47, 0x12, 0x16, 0x62, 0x16, 0x13, 0x05, 0xA8, 0x17, 0x15, 0x03,
/* 00007E50 */ 0x00, 0x16, 0x17, 0x09, 0x26, 0x00, 0x8F, 0x01, 0x06, 0x16, 0x06, 0x00, 0x4B, 0x16, 0x07, 0x04,
/* 00007E60 */ 0x00, 0x5C, 0x00, 0x03, 0x5C, 0x01, 0x12, 0x62, 0x17, 0x13, 0x05, 0x5C, 0x02, 0x17, 0x5D, 0x03,
/* 00007E70 */ 0x0D, 0x0B, 0x00, 0xEE, 0x04, 0x16, 0x16, 0x0B, 0x00, 0x47, 0x12, 0x16, 0x62, 0x16, 0x13, 0x06,
/* 00007E80 */ 0xA8, 0x17, 0x15, 0x03, 0x00, 0x16, 0x17, 0x09, 0x26, 0x00, 0x8F, 0x01, 0x06, 0x16, 0x06, 0x00,
/* 00007E90 */ 0x4B, 0x16, 0x07, 0x04, 0x00, 0x5C, 0x00, 0x03, 0x5C, 0x01, 0x12, 0x62, 0x17, 0x13, 0x06, 0x5C,
/* 00007EA0 */ 0x02, 0x17, 0x5D, 0x03, 0x0E, 0x0C, 0x00, 0xEE, 0x04, 0x16, 0x16, 0x0C, 0x00, 0x47, 0x12, 0x16,
/* 00007EB0 */ 0x62, 0x16, 0x13, 0x07, 0xA8, 0x17, 0x15, 0x03, 0x00, 0x16, 0x17, 0x09, 0x26, 0x00, 0x8F, 0x01,
/* 00007EC0 */ 0x06, 0x16, 0x06, 0x00, 0x4B, 0x16, 0x07, 0x04, 0x00, 0x5C, 0x00, 0x03, 0x5C, 0x01, 0x12, 0x62,
/* 00007ED0 */ 0x17, 0x13, 0x07, 0x5C, 0x02, 0x17, 0x5D, 0x03, 0x0F, 0x0D, 0x00, 0xEE, 0x04, 0x16, 0x16, 0x0D,
/* 00007EE0 */ 0x00, 0x47, 0x12, 0x16, 0x62, 0x16, 0x13, 0x08, 0xA8, 0x17, 0x15, 0x03, 0x00, 0x16, 0x17, 0x09,
/* 00007EF0 */ 0x26, 0x00, 0x8F, 0x01, 0x06, 0x16, 0x06, 0x00, 0x4B, 0x16, 0x07, 0x04, 0x00, 0x5C, 0x00, 0x03,
/* 00007F00 */ 0x5C, 0x01, 0x12, 0x62, 0x17, 0x13, 0x08, 0x5C, 0x02, 0x17, 0x5D, 0x03, 0x10, 0x0E, 0x00, 0xEE,
/* 00007F10 */ 0x04, 0x16, 0x16, 0x0E, 0x00, 0x47, 0x12, 0x16, 0x62, 0x16, 0x13, 0x09, 0xA8, 0x17, 0x15, 0x03,
/* 00007F20 */ 0x00, 0x16, 0x17, 0x09, 0x26, 0x00, 0x8F, 0x01, 0x05, 0x16, 0x00, 0x00, 0x4B, 0x16, 0x07, 0x04,
/* 00007F30 */ 0x00, 0x5C, 0x00, 0x03, 0x5C, 0x01, 0x12, 0x62, 0x17, 0x13, 0x09, 0x5C, 0x02, 0x17, 0x5D, 0x03,
/* 00007F40 */ 0x11, 0x0F, 0x00, 0xEE, 0x04, 0x16, 0x16, 0x0F, 0x00, 0x47, 0x12, 0x16, 0x47, 0x00, 0x12, 0x09,
/* 00007F50 */ 0x02, 0x00, 0xA8, 0x00, 0x24, 0x00, 0xFE, 0x86, 0x02, 0xFE, 0x8D, 0x02, 0xFE, 0x87, 0x02, 0xFE,
/* 00007F60 */ 0x37, 0x02, 0xFE, 0x88, 0x02, 0xFE, 0x89, 0x02, 0xFE, 0x8B, 0x02, 0xFE, 0x8A, 0x02, 0xFE, 0x8C,
/* 00007F70 */ 0x02, 0xFE, 0x8F, 0x02, 0x1C, 0xFE, 0x36, 0x04, 0x00, 0x1C, 0xFE, 0x36, 0x04, 0x00, 0xFF, 0x63,
/* 00007F80 */ 0x13, 0x01, 0x00, 0x1D, 0x02, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x43, 0x00, 0x26, 0x00, 0x8B, 0x00,
/* 00007F90 */ 0x0E, 0x00, 0x94, 0x01, 0x0C, 0x00, 0x40, 0x00, 0x26, 0x00, 0x6C, 0x00, 0x08, 0x00, 0x2F, 0x00,
/* 00007FA0 */ 0x2C, 0x00, 0x93, 0x00, 0x32, 0x00, 0x9A, 0x00, 0x0C, 0x00, 0x3D, 0x00, 0x26, 0x00, 0x6C, 0x00,
/* 00007FB0 */ 0x08, 0x00, 0x2F, 0x00, 0x2C, 0x00, 0x93, 0x00, 0x2F, 0x00, 0x34, 0x01, 0x26, 0x00, 0x91, 0x00,
/* 00007FC0 */ 0x29, 0x00, 0x77, 0x00, 0x0E, 0x00, 0x41, 0x00, 0x26, 0x00, 0x8E, 0x00, 0x0E, 0x00, 0x3F, 0x00,
/* 00007FD0 */ 0x26, 0x00, 0x8A, 0x00, 0x0E, 0x00, 0x40, 0x00, 0x26, 0x00, 0x8C, 0x00, 0x0E, 0x00, 0x42, 0x00,
/* 00007FE0 */ 0x26, 0x00, 0x90, 0x00, 0x0E, 0x00, 0x42, 0x00, 0x26, 0x00, 0x90, 0x00, 0x0E, 0x00, 0x48, 0x00,
/* 00007FF0 */ 0x26, 0x00, 0x8F, 0x00, 0x08, 0x00, 0x23, 0x00, 0x00, 0xBF, 0x5C, 0x85, 0xE0, 0x01, 0xC4, 0x00,
/* 00008000 */ 0xFE, 0x69, 0x05, 0x0C, 0xA3, 0x41, 0xC1, 0x00, 0xFE, 0x05, 0x04, 0x44, 0xFF, 0x97, 0x0D, 0x01,
/* 00008010 */ 0x00, 0xFF, 0x00, 0x10, 0x01, 0x00, 0x04, 0x04, 0xFF, 0x97, 0x0D, 0x01, 0x00, 0xFE, 0x09, 0x05,
/* 00008020 */ 0xFE, 0x09, 0x05, 0x01, 0x09, 0x11, 0x16, 0x07, 0x43, 0x40, 0x03, 0x05, 0x06, 0x06, 0x01, 0x01,
/* 00008030 */ 0x01, 0x01, 0x15, 0x05, 0xFE, 0x21, 0x04, 0x05, 0xFE, 0x2C, 0x04, 0x08, 0x07, 0x05, 0xFE, 0x2D,
/* 00008040 */ 0x04, 0x05, 0xFE, 0x24, 0x04, 0x05, 0xFE, 0x25, 0x04, 0x05, 0xFE, 0x17, 0x04, 0x01, 0x00, 0x06,
/* 00008050 */ 0xFE, 0x27, 0x04, 0x01, 0x01, 0x05, 0xFE, 0x2E, 0x04, 0x01, 0x02, 0x05, 0xFE, 0x2F, 0x04, 0x05,
/* 00008060 */ 0xFE, 0x30, 0x04, 0xFE, 0x14, 0x01, 0x8F, 0x03, 0x09, 0x17, 0x00, 0x00, 0x6D, 0x16, 0x17, 0x00,
/* 00008070 */ 0x07, 0x03, 0x00, 0x5C, 0x00, 0x17, 0x5C, 0x01, 0x11, 0x8F, 0x03, 0x0F, 0x18, 0x01, 0x00, 0x07,
/* 00008080 */ 0x02, 0x00, 0x5C, 0x00, 0x04, 0xFB, 0x19, 0x02, 0x13, 0x03, 0x5C, 0x01, 0x19, 0xEE, 0x02, 0x18,
/* 00008090 */ 0x18, 0x01, 0x00, 0x5C, 0x02, 0x18, 0xF2, 0x03, 0x16, 0x16, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
/* 000080A0 */ 0x47, 0x14, 0x16, 0x14, 0x03, 0x00, 0x14, 0x05, 0x09, 0x3C, 0x00, 0x8F, 0x03, 0x14, 0x16, 0x02,
/* 000080B0 */ 0x00, 0x07, 0x02, 0x00, 0x5C, 0x00, 0x04, 0x8F, 0x03, 0x13, 0x17, 0x03, 0x00, 0x07, 0x02, 0x00,
/* 000080C0 */ 0xFC, 0x18, 0x06, 0x11, 0x06, 0xFE, 0x18, 0x07, 0x02, 0x02, 0xFE, 0x18, 0x13, 0x08, 0x04, 0x5C,
/* 000080D0 */ 0x01, 0x18, 0xC3, 0x02, 0x17, 0x17, 0x03, 0x00, 0x5C, 0x01, 0x17, 0xEE, 0x02, 0xFF, 0x16, 0x02,
/* 000080E0 */ 0x00, 0x47, 0x00, 0x11, 0x09, 0x91, 0x00, 0x14, 0x03, 0x00, 0x12, 0x09, 0x09, 0x3B, 0x00, 0x8F,
/* 000080F0 */ 0x03, 0x0C, 0x16, 0x04, 0x00, 0x07, 0x05, 0x00, 0x5C, 0x00, 0x04, 0x8F, 0x03, 0x23, 0x17, 0x05,
/* 00008100 */ 0x00, 0x5C, 0x01, 0x17, 0x5C, 0x02, 0x11, 0x98, 0x17, 0x14, 0x0A, 0x00, 0x00, 0x5C, 0x03, 0x17,
/* 00008110 */ 0x98, 0x17, 0x14, 0x0C, 0x01, 0x00, 0xFB, 0x17, 0x0B, 0x17, 0x0D, 0x5C, 0x04, 0x17, 0xEE, 0x05,
/* 00008120 */ 0x00, 0x16, 0x04, 0x00, 0x09, 0x51, 0x00, 0x09, 0x46, 0x00, 0x98, 0x16, 0x14, 0x0E, 0x02, 0x00,
/* 00008130 */ 0x15, 0x03, 0x00, 0x16, 0x0F, 0x09, 0x38, 0x00, 0x8F, 0x03, 0x0C, 0x16, 0x04, 0x00, 0x07, 0x05,
/* 00008140 */ 0x00, 0x5C, 0x00, 0x04, 0x8F, 0x03, 0x23, 0x17, 0x05, 0x00, 0x5C, 0x01, 0x17, 0x5C, 0x02, 0x11,
/* 00008150 */ 0x98, 0x17, 0x14, 0x0A, 0x03, 0x00, 0x5C, 0x03, 0x17, 0x98, 0x17, 0x14, 0x0C, 0x04, 0x00, 0xFB,
/* 00008160 */ 0x17, 0x0B, 0x17, 0x10, 0x5C, 0x04, 0x17, 0xEE, 0x05, 0x00, 0x16, 0x05, 0x00, 0x09, 0x08, 0x00,
/* 00008170 */ 0x47, 0x00, 0x11, 0x09, 0x02, 0x00, 0xA8, 0x00, 0x24, 0x00, 0xFE, 0x37, 0x02, 0xFF, 0xC1, 0x0E,
/* 00008180 */ 0x01, 0x00, 0x0A, 0x00, 0x00, 0x00, 0x00, 0x3D, 0x00, 0x92, 0x00, 0x08, 0x00, 0x2B, 0x00, 0x36,
/* 00008190 */ 0x00, 0x01, 0x01, 0x06, 0x00, 0x87, 0x00, 0x08, 0x00, 0x34, 0x00, 0x3B, 0x00, 0x82, 0x00, 0x0E,
/* 000081A0 */ 0x00, 0x33, 0x00, 0x38, 0x00, 0x8D, 0x00, 0x08, 0x00, 0x23, 0x00, 0x00, 0xBF, 0x5C, 0x85, 0xE0,
/* 000081B0 */ 0x01, 0xC4, 0x00, 0xFE, 0x58, 0x05, 0x0C, 0xA3, 0x41, 0xC1, 0x00, 0xFE, 0x04, 0x04, 0x43, 0xFF,
/* 000081C0 */ 0x58, 0x08, 0x01, 0x00, 0xFF, 0x00, 0x10, 0x01, 0x00, 0x04, 0x04, 0xFF, 0x58, 0x08, 0x01, 0x00,
/* 000081D0 */ 0xFE, 0x2F, 0x05, 0xFE, 0x2F, 0x05, 0x01, 0x09, 0x14, 0x19, 0x07, 0x50, 0x4B, 0x03, 0x05, 0x06,
/* 000081E0 */ 0x06, 0x01, 0x01, 0x01, 0x01, 0x18, 0x05, 0xFE, 0x21, 0x04, 0x05, 0xFE, 0x22, 0x04, 0x08, 0x07,
/* 000081F0 */ 0x05, 0xFE, 0x23, 0x04, 0x05, 0xFE, 0x24, 0x04, 0x05, 0xFE, 0x25, 0x04, 0x01, 0x02, 0x05, 0xFE,
/* 00008200 */ 0x26, 0x04, 0x05, 0xFE, 0x15, 0x04, 0x01, 0x00, 0x06, 0xFE, 0x27, 0x04, 0x01, 0x01, 0x06, 0xFE,
/* 00008210 */ 0x28, 0x04, 0x06, 0xFE, 0x29, 0x04, 0x05, 0xFE, 0x13, 0x04, 0x05, 0xFE, 0x2A, 0x04, 0x05, 0xFE,
/* 00008220 */ 0x2B, 0x04, 0xFE, 0x43, 0x01, 0x8F, 0x03, 0x09, 0x1A, 0x00, 0x00, 0x6D, 0x19, 0x1A, 0x00, 0x07,
/* 00008230 */ 0x03, 0x00, 0x5C, 0x00, 0x1A, 0x5C, 0x01, 0x14, 0x8F, 0x03, 0x0F, 0x1B, 0x01, 0x00, 0x07, 0x02,
/* 00008240 */ 0x00, 0x5C, 0x00, 0x04, 0xFB, 0x1C, 0x02, 0x16, 0x03, 0x5C, 0x01, 0x1C, 0xEE, 0x02, 0x1B, 0x1B,
/* 00008250 */ 0x01, 0x00, 0x5C, 0x02, 0x1B, 0xF2, 0x03, 0x19, 0x19, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x47,
/* 00008260 */ 0x17, 0x19, 0x14, 0x03, 0x00, 0x17, 0x05, 0x09, 0x3C, 0x00, 0x8F, 0x03, 0x14, 0x19, 0x02, 0x00,
/* 00008270 */ 0x07, 0x02, 0x00, 0x5C, 0x00, 0x04, 0x8F, 0x03, 0x13, 0x1A, 0x03, 0x00, 0x07, 0x02, 0x00, 0xFC,
/* 00008280 */ 0x1B, 0x06, 0x14, 0x06, 0xFE, 0x1B, 0x07, 0x02, 0x02, 0xFE, 0x1B, 0x16, 0x08, 0x04, 0x5C, 0x01,
/* 00008290 */ 0x1B, 0xC3, 0x02, 0x1A, 0x1A, 0x03, 0x00, 0x5C, 0x01, 0x1A, 0xEE, 0x02, 0xFF, 0x19, 0x02, 0x00,
/* 000082A0 */ 0x47, 0x00, 0x14, 0x09, 0xC0, 0x00, 0x98, 0x19, 0x17, 0x09, 0x00, 0x00, 0x15, 0x03, 0x00, 0x19,
/* 000082B0 */ 0x0A, 0x09, 0x4E, 0x00, 0x14, 0x03, 0x00, 0x15, 0x0B, 0x09, 0x46, 0x00, 0x8F, 0x03, 0x0C, 0x19,
/* 000082C0 */ 0x04, 0x00, 0x07, 0x05, 0x00, 0x5C, 0x00, 0x04, 0x8F, 0x03, 0x23, 0x1A, 0x05, 0x00, 0x5C, 0x01,
/* 000082D0 */ 0x1A, 0x5C, 0x02, 0x14, 0x98, 0x1A, 0x17, 0x0C, 0x01, 0x00, 0x5C, 0x03, 0x1A, 0x98, 0x1A, 0x17,
/* 000082E0 */ 0x0E, 0x02, 0x00, 0x2F, 0x1A, 0x0D, 0x1A, 0x2F, 0x1A, 0x1A, 0x0F, 0x2F, 0x1A, 0x1A, 0x0A, 0x2F,
/* 000082F0 */ 0x1A, 0x1A, 0x10, 0x5C, 0x04, 0x1A, 0xEE, 0x05, 0x00, 0x19, 0x04, 0x00, 0x09, 0x67, 0x00, 0x09,
/* 00008300 */ 0x5C, 0x00, 0x15, 0x03, 0x00, 0x15, 0x0B, 0x09, 0x54, 0x00, 0x8F, 0x03, 0x0C, 0x19, 0x04, 0x00,
/* 00008310 */ 0x07, 0x05, 0x00, 0x5C, 0x00, 0x04, 0x8F, 0x03, 0x23, 0x1A, 0x05, 0x00, 0x5C, 0x01, 0x1A, 0x5C,
/* 00008320 */ 0x02, 0x14, 0x98, 0x1A, 0x17, 0x0C, 0x03, 0x00, 0x5C, 0x03, 0x1A, 0x98, 0x1A, 0x17, 0x0E, 0x04,
/* 00008330 */ 0x00, 0x2F, 0x1A, 0x0D, 0x1A, 0x2F, 0x1A, 0x1A, 0x0F, 0x14, 0x03, 0x00, 0x15, 0x11, 0x09, 0x06,
/* 00008340 */ 0x00, 0x47, 0x1B, 0x12, 0x09, 0x03, 0x00, 0x47, 0x1B, 0x13, 0x2F, 0x1A, 0x1A, 0x1B, 0x2F, 0x1A,
/* 00008350 */ 0x1A, 0x10, 0x5C, 0x04, 0x1A, 0xEE, 0x05, 0x00, 0x19, 0x05, 0x00, 0x09, 0x08, 0x00, 0x47, 0x00,
/* 00008360 */ 0x14, 0x09, 0x02, 0x00, 0xA8, 0x00, 0x24, 0x00, 0xFE, 0x37, 0x02, 0xFF, 0x30, 0x09, 0x01, 0x00,
/* 00008370 */ 0x0A, 0x00, 0x00, 0x00, 0x00, 0x3D, 0x00, 0x11, 0x01, 0x08, 0x00, 0x2B, 0x00, 0x36, 0x00, 0xF6,
/* 00008380 */ 0x00, 0x06, 0x00, 0x3C, 0x00, 0x16, 0x00, 0x48, 0x00, 0x46, 0x00, 0x86, 0x00, 0x08, 0x00, 0x31,
/* 00008390 */ 0x00, 0x54, 0x00, 0xC6, 0x00, 0x08, 0x00, 0x23, 0x00, 0x00, 0xBF, 0x4C, 0x81, 0x00, 0x00, 0xC4,
/* 000083A0 */ 0x00, 0xFE, 0x4F, 0x05, 0x0C, 0xA3, 0x41, 0xC1, 0x00, 0xFE, 0x03, 0x04, 0x42, 0xFF, 0xE8, 0x06,
/* 000083B0 */ 0x01, 0x00, 0xFF, 0x00, 0x10, 0x01, 0x00, 0x02, 0x02, 0xFF, 0xE8, 0x06, 0x01, 0x00, 0xEF, 0xEF,
/* 000083C0 */ 0x01, 0x03, 0x05, 0x07, 0x0E, 0x0B, 0x03, 0x01, 0x01, 0x06, 0x06, 0xFE, 0x5D, 0x03, 0x06, 0xFE,
/* 000083D0 */ 0xF6, 0x02, 0x05, 0xFE, 0xE9, 0x03, 0x2E, 0x2C, 0x07, 0x05, 0x14, 0x03, 0x00, 0x07, 0x02, 0x09,
/* 000083E0 */ 0x06, 0x00, 0x47, 0x00, 0x03, 0x09, 0x1B, 0x00, 0x8F, 0x02, 0x02, 0x07, 0x00, 0x00, 0x98, 0x07,
/* 000083F0 */ 0x07, 0x05, 0x00, 0x00, 0x47, 0x00, 0x07, 0x0F, 0x03, 0x00, 0x07, 0x47, 0x00, 0x04, 0x09, 0x02,
/* 00008400 */ 0x00, 0xA8, 0x00, 0x24, 0x00, 0xFF, 0x24, 0x07, 0x01, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x0B,
/* 00008410 */ 0x00, 0x3C, 0x00, 0x06, 0x00, 0x31, 0x00, 0x1B, 0x00, 0x45, 0x00, 0x00, 0x3F, 0x5D, 0x8C, 0xE0,
/* 00008420 */ 0x81, 0xC6, 0x02, 0xFE, 0x0F, 0x05, 0x0C, 0xA3, 0x41, 0xC1, 0x00, 0xFE, 0x02, 0x04, 0x40, 0xFE,
/* 00008430 */ 0x30, 0xFB, 0x01, 0xFF, 0x00, 0x10, 0x01, 0x00, 0x02, 0x02, 0xFE, 0x30, 0xFB, 0xFE, 0xC7, 0x09,
/* 00008440 */ 0xFE, 0xC7, 0x09, 0x02, 0x06, 0x17, 0x1B, 0x05, 0xCC, 0xCA, 0x03, 0x0D, 0x02, 0x07, 0x05, 0x05,
/* 00008450 */ 0x05, 0x05, 0x18, 0x19, 0x1A, 0x05, 0xFE, 0x12, 0x04, 0x05, 0xFE, 0x13, 0x04, 0x05, 0xFE, 0x14,
/* 00008460 */ 0x04, 0x08, 0x05, 0xFE, 0x15, 0x04, 0x05, 0xFE, 0x16, 0x04, 0x05, 0xFE, 0x17, 0x04, 0x05, 0xFE,
/* 00008470 */ 0x18, 0x04, 0x06, 0xFE, 0xB4, 0x03, 0x05, 0xFE, 0x19, 0x04, 0x05, 0xFE, 0x1A, 0x04, 0x05, 0xFE,
/* 00008480 */ 0x1B, 0x04, 0x05, 0xFE, 0x1C, 0x04, 0x06, 0xFE, 0x0E, 0x04, 0x05, 0xFE, 0x1D, 0x04, 0x05, 0xFE,
/* 00008490 */ 0x1E, 0x04, 0x06, 0xFE, 0x0F, 0x04, 0x06, 0xFE, 0x10, 0x04, 0x06, 0xFE, 0x11, 0x04, 0x01, 0x00,
/* 000084A0 */ 0x06, 0xFE, 0x1F, 0x04, 0xFE, 0x57, 0x03, 0x96, 0x03, 0x17, 0xCE, 0x1B, 0x00, 0x00, 0x00, 0x96,
/* 000084B0 */ 0x02, 0x1B, 0x93, 0x03, 0x1B, 0x00, 0x00, 0x62, 0x1B, 0x1B, 0x00, 0x0F, 0x03, 0x00, 0x1B, 0x09,
/* 000084C0 */ 0x86, 0x00, 0x93, 0x03, 0x1B, 0x00, 0x00, 0x62, 0x1B, 0x1B, 0x00, 0x14, 0x14, 0x00, 0x1B, 0x02,
/* 000084D0 */ 0x09, 0x00, 0x00, 0x93, 0x03, 0x1B, 0x00, 0x00, 0x62, 0x1B, 0x1B, 0x00, 0x14, 0x03, 0x00, 0x1B,
/* 000084E0 */ 0x03, 0x09, 0x2B, 0x00, 0x8F, 0x03, 0x0C, 0x1B, 0x01, 0x00, 0x07, 0x04, 0x00, 0x5C, 0x00, 0x05,
/* 000084F0 */ 0x8F, 0x03, 0x1E, 0x1C, 0x02, 0x00, 0x5C, 0x01, 0x1C, 0x93, 0x02, 0x1C, 0x03, 0x00, 0x5C, 0x02,
/* 00008500 */ 0x1C, 0x5D, 0x03, 0x04, 0x00, 0x00, 0xEE, 0x04, 0xFF, 0x1B, 0x00, 0x00, 0x09, 0x39, 0x00, 0x93,
/* 00008510 */ 0x03, 0x1B, 0x00, 0x00, 0x62, 0x1B, 0x1B, 0x00, 0x14, 0x03, 0x00, 0x1B, 0x06, 0x09, 0x28, 0x00,
/* 00008520 */ 0x8F, 0x03, 0x0C, 0x1B, 0x01, 0x00, 0x07, 0x04, 0x00, 0x5C, 0x00, 0x05, 0x8F, 0x03, 0x1E, 0x1C,
/* 00008530 */ 0x02, 0x00, 0x5C, 0x01, 0x1C, 0x93, 0x02, 0x1C, 0x03, 0x00, 0x5C, 0x02, 0x1C, 0x5D, 0x03, 0x07,
/* 00008540 */ 0x01, 0x00, 0xEE, 0x04, 0xFF, 0x1B, 0x01, 0x00, 0x93, 0x03, 0x1B, 0x00, 0x00, 0x62, 0x1B, 0x1B,
/* 00008550 */ 0x01, 0x0F, 0x03, 0x00, 0x1B, 0x09, 0x75, 0x00, 0x93, 0x03, 0x1B, 0x00, 0x00, 0x62, 0x1B, 0x1B,
/* 00008560 */ 0x01, 0x14, 0x03, 0x00, 0x1B, 0x08, 0x09, 0x2B, 0x00, 0x8F, 0x03, 0x0C, 0x1B, 0x01, 0x00, 0x07,
/* 00008570 */ 0x04, 0x00, 0x5C, 0x00, 0x05, 0x8F, 0x03, 0x1E, 0x1C, 0x02, 0x00, 0x5C, 0x01, 0x1C, 0x93, 0x02,
/* 00008580 */ 0x1C, 0x03, 0x00, 0x5C, 0x02, 0x1C, 0x5D, 0x03, 0x09, 0x02, 0x00, 0xEE, 0x04, 0xFF, 0x1B, 0x02,
/* 00008590 */ 0x00, 0x09, 0x39, 0x00, 0x93, 0x03, 0x1B, 0x00, 0x00, 0x62, 0x1B, 0x1B, 0x01, 0x14, 0x03, 0x00,
/* 000085A0 */ 0x1B, 0x0A, 0x09, 0x28, 0x00, 0x8F, 0x03, 0x0C, 0x1B, 0x01, 0x00, 0x07, 0x04, 0x00, 0x5C, 0x00,
/* 000085B0 */ 0x05, 0x8F, 0x03, 0x1E, 0x1C, 0x02, 0x00, 0x5C, 0x01, 0x1C, 0x93, 0x02, 0x1C, 0x03, 0x00, 0x5C,
/* 000085C0 */ 0x02, 0x1C, 0x5D, 0x03, 0x0B, 0x03, 0x00, 0xEE, 0x04, 0xFF, 0x1B, 0x03, 0x00, 0x93, 0x03, 0x1B,
/* 000085D0 */ 0x00, 0x00, 0x62, 0x1B, 0x1B, 0x02, 0x0F, 0x03, 0x00, 0x1B, 0x09, 0xD3, 0x00, 0x93, 0x03, 0x1B,
/* 000085E0 */ 0x00, 0x00, 0x62, 0x1B, 0x1B, 0x02, 0x14, 0x14, 0x00, 0x1B, 0x08, 0x09, 0x00, 0x00, 0x93, 0x03,
/* 000085F0 */ 0x1B, 0x00, 0x00, 0x62, 0x1B, 0x1B, 0x02, 0x14, 0x03, 0x00, 0x1B, 0x0A, 0x09, 0x2B, 0x00, 0x8F,
/* 00008600 */ 0x03, 0x0C, 0x1B, 0x01, 0x00, 0x07, 0x04, 0x00, 0x5C, 0x00, 0x05, 0x8F, 0x03, 0x1E, 0x1C, 0x02,
/* 00008610 */ 0x00, 0x5C, 0x01, 0x1C, 0x93, 0x02, 0x1C, 0x03, 0x00, 0x5C, 0x02, 0x1C, 0x5D, 0x03, 0x0C, 0x04,
/* 00008620 */ 0x00, 0xEE, 0x04, 0xFF, 0x1B, 0x04, 0x00, 0x09, 0x86, 0x00, 0x93, 0x03, 0x1B, 0x00, 0x00, 0x62,
/* 00008630 */ 0x1B, 0x1B, 0x02, 0x14, 0x14, 0x00, 0x1B, 0x03, 0x09, 0x00, 0x00, 0x93, 0x03, 0x1B, 0x00, 0x00,
/* 00008640 */ 0x62, 0x1B, 0x1B, 0x02, 0x14, 0x03, 0x00, 0x1B, 0x02, 0x09, 0x2B, 0x00, 0x8F, 0x03, 0x0C, 0x1B,
/* 00008650 */ 0x01, 0x00, 0x07, 0x04, 0x00, 0x5C, 0x00, 0x05, 0x8F, 0x03, 0x1E, 0x1C, 0x02, 0x00, 0x5C, 0x01,
/* 00008660 */ 0x1C, 0x93, 0x02, 0x1C, 0x03, 0x00, 0x5C, 0x02, 0x1C, 0x5D, 0x03, 0x0D, 0x05, 0x00, 0xEE, 0x04,
/* 00008670 */ 0xFF, 0x1B, 0x05, 0x00, 0x09, 0x39, 0x00, 0x93, 0x03, 0x1B, 0x00, 0x00, 0x62, 0x1B, 0x1B, 0x02,
/* 00008680 */ 0x14, 0x03, 0x00, 0x1B, 0x06, 0x09, 0x28, 0x00, 0x8F, 0x03, 0x0C, 0x1B, 0x01, 0x00, 0x07, 0x04,
/* 00008690 */ 0x00, 0x5C, 0x00, 0x05, 0x8F, 0x03, 0x1E, 0x1C, 0x02, 0x00, 0x5C, 0x01, 0x1C, 0x93, 0x02, 0x1C,
/* 000086A0 */ 0x03, 0x00, 0x5C, 0x02, 0x1C, 0x5D, 0x03, 0x0E, 0x06, 0x00, 0xEE, 0x04, 0xFF, 0x1B, 0x06, 0x00,
/* 000086B0 */ 0x93, 0x03, 0x1B, 0x00, 0x00, 0x62, 0x1B, 0x1B, 0x03, 0x0F, 0x03, 0x00, 0x1B, 0x09, 0x28, 0x00,
/* 000086C0 */ 0x8F, 0x03, 0x0C, 0x1B, 0x01, 0x00, 0x07, 0x04, 0x00, 0x5C, 0x00, 0x05, 0x8F, 0x03, 0x1E, 0x1C,
/* 000086D0 */ 0x02, 0x00, 0x5C, 0x01, 0x1C, 0x93, 0x02, 0x1C, 0x03, 0x00, 0x5C, 0x02, 0x1C, 0x5D, 0x03, 0x0F,
/* 000086E0 */ 0x07, 0x00, 0xEE, 0x04, 0xFF, 0x1B, 0x07, 0x00, 0x93, 0x03, 0x1B, 0x00, 0x00, 0x62, 0x1B, 0x1B,
/* 000086F0 */ 0x04, 0x0F, 0x03, 0x00, 0x1B, 0x09, 0x75, 0x00, 0x93, 0x03, 0x1B, 0x00, 0x00, 0x62, 0x1B, 0x1B,
/* 00008700 */ 0x04, 0x14, 0x03, 0x00, 0x1B, 0x03, 0x09, 0x2B, 0x00, 0x8F, 0x03, 0x0C, 0x1B, 0x01, 0x00, 0x07,
/* 00008710 */ 0x04, 0x00, 0x5C, 0x00, 0x05, 0x8F, 0x03, 0x1E, 0x1C, 0x02, 0x00, 0x5C, 0x01, 0x1C, 0x93, 0x02,
/* 00008720 */ 0x1C, 0x03, 0x00, 0x5C, 0x02, 0x1C, 0x5D, 0x03, 0x10, 0x08, 0x00, 0xEE, 0x04, 0xFF, 0x1B, 0x08,
/* 00008730 */ 0x00, 0x09, 0x39, 0x00, 0x93, 0x03, 0x1B, 0x00, 0x00, 0x62, 0x1B, 0x1B, 0x04, 0x14, 0x03, 0x00,
/* 00008740 */ 0x1B, 0x06, 0x09, 0x28, 0x00, 0x8F, 0x03, 0x0C, 0x1B, 0x01, 0x00, 0x07, 0x04, 0x00, 0x5C, 0x00,
/* 00008750 */ 0x05, 0x8F, 0x03, 0x1E, 0x1C, 0x02, 0x00, 0x5C, 0x01, 0x1C, 0x93, 0x02, 0x1C, 0x03, 0x00, 0x5C,
/* 00008760 */ 0x02, 0x1C, 0x5D, 0x03, 0x11, 0x09, 0x00, 0xEE, 0x04, 0xFF, 0x1B, 0x09, 0x00, 0x8F, 0x03, 0x0C,
/* 00008770 */ 0x1B, 0x01, 0x00, 0x07, 0x04, 0x00, 0x5C, 0x00, 0x05, 0x8F, 0x03, 0x1C, 0x1C, 0x04, 0x00, 0x5C,
/* 00008780 */ 0x01, 0x1C, 0xCE, 0x1C, 0x03, 0x01, 0x00, 0xA1, 0x00, 0x12, 0x1C, 0xA1, 0x01, 0x13, 0x1C, 0xA1,
/* 00008790 */ 0x02, 0x14, 0x1C, 0x5C, 0x02, 0x1C, 0xD4, 0x00, 0x1C, 0x5C, 0x03, 0x1C, 0xEE, 0x04, 0xFF, 0x1B,
/* 000087A0 */ 0x0A, 0x00, 0x8F, 0x03, 0x0B, 0x1B, 0x05, 0x00, 0x07, 0x02, 0x00, 0x5C, 0x00, 0x05, 0x93, 0x02,
/* 000087B0 */ 0x1C, 0x03, 0x00, 0x5C, 0x01, 0x1C, 0xEE, 0x02, 0x1B, 0x1B, 0x0B, 0x00, 0x11, 0x03, 0x00, 0x1B,
/* 000087C0 */ 0x15, 0x09, 0x2E, 0x00, 0x8F, 0x03, 0x0C, 0x1B, 0x01, 0x00, 0x07, 0x04, 0x00, 0x5C, 0x00, 0x05,
/* 000087D0 */ 0x8F, 0x03, 0x1F, 0x1C, 0x06, 0x00, 0x5C, 0x01, 0x1C, 0x93, 0x02, 0x1C, 0x03, 0x00, 0x5C, 0x02,
/* 000087E0 */ 0x1C, 0x5D, 0x03, 0x16, 0x0C, 0x00, 0xEE, 0x04, 0x1B, 0x1B, 0x0C, 0x00, 0x47, 0x00, 0x1B, 0x09,
/* 000087F0 */ 0x05, 0x00, 0xA8, 0x1B, 0x47, 0x00, 0x1B, 0x09, 0x02, 0x00, 0xA8, 0x00, 0x24, 0x00, 0xFE, 0x7B,
/* 00008800 */ 0x02, 0xFE, 0x7C, 0x02, 0xFE, 0x7D, 0x02, 0xFE, 0x7E, 0x02, 0xFE, 0x84, 0x02, 0xFE, 0x20, 0x04,
/* 00008810 */ 0xFE, 0xFB, 0x01, 0xFE, 0x72, 0xFB, 0x1C, 0x03, 0x00, 0x00, 0x00, 0x08, 0x00, 0x26, 0x00, 0x10,
/* 00008820 */ 0x00, 0x2C, 0x00, 0x22, 0x00, 0x5C, 0x00, 0x2B, 0x00, 0x64, 0x00, 0x11, 0x00, 0x3B, 0x00, 0x28,
/* 00008830 */ 0x00, 0xAA, 0x00, 0x10, 0x00, 0x29, 0x00, 0x11, 0x00, 0x3B, 0x00, 0x2B, 0x00, 0x5F, 0x00, 0x11,
/* 00008840 */ 0x00, 0x3B, 0x00, 0x28, 0x00, 0x79, 0x00, 0x10, 0x00, 0x2A, 0x00, 0x22, 0x00, 0x5B, 0x00, 0x2B,
/* 00008850 */ 0x00, 0x5B, 0x00, 0x22, 0x00, 0x58, 0x00, 0x2B, 0x00, 0x60, 0x00, 0x11, 0x00, 0x39, 0x00, 0x28,
/* 00008860 */ 0x00, 0x7A, 0x00, 0x10, 0x00, 0x28, 0x00, 0x28, 0x00, 0x5C, 0x00, 0x10, 0x00, 0x31, 0x00, 0x11,
/* 00008870 */ 0x00, 0x41, 0x00, 0x2B, 0x00, 0x63, 0x00, 0x11, 0x00, 0x40, 0x00, 0x28, 0x00, 0x7D, 0x00, 0x35,
/* 00008880 */ 0x00, 0x42, 0x01, 0x5A, 0x00, 0x73, 0x00, 0x00, 0x8C, 0x88, 0x00, 0x00, 0xBF, 0x5C, 0x85, 0x00,
/* 00008890 */ 0x00, 0xC4, 0x00, 0xFE, 0x39, 0x05, 0x55, 0xA2, 0x41, 0xD1, 0x00, 0x41, 0xFF, 0x86, 0x03, 0x01,
/* 000088A0 */ 0x00, 0xFF, 0x00, 0x10, 0x01, 0x00, 0x02, 0x02, 0xFF, 0x86, 0x03, 0x01, 0x00, 0xB0, 0xB0, 0x41,
/* 000088B0 */ 0x04, 0x03, 0x05, 0x05, 0x10, 0x10, 0x04, 0x01, 0x01, 0x04, 0x04, 0x08, 0x3E, 0x8F, 0x01, 0x03,
/* 000088C0 */ 0x05, 0x00, 0x00, 0x98, 0x05, 0x05, 0x03, 0x00, 0x00, 0x0F, 0x03, 0x00, 0x05, 0x09, 0x27, 0x00,
/* 000088D0 */ 0x8F, 0x04, 0x0C, 0x05, 0x01, 0x00, 0x07, 0x04, 0x00, 0x5C, 0x00, 0x02, 0x8F, 0x04, 0x1E, 0x06,
/* 000088E0 */ 0x02, 0x00, 0x5C, 0x01, 0x06, 0x8F, 0x01, 0x02, 0x06, 0x03, 0x00, 0x5C, 0x02, 0x06, 0x5C, 0x03,
/* 000088F0 */ 0x03, 0xEE, 0x04, 0xFF, 0x05, 0x00, 0x00, 0xA8, 0x00, 0x24, 0x00, 0xFF, 0xAC, 0x03, 0x01, 0x00,
/* 00008900 */ 0x03, 0x00, 0x00, 0x00, 0x00, 0x13, 0x00, 0x2D, 0x00, 0x29, 0x00, 0x5C, 0x00, 0x00, 0xBF, 0x5C,
/* 00008910 */ 0x84, 0xE0, 0x09, 0xC4, 0x10, 0xFE, 0xDC, 0x04, 0x0C, 0xA3, 0x41, 0xC1, 0x00, 0xFE, 0x01, 0x04,
/* 00008920 */ 0x3F, 0xFE, 0x44, 0xF1, 0xFF, 0x00, 0x10, 0x01, 0x00, 0x04, 0x04, 0xFE, 0x44, 0xF1, 0xFE, 0x51,
/* 00008930 */ 0x09, 0xFE, 0x51, 0x09, 0x01, 0x07, 0x15, 0x1A, 0x05, 0x93, 0x8D, 0x03, 0x08, 0x03, 0x0C, 0x0C,
/* 00008940 */ 0x0C, 0x0C, 0x06, 0x19, 0x07, 0x08, 0x0B, 0x06, 0xFE, 0x08, 0x04, 0x05, 0xFE, 0x09, 0x04, 0x0C,
/* 00008950 */ 0x05, 0xFE, 0x0A, 0x04, 0x06, 0xFE, 0x0B, 0x04, 0x06, 0xFE, 0x0C, 0x04, 0x06, 0xFE, 0xE5, 0x02,
/* 00008960 */ 0x06, 0xFE, 0xB4, 0x03, 0x06, 0xFE, 0xFE, 0x02, 0x06, 0xFE, 0xFF, 0x02, 0x06, 0xFE, 0x00, 0x03,
/* 00008970 */ 0x06, 0xFE, 0x0D, 0x04, 0x06, 0xFE, 0x0E, 0x04, 0x06, 0xFE, 0x0F, 0x04, 0x06, 0xFE, 0x10, 0x04,
/* 00008980 */ 0x06, 0xFE, 0x11, 0x04, 0xFE, 0x6B, 0x02, 0xA8, 0x1A, 0x14, 0x03, 0x00, 0x15, 0x1A, 0x09, 0x22,
/* 00008990 */ 0x00, 0x8F, 0x03, 0x0A, 0x1A, 0x00, 0x00, 0x07, 0x03, 0x00, 0x5C, 0x00, 0x03, 0xCB, 0x1B, 0x5C,
/* 000089A0 */ 0x01, 0x1B, 0x5D, 0x02, 0x02, 0x00, 0x00, 0xEE, 0x03, 0x1A, 0x1A, 0x00, 0x00, 0x47, 0x15, 0x1A,
/* 000089B0 */ 0x09, 0x20, 0x00, 0x8F, 0x03, 0x31, 0x1B, 0x01, 0x00, 0x6D, 0x1A, 0x1B, 0x00, 0x07, 0x02, 0x00,
/* 000089C0 */ 0x5C, 0x00, 0x1B, 0x5C, 0x01, 0x15, 0xF2, 0x02, 0x1A, 0x1A, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
/* 000089D0 */ 0x47, 0x15, 0x1A, 0x47, 0x18, 0x04, 0x14, 0x0B, 0x00, 0x16, 0x05, 0x09, 0x00, 0x00, 0x14, 0x03,
/* 000089E0 */ 0x00, 0x16, 0x06, 0x09, 0x3B, 0x00, 0x62, 0x1A, 0x15, 0x01, 0xA8, 0x1B, 0x15, 0x2D, 0x00, 0x1A,
/* 000089F0 */ 0x1B, 0x09, 0x00, 0x00, 0x62, 0x1A, 0x15, 0x02, 0xA8, 0x1B, 0x15, 0x1F, 0x00, 0x1A, 0x1B, 0x09,
/* 00008A00 */ 0x00, 0x00, 0x62, 0x1A, 0x15, 0x03, 0xA8, 0x1B, 0x15, 0x11, 0x00, 0x1A, 0x1B, 0x09, 0x00, 0x00,
/* 00008A10 */ 0x62, 0x1A, 0x15, 0x04, 0xA8, 0x1B, 0x15, 0x03, 0x00, 0x1A, 0x1B, 0x09, 0x03, 0x00, 0x47, 0x18,
/* 00008A20 */ 0x07, 0x14, 0x0B, 0x00, 0x16, 0x08, 0x09, 0x00, 0x00, 0x14, 0x03, 0x00, 0x16, 0x06, 0x09, 0x2D,
/* 00008A30 */ 0x00, 0x62, 0x1A, 0x15, 0x05, 0xA8, 0x1B, 0x15, 0x1F, 0x00, 0x1A, 0x1B, 0x09, 0x00, 0x00, 0x62,
/* 00008A40 */ 0x1A, 0x15, 0x06, 0xA8, 0x1B, 0x15, 0x11, 0x00, 0x1A, 0x1B, 0x09, 0x00, 0x00, 0x62, 0x1A, 0x15,
/* 00008A50 */ 0x07, 0xA8, 0x1B, 0x15, 0x03, 0x00, 0x1A, 0x1B, 0x09, 0x03, 0x00, 0x47, 0x18, 0x07, 0x0F, 0x03,
/* 00008A60 */ 0x00, 0x18, 0x09, 0xBE, 0x00, 0x14, 0x0B, 0x00, 0x17, 0x05, 0x09, 0x00, 0x00, 0x14, 0x03, 0x00,
/* 00008A70 */ 0x17, 0x09, 0x09, 0xAE, 0x00, 0x8F, 0x03, 0x1B, 0x1A, 0x02, 0x00, 0x07, 0x04, 0x00, 0x5C, 0x00,
/* 00008A80 */ 0x03, 0x5C, 0x01, 0x15, 0x5D, 0x02, 0x0A, 0x02, 0x00, 0xCC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
/* 00008A90 */ 0x00, 0x00, 0x1B, 0x00, 0x00, 0x00, 0x7B, 0x0C, 0x1B, 0x08, 0x7B, 0x04, 0x1B, 0x09, 0x7B, 0x04,
/* 00008AA0 */ 0x1B, 0x0A, 0x7B, 0x04, 0x1B, 0x0B, 0x5C, 0x03, 0x1B, 0xEE, 0x04, 0xFF, 0x1A, 0x02, 0x00, 0x8F,
/* 00008AB0 */ 0x03, 0x1B, 0x1A, 0x02, 0x00, 0x07, 0x04, 0x00, 0x5C, 0x00, 0x03, 0x5C, 0x01, 0x15, 0x5D, 0x02,
/* 00008AC0 */ 0x10, 0x03, 0x00, 0xCC, 0x18, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x1B, 0x00, 0x00, 0x00,
/* 00008AD0 */ 0x7B, 0x0C, 0x1B, 0x08, 0x7B, 0x04, 0x1B, 0x09, 0x7B, 0x04, 0x1B, 0x0A, 0x7B, 0x04, 0x1B, 0x0B,
/* 00008AE0 */ 0x5C, 0x03, 0x1B, 0xEE, 0x04, 0xFF, 0x1A, 0x03, 0x00, 0x8F, 0x03, 0x1B, 0x1A, 0x02, 0x00, 0x07,
/* 00008AF0 */ 0x04, 0x00, 0x5C, 0x00, 0x03, 0x5C, 0x01, 0x15, 0x5D, 0x02, 0x11, 0x04, 0x00, 0xCC, 0x30, 0x00,
/* 00008B00 */ 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x1B, 0x00, 0x00, 0x00, 0x7B, 0x0C, 0x1B, 0x08, 0x7B, 0x04,
/* 00008B10 */ 0x1B, 0x09, 0x7B, 0x04, 0x1B, 0x0A, 0x7B, 0x04, 0x1B, 0x0B, 0x5C, 0x03, 0x1B, 0xEE, 0x04, 0xFF,
/* 00008B20 */ 0x1A, 0x04, 0x00, 0x0F, 0x03, 0x00, 0x18, 0x09, 0xBE, 0x00, 0x14, 0x0B, 0x00, 0x17, 0x08, 0x09,
/* 00008B30 */ 0x00, 0x00, 0x14, 0x03, 0x00, 0x17, 0x09, 0x09, 0xAE, 0x00, 0x8F, 0x03, 0x1B, 0x1A, 0x02, 0x00,
/* 00008B40 */ 0x07, 0x04, 0x00, 0x5C, 0x00, 0x03, 0x5C, 0x01, 0x15, 0x5D, 0x02, 0x12, 0x05, 0x00, 0xCC, 0x48,
/* 00008B50 */ 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x1B, 0x00, 0x00, 0x00, 0x7B, 0x0C, 0x1B, 0x08, 0x7B,
/* 00008B60 */ 0x04, 0x1B, 0x09, 0x7B, 0x04, 0x1B, 0x0A, 0x7B, 0x04, 0x1B, 0x0B, 0x5C, 0x03, 0x1B, 0xEE, 0x04,
/* 00008B70 */ 0xFF, 0x1A, 0x05, 0x00, 0x8F, 0x03, 0x1B, 0x1A, 0x02, 0x00, 0x07, 0x04, 0x00, 0x5C, 0x00, 0x03,
/* 00008B80 */ 0x5C, 0x01, 0x15, 0x5D, 0x02, 0x13, 0x06, 0x00, 0xCC, 0x60, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00,
/* 00008B90 */ 0x00, 0x1B, 0x00, 0x00, 0x00, 0x7B, 0x0C, 0x1B, 0x08, 0x7B, 0x04, 0x1B, 0x09, 0x7B, 0x04, 0x1B,
/* 00008BA0 */ 0x0A, 0x7B, 0x04, 0x1B, 0x0B, 0x5C, 0x03, 0x1B, 0xEE, 0x04, 0xFF, 0x1A, 0x06, 0x00, 0x8F, 0x03,
/* 00008BB0 */ 0x1B, 0x1A, 0x02, 0x00, 0x07, 0x04, 0x00, 0x5C, 0x00, 0x03, 0x5C, 0x01, 0x15, 0x5D, 0x02, 0x14,
/* 00008BC0 */ 0x07, 0x00, 0xCC, 0x78, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x1B, 0x00, 0x00, 0x00, 0x7B,
/* 00008BD0 */ 0x0C, 0x1B, 0x08, 0x7B, 0x04, 0x1B, 0x09, 0x7B, 0x04, 0x1B, 0x0A, 0x7B, 0x04, 0x1B, 0x0B, 0x5C,
/* 00008BE0 */ 0x03, 0x1B, 0xEE, 0x04, 0xFF, 0x1A, 0x07, 0x00, 0x47, 0x00, 0x15, 0x09, 0x02, 0x00, 0xA8, 0x00,
/* 00008BF0 */ 0x24, 0x00, 0x06, 0x90, 0x00, 0x78, 0x00, 0x00, 0x00, 0x03, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00,
/* 00008C00 */ 0x00, 0xB4, 0x01, 0x00, 0x00, 0xB3, 0x01, 0x00, 0x00, 0xB1, 0x01, 0x00, 0x00, 0xB2, 0x01, 0x00,
/* 00008C10 */ 0x00, 0x60, 0x00, 0x00, 0x00, 0x03, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xB4, 0x01, 0x00,
/* 00008C20 */ 0x00, 0xB3, 0x01, 0x00, 0x00, 0xB1, 0x01, 0x00, 0x00, 0xB2, 0x01, 0x00, 0x00, 0x48, 0x00, 0x00,
/* 00008C30 */ 0x00, 0x03, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xB4, 0x01, 0x00, 0x00, 0xB3, 0x01, 0x00,
/* 00008C40 */ 0x00, 0xB1, 0x01, 0x00, 0x00, 0xB2, 0x01, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x03, 0x04, 0x00,
/* 00008C50 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0xB4, 0x01, 0x00, 0x00, 0xB3, 0x01, 0x00, 0x00, 0xB1, 0x01, 0x00,
/* 00008C60 */ 0x00, 0xB2, 0x01, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x03, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00,
/* 00008C70 */ 0x00, 0xB4, 0x01, 0x00, 0x00, 0xB3, 0x01, 0x00, 0x00, 0xB1, 0x01, 0x00, 0x00, 0xB2, 0x01, 0x00,
/* 00008C80 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xB4, 0x01, 0x00,
/* 00008C90 */ 0x00, 0xB3, 0x01, 0x00, 0x00, 0xB1, 0x01, 0x00, 0x00, 0xB2, 0x01, 0x00, 0x00, 0xFE, 0x51, 0x03,
/* 00008CA0 */ 0xFE, 0x7B, 0x02, 0xFE, 0x7C, 0x02, 0xFE, 0x7D, 0x02, 0xFE, 0x7E, 0x02, 0xFE, 0x80, 0x02, 0xFE,
/* 00008CB0 */ 0x7F, 0x02, 0xFE, 0x81, 0x02, 0xFE, 0xB4, 0x01, 0xFE, 0xB3, 0x01, 0xFE, 0xB1, 0x01, 0xFE, 0xB2,
/* 00008CC0 */ 0x01, 0xFE, 0x8F, 0xF1, 0x14, 0x00, 0x00, 0x00, 0x00, 0x0A, 0x00, 0x32, 0x00, 0x22, 0x00, 0x51,
/* 00008CD0 */ 0x00, 0x20, 0x00, 0x4C, 0x00, 0x03, 0x00, 0x2A, 0x00, 0x10, 0x00, 0x46, 0x00, 0x38, 0x00, 0x98,
/* 00008CE0 */ 0x00, 0x03, 0x00, 0x51, 0x00, 0x10, 0x00, 0x46, 0x00, 0x2A, 0x00, 0x7B, 0x00, 0x03, 0x00, 0x53,
/* 00008CF0 */ 0x00, 0x17, 0x00, 0x58, 0x00, 0x3A, 0x00, 0xCF, 0x00, 0x3A, 0x00, 0xD0, 0x00, 0x3A, 0x00, 0xDD,
/* 00008D00 */ 0x00, 0x17, 0x00, 0x58, 0x00, 0x3A, 0x00, 0xCF, 0x00, 0x3A, 0x00, 0xD1, 0x00, 0x3A, 0x00, 0xE0,
/* 00008D10 */ 0x00, 0x08, 0x00, 0x1D, 0x00, 0x00, 0x3F, 0x5D, 0x8C, 0xE0, 0xA9, 0xD6, 0x92, 0xFE, 0xC7, 0x03,
/* 00008D20 */ 0x18, 0xA0, 0x41, 0xD1, 0x00, 0x36, 0xFE, 0xDB, 0xB6, 0x06, 0xFF, 0x00, 0x10, 0x01, 0x00, 0x01,
/* 00008D30 */ 0x01, 0xFE, 0xDB, 0xB6, 0xFE, 0x6E, 0x39, 0xFE, 0x6E, 0x39, 0x03, 0x0D, 0x2D, 0x33, 0x09, 0xC5,
/* 00008D40 */ 0xC5, 0x01, 0x0E, 0x01, 0x09, 0x0F, 0x0F, 0x0F, 0x0F, 0x07, 0x02, 0x30, 0x31, 0x32, 0x33, 0x06,
/* 00008D50 */ 0xFE, 0xC1, 0x03, 0x01, 0x00, 0x06, 0xFE, 0xC2, 0x03, 0x06, 0xFE, 0xC3, 0x03, 0x01, 0x01, 0x06,
/* 00008D60 */ 0xFE, 0xC4, 0x03, 0x01, 0x02, 0x06, 0xFE, 0xC5, 0x03, 0x01, 0x03, 0x07, 0x08, 0x06, 0xFE, 0xC6,
/* 00008D70 */ 0x03, 0x06, 0xFE, 0xC7, 0x03, 0x06, 0xFE, 0xC8, 0x03, 0x06, 0xFE, 0xFC, 0x02, 0x06, 0xFE, 0xC9,
/* 00008D80 */ 0x03, 0x05, 0xFE, 0xCA, 0x03, 0x05, 0xFE, 0xCB, 0x03, 0x05, 0xFE, 0xCC, 0x03, 0x06, 0xFE, 0xE6,
/* 00008D90 */ 0x02, 0x06, 0xFE, 0xE5, 0x02, 0x06, 0xFE, 0xFE, 0x02, 0x0B, 0x06, 0xFE, 0x00, 0x03, 0x06, 0xFE,
/* 00008DA0 */ 0x48, 0x03, 0x06, 0xFE, 0xCD, 0x03, 0x05, 0xFE, 0xCE, 0x03, 0x05, 0xFE, 0xCF, 0x03, 0x05, 0xFE,
/* 00008DB0 */ 0xD0, 0x03, 0x05, 0xFE, 0xD1, 0x03, 0x05, 0xFE, 0xD2, 0x03, 0x05, 0xFE, 0xD3, 0x03, 0x06, 0xFE,
/* 00008DC0 */ 0xD4, 0x03, 0x06, 0xFE, 0xD5, 0x03, 0x05, 0xFE, 0xD6, 0x03, 0x06, 0xFE, 0x9F, 0x03, 0x0C, 0x06,
/* 00008DD0 */ 0xFE, 0xFF, 0x02, 0x06, 0xFE, 0xA0, 0x03, 0x06, 0xFE, 0xA1, 0x03, 0x06, 0xFE, 0xD7, 0x03, 0x06,
/* 00008DE0 */ 0xFE, 0xA3, 0x03, 0x05, 0xFE, 0xD8, 0x03, 0xFE, 0x80, 0x03, 0xA8, 0x2D, 0xA8, 0x2E, 0xA8, 0x2F,
/* 00008DF0 */ 0x4F, 0x35, 0x96, 0x03, 0x35, 0x4F, 0x35, 0x96, 0x04, 0x35, 0x8F, 0x01, 0x0A, 0x35, 0x00, 0x00,
/* 00008E00 */ 0x07, 0x03, 0x00, 0x5C, 0x00, 0x0C, 0xCC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x36,
/* 00008E10 */ 0x00, 0x00, 0x00, 0x7B, 0x03, 0x36, 0x00, 0x7B, 0x03, 0x36, 0x01, 0x7B, 0x06, 0x36, 0x02, 0x7B,
/* 00008E20 */ 0x08, 0x36, 0x03, 0x7B, 0x0A, 0x36, 0x04, 0x5C, 0x01, 0x36, 0x5D, 0x02, 0x0B, 0x00, 0x00, 0xEE,
/* 00008E30 */ 0x03, 0x35, 0x35, 0x00, 0x00, 0x96, 0x03, 0x35, 0x8F, 0x01, 0x0A, 0x35, 0x00, 0x00, 0x07, 0x03,
/* 00008E40 */ 0x00, 0x5C, 0x00, 0x0C, 0xCC, 0x1C, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x36, 0x00, 0x00,
/* 00008E50 */ 0x00, 0x7B, 0x03, 0x36, 0x00, 0x7B, 0x03, 0x36, 0x05, 0x7B, 0x06, 0x36, 0x06, 0x7B, 0x08, 0x36,
/* 00008E60 */ 0x07, 0x7B, 0x0A, 0x36, 0x04, 0x5C, 0x01, 0x36, 0x5D, 0x02, 0x0B, 0x01, 0x00, 0xEE, 0x03, 0x35,
/* 00008E70 */ 0x35, 0x01, 0x00, 0x96, 0x04, 0x35, 0x8F, 0x01, 0x38, 0x35, 0x01, 0x00, 0x14, 0x11, 0x00, 0x35,
/* 00008E80 */ 0x10, 0x09, 0x00, 0x00, 0x8F, 0x01, 0x38, 0x35, 0x01, 0x00, 0x14, 0x03, 0x00, 0x35, 0x11, 0x09,
/* 00008E90 */ 0xCF, 0x02, 0xDE, 0x00, 0x03, 0x02, 0xB8, 0x35, 0x00, 0x01, 0x50, 0x01, 0x00, 0x2D, 0x35, 0x95,
/* 00008EA0 */ 0x00, 0x02, 0x2D, 0x8F, 0x01, 0x09, 0x36, 0x02, 0x00, 0x6D, 0x35, 0x36, 0x08, 0x07, 0x03, 0x00,
/* 00008EB0 */ 0x5C, 0x00, 0x36, 0x8F, 0x01, 0x2A, 0x37, 0x03, 0x00, 0x07, 0x03, 0x00, 0x5C, 0x00, 0x0C, 0x5D,
/* 00008EC0 */ 0x01, 0x12, 0x03, 0x00, 0xB8, 0x39, 0x00, 0x01, 0x50, 0x01, 0x01, 0x38, 0x39, 0x5C, 0x02, 0x38,
/* 00008ED0 */ 0xEE, 0x03, 0x37, 0x37, 0x03, 0x00, 0x5C, 0x01, 0x37, 0x5D, 0x02, 0x0A, 0x02, 0x00, 0xF2, 0x03,
/* 00008EE0 */ 0xFF, 0x35, 0x08, 0x00, 0x00, 0x00, 0x02, 0x00, 0x8F, 0x01, 0x38, 0x35, 0x01, 0x00, 0x14, 0x03,
/* 00008EF0 */ 0x00, 0x35, 0x10, 0x09, 0x6B, 0x02, 0xDE, 0x01, 0x04, 0x03, 0xB8, 0x35, 0x00, 0xB7, 0x01, 0x00,
/* 00008F00 */ 0x00, 0x00, 0x35, 0x35, 0x01, 0x50, 0x01, 0x02, 0x2E, 0x35, 0x95, 0x01, 0x02, 0x2E, 0x01, 0x50,
/* 00008F10 */ 0x01, 0x03, 0x2F, 0x35, 0x95, 0x01, 0x03, 0x2F, 0x8F, 0x01, 0x2A, 0x35, 0x03, 0x00, 0x07, 0x03,
/* 00008F20 */ 0x00, 0x5C, 0x00, 0x0C, 0x5D, 0x01, 0x13, 0x04, 0x00, 0x91, 0x01, 0x02, 0x36, 0x04, 0x00, 0x5C,
/* 00008F30 */ 0x02, 0x36, 0xEE, 0x03, 0xFF, 0x35, 0x04, 0x00, 0x8F, 0x01, 0x2A, 0x35, 0x03, 0x00, 0x07, 0x03,
/* 00008F40 */ 0x00, 0x5C, 0x00, 0x0C, 0x5D, 0x01, 0x14, 0x05, 0x00, 0x91, 0x01, 0x03, 0x36, 0x05, 0x00, 0x5C,
/* 00008F50 */ 0x02, 0x36, 0xEE, 0x03, 0xFF, 0x35, 0x05, 0x00, 0x8F, 0x01, 0x1B, 0x35, 0x06, 0x00, 0x07, 0x04,
/* 00008F60 */ 0x00, 0x5C, 0x00, 0x0C, 0x91, 0x01, 0x02, 0x36, 0x04, 0x00, 0x5C, 0x01, 0x36, 0x5D, 0x02, 0x15,
/* 00008F70 */ 0x06, 0x00, 0xCC, 0x38, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x36, 0x00, 0x00, 0x00, 0x8F,
/* 00008F80 */ 0x01, 0x47, 0x37, 0x07, 0x00, 0x4B, 0x37, 0x7B, 0x37, 0x36, 0x09, 0x7B, 0x18, 0x36, 0x0A, 0x7B,
/* 00008F90 */ 0x18, 0x36, 0x0B, 0x5C, 0x03, 0x36, 0xEE, 0x04, 0xFF, 0x35, 0x06, 0x00, 0xCE, 0x35, 0x0B, 0x00,
/* 00008FA0 */ 0x00, 0xA1, 0x00, 0x1A, 0x35, 0xA1, 0x01, 0x1B, 0x35, 0xA1, 0x02, 0x1C, 0x35, 0xA1, 0x03, 0x1D,
/* 00008FB0 */ 0x35, 0xA1, 0x04, 0x1E, 0x35, 0xA1, 0x05, 0x1F, 0x35, 0xA1, 0x06, 0x20, 0x35, 0xA1, 0x07, 0x21,
/* 00008FC0 */ 0x35, 0xA1, 0x08, 0x22, 0x35, 0xA1, 0x09, 0x23, 0x35, 0xA1, 0x0A, 0x24, 0x35, 0x96, 0x02, 0x35,
/* 00008FD0 */ 0x8F, 0x01, 0x1B, 0x35, 0x06, 0x00, 0x07, 0x04, 0x00, 0x5C, 0x00, 0x0C, 0x91, 0x01, 0x02, 0x36,
/* 00008FE0 */ 0x04, 0x00, 0x5C, 0x01, 0x36, 0x5D, 0x02, 0x25, 0x07, 0x00, 0xCC, 0x4C, 0x00, 0x00, 0x00, 0x03,
/* 00008FF0 */ 0x00, 0x00, 0x00, 0x36, 0x00, 0x00, 0x00, 0x91, 0x01, 0x02, 0x37, 0x04, 0x00, 0x07, 0x01, 0x00,
/* 00009000 */ 0xC3, 0x01, 0x37, 0x37, 0x08, 0x00, 0x7B, 0x37, 0x36, 0x09, 0x7B, 0x26, 0x36, 0x0A, 0x7B, 0x26,
/* 00009010 */ 0x36, 0x0C, 0x7B, 0x26, 0x36, 0x0B, 0x5C, 0x03, 0x36, 0xEE, 0x04, 0xFF, 0x35, 0x07, 0x00, 0x8F,
/* 00009020 */ 0x01, 0x0A, 0x35, 0x00, 0x00, 0x07, 0x03, 0x00, 0x5C, 0x00, 0x0C, 0x91, 0x01, 0x02, 0x36, 0x04,
/* 00009030 */ 0x00, 0x62, 0x36, 0x36, 0x0D, 0x5C, 0x01, 0x36, 0x8F, 0x01, 0x0E, 0x36, 0x08, 0x00, 0x62, 0x36,
/* 00009040 */ 0x36, 0x0D, 0x5C, 0x02, 0x36, 0xEE, 0x03, 0xFF, 0x35, 0x09, 0x00, 0x8F, 0x01, 0x1B, 0x35, 0x06,
/* 00009050 */ 0x00, 0x07, 0x04, 0x00, 0x5C, 0x00, 0x0C, 0x91, 0x01, 0x02, 0x36, 0x04, 0x00, 0x62, 0x36, 0x36,
/* 00009060 */ 0x0D, 0x5C, 0x01, 0x36, 0x5D, 0x02, 0x28, 0x0A, 0x00, 0xCC, 0x64, 0x00, 0x00, 0x00, 0x04, 0x00,
/* 00009070 */ 0x00, 0x00, 0x36, 0x00, 0x00, 0x00, 0x91, 0x01, 0x02, 0x37, 0x04, 0x00, 0x7B, 0x37, 0x36, 0x09,
/* 00009080 */ 0x7B, 0x18, 0x36, 0x0A, 0x7B, 0x26, 0x36, 0x0C, 0x7B, 0x18, 0x36, 0x0B, 0x5C, 0x03, 0x36, 0xEE,
/* 00009090 */ 0x04, 0xFF, 0x35, 0x0A, 0x00, 0x8F, 0x01, 0x1B, 0x35, 0x06, 0x00, 0x07, 0x04, 0x00, 0x5C, 0x00,
/* 000090A0 */ 0x0C, 0x91, 0x01, 0x02, 0x36, 0x04, 0x00, 0x62, 0x36, 0x36, 0x0D, 0x5C, 0x01, 0x36, 0x5D, 0x02,
/* 000090B0 */ 0x29, 0x0B, 0x00, 0xCC, 0x7C, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x36, 0x00, 0x00, 0x00,
/* 000090C0 */ 0xB8, 0x38, 0x00, 0xB7, 0x01, 0x00, 0x00, 0x00, 0x38, 0x38, 0x01, 0x50, 0x01, 0x04, 0x37, 0x38,
/* 000090D0 */ 0x7B, 0x37, 0x36, 0x09, 0x01, 0x64, 0x01, 0x37, 0x36, 0x7B, 0x18, 0x36, 0x0A, 0x7B, 0x26, 0x36,
/* 000090E0 */ 0x0C, 0x7B, 0x18, 0x36, 0x0B, 0x5C, 0x03, 0x36, 0xEE, 0x04, 0xFF, 0x35, 0x0B, 0x00, 0x8F, 0x01,
/* 000090F0 */ 0x1B, 0x35, 0x06, 0x00, 0x07, 0x04, 0x00, 0x5C, 0x00, 0x0C, 0x91, 0x01, 0x02, 0x36, 0x04, 0x00,
/* 00009100 */ 0x62, 0x36, 0x36, 0x0D, 0x5C, 0x01, 0x36, 0x5D, 0x02, 0x2A, 0x0C, 0x00, 0xCC, 0x94, 0x00, 0x00,
/* 00009110 */ 0x00, 0x06, 0x00, 0x00, 0x00, 0x36, 0x00, 0x00, 0x00, 0x8F, 0x01, 0x2A, 0x37, 0x03, 0x00, 0x07,
/* 00009120 */ 0x03, 0x00, 0x5C, 0x00, 0x0C, 0x5D, 0x01, 0x2C, 0x0D, 0x00, 0xB8, 0x39, 0x00, 0xB7, 0x01, 0x00,
/* 00009130 */ 0x00, 0x00, 0x39, 0x39, 0x01, 0x50, 0x01, 0x05, 0x38, 0x39, 0x5C, 0x02, 0x38, 0xEE, 0x03, 0x37,
/* 00009140 */ 0x37, 0x0D, 0x00, 0x7B, 0x37, 0x36, 0x0E, 0x7B, 0x26, 0x36, 0x0C, 0x7B, 0x18, 0x36, 0x0B, 0x5C,
/* 00009150 */ 0x03, 0x36, 0xEE, 0x04, 0xFF, 0x35, 0x0C, 0x00, 0x91, 0x01, 0x02, 0x00, 0x04, 0x00, 0x09, 0x07,
/* 00009160 */ 0x00, 0xA8, 0x00, 0x09, 0x02, 0x00, 0xA8, 0x00, 0x24, 0x00, 0x07, 0xA8, 0x00, 0x94, 0x00, 0x00,
/* 00009170 */ 0x00, 0x03, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xB5, 0x01, 0x00, 0x00, 0xB1, 0x01, 0x00,
/* 00009180 */ 0x00, 0xB2, 0x01, 0x00, 0x00, 0x7C, 0x00, 0x00, 0x00, 0x03, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00,
/* 00009190 */ 0x00, 0xB4, 0x01, 0x00, 0x00, 0xB3, 0x01, 0x00, 0x00, 0xB1, 0x01, 0x00, 0x00, 0xB2, 0x01, 0x00,
/* 000091A0 */ 0x00, 0x64, 0x00, 0x00, 0x00, 0x03, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xB4, 0x01, 0x00,
/* 000091B0 */ 0x00, 0xB3, 0x01, 0x00, 0x00, 0xB1, 0x01, 0x00, 0x00, 0xB2, 0x01, 0x00, 0x00, 0x4C, 0x00, 0x00,
/* 000091C0 */ 0x00, 0x03, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xB4, 0x01, 0x00, 0x00, 0xB3, 0x01, 0x00,
/* 000091D0 */ 0x00, 0xB1, 0x01, 0x00, 0x00, 0xB2, 0x01, 0x00, 0x00, 0x38, 0x00, 0x00, 0x00, 0x03, 0x03, 0x00,
/* 000091E0 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0xB4, 0x01, 0x00, 0x00, 0xB3, 0x01, 0x00, 0x00, 0xB2, 0x01, 0x00,
/* 000091F0 */ 0x00, 0x1C, 0x00, 0x00, 0x00, 0x03, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC1, 0x03, 0x00,
/* 00009200 */ 0x00, 0xC6, 0x03, 0x00, 0x00, 0xC7, 0x03, 0x00, 0x00, 0xC8, 0x03, 0x00, 0x00, 0xC5, 0x03, 0x00,
/* 00009210 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC1, 0x03, 0x00,
/* 00009220 */ 0x00, 0xC2, 0x03, 0x00, 0x00, 0xC3, 0x03, 0x00, 0x00, 0xC4, 0x03, 0x00, 0x00, 0xC5, 0x03, 0x00,
/* 00009230 */ 0x00, 0xFE, 0xC1, 0x03, 0xFE, 0xC2, 0x03, 0xFE, 0xC3, 0x03, 0xFE, 0xC4, 0x03, 0xFE, 0xC5, 0x03,
/* 00009240 */ 0xFE, 0xC6, 0x03, 0xFE, 0xC7, 0x03, 0xFE, 0xC8, 0x03, 0xFE, 0x32, 0x02, 0xFE, 0xB4, 0x01, 0xFE,
/* 00009250 */ 0xB3, 0x01, 0xFE, 0xB2, 0x01, 0xFE, 0xB1, 0x01, 0xFE, 0x46, 0x01, 0xFE, 0xB5, 0x01, 0xFE, 0xFB,
/* 00009260 */ 0x01, 0xFE, 0xD9, 0x03, 0xFE, 0xDA, 0x03, 0x02, 0x02, 0x01, 0x00, 0xFE, 0xDB, 0x03, 0x03, 0x02,
/* 00009270 */ 0x00, 0xFE, 0x1A, 0x02, 0x01, 0xFE, 0x1C, 0x02, 0xFE, 0x42, 0xB7, 0x11, 0x10, 0x00, 0x00, 0x00,
/* 00009280 */ 0x3E, 0x00, 0x9B, 0x01, 0x3E, 0x00, 0x13, 0x02, 0x2D, 0x00, 0x91, 0x1C, 0x45, 0x00, 0xBB, 0x02,
/* 00009290 */ 0x30, 0x00, 0x8D, 0x06, 0x20, 0x00, 0x4C, 0x03, 0x20, 0x00, 0x54, 0x00, 0x44, 0x00, 0x9D, 0x00,
/* 000092A0 */ 0x34, 0x00, 0x23, 0x01, 0x4F, 0x00, 0x9A, 0x00, 0x2C, 0x00, 0x49, 0x00, 0x4A, 0x00, 0xA0, 0x00,
/* 000092B0 */ 0x59, 0x00, 0xD8, 0x04, 0x6A, 0x00, 0x25, 0x03, 0x09, 0x00, 0x88, 0x00, 0x07, 0x00, 0x17, 0x00,
/* 000092C0 */ 0x00, 0x14, 0x9B, 0x00, 0x00, 0xA1, 0x99, 0x00, 0x00, 0x58, 0x97, 0x00, 0x00, 0xE2, 0x95, 0x00,
/* 000092D0 */ 0x00, 0xDD, 0x93, 0x00, 0x00, 0xD9, 0x92, 0x00, 0x00, 0xBF, 0x5C, 0x84, 0xE0, 0x01, 0xC4, 0x00,
/* 000092E0 */ 0xFE, 0xC3, 0x04, 0x39, 0xA0, 0x41, 0xD1, 0x00, 0x3D, 0xFE, 0xF7, 0xEC, 0xFF, 0x00, 0x10, 0x01,
/* 000092F0 */ 0x00, 0x01, 0x01, 0xFE, 0xF7, 0xEC, 0xFE, 0x61, 0x02, 0xFE, 0x61, 0x02, 0x01, 0x05, 0x05, 0x08,
/* 00009300 */ 0x04, 0x25, 0x24, 0x04, 0x03, 0x01, 0x04, 0x04, 0x04, 0x04, 0x07, 0x06, 0xFE, 0x85, 0x03, 0x05,
/* 00009310 */ 0xFE, 0xE3, 0x03, 0x06, 0xFE, 0x01, 0x03, 0x98, 0x5B, 0x05, 0xB4, 0x05, 0x05, 0x2C, 0x08, 0x05,
/* 00009320 */ 0x15, 0x03, 0x00, 0x08, 0x02, 0x09, 0x24, 0x00, 0x8F, 0x04, 0x09, 0x09, 0x00, 0x00, 0x6D, 0x08,
/* 00009330 */ 0x09, 0x00, 0x07, 0x03, 0x00, 0x5C, 0x00, 0x09, 0x5D, 0x01, 0x03, 0x00, 0x00, 0x5D, 0x02, 0x04,
/* 00009340 */ 0x00, 0x00, 0xF2, 0x03, 0xFF, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x8F, 0x04, 0x09, 0x09,
/* 00009350 */ 0x00, 0x00, 0x6D, 0x08, 0x09, 0x01, 0x07, 0x02, 0x00, 0x5C, 0x00, 0x09, 0x5C, 0x01, 0x05, 0xF2,
/* 00009360 */ 0x02, 0x08, 0x08, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x47, 0x06, 0x08, 0xA8, 0x08, 0x14, 0x0E,
/* 00009370 */ 0x00, 0x06, 0x08, 0x09, 0x00, 0x00, 0x62, 0x08, 0x06, 0x02, 0x0F, 0x27, 0x00, 0x08, 0x09, 0x00,
/* 00009380 */ 0x00, 0x8F, 0x04, 0x09, 0x09, 0x00, 0x00, 0x6D, 0x08, 0x09, 0x00, 0x07, 0x03, 0x00, 0x5C, 0x00,
/* 00009390 */ 0x09, 0x5D, 0x01, 0x03, 0x02, 0x00, 0x5D, 0x02, 0x04, 0x02, 0x00, 0xF2, 0x03, 0xFF, 0x08, 0x00,
/* 000093A0 */ 0x00, 0x00, 0x00, 0x02, 0x00, 0x62, 0x00, 0x06, 0x03, 0x09, 0x02, 0x00, 0xA8, 0x00, 0x24, 0x00,
/* 000093B0 */ 0xFE, 0x67, 0x02, 0xFE, 0x33, 0x02, 0xFE, 0x6B, 0x02, 0xFE, 0x78, 0x02, 0xFE, 0x1E, 0xED, 0x07,
/* 000093C0 */ 0x05, 0x00, 0x00, 0x00, 0x0B, 0x00, 0x3D, 0x00, 0x24, 0x00, 0x87, 0x00, 0x20, 0x00, 0x4C, 0x00,
/* 000093D0 */ 0x15, 0x00, 0x6A, 0x00, 0x24, 0x00, 0x87, 0x00, 0x09, 0x00, 0x38, 0x00, 0x00, 0x3F, 0x5D, 0x84,
/* 000093E0 */ 0xE0, 0x81, 0xC6, 0x02, 0xFE, 0xAD, 0x04, 0x1B, 0xA0, 0x41, 0xC3, 0x00, 0xFE, 0xA1, 0x03, 0x3B,
/* 000093F0 */ 0xFE, 0x0A, 0xE8, 0x01, 0xFF, 0x00, 0x10, 0x01, 0x00, 0x01, 0x01, 0xFE, 0x0A, 0xE8, 0xFE, 0x1A,
/* 00009400 */ 0x04, 0xFE, 0x1A, 0x04, 0x02, 0x06, 0x07, 0x0B, 0x05, 0x40, 0x40, 0x04, 0x06, 0x07, 0x03, 0x03,
/* 00009410 */ 0x03, 0x03, 0x08, 0x09, 0x0A, 0x06, 0xFE, 0x85, 0x03, 0x05, 0xFE, 0xE4, 0x03, 0x06, 0xFE, 0x01,
/* 00009420 */ 0x03, 0x07, 0x08, 0xFE, 0x06, 0x01, 0x5B, 0x07, 0xB4, 0x07, 0x07, 0x2C, 0x0B, 0x07, 0x15, 0x03,
/* 00009430 */ 0x00, 0x0B, 0x02, 0x09, 0x24, 0x00, 0x8F, 0x04, 0x09, 0x0C, 0x00, 0x00, 0x6D, 0x0B, 0x0C, 0x00,
/* 00009440 */ 0x07, 0x03, 0x00, 0x5C, 0x00, 0x0C, 0x5D, 0x01, 0x03, 0x00, 0x00, 0x5D, 0x02, 0x04, 0x00, 0x00,
/* 00009450 */ 0xF2, 0x03, 0xFF, 0x0B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x8F, 0x04, 0x09, 0x0C, 0x00, 0x00,
/* 00009460 */ 0x6D, 0x0B, 0x0C, 0x01, 0x07, 0x02, 0x00, 0x5C, 0x00, 0x0C, 0x5C, 0x01, 0x07, 0xF2, 0x02, 0x0B,
/* 00009470 */ 0x0B, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x96, 0x02, 0x0B, 0x93, 0x02, 0x0B, 0x01, 0x00, 0xA8,
/* 00009480 */ 0x0C, 0x14, 0x13, 0x00, 0x0B, 0x0C, 0x09, 0x00, 0x00, 0x93, 0x02, 0x0B, 0x01, 0x00, 0x62, 0x0B,
/* 00009490 */ 0x0B, 0x02, 0x0F, 0x27, 0x00, 0x0B, 0x09, 0x00, 0x00, 0x8F, 0x04, 0x09, 0x0C, 0x00, 0x00, 0x6D,
/* 000094A0 */ 0x0B, 0x0C, 0x00, 0x07, 0x03, 0x00, 0x5C, 0x00, 0x0C, 0x5D, 0x01, 0x03, 0x02, 0x00, 0x5D, 0x02,
/* 000094B0 */ 0x04, 0x02, 0x00, 0xF2, 0x03, 0xFF, 0x0B, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x8F, 0x04, 0x0A,
/* 000094C0 */ 0x0B, 0x02, 0x00, 0x07, 0x03, 0x00, 0x5C, 0x00, 0x06, 0xCB, 0x0C, 0x5C, 0x01, 0x0C, 0x5D, 0x02,
/* 000094D0 */ 0x05, 0x03, 0x00, 0xEE, 0x03, 0x0B, 0x0B, 0x03, 0x00, 0x96, 0x03, 0x0B, 0x8F, 0x04, 0x0C, 0x0B,
/* 000094E0 */ 0x03, 0x00, 0x07, 0x04, 0x00, 0x5C, 0x00, 0x06, 0x8F, 0x04, 0x1C, 0x0C, 0x04, 0x00, 0x5C, 0x01,
/* 000094F0 */ 0x0C, 0x8F, 0x03, 0x02, 0x0C, 0x05, 0x00, 0x5C, 0x02, 0x0C, 0xD4, 0x00, 0x0C, 0x5C, 0x03, 0x0C,
/* 00009500 */ 0xEE, 0x04, 0xFF, 0x0B, 0x04, 0x00, 0x8F, 0x04, 0x0A, 0x0B, 0x02, 0x00, 0x07, 0x03, 0x00, 0x5C,
/* 00009510 */ 0x00, 0x06, 0x93, 0x03, 0x0C, 0x06, 0x00, 0x5C, 0x01, 0x0C, 0xCB, 0x0C, 0x5C, 0x02, 0x0C, 0xEE,
/* 00009520 */ 0x03, 0x00, 0x0B, 0x05, 0x00, 0x09, 0x02, 0x00, 0xA8, 0x00, 0x24, 0x00, 0xFE, 0x67, 0x02, 0xFE,
/* 00009530 */ 0x33, 0x02, 0xFE, 0x6B, 0x02, 0xFE, 0xE5, 0x03, 0xFE, 0x1D, 0x02, 0xFE, 0x40, 0xE8, 0x09, 0x05,
/* 00009540 */ 0x00, 0x00, 0x00, 0x0B, 0x00, 0x3D, 0x00, 0x24, 0x00, 0x8E, 0x00, 0x20, 0x00, 0x4C, 0x00, 0x1F,
/* 00009550 */ 0x00, 0x6A, 0x00, 0x24, 0x00, 0x90, 0x00, 0x1F, 0x00, 0x49, 0x00, 0x2A, 0x00, 0x4A, 0x01, 0x24,
/* 00009560 */ 0x00, 0x3F, 0x00, 0x00, 0x68, 0x95, 0x00, 0x00, 0xBF, 0x4C, 0x83, 0x00, 0x00, 0xC4, 0x00, 0xFE,
/* 00009570 */ 0xB8, 0x04, 0x48, 0xA2, 0x41, 0xD1, 0x00, 0x3C, 0xFE, 0xCA, 0xEA, 0xFF, 0x00, 0x10, 0x01, 0x00,
/* 00009580 */ 0x02, 0x02, 0xFE, 0xCA, 0xEA, 0xFC, 0xFC, 0x41, 0x05, 0x04, 0x06, 0x0D, 0x0D, 0x05, 0x01, 0x01,
/* 00009590 */ 0x02, 0x05, 0x05, 0xFE, 0xE6, 0x03, 0x06, 0xFE, 0x5D, 0x03, 0x36, 0x8F, 0x01, 0x02, 0x06, 0x00,
/* 000095A0 */ 0x00, 0x2F, 0x07, 0x02, 0x04, 0x2D, 0x06, 0x06, 0x07, 0x15, 0x03, 0x00, 0x06, 0x03, 0x09, 0x1C,
/* 000095B0 */ 0x00, 0x8F, 0x01, 0x03, 0x06, 0x01, 0x00, 0x8F, 0x01, 0x02, 0x07, 0x00, 0x00, 0x2F, 0x08, 0x02,
/* 000095C0 */ 0x04, 0x98, 0x07, 0x07, 0x08, 0x00, 0x00, 0x9D, 0x07, 0x06, 0x04, 0x00, 0x00, 0xA8, 0x00, 0x24,
/* 000095D0 */ 0x00, 0xFE, 0xFB, 0xEA, 0x03, 0x00, 0x00, 0x00, 0x00, 0x16, 0x00, 0x5B, 0x00, 0x1E, 0x00, 0x6F,
/* 000095E0 */ 0x00, 0x00, 0xBF, 0x5C, 0x84, 0xE0, 0x01, 0xC4, 0x00, 0xFE, 0x91, 0x04, 0x10, 0xA3, 0x41, 0xC1,
/* 000095F0 */ 0x00, 0xFE, 0xD7, 0x03, 0x3A, 0xFE, 0x12, 0xE1, 0xFF, 0x00, 0x10, 0x01, 0x00, 0x02, 0x02, 0xFE,
/* 00009600 */ 0x12, 0xE1, 0xFE, 0xF1, 0x02, 0xFE, 0xF1, 0x02, 0x01, 0x08, 0x07, 0x0B, 0x07, 0x3D, 0x39, 0x04,
/* 00009610 */ 0x06, 0x03, 0x05, 0x05, 0x05, 0x05, 0x0A, 0x06, 0xFE, 0x85, 0x03, 0x05, 0xFE, 0xE3, 0x03, 0x06,
/* 00009620 */ 0xFE, 0x01, 0x03, 0x01, 0x00, 0x08, 0xFD, 0x5B, 0x08, 0xB4, 0x08, 0x08, 0x8F, 0x04, 0x31, 0x0C,
/* 00009630 */ 0x00, 0x00, 0x6D, 0x0B, 0x0C, 0x00, 0x07, 0x02, 0x00, 0x5C, 0x00, 0x0C, 0x5C, 0x01, 0x07, 0xF2,
/* 00009640 */ 0x02, 0x0B, 0x0B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x47, 0x07, 0x0B, 0x2C, 0x0B, 0x08, 0x15,
/* 00009650 */ 0x03, 0x00, 0x0B, 0x02, 0x09, 0x24, 0x00, 0x8F, 0x04, 0x09, 0x0C, 0x01, 0x00, 0x6D, 0x0B, 0x0C,
/* 00009660 */ 0x01, 0x07, 0x03, 0x00, 0x5C, 0x00, 0x0C, 0x5D, 0x01, 0x03, 0x01, 0x00, 0x5D, 0x02, 0x04, 0x01,
/* 00009670 */ 0x00, 0xF2, 0x03, 0xFF, 0x0B, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x8F, 0x04, 0x09, 0x0C, 0x01,
/* 00009680 */ 0x00, 0x6D, 0x0B, 0x0C, 0x02, 0x07, 0x02, 0x00, 0x5C, 0x00, 0x0C, 0x5C, 0x01, 0x08, 0xF2, 0x02,
/* 00009690 */ 0x0B, 0x0B, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x47, 0x09, 0x0B, 0xA8, 0x0B, 0x14, 0x0E, 0x00,
/* 000096A0 */ 0x09, 0x0B, 0x09, 0x00, 0x00, 0x62, 0x0B, 0x09, 0x03, 0x0F, 0x27, 0x00, 0x0B, 0x09, 0x00, 0x00,
/* 000096B0 */ 0x8F, 0x04, 0x09, 0x0C, 0x01, 0x00, 0x6D, 0x0B, 0x0C, 0x01, 0x07, 0x03, 0x00, 0x5C, 0x00, 0x0C,
/* 000096C0 */ 0x5D, 0x01, 0x03, 0x03, 0x00, 0x5D, 0x02, 0x04, 0x03, 0x00, 0xF2, 0x03, 0xFF, 0x0B, 0x01, 0x00,
/* 000096D0 */ 0x00, 0x00, 0x03, 0x00, 0x8F, 0x04, 0x11, 0x0B, 0x02, 0x00, 0x07, 0x02, 0x00, 0x5C, 0x00, 0x06,
/* 000096E0 */ 0x8F, 0x04, 0x09, 0x0D, 0x01, 0x00, 0x6D, 0x0C, 0x0D, 0x04, 0x07, 0x03, 0x00, 0x5C, 0x00, 0x0D,
/* 000096F0 */ 0x2A, 0x0E, 0x05, 0x14, 0x03, 0x00, 0x07, 0x0E, 0x09, 0x06, 0x00, 0x47, 0x0E, 0x05, 0x09, 0x03,
/* 00009700 */ 0x00, 0x47, 0x0E, 0x07, 0x5C, 0x01, 0x0E, 0x5C, 0x02, 0x09, 0xF2, 0x03, 0x0C, 0x0C, 0x04, 0x00,
/* 00009710 */ 0x00, 0x00, 0x05, 0x00, 0x5C, 0x01, 0x0C, 0xEE, 0x02, 0x00, 0x0B, 0x04, 0x00, 0x09, 0x02, 0x00,
/* 00009720 */ 0xA8, 0x00, 0x24, 0x00, 0xFE, 0x5C, 0x02, 0xFE, 0x67, 0x02, 0xFE, 0x33, 0x02, 0xFE, 0x6B, 0x02,
/* 00009730 */ 0xFE, 0x2D, 0x02, 0xFE, 0x3C, 0xE1, 0x08, 0x05, 0x00, 0x00, 0x00, 0x20, 0x00, 0x31, 0x00, 0x0B,
/* 00009740 */ 0x00, 0x39, 0x00, 0x24, 0x00, 0x7F, 0x00, 0x20, 0x00, 0x48, 0x00, 0x15, 0x00, 0x66, 0x00, 0x24,
/* 00009750 */ 0x00, 0xD8, 0x00, 0x4E, 0x00, 0x57, 0x00, 0x00, 0xBF, 0x5C, 0x85, 0xE0, 0x01, 0xC4, 0x00, 0xFE,
/* 00009760 */ 0x6D, 0x04, 0x10, 0xA1, 0x41, 0xE1, 0x00, 0xFE, 0x01, 0x03, 0x39, 0xFE, 0x68, 0xDA, 0xFF, 0x00,
/* 00009770 */ 0x10, 0x01, 0x00, 0x01, 0x01, 0xFE, 0x68, 0xDA, 0xFE, 0x4F, 0x06, 0xFE, 0x4F, 0x06, 0x03, 0x0A,
/* 00009780 */ 0x08, 0x0F, 0x05, 0x6B, 0x62, 0x04, 0x02, 0x09, 0x09, 0x08, 0x07, 0x08, 0x08, 0x0E, 0x07, 0x01,
/* 00009790 */ 0x01, 0x01, 0x00, 0x01, 0x02, 0x08, 0x06, 0xFE, 0x01, 0x03, 0xFE, 0x9B, 0x01, 0xAE, 0x0A, 0x5B,
/* 000097A0 */ 0x0B, 0xB4, 0x0B, 0x0B, 0x4F, 0x08, 0x4F, 0x09, 0x4F, 0x0C, 0x4F, 0x0D, 0xA8, 0x0F, 0x47, 0x08,
/* 000097B0 */ 0x0F, 0xA8, 0x0F, 0x47, 0x09, 0x0F, 0x62, 0x0F, 0x0A, 0x00, 0x10, 0x03, 0x00, 0x0F, 0x03, 0x09,
/* 000097C0 */ 0x09, 0x00, 0x98, 0x0F, 0x0A, 0x04, 0x00, 0x00, 0x47, 0x08, 0x0F, 0x62, 0x0F, 0x0A, 0x00, 0x10,
/* 000097D0 */ 0x03, 0x00, 0x0F, 0x05, 0x09, 0x09, 0x00, 0x98, 0x0F, 0x0A, 0x03, 0x01, 0x00, 0x47, 0x09, 0x0F,
/* 000097E0 */ 0x6B, 0x07, 0x00, 0x00, 0x00, 0x0F, 0x14, 0x0D, 0x00, 0x0B, 0x0F, 0x09, 0x00, 0x00, 0xA8, 0x0F,
/* 000097F0 */ 0x14, 0x03, 0x00, 0x0B, 0x0F, 0x09, 0x1A, 0x00, 0x8F, 0x01, 0x02, 0x0F, 0x00, 0x00, 0x4B, 0x0F,
/* 00009800 */ 0x07, 0x03, 0x00, 0x5C, 0x01, 0x08, 0x5C, 0x02, 0x09, 0xC3, 0x03, 0x00, 0x0F, 0x00, 0x00, 0x09,
/* 00009810 */ 0x24, 0x01, 0x8F, 0x04, 0x31, 0x10, 0x01, 0x00, 0x6D, 0x0F, 0x10, 0x01, 0x07, 0x02, 0x00, 0x5C,
/* 00009820 */ 0x00, 0x10, 0x5C, 0x01, 0x0B, 0xF2, 0x02, 0x0F, 0x0F, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x47,
/* 00009830 */ 0x0C, 0x0F, 0x8F, 0x04, 0x17, 0x0F, 0x02, 0x00, 0x07, 0x02, 0x00, 0x5C, 0x00, 0x06, 0x5C, 0x01,
/* 00009840 */ 0x0C, 0xEE, 0x02, 0x0F, 0x0F, 0x02, 0x00, 0x0F, 0x22, 0x00, 0x0F, 0x09, 0x00, 0x00, 0x8F, 0x04,
/* 00009850 */ 0x09, 0x10, 0x03, 0x00, 0x6D, 0x0F, 0x10, 0x02, 0x07, 0x02, 0x00, 0x5C, 0x00, 0x10, 0x5D, 0x01,
/* 00009860 */ 0x07, 0x03, 0x00, 0xF2, 0x02, 0xFF, 0x0F, 0x02, 0x00, 0x00, 0x00, 0x03, 0x00, 0x8F, 0x04, 0x09,
/* 00009870 */ 0x10, 0x03, 0x00, 0x6D, 0x0F, 0x10, 0x03, 0x07, 0x02, 0x00, 0x5C, 0x00, 0x10, 0x5C, 0x01, 0x0C,
/* 00009880 */ 0xF2, 0x02, 0x0F, 0x0F, 0x03, 0x00, 0x00, 0x00, 0x04, 0x00, 0x47, 0x0D, 0x0F, 0xA8, 0x0F, 0x14,
/* 00009890 */ 0x03, 0x00, 0x0D, 0x0F, 0x09, 0x3F, 0x00, 0x8F, 0x04, 0x0A, 0x0F, 0x04, 0x00, 0x07, 0x03, 0x00,
/* 000098A0 */ 0x5C, 0x00, 0x06, 0xCB, 0x10, 0x5C, 0x01, 0x10, 0x5D, 0x02, 0x02, 0x05, 0x00, 0xEE, 0x03, 0x0F,
/* 000098B0 */ 0x0F, 0x05, 0x00, 0x47, 0x0D, 0x0F, 0x8F, 0x04, 0x09, 0x10, 0x03, 0x00, 0x6D, 0x0F, 0x10, 0x04,
/* 000098C0 */ 0x07, 0x03, 0x00, 0x5C, 0x00, 0x10, 0x5C, 0x01, 0x0C, 0x5C, 0x02, 0x0D, 0xF2, 0x03, 0xFF, 0x0F,
/* 000098D0 */ 0x04, 0x00, 0x00, 0x00, 0x06, 0x00, 0x8F, 0x02, 0x02, 0x0F, 0x05, 0x00, 0x4B, 0x0F, 0x07, 0x04,
/* 000098E0 */ 0x00, 0x5C, 0x00, 0x06, 0x5C, 0x01, 0x0D, 0x5C, 0x02, 0x08, 0x5C, 0x03, 0x09, 0xEE, 0x04, 0xFF,
/* 000098F0 */ 0x0F, 0x07, 0x00, 0x47, 0x0F, 0x0D, 0x8F, 0x04, 0x0C, 0x10, 0x06, 0x00, 0x07, 0x04, 0x00, 0x5C,
/* 00009900 */ 0x00, 0x06, 0x8F, 0x04, 0x20, 0x11, 0x07, 0x00, 0x5C, 0x01, 0x11, 0x8F, 0x01, 0x03, 0x11, 0x08,
/* 00009910 */ 0x00, 0x4B, 0x11, 0x5C, 0x02, 0x11, 0x5C, 0x03, 0x0C, 0xEE, 0x04, 0x10, 0x10, 0x08, 0x00, 0x77,
/* 00009920 */ 0x10, 0x0F, 0x05, 0x62, 0x0F, 0x0D, 0x06, 0x82, 0x0F, 0x0F, 0x29, 0x01, 0xFA, 0x0F, 0x47, 0x00,
/* 00009930 */ 0x0C, 0x09, 0x02, 0x00, 0xA8, 0x00, 0x24, 0x00, 0xF1, 0xFE, 0x51, 0x03, 0xFE, 0x66, 0x02, 0xFE,
/* 00009940 */ 0x33, 0x02, 0xFE, 0x34, 0x02, 0xFE, 0x78, 0x02, 0xFE, 0x78, 0x02, 0xDC, 0xFE, 0xE9, 0xDB, 0x14,
/* 00009950 */ 0x0F, 0x00, 0x00, 0x00, 0x05, 0x00, 0x2E, 0x00, 0x05, 0x00, 0x2E, 0x00, 0x0C, 0x00, 0x1B, 0x00,
/* 00009960 */ 0x09, 0x00, 0x2D, 0x00, 0x0C, 0x00, 0x1B, 0x00, 0x09, 0x00, 0x2F, 0x00, 0x18, 0x00, 0x44, 0x00,
/* 00009970 */ 0x1A, 0x00, 0x59, 0x00, 0x20, 0x00, 0x3A, 0x00, 0x1C, 0x00, 0x39, 0x00, 0x1F, 0x00, 0x9F, 0x00,
/* 00009980 */ 0x20, 0x00, 0x49, 0x00, 0x0A, 0x00, 0x3B, 0x00, 0x1F, 0x00, 0x40, 0x00, 0x20, 0x00, 0x5B, 0x00,
/* 00009990 */ 0x1D, 0x00, 0x4F, 0x00, 0x30, 0x00, 0x66, 0x00, 0x0B, 0x00, 0x3F, 0x00, 0x08, 0x00, 0x1D, 0x00,
/* 000099A0 */ 0x00, 0xBF, 0x5C, 0x85, 0xE0, 0x03, 0xC4, 0x00, 0xFE, 0x5F, 0x04, 0x62, 0xA0, 0x41, 0xF1, 0x00,
/* 000099B0 */ 0x38, 0xFE, 0xD7, 0xD7, 0xFF, 0x00, 0x10, 0x01, 0x00, 0x01, 0x01, 0xFE, 0xD7, 0xD7, 0xFE, 0x4F,
/* 000099C0 */ 0x02, 0xFE, 0x4F, 0x02, 0x03, 0x09, 0x09, 0x0E, 0x07, 0x40, 0x3C, 0x03, 0x02, 0x06, 0x06, 0x03,
/* 000099D0 */ 0x03, 0x03, 0x03, 0x01, 0x0D, 0x07, 0x06, 0xFE, 0x59, 0x03, 0x05, 0xFE, 0xCA, 0x03, 0x06, 0xFE,
/* 000099E0 */ 0xC9, 0x03, 0x08, 0x01, 0x00, 0x01, 0x01, 0xFE, 0x00, 0x01, 0xAE, 0x0B, 0x5B, 0x09, 0xB4, 0x09,
/* 000099F0 */ 0x09, 0x2C, 0x0E, 0x09, 0x15, 0x03, 0x00, 0x0E, 0x03, 0x09, 0x36, 0x00, 0x8F, 0x03, 0x10, 0x0E,
/* 00009A00 */ 0x00, 0x00, 0xE1, 0x0E, 0x09, 0x0E, 0x00, 0x0F, 0x27, 0x00, 0x0E, 0x09, 0x00, 0x00, 0x8F, 0x03,
/* 00009A10 */ 0x09, 0x0F, 0x01, 0x00, 0x6D, 0x0E, 0x0F, 0x00, 0x07, 0x03, 0x00, 0x5C, 0x00, 0x0F, 0x5D, 0x01,
/* 00009A20 */ 0x04, 0x00, 0x00, 0x5D, 0x02, 0x05, 0x00, 0x00, 0xF2, 0x03, 0xFF, 0x0E, 0x00, 0x00, 0x00, 0x00,
/* 00009A30 */ 0x00, 0x00, 0x8F, 0x03, 0x0A, 0x0E, 0x02, 0x00, 0x07, 0x03, 0x00, 0x5C, 0x00, 0x06, 0xCB, 0x0F,
/* 00009A40 */ 0x5C, 0x01, 0x0F, 0x5D, 0x02, 0x02, 0x01, 0x00, 0xEE, 0x03, 0x0E, 0x0E, 0x01, 0x00, 0x47, 0x0A,
/* 00009A50 */ 0x0E, 0x8F, 0x01, 0x02, 0x0E, 0x03, 0x00, 0x4B, 0x0E, 0x07, 0x04, 0x00, 0x5C, 0x00, 0x06, 0x5C,
/* 00009A60 */ 0x01, 0x0A, 0x98, 0x0F, 0x0B, 0x07, 0x00, 0x00, 0x5C, 0x02, 0x0F, 0x98, 0x0F, 0x0B, 0x08, 0x01,
/* 00009A70 */ 0x00, 0x5C, 0x03, 0x0F, 0xEE, 0x04, 0xFF, 0x0E, 0x02, 0x00, 0x8F, 0x03, 0x31, 0x0F, 0x04, 0x00,
/* 00009A80 */ 0x6D, 0x0E, 0x0F, 0x01, 0x07, 0x02, 0x00, 0x5C, 0x00, 0x0F, 0x5C, 0x01, 0x09, 0xF2, 0x02, 0x0E,
/* 00009A90 */ 0x0E, 0x01, 0x00, 0x00, 0x00, 0x03, 0x00, 0x47, 0x0C, 0x0E, 0x8F, 0x03, 0x11, 0x0E, 0x05, 0x00,
/* 00009AA0 */ 0x07, 0x02, 0x00, 0x5C, 0x00, 0x06, 0x8F, 0x03, 0x09, 0x10, 0x01, 0x00, 0x6D, 0x0F, 0x10, 0x02,
/* 00009AB0 */ 0x07, 0x03, 0x00, 0x5C, 0x00, 0x10, 0x2A, 0x11, 0x07, 0x14, 0x03, 0x00, 0x0C, 0x11, 0x09, 0x06,
/* 00009AC0 */ 0x00, 0x47, 0x11, 0x07, 0x09, 0x03, 0x00, 0x47, 0x11, 0x0C, 0x5C, 0x01, 0x11, 0x5C, 0x02, 0x0A,
/* 00009AD0 */ 0xF2, 0x03, 0x0F, 0x0F, 0x02, 0x00, 0x00, 0x00, 0x05, 0x00, 0x5C, 0x01, 0x0F, 0xEE, 0x02, 0x00,
/* 00009AE0 */ 0x0E, 0x04, 0x00, 0x09, 0x02, 0x00, 0xA8, 0x00, 0x24, 0x00, 0xFE, 0x67, 0x02, 0xFE, 0x5C, 0x02,
/* 00009AF0 */ 0xFE, 0x2D, 0x02, 0xFE, 0xF6, 0xD7, 0x07, 0x07, 0x00, 0x00, 0x00, 0x1D, 0x00, 0x54, 0x00, 0x24,
/* 00009B00 */ 0x00, 0x73, 0x00, 0x1F, 0x00, 0x3B, 0x00, 0x29, 0x00, 0x54, 0x00, 0x20, 0x00, 0x87, 0x00, 0x4E,
/* 00009B10 */ 0x00, 0x52, 0x00, 0x00, 0xBF, 0x5C, 0xC8, 0xE0, 0x21, 0xD4, 0x00, 0xFE, 0xD9, 0x03, 0x0C, 0xB3,
/* 00009B20 */ 0x41, 0xC1, 0x00, 0xFE, 0xDB, 0x03, 0x37, 0xFE, 0x31, 0xBB, 0xFF, 0x00, 0x10, 0x01, 0x00, 0x04,
/* 00009B30 */ 0x04, 0xFE, 0x31, 0xBB, 0xFE, 0x40, 0x1C, 0xFE, 0x40, 0x1C, 0x45, 0x18, 0x23, 0x37, 0x07, 0xFE,
/* 00009B40 */ 0x9B, 0x01, 0xFE, 0x7B, 0x01, 0x03, 0x04, 0x22, 0x12, 0x26, 0x26, 0x26, 0x26, 0x01, 0x36, 0x37,
/* 00009B50 */ 0x06, 0xFE, 0x85, 0x03, 0x06, 0xFE, 0xA6, 0x03, 0x08, 0x06, 0xFE, 0x01, 0x03, 0x0B, 0x06, 0xFE,
/* 00009B60 */ 0x5D, 0x03, 0x07, 0x06, 0xFE, 0x8D, 0x03, 0x06, 0xFE, 0x58, 0x03, 0x05, 0xFE, 0x4F, 0x03, 0x05,
/* 00009B70 */ 0xFE, 0x8C, 0x03, 0x05, 0xFE, 0xCE, 0x03, 0x05, 0xFE, 0xDC, 0x03, 0x05, 0xFE, 0xDD, 0x03, 0x05,
/* 00009B80 */ 0xFE, 0xCF, 0x03, 0x05, 0xFE, 0xD0, 0x03, 0x05, 0xFE, 0xDE, 0x03, 0x06, 0xFE, 0xDF, 0x03, 0x06,
/* 00009B90 */ 0xFE, 0xE4, 0x02, 0x05, 0xFE, 0xD1, 0x03, 0x01, 0x01, 0x01, 0x15, 0x06, 0xFE, 0xD4, 0x03, 0x06,
/* 00009BA0 */ 0xFE, 0xD5, 0x03, 0x05, 0xFE, 0xD6, 0x03, 0x06, 0xFE, 0x57, 0x03, 0x05, 0xFE, 0xE0, 0x03, 0x05,
/* 00009BB0 */ 0xFE, 0xD2, 0x03, 0x01, 0x00, 0x01, 0x14, 0x01, 0x03, 0x05, 0xFE, 0xD3, 0x03, 0x05, 0xFE, 0xE1,
/* 00009BC0 */ 0x03, 0xFE, 0xF9, 0x05, 0x2C, 0x38, 0x23, 0x0D, 0x03, 0x00, 0x38, 0x02, 0x09, 0x16, 0x00, 0x8F,
/* 00009BD0 */ 0x03, 0x09, 0x39, 0x00, 0x00, 0x6D, 0x38, 0x39, 0x00, 0x07, 0x01, 0x00, 0x5C, 0x00, 0x39, 0xF6,
/* 00009BE0 */ 0x01, 0xFF, 0x38, 0x00, 0x00, 0x8F, 0x03, 0x0C, 0x38, 0x01, 0x00, 0x07, 0x04, 0x00, 0x5C, 0x00,
/* 00009BF0 */ 0x04, 0x8F, 0x03, 0x19, 0x39, 0x02, 0x00, 0x5C, 0x01, 0x39, 0x5C, 0x02, 0x23, 0x5C, 0x03, 0x03,
/* 00009C00 */ 0xF6, 0x04, 0x38, 0x38, 0x01, 0x00, 0x0F, 0x03, 0x00, 0x38, 0x09, 0x27, 0x00, 0x62, 0x38, 0x23,
/* 00009C10 */ 0x01, 0x0F, 0x03, 0x00, 0x38, 0x09, 0x1C, 0x00, 0x8F, 0x03, 0x09, 0x39, 0x00, 0x00, 0x6D, 0x38,
/* 00009C20 */ 0x39, 0x02, 0x07, 0x03, 0x00, 0x5C, 0x00, 0x39, 0x5C, 0x01, 0x05, 0x5C, 0x02, 0x05, 0xF6, 0x03,
/* 00009C30 */ 0xFF, 0x38, 0x02, 0x00, 0x77, 0x06, 0x23, 0x03, 0x2C, 0x38, 0x25, 0x14, 0x03, 0x00, 0x38, 0x07,
/* 00009C40 */ 0x09, 0x20, 0x00, 0x8F, 0x03, 0x0A, 0x38, 0x03, 0x00, 0x07, 0x03, 0x00, 0x5C, 0x00, 0x04, 0xCB,
/* 00009C50 */ 0x39, 0x5C, 0x01, 0x39, 0x5C, 0x02, 0x08, 0xF6, 0x03, 0x38, 0x38, 0x03, 0x00, 0x47, 0x25, 0x38,
/* 00009C60 */ 0x09, 0x1C, 0x00, 0x8F, 0x03, 0x31, 0x39, 0x04, 0x00, 0x6D, 0x38, 0x39, 0x04, 0x07, 0x02, 0x00,
/* 00009C70 */ 0x5C, 0x00, 0x39, 0x5C, 0x01, 0x25, 0xF6, 0x02, 0x38, 0x38, 0x04, 0x00, 0x47, 0x25, 0x38, 0x8F,
/* 00009C80 */ 0x03, 0x02, 0x38, 0x05, 0x00, 0x07, 0x06, 0x00, 0x5C, 0x00, 0x04, 0x5C, 0x01, 0x25, 0x5C, 0x02,
/* 00009C90 */ 0x09, 0x5C, 0x03, 0x0A, 0xCE, 0x39, 0x02, 0x00, 0x00, 0xA1, 0x00, 0x0B, 0x39, 0xA1, 0x01, 0x0C,
/* 00009CA0 */ 0x39, 0x5C, 0x04, 0x39, 0x5C, 0x05, 0x0C, 0xF6, 0x06, 0x38, 0x38, 0x05, 0x00, 0x47, 0x28, 0x38,
/* 00009CB0 */ 0x8F, 0x03, 0x02, 0x38, 0x05, 0x00, 0x07, 0x06, 0x00, 0x5C, 0x00, 0x04, 0x5C, 0x01, 0x25, 0x5C,
/* 00009CC0 */ 0x02, 0x0D, 0x5C, 0x03, 0x0A, 0xCE, 0x39, 0x03, 0x01, 0x00, 0xA1, 0x00, 0x0E, 0x39, 0xA1, 0x01,
/* 00009CD0 */ 0x0F, 0x39, 0xA1, 0x02, 0x10, 0x39, 0x5C, 0x04, 0x39, 0x5C, 0x05, 0x0E, 0xF6, 0x06, 0x38, 0x38,
/* 00009CE0 */ 0x06, 0x00, 0x47, 0x29, 0x38, 0x8F, 0x02, 0x03, 0x38, 0x06, 0x00, 0x4B, 0x38, 0x62, 0x38, 0x38,
/* 00009CF0 */ 0x05, 0x47, 0x2A, 0x38, 0x14, 0x03, 0x00, 0x29, 0x0F, 0x09, 0x12, 0x00, 0x8F, 0x02, 0x03, 0x38,
/* 00009D00 */ 0x06, 0x00, 0x4B, 0x38, 0x62, 0x38, 0x38, 0x06, 0x47, 0x2A, 0x38, 0x09, 0x17, 0x00, 0x14, 0x03,
/* 00009D10 */ 0x00, 0x29, 0x10, 0x09, 0x0F, 0x00, 0x8F, 0x02, 0x03, 0x38, 0x06, 0x00, 0x4B, 0x38, 0x62, 0x38,
/* 00009D20 */ 0x38, 0x07, 0x47, 0x2A, 0x38, 0x8F, 0x03, 0x02, 0x38, 0x05, 0x00, 0x07, 0x06, 0x00, 0x5C, 0x00,
/* 00009D30 */ 0x04, 0x5C, 0x01, 0x25, 0x5C, 0x02, 0x10, 0x5C, 0x03, 0x0A, 0xA8, 0x39, 0x5C, 0x04, 0x39, 0xA8,
/* 00009D40 */ 0x39, 0x5C, 0x05, 0x39, 0xF6, 0x06, 0x38, 0x38, 0x07, 0x00, 0x47, 0x2B, 0x38, 0x8F, 0x03, 0x02,
/* 00009D50 */ 0x38, 0x05, 0x00, 0x07, 0x06, 0x00, 0x5C, 0x00, 0x04, 0x5C, 0x01, 0x25, 0x5C, 0x02, 0x11, 0x5C,
/* 00009D60 */ 0x03, 0x0A, 0xCE, 0x39, 0x03, 0x02, 0x00, 0xA1, 0x00, 0x12, 0x39, 0xA1, 0x01, 0x13, 0x39, 0xA1,
/* 00009D70 */ 0x02, 0x14, 0x39, 0x5C, 0x04, 0x39, 0x5C, 0x05, 0x13, 0xF6, 0x06, 0x38, 0x38, 0x08, 0x00, 0x47,
/* 00009D80 */ 0x2C, 0x38, 0xA8, 0x38, 0x47, 0x2D, 0x38, 0x8F, 0x03, 0x03, 0x38, 0x07, 0x00, 0x07, 0x06, 0x00,
/* 00009D90 */ 0x5C, 0x00, 0x04, 0x5C, 0x01, 0x25, 0x5C, 0x02, 0x15, 0x5C, 0x03, 0x16, 0x5C, 0x04, 0x17, 0x5C,
/* 00009DA0 */ 0x05, 0x16, 0xF6, 0x06, 0x38, 0x38, 0x09, 0x00, 0x47, 0x2E, 0x38, 0xA8, 0x38, 0x47, 0x2F, 0x38,
/* 00009DB0 */ 0xA8, 0x38, 0x47, 0x30, 0x38, 0xA8, 0x38, 0x47, 0x31, 0x38, 0x62, 0x38, 0x25, 0x08, 0x47, 0x32,
/* 00009DC0 */ 0x38, 0x62, 0x38, 0x25, 0x09, 0x47, 0x33, 0x38, 0x2C, 0x38, 0x32, 0x15, 0x0E, 0x00, 0x38, 0x07,
/* 00009DD0 */ 0x09, 0x00, 0x00, 0x2C, 0x38, 0x33, 0x15, 0x03, 0x00, 0x38, 0x07, 0x09, 0x48, 0x00, 0x8F, 0x03,
/* 00009DE0 */ 0x03, 0x38, 0x07, 0x00, 0x07, 0x06, 0x00, 0x5C, 0x00, 0x04, 0x5C, 0x01, 0x25, 0x5C, 0x02, 0x18,
/* 00009DF0 */ 0x5C, 0x03, 0x16, 0x5C, 0x04, 0x17, 0x5C, 0x05, 0x16, 0xF6, 0x06, 0x38, 0x38, 0x0A, 0x00, 0x47,
/* 00009E00 */ 0x32, 0x38, 0x8F, 0x03, 0x03, 0x38, 0x07, 0x00, 0x07, 0x06, 0x00, 0x5C, 0x00, 0x04, 0x5C, 0x01,
/* 00009E10 */ 0x25, 0x5C, 0x02, 0x19, 0x5C, 0x03, 0x32, 0x5C, 0x04, 0x17, 0x5C, 0x05, 0x17, 0xF6, 0x06, 0x38,
/* 00009E20 */ 0x38, 0x0B, 0x00, 0x47, 0x33, 0x38, 0x8F, 0x03, 0x02, 0x38, 0x05, 0x00, 0x07, 0x06, 0x00, 0x5C,
/* 00009E30 */ 0x00, 0x04, 0x5C, 0x01, 0x25, 0x5C, 0x02, 0x1A, 0x5C, 0x03, 0x1B, 0xA8, 0x39, 0x5C, 0x04, 0x39,
/* 00009E40 */ 0x5C, 0x05, 0x06, 0xF6, 0x06, 0x38, 0x38, 0x0C, 0x00, 0x47, 0x34, 0x38, 0x8F, 0x03, 0x07, 0x38,
/* 00009E50 */ 0x08, 0x00, 0x07, 0x02, 0x00, 0x5C, 0x00, 0x04, 0x5C, 0x01, 0x24, 0xF6, 0x02, 0x38, 0x38, 0x0D,
/* 00009E60 */ 0x00, 0x47, 0x24, 0x38, 0x8F, 0x03, 0x2F, 0x38, 0x09, 0x00, 0x07, 0x05, 0x00, 0x5C, 0x00, 0x04,
/* 00009E70 */ 0x5C, 0x01, 0x24, 0x5C, 0x02, 0x28, 0xCE, 0x39, 0x01, 0x03, 0x00, 0xA1, 0x00, 0x1C, 0x39, 0x5C,
/* 00009E80 */ 0x03, 0x39, 0x8F, 0x03, 0x30, 0x39, 0x0A, 0x00, 0x5C, 0x04, 0x39, 0xF6, 0x05, 0x38, 0x38, 0x0E,
/* 00009E90 */ 0x00, 0x47, 0x35, 0x38, 0x2C, 0x38, 0x2B, 0x15, 0x03, 0x00, 0x38, 0x07, 0x09, 0x4A, 0x00, 0x8F,
/* 00009EA0 */ 0x03, 0x06, 0x38, 0x0B, 0x00, 0x07, 0x02, 0x00, 0x5C, 0x00, 0x04, 0x5C, 0x01, 0x2B, 0xF6, 0x02,
/* 00009EB0 */ 0x38, 0x38, 0x0F, 0x00, 0x0F, 0x31, 0x00, 0x38, 0x09, 0x00, 0x00, 0x8F, 0x03, 0x09, 0x39, 0x00,
/* 00009EC0 */ 0x00, 0x6D, 0x38, 0x39, 0x0A, 0x07, 0x02, 0x00, 0x5C, 0x00, 0x39, 0x8F, 0x03, 0x11, 0x3A, 0x0C,
/* 00009ED0 */ 0x00, 0x07, 0x02, 0x00, 0x5C, 0x00, 0x04, 0x5C, 0x01, 0x2B, 0xF6, 0x02, 0x3A, 0x3A, 0x10, 0x00,
/* 00009EE0 */ 0x5C, 0x01, 0x3A, 0xF6, 0x02, 0xFF, 0x38, 0x11, 0x00, 0x14, 0x03, 0x00, 0x29, 0x10, 0x09, 0xF2,
/* 00009EF0 */ 0x00, 0x2C, 0x38, 0x2B, 0x14, 0x03, 0x00, 0x38, 0x07, 0x09, 0x16, 0x00, 0x8F, 0x03, 0x09, 0x39,
/* 00009F00 */ 0x00, 0x00, 0x6D, 0x38, 0x39, 0x0B, 0x07, 0x01, 0x00, 0x5C, 0x00, 0x39, 0xF6, 0x01, 0xFF, 0x38,
/* 00009F10 */ 0x12, 0x00, 0x8F, 0x03, 0x0C, 0x38, 0x01, 0x00, 0x07, 0x03, 0x00, 0x5C, 0x00, 0x04, 0x8F, 0x03,
/* 00009F20 */ 0x25, 0x39, 0x0D, 0x00, 0x5C, 0x01, 0x39, 0x5C, 0x02, 0x2B, 0xF6, 0x03, 0x38, 0x38, 0x13, 0x00,
/* 00009F30 */ 0x47, 0x2B, 0x38, 0xE5, 0x20, 0x00, 0x8F, 0x03, 0x09, 0x39, 0x00, 0x00, 0x6D, 0x38, 0x39, 0x0C,
/* 00009F40 */ 0x07, 0x02, 0x00, 0x5C, 0x00, 0x39, 0x5C, 0x01, 0x2B, 0xF6, 0x02, 0x38, 0x38, 0x14, 0x00, 0x47,
/* 00009F50 */ 0x2D, 0x38, 0xE9, 0x09, 0x47, 0x00, 0xE7, 0x26, 0x06, 0x8F, 0x03, 0x29, 0x38, 0x0E, 0x00, 0x07,
/* 00009F60 */ 0x02, 0x00, 0x5C, 0x00, 0x04, 0x5C, 0x01, 0x26, 0xF6, 0x02, 0xFF, 0x38, 0x15, 0x00, 0x8F, 0x03,
/* 00009F70 */ 0x09, 0x39, 0x00, 0x00, 0x6D, 0x38, 0x39, 0x0A, 0x07, 0x02, 0x00, 0x5C, 0x00, 0x39, 0x8F, 0x03,
/* 00009F80 */ 0x11, 0x3A, 0x0C, 0x00, 0x07, 0x02, 0x00, 0x5C, 0x00, 0x04, 0x5C, 0x01, 0x2B, 0xF6, 0x02, 0x3A,
/* 00009F90 */ 0x3A, 0x16, 0x00, 0x5C, 0x01, 0x3A, 0xF6, 0x02, 0xFF, 0x38, 0x17, 0x00, 0xE9, 0x8F, 0x03, 0x03,
/* 00009FA0 */ 0x38, 0x07, 0x00, 0x07, 0x06, 0x00, 0x5C, 0x00, 0x04, 0x5C, 0x01, 0x25, 0x5C, 0x02, 0x1D, 0x5C,
/* 00009FB0 */ 0x03, 0x1E, 0x5C, 0x04, 0x1F, 0x5C, 0x05, 0x2D, 0xF6, 0x06, 0x38, 0x38, 0x18, 0x00, 0x47, 0x2F,
/* 00009FC0 */ 0x38, 0x8F, 0x03, 0x15, 0x39, 0x0F, 0x00, 0x6D, 0x38, 0x39, 0x0D, 0x07, 0x03, 0x00, 0x5C, 0x00,
/* 00009FD0 */ 0x39, 0x5C, 0x01, 0x2D, 0x5C, 0x02, 0x2F, 0xF6, 0x03, 0x38, 0x38, 0x19, 0x00, 0x47, 0x31, 0x38,
/* 00009FE0 */ 0x09, 0x77, 0x00, 0xA8, 0x38, 0x47, 0x2B, 0x38, 0xA8, 0x38, 0x47, 0x2C, 0x38, 0x8F, 0x03, 0x03,
/* 00009FF0 */ 0x38, 0x07, 0x00, 0x07, 0x06, 0x00, 0x5C, 0x00, 0x04, 0x5C, 0x01, 0x25, 0x5C, 0x02, 0x1D, 0x5C,
/* 0000A000 */ 0x03, 0x1E, 0x5C, 0x04, 0x1F, 0x5C, 0x05, 0x1E, 0xF6, 0x06, 0x38, 0x38, 0x1A, 0x00, 0x47, 0x2F,
/* 0000A010 */ 0x38, 0x14, 0x03, 0x00, 0x29, 0x0F, 0x09, 0x22, 0x00, 0x8F, 0x03, 0x15, 0x39, 0x0F, 0x00, 0x6D,
/* 0000A020 */ 0x38, 0x39, 0x0D, 0x07, 0x03, 0x00, 0x5C, 0x00, 0x39, 0x5C, 0x01, 0x2F, 0x5C, 0x02, 0x1E, 0xF6,
/* 0000A030 */ 0x03, 0x38, 0x38, 0x1B, 0x00, 0x47, 0x31, 0x38, 0x09, 0x1F, 0x00, 0x8F, 0x03, 0x15, 0x39, 0x0F,
/* 0000A040 */ 0x00, 0x6D, 0x38, 0x39, 0x0D, 0x07, 0x03, 0x00, 0x5C, 0x00, 0x39, 0x5C, 0x01, 0x2F, 0x5C, 0x02,
/* 0000A050 */ 0x20, 0xF6, 0x03, 0x38, 0x38, 0x1C, 0x00, 0x47, 0x31, 0x38, 0x8F, 0x03, 0x03, 0x38, 0x07, 0x00,
/* 0000A060 */ 0x07, 0x06, 0x00, 0x5C, 0x00, 0x04, 0x5C, 0x01, 0x25, 0x5C, 0x02, 0x21, 0x5C, 0x03, 0x2F, 0x5C,
/* 0000A070 */ 0x04, 0x1F, 0x5C, 0x05, 0x31, 0xF6, 0x06, 0x38, 0x38, 0x1D, 0x00, 0x47, 0x30, 0x38, 0x77, 0x28,
/* 0000A080 */ 0x23, 0x0E, 0x62, 0x38, 0x35, 0x0F, 0x77, 0x38, 0x23, 0x10, 0x77, 0x29, 0x23, 0x11, 0xA8, 0x38,
/* 0000A090 */ 0x15, 0x03, 0x00, 0x2B, 0x38, 0x09, 0x04, 0x00, 0x77, 0x2B, 0x23, 0x12, 0xA8, 0x38, 0x15, 0x03,
/* 0000A0A0 */ 0x00, 0x2C, 0x38, 0x09, 0x62, 0x00, 0x77, 0x2C, 0x23, 0x13, 0x8F, 0x02, 0x04, 0x38, 0x10, 0x00,
/* 0000A0B0 */ 0x4B, 0x38, 0x62, 0x38, 0x38, 0x14, 0x77, 0x38, 0x23, 0x15, 0x14, 0x03, 0x00, 0x2C, 0x13, 0x09,
/* 0000A0C0 */ 0x13, 0x00, 0x8F, 0x02, 0x04, 0x38, 0x10, 0x00, 0x4B, 0x38, 0x62, 0x38, 0x38, 0x16, 0x77, 0x38,
/* 0000A0D0 */ 0x23, 0x15, 0x09, 0x33, 0x00, 0x14, 0x03, 0x00, 0x2C, 0x12, 0x09, 0x13, 0x00, 0x8F, 0x02, 0x04,
/* 0000A0E0 */ 0x38, 0x10, 0x00, 0x4B, 0x38, 0x62, 0x38, 0x38, 0x17, 0x77, 0x38, 0x23, 0x15, 0x09, 0x18, 0x00,
/* 0000A0F0 */ 0x14, 0x03, 0x00, 0x2C, 0x14, 0x09, 0x10, 0x00, 0x8F, 0x02, 0x04, 0x38, 0x10, 0x00, 0x4B, 0x38,
/* 0000A100 */ 0x62, 0x38, 0x38, 0x18, 0x77, 0x38, 0x23, 0x15, 0x77, 0x2E, 0x23, 0x19, 0x77, 0x2F, 0x23, 0x1A,
/* 0000A110 */ 0x77, 0x30, 0x23, 0x1B, 0xA8, 0x38, 0x15, 0x03, 0x00, 0x33, 0x38, 0x09, 0x08, 0x00, 0x77, 0x32,
/* 0000A120 */ 0x23, 0x1C, 0x77, 0x33, 0x23, 0x1D, 0x77, 0x2A, 0x23, 0x1E, 0x77, 0x34, 0x23, 0x1F, 0xE5, 0x1D,
/* 0000A130 */ 0x00, 0x8F, 0x03, 0x09, 0x39, 0x00, 0x00, 0x6D, 0x38, 0x39, 0x20, 0x07, 0x02, 0x00, 0x5C, 0x00,
/* 0000A140 */ 0x39, 0x5C, 0x01, 0x23, 0xF6, 0x02, 0xFF, 0x38, 0x1E, 0x00, 0xE9, 0x09, 0x2F, 0x00, 0xE7, 0x27,
/* 0000A150 */ 0x06, 0x8F, 0x03, 0x29, 0x38, 0x0E, 0x00, 0x07, 0x02, 0x00, 0x5C, 0x00, 0x04, 0x5C, 0x01, 0x27,
/* 0000A160 */ 0xF6, 0x02, 0xFF, 0x38, 0x1F, 0x00, 0x8F, 0x03, 0x09, 0x39, 0x00, 0x00, 0x6D, 0x38, 0x39, 0x21,
/* 0000A170 */ 0x07, 0x01, 0x00, 0x5C, 0x00, 0x39, 0xF6, 0x01, 0xFF, 0x38, 0x20, 0x00, 0xE9, 0x62, 0x38, 0x23,
/* 0000A180 */ 0x22, 0x0F, 0x07, 0x00, 0x38, 0x09, 0x00, 0x00, 0x77, 0x22, 0x23, 0x23, 0x47, 0x38, 0x23, 0x8F,
/* 0000A190 */ 0x03, 0x0C, 0x39, 0x01, 0x00, 0x07, 0x03, 0x00, 0x5C, 0x00, 0x04, 0x8F, 0x03, 0x24, 0x3A, 0x11,
/* 0000A1A0 */ 0x00, 0x5C, 0x01, 0x3A, 0x62, 0x3A, 0x23, 0x22, 0x5C, 0x02, 0x3A, 0xF6, 0x03, 0x39, 0x39, 0x21,
/* 0000A1B0 */ 0x00, 0x77, 0x39, 0x38, 0x24, 0x77, 0x06, 0x23, 0x25, 0xA8, 0x00, 0x24, 0x00, 0xFE, 0x55, 0x02,
/* 0000A1C0 */ 0xFE, 0x6A, 0x02, 0xFE, 0x65, 0x02, 0xFE, 0x6A, 0x02, 0xFE, 0x51, 0x03, 0xFE, 0xC2, 0x03, 0xFE,
/* 0000A1D0 */ 0xC3, 0x03, 0xFE, 0xC4, 0x03, 0xFE, 0x0E, 0x02, 0xFE, 0x0F, 0x02, 0xFE, 0x68, 0x02, 0xFE, 0x69,
/* 0000A1E0 */ 0x02, 0xFE, 0x30, 0x02, 0xFE, 0x1F, 0x01, 0xFE, 0xE2, 0x03, 0xFE, 0x1F, 0x02, 0xFE, 0x17, 0x02,
/* 0000A1F0 */ 0xFE, 0x7A, 0x02, 0xFE, 0x14, 0x02, 0xFE, 0x15, 0x02, 0xFE, 0xC1, 0x03, 0xFE, 0x16, 0x02, 0xFE,
/* 0000A200 */ 0xC6, 0x03, 0xFE, 0xC7, 0x03, 0xFE, 0xC8, 0x03, 0xFE, 0x0B, 0x02, 0xFE, 0x09, 0x02, 0xFE, 0x0A,
/* 0000A210 */ 0x02, 0xFE, 0x0C, 0x02, 0xFE, 0x0D, 0x02, 0xFE, 0x13, 0x02, 0xFE, 0x11, 0x02, 0xFE, 0x2E, 0x02,
/* 0000A220 */ 0xFE, 0x5E, 0x02, 0xFE, 0x12, 0x02, 0xFE, 0x12, 0x02, 0xFE, 0x12, 0x02, 0xFE, 0x6B, 0x02, 0xFE,
/* 0000A230 */ 0x87, 0xBB, 0x50, 0x00, 0x00, 0x00, 0x00, 0x0B, 0x00, 0x3C, 0x00, 0x16, 0x00, 0x42, 0x00, 0x33,
/* 0000A240 */ 0x00, 0x9C, 0x00, 0x1C, 0x00, 0x70, 0x00, 0x04, 0x00, 0x64, 0x00, 0x0B, 0x00, 0x3B, 0x00, 0x20,
/* 0000A250 */ 0x00, 0x51, 0x00, 0x1C, 0x00, 0x4C, 0x00, 0x31, 0x00, 0x72, 0x00, 0x35, 0x00, 0x75, 0x00, 0x0F,
/* 0000A260 */ 0x00, 0x4C, 0x00, 0x08, 0x00, 0x30, 0x00, 0x12, 0x00, 0x44, 0x00, 0x08, 0x00, 0x31, 0x00, 0x0F,
/* 0000A270 */ 0x00, 0x53, 0x00, 0x28, 0x00, 0x60, 0x00, 0x35, 0x00, 0x7E, 0x00, 0x05, 0x00, 0x33, 0x00, 0x24,
/* 0000A280 */ 0x00, 0x68, 0x00, 0x05, 0x00, 0x38, 0x00, 0x05, 0x00, 0x38, 0x00, 0x05, 0x00, 0x41, 0x00, 0x07,
/* 0000A290 */ 0x00, 0x52, 0x00, 0x07, 0x00, 0x54, 0x00, 0x16, 0x00, 0x7F, 0x00, 0x24, 0x00, 0x70, 0x00, 0x24,
/* 0000A2A0 */ 0x00, 0x99, 0x00, 0x26, 0x00, 0x9D, 0x00, 0x18, 0x00, 0x42, 0x00, 0x30, 0x00, 0xA5, 0x00, 0x27,
/* 0000A2B0 */ 0x00, 0x63, 0x00, 0x2E, 0x00, 0x5B, 0x00, 0x08, 0x00, 0x31, 0x00, 0x0B, 0x00, 0x40, 0x00, 0x16,
/* 0000A2C0 */ 0x00, 0x51, 0x00, 0x24, 0x00, 0x76, 0x00, 0x22, 0x00, 0x4B, 0x00, 0x01, 0x00, 0x25, 0x00, 0x15,
/* 0000A2D0 */ 0x00, 0x2F, 0x00, 0x2F, 0x00, 0x61, 0x00, 0x24, 0x00, 0x77, 0x00, 0x22, 0x00, 0x7F, 0x00, 0x05,
/* 0000A2E0 */ 0x00, 0x2B, 0x00, 0x05, 0x00, 0x32, 0x00, 0x24, 0x00, 0x6A, 0x00, 0x08, 0x00, 0x34, 0x00, 0x22,
/* 0000A2F0 */ 0x00, 0x7A, 0x00, 0x1F, 0x00, 0x7F, 0x00, 0x24, 0x00, 0xC9, 0x00, 0x04, 0x00, 0x39, 0x00, 0x08,
/* 0000A300 */ 0x00, 0x44, 0x00, 0x04, 0x00, 0x31, 0x00, 0x0A, 0x00, 0x33, 0x00, 0x04, 0x00, 0x4A, 0x00, 0x0A,
/* 0000A310 */ 0x00, 0x3A, 0x00, 0x04, 0x00, 0x47, 0x00, 0x10, 0x00, 0x60, 0x00, 0x08, 0x00, 0x3D, 0x00, 0x13,
/* 0000A320 */ 0x00, 0x66, 0x00, 0x08, 0x00, 0x3B, 0x00, 0x13, 0x00, 0x64, 0x00, 0x08, 0x00, 0x3B, 0x00, 0x10,
/* 0000A330 */ 0x00, 0x85, 0x00, 0x04, 0x00, 0x4D, 0x00, 0x04, 0x00, 0x4F, 0x00, 0x04, 0x00, 0x51, 0x00, 0x0A,
/* 0000A340 */ 0x00, 0x43, 0x00, 0x04, 0x00, 0x59, 0x00, 0x04, 0x00, 0x6A, 0x00, 0x04, 0x00, 0x41, 0x00, 0x07,
/* 0000A350 */ 0x00, 0xAD, 0x00, 0x1F, 0x00, 0x3D, 0x00, 0x01, 0x00, 0x21, 0x00, 0x15, 0x00, 0x6F, 0x01, 0x17,
/* 0000A360 */ 0x00, 0x4D, 0x00, 0x0B, 0x00, 0x3C, 0x00, 0x04, 0x00, 0x73, 0x00, 0x29, 0x00, 0x7F, 0x00, 0x06,
/* 0000A370 */ 0x00, 0x3C, 0x00, 0x00, 0x3F, 0x5C, 0x84, 0xE0, 0x29, 0xD4, 0x92, 0xFE, 0xDC, 0x02, 0x14, 0xA0,
/* 0000A380 */ 0x41, 0xD1, 0x00, 0x2E, 0xFE, 0x1B, 0x85, 0x06, 0xFF, 0x00, 0x10, 0x01, 0x00, 0x01, 0x01, 0xFE,
/* 0000A390 */ 0x1B, 0x85, 0xFE, 0x65, 0x31, 0xFE, 0x65, 0x31, 0x0B, 0x17, 0x1B, 0x09, 0x9A, 0x9A, 0x01, 0x0C,
/* 0000A3A0 */ 0x09, 0x07, 0x07, 0x07, 0x07, 0x05, 0x02, 0x1A, 0x1B, 0x06, 0xFE, 0xFC, 0x02, 0x06, 0xFE, 0x9B,
/* 0000A3B0 */ 0x03, 0x05, 0xFE, 0x9C, 0x03, 0x08, 0x01, 0x04, 0x05, 0xFE, 0x9D, 0x03, 0x05, 0xFE, 0x9E, 0x03,
/* 0000A3C0 */ 0x06, 0xFE, 0xE6, 0x02, 0x06, 0xFE, 0xE5, 0x02, 0x06, 0xFE, 0xFE, 0x02, 0x0B, 0x06, 0xFE, 0x00,
/* 0000A3D0 */ 0x03, 0x07, 0x06, 0xFE, 0x9F, 0x03, 0x0C, 0x06, 0xFE, 0xFF, 0x02, 0x06, 0xFE, 0xA0, 0x03, 0x06,
/* 0000A3E0 */ 0xFE, 0xA1, 0x03, 0x06, 0xFE, 0xA2, 0x03, 0x06, 0xFE, 0xA3, 0x03, 0x05, 0xFE, 0xA4, 0x03, 0xFE,
/* 0000A3F0 */ 0xC6, 0x02, 0xA8, 0x17, 0xA8, 0x18, 0xA8, 0x19, 0x8F, 0x01, 0x38, 0x1D, 0x00, 0x00, 0x14, 0x11,
/* 0000A400 */ 0x00, 0x1D, 0x02, 0x09, 0x00, 0x00, 0x8F, 0x01, 0x38, 0x1D, 0x00, 0x00, 0x14, 0x03, 0x00, 0x1D,
/* 0000A410 */ 0x03, 0x09, 0x9B, 0x02, 0xDE, 0x00, 0x03, 0x01, 0xB8, 0x1D, 0x00, 0x01, 0x50, 0x01, 0x00, 0x17,
/* 0000A420 */ 0x1D, 0x95, 0x00, 0x02, 0x17, 0x8F, 0x01, 0x09, 0x1E, 0x01, 0x00, 0x6D, 0x1D, 0x1E, 0x00, 0x07,
/* 0000A430 */ 0x03, 0x00, 0x5C, 0x00, 0x1E, 0x8F, 0x01, 0x2A, 0x1F, 0x02, 0x00, 0x07, 0x03, 0x00, 0x5C, 0x00,
/* 0000A440 */ 0x05, 0x5D, 0x01, 0x04, 0x01, 0x00, 0xB8, 0x21, 0x00, 0x01, 0x50, 0x01, 0x01, 0x20, 0x21, 0x5C,
/* 0000A450 */ 0x02, 0x20, 0xEE, 0x03, 0x1F, 0x1F, 0x01, 0x00, 0x5C, 0x01, 0x1F, 0x5D, 0x02, 0x06, 0x00, 0x00,
/* 0000A460 */ 0xF2, 0x03, 0xFF, 0x1D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x8F, 0x01, 0x38, 0x1D, 0x00, 0x00,
/* 0000A470 */ 0x14, 0x03, 0x00, 0x1D, 0x02, 0x09, 0x37, 0x02, 0xDE, 0x01, 0x04, 0x02, 0xB8, 0x1D, 0x00, 0xB7,
/* 0000A480 */ 0x01, 0x00, 0x00, 0x00, 0x1D, 0x1D, 0x01, 0x50, 0x01, 0x02, 0x18, 0x1D, 0x95, 0x01, 0x02, 0x18,
/* 0000A490 */ 0x01, 0x50, 0x01, 0x03, 0x19, 0x1D, 0x95, 0x01, 0x03, 0x19, 0x8F, 0x01, 0x2A, 0x1D, 0x02, 0x00,
/* 0000A4A0 */ 0x07, 0x03, 0x00, 0x5C, 0x00, 0x05, 0x5D, 0x01, 0x07, 0x02, 0x00, 0x91, 0x01, 0x02, 0x1E, 0x03,
/* 0000A4B0 */ 0x00, 0x5C, 0x02, 0x1E, 0xEE, 0x03, 0xFF, 0x1D, 0x02, 0x00, 0x8F, 0x01, 0x2A, 0x1D, 0x02, 0x00,
/* 0000A4C0 */ 0x07, 0x03, 0x00, 0x5C, 0x00, 0x05, 0x5D, 0x01, 0x08, 0x03, 0x00, 0x91, 0x01, 0x03, 0x1E, 0x04,
/* 0000A4D0 */ 0x00, 0x5C, 0x02, 0x1E, 0xEE, 0x03, 0xFF, 0x1D, 0x03, 0x00, 0x8F, 0x01, 0x1B, 0x1D, 0x05, 0x00,
/* 0000A4E0 */ 0x07, 0x04, 0x00, 0x5C, 0x00, 0x05, 0x91, 0x01, 0x02, 0x1E, 0x03, 0x00, 0x5C, 0x01, 0x1E, 0x5D,
/* 0000A4F0 */ 0x02, 0x09, 0x04, 0x00, 0xCC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1E, 0x00, 0x00,
/* 0000A500 */ 0x00, 0x8F, 0x01, 0x45, 0x1F, 0x06, 0x00, 0x4B, 0x1F, 0x7B, 0x1F, 0x1E, 0x01, 0x7B, 0x0C, 0x1E,
/* 0000A510 */ 0x02, 0x7B, 0x0C, 0x1E, 0x03, 0x5C, 0x03, 0x1E, 0xEE, 0x04, 0xFF, 0x1D, 0x04, 0x00, 0x8F, 0x01,
/* 0000A520 */ 0x1B, 0x1D, 0x05, 0x00, 0x07, 0x04, 0x00, 0x5C, 0x00, 0x05, 0x91, 0x01, 0x02, 0x1E, 0x03, 0x00,
/* 0000A530 */ 0x5C, 0x01, 0x1E, 0x5D, 0x02, 0x0F, 0x05, 0x00, 0xCC, 0x14, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
/* 0000A540 */ 0x00, 0x1E, 0x00, 0x00, 0x00, 0x91, 0x01, 0x02, 0x1F, 0x03, 0x00, 0x07, 0x01, 0x00, 0xC3, 0x01,
/* 0000A550 */ 0x1F, 0x1F, 0x06, 0x00, 0x7B, 0x1F, 0x1E, 0x01, 0x7B, 0x10, 0x1E, 0x02, 0x7B, 0x10, 0x1E, 0x04,
/* 0000A560 */ 0x7B, 0x10, 0x1E, 0x03, 0x5C, 0x03, 0x1E, 0xEE, 0x04, 0xFF, 0x1D, 0x05, 0x00, 0x8F, 0x01, 0x0A,
/* 0000A570 */ 0x1D, 0x07, 0x00, 0x07, 0x03, 0x00, 0x5C, 0x00, 0x05, 0x91, 0x01, 0x02, 0x1E, 0x03, 0x00, 0x62,
/* 0000A580 */ 0x1E, 0x1E, 0x05, 0x5C, 0x01, 0x1E, 0x8F, 0x01, 0x0E, 0x1E, 0x08, 0x00, 0x62, 0x1E, 0x1E, 0x05,
/* 0000A590 */ 0x5C, 0x02, 0x1E, 0xEE, 0x03, 0xFF, 0x1D, 0x07, 0x00, 0x8F, 0x01, 0x1B, 0x1D, 0x05, 0x00, 0x07,
/* 0000A5A0 */ 0x04, 0x00, 0x5C, 0x00, 0x05, 0x91, 0x01, 0x02, 0x1E, 0x03, 0x00, 0x62, 0x1E, 0x1E, 0x05, 0x5C,
/* 0000A5B0 */ 0x01, 0x1E, 0x5D, 0x02, 0x12, 0x08, 0x00, 0xCC, 0x2C, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
/* 0000A5C0 */ 0x1E, 0x00, 0x00, 0x00, 0x91, 0x01, 0x02, 0x1F, 0x03, 0x00, 0x7B, 0x1F, 0x1E, 0x01, 0x7B, 0x0C,
/* 0000A5D0 */ 0x1E, 0x02, 0x7B, 0x10, 0x1E, 0x04, 0x7B, 0x0C, 0x1E, 0x03, 0x5C, 0x03, 0x1E, 0xEE, 0x04, 0xFF,
/* 0000A5E0 */ 0x1D, 0x08, 0x00, 0x8F, 0x01, 0x1B, 0x1D, 0x05, 0x00, 0x07, 0x04, 0x00, 0x5C, 0x00, 0x05, 0x91,
/* 0000A5F0 */ 0x01, 0x02, 0x1E, 0x03, 0x00, 0x62, 0x1E, 0x1E, 0x05, 0x5C, 0x01, 0x1E, 0x5D, 0x02, 0x13, 0x09,
/* 0000A600 */ 0x00, 0xCC, 0x44, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x1E, 0x00, 0x00, 0x00, 0xB8, 0x20,
/* 0000A610 */ 0x00, 0xB7, 0x01, 0x00, 0x00, 0x00, 0x20, 0x20, 0x01, 0x50, 0x01, 0x04, 0x1F, 0x20, 0x7B, 0x1F,
/* 0000A620 */ 0x1E, 0x01, 0x01, 0x64, 0x01, 0x1F, 0x1E, 0x7B, 0x0C, 0x1E, 0x02, 0x7B, 0x10, 0x1E, 0x04, 0x7B,
/* 0000A630 */ 0x0C, 0x1E, 0x03, 0x5C, 0x03, 0x1E, 0xEE, 0x04, 0xFF, 0x1D, 0x09, 0x00, 0x8F, 0x01, 0x1B, 0x1D,
/* 0000A640 */ 0x05, 0x00, 0x07, 0x04, 0x00, 0x5C, 0x00, 0x05, 0x91, 0x01, 0x02, 0x1E, 0x03, 0x00, 0x62, 0x1E,
/* 0000A650 */ 0x1E, 0x05, 0x5C, 0x01, 0x1E, 0x5D, 0x02, 0x14, 0x0A, 0x00, 0xCC, 0x5C, 0x00, 0x00, 0x00, 0x04,
/* 0000A660 */ 0x00, 0x00, 0x00, 0x1E, 0x00, 0x00, 0x00, 0x8F, 0x01, 0x2A, 0x1F, 0x02, 0x00, 0x07, 0x03, 0x00,
/* 0000A670 */ 0x5C, 0x00, 0x05, 0x5D, 0x01, 0x16, 0x0B, 0x00, 0xB8, 0x21, 0x00, 0xB7, 0x01, 0x00, 0x00, 0x00,
/* 0000A680 */ 0x21, 0x21, 0x01, 0x50, 0x01, 0x05, 0x20, 0x21, 0x5C, 0x02, 0x20, 0xEE, 0x03, 0x1F, 0x1F, 0x0B,
/* 0000A690 */ 0x00, 0x7B, 0x1F, 0x1E, 0x06, 0x7B, 0x10, 0x1E, 0x04, 0x7B, 0x0C, 0x1E, 0x03, 0x5C, 0x03, 0x1E,
/* 0000A6A0 */ 0xEE, 0x04, 0xFF, 0x1D, 0x0A, 0x00, 0x91, 0x01, 0x02, 0x00, 0x03, 0x00, 0x09, 0x07, 0x00, 0xA8,
/* 0000A6B0 */ 0x00, 0x09, 0x02, 0x00, 0xA8, 0x00, 0x24, 0x00, 0x05, 0x70, 0x00, 0x5C, 0x00, 0x00, 0x00, 0x03,
/* 0000A6C0 */ 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xB5, 0x01, 0x00, 0x00, 0xB1, 0x01, 0x00, 0x00, 0xB2,
/* 0000A6D0 */ 0x01, 0x00, 0x00, 0x44, 0x00, 0x00, 0x00, 0x03, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xB4,
/* 0000A6E0 */ 0x01, 0x00, 0x00, 0xB3, 0x01, 0x00, 0x00, 0xB1, 0x01, 0x00, 0x00, 0xB2, 0x01, 0x00, 0x00, 0x2C,
/* 0000A6F0 */ 0x00, 0x00, 0x00, 0x03, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xB4, 0x01, 0x00, 0x00, 0xB3,
/* 0000A700 */ 0x01, 0x00, 0x00, 0xB1, 0x01, 0x00, 0x00, 0xB2, 0x01, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x03,
/* 0000A710 */ 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xB4, 0x01, 0x00, 0x00, 0xB3, 0x01, 0x00, 0x00, 0xB1,
/* 0000A720 */ 0x01, 0x00, 0x00, 0xB2, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x03, 0x00, 0x00, 0x00,
/* 0000A730 */ 0x00, 0x00, 0x00, 0xB4, 0x01, 0x00, 0x00, 0xB3, 0x01, 0x00, 0x00, 0xB2, 0x01, 0x00, 0x00, 0xFE,
/* 0000A740 */ 0x32, 0x02, 0xFE, 0xB4, 0x01, 0xFE, 0xB3, 0x01, 0xFE, 0xB2, 0x01, 0xFE, 0xB1, 0x01, 0xFE, 0x46,
/* 0000A750 */ 0x01, 0xFE, 0xB5, 0x01, 0x02, 0x01, 0x01, 0x00, 0xFE, 0xA5, 0x03, 0x02, 0x02, 0x00, 0xFE, 0x19,
/* 0000A760 */ 0x02, 0x01, 0xFE, 0x1E, 0x02, 0xFE, 0x34, 0x85, 0x0E, 0x06, 0x00, 0x00, 0x00, 0x2D, 0x00, 0x83,
/* 0000A770 */ 0x17, 0x45, 0x00, 0x09, 0x04, 0x30, 0x00, 0xAD, 0x06, 0x20, 0x00, 0x54, 0x03, 0x20, 0x00, 0x52,
/* 0000A780 */ 0x00, 0x44, 0x00, 0x95, 0x00, 0x4F, 0x00, 0x92, 0x00, 0x2C, 0x00, 0x47, 0x00, 0x4A, 0x00, 0x98,
/* 0000A790 */ 0x00, 0x59, 0x00, 0xBD, 0x05, 0x6A, 0x00, 0x12, 0x03, 0x09, 0x00, 0x80, 0x00, 0x07, 0x00, 0x17,
/* 0000A7A0 */ 0x00, 0x00, 0x10, 0xB0, 0x00, 0x00, 0x52, 0xAE, 0x00, 0x00, 0x11, 0xAC, 0x00, 0x00, 0x76, 0xAA,
/* 0000A7B0 */ 0x00, 0x00, 0xBE, 0xA8, 0x00, 0x00, 0xBA, 0xA7, 0x00, 0x00, 0xBF, 0x5C, 0x84, 0xE0, 0x01, 0xC4,
/* 0000A7C0 */ 0x00, 0xFE, 0xB1, 0x03, 0x3A, 0xA0, 0x41, 0xD1, 0x00, 0x35, 0xFE, 0x47, 0xB3, 0xFF, 0x00, 0x10,
/* 0000A7D0 */ 0x01, 0x00, 0x01, 0x01, 0xFE, 0x47, 0xB3, 0xFE, 0x50, 0x02, 0xFE, 0x50, 0x02, 0x01, 0x05, 0x05,
/* 0000A7E0 */ 0x08, 0x04, 0x25, 0x24, 0x03, 0x03, 0x01, 0x04, 0x04, 0x04, 0x04, 0x07, 0x06, 0xFE, 0x85, 0x03,
/* 0000A7F0 */ 0x05, 0xFE, 0xBF, 0x03, 0x06, 0xFE, 0xFD, 0x02, 0x98, 0x5B, 0x05, 0xB4, 0x05, 0x05, 0x2C, 0x08,
/* 0000A800 */ 0x05, 0x15, 0x03, 0x00, 0x08, 0x02, 0x09, 0x24, 0x00, 0x8F, 0x03, 0x09, 0x09, 0x00, 0x00, 0x6D,
/* 0000A810 */ 0x08, 0x09, 0x00, 0x07, 0x03, 0x00, 0x5C, 0x00, 0x09, 0x5D, 0x01, 0x03, 0x00, 0x00, 0x5D, 0x02,
/* 0000A820 */ 0x04, 0x00, 0x00, 0xF2, 0x03, 0xFF, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x8F, 0x03, 0x09,
/* 0000A830 */ 0x09, 0x00, 0x00, 0x6D, 0x08, 0x09, 0x01, 0x07, 0x02, 0x00, 0x5C, 0x00, 0x09, 0x5C, 0x01, 0x05,
/* 0000A840 */ 0xF2, 0x02, 0x08, 0x08, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x47, 0x06, 0x08, 0xA8, 0x08, 0x14,
/* 0000A850 */ 0x0E, 0x00, 0x06, 0x08, 0x09, 0x00, 0x00, 0x62, 0x08, 0x06, 0x02, 0x0F, 0x27, 0x00, 0x08, 0x09,
/* 0000A860 */ 0x00, 0x00, 0x8F, 0x03, 0x09, 0x09, 0x00, 0x00, 0x6D, 0x08, 0x09, 0x00, 0x07, 0x03, 0x00, 0x5C,
/* 0000A870 */ 0x00, 0x09, 0x5D, 0x01, 0x03, 0x02, 0x00, 0x5D, 0x02, 0x04, 0x02, 0x00, 0xF2, 0x03, 0xFF, 0x08,
/* 0000A880 */ 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x62, 0x00, 0x06, 0x03, 0x09, 0x02, 0x00, 0xA8, 0x00, 0x24,
/* 0000A890 */ 0x00, 0xFE, 0x67, 0x02, 0xFE, 0x33, 0x02, 0xFE, 0x76, 0x02, 0xFE, 0x77, 0x02, 0xFE, 0x6E, 0xB3,
/* 0000A8A0 */ 0x07, 0x05, 0x00, 0x00, 0x00, 0x0B, 0x00, 0x3D, 0x00, 0x24, 0x00, 0x80, 0x00, 0x20, 0x00, 0x4C,
/* 0000A8B0 */ 0x00, 0x15, 0x00, 0x66, 0x00, 0x24, 0x00, 0x80, 0x00, 0x09, 0x00, 0x39, 0x00, 0x00, 0xBF, 0x5C,
/* 0000A8C0 */ 0x84, 0xE0, 0x09, 0xC4, 0x10, 0xFE, 0x9B, 0x03, 0x1B, 0xA0, 0x41, 0xC3, 0x00, 0xFE, 0xA1, 0x03,
/* 0000A8D0 */ 0x34, 0xFE, 0x73, 0xAD, 0xFF, 0x00, 0x10, 0x01, 0x00, 0x01, 0x01, 0xFE, 0x73, 0xAD, 0xFE, 0x03,
/* 0000A8E0 */ 0x05, 0xFE, 0x03, 0x05, 0x01, 0x05, 0x0D, 0x10, 0x04, 0x33, 0x32, 0x03, 0x03, 0x01, 0x11, 0x11,
/* 0000A8F0 */ 0x11, 0x11, 0x01, 0x0F, 0x06, 0xFE, 0x85, 0x03, 0x05, 0xFE, 0xC0, 0x03, 0x06, 0xFE, 0xFD, 0x02,
/* 0000A900 */ 0x06, 0xFE, 0x48, 0x03, 0x06, 0xFE, 0xA7, 0x03, 0x06, 0xFE, 0xAA, 0x03, 0x06, 0xFE, 0xAF, 0x03,
/* 0000A910 */ 0x06, 0xFE, 0xB9, 0x03, 0x06, 0xFE, 0xB4, 0x03, 0x06, 0xFE, 0xB0, 0x03, 0x07, 0xD9, 0x5B, 0x0D,
/* 0000A920 */ 0xB4, 0x0D, 0x0D, 0x2C, 0x10, 0x0D, 0x15, 0x03, 0x00, 0x10, 0x02, 0x09, 0x24, 0x00, 0x8F, 0x03,
/* 0000A930 */ 0x09, 0x11, 0x00, 0x00, 0x6D, 0x10, 0x11, 0x00, 0x07, 0x03, 0x00, 0x5C, 0x00, 0x11, 0x5D, 0x01,
/* 0000A940 */ 0x03, 0x00, 0x00, 0x5D, 0x02, 0x04, 0x00, 0x00, 0xF2, 0x03, 0xFF, 0x10, 0x00, 0x00, 0x00, 0x00,
/* 0000A950 */ 0x00, 0x00, 0x8F, 0x03, 0x09, 0x11, 0x00, 0x00, 0x6D, 0x10, 0x11, 0x01, 0x07, 0x02, 0x00, 0x5C,
/* 0000A960 */ 0x00, 0x11, 0x5C, 0x01, 0x0D, 0xF2, 0x02, 0x10, 0x10, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x47,
/* 0000A970 */ 0x0E, 0x10, 0xA8, 0x10, 0x14, 0x0E, 0x00, 0x0E, 0x10, 0x09, 0x00, 0x00, 0x62, 0x10, 0x0E, 0x02,
/* 0000A980 */ 0x0F, 0x27, 0x00, 0x10, 0x09, 0x00, 0x00, 0x8F, 0x03, 0x09, 0x11, 0x00, 0x00, 0x6D, 0x10, 0x11,
/* 0000A990 */ 0x00, 0x07, 0x03, 0x00, 0x5C, 0x00, 0x11, 0x5D, 0x01, 0x03, 0x02, 0x00, 0x5D, 0x02, 0x04, 0x02,
/* 0000A9A0 */ 0x00, 0xF2, 0x03, 0xFF, 0x10, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0xCC, 0x00, 0x00, 0x00, 0x00,
/* 0000A9B0 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x62, 0x10, 0x0E, 0x03, 0x7B, 0x10, 0x00, 0x04,
/* 0000A9C0 */ 0x62, 0x10, 0x0E, 0x05, 0x7B, 0x10, 0x00, 0x06, 0x62, 0x10, 0x0E, 0x07, 0x7B, 0x10, 0x00, 0x08,
/* 0000A9D0 */ 0x62, 0x10, 0x0E, 0x09, 0x7B, 0x10, 0x00, 0x0A, 0x62, 0x10, 0x0E, 0x0B, 0x7B, 0x10, 0x00, 0x0C,
/* 0000A9E0 */ 0x62, 0x10, 0x0E, 0x0D, 0x7B, 0x10, 0x00, 0x0E, 0x62, 0x10, 0x0E, 0x0F, 0x7B, 0x10, 0x00, 0x10,
/* 0000A9F0 */ 0x09, 0x02, 0x00, 0xA8, 0x00, 0x24, 0x00, 0x01, 0x24, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x07,
/* 0000AA00 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1F, 0x02, 0x00, 0x00, 0xA7, 0x03, 0x00, 0x00, 0x20, 0x02,
/* 0000AA10 */ 0x00, 0x00, 0x22, 0x02, 0x00, 0x00, 0xB9, 0x03, 0x00, 0x00, 0x21, 0x02, 0x00, 0x00, 0xB0, 0x03,
/* 0000AA20 */ 0x00, 0x00, 0xFE, 0x67, 0x02, 0xFE, 0x33, 0x02, 0xFE, 0x76, 0x02, 0xFE, 0x17, 0x02, 0xFE, 0x1F,
/* 0000AA30 */ 0x02, 0xFE, 0x70, 0x02, 0xFE, 0xA7, 0x03, 0xFE, 0x71, 0x02, 0xFE, 0x20, 0x02, 0xFE, 0x72, 0x02,
/* 0000AA40 */ 0xFE, 0x22, 0x02, 0xFE, 0x75, 0x02, 0xFE, 0xB9, 0x03, 0xFE, 0x74, 0x02, 0xFE, 0x21, 0x02, 0xFE,
/* 0000AA50 */ 0x73, 0x02, 0xFE, 0xB0, 0x03, 0xFE, 0xA9, 0xAD, 0x07, 0x05, 0x00, 0x00, 0x00, 0x0B, 0x00, 0x3D,
/* 0000AA60 */ 0x00, 0x24, 0x00, 0x86, 0x00, 0x20, 0x00, 0x4C, 0x00, 0x15, 0x00, 0x66, 0x00, 0x24, 0x00, 0x88,
/* 0000AA70 */ 0x00, 0x4A, 0x00, 0xCF, 0x02, 0x00, 0xBF, 0x5C, 0x84, 0xE0, 0x01, 0xC4, 0x00, 0xFE, 0x82, 0x03,
/* 0000AA80 */ 0x10, 0xA3, 0x41, 0xC1, 0x00, 0xFE, 0xA2, 0x03, 0x33, 0xFE, 0xAE, 0xA7, 0xFF, 0x00, 0x10, 0x01,
/* 0000AA90 */ 0x00, 0x03, 0x03, 0xFE, 0xAE, 0xA7, 0xFE, 0x01, 0x03, 0xFE, 0x01, 0x03, 0x01, 0x09, 0x06, 0x0B,
/* 0000AAA0 */ 0x0B, 0x44, 0x41, 0x03, 0x07, 0x03, 0x08, 0x08, 0x08, 0x08, 0x0A, 0x06, 0xFE, 0x85, 0x03, 0x05,
/* 0000AAB0 */ 0xFE, 0xBF, 0x03, 0x06, 0xFE, 0xFD, 0x02, 0x08, 0xFE, 0x15, 0x01, 0x5B, 0x08, 0xB4, 0x08, 0x08,
/* 0000AAC0 */ 0x2C, 0x0B, 0x08, 0x15, 0x03, 0x00, 0x0B, 0x02, 0x09, 0x24, 0x00, 0x8F, 0x03, 0x09, 0x0C, 0x00,
/* 0000AAD0 */ 0x00, 0x6D, 0x0B, 0x0C, 0x00, 0x07, 0x03, 0x00, 0x5C, 0x00, 0x0C, 0x5D, 0x01, 0x03, 0x00, 0x00,
/* 0000AAE0 */ 0x5D, 0x02, 0x04, 0x00, 0x00, 0xF2, 0x03, 0xFF, 0x0B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x8F,
/* 0000AAF0 */ 0x03, 0x09, 0x0C, 0x00, 0x00, 0x6D, 0x0B, 0x0C, 0x01, 0x07, 0x02, 0x00, 0x5C, 0x00, 0x0C, 0x5C,
/* 0000AB00 */ 0x01, 0x08, 0xF2, 0x02, 0x0B, 0x0B, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x47, 0x09, 0x0B, 0xA8,
/* 0000AB10 */ 0x0B, 0x14, 0x0E, 0x00, 0x09, 0x0B, 0x09, 0x00, 0x00, 0x62, 0x0B, 0x09, 0x02, 0x0F, 0x27, 0x00,
/* 0000AB20 */ 0x0B, 0x09, 0x00, 0x00, 0x8F, 0x03, 0x09, 0x0C, 0x00, 0x00, 0x6D, 0x0B, 0x0C, 0x00, 0x07, 0x03,
/* 0000AB30 */ 0x00, 0x5C, 0x00, 0x0C, 0x5D, 0x01, 0x03, 0x02, 0x00, 0x5D, 0x02, 0x04, 0x02, 0x00, 0xF2, 0x03,
/* 0000AB40 */ 0xFF, 0x0B, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x8F, 0x03, 0x11, 0x0B, 0x01, 0x00, 0x07, 0x02,
/* 0000AB50 */ 0x00, 0x5C, 0x00, 0x05, 0x5C, 0x01, 0x06, 0xEE, 0x02, 0x0B, 0x0B, 0x03, 0x00, 0x47, 0x06, 0x0B,
/* 0000AB60 */ 0x8F, 0x03, 0x11, 0x0B, 0x01, 0x00, 0x07, 0x02, 0x00, 0x5C, 0x00, 0x05, 0x5C, 0x01, 0x07, 0xEE,
/* 0000AB70 */ 0x02, 0x0B, 0x0B, 0x04, 0x00, 0x47, 0x07, 0x0B, 0x8F, 0x03, 0x10, 0x0B, 0x02, 0x00, 0x07, 0x02,
/* 0000AB80 */ 0x00, 0x5C, 0x00, 0x05, 0x8F, 0x03, 0x09, 0x0D, 0x00, 0x00, 0x6D, 0x0C, 0x0D, 0x03, 0x07, 0x07,
/* 0000AB90 */ 0x00, 0x5C, 0x00, 0x0D, 0x5C, 0x01, 0x06, 0x5C, 0x02, 0x07, 0x62, 0x0E, 0x09, 0x04, 0x5C, 0x03,
/* 0000ABA0 */ 0x0E, 0x62, 0x0E, 0x09, 0x05, 0x5C, 0x04, 0x0E, 0x62, 0x0E, 0x09, 0x06, 0x5C, 0x05, 0x0E, 0x62,
/* 0000ABB0 */ 0x0E, 0x09, 0x07, 0x5C, 0x06, 0x0E, 0xF2, 0x07, 0x0C, 0x0C, 0x03, 0x00, 0x00, 0x00, 0x06, 0x00,
/* 0000ABC0 */ 0x5C, 0x01, 0x0C, 0xEE, 0x02, 0x00, 0x0B, 0x05, 0x00, 0x09, 0x02, 0x00, 0xA8, 0x00, 0x24, 0x00,
/* 0000ABD0 */ 0xFE, 0x67, 0x02, 0xFE, 0x33, 0x02, 0xFE, 0x76, 0x02, 0xFE, 0x28, 0x02, 0xFE, 0x6F, 0x02, 0xFE,
/* 0000ABE0 */ 0x71, 0x02, 0xFE, 0x72, 0x02, 0xFE, 0x74, 0x02, 0xFE, 0xDC, 0xA7, 0x09, 0x05, 0x00, 0x00, 0x00,
/* 0000ABF0 */ 0x0B, 0x00, 0x39, 0x00, 0x24, 0x00, 0x78, 0x00, 0x20, 0x00, 0x48, 0x00, 0x15, 0x00, 0x62, 0x00,
/* 0000AC00 */ 0x24, 0x00, 0x78, 0x00, 0x18, 0x00, 0x24, 0x00, 0x18, 0x00, 0x26, 0x00, 0x56, 0x00, 0xB5, 0x00,
/* 0000AC10 */ 0x00, 0xBF, 0x5C, 0x85, 0xE0, 0x01, 0xC4, 0x00, 0xFE, 0x5F, 0x03, 0x10, 0xA1, 0x41, 0xE1, 0x00,
/* 0000AC20 */ 0xFE, 0xFD, 0x02, 0x32, 0xFE, 0xEE, 0xA0, 0xFF, 0x00, 0x10, 0x01, 0x00, 0x01, 0x01, 0xFE, 0xEE,
/* 0000AC30 */ 0xA0, 0xFE, 0x6D, 0x06, 0xFE, 0x6D, 0x06, 0x03, 0x0A, 0x08, 0x0F, 0x05, 0x67, 0x5E, 0x03, 0x02,
/* 0000AC40 */ 0x09, 0x09, 0x08, 0x07, 0x08, 0x08, 0x0E, 0x07, 0x01, 0x01, 0x01, 0x00, 0x01, 0x02, 0x08, 0x06,
/* 0000AC50 */ 0xFE, 0xFD, 0x02, 0xFE, 0x93, 0x01, 0xAE, 0x0A, 0x5B, 0x0B, 0xB4, 0x0B, 0x0B, 0xA8, 0x0F, 0x47,
/* 0000AC60 */ 0x08, 0x0F, 0xA8, 0x0F, 0x47, 0x09, 0x0F, 0x62, 0x0F, 0x0A, 0x00, 0x10, 0x03, 0x00, 0x0F, 0x03,
/* 0000AC70 */ 0x09, 0x09, 0x00, 0x98, 0x0F, 0x0A, 0x04, 0x00, 0x00, 0x47, 0x08, 0x0F, 0x62, 0x0F, 0x0A, 0x00,
/* 0000AC80 */ 0x10, 0x03, 0x00, 0x0F, 0x05, 0x09, 0x09, 0x00, 0x98, 0x0F, 0x0A, 0x03, 0x01, 0x00, 0x47, 0x09,
/* 0000AC90 */ 0x0F, 0x6B, 0x07, 0x00, 0x00, 0x00, 0x0F, 0x14, 0x0D, 0x00, 0x0B, 0x0F, 0x09, 0x00, 0x00, 0xA8,
/* 0000ACA0 */ 0x0F, 0x14, 0x03, 0x00, 0x0B, 0x0F, 0x09, 0x1A, 0x00, 0x8F, 0x01, 0x02, 0x0F, 0x00, 0x00, 0x4B,
/* 0000ACB0 */ 0x0F, 0x07, 0x03, 0x00, 0x5C, 0x01, 0x08, 0x5C, 0x02, 0x09, 0xC3, 0x03, 0x00, 0x0F, 0x00, 0x00,
/* 0000ACC0 */ 0x09, 0x24, 0x01, 0x8F, 0x03, 0x31, 0x10, 0x01, 0x00, 0x6D, 0x0F, 0x10, 0x01, 0x07, 0x02, 0x00,
/* 0000ACD0 */ 0x5C, 0x00, 0x10, 0x5C, 0x01, 0x0B, 0xF2, 0x02, 0x0F, 0x0F, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
/* 0000ACE0 */ 0x47, 0x0C, 0x0F, 0x8F, 0x03, 0x17, 0x0F, 0x02, 0x00, 0x07, 0x02, 0x00, 0x5C, 0x00, 0x06, 0x5C,
/* 0000ACF0 */ 0x01, 0x0C, 0xEE, 0x02, 0x0F, 0x0F, 0x02, 0x00, 0x0F, 0x22, 0x00, 0x0F, 0x09, 0x00, 0x00, 0x8F,
/* 0000AD00 */ 0x03, 0x09, 0x10, 0x03, 0x00, 0x6D, 0x0F, 0x10, 0x02, 0x07, 0x02, 0x00, 0x5C, 0x00, 0x10, 0x5D,
/* 0000AD10 */ 0x01, 0x07, 0x03, 0x00, 0xF2, 0x02, 0xFF, 0x0F, 0x02, 0x00, 0x00, 0x00, 0x03, 0x00, 0x8F, 0x03,
/* 0000AD20 */ 0x09, 0x10, 0x03, 0x00, 0x6D, 0x0F, 0x10, 0x03, 0x07, 0x02, 0x00, 0x5C, 0x00, 0x10, 0x5C, 0x01,
/* 0000AD30 */ 0x0C, 0xF2, 0x02, 0x0F, 0x0F, 0x03, 0x00, 0x00, 0x00, 0x04, 0x00, 0x47, 0x0D, 0x0F, 0xA8, 0x0F,
/* 0000AD40 */ 0x14, 0x03, 0x00, 0x0D, 0x0F, 0x09, 0x3F, 0x00, 0x8F, 0x03, 0x0A, 0x0F, 0x04, 0x00, 0x07, 0x03,
/* 0000AD50 */ 0x00, 0x5C, 0x00, 0x06, 0xCB, 0x10, 0x5C, 0x01, 0x10, 0x5D, 0x02, 0x02, 0x05, 0x00, 0xEE, 0x03,
/* 0000AD60 */ 0x0F, 0x0F, 0x05, 0x00, 0x47, 0x0D, 0x0F, 0x8F, 0x03, 0x09, 0x10, 0x03, 0x00, 0x6D, 0x0F, 0x10,
/* 0000AD70 */ 0x04, 0x07, 0x03, 0x00, 0x5C, 0x00, 0x10, 0x5C, 0x01, 0x0C, 0x5C, 0x02, 0x0D, 0xF2, 0x03, 0xFF,
/* 0000AD80 */ 0x0F, 0x04, 0x00, 0x00, 0x00, 0x06, 0x00, 0x8F, 0x02, 0x02, 0x0F, 0x05, 0x00, 0x4B, 0x0F, 0x07,
/* 0000AD90 */ 0x04, 0x00, 0x5C, 0x00, 0x06, 0x5C, 0x01, 0x0D, 0x5C, 0x02, 0x08, 0x5C, 0x03, 0x09, 0xEE, 0x04,
/* 0000ADA0 */ 0xFF, 0x0F, 0x07, 0x00, 0x47, 0x0F, 0x0D, 0x8F, 0x03, 0x0C, 0x10, 0x06, 0x00, 0x07, 0x04, 0x00,
/* 0000ADB0 */ 0x5C, 0x00, 0x06, 0x8F, 0x03, 0x20, 0x11, 0x07, 0x00, 0x5C, 0x01, 0x11, 0x8F, 0x01, 0x03, 0x11,
/* 0000ADC0 */ 0x08, 0x00, 0x4B, 0x11, 0x5C, 0x02, 0x11, 0x5C, 0x03, 0x0C, 0xEE, 0x04, 0x10, 0x10, 0x08, 0x00,
/* 0000ADD0 */ 0x77, 0x10, 0x0F, 0x05, 0x62, 0x0F, 0x0D, 0x06, 0x82, 0x0F, 0x0F, 0x29, 0x01, 0xFA, 0x0F, 0x47,
/* 0000ADE0 */ 0x00, 0x0C, 0x09, 0x02, 0x00, 0xA8, 0x00, 0x24, 0x00, 0xF1, 0xFE, 0x51, 0x03, 0xFE, 0x66, 0x02,
/* 0000ADF0 */ 0xFE, 0x33, 0x02, 0xFE, 0x34, 0x02, 0xFE, 0x77, 0x02, 0xFE, 0x77, 0x02, 0xDC, 0xFE, 0x6B, 0xA2,
/* 0000AE00 */ 0x14, 0x07, 0x00, 0x00, 0x00, 0x05, 0x00, 0x2E, 0x00, 0x05, 0x00, 0x2E, 0x00, 0x0C, 0x00, 0x1B,
/* 0000AE10 */ 0x00, 0x09, 0x00, 0x2D, 0x00, 0x0C, 0x00, 0x1B, 0x00, 0x09, 0x00, 0x2F, 0x00, 0x18, 0x00, 0x44,
/* 0000AE20 */ 0x00, 0x1A, 0x00, 0x55, 0x00, 0x20, 0x00, 0x38, 0x00, 0x1C, 0x00, 0x39, 0x00, 0x1F, 0x00, 0x9B,
/* 0000AE30 */ 0x00, 0x20, 0x00, 0x49, 0x00, 0x0A, 0x00, 0x3B, 0x00, 0x1F, 0x00, 0x40, 0x00, 0x20, 0x00, 0x5B,
/* 0000AE40 */ 0x00, 0x1D, 0x00, 0x79, 0x00, 0x30, 0x00, 0x69, 0x00, 0x0B, 0x00, 0x3E, 0x00, 0x08, 0x00, 0x1D,
/* 0000AE50 */ 0x00, 0x00, 0xBF, 0x5C, 0x85, 0xE0, 0x01, 0xC4, 0x00, 0xFE, 0x4D, 0x03, 0x61, 0xA0, 0x41, 0xF1,
/* 0000AE60 */ 0x00, 0x31, 0xFE, 0x0C, 0x9D, 0xFF, 0x00, 0x10, 0x01, 0x00, 0x01, 0x01, 0xFE, 0x0C, 0x9D, 0xFE,
/* 0000AE70 */ 0x9E, 0x03, 0xFE, 0x9E, 0x03, 0x03, 0x0A, 0x08, 0x0E, 0x0B, 0x4E, 0x4A, 0x02, 0x03, 0x08, 0x05,
/* 0000AE80 */ 0x07, 0x07, 0x07, 0x07, 0x0D, 0x07, 0x01, 0x00, 0x05, 0xFE, 0x9C, 0x03, 0x08, 0x01, 0x01, 0x01,
/* 0000AE90 */ 0x02, 0xFE, 0x36, 0x01, 0xAE, 0x08, 0x5B, 0x0A, 0xB4, 0x0A, 0x0A, 0x98, 0x0E, 0x08, 0x03, 0x00,
/* 0000AEA0 */ 0x00, 0x47, 0x09, 0x0E, 0xA8, 0x0E, 0x14, 0x0B, 0x00, 0x0A, 0x0E, 0x09, 0x00, 0x00, 0x14, 0x03,
/* 0000AEB0 */ 0x00, 0x0A, 0x02, 0x09, 0x22, 0x00, 0x8F, 0x02, 0x09, 0x0F, 0x00, 0x00, 0x6D, 0x0E, 0x0F, 0x00,
/* 0000AEC0 */ 0x07, 0x02, 0x00, 0x5C, 0x00, 0x0F, 0x5D, 0x01, 0x04, 0x00, 0x00, 0xF2, 0x02, 0xFF, 0x0E, 0x00,
/* 0000AED0 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x09, 0x22, 0x00, 0x14, 0x03, 0x00, 0x09, 0x02, 0x09, 0x1A, 0x00,
/* 0000AEE0 */ 0x8F, 0x02, 0x09, 0x0F, 0x00, 0x00, 0x6D, 0x0E, 0x0F, 0x01, 0x07, 0x01, 0x00, 0x5C, 0x00, 0x0F,
/* 0000AEF0 */ 0xF2, 0x01, 0xFF, 0x0E, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x8F, 0x02, 0x11, 0x0E, 0x01, 0x00,
/* 0000AF00 */ 0x07, 0x02, 0x00, 0x5C, 0x00, 0x05, 0x5C, 0x01, 0x0A, 0xEE, 0x02, 0x0E, 0x0E, 0x02, 0x00, 0x47,
/* 0000AF10 */ 0x0B, 0x0E, 0x8F, 0x02, 0x11, 0x0E, 0x01, 0x00, 0x07, 0x02, 0x00, 0x5C, 0x00, 0x05, 0x5C, 0x01,
/* 0000AF20 */ 0x09, 0xEE, 0x02, 0x0E, 0x0E, 0x03, 0x00, 0x47, 0x09, 0x0E, 0x8F, 0x02, 0x0A, 0x0E, 0x02, 0x00,
/* 0000AF30 */ 0x07, 0x03, 0x00, 0x5C, 0x00, 0x05, 0xCB, 0x0F, 0x5C, 0x01, 0x0F, 0x5D, 0x02, 0x02, 0x04, 0x00,
/* 0000AF40 */ 0xEE, 0x03, 0x0E, 0x0E, 0x04, 0x00, 0x47, 0x0C, 0x0E, 0x8F, 0x01, 0x02, 0x0E, 0x03, 0x00, 0x4B,
/* 0000AF50 */ 0x0E, 0x07, 0x04, 0x00, 0x5C, 0x00, 0x05, 0x5C, 0x01, 0x0C, 0x98, 0x0F, 0x08, 0x06, 0x01, 0x00,
/* 0000AF60 */ 0x5C, 0x02, 0x0F, 0x98, 0x0F, 0x08, 0x07, 0x02, 0x00, 0x5C, 0x03, 0x0F, 0xEE, 0x04, 0xFF, 0x0E,
/* 0000AF70 */ 0x05, 0x00, 0x8F, 0x02, 0x10, 0x0E, 0x04, 0x00, 0x07, 0x02, 0x00, 0x5C, 0x00, 0x05, 0x8F, 0x02,
/* 0000AF80 */ 0x09, 0x10, 0x00, 0x00, 0x6D, 0x0F, 0x10, 0x02, 0x07, 0x07, 0x00, 0x5C, 0x00, 0x10, 0x5C, 0x01,
/* 0000AF90 */ 0x0B, 0x5C, 0x02, 0x09, 0x62, 0x11, 0x0C, 0x03, 0x5C, 0x03, 0x11, 0x62, 0x11, 0x0C, 0x04, 0x5C,
/* 0000AFA0 */ 0x04, 0x11, 0x62, 0x11, 0x0C, 0x05, 0x5C, 0x05, 0x11, 0x62, 0x11, 0x0C, 0x06, 0x5C, 0x06, 0x11,
/* 0000AFB0 */ 0xF2, 0x07, 0x0F, 0x0F, 0x02, 0x00, 0x00, 0x00, 0x07, 0x00, 0x5C, 0x01, 0x0F, 0xEE, 0x02, 0x00,
/* 0000AFC0 */ 0x0E, 0x06, 0x00, 0x09, 0x02, 0x00, 0xA8, 0x00, 0x24, 0x00, 0xFE, 0x57, 0x02, 0xFE, 0x55, 0x02,
/* 0000AFD0 */ 0xFE, 0x28, 0x02, 0xFE, 0x6F, 0x02, 0xFE, 0x71, 0x02, 0xFE, 0x72, 0x02, 0xFE, 0x74, 0x02, 0xFE,
/* 0000AFE0 */ 0x2B, 0x9D, 0x0B, 0x07, 0x00, 0x00, 0x00, 0x09, 0x00, 0x2A, 0x00, 0x12, 0x00, 0x40, 0x00, 0x22,
/* 0000AFF0 */ 0x00, 0x6F, 0x00, 0x08, 0x00, 0x2A, 0x00, 0x1A, 0x00, 0xE5, 0x00, 0x18, 0x00, 0x2D, 0x00, 0x18,
/* 0000B000 */ 0x00, 0x2A, 0x00, 0x1F, 0x00, 0x3B, 0x00, 0x29, 0x00, 0x4E, 0x00, 0x56, 0x00, 0xB6, 0x00, 0x00,
/* 0000B010 */ 0xBF, 0x5D, 0xC9, 0xE0, 0xA1, 0xD6, 0x02, 0xFE, 0xE0, 0x02, 0x0C, 0xB3, 0x41, 0xC1, 0x00, 0xFE,
/* 0000B020 */ 0xA5, 0x03, 0x2F, 0xFE, 0x77, 0x85, 0x01, 0xFF, 0x00, 0x10, 0x01, 0x00, 0x04, 0x04, 0xFE, 0x77,
/* 0000B030 */ 0x85, 0xFE, 0x30, 0x17, 0xFE, 0x30, 0x17, 0x44, 0x03, 0x15, 0x24, 0x35, 0x08, 0xFE, 0x0A, 0x01,
/* 0000B040 */ 0xF9, 0x02, 0x02, 0x05, 0x12, 0x10, 0x13, 0x13, 0x13, 0x13, 0x01, 0x32, 0x33, 0x34, 0x35, 0x06,
/* 0000B050 */ 0xFE, 0x85, 0x03, 0x06, 0xFE, 0xA6, 0x03, 0x08, 0x06, 0xFE, 0xFD, 0x02, 0x0B, 0x06, 0xFE, 0x5D,
/* 0000B060 */ 0x03, 0x07, 0x06, 0xFE, 0x8D, 0x03, 0x06, 0xFE, 0x58, 0x03, 0x05, 0xFE, 0x4F, 0x03, 0x05, 0xFE,
/* 0000B070 */ 0x8C, 0x03, 0x06, 0xFE, 0xA7, 0x03, 0x06, 0xFE, 0xA8, 0x03, 0x06, 0xFE, 0xA9, 0x03, 0x06, 0xFE,
/* 0000B080 */ 0xAA, 0x03, 0x05, 0xFE, 0xAB, 0x03, 0x05, 0xFE, 0xAC, 0x03, 0x05, 0xFE, 0xAD, 0x03, 0x05, 0xFE,
/* 0000B090 */ 0xAE, 0x03, 0x06, 0xFE, 0xAF, 0x03, 0x06, 0xFE, 0x57, 0x03, 0x0C, 0x06, 0xFE, 0xB0, 0x03, 0x05,
/* 0000B0A0 */ 0xFE, 0xB1, 0x03, 0x05, 0xFE, 0xB2, 0x03, 0x06, 0xFE, 0xB3, 0x03, 0x06, 0xFE, 0xB4, 0x03, 0x06,
/* 0000B0B0 */ 0xFE, 0xB5, 0x03, 0x06, 0xFE, 0xF6, 0x02, 0x06, 0xFE, 0xB6, 0x03, 0x06, 0xFE, 0xB7, 0x03, 0x06,
/* 0000B0C0 */ 0xFE, 0xB8, 0x03, 0x01, 0x00, 0x01, 0xFF, 0xFE, 0xD4, 0x03, 0xA8, 0x2F, 0xA8, 0x30, 0xA8, 0x31,
/* 0000B0D0 */ 0x2C, 0x36, 0x24, 0x0D, 0x03, 0x00, 0x36, 0x02, 0x09, 0x16, 0x00, 0x8F, 0x02, 0x09, 0x37, 0x00,
/* 0000B0E0 */ 0x00, 0x6D, 0x36, 0x37, 0x00, 0x07, 0x01, 0x00, 0x5C, 0x00, 0x37, 0xF6, 0x01, 0xFF, 0x36, 0x00,
/* 0000B0F0 */ 0x00, 0x8F, 0x02, 0x0C, 0x36, 0x01, 0x00, 0x07, 0x04, 0x00, 0x5C, 0x00, 0x04, 0x8F, 0x02, 0x19,
/* 0000B100 */ 0x37, 0x02, 0x00, 0x5C, 0x01, 0x37, 0x5C, 0x02, 0x24, 0x5C, 0x03, 0x03, 0xF6, 0x04, 0x36, 0x36,
/* 0000B110 */ 0x01, 0x00, 0x0F, 0x03, 0x00, 0x36, 0x09, 0x27, 0x00, 0x62, 0x36, 0x24, 0x01, 0x0F, 0x03, 0x00,
/* 0000B120 */ 0x36, 0x09, 0x1C, 0x00, 0x8F, 0x02, 0x09, 0x37, 0x00, 0x00, 0x6D, 0x36, 0x37, 0x02, 0x07, 0x03,
/* 0000B130 */ 0x00, 0x5C, 0x00, 0x37, 0x5C, 0x01, 0x05, 0x5C, 0x02, 0x05, 0xF6, 0x03, 0xFF, 0x36, 0x02, 0x00,
/* 0000B140 */ 0x77, 0x06, 0x24, 0x03, 0x2C, 0x36, 0x26, 0x14, 0x03, 0x00, 0x36, 0x07, 0x09, 0x20, 0x00, 0x8F,
/* 0000B150 */ 0x02, 0x0A, 0x36, 0x03, 0x00, 0x07, 0x03, 0x00, 0x5C, 0x00, 0x04, 0xCB, 0x37, 0x5C, 0x01, 0x37,
/* 0000B160 */ 0x5C, 0x02, 0x08, 0xF6, 0x03, 0x36, 0x36, 0x03, 0x00, 0x47, 0x26, 0x36, 0x09, 0x1C, 0x00, 0x8F,
/* 0000B170 */ 0x02, 0x31, 0x37, 0x04, 0x00, 0x6D, 0x36, 0x37, 0x04, 0x07, 0x02, 0x00, 0x5C, 0x00, 0x37, 0x5C,
/* 0000B180 */ 0x01, 0x26, 0xF6, 0x02, 0x36, 0x36, 0x04, 0x00, 0x47, 0x26, 0x36, 0x8F, 0x02, 0x02, 0x36, 0x05,
/* 0000B190 */ 0x00, 0x07, 0x06, 0x00, 0x5C, 0x00, 0x04, 0x5C, 0x01, 0x26, 0x5C, 0x02, 0x09, 0x5C, 0x03, 0x0A,
/* 0000B1A0 */ 0xCE, 0x37, 0x02, 0x00, 0x00, 0xA1, 0x00, 0x0B, 0x37, 0xA1, 0x01, 0x0C, 0x37, 0x5C, 0x04, 0x37,
/* 0000B1B0 */ 0x5C, 0x05, 0x0C, 0xF6, 0x06, 0x36, 0x36, 0x05, 0x00, 0x47, 0x28, 0x36, 0x8F, 0x02, 0x02, 0x36,
/* 0000B1C0 */ 0x05, 0x00, 0x07, 0x06, 0x00, 0x5C, 0x00, 0x04, 0x5C, 0x01, 0x26, 0x5C, 0x02, 0x0D, 0x5C, 0x03,
/* 0000B1D0 */ 0x0A, 0xCE, 0x37, 0x02, 0x01, 0x00, 0xA1, 0x00, 0x0E, 0x37, 0xA1, 0x01, 0x0F, 0x37, 0x5C, 0x04,
/* 0000B1E0 */ 0x37, 0x5C, 0x05, 0x0E, 0xF6, 0x06, 0x36, 0x36, 0x06, 0x00, 0x47, 0x29, 0x36, 0x8F, 0x02, 0x02,
/* 0000B1F0 */ 0x36, 0x05, 0x00, 0x07, 0x06, 0x00, 0x5C, 0x00, 0x04, 0x5C, 0x01, 0x26, 0x5C, 0x02, 0x10, 0x5C,
/* 0000B200 */ 0x03, 0x0A, 0xCE, 0x37, 0x04, 0x02, 0x00, 0xA1, 0x00, 0x11, 0x37, 0xA1, 0x01, 0x12, 0x37, 0xA1,
/* 0000B210 */ 0x02, 0x13, 0x37, 0xA1, 0x03, 0x14, 0x37, 0x5C, 0x04, 0x37, 0xA8, 0x37, 0x5C, 0x05, 0x37, 0xF6,
/* 0000B220 */ 0x06, 0x36, 0x36, 0x07, 0x00, 0x47, 0x2A, 0x36, 0x8F, 0x02, 0x02, 0x36, 0x05, 0x00, 0x07, 0x06,
/* 0000B230 */ 0x00, 0x5C, 0x00, 0x04, 0x5C, 0x01, 0x26, 0x5C, 0x02, 0x15, 0x5C, 0x03, 0x16, 0xA8, 0x37, 0x5C,
/* 0000B240 */ 0x04, 0x37, 0x5C, 0x05, 0x17, 0xF6, 0x06, 0x36, 0x36, 0x08, 0x00, 0x47, 0x2B, 0x36, 0x8F, 0x02,
/* 0000B250 */ 0x02, 0x36, 0x05, 0x00, 0x07, 0x06, 0x00, 0x5C, 0x00, 0x04, 0x5C, 0x01, 0x26, 0x5C, 0x02, 0x18,
/* 0000B260 */ 0x5C, 0x03, 0x0A, 0xCE, 0x37, 0x03, 0x03, 0x00, 0xA1, 0x00, 0x19, 0x37, 0xA1, 0x01, 0x1A, 0x37,
/* 0000B270 */ 0xA1, 0x02, 0x1B, 0x37, 0x5C, 0x04, 0x37, 0xA8, 0x37, 0x5C, 0x05, 0x37, 0xF6, 0x06, 0x36, 0x36,
/* 0000B280 */ 0x09, 0x00, 0x96, 0x02, 0x36, 0x8F, 0x02, 0x02, 0x36, 0x05, 0x00, 0x07, 0x06, 0x00, 0x5C, 0x00,
/* 0000B290 */ 0x04, 0x5C, 0x01, 0x26, 0x5C, 0x02, 0x1C, 0x5C, 0x03, 0x16, 0xCE, 0x37, 0x02, 0x04, 0x00, 0xA1,
/* 0000B2A0 */ 0x00, 0x06, 0x37, 0xA1, 0x01, 0x17, 0x37, 0x5C, 0x04, 0x37, 0xA8, 0x37, 0x5C, 0x05, 0x37, 0xF6,
/* 0000B2B0 */ 0x06, 0x36, 0x36, 0x0A, 0x00, 0x96, 0x03, 0x36, 0x8F, 0x02, 0x07, 0x36, 0x06, 0x00, 0x07, 0x02,
/* 0000B2C0 */ 0x00, 0x5C, 0x00, 0x04, 0x5C, 0x01, 0x25, 0xF6, 0x02, 0x36, 0x36, 0x0B, 0x00, 0x47, 0x25, 0x36,
/* 0000B2D0 */ 0x8F, 0x02, 0x2F, 0x36, 0x07, 0x00, 0x07, 0x05, 0x00, 0x5C, 0x00, 0x04, 0x5C, 0x01, 0x25, 0x5C,
/* 0000B2E0 */ 0x02, 0x28, 0xA8, 0x37, 0x5C, 0x03, 0x37, 0x8F, 0x02, 0x37, 0x37, 0x08, 0x00, 0x5C, 0x04, 0x37,
/* 0000B2F0 */ 0xF6, 0x05, 0x36, 0x36, 0x0C, 0x00, 0x47, 0x2C, 0x36, 0x96, 0x04, 0x1D, 0x8F, 0x02, 0x2C, 0x36,
/* 0000B300 */ 0x09, 0x00, 0x07, 0x02, 0x00, 0x5C, 0x00, 0x04, 0x62, 0x37, 0x2C, 0x05, 0x5C, 0x01, 0x37, 0xF6,
/* 0000B310 */ 0x02, 0x36, 0x36, 0x0D, 0x00, 0x47, 0x2D, 0x36, 0x47, 0x2E, 0x2D, 0x62, 0x36, 0x2C, 0x06, 0x0F,
/* 0000B320 */ 0x03, 0x00, 0x36, 0x09, 0x28, 0x00, 0x8F, 0x02, 0x0C, 0x36, 0x01, 0x00, 0x07, 0x04, 0x00, 0x5C,
/* 0000B330 */ 0x00, 0x04, 0x8F, 0x02, 0x1C, 0x37, 0x0A, 0x00, 0x5C, 0x01, 0x37, 0x62, 0x37, 0x2C, 0x06, 0x5C,
/* 0000B340 */ 0x02, 0x37, 0xD4, 0x00, 0x37, 0x5C, 0x03, 0x37, 0xF6, 0x04, 0xFF, 0x36, 0x0E, 0x00, 0x93, 0x04,
/* 0000B350 */ 0x36, 0x0B, 0x00, 0x15, 0x03, 0x00, 0x36, 0x1D, 0x09, 0x50, 0x00, 0x8F, 0x02, 0x35, 0x36, 0x0C,
/* 0000B360 */ 0x00, 0x98, 0x36, 0x36, 0x2E, 0x00, 0x00, 0x47, 0x2F, 0x36, 0x47, 0x30, 0x1E, 0xA8, 0x36, 0x15,
/* 0000B370 */ 0x03, 0x00, 0x2F, 0x36, 0x09, 0x31, 0x00, 0x93, 0x04, 0x37, 0x0B, 0x00, 0x98, 0x37, 0x2F, 0x37,
/* 0000B380 */ 0x01, 0x00, 0x47, 0x30, 0x37, 0x47, 0x36, 0x37, 0xA8, 0x37, 0x15, 0x03, 0x00, 0x36, 0x37, 0x09,
/* 0000B390 */ 0x16, 0x00, 0x15, 0x03, 0x00, 0x30, 0x1E, 0x09, 0x0B, 0x00, 0x2F, 0x36, 0x2E, 0x1F, 0x2F, 0x36,
/* 0000B3A0 */ 0x36, 0x30, 0x47, 0x2E, 0x36, 0x09, 0x03, 0x00, 0x96, 0x04, 0x1D, 0x93, 0x02, 0x36, 0x0D, 0x00,
/* 0000B3B0 */ 0xA8, 0x37, 0x14, 0x03, 0x00, 0x36, 0x37, 0x09, 0x86, 0x00, 0xE5, 0x35, 0x00, 0x8F, 0x02, 0x09,
/* 0000B3C0 */ 0x37, 0x00, 0x00, 0x6D, 0x36, 0x37, 0x07, 0x07, 0x07, 0x00, 0x5C, 0x00, 0x37, 0x5C, 0x01, 0x20,
/* 0000B3D0 */ 0x5C, 0x02, 0x21, 0x5C, 0x03, 0x2D, 0xA8, 0x38, 0x5C, 0x04, 0x38, 0xA8, 0x38, 0x5C, 0x05, 0x38,
/* 0000B3E0 */ 0xA8, 0x38, 0x5C, 0x06, 0x38, 0xF6, 0x07, 0x36, 0x36, 0x0F, 0x00, 0x47, 0x31, 0x36, 0xE9, 0x09,
/* 0000B3F0 */ 0x2F, 0x00, 0xE7, 0x27, 0x06, 0x8F, 0x02, 0x29, 0x36, 0x0E, 0x00, 0x07, 0x02, 0x00, 0x5C, 0x00,
/* 0000B400 */ 0x04, 0x5C, 0x01, 0x27, 0xF6, 0x02, 0xFF, 0x36, 0x10, 0x00, 0x8F, 0x02, 0x09, 0x37, 0x00, 0x00,
/* 0000B410 */ 0x6D, 0x36, 0x37, 0x08, 0x07, 0x01, 0x00, 0x5C, 0x00, 0x37, 0xF6, 0x01, 0xFF, 0x36, 0x11, 0x00,
/* 0000B420 */ 0xE9, 0x14, 0x03, 0x00, 0x31, 0x22, 0x09, 0x06, 0x00, 0x96, 0x02, 0x1B, 0x09, 0x11, 0x00, 0x14,
/* 0000B430 */ 0x03, 0x00, 0x31, 0x23, 0x09, 0x06, 0x00, 0x96, 0x02, 0x19, 0x09, 0x03, 0x00, 0x96, 0x02, 0x1A,
/* 0000B440 */ 0xA8, 0x36, 0x14, 0x03, 0x00, 0x2A, 0x36, 0x09, 0x03, 0x00, 0x47, 0x2A, 0x14, 0x93, 0x03, 0x36,
/* 0000B450 */ 0x0F, 0x00, 0xA8, 0x37, 0x14, 0x03, 0x00, 0x36, 0x37, 0x09, 0x03, 0x00, 0x96, 0x03, 0x17, 0x77,
/* 0000B460 */ 0x28, 0x24, 0x09, 0x62, 0x36, 0x2C, 0x05, 0x77, 0x36, 0x24, 0x0A, 0x77, 0x2E, 0x24, 0x0B, 0x77,
/* 0000B470 */ 0x29, 0x24, 0x0C, 0x77, 0x2A, 0x24, 0x0D, 0x77, 0x2B, 0x24, 0x0E, 0x93, 0x02, 0x36, 0x0D, 0x00,
/* 0000B480 */ 0x77, 0x36, 0x24, 0x0F, 0x93, 0x03, 0x36, 0x0F, 0x00, 0x77, 0x36, 0x24, 0x10, 0x93, 0x04, 0x36,
/* 0000B490 */ 0x0B, 0x00, 0x77, 0x36, 0x24, 0x11, 0x77, 0x06, 0x24, 0x12, 0xA8, 0x00, 0x24, 0x00, 0xFE, 0x55,
/* 0000B4A0 */ 0x02, 0xFE, 0x6A, 0x02, 0xFE, 0x65, 0x02, 0xFE, 0x6A, 0x02, 0xFE, 0x51, 0x03, 0xFE, 0x6D, 0x02,
/* 0000B4B0 */ 0xFE, 0x39, 0x02, 0xFE, 0x28, 0x02, 0xFE, 0x5E, 0x02, 0xFE, 0x6E, 0x02, 0xFE, 0x17, 0x02, 0xFE,
/* 0000B4C0 */ 0x6F, 0x02, 0xFE, 0x70, 0x02, 0xFE, 0x71, 0x02, 0xFE, 0x72, 0x02, 0xFE, 0x73, 0x02, 0xFE, 0x74,
/* 0000B4D0 */ 0x02, 0xFE, 0x75, 0x02, 0xFE, 0x76, 0x02, 0xFE, 0xB0, 0x03, 0xFE, 0x21, 0x02, 0xFE, 0xB9, 0x03,
/* 0000B4E0 */ 0xFE, 0xC5, 0x85, 0x35, 0x06, 0x00, 0x00, 0x00, 0x0B, 0x00, 0x38, 0x00, 0x16, 0x00, 0x42, 0x00,
/* 0000B4F0 */ 0x33, 0x00, 0x94, 0x00, 0x1C, 0x00, 0x68, 0x00, 0x04, 0x00, 0x60, 0x00, 0x0B, 0x00, 0x3B, 0x00,
/* 0000B500 */ 0x20, 0x00, 0x51, 0x00, 0x1C, 0x00, 0x4C, 0x00, 0x31, 0x00, 0x72, 0x00, 0x31, 0x00, 0x60, 0x00,
/* 0000B510 */ 0x3B, 0x00, 0x82, 0x00, 0x26, 0x00, 0x6F, 0x00, 0x37, 0x00, 0x74, 0x00, 0x33, 0x00, 0x9E, 0x00,
/* 0000B520 */ 0x18, 0x00, 0x42, 0x00, 0x29, 0x00, 0x71, 0x00, 0x03, 0x00, 0x2C, 0x00, 0x1C, 0x00, 0x6A, 0x00,
/* 0000B530 */ 0x03, 0x00, 0x48, 0x00, 0x0B, 0x00, 0x37, 0x00, 0x28, 0x00, 0x45, 0x05, 0x0D, 0x00, 0x34, 0x00,
/* 0000B540 */ 0x0F, 0x00, 0x70, 0x00, 0x03, 0x00, 0x30, 0x00, 0x25, 0x00, 0x93, 0x00, 0x08, 0x00, 0x3C, 0x00,
/* 0000B550 */ 0x0E, 0x00, 0xB5, 0x00, 0x03, 0x00, 0x84, 0x00, 0x12, 0x00, 0x53, 0x00, 0x37, 0x00, 0x7A, 0x00,
/* 0000B560 */ 0x01, 0x00, 0x54, 0x00, 0x15, 0x00, 0x97, 0x01, 0x17, 0x00, 0x55, 0x00, 0x08, 0x00, 0x2A, 0x00,
/* 0000B570 */ 0x06, 0x00, 0x31, 0x00, 0x08, 0x00, 0x2B, 0x00, 0x06, 0x00, 0x4C, 0x00, 0x03, 0x00, 0x52, 0x00,
/* 0000B580 */ 0x0A, 0x00, 0x36, 0x00, 0x03, 0x00, 0x3F, 0x00, 0x0F, 0x00, 0x32, 0x00, 0x03, 0x00, 0x69, 0x00,
/* 0000B590 */ 0x04, 0x00, 0x2F, 0x00, 0x08, 0x00, 0x4E, 0x00, 0x04, 0x00, 0x49, 0x00, 0x04, 0x00, 0x2B, 0x00,
/* 0000B5A0 */ 0x04, 0x00, 0x37, 0x00, 0x04, 0x00, 0x43, 0x00, 0x09, 0x00, 0x33, 0x00, 0x09, 0x00, 0x2F, 0x00,
/* 0000B5B0 */ 0x09, 0x00, 0x33, 0x00, 0x06, 0x00, 0x34, 0x00, 0x00, 0xBD, 0xB5, 0x00, 0x00, 0xBF, 0x5C, 0x8D,
/* 0000B5C0 */ 0xE0, 0x19, 0xC4, 0x10, 0xFE, 0x02, 0x03, 0x57, 0xA2, 0x41, 0xD1, 0x00, 0x30, 0xFE, 0x53, 0x8D,
/* 0000B5D0 */ 0xFF, 0x00, 0x10, 0x01, 0x00, 0x02, 0x02, 0xFE, 0x53, 0x8D, 0xFE, 0xDB, 0x04, 0xFE, 0xDB, 0x04,
/* 0000B5E0 */ 0x41, 0x09, 0x15, 0x1A, 0x0B, 0x5E, 0x59, 0x03, 0x03, 0x05, 0x01, 0x08, 0x03, 0x03, 0x03, 0x03,
/* 0000B5F0 */ 0x01, 0x01, 0x19, 0x01, 0x01, 0x01, 0x02, 0x06, 0xFE, 0xF6, 0x02, 0x05, 0xFE, 0xBA, 0x03, 0x06,
/* 0000B600 */ 0xFE, 0xB0, 0x03, 0x07, 0x08, 0x06, 0xFE, 0x58, 0x03, 0x05, 0xFE, 0xB1, 0x03, 0x05, 0xFE, 0xB2,
/* 0000B610 */ 0x03, 0x06, 0xFE, 0xB3, 0x03, 0x05, 0xFE, 0xBB, 0x03, 0x06, 0xFE, 0xBC, 0x03, 0x0B, 0x05, 0xFE,
/* 0000B620 */ 0xBD, 0x03, 0x06, 0xFE, 0xB5, 0x03, 0x06, 0xFE, 0xA9, 0x03, 0x06, 0xFE, 0xA8, 0x03, 0x05, 0xFE,
/* 0000B630 */ 0xBE, 0x03, 0xFE, 0x7C, 0x01, 0x8F, 0x03, 0x09, 0x1B, 0x00, 0x00, 0x6D, 0x1A, 0x1B, 0x00, 0x07,
/* 0000B640 */ 0x03, 0x00, 0x5C, 0x00, 0x1B, 0x5C, 0x01, 0x15, 0xE0, 0x1C, 0x00, 0x5C, 0x02, 0x1C, 0xF2, 0x03,
/* 0000B650 */ 0x1A, 0x1A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x47, 0x16, 0x1A, 0x98, 0x1A, 0x16, 0x02, 0x00,
/* 0000B660 */ 0x00, 0x47, 0x17, 0x1A, 0x98, 0x1A, 0x16, 0x03, 0x01, 0x00, 0x14, 0x03, 0x00, 0x1A, 0x04, 0x09,
/* 0000B670 */ 0x08, 0x00, 0xA8, 0x1B, 0x47, 0x1A, 0x1B, 0x09, 0x09, 0x00, 0x98, 0x1B, 0x16, 0x03, 0x02, 0x00,
/* 0000B680 */ 0x47, 0x1A, 0x1B, 0x47, 0x18, 0x1A, 0x14, 0x03, 0x00, 0x17, 0x05, 0x09, 0x7A, 0x00, 0x8F, 0x01,
/* 0000B690 */ 0x02, 0x1A, 0x01, 0x00, 0xA8, 0x1B, 0x14, 0x03, 0x00, 0x1A, 0x1B, 0x09, 0x6A, 0x00, 0x8F, 0x03,
/* 0000B6A0 */ 0x02, 0x1A, 0x02, 0x00, 0x07, 0x06, 0x00, 0x5C, 0x00, 0x08, 0x8F, 0x03, 0x0A, 0x1B, 0x03, 0x00,
/* 0000B6B0 */ 0x07, 0x03, 0x00, 0x5C, 0x00, 0x08, 0xCC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1C,
/* 0000B6C0 */ 0x00, 0x00, 0x00, 0x7B, 0x18, 0x1C, 0x01, 0x5C, 0x01, 0x1C, 0x5D, 0x02, 0x07, 0x02, 0x00, 0xEE,
/* 0000B6D0 */ 0x03, 0x1B, 0x1B, 0x02, 0x00, 0x5C, 0x01, 0x1B, 0x5D, 0x02, 0x06, 0x01, 0x00, 0x5D, 0x03, 0x09,
/* 0000B6E0 */ 0x01, 0x00, 0xCE, 0x1B, 0x03, 0x00, 0x00, 0xA1, 0x00, 0x0A, 0x1B, 0xA1, 0x01, 0x0B, 0x1B, 0xA1,
/* 0000B6F0 */ 0x02, 0x0C, 0x1B, 0x5C, 0x04, 0x1B, 0xA8, 0x1B, 0x5C, 0x05, 0x1B, 0xEE, 0x06, 0x1A, 0x1A, 0x01,
/* 0000B700 */ 0x00, 0x94, 0x01, 0x02, 0x1A, 0x09, 0xA5, 0x00, 0x14, 0x03, 0x00, 0x17, 0x0D, 0x09, 0x67, 0x00,
/* 0000B710 */ 0x8F, 0x01, 0x03, 0x1A, 0x04, 0x00, 0xA8, 0x1B, 0x14, 0x03, 0x00, 0x1A, 0x1B, 0x09, 0x57, 0x00,
/* 0000B720 */ 0xA8, 0x1A, 0x15, 0x03, 0x00, 0x18, 0x1A, 0x09, 0x46, 0x00, 0x8F, 0x03, 0x31, 0x1B, 0x05, 0x00,
/* 0000B730 */ 0x6D, 0x1A, 0x1B, 0x02, 0x07, 0x02, 0x00, 0x5C, 0x00, 0x1B, 0x8F, 0x03, 0x0C, 0x1C, 0x06, 0x00,
/* 0000B740 */ 0x07, 0x03, 0x00, 0x5C, 0x00, 0x08, 0x8F, 0x03, 0x24, 0x1D, 0x07, 0x00, 0x5C, 0x01, 0x1D, 0x5C,
/* 0000B750 */ 0x02, 0x18, 0xEE, 0x03, 0x1C, 0x1C, 0x04, 0x00, 0x43, 0x1C, 0x1C, 0x0E, 0x5C, 0x01, 0x1C, 0xF2,
/* 0000B760 */ 0x02, 0x1A, 0x1A, 0x02, 0x00, 0x00, 0x00, 0x03, 0x00, 0x94, 0x01, 0x03, 0x1A, 0x09, 0x04, 0x00,
/* 0000B770 */ 0x94, 0x01, 0x03, 0x0F, 0x09, 0x36, 0x00, 0x14, 0x03, 0x00, 0x17, 0x10, 0x09, 0x2E, 0x00, 0xA8,
/* 0000B780 */ 0x1A, 0x15, 0x03, 0x00, 0x18, 0x1A, 0x09, 0x24, 0x00, 0x15, 0x03, 0x00, 0x18, 0x11, 0x09, 0x1C,
/* 0000B790 */ 0x00, 0x15, 0x03, 0x00, 0x18, 0x12, 0x09, 0x14, 0x00, 0x15, 0x03, 0x00, 0x18, 0x13, 0x09, 0x0C,
/* 0000B7A0 */ 0x00, 0x15, 0x03, 0x00, 0x18, 0x14, 0x09, 0x04, 0x00, 0x94, 0x01, 0x04, 0x18, 0xA8, 0x00, 0x24,
/* 0000B7B0 */ 0x00, 0x01, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
/* 0000B7C0 */ 0xB0, 0x03, 0x00, 0x00, 0xFE, 0x37, 0x02, 0xFE, 0xB0, 0x03, 0xFE, 0x5A, 0x02, 0x0E, 0xFE, 0x4E,
/* 0000B7D0 */ 0x03, 0x00, 0xFE, 0x80, 0x8D, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x26, 0x00, 0x83, 0x00, 0x09, 0x00,
/* 0000B7E0 */ 0x2D, 0x00, 0x22, 0x00, 0x4D, 0x00, 0x18, 0x00, 0x4C, 0x00, 0x6A, 0x00, 0xA0, 0x00, 0x18, 0x00,
/* 0000B7F0 */ 0x4A, 0x00, 0x0A, 0x00, 0x3C, 0x00, 0x46, 0x00, 0xAB, 0x00, 0x07, 0x00, 0x4F, 0x00, 0x32, 0x00,
/* 0000B800 */ 0x01, 0x01, 0x06, 0x00, 0x43, 0x00, 0x00, 0xBF, 0x5C, 0x85, 0xE0, 0x31, 0xD4, 0x02, 0xFE, 0xA4,
/* 0000B810 */ 0x02, 0x1E, 0xA0, 0x41, 0xC1, 0x00, 0xFE, 0x2E, 0x03, 0x2C, 0xFE, 0xB2, 0x7B, 0x01, 0xFF, 0x00,
/* 0000B820 */ 0x10, 0x01, 0x00, 0x01, 0x01, 0xFE, 0xB2, 0x7B, 0xFE, 0x1A, 0x09, 0xFE, 0x1A, 0x09, 0x01, 0x0C,
/* 0000B830 */ 0x07, 0x0F, 0x06, 0x7E, 0x76, 0x01, 0x05, 0x08, 0x07, 0x02, 0x02, 0x02, 0x02, 0x02, 0x01, 0x0E,
/* 0000B840 */ 0x0F, 0x08, 0x01, 0x01, 0x05, 0xFE, 0x96, 0x03, 0x06, 0xFE, 0xF6, 0x02, 0x01, 0x02, 0xFE, 0xD9,
/* 0000B850 */ 0x01, 0x4F, 0x07, 0x4F, 0x08, 0x4F, 0x0B, 0x4F, 0x0C, 0x4F, 0x0D, 0x4F, 0x09, 0x4F, 0x0A, 0x8F,
/* 0000B860 */ 0x01, 0x4B, 0x10, 0x00, 0x00, 0x4B, 0x10, 0x0F, 0x03, 0x00, 0x10, 0x09, 0x1C, 0x00, 0x8F, 0x01,
/* 0000B870 */ 0x09, 0x10, 0x01, 0x00, 0x62, 0x10, 0x10, 0x00, 0x0F, 0x03, 0x00, 0x10, 0x09, 0x0B, 0x00, 0x8F,
/* 0000B880 */ 0x01, 0x4B, 0x00, 0x00, 0x00, 0x4B, 0x00, 0x09, 0x9E, 0x01, 0xA8, 0x10, 0x47, 0x07, 0x10, 0xA8,
/* 0000B890 */ 0x10, 0x47, 0x08, 0x10, 0x8F, 0x01, 0x39, 0x10, 0x02, 0x00, 0x4B, 0x10, 0x0F, 0x03, 0x00, 0x10,
/* 0000B8A0 */ 0x09, 0x89, 0x00, 0x8F, 0x01, 0x3C, 0x10, 0x03, 0x00, 0x4B, 0x10, 0x07, 0x01, 0x00, 0x5C, 0x00,
/* 0000B8B0 */ 0x02, 0xEE, 0x01, 0x10, 0x10, 0x00, 0x00, 0x47, 0x07, 0x10, 0x8F, 0x01, 0x09, 0x11, 0x01, 0x00,
/* 0000B8C0 */ 0x6D, 0x10, 0x11, 0x01, 0x07, 0x03, 0x00, 0x5C, 0x00, 0x11, 0x5C, 0x01, 0x07, 0xE0, 0x12, 0x00,
/* 0000B8D0 */ 0x5C, 0x02, 0x12, 0xF2, 0x03, 0x10, 0x10, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x54, 0x09, 0x10,
/* 0000B8E0 */ 0x0F, 0x03, 0x00, 0x09, 0x09, 0x42, 0x00, 0x98, 0x10, 0x09, 0x03, 0x00, 0x00, 0x47, 0x08, 0x10,
/* 0000B8F0 */ 0x8F, 0x01, 0x0C, 0x10, 0x04, 0x00, 0x07, 0x05, 0x00, 0x5C, 0x00, 0x02, 0x8F, 0x01, 0x23, 0x11,
/* 0000B900 */ 0x05, 0x00, 0x5C, 0x01, 0x11, 0x5C, 0x02, 0x07, 0x47, 0x11, 0x04, 0x01, 0x04, 0x01, 0x12, 0x08,
/* 0000B910 */ 0x2F, 0x11, 0x11, 0x12, 0x2F, 0x11, 0x11, 0x05, 0x5C, 0x03, 0x11, 0x5D, 0x04, 0x05, 0x02, 0x00,
/* 0000B920 */ 0xEE, 0x05, 0x10, 0x10, 0x02, 0x00, 0x47, 0x07, 0x10, 0x09, 0x4C, 0x00, 0x8F, 0x01, 0x09, 0x11,
/* 0000B930 */ 0x01, 0x00, 0x6D, 0x10, 0x11, 0x01, 0x07, 0x03, 0x00, 0x5C, 0x00, 0x11, 0x8F, 0x01, 0x3C, 0x12,
/* 0000B940 */ 0x03, 0x00, 0x4B, 0x12, 0x07, 0x01, 0x00, 0x5C, 0x00, 0x02, 0xEE, 0x01, 0x12, 0x12, 0x04, 0x00,
/* 0000B950 */ 0x5C, 0x01, 0x12, 0xE0, 0x12, 0x01, 0x5C, 0x02, 0x12, 0xF2, 0x03, 0x10, 0x10, 0x01, 0x00, 0x00,
/* 0000B960 */ 0x00, 0x03, 0x00, 0x54, 0x0A, 0x10, 0x98, 0x10, 0x0A, 0x03, 0x01, 0x00, 0x47, 0x07, 0x10, 0x98,
/* 0000B970 */ 0x10, 0x0A, 0x06, 0x02, 0x00, 0x47, 0x08, 0x10, 0xA8, 0x10, 0x14, 0x03, 0x00, 0x08, 0x10, 0x09,
/* 0000B980 */ 0x11, 0x00, 0x01, 0x32, 0x01, 0x01, 0x4B, 0x07, 0x8F, 0x01, 0x4B, 0x00, 0x00, 0x00, 0x4B, 0x00,
/* 0000B990 */ 0x09, 0x95, 0x00, 0xD6, 0x00, 0x10, 0x54, 0x0B, 0x10, 0x8F, 0x01, 0x36, 0x10, 0x06, 0x00, 0x98,
/* 0000B9A0 */ 0x10, 0x10, 0x07, 0x03, 0x00, 0x54, 0x0C, 0x10, 0xA8, 0x10, 0x14, 0x03, 0x00, 0x0C, 0x10, 0x09,
/* 0000B9B0 */ 0x23, 0x00, 0x07, 0x03, 0x00, 0x5C, 0x00, 0x02, 0x5C, 0x01, 0x07, 0x5C, 0x02, 0x08, 0xEE, 0x03,
/* 0000B9C0 */ 0x10, 0x0B, 0x05, 0x00, 0x01, 0x32, 0x01, 0x01, 0x4B, 0x10, 0x8F, 0x01, 0x4B, 0x00, 0x00, 0x00,
/* 0000B9D0 */ 0x4B, 0x00, 0x09, 0x53, 0x00, 0x98, 0x10, 0x0C, 0x08, 0x04, 0x00, 0x54, 0x0D, 0x10, 0xA8, 0x10,
/* 0000B9E0 */ 0x15, 0x03, 0x00, 0x0D, 0x10, 0x09, 0x1B, 0x00, 0x07, 0x03, 0x00, 0x5C, 0x00, 0x02, 0x5C, 0x01,
/* 0000B9F0 */ 0x07, 0x5C, 0x02, 0x0D, 0xEE, 0x03, 0x10, 0x0B, 0x06, 0x00, 0x01, 0x32, 0x01, 0x01, 0x4B, 0x10,
/* 0000BA00 */ 0x09, 0x18, 0x00, 0x07, 0x03, 0x00, 0x5C, 0x00, 0x02, 0x5C, 0x01, 0x07, 0x5C, 0x02, 0x08, 0xEE,
/* 0000BA10 */ 0x03, 0x10, 0x0B, 0x07, 0x00, 0x01, 0x32, 0x01, 0x01, 0x4B, 0x10, 0x8F, 0x01, 0x4B, 0x00, 0x00,
/* 0000BA20 */ 0x00, 0x4B, 0x00, 0x09, 0x02, 0x00, 0xA8, 0x00, 0x24, 0x00, 0xFE, 0x03, 0x03, 0xFE, 0x37, 0x02,
/* 0000BA30 */ 0x28, 0xFE, 0x97, 0x03, 0x00, 0x0E, 0xFE, 0x98, 0x03, 0x00, 0xFE, 0xC9, 0x7B, 0x1B, 0x0E, 0x00,
/* 0000BA40 */ 0x00, 0x00, 0x20, 0x00, 0x40, 0x00, 0x0B, 0x00, 0x34, 0x00, 0x05, 0x00, 0x21, 0x00, 0x05, 0x00,
/* 0000BA50 */ 0x24, 0x00, 0x0F, 0x00, 0x7C, 0x00, 0x17, 0x00, 0x2A, 0x00, 0x26, 0x00, 0x6B, 0x00, 0x07, 0x00,
/* 0000BA60 */ 0xBB, 0x00, 0x09, 0x00, 0x27, 0x00, 0x3C, 0x00, 0xCA, 0x00, 0x3A, 0x00, 0x5D, 0x00, 0x09, 0x00,
/* 0000BA70 */ 0x20, 0x00, 0x09, 0x00, 0x2C, 0x00, 0x0A, 0x00, 0x2C, 0x00, 0x06, 0x00, 0x2D, 0x00, 0x0B, 0x00,
/* 0000BA80 */ 0x91, 0x00, 0x06, 0x00, 0x30, 0x01, 0x0F, 0x00, 0x57, 0x00, 0x0A, 0x00, 0x86, 0x00, 0x18, 0x00,
/* 0000BA90 */ 0x55, 0x00, 0x0B, 0x00, 0x34, 0x00, 0x09, 0x00, 0x43, 0x00, 0x0A, 0x00, 0x32, 0x00, 0x1B, 0x00,
/* 0000BAA0 */ 0x6D, 0x00, 0x18, 0x00, 0x5E, 0x00, 0x0D, 0x00, 0x23, 0x00, 0x00, 0xAF, 0xBA, 0x00, 0x00, 0xBF,
/* 0000BAB0 */ 0x4C, 0x80, 0x00, 0x00, 0xC4, 0x00, 0xFE, 0xC2, 0x02, 0x2C, 0xA2, 0x41, 0xC1, 0x00, 0xFE, 0x99,
/* 0000BAC0 */ 0x03, 0x2D, 0xFE, 0xF6, 0x80, 0xFF, 0x00, 0x10, 0x01, 0x00, 0x03, 0x03, 0xFE, 0xF6, 0x80, 0xFE,
/* 0000BAD0 */ 0xFF, 0x00, 0xFE, 0xFF, 0x00, 0x01, 0x04, 0x05, 0x08, 0x18, 0x16, 0x01, 0x01, 0x07, 0x06, 0xFE,
/* 0000BAE0 */ 0xF6, 0x02, 0x05, 0xFE, 0x96, 0x03, 0x05, 0xFE, 0x9A, 0x03, 0x56, 0x8F, 0x01, 0x39, 0x08, 0x00,
/* 0000BAF0 */ 0x00, 0x4B, 0x08, 0x0F, 0x03, 0x00, 0x08, 0x09, 0x23, 0x00, 0x47, 0x00, 0x02, 0x01, 0x04, 0x01,
/* 0000BB00 */ 0x08, 0x05, 0x2F, 0x00, 0x00, 0x08, 0x2F, 0x00, 0x00, 0x03, 0x01, 0x04, 0x01, 0x08, 0x06, 0x2F,
/* 0000BB10 */ 0x00, 0x00, 0x08, 0x2F, 0x00, 0x00, 0x02, 0x09, 0x25, 0x00, 0x09, 0x20, 0x00, 0x47, 0x00, 0x02,
/* 0000BB20 */ 0x01, 0x04, 0x01, 0x08, 0x05, 0x2F, 0x00, 0x00, 0x08, 0x2F, 0x00, 0x00, 0x04, 0x01, 0x04, 0x01,
/* 0000BB30 */ 0x08, 0x06, 0x2F, 0x00, 0x00, 0x08, 0x2F, 0x00, 0x00, 0x02, 0x09, 0x02, 0x00, 0xA8, 0x00, 0x24,
/* 0000BB40 */ 0x00, 0xFE, 0x2C, 0x81, 0x04, 0x00, 0x00, 0x00, 0x00, 0x0F, 0x00, 0x2B, 0x00, 0x23, 0x00, 0x55,
/* 0000BB50 */ 0x00, 0x22, 0x00, 0x48, 0x00, 0x00, 0x3F, 0x5D, 0x84, 0x00, 0x80, 0xC6, 0x02, 0xFE, 0x8F, 0x02,
/* 0000BB60 */ 0x32, 0xA0, 0x41, 0xD1, 0x00, 0x29, 0xFE, 0xBC, 0x77, 0x01, 0xFF, 0x00, 0x10, 0x01, 0x00, 0x01,
/* 0000BB70 */ 0x01, 0xFE, 0xBC, 0x77, 0xFE, 0x23, 0x03, 0xFE, 0x23, 0x03, 0x01, 0x06, 0x04, 0x07, 0x08, 0x1E,
/* 0000BB80 */ 0x1E, 0x01, 0x03, 0x06, 0x04, 0x05, 0x06, 0x07, 0x08, 0x6F, 0x4F, 0x07, 0x96, 0x02, 0x07, 0x8F,
/* 0000BB90 */ 0x01, 0x0A, 0x07, 0x00, 0x00, 0x07, 0x03, 0x00, 0x5C, 0x00, 0x03, 0xCB, 0x08, 0x5C, 0x01, 0x08,
/* 0000BBA0 */ 0x5D, 0x02, 0x02, 0x00, 0x00, 0xEE, 0x03, 0x07, 0x07, 0x00, 0x00, 0x96, 0x02, 0x07, 0x8F, 0x01,
/* 0000BBB0 */ 0x0C, 0x07, 0x01, 0x00, 0x07, 0x04, 0x00, 0x5C, 0x00, 0x03, 0x8F, 0x01, 0x1C, 0x08, 0x02, 0x00,
/* 0000BBC0 */ 0x5C, 0x01, 0x08, 0x8F, 0x01, 0x18, 0x08, 0x03, 0x00, 0x07, 0x02, 0x00, 0x5C, 0x00, 0x03, 0x8F,
/* 0000BBD0 */ 0x01, 0x35, 0x09, 0x04, 0x00, 0x5C, 0x01, 0x09, 0xEE, 0x02, 0x08, 0x08, 0x02, 0x00, 0x5C, 0x02,
/* 0000BBE0 */ 0x08, 0xD4, 0x00, 0x08, 0x5C, 0x03, 0x08, 0xEE, 0x04, 0xFF, 0x07, 0x01, 0x00, 0x93, 0x02, 0x00,
/* 0000BBF0 */ 0x05, 0x00, 0x09, 0x02, 0x00, 0xA8, 0x00, 0x24, 0x00, 0xFE, 0x93, 0x03, 0xFE, 0xD3, 0x77, 0x04,
/* 0000BC00 */ 0x05, 0x00, 0x00, 0x00, 0x1F, 0x00, 0x32, 0x00, 0x3F, 0x00, 0xC3, 0x02, 0x0A, 0x00, 0x16, 0x00,
/* 0000BC10 */ 0x00, 0x15, 0xBC, 0x00, 0x00, 0xBF, 0x5D, 0x87, 0x00, 0x80, 0xC6, 0x02, 0xFE, 0x91, 0x02, 0x6B,
/* 0000BC20 */ 0xA2, 0x41, 0xD1, 0x00, 0x2A, 0xFE, 0x68, 0x78, 0x01, 0xFF, 0x00, 0x10, 0x01, 0x00, 0x02, 0x02,
/* 0000BC30 */ 0xFE, 0x68, 0x78, 0xFE, 0x54, 0x02, 0xFE, 0x54, 0x02, 0x40, 0x02, 0x07, 0x04, 0x08, 0x08, 0x25,
/* 0000BC40 */ 0x25, 0x02, 0x01, 0x01, 0x03, 0x08, 0x05, 0x06, 0x07, 0x07, 0x08, 0x8D, 0x4F, 0x08, 0x96, 0x02,
/* 0000BC50 */ 0x08, 0x4F, 0x08, 0x96, 0x03, 0x08, 0x8F, 0x02, 0x35, 0x08, 0x00, 0x00, 0x98, 0x08, 0x08, 0x04,
/* 0000BC60 */ 0x00, 0x00, 0x96, 0x02, 0x08, 0x8F, 0x02, 0x0A, 0x08, 0x01, 0x00, 0x07, 0x03, 0x00, 0x5C, 0x00,
/* 0000BC70 */ 0x03, 0xCB, 0x09, 0x5C, 0x01, 0x09, 0x5D, 0x02, 0x02, 0x00, 0x00, 0xEE, 0x03, 0x08, 0x08, 0x00,
/* 0000BC80 */ 0x00, 0x96, 0x03, 0x08, 0x8F, 0x02, 0x0C, 0x08, 0x02, 0x00, 0x07, 0x04, 0x00, 0x5C, 0x00, 0x03,
/* 0000BC90 */ 0x8F, 0x02, 0x1C, 0x09, 0x03, 0x00, 0x5C, 0x01, 0x09, 0x8F, 0x02, 0x18, 0x09, 0x04, 0x00, 0x07,
/* 0000BCA0 */ 0x02, 0x00, 0x5C, 0x00, 0x03, 0x93, 0x02, 0x0A, 0x05, 0x00, 0x5C, 0x01, 0x0A, 0xEE, 0x02, 0x09,
/* 0000BCB0 */ 0x09, 0x02, 0x00, 0x5C, 0x02, 0x09, 0xD4, 0x00, 0x09, 0x5C, 0x03, 0x09, 0xEE, 0x04, 0xFF, 0x08,
/* 0000BCC0 */ 0x01, 0x00, 0x8F, 0x01, 0x02, 0x08, 0x06, 0x00, 0x4B, 0x08, 0x93, 0x03, 0x09, 0x07, 0x00, 0x9D,
/* 0000BCD0 */ 0x09, 0x08, 0x04, 0x00, 0x00, 0xA8, 0x00, 0x24, 0x00, 0xFE, 0x94, 0x03, 0xFE, 0x95, 0x03, 0xFE,
/* 0000BCE0 */ 0x89, 0x78, 0x05, 0x0A, 0x00, 0x00, 0x00, 0x0F, 0x00, 0x57, 0x00, 0x1F, 0x00, 0x47, 0x00, 0x3E,
/* 0000BCF0 */ 0x00, 0x5F, 0x01, 0x15, 0x00, 0x35, 0x00, 0x00, 0xFC, 0xBC, 0x00, 0x00, 0xBF, 0x4C, 0x83, 0x00,
/* 0000BD00 */ 0x00, 0xC4, 0x00, 0xFE, 0x95, 0x02, 0x68, 0xA2, 0x41, 0xD1, 0x00, 0x2B, 0xFE, 0x83, 0x79, 0xFF,
/* 0000BD10 */ 0x00, 0x10, 0x01, 0x00, 0x02, 0x02, 0xFE, 0x83, 0x79, 0xF1, 0xF1, 0x41, 0x04, 0x03, 0x06, 0x0D,
/* 0000BD20 */ 0x0D, 0x03, 0x01, 0x01, 0x02, 0x05, 0x06, 0xFE, 0xF6, 0x02, 0x2D, 0x4F, 0x04, 0x8F, 0x01, 0x02,
/* 0000BD30 */ 0x06, 0x00, 0x00, 0x4B, 0x06, 0x98, 0x06, 0x06, 0x03, 0x00, 0x00, 0x54, 0x04, 0x06, 0x15, 0x03,
/* 0000BD40 */ 0x00, 0x04, 0x02, 0x09, 0x0E, 0x00, 0x8F, 0x01, 0x03, 0x06, 0x01, 0x00, 0x4B, 0x06, 0x9D, 0x03,
/* 0000BD50 */ 0x06, 0x04, 0x00, 0x00, 0xA8, 0x00, 0x24, 0x00, 0xFE, 0xAB, 0x79, 0x04, 0x02, 0x00, 0x00, 0x00,
/* 0000BD60 */ 0x11, 0x00, 0x49, 0x00, 0x08, 0x00, 0x2E, 0x00, 0x10, 0x00, 0x51, 0x00, 0x00, 0xBF, 0x5C, 0x84,
/* 0000BD70 */ 0x00, 0x00, 0xC4, 0x00, 0xFE, 0x6A, 0x02, 0x08, 0xA2, 0x41, 0xC3, 0x00, 0xFE, 0x92, 0x03, 0x28,
/* 0000BD80 */ 0xFE, 0x6F, 0x6D, 0xFF, 0x00, 0x10, 0x01, 0x00, 0x02, 0x02, 0xFE, 0x6F, 0x6D, 0x98, 0x98, 0x01,
/* 0000BD90 */ 0x05, 0x03, 0x06, 0x05, 0x0F, 0x0F, 0x01, 0x01, 0x02, 0x05, 0x08, 0x2F, 0x5B, 0x04, 0xB4, 0x04,
/* 0000BDA0 */ 0x04, 0x8F, 0x01, 0x33, 0x06, 0x00, 0x00, 0x07, 0x04, 0x00, 0x5C, 0x00, 0x02, 0x5C, 0x01, 0x04,
/* 0000BDB0 */ 0x8F, 0x01, 0x4A, 0x07, 0x01, 0x00, 0x4B, 0x07, 0x5C, 0x02, 0x07, 0x5C, 0x03, 0x03, 0xEE, 0x04,
/* 0000BDC0 */ 0x00, 0x06, 0x00, 0x00, 0x09, 0x02, 0x00, 0xA8, 0x00, 0x24, 0x00, 0xFE, 0xAE, 0x6D, 0x02, 0x05,
/* 0000BDD0 */ 0x00, 0x00, 0x00, 0x28, 0x00, 0x58, 0x00, 0x00, 0xBF, 0x5C, 0x85, 0xE0, 0x01, 0xC4, 0x00, 0xFE,
/* 0000BDE0 */ 0x63, 0x02, 0x08, 0xA2, 0x41, 0xA3, 0x00, 0xFE, 0x91, 0x03, 0x27, 0xFE, 0x8A, 0x6B, 0xFF, 0x00,
/* 0000BDF0 */ 0x10, 0x01, 0x00, 0x02, 0x02, 0xFE, 0x8A, 0x6B, 0xFE, 0x07, 0x01, 0xFE, 0x07, 0x01, 0x03, 0x07,
/* 0000BE00 */ 0x06, 0x0B, 0x06, 0x1B, 0x19, 0x01, 0x01, 0x01, 0x02, 0x01, 0x01, 0x01, 0x01, 0x0A, 0x07, 0x01,
/* 0000BE10 */ 0x02, 0x01, 0x01, 0x08, 0x56, 0xAE, 0x07, 0x5B, 0x09, 0xB4, 0x09, 0x09, 0x4F, 0x08, 0x62, 0x0B,
/* 0000BE20 */ 0x07, 0x00, 0x12, 0x03, 0x00, 0x0B, 0x03, 0x09, 0x08, 0x00, 0xA8, 0x0C, 0x47, 0x0B, 0x0C, 0x09,
/* 0000BE30 */ 0x09, 0x00, 0x98, 0x0C, 0x07, 0x04, 0x00, 0x00, 0x47, 0x0B, 0x0C, 0x54, 0x08, 0x0B, 0x8F, 0x01,
/* 0000BE40 */ 0x32, 0x0B, 0x00, 0x00, 0x07, 0x05, 0x00, 0x5C, 0x00, 0x05, 0x5C, 0x01, 0x09, 0x8F, 0x01, 0x48,
/* 0000BE50 */ 0x0C, 0x01, 0x00, 0x4B, 0x0C, 0x5C, 0x02, 0x0C, 0x5C, 0x03, 0x06, 0x5C, 0x04, 0x08, 0xEE, 0x05,
/* 0000BE60 */ 0x00, 0x0B, 0x00, 0x00, 0x09, 0x02, 0x00, 0xA8, 0x00, 0x24, 0x00, 0xF1, 0xFE, 0xD7, 0x6B, 0x03,
/* 0000BE70 */ 0x09, 0x00, 0x00, 0x00, 0x20, 0x00, 0x4E, 0x00, 0x2B, 0x00, 0x6B, 0x00, 0x00, 0xBF, 0x5C, 0x85,
/* 0000BE80 */ 0xE0, 0x01, 0xC4, 0x00, 0xFE, 0x5C, 0x02, 0x08, 0xA2, 0x41, 0xA3, 0x00, 0xFE, 0x90, 0x03, 0x26,
/* 0000BE90 */ 0xFE, 0x71, 0x69, 0xFF, 0x00, 0x10, 0x01, 0x00, 0x02, 0x02, 0xFE, 0x71, 0x69, 0xFE, 0x03, 0x01,
/* 0000BEA0 */ 0xFE, 0x03, 0x01, 0x03, 0x07, 0x06, 0x0B, 0x06, 0x1B, 0x19, 0x01, 0x01, 0x01, 0x02, 0x01, 0x01,
/* 0000BEB0 */ 0x01, 0x01, 0x0A, 0x07, 0x01, 0x02, 0x01, 0x01, 0x08, 0x56, 0xAE, 0x07, 0x5B, 0x09, 0xB4, 0x09,
/* 0000BEC0 */ 0x09, 0x4F, 0x08, 0x62, 0x0B, 0x07, 0x00, 0x12, 0x03, 0x00, 0x0B, 0x03, 0x09, 0x08, 0x00, 0xA8,
/* 0000BED0 */ 0x0C, 0x47, 0x0B, 0x0C, 0x09, 0x09, 0x00, 0x98, 0x0C, 0x07, 0x04, 0x00, 0x00, 0x47, 0x0B, 0x0C,
/* 0000BEE0 */ 0x54, 0x08, 0x0B, 0x8F, 0x01, 0x32, 0x0B, 0x00, 0x00, 0x07, 0x05, 0x00, 0x5C, 0x00, 0x05, 0x5C,
/* 0000BEF0 */ 0x01, 0x09, 0x8F, 0x01, 0x46, 0x0C, 0x01, 0x00, 0x4B, 0x0C, 0x5C, 0x02, 0x0C, 0x5C, 0x03, 0x06,
/* 0000BF00 */ 0x5C, 0x04, 0x08, 0xEE, 0x05, 0x00, 0x0B, 0x00, 0x00, 0x09, 0x02, 0x00, 0xA8, 0x00, 0x24, 0x00,
/* 0000BF10 */ 0xF1, 0xFE, 0xBC, 0x69, 0x03, 0x09, 0x00, 0x00, 0x00, 0x20, 0x00, 0x4E, 0x00, 0x2B, 0x00, 0x69,
/* 0000BF20 */ 0x00, 0x00, 0xBF, 0x5C, 0x85, 0xE0, 0x01, 0xC4, 0x00, 0xFE, 0x55, 0x02, 0x08, 0xA2, 0x41, 0xA3,
/* 0000BF30 */ 0x00, 0xFE, 0x8F, 0x03, 0x25, 0xFE, 0x68, 0x67, 0xFF, 0x00, 0x10, 0x01, 0x00, 0x02, 0x02, 0xFE,
/* 0000BF40 */ 0x68, 0x67, 0xFB, 0xFB, 0x03, 0x07, 0x06, 0x0B, 0x06, 0x1B, 0x19, 0x01, 0x01, 0x01, 0x02, 0x01,
/* 0000BF50 */ 0x01, 0x01, 0x01, 0x0A, 0x07, 0x01, 0x02, 0x01, 0x01, 0x08, 0x56, 0xAE, 0x07, 0x5B, 0x09, 0xB4,
/* 0000BF60 */ 0x09, 0x09, 0x4F, 0x08, 0x62, 0x0B, 0x07, 0x00, 0x12, 0x03, 0x00, 0x0B, 0x03, 0x09, 0x08, 0x00,
/* 0000BF70 */ 0xA8, 0x0C, 0x47, 0x0B, 0x0C, 0x09, 0x09, 0x00, 0x98, 0x0C, 0x07, 0x04, 0x00, 0x00, 0x47, 0x0B,
/* 0000BF80 */ 0x0C, 0x54, 0x08, 0x0B, 0x8F, 0x01, 0x32, 0x0B, 0x00, 0x00, 0x07, 0x05, 0x00, 0x5C, 0x00, 0x05,
/* 0000BF90 */ 0x5C, 0x01, 0x09, 0x8F, 0x01, 0x44, 0x0C, 0x01, 0x00, 0x4B, 0x0C, 0x5C, 0x02, 0x0C, 0x5C, 0x03,
/* 0000BFA0 */ 0x06, 0x5C, 0x04, 0x08, 0xEE, 0x05, 0x00, 0x0B, 0x00, 0x00, 0x09, 0x02, 0x00, 0xA8, 0x00, 0x24,
/* 0000BFB0 */ 0x00, 0xF1, 0xFE, 0xAF, 0x67, 0x03, 0x09, 0x00, 0x00, 0x00, 0x20, 0x00, 0x4E, 0x00, 0x2B, 0x00,
/* 0000BFC0 */ 0x65, 0x00, 0x00, 0xBF, 0x5C, 0x84, 0xE0, 0x01, 0xC4, 0x00, 0xFE, 0x37, 0x02, 0x1D, 0xA2, 0x41,
/* 0000BFD0 */ 0xC1, 0x00, 0xFE, 0xE6, 0x02, 0x24, 0xFE, 0xAA, 0x61, 0xFF, 0x00, 0x10, 0x01, 0x00, 0x03, 0x03,
/* 0000BFE0 */ 0xFE, 0xAA, 0x61, 0xFE, 0x75, 0x03, 0xFE, 0x75, 0x03, 0x01, 0x08, 0x08, 0x0C, 0x0A, 0x50, 0x4D,
/* 0000BFF0 */ 0x01, 0x09, 0x08, 0x04, 0x04, 0x04, 0x04, 0x0B, 0x08, 0x06, 0xFE, 0x5D, 0x03, 0x05, 0xFE, 0x4F,
/* 0000C000 */ 0x03, 0x05, 0xFE, 0x8C, 0x03, 0x06, 0xFE, 0x8D, 0x03, 0x05, 0xFE, 0x8E, 0x03, 0xFE, 0x46, 0x01,
/* 0000C010 */ 0xA8, 0x0A, 0x8F, 0x01, 0x07, 0x0C, 0x00, 0x00, 0x07, 0x02, 0x00, 0x5C, 0x00, 0x02, 0x5C, 0x01,
/* 0000C020 */ 0x08, 0xEE, 0x02, 0x0C, 0x0C, 0x00, 0x00, 0x47, 0x08, 0x0C, 0x2C, 0x0C, 0x09, 0x15, 0x03, 0x00,
/* 0000C030 */ 0x0C, 0x03, 0x09, 0x7E, 0x00, 0x62, 0x0C, 0x09, 0x00, 0x47, 0x0A, 0x0C, 0x2C, 0x0C, 0x0A, 0x15,
/* 0000C040 */ 0x03, 0x00, 0x0C, 0x03, 0x09, 0x6C, 0x00, 0x8F, 0x01, 0x31, 0x0D, 0x01, 0x00, 0x6D, 0x0C, 0x0D,
/* 0000C050 */ 0x01, 0x07, 0x02, 0x00, 0x5C, 0x00, 0x0D, 0x5C, 0x01, 0x0A, 0xF2, 0x02, 0x0C, 0x0C, 0x01, 0x00,
/* 0000C060 */ 0x00, 0x00, 0x01, 0x00, 0x47, 0x0A, 0x0C, 0x15, 0x03, 0x00, 0x0A, 0x04, 0x09, 0x44, 0x00, 0x15,
/* 0000C070 */ 0x03, 0x00, 0x0A, 0x05, 0x09, 0x3C, 0x00, 0x8F, 0x01, 0x09, 0x0D, 0x02, 0x00, 0x6D, 0x0C, 0x0D,
/* 0000C080 */ 0x02, 0x07, 0x04, 0x00, 0x5C, 0x00, 0x0D, 0x8F, 0x01, 0x11, 0x0E, 0x03, 0x00, 0x07, 0x02, 0x00,
/* 0000C090 */ 0x5C, 0x00, 0x02, 0x5C, 0x01, 0x0A, 0xEE, 0x02, 0x0E, 0x0E, 0x03, 0x00, 0x5C, 0x01, 0x0E, 0x5D,
/* 0000C0A0 */ 0x02, 0x06, 0x02, 0x00, 0x5D, 0x03, 0x07, 0x02, 0x00, 0xF2, 0x04, 0xFF, 0x0C, 0x02, 0x00, 0x00,
/* 0000C0B0 */ 0x00, 0x02, 0x00, 0x2C, 0x0C, 0x0A, 0x14, 0x0B, 0x00, 0x0C, 0x03, 0x09, 0x00, 0x00, 0x14, 0x03,
/* 0000C0C0 */ 0x00, 0x0A, 0x05, 0x09, 0x56, 0x00, 0x8F, 0x01, 0x08, 0x0C, 0x04, 0x00, 0x07, 0x04, 0x00, 0x5C,
/* 0000C0D0 */ 0x00, 0x02, 0x5C, 0x01, 0x08, 0x8F, 0x01, 0x2B, 0x0D, 0x05, 0x00, 0x5C, 0x02, 0x0D, 0x8F, 0x01,
/* 0000C0E0 */ 0x09, 0x0E, 0x02, 0x00, 0x6D, 0x0D, 0x0E, 0x03, 0x07, 0x02, 0x00, 0x5C, 0x00, 0x0E, 0x8F, 0x01,
/* 0000C0F0 */ 0x30, 0x0F, 0x06, 0x00, 0x07, 0x01, 0x00, 0x5C, 0x00, 0x02, 0xEE, 0x01, 0x0F, 0x0F, 0x06, 0x00,
/* 0000C100 */ 0x5C, 0x01, 0x0F, 0xF2, 0x02, 0x0D, 0x0D, 0x03, 0x00, 0x00, 0x00, 0x05, 0x00, 0x5C, 0x03, 0x0D,
/* 0000C110 */ 0xEE, 0x04, 0x00, 0x0C, 0x04, 0x00, 0x09, 0x3B, 0x00, 0x09, 0x36, 0x00, 0x8F, 0x01, 0x08, 0x0C,
/* 0000C120 */ 0x04, 0x00, 0x07, 0x04, 0x00, 0x5C, 0x00, 0x02, 0x5C, 0x01, 0x08, 0x8F, 0x01, 0x2C, 0x0D, 0x07,
/* 0000C130 */ 0x00, 0x5C, 0x02, 0x0D, 0x8F, 0x01, 0x30, 0x0D, 0x06, 0x00, 0x07, 0x01, 0x00, 0x5C, 0x00, 0x02,
/* 0000C140 */ 0xEE, 0x01, 0x0D, 0x0D, 0x08, 0x00, 0x5C, 0x03, 0x0D, 0xEE, 0x04, 0x00, 0x0C, 0x07, 0x00, 0x09,
/* 0000C150 */ 0x02, 0x00, 0xA8, 0x00, 0x24, 0x00, 0xFE, 0x62, 0x02, 0xFE, 0x5B, 0x02, 0xFE, 0x5D, 0x02, 0xFE,
/* 0000C160 */ 0x27, 0x02, 0xFE, 0xE7, 0x61, 0x0B, 0x02, 0x00, 0x00, 0x00, 0x18, 0x00, 0x36, 0x00, 0x0B, 0x00,
/* 0000C170 */ 0x33, 0x00, 0x07, 0x00, 0x30, 0x00, 0x0B, 0x00, 0x37, 0x00, 0x20, 0x00, 0x39, 0x00, 0x10, 0x00,
/* 0000C180 */ 0x4B, 0x00, 0x3C, 0x00, 0x9B, 0x00, 0x13, 0x00, 0x4D, 0x00, 0x56, 0x00, 0x95, 0x00, 0x38, 0x00,
/* 0000C190 */ 0x66, 0x00, 0x00, 0xBF, 0x5C, 0x84, 0xE0, 0x01, 0xC4, 0x00, 0xFE, 0x29, 0x02, 0x28, 0xA2, 0x41,
/* 0000C1A0 */ 0xC1, 0x00, 0xFE, 0x2B, 0x03, 0x23, 0xFE, 0xC8, 0x5F, 0xFF, 0x00, 0x10, 0x01, 0x00, 0x04, 0x04,
/* 0000C1B0 */ 0xFE, 0xC8, 0x5F, 0xFE, 0x97, 0x01, 0xFE, 0x97, 0x01, 0x01, 0x07, 0x05, 0x0A, 0x03, 0x26, 0x25,
/* 0000C1C0 */ 0x01, 0x04, 0x02, 0x03, 0x03, 0x03, 0x03, 0x09, 0x07, 0x05, 0xFE, 0xDF, 0x02, 0x08, 0x9B, 0x14,
/* 0000C1D0 */ 0x0D, 0x00, 0x05, 0x02, 0x09, 0x00, 0x00, 0xA8, 0x0A, 0x14, 0x03, 0x00, 0x05, 0x0A, 0x09, 0x1D,
/* 0000C1E0 */ 0x00, 0x8F, 0x01, 0x09, 0x0B, 0x00, 0x00, 0x6D, 0x0A, 0x0B, 0x00, 0x07, 0x02, 0x00, 0x5C, 0x00,
/* 0000C1F0 */ 0x0B, 0x5C, 0x01, 0x06, 0xF2, 0x02, 0xFF, 0x0A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x8F, 0x01,
/* 0000C200 */ 0x09, 0x0B, 0x00, 0x00, 0x6D, 0x0A, 0x0B, 0x01, 0x07, 0x02, 0x00, 0x5C, 0x00, 0x0B, 0x5C, 0x01,
/* 0000C210 */ 0x05, 0xF2, 0x02, 0x0A, 0x0A, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x47, 0x08, 0x0A, 0x0F, 0x03,
/* 0000C220 */ 0x00, 0x08, 0x09, 0x0C, 0x00, 0x62, 0x0A, 0x08, 0x02, 0x15, 0x03, 0x00, 0x0A, 0x03, 0x09, 0x1D,
/* 0000C230 */ 0x00, 0x8F, 0x01, 0x09, 0x0B, 0x00, 0x00, 0x6D, 0x0A, 0x0B, 0x00, 0x07, 0x02, 0x00, 0x5C, 0x00,
/* 0000C240 */ 0x0B, 0x5C, 0x01, 0x06, 0xF2, 0x02, 0xFF, 0x0A, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x8F, 0x01,
/* 0000C250 */ 0x07, 0x0A, 0x01, 0x00, 0x07, 0x02, 0x00, 0x5C, 0x00, 0x04, 0x5C, 0x01, 0x07, 0xEE, 0x02, 0x00,
/* 0000C260 */ 0x0A, 0x03, 0x00, 0x09, 0x02, 0x00, 0xA8, 0x00, 0x24, 0x00, 0xFE, 0x58, 0x02, 0xFE, 0x33, 0x02,
/* 0000C270 */ 0xFE, 0x61, 0x02, 0xFE, 0xFA, 0x5F, 0x07, 0x00, 0x00, 0x00, 0x00, 0x12, 0x00, 0x38, 0x00, 0x1D,
/* 0000C280 */ 0x00, 0x43, 0x00, 0x20, 0x00, 0x39, 0x00, 0x13, 0x00, 0x40, 0x00, 0x1D, 0x00, 0x43, 0x00, 0x1A,
/* 0000C290 */ 0x00, 0x2D, 0x00, 0x00, 0xBF, 0x5C, 0x84, 0xE0, 0x01, 0xC4, 0x00, 0xFE, 0x1C, 0x02, 0x24, 0xA2,
/* 0000C2A0 */ 0x41, 0xC1, 0x00, 0xFE, 0x2A, 0x03, 0x22, 0xFE, 0xF7, 0x5D, 0xFF, 0x00, 0x10, 0x01, 0x00, 0x05,
/* 0000C2B0 */ 0x05, 0xFE, 0xF7, 0x5D, 0xFE, 0xA5, 0x01, 0xFE, 0xA5, 0x01, 0x01, 0x08, 0x05, 0x0B, 0x04, 0x27,
/* 0000C2C0 */ 0x26, 0x01, 0x04, 0x02, 0x03, 0x03, 0x03, 0x03, 0x0A, 0x07, 0x05, 0xFE, 0xDF, 0x02, 0x08, 0x9E,
/* 0000C2D0 */ 0x14, 0x0D, 0x00, 0x05, 0x02, 0x09, 0x00, 0x00, 0xA8, 0x0B, 0x14, 0x03, 0x00, 0x05, 0x0B, 0x09,
/* 0000C2E0 */ 0x1D, 0x00, 0x8F, 0x01, 0x09, 0x0C, 0x00, 0x00, 0x6D, 0x0B, 0x0C, 0x00, 0x07, 0x02, 0x00, 0x5C,
/* 0000C2F0 */ 0x00, 0x0C, 0x5C, 0x01, 0x06, 0xF2, 0x02, 0xFF, 0x0B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x8F,
/* 0000C300 */ 0x01, 0x09, 0x0C, 0x00, 0x00, 0x6D, 0x0B, 0x0C, 0x01, 0x07, 0x02, 0x00, 0x5C, 0x00, 0x0C, 0x5C,
/* 0000C310 */ 0x01, 0x05, 0xF2, 0x02, 0x0B, 0x0B, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x47, 0x09, 0x0B, 0x0F,
/* 0000C320 */ 0x03, 0x00, 0x09, 0x09, 0x0C, 0x00, 0x62, 0x0B, 0x09, 0x02, 0x15, 0x03, 0x00, 0x0B, 0x03, 0x09,
/* 0000C330 */ 0x1D, 0x00, 0x8F, 0x01, 0x09, 0x0C, 0x00, 0x00, 0x6D, 0x0B, 0x0C, 0x00, 0x07, 0x02, 0x00, 0x5C,
/* 0000C340 */ 0x00, 0x0C, 0x5C, 0x01, 0x06, 0xF2, 0x02, 0xFF, 0x0B, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x8F,
/* 0000C350 */ 0x01, 0x34, 0x0B, 0x01, 0x00, 0x07, 0x03, 0x00, 0x5C, 0x00, 0x04, 0x5C, 0x01, 0x07, 0x5C, 0x02,
/* 0000C360 */ 0x08, 0xEE, 0x03, 0x00, 0x0B, 0x03, 0x00, 0x09, 0x02, 0x00, 0xA8, 0x00, 0x24, 0x00, 0xFE, 0x58,
/* 0000C370 */ 0x02, 0xFE, 0x33, 0x02, 0xFE, 0x61, 0x02, 0xFE, 0x32, 0x5E, 0x07, 0x00, 0x00, 0x00, 0x00, 0x12,
/* 0000C380 */ 0x00, 0x38, 0x00, 0x1D, 0x00, 0x43, 0x00, 0x20, 0x00, 0x39, 0x00, 0x13, 0x00, 0x40, 0x00, 0x1D,
/* 0000C390 */ 0x00, 0x43, 0x00, 0x1D, 0x00, 0x32, 0x00, 0x00, 0x3F, 0x5D, 0x8C, 0xE0, 0x89, 0xC6, 0x12, 0xFE,
/* 0000C3A0 */ 0x09, 0x02, 0x04, 0xA3, 0x41, 0xC1, 0x00, 0xFE, 0x0C, 0x03, 0x20, 0xFE, 0x4F, 0x5A, 0x01, 0xFF,
/* 0000C3B0 */ 0x00, 0x10, 0x01, 0x00, 0x04, 0x04, 0xFE, 0x4F, 0x5A, 0xFE, 0x80, 0x03, 0xFE, 0x80, 0x03, 0x04,
/* 0000C3C0 */ 0x09, 0x0A, 0x10, 0x05, 0x20, 0x20, 0x01, 0x02, 0x01, 0x05, 0x03, 0x03, 0x03, 0x03, 0x01, 0x0D,
/* 0000C3D0 */ 0x0E, 0x0F, 0x01, 0x00, 0x08, 0x06, 0xFE, 0x87, 0x03, 0x06, 0xFE, 0xE5, 0x02, 0x06, 0xFE, 0xFE,
/* 0000C3E0 */ 0x02, 0x0C, 0x06, 0xFE, 0x00, 0x03, 0x07, 0x81, 0x96, 0x04, 0x0B, 0x96, 0x05, 0x0C, 0xCE, 0x10,
/* 0000C3F0 */ 0x00, 0x00, 0x00, 0x96, 0x02, 0x10, 0x96, 0x03, 0x02, 0x8F, 0x01, 0x0C, 0x10, 0x00, 0x00, 0x07,
/* 0000C400 */ 0x04, 0x00, 0x5C, 0x00, 0x03, 0x8F, 0x01, 0x1C, 0x11, 0x01, 0x00, 0x5C, 0x01, 0x11, 0x5C, 0x02,
/* 0000C410 */ 0x0A, 0xD4, 0x00, 0x11, 0x5C, 0x03, 0x11, 0xEE, 0x04, 0xFF, 0x10, 0x00, 0x00, 0x8F, 0x01, 0x1B,
/* 0000C420 */ 0x10, 0x02, 0x00, 0x07, 0x04, 0x00, 0x5C, 0x00, 0x03, 0x93, 0x02, 0x11, 0x03, 0x00, 0x5C, 0x01,
/* 0000C430 */ 0x11, 0x5D, 0x02, 0x04, 0x01, 0x00, 0xCC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x11,
/* 0000C440 */ 0x00, 0x00, 0x00, 0x93, 0x03, 0x12, 0x04, 0x00, 0x7B, 0x12, 0x11, 0x00, 0x7B, 0x07, 0x11, 0x01,
/* 0000C450 */ 0x7B, 0x07, 0x11, 0x02, 0x5C, 0x03, 0x11, 0xEE, 0x04, 0xFF, 0x10, 0x01, 0x00, 0x93, 0x02, 0x00,
/* 0000C460 */ 0x03, 0x00, 0x09, 0x02, 0x00, 0xA8, 0x00, 0x24, 0x00, 0x01, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00,
/* 0000C470 */ 0x03, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xB4, 0x01, 0x00, 0x00, 0xB3, 0x01, 0x00, 0x00,
/* 0000C480 */ 0xB2, 0x01, 0x00, 0x00, 0xFE, 0xB4, 0x01, 0xFE, 0xB3, 0x01, 0xFE, 0xB2, 0x01, 0xFE, 0x88, 0x03,
/* 0000C490 */ 0xFE, 0x89, 0x03, 0xFE, 0x8A, 0x03, 0xFE, 0x8B, 0x03, 0xFE, 0xA3, 0x5A, 0x06, 0x06, 0x00, 0x00,
/* 0000C4A0 */ 0x00, 0x08, 0x00, 0x1A, 0x00, 0x03, 0x00, 0x18, 0x00, 0x24, 0x00, 0x7C, 0x02, 0x40, 0x00, 0x69,
/* 0000C4B0 */ 0x00, 0x0A, 0x00, 0x14, 0x00, 0x00, 0xBA, 0xC4, 0x00, 0x00, 0xBF, 0x5C, 0xC0, 0xE0, 0x29, 0xD4,
/* 0000C4C0 */ 0x10, 0xFE, 0x0C, 0x02, 0x41, 0xB2, 0x41, 0xD1, 0x00, 0x21, 0xFE, 0x0E, 0x5B, 0xFF, 0x00, 0x10,
/* 0000C4D0 */ 0x01, 0x00, 0x02, 0x02, 0xFE, 0x0E, 0x5B, 0xFE, 0x37, 0x02, 0xFE, 0x37, 0x02, 0x45, 0x08, 0x0B,
/* 0000C4E0 */ 0x0F, 0x06, 0x30, 0x2F, 0x02, 0x03, 0x07, 0x05, 0x05, 0x05, 0x05, 0x01, 0x01, 0x0E, 0x0F, 0x08,
/* 0000C4F0 */ 0x06, 0xFE, 0xE5, 0x02, 0x06, 0xFE, 0xFE, 0x02, 0x0C, 0x06, 0xFE, 0x00, 0x03, 0x06, 0xFE, 0xFF,
/* 0000C500 */ 0x02, 0x0B, 0x07, 0x01, 0x01, 0xB6, 0xA8, 0x0D, 0xE5, 0x94, 0x00, 0x8F, 0x02, 0x2E, 0x10, 0x00,
/* 0000C510 */ 0x00, 0x07, 0x05, 0x00, 0x5C, 0x00, 0x02, 0x5C, 0x01, 0x0B, 0x8F, 0x01, 0x04, 0x11, 0x01, 0x00,
/* 0000C520 */ 0x5C, 0x02, 0x11, 0xA8, 0x11, 0x5C, 0x03, 0x11, 0x8F, 0x01, 0x05, 0x11, 0x02, 0x00, 0x5C, 0x04,
/* 0000C530 */ 0x11, 0xF6, 0x05, 0x10, 0x10, 0x00, 0x00, 0x47, 0x0D, 0x10, 0x62, 0x10, 0x0D, 0x00, 0x0F, 0x03,
/* 0000C540 */ 0x00, 0x10, 0x09, 0x56, 0x00, 0x8F, 0x02, 0x1B, 0x10, 0x03, 0x00, 0x07, 0x04, 0x00, 0x5C, 0x00,
/* 0000C550 */ 0x02, 0x8F, 0x01, 0x02, 0x11, 0x04, 0x00, 0x5C, 0x01, 0x11, 0x8F, 0x01, 0x03, 0x11, 0x05, 0x00,
/* 0000C560 */ 0x5C, 0x02, 0x11, 0xCC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00,
/* 0000C570 */ 0x62, 0x12, 0x0D, 0x00, 0x7B, 0x12, 0x11, 0x01, 0x7B, 0x05, 0x11, 0x02, 0x7B, 0x05, 0x11, 0x03,
/* 0000C580 */ 0x7B, 0x08, 0x11, 0x04, 0x5C, 0x03, 0x11, 0xF6, 0x04, 0xFF, 0x10, 0x01, 0x00, 0x8F, 0x01, 0x03,
/* 0000C590 */ 0x10, 0x05, 0x00, 0x2F, 0x10, 0x10, 0x0A, 0x94, 0x01, 0x03, 0x10, 0xE9, 0x09, 0x19, 0x00, 0xE7,
/* 0000C5A0 */ 0x0C, 0x06, 0x8F, 0x02, 0x29, 0x10, 0x06, 0x00, 0x07, 0x02, 0x00, 0x5C, 0x00, 0x02, 0x5C, 0x01,
/* 0000C5B0 */ 0x0C, 0xF6, 0x02, 0xFF, 0x10, 0x02, 0x00, 0xE9, 0xA8, 0x00, 0x24, 0x00, 0x01, 0x18, 0x00, 0x00,
/* 0000C5C0 */ 0x00, 0x00, 0x00, 0x03, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xB4, 0x01, 0x00, 0x00, 0xB3,
/* 0000C5D0 */ 0x01, 0x00, 0x00, 0xB2, 0x01, 0x00, 0x00, 0xB1, 0x01, 0x00, 0x00, 0xFE, 0x1F, 0x02, 0xFE, 0xB4,
/* 0000C5E0 */ 0x01, 0xFE, 0xB3, 0x01, 0xFE, 0xB2, 0x01, 0xFE, 0xB1, 0x01, 0xFE, 0x46, 0x5B, 0x07, 0x05, 0x00,
/* 0000C5F0 */ 0x00, 0x00, 0x2F, 0x00, 0x5F, 0x00, 0x0B, 0x00, 0x2C, 0x00, 0x48, 0x00, 0x8E, 0x00, 0x14, 0x00,
/* 0000C600 */ 0x35, 0x00, 0x01, 0x00, 0x1E, 0x00, 0x18, 0x00, 0x92, 0x00, 0x00, 0x3F, 0x5D, 0x8C, 0xE0, 0x81,
/* 0000C610 */ 0xC6, 0x02, 0xFE, 0xE5, 0x01, 0x04, 0xA3, 0x41, 0xC1, 0x00, 0xFE, 0x0B, 0x03, 0x1E, 0xFE, 0xF4,
/* 0000C620 */ 0x55, 0x01, 0xFF, 0x00, 0x10, 0x01, 0x00, 0x02, 0x02, 0xFE, 0xF4, 0x55, 0xFE, 0x53, 0x04, 0xFE,
/* 0000C630 */ 0x53, 0x04, 0x01, 0x08, 0x05, 0x0A, 0x05, 0x2C, 0x2A, 0x01, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03,
/* 0000C640 */ 0x03, 0x07, 0x08, 0x09, 0x06, 0xFE, 0x5D, 0x03, 0x06, 0xFE, 0x58, 0x03, 0x08, 0xA7, 0x4F, 0x06,
/* 0000C650 */ 0x4F, 0x0A, 0x96, 0x02, 0x0A, 0x2C, 0x0A, 0x05, 0x14, 0x03, 0x00, 0x0A, 0x02, 0x09, 0x08, 0x00,
/* 0000C660 */ 0xCE, 0x00, 0x00, 0x00, 0x00, 0x09, 0x8B, 0x00, 0x2C, 0x0A, 0x05, 0x14, 0x03, 0x00, 0x0A, 0x03,
/* 0000C670 */ 0x09, 0x0C, 0x00, 0xCE, 0x0A, 0x01, 0x01, 0x00, 0xA1, 0x00, 0x05, 0x0A, 0x47, 0x05, 0x0A, 0x8F,
/* 0000C680 */ 0x01, 0x31, 0x0B, 0x00, 0x00, 0x6D, 0x0A, 0x0B, 0x00, 0x07, 0x02, 0x00, 0x5C, 0x00, 0x0B, 0x5C,
/* 0000C690 */ 0x01, 0x05, 0xF2, 0x02, 0x0A, 0x0A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x47, 0x05, 0x0A, 0x8F,
/* 0000C6A0 */ 0x01, 0x31, 0x0B, 0x00, 0x00, 0x6D, 0x0A, 0x0B, 0x01, 0x07, 0x02, 0x00, 0x5C, 0x00, 0x0B, 0x62,
/* 0000C6B0 */ 0x0C, 0x05, 0x02, 0x5C, 0x01, 0x0C, 0xF2, 0x02, 0x0A, 0x0A, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
/* 0000C6C0 */ 0x54, 0x06, 0x0A, 0xCE, 0x0A, 0x00, 0x02, 0x00, 0x96, 0x02, 0x0A, 0x8F, 0x01, 0x28, 0x0A, 0x01,
/* 0000C6D0 */ 0x00, 0x07, 0x04, 0x00, 0x5C, 0x00, 0x04, 0x5C, 0x01, 0x05, 0x5C, 0x02, 0x06, 0xD4, 0x00, 0x0B,
/* 0000C6E0 */ 0x5C, 0x03, 0x0B, 0xEE, 0x04, 0xFF, 0x0A, 0x02, 0x00, 0x93, 0x02, 0x00, 0x02, 0x00, 0x09, 0x02,
/* 0000C6F0 */ 0x00, 0xA8, 0x00, 0x24, 0x00, 0xFE, 0x51, 0x03, 0xFE, 0x5F, 0x02, 0xF1, 0xFE, 0x84, 0x03, 0xFE,
/* 0000C700 */ 0x28, 0x56, 0x0A, 0x07, 0x00, 0x00, 0x00, 0x0B, 0x00, 0x33, 0x00, 0x08, 0x00, 0x21, 0x00, 0x0B,
/* 0000C710 */ 0x00, 0x30, 0x00, 0x0C, 0x00, 0x2B, 0x00, 0x20, 0x00, 0x2F, 0x00, 0x24, 0x00, 0x73, 0x00, 0x08,
/* 0000C720 */ 0x00, 0x1A, 0x00, 0x1E, 0x00, 0xA1, 0x02, 0x0A, 0x00, 0x12, 0x00, 0x00, 0x30, 0xC7, 0x00, 0x00,
/* 0000C730 */ 0xBF, 0x5C, 0x84, 0xE0, 0x01, 0xC4, 0x00, 0xFE, 0xF4, 0x01, 0x2A, 0xA2, 0x41, 0xD1, 0x00, 0x1F,
/* 0000C740 */ 0xFE, 0xB5, 0x57, 0xFF, 0x00, 0x10, 0x01, 0x00, 0x02, 0x02, 0xFE, 0xB5, 0x57, 0xFE, 0x71, 0x02,
/* 0000C750 */ 0xFE, 0x71, 0x02, 0x41, 0x06, 0x08, 0x0B, 0x06, 0x4C, 0x4A, 0x02, 0x08, 0x08, 0x04, 0x04, 0x04,
/* 0000C760 */ 0x04, 0x0A, 0x06, 0xFE, 0x58, 0x03, 0x06, 0xFE, 0x85, 0x03, 0x07, 0x05, 0xFE, 0x86, 0x03, 0x08,
/* 0000C770 */ 0x01, 0xFF, 0xFE, 0x37, 0x01, 0x4F, 0x09, 0x2C, 0x0B, 0x08, 0x15, 0x03, 0x00, 0x0B, 0x02, 0x09,
/* 0000C780 */ 0x0B, 0x00, 0x2C, 0x0B, 0x08, 0x15, 0x0B, 0x00, 0x0B, 0x03, 0x09, 0x00, 0x00, 0x14, 0x03, 0x00,
/* 0000C790 */ 0x08, 0x04, 0x09, 0x1F, 0x00, 0x8F, 0x02, 0x09, 0x0C, 0x00, 0x00, 0x6D, 0x0B, 0x0C, 0x00, 0x07,
/* 0000C7A0 */ 0x02, 0x00, 0x5C, 0x00, 0x0C, 0x5D, 0x01, 0x05, 0x00, 0x00, 0xF2, 0x02, 0xFF, 0x0B, 0x00, 0x00,
/* 0000C7B0 */ 0x00, 0x00, 0x00, 0x00, 0x8F, 0x02, 0x31, 0x0C, 0x01, 0x00, 0x6D, 0x0B, 0x0C, 0x01, 0x07, 0x02,
/* 0000C7C0 */ 0x00, 0x5C, 0x00, 0x0C, 0x5C, 0x01, 0x08, 0xF2, 0x02, 0x0B, 0x0B, 0x01, 0x00, 0x00, 0x00, 0x01,
/* 0000C7D0 */ 0x00, 0x47, 0x09, 0x0B, 0x8F, 0x02, 0x3E, 0x0B, 0x02, 0x00, 0x4B, 0x0B, 0x07, 0x02, 0x00, 0x5C,
/* 0000C7E0 */ 0x00, 0x06, 0x5C, 0x01, 0x09, 0xEE, 0x02, 0x0B, 0x0B, 0x02, 0x00, 0x0F, 0x35, 0x00, 0x0B, 0x09,
/* 0000C7F0 */ 0x00, 0x00, 0x8F, 0x02, 0x09, 0x0C, 0x00, 0x00, 0x6D, 0x0B, 0x0C, 0x02, 0x07, 0x02, 0x00, 0x5C,
/* 0000C800 */ 0x00, 0x0C, 0x8F, 0x02, 0x11, 0x0D, 0x03, 0x00, 0x07, 0x02, 0x00, 0x5C, 0x00, 0x06, 0x5C, 0x01,
/* 0000C810 */ 0x09, 0xEE, 0x02, 0x0D, 0x0D, 0x04, 0x00, 0x5C, 0x01, 0x0D, 0xF2, 0x02, 0xFF, 0x0B, 0x02, 0x00,
/* 0000C820 */ 0x00, 0x00, 0x03, 0x00, 0x8F, 0x02, 0x09, 0x0C, 0x00, 0x00, 0x6D, 0x0B, 0x0C, 0x03, 0x07, 0x02,
/* 0000C830 */ 0x00, 0x5C, 0x00, 0x0C, 0x5C, 0x01, 0x09, 0xF2, 0x02, 0x0B, 0x0B, 0x03, 0x00, 0x00, 0x00, 0x05,
/* 0000C840 */ 0x00, 0x47, 0x09, 0x0B, 0xA8, 0x0B, 0x15, 0x03, 0x00, 0x09, 0x0B, 0x09, 0x5A, 0x00, 0x8F, 0x02,
/* 0000C850 */ 0x0C, 0x0B, 0x04, 0x00, 0x07, 0x04, 0x00, 0x5C, 0x00, 0x06, 0x8F, 0x02, 0x1D, 0x0C, 0x05, 0x00,
/* 0000C860 */ 0x5C, 0x01, 0x0C, 0x8F, 0x01, 0x02, 0x0C, 0x06, 0x00, 0x4B, 0x0C, 0x5C, 0x02, 0x0C, 0x5C, 0x03,
/* 0000C870 */ 0x09, 0xEE, 0x04, 0x0B, 0x0B, 0x06, 0x00, 0x14, 0x03, 0x00, 0x0B, 0x07, 0x09, 0x29, 0x00, 0x8F,
/* 0000C880 */ 0x02, 0x0C, 0x0B, 0x04, 0x00, 0x07, 0x04, 0x00, 0x5C, 0x00, 0x06, 0x8F, 0x02, 0x1E, 0x0C, 0x07,
/* 0000C890 */ 0x00, 0x5C, 0x01, 0x0C, 0x8F, 0x01, 0x02, 0x0C, 0x06, 0x00, 0x4B, 0x0C, 0x5C, 0x02, 0x0C, 0x5C,
/* 0000C8A0 */ 0x03, 0x09, 0xEE, 0x04, 0xFF, 0x0B, 0x07, 0x00, 0xA8, 0x00, 0x24, 0x00, 0xFE, 0x56, 0x02, 0xFE,
/* 0000C8B0 */ 0x5B, 0x02, 0xFE, 0x60, 0x02, 0xFE, 0x27, 0x02, 0xFE, 0xD6, 0x57, 0x09, 0x02, 0x00, 0x00, 0x00,
/* 0000C8C0 */ 0x1E, 0x00, 0x66, 0x00, 0x1F, 0x00, 0x4A, 0x00, 0x20, 0x00, 0x34, 0x00, 0x1E, 0x00, 0x36, 0x00,
/* 0000C8D0 */ 0x32, 0x00, 0x4E, 0x00, 0x20, 0x00, 0x39, 0x00, 0x3B, 0x00, 0x66, 0x00, 0x2B, 0x00, 0x48, 0x00,
/* 0000C8E0 */ 0x00, 0xBF, 0x5C, 0x84, 0xE0, 0x01, 0xC4, 0x00, 0xFE, 0xDA, 0x01, 0x04, 0xA3, 0x41, 0xC1, 0x00,
/* 0000C8F0 */ 0xFE, 0x0A, 0x03, 0x1D, 0xFE, 0x74, 0x54, 0xFF, 0x00, 0x10, 0x01, 0x00, 0x02, 0x02, 0xFE, 0x74,
/* 0000C900 */ 0x54, 0xFE, 0x00, 0x01, 0xFE, 0x00, 0x01, 0x01, 0x05, 0x04, 0x06, 0x04, 0x1D, 0x1C, 0x01, 0x03,
/* 0000C910 */ 0x04, 0x02, 0x02, 0x02, 0x02, 0x05, 0x08, 0x07, 0x74, 0x8F, 0x01, 0x31, 0x07, 0x00, 0x00, 0x6D,
/* 0000C920 */ 0x06, 0x07, 0x00, 0x07, 0x02, 0x00, 0x5C, 0x00, 0x07, 0x5C, 0x01, 0x04, 0xF2, 0x02, 0x06, 0x06,
/* 0000C930 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x47, 0x04, 0x06, 0x8F, 0x01, 0x40, 0x06, 0x01, 0x00, 0x4B,
/* 0000C940 */ 0x06, 0x0F, 0x15, 0x00, 0x06, 0x09, 0x00, 0x00, 0x8F, 0x01, 0x04, 0x06, 0x02, 0x00, 0x07, 0x01,
/* 0000C950 */ 0x00, 0x5C, 0x00, 0x02, 0xEE, 0x01, 0xFF, 0x06, 0x01, 0x00, 0x8F, 0x01, 0x09, 0x07, 0x03, 0x00,
/* 0000C960 */ 0x6D, 0x06, 0x07, 0x01, 0x07, 0x03, 0x00, 0x5C, 0x00, 0x07, 0x5C, 0x01, 0x04, 0x8F, 0x01, 0x40,
/* 0000C970 */ 0x08, 0x01, 0x00, 0x4B, 0x08, 0x5C, 0x02, 0x08, 0xF2, 0x03, 0x06, 0x06, 0x01, 0x00, 0x00, 0x00,
/* 0000C980 */ 0x02, 0x00, 0x44, 0x00, 0x06, 0x03, 0x09, 0x02, 0x00, 0xA8, 0x00, 0x24, 0x00, 0xFE, 0x5B, 0x02,
/* 0000C990 */ 0xFE, 0x37, 0x02, 0xFE, 0xA7, 0x54, 0x05, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x2B, 0x00, 0x0F,
/* 0000C9A0 */ 0x00, 0x26, 0x00, 0x12, 0x00, 0x32, 0x00, 0x31, 0x00, 0x49, 0x00, 0x00, 0xBF, 0x5C, 0x84, 0x00,
/* 0000C9B0 */ 0x00, 0xC4, 0x00, 0xFE, 0x9F, 0x01, 0x04, 0xA1, 0x41, 0xC1, 0x00, 0xFE, 0x09, 0x03, 0x1C, 0xFE,
/* 0000C9C0 */ 0x35, 0x41, 0xFF, 0x00, 0x10, 0x01, 0x00, 0x01, 0x01, 0xFE, 0x35, 0x41, 0xFE, 0x37, 0x13, 0xFE,
/* 0000C9D0 */ 0x37, 0x13, 0x41, 0x16, 0x25, 0x38, 0x04, 0xB0, 0x9C, 0x01, 0x03, 0x01, 0x37, 0x05, 0xFE, 0x62,
/* 0000C9E0 */ 0x03, 0x05, 0xFE, 0x63, 0x03, 0x05, 0xFE, 0x64, 0x03, 0x06, 0xFE, 0x65, 0x03, 0x06, 0xFE, 0x66,
/* 0000C9F0 */ 0x03, 0x05, 0xFE, 0x67, 0x03, 0x05, 0xFE, 0x68, 0x03, 0x05, 0xFE, 0x69, 0x03, 0x05, 0xFE, 0x6A,
/* 0000CA00 */ 0x03, 0x05, 0xFE, 0x6B, 0x03, 0x05, 0xFE, 0x6C, 0x03, 0x05, 0xFE, 0x6D, 0x03, 0x05, 0xFE, 0x6E,
/* 0000CA10 */ 0x03, 0x05, 0xFE, 0x6F, 0x03, 0x05, 0xFE, 0x70, 0x03, 0x05, 0xFE, 0x71, 0x03, 0x06, 0xFE, 0xF6,
/* 0000CA20 */ 0x02, 0x05, 0xFE, 0x72, 0x03, 0x05, 0xFE, 0x73, 0x03, 0x05, 0xFE, 0x74, 0x03, 0x05, 0xFE, 0x75,
/* 0000CA30 */ 0x03, 0x05, 0xFE, 0x76, 0x03, 0x05, 0xFE, 0x77, 0x03, 0x05, 0xFE, 0x78, 0x03, 0x05, 0xFE, 0x79,
/* 0000CA40 */ 0x03, 0x05, 0xFE, 0x7A, 0x03, 0x05, 0xFE, 0x7B, 0x03, 0x05, 0xFE, 0x7C, 0x03, 0x05, 0xFE, 0x7D,
/* 0000CA50 */ 0x03, 0x05, 0xFE, 0x7E, 0x03, 0x05, 0xFE, 0x7F, 0x03, 0x05, 0xFE, 0x80, 0x03, 0x05, 0xFE, 0x81,
/* 0000CA60 */ 0x03, 0x05, 0xFE, 0x82, 0x03, 0x06, 0xFE, 0x83, 0x03, 0xFE, 0x9B, 0x02, 0x4F, 0x25, 0x4F, 0x26,
/* 0000CA70 */ 0x4F, 0x27, 0x4F, 0x28, 0x4F, 0x29, 0x4F, 0x2A, 0x4F, 0x2B, 0x4F, 0x2C, 0x4F, 0x2D, 0x4F, 0x2E,
/* 0000CA80 */ 0x4F, 0x2F, 0x4F, 0x30, 0x4F, 0x31, 0x4F, 0x32, 0x4F, 0x33, 0x4F, 0x34, 0x4F, 0x35, 0x4F, 0x36,
/* 0000CA90 */ 0x54, 0x25, 0x02, 0x54, 0x26, 0x03, 0x47, 0x38, 0x04, 0x01, 0x04, 0x01, 0x39, 0x25, 0x2F, 0x38,
/* 0000CAA0 */ 0x38, 0x39, 0x2F, 0x38, 0x38, 0x05, 0x01, 0x04, 0x01, 0x39, 0x26, 0x2F, 0x38, 0x38, 0x39, 0x2F,
/* 0000CAB0 */ 0x38, 0x38, 0x06, 0x54, 0x27, 0x38, 0x54, 0x28, 0x07, 0x2F, 0x38, 0x08, 0x09, 0x54, 0x29, 0x38,
/* 0000CAC0 */ 0x47, 0x38, 0x0A, 0x01, 0x04, 0x01, 0x39, 0x28, 0x2F, 0x38, 0x38, 0x39, 0x2F, 0x38, 0x38, 0x05,
/* 0000CAD0 */ 0x01, 0x04, 0x01, 0x39, 0x29, 0x2F, 0x38, 0x38, 0x39, 0x2F, 0x38, 0x38, 0x0B, 0x54, 0x2A, 0x38,
/* 0000CAE0 */ 0x47, 0x38, 0x0C, 0x01, 0x04, 0x01, 0x39, 0x27, 0x2F, 0x38, 0x38, 0x39, 0x2F, 0x38, 0x38, 0x0D,
/* 0000CAF0 */ 0x54, 0x2B, 0x38, 0x47, 0x38, 0x0A, 0x01, 0x04, 0x01, 0x39, 0x26, 0x2F, 0x38, 0x38, 0x39, 0x2F,
/* 0000CB00 */ 0x38, 0x38, 0x0E, 0x54, 0x2C, 0x38, 0x47, 0x38, 0x0A, 0x01, 0x04, 0x01, 0x39, 0x2C, 0x2F, 0x38,
/* 0000CB10 */ 0x38, 0x39, 0x2F, 0x38, 0x38, 0x0F, 0x01, 0x04, 0x01, 0x39, 0x27, 0x2F, 0x38, 0x38, 0x39, 0x2F,
/* 0000CB20 */ 0x38, 0x38, 0x10, 0x54, 0x2D, 0x38, 0x47, 0x38, 0x0A, 0x01, 0x04, 0x01, 0x39, 0x27, 0x2F, 0x38,
/* 0000CB30 */ 0x38, 0x39, 0x2F, 0x38, 0x38, 0x11, 0x01, 0x04, 0x01, 0x39, 0x26, 0x2F, 0x38, 0x38, 0x39, 0x2F,
/* 0000CB40 */ 0x38, 0x38, 0x12, 0x01, 0x04, 0x01, 0x39, 0x27, 0x2F, 0x38, 0x38, 0x39, 0x2F, 0x38, 0x38, 0x13,
/* 0000CB50 */ 0x54, 0x2E, 0x38, 0x47, 0x38, 0x0A, 0x01, 0x04, 0x01, 0x39, 0x25, 0x2F, 0x38, 0x38, 0x39, 0x2F,
/* 0000CB60 */ 0x38, 0x38, 0x14, 0x01, 0x04, 0x01, 0x39, 0x26, 0x2F, 0x38, 0x38, 0x39, 0x2F, 0x38, 0x38, 0x13,
/* 0000CB70 */ 0x54, 0x2F, 0x38, 0x47, 0x38, 0x0A, 0x01, 0x04, 0x01, 0x39, 0x25, 0x2F, 0x38, 0x38, 0x39, 0x2F,
/* 0000CB80 */ 0x38, 0x38, 0x15, 0x54, 0x30, 0x38, 0x47, 0x38, 0x0A, 0x01, 0x04, 0x01, 0x39, 0x25, 0x2F, 0x38,
/* 0000CB90 */ 0x38, 0x39, 0x2F, 0x38, 0x38, 0x16, 0x01, 0x04, 0x01, 0x39, 0x25, 0x2F, 0x38, 0x38, 0x39, 0x2F,
/* 0000CBA0 */ 0x38, 0x38, 0x17, 0x54, 0x31, 0x38, 0x47, 0x38, 0x12, 0x01, 0x04, 0x01, 0x39, 0x25, 0x2F, 0x38,
/* 0000CBB0 */ 0x38, 0x39, 0x2F, 0x38, 0x38, 0x18, 0x2F, 0x38, 0x0A, 0x38, 0x47, 0x39, 0x19, 0x01, 0x04, 0x01,
/* 0000CBC0 */ 0x3A, 0x31, 0x2F, 0x39, 0x39, 0x3A, 0x2F, 0x39, 0x39, 0x1A, 0x2F, 0x38, 0x38, 0x39, 0x47, 0x39,
/* 0000CBD0 */ 0x05, 0x01, 0x04, 0x01, 0x3A, 0x25, 0x2F, 0x39, 0x39, 0x3A, 0x2F, 0x39, 0x39, 0x1B, 0x2F, 0x38,
/* 0000CBE0 */ 0x38, 0x39, 0x2F, 0x38, 0x38, 0x0B, 0x54, 0x32, 0x38, 0x47, 0x38, 0x1C, 0x01, 0x04, 0x01, 0x39,
/* 0000CBF0 */ 0x32, 0x2F, 0x38, 0x38, 0x39, 0x2F, 0x38, 0x38, 0x0B, 0x47, 0x39, 0x1D, 0x01, 0x04, 0x01, 0x3A,
/* 0000CC00 */ 0x30, 0x2F, 0x39, 0x39, 0x3A, 0x2F, 0x39, 0x39, 0x1E, 0x2F, 0x38, 0x38, 0x39, 0x47, 0x39, 0x1D,
/* 0000CC10 */ 0x01, 0x04, 0x01, 0x3A, 0x2F, 0x2F, 0x39, 0x39, 0x3A, 0x2F, 0x39, 0x39, 0x1E, 0x2F, 0x38, 0x38,
/* 0000CC20 */ 0x39, 0x54, 0x33, 0x38, 0x47, 0x38, 0x19, 0x01, 0x04, 0x01, 0x39, 0x2E, 0x2F, 0x38, 0x38, 0x39,
/* 0000CC30 */ 0x2F, 0x38, 0x38, 0x1F, 0x47, 0x39, 0x20, 0x01, 0x04, 0x01, 0x3A, 0x2D, 0x2F, 0x39, 0x39, 0x3A,
/* 0000CC40 */ 0x2F, 0x39, 0x39, 0x21, 0x2F, 0x38, 0x38, 0x39, 0x47, 0x39, 0x19, 0x01, 0x04, 0x01, 0x3A, 0x2B,
/* 0000CC50 */ 0x2F, 0x39, 0x39, 0x3A, 0x2F, 0x39, 0x39, 0x22, 0x2F, 0x38, 0x38, 0x39, 0x54, 0x34, 0x38, 0x47,
/* 0000CC60 */ 0x38, 0x23, 0x01, 0x04, 0x01, 0x39, 0x33, 0x2F, 0x38, 0x38, 0x39, 0x2F, 0x38, 0x38, 0x23, 0x01,
/* 0000CC70 */ 0x04, 0x01, 0x39, 0x34, 0x2F, 0x38, 0x38, 0x39, 0x2F, 0x38, 0x38, 0x23, 0x54, 0x35, 0x38, 0x47,
/* 0000CC80 */ 0x38, 0x0A, 0x01, 0x04, 0x01, 0x39, 0x35, 0x2F, 0x38, 0x38, 0x39, 0x2F, 0x38, 0x38, 0x05, 0x01,
/* 0000CC90 */ 0x04, 0x01, 0x39, 0x2B, 0x2F, 0x38, 0x38, 0x39, 0x2F, 0x38, 0x38, 0x05, 0x01, 0x04, 0x01, 0x39,
/* 0000CCA0 */ 0x2A, 0x2F, 0x38, 0x38, 0x39, 0x2F, 0x38, 0x38, 0x0B, 0x54, 0x36, 0x38, 0x8F, 0x01, 0x0F, 0x38,
/* 0000CCB0 */ 0x00, 0x00, 0x07, 0x03, 0x00, 0x5C, 0x01, 0x33, 0x5D, 0x02, 0x24, 0x00, 0x00, 0xC3, 0x03, 0x38,
/* 0000CCC0 */ 0x38, 0x00, 0x00, 0x01, 0x32, 0x01, 0x01, 0x41, 0x38, 0x8F, 0x01, 0x0F, 0x38, 0x00, 0x00, 0x07,
/* 0000CCD0 */ 0x03, 0x00, 0x5C, 0x01, 0x34, 0x5D, 0x02, 0x24, 0x01, 0x00, 0xC3, 0x03, 0x38, 0x38, 0x01, 0x00,
/* 0000CCE0 */ 0x01, 0x32, 0x01, 0x01, 0x42, 0x38, 0x8F, 0x01, 0x0F, 0x38, 0x00, 0x00, 0x07, 0x03, 0x00, 0x5C,
/* 0000CCF0 */ 0x01, 0x36, 0x5D, 0x02, 0x24, 0x02, 0x00, 0xC3, 0x03, 0x38, 0x38, 0x02, 0x00, 0x01, 0x32, 0x01,
/* 0000CD00 */ 0x01, 0x43, 0x38, 0xA8, 0x00, 0x24, 0x00, 0xFE, 0x26, 0x46, 0x16, 0x24, 0x00, 0x00, 0x00, 0x03,
/* 0000CD10 */ 0x00, 0x20, 0x00, 0x03, 0x00, 0x20, 0x00, 0x20, 0x00, 0x35, 0x00, 0x03, 0x00, 0x78, 0x00, 0x07,
/* 0000CD20 */ 0x00, 0xC2, 0x00, 0x20, 0x00, 0x46, 0x00, 0x13, 0x00, 0x7E, 0x00, 0x13, 0x00, 0x95, 0x00, 0x20,
/* 0000CD30 */ 0x00, 0x84, 0x00, 0x2D, 0x00, 0x84, 0x00, 0x20, 0x00, 0x76, 0x00, 0x13, 0x00, 0x6B, 0x00, 0x20,
/* 0000CD40 */ 0x00, 0x7C, 0x00, 0x43, 0x00, 0x09, 0x04, 0x3B, 0x00, 0x4F, 0x01, 0x3B, 0x00, 0x5D, 0x01, 0x20,
/* 0000CD50 */ 0x00, 0x4D, 0x00, 0x2D, 0x00, 0x70, 0x00, 0x1D, 0x00, 0x67, 0x00, 0x1D, 0x00, 0x8C, 0x00, 0x1F,
/* 0000CD60 */ 0x00, 0x73, 0x00, 0x00, 0xBF, 0x4C, 0x00, 0x00, 0x10, 0xC4, 0x00, 0xFE, 0x98, 0x01, 0x04, 0xA1,
/* 0000CD70 */ 0x41, 0xC1, 0x00, 0xFE, 0x08, 0x03, 0x1B, 0xFE, 0xF1, 0x3F, 0xFF, 0x00, 0x10, 0x01, 0x00, 0x01,
/* 0000CD80 */ 0x01, 0xFE, 0xF1, 0x3F, 0x57, 0x57, 0x41, 0x02, 0x02, 0x03, 0x05, 0x05, 0x01, 0x01, 0x02, 0x0D,
/* 0000CD90 */ 0xE0, 0x03, 0x00, 0x01, 0x32, 0x01, 0x01, 0x40, 0x03, 0xA8, 0x00, 0x24, 0x00, 0x0A, 0xFE, 0x61,
/* 0000CDA0 */ 0x03, 0x01, 0xFE, 0x20, 0x40, 0x02, 0x00, 0x00, 0x00, 0x00, 0x0B, 0x00, 0x27, 0x00, 0x00, 0xBF,
/* 0000CDB0 */ 0x5C, 0x85, 0xE0, 0x21, 0xD4, 0x00, 0xFE, 0x87, 0x01, 0x04, 0xA3, 0x41, 0xC1, 0x00, 0xFE, 0x07,
/* 0000CDC0 */ 0x03, 0x1A, 0xFE, 0x7B, 0x3D, 0xFF, 0x00, 0x10, 0x01, 0x00, 0x06, 0x06, 0xFE, 0x7B, 0x3D, 0xFE,
/* 0000CDD0 */ 0x53, 0x02, 0xFE, 0x53, 0x02, 0x01, 0x0C, 0x07, 0x0F, 0x08, 0x3C, 0x3B, 0x01, 0x01, 0x06, 0x05,
/* 0000CDE0 */ 0x03, 0x03, 0x03, 0x03, 0x01, 0x0E, 0x0F, 0x06, 0xFE, 0x5D, 0x03, 0x08, 0x06, 0xFE, 0x5E, 0x03,
/* 0000CDF0 */ 0x05, 0xFE, 0x5F, 0x03, 0x06, 0xFE, 0x60, 0x03, 0xEE, 0x4F, 0x0C, 0x4F, 0x0D, 0x98, 0x10, 0x07,
/* 0000CE00 */ 0x08, 0x00, 0x00, 0x54, 0x0C, 0x10, 0x2C, 0x10, 0x0C, 0x15, 0x03, 0x00, 0x10, 0x02, 0x09, 0xCC,
/* 0000CE10 */ 0x00, 0x8F, 0x01, 0x31, 0x11, 0x00, 0x00, 0x6D, 0x10, 0x11, 0x00, 0x07, 0x02, 0x00, 0x5C, 0x00,
/* 0000CE20 */ 0x11, 0x5C, 0x01, 0x0C, 0xF2, 0x02, 0x10, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x54, 0x0D,
/* 0000CE30 */ 0x10, 0x8F, 0x01, 0x27, 0x10, 0x01, 0x00, 0x07, 0x02, 0x00, 0x5C, 0x00, 0x03, 0x5C, 0x01, 0x0D,
/* 0000CE40 */ 0xEE, 0x02, 0x10, 0x10, 0x01, 0x00, 0x0F, 0x13, 0x00, 0x10, 0x09, 0x00, 0x00, 0x12, 0x0B, 0x00,
/* 0000CE50 */ 0x0D, 0x09, 0x09, 0x00, 0x00, 0x11, 0x03, 0x00, 0x0D, 0x0A, 0x09, 0x5D, 0x00, 0x8F, 0x01, 0x09,
/* 0000CE60 */ 0x11, 0x02, 0x00, 0x6D, 0x10, 0x11, 0x01, 0x07, 0x04, 0x00, 0x5C, 0x00, 0x11, 0x8F, 0x01, 0x11,
/* 0000CE70 */ 0x12, 0x03, 0x00, 0x07, 0x02, 0x00, 0x5C, 0x00, 0x03, 0x5C, 0x01, 0x0C, 0xEE, 0x02, 0x12, 0x12,
/* 0000CE80 */ 0x03, 0x00, 0x5C, 0x01, 0x12, 0x8F, 0x01, 0x11, 0x12, 0x03, 0x00, 0x07, 0x02, 0x00, 0x5C, 0x00,
/* 0000CE90 */ 0x03, 0x5C, 0x01, 0x08, 0xEE, 0x02, 0x12, 0x12, 0x04, 0x00, 0x5C, 0x02, 0x12, 0x2F, 0x12, 0x04,
/* 0000CEA0 */ 0x09, 0x2F, 0x12, 0x12, 0x05, 0x2F, 0x12, 0x12, 0x0A, 0x2F, 0x12, 0x12, 0x06, 0x5C, 0x03, 0x12,
/* 0000CEB0 */ 0xF2, 0x04, 0xFF, 0x10, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x8F, 0x01, 0x15, 0x11, 0x04, 0x00,
/* 0000CEC0 */ 0x6D, 0x10, 0x11, 0x02, 0x07, 0x02, 0x00, 0x5C, 0x00, 0x11, 0x5C, 0x01, 0x0D, 0xF2, 0x02, 0x00,
/* 0000CED0 */ 0x10, 0x02, 0x00, 0x00, 0x00, 0x05, 0x00, 0x09, 0x0B, 0x00, 0x09, 0x06, 0x00, 0x47, 0x00, 0x0B,
/* 0000CEE0 */ 0x09, 0x02, 0x00, 0xA8, 0x00, 0x24, 0x00, 0xFE, 0x5C, 0x02, 0xFE, 0x5D, 0x02, 0x1F, 0xFE, 0xCE,
/* 0000CEF0 */ 0x3D, 0x08, 0x04, 0x00, 0x00, 0x00, 0x09, 0x00, 0x2F, 0x00, 0x0B, 0x00, 0x34, 0x00, 0x20, 0x00,
/* 0000CF00 */ 0x43, 0x00, 0x2C, 0x00, 0x66, 0x00, 0x5D, 0x00, 0x90, 0x00, 0x23, 0x00, 0x42, 0x00, 0x08, 0x00,
/* 0000CF10 */ 0x21, 0x00, 0x00, 0xBF, 0x5C, 0x85, 0xE0, 0x01, 0xC4, 0x00, 0xFE, 0x6D, 0x01, 0x04, 0xA3, 0x41,
/* 0000CF20 */ 0xC1, 0x00, 0xFE, 0x06, 0x03, 0x19, 0xFE, 0x44, 0x3A, 0xFF, 0x00, 0x10, 0x01, 0x00, 0x06, 0x06,
/* 0000CF30 */ 0xFE, 0x44, 0x3A, 0xFE, 0x2F, 0x03, 0xFE, 0x2F, 0x03, 0x01, 0x0B, 0x0A, 0x11, 0x0A, 0x51, 0x4B,
/* 0000CF40 */ 0x01, 0x01, 0x08, 0x06, 0x04, 0x04, 0x04, 0x04, 0x10, 0x06, 0xFE, 0x57, 0x03, 0x06, 0xFE, 0x58,
/* 0000CF50 */ 0x03, 0x06, 0xFE, 0x59, 0x03, 0x08, 0x01, 0xFF, 0x05, 0xFE, 0x5A, 0x03, 0x05, 0xFE, 0x5B, 0x03,
/* 0000CF60 */ 0x05, 0xFE, 0x5C, 0x03, 0xFE, 0x48, 0x01, 0x4F, 0x0F, 0x98, 0x11, 0x0A, 0x0B, 0x00, 0x00, 0x47,
/* 0000CF70 */ 0x0F, 0x11, 0xA8, 0x11, 0x15, 0x03, 0x00, 0x0F, 0x11, 0x09, 0x29, 0x01, 0x0C, 0x03, 0x00, 0x0C,
/* 0000CF80 */ 0x02, 0x09, 0x20, 0x00, 0x8F, 0x01, 0x31, 0x12, 0x00, 0x00, 0x6D, 0x11, 0x12, 0x00, 0x07, 0x02,
/* 0000CF90 */ 0x00, 0x5C, 0x00, 0x12, 0x5C, 0x01, 0x0F, 0xF2, 0x02, 0x11, 0x11, 0x00, 0x00, 0x00, 0x00, 0x00,
/* 0000CFA0 */ 0x00, 0x47, 0x0F, 0x11, 0x0C, 0x03, 0x00, 0x0C, 0x03, 0x09, 0x20, 0x00, 0x8F, 0x01, 0x31, 0x12,
/* 0000CFB0 */ 0x00, 0x00, 0x6D, 0x11, 0x12, 0x01, 0x07, 0x02, 0x00, 0x5C, 0x00, 0x12, 0x5C, 0x01, 0x0F, 0xF2,
/* 0000CFC0 */ 0x02, 0x11, 0x11, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x47, 0x0F, 0x11, 0x0C, 0x03, 0x00, 0x0C,
/* 0000CFD0 */ 0x04, 0x09, 0x20, 0x00, 0x8F, 0x01, 0x31, 0x12, 0x00, 0x00, 0x6D, 0x11, 0x12, 0x02, 0x07, 0x02,
/* 0000CFE0 */ 0x00, 0x5C, 0x00, 0x12, 0x5C, 0x01, 0x0F, 0xF2, 0x02, 0x11, 0x11, 0x02, 0x00, 0x00, 0x00, 0x02,
/* 0000CFF0 */ 0x00, 0x47, 0x0F, 0x11, 0xA8, 0x11, 0x15, 0x03, 0x00, 0x0D, 0x11, 0x09, 0xA1, 0x00, 0x8F, 0x01,
/* 0000D000 */ 0x0C, 0x11, 0x01, 0x00, 0x07, 0x04, 0x00, 0x5C, 0x00, 0x05, 0x8F, 0x01, 0x1D, 0x12, 0x02, 0x00,
/* 0000D010 */ 0x5C, 0x01, 0x12, 0x5C, 0x02, 0x0D, 0x5C, 0x03, 0x0F, 0xEE, 0x04, 0x11, 0x11, 0x03, 0x00, 0x0C,
/* 0000D020 */ 0x03, 0x00, 0x11, 0x06, 0x09, 0x78, 0x00, 0x8F, 0x01, 0x09, 0x12, 0x03, 0x00, 0x6D, 0x11, 0x12,
/* 0000D030 */ 0x03, 0x07, 0x04, 0x00, 0x5C, 0x00, 0x12, 0x8F, 0x01, 0x11, 0x13, 0x04, 0x00, 0x07, 0x02, 0x00,
/* 0000D040 */ 0x5C, 0x00, 0x05, 0x5C, 0x01, 0x0F, 0xEE, 0x02, 0x13, 0x13, 0x05, 0x00, 0x5C, 0x01, 0x13, 0x8F,
/* 0000D050 */ 0x01, 0x11, 0x13, 0x04, 0x00, 0x07, 0x02, 0x00, 0x5C, 0x00, 0x05, 0x5C, 0x01, 0x0B, 0xEE, 0x02,
/* 0000D060 */ 0x13, 0x13, 0x06, 0x00, 0x5C, 0x02, 0x13, 0x8F, 0x01, 0x0C, 0x13, 0x01, 0x00, 0x07, 0x04, 0x00,
/* 0000D070 */ 0x5C, 0x00, 0x05, 0x8F, 0x01, 0x1F, 0x14, 0x05, 0x00, 0x5C, 0x01, 0x14, 0x5C, 0x02, 0x0D, 0x5D,
/* 0000D080 */ 0x03, 0x08, 0x07, 0x00, 0xEE, 0x04, 0x13, 0x13, 0x07, 0x00, 0x2F, 0x13, 0x07, 0x13, 0x2F, 0x13,
/* 0000D090 */ 0x13, 0x09, 0x5C, 0x03, 0x13, 0xF2, 0x04, 0xFF, 0x11, 0x03, 0x00, 0x00, 0x00, 0x04, 0x00, 0x47,
/* 0000D0A0 */ 0x00, 0x0F, 0x09, 0x08, 0x00, 0x47, 0x00, 0x0E, 0x09, 0x02, 0x00, 0xA8, 0x00, 0x24, 0x00, 0xFE,
/* 0000D0B0 */ 0x5A, 0x02, 0xFE, 0x5B, 0x02, 0xFE, 0x5C, 0x02, 0xFE, 0x5D, 0x02, 0xFE, 0x8D, 0x3A, 0x0D, 0x02,
/* 0000D0C0 */ 0x00, 0x00, 0x00, 0x09, 0x00, 0x2A, 0x00, 0x0A, 0x00, 0x28, 0x00, 0x08, 0x00, 0x2A, 0x00, 0x20,
/* 0000D0D0 */ 0x00, 0x48, 0x00, 0x08, 0x00, 0x29, 0x00, 0x20, 0x00, 0x40, 0x00, 0x08, 0x00, 0x29, 0x00, 0x20,
/* 0000D0E0 */ 0x00, 0x40, 0x00, 0x33, 0x00, 0x6C, 0x00, 0x78, 0x00, 0xA9, 0x00, 0x06, 0x00, 0x24, 0x00, 0x08,
/* 0000D0F0 */ 0x00, 0x16, 0x00, 0x00, 0x3F, 0x5C, 0x84, 0xE0, 0x09, 0xC4, 0x12, 0xFE, 0x42, 0x01, 0x14, 0xA0,
/* 0000D100 */ 0x41, 0xD1, 0x00, 0x12, 0xFE, 0x08, 0x35, 0x06, 0xFF, 0x00, 0x10, 0x01, 0x00, 0x01, 0x01, 0xFE,
/* 0000D110 */ 0x08, 0x35, 0xFE, 0x08, 0x05, 0xFE, 0x08, 0x05, 0x04, 0x0A, 0x0B, 0x04, 0x1D, 0x1D, 0x01, 0x01,
/* 0000D120 */ 0x01, 0x06, 0x06, 0x06, 0x06, 0x01, 0x0A, 0x06, 0xFE, 0x51, 0x03, 0x06, 0xFE, 0x52, 0x03, 0x06,
/* 0000D130 */ 0xFE, 0x53, 0x03, 0x06, 0xFE, 0x54, 0x03, 0x06, 0xFE, 0x55, 0x03, 0x06, 0xFE, 0x56, 0x03, 0x07,
/* 0000D140 */ 0x08, 0x76, 0x8F, 0x01, 0x0A, 0x0B, 0x00, 0x00, 0x07, 0x03, 0x00, 0x5C, 0x00, 0x09, 0xCC, 0x00,
/* 0000D150 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00, 0xD4, 0x00, 0x0D, 0x7B, 0x0D,
/* 0000D160 */ 0x0C, 0x00, 0x01, 0x64, 0x01, 0x0D, 0x0C, 0xD4, 0x01, 0x0D, 0x7B, 0x0D, 0x0C, 0x01, 0x01, 0x64,
/* 0000D170 */ 0x01, 0x0D, 0x0C, 0xD4, 0x02, 0x0D, 0x7B, 0x0D, 0x0C, 0x02, 0x01, 0x64, 0x01, 0x0D, 0x0C, 0xD4,
/* 0000D180 */ 0x03, 0x0D, 0x7B, 0x0D, 0x0C, 0x03, 0x01, 0x64, 0x01, 0x0D, 0x0C, 0xD4, 0x04, 0x0D, 0x7B, 0x0D,
/* 0000D190 */ 0x0C, 0x04, 0x01, 0x64, 0x01, 0x0D, 0x0C, 0xD4, 0x05, 0x0D, 0x7B, 0x0D, 0x0C, 0x05, 0x01, 0x64,
/* 0000D1A0 */ 0x01, 0x0D, 0x0C, 0x5C, 0x01, 0x0C, 0x5D, 0x02, 0x08, 0x00, 0x00, 0xEE, 0x03, 0x00, 0x0B, 0x00,
/* 0000D1B0 */ 0x00, 0x09, 0x02, 0x00, 0xA8, 0x00, 0x24, 0x00, 0x01, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03,
/* 0000D1C0 */ 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x51, 0x03, 0x00, 0x00, 0x5B, 0x02, 0x00, 0x00, 0x5C,
/* 0000D1D0 */ 0x02, 0x00, 0x00, 0x5A, 0x02, 0x00, 0x00, 0x5F, 0x02, 0x00, 0x00, 0x56, 0x03, 0x00, 0x00, 0xFE,
/* 0000D1E0 */ 0x51, 0x03, 0xFE, 0x5B, 0x02, 0xFE, 0x5C, 0x02, 0xFE, 0x5A, 0x02, 0xFE, 0x5F, 0x02, 0xFE, 0x56,
/* 0000D1F0 */ 0x03, 0xFE, 0x1F, 0x35, 0x02, 0x00, 0x00, 0x00, 0x00, 0x74, 0x00, 0xF0, 0x04, 0x00, 0x11, 0xD5,
/* 0000D200 */ 0x00, 0x00, 0xA4, 0xD4, 0x00, 0x00, 0x37, 0xD4, 0x00, 0x00, 0xCA, 0xD3, 0x00, 0x00, 0xC3, 0xD2,
/* 0000D210 */ 0x00, 0x00, 0x16, 0xD2, 0x00, 0x00, 0xBF, 0x7C, 0x84, 0x01, 0x00, 0xC4, 0x04, 0xFE, 0x60, 0x01,
/* 0000D220 */ 0x19, 0xA2, 0x41, 0xC1, 0x00, 0xFE, 0x56, 0x03, 0x18, 0xFE, 0xBA, 0x38, 0xFF, 0x00, 0x10, 0x01,
/* 0000D230 */ 0x00, 0x03, 0x03, 0xFE, 0xBA, 0x38, 0xFE, 0x3D, 0x01, 0xFE, 0x3D, 0x01, 0x01, 0x05, 0x04, 0x07,
/* 0000D240 */ 0x05, 0x1C, 0x1A, 0x19, 0x01, 0x02, 0x03, 0x01, 0x06, 0x00, 0x58, 0x08, 0x0B, 0x5C, 0xEB, 0x00,
/* 0000D250 */ 0xEC, 0x00, 0x0F, 0x03, 0x00, 0x04, 0x09, 0x4B, 0x00, 0x8F, 0x01, 0x0C, 0x07, 0x00, 0x00, 0x07,
/* 0000D260 */ 0x04, 0x00, 0x5C, 0x00, 0x02, 0x8F, 0x01, 0x19, 0x08, 0x01, 0x00, 0x5C, 0x01, 0x08, 0x5C, 0x02,
/* 0000D270 */ 0x04, 0x5C, 0x03, 0x05, 0xEE, 0x04, 0x07, 0x07, 0x00, 0x00, 0x0F, 0x03, 0x00, 0x07, 0x09, 0x08,
/* 0000D280 */ 0x00, 0x47, 0x00, 0x03, 0xED, 0x00, 0x09, 0x1F, 0x00, 0x8F, 0x01, 0x16, 0x07, 0x02, 0x00, 0x07,
/* 0000D290 */ 0x02, 0x00, 0x5C, 0x00, 0x02, 0x5C, 0x01, 0x04, 0xEE, 0x02, 0x07, 0x07, 0x01, 0x00, 0x47, 0x04,
/* 0000D2A0 */ 0x07, 0x09, 0xAC, 0xFF, 0xED, 0x00, 0xA8, 0x00, 0x24, 0x00, 0xFE, 0x11, 0x39, 0x05, 0x04, 0x00,
/* 0000D2B0 */ 0x00, 0x00, 0x07, 0x00, 0x1A, 0x00, 0x28, 0x00, 0x55, 0x00, 0x08, 0x00, 0x39, 0x00, 0x1F, 0x00,
/* 0000D2C0 */ 0x3D, 0x00, 0x00, 0xBF, 0x5C, 0x94, 0xE0, 0x01, 0xC4, 0x00, 0xFE, 0x57, 0x01, 0x16, 0xA2, 0x41,
/* 0000D2D0 */ 0xC1, 0x00, 0xFE, 0x55, 0x03, 0x17, 0xFE, 0x9A, 0x37, 0xFF, 0x00, 0x10, 0x01, 0x00, 0x02, 0x02,
/* 0000D2E0 */ 0xFE, 0x9A, 0x37, 0xFE, 0x02, 0x01, 0xFE, 0x02, 0x01, 0x01, 0x09, 0x06, 0x0A, 0x07, 0x2A, 0x25,
/* 0000D2F0 */ 0x01, 0x05, 0x01, 0x04, 0x02, 0x02, 0x02, 0x02, 0x09, 0x08, 0x01, 0x00, 0x01, 0x02, 0x01, 0x20,
/* 0000D300 */ 0xAA, 0x8F, 0x01, 0x10, 0x0A, 0x00, 0x00, 0x07, 0x02, 0x00, 0x5C, 0x00, 0x02, 0x5C, 0x01, 0x06,
/* 0000D310 */ 0xEE, 0x02, 0x0A, 0x0A, 0x00, 0x00, 0x47, 0x07, 0x0A, 0x47, 0x08, 0x03, 0x8F, 0x01, 0x27, 0x0A,
/* 0000D320 */ 0x01, 0x00, 0x07, 0x02, 0x00, 0x5C, 0x00, 0x02, 0x5C, 0x01, 0x07, 0xEE, 0x02, 0x0A, 0x0A, 0x01,
/* 0000D330 */ 0x00, 0x0F, 0x6C, 0x00, 0x0A, 0x09, 0x00, 0x00, 0x8F, 0x01, 0x26, 0x0A, 0x02, 0x00, 0x07, 0x02,
/* 0000D340 */ 0x00, 0x5C, 0x00, 0x02, 0x5C, 0x01, 0x07, 0xEE, 0x02, 0x0A, 0x0A, 0x02, 0x00, 0x0F, 0x03, 0x00,
/* 0000D350 */ 0x0A, 0x09, 0x4D, 0x00, 0x8F, 0x01, 0x15, 0x0B, 0x03, 0x00, 0x6D, 0x0A, 0x0B, 0x00, 0x07, 0x02,
/* 0000D360 */ 0x00, 0x5C, 0x00, 0x0B, 0x47, 0x0C, 0x07, 0x8F, 0x01, 0x15, 0x0E, 0x03, 0x00, 0x6D, 0x0D, 0x0E,
/* 0000D370 */ 0x01, 0x07, 0x03, 0x00, 0x5C, 0x00, 0x0E, 0x5D, 0x01, 0x04, 0x04, 0x00, 0x5D, 0x02, 0x05, 0x04,
/* 0000D380 */ 0x00, 0xF2, 0x03, 0x0D, 0x0D, 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x34, 0x0C, 0x0C, 0x0D, 0x00,
/* 0000D390 */ 0x00, 0x5C, 0x01, 0x0C, 0xF2, 0x02, 0x0A, 0x0A, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x47, 0x08,
/* 0000D3A0 */ 0x0A, 0x47, 0x00, 0x08, 0x09, 0x02, 0x00, 0xA8, 0x00, 0x24, 0x00, 0x17, 0x25, 0xFE, 0xBA, 0x37,
/* 0000D3B0 */ 0x06, 0x00, 0x00, 0x00, 0x00, 0x18, 0x00, 0x2A, 0x00, 0x03, 0x00, 0x1A, 0x00, 0x38, 0x00, 0x39,
/* 0000D3C0 */ 0x00, 0x4D, 0x00, 0x4B, 0x00, 0x08, 0x00, 0x19, 0x00, 0x00, 0xBF, 0x5C, 0x84, 0x00, 0x00, 0xC4,
/* 0000D3D0 */ 0x00, 0xFE, 0x53, 0x01, 0x1E, 0xA2, 0x41, 0xC1, 0x00, 0xFE, 0x54, 0x03, 0x16, 0xFE, 0x20, 0x37,
/* 0000D3E0 */ 0xFF, 0x00, 0x10, 0x01, 0x00, 0x02, 0x02, 0xFE, 0x20, 0x37, 0x5F, 0x5F, 0x01, 0x03, 0x03, 0x05,
/* 0000D3F0 */ 0x03, 0x10, 0x0E, 0x01, 0x01, 0x01, 0x04, 0x08, 0x31, 0xA8, 0x05, 0x15, 0x03, 0x00, 0x03, 0x05,
/* 0000D400 */ 0x09, 0x1B, 0x00, 0x8F, 0x01, 0x0D, 0x05, 0x00, 0x00, 0x07, 0x02, 0x00, 0x5C, 0x00, 0x02, 0x5C,
/* 0000D410 */ 0x01, 0x03, 0xEE, 0x02, 0x05, 0x05, 0x00, 0x00, 0x47, 0x00, 0x05, 0x09, 0x05, 0x00, 0xA8, 0x05,
/* 0000D420 */ 0x47, 0x00, 0x05, 0x09, 0x02, 0x00, 0xA8, 0x00, 0x24, 0x00, 0xFE, 0x40, 0x37, 0x02, 0x00, 0x00,
/* 0000D430 */ 0x00, 0x00, 0x2F, 0x00, 0x3E, 0x00, 0x00, 0xBF, 0x5C, 0x84, 0x00, 0x00, 0xC4, 0x00, 0xFE, 0x4F,
/* 0000D440 */ 0x01, 0x16, 0xA2, 0x41, 0xC1, 0x00, 0xFE, 0x53, 0x03, 0x15, 0xFE, 0xA5, 0x36, 0xFF, 0x00, 0x10,
/* 0000D450 */ 0x01, 0x00, 0x02, 0x02, 0xFE, 0xA5, 0x36, 0x58, 0x58, 0x01, 0x03, 0x03, 0x05, 0x03, 0x10, 0x0E,
/* 0000D460 */ 0x01, 0x01, 0x01, 0x04, 0x08, 0x31, 0xA8, 0x05, 0x14, 0x03, 0x00, 0x03, 0x05, 0x09, 0x08, 0x00,
/* 0000D470 */ 0xA9, 0x05, 0x47, 0x00, 0x05, 0x09, 0x18, 0x00, 0x8F, 0x01, 0x10, 0x05, 0x00, 0x00, 0x07, 0x02,
/* 0000D480 */ 0x00, 0x5C, 0x00, 0x02, 0x5C, 0x01, 0x03, 0xEE, 0x02, 0x05, 0x05, 0x00, 0x00, 0x47, 0x00, 0x05,
/* 0000D490 */ 0x09, 0x02, 0x00, 0xA8, 0x00, 0x24, 0x00, 0xFE, 0xC5, 0x36, 0x02, 0x00, 0x00, 0x00, 0x00, 0x2F,
/* 0000D4A0 */ 0x00, 0x37, 0x00, 0x00, 0xBF, 0x5C, 0x84, 0x00, 0x00, 0xC4, 0x00, 0xFE, 0x4B, 0x01, 0x16, 0xA2,
/* 0000D4B0 */ 0x41, 0xC1, 0x00, 0xFE, 0x52, 0x03, 0x14, 0xFE, 0x2C, 0x36, 0xFF, 0x00, 0x10, 0x01, 0x00, 0x02,
/* 0000D4C0 */ 0x02, 0xFE, 0x2C, 0x36, 0x5E, 0x5E, 0x01, 0x03, 0x03, 0x05, 0x03, 0x10, 0x0E, 0x01, 0x01, 0x01,
/* 0000D4D0 */ 0x04, 0x08, 0x31, 0xA8, 0x05, 0x15, 0x03, 0x00, 0x03, 0x05, 0x09, 0x1B, 0x00, 0x8F, 0x01, 0x11,
/* 0000D4E0 */ 0x05, 0x00, 0x00, 0x07, 0x02, 0x00, 0x5C, 0x00, 0x02, 0x5C, 0x01, 0x03, 0xEE, 0x02, 0x05, 0x05,
/* 0000D4F0 */ 0x00, 0x00, 0x47, 0x00, 0x05, 0x09, 0x05, 0x00, 0xA8, 0x05, 0x47, 0x00, 0x05, 0x09, 0x02, 0x00,
/* 0000D500 */ 0xA8, 0x00, 0x24, 0x00, 0xFE, 0x4C, 0x36, 0x02, 0x00, 0x00, 0x00, 0x00, 0x2F, 0x00, 0x3D, 0x00,
/* 0000D510 */ 0x00, 0xBF, 0x5C, 0x84, 0xE0, 0x01, 0xC4, 0x00, 0xFE, 0x44, 0x01, 0x16, 0xA2, 0x41, 0xC1, 0x00,
/* 0000D520 */ 0xFE, 0x51, 0x03, 0x13, 0xFE, 0x4C, 0x35, 0xFF, 0x00, 0x10, 0x01, 0x00, 0x02, 0x02, 0xFE, 0x4C,
/* 0000D530 */ 0x35, 0xC5, 0xC5, 0x01, 0x04, 0x04, 0x06, 0x03, 0x17, 0x15, 0x01, 0x02, 0x02, 0x01, 0x01, 0x01,
/* 0000D540 */ 0x01, 0x05, 0x07, 0x08, 0x53, 0x14, 0x03, 0x00, 0x04, 0x02, 0x09, 0x1A, 0x00, 0x8F, 0x01, 0x09,
/* 0000D550 */ 0x07, 0x00, 0x00, 0x6D, 0x06, 0x07, 0x00, 0x07, 0x01, 0x00, 0x5C, 0x00, 0x07, 0xF2, 0x01, 0xFF,
/* 0000D560 */ 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xA8, 0x06, 0x15, 0x03, 0x00, 0x04, 0x06, 0x09, 0x1B,
/* 0000D570 */ 0x00, 0x8F, 0x01, 0x0E, 0x06, 0x01, 0x00, 0x07, 0x02, 0x00, 0x5C, 0x00, 0x03, 0x5C, 0x01, 0x04,
/* 0000D580 */ 0xEE, 0x02, 0x06, 0x06, 0x01, 0x00, 0x47, 0x00, 0x06, 0x09, 0x05, 0x00, 0xA8, 0x06, 0x47, 0x00,
/* 0000D590 */ 0x06, 0x09, 0x02, 0x00, 0xA8, 0x00, 0x24, 0x00, 0xFE, 0x55, 0x02, 0xFE, 0x6C, 0x35, 0x04, 0x00,
/* 0000D5A0 */ 0x00, 0x00, 0x00, 0x08, 0x00, 0x27, 0x00, 0x1A, 0x00, 0x40, 0x00, 0x2F, 0x00, 0x3D, 0x00, 0x00,
/* 0000D5B0 */ 0xBF, 0x5C, 0x85, 0xE0, 0x31, 0xD4, 0x00, 0xFE, 0x27, 0x01, 0x20, 0xA0, 0x41, 0xC1, 0x00, 0xFE,
/* 0000D5C0 */ 0x28, 0x03, 0x11, 0xFE, 0x66, 0x31, 0xFF, 0x00, 0x10, 0x01, 0x00, 0x01, 0x01, 0xFE, 0x66, 0x31,
/* 0000D5D0 */ 0xFE, 0x89, 0x03, 0xFE, 0x89, 0x03, 0x01, 0x07, 0x05, 0x08, 0x06, 0x41, 0x41, 0x01, 0x02, 0x05,
/* 0000D5E0 */ 0x06, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x07, 0x08, 0x08, 0x01, 0x00, 0x01, 0x01, 0xFE, 0x01,
/* 0000D5F0 */ 0x01, 0x4F, 0x05, 0x4F, 0x06, 0x8F, 0x01, 0x3F, 0x09, 0x00, 0x00, 0x4B, 0x09, 0x0F, 0x03, 0x00,
/* 0000D600 */ 0x09, 0x09, 0x0B, 0x00, 0x8F, 0x01, 0x3F, 0x00, 0x00, 0x00, 0x4B, 0x00, 0x09, 0xE1, 0x00, 0x8F,
/* 0000D610 */ 0x01, 0x39, 0x09, 0x01, 0x00, 0x4B, 0x09, 0x0F, 0x03, 0x00, 0x09, 0x09, 0x82, 0x00, 0x8F, 0x01,
/* 0000D620 */ 0x41, 0x09, 0x02, 0x00, 0x4B, 0x09, 0x0F, 0x15, 0x00, 0x09, 0x09, 0x00, 0x00, 0x8F, 0x01, 0x05,
/* 0000D630 */ 0x09, 0x03, 0x00, 0x07, 0x01, 0x00, 0x5C, 0x00, 0x02, 0xEE, 0x01, 0xFF, 0x09, 0x00, 0x00, 0x8F,
/* 0000D640 */ 0x01, 0x3C, 0x09, 0x04, 0x00, 0x4B, 0x09, 0x07, 0x01, 0x00, 0x5C, 0x00, 0x02, 0xEE, 0x01, 0x09,
/* 0000D650 */ 0x09, 0x01, 0x00, 0x54, 0x05, 0x09, 0x8F, 0x01, 0x09, 0x0A, 0x05, 0x00, 0x6D, 0x09, 0x0A, 0x00,
/* 0000D660 */ 0x07, 0x03, 0x00, 0x5C, 0x00, 0x0A, 0x5C, 0x01, 0x05, 0x8F, 0x01, 0x41, 0x0B, 0x02, 0x00, 0x4B,
/* 0000D670 */ 0x0B, 0x5C, 0x02, 0x0B, 0xF2, 0x03, 0x09, 0x09, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x54, 0x06,
/* 0000D680 */ 0x09, 0x0F, 0x03, 0x00, 0x06, 0x09, 0x0F, 0x00, 0x98, 0x09, 0x06, 0x03, 0x00, 0x00, 0x01, 0x32,
/* 0000D690 */ 0x01, 0x01, 0x3F, 0x09, 0x09, 0x06, 0x00, 0x01, 0x32, 0x01, 0x01, 0x3F, 0x05, 0x09, 0x43, 0x00,
/* 0000D6A0 */ 0x8F, 0x01, 0x09, 0x0A, 0x05, 0x00, 0x6D, 0x09, 0x0A, 0x00, 0x07, 0x03, 0x00, 0x5C, 0x00, 0x0A,
/* 0000D6B0 */ 0x8F, 0x01, 0x3C, 0x0B, 0x04, 0x00, 0x4B, 0x0B, 0x07, 0x01, 0x00, 0x5C, 0x00, 0x02, 0xEE, 0x01,
/* 0000D6C0 */ 0x0B, 0x0B, 0x04, 0x00, 0x5C, 0x01, 0x0B, 0xE0, 0x0B, 0x00, 0x5C, 0x02, 0x0B, 0xF2, 0x03, 0x09,
/* 0000D6D0 */ 0x09, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x98, 0x09, 0x09, 0x04, 0x01, 0x00, 0x01, 0x32, 0x01,
/* 0000D6E0 */ 0x01, 0x3F, 0x09, 0x8F, 0x01, 0x3F, 0x00, 0x00, 0x00, 0x4B, 0x00, 0x09, 0x02, 0x00, 0xA8, 0x00,
/* 0000D6F0 */ 0x24, 0x00, 0xFE, 0x37, 0x02, 0x09, 0xFE, 0x50, 0x03, 0x00, 0xFE, 0x7D, 0x31, 0x0D, 0x04, 0x00,
/* 0000D700 */ 0x00, 0x00, 0x0F, 0x00, 0x2C, 0x00, 0x0B, 0x00, 0x36, 0x00, 0x0F, 0x00, 0x27, 0x00, 0x0F, 0x00,
/* 0000D710 */ 0x2A, 0x00, 0x12, 0x00, 0x36, 0x00, 0x17, 0x00, 0x2D, 0x00, 0x2B, 0x00, 0x4E, 0x00, 0x07, 0x00,
/* 0000D720 */ 0x5D, 0x00, 0x0F, 0x00, 0x4B, 0x00, 0x09, 0x00, 0xD0, 0x00, 0x43, 0x00, 0x70, 0x00, 0x0D, 0x00,
/* 0000D730 */ 0x25, 0x00, 0x00, 0xBF, 0x7C, 0x85, 0xE1, 0x01, 0xC4, 0x04, 0xFE, 0x15, 0x01, 0x19, 0xA2, 0x41,
/* 0000D740 */ 0xC1, 0x00, 0xFE, 0x27, 0x03, 0x10, 0xFE, 0x31, 0x2E, 0xFF, 0x00, 0x10, 0x01, 0x00, 0x05, 0x05,
/* 0000D750 */ 0xFE, 0x31, 0x2E, 0xFE, 0x9F, 0x02, 0xFE, 0x9F, 0x02, 0x01, 0x0C, 0x06, 0x10, 0x06, 0x41, 0x36,
/* 0000D760 */ 0x18, 0x01, 0x01, 0x04, 0x04, 0x01, 0x01, 0x01, 0x01, 0x01, 0x0F, 0x64, 0xB5, 0x05, 0xFE, 0x4F,
/* 0000D770 */ 0x03, 0x08, 0x01, 0x00, 0x01, 0x01, 0xDC, 0xA8, 0x0D, 0xA8, 0x0E, 0x14, 0x03, 0x00, 0x07, 0x02,
/* 0000D780 */ 0x09, 0x0C, 0x00, 0x8F, 0x01, 0x2C, 0x11, 0x00, 0x00, 0x47, 0x10, 0x11, 0x09, 0x09, 0x00, 0x8F,
/* 0000D790 */ 0x01, 0x2B, 0x11, 0x01, 0x00, 0x47, 0x10, 0x11, 0x47, 0x0A, 0x10, 0x8F, 0x01, 0x0B, 0x10, 0x02,
/* 0000D7A0 */ 0x00, 0x07, 0x02, 0x00, 0x5C, 0x00, 0x03, 0x5C, 0x01, 0x06, 0xEE, 0x02, 0x10, 0x10, 0x00, 0x00,
/* 0000D7B0 */ 0x47, 0x0B, 0x10, 0x07, 0x01, 0x00, 0x5C, 0x00, 0x03, 0xEE, 0x01, 0x10, 0x09, 0x01, 0x00, 0x47,
/* 0000D7C0 */ 0x0C, 0x10, 0xA8, 0x10, 0x15, 0x03, 0x00, 0x0B, 0x10, 0x09, 0x06, 0x00, 0x47, 0x10, 0x0B, 0x09,
/* 0000D7D0 */ 0x03, 0x00, 0x47, 0x10, 0x04, 0x47, 0x0B, 0x10, 0x47, 0x0D, 0x04, 0xEB, 0x00, 0xEC, 0x00, 0x12,
/* 0000D7E0 */ 0x03, 0x00, 0x0D, 0x0B, 0x09, 0x43, 0x00, 0x8F, 0x01, 0x2E, 0x10, 0x03, 0x00, 0x07, 0x05, 0x00,
/* 0000D7F0 */ 0x5C, 0x00, 0x03, 0x98, 0x11, 0x06, 0x0D, 0x00, 0x00, 0x5C, 0x01, 0x11, 0x5C, 0x02, 0x0A, 0x5C,
/* 0000D800 */ 0x03, 0x08, 0x5C, 0x04, 0x0C, 0xEE, 0x05, 0x10, 0x10, 0x02, 0x00, 0x47, 0x0E, 0x10, 0x62, 0x10,
/* 0000D810 */ 0x0E, 0x00, 0xA8, 0x11, 0x15, 0x03, 0x00, 0x10, 0x11, 0x09, 0x08, 0x00, 0x47, 0x00, 0x0E, 0xED,
/* 0000D820 */ 0x00, 0x09, 0x2D, 0x00, 0x28, 0x0D, 0x0D, 0x09, 0xB3, 0xFF, 0xED, 0x00, 0x8F, 0x01, 0x2E, 0x10,
/* 0000D830 */ 0x03, 0x00, 0x07, 0x05, 0x00, 0x5C, 0x00, 0x03, 0x5C, 0x01, 0x0C, 0x5C, 0x02, 0x0A, 0xA8, 0x11,
/* 0000D840 */ 0x5C, 0x03, 0x11, 0x5C, 0x04, 0x0C, 0xEE, 0x05, 0x00, 0x10, 0x03, 0x00, 0x09, 0x02, 0x00, 0xA8,
/* 0000D850 */ 0x00, 0x24, 0x00, 0xFE, 0x1F, 0x02, 0xFE, 0x81, 0x2E, 0x0C, 0x04, 0x00, 0x00, 0x00, 0x20, 0x00,
/* 0000D860 */ 0x59, 0x00, 0x18, 0x00, 0x36, 0x00, 0x0F, 0x00, 0x34, 0x00, 0x16, 0x00, 0x3A, 0x00, 0x07, 0x00,
/* 0000D870 */ 0x0B, 0x00, 0x08, 0x00, 0x20, 0x00, 0x27, 0x00, 0x6A, 0x00, 0x0E, 0x00, 0x36, 0x00, 0x08, 0x00,
/* 0000D880 */ 0x4C, 0xFF, 0x08, 0x00, 0xE8, 0x00, 0x25, 0x00, 0x52, 0x00, 0x00, 0x3F, 0x5D, 0x8D, 0xE0, 0xB9,
/* 0000D890 */ 0xD6, 0x12, 0xDD, 0x1E, 0xA2, 0x41, 0xC1, 0x00, 0xFE, 0x26, 0x03, 0x0D, 0xFE, 0x4D, 0x24, 0x02,
/* 0000D8A0 */ 0xFF, 0x00, 0x10, 0x01, 0x00, 0x05, 0x05, 0xFE, 0x4D, 0x24, 0xFE, 0xC7, 0x09, 0xFE, 0xC7, 0x09,
/* 0000D8B0 */ 0x03, 0x0E, 0x0B, 0x15, 0x05, 0x71, 0x6A, 0x01, 0x01, 0x09, 0x01, 0x0B, 0x05, 0x05, 0x05, 0x05,
/* 0000D8C0 */ 0x01, 0x01, 0x01, 0x12, 0x13, 0x14, 0x15, 0x07, 0x08, 0x01, 0x01, 0x01, 0x00, 0x06, 0xFE, 0x45,
/* 0000D8D0 */ 0x03, 0x05, 0xFE, 0x47, 0x03, 0x06, 0xFE, 0x48, 0x03, 0x06, 0xFE, 0x49, 0x03, 0x06, 0xFE, 0x4A,
/* 0000D8E0 */ 0x03, 0xFE, 0xC2, 0x01, 0x96, 0x03, 0x0B, 0x96, 0x04, 0x0D, 0x4F, 0x11, 0x8F, 0x01, 0x09, 0x17,
/* 0000D8F0 */ 0x00, 0x00, 0x6D, 0x16, 0x17, 0x00, 0x07, 0x02, 0x00, 0x5C, 0x00, 0x17, 0x93, 0x03, 0x18, 0x01,
/* 0000D900 */ 0x00, 0x5C, 0x01, 0x18, 0xF2, 0x02, 0x16, 0x16, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x47, 0x0F,
/* 0000D910 */ 0x16, 0x14, 0x03, 0x00, 0x0F, 0x02, 0x09, 0x1D, 0x00, 0x8F, 0x01, 0x2D, 0x16, 0x02, 0x00, 0x07,
/* 0000D920 */ 0x02, 0x00, 0x5C, 0x00, 0x03, 0x93, 0x03, 0x17, 0x01, 0x00, 0x5C, 0x01, 0x17, 0xEE, 0x02, 0x16,
/* 0000D930 */ 0x16, 0x01, 0x00, 0x47, 0x0F, 0x16, 0x0F, 0x03, 0x00, 0x0F, 0x09, 0x24, 0x00, 0x8F, 0x01, 0x0C,
/* 0000D940 */ 0x16, 0x03, 0x00, 0x07, 0x04, 0x00, 0x5C, 0x00, 0x03, 0x8F, 0x01, 0x1C, 0x17, 0x04, 0x00, 0x5C,
/* 0000D950 */ 0x01, 0x17, 0x5C, 0x02, 0x0F, 0xD4, 0x00, 0x17, 0x5C, 0x03, 0x17, 0xEE, 0x04, 0xFF, 0x16, 0x02,
/* 0000D960 */ 0x00, 0x8F, 0x01, 0x09, 0x17, 0x00, 0x00, 0x6D, 0x16, 0x17, 0x01, 0x07, 0x03, 0x00, 0x5C, 0x00,
/* 0000D970 */ 0x17, 0x93, 0x03, 0x18, 0x01, 0x00, 0x5C, 0x01, 0x18, 0xE0, 0x18, 0x00, 0x5C, 0x02, 0x18, 0xF2,
/* 0000D980 */ 0x03, 0x16, 0x16, 0x01, 0x00, 0x00, 0x00, 0x03, 0x00, 0x98, 0x16, 0x16, 0x04, 0x00, 0x00, 0x96,
/* 0000D990 */ 0x03, 0x16, 0x07, 0x03, 0x00, 0x5C, 0x00, 0x03, 0x93, 0x03, 0x16, 0x01, 0x00, 0x5C, 0x01, 0x16,
/* 0000D9A0 */ 0x5C, 0x02, 0x0E, 0xEE, 0x03, 0x16, 0x0C, 0x04, 0x00, 0x47, 0x10, 0x16, 0x93, 0x04, 0x16, 0x05,
/* 0000D9B0 */ 0x00, 0xA8, 0x17, 0x15, 0x03, 0x00, 0x16, 0x17, 0x09, 0x34, 0x00, 0xCE, 0x16, 0x00, 0x00, 0x00,
/* 0000D9C0 */ 0x96, 0x02, 0x16, 0x8F, 0x01, 0x0C, 0x16, 0x03, 0x00, 0x07, 0x04, 0x00, 0x5C, 0x00, 0x03, 0x8F,
/* 0000D9D0 */ 0x01, 0x1C, 0x17, 0x04, 0x00, 0x5C, 0x01, 0x17, 0x5C, 0x02, 0x0F, 0xD4, 0x01, 0x17, 0x5C, 0x03,
/* 0000D9E0 */ 0x17, 0xEE, 0x04, 0xFF, 0x16, 0x05, 0x00, 0x93, 0x02, 0x16, 0x06, 0x00, 0x47, 0x0F, 0x16, 0x54,
/* 0000D9F0 */ 0x11, 0x10, 0x0F, 0x03, 0x00, 0x10, 0x09, 0x6E, 0x00, 0x0F, 0x03, 0x00, 0x0F, 0x09, 0x37, 0x00,
/* 0000DA00 */ 0x8F, 0x01, 0x0B, 0x16, 0x07, 0x00, 0x07, 0x02, 0x00, 0x5C, 0x00, 0x03, 0x5C, 0x01, 0x0F, 0xEE,
/* 0000DA10 */ 0x02, 0x16, 0x16, 0x06, 0x00, 0x11, 0x03, 0x00, 0x16, 0x05, 0x09, 0x1A, 0x00, 0x8F, 0x01, 0x39,
/* 0000DA20 */ 0x16, 0x08, 0x00, 0x4B, 0x16, 0x0F, 0x03, 0x00, 0x16, 0x09, 0x07, 0x00, 0x2F, 0x10, 0x10, 0x06,
/* 0000DA30 */ 0x09, 0x04, 0x00, 0x2F, 0x10, 0x10, 0x07, 0x47, 0x16, 0x10, 0x8F, 0x01, 0x0C, 0x17, 0x03, 0x00,
/* 0000DA40 */ 0x07, 0x04, 0x00, 0x5C, 0x00, 0x03, 0x8F, 0x01, 0x1F, 0x18, 0x09, 0x00, 0x5C, 0x01, 0x18, 0x5C,
/* 0000DA50 */ 0x02, 0x0F, 0x5D, 0x03, 0x06, 0x07, 0x00, 0xEE, 0x04, 0x17, 0x17, 0x07, 0x00, 0x2F, 0x16, 0x16,
/* 0000DA60 */ 0x17, 0x47, 0x10, 0x16, 0x09, 0x05, 0x00, 0xA8, 0x16, 0x47, 0x10, 0x16, 0x8F, 0x01, 0x0A, 0x16,
/* 0000DA70 */ 0x0A, 0x00, 0x07, 0x03, 0x00, 0x5C, 0x00, 0x03, 0xCC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
/* 0000DA80 */ 0x00, 0x17, 0x00, 0x00, 0x00, 0x7B, 0x10, 0x17, 0x02, 0x7B, 0x0F, 0x17, 0x03, 0x7B, 0x11, 0x17,
/* 0000DA90 */ 0x04, 0x5C, 0x01, 0x17, 0x5D, 0x02, 0x02, 0x08, 0x00, 0xEE, 0x03, 0x00, 0x16, 0x08, 0x00, 0x09,
/* 0000DAA0 */ 0x02, 0x00, 0xA8, 0x00, 0x24, 0x00, 0x01, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x03, 0x00,
/* 0000DAB0 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x1F, 0x02, 0x00, 0x00, 0x39, 0x02, 0x00, 0x00, 0x6D, 0x02, 0x00,
/* 0000DAC0 */ 0x00, 0xFE, 0x2C, 0x02, 0xFE, 0x37, 0x02, 0xFE, 0x1F, 0x02, 0xFE, 0x39, 0x02, 0xFE, 0x6D, 0x02,
/* 0000DAD0 */ 0xFE, 0x4B, 0x03, 0xFE, 0x1F, 0x02, 0xFE, 0x4C, 0x03, 0x0D, 0xFE, 0x4D, 0x03, 0x00, 0xFE, 0x92,
/* 0000DAE0 */ 0x24, 0x15, 0x08, 0x00, 0x00, 0x00, 0x25, 0x00, 0x37, 0x00, 0x08, 0x00, 0x83, 0x00, 0x1D, 0x00,
/* 0000DAF0 */ 0x3D, 0x00, 0x07, 0x00, 0x1C, 0x00, 0x24, 0x00, 0x5B, 0x02, 0x31, 0x00, 0x4A, 0x00, 0x1A, 0x00,
/* 0000DB00 */ 0x39, 0x00, 0x0F, 0x00, 0x51, 0x00, 0x08, 0x00, 0x20, 0x00, 0x24, 0x00, 0xBF, 0x01, 0x08, 0x00,
/* 0000DB10 */ 0xFF, 0x00, 0x03, 0x00, 0x2A, 0x00, 0x07, 0x00, 0x1D, 0x00, 0x24, 0x00, 0x3F, 0x00, 0x0F, 0x00,
/* 0000DB20 */ 0x2F, 0x00, 0x07, 0x00, 0x40, 0x00, 0x04, 0x00, 0x44, 0x00, 0x30, 0x00, 0x5E, 0x00, 0x05, 0x00,
/* 0000DB30 */ 0x2C, 0x00, 0x38, 0x00, 0x9E, 0x00, 0x00, 0x21, 0xDC, 0x00, 0x00, 0x3F, 0xDB, 0x00, 0x00, 0xBF,
/* 0000DB40 */ 0x5C, 0x85, 0xE0, 0x11, 0xC4, 0x00, 0xF2, 0x3D, 0xA2, 0x41, 0xD1, 0x00, 0x0F, 0xFE, 0x25, 0x29,
/* 0000DB50 */ 0xFF, 0x00, 0x10, 0x01, 0x00, 0x02, 0x02, 0xFE, 0x25, 0x29, 0xFE, 0x7D, 0x01, 0xFE, 0x7D, 0x01,
/* 0000DB60 */ 0x41, 0x07, 0x05, 0x09, 0x05, 0x22, 0x20, 0x02, 0x01, 0x03, 0x06, 0x01, 0x01, 0x01, 0x01, 0x01,
/* 0000DB70 */ 0x08, 0x01, 0x01, 0x08, 0x01, 0xFF, 0x89, 0x8F, 0x02, 0x09, 0x0A, 0x00, 0x00, 0x6D, 0x09, 0x0A,
/* 0000DB80 */ 0x00, 0x07, 0x03, 0x00, 0x5C, 0x00, 0x0A, 0x5C, 0x01, 0x05, 0xE0, 0x0B, 0x00, 0x5C, 0x02, 0x0B,
/* 0000DB90 */ 0xF2, 0x03, 0x09, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x47, 0x06, 0x09, 0x98, 0x09, 0x06,
/* 0000DBA0 */ 0x02, 0x00, 0x00, 0x47, 0x07, 0x09, 0x8F, 0x02, 0x0C, 0x09, 0x01, 0x00, 0x07, 0x04, 0x00, 0x5C,
/* 0000DBB0 */ 0x00, 0x03, 0x8F, 0x02, 0x1D, 0x0A, 0x02, 0x00, 0x5C, 0x01, 0x0A, 0x8F, 0x01, 0x04, 0x0A, 0x03,
/* 0000DBC0 */ 0x00, 0x5C, 0x02, 0x0A, 0x5C, 0x03, 0x07, 0xEE, 0x04, 0x09, 0x09, 0x01, 0x00, 0x15, 0x03, 0x00,
/* 0000DBD0 */ 0x09, 0x04, 0x09, 0x27, 0x00, 0x8F, 0x02, 0x0C, 0x09, 0x01, 0x00, 0x07, 0x04, 0x00, 0x5C, 0x00,
/* 0000DBE0 */ 0x03, 0x8F, 0x02, 0x1E, 0x0A, 0x04, 0x00, 0x5C, 0x01, 0x0A, 0x8F, 0x01, 0x02, 0x0A, 0x05, 0x00,
/* 0000DBF0 */ 0x5C, 0x02, 0x0A, 0x5C, 0x03, 0x05, 0xEE, 0x04, 0xFF, 0x09, 0x02, 0x00, 0xA8, 0x00, 0x24, 0x00,
/* 0000DC00 */ 0xFE, 0x37, 0x02, 0x0E, 0xFE, 0x4E, 0x03, 0x00, 0xFE, 0x4A, 0x29, 0x05, 0x00, 0x00, 0x00, 0x00,
/* 0000DC10 */ 0x26, 0x00, 0x7B, 0x00, 0x09, 0x00, 0x25, 0x00, 0x2F, 0x00, 0x60, 0x00, 0x29, 0x00, 0x57, 0x00,
/* 0000DC20 */ 0x00, 0xBF, 0x5C, 0x84, 0x00, 0x00, 0xC4, 0x00, 0xE5, 0x3C, 0xA2, 0x41, 0xD1, 0x00, 0x0E, 0xFE,
/* 0000DC30 */ 0xD5, 0x25, 0xFF, 0x00, 0x10, 0x01, 0x00, 0x02, 0x02, 0xFE, 0xD5, 0x25, 0x7F, 0x7F, 0x41, 0x04,
/* 0000DC40 */ 0x05, 0x07, 0x06, 0x0F, 0x0F, 0x02, 0x01, 0x03, 0x06, 0x06, 0xFE, 0x45, 0x03, 0x06, 0xFE, 0xF6,
/* 0000DC50 */ 0x02, 0x08, 0x38, 0x8F, 0x02, 0x0C, 0x07, 0x00, 0x00, 0x07, 0x05, 0x00, 0x5C, 0x00, 0x04, 0x8F,
/* 0000DC60 */ 0x02, 0x23, 0x08, 0x01, 0x00, 0x5C, 0x01, 0x08, 0x8F, 0x01, 0x03, 0x08, 0x02, 0x00, 0x5C, 0x02,
/* 0000DC70 */ 0x08, 0x2F, 0x08, 0x02, 0x05, 0x5C, 0x03, 0x08, 0x5D, 0x04, 0x03, 0x00, 0x00, 0xEE, 0x05, 0x07,
/* 0000DC80 */ 0x07, 0x00, 0x00, 0x94, 0x01, 0x03, 0x07, 0xA8, 0x00, 0x24, 0x00, 0xFE, 0xFA, 0x25, 0x02, 0x00,
/* 0000DC90 */ 0x00, 0x00, 0x00, 0x36, 0x00, 0x59, 0x00, 0x00, 0x3F, 0x5C, 0x85, 0xE0, 0x01, 0xC4, 0x02, 0xC4,
/* 0000DCA0 */ 0x1E, 0xA2, 0x41, 0xC1, 0x00, 0xFE, 0x25, 0x03, 0x0B, 0xFE, 0x03, 0x20, 0x01, 0xFF, 0x00, 0x10,
/* 0000DCB0 */ 0x01, 0x00, 0x02, 0x02, 0xFE, 0x03, 0x20, 0xFE, 0x28, 0x04, 0xFE, 0x28, 0x04, 0x07, 0x05, 0x09,
/* 0000DCC0 */ 0x04, 0x2A, 0x29, 0x01, 0x01, 0x04, 0x03, 0x03, 0x03, 0x03, 0x03, 0x08, 0x08, 0x01, 0x00, 0x06,
/* 0000DCD0 */ 0xFE, 0x45, 0x03, 0xA2, 0x4F, 0x06, 0x4F, 0x07, 0x8F, 0x01, 0x42, 0x09, 0x00, 0x00, 0x4B, 0x09,
/* 0000DCE0 */ 0x0F, 0x15, 0x00, 0x09, 0x09, 0x00, 0x00, 0x8F, 0x01, 0x05, 0x09, 0x01, 0x00, 0x07, 0x01, 0x00,
/* 0000DCF0 */ 0x5C, 0x00, 0x02, 0xEE, 0x01, 0xFF, 0x09, 0x00, 0x00, 0x8F, 0x01, 0x09, 0x0A, 0x02, 0x00, 0x6D,
/* 0000DD00 */ 0x09, 0x0A, 0x00, 0x07, 0x03, 0x00, 0x5C, 0x00, 0x0A, 0x5C, 0x01, 0x05, 0x8F, 0x01, 0x42, 0x0B,
/* 0000DD10 */ 0x00, 0x00, 0x4B, 0x0B, 0x5C, 0x02, 0x0B, 0xF2, 0x03, 0x09, 0x09, 0x00, 0x00, 0x00, 0x00, 0x01,
/* 0000DD20 */ 0x00, 0x54, 0x06, 0x09, 0x0F, 0x08, 0x00, 0x06, 0x09, 0x00, 0x00, 0xA8, 0x00, 0x09, 0x44, 0x00,
/* 0000DD30 */ 0x98, 0x0B, 0x06, 0x03, 0x00, 0x00, 0x6D, 0x0A, 0x0B, 0x01, 0x07, 0x02, 0x00, 0x5C, 0x00, 0x0B,
/* 0000DD40 */ 0x5D, 0x01, 0x04, 0x02, 0x00, 0xF2, 0x02, 0x0A, 0x0A, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x6D,
/* 0000DD50 */ 0x09, 0x0A, 0x02, 0x07, 0x02, 0x00, 0x5C, 0x00, 0x0A, 0xD4, 0x00, 0x0B, 0x5C, 0x01, 0x0B, 0xF2,
/* 0000DD60 */ 0x02, 0x09, 0x09, 0x02, 0x00, 0x00, 0x00, 0x03, 0x00, 0x54, 0x07, 0x09, 0x47, 0x00, 0x07, 0x09,
/* 0000DD70 */ 0x02, 0x00, 0xA8, 0x00, 0x24, 0x00, 0xFE, 0x37, 0x02, 0xFE, 0x76, 0x01, 0xB0, 0xFE, 0x20, 0x20,
/* 0000DD80 */ 0x08, 0x04, 0x00, 0x00, 0x00, 0x0F, 0x00, 0x25, 0x00, 0x12, 0x00, 0x2E, 0x00, 0x2B, 0x00, 0x4C,
/* 0000DD90 */ 0x00, 0x07, 0x00, 0x1B, 0x00, 0x05, 0x00, 0x68, 0x02, 0x3C, 0x00, 0xD0, 0x00, 0x08, 0x00, 0x18,
/* 0000DDA0 */ 0x00, 0x00, 0xA6, 0xDD, 0x00, 0x00, 0xBF, 0x4C, 0x00, 0x00, 0x00, 0xC0, 0x01, 0xD7, 0x36, 0xA2,
/* 0000DDB0 */ 0x41, 0xD0, 0x00, 0x0C, 0xFE, 0x01, 0x10, 0xFE, 0x70, 0x23, 0xFF, 0x00, 0x10, 0x01, 0x00, 0x02,
/* 0000DDC0 */ 0x02, 0xFE, 0x70, 0x23, 0x0A, 0x0A, 0x01, 0x02, 0x02, 0x03, 0x0A, 0x0A, 0x01, 0x17, 0xAC, 0x03,
/* 0000DDD0 */ 0x0F, 0x02, 0x00, 0x02, 0xAB, 0x03, 0xAC, 0x00, 0x0F, 0x02, 0x00, 0x03, 0xAB, 0x00, 0x09, 0x02,
/* 0000DDE0 */ 0x00, 0xA8, 0x00, 0x24, 0x00, 0xFE, 0x77, 0x23, 0x02, 0x00, 0x00, 0x00, 0x00, 0x15, 0x00, 0x03,
/* 0000DDF0 */ 0x00, 0x00, 0xBF, 0x5C, 0x85, 0xE0, 0x21, 0xD4, 0x00, 0xAD, 0x1E, 0xA2, 0x41, 0xC1, 0x00, 0xFE,
/* 0000DE00 */ 0x46, 0x03, 0x0A, 0xFE, 0x59, 0x1B, 0xFF, 0x00, 0x10, 0x01, 0x00, 0x02, 0x02, 0xFE, 0x59, 0x1B,
/* 0000DE10 */ 0xFE, 0x88, 0x04, 0xFE, 0x88, 0x04, 0x01, 0x09, 0x09, 0x0D, 0x04, 0x58, 0x4C, 0x01, 0x05, 0x05,
/* 0000DE20 */ 0x04, 0x05, 0x05, 0x05, 0x05, 0x01, 0x0C, 0x0D, 0x07, 0x08, 0x01, 0x01, 0x01, 0x02, 0x06, 0xFE,
/* 0000DE30 */ 0x45, 0x03, 0x06, 0xFE, 0xF6, 0x02, 0x01, 0x03, 0xFE, 0x58, 0x01, 0x4F, 0x0A, 0x4F, 0x0B, 0x8F,
/* 0000DE40 */ 0x01, 0x09, 0x0F, 0x00, 0x00, 0x62, 0x0F, 0x0F, 0x00, 0x6D, 0x0E, 0x0F, 0x01, 0x07, 0x02, 0x00,
/* 0000DE50 */ 0x5C, 0x00, 0x0F, 0x5C, 0x01, 0x09, 0xF2, 0x02, 0x0E, 0x0E, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
/* 0000DE60 */ 0x47, 0x0A, 0x0E, 0xA8, 0x0E, 0x14, 0x03, 0x00, 0x0A, 0x0E, 0x09, 0x07, 0x01, 0x8F, 0x01, 0x09,
/* 0000DE70 */ 0x0F, 0x00, 0x00, 0x6D, 0x0E, 0x0F, 0x02, 0x07, 0x02, 0x00, 0x5C, 0x00, 0x0F, 0x5C, 0x01, 0x09,
/* 0000DE80 */ 0xF2, 0x02, 0x0E, 0x0E, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x47, 0x0A, 0x0E, 0x14, 0x03, 0x00,
/* 0000DE90 */ 0x0A, 0x02, 0x09, 0x9D, 0x00, 0x8F, 0x01, 0x41, 0x0E, 0x01, 0x00, 0x4B, 0x0E, 0x0F, 0x15, 0x00,
/* 0000DEA0 */ 0x0E, 0x09, 0x00, 0x00, 0x8F, 0x01, 0x05, 0x0E, 0x02, 0x00, 0x07, 0x01, 0x00, 0x5C, 0x00, 0x03,
/* 0000DEB0 */ 0xEE, 0x01, 0xFF, 0x0E, 0x02, 0x00, 0x8F, 0x01, 0x09, 0x0F, 0x00, 0x00, 0x6D, 0x0E, 0x0F, 0x03,
/* 0000DEC0 */ 0x07, 0x03, 0x00, 0x5C, 0x00, 0x0F, 0x5C, 0x01, 0x09, 0x8F, 0x01, 0x41, 0x10, 0x01, 0x00, 0x4B,
/* 0000DED0 */ 0x10, 0x5C, 0x02, 0x10, 0xF2, 0x03, 0x0E, 0x0E, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x47, 0x0B,
/* 0000DEE0 */ 0x0E, 0x98, 0x0E, 0x0B, 0x04, 0x00, 0x00, 0x98, 0x0F, 0x0B, 0x05, 0x01, 0x00, 0x0F, 0x03, 0x00,
/* 0000DEF0 */ 0x0F, 0x09, 0x10, 0x00, 0x98, 0x10, 0x0B, 0x05, 0x02, 0x00, 0x2F, 0x10, 0x06, 0x10, 0x47, 0x0F,
/* 0000DF00 */ 0x10, 0x09, 0x03, 0x00, 0x47, 0x0F, 0x07, 0x2F, 0x0E, 0x0E, 0x0F, 0x98, 0x0F, 0x0B, 0x08, 0x03,
/* 0000DF10 */ 0x00, 0x0F, 0x03, 0x00, 0x0F, 0x09, 0x10, 0x00, 0x98, 0x10, 0x0B, 0x08, 0x04, 0x00, 0x2F, 0x10,
/* 0000DF20 */ 0x06, 0x10, 0x47, 0x0F, 0x10, 0x09, 0x03, 0x00, 0x47, 0x0F, 0x07, 0x2F, 0x0E, 0x0E, 0x0F, 0x47,
/* 0000DF30 */ 0x0A, 0x0E, 0x8F, 0x01, 0x09, 0x0F, 0x00, 0x00, 0x62, 0x0F, 0x0F, 0x00, 0x6D, 0x0E, 0x0F, 0x04,
/* 0000DF40 */ 0x07, 0x03, 0x00, 0x5C, 0x00, 0x0F, 0x5C, 0x01, 0x09, 0xA8, 0x10, 0x14, 0x03, 0x00, 0x0A, 0x10,
/* 0000DF50 */ 0x09, 0x0E, 0x00, 0x8F, 0x01, 0x3A, 0x11, 0x03, 0x00, 0x4B, 0x11, 0x47, 0x10, 0x11, 0x09, 0x03,
/* 0000DF60 */ 0x00, 0x47, 0x10, 0x0A, 0x5C, 0x02, 0x10, 0xF2, 0x03, 0xFF, 0x0E, 0x04, 0x00, 0x00, 0x00, 0x04,
/* 0000DF70 */ 0x00, 0x09, 0x15, 0x00, 0x8F, 0x01, 0x3A, 0x0E, 0x03, 0x00, 0x4B, 0x0E, 0x14, 0x03, 0x00, 0x0A,
/* 0000DF80 */ 0x0E, 0x09, 0x05, 0x00, 0xA8, 0x0E, 0x47, 0x0A, 0x0E, 0x47, 0x00, 0x0A, 0x09, 0x02, 0x00, 0xA8,
/* 0000DF90 */ 0x00, 0x24, 0x00, 0xFE, 0x04, 0x03, 0xFE, 0xB5, 0x01, 0xFE, 0x29, 0x02, 0xFE, 0x37, 0x02, 0xFE,
/* 0000DFA0 */ 0xB8, 0x01, 0xFE, 0x84, 0x1B, 0x0D, 0x04, 0x00, 0x00, 0x00, 0x24, 0x00, 0x54, 0x00, 0x0A, 0x00,
/* 0000DFB0 */ 0x31, 0x00, 0x20, 0x00, 0x52, 0x00, 0x08, 0x00, 0x30, 0x00, 0x0F, 0x00, 0x2E, 0x00, 0x12, 0x00,
/* 0000DFC0 */ 0x3C, 0x00, 0x2B, 0x00, 0xB3, 0x00, 0x51, 0x00, 0x3A, 0x01, 0x42, 0x00, 0x81, 0x00, 0x10, 0x00,
/* 0000DFD0 */ 0x31, 0x00, 0x05, 0x00, 0x30, 0x00, 0x08, 0x00, 0x1C, 0x00, 0x00, 0xBF, 0x5C, 0x85, 0xE0, 0x21,
/* 0000DFE0 */ 0xD4, 0x00, 0x92, 0x1F, 0xA2, 0x41, 0xC1, 0x00, 0xFE, 0x44, 0x03, 0x09, 0xFE, 0x98, 0x16, 0xFF,
/* 0000DFF0 */ 0x00, 0x10, 0x01, 0x00, 0x03, 0x03, 0xFE, 0x98, 0x16, 0xFE, 0x9F, 0x04, 0xFE, 0x9F, 0x04, 0x01,
/* 0000E000 */ 0x0A, 0x09, 0x0E, 0x04, 0x61, 0x54, 0x01, 0x05, 0x05, 0x04, 0x05, 0x05, 0x05, 0x05, 0x01, 0x0D,
/* 0000E010 */ 0x0E, 0x07, 0x08, 0x01, 0x01, 0x01, 0x02, 0x06, 0xFE, 0x45, 0x03, 0x06, 0xFE, 0xF6, 0x02, 0x01,
/* 0000E020 */ 0x03, 0xFE, 0x77, 0x01, 0x4F, 0x0C, 0x8F, 0x01, 0x09, 0x10, 0x00, 0x00, 0x62, 0x10, 0x10, 0x00,
/* 0000E030 */ 0x6D, 0x0F, 0x10, 0x01, 0x07, 0x02, 0x00, 0x5C, 0x00, 0x10, 0x5C, 0x01, 0x09, 0xF2, 0x02, 0x0F,
/* 0000E040 */ 0x0F, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x47, 0x0B, 0x0F, 0xA8, 0x0F, 0x14, 0x03, 0x00, 0x0B,
/* 0000E050 */ 0x0F, 0x09, 0x07, 0x01, 0x8F, 0x01, 0x09, 0x10, 0x00, 0x00, 0x6D, 0x0F, 0x10, 0x02, 0x07, 0x02,
/* 0000E060 */ 0x00, 0x5C, 0x00, 0x10, 0x5C, 0x01, 0x09, 0xF2, 0x02, 0x0F, 0x0F, 0x02, 0x00, 0x00, 0x00, 0x01,
/* 0000E070 */ 0x00, 0x47, 0x0B, 0x0F, 0x14, 0x03, 0x00, 0x0B, 0x02, 0x09, 0x9D, 0x00, 0x8F, 0x01, 0x41, 0x0F,
/* 0000E080 */ 0x01, 0x00, 0x4B, 0x0F, 0x0F, 0x15, 0x00, 0x0F, 0x09, 0x00, 0x00, 0x8F, 0x01, 0x05, 0x0F, 0x02,
/* 0000E090 */ 0x00, 0x07, 0x01, 0x00, 0x5C, 0x00, 0x03, 0xEE, 0x01, 0xFF, 0x0F, 0x02, 0x00, 0x8F, 0x01, 0x09,
/* 0000E0A0 */ 0x10, 0x00, 0x00, 0x6D, 0x0F, 0x10, 0x03, 0x07, 0x03, 0x00, 0x5C, 0x00, 0x10, 0x5C, 0x01, 0x09,
/* 0000E0B0 */ 0x8F, 0x01, 0x41, 0x11, 0x01, 0x00, 0x4B, 0x11, 0x5C, 0x02, 0x11, 0xF2, 0x03, 0x0F, 0x0F, 0x03,
/* 0000E0C0 */ 0x00, 0x00, 0x00, 0x03, 0x00, 0x47, 0x0C, 0x0F, 0x98, 0x0F, 0x0C, 0x04, 0x00, 0x00, 0x98, 0x10,
/* 0000E0D0 */ 0x0C, 0x05, 0x01, 0x00, 0x0F, 0x03, 0x00, 0x10, 0x09, 0x10, 0x00, 0x98, 0x11, 0x0C, 0x05, 0x02,
/* 0000E0E0 */ 0x00, 0x2F, 0x11, 0x06, 0x11, 0x47, 0x10, 0x11, 0x09, 0x03, 0x00, 0x47, 0x10, 0x07, 0x2F, 0x0F,
/* 0000E0F0 */ 0x0F, 0x10, 0x98, 0x10, 0x0C, 0x08, 0x03, 0x00, 0x0F, 0x03, 0x00, 0x10, 0x09, 0x10, 0x00, 0x98,
/* 0000E100 */ 0x11, 0x0C, 0x08, 0x04, 0x00, 0x2F, 0x11, 0x06, 0x11, 0x47, 0x10, 0x11, 0x09, 0x03, 0x00, 0x47,
/* 0000E110 */ 0x10, 0x07, 0x2F, 0x0F, 0x0F, 0x10, 0x47, 0x0B, 0x0F, 0x8F, 0x01, 0x09, 0x10, 0x00, 0x00, 0x62,
/* 0000E120 */ 0x10, 0x10, 0x00, 0x6D, 0x0F, 0x10, 0x04, 0x07, 0x03, 0x00, 0x5C, 0x00, 0x10, 0x5C, 0x01, 0x09,
/* 0000E130 */ 0xA8, 0x11, 0x14, 0x03, 0x00, 0x0B, 0x11, 0x09, 0x0E, 0x00, 0x8F, 0x01, 0x3A, 0x12, 0x03, 0x00,
/* 0000E140 */ 0x4B, 0x12, 0x47, 0x11, 0x12, 0x09, 0x03, 0x00, 0x47, 0x11, 0x0B, 0x5C, 0x02, 0x11, 0xF2, 0x03,
/* 0000E150 */ 0xFF, 0x0F, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x09, 0x15, 0x00, 0x8F, 0x01, 0x3A, 0x0F, 0x03,
/* 0000E160 */ 0x00, 0x4B, 0x0F, 0x14, 0x03, 0x00, 0x0B, 0x0F, 0x09, 0x05, 0x00, 0xA8, 0x0F, 0x47, 0x0B, 0x0F,
/* 0000E170 */ 0x14, 0x03, 0x00, 0x0A, 0x09, 0x09, 0x09, 0x00, 0x47, 0x00, 0x0B, 0x09, 0x1B, 0x00, 0x09, 0x16,
/* 0000E180 */ 0x00, 0x14, 0x03, 0x00, 0x0A, 0x0B, 0x09, 0x08, 0x00, 0xA8, 0x00, 0x09, 0x0B, 0x00, 0x09, 0x06,
/* 0000E190 */ 0x00, 0x47, 0x00, 0x0B, 0x09, 0x02, 0x00, 0xA8, 0x00, 0x24, 0x00, 0xFE, 0x05, 0x03, 0xFE, 0xB5,
/* 0000E1A0 */ 0x01, 0xFE, 0x2A, 0x02, 0xFE, 0x37, 0x02, 0xFE, 0xB8, 0x01, 0xFE, 0xC4, 0x16, 0x11, 0x02, 0x00,
/* 0000E1B0 */ 0x00, 0x00, 0x24, 0x00, 0x47, 0x00, 0x0A, 0x00, 0x31, 0x00, 0x20, 0x00, 0x45, 0x00, 0x08, 0x00,
/* 0000E1C0 */ 0x30, 0x00, 0x0F, 0x00, 0x2E, 0x00, 0x12, 0x00, 0x3C, 0x00, 0x2B, 0x00, 0x53, 0x00, 0x51, 0x00,
/* 0000E1D0 */ 0x10, 0x01, 0x42, 0x00, 0x74, 0x00, 0x10, 0x00, 0x31, 0x00, 0x05, 0x00, 0x32, 0x00, 0x08, 0x00,
/* 0000E1E0 */ 0x2D, 0x00, 0x09, 0x00, 0x27, 0x00, 0x08, 0x00, 0x35, 0x00, 0x08, 0x00, 0x31, 0x00, 0x08, 0x00,
/* 0000E1F0 */ 0x27, 0x00, 0x00, 0xBF, 0x5C, 0x84, 0xE0, 0x01, 0xC4, 0x00, 0x8E, 0x1C, 0xA2, 0x41, 0xC1, 0x00,
/* 0000E200 */ 0xFE, 0x24, 0x03, 0x08, 0xFE, 0x21, 0x16, 0xFF, 0x00, 0x10, 0x01, 0x00, 0x03, 0x03, 0xFE, 0x21,
/* 0000E210 */ 0x16, 0x53, 0x53, 0x01, 0x05, 0x02, 0x05, 0x04, 0x0B, 0x0B, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
/* 0000E220 */ 0x01, 0x04, 0x27, 0x8F, 0x01, 0x09, 0x06, 0x00, 0x00, 0x6D, 0x05, 0x06, 0x00, 0x07, 0x03, 0x00,
/* 0000E230 */ 0x5C, 0x00, 0x06, 0x5C, 0x01, 0x03, 0x5C, 0x02, 0x02, 0xF2, 0x03, 0x00, 0x05, 0x00, 0x00, 0x00,
/* 0000E240 */ 0x00, 0x00, 0x00, 0x09, 0x02, 0x00, 0xA8, 0x00, 0x24, 0x00, 0xFE, 0xA5, 0x02, 0xFE, 0x3F, 0x16,
/* 0000E250 */ 0x02, 0x00, 0x00, 0x00, 0x00, 0x25, 0x00, 0x34, 0x00, 0x00, 0xBF, 0x4C, 0x00, 0xE0, 0x01, 0xC0,
/* 0000E260 */ 0x00, 0x88, 0x1C, 0xA2, 0x41, 0xC1, 0x00, 0xFE, 0x23, 0x03, 0x07, 0xFE, 0x81, 0x15, 0xFF, 0x00,
/* 0000E270 */ 0x10, 0x01, 0x00, 0x02, 0x02, 0xFE, 0x81, 0x15, 0x7F, 0x7F, 0x41, 0x02, 0x04, 0x05, 0x0A, 0x0A,
/* 0000E280 */ 0x01, 0x01, 0x01, 0x01, 0x01, 0x03, 0x1C, 0x00, 0x0A, 0x80, 0x03, 0x07, 0x00, 0x0A, 0x80, 0x1E,
/* 0000E290 */ 0x62, 0x05, 0x04, 0x00, 0x14, 0x0F, 0x00, 0x05, 0x02, 0x09, 0x00, 0x00, 0x62, 0x05, 0x04, 0x00,
/* 0000E2A0 */ 0x14, 0x03, 0x00, 0x05, 0x03, 0x09, 0x02, 0x00, 0x23, 0x04, 0xA8, 0x00, 0x24, 0x00, 0xFE, 0x2F,
/* 0000E2B0 */ 0x01, 0xFE, 0x9A, 0x15, 0x03, 0x00, 0x00, 0x00, 0x00, 0x18, 0x00, 0x4B, 0x00, 0x04, 0x00, 0x1A,
/* 0000E2C0 */ 0x00, 0x00, 0xBF, 0x7C, 0x05, 0x01, 0x00, 0xC0, 0x04, 0x7D, 0x1B, 0xA2, 0x41, 0xC1, 0x00, 0xFE,
/* 0000E2D0 */ 0x22, 0x03, 0x06, 0xFE, 0x1D, 0x14, 0xFF, 0x00, 0x10, 0x01, 0x00, 0x04, 0x04, 0xFE, 0x1D, 0x14,
/* 0000E2E0 */ 0xDD, 0xDD, 0x41, 0x06, 0x05, 0x09, 0x03, 0x15, 0x13, 0x10, 0x01, 0x01, 0x01, 0x01, 0x05, 0x3C,
/* 0000E2F0 */ 0x01, 0x00, 0x08, 0x01, 0x01, 0x40, 0x4F, 0x08, 0x47, 0x08, 0x02, 0xEB, 0x00, 0xEC, 0x00, 0x12,
/* 0000E300 */ 0x03, 0x00, 0x08, 0x06, 0x09, 0x29, 0x00, 0xBA, 0x09, 0x08, 0x05, 0x0F, 0x03, 0x00, 0x09, 0x09,
/* 0000E310 */ 0x18, 0x00, 0x47, 0x09, 0x07, 0x07, 0x02, 0x00, 0x5C, 0x00, 0x03, 0x98, 0x0A, 0x05, 0x08, 0x00,
/* 0000E320 */ 0x00, 0x5C, 0x01, 0x0A, 0xEE, 0x02, 0xFF, 0x09, 0x00, 0x00, 0x28, 0x08, 0x08, 0x09, 0xCD, 0xFF,
/* 0000E330 */ 0xED, 0x00, 0xA8, 0x00, 0x24, 0x00, 0xFE, 0x45, 0x14, 0x06, 0x02, 0x00, 0x00, 0x00, 0x07, 0x00,
/* 0000E340 */ 0x21, 0x00, 0x08, 0x00, 0x21, 0x00, 0x0B, 0x00, 0x27, 0x00, 0x18, 0x00, 0x30, 0x00, 0x0A, 0x00,
/* 0000E350 */ 0x1B, 0x00, 0x00, 0xBF, 0x5C, 0x84, 0xE0, 0x21, 0xD4, 0x00, 0x70, 0x22, 0xA2, 0x41, 0xC1, 0x00,
/* 0000E360 */ 0xFE, 0x34, 0x03, 0x05, 0xFE, 0x87, 0x12, 0xFF, 0x00, 0x10, 0x01, 0x00, 0x02, 0x02, 0xFE, 0x87,
/* 0000E370 */ 0x12, 0xFE, 0x76, 0x01, 0xFE, 0x76, 0x01, 0x01, 0x08, 0x04, 0x08, 0x04, 0x2A, 0x27, 0x01, 0x03,
/* 0000E380 */ 0x03, 0x02, 0x02, 0x02, 0x02, 0x01, 0x07, 0x08, 0x07, 0x08, 0x98, 0x4F, 0x05, 0x4F, 0x06, 0x8F,
/* 0000E390 */ 0x01, 0x09, 0x0A, 0x00, 0x00, 0x6D, 0x09, 0x0A, 0x00, 0x07, 0x02, 0x00, 0x5C, 0x00, 0x0A, 0x5C,
/* 0000E3A0 */ 0x01, 0x04, 0xF2, 0x02, 0x09, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x47, 0x05, 0x09, 0x14,
/* 0000E3B0 */ 0x03, 0x00, 0x05, 0x02, 0x09, 0x62, 0x00, 0x8F, 0x01, 0x43, 0x09, 0x01, 0x00, 0x4B, 0x09, 0x0F,
/* 0000E3C0 */ 0x15, 0x00, 0x09, 0x09, 0x00, 0x00, 0x8F, 0x01, 0x05, 0x09, 0x02, 0x00, 0x07, 0x01, 0x00, 0x5C,
/* 0000E3D0 */ 0x00, 0x03, 0xEE, 0x01, 0xFF, 0x09, 0x01, 0x00, 0x8F, 0x01, 0x09, 0x0A, 0x00, 0x00, 0x6D, 0x09,
/* 0000E3E0 */ 0x0A, 0x01, 0x07, 0x03, 0x00, 0x5C, 0x00, 0x0A, 0x5C, 0x01, 0x04, 0x8F, 0x01, 0x43, 0x0B, 0x01,
/* 0000E3F0 */ 0x00, 0x4B, 0x0B, 0x5C, 0x02, 0x0B, 0xF2, 0x03, 0x09, 0x09, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00,
/* 0000E400 */ 0x47, 0x06, 0x09, 0xAC, 0x09, 0x0F, 0x02, 0x00, 0x06, 0xAB, 0x09, 0xAC, 0x00, 0x0F, 0x02, 0x00,
/* 0000E410 */ 0x09, 0xAB, 0x00, 0x09, 0x0B, 0x00, 0x09, 0x06, 0x00, 0x47, 0x00, 0x05, 0x09, 0x02, 0x00, 0xA8,
/* 0000E420 */ 0x00, 0x24, 0x00, 0xFE, 0x26, 0x02, 0xFE, 0x37, 0x02, 0xFE, 0xA5, 0x12, 0x08, 0x04, 0x00, 0x00,
/* 0000E430 */ 0x00, 0x20, 0x00, 0x41, 0x00, 0x08, 0x00, 0x24, 0x00, 0x0F, 0x00, 0x25, 0x00, 0x12, 0x00, 0x34,
/* 0000E440 */ 0x00, 0x2B, 0x00, 0x4B, 0x00, 0x16, 0x00, 0x2F, 0x00, 0x08, 0x00, 0x1F, 0x00, 0x00, 0xBF, 0x5C,
/* 0000E450 */ 0x8C, 0xE0, 0x01, 0xC4, 0x00, 0x63, 0x1F, 0xA2, 0x41, 0xC1, 0x00, 0xFE, 0x33, 0x03, 0x04, 0xFE,
/* 0000E460 */ 0x6B, 0x10, 0xFF, 0x00, 0x10, 0x01, 0x00, 0x03, 0x03, 0xFE, 0x6B, 0x10, 0xFE, 0xF5, 0x01, 0xFE,
/* 0000E470 */ 0xF5, 0x01, 0x41, 0x06, 0x05, 0x09, 0x04, 0x14, 0x12, 0x01, 0x01, 0x01, 0x01, 0x03, 0x03, 0x03,
/* 0000E480 */ 0x03, 0x08, 0x07, 0x06, 0xFE, 0xF6, 0x02, 0x05, 0xFE, 0x43, 0x03, 0x49, 0x4F, 0x07, 0x8F, 0x01,
/* 0000E490 */ 0x09, 0x0A, 0x00, 0x00, 0x6D, 0x09, 0x0A, 0x00, 0x07, 0x03, 0x00, 0x5C, 0x00, 0x0A, 0x5C, 0x01,
/* 0000E4A0 */ 0x05, 0x5C, 0x02, 0x06, 0xF2, 0x03, 0x09, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x47, 0x07,
/* 0000E4B0 */ 0x09, 0x14, 0x03, 0x00, 0x07, 0x02, 0x09, 0x18, 0x00, 0x77, 0x03, 0x05, 0x01, 0x47, 0x09, 0x05,
/* 0000E4C0 */ 0xCE, 0x0A, 0x02, 0x00, 0x00, 0xA1, 0x00, 0x04, 0x0A, 0xA1, 0x01, 0x03, 0x0A, 0x77, 0x0A, 0x09,
/* 0000E4D0 */ 0x02, 0xA8, 0x00, 0x24, 0x00, 0xFE, 0x2F, 0x02, 0xFE, 0x12, 0x02, 0xFE, 0x25, 0x02, 0xFE, 0x9B,
/* 0000E4E0 */ 0x10, 0x05, 0x02, 0x00, 0x00, 0x00, 0x23, 0x00, 0x50, 0x00, 0x08, 0x00, 0x73, 0x00, 0x04, 0x00,
/* 0000E4F0 */ 0x34, 0x00, 0x16, 0x00, 0xCD, 0x00, 0x00, 0xBF, 0x5C, 0x84, 0xE0, 0x01, 0xC4, 0x00, 0x52, 0x1D,
/* 0000E500 */ 0xA0, 0x41, 0xC1, 0x00, 0xFE, 0x32, 0x03, 0x03, 0xFE, 0x6F, 0x0E, 0xFF, 0x00, 0x10, 0x01, 0x00,
/* 0000E510 */ 0x01, 0x01, 0xFE, 0x6F, 0x0E, 0xFE, 0xD8, 0x01, 0xFE, 0xD8, 0x01, 0x01, 0x04, 0x03, 0x05, 0x02,
/* 0000E520 */ 0x1D, 0x1D, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, 0x02, 0x04, 0x05, 0xFE, 0x42, 0x03, 0x6F, 0x4F,
/* 0000E530 */ 0x03, 0x8F, 0x01, 0x3B, 0x05, 0x00, 0x00, 0x4B, 0x05, 0x0F, 0x03, 0x00, 0x05, 0x09, 0x1C, 0x00,
/* 0000E540 */ 0x8F, 0x01, 0x09, 0x05, 0x01, 0x00, 0x62, 0x05, 0x05, 0x00, 0x0F, 0x03, 0x00, 0x05, 0x09, 0x0B,
/* 0000E550 */ 0x00, 0x8F, 0x01, 0x3B, 0x00, 0x00, 0x00, 0x4B, 0x00, 0x09, 0x40, 0x00, 0x8F, 0x01, 0x09, 0x06,
/* 0000E560 */ 0x01, 0x00, 0x6D, 0x05, 0x06, 0x01, 0x07, 0x01, 0x00, 0x5C, 0x00, 0x06, 0xF2, 0x01, 0x05, 0x05,
/* 0000E570 */ 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x54, 0x03, 0x05, 0x0F, 0x0C, 0x00, 0x03, 0x09, 0x00, 0x00,
/* 0000E580 */ 0x01, 0x32, 0x01, 0x01, 0x3B, 0x02, 0x09, 0x06, 0x00, 0x01, 0x32, 0x01, 0x01, 0x3B, 0x03, 0x8F,
/* 0000E590 */ 0x01, 0x3B, 0x00, 0x00, 0x00, 0x4B, 0x00, 0x09, 0x02, 0x00, 0xA8, 0x00, 0x24, 0x00, 0xFE, 0x03,
/* 0000E5A0 */ 0x03, 0xFE, 0x2B, 0x02, 0xFE, 0x86, 0x0E, 0x08, 0x02, 0x00, 0x00, 0x00, 0x20, 0x00, 0x3A, 0x00,
/* 0000E5B0 */ 0x0B, 0x00, 0x2E, 0x00, 0x1D, 0x00, 0x35, 0x00, 0x07, 0x00, 0x9F, 0x00, 0x09, 0x00, 0x37, 0x00,
/* 0000E5C0 */ 0x06, 0x00, 0x30, 0x00, 0x0D, 0x00, 0x1D, 0x00, 0x00, 0xBF, 0x5C, 0x84, 0x00, 0x00, 0xC4, 0x00,
/* 0000E5D0 */ 0x3B, 0x1F, 0xA2, 0x41, 0xC1, 0x00, 0xFE, 0x17, 0x03, 0x02, 0xFE, 0x04, 0x0A, 0xFF, 0x00, 0x10,
/* 0000E5E0 */ 0x01, 0x00, 0x04, 0x04, 0xFE, 0x04, 0x0A, 0x74, 0x74, 0x41, 0x06, 0x04, 0x08, 0x09, 0x10, 0x10,
/* 0000E5F0 */ 0x01, 0x02, 0x02, 0x07, 0x07, 0x08, 0x39, 0x8F, 0x01, 0x1A, 0x08, 0x00, 0x00, 0x07, 0x04, 0x00,
/* 0000E600 */ 0x5C, 0x00, 0x03, 0x5C, 0x01, 0x04, 0x5C, 0x02, 0x05, 0x8F, 0x01, 0x0A, 0x09, 0x01, 0x00, 0x07,
/* 0000E610 */ 0x03, 0x00, 0x5C, 0x00, 0x03, 0x5C, 0x01, 0x06, 0x5D, 0x02, 0x02, 0x01, 0x00, 0xEE, 0x03, 0x09,
/* 0000E620 */ 0x09, 0x01, 0x00, 0x5C, 0x03, 0x09, 0xEE, 0x04, 0xFF, 0x08, 0x00, 0x00, 0xA8, 0x00, 0x24, 0x00,
/* 0000E630 */ 0xFE, 0x30, 0x0A, 0x02, 0x00, 0x00, 0x00, 0x00, 0x37, 0x00, 0x47, 0x00, 0x00};
}
|
#include <iostream>
#include <algorithm>
#include <cstdio>
#include <cstdlib>
#include <ctime>
#include <memory.h>
#include <cmath>
#include <string>
#include <cstring>
#include <queue>
#include <vector>
#include <set>
#include <deque>
#include <map>
#include <functional>
#include <numeric>
#include <sstream>
#include <complex>
typedef long double LD;
typedef long long ll;
typedef unsigned long long ULL;
typedef unsigned int uint;
#define PI 3.1415926535897932384626433832795
#define sqr(x) ((x)*(x))
using namespace std;
const int N = 111111;
struct cell {
int l, r, mx, cnt;
} a[4*N];
int b[N], pos[N];
void relax(int x) {
a[x].mx = max(a[x + x].mx, a[x + x + 1].mx);
a[x].cnt = 0;
if (a[x].mx == a[x + x].mx) a[x].cnt += a[x + x].cnt;
if (a[x].mx == a[x + x + 1].mx) a[x].cnt += a[x + x + 1].cnt;
}
void build(int x, int l, int r) {
a[x].l = l; a[x].r = r;
if (l < r) {
build(x + x, l, (l + r) / 2);
build(x + x + 1, ((l + r) / 2) + 1, r);
relax(x);
} else {
a[x].mx = b[l];
a[x].cnt = 1;
pos[l] = x;
}
}
void modify(int x, int val) {
x = pos[x];
a[x].mx += val;
x /= 2;
while (x) {
relax(x);
x /= 2;
}
}
inline ll calc() {
return ll(a[1].mx) * a[1].cnt;
}
int main() {
//freopen(".in", "r", stdin);
//freopen(".out", "w", stdout);
int n;
scanf("%d", &n);
for (int i = 0; i < n; ++i) scanf("%d", b + i);
build(1, 0, n - 1);
ll ans = calc();
for (int i = 0; i < n; ++i) {
if (!b[i]) continue;
modify(i, -1);
if (i) {
modify(i - 1, 1);
ans = min(ans, calc());
modify(i - 1, -1);
}
if (i + 1 < n) {
modify(i + 1, 1);
ans = min(ans, calc());
modify(i + 1, -1);
}
modify(i, 1);
}
cout << ans << endl;
return 0;
}
|
/**
* @author Felix Stegmaier
*/
#ifndef DEBUG_H
#define DEBUG_H
#define ENABLE_DEBUG
#ifdef ENABLE_DEBUG
#include <iostream>
#define DEBUG(x) std::cerr << "DEBUG: " << x << std::endl;
#else
#define DEBUG(x)
#endif
#endif
|
#define F_CPU 3200000
#include <stdio.h>
#include <avr/io.h>
#include <avr/interrupt.h>
#include <util/delay.h>
#include "USART_Debug.h"
#include "USART.h"
#include "TWI.h"
#define HT16K33_BLINK_CMD 0x80
#define HT16K33_BLINK_DISPLAYON 0x01
#define HT16K33_BLINK_OFF 0
#define HT16K33_BLINK_2HZ 1
#define HT16K33_BLINK_1HZ 2
#define HT16K33_BLINK_HALFHZ 3
#define HT16K33_CMD_BRIGHTNESS 0xE0
void initClocks(){
// Use internal oscillator (22MHz)
OSC.CTRL |= OSC_RC32MEN_bm;
// Wait for internal oscillator to stabilise
while ((OSC.STATUS & OSC_RC32MRDY_bm) == 0);
// disable register for clock control
CCP = CCP_IOREG_gc;
// set clock to 32MHz
CLK.CTRL = CLK_SCLKSEL_RC32M_gc;
// disable default 2MHz internal osc.
OSC.CTRL &= (~OSC_RC2MEN_bm);
//enable 32khz calibrated internal osc
OSC.CTRL |= OSC_RC32KEN_bm;
while (!(OSC.STATUS & OSC_RC32KRDY_bm));
// set bit to 0 to indicate we use the internal 32kHz
// callibrated osc as auto-calibration source for
// our 32MHz osc
OSC.DFLLCTRL &= ~OSC_RC32MCREF0_bm;
//enable auto-calibration for the 32MHz osc
DFLLRC32M.CTRL |= DFLL_ENABLE_bm;
}
void initClocks2(){
OSC.CTRL |= OSC_RC32MEN_bm | OSC_RC32KEN_bm; /* Enable the internal 32MHz & 32KHz oscillators */
while(!(OSC.STATUS & OSC_RC32KRDY_bm)); /* Wait for 32Khz oscillator to stabilize */
while(!(OSC.STATUS & OSC_RC32MRDY_bm)); /* Wait for 32MHz oscillator to stabilize */
DFLLRC32M.CTRL = DFLL_ENABLE_bm ; /* Enable DFLL - defaults to calibrate against internal 32Khz clock */
CCP = CCP_IOREG_gc; /* Disable register security for clock update */
CLK.CTRL = CLK_SCLKSEL_RC32M_gc; /* Switch to 32MHz clock */
OSC.CTRL &= ~OSC_RC2MEN_bm; /* Disable 2Mhz oscillator */
}
void restartInterrupts(){
cli();
PMIC.CTRL |= PMIC_HILVLEN_bm | PMIC_LOLVLEN_bm | PMIC_MEDLVLEN_bm;
sei();
}
int main(){
initClocks2();
restartInterrupts();
_delay_ms(100);
PORTE.DIR = 0xff;
PORTE.OUT = 0x01;
_delay_ms(100);
PORTE.OUT = 0x00;
_delay_ms(100);
PORTE.OUT = 0x01;
_delay_ms(100);
PORTE.OUT = 0x00;
_delay_ms(100);
for(int i = 0; i < 10; i++){
PORTE.OUTTGL = 0x01;
_delay_ms(10);
}
for(int i = 0; i < 10; i++){
PORTE.OUTTGL = 0x02;
_delay_ms(10);
}
USART_Data uc0 = {};
USART_Data uc1 = {};
uc0.port = &PORTC;
uc0.usart_port = &USARTC0;
uc0.txPin = PIN3_bm;
uc0.rxPin = PIN2_bm;
uc0.baudRate = 9600;
uc1.port = &PORTC;
uc1.usart_port = &USARTC1;
uc1.txPin = PIN7_bm;
uc1.rxPin = PIN6_bm;
uc1.baudRate = 9600;
USART C0 = USART(&uc0, false);
USART C1 = USART(&uc1, false);
setDebugOutputPort(&USARTC0);
TWI_Data rtcData = {};
rtcData.baud_hz = 400000L;
rtcData.master_addr = 0x00;
rtcData.maxDataLength = 64;
rtcData.port = 0x00;
rtcData.twi_port = &TWIE;
TWI leds = TWI(&rtcData);
char leds_addr = 0x70;
_delay_ms(10);
//char tmp[80];
printf("Hello world\n");
printf("Polling I2C bus...");
register8_t * i2cAddresses;
i2cAddresses = leds.pollBus();
char i2c_data[64];//
// = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
for(int i = 0; i < 64; i++){
i2c_data[i] = (char)i;
}
//rtc.writeData(0x70, i2c_data, 64);
printf("Done.\n");
printf("LEDs might work, who knows..\n");
for(int i = 0; i < 127; i++){
if (i == 127){
printf("%x\n", i2cAddresses[i]);
}
if (i % 25 == 0){
printf("\n");
}
printf("%x, ", i2cAddresses[i]);
}
printf("Turning on led matrix osc.\n");
// turn on oscillator
leds.beginWrite(leds_addr);
printf("Write begun..");
leds.putChar(0x21);
printf("Wrote a char");
leds.endTransmission();
printf("Setting led matrix blink rate\n");
// set blink rate
leds.beginWrite(leds_addr);
leds.putChar(HT16K33_BLINK_CMD | HT16K33_BLINK_DISPLAYON | (HT16K33_BLINK_OFF << 1));
leds.endTransmission();
// set brightness (15 - max)
leds.beginWrite(leds_addr);
leds.putChar(HT16K33_CMD_BRIGHTNESS | 15);
leds.endTransmission();
uint8_t counter = 0;
uint16_t displaybuffer[8];
printf("LED init finished?\n");
while(true){
for (uint8_t i=0; i<8; i++) {
// draw a diagonal row of pixels
displaybuffer[i] = 1 << ((counter+i) % 16) | 1 << ((counter+i+8) % 16) ;
//printf("%d\n", displaybuffer[i]);
}
//test write
leds.beginWrite(leds_addr);
leds.putChar((uint8_t) 0x00);
for(uint8_t i=0; i < 8; i++){
leds.putChar(displaybuffer[i] & 0xFF);
leds.putChar(displaybuffer[i] >> 8);
}
leds.endTransmission();
counter++;
if (counter >= 16) counter = 0;
_delay_ms(1000);
}
leds.end();
return 0;
}
|
// Created on: 1993-05-27
// Created by: Yves FRICAUD
// Copyright (c) 1993-1999 Matra Datavision
// Copyright (c) 1999-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#ifndef _MAT_Zone_HeaderFile
#define _MAT_Zone_HeaderFile
#include <Standard.hxx>
#include <Standard_Type.hxx>
#include <MAT_SequenceOfArc.hxx>
#include <Standard_Transient.hxx>
#include <Standard_Integer.hxx>
#include <MAT_Side.hxx>
class MAT_BasicElt;
class MAT_Arc;
class MAT_Node;
class MAT_Zone;
DEFINE_STANDARD_HANDLE(MAT_Zone, Standard_Transient)
//! Definition of Zone of Proximity of a BasicElt :
//! ----------------------------------------------
//! A Zone of proximity is the set of the points which are
//! more near from the BasicElt than any other.
class MAT_Zone : public Standard_Transient
{
public:
Standard_EXPORT MAT_Zone();
//! Compute the frontier of the Zone of proximity.
Standard_EXPORT MAT_Zone(const Handle(MAT_BasicElt)& aBasicElt);
//! Compute the frontier of the Zone of proximity.
Standard_EXPORT void Perform (const Handle(MAT_BasicElt)& aBasicElt);
//! Return the number Of Arcs On the frontier of <me>.
Standard_EXPORT Standard_Integer NumberOfArcs() const;
//! Return the Arc number <Index> on the frontier.
//! of <me>.
Standard_EXPORT Handle(MAT_Arc) ArcOnFrontier (const Standard_Integer Index) const;
//! Return TRUE if <me> is not empty .
Standard_EXPORT Standard_Boolean NoEmptyZone() const;
//! Return TRUE if <me> is Limited.
Standard_EXPORT Standard_Boolean Limited() const;
DEFINE_STANDARD_RTTIEXT(MAT_Zone,Standard_Transient)
protected:
private:
Standard_EXPORT Handle(MAT_Node) NodeForTurn (const Handle(MAT_Arc)& anArc, const Handle(MAT_BasicElt)& aBasicElt, const MAT_Side aSide) const;
MAT_SequenceOfArc frontier;
Standard_Boolean limited;
};
#endif // _MAT_Zone_HeaderFile
|
//
// Created by 钟奇龙 on 2019-04-15.
//
#include <iostream>
using namespace std;
class Node{
public:
int data;
Node *next;
Node(int x):data(x),next(NULL){
}
};
Node* reverseList(Node *head){
Node *pre = NULL;
while(head){
Node *next = head->next;
head->next = pre;
pre = head;
head = next;
}
return pre;
}
Node* addList(Node *head1,Node *head2){
head1 = reverseList(head1);
head2 = reverseList(head2);
Node *p1 = head1;
Node *p2 = head2;
//头插法建立
int n1 = 0;
int n2 = 0;
int carry = 0;
Node *pre = NULL;
while(p1 || p2){
n1 = p1 ? p1->data : 0;
n2 = p2 ? p2->data : 0;
int current_num = n1 + n2 + carry;
Node *new_node = new Node(current_num%10);
new_node->next = pre;
pre = new_node;
carry = current_num / 10;
p1 = p1 ? p1->next : NULL;
p2 = p2 ? p2->next : NULL;
}
if(carry){
Node *new_node = new Node(1);
new_node->next = pre;
pre = new_node;
}
reverseList(head1);
reverseList(head2);
return pre;
}
int main(){
Node *node1 = new Node(9);
Node *node2 = new Node(3);
Node *node3 = new Node(7);
Node *node4 = new Node(6);
Node *node5 = new Node(3);
node1->next = node2;
node2->next = node3;
node4->next = node5;
Node *result = addList(node1,node4);
return 0;
}
|
//
// Created by griha on 10.12.17.
//
#pragma once
#ifndef MIKRONSST_HSM_IO_MANIP_HPP
#define MIKRONSST_HSM_IO_MANIP_HPP
#include <iostream>
#include <iomanip>
#include <windows.h>
#include <crypto/cipher.hpp>
namespace griha { namespace hsm {
struct _GLE {
DWORD last_error;
};
inline _GLE
get_last_error(DWORD last_error = ::GetLastError()) {
return { last_error};
}
//inline _GLE
//get_last_error() {
// return { .last_error = ::GetLastError()};
//}
template<typename _CharT, typename _Traits>
inline std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os, _GLE __gle) {
auto fmt_flags = __os.flags();
__os << '(' << std::showbase << std::hex << std::setfill(__os.widen('0')) << std::setw(8) << __gle.last_error << ')';
__os.flags(fmt_flags);
return __os;
}
template<typename _CharT, typename _Traits>
inline std::basic_ostream<_CharT, _Traits>&
last_error(std::basic_ostream<_CharT, _Traits>& __os) {
return __os << _GLE{::GetLastError()};
}
template<typename _CharT, typename _Traits>
std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os, CipherMode mode) {
switch (mode) {
case CipherMode::ECB: __os << "ecb"; break;
case CipherMode::CBC: __os << "cbc"; break;
case CipherMode::CFB: __os << "cfb"; break;
case CipherMode::OFB: __os << "ofb"; break;
case CipherMode::CTS: __os << "cts"; break;
}
}
template<typename _CharT, typename _Traits>
std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is, CipherMode mode) {
std::basic_string<_CharT, _Traits> str;
__is >> str;
if (str.compare("ecb") == 0) mode = CipherMode::ECB;
else if (str.compare("cbc") == 0) mode = CipherMode::CBC;
else if (str.compare("cfb") == 0) mode = CipherMode::CFB;
else if (str.compare("ofb") == 0) mode = CipherMode::OFB;
else if (str.compare("cts") == 0) mode = CipherMode::CTS;
else throw std::bad_cast();
}
template<typename _CharT, typename _Traits>
std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os, Padding mode) {
switch (mode) {
case Padding::Pkcs5: __os << "pkcs5"; break;
case Padding::Random: __os << "rand"; break;
case Padding::Zero: __os << "zero"; break;
}
}
template<typename _CharT, typename _Traits>
std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is, Padding mode) {
std::basic_string<_CharT, _Traits> str;
__is >> str;
if (str.compare("pkcs5") == 0) mode = Padding::Pkcs5;
else if (str.compare("rand") == 0) mode = Padding::Random;
else if (str.compare("zero") == 0) mode = Padding::Zero;
else throw std::bad_cast();
}
}} // namespace griha::hsm
#endif //MIKRONSST_HSM_IO_MANIP_HPP
|
// 톱니바퀴
#include <iostream>
#include <vector>
#include <queue>
using namespace std;
struct location {
int x, y;
};
queue<location> q;
int r_wheel[10][100] = { 0 };
int wheel[10][10];
location list[110];
int check[4] = { 1,1,1,1 };
int K;
void rotate(int n);
void BFS(int n);
int main() {
char temp[5][10];
for (int i = 0; i < 4; i++) {
cin >> temp[i];
}
for (int i = 0; i < 4; i++) {
for (int j = 0; j < 8; j++) {
wheel[i][j] = (temp[i][j] - '0'); // 연속된 숫자 입력
}
}
cin >> K;
for (int i = 0; i < K; i++) {
int wheel_num, direction;
cin >> wheel_num >> direction;
list[i] = { wheel_num, direction };
}
for (int i = 0; i < K; i++) {
q.push({ list[i].x, list[i].y }); // 초기값 큐에 삽입
BFS(i); // 초기값으로 인해 돌아가는 톱니 계산
rotate(i); // 1회마다 한꺼번에 톱니를 돌려줌
for (int j = 0; j < 4; j++) { // flag 초기화
check[j] = 1;
}
}
cout << 1 * wheel[0][0] + 2 * wheel[1][0] + 4 * wheel[2][0] + 8 * wheel[3][0] << endl;
cin >> K;
}
void rotate(int n) { // 방향에 따라 배열 시프트
for (int a = 0; a < 4; a++) {
int direction = r_wheel[a][n];
if (direction == 1) {
int temp_num = wheel[a][0];
wheel[a][0] = wheel[a][7];
for (int i = 0; i < 7; i++) {
int temp = wheel[a][i + 1];
wheel[a][i + 1] = temp_num;
temp_num = temp;
}
}
else if (direction == -1){
int temp_num = wheel[a][7];
wheel[a][7] = wheel[a][0];
for (int i = 7; i > 0; i--) {
int temp = wheel[a][i - 1];
wheel[a][i - 1] = temp_num;
temp_num = temp;
}
}
}
}
void BFS(int n) {
while (!q.empty()) {
location temp = q.front();
int wheel_num = temp.x;
int direction = temp.y;
r_wheel[wheel_num - 1][n] = direction; // 초기값 회전 배열에 추가
if (wheel_num == 1) { // 1번 톱니는 2번 톱니 관여
check[0] = 0;
if (wheel[0][2] + wheel[1][6] == 1 && check[1]) {
q.push({ 2, -direction });
}
}
else if (wheel_num == 2) { // 2번 톱니는 1,3번 톱니 관여
check[1] = 0;
if (wheel[0][2] + wheel[1][6] == 1 && check[0]) {
q.push({ 1, -direction });
}
if (wheel[1][2] + wheel[2][6] == 1 && check[2]) {
q.push({ 3 , -direction });
}
}
else if (wheel_num == 3) { // 3번 톱니는 2,4번 톱니 관여
check[2] = 0;
if (wheel[1][2] + wheel[2][6] == 1 && check[1]) {
q.push({ 2, -direction });
}
if (wheel[2][2] + wheel[3][6] == 1 && check[3]) {
q.push({ 4 , -direction });
}
}
else { // 4번 톱니는 3번 톱니 관여
check[3] = 0;
if (wheel[2][2] + wheel[3][6] == 1 && check[2]) {
q.push({ 3, -direction });
}
}
q.pop();
}
}
|
#ifndef GNGAMESTATE_H
#define GNGAMESTATE_H
#define DEFAULT_SCALE 0.7f
class GnGameState
{
private:
static GnGameState mSingleton;
float mGameScale;
float mGameWidth;
float mGameHeight;
public:
static GnGameState* GetSingleton();
inline float GetGameScale() {
return mGameScale;
}
inline void SetGameScale(float val) {
mGameScale = val;
}
inline float GetGameWidth() {
return mGameWidth;
}
inline float GetGameHeight() {
return mGameHeight;
}
inline void SetGameDisplaySize(float fWidth, float fHeight) {
mGameWidth = fWidth;
mGameHeight = fHeight;
}
private:
GnGameState();
};
#define GetGameState GnGameState::GetSingleton
#endif // GNGAMESTATE_H
|
/*
* Author: Elijah De Vera
* Created on January 23,2021
* Purpose: average
*/
//System Libraries
#include <iostream>
#include <math.h>
#include <iomanip>
using namespace std;
//User Libraries
//Global Constants - Math/Physics Constants, Conversions,
// 2-D Array Dimensions
//Function Prototypes
void getScre(int &,int &,int &,int &,int &);
float calcAvg(int,int,int,int,int);
int fndLwst(int,int,int,int,int);
//Execution Begins Here
int main(int argc, char** argv) {
//Declare Variables
int s1,
s2,
s3,
s4,
s5;
//Project title
cout<<setprecision(1)<<fixed;
cout<<"Find the Average of Test Scores"<<endl;
cout<<"by removing the lowest value."<<endl;
//Initialize Variables
getScre(s1,s2,s3,s4,s5);
cout<<"The average test score = "<<calcAvg(s1,s2,s3,s4,s5);
//Exit stage right!
return 0;
}
//get score Function
void getScre(int & s1,int &s2,int &s3,int &s4,int &s5)
{
cout<<"Input the 5 test scores."<<endl;
cin>>s1;
cin>>s2;
cin>>s3;
cin>>s4;
cin>>s5;
if ( s2 > 100 || s2 < 0 ){ cout<<"INVALID";
}
if ( s1 > 100 || s1 < 0 ){ cout<<"INVALID";
}
if ( s3 > 100 || s3 < 0 ){ cout<<"INVALID";
}
if ( s4 > 100 || s4 < 0 ){ cout<<"INVALID";
}
if ( s5 > 100 || s5 < 0 ){ cout<<"INVALID";
}
}
//average function
float calcAvg(int test1, int test2, int test3, int test4, int test5)
{
int average=0;
average = ((test1+test2+test3+test4+test5)-fndLwst(test1, test2, test3, test4, test5))/4.0;
return average;
}
//finding lowest number function
int fndLwst(int score1, int score2, int score3, int score4, int score5)
{
if(score1 < score2 && score1 < score3 && score1 < score4 && score1 < score5)
return score1;
else if(score2 < score1 && score2 < score3 && score2 < score4 && score2 < score5)
return score2;
else if(score3 < score1 && score3 < score2 && score3 < score4 && score3 < score5)
return score3;
else if(score4 < score1 && score4 < score2 && score4 < score3 && score4 < score5)
return score4;
else if(score5 < score1 && score5 < score2 && score5 < score3 && score5 < score4)
return score5;
}
|
#include<iostream>
#include<sstream>
#include<algorithm>
#include<vector>
#include<string>
using namespace std;
class Solution {
public:
int compareVersion(string version1, string version2) {
//基本思想：用istrigstream做
istringstream nums1(version1);
istringstream nums2(version2);
char c;
int v1, v2;
//while里面判断既不能用&&也不能用||，因为用&&，nums1>>v1成功后已经输出v1了
while (bool(nums1 >> v1) + bool(nums2 >> v2))
{
if (v1 > v2)
return 1;
if (v1 < v2)
return -1;
v1 = 0;
v2 = 0;
nums1 >> c;
nums2 >> c;
}
return 0;
}
};
class Solution1 {
public:
int compareVersion(string version1, string version2) {
//基本思想：双指针，一次遍历，常数空间
//version1上使用两个指针，以'.'分割跟踪每个数值的开始pos1和结束i，得到数值v1
//version2上使用两个指针，以'.'分割跟踪每个数值的开始pos2和结束j，得到数值v2
//分别比较对应v1和v2
int pos1 = 0, pos2 = 0, i = 0, j = 0, v1, v2, flag1 = 0, flag2 = 0;
while (i <= version1.size() && j <= version2.size())
{
if (i == version1.size() || version1[i] == '.')
flag1 = 1;
else
i++;
if (j == version2.size() || version2[j] == '.')
flag2 = 1;
else
j++;
if (flag1 && flag2)
{
v1 = stoi(version1.substr(pos1, i - pos1));
v2 = stoi(version2.substr(pos2, j - pos2));
if (v1 > v2)
return 1;
if (v1 < v2)
return -1;
flag1 = 0;
flag2 = 0;
i++;
j++;
pos1 = i;
pos2 = j;
}
}
while (i <= version1.size())
{
if (version1[i] != '.' && version1[i] != '0')
return 1;
i++;
}
while (j <= version2.size())
{
if (version2[j] != '.' && version2[j] != '0')
return -1;
j++;
}
return 0;
}
};
class Solution2 {
public:
int compareVersion(string version1, string version2) {
//基本思想：分割字符串，两次遍历，O(n)空间复杂度
//将两个字符串分割出数字保存到两个数组，然后依次比较对应元素大小
vector<int> v1, v2;
int pos = 0, i;
for (i = 0; i <= version1.size(); i++)
{
if (i == version1.size() || version1[i] == '.')
{
v1.push_back(stoi(version1.substr(pos, i - pos)));
pos = i + 1;
}
}
pos = 0;
for (i = 0; i <= version2.size(); i++)
{
if (i == version2.size() || version2[i] == '.')
{
v2.push_back(stoi(version2.substr(pos, i - pos)));
pos = i + 1;
}
}
for (i = 0; i < v1.size() && i < v2.size(); i++)
{
if (v1[i] > v2[i])
return 1;
if (v1[i] < v2[i])
return -1;
}
while (i < v1.size())
{
if (v1[i] != 0)
return 1;
i++;
}
while (i < v2.size())
{
if (v2[i] != 0)
return -1;
i++;
}
return 0;
}
};
int main()
{
Solution solute;
string version1 = "7.5.2.4", version2 = "7.5";
cout << solute.compareVersion(version1, version2) << endl;
return 0;
}
|
// -*- Mode: c++; tab-width: 4; indent-tabs-mode: t; c-basic-offset: 4 -*-
//
// Copyright (C) 2003-2007 Opera Software AS. All rights reserved.
//
// This file is part of the Opera web browser. It may not be distributed
// under any circumstances.
//
// Julien Picalausa
//
#include "core/pch.h"
#include "platforms/windows/installer/DeleteRegKeyOperation.h"
#include "modules/util/opfile/opfile.h"
#include "platforms/windows/windows_ui/registry.h"
DeleteRegKeyOperation::DeleteRegKeyOperation(const HKEY root_key, const OpStringC &key_path)
: m_root_key(root_key)
{
m_key_path.Set(key_path);
}
OP_STATUS DeleteRegKeyOperation::Do()
{
if (m_key_path.IsEmpty())
return OpStatus::ERR;
HKEY key;
DWORD err = RegOpenKeyEx(m_root_key, m_key_path, 0, KEY_QUERY_VALUE, &key);
if (err == ERROR_FILE_NOT_FOUND)
return OpStatus::OK;
else if (err != ERROR_SUCCESS && err != ERROR_ACCESS_DENIED)
return OpStatus::ERR;
RegCloseKey(key);
OpString full_key_path;
RETURN_IF_ERROR(WindowsUtils::RegkeyToObjectname(m_root_key, m_key_path, full_key_path));
OP_STATUS status = DeleteAndSaveRecursive(m_root_key, m_key_path, full_key_path);
if (OpStatus::IsError(status))
Undo();
return status;
}
OP_STATUS DeleteRegKeyOperation::DeleteAndSaveRecursive(const HKEY parent_key, const OpStringC &key_path, OpString &full_key_path)
{
OpAutoHKEY key;
DWORD err;
DWORD sec_desc_size = 0;
err = RegOpenKeyEx(parent_key, key_path, 0, READ_CONTROL, &key);
//Sometimes, opening the key succeeds even though we have no access
if (err == ERROR_ACCESS_DENIED ||
(err == ERROR_SUCCESS && !WindowsUtils::CheckObjectAccess(full_key_path, SE_REGISTRY_KEY, READ_CONTROL)))
{
if (err == ERROR_SUCCESS)
RegCloseKey(key);
WindowsUtils::RestoreAccessInfo* t;
if (!WindowsUtils::GiveObjectAccess(full_key_path, SE_REGISTRY_KEY, KEY_READ | DELETE, TRUE, t))
return OpStatus::ERR;
err = RegOpenKeyEx(parent_key, key_path, 0, KEY_READ | DELETE, &key);
}
if (err != ERROR_SUCCESS)
return OpStatus::ERR;
err = RegGetKeySecurity(key, GROUP_SECURITY_INFORMATION | DACL_SECURITY_INFORMATION | LABEL_SECURITY_INFORMATION, NULL, &sec_desc_size);
if (err != ERROR_SUCCESS && err != ERROR_INSUFFICIENT_BUFFER)
return OpStatus::ERR;
KeyInfo* ki = OP_NEW(KeyInfo, ());
OpAutoPtr<KeyInfo> key_info(ki);
RETURN_IF_ERROR(key_info->key_path.Set(key_path));
RETURN_OOM_IF_NULL(key_info->sec_desc = (PSECURITY_DESCRIPTOR)(OP_NEWA(char, sec_desc_size)));
//The SACL won't be backed up here (and will thus get lost) because doing so requires administrative privileges.
err = RegGetKeySecurity(key, GROUP_SECURITY_INFORMATION | DACL_SECURITY_INFORMATION | LABEL_SECURITY_INFORMATION, key_info->sec_desc, &sec_desc_size);
if (err != ERROR_SUCCESS)
return OpStatus::ERR;
key.reset();
err = RegOpenKeyEx(parent_key, key_path, 0, KEY_READ | DELETE, &key);
//Sometimes, opening the key succeeds even though we have no access
if (err == ERROR_ACCESS_DENIED ||
(err == ERROR_SUCCESS && !WindowsUtils::CheckObjectAccess(full_key_path, SE_REGISTRY_KEY, KEY_QUERY_VALUE | KEY_SET_VALUE)))
{
if (err == ERROR_SUCCESS)
RegCloseKey(key);
WindowsUtils::RestoreAccessInfo* t;
if (!WindowsUtils::GiveObjectAccess(full_key_path, SE_REGISTRY_KEY, KEY_READ | DELETE, TRUE, t))
return OpStatus::ERR;
err = RegOpenKeyEx(parent_key, key_path, 0, KEY_READ | DELETE, &key);
}
if (err != ERROR_SUCCESS)
return OpStatus::ERR;
DWORD max_subkey_len;
DWORD num_values;
DWORD max_value_name_len;
DWORD max_value_len;
//Ignoring the key class here because it doesn't seem possible to read and or write it. (and it practically not used anyway)
if (RegQueryInfoKey(key, NULL, NULL, NULL, NULL, &max_subkey_len, NULL, &num_values, &max_value_name_len, &max_value_len, NULL, NULL) != ERROR_SUCCESS)
return OpStatus::ERR;
max_subkey_len++;
max_value_name_len++;
OpAutoArray<uni_char> value_name(OP_NEWA(uni_char, max_value_name_len));
RETURN_OOM_IF_NULL(value_name.get());
OpAutoArray<BYTE> value_data(OP_NEWA(BYTE, max_value_len));
RETURN_OOM_IF_NULL(value_data.get());
for (UINT i = 0; i < num_values; i++)
{
DWORD value_name_len = max_value_name_len;
DWORD value_len = max_value_len;
DWORD value_type;
if (RegEnumValue(key, i, value_name.get(), &value_name_len, NULL, &value_type, value_data.get(), &value_len) != ERROR_SUCCESS)
return OpStatus::ERR;
ValueInfo *value_info = OP_NEW(ValueInfo, ());
value_info->value_type = value_type;
RETURN_IF_ERROR(value_info->value_name.Set(value_name.get()));
RETURN_OOM_IF_NULL(value_info->value_data = OP_NEWA(BYTE, value_len));
value_info->value_data_len = value_len;
op_memcpy(value_info->value_data, value_data.get(), value_len);
RETURN_IF_ERROR(key_info->values.Add(value_info));
}
RETURN_IF_ERROR(m_keys.Add(key_info.get()));
key_info.release();
OpAutoArray<uni_char> subkey_name(OP_NEWA(uni_char, max_subkey_len));
RETURN_OOM_IF_NULL(subkey_name.get());
do
{
DWORD subkey_len = max_subkey_len;
DWORD ret = RegEnumKeyEx(key, 0, subkey_name.get(), &subkey_len, NULL, NULL, NULL, NULL);
if (ret == ERROR_NO_MORE_ITEMS)
break;
if (ret != ERROR_SUCCESS)
return OpStatus::ERR;
OpString subkey_path;
RETURN_IF_ERROR(subkey_path.Set(key_path));
RETURN_IF_ERROR(subkey_path.Append(PATHSEP));
RETURN_IF_ERROR(subkey_path.Append(subkey_name.get()));
OpString full_subkey_path;
RETURN_IF_ERROR(full_subkey_path.Set(full_key_path));
RETURN_IF_ERROR(full_subkey_path.Append("\\"));
RETURN_IF_ERROR(full_subkey_path.Append(subkey_name.get()));
RETURN_IF_ERROR(DeleteAndSaveRecursive(parent_key, subkey_path, full_subkey_path));
}
while(TRUE);
//Need to close the key here, sowe can delete it.
key.reset();
RegDeleteKey(parent_key, key_path);
return OpStatus::OK;
}
void DeleteRegKeyOperation::Undo()
{
UINT n_keys = m_keys.GetCount();
for (UINT i = 0; i < n_keys; i++)
{
KeyInfo* key_info = m_keys.Get(i);
SECURITY_ATTRIBUTES sec_attr;
sec_attr.bInheritHandle = FALSE;
sec_attr.nLength = sizeof(sec_attr);
sec_attr.lpSecurityDescriptor = key_info->sec_desc;
HKEY key;
DWORD disposition;
if (RegCreateKeyEx(m_root_key, key_info->key_path.CStr(), 0, NULL, REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, &sec_attr, &key, &disposition) != ERROR_SUCCESS || disposition != REG_CREATED_NEW_KEY)
continue;
UINT n_values = key_info->values.GetCount();
for (UINT j = 0; j < n_values; j++)
{
ValueInfo* value_info = key_info->values.Get(j);
RegSetValueEx(key, value_info->value_name.CStr(), 0, value_info->value_type, value_info->value_data, value_info->value_data_len);
}
RegCloseKey(key);
}
m_keys.DeleteAll();
}
|
#include <memory>
#include <vector>
#include "gmock/gmock.h"
#include "bsgs.h"
#include "perm.h"
#include "perm_group.h"
#include "perm_set.h"
#include "schreier_structure.h"
#include "test_main.cc"
using cgtl::BSGS;
using cgtl::Perm;
using cgtl::PermGroup;
using cgtl::PermSet;
TEST(DISABLED_BSGSSolveTest, CanSolveBSGS)
{
BSGS::Options bsgs_options;
bsgs_options.construction = BSGS::Construction::SOLVE;
PermSet generators_solvable {
Perm(4, {{2, 4}}),
Perm(4, {{1, 2}, {3, 4}})
};
Perm generators_solvable_expected_elements[] = {
Perm(4, {{1, 2, 3, 4}}),
Perm(4, {{1, 2}, {3, 4}}),
Perm(4, {{1, 3}, {2, 4}}),
Perm(4, {{1, 3}}),
Perm(4, {{1, 4, 3, 2}}),
Perm(4, {{1, 4}, {2, 3}}),
Perm(4, {{2, 4}})
};
PermSet generators_non_solvable(PermGroup::symmetric(5).generators());
BSGS bsgs(4, generators_solvable, &bsgs_options);
for (Perm const &perm : generators_solvable_expected_elements) {
EXPECT_TRUE(bsgs.strips_completely(perm))
<< "Solvable group BSGS correct.";
}
EXPECT_THROW(BSGS dummy(5, generators_non_solvable, &bsgs_options),
BSGS::SolveError)
<< "Solving BSGS fails for non-solvable group generating set.";
}
//TEST(BSGSBaseSwapTest, CanConjugateBSGS)
//{
// PermGroup pg(5, {Perm(5, {{1, 2}, {3, 4}}), Perm(5, {{1, 4, 2}})});
//
// for (Perm const &perm : pg) {
// PermGroup pg_conjugated_bsgs(pg);
// pg_conjugated_bsgs.bsgs().conjugate(perm)
//
// EXPECT_TRUE(perm_group_equal(pg, pg_conjugated_bsgs))
// << "Permutation group remains the same after conjugating BSGS."
// }
//}
|
#ifndef TABWIDGETS
#define TABWIDGETS
#include <QTabWidget>
class RequestWidget;
class ActionsTestWidget;
class YoumeTabWidget : public QTabWidget
{
Q_OBJECT
public:
explicit YoumeTabWidget(QWidget *parent= 0);
private:
RequestWidget *m_requestWidget;
ActionsTestWidget *m_actionsWidget;
};
#endif // TABWIDGETS
|
#include <bits/stdc++.h>
using namespace std;
int goodNum()
{
int n, temp;
cout<<"Enter the number : ";
cin>>n;
temp=n;
n--;
queue<string> q;
q.push("1");
q.push("2");
while(n--){
string str = q.front();
q.pop();
q.push(str+"1");
q.push(str+"2");
}
cout<<"The Good Number for "<<temp<<" is "<<q.front()<< endl;
}
int main()
{
int T;
cout<<"Enter the number of tests : ";
cin >> T;
while(T--)
{
goodNum();
}
return 0;
}
|
/*
Name: Graham Atlee
Course: csc1720
Date: 10/24/19
Location of program: ~/csc1720/Labs/lab9
This file contains prototypes methods for the unorderedArrayListType.
This class derives from arrayListType.
*/
#ifndef H_unorderedArrayListType
#define H_unorderedArrayListType
#include "arrayListType.h"
class unorderedArrayListType: public arrayListType
{
public:
void insertAt(int location, int insertItem);
void insertFirst(int insertItem);
void insertEnd(int insertItem);
void replaceAt(int location, int repItem);
int seqSearch(int searchItem) const;
void remove(int removeItem);
void removeAt(int location);
void removeAll(int removeItem);
unorderedArrayListType(int size = 100);
//Constructor
};
#endif
|
#ifndef BARTENDING_MOVEIT_SERVICE
#define BARTENDING_MOVEIT_SERVICE
#include <ros/ros.h>
#include <moveit/move_group_interface/move_group_interface.h>
#include <moveit/planning_scene_interface/planning_scene_interface.h>
#include <moveit/robot_state/robot_state.h>
#include <moveit/planning_interface/planning_interface.h>
#include <moveit/robot_model_loader/robot_model_loader.h>
#include <moveit/robot_model/robot_model.h>
#include <moveit/robot_state/robot_state.h>
#include <moveit_msgs/DisplayTrajectory.h>
#include <vector>
// #include <std_msgs/String.h>
#include "open_manipulator_msgs/OpenManipulatorState.h"
#include "open_manipulator_msgs/GetJointPosition.h"
#include "open_manipulator_msgs/GetKinematicsPose.h"
#include "open_manipulator_msgs/SetJointPosition.h"
#include "open_manipulator_msgs/SetKinematicsPose.h"
class MoveitPlannerPostProcessor {
public:
MoveitPlannerPostProcessor();
virtual ~MoveitPlannerPostProcessor();
void TestPlanPath();
private:
// void ControlCallback(const ros::TimerEvent&);
void Initialise();
bool PlanPath(const std::string planning_group,
open_manipulator_msgs::JointPosition msg);
// bool PlanPath(const std::string planning_group,
// open_manipulator_msgs::KinematicsPose msg, bool grasping);
void DisplayPlannedPathMsgCallback(
const moveit_msgs::DisplayTrajectory::ConstPtr &msg);
bool setJointPositionMsgCallback(
open_manipulator_msgs::SetJointPosition::Request &req,
open_manipulator_msgs::SetJointPosition::Response &res);
// bool setKinematicsPoseMsgCallback(
// open_manipulator_msgs::SetKinematicsPose::Request &req,
// open_manipulator_msgs::SetKinematicsPose::Response &res);
bool getJointPositionMsgCallback(
open_manipulator_msgs::GetJointPosition::Request &req,
open_manipulator_msgs::GetJointPosition::Response &res);
// bool getKinematicsPoseMsgCallback(
// open_manipulator_msgs::GetKinematicsPose::Request &req,
// open_manipulator_msgs::GetKinematicsPose::Response &res);
private:
ros::NodeHandle nh_;
ros::NodeHandle priv_nh_;
std::string planning_group_;
bool fake_execution_ = false;
ros::Publisher dynamixel_workbench_pub_;
ros::Subscriber display_planned_path_sub_;
ros::ServiceServer get_joint_position_server_;
// ros::ServiceServer get_kinematics_pose_server_;
ros::ServiceServer set_joint_position_server_;
// ros::ServiceServer set_kinematics_pose_server_;
moveit::planning_interface::MoveGroupInterface *move_group_;
moveit::planning_interface::PlanningSceneInterface planning_scene_interface_;
// joint_names: [base_z_rot, base_y_rot, elbow_y_rot, wrist_y_rot,
// gripper_z_rot] float angle_offset_[5] = {1.9789, 2.6435, 2.6077, 2.6334,
// 0.0}; // TODO
// float angle_offset_[5] = {-0.7, -0.25, 0.0, 0.0, 0.0};
float angle_offset_[5] = {0.0, 0.0, 0.0, 0.0, 0.0};
};
#endif /* BARTENDING_MOVEIT_SERVICE */
|
// -*- Mode: c++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
//
// Copyright (C) 2005-2011 Opera Software ASA. All rights reserved.
//
// This file is part of the Opera web browser. It may not be distributed
// under any circumstances.
#include "core/pch.h"
#ifdef WEBFEEDS_BACKEND_SUPPORT
#include "modules/webfeeds/src/webfeed-parsestates.h"
#include "modules/webfeeds/src/webfeedparser.h"
#include "modules/webfeeds/src/webfeedutil.h"
#include "modules/stdlib/util/opdate.h"
// ***************************************************************************
//
// RSSFormat
//
// ***************************************************************************
class RSSFormat // Really a namespace
{
public:
// Version enumeration.
enum Version
{
RSSUnknown,
RSS091, // Netscape / userland rss 0.91.
RSS092, // Userland rss 0.92.
RSS093, // Userland rss 0.93.
RSS094, // Userland rss 0.94.
RSS10, // RSS-DEV rss 1.0.
RSS20, // Userland rss 2.x.
};
// Functions.
static BOOL IsRSSElement(const OpStringC& name) { return name.CompareI("rss") == 0; }
static BOOL IsRDFElement(const OpStringC& name) { return name.CompareI("rdf:RDF") == 0; }
static BOOL IsChannel(const OpStringC& name) { return (name.CompareI("channel") == 0) || (name.CompareI("rss:channel") == 0); }
static BOOL IsItem(const OpStringC& name) { return (name.CompareI("item") == 0) || (name.CompareI("rss:item") == 0); }
static BOOL IsTitle(const OpStringC& name) { return (name.CompareI("title") == 0) || (name.CompareI("rss:title") == 0); }
static BOOL IsLink(const OpStringC& name) { return (name.CompareI("link") == 0) || (name.CompareI("rss:link") == 0); }
static BOOL IsDescription(const OpStringC& name) { return (name.CompareI("description") == 0) || (name.CompareI("rss:description") == 0); }
static BOOL IsEncodedContent(const OpStringC& name) { return name.CompareI("content:encoded") == 0; }
static BOOL IsXMLContent(const OpStringC& name);
static BOOL IsAuthorName(const OpStringC& name) { return name.CompareI("dc:creator") == 0; }
static BOOL IsAuthorEmail(const OpStringC& name) { return (name.CompareI("author") == 0) || (name.CompareI("managingEditor") == 0); }
static BOOL IsWebmasterEmail(const OpStringC& name) { return name.CompareI("webMaster") == 0; }
static BOOL IsUpdatePeriod(const OpStringC& name) { return (name.CompareI("ttl") == 0) || (name.CompareI("sy:updatePeriod") == 0); }
static BOOL IsUpdateFrequency(const OpStringC& name) { return name.CompareI("sy:updateFrequency") == 0; }
static BOOL IsGUID(const OpStringC& name) { return name.CompareI("guid") == 0; }
static BOOL IsPublicationDate(const OpStringC& name);
static BOOL IsSource(const OpStringC& name) { return name.CompareI("source") == 0; }
static BOOL IsEnclosure(const OpStringC& name) { return name.CompareI("enclosure") == 0; }
static BOOL IsImage(const OpStringC& name) { return name.CompareI("image") == 0; }
static OP_STATUS DefaultContentTypeFromVersion(const Version version, OpString& mime_type);
private:
// No construction, copy or assignment.
RSSFormat();
RSSFormat(const RSSFormat& other);
RSSFormat& operator=(const RSSFormat& other);
};
BOOL RSSFormat::IsXMLContent(const OpStringC& name)
{
const BOOL is_xml_content = (name.CompareI("xhtml:body") == 0) ||
(name.CompareI("xhtml:div") == 0) || (name.CompareI("body") == 0) ||
(name.CompareI("div") == 0);
return is_xml_content;
}
BOOL RSSFormat::IsPublicationDate(const OpStringC& name)
{
const BOOL is_publication_date = (name.CompareI("pubDate") == 0) ||
(name.CompareI("lastBuildDate") == 0) ||
(name.CompareI("dc:date") == 0);
return is_publication_date;
}
OP_STATUS RSSFormat::DefaultContentTypeFromVersion(const Version version,
OpString& mime_type)
{
// According to the standards, rss 0.91 and rss 1.0 have a MIME type of
// text/plain, while the rest are text/html.
if (version == RSS091 || version == RSS10)
RETURN_IF_ERROR(mime_type.Set(UNI_L("text/plain")));
else
RETURN_IF_ERROR(mime_type.Set(UNI_L("text/html")));
return OpStatus::OK;
}
// ***************************************************************************
//
// RSSContext
//
// ***************************************************************************
class RSSContext
: public WebFeedParseState::WebFeedContext
{
public:
// Construction.
RSSContext(RSSFormat::Version version)
: m_version(version),
m_items_outside_channel(FALSE)
{}
// Methods.
RSSFormat::Version Version() const { return m_version; }
void SetItemsOutsideChannel(BOOL outside) { m_items_outside_channel = outside; }
BOOL ItemsOutsideChannel() const { return m_items_outside_channel; }
private:
// Members.
RSSFormat::Version m_version;
BOOL m_items_outside_channel;
};
// ***************************************************************************
//
// AtomFormat
//
// ***************************************************************************
class AtomFormat // really a namespace
{
public:
// Version enumeration.
enum Version
{
AtomUnknown,
Atom03, // The Atom Syndication Format 0.3 (PRE-DRAFT).
Atom10 // The Atom Syndication Format (draft-ietf-atompub-format-11).
};
// Methods.
static BOOL IsFeedElement(const OpStringC& name) { return (name.CompareI("feed") == 0) || (name.CompareI("atom:feed") == 0); }
static BOOL IsTitle(const OpStringC& name) { return (name.CompareI("title") == 0) || (name.CompareI("atom:title") == 0); }
static BOOL IsLink(const OpStringC& name) { return (name.CompareI("link") == 0) || (name.CompareI("atom:link") == 0); }
static BOOL IsAuthor(const OpStringC& name) { return (name.CompareI("author") == 0) || (name.CompareI("atom:author") == 0); }
static BOOL IsAuthorName(const OpStringC& name) { return (name.CompareI("name") == 0) || name.CompareI("atom:name") == 0; }
static BOOL IsAuthorEmail(const OpStringC& name) { return (name.CompareI("email") == 0) || (name.CompareI("atom:email") == 0); }
static BOOL IsSubtitle(const OpStringC& name);
static BOOL IsSummary(const OpStringC& name) { return (name.CompareI("summary") == 0) || (name.CompareI("atom:summary") == 0); }
static BOOL IsPublished(const OpStringC& name);
static BOOL IsUpdated(const OpStringC& name);
static BOOL IsId(const OpStringC& name) { return (name.CompareI("id") == 0) || (name.CompareI("atom:id") == 0); }
static BOOL IsIcon(const OpStringC& name) { return (name.CompareI("icon") == 0) || (name.CompareI("atom:icon") == 0); }
static BOOL IsEntry(const OpStringC& name) { return (name.CompareI("entry") == 0) || (name.CompareI("atom:entry") == 0); }
static BOOL IsContent(const OpStringC& name) { return (name.CompareI("content") == 0) || (name.CompareI("atom:content") == 0); }
static BOOL IsSource(const OpStringC& name) { return (name.CompareI("source") == 0) || (name.CompareI("atom:source") == 0); }
private:
// No construction, copy or assignment.
AtomFormat();
AtomFormat(const AtomFormat& other);
AtomFormat& operator=(const AtomFormat& other);
};
BOOL AtomFormat::IsSubtitle(const OpStringC& name)
{
const BOOL is_tagline = (name.CompareI("tagline") == 0) ||
(name.CompareI("subtitle") == 0) ||
(name.CompareI("atom:tagline") == 0) ||
(name.CompareI("atom:subtitle") == 0);
return is_tagline;
}
BOOL AtomFormat::IsPublished(const OpStringC& name)
{
const BOOL is_published = (name.CompareI("created") == 0) ||
(name.CompareI("published") == 0) ||
(name.CompareI("atom:created") == 0) ||
(name.CompareI("atom:published") == 0);
return is_published;
}
BOOL AtomFormat::IsUpdated(const OpStringC& name)
{
const BOOL is_updated = (name.CompareI("modified") == 0) ||
(name.CompareI("atom:modified") == 0) ||
(name.CompareI("updated") == 0) ||
(name.CompareI("atom:updated") == 0);
return is_updated;
}
// ***************************************************************************
//
// AtomContext
//
// ***************************************************************************
class AtomContext
: public WebFeedParseState::WebFeedContext
{
public:
// Construction.
AtomContext(AtomFormat::Version version)
: m_version(version)
{}
// Methods.
AtomFormat::Version Version() const { return m_version; }
private:
// Members.
AtomFormat::Version m_version;
};
// ***************************************************************************
//
// WebFeedParseState
//
// ***************************************************************************
WebFeedParseState::WebFeedParseState(WebFeedParser& parser)
: m_parser(parser),
m_ancestor_count(UINT_MAX)
{}
// ***************************************************************************
//
// WebFeedParseState::WebFeedContext
//
// ***************************************************************************
RSSContext& WebFeedParseState::WebFeedContext::AsRSSContext()
{
RSSContext& context = (RSSContext &)(*this);
return context;
}
const RSSContext& WebFeedParseState::WebFeedContext::AsRSSContext() const
{
const RSSContext& context = (const RSSContext &)(*this);
return context;
}
AtomContext& WebFeedParseState::WebFeedContext::AsAtomContext()
{
AtomContext& context = (AtomContext &)(*this);
return context;
}
const AtomContext& WebFeedParseState::WebFeedContext::AsAtomContext() const
{
const AtomContext& context = (const AtomContext &)(*this);
return context;
}
// ***************************************************************************
//
// InitialFeedParseState
//
// ***************************************************************************
InitialFeedParseState::InitialFeedParseState(WebFeedParser& parser)
: WebFeedParseState(parser)
{
}
OP_STATUS InitialFeedParseState::OnStartElement(const OpStringC& namespace_uri,
const OpStringC& local_name, const OpStringC& qualified_name,
OpAutoStringHashTable<XMLAttributeQN> &attributes, StateType& next_state)
{
if (RSSFormat::IsRSSElement(qualified_name))
{
// Attempt to detect the rss version used.
RSSFormat::Version version = RSSFormat::RSS20;
if (attributes.Contains(UNI_L("version")))
{
XMLAttributeQN* attribute = 0;
RETURN_IF_ERROR(attributes.GetData(UNI_L("version"), &attribute));
OP_ASSERT(attribute != 0);
const OpStringC& value = attribute->Value();
if (value.Compare("0.91") == 0)
version = RSSFormat::RSS091;
else if (value.Compare("0.92") == 0)
version = RSSFormat::RSS092;
else if (value.Compare("0.93") == 0)
version = RSSFormat::RSS093;
else if (value.Compare("0.94") == 0)
version = RSSFormat::RSS094;
else if (value.Find("2.") != KNotFound)
version = RSSFormat::RSS20;
}
// Create a context and switch state.
OP_ASSERT(!HasContext());
RSSContext* context = OP_NEW(RSSContext, (version));
if (!context)
return OpStatus::ERR_NO_MEMORY;
SetContext(context);
next_state = StateRSSRoot;
}
else if (RSSFormat::IsRDFElement(qualified_name))
{
// Create a context and switch state.
OP_ASSERT(!HasContext());
RSSContext* context = OP_NEW(RSSContext, (RSSFormat::RSS10));
if (!context)
return OpStatus::ERR_NO_MEMORY;
SetContext(context);
next_state = StateRSSRoot;
}
else if (AtomFormat::IsFeedElement(qualified_name))
{
// Detect the Atom version.
AtomFormat::Version version = AtomFormat::Atom10;
if (attributes.Contains(UNI_L("version")))
{
XMLAttributeQN* attribute = 0;
RETURN_IF_ERROR(attributes.GetData(UNI_L("version"), &attribute));
OP_ASSERT(attribute != 0);
const OpStringC& value = attribute->Value();
if (value.Compare("0.3") == 0)
version = AtomFormat::Atom03;
}
// Create a context and switch state.
OP_ASSERT(!HasContext());
AtomContext* context = OP_NEW(AtomContext, (version));
if (!context)
return OpStatus::ERR_NO_MEMORY;
SetContext(context);
next_state = StateAtomRoot;
}
if (next_state == StateRSSRoot || next_state == StateAtomRoot)
RETURN_IF_ERROR(Parser().CreateFeed());
return OpStatus::OK;
}
// ***************************************************************************
//
// RSSParseStateBase
//
// ***************************************************************************
RSSParseStateBase::RSSParseStateBase(WebFeedParser& parser)
: WebFeedParseState(parser)
{
}
OP_STATUS RSSParseStateBase::UpdateContentElement(WebFeedContentElement& element,
const OpStringC& namespace_uri, const OpStringC& local_name,
const OpStringC& qualified_name, OpAutoStringHashTable<XMLAttributeQN>& attributes)
{
// Update the content type.
OpString content_type;
if (RSSFormat::IsDescription(qualified_name))
{
// Description might, for RSS 0.94, have a type attribute, telling
// the MIME type of the content. To be on the safe side we will
// respect it no matter the RSS version.
if (attributes.Contains(UNI_L("type")))
{
XMLAttributeQN* attribute = NULL;
RETURN_IF_ERROR(attributes.GetData(UNI_L("type"), &attribute));
RETURN_IF_ERROR(content_type.Set(attribute->Value()));
}
}
else if (RSSFormat::IsEncodedContent(qualified_name))
{
// Always use text/html for encoded content.
RETURN_IF_ERROR(content_type.Set("text/html"));
}
else if (RSSFormat::IsXMLContent(qualified_name))
{
// Always use application/xhtml+xml for embedded html / xml.
RETURN_IF_ERROR(content_type.Set("application/xhtml+xml"));
RETURN_IF_ERROR(Parser().SetKeepTags(namespace_uri, local_name));
}
if (content_type.IsEmpty())
{
RETURN_IF_ERROR(RSSFormat::DefaultContentTypeFromVersion(
Context().AsRSSContext().Version(), content_type));
}
OP_ASSERT(content_type.HasContent());
RETURN_IF_ERROR(element.SetType(content_type));
// Update the base uri.
RETURN_IF_ERROR(Parser().UpdateContentBaseURIIfNeeded(element));
return OpStatus::OK;
}
OP_STATUS RSSParseStateBase::UpdateContentElementValue(WebFeedContentElement& element)
{
const RSSFormat::Version version = Context().AsRSSContext().Version();
if (version == RSSFormat::RSS091 || version == RSSFormat::RSS10)
{
// Final attempt to determine if the content type should be
// text/html.
if (WebFeedUtil::ContentContainsHTML(Parser().ElementContent()))
RETURN_IF_ERROR(element.SetType(UNI_L("text/html")));
}
RETURN_IF_ERROR(element.SetValue(Parser().ElementContent()));
return OpStatus::OK;
}
OP_STATUS RSSParseStateBase::UpdateAuthorInfo(WebFeedPersonElement& author)
{
OpString email;
OpString name;
RETURN_IF_ERROR(Parser().ParseAuthorInformation(Parser().ElementContent(), email, name));
if (email.HasContent())
RETURN_IF_ERROR(author.SetEmail(email));
if (name.HasContent())
RETURN_IF_ERROR(author.SetName(name));
return OpStatus::OK;
}
// ***************************************************************************
//
// RSSRootParseState
//
// ***************************************************************************
RSSRootParseState::RSSRootParseState(WebFeedParser& parser)
: RSSParseStateBase(parser)
{
}
OP_STATUS RSSRootParseState::OnStartElement(const OpStringC& namespace_uri,
const OpStringC& local_name, const OpStringC& qualified_name,
OpAutoStringHashTable<XMLAttributeQN> &attributes, StateType& next_state)
{
if (RSSFormat::IsChannel(qualified_name))
next_state = StateRSSChannel;
// Support feeds that close the channel element before the items.
else if (RSSFormat::IsItem(qualified_name))
{
Context().AsRSSContext().SetItemsOutsideChannel(TRUE);
next_state = StateRSSItem;
}
return OpStatus::OK;
}
OP_STATUS RSSRootParseState::OnEndElement(const OpStringC& namespace_uri,
const OpStringC& local_name, const OpStringC& qualified_name,
StateType& next_state)
{
if (Context().AsRSSContext().Version() == RSSFormat::RSS10 &&
RSSFormat::IsRDFElement(qualified_name))
next_state = StateDone;
else if (RSSFormat::IsRSSElement(qualified_name))
next_state = StateDone;
return OpStatus::OK;
}
// ***************************************************************************
//
// RSSChannelParseState
//
// ***************************************************************************
RSSChannelParseState::RSSChannelParseState(WebFeedParser& parser)
: RSSParseStateBase(parser)
{
}
OP_STATUS RSSChannelParseState::OnStartElement(const OpStringC& namespace_uri,
const OpStringC& local_name, const OpStringC& qualified_name,
OpAutoStringHashTable<XMLAttributeQN> &attributes, StateType& next_state)
{
if (RSSFormat::IsItem(qualified_name))
next_state = StateRSSItem;
else if (RSSFormat::IsImage(qualified_name))
next_state = StateRSSImage;
else if (RSSFormat::IsTitle(qualified_name))
{
OP_ASSERT(Parser().Feed());
WebFeedContentElement* title = (WebFeedContentElement*)Parser().Feed()->GetTitle();
RETURN_IF_ERROR(UpdateContentElement(*title, namespace_uri, local_name, qualified_name, attributes));
}
else if (RSSFormat::IsDescription(qualified_name))
{
WebFeedContentElement* tagline = Parser().Feed()->Tagline();
RETURN_IF_ERROR(UpdateContentElement(*tagline, namespace_uri, local_name, qualified_name, attributes));
}
return OpStatus::OK;
}
OP_STATUS RSSChannelParseState::OnEndElement(const OpStringC& namespace_uri,
const OpStringC& local_name, const OpStringC& qualified_name,
StateType& next_state)
{
if (RSSFormat::IsTitle(qualified_name))
{
WebFeedContentElement* title = (WebFeedContentElement*)Parser().Feed()->GetTitle();
RETURN_IF_ERROR(UpdateContentElementValue(*title));
}
else if (RSSFormat::IsLink(qualified_name))
{
WebFeedLinkElement* link = Parser().Feed()->FeedLink();
RETURN_IF_ERROR(Parser().ResolveAndUpdateLink(*link, Parser().ElementContent()));
}
else if (RSSFormat::IsDescription(qualified_name))
{
WebFeedContentElement* tagline = Parser().Feed()->Tagline();
RETURN_IF_ERROR(UpdateContentElementValue(*tagline));
}
else if (RSSFormat::IsAuthorName(qualified_name) ||
RSSFormat::IsAuthorEmail(qualified_name))
{
WebFeedPersonElement* author = Parser().Feed()->AuthorElement();
RETURN_IF_ERROR(UpdateAuthorInfo(*author));
}
else if (RSSFormat::IsWebmasterEmail(qualified_name))
{
// Only use the webmaster information if we don't have anything else.
WebFeedPersonElement* author = Parser().Feed()->AuthorElement();
if (!author->HasEmail())
RETURN_IF_ERROR(UpdateAuthorInfo(*author));
}
else if (RSSFormat::IsUpdatePeriod(qualified_name))
{
if (Parser().ElementContent())
{
UINT32 frequency = 0; // in minutes
if (uni_stri_eq(Parser().ElementContent(), "hourly"))
frequency = 60;
else if (uni_stri_eq(Parser().ElementContent(), "daily"))
frequency = 1440;
else if (uni_stri_eq(Parser().ElementContent(), "weekly") ||
uni_stri_eq(Parser().ElementContent(), "monthly") ||
uni_stri_eq(Parser().ElementContent(), "yearly"))
{
frequency = 10080; // Maximum of one week.
}
else
frequency = uni_atoi(Parser().ElementContent()); // TTL
if (frequency != 0)
{
Parser().Feed()->SetMinUpdateInterval(frequency);
Parser().Feed()->SetUpdateInterval(frequency);
}
}
}
else if (RSSFormat::IsUpdateFrequency(qualified_name))
{
if (Parser().ElementContent())
{
UINT32 frequency = uni_atoi(Parser().ElementContent());
if (frequency > 0)
{
UINT time_to_live = Parser().Feed()->GetUpdateInterval();
Parser().Feed()->SetMinUpdateInterval(time_to_live / frequency);
Parser().Feed()->SetUpdateInterval(time_to_live / frequency);
}
}
}
else if (RSSFormat::IsPublicationDate(qualified_name))
{
// RETURN_IF_ERROR(Parser().Feed()->SetDateCreated(Parser().ElementContent()));
}
else if (RSSFormat::IsChannel(qualified_name))
next_state = StateRSSRoot;
return OpStatus::OK;
}
// ***************************************************************************
//
// RSSItemParseState
//
// ***************************************************************************
RSSItemParseState::RSSItemParseState(WebFeedParser& parser)
: RSSParseStateBase(parser),
m_guid_is_permalink(NO),
m_have_good_author_info(FALSE),
m_have_xml_content(FALSE)
{
}
OP_STATUS RSSItemParseState::Init()
{
// Create an entry that we'll add to the feed when it's complete.
RETURN_IF_ERROR(Parser().CreateEntry());
return OpStatus::OK;
}
OP_STATUS RSSItemParseState::OnStartElement(const OpStringC& namespace_uri,
const OpStringC& local_name, const OpStringC& qualified_name,
OpAutoStringHashTable<XMLAttributeQN> &attributes, StateType& next_state)
{
if (RSSFormat::IsTitle(qualified_name))
{
WebFeedContentElement* title = (WebFeedContentElement*)Parser().Entry()->GetTitle();
RETURN_IF_ERROR(UpdateContentElement(*title, namespace_uri, local_name, qualified_name, attributes));
}
else if (RSSFormat::IsGUID(qualified_name))
{
// Check if the guid is a permalink or not.
// we consider it a permalink unless the permaLink-attribute is set to false,
// but need to distinguish between which is just default, and one which is set to true
m_guid_is_permalink = MAYBE;
if (attributes.Contains(UNI_L("isPermaLink")))
{
XMLAttributeQN* attribute = NULL;
RETURN_IF_ERROR(attributes.GetData(UNI_L("isPermaLink"), &attribute));
OP_ASSERT(attribute);
const OpStringC& value = attribute->Value();
if ((value.CompareI("false") == 0) || (value.Compare("0") == 0))
m_guid_is_permalink = NO;
else if ((value.CompareI("true") == 0) || (value.Compare("1") == 0))
m_guid_is_permalink = YES;
}
}
else if (RSSFormat::IsDescription(qualified_name))
{
WebFeedContentElement* content = (WebFeedContentElement*)Parser().Entry()->GetContent();
if (!content->HasType())
RETURN_IF_ERROR(UpdateContentElement(*content, namespace_uri, local_name, qualified_name, attributes));
}
else if (RSSFormat::IsEncodedContent(qualified_name))
{
if (!m_have_xml_content)
{
WebFeedContentElement* content = (WebFeedContentElement*)Parser().Entry()->GetContent();
RETURN_IF_ERROR(UpdateContentElement(*content, namespace_uri, local_name, qualified_name, attributes));
}
}
else if (RSSFormat::IsXMLContent(qualified_name))
{
WebFeedContentElement* content = (WebFeedContentElement*)Parser().Entry()->GetContent();
RETURN_IF_ERROR(UpdateContentElement(*content, namespace_uri, local_name, qualified_name, attributes));
m_have_xml_content = TRUE;
}
else if (RSSFormat::IsEnclosure(qualified_name))
{
WebFeedLinkElement* enclosure = NULL;
RETURN_IF_ERROR(Parser().Entry()->AddEnclosureLink(enclosure));
// An enclosure must contain 'url', 'length' and 'type'.
XMLAttributeQN* url_attribute = NULL;
OpStatus::Ignore(attributes.GetData(UNI_L("url"), &url_attribute));
if (url_attribute)
RETURN_IF_ERROR(Parser().ResolveAndUpdateLink(*enclosure, url_attribute->Value()));
XMLAttributeQN* type_attribute = NULL;
OpStatus::Ignore(attributes.GetData(UNI_L("type"), &type_attribute));
if (type_attribute)
RETURN_IF_ERROR(enclosure->SetType(type_attribute->Value()));
}
return OpStatus::OK;
}
OP_STATUS RSSItemParseState::OnEndElement(const OpStringC& namespace_uri,
const OpStringC& local_name, const OpStringC& qualified_name,
StateType& next_state)
{
// This adds the content to the element just ended.
if (RSSFormat::IsTitle(qualified_name))
{
WebFeedContentElement* title = (WebFeedContentElement*)Parser().Entry()->GetTitle();
RETURN_IF_ERROR(UpdateContentElementValue(*title));
}
else if (RSSFormat::IsLink(qualified_name))
{
// Don't add a link if we allready have a guid used as link.
if (m_guid_is_permalink != YES)
{
WebFeedLinkElement* link = NULL;
RETURN_IF_ERROR(ItemLink(link));
// TODO: check that we haven't saved as id
if (!link->HasURI())
RETURN_IF_ERROR(Parser().ResolveAndUpdateLink(*link, Parser().ElementContent()));
}
}
else if (RSSFormat::IsAuthorName(qualified_name) ||
RSSFormat::IsAuthorEmail(qualified_name))
{
WebFeedPersonElement* author = Parser().Entry()->AuthorElement();
RETURN_IF_ERROR(UpdateAuthorInfo(*author));
m_have_good_author_info = TRUE;
}
else if (RSSFormat::IsWebmasterEmail(qualified_name))
{
// Only use the webmaster information if we don't have good author
// information allready.
if (!m_have_good_author_info)
{
WebFeedPersonElement* author = Parser().Entry()->AuthorElement();
RETURN_IF_ERROR(UpdateAuthorInfo(*author));
}
}
else if (RSSFormat::IsSource(qualified_name))
{
// Do we have a valid author name?
WebFeedPersonElement* author = Parser().Entry()->AuthorElement();
if (!author->HasName())
{
// Use the source, Luke.
RETURN_IF_ERROR(UpdateAuthorInfo(*author));
}
}
else if (RSSFormat::IsGUID(qualified_name))
{
RETURN_IF_ERROR(Parser().Entry()->SetGuid(Parser().ElementContent()));
// use link if we have one unless the guid has the permaLink-attribute set to yes
if (m_guid_is_permalink == YES || (m_guid_is_permalink == MAYBE && Parser().Entry()->GetPrimaryLink().IsEmpty()))
{
WebFeedLinkElement* link = 0;
RETURN_IF_ERROR(ItemLink(link));
RETURN_IF_ERROR(Parser().ResolveAndUpdateLink(*link, Parser().ElementContent()));
}
}
else if (RSSFormat::IsPublicationDate(qualified_name))
{
// try first to parse as RFC3339, some feeds use that format, and the parser is very strict
double time = OpDate::ParseRFC3339Date(Parser().ElementContent());
if (!op_isnan(time))
Parser().Entry()->SetPublicationDate(time);
else
{
// try the general date parser
double time = OpDate::ParseDate(Parser().ElementContent());
if (!op_isnan(time))
Parser().Entry()->SetPublicationDate(time);
}
}
else if (RSSFormat::IsDescription(qualified_name))
{
// Set content if we don't allready have content (thus making
// description the least valuable content element).
WebFeedContentElement* content = (WebFeedContentElement*)Parser().Entry()->GetContent();
if (!content->HasValue())
RETURN_IF_ERROR(UpdateContentElementValue(*content));
}
else if (RSSFormat::IsEncodedContent(qualified_name))
{
// Set this type of content if we don't have xml content.
if (!m_have_xml_content)
{
WebFeedContentElement* content = (WebFeedContentElement*)Parser().Entry()->GetContent();
RETURN_IF_ERROR(UpdateContentElementValue(*content));
}
}
else if (RSSFormat::IsXMLContent(qualified_name))
{
// Always set this type of content.
WebFeedContentElement* content = (WebFeedContentElement*)Parser().Entry()->GetContent();
RETURN_IF_ERROR(UpdateContentElementValue(*content));
}
else if (RSSFormat::IsItem(qualified_name))
{
// Next state depends on whether this feed has items outside of the
// channel or not.
if (Context().AsRSSContext().ItemsOutsideChannel())
next_state = StateRSSRoot;
else
next_state = StateRSSChannel;
// Add the entry we have to the list of feed items.
RETURN_IF_ERROR(Parser().AddEntryToFeed());
}
return OpStatus::OK;
}
OP_STATUS RSSItemParseState::ItemLink(WebFeedLinkElement*& link)
{
// RSS feeds only have one link element, accessed through this function
// instead of going via the more complicated interface in WebFeedEntry.
RETURN_IF_ERROR(Parser().Entry()->SetAlternateLink(link));
return OpStatus::OK;
}
// ***************************************************************************
//
// RSSImageParseState
//
// ***************************************************************************
RSSImageParseState::RSSImageParseState(WebFeedParser& parser, StateType previous_state) :
RSSParseStateBase(parser),
m_previous_state(previous_state)
{
}
OP_STATUS RSSImageParseState::OnEndElement(const OpStringC& namespace_uri, const OpStringC& local_name, const OpStringC& qualified_name, StateType& next_state)
{
if (RSSFormat::IsImage(qualified_name))
next_state = m_previous_state;
return OpStatus::OK;
}
// ***************************************************************************
//
// AtomParseStateBase
//
// ***************************************************************************
AtomParseStateBase::AtomParseStateBase(WebFeedParser& parser)
: WebFeedParseState(parser),
m_content_mode(ContentUnknown)
{
}
OP_STATUS AtomParseStateBase::UpdateContentConstruct(WebFeedContentElement& element,
const OpStringC& namespace_uri, const OpStringC& local_name,
const OpStringC& qualified_name, OpAutoStringHashTable<XMLAttributeQN>& attributes)
{
// Ignore <content> with the attribute src (we don't load the content from that
// source anyway, so).
if (AtomFormat::IsContent(qualified_name) && attributes.Contains(UNI_L("src")))
{
m_content_mode = ContentUnknown;
return OpStatus::OK;
}
// All content constructs in Atom may have a "type" attribute. If it is not
// present, we should assume the media type to be "text/plain".
if (attributes.Contains(UNI_L("type")))
{
XMLAttributeQN* attribute = NULL;
RETURN_IF_ERROR(attributes.GetData(UNI_L("type"), &attribute));
OP_ASSERT(attribute);
const uni_char* type_value = attribute->Value().CStr();
// In Atom 0.3, the type is given directly. For Atom 1.0 we must check
// for a few special values, that also affects the mode somewhat.
if (uni_stricmp(type_value, UNI_L("text")) == 0 ||
uni_stricmp(type_value, UNI_L("text/plain")) == 0)
{
RETURN_IF_ERROR(element.SetType(UNI_L("text/plain")));
m_content_mode = ContentText;
}
else if (uni_stricmp(type_value, UNI_L("html")) == 0 ||
uni_stricmp(type_value, UNI_L("text/html")) == 0)
{
RETURN_IF_ERROR(element.SetType(UNI_L("text/html")));
m_content_mode = ContentEscaped;
}
else if (uni_stricmp(type_value, UNI_L("xhtml")) == 0 ||
(uni_strni_eq_lower(type_value, UNI_L("application/"), 12) && // Starts with "application/"
uni_stri_eq(type_value + (attribute->Value().Length() - 3), "XML"))) // Ends with "xml"
{
RETURN_IF_ERROR(element.SetType(UNI_L("application/xhtml+xml")));
m_content_mode = ContentXML;
}
else
{
RETURN_IF_ERROR(element.SetType(attribute->Value()));
m_content_mode = ContentUnknown;
}
}
else
{
RETURN_IF_ERROR(element.SetType(UNI_L("text/plain")));
// Valid for 1.0 feeds, will be overwritten for 0.3.
m_content_mode = ContentText;
}
// Also determine the mode the content is encoded in. This attribute will
// normally only be present in Atom 0.3 feeds.
if (attributes.Contains(UNI_L("mode")))
{
XMLAttributeQN* attribute = 0;
RETURN_IF_ERROR(attributes.GetData(UNI_L("mode"), &attribute));
OP_ASSERT(attribute != 0);
const OpStringC& value = attribute->Value();
if (value.CompareI("xml") == 0)
m_content_mode = ContentXML;
else if (value.CompareI("escaped") == 0)
m_content_mode = ContentEscaped;
else if (value.CompareI("base64") == 0)
m_content_mode = ContentBase64;
}
else if (Context().AsAtomContext().Version() == AtomFormat::Atom03)
{
if (m_content_mode == ContentUnknown)
{
// The Atom 0.3 specifications says that the default mode for content
// constructs is to be considered as "xml". However, as a special hack
// to support feeds such as http://groovymother.com/atom.xml, we
// assume that the default mode for anything but the <content> element
// is "escaped". This is actually what Mark Pilgrim does in Universal
// Feed Parser as well.
if (AtomFormat::IsContent(qualified_name))
m_content_mode = ContentXML;
else
m_content_mode = ContentEscaped;
}
}
// We must store tags if the content is xml. We should always ignore the
// first child tag though.
if (m_content_mode == ContentXML)
RETURN_IF_ERROR(Parser().SetKeepTags(namespace_uri, local_name, TRUE));
RETURN_IF_ERROR(Parser().UpdateContentBaseURIIfNeeded(element));
return OpStatus::OK;
}
OP_STATUS AtomParseStateBase::UpdateContentConstructValue(WebFeedContentElement& element)
{
// Decide what to to with the content, based on the content mode.
switch (m_content_mode)
{
case ContentXML :
case ContentEscaped : // Unescaping has been done by the xml parser.
{
// Just store the content we have gathered.
RETURN_IF_ERROR(element.SetValue(Parser().ElementContent()));
break;
}
case ContentBase64 :
{
// Decode, then store.
unsigned char* decoded;
UINT decoded_length;
RETURN_IF_ERROR(WebFeedUtil::DecodeBase64(Parser().ElementContent(), decoded, decoded_length));
element.SetValue(decoded, decoded_length);
break;
}
case ContentText :
{
// Store the content after stripping it for spaces, newlines etc.
OpString content;
RETURN_IF_ERROR(content.Set(Parser().ElementContent()));
content.Strip(TRUE, TRUE);
RETURN_IF_ERROR(element.SetValue(content));
break;
}
default:
OP_ASSERT(!"Unknown Content Mode!");
}
return OpStatus::OK;
}
OP_STATUS AtomParseStateBase::UpdateLinkElement(WebFeedLinkElement& link,
OpAutoStringHashTable<XMLAttributeQN>& attributes)
{
// All important information about the link will be in the 'href', 'type'
// and 'title' attributes.
XMLAttributeQN* title_attribute = NULL;
OpStatus::Ignore(attributes.GetData(UNI_L("title"), &title_attribute));
if (title_attribute)
RETURN_IF_ERROR(link.SetTitle(title_attribute->Value()));
XMLAttributeQN* type_attribute = NULL;
OpStatus::Ignore(attributes.GetData(UNI_L("type"), &type_attribute));
if (type_attribute)
RETURN_IF_ERROR(link.SetType(type_attribute->Value()));
XMLAttributeQN* href_attribute = NULL;
OpStatus::Ignore(attributes.GetData(UNI_L("href"), &href_attribute));
if (href_attribute)
RETURN_IF_ERROR(Parser().ResolveAndUpdateLink(link, href_attribute->Value()));
return OpStatus::OK;
}
// ***************************************************************************
//
// AtomRootParseState
//
// ***************************************************************************
AtomRootParseState::AtomRootParseState(WebFeedParser& parser)
: AtomParseStateBase(parser)
{
}
OP_STATUS AtomRootParseState::OnStartElement(const OpStringC& namespace_uri,
const OpStringC& local_name, const OpStringC& qualified_name,
OpAutoStringHashTable<XMLAttributeQN> &attributes, StateType& next_state)
{
if (AtomFormat::IsTitle(qualified_name))
{
WebFeedContentElement* title = (WebFeedContentElement*)Parser().Feed()->GetTitle();
RETURN_IF_ERROR(UpdateContentConstruct(*title, namespace_uri, local_name, qualified_name, attributes));
}
else if (AtomFormat::IsLink(qualified_name))
{
WebFeedLinkElement* alternate_link = Parser().Feed()->FeedLink();
RETURN_IF_ERROR(HandleLinkElement(*alternate_link, attributes));
}
else if (AtomFormat::IsAuthor(qualified_name))
next_state = StateAtomAuthor;
else if (AtomFormat::IsSubtitle(qualified_name))
{
WebFeedContentElement* tagline = Parser().Feed()->Tagline();
RETURN_IF_ERROR(UpdateContentConstruct(*tagline, namespace_uri, local_name, qualified_name, attributes));
}
else if (AtomFormat::IsEntry(qualified_name))
next_state = StateAtomEntry;
return OpStatus::OK;
}
OP_STATUS AtomRootParseState::OnEndElement(const OpStringC& namespace_uri,
const OpStringC& local_name, const OpStringC& qualified_name,
StateType& next_state)
{
if (AtomFormat::IsTitle(qualified_name))
{
WebFeedContentElement* title = (WebFeedContentElement*)Parser().Feed()->GetTitle();
RETURN_IF_ERROR(UpdateContentConstructValue(*title));
}
else if (AtomFormat::IsSubtitle(qualified_name))
{
WebFeedContentElement* tagline = Parser().Feed()->Tagline();
RETURN_IF_ERROR(UpdateContentConstructValue(*tagline));
}
else if (AtomFormat::IsIcon(qualified_name))
{
Parser().Feed()->SetIcon(Parser().ElementContent());
}
/* else if (AtomFormat::IsUpdated(qualified_name))
{
RETURN_IF_ERROR(Parser().Feed()->SetDateCreated(Parser().ElementContent()));
}*/
else if (AtomFormat::IsFeedElement(qualified_name))
{
next_state = StateDone;
}
return OpStatus::OK;
}
OP_STATUS AtomRootParseState::HandleLinkElement(WebFeedLinkElement& link,
OpAutoStringHashTable<XMLAttributeQN>& attributes)
{
XMLAttributeQN* rel_attribute = NULL;
RETURN_IF_ERROR(attributes.GetData(UNI_L("rel"), &rel_attribute));
// We only want the alternate link for the feed itself. For Atom 1.0, the
// 'self' attribute might be used instead.
if (rel_attribute && rel_attribute->Value().CompareI("self") == 0)
RETURN_IF_ERROR(UpdateLinkElement(link, attributes));
else if (!rel_attribute || rel_attribute->Value().CompareI("alternate") == 0)
RETURN_IF_ERROR(UpdateLinkElement(link, attributes));
return OpStatus::OK;
}
// ***************************************************************************
//
// AtomAuthorParseState
//
// ***************************************************************************
AtomAuthorParseState::AtomAuthorParseState(WebFeedParser& parser,
WebFeedPersonElement& author, StateType previous_state)
: AtomParseStateBase(parser),
m_author(author),
m_previous_state(previous_state)
{
}
OP_STATUS AtomAuthorParseState::OnEndElement(const OpStringC& namespace_uri,
const OpStringC& local_name, const OpStringC& qualified_name,
StateType& next_state)
{
if (AtomFormat::IsAuthorName(qualified_name))
RETURN_IF_ERROR(m_author.SetName(Parser().ElementContent()));
else if (AtomFormat::IsAuthorEmail(qualified_name))
{
OpString email;
OpString name;
RETURN_IF_ERROR(Parser().ParseAuthorInformation(Parser().ElementContent(), email, name));
if (email.HasContent())
RETURN_IF_ERROR(m_author.SetEmail(email));
}
else if (AtomFormat::IsAuthor(qualified_name))
next_state = m_previous_state;
return OpStatus::OK;
}
// ***************************************************************************
//
// AtomEntryParseState
//
// ***************************************************************************
AtomEntryParseState::AtomEntryParseState(WebFeedParser& parser)
: AtomParseStateBase(parser), m_is_in_source_element(FALSE)
{
}
OP_STATUS AtomEntryParseState::Init()
{
if (!Parser().HasEntry())
RETURN_IF_ERROR(Parser().CreateEntry());
return OpStatus::OK;
}
OP_STATUS AtomEntryParseState::OnStartElement(const OpStringC& namespace_uri,
const OpStringC& local_name, const OpStringC& qualified_name,
OpAutoStringHashTable<XMLAttributeQN> &attributes, StateType& next_state)
{
if (m_is_in_source_element)
return OpStatus::OK;
if (AtomFormat::IsTitle(qualified_name))
{
WebFeedContentElement* title = (WebFeedContentElement*)Parser().Entry()->GetTitle();
RETURN_IF_ERROR(UpdateContentConstruct(*title, namespace_uri, local_name, qualified_name, attributes));
}
else if (AtomFormat::IsLink(qualified_name))
{
RETURN_IF_ERROR(HandleLinkElement(attributes));
}
else if (AtomFormat::IsSummary(qualified_name))
{
// We prefer full content, so only update if this is the first content
// we have seen.
WebFeedContentElement* content = (WebFeedContentElement*)Parser().Entry()->GetContent();
if (!content->HasType())
RETURN_IF_ERROR(UpdateContentConstruct(*content, namespace_uri, local_name, qualified_name, attributes));
}
else if (AtomFormat::IsContent(qualified_name))
{
WebFeedContentElement* content = (WebFeedContentElement*)Parser().Entry()->GetContent();
RETURN_IF_ERROR(UpdateContentConstruct(*content, namespace_uri, local_name, qualified_name, attributes));
}
else if (AtomFormat::IsAuthor(qualified_name))
next_state = StateAtomAuthor;
else if (AtomFormat::IsSource(qualified_name))
m_is_in_source_element = TRUE;
return OpStatus::OK;
}
OP_STATUS AtomEntryParseState::OnEndElement(const OpStringC& namespace_uri,
const OpStringC& local_name, const OpStringC& qualified_name,
StateType& next_state)
{
if (AtomFormat::IsSource(qualified_name))
m_is_in_source_element = FALSE;
else if (m_is_in_source_element)
return OpStatus::OK;
else if (AtomFormat::IsTitle(qualified_name))
{
WebFeedContentElement* title = (WebFeedContentElement*)Parser().Entry()->GetTitle();
RETURN_IF_ERROR(UpdateContentConstructValue(*title));
}
else if (AtomFormat::IsSummary(qualified_name))
{
// Only update the content if we don't have anything else (if we have
// anything else it's probably full content, and we prefer that).
WebFeedContentElement* content = (WebFeedContentElement*)Parser().Entry()->GetContent();
if (!content->HasValue())
RETURN_IF_ERROR(UpdateContentConstructValue(*content));
}
else if (AtomFormat::IsUpdated(qualified_name))
{
// Always update if we have a value for updated.
double time = OpDate::ParseRFC3339Date(Parser().ElementContent());
if (!op_isnan(time))
Parser().Entry()->SetPublicationDate(time);
}
else if (AtomFormat::IsPublished(qualified_name))
{
// Prefer <updated> in favor of this value.
if (Parser().Entry()->GetPublicationDate() == 0.0)
{
double time = OpDate::ParseRFC3339Date(Parser().ElementContent());
if (!op_isnan(time))
Parser().Entry()->SetPublicationDate(time);
}
}
else if (AtomFormat::IsId(qualified_name))
{
RETURN_IF_ERROR(Parser().Entry()->SetGuid(Parser().ElementContent()));
}
else if (AtomFormat::IsContent(qualified_name))
{
// Always store.
WebFeedContentElement* content = (WebFeedContentElement*)Parser().Entry()->GetContent();
RETURN_IF_ERROR(UpdateContentConstructValue(*content));
}
else if (AtomFormat::IsEntry(qualified_name))
{
next_state = StateAtomRoot;
RETURN_IF_ERROR(Parser().AddEntryToFeed());
}
return OpStatus::OK;
}
OP_STATUS AtomEntryParseState::HandleLinkElement(OpAutoStringHashTable<XMLAttributeQN> &attributes)
{
XMLAttributeQN* rel_attribute = 0;
OpStatus::Ignore(attributes.GetData(UNI_L("rel"), &rel_attribute));
// Atom 0.3 feeds must have a rel attribute, atom 1.0 assumes that
// 'alternate' is the default.
WebFeedLinkElement* new_link = 0;
if (rel_attribute == 0 || rel_attribute->Value().CompareI("alternate") == 0)
RETURN_IF_ERROR(Parser().Entry()->AddAlternateLink(new_link));
else if (rel_attribute->Value().CompareI("related") == 0)
RETURN_IF_ERROR(Parser().Entry()->AddRelatedLink(new_link));
else if (rel_attribute->Value().CompareI("via") == 0)
RETURN_IF_ERROR(Parser().Entry()->AddViaLink(new_link));
else if (rel_attribute->Value().CompareI("enclosure") == 0)
RETURN_IF_ERROR(Parser().Entry()->AddEnclosureLink(new_link));
if (new_link != 0)
RETURN_IF_ERROR(UpdateLinkElement(*new_link, attributes));
return OpStatus::OK;
}
#endif // WEBFEEDS_BACKEND_SUPPORT
|
#ifndef _DIAGRAMS_C_H
#define _DIAGRAMS_C_H
#include "diagrams_a.hpp"
#include <memory>
class D;
class C : public A {
public:
std::unique_ptr<D> m_d;
};
#endif
|
// File: table.h
// Written by Joshua Green
#ifndef TABLE_H
#define TABLE_H
//-----------------------------------------------------//
// Define DB_PROMPT to prompt user at runtime before //
// optimizing table file. //
// //
#ifndef DB_PROMPT //
#define USR_PROMPT true //
#define REQ_OPT(a) optimize() //
#else //
#define USR_PROMPT _prompt() //
#define REQ_OPT(a) _error_req_opt(#a) //
#endif //
// //
// //
//-----------------------------------------------------//
//-----------------------------------------------------//
// Define the number of digits used to store integers. //
#define INDEX_MAX_SIZE 10 //
//-----------------------------------------------------//
#include "shared/fileio/fileio.h"
#include "row.h"
#include "column.h"
#include "query.h"
#include "key.h"
#include <string>
#include <map>
#include <vector>
// -------------------------------------------------------------- CLASS TABLE --------------------------------------------------------------- //
// + initialize(string table_name) //
// - loads the table named by string and sets the tables internal variables //
// - if the table doesn't exist, a table is created //
// + close() //
// - closes the table and writes all data to file //
// + name() //
// - returns the name of the table //
// + size() //
// - returns the number of rows within the table //
// + add_column(column) //
// - inserts a column structure into the table //
// - if the table is not empty before modifying its structure, optimization() must be called before accessing row data //
// - if a default value is assigned within new_column, any old rows will inherit new_column's default value //
// - if a default value is not assigned within new_column, any old rows will inherit an empty value //
// + edit_column(column old_column, column new_column) //
// - replaces the column identically matched by old_column with the new_column //
// - if the table is not empty before modifying its structure, optimization() must be called before accessing row data //
// - any old rows inserted prior to a call to edit_column() will: //
// - be truncated to fit a smaller column size if set //
// - maintined data within the edited column if renamed //
// + delete_column(column deleted_column) //
// - deletes a column structure from the table //
// - if the table is not empty before modifying its structure, optimization() must be called before accessing row data //
// - any data from previous rows that was referenced by deleted_column will be removed //
// + get_column(string col_name) //
// - retrieves a column which matches the referenced col_name //
// - if no column referenced by col_name is found within the table an empty column is returned //
// + get_structure() //
// - returns a vector of type column which contains every column inside table //
// + set_key() //
// - sets the key column used within table for optimized searching //
// - changing the table's key requires a call to optimize() before accessing row data regardless the table being empty //
// + add_row(row inserted_row) //
// - appends inserted_row into table //
// - any column fields that are not defined within inserted_row will assume the column's default value or remain empty //
// + edit_row(row old_row, row new_row) //
// - replaces old_row with the data in new_row //
// - any column fields that are not defined within new_row will assume old_row's data //
// - returns the number of rows affected //
// - NOTES: //
// - column fields within new_row that are defined but empty will not assume old_row's data //
// - it is recommended, but not necessary, to use select() and the vector-overloaded edit_row() //
// + edit_row(vector<row> old_rows, row new_row) //
// - performs edit_row(old_rows[i], row) for each row within old_rows //
// - NOTES: //
// - it is recommended, but not necessary, to use select() and the vector-overloaded edit_row() //
// + read_row(int row_id) //
// - returns the row associated with row_id //
// - NOTES: //
// - it is not recommended to use this function standalone as row_id is subject to change after a call to optimize() //
// + delete_row(int row_id) //
// - removes the row associated with row_id from the table //
// - NOTES: //
// - it is not recommended to use this function standalone as row_id is subject to change after a call to optimize() //
// + delete_row(row) //
// - removes the row exactly matching all columns and data defined in row //
// - NOTES: //
// - this function calls the delete_row(int) if id is defined within row //
// - if id is not defined in row, //
// delete_row(row) runs a query to return all rows matching the provided row, deleting the matching rows //
// + delete_row(vector<row> rows) //
// - removes each individual row within rows from the table //
// - NOTES: //
// - it is recommended, but not necessary, to use select() to acquire the rows vector //
// + select(query) //
// - returns a vector of rows which is descibred by query //
// - NOTES: //
// - it is recommended, but not necessary, to use select() for acquisition of all row vectors //
// + optimize() //
// - rewrites the table data, structure, and key files to reflect any data and structure changes //
// - orders key entries to reflect optimized ordering //
// - NOTES: //
// - a call to optimize() is required after any structual changes to the table //
// ------------------------------------------------------------------------------------------------------------------------------------------ //
class table {
private:
bool _initialized;
bool _require_optimize;
fileio* _fstruct;
fileio* _fdata;
fileio* _fkeys;
std::string _name;
int _row_count; // contains number of rows (including empty/deleted) in the file.
int _deleted_row_count; // semi-cosmetic variable used only in size().
int _row_size;
column _key; // _key is the table's key column (ie: column("id", 20)).
std::vector<key_entry> _keys; // _keys contains the indexed rows (key_entry),
// sorted (0 to 9 to a to z) by the row's column value
bool _load_structure();
void _load_keys(); // loads keys directly from key file. key file is only updated at optimize() and close().
void _write_structure();
void _calc_row_size();
void _calc_rows();
void _calc_deleted_rows(); // heavy resourced function used only at initialize() to set initial _deleted_row_count.
void _mark_size(std::string &data);
void _write_keys();
bool _write_row(std::map<std::string, std::string>&, // writes a row into _fdata at last _fdata.seek()'ed position.
bool enforce_flags=true); // and only writes columns found within _Tstruct.
// ** modified the provided map to match the data written (ie. data changed via column flags)
bool _prompt();
void _error_req_opt(std::string);
std::vector<column> _Tstruct;
public:
table();
~table();
bool initialize(std::string filename);
void close();
std::string name();
long int size(); // returns the total number of rows in the table
column add_column(const column &new_col);
column edit_column(const column &old_col, column &new_col);
void delete_column(const column &col);
column get_column(const std::string &col_name) const;
std::vector<column> get_structure() const;
void set_key(const column &key);
column get_key();
row add_row(const row&);
int edit_row(const row &old_row, row new_row);
int edit_row(const std::vector<row> &, const row &new_row);
row read_row(long int row_id);
void delete_row(long int row_id);
void delete_row(const row&);
void delete_row(const std::vector<row>&);
std::vector<row> select(const query&);
void optimize();
// Debug Functions:
void print_structure();
};
#endif
|
/*
Petar 'PetarV' Velickovic
Algorithm: Knuth-Morris-Pratt
*/
#include <stdio.h>
#include <math.h>
#include <string.h>
#include <iostream>
#include <vector>
#include <list>
#include <string>
#include <algorithm>
#include <queue>
#include <stack>
#include <set>
#include <map>
#include <complex>
#define MAX_N 1000001
using namespace std;
typedef long long lld;
int n, m;
string needle, haystack;
int P[MAX_N];
vector<int> matches;
//Knuth-Morris-Pratt algoritam za string matching
//Slozenost: O(N + M)
inline void KMP()
{
for (int i=0;i<m;i++) P[i] = -1;
for (int i=0, j=-1;i<m;)
{
while (j > -1 && needle[i] != needle[j]) j = P[j];
i++;
j++;
P[i] = j;
}
for (int i=0, j=0;i<n;)
{
while (j > -1 && haystack[i] != needle[j]) j = P[j];
i++;
j++;
if (j == m)
{
matches.push_back(i - m);
j = P[j];
}
}
}
int main()
{
n = 6, m = 2;
haystack = "abcabc";
needle = "bc";
KMP();
for (int i=0;i<matches.size();i++) printf("%d ",matches[i]);
printf("\n");
return 0;
}
|
/*
warriors.cpp
Purpose: Main executable for whatever this Warriors thing is. Controls setup
/teardown of game as well as game loop.
@author Jeremy Elkayam
*/
#include <SFML/Graphics.hpp>
#include <SFML/Audio.hpp>
#include <iostream>
#include <memory>
#include "human_view.hpp"
#include "logic.hpp"
#include "text_loader.hpp"
#include "resource_manager.hpp"
#include "input_manager.hpp"
using std::shared_ptr;
using std::make_shared;
using std::mt19937;
using std::chrono::high_resolution_clock;
int main(int argc, char** argv)
{
TextLoader text_loader;
ResourceManager resource_manager(text_loader);
InputManager input_manager((unsigned)text_loader.get_integer("IDS_MAX_PLAYERS"));
//set up game componentss
Logic logic(text_loader, resource_manager, input_manager);
// create main window
sf::RenderWindow window(
sf::VideoMode(
(unsigned int)text_loader.get_integer("IDS_WINDOW_X"),
(unsigned int)text_loader.get_integer("IDS_WINDOW_Y"),
(unsigned int)text_loader.get_integer("IDS_WINDOW_PDEPTH")),
text_loader.get_string("IDS_W_NAME"),
sf::Style::Resize | sf::Style::Close);
//set up rendering
HumanView human_view(logic, text_loader);
//enable titlebar & close options
sf::Clock clock;
// start main loop
while(window.isOpen())
{
//Reset clock and track elapsed time since last loop.
float s_elapsed=clock.restart().asSeconds();
if(window.hasFocus())
{
sf::Event event;
while(window.pollEvent(event))
{
human_view.handle_event(window, event);
}
//update renderer and logic
logic.update(s_elapsed);
human_view.update(window);
}
}
return 0;
}
|
#pragma once
#include "GameNode.h"
class MainGame23 : public GameNode
{
private:
bool isDebug;
char str[128];
public:
MainGame23();
~MainGame23();
HRESULT Init() override;
void Release() override;
void Update() override;
void Render() override;
};
|
// Spiral Oder Matrix Traversal
/*
@ row_start + 1
@ column_end -1
@ row_end - 1
@ column_start + 1
# row_start <= row_end
# column_start <= colunm_end
*/
#include<iostream>
using namespace std;
int main(){
int n,m;
cout<<"Please enter numbers of rows: ";
cin>>n;
cout<<"Please enter number of columns :";
cin>>m;
// taking input in the 2d array
int a[n][m];
for(int i=0; i<n; i++){
for(int j=0; j<m; j++){
cin>>a[n][m];
}
}
// Spiral order print
int row_start = 0;
int row_end = n-1;
int column_start = 0;
int column_end = m-1;
while(row_start <= row_end && column_start <= column_end){
// for row_start
for(int col = column_start; col<=column_end; col++){
cout<<a[row_start][col]<<" ";
}
row_start ++;
// for colums end
for(int row = row_start; row<=row_end; row++){
cout<<a[row][column_end]<<" ";
}
column_end --;
// for row_end
for(int col = column_end; col>= column_start; col--){
cout<<a[row_end][col]<<" ";
}
row_end --;
// for column start
for(int row = row_end; row >= row_start; row--){
cout<<a[row][column_start];
}
column_start ++;
}
return 0;
}
|
// Created on: 1993-01-13
// Created by: CKY / Contract Toubro-Larsen ( Deepak PRABHU )
// Copyright (c) 1993-1999 Matra Datavision
// Copyright (c) 1999-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#ifndef _IGESDefs_AttributeDef_HeaderFile
#define _IGESDefs_AttributeDef_HeaderFile
#include <Standard.hxx>
#include <Standard_Type.hxx>
#include <Standard_Integer.hxx>
#include <TColStd_HArray1OfInteger.hxx>
#include <TColStd_HArray1OfTransient.hxx>
#include <IGESData_IGESEntity.hxx>
class TCollection_HAsciiString;
class IGESDefs_HArray1OfHArray1OfTextDisplayTemplate;
class IGESGraph_TextDisplayTemplate;
class Standard_Transient;
class IGESDefs_AttributeDef;
DEFINE_STANDARD_HANDLE(IGESDefs_AttributeDef, IGESData_IGESEntity)
//! defines IGES Attribute Table Definition Entity,
//! Type <322> Form [0, 1, 2] in package IGESDefs.
//! This is class is used to support the concept of well
//! defined collection of attributes, whether it is a table
//! or a single row of attributes.
class IGESDefs_AttributeDef : public IGESData_IGESEntity
{
public:
Standard_EXPORT IGESDefs_AttributeDef();
Standard_EXPORT void Init (const Handle(TCollection_HAsciiString)& aName, const Standard_Integer aListType, const Handle(TColStd_HArray1OfInteger)& attrTypes, const Handle(TColStd_HArray1OfInteger)& attrValueDataTypes, const Handle(TColStd_HArray1OfInteger)& attrValueCounts, const Handle(TColStd_HArray1OfTransient)& attrValues, const Handle(IGESDefs_HArray1OfHArray1OfTextDisplayTemplate)& attrValuePointers);
//! Returns True if a Table Name is defined
Standard_EXPORT Standard_Boolean HasTableName() const;
//! returns the Attribute Table name, or comment
//! (default = null, no name : seeHasTableName)
Standard_EXPORT Handle(TCollection_HAsciiString) TableName() const;
//! returns the Attribute List Type
Standard_EXPORT Standard_Integer ListType() const;
//! returns the Number of Attributes
Standard_EXPORT Standard_Integer NbAttributes() const;
//! returns the num'th Attribute Type
//! raises exception if num <= 0 or num > NbAttributes()
Standard_EXPORT Standard_Integer AttributeType (const Standard_Integer num) const;
//! returns the num'th Attribute value data type
//! raises exception if num <= 0 or num > NbAttributes()
Standard_EXPORT Standard_Integer AttributeValueDataType (const Standard_Integer num) const;
//! returns the num'th Attribute value count
//! raises exception if num <= 0 or num > NbAttributes()
Standard_EXPORT Standard_Integer AttributeValueCount (const Standard_Integer num) const;
//! returns false if Values are defined (i.e. for Form = 1 or 2)
Standard_EXPORT Standard_Boolean HasValues() const;
//! returns false if TextDisplays are defined (i.e. for Form = 2)
Standard_EXPORT Standard_Boolean HasTextDisplay() const;
Standard_EXPORT Handle(IGESGraph_TextDisplayTemplate) AttributeTextDisplay (const Standard_Integer AttrNum, const Standard_Integer PointerNum) const;
//! Returns the List of Attributes <AttrNum>, as a Transient.
//! Its effective Type depends of the Type of Attribute :
//! HArray1OfInteger for Integer, Logical(0-1),
//! HArray1OfReal for Real, HArray1OfHSaciiString for String,
//! HArray1OfIGESEntity for Entity (Pointer)
//! See methods AttributeAs... for an accurate access
Standard_EXPORT Handle(Standard_Transient) AttributeList (const Standard_Integer AttrNum) const;
//! Returns Attribute Value <AttrNum, rank ValueNum> as an Integer
//! Error if Indices out of Range, or no Value defined, or not an Integer
Standard_EXPORT Standard_Integer AttributeAsInteger (const Standard_Integer AttrNum, const Standard_Integer ValueNum) const;
//! Returns Attribute Value <AttrNum, rank ValueNum> as a Real
//! Error if Indices out of Range, or no Value defined, or not a Real
Standard_EXPORT Standard_Real AttributeAsReal (const Standard_Integer AttrNum, const Standard_Integer ValueNum) const;
//! Returns Attribute Value <AttrNum, rank ValueNum> as an Integer
Standard_EXPORT Handle(TCollection_HAsciiString) AttributeAsString (const Standard_Integer AttrNum, const Standard_Integer ValueNum) const;
//! Returns Attribute Value <AttrNum, rank ValueNum> as an Entity
//! Error if Indices out of Range, or no Value defined, or not a Entity
Standard_EXPORT Handle(IGESData_IGESEntity) AttributeAsEntity (const Standard_Integer AttrNum, const Standard_Integer ValueNum) const;
//! Returns Attribute Value <AttrNum, rank ValueNum> as a Boolean
//! Error if Indices out of Range, or no Value defined, or not a Logical
Standard_EXPORT Standard_Boolean AttributeAsLogical (const Standard_Integer AttrNum, const Standard_Integer ValueNum) const;
DEFINE_STANDARD_RTTIEXT(IGESDefs_AttributeDef,IGESData_IGESEntity)
protected:
private:
Handle(TCollection_HAsciiString) theName;
Standard_Integer theListType;
Handle(TColStd_HArray1OfInteger) theAttrTypes;
Handle(TColStd_HArray1OfInteger) theAttrValueDataTypes;
Handle(TColStd_HArray1OfInteger) theAttrValueCounts;
Handle(TColStd_HArray1OfTransient) theAttrValues;
Handle(IGESDefs_HArray1OfHArray1OfTextDisplayTemplate) theAttrValuePointers;
};
#endif // _IGESDefs_AttributeDef_HeaderFile
|
/* -*- Mode: c++; tab-width: 4; c-basic-offset: 4 -*-
*
* Copyright (C) 1995-2008 Opera Software AS. All rights reserved.
*
* This file is part of the Opera web browser.
* It may not be distributed under any circumstances.
*
* @author Patricia Aas (psmaas)
*/
#include "core/pch.h"
#include "platforms/viewix/FileHandlerManager.h"
#include "platforms/viewix/src/input_files/KDErcFile.h"
#include "platforms/viewix/src/FileHandlerManagerUtilities.h"
#include "modules/util/opfile/opfile.h"
/***********************************************************************************
** ParseDefaultFile
**
**
**
** FOR KDE : /etc/kderc
***********************************************************************************/
OP_STATUS KDErcFile::ParseInternal(OpFile & file)
{
//-----------------------------------------------------
// Parameter checking:
//-----------------------------------------------------
//File pointer cannot be null
OP_ASSERT(file.IsOpen());
if(!file.IsOpen())
return OpStatus::ERR;
//-----------------------------------------------------
//Split file into lines - only if smaller than 10MB
UINT32 max_size = 10000000;
OpAutoVector<OpString> list;
FileHandlerManagerUtilities::FileToLineVector(&file, list, max_size);
OP_STATUS status = OpStatus::OK;
OpString tag;
for(UINT32 i = 0; i < list.GetCount(); i++)
{
OpString* line = list.Get(i);
line->Strip();
// Seperator line :
if(line->IsEmpty())
{
continue;
}
if(ParsedTag(*line, tag, status))
continue;
RETURN_IF_ERROR(status);
OpAutoVector<OpString> items;
FileHandlerManagerUtilities::SplitString(items, *line, '=');
if(items.GetCount() == 2)
{
items.Get(0)->Strip();
items.Get(1)->Strip();
OpString * key = items.Get(0);
OpString * value = items.Get(1);
if(uni_strncmp(key->CStr(), UNI_L("prefixes"), 8) == 0)
{
m_dir.Set(value->CStr());
}
}
}
return status;
}
BOOL KDErcFile::ParsedTag(OpString & line,
OpString & tag,
OP_STATUS & status)
{
status = OpStatus::OK;
if (!tag.Reserve(256))
{
status = OpStatus::ERR_NO_MEMORY;
return FALSE;
}
if (uni_sscanf(line.CStr(), UNI_L("[%256s]"), tag.CStr()) == 1)
{
return TRUE;
}
return FALSE;
}
|
//
// main.cpp
// EX05_05
//
// Created by Eben Schumann on 11/1/16.
// Copyright © 2016 Eben Schumann. All rights reserved.
//
#include <iostream>
#include <string>
#include <vector>
#include "Account.hpp"
#include "Transaction.hpp"
using namespace std;
int main()
{
Account A1;
Transaction T1;
vector<Transaction> Transactions; // Creates a vector
int intInput = 0; // Declares a variable for user input
double doubleInput = 0; // Declares a variable for user input
string stringInput = ""; // Declares a variable for user input
cout << "You are making a new accout at the bank." << endl;
cout << "What is your ID number?" << endl;
cin >> intInput; // Get input from the user
A1.setID(intInput); // Sends the user input to the "Account" class to set up the account information
cout << "\nHow much money are you going to put into your new bank account? " << endl;
cin >> doubleInput; // Get input from the user
A1.setBalance(doubleInput); // Sends the user input to the "Account" class to set up the account information
cout << "\nAt which interest rate would you like you account to be on?" << endl;
cin >> doubleInput; // Get input from the user
A1.setAnnualInterestRate(doubleInput); // Sends the user input to the "Account" class to set up the account information
cout << "Your cuurent information is:" << endl;
cout << "You ID is: " << A1.getID() << endl; // Outputs to the user their ID number
cout << "You balance is currently: " << A1.getBalance() << endl; // Outputs to the user the current amount of money they have in their account
cout << "Your monthly interest rate is : " << A1.getMonthlyInterestRate() << endl; // outputs to the user the monthly interest rate that their account is under
int intInputW = 0; // Declares a variable for user input
double doubleInputW = 0; // Declares a variable for user input
string stringInputW = ""; // Declares a variable for user input
cout << "\nHow much money do you want to remove from your account?" << endl;
cin >> doubleInputW; // Get input from the user
A1.withdraw(doubleInputW); // Sends the user input to the "Account" class to set up the account information
cout << "\nWhy did you withdrawl from your account?" << endl;
cin >> stringInputW; // Get input from the user
A1.setDescription(stringInputW); // Sends the user input to the "Account" class to set up the account information
//cout << "You balance is currently: " << A1.getBalance() << endl; // Outputs to the user the current amount of money they have in their account
int intInputD = 0; // Declares a variable for user input
double doubleInputD = 0; // Declares a variable for user input
string stringInputD = ""; // Declares a variable for user input
cout << "\nHow much money do you want to diposit into your account?" << endl;
cin >> doubleInputD; // Get input from the user
A1.disposit(doubleInputD); // Sends the user input to the "Account" class to set up the account information
cout << "\nWhy did you put money into your account?" << endl;
cin >> stringInputD; // Get input from the user
A1.setDescription(stringInputD); // Sends the user input to the "Account" class to set up the account information
cout << "You balance is currently: " << A1.getBalance() << endl; // Outputs to the user the current amount of money they have in their account
//T1.displayTransactions();
cout << endl; // Creates a empty line
return 0;
}
|
/* -*- Mode: c++; tab-width: 4; indent-tabs-mode: t; c-basic-offset: 4 -*-
*
* Copyright (C) 1995-2007 Opera Software ASA. All rights reserved.
*
* This file is part of the Opera web browser.
* It may not be distributed under any circumstances.
*/
// ---------------------------------------------------------------------------------
#include "core/pch.h"
#include "modules/util/adt/opvector.h"
#include "modules/util/opswap.h"
// ---------------------------------------------------------------------------------
OpGenericVector::OpGenericVector(UINT32 stepsize)
: m_size(0),
m_items(NULL),
m_count(0),
m_step(stepsize),
m_min_step(stepsize)
{
}
OpGenericVector::~OpGenericVector()
{
OP_DELETEA(m_items);
}
void OpGenericVector::Clear()
{
OP_DELETEA(m_items);
m_items = NULL;
m_size = 0;
m_count = 0;
}
void OpGenericVector::Empty()
{
m_count = 0;
}
OP_STATUS
OpGenericVector::DuplicateOf(const OpGenericVector& vec)
{
void** new_items = NULL;
if (vec.m_size > 0)
{
new_items = OP_NEWA(void*, vec.m_size);
if (new_items == NULL)
return OpStatus::ERR_NO_MEMORY;
op_memcpy(new_items, vec.m_items, vec.m_size * sizeof(void*));
}
OP_DELETEA(m_items);
m_items = new_items;
m_size = vec.m_size;
m_count = vec.m_count;
m_step = vec.m_step;
return OpStatus::OK;
}
OP_STATUS
OpGenericVector::Replace(UINT32 idx, void* item)
{
OP_ASSERT(idx < m_count);
if (idx >= m_count)
{
return OpStatus::ERR;
}
m_items[idx] = item;
return OpStatus::OK;
}
OP_STATUS
OpGenericVector::Insert(UINT32 idx, void* item)
{
if (idx > m_count)
{
idx = m_count;
}
if (m_items == NULL)
{
RETURN_IF_ERROR(Init());
}
if (m_count >= m_size)
{
return GrowInsert(idx, item);
}
NormalInsert(idx, item);
return OpStatus::OK;
}
OP_STATUS
OpGenericVector::Add(void* item)
{
return Insert(m_count, item);
}
OP_STATUS
OpGenericVector::RemoveByItem(void* item)
{
INT32 idx = Find(item);
if (idx == -1)
{
return OpStatus::ERR;
}
Remove(idx);
return OpStatus::OK;
}
void*
OpGenericVector::Remove(UINT32 idx, UINT32 count)
{
OP_ASSERT(idx + count <= m_count);
if (idx >= m_count)
{
return NULL;
}
if (m_size > m_step && m_count + m_step - count < m_size)
{
return ShrinkRemove(idx, count);
}
else
{
return NormalRemove(idx, count);
}
}
INT32
OpGenericVector::Find(void* item) const
{
if (m_items)
{
for (UINT32 idx = 0; idx < m_count; idx++)
{
if (m_items[idx] == item)
{
return idx;
}
}
}
return -1;
}
void*
OpGenericVector::Get(UINT32 idx) const
{
if (idx >= m_count)
{
return NULL;
}
return m_items[idx];
}
OP_STATUS
OpGenericVector::Init()
{
m_items = OP_NEWA(void*, m_step);
if (m_items == NULL)
{
return OpStatus::ERR_NO_MEMORY;
}
m_size = m_step;
return OpStatus::OK;
}
OP_STATUS
OpGenericVector::GrowInsert(UINT32 insertidx, void* item)
{
OP_ASSERT(insertidx <= m_count);
// auto-increase m_step
UINT32 new_step = m_step * 2;
size_t new_size = m_size + new_step;
void** new_items = OP_NEWA(void*, new_size);
if (new_items == NULL)
{
return OpStatus::ERR_NO_MEMORY;
}
m_step = new_step;
m_size = new_size;
// Copy elements before item.
op_memcpy(&new_items[0], &m_items[0], insertidx * sizeof(void*));
// Insert item.
new_items[insertidx] = item;
// Copy elements after item.
op_memcpy(&new_items[insertidx + 1], &m_items[insertidx], (m_count - insertidx) * sizeof(void*));
OP_DELETEA(m_items);
m_count++;
m_items = new_items;
return OpStatus::OK;
}
void
OpGenericVector::NormalInsert(UINT32 insertidx, void* item)
{
OP_ASSERT(insertidx <= m_count);
if (insertidx < m_count)
{
// Make room for insert.
op_memmove(&m_items[insertidx + 1], &m_items[insertidx], (m_count - insertidx) * sizeof(void*));
}
m_items[insertidx] = item;
m_count++;
}
void*
OpGenericVector::ShrinkRemove(UINT32 removeidx, UINT32 count)
{
OP_ASSERT(removeidx + count <= m_count);
void* remove_item = m_items[removeidx];
size_t new_size = ((m_count + m_step - count) / m_step) * m_step;
OP_ASSERT(new_size > 0);
void** new_items = OP_NEWA(void*, new_size);
if (new_items == NULL)
{
// We do not need to shrink things, if we fail, just use the old vector.
return NormalRemove(removeidx, count);
}
m_count -= count;
// Copy all items before removeidx.
op_memcpy(&new_items[0], &m_items[0], removeidx * sizeof(void*));
// Copy all items after removeidx.
op_memcpy(&new_items[removeidx], &m_items[removeidx + count], (m_count - removeidx) * sizeof(void*));
OP_DELETEA(m_items);
m_size = new_size;
m_items = new_items;
// auto-decrease m_step
if (m_step > m_min_step)
{
m_step /= 2;
}
return remove_item;
}
void*
OpGenericVector::NormalRemove(UINT32 removeidx, UINT32 count)
{
OP_ASSERT(removeidx + count <= m_count);
void* remove_item = m_items[removeidx];
m_count -= count;
if (removeidx < m_count)
{
op_memmove(&m_items[removeidx], &m_items[removeidx + count], (m_count - removeidx) * sizeof(void*));
}
return remove_item;
}
void
OpGenericVector::QSort(int (*cmp)(const void **, const void **))
{
op_qsort(m_items, GetCount(), sizeof(void **),
reinterpret_cast<int (*)(const void *, const void *)>(cmp));
}
void
OpGenericVector::Swap(OpGenericVector* v)
{
op_swap(this->m_size, v->m_size);
op_swap(this->m_items, v->m_items);
op_swap(this->m_count, v->m_count);
}
#if defined ADVANCED_OPINT32VECTOR || defined ADVANCED_OPVECTOR
static INT32 MergeSort(void** array, void** temp_array, INT32 left, INT32 right)
{
INT32 left_end;
INT32 temp_pos;
INT32 center = (left + right) / 2;
INTPTR last;
INT32 shift;
if (center > left)
{
if ((shift = MergeSort(temp_array, array, left, center)) <= center)
{
op_memmove(temp_array + shift, temp_array + center + 1, (right - center) * sizeof(void *));
op_memmove(array + shift, array + center + 1, (right - center) * sizeof(void *));
right -= center + 1 - shift;
center = shift - 1;
}
right = MergeSort(temp_array, array, center + 1, right) - 1;
}
left_end = center;
temp_pos = left;
++center;
if (left > 0)
last = (INTPTR)(array[left - 1]);
else {
if ((INTPTR)(array[left]) == (INTPTR)(array[center])) // just init to some value
last = (INTPTR)(array[left]) - 1;
else last = (INTPTR)(array[left]) < (INTPTR)(array[center]) ? (INTPTR)(array[center]) : (INTPTR)(array[left]);
}
while (left <= left_end && center <= right)
{
if ((INTPTR)(array[left]) < (INTPTR)(array[center]))
{
if ((INTPTR)(array[left]) != last)
last = INTPTR(temp_array[temp_pos++] = array[left++]);
else ++left;
}
else {
if ((INTPTR)(array[center]) != last)
last = INTPTR(temp_array[temp_pos++] = array[center++]);
else ++center;
}
}
while (left <= left_end)
{
if ((INTPTR)(array[left]) != last)
last = INTPTR(temp_array[temp_pos++] = array[left++]);
else ++left;
}
while (center <= right)
{
if ((INTPTR)(array[center]) != last)
last = INTPTR(temp_array[temp_pos++] = array[center++]);
else ++center;
}
return temp_pos;
}
// based on johan's OpGenericBinaryTree with some optimizations
OP_STATUS OpINT32Vector::Sort()
{
int count;
if (m_count <= 1)
return OpStatus::OK;
void** temp_array = OP_NEWA(void*, m_count);
if (!temp_array)
return OpStatus::ERR_NO_MEMORY;
op_memcpy(temp_array, m_items, m_count * sizeof(void *));
count = MergeSort(temp_array, m_items, 0, m_count - 1);
Remove(count, m_count - count);
OP_DELETEA(temp_array);
return OpStatus::OK;
}
// returns either a position of item, if found, or position where to insert
UINT32 OpINT32Vector::Search(INT32 item, UINT32 start, UINT32 end) const
{
int n2;
while (end > start)
{
n2 = (end - start) / 2;
if (Get(start + n2) < item)
start = start + n2 + 1;
else
end = start + n2;
}
return start;
}
OP_STATUS OpINT32Vector::Add(const OpINT32Vector &vec)
{
void **dst;
UINT32 i, j, pos, len;
pos = 0;
if (m_size > m_count + vec.m_count)
{
i = 0;
while (i < vec.m_count)
{
pos = Search((INTPTR)(vec.m_items[i]), pos, m_count);
while (pos < m_count && (INTPTR)(m_items[pos]) == (INTPTR)(vec.m_items[i])) // remove duplicities
{
if (++i >= vec.m_count)
return OpStatus::OK;
++pos;
}
if (pos >= m_count)
break;
if ((INTPTR)(m_items[pos]) < (INTPTR)(vec.m_items[i]))
continue;
len = 1;
while (i + len < vec.m_count && (INTPTR)(m_items[pos]) > (INTPTR)(vec.m_items[i + len]))
++len;
op_memmove(m_items + pos + len, m_items + pos, (m_count - pos) * sizeof(void *));
op_memcpy(m_items + pos, vec.m_items + i, len * sizeof(void *));
m_count += len;
i += len;
pos += len;
}
if (i < vec.m_count && (INTPTR)(vec.m_items[i]) == (INTPTR)(m_items[m_count - 1]))
++i;
if (i < vec.m_count)
{
op_memcpy(m_items + m_count, vec.m_items + i, (vec.m_count - i) * sizeof(void *));
m_count += (vec.m_count - i);
}
return OpStatus::OK;
}
if ((dst = OP_NEWA(void *, m_count + vec.m_count)) == NULL)
return OpStatus::ERR_NO_MEMORY;
m_size = m_count + vec.m_count;
i = 0;
j = 0;
pos = 0;
while (i < m_count && j < vec.m_count)
{
if ((INTPTR)(m_items[i]) == (INTPTR)(vec.m_items[j]))
{
dst[pos++] = m_items[i++];
++j;
}
else if ((INTPTR)(m_items[i]) < (INTPTR)(vec.m_items[j]))
dst[pos++] = m_items[i++];
else dst[pos++] = vec.m_items[j++];
}
while (i < m_count)
dst[pos++] = m_items[i++];
while (j < vec.m_count)
dst[pos++] = vec.m_items[j++];
if (m_items != NULL)
OP_DELETEA(m_items);
m_items = dst;
m_count = pos;
return OpStatus::OK;
}
OP_STATUS OpINT32Vector::Add(OpINT32Vector &result, const OpINT32Vector &vec1, const OpINT32Vector &vec2)
{
UINT32 i,j;
if (result.m_size < vec1.m_size + vec2.m_size)
{
void **dst;
if ((dst = OP_NEWA(void *, vec1.m_count + vec2.m_count)) == NULL)
return OpStatus::ERR_NO_MEMORY;
result.m_size = vec1.m_count + vec2.m_count;
if (result.m_items != NULL)
OP_DELETEA(result.m_items);
result.m_items = dst;
}
i = 0;
j = 0;
result.m_count = 0;
while (i < vec1.m_count && j < vec2.m_count)
{
if ((INTPTR)(vec1.m_items[i]) == (INTPTR)(vec2.m_items[j]))
{
result.m_items[result.m_count++] = vec1.m_items[i++];
++j;
}
else if ((INTPTR)(vec1.m_items[i]) < (INTPTR)(vec2.m_items[j]))
result.m_items[result.m_count++] = vec1.m_items[i++];
else result.m_items[result.m_count++] = vec2.m_items[j++];
}
while (i < vec1.m_count)
result.m_items[result.m_count++] = vec1.m_items[i++];
while (j < vec2.m_count)
result.m_items[result.m_count++] = vec2.m_items[j++];
return OpStatus::OK;
}
#ifdef ADVANCED_OPINT32VECTOR
OP_STATUS OpINT32Vector::Subtract(const OpINT32Vector &vec)
#else
OP_STATUS OpINT32Vector::Substract(const OpINT32Vector &vec)
#endif
{
UINT32 i, dpos1, dpos2, pos, orig_count;
if (m_count == 0 || vec.m_count == 0)
return OpStatus::OK;
dpos1 = 0;
i = (UINT32)-1;
do {
if (++i >= vec.m_count)
return OpStatus::OK; // nothing to delete
dpos1 = Search((INTPTR)(vec.m_items[i]), dpos1, m_count);
} while (dpos1 >= m_count || (INTPTR)(m_items[dpos1]) != (INTPTR)(vec.m_items[i]));
pos = dpos1;
orig_count = m_count;
UINT32 dlen;
for (;;)
{
dlen = 1;
while (dpos1 + dlen < orig_count && i + 1 < vec.m_count &&
(INTPTR)(m_items[dpos1 + dlen]) == (INTPTR)(vec.m_items[i + 1]))
{
++i;
++dlen;
}
if (dpos1 + dlen >= orig_count)
{
m_count = pos;
Refit();
return OpStatus::OK;
}
if (i >= vec.m_count)
break;
dpos2 = dpos1 + dlen;
do {
if (++i >= vec.m_count)
break;
dpos2 = Search((INTPTR)(vec.m_items[i]), dpos2, orig_count);
} while (dpos2 >= m_count || (INTPTR)(m_items[dpos2]) != (INTPTR)(vec.m_items[i]));
if (i >= vec.m_count)
break;
if ((dpos2 - dpos1 - dlen) > 0)
{
op_memmove(m_items + pos, m_items + dpos1 + dlen, (dpos2 - dpos1 - dlen) * sizeof(void *));
pos += (dpos2 - dpos1 - dlen);
}
dpos1 = dpos2;
m_count -= dlen;
}
op_memmove(m_items + pos, m_items + dpos1 + dlen, (orig_count - dpos1 - dlen) * sizeof(void *));
m_count -= dlen;
Refit();
return OpStatus::OK;
}
#ifdef ADVANCED_OPINT32VECTOR
OP_STATUS OpINT32Vector::Subtract(OpINT32Vector &result, const OpINT32Vector &vec1, const OpINT32Vector &vec2)
#else
OP_STATUS OpINT32Vector::Substract(OpINT32Vector &result, const OpINT32Vector &vec1, const OpINT32Vector &vec2)
#endif
{
UINT32 i,j;
if (result.m_size < vec1.m_size)
{
void **dst;
if ((dst = OP_NEWA(void *, vec1.m_count)) == NULL)
return OpStatus::ERR_NO_MEMORY;
result.m_size = vec1.m_count;
if (result.m_items != NULL)
OP_DELETEA(result.m_items);
result.m_items = dst;
}
i = 0;
j = 0;
result.m_count = 0;
while (i < vec1.m_count && j < vec2.m_count)
{
if ((INTPTR)(vec1.m_items[i]) == (INTPTR)(vec2.m_items[j]))
{
++i;
++j;
}
else if ((INTPTR)(vec1.m_items[i]) < (INTPTR)(vec2.m_items[j]))
result.m_items[result.m_count++] = vec1.m_items[i++];
else ++j;
}
while (i < vec1.m_count)
result.m_items[result.m_count++] = vec1.m_items[i++];
result.Refit();
return OpStatus::OK;
}
OP_STATUS OpINT32Vector::Intersect(const OpINT32Vector &vec)
{
UINT32 i, dpos1, dpos2, dlen, pos, orig_count;
if (m_count == 0 || vec.m_count == 0)
{
Clear();
return OpStatus::OK;
}
dpos1 = (UINT32)-1;
i = 0;
do {
if (++dpos1 >= m_count)
return OpStatus::OK;
i = vec.Search((INTPTR)(m_items[dpos1]), i, vec.m_count);
} while (i < vec.m_count && (INTPTR)(m_items[dpos1]) == (INTPTR)(vec.m_items[i]));
pos = dpos1;
orig_count = m_count;
for (;;)
{
dlen = 0;
do {
if (dpos1 + ++dlen >= orig_count)
break;
i = vec.Search((INTPTR)(m_items[dpos1 + dlen]), i, vec.m_count);
} while (i < vec.m_count && (INTPTR)(m_items[dpos1 + dlen]) != (INTPTR)(vec.m_items[i]));
if (dpos1 + dlen >= orig_count || i >= vec.m_count)
{
m_count = pos;
Refit();
return OpStatus::OK;
}
dpos2 = dpos1 + dlen;
do {
if (++dpos2 >= orig_count)
break;
i = vec.Search((INTPTR)(m_items[dpos2]), i, vec.m_count);
} while (i < vec.m_count && (INTPTR)(m_items[dpos2]) == (INTPTR)(vec.m_items[i]));
if (dpos2 >= orig_count)
break;
op_memmove(m_items + pos, m_items + dpos1 + dlen, (dpos2 - dpos1 - dlen) * sizeof(void *));
pos += (dpos2 - dpos1 - dlen);
dpos1 = dpos2;
m_count -= dlen;
}
op_memmove(m_items + pos, m_items + dpos1 + dlen, (orig_count - dpos1 - dlen) * sizeof(void *));
m_count -= dlen;
Refit();
return OpStatus::OK;
}
OP_STATUS OpINT32Vector::Intersect(OpINT32Vector &result, const OpINT32Vector &vec1, const OpINT32Vector &vec2)
{
UINT32 i,j;
if (result.m_size < vec1.m_size)
{
void **dst;
if ((dst = OP_NEWA(void *, vec1.m_count)) == NULL)
return OpStatus::ERR_NO_MEMORY;
result.m_size = vec1.m_count;
if (result.m_items != NULL)
OP_DELETEA(result.m_items);
result.m_items = dst;
}
i = 0;
j = 0;
result.m_count = 0;
while (i < vec1.m_count && j < vec2.m_count)
{
if ((INTPTR)(vec1.m_items[i]) == (INTPTR)(vec2.m_items[j]))
{
result.m_items[result.m_count++] = vec1.m_items[i++];
++j;
}
else if ((INTPTR)(vec1.m_items[i]) < (INTPTR)(vec2.m_items[j]))
++i;
else ++j;
}
result.Refit();
return OpStatus::OK;
}
// algorithm taken from ShrinkRemove;
// doesn't seem to work precisely even there if you removed a significant number of elements,
// but it doesn't matter
void OpINT32Vector::Refit(void)
{
size_t new_size;
void** new_items;
if (m_size <= m_step || m_count + m_step >= m_size)
return;
if (m_count == 0)
{
Clear();
return;
}
new_size = ((m_count + m_step) / m_step) * m_step;
if ((new_items = OP_NEWA(void*, new_size)) == NULL)
return;
op_memcpy(new_items, m_items, m_count * sizeof(void *));
OP_DELETEA(m_items);
m_size = new_size;
m_items = new_items;
// auto-decrease m_step
if (m_step > m_min_step)
{
m_step /= 2;
}
}
#endif // ADVANCED_OPVECTOR
// The following is needed because .ot files apparently cannot have static functions
#ifdef SELFTEST
extern "C" {
int util_test_OpVector_QSort_intcmp(const int **a, const int **b)
{
return **a - **b;
}
} // extern "C"
#endif // SELFTEST
|
#include <math.h>
#include "matrix_utils.h"
#include "dct.h"
int main()
{
//srand(10);
//byte* bm = generate_byte_matrix(16,16);
//double* dm = generate_double_matrix(16,16);
//print_matrix_generic(16,16,1,6,8,bm,print_byte);
//print_matrix_generic(16,16,sizeof(double),10,4,(byte*)dm,print_double);
dct_trig_table t = dct_table_init(8);
printf("8x8 DCT kernel:\n");
print_matrix_generic(8,8,sizeof(double),10,8,(byte*)t,print_double);
return 0;
}
|
#include "qtestutility.h"
namespace qEngine
{
qTestUtility::qTestUtility(void)
{
}
qTestUtility::qTestUtility(boost::shared_ptr< qConsole > spConsole) : m_spConsole(spConsole)
{
ZeroMemory(&lf, sizeof(LOGFONT));
strcpy(lf.lfFaceName, "Times New Roman");
lf.lfHeight = -12;
if(FAILED(D3DXCreateFontIndirect(g_lpD3DDevice, &lf, &lpFont)))
{
m_spConsole->setMessage(MSG_ERROR, "qTestUtility", "init : Cannot create font for test utility");
}
m_spConsole->setMessage(MSG_INIT, "qTestUtility", "constructor : Test utility initialized");
}
void qTestUtility::displayConsoleMessages(int iWindowHeight, float FPS)
{
RECT rect = {0, 0, iWindowHeight, iWindowHeight};
int iNumLines = (int) (iWindowHeight / 12);
vector<string> vMsgBuffer;
m_spConsole->getMessages(iNumLines, &vMsgBuffer);
string title = "qEngine v1.0 FPS:" + boost::lexical_cast<string>(FPS);
if(SUCCEEDED(g_lpD3DDevice->BeginScene()))
{
lpFont->DrawText(title.c_str(), -1, &rect, 0, D3DCOLOR_RGBA(255,255,255,255));
rect.top = 12;
for(UINT i = 1; i < vMsgBuffer.size(); ++i)
{
lpFont->DrawText(vMsgBuffer[i - 1].c_str(), -1, &rect, 0, D3DCOLOR_RGBA(255,255,255,255));
rect.top = ((i) + 1)*12;
rect.bottom = iWindowHeight;
rect.left = 0;
rect.right = iWindowHeight;
}
}
g_lpD3DDevice->EndScene();
}
qTestUtility::~qTestUtility(void)
{
if(lpFont)
{
lpFont->Release();
}
}
}
|
class GameEventManager //Never disposed
{
public:
enum EventEnum
{
None = 0,
OnHit = 1,
};
GameEventManager();
void OnHitByPlayer();
};
void CreateGameEventHook();
|
/*
* GameServer.cpp
*
* Created on: Jun 24, 2017
* Author: root
*/
#include <iostream>
#include "ServiceMain.h"
#include "util.h"
using namespace std;
using namespace CommBaseOut;
int main()
{
#ifndef TEST
CUtil::InitDaemon();
#endif
#ifdef USE_MEMORY_LEAKS
MemoryLeaks::GetInstance()->Init(120);
#endif
#ifdef USE_MEMORY_POOL
MemAllocator::GetInstance();
#endif
{
CServiceMain service;
service.Start();
}
#ifdef USE_MEMORY_LEAKS
MemoryLeaks::GetInstance()->DestroyInstance();
#endif
#ifdef USE_MEMORY_POOL
MemAllocator::GetInstance()->DestroyInstance();
#endif
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define TESTC ""
#define PROBLEM "11494"
#define USE_CPPIO() ios_base::sync_with_stdio(0); cin.tie(0)
int main(int argc, char const *argv[])
{
#ifdef DBG
freopen("uva" PROBLEM TESTC ".in", "r", stdin);
freopen("uva" PROBLEM ".out", "w", stdout);
#endif
int x,y,x2,y2;
while( ~scanf("%d %d %d %d",&x,&y,&x2,&y2) && x ){
if( x == x2 && y == y2 )
printf("0\n");
else if( abs(x-x2) == abs(y-y2) || x == x2 || y == y2 )
printf("1\n");
else
printf("2\n");
}
return 0;
}
|
/**
* created: 2013-4-7 22:05
* filename: FKIocp
* author: FreeKnight
* Copyright (C):
* purpose:
*/
//------------------------------------------------------------------------
#pragma once
//------------------------------------------------------------------------
#include "FKAsynSocket.h"
#include "../STLTemplate/FKLookasideAlloc.h"
//------------------------------------------------------------------------
#define MAX_WORKTHREADCOUNT 48
#define IOCP_ACCEPTER_MINWAIT_OBJECTSID 2
#define IOCP_MAXSENDPACKETSIZE 1024*4
#define _IOCP_ACCEPTEX_ADDRESSLENGTH_ sizeof(sockaddr_in) + 16
//------------------------------------------------------------------------
class CLD_IocpBaseAccepter;
class CLD_IocpAccepter;
class CLD_IocpObj;
//------------------------------------------------------------------------
enum CLD_IocpOpCode
{
IOCP_NONE,
IOCP_ACCEPT,
IOCP_SEND,
IOCP_RECV,
};
//------------------------------------------------------------------------
struct OLEX : public OVERLAPPED
{
CLD_IocpOpCode nOpCode;
WSABUF wsaBuf;
OLEX(CLD_IocpOpCode op=IOCP_NONE){ wsaBuf.buf=NULL;wsaBuf.len=0;nOpCode=op; }
};
//------------------------------------------------------------------------
struct ACCEPT_OLEX:public OLEX
{
CLD_IocpBaseAccepter* Accepter;
SOCKET client;
char buffer[512];
ACCEPT_OLEX():OLEX(IOCP_ACCEPT)
{
Accepter=NULL;
client=INVALID_SOCKET;
wsaBuf.buf=&buffer[0];
wsaBuf.len=sizeof(buffer);
};
void* operator new(size_t n)
{
return LOOKASIDE_GETMEM(m_allocator);
}
void operator delete(void* p)
{
m_allocator.freemem((ACCEPT_OLEX *) p);
}
static safe_lookaside_allocator< ACCEPT_OLEX > m_allocator;
};
//------------------------------------------------------------------------
typedef void(*pIocpHandleCallBacklFunc)(void*);
//------------------------------------------------------------------------
class CLD_IocpObj
{
protected:
friend class CLD_IocpConnecter;
friend class CLD_IocpClientSocket;
friend class CLD_IocpAccepter;
public:
CLD_IocpHandle& GetIocpHandle(){return m_IocpHandle;}
CLD_Socket* GetSocket(){return m_IocpKey.pSocket;}
bool RecycleMe();
static bool RecycleMe(CLD_IocpObj* me);
virtual int AddBuf_Send(const char* pbuf,int nlen){return 0;};
virtual int AddSendBuf(const char* pbuf,int nlen){return 0;};
virtual bool PostSendBuf(){return false;};
//设置线程回调函数和参数
void SetRecycleThreadCallBack(pIocpHandleCallBacklFunc func,void* param)
{
m_iocpcallbcak=func;
m_iocpcallbcakparam=param;
}
virtual void SetRecycle(){m_dwAddRecycleTime=time(NULL);} //设置循环时间
CIntLock& GetTopLock(){ return m_callbacktoplock;}
protected:
int m_nSendRefCount;
int m_nRecvRefCount;
int m_nRefCount;
protected:
virtual bool IocpCanRecycle();
CLD_IocpObj(CLD_IocpHandle& Owner,CLD_Socket* pSock):m_IocpKey(pSock,this),m_IocpHandle(Owner)
{
m_nSendRefCount=0;
m_nRecvRefCount=0;
m_nRefCount=0;
m_dwAddRecycleTime=0;
m_boBind=false;
m_CanRecycle=true;
m_iocpcallbcak=NULL;
m_iocpcallbcakparam=NULL;
}
virtual ~CLD_IocpObj();
virtual void Init()
{
m_nSendRefCount=0;
m_nRecvRefCount=0;
m_nRefCount=0;
m_dwAddRecycleTime=0;
m_boBind=false;
m_CanRecycle=true;
}
friend class CLD_IocpHandle;
bool wsasend_safe(IN SOCKET s,
IN LPWSABUF lpBuffers,
IN DWORD dwBufferCount,
OUT LPDWORD lpNumberOfBytesSent,
IN DWORD dwFlags,
IN LPWSAOVERLAPPED lpOverlapped,
IN LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine,
int& nwsaErrorCode);
bool wsarecv_safe(IN SOCKET s,
IN OUT LPWSABUF lpBuffers,
IN DWORD dwBufferCount,
OUT LPDWORD lpNumberOfBytesRecvd,
IN OUT LPDWORD lpFlags,
IN LPWSAOVERLAPPED lpOverlapped,
IN LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine,
int& nwsaErrorCode);
struct stIocpKey {
CLD_Socket* pSocket;
CLD_IocpObj* pIocpObj;
stIocpKey(CLD_Socket* p1,CLD_IocpObj* p2):pSocket(p1),pIocpObj(p2){}
};
const stIocpKey* GetIocpKey(){return &m_IocpKey;};
virtual bool PostIocpRecv(OLEX* pOverlapped=NULL,int nTransferred=0){return false;}; //发送Iocp接收
virtual bool PostIocpSend(OLEX* pOverlapped=NULL,int nTransferred=0){return false;}; //发送Iocp发送
virtual void RecycleThreadCallBack(){
if (m_iocpcallbcak){m_iocpcallbcak(m_iocpcallbcakparam);}
}
protected:
time_t m_i64LastpostRecvTime; //上次的收发时间
time_t m_i64LastpostSendTime;
bool m_CanRecycle; //能够循环
bool m_boBind; //能够被绑定
time_t m_dwAddRecycleTime;
const stIocpKey m_IocpKey; //Iocp的key
CLD_IocpHandle& m_IocpHandle; //IocpHandle的引用
pIocpHandleCallBacklFunc m_iocpcallbcak;
void* m_iocpcallbcakparam;
OLEX m_olRecv; //OVERLAPPED
OLEX m_olSend;
private:
CIntLock m_callbacktoplock;
};
//------------------------------------------------------------------------
class CLD_IocpBaseAccepter:public CLD_Accepter
{
public:
CLD_IocpBaseAccepter()
{
m_bouseAcceptex=false;
m_boStopAcceptex=false;
m_dwPostSocket=50;
m_dwConnectTimeOutSec=2;
m_dwCheckConnectTick=400;
m_dwtmp_lastCheckConnectTick=0;
}
virtual ~CLD_IocpBaseAccepter(){}
virtual bool Open(const char * sAddr,u_short nPort);
virtual CLD_IocpObj& GetIocpObj()=0;
bool SetAcceptExConfig(bool useAcceptex,DWORD dwPostSocket=50,DWORD dwConnectTimeOutSec=2,DWORD dwCheckConnectcTick=400);
protected:
friend class CLD_IocpHandle;
virtual void DoDisconnect();
virtual void OnIocpClientConnect(CLD_Socket* Socket)=0;
virtual CLD_IocpClientSocket * CreateIocpClient(SOCKET s)=0;
virtual int RunAcceptExCheck();
static bool GetAcceptEx(SOCKET listensocket);
static bool GetAcceptExSockaddrs(SOCKET listensocket);
virtual int PostAcceptEx(DWORD dwPostCount=0);
bool m_bouseAcceptex; //是否接受
DWORD m_dwPostSocket;
DWORD m_dwConnectTimeOutSec; //超出连接时间
DWORD m_dwCheckConnectTick; //心跳包用
DWORD m_dwtmp_lastCheckConnectTick; //上次确定连接的时间
bool m_boStopAcceptex;
std::CSyncSet< ACCEPT_OLEX* > m_acceptexsockets;
static LPFN_ACCEPTEX m_lpAcceptExFun;
static LPFN_GETACCEPTEXSOCKADDRS m_lpGetAcceptExSockaddrsFun;
private:
virtual CLD_ClientSocket * CreateClient(SOCKET s)
{
return (CLD_ClientSocket*)CreateIocpClient(s);
}
virtual void OnClientConnect(CLD_Socket* Socket){};
};
//------------------------------------------------------------------------
class CLD_IocpAccepter:public CLD_IocpBaseAccepter
{
public:
CLD_IocpAccepter(CLD_IocpHandle& Owner)
:m_IocpObj(Owner,this),CLD_IocpBaseAccepter(){}
virtual ~CLD_IocpAccepter(){}
virtual CLD_IocpObj& GetIocpObj(){return m_IocpObj;};
protected:
CLD_IocpObj m_IocpObj;
};
//------------------------------------------------------------------------
class CLD_IocpClientSocket:public CLD_ClientSocket
{
protected:
DWORD m_lastcallbacktime;
friend class CLD_IocpBaseAccepter;
friend class CLD_IocpHandle;
CLD_IocpClientSocket(CLD_IocpBaseAccepter* Owner,SOCKET s)
:CLD_ClientSocket((CLD_Accepter *)Owner,s),m_lastcallbacktime(0){}
virtual ~CLD_IocpClientSocket(){}
virtual void OnIocpConnect(){};
public:
virtual CLD_IocpObj& GetIocpObj()=0;
private:
virtual void DeferFree();
//禁止从 cld_socket 继承该函数 防止还没有和iocp bind 就执行了 send 或则 recv 操做
virtual void OnConnect(){};
};
//------------------------------------------------------------------------
class CLD_IocpConnecterBase:public CLD_Connecter
{
protected:
DWORD m_lastcallbacktime;
CLD_IocpConnecterBase()
:CLD_Connecter(),m_lastcallbacktime(0){};
virtual ~CLD_IocpConnecterBase(){}
virtual void OnIocpConnect()=0;
public:
friend class CLD_IocpHandle;
virtual CLD_IocpObj& GetIocpObj()=0;
private:
virtual void OnConnect(){};
};
//------------------------------------------------------------------------
class CLD_IocpConnecter:public CLD_IocpConnecterBase
{
public:
CLD_IocpConnecter();
virtual ~CLD_IocpConnecter(){}
virtual bool Open(const char * sAddr,u_short nPort);
protected:
friend class CLD_IocpHandle;
virtual void DoDisconnect();
};
//------------------------------------------------------------------------
//IOCP管理类
class CLD_IocpHandle
{
public:
CLD_IocpHandle();
virtual ~CLD_IocpHandle();
bool IsReady(){return m_hIocp != INVALID_HANDLE_VALUE;};
HANDLE GetIocp(){return m_hIocp;};
bool Init(int nWorkers=0);
void Uninit();
static int GetNoOfProcessors();
int GetAccepterCount();
int GetClientCount();
int GetConnecterCount();
int GetWaitRecycleCount();
bool SetAcceptExConfig(bool useAcceptex,DWORD dwCheckConnectcTick=100);
bool SetIocpCallBack(bool boCallBack,int nIocpCallbackSleepTick=100,DWORD nIocpObjCallbackTick=100,DWORD nIocpHandleCallbackTick=100);
void SetRecycleThreadCallBack(pIocpHandleCallBacklFunc func,void* param)
{
m_iocpcallbcak=func;
m_iocpcallbcakparam=param;
}
protected:
friend class CLD_IocpConnecter;
friend class CLD_IocpClientSocket;
friend class CLD_IocpBaseAccepter;
friend class CLD_IocpObj;
struct WorkThreadinfo
{
CLD_IocpHandle* OwnerHandle;
stThreadDebugInfo* pDebuginfo;
CLD_ThreadBase* pWorkThreadObj;
};
bool BindAccepter(CLD_IocpBaseAccepter* Accepter);
void UnBindAccepter(CLD_IocpBaseAccepter* Accepter);
//这里只绑定已经和服务器建立连接的 Connecter
//可以在异步的 OnConnect 事件里面进行绑定
bool BindConnecter(CLD_IocpConnecterBase* Connecter);
void UnBindConnecter(CLD_IocpConnecterBase* Connecter);
bool InitWorkers( int nWorkers );
void UninitWorkers();
bool InitAcceptor();
void UninitAcceptor();
bool InitRecycle();
void UninitRecycle();
bool AddRecycle(CLD_IocpObj& pIocpObj);
static unsigned int __stdcall static_callbackworker(CLD_ThreadBase*, WorkThreadinfo* wth );
static unsigned int __stdcall static_callbackacceptor(CLD_ThreadBase*, CLD_IocpHandle *thisobj );
static unsigned int __stdcall static_callbackrecycle(CLD_ThreadBase*, CLD_IocpHandle *thisobj );
virtual void RecycleThreadCallBack()
{
if (m_iocpcallbcak)
{
m_iocpcallbcak(m_iocpcallbcakparam);
}
}
private:
static int m_nProcessors;
HANDLE m_hIocp;
int m_nWorkerCnt;
WorkThreadinfo m_WorkerThreadinfos[MAX_WORKTHREADCOUNT]; //最大工作线程数
HANDLE m_hAddAccepter; //增加接收的句柄
HANDLE m_hCloseAcceptor;
CLD_ThreadBase* m_hAcceptor; //线程的基础接收类
stThreadDebugInfo* m_AcceptorThreadDebuginfo; //线程的调试信息
CLD_ThreadBase* m_hRecycle;
bool m_boTerminatedRecycle;
stThreadDebugInfo* m_RecycleThreadDebuginfo;
typedef CSyncSet< CLD_IocpObj* > CWaitRecycleObjList; //等待循环列表
CWaitRecycleObjList m_RecycleObjList;
typedef CSyncList< CLD_IocpBaseAccepter* > CAccepterList;
CAccepterList m_AccepterList; //接收链表
typedef CSyncList< CLD_IocpConnecterBase* > CConnecterList;
CConnecterList m_ConnecterList; //连接链表
typedef vector< CLD_Socket* > CCallBackVector; //回调的Vector
CCallBackVector m_CallBackVector;
bool m_boIocpCallback;
int m_nIocpCallbackSleepTick;
DWORD m_nIocpHandleCallbackTick;
DWORD m_nIocpObjCallbackTick;
bool m_boUseAcceptex;
DWORD m_dwCheckConnectcTick;
int m_AccepterCount;
int m_ClientCount;
int m_ConnecterCount;
int m_WaitRecycleCount;
int m_WaitPrcessCount;
pIocpHandleCallBacklFunc m_iocpcallbcak;
void* m_iocpcallbcakparam;
void AllIocpObjTimerCallBack();
void WorkThread(WorkThreadinfo* pInfo);
void AcceptThread();
void RecycleThread();
};
//------------------------------------------------------------------------
//IOCPOBJ的扩展功能,加了个环形Buffer
class CLD_LoopbufIocpObj:public CLD_IocpObj
{
public:
CLD_LoopbufIocpObj(CLD_IocpHandle* Owner,CLD_Socket* pSock,int nLoopbufSize);
virtual ~CLD_LoopbufIocpObj();
public:
virtual void Init();
virtual int AddBuf_Send(const char* pbuf,int nlen);
virtual int AddSendBuf(const char* pbuf,int nlen);
virtual bool PostSendBuf();
CLD_LoopBuf* GetRecvBufer(){return &m_recvbuf;}
protected:
friend class CLD_LoopbufIocpConnecter;
virtual bool PostIocpRecv(OLEX* pOverlapped=NULL,int nTransferred=0);
virtual bool PostIocpSend(OLEX* pOverlapped=NULL,int nTransferred=0);
private:
const int m_initloopbufsize;
CLD_LoopBuf m_recvbuf;
CIntLock m_bottomlocksendbuf;
CLD_LoopBuf* m_sendbuf;
CLD_LoopBuf* m_backsendbuf;
CLD_LoopBuf m_sendbuffer;
CLD_LoopBuf m_backsendbuffer;
time_t m_lastreducerecvmemtime;
time_t m_lastreducersendmemtime;
};
//------------------------------------------------------------------------
class CLD_LoopbufIocpClientSocket: public CLD_IocpClientSocket
{
public:
CLD_LoopbufIocpClientSocket(CLD_IocpBaseAccepter* Owner,SOCKET s,int nLoopbufSize=DEF_LOOPBUF_SIZE)
:m_IocpObj(&Owner->GetIocpObj().GetIocpHandle(),this,nLoopbufSize),
CLD_IocpClientSocket(Owner,s){ m_IocpObj.Init(); };
CLD_LoopBuf* GetRecvBufer(){return m_IocpObj.GetRecvBufer();}
virtual CLD_IocpObj& GetIocpObj(){return m_IocpObj;};
protected:
CLD_LoopbufIocpObj m_IocpObj;
};
//------------------------------------------------------------------------
class CLD_LoopbufIocpConnecter: public CLD_IocpConnecter
{
public:
CLD_LoopbufIocpConnecter(CLD_IocpHandle* Owner,int nLoopbufSize=DEF_LOOPBUF_SIZE)
:m_IocpObj(Owner,this,nLoopbufSize),CLD_IocpConnecter(){ m_IocpObj.Init(); }
CLD_LoopBuf* GetRecvBufer(){return m_IocpObj.GetRecvBufer();}
virtual CLD_IocpObj& GetIocpObj(){return m_IocpObj;};
virtual void OnDisconnect(){
m_IocpObj.m_recvbuf.Clear();
INFOLOCK(m_IocpObj.m_bottomlocksendbuf);
m_IocpObj.m_sendbuf->Clear();
m_IocpObj.m_backsendbuf->Clear();
UNINFOLOCK(m_IocpObj.m_bottomlocksendbuf);
};
protected:
CLD_LoopbufIocpObj m_IocpObj;
};
//------------------------------------------------------------------------
|
#include <opencv2/core/core.hpp>
#include <opencv2/imgproc/imgproc.hpp>
#include <opencv2/highgui/highgui.hpp>
#include <iostream>
#include <fstream>
#include <iomanip>
#include <stdlib.h>
#include <string>
#include <stdio.h>
#define alpha_max 100
using namespace cv;
using namespace std;
string filename1("archie.jpg");
string filename2("betty.jpg");
void on_trackbar(int, void*);
void onMouse_1(int Event, int x, int y, int flags, void* param);
void onMouse_2(int Event, int x, int y, int flags, void* param);
void Button_tri(int event, int x, int y, int flags, void* userdata);
void txt1_point();
void txt2_point();
void morphTriangle(Mat &img1, Mat &img2, Mat &img, vector<Point2f> &t1, vector<Point2f> &t2, vector<Point2f> &t, double alpha);
ofstream in_txt_point("in_txt_point.txt");
ofstream out_txt_point("out_txt_point.txt");
ofstream tri_index("tri_index.txt");
vector<Point2f> points1;
vector<Point2f> points2;
vector<Point2f> points;
Mat img1;
Mat img2;
Mat imgMorph;
Mat image1,image2;
int alpha_slider;
bool flag = false;
double alpha;
// Read points stored in the text files
vector<Point2f> readPoints(string pointsFileName)
{
vector<Point2f> points;
ifstream ifs(pointsFileName.c_str());
float x, y;
while (ifs >> x >> y)
{
points.push_back(Point2f(x, y));
}
return points;
}
static void draw_delaunay(Mat& img, Subdiv2D& subdiv)
{
vector<Vec6f> triangleList;
subdiv.getTriangleList(triangleList);
vector<Point> pt(3);
Size size = img.size();
Rect rect(0, 0, size.width, size.height);
for (size_t i = 0; i < triangleList.size(); i++)
{
Vec6f t = triangleList[i];
pt[0] = Point(cvRound(t[0]), cvRound(t[1]));
pt[1] = Point(cvRound(t[2]), cvRound(t[3]));
pt[2] = Point(cvRound(t[4]), cvRound(t[5]));
// Draw rectangles completely inside the image.
if (rect.contains(pt[0]) && rect.contains(pt[1]) && rect.contains(pt[2]))
{
ifstream ifs("in_txt_point.txt");
int x, y, it;
int vex_1, vex_2, vex_3;
it = vex_1 = vex_2 = vex_3 = 0;
while (ifs >> x >> y) {
if (pt[0].x == x && pt[0].y == y)
vex_1 = it;
if (pt[1].x == x && pt[1].y == y)
vex_2 = it;
if (pt[2].x == x && pt[2].y == y)
vex_3 = it;
it++;
}
tri_index << vex_1 << " " << vex_2 << " " << vex_3 << endl;
}
}
tri_index.close();
}
// Apply affine transform calculated using srcTri and dstTri to src
void applyAffineTransform(Mat &warpImage, Mat &src, vector<Point2f> &srcTri, vector<Point2f> &dstTri)
{
// Given a pair of triangles, find the affine transform.
Mat warpMat = getAffineTransform(srcTri, dstTri);
// Apply the Affine Transform just found to the src image
warpAffine(src, warpImage, warpMat, warpImage.size(), INTER_LINEAR, BORDER_REFLECT_101);
}
// Warps and alpha blends triangular regions from img1 and img2 to img
void morphTriangle(Mat &img1, Mat &img2, Mat &img, vector<Point2f> &t1, vector<Point2f> &t2, vector<Point2f> &t, double alpha)
{
// Find bounding rectangle for each triangle
Rect r = boundingRect(t);
Rect r1 = boundingRect(t1);
Rect r2 = boundingRect(t2);
// Offset points by left top corner of the respective rectangles
vector<Point2f> t1Rect, t2Rect, tRect;
vector<Point> tRectInt;
for (int i = 0; i < 3; i++)
{
tRect.push_back(Point2f(t[i].x - r.x, t[i].y - r.y));
tRectInt.push_back(Point(t[i].x - r.x, t[i].y - r.y)); // for fillConvexPoly
t1Rect.push_back(Point2f(t1[i].x - r1.x, t1[i].y - r1.y));
t2Rect.push_back(Point2f(t2[i].x - r2.x, t2[i].y - r2.y));
}
// Get mask by filling triangle
Mat mask = Mat::zeros(r.height, r.width, CV_32FC3);
fillConvexPoly(mask, tRectInt, Scalar(1.0, 1.0, 1.0), 16, 0);
// Apply warpImage to small rectangular patches
Mat img1Rect, img2Rect;
img1(r1).copyTo(img1Rect);
img2(r2).copyTo(img2Rect);
Mat warpImage1 = Mat::zeros(r.height, r.width, img1Rect.type());
Mat warpImage2 = Mat::zeros(r.height, r.width, img2Rect.type());
applyAffineTransform(warpImage1, img1Rect, t1Rect, tRect);
applyAffineTransform(warpImage2, img2Rect, t2Rect, tRect);
// Alpha blend rectangular patches
Mat imgRect = (1.0 - alpha) * warpImage1 + alpha * warpImage2;
// Copy triangular region of the rectangular patch to the output image
multiply(imgRect, mask, imgRect);
multiply(img(r), Scalar(1.0, 1.0, 1.0) - mask, img(r));
img(r) = img(r) + imgRect;
}
void on_trackbar(int, void*) {
if (flag == true) {
points1 = readPoints("in_txt_point.txt");
points2 = readPoints("out_txt_point.txt");
for (int i = 0; i < points1.size(); i++)
{
float x, y;
alpha = (double)alpha_slider / alpha_max;
x = (1 - alpha) * points1[i].x + alpha * points2[i].x;
y = (1 - alpha) * points1[i].y + alpha * points2[i].y;
points.push_back(Point2f(x, y));
}
ifstream ifs("tri_index.txt");
int x, y, z;
while (ifs >> x >> y >> z)
{
// Triangles
vector<Point2f> t1, t2, t;
// Triangle corners for image 1.
t1.push_back(points1[x]);
t1.push_back(points1[y]);
t1.push_back(points1[z]);
// Triangle corners for image 2.
t2.push_back(points2[x]);
t2.push_back(points2[y]);
t2.push_back(points2[z]);
// Triangle corners for morphed image.
t.push_back(points[x]);
t.push_back(points[y]);
t.push_back(points[z]);
morphTriangle(image1, image2, imgMorph, t1, t2, t, alpha);
}
}
points.clear();
imshow("Morphed Face", imgMorph / 255.0);
}
void onMouse_1(int Event, int x, int y, int flags, void* param) {
if (Event == CV_EVENT_LBUTTONDOWN && flag == false) {
cout << x << "," << y << endl;
circle(img1, Point(x, y), 2, Scalar(0, 255, 0), 3, 10);
in_txt_point << to_string(x) << " " << to_string(y) << endl;
imshow("Initial Face", img1 / 255.0);
}
if(Event == CV_EVENT_MBUTTONDOWN && flag == false){
in_txt_point.close();
in_txt_point.open("in_txt_point.txt", std::ios::out | std::ios::trunc);
txt1_point();
image1.copyTo(img1);
imshow("Initial Face", img1 / 255.0);
}
}
void onMouse_2(int Event, int x, int y, int flags, void* param) {
if (Event == CV_EVENT_LBUTTONDOWN && flag == false) {
cout << x << "," << y << endl;
circle(img2, Point(x, y), 2, Scalar(0, 0, 255), 3, 10);
out_txt_point << to_string(x) << " " << to_string(y) << endl;
imshow("Result Face", img2 / 255.0);
}
if(Event == CV_EVENT_MBUTTONDOWN && flag == false){
out_txt_point.close();
out_txt_point.open("out_txt_point.txt", std::ios::out | std::ios::trunc);
txt2_point();
image2.copyTo(img2);
imshow("Result Face", img2 / 255.0);
}
}
void txt1_point() {
in_txt_point << 1 << " " << 1 << endl;
for (int i = 99; i < img1.rows; i += 100)
in_txt_point << 1 << " " << i << endl;
for (int i = 99; i < img1.cols; i += 100)
in_txt_point << i << " " << img1.rows - 1 << endl;
for (int i = img1.rows - 1; i > 0; i -= 100)
in_txt_point << img1.cols - 1 << " " << i << endl;
for (int i = img1.cols - 1; i > 0; i -= 100)
in_txt_point << i << " " << 1 << endl;
}
void txt2_point(){
out_txt_point << 1 << " " << 1 << endl;
for (int i = 99; i < img1.rows; i += 100)
out_txt_point << 1 << " " << i << endl;
for (int i = 99; i < img1.cols; i += 100)
out_txt_point << i << " " << img1.rows - 1 << endl;
for (int i = img1.rows - 1; i > 0; i -= 100)
out_txt_point << img1.cols - 1 << " " << i << endl;
for (int i = img1.cols - 1; i > 0; i -= 100)
out_txt_point << i << " " << 1 << endl;
}
void Button_tri(int event, int x, int y, int flags, void* userdata) {
if (event == EVENT_LBUTTONDOWN){
flag = true;
points1 = readPoints("in_txt_point.txt");
Size size = img1.size();
Rect rect(0, 0, size.width, size.height);
Subdiv2D subdiv(rect);
// Create an instance of Subdiv2D
for (vector<Point2f>::iterator it = points1.begin(); it != points1.end(); it++)
subdiv.insert(*it);
draw_delaunay(img1, subdiv);
}
if(event == EVENT_MBUTTONDOWN && flag == true){
Size size = img1.size();
VideoWriter writer("Morphing.avi",CV_FOURCC('M', 'J', 'P', 'G'),10,size);
int ti = 0;
while(ti < 150){
points1 = readPoints("in_txt_point.txt");
points2 = readPoints("out_txt_point.txt");
for (int i = 0; i < points1.size(); i++)
{
float x, y;
alpha = (double)ti / 150;
x = (1 - alpha) * points1[i].x + alpha * points2[i].x;
y = (1 - alpha) * points1[i].y + alpha * points2[i].y;
points.push_back(Point2f(x, y));
}
ifstream ifs("tri_index.txt");
int x, y, z;
while (ifs >> x >> y >> z)
{
// Triangles
vector<Point2f> t1, t2, t;
// Triangle corners for image 1.
t1.push_back(points1[x]);
t1.push_back(points1[y]);
t1.push_back(points1[z]);
// Triangle corners for image 2.
t2.push_back(points2[x]);
t2.push_back(points2[y]);
t2.push_back(points2[z]);
// Triangle corners for morphed image.
t.push_back(points[x]);
t.push_back(points[y]);
t.push_back(points[z]);
morphTriangle(image1, image2, imgMorph, t1, t2, t, alpha);
}
ti++;
points.clear();
string name = "./JPG/" + to_string(ti) + ".jpg";
imwrite(name,imgMorph);
}
ti = 0;
Mat image;
while (true){
VideoCapture in_capture("./JPG/" + to_string(ti) + ".jpg") ;
in_capture >> image;
if(image.empty())
break;
writer.write(image);
ti++;
}
writer.release();
}
}
int main(int argc, char** argv)
{
alpha_slider = 0;
//Read input images
img1 = imread(argv[1]);
img2 = imread(argv[2]);
points1 = readPoints("in_txt_point.txt");
points2 = readPoints("out_txt_point.txt");
Mat Button(50, 250, CV_8UC1);
for(MatIterator_<uchar> ite= Button.begin<uchar>(); ite != Button.end<uchar>(); ite ++)
(*ite) = 0;
putText(Button, String("Save point"), Point(30, 30), 0, 1, Scalar(255, 255, 255), 3);
txt1_point();
txt2_point();
//convert Mat to float data type
img1.convertTo(img1, CV_32F);
img2.convertTo(img2, CV_32F);
img1.copyTo(image1);img2.copyTo(image2);
imgMorph = Mat::zeros(img1.size(), CV_32FC3);
//Read points
// Display Result
namedWindow("Morphed Face", 1);
namedWindow("Result Face", 1);
namedWindow("Button_trigle");
moveWindow("Result Face", img1.rows*2, 0);
moveWindow("Morphed Face", img1.rows-125, 0);
imshow("Result Face", img2 / 255.0);
imshow("Initial Face", img1 / 255.0);
imshow("Button_trigle", Button);
moveWindow("Button_trigle", img1.rows,img1.cols+300);
setMouseCallback("Initial Face", onMouse_1, NULL);
setMouseCallback("Result Face", onMouse_2, NULL);
setMouseCallback("Button_trigle", Button_tri, NULL);
createTrackbar("Trackbar", "Morphed Face", &alpha_slider, alpha_max, on_trackbar);
on_trackbar(alpha_slider, 0);
waitKey(0);
in_txt_point.close();
out_txt_point.close();
destroyAllWindows();
return 0;
}
|
#include "character.h"
Character::Character(int str, int dex, int inte)
{
_str = str;
_dex = dex;
_int = inte;
}
Character::Character()
{
}
Character::~Character()
{}
int Character::getStrength()
{
return _str;
}
int Character::getDexterity()
{
return _dex;
}
int Character::getIntelligence()
{
return _int;
}
void Character::setStrength(int s)
{
_str = s;
}
void Character::setDexterity(int d)
{
_dex = d;
}
void Character::setIntelligence(int i)
{
_int = i;
}
void Character::acceptAI(SpriteAIengine*ai)
{
}
|
// Copyright (c) 1991-1999 Matra Datavision
// Copyright (c) 1999-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#ifndef _gp_Ax22d_HeaderFile
#define _gp_Ax22d_HeaderFile
#include <gp_Ax2d.hxx>
#include <gp_Dir2d.hxx>
#include <gp_Pnt2d.hxx>
#include <gp_Trsf2d.hxx>
#include <gp_Vec2d.hxx>
//! Describes a coordinate system in a plane (2D space).
//! A coordinate system is defined by:
//! - its origin (also referred to as its "Location point"), and
//! - two orthogonal unit vectors, respectively, called the "X
//! Direction" and the "Y Direction".
//! A gp_Ax22d may be right-handed ("direct sense") or
//! left-handed ("inverse" or "indirect sense").
//! You use a gp_Ax22d to:
//! - describe 2D geometric entities, in particular to position
//! them. The local coordinate system of a geometric
//! entity serves for the same purpose as the STEP
//! function "axis placement two axes", or
//! - define geometric transformations.
//! Note: we refer to the "X Axis" and "Y Axis" as the axes having:
//! - the origin of the coordinate system as their origin, and
//! - the unit vectors "X Direction" and "Y Direction",
//! respectively, as their unit vectors.
class gp_Ax22d
{
public:
DEFINE_STANDARD_ALLOC
//! Creates an object representing the reference
//! coordinate system (OXY).
gp_Ax22d() : vydir (0., 1.)
// vxdir(1.,0.) use default ctor of gp_Dir2d, as it creates the same dir(1, 0)
{}
//! Creates a coordinate system with origin theP and where:
//! - theVx is the "X Direction", and
//! - the "Y Direction" is orthogonal to theVx and
//! oriented so that the cross products theVx^"Y
//! Direction" and theVx^theVy have the same sign.
//! Raises ConstructionError if theVx and theVy are parallel (same or opposite orientation).
gp_Ax22d (const gp_Pnt2d& theP, const gp_Dir2d& theVx, const gp_Dir2d& theVy)
: point (theP),
vydir (theVy),
vxdir (theVx)
{
Standard_Real aValue = theVx.Crossed (theVy);
if (aValue >= 0.0)
{
vydir.SetCoord (-vxdir.Y(), vxdir.X());
}
else
{
vydir.SetCoord (vxdir.Y(), -vxdir.X());
}
}
//! Creates - a coordinate system with origin theP and "X Direction"
//! theV, which is:
//! - right-handed if theIsSense is true (default value), or
//! - left-handed if theIsSense is false
gp_Ax22d (const gp_Pnt2d& theP, const gp_Dir2d& theV, const Standard_Boolean theIsSense = Standard_True)
: point (theP),
vxdir (theV)
{
if (theIsSense)
{
vydir.SetCoord (-theV.Y(), theV.X());
}
else
{
vydir.SetCoord (theV.Y(), -theV.X());
}
}
//! Creates - a coordinate system where its origin is the origin of
//! theA and its "X Direction" is the unit vector of theA, which is:
//! - right-handed if theIsSense is true (default value), or
//! - left-handed if theIsSense is false.
gp_Ax22d (const gp_Ax2d& theA, const Standard_Boolean theIsSense = Standard_True)
: point (theA.Location()),
vxdir (theA.Direction())
{
if (theIsSense)
{
vydir.SetCoord (-vxdir.Y(), vxdir.X());
}
else
{
vydir.SetCoord (vxdir.Y(), -vxdir.X());
}
}
//! Assigns the origin and the two unit vectors of the
//! coordinate system theA1 to this coordinate system.
void SetAxis (const gp_Ax22d& theA1)
{
point = theA1.Location();
vxdir = theA1.XDirection();
vydir = theA1.YDirection();
}
//! Changes the XAxis and YAxis ("Location" point and "Direction")
//! of <me>.
//! The "YDirection" is recomputed in the same sense as before.
void SetXAxis (const gp_Ax2d& theA1);
//! Changes the XAxis and YAxis ("Location" point and "Direction") of <me>.
//! The "XDirection" is recomputed in the same sense as before.
void SetYAxis (const gp_Ax2d& theA1);
//! Changes the "Location" point (origin) of <me>.
void SetLocation (const gp_Pnt2d& theP) { point = theP; }
//! Assigns theVx to the "X Direction" of
//! this coordinate system. The other unit vector of this
//! coordinate system is recomputed, normal to theVx ,
//! without modifying the orientation (right-handed or
//! left-handed) of this coordinate system.
void SetXDirection (const gp_Dir2d& theVx);
//! Assignsr theVy to the "Y Direction" of
//! this coordinate system. The other unit vector of this
//! coordinate system is recomputed, normal to theVy,
//! without modifying the orientation (right-handed or
//! left-handed) of this coordinate system.
void SetYDirection (const gp_Dir2d& theVy);
//! Returns an axis, for which
//! - the origin is that of this coordinate system, and
//! - the unit vector is either the "X Direction" of this coordinate system.
//! Note: the result is the "X Axis" of this coordinate system.
gp_Ax2d XAxis() const { return gp_Ax2d (point, vxdir); }
//! Returns an axis, for which
//! - the origin is that of this coordinate system, and
//! - the unit vector is either the "Y Direction" of this coordinate system.
//! Note: the result is the "Y Axis" of this coordinate system.
gp_Ax2d YAxis() const { return gp_Ax2d (point, vydir); }
//! Returns the "Location" point (origin) of <me>.
const gp_Pnt2d& Location() const { return point; }
//! Returns the "XDirection" of <me>.
const gp_Dir2d& XDirection() const { return vxdir; }
//! Returns the "YDirection" of <me>.
const gp_Dir2d& YDirection() const { return vydir; }
Standard_EXPORT void Mirror (const gp_Pnt2d& theP);
//! Performs the symmetrical transformation of an axis
//! placement with respect to the point theP which is the
//! center of the symmetry.
//! Warnings :
//! The main direction of the axis placement is not changed.
//! The "XDirection" and the "YDirection" are reversed.
//! So the axis placement stay right handed.
Standard_NODISCARD Standard_EXPORT gp_Ax22d Mirrored (const gp_Pnt2d& theP) const;
Standard_EXPORT void Mirror (const gp_Ax2d& theA);
//! Performs the symmetrical transformation of an axis
//! placement with respect to an axis placement which
//! is the axis of the symmetry.
//! The transformation is performed on the "Location"
//! point, on the "XDirection" and "YDirection".
//! The resulting main "Direction" is the cross product between
//! the "XDirection" and the "YDirection" after transformation.
Standard_NODISCARD Standard_EXPORT gp_Ax22d Mirrored (const gp_Ax2d& theA) const;
void Rotate (const gp_Pnt2d& theP, const Standard_Real theAng);
//! Rotates an axis placement. <theA1> is the axis of the
//! rotation . theAng is the angular value of the rotation
//! in radians.
Standard_NODISCARD gp_Ax22d Rotated (const gp_Pnt2d& theP, const Standard_Real theAng) const
{
gp_Ax22d aTemp = *this;
aTemp.Rotate (theP, theAng);
return aTemp;
}
void Scale (const gp_Pnt2d& theP, const Standard_Real theS);
//! Applies a scaling transformation on the axis placement.
//! The "Location" point of the axisplacement is modified.
//! Warnings :
//! If the scale <theS> is negative :
//! . the main direction of the axis placement is not changed.
//! . The "XDirection" and the "YDirection" are reversed.
//! So the axis placement stay right handed.
Standard_NODISCARD gp_Ax22d Scaled (const gp_Pnt2d& theP, const Standard_Real theS) const
{
gp_Ax22d aTemp = *this;
aTemp.Scale (theP, theS);
return aTemp;
}
void Transform (const gp_Trsf2d& theT);
//! Transforms an axis placement with a Trsf.
//! The "Location" point, the "XDirection" and the
//! "YDirection" are transformed with theT. The resulting
//! main "Direction" of <me> is the cross product between
//! the "XDirection" and the "YDirection" after transformation.
Standard_NODISCARD gp_Ax22d Transformed (const gp_Trsf2d& theT) const
{
gp_Ax22d aTemp = *this;
aTemp.Transform (theT);
return aTemp;
}
void Translate (const gp_Vec2d& theV) { point.Translate (theV); }
//! Translates an axis plaxement in the direction of the vector
//! <theV>. The magnitude of the translation is the vector's magnitude.
Standard_NODISCARD gp_Ax22d Translated (const gp_Vec2d& theV) const
{
gp_Ax22d aTemp = *this;
aTemp.Translate (theV);
return aTemp;
}
void Translate (const gp_Pnt2d& theP1, const gp_Pnt2d& theP2) { point.Translate (theP1, theP2); }
//! Translates an axis placement from the point <theP1> to the
//! point <theP2>.
Standard_NODISCARD gp_Ax22d Translated (const gp_Pnt2d& theP1, const gp_Pnt2d& theP2) const
{
gp_Ax22d aTemp = *this;
aTemp.Translate (theP1, theP2);
return aTemp;
}
//! Dumps the content of me into the stream
Standard_EXPORT void DumpJson (Standard_OStream& theOStream, Standard_Integer theDepth = -1) const;
private:
gp_Pnt2d point;
gp_Dir2d vydir;
gp_Dir2d vxdir;
};
// =======================================================================
// function : SetDirection
// purpose :
// =======================================================================
inline void gp_Ax22d::SetXAxis (const gp_Ax2d& theA1)
{
Standard_Boolean isSign = (vxdir.Crossed(vydir)) >= 0.0;
point = theA1.Location ();
vxdir = theA1.Direction();
if (isSign)
{
vydir.SetCoord (-vxdir.Y(), vxdir.X());
}
else
{
vydir.SetCoord (vxdir.Y(), -vxdir.X());
}
}
// =======================================================================
// function : SetDirection
// purpose :
// =======================================================================
inline void gp_Ax22d::SetYAxis (const gp_Ax2d& theA1)
{
Standard_Boolean isSign = (vxdir.Crossed(vydir)) >= 0.0;
point = theA1.Location ();
vydir = theA1.Direction();
if (isSign)
{
vxdir.SetCoord (vydir.Y(), -vydir.X());
}
else
{
vxdir.SetCoord (-vydir.Y(), vydir.X());
}
}
// =======================================================================
// function : SetXDirection
// purpose :
// =======================================================================
inline void gp_Ax22d::SetXDirection (const gp_Dir2d& theVx)
{
Standard_Boolean isSign = (vxdir.Crossed(vydir)) >= 0.0;
vxdir = theVx;
if (isSign)
{
vydir.SetCoord (-theVx.Y(), theVx.X());
}
else
{
vydir.SetCoord (theVx.Y(), -theVx.X());
}
}
// =======================================================================
// function : SetYDirection
// purpose :
// =======================================================================
inline void gp_Ax22d::SetYDirection (const gp_Dir2d& theVy)
{
Standard_Boolean isSign = (vxdir.Crossed(vydir)) >= 0.0;
vydir = theVy;
if (isSign)
{
vxdir.SetCoord (theVy.Y(), -theVy.X());
}
else
{
vxdir.SetCoord (-theVy.Y(), theVy.X());
}
}
// =======================================================================
// function : Rotate
// purpose :
// =======================================================================
inline void gp_Ax22d::Rotate (const gp_Pnt2d& theP, const Standard_Real theAng)
{
gp_Pnt2d aTemp = point;
aTemp.Rotate (theP, theAng);
point = aTemp;
vxdir.Rotate (theAng);
vydir.Rotate (theAng);
}
// =======================================================================
// function : Scale
// purpose :
// =======================================================================
inline void gp_Ax22d::Scale (const gp_Pnt2d& theP, const Standard_Real theS)
{
gp_Pnt2d aTemp = point;
aTemp.Scale (theP, theS);
point = aTemp;
if (theS < 0.0)
{
vxdir.Reverse();
vydir.Reverse();
}
}
// =======================================================================
// function : Transform
// purpose :
// =======================================================================
inline void gp_Ax22d::Transform (const gp_Trsf2d& theT)
{
gp_Pnt2d aTemp = point;
aTemp.Transform (theT);
point = aTemp;
vxdir.Transform (theT);
vydir.Transform (theT);
}
#endif // _gp_Ax22d_HeaderFile
|
/*
* Copyright (c) 2015-2020 Morwenn
* SPDX-License-Identifier: MIT
*/
#include <functional>
#include <iterator>
#include <vector>
#include <catch2/catch.hpp>
#include <cpp-sort/adapters/hybrid_adapter.h>
#include <cpp-sort/sorter_facade.h>
namespace
{
enum struct sorter_type
{
ascending,
descending,
generic
};
struct partial_comparison_sorter_impl
{
// Sort in ascending order
template<typename Iterator>
auto operator()(Iterator, Iterator) const
-> sorter_type
{
return sorter_type::ascending;
}
// Sort in descending order
template<typename Iterator>
auto operator()(Iterator, Iterator, std::greater<>) const
-> sorter_type
{
return sorter_type::descending;
}
using iterator_category = std::random_access_iterator_tag;
};
struct generic_sorter_impl
{
template<typename Iterator, typename Compare>
auto operator()(Iterator, Iterator, Compare) const
-> sorter_type
{
return sorter_type::generic;
}
using iterator_category = std::forward_iterator_tag;
};
struct partial_comparison_sorter:
cppsort::sorter_facade<partial_comparison_sorter_impl>
{};
struct generic_sorter:
cppsort::sorter_facade<generic_sorter_impl>
{};
}
TEST_CASE( "hybrid_adapter over partial comparison sorter",
"[hybrid_adapter][compare]" )
{
// Check that hybrid_adapter works as expected even
// with partial comparison sorters
cppsort::hybrid_adapter<
partial_comparison_sorter,
generic_sorter
> sorter;
// Vector to "sort"
std::vector<int> vec(3);
SECTION( "without a comparison function" )
{
sorter_type res1 = sorter(vec);
CHECK( res1 == sorter_type::ascending );
sorter_type res2 = sorter(std::begin(vec), std::end(vec));
CHECK( res2 == sorter_type::ascending );
}
SECTION( "with std::less<>" )
{
sorter_type res1 = sorter(vec, std::less<>{});
CHECK( res1 == sorter_type::ascending );
sorter_type res2 = sorter(std::begin(vec), std::end(vec), std::less<>{});
CHECK( res2 == sorter_type::ascending );
}
SECTION( "with std::greater<>" )
{
sorter_type res1 = sorter(vec, std::greater<>{});
CHECK( res1 == sorter_type::descending );
sorter_type res2 = sorter(std::begin(vec), std::end(vec), std::greater<>{});
CHECK( res2 == sorter_type::descending );
}
SECTION( "with another function object" )
{
sorter_type res1 = sorter(vec, std::less_equal<>{});
CHECK( res1 == sorter_type::generic );
sorter_type res2 = sorter(std::begin(vec), std::end(vec), std::less_equal<>{});
CHECK( res2 == sorter_type::generic );
}
}
|
// Created on: 1993-01-09
// Created by: CKY / Contract Toubro-Larsen ( Kiran )
// Copyright (c) 1993-1999 Matra Datavision
// Copyright (c) 1999-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#ifndef _IGESGeom_Point_HeaderFile
#define _IGESGeom_Point_HeaderFile
#include <Standard.hxx>
#include <Standard_Type.hxx>
#include <gp_XYZ.hxx>
#include <IGESData_IGESEntity.hxx>
class IGESBasic_SubfigureDef;
class gp_Pnt;
class IGESGeom_Point;
DEFINE_STANDARD_HANDLE(IGESGeom_Point, IGESData_IGESEntity)
//! defines IGESPoint, Type <116> Form <0>
//! in package IGESGeom
class IGESGeom_Point : public IGESData_IGESEntity
{
public:
Standard_EXPORT IGESGeom_Point();
//! This method is used to set the fields of the class Point
//! - aPoint : Coordinates of point
//! - aSymbol : SubfigureDefinition entity specifying the
//! display symbol if there exists one, or zero
Standard_EXPORT void Init (const gp_XYZ& aPoint, const Handle(IGESBasic_SubfigureDef)& aSymbol);
//! returns coordinates of the point
Standard_EXPORT gp_Pnt Value() const;
//! returns coordinates of the point after applying Transf. Matrix
Standard_EXPORT gp_Pnt TransformedValue() const;
//! returns True if symbol exists
Standard_EXPORT Standard_Boolean HasDisplaySymbol() const;
//! returns display symbol entity if it exists
Standard_EXPORT Handle(IGESBasic_SubfigureDef) DisplaySymbol() const;
DEFINE_STANDARD_RTTIEXT(IGESGeom_Point,IGESData_IGESEntity)
protected:
private:
gp_XYZ thePoint;
Handle(IGESBasic_SubfigureDef) theSymbol;
};
#endif // _IGESGeom_Point_HeaderFile
|
// Alfred Shaker
// counting_observer.cpp
// cs33901
#include "counting_observer.h"
#include <iostream>
#include <string>
#include <vector>
using std::cin;
using std::cout;
using std::string;
using std::vector;
void CountingObserver::update(Observable*) {
// keep track of the upper case letters
++upperIndex;
}
void CountingObserver::show_data() {
// Output
cout << "Upper count: " << upperIndex << "\n";
}
|
#ifndef __SNAPSHOT_H__
#define __SNAPSHOT_H__
#include <string>
#include "com_bql_MSG_Native.h"
#include "SwsScale.h"
////////////////////////////////////////////////////////////////////////////////
class CSnapshot : public CWriter
{
public:
CSnapshot(JNIStreamerContext *pParams, CSwsScale *pScales, const char *file, int type)
: m_pParams(pParams), m_pScales(pScales), m_file(file), m_type(type)
{
THIS_LOGT_print("is created of %s", file);
}
virtual ~CSnapshot()
{
if( m_pScales != 0 ) delete m_pScales;
THIS_LOGT_print("is deleted");
}
public: //interface of CWriter
virtual int Write(JNIEnv *env, void *buffer = 0);
private:
JNIStreamerContext *m_pParams;
CSwsScale *m_pScales;
std::string m_file;
int m_type; //0-bmp 1-jpg
CLASS_LOG_DECLARE(CSnapshot);
};
#endif
|
/* -*- Mode: c++; tab-width: 4; indent-tabs-mode: t; c-basic-offset: 4 -*-
**
** Copyright (C) 1995-1999 Opera Software AS. All rights reserved.
**
** This file is part of the Opera web browser. It may not be distributed
** under any circumstances.
**
*/
#include "core/pch.h"
#include "modules/dom/src/domcore/domstringmap.h"
#include "modules/dom/src/domhtml/htmlelem.h"
#include "modules/dom/src/domenvironmentimpl.h"
#include "modules/logdoc/htm_elm.h"
/**
* Returns OpStatus:ERR if there is no legal mapping.
*/
static OP_STATUS MapPropertyToAttributeName(const uni_char* prop, TempBuffer& attr)
{
RETURN_IF_ERROR(attr.Append("data-"));
while (*prop)
{
if (*prop == '-' && prop[1] >= 'a' && prop[1] <= 'z')
return OpStatus::ERR;
if (*prop >= 'A' && *prop <= 'Z')
{
RETURN_IF_ERROR(attr.Append('-'));
RETURN_IF_ERROR(attr.Append(*prop - 'A' + 'a'));
}
else
RETURN_IF_ERROR(attr.Append(*prop));
prop++;
}
return OpStatus::OK;
}
/**
* Returns OpStatus:ERR if there is no legal mapping.
*/
static OP_STATUS MapAttributeToPropertyName(const uni_char* attr, TempBuffer& prop)
{
if (uni_strncmp(attr, "data-", 5) != 0)
return OpStatus::ERR;
attr += 5;
const uni_char* p = attr;
while (*p)
{
if (*p >= 'A' && *p <= 'Z')
return OpStatus::ERR;
p++;
}
while (*attr)
{
if (*attr == '-' && attr[1] >= 'a' && attr[1] <= 'z')
{
RETURN_IF_ERROR(prop.Append(attr[1] - 'a' + 'A'));
attr++;
}
else
RETURN_IF_ERROR(prop.Append(*attr));
attr++;
}
return OpStatus::OK;
}
/* static */ OP_STATUS
DOM_DOMStringMap::Make(DOM_DOMStringMap *&stringmap, DOM_Element *owner)
{
DOM_Runtime *runtime = owner->GetRuntime();
RETURN_IF_ERROR(DOMSetObjectRuntime(stringmap = OP_NEW(DOM_DOMStringMap, (owner)), runtime, runtime->GetPrototype(DOM_Runtime::DOMSTRINGMAP_PROTOTYPE), "DOMStringMap"));
stringmap->SetHasVolatilePropertySet();
return OpStatus::OK;
}
/* virtual */ ES_GetState
DOM_DOMStringMap::GetName(const uni_char* property_name, int property_code, ES_Value* value, ES_Runtime* origining_runtime)
{
TempBuffer attribute_name;
OP_STATUS status = MapPropertyToAttributeName(property_name, attribute_name);
if (OpStatus::IsMemoryError(status))
return GET_NO_MEMORY;
if (OpStatus::IsSuccess(status))
{
OP_ASSERT(attribute_name.GetStorage());
DOM_EnvironmentImpl *environment = GetEnvironment();
int index;
BOOL case_sensitive = owner->HasCaseSensitiveNames();
HTML_Element *element = owner->GetThisElement();
if (element->DOMHasAttribute(environment, ATTR_XML, attribute_name.GetStorage(), NS_IDX_ANY_NAMESPACE, case_sensitive, index))
{
if (value)
DOMSetString(value, element->DOMGetAttribute(environment, ATTR_XML, attribute_name.GetStorage(), NS_IDX_ANY_NAMESPACE, case_sensitive, FALSE, index));
return GET_SUCCESS;
}
}
return DOM_Object::GetName(property_name, property_code, value, origining_runtime);
}
/* virtual */ ES_PutState
DOM_DOMStringMap::PutName(const uni_char* property_name, int property_code, ES_Value* value, ES_Runtime* origining_runtime)
{
TempBuffer attribute_name;
OP_STATUS status = MapPropertyToAttributeName(property_name, attribute_name);
if (OpStatus::IsError(status))
{
if (OpStatus::IsMemoryError(status))
return PUT_NO_MEMORY;
return DOM_PUTNAME_DOMEXCEPTION(SYNTAX_ERR);
}
if (value->type != VALUE_STRING)
return PUT_NEEDS_STRING;
OP_ASSERT(attribute_name.GetStorage());
PUT_FAILED_IF_ERROR(owner->SetAttribute(ATTR_XML, attribute_name.GetStorage(), NS_IDX_DEFAULT, value->value.string, value->GetStringLength(), owner->HasCaseSensitiveNames(), origining_runtime));
return PUT_SUCCESS;
}
/* virtual */ ES_DeleteStatus
DOM_DOMStringMap::DeleteName(const uni_char* property_name, ES_Runtime *origining_runtime)
{
TempBuffer attribute_name;
OP_STATUS status = MapPropertyToAttributeName(property_name, attribute_name);
if (OpStatus::IsMemoryError(status))
return DELETE_NO_MEMORY;
if (OpStatus::IsSuccess(status))
{
DOM_EnvironmentImpl *environment = GetEnvironment();
int index;
BOOL case_sensitive = owner->HasCaseSensitiveNames();
HTML_Element *element = owner->GetThisElement();
if (element->DOMHasAttribute(environment, ATTR_XML, attribute_name.GetStorage(), NS_IDX_ANY_NAMESPACE, case_sensitive, index))
DELETE_FAILED_IF_MEMORY_ERROR(element->DOMRemoveAttribute(environment, attribute_name.GetStorage(), NS_IDX_ANY_NAMESPACE, case_sensitive));
}
return DELETE_OK;
}
/* virtual */ ES_GetState
DOM_DOMStringMap::FetchPropertiesL(ES_PropertyEnumerator *enumerator, ES_Runtime *origining_runtime)
{
ES_GetState result = DOM_Object::FetchPropertiesL(enumerator, origining_runtime);
if (result != GET_SUCCESS)
return result;
TempBuffer property_name;
HTML_AttrIterator it(owner->GetThisElement());
const uni_char* attribute_name;
const uni_char* dummy_value;
while (it.GetNext(attribute_name, dummy_value))
{
property_name.Clear();
OP_STATUS status = MapAttributeToPropertyName(attribute_name, property_name);
if (OpStatus::IsMemoryError(status))
LEAVE(status);
else if (OpStatus::IsSuccess(status))
enumerator->AddPropertyL(property_name.GetStorage());
}
return GET_SUCCESS;
}
/* virtual */ void
DOM_DOMStringMap::GCTrace()
{
GCMark(owner);
}
|
#pragma once
#include "object\Player.h"
class Result {
Player *player;
bool scoreAdded;
int clearBonus;
int point;
int graze;
int player;
int bomb;
double rank;
int total;
public:
Result() = delete;
Result(Player *player);
void Update();
void Draw() const;
};
|
#include "ports.h"
#include <ctime>
int get_valid_port() {
std::srand(std::time(0));
return std::rand() % RANGE_PORT + MIN_PORT;
}
|
#include "PacketInfo.hpp"
PacketInfo::PacketInfo(char* sourceIp, char* destinationIp){
this->sourceIp = new IpAddr(sourceIp); // TODO: exchange with smart pointers
this->destinationIp = new IpAddr(destinationIp);
}
PacketInfo::PacketInfo(std::string& sourceIp, std::string& destinationIp){
// this->sourceIp = // TODO: exchange with smart pointers
this->sourceIp = new IpAddr(sourceIp);
this->destinationIp = new IpAddr(destinationIp);
}
PacketInfo::~PacketInfo(){
delete(this->sourceIp);
delete(this->destinationIp);
}
|
#include <iostream>
#include <fstream>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <map>
#include <vector>
#include <algorithm>
#include <math.h>
#define pb push_back
using namespace std;
int a, b;
int main()
{
freopen("labiec1c.inp", "r", stdin);
scanf("%d %d", &a, &b);
for (int i=a; i<=b; i++) {
if (i%2 == 0)
printf("%d\n", i);
}
return 0;
}
|
// Created on: 1998-06-03
// Created by: data exchange team
// Copyright (c) 1998-1999 Matra Datavision
// Copyright (c) 1999-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#ifndef _ShapeExtend_Explorer_HeaderFile
#define _ShapeExtend_Explorer_HeaderFile
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <TopTools_HSequenceOfShape.hxx>
#include <TopTools_ListOfShape.hxx>
#include <TopAbs_ShapeEnum.hxx>
class TopoDS_Shape;
//! This class is intended to
//! explore shapes and convert different representations
//! (list, sequence, compound) of complex shapes. It provides tools for:
//! - obtaining type of the shapes in context of TopoDS_Compound,
//! - exploring shapes in context of TopoDS_Compound,
//! - converting different representations of shapes (list, sequence, compound).
class ShapeExtend_Explorer
{
public:
DEFINE_STANDARD_ALLOC
//! Creates an object Explorer
Standard_EXPORT ShapeExtend_Explorer();
//! Converts a sequence of Shapes to a Compound
Standard_EXPORT TopoDS_Shape CompoundFromSeq (const Handle(TopTools_HSequenceOfShape)& seqval) const;
//! Converts a Compound to a list of Shapes
//! if <comp> is not a compound, the list contains only <comp>
//! if <comp> is Null, the list is empty
//! if <comp> is a Compound, its sub-shapes are put into the list
//! then if <expcomp> is True, if a sub-shape is a Compound, it
//! is not put to the list but its sub-shapes are (recursive)
Standard_EXPORT Handle(TopTools_HSequenceOfShape) SeqFromCompound (const TopoDS_Shape& comp, const Standard_Boolean expcomp) const;
//! Converts a Sequence of Shapes to a List of Shapes
//! <clear> if True (D), commands the list to start from scratch
//! else, the list is cumulated
Standard_EXPORT void ListFromSeq (const Handle(TopTools_HSequenceOfShape)& seqval, TopTools_ListOfShape& lisval, const Standard_Boolean clear = Standard_True) const;
//! Converts a List of Shapes to a Sequence of Shapes
Standard_EXPORT Handle(TopTools_HSequenceOfShape) SeqFromList (const TopTools_ListOfShape& lisval) const;
//! Returns the type of a Shape: true type if <compound> is False
//! If <compound> is True and <shape> is a Compound, iterates on
//! its items. If all are of the same type, returns this type.
//! Else, returns COMPOUND. If it is empty, returns SHAPE
//! For a Null Shape, returns SHAPE
Standard_EXPORT TopAbs_ShapeEnum ShapeType (const TopoDS_Shape& shape, const Standard_Boolean compound) const;
//! Builds a COMPOUND from the given shape.
//! It explores the shape level by level, according to the
//! <explore> argument. If <explore> is False, only COMPOUND
//! items are explored, else all items are.
//! The following shapes are added to resulting compound:
//! - shapes which comply to <type>
//! - if <type> is WIRE, considers also free edges (and makes wires)
//! - if <type> is SHELL, considers also free faces (and makes shells)
//! If <compound> is True, gathers items in compounds which
//! correspond to starting COMPOUND,SOLID or SHELL containers, or
//! items directly contained in a Compound
Standard_EXPORT TopoDS_Shape SortedCompound (const TopoDS_Shape& shape, const TopAbs_ShapeEnum type, const Standard_Boolean explore, const Standard_Boolean compound) const;
//! Dispatches starting list of shapes according to their type,
//! to the appropriate resulting lists
//! For each of these lists, if it is null, it is firstly created
//! else, new items are appended to the already existing ones
Standard_EXPORT void DispatchList (const Handle(TopTools_HSequenceOfShape)& list, Handle(TopTools_HSequenceOfShape)& vertices, Handle(TopTools_HSequenceOfShape)& edges, Handle(TopTools_HSequenceOfShape)& wires, Handle(TopTools_HSequenceOfShape)& faces, Handle(TopTools_HSequenceOfShape)& shells, Handle(TopTools_HSequenceOfShape)& solids, Handle(TopTools_HSequenceOfShape)& compsols, Handle(TopTools_HSequenceOfShape)& compounds) const;
protected:
private:
};
#endif // _ShapeExtend_Explorer_HeaderFile
|
#include <QDebug>
#include "MasterPlaylist.h"
namespace hls {
MasterPlaylist::MasterPlaylist()
{
}
MasterPlaylist::~MasterPlaylist()
{
}
QList<StreamInf> MasterPlaylist::variantStreams()
{
return mVariantStreams;
}
QList<Media> MasterPlaylist::medias() const
{
return mMedias;
}
void MasterPlaylist::setVariantStreams(const QList<StreamInf> &variantStreams)
{
mVariantStreams = variantStreams;
}
void MasterPlaylist::setMedias(const QList<Media> &medias)
{
mMedias = medias;
}
} // namespace hls
|
#include "msg_0x1e_entity_stc.h"
namespace MC
{
namespace Protocol
{
namespace Msg
{
Entity::Entity()
{
_pf_packetId = static_cast<int8_t>(0x1E);
_pf_initialized = false;
}
Entity::Entity(int32_t _entityId)
: _pf_entityId(_entityId)
{
_pf_packetId = static_cast<int8_t>(0x1E);
_pf_initialized = true;
}
size_t Entity::serialize(Buffer& _dst, size_t _offset)
{
_pm_checkInit();
if(_offset == 0) _dst.clear();
_offset = WriteInt8(_dst, _offset, _pf_packetId);
_offset = WriteInt32(_dst, _offset, _pf_entityId);
return _offset;
}
size_t Entity::deserialize(const Buffer& _src, size_t _offset)
{
_offset = _pm_checkPacketId(_src, _offset);
_offset = ReadInt32(_src, _offset, _pf_entityId);
_pf_initialized = true;
return _offset;
}
int32_t Entity::getEntityId() const { return _pf_entityId; }
void Entity::setEntityId(int32_t _val) { _pf_entityId = _val; }
} // namespace Msg
} // namespace Protocol
} // namespace MC
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.