blob_id
stringlengths 40
40
| directory_id
stringlengths 40
40
| path
stringlengths 2
247
| content_id
stringlengths 40
40
| detected_licenses
listlengths 0
57
| license_type
stringclasses 2
values | repo_name
stringlengths 4
111
| snapshot_id
stringlengths 40
40
| revision_id
stringlengths 40
40
| branch_name
stringlengths 4
58
| visit_date
timestamp[ns]date 2015-07-25 18:16:41
2023-09-06 10:45:08
| revision_date
timestamp[ns]date 1970-01-14 14:03:36
2023-09-06 06:22:19
| committer_date
timestamp[ns]date 1970-01-14 14:03:36
2023-09-06 06:22:19
| github_id
int64 3.89k
689M
โ | star_events_count
int64 0
209k
| fork_events_count
int64 0
110k
| gha_license_id
stringclasses 25
values | gha_event_created_at
timestamp[ns]date 2012-06-07 00:51:45
2023-09-14 21:58:52
โ | gha_created_at
timestamp[ns]date 2008-03-27 23:40:48
2023-08-24 19:49:39
โ | gha_language
stringclasses 159
values | src_encoding
stringclasses 34
values | language
stringclasses 1
value | is_vendor
bool 1
class | is_generated
bool 2
classes | length_bytes
int64 7
10.5M
| extension
stringclasses 111
values | filename
stringlengths 1
195
| text
stringlengths 7
10.5M
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
096059c15c82102f5394b6f416dfd26b62cccd0e
|
609aa99c768388654af6086b8fdc696e550bf24e
|
/src/Driver.h
|
ca76bb415ccaa9ccf2ce9ca7e62e9241435b25ef
|
[
"BSD-3-Clause"
] |
permissive
|
criort/libPRISM
|
db702e31fe6891687a56dad5454fb65e00370de6
|
7bcd991a9e44e8e22e58afc039e2c182f5f284c7
|
refs/heads/master
| 2021-01-19T12:53:40.996585
| 2017-09-14T08:37:16
| 2017-09-14T08:37:16
| 88,055,288
| 5
| 2
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 3,908
|
h
|
Driver.h
|
/*
* Copyright (c) 2017, Barcelona Supercomputing Center and International Business Machines.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* * Redistributions of source code must retain the above copyright notice, this
* list of conditions and the following disclaimer.
*
* * Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* * Neither the name of the copyright holder nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
* Author: Cristobal Ortega <cortega@bsc.es>, <cristo@us.ibm.com>
*
*/
#ifndef SRC_DRIVER_H_
#define SRC_DRIVER_H_
#include <stdlib.h>
#include <string>
#include <vector>
#include <cstdio>
#include "Sensor.h"
#include "Policy.h"
#include "DummyPolicy.h"
#include "OraclePolicy.h"
#include "ExplorationPolicy.h"
#include "utils/utils.h"
#include "sys/unistd.h"
#include "sys/types.h"
// Object Policy
Policy * _policy;
// Track parallelism level
int max_level;
int level;
void __attribute__((constructor)) PRISM_init(void);
void __attribute__((destructor)) PRISM_fini(void);
/** Library API
* API to libPRISM
*/
/**
* API to communicate to PRISM that a parallel region has started
* @param PC Value of Program Counter where the parallel region starts, used as Identifier for that region
* @param nthreads Number of threads that originially the parallel region was using
*/
void PRISM_parallelStart(int PC, int nthreads);
/**
* API to communicate to PRISM that a parallel region ended
* @param PC Value of Program Counter where the parallel region end, used as Identifier for that region, just for information.
*/
void PRISM_parallelEnd(int PC);
/**
* API to communicate to PRISM that a pthread was created
* @param pid PID of the created pthread
*/
void PRISM_pthread_create(pid_t pid);
/**
* API to communicate to PRISM that the programmer changed the number of threads through the call omp_set_num_threads
* @param nthreads Number of threads that the programmer wants to use
*/
void PRISM_setNumThreads(int nthreads);
/**
* API to communicate to PRISM that the program is about to enter in a parallel region identified with PC, PRISM should
* make the changes in the current configuration to get the best configuration for the active policy
* @param PC Identifier of the parallel region the program will enter
*/
void PRISM_bestConfig(int PC);
/**
* API to communicate to PRISM that the program is about to enter in a parallel region identified with PC, which has tasks to be completed
* PRISM should
* make the changes in the current configuration to get the best configuration for the active policy
* @param PC Identifier of the parallel region the program will enter
*/
void PRISM_taskBasedParallel(int PC);
#endif // SRC_DRIVER_H_
|
14f02aa636cac586823cfb367a0c7b23587bd59c
|
cbe0cb8c0a1456e6e793283090ef2e11c97709ed
|
/lecture_012_graph/question.cpp
|
f7fef408f455de0a2aaea929e253ebbf894bd1d8
|
[] |
no_license
|
varunjeett/PepCodes
|
cd84ff9f75eedac79b0136e7e37278902337b9ee
|
c27cfa7e63a0d9629529848fdbea712893a5a1f0
|
refs/heads/master
| 2023-04-05T18:23:26.154712
| 2021-04-14T06:03:10
| 2021-04-14T06:03:10
| 294,819,356
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 1,444
|
cpp
|
question.cpp
|
//leetcode 542.==================================================
class Solution {
public:
vector<vector<int>> updateMatrix(vector<vector<int>>& arr) {
int n=arr.size();
int m=arr[0].size();
queue<int> q;
vector<vector<bool>>vis(n,vector<bool>(m,false));
for(int i=0;i<n; i++) {
for(int j=0; j<m; j++) {
if(arr[i][j]==0) {
q.push(i*m+j); //pushing all zeroes
vis[i][j]=true;
}
}
}
int level=0;
vector<int> dir={-1,0,1,0,-1};
while(q.size()!=0) {
int sz=q.size();
while(sz-- > 0) {
int ele=q.front();
q.pop();
int r=ele/m;
int c=ele%m;
arr[r][c]=level; //consider it as a virtual zero ,as a path for other one.===
for(int d=0; d<dir.size()-1;d++){
int x=r+dir[d];
int y=c+dir[d+1];
if(x>=0 && y>=0 && x<n && y<m && arr[x][y]==1 && !vis[x][y]) {
q.push(x*m+y);
vis[x][y]=true;
}
}
}
level++;
}
return arr;
}
};
|
9adda27482f91fb6ab97c1b0ffb2c1a571afb62b
|
76316a343e1b9909d991549e21158de51b6de597
|
/ballastwidget.cpp
|
e9e85c42467675ffc65474b081ebabf68b0d7ea4
|
[] |
no_license
|
MaksStalker1985/LevelApp
|
50433d8ea4e80a26767fc5b9f9069eed28e3e4d6
|
2707d87449ea911622eec542cfa6a019cf4429dc
|
refs/heads/master
| 2023-08-26T11:11:42.556535
| 2021-10-01T14:29:30
| 2021-10-01T14:29:30
| 408,053,079
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 754
|
cpp
|
ballastwidget.cpp
|
#include "ballastwidget.h"
#include "ui_ballastwidget.h"
BallastWidget::BallastWidget(QWidget *parent) :
QWidget(parent),
ui(new Ui::BallastWidget)
{
ui->setupUi(this);
connect(this,&BallastWidget::insertItem,&BallastWidget::addUnit);
}
BallastWidget::~BallastWidget()
{
delete ui;
}
void BallastWidget::addUnit(QWidget *ptr_wdg, int position_x, int position_y, int type)
{
switch (type) {
case afterPeak:{
ui->aptLayout->addWidget(ptr_wdg,0,Qt::AlignCenter);
break;
}
case usual:{
ui->gridLayout->addWidget(ptr_wdg,position_x,position_y,Qt::AlignCenter);
break;
}
case forpeak:{
ui->fptLayout->addWidget(ptr_wdg,0,Qt::AlignCenter);
break;
}
}
}
|
edfd83fa65b615bd9e3c9534b15828d0bae7e21a
|
af0ecafb5428bd556d49575da2a72f6f80d3d14b
|
/CodeJamCrawler/dataset/08_5042_30.cpp
|
2305a0f56d67be29c5e4ad940cac527a5a7332b8
|
[] |
no_license
|
gbrlas/AVSP
|
0a2a08be5661c1b4a2238e875b6cdc88b4ee0997
|
e259090bf282694676b2568023745f9ffb6d73fd
|
refs/heads/master
| 2021-06-16T22:25:41.585830
| 2017-06-09T06:32:01
| 2017-06-09T06:32:01
| null | 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 2,487
|
cpp
|
08_5042_30.cpp
|
#pragma warning (disable:4786)
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <windows.h>
#include <map>
#include <string>
#include <iostream>
#include <vector>
#include <algorithm>
#include <functional>
using namespace std;
//vector <int> x;
//vector <int>::iterator iter;
int s1[1450][100],s2[1450][100];
int v1[1450],v2[1450];
int main()
{
int d1,d2,d3,d4,a,b;
int z,out,k,i,last,flag,j,ansA,ansB,key,T,temp,l,min1,min2;
char ch[5000];
char list[1010][500];
freopen("B-small-attempt4.in","r",stdin);
freopen("output.txt","w",stdout);
gets(ch);sscanf(ch,"%d",&z);
for (out=1;out<=z;out++)
{
ansA=0; ansB=0;
memset(s1,0,sizeof(s1));
memset(s2,0,sizeof(s2));
memset(v1,0,sizeof(v1));
memset(v2,0,sizeof(v2));
gets(ch);sscanf(ch,"%d",&T);
gets(ch);sscanf(ch,"%d %d",&a,&b);
for (i=1;i<=a;i++)
{
gets(ch); sscanf(ch,"%d:%d %d:%d",&d1,&d2,&d3,&d4);
s1[d1*60+d2][0]++; s1[d1*60+d2][s1[d1*60+d2][0]] = d3 * 60 + d4;
v2[d3 * 60 + d4 + T]++;
}
for (i=1;i<=b;i++)
{
gets(ch); sscanf(ch,"%d:%d %d:%d",&d1,&d2,&d3,&d4);
s2[d1*60+d2][0]++; s2[d1*60+d2][s2[d1*60+d2][0]] = d3 * 60 + d4;
v1[d3 * 60 + d4 + T]++;
}
/*
for (i=0;i<=1440;i++)
{
if (s1[i][0]>1)
{
for (j=1;j<s1[i][0];j++)
for (k=j+1;k<=s1[i][0];k++)
if (s1[i][j]<s1[i][k])
{
temp=s1[i][j]; s1[i][j]=s1[i][k]; s1[i][k]=temp;
}
}
if (s2[i][0]>1)
{
for (j=1;j<s2[i][0];j++)
for (k=j+1;k<=s2[i][0];k++)
if (s2[i][j]<s2[i][k])
{
temp=s2[i][j]; s2[i][j]=s2[i][k]; s2[i][k]=temp;
}
}
}
*/
for (i=0;i<=23*60+59;i++)
{
if (s1[i][0]>0)
{
for (l=0;l<=i;l++)
{
if (v1[l]>0)
{
while(s1[i][0]>0 && v1[l]>0)
{
s1[i][0]--;
v1[l]--;
}
}
if (s1[i][0]==0) break;
}
if (s1[i][0]>0) ansA+=s1[i][0];
while(s1[i][0]>0)
{
s1[i][0]--;
}
}
if (s2[i][0]>0)
{
for (l=0;l<=i;l++)
{
if (v2[l]>0)
{
while(s2[i][0]>0 && v2[l]>0)
{
s2[i][0]--;
v2[l]--;
}
}
if (s2[i][0]==0) break;
}
if (s2[i][0]>0) ansB+=s2[i][0];
while(s2[i][0]>0)
{
s2[i][0]--;
}
}
}
printf("Case #%d: %d %d\n",out,ansA,ansB);
}
return 1;
}
|
27073097513639872380a11debfc4acd3791fe5d
|
e782b2fe6b3c0b20513c8334ba653030efbbc341
|
/source/gl_wrapper/GLWFCallbacks.cpp
|
9422a8a90301cef8172534e2c0485938e59c3184
|
[] |
no_license
|
VladasZ/gl_wrapper
|
b8f0d3f3186194cc3d5847639df581918b2f18a3
|
f4e54b596110a9c3875a4e482f12e272cbf66108
|
refs/heads/master
| 2021-06-14T17:22:52.536071
| 2021-03-29T10:33:35
| 2021-03-29T10:33:35
| 173,499,860
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 1,536
|
cpp
|
GLWFCallbacks.cpp
|
//
// GLWFCallbacks.cpp
// gl_wrapper
//
// Created by Vladas Zakrevskis on 15/12/19.
// Copyright ยฉ 2019 VladasZ. All rights reserved.
//
#include "GLWFCallbacks.hpp"
#ifdef DESKTOP_BUILD
#include "GLDebug.hpp"
#include "GLWrapper.hpp"
#include "OpenGLHeaders.hpp"
void size_changed(GLFWwindow* window, int width, int height) {
GL::on_window_size_change({ static_cast<float>(width * GL::render_scale), static_cast<float>(height * GL::render_scale) });
GL(glfwSwapBuffers(window));
}
void mouse_button_callback(GLFWwindow*,
int glfw_button,
int action,
int) {
auto button = GL::MouseButton::Left;
if (glfw_button == GLFW_MOUSE_BUTTON_RIGHT ) button = GL::MouseButton::Right ;
else if (glfw_button == GLFW_MOUSE_BUTTON_MIDDLE) button = GL::MouseButton::Middle;
GL::on_mouse_key_pressed(button, action == GLFW_PRESS ? GL::ButtonState::Down : GL::ButtonState::Up);
}
void cursor_position_callback([[maybe_unused]] GLFWwindow* window, double x, double y) {
GL::on_cursor_moved({ x / GL::render_scale, y / GL::render_scale });
}
void scroll_callback([[maybe_unused]] GLFWwindow* window, double xoffset, double yoffset) {
GL::on_scroll_moved({ xoffset, yoffset });
}
void key_callback([[maybe_unused]] GLFWwindow* window,
int key,
[[maybe_unused]] int scancode,
int action,
int mod) {
GL::on_key_pressed(key, mod, action);
}
#endif
|
47cc7f1d1d367f194bd324c405f0726e358943aa
|
e0dcdf93a4c214b65d8cab18d4aca837664ec1cd
|
/ml_engine/source/src/DbAdmin.cpp
|
218e256cf8f4bda4ded9544d5c846120a2d6e2fb
|
[] |
no_license
|
andy-zha/trunk
|
6af03478a78746f0850e020e0ef0aaf26c05799c
|
1e8712e6bf98af9d5cf4b49464c84b2c4341d749
|
refs/heads/master
| 2020-05-25T01:16:24.277786
| 2019-10-11T07:58:00
| 2019-10-11T07:58:00
| 187,550,095
| 1
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 4,564
|
cpp
|
DbAdmin.cpp
|
#include "DbAdmin.h"
//ๆ้ ๅฝๆฐ
DbAdmin::DbAdmin()
{
conn = nullptr;
}
//ๆๆๅฝๆฐ
DbAdmin::~DbAdmin()
{}
//่ฟๆฅๆฅๅฃ
int32_t DbAdmin::connect()
{
try
{
conn = mysql_init(nullptr);
if (!mysql_real_connect(conn, NS_DBADMIN::HOST, NS_DBADMIN::USER,
NS_DBADMIN::PASSWD, NS_DBADMIN::DBNAME, 0, nullptr, CLIENT_FOUND_ROWS))
{
return RET::FAIL;
}
}
catch(...)
{
return RET::FAIL;
}
return RET::SUC;
}
//ๆญๅผ่ฟๆฅๆฅๅฃ
int32_t DbAdmin::close()
{
if (nullptr == conn)
{
return RET::SUC;
}
try
{
mysql_close(conn);
mysql_library_end();
conn = nullptr;
}
catch(...)
{
return RET::FAIL;
}
return RET::SUC;
}
//ๆง่กๆฅ่ฏข่ฏญๅฅๆฅๅฃ
int32_t DbAdmin::execQuery(std::string Sql, MYSQL_RES *&pResult)
{
if (nullptr == conn)
{
return RET::FAIL;
}
try
{
if (0 != mysql_query(conn, Sql.c_str()))
{
return RET::FAIL;
}
}
catch(...)
{
return RET::FAIL;
}
pResult = mysql_store_result(conn);
return RET::SUC;
}
//ๆง่ก่ฏญๅฅๆฅๅฃ
int32_t DbAdmin::execSql(std::string Sql)
{
if (nullptr == conn)
{
return RET::FAIL;
}
try
{
if (0 != mysql_query(conn, Sql.c_str()))
{
return RET::FAIL;
}
}
catch(...)
{
return RET::FAIL;
}
return RET::SUC;
}
int32_t DbAdmin::stmtExecQuery(std::string Sql, std::vector<std::string> Vec,
uint32_t uCount, std::vector<std::vector<std::string>> &Res)
{
//ๅผๅธธๅคๆญ
uint32_t param_count = Vec.size();
if (0 == Sql.size() || 0 == uCount
|| 0 == param_count || nullptr == conn)
{
return RET::FAIL;
}
//ๅๅงๅ้ขๅค็็ฏๅขๅฅๆ MYSQL_STMT *stmt
MYSQL_STMT *stmt = mysql_stmt_init(conn);
if (nullptr == stmt)
{
return RET::FAIL;
}
//ๅ้ขๅค็็ฏๅขๅฅๆstmt ไธญๆทปๅ sql( ๅธฆๆๅ ไฝ็ฌฆ)
if (mysql_stmt_prepare(stmt, Sql.c_str(), Sql.size()))
{
mysql_stmt_close(stmt);
return RET::FAIL;
}
//่ทๅsql่ฏญ่จไธญๅ ไฝ็ฌฆ็ไธชๆฐ
if (param_count != mysql_stmt_param_count(stmt))
{
mysql_stmt_close(stmt);
return RET::FAIL;
}
//ๅๅงๅbindๆฐ็ป
MYSQL_BIND bind[param_count];
memset(bind, 0, sizeof(bind));
for (uint32_t uIndex = 0; uIndex < param_count; uIndex++)
{
bind[uIndex].buffer_type = MYSQL_TYPE_STRING;
bind[uIndex].buffer = (char*)(Vec[uIndex].c_str());
bind[uIndex].is_null = nullptr;
bind[uIndex].buffer_length = Vec[uIndex].size();
}
//bind buffers
if (mysql_stmt_bind_param(stmt, bind))
{
mysql_stmt_close(stmt);
return RET::FAIL;
}
//็ปๅฎresult
char tmp[uCount][1024];
MYSQL_BIND result[uCount];
memset(result, 0, sizeof(result));
for (uint32_t ui = 0; ui < uCount; ui++)
{
result[ui].buffer_type = MYSQL_TYPE_STRING;
result[ui].buffer = tmp[ui];
result[ui].buffer_length = sizeof(tmp);
}
if (mysql_stmt_bind_result(stmt, result))
{
mysql_stmt_close(stmt);
return RET::FAIL;
}
//ๆง่ก่ฏญๅฅ
if (mysql_stmt_execute(stmt))
{
mysql_stmt_close(stmt);
return RET::FAIL;
}
//ๅๅบๆฅ่ฏข็ปๆ
if (mysql_stmt_store_result(stmt))
{
mysql_stmt_close(stmt);
return RET::FAIL;
}
while (0 == mysql_stmt_fetch(stmt))
{
std::vector<std::string> res;
for (uint32_t uIndex = 0; uIndex < uCount; uIndex++)
{
std::string bak = tmp[uIndex];
res.push_back(bak);
}
Res.push_back(res);
}
//้ๆพๅ
ๅญ๏ผๅ
ณ้ญๅฅๆ
mysql_stmt_close(stmt);
return RET::SUC;
}
int32_t DbAdmin::stmtExecSql(std::string Sql, std::vector<std::string> Vec)
{
uint32_t param_count = Vec.size();
if (0 == param_count || nullptr == conn)
{
return RET::FAIL;
}
//ๅๅงๅ้ขๅค็็ฏๅขๅฅๆMYSQL_STMT *stmt
MYSQL_STMT *stmt = mysql_stmt_init(conn);
if (nullptr == stmt)
{
return RET::FAIL;
}
//ๅ้ขๅค็็ฏๅขๅฅๆstmtไธญๆทปๅ sql(ๅธฆๆๅ ไฝ็ฌฆ)
if (mysql_stmt_prepare(stmt, Sql.c_str(), Sql.size()))
{
mysql_stmt_close(stmt);
return RET::FAIL;
}
//่ทๅsql่ฏญ่จไธญๅ ไฝ็ฌฆ็ไธชๆฐ
if (param_count != mysql_stmt_param_count(stmt))
{
mysql_stmt_close(stmt);
return RET::FAIL;
}
//ๅๅงๅbindๆฐ็ป
MYSQL_BIND bind[param_count];
for (uint32_t uIndex = 0; uIndex < param_count; uIndex++)
{
bind[uIndex].buffer_type = MYSQL_TYPE_STRING;
bind[uIndex].buffer = (char*)(Vec[uIndex].c_str());
bind[uIndex].is_null = nullptr;
unsigned long Strlen = Vec[uIndex].size();
bind[uIndex].length = &Strlen;
}
//bind buffers
if (mysql_stmt_bind_param(stmt, bind))
{
mysql_stmt_close(stmt);
return RET::FAIL;
}
//ๆง่ก่ฏญๅฅ
if (mysql_stmt_execute(stmt))
{
mysql_stmt_close(stmt);
return RET::FAIL;
}
mysql_stmt_close(stmt);
return RET::SUC;
}
|
d0c65ffca1c154acb71d11cd3c526d86e5a4e314
|
e5f7f5ec52e4745ae61c3f52309e82a80fb18073
|
/src/Interpol.cpp
|
9a90406f64cc72055ea864c92a7b2bdbb73e639a
|
[] |
no_license
|
szabiyako/Interpolation
|
757006f90d8b4fbf6ace910dff630be85cbd629e
|
01d00033d6cb2d333e060d4d4ce7588ea399dcb9
|
refs/heads/master
| 2020-07-23T02:31:49.139544
| 2019-09-14T05:25:29
| 2019-09-14T05:25:29
| 207,418,943
| 0
| 0
| null | null | null | null |
WINDOWS-1251
|
C++
| false
| false
| 3,484
|
cpp
|
Interpol.cpp
|
#include "Interpol.h"
//PRIVATE
double Interpol::l(int &i, double &j, int &begin_index, int &end_index)
{
int size = this->y->size();
double answer = 1;
for (int k = begin_index; k <= end_index; k++)
{
if (k == i)
continue;
answer *= ((j - k) / (i - k));
}
Console::addLine(L"l(i=" + std::to_wstring(i) + L", j=" + std::to_wstring(j) + L") = " + std::to_wstring(answer));
return answer;
}
void Interpol::fillAdditional()
{
int size = this->y->size();
int k = 0;
for (double j = 0.5; j < size - 1; j += 1.0)
{
double answer = 0;
int begin_index;
int end_index;
this->getBeginEnd(j, begin_index, end_index);
Console::addLine(L"ะััะธัะปัะตะผ l(x" + std::to_wstring(j) + L") ััะตะฟะตะฝะธ " + std::to_wstring(m)
+ L" ะฟะพ ัะพัะบะฐะผ ั x" + std::to_wstring(begin_index) + L" ะฟะพ x" + std::to_wstring(end_index));
for (int i = begin_index; i <= end_index; i++)
{
answer += this->y->at(i) * this->l(i, j, begin_index, end_index);
}
this->yAdditional->at(k++) = answer;
Console::addLine(L"ะััะธัะปัะตะผ L(x" + std::to_wstring(j) + L") ััะตะฟะตะฝะธ " + std::to_wstring(m)
+ L" ะฟะพ ัะพัะบะฐะผ ั x" + std::to_wstring(begin_index) + L" ะฟะพ x" + std::to_wstring(end_index));
Console::addLine(L"L(m=" + std::to_wstring(this->m) + L", j=" + std::to_wstring(j) + L") = " + std::to_wstring(answer));
Console::addLine(L"--------------------");
}
}
std::vector<double> Interpol::getAnswerVector()
{
this->fillAdditional();
int size = this->y->size();
std::vector<double> answer(2 * size - 1);
bool first = true;
for (int i = 0, j = 0, k = 0; i < size; k++)
{
if (first)
answer[k] = this->y->at(i++);
else
answer[k] = this->yAdditional->at(j++);
first = first ? false : true;
}
return answer;
}
void Interpol::getBeginEnd(double & j, int & begin, int & end)
{
int m = (int)this->m;
begin = (int)j;
end = begin + 1;
m--;
int last = this->y->size() - 1;
while (m != 0)
{
if (begin > 0)
{
begin--;
m--;
}
if (m != 0 && end < last)
{
end++;
m--;
}
}
}
//PUBLIC
Interpol::Interpol()
{
this->input = new std::ifstream();
this->output = new std::ofstream();
}
Interpol::~Interpol()
{
if (this->yAdditional != nullptr)
delete this->yAdditional;
if (this->y != nullptr)
delete this->y;
this->input->close();
this->input->close();
delete this->input;
delete this->output;
}
int Interpol::openFilesAndRead(const char * pathIn, const char * pathOut)
{
this->input->open(pathIn);
if (!this->input->is_open())
{
return -1;
}
this->output->open(pathOut);
if (!this->output->is_open())
{
return -2;
}
unsigned int size;
*this->input >> size;
*this->input >> m;
if (m >= size || m == 0)
{
*this->output << 1;
return -3;
}
this->y = new std::vector<double>(size);
this->yAdditional = new std::vector<double>(size - 1);
for (unsigned int i = 0; i < size; i++)
{
double temp;
*this->input >> temp;
this->y->at(i) = temp;
}
return 0;
}
void Interpol::outFileAnswer()
{
std::vector<double> v(this->getAnswerVector());
int size = v.size();
Console::addLine(L"ะะฐะฟะธัั ะพัะฒะตัะฐ ะฒ ัะฐะนะป");
Console::addLine(L"--------------------");
for (int i = 0; i < size; i++)
{
*this->output << std::fixed;
//How many numbers will shows (EX 1.234852134000) -precision(12)
this->output->precision(8);
*this->output << v.at(i) << "\n";
//LOGS
Console::addLine(std::to_string(v.at(i)));
}
*this->output << "\n0";
}
|
e5ff9de99d13c7c35c9727edb6a431ceadda6ebd
|
39d9c789c1d9e8eb28a3766831451bc8aa3fbda1
|
/python/set_replace/match_py.cpp
|
2a2cb998bfe973646da160ff204e2d0ecbe3db8d
|
[
"MIT"
] |
permissive
|
greenboat11/wolfram_model
|
081d883680342078a48e83deeb9169c9726c7c4b
|
a4dd26295df7cb995ce666007860ca86efa38e8a
|
refs/heads/master
| 2023-03-15T12:54:16.200845
| 2020-06-03T22:01:13
| 2020-06-03T22:01:13
| null | 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 3,515
|
cpp
|
match_py.cpp
|
/* Copyright (c) 2020 Pablo Hernandez-Cerdan
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE. */
#include "Match.hpp"
#include <sstream>
#include "set_replace_common_py.hpp"
#include "SetReplaceIO.hpp"
namespace py = pybind11;
using namespace SetReplace;
void init_match(py::module &m) {
py::class_<Matcher, std::shared_ptr<Matcher> > matcher(m, "matcher",
"Set that will evolve based on rules.\n");
matcher.def(
py::init(
[](const std::vector<Rule> &in_rules, AtomsIndex *in_atomsIndex,
const std::function<AtomsVector(ExpressionID)> &in_getAtomsVector,
const Matcher::OrderingSpec &in_orderingSpec,
const unsigned int in_randomSeed) {
return std::make_shared<Matcher>(in_rules, in_atomsIndex,
in_getAtomsVector,
in_orderingSpec, in_randomSeed);
}),
py::arg("rules"), py::arg("atoms_index"), py::arg("get_atoms_vector"),
py::arg("ordering"), py::arg("random_seed") = 0);
matcher.def("add_matches_involving_expressions",
&Matcher::addMatchesInvolvingExpressions);
matcher.def("remove_matches_involving_expressions",
&Matcher::removeMatchesInvolvingExpressions);
matcher.def("empty", &Matcher::empty);
matcher.def("nextMatch", &Matcher::nextMatch);
matcher.def("substitute_missing_atoms_if_possible",
&Matcher::substituteMissingAtomsIfPossible);
matcher.def("all_matches", &Matcher::allMatches);
/*****************************************************************************/
py::enum_<Matcher::OrderingDirection>(matcher, "ordering_direction",
"OrderingDirection for Matcher.")
.value("Normal", Matcher::OrderingDirection::Normal)
.value("Reverse", Matcher::OrderingDirection::Reverse);
/*****************************************************************************/
py::enum_<Matcher::OrderingFunction>(matcher, "ordering_function",
"OrderingFunction for Matcher.")
.value("SortedExpressionIDs",
Matcher::OrderingFunction::SortedExpressionIDs)
.value("ReverseSortedExpressionIDs",
Matcher::OrderingFunction::ReverseSortedExpressionIDs)
.value("ExpressionIDs", Matcher::OrderingFunction::ExpressionIDs)
.value("RuleIndex", Matcher::OrderingFunction::RuleIndex);
}
|
0b5c9adf38b2aff58e4e2a51f4d0ff8ec628d897
|
33c8f4a71ca4fe71578d8f4bb6f8e4633142d855
|
/isMatch/isMatch/test.cpp
|
609f32d5de5d97b467f62d6364b75fb9a28ac5d7
|
[] |
no_license
|
siwei1234/cpp
|
87252867c02f7c5429b7b241129512e0ac0d5cf1
|
6a8316f4a8dc6c4db681a8ff113db9ea955d14d2
|
refs/heads/master
| 2021-05-21T15:26:04.706931
| 2021-01-20T08:51:45
| 2021-01-20T08:51:45
| 252,688,553
| 1
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 706
|
cpp
|
test.cpp
|
#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
#include<string>
using namespace std;
class Solution {
public:
bool _isMatch(const char* s, const char* p)
{
if (!*p) return !*s;
if (*(p + 1) != '*')
{
if (*s == *p || (*p == '.' && *s != '\0'))
{
return _isMatch(s + 1, p + 1);
}
else
return false;
}
else
{
if (*s == *p || (*p == '.' && *s != '\0'))
{
return _isMatch(s, p + 2) || _isMatch(s + 1, p);
}
else
{
return _isMatch(s, p + 2);
}
}
}
bool isMatch(string s, string p) {
return _isMatch(s.c_str(), p.c_str());
}
};
int main()
{
string s = "aab";
string p = "c*a*b";
cout << Solution().isMatch(s, p) << endl;
return 0;
}
|
be5bcc17ccd1323f7d8f46a56e365d4fcb5a446e
|
4ceb488e829ab2f30e9846c478ab4c8c21ce22a1
|
/competitive_programming/codeforces/711_div2/c.cpp
|
0622eba6c1c9b863614685390e4a54011aaa4914
|
[] |
no_license
|
luatil/cppractice
|
f24eded2aa425e06f07526459bb61ab681b0d50a
|
7d9989f1aa3261603179238f091d41650fb42cdd
|
refs/heads/main
| 2023-05-23T18:59:54.681986
| 2021-06-03T15:00:13
| 2021-06-03T15:00:13
| 334,229,008
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 307
|
cpp
|
c.cpp
|
#include <bits/stdc++.h>
using namespace std;
#define all(v) v.begin(), v.end()
#define REP(i, n) for(int i = 0; i < n; i++)
#define ll long long
#define vi vector<int>
void solve()
{
}
int main()
{
ios::sync_with_stdio(false);
cin.tie(0);
int t; cin >> t;
while(t--)
solve();
}
|
9bcf58c2bda3afa99e804547c708568d34fc0632
|
7d3959c7f44995f4899ccf782faf1615526ed2fa
|
/main.cpp
|
4b0dbb5c85091ad2d8e70601502022f8d98a6a27
|
[] |
no_license
|
Tim301/VQA_Launcher
|
4b6d9e8cab780f9ece946826e5aab98e170df01e
|
d5aed2cde7041c9f92a0e4e7795362099fb11dd4
|
refs/heads/master
| 2022-12-18T01:00:35.723669
| 2020-09-29T15:45:44
| 2020-09-29T15:45:44
| 277,475,084
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 15,033
|
cpp
|
main.cpp
|
#include <iostream>
#include <fstream>
#include <sstream>
#include <stdio.h>
#include <math.h>
#include <opencv2/opencv.hpp>
#include <thread>
#include <mutex>
#include <cstdio>
#include <iostream>
#include <memory>
#include <stdexcept>
#include <string>
#include <array>
#include <nlohmann/json.hpp>
using json = nlohmann::json;
/* Credit correlation() - Paul Bourke */
void correlation(double* x, double* y, int n, double* r/*out*/)
{
int i, j, delay, maxdelay;
double mx, my, sx, sy, sxy, denom;
maxdelay = n / 2;
/* Calculate the mean of the two series x[], y[] */
mx = 0;
my = 0;
for (i = 0;i < n;i++) {
mx += x[i];
my += y[i];
}
mx /= n;
my /= n;
/* Calculate the denominator */
sx = 0;
sy = 0;
for (i = 0;i < n;i++) {
sx += (x[i] - mx) * (x[i] - mx);
sy += (y[i] - my) * (y[i] - my);
}
denom = sqrt(sx * sy);
/* Calculate the correlation series */
for (delay = -maxdelay;delay < maxdelay;delay++) {
sxy = 0;
for (i = 0;i < n;i++) {
j = i + delay;
if (j < 0 || j >= n)
continue;
else
sxy += (x[i] - mx) * (y[j] - my);
/* Or should it be (?)
if (j < 0 || j >= n)
sxy += (x[i] - mx) * (-my);
else
sxy += (x[i] - mx) * (y[j] - my);
*/
}
r[delay + maxdelay] = sxy / denom;
/* r is the correlation coefficient at "delay" */
}
}
std::string exec(const std::string strcmd) {
int n = strcmd.length();
char* charcmd = new char[n + 1];
strcpy(charcmd, strcmd.c_str());
std::array<char, 128> buffer;
std::string result;
std::unique_ptr<FILE, decltype(&pclose)> pipe(popen(charcmd, "r"), pclose);
if (!pipe) {
throw std::runtime_error("popen() failed!");
}
while (fgets(buffer.data(), buffer.size(), pipe.get()) != nullptr) {
result += buffer.data();
}
return result;
}
int main(int argc, const char* argv[])
{
auto start = std::chrono::system_clock::now(); //QStart Chrono
std::cout << "V3: " << std::endl;
if (argc == 2) {
json json = json::parse(argv[1]); // Parse json passed as argument
std::string ref = json["ref"]; //
//std::string converted = json["converted"];
unsigned int window = 1200;
if (!json["window"].is_null()){
window = json["window"];
}
std::cout <<"Search window: " << window << std::endl;
std::vector<std::string> comps = json["comps"];
std::vector< std::vector<float> > corr;
corr.reserve(json["comps"].size()+1);
for (unsigned int i = 0; i < json["comps"].size()+1; i++) {
corr.push_back(std::vector<float>(window));
}
std::cout << "Start delay synchronize" << std::endl;
//Get mean luma of each frame for future cross-correlation
uint8_t fps;
cv::VideoCapture cap;
for (unsigned int i = 0; i < json["comps"].size()+1; i++) {
if (i == 0) {
cap = cv::VideoCapture(ref);
fps = cap.get(cv::CAP_PROP_FPS); //Get framerate. Needed later.
} else {
cap = cv::VideoCapture(comps[i-1]);
}
for (unsigned int j = 0; cap.isOpened() && j < window; j++) {
cv::Mat img;
cap >> img;
cv::Mat cropimg;
//img(cv::Rect(cv::Point(0, 0), cv::Point(100, 100))).copyTo(cropimg);
//cv::imshow("test", img);
//cv::waitKey(0);
cv::Scalar m = cv::sum(img);
//std::cout <<"nยฐ"<<j<<": " << m[0] << std::endl;
//corr[i][j] = m[0] + m[1] + m[2]; // A faire: Vรฉrifier qu'on utilise le vert.
corr[i][j] = m[0]; // A faire: Vรฉrifier qu'on utilise le vert.
}
}
//Luma mean for reference
double corref[window];
for (unsigned int j = 0; j < window; j++) {
corref[j] = corr[0][j];
}
std::cout <<"Results:" << std::endl;
std::vector<int> delay;
delay.reserve(json["comps"].size()+1);
delay.push_back(0); //Set delay for ref at [0]
//Cross-correlation for each comps
for (unsigned int i = 0; i < json["comps"].size(); i++) {
double comps[window]; //Luma mean for comps
double coefcorr[window]; //Coefficients of cross-corr
for (unsigned int j = 0; j < window; j++) {
comps[j] = corr[i + 1][j];
coefcorr[j] = 0; //Initialize array
}
correlation(corref, comps, window, coefcorr); //See cross-correlation function
long index;
double maxcorr = -2; // correlaration between -1 and 1
for (unsigned int j = 0; j < window; j++) {
if (coefcorr[j] > maxcorr) {
maxcorr = coefcorr[j];
index = j;
//std::cout << "Max: " << coefcorr[j] << std::endl;
}
//std::cout << "Index: "<< j <<" , Value: " << coefcorr[j] << std::endl;
}
//std::cout << "-----------------------------" << std::endl;
std::cout << "Delay: " << index - window / 2 << ", MaxCoef: " << maxcorr << std::endl;
delay.push_back(index - (window / 2));
}
std::cout << "Start compute PSNR&SSIM by ffmpeg" << std::endl;
for (unsigned long i = 1; i < delay.size(); i++) {
std::string comp = comps[i-1];
std::string name = comp.substr(comp.find_last_of("/\\") + 1);
size_t p = name.find_last_of('.');
name = name.substr(0, p);
name = name + ".log";
float delaycomp_pts = 0;
float delayref_pts = 0;
if ((float) delay[i] / fps >=0) {
delaycomp_pts = (float) delay[i] / fps;
delayref_pts = 0;
} else {
delaycomp_pts = 0;
delayref_pts = std::abs((float) delay[i] / fps);
}
//std::cout <<"Framerate: " << fps << std::endl;
//std::cout <<"Delay compspts: " << delaycomp_pts << ", delay refpst: " << delayref_pts << std::endl;
//std::string strcmd = "ffmpeg -y -nostats -loglevel 0 -i " + comp + " -i " + ref + " -lavfi \"[0:v]settb=AVTB,setpts=PTS-" + std::to_string(delaycomp_pts) +"/TB[main];[1:v]settb=AVTB,setpts=PTS-" + std::to_string(delayref_pts) +"/TB[ref];[main][ref] psnr=stats_file='[PSNR]" + name + "'\" -f null -";
std::string strcmd = "ffmpeg -i " + comp + " -i " + ref + " -lavfi \"[0:v]settb=AVTB,setpts=PTS-" + std::to_string(delaycomp_pts) +"/TB[main];[1:v]settb=AVTB,setpts=PTS-" + std::to_string(delayref_pts) +"/TB[ref];[main][ref] psnr=stats_file='[PSNR]" + name + "'\" -f null -";
//std::cout << strcmd << std::endl;
exec(strcmd);
strcmd = "ffmpeg -y -nostats -loglevel 0 -i " + comp + " -i " + ref + " -lavfi \"[0:v]settb=AVTB,setpts=PTS-" + std::to_string(delaycomp_pts) + "/TB[main];[1:v]settb=AVTB,setpts=PTS-" + std::to_string(delayref_pts) +"/TB[ref];[main][ref] ssim=stats_file='[SSIM]" + name + "'\" -f null -";
//std::cout << strcmd << std::endl;
exec(strcmd);
std::cout << std::to_string(i)+"/" + std::to_string(delay.size()-1) << " completed." <<std::endl;
}
auto end = std::chrono::system_clock::now();
std::chrono::duration<double> elapsed = end - start;
std::cout << "Elapsed time: " << elapsed.count() << std::endl;
for (int i=0; i < (int) delay.size();i++){
if(i==0) cv::VideoCapture cap = cv::VideoCapture(ref);
else cv::VideoCapture cap = cv::VideoCapture(comps[i-1]);
cv::Mat img;
for(int j=0; j < delay[i]; j++){
cap >> img;
}
if(i==0){
std::string comp = ref;
std::string name = comp.substr(comp.find_last_of("/\\") + 1);
size_t p = name.find_last_of('.');
name = name.substr(0, p);
name = name + ".jpg";
cv::imwrite(name, img );
} else{
std::string comp = comps[i-1];
std::string name = comp.substr(comp.find_last_of("/\\") + 1);
size_t p = name.find_last_of('.');
name = name.substr(0, p);
name = name + ".jpg";
cv::imwrite(name, img );
}
}
}
if (argc == 4) {
std::cout << "No json sended" << std::endl;
std::string ref = argv[1]; //
unsigned int window = std::stoi(argv[3]);
std::cout <<"Search window: " << window << std::endl;
//const char comp[] = argv[2];
std::vector<std::string> comps = {argv[2]};
std::vector< std::vector<float> > corr;
corr.reserve(2);
for (unsigned int i = 0; i < 2; i++) {
corr.push_back(std::vector<float>(window));
}
std::cout << "Start delay synchronize" << std::endl;
//Get mean luma of each frame for future cross-correlation
uint8_t fps;
cv::VideoCapture cap;
for (unsigned int i = 0; i < 2; i++) {
if (i == 0) {
cap = cv::VideoCapture(ref);
fps = cap.get(cv::CAP_PROP_FPS); //Get framerate. Needed later.
} else {
cap = cv::VideoCapture(comps[i-1]);
}
for (unsigned int j = 0; cap.isOpened() && j < window; j++) {
cv::Mat img;
cap >> img;
cv::Mat cropimg;
//img(cv::Rect(cv::Point(0, 0), cv::Point(100, 100))).copyTo(cropimg);
//cv::imshow("test", img);
//cv::waitKey(0);
cv::Scalar m = cv::sum(img);
//std::cout <<"nยฐ"<<j<<": " << m[0] << std::endl;
corr[i][j] = m[0] + m[1] + m[2]; // A faire: Vรฉrifier qu'on utilise le vert.
//corr[i][j] = m[0]; // A faire: Vรฉrifier qu'on utilise le vert.
}
}
//Luma mean for reference
double corref[window];
for (unsigned int j = 0; j < window; j++) {
corref[j] = corr[0][j];
}
std::cout <<"Results:" << std::endl;
std::vector<int> delay;
delay.reserve(2+1);
delay.push_back(0); //Set delay for ref at [0]
//Cross-correlation for each comps
for (unsigned int i = 0; i < 2; i++) {
double comps[window]; //Luma mean for comps
double coefcorr[window]; //Coefficients of cross-corr
for (unsigned int j = 0; j < window; j++) {
comps[j] = corr[i + 1][j];
coefcorr[j] = 0; //Initialize array
}
correlation(corref, comps, window, coefcorr); //See cross-correlation function
long index;
double maxcorr = -2; // correlaration between -1 and 1
for (unsigned int j = 0; j < window; j++) {
if (coefcorr[j] > maxcorr) {
maxcorr = coefcorr[j];
index = j;
//std::cout << "Max: " << coefcorr[j] << std::endl;
}
//std::cout << "Index: "<< j <<" , Value: " << coefcorr[j] << std::endl;
}
//std::cout << "-----------------------------" << std::endl;
std::cout << "Delay: " << index - window / 2 << ", MaxCoef: " << maxcorr << std::endl;
delay.push_back(index - (window / 2));
}
std::cout << "Start compute PSNR&SSIM by ffmpeg" << std::endl;
for (unsigned long i = 1; i < delay.size(); i++) {
std::string comp = comps[i-1];
std::string name = comp.substr(comp.find_last_of("/\\") + 1);
size_t p = name.find_last_of('.');
name = name.substr(0, p);
name = name + ".log";
float delaycomp_pts = 0;
float delayref_pts = 0;
if ((float) delay[i] / fps >=0) {
delaycomp_pts = (float) delay[i] / fps;
delayref_pts = 0;
} else {
delaycomp_pts = 0;
delayref_pts = std::abs((float) delay[i] / fps);
}
//std::cout <<"Framerate: " << fps << std::endl;
//std::cout <<"Delay compspts: " << delaycomp_pts << ", delay refpst: " << delayref_pts << std::endl;
//std::string strcmd = "ffmpeg -y -nostats -loglevel 0 -i " + comp + " -i " + ref + " -lavfi \"[0:v]settb=AVTB,setpts=PTS-" + std::to_string(delaycomp_pts) +"/TB[main];[1:v]settb=AVTB,setpts=PTS-" + std::to_string(delayref_pts) +"/TB[ref];[main][ref] psnr=stats_file='[PSNR]" + name + "'\" -f null -";
std::string strcmd = "ffmpeg -i " + comp + " -i " + ref + " -lavfi \"[0:v]settb=AVTB,setpts=PTS-" + std::to_string(delaycomp_pts) +"/TB[main];[1:v]settb=AVTB,setpts=PTS-" + std::to_string(delayref_pts) +"/TB[ref];[main][ref] psnr=stats_file='[PSNR]" + name + "'\" -f null -";
//std::cout << strcmd << std::endl;
exec(strcmd);
strcmd = "ffmpeg -y -nostats -loglevel 0 -i " + comp + " -i " + ref + " -lavfi \"[0:v]settb=AVTB,setpts=PTS-" + std::to_string(delaycomp_pts) + "/TB[main];[1:v]settb=AVTB,setpts=PTS-" + std::to_string(delayref_pts) +"/TB[ref];[main][ref] ssim=stats_file='[SSIM]" + name + "'\" -f null -";
//std::cout << strcmd << std::endl;
exec(strcmd);
std::cout << std::to_string(i)+"/" + std::to_string(delay.size()-1) << " completed." <<std::endl;
}
auto end = std::chrono::system_clock::now();
std::chrono::duration<double> elapsed = end - start;
std::cout << "Elapsed time: " << elapsed.count() << std::endl;
for (int i=0; i < (int) delay.size();i++){
if(i==0) cv::VideoCapture cap = cv::VideoCapture(ref);
else cv::VideoCapture cap = cv::VideoCapture(comps[i-1]);
cv::Mat img;
for(int j=0; j < delay[i]; j++){
cap >> img;
}
if(i==0){
std::string comp = ref;
std::string name = comp.substr(comp.find_last_of("/\\") + 1);
size_t p = name.find_last_of('.');
name = name.substr(0, p);
name = name + ".jpg";
cv::imwrite(name, img );
} else{
std::string comp = comps[i-1];
std::string name = comp.substr(comp.find_last_of("/\\") + 1);
size_t p = name.find_last_of('.');
name = name.substr(0, p);
name = name + ".jpg";
cv::imwrite(name, img );
}
}
}
else {
std::cout << "Missing ref's path and comps's path as arguments" << std::endl;
}
return 0;
}
|
0516a09a6f1e28e5721bcda9c9ed0771c6a4f90c
|
cef10c8a57377d7a57d1f8ec7a2562ba0251eb2b
|
/Raytracer/src/core/Film.h
|
db671ca4dc778e44d0187bd88322686d9d73ab10
|
[] |
no_license
|
kell18/Sparkler
|
e9e303954e998ee677b1af09393746537961718c
|
8623f98173ffd992e8abb86fcb0caae82bc12043
|
refs/heads/master
| 2020-12-02T22:39:57.388707
| 2017-03-17T19:12:02
| 2017-03-17T19:12:02
| 26,179,119
| 1
| 1
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 750
|
h
|
Film.h
|
#pragma once
#include <FreeImage.h>
#include <stdio.h>
#include <vector>
#include <iostream>
#include <iomanip>
#include "../utils/Mathf.h"
#include "../utils/Color.h"
using namespace glm;
using namespace std;
namespace raytracer
{
class Film {
private:
int width, height;
string outputFile;
FIBITMAP* raw_imageBitmap;
int logInterval;
string progressMsg = "";
public:
int logFrequency = 20;
void commitFragment(int x, int y, Color color);
void pushFragments();
void logProgress(int param);
Film(int width, int height, string outputFile,
short bitsPerPixel = 24);
~Film();
Film(const Film&) = delete;
Film& operator = (const Film&) = delete;
};
}
|
d23a88badcdf35f266ab76c16d631aebff3155cf
|
acc7983ce9431f45df5cf37c222290c5b4687e5b
|
/Source/Survival/Interaction/DestructibleComponent.cpp
|
6859af0ad74cce1c3099dec09bc3e67c10563641
|
[] |
no_license
|
emqk/Survival
|
51f2c5876cff01601543d9207964c8419050c12f
|
f65432026ff66e7e236206a1b1cf644b2b0c52a6
|
refs/heads/master
| 2023-03-09T19:28:53.806091
| 2021-03-01T14:36:18
| 2021-03-01T14:36:18
| 284,226,651
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 2,604
|
cpp
|
DestructibleComponent.cpp
|
// Fill out your copyright notice in the Description page of Project Settings.
#include "DestructibleComponent.h"
#include "Kismet/GameplayStatics.h"
#include "../PlayerGameInstance.h"
#include "Kismet/KismetMathLibrary.h"
#include "ItemActor.h"
#include "GameFramework/Actor.h"
#include "../PlayerGameMode.h"
// Sets default values for this component's properties
UDestructibleComponent::UDestructibleComponent()
{
// Set this component to be initialized when the game starts, and to be ticked every frame. You can turn these features
// off to improve performance if you don't need them.
PrimaryComponentTick.bCanEverTick = true;
}
// Called when the game starts
void UDestructibleComponent::BeginPlay()
{
Super::BeginPlay();
startHP = hp;
if (!onDestroyFX)
{
onDestroyFX = Cast<APlayerGameMode>(GetWorld()->GetAuthGameMode())->GetDefaultDestroyFX();
}
}
// Called every frame
void UDestructibleComponent::TickComponent(float DeltaTime, ELevelTick TickType, FActorComponentTickFunction* ThisTickFunction)
{
Super::TickComponent(DeltaTime, TickType, ThisTickFunction);
}
bool UDestructibleComponent::InteractionTick_Implementation(const float& deltaSeconds, const AAICharacter* character)
{
//UE_LOG(LogTemp, Warning, TEXT("Destructible component interaction"));
hp -= character->GetDestructionSpeedForMaterialType(materialType) * deltaSeconds;
bool finished = hp <= 0;
if (finished)
{
OnDestructed.Broadcast();
GetOwner()->Destroy();
}
return finished;
}
void UDestructibleComponent::EndPlay(const EEndPlayReason::Type EndPlayReason)
{
Super::EndPlay(EndPlayReason);
if (EndPlayReason == EEndPlayReason::Destroyed)
{
//Spawn items
UPlayerGameInstance* gameInstance = Cast<UPlayerGameInstance>(UGameplayStatics::GetGameInstance(this));
gameInstance->itemManager->SpawnItemsFromActorInstance(afterDestroyActors, GetOwner()->GetActorLocation());
//Play destroy sound and spawn particles
UGameplayStatics::PlaySoundAtLocation(GetWorld(), onDestroySound, GetOwner()->GetActorLocation());
UNiagaraFunctionLibrary::SpawnSystemAtLocation(GetWorld(), onDestroyFX, GetOwner()->GetActorLocation());
//Remove corresponding UI widget
APlayerGameMode* gameMode = GetWorld()->GetAuthGameMode<APlayerGameMode>();
gameMode->GetUIManager()->RemoveDestructionProgressWidget(this);
}
}
float UDestructibleComponent::GetHPPercentageNormalized() const
{
return hp / startHP;
}
void UDestructibleComponent::InitWidget()
{
APlayerGameMode* gameMode = GetWorld()->GetAuthGameMode<APlayerGameMode>();
gameMode->GetUIManager()->SetDestructionProgressWidget(this);
}
|
b214b77408664b88f4fb65232b99d139ec883ff3
|
e1bfeb5fc79b5b624eea4996cef7e5bccb4877ed
|
/Learning DSA/Learning DSA/Sort.h
|
e9f8b3fbec028159d1a3ead47eda1790f05000ce
|
[] |
no_license
|
phaninder/DSA
|
6fe71a6a9da5eeb8860746ecae9e4c1bd2e9079a
|
c1f8b3d07b86d075ec8ccdd024c9626fb8018eca
|
refs/heads/master
| 2021-01-19T17:36:19.664458
| 2017-11-16T05:48:37
| 2017-11-16T05:48:37
| 101,071,275
| 0
| 0
| null | 2017-09-12T16:15:24
| 2017-08-22T14:22:50
|
C++
|
UTF-8
|
C++
| false
| false
| 525
|
h
|
Sort.h
|
#pragma once
class Sort
{
private:
int *A,*leftArray,*rightArray, size;
void MergeProcedure(int A[],int n);
void Merge(int left[], int right[], int A[],int leftASize,int rightASize,int mainAsize);
void QuickSorting(int A[], int lb, int ub);
int Partition(int A[], int lb, int ub);
public:
Sort();
void CreateArray();
void BubbleSort();
void InsertionSort();
void SelectionSort();
void MergeSort();
void MergeSort(int *Ar, int size);
void QuickSort();
void QuickSort(int *A,int lastIndex);
void Display();
};
|
f49219aa5777b89fb6eae3e6e2ad990536dcb639
|
11ca89b76e83e7198418ec1ff73d6f40e36e292b
|
/src/singleton.h
|
1b1a65beb24e346c2e6316068433e8aae3447b2a
|
[] |
no_license
|
turbobit/ddosmon
|
cd254d3de23334e9e54030567e47408405e69981
|
d1912a05eb264f0756235686ddc54667176ecd48
|
refs/heads/master
| 2020-04-03T15:29:43.429064
| 2018-10-30T10:57:26
| 2018-10-30T10:57:26
| 155,364,523
| 0
| 0
| null | 2018-10-30T10:14:26
| 2018-10-30T10:14:26
| null |
UTF-8
|
C++
| false
| false
| 562
|
h
|
singleton.h
|
#ifndef __SINGLETON_H__
#define __SINGLETON_H__
template <class T>
class Singleton
{
private:
Singleton(const Singleton<T> &);
Singleton& operator=(const Singleton<T> &);
static T* m_instance;
protected:
Singleton() {
m_instance = static_cast<T*>(this);
}
public:
virtual ~Singleton() {
m_instance = 0;
}
static T* instance() {
if(!m_instance) {
m_instance = static_cast<T*>(new T);
}
return m_instance;
}
};
template<class T>
T* Singleton<T>::m_instance = 0;
#endif
|
6634f799ee0793e30f68f83047039765e9d48f12
|
dd46500227bf97a1e3d383f8c8ebb323d33e94a0
|
/arduino/all_nano_33_ble_sense/all_model.cpp
|
19622491b1598b3dde5f9f2168d6472e2932fafe
|
[
"MIT"
] |
permissive
|
AdamMiltonBarker/ALL-Arduino-Nano-33-BLE-Sense-Classifier
|
dde49e8c934a5cda32e4aeaf646df9c740b1130a
|
744f538e265533a9ed81429fac367c852555b674
|
refs/heads/main
| 2023-06-19T02:31:10.412983
| 2021-07-19T21:01:22
| 2021-07-19T21:01:22
| 386,728,228
| 0
| 0
|
MIT
| 2021-07-16T18:21:31
| 2021-07-16T18:21:30
| null |
UTF-8
|
C++
| false
| false
| 322,924
|
cpp
|
all_model.cpp
|
/* ALL Arduino Nano 33 BLE Sense Classifier
An experiment to explore how low powered microcontrollers, specifically the
Arduino Nano 33 BLE Sense, can be used to detect Acute Lymphoblastic Leukemia.
MIT License
Copyright (c) 2021 Asociaciรณn de Investigacion en Inteligencia Artificial
Para la Leucemia Peter Moss
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files(the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and / or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
Contributors:
- Adam Milton-Barker
==============================================================================*/
#include "all_model.h"
alignas(8) const unsigned char all_model[] = {
0x20, 0x00, 0x00, 0x00, 0x54, 0x46, 0x4c, 0x33, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x12, 0x00, 0x1c, 0x00, 0x04, 0x00, 0x08, 0x00, 0x0c, 0x00,
0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x18, 0x00, 0x12, 0x00, 0x00, 0x00,
0x03, 0x00, 0x00, 0x00, 0xe8, 0xca, 0x00, 0x00, 0xc8, 0xb8, 0x00, 0x00,
0xb0, 0xb8, 0x00, 0x00, 0x3c, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
0x01, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x08, 0x00, 0x0c, 0x00,
0x04, 0x00, 0x08, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00,
0x0f, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x6d, 0x69, 0x6e, 0x5f,
0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x5f, 0x76, 0x65, 0x72, 0x73,
0x69, 0x6f, 0x6e, 0x00, 0x10, 0x00, 0x00, 0x00, 0x68, 0xb8, 0x00, 0x00,
0x54, 0xb8, 0x00, 0x00, 0xc8, 0xb7, 0x00, 0x00, 0xa4, 0xb7, 0x00, 0x00,
0x10, 0xb7, 0x00, 0x00, 0xec, 0xb6, 0x00, 0x00, 0x18, 0x73, 0x00, 0x00,
0x34, 0x6a, 0x00, 0x00, 0xa0, 0x00, 0x00, 0x00, 0x94, 0x00, 0x00, 0x00,
0x80, 0x00, 0x00, 0x00, 0x6c, 0x00, 0x00, 0x00, 0x58, 0x00, 0x00, 0x00,
0x44, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
0x4e, 0x47, 0xff, 0xff, 0x04, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00,
0x31, 0x2e, 0x35, 0x2e, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0xe0, 0x3a, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf0, 0x3a, 0xff, 0xff,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x3b, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x10, 0x3b, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x3b, 0xff, 0xff,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x30, 0x3b, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xce, 0x47, 0xff, 0xff,
0x04, 0x00, 0x00, 0x00, 0x78, 0x69, 0x00, 0x00, 0x9d, 0x29, 0xd2, 0x63,
0xef, 0xbb, 0xae, 0xea, 0x44, 0xd3, 0x2a, 0x04, 0xfc, 0x32, 0x13, 0xf8,
0xc8, 0x3d, 0x5a, 0xdd, 0xe1, 0xf0, 0x61, 0x8c, 0xed, 0x69, 0x63, 0x0e,
0x1d, 0x0c, 0xa9, 0x2a, 0xbf, 0x06, 0xa0, 0xbd, 0xdb, 0xa5, 0x45, 0x00,
0x16, 0x2b, 0x9d, 0xfe, 0xaf, 0xc0, 0x1b, 0x95, 0x22, 0xff, 0xca, 0x1a,
0x69, 0xd5, 0x32, 0x3c, 0x39, 0xfb, 0x08, 0xb9, 0xca, 0x27, 0xf8, 0xf7,
0x00, 0xcc, 0x46, 0x01, 0x54, 0xfe, 0xfa, 0x36, 0x0e, 0x2b, 0x5e, 0xe9,
0x05, 0x6c, 0x50, 0xf9, 0x25, 0xe5, 0x35, 0xf4, 0xde, 0x53, 0xcd, 0xcf,
0x2e, 0xbc, 0xdb, 0xbf, 0xc9, 0xf4, 0x6a, 0xad, 0x68, 0x3f, 0x5e, 0xbc,
0x13, 0x0a, 0x3c, 0xcb, 0xb4, 0x11, 0xf3, 0x9a, 0x1f, 0xdb, 0x0c, 0xf5,
0x4c, 0xee, 0x1f, 0x55, 0xfd, 0x0c, 0x28, 0xb4, 0xd3, 0x36, 0x2d, 0x2f,
0x08, 0xa0, 0xc2, 0x44, 0x4c, 0xd4, 0xfd, 0x39, 0xe9, 0xd6, 0x38, 0xb3,
0x71, 0xe3, 0x2a, 0x0c, 0xc7, 0x13, 0x3c, 0x25, 0xe6, 0x70, 0xc0, 0xf9,
0x2d, 0x11, 0xf9, 0x51, 0xa9, 0xe6, 0xed, 0xd7, 0xc5, 0x3d, 0x67, 0xf8,
0x0f, 0x42, 0x5b, 0x14, 0xf6, 0xc7, 0x23, 0x8e, 0x3a, 0xc9, 0xe4, 0xe3,
0x2b, 0xf5, 0xd9, 0x5d, 0x38, 0x10, 0x31, 0xb8, 0x0f, 0xbf, 0xdd, 0x97,
0xfb, 0xc0, 0x3b, 0x36, 0x29, 0xf7, 0xef, 0x1b, 0x1b, 0x43, 0x59, 0xc7,
0x40, 0x42, 0x3b, 0x24, 0xef, 0xef, 0x2e, 0x08, 0x1d, 0x37, 0xbe, 0xf3,
0x1a, 0xfe, 0xf3, 0xd9, 0x2c, 0x48, 0x00, 0xa2, 0x39, 0x4d, 0x31, 0xd5,
0x01, 0x26, 0xa0, 0x01, 0x4f, 0x0b, 0xc0, 0x97, 0x23, 0x2e, 0x37, 0x0f,
0x49, 0xad, 0xe0, 0x44, 0xcd, 0x10, 0x1a, 0xe0, 0x55, 0x40, 0x5a, 0x92,
0x14, 0x9c, 0x40, 0x17, 0x24, 0xe4, 0xf9, 0xf2, 0x46, 0x03, 0x1b, 0xd0,
0xfc, 0x2b, 0x3e, 0x24, 0x28, 0xcf, 0x33, 0x4d, 0xf0, 0x64, 0x56, 0x21,
0x1c, 0xf7, 0xd7, 0xdd, 0xa1, 0x29, 0x8e, 0xdf, 0x20, 0x01, 0x4e, 0xda,
0xe6, 0xe2, 0xf9, 0xe2, 0xfc, 0xef, 0xdc, 0x5a, 0x57, 0x0c, 0x12, 0xd4,
0x3b, 0x6e, 0xc7, 0x3c, 0x2c, 0xe6, 0x06, 0x20, 0x60, 0x29, 0x03, 0x71,
0x61, 0xc9, 0x29, 0xdc, 0x4b, 0x1e, 0x03, 0x2d, 0xd9, 0xe7, 0xd7, 0xd3,
0xd9, 0xb4, 0x2c, 0xd4, 0xfe, 0xf7, 0x59, 0x22, 0xe2, 0x5a, 0xa9, 0xf4,
0x4d, 0xc5, 0x95, 0xf2, 0x64, 0x52, 0xfd, 0xac, 0xeb, 0x43, 0x42, 0x1f,
0x10, 0xef, 0xb6, 0xf5, 0xe6, 0xd8, 0x3a, 0x96, 0x4d, 0x0f, 0x39, 0xe7,
0x5d, 0x01, 0xd2, 0x4f, 0x5f, 0x03, 0x58, 0xf6, 0x03, 0x4d, 0x43, 0xf4,
0x9d, 0xd0, 0xde, 0xe1, 0x27, 0xd9, 0x2e, 0x2f, 0xce, 0x12, 0xb0, 0x09,
0x2a, 0x4e, 0x59, 0x5c, 0xfa, 0x08, 0x37, 0xe4, 0xdf, 0x7f, 0x58, 0xf1,
0x2a, 0x30, 0x8d, 0x66, 0xed, 0x61, 0xc5, 0xb3, 0x1f, 0xc9, 0x25, 0x14,
0xf4, 0xfd, 0xb1, 0xe4, 0xec, 0x32, 0x22, 0x1f, 0x54, 0x27, 0x2e, 0x15,
0x5e, 0x91, 0xca, 0x33, 0x43, 0xf2, 0x2e, 0xf4, 0x00, 0x55, 0xe2, 0x10,
0x4c, 0xec, 0xd3, 0xc1, 0x44, 0xe1, 0x18, 0x1f, 0xc1, 0xef, 0xdc, 0xc0,
0x2d, 0xbe, 0x4c, 0x01, 0x28, 0x22, 0x68, 0xe2, 0x09, 0x2c, 0xc9, 0x01,
0xec, 0x17, 0x12, 0x22, 0x33, 0x39, 0x15, 0xbc, 0x53, 0xb2, 0x2e, 0x21,
0xfe, 0x2b, 0x42, 0x48, 0xa3, 0xc0, 0xc3, 0xd6, 0x25, 0x00, 0xe8, 0x09,
0x69, 0x34, 0xfc, 0x64, 0x02, 0xff, 0xfd, 0x09, 0xf9, 0xe0, 0x28, 0xb0,
0x42, 0xbe, 0x2d, 0x47, 0xee, 0x20, 0xf8, 0x17, 0x5b, 0x12, 0x04, 0x00,
0xe4, 0xd1, 0x1e, 0x3d, 0x4c, 0xea, 0x50, 0xf8, 0x0f, 0x31, 0x2b, 0x00,
0x40, 0xf8, 0x94, 0x3a, 0x16, 0x4e, 0xe9, 0xeb, 0x67, 0x0a, 0x26, 0xed,
0xd3, 0xcc, 0xdf, 0xfa, 0x45, 0xcb, 0xcc, 0xac, 0x52, 0xd9, 0x27, 0xf9,
0x2e, 0x03, 0xe9, 0x49, 0xfd, 0xf4, 0x42, 0xde, 0x66, 0xb8, 0x5c, 0x74,
0xd1, 0xc8, 0xb1, 0x09, 0x12, 0x22, 0xef, 0x1c, 0x04, 0x15, 0x67, 0xf9,
0x45, 0x3b, 0x49, 0x38, 0xe0, 0x33, 0x41, 0x88, 0xf2, 0x45, 0x8c, 0xf6,
0x44, 0x27, 0xe5, 0xc4, 0x33, 0x8d, 0x22, 0xc2, 0x3e, 0x05, 0x47, 0x2f,
0xd9, 0x2a, 0x3a, 0xee, 0x1a, 0x34, 0xed, 0x3e, 0x1e, 0xf7, 0xe6, 0xf5,
0x47, 0xdf, 0xf1, 0x53, 0xe4, 0xf4, 0x03, 0xe4, 0x23, 0x4d, 0xfe, 0x4a,
0x51, 0xd2, 0xe9, 0xb3, 0x5a, 0x09, 0xe3, 0xdc, 0xf4, 0x03, 0x1b, 0xbc,
0xd4, 0x46, 0x23, 0x3a, 0x20, 0x0f, 0x7b, 0xc1, 0xf1, 0x1b, 0x4f, 0xe5,
0x09, 0x06, 0x03, 0xe8, 0x62, 0x25, 0xc7, 0xf5, 0xe4, 0xa9, 0x52, 0x17,
0xb7, 0xe2, 0x46, 0x05, 0x1c, 0xe7, 0x2c, 0x2e, 0x6e, 0x29, 0x36, 0x2c,
0x77, 0x93, 0x25, 0x4c, 0xe7, 0x22, 0x28, 0xd0, 0x16, 0xb4, 0x48, 0x1e,
0xd2, 0xad, 0xce, 0x3c, 0x34, 0x15, 0xbf, 0xca, 0x12, 0xeb, 0xe2, 0xe9,
0x71, 0xca, 0x30, 0xf1, 0xe6, 0x07, 0x61, 0xc7, 0x41, 0x3c, 0xc7, 0xf8,
0x07, 0xf2, 0xbb, 0x22, 0xe8, 0x74, 0xa1, 0xe8, 0x39, 0x25, 0x40, 0xf9,
0xdf, 0x08, 0x3f, 0x27, 0x22, 0xf2, 0x2f, 0x55, 0x36, 0x0f, 0xc8, 0xf2,
0x5b, 0x98, 0xe3, 0x31, 0xe7, 0x11, 0x32, 0xab, 0xb8, 0xd1, 0xef, 0xc4,
0x88, 0xcb, 0xf3, 0xa8, 0x4f, 0xe3, 0xf1, 0x14, 0x30, 0xde, 0x28, 0x0f,
0x0b, 0x18, 0x60, 0xf2, 0x21, 0xd2, 0x7f, 0xb6, 0xc3, 0x34, 0x9a, 0xdb,
0x28, 0x0a, 0xb3, 0x39, 0x40, 0x99, 0xcf, 0xc6, 0x3a, 0xf4, 0x35, 0x1a,
0xc6, 0x04, 0x13, 0xcc, 0x41, 0xd4, 0x62, 0x83, 0x33, 0x3d, 0xf9, 0x08,
0x75, 0xce, 0xc2, 0x5b, 0xd9, 0x01, 0x0b, 0x04, 0x31, 0x02, 0x33, 0x33,
0x3c, 0xb5, 0x6a, 0xee, 0x28, 0xdc, 0xc6, 0x1b, 0xf7, 0xec, 0xe4, 0xf2,
0xc3, 0x2d, 0x3d, 0xc5, 0x25, 0x0a, 0x52, 0x52, 0xc0, 0x2a, 0x36, 0x00,
0x0c, 0xc6, 0x57, 0x4a, 0x64, 0x66, 0x11, 0xcb, 0x18, 0xfc, 0x21, 0xf5,
0xd9, 0xee, 0x1e, 0x19, 0x55, 0xf9, 0x08, 0xb3, 0x34, 0xb8, 0xe5, 0x0a,
0x4c, 0xda, 0x08, 0x51, 0x20, 0xf0, 0x2a, 0xbd, 0x1f, 0x62, 0x0f, 0x39,
0x65, 0xa3, 0x6b, 0xf6, 0x30, 0xe2, 0xbd, 0x95, 0x1b, 0xcb, 0x07, 0xb2,
0xf0, 0x4c, 0x38, 0xc6, 0xc2, 0xf0, 0x44, 0x8c, 0x0d, 0x48, 0x03, 0xdb,
0x0e, 0xdd, 0x6f, 0x58, 0xea, 0x9f, 0x66, 0xc1, 0xb4, 0xf3, 0x39, 0xfd,
0xc6, 0xf2, 0x13, 0xdc, 0x3d, 0xd7, 0xd8, 0xdb, 0x5a, 0xca, 0x2c, 0x16,
0x31, 0x38, 0xe6, 0x2b, 0x29, 0xd7, 0x49, 0xef, 0x4f, 0xed, 0xdb, 0xbd,
0x1c, 0xcb, 0x3b, 0xe2, 0x3b, 0xe3, 0x20, 0x01, 0x47, 0x1b, 0x6a, 0xdc,
0xcd, 0x49, 0x40, 0x38, 0x2c, 0x21, 0x53, 0xc3, 0xe8, 0x66, 0xc9, 0xea,
0x1f, 0xba, 0xd8, 0xdc, 0x41, 0x07, 0xfd, 0x81, 0xf4, 0xfc, 0x18, 0xef,
0x0d, 0xce, 0x07, 0x11, 0x93, 0x1f, 0x1f, 0x3b, 0x36, 0xd4, 0xf6, 0xe3,
0x5f, 0xee, 0x0f, 0x38, 0xb3, 0xd3, 0x3c, 0xf0, 0x2e, 0xbf, 0x15, 0x3b,
0x60, 0xb5, 0x11, 0x0a, 0x41, 0xf4, 0x26, 0x20, 0x36, 0x15, 0xdb, 0x0b,
0xb6, 0x07, 0x0e, 0x12, 0x0c, 0xdb, 0x2e, 0xdc, 0x19, 0x64, 0x23, 0xf1,
0x2b, 0x12, 0xaa, 0x36, 0xac, 0x37, 0x84, 0x8e, 0xd6, 0x49, 0x30, 0x03,
0x1c, 0x49, 0x07, 0xfd, 0x16, 0xbf, 0x63, 0x42, 0x1a, 0x05, 0xee, 0x0f,
0x76, 0x98, 0x22, 0x32, 0x26, 0xf6, 0x17, 0xe1, 0xc3, 0xd3, 0xe4, 0x59,
0x3c, 0xc3, 0x1b, 0xb7, 0x19, 0x16, 0xd6, 0x35, 0xbf, 0xc7, 0x6a, 0xae,
0x02, 0x02, 0x37, 0x05, 0x27, 0xf9, 0x62, 0x1b, 0xd6, 0x3d, 0x2c, 0x09,
0x09, 0x01, 0x72, 0x61, 0x93, 0x75, 0x4d, 0xde, 0xfb, 0xeb, 0x5c, 0x0c,
0xfa, 0x11, 0x1b, 0xca, 0x93, 0x13, 0x2d, 0x5a, 0x3b, 0x58, 0xca, 0xd5,
0x3b, 0x36, 0xe7, 0x41, 0xe0, 0xf4, 0x37, 0xf1, 0x0d, 0xd2, 0x4a, 0x34,
0x4d, 0xb4, 0x0b, 0x53, 0x08, 0x11, 0x03, 0x5c, 0xfb, 0x3c, 0x6a, 0x1f,
0x54, 0xe7, 0x1f, 0x22, 0x35, 0xe2, 0x75, 0xe8, 0xf9, 0x68, 0xc1, 0xfe,
0xf3, 0x26, 0x8f, 0x56, 0xa8, 0x5c, 0x1d, 0xdf, 0xb0, 0x5e, 0x5e, 0xe7,
0xf2, 0x0a, 0xb2, 0xec, 0xfe, 0xf0, 0x63, 0xec, 0x1e, 0x06, 0x0d, 0xc9,
0x40, 0xaa, 0x09, 0x34, 0x56, 0x0a, 0xf3, 0xc8, 0xe4, 0x39, 0xdd, 0xfb,
0x97, 0xde, 0x4c, 0xc9, 0x1d, 0x0f, 0x03, 0x50, 0xd5, 0xc1, 0xe1, 0xc6,
0x64, 0x40, 0x11, 0xaf, 0x22, 0x06, 0x67, 0x4f, 0xe8, 0x4c, 0xf5, 0xf1,
0x0c, 0xda, 0xba, 0xe2, 0xd0, 0xcb, 0x07, 0xe5, 0xc3, 0x44, 0x66, 0x17,
0x15, 0x09, 0x79, 0xe1, 0xcb, 0x18, 0xd1, 0x1c, 0x1c, 0x23, 0xe8, 0xbc,
0x55, 0x0e, 0x90, 0x23, 0x24, 0x1f, 0x49, 0xff, 0x43, 0x57, 0xee, 0x90,
0x25, 0xee, 0x28, 0xcb, 0x3a, 0x08, 0x23, 0x5a, 0x27, 0xeb, 0xa7, 0x34,
0xe3, 0x8d, 0x1b, 0xf2, 0xfc, 0xda, 0x4a, 0xb3, 0xf5, 0x43, 0x55, 0x1b,
0x2f, 0x19, 0x65, 0x42, 0x6c, 0xcc, 0xcf, 0xc9, 0x4f, 0x14, 0x25, 0x2c,
0x09, 0x13, 0xef, 0xfe, 0xed, 0xd4, 0x40, 0x5c, 0x2a, 0x38, 0x1f, 0xee,
0x44, 0x9c, 0xa3, 0x70, 0xb2, 0x27, 0xf8, 0xf4, 0x07, 0xd9, 0xab, 0x82,
0x04, 0xd0, 0x03, 0x2f, 0x51, 0x11, 0x0a, 0x2a, 0x0d, 0xe0, 0x16, 0x01,
0x37, 0x12, 0x1e, 0x2b, 0xd2, 0xe7, 0x77, 0xd1, 0xcd, 0x5f, 0xec, 0xf6,
0x23, 0x06, 0x9b, 0x30, 0x3d, 0xfd, 0xd4, 0xd3, 0xce, 0x2d, 0x2f, 0x2c,
0xea, 0x17, 0x39, 0x17, 0xfd, 0xc7, 0xf4, 0xea, 0x33, 0x47, 0xf5, 0xd2,
0x34, 0xa9, 0xd8, 0x2e, 0xf3, 0x10, 0x2b, 0x1b, 0x84, 0x6b, 0x04, 0x0c,
0x6d, 0xff, 0x5d, 0x2f, 0x1f, 0xff, 0xea, 0xc8, 0xf8, 0xf2, 0xb6, 0x00,
0x69, 0x97, 0x40, 0xc7, 0x24, 0xdc, 0x66, 0xbb, 0xcd, 0x2e, 0x47, 0xf8,
0xf9, 0x0c, 0xf0, 0xcb, 0x2a, 0x7a, 0xe2, 0xc5, 0x1b, 0xdd, 0x42, 0xe6,
0xf1, 0xfd, 0x26, 0x00, 0xf6, 0xc7, 0x0f, 0x89, 0x30, 0xf0, 0xe3, 0x23,
0x4a, 0x97, 0xf4, 0x51, 0x54, 0x0d, 0x2d, 0xd9, 0x3c, 0x21, 0x15, 0x8e,
0x8a, 0xc7, 0x66, 0x17, 0x47, 0x24, 0xe4, 0x4f, 0xda, 0x1a, 0xc9, 0x37,
0x1d, 0x48, 0x30, 0xed, 0xf0, 0x27, 0x7c, 0x2d, 0x28, 0x3c, 0x4b, 0x14,
0x60, 0xbc, 0xef, 0x65, 0xa2, 0x34, 0x63, 0xd5, 0x5c, 0xc7, 0x25, 0x19,
0xdd, 0x21, 0x40, 0xf4, 0xc4, 0x37, 0x0d, 0xf1, 0x54, 0x5d, 0xdc, 0x1d,
0x35, 0xe1, 0xff, 0x3a, 0x09, 0xf5, 0x2e, 0x03, 0xf7, 0x4e, 0x09, 0x65,
0xab, 0xc5, 0x3f, 0x1c, 0x17, 0xfb, 0xd5, 0x22, 0xc2, 0x1c, 0xac, 0xe9,
0x51, 0x29, 0x16, 0xec, 0x2b, 0x18, 0x2a, 0x89, 0x1b, 0x2c, 0x03, 0x0a,
0xfa, 0x17, 0x59, 0x17, 0x17, 0x6f, 0xea, 0xe2, 0x6e, 0xcd, 0x4b, 0x0b,
0xe8, 0xd9, 0x51, 0x2b, 0x1f, 0xf6, 0x24, 0xde, 0x28, 0x43, 0x13, 0x04,
0x34, 0x04, 0xfc, 0x2b, 0x42, 0x29, 0x2a, 0xd3, 0x54, 0x47, 0xcd, 0xce,
0x08, 0x02, 0x5c, 0xfc, 0x6b, 0x01, 0xef, 0xd8, 0xcb, 0xc4, 0xe5, 0xd0,
0x25, 0xfb, 0x35, 0x24, 0x03, 0x37, 0x7f, 0x64, 0xe0, 0x3a, 0x03, 0x0e,
0x17, 0x12, 0xf4, 0xb8, 0x1d, 0x6b, 0x3c, 0xc1, 0xe6, 0xad, 0x58, 0x08,
0xeb, 0x0b, 0xb0, 0xfa, 0x60, 0xcf, 0x6f, 0xd2, 0x2a, 0xd0, 0x37, 0x40,
0x3b, 0x29, 0x16, 0x45, 0x25, 0xf8, 0x44, 0xe7, 0xa9, 0x58, 0x57, 0xb1,
0xd3, 0xd4, 0x32, 0xc2, 0x14, 0xfa, 0xe0, 0xe2, 0x4d, 0xd0, 0xb8, 0xff,
0x68, 0x12, 0x29, 0x3e, 0x27, 0xf3, 0x33, 0xac, 0x4d, 0x37, 0x1d, 0xee,
0x0b, 0xb8, 0x8e, 0x30, 0x1e, 0x50, 0x65, 0xdd, 0xad, 0x0f, 0x37, 0xf6,
0xb4, 0xfc, 0xea, 0x21, 0x22, 0x17, 0x75, 0xa3, 0x16, 0xd0, 0xf4, 0x1b,
0x63, 0xe3, 0x3f, 0x41, 0x12, 0x00, 0x44, 0x19, 0xa1, 0xc6, 0x27, 0xb1,
0x57, 0xd9, 0x35, 0x3a, 0x5a, 0x11, 0xdf, 0xb4, 0xce, 0x22, 0x20, 0x1a,
0x5a, 0xdc, 0x22, 0x2b, 0xe0, 0xed, 0x73, 0x08, 0x12, 0x48, 0xe1, 0xfd,
0x39, 0x1e, 0x0e, 0x1d, 0xef, 0x1e, 0x10, 0xcf, 0xce, 0xb8, 0x22, 0xe2,
0xd5, 0xea, 0x0c, 0xf4, 0x51, 0xbc, 0xe5, 0x3e, 0x52, 0x17, 0xca, 0x11,
0x2f, 0xcc, 0xbd, 0x19, 0x9b, 0x01, 0x40, 0xc8, 0xf2, 0x54, 0xba, 0xc8,
0xe3, 0xe0, 0x37, 0x0c, 0x61, 0xe2, 0xcb, 0xed, 0x06, 0xd8, 0x90, 0xc5,
0x2c, 0x51, 0x29, 0x02, 0xe8, 0x07, 0x54, 0x74, 0xbe, 0x5e, 0xa9, 0xe0,
0x27, 0xf2, 0xe4, 0xf6, 0x15, 0x37, 0x95, 0xc3, 0x13, 0x36, 0x14, 0xf8,
0xdd, 0x14, 0x4b, 0xfc, 0x4a, 0xdb, 0xe3, 0xcc, 0x3c, 0x1e, 0x13, 0xef,
0x34, 0x5c, 0x06, 0x4f, 0xbf, 0x0e, 0x43, 0xfb, 0xf7, 0xb1, 0xd0, 0xfb,
0x06, 0xc1, 0x4d, 0x28, 0x49, 0x06, 0xfc, 0xf9, 0x52, 0xf5, 0x01, 0xb1,
0x64, 0x6a, 0x42, 0xf0, 0xee, 0x24, 0x4d, 0x22, 0xe8, 0x22, 0x3f, 0xf7,
0x3c, 0xb7, 0xed, 0xfa, 0x44, 0xd6, 0xfc, 0xa3, 0xc1, 0xe2, 0x41, 0x22,
0xa3, 0xc2, 0x44, 0xfd, 0x22, 0x0c, 0xfd, 0xf8, 0x45, 0x2d, 0x17, 0x20,
0x58, 0xda, 0xdb, 0x21, 0x5a, 0x04, 0x26, 0xa6, 0xe5, 0x28, 0xf9, 0xb8,
0x9f, 0xd5, 0x69, 0xbb, 0x44, 0xdf, 0x1d, 0xe3, 0xf8, 0x21, 0x2e, 0xcc,
0x5a, 0xc5, 0x58, 0x3a, 0x37, 0x1d, 0x25, 0x40, 0x32, 0x57, 0xe6, 0xfc,
0x1f, 0xff, 0x31, 0xb1, 0x3b, 0x26, 0xe0, 0xb5, 0xfa, 0x40, 0x1d, 0xe6,
0x37, 0xde, 0xca, 0x11, 0x4b, 0x0e, 0x44, 0x11, 0x4f, 0x13, 0x01, 0x03,
0x73, 0x3e, 0x1d, 0x54, 0xb3, 0xe4, 0x1f, 0xc2, 0xa2, 0x30, 0x4e, 0xbb,
0x2a, 0xab, 0x37, 0x14, 0x34, 0x1d, 0xf1, 0x2f, 0x4c, 0x26, 0x23, 0xdb,
0x0c, 0x48, 0x37, 0xec, 0xf9, 0xe1, 0x23, 0x25, 0x23, 0x3b, 0xc1, 0x00,
0x24, 0xc5, 0x9d, 0x21, 0xee, 0x5d, 0x07, 0xc2, 0x22, 0x53, 0x5c, 0xce,
0x0e, 0x43, 0x1f, 0x01, 0xae, 0x0d, 0x47, 0x48, 0x61, 0x2d, 0xe0, 0x09,
0x22, 0x3a, 0xfa, 0x54, 0xf2, 0xe5, 0x03, 0xc3, 0xb1, 0x1e, 0x12, 0xa9,
0x20, 0xa0, 0x6d, 0xef, 0x1f, 0xfd, 0x1c, 0x45, 0xaa, 0x11, 0x09, 0x27,
0x0e, 0xf1, 0x43, 0x46, 0xd3, 0x0a, 0x6a, 0xee, 0x23, 0x57, 0x01, 0x0a,
0x38, 0xde, 0xeb, 0x59, 0xa6, 0x07, 0x36, 0xda, 0x4c, 0x22, 0x58, 0x04,
0xfc, 0x4e, 0x05, 0xce, 0xf9, 0xd1, 0xc9, 0x2c, 0x36, 0x17, 0x1c, 0xe7,
0x3a, 0xce, 0xd6, 0x35, 0xfd, 0xfd, 0x29, 0xed, 0xc7, 0xb5, 0xd5, 0x61,
0x93, 0xc7, 0x5a, 0x5f, 0x5a, 0x0e, 0xf7, 0x2f, 0x4e, 0x19, 0xd3, 0xdc,
0x2d, 0xbf, 0x1a, 0x0e, 0xef, 0xc0, 0x30, 0x77, 0x10, 0x31, 0x42, 0x0c,
0xfa, 0x21, 0xa7, 0x60, 0x48, 0x16, 0x18, 0xaa, 0x6b, 0x38, 0x09, 0x08,
0x13, 0xf1, 0x43, 0x3d, 0x2e, 0x26, 0xf3, 0x87, 0x18, 0xdc, 0x11, 0xc9,
0x30, 0x28, 0xce, 0x4f, 0x61, 0xf8, 0x1e, 0xf5, 0x5e, 0x1d, 0x0e, 0x73,
0x6a, 0xeb, 0xc4, 0x4d, 0x56, 0x1b, 0xf9, 0xee, 0x19, 0xee, 0x53, 0xd3,
0xe7, 0x9c, 0x19, 0xe9, 0xd4, 0xb0, 0x58, 0xff, 0xbe, 0x63, 0xee, 0xed,
0x2c, 0xea, 0x1b, 0x59, 0xeb, 0x11, 0x98, 0xaf, 0x2b, 0x2a, 0x4f, 0xf8,
0x10, 0x33, 0x42, 0xea, 0x01, 0x21, 0xc4, 0x40, 0x4d, 0xfe, 0x3f, 0xdd,
0x40, 0xee, 0xed, 0x28, 0xcb, 0x00, 0x3c, 0xd8, 0xcb, 0xdb, 0x39, 0xb7,
0xac, 0xd9, 0x52, 0xc8, 0x1f, 0x2f, 0x1a, 0x56, 0xa5, 0x01, 0x6d, 0xe2,
0xd7, 0x47, 0x21, 0xe1, 0xde, 0xcc, 0x60, 0x3e, 0xbb, 0x5a, 0x1d, 0x22,
0x4b, 0x04, 0xe4, 0x1a, 0x2d, 0x24, 0xd4, 0xf6, 0x57, 0x09, 0x34, 0x1a,
0xff, 0xde, 0xc3, 0xe5, 0x2b, 0xf8, 0xfb, 0x4a, 0x23, 0x27, 0xfd, 0xff,
0x4e, 0x75, 0xe8, 0x36, 0x17, 0x2b, 0x0d, 0x17, 0xd6, 0x18, 0x5c, 0x12,
0x53, 0xc8, 0x34, 0xc7, 0x02, 0xf1, 0xe4, 0x31, 0xc7, 0xd1, 0x61, 0xfe,
0x07, 0xf2, 0x37, 0xcc, 0x11, 0xda, 0x3b, 0x39, 0x0b, 0x54, 0xed, 0xf3,
0x1f, 0xcf, 0x30, 0x0d, 0x0c, 0xa7, 0x54, 0xc0, 0xd8, 0xf4, 0x46, 0x04,
0x05, 0x01, 0xe1, 0xce, 0x6f, 0xf1, 0x2a, 0x60, 0x23, 0x25, 0x43, 0x1a,
0x56, 0xf4, 0xde, 0x5d, 0x2e, 0x0b, 0x20, 0xfb, 0x05, 0x0f, 0x55, 0x25,
0x5f, 0xf5, 0x34, 0x12, 0x47, 0x1d, 0xed, 0x0c, 0x88, 0x1c, 0xb7, 0xea,
0x16, 0xcf, 0x49, 0xd7, 0x0f, 0xf8, 0x66, 0xe1, 0x27, 0x32, 0x45, 0x11,
0x10, 0x14, 0xf6, 0xdb, 0xd0, 0xec, 0x0c, 0xcd, 0xf8, 0xc8, 0x47, 0x2a,
0xda, 0x11, 0x54, 0x3b, 0x3b, 0xc1, 0x66, 0xb1, 0x42, 0x47, 0xec, 0x20,
0x57, 0xea, 0x2d, 0x5a, 0xf8, 0x1b, 0x20, 0xed, 0x99, 0x24, 0xed, 0x1e,
0xfd, 0xf0, 0xdc, 0x41, 0x26, 0x3e, 0xfe, 0x02, 0x13, 0xf1, 0xc4, 0x00,
0xca, 0x5b, 0x3e, 0x02, 0x50, 0xfb, 0x67, 0x59, 0x17, 0x58, 0x00, 0x07,
0x12, 0x25, 0x37, 0x51, 0x6c, 0x31, 0x3d, 0xd4, 0xef, 0xc1, 0x30, 0xf4,
0xf4, 0x37, 0x4d, 0x18, 0x30, 0x36, 0x06, 0xee, 0x26, 0x41, 0x42, 0x32,
0x33, 0xa6, 0x36, 0x3e, 0x26, 0x2d, 0x0c, 0x1d, 0x08, 0x1a, 0x68, 0x8f,
0x89, 0xd7, 0x45, 0xd5, 0x0d, 0x41, 0xe6, 0x5a, 0xd8, 0x2c, 0x51, 0x1c,
0x04, 0x01, 0x29, 0x42, 0x16, 0x17, 0x67, 0x1d, 0x48, 0x58, 0x2b, 0x16,
0x25, 0x0b, 0xe7, 0xf4, 0xd9, 0x96, 0xef, 0x05, 0x2f, 0xe5, 0x0b, 0x24,
0xdd, 0x22, 0x12, 0x3a, 0xd8, 0x33, 0xe4, 0x11, 0x15, 0x07, 0x1b, 0x43,
0x26, 0xff, 0x31, 0x58, 0xcb, 0x0c, 0x51, 0xfd, 0xba, 0x52, 0xea, 0x1d,
0xaf, 0xc8, 0x22, 0xef, 0x1e, 0x41, 0xf1, 0x23, 0x96, 0xbb, 0x03, 0xe3,
0x24, 0xbc, 0x48, 0xf6, 0xe5, 0x24, 0x52, 0x8d, 0x26, 0x21, 0x9b, 0x2d,
0x42, 0xca, 0xf1, 0x2f, 0x2b, 0xaf, 0x44, 0xd0, 0x05, 0xe2, 0x67, 0x0d,
0xc5, 0xde, 0x43, 0xfc, 0x09, 0x26, 0x4e, 0xd8, 0x0b, 0x00, 0x0c, 0x2a,
0x24, 0x20, 0x32, 0x51, 0xcb, 0x28, 0x51, 0x29, 0xa5, 0xf3, 0xa0, 0x77,
0x0a, 0xe4, 0xb2, 0xc7, 0x57, 0x2f, 0xe8, 0xc1, 0x38, 0xeb, 0x94, 0x36,
0x3a, 0x2e, 0x5a, 0x3c, 0x1d, 0x13, 0x53, 0x31, 0x5d, 0x3d, 0x5a, 0x22,
0x15, 0xf7, 0xed, 0xfd, 0xce, 0xa0, 0xb6, 0xdd, 0xdc, 0xff, 0x6c, 0x08,
0xf4, 0x00, 0x56, 0xdb, 0x03, 0xf8, 0x45, 0xdc, 0x3c, 0x2a, 0x25, 0xfd,
0x63, 0x1d, 0x06, 0x38, 0x0b, 0x07, 0xfd, 0xcd, 0xcb, 0xda, 0xa0, 0x93,
0x19, 0xec, 0x10, 0xb6, 0x18, 0x3a, 0xc7, 0x04, 0x4e, 0xf3, 0xd1, 0xee,
0x23, 0xd4, 0x32, 0xeb, 0x2c, 0x0e, 0x4c, 0x9a, 0xf3, 0x21, 0xd2, 0x20,
0x30, 0x12, 0x28, 0x1d, 0xea, 0xcd, 0x66, 0xc6, 0x48, 0x10, 0x63, 0xe9,
0xba, 0xea, 0xdb, 0x27, 0x32, 0xeb, 0x24, 0x65, 0x51, 0x58, 0xfc, 0x09,
0x6b, 0x63, 0xfd, 0x64, 0x15, 0x16, 0x37, 0xe1, 0x93, 0xb8, 0x1b, 0xbd,
0xe3, 0xdd, 0x5e, 0xec, 0x4f, 0x16, 0xdc, 0x0c, 0x67, 0xe4, 0x82, 0xcd,
0x3c, 0x86, 0x5d, 0xd9, 0xd7, 0xda, 0x50, 0xf0, 0x0b, 0x2c, 0x01, 0x17,
0xf8, 0xf5, 0x94, 0x28, 0x09, 0x10, 0x41, 0xc5, 0xde, 0xa2, 0x38, 0xe4,
0xc3, 0xe6, 0x44, 0xd5, 0x87, 0xdf, 0x6a, 0xd4, 0x39, 0x04, 0x28, 0xe7,
0x63, 0xcd, 0xc8, 0x52, 0xd4, 0xf0, 0x31, 0x14, 0x3c, 0xa9, 0x07, 0x8d,
0xd0, 0xa7, 0x3f, 0xa0, 0x6c, 0x0b, 0xad, 0xf1, 0xb4, 0xd8, 0x9a, 0xa5,
0x0e, 0xea, 0x57, 0xb5, 0xdb, 0x0d, 0x67, 0xba, 0x17, 0x3b, 0x5d, 0x17,
0x30, 0xc5, 0xce, 0xc3, 0x9b, 0xa2, 0xc7, 0xed, 0x52, 0xea, 0x25, 0x0a,
0xe6, 0xf7, 0x05, 0xc1, 0xf1, 0x9b, 0xb1, 0x2c, 0x47, 0x15, 0x09, 0xe8,
0x5b, 0x1c, 0xf3, 0x4d, 0x37, 0x07, 0x1f, 0xe9, 0x9d, 0xbd, 0xf3, 0x2f,
0x29, 0xc6, 0x50, 0x2d, 0x3a, 0xe8, 0x0a, 0x0e, 0xd3, 0x28, 0xba, 0xe1,
0x57, 0x96, 0x10, 0x33, 0xe2, 0x29, 0x3a, 0x36, 0x07, 0x71, 0xd6, 0x14,
0x26, 0x0f, 0xbd, 0x3f, 0xfd, 0xf0, 0x1e, 0xb4, 0x32, 0x3b, 0x17, 0xd5,
0x22, 0xef, 0xb7, 0xff, 0xa4, 0xc1, 0x0c, 0xa1, 0x40, 0xd9, 0x15, 0x1e,
0x6a, 0x20, 0x53, 0x48, 0x01, 0xe0, 0xfd, 0xfc, 0x51, 0x56, 0x4c, 0x38,
0x3c, 0xc7, 0x37, 0x44, 0x1d, 0x1f, 0xef, 0xf6, 0xf5, 0x13, 0x4a, 0xd3,
0x1c, 0x0d, 0x06, 0x18, 0x3c, 0xf6, 0x1e, 0xac, 0xf6, 0x61, 0x4e, 0x16,
0x11, 0xc9, 0x62, 0x3d, 0xe9, 0x03, 0xd7, 0xea, 0x2e, 0x00, 0x57, 0x05,
0xf8, 0xf1, 0x17, 0x01, 0x65, 0xc6, 0x38, 0x64, 0x01, 0x0a, 0xc8, 0x05,
0x68, 0x9e, 0x16, 0x64, 0xd0, 0xf1, 0xf9, 0xf6, 0x56, 0x60, 0x55, 0x7e,
0xe6, 0xd9, 0xdf, 0xe6, 0x39, 0x1a, 0x0a, 0x3d, 0x96, 0x09, 0x3e, 0xea,
0x52, 0xd4, 0x0e, 0x44, 0x1a, 0xfb, 0x59, 0x86, 0xf9, 0x37, 0x62, 0x06,
0x31, 0xbf, 0xdd, 0x5f, 0xca, 0xd6, 0xb8, 0xeb, 0x07, 0xe5, 0x30, 0x0d,
0xe4, 0x26, 0x1c, 0xe2, 0x61, 0x0d, 0x5f, 0x51, 0x24, 0x53, 0xf1, 0xe8,
0x60, 0xbd, 0x1d, 0x58, 0xd6, 0xfa, 0xd9, 0x06, 0xeb, 0xb7, 0x36, 0x73,
0x9d, 0xb9, 0x04, 0xd9, 0x2f, 0x1e, 0x15, 0x30, 0xbd, 0xf6, 0xd8, 0x5d,
0xf2, 0x82, 0x39, 0x56, 0xdf, 0xaa, 0x43, 0x01, 0xdf, 0x46, 0x10, 0xf0,
0x0a, 0xc7, 0x32, 0xbd, 0xd7, 0xa0, 0x17, 0xd2, 0xe0, 0x51, 0x13, 0x2a,
0xf7, 0x0c, 0xcf, 0x26, 0x21, 0xe3, 0xda, 0x98, 0x3d, 0x17, 0xda, 0xba,
0x20, 0xa4, 0xdf, 0x50, 0x69, 0x16, 0x59, 0x05, 0xa5, 0x22, 0xa9, 0x0f,
0x12, 0xd1, 0x5a, 0x15, 0x37, 0xfe, 0xf7, 0x3c, 0x22, 0x33, 0x26, 0xe8,
0x59, 0x33, 0x36, 0x23, 0x0d, 0xc5, 0x69, 0x98, 0xca, 0x31, 0xa1, 0xfb,
0x52, 0x40, 0xa0, 0x44, 0xea, 0x87, 0x31, 0xeb, 0xed, 0xd0, 0x0c, 0x42,
0xea, 0x0b, 0x31, 0x27, 0x69, 0x2c, 0x5a, 0xbd, 0x33, 0x0f, 0xee, 0xba,
0x71, 0x69, 0xa4, 0x5f, 0xba, 0xf5, 0x48, 0x21, 0x17, 0x0c, 0x4f, 0xa9,
0xe6, 0xbe, 0x65, 0x5d, 0x20, 0xf6, 0x10, 0xe4, 0x5a, 0x27, 0xe4, 0x10,
0x7a, 0x57, 0x3c, 0x41, 0xe2, 0xd7, 0x49, 0x3f, 0xbd, 0x33, 0xd1, 0x17,
0x25, 0x29, 0x3b, 0x13, 0x63, 0xba, 0x09, 0xd5, 0xb1, 0x5b, 0x56, 0x2f,
0xda, 0x25, 0x3d, 0xd5, 0xbe, 0x33, 0xf7, 0x5d, 0x20, 0x43, 0x02, 0xb8,
0x65, 0xf5, 0xc2, 0x62, 0x2d, 0x22, 0x29, 0xdd, 0xaf, 0x14, 0x28, 0xfa,
0x3a, 0xeb, 0x07, 0xf8, 0x40, 0x3d, 0xf7, 0x0d, 0xe4, 0xf3, 0x9b, 0xfc,
0xd5, 0xf8, 0x20, 0x4d, 0x08, 0xcc, 0x64, 0x8b, 0x1b, 0x62, 0x02, 0x06,
0x29, 0x47, 0x91, 0x25, 0xdd, 0xc7, 0xc8, 0xd5, 0x6f, 0xe6, 0x51, 0x25,
0xe6, 0x24, 0x67, 0xf9, 0x6e, 0x2e, 0x65, 0xea, 0x24, 0x02, 0x14, 0x1e,
0x1e, 0xc1, 0x10, 0x14, 0xab, 0x3f, 0x0b, 0xd7, 0xbd, 0x09, 0x16, 0x85,
0x55, 0xd3, 0xe5, 0x22, 0x37, 0x48, 0xe5, 0x01, 0x50, 0x17, 0x02, 0xe8,
0xc7, 0x1c, 0xfa, 0x4e, 0x0e, 0xea, 0x5b, 0xde, 0x2f, 0x25, 0xc9, 0x24,
0x10, 0x2c, 0x0f, 0x64, 0x5d, 0xe7, 0x6b, 0xc9, 0x1f, 0x4f, 0x13, 0x47,
0x1a, 0x32, 0xf6, 0x27, 0x72, 0xff, 0xbb, 0x23, 0x05, 0x5a, 0x4a, 0x19,
0x5d, 0x1d, 0x20, 0x4c, 0x3c, 0x06, 0x10, 0x33, 0xef, 0x66, 0x61, 0xc6,
0x85, 0x05, 0xf2, 0xdb, 0x58, 0x40, 0xc9, 0xfb, 0xcc, 0xf5, 0xfe, 0x1c,
0x3e, 0x1b, 0xf6, 0xdc, 0x12, 0x13, 0x56, 0x6d, 0x50, 0x3c, 0x59, 0x41,
0x35, 0x12, 0x4a, 0xf1, 0xb0, 0x88, 0xaf, 0xd9, 0xde, 0x17, 0x2e, 0x4f,
0xef, 0xe0, 0x9a, 0x14, 0xeb, 0x45, 0xd7, 0xff, 0x36, 0x1f, 0x35, 0x2c,
0x3c, 0x55, 0x0c, 0x39, 0xac, 0x20, 0x0c, 0x25, 0xe3, 0xe4, 0x30, 0x12,
0xa7, 0xdf, 0x05, 0x55, 0x3c, 0x34, 0x04, 0x05, 0xc2, 0x31, 0xa5, 0x4f,
0x69, 0xfd, 0x14, 0x14, 0x1c, 0x2d, 0x4d, 0xd1, 0x0d, 0x20, 0x32, 0x39,
0x2f, 0xfc, 0xab, 0x38, 0xe5, 0x8a, 0xc3, 0xc1, 0xee, 0xde, 0x55, 0x01,
0xea, 0x19, 0x0c, 0x11, 0x47, 0x18, 0x1d, 0x12, 0x45, 0xc4, 0x06, 0xfc,
0x44, 0x9c, 0x14, 0x57, 0xab, 0x13, 0xe9, 0x0c, 0x44, 0x00, 0x98, 0x48,
0x17, 0x0a, 0x0a, 0xe0, 0x50, 0x1d, 0xec, 0x1d, 0xf3, 0x06, 0x1a, 0x13,
0x14, 0x95, 0x51, 0x40, 0x46, 0x2c, 0x61, 0x04, 0xee, 0x44, 0xbe, 0x08,
0x21, 0xd8, 0xf0, 0x5b, 0xec, 0xec, 0xd4, 0xf7, 0x5b, 0x29, 0x38, 0x27,
0xfa, 0x11, 0x48, 0xed, 0xd5, 0xed, 0xf8, 0x45, 0x31, 0xee, 0xde, 0x03,
0x37, 0x0f, 0x4e, 0x2c, 0xde, 0x02, 0x20, 0xd2, 0xa4, 0xce, 0x65, 0xf6,
0xc1, 0xcb, 0x0e, 0x12, 0x01, 0x14, 0xe3, 0xd0, 0x6e, 0xed, 0x22, 0x05,
0xc9, 0x14, 0x47, 0xfd, 0x41, 0x2a, 0x25, 0x5c, 0x46, 0x30, 0x19, 0x14,
0x17, 0xfb, 0x3e, 0xf8, 0x3f, 0x01, 0x4e, 0xdb, 0x2d, 0x30, 0x55, 0x4b,
0xd2, 0xe3, 0x2e, 0xde, 0xf9, 0xc5, 0x6e, 0xa9, 0x44, 0x33, 0x50, 0x05,
0x2b, 0x67, 0x4e, 0x4d, 0x3e, 0x0a, 0x45, 0x29, 0x00, 0xb0, 0xde, 0x05,
0x1e, 0xce, 0xcf, 0x2e, 0x19, 0x23, 0xc9, 0xe1, 0x9f, 0xf4, 0x5d, 0x25,
0x01, 0xe5, 0x48, 0xd4, 0x2c, 0xe5, 0x68, 0x9c, 0x37, 0x56, 0x4e, 0x04,
0x17, 0xcb, 0xdb, 0xe9, 0x5d, 0x68, 0x27, 0xb6, 0x52, 0xfb, 0x33, 0xec,
0xd9, 0xbd, 0xde, 0xe7, 0x07, 0xe2, 0x08, 0xea, 0x25, 0x1a, 0x1d, 0xed,
0x78, 0x6c, 0xf7, 0x54, 0xf5, 0xf7, 0x35, 0xda, 0x95, 0x6d, 0x27, 0x2f,
0xf5, 0xcd, 0xb5, 0xb7, 0x5a, 0x0c, 0xe5, 0x32, 0x14, 0xea, 0xcf, 0x12,
0x0b, 0x47, 0x41, 0xf6, 0x10, 0xfd, 0x7a, 0xdd, 0x0b, 0x2b, 0xb6, 0x07,
0x4f, 0xfc, 0xe2, 0x0d, 0xfa, 0xe2, 0x2b, 0xc3, 0xb1, 0xec, 0x3d, 0x01,
0xcb, 0xdb, 0xa0, 0xda, 0xd7, 0x1e, 0xe5, 0x4a, 0x11, 0xea, 0xdc, 0xf8,
0x55, 0xe5, 0x19, 0x48, 0x15, 0xf3, 0x68, 0xe7, 0xf8, 0x45, 0xcd, 0x14,
0x5f, 0xeb, 0x53, 0x18, 0x3d, 0xe5, 0xc7, 0xe9, 0x13, 0xd4, 0x96, 0x13,
0x3d, 0xcd, 0x67, 0xee, 0x33, 0x01, 0x73, 0x23, 0x35, 0x2b, 0xe4, 0x18,
0x28, 0xaa, 0xe9, 0xaf, 0x46, 0x98, 0x83, 0xc2, 0x18, 0x2d, 0x72, 0x21,
0xc9, 0xb2, 0x11, 0xdd, 0x6a, 0xf6, 0xad, 0xda, 0x1c, 0xf4, 0x2b, 0xf7,
0x68, 0xa9, 0x29, 0x64, 0x09, 0xeb, 0x0a, 0xb8, 0x3b, 0x24, 0x6a, 0x43,
0x85, 0xd3, 0x17, 0x04, 0x24, 0xdd, 0x2f, 0xf3, 0x55, 0x4b, 0x46, 0xcf,
0xe5, 0x53, 0x2f, 0xd4, 0xfc, 0x2a, 0x47, 0x0c, 0xea, 0x44, 0x08, 0xf5,
0xfe, 0xdb, 0xf8, 0x29, 0x1d, 0x8d, 0x62, 0xe7, 0xc0, 0xcc, 0x77, 0xda,
0x0f, 0x13, 0xf8, 0x21, 0x67, 0xd7, 0xec, 0x53, 0x36, 0x3e, 0x3e, 0x21,
0x45, 0x0a, 0x13, 0x5f, 0xbb, 0xf6, 0x31, 0xe7, 0x89, 0x06, 0xe3, 0x21,
0x0d, 0xb5, 0x30, 0x25, 0x34, 0xe0, 0x15, 0xec, 0x4c, 0x20, 0x8c, 0x11,
0xbd, 0xb1, 0x0b, 0xe6, 0x3d, 0x15, 0x30, 0x57, 0xf4, 0x24, 0xe1, 0xfd,
0x24, 0x05, 0xb1, 0x47, 0xb9, 0x89, 0x02, 0xc9, 0x12, 0x10, 0x03, 0x12,
0xe3, 0x44, 0xca, 0x4a, 0x84, 0x19, 0x5c, 0x1b, 0xff, 0xd9, 0xfc, 0x02,
0x40, 0xe3, 0xd8, 0x39, 0x3b, 0xfb, 0x0b, 0xfd, 0xbe, 0x3b, 0x92, 0x42,
0xcb, 0xc8, 0x4c, 0xda, 0x33, 0x20, 0x06, 0x4a, 0x20, 0x5a, 0x22, 0x08,
0x2c, 0x08, 0x0d, 0x3e, 0x14, 0xde, 0x26, 0x12, 0xd0, 0x14, 0x5c, 0xf1,
0xf8, 0xd8, 0xbf, 0xed, 0xc9, 0x15, 0x1a, 0xde, 0xde, 0xef, 0x13, 0x2e,
0xf3, 0x58, 0xe6, 0x2c, 0xf4, 0xd9, 0x6f, 0x4f, 0xfa, 0x22, 0x27, 0x06,
0x14, 0xab, 0xdf, 0x2f, 0xb5, 0x27, 0xec, 0x2f, 0xeb, 0x54, 0xd5, 0x9f,
0xda, 0xbf, 0xd5, 0xdc, 0x37, 0x21, 0xf4, 0x61, 0x99, 0x1c, 0x4a, 0x39,
0x51, 0xfd, 0x1c, 0x1c, 0x1e, 0xd1, 0x37, 0xb8, 0xea, 0x48, 0x2e, 0x07,
0x09, 0x18, 0x6d, 0x30, 0xe3, 0x9e, 0x34, 0xd9, 0xf9, 0xf0, 0x5e, 0x0b,
0x03, 0x15, 0xf3, 0x00, 0x38, 0x3d, 0x5f, 0x53, 0xf9, 0x4c, 0x4d, 0xb8,
0x48, 0xa8, 0xa1, 0x2f, 0x37, 0x0f, 0x05, 0x19, 0x94, 0xfc, 0xb9, 0xfd,
0xa1, 0xc4, 0x2a, 0x08, 0x36, 0x19, 0x05, 0x62, 0x1c, 0x56, 0x1f, 0x4a,
0x08, 0x9b, 0x50, 0xf0, 0x1f, 0xcd, 0x59, 0xb4, 0xcf, 0x52, 0xf6, 0x22,
0x1b, 0x0d, 0x10, 0x06, 0xa7, 0x46, 0xec, 0xce, 0x18, 0x59, 0x42, 0x0f,
0x08, 0x51, 0x02, 0x2d, 0x0e, 0x10, 0x5a, 0xb0, 0x31, 0x48, 0xed, 0xe1,
0x4b, 0xed, 0xd2, 0x19, 0x3b, 0x0d, 0x02, 0xd7, 0x34, 0xd7, 0xca, 0x1c,
0xab, 0xc6, 0x70, 0xe1, 0x27, 0x15, 0xed, 0x00, 0x5c, 0x07, 0xc0, 0x0d,
0x05, 0x41, 0x1a, 0xe6, 0x1c, 0xef, 0x24, 0x02, 0xfd, 0x23, 0x54, 0x07,
0x1c, 0x19, 0xc8, 0xdf, 0xd6, 0x19, 0x95, 0xf5, 0xf6, 0x30, 0x2b, 0x61,
0xd1, 0x1d, 0xf4, 0x23, 0x6f, 0xe4, 0x2f, 0xd0, 0x43, 0x5d, 0x1b, 0xf7,
0x3d, 0x94, 0xe3, 0x49, 0x11, 0x2f, 0x0e, 0xfc, 0xe7, 0xe8, 0xe6, 0xb3,
0xf6, 0xe8, 0x57, 0x59, 0x15, 0x27, 0xe6, 0x49, 0x45, 0x1a, 0x86, 0x1d,
0x3f, 0xde, 0x13, 0xff, 0x0d, 0xfa, 0x3f, 0xe5, 0xf9, 0x4f, 0x01, 0x2d,
0x27, 0xeb, 0x4c, 0x10, 0x0e, 0x32, 0x6b, 0xd4, 0x49, 0x08, 0x34, 0x33,
0xf1, 0x28, 0xcb, 0x1d, 0xfe, 0x31, 0x6c, 0xf9, 0xfd, 0x03, 0xfd, 0xe4,
0x49, 0x51, 0xf3, 0x55, 0xe4, 0x16, 0x14, 0xf3, 0xc1, 0x57, 0xd1, 0x79,
0x4e, 0x03, 0x34, 0xfc, 0x08, 0x0f, 0xf3, 0xf9, 0xa4, 0x33, 0xe8, 0xfb,
0x1c, 0x31, 0x0c, 0x0f, 0x11, 0x2c, 0x55, 0x73, 0x1b, 0x4b, 0x4a, 0x0a,
0x26, 0xf7, 0xe1, 0xf5, 0x25, 0x4b, 0x66, 0xd7, 0x26, 0x1f, 0x4f, 0x37,
0xdf, 0x25, 0xe4, 0x34, 0x0e, 0x0d, 0xde, 0xfc, 0x31, 0x6b, 0xea, 0xf9,
0x50, 0x3c, 0x21, 0x1b, 0x5c, 0x3f, 0x49, 0x1d, 0xb5, 0x62, 0x33, 0x2c,
0x50, 0xd7, 0x48, 0xf8, 0x18, 0x29, 0x0e, 0xfb, 0x1a, 0x04, 0x30, 0x10,
0x59, 0xbf, 0x39, 0x26, 0x28, 0x06, 0x4f, 0x1b, 0x37, 0x1b, 0x39, 0x21,
0x09, 0xe4, 0xc0, 0x06, 0xe4, 0x65, 0x43, 0x03, 0xe9, 0x37, 0x42, 0x45,
0xd5, 0xe9, 0xa7, 0xfa, 0x72, 0x51, 0x4c, 0x58, 0x02, 0x01, 0x47, 0x54,
0x43, 0x5b, 0x46, 0x40, 0xe7, 0x42, 0x0e, 0xd6, 0xe9, 0x4e, 0x70, 0xac,
0xd0, 0x0d, 0xb9, 0xc5, 0x2f, 0x3e, 0xfb, 0x16, 0xca, 0x24, 0xf3, 0x53,
0x59, 0xb7, 0x17, 0xfd, 0x03, 0x1e, 0x59, 0x18, 0x66, 0x14, 0xca, 0x0f,
0x0f, 0x19, 0x46, 0x00, 0x1a, 0xb7, 0x59, 0xdb, 0x34, 0x34, 0x47, 0x16,
0xda, 0xfc, 0x14, 0xfa, 0x31, 0x3e, 0x3e, 0x8c, 0x02, 0xde, 0x43, 0x08,
0x37, 0xe7, 0x4a, 0x43, 0xb1, 0x2e, 0x34, 0xde, 0xcf, 0xd1, 0xe9, 0xaf,
0x3e, 0xde, 0xea, 0xd2, 0x0a, 0x40, 0x0e, 0x13, 0xc2, 0xf7, 0x93, 0xfc,
0xc5, 0x90, 0x1e, 0xf4, 0xea, 0x4b, 0x2c, 0x71, 0x4b, 0x10, 0x29, 0x3d,
0x20, 0xea, 0xd8, 0xdf, 0xc0, 0x29, 0x99, 0xf6, 0x34, 0xd2, 0x4b, 0x11,
0xb0, 0xf8, 0x2d, 0xeb, 0xe6, 0xd6, 0xc1, 0xe6, 0x02, 0xd8, 0x3b, 0x2d,
0x3c, 0x36, 0x3c, 0x35, 0xa0, 0x13, 0x49, 0x21, 0x26, 0x6e, 0xbc, 0xc1,
0x1f, 0xd8, 0x6f, 0xda, 0x0b, 0x0b, 0xf5, 0x05, 0xde, 0xb4, 0xb2, 0xcc,
0xc6, 0x31, 0x05, 0x53, 0x0f, 0x29, 0x24, 0x2a, 0x31, 0x43, 0xc5, 0x30,
0xfb, 0x2c, 0x1b, 0xd9, 0x50, 0xa2, 0x39, 0xca, 0xfa, 0xd8, 0x4f, 0x40,
0xd4, 0x18, 0x3a, 0xae, 0x29, 0xc8, 0xfd, 0xb5, 0x0c, 0x41, 0x04, 0x37,
0x4c, 0xcc, 0x53, 0x1c, 0xda, 0x1f, 0x1d, 0x02, 0x62, 0x5e, 0xff, 0x24,
0xe2, 0x05, 0xb0, 0xb2, 0xf7, 0x43, 0xe4, 0xb6, 0x03, 0xd3, 0x53, 0x1b,
0x25, 0xf6, 0x1b, 0xcb, 0x1e, 0x12, 0x25, 0x0f, 0x63, 0x32, 0xe4, 0x2d,
0x34, 0xfc, 0x29, 0x4d, 0x48, 0xbf, 0xfe, 0xd8, 0xed, 0x2e, 0x5b, 0x48,
0xc0, 0xa6, 0xd7, 0xdb, 0x6f, 0xc8, 0xd2, 0x0e, 0x57, 0x3d, 0x24, 0x11,
0x51, 0xc8, 0x17, 0x2b, 0xff, 0x14, 0x52, 0xd7, 0xdb, 0x29, 0xc6, 0xf8,
0xd9, 0xc8, 0x64, 0x06, 0x18, 0x2d, 0xac, 0xb7, 0xdc, 0xa5, 0xae, 0xe4,
0x38, 0x82, 0x0f, 0x05, 0x33, 0x05, 0x4f, 0xa6, 0xf4, 0x1c, 0xbf, 0x2b,
0x38, 0x09, 0xbf, 0x26, 0xe6, 0x9a, 0x93, 0xe4, 0xe5, 0xa4, 0x47, 0x0d,
0xda, 0x01, 0xcb, 0xbb, 0xc3, 0xdd, 0x0d, 0x06, 0x27, 0x0e, 0xee, 0x2a,
0x22, 0x94, 0x13, 0x2c, 0x4c, 0x16, 0x3d, 0xc3, 0x8d, 0xc1, 0xc5, 0x9c,
0x9c, 0xf8, 0x1e, 0x3b, 0x57, 0x27, 0xb7, 0x1f, 0xcb, 0xc9, 0x2b, 0xe5,
0x55, 0x2e, 0x1e, 0x1b, 0xf9, 0x08, 0x2f, 0x89, 0x1b, 0x29, 0x32, 0xf7,
0xfb, 0x06, 0xb3, 0x47, 0xe1, 0x04, 0x95, 0xcb, 0xbc, 0xec, 0x43, 0x1d,
0xd1, 0xa9, 0x41, 0xf5, 0x57, 0xa4, 0x03, 0x9a, 0x59, 0xf7, 0x26, 0x03,
0x34, 0x3e, 0xfe, 0x5a, 0x12, 0x23, 0xda, 0xb0, 0xa6, 0x5e, 0x1e, 0x8c,
0xa4, 0xae, 0x5b, 0x48, 0x1c, 0xd9, 0x26, 0xfb, 0x21, 0x2d, 0x4f, 0x18,
0xbf, 0xde, 0x16, 0x06, 0x43, 0xef, 0x26, 0x0d, 0x33, 0x31, 0xfc, 0xeb,
0x00, 0x0b, 0x42, 0x2d, 0x29, 0x2a, 0x8e, 0xde, 0x23, 0x31, 0x64, 0xf0,
0xf5, 0x34, 0xc3, 0x30, 0x36, 0x3e, 0x18, 0x9d, 0xfb, 0xf1, 0xfb, 0xfa,
0x39, 0x36, 0xed, 0x6c, 0x01, 0xfa, 0x1a, 0x13, 0xb7, 0x24, 0x6a, 0xdc,
0xe7, 0xdd, 0x4d, 0x58, 0x38, 0x14, 0xf9, 0xc4, 0x16, 0x09, 0x1f, 0xdb,
0xf6, 0x27, 0x4c, 0xcf, 0x02, 0x19, 0x36, 0xcb, 0xe9, 0x3b, 0xd7, 0x27,
0x04, 0xe2, 0x61, 0xda, 0x47, 0x28, 0x17, 0xcf, 0x5a, 0x19, 0x23, 0xfc,
0x05, 0x04, 0x14, 0x08, 0x81, 0x11, 0x57, 0xfc, 0xfd, 0x1c, 0xe8, 0xe1,
0x36, 0x33, 0x23, 0x29, 0x05, 0x16, 0x03, 0xfc, 0x06, 0xf0, 0x5b, 0x50,
0x45, 0xdc, 0x34, 0xf0, 0xf9, 0x2c, 0xe0, 0x00, 0x05, 0x53, 0x50, 0xed,
0x5f, 0x8f, 0x1b, 0x0a, 0x31, 0xc0, 0x42, 0x55, 0x11, 0x45, 0xcd, 0xfe,
0x1f, 0x25, 0xa3, 0xe0, 0xdb, 0xee, 0x8c, 0xc6, 0x17, 0x16, 0x27, 0xfe,
0xee, 0x08, 0x3c, 0x27, 0x1c, 0x44, 0xca, 0x81, 0x20, 0x4c, 0x4f, 0xdb,
0x3e, 0x0c, 0xcf, 0x17, 0xd3, 0xfa, 0x2a, 0x22, 0x2a, 0x18, 0x50, 0xa2,
0x20, 0xb6, 0x2a, 0x2f, 0x18, 0x17, 0xdb, 0x55, 0x27, 0x11, 0x8e, 0x3d,
0x73, 0xf2, 0x0a, 0x5b, 0x10, 0xbc, 0x29, 0x90, 0xf4, 0x21, 0x2e, 0x33,
0xeb, 0x1d, 0xb6, 0xd6, 0xbe, 0xeb, 0xb5, 0xe6, 0x52, 0x1a, 0x52, 0x44,
0xcf, 0x4c, 0xee, 0x1f, 0x95, 0x4b, 0xf5, 0xe6, 0x2c, 0x19, 0x46, 0xed,
0x28, 0xf0, 0xcf, 0x21, 0x1c, 0x35, 0xf1, 0xdf, 0xbd, 0xbe, 0x20, 0xa9,
0x32, 0xf0, 0x13, 0x63, 0x20, 0x29, 0x0b, 0x7a, 0x39, 0x2c, 0x5d, 0x36,
0xc0, 0xd1, 0xfc, 0x3b, 0x35, 0xbb, 0x4a, 0xd5, 0xfc, 0x5e, 0x18, 0x32,
0x28, 0x31, 0xdd, 0xdb, 0xb8, 0xe2, 0xa2, 0x0c, 0xe4, 0x09, 0x3b, 0x18,
0xd3, 0x46, 0x01, 0x40, 0x12, 0x29, 0x0c, 0x14, 0xfe, 0x1a, 0x3c, 0xd0,
0x24, 0x4f, 0xf7, 0x46, 0xc8, 0x0d, 0xf2, 0x16, 0x93, 0x56, 0xb8, 0xfa,
0x3a, 0xdd, 0x1b, 0x20, 0x18, 0x50, 0xdd, 0x2e, 0x0b, 0x1d, 0x0e, 0x33,
0x42, 0x4b, 0x16, 0x09, 0x61, 0xaa, 0x48, 0x60, 0x0c, 0x4d, 0x4c, 0x47,
0xed, 0x08, 0x2d, 0x1e, 0x47, 0x90, 0x92, 0xf1, 0x14, 0x2b, 0x0d, 0x4a,
0xe7, 0x0b, 0x14, 0xc5, 0x4d, 0x28, 0xe9, 0x86, 0x11, 0x64, 0x45, 0xec,
0x2c, 0x2a, 0x15, 0x11, 0x17, 0x17, 0x0c, 0xee, 0x05, 0xbb, 0xc1, 0xa9,
0x0b, 0xca, 0xe6, 0x5e, 0x04, 0x18, 0x10, 0x5e, 0xd5, 0xe8, 0xf2, 0x42,
0x05, 0xaa, 0x34, 0xf4, 0xed, 0xfa, 0x5b, 0xb1, 0xdc, 0x47, 0x19, 0x27,
0x13, 0x2c, 0xfc, 0x49, 0x19, 0x96, 0x3e, 0xcb, 0xca, 0xdd, 0x11, 0x3b,
0xf5, 0x21, 0x08, 0x13, 0xaf, 0x37, 0xea, 0xcd, 0x2f, 0x15, 0x11, 0x0a,
0x61, 0x61, 0x1b, 0x4c, 0x34, 0x3b, 0x01, 0x3c, 0xe3, 0x1f, 0xdd, 0x22,
0x21, 0x20, 0x5f, 0x41, 0x18, 0x4b, 0x14, 0x4c, 0x17, 0xf9, 0x4d, 0x2f,
0xc5, 0xef, 0xf9, 0x0e, 0x2f, 0xe7, 0x5c, 0x44, 0x69, 0x13, 0xb1, 0x52,
0x15, 0x0b, 0xc9, 0x43, 0xa5, 0x97, 0x19, 0x19, 0xd9, 0x60, 0xf7, 0x4c,
0xec, 0x21, 0xee, 0x24, 0x8c, 0x0a, 0xed, 0xc2, 0x26, 0x6b, 0x2f, 0x18,
0x5f, 0x3e, 0x5e, 0x3f, 0xe3, 0x2f, 0x05, 0xf4, 0xda, 0xf9, 0xcb, 0xe2,
0x2d, 0xe1, 0x61, 0x3a, 0x53, 0x57, 0xd3, 0x17, 0x2c, 0x50, 0xf2, 0x3e,
0xeb, 0x9e, 0x00, 0x25, 0xfb, 0x4c, 0x5f, 0x70, 0x37, 0x21, 0x07, 0x1b,
0xe1, 0xf5, 0xc8, 0x54, 0xf8, 0x28, 0xb1, 0x2d, 0x11, 0x65, 0x1d, 0x60,
0xdd, 0xfa, 0x90, 0x31, 0xca, 0x03, 0x20, 0x28, 0x2f, 0xfa, 0x26, 0x45,
0x60, 0x12, 0x7d, 0x2c, 0xc1, 0x1f, 0x24, 0x33, 0xa3, 0xcc, 0xf8, 0xa1,
0x03, 0x13, 0x06, 0x22, 0x4e, 0x21, 0xc3, 0xf7, 0x39, 0xfd, 0x58, 0x48,
0xe7, 0x26, 0xf3, 0xef, 0x54, 0x28, 0x58, 0x6b, 0x49, 0x31, 0x16, 0x28,
0x23, 0xd1, 0x19, 0x66, 0x29, 0x4c, 0x4e, 0xfe, 0xda, 0x5d, 0x33, 0x45,
0x05, 0x5d, 0xc3, 0xcd, 0x8d, 0x61, 0xd7, 0xbd, 0xfa, 0x24, 0xf2, 0x3f,
0x2f, 0x16, 0x45, 0x43, 0xc8, 0x52, 0x51, 0x2e, 0x83, 0x0f, 0x1e, 0x17,
0x35, 0x13, 0x10, 0xd2, 0x1e, 0x1f, 0xd3, 0x02, 0xc4, 0x03, 0x93, 0x52,
0x4e, 0x69, 0x44, 0x08, 0x0b, 0x4c, 0x62, 0x59, 0x2a, 0x54, 0xb4, 0x4c,
0x0e, 0xf9, 0xe6, 0xee, 0x3e, 0xfc, 0x24, 0xee, 0xd9, 0x42, 0xf1, 0x12,
0xee, 0x29, 0x53, 0x23, 0xbf, 0xdb, 0x1e, 0x61, 0x39, 0xf0, 0x49, 0x3e,
0x1b, 0xac, 0x4a, 0x3b, 0xdf, 0x51, 0x1a, 0x31, 0x75, 0x31, 0xf1, 0xfe,
0xbc, 0x18, 0x6d, 0xc9, 0x49, 0x0b, 0xdb, 0xe0, 0xde, 0x18, 0xb7, 0x3e,
0x78, 0xf3, 0x15, 0x1a, 0x51, 0x31, 0x50, 0xdf, 0x00, 0x31, 0x29, 0x39,
0xf6, 0x11, 0x85, 0xf9, 0x48, 0x20, 0x11, 0x15, 0x64, 0xcb, 0x21, 0x37,
0xf2, 0x22, 0xe9, 0xe2, 0x6d, 0x05, 0xd7, 0xb3, 0x08, 0x40, 0x26, 0xed,
0x5c, 0x8b, 0x28, 0x39, 0x3a, 0x19, 0x1d, 0xee, 0x27, 0x2e, 0x51, 0x5f,
0xf0, 0xfc, 0xdb, 0x0b, 0x56, 0x2d, 0xb4, 0xea, 0xc7, 0xe9, 0x67, 0xeb,
0x1c, 0xbf, 0x2f, 0xd0, 0x5d, 0x21, 0x4f, 0xdb, 0x51, 0x43, 0xbe, 0x0d,
0x48, 0x11, 0x32, 0xd0, 0xfa, 0xa2, 0x64, 0xdf, 0x30, 0xd6, 0x19, 0x1a,
0xcb, 0xc3, 0x4a, 0xe0, 0x4d, 0x2d, 0xf6, 0xda, 0x4c, 0xf8, 0x13, 0xfb,
0x16, 0x03, 0x3e, 0x58, 0xff, 0x04, 0x39, 0x35, 0x61, 0xb2, 0xa2, 0x4f,
0x3d, 0xfc, 0x0e, 0xe8, 0x52, 0x4f, 0xb4, 0xae, 0x9d, 0xbb, 0x1e, 0x0c,
0xd9, 0x0f, 0x56, 0xc0, 0xfe, 0x39, 0x26, 0xe7, 0x08, 0x5a, 0x2d, 0x15,
0x10, 0x01, 0x2f, 0x31, 0xab, 0x9c, 0xcd, 0xf6, 0xac, 0xad, 0x12, 0xf0,
0xf7, 0x26, 0x62, 0x9a, 0x6c, 0x28, 0xe2, 0x4e, 0x44, 0x2d, 0x35, 0xf9,
0x77, 0x15, 0xda, 0x2f, 0x00, 0x03, 0x15, 0x29, 0x00, 0x3b, 0xe0, 0x89,
0x00, 0xcb, 0x0e, 0xaa, 0x4d, 0x15, 0xb7, 0x06, 0xf7, 0xd1, 0xee, 0xfb,
0x29, 0xcb, 0x25, 0x04, 0x41, 0x37, 0x6e, 0xdd, 0xef, 0x41, 0xd7, 0x24,
0x05, 0x2a, 0xd0, 0xe5, 0x62, 0x26, 0x65, 0xd7, 0x37, 0x33, 0x37, 0x06,
0xeb, 0xf1, 0x0a, 0xb8, 0x5b, 0xbd, 0x5a, 0x00, 0x40, 0xd4, 0xcd, 0x04,
0x6e, 0x94, 0x18, 0x27, 0x43, 0xff, 0x32, 0xc0, 0x35, 0xb0, 0x5d, 0x83,
0x41, 0xe7, 0xdb, 0x26, 0x1b, 0x1f, 0x14, 0x30, 0xcf, 0x2b, 0xde, 0x1a,
0xd1, 0x89, 0x2e, 0xda, 0x4b, 0x05, 0x3c, 0xa2, 0x3e, 0x3c, 0xdb, 0x20,
0x31, 0x2a, 0xe2, 0xda, 0x9d, 0x5e, 0xd6, 0xd1, 0x18, 0xe2, 0x57, 0xe4,
0xe5, 0x26, 0xa4, 0x16, 0x0f, 0xc7, 0xe8, 0xbf, 0x1a, 0xf2, 0x1b, 0x03,
0x24, 0x5a, 0xf6, 0x35, 0xec, 0xfe, 0xeb, 0x25, 0xe3, 0xd5, 0x15, 0xd4,
0x43, 0xec, 0x31, 0xdb, 0x42, 0xf0, 0xfc, 0x02, 0x17, 0x46, 0x34, 0x20,
0x62, 0xee, 0x0c, 0xd4, 0xe8, 0xd2, 0x22, 0xf8, 0xef, 0x52, 0xcf, 0x29,
0x2f, 0x3b, 0xbe, 0xf2, 0x15, 0x9d, 0x87, 0xab, 0x2e, 0x4c, 0x48, 0xda,
0x04, 0xc6, 0x9f, 0xee, 0x6a, 0xd4, 0x5c, 0x62, 0x03, 0xf2, 0xe2, 0xf8,
0x34, 0x6c, 0xff, 0x3b, 0xc4, 0xfc, 0x1b, 0xdc, 0x30, 0x13, 0x42, 0x41,
0x08, 0xab, 0x0c, 0x08, 0x09, 0x38, 0xd9, 0x37, 0x18, 0x48, 0x1a, 0xdd,
0x26, 0xcc, 0x1a, 0xe9, 0x3b, 0xc1, 0x13, 0x16, 0x17, 0x3b, 0xf1, 0x32,
0x2d, 0x35, 0xeb, 0x08, 0xc0, 0xcb, 0x4b, 0xef, 0x10, 0x4d, 0x1f, 0xf3,
0xe8, 0x01, 0x2f, 0x55, 0x48, 0xf8, 0x6e, 0xde, 0x29, 0x4c, 0xe6, 0xed,
0x5a, 0x9b, 0xda, 0x1f, 0xf9, 0x2a, 0xeb, 0xdf, 0x82, 0x53, 0x24, 0x32,
0xa2, 0xd2, 0x6b, 0xe0, 0x23, 0x26, 0xf0, 0x2f, 0x28, 0x5e, 0x15, 0x39,
0x2a, 0x56, 0x48, 0x5b, 0x22, 0xa6, 0x39, 0x79, 0xdf, 0x50, 0x52, 0x21,
0x00, 0x40, 0x07, 0xb4, 0x23, 0x32, 0xf1, 0xd3, 0xc4, 0x26, 0x3f, 0x2c,
0xe5, 0x35, 0x90, 0x1a, 0xb5, 0x63, 0x3e, 0x62, 0x18, 0x63, 0xf5, 0xd3,
0x30, 0x14, 0xcd, 0x4b, 0x10, 0x15, 0x07, 0x24, 0x61, 0xe9, 0x0a, 0xe0,
0x41, 0xf1, 0x1b, 0x1a, 0x1a, 0x62, 0x15, 0x48, 0x1b, 0x47, 0x17, 0x42,
0x49, 0xfa, 0x01, 0x3b, 0x4c, 0xd7, 0x44, 0xdc, 0xb3, 0x12, 0x52, 0x0c,
0x32, 0x31, 0x4c, 0xcd, 0x56, 0xbd, 0x0a, 0xfe, 0xfb, 0xd7, 0x46, 0x3b,
0xdd, 0x39, 0xa4, 0x5e, 0x88, 0x4d, 0x5a, 0xd3, 0x38, 0xd4, 0xf3, 0xa4,
0x37, 0x0c, 0x01, 0x3e, 0xdc, 0x13, 0x06, 0xee, 0x95, 0x5f, 0xe9, 0xc7,
0x1b, 0xfb, 0x5e, 0x6b, 0x14, 0x34, 0xfe, 0x23, 0xe7, 0x02, 0xda, 0x29,
0x06, 0x2d, 0x33, 0x53, 0x63, 0xcb, 0x3a, 0xd2, 0x10, 0xfc, 0xf5, 0x4d,
0x25, 0xfb, 0xb0, 0xe0, 0x68, 0x0a, 0x5b, 0x0a, 0xf6, 0x2f, 0x04, 0x32,
0xf5, 0x08, 0x95, 0xe6, 0xec, 0x0d, 0xf5, 0x49, 0xe7, 0x0c, 0xf5, 0xbe,
0x5e, 0xc0, 0xe9, 0x15, 0x40, 0x49, 0x4e, 0xfd, 0x8d, 0x23, 0x3c, 0x92,
0x83, 0xe6, 0x2e, 0x17, 0x4e, 0x6c, 0x08, 0x2c, 0xe3, 0xfe, 0xf1, 0x3e,
0x0c, 0xc1, 0x48, 0x1e, 0x2b, 0xad, 0x1e, 0xb8, 0xf8, 0x41, 0xf8, 0x26,
0x29, 0x5c, 0x37, 0x21, 0x67, 0x05, 0xb4, 0x00, 0x59, 0x17, 0x11, 0x5c,
0xe9, 0x22, 0x06, 0x01, 0x9a, 0xff, 0xd1, 0xcb, 0x01, 0xe4, 0x23, 0x04,
0x42, 0x94, 0xe5, 0x44, 0x41, 0x29, 0x1f, 0x26, 0xb7, 0xce, 0x77, 0xa7,
0x13, 0x1d, 0x52, 0x03, 0x0a, 0x36, 0xd8, 0x44, 0x4e, 0xfb, 0x31, 0xe2,
0x54, 0x84, 0x2f, 0x5a, 0xf9, 0xea, 0x53, 0x92, 0x4c, 0x3b, 0xa9, 0x49,
0x28, 0x59, 0x3a, 0x1f, 0x26, 0xdd, 0x31, 0x28, 0xde, 0x53, 0x18, 0x38,
0x15, 0x0f, 0x30, 0x07, 0xbd, 0x43, 0x0d, 0x5d, 0x04, 0xfa, 0x13, 0x30,
0x30, 0x03, 0x40, 0x0c, 0x27, 0x49, 0xff, 0x5b, 0x9c, 0x23, 0x3f, 0x3f,
0x90, 0xfb, 0x43, 0x3d, 0x21, 0x75, 0xd7, 0x4a, 0xea, 0x1d, 0x00, 0x05,
0x3c, 0x21, 0xf8, 0xfa, 0x17, 0xfa, 0x61, 0xc4, 0x0f, 0x4c, 0x09, 0x29,
0x26, 0x31, 0x1d, 0x51, 0xec, 0xfb, 0x09, 0xed, 0xf5, 0x6e, 0x0b, 0x3f,
0xea, 0x01, 0x19, 0x49, 0x58, 0x61, 0x5a, 0x62, 0x2f, 0x30, 0x15, 0x21,
0x2a, 0x2a, 0x6b, 0x21, 0x5a, 0x28, 0x25, 0x0e, 0xbf, 0x75, 0x02, 0xef,
0xc3, 0xe9, 0xbf, 0x10, 0x22, 0x26, 0x08, 0x27, 0x9c, 0x19, 0xd3, 0x3c,
0x6d, 0xd3, 0x1f, 0xd3, 0xf0, 0x38, 0x51, 0x52, 0x41, 0x1f, 0xf3, 0x3f,
0x05, 0x36, 0x60, 0x40, 0x1f, 0xa9, 0xbb, 0x19, 0x67, 0xe8, 0x2e, 0x1a,
0xfa, 0x74, 0xf5, 0xd2, 0x84, 0x22, 0x1d, 0x8c, 0x1b, 0x38, 0x1f, 0x2f,
0x1f, 0x42, 0x55, 0x2b, 0xe1, 0x26, 0x00, 0x1e, 0xef, 0xd1, 0x59, 0x91,
0x5a, 0x2f, 0x50, 0x0f, 0xed, 0x45, 0xcb, 0x56, 0xa5, 0xe1, 0x82, 0xe8,
0x45, 0xec, 0x20, 0x49, 0x33, 0x2a, 0x54, 0xdc, 0x3c, 0x1e, 0x1c, 0x49,
0x16, 0x20, 0x95, 0x68, 0xca, 0x5a, 0x10, 0xf4, 0x0e, 0x2d, 0x36, 0x47,
0xe8, 0x51, 0x35, 0x1c, 0x30, 0x2c, 0x6b, 0xe1, 0x51, 0x32, 0xfb, 0x3f,
0x3c, 0xec, 0x06, 0x57, 0x29, 0x2a, 0xfc, 0x29, 0xd9, 0x2e, 0x16, 0x77,
0x38, 0xe0, 0x2e, 0xc8, 0x3e, 0x3c, 0xc3, 0x15, 0x40, 0xf8, 0xeb, 0x16,
0x23, 0x17, 0x25, 0x53, 0x57, 0x2a, 0x4e, 0x55, 0x5d, 0x10, 0xd6, 0x3b,
0x03, 0x22, 0xb1, 0x59, 0x63, 0xd3, 0x8b, 0xf9, 0xef, 0x2b, 0x26, 0x31,
0xc3, 0x22, 0x64, 0xe4, 0xbc, 0x59, 0x1c, 0x5e, 0x47, 0x36, 0x4b, 0x52,
0x17, 0xc5, 0x28, 0x14, 0x2b, 0x31, 0x0b, 0xef, 0xe1, 0xf1, 0xd2, 0x73,
0x63, 0x04, 0x13, 0x39, 0x10, 0x35, 0xc3, 0xf4, 0xe6, 0xc3, 0x0d, 0xdd,
0x4e, 0x4e, 0x32, 0xf0, 0xed, 0x23, 0x40, 0xce, 0x02, 0x33, 0x21, 0x3f,
0x2c, 0x32, 0xbf, 0xfa, 0x1a, 0xbb, 0x43, 0xcd, 0x4f, 0xf8, 0x14, 0x28,
0xe4, 0x02, 0x20, 0xc6, 0x4a, 0x10, 0x5d, 0x29, 0x3c, 0x19, 0x16, 0x48,
0x30, 0x49, 0x50, 0x2b, 0x0e, 0x45, 0x2f, 0x05, 0x25, 0x1f, 0xc1, 0xd4,
0x08, 0x04, 0x01, 0x4a, 0x4a, 0x0f, 0xc9, 0xe2, 0x92, 0x03, 0xd4, 0x01,
0x45, 0x31, 0x26, 0xd4, 0xf6, 0x3f, 0x5e, 0x71, 0x45, 0x23, 0xb1, 0x17,
0x1a, 0x1c, 0xdd, 0x45, 0x45, 0xb2, 0x32, 0xed, 0x38, 0xd6, 0x66, 0x07,
0xb4, 0xdb, 0x63, 0xf8, 0xb8, 0xd6, 0x65, 0xcb, 0x62, 0x12, 0xe3, 0x38,
0x35, 0xfc, 0xfc, 0x4f, 0xda, 0x13, 0x0a, 0xed, 0xc0, 0x5d, 0x5a, 0x23,
0xc2, 0xc9, 0xb6, 0x1d, 0x1f, 0x43, 0xae, 0xd8, 0xfc, 0xd2, 0x4d, 0xe5,
0xfd, 0x26, 0x1c, 0xf4, 0xd6, 0x37, 0x45, 0xbf, 0xda, 0x28, 0x18, 0x29,
0x1f, 0xdd, 0xc5, 0xe3, 0x3a, 0x38, 0x16, 0x02, 0x58, 0xe3, 0x68, 0x12,
0xe3, 0xa1, 0x0a, 0x9f, 0x49, 0xc2, 0x36, 0x44, 0x1a, 0x28, 0x3d, 0x34,
0x66, 0x01, 0x36, 0x4f, 0xc6, 0x26, 0x2d, 0x02, 0x1c, 0xea, 0x5e, 0x12,
0x40, 0xa5, 0xbd, 0x47, 0x1e, 0x08, 0xed, 0x64, 0x0f, 0x21, 0xec, 0xc2,
0xb2, 0x22, 0x25, 0x06, 0x46, 0x32, 0x4b, 0xd7, 0xf5, 0x27, 0xb7, 0x1f,
0x6e, 0xd4, 0x01, 0xf5, 0xa0, 0x23, 0xc0, 0xdf, 0xc8, 0x22, 0x0f, 0x15,
0xf5, 0x41, 0x8b, 0x0d, 0xec, 0xc3, 0x54, 0x43, 0x1b, 0xd0, 0x0b, 0x27,
0x3c, 0xf1, 0x20, 0x54, 0xd0, 0x03, 0x03, 0xfd, 0xa9, 0x1b, 0x2c, 0xf5,
0x2f, 0xf7, 0xf1, 0x37, 0x4e, 0x27, 0xd4, 0x2a, 0xea, 0x21, 0xcc, 0xe6,
0xd8, 0xd3, 0x10, 0x42, 0x0f, 0xd3, 0x51, 0x10, 0xe9, 0x2c, 0x63, 0x1d,
0x10, 0xfe, 0x12, 0x10, 0x46, 0x54, 0xcb, 0xfa, 0x41, 0x3a, 0xff, 0xf0,
0xfa, 0x1b, 0x20, 0x3e, 0x0e, 0xf3, 0x3c, 0xfc, 0x15, 0x22, 0xee, 0x03,
0x5a, 0x52, 0x2d, 0x19, 0x41, 0x08, 0xfa, 0xef, 0xa6, 0x3d, 0x18, 0x21,
0x90, 0xe7, 0xea, 0xfa, 0x3a, 0x14, 0xce, 0x29, 0xae, 0x00, 0x85, 0xe6,
0xea, 0x16, 0x0c, 0xd7, 0x0d, 0xd7, 0x4d, 0xac, 0xf3, 0x04, 0x12, 0x24,
0xe3, 0x18, 0x26, 0xde, 0x14, 0x85, 0xbf, 0xe4, 0xf0, 0xd8, 0x09, 0x0a,
0xbe, 0x19, 0xb1, 0x15, 0xb0, 0x49, 0x19, 0xfe, 0x10, 0x01, 0x28, 0xb0,
0x42, 0x18, 0xe5, 0x30, 0xd8, 0x30, 0xd5, 0x0b, 0x5c, 0xd9, 0xa0, 0x59,
0xef, 0xe2, 0xc8, 0x11, 0xf2, 0x2f, 0xee, 0x0f, 0x81, 0xf5, 0x5c, 0x25,
0x14, 0x01, 0x26, 0x40, 0x14, 0xdd, 0x65, 0x41, 0xba, 0x09, 0x38, 0x23,
0x05, 0xfe, 0xff, 0x3e, 0x3b, 0xd8, 0x1e, 0x07, 0xd9, 0x61, 0x4e, 0x5b,
0xd9, 0x56, 0xa9, 0x40, 0x0b, 0x15, 0x32, 0xa4, 0xfd, 0x6d, 0x43, 0x9b,
0x3d, 0x4e, 0xf4, 0x1c, 0x05, 0x1d, 0x2a, 0x4b, 0xfc, 0xdb, 0xf7, 0xc2,
0x1e, 0x04, 0xce, 0x1f, 0x03, 0x57, 0xff, 0x28, 0x43, 0x1c, 0xc1, 0x1d,
0xcf, 0x37, 0x11, 0xfc, 0x69, 0xb7, 0x49, 0xe3, 0xea, 0x3b, 0x34, 0x2d,
0x25, 0x2e, 0xcc, 0xc9, 0xfb, 0x26, 0xde, 0xd6, 0xd3, 0xda, 0x3a, 0x52,
0xfc, 0x43, 0x53, 0x3d, 0x1c, 0x63, 0x79, 0x3d, 0x31, 0x06, 0xf4, 0xa4,
0x23, 0xcb, 0xc2, 0x29, 0xd8, 0x13, 0x18, 0x43, 0x5c, 0xe3, 0x37, 0x02,
0x53, 0xfd, 0x1e, 0xe0, 0x20, 0x6d, 0xf9, 0x55, 0x13, 0x0a, 0xfe, 0x21,
0x05, 0x35, 0x38, 0x0d, 0x21, 0xb5, 0x4b, 0x6a, 0xd9, 0x2f, 0xf3, 0x2e,
0x2b, 0xea, 0xd1, 0xce, 0xc8, 0xeb, 0x42, 0xec, 0x36, 0x16, 0x3b, 0x4a,
0xff, 0x2d, 0xbf, 0x17, 0x18, 0x3a, 0x4d, 0x94, 0x37, 0x55, 0x58, 0xba,
0x5a, 0x68, 0x01, 0x00, 0x56, 0x4d, 0x12, 0x6d, 0x33, 0xf8, 0x66, 0xfb,
0xf9, 0xf0, 0xe1, 0x30, 0x0b, 0x52, 0xe7, 0x4a, 0xda, 0x24, 0x45, 0x35,
0x7c, 0x81, 0xf4, 0x57, 0x04, 0xe2, 0x4a, 0xbd, 0xd4, 0x1b, 0x42, 0x27,
0x4f, 0x63, 0xe3, 0xd8, 0xd3, 0x24, 0xbf, 0x06, 0x5d, 0x10, 0xf1, 0x31,
0xde, 0xe9, 0xe3, 0xdc, 0x35, 0xe6, 0xdd, 0x21, 0x15, 0xd2, 0xfb, 0x05,
0x37, 0x1d, 0x13, 0x40, 0x19, 0x1d, 0x22, 0x26, 0xc3, 0x11, 0x11, 0xd2,
0x9d, 0x0b, 0x35, 0x1d, 0x28, 0x5c, 0xd4, 0x19, 0xae, 0x0d, 0x82, 0x58,
0x27, 0x45, 0x40, 0x44, 0xee, 0xe8, 0x21, 0xa4, 0x07, 0x07, 0xcf, 0x50,
0xee, 0x53, 0x8f, 0xdf, 0x6e, 0xac, 0x9c, 0xf6, 0xc7, 0xe0, 0xff, 0x7d,
0xf6, 0x4c, 0x8c, 0xef, 0x55, 0x11, 0xf7, 0xed, 0x11, 0xe9, 0x5b, 0x2b,
0x5c, 0xf5, 0x1e, 0xff, 0xe3, 0x34, 0x09, 0x5f, 0x01, 0x49, 0x76, 0x6b,
0x20, 0x14, 0x46, 0x65, 0x2e, 0x3a, 0xda, 0x1f, 0x49, 0x19, 0x5b, 0x27,
0x1a, 0xa5, 0xef, 0x5e, 0x0d, 0x33, 0x60, 0xee, 0x27, 0xfc, 0xc3, 0x47,
0x03, 0xed, 0xec, 0x39, 0xfb, 0xa4, 0xa0, 0x00, 0xd3, 0xd9, 0x08, 0x32,
0xed, 0x38, 0x1d, 0x21, 0xac, 0x1c, 0x10, 0x64, 0x3d, 0x14, 0x2c, 0x55,
0x5e, 0x72, 0x29, 0x2c, 0xae, 0x51, 0x24, 0xed, 0x44, 0x0b, 0x5b, 0x16,
0x69, 0x01, 0xf6, 0xce, 0x03, 0x23, 0xef, 0x2b, 0xd3, 0x02, 0x8b, 0x47,
0xf6, 0x13, 0x04, 0x00, 0x42, 0x2f, 0x5c, 0x52, 0x5d, 0x32, 0x08, 0x32,
0x0d, 0xe3, 0x58, 0x65, 0x2c, 0xcc, 0x54, 0x0f, 0x44, 0xd3, 0x1b, 0x19,
0xe4, 0x22, 0xf9, 0x19, 0xb7, 0x11, 0x08, 0x0a, 0x31, 0x04, 0x31, 0x32,
0x4d, 0xf9, 0x6c, 0x16, 0xf4, 0x68, 0xdf, 0x02, 0x5d, 0xf4, 0x2e, 0x26,
0x0d, 0xfc, 0xc6, 0x6b, 0x51, 0x47, 0xf6, 0x03, 0xed, 0xd1, 0x9d, 0xfc,
0xea, 0xbd, 0x14, 0x30, 0x14, 0x15, 0x0a, 0x3d, 0x4d, 0x46, 0xfd, 0x2d,
0xfc, 0xdc, 0xe2, 0x51, 0x33, 0xba, 0x0c, 0xfd, 0xba, 0x33, 0x3c, 0x6f,
0x1a, 0x44, 0x52, 0xdc, 0x03, 0x3e, 0x78, 0xc0, 0x0a, 0x1d, 0xeb, 0x0e,
0x52, 0xba, 0x49, 0x19, 0x1f, 0x34, 0x19, 0xd7, 0xe6, 0xe9, 0xe2, 0x70,
0x41, 0x1d, 0xe7, 0xdb, 0x38, 0x11, 0xd0, 0x19, 0x08, 0x01, 0xbb, 0x08,
0xd6, 0xe0, 0x09, 0x62, 0xe4, 0x54, 0x2d, 0xb8, 0x66, 0x22, 0xb9, 0x48,
0x27, 0x13, 0xc7, 0x48, 0xa8, 0x77, 0x66, 0x03, 0x60, 0x07, 0x09, 0x27,
0xf4, 0x11, 0xbf, 0xcf, 0x6c, 0x47, 0x2d, 0xaa, 0x50, 0x42, 0x2c, 0x08,
0x60, 0x9d, 0x05, 0x0b, 0xc7, 0x24, 0x0a, 0xe0, 0xa6, 0xf8, 0x46, 0x59,
0x23, 0xf7, 0xc6, 0x3b, 0x00, 0x53, 0xcf, 0xe3, 0xdd, 0xc5, 0xe4, 0x2a,
0x1e, 0x97, 0x33, 0xaf, 0x0d, 0x2a, 0x48, 0x61, 0x08, 0x18, 0xae, 0x21,
0x19, 0x45, 0xf1, 0xe9, 0x48, 0x02, 0x89, 0x23, 0x08, 0x0c, 0x51, 0x27,
0xd7, 0x06, 0x37, 0xf0, 0xdf, 0xd9, 0xc7, 0xc3, 0x1d, 0xfd, 0x5a, 0x2e,
0x50, 0x9a, 0x1b, 0x34, 0xcf, 0x18, 0x1c, 0xfe, 0x4c, 0x50, 0xc1, 0x87,
0xb6, 0xda, 0xd7, 0x25, 0x2d, 0x19, 0xc9, 0xa9, 0x98, 0x1d, 0xa9, 0x1e,
0x50, 0x4f, 0x58, 0xcb, 0x55, 0x05, 0x4d, 0x4b, 0x55, 0x59, 0xde, 0x1a,
0x19, 0x2d, 0x65, 0xbc, 0x97, 0x90, 0x3d, 0xc2, 0x07, 0xc0, 0x74, 0x41,
0xf0, 0x0d, 0xb9, 0xd0, 0xb6, 0xcf, 0x59, 0xeb, 0x3b, 0xdf, 0x4f, 0x32,
0x3c, 0x67, 0x4f, 0x26, 0x23, 0x40, 0x12, 0x30, 0xbb, 0x54, 0xef, 0x0b,
0x33, 0x0d, 0x43, 0xf4, 0x5b, 0x3a, 0xb6, 0xe2, 0x2e, 0x05, 0x12, 0xc2,
0x57, 0x4e, 0x40, 0x16, 0x2d, 0x39, 0x46, 0x5d, 0xf7, 0x3c, 0x1e, 0x11,
0x2b, 0xce, 0x47, 0x1a, 0xc8, 0xb5, 0x11, 0xef, 0xd8, 0xe6, 0x57, 0x12,
0xbd, 0xab, 0xd3, 0xe5, 0x8b, 0xb9, 0xbb, 0x37, 0x47, 0xdf, 0x01, 0xf4,
0x53, 0x39, 0xe0, 0x40, 0x23, 0xf8, 0x51, 0x1a, 0x3a, 0xd3, 0x53, 0x7e,
0xa4, 0x9a, 0xc0, 0x26, 0x30, 0xe3, 0xf9, 0x2e, 0x1d, 0x4e, 0x42, 0x0d,
0x3d, 0xd8, 0x10, 0xa7, 0x02, 0xf8, 0x5d, 0x8e, 0x35, 0x41, 0xf8, 0x1a,
0x13, 0xf2, 0xc0, 0x54, 0x41, 0x22, 0x48, 0xe1, 0x46, 0x36, 0xfc, 0x27,
0xe8, 0x05, 0xdc, 0x3f, 0x30, 0xca, 0x5f, 0x8d, 0x56, 0xc8, 0xec, 0x18,
0x62, 0x60, 0xfc, 0x15, 0x2e, 0xf3, 0x03, 0x3a, 0xe5, 0xb6, 0x13, 0x4c,
0xc8, 0xc1, 0x1a, 0x21, 0x5c, 0x09, 0x12, 0x31, 0x9d, 0x2d, 0x5a, 0xfd,
0x22, 0x40, 0x26, 0xdc, 0x44, 0x05, 0x2e, 0x71, 0xe8, 0x19, 0xdd, 0x03,
0x42, 0x16, 0xf0, 0x48, 0xae, 0x5e, 0x3a, 0xfa, 0x69, 0xd8, 0x0a, 0x22,
0xe2, 0xef, 0xda, 0x08, 0xe7, 0xfc, 0x3d, 0x31, 0x1c, 0xf8, 0xfd, 0xe1,
0x22, 0xe1, 0xf8, 0x35, 0x37, 0x03, 0x18, 0x2f, 0xe2, 0xee, 0x52, 0x8b,
0x49, 0xd7, 0x00, 0x38, 0x1e, 0x3d, 0xef, 0xc5, 0x9d, 0x1a, 0x25, 0x1b,
0xe0, 0x49, 0x0b, 0x2d, 0xf7, 0xf5, 0x47, 0x9b, 0x0d, 0x25, 0x07, 0x17,
0xff, 0x46, 0x68, 0xe2, 0xf9, 0x13, 0xc1, 0x1c, 0xcb, 0xd3, 0xfb, 0x27,
0xd1, 0x0b, 0x4f, 0x3f, 0xae, 0x07, 0x62, 0xa9, 0x3d, 0xee, 0x2a, 0xb1,
0x58, 0x56, 0xe2, 0x4d, 0xdd, 0x2c, 0x1c, 0xfb, 0xdd, 0x1d, 0x09, 0xcc,
0x6b, 0x12, 0xe1, 0x41, 0x21, 0x29, 0xf8, 0x46, 0xb6, 0x11, 0x98, 0x37,
0x36, 0x61, 0xef, 0x0b, 0x61, 0xa5, 0x62, 0x18, 0xc0, 0x2a, 0xe7, 0x3c,
0x0b, 0xfe, 0x8e, 0x53, 0xed, 0xd2, 0x87, 0xe4, 0x40, 0xfc, 0xf5, 0x63,
0xda, 0x41, 0xf8, 0x1a, 0x1a, 0x0e, 0x5b, 0x10, 0x10, 0x21, 0xfe, 0xc4,
0x20, 0x29, 0xd9, 0x0f, 0xbb, 0x49, 0x13, 0x00, 0xd7, 0x3d, 0xaa, 0x33,
0xd3, 0x0f, 0x5e, 0x0a, 0x10, 0x55, 0xcc, 0x5b, 0x8d, 0xd9, 0xbb, 0x30,
0x47, 0x04, 0x0d, 0xe2, 0x5b, 0x91, 0x18, 0x60, 0x16, 0x13, 0xe5, 0x27,
0x2f, 0x0e, 0xe5, 0x09, 0x3b, 0xbe, 0x14, 0x10, 0xf5, 0xda, 0x23, 0x6f,
0xda, 0x29, 0x45, 0x18, 0xc2, 0x10, 0x32, 0x3e, 0x27, 0xdc, 0x41, 0xa8,
0x12, 0x11, 0xae, 0x30, 0xf6, 0x3c, 0x0b, 0x2f, 0x3e, 0xda, 0xd8, 0x1a,
0xca, 0x31, 0x50, 0x46, 0x08, 0x24, 0xea, 0x0f, 0xe9, 0x11, 0x4d, 0x52,
0xf8, 0x43, 0xf4, 0x17, 0x4e, 0x92, 0x58, 0x22, 0xc2, 0x29, 0x07, 0x3c,
0x1c, 0x29, 0x08, 0xe5, 0xcf, 0xac, 0x4e, 0xed, 0x0e, 0x50, 0xf0, 0x4d,
0xac, 0x32, 0x91, 0xdb, 0x21, 0x21, 0xe5, 0x84, 0x09, 0x57, 0x3c, 0xb2,
0x25, 0x9b, 0xdd, 0x41, 0xba, 0x2c, 0x2e, 0x4b, 0x34, 0xee, 0x65, 0x62,
0x39, 0xd8, 0x53, 0xd8, 0x2d, 0x69, 0xfa, 0x2e, 0x22, 0xfd, 0xa6, 0x2f,
0xe1, 0x29, 0x14, 0xfc, 0x16, 0xc5, 0x68, 0x42, 0x21, 0x05, 0xe1, 0x26,
0x30, 0xf2, 0x40, 0xe0, 0x53, 0xd2, 0x4d, 0xf7, 0x48, 0x6d, 0x29, 0x51,
0xf9, 0x40, 0xf0, 0xe0, 0xbc, 0xe8, 0x6e, 0xc8, 0x2f, 0xfb, 0x41, 0xfd,
0x34, 0xc1, 0x23, 0x07, 0xa9, 0x49, 0x20, 0x39, 0xcc, 0x49, 0x55, 0xc5,
0xce, 0x15, 0xe5, 0xe6, 0x0f, 0x50, 0x07, 0x01, 0x3d, 0xe0, 0xae, 0xf8,
0x7d, 0x47, 0x0f, 0x53, 0xf9, 0x22, 0x62, 0xf8, 0x39, 0x22, 0x26, 0x49,
0xf0, 0x61, 0xaa, 0x0e, 0x02, 0xe0, 0x6c, 0x2f, 0xdd, 0x02, 0x0c, 0x61,
0xb4, 0x42, 0xfd, 0x00, 0x95, 0x52, 0xc4, 0x01, 0x2d, 0x21, 0x22, 0xf1,
0x34, 0xef, 0x0a, 0xff, 0xdc, 0x36, 0x1c, 0x2c, 0x9b, 0x56, 0x0f, 0xbd,
0x36, 0x1c, 0x49, 0x44, 0x05, 0x5d, 0xf3, 0x0c, 0xeb, 0xe5, 0xbd, 0x0f,
0x0c, 0x2c, 0xfb, 0x1e, 0x11, 0x10, 0x54, 0xdd, 0x36, 0x02, 0xe3, 0x3c,
0x04, 0x10, 0x48, 0x64, 0x63, 0x5a, 0x54, 0x3d, 0x7b, 0x04, 0x00, 0x27,
0xea, 0xe5, 0xf9, 0x03, 0xcd, 0x39, 0xca, 0xce, 0x3c, 0xef, 0x6e, 0x35,
0x58, 0xab, 0x13, 0xfb, 0x29, 0x4c, 0x36, 0x32, 0x95, 0xc1, 0xe6, 0xd7,
0x9b, 0x40, 0x4a, 0xed, 0x1c, 0x3a, 0xfe, 0xd9, 0xeb, 0x2c, 0xd5, 0x1a,
0x45, 0x9e, 0x1b, 0x0c, 0x09, 0x09, 0x28, 0x2f, 0x61, 0xfa, 0x38, 0x6b,
0x21, 0x09, 0x5b, 0xdc, 0x19, 0x8b, 0xeb, 0xfe, 0xec, 0x20, 0xed, 0x70,
0xeb, 0xe7, 0x32, 0x34, 0x15, 0x31, 0x15, 0x1b, 0x28, 0xdb, 0xf3, 0x2c,
0x3e, 0x16, 0x75, 0x27, 0xe4, 0x3c, 0xf2, 0xe3, 0xd7, 0x17, 0x20, 0xbc,
0x8d, 0x00, 0x55, 0x58, 0x5f, 0x62, 0xed, 0xf3, 0x5b, 0xfe, 0xee, 0xf0,
0xf4, 0xd4, 0x1f, 0x36, 0x4e, 0x46, 0x51, 0x9a, 0x28, 0x45, 0x15, 0x59,
0x04, 0x3b, 0xf2, 0xf0, 0xb3, 0x90, 0xf7, 0x05, 0x2c, 0x02, 0x4e, 0x3c,
0xfe, 0x0a, 0xc1, 0xef, 0x22, 0x54, 0x44, 0xf2, 0x2e, 0x35, 0xff, 0x36,
0x14, 0x4c, 0x0e, 0xfa, 0x1a, 0x54, 0x02, 0xf5, 0xbd, 0x02, 0x2f, 0x71,
0xd9, 0x30, 0x08, 0x54, 0x29, 0x5d, 0xe5, 0xf8, 0x69, 0xaf, 0x22, 0x1f,
0x66, 0x4f, 0x52, 0x4a, 0x19, 0x23, 0x51, 0xa1, 0x1b, 0x33, 0x3f, 0x36,
0x2d, 0x20, 0x4e, 0x16, 0x6c, 0x1d, 0x12, 0x34, 0xcb, 0x01, 0x0a, 0x65,
0xd1, 0x0f, 0x52, 0xd9, 0x83, 0xfd, 0x2e, 0xdf, 0x1a, 0x4c, 0x4a, 0x46,
0x33, 0xa6, 0x52, 0x3f, 0xaf, 0x20, 0x0e, 0x06, 0x2c, 0x57, 0xd1, 0x5b,
0xad, 0x05, 0x51, 0xd1, 0x54, 0x68, 0xd3, 0xf1, 0x31, 0xbc, 0x34, 0xde,
0x46, 0xbd, 0x59, 0xf3, 0x19, 0x16, 0x25, 0x29, 0x17, 0x1f, 0x1d, 0x34,
0xff, 0xda, 0x5d, 0xf1, 0x4e, 0xfc, 0x23, 0x18, 0x29, 0x27, 0x2f, 0x42,
0xb8, 0xee, 0x1e, 0x2e, 0xc0, 0xf0, 0xe6, 0xa1, 0x45, 0xcf, 0x5c, 0x1e,
0x4c, 0xcd, 0x3d, 0x3c, 0xcd, 0x47, 0x06, 0x35, 0xb7, 0xd8, 0xbe, 0x0e,
0x59, 0xfe, 0x47, 0xca, 0xfc, 0x55, 0xbc, 0xc5, 0xe7, 0x0f, 0xc5, 0xd3,
0x70, 0x8c, 0x08, 0xe2, 0x33, 0xfc, 0x64, 0x5a, 0x29, 0x47, 0xec, 0x23,
0x30, 0x3d, 0xac, 0xd7, 0x63, 0x40, 0x05, 0xd3, 0x0b, 0xf8, 0x0e, 0x34,
0xdf, 0xfd, 0xc4, 0x1e, 0x18, 0xc4, 0xbd, 0x0d, 0x65, 0x41, 0xf0, 0x34,
0x22, 0xce, 0xff, 0x10, 0x54, 0x39, 0x12, 0x27, 0x5c, 0x4c, 0xbe, 0x21,
0x37, 0xe0, 0xf2, 0xba, 0x61, 0x00, 0xd7, 0xb3, 0xeb, 0xfd, 0xdf, 0xdc,
0x3d, 0xf3, 0x3b, 0x35, 0x52, 0x3f, 0x3c, 0xc7, 0xe5, 0x21, 0xe3, 0x0e,
0x32, 0x0b, 0xb6, 0x21, 0x18, 0xba, 0xc8, 0x02, 0x4e, 0xc2, 0x60, 0x12,
0xc8, 0xd6, 0xfe, 0xe9, 0x47, 0x1a, 0x62, 0xe8, 0x1e, 0x07, 0x3f, 0x07,
0x36, 0xcd, 0xf7, 0x4e, 0x17, 0xfc, 0x40, 0x1a, 0xf0, 0x19, 0xad, 0x92,
0x6b, 0xad, 0x43, 0xf1, 0x1a, 0x1d, 0xeb, 0x09, 0xb7, 0xdd, 0x2e, 0xd4,
0x01, 0x24, 0x1e, 0x02, 0x32, 0xfc, 0x26, 0x69, 0xe2, 0x47, 0xc5, 0xfe,
0x1e, 0xf9, 0xec, 0xf6, 0xaa, 0x8f, 0xed, 0xc7, 0xba, 0x00, 0x3b, 0xe5,
0x1d, 0x28, 0xa4, 0x10, 0xb9, 0x06, 0x14, 0xee, 0x34, 0xf3, 0x3c, 0xfa,
0x6c, 0x9e, 0x0e, 0x16, 0xe2, 0xf0, 0x3e, 0x28, 0x9d, 0x54, 0xaf, 0xc0,
0x18, 0xe4, 0x2b, 0x2b, 0x6a, 0x30, 0xfb, 0x33, 0x8a, 0xf0, 0x24, 0x3f,
0x25, 0xe6, 0x03, 0x17, 0x4a, 0x1b, 0x1a, 0xd7, 0x48, 0x07, 0xe5, 0xf6,
0x14, 0xdd, 0xef, 0xf3, 0x40, 0x26, 0xd8, 0xe8, 0xb9, 0x6b, 0x15, 0x1b,
0xd0, 0xfc, 0xe0, 0x10, 0xa8, 0x17, 0x64, 0x10, 0x08, 0x40, 0x58, 0xe7,
0x4f, 0x06, 0xe4, 0x41, 0x5b, 0x0b, 0xd1, 0xe9, 0xd1, 0x51, 0x32, 0x89,
0x0e, 0x11, 0xf1, 0x6f, 0x35, 0x29, 0xe9, 0xf7, 0x45, 0x32, 0xad, 0x31,
0x46, 0x69, 0x28, 0x57, 0x0f, 0xec, 0x46, 0x12, 0x0b, 0x40, 0xdb, 0x30,
0xf8, 0x0a, 0x16, 0x10, 0x03, 0x50, 0x0d, 0xfb, 0x0e, 0xdd, 0x14, 0x0e,
0xf7, 0xf2, 0x15, 0x21, 0xa1, 0x6b, 0x73, 0xd9, 0x1e, 0xf8, 0x0f, 0xe8,
0x24, 0x69, 0x1e, 0x2d, 0xbe, 0x43, 0x05, 0x45, 0x24, 0xa7, 0xd9, 0xc0,
0x3c, 0xfe, 0xef, 0x3a, 0x20, 0x4f, 0xb1, 0xf1, 0x41, 0x38, 0xd3, 0x0a,
0x58, 0x5f, 0x06, 0x47, 0x6a, 0xdb, 0x2c, 0xb7, 0xd8, 0x10, 0xdd, 0x14,
0x16, 0x4d, 0xf8, 0x24, 0x1e, 0xf7, 0xe1, 0x0e, 0x23, 0x73, 0xfa, 0x3f,
0xf4, 0x5b, 0xad, 0x46, 0x49, 0x57, 0x5d, 0x6c, 0xff, 0x14, 0x57, 0x9e,
0x48, 0x16, 0xc9, 0xf9, 0xec, 0x22, 0x0f, 0x5d, 0xf1, 0x6f, 0xf9, 0xfd,
0x92, 0x07, 0x62, 0x24, 0x00, 0x2a, 0xea, 0x05, 0xb0, 0x04, 0x6d, 0x58,
0x19, 0x31, 0x1f, 0x4a, 0x1d, 0x91, 0x5f, 0x48, 0xeb, 0x24, 0xd4, 0x25,
0x04, 0x30, 0x49, 0x62, 0xd9, 0x41, 0x33, 0x18, 0x29, 0x2a, 0x1b, 0x5e,
0xe6, 0x2d, 0xb5, 0x19, 0xa5, 0x58, 0x63, 0x6a, 0x45, 0x27, 0x2d, 0xbd,
0x2a, 0x88, 0x21, 0x02, 0x0c, 0x27, 0x32, 0x30, 0x27, 0x35, 0x3c, 0xb1,
0x4d, 0x04, 0xff, 0x19, 0x3a, 0x3c, 0x05, 0x1a, 0xb9, 0x0a, 0x24, 0x48,
0x07, 0xe9, 0x3c, 0x2d, 0xfd, 0x8d, 0x44, 0x4d, 0xd0, 0x43, 0x4a, 0x2f,
0x17, 0x3d, 0xeb, 0x2d, 0x3a, 0x7e, 0xbb, 0x18, 0x00, 0x37, 0x1c, 0x50,
0xe1, 0x0f, 0xc2, 0x15, 0xf1, 0x02, 0xdb, 0xbf, 0x14, 0x40, 0xf6, 0xc1,
0x17, 0x9b, 0xc3, 0x3b, 0xbf, 0x33, 0x2b, 0x19, 0x46, 0x52, 0x1c, 0xf8,
0x83, 0xdf, 0xd5, 0xe7, 0xe5, 0x44, 0xd4, 0xee, 0x34, 0x42, 0xdc, 0x27,
0x2c, 0x18, 0x00, 0x58, 0x58, 0xa1, 0x51, 0xfa, 0x03, 0x01, 0x5d, 0x3c,
0x1b, 0xf5, 0x62, 0xe7, 0x79, 0xb3, 0x67, 0x2c, 0x30, 0x2a, 0x2e, 0x29,
0xd4, 0x15, 0x42, 0x08, 0xa1, 0x49, 0xed, 0xe7, 0xed, 0x1b, 0x55, 0xc4,
0x4a, 0x93, 0x15, 0x3c, 0xea, 0x25, 0x07, 0x70, 0x5f, 0x3d, 0x73, 0x4e,
0x0e, 0xf3, 0x16, 0x2d, 0xfe, 0x40, 0xf0, 0x49, 0x4f, 0xd5, 0x5d, 0x10,
0x40, 0xd9, 0xf8, 0xee, 0x63, 0xf1, 0x22, 0x9f, 0x41, 0x24, 0xd6, 0x2b,
0xfb, 0x0a, 0x47, 0x69, 0xd8, 0x21, 0xd9, 0x04, 0xd6, 0x10, 0xe7, 0x59,
0x04, 0xf7, 0x30, 0xcc, 0x6c, 0x26, 0x4d, 0xd7, 0x32, 0x0d, 0x2b, 0x0b,
0x1b, 0xe7, 0x29, 0x22, 0x21, 0x53, 0x2a, 0x5b, 0xc0, 0x36, 0xb8, 0x94,
0xe7, 0x28, 0xd3, 0x68, 0x29, 0x79, 0xf0, 0x2f, 0x49, 0x20, 0xb3, 0x24,
0xc6, 0x47, 0x35, 0x1f, 0x06, 0x0c, 0x47, 0xf5, 0x56, 0x0b, 0xd7, 0x54,
0x2b, 0x31, 0xd1, 0x15, 0x35, 0xd1, 0x66, 0x27, 0x35, 0xfc, 0xee, 0x45,
0xdb, 0x1a, 0x9d, 0x17, 0x9e, 0x3b, 0xe4, 0xbf, 0xf2, 0xe6, 0x63, 0x0a,
0x34, 0x08, 0x05, 0xfa, 0x04, 0x58, 0x0d, 0x39, 0x36, 0xed, 0xe0, 0x0b,
0x99, 0x40, 0x1f, 0xe7, 0x05, 0x75, 0xef, 0x06, 0x0f, 0x26, 0x28, 0x04,
0x53, 0xaa, 0x06, 0xc5, 0xf2, 0x51, 0x38, 0xcc, 0x6b, 0x02, 0x2e, 0x65,
0x45, 0x05, 0xa5, 0xe7, 0xab, 0x25, 0x8e, 0x3d, 0x19, 0x2d, 0x13, 0x56,
0xe1, 0x0c, 0x11, 0xf8, 0x65, 0xf6, 0xcb, 0xe2, 0x17, 0x2f, 0x03, 0x4b,
0x3b, 0x74, 0x53, 0x28, 0x5b, 0x3e, 0xe8, 0xf3, 0xc7, 0x1f, 0x6d, 0x11,
0xe3, 0x22, 0xfd, 0x1f, 0x29, 0x36, 0xef, 0x3c, 0x30, 0x32, 0x38, 0x48,
0x5a, 0x18, 0x2e, 0x13, 0x5b, 0x31, 0x29, 0xb4, 0x52, 0x3e, 0xd2, 0x5d,
0x19, 0x2b, 0x02, 0x2f, 0x3e, 0x56, 0x19, 0x20, 0x59, 0x3d, 0xf7, 0x67,
0xf2, 0x29, 0x16, 0x07, 0x88, 0xed, 0x3e, 0x67, 0x2f, 0x52, 0x17, 0x38,
0x36, 0xc2, 0x17, 0x3d, 0x48, 0x41, 0x01, 0x16, 0xfe, 0xd5, 0xf2, 0xa7,
0x6b, 0x13, 0x74, 0xdd, 0x40, 0x53, 0xc8, 0x27, 0xaf, 0x13, 0xfd, 0x0a,
0xf9, 0xf3, 0x2f, 0x45, 0xea, 0x15, 0x1e, 0xf6, 0x42, 0x16, 0x2b, 0x43,
0x10, 0x31, 0xa0, 0xbd, 0x26, 0xe6, 0x83, 0x2e, 0x6c, 0x3a, 0x38, 0x32,
0xc2, 0xe9, 0xdc, 0xf9, 0x9e, 0x06, 0x1a, 0x65, 0x4e, 0x2e, 0x2d, 0x36,
0x39, 0xee, 0x13, 0x24, 0x01, 0x44, 0xf1, 0x46, 0xac, 0x33, 0xc4, 0x31,
0xbb, 0x07, 0x65, 0xe1, 0x52, 0x4d, 0xa4, 0xe3, 0xc5, 0xf1, 0x39, 0xf0,
0xc1, 0xce, 0x1d, 0xe7, 0x21, 0x0e, 0x56, 0xd7, 0x25, 0x31, 0xed, 0x33,
0xf4, 0x3c, 0x9e, 0xeb, 0xa4, 0x7e, 0x83, 0x2c, 0x32, 0x3b, 0x52, 0x3a,
0xd3, 0xd9, 0x48, 0x1f, 0x3d, 0x06, 0x6a, 0x38, 0x1a, 0xcc, 0x00, 0x1b,
0x68, 0x23, 0x37, 0x05, 0xe5, 0x29, 0x1b, 0xd7, 0xfa, 0xf4, 0x52, 0x76,
0x59, 0x18, 0x58, 0xcf, 0x24, 0x15, 0xda, 0xf1, 0x8d, 0xdb, 0x2c, 0xe6,
0x71, 0x12, 0x37, 0xc8, 0x26, 0x2f, 0x15, 0xaa, 0x26, 0x27, 0xcb, 0x14,
0x16, 0x1b, 0x3e, 0xcd, 0x4f, 0x18, 0x4e, 0xfd, 0x5a, 0xea, 0x34, 0x55,
0xd1, 0xa0, 0x5b, 0xab, 0xe5, 0xd3, 0xd5, 0x5a, 0x3d, 0xde, 0x49, 0x1f,
0x49, 0x66, 0x64, 0x53, 0x27, 0x3a, 0x37, 0x06, 0x2f, 0x26, 0x20, 0xf8,
0x88, 0xdd, 0x57, 0xd1, 0x18, 0x08, 0xa6, 0xe1, 0x09, 0xe7, 0x5e, 0xfc,
0x34, 0xe1, 0x48, 0x4a, 0x3c, 0x37, 0x62, 0xd8, 0xf0, 0x47, 0x22, 0x1d,
0x52, 0x32, 0x8a, 0x0f, 0xa5, 0xf2, 0x5e, 0xd2, 0x11, 0x3a, 0x3e, 0x2a,
0xed, 0xa6, 0xbc, 0xf6, 0x06, 0xf6, 0x05, 0xa5, 0x4e, 0x2e, 0xf6, 0x38,
0x59, 0x74, 0xfe, 0x56, 0x0b, 0x28, 0x3b, 0x07, 0x31, 0xb5, 0x59, 0xaa,
0x19, 0xb2, 0xe9, 0x26, 0x50, 0xec, 0xee, 0x28, 0x1b, 0x1f, 0xca, 0xdb,
0xe1, 0x12, 0x53, 0x0e, 0xfb, 0x30, 0x44, 0x97, 0x19, 0x36, 0xca, 0xec,
0x36, 0xf8, 0x90, 0xff, 0xad, 0xf7, 0x4f, 0xdb, 0xb7, 0x20, 0x61, 0xf4,
0x0a, 0x24, 0x15, 0x22, 0x5a, 0x4e, 0x2a, 0xf9, 0x25, 0x4a, 0xd7, 0x0b,
0x25, 0xb9, 0x08, 0x13, 0x31, 0x16, 0xe5, 0xe5, 0xc5, 0x2b, 0x58, 0xe5,
0x57, 0xd6, 0x37, 0x25, 0x37, 0xfa, 0x04, 0xfd, 0xd4, 0x14, 0xcc, 0x38,
0xd9, 0xf2, 0x05, 0x1a, 0x51, 0x01, 0x15, 0xcf, 0x26, 0x0a, 0x05, 0x2f,
0xf6, 0x17, 0xb6, 0xf5, 0x4b, 0x7f, 0xc2, 0xd1, 0x17, 0x49, 0x2c, 0x44,
0xdc, 0xff, 0x3c, 0x16, 0xd8, 0x1a, 0x0f, 0xf4, 0x38, 0xe4, 0xef, 0xd6,
0x22, 0xdf, 0xe6, 0x4c, 0xc5, 0x12, 0x5d, 0x49, 0x26, 0xf5, 0xeb, 0xa0,
0x27, 0xd8, 0x70, 0xf9, 0xf8, 0x38, 0xd5, 0x17, 0xcf, 0x36, 0xa5, 0x55,
0xc7, 0x88, 0x38, 0x0e, 0xfc, 0xc1, 0x59, 0xf6, 0xec, 0x3d, 0x3b, 0x0d,
0x16, 0xf3, 0x71, 0xab, 0x94, 0xcc, 0x6b, 0xe6, 0x18, 0x00, 0x2e, 0x54,
0xe8, 0x33, 0xa6, 0x1e, 0xa2, 0x36, 0x77, 0x44, 0x35, 0x38, 0xf1, 0xdb,
0x40, 0x9e, 0xf0, 0x13, 0x5c, 0x19, 0x0e, 0x37, 0xb9, 0x52, 0xba, 0x51,
0x8c, 0xfe, 0xf8, 0x34, 0x41, 0x43, 0xc7, 0xeb, 0x83, 0x0e, 0xc1, 0x72,
0x56, 0x9f, 0xea, 0x18, 0x57, 0xa4, 0x3d, 0xef, 0xff, 0x19, 0x33, 0x2e,
0x32, 0x0b, 0xcb, 0x43, 0xd1, 0xa5, 0x5c, 0xe4, 0x0a, 0x63, 0x02, 0x2b,
0xdd, 0x53, 0x82, 0x2c, 0xda, 0x2e, 0xe8, 0xe7, 0x17, 0x31, 0x4d, 0xa2,
0x5f, 0x8a, 0xb4, 0xea, 0x48, 0x28, 0xfb, 0xf9, 0xdb, 0x3e, 0xcb, 0xd2,
0xa9, 0xdd, 0x4d, 0x30, 0x4b, 0x3b, 0xf9, 0x5a, 0xbf, 0x47, 0xf5, 0x3e,
0x08, 0x47, 0xf8, 0x16, 0x63, 0x9a, 0x0c, 0xe3, 0xad, 0x00, 0xcb, 0x36,
0xd3, 0x6c, 0xed, 0xf4, 0x4e, 0x26, 0x88, 0x27, 0x72, 0x2c, 0x52, 0x62,
0xe4, 0x2e, 0xe1, 0xf3, 0xf2, 0x4a, 0x58, 0x01, 0x36, 0x10, 0x71, 0x99,
0x51, 0x6c, 0xee, 0x2f, 0x56, 0x2e, 0x21, 0x4a, 0xa0, 0x67, 0xe9, 0xd6,
0x2c, 0x13, 0xda, 0xe8, 0x09, 0x4a, 0xf1, 0x44, 0x44, 0xfd, 0x73, 0xfa,
0x45, 0xec, 0x20, 0xf3, 0xf6, 0xdc, 0x49, 0x86, 0x08, 0x41, 0x22, 0x59,
0x4b, 0x70, 0x24, 0xef, 0x5b, 0x89, 0x45, 0xf2, 0xd2, 0x32, 0x26, 0x40,
0xe8, 0x19, 0x94, 0x2c, 0x6a, 0x0c, 0x51, 0xd0, 0x34, 0x25, 0x31, 0xc5,
0x26, 0xd1, 0xf0, 0x00, 0x31, 0x4a, 0x0b, 0xf2, 0xd4, 0xf7, 0x72, 0x50,
0x0b, 0xde, 0xef, 0x08, 0x45, 0x66, 0x0b, 0x2c, 0x0c, 0x1a, 0xfc, 0x20,
0xfe, 0x4c, 0xf8, 0xf8, 0x26, 0xbf, 0x24, 0xed, 0xe3, 0x14, 0x18, 0x51,
0x36, 0x6f, 0xb1, 0x12, 0xc4, 0x82, 0xa7, 0xe0, 0x72, 0x20, 0xfa, 0x40,
0xe2, 0x23, 0xf4, 0x12, 0x3c, 0x4d, 0x15, 0x01, 0x02, 0x01, 0x2e, 0x01,
0x3d, 0xdc, 0x22, 0x04, 0x73, 0x54, 0xd8, 0x53, 0xd4, 0x00, 0x1d, 0xe5,
0xee, 0xfb, 0x62, 0x40, 0x35, 0x57, 0xc3, 0x2c, 0x9a, 0x13, 0x56, 0x26,
0x01, 0x37, 0xe3, 0x36, 0x57, 0xf7, 0x33, 0xf3, 0xf4, 0x33, 0xb9, 0x45,
0xf5, 0x12, 0x91, 0xe7, 0x34, 0x3d, 0x23, 0x1c, 0x7a, 0xfc, 0x0d, 0x52,
0xf0, 0x5f, 0x4d, 0xe7, 0xbb, 0xf7, 0x49, 0xea, 0x18, 0x1b, 0x48, 0x18,
0x4b, 0x33, 0xf2, 0x14, 0xb0, 0x6f, 0x01, 0x63, 0x5b, 0x52, 0x3f, 0x1d,
0x68, 0x3c, 0xf0, 0x33, 0x09, 0x53, 0xea, 0xe7, 0x8c, 0xd3, 0x05, 0x3e,
0xc3, 0xe3, 0x29, 0x0c, 0x2b, 0x35, 0x2a, 0x1e, 0x3e, 0x29, 0x28, 0x43,
0x02, 0x2b, 0x09, 0x4f, 0x14, 0x2b, 0x89, 0x24, 0x58, 0xf4, 0x15, 0x42,
0xea, 0x38, 0x1b, 0xf2, 0x3f, 0x44, 0xc9, 0xe5, 0x25, 0xb2, 0x59, 0x4f,
0x1b, 0xfd, 0x1b, 0x2d, 0x34, 0x75, 0x42, 0x35, 0x01, 0xfb, 0x5f, 0x6d,
0xef, 0x25, 0x07, 0x5d, 0xf3, 0x33, 0xdb, 0x15, 0x1d, 0x0c, 0x48, 0x74,
0xdd, 0x11, 0xff, 0x3d, 0x5e, 0x4d, 0x43, 0xb8, 0x38, 0x3f, 0x30, 0x74,
0xf2, 0x0d, 0x02, 0x09, 0x68, 0xa9, 0x95, 0x2b, 0x5c, 0x69, 0x01, 0x53,
0xff, 0xfa, 0x13, 0x09, 0xd9, 0x18, 0xd6, 0x8c, 0x00, 0x3d, 0x14, 0x48,
0x29, 0xfc, 0x3d, 0x21, 0xc7, 0x38, 0x23, 0x3c, 0xc9, 0x35, 0x04, 0xae,
0xd9, 0x1b, 0x5e, 0xfd, 0x35, 0x71, 0xe1, 0x34, 0x25, 0x19, 0xea, 0xfd,
0x38, 0xdf, 0x4a, 0x0b, 0x5f, 0x53, 0x1d, 0xbc, 0x62, 0x26, 0xbe, 0x5c,
0x16, 0x2a, 0x6f, 0xf9, 0x18, 0xe3, 0x51, 0x20, 0x1c, 0x38, 0xfc, 0x5e,
0x04, 0x6c, 0x0f, 0xd3, 0xf6, 0x37, 0x40, 0x1a, 0x21, 0x53, 0xff, 0x45,
0x29, 0xc2, 0x71, 0x19, 0x45, 0x44, 0x1b, 0x50, 0xe1, 0x50, 0x58, 0x8f,
0xfd, 0x08, 0x6b, 0x10, 0x36, 0x44, 0xe0, 0x02, 0xf1, 0x1b, 0x93, 0x13,
0x1e, 0x00, 0x15, 0x12, 0x25, 0x18, 0x0f, 0x98, 0x6a, 0x1f, 0x3f, 0x59,
0x1f, 0x29, 0x2d, 0xb7, 0xcc, 0xa0, 0xe9, 0x03, 0xca, 0x1e, 0x3a, 0x22,
0xe3, 0xf7, 0x9a, 0x13, 0x59, 0x12, 0xd4, 0x8b, 0x2c, 0xbc, 0x53, 0x30,
0x54, 0xc8, 0x19, 0x0b, 0x3c, 0x43, 0xfb, 0xe3, 0xa1, 0xfa, 0x74, 0xb0,
0x36, 0x05, 0x12, 0xc7, 0x3a, 0x4c, 0xd1, 0x00, 0x1b, 0x0d, 0x8d, 0x1f,
0xf7, 0x89, 0xfc, 0x20, 0x4a, 0x55, 0x5e, 0xad, 0x39, 0x37, 0x0c, 0x41,
0x12, 0x44, 0xc0, 0xde, 0x58, 0xb0, 0x8b, 0x15, 0x3c, 0x0e, 0x3b, 0x35,
0xa9, 0xf6, 0xe2, 0xc2, 0x6d, 0x16, 0xf8, 0x9f, 0x2a, 0x28, 0x46, 0xfa,
0x45, 0x8f, 0x26, 0x12, 0x49, 0x4f, 0x4a, 0x4b, 0x25, 0x51, 0xec, 0xd9,
0xd3, 0xf7, 0xdf, 0x37, 0x1d, 0x11, 0xbe, 0xc7, 0x36, 0x18, 0xcb, 0xf5,
0xfa, 0xce, 0x21, 0xd5, 0x51, 0x53, 0x19, 0x32, 0x16, 0x56, 0x10, 0x4b,
0x49, 0x47, 0x2c, 0x59, 0xb9, 0xad, 0x14, 0x1c, 0x0b, 0x38, 0x60, 0x1c,
0xc1, 0xc4, 0x3a, 0x0c, 0xd6, 0xe1, 0xdb, 0x2f, 0x2c, 0x4d, 0x20, 0xfa,
0x58, 0x72, 0x11, 0x33, 0xd1, 0x51, 0x23, 0x0f, 0xf4, 0x42, 0xe9, 0x67,
0x39, 0x07, 0x22, 0x2d, 0x3d, 0x50, 0xc4, 0xbe, 0xc7, 0xd4, 0xf8, 0x14,
0xd2, 0x23, 0x2d, 0x1f, 0x50, 0x39, 0x54, 0xa1, 0x30, 0x19, 0xb5, 0x1b,
0x12, 0xf1, 0x2b, 0xc2, 0x27, 0x74, 0x96, 0x12, 0x5c, 0x1d, 0x2d, 0x04,
0x9d, 0xf3, 0x0e, 0xd4, 0x50, 0xf6, 0xf0, 0x99, 0x5c, 0xca, 0xeb, 0x31,
0x49, 0x2f, 0x08, 0x19, 0x2d, 0x1a, 0x34, 0xd5, 0x08, 0x0b, 0xec, 0xce,
0x6f, 0xc8, 0xf5, 0x2a, 0x66, 0x0f, 0xf9, 0x1d, 0x24, 0x14, 0x1d, 0x37,
0xd4, 0x4f, 0x4b, 0xdc, 0x29, 0x29, 0x39, 0xd0, 0x55, 0x36, 0x2b, 0x2a,
0x0e, 0xe3, 0x70, 0x51, 0xab, 0x24, 0xde, 0xe0, 0x18, 0x5f, 0x5e, 0x0a,
0xe9, 0x26, 0x01, 0x38, 0x4e, 0x18, 0xe0, 0x1c, 0x28, 0x3d, 0xe8, 0xf3,
0x37, 0x0e, 0x33, 0x10, 0x1f, 0x26, 0x0b, 0xe7, 0x71, 0x06, 0x91, 0xdc,
0x07, 0xcb, 0xca, 0x58, 0x2f, 0xef, 0xde, 0x26, 0xbf, 0x06, 0xfe, 0x04,
0x43, 0xe3, 0x2d, 0xf8, 0xf0, 0x0a, 0x59, 0x20, 0x20, 0x2e, 0x30, 0x19,
0xef, 0xc2, 0x9b, 0xbb, 0x3c, 0xc4, 0x8d, 0xd6, 0xcc, 0x3f, 0x49, 0x02,
0xda, 0xeb, 0x28, 0x3a, 0xd3, 0x00, 0x58, 0xab, 0x44, 0x1f, 0x3c, 0xe4,
0x18, 0xb3, 0x3e, 0x17, 0x4a, 0x19, 0x28, 0xf8, 0xa4, 0x1b, 0xbc, 0x33,
0x9f, 0xdf, 0x57, 0x10, 0x26, 0x18, 0xb8, 0xec, 0xa8, 0x34, 0x95, 0x08,
0xec, 0x2f, 0x36, 0x58, 0x06, 0xf0, 0x2c, 0x2f, 0x06, 0x43, 0x37, 0x0f,
0x05, 0x1d, 0x0f, 0x0d, 0xdb, 0x49, 0xf0, 0x17, 0xd4, 0xef, 0x03, 0x50,
0xeb, 0x2c, 0xa5, 0x3c, 0xc6, 0xf6, 0xc6, 0xd8, 0x2a, 0x41, 0x62, 0xaf,
0x3b, 0xea, 0xdc, 0x39, 0x2a, 0x4b, 0x40, 0x58, 0x1f, 0xf1, 0xd7, 0x82,
0x6a, 0xf0, 0xfc, 0x47, 0x3a, 0x21, 0xfd, 0x4c, 0x44, 0x4f, 0x91, 0x42,
0xeb, 0x52, 0xf2, 0x32, 0x03, 0xc9, 0x2c, 0xbb, 0x1a, 0x05, 0x71, 0x14,
0x20, 0x5b, 0x47, 0x21, 0xf0, 0x8e, 0x87, 0x0b, 0x3d, 0x3c, 0xd9, 0x4d,
0xee, 0x34, 0x25, 0x45, 0x17, 0x0d, 0x02, 0xdd, 0x37, 0x4f, 0x4c, 0xbb,
0x15, 0x0b, 0xec, 0xee, 0xf3, 0x2e, 0xe1, 0x44, 0x6a, 0x03, 0x5a, 0xcc,
0xe7, 0x10, 0x56, 0x54, 0x0c, 0x2f, 0x01, 0x55, 0xd1, 0x34, 0xd2, 0x59,
0xe6, 0x1f, 0x0b, 0x21, 0x2d, 0xb9, 0x52, 0x2c, 0xd9, 0xfe, 0xba, 0x44,
0xf4, 0x06, 0x96, 0x1e, 0xae, 0x49, 0xaa, 0x00, 0x17, 0x79, 0x18, 0x63,
0xe7, 0x1f, 0x43, 0x17, 0xca, 0x12, 0x4f, 0x8c, 0x0c, 0x5b, 0x10, 0xa8,
0x3e, 0x9a, 0xdc, 0x2b, 0xde, 0x51, 0x1b, 0x78, 0x9d, 0x2e, 0xe0, 0xec,
0x1f, 0x1f, 0x2c, 0x40, 0xf8, 0x47, 0x0c, 0x65, 0xcc, 0xf1, 0x0b, 0x3c,
0xd1, 0x89, 0x26, 0x2e, 0xf6, 0xb9, 0x3e, 0x84, 0xfd, 0x36, 0xfe, 0x42,
0x07, 0x3a, 0xad, 0xcf, 0xdf, 0x97, 0xfe, 0x12, 0xe4, 0x4d, 0x17, 0x2d,
0xff, 0x1b, 0x93, 0x2d, 0x60, 0xf4, 0xd0, 0x33, 0x31, 0x23, 0x3e, 0xb1,
0x52, 0x5b, 0xef, 0x17, 0xfb, 0x30, 0x07, 0x33, 0xb7, 0xe2, 0xd7, 0x6c,
0x0d, 0x1f, 0xe4, 0x4b, 0x01, 0x30, 0xf1, 0x49, 0x15, 0xe6, 0xfb, 0x0f,
0x7f, 0x21, 0xf9, 0x1a, 0x34, 0xec, 0x64, 0x85, 0x0a, 0x34, 0xc1, 0x43,
0x1e, 0x1d, 0xf4, 0x57, 0x1d, 0xc3, 0xe5, 0x23, 0x03, 0xf0, 0x0b, 0x48,
0x0a, 0x54, 0x4c, 0x36, 0x41, 0x4a, 0xe7, 0xa9, 0xf8, 0x23, 0x36, 0xfd,
0x45, 0x04, 0x1e, 0x2e, 0xdd, 0x5c, 0xed, 0x50, 0x62, 0xe9, 0x15, 0xc6,
0xf6, 0x28, 0x3e, 0xd3, 0x32, 0x64, 0x09, 0x28, 0x3a, 0x1a, 0xb9, 0x13,
0xee, 0xf6, 0x38, 0xf8, 0x57, 0x23, 0x4f, 0x12, 0xe2, 0x0d, 0xfe, 0x69,
0xf9, 0x2d, 0xa6, 0x40, 0x08, 0xef, 0xce, 0x1d, 0x70, 0xf7, 0x43, 0x4b,
0xdb, 0xef, 0x0e, 0xf5, 0x58, 0x6a, 0x6c, 0x23, 0x34, 0x17, 0x0c, 0xee,
0x47, 0x35, 0x15, 0x26, 0x0e, 0x74, 0x03, 0x6b, 0x64, 0x38, 0xe3, 0xb2,
0xc3, 0x1e, 0xc5, 0x0e, 0x11, 0x5d, 0xd2, 0x21, 0xd1, 0xf8, 0xbf, 0x4b,
0x37, 0xf5, 0x3a, 0x4e, 0x30, 0x49, 0x47, 0xb4, 0xfe, 0x01, 0xd4, 0x4b,
0x47, 0x51, 0x10, 0x14, 0x03, 0x99, 0x86, 0x38, 0x3a, 0x63, 0x29, 0x38,
0xfc, 0x04, 0x33, 0x01, 0xa2, 0x16, 0xd5, 0x6a, 0x19, 0x3d, 0x1b, 0x24,
0x59, 0x70, 0x3d, 0x3f, 0xdd, 0x69, 0x26, 0x0a, 0xc5, 0xf8, 0x20, 0xc5,
0x6b, 0x46, 0x61, 0xd8, 0x34, 0x74, 0xee, 0xf9, 0x46, 0x08, 0x8a, 0x22,
0x1c, 0xa0, 0x0f, 0x34, 0x59, 0x42, 0x45, 0xe8, 0x5b, 0x38, 0x34, 0x4d,
0xf4, 0xf9, 0x48, 0x21, 0xfc, 0xd4, 0x68, 0x54, 0xd2, 0x48, 0xf5, 0x37,
0xfd, 0xdb, 0x07, 0x14, 0x5f, 0x54, 0xf1, 0x9f, 0x32, 0xe7, 0x00, 0x21,
0x20, 0x9a, 0x52, 0x31, 0x15, 0x4d, 0x16, 0xdd, 0xe3, 0x08, 0x58, 0x83,
0xb4, 0x52, 0xcb, 0x02, 0x29, 0x46, 0xec, 0x24, 0x18, 0xed, 0xa7, 0x36,
0x0f, 0xf6, 0x2e, 0x53, 0x07, 0x17, 0x13, 0x8a, 0x49, 0x04, 0xf9, 0x66,
0x12, 0x3c, 0x22, 0x08, 0xb9, 0x59, 0x5c, 0x34, 0x4c, 0x61, 0x4d, 0x47,
0xf0, 0xec, 0x38, 0xd3, 0x62, 0x5e, 0xf2, 0x20, 0x3b, 0xda, 0x41, 0x31,
0x49, 0x61, 0x2d, 0x1e, 0x43, 0x60, 0x26, 0x3d, 0x2a, 0xf7, 0xc8, 0xae,
0x55, 0x0d, 0x1f, 0x31, 0x48, 0x78, 0x00, 0x31, 0xce, 0x07, 0x47, 0x52,
0xea, 0xdf, 0x12, 0xd9, 0x5b, 0x33, 0x20, 0xb1, 0x0a, 0x0c, 0x29, 0x6d,
0x26, 0x4a, 0x2a, 0x0f, 0xad, 0x15, 0xb9, 0xf1, 0x16, 0x4f, 0x02, 0x64,
0xc0, 0x19, 0x36, 0x06, 0x10, 0x44, 0xec, 0xe3, 0x53, 0x04, 0x59, 0x5d,
0x19, 0x1f, 0x60, 0x3f, 0x21, 0x47, 0x1b, 0x06, 0xb8, 0xf1, 0xae, 0x40,
0xd7, 0x04, 0x07, 0xee, 0x31, 0x4b, 0x9e, 0xf2, 0x13, 0xdf, 0xd0, 0x17,
0x73, 0x15, 0x19, 0x10, 0x51, 0x42, 0x29, 0xcc, 0x60, 0x38, 0x5c, 0x51,
0x15, 0x32, 0xff, 0x33, 0xa0, 0xd3, 0xd4, 0x22, 0x47, 0xf3, 0x19, 0x35,
0xb9, 0x3d, 0xc5, 0xcc, 0x96, 0x67, 0x1f, 0xb2, 0x66, 0x20, 0x22, 0x1a,
0x30, 0x97, 0x2e, 0x0a, 0x1c, 0x34, 0x27, 0x4e, 0x5b, 0x3a, 0x0d, 0x09,
0x88, 0x20, 0x30, 0x1b, 0x1a, 0x13, 0xba, 0xbc, 0xd8, 0xf0, 0x25, 0x00,
0xf6, 0xa8, 0x0e, 0xd6, 0x00, 0x01, 0x4d, 0x03, 0x43, 0x3e, 0x31, 0x48,
0x14, 0x15, 0x55, 0x5d, 0xf6, 0xfb, 0x00, 0xee, 0xdc, 0x10, 0x1a, 0x1e,
0xb9, 0xa0, 0xba, 0xc8, 0xb5, 0x1d, 0xd6, 0x30, 0x41, 0xe6, 0xf4, 0x15,
0x39, 0x6d, 0x3e, 0x49, 0x2c, 0x41, 0x15, 0x0c, 0x28, 0xbb, 0x57, 0xdc,
0x41, 0xf7, 0xd5, 0x39, 0xfb, 0x0b, 0xc9, 0xbb, 0x37, 0x06, 0xa4, 0x26,
0x2f, 0xda, 0x30, 0xee, 0x48, 0xfa, 0x13, 0x2c, 0x3d, 0x59, 0x35, 0x36,
0x26, 0x21, 0xc5, 0xb3, 0xed, 0xa8, 0x34, 0xed, 0x29, 0x43, 0x2d, 0x3c,
0xb1, 0x22, 0xfe, 0xd3, 0xd0, 0x1d, 0xdb, 0x51, 0x5e, 0xde, 0x0d, 0x26,
0x64, 0xfa, 0x02, 0x1e, 0x04, 0x21, 0x41, 0x29, 0x30, 0xc9, 0xf5, 0x1c,
0x97, 0xc3, 0x2e, 0x25, 0x2b, 0xfa, 0x10, 0x2a, 0x0f, 0xd6, 0x1a, 0x28,
0xca, 0xff, 0x3f, 0xe2, 0x3d, 0xf5, 0x20, 0x9b, 0x23, 0x49, 0xdd, 0x00,
0x2c, 0x21, 0xc1, 0x02, 0xe9, 0x65, 0xca, 0xd9, 0x0f, 0x4f, 0x3c, 0xf0,
0xec, 0x2d, 0xf0, 0x2e, 0xea, 0x11, 0x33, 0xe9, 0x18, 0x24, 0x1d, 0x13,
0x15, 0x6a, 0x2f, 0x40, 0x01, 0xf5, 0x2d, 0x36, 0x2a, 0xf6, 0x9d, 0xdb,
0x38, 0xad, 0xee, 0xed, 0x25, 0x2c, 0xf4, 0x21, 0x28, 0x16, 0x29, 0xff,
0x40, 0x1d, 0x31, 0x53, 0x30, 0xfb, 0x21, 0x48, 0x5e, 0x00, 0xf3, 0x08,
0x1c, 0x29, 0xa3, 0x3a, 0xda, 0xcd, 0x26, 0xe0, 0x3a, 0xd9, 0x24, 0x34,
0xbf, 0x25, 0xef, 0x0d, 0xaf, 0x1c, 0xb9, 0x1f, 0x3d, 0xf9, 0x47, 0xeb,
0x46, 0xa2, 0x4b, 0xfd, 0x4b, 0x00, 0x05, 0x35, 0x5c, 0xce, 0xeb, 0x0a,
0x27, 0x0b, 0x1c, 0x21, 0x21, 0x13, 0xe6, 0xe5, 0x0b, 0xf7, 0x5d, 0x42,
0x4f, 0xb2, 0x16, 0x40, 0xee, 0xb8, 0x21, 0x91, 0x0f, 0x41, 0x35, 0x31,
0x0e, 0xeb, 0xb6, 0x0b, 0x3b, 0x78, 0x87, 0x1d, 0x66, 0x38, 0x27, 0x20,
0xc9, 0xcb, 0x31, 0x1d, 0xfb, 0x09, 0x42, 0x38, 0xff, 0x01, 0x16, 0xa5,
0x3f, 0x3e, 0x0e, 0x2c, 0x43, 0x22, 0x06, 0x54, 0x27, 0x4a, 0xec, 0xa2,
0x94, 0x24, 0x06, 0x6d, 0x07, 0x5e, 0xe5, 0xff, 0xa3, 0x56, 0x06, 0x18,
0x4b, 0x1f, 0x26, 0x29, 0x4e, 0x9a, 0x07, 0x11, 0x0e, 0x21, 0x55, 0x32,
0xdc, 0x2a, 0x1d, 0x5e, 0xe5, 0x18, 0x1c, 0x1d, 0x43, 0x24, 0xeb, 0x7e,
0xcf, 0x3f, 0x2f, 0x51, 0xa6, 0x27, 0x0a, 0xdd, 0x36, 0xc3, 0x51, 0xac,
0x3d, 0xe2, 0xf5, 0x01, 0xd9, 0x17, 0xe2, 0x38, 0x08, 0xd0, 0x3b, 0x2e,
0x1c, 0x1b, 0x31, 0xe3, 0xf7, 0x42, 0xe3, 0x31, 0x59, 0x08, 0x07, 0x11,
0x17, 0x66, 0x20, 0x0c, 0x3a, 0x86, 0x2b, 0xc3, 0xa1, 0xf0, 0xde, 0x5c,
0x40, 0x1b, 0x13, 0xde, 0x2c, 0xf5, 0xdc, 0x2b, 0xf8, 0xe9, 0x41, 0x72,
0xdd, 0x59, 0xfd, 0x0f, 0x90, 0x0a, 0x78, 0xb2, 0x3a, 0x00, 0x67, 0x81,
0x4b, 0x0a, 0x9d, 0x16, 0xae, 0x41, 0x34, 0x7d, 0x16, 0xca, 0xbb, 0xe7,
0x1b, 0x33, 0xf2, 0x4f, 0x1a, 0x2d, 0xda, 0x5f, 0xf5, 0xd3, 0xab, 0x4f,
0x0b, 0x4f, 0xf8, 0x40, 0x15, 0xb0, 0x19, 0xb6, 0xe6, 0x42, 0xae, 0x59,
0x23, 0x57, 0x30, 0x0b, 0x1d, 0x46, 0xd9, 0x0f, 0x71, 0x11, 0xe7, 0x75,
0xe8, 0x29, 0xc0, 0x3a, 0xa5, 0x1d, 0x32, 0x02, 0xfb, 0xd8, 0xf9, 0x98,
0x0f, 0x4f, 0xd8, 0xf4, 0x0d, 0x5d, 0x1f, 0x38, 0x10, 0x7f, 0x01, 0xb6,
0x47, 0x30, 0x11, 0xf2, 0xf6, 0x7d, 0xf4, 0x2e, 0x9c, 0x2a, 0xf4, 0xf6,
0xe2, 0xe9, 0x1f, 0xc7, 0x50, 0xab, 0x25, 0xe7, 0xb2, 0x1a, 0x05, 0x29,
0x17, 0x2d, 0x66, 0x14, 0xab, 0x73, 0x33, 0xf7, 0x19, 0x35, 0x37, 0x44,
0xc8, 0x36, 0x35, 0xec, 0x8d, 0x32, 0x4e, 0xf6, 0x1e, 0x38, 0x6a, 0x05,
0x4e, 0xe4, 0xde, 0x08, 0x19, 0x3b, 0x22, 0x73, 0x20, 0xdf, 0xdb, 0x8a,
0xb6, 0x06, 0xed, 0x1f, 0x17, 0x42, 0xe7, 0x09, 0x43, 0xed, 0xb1, 0xfb,
0xff, 0x1c, 0x36, 0xf4, 0x39, 0x05, 0x50, 0x9e, 0x22, 0x2c, 0x14, 0x38,
0x17, 0x22, 0x5b, 0xcc, 0x38, 0x46, 0xde, 0x20, 0x5f, 0x3c, 0xf1, 0x70,
0xe9, 0x24, 0xa5, 0x0a, 0x63, 0x44, 0xcf, 0x47, 0x2c, 0xdf, 0x57, 0x37,
0x28, 0x99, 0xe0, 0x12, 0x3f, 0x73, 0x1c, 0x5b, 0x88, 0x78, 0xd8, 0x70,
0x61, 0x0c, 0x7f, 0x00, 0xf3, 0x33, 0xff, 0x09, 0x68, 0x01, 0x3d, 0x47,
0x0b, 0x26, 0xf6, 0xea, 0x6e, 0x28, 0x22, 0x0b, 0xe0, 0x3b, 0xa1, 0x4d,
0x2d, 0x57, 0x24, 0x0b, 0x1c, 0xeb, 0xf9, 0x0a, 0x2d, 0x69, 0x29, 0x38,
0xff, 0x44, 0xba, 0x05, 0x9c, 0x0d, 0x35, 0x94, 0xf3, 0xcf, 0x20, 0x53,
0x68, 0x68, 0x49, 0x04, 0x41, 0x63, 0x11, 0x07, 0x91, 0xfb, 0x45, 0x1d,
0x88, 0x23, 0xe9, 0x1a, 0x0a, 0x57, 0xf6, 0x1e, 0x31, 0x0c, 0xd9, 0x73,
0x57, 0xe7, 0x29, 0xe6, 0x54, 0x5e, 0x40, 0x92, 0x44, 0x0d, 0xfa, 0x75,
0x07, 0x4d, 0xf1, 0xbe, 0xec, 0x12, 0xf3, 0x41, 0x02, 0xf0, 0x11, 0x60,
0xf5, 0x05, 0xd9, 0xbe, 0x6f, 0x22, 0xcb, 0x31, 0x3a, 0x24, 0x4d, 0x48,
0x11, 0x1e, 0x3a, 0x05, 0x49, 0x51, 0x0f, 0xf9, 0x38, 0x14, 0xfe, 0x09,
0xda, 0x3f, 0x11, 0xd4, 0x5b, 0x4f, 0xfa, 0x15, 0x03, 0xf3, 0x39, 0x20,
0xce, 0x04, 0x44, 0xef, 0x48, 0x57, 0x08, 0xb2, 0x09, 0x3c, 0xa5, 0x75,
0x48, 0x02, 0xa5, 0xcb, 0x5d, 0x6e, 0xb8, 0x49, 0x6a, 0x2f, 0x10, 0x3f,
0xed, 0xf3, 0x05, 0xca, 0x47, 0x66, 0x5e, 0xd1, 0x14, 0x3d, 0x42, 0x64,
0x38, 0x65, 0x52, 0x0a, 0xf9, 0x42, 0x16, 0xfb, 0x01, 0xef, 0xe5, 0x2b,
0x50, 0x14, 0x0c, 0x2d, 0x48, 0x75, 0xc6, 0xd3, 0xb8, 0xec, 0x71, 0x4e,
0x4b, 0x66, 0x30, 0xf2, 0x6d, 0x53, 0x0c, 0x6f, 0x33, 0x3f, 0xfe, 0x5e,
0x08, 0x25, 0xc6, 0x08, 0xad, 0xc8, 0xae, 0x08, 0xf9, 0xd0, 0x45, 0x43,
0xc6, 0xf8, 0x9b, 0x0b, 0x86, 0xfc, 0x45, 0x35, 0x1d, 0xcd, 0x2b, 0x15,
0x54, 0x1e, 0x16, 0x29, 0xc9, 0x3e, 0x4f, 0xe7, 0xc4, 0xed, 0xa8, 0x7e,
0x62, 0x26, 0xbb, 0xe4, 0xff, 0x78, 0xd0, 0xf0, 0x2b, 0x0f, 0x70, 0x39,
0x58, 0x36, 0x06, 0xca, 0x14, 0x32, 0x1c, 0x96, 0x4c, 0x3e, 0xa3, 0x4d,
0x15, 0xed, 0x26, 0xbf, 0x5c, 0xa4, 0xf2, 0x35, 0xe0, 0x49, 0x21, 0x24,
0xaf, 0x2e, 0x3d, 0xc8, 0x56, 0x69, 0x52, 0x25, 0x4e, 0xdc, 0x21, 0x0b,
0x22, 0xd2, 0x07, 0x39, 0x1c, 0x51, 0x20, 0xdf, 0x40, 0xe5, 0xad, 0x23,
0x41, 0x14, 0x4b, 0x50, 0x5f, 0x33, 0xcb, 0x9f, 0xe0, 0xf7, 0x8c, 0xf0,
0x6a, 0xd2, 0x46, 0xd2, 0xf4, 0x01, 0x54, 0x4d, 0xdf, 0x23, 0x53, 0x35,
0x0c, 0x44, 0xf3, 0x04, 0xf6, 0x2a, 0x84, 0x08, 0xb4, 0xf3, 0x22, 0x3a,
0x82, 0xce, 0x1c, 0xdf, 0xbd, 0x58, 0x4f, 0x8e, 0x1e, 0x20, 0xf6, 0xff,
0x20, 0x32, 0xe5, 0x1a, 0xf2, 0x40, 0xff, 0x08, 0x99, 0xdd, 0x53, 0xe1,
0xd3, 0x14, 0xf9, 0x52, 0x69, 0x26, 0xd0, 0x2f, 0x13, 0xfe, 0x0b, 0x4b,
0xf1, 0xf9, 0x4b, 0xbf, 0x71, 0xf9, 0x25, 0x5a, 0x49, 0x47, 0xb2, 0x2b,
0x0b, 0x41, 0x0a, 0x1c, 0x48, 0xa0, 0x23, 0x31, 0x02, 0xe1, 0x66, 0x19,
0xaf, 0xc0, 0x0e, 0xb3, 0x08, 0xe5, 0xc3, 0x31, 0x33, 0xc1, 0x31, 0xfa,
0x49, 0x8f, 0x30, 0x29, 0x68, 0x3c, 0x34, 0x25, 0x11, 0xf6, 0x61, 0x6c,
0x25, 0xc9, 0xbd, 0xdd, 0x18, 0x18, 0xe2, 0x31, 0xad, 0x13, 0x0d, 0x27,
0x12, 0xe4, 0x2c, 0x19, 0xd6, 0x12, 0x2e, 0xc9, 0x14, 0x47, 0x4d, 0x12,
0xfd, 0xe4, 0xbf, 0xb3, 0xea, 0x93, 0x08, 0xb2, 0xf9, 0xea, 0x36, 0x11,
0xea, 0x2d, 0xf3, 0x25, 0xc2, 0xf7, 0x1e, 0xae, 0x11, 0x29, 0xf6, 0xf6,
0x5f, 0x35, 0x56, 0x20, 0x30, 0x0c, 0x18, 0x28, 0xa6, 0xdc, 0x21, 0x3e,
0x98, 0xa5, 0x5e, 0xf2, 0x4a, 0x3d, 0xdc, 0x12, 0x9c, 0x4c, 0xb6, 0x26,
0xfc, 0x45, 0x40, 0xf5, 0x15, 0x14, 0x28, 0xe3, 0x09, 0x07, 0xfd, 0x09,
0x42, 0xf5, 0x29, 0x44, 0xe0, 0xff, 0xe9, 0xbe, 0xb2, 0x25, 0x0f, 0x29,
0xdf, 0x31, 0x27, 0x48, 0x60, 0x13, 0x64, 0x9c, 0x04, 0xe2, 0x58, 0x0c,
0x2d, 0x21, 0x06, 0xf6, 0x32, 0x23, 0x0f, 0x4b, 0xb6, 0x3d, 0xd2, 0x28,
0xec, 0xe4, 0xc0, 0x14, 0xfe, 0x12, 0xee, 0x1a, 0x04, 0x22, 0x47, 0x4f,
0x1c, 0x62, 0x2f, 0xed, 0x19, 0xbe, 0x39, 0x56, 0x09, 0x13, 0x40, 0x1f,
0x0b, 0xf4, 0xdb, 0xb1, 0x41, 0x3f, 0x9f, 0x2a, 0x57, 0x53, 0xf1, 0x47,
0xdc, 0x1e, 0xc6, 0x0c, 0xe8, 0xfe, 0x29, 0xa2, 0xed, 0x08, 0x16, 0xc6,
0x3b, 0x4c, 0xe3, 0x0f, 0xd6, 0x3d, 0xed, 0x60, 0x6f, 0x36, 0x5a, 0x35,
0x92, 0x0e, 0x39, 0xfd, 0x1a, 0x5e, 0xeb, 0x17, 0xc9, 0x1a, 0xbc, 0x2c,
0x73, 0xc5, 0x1c, 0x34, 0x19, 0xe0, 0x3f, 0x20, 0x1e, 0x04, 0xfc, 0x46,
0xee, 0x30, 0xaa, 0x6c, 0xee, 0xde, 0x98, 0x19, 0x42, 0x07, 0x13, 0x33,
0xde, 0x02, 0x16, 0x41, 0xad, 0x06, 0x0d, 0xfe, 0xf8, 0xff, 0x09, 0x9c,
0x27, 0x26, 0xe3, 0x1d, 0x1d, 0x2c, 0xfd, 0x52, 0xab, 0x64, 0xbd, 0xa0,
0xa8, 0xf8, 0x3a, 0x50, 0x2f, 0x4f, 0xdb, 0x14, 0xb5, 0x13, 0xe4, 0x69,
0x75, 0x15, 0x36, 0x4d, 0x0e, 0xa9, 0x1c, 0xcc, 0xa3, 0x1c, 0x0e, 0x3c,
0x00, 0x7f, 0xf1, 0xbb, 0xd1, 0x69, 0xfe, 0xf6, 0x43, 0x5f, 0x21, 0x39,
0xf0, 0x4d, 0x2b, 0x2c, 0x11, 0x57, 0x6a, 0x88, 0x29, 0xde, 0x5d, 0xa6,
0x55, 0x4a, 0xcd, 0xfe, 0x54, 0x49, 0xf1, 0x31, 0xa0, 0x18, 0xe1, 0xa9,
0x48, 0x20, 0x06, 0x01, 0x17, 0x58, 0xde, 0x24, 0x1b, 0x0c, 0x30, 0x08,
0xfb, 0x6b, 0x32, 0x37, 0x00, 0xa9, 0x12, 0xe6, 0xc4, 0x19, 0x3e, 0x43,
0xed, 0x4a, 0x48, 0x03, 0xfa, 0xfd, 0xdf, 0x21, 0xff, 0x4b, 0xf1, 0x3b,
0xf8, 0x48, 0x02, 0xe0, 0xa3, 0x07, 0xff, 0x5d, 0x27, 0x3f, 0x10, 0xc9,
0x60, 0xa4, 0xc9, 0x19, 0x36, 0x5d, 0x09, 0x61, 0xca, 0x5f, 0xff, 0x7d,
0x00, 0xfc, 0x10, 0x6b, 0xfc, 0x3f, 0xfd, 0x08, 0xfc, 0x11, 0x9b, 0x23,
0x54, 0x1f, 0x39, 0xd8, 0x30, 0xc9, 0x2f, 0x59, 0xe6, 0x2c, 0x1f, 0x44,
0x1b, 0x59, 0xdf, 0x18, 0xfb, 0xe6, 0xf5, 0x20, 0x4b, 0x27, 0x22, 0x34,
0xe3, 0x3d, 0x5f, 0x0b, 0xe0, 0x0c, 0x48, 0x1a, 0x0e, 0xd8, 0x08, 0xe2,
0x29, 0x0b, 0xca, 0x0d, 0xbe, 0x67, 0xf9, 0x54, 0x18, 0x43, 0xb0, 0x18,
0x58, 0x2f, 0x1d, 0x3f, 0xf0, 0x59, 0xe8, 0xfc, 0x2c, 0xf3, 0xd1, 0x67,
0x24, 0x37, 0x04, 0xf2, 0x0d, 0xdc, 0x2c, 0xc5, 0xae, 0x30, 0x12, 0x57,
0x39, 0x45, 0xcf, 0xf9, 0x27, 0x21, 0x1a, 0x01, 0xd2, 0x12, 0x23, 0x5e,
0xdc, 0xec, 0xe7, 0x23, 0xd4, 0x33, 0x7c, 0xe7, 0x16, 0x02, 0x25, 0x0c,
0x47, 0xb1, 0xd0, 0x1a, 0x9e, 0x36, 0xec, 0x64, 0x88, 0x6d, 0x00, 0x5e,
0xa9, 0x13, 0x40, 0x25, 0x3c, 0x56, 0xcd, 0x29, 0xe9, 0x15, 0xf4, 0x66,
0xe3, 0x19, 0x41, 0x1d, 0x1f, 0x26, 0x56, 0x6a, 0x13, 0x29, 0xdf, 0x3d,
0x0b, 0x68, 0xd9, 0xef, 0x0e, 0xa5, 0xf6, 0x24, 0x11, 0x38, 0x01, 0x4d,
0xec, 0x43, 0xd4, 0xdb, 0x3a, 0x63, 0x1a, 0x4e, 0xf8, 0x0f, 0x7c, 0x4a,
0x4c, 0x8f, 0x17, 0xf6, 0x1d, 0x51, 0xf8, 0x6f, 0xb8, 0x00, 0x10, 0x89,
0xc1, 0x4a, 0x30, 0xe8, 0x1d, 0x24, 0xfb, 0xff, 0x35, 0x2f, 0x23, 0x51,
0x75, 0x14, 0xf8, 0x1b, 0x38, 0x5f, 0x4f, 0xe7, 0x62, 0x15, 0xc9, 0x70,
0xf6, 0x23, 0x23, 0x54, 0x7d, 0xeb, 0x0c, 0x58, 0x17, 0xfd, 0x1d, 0x21,
0xee, 0x0b, 0xb0, 0x23, 0x18, 0x53, 0xeb, 0xcc, 0x05, 0xfe, 0x63, 0x4f,
0x4e, 0x9e, 0x20, 0x1e, 0x3d, 0x60, 0x42, 0x0f, 0xa0, 0x4c, 0xd1, 0xde,
0xd7, 0x3b, 0xd6, 0x69, 0x0b, 0x79, 0xd6, 0xfd, 0xa5, 0x31, 0x1e, 0x45,
0x57, 0x4b, 0x1b, 0x40, 0x08, 0x47, 0x37, 0x14, 0x23, 0x12, 0x48, 0x5e,
0x2a, 0x57, 0x09, 0x0f, 0x08, 0x52, 0x65, 0x39, 0x71, 0x2f, 0x2f, 0x44,
0xd9, 0x1d, 0x9e, 0x1e, 0x50, 0x60, 0xc7, 0x2b, 0x03, 0xbc, 0x52, 0x30,
0x46, 0xd0, 0x15, 0x0a, 0xc2, 0x3f, 0x08, 0x5c, 0xc4, 0x5b, 0xc8, 0xd4,
0x4e, 0x4e, 0xf6, 0x41, 0xf7, 0x48, 0xf9, 0xfa, 0xd5, 0x19, 0x5b, 0x26,
0xe7, 0x04, 0x09, 0xa5, 0x2d, 0x17, 0x39, 0x98, 0x11, 0x0d, 0x16, 0x3d,
0xeb, 0xec, 0x1c, 0xcb, 0x6e, 0xe6, 0x5c, 0x2f, 0x32, 0x49, 0x42, 0x56,
0xc1, 0xeb, 0xa8, 0x23, 0x9c, 0x24, 0x09, 0x06, 0x15, 0x0f, 0x17, 0x59,
0x35, 0x26, 0x33, 0x3e, 0x39, 0x64, 0x12, 0x08, 0xc6, 0xe9, 0xc9, 0xac,
0xcc, 0x0c, 0x5f, 0xfe, 0x15, 0x71, 0xc0, 0xf8, 0xb8, 0xdb, 0x6f, 0x34,
0xe1, 0x3e, 0x1e, 0xd8, 0xfc, 0x2f, 0x2d, 0xec, 0x02, 0x29, 0xe2, 0x3c,
0x31, 0x04, 0x89, 0x05, 0xdb, 0x82, 0x1d, 0x43, 0x66, 0x18, 0x01, 0x2f,
0xad, 0xdc, 0xca, 0x00, 0x3f, 0x49, 0x53, 0x5e, 0x3a, 0x08, 0x3d, 0x2a,
0x5d, 0x44, 0x20, 0x05, 0x37, 0x40, 0x18, 0xe3, 0x62, 0x4b, 0x02, 0xa2,
0xbb, 0x4b, 0x56, 0xd2, 0x32, 0x4d, 0x8b, 0xcf, 0x1b, 0x36, 0x99, 0x55,
0xca, 0x5d, 0x14, 0xed, 0x44, 0x12, 0x21, 0xff, 0x1a, 0x49, 0x03, 0x52,
0x14, 0x57, 0xa9, 0xe4, 0xfd, 0x58, 0x14, 0x12, 0x1f, 0x5a, 0x23, 0x11,
0xd2, 0xcb, 0x8a, 0x15, 0x56, 0x4d, 0xec, 0x45, 0x23, 0xe1, 0x73, 0x26,
0x40, 0x9f, 0x23, 0x1f, 0xed, 0x23, 0x3f, 0x34, 0xc9, 0xd6, 0xba, 0xae,
0xec, 0x1d, 0x25, 0x22, 0x4f, 0x62, 0xc4, 0xf6, 0x49, 0xc0, 0x2b, 0xe5,
0x0d, 0x91, 0x50, 0xe4, 0x1d, 0x40, 0x61, 0x16, 0x1d, 0x24, 0x37, 0x25,
0x10, 0x09, 0x6e, 0xe2, 0x2b, 0x1b, 0x88, 0x2f, 0x68, 0x01, 0x31, 0x47,
0x8c, 0x16, 0xc4, 0xee, 0xfe, 0xf6, 0x1f, 0x1b, 0x3c, 0x0e, 0x2a, 0xfd,
0x23, 0xa6, 0x0c, 0x41, 0x3c, 0x1f, 0x05, 0x12, 0x24, 0x54, 0xf3, 0x30,
0x50, 0xd2, 0xb5, 0x26, 0x0a, 0x1e, 0xfe, 0x1a, 0x92, 0x2a, 0x9c, 0x16,
0xd7, 0x52, 0x2a, 0x4b, 0x03, 0xea, 0x32, 0x12, 0x41, 0x02, 0xcc, 0x06,
0x20, 0x21, 0x00, 0xfa, 0xa5, 0xa3, 0x2a, 0xb8, 0xd8, 0x0a, 0x21, 0x10,
0x19, 0x07, 0x01, 0x18, 0xe2, 0xfd, 0x6c, 0x38, 0x1b, 0x19, 0x41, 0x1b,
0x51, 0xe8, 0x5d, 0x18, 0x4d, 0x13, 0x1d, 0x34, 0xab, 0xfd, 0x00, 0x17,
0xa5, 0xd8, 0x09, 0x68, 0x14, 0x40, 0xdf, 0x5b, 0x1b, 0xfe, 0x8a, 0x39,
0x16, 0x3d, 0x1c, 0x32, 0xf3, 0xce, 0x4a, 0x54, 0x49, 0x3b, 0xdf, 0x0a,
0x3e, 0x35, 0xaf, 0x4f, 0x45, 0x45, 0x0e, 0xf7, 0x20, 0x21, 0x22, 0x57,
0xd4, 0x45, 0xdb, 0x04, 0xa9, 0x16, 0x21, 0xa6, 0x2f, 0x2a, 0xf1, 0x16,
0x1a, 0xb6, 0x1d, 0x0b, 0x32, 0x25, 0x05, 0xf3, 0x9a, 0x23, 0xf9, 0xaa,
0xe4, 0xe6, 0x2a, 0x77, 0x12, 0x20, 0xc6, 0x41, 0x28, 0x45, 0x4b, 0x5f,
0x6a, 0x6a, 0x49, 0x31, 0x58, 0xcb, 0x5a, 0xf0, 0xfb, 0x1b, 0xbb, 0x24,
0x03, 0x2e, 0xfb, 0x61, 0xd9, 0x55, 0x28, 0x15, 0x12, 0x50, 0x21, 0x3a,
0xd4, 0x3b, 0x50, 0xf5, 0x92, 0xfe, 0x78, 0x6d, 0xff, 0x2b, 0xf5, 0xe7,
0x2f, 0x3c, 0xcb, 0x05, 0x3f, 0x33, 0xfe, 0x11, 0x21, 0xe4, 0x9c, 0xe2,
0x95, 0x0b, 0x33, 0x78, 0x0c, 0x5b, 0xbd, 0x3e, 0x1c, 0xfd, 0x52, 0x47,
0x75, 0xd1, 0x45, 0xb9, 0xf8, 0xce, 0x31, 0xbd, 0xdd, 0x03, 0xd5, 0x3e,
0x0a, 0x5f, 0xf3, 0xed, 0xe6, 0x3c, 0xea, 0xee, 0x58, 0x26, 0x2f, 0x62,
0x10, 0xc4, 0xb1, 0x19, 0x46, 0x41, 0x62, 0x89, 0x30, 0xb3, 0x0d, 0x9d,
0x4e, 0x73, 0xc5, 0x28, 0xde, 0x47, 0xe8, 0x4c, 0x2c, 0x04, 0xe6, 0x53,
0xfa, 0xf7, 0x52, 0x5d, 0x1f, 0x51, 0xf7, 0xea, 0xe8, 0x24, 0x99, 0x12,
0x53, 0xf4, 0x09, 0x12, 0x78, 0x94, 0x1e, 0xbf, 0xd6, 0x29, 0xf2, 0x41,
0x0a, 0x7d, 0x58, 0x43, 0xe0, 0x5c, 0xfd, 0x05, 0xec, 0x30, 0x23, 0x57,
0xdb, 0x1e, 0xe8, 0x22, 0x44, 0x0d, 0xfd, 0x2a, 0x04, 0xe0, 0xfe, 0xac,
0x0e, 0x04, 0xe4, 0x35, 0x4f, 0x3c, 0xf9, 0x19, 0xec, 0x49, 0x59, 0x3a,
0x45, 0xfe, 0xf2, 0x1b, 0x0f, 0x52, 0xf5, 0x47, 0xcd, 0xd1, 0x5d, 0x73,
0xd2, 0xda, 0x12, 0x30, 0x04, 0x97, 0x2b, 0x6e, 0x9e, 0x2a, 0x47, 0x56,
0x0a, 0x48, 0x3a, 0x04, 0xe7, 0x77, 0xa4, 0x34, 0x11, 0x5e, 0xfb, 0x65,
0xf9, 0x2e, 0x51, 0xc9, 0x4a, 0x6d, 0xca, 0xe1, 0x06, 0x0d, 0x65, 0x9f,
0x23, 0x92, 0xc6, 0x39, 0x10, 0x4b, 0x04, 0x1b, 0x00, 0x39, 0x32, 0xf9,
0xf4, 0x21, 0x08, 0x3e, 0xee, 0x36, 0xe1, 0x35, 0x43, 0x37, 0xed, 0x0d,
0x11, 0xe5, 0x28, 0x1c, 0x23, 0xf4, 0x3b, 0xcb, 0xb2, 0x31, 0xe3, 0x41,
0x10, 0x56, 0xca, 0x19, 0x37, 0x2a, 0xe9, 0x01, 0x0b, 0x54, 0x2a, 0x78,
0x03, 0x02, 0x34, 0xfa, 0xff, 0x18, 0x37, 0x32, 0x0d, 0x24, 0x0c, 0xdd,
0x29, 0xbe, 0xdd, 0x25, 0x3f, 0x4d, 0x03, 0x18, 0x61, 0x38, 0x50, 0xcc,
0xa7, 0x37, 0xf3, 0xd2, 0xf4, 0x3c, 0xdd, 0x26, 0xcc, 0xea, 0x68, 0x50,
0xf3, 0x39, 0x06, 0xa8, 0x0d, 0x16, 0x27, 0x2c, 0xad, 0x2e, 0x38, 0x52,
0xe2, 0x3a, 0xcf, 0xc5, 0xd0, 0xc2, 0x27, 0x23, 0xf6, 0x65, 0x40, 0x35,
0x12, 0x18, 0x9e, 0x29, 0x02, 0x02, 0xf1, 0x68, 0x2d, 0x4a, 0x3d, 0xf2,
0x4a, 0xf2, 0xec, 0x19, 0xc5, 0x5e, 0x0e, 0x1c, 0xc3, 0x38, 0x6e, 0x23,
0x11, 0x51, 0x34, 0x5e, 0x34, 0x40, 0xe4, 0x19, 0xf3, 0x15, 0xfc, 0x56,
0xdd, 0xca, 0x40, 0x1b, 0x62, 0x25, 0x3b, 0xc3, 0xf0, 0x33, 0xc0, 0x65,
0x01, 0x3c, 0xca, 0x1f, 0xf7, 0x5c, 0xb8, 0x44, 0xd9, 0x18, 0x0e, 0x3d,
0xfa, 0x2b, 0x02, 0xd2, 0xe5, 0x15, 0xed, 0x57, 0x23, 0xdd, 0x39, 0x05,
0x29, 0x8f, 0xe9, 0x23, 0xde, 0x75, 0x0d, 0x2e, 0xc1, 0xdd, 0xb8, 0x3e,
0x1d, 0x26, 0x3d, 0x2b, 0x27, 0x46, 0xcd, 0xf2, 0x42, 0xf8, 0x5f, 0x00,
0xf5, 0xa8, 0x20, 0x45, 0x7a, 0x29, 0x25, 0x4a, 0xf4, 0x2c, 0x0c, 0x51,
0x0f, 0x50, 0xb8, 0x1c, 0x09, 0x69, 0x9c, 0x2d, 0x2a, 0xd4, 0x33, 0x42,
0x0a, 0x10, 0xba, 0xfe, 0xa3, 0x47, 0x57, 0xf0, 0x01, 0xf2, 0x29, 0x47,
0x13, 0xab, 0x5b, 0x17, 0x81, 0x5d, 0x0c, 0x1a, 0x00, 0xd1, 0xe6, 0x2f,
0x17, 0x6e, 0x0e, 0x17, 0xf8, 0x5f, 0xd7, 0xe2, 0xff, 0x01, 0x10, 0x48,
0x77, 0x53, 0x1d, 0xc1, 0x40, 0x42, 0x4a, 0x40, 0x2f, 0x38, 0x38, 0x7f,
0xed, 0x1b, 0xe2, 0x68, 0xa9, 0x5a, 0xa8, 0x2d, 0xcf, 0x12, 0xfe, 0x42,
0xfb, 0xd7, 0xb2, 0xd1, 0x8e, 0x0f, 0x15, 0xbd, 0x4c, 0x9b, 0x00, 0x4f,
0x17, 0x4c, 0x39, 0x0e, 0x2d, 0x69, 0x12, 0x1b, 0xee, 0xc5, 0x71, 0x7e,
0xe8, 0x22, 0xbd, 0x4a, 0x37, 0x21, 0xef, 0xea, 0x46, 0x0a, 0xa4, 0x3a,
0xf4, 0x49, 0x1f, 0xfa, 0x37, 0x0e, 0x51, 0xb5, 0xed, 0x04, 0xc6, 0x45,
0x23, 0x03, 0xa5, 0x4e, 0x27, 0x8c, 0xcd, 0x46, 0x1f, 0xfa, 0x5e, 0x71,
0xd9, 0x40, 0x47, 0xfa, 0x47, 0x58, 0x26, 0xc4, 0x18, 0xc6, 0x24, 0x30,
0x08, 0xe9, 0xfa, 0x33, 0x48, 0x76, 0x3d, 0x03, 0x75, 0xea, 0x2d, 0x31,
0xf1, 0x1f, 0x1d, 0x6c, 0x61, 0x59, 0xa9, 0xe8, 0x66, 0x01, 0x62, 0x4c,
0xb8, 0x49, 0x22, 0x38, 0x2c, 0x1e, 0x3b, 0x74, 0xf5, 0x01, 0xe7, 0x40,
0x32, 0x49, 0x17, 0xe2, 0x5c, 0xe2, 0x16, 0x24, 0xc0, 0x3b, 0x59, 0x6a,
0xc2, 0x0c, 0xcb, 0xe4, 0x0c, 0x59, 0xc8, 0xf4, 0x49, 0x21, 0x2d, 0x18,
0x5a, 0x24, 0x2e, 0x48, 0x06, 0x59, 0x1c, 0x46, 0xa2, 0x4b, 0x12, 0x0c,
0xde, 0x4e, 0xb4, 0x02, 0x37, 0x5c, 0xd0, 0xf0, 0xa5, 0xca, 0x28, 0x67,
0xd7, 0x9c, 0x48, 0x38, 0xfd, 0x43, 0x23, 0x49, 0x04, 0x40, 0xde, 0x47,
0xfd, 0x59, 0x9c, 0x08, 0xd5, 0xc5, 0x28, 0x09, 0x43, 0xc9, 0x00, 0x30,
0xd3, 0xcf, 0xe5, 0xe0, 0x4e, 0x48, 0x37, 0x89, 0x1c, 0x0e, 0x63, 0x10,
0x3f, 0xe0, 0x06, 0x2d, 0xfc, 0x44, 0xef, 0xff, 0xbf, 0xe3, 0x66, 0x40,
0x12, 0x2f, 0xf8, 0xff, 0x2b, 0x1a, 0xb2, 0xf5, 0xe4, 0xca, 0x35, 0xeb,
0x01, 0xcc, 0x32, 0xcd, 0xf4, 0x15, 0x2d, 0x26, 0x10, 0x35, 0x2c, 0x21,
0x19, 0x18, 0x32, 0x5f, 0x23, 0xf2, 0x64, 0x15, 0xce, 0xd5, 0x08, 0x2f,
0x9a, 0x0e, 0xd3, 0xc5, 0x57, 0xda, 0xf9, 0xcf, 0x42, 0xf3, 0x29, 0x0b,
0x22, 0xed, 0x28, 0x32, 0xef, 0x51, 0x20, 0x4a, 0x93, 0x27, 0xde, 0x49,
0xfe, 0xba, 0x10, 0xf6, 0x50, 0xff, 0xfc, 0x33, 0x09, 0xf7, 0x8a, 0x14,
0xea, 0x5c, 0x17, 0x06, 0x34, 0x05, 0x4d, 0xf0, 0x1d, 0x10, 0x58, 0xfd,
0x0a, 0x25, 0x8f, 0x50, 0x08, 0x95, 0x09, 0xdb, 0x2e, 0x52, 0x37, 0x2f,
0xd1, 0x41, 0x0b, 0x3a, 0xba, 0x41, 0x31, 0xdf, 0x15, 0x17, 0xe7, 0x24,
0x5d, 0x54, 0x20, 0x1d, 0x27, 0xef, 0x0a, 0xda, 0x46, 0x5b, 0x29, 0xaa,
0x28, 0xd8, 0xbc, 0x23, 0x2d, 0x1d, 0xff, 0x30, 0x9a, 0xe9, 0x74, 0xe7,
0xbc, 0x0b, 0x4a, 0x24, 0x39, 0xd6, 0x37, 0x0a, 0xfa, 0x1c, 0x48, 0x0a,
0x0e, 0x3f, 0xec, 0xac, 0xfc, 0x0d, 0xa8, 0xf5, 0xb0, 0x1f, 0x4d, 0x4b,
0xd6, 0x55, 0x3e, 0xec, 0xa3, 0x27, 0xf5, 0xcf, 0x08, 0x08, 0x5e, 0xe3,
0x11, 0xcf, 0x27, 0xee, 0x59, 0x0c, 0x26, 0xf9, 0x8d, 0x45, 0xe7, 0x68,
0x46, 0xfb, 0xe0, 0x44, 0x29, 0x40, 0xf5, 0x3f, 0x19, 0x49, 0x96, 0xec,
0x60, 0x1b, 0x15, 0xda, 0x4e, 0x09, 0x56, 0x64, 0xee, 0xdf, 0xe9, 0x19,
0x27, 0x06, 0x5b, 0xae, 0xbc, 0x6a, 0x85, 0x24, 0xf6, 0x73, 0x3a, 0x76,
0xdf, 0x1e, 0x9d, 0x37, 0x59, 0x67, 0x68, 0x8d, 0x24, 0xde, 0x6a, 0xab,
0x59, 0xa6, 0xfa, 0xfb, 0x5a, 0x44, 0xe5, 0x04, 0x68, 0xb9, 0x2f, 0x96,
0x12, 0x10, 0x63, 0x02, 0xfd, 0x4c, 0xe8, 0x04, 0x17, 0x06, 0xf6, 0x27,
0x65, 0x0a, 0x2c, 0xd7, 0x31, 0xf0, 0x0b, 0x0e, 0xea, 0x24, 0xce, 0x3e,
0x06, 0x4c, 0xed, 0x52, 0x55, 0xd8, 0x09, 0x34, 0x1d, 0x30, 0xed, 0x3d,
0xd7, 0xe0, 0xcb, 0xf9, 0x92, 0x0b, 0xe1, 0x69, 0x38, 0xe5, 0x50, 0xa8,
0x4b, 0xb9, 0xf2, 0x19, 0x3d, 0x4a, 0x26, 0x2f, 0xea, 0xfe, 0x18, 0x1e,
0xbc, 0xf6, 0x22, 0x33, 0x3f, 0x27, 0xf7, 0x2b, 0x09, 0xff, 0x56, 0x37,
0x2b, 0xef, 0xf3, 0x29, 0x11, 0xdd, 0x13, 0x74, 0xcd, 0x08, 0x35, 0x59,
0xd5, 0x28, 0xef, 0x23, 0x25, 0x2d, 0x9e, 0x04, 0x5e, 0x60, 0x04, 0x43,
0xcc, 0x15, 0x0c, 0x37, 0x91, 0x44, 0x1d, 0x44, 0x2f, 0x1b, 0x62, 0xdd,
0x51, 0xac, 0x97, 0xf8, 0x48, 0x44, 0xe9, 0x77, 0x42, 0xda, 0x24, 0x73,
0xbd, 0x03, 0x75, 0xfb, 0xfa, 0x2f, 0xff, 0x35, 0x28, 0x25, 0xc1, 0x2b,
0x4f, 0xce, 0x4b, 0xf2, 0x1f, 0xd2, 0x38, 0x42, 0xce, 0x32, 0x2f, 0x30,
0xfe, 0x41, 0x8d, 0x67, 0x67, 0x49, 0x66, 0x1d, 0x5b, 0x58, 0x2e, 0x60,
0xdd, 0x24, 0x8d, 0xed, 0xc0, 0x23, 0xd9, 0x89, 0x2b, 0xe8, 0x08, 0xcb,
0x4b, 0x0a, 0xde, 0x1a, 0x15, 0x40, 0x33, 0x42, 0x6f, 0x32, 0xa7, 0xea,
0x01, 0x4c, 0x37, 0x47, 0x12, 0x53, 0x1c, 0x52, 0xdc, 0xdd, 0xe8, 0x45,
0x29, 0xa6, 0x54, 0x4b, 0x64, 0xe3, 0x12, 0x07, 0x0e, 0x11, 0xaf, 0x32,
0x16, 0x29, 0xa5, 0x2e, 0x6d, 0x25, 0x5f, 0x36, 0x01, 0x16, 0x06, 0x6b,
0xdd, 0x50, 0xd8, 0x0a, 0x23, 0x08, 0x3d, 0xab, 0x00, 0x2b, 0x24, 0xf2,
0x61, 0x0f, 0xed, 0x0d, 0xe5, 0x67, 0x18, 0x50, 0x08, 0x68, 0x4d, 0xfe,
0x4f, 0x34, 0x49, 0x57, 0xfc, 0x65, 0xff, 0x37, 0x1f, 0x03, 0x0b, 0x4e,
0x70, 0x1e, 0x0f, 0xfd, 0x44, 0x05, 0x59, 0x59, 0xcb, 0x1a, 0xa4, 0x40,
0x11, 0x50, 0xbb, 0x6d, 0x19, 0xae, 0xcb, 0x2a, 0x1b, 0xf9, 0x46, 0x4d,
0xd2, 0x12, 0xbc, 0x08, 0xde, 0x5f, 0x22, 0x4a, 0x0f, 0x2b, 0x16, 0x1a,
0x1d, 0x70, 0xe5, 0x25, 0xe7, 0x47, 0x07, 0x6f, 0x4e, 0xe4, 0x56, 0x27,
0xdf, 0x1d, 0x34, 0x09, 0x2c, 0x74, 0xf3, 0x39, 0x1d, 0x24, 0x56, 0x03,
0x51, 0x3b, 0x24, 0xc1, 0x04, 0x09, 0x39, 0xf5, 0x01, 0x44, 0xd5, 0x4c,
0x0d, 0x08, 0x15, 0xd0, 0x0f, 0x24, 0xc9, 0x11, 0xe0, 0x09, 0xe8, 0x37,
0xf5, 0xf6, 0x26, 0x1b, 0xcf, 0x49, 0xf9, 0x08, 0x14, 0xd9, 0x56, 0x26,
0x40, 0x9e, 0x1f, 0x1b, 0xd8, 0x57, 0xe7, 0x31, 0xe2, 0x03, 0x2c, 0x53,
0x60, 0x2c, 0xfd, 0x0e, 0x13, 0x5d, 0xdb, 0x24, 0x3a, 0xd4, 0xe8, 0x75,
0x4a, 0x9a, 0x15, 0x29, 0x5a, 0x08, 0x1e, 0x1e, 0x28, 0x23, 0xc0, 0x79,
0xe0, 0x1a, 0x2f, 0x06, 0x4b, 0xcd, 0xb1, 0x4c, 0x46, 0x15, 0xdf, 0x48,
0xda, 0x42, 0xf9, 0xe1, 0x29, 0x15, 0xe5, 0x5d, 0x1d, 0xc1, 0x73, 0x5d,
0x0a, 0x36, 0xec, 0x26, 0xac, 0x64, 0xff, 0x03, 0x1b, 0x54, 0xe4, 0xc7,
0x20, 0x29, 0x1a, 0x61, 0x0e, 0x5a, 0x11, 0xdc, 0x46, 0xf5, 0xf3, 0x35,
0x5f, 0x64, 0x08, 0xc0, 0x41, 0x3b, 0x30, 0xcf, 0x25, 0xfe, 0xd8, 0x55,
0x0c, 0x5a, 0xd7, 0x27, 0xba, 0x45, 0x3d, 0x6b, 0x05, 0xdd, 0x2d, 0x38,
0xfb, 0xdd, 0x40, 0xef, 0x62, 0x39, 0x1a, 0x97, 0x3d, 0xb7, 0x13, 0x1e,
0x2e, 0xe9, 0x1b, 0x09, 0xcd, 0x7b, 0xe7, 0x4e, 0x30, 0x51, 0x1e, 0x39,
0xa2, 0x3a, 0x45, 0x65, 0x40, 0x23, 0xdd, 0xfd, 0xf2, 0xb3, 0xbb, 0x72,
0x2e, 0x25, 0x1d, 0xbe, 0x74, 0x14, 0x52, 0xa0, 0x29, 0x0d, 0x51, 0x5e,
0xfa, 0x4b, 0x38, 0x4e, 0x4a, 0xfa, 0xf4, 0x28, 0x7a, 0x2d, 0x0d, 0x52,
0xde, 0xdf, 0x91, 0xdf, 0xbc, 0x5d, 0x34, 0x14, 0x1c, 0x15, 0x3a, 0x2c,
0x1a, 0x0a, 0x45, 0x32, 0x09, 0x73, 0x20, 0x0e, 0xfb, 0x3a, 0x06, 0x22,
0xa9, 0x11, 0x56, 0x06, 0x2a, 0x5b, 0xab, 0xb1, 0x42, 0xfb, 0x29, 0x0b,
0xeb, 0x50, 0x54, 0xf8, 0x4f, 0x27, 0x45, 0x14, 0x43, 0x40, 0xdb, 0x37,
0xfd, 0xf7, 0x02, 0x1e, 0x6c, 0xb6, 0x37, 0x32, 0xc0, 0x06, 0x55, 0x32,
0xab, 0xef, 0xb4, 0x04, 0xe4, 0x51, 0xdf, 0x20, 0x25, 0xd5, 0x0c, 0x34,
0x45, 0x2f, 0xd3, 0x28, 0x18, 0x5c, 0xf9, 0x1d, 0x58, 0x00, 0x33, 0x31,
0x0e, 0x36, 0x03, 0xd0, 0x1c, 0x29, 0xcf, 0x04, 0xa2, 0xed, 0x3b, 0x5b,
0xf9, 0x13, 0x10, 0xf8, 0x3f, 0x35, 0x41, 0xcd, 0x03, 0x26, 0x3f, 0x47,
0x30, 0x04, 0x04, 0x42, 0xaf, 0xc5, 0x35, 0x21, 0xf5, 0x5a, 0x14, 0x4c,
0xbf, 0xfa, 0xba, 0xf0, 0x0b, 0x5b, 0x1b, 0xab, 0x31, 0xb0, 0x28, 0xee,
0x22, 0x25, 0xe7, 0x0b, 0xe2, 0x43, 0x13, 0x1c, 0x53, 0x0f, 0xa5, 0x96,
0x37, 0x12, 0xcd, 0x33, 0x21, 0x39, 0xc1, 0x1d, 0x66, 0xd5, 0x38, 0xe3,
0x2d, 0xba, 0x3b, 0xc0, 0x54, 0x15, 0x30, 0x5b, 0x15, 0x4f, 0x37, 0x3b,
0x0a, 0xf9, 0xf7, 0xf6, 0x05, 0x0c, 0xaf, 0x34, 0xb0, 0xde, 0x11, 0x4d,
0xd2, 0x10, 0xad, 0x0e, 0x46, 0x0f, 0xeb, 0x25, 0x20, 0xd8, 0x35, 0xf6,
0x60, 0x8b, 0xeb, 0x22, 0x5e, 0x43, 0x1a, 0x1e, 0xba, 0xee, 0x0c, 0x62,
0x2e, 0xe3, 0x26, 0x27, 0x41, 0xed, 0xef, 0x05, 0x59, 0x3f, 0xcb, 0xec,
0x18, 0x13, 0x36, 0x14, 0xde, 0xd3, 0x23, 0x3b, 0x28, 0x11, 0xe3, 0x07,
0x0c, 0xc5, 0xa9, 0x54, 0xb2, 0xe4, 0x6e, 0xe0, 0x4b, 0x53, 0x69, 0x09,
0xda, 0x1e, 0x9d, 0x29, 0xe2, 0x10, 0x5b, 0x42, 0x38, 0xee, 0xea, 0x08,
0x2e, 0xd6, 0x11, 0x20, 0x42, 0x18, 0xe7, 0x26, 0x5f, 0xc2, 0xe5, 0x94,
0xf0, 0xd0, 0xeb, 0xed, 0x59, 0x0d, 0xf1, 0x0c, 0xcc, 0xe5, 0x1e, 0x55,
0x02, 0x88, 0x4c, 0xd4, 0x1e, 0x20, 0x51, 0x56, 0x07, 0x36, 0x27, 0x1a,
0x08, 0xfc, 0x5c, 0x3b, 0x92, 0x6b, 0x0e, 0xd5, 0xcc, 0x65, 0x1e, 0x4b,
0xb5, 0x44, 0x33, 0xe0, 0x5e, 0xf3, 0x26, 0x58, 0x41, 0x1e, 0x5d, 0xc6,
0x30, 0x76, 0x1e, 0x0a, 0xd6, 0x1f, 0x3f, 0x44, 0x4d, 0x44, 0x0b, 0xe6,
0x37, 0xc9, 0xed, 0xf6, 0x05, 0x23, 0xdc, 0x3b, 0x6c, 0xed, 0xa1, 0x21,
0x2a, 0xfe, 0x3c, 0x0d, 0x54, 0xe1, 0x24, 0x63, 0x0f, 0xe3, 0x36, 0x10,
0x24, 0x4d, 0x6e, 0xf2, 0xf4, 0xa9, 0xda, 0x20, 0x4e, 0xea, 0x30, 0x22,
0xbb, 0x27, 0xa1, 0x1c, 0x55, 0x1f, 0xd3, 0x24, 0xfd, 0x37, 0x5a, 0xd9,
0x1e, 0x14, 0xcd, 0x20, 0x14, 0x23, 0x01, 0xf5, 0xc4, 0xee, 0x01, 0x67,
0x5a, 0x24, 0xc4, 0x10, 0xff, 0x21, 0xe4, 0x25, 0x25, 0xef, 0x13, 0x7c,
0x45, 0x26, 0xe3, 0x25, 0x05, 0xcb, 0x54, 0x5c, 0xae, 0x43, 0x3a, 0x55,
0x15, 0x66, 0xa3, 0x63, 0x46, 0x15, 0x96, 0x1a, 0x7c, 0x5b, 0xf9, 0x56,
0xe1, 0xe8, 0x49, 0x35, 0x40, 0x70, 0x32, 0xed, 0xfa, 0xe0, 0x3d, 0xcb,
0x2a, 0xe6, 0xb7, 0x14, 0x18, 0x4f, 0x2e, 0x32, 0x84, 0x5b, 0x36, 0x4b,
0x34, 0x22, 0xd4, 0x04, 0x1c, 0x2c, 0xf1, 0xc8, 0xc2, 0x2f, 0x90, 0x60,
0x34, 0xb1, 0xfb, 0x2e, 0x57, 0x9c, 0x29, 0x46, 0x9a, 0x31, 0x4a, 0x3e,
0x1a, 0x25, 0xab, 0x05, 0xee, 0xe3, 0x8c, 0x04, 0x69, 0x3d, 0x0f, 0x7f,
0xe4, 0x3d, 0x42, 0x08, 0x1a, 0x20, 0x1d, 0x8c, 0x3d, 0x14, 0x18, 0x9c,
0x43, 0x08, 0xbe, 0x1f, 0x12, 0x5e, 0xcf, 0x5e, 0xf3, 0x59, 0x65, 0xba,
0x13, 0x12, 0x49, 0x76, 0x05, 0x60, 0x0d, 0x21, 0x4c, 0xfc, 0x68, 0x4d,
0x17, 0xc6, 0x45, 0x44, 0x14, 0xc9, 0x50, 0x32, 0xe1, 0xfb, 0x3e, 0x6e,
0x0d, 0x43, 0xf9, 0xee, 0xc7, 0xc4, 0x05, 0x45, 0xe0, 0xda, 0x01, 0x69,
0xf3, 0x58, 0x98, 0xea, 0xe5, 0x29, 0x78, 0x33, 0x03, 0x16, 0x11, 0xc9,
0x54, 0x4c, 0xab, 0x1b, 0xe9, 0x46, 0x0a, 0x60, 0x10, 0x30, 0x11, 0xd3,
0x42, 0x0e, 0x7d, 0x11, 0x13, 0x44, 0xf2, 0x24, 0x93, 0xd3, 0x8d, 0x14,
0x6e, 0xac, 0x2c, 0x3c, 0x55, 0xe9, 0x54, 0x6c, 0xbc, 0xf9, 0xa5, 0x50,
0x3e, 0x4d, 0xea, 0x14, 0xf1, 0xb5, 0x14, 0x1a, 0x4f, 0x01, 0xea, 0x3f,
0xee, 0x19, 0xf9, 0x36, 0x93, 0x2a, 0x69, 0xe6, 0x3f, 0x0d, 0x25, 0xda,
0x10, 0xb9, 0x14, 0x30, 0xde, 0x44, 0x1b, 0x3f, 0x6a, 0x6e, 0x40, 0x5b,
0x0e, 0x17, 0x4d, 0x5a, 0x1d, 0x37, 0xe9, 0x4d, 0xaf, 0x3b, 0x0f, 0x5a,
0x70, 0x02, 0x21, 0xff, 0x79, 0xd0, 0x4b, 0x07, 0xc5, 0x12, 0xc8, 0x5d,
0xfb, 0x11, 0x3e, 0x3d, 0x17, 0x7d, 0x93, 0x54, 0x41, 0x14, 0x44, 0x47,
0xee, 0x26, 0x8c, 0x2d, 0x45, 0x12, 0xfa, 0xbf, 0x39, 0xc1, 0x00, 0x0f,
0x4a, 0x3f, 0xbd, 0x39, 0xbb, 0x56, 0x0e, 0x01, 0xb8, 0xe5, 0xe7, 0xe3,
0x3d, 0x3f, 0x56, 0x46, 0x29, 0x4d, 0xf0, 0x22, 0xec, 0x21, 0xa4, 0x4b,
0x5e, 0x91, 0x16, 0xef, 0x13, 0x17, 0x17, 0x60, 0x1e, 0x3d, 0xc0, 0x70,
0xdf, 0x28, 0x1e, 0xcb, 0xd4, 0x03, 0x27, 0x43, 0xe2, 0xde, 0x22, 0x70,
0xdd, 0x02, 0x16, 0x36, 0x6d, 0x36, 0xe4, 0x3a, 0x3d, 0x2d, 0x7f, 0x22,
0x23, 0x8e, 0x45, 0x0d, 0x01, 0x58, 0x25, 0x5d, 0x87, 0x25, 0x45, 0x68,
0x9a, 0x43, 0x30, 0xf6, 0x1d, 0x4c, 0xe6, 0x31, 0xf1, 0xee, 0x97, 0x7f,
0x5c, 0xb7, 0x00, 0x4b, 0x41, 0x44, 0x42, 0x60, 0xc4, 0x0d, 0xd9, 0x74,
0xeb, 0x55, 0x2d, 0x25, 0x75, 0xb8, 0xcc, 0x24, 0x06, 0x47, 0x37, 0x51,
0xe2, 0x31, 0x99, 0xcd, 0x17, 0x2d, 0x23, 0x8a, 0x33, 0xdc, 0x4a, 0x2b,
0x52, 0x35, 0xff, 0x26, 0x52, 0x56, 0x20, 0x11, 0x2a, 0xfb, 0xe7, 0x43,
0x01, 0x52, 0xc0, 0xfc, 0x04, 0x78, 0xe8, 0x0c, 0x42, 0xef, 0xeb, 0x0f,
0x4d, 0xee, 0x1a, 0x20, 0x60, 0x53, 0x32, 0x54, 0x23, 0x19, 0xfc, 0x56,
0x33, 0x3f, 0xd1, 0x5e, 0x39, 0x71, 0xf2, 0x4e, 0x71, 0x33, 0x13, 0x6a,
0xd9, 0x41, 0x0e, 0xc9, 0x5b, 0x34, 0xcd, 0x46, 0x17, 0xe1, 0x38, 0x4f,
0x07, 0x29, 0x25, 0x30, 0xb6, 0x52, 0x2d, 0x4a, 0xf9, 0xf7, 0xb6, 0x50,
0xc1, 0x1c, 0x48, 0xee, 0x16, 0x3c, 0xc6, 0x03, 0x1c, 0x0f, 0xb4, 0x58,
0xb3, 0xdb, 0x39, 0xc3, 0x13, 0x07, 0x0c, 0x64, 0xd3, 0x02, 0xf2, 0x74,
0xf9, 0x27, 0xce, 0xed, 0x19, 0x13, 0xe2, 0x24, 0xec, 0x2c, 0x29, 0x4f,
0xbb, 0xf9, 0x11, 0xac, 0xc7, 0x00, 0x49, 0xb2, 0x42, 0x2e, 0x24, 0x15,
0x0e, 0x60, 0x3a, 0x3b, 0xac, 0x61, 0x12, 0x1c, 0x2a, 0x60, 0xeb, 0x16,
0x00, 0x19, 0xdf, 0xdf, 0x06, 0x48, 0xb9, 0xcd, 0x2c, 0xe3, 0x68, 0x5a,
0xe5, 0x69, 0x38, 0x08, 0x67, 0x23, 0x30, 0x0b, 0x3f, 0x48, 0x41, 0x62,
0x06, 0x10, 0x38, 0x40, 0xdd, 0xd6, 0xf5, 0x21, 0x61, 0x4b, 0x26, 0x67,
0xb5, 0xb8, 0x5c, 0xd5, 0x07, 0x4b, 0x41, 0xea, 0x35, 0xea, 0x48, 0xef,
0x1d, 0xd2, 0x2d, 0x32, 0xed, 0x40, 0x34, 0x3b, 0x1c, 0xd9, 0x6a, 0x16,
0xe0, 0x33, 0x58, 0x4f, 0x55, 0x4d, 0xbd, 0x1a, 0xd5, 0xb3, 0xb1, 0xed,
0x4c, 0xf0, 0x38, 0x2b, 0x5f, 0x0c, 0x45, 0xa8, 0x17, 0x45, 0x62, 0x45,
0x4d, 0xf5, 0x60, 0xb2, 0xbb, 0x2a, 0x5a, 0x2c, 0xe7, 0x05, 0x1f, 0x0a,
0xc0, 0x05, 0x21, 0xd2, 0xf7, 0xfe, 0xeb, 0x07, 0x3f, 0xe1, 0x41, 0xfa,
0x48, 0xde, 0xf4, 0x34, 0x58, 0x24, 0x29, 0xec, 0xf0, 0xd6, 0xa7, 0xfc,
0x20, 0x26, 0x0e, 0x17, 0x4d, 0x2b, 0xbb, 0xdc, 0x5b, 0xf1, 0x85, 0x3d,
0xe9, 0x1a, 0x19, 0xed, 0x6a, 0x12, 0x18, 0xe0, 0xdc, 0x1a, 0x4a, 0x34,
0x2f, 0x22, 0x52, 0xc1, 0x57, 0xf5, 0x04, 0x3d, 0x09, 0x43, 0x3c, 0x14,
0x93, 0xde, 0x47, 0x11, 0xe9, 0x3a, 0x1e, 0x10, 0x59, 0xe1, 0x2b, 0x0a,
0x10, 0x3c, 0xeb, 0x3e, 0x68, 0x54, 0xfe, 0x33, 0xa8, 0xb7, 0x57, 0x9d,
0x8e, 0xb8, 0xbd, 0x64, 0x37, 0x21, 0xeb, 0x04, 0x2e, 0x1b, 0xa3, 0x0a,
0x10, 0xd9, 0x53, 0x0e, 0x1a, 0xe7, 0x1a, 0x9d, 0x23, 0xfc, 0x5e, 0x17,
0x2a, 0x14, 0x2c, 0x60, 0xa3, 0x65, 0x89, 0xdf, 0x1e, 0x59, 0x1c, 0x40,
0xe9, 0x16, 0x8e, 0x1d, 0x9a, 0x1c, 0x6a, 0xed, 0x15, 0x1b, 0x36, 0x18,
0x1f, 0xc5, 0xee, 0x0c, 0x4d, 0xf9, 0xe1, 0xd1, 0x57, 0x19, 0xf3, 0xc6,
0xf6, 0xdd, 0xe2, 0x37, 0x31, 0x4f, 0xe9, 0x31, 0x8e, 0x29, 0x13, 0x56,
0x1a, 0xab, 0x48, 0xe2, 0x25, 0xf2, 0x3f, 0xbf, 0x53, 0x1e, 0x20, 0xf3,
0xe8, 0xf7, 0x71, 0x09, 0xe0, 0xa9, 0xac, 0xe7, 0x40, 0x37, 0x26, 0x4a,
0xdb, 0x22, 0xde, 0x17, 0xf0, 0x40, 0xd3, 0x98, 0x01, 0xfd, 0x31, 0xec,
0x58, 0xca, 0x2c, 0x21, 0xdc, 0x29, 0x11, 0xec, 0x1c, 0xd0, 0xce, 0x1c,
0x72, 0xe2, 0x6d, 0x59, 0x2d, 0x10, 0xd5, 0x0a, 0xe6, 0x12, 0xec, 0x46,
0x24, 0x3f, 0xfb, 0xd2, 0x3b, 0xfc, 0x2d, 0x1e, 0xc5, 0x06, 0xd9, 0x0b,
0x37, 0x36, 0x85, 0x54, 0xd8, 0xf1, 0x0a, 0x27, 0xea, 0x6a, 0x3e, 0x64,
0xe4, 0x00, 0xeb, 0x40, 0xfe, 0x24, 0x38, 0xcd, 0x21, 0x45, 0x61, 0xc8,
0x40, 0x4d, 0xf9, 0x02, 0xf7, 0x4b, 0x14, 0x2b, 0xba, 0x32, 0xa5, 0x94,
0x99, 0x0d, 0xef, 0xe7, 0xff, 0x57, 0xd0, 0x4f, 0x08, 0xff, 0x3d, 0x3f,
0xfa, 0xb8, 0xf0, 0x26, 0x38, 0xec, 0x3f, 0xce, 0xcd, 0x05, 0x44, 0x31,
0xcc, 0x20, 0xa5, 0x5e, 0x46, 0x18, 0xbb, 0x14, 0x3a, 0x62, 0xff, 0x64,
0xf4, 0x03, 0xe4, 0xec, 0xda, 0x64, 0xde, 0x44, 0x32, 0xfa, 0x30, 0xbe,
0x54, 0xf1, 0xac, 0x19, 0x69, 0x53, 0xd4, 0x71, 0x3f, 0x2e, 0x39, 0x0f,
0x07, 0x1f, 0x57, 0xfd, 0x1a, 0x4d, 0x05, 0xe4, 0x1f, 0x00, 0xdb, 0x3d,
0xbd, 0xc2, 0xf9, 0xf4, 0x0d, 0xf5, 0x39, 0xb2, 0xb7, 0x01, 0xf7, 0x53,
0x16, 0x1d, 0xb9, 0x3e, 0x3e, 0x5b, 0xd0, 0x04, 0xf1, 0xf2, 0x26, 0x46,
0xe4, 0x1e, 0x3f, 0x4e, 0xf9, 0x64, 0xea, 0x29, 0x3d, 0xd6, 0x74, 0xbf,
0x28, 0x27, 0xd0, 0x0f, 0x3e, 0x63, 0xf0, 0x28, 0x87, 0xe4, 0x59, 0xc6,
0x19, 0x0a, 0x63, 0x11, 0x1e, 0x54, 0xf7, 0x33, 0x33, 0x2d, 0x71, 0x6b,
0xd7, 0x9e, 0x38, 0x2b, 0x64, 0xca, 0x19, 0xdb, 0xb3, 0x18, 0x33, 0x70,
0x2a, 0x10, 0xdf, 0x53, 0xc4, 0x20, 0xc1, 0x23, 0xfe, 0x6b, 0x12, 0x41,
0xe4, 0x4d, 0xa1, 0x39, 0x6c, 0x57, 0x6b, 0xd5, 0x24, 0x32, 0x43, 0xa8,
0x19, 0x65, 0xfc, 0x34, 0x04, 0x63, 0xf5, 0x28, 0x8c, 0xd0, 0xb7, 0xb1,
0xfd, 0x3c, 0xc7, 0x52, 0x3b, 0x2c, 0xd9, 0x43, 0x4f, 0xe4, 0xef, 0xf9,
0xbc, 0x50, 0x07, 0x55, 0x1f, 0xc9, 0x42, 0xf9, 0xf4, 0x21, 0xcb, 0x38,
0x43, 0x1b, 0x8c, 0x13, 0x3c, 0xc1, 0x51, 0x29, 0x43, 0x4e, 0x23, 0x4f,
0xd8, 0x59, 0x3e, 0x03, 0xa3, 0x10, 0x1e, 0x27, 0x15, 0x14, 0x48, 0x04,
0x56, 0x5a, 0xf8, 0x17, 0x17, 0x43, 0x1c, 0x76, 0xf6, 0xfa, 0xba, 0xd8,
0x58, 0x26, 0xf2, 0xdc, 0xf6, 0x3d, 0xd4, 0xfe, 0xf1, 0x2b, 0x34, 0x4f,
0x1f, 0x11, 0x1a, 0x98, 0x07, 0xe9, 0x08, 0x0e, 0xdd, 0x28, 0xa6, 0x6a,
0x18, 0x46, 0x02, 0xcd, 0x76, 0x28, 0x0d, 0x31, 0x17, 0xef, 0x32, 0x3b,
0xc1, 0xc3, 0xde, 0xfb, 0xe8, 0x62, 0xc6, 0xff, 0x1c, 0xff, 0x0f, 0xe1,
0x3d, 0x10, 0xb4, 0x3e, 0x41, 0x54, 0x13, 0x18, 0x12, 0x32, 0x02, 0xcf,
0x1a, 0x10, 0x35, 0x51, 0x1e, 0x6e, 0xf2, 0x22, 0x2c, 0x3d, 0x92, 0x51,
0x3b, 0x8c, 0x38, 0xde, 0x62, 0x28, 0x42, 0xb3, 0x10, 0x37, 0x31, 0x53,
0x0a, 0x09, 0xe5, 0x6e, 0x3d, 0xbe, 0x4a, 0x3d, 0x60, 0x07, 0x17, 0x69,
0xe2, 0x09, 0xe8, 0x2f, 0xf8, 0x72, 0x75, 0x4b, 0x20, 0x44, 0x33, 0x5c,
0x17, 0x31, 0x10, 0x2b, 0xfb, 0x78, 0xfe, 0x37, 0x4f, 0x43, 0xcf, 0xe7,
0x57, 0x35, 0x50, 0x47, 0x1a, 0x62, 0xef, 0xe9, 0xbc, 0x16, 0xbd, 0x43,
0x02, 0xb8, 0x2b, 0x0a, 0x65, 0x19, 0x31, 0xd1, 0xf3, 0x19, 0xde, 0x63,
0xec, 0x69, 0xb9, 0x69, 0xff, 0x12, 0xf2, 0x4c, 0x47, 0x2f, 0x03, 0x4d,
0xf9, 0x11, 0xe7, 0x1d, 0xee, 0x46, 0x76, 0xd5, 0x46, 0xbc, 0x7b, 0x2c,
0x47, 0x95, 0xc9, 0x32, 0xbd, 0x5d, 0x37, 0x5f, 0x59, 0xbf, 0x5b, 0x27,
0x3c, 0x5c, 0x29, 0xf6, 0x0b, 0x4b, 0x08, 0x4e, 0x56, 0xea, 0x63, 0x13,
0x66, 0xe3, 0x08, 0xa7, 0x3e, 0x17, 0x53, 0x5c, 0xbb, 0x44, 0x1a, 0x41,
0xf9, 0x04, 0x69, 0xd8, 0x4c, 0x08, 0x0f, 0x30, 0x1d, 0x5a, 0xfe, 0x69,
0xf1, 0x19, 0xbf, 0xf7, 0xda, 0x76, 0xef, 0x53, 0x06, 0x87, 0x69, 0x15,
0x2c, 0x0a, 0xe0, 0x03, 0xbe, 0x54, 0xe3, 0x03, 0x39, 0xf2, 0x3a, 0x2f,
0xa1, 0x47, 0x53, 0x47, 0x43, 0x50, 0xc6, 0xfb, 0x11, 0xd5, 0x9e, 0x09,
0xc7, 0x30, 0x40, 0x29, 0x71, 0x2e, 0x08, 0x2e, 0x27, 0x08, 0xb6, 0x52,
0xf1, 0xfa, 0x5e, 0x2b, 0x50, 0x96, 0xbc, 0x24, 0x77, 0x06, 0x08, 0x5a,
0xdb, 0xf6, 0x2a, 0xfa, 0x35, 0x2b, 0x06, 0x2c, 0x0e, 0xe1, 0x5c, 0x50,
0x31, 0x14, 0x0c, 0x43, 0x2e, 0x6e, 0x0e, 0x59, 0xfe, 0xb3, 0x79, 0x06,
0x88, 0x3f, 0x46, 0xe9, 0x4d, 0x27, 0xc5, 0x18, 0xdd, 0x0d, 0x5b, 0x4d,
0x23, 0xe9, 0x38, 0x34, 0x66, 0x07, 0x1d, 0xf9, 0x44, 0x47, 0xda, 0x6a,
0x55, 0x4a, 0x68, 0x29, 0x1b, 0xa9, 0xe0, 0xfc, 0x04, 0xe8, 0x28, 0x40,
0xa7, 0xd5, 0x5c, 0x0e, 0xbd, 0x58, 0x2e, 0x0f, 0x2d, 0x35, 0x4a, 0x3a,
0x56, 0x4e, 0x34, 0x4e, 0xdb, 0x6a, 0x32, 0x1a, 0x3d, 0xe6, 0xff, 0x50,
0xbe, 0x34, 0x65, 0x36, 0x42, 0x32, 0xd3, 0xd1, 0xb0, 0x9f, 0x52, 0x34,
0x46, 0x99, 0x26, 0xf9, 0x6b, 0x33, 0x39, 0x22, 0x0d, 0x2c, 0xc1, 0x5d,
0x22, 0xf5, 0xcf, 0xde, 0xf0, 0x9b, 0xfa, 0x0f, 0x38, 0xcc, 0x2a, 0x28,
0xb6, 0xdc, 0x92, 0x0d, 0x85, 0xe1, 0x39, 0x95, 0x50, 0x94, 0x54, 0x2e,
0x05, 0x38, 0x12, 0x3d, 0xfc, 0x2b, 0x37, 0x14, 0xa2, 0x0c, 0x9f, 0xa6,
0x31, 0x2e, 0xcb, 0x3c, 0x42, 0x3d, 0xb8, 0xf0, 0xac, 0xdf, 0x10, 0xf0,
0x5b, 0xbc, 0x12, 0xd2, 0x70, 0x2c, 0x50, 0xcd, 0x39, 0x1f, 0x7c, 0x4a,
0x0d, 0xe7, 0x30, 0x09, 0x21, 0xea, 0xbd, 0x23, 0xe8, 0x24, 0x22, 0x09,
0xc3, 0xf0, 0x4d, 0x23, 0xb1, 0xdd, 0x4f, 0xb3, 0x16, 0xe4, 0xf7, 0x13,
0x1e, 0xdf, 0x1b, 0x37, 0x3c, 0x3a, 0x1f, 0x41, 0x90, 0x17, 0x2c, 0xa2,
0x5f, 0xaf, 0xf1, 0xf3, 0x27, 0x20, 0xe1, 0xff, 0x46, 0x44, 0xc5, 0x21,
0xc8, 0x4b, 0x32, 0x0e, 0x11, 0xef, 0x50, 0xde, 0xe9, 0x02, 0x33, 0x15,
0x38, 0x47, 0x54, 0xb3, 0x68, 0xb8, 0x1e, 0xd1, 0xbb, 0x2d, 0x4c, 0x42,
0xef, 0x34, 0xec, 0x15, 0x42, 0xe9, 0x58, 0x1b, 0xfa, 0x36, 0xf2, 0x05,
0x46, 0x50, 0x2a, 0x12, 0x0d, 0xfb, 0x33, 0x1f, 0x50, 0x3f, 0x0d, 0x62,
0x5d, 0xf3, 0xef, 0xf2, 0x2a, 0x4f, 0xbd, 0x2f, 0xc8, 0x3d, 0x53, 0xdf,
0x0a, 0x30, 0x3e, 0x02, 0x2a, 0xef, 0x23, 0xc7, 0x16, 0x0d, 0x6e, 0x23,
0xec, 0x03, 0xea, 0x01, 0x1b, 0xc6, 0x60, 0xcf, 0x44, 0x59, 0x51, 0x0a,
0xee, 0x22, 0x5d, 0xff, 0xce, 0x13, 0x4f, 0x3c, 0x32, 0xc5, 0x55, 0xcd,
0x4a, 0xdf, 0x15, 0x49, 0x35, 0x19, 0x2b, 0xe4, 0xb3, 0xee, 0x05, 0x34,
0x8a, 0xd3, 0x36, 0xd0, 0x25, 0x23, 0xc9, 0x39, 0x62, 0xeb, 0x35, 0x35,
0xcc, 0x22, 0x2b, 0x13, 0x0f, 0x19, 0x27, 0x17, 0xf4, 0x25, 0x21, 0x23,
0x12, 0x0a, 0x17, 0x05, 0xb7, 0x89, 0xab, 0xed, 0x58, 0xfc, 0x33, 0x31,
0xdb, 0x3f, 0x63, 0x09, 0xac, 0x78, 0xda, 0x82, 0x00, 0x4c, 0x62, 0xda,
0x0b, 0xb1, 0xdd, 0x1b, 0x5b, 0x36, 0xde, 0x55, 0xa3, 0x4c, 0x98, 0xaf,
0xb5, 0x0e, 0x04, 0x52, 0x06, 0x31, 0xca, 0x27, 0xa9, 0x0c, 0xc4, 0x20,
0x48, 0x1b, 0xf1, 0xd5, 0x20, 0xce, 0x39, 0x05, 0xcf, 0xf4, 0x37, 0x18,
0xf2, 0x4b, 0x29, 0xd6, 0xd8, 0x1e, 0x11, 0x23, 0x6f, 0x3e, 0x28, 0x65,
0xdb, 0x08, 0x62, 0x1d, 0x6e, 0x6b, 0x5d, 0x49, 0x00, 0xd6, 0x4c, 0xe5,
0x0c, 0x4d, 0xae, 0x3d, 0x54, 0x45, 0x0c, 0x27, 0x4d, 0x48, 0xde, 0x63,
0x69, 0x1b, 0xcb, 0x38, 0x0f, 0x34, 0xbd, 0xe4, 0x06, 0x52, 0x51, 0x0a,
0xd2, 0xd7, 0x0f, 0xfa, 0x3e, 0xca, 0x34, 0x12, 0xb0, 0x23, 0xe1, 0x2c,
0x09, 0x46, 0x2e, 0x29, 0x11, 0x6d, 0x2b, 0x22, 0xfd, 0xfb, 0x04, 0x51,
0xfd, 0x00, 0xe1, 0x3d, 0xde, 0x09, 0x7b, 0xec, 0x2a, 0x0f, 0x2b, 0xf0,
0xfc, 0x43, 0x06, 0x16, 0xc3, 0x64, 0x3d, 0x4d, 0x0d, 0xf5, 0x4e, 0xb6,
0x10, 0xfc, 0xf1, 0x6c, 0x33, 0x39, 0xd4, 0x18, 0x3d, 0x44, 0xc0, 0x37,
0x37, 0xa8, 0x04, 0x4a, 0x3a, 0xc3, 0x08, 0xbf, 0xd2, 0x29, 0xdb, 0x4d,
0xe7, 0x27, 0xd6, 0xc0, 0x35, 0xff, 0xf4, 0x15, 0xf9, 0xdc, 0x25, 0x6f,
0xf6, 0x42, 0x1d, 0x21, 0xee, 0x1a, 0x54, 0xdb, 0x44, 0x01, 0x75, 0xf1,
0x26, 0xd0, 0x05, 0x12, 0x11, 0x6e, 0xef, 0x78, 0x81, 0xe4, 0x63, 0x0d,
0x03, 0x1e, 0x7e, 0x60, 0x17, 0x3b, 0xc6, 0x17, 0xc7, 0xeb, 0xac, 0x3c,
0x02, 0x31, 0x16, 0x14, 0x4a, 0xb9, 0x44, 0x43, 0xf6, 0x1f, 0x46, 0x6e,
0x18, 0x61, 0x95, 0xf0, 0xd8, 0xb7, 0xde, 0x0c, 0x3a, 0x67, 0x22, 0x49,
0xd8, 0x07, 0xcb, 0x08, 0x07, 0x72, 0xe6, 0xc2, 0x30, 0xbc, 0x47, 0xdb,
0x03, 0xe0, 0xe6, 0x10, 0xe0, 0x4a, 0x0d, 0x4d, 0x22, 0x66, 0x7a, 0xae,
0x37, 0x5d, 0xd9, 0xfb, 0x33, 0x52, 0xfa, 0x52, 0xf5, 0xeb, 0x3a, 0x60,
0xe3, 0xc7, 0x0b, 0xd0, 0x55, 0x17, 0x1a, 0x9a, 0xf4, 0xfb, 0xb6, 0x73,
0x23, 0x6f, 0x97, 0xe5, 0x55, 0xd3, 0xcc, 0x59, 0x33, 0xef, 0xef, 0x33,
0xdc, 0xe1, 0xcf, 0xe5, 0x64, 0x53, 0x72, 0x94, 0x35, 0xc7, 0x3b, 0x02,
0x50, 0x2f, 0xad, 0x1d, 0xe4, 0x60, 0xef, 0x72, 0x32, 0x60, 0x34, 0x22,
0xa0, 0x60, 0x74, 0x12, 0x16, 0x66, 0xcc, 0xd1, 0x25, 0xfc, 0xe0, 0x54,
0x27, 0xed, 0x43, 0xfb, 0x4a, 0x12, 0x27, 0xa2, 0xca, 0x2a, 0x53, 0x42,
0x18, 0x35, 0x8d, 0xf9, 0x0d, 0x40, 0xed, 0x3d, 0x67, 0xff, 0x2f, 0x5f,
0xf7, 0xe9, 0xbf, 0x14, 0x24, 0x3f, 0xff, 0x36, 0x1d, 0x18, 0x2b, 0x35,
0x21, 0x1c, 0xd8, 0x07, 0x20, 0x4c, 0xeb, 0x20, 0x9a, 0x46, 0xad, 0x3a,
0x1d, 0x1e, 0x09, 0xe4, 0x2d, 0x35, 0x09, 0x13, 0xde, 0xf4, 0xb6, 0x68,
0x15, 0x18, 0x12, 0x1c, 0x0c, 0x35, 0x46, 0xb7, 0xd2, 0x18, 0x10, 0x4a,
0x0d, 0x31, 0xc0, 0x4f, 0x05, 0x62, 0xfc, 0x2c, 0xee, 0x17, 0x08, 0x53,
0xd2, 0xf1, 0xd3, 0xed, 0xc7, 0x7c, 0x17, 0x6c, 0x10, 0xf8, 0x0f, 0x5a,
0x43, 0xa2, 0xc7, 0x0d, 0x2a, 0x6b, 0xe8, 0xfc, 0x17, 0x37, 0xe1, 0x40,
0x1b, 0x48, 0x70, 0x3f, 0x22, 0x52, 0x04, 0xfe, 0xa7, 0xff, 0xd5, 0x5f,
0xe2, 0x8b, 0x4f, 0xa0, 0x7e, 0x17, 0x46, 0x99, 0xc2, 0x45, 0xda, 0x59,
0x0b, 0x17, 0x3c, 0xfa, 0x2a, 0x90, 0xa3, 0x2c, 0xba, 0x08, 0x30, 0x30,
0xed, 0xd8, 0xbf, 0x27, 0x51, 0x71, 0x43, 0x31, 0x1a, 0xe0, 0x5e, 0x1e,
0x4e, 0x21, 0x21, 0x1a, 0x4f, 0x6b, 0x11, 0x11, 0xb8, 0xe3, 0x40, 0x08,
0x24, 0x3a, 0x56, 0x70, 0x57, 0x32, 0xd4, 0x09, 0xfe, 0xe0, 0xd9, 0x40,
0x41, 0x0a, 0x51, 0xc6, 0x7e, 0x4b, 0x19, 0x4b, 0x2e, 0x1e, 0xcc, 0x44,
0x0c, 0x5a, 0x35, 0xb6, 0xdb, 0x95, 0x62, 0x54, 0xe7, 0xf9, 0x22, 0x4f,
0xe2, 0x10, 0x5e, 0x16, 0x61, 0xfd, 0x69, 0x95, 0x44, 0x34, 0x35, 0x10,
0x55, 0xed, 0x30, 0x32, 0x46, 0x40, 0x30, 0xfd, 0x01, 0x26, 0xb4, 0x7c,
0xaf, 0x2c, 0xf9, 0xea, 0xfd, 0x30, 0xab, 0xf2, 0xcf, 0xd9, 0xc4, 0x1e,
0x53, 0x41, 0x37, 0x31, 0x24, 0xfd, 0x50, 0xf1, 0x44, 0x43, 0xce, 0x49,
0x13, 0xfc, 0x95, 0xc1, 0x4b, 0x78, 0xa4, 0x36, 0x05, 0x48, 0x13, 0x46,
0xaf, 0xa0, 0x91, 0xed, 0x07, 0x69, 0x43, 0x27, 0x46, 0xfb, 0x76, 0x11,
0x1a, 0x5e, 0x26, 0x29, 0xdc, 0x4f, 0x62, 0x4c, 0x50, 0x31, 0xc9, 0x94,
0x36, 0x26, 0x55, 0x52, 0x4c, 0x37, 0xc6, 0xe9, 0x2b, 0xfc, 0x00, 0x12,
0xf8, 0xec, 0x29, 0xf1, 0x30, 0x1f, 0x38, 0xb9, 0xff, 0x26, 0x44, 0x6b,
0x2a, 0x0d, 0xbe, 0x4a, 0x68, 0x74, 0x6b, 0x1d, 0xf9, 0x61, 0x00, 0x0e,
0xd6, 0xd0, 0xa8, 0xe2, 0x51, 0x35, 0xb6, 0x29, 0x31, 0xb9, 0x1e, 0xfd,
0x56, 0x11, 0x25, 0x28, 0x71, 0x35, 0xfc, 0x54, 0xb8, 0x2f, 0xc0, 0xb3,
0xea, 0x08, 0x23, 0xe4, 0x23, 0x5c, 0xbe, 0xd4, 0xbb, 0xdc, 0xcd, 0x2f,
0xbb, 0xa3, 0x5c, 0x06, 0x4d, 0xf6, 0x50, 0x97, 0x27, 0x1d, 0x21, 0x32,
0x4a, 0x3f, 0x2c, 0x11, 0x1a, 0x10, 0xb8, 0xee, 0xbc, 0x1b, 0x30, 0x1c,
0xaa, 0xad, 0xca, 0xc5, 0x73, 0xcf, 0x3e, 0xa3, 0x4d, 0x1b, 0x4f, 0x30,
0x61, 0xfa, 0x08, 0x14, 0x30, 0x2f, 0x2f, 0xf2, 0xd8, 0x51, 0x55, 0x2b,
0xb1, 0xa1, 0xb4, 0xe5, 0x12, 0x1a, 0xe8, 0x19, 0x93, 0x1e, 0x6c, 0x2f,
0x30, 0xce, 0x4d, 0x20, 0x2a, 0xfa, 0x31, 0x56, 0x1a, 0x02, 0x1b, 0xf9,
0x16, 0xd9, 0xec, 0xcf, 0xcd, 0xf4, 0xda, 0xc4, 0x60, 0x21, 0x4c, 0x43,
0xf7, 0x0d, 0xb6, 0x40, 0xeb, 0xf5, 0xc9, 0xdd, 0x32, 0xde, 0x1e, 0x17,
0x09, 0x8c, 0x1f, 0x1a, 0xdd, 0x1a, 0x40, 0xe0, 0x33, 0xbb, 0xd2, 0x77,
0xff, 0xbd, 0xc4, 0x53, 0x48, 0xff, 0xe1, 0x0e, 0x11, 0x16, 0x33, 0x0c,
0x43, 0xc3, 0x0d, 0x26, 0xf1, 0xf8, 0x4a, 0xf3, 0x01, 0xfa, 0x30, 0xff,
0x19, 0x17, 0x03, 0x55, 0x32, 0x0c, 0x60, 0xbb, 0xd7, 0x4e, 0x4f, 0x17,
0xe3, 0x22, 0x2f, 0x31, 0xcc, 0x41, 0x0f, 0xcd, 0x05, 0xd7, 0xee, 0xe9,
0x1f, 0xe0, 0x23, 0x3d, 0xb0, 0x02, 0xf0, 0xfa, 0xea, 0x3a, 0x17, 0x50,
0xac, 0xd0, 0xcb, 0x0b, 0x22, 0x14, 0xd4, 0x2a, 0x47, 0xdf, 0x98, 0x42,
0x63, 0xb9, 0x1f, 0xba, 0x66, 0x09, 0x41, 0xd7, 0x29, 0x44, 0x28, 0x06,
0xea, 0x55, 0xe8, 0x44, 0xaa, 0x0a, 0x5b, 0x03, 0xb7, 0x52, 0x1f, 0x65,
0xd8, 0x0c, 0xfe, 0x31, 0xce, 0x14, 0x2c, 0xb8, 0xfb, 0xe5, 0x26, 0xd6,
0x28, 0x69, 0xea, 0x01, 0x14, 0x43, 0x08, 0x5a, 0xeb, 0xb6, 0xf2, 0x08,
0x8f, 0x17, 0x54, 0x20, 0x35, 0x42, 0x0d, 0x46, 0x8f, 0x45, 0xd9, 0x16,
0xc7, 0x6a, 0x24, 0x2b, 0x1a, 0xfc, 0x31, 0xa8, 0xbe, 0xf9, 0x39, 0x2e,
0x2d, 0x65, 0x2a, 0x0f, 0xf7, 0x27, 0xe3, 0x2a, 0x27, 0xdb, 0x04, 0x5f,
0xf3, 0xfe, 0x4d, 0x1c, 0x36, 0x2d, 0x50, 0xa0, 0xf5, 0xfc, 0x65, 0xe1,
0x05, 0xaf, 0xd0, 0xf5, 0x34, 0x56, 0x18, 0x03, 0x95, 0x1e, 0x0f, 0x68,
0x12, 0x2b, 0xef, 0x04, 0x47, 0x62, 0xc5, 0x24, 0x27, 0x50, 0x65, 0x40,
0xd8, 0x56, 0x23, 0x9f, 0x49, 0xdf, 0x4a, 0x2b, 0xd4, 0x46, 0x0c, 0x38,
0xec, 0x3d, 0x65, 0x1e, 0x2b, 0x0b, 0xef, 0x21, 0x13, 0xdf, 0x15, 0x6a,
0xd8, 0x0b, 0x59, 0x0d, 0xca, 0x5f, 0x29, 0x3b, 0x04, 0xeb, 0x79, 0xe5,
0x12, 0x62, 0x01, 0x1c, 0x68, 0x44, 0xf7, 0x78, 0x3d, 0x53, 0x5f, 0x33,
0x5b, 0x08, 0xc6, 0x51, 0x12, 0x30, 0xd7, 0x0f, 0xa0, 0xf3, 0xc3, 0x30,
0x48, 0xe7, 0x38, 0x26, 0x46, 0xd9, 0x21, 0xfa, 0x05, 0x2f, 0xd4, 0x5f,
0x03, 0x4c, 0x50, 0xe9, 0xf0, 0xda, 0xfd, 0x20, 0xec, 0x01, 0x20, 0x32,
0xe7, 0x31, 0x86, 0x37, 0x48, 0x55, 0x56, 0xc6, 0x00, 0xf8, 0x09, 0xff,
0x53, 0x93, 0xb9, 0x0a, 0xc2, 0x42, 0x25, 0x48, 0x9a, 0xf7, 0xd1, 0x43,
0x89, 0xfc, 0x6a, 0x7f, 0x16, 0x52, 0xf8, 0x42, 0xe7, 0x19, 0x59, 0x10,
0xfd, 0x08, 0xf6, 0xd4, 0x2b, 0xf4, 0xfd, 0xbe, 0xe3, 0x2f, 0x2d, 0x51,
0xfe, 0x2a, 0x65, 0x1b, 0x34, 0x26, 0xca, 0x25, 0x12, 0xd6, 0xf9, 0x53,
0xee, 0x2b, 0xad, 0xf7, 0x87, 0x2b, 0x1e, 0x02, 0x21, 0xe6, 0x34, 0xf7,
0x47, 0x70, 0xf9, 0x1c, 0x07, 0x64, 0xfa, 0x46, 0xfc, 0x4c, 0x23, 0x2b,
0x0b, 0x34, 0x48, 0x65, 0x15, 0x57, 0xf1, 0x5a, 0x59, 0x14, 0x40, 0x1a,
0xde, 0x82, 0x18, 0x81, 0x1e, 0xe0, 0x26, 0x8a, 0xb1, 0xfc, 0xb1, 0x56,
0x15, 0x7c, 0x91, 0x5a, 0x6e, 0x2a, 0x65, 0x3e, 0xdf, 0x2c, 0x0a, 0x6e,
0xe1, 0x1c, 0x2c, 0xed, 0x87, 0x15, 0x37, 0xd1, 0x0e, 0x98, 0x73, 0x16,
0x0b, 0xe4, 0xe7, 0x38, 0x39, 0x7b, 0x1a, 0x2e, 0x05, 0xf4, 0x3a, 0xb9,
0x39, 0x34, 0xc0, 0x44, 0x30, 0x3a, 0xd6, 0x05, 0x2c, 0xfa, 0x38, 0x5c,
0x24, 0x5b, 0x22, 0x21, 0x70, 0x30, 0x42, 0xab, 0xb1, 0x45, 0x1d, 0x5b,
0x05, 0x07, 0x5b, 0xc3, 0x04, 0x9b, 0x17, 0x2e, 0x31, 0x29, 0xe9, 0x5f,
0xd8, 0xd0, 0x4b, 0x23, 0xa6, 0x10, 0x1d, 0xe2, 0x16, 0x09, 0x65, 0xfb,
0x33, 0x9e, 0xfe, 0x22, 0xc4, 0x4c, 0xf3, 0x1e, 0x36, 0x3a, 0x3d, 0x84,
0x88, 0x1e, 0xe1, 0x63, 0x27, 0x33, 0xce, 0xd6, 0x0b, 0x1a, 0x9b, 0x04,
0x62, 0xa1, 0x12, 0xfa, 0x26, 0x41, 0x3b, 0xf5, 0xe2, 0x09, 0x28, 0x6f,
0xe6, 0x34, 0xc4, 0x10, 0x31, 0x01, 0x9a, 0x32, 0xdc, 0x68, 0xf6, 0x44,
0xf8, 0x19, 0xac, 0xf5, 0x44, 0x49, 0x22, 0x2c, 0x53, 0xfc, 0x6a, 0x3b,
0x09, 0x0c, 0xce, 0x26, 0xf3, 0x4b, 0x13, 0x1c, 0x20, 0x49, 0xf5, 0x6f,
0x28, 0x57, 0x36, 0x61, 0x55, 0x6f, 0xed, 0xde, 0xcf, 0xf3, 0xd9, 0x16,
0x76, 0xf9, 0x41, 0x10, 0x1e, 0x59, 0x48, 0x47, 0xc5, 0x40, 0x04, 0x6c,
0x08, 0x3f, 0xd1, 0x1c, 0x43, 0xd1, 0x2e, 0x61, 0x72, 0x38, 0x3a, 0x24,
0xf2, 0x14, 0xd5, 0xa2, 0x29, 0x5e, 0xfe, 0xbb, 0x08, 0xd5, 0x57, 0x4f,
0x32, 0x25, 0x21, 0x09, 0xa7, 0x57, 0x0d, 0x1f, 0x58, 0x28, 0x55, 0xe3,
0x92, 0x61, 0xc3, 0xcf, 0xfe, 0x36, 0xb0, 0x1f, 0x32, 0xa0, 0x4a, 0xfb,
0x03, 0x01, 0x2d, 0xd9, 0x0f, 0x15, 0x1e, 0x44, 0xed, 0x4e, 0xd5, 0x79,
0x2b, 0x4a, 0xaf, 0xac, 0xb5, 0x89, 0xc9, 0x4c, 0x47, 0x01, 0x00, 0x19,
0xde, 0xfa, 0x2d, 0xe2, 0x67, 0xfb, 0xde, 0x5e, 0x3f, 0x22, 0x1d, 0x49,
0x2e, 0x9d, 0x29, 0x4b, 0x43, 0x6e, 0x2a, 0x1b, 0x05, 0x0a, 0x3f, 0xe9,
0x89, 0x17, 0xfe, 0x22, 0x54, 0x63, 0xcd, 0xbc, 0x62, 0xca, 0xa7, 0x3d,
0x3d, 0xe0, 0x40, 0x17, 0x37, 0x16, 0x17, 0xbc, 0x02, 0x0e, 0x39, 0x6b,
0x34, 0x6b, 0xe0, 0x5f, 0x45, 0x7c, 0x91, 0x2c, 0x10, 0x70, 0x40, 0x56,
0xa5, 0xa4, 0x2c, 0xd0, 0xba, 0x1e, 0x10, 0xf4, 0x2a, 0x4b, 0x06, 0x2f,
0x46, 0xe3, 0x0a, 0x13, 0x45, 0x6b, 0x28, 0x1d, 0x65, 0x49, 0x6b, 0xf0,
0x59, 0x47, 0x3c, 0x01, 0x4c, 0x27, 0xc5, 0xcb, 0x39, 0xf5, 0x6f, 0x3a,
0xef, 0x51, 0x36, 0x26, 0xfb, 0x2b, 0x36, 0x3c, 0x2f, 0x38, 0xe9, 0x69,
0x06, 0x07, 0x9b, 0xfb, 0x9d, 0xe6, 0x94, 0x42, 0x34, 0xf4, 0x3e, 0x33,
0xbf, 0xad, 0xa5, 0x0c, 0xd9, 0xdb, 0xb8, 0xa0, 0x11, 0xf7, 0x64, 0x0a,
0x3d, 0x86, 0x1f, 0x4c, 0x27, 0x4d, 0x09, 0x03, 0xfc, 0x29, 0x36, 0x8e,
0xf7, 0xfe, 0xfc, 0x47, 0x19, 0x22, 0xb1, 0xcf, 0x63, 0xf2, 0xb5, 0x4e,
0x4f, 0xd8, 0x0e, 0x04, 0x56, 0xf6, 0x30, 0x72, 0x02, 0x46, 0xea, 0x38,
0x25, 0x41, 0x0b, 0xef, 0xb5, 0x4e, 0x1a, 0x12, 0x6d, 0xfd, 0x5e, 0x34,
0x9d, 0xaa, 0xb6, 0xd9, 0x2f, 0x2e, 0xac, 0xa2, 0x4f, 0x0b, 0x36, 0x1e,
0x22, 0x8f, 0x2b, 0x30, 0x47, 0x33, 0x2d, 0x49, 0xa9, 0xcd, 0xf2, 0x66,
0x03, 0x96, 0xf4, 0x41, 0x6e, 0x26, 0x05, 0x46, 0xeb, 0x03, 0xf3, 0x16,
0x66, 0x9e, 0x4b, 0x02, 0xd9, 0xe5, 0x18, 0xb2, 0x14, 0x09, 0x22, 0x03,
0x0e, 0xde, 0xb3, 0xed, 0xef, 0xcc, 0x52, 0xdc, 0xb9, 0x1a, 0x6a, 0x28,
0xfd, 0x23, 0x01, 0x48, 0x70, 0x24, 0x28, 0x20, 0x29, 0xeb, 0xea, 0xea,
0x25, 0x8f, 0xfb, 0xe7, 0x47, 0x2c, 0x33, 0xec, 0xf7, 0x05, 0x09, 0xeb,
0xf3, 0xb0, 0xb8, 0x59, 0x59, 0x0d, 0xc2, 0xf2, 0x49, 0x23, 0x2e, 0xda,
0xe1, 0xa5, 0x12, 0x02, 0xfd, 0xcb, 0x2f, 0xb3, 0xc6, 0x22, 0xdd, 0x07,
0x2c, 0xef, 0x39, 0xb4, 0x2a, 0x69, 0x1c, 0xe0, 0x54, 0x1a, 0x0e, 0x24,
0xbc, 0xf9, 0x1d, 0xfb, 0xdc, 0x03, 0xdf, 0x8c, 0x04, 0x31, 0x33, 0xec,
0x16, 0xc3, 0xfa, 0x01, 0x28, 0x06, 0x13, 0x43, 0xc2, 0xb5, 0x29, 0x0c,
0xc8, 0xd1, 0x59, 0x70, 0x2e, 0x1c, 0xef, 0x11, 0x67, 0xdc, 0xbe, 0xf1,
0xe8, 0xb8, 0x06, 0xbc, 0x60, 0x08, 0x49, 0x9e, 0x30, 0x2e, 0x13, 0x28,
0x25, 0x3b, 0x60, 0xdd, 0x10, 0xb8, 0x2e, 0xbb, 0x77, 0x3e, 0x53, 0x12,
0xba, 0x5b, 0x88, 0x3e, 0x8f, 0x72, 0x3f, 0xa5, 0x4d, 0xec, 0xfe, 0xfe,
0x1d, 0x04, 0x31, 0xf3, 0x3c, 0x3d, 0x24, 0x29, 0xe7, 0x38, 0x03, 0xa5,
0xe0, 0xf1, 0xf8, 0x71, 0x07, 0x4f, 0xd0, 0x3c, 0xd6, 0xf6, 0x42, 0x01,
0x5f, 0x0a, 0x34, 0x14, 0x11, 0xd2, 0x15, 0xd9, 0xcd, 0xe7, 0xf7, 0x35,
0x37, 0x4e, 0xbb, 0x61, 0xd6, 0xf6, 0x45, 0x08, 0x76, 0x4e, 0x05, 0x31,
0xf3, 0xf9, 0xec, 0x34, 0x88, 0x32, 0xfb, 0x9e, 0x4a, 0x0c, 0x28, 0x23,
0x27, 0x0b, 0xb7, 0x2c, 0x41, 0x49, 0xee, 0x25, 0x29, 0x52, 0x30, 0xc5,
0x8f, 0x0a, 0x1b, 0x26, 0xf7, 0x47, 0xcc, 0x37, 0xbd, 0x22, 0x31, 0x1a,
0x36, 0x36, 0x31, 0x09, 0x0f, 0xef, 0x29, 0x62, 0xc3, 0x17, 0xcc, 0x41,
0x3c, 0x02, 0x6c, 0x38, 0x37, 0x5a, 0x36, 0x3b, 0xd3, 0x30, 0xf0, 0x27,
0xfc, 0x0c, 0x37, 0x17, 0x04, 0x74, 0x4f, 0x2c, 0x34, 0x23, 0x16, 0xcd,
0x33, 0xc1, 0xdd, 0x07, 0x4d, 0x33, 0xfa, 0x5d, 0x38, 0x23, 0xc8, 0x6f,
0x5a, 0x21, 0xf4, 0x78, 0x15, 0x2f, 0x02, 0xe2, 0xe6, 0x3e, 0xfd, 0x1f,
0xbb, 0x1d, 0x09, 0x45, 0x5d, 0xd0, 0x30, 0x9a, 0x0b, 0x30, 0x31, 0x3b,
0xc3, 0x6a, 0x2a, 0x17, 0xd2, 0x4a, 0xc3, 0x09, 0xe1, 0x2e, 0x31, 0x68,
0xb6, 0x33, 0xec, 0x14, 0x1a, 0x69, 0xff, 0x15, 0x2a, 0x2a, 0x51, 0xeb,
0x31, 0x9b, 0xbe, 0x10, 0xd5, 0x4b, 0x01, 0x3b, 0xa7, 0x60, 0x4b, 0x21,
0x6a, 0x3d, 0x49, 0x3b, 0xf5, 0x37, 0x03, 0x3b, 0xaa, 0x29, 0x14, 0x08,
0x39, 0x19, 0x37, 0x18, 0x21, 0xca, 0x16, 0xd6, 0x14, 0x20, 0xc8, 0x68,
0x21, 0x51, 0xd4, 0x53, 0x9e, 0x9d, 0x6a, 0x3b, 0xcf, 0x6c, 0xfe, 0x29,
0xf4, 0x16, 0x46, 0x46, 0x85, 0x3c, 0x43, 0xff, 0x25, 0xc4, 0x65, 0xef,
0x37, 0xe6, 0xe5, 0x33, 0xcf, 0x59, 0x2c, 0x28, 0xf3, 0xc6, 0x27, 0x07,
0xc6, 0x26, 0xc3, 0x69, 0xef, 0x24, 0xda, 0x0c, 0xdb, 0xef, 0x61, 0x56,
0x2d, 0xc6, 0x16, 0x05, 0x10, 0x1d, 0x18, 0xd5, 0x01, 0x38, 0xb0, 0x44,
0x25, 0x3f, 0x8a, 0xf1, 0x1b, 0x06, 0x8a, 0x56, 0x2c, 0xf9, 0x1d, 0x78,
0xc7, 0x0f, 0x07, 0xfa, 0xc7, 0x03, 0x2c, 0x47, 0x11, 0xe3, 0x32, 0x36,
0x29, 0x54, 0xeb, 0x40, 0x56, 0x4a, 0x0c, 0x76, 0x30, 0x4a, 0x58, 0x2c,
0xa4, 0x2b, 0x27, 0xf1, 0x27, 0x46, 0xe1, 0x2d, 0x57, 0x26, 0xcf, 0x46,
0x59, 0x4f, 0x23, 0xd2, 0x3b, 0x07, 0x36, 0x43, 0xc8, 0x27, 0x3b, 0x78,
0x04, 0x27, 0xa9, 0xd5, 0xd8, 0x0d, 0xaa, 0x25, 0x69, 0x61, 0x09, 0x3e,
0xe6, 0xb6, 0xef, 0x10, 0x22, 0x41, 0x0a, 0x39, 0x0d, 0x2a, 0x4b, 0x13,
0x31, 0x86, 0xf1, 0x12, 0x45, 0x4b, 0x22, 0x33, 0x5c, 0xf1, 0x7a, 0x3d,
0xbc, 0x22, 0xfe, 0x54, 0x21, 0x4e, 0x08, 0xd8, 0xac, 0x15, 0x20, 0x72,
0xc4, 0x60, 0x16, 0x28, 0x5e, 0x29, 0x38, 0x5b, 0xd7, 0x31, 0x9e, 0x74,
0x21, 0x79, 0xd7, 0x20, 0x03, 0xc0, 0x9c, 0x23, 0x56, 0x27, 0x1d, 0x52,
0xf3, 0x0a, 0x6c, 0xd6, 0x1f, 0x2d, 0x15, 0x4e, 0x21, 0xd9, 0x6b, 0x30,
0x0e, 0xd5, 0xfc, 0x17, 0x47, 0x3f, 0x33, 0x7a, 0x3b, 0x11, 0xe7, 0x6b,
0x06, 0x46, 0x5d, 0x19, 0x08, 0x44, 0xe6, 0xfb, 0x15, 0xce, 0x01, 0x27,
0x31, 0x94, 0x1c, 0x0c, 0x73, 0x48, 0x33, 0x30, 0x1d, 0x1e, 0x32, 0x4e,
0x18, 0x28, 0xb1, 0xde, 0x19, 0xc7, 0xc0, 0x29, 0x5f, 0xfc, 0x12, 0x5b,
0xba, 0xe5, 0xb5, 0xf2, 0x6d, 0x12, 0x3d, 0x9f, 0x46, 0xc6, 0x48, 0x0b,
0x28, 0xfd, 0x0b, 0x48, 0x16, 0x5d, 0x01, 0x48, 0x8b, 0x52, 0xb2, 0xc8,
0x29, 0x4e, 0xd0, 0x30, 0x05, 0x61, 0xd4, 0x1a, 0xd3, 0xdd, 0x4a, 0xe4,
0x4e, 0xd9, 0x24, 0x04, 0x76, 0x3a, 0x55, 0x8c, 0x1e, 0x14, 0x19, 0x5f,
0x37, 0x0e, 0x18, 0xf3, 0x30, 0x3f, 0x23, 0x2d, 0xfd, 0xdf, 0x18, 0x35,
0xaf, 0x0a, 0x0b, 0xb0, 0x0b, 0xdc, 0x5b, 0xcc, 0x56, 0xcb, 0x11, 0x04,
0x1b, 0x3d, 0x3d, 0x10, 0x4a, 0x55, 0xfd, 0x1e, 0xf2, 0xd2, 0x09, 0xe7,
0x99, 0x59, 0xed, 0xd7, 0x0d, 0x3f, 0xba, 0xea, 0x6d, 0xcf, 0x44, 0x39,
0x20, 0x1e, 0x1d, 0xf4, 0x15, 0x23, 0x1a, 0xfc, 0xf7, 0x3d, 0x52, 0x39,
0x07, 0x24, 0xc3, 0x34, 0xde, 0x29, 0x83, 0x43, 0xe6, 0xf9, 0x2a, 0x27,
0xbc, 0xd4, 0x0d, 0xbc, 0xb1, 0x36, 0xe6, 0x4d, 0x29, 0xd7, 0x45, 0x0c,
0x64, 0x63, 0xdb, 0x30, 0xd0, 0x65, 0x23, 0x33, 0x8a, 0xfc, 0x3d, 0x67,
0x03, 0x3c, 0x0c, 0x54, 0x41, 0x50, 0xac, 0xc8, 0xee, 0xb0, 0x98, 0xf2,
0xf3, 0x54, 0x4b, 0xef, 0x02, 0xed, 0x19, 0x0d, 0xd8, 0x51, 0x12, 0x33,
0x2c, 0x29, 0xbb, 0x5b, 0xc3, 0xd7, 0xaf, 0x2d, 0x30, 0xe1, 0x05, 0x0c,
0xc7, 0xb6, 0xa3, 0x08, 0x0c, 0xf7, 0xeb, 0x4c, 0x64, 0xda, 0x1a, 0xdd,
0x17, 0x1c, 0x1f, 0x48, 0xcb, 0x5c, 0x11, 0xf6, 0x45, 0x21, 0xee, 0xbb,
0x2b, 0x0c, 0xe6, 0x2d, 0x29, 0x0d, 0xa5, 0xd9, 0xd3, 0xfc, 0xa2, 0x11,
0xf5, 0x00, 0x40, 0xb2, 0xf6, 0x25, 0x33, 0x73, 0x03, 0x39, 0x01, 0x1f,
0x2d, 0xf8, 0x6d, 0xcd, 0x9a, 0xb7, 0xf7, 0x03, 0x28, 0x65, 0x1f, 0x09,
0xb6, 0xe4, 0xb6, 0xf1, 0x36, 0xf3, 0x40, 0x5b, 0x2d, 0x14, 0x2f, 0x01,
0x3b, 0x4d, 0xf0, 0x2a, 0x0e, 0x52, 0x1b, 0x55, 0x88, 0xd7, 0x14, 0x3b,
0xe8, 0xee, 0x33, 0x4a, 0x51, 0xe5, 0x09, 0x04, 0xa5, 0x06, 0xd1, 0xbd,
0x6d, 0x48, 0x4c, 0xe3, 0x46, 0xf8, 0x57, 0x54, 0xf6, 0x21, 0xc0, 0x1c,
0x17, 0xe9, 0x0f, 0xea, 0x02, 0x9b, 0x6a, 0xe9, 0x40, 0x3e, 0x77, 0x3c,
0xe1, 0x52, 0x2c, 0x2c, 0xea, 0xe8, 0x32, 0x24, 0x23, 0xac, 0x4f, 0x13,
0x35, 0xe3, 0x09, 0x33, 0xb3, 0x10, 0x0e, 0x0c, 0xaf, 0xc7, 0x3d, 0x7d,
0x2a, 0xc0, 0x37, 0x60, 0x4e, 0x38, 0x02, 0x4a, 0x2c, 0x11, 0x29, 0x3a,
0x0c, 0x22, 0x37, 0xdf, 0x31, 0xcf, 0x36, 0xfc, 0xfa, 0x05, 0x3b, 0x0f,
0x30, 0x21, 0xaa, 0x40, 0xc8, 0x7a, 0x05, 0xc7, 0x61, 0x16, 0x1d, 0x2c,
0xe5, 0xf6, 0x32, 0x1b, 0x12, 0x30, 0xcd, 0x9f, 0x2d, 0x31, 0x3a, 0x10,
0x53, 0x09, 0xc5, 0x1c, 0x67, 0x29, 0x01, 0xf8, 0x6a, 0x52, 0x5e, 0x90,
0x58, 0xbe, 0xe6, 0x4e, 0x20, 0x43, 0xe7, 0xfc, 0x5b, 0x26, 0x04, 0xd8,
0x4b, 0x3c, 0x2e, 0xad, 0x49, 0xe1, 0x47, 0x6b, 0xf1, 0x3c, 0x00, 0x2f,
0xe7, 0x4e, 0x2a, 0x0f, 0xca, 0x9c, 0x88, 0xb4, 0x0b, 0x3b, 0x13, 0x10,
0xc3, 0x16, 0xaa, 0x04, 0x4c, 0x01, 0xc0, 0xfb, 0x34, 0xea, 0x20, 0x0a,
0x09, 0x79, 0x2c, 0x3d, 0xad, 0x40, 0x13, 0x4b, 0xd5, 0xf0, 0x0a, 0x29,
0xe9, 0x0a, 0x6a, 0x38, 0x4e, 0x54, 0xe4, 0x62, 0xf5, 0x21, 0x99, 0x43,
0x61, 0xca, 0x35, 0x9d, 0xfc, 0xe1, 0x09, 0x4f, 0x20, 0x1c, 0xdc, 0x23,
0x08, 0x41, 0x43, 0x5f, 0x17, 0xb1, 0xbf, 0x37, 0x17, 0x6c, 0x28, 0x2b,
0xf9, 0x37, 0x25, 0x15, 0x91, 0x36, 0x5a, 0x56, 0x34, 0xfa, 0x44, 0xdf,
0x36, 0x98, 0xef, 0xf1, 0xfe, 0x1e, 0x23, 0x35, 0xca, 0xe7, 0xd4, 0xd7,
0xce, 0x12, 0x15, 0x62, 0x2e, 0x54, 0xd9, 0x34, 0x1c, 0x48, 0x0a, 0x37,
0xfd, 0x05, 0x47, 0xd5, 0x67, 0x17, 0x07, 0x59, 0xea, 0x36, 0x70, 0x3e,
0xdf, 0x5e, 0xb3, 0xaf, 0x1f, 0x65, 0x0f, 0x01, 0x59, 0x76, 0x17, 0x55,
0xee, 0xe4, 0x22, 0x27, 0xb1, 0x3a, 0xb6, 0x19, 0x52, 0xcf, 0x6e, 0x1a,
0x52, 0x2b, 0x1b, 0x37, 0x40, 0x3e, 0x13, 0x15, 0xf3, 0xfc, 0xd0, 0x49,
0x1d, 0x04, 0x41, 0x21, 0xfe, 0x36, 0xf6, 0xb1, 0x33, 0x36, 0x1d, 0x36,
0xd4, 0x68, 0x14, 0x29, 0x7d, 0xca, 0x4d, 0x19, 0xeb, 0x1c, 0x46, 0x40,
0x1e, 0x1c, 0xb3, 0x4e, 0xb7, 0xf9, 0xbb, 0x33, 0x69, 0x71, 0xfa, 0x52,
0xfb, 0x0c, 0x10, 0xf6, 0x61, 0x0c, 0x0a, 0x9c, 0x24, 0x1c, 0x36, 0xe2,
0x0c, 0xec, 0x04, 0x08, 0x3a, 0x43, 0x12, 0x25, 0xfe, 0x48, 0x4a, 0xd9,
0xe4, 0x11, 0xcd, 0xf3, 0x17, 0x2b, 0xd7, 0x2b, 0x3b, 0x0c, 0x13, 0x4c,
0x4b, 0xd5, 0x41, 0x06, 0x60, 0x1e, 0x3e, 0xd3, 0xb0, 0x16, 0x35, 0x4a,
0x14, 0x4c, 0xde, 0x18, 0x00, 0xe6, 0xc2, 0x34, 0x07, 0x54, 0x39, 0x20,
0xf2, 0x14, 0xb9, 0x27, 0xaa, 0x56, 0xe0, 0x5f, 0x30, 0xb8, 0x55, 0xed,
0x58, 0xe9, 0x00, 0x14, 0xc1, 0x4e, 0x10, 0x18, 0x93, 0x36, 0x9d, 0x93,
0xa1, 0x1d, 0x6d, 0xda, 0x1b, 0x63, 0xc8, 0x18, 0x60, 0xee, 0xe7, 0x0f,
0xea, 0xce, 0x2c, 0xa1, 0x42, 0x26, 0x13, 0xa5, 0xc4, 0xf5, 0xd5, 0x42,
0x10, 0x6a, 0xea, 0xc5, 0x0a, 0x97, 0x0a, 0x26, 0xde, 0x07, 0x1e, 0x47,
0xe9, 0x3d, 0x4c, 0xdd, 0x27, 0x1c, 0x50, 0xcb, 0x46, 0x22, 0x3c, 0x0c,
0x59, 0x47, 0xb0, 0x15, 0xc2, 0x42, 0xd7, 0x4c, 0x95, 0x3a, 0x79, 0x49,
0x9d, 0x0e, 0x69, 0x66, 0x1d, 0x62, 0xc7, 0x40, 0x1e, 0x04, 0xc4, 0x2e,
0xb7, 0x06, 0x16, 0xcb, 0x63, 0x0a, 0x2d, 0x20, 0x81, 0x20, 0xce, 0x5a,
0x3c, 0x16, 0x22, 0x1a, 0x12, 0xcb, 0x92, 0x1f, 0xd8, 0x0c, 0x1b, 0x66,
0x03, 0xf1, 0xb2, 0xa2, 0x8f, 0x14, 0x5b, 0x3e, 0x0e, 0x16, 0x66, 0x46,
0x32, 0x2b, 0xa7, 0x42, 0xed, 0x74, 0x3f, 0x55, 0xde, 0x34, 0x7f, 0xdd,
0x40, 0x26, 0x10, 0x70, 0x49, 0x1f, 0xc8, 0xda, 0x13, 0x3e, 0x9d, 0x7b,
0x28, 0x87, 0x25, 0x1d, 0x5e, 0x1e, 0x0d, 0x90, 0xfe, 0x2d, 0xec, 0x62,
0x43, 0x39, 0xc9, 0x07, 0x16, 0x1a, 0xf1, 0x4c, 0x74, 0x0a, 0x3c, 0x19,
0xde, 0xcf, 0x9c, 0x23, 0x16, 0x5a, 0x34, 0x85, 0x65, 0x2f, 0x3a, 0x3e,
0x51, 0x87, 0x10, 0x13, 0xc9, 0x70, 0x16, 0x2a, 0x49, 0x3a, 0xd7, 0xc8,
0x39, 0x1f, 0x01, 0x29, 0x0f, 0x4a, 0xc8, 0xcc, 0x2e, 0xce, 0x91, 0x0f,
0x0c, 0xd9, 0x10, 0xbd, 0x4a, 0x49, 0x55, 0xcd, 0xe3, 0x19, 0xeb, 0x56,
0xf7, 0x56, 0xb3, 0xf7, 0x57, 0x0a, 0xed, 0x25, 0xe7, 0x02, 0xf7, 0x4b,
0xe6, 0xdf, 0x07, 0xff, 0x5f, 0x04, 0x3c, 0x64, 0x37, 0x1b, 0x18, 0x4a,
0x23, 0xc5, 0xee, 0x4f, 0xde, 0x61, 0x08, 0xfe, 0x92, 0xda, 0x12, 0x7d,
0x51, 0x14, 0xca, 0xe7, 0x29, 0x1b, 0xf1, 0x14, 0xfc, 0xcf, 0x11, 0xf4,
0x65, 0x2f, 0x51, 0xe3, 0x02, 0x21, 0x52, 0x53, 0x1c, 0x47, 0xde, 0x72,
0x10, 0x69, 0xf3, 0xd2, 0xe0, 0xcf, 0x63, 0x14, 0x41, 0x08, 0x3f, 0x41,
0xbd, 0x01, 0xeb, 0xca, 0xac, 0x4a, 0xd5, 0x9c, 0x53, 0xd5, 0x3c, 0x07,
0x20, 0x8d, 0x3e, 0x42, 0x0d, 0x43, 0x16, 0x30, 0xab, 0x30, 0xc2, 0x12,
0x84, 0x33, 0x52, 0x4e, 0x01, 0x4b, 0xb0, 0xd0, 0xe3, 0xd2, 0x1c, 0x26,
0x3f, 0xa0, 0x49, 0x00, 0x14, 0x26, 0x16, 0x95, 0x40, 0x38, 0x04, 0x69,
0x33, 0x77, 0x12, 0xc4, 0x54, 0x2e, 0xdd, 0x12, 0x2f, 0x51, 0x0a, 0x0c,
0xaa, 0xe9, 0xe0, 0xa3, 0xea, 0x0f, 0x0b, 0xd0, 0x10, 0xba, 0x02, 0xe4,
0x4e, 0xcb, 0xef, 0x2d, 0x01, 0x49, 0x42, 0x3d, 0xad, 0x07, 0x24, 0x3a,
0x44, 0x29, 0xc5, 0xf3, 0x33, 0x49, 0xd3, 0x91, 0xb8, 0xe1, 0x25, 0xc9,
0x49, 0xe3, 0x3a, 0xdf, 0x04, 0xec, 0x27, 0xf5, 0xe1, 0x3e, 0xed, 0x2a,
0x27, 0x05, 0x4c, 0xb9, 0x2a, 0x76, 0x1c, 0x0a, 0x66, 0xf6, 0x3a, 0x1c,
0xaf, 0xeb, 0xe5, 0x12, 0xc9, 0x12, 0x0d, 0xb7, 0x27, 0x36, 0x57, 0xdb,
0x42, 0x3f, 0xe6, 0x12, 0x00, 0x2c, 0x2f, 0xf3, 0x2b, 0xc6, 0xad, 0x89,
0x52, 0x49, 0x55, 0xfc, 0x18, 0x3b, 0xba, 0xcc, 0x54, 0x2c, 0x93, 0x17,
0x3b, 0xa5, 0x58, 0xdd, 0x63, 0xe5, 0x23, 0xb7, 0x16, 0x47, 0x60, 0x3e,
0x43, 0x4c, 0x98, 0xff, 0xd2, 0x37, 0x33, 0x2b, 0xb1, 0x3b, 0x3e, 0x06,
0xae, 0xcf, 0x35, 0xdc, 0xf8, 0x0d, 0x5c, 0x00, 0x1f, 0x11, 0x2a, 0x11,
0x5a, 0x15, 0x1c, 0x52, 0xfe, 0x50, 0x26, 0x3a, 0xe7, 0x38, 0xe4, 0xa2,
0x50, 0xc5, 0x08, 0xef, 0x54, 0x15, 0xee, 0x35, 0xb9, 0xe2, 0xce, 0xd6,
0xcf, 0x12, 0x5a, 0xbe, 0xff, 0xe2, 0x10, 0x0a, 0xea, 0x25, 0xe1, 0x19,
0x04, 0xc6, 0x8e, 0x31, 0xc8, 0xe6, 0xb9, 0xe8, 0x5b, 0x63, 0x45, 0x30,
0xfc, 0x3b, 0x05, 0xf6, 0xc4, 0xce, 0x5a, 0x61, 0x4a, 0x16, 0x11, 0x18,
0x3a, 0x31, 0xe5, 0x31, 0x3e, 0x21, 0x02, 0xd3, 0x13, 0xdd, 0x40, 0x8b,
0xa0, 0xc7, 0x00, 0x16, 0x5f, 0x2a, 0xed, 0xff, 0x6d, 0x26, 0xe7, 0xf5,
0x40, 0x8e, 0x51, 0x3d, 0xf9, 0x1d, 0x4e, 0xf6, 0xf8, 0x05, 0x96, 0x0b,
0xf2, 0xea, 0xfe, 0x4d, 0x9d, 0x70, 0xa4, 0xbd, 0x5b, 0xf4, 0x4a, 0x21,
0xf4, 0x0d, 0xa3, 0x4c, 0x8a, 0x27, 0x2f, 0x5d, 0x24, 0xe7, 0xfb, 0x1c,
0x0a, 0xda, 0xc8, 0x29, 0x3a, 0x35, 0xfd, 0x44, 0xb6, 0xaf, 0xb3, 0xbc,
0x59, 0xc2, 0xdc, 0x42, 0x1d, 0x5b, 0xdc, 0x20, 0x6c, 0x2d, 0xc8, 0x3b,
0x14, 0xc6, 0x3d, 0xe6, 0xf8, 0xf4, 0x56, 0x82, 0x36, 0x25, 0x5a, 0x2b,
0xe3, 0x24, 0x0d, 0xce, 0x00, 0x1d, 0x9e, 0x00, 0x68, 0xde, 0x34, 0x61,
0x00, 0x03, 0x21, 0x13, 0x72, 0x0a, 0xd1, 0x06, 0x20, 0xd4, 0x37, 0x00,
0x62, 0xcd, 0x37, 0x37, 0xaf, 0x3b, 0x1a, 0x2e, 0xf8, 0xd7, 0xa3, 0x85,
0xe9, 0x0e, 0x29, 0x68, 0x1c, 0x61, 0xbe, 0x17, 0x34, 0x18, 0xde, 0x20,
0x6e, 0x09, 0x4b, 0xfa, 0x1a, 0xd2, 0x38, 0x06, 0xee, 0x16, 0xc0, 0x51,
0x3d, 0xf3, 0x45, 0xcb, 0xe2, 0xae, 0x0d, 0xf6, 0xee, 0xe4, 0x44, 0x51,
0xf4, 0x56, 0x4c, 0x2b, 0x41, 0x47, 0x6a, 0x0f, 0x48, 0xef, 0xfe, 0xfd,
0x14, 0x62, 0xd9, 0xf6, 0xe5, 0x4f, 0xf7, 0x4f, 0xc3, 0x33, 0xde, 0xcf,
0x93, 0x28, 0x57, 0x10, 0x0b, 0x1d, 0xe7, 0x12, 0xf6, 0x16, 0xc6, 0xf2,
0x25, 0x51, 0x41, 0x07, 0x49, 0xfb, 0x29, 0x53, 0x18, 0x07, 0x4b, 0x57,
0x05, 0x5b, 0x6f, 0x23, 0xc4, 0x75, 0x2a, 0x2d, 0x43, 0x2f, 0x4d, 0x57,
0xf3, 0xf3, 0x63, 0x17, 0xa3, 0x32, 0x57, 0x2a, 0x43, 0xeb, 0x69, 0xe1,
0x2d, 0xfb, 0xd3, 0x31, 0x28, 0x27, 0x1a, 0x29, 0xb2, 0x4c, 0xa9, 0x12,
0x37, 0xfa, 0x74, 0x2b, 0x08, 0x1f, 0xc8, 0xdd, 0xe0, 0x4f, 0xaa, 0x29,
0x08, 0x37, 0x34, 0xdd, 0x60, 0x1f, 0xff, 0xa1, 0x01, 0x11, 0x3c, 0x63,
0xe6, 0x3a, 0x2c, 0xc5, 0xb4, 0x99, 0x08, 0x2b, 0x47, 0x67, 0x3e, 0x4d,
0xe0, 0xd4, 0x2b, 0x08, 0xfb, 0x13, 0xe4, 0x25, 0x2a, 0xde, 0x02, 0x10,
0x39, 0x09, 0xfa, 0xfe, 0xba, 0x50, 0xed, 0x13, 0x46, 0x00, 0x39, 0xf2,
0x3a, 0x20, 0xc1, 0x53, 0xfa, 0x58, 0xef, 0xd6, 0xaa, 0x1e, 0x39, 0x2b,
0x3e, 0x8b, 0x2c, 0x98, 0x1f, 0xe0, 0x15, 0x56, 0xf9, 0x1e, 0x9d, 0x3d,
0xd8, 0x4c, 0x06, 0x08, 0x21, 0xdc, 0xf3, 0x12, 0x69, 0x67, 0x30, 0x50,
0xf7, 0x0f, 0xc0, 0x25, 0xb9, 0x25, 0x37, 0x90, 0x1e, 0xf3, 0x37, 0x0c,
0x1d, 0x76, 0xff, 0xf7, 0xf8, 0x33, 0x09, 0x1b, 0xf1, 0x54, 0x40, 0x67,
0xb3, 0x12, 0xff, 0xfc, 0x4b, 0x3e, 0xd5, 0x4c, 0x49, 0xf9, 0x92, 0x25,
0x05, 0xf6, 0x0a, 0x9f, 0x1e, 0xd4, 0x29, 0xff, 0x1b, 0x45, 0x59, 0x68,
0x1f, 0x04, 0x1b, 0x31, 0x50, 0x88, 0x2a, 0x23, 0xfe, 0x2c, 0x3f, 0x57,
0xd4, 0x50, 0x25, 0xb9, 0x5d, 0x0b, 0xdc, 0x54, 0x4b, 0xff, 0x5e, 0xdc,
0x1a, 0xef, 0xe0, 0x42, 0xcb, 0x42, 0x3f, 0x5d, 0x4d, 0xd1, 0x49, 0xbd,
0xed, 0x45, 0x27, 0x2d, 0x26, 0x25, 0xcb, 0x20, 0x40, 0xef, 0xcf, 0xfe,
0x16, 0xb7, 0x1c, 0xcf, 0x43, 0x39, 0x0b, 0x23, 0xa1, 0x3a, 0x62, 0x42,
0x30, 0x07, 0xef, 0x3e, 0x01, 0xcc, 0x0c, 0x17, 0xdb, 0x43, 0x4f, 0x2c,
0xc4, 0x09, 0xdf, 0xcb, 0x54, 0x09, 0xec, 0xea, 0x40, 0x3d, 0x20, 0x31,
0x1e, 0x72, 0xa2, 0x23, 0x1c, 0x68, 0xf1, 0x0c, 0x2c, 0x04, 0x45, 0x49,
0x11, 0x26, 0x16, 0xd9, 0x45, 0x3a, 0xf0, 0xa2, 0x8e, 0xd8, 0xf6, 0x0f,
0xc8, 0x55, 0x31, 0x49, 0x57, 0xf8, 0x09, 0xdc, 0xb9, 0x1e, 0xce, 0x4c,
0x07, 0x06, 0x20, 0x42, 0xd4, 0xfc, 0x6e, 0x31, 0x1c, 0x68, 0xf9, 0x51,
0xed, 0x07, 0x52, 0x0c, 0xaa, 0x4b, 0x04, 0x04, 0x0e, 0xe1, 0x3a, 0x17,
0x36, 0xee, 0xe5, 0x38, 0x50, 0x5b, 0x25, 0x2f, 0x9f, 0xd9, 0xa9, 0x57,
0xed, 0x2c, 0x3b, 0x0a, 0xf8, 0x42, 0xe4, 0xd2, 0x64, 0xbd, 0xb9, 0x28,
0x55, 0x16, 0x34, 0xda, 0x0f, 0x4c, 0x28, 0x87, 0x25, 0x11, 0xb0, 0x51,
0x3e, 0x2a, 0x82, 0x5f, 0x23, 0x18, 0x83, 0x3a, 0x56, 0x4d, 0xf3, 0x32,
0xc1, 0xec, 0xab, 0xa9, 0x36, 0xf7, 0x54, 0x0c, 0x31, 0xb9, 0x2a, 0x33,
0x0e, 0x3e, 0x38, 0x2a, 0xaf, 0x43, 0x0b, 0x5f, 0x31, 0x21, 0xb0, 0x6f,
0xd2, 0x1b, 0x4b, 0x37, 0x1a, 0x29, 0xca, 0xc6, 0x16, 0xb7, 0xd9, 0xda,
0x27, 0xbe, 0x3b, 0xdf, 0x27, 0x25, 0x1e, 0x2a, 0xe0, 0x23, 0xe4, 0x4f,
0x4b, 0x01, 0x37, 0x2d, 0x63, 0x9a, 0x56, 0x17, 0x02, 0x43, 0x24, 0x5b,
0xe6, 0xbc, 0xde, 0xdc, 0xe2, 0xdf, 0xee, 0x38, 0x35, 0xba, 0x18, 0x18,
0x1b, 0x64, 0x01, 0x0d, 0x4c, 0x39, 0x36, 0xfc, 0x0b, 0xde, 0xa2, 0xca,
0x3f, 0x1d, 0xf4, 0x40, 0x0e, 0x5b, 0xb8, 0xe0, 0xbe, 0xa0, 0xae, 0xd0,
0xfe, 0xd7, 0x2f, 0x0e, 0x38, 0x0e, 0x3d, 0xc3, 0x34, 0x38, 0x08, 0x53,
0x3c, 0x79, 0xc5, 0x23, 0xcb, 0x18, 0xf8, 0x3d, 0xd2, 0xf2, 0x12, 0x42,
0xb3, 0xda, 0x5f, 0xb1, 0x1d, 0xd0, 0xdc, 0x0f, 0x4d, 0x3a, 0x75, 0xeb,
0x26, 0xef, 0x17, 0x56, 0x46, 0x52, 0x1d, 0x07, 0x2e, 0xeb, 0xdf, 0x1e,
0x14, 0x32, 0xaf, 0x5c, 0x69, 0x25, 0x8d, 0xfd, 0xc8, 0xd4, 0x1a, 0xd3,
0xcc, 0x27, 0x3d, 0x0d, 0x14, 0x0d, 0x64, 0xf1, 0xbb, 0x2d, 0x34, 0x48,
0x08, 0x4f, 0xf8, 0x25, 0xac, 0x5f, 0x24, 0x2e, 0xef, 0x74, 0x3d, 0x40,
0xb1, 0xd5, 0x00, 0x0c, 0xf6, 0xf0, 0xd0, 0xda, 0x63, 0xe5, 0x0b, 0x22,
0x3b, 0x3b, 0xdd, 0x3c, 0x32, 0x23, 0x1b, 0x1d, 0xf5, 0xaa, 0x37, 0x30,
0x59, 0x25, 0xb4, 0xee, 0x67, 0x19, 0xb9, 0xb3, 0x61, 0x20, 0xe1, 0x0f,
0xb1, 0x6a, 0x2f, 0xbc, 0x32, 0x09, 0x5e, 0x4c, 0xaf, 0x39, 0x2c, 0x37,
0x44, 0x2c, 0x3c, 0xea, 0xdf, 0xa2, 0x3a, 0x28, 0x04, 0xf3, 0x39, 0x17,
0x91, 0xf0, 0xc2, 0xef, 0x3e, 0x2e, 0xe9, 0x99, 0x44, 0x35, 0x20, 0xd0,
0x1f, 0x1b, 0xf1, 0x39, 0xd8, 0x3f, 0x55, 0x35, 0xc5, 0xcd, 0xbd, 0xcc,
0xee, 0xf0, 0x1c, 0xce, 0x32, 0xee, 0xf2, 0x30, 0xc6, 0x0a, 0x69, 0x0c,
0x07, 0x05, 0x20, 0xdd, 0x4d, 0xd2, 0x14, 0xb8, 0x2d, 0x4f, 0xf6, 0x15,
0x37, 0x02, 0xc3, 0x03, 0x59, 0xfb, 0x41, 0xec, 0xe6, 0x43, 0x2c, 0x1a,
0x09, 0x58, 0x53, 0x12, 0x59, 0xfe, 0x16, 0x0e, 0x10, 0xd6, 0x2a, 0x1e,
0x11, 0x6e, 0x16, 0x4a, 0x4b, 0x1f, 0x1b, 0xdf, 0xba, 0xbe, 0x24, 0x0e,
0x6a, 0xe2, 0x6d, 0xe4, 0x61, 0x2b, 0xe1, 0x10, 0x39, 0x09, 0xa6, 0xb4,
0xcf, 0x40, 0x3a, 0x5e, 0x41, 0xda, 0x53, 0x10, 0xef, 0xf8, 0xd9, 0xfa,
0x17, 0xd1, 0x46, 0x54, 0x33, 0x82, 0x5b, 0xb7, 0x3f, 0xf7, 0x1d, 0x22,
0xf3, 0x40, 0x27, 0x40, 0xd3, 0xcd, 0x4d, 0xdc, 0x43, 0x30, 0xf0, 0xe4,
0x21, 0xd3, 0xe5, 0x2d, 0x1f, 0x32, 0x06, 0xe1, 0xc7, 0xcf, 0xe1, 0xea,
0xf3, 0xcc, 0x1f, 0x23, 0x4e, 0x31, 0xd3, 0x30, 0xcf, 0x1f, 0xc3, 0x07,
0x4f, 0xac, 0x2c, 0x07, 0x19, 0xd6, 0x38, 0xea, 0x17, 0x15, 0xda, 0x3d,
0x21, 0x11, 0x0f, 0xc1, 0x66, 0x2b, 0xd5, 0xe9, 0x08, 0xdf, 0x66, 0x10,
0xec, 0x23, 0xbc, 0xff, 0xb2, 0x28, 0xf5, 0xad, 0x44, 0xcd, 0x46, 0x18,
0x36, 0x30, 0x05, 0x1c, 0xdd, 0x3f, 0x23, 0xf0, 0xaa, 0x1e, 0xf2, 0x75,
0xda, 0x1e, 0x49, 0x4b, 0x39, 0x1e, 0xe8, 0x4b, 0x66, 0xf4, 0x3d, 0x00,
0xb4, 0x1e, 0x12, 0xb7, 0x04, 0xf1, 0x59, 0x1c, 0x25, 0xff, 0x47, 0x3a,
0x17, 0x56, 0xca, 0x63, 0xde, 0x95, 0x9b, 0x1e, 0xfb, 0x02, 0x28, 0x13,
0x02, 0x1b, 0xac, 0x1d, 0xd9, 0x0f, 0x0c, 0x4b, 0x1f, 0xff, 0x5f, 0x0f,
0x13, 0x92, 0xff, 0x0a, 0x07, 0x4e, 0xe6, 0x5b, 0x5b, 0xd6, 0x5e, 0x58,
0xc8, 0x09, 0xf8, 0x36, 0x1f, 0x34, 0xe9, 0x47, 0x62, 0x2c, 0x57, 0x2a,
0xe5, 0x64, 0x2e, 0x18, 0xf7, 0x28, 0x43, 0x90, 0x07, 0xfd, 0xae, 0x2a,
0x0d, 0x37, 0x5e, 0x03, 0xcb, 0x73, 0x54, 0x00, 0x21, 0xe4, 0x62, 0x20,
0xce, 0xef, 0x25, 0x51, 0xf4, 0x5a, 0x57, 0x6b, 0x0a, 0x30, 0x7b, 0xf9,
0x1d, 0x5c, 0x1a, 0x2c, 0xdf, 0x3c, 0xe7, 0x51, 0xc0, 0x4c, 0xb8, 0x1c,
0xac, 0x1a, 0xcd, 0x5c, 0x12, 0x18, 0xd2, 0x2a, 0x27, 0x49, 0x42, 0x5f,
0xc7, 0x48, 0x39, 0xdc, 0x16, 0x12, 0x3e, 0x95, 0x03, 0x10, 0x46, 0x32,
0xda, 0x71, 0xde, 0x6b, 0xb1, 0x17, 0x07, 0x24, 0x0a, 0x3a, 0x57, 0x21,
0xe0, 0xcc, 0x39, 0x3e, 0xbc, 0x0c, 0x55, 0x00, 0x5b, 0xd2, 0x36, 0x1b,
0x26, 0xac, 0xc3, 0x0d, 0x30, 0x36, 0xd0, 0x23, 0xce, 0x61, 0xed, 0x25,
0x37, 0x0a, 0x3e, 0xfa, 0x4c, 0x5b, 0xd2, 0x17, 0xac, 0x29, 0xe0, 0x15,
0x39, 0xc6, 0x59, 0x97, 0xff, 0xf9, 0x2f, 0x1d, 0xf1, 0xfb, 0x29, 0x47,
0x37, 0x55, 0x0e, 0x57, 0x2a, 0x88, 0xf9, 0x30, 0xbc, 0x1d, 0x42, 0x53,
0xd7, 0x25, 0x31, 0x3b, 0x01, 0x16, 0xbb, 0xdb, 0x37, 0xbd, 0x68, 0xdc,
0x17, 0x38, 0xb2, 0x34, 0x45, 0x31, 0x07, 0x25, 0xab, 0x28, 0xe0, 0x4b,
0x24, 0x0b, 0x48, 0x27, 0x1d, 0x64, 0xf1, 0x20, 0x34, 0xe4, 0xbf, 0xf8,
0x6e, 0xa4, 0x49, 0xf1, 0x38, 0x2e, 0x4d, 0x84, 0x28, 0xfa, 0x65, 0x46,
0x31, 0x05, 0x2e, 0xb8, 0x00, 0x68, 0xd0, 0x1b, 0x15, 0x24, 0xfd, 0x2d,
0xda, 0x29, 0x12, 0xc7, 0xcc, 0x0e, 0xc0, 0xc9, 0x11, 0x2e, 0x5c, 0xfe,
0x38, 0xba, 0x03, 0x12, 0xbf, 0x59, 0x0f, 0x18, 0xcd, 0x12, 0x28, 0x9c,
0xd1, 0x59, 0x57, 0xf0, 0x20, 0x63, 0xc8, 0x3d, 0x9c, 0xc8, 0xc7, 0x24,
0xcf, 0xd8, 0x63, 0x09, 0x22, 0x2c, 0x28, 0x6a, 0xd1, 0x4a, 0x55, 0x43,
0xe8, 0x7e, 0x5c, 0x4d, 0xc3, 0x2d, 0x66, 0x2a, 0xd4, 0x09, 0xff, 0x37,
0xcd, 0x3e, 0x41, 0x18, 0x69, 0x14, 0x56, 0xfd, 0x15, 0x1d, 0x04, 0x1f,
0x1e, 0xe3, 0x03, 0x3d, 0xd6, 0x6e, 0xe6, 0x4f, 0xf5, 0xbc, 0x32, 0xe1,
0x49, 0x0f, 0xeb, 0x52, 0x51, 0x48, 0xb7, 0xdc, 0xa6, 0xdb, 0x12, 0xe3,
0x6d, 0x39, 0x1f, 0x19, 0x49, 0x0b, 0x1f, 0xc0, 0xf0, 0x46, 0xb5, 0x60,
0x0a, 0x5f, 0xd7, 0x4c, 0xec, 0x98, 0x69, 0x11, 0xd8, 0x69, 0x15, 0x2a,
0xe8, 0xc2, 0x5e, 0x0d, 0x49, 0xfc, 0x51, 0x17, 0x32, 0xd8, 0x1f, 0x11,
0x19, 0x5e, 0xf0, 0x43, 0xc5, 0x76, 0xe8, 0x5c, 0xdc, 0xff, 0xf7, 0x78,
0xdb, 0x06, 0x64, 0x2e, 0x4b, 0x40, 0xe0, 0xe7, 0x19, 0xc6, 0xf3, 0x0d,
0xde, 0x19, 0x3c, 0x13, 0x30, 0x08, 0x2f, 0x47, 0xf0, 0x4d, 0x29, 0x45,
0x23, 0x2c, 0x00, 0xb0, 0xb9, 0x38, 0x81, 0xfe, 0xc9, 0x4a, 0x25, 0x18,
0xc9, 0xe7, 0xe5, 0xc2, 0xe1, 0x3d, 0xe7, 0xb6, 0x43, 0x33, 0x4c, 0x27,
0x1e, 0x09, 0x4f, 0x36, 0x31, 0x5b, 0x3c, 0x13, 0x99, 0x13, 0x55, 0x00,
0xd3, 0x21, 0x5b, 0xe8, 0x2a, 0x13, 0xa6, 0xc9, 0x29, 0xed, 0xd2, 0x46,
0xe3, 0xec, 0x28, 0xe3, 0x0b, 0x19, 0x43, 0xd3, 0xe4, 0x3b, 0xb0, 0x45,
0x7f, 0x48, 0xf2, 0xff, 0xee, 0x6b, 0xb9, 0x20, 0x06, 0xda, 0x0e, 0x1e,
0xc0, 0xd6, 0x32, 0xdd, 0xd5, 0x1b, 0x38, 0xe0, 0x30, 0x15, 0x6f, 0x30,
0x54, 0xb1, 0xd8, 0x54, 0xce, 0x44, 0x1b, 0x62, 0x1f, 0x31, 0x51, 0x1f,
0x0a, 0x02, 0x53, 0x73, 0x48, 0x0f, 0x9f, 0xc3, 0x0e, 0xab, 0xb3, 0xe4,
0x2d, 0xd3, 0x0d, 0xe0, 0x29, 0x06, 0x5b, 0x21, 0xd5, 0x47, 0xce, 0x30,
0x06, 0x34, 0xc1, 0x00, 0x45, 0x4a, 0xeb, 0x3c, 0x3e, 0xfa, 0xfb, 0x27,
0xc4, 0xff, 0x06, 0xb9, 0x1c, 0x05, 0xd2, 0xa2, 0x27, 0xc0, 0x1d, 0x27,
0x3a, 0xd6, 0x1f, 0x3c, 0x1a, 0x47, 0x1f, 0xfb, 0xe5, 0x29, 0x25, 0x23,
0x50, 0x24, 0x0a, 0x2f, 0x50, 0x3b, 0xae, 0xb0, 0xc9, 0xb8, 0x4b, 0x1d,
0x0e, 0x27, 0x4d, 0x3e, 0x32, 0xf6, 0x46, 0xdb, 0xc2, 0x41, 0x04, 0x31,
0x0b, 0xf4, 0x21, 0x24, 0x16, 0xcb, 0xea, 0x08, 0x2b, 0x74, 0x14, 0xff,
0xa8, 0x8a, 0x0f, 0xc2, 0xf6, 0xc4, 0x3b, 0xaa, 0x5b, 0xd4, 0x33, 0xe7,
0x36, 0x01, 0xa5, 0x30, 0x63, 0x3d, 0x61, 0xf6, 0xfb, 0x0f, 0x93, 0x0e,
0x35, 0x07, 0x3e, 0x28, 0x54, 0x0d, 0xaf, 0xd0, 0xe8, 0xdc, 0x3e, 0x14,
0xaa, 0x85, 0x40, 0xab, 0x20, 0xd9, 0x47, 0x55, 0xae, 0x27, 0x1a, 0x44,
0x5f, 0x2b, 0xe1, 0x0b, 0x1e, 0xfd, 0xe4, 0xfd, 0xcb, 0x1e, 0x60, 0x20,
0x81, 0xe8, 0xf1, 0x13, 0xf0, 0xbe, 0xdc, 0xa6, 0x22, 0x2a, 0xfb, 0xd3,
0x5c, 0xd6, 0xdf, 0x58, 0x3a, 0x38, 0x4d, 0xec, 0xb0, 0x13, 0xab, 0xa8,
0xfc, 0xc5, 0x49, 0x45, 0x7f, 0xdf, 0xea, 0x48, 0xc7, 0x1f, 0x3b, 0xf4,
0xda, 0xaf, 0x36, 0x42, 0xf8, 0xd2, 0x53, 0xf0, 0x24, 0x4d, 0xa9, 0xf2,
0x0e, 0x1c, 0xcf, 0x38, 0xc0, 0xc8, 0xd3, 0xea, 0x6c, 0x21, 0x51, 0x30,
0xe8, 0x51, 0xf0, 0xfd, 0x0e, 0x23, 0x50, 0x36, 0x4d, 0xd0, 0x06, 0xf8,
0x44, 0x19, 0x08, 0x1e, 0xca, 0xf7, 0xe0, 0xed, 0x08, 0x3d, 0x4f, 0x25,
0xf7, 0xa5, 0xc6, 0x3b, 0x16, 0x23, 0x23, 0xfc, 0x4b, 0x16, 0x01, 0xd8,
0x06, 0xa4, 0x1b, 0x21, 0x3d, 0xd0, 0x2e, 0x9b, 0x23, 0x21, 0x41, 0x15,
0x14, 0x2e, 0x3a, 0xf1, 0xcd, 0x9f, 0x95, 0xb7, 0x46, 0x42, 0x3b, 0xf5,
0xe0, 0x2d, 0x20, 0x52, 0x25, 0xf9, 0x0a, 0x0d, 0x19, 0xc9, 0x2a, 0x12,
0x16, 0x65, 0x02, 0x01, 0x1b, 0xfe, 0x22, 0x05, 0x18, 0x37, 0xa3, 0xb3,
0xd2, 0xd8, 0xef, 0xf1, 0x35, 0x3d, 0xf8, 0x40, 0x5d, 0x19, 0xcd, 0xd0,
0xd8, 0x43, 0x1f, 0x21, 0x1f, 0x00, 0x25, 0x41, 0xcc, 0xec, 0x13, 0x1a,
0x36, 0x0a, 0xbf, 0x2b, 0xb9, 0x1b, 0x6b, 0xcc, 0x10, 0x2b, 0x42, 0x17,
0xd9, 0x33, 0x94, 0x1b, 0xd7, 0x3d, 0x35, 0x0b, 0x0c, 0xf9, 0x04, 0x0e,
0x47, 0x48, 0xed, 0x38, 0x2a, 0x1c, 0x32, 0x30, 0x6d, 0xdf, 0xfc, 0x23,
0x17, 0xdc, 0x30, 0xf5, 0x12, 0x3e, 0x0e, 0x39, 0xeb, 0xde, 0x58, 0xdd,
0xc6, 0x15, 0x31, 0x22, 0xfd, 0xe7, 0x5c, 0xea, 0x4d, 0x26, 0xa4, 0x26,
0x01, 0x53, 0x69, 0xe5, 0x96, 0xd0, 0xb0, 0xed, 0x6e, 0x4b, 0xf7, 0x45,
0xca, 0x2f, 0x6c, 0xf7, 0x69, 0x43, 0x1e, 0x65, 0x4e, 0xf4, 0x52, 0x27,
0x18, 0xe4, 0xfd, 0x03, 0x23, 0x34, 0x1b, 0x29, 0x5c, 0x5c, 0x20, 0xb3,
0x44, 0x07, 0x44, 0x4c, 0x4c, 0x4a, 0xee, 0x57, 0xec, 0x0b, 0x45, 0xd4,
0xda, 0x1d, 0x39, 0x0a, 0x23, 0xf1, 0x2d, 0xae, 0x08, 0x00, 0xe5, 0x53,
0xfa, 0x35, 0xb6, 0xe7, 0x53, 0x64, 0x91, 0xf5, 0xc6, 0x6b, 0x1b, 0x30,
0xff, 0xf4, 0x50, 0x00, 0x8c, 0x4a, 0xf0, 0xec, 0x1e, 0xdf, 0x2b, 0x18,
0x08, 0x4a, 0xef, 0x3f, 0xf0, 0x50, 0x19, 0x4c, 0x53, 0x23, 0xea, 0x2c,
0x20, 0x12, 0x20, 0xdb, 0x45, 0x2e, 0xe0, 0x0a, 0xe9, 0x2a, 0x9c, 0x0e,
0xee, 0x2e, 0x20, 0xa3, 0x51, 0xf5, 0x4c, 0x2e, 0xd9, 0x2b, 0xe9, 0x20,
0xe1, 0x13, 0xdc, 0xe1, 0x13, 0xd8, 0xd3, 0x0e, 0x18, 0x5e, 0x1d, 0x45,
0xcb, 0xd6, 0x5b, 0xf9, 0xe7, 0x5f, 0x68, 0xe7, 0x0f, 0xe8, 0x30, 0xeb,
0x13, 0xf3, 0xee, 0x28, 0xc5, 0x48, 0x20, 0x70, 0xc5, 0xfc, 0x3d, 0x4f,
0xc5, 0x3c, 0xe5, 0x44, 0x1b, 0x69, 0xe8, 0x05, 0xee, 0x2a, 0x4b, 0x60,
0xfe, 0x12, 0x4e, 0x8a, 0x6a, 0x08, 0x38, 0x6d, 0xf9, 0x2b, 0xec, 0x30,
0x17, 0x32, 0x98, 0xc7, 0xb6, 0xbb, 0x8b, 0x32, 0xf9, 0x69, 0x0c, 0x37,
0xbe, 0xec, 0x08, 0x26, 0x0f, 0x41, 0xee, 0xb5, 0x59, 0x19, 0x70, 0xf0,
0x1c, 0x92, 0xe8, 0xf8, 0x2a, 0x59, 0x23, 0x44, 0x9e, 0xba, 0xec, 0xc4,
0x43, 0x33, 0xe0, 0x50, 0x41, 0x10, 0xf6, 0x2b, 0x47, 0x01, 0x95, 0x01,
0x1b, 0x4b, 0x1b, 0x0f, 0x4c, 0x1d, 0x2e, 0x76, 0xce, 0x3c, 0xf5, 0x42,
0xf7, 0x1a, 0x63, 0x50, 0x20, 0x58, 0xd0, 0x1b, 0x22, 0x3f, 0x10, 0x3d,
0xaf, 0x08, 0xd7, 0x0d, 0x34, 0x14, 0xc9, 0x43, 0x32, 0x4e, 0x18, 0xe8,
0x32, 0xac, 0x1e, 0x33, 0xc9, 0x43, 0xe9, 0x4b, 0xb0, 0xd1, 0x2c, 0x7e,
0x82, 0x39, 0xba, 0x4a, 0x15, 0x45, 0xbb, 0x1a, 0xbb, 0xf6, 0x90, 0x42,
0xe8, 0xdd, 0x11, 0x12, 0x22, 0xe0, 0x57, 0xaf, 0xd6, 0x00, 0xd9, 0x6e,
0x4a, 0x1c, 0x24, 0x34, 0x0e, 0x52, 0xc1, 0x37, 0xbe, 0x2a, 0x1f, 0x5f,
0xd6, 0x1e, 0xe7, 0xf1, 0xd0, 0x30, 0xb1, 0x09, 0x37, 0xfd, 0x76, 0xeb,
0x35, 0xf5, 0x11, 0x18, 0xb9, 0x4f, 0x21, 0x70, 0x15, 0x46, 0xc0, 0x43,
0xbd, 0x33, 0xbe, 0x19, 0x0c, 0x50, 0xee, 0x15, 0x50, 0x19, 0x08, 0x09,
0x0d, 0xb6, 0x21, 0x26, 0x4a, 0x04, 0x24, 0xf6, 0xc3, 0x0e, 0xd0, 0x58,
0x1d, 0x08, 0xb9, 0x15, 0xa0, 0xb9, 0x68, 0x1d, 0xd7, 0x22, 0x17, 0x40,
0xcb, 0x13, 0xd8, 0x0e, 0x04, 0xf5, 0xf2, 0x95, 0x59, 0x0d, 0x28, 0x39,
0x3b, 0xee, 0x19, 0x46, 0x64, 0x38, 0x32, 0x67, 0x41, 0xf2, 0xfe, 0xf0,
0xc7, 0x26, 0xf5, 0x12, 0x69, 0x41, 0xc3, 0x06, 0x3a, 0xe2, 0xbf, 0x06,
0xf3, 0xbf, 0x21, 0x03, 0x4a, 0xef, 0x41, 0x4a, 0x26, 0x4c, 0x3e, 0x5c,
0x38, 0x3c, 0x41, 0x4a, 0x63, 0xd7, 0xf3, 0x0c, 0x39, 0x27, 0x06, 0x37,
0xad, 0x1a, 0x2a, 0xef, 0xd1, 0xe2, 0x1f, 0xd8, 0x28, 0xf5, 0x0a, 0x0e,
0x55, 0x41, 0xf4, 0x3b, 0x03, 0x53, 0x1d, 0x26, 0x31, 0xf2, 0x64, 0xe3,
0x58, 0x25, 0x30, 0x12, 0x48, 0x24, 0xb9, 0xd9, 0x47, 0xb0, 0x9a, 0x0e,
0x40, 0xdd, 0x31, 0x94, 0x5c, 0x05, 0x26, 0xe6, 0x0f, 0x3e, 0xe0, 0x49,
0x21, 0xf6, 0x41, 0x0b, 0x3e, 0x5e, 0xbe, 0x32, 0xee, 0x19, 0x54, 0x5a,
0xb2, 0xba, 0x10, 0xf3, 0xea, 0xc5, 0xff, 0x05, 0x25, 0xd8, 0xff, 0x2f,
0x49, 0x6f, 0x0a, 0x38, 0x33, 0x5e, 0xfe, 0x66, 0x02, 0xcc, 0xa1, 0xa2,
0x21, 0x3c, 0xd5, 0x1c, 0x58, 0x44, 0xb3, 0xfe, 0x2c, 0xbf, 0x70, 0xd8,
0x36, 0xfc, 0x18, 0xb8, 0x55, 0xeb, 0x2e, 0xf3, 0xc5, 0x65, 0x21, 0x41,
0xfa, 0x33, 0x55, 0xaa, 0x20, 0x3b, 0x26, 0x1f, 0xd5, 0x6c, 0x0b, 0x08,
0xae, 0x1d, 0xeb, 0xe1, 0x24, 0x08, 0xd8, 0x0f, 0x17, 0x4c, 0x69, 0x17,
0x3b, 0x66, 0xed, 0x28, 0x0a, 0x24, 0x27, 0x40, 0xb4, 0x54, 0xfd, 0x3a,
0x96, 0x3f, 0x22, 0x4a, 0x0d, 0xfd, 0xa5, 0xf4, 0x6e, 0xd1, 0x27, 0x25,
0x0f, 0x07, 0x25, 0xf0, 0x1e, 0x22, 0x4a, 0x1f, 0xcf, 0x55, 0x5d, 0x45,
0x63, 0x4c, 0xea, 0x2e, 0x31, 0x01, 0x91, 0x34, 0x1f, 0xf2, 0x21, 0x27,
0xa0, 0xd0, 0x01, 0xb4, 0x24, 0x0f, 0xaf, 0xc5, 0x3c, 0x35, 0x61, 0xe2,
0x63, 0x0c, 0xe4, 0x25, 0x3f, 0x16, 0x72, 0x49, 0x4b, 0x4d, 0x3e, 0x41,
0x66, 0x30, 0xb2, 0x09, 0x3c, 0x25, 0xa6, 0xe5, 0x67, 0xcc, 0xca, 0x0a,
0x24, 0xe6, 0x61, 0x35, 0x49, 0x14, 0x24, 0x2d, 0xe7, 0x51, 0xf3, 0x43,
0x5b, 0x43, 0x9f, 0xba, 0xa6, 0x49, 0xaf, 0x37, 0xb7, 0x1f, 0x33, 0x16,
0xb0, 0xd1, 0x2d, 0xf7, 0xd9, 0xd7, 0x40, 0x06, 0x4f, 0xe1, 0x2d, 0x02,
0x56, 0x6f, 0x04, 0x22, 0x40, 0x26, 0x1e, 0x1e, 0xb5, 0x26, 0xcd, 0x09,
0xae, 0xad, 0x23, 0x16, 0x5c, 0xd2, 0xea, 0x12, 0xc1, 0x0c, 0xaf, 0x04,
0x57, 0x29, 0x21, 0xc3, 0x0b, 0xf9, 0x0b, 0xd7, 0xeb, 0x14, 0xf3, 0xed,
0xf4, 0x25, 0xfc, 0xd3, 0xf9, 0x8a, 0x39, 0xc4, 0xb5, 0xc9, 0x52, 0xef,
0xef, 0x37, 0x4e, 0x31, 0xe6, 0x02, 0x0d, 0xbc, 0x38, 0xdd, 0x47, 0x16,
0x10, 0x44, 0xed, 0x55, 0xda, 0x03, 0x04, 0xc9, 0xa2, 0x47, 0xcc, 0xff,
0xd8, 0xb8, 0xe9, 0x57, 0x2f, 0x2c, 0x19, 0x13, 0x27, 0x08, 0x19, 0xe9,
0x61, 0x93, 0x3e, 0x22, 0x52, 0xd5, 0x17, 0x63, 0xf9, 0x43, 0xd1, 0x24,
0x2f, 0x31, 0xf5, 0x53, 0xfc, 0x82, 0xa5, 0xcc, 0x10, 0x13, 0x3c, 0x38,
0xdd, 0x1a, 0xb9, 0x35, 0x54, 0xa9, 0xc1, 0xb0, 0x47, 0xcd, 0xfe, 0xf0,
0x15, 0x89, 0xf9, 0x18, 0xfd, 0x2a, 0x17, 0x2a, 0x4a, 0x02, 0xba, 0xbc,
0x4f, 0xd1, 0xed, 0x1e, 0x65, 0x1f, 0xe5, 0x24, 0xb5, 0x35, 0x40, 0x0c,
0x3c, 0xd5, 0x2e, 0x22, 0x20, 0x26, 0x37, 0xd9, 0xe0, 0x13, 0xe2, 0x2d,
0x09, 0xe3, 0x37, 0x5c, 0x00, 0xff, 0xb3, 0xf0, 0x37, 0x05, 0x46, 0x00,
0xf9, 0x2b, 0x33, 0x08, 0x65, 0x04, 0x26, 0x6d, 0x46, 0xb8, 0x15, 0xee,
0x42, 0xc7, 0xe9, 0x15, 0x5b, 0x14, 0xe9, 0x41, 0x40, 0x15, 0x29, 0xb1,
0x66, 0x09, 0xf0, 0xf0, 0x09, 0x19, 0xe7, 0x55, 0x28, 0x07, 0x03, 0x2a,
0x29, 0x63, 0x24, 0x2c, 0x04, 0xdc, 0x43, 0xd6, 0x11, 0x36, 0xf2, 0x1a,
0xed, 0x11, 0x98, 0x53, 0x60, 0xb5, 0x45, 0xed, 0xba, 0x06, 0x3b, 0x38,
0x00, 0x1e, 0xd3, 0x1c, 0xc8, 0xd2, 0x13, 0xd0, 0x10, 0x1b, 0xf7, 0x02,
0x3d, 0x38, 0x21, 0x1f, 0x5f, 0x27, 0xfd, 0x58, 0xeb, 0xc8, 0xc4, 0xab,
0x17, 0x03, 0x21, 0x4b, 0x00, 0x48, 0xf9, 0x5f, 0xf4, 0x1a, 0x9a, 0x33,
0x12, 0xe9, 0x28, 0xcb, 0x6e, 0xf4, 0x42, 0xdc, 0x0a, 0x32, 0xff, 0x1f,
0xfd, 0x24, 0x33, 0xb9, 0x1d, 0x74, 0x50, 0x1d, 0x1c, 0x67, 0x3f, 0x1f,
0xf3, 0x42, 0x13, 0xfc, 0x14, 0xd4, 0x3c, 0xae, 0x37, 0xc7, 0xfb, 0xf1,
0x53, 0x08, 0x05, 0x01, 0xae, 0x33, 0x1a, 0x57, 0x97, 0x19, 0x37, 0xad,
0xa2, 0x2f, 0x15, 0xfc, 0x66, 0x2b, 0xe8, 0x38, 0x08, 0x58, 0x91, 0x22,
0xba, 0xeb, 0x14, 0x0e, 0x16, 0x32, 0x34, 0x19, 0x01, 0x3b, 0xbc, 0x26,
0x18, 0x30, 0xf0, 0xd8, 0x9d, 0xe7, 0x93, 0x22, 0xf5, 0x13, 0x61, 0x23,
0xdc, 0x02, 0xe7, 0x48, 0x3d, 0x17, 0xe4, 0xce, 0x58, 0xec, 0x40, 0x1c,
0x25, 0x81, 0x0f, 0x3a, 0x41, 0x3d, 0x26, 0x5c, 0x47, 0xdf, 0x1f, 0xb9,
0x96, 0x23, 0xb7, 0x55, 0x31, 0x30, 0xf7, 0xc0, 0x57, 0x40, 0x3b, 0x2b,
0xc5, 0xea, 0x54, 0x13, 0x59, 0x32, 0x2a, 0x30, 0xfb, 0x13, 0x66, 0x25,
0xd4, 0x1f, 0xb6, 0x69, 0xab, 0xe0, 0xdb, 0x3f, 0x22, 0x46, 0x3c, 0x3e,
0xce, 0xd8, 0x1e, 0xfb, 0x6d, 0x4f, 0x26, 0xa2, 0x3d, 0xb2, 0x56, 0x23,
0x11, 0xc3, 0xda, 0x38, 0xf5, 0x62, 0xdf, 0x3d, 0x03, 0x1a, 0xdd, 0x3c,
0x84, 0x0b, 0x68, 0xef, 0x22, 0x51, 0xc4, 0x1b, 0x24, 0x02, 0x57, 0x37,
0xc0, 0xa4, 0x5a, 0xe7, 0x3d, 0xff, 0x2a, 0xd9, 0x24, 0x39, 0x48, 0x51,
0xe4, 0x2b, 0xb0, 0x01, 0x5c, 0xe3, 0xf6, 0x4d, 0x55, 0x49, 0x27, 0x3f,
0xda, 0x4c, 0x34, 0xe3, 0xb8, 0x20, 0x3c, 0xa2, 0x51, 0x53, 0x79, 0xf0,
0x38, 0x08, 0x1f, 0x14, 0xac, 0x63, 0x02, 0xf5, 0x00, 0x44, 0xe2, 0xd6,
0xc5, 0x34, 0x64, 0x58, 0x3d, 0x4e, 0xe7, 0x08, 0xef, 0xc8, 0x98, 0xe6,
0x18, 0xfe, 0x10, 0x2d, 0x1e, 0xe8, 0x16, 0xac, 0xdc, 0x31, 0x03, 0x68,
0x1a, 0x72, 0x3e, 0x1a, 0x09, 0x5a, 0xab, 0x14, 0xe0, 0xdc, 0x3c, 0x56,
0xcc, 0x4c, 0x31, 0x0f, 0xe9, 0x13, 0x40, 0xb0, 0x41, 0xea, 0x3f, 0x14,
0x4a, 0xbf, 0x1a, 0x16, 0x1a, 0x5a, 0x06, 0x04, 0xd6, 0x23, 0x4d, 0xde,
0x88, 0x3c, 0x6f, 0xf6, 0x4b, 0x61, 0xd8, 0x10, 0x4e, 0x27, 0x34, 0x17,
0x40, 0x82, 0x27, 0xad, 0x1f, 0x26, 0x12, 0x1d, 0xf8, 0x13, 0xf7, 0x6b,
0x30, 0x60, 0xc6, 0x0e, 0x4e, 0x86, 0xcf, 0x22, 0xd3, 0x5f, 0x4d, 0x5e,
0xbd, 0x9f, 0xb6, 0xec, 0x62, 0xd7, 0xd9, 0x04, 0x5b, 0xf0, 0x4d, 0x00,
0x15, 0xa2, 0xbc, 0x49, 0xf5, 0x4a, 0x14, 0x1e, 0x1d, 0xa7, 0xac, 0xa9,
0x57, 0x39, 0x53, 0x2b, 0x1b, 0x49, 0xca, 0xd5, 0x26, 0xe4, 0x02, 0x26,
0x57, 0xee, 0x57, 0xb8, 0x5d, 0x0b, 0x1a, 0xad, 0x1a, 0x50, 0xc6, 0x69,
0x1b, 0x50, 0x5b, 0xd5, 0x21, 0x94, 0x6d, 0x12, 0x35, 0xed, 0x21, 0x27,
0xf1, 0xa2, 0x53, 0xaf, 0x1d, 0x4e, 0xeb, 0x20, 0x29, 0xb5, 0x70, 0x30,
0x61, 0xa5, 0x0c, 0x1c, 0x2a, 0x3d, 0x5a, 0x08, 0x24, 0x50, 0x05, 0x88,
0xec, 0x16, 0x4f, 0xd5, 0x29, 0x54, 0xbf, 0xbb, 0x22, 0xe5, 0x09, 0x38,
0xfd, 0xd3, 0x12, 0xec, 0x1b, 0x2b, 0x1f, 0x11, 0xfe, 0x38, 0xe9, 0x2a,
0x13, 0x44, 0xb8, 0xf2, 0x4d, 0x5a, 0xbb, 0x34, 0xd8, 0x02, 0x4e, 0x05,
0xcb, 0x12, 0x93, 0xb0, 0xdf, 0x15, 0xeb, 0xfd, 0x53, 0x23, 0x47, 0x24,
0x1c, 0x39, 0xfa, 0x24, 0xbb, 0x38, 0x3f, 0x0a, 0xbf, 0x25, 0x9c, 0x89,
0xcf, 0x0b, 0xf2, 0x4a, 0x40, 0x00, 0xce, 0x09, 0x34, 0xb6, 0xad, 0x12,
0x15, 0x43, 0x51, 0x17, 0x3f, 0xf2, 0x46, 0x3f, 0xae, 0x53, 0x3f, 0x4c,
0x63, 0x00, 0xbb, 0x9d, 0x45, 0x53, 0xb7, 0x2e, 0x09, 0x3a, 0x60, 0x2a,
0x99, 0x1d, 0x44, 0xf8, 0xe6, 0xf8, 0x4f, 0x19, 0x30, 0x1d, 0x48, 0x0e,
0x3c, 0xd4, 0xe3, 0x36, 0x1e, 0x19, 0x23, 0x3c, 0x53, 0xe6, 0xac, 0x21,
0x57, 0x28, 0x34, 0x60, 0x26, 0x1b, 0x9e, 0xcb, 0x93, 0xc4, 0xb7, 0xc2,
0x1c, 0xf5, 0x19, 0x00, 0x2b, 0x15, 0x59, 0x4c, 0x05, 0x28, 0xdf, 0x1e,
0x30, 0x58, 0xd5, 0x63, 0xd6, 0xfa, 0xe7, 0x19, 0x2a, 0x0e, 0x38, 0xe9,
0xc6, 0xe8, 0xf2, 0xc0, 0x25, 0xef, 0x5b, 0xe3, 0x43, 0x0b, 0x6e, 0xd1,
0x65, 0x59, 0xc0, 0x31, 0xc7, 0x1a, 0x24, 0xef, 0x71, 0xba, 0x08, 0x75,
0xe9, 0xfa, 0x61, 0xe1, 0x15, 0xf8, 0x9c, 0x02, 0x59, 0xae, 0x57, 0xc0,
0x12, 0x3e, 0x33, 0xb1, 0x30, 0xcf, 0x55, 0xbd, 0xb1, 0x4a, 0xb5, 0x12,
0x2d, 0x11, 0x3b, 0xa0, 0x3a, 0x63, 0x0d, 0x0f, 0xe3, 0x39, 0x40, 0xf4,
0x89, 0xa8, 0x9c, 0xf1, 0xc2, 0xda, 0xff, 0xdd, 0x58, 0xc9, 0x0c, 0xf6,
0x39, 0x9c, 0x13, 0x4b, 0x05, 0x0a, 0x24, 0x2e, 0xb4, 0x49, 0x47, 0xbe,
0xa3, 0xa8, 0x33, 0x55, 0x58, 0xf3, 0x1c, 0x14, 0xec, 0x3d, 0xf8, 0xde,
0x3a, 0xb4, 0x30, 0x05, 0x31, 0xe1, 0x3c, 0xf1, 0x16, 0x20, 0xe2, 0x16,
0x1a, 0xcd, 0x5e, 0xeb, 0x07, 0x1f, 0x39, 0xb1, 0xe3, 0x11, 0x69, 0xda,
0xfe, 0x21, 0x43, 0x1e, 0x21, 0xd6, 0x01, 0xca, 0x62, 0x2e, 0xd0, 0x09,
0x22, 0xb4, 0x36, 0x26, 0xff, 0xf8, 0x15, 0xd9, 0x07, 0xb1, 0xb2, 0xcf,
0x97, 0xb8, 0xbe, 0x49, 0x4a, 0x08, 0xf8, 0x04, 0xe8, 0x12, 0x54, 0x20,
0xfc, 0x3a, 0x49, 0x17, 0x25, 0x20, 0x2c, 0x6b, 0xec, 0x1a, 0x0a, 0x15,
0x15, 0xcd, 0x02, 0xc6, 0x26, 0x01, 0xc7, 0xd2, 0x46, 0xe4, 0x1a, 0xe0,
0xee, 0x41, 0xff, 0x23, 0x8a, 0xe2, 0x1f, 0xfc, 0x17, 0xf6, 0x51, 0xf4,
0x34, 0x8a, 0xe5, 0x2b, 0xf9, 0x05, 0xe1, 0x19, 0x9d, 0xd3, 0xb1, 0x3e,
0xbf, 0xd0, 0x52, 0x60, 0x26, 0x08, 0xfc, 0x4e, 0xc2, 0x21, 0x2f, 0x0c,
0xf0, 0x86, 0x13, 0xd3, 0x5d, 0xf6, 0x16, 0x10, 0xdf, 0xf1, 0x38, 0x1f,
0x1b, 0x18, 0x1a, 0x5a, 0xef, 0x70, 0x3f, 0xec, 0xf3, 0x1a, 0x51, 0x1e,
0x12, 0x06, 0x33, 0x31, 0xca, 0xde, 0xb1, 0xb5, 0x3e, 0x14, 0x52, 0xe7,
0x5f, 0x8c, 0x01, 0xfb, 0x0d, 0x22, 0xf4, 0x1d, 0x1d, 0x5b, 0x99, 0x9c,
0xfc, 0xb5, 0x06, 0x64, 0x68, 0x06, 0xea, 0x4c, 0xa4, 0xf6, 0x2c, 0xd8,
0x3f, 0x0f, 0x53, 0x1c, 0x25, 0xf1, 0x28, 0xdb, 0xf2, 0x40, 0xa8, 0x18,
0x0d, 0xdc, 0x3f, 0xed, 0x35, 0x4a, 0xe4, 0xf2, 0x06, 0x72, 0x50, 0x0c,
0xfc, 0x38, 0xf4, 0xf3, 0xcc, 0x2f, 0x4a, 0xc2, 0x68, 0xba, 0x62, 0x0b,
0x25, 0xac, 0xef, 0x24, 0x29, 0x16, 0xf3, 0x4c, 0x86, 0x67, 0x52, 0xdd,
0x9a, 0xcc, 0xbc, 0x2c, 0x3d, 0x11, 0xd9, 0x2b, 0x5c, 0x04, 0xd7, 0xc0,
0xce, 0x32, 0x67, 0x00, 0x2f, 0x01, 0x3c, 0xc9, 0x22, 0x05, 0x28, 0x20,
0x20, 0x58, 0x4c, 0x15, 0x56, 0x77, 0x23, 0x18, 0xc8, 0x0c, 0x20, 0x5b,
0xf1, 0x40, 0x4a, 0x01, 0xcd, 0xd7, 0xd3, 0xf3, 0x12, 0xc2, 0x15, 0xe9,
0x44, 0x1d, 0xca, 0xf4, 0xb2, 0x3e, 0x19, 0x0c, 0xf6, 0x35, 0xb8, 0x00,
0x58, 0xeb, 0xcd, 0x68, 0x18, 0x53, 0xe6, 0x40, 0xd6, 0x0f, 0x4f, 0x10,
0x35, 0x17, 0x33, 0xfe, 0x40, 0x0e, 0x21, 0xb6, 0x1f, 0x36, 0xb8, 0x28,
0x10, 0xee, 0x5a, 0x04, 0x99, 0x14, 0x22, 0x39, 0xfc, 0xef, 0x4a, 0x38,
0xe3, 0x15, 0x55, 0x0d, 0xcb, 0xea, 0x0a, 0xb3, 0x14, 0x05, 0x03, 0x2f,
0x44, 0xf0, 0x0d, 0x53, 0x13, 0x49, 0x17, 0x24, 0x3e, 0x58, 0x2b, 0x2b,
0x54, 0xf0, 0xd9, 0x02, 0x22, 0x2a, 0xc3, 0x9d, 0xb2, 0xfc, 0xd8, 0x13,
0xba, 0x41, 0x36, 0xbe, 0x0c, 0xf1, 0x12, 0xeb, 0x15, 0x3f, 0xce, 0x31,
0xd8, 0x52, 0xa6, 0x0f, 0xae, 0x47, 0x9b, 0xfc, 0x66, 0x74, 0x0d, 0x07,
0xeb, 0xdd, 0x17, 0x35, 0x10, 0x37, 0xfc, 0xb9, 0x1d, 0x08, 0x3f, 0x25,
0x3f, 0x4d, 0xdd, 0x25, 0x67, 0x53, 0x14, 0x48, 0xf2, 0x5c, 0x2b, 0xd1,
0x4d, 0xfc, 0xe1, 0xf0, 0x35, 0x36, 0xdf, 0xd1, 0xaf, 0x22, 0x9e, 0x29,
0xe8, 0xde, 0x47, 0xc0, 0xfe, 0xf0, 0x53, 0x29, 0xc9, 0x38, 0x65, 0x4b,
0x0c, 0x5e, 0x8b, 0x28, 0xf9, 0x4c, 0xaa, 0x20, 0x6d, 0x31, 0x12, 0x30,
0xc4, 0x0a, 0xa1, 0x1b, 0xbf, 0x02, 0xdb, 0xbb, 0x27, 0x01, 0x78, 0x2d,
0x12, 0x85, 0x0b, 0x0f, 0xb7, 0x4c, 0x42, 0x45, 0x01, 0xbc, 0x42, 0x23,
0x94, 0x4a, 0x2f, 0x3a, 0x41, 0x1e, 0xcb, 0x2b, 0x38, 0xce, 0x39, 0x28,
0xf3, 0x24, 0x18, 0x04, 0xf5, 0x3d, 0x46, 0xd7, 0xe7, 0x42, 0x12, 0x67,
0x1f, 0x66, 0x99, 0xe6, 0x29, 0x0b, 0xc4, 0x44, 0x06, 0xde, 0x03, 0x0f,
0xaf, 0x17, 0x5b, 0xe0, 0xed, 0xdd, 0x53, 0xdb, 0x47, 0xff, 0x73, 0x34,
0x2c, 0x31, 0xe6, 0x17, 0x5a, 0x5d, 0x24, 0xf1, 0xb2, 0x0a, 0xc1, 0xcc,
0xb5, 0x46, 0x5a, 0xf6, 0x3b, 0x25, 0xc8, 0x2d, 0x3a, 0x0b, 0xd4, 0x01,
0x1a, 0x17, 0x44, 0xb8, 0xf8, 0xfc, 0x52, 0xc1, 0xcf, 0x0d, 0xcd, 0x4f,
0x0d, 0x05, 0xbb, 0xe2, 0xa9, 0x54, 0xf5, 0x0e, 0x25, 0xfc, 0x26, 0x26,
0xa1, 0x07, 0xfa, 0xd5, 0x1d, 0x24, 0x2c, 0x1f, 0x51, 0x40, 0x30, 0x25,
0x24, 0x8d, 0xac, 0x33, 0x0f, 0x40, 0x0a, 0x64, 0xf2, 0x05, 0x67, 0x48,
0xcb, 0xf8, 0xed, 0x51, 0x25, 0x43, 0xc1, 0xd4, 0xda, 0xe0, 0x48, 0xe0,
0xf5, 0xd3, 0x38, 0xda, 0x11, 0x35, 0x28, 0xef, 0xd6, 0x28, 0xcb, 0x54,
0x2a, 0x13, 0xc5, 0x41, 0xca, 0x7d, 0xd3, 0x1d, 0x00, 0x11, 0x2d, 0x36,
0xcc, 0xd9, 0x10, 0xc6, 0x3b, 0xeb, 0xf7, 0x07, 0x5b, 0x13, 0x67, 0x15,
0x61, 0xa7, 0xf8, 0x5b, 0x61, 0x30, 0x55, 0x11, 0x28, 0xb3, 0x46, 0x10,
0xe6, 0x20, 0x28, 0x6c, 0x22, 0x2d, 0xb7, 0xc2, 0x45, 0xc5, 0x89, 0x0d,
0xdf, 0xe7, 0x44, 0x17, 0x43, 0xf6, 0x69, 0x41, 0xcc, 0x2e, 0x10, 0x3c,
0x5b, 0xf0, 0x18, 0x51, 0xc2, 0x2b, 0x05, 0xf6, 0x26, 0x63, 0x5b, 0x3c,
0xd5, 0xd3, 0xdc, 0xe4, 0x0a, 0xce, 0x02, 0xb4, 0x62, 0xba, 0x53, 0x2a,
0x56, 0x50, 0xba, 0x61, 0x2c, 0x3e, 0x34, 0x4b, 0x9e, 0xba, 0x96, 0x96,
0x55, 0x0c, 0x41, 0x33, 0x62, 0x35, 0xb2, 0xfb, 0xb1, 0xac, 0x13, 0x02,
0xbd, 0xa9, 0x37, 0x17, 0x06, 0x11, 0x61, 0x2b, 0x05, 0x24, 0xe5, 0x53,
0x1b, 0x51, 0x0b, 0xeb, 0x37, 0x37, 0xa3, 0x2f, 0x15, 0x29, 0x29, 0x0e,
0x92, 0x8c, 0x5c, 0xcf, 0x15, 0x3d, 0x1d, 0x8d, 0x58, 0x2e, 0x42, 0x04,
0x1d, 0xbe, 0xab, 0x37, 0xc0, 0x17, 0x46, 0xf3, 0x71, 0xc5, 0xcd, 0xc5,
0x6a, 0x2c, 0x0e, 0xfe, 0x61, 0x42, 0xaa, 0xb9, 0x3f, 0xd7, 0x56, 0x16,
0x00, 0xc3, 0x31, 0xf2, 0x65, 0x1b, 0x36, 0x53, 0x0b, 0x5f, 0xd3, 0x44,
0x4f, 0x2c, 0xe9, 0x56, 0xa2, 0x64, 0xef, 0xfa, 0xb2, 0xef, 0x61, 0xf4,
0x96, 0xa5, 0x92, 0xa8, 0x23, 0x16, 0x27, 0xc6, 0x3d, 0xed, 0x08, 0xd0,
0x39, 0xc3, 0xd7, 0x57, 0x0b, 0x44, 0x4c, 0x09, 0xf6, 0x3c, 0xdd, 0x3b,
0x8d, 0x0b, 0x04, 0xe6, 0x1d, 0xf4, 0xb0, 0xee, 0xb1, 0xcb, 0x6b, 0x22,
0x50, 0xa4, 0x54, 0xd6, 0x1c, 0xd8, 0x46, 0x25, 0x0a, 0x38, 0xbb, 0x3e,
0x35, 0x3b, 0x2e, 0xe3, 0xde, 0x94, 0xee, 0x1e, 0xd5, 0x15, 0x24, 0xfa,
0xbc, 0xc1, 0xcb, 0xb4, 0x89, 0x28, 0x01, 0x42, 0x29, 0x07, 0xfc, 0xe8,
0x68, 0x9a, 0xf9, 0x5b, 0x03, 0x2c, 0x23, 0x0f, 0xa4, 0x0d, 0xb8, 0x2c,
0xf4, 0xf5, 0xbf, 0xc9, 0x5e, 0x06, 0x09, 0x44, 0x43, 0x06, 0x1e, 0xe5,
0xe6, 0x22, 0x41, 0x1b, 0x3a, 0xe1, 0x6c, 0x8f, 0xff, 0xf3, 0xdf, 0xe7,
0xf8, 0xfa, 0xcc, 0x1d, 0xd4, 0xb5, 0x8f, 0xf5, 0xf0, 0x55, 0x30, 0xfb,
0x18, 0x4e, 0x1f, 0x1d, 0xb2, 0xea, 0x32, 0xe0, 0x64, 0xfd, 0xdc, 0xda,
0x3e, 0x4f, 0xe2, 0x00, 0x51, 0x1b, 0x0d, 0x15, 0x2b, 0x4b, 0xf1, 0x36,
0x2c, 0xb9, 0xc2, 0x2f, 0x3a, 0x0e, 0x15, 0x3b, 0x17, 0x1a, 0x35, 0xd0,
0xf8, 0x27, 0x1c, 0xbc, 0x49, 0x23, 0x20, 0x4e, 0x1a, 0x44, 0xbb, 0x03,
0x16, 0x11, 0x2a, 0x41, 0x40, 0x53, 0x34, 0xba, 0x46, 0x03, 0x19, 0xef,
0x25, 0x03, 0x19, 0x25, 0x0a, 0xc5, 0xc7, 0xde, 0x56, 0xc0, 0x03, 0xe7,
0x55, 0x73, 0xee, 0x23, 0xc2, 0x0f, 0x24, 0xe1, 0xf2, 0xac, 0xc0, 0x21,
0xe3, 0xb9, 0xf6, 0x60, 0x50, 0x33, 0xe0, 0x06, 0xfe, 0x3f, 0x68, 0xad,
0xec, 0xb7, 0x3a, 0xcd, 0x30, 0x11, 0x3b, 0x4f, 0x12, 0x0e, 0xf9, 0x21,
0x2e, 0x31, 0xf9, 0x59, 0x42, 0x2e, 0xab, 0xd5, 0x13, 0x28, 0x12, 0x2a,
0xe7, 0x17, 0x57, 0x21, 0xaa, 0xb1, 0x08, 0x57, 0x04, 0x12, 0xf9, 0x2b,
0x57, 0xe2, 0x34, 0x05, 0x35, 0x34, 0xf0, 0x2f, 0xad, 0xba, 0xce, 0xa3,
0xe5, 0xf8, 0x5c, 0x0c, 0x21, 0xee, 0xe4, 0x34, 0x99, 0x1c, 0xb1, 0xc9,
0xec, 0x03, 0x3b, 0xef, 0x60, 0x1d, 0x3d, 0x91, 0xfa, 0x24, 0x0a, 0x31,
0x17, 0x2a, 0x4d, 0x1c, 0x97, 0xde, 0x93, 0xb8, 0xec, 0x13, 0x37, 0x44,
0x0e, 0x4a, 0x03, 0x2b, 0xcd, 0x14, 0x42, 0x2d, 0x39, 0xc8, 0x05, 0xee,
0x11, 0x1e, 0x32, 0x24, 0x04, 0x3c, 0xf8, 0xdd, 0xc9, 0x10, 0x4d, 0x4c,
0x27, 0xc4, 0x35, 0x11, 0x28, 0x02, 0xd6, 0x38, 0xf5, 0x1b, 0xde, 0xd2,
0xd2, 0x04, 0x17, 0x14, 0x1e, 0x25, 0x22, 0xb0, 0xf5, 0x33, 0x1b, 0x22,
0x63, 0xf2, 0xca, 0xf3, 0x5a, 0x77, 0xd0, 0xd1, 0xcf, 0x52, 0x0b, 0x46,
0x04, 0x58, 0x0b, 0x00, 0xd0, 0x08, 0xbb, 0xb6, 0x5b, 0xb1, 0xed, 0x11,
0x29, 0x3a, 0xf2, 0x05, 0xe8, 0x2b, 0x10, 0x36, 0xf1, 0x22, 0x53, 0xf9,
0x24, 0xe9, 0x1b, 0x67, 0x39, 0x43, 0xe7, 0x54, 0xd2, 0x19, 0x06, 0x1a,
0xb1, 0x0f, 0x5d, 0x16, 0x50, 0xfe, 0x20, 0x43, 0xfc, 0xf9, 0xf9, 0x40,
0xe4, 0xf5, 0x50, 0xd5, 0x20, 0x45, 0x1f, 0x21, 0x5b, 0x44, 0x19, 0xfd,
0x08, 0x3d, 0x0b, 0x0e, 0xc2, 0x19, 0xf5, 0x64, 0x47, 0x0a, 0xfb, 0x26,
0x40, 0xee, 0x1a, 0x5c, 0x19, 0x3c, 0x05, 0xef, 0xa7, 0x44, 0x4f, 0x78,
0xbf, 0xeb, 0x3b, 0x63, 0x12, 0xfd, 0xd2, 0x1b, 0x50, 0x3f, 0x2e, 0xda,
0x5c, 0x0b, 0x60, 0x19, 0xf5, 0x0b, 0x15, 0xb7, 0xeb, 0x1d, 0x48, 0x52,
0x12, 0x0f, 0xf4, 0xa9, 0x17, 0xd4, 0x2a, 0x23, 0xbd, 0x3b, 0x05, 0x32,
0xd1, 0xa7, 0xea, 0x27, 0x3e, 0xd4, 0xb2, 0xee, 0x51, 0xb8, 0x1e, 0xf8,
0x20, 0x3e, 0xe1, 0x0a, 0xbe, 0x5a, 0x01, 0x19, 0xc0, 0xaa, 0x5a, 0x5b,
0xb4, 0xf0, 0x16, 0x29, 0xf8, 0x14, 0xc2, 0xf1, 0xa5, 0x01, 0x8c, 0x41,
0x42, 0x47, 0x43, 0x1f, 0x1e, 0x38, 0x4b, 0x94, 0xd1, 0x35, 0x51, 0x31,
0x3c, 0x58, 0xba, 0xa6, 0xaa, 0x4b, 0x6b, 0x31, 0xb1, 0x34, 0x29, 0x12,
0xc4, 0x0c, 0x14, 0xf7, 0x8b, 0xf2, 0x16, 0x33, 0x37, 0x27, 0x4d, 0xf0,
0x1e, 0xf4, 0xbb, 0x37, 0xe9, 0x37, 0x3e, 0x37, 0xb2, 0xec, 0xa0, 0x34,
0x9c, 0x2d, 0x0f, 0x6e, 0x62, 0x4c, 0xe1, 0x0e, 0xf9, 0x29, 0x48, 0xcd,
0xf3, 0x94, 0x45, 0x9b, 0x46, 0xf3, 0x17, 0x27, 0xe0, 0x10, 0xf7, 0x49,
0x17, 0x21, 0x61, 0xf1, 0xe1, 0xad, 0x67, 0x39, 0x5f, 0xf9, 0x34, 0x27,
0xd3, 0x1c, 0x00, 0xf4, 0xd7, 0xe4, 0x62, 0xe9, 0x39, 0x8a, 0x07, 0xf4,
0x4b, 0x39, 0x30, 0x22, 0x41, 0x65, 0xe2, 0x52, 0xc0, 0xea, 0xef, 0xa1,
0xa7, 0x2e, 0xfe, 0xf2, 0x4c, 0x34, 0xcf, 0x44, 0xd3, 0x0c, 0x6f, 0x24,
0x22, 0xfc, 0x2c, 0x09, 0x4d, 0x06, 0x4d, 0x3d, 0xcf, 0x27, 0x6a, 0x28,
0x16, 0x2e, 0xd2, 0x0c, 0xd1, 0x9e, 0x41, 0x24, 0xee, 0x2b, 0x14, 0x3f,
0xbf, 0x3f, 0xdb, 0x13, 0x5a, 0xe2, 0xe8, 0x6a, 0x59, 0xb9, 0x2f, 0x0a,
0x47, 0xc7, 0x98, 0x3c, 0x3c, 0x2a, 0x3c, 0x16, 0x06, 0xf1, 0x6a, 0x54,
0xa9, 0xf1, 0xd1, 0x2b, 0x24, 0x4a, 0xbb, 0xdb, 0xe2, 0xa1, 0x24, 0xf3,
0xe4, 0x55, 0x44, 0xf8, 0xf6, 0xe0, 0x36, 0xc9, 0xce, 0x35, 0x0d, 0x57,
0x34, 0x42, 0x6a, 0xb7, 0xfa, 0x24, 0xad, 0x05, 0x47, 0xeb, 0x66, 0x1c,
0xee, 0x9c, 0x92, 0xdf, 0x59, 0x0f, 0xc7, 0x4c, 0x54, 0xaf, 0x16, 0xf0,
0x1f, 0x73, 0xf5, 0x24, 0xe4, 0x45, 0x2e, 0xf2, 0x54, 0x38, 0x0c, 0xfa,
0xad, 0x2f, 0xca, 0x49, 0x56, 0x3f, 0xc2, 0xeb, 0x58, 0xda, 0xdb, 0xf8,
0x31, 0x33, 0x70, 0x1a, 0x22, 0xea, 0x3f, 0xd9, 0x06, 0x1d, 0x28, 0x4e,
0x14, 0x40, 0xe2, 0xc1, 0x02, 0xbe, 0x18, 0xeb, 0xdd, 0xd5, 0x6e, 0xf8,
0xa4, 0x0a, 0x48, 0x91, 0x55, 0xfd, 0xd7, 0xad, 0x31, 0xcc, 0xfb, 0xeb,
0x45, 0x1a, 0x22, 0x4d, 0xdc, 0x11, 0x27, 0xef, 0x62, 0x1d, 0xb6, 0x28,
0x4d, 0x2f, 0xcb, 0x64, 0x55, 0x23, 0xc5, 0xdf, 0x52, 0xb7, 0x9c, 0x18,
0x34, 0xa8, 0x44, 0xbe, 0x1a, 0x12, 0x14, 0x01, 0xb4, 0x4f, 0x09, 0x1f,
0x2d, 0x27, 0xde, 0x47, 0xe9, 0x44, 0x8b, 0x1d, 0xf3, 0x48, 0x5d, 0x17,
0xc4, 0xca, 0xa7, 0xee, 0x3e, 0xda, 0x2c, 0xc2, 0x3e, 0xe6, 0x52, 0xf9,
0x41, 0xf3, 0xb8, 0x28, 0x2f, 0x3f, 0x4d, 0x1a, 0xb2, 0x53, 0x62, 0xd1,
0xb1, 0xf6, 0xdd, 0xe3, 0x6f, 0xe3, 0xd4, 0xd6, 0xef, 0xf0, 0x35, 0xed,
0x2a, 0xac, 0x2e, 0x28, 0xee, 0xec, 0x6e, 0xc7, 0x06, 0x4b, 0x61, 0x39,
0x42, 0xfd, 0xb6, 0x42, 0x53, 0xc9, 0xd8, 0x1b, 0x34, 0x40, 0x23, 0x1f,
0xc9, 0xb7, 0x86, 0x03, 0x61, 0xc3, 0xac, 0x68, 0x78, 0xf6, 0x3a, 0xe8,
0x4a, 0x04, 0xbd, 0x57, 0xba, 0x2a, 0x46, 0x49, 0x95, 0xbb, 0xc1, 0x4f,
0xfe, 0x08, 0x19, 0xce, 0x47, 0xf3, 0xbe, 0xaa, 0x36, 0xb6, 0x8a, 0xf0,
0xab, 0x08, 0x50, 0x06, 0x67, 0xfd, 0x29, 0xb3, 0xe6, 0x3b, 0x01, 0x17,
0x42, 0xf6, 0x91, 0x0b, 0x52, 0x83, 0x11, 0x13, 0x1e, 0xff, 0x40, 0xdc,
0x93, 0xc3, 0xde, 0xc5, 0x5f, 0xcd, 0x33, 0x37, 0x50, 0xcf, 0x5a, 0xde,
0x50, 0x2e, 0x13, 0x17, 0x12, 0x31, 0x5b, 0x51, 0xda, 0x0c, 0x4c, 0x84,
0xda, 0xf4, 0xf9, 0xba, 0x1a, 0xbd, 0xf4, 0xf9, 0xea, 0x09, 0xfa, 0xf1,
0x62, 0x20, 0x23, 0xc6, 0xd7, 0xf6, 0x37, 0x20, 0x07, 0x39, 0xaa, 0xd8,
0xf3, 0xda, 0x28, 0xcc, 0xdd, 0xaa, 0x9e, 0xc5, 0x32, 0xe9, 0x4c, 0x18,
0x11, 0x27, 0x41, 0x22, 0xea, 0xd8, 0xd1, 0x6d, 0x4c, 0x1f, 0xdd, 0xd9,
0x53, 0xc0, 0x1f, 0x07, 0x5a, 0x1c, 0xf1, 0x11, 0xe0, 0xf6, 0xa0, 0xef,
0x41, 0xbd, 0xdd, 0x5a, 0x5f, 0x0c, 0x06, 0x45, 0x9f, 0x1c, 0x92, 0xcf,
0xe0, 0xc6, 0x32, 0x10, 0x3f, 0xf9, 0x1a, 0xd7, 0xe6, 0x52, 0x34, 0x00,
0x20, 0x00, 0x57, 0xd3, 0xec, 0xc8, 0x92, 0xc3, 0xcd, 0x14, 0x45, 0x08,
0xfd, 0x51, 0x8d, 0x13, 0x3c, 0xba, 0xbd, 0x3e, 0x2e, 0xb5, 0xdd, 0x18,
0x4a, 0xfc, 0xd3, 0x31, 0x3f, 0xfc, 0x01, 0xf5, 0x65, 0xe8, 0xde, 0x89,
0x2b, 0xb9, 0xbd, 0x1f, 0x65, 0xeb, 0x0b, 0x09, 0x52, 0x2c, 0xa7, 0x0a,
0xec, 0xdc, 0x5e, 0xb5, 0x4b, 0xe4, 0x34, 0xca, 0x1b, 0x31, 0x49, 0x0a,
0x0b, 0x0e, 0x6f, 0x41, 0xe0, 0x08, 0x01, 0xb1, 0xf7, 0x66, 0x3b, 0xfe,
0xed, 0xfc, 0xe6, 0x1e, 0x8d, 0xda, 0x16, 0x15, 0x3e, 0xc9, 0x3f, 0xea,
0x09, 0x13, 0xd1, 0x04, 0xe0, 0x19, 0x12, 0x1b, 0x9b, 0x42, 0x12, 0xae,
0xb5, 0xec, 0x08, 0x2d, 0x25, 0xe0, 0xf9, 0x02, 0x54, 0x1d, 0x18, 0x19,
0xb0, 0x02, 0x31, 0xd7, 0x58, 0x15, 0x4e, 0x71, 0x1f, 0xf1, 0x24, 0x03,
0xf4, 0xdf, 0xa2, 0x15, 0x35, 0x91, 0xf5, 0xb8, 0x46, 0x15, 0x61, 0x0f,
0xce, 0x0c, 0xd2, 0x3f, 0xc6, 0x06, 0x54, 0x21, 0x27, 0xb3, 0xe5, 0x05,
0x4d, 0xfc, 0x29, 0x20, 0x5a, 0x12, 0x0f, 0xd8, 0xf8, 0x4c, 0xbe, 0xd2,
0xe8, 0xd6, 0xfe, 0x06, 0x0b, 0x44, 0x0f, 0x4b, 0x5f, 0xd4, 0xd4, 0xf9,
0xec, 0x03, 0x4f, 0xfe, 0xf4, 0x0d, 0x22, 0x15, 0x0a, 0x1c, 0x0d, 0x2e,
0x31, 0x2d, 0xb7, 0x44, 0xef, 0x63, 0x39, 0xbb, 0xb5, 0x19, 0x41, 0x35,
0xc7, 0x0c, 0xae, 0x09, 0x98, 0xe1, 0xba, 0x21, 0x31, 0x11, 0x44, 0x21,
0x49, 0x36, 0xe9, 0x2d, 0xf8, 0x2e, 0x27, 0x4c, 0x9c, 0xa7, 0xf4, 0xc1,
0x35, 0xf8, 0x28, 0x5e, 0x2f, 0x48, 0xe6, 0x37, 0xf6, 0x19, 0xef, 0x0c,
0xbd, 0xe4, 0x30, 0xc3, 0x32, 0x12, 0x68, 0x9a, 0xf1, 0x0f, 0xbe, 0x21,
0x29, 0x14, 0x91, 0x2c, 0xff, 0x87, 0xac, 0x0e, 0x07, 0x11, 0x59, 0x22,
0xe9, 0x15, 0xf8, 0xed, 0x42, 0xd2, 0x27, 0x34, 0x50, 0x18, 0x24, 0x15,
0x3c, 0xe7, 0xd3, 0x2c, 0xfe, 0x1f, 0x31, 0x08, 0x54, 0xb4, 0x9d, 0xfd,
0xc6, 0x1f, 0xc9, 0x6f, 0x0b, 0x28, 0xd5, 0x38, 0xc8, 0xef, 0x94, 0xd1,
0xa3, 0xe8, 0x17, 0x24, 0x27, 0x2d, 0x29, 0xbf, 0x35, 0x54, 0x3a, 0x2a,
0x2e, 0xef, 0x0b, 0x18, 0xbe, 0x5d, 0xcc, 0x05, 0x11, 0xe2, 0x3c, 0x4d,
0xb9, 0xd5, 0xf7, 0xf9, 0xb9, 0x29, 0xab, 0x04, 0x44, 0x18, 0x41, 0xf9,
0x3d, 0x97, 0xf9, 0x10, 0x1f, 0x52, 0x37, 0x23, 0x4a, 0xa2, 0x92, 0xcf,
0x6e, 0xea, 0x66, 0x66, 0x14, 0x1f, 0xdd, 0xc4, 0x2e, 0x2e, 0xe5, 0x06,
0xc5, 0xaf, 0x45, 0x12, 0xf4, 0x16, 0x46, 0xd9, 0x13, 0x22, 0x2a, 0x3a,
0x20, 0x17, 0x4d, 0x46, 0xa1, 0x95, 0xac, 0x24, 0x24, 0xf2, 0x66, 0x45,
0xc8, 0x2a, 0xbf, 0x1f, 0x41, 0xe8, 0xcf, 0x41, 0x4d, 0xb8, 0x2a, 0x2a,
0x5e, 0xdf, 0xda, 0x14, 0x16, 0x2b, 0xe1, 0xe4, 0x6f, 0xca, 0xb6, 0x58,
0x2c, 0x12, 0xba, 0xe6, 0x42, 0xfd, 0xc5, 0x39, 0x4b, 0xf7, 0xb2, 0xee,
0x25, 0xb8, 0x42, 0xd2, 0x18, 0xda, 0x5d, 0xdb, 0xe3, 0x1f, 0x11, 0x4d,
0x1a, 0xe8, 0x5f, 0x50, 0x63, 0x45, 0x9d, 0x1d, 0x68, 0x06, 0x4f, 0x05,
0xcd, 0x03, 0xa7, 0xd9, 0x33, 0xcc, 0x50, 0x63, 0x5a, 0x90, 0x1d, 0xe4,
0x11, 0xf7, 0x13, 0x38, 0x57, 0x3f, 0x49, 0x42, 0xe8, 0x0b, 0xa3, 0x87,
0x25, 0xec, 0xfc, 0x6f, 0x7f, 0x18, 0xb5, 0x5e, 0x91, 0x09, 0xf0, 0xd4,
0xcf, 0x41, 0x1e, 0xad, 0x0f, 0x29, 0x3e, 0x93, 0xfe, 0x21, 0x55, 0x5b,
0x2f, 0xfc, 0x9f, 0x06, 0x67, 0xc4, 0x43, 0x13, 0xc6, 0xf7, 0x33, 0x28,
0xc7, 0x09, 0x2f, 0x2c, 0x49, 0x07, 0xe7, 0x84, 0x3b, 0x31, 0xfd, 0x0b,
0x6d, 0xd7, 0xee, 0x39, 0xca, 0x3f, 0x49, 0x66, 0x10, 0xdc, 0xfb, 0x05,
0xd7, 0x2c, 0x25, 0x22, 0x3e, 0x15, 0xc8, 0xdd, 0xb7, 0xdf, 0xc0, 0x26,
0x5d, 0x63, 0x73, 0x2a, 0x14, 0xf0, 0x5e, 0x40, 0xe2, 0x2b, 0x08, 0x3d,
0x60, 0x52, 0x18, 0xe4, 0x95, 0xd0, 0x4c, 0x1f, 0xc7, 0x0b, 0x43, 0x18,
0xc4, 0xcf, 0x0b, 0xd4, 0xdf, 0xf0, 0xec, 0x0e, 0x79, 0xd9, 0x1a, 0xf0,
0x29, 0x9d, 0xc1, 0x46, 0x53, 0x19, 0x2c, 0xfe, 0xf7, 0x23, 0x4d, 0xcd,
0xab, 0x1d, 0x47, 0xe9, 0x42, 0x15, 0xb1, 0xea, 0x4c, 0xf1, 0x2f, 0x10,
0xd3, 0x86, 0x3d, 0x19, 0x1a, 0xe4, 0x54, 0x44, 0x0f, 0x64, 0x0f, 0x39,
0x3d, 0x47, 0xc7, 0x24, 0xa7, 0x3e, 0x3d, 0x0c, 0x56, 0x1e, 0x20, 0xe8,
0xbf, 0xc8, 0x5d, 0xba, 0x9e, 0xd8, 0xa9, 0x44, 0x45, 0x29, 0x47, 0x19,
0x33, 0x5e, 0xdf, 0x33, 0x67, 0x11, 0x39, 0x2b, 0xbd, 0x25, 0xf1, 0x15,
0xdb, 0xe7, 0xb1, 0xf4, 0x35, 0x27, 0x9a, 0x11, 0x05, 0xc8, 0x65, 0xc7,
0xa9, 0x15, 0x4b, 0x4d, 0x1c, 0xf0, 0x7a, 0xcc, 0xf3, 0x52, 0x71, 0x0f,
0x2a, 0x2d, 0x91, 0x40, 0x09, 0xda, 0x15, 0x30, 0x53, 0x1e, 0x30, 0x16,
0xb0, 0xc8, 0x4b, 0xb1, 0xd9, 0xc4, 0xaa, 0x6b, 0x55, 0x2f, 0x27, 0xfc,
0x44, 0xdc, 0x0b, 0x3e, 0xf4, 0x27, 0x4b, 0x0e, 0xf6, 0xbb, 0x35, 0x32,
0x16, 0x1a, 0x21, 0x44, 0x65, 0x29, 0x9b, 0x03, 0x1e, 0xa2, 0x48, 0x13,
0xfd, 0xa5, 0x40, 0x08, 0x11, 0xd1, 0x1b, 0x74, 0xcd, 0x54, 0xe7, 0x2e,
0x24, 0x12, 0xb5, 0x5a, 0xc2, 0x60, 0xad, 0x02, 0xcf, 0x26, 0x1c, 0xdb,
0xa2, 0x00, 0xd1, 0x95, 0x27, 0xc0, 0x1a, 0x28, 0x67, 0x0c, 0x62, 0xc3,
0x6f, 0x0b, 0x01, 0x41, 0x25, 0x01, 0x3c, 0x3e, 0xff, 0x1a, 0xc9, 0xb7,
0x51, 0xf2, 0x3a, 0x5b, 0x3e, 0xf1, 0xb1, 0xb6, 0x0f, 0x96, 0xc2, 0x05,
0xb7, 0x64, 0x61, 0x0a, 0xfa, 0xec, 0x23, 0xe4, 0x0b, 0x39, 0xf5, 0x3c,
0x01, 0x1c, 0xba, 0xde, 0x18, 0x7c, 0x32, 0xf9, 0x4b, 0x53, 0x4d, 0x0f,
0xa1, 0xe6, 0x2d, 0xb0, 0x28, 0x13, 0x05, 0x85, 0x60, 0xff, 0x3b, 0xbb,
0x3c, 0x99, 0xf6, 0x11, 0x55, 0x0c, 0x14, 0x4e, 0xfa, 0x2e, 0xa7, 0x46,
0x4b, 0xf3, 0x48, 0x0c, 0x25, 0x12, 0x11, 0x22, 0x0e, 0x31, 0xb1, 0xe3,
0x60, 0x23, 0x40, 0x9e, 0x15, 0xdb, 0x5c, 0x25, 0xe1, 0x37, 0xe3, 0xfb,
0xf8, 0x24, 0x50, 0xc5, 0x53, 0x3e, 0x07, 0xf4, 0x32, 0xd9, 0x2d, 0x0e,
0x08, 0x43, 0x4e, 0x1f, 0xc8, 0xfa, 0xbe, 0xff, 0x1d, 0x09, 0x3a, 0xcb,
0x4e, 0x0b, 0x0e, 0xf8, 0xee, 0x10, 0x1d, 0x28, 0xf8, 0x60, 0x4d, 0x61,
0x16, 0xad, 0xed, 0x2c, 0x46, 0xeb, 0xe2, 0x55, 0xb1, 0x1a, 0xce, 0x8e,
0x0a, 0xdb, 0x29, 0xb1, 0x46, 0xee, 0x3e, 0x48, 0xde, 0x19, 0xf9, 0xe3,
0x34, 0xcb, 0xec, 0xf5, 0x08, 0xd5, 0xf3, 0xc6, 0x66, 0x2f, 0x5f, 0xce,
0x00, 0x51, 0x8d, 0x26, 0x16, 0x83, 0x12, 0xf3, 0x2f, 0xb8, 0x3e, 0xc6,
0x4a, 0x07, 0x31, 0x47, 0x03, 0xed, 0x09, 0x00, 0xcf, 0xcf, 0xdb, 0xba,
0x32, 0xa3, 0x35, 0xcf, 0x54, 0x20, 0xfb, 0x3e, 0x83, 0x13, 0xbc, 0xd7,
0x03, 0xc0, 0x2d, 0xfe, 0xd1, 0xe2, 0x5e, 0x06, 0xc4, 0x09, 0xde, 0xf5,
0xdc, 0xd5, 0xe8, 0xac, 0xec, 0x10, 0x20, 0xc2, 0xcb, 0x08, 0x59, 0xe2,
0xf9, 0x1a, 0xe6, 0x00, 0xb9, 0xb8, 0xb2, 0x95, 0x43, 0x41, 0x31, 0xf5,
0x31, 0x14, 0x13, 0x27, 0x40, 0x2b, 0x26, 0x19, 0x5e, 0xbd, 0xf0, 0x41,
0x63, 0xee, 0x22, 0x3f, 0x44, 0x02, 0x06, 0x0c, 0x15, 0x1c, 0x1c, 0xf6,
0x11, 0x8b, 0x73, 0x66, 0x35, 0x00, 0x4f, 0xa5, 0x03, 0xee, 0xf2, 0xfe,
0x43, 0x0b, 0x97, 0xcc, 0xdd, 0x1c, 0xeb, 0xb9, 0x50, 0xda, 0x5f, 0x02,
0xf3, 0x13, 0xbc, 0x28, 0xa1, 0xb7, 0xd7, 0x3e, 0x42, 0xd5, 0x12, 0x02,
0x1e, 0x3f, 0x02, 0x15, 0xe0, 0x30, 0x19, 0xdf, 0x08, 0xf4, 0x08, 0x0a,
0xa2, 0xb5, 0x3c, 0xe4, 0x3e, 0x28, 0x0f, 0x45, 0xdf, 0x28, 0x6d, 0xd4,
0x1a, 0xe3, 0x5f, 0xcb, 0x44, 0x0f, 0x51, 0xf3, 0x22, 0x11, 0x24, 0x0c,
0x19, 0x35, 0x30, 0x22, 0x0d, 0x4a, 0xa5, 0xec, 0xac, 0x4c, 0x12, 0xfa,
0xd0, 0x22, 0x9c, 0x2e, 0x5b, 0x1a, 0xec, 0x65, 0x2b, 0xd7, 0x13, 0x09,
0x2d, 0x26, 0x21, 0x36, 0xff, 0x19, 0x35, 0x32, 0xc2, 0x28, 0x17, 0x38,
0xe2, 0xdd, 0x09, 0x35, 0x43, 0x2c, 0xfa, 0x3f, 0x8d, 0x1f, 0x3c, 0xf7,
0xf4, 0x8d, 0x51, 0xb9, 0x50, 0x31, 0x0f, 0xb5, 0x0b, 0xf8, 0x06, 0x10,
0x0f, 0x2d, 0x97, 0xd7, 0xb1, 0x66, 0x9f, 0xf1, 0xb3, 0x4b, 0x65, 0xff,
0xe4, 0x37, 0x9b, 0xfd, 0x90, 0xe4, 0xd4, 0x46, 0x31, 0xf2, 0x04, 0x30,
0x30, 0xc0, 0xe1, 0x36, 0x3b, 0x26, 0x38, 0xf6, 0x8a, 0x55, 0xe7, 0x5c,
0xd2, 0x26, 0xb6, 0xfb, 0x42, 0x3a, 0xeb, 0xf8, 0x2a, 0x29, 0x9d, 0x2b,
0xb0, 0xec, 0x51, 0xfa, 0xf5, 0x0b, 0x64, 0x32, 0xdf, 0x38, 0xf8, 0x25,
0x3a, 0x1c, 0x2a, 0xe3, 0xf1, 0x24, 0xf4, 0x21, 0x2a, 0xd8, 0x36, 0x37,
0xbb, 0x1c, 0xb0, 0x15, 0xc9, 0xd8, 0x00, 0xb2, 0x46, 0x05, 0x47, 0xff,
0x4e, 0xb4, 0xed, 0x45, 0xd6, 0x30, 0xe7, 0x67, 0xfb, 0x57, 0xc4, 0xda,
0xec, 0x06, 0xf7, 0x48, 0x2a, 0x0f, 0xbf, 0xd1, 0xd2, 0x23, 0x75, 0x16,
0x16, 0xdb, 0x5e, 0xf3, 0x33, 0xfd, 0x2b, 0x4b, 0xff, 0x23, 0x6b, 0x39,
0x1a, 0x08, 0xea, 0xd8, 0xcd, 0x68, 0x01, 0xff, 0xe5, 0xd1, 0x46, 0x23,
0xa6, 0xc4, 0xa6, 0x07, 0x4e, 0x12, 0x1d, 0x9f, 0x4a, 0xb5, 0xec, 0x12,
0x42, 0xe2, 0xe4, 0x36, 0x55, 0x26, 0x1f, 0xfe, 0x27, 0x5a, 0x32, 0xc0,
0xc5, 0x44, 0x66, 0x51, 0x1e, 0x29, 0xe0, 0x45, 0xb7, 0x26, 0xe9, 0xe4,
0x25, 0x3e, 0x5a, 0x9d, 0x27, 0xdc, 0x2c, 0x2f, 0xb4, 0x46, 0x33, 0x3e,
0x18, 0x52, 0xd2, 0xf3, 0xef, 0x7e, 0xa0, 0xfc, 0x1d, 0x31, 0x59, 0x03,
0xc8, 0x19, 0xc8, 0xf6, 0x69, 0x2e, 0xcc, 0x37, 0x56, 0x89, 0x14, 0x09,
0x1c, 0x70, 0xdb, 0x19, 0x40, 0x28, 0x11, 0x3c, 0x49, 0xa8, 0x41, 0x10,
0x57, 0x04, 0x4d, 0x4b, 0x63, 0x22, 0xc2, 0x2d, 0xac, 0xd4, 0x20, 0xa5,
0x25, 0xa7, 0x23, 0xce, 0x3a, 0x04, 0x39, 0xf6, 0x0c, 0x56, 0xed, 0x48,
0x08, 0x45, 0xd0, 0xd9, 0xc6, 0x69, 0x00, 0x0e, 0xb4, 0x23, 0x12, 0xf3,
0xc9, 0x0d, 0xd0, 0xf0, 0x0d, 0x27, 0xb3, 0x45, 0x69, 0x3c, 0xed, 0xfd,
0x18, 0xc7, 0xf5, 0x51, 0xc2, 0x27, 0x40, 0x29, 0xfb, 0xd4, 0xc7, 0x8c,
0x1d, 0xe4, 0xbf, 0xd9, 0x4c, 0x08, 0xbc, 0x14, 0x9e, 0xea, 0x0b, 0xc2,
0x1e, 0x94, 0x2d, 0xef, 0x65, 0xfa, 0x22, 0x36, 0xe3, 0x51, 0x2d, 0x1d,
0xf2, 0x0e, 0x93, 0x3a, 0xa4, 0x98, 0x6c, 0x0a, 0xee, 0x08, 0x62, 0x11,
0xda, 0xe7, 0xa2, 0xbd, 0x66, 0xb6, 0x1a, 0xfb, 0x2e, 0x0f, 0x2e, 0x2a,
0x2b, 0x9b, 0xf4, 0x46, 0xf6, 0x36, 0x16, 0x24, 0xc3, 0xfb, 0xa0, 0x1c,
0x47, 0x0d, 0xba, 0x60, 0x2d, 0xf4, 0xcc, 0xa9, 0xaf, 0x9d, 0xd6, 0xe5,
0xef, 0x69, 0x22, 0x04, 0xf9, 0x27, 0x35, 0x53, 0x31, 0x56, 0xb0, 0x3a,
0x3f, 0x0e, 0xd0, 0x14, 0xce, 0xa7, 0xbe, 0xd7, 0xa7, 0x10, 0x3e, 0x32,
0xb9, 0xea, 0xec, 0xd4, 0xdf, 0xcf, 0x23, 0x48, 0x5b, 0x12, 0xe9, 0x17,
0x5d, 0x62, 0xf5, 0x28, 0x61, 0x34, 0x64, 0x37, 0x04, 0x45, 0x31, 0xb8,
0x18, 0x23, 0x0c, 0x22, 0x3e, 0x1b, 0x99, 0xf4, 0x8f, 0x91, 0xd5, 0x06,
0x34, 0x15, 0x69, 0xb8, 0x55, 0xe1, 0x6d, 0x47, 0x32, 0x28, 0xb3, 0x06,
0x43, 0x2b, 0x3f, 0xb0, 0xdb, 0x46, 0x26, 0x32, 0x5f, 0x2a, 0x6b, 0xd2,
0xaa, 0x0f, 0x92, 0xd0, 0x95, 0xc1, 0xf7, 0xc5, 0x7f, 0x03, 0x46, 0xcb,
0x72, 0x16, 0xdc, 0x44, 0xfb, 0x36, 0x72, 0xcc, 0x03, 0xd9, 0x4d, 0xea,
0xa6, 0x26, 0xe2, 0x30, 0x30, 0xf8, 0xc8, 0xc9, 0x1e, 0xab, 0x14, 0xe6,
0x1e, 0x8f, 0x4a, 0xcb, 0x26, 0xc4, 0x1c, 0x6a, 0x04, 0x5e, 0xd6, 0x15,
0x36, 0x18, 0x65, 0xc7, 0x2b, 0xff, 0xe2, 0x04, 0x2a, 0xc7, 0x24, 0xe0,
0xb7, 0xdd, 0xdd, 0x81, 0x37, 0xe2, 0xf9, 0xb5, 0x5d, 0xf0, 0xf4, 0xd9,
0x29, 0x0f, 0x19, 0x5c, 0xf6, 0x2a, 0x16, 0xe0, 0xd6, 0xcf, 0x2b, 0x51,
0xd9, 0xeb, 0x0f, 0x30, 0x36, 0xcc, 0xaf, 0x90, 0xe6, 0xbc, 0xb4, 0xf6,
0xd9, 0xb0, 0x3f, 0xc9, 0x56, 0xeb, 0x59, 0x5b, 0x34, 0x4e, 0x49, 0xf8,
0x3b, 0xfb, 0xcf, 0xa2, 0x3e, 0x81, 0x6d, 0x16, 0xf5, 0x05, 0x4d, 0xd2,
0x8b, 0x81, 0xd3, 0xe1, 0xf4, 0xd9, 0xdf, 0x5b, 0x4f, 0x0f, 0x64, 0xa3,
0x4b, 0xaa, 0xc0, 0x34, 0xbe, 0x11, 0x2e, 0x0c, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x5e, 0xb1, 0xff, 0xff,
0x04, 0x00, 0x00, 0x00, 0xca, 0x08, 0x00, 0x00, 0xfe, 0x90, 0x52, 0xd1,
0x07, 0x13, 0x40, 0x25, 0x5b, 0xd3, 0xc0, 0x32, 0x4a, 0x30, 0x6b, 0x2c,
0xcc, 0x95, 0x33, 0x78, 0x35, 0xa2, 0x95, 0x56, 0xc5, 0x9e, 0x50, 0x0c,
0x7c, 0x11, 0x10, 0xae, 0xb9, 0xe0, 0x0f, 0x27, 0x09, 0x88, 0x62, 0x22,
0x90, 0x74, 0x02, 0xd8, 0x86, 0x6c, 0xf7, 0x23, 0x36, 0x7f, 0x53, 0x2c,
0xf9, 0xe3, 0xf5, 0x9d, 0x4a, 0xfb, 0xaf, 0x2f, 0x3c, 0x6e, 0x97, 0xe5,
0xa0, 0xc3, 0x2e, 0x0a, 0x89, 0x90, 0x27, 0xa4, 0xf7, 0x3f, 0xd8, 0x2e,
0x9a, 0x3f, 0xf1, 0x3e, 0xe2, 0x6e, 0x3f, 0x17, 0x5c, 0x4f, 0x4c, 0x86,
0xce, 0x87, 0xa8, 0xd9, 0x40, 0x07, 0x94, 0x09, 0x5e, 0x07, 0xd7, 0xe8,
0x7f, 0x12, 0xae, 0x4b, 0xe8, 0x0a, 0xce, 0x41, 0xb8, 0xa9, 0xc1, 0x5b,
0xf5, 0x7d, 0x11, 0xd5, 0x26, 0x6b, 0xe5, 0xc2, 0xeb, 0xf5, 0x4f, 0x09,
0x90, 0xda, 0x94, 0x1c, 0x12, 0xc1, 0x46, 0x68, 0xbf, 0x7e, 0xe8, 0xb7,
0x90, 0x47, 0x26, 0x4d, 0x1e, 0xcf, 0x63, 0xe3, 0x70, 0xaf, 0x61, 0xbf,
0x49, 0xf3, 0xf3, 0x36, 0xbe, 0x3e, 0x31, 0xc5, 0x38, 0x42, 0x05, 0xff,
0x08, 0x59, 0x54, 0xea, 0x9e, 0xca, 0x28, 0x7f, 0xe6, 0xb7, 0xe6, 0x0f,
0x55, 0x5d, 0xcb, 0xd1, 0x04, 0x8f, 0x6b, 0xc4, 0xc5, 0xcd, 0x2c, 0x64,
0x5a, 0x3f, 0x23, 0xe0, 0x98, 0x75, 0x58, 0xfa, 0x8d, 0x9f, 0x4c, 0x25,
0x21, 0xf5, 0x71, 0x3d, 0x6e, 0x4b, 0xcc, 0xee, 0x10, 0x70, 0x15, 0xbe,
0xa0, 0x0b, 0xe5, 0x23, 0x04, 0x08, 0xd3, 0x94, 0xea, 0xd3, 0x91, 0x2c,
0xd2, 0x3a, 0xe8, 0x3a, 0x5f, 0x29, 0xad, 0xd1, 0x3d, 0xfe, 0x13, 0x14,
0xe3, 0xb4, 0xcb, 0xa2, 0x87, 0x95, 0x35, 0xff, 0x0d, 0x42, 0x82, 0xa8,
0x32, 0x82, 0xf7, 0xc4, 0xa1, 0x0c, 0xc5, 0xf9, 0xed, 0xe3, 0xd1, 0xfc,
0xee, 0x77, 0xc2, 0xfc, 0x39, 0x15, 0x9f, 0x39, 0x93, 0x35, 0xf0, 0x05,
0x88, 0x42, 0x81, 0x34, 0xc3, 0x99, 0x03, 0x3d, 0x64, 0xfb, 0x62, 0x19,
0x8f, 0x03, 0x0b, 0xcd, 0x9f, 0x22, 0xef, 0xb7, 0x9f, 0xdb, 0x38, 0xe8,
0x9c, 0x37, 0xdf, 0x07, 0xb1, 0x4a, 0xcc, 0x0a, 0x67, 0xe9, 0x53, 0xf6,
0x52, 0x82, 0x28, 0x6f, 0xf8, 0xdc, 0x6e, 0x9e, 0xb2, 0x52, 0x47, 0x82,
0x7c, 0x57, 0x7b, 0x92, 0x4a, 0xaf, 0x69, 0xb4, 0xed, 0xd7, 0xd1, 0x3b,
0x54, 0x81, 0x33, 0xb6, 0x66, 0x74, 0x35, 0x08, 0xda, 0x1f, 0x24, 0x12,
0x9e, 0x11, 0xf3, 0xca, 0x18, 0x5c, 0x3e, 0xe9, 0xfc, 0xb4, 0xe0, 0x3c,
0xe8, 0x49, 0x87, 0xab, 0x9c, 0x53, 0xf5, 0x95, 0x01, 0xfc, 0x58, 0x12,
0x6e, 0xb1, 0x25, 0x59, 0xfc, 0x73, 0x5d, 0x55, 0x81, 0x61, 0xe6, 0xda,
0x81, 0x95, 0x72, 0x09, 0x9e, 0x6e, 0x29, 0x2f, 0x01, 0xf5, 0xe8, 0x19,
0xd2, 0xf4, 0xb8, 0x9b, 0xda, 0x64, 0x21, 0x44, 0x49, 0x0a, 0xff, 0xfa,
0x4c, 0x4a, 0xdc, 0xc6, 0x6d, 0x4f, 0x47, 0xf0, 0xb4, 0x21, 0x54, 0xab,
0xcc, 0xc6, 0xe9, 0xd5, 0x3e, 0x01, 0x00, 0xe8, 0x72, 0xf2, 0x92, 0x6c,
0x99, 0x48, 0xd6, 0xaf, 0xdc, 0xb5, 0x50, 0xf8, 0x76, 0x50, 0xfd, 0xe3,
0xe9, 0xbb, 0x09, 0x9d, 0x96, 0x67, 0x43, 0xc2, 0xd4, 0x4c, 0xdd, 0xc7,
0x3b, 0x36, 0x2c, 0x5e, 0x56, 0x13, 0x73, 0xd8, 0x12, 0x50, 0xcb, 0x29,
0xc1, 0x4f, 0x3c, 0x31, 0x57, 0x23, 0x56, 0x61, 0xc4, 0x27, 0x77, 0x95,
0x2b, 0x47, 0x4d, 0xda, 0x21, 0x88, 0x15, 0x67, 0x8b, 0x58, 0x65, 0xd2,
0xfb, 0x8d, 0x88, 0x7e, 0x7f, 0x42, 0xba, 0x8b, 0xef, 0x97, 0x22, 0x44,
0x58, 0xce, 0x99, 0xa4, 0xe5, 0xf3, 0xbd, 0x8e, 0x7c, 0x42, 0x56, 0x13,
0x8f, 0x6e, 0xa5, 0x7c, 0x0a, 0xf2, 0x44, 0xc5, 0x5d, 0xb8, 0x38, 0xe1,
0xb9, 0xa7, 0xce, 0x1d, 0x42, 0xc6, 0x04, 0x68, 0x3d, 0xde, 0xb6, 0x77,
0xcf, 0x75, 0x5f, 0x81, 0xa6, 0x70, 0x72, 0xe9, 0x15, 0x90, 0x84, 0xc9,
0xfe, 0x9e, 0x62, 0x20, 0xc3, 0xb5, 0x34, 0x06, 0xe8, 0x11, 0x11, 0xbf,
0x46, 0x07, 0x2a, 0x71, 0xf1, 0xd7, 0x0e, 0x14, 0x7a, 0xe0, 0x28, 0xd8,
0xe2, 0xac, 0x4f, 0x71, 0xb8, 0x1d, 0x62, 0x17, 0x6d, 0x8a, 0xe6, 0x7c,
0xdb, 0xb0, 0x65, 0xf3, 0xa3, 0xc4, 0x50, 0xe0, 0x4f, 0x88, 0x07, 0x92,
0xb3, 0x3f, 0xd2, 0x33, 0x0b, 0x20, 0xac, 0x55, 0xa3, 0x73, 0xd6, 0x76,
0x9c, 0x60, 0xdb, 0xb8, 0x69, 0x40, 0xa3, 0x1a, 0xb7, 0xa7, 0x22, 0xce,
0xc1, 0xdc, 0x3d, 0xa6, 0xc8, 0xc0, 0xff, 0x7f, 0x10, 0xb2, 0x41, 0xdf,
0x51, 0x01, 0xa1, 0x20, 0x31, 0x77, 0x0e, 0xd2, 0x19, 0xae, 0xc3, 0xd3,
0x93, 0xaf, 0x39, 0x61, 0x25, 0xf0, 0xdd, 0x4e, 0x1f, 0x6b, 0xf9, 0xf9,
0x38, 0x3f, 0xd3, 0x69, 0x67, 0xa1, 0xd6, 0x8b, 0x65, 0x2d, 0xc5, 0x0a,
0x7b, 0xa9, 0x59, 0xff, 0x24, 0x89, 0xb7, 0x23, 0xa5, 0xe4, 0x0a, 0x52,
0x83, 0xf6, 0xad, 0x4b, 0x90, 0x51, 0xe6, 0x0a, 0xc7, 0x71, 0xb5, 0x7f,
0x41, 0x88, 0x2f, 0x24, 0xc0, 0x15, 0x36, 0x71, 0x18, 0x51, 0x35, 0x3c,
0x11, 0x09, 0xe0, 0x03, 0x3f, 0x2e, 0xb3, 0xe6, 0xe2, 0xc7, 0x7f, 0xf9,
0x5b, 0x72, 0xe6, 0x27, 0xcf, 0xfd, 0xdd, 0x8d, 0xe9, 0x9d, 0x8e, 0x5d,
0x77, 0x47, 0x42, 0x84, 0xed, 0xbb, 0xa0, 0x29, 0x71, 0xcf, 0xe5, 0x5a,
0x32, 0x9d, 0x30, 0xa7, 0x3d, 0xa7, 0x9a, 0x57, 0xaa, 0xcb, 0x93, 0xdd,
0xb0, 0x5d, 0xf6, 0x0e, 0x5b, 0xb1, 0x2c, 0x6d, 0x37, 0xc7, 0xeb, 0xf4,
0xef, 0x0f, 0x5a, 0x55, 0x28, 0xce, 0x2c, 0xff, 0x09, 0x3c, 0x3c, 0x2b,
0xd2, 0x2b, 0x09, 0xaf, 0xdd, 0xc6, 0xed, 0xe2, 0xea, 0xeb, 0x53, 0x68,
0xad, 0xc1, 0x60, 0xb6, 0x1a, 0x33, 0x06, 0xd5, 0xc6, 0x92, 0xb3, 0x00,
0x70, 0xdd, 0x14, 0x71, 0xe5, 0xe6, 0x38, 0xd9, 0xc5, 0xc1, 0xdb, 0x51,
0x81, 0xcf, 0xde, 0xb8, 0xdc, 0xd5, 0x26, 0x31, 0x27, 0x20, 0x13, 0xea,
0xb5, 0x30, 0x69, 0xaf, 0xc6, 0xcd, 0x89, 0x88, 0x1f, 0x37, 0x28, 0x06,
0xf5, 0x23, 0xb1, 0x5b, 0x50, 0x36, 0x34, 0xc4, 0x48, 0x8f, 0xc0, 0xc4,
0x44, 0x41, 0xcd, 0xc9, 0xd3, 0x2c, 0xf5, 0x54, 0x3a, 0x47, 0x71, 0x3a,
0xd9, 0xf7, 0x8a, 0x06, 0x3d, 0x63, 0xb3, 0x19, 0x2c, 0xd6, 0xc3, 0x69,
0x35, 0x42, 0xff, 0x81, 0xe2, 0xad, 0x31, 0x04, 0x9b, 0x89, 0xeb, 0xa0,
0x22, 0x06, 0x19, 0xe0, 0xfc, 0x50, 0x24, 0xd4, 0x9e, 0x83, 0x04, 0x95,
0xd0, 0xd2, 0x2e, 0x3b, 0xa8, 0xef, 0xaa, 0xf8, 0x89, 0x57, 0xde, 0x51,
0x43, 0x38, 0x53, 0xee, 0x4c, 0x26, 0xec, 0xa7, 0x22, 0x57, 0x01, 0x41,
0xbe, 0x16, 0xe1, 0x9e, 0x2a, 0x74, 0xbc, 0x0f, 0x92, 0x93, 0x39, 0x48,
0x6e, 0xc4, 0x7f, 0x8f, 0x52, 0x2d, 0x20, 0x73, 0xd2, 0x4b, 0x2b, 0xcb,
0x1d, 0xc9, 0xf1, 0x1f, 0x8b, 0x3d, 0x8e, 0x5d, 0x70, 0x24, 0xd7, 0xfa,
0xc3, 0xc1, 0xa7, 0xce, 0x5d, 0x43, 0x1c, 0xad, 0xcb, 0x90, 0xcc, 0x22,
0x76, 0x3f, 0x75, 0x97, 0xc3, 0xe7, 0x4b, 0x24, 0x6a, 0xe2, 0x4c, 0xa9,
0x9b, 0xb9, 0x62, 0x3b, 0x7d, 0x15, 0x34, 0x65, 0xf5, 0x22, 0x7f, 0xd0,
0x7c, 0x14, 0xc2, 0xea, 0xca, 0xd7, 0xd6, 0xad, 0x5d, 0x2e, 0x35, 0x5b,
0xda, 0x40, 0x0f, 0xd1, 0xaa, 0xbf, 0x9c, 0xb5, 0x5f, 0x18, 0x8c, 0x74,
0xeb, 0x20, 0x54, 0xff, 0xae, 0xb6, 0x68, 0xb5, 0x87, 0x61, 0xcc, 0xb6,
0x2d, 0x93, 0x05, 0x0d, 0x15, 0xb8, 0x2b, 0x45, 0xb2, 0xda, 0x71, 0x3b,
0x0e, 0xce, 0xa2, 0x27, 0x22, 0x0c, 0x9b, 0x10, 0xb0, 0xb6, 0x3c, 0xcd,
0xa8, 0xc5, 0x0b, 0x13, 0x9b, 0xc6, 0xc4, 0xb3, 0x58, 0xbc, 0x37, 0x8d,
0x79, 0x0d, 0xa4, 0x82, 0xf6, 0xf1, 0x1a, 0x76, 0x1c, 0x1e, 0x67, 0x14,
0xac, 0x6b, 0x56, 0xcd, 0x8c, 0xdd, 0x96, 0xbb, 0x53, 0xfd, 0xd7, 0xd4,
0x5d, 0x71, 0xc9, 0x60, 0x41, 0xc3, 0x4b, 0x79, 0x93, 0x5e, 0x24, 0x81,
0x5d, 0x77, 0xed, 0x25, 0x1e, 0xb0, 0xc6, 0xef, 0xb8, 0x46, 0x34, 0xc2,
0xe7, 0x3a, 0x6c, 0x22, 0x7b, 0x4f, 0x0d, 0x07, 0x42, 0xd5, 0x3c, 0x47,
0x67, 0x08, 0xbb, 0xa8, 0xce, 0x90, 0xd2, 0x73, 0xbc, 0x0f, 0x4c, 0x8f,
0x92, 0x35, 0xa8, 0x29, 0xc8, 0x0b, 0x17, 0x9f, 0x3a, 0x15, 0xad, 0x13,
0x22, 0x9a, 0xcb, 0xd9, 0xfa, 0x4a, 0x72, 0x96, 0x37, 0xd3, 0xee, 0x4e,
0x6e, 0x03, 0xaa, 0xc5, 0x92, 0x47, 0x22, 0x85, 0xc5, 0x74, 0x36, 0x53,
0xed, 0x93, 0x4e, 0x52, 0x22, 0x7f, 0x0e, 0xd1, 0xce, 0xf1, 0x5c, 0x70,
0xf3, 0x2b, 0xee, 0x28, 0x54, 0xc5, 0xd1, 0x14, 0xd8, 0x89, 0x49, 0x46,
0xa1, 0x20, 0x29, 0x91, 0x22, 0x7d, 0xf6, 0xe0, 0xbf, 0x27, 0x7f, 0x2a,
0x4a, 0x88, 0x5a, 0xe1, 0x23, 0x9e, 0xcc, 0xb3, 0x3e, 0xf8, 0x53, 0xa8,
0x9c, 0x87, 0xfd, 0x4a, 0x59, 0xd1, 0x35, 0x7e, 0x4d, 0x08, 0x92, 0x2d,
0xba, 0xbc, 0x43, 0x0d, 0xf2, 0x12, 0xbf, 0x66, 0x00, 0xb1, 0x54, 0xdc,
0x59, 0x42, 0x6b, 0xe1, 0x50, 0xec, 0x03, 0x24, 0xb1, 0x20, 0x3e, 0xa4,
0x61, 0xe8, 0x98, 0xcf, 0x32, 0xeb, 0xc2, 0x5c, 0x12, 0x2c, 0x4c, 0xab,
0xa6, 0xe7, 0xb2, 0x23, 0xb4, 0x4a, 0x51, 0xad, 0x1a, 0xfd, 0x4c, 0x44,
0x89, 0x29, 0x3d, 0x7f, 0x32, 0x2b, 0x19, 0x64, 0xf6, 0x6b, 0x3f, 0xa3,
0x08, 0x91, 0x2a, 0xde, 0x30, 0xfa, 0xdd, 0xe9, 0xbe, 0x10, 0xb7, 0xeb,
0x5f, 0x37, 0xdc, 0x6f, 0x73, 0xda, 0x28, 0xfe, 0x39, 0x6e, 0x5e, 0xe3,
0x2c, 0x71, 0xe0, 0x79, 0xd4, 0x75, 0xfa, 0x0d, 0x1f, 0xa1, 0x70, 0xa1,
0x7c, 0x81, 0xe7, 0x24, 0x22, 0x14, 0x87, 0x10, 0x46, 0xa9, 0x9b, 0x1c,
0xe0, 0x8f, 0x9d, 0xbb, 0x4d, 0x36, 0x31, 0xb4, 0x1e, 0x4f, 0x30, 0xb3,
0xf6, 0x55, 0x4d, 0x73, 0x36, 0x09, 0xb2, 0x4b, 0x50, 0x1d, 0xcc, 0xbb,
0x3a, 0xd9, 0xd4, 0xed, 0x43, 0x8e, 0xc3, 0x94, 0xcc, 0x3e, 0xa2, 0xba,
0xea, 0xae, 0xa4, 0xec, 0x3e, 0x2c, 0x6f, 0xf5, 0x0d, 0xc3, 0xaa, 0x32,
0xea, 0x24, 0xfb, 0x1b, 0x6c, 0x5d, 0x76, 0xf1, 0xa3, 0xd8, 0xf9, 0xe2,
0x7e, 0x6e, 0x97, 0x57, 0x1f, 0xa7, 0x58, 0xbc, 0xff, 0xdd, 0x7f, 0x3a,
0xa6, 0x00, 0x60, 0xd9, 0xee, 0xa7, 0x00, 0x43, 0xe6, 0x91, 0xd2, 0x19,
0xce, 0x66, 0x33, 0xa0, 0xc0, 0xbe, 0xe2, 0x89, 0xa0, 0x10, 0x66, 0xdd,
0x16, 0xcb, 0xd4, 0x7f, 0x6e, 0xdd, 0x39, 0x68, 0x36, 0x0a, 0x3e, 0xf6,
0x8a, 0x15, 0xf4, 0xdc, 0x0c, 0x4a, 0xf5, 0xfb, 0x04, 0x9c, 0x8b, 0x8c,
0x84, 0xb5, 0x46, 0xae, 0x24, 0xa3, 0x5a, 0xcb, 0x46, 0x72, 0x74, 0x9e,
0x4d, 0x4c, 0xd7, 0x0f, 0x73, 0xf8, 0x6d, 0xe9, 0x9b, 0x70, 0x26, 0x57,
0x4f, 0x19, 0x70, 0x28, 0xbc, 0xd0, 0x4c, 0x21, 0x9f, 0x4d, 0x8d, 0x90,
0x74, 0x76, 0x54, 0xa6, 0x6a, 0xab, 0x0b, 0xa3, 0x74, 0x68, 0xa9, 0x08,
0xe6, 0x9e, 0x8f, 0x7b, 0xaa, 0x5e, 0xeb, 0xc9, 0x3a, 0xa1, 0x4b, 0x5d,
0xc5, 0x15, 0x2c, 0x39, 0xb6, 0xa1, 0xc9, 0x0f, 0x06, 0xc3, 0xe1, 0xbe,
0xb0, 0xfe, 0x3b, 0x0f, 0xa2, 0xa2, 0xac, 0x21, 0xf9, 0x14, 0x95, 0x7f,
0xbb, 0x30, 0x74, 0xfb, 0xe8, 0xf1, 0x8e, 0x28, 0x4e, 0x97, 0x41, 0x10,
0xa2, 0xc0, 0x5d, 0x4c, 0x25, 0xcf, 0xfc, 0x41, 0x1e, 0x32, 0x7b, 0x69,
0x5c, 0xb5, 0xc8, 0xc6, 0xf1, 0x0d, 0x4b, 0x66, 0x21, 0xe1, 0x62, 0x06,
0xfa, 0x58, 0xe9, 0x79, 0x56, 0xde, 0x72, 0xea, 0xcb, 0x5f, 0xf3, 0xbe,
0x7f, 0x41, 0xf5, 0x6b, 0x22, 0x1b, 0x34, 0x27, 0xdb, 0x39, 0xed, 0xfe,
0x2f, 0x69, 0x5d, 0xfd, 0xed, 0x1b, 0xe9, 0xca, 0x48, 0x7c, 0xd2, 0x34,
0xe3, 0x20, 0xe5, 0x23, 0xef, 0x4c, 0x60, 0x4b, 0xac, 0xd2, 0xbc, 0x44,
0x37, 0x19, 0x04, 0x71, 0xe6, 0xbf, 0x01, 0x34, 0xce, 0xdf, 0x6d, 0x2b,
0x56, 0x68, 0x47, 0xfb, 0x42, 0xe1, 0x4f, 0xe0, 0x27, 0x50, 0x4c, 0x15,
0x5e, 0x24, 0x95, 0x91, 0x87, 0xd9, 0x3d, 0xa5, 0xb7, 0x30, 0x3c, 0xb0,
0x14, 0x5d, 0x4d, 0xed, 0x91, 0x63, 0x50, 0xbd, 0x6d, 0x17, 0x59, 0xb7,
0x8f, 0xc8, 0xf8, 0xbd, 0xf3, 0x71, 0x29, 0x45, 0x42, 0x32, 0x23, 0xe0,
0x2c, 0x26, 0xf4, 0xc9, 0x43, 0xbd, 0x02, 0xff, 0x31, 0x00, 0x1c, 0xb5,
0xee, 0xfd, 0xd1, 0x67, 0xa1, 0x26, 0x32, 0x32, 0x44, 0x5a, 0x75, 0x85,
0xbf, 0x4d, 0x22, 0x0d, 0x93, 0xcb, 0x31, 0xa0, 0xd9, 0x19, 0xcc, 0x1d,
0x7f, 0x9b, 0x78, 0xbb, 0x91, 0x30, 0x92, 0x3f, 0xc7, 0x98, 0xcc, 0xe3,
0x79, 0x53, 0x37, 0x87, 0xee, 0x32, 0xcf, 0x5e, 0x68, 0xc0, 0xb2, 0x47,
0x03, 0x7b, 0x45, 0xb8, 0x03, 0x99, 0xca, 0xf6, 0x4c, 0x6f, 0x2c, 0x77,
0x7b, 0x6d, 0xc2, 0xec, 0x36, 0x8c, 0x6b, 0xec, 0x13, 0x21, 0xad, 0x23,
0x81, 0xab, 0xdc, 0x1a, 0xdc, 0x5a, 0x13, 0x48, 0xbd, 0x76, 0xc1, 0x75,
0x6b, 0xcd, 0x64, 0x87, 0xf8, 0x74, 0x85, 0xea, 0x1a, 0xa1, 0xfd, 0xb7,
0x50, 0x0c, 0xe5, 0x96, 0x7c, 0x27, 0x61, 0x0b, 0x48, 0x4d, 0x4f, 0xe2,
0x09, 0x77, 0x17, 0xd6, 0x0a, 0x39, 0xed, 0xf9, 0x0c, 0x5b, 0x16, 0x6d,
0xeb, 0x61, 0x6c, 0x6a, 0xf0, 0x13, 0x68, 0xf0, 0xc1, 0xe4, 0xd4, 0x9e,
0xe9, 0x49, 0xef, 0x32, 0x59, 0x4e, 0x6a, 0x7a, 0x3f, 0x3e, 0xd2, 0xe3,
0xff, 0x2c, 0xdc, 0xab, 0xc2, 0x11, 0xda, 0x04, 0xfd, 0x1e, 0x05, 0xbd,
0x5f, 0x30, 0xbb, 0x67, 0x42, 0xf0, 0x5a, 0xd9, 0x3e, 0x7f, 0x34, 0xc4,
0x16, 0xec, 0x44, 0xe2, 0x24, 0xae, 0x6d, 0xb0, 0xd7, 0xcb, 0xe5, 0x49,
0xe2, 0x31, 0xae, 0x5f, 0x93, 0xfd, 0x9b, 0x17, 0xfe, 0x3d, 0x1f, 0x56,
0x70, 0x94, 0xbc, 0x7f, 0x47, 0x7f, 0x5b, 0x71, 0xdc, 0xa4, 0x43, 0x4a,
0xdf, 0xe9, 0x4c, 0x9f, 0xee, 0xb4, 0xc1, 0x9e, 0x30, 0x91, 0xf1, 0x75,
0xf1, 0x27, 0xac, 0xf8, 0xe2, 0xf5, 0x6b, 0xd1, 0x18, 0x28, 0xaf, 0x11,
0x37, 0x4a, 0xa8, 0x0a, 0x5b, 0xec, 0x9d, 0x1e, 0xc6, 0x72, 0xa3, 0x98,
0x0d, 0x03, 0xd3, 0x53, 0x0a, 0x25, 0x11, 0x97, 0x26, 0xf4, 0xf5, 0x95,
0xe4, 0xc1, 0x9f, 0x47, 0x14, 0x3b, 0x60, 0xe6, 0x6f, 0x91, 0x05, 0xcb,
0x63, 0xbf, 0xef, 0x3d, 0xcc, 0xde, 0xc1, 0xf1, 0x6e, 0x7f, 0xf1, 0x2e,
0x26, 0x78, 0xa5, 0x8e, 0xac, 0xf4, 0x32, 0xa3, 0xfd, 0xf0, 0x70, 0xa3,
0x5c, 0xc0, 0xe0, 0x1b, 0x93, 0x5a, 0x63, 0xe8, 0x7d, 0x40, 0xdb, 0xd9,
0xd3, 0x8e, 0xbb, 0x4c, 0x86, 0x2e, 0x5a, 0xb2, 0xf2, 0x56, 0xcc, 0xde,
0x63, 0x56, 0x9e, 0x30, 0x99, 0x18, 0x23, 0x35, 0x3f, 0xde, 0x07, 0x7f,
0xe6, 0xe3, 0x06, 0xbb, 0xaa, 0x75, 0xe7, 0x9c, 0x6c, 0x0f, 0xbd, 0xac,
0x24, 0x60, 0xac, 0x46, 0xb2, 0x5a, 0x9e, 0xdf, 0x48, 0xeb, 0xab, 0xc0,
0x1b, 0x8c, 0x70, 0xd8, 0x14, 0x4b, 0xa3, 0x58, 0xa7, 0x50, 0x62, 0x99,
0xb1, 0xd5, 0xad, 0xa5, 0xbd, 0x7f, 0x9b, 0xae, 0x37, 0x69, 0xed, 0x37,
0x32, 0xd4, 0x19, 0xe1, 0x34, 0x28, 0xc6, 0xee, 0x67, 0xfc, 0x5d, 0x05,
0x27, 0x53, 0xd1, 0xd3, 0x3f, 0xcd, 0xcc, 0x22, 0xac, 0xc3, 0x24, 0x39,
0x3e, 0x17, 0xc5, 0x34, 0x01, 0xdd, 0xbd, 0x71, 0xca, 0x78, 0xe3, 0x90,
0x33, 0xc0, 0xf7, 0x4b, 0xc0, 0xa2, 0xd5, 0x7f, 0xaa, 0x62, 0xd0, 0x88,
0xd4, 0x2b, 0x2c, 0x9c, 0xf2, 0x2f, 0xf4, 0xd2, 0xfc, 0xcd, 0x96, 0x67,
0x78, 0x11, 0xb7, 0xe3, 0x17, 0x7c, 0x8f, 0x94, 0xfe, 0xf1, 0xd6, 0x20,
0x32, 0x68, 0xc9, 0xe4, 0xd6, 0xb9, 0x52, 0xc1, 0x10, 0x0a, 0xe5, 0x62,
0x6d, 0x67, 0x0f, 0x01, 0x3c, 0x91, 0x7a, 0x92, 0x19, 0x40, 0x3b, 0xb5,
0xfb, 0xea, 0x23, 0xe9, 0xb0, 0x7e, 0xde, 0x32, 0x21, 0xd1, 0x05, 0xa0,
0x14, 0x76, 0x7f, 0xc8, 0x31, 0xf2, 0xcd, 0xa2, 0xf3, 0xa7, 0x43, 0x57,
0x9f, 0x84, 0xed, 0x38, 0xdb, 0xf4, 0x37, 0x3e, 0x20, 0xd5, 0xb7, 0x06,
0x21, 0x1f, 0xce, 0xf9, 0x6c, 0xbc, 0x56, 0x6b, 0xec, 0x9d, 0xef, 0x12,
0x87, 0x00, 0xf8, 0x1c, 0x1f, 0xa2, 0xc7, 0x8a, 0x4b, 0x7b, 0xb6, 0x6a,
0x7b, 0xd4, 0xa8, 0x78, 0x30, 0x20, 0xb7, 0xc3, 0x45, 0x54, 0xbc, 0x4a,
0xf6, 0xe5, 0x9e, 0xef, 0x17, 0x4f, 0x40, 0xfa, 0xfa, 0x90, 0xa2, 0x68,
0x40, 0xbf, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x3e, 0xba, 0xff, 0xff, 0x04, 0x00, 0x00, 0x00, 0xbc, 0x43, 0x00, 0x00,
0x23, 0xee, 0x18, 0x05, 0xec, 0xbb, 0x24, 0x1b, 0x1b, 0xd6, 0x3b, 0x04,
0x15, 0xcd, 0x1c, 0xff, 0xe1, 0xe6, 0x38, 0x03, 0x0e, 0x23, 0x0b, 0xec,
0x03, 0x30, 0xe1, 0xf9, 0x34, 0x0e, 0xe9, 0x15, 0x0d, 0xec, 0x1a, 0x9d,
0x1e, 0xda, 0xf6, 0xf9, 0x0f, 0xca, 0x07, 0xd6, 0x1d, 0x11, 0x27, 0x0c,
0xfa, 0x10, 0x13, 0x25, 0x3e, 0x05, 0xfb, 0x2c, 0xe4, 0xcb, 0x0f, 0x0e,
0xe7, 0xf5, 0x1e, 0x12, 0x0b, 0xc0, 0xe3, 0x0f, 0xfe, 0xe5, 0x4c, 0xff,
0x21, 0xd3, 0x15, 0xe5, 0x27, 0x21, 0x09, 0x05, 0x0e, 0xe6, 0x0c, 0xed,
0xf9, 0x31, 0xf9, 0xf5, 0x39, 0x0f, 0x22, 0xe9, 0x05, 0x0b, 0xf7, 0xaf,
0x11, 0xf0, 0x35, 0xeb, 0x3c, 0x08, 0xfd, 0x00, 0x1a, 0x0d, 0x12, 0xf1,
0x22, 0xfe, 0x0f, 0xee, 0x2c, 0xfe, 0x03, 0x39, 0x16, 0xd6, 0x25, 0xd8,
0x1b, 0xfc, 0x0a, 0x01, 0xee, 0xb1, 0x06, 0xff, 0x3d, 0xdd, 0x27, 0xda,
0x06, 0xc8, 0x10, 0xe3, 0x27, 0xef, 0xf9, 0x19, 0xf7, 0xe9, 0x22, 0x1d,
0xd4, 0x3f, 0xe4, 0xb6, 0x06, 0xf6, 0x0d, 0x22, 0x0d, 0xf8, 0xee, 0xad,
0x13, 0x11, 0x2f, 0xd6, 0x25, 0xd3, 0xe6, 0x03, 0xf1, 0xf6, 0xfa, 0xf2,
0x32, 0x16, 0xea, 0x27, 0x33, 0x0c, 0x10, 0x22, 0xff, 0xd0, 0x24, 0xf4,
0x13, 0x24, 0xfb, 0xdd, 0x01, 0x9e, 0xe7, 0xf3, 0x06, 0xcf, 0x17, 0xe1,
0xe4, 0xea, 0xf5, 0x16, 0x25, 0x03, 0xff, 0xda, 0xd3, 0x16, 0x23, 0x1b,
0xfd, 0x36, 0x0e, 0xb4, 0x0a, 0xe4, 0xf6, 0xfb, 0x0f, 0xe0, 0xf1, 0xa4,
0x00, 0x11, 0x0b, 0xe0, 0x15, 0xdf, 0x00, 0xce, 0xe5, 0xf7, 0xfb, 0xe9,
0x03, 0xf9, 0xe2, 0x1c, 0x3b, 0x14, 0xe4, 0x01, 0xfe, 0xee, 0xf3, 0xf0,
0xee, 0xfb, 0x0a, 0xe5, 0xf3, 0xa0, 0xfb, 0xea, 0x0c, 0xe8, 0x48, 0xcc,
0x09, 0xdb, 0x1f, 0xe9, 0xe1, 0x0f, 0xf5, 0x08, 0x16, 0xe6, 0x09, 0x05,
0xd3, 0x33, 0x08, 0xbe, 0x0f, 0x00, 0xfb, 0x09, 0xe5, 0x21, 0xeb, 0xcd,
0xe2, 0xed, 0x12, 0xe7, 0x0f, 0x05, 0x16, 0xde, 0xf2, 0xd9, 0x0a, 0x1b,
0x1f, 0xe7, 0xd2, 0xf5, 0x32, 0x05, 0xf3, 0x23, 0xec, 0xb4, 0x18, 0xfd,
0x07, 0xe1, 0xe8, 0xe8, 0x0d, 0xc8, 0x25, 0x17, 0xfe, 0xee, 0x2f, 0xf5,
0xe3, 0xd3, 0xfe, 0x19, 0x12, 0x1e, 0xfa, 0xe6, 0xdb, 0x0f, 0x38, 0x0c,
0xe8, 0x1f, 0x25, 0xdd, 0xff, 0xcd, 0xf1, 0xf1, 0xe0, 0xf1, 0x06, 0xdc,
0xe5, 0xde, 0x02, 0xd2, 0x48, 0xc4, 0xf7, 0xe3, 0x13, 0x05, 0x27, 0xe6,
0x10, 0xf4, 0x14, 0x0d, 0x39, 0xeb, 0xee, 0x0a, 0x09, 0xc7, 0xed, 0xc9,
0xf4, 0x03, 0xf7, 0xfd, 0x1f, 0xa7, 0x1b, 0xe2, 0x31, 0x00, 0x0b, 0xfd,
0xef, 0x0d, 0xe7, 0x12, 0x1d, 0xed, 0x21, 0xfe, 0xe0, 0xde, 0x0f, 0x13,
0xea, 0x2a, 0xeb, 0xea, 0x2f, 0xe9, 0xf4, 0x1e, 0x21, 0xe2, 0x12, 0xd9,
0x1c, 0x17, 0x21, 0xc8, 0x2a, 0x13, 0xe7, 0x25, 0xf3, 0xff, 0x26, 0x23,
0x17, 0x17, 0xf5, 0xe6, 0x3a, 0xe3, 0x13, 0x30, 0x19, 0xd0, 0x00, 0xf2,
0xe6, 0xeb, 0xe1, 0x17, 0x22, 0xa8, 0x23, 0x0c, 0x14, 0xd2, 0x31, 0xf1,
0xfe, 0x14, 0xea, 0xef, 0xfd, 0xed, 0x1a, 0xfc, 0xd3, 0xf2, 0x1c, 0x0d,
0xfa, 0x26, 0xfb, 0xbf, 0xfd, 0x03, 0x0c, 0xfd, 0xfe, 0xdd, 0xf2, 0xdc,
0x1d, 0x00, 0x0e, 0xf4, 0x22, 0xcf, 0x0f, 0x24, 0x0b, 0xdf, 0x0e, 0x08,
0x2a, 0x02, 0x0c, 0x0f, 0x35, 0xf8, 0xf5, 0x34, 0xea, 0xed, 0xf8, 0xd0,
0xe7, 0xe2, 0x09, 0x0c, 0x1c, 0xcc, 0xed, 0x1d, 0x29, 0xdb, 0x25, 0xd6,
0x09, 0x11, 0xea, 0xf0, 0x0a, 0x05, 0x28, 0x1e, 0xf2, 0xf0, 0x1a, 0xf6,
0xde, 0x33, 0x04, 0xfb, 0x27, 0xed, 0x08, 0x13, 0x0e, 0x19, 0xe0, 0xc8,
0xf3, 0xfe, 0xf3, 0x0d, 0x1c, 0xdd, 0xf0, 0xf7, 0xf4, 0x02, 0x1b, 0x0a,
0x0f, 0xf8, 0xd7, 0x25, 0x23, 0x02, 0x15, 0x0f, 0xf2, 0xc5, 0x04, 0x02,
0xf4, 0xe8, 0xf5, 0x1d, 0x19, 0xab, 0xed, 0xf8, 0x1e, 0xf2, 0x3d, 0xd8,
0x06, 0xe1, 0xf6, 0xdf, 0xfe, 0x14, 0x0d, 0x01, 0xe4, 0x06, 0x35, 0x03,
0x06, 0x23, 0xf5, 0xb9, 0x12, 0xd5, 0xec, 0x0f, 0xde, 0x19, 0x1f, 0xc0,
0x0a, 0xe3, 0x3b, 0xd9, 0x26, 0x04, 0xf2, 0x13, 0xf7, 0x14, 0x00, 0x0f,
0x15, 0xee, 0xff, 0x15, 0x06, 0xf4, 0xf3, 0x1b, 0xf1, 0xdc, 0xf0, 0xe4,
0xe1, 0x1c, 0x0d, 0x00, 0x0e, 0xd5, 0xfb, 0xe1, 0xfc, 0xf7, 0x16, 0xd0,
0xe0, 0x10, 0x20, 0xff, 0xfd, 0x1f, 0xf5, 0x21, 0xea, 0x28, 0x0a, 0xe3,
0xfb, 0x32, 0x1c, 0xcf, 0x2a, 0xd7, 0x20, 0xea, 0x11, 0xe7, 0xed, 0x9f,
0xe1, 0x1c, 0xf8, 0xf2, 0x3c, 0xcb, 0xe7, 0xe7, 0x16, 0xdc, 0x11, 0xf6,
0x20, 0xe1, 0x11, 0x13, 0x2b, 0x02, 0x1a, 0x18, 0x1e, 0xb3, 0x29, 0x06,
0x1a, 0x10, 0x1b, 0xfa, 0x1f, 0xae, 0x11, 0xe1, 0x00, 0xfd, 0x3d, 0xf1,
0x20, 0x08, 0xfe, 0x17, 0x24, 0x1a, 0x2a, 0x11, 0xd1, 0xe5, 0x0f, 0xf4,
0xf2, 0x19, 0xe2, 0xa9, 0xf1, 0xd1, 0x21, 0xe1, 0x1b, 0xed, 0x02, 0xcb,
0x18, 0xe9, 0x05, 0x00, 0x21, 0xf4, 0x12, 0xf0, 0x07, 0xd8, 0x10, 0x03,
0x1a, 0xef, 0x00, 0xf2, 0x28, 0xef, 0xfc, 0x37, 0x11, 0xe8, 0x0a, 0x09,
0xe6, 0xf9, 0xe7, 0xef, 0x16, 0xbb, 0xf4, 0xd9, 0x1f, 0xf8, 0x10, 0xe8,
0xfd, 0xcc, 0xed, 0xf2, 0xf7, 0x11, 0x25, 0x12, 0xf2, 0x06, 0x0c, 0x0b,
0x0e, 0x0e, 0xdd, 0xe5, 0x20, 0xe8, 0xf1, 0x06, 0x1e, 0x06, 0x24, 0xab,
0x25, 0x14, 0x15, 0xd0, 0x1d, 0xf2, 0x17, 0xe4, 0xf4, 0x0f, 0x11, 0x00,
0xf3, 0xd7, 0x0c, 0xf1, 0x1f, 0x11, 0x18, 0x37, 0xfa, 0xc7, 0x07, 0x07,
0x13, 0xee, 0x12, 0xfc, 0x1a, 0xc9, 0xf0, 0xf4, 0x3b, 0xc1, 0x18, 0xd2,
0xf3, 0x0e, 0xf4, 0xd2, 0x0b, 0xfa, 0x2a, 0x0d, 0xf4, 0xe4, 0x18, 0xfb,
0xff, 0x0a, 0xe0, 0xb5, 0x2c, 0xdc, 0xf3, 0xeb, 0x00, 0x13, 0x0d, 0xcf,
0xe6, 0x09, 0x1b, 0xd2, 0x4d, 0xec, 0x1e, 0xe3, 0xf8, 0x17, 0xe7, 0x17,
0x07, 0xfc, 0xea, 0x19, 0x13, 0x19, 0x02, 0x3a, 0xed, 0xd2, 0xf9, 0xe9,
0x05, 0xf5, 0x0e, 0x0e, 0xe7, 0xc7, 0x20, 0x0d, 0x22, 0xee, 0x43, 0xe9,
0xe0, 0x00, 0x03, 0xdc, 0xea, 0xea, 0x39, 0xd6, 0xd2, 0xe8, 0x20, 0x0b,
0xe6, 0x0b, 0x00, 0xec, 0x2b, 0xe3, 0x00, 0x24, 0xe3, 0xee, 0x20, 0xda,
0x21, 0xf2, 0x29, 0xdc, 0x2b, 0x09, 0x0e, 0xc0, 0xeb, 0x11, 0x17, 0x00,
0x1f, 0xf0, 0xfa, 0x0c, 0x2f, 0x1b, 0x09, 0x31, 0xf1, 0xcf, 0x1a, 0x0a,
0x00, 0x07, 0xfc, 0xf5, 0x21, 0xdd, 0x20, 0x18, 0x30, 0xeb, 0x11, 0xde,
0xeb, 0x00, 0xde, 0x01, 0xe2, 0xe1, 0x00, 0xd2, 0xd8, 0x0a, 0x32, 0x16,
0x15, 0x14, 0xe7, 0xe1, 0xec, 0x05, 0x00, 0x0e, 0x1b, 0xe1, 0xf3, 0xa2,
0x05, 0xeb, 0x0f, 0xfb, 0x3d, 0x0f, 0x08, 0xde, 0x04, 0xd7, 0x09, 0x12,
0x1c, 0xec, 0xf7, 0xdb, 0x32, 0x04, 0x13, 0x15, 0x08, 0xea, 0xf8, 0x01,
0xf3, 0x17, 0xdd, 0xfd, 0xe5, 0x9e, 0x1e, 0x08, 0x32, 0xeb, 0x33, 0xfd,
0x10, 0x13, 0x1b, 0xdb, 0xf8, 0xe2, 0x2c, 0x20, 0xf5, 0x09, 0x2d, 0x0d,
0xd5, 0x2f, 0x03, 0xe6, 0xf0, 0x11, 0x1e, 0x08, 0xfc, 0xe9, 0x01, 0xd8,
0xf8, 0xf3, 0x25, 0xee, 0x4f, 0x0d, 0x15, 0x02, 0x16, 0xf5, 0x26, 0xee,
0x18, 0x00, 0x09, 0x15, 0x38, 0x11, 0xec, 0x07, 0xff, 0xe6, 0x13, 0xf7,
0xea, 0x1d, 0x17, 0x1b, 0xed, 0xb5, 0x07, 0xde, 0x22, 0x09, 0x33, 0xf3,
0xed, 0xd6, 0xfc, 0xfa, 0x1e, 0x01, 0x0b, 0x02, 0x07, 0xea, 0x46, 0xed,
0xdf, 0x29, 0x17, 0xd3, 0x42, 0xe3, 0xf1, 0x02, 0x1b, 0x12, 0x17, 0xbc,
0x19, 0xea, 0x37, 0x02, 0x37, 0xf3, 0x18, 0xe1, 0xe1, 0x02, 0xe7, 0xff,
0x32, 0x14, 0xd6, 0xe8, 0x42, 0xfe, 0xec, 0x11, 0xfb, 0xcf, 0x29, 0xf2,
0xfa, 0xec, 0x07, 0x04, 0x04, 0x97, 0xe7, 0xe4, 0xf9, 0xce, 0x0a, 0xfc,
0xde, 0xd9, 0xf4, 0xde, 0x25, 0xe9, 0x27, 0x08, 0xf1, 0x0f, 0x2a, 0x18,
0xe3, 0xf8, 0x0b, 0xe1, 0xf0, 0xe3, 0x16, 0xf8, 0xf6, 0x12, 0x0c, 0xe8,
0x27, 0xff, 0xfe, 0xf7, 0x4e, 0xcd, 0xff, 0x06, 0x1c, 0x13, 0xf6, 0x08,
0x17, 0x18, 0xef, 0x14, 0x19, 0x22, 0xdc, 0x21, 0x14, 0xc3, 0xf3, 0xd3,
0x0b, 0xe8, 0x21, 0xdf, 0x04, 0xd2, 0xeb, 0x10, 0x2d, 0xfc, 0x3e, 0xe4,
0xfa, 0xf2, 0x24, 0xf9, 0xf2, 0x0e, 0x1d, 0x1a, 0x01, 0x11, 0x25, 0xf5,
0x21, 0x16, 0x0c, 0xca, 0x2d, 0xd7, 0xfa, 0xf1, 0x0a, 0x05, 0x11, 0x92,
0x0f, 0x00, 0x1e, 0xd8, 0x33, 0xdc, 0x14, 0xe3, 0xf5, 0x10, 0x1f, 0xf9,
0xfb, 0xd7, 0x00, 0xf4, 0x2a, 0x20, 0x0b, 0x09, 0xfd, 0xc1, 0xeb, 0xdb,
0x06, 0x0c, 0x05, 0x1b, 0x0c, 0xb4, 0x03, 0xff, 0x33, 0xd2, 0x20, 0xe1,
0x1d, 0x11, 0xf7, 0x06, 0x06, 0xe7, 0xf5, 0xfd, 0x09, 0xf7, 0x2c, 0xeb,
0xf1, 0x43, 0xe3, 0xde, 0xf7, 0xc8, 0x19, 0x26, 0x0b, 0x01, 0xf1, 0xb3,
0x03, 0xf6, 0xfe, 0xe8, 0x31, 0xd6, 0x08, 0x08, 0x0e, 0x1b, 0x14, 0xe3,
0x28, 0xf7, 0xf6, 0x29, 0x1c, 0x17, 0x0f, 0x09, 0xe6, 0xec, 0x26, 0xdb,
0x10, 0x0e, 0xf7, 0xe2, 0x21, 0xbe, 0x0c, 0xde, 0xf5, 0xe4, 0x34, 0xd8,
0x1f, 0xce, 0x12, 0x15, 0x1c, 0x0e, 0x04, 0xf1, 0x15, 0xf3, 0x2c, 0xf2,
0xe3, 0x09, 0xf3, 0xb1, 0xf1, 0xf2, 0xf3, 0xe2, 0x1a, 0x0f, 0x17, 0xa7,
0xea, 0xdf, 0x30, 0xdf, 0x4f, 0xf4, 0x16, 0x05, 0x21, 0xfe, 0x05, 0x1a,
0x28, 0xe9, 0xe4, 0xf6, 0x3f, 0xee, 0xe6, 0x00, 0xf3, 0xe6, 0x04, 0xf9,
0x0e, 0x22, 0x23, 0xe7, 0x1a, 0x9e, 0x0b, 0xfb, 0x11, 0xe3, 0x42, 0x01,
0x1f, 0x14, 0x11, 0xfd, 0x10, 0xe4, 0x1f, 0xfe, 0xeb, 0xdd, 0x1f, 0xeb,
0xea, 0x1a, 0xec, 0xb7, 0x03, 0x00, 0x1f, 0xf6, 0xea, 0x14, 0x06, 0xb4,
0xea, 0xde, 0x2a, 0xcc, 0x1c, 0xf0, 0xe2, 0xed, 0xdd, 0xdc, 0xf5, 0x08,
0xf1, 0x03, 0xf4, 0x17, 0x43, 0xf9, 0x18, 0x42, 0xfe, 0xaf, 0xee, 0x09,
0xdd, 0xe4, 0xf1, 0xfc, 0xe3, 0xaf, 0x0d, 0xe2, 0xf9, 0xe5, 0x4e, 0xd3,
0xf0, 0xf2, 0x1f, 0x02, 0xf4, 0x00, 0x2a, 0xd0, 0x0d, 0x1d, 0x2f, 0xe2,
0xe3, 0x31, 0x19, 0xe7, 0x11, 0xf7, 0xf1, 0x16, 0x0c, 0x0d, 0xfd, 0xa7,
0x24, 0xf9, 0x2a, 0xd3, 0x54, 0xcc, 0x26, 0xe2, 0xea, 0xe1, 0x14, 0x0f,
0x36, 0xf8, 0xd5, 0xf7, 0x3c, 0xe7, 0xd3, 0x24, 0xfc, 0xa9, 0xfe, 0xff,
0xf1, 0x03, 0x16, 0xfb, 0xe3, 0xc8, 0x15, 0xe0, 0x34, 0xfa, 0x50, 0xee,
0xe8, 0xea, 0xef, 0x16, 0xf1, 0x12, 0x1b, 0xdc, 0x11, 0x0e, 0x1a, 0x1b,
0xda, 0x08, 0xf1, 0xbf, 0x30, 0xf4, 0x0a, 0xef, 0x1d, 0xfa, 0x17, 0x95,
0x0f, 0x14, 0x3d, 0xfd, 0x49, 0xf9, 0x10, 0xfe, 0xf4, 0x08, 0xea, 0xe1,
0x38, 0x02, 0x14, 0x05, 0x2d, 0x23, 0xdf, 0x34, 0xe1, 0xe4, 0x39, 0xce,
0x13, 0x0b, 0xf2, 0xfe, 0x1a, 0xbc, 0x11, 0xea, 0x39, 0xc9, 0x19, 0xed,
0x11, 0xfc, 0xfa, 0xda, 0x16, 0x11, 0x20, 0x10, 0xe0, 0xe1, 0x13, 0xf0,
0xef, 0x19, 0x21, 0xd7, 0x14, 0xf5, 0x22, 0x15, 0xe5, 0x11, 0xef, 0xcc,
0x0e, 0xf4, 0x34, 0x01, 0x47, 0x1a, 0xee, 0xd3, 0xfa, 0x17, 0x12, 0x1e,
0xf7, 0xda, 0xe6, 0x09, 0x17, 0xe1, 0x09, 0x26, 0xdf, 0xef, 0x44, 0xf5,
0x07, 0xe5, 0xdc, 0xff, 0x09, 0x95, 0x08, 0x1d, 0x44, 0xec, 0x32, 0xce,
0x1b, 0xee, 0x21, 0x0e, 0xf7, 0x1c, 0x10, 0x00, 0xdf, 0x01, 0x1e, 0x1c,
0x07, 0x0a, 0x05, 0xdb, 0xe5, 0xd0, 0xdc, 0x03, 0x00, 0xe1, 0xe7, 0xa6,
0xe2, 0x13, 0x3d, 0x02, 0x2a, 0x01, 0x1d, 0xf7, 0xf5, 0x01, 0x08, 0xe9,
0x14, 0x0a, 0xed, 0x1c, 0x3a, 0xef, 0xe7, 0x19, 0xe7, 0xc2, 0x1e, 0xe4,
0x20, 0x20, 0xf1, 0x05, 0xe8, 0xe2, 0xf6, 0xef, 0x13, 0xd8, 0x0a, 0xef,
0xfe, 0xf0, 0x16, 0xfe, 0x1e, 0x11, 0x19, 0xe3, 0xdc, 0x2d, 0x1c, 0xf4,
0x0f, 0xfb, 0x0f, 0xd8, 0x23, 0xdf, 0xe7, 0x1f, 0x00, 0xe2, 0x0e, 0x9b,
0xf2, 0x12, 0x28, 0xc9, 0x3d, 0xd8, 0xf2, 0xd7, 0x1f, 0x14, 0x10, 0xee,
0x2f, 0xe5, 0xff, 0x17, 0x1c, 0x1c, 0xe2, 0x09, 0xe2, 0xbd, 0x0c, 0xfd,
0xed, 0x06, 0x07, 0xf4, 0xf3, 0xb2, 0x14, 0xd9, 0x2f, 0xfe, 0x33, 0x01,
0xfe, 0x0d, 0xf5, 0xe9, 0x25, 0x07, 0xf2, 0x0c, 0xf2, 0x02, 0x21, 0xdc,
0xf1, 0x45, 0x0d, 0xe1, 0x36, 0xdf, 0xf1, 0x17, 0x1d, 0xec, 0xdf, 0xb8,
0x1f, 0x08, 0x1c, 0xd4, 0x3f, 0xcd, 0x1f, 0xdb, 0xfb, 0xe4, 0xfe, 0x04,
0xf2, 0xee, 0xf5, 0x05, 0x25, 0x18, 0xfd, 0x19, 0xd9, 0xd6, 0x1d, 0xe9,
0xe4, 0x17, 0x15, 0x0b, 0x14, 0xac, 0x0c, 0x14, 0x1f, 0xd6, 0x45, 0xcc,
0x0d, 0xda, 0x01, 0xd6, 0x0a, 0x02, 0x18, 0xef, 0xe5, 0x1c, 0x40, 0x0b,
0xfa, 0x0e, 0xf8, 0xce, 0xfe, 0xd8, 0xe9, 0xf3, 0xf8, 0xe0, 0x00, 0xab,
0x12, 0xe9, 0x04, 0xcf, 0x1f, 0x08, 0xf2, 0xd5, 0xe7, 0xd4, 0x02, 0x07,
0x04, 0xe1, 0xdf, 0xea, 0x37, 0xf4, 0xe6, 0xfa, 0x0e, 0xc2, 0x10, 0xe7,
0xee, 0xe4, 0xfb, 0x04, 0x0f, 0xab, 0x27, 0x10, 0x24, 0xbf, 0x15, 0xd6,
0x12, 0xe2, 0xff, 0xf3, 0xf3, 0xed, 0x09, 0x12, 0x0a, 0x0d, 0x2c, 0xf9,
0xf7, 0x06, 0xe6, 0xb2, 0xfd, 0xfb, 0xf5, 0xf0, 0xe7, 0xf6, 0x10, 0xa6,
0x27, 0x10, 0x0d, 0x01, 0x4a, 0x06, 0x1b, 0x0c, 0x16, 0x01, 0xfc, 0xf6,
0xf2, 0x1e, 0x07, 0xf4, 0x1f, 0x02, 0xdd, 0x40, 0x1f, 0xcd, 0x22, 0xc8,
0xfa, 0xe2, 0xff, 0xfb, 0xf3, 0xad, 0xf3, 0x13, 0x0b, 0xef, 0x37, 0xfb,
0x12, 0x0d, 0xf4, 0xdc, 0xf6, 0xea, 0xfe, 0xf6, 0xfe, 0xe4, 0x17, 0x0c,
0xfa, 0x1f, 0xfe, 0xc1, 0x11, 0x00, 0x0b, 0x13, 0xe0, 0x17, 0x20, 0xbe,
0x1d, 0x02, 0xf6, 0xe2, 0x36, 0x09, 0x1e, 0xca, 0x17, 0xf9, 0xfd, 0x18,
0xfd, 0xdd, 0x10, 0xfb, 0x3e, 0x05, 0xe3, 0xfa, 0xe1, 0xbd, 0x22, 0xdd,
0x13, 0xf5, 0xeb, 0x10, 0x23, 0xa7, 0xfa, 0xf1, 0x13, 0xce, 0x3c, 0xf9,
0xec, 0xd7, 0xee, 0x01, 0x1a, 0xdf, 0x26, 0xdb, 0xf0, 0xe4, 0x1e, 0x23,
0xe6, 0x37, 0xe0, 0xd4, 0x3f, 0xe3, 0x1b, 0xe1, 0x1a, 0x20, 0xe5, 0xdc,
0xef, 0xe1, 0x2d, 0xd8, 0x27, 0xfa, 0x0e, 0xdb, 0x05, 0xf3, 0xed, 0xe9,
0xf6, 0x08, 0x0a, 0x12, 0x44, 0xf2, 0xf0, 0x2b, 0x11, 0xaf, 0x15, 0x07,
0x02, 0xee, 0xf7, 0xe6, 0x0d, 0xbc, 0xfa, 0xfd, 0x39, 0xca, 0x14, 0x16,
0xe4, 0xe5, 0xf2, 0xf1, 0x1f, 0x1b, 0x1c, 0x0c, 0x10, 0x15, 0x30, 0xe1,
0xd0, 0x3e, 0xe8, 0xcd, 0x2e, 0xec, 0xf9, 0xf9, 0xde, 0x10, 0x0a, 0xa4,
0x09, 0xf2, 0x14, 0xd1, 0x51, 0xc8, 0x08, 0x1b, 0x0e, 0x10, 0x1e, 0xe9,
0x24, 0xf4, 0xf6, 0x0f, 0xfe, 0x22, 0xdf, 0x05, 0x0e, 0xb2, 0x1d, 0xd9,
0xe6, 0x0c, 0xf1, 0x16, 0xe2, 0x9f, 0xe7, 0xf7, 0x40, 0xd3, 0x4b, 0x22,
0x11, 0xd8, 0xf3, 0x0a, 0x26, 0xed, 0x19, 0x19, 0xfa, 0xf9, 0x05, 0x10,
0x1f, 0x08, 0xff, 0xbb, 0x12, 0xd0, 0x03, 0xfb, 0xf8, 0x20, 0x10, 0xb6,
0x22, 0xfa, 0x2b, 0xef, 0x1e, 0xdb, 0x04, 0x13, 0x21, 0xd7, 0xf5, 0x1f,
0x2c, 0x02, 0xd3, 0x30, 0x28, 0x1b, 0x03, 0x2a, 0xee, 0xb7, 0x1e, 0xe7,
0xe5, 0xff, 0xe9, 0xe4, 0x0d, 0x93, 0x19, 0xe9, 0x17, 0xd0, 0x33, 0xe1,
0x03, 0xce, 0x02, 0x02, 0x16, 0x11, 0x33, 0xf5, 0xe9, 0x09, 0x40, 0xfa,
0xe8, 0x29, 0x1b, 0xd7, 0x11, 0x01, 0xfe, 0x06, 0xe3, 0xe9, 0xe9, 0xad,
0x1c, 0xf3, 0x22, 0xdb, 0x28, 0x07, 0x13, 0xef, 0xf1, 0xfe, 0xff, 0x1c,
0x2e, 0xef, 0x12, 0x30, 0x23, 0x09, 0x05, 0x0e, 0x14, 0xb1, 0x10, 0xd4,
0xe6, 0x20, 0x11, 0xf7, 0x04, 0xd7, 0x18, 0xe0, 0x31, 0x01, 0x22, 0xe2,
0x02, 0xe3, 0xfd, 0xe9, 0xe2, 0xe6, 0x17, 0x15, 0xf5, 0xfd, 0x0a, 0x16,
0xea, 0x0a, 0xf8, 0xeb, 0x2c, 0xea, 0xee, 0xf4, 0x0f, 0xfd, 0xde, 0xae,
0xf8, 0x03, 0xfd, 0x01, 0x53, 0xcd, 0x15, 0x18, 0x03, 0xeb, 0xe9, 0xec,
0x10, 0x0f, 0xee, 0x0d, 0x42, 0x20, 0xf6, 0xf8, 0xf3, 0xbb, 0xee, 0x02,
0x1b, 0xec, 0xfc, 0x01, 0xe8, 0xae, 0x19, 0xdf, 0xfd, 0xdd, 0x3c, 0xee,
0x08, 0x10, 0xf9, 0xec, 0xea, 0xe1, 0x14, 0xcf, 0xfd, 0x23, 0x27, 0xf1,
0x1b, 0x0c, 0x0d, 0xe4, 0x13, 0xff, 0x05, 0x0e, 0x09, 0x14, 0xe6, 0xcf,
0x05, 0xe8, 0xee, 0xce, 0x47, 0xea, 0x04, 0xf3, 0xf1, 0xf2, 0x09, 0xf1,
0xf2, 0xd6, 0xd7, 0x13, 0xfc, 0x1b, 0x12, 0x2b, 0x19, 0xdb, 0xf7, 0xd1,
0xfa, 0x0b, 0x1b, 0x00, 0x1f, 0xc6, 0x1c, 0xe2, 0x10, 0xc9, 0x1b, 0xfe,
0x0b, 0xca, 0x20, 0xe8, 0x1a, 0xea, 0xf6, 0x0f, 0xf5, 0x22, 0x0d, 0xeb,
0xec, 0x36, 0xfc, 0xb9, 0x23, 0xcc, 0x08, 0x02, 0x04, 0x0b, 0x0a, 0xc8,
0x10, 0x09, 0x04, 0xe9, 0x3e, 0xeb, 0x12, 0xf6, 0xe0, 0xe9, 0x1f, 0x04,
0x13, 0xfc, 0x0c, 0xfc, 0x42, 0xe6, 0xf1, 0xf6, 0x13, 0xb3, 0x09, 0xc9,
0x12, 0xf5, 0x05, 0x08, 0xe8, 0xe3, 0x03, 0xf2, 0x30, 0xea, 0x32, 0x02,
0x14, 0x03, 0x1b, 0xfb, 0xef, 0x09, 0xf4, 0x12, 0xe8, 0xe7, 0x2a, 0xf9,
0xd8, 0x13, 0xf1, 0xd7, 0xea, 0xef, 0xec, 0xe2, 0xf9, 0x15, 0x17, 0xdf,
0xf9, 0xf2, 0x0a, 0xbb, 0x2f, 0xfa, 0x08, 0xf8, 0x21, 0xda, 0x0d, 0xfb,
0xf7, 0xf7, 0x09, 0xe5, 0x2f, 0x17, 0xfe, 0x3e, 0xf6, 0xab, 0x1f, 0xf2,
0xed, 0x16, 0xfb, 0xf4, 0x13, 0xc7, 0x1e, 0xd6, 0x03, 0xf1, 0x44, 0xf3,
0xfc, 0x17, 0x0d, 0x0c, 0x08, 0xf3, 0x33, 0xf2, 0xe0, 0xff, 0x18, 0x00,
0xe0, 0x2a, 0x04, 0xc4, 0x07, 0xcf, 0x20, 0x26, 0xde, 0xe4, 0x23, 0xa8,
0x0f, 0xf7, 0xfc, 0xeb, 0x1c, 0xe9, 0x26, 0xf7, 0x20, 0x02, 0x03, 0xdf,
0xfd, 0x1e, 0xfc, 0x0a, 0x10, 0x1c, 0x01, 0x27, 0x04, 0xbe, 0x15, 0xeb,
0x0b, 0xf8, 0xde, 0x1c, 0xe4, 0xdf, 0x22, 0xe5, 0x0a, 0xc9, 0x19, 0x02,
0xfe, 0xfb, 0x09, 0x05, 0xf5, 0x1e, 0x1b, 0x23, 0xe7, 0x11, 0x24, 0x01,
0xe1, 0x28, 0xef, 0xc7, 0x27, 0xcb, 0x0d, 0xfe, 0xde, 0x0f, 0xeb, 0xa7,
0xfa, 0xf4, 0x0d, 0x01, 0x44, 0x1d, 0xfb, 0x19, 0x20, 0xf6, 0xf8, 0xe7,
0x07, 0x00, 0xde, 0x05, 0x0f, 0xde, 0xce, 0x0a, 0xe7, 0xd2, 0x0b, 0xe7,
0xf4, 0xec, 0xed, 0xef, 0x1f, 0x95, 0x01, 0x05, 0x0f, 0xf1, 0x4d, 0xfa,
0xef, 0x2f, 0xe8, 0x01, 0xec, 0xff, 0x34, 0xec, 0xed, 0xf6, 0x12, 0x21,
0x12, 0x0d, 0xfd, 0xd3, 0x12, 0xde, 0x18, 0xfd, 0xf8, 0xf8, 0xe7, 0xe1,
0x1c, 0x00, 0x09, 0xdf, 0x29, 0x1c, 0xe8, 0x10, 0xfc, 0xee, 0x17, 0x21,
0x1a, 0x0e, 0xd5, 0xfe, 0x2d, 0x1f, 0x27, 0x13, 0xfa, 0xca, 0x3e, 0xee,
0xff, 0xfd, 0xf6, 0xff, 0xfa, 0xb8, 0x0d, 0x13, 0x2b, 0xf6, 0x33, 0xe7,
0xe5, 0x04, 0x23, 0xda, 0x0f, 0x10, 0x27, 0x0d, 0x14, 0xef, 0x13, 0xe8,
0x1a, 0x01, 0xeb, 0xc5, 0x2d, 0x14, 0x00, 0x0e, 0xe4, 0x21, 0xe8, 0xc3,
0xf3, 0x1a, 0x0f, 0xcf, 0x18, 0xd1, 0xfc, 0xfe, 0x1e, 0xf5, 0xf0, 0x1e,
0x31, 0x23, 0x0b, 0x16, 0x0c, 0x1f, 0x1d, 0x14, 0x08, 0xad, 0xfc, 0xe8,
0x0c, 0x0e, 0xf6, 0xfd, 0xde, 0xa2, 0xf6, 0x00, 0x1b, 0xed, 0x26, 0xc8,
0xf3, 0xed, 0x1b, 0xe2, 0xf4, 0xdf, 0x0a, 0x19, 0xfc, 0x1a, 0x0b, 0x13,
0x1f, 0x33, 0xfc, 0xed, 0x10, 0xd8, 0x0c, 0xf4, 0x0d, 0x18, 0x03, 0xd8,
0x04, 0xd7, 0x02, 0xbc, 0x2e, 0x0a, 0xec, 0x06, 0x19, 0xf2, 0xfb, 0xff,
0x29, 0xdb, 0xf0, 0x0b, 0x34, 0xe5, 0x14, 0x22, 0xe9, 0xc5, 0x01, 0xf6,
0xe2, 0x11, 0x11, 0xe9, 0x05, 0xd6, 0x23, 0xfa, 0x12, 0xec, 0x34, 0xe3,
0xe5, 0x10, 0xfb, 0x01, 0xe4, 0xee, 0x07, 0xd6, 0xee, 0x1d, 0x29, 0xff,
0x1e, 0x32, 0xf4, 0xdb, 0xf0, 0xe9, 0xe1, 0xfc, 0xff, 0x0d, 0xf7, 0x98,
0xe7, 0x15, 0x1e, 0xfe, 0x44, 0xf1, 0x0c, 0xd3, 0xec, 0x15, 0x11, 0xf2,
0x36, 0xf9, 0x0d, 0x03, 0x2f, 0xe4, 0x07, 0x11, 0xdb, 0xaa, 0xec, 0xc5,
0xe2, 0xef, 0x05, 0x1f, 0xe0, 0x9e, 0x09, 0xf1, 0x0b, 0xe0, 0x43, 0xcf,
0x1f, 0xfa, 0xde, 0xce, 0x1d, 0xfb, 0x22, 0x1b, 0xce, 0x1c, 0x41, 0xf2,
0x1c, 0x2f, 0xfe, 0xde, 0x30, 0xda, 0xf4, 0x0b, 0xed, 0xf1, 0xfc, 0xdb,
0x04, 0xeb, 0x2d, 0xee, 0x24, 0x07, 0xe4, 0xd1, 0x1a, 0x11, 0x26, 0x10,
0x08, 0x28, 0xee, 0xea, 0x19, 0xe7, 0x03, 0x2b, 0x14, 0xd5, 0x2d, 0xc9,
0x0a, 0xe0, 0x13, 0x02, 0x1b, 0xc3, 0xe1, 0xd7, 0x18, 0xb9, 0x2b, 0xd2,
0x0d, 0x07, 0x02, 0xe8, 0x24, 0xf5, 0x07, 0xf5, 0xdb, 0x1f, 0x30, 0x19,
0x0f, 0x26, 0xdc, 0xba, 0x21, 0xda, 0x0d, 0xfd, 0xdf, 0xfa, 0x11, 0xad,
0xe6, 0xe2, 0x1f, 0xcb, 0x47, 0xf2, 0x0b, 0xdf, 0xeb, 0xe2, 0xf9, 0x23,
0x10, 0xed, 0xfb, 0x12, 0x1f, 0x00, 0xff, 0xf9, 0x0d, 0xd0, 0x27, 0x0a,
0x0f, 0xf9, 0x1d, 0xff, 0xf9, 0xe9, 0x1f, 0x03, 0x32, 0xbb, 0x30, 0xe8,
0xe9, 0x25, 0xe2, 0xe2, 0x17, 0xdf, 0xff, 0xed, 0xcf, 0xd9, 0x26, 0xde,
0x19, 0x35, 0x16, 0xd9, 0x28, 0xf1, 0x07, 0x01, 0xf2, 0xff, 0x21, 0xd2,
0x21, 0xe2, 0x38, 0xf0, 0x20, 0xe1, 0x26, 0x09, 0xe4, 0x13, 0xfc, 0x0a,
0x06, 0x06, 0x11, 0xd3, 0x17, 0xf1, 0xd7, 0x40, 0xf0, 0xd2, 0xf4, 0xe8,
0x12, 0x18, 0x17, 0x10, 0xed, 0xcd, 0x22, 0x14, 0x1b, 0x02, 0x2f, 0x0b,
0x17, 0xd5, 0xfa, 0xe4, 0xe9, 0xe2, 0x28, 0xe1, 0xfc, 0x17, 0x36, 0x02,
0xe8, 0x36, 0x01, 0xb6, 0x11, 0xf6, 0xfb, 0x20, 0x12, 0xed, 0xf0, 0xbe,
0x1d, 0xe3, 0x17, 0xe8, 0x4b, 0xf8, 0xed, 0xeb, 0x13, 0xfe, 0xfd, 0xf3,
0x0e, 0x23, 0xfa, 0xf5, 0x29, 0xf5, 0x14, 0x2d, 0xec, 0xe3, 0x02, 0xe8,
0x18, 0x24, 0xfb, 0x20, 0x0c, 0xce, 0xf1, 0xfc, 0x19, 0xc8, 0x14, 0xf2,
0x03, 0xd8, 0xe4, 0xed, 0x13, 0xf2, 0x02, 0x1c, 0xd6, 0x13, 0x3a, 0x17,
0xf0, 0x0f, 0xdd, 0xae, 0x2a, 0xfb, 0xdd, 0xfc, 0x06, 0xeb, 0x0e, 0xa8,
0xec, 0x00, 0x1a, 0xd7, 0x30, 0xf2, 0x0d, 0xdf, 0xf0, 0x0e, 0x03, 0x1a,
0x38, 0x17, 0xf5, 0xf8, 0x3f, 0xfd, 0x0e, 0x1a, 0x01, 0xc1, 0x39, 0x01,
0x05, 0x08, 0xee, 0x01, 0xea, 0xb6, 0x1b, 0x07, 0xf5, 0x08, 0x38, 0xfb,
0xfb, 0xea, 0xe5, 0xe1, 0xea, 0xea, 0xf3, 0x0f, 0x12, 0x0e, 0x24, 0x19,
0xfe, 0x14, 0x14, 0xce, 0x29, 0xf3, 0x00, 0x0f, 0x1d, 0xdf, 0x13, 0xaf,
0x16, 0x19, 0x06, 0x02, 0x40, 0x0e, 0x1d, 0x0a, 0x1f, 0xe9, 0x21, 0x03,
0x08, 0xf7, 0xf6, 0x2c, 0x15, 0x01, 0x02, 0x31, 0xf2, 0xd7, 0xfc, 0xd3,
0x0a, 0x0d, 0xfa, 0xe0, 0x04, 0x8d, 0x12, 0x18, 0x0c, 0xcb, 0x15, 0x0c,
0x1a, 0xe0, 0xef, 0xd2, 0x05, 0x0a, 0x10, 0x0c, 0xd5, 0x1d, 0x00, 0x0e,
0x14, 0x26, 0xeb, 0xd2, 0xf3, 0x00, 0x0e, 0xe3, 0x03, 0xdf, 0xf2, 0xdf,
0xec, 0xde, 0x2c, 0x01, 0x41, 0xe8, 0x0d, 0x11, 0x03, 0xea, 0x1e, 0x11,
0x12, 0xdb, 0xf9, 0x1d, 0x1e, 0x07, 0x13, 0x15, 0xef, 0xad, 0x0d, 0x07,
0x09, 0x0b, 0x06, 0x08, 0xe4, 0xa5, 0xef, 0xe1, 0x1a, 0xcf, 0x1c, 0xdb,
0xed, 0xfc, 0x00, 0xe8, 0xf4, 0x07, 0x30, 0xe0, 0xe7, 0x17, 0x1b, 0x17,
0xf2, 0x06, 0xe4, 0xe7, 0x04, 0xe0, 0x17, 0xfa, 0x0d, 0x04, 0x15, 0xcb,
0xea, 0x18, 0x1b, 0xf8, 0x22, 0x02, 0xeb, 0x0e, 0xef, 0x0e, 0xe9, 0x12,
0xf6, 0xe9, 0xf4, 0xf8, 0x3b, 0x03, 0xe4, 0xf4, 0x1a, 0xe3, 0x25, 0x03,
0xf4, 0x12, 0xf4, 0xfc, 0xf7, 0xc4, 0xfb, 0x0e, 0x0c, 0xfd, 0x48, 0x03,
0x1f, 0xe6, 0xe5, 0x10, 0xef, 0x1e, 0xfc, 0xfb, 0xd0, 0xfe, 0x27, 0xfa,
0xea, 0xfb, 0xf7, 0xe4, 0x21, 0xde, 0xee, 0x01, 0x11, 0xf4, 0xe3, 0xba,
0x15, 0x11, 0x18, 0xda, 0x54, 0xed, 0x23, 0x1a, 0xfd, 0xd9, 0xe7, 0x21,
0x19, 0x1a, 0xe6, 0x19, 0xff, 0x1f, 0xe4, 0x32, 0xfa, 0xe2, 0x19, 0x0b,
0x19, 0x23, 0x21, 0x12, 0xdd, 0xb8, 0x0c, 0xdc, 0x1d, 0xf2, 0x4b, 0xcd,
0x0e, 0x14, 0x22, 0xd5, 0x18, 0xea, 0xfc, 0x19, 0xdb, 0xe2, 0x29, 0x06,
0xe3, 0x37, 0x08, 0xe5, 0x0a, 0xf3, 0x16, 0xe9, 0x01, 0x13, 0xfb, 0xc0,
0xe7, 0xe6, 0x08, 0xe4, 0x4b, 0xe2, 0xf1, 0x0f, 0xf4, 0xdd, 0x1d, 0xe9,
0xf5, 0x24, 0xf5, 0xe9, 0x01, 0x06, 0xea, 0x35, 0xfa, 0xa9, 0x18, 0xde,
0x01, 0xf1, 0xf2, 0xdd, 0x08, 0xf0, 0xec, 0x15, 0x31, 0xe5, 0x58, 0xe1,
0x13, 0x03, 0x0a, 0x12, 0xfb, 0xf9, 0x1d, 0x16, 0x0f, 0xe4, 0x1e, 0x04,
0x1d, 0x26, 0xe2, 0xb5, 0x01, 0xe3, 0x02, 0x27, 0x13, 0x18, 0x1e, 0xd6,
0x17, 0xd4, 0x1d, 0xeb, 0x48, 0xfa, 0x1b, 0xf3, 0x16, 0x07, 0x25, 0xe9,
0x31, 0xdd, 0xe2, 0xe0, 0x40, 0xde, 0xea, 0x2a, 0xef, 0xbf, 0x01, 0x07,
0xe8, 0x22, 0x0f, 0xfe, 0xec, 0xa7, 0xf4, 0x06, 0x34, 0xe1, 0x4b, 0xf4,
0xfa, 0x21, 0x18, 0xe7, 0x05, 0x03, 0x31, 0xfc, 0xe4, 0xea, 0x09, 0x14,
0xf6, 0x3c, 0xe8, 0xbc, 0x0d, 0xec, 0x0f, 0xe5, 0xea, 0x22, 0xef, 0xce,
0x14, 0xff, 0x3c, 0xf6, 0x40, 0xde, 0x20, 0x1f, 0x0b, 0xef, 0xe7, 0xf6,
0x01, 0x14, 0xee, 0x13, 0x42, 0xf5, 0xd1, 0x35, 0x21, 0xab, 0xf9, 0xe6,
0x1e, 0xfc, 0xf2, 0xdf, 0x19, 0xbd, 0x0c, 0x10, 0x05, 0xd6, 0x2b, 0xd3,
0x02, 0xfe, 0xfa, 0xfd, 0xfe, 0x0b, 0x35, 0xe2, 0xf6, 0xdd, 0x18, 0xe6,
0x11, 0x17, 0x0f, 0xc8, 0x0b, 0x05, 0x02, 0x0a, 0x1c, 0xf1, 0x04, 0xab,
0x1b, 0xf7, 0x0f, 0xea, 0x52, 0xd2, 0xe1, 0xda, 0x20, 0xdf, 0x14, 0xea,
0x1b, 0xfd, 0xde, 0xd4, 0x3a, 0x14, 0x13, 0x3d, 0xf2, 0xc3, 0x2b, 0xe5,
0xdc, 0x1b, 0x00, 0x23, 0xf9, 0xb1, 0x18, 0xe5, 0x16, 0xd8, 0x15, 0xf6,
0x09, 0xee, 0xfe, 0x09, 0x09, 0x21, 0x39, 0xe5, 0xda, 0xdc, 0x30, 0x0d,
0x0a, 0x30, 0xf4, 0xd1, 0x06, 0xea, 0xfa, 0x15, 0x10, 0xfe, 0xf9, 0xa9,
0x0d, 0xff, 0x04, 0xd0, 0x0d, 0x0e, 0xde, 0xfe, 0xfe, 0x0c, 0x01, 0x12,
0x03, 0x16, 0xd7, 0xf3, 0x0f, 0xf8, 0x25, 0xfa, 0x1c, 0xee, 0xea, 0xe5,
0x0f, 0xf7, 0xf5, 0x0c, 0x21, 0xb7, 0x08, 0xef, 0x14, 0xfd, 0x1a, 0xf0,
0x1d, 0xe1, 0x02, 0xd5, 0xe7, 0x19, 0x37, 0x1e, 0xd3, 0x22, 0xfb, 0xe4,
0x07, 0x33, 0xed, 0xf2, 0x1d, 0xd6, 0xf6, 0xf6, 0x04, 0x0d, 0xe7, 0xc3,
0xfe, 0xeb, 0x09, 0xf4, 0x10, 0x0b, 0xeb, 0xe5, 0x01, 0xcd, 0xfa, 0x06,
0x10, 0xfb, 0xdc, 0x2d, 0x06, 0x15, 0xf4, 0x31, 0x1e, 0xda, 0x2c, 0xcd,
0x15, 0x17, 0x18, 0xe8, 0xf1, 0xb0, 0x21, 0x0c, 0x28, 0xc3, 0x39, 0xe9,
0xe1, 0xcf, 0xf2, 0xd5, 0xea, 0x0e, 0x2f, 0x07, 0xf4, 0xf2, 0x2f, 0xe1,
0xf1, 0x0c, 0x06, 0xcb, 0x20, 0xf9, 0x00, 0x0a, 0x12, 0xe2, 0xfd, 0xd1,
0x17, 0xeb, 0x0f, 0xbb, 0x51, 0xd6, 0xf6, 0xf1, 0xfc, 0xe8, 0xec, 0x14,
0x23, 0xee, 0xf9, 0xff, 0x1e, 0xec, 0xf9, 0xf5, 0x1d, 0xbd, 0xef, 0xde,
0x1e, 0x0d, 0x17, 0x1f, 0x13, 0x9b, 0x21, 0xfd, 0x08, 0xbb, 0x2e, 0x01,
0x1d, 0xcd, 0x1c, 0xd8, 0xfc, 0xe5, 0x19, 0xe1, 0x00, 0x1e, 0x10, 0x16,
0x07, 0xfb, 0xfe, 0xe3, 0xe4, 0xdd, 0x0e, 0xe9, 0x24, 0x23, 0x13, 0xab,
0x18, 0xfd, 0x04, 0xd4, 0x0f, 0xe2, 0x04, 0xd3, 0x03, 0xd0, 0xed, 0x0e,
0xf4, 0xd7, 0xe0, 0x1f, 0x1f, 0x18, 0x0f, 0xf9, 0xef, 0xc0, 0x20, 0xeb,
0xf9, 0xf2, 0xdf, 0xf5, 0xfd, 0xbf, 0x18, 0xfa, 0x01, 0xe5, 0x10, 0x0c,
0xff, 0x19, 0x08, 0xfc, 0x1a, 0xf1, 0x2a, 0xeb, 0x0a, 0x02, 0x10, 0xec,
0x09, 0x2d, 0x17, 0xab, 0xf8, 0xe0, 0xdd, 0x18, 0x1c, 0x09, 0xf0, 0xd1,
0xea, 0xf2, 0x1d, 0xca, 0x39, 0xff, 0xf3, 0x16, 0xde, 0xf7, 0xfc, 0x08,
0x24, 0xf9, 0xd2, 0xf9, 0xfc, 0xf6, 0xe6, 0x36, 0x11, 0xe5, 0x1d, 0xc3,
0x1e, 0x10, 0x18, 0xdf, 0xe7, 0x95, 0x12, 0x15, 0xfd, 0xd9, 0x25, 0xee,
0xed, 0xcd, 0xde, 0xf2, 0x0e, 0x04, 0x0f, 0x0f, 0xf5, 0x1a, 0x33, 0x0d,
0xe3, 0x02, 0x1f, 0xd5, 0x2b, 0xe7, 0x03, 0x12, 0xfc, 0x01, 0x15, 0x9e,
0x0e, 0xf4, 0x1f, 0xf3, 0x15, 0x05, 0xe4, 0xf0, 0x0a, 0xe6, 0xf5, 0x0e,
0x16, 0x21, 0x0f, 0xfc, 0x06, 0x03, 0x0c, 0x2c, 0x06, 0xd4, 0x08, 0x07,
0xf8, 0x20, 0x11, 0x22, 0xf0, 0xb4, 0xe1, 0x07, 0x35, 0xd5, 0x4e, 0xdf,
0x24, 0xf3, 0xfc, 0xea, 0x15, 0x07, 0x08, 0xea, 0xea, 0x0e, 0x0a, 0x06,
0x16, 0xf9, 0x04, 0xb4, 0xf4, 0xdc, 0xe6, 0x16, 0x0a, 0x1e, 0xed, 0xbf,
0x21, 0xe2, 0x04, 0xfa, 0x3f, 0xd5, 0xea, 0x02, 0xdf, 0x0e, 0xf1, 0xea,
0x32, 0x12, 0x01, 0xea, 0x11, 0x19, 0x00, 0x10, 0xea, 0xad, 0x17, 0xe9,
0xe5, 0x1b, 0x0e, 0xfd, 0xe7, 0xf0, 0xfd, 0xe2, 0x02, 0xcb, 0x52, 0xca,
0xf6, 0xf3, 0xff, 0xfe, 0x11, 0xf0, 0x11, 0x18, 0xd8, 0xf6, 0x0e, 0x10,
0xfd, 0x11, 0xfa, 0xc4, 0x2c, 0xfe, 0xf7, 0xfc, 0x12, 0xfd, 0x15, 0xc0,
0x00, 0x15, 0x1d, 0xee, 0x50, 0xf6, 0xec, 0x1b, 0xdf, 0xe1, 0x1a, 0xf1,
0x21, 0x09, 0x0b, 0xdc, 0x3d, 0xe7, 0xe4, 0x17, 0x0f, 0xd6, 0x3b, 0x02,
0xf6, 0xeb, 0xe3, 0xf1, 0x09, 0xb1, 0xea, 0xf1, 0x1e, 0x04, 0x37, 0xfa,
0xe8, 0xfb, 0xe2, 0x0e, 0x0a, 0x1e, 0x06, 0x03, 0x0d, 0xd9, 0x10, 0xf5,
0xe4, 0x21, 0x19, 0xbc, 0xf7, 0xd1, 0xe9, 0x08, 0xf2, 0x19, 0x20, 0xdf,
0xf9, 0xed, 0x05, 0xe0, 0x24, 0x1c, 0xfd, 0xf9, 0x1a, 0x0d, 0x0c, 0x14,
0x30, 0x09, 0xf4, 0xcd, 0x3e, 0x08, 0x0b, 0x1b, 0xeb, 0xb0, 0x0e, 0xf8,
0xe3, 0x25, 0xe7, 0x21, 0x00, 0xb3, 0xef, 0xe2, 0x0d, 0xc3, 0x4e, 0xff,
0xdf, 0x08, 0x01, 0x0e, 0xe7, 0xf1, 0x1d, 0xf6, 0xdb, 0xf9, 0x3b, 0xe1,
0x01, 0x0a, 0xf9, 0xef, 0x1a, 0xe5, 0xe2, 0x19, 0x08, 0x15, 0x18, 0xc0,
0x13, 0x00, 0xf2, 0xc6, 0x4b, 0xff, 0x1d, 0xca, 0x17, 0x00, 0x15, 0xeb,
0xf7, 0xfa, 0xfd, 0x03, 0x05, 0x07, 0x2a, 0x2f, 0x04, 0xe0, 0x14, 0xe0,
0xdf, 0x20, 0x22, 0xe5, 0xf1, 0xc8, 0x1f, 0xe8, 0x25, 0xcc, 0x2c, 0xec,
0x0c, 0xcc, 0xfc, 0x14, 0xfa, 0xea, 0x18, 0xe8, 0x0a, 0xee, 0x17, 0x20,
0x14, 0xf4, 0x0c, 0xbe, 0x2a, 0x08, 0x19, 0x25, 0x1f, 0xee, 0x1b, 0xbd,
0x27, 0xf6, 0x02, 0xce, 0x33, 0xf9, 0x14, 0x16, 0xf5, 0x07, 0xf8, 0x1c,
0x05, 0x19, 0xd3, 0x09, 0x30, 0xf7, 0x23, 0x29, 0xe4, 0xb9, 0x17, 0xd2,
0x0c, 0x13, 0xe4, 0x0d, 0xec, 0xcc, 0x26, 0x08, 0x01, 0xf2, 0x14, 0x06,
0xde, 0xfa, 0xeb, 0xff, 0x1f, 0xf7, 0x00, 0xda, 0xdb, 0x03, 0x26, 0x22,
0xe7, 0x04, 0xef, 0xb3, 0x0e, 0xd6, 0xde, 0xf4, 0x07, 0x0d, 0xed, 0xc1,
0x1d, 0xf6, 0x09, 0xd8, 0x0e, 0xf4, 0x1f, 0xd2, 0xe8, 0x00, 0xea, 0x00,
0x20, 0x1e, 0xdf, 0xfe, 0x16, 0xdf, 0x1f, 0x2d, 0xde, 0xdf, 0xe6, 0xd9,
0x03, 0xe6, 0xe7, 0xf1, 0xe9, 0xce, 0x19, 0xfa, 0x29, 0xf5, 0x29, 0x00,
0x02, 0xd5, 0xe2, 0xf8, 0x1b, 0x17, 0x12, 0x01, 0xcf, 0x20, 0x13, 0x10,
0x22, 0x20, 0xe2, 0xc0, 0x10, 0xcd, 0xf2, 0x0e, 0x0f, 0xe5, 0xee, 0xcb,
0x0e, 0x1a, 0x04, 0xf6, 0x14, 0xd4, 0x0f, 0x13, 0xff, 0xd4, 0x0e, 0x05,
0x16, 0x08, 0xd0, 0x04, 0x33, 0x04, 0xf2, 0x1d, 0xf7, 0xe0, 0x11, 0xcf,
0xfa, 0x24, 0xfa, 0x05, 0xe0, 0xbe, 0x0d, 0xe9, 0x2b, 0xd0, 0x42, 0x19,
0xea, 0x00, 0xf5, 0x08, 0x05, 0x17, 0x21, 0x22, 0x03, 0x1a, 0x2d, 0x04,
0x22, 0x05, 0x03, 0xc4, 0x0b, 0xff, 0xea, 0x04, 0x20, 0x03, 0x01, 0xe1,
0xee, 0xdf, 0xfc, 0xd2, 0x45, 0x07, 0xf8, 0xd1, 0xeb, 0xfc, 0x25, 0x0c,
0xfd, 0x1b, 0xd1, 0xe6, 0x2e, 0x1f, 0xef, 0xf8, 0x01, 0xcd, 0x13, 0xf7,
0xf9, 0xe9, 0x1e, 0xe8, 0xe7, 0xbe, 0x17, 0x08, 0x2a, 0xc7, 0x4a, 0xde,
0x1f, 0xe0, 0x23, 0xe0, 0x07, 0xf2, 0x0c, 0xfb, 0xe8, 0xf3, 0x2c, 0xec,
0xfa, 0x12, 0xdd, 0xe3, 0xf8, 0xef, 0xf2, 0x17, 0x03, 0xde, 0xef, 0xca,
0xf1, 0xde, 0x2d, 0xf3, 0x1e, 0xf3, 0xe8, 0xf8, 0x03, 0x06, 0x28, 0x00,
0x30, 0xdf, 0xfd, 0xee, 0x03, 0xfb, 0xf9, 0xf5, 0x0b, 0xc0, 0x36, 0xd5,
0x18, 0x1f, 0xe5, 0x12, 0xf8, 0xe5, 0x23, 0xe0, 0x05, 0xc4, 0x37, 0x02,
0x1a, 0x0c, 0x22, 0xdf, 0x05, 0xf7, 0x0b, 0x2a, 0x11, 0x08, 0x28, 0xdd,
0xf7, 0x1f, 0x0c, 0xb1, 0xf9, 0xe9, 0x05, 0x1a, 0xe9, 0xe9, 0x07, 0xc7,
0xf8, 0x08, 0x26, 0xde, 0x33, 0x01, 0x10, 0x04, 0xdd, 0xe8, 0x12, 0x11,
0x22, 0x2c, 0xf7, 0x04, 0x21, 0x07, 0x05, 0x38, 0xe2, 0xd4, 0x2c, 0xd0,
0x01, 0xff, 0x06, 0x04, 0x19, 0x01, 0xfc, 0xdd, 0x0b, 0xc2, 0x1b, 0xff,
0xeb, 0x1b, 0xfc, 0xea, 0x22, 0x0c, 0xf9, 0x17, 0x04, 0xd8, 0x0f, 0x03,
0xe4, 0xfa, 0x12, 0xd2, 0x38, 0xe8, 0x0b, 0x10, 0xee, 0xe9, 0xe9, 0xe8,
0xf3, 0xd9, 0x26, 0xe4, 0x42, 0xe3, 0xf7, 0x19, 0x04, 0xe0, 0xe6, 0xed,
0x0a, 0xe7, 0xe8, 0xd5, 0x39, 0xfd, 0x15, 0x21, 0x1c, 0xd7, 0xee, 0xd0,
0xfc, 0xef, 0xea, 0x00, 0xe1, 0xa6, 0x20, 0xd5, 0x06, 0x05, 0x51, 0x04,
0x11, 0xe3, 0x09, 0xdf, 0x10, 0xec, 0x30, 0x21, 0xff, 0xf7, 0x1e, 0xef,
0xff, 0x39, 0xf7, 0xdd, 0x24, 0xf6, 0xfa, 0xe9, 0x16, 0xe7, 0x0f, 0xb7,
0x20, 0xe5, 0xf7, 0xd6, 0x2a, 0xe8, 0xe4, 0xf2, 0xef, 0xdb, 0xf1, 0xde,
0x04, 0xdb, 0xf8, 0x19, 0x40, 0x06, 0xe5, 0x0b, 0x01, 0xcc, 0x3a, 0xf9,
0x18, 0x1d, 0x11, 0xfa, 0x04, 0xd0, 0xe1, 0x17, 0x1a, 0xfe, 0x2e, 0xff,
0xf7, 0x09, 0xe5, 0xf6, 0xf6, 0xf9, 0xf5, 0x06, 0xd1, 0x05, 0x14, 0xf1,
0x06, 0x06, 0x16, 0xc2, 0x30, 0xde, 0xde, 0x02, 0xe0, 0x01, 0xde, 0xc4,
0xf0, 0x0c, 0x18, 0xda, 0x0f, 0xee, 0xf2, 0xd0, 0xfc, 0x0a, 0xe9, 0x23,
0x11, 0x08, 0xe8, 0x08, 0x0e, 0xe6, 0x0d, 0xfd, 0xea, 0xb7, 0x11, 0xe5,
0x1b, 0x01, 0xe2, 0x1d, 0xef, 0xa1, 0x22, 0xe5, 0x29, 0xca, 0x50, 0xe7,
0xf1, 0xe5, 0xf0, 0xcd, 0x24, 0x16, 0x06, 0xe6, 0xd5, 0x30, 0x13, 0x22,
0xf9, 0x21, 0x1d, 0xaf, 0x19, 0xff, 0x12, 0x04, 0x14, 0x12, 0x20, 0xad,
0x10, 0x06, 0xf8, 0xba, 0x41, 0x06, 0xee, 0xf4, 0xfc, 0xf5, 0xf6, 0xfb,
0x31, 0xdb, 0xf2, 0x01, 0x28, 0x00, 0xf0, 0x07, 0xec, 0xa7, 0xf9, 0xdc,
0xfc, 0x01, 0xee, 0x10, 0xe3, 0xaf, 0x17, 0xf4, 0x3c, 0xe4, 0x0f, 0xcc,
0xf5, 0xe9, 0x21, 0x10, 0xfb, 0x10, 0xf7, 0xff, 0xfe, 0xfc, 0x3b, 0xed,
0x24, 0xfb, 0xe5, 0xba, 0x28, 0xce, 0xe6, 0xf9, 0xfc, 0x21, 0x10, 0xd1,
0xe3, 0x0e, 0x23, 0xce, 0x32, 0xd5, 0xe1, 0xfe, 0xe7, 0x0f, 0x0e, 0x0c,
0x13, 0x1c, 0xe9, 0x2b, 0x05, 0xe7, 0xe5, 0x0d, 0xdb, 0xae, 0x09, 0xf8,
0xee, 0xf1, 0xef, 0x23, 0xf8, 0x9b, 0xf3, 0xe1, 0x39, 0xfb, 0x2b, 0xd0,
0x15, 0xf3, 0x08, 0xfb, 0x28, 0xde, 0x11, 0x16, 0xdf, 0xe6, 0x32, 0xf5,
0xfe, 0x24, 0x15, 0xc1, 0xfe, 0xfd, 0xe2, 0x22, 0xe6, 0x1f, 0x03, 0xd4,
0x1e, 0xee, 0xfc, 0xf6, 0x17, 0xf5, 0xdf, 0xfc, 0x11, 0xdb, 0x01, 0x19,
0x13, 0x05, 0xe1, 0x14, 0x3a, 0x1a, 0x0d, 0x26, 0xf4, 0xd7, 0xea, 0x08,
0xf8, 0xe6, 0xfa, 0x21, 0x0f, 0xda, 0x13, 0xd8, 0x0c, 0xd9, 0x1c, 0xe4,
0xf0, 0xf2, 0xea, 0x0f, 0xe6, 0x0d, 0x01, 0xfa, 0x06, 0x05, 0x33, 0xef,
0xf8, 0x25, 0x20, 0xe5, 0xed, 0xfd, 0x0c, 0x14, 0x20, 0x05, 0xf3, 0xa6,
0xef, 0xf0, 0x0b, 0xed, 0x17, 0xf8, 0x03, 0xf9, 0x20, 0xd8, 0x24, 0xee,
0x21, 0x0e, 0xe6, 0x07, 0x0e, 0x0b, 0x0a, 0x23, 0xec, 0xae, 0xf6, 0xe2,
0xfb, 0x1f, 0x23, 0x13, 0x14, 0x00, 0xe5, 0x1a, 0x02, 0xef, 0x49, 0x16,
0xea, 0xfd, 0x16, 0xd8, 0xfe, 0x05, 0x0f, 0xf6, 0xf3, 0x04, 0xff, 0x09,
0x05, 0x2d, 0x13, 0xcb, 0x0f, 0xfa, 0xf3, 0x1c, 0x1d, 0xfb, 0x1f, 0xdc,
0x01, 0xf3, 0x03, 0xd1, 0x54, 0x0e, 0x03, 0xda, 0xfd, 0xdd, 0xea, 0x01,
0x25, 0x24, 0xf8, 0xd1, 0x27, 0xfb, 0xe3, 0x31, 0xf6, 0xa3, 0xf0, 0xdc,
0x0f, 0x25, 0x18, 0xf2, 0xf1, 0xb2, 0x16, 0xe6, 0x0d, 0xd9, 0x52, 0xea,
0xe5, 0xe5, 0xfa, 0xe2, 0xfd, 0xf4, 0x31, 0xf4, 0xe1, 0x09, 0x33, 0xf4,
0xd5, 0x24, 0x03, 0xb2, 0x24, 0xfa, 0x01, 0xe8, 0xdf, 0x05, 0xf8, 0xf9,
0x19, 0xe8, 0x07, 0xbe, 0x31, 0xd8, 0x03, 0xe8, 0x12, 0xe9, 0xf3, 0xf8,
0x37, 0xf6, 0xf1, 0xca, 0x34, 0x1d, 0x0b, 0x22, 0x07, 0xb5, 0x2c, 0x0a,
0x17, 0x17, 0xf3, 0xfe, 0xee, 0xc0, 0xee, 0xda, 0x38, 0xf2, 0x19, 0xea,
0xf4, 0x17, 0xe4, 0xd6, 0xeb, 0x20, 0x0c, 0x1a, 0x0c, 0x09, 0x19, 0x22,
0x0d, 0x26, 0xe4, 0xd5, 0x13, 0xfd, 0x20, 0xf4, 0x0c, 0xf3, 0xeb, 0xe9,
0x0a, 0xe0, 0x00, 0xe5, 0x53, 0xf1, 0x1a, 0x20, 0xdf, 0xe5, 0xed, 0xf6,
0x0b, 0xdb, 0xec, 0xce, 0x17, 0xf7, 0xdd, 0x38, 0x17, 0xcd, 0x10, 0xff,
0x0d, 0xf7, 0xea, 0x05, 0xee, 0xb4, 0x07, 0xf5, 0xf7, 0xde, 0x1f, 0xe4,
0xed, 0x31, 0x22, 0xdd, 0xee, 0x22, 0x31, 0x0e, 0xe7, 0xf5, 0x18, 0xef,
0xfb, 0xf5, 0xdf, 0xb8, 0x03, 0xd7, 0x08, 0x0b, 0xf2, 0x02, 0x09, 0xd5,
0x16, 0xf7, 0x2a, 0xd9, 0x1c, 0x11, 0xf4, 0x17, 0xf4, 0x0f, 0xe0, 0x14,
0x07, 0xe8, 0xdf, 0x1f, 0x09, 0xf2, 0xee, 0x0e, 0x05, 0xbb, 0x07, 0xd5,
0x18, 0xea, 0xee, 0x1c, 0xfd, 0xcd, 0xf3, 0xe3, 0x17, 0xdb, 0x43, 0x23,
0xec, 0x0d, 0xed, 0xeb, 0xeb, 0x19, 0xfe, 0xf9, 0xf2, 0xf5, 0x04, 0x02,
0x35, 0xfb, 0x07, 0xda, 0x2b, 0x03, 0xe6, 0x1a, 0xe0, 0x21, 0x16, 0xb6,
0xef, 0xeb, 0x20, 0xee, 0x1b, 0xea, 0xf9, 0xe8, 0x0d, 0x03, 0x17, 0x05,
0x0d, 0xe9, 0xd8, 0x33, 0x41, 0xef, 0x0e, 0x1c, 0x19, 0xbd, 0xee, 0x05,
0x17, 0x14, 0xfb, 0x06, 0x12, 0xe6, 0xf8, 0x07, 0x27, 0xcd, 0x41, 0xf7,
0x0f, 0xfd, 0xfc, 0xdf, 0x1b, 0xe3, 0xfd, 0x08, 0xf9, 0x1e, 0x1e, 0x00,
0x28, 0x1f, 0x12, 0xac, 0x17, 0xe3, 0x0b, 0xeb, 0xf9, 0xf0, 0x01, 0xc6,
0x01, 0x0d, 0x14, 0xed, 0x2d, 0xfd, 0xe5, 0xf6, 0xed, 0xf8, 0x1d, 0xee,
0x27, 0x0e, 0xfb, 0x28, 0x15, 0x1c, 0xf0, 0x1a, 0xfe, 0xeb, 0x23, 0xcb,
0x07, 0xf1, 0x09, 0xfb, 0xfa, 0xd6, 0x10, 0xe9, 0xfc, 0xf3, 0x28, 0x08,
0xe5, 0x18, 0xf8, 0xf6, 0x1b, 0xee, 0x03, 0x04, 0xd2, 0x26, 0x37, 0x0d,
0xf9, 0x14, 0xfe, 0xb8, 0x3d, 0xfc, 0xff, 0xee, 0x1c, 0x13, 0xfa, 0xa9,
0x26, 0x0e, 0x19, 0xd9, 0x29, 0xe1, 0x1c, 0x05, 0xf2, 0xcf, 0xfc, 0x10,
0x36, 0x25, 0xd9, 0xf0, 0x15, 0x0d, 0x11, 0xff, 0xeb, 0xd4, 0x0e, 0xd7,
0xf9, 0xfb, 0xeb, 0x1c, 0xf4, 0xaf, 0x0d, 0x0f, 0x33, 0xdb, 0x1d, 0xce,
0xfd, 0x0d, 0x16, 0xfc, 0xee, 0xfd, 0x34, 0xe4, 0x09, 0x13, 0x37, 0xe9,
0x08, 0x39, 0xf2, 0xdf, 0x13, 0x02, 0xf9, 0xef, 0xdd, 0xff, 0xef, 0xa6,
0x25, 0x17, 0x2c, 0xe4, 0x53, 0xe2, 0x13, 0x15, 0x20, 0xfe, 0x06, 0x01,
0x05, 0xf9, 0xcd, 0xdf, 0x2b, 0xe7, 0x28, 0x2d, 0x04, 0xdb, 0xf0, 0xf0,
0x19, 0x13, 0xf2, 0x11, 0xe8, 0xdf, 0xf4, 0x05, 0xfa, 0xc2, 0x1a, 0x02,
0x07, 0xf4, 0x15, 0xf5, 0xf7, 0x1e, 0xf6, 0x17, 0xf0, 0xd9, 0xf8, 0xe1,
0xf6, 0x33, 0xfb, 0xde, 0xe6, 0xc9, 0xf8, 0x02, 0xe8, 0xf3, 0x04, 0xea,
0x02, 0x10, 0x39, 0xc4, 0x2e, 0xe0, 0x09, 0x0f, 0x0f, 0xcd, 0x26, 0x06,
0x12, 0x1a, 0xfa, 0xe1, 0x33, 0xdf, 0x13, 0xf8, 0xe6, 0xc7, 0x1c, 0xd3,
0xfe, 0xe2, 0xf0, 0x05, 0x0b, 0xde, 0x12, 0xf9, 0x0a, 0xcb, 0x4e, 0xf6,
0x0b, 0xd4, 0x1a, 0xfa, 0x1b, 0xe4, 0x32, 0xe9, 0x0d, 0xee, 0x30, 0xe1,
0x01, 0x1a, 0x23, 0xcf, 0xfb, 0x02, 0x1f, 0x05, 0x07, 0x23, 0x15, 0xed,
0x08, 0xf6, 0x29, 0xbf, 0x22, 0xff, 0xe5, 0xe2, 0xf9, 0xe3, 0xed, 0x07,
0x2c, 0x03, 0xd1, 0x06, 0x40, 0x12, 0xdf, 0x15, 0xf3, 0xb3, 0x29, 0x03,
0xfd, 0xe1, 0x0e, 0xe3, 0xe2, 0xc4, 0x02, 0xf7, 0x15, 0xc5, 0x5a, 0xda,
0xe6, 0xe5, 0xe7, 0xcf, 0x04, 0x00, 0x10, 0x21, 0xce, 0xc7, 0x2e, 0xea,
0xda, 0x37, 0xf8, 0xad, 0x11, 0x00, 0xe3, 0xdf, 0xff, 0xf6, 0xef, 0xf7,
0x11, 0xe5, 0xfc, 0xe1, 0x2d, 0xd8, 0xe4, 0xf7, 0x0d, 0x0d, 0x1a, 0xdf,
0x17, 0xda, 0xf2, 0xdf, 0xff, 0x1f, 0xf6, 0x20, 0xe7, 0xdb, 0x0f, 0x03,
0x0e, 0xf2, 0x0d, 0x08, 0x06, 0xdb, 0xe1, 0xd6, 0x11, 0xe6, 0x38, 0xfd,
0x06, 0x0d, 0x1b, 0xee, 0xef, 0x09, 0x19, 0xf0, 0xcd, 0xd9, 0x2e, 0xf2,
0x0b, 0x04, 0xfd, 0xe2, 0x1f, 0xd6, 0x23, 0x15, 0xe1, 0x0e, 0xe7, 0xc8,
0x1d, 0x17, 0x23, 0xf7, 0x4c, 0xcf, 0x1b, 0x3c, 0x13, 0xf9, 0x1b, 0xf8,
0x06, 0x14, 0xf1, 0x0b, 0x2c, 0xfb, 0xff, 0x12, 0xde, 0xf4, 0x27, 0xf5,
0x00, 0x1f, 0x1b, 0xf0, 0x11, 0x93, 0xf7, 0xfd, 0x3a, 0xcc, 0x3b, 0xdd,
0xf9, 0x07, 0xf8, 0x0c, 0x02, 0x0f, 0x23, 0x02, 0xfc, 0x32, 0x45, 0x1d,
0x0d, 0xfd, 0x03, 0xec, 0x34, 0xdc, 0xfa, 0x11, 0xe4, 0x1c, 0x16, 0xaa,
0xec, 0xea, 0x3a, 0xd4, 0x2a, 0x06, 0x0e, 0xf6, 0xeb, 0x09, 0x1e, 0xea,
0xf4, 0x14, 0xd4, 0x03, 0x1a, 0xf4, 0x18, 0x18, 0xfc, 0xb3, 0x24, 0xfd,
0xfc, 0x00, 0xfd, 0x13, 0x11, 0xb8, 0x00, 0x16, 0x37, 0xc3, 0x3a, 0x1e,
0x0c, 0x12, 0xde, 0xe1, 0x0a, 0xfd, 0x19, 0x09, 0x02, 0xec, 0x0b, 0xdf,
0x29, 0x21, 0xee, 0xb0, 0x06, 0x01, 0x10, 0x02, 0x09, 0x05, 0x0a, 0xbe,
0x13, 0xd8, 0x22, 0xef, 0x2d, 0xf8, 0x23, 0xe5, 0x22, 0xdb, 0x1a, 0xe2,
0x17, 0xe7, 0xeb, 0xf5, 0x34, 0xf0, 0x30, 0x11, 0xf7, 0xb0, 0x1b, 0xe3,
0x1c, 0x19, 0x02, 0x0b, 0x05, 0xe7, 0x0c, 0x0e, 0x00, 0xe7, 0x42, 0xcc,
0xde, 0xe7, 0xe2, 0xea, 0xf3, 0xfe, 0x03, 0x04, 0xf6, 0xfa, 0x05, 0xed,
0xfe, 0x07, 0x09, 0xdd, 0x22, 0xe4, 0x07, 0xfc, 0x10, 0xfb, 0xea, 0xae,
0xfa, 0x1b, 0x39, 0xc5, 0x4d, 0xe9, 0x0e, 0x06, 0x1a, 0x12, 0xfe, 0x22,
0x16, 0xf9, 0x12, 0x0d, 0xf8, 0xe0, 0x0f, 0xf8, 0xfb, 0xe9, 0x08, 0xd7,
0xf9, 0x24, 0x04, 0xee, 0xfb, 0xa7, 0x00, 0x14, 0x1a, 0xc7, 0x33, 0xe6,
0xfe, 0xe8, 0xe4, 0xe3, 0xe6, 0xde, 0x0d, 0xf6, 0x02, 0x14, 0x2a, 0xf2,
0x26, 0xf7, 0xed, 0xd6, 0x1b, 0xfb, 0x18, 0xe2, 0x24, 0x0d, 0xf4, 0xdf,
0x25, 0x00, 0x07, 0xe8, 0x55, 0xe2, 0xf3, 0xe0, 0xdf, 0xd4, 0xe2, 0xe5,
0x18, 0x12, 0xd2, 0xea, 0xfe, 0xff, 0x25, 0x32, 0xfa, 0xbf, 0xe7, 0x0d,
0xfb, 0xf2, 0x24, 0xfa, 0x03, 0xc3, 0x15, 0xd8, 0x13, 0xc6, 0x52, 0x0c,
0xe5, 0x0b, 0xf8, 0xee, 0x02, 0xf6, 0x23, 0xea, 0x0f, 0x10, 0x27, 0x15,
0x2b, 0x0c, 0x09, 0xbc, 0xfe, 0xe1, 0x02, 0x0d, 0xfb, 0x14, 0x24, 0xa3,
0x23, 0xf6, 0x1c, 0xdc, 0x42, 0xfe, 0xf4, 0x15, 0xe2, 0x11, 0x02, 0x1a,
0x2d, 0x26, 0x10, 0x17, 0x10, 0xf7, 0x12, 0x37, 0x01, 0xb7, 0x0a, 0xe7,
0x1f, 0xf9, 0x1c, 0x08, 0x22, 0xc2, 0xf0, 0xf0, 0x31, 0xf9, 0x22, 0xe8,
0xf2, 0xe0, 0x03, 0xcf, 0x20, 0x14, 0xfe, 0x0f, 0xd6, 0xd8, 0x2a, 0x06,
0x14, 0x00, 0x03, 0xa6, 0x34, 0xcf, 0xe9, 0x13, 0x20, 0xeb, 0x19, 0xc2,
0x26, 0xe8, 0x23, 0xed, 0x5d, 0xdd, 0xf9, 0xca, 0x14, 0xcb, 0xf2, 0x04,
0x39, 0x0e, 0xf4, 0xcf, 0x1c, 0xfe, 0xf2, 0xf8, 0x03, 0xb6, 0x38, 0xcc,
0xe1, 0xfb, 0x15, 0xfc, 0x14, 0x0e, 0x24, 0x02, 0x35, 0xfc, 0x3e, 0xcb,
0xff, 0xe5, 0x11, 0xf6, 0x28, 0x19, 0xff, 0x09, 0xe3, 0xd0, 0x16, 0x18,
0x1a, 0xfa, 0x16, 0xd2, 0x02, 0x0d, 0xf9, 0x20, 0xe6, 0x08, 0x19, 0xce,
0xfa, 0xe8, 0x23, 0xc7, 0x49, 0xd0, 0x00, 0xe0, 0x0f, 0x09, 0x05, 0x06,
0x07, 0x29, 0xfb, 0xdf, 0x0e, 0x23, 0xd7, 0x29, 0x22, 0xb8, 0x26, 0x04,
0xf4, 0x1b, 0x0c, 0x05, 0x16, 0xc4, 0xf2, 0x1a, 0xff, 0xe4, 0x2d, 0xf1,
0x05, 0xcb, 0x1b, 0xde, 0x0b, 0x1f, 0x39, 0xf6, 0xe8, 0xcc, 0x35, 0x22,
0xe4, 0x0c, 0x03, 0xca, 0x16, 0xef, 0x11, 0xf5, 0xed, 0xf4, 0xf9, 0xf0,
0x0e, 0x18, 0x24, 0xf7, 0x12, 0xd7, 0xf2, 0xdf, 0x17, 0xf1, 0xf1, 0xee,
0x39, 0xe6, 0xce, 0xfa, 0x08, 0xf0, 0xdb, 0x15, 0x04, 0xd6, 0x48, 0x05,
0x03, 0xef, 0xe7, 0xfa, 0x09, 0xc0, 0x04, 0xe6, 0x14, 0xcc, 0x2f, 0xfb,
0x17, 0x18, 0x04, 0xe6, 0x0b, 0xf8, 0x0e, 0xe9, 0x12, 0x0e, 0x12, 0xea,
0xf5, 0x11, 0xf1, 0xcc, 0xea, 0x09, 0x13, 0x02, 0xe0, 0xf4, 0xf8, 0xe1,
0x0d, 0x06, 0x0e, 0xd1, 0x43, 0xea, 0xe7, 0x2a, 0xe2, 0xd9, 0x0c, 0x14,
0x0d, 0xe5, 0x04, 0x0b, 0x3a, 0x06, 0x07, 0x35, 0xfe, 0xb9, 0xf4, 0x0a,
0x15, 0x1a, 0x04, 0x18, 0xf7, 0xaa, 0xe8, 0xea, 0x30, 0xd4, 0x0c, 0xf1,
0xe4, 0x15, 0x0a, 0xef, 0x05, 0x0a, 0x2f, 0x10, 0xf0, 0x15, 0x01, 0xf5,
0x13, 0x19, 0xe8, 0xca, 0xe3, 0xeb, 0xe5, 0x15, 0xfc, 0x14, 0xee, 0xb7,
0x18, 0xf2, 0x3b, 0xcd, 0x24, 0x20, 0xe5, 0xef, 0x07, 0xd2, 0xfc, 0xe9,
0x11, 0x1d, 0xd7, 0x33, 0x00, 0xe1, 0x32, 0x17, 0xde, 0xd2, 0x1f, 0x17,
0xe8, 0xe7, 0xe5, 0xf1, 0xfa, 0xe9, 0xee, 0xd6, 0x2b, 0xf9, 0x54, 0x29,
0xe6, 0xfd, 0xf2, 0xd4, 0x0f, 0x16, 0x2e, 0x19, 0x11, 0x08, 0x1a, 0x1f,
0x22, 0xf1, 0x1f, 0xbd, 0x08, 0xdb, 0x02, 0x12, 0x03, 0x0d, 0x1c, 0xd2,
0xea, 0xde, 0x2e, 0xdb, 0x14, 0xf9, 0xe6, 0xda, 0xfd, 0xcf, 0x15, 0xf7,
0x2b, 0x0c, 0xce, 0x29, 0x36, 0x1b, 0x1e, 0x3b, 0x08, 0xec, 0x15, 0xf6,
0xe6, 0x26, 0x23, 0x13, 0xe1, 0xbe, 0x14, 0xe7, 0x0d, 0xfe, 0x2d, 0xfd,
0x04, 0xf1, 0xe6, 0x02, 0x14, 0x06, 0x18, 0xf3, 0x03, 0x0e, 0x3a, 0x03,
0x0c, 0x33, 0xf0, 0xb2, 0x25, 0xe1, 0xdc, 0x08, 0x06, 0xf4, 0x1c, 0xce,
0x26, 0xfa, 0x0d, 0xf5, 0x13, 0xe7, 0x06, 0xfd, 0x0d, 0x03, 0xe4, 0xfe,
0x2c, 0x18, 0xd3, 0x2b, 0x17, 0xff, 0xf4, 0x07, 0xeb, 0xaa, 0x13, 0xff,
0x0d, 0x0b, 0x24, 0x18, 0x01, 0xd0, 0xf0, 0xd4, 0x1a, 0xce, 0x1f, 0xe5,
0xe6, 0x13, 0xe6, 0x08, 0x02, 0x21, 0x03, 0xfb, 0xec, 0x12, 0x22, 0xf8,
0xf1, 0x0a, 0x06, 0xd2, 0x12, 0xee, 0xfd, 0x23, 0x07, 0xdf, 0xf9, 0xbc,
0x26, 0x0b, 0x0c, 0xfc, 0x12, 0x02, 0x0f, 0xd7, 0x04, 0x0f, 0xec, 0xf4,
0x30, 0x04, 0x12, 0xec, 0x21, 0xf9, 0x01, 0x27, 0xe9, 0xe0, 0x31, 0xfb,
0x00, 0xf1, 0xec, 0x15, 0xed, 0xbf, 0xeb, 0x02, 0x05, 0xdb, 0x20, 0xfb,
0xde, 0xe3, 0xf3, 0x03, 0x0f, 0x0b, 0x23, 0xeb, 0x0a, 0xd6, 0x22, 0xe0,
0x1b, 0x30, 0xe7, 0xea, 0x13, 0xf5, 0xe2, 0xe8, 0xff, 0x11, 0x0b, 0xee,
0x06, 0x00, 0x0e, 0xe2, 0x2c, 0xde, 0xf7, 0xe4, 0xf0, 0xde, 0xe6, 0x03,
0x0f, 0xdf, 0xd8, 0xf8, 0x3d, 0x17, 0x02, 0x0d, 0xf4, 0xa9, 0x12, 0xd2,
0x19, 0x14, 0xff, 0x21, 0x1f, 0xbe, 0xe6, 0xef, 0x03, 0xf0, 0x56, 0xf8,
0xee, 0xeb, 0x22, 0xf4, 0x1d, 0xdf, 0x15, 0xf2, 0xf9, 0xe3, 0x16, 0xe5,
0x09, 0x28, 0x1a, 0xce, 0xfa, 0x0f, 0xfc, 0xe6, 0xe9, 0x15, 0x0e, 0xcf,
0x0d, 0xe2, 0x22, 0xe2, 0x54, 0x02, 0x05, 0xfd, 0x07, 0xdf, 0x03, 0xde,
0x31, 0x16, 0xec, 0x0f, 0x3e, 0xfb, 0xe3, 0x00, 0xf9, 0xed, 0xea, 0xe7,
0x00, 0xf4, 0x06, 0x18, 0x18, 0xd5, 0xeb, 0x1a, 0x37, 0xd2, 0x42, 0xe4,
0xec, 0xe6, 0x0d, 0xeb, 0xf7, 0xdf, 0xff, 0x09, 0xe7, 0xfc, 0x3c, 0x14,
0x08, 0x1a, 0xfc, 0xd9, 0xf3, 0xd9, 0xea, 0x16, 0xdf, 0x07, 0x15, 0xca,
0x10, 0xfb, 0x16, 0xc6, 0x48, 0xfc, 0xe6, 0x0e, 0xe6, 0xdd, 0x27, 0x19,
0x17, 0xea, 0xe1, 0xd9, 0x2c, 0xde, 0xf1, 0x25, 0x21, 0xdd, 0x2b, 0x0d,
0x1e, 0x22, 0x0a, 0x1e, 0x09, 0xe9, 0x13, 0xe6, 0x25, 0xfc, 0x39, 0xf9,
0x22, 0x1f, 0x09, 0xe0, 0x20, 0xfd, 0x3c, 0xfb, 0x01, 0x01, 0x26, 0x0e,
0xe6, 0x0b, 0xe0, 0xda, 0x55, 0xed, 0xf7, 0x11, 0x03, 0x23, 0x1c, 0xcb,
0xef, 0xed, 0xf2, 0x09, 0x23, 0xc8, 0x1b, 0xd9, 0x05, 0xf7, 0xf4, 0x18,
0x1f, 0xea, 0x08, 0x11, 0x10, 0x11, 0x15, 0xfd, 0xe0, 0xee, 0x2a, 0x1b,
0xe1, 0xf4, 0x10, 0x1f, 0xe8, 0xd5, 0x0d, 0xe1, 0x32, 0xc9, 0x1e, 0xf3,
0x21, 0x1f, 0xe3, 0xe6, 0x17, 0x1a, 0x0e, 0xf7, 0xe5, 0x33, 0x16, 0x17,
0xf3, 0x0d, 0xea, 0xd1, 0xeb, 0xe2, 0xf0, 0x06, 0xf3, 0x06, 0x02, 0xc3,
0x0f, 0xf0, 0xfd, 0xd9, 0x2d, 0x02, 0xf2, 0x09, 0x0d, 0xd9, 0x17, 0x18,
0x0f, 0xfb, 0xe9, 0x2e, 0x1a, 0x00, 0x0d, 0xf5, 0xe2, 0xd8, 0xfe, 0xe7,
0xe3, 0x00, 0x0f, 0x1d, 0x20, 0xac, 0x00, 0x06, 0x06, 0xf6, 0x14, 0x0f,
0x0a, 0x04, 0xf7, 0x17, 0x22, 0xe9, 0xf5, 0x07, 0xd7, 0x36, 0x30, 0x0e,
0x3b, 0xf1, 0xe4, 0xae, 0xfb, 0x14, 0x0e, 0xf5, 0x15, 0xe7, 0xf4, 0xdb,
0x1f, 0x0e, 0x1c, 0x02, 0x1a, 0x03, 0x00, 0xd3, 0xfd, 0x16, 0xf5, 0x02,
0x08, 0x28, 0x0e, 0x15, 0x0d, 0xf2, 0x28, 0xf8, 0x08, 0xc5, 0x32, 0xe3,
0x12, 0x15, 0xe1, 0xec, 0xfa, 0xb1, 0x25, 0xf0, 0x29, 0xfa, 0x38, 0x03,
0x09, 0xe6, 0x16, 0x18, 0xea, 0x04, 0x2d, 0x1e, 0xe5, 0x10, 0x38, 0xf0,
0x2c, 0x04, 0x14, 0xcf, 0xfb, 0xf5, 0x10, 0x13, 0x23, 0xf2, 0xee, 0xb2,
0x21, 0xf7, 0x17, 0xe2, 0x44, 0xe9, 0xdc, 0xe7, 0x13, 0xf0, 0xf1, 0x02,
0x10, 0x1d, 0xee, 0x20, 0x0f, 0xfc, 0xf3, 0x1a, 0x15, 0xb8, 0xf4, 0xd1,
0xe2, 0x0d, 0x1d, 0x1e, 0xed, 0xfe, 0x01, 0xf7, 0x20, 0xd2, 0x4e, 0x09,
0x1f, 0xec, 0x05, 0xd5, 0x26, 0x1e, 0x37, 0x23, 0x0a, 0x13, 0x3d, 0x21,
0x18, 0xfb, 0x1a, 0xa8, 0xf8, 0x04, 0xfb, 0x0f, 0xeb, 0x0f, 0xea, 0xcd,
0x0b, 0xf7, 0x27, 0xe8, 0x46, 0x00, 0x10, 0xd9, 0x12, 0x04, 0xf1, 0x11,
0x01, 0x1d, 0xfc, 0xff, 0x29, 0xed, 0x0d, 0x30, 0xf6, 0xc5, 0x33, 0xdf,
0x22, 0xf9, 0xed, 0x22, 0xed, 0xdf, 0x00, 0xef, 0x0e, 0xc6, 0x14, 0xdb,
0x05, 0xf9, 0x23, 0xf7, 0x1d, 0xe4, 0x22, 0x02, 0xf4, 0x03, 0x10, 0x1d,
0x04, 0xfc, 0x15, 0xac, 0x03, 0x05, 0x01, 0x13, 0x14, 0xf9, 0xee, 0xd6,
0x15, 0xec, 0x25, 0xc1, 0x44, 0xed, 0xde, 0x13, 0x13, 0x0c, 0x0f, 0x22,
0x38, 0x2c, 0xd2, 0xdd, 0x20, 0x0e, 0x2a, 0x21, 0xe4, 0xc4, 0x10, 0x04,
0x19, 0xf6, 0xfa, 0x10, 0xf4, 0xe1, 0xf4, 0xdb, 0x14, 0xec, 0x5a, 0xeb,
0xdf, 0x0a, 0xf1, 0x00, 0xea, 0x09, 0x16, 0x17, 0xde, 0xd5, 0x20, 0x0f,
0xfa, 0x17, 0xf8, 0xc4, 0xf8, 0xdb, 0x0f, 0xe9, 0xe6, 0xdf, 0x07, 0xc2,
0x06, 0xf0, 0xf6, 0xc7, 0x1b, 0x11, 0x16, 0xee, 0xe5, 0xf8, 0x27, 0x1d,
0x0e, 0xf1, 0xe2, 0xec, 0xfc, 0x0a, 0xe2, 0xfa, 0xe8, 0xb9, 0xec, 0xd9,
0x0d, 0xe6, 0x12, 0x1c, 0xfe, 0xc4, 0x03, 0xf0, 0x1a, 0xcc, 0x3f, 0x0a,
0x0b, 0xd6, 0xe4, 0xe3, 0x28, 0x03, 0x2d, 0x05, 0xd8, 0xe2, 0x3e, 0xe4,
0xea, 0xff, 0x1e, 0xc8, 0x16, 0x0c, 0xe9, 0x13, 0x23, 0xfc, 0x12, 0xd8,
0x0c, 0xfa, 0x0c, 0x01, 0x2d, 0xda, 0x1c, 0xd6, 0x21, 0xe7, 0xfc, 0x0b,
0x2a, 0x2c, 0x0e, 0xd7, 0x11, 0x00, 0x1a, 0x0b, 0xf6, 0xc2, 0x33, 0x14,
0x0d, 0xe3, 0x0a, 0xf2, 0x12, 0x02, 0xfd, 0xf9, 0x1e, 0xfb, 0x1b, 0xd4,
0x13, 0xfa, 0xf1, 0xf8, 0x16, 0xee, 0x1a, 0xfc, 0xf5, 0xe5, 0x40, 0xf1,
0xf9, 0x1e, 0xe8, 0xc9, 0x1c, 0x18, 0x1a, 0xdf, 0xf3, 0xe8, 0x1e, 0xe2,
0xf7, 0xda, 0x23, 0xe1, 0x14, 0xfc, 0xe7, 0xea, 0x0b, 0x10, 0x12, 0x02,
0x34, 0xf5, 0xe6, 0xe0, 0x06, 0x11, 0x12, 0x0e, 0x25, 0xd6, 0x40, 0x00,
0xed, 0x0c, 0x1b, 0xe5, 0x16, 0xdf, 0x17, 0xe8, 0x34, 0xe1, 0x1a, 0xd0,
0x03, 0xe1, 0xfe, 0x19, 0x20, 0x22, 0x0e, 0xe1, 0xdf, 0x09, 0x10, 0xfa,
0x20, 0x27, 0x1f, 0xb7, 0x2c, 0x1b, 0x18, 0xfd, 0xe6, 0x07, 0x00, 0xd2,
0xfc, 0x14, 0x18, 0xe1, 0x45, 0xc7, 0x17, 0x31, 0x0f, 0xef, 0xfc, 0xe4,
0xf6, 0xd9, 0xef, 0x21, 0x08, 0xff, 0x1e, 0x2c, 0xf4, 0xcd, 0xea, 0x15,
0x0b, 0xf6, 0xe5, 0xf1, 0xdf, 0xe2, 0xe9, 0x05, 0x27, 0xfa, 0x3d, 0x08,
0xe0, 0x22, 0xe7, 0xec, 0x07, 0xf4, 0xfd, 0xdc, 0xd7, 0x23, 0x34, 0xe2,
0xf4, 0x04, 0x17, 0xe8, 0xeb, 0x12, 0x18, 0x1a, 0x22, 0xea, 0xf7, 0xa3,
0x1c, 0x13, 0xff, 0x05, 0x3d, 0xf7, 0xfb, 0xd7, 0x23, 0x00, 0x1b, 0xea,
0xf4, 0x03, 0xf1, 0x01, 0x27, 0x1f, 0x2d, 0x30, 0xfd, 0xec, 0x19, 0xf6,
0x06, 0xf5, 0xf4, 0x0b, 0xe2, 0xe6, 0xfc, 0xea, 0x2f, 0xc1, 0x31, 0x12,
0x03, 0x01, 0xfa, 0x02, 0x13, 0x0d, 0x06, 0x21, 0x0b, 0x1d, 0x1c, 0xe4,
0x30, 0x1a, 0x14, 0xd6, 0x1c, 0xcf, 0xe0, 0xf1, 0xfc, 0x0c, 0xde, 0xdc,
0x17, 0xf8, 0x08, 0xe4, 0x26, 0xf4, 0xf2, 0xed, 0xde, 0xd3, 0xf0, 0x19,
0xf8, 0x0c, 0x13, 0xfb, 0x1c, 0xeb, 0x0f, 0x31, 0x20, 0xae, 0x0c, 0xe9,
0xfd, 0x21, 0x07, 0x06, 0xe8, 0xbc, 0x14, 0xe5, 0x1d, 0xf1, 0x49, 0x06,
0x1b, 0xfd, 0xee, 0x0b, 0x05, 0xe2, 0xfb, 0x10, 0x13, 0x04, 0x1e, 0x20,
0x2a, 0xf4, 0x0e, 0xd2, 0x30, 0xd4, 0xe2, 0x03, 0xf1, 0x02, 0xf5, 0xbe,
0x0e, 0xdb, 0x16, 0xea, 0x1f, 0xd6, 0xef, 0xd7, 0x01, 0xf4, 0x18, 0xe6,
0x2b, 0xea, 0xf9, 0x00, 0x21, 0x05, 0x12, 0x02, 0xe7, 0xc8, 0x0c, 0x07,
0x16, 0xff, 0xe8, 0xf3, 0x10, 0xbe, 0x05, 0x13, 0x01, 0xd5, 0x0c, 0xd9,
0xfd, 0xfe, 0x07, 0xe5, 0x26, 0xf2, 0xf9, 0xee, 0xf0, 0xe4, 0x23, 0xfa,
0xf1, 0x0e, 0xd5, 0xe6, 0x2e, 0xd6, 0xfe, 0x00, 0x01, 0x0e, 0x02, 0xf5,
0xfc, 0xe4, 0x19, 0xcf, 0x53, 0x04, 0x14, 0xd2, 0x03, 0xf8, 0x0f, 0x19,
0x38, 0x0d, 0xff, 0x22, 0x05, 0x05, 0x1e, 0x36, 0x0d, 0xb6, 0xfe, 0xd4,
0xdc, 0xf2, 0xe3, 0xf6, 0x13, 0xff, 0x13, 0xf3, 0x0f, 0xd0, 0x49, 0x09,
0x0e, 0x11, 0xf1, 0xce, 0x24, 0xf4, 0x16, 0x0a, 0xd8, 0xfc, 0x01, 0xf4,
0x02, 0x3a, 0x13, 0xce, 0xf3, 0xee, 0x1b, 0xe3, 0x1a, 0xed, 0xfe, 0xf0,
0xf1, 0xee, 0xf3, 0xc9, 0x1e, 0xeb, 0x11, 0x06, 0x08, 0xe6, 0xf4, 0x07,
0xfa, 0x20, 0xe4, 0xdf, 0x09, 0x1b, 0xf9, 0x2c, 0xe9, 0xb8, 0x0c, 0xd4,
0xfe, 0xf0, 0xfe, 0xe0, 0xe1, 0xcf, 0x05, 0xe0, 0xf1, 0xe0, 0x29, 0xf4,
0x16, 0xf3, 0x19, 0xd8, 0xe4, 0x09, 0x24, 0x1d, 0x09, 0x14, 0x3a, 0xf4,
0xde, 0x31, 0x20, 0xba, 0x10, 0x0c, 0x1b, 0xf8, 0x01, 0x14, 0xf0, 0xf9,
0xed, 0x00, 0x20, 0xe1, 0x40, 0x02, 0x21, 0xef, 0x16, 0xe5, 0xfd, 0x1d,
0x16, 0x25, 0x01, 0xcf, 0x14, 0x14, 0x05, 0x22, 0x22, 0xb9, 0x2d, 0x0a,
0x0d, 0x1c, 0x1b, 0x0f, 0x05, 0xe5, 0xee, 0xd7, 0x37, 0xf8, 0x46, 0xe5,
0xe2, 0xeb, 0xef, 0xeb, 0x0b, 0xf4, 0x05, 0x27, 0xfa, 0xfd, 0x42, 0xf4,
0x05, 0x2d, 0x05, 0xed, 0xfc, 0x07, 0xea, 0x09, 0xe3, 0xf3, 0x11, 0xda,
0x0c, 0x10, 0xfb, 0x00, 0x38, 0xda, 0xe7, 0xdb, 0xe4, 0xf7, 0x09, 0x21,
0x2d, 0x27, 0x03, 0xf3, 0x47, 0x23, 0xe9, 0x10, 0x18, 0xe2, 0x13, 0xe3,
0xf2, 0x10, 0x08, 0x03, 0x18, 0xd0, 0xe3, 0x02, 0x14, 0xf4, 0x1f, 0xdc,
0xf6, 0x0b, 0xdf, 0xd7, 0x01, 0x13, 0x3d, 0x03, 0xff, 0xd6, 0x3d, 0x1c,
0x14, 0x2a, 0x09, 0xea, 0x3f, 0x05, 0xe4, 0x17, 0xf5, 0x0a, 0xf5, 0xf2,
0xe3, 0xfe, 0x01, 0xed, 0x0e, 0xe7, 0xee, 0xd0, 0x02, 0xde, 0x13, 0xf1,
0x1c, 0x0a, 0xd6, 0x2c, 0x3c, 0xf7, 0xee, 0x1d, 0xfa, 0xe3, 0xf0, 0x06,
0xe7, 0xe6, 0xe7, 0xeb, 0xe9, 0xc7, 0x17, 0xe0, 0x2b, 0xd4, 0x3b, 0xd5,
0xf6, 0xfe, 0xde, 0x0b, 0xf1, 0x16, 0x2d, 0xfb, 0xfb, 0x33, 0x39, 0x1e,
0x0d, 0x3d, 0x06, 0xc9, 0xf0, 0xea, 0xfe, 0x1d, 0x0a, 0xdf, 0xdf, 0xb5,
0x0c, 0xfe, 0x37, 0xd4, 0x49, 0x09, 0xee, 0x20, 0x15, 0xe8, 0x09, 0xe6,
0x10, 0x0f, 0xe5, 0xf1, 0x40, 0x02, 0xf5, 0xf2, 0x0c, 0xc6, 0x25, 0x03,
0xdd, 0xe8, 0x09, 0xdf, 0xeb, 0xc6, 0x03, 0x11, 0xfe, 0xea, 0x1a, 0xef,
0xee, 0xd7, 0xe3, 0x04, 0x0c, 0x0a, 0x07, 0xe4, 0x07, 0x08, 0x1b, 0x04,
0x14, 0xf8, 0xdd, 0xe0, 0x2f, 0xf2, 0xe1, 0xf0, 0x21, 0xfc, 0x20, 0xdb,
0xfd, 0xf6, 0x35, 0xdc, 0x4e, 0x09, 0xf0, 0xee, 0x03, 0xfb, 0xe5, 0xed,
0x09, 0x13, 0xe3, 0x09, 0x03, 0x08, 0x0f, 0x0a, 0x10, 0xf4, 0xef, 0x0d,
0x18, 0x06, 0x0e, 0x07, 0x18, 0xe0, 0x18, 0xf1, 0x2b, 0xc9, 0x11, 0x1c,
0xfb, 0x04, 0x1e, 0xf1, 0x16, 0xf5, 0x3b, 0xee, 0x12, 0x0c, 0x3d, 0xe3,
0x2d, 0x1b, 0xde, 0xbc, 0x17, 0xfc, 0xf4, 0x08, 0x1e, 0x10, 0x1e, 0xdd,
0x1d, 0xe5, 0x07, 0xe9, 0x1b, 0x20, 0x04, 0x08, 0x00, 0x00, 0x0d, 0xec,
0x0b, 0x0f, 0x0d, 0x2b, 0x21, 0x0a, 0x21, 0x09, 0x1e, 0xdd, 0x2e, 0xdc,
0x17, 0x1f, 0xe8, 0x12, 0xe1, 0xb2, 0x27, 0xec, 0x2c, 0xd4, 0x54, 0xec,
0xf2, 0xe1, 0xec, 0x13, 0xfd, 0x1b, 0x17, 0xf0, 0xe2, 0xe6, 0x02, 0xe6,
0xe5, 0x36, 0xd8, 0xdf, 0x00, 0x10, 0x0f, 0x00, 0x0f, 0x1b, 0x09, 0x0d,
0x1d, 0x11, 0x2f, 0xe4, 0x41, 0xd7, 0x22, 0x04, 0x11, 0xd2, 0xe5, 0x09,
0x0e, 0xf4, 0x0c, 0x15, 0x2b, 0x10, 0x2c, 0x01, 0xf0, 0xd9, 0xf9, 0x15,
0x15, 0x0c, 0x1b, 0x20, 0x0d, 0xf4, 0x24, 0xdb, 0x02, 0xd2, 0x1a, 0xca,
0x01, 0x02, 0xfb, 0xf0, 0x1e, 0xff, 0x39, 0xee, 0x0b, 0x0a, 0x1a, 0xe3,
0xe8, 0x2a, 0xdd, 0xe6, 0x1d, 0xd9, 0xe0, 0x05, 0x1b, 0xfc, 0x1c, 0xd5,
0xf4, 0x12, 0x2f, 0xcc, 0x40, 0xe8, 0x0f, 0xe7, 0xec, 0xd2, 0xe6, 0x0e,
0x13, 0x0c, 0xf7, 0x02, 0x05, 0x12, 0xd9, 0xf9, 0x1a, 0xd1, 0x04, 0x12,
0xf4, 0xed, 0x01, 0xfd, 0x15, 0xdb, 0xfb, 0xf9, 0x1a, 0x05, 0x41, 0xd1,
0x04, 0x18, 0xea, 0xe6, 0x18, 0x20, 0x12, 0x0c, 0x04, 0xec, 0x36, 0x03,
0x1e, 0x1c, 0xf4, 0xce, 0xf7, 0xef, 0xed, 0x14, 0x01, 0xf0, 0xe5, 0xce,
0x0d, 0xe5, 0x09, 0xf9, 0x37, 0x07, 0x09, 0xff, 0xe0, 0xce, 0x20, 0x0d,
0x23, 0x18, 0x08, 0xf5, 0x42, 0xee, 0x1a, 0xf6, 0xea, 0xcc, 0x00, 0x1d,
0x16, 0xfd, 0xe9, 0x1d, 0x0d, 0xd6, 0x02, 0x0f, 0x30, 0xc2, 0x1f, 0x0e,
0xf8, 0xf3, 0xf9, 0xfd, 0x24, 0xfc, 0x04, 0x18, 0xe5, 0xf3, 0x27, 0x14,
0x1d, 0x16, 0x1e, 0xd2, 0x20, 0xef, 0xed, 0xe2, 0x1f, 0xde, 0x23, 0x0d,
0x05, 0x07, 0x33, 0x03, 0x36, 0x00, 0x08, 0xdf, 0xf9, 0xd8, 0x18, 0xf0,
0x38, 0x05, 0xcd, 0xf5, 0x2e, 0xe0, 0xe9, 0x01, 0x11, 0xc6, 0x22, 0xe7,
0xe1, 0x20, 0x0f, 0xec, 0x00, 0xf6, 0xeb, 0x14, 0x14, 0xe3, 0x44, 0xf3,
0xf6, 0x04, 0x0d, 0xe2, 0xfd, 0xe4, 0x2a, 0x1e, 0xf3, 0xf3, 0x27, 0xde,
0xfe, 0x14, 0xf9, 0xbb, 0x0a, 0xfa, 0xee, 0xf1, 0xe8, 0xf7, 0x0a, 0xbf,
0x08, 0xda, 0x19, 0xf6, 0x56, 0xe4, 0x00, 0xee, 0xfb, 0xff, 0x0f, 0x00,
0x36, 0x27, 0x07, 0x04, 0x30, 0xef, 0xe3, 0x06, 0xf9, 0xf1, 0x26, 0x19,
0x0d, 0xfd, 0xe1, 0x11, 0xef, 0xf8, 0xe4, 0x21, 0x17, 0xd6, 0x11, 0x05,
0x04, 0xe8, 0xed, 0xff, 0xe4, 0x0d, 0x24, 0xf2, 0xec, 0x25, 0x04, 0x1b,
0xf9, 0x28, 0x00, 0xdc, 0x0c, 0xef, 0xf2, 0x11, 0x0f, 0xe0, 0xe3, 0xc5,
0xe9, 0xfd, 0x14, 0x09, 0x0e, 0xed, 0xeb, 0xd4, 0x12, 0xf0, 0x11, 0xe3,
0x06, 0xe7, 0xef, 0x20, 0x30, 0x01, 0x21, 0x07, 0xeb, 0xe5, 0x04, 0x03,
0xf3, 0x12, 0xfa, 0x23, 0x22, 0xf6, 0xe4, 0xe0, 0x17, 0xf8, 0x4e, 0xf2,
0x1e, 0x1a, 0x1a, 0x18, 0x1b, 0xfc, 0x3d, 0xf5, 0x11, 0x20, 0x2d, 0x1e,
0x00, 0x23, 0xe8, 0xe0, 0xf1, 0x03, 0xee, 0x12, 0x0d, 0x13, 0x23, 0xd9,
0xe7, 0x0d, 0x31, 0xec, 0x13, 0xe1, 0xef, 0xfd, 0x11, 0xf8, 0x08, 0xeb,
0x1d, 0x04, 0x0c, 0x16, 0x0a, 0x20, 0xf2, 0x38, 0xe4, 0xd4, 0x23, 0xf5,
0xee, 0x21, 0xf9, 0xe1, 0x1d, 0xd3, 0x10, 0xeb, 0x3d, 0xf7, 0x34, 0xf9,
0x06, 0xe8, 0xe1, 0x19, 0xe3, 0xfd, 0x30, 0x1d, 0x14, 0x14, 0x1c, 0xfe,
0x18, 0x0d, 0x01, 0xe2, 0x19, 0x0a, 0x24, 0xec, 0x13, 0xec, 0xee, 0xf2,
0xfb, 0x1e, 0x15, 0xff, 0x12, 0xf6, 0x1f, 0xd0, 0x03, 0xda, 0xe5, 0x06,
0x0d, 0xe5, 0xf0, 0xe7, 0x38, 0xe6, 0x0b, 0xf8, 0x09, 0xe1, 0xe6, 0x16,
0xe0, 0x0f, 0x23, 0xf9, 0x0b, 0xcd, 0xee, 0x10, 0x03, 0xe5, 0x47, 0x07,
0xf8, 0x01, 0xdf, 0x19, 0x0d, 0x0f, 0x39, 0x1a, 0x0c, 0x1c, 0xfd, 0x1b,
0x17, 0x22, 0xe7, 0xdb, 0x12, 0xf4, 0x11, 0x07, 0xf3, 0x16, 0xfb, 0xb7,
0xea, 0x11, 0x04, 0xd9, 0x24, 0xe4, 0xfb, 0x15, 0xe9, 0x0c, 0x18, 0x0f,
0x00, 0x24, 0xd7, 0xfc, 0xff, 0xfb, 0x22, 0x2e, 0xda, 0xed, 0x0c, 0xf5,
0xe6, 0xf5, 0xfa, 0x15, 0xed, 0x12, 0xe3, 0x0e, 0x39, 0xee, 0x2e, 0xe8,
0x11, 0xee, 0xee, 0xf0, 0xf6, 0xec, 0x2e, 0x04, 0xf7, 0x14, 0x02, 0xe0,
0x23, 0x32, 0xde, 0xe0, 0x1c, 0x0e, 0x1a, 0x06, 0xf6, 0xe8, 0xe2, 0x05,
0xe9, 0xec, 0x10, 0xc2, 0x49, 0xe6, 0x00, 0xe3, 0x03, 0x16, 0xf8, 0x20,
0x22, 0x06, 0xed, 0x06, 0x26, 0x18, 0xf2, 0xfb, 0xfb, 0xf1, 0xf2, 0x01,
0xf3, 0xf5, 0xfb, 0x00, 0xf9, 0x01, 0xf6, 0x1a, 0x07, 0x07, 0x4c, 0xf8,
0x19, 0x0d, 0x1c, 0xdf, 0xfd, 0x21, 0x22, 0x07, 0x01, 0xe0, 0x12, 0x06,
0xf1, 0xf3, 0xe4, 0xe5, 0x10, 0x17, 0x0b, 0x1b, 0xe2, 0x0e, 0x21, 0xd0,
0xf4, 0xf9, 0x2b, 0xe4, 0x56, 0x01, 0xe3, 0x07, 0xf2, 0xe0, 0xfa, 0x0c,
0x01, 0xfc, 0xdc, 0xda, 0x42, 0x14, 0xf5, 0x1f, 0x0f, 0xc5, 0x1f, 0x0f,
0xf2, 0x05, 0x19, 0xed, 0xe4, 0xf0, 0x05, 0xf2, 0x11, 0xc5, 0x3b, 0x1b,
0x1e, 0xf6, 0xf7, 0xde, 0xf0, 0xfb, 0xfc, 0x29, 0xee, 0x19, 0x1c, 0xdf,
0xe2, 0x04, 0xf5, 0xcd, 0xf1, 0xe9, 0x1c, 0xe4, 0xe3, 0x23, 0x12, 0x15,
0x17, 0x02, 0x25, 0xef, 0x12, 0xe2, 0x03, 0xd7, 0xe5, 0x12, 0xe9, 0x13,
0x32, 0xec, 0xe3, 0x06, 0x3e, 0x09, 0xdc, 0x2d, 0xfd, 0xca, 0x30, 0xfc,
0xe4, 0xe3, 0x0d, 0xe9, 0x15, 0xf2, 0xfa, 0xeb, 0x31, 0x02, 0x35, 0x0b,
0x11, 0xd6, 0x21, 0xfd, 0x21, 0x10, 0x0f, 0x1b, 0xee, 0xfd, 0x2f, 0x18,
0x04, 0x0d, 0x01, 0xec, 0xff, 0xf7, 0xeb, 0x1c, 0x19, 0x0c, 0x1a, 0xf9,
0x1c, 0xee, 0x19, 0xf0, 0x22, 0xda, 0xfe, 0x03, 0x12, 0xe1, 0x28, 0x08,
0x04, 0xf1, 0xd5, 0xd7, 0x36, 0xea, 0x05, 0x2c, 0x18, 0xd6, 0x1b, 0xdd,
0xf7, 0x08, 0x0c, 0xeb, 0x20, 0xe5, 0x15, 0xf7, 0x3a, 0xfc, 0x29, 0xd8,
0xe3, 0x13, 0x09, 0xe3, 0x05, 0x10, 0x15, 0x15, 0xd7, 0xeb, 0x1d, 0x0b,
0xf4, 0x16, 0xee, 0xdb, 0xf5, 0xfd, 0xdd, 0x0d, 0xfe, 0xe5, 0x23, 0x2d,
0x19, 0xf1, 0xd0, 0xf3, 0xe5, 0x18, 0xf1, 0x1f, 0xe2, 0xe9, 0xe4, 0xf3,
0xdd, 0x1b, 0xf6, 0xef, 0xda, 0x07, 0x13, 0xf7, 0xea, 0x36, 0xf8, 0x03,
0xfc, 0x17, 0xe5, 0x1f, 0xdd, 0x69, 0x1d, 0xe0, 0xd5, 0xff, 0xbc, 0x3b,
0xde, 0xf1, 0xfb, 0x0e, 0x1d, 0x09, 0x0a, 0xf1, 0xf4, 0x00, 0xc4, 0x19,
0x07, 0xcc, 0x25, 0x3c, 0xe1, 0xf8, 0x13, 0x01, 0xe4, 0x09, 0x0f, 0x6d,
0xfd, 0xef, 0xf5, 0x2e, 0xf3, 0x33, 0xf0, 0x17, 0xf5, 0xfa, 0x0e, 0x1d,
0xef, 0xf7, 0x1c, 0xe7, 0xc1, 0xf4, 0xe4, 0x03, 0x13, 0x1f, 0xeb, 0xf3,
0xe2, 0x01, 0xf7, 0xeb, 0xf3, 0x3a, 0xed, 0xe6, 0xc2, 0x2c, 0xb4, 0x32,
0x14, 0x33, 0x08, 0x0e, 0x1c, 0x0e, 0xcc, 0x1a, 0x1f, 0x12, 0xff, 0x07,
0xed, 0xe4, 0x05, 0x14, 0xf4, 0x10, 0x1d, 0x11, 0x12, 0x14, 0x02, 0x62,
0x00, 0xe4, 0x05, 0x1c, 0xc0, 0x12, 0x05, 0x40, 0xf2, 0xff, 0x02, 0x00,
0xf7, 0x20, 0x0e, 0xdc, 0xfb, 0x07, 0xf7, 0xc9, 0x1f, 0x16, 0xe9, 0x14,
0xfd, 0xf2, 0xf1, 0x10, 0x06, 0x4d, 0xe6, 0x28, 0xc6, 0x14, 0xcb, 0xf8,
0x0d, 0x29, 0xef, 0x08, 0xe4, 0x19, 0xc7, 0x0c, 0x0e, 0xf5, 0xc5, 0x20,
0x2d, 0x03, 0x02, 0x3a, 0xfb, 0x27, 0x1c, 0xf7, 0x07, 0x23, 0xe6, 0x5b,
0xef, 0xf8, 0xe8, 0x25, 0xe3, 0xff, 0xe6, 0x1a, 0xde, 0xfa, 0xdb, 0x14,
0x0a, 0x07, 0x11, 0xed, 0xf2, 0xe8, 0xf7, 0xbf, 0x25, 0x28, 0xfa, 0x30,
0x21, 0x0a, 0x20, 0xf3, 0xfe, 0x2a, 0xfd, 0xfa, 0xe1, 0x2e, 0xb7, 0x0d,
0x07, 0x20, 0x17, 0x17, 0x06, 0x16, 0xf0, 0xee, 0xee, 0xe3, 0xc7, 0x01,
0xf0, 0xdb, 0x1a, 0x2d, 0x0c, 0x18, 0xe2, 0xff, 0x04, 0xed, 0x20, 0x43,
0x0b, 0x1d, 0xee, 0x38, 0xee, 0x19, 0x1b, 0x0c, 0x13, 0xfe, 0x06, 0x17,
0xf8, 0x1f, 0x0d, 0xfe, 0xb9, 0x0d, 0x1e, 0xe5, 0xe9, 0x37, 0x1c, 0x1c,
0x17, 0x01, 0x21, 0xf0, 0xfb, 0x25, 0x1d, 0x10, 0xfa, 0x36, 0xe4, 0xf3,
0xfb, 0x10, 0x18, 0x14, 0xff, 0xfc, 0x0c, 0x10, 0x2d, 0x0b, 0xce, 0xee,
0xfa, 0xef, 0xe9, 0x3a, 0x10, 0x1c, 0xfc, 0xee, 0x1c, 0x23, 0xf7, 0x63,
0xff, 0x01, 0xc4, 0xfc, 0xbe, 0x1b, 0xf9, 0x23, 0x15, 0x1f, 0x17, 0x18,
0xed, 0x26, 0xfa, 0xe3, 0xb6, 0x11, 0xf3, 0xe7, 0xe8, 0x39, 0xd0, 0x23,
0xe5, 0xf1, 0xe0, 0x02, 0xf9, 0x41, 0x15, 0x00, 0xf9, 0x3e, 0xe3, 0x03,
0x19, 0x31, 0xec, 0xf8, 0x16, 0x09, 0xef, 0xf2, 0xed, 0xe9, 0xcb, 0x1e,
0x09, 0xd9, 0x0a, 0x1e, 0x0c, 0x0b, 0xfc, 0x09, 0x21, 0x12, 0xf5, 0x4b,
0x15, 0x25, 0xfe, 0x28, 0xc4, 0x0f, 0x05, 0xef, 0x19, 0xef, 0x00, 0xdf,
0xed, 0x2c, 0x20, 0x1f, 0xfa, 0x07, 0xf4, 0xd5, 0x08, 0x3c, 0xc5, 0x16,
0x20, 0xf6, 0x16, 0xe0, 0x08, 0x5f, 0x09, 0xe5, 0x03, 0xfa, 0xf1, 0x25,
0x0c, 0x01, 0xe8, 0x0b, 0x14, 0xfc, 0xf5, 0x2d, 0xea, 0xf9, 0xbd, 0xf7,
0x06, 0xcb, 0x18, 0x49, 0xdf, 0x28, 0x13, 0xe6, 0x04, 0xe2, 0xf7, 0x48,
0xee, 0x1f, 0xe5, 0x37, 0xdd, 0x14, 0x0f, 0xd7, 0xf3, 0x08, 0xec, 0xfc,
0x05, 0x14, 0x22, 0x24, 0xf9, 0x02, 0x2c, 0xef, 0x13, 0x37, 0xfb, 0x0f,
0xdd, 0xe7, 0x01, 0xfb, 0x20, 0x59, 0x18, 0xe2, 0xe7, 0x1d, 0xf2, 0x32,
0xe9, 0x16, 0xe5, 0x2b, 0xf1, 0x0d, 0xc6, 0x06, 0xf8, 0x0f, 0xd0, 0x05,
0xfc, 0xc4, 0xdf, 0x44, 0x0f, 0x05, 0xf3, 0xfb, 0xf9, 0xde, 0x1f, 0x18,
0x02, 0x24, 0x07, 0x2d, 0xc4, 0xf3, 0xda, 0x1d, 0xf7, 0x0e, 0x01, 0xdd,
0xe7, 0x11, 0x14, 0x23, 0xc9, 0x1c, 0xed, 0xf1, 0xe4, 0x29, 0x03, 0x0f,
0x00, 0x10, 0xe1, 0x18, 0xef, 0x45, 0x05, 0x26, 0xde, 0xf5, 0xc3, 0x18,
0xf2, 0x25, 0xee, 0xfb, 0x18, 0xe2, 0xf7, 0x1d, 0x13, 0xf7, 0xe1, 0xfe,
0xec, 0x04, 0x24, 0x33, 0xf9, 0x1b, 0xfb, 0xfc, 0x00, 0xe8, 0x17, 0x3c,
0xdc, 0xf8, 0xd4, 0x0e, 0xf0, 0x0b, 0x17, 0x02, 0xdd, 0xf9, 0xe8, 0x06,
0xf4, 0x29, 0x1d, 0xe8, 0xcc, 0xf0, 0x0c, 0xd7, 0x06, 0x42, 0xde, 0x32,
0x21, 0xfc, 0xf6, 0xff, 0x0c, 0x63, 0xfd, 0x0d, 0xd7, 0x02, 0xce, 0x1f,
0x1b, 0x0c, 0x08, 0x06, 0x1c, 0x13, 0xfc, 0xfe, 0x20, 0xfb, 0xd0, 0xe7,
0xf3, 0xe7, 0xdf, 0x35, 0xfc, 0x21, 0x01, 0xf4, 0x14, 0xe7, 0xe2, 0x2b,
0xf7, 0x23, 0xf1, 0xf6, 0xec, 0x05, 0xf9, 0x0a, 0xe9, 0x26, 0x01, 0xff,
0x05, 0x1d, 0x22, 0xee, 0xf9, 0xf0, 0x1d, 0xcb, 0x02, 0x36, 0xdb, 0x0e,
0x1a, 0xfd, 0x06, 0xfe, 0xe3, 0x44, 0xdd, 0x26, 0x06, 0x22, 0xf4, 0x16,
0x22, 0x33, 0xf5, 0x08, 0x1b, 0x18, 0xff, 0x1b, 0x2d, 0xdb, 0xf2, 0x08,
0xe5, 0xd7, 0x10, 0x3e, 0xc5, 0x0f, 0x11, 0x1f, 0x09, 0xe7, 0x1d, 0x35,
0x09, 0x1c, 0xcf, 0x35, 0xf3, 0x29, 0xfb, 0xe9, 0xf7, 0x0e, 0xfb, 0xfc,
0x07, 0xe9, 0x2e, 0x12, 0xc1, 0x0a, 0x05, 0xc6, 0x16, 0x43, 0xf7, 0xfe,
0xfd, 0xfd, 0x05, 0xf7, 0x10, 0x54, 0xdb, 0xf0, 0xdb, 0x08, 0xc5, 0x36,
0x09, 0x00, 0xee, 0x00, 0xf4, 0xf9, 0xca, 0x13, 0x26, 0xe6, 0xca, 0x06,
0x18, 0xfc, 0x05, 0x44, 0xc9, 0xfd, 0xe7, 0xde, 0xfe, 0xe1, 0xef, 0x66,
0x19, 0x0f, 0xcf, 0x3b, 0xdf, 0x05, 0x13, 0x31, 0x22, 0x1e, 0xfc, 0x0a,
0xe3, 0x07, 0xfb, 0x1a, 0xfc, 0xe7, 0x03, 0xf5, 0x19, 0x25, 0xed, 0x38,
0xdf, 0xf7, 0xf6, 0x23, 0x05, 0x49, 0xea, 0xf1, 0x01, 0x0e, 0xdb, 0xf7,
0x07, 0x2b, 0xfd, 0xf9, 0x05, 0x02, 0xf7, 0x17, 0xea, 0x08, 0xc3, 0x17,
0xeb, 0xc1, 0x23, 0x50, 0x0f, 0x1f, 0x02, 0xee, 0xea, 0xe9, 0xf5, 0x38,
0x16, 0xeb, 0xdb, 0x39, 0xcf, 0x2e, 0xf7, 0xef, 0xf8, 0x24, 0xe1, 0xfa,
0xc9, 0x28, 0xea, 0x0b, 0xff, 0x18, 0x01, 0xee, 0xe1, 0x1f, 0x00, 0xf5,
0xef, 0xf9, 0x00, 0xf4, 0xf7, 0x37, 0x04, 0xe5, 0xf0, 0x1e, 0xdc, 0x0a,
0x01, 0x14, 0x0a, 0x10, 0xf0, 0x02, 0xda, 0x23, 0xf7, 0xf2, 0xf4, 0xf6,
0x05, 0xc6, 0xfe, 0x54, 0xe7, 0x32, 0xfb, 0xdb, 0xfb, 0x08, 0xf8, 0x4a,
0xff, 0x1a, 0xcd, 0x1c, 0xbe, 0x0e, 0x1b, 0x39, 0xee, 0x07, 0x1f, 0x05,
0x09, 0x16, 0xef, 0x07, 0xb3, 0x15, 0xed, 0xd3, 0xf4, 0x32, 0xfc, 0x14,
0xef, 0xda, 0x1e, 0xf4, 0xf9, 0x66, 0x13, 0x02, 0x0a, 0x22, 0xea, 0x09,
0xe3, 0x2a, 0x20, 0x1e, 0x0a, 0x1e, 0xc9, 0x31, 0x2e, 0x0e, 0xc0, 0xec,
0xf9, 0xd6, 0xf8, 0x4a, 0xec, 0x05, 0x1a, 0x17, 0x1f, 0xe2, 0xeb, 0x53,
0xfe, 0x1e, 0xe0, 0x20, 0xde, 0xf2, 0xda, 0x36, 0xf1, 0x12, 0xdb, 0x18,
0xc3, 0xf5, 0xfa, 0xf1, 0xca, 0x0b, 0x05, 0xd2, 0x1e, 0x13, 0x16, 0x15,
0xe4, 0x15, 0x1c, 0x02, 0x12, 0x49, 0xdb, 0x12, 0xda, 0x23, 0xcd, 0xef,
0x02, 0x04, 0x1f, 0xf5, 0x11, 0x0d, 0xd0, 0x1d, 0x25, 0x19, 0xc3, 0xfc,
0x28, 0xdb, 0xe6, 0x50, 0xe8, 0x19, 0x16, 0x00, 0x22, 0xfd, 0xf5, 0x34,
0x12, 0x25, 0xec, 0x13, 0xe9, 0x0c, 0xdf, 0xff, 0xe9, 0x2d, 0x04, 0xf6,
0xd3, 0x05, 0x08, 0x04, 0xc5, 0x16, 0x11, 0xc3, 0xf2, 0x1d, 0xf6, 0x30,
0x10, 0x15, 0x0e, 0x0f, 0x0f, 0x18, 0xed, 0x16, 0xcb, 0x00, 0xdb, 0x1b,
0xeb, 0x17, 0x16, 0xf1, 0x13, 0xf2, 0xf0, 0xf9, 0x0c, 0x1f, 0xf6, 0xee,
0x2a, 0xf8, 0x17, 0x34, 0xf7, 0x2a, 0x07, 0x1d, 0xe8, 0xe5, 0xf3, 0x2a,
0xff, 0xea, 0xe3, 0x32, 0xd7, 0x09, 0xe3, 0x11, 0x10, 0x10, 0x18, 0xff,
0xe8, 0x0d, 0xef, 0xf0, 0xf2, 0xf4, 0x1c, 0xee, 0x23, 0x35, 0xd5, 0x0e,
0xee, 0xe3, 0x12, 0xf6, 0x1f, 0x67, 0xff, 0x27, 0xe7, 0x21, 0xe7, 0x0b,
0x02, 0x37, 0xf6, 0x0c, 0xea, 0xf5, 0x0a, 0x12, 0x1b, 0x09, 0xc6, 0x11,
0xfb, 0xff, 0xe5, 0x45, 0xf8, 0x0d, 0xf1, 0xf9, 0xee, 0x14, 0xf4, 0x5f,
0xfa, 0x1b, 0x02, 0x27, 0xf0, 0x24, 0xe8, 0x15, 0xe2, 0x17, 0xfa, 0xe3,
0xff, 0xe3, 0x1b, 0x03, 0xf2, 0xe4, 0x18, 0xdd, 0xe0, 0x45, 0xfa, 0x37,
0x0a, 0xdf, 0xf9, 0xec, 0x18, 0x2c, 0xfd, 0x0e, 0xe6, 0x2c, 0xd4, 0x07,
0x1e, 0x1d, 0x02, 0xf7, 0xf7, 0x1e, 0x00, 0x05, 0x08, 0x17, 0xf2, 0xf3,
0xf2, 0xd9, 0xf3, 0x4b, 0x07, 0x31, 0x01, 0xe4, 0x1c, 0x1b, 0x23, 0x55,
0xec, 0x0a, 0xf7, 0x00, 0xe2, 0xfd, 0xe8, 0xfa, 0xf9, 0x31, 0x09, 0x15,
0xe2, 0x0c, 0x06, 0x17, 0xec, 0x02, 0xda, 0xf9, 0xf0, 0x47, 0xef, 0x27,
0xf5, 0xe1, 0xf4, 0xff, 0x09, 0x58, 0x13, 0x18, 0xd3, 0x1c, 0xb1, 0x20,
0xee, 0xf8, 0x0b, 0xf2, 0x0b, 0xfd, 0xcf, 0x1d, 0x00, 0x1d, 0xcb, 0x16,
0x20, 0xd0, 0xee, 0x23, 0xfa, 0x09, 0x1a, 0x10, 0x20, 0xdf, 0xf8, 0x50,
0xda, 0x0f, 0xe6, 0x1f, 0xf5, 0xfc, 0x1f, 0x0f, 0x02, 0x22, 0x20, 0xdc,
0xef, 0x09, 0x1e, 0x0f, 0xe4, 0x1f, 0x19, 0xcb, 0x06, 0x45, 0xda, 0x1d,
0x02, 0x04, 0xea, 0x1e, 0xdf, 0x61, 0x17, 0x1f, 0xca, 0x33, 0xdf, 0x12,
0x0a, 0xea, 0x03, 0x19, 0xfa, 0x1c, 0xf5, 0xf1, 0xf0, 0xf1, 0xde, 0x0b,
0x03, 0xdc, 0xf2, 0x2a, 0x13, 0x22, 0x22, 0xeb, 0x0a, 0x1e, 0xe8, 0x65,
0x09, 0x10, 0xf3, 0x3a, 0xec, 0x0e, 0x0d, 0x0c, 0x13, 0x2e, 0xeb, 0x20,
0xe7, 0xea, 0x07, 0xdc, 0xd0, 0x14, 0xf9, 0xfe, 0x1f, 0x1d, 0xe9, 0x04,
0xe1, 0x01, 0xe1, 0x0e, 0x0e, 0x48, 0x10, 0x10, 0xec, 0x37, 0xb8, 0x35,
0xff, 0x16, 0x21, 0x24, 0x01, 0xe0, 0xec, 0xfc, 0x2d, 0x0c, 0xba, 0xf8,
0x15, 0xd4, 0x26, 0x1c, 0xc7, 0x02, 0xf7, 0x0b, 0x1a, 0x02, 0xe3, 0x5d,
0x13, 0x1e, 0x01, 0x0d, 0xe6, 0x26, 0xec, 0xf9, 0xe9, 0x09, 0xf7, 0xdf,
0xda, 0xe2, 0x2a, 0x16, 0xc0, 0x0c, 0x1b, 0xc8, 0x08, 0x34, 0xff, 0x18,
0x01, 0x1d, 0xee, 0x06, 0x13, 0x65, 0x0c, 0xed, 0xd5, 0x29, 0xf0, 0x19,
0xe9, 0xfb, 0x18, 0x12, 0x04, 0xfb, 0xef, 0x21, 0x2e, 0x17, 0xe2, 0xfc,
0x14, 0xd8, 0xe2, 0x4e, 0xd6, 0x32, 0x0c, 0xda, 0xe1, 0x1f, 0xe2, 0x2b,
0xec, 0x08, 0x08, 0x30, 0xe8, 0x22, 0xe8, 0x22, 0x03, 0xf9, 0x15, 0xf8,
0xf1, 0x21, 0x21, 0x15, 0xe3, 0xf6, 0x27, 0x03, 0x0b, 0x32, 0xec, 0x0d,
0xef, 0xfe, 0x01, 0x12, 0xf1, 0x54, 0xf9, 0xe5, 0xcb, 0x28, 0xcd, 0xf5,
0xe4, 0x12, 0x20, 0x04, 0x01, 0x1a, 0xd3, 0xf0, 0x20, 0x17, 0xd6, 0xde,
0x1e, 0xea, 0xfe, 0x38, 0x10, 0xfa, 0xeb, 0x12, 0xf2, 0xe2, 0xf7, 0x46,
0x13, 0xe4, 0xde, 0x04, 0xd7, 0x0f, 0xf7, 0x15, 0xfc, 0xfa, 0x09, 0xde,
0xc6, 0x24, 0xec, 0xf6, 0xfa, 0x0a, 0x0a, 0xbb, 0xe9, 0x49, 0xd2, 0x2e,
0xdd, 0xde, 0x11, 0x05, 0xfe, 0x41, 0x03, 0xea, 0xe4, 0x37, 0xda, 0xef,
0xed, 0xfc, 0x06, 0x13, 0x17, 0xef, 0xf1, 0xef, 0x2b, 0xe5, 0xc5, 0xf9,
0x1f, 0xe3, 0xf4, 0x20, 0xdb, 0x2e, 0x08, 0x1f, 0x18, 0xf3, 0x1e, 0x61,
0xf5, 0xf9, 0xf0, 0xf9, 0xde, 0x16, 0xe4, 0xf8, 0x18, 0x2c, 0x01, 0x17,
0xf3, 0x13, 0xf4, 0x24, 0xee, 0xf6, 0x15, 0xcf, 0xe9, 0x49, 0xc8, 0x0e,
0xef, 0x15, 0xe9, 0xe1, 0x18, 0x33, 0x13, 0xee, 0xd1, 0x3b, 0xdf, 0xf6,
0xe9, 0xed, 0x10, 0x12, 0x15, 0x1a, 0xf3, 0xf7, 0x09, 0xd1, 0xc8, 0x22,
0xf0, 0xe0, 0xff, 0x20, 0xe1, 0x0c, 0xf3, 0xf2, 0xf6, 0xe8, 0xdc, 0x6f,
0xf1, 0x13, 0xde, 0x08, 0xeb, 0x15, 0xf0, 0x01, 0x15, 0xfc, 0xe4, 0x17,
0xd0, 0x26, 0xff, 0x0f, 0xf7, 0xef, 0xf0, 0xd3, 0x26, 0x50, 0xf3, 0x12,
0x0a, 0x0c, 0xfc, 0xe2, 0xf9, 0x46, 0xe5, 0x0e, 0x04, 0x3a, 0xc0, 0x15,
0xf3, 0x31, 0x14, 0x08, 0x0d, 0xe6, 0xff, 0xfe, 0x10, 0xeb, 0xdf, 0x11,
0x21, 0xce, 0x0b, 0x33, 0x22, 0x31, 0xe9, 0x11, 0xed, 0x04, 0x08, 0x4d,
0xe0, 0xea, 0xfc, 0x2c, 0xc2, 0x30, 0xe4, 0xfb, 0xef, 0x04, 0xf4, 0x0f,
0xfa, 0xd8, 0xfb, 0xd9, 0xc3, 0xe8, 0x0b, 0xe8, 0x1e, 0x1c, 0xe6, 0x32,
0x09, 0xde, 0xe3, 0x08, 0xf3, 0x41, 0xe6, 0x12, 0xcf, 0x38, 0xed, 0xf8,
0xea, 0x1f, 0xdf, 0x18, 0xde, 0x23, 0xf0, 0x16, 0x00, 0x08, 0xf4, 0x16,
0xdb, 0xdf, 0xfd, 0x24, 0xcf, 0x17, 0xfd, 0x14, 0xfc, 0x06, 0xfb, 0x4c,
0x0a, 0x1c, 0x02, 0xff, 0xdf, 0x0d, 0xe4, 0x18, 0x0d, 0xf3, 0xf0, 0xec,
0xdc, 0x16, 0x0e, 0xde, 0xdd, 0xeb, 0x11, 0xbf, 0xf0, 0x2e, 0xd1, 0x16,
0x03, 0x0b, 0x14, 0xf5, 0xeb, 0x60, 0x16, 0xf6, 0xe6, 0x1e, 0xbc, 0x07,
0xf6, 0x0a, 0x19, 0x07, 0x0e, 0xe0, 0xfd, 0x03, 0x16, 0x1d, 0xd1, 0x14,
0x1b, 0xe3, 0xf1, 0x3e, 0xf6, 0x34, 0xed, 0xf0, 0xfa, 0xf7, 0xf7, 0x47,
0xde, 0xf0, 0xe2, 0x43, 0xdb, 0xfd, 0x1d, 0x13, 0x0a, 0x01, 0xd9, 0xf2,
0xdf, 0x19, 0xed, 0x09, 0xd4, 0x19, 0x1c, 0xef, 0x23, 0x19, 0xe8, 0x32,
0x22, 0xdc, 0xe5, 0xfa, 0xf9, 0x5d, 0x02, 0xe4, 0xd5, 0x0b, 0xbd, 0xf1,
0x02, 0x25, 0x07, 0xf3, 0x13, 0x13, 0xfa, 0xed, 0x2d, 0xfe, 0x00, 0x12,
0xf7, 0x03, 0xe9, 0x59, 0x03, 0x26, 0x08, 0xe2, 0xe7, 0x0f, 0x05, 0x33,
0x17, 0x17, 0xcb, 0x1d, 0xaf, 0x19, 0xfe, 0x1f, 0xf2, 0x1a, 0x0c, 0xec,
0xdc, 0x1e, 0x32, 0xed, 0xe5, 0xff, 0x2a, 0xde, 0xfc, 0x31, 0xff, 0xf3,
0xe9, 0xf7, 0x12, 0x1f, 0xe2, 0x6a, 0xf3, 0x20, 0xf8, 0xff, 0xbf, 0xf4,
0x0f, 0xf1, 0x20, 0x0b, 0x1d, 0xfc, 0xfc, 0xe2, 0x13, 0x26, 0xc0, 0x06,
0x13, 0xcd, 0xf1, 0x1f, 0x1e, 0x36, 0x19, 0xf4, 0x0e, 0x0a, 0x0c, 0x4a,
0x13, 0xf4, 0xd0, 0x2f, 0xe6, 0xf7, 0x0e, 0x13, 0xe7, 0x12, 0x06, 0xfc,
0xea, 0xf6, 0xfb, 0xe1, 0xc5, 0x05, 0x12, 0xc9, 0xdd, 0x1e, 0xfa, 0xf5,
0x12, 0x0a, 0x05, 0xeb, 0x13, 0x55, 0xfb, 0x25, 0xd3, 0x41, 0xdc, 0x07,
0xed, 0x32, 0x05, 0x1c, 0xe9, 0xf0, 0xec, 0x10, 0xf2, 0x1b, 0xc5, 0xf5,
0x1a, 0xfb, 0xe0, 0x29, 0xfc, 0x30, 0x1e, 0xe2, 0x1a, 0x0e, 0xde, 0x20,
0xfe, 0x21, 0x06, 0x1b, 0xb6, 0x05, 0x03, 0x0b, 0x23, 0x04, 0xf5, 0xe8,
0xf5, 0x1e, 0x32, 0x13, 0xdc, 0x14, 0x31, 0xf9, 0x10, 0x48, 0xb9, 0x12,
0x0c, 0xf0, 0xed, 0xf6, 0x1a, 0x38, 0xfe, 0x25, 0xc8, 0x30, 0xb4, 0xf6,
0x01, 0x1f, 0x1b, 0x1c, 0xf8, 0xe7, 0xf5, 0x17, 0x0b, 0x0b, 0xce, 0xe7,
0xf4, 0xf0, 0x0f, 0x45, 0x08, 0x16, 0x1e, 0xdc, 0xf5, 0xec, 0xf8, 0x23,
0x17, 0xe7, 0xda, 0x26, 0xe3, 0xdf, 0xf8, 0x11, 0x01, 0xf7, 0x0c, 0xfb,
0xe7, 0x03, 0x12, 0x02, 0xbc, 0x08, 0xf9, 0x00, 0x0a, 0x3a, 0x11, 0x02,
0x1b, 0xef, 0xeb, 0x06, 0xff, 0x51, 0xdb, 0x1d, 0xcb, 0x0a, 0xb3, 0x18,
0x03, 0xe6, 0x09, 0x0c, 0xdf, 0xf7, 0xe5, 0xdd, 0x1d, 0xfc, 0xf1, 0x0b,
0x12, 0xc6, 0xf7, 0x38, 0x08, 0x23, 0x0a, 0xf2, 0x18, 0xff, 0xe1, 0x66,
0xfe, 0xe7, 0xc1, 0x1c, 0xeb, 0x07, 0xf4, 0xeb, 0xef, 0xfb, 0x0b, 0x19,
0xe1, 0xf8, 0x01, 0xff, 0xcc, 0xee, 0xf1, 0x00, 0xef, 0x3e, 0xfc, 0x22,
0xde, 0x11, 0xdd, 0x06, 0x15, 0x33, 0x0c, 0x00, 0xce, 0x13, 0xf6, 0x06,
0xf6, 0xf8, 0x02, 0xf3, 0xf7, 0x0e, 0x0c, 0x1f, 0x25, 0xd8, 0xc4, 0x1d,
0x17, 0xf4, 0xf9, 0x0e, 0xdd, 0xfc, 0xf0, 0x08, 0xe3, 0x05, 0x1a, 0x30,
0x0a, 0x11, 0xe8, 0x3f, 0xd5, 0x13, 0x13, 0xf5, 0xef, 0x2f, 0xe1, 0xe4,
0xd1, 0xeb, 0x11, 0xeb, 0xda, 0x0d, 0x03, 0xdb, 0x15, 0x2f, 0xca, 0x27,
0x1d, 0x19, 0xf6, 0xf4, 0x22, 0x3c, 0x17, 0xe8, 0xe1, 0x05, 0xc2, 0x3a,
0xe2, 0x37, 0x0d, 0xfa, 0xe8, 0x09, 0xf4, 0xf8, 0x2b, 0x04, 0xd6, 0xfd,
0x15, 0xcb, 0x08, 0x4f, 0xda, 0x1e, 0xe7, 0x01, 0xe1, 0xf4, 0x1e, 0x5f,
0xf8, 0x23, 0xfe, 0x34, 0xaf, 0x09, 0x24, 0xff, 0x00, 0x1f, 0xdd, 0x0a,
0xde, 0xe9, 0xfe, 0xda, 0xfb, 0x15, 0xe6, 0x0b, 0x13, 0x3d, 0xdd, 0x2b,
0xed, 0x08, 0xe3, 0x13, 0x13, 0x57, 0xe9, 0xf0, 0xd4, 0x1c, 0xb7, 0x25,
0x1f, 0x04, 0xf0, 0x0f, 0x07, 0xed, 0xcc, 0x0c, 0x04, 0xd5, 0xd4, 0xe8,
0xf9, 0xe5, 0x06, 0x24, 0x10, 0xf6, 0xe8, 0xde, 0x1d, 0xfb, 0xf0, 0x49,
0x1f, 0x08, 0xff, 0x36, 0xde, 0x0f, 0x04, 0x06, 0x1a, 0x13, 0x09, 0x0c,
0xf6, 0x27, 0x30, 0xfe, 0xff, 0x1d, 0x19, 0xcc, 0x01, 0x49, 0xec, 0x33,
0xf9, 0xff, 0xed, 0xed, 0xf4, 0x52, 0xde, 0xf0, 0xe5, 0x45, 0xae, 0xf2,
0xdc, 0x0e, 0x1e, 0x19, 0xe0, 0xe8, 0xf4, 0xfe, 0x1b, 0x12, 0xdd, 0x23,
0x08, 0xe7, 0xf6, 0x53, 0xdc, 0x2e, 0x07, 0x13, 0x09, 0xdd, 0xe8, 0x21,
0x00, 0x14, 0xd0, 0x10, 0xe1, 0xf0, 0xf8, 0x14, 0x0b, 0x25, 0xe8, 0xe5,
0x08, 0xf2, 0x2a, 0x17, 0xe8, 0x15, 0x01, 0xe8, 0xf6, 0x40, 0x0e, 0x35,
0xe7, 0x0a, 0xeb, 0x22, 0x1a, 0x5b, 0xe6, 0xef, 0xcd, 0x00, 0xb2, 0x3a,
0x08, 0x2f, 0x20, 0xf1, 0xec, 0x1e, 0x0d, 0xea, 0x09, 0xf1, 0xca, 0x03,
0xec, 0xe4, 0xf9, 0x4c, 0xf0, 0x38, 0xff, 0xfa, 0x05, 0x01, 0xf0, 0x41,
0xf5, 0x17, 0xc8, 0x00, 0xb3, 0x1b, 0x12, 0xfc, 0xf7, 0x0f, 0x00, 0xdf,
0xd2, 0xf4, 0x2d, 0xec, 0xdd, 0x22, 0x16, 0xca, 0x1e, 0x3e, 0xe2, 0x06,
0x00, 0x12, 0x1e, 0xe7, 0xf2, 0x1e, 0x07, 0x05, 0xd4, 0x2c, 0xb5, 0x18,
0x0d, 0x16, 0xf7, 0x1f, 0x13, 0xfe, 0xd0, 0x26, 0x0f, 0xed, 0xf0, 0xf5,
0x0e, 0xfe, 0xfa, 0x35, 0xf9, 0x15, 0x0f, 0xd9, 0x06, 0xef, 0xe1, 0x35,
0xfd, 0x23, 0xc7, 0x22, 0xca, 0x19, 0xff, 0x1d, 0x16, 0x0f, 0xd8, 0x06,
0xf4, 0x07, 0x2e, 0x10, 0xd2, 0xf9, 0x0a, 0xcb, 0xfa, 0x46, 0xf2, 0x02,
0x15, 0xf6, 0x0a, 0xe2, 0x1d, 0x2b, 0xfa, 0x2b, 0xfb, 0x2f, 0xec, 0xff,
0x1a, 0x0c, 0xf8, 0xf3, 0x06, 0xde, 0xd7, 0x0f, 0x30, 0x27, 0xfc, 0xfa,
0x1e, 0xfb, 0xe5, 0x31, 0xd1, 0x1f, 0x06, 0x05, 0x01, 0x23, 0x23, 0x60,
0xf3, 0x13, 0xec, 0x11, 0xb1, 0x14, 0xf2, 0x11, 0xe1, 0x1c, 0x14, 0xe9,
0xe4, 0xed, 0x1c, 0xfe, 0xfc, 0x0c, 0x08, 0xcf, 0xfe, 0x36, 0xd6, 0x07,
0x04, 0xe9, 0xf5, 0xe4, 0x21, 0x36, 0x0f, 0x10, 0xf7, 0x1d, 0xb2, 0xe6,
0x0f, 0x28, 0x23, 0x2f, 0x15, 0xf7, 0xce, 0xd6, 0x05, 0x0f, 0xe2, 0x1e,
0x1f, 0xd5, 0xe8, 0x42, 0xc5, 0x35, 0xe0, 0xfd, 0x13, 0x11, 0x10, 0x40,
0xed, 0x27, 0xc3, 0x2b, 0xb2, 0x0b, 0x04, 0xf2, 0x21, 0x1d, 0xf7, 0x0b,
0xd8, 0xe3, 0x26, 0xfd, 0xea, 0x01, 0x08, 0x04, 0x14, 0x12, 0x02, 0x2b,
0x21, 0x1c, 0xfd, 0xfa, 0x0b, 0x4e, 0xf8, 0xed, 0xd8, 0x12, 0xdf, 0xe8,
0x07, 0x24, 0x15, 0x10, 0xec, 0xfa, 0xf9, 0xf2, 0x05, 0xfc, 0xec, 0xfe,
0x0e, 0x01, 0x01, 0x12, 0xc4, 0x16, 0xe2, 0x06, 0x1b, 0x00, 0x0d, 0x3d,
0x13, 0x23, 0xd8, 0x0e, 0xe2, 0x2b, 0x04, 0x1b, 0x10, 0x0b, 0xff, 0x23,
0xfd, 0x02, 0x00, 0x00, 0xe1, 0x02, 0xda, 0x0a, 0xed, 0x4e, 0x0c, 0x1e,
0xe1, 0xe0, 0xe3, 0xeb, 0x09, 0x34, 0xef, 0xfe, 0xf2, 0x1f, 0xbc, 0xed,
0x06, 0xf4, 0x07, 0xfe, 0xfa, 0x00, 0xcb, 0xdf, 0x1f, 0xe4, 0xea, 0x11,
0x0f, 0xd5, 0x20, 0x3d, 0x18, 0xf7, 0x16, 0xf9, 0xf4, 0xfa, 0x02, 0x4d,
0xf2, 0x21, 0x08, 0x30, 0xca, 0x39, 0xf8, 0x28, 0xea, 0x00, 0x19, 0xe2,
0xd7, 0x13, 0xed, 0xef, 0xf3, 0xe2, 0xf2, 0x04, 0x00, 0x47, 0x0f, 0x0a,
0x1a, 0xed, 0x00, 0x08, 0xe1, 0x42, 0xf1, 0x1f, 0xed, 0x2f, 0xe1, 0x16,
0x0d, 0x28, 0x16, 0x01, 0x19, 0x08, 0x0c, 0xf3, 0x31, 0xf1, 0xe9, 0x21,
0x1e, 0xd2, 0xfb, 0x1c, 0xdc, 0x1f, 0xf8, 0xf3, 0x12, 0x17, 0x05, 0x16,
0x0d, 0x28, 0xf6, 0x1b, 0xee, 0x21, 0x0f, 0x1d, 0x0d, 0x08, 0x16, 0x14,
0x03, 0x0b, 0x05, 0xfb, 0xeb, 0x12, 0x04, 0xea, 0x14, 0x55, 0x00, 0xfe,
0xfb, 0x11, 0x07, 0x13, 0x19, 0x4c, 0x18, 0xf2, 0xe8, 0x2f, 0xab, 0x29,
0xfe, 0x34, 0x0a, 0x01, 0x0a, 0x04, 0xd4, 0xee, 0x01, 0x14, 0xe2, 0x1b,
0x0f, 0xc3, 0xf8, 0x54, 0x14, 0x3d, 0x13, 0xdd, 0xdf, 0xfd, 0xf8, 0x37,
0xee, 0xfa, 0xc6, 0x13, 0xd9, 0xf9, 0x09, 0xf5, 0x21, 0x2d, 0xe3, 0x06,
0x08, 0x1f, 0x11, 0x10, 0xf9, 0xe1, 0xff, 0xc6, 0x15, 0x49, 0x0e, 0x16,
0xf9, 0xff, 0xdd, 0x12, 0x08, 0x40, 0x05, 0x23, 0xd3, 0x40, 0xca, 0x19,
0xf0, 0x21, 0xfb, 0x33, 0xde, 0x10, 0xe0, 0xe3, 0x0d, 0x11, 0xc5, 0xdd,
0xe9, 0xf1, 0x26, 0x15, 0x03, 0x16, 0xee, 0xdb, 0x22, 0x11, 0xf8, 0x52,
0x0e, 0xf3, 0xce, 0x03, 0xac, 0x2c, 0xee, 0x2f, 0xde, 0xfa, 0xf1, 0xf6,
0xdf, 0xd7, 0x1d, 0xf7, 0xed, 0xf5, 0x24, 0xc9, 0x06, 0x4f, 0xdf, 0x35,
0xe1, 0xeb, 0xed, 0xf7, 0xf0, 0x3d, 0xe1, 0x17, 0xca, 0x2c, 0xc3, 0x21,
0xfe, 0x0c, 0x07, 0x05, 0xe5, 0x0d, 0xd3, 0xeb, 0x0c, 0x21, 0xbe, 0xe5,
0x21, 0xf6, 0xed, 0x1c, 0x00, 0x26, 0x21, 0xf7, 0xe6, 0xf4, 0xee, 0x0c,
0x18, 0xff, 0xfd, 0x29, 0xad, 0x1a, 0x13, 0xe2, 0x1c, 0x29, 0x19, 0xf2,
0xc9, 0x1b, 0x28, 0xf0, 0xe2, 0x05, 0x08, 0xf1, 0x0a, 0x1e, 0xf4, 0x12,
0x13, 0x11, 0x12, 0xdf, 0xfa, 0x2b, 0xe7, 0xeb, 0xf2, 0x32, 0xc5, 0x3c,
0x07, 0x01, 0x01, 0x1b, 0xec, 0xf2, 0xf8, 0x06, 0x03, 0x11, 0xc3, 0xf3,
0xf9, 0xe4, 0xfe, 0x34, 0xd8, 0x2e, 0xed, 0xe9, 0xf5, 0x1f, 0xde, 0x62,
0x0b, 0xfb, 0xd2, 0x44, 0xb9, 0x26, 0xf4, 0x12, 0x14, 0xea, 0x0e, 0xfc,
0x08, 0xf9, 0x1b, 0x07, 0xfd, 0xe2, 0x09, 0xd1, 0xea, 0x1c, 0xe3, 0x12,
0xf7, 0x05, 0xe6, 0x23, 0x05, 0x5c, 0xdc, 0x0d, 0xcf, 0x16, 0xcc, 0xfd,
0xff, 0x32, 0x14, 0x06, 0xe9, 0xf2, 0x07, 0x16, 0x28, 0x26, 0xe6, 0xe7,
0x15, 0xfa, 0x11, 0x46, 0xc4, 0xef, 0x0d, 0x17, 0x1a, 0xf0, 0x20, 0x31,
0xf5, 0x19, 0xe6, 0xfd, 0xbf, 0xe5, 0x06, 0x08, 0xe9, 0x04, 0xdf, 0x0d,
0xe0, 0xd3, 0xf6, 0x00, 0xf7, 0xf3, 0x23, 0xec, 0xf3, 0x31, 0xdf, 0x32,
0xfd, 0xf9, 0xe0, 0xe3, 0x1e, 0x37, 0x10, 0xef, 0xed, 0x0d, 0xac, 0xe9,
0x1d, 0xe6, 0xe1, 0x15, 0xde, 0xff, 0xd2, 0xf4, 0x24, 0x08, 0xe0, 0x15,
0x2b, 0xc4, 0xec, 0x16, 0xf1, 0x0e, 0xf9, 0xf9, 0x07, 0x0a, 0xf7, 0x4d,
0x08, 0xe6, 0xf3, 0x08, 0xc5, 0xe8, 0x09, 0x03, 0x11, 0xf3, 0xff, 0xde,
0x10, 0x1b, 0x13, 0x02, 0xf1, 0xf0, 0xff, 0xe7, 0xe1, 0x1d, 0xd4, 0x31,
0x04, 0xfc, 0x0a, 0x01, 0x22, 0x3f, 0xf8, 0x03, 0xd9, 0x3a, 0xd7, 0x18,
0xfa, 0x07, 0x06, 0x29, 0x13, 0x13, 0xd0, 0xf4, 0x17, 0xfd, 0xcf, 0xfd,
0xde, 0xdf, 0x03, 0x43, 0xdd, 0x32, 0x1b, 0x1f, 0xec, 0x20, 0x1c, 0x64,
0x1a, 0x22, 0xd0, 0x1c, 0xd7, 0xf7, 0x0d, 0xfb, 0xec, 0x09, 0xdf, 0xea,
0x0c, 0x05, 0x12, 0xd8, 0xc2, 0x0e, 0x08, 0xc8, 0xe6, 0x2f, 0xe4, 0x30,
0x02, 0x0a, 0xf5, 0x05, 0x0f, 0x50, 0x13, 0xe3, 0xe9, 0x44, 0xb7, 0x35,
0x0b, 0xf4, 0xf7, 0x0d, 0xe9, 0x21, 0xe6, 0xea, 0x0c, 0xd0, 0xf5, 0x12,
0xfe, 0xf4, 0xe9, 0x55, 0xfe, 0x0c, 0x1f, 0xf3, 0xf5, 0x1c, 0x0c, 0x62,
0x00, 0x07, 0xc3, 0x1e, 0xdb, 0x35, 0x07, 0xe6, 0xfb, 0xfb, 0x01, 0xe9,
0xe0, 0x16, 0x2e, 0xf6, 0xdf, 0x14, 0x10, 0x07, 0x1a, 0x1b, 0x02, 0x23,
0x00, 0xf8, 0xfb, 0x15, 0x00, 0x4b, 0x12, 0xf9, 0x07, 0x19, 0xce, 0x30,
0xef, 0x17, 0xe5, 0x0e, 0x0f, 0x1c, 0xe6, 0xf6, 0x15, 0xf2, 0xe5, 0x01,
0x1f, 0x06, 0xf7, 0x2a, 0xfb, 0x18, 0xe5, 0x1d, 0xed, 0xe0, 0xf7, 0x5b,
0x06, 0x24, 0xfb, 0x25, 0xe9, 0xee, 0x14, 0x24, 0x0f, 0x1e, 0x1e, 0xfe,
0xe3, 0x0a, 0xf7, 0xe9, 0xcf, 0x0c, 0xff, 0xcc, 0xf1, 0x38, 0xef, 0x34,
0xf2, 0xfb, 0x0f, 0xfe, 0xe6, 0x43, 0x0a, 0xf3, 0xc8, 0x3d, 0xcc, 0x2b,
0xe9, 0xdc, 0xf8, 0xf5, 0xdd, 0xe7, 0xca, 0x02, 0xf6, 0x06, 0xf3, 0xfa,
0xe0, 0xf4, 0x24, 0x5a, 0xe0, 0x30, 0xee, 0xda, 0x0a, 0xe9, 0xf3, 0x6b,
0x1f, 0x27, 0xc8, 0x2d, 0xf2, 0x2f, 0xea, 0x0a, 0xfa, 0xfc, 0xfb, 0xfc,
0x07, 0xdc, 0x31, 0x0d, 0xcb, 0x1b, 0xf1, 0xfc, 0xf6, 0x46, 0xe5, 0x20,
0xef, 0x17, 0x05, 0x00, 0x11, 0x3f, 0x0a, 0x20, 0x08, 0x10, 0xc1, 0x04,
0xfd, 0xf1, 0xe3, 0x0e, 0x0c, 0xfa, 0xd3, 0x13, 0x2e, 0x24, 0xe6, 0x18,
0x1e, 0xce, 0xe3, 0x3f, 0xff, 0x25, 0xde, 0x1d, 0xe2, 0x15, 0x15, 0x38,
0xfe, 0xf2, 0xcf, 0x1c, 0xa8, 0xf4, 0x1b, 0x1b, 0xe2, 0x03, 0xe7, 0x11,
0xdc, 0xdd, 0x25, 0xf8, 0xed, 0xec, 0xe2, 0xfa, 0xf2, 0x5a, 0xe5, 0x1f,
0x04, 0x01, 0xf0, 0xe3, 0x03, 0x4f, 0xda, 0x0e, 0xfe, 0x12, 0xc5, 0x04,
0xec, 0x0e, 0xed, 0x0b, 0xf6, 0x15, 0x0a, 0x20, 0x05, 0x00, 0xc6, 0x17,
0xf0, 0xe9, 0x10, 0x42, 0xed, 0xf8, 0x0c, 0xf8, 0xe0, 0x16, 0x16, 0x39,
0x14, 0xe8, 0xca, 0x2d, 0xbf, 0xfd, 0xdb, 0xda, 0xfd, 0x1b, 0xda, 0x00,
0xea, 0x03, 0x25, 0xec, 0xc4, 0xea, 0x16, 0xc6, 0x0c, 0x40, 0xd8, 0x2b,
0xf3, 0x04, 0xdf, 0xe5, 0x1c, 0x2c, 0xdf, 0x0c, 0xe9, 0x0c, 0xaa, 0x25,
0xf3, 0xee, 0x08, 0x0a, 0xe5, 0x0a, 0xff, 0x0e, 0x18, 0xff, 0xfd, 0x1c,
0x05, 0xd4, 0xf4, 0x38, 0xd9, 0x06, 0x22, 0x18, 0xed, 0xe0, 0xe6, 0x13,
0x0b, 0xfe, 0xd7, 0x1b, 0xd5, 0xf2, 0xfe, 0x37, 0x1f, 0x1e, 0x1a, 0xe4,
0xdc, 0x09, 0xf7, 0x25, 0xec, 0xe6, 0x1e, 0xea, 0xf6, 0x51, 0xe5, 0x04,
0xe1, 0xf4, 0x02, 0xeb, 0x07, 0x35, 0xe4, 0x2d, 0xd7, 0x27, 0xd2, 0x14,
0xf7, 0x30, 0xe5, 0x31, 0xee, 0xf6, 0xfc, 0xea, 0x2f, 0x0a, 0xce, 0x02,
0x04, 0xec, 0xed, 0x2a, 0xe4, 0x18, 0xe5, 0x12, 0x13, 0xf2, 0xed, 0x20,
0xec, 0xf5, 0xc7, 0x18, 0xbd, 0xd1, 0x13, 0x31, 0x18, 0x26, 0x14, 0x1f,
0xf3, 0xfa, 0x2b, 0xee, 0xef, 0xec, 0x12, 0xec, 0xe2, 0x26, 0xd9, 0xf1,
0xf0, 0xf3, 0xfa, 0x0a, 0xe4, 0x53, 0x0c, 0x21, 0x04, 0x35, 0xb8, 0x31,
0x00, 0xf7, 0x00, 0xf4, 0x1a, 0xe4, 0xe4, 0xdf, 0xfb, 0xea, 0xbf, 0x23,
0xd6, 0xd8, 0x1e, 0x37, 0xec, 0x28, 0x07, 0xe9, 0xe0, 0xe6, 0x14, 0x7f,
0xe5, 0x1a, 0x0e, 0x16, 0xb3, 0xe2, 0xe2, 0x0f, 0xf7, 0x11, 0x1e, 0xe9,
0xee, 0xdc, 0x1f, 0x02, 0xc1, 0x1b, 0xf3, 0x04, 0xfa, 0x34, 0x12, 0x16,
0xf6, 0xdc, 0x0a, 0xe1, 0x20, 0x63, 0x03, 0x23, 0xfa, 0x34, 0xb3, 0x00,
0x21, 0x18, 0x0b, 0x08, 0xf5, 0x07, 0x0f, 0xf3, 0x2a, 0x02, 0xfd, 0xe3,
0x17, 0x0d, 0x12, 0x3b, 0x07, 0xf4, 0xef, 0x1c, 0x1a, 0xed, 0xde, 0x38,
0xdc, 0xea, 0xd5, 0x44, 0xb4, 0x05, 0xe5, 0x22, 0xe8, 0x1a, 0x12, 0x11,
0xd0, 0x1d, 0x01, 0xd0, 0xd4, 0xe4, 0xfc, 0xc5, 0x1a, 0x20, 0x02, 0x00,
0xf2, 0xe1, 0xf3, 0x02, 0xfd, 0x38, 0x13, 0xf3, 0x05, 0x33, 0xe2, 0xf9,
0x20, 0xe9, 0x21, 0x20, 0xff, 0xf7, 0x04, 0x20, 0x0b, 0x00, 0xf8, 0x02,
0x19, 0xe0, 0x10, 0x1d, 0xe5, 0x37, 0x06, 0x1c, 0xf4, 0xdf, 0x24, 0x5b,
0x0f, 0x06, 0xcc, 0x23, 0xd2, 0xfe, 0xef, 0x0e, 0x0a, 0x1c, 0x05, 0x0b,
0x0f, 0x07, 0x30, 0xf9, 0xc0, 0x0c, 0x08, 0xd6, 0x03, 0x53, 0xf0, 0x14,
0x07, 0xe9, 0xeb, 0x21, 0x13, 0x51, 0x13, 0x26, 0x0a, 0x12, 0xca, 0x0e,
0x00, 0xf7, 0x20, 0x22, 0x05, 0xf7, 0xd1, 0x14, 0x12, 0xd7, 0xda, 0x0d,
0xfe, 0xf5, 0xfe, 0x37, 0xf5, 0x34, 0xeb, 0xf1, 0xde, 0xe2, 0xf9, 0x31,
0x15, 0x08, 0x0f, 0x12, 0xb3, 0x0f, 0x15, 0xf7, 0xfc, 0xf5, 0xe2, 0xe7,
0x01, 0x21, 0xf8, 0xdb, 0xc6, 0x12, 0xfa, 0xd2, 0xe4, 0x4e, 0xe9, 0x29,
0x0d, 0xe1, 0xde, 0xf3, 0xee, 0x30, 0xdb, 0x18, 0xf4, 0x43, 0xc9, 0xeb,
0x0a, 0x0e, 0x1b, 0x0f, 0xf8, 0x23, 0xeb, 0x04, 0xef, 0x05, 0xd7, 0xee,
0x1a, 0xc5, 0x18, 0x23, 0x03, 0x04, 0xf4, 0x0e, 0xe0, 0x0f, 0xf0, 0x4f,
0xe5, 0x28, 0x05, 0x05, 0xb7, 0x0f, 0xde, 0x2f, 0x17, 0x1c, 0x15, 0xf2,
0xe6, 0xed, 0x15, 0x1b, 0xe2, 0x13, 0xec, 0x0d, 0xe4, 0x40, 0x02, 0x0a,
0x1c, 0xf4, 0x0d, 0x1c, 0xeb, 0x61, 0xda, 0x10, 0x0d, 0x3a, 0xc8, 0xfb,
0x0f, 0x17, 0x1a, 0x1f, 0x08, 0x1c, 0xe2, 0x11, 0xff, 0x10, 0xda, 0x0b,
0x1f, 0x03, 0x02, 0x27, 0xe1, 0x38, 0xf3, 0xec, 0xfc, 0x21, 0xea, 0x28,
0xe5, 0x24, 0xd5, 0x37, 0xe1, 0x2b, 0xf5, 0xfb, 0xe1, 0x2c, 0xf6, 0x0e,
0xee, 0x08, 0x1f, 0x01, 0xbe, 0x18, 0xdf, 0xf6, 0x1a, 0x21, 0x03, 0x1b,
0x14, 0x08, 0xee, 0x04, 0xe6, 0x5a, 0xd9, 0x1e, 0xe5, 0x46, 0xb6, 0x34,
0x0a, 0xf5, 0xee, 0xf5, 0x03, 0x20, 0xd0, 0xe1, 0x05, 0xff, 0xb9, 0xde,
0x0f, 0xd3, 0x0d, 0x4b, 0xef, 0x1c, 0xe3, 0xe3, 0xf2, 0xf5, 0xde, 0x20,
0xe4, 0x12, 0xe3, 0x1d, 0xb8, 0x13, 0x0c, 0x02, 0x02, 0x1e, 0x03, 0x08,
0xfd, 0xe6, 0x20, 0xfe, 0xc6, 0x0d, 0x17, 0xd7, 0xfd, 0x2a, 0xce, 0x2e,
0x19, 0x0b, 0x0e, 0xfd, 0xfb, 0x1a, 0xde, 0x0c, 0x0b, 0x01, 0xef, 0x23,
0x1b, 0xed, 0x0d, 0x00, 0xee, 0x07, 0xc8, 0x03, 0x16, 0x20, 0xe2, 0x00,
0x24, 0x0b, 0x12, 0x5a, 0xbf, 0xf5, 0x23, 0xe2, 0x1d, 0x03, 0xf4, 0x31,
0xdb, 0x1d, 0xc7, 0x31, 0xc8, 0xea, 0x04, 0xfd, 0x0f, 0x1b, 0xf7, 0x08,
0xff, 0xed, 0x26, 0x1f, 0xd3, 0xf1, 0x30, 0x01, 0x1e, 0x19, 0xf3, 0xf9,
0x22, 0x10, 0xe8, 0x23, 0x20, 0x5c, 0x15, 0x15, 0xf8, 0x29, 0xb7, 0x1f,
0xde, 0x1c, 0x05, 0xf4, 0xf9, 0x0a, 0xe2, 0xee, 0x2d, 0xff, 0xc9, 0xfa,
0xf0, 0xe1, 0x07, 0x3e, 0xe2, 0xf7, 0x03, 0xec, 0xec, 0x1a, 0xdd, 0x5c,
0x1d, 0xfb, 0x09, 0x2a, 0xe4, 0xf8, 0xef, 0x22, 0xee, 0xed, 0xf4, 0xf5,
0xe8, 0x0e, 0xf0, 0xd9, 0x03, 0xfb, 0x1a, 0xde, 0xe2, 0x38, 0x13, 0x22,
0xdf, 0x02, 0x13, 0xef, 0xf2, 0x53, 0x04, 0xf7, 0xe6, 0x23, 0xbf, 0xf1,
0xed, 0x33, 0x03, 0x1d, 0xfa, 0x0b, 0x07, 0xfc, 0x2a, 0xef, 0xe0, 0x0e,
0xfb, 0xd4, 0xe2, 0x12, 0xdd, 0x1d, 0x1d, 0xee, 0xf3, 0xea, 0x03, 0x66,
0x02, 0x1f, 0xfd, 0x06, 0xb1, 0x28, 0xf5, 0x15, 0xe7, 0x1f, 0xd9, 0x10,
0xcb, 0x08, 0xfb, 0x0e, 0xf7, 0xfd, 0x0f, 0x08, 0xe1, 0x24, 0xf9, 0x09,
0xf5, 0xdd, 0x1c, 0x03, 0x0c, 0x4f, 0xdc, 0x0c, 0xfe, 0x09, 0xea, 0x27,
0x10, 0x02, 0xed, 0x1d, 0x14, 0xed, 0xed, 0x0b, 0x00, 0xe7, 0x04, 0x08,
0x01, 0xca, 0xfa, 0x3c, 0x08, 0x1b, 0xea, 0x08, 0xe2, 0x0c, 0xf2, 0x39,
0xec, 0xf2, 0x0a, 0x21, 0xb6, 0xf3, 0x06, 0xf4, 0xe5, 0x2c, 0x06, 0xf4,
0x0d, 0x1d, 0x27, 0xd2, 0xdd, 0xec, 0x08, 0xfc, 0xfa, 0x2e, 0xe6, 0x05,
0x0b, 0x20, 0xe1, 0x07, 0xf7, 0x5d, 0x16, 0x14, 0xfd, 0x12, 0xf7, 0x18,
0x09, 0x1c, 0x19, 0x28, 0x1a, 0xe3, 0x09, 0x19, 0xf2, 0xf9, 0xfa, 0x05,
0x13, 0xda, 0xec, 0x39, 0x1b, 0xf7, 0x0a, 0xdd, 0xff, 0x10, 0x08, 0x47,
0xed, 0x1f, 0x04, 0x23, 0xaa, 0x0f, 0xea, 0xf8, 0xf2, 0xf1, 0xf9, 0x15,
0x03, 0x0e, 0x15, 0x01, 0xf7, 0x1f, 0xfe, 0xce, 0x03, 0x39, 0x1a, 0x18,
0x18, 0xdb, 0x1a, 0xe5, 0x17, 0x55, 0x15, 0x0c, 0x11, 0x10, 0xe3, 0x33,
0xf2, 0x2a, 0xf2, 0x31, 0xde, 0x22, 0x0b, 0xff, 0xfd, 0x0e, 0x00, 0x0a,
0xe6, 0xe0, 0x00, 0x4d, 0x0c, 0x0b, 0x15, 0x00, 0x06, 0xe8, 0x10, 0x35,
0x05, 0xfd, 0xd1, 0x35, 0xd4, 0xfb, 0x02, 0x0a, 0x05, 0xed, 0xe5, 0x13,
0xf2, 0x16, 0x1b, 0x10, 0xea, 0x16, 0x05, 0xff, 0xef, 0x53, 0x15, 0x2c,
0xf0, 0xed, 0xe5, 0xf3, 0xf0, 0x54, 0x0a, 0xee, 0xdd, 0x41, 0xe9, 0xf1,
0xff, 0x23, 0x17, 0x2c, 0x0c, 0x01, 0xdf, 0x09, 0xff, 0x0f, 0xcf, 0xea,
0xf9, 0x08, 0x16, 0x2d, 0xdd, 0xf3, 0xe7, 0x1a, 0xef, 0x0a, 0x11, 0x25,
0x09, 0xeb, 0xfc, 0x1f, 0xc1, 0x0f, 0x18, 0xe8, 0xdd, 0x0c, 0x08, 0xfa,
0xce, 0xee, 0x0a, 0xfc, 0x02, 0x17, 0x11, 0xf1, 0x1c, 0x35, 0x17, 0x38,
0xf0, 0xe8, 0xe2, 0xed, 0x1a, 0x10, 0xfa, 0x06, 0x0c, 0x2b, 0xe3, 0x23,
0xf7, 0xf4, 0x1b, 0x1e, 0xe2, 0x1d, 0xdc, 0x17, 0x19, 0x0b, 0xf0, 0xf1,
0xf0, 0xe5, 0x14, 0x38, 0xe5, 0x33, 0xdf, 0xfa, 0xea, 0x20, 0xfa, 0x1b,
0xe5, 0xf1, 0xdc, 0x06, 0xe1, 0x02, 0x18, 0xe4, 0x09, 0x08, 0xe6, 0x02,
0xf5, 0x1a, 0x34, 0xf9, 0xe7, 0x14, 0xe1, 0xfb, 0x22, 0x58, 0xcf, 0x07,
0x07, 0xea, 0x24, 0xf5, 0xfc, 0x47, 0xe4, 0x0c, 0xf3, 0x1b, 0xd4, 0xf8,
0xdc, 0xea, 0x01, 0x13, 0xe3, 0x06, 0xee, 0xdf, 0xf5, 0x25, 0xf7, 0xe9,
0x10, 0xcc, 0xe2, 0x4d, 0xd3, 0x28, 0xff, 0x0f, 0xea, 0xdf, 0xe2, 0x01,
0xd9, 0x20, 0xc9, 0xff, 0xc0, 0xf6, 0x1e, 0x16, 0x24, 0x26, 0xf6, 0x1f,
0xf9, 0x03, 0x2f, 0x05, 0xc0, 0xe6, 0x01, 0xd0, 0x00, 0x17, 0x02, 0x32,
0x1b, 0xf1, 0x04, 0x12, 0xfd, 0x1f, 0x17, 0xe7, 0xec, 0xfc, 0xad, 0xe4,
0xde, 0x14, 0xe4, 0x22, 0x15, 0x1a, 0xc9, 0x15, 0x25, 0x1a, 0xd3, 0x23,
0xf2, 0x01, 0x1a, 0x45, 0xff, 0x21, 0xf0, 0x12, 0x19, 0x00, 0x04, 0x2f,
0x19, 0x27, 0xeb, 0x3a, 0xdc, 0xea, 0xe2, 0xe3, 0xf0, 0x0d, 0xdf, 0xea,
0xd1, 0xe5, 0x16, 0x04, 0xe5, 0xec, 0xe8, 0xd6, 0x1c, 0x4b, 0xda, 0xee,
0xf4, 0xea, 0x1b, 0x02, 0x12, 0x5a, 0x08, 0x0b, 0xd2, 0x17, 0xe5, 0xfc,
0x07, 0x24, 0xf4, 0x0b, 0xe8, 0x1a, 0xed, 0x08, 0x00, 0xe5, 0xdd, 0x0d,
0x05, 0xc9, 0x1b, 0x0a, 0xf2, 0x16, 0x1b, 0xe7, 0xea, 0x09, 0x06, 0x64,
0x1a, 0x09, 0x01, 0x1a, 0xaf, 0xf7, 0x01, 0xf5, 0xeb, 0x22, 0x13, 0xe7,
0xf4, 0x16, 0xf9, 0x03, 0xc5, 0xfe, 0xd5, 0xee, 0xed, 0x16, 0xd6, 0xf2,
0x0a, 0xde, 0x0b, 0xf7, 0x0f, 0x49, 0xf2, 0x0c, 0xd0, 0x17, 0xb9, 0xf9,
0x1e, 0x06, 0x01, 0xee, 0xe9, 0xde, 0xe1, 0x1b, 0x2b, 0xe0, 0xff, 0xee,
0xf6, 0xff, 0x06, 0x3f, 0xe3, 0x16, 0x0b, 0xe6, 0x1c, 0xff, 0xf8, 0x5b,
0x15, 0xe9, 0xed, 0x29, 0xed, 0xec, 0xf3, 0x22, 0x18, 0x2d, 0xe0, 0x02,
0xef, 0x0e, 0x21, 0xff, 0xe7, 0xf4, 0xd3, 0x01, 0x29, 0x17, 0xda, 0xf4,
0xf9, 0xfd, 0xf4, 0x23, 0xe4, 0x3d, 0x06, 0x07, 0xef, 0x0b, 0xc9, 0xf4,
0x03, 0x11, 0xe8, 0x30, 0xf5, 0xeb, 0x09, 0x1f, 0x00, 0xe5, 0xe0, 0x0c,
0x01, 0xee, 0x14, 0x38, 0xfd, 0x18, 0xf2, 0x1e, 0xf6, 0x07, 0x11, 0x46,
0xdb, 0x00, 0xd3, 0x1d, 0xf0, 0xf2, 0x17, 0xf8, 0xea, 0xec, 0xf7, 0xf2,
0xf4, 0xfa, 0xf1, 0x12, 0xf6, 0xfe, 0x12, 0xe5, 0x1e, 0x5b, 0xeb, 0x38,
0xdd, 0x03, 0xf6, 0x08, 0xf2, 0x42, 0xdb, 0x07, 0xd0, 0x04, 0xef, 0xfe,
0x05, 0x1b, 0x10, 0xf5, 0x0d, 0xef, 0xef, 0xdf, 0x0d, 0xef, 0xe9, 0x00,
0x1a, 0xdf, 0x19, 0x1f, 0xe7, 0x10, 0xf5, 0xfe, 0xdf, 0x14, 0x22, 0x2e,
0x1d, 0x1b, 0xce, 0x14, 0xcf, 0x2f, 0xef, 0xed, 0xdc, 0x27, 0x19, 0xff,
0xd1, 0x09, 0x28, 0xf4, 0x06, 0xeb, 0xdb, 0xf3, 0xe5, 0x40, 0xf9, 0x10,
0x07, 0xda, 0xf3, 0xf3, 0xf6, 0x2b, 0xfa, 0x20, 0xd3, 0x22, 0xe1, 0x1a,
0xf8, 0xed, 0xf2, 0xee, 0xe0, 0x0e, 0x08, 0xfa, 0xf5, 0xff, 0xfa, 0x0c,
0xda, 0xf1, 0xf2, 0x2b, 0xd6, 0x17, 0xf8, 0x0c, 0xe4, 0x21, 0x07, 0x64,
0xe6, 0x02, 0xe4, 0x35, 0xe8, 0x06, 0xf0, 0xe8, 0xfb, 0x14, 0x16, 0x07,
0xcd, 0x0b, 0x06, 0xe0, 0xf7, 0xdd, 0x10, 0xe6, 0x0c, 0x4d, 0xe6, 0x21,
0xf4, 0x0a, 0xdc, 0xf5, 0xe6, 0x66, 0x07, 0x14, 0x00, 0x20, 0xe7, 0x2a,
0x1b, 0x27, 0xe9, 0x08, 0xe8, 0x12, 0x03, 0x0b, 0xf3, 0x25, 0xe5, 0xfd,
0xfc, 0x06, 0x09, 0x3e, 0xed, 0x18, 0xde, 0xfa, 0x22, 0x0b, 0xf0, 0x06,
0x07, 0x25, 0xeb, 0x29, 0xbe, 0xe9, 0xf8, 0x2a, 0x0d, 0xef, 0x13, 0xe5,
0x04, 0x19, 0xfc, 0xfe, 0xca, 0xe6, 0xe8, 0x09, 0x02, 0x1c, 0x1b, 0x14,
0x15, 0x15, 0xf1, 0x0c, 0x0e, 0x2f, 0x05, 0xfc, 0xc9, 0x0c, 0xb7, 0x21,
0x13, 0xed, 0xe0, 0x2e, 0xf8, 0x01, 0xe6, 0xd4, 0x33, 0x19, 0xd7, 0x21,
0xe2, 0xe6, 0xee, 0x50, 0xd4, 0x0d, 0x12, 0xf5, 0xde, 0x16, 0x17, 0x33,
0x16, 0xf2, 0xfc, 0x3e, 0xe5, 0x15, 0x06, 0x24, 0x16, 0x22, 0x09, 0xfe,
0xe9, 0x09, 0x06, 0x15, 0xe5, 0x0b, 0xee, 0xdf, 0xf2, 0x31, 0xcc, 0x0c,
0x01, 0xf7, 0x0a, 0x02, 0x0f, 0x19, 0x00, 0xf3, 0xdb, 0x2f, 0xda, 0x1a,
0x1d, 0xf7, 0xfd, 0xed, 0x12, 0xef, 0xd7, 0x20, 0x23, 0x1e, 0x02, 0x22,
0x16, 0xe5, 0xf2, 0x52, 0xdc, 0xf5, 0xec, 0x16, 0x21, 0x06, 0x16, 0x3c,
0xe5, 0x05, 0xc8, 0x1c, 0xc6, 0x0a, 0xfc, 0xdc, 0x16, 0x15, 0xe5, 0x12,
0xe3, 0x21, 0xf4, 0x01, 0xde, 0x19, 0x16, 0x0b, 0x1c, 0x1f, 0xbe, 0xee,
0xe7, 0xec, 0x04, 0xf1, 0xef, 0x3e, 0xf5, 0x26, 0xf6, 0x0b, 0xdd, 0xf5,
0xec, 0xeb, 0xf5, 0x10, 0xde, 0xfb, 0xd2, 0x1f, 0x25, 0x2a, 0xd4, 0x17,
0xf8, 0xcd, 0xfa, 0x2f, 0xeb, 0xfb, 0x0c, 0xea, 0xed, 0xf3, 0x1b, 0x1e,
0x12, 0x01, 0xec, 0x37, 0xd7, 0xfd, 0xf4, 0xc7, 0xde, 0xfc, 0xfa, 0x04,
0xf3, 0x0d, 0x03, 0xf8, 0xba, 0xf8, 0xe1, 0xf6, 0xf7, 0x35, 0xbe, 0x33,
0xde, 0xf0, 0x1f, 0x00, 0xf3, 0x40, 0x12, 0xeb, 0xfd, 0x0e, 0xc1, 0x25,
0xff, 0x2b, 0xf6, 0x02, 0x1a, 0x0a, 0xf8, 0x18, 0x1f, 0xe9, 0xda, 0xde,
0x01, 0xf2, 0xe0, 0x3f, 0xf6, 0x11, 0x13, 0xfd, 0xdf, 0xec, 0x19, 0x50,
0x1a, 0x27, 0xc2, 0x40, 0xbf, 0xe3, 0xe0, 0x2b, 0xf1, 0x25, 0xf7, 0x14,
0xea, 0xfd, 0xf8, 0xdb, 0xf3, 0xec, 0x04, 0xd3, 0x10, 0x19, 0x05, 0x1c,
0x0d, 0xec, 0xf6, 0xe0, 0xe0, 0x35, 0x01, 0x27, 0x0c, 0x0c, 0xca, 0x16,
0xf9, 0x21, 0xfd, 0x13, 0xdb, 0x19, 0xee, 0x11, 0xfb, 0xf2, 0xfb, 0x19,
0x03, 0xfe, 0x17, 0x16, 0xf5, 0x26, 0xf5, 0xfe, 0xdf, 0xf0, 0x00, 0x1f,
0x11, 0x04, 0xfe, 0x37, 0xd5, 0xed, 0xe0, 0x1b, 0x20, 0x0c, 0xf4, 0x01,
0xf0, 0x04, 0x15, 0xe7, 0xf4, 0xe6, 0xe4, 0x08, 0x12, 0x1c, 0xf2, 0x2a,
0xe1, 0x0a, 0xe0, 0xf5, 0x1e, 0x50, 0xdf, 0x20, 0xeb, 0x0b, 0xb7, 0x0b,
0xfd, 0x24, 0xf2, 0x17, 0xe2, 0x08, 0xd9, 0xe2, 0xf3, 0xcd, 0xdc, 0xe1,
0xd8, 0xc7, 0x09, 0x22, 0x0e, 0x38, 0xf8, 0xfa, 0xec, 0xe5, 0x09, 0x53,
0xeb, 0x16, 0xd4, 0x0d, 0xf5, 0x10, 0x19, 0xf9, 0x16, 0x21, 0xfa, 0x03,
0x03, 0x01, 0xef, 0x0c, 0xcf, 0x05, 0x06, 0xeb, 0xe6, 0x30, 0xe8, 0x24,
0xfe, 0xe2, 0xef, 0x15, 0x1d, 0x50, 0xe3, 0xf2, 0xf0, 0x1c, 0xd8, 0x05,
0xed, 0x0d, 0x18, 0x06, 0x10, 0xe2, 0x02, 0x15, 0xf5, 0x19, 0xe7, 0xe6,
0x11, 0x15, 0xe6, 0x47, 0xe9, 0x29, 0x04, 0xf2, 0x19, 0x09, 0xe7, 0x1f,
0x00, 0xea, 0xd0, 0x31, 0xee, 0x1d, 0xe6, 0xe7, 0xe1, 0x0e, 0x1b, 0x14,
0xf9, 0x16, 0xf3, 0x0d, 0xe1, 0x0e, 0xf6, 0xe4, 0x17, 0x33, 0xe1, 0x03,
0x0f, 0x0b, 0x05, 0x13, 0xee, 0x68, 0xfd, 0x0c, 0xd4, 0x47, 0xb5, 0xfa,
0xf4, 0xee, 0xeb, 0xf3, 0x15, 0x09, 0xe5, 0xd6, 0x12, 0x16, 0xfd, 0x0d,
0xec, 0xcf, 0x15, 0x54, 0x23, 0x10, 0xf2, 0x08, 0xeb, 0x1c, 0xf5, 0x2b,
0xf4, 0xf1, 0x0c, 0x41, 0xc6, 0x2c, 0x11, 0x33, 0xfc, 0x15, 0xfe, 0x21,
0xcc, 0xda, 0x10, 0x22, 0xd3, 0xf9, 0x19, 0xda, 0xed, 0x28, 0xee, 0x28,
0xdc, 0x0f, 0x0b, 0xf1, 0x1f, 0x11, 0xe0, 0xf0, 0xda, 0x1b, 0xaf, 0x0a,
0x11, 0x29, 0xeb, 0x35, 0xf8, 0xe1, 0xcf, 0x1e, 0xf6, 0x23, 0xf1, 0xf8,
0x05, 0xf6, 0x0c, 0x1b, 0xf0, 0xfd, 0x22, 0xfd, 0xe6, 0x17, 0x0c, 0x13,
0xe1, 0x29, 0xdd, 0x34, 0xdb, 0x1d, 0x0d, 0x2c, 0x20, 0xf7, 0xde, 0x08,
0x0d, 0x19, 0x21, 0x0f, 0x01, 0x18, 0xde, 0xc9, 0x1f, 0x32, 0xc2, 0xf4,
0x12, 0x14, 0x16, 0xfc, 0xea, 0x02, 0xf1, 0x09, 0xcd, 0x2d, 0xac, 0x15,
0xf2, 0x2c, 0x0d, 0xfb, 0xde, 0xe2, 0xe4, 0xde, 0x0d, 0xfa, 0xcc, 0x10,
0x12, 0xf3, 0xe5, 0x21, 0x13, 0x16, 0x03, 0x17, 0xfb, 0x0f, 0x09, 0x47,
0xf3, 0xeb, 0xc0, 0x38, 0xb6, 0x12, 0xeb, 0xfa, 0x0e, 0x34, 0xe8, 0xf1,
0xcf, 0x0b, 0xfa, 0x14, 0xcc, 0xf3, 0xec, 0xce, 0x06, 0x26, 0xd4, 0x02,
0x01, 0x09, 0x05, 0xf6, 0xfe, 0x12, 0xf7, 0xf6, 0xcd, 0x2d, 0xc3, 0x07,
0x05, 0xfe, 0xe0, 0x22, 0x03, 0x07, 0xda, 0xe5, 0xf6, 0x2c, 0xe6, 0xf2,
0x28, 0xff, 0x0c, 0x27, 0xf6, 0xef, 0xf4, 0x1d, 0x10, 0x02, 0xfc, 0x53,
0x17, 0x1f, 0xec, 0x29, 0xdf, 0xf6, 0xf0, 0x13, 0x20, 0x22, 0xfc, 0xe5,
0x09, 0x02, 0xf0, 0x12, 0xf8, 0x15, 0xe0, 0xd4, 0xfe, 0x20, 0xef, 0x1b,
0xe6, 0xee, 0x0f, 0x21, 0x06, 0x24, 0xe8, 0xef, 0xe0, 0x27, 0xf5, 0xf7,
0x1d, 0xc5, 0xde, 0x2d, 0xf0, 0x1c, 0xcd, 0xe7, 0x24, 0x03, 0xe2, 0x1e,
0x18, 0xe0, 0x14, 0x09, 0xd9, 0x18, 0x1b, 0x06, 0xe8, 0xed, 0x19, 0x54,
0x06, 0xea, 0x04, 0x11, 0xdf, 0x30, 0xfa, 0x03, 0xf8, 0x22, 0xf5, 0x1d,
0xdf, 0xfe, 0xff, 0xfa, 0xfb, 0x0c, 0x01, 0xe6, 0x0f, 0x38, 0xfe, 0xf5,
0xe0, 0xdf, 0xf6, 0x03, 0x0b, 0x56, 0x14, 0x14, 0xed, 0x22, 0xf4, 0x27,
0x04, 0x14, 0xe1, 0x28, 0x16, 0x0f, 0xd6, 0xe5, 0x01, 0xe9, 0xf3, 0x12,
0xd6, 0x06, 0x14, 0x3e, 0xef, 0x16, 0x1e, 0xe5, 0xf7, 0x22, 0xec, 0x43,
0x0a, 0xe7, 0xe0, 0x18, 0xd9, 0x07, 0x04, 0x15, 0x23, 0x0f, 0x1d, 0x04,
0xdc, 0x02, 0x1a, 0xdf, 0xf5, 0xfb, 0xd1, 0x0b, 0x13, 0x24, 0xf1, 0xfb,
0xe9, 0x00, 0x10, 0xfd, 0x12, 0x52, 0xef, 0x13, 0xeb, 0xff, 0xe8, 0x2b,
0xe7, 0x0a, 0xf4, 0xeb, 0xf0, 0xf0, 0xca, 0xec, 0x14, 0x0a, 0xd4, 0xee,
0x07, 0xd4, 0x27, 0x26, 0xf8, 0x16, 0x12, 0xe5, 0x03, 0xfa, 0x16, 0x4c,
0x1d, 0x24, 0xf9, 0x41, 0xc5, 0xf8, 0xf3, 0x1a, 0x0e, 0xfa, 0xfb, 0x1e,
0xdf, 0x06, 0x1c, 0xf1, 0xc3, 0x05, 0x16, 0xe9, 0x05, 0x3a, 0x0c, 0xfe,
0xff, 0x12, 0x1d, 0xf8, 0x06, 0x50, 0xef, 0x02, 0xf2, 0x2d, 0xb2, 0x24,
0xf2, 0x18, 0xdf, 0x25, 0x02, 0x14, 0x0a, 0x12, 0x00, 0xf5, 0xca, 0xf6,
0x14, 0xe1, 0xef, 0x3a, 0x1f, 0x36, 0x1a, 0x04, 0x02, 0x1a, 0x10, 0x57,
0x02, 0x20, 0xd8, 0x16, 0xb0, 0x19, 0x0b, 0x1f, 0xed, 0x2d, 0xf1, 0xe6,
0xca, 0xd6, 0xef, 0xe9, 0xf2, 0xfd, 0x0b, 0xf0, 0x10, 0x3b, 0x12, 0x39,
0xfd, 0xf8, 0xe6, 0xe1, 0x08, 0x1c, 0x13, 0x05, 0xf3, 0x37, 0xcf, 0x29,
0x1d, 0x02, 0x1f, 0x20, 0xe8, 0xed, 0x09, 0xfe, 0x05, 0x0f, 0xf5, 0xe6,
0xf6, 0xe8, 0x04, 0x3c, 0x11, 0xf9, 0xde, 0xdc, 0xeb, 0xdf, 0xe9, 0x34,
0x17, 0x07, 0xeb, 0x3e, 0xc8, 0x04, 0x17, 0x0b, 0x1e, 0x14, 0xdd, 0x0f,
0xcc, 0xe8, 0xf6, 0x17, 0xc7, 0x0e, 0xd7, 0xe3, 0x10, 0x16, 0xec, 0x01,
0xed, 0xff, 0xf9, 0x15, 0xe3, 0x38, 0x0d, 0x04, 0xd9, 0x38, 0xb5, 0xef,
0x05, 0x02, 0x1c, 0xf7, 0x1d, 0xe9, 0xe8, 0xdb, 0x18, 0x10, 0xd2, 0xf4,
0x0d, 0xca, 0xe8, 0x52, 0xfc, 0x15, 0xdd, 0xdb, 0x17, 0x1c, 0xe3, 0x37,
0xf0, 0x24, 0xeb, 0x1e, 0xdb, 0x0e, 0xde, 0xfc, 0x18, 0x10, 0xe7, 0x16,
0xef, 0x18, 0xfd, 0x2e, 0xdc, 0x0c, 0x17, 0x01, 0x06, 0x1d, 0xce, 0x01,
0xe6, 0x12, 0xe3, 0x1c, 0x00, 0x0c, 0xe7, 0xf6, 0xcb, 0x10, 0xb3, 0x0c,
0x22, 0x36, 0x22, 0x24, 0xf8, 0xff, 0xff, 0x10, 0x0b, 0x23, 0xf4, 0x11,
0x12, 0x08, 0x04, 0x41, 0xce, 0x10, 0xea, 0xfa, 0xf8, 0xed, 0xfe, 0xf7,
0xdd, 0x1c, 0xc0, 0x14, 0xb9, 0x1a, 0x03, 0x38, 0x1f, 0xfc, 0xe1, 0x0c,
0xde, 0xf2, 0x1a, 0x05, 0xef, 0xfb, 0x21, 0xfd, 0x20, 0x1d, 0xe2, 0xf4,
0xf4, 0xe5, 0xe3, 0xea, 0x03, 0x13, 0xf4, 0xf2, 0xe0, 0x1d, 0xd7, 0x15,
0x20, 0xfa, 0xfc, 0x10, 0xf6, 0xeb, 0xe6, 0xf6, 0x28, 0x1e, 0xce, 0x0b,
0x2c, 0xc9, 0xe1, 0x4e, 0x03, 0xf5, 0xf5, 0xf0, 0x17, 0x05, 0x1f, 0x4a,
0xee, 0x18, 0xed, 0x10, 0xe3, 0x22, 0xfc, 0xfd, 0xeb, 0x27, 0xfd, 0x03,
0x07, 0x07, 0x1e, 0x35, 0xe5, 0x1b, 0x2e, 0xef, 0xee, 0x28, 0xe4, 0x2e,
0x1e, 0x1f, 0x05, 0x0a, 0x0c, 0x2d, 0xeb, 0x2d, 0xc5, 0x22, 0xca, 0x24,
0x10, 0x22, 0xfa, 0x09, 0xe3, 0x0a, 0xdb, 0x03, 0x1f, 0x25, 0xfe, 0xe3,
0x0f, 0xfa, 0x1b, 0x50, 0xc1, 0xf9, 0xef, 0x20, 0xf1, 0x0d, 0x01, 0x1c,
0xed, 0xfc, 0x08, 0x1e, 0xd4, 0x38, 0x20, 0xcf, 0x1f, 0xfe, 0x12, 0x01,
0xd5, 0xe6, 0x30, 0x03, 0xdf, 0x14, 0xf9, 0xed, 0xe5, 0x22, 0xde, 0x05,
0x16, 0xdc, 0x19, 0xfe, 0x11, 0x29, 0x1b, 0xef, 0xf9, 0x2e, 0xf8, 0x20,
0xf1, 0xe8, 0xec, 0x2d, 0x19, 0x00, 0xdc, 0x27, 0x06, 0xf4, 0xe8, 0x01,
0xf8, 0xe3, 0x19, 0x17, 0x17, 0x25, 0xe1, 0xf2, 0x00, 0x06, 0xe3, 0x32,
0xfb, 0xf2, 0xde, 0x3a, 0xdc, 0xfa, 0x1c, 0xed, 0x13, 0xf0, 0xd9, 0xdd,
0xe1, 0xed, 0x02, 0xe8, 0xf2, 0xdd, 0xd6, 0x0f, 0xfb, 0x39, 0xf1, 0x1a,
0x25, 0xe2, 0x08, 0xe7, 0xfa, 0x22, 0x1d, 0x14, 0x00, 0x05, 0xb6, 0xf9,
0x0f, 0x1a, 0xe1, 0xf8, 0x1d, 0xec, 0xdb, 0xf1, 0xfa, 0x01, 0xf7, 0xdd,
0xf7, 0xdc, 0x02, 0x12, 0xe1, 0x2f, 0x07, 0x0c, 0x1a, 0x19, 0x0e, 0x2a,
0xff, 0x08, 0xc9, 0x2e, 0xe0, 0xe6, 0xea, 0xf2, 0x1d, 0xf2, 0x1e, 0x0b,
0x04, 0xdf, 0x15, 0xf5, 0xc7, 0xe8, 0xca, 0xf0, 0x08, 0x18, 0xf0, 0x13,
0xe1, 0xed, 0x1b, 0x19, 0xeb, 0x31, 0xdf, 0xf5, 0xce, 0x1b, 0xd6, 0x1f,
0xe1, 0x13, 0xe4, 0x1a, 0xdc, 0x13, 0xe1, 0xd4, 0x09, 0x0d, 0xeb, 0x18,
0xfd, 0xc8, 0xe8, 0x46, 0x03, 0x39, 0xe8, 0x19, 0x0a, 0xf4, 0xed, 0x1a,
0xfe, 0x0a, 0xf1, 0x0f, 0xbe, 0x25, 0x1b, 0x23, 0xdd, 0x1a, 0xdc, 0x11,
0xd3, 0x06, 0x11, 0xff, 0x06, 0x11, 0xd7, 0xea, 0xef, 0x48, 0xed, 0xf2,
0x0d, 0xf2, 0x1a, 0x13, 0x19, 0x13, 0x1e, 0x08, 0xd0, 0x15, 0xbd, 0x1d,
0x1f, 0x05, 0x01, 0xef, 0xf9, 0x22, 0xd9, 0xe5, 0x31, 0xf1, 0xf3, 0x1f,
0xe1, 0x07, 0x06, 0x24, 0x15, 0x1e, 0xfe, 0x0f, 0xe4, 0x13, 0x1a, 0x0b,
0xe8, 0x28, 0xd1, 0x03, 0xcf, 0xfa, 0xf4, 0x1d, 0xdd, 0xff, 0x01, 0x12,
0xcb, 0xea, 0x04, 0x00, 0xf1, 0x19, 0xe8, 0x12, 0x15, 0x1e, 0xdd, 0xf1,
0xeb, 0xe6, 0xfc, 0x12, 0x09, 0x1d, 0xf1, 0x15, 0xd4, 0x3a, 0xab, 0xf8,
0x13, 0x01, 0xee, 0x17, 0xdc, 0xea, 0xd7, 0x1c, 0x25, 0x20, 0xda, 0x04,
0xe1, 0xf4, 0xf2, 0x40, 0xd0, 0x26, 0x1a, 0xe0, 0xdd, 0xf6, 0xf4, 0x10,
0x07, 0x20, 0xe9, 0x02, 0xcf, 0xf5, 0x24, 0x06, 0x05, 0x29, 0xed, 0x03,
0xe0, 0x11, 0x1a, 0xe7, 0xe5, 0x01, 0xe5, 0xdc, 0xe0, 0x1c, 0xc8, 0xee,
0x0d, 0xdc, 0x04, 0xfe, 0xf9, 0x4c, 0xdf, 0x10, 0x06, 0x31, 0xc6, 0x17,
0x10, 0xfd, 0xf0, 0xff, 0xfb, 0x01, 0xcf, 0x0f, 0x00, 0x17, 0xee, 0xe5,
0xfe, 0x08, 0xdf, 0x39, 0x0b, 0x2c, 0x0c, 0xe5, 0xf2, 0xe4, 0xfc, 0x45,
0xfb, 0x0f, 0xca, 0x0f, 0xa3, 0x00, 0x11, 0x08, 0x22, 0x04, 0xe5, 0x09,
0xee, 0xe8, 0x19, 0x2a, 0xf4, 0x09, 0x0e, 0xc8, 0x0e, 0x55, 0xef, 0x1f,
0xef, 0x10, 0x07, 0xfd, 0x19, 0xf5, 0xfc, 0x13, 0xfc, 0x34, 0xa6, 0xf2,
0xff, 0x2c, 0x04, 0x03, 0xe9, 0x0c, 0xf4, 0xec, 0x2d, 0xfc, 0xd8, 0xff,
0xee, 0xce, 0xe4, 0x42, 0x13, 0x01, 0xf1, 0x15, 0xe6, 0xff, 0xe0, 0x22,
0xe8, 0xfb, 0xe3, 0x12, 0xe5, 0xf2, 0x03, 0x2f, 0x05, 0x2d, 0xe6, 0xeb,
0xf1, 0xff, 0x0c, 0x25, 0xd7, 0xfe, 0x22, 0xd7, 0xf9, 0x18, 0xdd, 0x2f,
0xfb, 0x0b, 0xf4, 0x23, 0xf1, 0x32, 0x01, 0x02, 0xee, 0x14, 0xd4, 0xf2,
0xe8, 0x14, 0xf0, 0x0b, 0xdb, 0xf9, 0xeb, 0xf2, 0x1c, 0x2d, 0xc4, 0x0d,
0x28, 0xef, 0xf0, 0x48, 0xe5, 0xfc, 0xeb, 0x20, 0x04, 0xdf, 0xf4, 0xf8,
0x07, 0x24, 0xc7, 0x2e, 0xef, 0xf9, 0x19, 0x11, 0xec, 0x06, 0x02, 0x0c,
0x02, 0xe4, 0x1b, 0xfb, 0xc8, 0x09, 0x15, 0x0b, 0x0d, 0x37, 0xb6, 0x28,
0xeb, 0x0f, 0xf4, 0xf8, 0x0a, 0x1d, 0xef, 0x0e, 0x0a, 0x2f, 0xf6, 0x33,
0xe8, 0x04, 0xdf, 0x06, 0xf4, 0xe6, 0x05, 0xe2, 0xfa, 0xf0, 0xc5, 0x0e,
0xf3, 0xec, 0xf7, 0x15, 0xfe, 0x0b, 0xeb, 0xf9, 0xfa, 0xf3, 0xf5, 0x24,
0xdf, 0x02, 0xe8, 0x0d, 0xc9, 0x1e, 0x0e, 0xf3, 0x13, 0xfe, 0x16, 0xde,
0xea, 0x1c, 0xf9, 0xce, 0xe3, 0xeb, 0xec, 0xd7, 0x20, 0x16, 0xff, 0x25,
0xf4, 0xed, 0xde, 0x09, 0xdc, 0x3f, 0xe0, 0xf3, 0xdf, 0x38, 0xd3, 0xf9,
0x0b, 0xf8, 0x10, 0x26, 0xdc, 0x16, 0xe6, 0xfe, 0x2f, 0xe0, 0xe8, 0xfc,
0x10, 0xcb, 0x03, 0x3e, 0x09, 0x1f, 0x07, 0xf9, 0xe1, 0x0d, 0x21, 0x33,
0xe8, 0xec, 0xc5, 0x3d, 0xcf, 0xfd, 0xe9, 0xff, 0x15, 0x28, 0xf7, 0x10,
0xd8, 0x1c, 0x27, 0xcd, 0x04, 0xf1, 0xe0, 0xdb, 0xf4, 0x51, 0xfa, 0x20,
0x18, 0xf3, 0xee, 0xe5, 0x20, 0x20, 0xe5, 0x06, 0xd5, 0x11, 0xcb, 0xfc,
0xfc, 0x27, 0x0b, 0x0f, 0x1f, 0xf2, 0xc8, 0xfc, 0x1d, 0x10, 0xc2, 0x0c,
0xc0, 0xf8, 0xf2, 0x4f, 0xd9, 0x15, 0xe4, 0x1d, 0x06, 0xde, 0xe6, 0x5d,
0xf0, 0x04, 0xbe, 0x34, 0xb2, 0xdd, 0xf0, 0x00, 0xfd, 0x04, 0x1c, 0xdd,
0xee, 0xe1, 0x05, 0xe2, 0xc4, 0xff, 0xd9, 0xcd, 0x02, 0x10, 0x0a, 0x22,
0xf0, 0xdc, 0x00, 0xf4, 0x03, 0x10, 0xfe, 0xfa, 0xc7, 0x35, 0xc2, 0x0c,
0x03, 0x1f, 0x1e, 0x15, 0xfd, 0xe1, 0xcf, 0x0b, 0xf4, 0x08, 0xf3, 0xee,
0xfe, 0xc9, 0xeb, 0x52, 0xf4, 0xfa, 0x1b, 0x10, 0x22, 0x0f, 0x01, 0x08,
0x00, 0x27, 0xf0, 0x1f, 0xac, 0x09, 0xf9, 0x17, 0xdc, 0xf3, 0x06, 0xde,
0xd8, 0xdd, 0x27, 0xdf, 0x04, 0xf5, 0xf6, 0xdf, 0xf1, 0x39, 0x0e, 0xf3,
0x19, 0xea, 0xea, 0xeb, 0xeb, 0x28, 0xf8, 0x08, 0xca, 0x0f, 0xf2, 0x05,
0x1d, 0x2b, 0xf6, 0x14, 0x18, 0xdc, 0xec, 0x01, 0x14, 0xfe, 0xff, 0xe8,
0x02, 0xfd, 0xf4, 0x57, 0xc0, 0xf4, 0x21, 0xf9, 0xe8, 0x13, 0x17, 0x25,
0x17, 0xfb, 0xce, 0x00, 0xc3, 0x09, 0x02, 0x2a, 0xf6, 0x1b, 0x08, 0xec,
0xcb, 0x08, 0x11, 0xf9, 0xe2, 0xe6, 0xd6, 0xed, 0xfd, 0x43, 0xd4, 0x05,
0x0a, 0x17, 0x21, 0x17, 0xff, 0x07, 0xdb, 0x14, 0x0a, 0x34, 0xc7, 0x0e,
0x10, 0x28, 0x16, 0x22, 0xed, 0x11, 0xd7, 0xf3, 0x1b, 0x0b, 0xce, 0x04,
0x09, 0xe1, 0xf9, 0x31, 0x13, 0x18, 0x0e, 0xd9, 0xeb, 0x0a, 0xe4, 0x2c,
0xef, 0xec, 0xe7, 0x3a, 0xe0, 0x0b, 0x11, 0xe8, 0x0b, 0x28, 0xe6, 0x08,
0xf0, 0xd7, 0xf9, 0xef, 0xf7, 0xef, 0xf5, 0xdd, 0xfc, 0x56, 0x02, 0x0e,
0x19, 0xf5, 0x0c, 0xff, 0x12, 0x1c, 0x16, 0xe9, 0xd5, 0x07, 0xd7, 0x13,
0x0b, 0x21, 0x18, 0x25, 0x02, 0xe6, 0xe2, 0x01, 0x14, 0x1b, 0x00, 0x0b,
0x11, 0x0c, 0x11, 0x15, 0x13, 0xee, 0xe4, 0x17, 0x21, 0xfb, 0xf7, 0x2e,
0xde, 0xe8, 0x01, 0x0f, 0xba, 0xfe, 0x14, 0x32, 0xf5, 0x0b, 0x09, 0x20,
0xc7, 0x15, 0x22, 0x14, 0xf3, 0x22, 0xe1, 0x02, 0x1b, 0x31, 0x05, 0x0f,
0xe1, 0xf7, 0x1d, 0x0b, 0xf7, 0xfd, 0xf1, 0xf2, 0xcf, 0xfd, 0xd0, 0x15,
0x06, 0x16, 0xf0, 0x21, 0xe7, 0x01, 0xec, 0x01, 0xfd, 0x33, 0xfe, 0x15,
0xe2, 0xf2, 0xef, 0x1f, 0xdb, 0x13, 0x15, 0xe8, 0xdd, 0x1b, 0xfb, 0x2b,
0xdf, 0x03, 0xf1, 0x25, 0xe0, 0x2c, 0x1f, 0x2d, 0x0c, 0xf0, 0x1c, 0x08,
0xff, 0x1b, 0x1f, 0x0a, 0xc1, 0xe3, 0x19, 0xde, 0xec, 0x50, 0xbe, 0x2c,
0xe2, 0x00, 0x1b, 0xfc, 0x0e, 0x17, 0xe1, 0xea, 0xea, 0x1f, 0xce, 0x24,
0xf3, 0x20, 0x0f, 0xf5, 0xf4, 0x07, 0xf5, 0x0a, 0x1f, 0xfe, 0xd8, 0x17,
0x01, 0xc6, 0xee, 0x1e, 0xbd, 0x29, 0x04, 0x04, 0x12, 0x0a, 0xea, 0x17,
0xeb, 0x0c, 0xca, 0x26, 0xd2, 0x29, 0x14, 0x05, 0xee, 0x24, 0xf8, 0xf0,
0xf3, 0x14, 0xf0, 0xdd, 0x02, 0xf0, 0xdb, 0xf5, 0xfe, 0x19, 0xf7, 0xf4,
0xe4, 0xf1, 0x1a, 0x07, 0x1c, 0x49, 0xe5, 0xf6, 0xcb, 0x0a, 0xee, 0x18,
0xe9, 0xf7, 0x10, 0xeb, 0xf9, 0x1d, 0x07, 0xf3, 0x1e, 0xea, 0xe2, 0x19,
0xfb, 0xc9, 0x05, 0x41, 0x0a, 0x26, 0x1e, 0x0e, 0x18, 0x21, 0xdc, 0x0d,
0x0e, 0x22, 0xeb, 0x2b, 0xc9, 0xee, 0xf7, 0x1d, 0xe9, 0x0b, 0xdb, 0x0a,
0xdc, 0xed, 0x03, 0xdb, 0xf9, 0x1b, 0xf6, 0xff, 0xfe, 0x42, 0xfd, 0x27,
0xf2, 0xe6, 0xe9, 0x05, 0x17, 0x35, 0xfa, 0x00, 0x06, 0x03, 0xbe, 0x01,
0x02, 0xf5, 0x22, 0x22, 0xdd, 0x15, 0xdc, 0x06, 0x13, 0xe9, 0xc1, 0x11,
0xe1, 0xdd, 0xe4, 0x13, 0x08, 0x12, 0xfa, 0x0e, 0x19, 0x20, 0x1a, 0x28,
0x0e, 0xed, 0x04, 0x23, 0xd2, 0xde, 0xfc, 0x25, 0x0c, 0x1f, 0x0b, 0xf2,
0xed, 0xd7, 0x2a, 0xdc, 0xc5, 0x0f, 0xd1, 0xf9, 0x0b, 0x47, 0xe4, 0xfa,
0x06, 0x16, 0xea, 0x21, 0x05, 0x2f, 0xf9, 0x23, 0xe6, 0x3e, 0xde, 0xef,
0x08, 0xf6, 0x04, 0xf7, 0x07, 0xf5, 0xdc, 0xe8, 0xef, 0xd5, 0x04, 0xff,
0xe1, 0xf1, 0x1b, 0x1f, 0xd4, 0x24, 0xfa, 0x06, 0xdf, 0x22, 0x08, 0x0c,
0xf5, 0x09, 0xe8, 0x0f, 0xbc, 0xea, 0x09, 0x15, 0xfe, 0xfe, 0xe6, 0xe3,
0xf4, 0x19, 0xf5, 0xed, 0xf6, 0x18, 0x0c, 0xd6, 0xeb, 0x33, 0xd5, 0xff,
0x1e, 0x0f, 0x0b, 0x00, 0x1b, 0x14, 0x1b, 0xec, 0xca, 0x0e, 0xf1, 0x22,
0xf6, 0xf0, 0x0b, 0xf1, 0xe4, 0x1b, 0xe4, 0x11, 0x2a, 0x0d, 0xd4, 0x0a,
0xe2, 0xd6, 0x28, 0x18, 0xc8, 0x0b, 0x17, 0x00, 0xdd, 0x0b, 0x15, 0x21,
0xe0, 0x16, 0xe8, 0x29, 0xb2, 0x05, 0xe3, 0xef, 0xe6, 0x00, 0xee, 0x1f,
0xfd, 0x1c, 0x2a, 0x0c, 0xf1, 0xfb, 0x19, 0xf3, 0xf3, 0x2a, 0xdd, 0x28,
0xec, 0xdd, 0x05, 0xe0, 0xf5, 0x24, 0x09, 0xed, 0xfa, 0xfc, 0xd6, 0x15,
0xeb, 0x19, 0xe9, 0x2b, 0xe4, 0xf3, 0xc8, 0x15, 0x28, 0xf3, 0xeb, 0xe7,
0x03, 0xdc, 0x03, 0x30, 0xf1, 0x06, 0x1e, 0xfc, 0x17, 0x18, 0x10, 0x3c,
0x10, 0x11, 0xcc, 0x2e, 0xed, 0xf7, 0xe6, 0xe5, 0xf5, 0x33, 0xfa, 0x10,
0x0b, 0xdd, 0x20, 0xf5, 0x01, 0xe0, 0x1e, 0xc7, 0xdf, 0x4a, 0x0f, 0x1f,
0xe3, 0xee, 0x1b, 0xfb, 0x1a, 0x2f, 0xf1, 0x11, 0x0f, 0x2c, 0xe0, 0xfb,
0x03, 0x23, 0xf8, 0x16, 0x02, 0x0d, 0xfd, 0xdd, 0x0f, 0x0f, 0xcf, 0xef,
0xe0, 0xf9, 0x0e, 0x2e, 0x02, 0x1b, 0x14, 0x1d, 0x17, 0xf2, 0xef, 0x02,
0xf2, 0x23, 0x02, 0x25, 0xd7, 0x0f, 0xdf, 0x07, 0xee, 0x31, 0x0b, 0xe9,
0xd2, 0xf0, 0x2a, 0x23, 0xf6, 0x07, 0x0d, 0xd9, 0xed, 0x0f, 0xdb, 0x17,
0xf7, 0xfc, 0xee, 0x02, 0x08, 0x3c, 0xe9, 0x15, 0xff, 0x36, 0xa6, 0x22,
0xe6, 0x23, 0x14, 0x38, 0xf1, 0xf1, 0x05, 0x13, 0x18, 0x27, 0xfc, 0xe3,
0x18, 0xe1, 0xf9, 0x19, 0xce, 0xf5, 0x20, 0xe1, 0x0a, 0xe0, 0x1f, 0xec,
0x0b, 0x08, 0xf0, 0x32, 0xc6, 0x0d, 0x1a, 0x2d, 0xe7, 0xf8, 0x06, 0x1f,
0xcd, 0x1b, 0xf2, 0x01, 0xec, 0x02, 0x02, 0xcf, 0x04, 0x27, 0xfb, 0x28,
0x0f, 0x15, 0x1d, 0x03, 0x05, 0x24, 0xfa, 0x11, 0xdb, 0x03, 0xbd, 0xfe,
0xe8, 0x26, 0xf6, 0x06, 0xfa, 0xe1, 0xdb, 0x04, 0xff, 0x10, 0xb9, 0x05,
0xeb, 0xdc, 0xfb, 0x17, 0xc0, 0x03, 0xde, 0xfd, 0x20, 0xf2, 0xe4, 0x15,
0xe4, 0xf7, 0xc5, 0x09, 0xb7, 0x30, 0x02, 0xc9, 0x05, 0x27, 0xe2, 0x0c,
0xf8, 0xdc, 0x20, 0x06, 0xd1, 0x21, 0xea, 0xc4, 0xe7, 0x1b, 0xe2, 0x06,
0xe0, 0x00, 0x23, 0xe5, 0x0c, 0x3b, 0x1f, 0x13, 0xfc, 0x39, 0xe4, 0x2e,
0xf2, 0x0f, 0x05, 0xfa, 0xfb, 0xed, 0xf1, 0xe2, 0x18, 0xfc, 0xbe, 0x11,
0xd5, 0xe6, 0x0e, 0x27, 0x14, 0xe6, 0xf3, 0xdb, 0xe2, 0xde, 0x17, 0x12,
0x00, 0xee, 0xdf, 0x36, 0xdc, 0x1d, 0x23, 0x09, 0x05, 0xee, 0xe3, 0xe4,
0xe7, 0xe5, 0x26, 0xf0, 0xe9, 0xe9, 0xec, 0xc3, 0xf0, 0x1b, 0x1b, 0x29,
0xe7, 0x11, 0x0b, 0xf8, 0x1c, 0x0e, 0x09, 0xf1, 0xfe, 0x21, 0xba, 0x1e,
0x1b, 0xfc, 0xe8, 0x05, 0xfb, 0xed, 0xcc, 0x0f, 0xf6, 0xf2, 0xc4, 0x04,
0xd0, 0xed, 0x02, 0x44, 0xdb, 0x15, 0xe0, 0x1c, 0xf8, 0x09, 0x01, 0x46,
0xe6, 0x12, 0xf0, 0x03, 0xeb, 0x0c, 0xfe, 0x2d, 0x17, 0x27, 0x1d, 0x12,
0xd4, 0x15, 0x05, 0x18, 0xda, 0xde, 0xcf, 0xf6, 0x21, 0x46, 0xd9, 0x1e,
0xfd, 0xda, 0xf2, 0xe5, 0x11, 0x09, 0x1e, 0x23, 0xf1, 0x36, 0xd5, 0x0d,
0xea, 0x1b, 0x01, 0x25, 0xee, 0xf0, 0xd3, 0xf6, 0x13, 0xda, 0xcd, 0xea,
0x05, 0xd0, 0xff, 0x2c, 0xd4, 0xe6, 0x01, 0x0f, 0xf5, 0xf2, 0x01, 0x24,
0xe4, 0x13, 0xc9, 0x1b, 0xd7, 0xd3, 0xea, 0x00, 0xe3, 0x2a, 0x04, 0x07,
0xc5, 0x0b, 0xf0, 0xdd, 0xbf, 0xe1, 0xe8, 0xce, 0xfc, 0x50, 0xf8, 0x16,
0x1c, 0xec, 0x0a, 0x17, 0x0b, 0xfb, 0xdc, 0x08, 0x0d, 0xfd, 0xcb, 0xe7,
0xea, 0x03, 0x10, 0x2a, 0xea, 0xe6, 0xd3, 0xef, 0x08, 0xdc, 0xf0, 0x05,
0xd8, 0x02, 0x1d, 0x2b, 0xd5, 0x14, 0xf9, 0xf4, 0x12, 0x12, 0xef, 0x3e,
0x1e, 0xe4, 0xea, 0xf8, 0xe5, 0xf6, 0x08, 0xfb, 0x11, 0x0b, 0xe0, 0x07,
0xdb, 0xe9, 0x1a, 0xe2, 0xf1, 0xeb, 0xe6, 0xcb, 0x29, 0x53, 0x09, 0x10,
0xfc, 0xe2, 0x0a, 0x01, 0x20, 0x19, 0xe2, 0x1b, 0xf8, 0x2a, 0xf4, 0x05,
0x09, 0x1f, 0x0a, 0xf9, 0x17, 0xee, 0xe3, 0x21, 0x05, 0x13, 0xd5, 0xf0,
0xf6, 0xe3, 0x0e, 0x38, 0xea, 0x0f, 0x18, 0x15, 0xee, 0x1b, 0xe8, 0x07,
0x16, 0xf6, 0xfd, 0x0c, 0xdd, 0x34, 0x18, 0x0d, 0xee, 0x00, 0xfa, 0x16,
0xed, 0x12, 0x12, 0x04, 0x03, 0xe5, 0xe5, 0x01, 0xe1, 0x3c, 0xe0, 0xe8,
0xe8, 0x09, 0x02, 0x23, 0xfd, 0xfb, 0x05, 0x09, 0xe6, 0x1e, 0xdc, 0x16,
0xfa, 0x14, 0x14, 0x38, 0xee, 0x10, 0x09, 0x04, 0x18, 0x17, 0xf0, 0x19,
0x24, 0xe5, 0x1f, 0x35, 0xe1, 0xf3, 0xdf, 0xee, 0x09, 0x0e, 0xf0, 0x14,
0xef, 0xee, 0xda, 0x16, 0xa7, 0xfc, 0x0b, 0x23, 0xf9, 0x1c, 0x1e, 0xed,
0xee, 0x10, 0x0b, 0x2c, 0xf0, 0x12, 0x01, 0xf3, 0x1f, 0x0d, 0xeb, 0xea,
0xf2, 0xda, 0x12, 0x1e, 0xe9, 0xf5, 0xda, 0xfc, 0xc4, 0xfa, 0xaf, 0x2c,
0x0d, 0x12, 0xe1, 0x23, 0x07, 0x05, 0xdf, 0xe3, 0xfc, 0x2a, 0xcf, 0x1c,
0x1c, 0xe4, 0x03, 0x0e, 0xed, 0x0b, 0x05, 0xf7, 0x0f, 0xf9, 0xf0, 0x2f,
0xde, 0x25, 0xce, 0x30, 0xc3, 0x06, 0xed, 0xf6, 0x09, 0x21, 0xff, 0x1a,
0xca, 0xec, 0x0d, 0x17, 0x02, 0x08, 0xfe, 0xe5, 0x0c, 0x11, 0xdf, 0x20,
0xf9, 0x0d, 0x0a, 0xdd, 0xf1, 0x0c, 0x11, 0xed, 0xfa, 0x28, 0xba, 0xf8,
0x24, 0x00, 0x01, 0x18, 0xe2, 0x20, 0xc3, 0xec, 0x14, 0x24, 0xce, 0xfe,
0xe6, 0xd1, 0x05, 0x16, 0xc3, 0xf1, 0x1b, 0xfa, 0x07, 0xe6, 0xfa, 0xfc,
0x0a, 0xe9, 0xc8, 0xf6, 0xd4, 0xf7, 0x24, 0x13, 0xf4, 0x35, 0x02, 0xe4,
0x07, 0x10, 0x12, 0x01, 0xf3, 0x00, 0xea, 0xd9, 0x11, 0x23, 0xe0, 0x0a,
0x16, 0x1e, 0xfd, 0x22, 0x0d, 0x4c, 0x16, 0x09, 0xe5, 0x26, 0xc0, 0x1e,
0xf1, 0xeb, 0xf1, 0x1a, 0xfb, 0xdd, 0xe1, 0xef, 0x21, 0x07, 0xc3, 0xef,
0x13, 0xd4, 0x24, 0x3f, 0x0c, 0xe3, 0x23, 0xe1, 0x05, 0x0d, 0x18, 0x2c,
0x19, 0x24, 0xfc, 0xf2, 0xbc, 0x39, 0xf6, 0xe8, 0x13, 0xec, 0x19, 0xdd,
0xc6, 0x03, 0xff, 0xea, 0x01, 0x16, 0xf1, 0x01, 0x0f, 0x1e, 0x04, 0xf1,
0xe7, 0x0c, 0x0f, 0x1f, 0xef, 0x35, 0x04, 0xf4, 0xc8, 0x13, 0xfd, 0x0f,
0xfd, 0xf2, 0xf5, 0x25, 0xed, 0xfa, 0xef, 0x14, 0x0e, 0xda, 0xbd, 0xe6,
0xdd, 0xdb, 0x11, 0x08, 0xef, 0xf2, 0x0d, 0xf9, 0x02, 0xe6, 0x0f, 0x23,
0xe1, 0x04, 0xe6, 0x3c, 0xf3, 0xf8, 0x14, 0xf3, 0xf7, 0x19, 0xe5, 0xfe,
0xe4, 0x04, 0xfc, 0x06, 0xe2, 0x0a, 0xed, 0xe7, 0x22, 0x3f, 0xe2, 0xe0,
0xfe, 0x0b, 0xde, 0x10, 0x23, 0x49, 0x14, 0x0e, 0xc4, 0x2b, 0xf2, 0x08,
0xe2, 0x20, 0x24, 0x12, 0xdb, 0x10, 0xe6, 0xfc, 0x2b, 0xda, 0xde, 0x05,
0xf1, 0xf9, 0x14, 0x2e, 0xf2, 0x27, 0xf1, 0x05, 0x0f, 0x06, 0x07, 0x2d,
0x11, 0xe4, 0xe7, 0x27, 0xad, 0x2d, 0x1a, 0x2f, 0x05, 0x0e, 0x0a, 0x01,
0x09, 0xf9, 0x01, 0xe9, 0xd3, 0xee, 0x13, 0xd8, 0xf7, 0x36, 0xda, 0x2a,
0x05, 0xf8, 0xe5, 0xe5, 0xe0, 0x01, 0x1e, 0xec, 0xdd, 0x04, 0xc7, 0xd4,
0x25, 0xf7, 0xf4, 0x06, 0xdb, 0xed, 0xc9, 0xf3, 0x12, 0x14, 0xe8, 0x1a,
0xd2, 0xda, 0xe4, 0x45, 0x20, 0x08, 0xef, 0xdb, 0xe7, 0x0e, 0x07, 0x48,
0x1e, 0x1b, 0xd4, 0x23, 0xac, 0x13, 0xe9, 0x2f, 0xdd, 0xff, 0x17, 0x09,
0xc8, 0xfe, 0xed, 0xe9, 0xfa, 0xdd, 0xe0, 0xd3, 0x25, 0x34, 0xfb, 0x09,
0xf8, 0x01, 0x03, 0xe0, 0x1c, 0x31, 0xed, 0xff, 0xed, 0x23, 0xc8, 0xf7,
0xf6, 0x29, 0x0c, 0x0f, 0xed, 0x18, 0xf8, 0x0a, 0x09, 0x19, 0xdf, 0xe2,
0x17, 0xed, 0xf9, 0x4c, 0xf1, 0x19, 0xf6, 0x00, 0x06, 0xfc, 0xea, 0x14,
0x1d, 0x1d, 0xe0, 0x11, 0xb3, 0x15, 0x02, 0x09, 0xe6, 0x2c, 0xf5, 0xfd,
0xe7, 0xe8, 0x0b, 0xf5, 0xdb, 0xe6, 0x13, 0xf2, 0x1d, 0x3d, 0xd1, 0x16,
0x04, 0x1d, 0x16, 0xe3, 0x04, 0xfd, 0xf4, 0xf5, 0xe9, 0x2f, 0xc6, 0x16,
0x0e, 0x11, 0x21, 0x1b, 0x1f, 0x11, 0xf3, 0x00, 0x10, 0x15, 0xe8, 0xeb,
0xe6, 0xda, 0xe8, 0x4a, 0x0a, 0xf0, 0xe3, 0x07, 0xf7, 0x10, 0x11, 0xff,
0xe6, 0xf1, 0xfd, 0x22, 0xe8, 0x21, 0x09, 0x09, 0x13, 0xfa, 0xe1, 0xef,
0xca, 0xd7, 0x32, 0x22, 0xd4, 0x1e, 0x10, 0xe5, 0xf4, 0x0d, 0x0f, 0xe3,
0x21, 0x18, 0xea, 0xf0, 0xef, 0xf3, 0x09, 0x0a, 0xd9, 0xfd, 0xa5, 0xfb,
0x14, 0xfb, 0x0c, 0x11, 0x07, 0xfc, 0xcd, 0x04, 0x1b, 0x09, 0xcd, 0xed,
0x26, 0xcf, 0x01, 0x14, 0xda, 0xf0, 0x18, 0x08, 0x14, 0xff, 0x18, 0x04,
0xed, 0xf0, 0xef, 0x3b, 0xb4, 0xe5, 0x10, 0xf3, 0x07, 0x11, 0x13, 0xde,
0xff, 0x0f, 0x2e, 0x09, 0xc2, 0xdd, 0xfa, 0x00, 0xe2, 0x1f, 0x0a, 0x15,
0x0d, 0xfd, 0x19, 0x06, 0x21, 0xf7, 0xf7, 0x15, 0xfe, 0x0f, 0xc3, 0x13,
0xf1, 0xfd, 0x19, 0xf0, 0xf2, 0x13, 0xc8, 0xda, 0x26, 0x2c, 0xd7, 0xe6,
0x19, 0xf2, 0x08, 0x06, 0xcc, 0xfa, 0x0a, 0x05, 0x0f, 0x06, 0xf8, 0x0b,
0x0f, 0x09, 0x04, 0xf9, 0xb7, 0xea, 0x13, 0xf3, 0xde, 0xf4, 0xdf, 0xef,
0xf7, 0x22, 0x13, 0x1c, 0xee, 0xe3, 0x01, 0xcf, 0xe1, 0x08, 0x02, 0xf1,
0x16, 0xdd, 0xe3, 0x11, 0x16, 0x0e, 0xf0, 0xfb, 0xcc, 0x14, 0xad, 0x2f,
0x21, 0xe9, 0xe9, 0x1b, 0xfe, 0xf7, 0xd0, 0xec, 0x19, 0xf9, 0xfd, 0x19,
0xfa, 0xe1, 0xe7, 0x20, 0x09, 0xf4, 0x0c, 0xe2, 0xee, 0xdf, 0x03, 0x27,
0x20, 0x0a, 0xca, 0x12, 0xd6, 0xfc, 0x25, 0x1d, 0xef, 0xfe, 0xdd, 0x22,
0xcc, 0xfa, 0x2f, 0x17, 0xc1, 0xfc, 0x1f, 0xf5, 0xf5, 0x36, 0x13, 0xf4,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0e, 0xfe, 0xff, 0xff,
0x04, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff,
0xde, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x2e, 0xfe, 0xff, 0xff, 0x04, 0x00, 0x00, 0x00,
0x78, 0x00, 0x00, 0x00, 0x74, 0xfa, 0xff, 0xff, 0x3b, 0x1e, 0x00, 0x00,
0x34, 0x1d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xd8, 0xf9, 0xff, 0xff,
0x0b, 0x08, 0x00, 0x00, 0x50, 0x20, 0x00, 0x00, 0xc6, 0xdd, 0xff, 0xff,
0xfc, 0xd7, 0xff, 0xff, 0xbd, 0xee, 0xff, 0xff, 0xd9, 0x30, 0x00, 0x00,
0xc8, 0xfc, 0xff, 0xff, 0xa4, 0xf5, 0xff, 0xff, 0x5f, 0xff, 0xff, 0xff,
0x63, 0xfa, 0xff, 0xff, 0x3d, 0xf9, 0xff, 0xff, 0x4c, 0x20, 0x00, 0x00,
0xd4, 0xf9, 0xff, 0xff, 0xfb, 0x10, 0x00, 0x00, 0x55, 0x0c, 0x00, 0x00,
0x71, 0xea, 0xff, 0xff, 0x03, 0xfe, 0xff, 0xff, 0xa7, 0xfc, 0xff, 0xff,
0x24, 0xfd, 0xff, 0xff, 0x01, 0x09, 0x00, 0x00, 0x14, 0x0f, 0x00, 0x00,
0xf8, 0xf3, 0xff, 0xff, 0xb7, 0xeb, 0xff, 0xff, 0x64, 0xee, 0xff, 0xff,
0xf5, 0xf9, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0xbe, 0xfe, 0xff, 0xff, 0x04, 0x00, 0x00, 0x00,
0x08, 0x00, 0x00, 0x00, 0xed, 0x05, 0x00, 0x00, 0x13, 0xfa, 0xff, 0xff,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0xde, 0xfe, 0xff, 0xff, 0x04, 0x00, 0x00, 0x00, 0x78, 0x00, 0x00, 0x00,
0x26, 0x02, 0x00, 0x00, 0xe9, 0x08, 0x00, 0x00, 0x9c, 0x05, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0xd0, 0x00, 0x00, 0x00, 0xae, 0x08, 0x00, 0x00,
0xdd, 0x09, 0x00, 0x00, 0x54, 0xf5, 0xff, 0xff, 0xbb, 0x09, 0x00, 0x00,
0xb0, 0xfe, 0xff, 0xff, 0x0c, 0xfc, 0xff, 0xff, 0x57, 0x11, 0x00, 0x00,
0xe6, 0xfc, 0xff, 0xff, 0x61, 0x10, 0x00, 0x00, 0x71, 0xfc, 0xff, 0xff,
0x26, 0x00, 0x00, 0x00, 0x12, 0x09, 0x00, 0x00, 0x13, 0xff, 0xff, 0xff,
0x79, 0x10, 0x00, 0x00, 0x8a, 0xfb, 0xff, 0xff, 0xa5, 0xfa, 0xff, 0xff,
0x6a, 0xea, 0xff, 0xff, 0x8c, 0x05, 0x00, 0x00, 0xa4, 0x00, 0x00, 0x00,
0x26, 0xf6, 0xff, 0xff, 0xb6, 0x0e, 0x00, 0x00, 0x99, 0xfd, 0xff, 0xff,
0x15, 0xfd, 0xff, 0xff, 0x2d, 0x06, 0x00, 0x00, 0x53, 0xfb, 0xff, 0xff,
0x00, 0x00, 0x00, 0x00, 0xd0, 0xf2, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0xf2, 0xff, 0xff,
0x0f, 0x00, 0x00, 0x00, 0x4d, 0x4c, 0x49, 0x52, 0x20, 0x43, 0x6f, 0x6e,
0x76, 0x65, 0x72, 0x74, 0x65, 0x64, 0x2e, 0x00, 0x01, 0x00, 0x00, 0x00,
0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x18, 0x00, 0x04, 0x00,
0x08, 0x00, 0x0c, 0x00, 0x10, 0x00, 0x14, 0x00, 0x0e, 0x00, 0x00, 0x00,
0x04, 0x02, 0x00, 0x00, 0xf8, 0x01, 0x00, 0x00, 0xec, 0x01, 0x00, 0x00,
0x14, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
0x6d, 0x61, 0x69, 0x6e, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00,
0x84, 0x01, 0x00, 0x00, 0x24, 0x01, 0x00, 0x00, 0xbc, 0x00, 0x00, 0x00,
0x84, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
0x62, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x09, 0x05, 0x00, 0x00, 0x00,
0x24, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00,
0x00, 0x00, 0x06, 0x00, 0x08, 0x00, 0x04, 0x00, 0x06, 0x00, 0x00, 0x00,
0x00, 0x00, 0x80, 0x3f, 0x01, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00,
0x01, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x36, 0xff, 0xff, 0xff,
0x00, 0x00, 0x00, 0x08, 0x04, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00,
0x0c, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0xa0, 0xf3, 0xff, 0xff,
0x01, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
0x0b, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
0x00, 0x00, 0x0a, 0x00, 0x10, 0x00, 0x04, 0x00, 0x08, 0x00, 0x0c, 0x00,
0x0a, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00,
0x04, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00,
0x02, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
0x00, 0x00, 0x0e, 0x00, 0x1a, 0x00, 0x08, 0x00, 0x0c, 0x00, 0x10, 0x00,
0x07, 0x00, 0x14, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02,
0x02, 0x00, 0x00, 0x00, 0x38, 0x00, 0x00, 0x00, 0x2c, 0x00, 0x00, 0x00,
0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x14, 0x00, 0x06, 0x00,
0x08, 0x00, 0x0c, 0x00, 0x10, 0x00, 0x07, 0x00, 0x0e, 0x00, 0x00, 0x00,
0x00, 0x00, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00,
0x03, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00,
0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x18, 0x00, 0x08, 0x00,
0x0c, 0x00, 0x10, 0x00, 0x07, 0x00, 0x14, 0x00, 0x0e, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00,
0x24, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x10, 0x00,
0x06, 0x00, 0x08, 0x00, 0x0c, 0x00, 0x07, 0x00, 0x0c, 0x00, 0x00, 0x00,
0x00, 0x00, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
0x01, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
0x08, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
0x00, 0x00, 0x0e, 0x00, 0x16, 0x00, 0x00, 0x00, 0x08, 0x00, 0x0c, 0x00,
0x07, 0x00, 0x10, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05,
0x3c, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00,
0x00, 0x00, 0x0e, 0x00, 0x18, 0x00, 0x07, 0x00, 0x08, 0x00, 0x0c, 0x00,
0x10, 0x00, 0x14, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00,
0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
0x0d, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x0e, 0x00, 0x00, 0x00, 0x64, 0x0f, 0x00, 0x00, 0x70, 0x0d, 0x00, 0x00,
0xe8, 0x0c, 0x00, 0x00, 0x04, 0x0b, 0x00, 0x00, 0xbc, 0x0a, 0x00, 0x00,
0x3c, 0x0a, 0x00, 0x00, 0x70, 0x07, 0x00, 0x00, 0x84, 0x04, 0x00, 0x00,
0xc8, 0x03, 0x00, 0x00, 0xac, 0x02, 0x00, 0x00, 0x88, 0x01, 0x00, 0x00,
0xfc, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
0xe8, 0xf0, 0xff, 0xff, 0x00, 0x00, 0x00, 0x09, 0x54, 0x00, 0x00, 0x00,
0x0e, 0x00, 0x00, 0x00, 0x3c, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00,
0x04, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff,
0x02, 0x00, 0x00, 0x00, 0xd4, 0xf2, 0xff, 0xff, 0x18, 0x00, 0x00, 0x00,
0x04, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x80, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
0x00, 0x00, 0x80, 0x3b, 0x08, 0x00, 0x00, 0x00, 0x49, 0x64, 0x65, 0x6e,
0x74, 0x69, 0x74, 0x79, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x50, 0xf1, 0xff, 0xff,
0x00, 0x00, 0x00, 0x09, 0x74, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00,
0x50, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
0x02, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0x00, 0x00,
0x34, 0xf1, 0xff, 0xff, 0x2c, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00,
0x14, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
0xfa, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x01, 0x00, 0x00, 0x00,
0x6b, 0x57, 0xaa, 0x3d, 0x01, 0x00, 0x00, 0x00, 0x37, 0xb9, 0x30, 0x41,
0x01, 0x00, 0x00, 0x00, 0xf2, 0xa0, 0x22, 0xc1, 0x15, 0x00, 0x00, 0x00,
0x41, 0x6c, 0x6c, 0x41, 0x4e, 0x42, 0x53, 0x2f, 0x64, 0x65, 0x6e, 0x73,
0x65, 0x2f, 0x42, 0x69, 0x61, 0x73, 0x41, 0x64, 0x64, 0x00, 0x00, 0x00,
0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
0xd8, 0xf1, 0xff, 0xff, 0x00, 0x00, 0x00, 0x09, 0x74, 0x00, 0x00, 0x00,
0x0c, 0x00, 0x00, 0x00, 0x50, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00,
0x04, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff,
0xde, 0x21, 0x00, 0x00, 0xbc, 0xf1, 0xff, 0xff, 0x2c, 0x00, 0x00, 0x00,
0x20, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
0x01, 0x00, 0x00, 0x00, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0x01, 0x00, 0x00, 0x00, 0x02, 0x88, 0xc1, 0x3b, 0x01, 0x00, 0x00, 0x00,
0x7a, 0xc6, 0xc0, 0x3f, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x17, 0x00, 0x00, 0x00, 0x41, 0x6c, 0x6c, 0x41, 0x4e, 0x42, 0x53, 0x2f,
0x66, 0x6c, 0x61, 0x74, 0x74, 0x65, 0x6e, 0x2f, 0x52, 0x65, 0x73, 0x68,
0x61, 0x70, 0x65, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
0xde, 0x21, 0x00, 0x00, 0x60, 0xf2, 0xff, 0xff, 0x00, 0x00, 0x00, 0x09,
0x04, 0x01, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x5c, 0x00, 0x00, 0x00,
0x1c, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
0xff, 0xff, 0xff, 0xff, 0x11, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00,
0x1e, 0x00, 0x00, 0x00, 0x4c, 0xf2, 0xff, 0xff, 0x30, 0x00, 0x00, 0x00,
0x24, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
0x01, 0x00, 0x00, 0x00, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x88, 0xc1, 0x3b,
0x01, 0x00, 0x00, 0x00, 0x7a, 0xc6, 0xc0, 0x3f, 0x01, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x9a, 0x00, 0x00, 0x00, 0x41, 0x6c, 0x6c, 0x41,
0x4e, 0x42, 0x53, 0x2f, 0x64, 0x65, 0x70, 0x74, 0x68, 0x77, 0x69, 0x73,
0x65, 0x5f, 0x63, 0x6f, 0x6e, 0x76, 0x32, 0x64, 0x2f, 0x52, 0x65, 0x6c,
0x75, 0x3b, 0x41, 0x6c, 0x6c, 0x41, 0x4e, 0x42, 0x53, 0x2f, 0x64, 0x65,
0x70, 0x74, 0x68, 0x77, 0x69, 0x73, 0x65, 0x5f, 0x63, 0x6f, 0x6e, 0x76,
0x32, 0x64, 0x2f, 0x42, 0x69, 0x61, 0x73, 0x41, 0x64, 0x64, 0x3b, 0x41,
0x6c, 0x6c, 0x41, 0x4e, 0x42, 0x53, 0x2f, 0x64, 0x65, 0x70, 0x74, 0x68,
0x77, 0x69, 0x73, 0x65, 0x5f, 0x63, 0x6f, 0x6e, 0x76, 0x32, 0x64, 0x2f,
0x64, 0x65, 0x70, 0x74, 0x68, 0x77, 0x69, 0x73, 0x65, 0x3b, 0x41, 0x6c,
0x6c, 0x41, 0x4e, 0x42, 0x53, 0x2f, 0x64, 0x65, 0x70, 0x74, 0x68, 0x77,
0x69, 0x73, 0x65, 0x5f, 0x63, 0x6f, 0x6e, 0x76, 0x32, 0x64, 0x2f, 0x42,
0x69, 0x61, 0x73, 0x41, 0x64, 0x64, 0x2f, 0x52, 0x65, 0x61, 0x64, 0x56,
0x61, 0x72, 0x69, 0x61, 0x62, 0x6c, 0x65, 0x4f, 0x70, 0x2f, 0x72, 0x65,
0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
0x01, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00,
0x1e, 0x00, 0x00, 0x00, 0x80, 0xf3, 0xff, 0xff, 0x00, 0x00, 0x00, 0x09,
0xfc, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x5c, 0x00, 0x00, 0x00,
0x1c, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
0xff, 0xff, 0xff, 0xff, 0x2e, 0x00, 0x00, 0x00, 0x2e, 0x00, 0x00, 0x00,
0x1e, 0x00, 0x00, 0x00, 0x6c, 0xf3, 0xff, 0xff, 0x30, 0x00, 0x00, 0x00,
0x24, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
0x01, 0x00, 0x00, 0x00, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x37, 0x20, 0xb5, 0x3b,
0x01, 0x00, 0x00, 0x00, 0x17, 0x6b, 0xb4, 0x3f, 0x01, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x92, 0x00, 0x00, 0x00, 0x41, 0x6c, 0x6c, 0x41,
0x4e, 0x42, 0x53, 0x2f, 0x63, 0x6f, 0x6e, 0x76, 0x32, 0x64, 0x2f, 0x52,
0x65, 0x6c, 0x75, 0x3b, 0x41, 0x6c, 0x6c, 0x41, 0x4e, 0x42, 0x53, 0x2f,
0x63, 0x6f, 0x6e, 0x76, 0x32, 0x64, 0x2f, 0x42, 0x69, 0x61, 0x73, 0x41,
0x64, 0x64, 0x3b, 0x41, 0x6c, 0x6c, 0x41, 0x4e, 0x42, 0x53, 0x2f, 0x64,
0x65, 0x70, 0x74, 0x68, 0x77, 0x69, 0x73, 0x65, 0x5f, 0x63, 0x6f, 0x6e,
0x76, 0x32, 0x64, 0x2f, 0x64, 0x65, 0x70, 0x74, 0x68, 0x77, 0x69, 0x73,
0x65, 0x3b, 0x41, 0x6c, 0x6c, 0x41, 0x4e, 0x42, 0x53, 0x2f, 0x63, 0x6f,
0x6e, 0x76, 0x32, 0x64, 0x2f, 0x43, 0x6f, 0x6e, 0x76, 0x32, 0x44, 0x3b,
0x41, 0x6c, 0x6c, 0x41, 0x4e, 0x42, 0x53, 0x2f, 0x63, 0x6f, 0x6e, 0x76,
0x32, 0x64, 0x2f, 0x42, 0x69, 0x61, 0x73, 0x41, 0x64, 0x64, 0x2f, 0x52,
0x65, 0x61, 0x64, 0x56, 0x61, 0x72, 0x69, 0x61, 0x62, 0x6c, 0x65, 0x4f,
0x70, 0x2f, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x00, 0x00,
0x04, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x2e, 0x00, 0x00, 0x00,
0x2e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x98, 0xf4, 0xff, 0xff,
0x00, 0x00, 0x00, 0x09, 0x8c, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00,
0x5c, 0x00, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
0x04, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x32, 0x00, 0x00, 0x00,
0x32, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x84, 0xf4, 0xff, 0xff,
0x30, 0x00, 0x00, 0x00, 0x24, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00,
0x04, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x80, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
0x81, 0x80, 0x80, 0x3b, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x3f,
0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00,
0x41, 0x6c, 0x6c, 0x41, 0x4e, 0x42, 0x53, 0x2f, 0x61, 0x76, 0x65, 0x72,
0x61, 0x67, 0x65, 0x5f, 0x70, 0x6f, 0x6f, 0x6c, 0x69, 0x6e, 0x67, 0x32,
0x64, 0x2f, 0x41, 0x76, 0x67, 0x50, 0x6f, 0x6f, 0x6c, 0x00, 0x00, 0x00,
0x04, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x32, 0x00, 0x00, 0x00,
0x32, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0e, 0x00,
0x1a, 0x00, 0x08, 0x00, 0x07, 0x00, 0x0c, 0x00, 0x10, 0x00, 0x14, 0x00,
0x0e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x09, 0xcc, 0x02, 0x00, 0x00,
0x08, 0x00, 0x00, 0x00, 0x9c, 0x02, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00,
0x00, 0x00, 0x12, 0x00, 0x18, 0x00, 0x04, 0x00, 0x08, 0x00, 0x0c, 0x00,
0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x14, 0x00, 0x12, 0x00, 0x00, 0x00,
0x00, 0x02, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
0x08, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x1e, 0x00, 0x00, 0x00, 0x8a, 0x6a, 0x01, 0x39, 0x90, 0xef, 0x23, 0x39,
0x81, 0xa3, 0x0d, 0x39, 0x4a, 0xac, 0xf1, 0x38, 0x45, 0x7d, 0x01, 0x39,
0x66, 0xa6, 0xbe, 0x39, 0x8d, 0x80, 0x1e, 0x39, 0xfe, 0x12, 0x3f, 0x39,
0x7a, 0x8a, 0x9d, 0x39, 0x0a, 0x74, 0xac, 0x39, 0x26, 0x44, 0xf3, 0x39,
0x5c, 0xdf, 0xa2, 0x39, 0x86, 0x36, 0x12, 0x39, 0xe0, 0xef, 0xb6, 0x39,
0x44, 0xfb, 0xff, 0x38, 0xf1, 0xc4, 0x79, 0x39, 0x80, 0x9c, 0x20, 0x39,
0x07, 0xa2, 0x02, 0x39, 0xb7, 0x55, 0xb6, 0x39, 0xa6, 0xb1, 0x73, 0x39,
0x9e, 0xea, 0x6b, 0x39, 0xc4, 0xa3, 0xb8, 0x39, 0x30, 0xfa, 0xb9, 0x39,
0x65, 0x3b, 0xfe, 0x38, 0x0b, 0xb7, 0x99, 0x39, 0x77, 0x93, 0xdb, 0x39,
0xc9, 0xf0, 0x27, 0x39, 0x24, 0xe5, 0xf1, 0x39, 0x7e, 0xe7, 0xd2, 0x39,
0xa6, 0x56, 0x7f, 0x39, 0x1e, 0x00, 0x00, 0x00, 0x81, 0xca, 0x6c, 0x3c,
0xb1, 0xa7, 0xa2, 0x3c, 0x3a, 0x88, 0x8c, 0x3c, 0x7c, 0x9a, 0x6f, 0x3c,
0x95, 0xa9, 0x66, 0x3c, 0x56, 0x5e, 0x23, 0x3d, 0x8c, 0x43, 0x9d, 0x3c,
0xd8, 0x94, 0xbd, 0x3c, 0x65, 0x4f, 0x1c, 0x3d, 0x22, 0x1b, 0x2b, 0x3d,
0x2c, 0xb6, 0xd0, 0x3c, 0xa0, 0x5d, 0x1b, 0x3d, 0x4c, 0xaf, 0x8a, 0x3c,
0xa5, 0x0e, 0x07, 0x3d, 0xe2, 0x45, 0x6a, 0x3c, 0x67, 0xd1, 0xf7, 0x3c,
0x47, 0x5b, 0x9f, 0x3c, 0xe1, 0x1d, 0x5f, 0x3c, 0x0c, 0xe9, 0x34, 0x3d,
0x07, 0xb2, 0xce, 0x3c, 0xc9, 0x12, 0xea, 0x3c, 0xa8, 0xb3, 0x0f, 0x3d,
0x3c, 0x86, 0x38, 0x3d, 0x82, 0xe0, 0x70, 0x3c, 0xe8, 0x9b, 0x15, 0x3d,
0x50, 0xdc, 0x59, 0x3d, 0x4e, 0xb6, 0xa2, 0x3c, 0x5a, 0x01, 0x70, 0x3d,
0xaf, 0x41, 0x51, 0x3d, 0xf9, 0x57, 0xfd, 0x3c, 0x1e, 0x00, 0x00, 0x00,
0xb5, 0x67, 0x80, 0xbc, 0x67, 0x7e, 0x7d, 0xbc, 0x67, 0xea, 0x75, 0xbc,
0xf1, 0xc8, 0x6f, 0xbc, 0x4a, 0x7a, 0x80, 0xbc, 0x19, 0x29, 0x3d, 0xbd,
0x03, 0x3b, 0x5d, 0xbc, 0x65, 0xf5, 0x8f, 0xbc, 0x26, 0x60, 0x3f, 0xbc,
0x0c, 0x54, 0xb7, 0xbc, 0x9e, 0x5d, 0x71, 0xbd, 0x9d, 0x99, 0x21, 0xbd,
0x19, 0x12, 0x91, 0xbc, 0x00, 0x82, 0x35, 0xbd, 0x4d, 0xfb, 0x7d, 0xbc,
0xfa, 0x2f, 0xf3, 0xbc, 0xba, 0x32, 0x6a, 0xbc, 0xc3, 0x9c, 0x81, 0xbc,
0x12, 0x8a, 0x25, 0xbc, 0x43, 0xca, 0xf1, 0xbc, 0x4d, 0xa7, 0x64, 0xbc,
0x7c, 0x32, 0x37, 0xbd, 0x48, 0x5e, 0xba, 0xba, 0xee, 0x3e, 0x7c, 0xbc,
0x9d, 0x83, 0x18, 0xbd, 0xa3, 0x28, 0x60, 0xbc, 0xe7, 0xa0, 0xa6, 0xbc,
0xbd, 0x5b, 0xb8, 0xbc, 0xd3, 0x9b, 0xca, 0xbc, 0x43, 0x32, 0xb3, 0xbc,
0x22, 0x00, 0x00, 0x00, 0x41, 0x6c, 0x6c, 0x41, 0x4e, 0x42, 0x53, 0x2f,
0x64, 0x65, 0x70, 0x74, 0x68, 0x77, 0x69, 0x73, 0x65, 0x5f, 0x63, 0x6f,
0x6e, 0x76, 0x32, 0x64, 0x2f, 0x64, 0x65, 0x70, 0x74, 0x68, 0x77, 0x69,
0x73, 0x65, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00,
0x22, 0xfa, 0xff, 0xff, 0x00, 0x00, 0x00, 0x09, 0xac, 0x02, 0x00, 0x00,
0x07, 0x00, 0x00, 0x00, 0x88, 0x02, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
0x0c, 0xf8, 0xff, 0xff, 0x00, 0x02, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00,
0x00, 0x01, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x49, 0x3c, 0x32, 0x3a,
0x0d, 0xec, 0x30, 0x3a, 0x25, 0xcb, 0x2e, 0x3a, 0x36, 0x69, 0x2e, 0x3a,
0xbc, 0x89, 0x2f, 0x3a, 0xe4, 0x84, 0x4a, 0x3a, 0x81, 0x05, 0x2e, 0x3a,
0xd8, 0x35, 0x30, 0x3a, 0x98, 0xac, 0x3a, 0x3a, 0x68, 0xf6, 0x29, 0x3a,
0x2d, 0x4a, 0x51, 0x3a, 0x21, 0x7b, 0x3f, 0x3a, 0xf3, 0xc1, 0x35, 0x3a,
0x69, 0x8b, 0x3d, 0x3a, 0x88, 0xce, 0x30, 0x3a, 0x36, 0x66, 0x35, 0x3a,
0x27, 0x04, 0x33, 0x3a, 0x90, 0xc7, 0x2f, 0x3a, 0x57, 0x09, 0x3b, 0x3a,
0x1f, 0xcf, 0x34, 0x3a, 0x81, 0x4b, 0x35, 0x3a, 0x89, 0xc6, 0x7c, 0x3a,
0xa3, 0x78, 0x2f, 0x3a, 0x92, 0x9f, 0x2f, 0x3a, 0x73, 0x47, 0x6f, 0x3a,
0x24, 0x8c, 0x37, 0x3a, 0x98, 0x9d, 0x2d, 0x3a, 0xbc, 0xf0, 0x3a, 0x3a,
0xa8, 0x2b, 0x31, 0x3a, 0x66, 0x09, 0x30, 0x3a, 0x1e, 0x00, 0x00, 0x00,
0xd0, 0xd7, 0xb0, 0x3d, 0x35, 0x8a, 0xaf, 0x3d, 0x8f, 0x6d, 0xad, 0x3d,
0xc0, 0x6e, 0xa2, 0x3d, 0x43, 0xc9, 0xa9, 0x3d, 0xff, 0x2a, 0xbb, 0x3d,
0x76, 0xa9, 0xac, 0x3d, 0xbb, 0xe5, 0xaa, 0x3d, 0x3f, 0x37, 0xb9, 0x3d,
0x7b, 0xa2, 0xa8, 0x3d, 0xc8, 0x6f, 0xb9, 0x3d, 0x2b, 0xae, 0xa8, 0x3d,
0x6f, 0x56, 0xb4, 0x3d, 0x52, 0x10, 0xbc, 0x3d, 0xe0, 0xbb, 0xa9, 0x3d,
0x6a, 0xfb, 0xb3, 0x3d, 0x1f, 0x9e, 0xb1, 0x3d, 0x80, 0xd6, 0xad, 0x3d,
0x44, 0x93, 0xb9, 0x3d, 0x81, 0x65, 0xb3, 0x3d, 0xea, 0xe0, 0xb3, 0x3d,
0xfc, 0xcc, 0xfa, 0x3d, 0xb2, 0x19, 0xae, 0x3d, 0x72, 0x71, 0xaa, 0x3d,
0xe4, 0x68, 0xed, 0x3d, 0x0c, 0x1d, 0xb6, 0x3d, 0x5d, 0x42, 0xac, 0x3d,
0xdb, 0x7a, 0xb9, 0x3d, 0x51, 0xc9, 0xaf, 0x3d, 0x53, 0xa9, 0xae, 0x3d,
0x1e, 0x00, 0x00, 0x00, 0x81, 0xec, 0xa9, 0xbd, 0x33, 0x6a, 0xa8, 0xbd,
0xfa, 0x7b, 0x9c, 0xbd, 0x64, 0x0c, 0xad, 0xbd, 0xa9, 0x2a, 0xae, 0xbd,
0xda, 0xef, 0xc8, 0xbd, 0xc5, 0xbc, 0xa3, 0xbd, 0x6c, 0xd5, 0xae, 0xbd,
0x8b, 0x32, 0xad, 0xbd, 0x70, 0x90, 0xa6, 0xbd, 0x99, 0xa7, 0xcf, 0xbd,
0x2b, 0xfc, 0xbd, 0xbd, 0x94, 0x56, 0xa8, 0xbd, 0x28, 0x9e, 0xb3, 0xbd,
0xeb, 0x6c, 0xaf, 0xbd, 0x32, 0xe2, 0xad, 0xbd, 0xd9, 0x2a, 0xa9, 0xbd,
0x01, 0x68, 0xae, 0xbd, 0x5a, 0xe1, 0xa6, 0xbd, 0x3d, 0xbf, 0xae, 0xbd,
0x7c, 0x11, 0xa2, 0xbd, 0x70, 0xc9, 0xa5, 0xbd, 0xa7, 0x29, 0xa9, 0xbd,
0x53, 0x40, 0xae, 0xbd, 0x6c, 0xdf, 0xb6, 0xbd, 0xb0, 0xd5, 0x9e, 0xbd,
0x1f, 0x32, 0xa5, 0xbd, 0xc5, 0xca, 0xa8, 0xbd, 0x1c, 0x8e, 0xa6, 0xbd,
0x6e, 0xee, 0xa9, 0xbd, 0x15, 0x00, 0x00, 0x00, 0x41, 0x6c, 0x6c, 0x41,
0x4e, 0x42, 0x53, 0x2f, 0x63, 0x6f, 0x6e, 0x76, 0x32, 0x64, 0x2f, 0x43,
0x6f, 0x6e, 0x76, 0x32, 0x44, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
0x1e, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00,
0x03, 0x00, 0x00, 0x00, 0xea, 0xfc, 0xff, 0xff, 0x00, 0x00, 0x00, 0x09,
0x68, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x44, 0x00, 0x00, 0x00,
0x04, 0x00, 0x00, 0x00, 0xd4, 0xfa, 0xff, 0xff, 0x30, 0x00, 0x00, 0x00,
0x24, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x36, 0x58, 0x42, 0x3a,
0x01, 0x00, 0x00, 0x00, 0x86, 0xd3, 0xc0, 0x3d, 0x01, 0x00, 0x00, 0x00,
0x65, 0xea, 0xae, 0xbd, 0x14, 0x00, 0x00, 0x00, 0x41, 0x6c, 0x6c, 0x41,
0x4e, 0x42, 0x53, 0x2f, 0x64, 0x65, 0x6e, 0x73, 0x65, 0x2f, 0x4d, 0x61,
0x74, 0x4d, 0x75, 0x6c, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
0x02, 0x00, 0x00, 0x00, 0xde, 0x21, 0x00, 0x00, 0x66, 0xfd, 0xff, 0xff,
0x00, 0x00, 0x00, 0x02, 0x34, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00,
0x10, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x04, 0x00, 0x04, 0x00,
0x04, 0x00, 0x00, 0x00, 0x15, 0x00, 0x00, 0x00, 0x41, 0x6c, 0x6c, 0x41,
0x4e, 0x42, 0x53, 0x2f, 0x66, 0x6c, 0x61, 0x74, 0x74, 0x65, 0x6e, 0x2f,
0x43, 0x6f, 0x6e, 0x73, 0x74, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
0x02, 0x00, 0x00, 0x00, 0xaa, 0xfd, 0xff, 0xff, 0x00, 0x00, 0x00, 0x02,
0xd0, 0x01, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x88, 0x01, 0x00, 0x00,
0x04, 0x00, 0x00, 0x00, 0x9c, 0xfd, 0xff, 0xff, 0x00, 0x01, 0x00, 0x00,
0x04, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x1e, 0x00, 0x00, 0x00, 0x39, 0x21, 0x37, 0x35, 0x04, 0xfa, 0x67, 0x35,
0xda, 0x6c, 0x48, 0x35, 0x3a, 0xfd, 0x2a, 0x35, 0xbb, 0x3b, 0x37, 0x35,
0xa4, 0xe3, 0x06, 0x36, 0xac, 0x49, 0x60, 0x35, 0x79, 0x30, 0x87, 0x35,
0x77, 0xed, 0xde, 0x35, 0x7d, 0x07, 0xf4, 0x35, 0xcc, 0x1d, 0x2c, 0x36,
0xd6, 0x78, 0xe6, 0x35, 0xe6, 0xe5, 0x4e, 0x35, 0x9f, 0x6e, 0x01, 0x36,
0xdd, 0x1c, 0x35, 0x35, 0xad, 0xb7, 0xb0, 0x35, 0xb9, 0x45, 0x63, 0x35,
0xff, 0xd9, 0x38, 0x35, 0x8c, 0x01, 0x01, 0x36, 0x45, 0x6b, 0xac, 0x35,
0x92, 0xea, 0xa6, 0x35, 0x06, 0xa3, 0x02, 0x36, 0x4b, 0x95, 0x03, 0x36,
0xfc, 0xdf, 0x33, 0x35, 0x85, 0x83, 0xd9, 0x35, 0xe5, 0x5a, 0x1b, 0x36,
0xc1, 0xa4, 0x6d, 0x35, 0x73, 0x25, 0x2b, 0x36, 0x36, 0x38, 0x15, 0x36,
0x65, 0xa8, 0xb4, 0x35, 0x38, 0x00, 0x00, 0x00, 0x41, 0x6c, 0x6c, 0x41,
0x4e, 0x42, 0x53, 0x2f, 0x64, 0x65, 0x70, 0x74, 0x68, 0x77, 0x69, 0x73,
0x65, 0x5f, 0x63, 0x6f, 0x6e, 0x76, 0x32, 0x64, 0x2f, 0x42, 0x69, 0x61,
0x73, 0x41, 0x64, 0x64, 0x2f, 0x52, 0x65, 0x61, 0x64, 0x56, 0x61, 0x72,
0x69, 0x61, 0x62, 0x6c, 0x65, 0x4f, 0x70, 0x2f, 0x72, 0x65, 0x73, 0x6f,
0x75, 0x72, 0x63, 0x65, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
0x1e, 0x00, 0x00, 0x00, 0x8a, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x02,
0x64, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00,
0x04, 0x00, 0x00, 0x00, 0x7c, 0xff, 0xff, 0xff, 0x14, 0x00, 0x00, 0x00,
0x04, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0xc1, 0xeb, 0x92, 0x36,
0x2d, 0x00, 0x00, 0x00, 0x41, 0x6c, 0x6c, 0x41, 0x4e, 0x42, 0x53, 0x2f,
0x64, 0x65, 0x6e, 0x73, 0x65, 0x2f, 0x42, 0x69, 0x61, 0x73, 0x41, 0x64,
0x64, 0x2f, 0x52, 0x65, 0x61, 0x64, 0x56, 0x61, 0x72, 0x69, 0x61, 0x62,
0x6c, 0x65, 0x4f, 0x70, 0x2f, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63,
0x65, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
0x00, 0x00, 0x0e, 0x00, 0x18, 0x00, 0x08, 0x00, 0x07, 0x00, 0x0c, 0x00,
0x10, 0x00, 0x14, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02,
0xcc, 0x01, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x90, 0x01, 0x00, 0x00,
0x10, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00,
0x04, 0x00, 0x08, 0x00, 0x0c, 0x00, 0x00, 0x00, 0xfc, 0x00, 0x00, 0x00,
0x04, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00,
0x39, 0xef, 0x32, 0x36, 0xab, 0x9d, 0x31, 0x36, 0xa0, 0x7a, 0x2f, 0x36,
0x4f, 0x18, 0x2f, 0x36, 0xf7, 0x39, 0x30, 0x36, 0x35, 0x50, 0x4b, 0x36,
0x36, 0xb4, 0x2e, 0x36, 0xbf, 0xe6, 0x30, 0x36, 0x01, 0x68, 0x3b, 0x36,
0x0a, 0xa1, 0x2a, 0x36, 0x4a, 0x1c, 0x52, 0x36, 0x5d, 0x3b, 0x40, 0x36,
0x6c, 0x78, 0x36, 0x36, 0xb3, 0x49, 0x3e, 0x36, 0x09, 0x80, 0x31, 0x36,
0x53, 0x1c, 0x36, 0x36, 0xe0, 0xb7, 0x33, 0x36, 0x09, 0x78, 0x30, 0x36,
0x1d, 0xc5, 0x3b, 0x36, 0xa4, 0x84, 0x35, 0x36, 0x83, 0x01, 0x36, 0x36,
0x4e, 0xc4, 0x7d, 0x36, 0xcc, 0x28, 0x30, 0x36, 0xe3, 0x4f, 0x30, 0x36,
0xac, 0x37, 0x70, 0x36, 0x69, 0x44, 0x38, 0x36, 0xe5, 0x4b, 0x2e, 0x36,
0x69, 0xac, 0x3b, 0x36, 0x86, 0xdd, 0x31, 0x36, 0x21, 0xba, 0x30, 0x36,
0x2e, 0x00, 0x00, 0x00, 0x41, 0x6c, 0x6c, 0x41, 0x4e, 0x42, 0x53, 0x2f,
0x63, 0x6f, 0x6e, 0x76, 0x32, 0x64, 0x2f, 0x42, 0x69, 0x61, 0x73, 0x41,
0x64, 0x64, 0x2f, 0x52, 0x65, 0x61, 0x64, 0x56, 0x61, 0x72, 0x69, 0x61,
0x62, 0x6c, 0x65, 0x4f, 0x70, 0x2f, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72,
0x63, 0x65, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00,
0x14, 0x00, 0x1c, 0x00, 0x08, 0x00, 0x07, 0x00, 0x0c, 0x00, 0x10, 0x00,
0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x00, 0x14, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x09, 0x78, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
0x64, 0x00, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
0x04, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x64, 0x00, 0x00, 0x00,
0x64, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x14, 0x00,
0x04, 0x00, 0x08, 0x00, 0x0c, 0x00, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00,
0x2c, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00,
0x04, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x80, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0x01, 0x00, 0x00, 0x00, 0x81, 0x80, 0x80, 0x3b,
0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x3f, 0x01, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x69, 0x6e, 0x70, 0x75,
0x74, 0x5f, 0x31, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
0x64, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
0x06, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x54, 0x00, 0x00, 0x00,
0x38, 0x00, 0x00, 0x00, 0x2c, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00,
0x04, 0x00, 0x00, 0x00, 0xb2, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x19,
0x02, 0x00, 0x00, 0x00, 0xd6, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x09,
0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x08, 0x00, 0x07, 0x00,
0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x16, 0xf2, 0xff, 0xff, 0xff,
0x00, 0x00, 0x00, 0x04, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0a, 0x00,
0x0e, 0x00, 0x07, 0x00, 0x00, 0x00, 0x08, 0x00, 0x0a, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x03, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0a, 0x00,
0x0c, 0x00, 0x07, 0x00, 0x00, 0x00, 0x08, 0x00, 0x0a, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00
};
const int all_model_len = 52112;
|
290fc4b47567e2a8e28e1c8c18707ca6f6a1bc61
|
98a3a121f9a5963c2c44ea4d66b373a837e76373
|
/LeetCodeReview/LeetCodeReview/DP/UniquePaths.cpp
|
eb4ea585cb3c79c92fc6ce93081081dcaafaf53c
|
[] |
no_license
|
dlsyj/AlgoPrac
|
4ccab72065521641448d494ee04df0d60dd076d1
|
0742ff261058fc371fa049e96dbdab1a8158f507
|
refs/heads/master
| 2021-01-21T07:25:26.741533
| 2014-10-20T15:29:10
| 2014-10-20T15:29:10
| null | 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 652
|
cpp
|
UniquePaths.cpp
|
//
// UniquePaths.cpp
// LeetCodeReview
//
// Created by WangJZ on 14-10-4.
// Copyright (c) 2014ๅนด WangJZ. All rights reserved.
//
#include "leetcode_dp.h"
int uniquePaths(int m, int n) {
if (m == 0 && n == 0) return 1;
if (m == 0 || n == 0) return 1;
vector<vector<int>> state;
for (int i = 0; i < m; i++) {
vector<int> row(n,0);
row[0] = 1;
state.push_back(row);
}
for (int j = 0; j < n; j++)
state[0][j] = 1;
for (int i = 1; i < m; i++)
for (int j = 1 ; j < n; j++)
state[i][j] = state[i-1][j] + state[i][j-1];
return state[m-1][n-1];
}
|
3fd8cda3bb8c4228204883c1168deb12b7ae9af3
|
af59e00881a72a40edd4330237161d2d34840c35
|
/cub/task/concurrent_executor.cc
|
910e3c3d6e22828cc21129df018dea602ec8a6f7
|
[
"Apache-2.0"
] |
permissive
|
sineagles/Adlik
|
f0974800c7e3d7079d1a284d0b519088d09f628e
|
13e7bb81e4729564dc8dc234c203b245d53ab520
|
refs/heads/master
| 2023-04-11T00:11:37.676494
| 2019-11-15T06:20:31
| 2019-11-15T06:20:31
| 222,104,455
| 2
| 0
|
Apache-2.0
| 2023-03-24T23:21:18
| 2019-11-16T13:37:33
|
C++
|
UTF-8
|
C++
| false
| false
| 337
|
cc
|
concurrent_executor.cc
|
// Copyright 2019 ZTE corporation. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
#include "cub/task/concurrent_executor.h"
namespace cub {
ConcurrentExecutor::ConcurrentExecutor(int numThreads) : pool(numThreads) {
}
void ConcurrentExecutor::schedule(thread_t f) {
pool.schedule(std::move(f));
}
} // namespace cub
|
354452d4363081661b0ce52db2092c6767083095
|
4df5e4c5b2e17218608e5269ec14ba44f6ae124a
|
/EmptyDoublyException.h
|
3b87e2e79fbd691bc5b5babdb2204230ba223ca7
|
[] |
no_license
|
arielmata/cpsc350-assign5
|
1676e5598d91f5dd073450f539aded26e1a7b6ad
|
2daf6c84e885d0d344cf7767a92f46e29c229da1
|
refs/heads/main
| 2023-01-21T06:39:47.389819
| 2020-12-04T07:36:09
| 2020-12-04T07:36:09
| 314,026,877
| 1
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 653
|
h
|
EmptyDoublyException.h
|
//header - EmptyDoublyException.h
// Full name: Ariel Gutierrez
// Student ID: 2318163
// Chapman email: arigutierrez@chapman.edu
// Course number and section: CPSC 350-01
// Assignment or exercise number: Assignment 5
// Assignment 5: A C++ program that implements a simple database system using
// binary search trees. The databases will allow the user to insert, delete,
// and query data.
#include <stdexcept>
using namespace std;
//EmptyDoublyException: Exception for throwing an error when stack is empty
class EmptyDoublyException : public runtime_error{
public:
EmptyDoublyException(const char* message) : runtime_error(message){}
};
|
ce445118ef017b7d13f9264094120082ec8de001
|
3ead10074a9e21f8642923690b89fd516f8bf0eb
|
/src/demo/monte/main.cpp
|
a5bd373a2aade56f70b75ae583c2101a4737e439
|
[] |
no_license
|
xandercrews/mtm
|
78110571e0cac0c32c474df7a093294f6454fa2a
|
643aa8f146ebd3f9ecbe3bbcd86a10f56a1b3f9f
|
refs/heads/master
| 2020-05-18T06:56:48.907995
| 2013-11-14T12:41:11
| 2013-11-14T12:41:11
| null | 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 4,177
|
cpp
|
main.cpp
|
#include <chrono>
#include <cmath>
#include <cstdlib>
#include <random>
#include <stdio.h>
using std::mt19937;
using std::chrono::system_clock;
using std::min;
using std::max;
/**
* Return the cumulative probability that a number will be equal or less than
* the specified number, where probability is a classic bell curve with range
* 0..1.
*
* Numbers < 0.5 have a neg score; numbers > 0.5 have a positive score.
*/
double raw_norminv(double q) {
if (q == .5)
return 0;
q = 1.0 - q;
double p = (q > 0.0 && q < 0.5) ? q : (1.0 - q);
double t = sqrt(log(1.0 / pow(p, 2.0)));
double c0 = 2.515517;
double c1 = 0.802853;
double c2 = 0.010328;
double d1 = 1.432788;
double d2 = 0.189269;
double d3 = 0.001308;
double x = t
- (c0 + c1 * t + c2 * pow(t, 2.0))
/ (1.0 + d1 * t + d2 * pow(t, 2.0) + d3 * pow(t, 3.0));
if (q > .5)
x *= -1.0;
return x;
}
double get_random_ratio() {
static unsigned seed = system_clock::now().time_since_epoch().count();
static mt19937 randomizer(seed);
unsigned n = static_cast<unsigned>(randomizer()) % 1000000000u;
return n / 1000000000.0;
}
/**
* Return the cumulative probability that a number will be equal or less than
* the specified number, where probability is a classic bell curve with range
* 0..1.
*/
double norminv(double q) {
return raw_norminv(q) + 0.5;
}
/**
* Return the cumulative probability that a number will be equal or less than
* the specified number, given a classic bell curve with the specified mean
* and stddev. Unlike raw_norminv, this func returns no negative values, so
* the probability at the right side of the curve approaches 1.0, and the
* probability at the left side approaches 0.0.
*/
double norminv(double q, double mean, double stddev) {
// Assume 7 std deviations encompasses everything interesting.
double lower_bound = mean - 3.5 * stddev;
if (q < lower_bound) {
return 0.0;
}
double upper_bound = lower_bound + (7.0 * stddev);
if (q > upper_bound) {
return 1.0;
}
double range = upper_bound - lower_bound;
// Map q into a proportional spot in the canonical range.
double ratio = (q - lower_bound) / range;
return norminv(ratio);
}
double probability_of_war() {
// low but rising slightly over time
return norminv(0.2 * get_random_ratio());
}
double probability_that_market_will_tank() {
// low but rising slightly over time; higher than war
return 1.5 * norminv(0.5 * get_random_ratio());
}
double probability_that_competitor_will_implode() {
// random, uniform
return get_random_ratio();
}
double probability_of_competitor_quantum_leap() {
// low but rising slightly over time
return norminv(min(0.3 + get_random_ratio(), 0.6));
}
double probability_of_quantum_leap() {
// sawtooth
auto raw = get_random_ratio();
return (raw > 0.5) ? 1.0 - raw : raw *= 0.4;
}
double day_of_week_influence() {
return norminv(get_random_ratio());
}
double time_of_day_influence() {
auto raw = get_random_ratio();
if (raw < 0.33) {
return raw * .2;
} else if (raw > 0.65) {
return raw * .3;
} else if (raw < 0.5) {
return max(1.0, raw * 2);
}
return raw;
}
double probability_of_gvt_shutdown() {
double raw = get_random_ratio();
if (raw < 0.25) {
raw = 0;
}
if (raw < 0.75) {
raw = min(1.0, raw * 2);
}
return norminv(raw);
}
int main(int argc, char ** argv) {
if (argc > 1 && (argv[1][0] == '-' || argv[1][0] == '?')) {
printf("monte -- simulate ticker price under various scenarios\n");
return 0;
}
double initial_price = 37.50;
double timeframe = get_random_ratio();
double multiplier = 1.0
+ probability_of_quantum_leap()
- (probability_of_competitor_quantum_leap()
- probability_that_competitor_will_implode() * 0.5)
- (probability_that_market_will_tank() + 0.5)
- (probability_of_war());
multiplier = multiplier
* (0.5 + day_of_week_influence())
* (0.5 + time_of_day_influence())
* timeframe;
// Sanity filter
if (multiplier < 0.35) {
multiplier = 1.0 - multiplier;
}
while (multiplier > 2.5) {
multiplier = norminv(multiplier, 1.5, 1);
}
double simulated_price = initial_price * (1.0 + multiplier);
printf("%.2f\n", simulated_price);
return 0;
}
|
ec98d2339688be49735dd585cdaff8532c85cb1c
|
632550c5897f9f9a838ee055f02a5b537f3e0f8a
|
/Stmt.cpp
|
d3cb03082f2e76290b9679a3081dfb6eac08e5c4
|
[] |
no_license
|
AymanAzzam/Cplus
|
485ae9e38d80e0adf0ffce0e3a5928f60b0ad0b9
|
81a2b3c32cbdc629009b1021a40e0e363b36cef1
|
refs/heads/main
| 2023-05-26T16:44:43.772517
| 2021-06-10T19:03:49
| 2021-06-10T19:03:49
| 371,521,308
| 0
| 1
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 200
|
cpp
|
Stmt.cpp
|
#include "Stmt.h"
#include <iostream>
using namespace std;
Stmt::Stmt(Node *s) {
stmt = s;
}
void Stmt::execute() {
if (stmt)
stmt->execute();
}
Stmt::~Stmt() {
delete stmt;
}
|
9b3411ff90e635998dc10014fff890d36dbadcaf
|
91c505c8d7c73d6f4d27e922cfa6bebcdbd30264
|
/include/bby/metaprogram/variadic_wrap.cc
|
d467347a74fd7f1dce2e7ca01eb8168cb2728d88
|
[] |
no_license
|
danielmevi/bby
|
27c62eb8830daff5c8d1e10346341897468de029
|
b76aa3f9b0220f234062f943d8b38e730fb28c07
|
refs/heads/master
| 2023-04-11T02:32:27.162033
| 2021-04-13T03:20:46
| 2021-04-23T02:17:04
| 190,762,252
| 1
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 334
|
cc
|
variadic_wrap.cc
|
#include <initializer_list>
#include <iostream>
template <typename T> void print_impl(T &t) { std::cout << t << '\n'; }
template <typename... T> void print(const T &... t) {
(void)std::initializer_list<int>{(print_impl(t), 0)...};
}
int main(const int, const char *const[]) {
print("Hello", 1, 3, 5.5, "World");
return 1;
}
|
217a0d9b6f8e00d98062f197b8976edbf023ecff
|
95d152746743a0032ed3e7bbe0dadd5e1f1582e9
|
/tomau.cpp
|
d2fa3a44fc03eb1847b6379b945fa52d12836af0
|
[] |
no_license
|
tatphong/OLP
|
f9fa08c7827029f1b4a4e28645f975bf9703d9b8
|
9d41a9181bb6bb369d518948697b5d5a27ed135a
|
refs/heads/master
| 2021-11-08T03:59:59.314925
| 2021-11-06T10:20:42
| 2021-11-06T10:20:42
| 196,706,189
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 3,558
|
cpp
|
tomau.cpp
|
#include <bits/stdc++.h>
using namespace std;
typedef pair<int, int> ii;
int n, a[10000][10000], mau = 0;
ii dem[10000];
string s[10000];
vector <int> bancolor[10000];
void nhap()
{
freopen("TOMAU.INP", "r", stdin);
cin >> n;
for (int i = 0; i < n; ++i)
cin >> s[i];
for (int i = 0; i < n; ++i)
for (int j = 0; j < n; ++j)
{
cin >> a[i][j];
}
}
bool cmp(ii a, ii b)
{
return a.second > b.second;
}
int tomau(int x)
{
int m = 1;
for (m = 1; m <= mau + 1; ++m)
{
bool color_banned=false;
for (int i =0; i < bancolor[x].size(); ++i)
{
if (bancolor[x][i] == m)
{color_banned=true;break;}
}
if (!color_banned)
{mau = max(mau, m);return m;}
}
}
void update_nutlienket(int x, int color)
{
for (int i = 0; i < n; ++i)
if (a[i][x] == 1)
{
--dem[i].second;
bancolor[i].push_back(color);
}
}
int main()
{
ios_base::sync_with_stdio(0);
cin.tie(0);
nhap();
//count rank
for (int i = 0; i < n; ++i)
for (int j = 0; j < n; ++j)
{
if (a[i][j])
{
dem[i].first = i;
++dem[i].second;
}
}
//solve
sort(dem, dem + n, cmp);
while (n-- > 0)
{
int color = tomau(dem[0].first);
update_nutlienket(dem[0].first, color);
dem[0].second = 0;
sort(dem, dem + n, cmp);
}
//result
// freopen("tomau.out","w",stdout);
cout<<endl<< mau << endl;
return 0;
}
//toi uu con sai******************************************
#include <bits/stdc++.h>
using namespace std;
typedef pair<int, int> ii;
int n, a[10000][10000], mau = 0, flagmax;
bool bancolor[10000][1000];
ii dem[10000];
string s[10000];
//vector <int> ;
void nhap()
{
freopen("tomau.inp", "r", stdin);
cin >> n;
for (int i = 0; i < n; ++i)
cin >> s[i];
for (int i = 0; i < n; ++i)
for (int j = 0; j < n; ++j)
{
cin >> a[i][j];
}
}
bool cmp(ii a, ii b)
{
return a.second > b.second;
}
int tomau(int x)
{
int m = 1;
for (m = 1; m <= mau + 1; ++m)
{
cout<<x<<" "<<m<<" "<<bancolor[x][m]<<endl;
if (bancolor[x][m]==0)
{mau = max(mau, m);return m;}
}
}
void update_nutlienket(int x, int color)
{
int tempmax=flagmax;
for (int i = 0; i < n; ++i)
if (a[i][x] == 1)
{
--dem[i].second;
bancolor[i][color]=1;
if (dem[i].second>dem[tempmax].second) tempmax=i;
}
flagmax=tempmax;
cout<<flagmax<<" "<<dem[flagmax].second<<endl;
}
int main()
{
ios_base::sync_with_stdio(0);
cin.tie(0);cout.tie(0);
nhap();
//count rank
for (int i = 0; i < n; ++i)
{
for (int j = 0; j < n; ++j)
{
if (a[i][j]==1)
{
dem[i].first = i;
++dem[i].second;
}
}
// cout<<i<<" "<<dem[i].second<<endl;
}
//solve
sort(dem, dem + n, cmp);
// for (int i=0;i<n;++i)
// cout<<dem[i].first<<" "<<dem[i].second<<endl;
flagmax=0;
int k=n;
while (k-- > 0 && dem[flagmax].second>0)
{
int color = tomau(dem[flagmax].first);
dem[flagmax].second = 0;
update_nutlienket(dem[flagmax].first, color);
// sort(dem, dem + n, cmp);
}
//result
// freopen("tomau.out","w",stdout);
cout<< mau;
return 0;
}
|
81b8a205569eabd51b624419f703d1c4b271c2b8
|
f0a95fab0e582fe5fff0f579ae0e7392193486bd
|
/RAVITEMP.CPP
|
14eeb34d8e49a45ef79ba9d555e96e1c680f8b23
|
[] |
no_license
|
ravikumarmakwana/C-and-CPP-Programs
|
5ed5c6f8dbc525bb1c349e79ee392de34ba7a60e
|
4e227fafb14db02326dbf427bc4bf5ec27055ea2
|
refs/heads/master
| 2022-04-11T12:58:23.990926
| 2020-03-27T11:59:22
| 2020-03-27T11:59:22
| null | 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 293
|
cpp
|
RAVITEMP.CPP
|
#include<stdio.h>
#include<iostream.h>
#include<conio.h>
#include<dos.h>
#include<stdlib.h>
void main()
{
int a;
int b;
clrscr();
while(1)
{
srand(time(0));
a=rand()%100;
b=rand()%100;
gotoxy(a,b);
cout<<"Ravi";
delay(1000);
clrscr();
if(kbhit())
break;
}
getch();
}
|
ec4c82293d5360d2687bf6616cfb959af13c014c
|
9feefb5c19469e528e40c183f45d295d7e3114d0
|
/book/ch03/ch03-2.cpp
|
cbfed52842e0f2fe8f944cb0a20b8df5c748a729
|
[] |
no_license
|
oiu850714/cp2017
|
a3807b1962488cd89f32b6e7d4fe30e14d962583
|
8af99ab586f96a16fc5e167a254ed1abd2fcf2c4
|
refs/heads/master
| 2021-01-19T18:17:24.388880
| 2017-04-25T13:14:41
| 2017-04-25T13:14:41
| 88,352,512
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 663
|
cpp
|
ch03-2.cpp
|
#include <cstring>
#include <cstdio>
#define MAXN 100
int a[MAXN][MAXN];
int main()
{
int n, x, y, tot = 0;
scanf("%d", &n);
memset(a, 0, sizeof(a));
tot = a[x=0][y=n-1] = 1;
while(tot < n*n)
{
while(x+1<n && !a[x+1][y])
a[++x][y] = ++tot;
while(y-1>=0 && !a[x][y-1])
a[x][--y] = ++tot;
while(x-1>=0 && !a[x-1][y])
a[--x][y] = ++tot;
while(y+1<n && !a[x][y+1])
a[x][++y] = ++tot;
}
for(int x = 0; x < n; x++)
{
for(int y = 0; y < n; y++)
{
printf("%4d", a[x][y]);
}
printf("\n");
}
return 0;
}
|
91f1b6aec6bf994a04b2b71cb7498ecede59d86c
|
b0b500980f0fc6902bfd32bcdc05716ae7372de7
|
/ClientGame/AIGoal_BuyResources.h
|
dc1464a4ecdd66e8ce73cc5e8d68baa276dfc290
|
[] |
no_license
|
Gi133/Honours-Project
|
ba31639a95a9ba1ec26d7ee88a57090851cbb155
|
f30ff50c61f45c419c4d0ea5722d0bc58eeb50b6
|
refs/heads/master
| 2021-01-21T22:26:51.267727
| 2015-06-18T15:43:45
| 2015-06-18T15:43:45
| 30,205,845
| 2
| 1
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 525
|
h
|
AIGoal_BuyResources.h
|
#pragma once
#include "AIGoal.h"
class AIGoal_BuyResources :
public AIGoal
{
private:
std::string resourceName;
int resourceIterator, quantity;
unsigned int expectedPrice;
void ReceiveMessage(Message *message);
public:
AIGoal_BuyResources(std::weak_ptr<NPC> _owner, const std::string _resourceName, const unsigned int _quantity, const unsigned int _expectedPrice);
~AIGoal_BuyResources();
void Activate();
int Process();
void Terminate();
std::string GetGoalString();
std::string GetGoalProgressString();
};
|
e333976a602f23490d4216152d129fbda4a21848
|
35f0595998ebf26aea947dde8ecf8f7dc27ca603
|
/first_round/easy/test/test_palindrome_number_9.cpp
|
6b4073b8e5cc058b888096aea8a791d9b661fb9c
|
[
"MIT"
] |
permissive
|
forwardkth/leetcode
|
437d5e80388fc887f90edd4449d85c444709248a
|
f22a16f5bce91d589c689be251f4710bab7580fb
|
refs/heads/master
| 2023-05-10T12:07:44.601103
| 2023-05-07T15:39:37
| 2023-05-07T15:39:37
| 167,970,291
| 1
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 550
|
cpp
|
test_palindrome_number_9.cpp
|
#include "../include/palindrome_number_9.h"
#include <gtest/gtest.h>
//Google Test cases
TEST(Palindrome_Num_Test, Basics)
{
int num0 = 121;
int num1 = -121;
int num2 = 10;
int num3 = -101;
int num4 = 230;
Solution ts;
EXPECT_EQ(ts.isPalindrome(num0), true);
EXPECT_EQ(ts.isPalindrome(num1), false);
EXPECT_EQ(ts.isPalindrome(num2), false);
EXPECT_EQ(ts.isPalindrome(num3), false);
EXPECT_EQ(ts.isPalindrome(num4), false);
}
int main(int argc, char **argv)
{
testing::InitGoogleTest(&argc, argv);
return RUN_ALL_TESTS();
}
|
0b1fee98232ad7512f1c566540c1cc6f898ab51a
|
568fa58296378fa129ab3349adf010daa44ed45b
|
/src/poly/tiling/tiling_strategy_manager_gpu.cc
|
c78f925ecf33084cb8195944eba58a4d520c4883
|
[
"Apache-2.0",
"BSD-3-Clause",
"NCSA",
"X11-distribute-modifications-variant",
"Zlib",
"MIT",
"LicenseRef-scancode-unknown-license-reference",
"Unlicense",
"LLVM-exception",
"BSD-2-Clause"
] |
permissive
|
mindspore-ai/akg
|
37f471badc66de6a831f1f45ad84344f34d23ef2
|
99f33858d6972741748cbfc9ab0bf9600428fef7
|
refs/heads/master
| 2023-07-25T23:03:17.672665
| 2023-07-11T07:33:57
| 2023-07-11T07:33:57
| 274,077,856
| 319
| 36
|
Apache-2.0
| 2021-12-30T13:43:08
| 2020-06-22T08:09:05
|
Python
|
UTF-8
|
C++
| false
| false
| 109,024
|
cc
|
tiling_strategy_manager_gpu.cc
|
/**
* Copyright 2020-2022 Huawei Technologies Co., Ltd
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "./tiling_strategy_manager.h"
#include <algorithm>
#include <numeric>
#include <sstream>
#include <build_module.h>
#include "../../src/include/build_module.h"
#include "./tiling_analyzer.h"
#include "poly/schedule_pass_gpu/register_memory_manager.h"
#include "poly/tiling/tiling_utils.h"
namespace akg {
namespace ir {
namespace poly {
bool TryCombination(int64_t shape_m, int64_t shape_n, const Mma &mma, int64_t factor1, int64_t factor2) {
return (factor1 != 0 && factor2 != 0 && shape_m % factor1 == 0 && shape_n % factor2 == 0 &&
shape_m / factor1 >= mma.m && shape_n / factor2 >= mma.n);
}
void GpuDmaAnalysisStrategy::AddGpuConstraint() {
analyzer_->ForEachAxisTopDown(
[](TileAxis *axis) { axis->TileRestrainToSingleValue(CastIntToExpr(MIN_TILE), TileLevel::CACHE1); });
}
void CastStrategy::AddGpuConstraint() { MarkDataSize(); }
void CastStrategy::AddCpuConstraint() { MarkDataSize(); }
void GemmStrategy::AddGpuConstraint() {
if (!analyzer_->scop_info_.user_config_.GetEnableTensorCore() ||
analyzer_->scop_info_.analysis_result_.GetIsGpuDmaAnalysed() ||
analyzer_->scop_info_.user_config_.GetEnableConvTensorCore()) {
return;
}
Mma mma = analyzer_->scop_info_.analysis_result_.GetMmaMode();
// Step 1. Collect Batch, M, N, K axis info.
std::unique_ptr<Mma> shape = InitGemmShape(mma);
if (shape == nullptr) {
return;
}
if (!analyzer_->scop_info_.user_config_.EnableStitchFusion()) {
analyzer_->scop_info_.user_config_.SetEnableOneDimThread(true);
}
Mma middle_band = {shape->m / SafeDivisor(mma.m), shape->n / SafeDivisor(mma.n), shape->k / SafeDivisor(mma.k)};
std::stringstream ss;
ss << "[Gemm] M = " << shape->m << " N = " << shape->n << " K = " << shape->k << ", middle band = [" << middle_band.m
<< ", " << middle_band.n << ", " << middle_band.k << "]";
analyzer_->GetTileLogger().AppendLog(GPU_MAPPING, ss);
GpuInfo &gpu_info = GpuInfo::GetInstance(analyzer_->scop_info_.user_config_.GetDeviceType());
sm_bytes_ = static_cast<int>(gpu_info.GetMemoryLimitInScope(static_cast<int>(MEM_SCOPE_SHARED)));
sm_bytes_ = (sm_bytes_ / sm_bytes_div_factor_) * sm_bytes_mul_factor_;
reg_bytes_ = static_cast<int>(MAX_REGISTER_PER_THREAD_BLOCK * REGISTER_ALLOC_RATIO);
auto b_axes = analyzer_->GetAxesOfAttr(AttrInfo{AT_GEMM, kDsabi});
auto bo_axes = analyzer_->GetAxesOfAttr(AttrInfo{AT_GEMM, kDsabo});
(void)std::copy(bo_axes.begin(), bo_axes.end(), std::back_inserter(b_axes));
for (auto b_axis : b_axes) {
CHECK(b_axis->range_extent.as<IntImm>()) << "Dynamic shape is not supported in tensor core for now.";
b_axis->TileRestrainToSingleValue(CastIntToExpr(MIN_TILE), CACHE1);
b_axis->TileRestrainToSingleValue(CastIntToExpr(MIN_TILE), CACHE0);
b_axis->thread_constraints.map_min_ = MIN_TILE;
b_axis->thread_constraints.map_extent_ = MIN_TILE;
CHECK(b_axis->range_extent.as<IntImm>());
min_blocks_ /= b_axis->range_extent.as<IntImm>()->value;
ss << "Map batch axis " << b_axis->range_extent.as<IntImm>()->value << " to block.";
analyzer_->GetTileLogger().AppendLog(GPU_MAPPING, ss);
}
min_blocks_ = std::max<int>(1, min_blocks_);
// Step 2. Calculate macro M, N, K tile size.
CalculateMacroMma(*shape, mma);
// Step 3. Calculate possible number of warps.
auto warp_sizes = CalculateNumOfWarps(mma);
std::tie(w0_for_m_, w1_for_n_) = warp_sizes;
middle_band.m /= w0_for_m_;
middle_band.n /= w1_for_n_;
std::string warp_cfg = std::to_string(w0_for_m_) + " " + std::to_string(w1_for_n_);
analyzer_->scop_info_.user_config_.RecordReplaceConfig(WARP_COMPUTE, warp_cfg, MappingType::REPLACE_THREADS);
// Step 4. Set mapping and tiling config.
SetFinalConfig(macro_mma_, mma);
}
std::pair<int64_t, int64_t> GemmStrategy::CalculateNumOfWarps(const Mma &mma) {
int w0 = 1;
int w1 = 1;
int use_local_group = (macro_mma_.m / SafeDivisor(mma.m)) * (macro_mma_.n / SafeDivisor(mma.n));
CHECK_GE(use_local_group, 1);
if (use_local_group > use_local_group_high_) {
default_num_warps_ = default_num_warps_high_;
} else if (use_local_group > 1) {
default_num_warps_ = default_num_warps_low_;
}
std::tie(w0, w1) = GetDivisibleFactorForMN(macro_mma_.m, macro_mma_.n, default_num_warps_, mma);
std::stringstream ss;
ss << "[Gemm] Try warp " << default_num_warps_ << " -> " << w0 << " * " << w1;
analyzer_->GetTileLogger().AppendLog(GPU_MAPPING, ss);
return std::make_pair(w0, w1);
}
std::unique_ptr<Mma> GemmStrategy::InitGemmShape(const Mma &mma) {
auto m_axes = analyzer_->GetAxesOfAttr(AttrInfo{AT_GEMM, kDsami});
auto n_axes = analyzer_->GetAxesOfAttr(AttrInfo{AT_GEMM, kDsani});
auto k_axes = analyzer_->GetAxesOfAttr(AttrInfo{AT_GEMM, kDsaki});
if (m_axes.size() != 1U || n_axes.size() != 1U || k_axes.size() != 1U) {
return nullptr;
}
m_axis_ = m_axes[0];
n_axis_ = n_axes[0];
k_axis_ = k_axes[0];
if (m_axis_->range_extent.as<IntImm>() == nullptr || n_axis_->range_extent.as<IntImm>() == nullptr ||
k_axis_->range_extent.as<IntImm>() == nullptr) {
return nullptr;
}
auto shape_m = m_axis_->range_extent.as<IntImm>()->value;
auto shape_n = n_axis_->range_extent.as<IntImm>()->value;
auto shape_k = k_axis_->range_extent.as<IntImm>()->value;
CHECK_EQ(shape_m % mma.m, 0) << "Shape m " << shape_m << " should be multiples of mma.m " << mma.m
<< " to enable tensor core.";
CHECK_EQ(shape_n % mma.n, 0) << "Shape n " << shape_n << " should be multiples of mma.n " << mma.n
<< " to enable tensor core.";
CHECK_EQ(shape_k % mma.k, 0) << "Shape k " << shape_k << " should be multiples of mma.k " << mma.k
<< " to enable tensor core.";
return std::make_unique<Mma>(Mma{shape_m, shape_n, shape_k});
}
int GemmStrategy::EstimateSharedSize(const Mma &alloc, int dtype) {
std::string a_major = ROW_MAJOR;
std::string b_major = ROW_MAJOR;
auto major_map = analyzer_->scop_info_.analysis_result_.GetMatrixMatmulMajor();
auto matmul_map = analyzer_->scop_info_.analysis_result_.GetMatrixMatmulMap();
for (auto i : matmul_map) {
if (i.second == MATRIX_A) {
CHECK(major_map.find(i.first) != major_map.end());
a_major = major_map[i.first];
} else if (i.second == MATRIX_B) {
CHECK(major_map.find(i.first) != major_map.end());
b_major = major_map[i.first];
}
}
// bank conflit avoid strategy
auto matrix_a_size = a_major == ROW_MAJOR ? (alloc.m * (alloc.k + 16)) : ((alloc.m + 16) * alloc.k);
auto matrix_b_size = b_major == COL_MAJOR ? (alloc.n * (alloc.k + 16)) : ((alloc.n + 16) * alloc.k);
auto matrix_c_size = alloc.m * alloc.n;
auto alloc_shared = (matrix_a_size + matrix_b_size) * dtype; // single op does not alloc shared for matrix_c
std::stringstream ss;
ss << "[Shared] A(" << a_major << "), B(" << b_major << "); This config results matrix_a_size = " << matrix_a_size
<< " matrix_b_size = " << matrix_b_size << " matrix_c_size = " << matrix_c_size
<< " --> alloc shared = " << alloc_shared;
analyzer_->GetTileLogger().AppendLog(GPU_MAPPING, ss);
return static_cast<int>(alloc_shared);
}
int GemmStrategy::EstimateRegisterSize(const Mma &alloc, int dtype) {
auto alloc_reg_unit = std::max<int>(1, dtype / BYTES_PER_REGISTER);
auto matrix_a_size = alloc.m * alloc.k * binary_factor_;
auto matrix_b_size = alloc.n * alloc.k * binary_factor_;
auto matrix_c_size = alloc.m * alloc.n;
auto alloc_reg = (matrix_a_size + matrix_b_size + matrix_c_size) * alloc_reg_unit;
std::stringstream ss;
ss << "[Reg] This config results matrix_a_size = " << matrix_a_size << " matrix_b_size = " << matrix_b_size
<< " matrix_c_size = " << matrix_c_size << " --> alloc reg = " << alloc_reg;
analyzer_->GetTileLogger().AppendLog(GPU_MAPPING, ss);
return static_cast<int>(alloc_reg);
}
void GemmStrategy::CalculateMacroMma(const Mma &shape, const Mma &mma) {
std::stringstream ss;
Mma default_macro_mma = macro_mma_;
Mma macro_mma = {std::min<int>(macro_mma_.m, shape.m), std::min<int>(macro_mma_.n, shape.n),
std::min<int>(macro_mma_.k, shape.k)};
ss << "[Init macro mma]: [" << macro_mma.m << ", " << macro_mma.n << ", " << macro_mma.k << "]";
analyzer_->GetTileLogger().AppendLog(GPU_MAPPING, ss);
while (shape.m % SafeDivisor(macro_mma_.m) != 0 && macro_mma_.m - tile_stride_ >= mma.m) {
macro_mma_.m -= tile_stride_;
}
while (shape.n % SafeDivisor(macro_mma_.n) != 0 && macro_mma_.n - tile_stride_ >= mma.n) {
macro_mma_.n -= tile_stride_;
}
if (shape.m % SafeDivisor(macro_mma_.m) != 0) {
macro_mma_.m /= binary_factor_;
}
if (shape.n % SafeDivisor(macro_mma_.n) != 0) {
macro_mma_.n /= binary_factor_;
}
while (shape.k % SafeDivisor(macro_mma_.k) != 0 && macro_mma_.k / binary_factor_ >= mma.k) {
macro_mma_.k /= binary_factor_;
}
while ((shape.m / SafeDivisor(macro_mma_.m)) * (shape.n / SafeDivisor(macro_mma_.n)) < min_blocks_ &&
macro_mma_.m == default_macro_mma.m && macro_mma_.n == default_macro_mma.n) {
(shape.m < shape.n) ? (macro_mma_.m /= binary_factor_) : (macro_mma_.n /= binary_factor_);
}
if ((shape.m / SafeDivisor(macro_mma_.m)) * (shape.n / SafeDivisor(macro_mma_.n)) < min_blocks_ &&
shape.k % SafeDivisor(macro_mma_.k * binary_factor_) == 0 &&
shape.k / SafeDivisor(macro_mma_.k * binary_factor_) > 1) {
macro_mma_.k *= binary_factor_;
}
if (shape.k == macro_mma_.k) {
g_attrs.Set(kEnableTransferBuffer, air::make_const(Int(int_bit_count_), false));
}
ss << "[Final macro mma]: [" << macro_mma.m << ", " << macro_mma.n << ", " << macro_mma.k << "]";
analyzer_->GetTileLogger().AppendLog(GPU_MAPPING, ss);
}
void GemmStrategy::SetFinalConfig(const Mma ¯o_mma, const Mma &mma) {
std::stringstream ss;
m_axis_->TileRestrainToSingleValue(CastIntToExpr(static_cast<int>(macro_mma.m)), CACHE1);
m_axis_->thread_constraints.map_min_ = w0_for_m_ * w1_for_n_;
m_axis_->thread_constraints.map_extent_ = w0_for_m_ * w1_for_n_;
m_axis_->TileRestrainToSingleValue(CastIntToExpr(static_cast<int>(mma.m)), CACHE0);
n_axis_->TileRestrainToSingleValue(CastIntToExpr(static_cast<int>(macro_mma.n)), CACHE1);
n_axis_->thread_constraints.map_min_ = warp_sizes_;
n_axis_->thread_constraints.map_extent_ = warp_sizes_;
n_axis_->TileRestrainToSingleValue(CastIntToExpr(static_cast<int>(mma.n)), CACHE0);
k_axis_->TileRestrainToSingleValue(CastIntToExpr(static_cast<int>(macro_mma.k)), CACHE1);
k_axis_->thread_constraints.map_min_ = MIN_TILE;
k_axis_->thread_constraints.map_extent_ = MIN_TILE;
k_axis_->TileRestrainToSingleValue(CastIntToExpr(static_cast<int>(mma.k)), CACHE0);
ss << "[Final config] : L1(M, N, K) = " << macro_mma.m << ", " << macro_mma.n << ", " << macro_mma.k;
ss << "; L0(M, N, K) = " << mma.m << ", " << mma.n << ", " << mma.k;
ss << "; Thread(W0, W1, TX) = " << w0_for_m_ << ", " << w1_for_n_ << ", " << warp_sizes_;
analyzer_->GetTileLogger().AppendLog(GPU_MAPPING, ss);
}
const std::pair<int64_t, int64_t> GetTensorCoreDivisibleFactorForMN(int64_t shape_m, int64_t shape_n,
int64_t total_factor, int64_t binary_factor,
const Mma &mma) {
auto SwapWarp = [&shape_m, &shape_n, &mma](int64_t w0, int64_t w1) -> std::pair<int64_t, int64_t> {
int64_t max_w0 = shape_m / SafeDivisor(mma.m);
int64_t max_w1 = shape_n / SafeDivisor(mma.n);
if (static_cast<size_t>(max_w0 - max_w1 > 0) ^ static_cast<size_t>(w0 - w1 > 0)) {
return std::make_pair(w1, w0);
}
return std::make_pair(w0, w1);
};
int64_t w0 = static_cast<int64_t>(std::sqrt(total_factor));
int64_t w1 = total_factor / SafeDivisor(w0);
CHECK_EQ(w0 * w1, total_factor);
std::tie(w0, w1) = SwapWarp(w0, w1);
if (TryCombination(shape_m, shape_n, mma, w0, w1)) {
return std::make_pair(w0, w1);
} else {
while (total_factor > 1) {
CHECK(binary_factor != 0);
total_factor /= binary_factor;
w0 = std::sqrt(total_factor);
w1 = total_factor / SafeDivisor(w0);
CHECK_EQ(w0 * w1, total_factor);
std::tie(w0, w1) = SwapWarp(w0, w1);
if (TryCombination(shape_m, shape_n, mma, w0, w1)) {
return std::make_pair(w0, w1);
}
}
}
return std::make_pair(1, 1);
}
const std::pair<int64_t, int64_t> GemmStrategy::GetDivisibleFactorForMN(int64_t shape_m, int64_t shape_n,
int64_t total_factor, const Mma &mma) {
return GetTensorCoreDivisibleFactorForMN(shape_m, shape_n, total_factor, binary_factor_, mma);
}
void ReduceStrategy::AnalyzeReduceConfig(ReduceDirection direction, int band_index) {
if (!analyzer_->scop_info_.user_config_.EnableStitchFusion()) {
if (reduce_length_ <= reduce_length_limit_) {
analyzer_->scop_info_.user_config_.SetEnableOneDimThread(true);
analyzer_->GetTileLogger().AppendLine(GPU_MAPPING, "ReduceLength <= 32, enable onedim thread.");
}
if ((direction == ReduceDirection::Y && reduce_length_ <= reduce_length_limit_) ||
((direction == ReduceDirection::X || direction == ReduceDirection::ALL) &&
reduce_length_ < reduce_length_limit_)) {
analyzer_->scop_info_.analysis_result_.SetUseGpuReduceLib(false);
analyzer_->GetTileLogger().AppendLine(GPU_MAPPING, "Small Reduction (Y<=32, X<32), disable akg reduce lib.");
}
if (direction == ReduceDirection::X && reduce_length_ < binary_factor_ * reduce_length_limit_ &&
nonreduce_length_ > max_y_z_dim_block_ * max_x_y_dim_thread_) {
analyzer_->scop_info_.analysis_result_.SetUseGpuReduceLib(false);
analyzer_->GetTileLogger().AppendLine(GPU_MAPPING,
"Small Reduction (X<64) and large nonreduction axis (exceeding block and "
"thread limit) , disable akg reduce lib.");
}
}
if (!analyzer_->scop_info_.analysis_result_.GetUseGpuReduceLib()) {
DisableReduceMapping();
} else {
AkgReduceLibStrategyOnGpu(band_index);
}
}
void ReduceStrategy::AddGpuConstraint() {
for (int band_index = 0; band_index < static_cast<int>(analyzer_->RootAxis()->children.size()); ++band_index) {
reduce_axes_ = analyzer_->GetAxesOfAttr(AT_REDUCE_AXIS, band_index);
if (reduce_axes_.empty()) {
continue;
}
if (analyzer_->scop_info_.user_config_.GetThreadConfig() != nullptr &&
analyzer_->scop_info_.user_config_.GetBlockConfig() != nullptr &&
analyzer_->scop_info_.user_config_.GetThreadConfig()->bound > 0 &&
analyzer_->scop_info_.user_config_.GetBlockConfig()->bound > 0) {
continue;
}
size_t depth = 0;
auto HasTranspose = [this](const AttrInfo &info) {
std::string key = info.attr_key;
return key.find(AT_TRANSPOSE) != std::string::npos;
};
reduce_length_ = 1;
nonreduce_length_ = 1;
analyzer_->ForEachAxisTopDown([this, &depth, &band_index, &HasTranspose](TileAxis *axis) {
if (axis->index != band_index && axis != analyzer_->RootAxis()) {
return;
}
if (!has_transpose_) {
has_transpose_ = std::any_of(axis->attrs.begin(), axis->attrs.end(), HasTranspose);
}
if (axis == analyzer_->RootAxis() || axis->is_inner) {
return;
}
++depth;
if (axis->mc_sup) {
(void)injective_axes_.emplace_back(axis);
if (auto ext = axis->range_extent.as<IntImm>()) {
nonreduce_length_ *= ext->value;
}
return;
}
if (auto ext = axis->range_extent.as<IntImm>()) {
reduce_length_ *= ext->value;
} else if (analyzer_->scop_info_.analysis_result_.IsCsrDynamicExtent(axis->range_extent)) {
int rest_thread = total_available_thread_ / analyzer_->scop_info_.analysis_result_.GetCsrFeatLen();
reduce_length_ = std::min(analyzer_->scop_info_.user_config_.GetCsrThreadNum(), rest_thread);
}
if (std::count(reduce_axes_.begin(), reduce_axes_.end(), axis)) {
return;
}
(void)reduce_axes_.emplace_back(axis);
});
all_reduce_ = reduce_axes_.size() == depth;
auto current_outer_bn = analyzer_->scop_info_.analysis_result_.GetOuterBandNode(band_index);
auto direction = current_outer_bn->reduce_direction;
AnalyzeReduceConfig(direction, band_index);
}
}
void ReduceStrategy::DisableReduceMapping() {
bool is_tuning = analyzer_->scop_info_.user_config_.GetIsTuning();
for (auto axis : reduce_axes_) {
axis->block_constraints.map_extent_ = MIN_TILE;
axis->thread_constraints.map_extent_ = MIN_TILE;
if (!is_tuning) {
axis->TileRestrainEntire(TileLevel::CACHE1);
}
}
}
void ReduceStrategy::UpdateThreadRange(bool square_thread) {
auto AlignToPowerOfTwo = [](int64_t original_factor) -> int64_t {
while ((original_factor) & (original_factor - 1)) {
--original_factor;
}
return original_factor;
};
if (square_thread) {
tx_range_.first = AlignToPowerOfTwo(std::min(warp_sizes_, total_injective_size_));
ty_range_.first = AlignToPowerOfTwo(std::min<int64_t>(min_ty_, total_reduce_size_));
tx_range_.second = AlignToPowerOfTwo(
std::min(tx_range_.second,
static_cast<int64_t>(ceil(static_cast<float>(tx_range_.second) / SafeDivisor(ty_range_.first)))));
tx_range_.second = AlignToPowerOfTwo(std::min(tx_range_.second, total_injective_size_));
} else {
if (analyzer_->scop_info_.analysis_result_.GetUseGpuReduceLib()) {
tx_range_.first = AlignToPowerOfTwo(std::min(warp_sizes_, total_reduce_size_));
} else {
tx_range_.first = 1;
}
ty_range_.first = AlignToPowerOfTwo(std::min<int64_t>(min_ty_, total_injective_size_));
tx_range_.second = AlignToPowerOfTwo(
std::min(tx_range_.second,
static_cast<int64_t>(ceil(static_cast<float>(tx_range_.second) / SafeDivisor(ty_range_.first)))));
tx_range_.second = AlignToPowerOfTwo(std::min(tx_range_.second, total_reduce_size_));
}
ty_range_.second = std::min(
ty_range_.second, static_cast<int64_t>(ceil(static_cast<float>(ty_range_.second) / SafeDivisor(tx_range_.first))));
}
void ReduceStrategy::ComputeProperReduceThreads(bool use_local) {
for (auto axis : reduce_axes_) {
for (const auto &attr : axis->attrs) {
if (attr.attr_key != AT_MOD) {
continue;
}
CHECK_NE(attr.attr_value, "");
auto mod_value = StrToDecimalInt64(attr.attr_value);
axis->TileRestrainMod(CastInt64ToExpr(mod_value), TileLevel::CACHE1);
}
if (use_local) {
auto ori_reduce_threads = reduce_threads_;
CHECK(axis->c1_constraints.tile_mod_.as<IntImm>());
auto tile_mod = axis->c1_constraints.tile_mod_.as<IntImm>()->value;
while (tile_mod > reduce_threads_ && tile_mod % SafeDivisor(reduce_threads_) != 0) {
--reduce_threads_;
}
if (ori_reduce_threads / SafeDivisor(reduce_threads_) > binary_factor_) {
reduce_threads_ = ori_reduce_threads;
}
}
}
}
void ReduceStrategy::UpdateReduceThreads(bool square_thread, int64_t min_blocks, bool use_local) {
if (square_thread) {
int coef = 1;
while (coef < max_coef_) {
if (total_reduce_size_ % SafeDivisor(ty_range_.first * coef) == 0 ||
(coef < max_coef_ / binary_factor_ &&
total_reduce_size_ % SafeDivisor(ty_range_.first * coef * binary_factor_) != 0)) {
break;
}
coef *= binary_factor_;
}
reduce_threads_ = ty_range_.first * coef;
injective_threads_ = tx_range_.second / SafeDivisor(coef);
} else {
int coef = 1;
while (coef < max_coef_) {
if (total_reduce_size_ % SafeDivisor(tx_range_.second / SafeDivisor(coef)) == 0 ||
(coef < max_coef_ / binary_factor_ &&
total_reduce_size_ % SafeDivisor((tx_range_.second / SafeDivisor(coef)) / binary_factor_) != 0)) {
break;
}
coef *= binary_factor_;
}
if (analyzer_->scop_info_.analysis_result_.GetUseGpuReduceLib()) {
reduce_threads_ = tx_range_.second / SafeDivisor(coef);
}
injective_threads_ = ty_range_.first * coef;
if (total_reduce_size_ < warp_sizes_) {
// we increase thread y for small reduction cases
while ((coef < max_coef_) && (total_injective_size_ % SafeDivisor(injective_threads_) == 0) &&
(total_injective_size_ / SafeDivisor(injective_threads_) > min_blocks)) {
coef *= binary_factor_;
injective_threads_ = ty_range_.first * coef;
}
}
}
ComputeProperReduceThreads(use_local);
}
void ReduceStrategy::UpdateAxes(int possible_blocks, int default_elem_per_thread) {
if (analyzer_->scop_info_.analysis_result_.GetUseGpuReduceLib()) {
auto original_ept = default_elem_per_thread;
// try to increase thread loop (no more than twice as original)
while (possible_blocks > default_elem_per_thread && default_elem_per_thread != 0 &&
possible_blocks % SafeDivisor(default_elem_per_thread) != 0) {
++default_elem_per_thread;
}
if (original_ept * binary_factor_ < default_elem_per_thread) {
default_elem_per_thread = original_ept;
}
// try to decrease thread loop (no less than half of original)
while (possible_blocks > default_elem_per_thread && default_elem_per_thread != 0 &&
possible_blocks % SafeDivisor(default_elem_per_thread) != 0) {
--default_elem_per_thread;
}
if (default_elem_per_thread * binary_factor_ < original_ept) {
default_elem_per_thread = original_ept;
}
} else {
default_elem_per_thread = 1;
}
std::stringstream ss;
ss << "total_injective_size " << total_injective_size_ << " total_reduce_size " << total_reduce_size_;
analyzer_->GetTileLogger().AppendLog(GPU_MAPPING, ss);
ss << "injective_threads " << injective_threads_ << " reduce_threads " << reduce_threads_;
analyzer_->GetTileLogger().AppendLog(GPU_MAPPING, ss);
ss << "possible_blocks " << possible_blocks << " possible_injective_blocks " << possible_injective_blocks_
<< " possible_reduce_blocks " << possible_reduce_blocks_ << " default_elem_per_thread " << default_elem_per_thread;
analyzer_->GetTileLogger().AppendLog(GPU_MAPPING, ss);
ss << "tx:[" << tx_range_.first << ", " << tx_range_.second << "]; ty:[" << ty_range_.first << ", "
<< ty_range_.second << "]";
analyzer_->GetTileLogger().AppendLog(GPU_MAPPING, ss);
auto inject_len = injective_axes_.size();
for (size_t i = 0; i < inject_len; ++i) {
auto axis_in = injective_axes_[i];
if (axis_in->HasAttr(AT_MOD) && axis_in->c1_constraints.tile_min_.as<IntImm>()->value == MIN_TILE) {
axis_in->TileRestrainLower(CastIntToExpr(reduce_threads_), TileLevel::CACHE1);
}
if (i == inject_len - 1) {
axis_in->thread_constraints.map_min_ = injective_threads_;
axis_in->thread_constraints.map_extent_ = injective_threads_;
axis_in->thread_constraints.item_process_ = MIN_TILE;
} else {
axis_in->thread_constraints.map_min_ = MIN_TILE;
axis_in->thread_constraints.map_extent_ = MIN_TILE;
axis_in->thread_constraints.item_process_ = MIN_TILE;
}
}
for (auto axis : reduce_axes_) {
if (axis->thread_constraints.map_min_ == axis->thread_constraints.map_extent_) {
continue;
}
axis->thread_constraints.map_extent_ = reduce_threads_;
axis->thread_constraints.item_process_ = default_elem_per_thread;
}
}
void ReduceStrategy::CollectReduceAxesInfo() {
for (auto axis : reduce_axes_) {
total_reduce_size_ *= axis->extent_val;
if (axis->block_constraints.map_extent_ == 0) {
possible_reduce_blocks_ *= axis->extent_val;
} else {
possible_reduce_blocks_ *= axis->block_constraints.map_extent_;
}
if (axis->thread_constraints.map_min_ == axis->thread_constraints.map_extent_ &&
axis->thread_constraints.map_extent_ != 0) {
reduce_threads_ *= axis->thread_constraints.map_min_;
}
}
}
void ReduceStrategy::CollectInjectiveAxesInfo() {
for (auto axis : injective_axes_) {
total_injective_size_ *= axis->extent_val;
if (axis->block_constraints.map_extent_ == 0) {
possible_injective_blocks_ *= axis->extent_val;
} else {
possible_injective_blocks_ *= axis->block_constraints.map_extent_;
}
if (axis->thread_constraints.map_min_ == axis->thread_constraints.map_extent_ &&
axis->thread_constraints.map_extent_ != 0) {
injective_threads_ *= axis->thread_constraints.map_min_;
}
}
}
void ReduceStrategy::AkgReduceLibStrategyOnGpu(int band_index) {
// disable atomic-add for bitwise-reduction
auto current_outer_bn = analyzer_->scop_info_.analysis_result_.GetOuterBandNode(band_index);
bool disable_atomic = !analyzer_->scop_info_.user_config_.GetEnableAtomicAdd() ||
current_outer_bn->template_type == Template::BITWISE_REDUCTION;
if (disable_atomic) {
for (auto axis : reduce_axes_) {
axis->block_constraints.map_extent_ = MIN_TILE;
}
}
// disable atomic-add for post reduce tensors
DealWithPostReduceTensors();
if (has_transpose_) {
for (auto axis : reduce_axes_) {
axis->TileRestrainEntire(TileLevel::CACHE1);
axis->block_constraints.map_extent_ = MIN_TILE;
}
}
if (!all_reduce_) {
DealWith4DFusedReduce();
}
total_reduce_size_ = 1;
possible_reduce_blocks_ = 1;
reduce_threads_ = 1;
CollectReduceAxesInfo();
total_injective_size_ = 1;
possible_injective_blocks_ = 1;
injective_threads_ = 1;
CollectInjectiveAxesInfo();
bool is_special_4d = reduce_threads_ != 1 || injective_threads_ != 1;
if (is_special_4d) {
return;
}
auto direction = current_outer_bn->reduce_direction;
bool square_thread = direction == ReduceDirection::Y && analyzer_->scop_info_.analysis_result_.GetUseGpuReduceLib();
bool use_local = UseRegisterMem();
int64_t min_blocks = square_thread ? warp_sizes_ : 512;
int64_t min_elem_per_thread = use_local ? binary_factor_ : 8;
min_ty_ = min_ty_init_;
if (((total_injective_size_ * total_reduce_size_) / min_blocks) / max_x_y_dim_thread_ < min_elem_per_thread) {
min_blocks = warp_sizes_;
min_ty_ = square_thread ? min_ty_ : 1;
}
tx_range_ = {1, max_x_y_dim_thread_};
ty_range_ = {1, max_x_y_dim_thread_};
UpdateThreadRange(square_thread);
max_coef_ =
std::max(ty_range_.second / SafeDivisor(ty_range_.first), tx_range_.second / SafeDivisor(tx_range_.first));
UpdateReduceThreads(square_thread, min_blocks, use_local);
int possible_blocks = static_cast<int>(
ceil(static_cast<float>(((possible_injective_blocks_ * possible_reduce_blocks_) / SafeDivisor(injective_threads_)) /
SafeDivisor(reduce_threads_))));
int proposal = use_local ? 8 : warp_sizes_;
auto default_elem_per_thread =
possible_reduce_blocks_ > 1
? std::max(
std::min<int>(proposal, ((possible_blocks / SafeDivisor(min_blocks) + 1) / binary_factor_) * binary_factor_),
1)
: IsHalfReduce() ? double_warp_size_ : static_cast<int>(SpItemPerThread::FULL);
UpdateAxes(possible_blocks, default_elem_per_thread);
}
const bool ReduceStrategy::UseRegisterMem() {
for (auto &it : analyzer_->buf_info_) {
auto buf = it.second.get();
CHECK(buf != nullptr);
if (buf->scope == TilingMemScope::MEM_SCOPE_LOCAL) {
return true;
}
}
return false;
}
bool ReduceStrategy::IsHalfReduce() {
for (const auto axis : reduce_axes_) {
for (const auto &attr : axis->attrs) {
if (attr.attr_key != AT_REDUCE_AXIS) {
continue;
}
auto red_tensor_name = attr.attr_value;
auto it = axis->data_size.find(red_tensor_name);
if (it != axis->data_size.end() && *std::min_element(it->second.begin(), it->second.end()) == binary_factor_) {
return true;
}
}
}
return false;
}
const void ReduceStrategy::DealWith4DFusedReduce() {
auto mod_axes = analyzer_->GetAxesOfAttr(AT_MOD);
for (auto axis : mod_axes) {
if (axis->HasAttr(AT_REDUCE_AXIS) || axis->mc_sup == 0) {
continue;
}
int last_mod_value = -1;
size_t fuse_axis_size = 1; // count myself
for (const auto &attr : axis->attrs) {
if (attr.attr_key != AT_MOD) {
continue;
}
CHECK_NE(attr.attr_value, "");
last_mod_value = StrToDecimalInt(attr.attr_value);
++fuse_axis_size;
}
if (fuse_axis_size <= max_fuse_size_) {
continue;
}
axis->TileRestrainLower(CastIntToExpr(last_mod_value), TileLevel::CACHE1);
if (last_mod_value > max_x_y_dim_thread_) {
LOG(WARNING) << "Cannot bind axis to " << last_mod_value << " threads, maximal thread number is "
<< max_x_y_dim_thread_
<< ". If fusing more than two axes together, footprint box calculated by isl may not be correct.";
continue;
}
axis->thread_constraints.map_min_ = last_mod_value;
}
}
void ReduceStrategy::DealWithPostReduceTensors() {
std::unordered_set<std::string> post_reduce_tensors;
auto root = analyzer_->RootAxis();
for (const auto &attr : root->attrs) {
if (attr.attr_key != AT_POST_FUSION_REDUCE_TENSOR) {
continue;
}
auto tensor_name = attr.attr_value;
(void)post_reduce_tensors.insert(tensor_name);
}
for (const auto axis : reduce_axes_) {
for (const auto &attr : axis->attrs) {
if (attr.attr_key != AT_REDUCE_AXIS) {
continue;
}
auto red_tensor_name = attr.attr_value;
if (post_reduce_tensors.find(red_tensor_name) == post_reduce_tensors.end()) {
continue;
}
axis->block_constraints.map_min_ = MIN_TILE;
axis->block_constraints.map_extent_ = MIN_TILE;
axis->thread_constraints.item_process_ = static_cast<int64_t>(SpItemPerThread::FULL);
}
}
}
int GpuStrategy::GetLocalAllocBufCount() {
int count = 0;
for (auto &it : analyzer_->buf_info_) {
auto buf = it.second.get();
CHECK(buf);
if (buf->scope == TilingMemScope::MEM_SCOPE_LOCAL) {
count++;
}
}
return count;
}
void GpuStrategy::ApplyConstraintsToBindingSpace() {
auto ParseBindingConstraint = [](const std::string &constraint, size_t max_size) {
std::vector<std::string> sp = akg::common::Split(constraint, ",");
std::vector<int64_t> ret;
for (auto &val : sp) {
if (ret.size() == max_size) {
break;
}
CHECK(!val.empty());
(void)ret.emplace_back(StrToDecimalInt64(val));
}
return ret;
};
std::unordered_set<std::string> thread_keys = {AT_THREAD_MIN, AT_THREAD_MAX, AT_THREAD_MOD};
std::unordered_set<std::string> block_keys = {AT_BLOCK_MIN, AT_BLOCK_MAX, AT_BLOCK_MOD};
for (const auto &attr : analyzer_->RootAxis()->attrs) {
std::vector<int64_t> constraint;
std::vector<TileAxis::MappingConstraint> target;
if (thread_keys.find(attr.attr_key) != thread_keys.end()) {
constraint = ParseBindingConstraint(attr.attr_value, thread_binding_spaces_.size());
target = thread_binding_spaces_;
} else if (block_keys.find(attr.attr_key) != block_keys.end()) {
constraint = ParseBindingConstraint(attr.attr_value, block_binding_spaces_.size());
target = block_binding_spaces_;
}
if (constraint.empty()) {
continue;
}
for (size_t i = 0; i < constraint.size(); ++i) {
if (attr.attr_key.find("MIN") != std::string::npos) {
target[i].map_min_ = std::max<int64_t>(target[i].map_min_, constraint[i]);
} else if (attr.attr_key.find("MAX") != std::string::npos && constraint[i] > 0) {
target[i].map_extent_ = std::min<int64_t>(target[i].map_extent_, constraint[i]);
} else if (attr.attr_key.find("MOD") != std::string::npos) {
target[i].map_mod_ = std::max<int64_t>(1, constraint[i]);
}
}
if (thread_keys.find(attr.attr_key) != thread_keys.end()) {
thread_binding_spaces_ = target;
} else if (block_keys.find(attr.attr_key) != block_keys.end()) {
block_binding_spaces_ = target;
}
}
}
void GpuStrategy::ApplyCustomConstraint() {
// init binding space through template-determined limit
thread_binding_spaces_.clear();
block_binding_spaces_.clear();
for (size_t i = 0; i < thread_limit_.size(); ++i) {
TileAxis::MappingConstraint elem;
elem.map_extent_ = thread_limit_[i];
(void)thread_binding_spaces_.emplace_back(elem);
}
for (size_t i = 0; i < std::min(depth_, block_limit_.size()); ++i) {
TileAxis::MappingConstraint elem;
elem.map_extent_ = block_limit_[i];
(void)block_binding_spaces_.emplace_back(elem);
}
ApplyConstraintsToBindingSpace();
size_t cur_depth = 0;
analyzer_->ForEachAxisTopDown([this, &cur_depth](TileAxis *axis) {
if (axis == analyzer_->RootAxis()) {
return;
}
auto cons = axis->GetConstConstraint(CACHE1);
auto range_extent = axis->GetConstExtent();
auto tile_min = cons.tile_min_.as<IntImm>()->value;
int64_t tile_extent = cons.tile_extent_.as<IntImm>()->value;
auto idx = reverse_binding_ ? cur_depth : (depth_ - 1) - cur_depth;
auto thread_extent = tile_extent;
if (idx < thread_binding_spaces_.size()) {
thread_extent = std::min(thread_extent, thread_binding_spaces_[idx].map_extent_);
thread_binding_spaces_[idx].map_extent_ = thread_extent;
}
auto block_extent = range_extent / SafeDivisor(tile_min);
if (idx < block_binding_spaces_.size()) {
block_extent = std::min<int64_t>(block_extent, block_binding_spaces_[idx].map_extent_);
block_binding_spaces_[idx].map_extent_ = block_extent;
}
auto block_min = block_extent / SafeDivisor(thread_extent);
if (idx < block_binding_spaces_.size()) {
block_min = std::max<int64_t>(block_min, block_binding_spaces_[idx].map_min_);
block_binding_spaces_[idx].map_min_ = block_min;
}
axis->thread_constraints.map_extent_ = thread_extent;
axis->block_constraints.map_extent_ = block_extent;
axis->block_constraints.map_min_ = block_min;
if (idx < thread_binding_spaces_.size()) {
axis->thread_constraints.map_mod_ = thread_binding_spaces_[idx].map_mod_;
}
if (idx < block_binding_spaces_.size()) {
axis->block_constraints.map_mod_ = block_binding_spaces_[idx].map_mod_;
}
++cur_depth;
});
}
const void GpuStrategy::ShowOptions() {
std::stringstream ss;
ss << "Options:\n";
std::string indent = " ";
ss << indent << "[EnableAkgReduceLib]: " << analyzer_->scop_info_.analysis_result_.GetUseGpuReduceLib() << "\n";
ss << indent << "[EnableAtomicAdd]: " << analyzer_->scop_info_.user_config_.GetEnableAtomicAdd() << "\n";
ss << indent << "[EnableStitchFusion]: " << analyzer_->scop_info_.user_config_.EnableStitchFusion() << "\n";
ss << indent << "[EnableMatmul]: " << analyzer_->scop_info_.user_config_.GetEnableMatmul() << "\n";
ss << indent << "[EnableTensorCore]: " << analyzer_->scop_info_.user_config_.GetEnableTensorCore() << "\n";
ss << indent << "[EnableConvTensorCore]: " << analyzer_->scop_info_.user_config_.GetEnableConvTensorCore() << "\n";
ss << indent << "[EnableOneDimThread]: " << analyzer_->scop_info_.user_config_.GetEnableOneDimThread() << "\n";
ss << indent << "[EnableVectorization]: " << analyzer_->scop_info_.user_config_.GetEnableVectorization() << "\n";
ss << indent << "[HasNormalTot]: " << analyzer_->scop_info_.analysis_result_.GetTensorOfTensor() << "\n";
ss << indent << "[HasAtomicTot]: " << !analyzer_->scop_info_.analysis_result_.GetTensorOfTensorStmt().empty() << "\n";
analyzer_->GetTileLogger().AppendLog(GPU_MAPPING, ss);
}
bool GpuStrategy::NeedModifyOrderOfAxis() {
int last_axis = current_outer_bn_->last_axis;
if (last_axis < 0 || last_axis >= static_cast<int>(pending_axes_.size())) {
return false;
}
int real_pos = (static_cast<int>(pending_axes_.size()) - 1) - last_axis;
if (real_pos == 0) {
return false;
}
TileAxis *axis;
int64_t shape;
std::tie(axis, shape) = pending_axes_[static_cast<size_t>(real_pos)];
pending_axes_.erase(pending_axes_.cbegin() + real_pos, pending_axes_.cbegin() + real_pos + 1);
pending_axes_.push_front(std::make_pair(axis, shape));
return true;
}
void GpuStrategy::CountGlobalBufferSize() {
global_buf_size_ = 0;
std::unordered_set<std::string> global_buf_names;
for (auto &it : analyzer_->buf_info_) {
auto buf = it.second.get();
CHECK(buf != nullptr);
if (buf->scope == TilingMemScope::MEM_SCOPE_GM) {
global_buf_names.insert(buf->name);
}
}
for (auto attr : analyzer_->RootAxis()->attrs) {
auto buf = attr.attr_key;
if (global_buf_names.count(buf)) {
global_buf_size_ += StrToDecimalInt(attr.attr_value);
}
}
}
void GpuStrategy::SetInitTiledConfig() {
InitMappingLimit();
if (!analyzer_->scop_info_.user_config_.GetIsTuning()) {
if (template_ == Template::BROADCAST_OP || template_ == Template::CUSTOM_CONFIG) {
BroadcastSpeedup();
} else if (template_ == Template::PAD_OP && !current_outer_bn_->enable_vectorization) {
PadSpeedup();
} else if (template_ == Template::TRANSPOSE_OP) {
TransposeSpeedup();
} else if (template_ == Template::REDUCTION || template_ == Template::BITWISE_REDUCTION) {
use_shared_mem_ = true;
}
}
BuildAxesQueue();
if (analyzer_->scop_info_.user_config_.GetIsTuning()) {
ApplyCustomConstraint();
for (size_t i = 0; i < max_dim_; ++i) {
TileAxis::MappingConstraint pad;
if (i >= thread_binding_spaces_.size()) {
(void)thread_binding_spaces_.emplace_back(pad);
}
if (i >= block_binding_spaces_.size()) {
(void)block_binding_spaces_.emplace_back(pad);
}
}
}
}
bool GpuStrategy::CheckNeedInjectiveSpeedUp() {
std::stringstream ss;
ss << "CheckNeedInjectiveSpeedUp: ";
bool need_injective_speed_up = true;
if ((template_ == Template::PURE_ELEM || template_ == Template::BROADCAST_OP || template_ == Template::EXTERN_CALL ||
(template_ == Template::REDUCTION && !analyzer_->scop_info_.analysis_result_.GetUseGpuReduceLib())) &&
analyzer_->scop_info_.analysis_result_.GetTensorOfTensor()) {
need_injective_speed_up = !NeedModifyOrderOfAxis();
} else {
need_injective_speed_up = global_buf_size_ < max_buf_size_to_speedup_inj_;
}
return need_injective_speed_up;
}
void GpuStrategy::AddGpuConstraint() {
CountGlobalBufferSize();
bool is_first = true;
std::stringstream ss;
for (auto sorted_idx : analyzer_->GetSortedBands()) {
band_index_ = sorted_idx;
current_outer_bn_ = analyzer_->scop_info_.analysis_result_.GetOuterBandNode(band_index_);
SetInitTiledConfig();
ss << "------Band " << band_index_ << ": " << analyzer_->scop_info_.analysis_result_.ShowOpTemplate(template_);
analyzer_->GetTileLogger().AppendLog(GPU_MAPPING, ss);
if (analyzer_->scop_info_.user_config_.GetIsTuning()) return;
// tensor of tensor
bool need_injective_speed_up = CheckNeedInjectiveSpeedUp();
block_count_ = 0;
InnerThreadOuterBlock(is_first);
// For the outer band is multiple filters, set the thread/block configuration according to the operator with the
// highest priority, and other operators cannot change it.
if (!is_first) {
current_outer_bn_->enable_vectorization = false;
continue;
}
if ((template_ == Template::PURE_ELEM || template_ == Template::PARTIAL_ELEM ||
template_ == Template::EXTERN_CALL) &&
need_injective_speed_up) {
InjectiveSpeedup();
}
is_first = false;
if ((template_ == Template::MATMUL || template_ == Template::CONV) &&
analyzer_->scop_info_.user_config_.GetEnableTensorCore()) {
continue;
}
analyzer_->ForEachAxisTopDown([this](TileAxis *axis) {
if (axis == analyzer_->RootAxis()) {
return;
}
if (!current_outer_bn_->enable_vectorization) {
axis->TileRestrainToSingleValue(axis->c1_constraints.tile_min_, TileLevel::CACHE0);
}
});
}
ShowOptions();
}
void GpuStrategy::ThreadConfiguration(ReduceDirection direct, bool use_lib) {
thread_limit_.clear();
if (template_ == Template::CUSTOM_CONFIG) {
auto thread_config = analyzer_->scop_info_.user_config_.GetThreadConfig();
for (size_t i = 0; i < thread_config->bound; ++i) {
auto idx = reverse_binding_ ? ((thread_config->bound - 1) - i) : i;
if (idx >= depth_) {
continue;
}
(void)thread_limit_.emplace_back(thread_config->GetAt(idx).second);
}
} else if (template_ == Template::REDUCTION || template_ == Template::BITWISE_REDUCTION) {
if (direct == ReduceDirection::ALL && !use_lib) {
thread_limit_ = {1};
} else if (analyzer_->scop_info_.analysis_result_.GetCsr() && !use_lib) {
thread_limit_ = {max_x_y_dim_thread_, max_x_y_dim_thread_, max_z_dim_thread_};
} else {
thread_limit_ = {max_x_y_dim_thread_, max_x_y_dim_thread_};
}
} else if (template_ == Template::TRANSPOSE_OP) {
auto max_dim_thread = static_cast<int64_t>(std::floor(std::sqrt(total_available_thread_)));
thread_limit_ = {max_dim_thread, max_dim_thread};
} else if (template_ == Template::MATMUL) {
// This is a naive tiling strategy used in gpu when thread and block configs are already set.
// This strategy will tile up to three inner-most axes to 32 (for thread binding).
if (analyzer_->scop_info_.user_config_.GetEnableTensorCore()) {
thread_limit_ = {warp_sizes_, 16};
} else {
thread_limit_ = {warp_sizes_, 8};
}
} else {
thread_limit_ = {max_x_y_dim_thread_, max_x_y_dim_thread_, max_z_dim_thread_};
}
}
void GpuStrategy::UpdateBlockConfig(ReduceDirection direct, bool use_lib) {
block_limit_.clear();
if (template_ == Template::CUSTOM_CONFIG) {
auto block_config = analyzer_->scop_info_.user_config_.GetBlockConfig();
for (size_t i = 0; i < block_config->bound - 1; ++i) {
if (i >= depth_) {
break;
}
(void)block_limit_.emplace_back(block_config->GetAt(i).second);
}
} else if (template_ == Template::REDUCTION && direct == ReduceDirection::ALL && !use_lib) {
block_limit_ = {1};
} else if (template_ == Template::CONV) {
block_limit_ = {max_x_dim_block_, max_y_z_dim_block_, max_y_z_dim_block_, max_y_z_dim_block_};
} else {
block_limit_ = {max_x_dim_block_, max_y_z_dim_block_, max_y_z_dim_block_};
}
}
void GpuStrategy::InitMappingLimit() {
max_x_y_dim_thread_ = analyzer_->scop_info_.user_config_.GetMaxElemPerThread();
// Determine op template
size_t depth = 0;
analyzer_->ForEachAxisTopDown([this, &depth](const TileAxis *axis) {
if (axis == analyzer_->RootAxis() || axis->index != band_index_) {
return;
}
++depth;
});
depth_ = depth;
if (analyzer_->scop_info_.user_config_.GetThreadConfig() != nullptr &&
analyzer_->scop_info_.user_config_.GetBlockConfig() != nullptr &&
analyzer_->scop_info_.user_config_.GetThreadConfig()->bound > 0 &&
analyzer_->scop_info_.user_config_.GetBlockConfig()->bound > 0) {
template_ = Template::CUSTOM_CONFIG;
} else {
template_ = current_outer_bn_->template_type;
}
ReduceDirection direct = current_outer_bn_->reduce_direction;
bool use_lib = analyzer_->scop_info_.analysis_result_.GetUseGpuReduceLib();
reverse_binding_ = use_lib && direct == ReduceDirection::Y;
ThreadConfiguration(direct, use_lib);
if (template_ != Template::CUSTOM_CONFIG && !analyzer_->scop_info_.user_config_.GetEnableTensorCore()) {
AdjustThreadMappingLimit();
}
// Block configuration
UpdateBlockConfig(direct, use_lib);
}
void GpuStrategy::BuildAxesQueue() {
this->pending_axes_.clear();
analyzer_->ForEachAxisTopDown([this](TileAxis *axis) {
if (axis == this->analyzer_->RootAxis() || axis->index != band_index_) {
return;
}
int extent = static_cast<int>(axis->extent_val);
// When vectorization is enabled, make sure non-vectorization axes' c0 tile equals to 1
if (current_outer_bn_->enable_vectorization) {
axis->TileRestrainToSingleValue(axis->c0_constraints.tile_min_, TileLevel::CACHE0);
}
// For Conv, kh and kw are invalid for pending_axes
if (!axis->is_inner && extent > 0) {
this->pending_axes_.push_front(std::make_pair(axis, extent));
}
// init map extent to shape if they are not modified by other constraints
axis->block_constraints.map_extent_ =
axis->block_constraints.map_extent_ == 0 ? axis->extent_val : axis->block_constraints.map_extent_;
axis->thread_constraints.map_extent_ =
axis->thread_constraints.map_extent_ == 0 ? axis->extent_val : axis->thread_constraints.map_extent_;
if (!axis->mc_sup &&
(!analyzer_->scop_info_.analysis_result_.GetUseGpuReduceLib() || template_ == Template::PARTIAL_ELEM)) {
axis->block_constraints.map_extent_ = 1;
axis->thread_constraints.map_extent_ = 1;
std::stringstream ss;
ss << "Axis " << axis->index << "_" << axis->dim_axis;
if (template_ == Template::PARTIAL_ELEM) {
axis->c1_constraints.tile_extent_ = 1;
ss << " Coincidence = 0 and template = PARTIAL_ELEM, disable block/thread mapping.";
} else {
ss << " Coincidence = 0 and Akg-reduce-lib not enabled, disable block/thread mapping.";
}
analyzer_->GetTileLogger().AppendLog(GPU_MAPPING, ss);
}
});
}
void GpuStrategy::SkipMapping(TileAxis *axis, int64_t shape, std::stringstream &ss, size_t inner_dim,
size_t thread_dim) {
axis->thread_constraints.map_extent_ = 1;
(void)axis->thread_constraints.map_cand_.emplace_back(1);
auto tile = inner_dim < thread_dim ? elem_per_thread_[inner_dim] : 1;
tile = tile == static_cast<int64_t>(SpItemPerThread::AUTO)
? std::min(axis->thread_constraints.item_process_, max_elem_per_thread_)
: tile == static_cast<int64_t>(SpItemPerThread::FULL) ? std::min(shape, max_elem_per_thread_) : 1;
CHECK(axis->c1_constraints.tile_min_.as<IntImm>() && axis->c1_constraints.tile_extent_.as<IntImm>());
auto tile_min = axis->c1_constraints.tile_min_.as<IntImm>()->value;
auto tile_extent = axis->c1_constraints.tile_extent_.as<IntImm>()->value;
if (tile_min == tile_extent && tile_extent != MIN_TILE) {
ss << "tile extent is already determined = " << tile_extent;
analyzer_->GetTileLogger().AppendLog(GPU_MAPPING, ss);
tile = tile_min;
} else {
if (axis->block_constraints.map_extent_ > 1) {
// block.min <= shape / tile <= block.max
tile = std::max(
tile,
std::max<int64_t>(
static_cast<int64_t>(ceil(static_cast<float>(shape) / SafeDivisor(axis->block_constraints.map_extent_))), 1));
} else {
tile = std::min(tile, shape);
}
}
tile = std::max<int64_t>(tile, tile_min);
tile = std::min<int64_t>(tile, tile_extent);
axis->TileRestrainLower(tile, TileLevel::CACHE1);
ss << ", tile = " << tile;
if (axis->mc_sup || analyzer_->scop_info_.analysis_result_.GetUseGpuReduceLib()) {
if (axis->block_constraints.map_extent_ > 1) {
CHECK(tile);
pending_axes_.push_back(std::make_pair(
axis, std::max<int64_t>(static_cast<int64_t>(ceil(static_cast<float>(shape) / SafeDivisor(tile))), 1)));
ss << ", map to block.";
}
}
analyzer_->GetTileLogger().AppendLog(GPU_MAPPING, ss);
}
void GpuStrategy::GreedyMapBlocks(size_t ori_size, size_t block_dim) {
// If all axes for block mapping are element-wise, we can map them in any order
// so we need a greedy algorithm to map the most blocks;
// otherwise, we can simply map from outer to inner in sequence.
std::stringstream ss;
if (template_ == Template::PURE_ELEM || template_ == Template::EXTERN_CALL) {
std::map<int64_t, std::vector<size_t>, std::greater<int64_t>> sorted_by_gcd;
for (size_t i = pending_axes_.size() - 1; i >= ori_size; --i) {
auto block_limit = i == 0 ? max_x_dim_block_ : max_y_z_dim_block_;
auto use = (block_limit > 0 && pending_axes_[i].second > 0)
? TilingAnalyzer::GetLargestDivisor(block_limit, pending_axes_[i].second)
: 1;
if (sorted_by_gcd.find(use) == sorted_by_gcd.end()) {
sorted_by_gcd[use] = {i};
} else {
(void)sorted_by_gcd[use].emplace_back(i);
}
}
for (const auto &it : sorted_by_gcd) {
auto index_list = it.second;
for (const auto &i : index_list) {
if (pending_axes_.size() - i > block_dim) {
auto axis = pending_axes_[i].first;
ss << "axis " << axis->index << "_" << axis->dim_axis
<< " exceeded block dim and should be mapped to block for higher performance, consider flatten";
analyzer_->GetTileLogger().AppendLog(GPU_MAPPING, ss);
continue;
}
(void)indexing_.emplace_back(i);
}
}
} else {
for (size_t i = pending_axes_.size() - 1; i >= ori_size; --i) {
if (pending_axes_[i].second <= 1 && indexing_.size() == block_limit_.size()) {
continue;
}
(void)indexing_.emplace_back(i);
}
}
analyzer_->GetTileLogger().AppendLog(GPU_MAPPING, ss);
}
void GpuStrategy::CheckAlignedUse(int64_t &use, int64_t shape, TileAxis *axis, std::stringstream &ss) {
if (axis->forbid_iso && use != 0 && shape % SafeDivisor(use) != 0) {
auto aligned_use = TilingAnalyzer::GetLargestDivisor(use, shape);
CHECK(aligned_use);
if (aligned_use % SafeDivisor(axis->thread_constraints.map_mod_) != 0) {
return;
}
// balance thread size and code complexity
bool efficient = (use / SafeDivisor(aligned_use) < 4 || activated_threads_ >= warp_sizes_);
ss << ", forbid iso and adjust use: original = " << use << ", adjust to " << aligned_use << " is efficient ? "
<< efficient;
if (efficient) {
use = aligned_use;
}
}
}
void GpuStrategy::MapPendingAxes(size_t ori_size, std::stringstream &ss, size_t thread_dim, bool write_cfg) {
size_t inner_dim = 0;
for (size_t i = 0; i < ori_size; ++i) {
TileAxis *axis;
int64_t shape;
std::tie(axis, shape) = pending_axes_[i];
int64_t rest_threads =
std::min(total_available_thread_ / SafeDivisor(activated_threads_), thread_limit_[thread_cfg_.size()]);
ss << "axis " << axis->index << "_" << axis->dim_axis << " shape = " << shape
<< ", rest_threads = " << rest_threads;
ss << "\n--------> Tile: " << axis->c1_constraints.tile_min_ << "," << axis->c1_constraints.tile_extent_;
ss << "\n--------> Tile0: " << axis->c0_constraints.tile_min_ << "," << axis->c0_constraints.tile_extent_;
ss << "\n--------> Thread: " << axis->thread_constraints.map_min_ << "," << axis->thread_constraints.map_extent_;
ss << "\n--------> Block: " << axis->block_constraints.map_min_ << "," << axis->block_constraints.map_extent_;
if (template_ != Template::CUSTOM_CONFIG) {
rest_threads = std::min(rest_threads, axis->thread_constraints.map_extent_);
}
if ((thread_cfg_.size() >= thread_dim && write_cfg) || inner_dim >= max_dim_) {
ss << ", no thread/dim rests";
SkipMapping(axis, shape, ss, inner_dim, thread_dim);
continue;
}
// For Conv, hi and wi are invalid for thread mapping
if (axis->HasAttr(AttrInfo{AT_CONV, kDsahi}) || axis->HasAttr(AttrInfo{AT_CONV, kDsawi})) {
SkipMapping(axis, shape, ss, inner_dim, thread_dim);
continue;
}
if (rest_threads <= 1) {
if (axis->mc_sup ||
(template_ == Template::REDUCTION && analyzer_->scop_info_.analysis_result_.GetUseGpuReduceLib())) {
if (write_cfg) {
(void)thread_cfg_.emplace_back(1);
}
(void)axis->thread_constraints.map_cand_.emplace_back(1);
thread_cfg_map_[axis] = static_cast<int64_t>(i);
}
SkipMapping(axis, shape, ss, inner_dim, thread_dim);
continue;
}
auto item = elem_per_thread_[inner_dim] == static_cast<int64_t>(SpItemPerThread::AUTO)
? axis->thread_constraints.item_process_
: elem_per_thread_[inner_dim];
item = std::min(item, max_elem_per_thread_);
int64_t use;
if (analyzer_->scop_info_.analysis_result_.IsCsrDynamicExtent(axis->range_extent)) {
use = analyzer_->scop_info_.user_config_.GetCsrThreadNum();
} else {
use = GetThreadSize(rest_threads, inner_dim, shape, item);
ss << ", proposed use = " << use;
if (use >= axis->thread_constraints.map_mod_ && axis->thread_constraints.map_mod_ > 0) {
use = AlignToDivisibleSize(use, axis->thread_constraints.map_mod_);
}
ss << ", thread mod = " << axis->thread_constraints.map_mod_;
if (!write_cfg && thread_cfg_.size() > i) {
use = thread_cfg_[i];
}
}
if (axis->forbid_iso || !analyzer_->scop_info_.user_config_.GetEnableOneDimThread() || !thread_cfg_.empty()) {
// do not align thread usage for threadX with one dim thread enabled
ss << ", check aligned use...";
CheckAlignedUse(use, shape, axis, ss);
}
activated_threads_ *= use;
ss << ", final use = " << use << ", activated threads = " << activated_threads_;
if (write_cfg) {
(void)thread_cfg_.emplace_back(use);
}
(void)axis->thread_constraints.map_cand_.emplace_back(use);
thread_cfg_map_[axis] = static_cast<int64_t>(i);
axis->thread_constraints.map_extent_ = use;
analyzer_->GetTileLogger().AppendLog(GPU_MAPPING, ss);
auto tile = TileAfterThreadMapping(axis, inner_dim, use, item);
if (current_outer_bn_->enable_vectorization && axis->HasAttr(AT_VECTORIZED)) {
CHECK(axis->c0_constraints.tile_min_.as<IntImm>());
auto c0_tile = axis->c0_constraints.tile_min_.as<IntImm>()->value;
if (tile * c0_tile <= shape) {
tile *= c0_tile;
ss << ", vectorized axis, multiply with " << c0_tile;
}
}
CHECK(axis->c1_constraints.tile_mod_.as<IntImm>());
auto tile_mod = axis->c1_constraints.tile_mod_.as<IntImm>()->value;
CHECK(tile);
ss << ", original tile = " << tile << ", tile mod = " << tile_mod;
if (tile >= tile_mod && tile_mod > 0) {
tile = AlignToDivisibleSize(tile, tile_mod);
}
ss << ", final c1 tile = " << tile;
pending_axes_.push_back(std::make_pair(
axis, std::max<int64_t>(static_cast<int64_t>(ceil(static_cast<float>(shape) / SafeDivisor(tile))), 1)));
analyzer_->GetTileLogger().AppendLog(GPU_MAPPING, ss);
++inner_dim;
}
}
void GpuStrategy::InnerThreadOuterBlock(bool write_cfg) {
if (pending_axes_.empty()) {
return;
}
std::stringstream ss;
activated_threads_ = 1;
int64_t activated_blocks = 1;
auto thread_dim = std::min(thread_limit_.size(), max_dim_);
auto block_dim = std::min(block_limit_.size(), max_dim_);
if (analyzer_->scop_info_.user_config_.GetEnableConvTensorCore()) {
block_dim = block_limit_.size();
}
// tile from inner to outer and map to thread
analyzer_->GetTileLogger().AppendLine(GPU_MAPPING, "-----Map to thread-----");
ss << "[Thread Limit]: ";
for (auto l : thread_limit_) {
ss << l << ", ";
}
analyzer_->GetTileLogger().AppendLog(GPU_MAPPING, ss);
size_t ori_size = pending_axes_.size();
MapPendingAxes(ori_size, ss, thread_dim, write_cfg);
indexing_.clear();
if (write_cfg) {
for (size_t i = 0; i < block_dim; ++i) {
(void)block_cfg_.emplace_back(1);
}
}
GreedyMapBlocks(ori_size, block_dim);
// map outer band to block according to predefined indice
analyzer_->GetTileLogger().AppendLine(GPU_MAPPING, "-----Map to block-----");
ss << "[Block Limit]: ";
for (auto l : block_limit_) {
ss << l << ", ";
}
analyzer_->GetTileLogger().AppendLog(GPU_MAPPING, ss);
for (const auto &i : indexing_) {
TileAxis *axis;
int64_t shape;
std::tie(axis, shape) = pending_axes_[i];
auto idx = ((indexing_.size() - 1) - ((pending_axes_.size() - 1) - i));
auto rest_blocks = idx < block_limit_.size() ? std::min(block_limit_[idx], axis->block_constraints.map_extent_) : 1;
rest_blocks = std::min(rest_blocks, shape);
ss << "axis " << axis->index << "_" << axis->dim_axis << " shape = " << shape << ", block_idx = " << idx
<< ", rest blocks = " << rest_blocks;
ss << "\n--------> Tile1: " << axis->c1_constraints.tile_min_ << "," << axis->c1_constraints.tile_extent_;
ss << "\n--------> Thread: " << axis->thread_constraints.map_min_ << "," << axis->thread_constraints.map_extent_;
ss << "\n--------> Block: " << axis->block_constraints.map_min_ << "," << axis->block_constraints.map_extent_;
if (block_count_ >= static_cast<int>(block_dim)) {
ss << "-> No mapping.";
analyzer_->GetTileLogger().AppendLog(GPU_MAPPING, ss);
continue;
}
auto use = 1;
if (rest_blocks > 0 && shape > 1) {
auto aligned_blocks = TilingAnalyzer::GetLargestDivisor(rest_blocks, shape);
ss << "aligned_blocks = " << aligned_blocks << ", rest_blocks = " << rest_blocks;
if (aligned_blocks <= 1 || aligned_blocks * min_elem_for_io_bound_ * double_ < rest_blocks) {
use = rest_blocks;
} else {
use = aligned_blocks;
}
}
if (!write_cfg) {
use = block_cfg_[(pending_axes_.size() - 1) - i];
}
activated_blocks *= use;
ss << ", use = " << use << ", activated blocks = " << activated_blocks;
if (write_cfg) {
block_cfg_[(pending_axes_.size() - 1) - i] = use;
}
(void)axis->block_constraints.map_cand_.emplace_back(use);
block_cfg_map_[axis] = (pending_axes_.size() - 1) - i;
axis->block_constraints.map_extent_ = use;
if (analyzer_->scop_info_.analysis_result_.GetUseGpuReduceLib() || axis->mc_sup) {
++block_count_;
}
auto extent = axis->extent_val;
auto thread_size = axis->thread_constraints.map_extent_;
auto upper = std::max<int64_t>(static_cast<int64_t>(ceil(static_cast<float>(extent) / SafeDivisor(use))), 1);
CHECK(axis->c1_constraints.tile_min_.as<IntImm>());
bool partial_block_and_thread = (axis->c1_constraints.tile_min_.as<IntImm>()->value > upper) && (use > thread_size);
if (!use_shared_mem_ && axis->forbid_iso && axis->extent_val % upper != 0) {
axis->TileRestrainToSingleValue(thread_size, TileLevel::CACHE1);
} else if (partial_block_and_thread) {
axis->TileRestrainToSingleValue(upper, TileLevel::CACHE1);
} else {
axis->TileRestrainUpper(upper, TileLevel::CACHE1);
}
ss << ", tile range = [" << axis->c1_constraints.tile_min_ << ", " << axis->c1_constraints.tile_extent_ << "]";
analyzer_->GetTileLogger().AppendLog(GPU_MAPPING, ss);
}
}
const int64_t GpuStrategy::GetThreadSize(const int64_t rest_threads, size_t inner_dim, const int64_t shape,
const int64_t item) {
// Current experience is that let mapped threads divisible by warp_size to increase performance.
CHECK(item);
int64_t thread_extent = item == SpItemPerThread::FULL
? rest_threads
: static_cast<int64_t>(ceil(static_cast<float>(shape) / SafeDivisor(item)));
thread_extent = std::min(thread_extent, shape);
if (thread_extent > rest_threads || template_ == Template::CUSTOM_CONFIG) {
return rest_threads;
}
auto proposal = inner_dim == 0 ? ((((thread_extent - 1) + warp_sizes_) / warp_sizes_) * warp_sizes_) : thread_extent;
return std::min(rest_threads, proposal);
}
int64_t GpuStrategy::ApplyCustomTile(TileAxis *axis, size_t inner_dim, int64_t thread_size, int64_t tile,
int64_t shape) {
std::stringstream ss;
if (template_ == Template::CUSTOM_CONFIG) {
if (!analyzer_->scop_info_.user_config_.GetEnableAtomicAdd() &&
(axis->HasAttr(AT_REDUCE_AXIS) || axis->mc_sup == 0)) {
tile = shape;
ss << "tile = shape to disable atomic add, ";
} else if (tile < thread_size) {
tile = thread_size;
ss << "tile = thread size, ";
} else {
int64_t block_dim = reverse_binding_ ? static_cast<int64_t>((block_limit_.size() - 1) - inner_dim)
: static_cast<int64_t>(inner_dim);
int64_t least_blocks;
if (block_dim >= 0 && block_dim < static_cast<int64_t>(block_limit_.size())) {
least_blocks = block_limit_[block_dim];
} else {
least_blocks = std::accumulate(block_limit_.begin(), block_limit_.end(), 1, std::multiplies<int>());
}
auto max_tile = shape / SafeDivisor(least_blocks);
if (thread_size != 0 && shape % SafeDivisor(thread_size) == 0) {
// ensure no if condition in thread for-loop
tile = TilingAnalyzer::GetLargestDivisor(max_tile, shape);
} else {
// ensure thread for-loop bound has no min/max
tile = TilingAnalyzer::GetLargestDivisor(max_tile, thread_size);
}
ss << "reduce tile size to enable at least " << least_blocks << " blocks, ";
}
}
analyzer_->GetTileLogger().AppendLog(GPU_MAPPING, ss);
return tile;
}
int64_t GpuStrategy::TileAfterThreadMapping(TileAxis *axis, size_t inner_dim, int64_t thread_size, const int64_t item) {
std::stringstream ss;
auto shape = axis->extent_val;
CHECK(axis->c1_constraints.tile_min_.as<IntImm>() && axis->c1_constraints.tile_mod_.as<IntImm>() &&
axis->c1_constraints.tile_extent_.as<IntImm>());
auto tile_min = axis->c1_constraints.tile_min_.as<IntImm>()->value;
auto tile_mod = axis->c1_constraints.tile_mod_.as<IntImm>()->value;
auto tile_extent = axis->c1_constraints.tile_extent_.as<IntImm>()->value;
if (tile_min == tile_extent && tile_extent != MIN_TILE) {
ss << "tile extent is already determined = " << tile_extent;
analyzer_->GetTileLogger().AppendLog(GPU_MAPPING, ss);
return tile_extent;
}
auto tile = item == static_cast<int64_t>(SpItemPerThread::FULL)
? std::min(tile_extent, thread_size * max_elem_per_thread_)
: std::min(tile_extent, thread_size * item);
tile = std::max<int64_t>(tile, tile_min);
if (analyzer_->scop_info_.analysis_result_.GetUseGpuReduceLib()) {
if (tile < tile_mod) {
// tile axis with mod value
// e.g. tile cc0 with 128 in the following code
// for cc0 in 1024:
// A[0, floormod(cc0, 256)] = B[floordiv(cc0, 256), floormod(cc0, 256)]
while (tile_mod % SafeDivisor(tile) != 0 && tile > thread_size) {
--tile;
}
} else if (axis->forbid_iso) {
// tile axis with div value
// e.g. tile cc0 with 512 in the following code (which equals tile floordiv(cc0, 256) with 2)
// for cc0 in 1024:
// A[0, floormod(cc0, 256)] = B[floordiv(cc0, 256), floormod(cc0, 256)]
while (shape % SafeDivisor(tile) != 0 && tile > thread_size) {
--tile;
}
}
}
bool partial_block = (shape / SafeDivisor(tile) <= 1 && shape > tile);
if (partial_block) {
tile = shape;
}
tile = ApplyCustomTile(axis, inner_dim, thread_size, tile, shape);
ss << "axis " << axis->index << "_" << axis->dim_axis << " elem_per_thread = " << item << ", tile = " << tile;
analyzer_->GetTileLogger().AppendLog(GPU_MAPPING, ss);
axis->TileRestrainLower(CastInt64ToExpr(tile), TileLevel::CACHE1);
return tile;
}
void GpuStrategy::AdjustThreadMappingLimit() {
std::stringstream ss;
std::vector<int64_t> map_mins;
ss << "Original thread limit = ";
for (auto tl : thread_limit_) {
ss << tl << ", ";
}
analyzer_->GetTileLogger().AppendLog(GPU_MAPPING, ss);
analyzer_->ForEachAxisTopDown([this, &map_mins](TileAxis *axis) {
if (axis == this->analyzer_->RootAxis()) {
return;
}
if (!axis->mc_sup && !analyzer_->scop_info_.analysis_result_.GetUseGpuReduceLib()) {
return;
}
(void)map_mins.emplace_back(axis->thread_constraints.map_min_);
});
std::reverse(map_mins.begin(), map_mins.end());
auto map_size = thread_limit_.size();
for (size_t i = 0; i < map_mins.size(); ++i) {
if (i > map_size) {
continue;
}
for (size_t j = 0; j < map_size; ++j) {
if (j == i) {
continue;
}
int64_t res = static_cast<int64_t>(floor(static_cast<float>(thread_limit_[j]) / SafeDivisor(map_mins[i])));
thread_limit_[j] = res;
}
}
ss << "Adjust thread limit by axes' mapping mins = ";
for (auto tl : thread_limit_) {
ss << tl << ", ";
}
analyzer_->GetTileLogger().AppendLog(GPU_MAPPING, ss);
}
void GpuStrategy::WriteConfigBackInjective() {
std::stringstream ss;
for (size_t i = 0; i < injective_axes_.size(); ++i) {
ss << "replace block " << block_cfg_[i] << " with " << injective_axes_[i]->block_constraints.map_extent_
<< " replace thread " << thread_cfg_[(injective_axes_.size() - 1) - i] << " with "
<< injective_axes_[i]->thread_constraints.map_extent_;
analyzer_->GetTileLogger().AppendLog(GPU_MAPPING, ss);
block_cfg_[i] = injective_axes_[i]->block_constraints.map_extent_;
injective_axes_[i]->block_constraints.map_cand_.clear();
injective_axes_[i]->block_constraints.map_cand_.push_back(block_cfg_[i]);
if (g_csr.empty()) {
thread_cfg_[(injective_axes_.size() - 1) - i] = injective_axes_[i]->thread_constraints.map_extent_;
injective_axes_[i]->thread_constraints.map_cand_.clear();
injective_axes_[i]->thread_constraints.map_cand_.push_back(thread_cfg_[(injective_axes_.size() - 1) - i]);
}
}
}
std::pair<int64_t, int64_t> GpuStrategy::GetProposalParallelSize(int problem_size) {
int64_t block_size = 1;
int64_t thread_size = 1;
thread_coef_ = thread_coef_init_;
if (problem_size <= warp_sizes_) {
thread_size = warp_sizes_;
} else if (problem_size <= warp_sizes_ * num_sm_) {
thread_size = warp_sizes_;
block_size = num_sm_;
} else if (problem_size <= warp_sizes_ * thread_coef_.first * num_sm_ * active_blocks_per_sm_.first) {
thread_size = TilingAnalyzer::GetLargestDivisor(warp_sizes_ * thread_coef_.first, problem_size);
block_size = num_sm_ * active_blocks_per_sm_.first;
} else if (problem_size <= warp_sizes_ * thread_coef_.second * num_sm_ * active_blocks_per_sm_.second) {
thread_size = TilingAnalyzer::GetLargestDivisor(warp_sizes_ * thread_coef_.second, problem_size);
block_size = num_sm_ * active_blocks_per_sm_.second;
} else if (problem_size <= warp_sizes_ * thread_coef_.second * num_sm_ * active_blocks_per_sm_.second * num_sm_) {
thread_size = total_available_thread_;
block_size = num_sm_ * active_blocks_per_sm_.second;
} else {
// extremely large shape
thread_size = total_available_thread_;
block_size = num_sm_ * active_blocks_per_sm_.second * double_;
}
return std::make_pair(block_size, thread_size);
}
int64_t GpuStrategy::AlignThreadToShape() {
std::stringstream ss;
// sum of threadIdx.x, threadIdx.y and threadIdx.z
auto total_threads = std::accumulate(thread_cfg_.begin(), thread_cfg_.end(), 1, std::multiplies<int>());
for (size_t i = 0; i < injective_axes_.size(); ++i) {
auto axis = injective_axes_[i];
auto shape = axis->extent_val;
CHECK(axis->c1_constraints.tile_extent_.as<IntImm>());
auto tile_size = axis->c1_constraints.tile_extent_.as<IntImm>()->value;
auto thread_size = axis->thread_constraints.map_extent_;
if (shape % SafeDivisor(thread_size) == 0) {
continue;
}
int64_t lower = analyzer_->GetLargestDivisor(thread_size, shape);
bool is_invalid = (lower % SafeDivisor(axis->thread_constraints.map_mod_ != 0));
if (is_invalid) {
ss << "thread size is invalid: " << lower << " % " << axis->thread_constraints.map_mod_ << " != 0";
continue;
}
// The modified thread_size cannot be reduced to half of the original thread_size
// The modified total thread_size cannot be reduced to half of 1024
bool is_efficient = lower * binary_factor_ > thread_size ||
((total_threads / SafeDivisor(thread_size)) * lower) * binary_factor_ >= max_x_y_dim_thread_;
if (is_efficient) {
ss << "align thread from " << thread_size << " to " << lower << " according to shape " << shape;
analyzer_->GetTileLogger().AppendLog(GPU_MAPPING, ss);
axis->thread_constraints.map_extent_ = lower;
total_threads = (total_threads / SafeDivisor(thread_size)) * lower;
auto thread_loop = std::max<int>(1, tile_size / SafeDivisor(thread_size));
tile_size = std::min(shape, thread_loop * lower);
CHECK(axis->c1_constraints.tile_mod_.as<IntImm>());
auto tile_mod = axis->c1_constraints.tile_mod_.as<IntImm>()->value;
if (tile_size % SafeDivisor(tile_mod) != 0) {
ss << "tile size is invalid: " << tile_size << " % " << tile_mod << " != 0";
continue;
}
axis->TileRestrainToSingleValue(tile_size, TileLevel::CACHE1);
CHECK(tile_size);
axis->block_constraints.map_extent_ =
static_cast<int64_t>(ceil(static_cast<float>(shape) / SafeDivisor(tile_size)));
}
}
analyzer_->GetTileLogger().AppendLog(GPU_MAPPING, ss);
WriteConfigBackInjective();
return total_threads;
}
void GpuStrategy::HandleShrinkThreadToBlock(int64_t &shrinked_threads, bool thread_to_block, std::stringstream &ss) {
if (thread_to_block) {
for (auto axis : injective_axes_) {
if (shrinked_threads <= 0) {
break;
}
auto thread_size = axis->thread_constraints.map_extent_;
auto block_size = axis->block_constraints.map_extent_;
CHECK(axis->c1_constraints.tile_extent_.as<IntImm>());
auto tile_size = axis->c1_constraints.tile_extent_.as<IntImm>()->value;
auto coef = TilingAnalyzer::GetLargestDivisor(shrinked_threads, thread_size);
CHECK(coef != 0);
shrinked_threads /= SafeDivisor(coef);
axis->thread_constraints.map_extent_ = thread_size / SafeDivisor(coef);
axis->block_constraints.map_extent_ = block_size * coef;
axis->TileRestrainToSingleValue(tile_size / SafeDivisor(coef), TileLevel::CACHE1);
ss << "axis " << axis->dim_axis << " before shrink " << thread_size << " shrink size " << coef;
}
}
}
void GpuStrategy::InjectiveSpeedup() {
// not need speedup if thread_cfg_ or block_cfg_ is empty
if (thread_cfg_.size() == 0 || block_cfg_.size() == 0) {
return;
}
analyzer_->GetTileLogger().AppendLine(GPU_MAPPING, "InjectiveSpeedup");
std::stringstream ss;
injective_axes_.clear();
auto problem_size = 1;
auto curr_elem_size = 1;
analyzer_->ForEachAxisTopDown([this, &problem_size, &curr_elem_size](TileAxis *axis) {
if (axis == analyzer_->RootAxis() || axis->range_extent.as<IntImm>() == nullptr || axis->is_inner ||
axis->index != band_index_) {
return;
}
(void)injective_axes_.emplace_back(axis);
problem_size *= static_cast<int>(axis->extent_val);
curr_elem_size *= axis->thread_constraints.item_process_;
});
// Step 1. Reduce code complexity by aligning thread size to shape
int64_t total_threads = AlignThreadToShape();
// Step 2. Adjust the ratio of thread for-loop, thread size and block size.
if (!injective_axes_.size()) {
return;
}
auto coaleasced_size = injective_axes_.back()->thread_constraints.map_extent_;
auto total_blocks = std::accumulate(block_cfg_.begin(), block_cfg_.end(), 1, std::multiplies<int>());
auto parallel_size = GetProposalParallelSize(problem_size);
auto proposal_blocks = parallel_size.first;
auto proposal_threads = parallel_size.second;
auto proposal_elem_per_thread =
coaleasced_size < warp_sizes_ ? 1 : total_blocks < proposal_blocks * 8 ? min_elem_for_io_bound_ : 8;
proposal_elem_per_thread = proposal_elem_per_thread / SafeDivisor(curr_elem_size);
CHECK(proposal_threads != 0 && total_blocks != 0);
int64_t shrinked_threads =
std::min<int64_t>(total_threads / SafeDivisor(proposal_threads), proposal_blocks / SafeDivisor(total_blocks));
int64_t shrinked_blocks = (total_blocks - 1 + proposal_blocks) / SafeDivisor(proposal_blocks);
auto thread_to_block = shrinked_threads > 0 && total_blocks < proposal_blocks;
auto block_to_elem = proposal_elem_per_thread > 0 && shrinked_blocks > 0;
auto thread_to_elem = proposal_elem_per_thread > 0 && !block_to_elem && shrinked_threads > 0 &&
total_blocks * shrinked_threads > proposal_blocks * proposal_elem_per_thread;
ss << "problem_size = " << problem_size << " coaleasced_size = " << coaleasced_size
<< " total_blocks = " << total_blocks << " total_threads = " << total_threads
<< " proposal_blocks = " << proposal_blocks << " proposal_threads = " << proposal_threads
<< " proposal_elem_per_thread = " << proposal_elem_per_thread << " shrinked_threads = " << shrinked_threads
<< " shrinked_blocks = " << shrinked_blocks;
analyzer_->GetTileLogger().AppendLog(GPU_MAPPING, ss);
ss << "Parallel size = [" << proposal_blocks << ", " << proposal_threads << "]";
analyzer_->GetTileLogger().AppendLog(GPU_MAPPING, ss);
HandleShrinkThreadToBlock(shrinked_threads, thread_to_block, ss);
if (block_to_elem || thread_to_elem) {
for (auto axis : injective_axes_) {
auto shrink_limit = block_to_elem ? shrinked_blocks : shrinked_threads;
if (shrink_limit <= 0) {
break;
}
CHECK(axis->c1_constraints.tile_extent_.as<IntImm>());
auto tile_size = axis->c1_constraints.tile_extent_.as<IntImm>()->value;
auto before_shrink = block_to_elem ? axis->block_constraints.map_extent_ : axis->thread_constraints.map_extent_;
auto coef = std::min<int64_t>(proposal_elem_per_thread, shrink_limit);
CHECK(coef);
shrink_limit = std::min<int64_t>(shrink_limit, before_shrink);
int64_t aligned_coef = TilingAnalyzer::GetLargestDivisor(shrink_limit, before_shrink);
ss << "\nTo elem: before shrink = " << before_shrink << " shrink limit " << shrink_limit
<< " aligned_coef = " << aligned_coef;
ss << " origianl coef = " << coef;
if (aligned_coef * binary_factor_ > coef || axis->forbid_iso) {
coef = aligned_coef;
}
ss << " final coef = " << coef << "\n";
if (block_to_elem) {
auto before_shrink_limit = std::max<int64_t>(before_shrink / SafeDivisor(coef), 1);
auto actual_block = TilingAnalyzer::GetLargestDivisor(before_shrink_limit, before_shrink);
auto actual_coef = before_shrink / SafeDivisor(actual_block);
if (actual_coef > shrink_limit) {
ss << "actual shrink = " << actual_coef << "exceed shrink limit: " << shrink_limit << ", continue.";
continue;
}
ss << "block_to_elem: \n"
<< shrinked_blocks << " /= " << coef << "\n block = " << before_shrink << " / " << coef << " = "
<< axis->block_constraints.map_extent_ << ", curr actual_coef = " << actual_coef << "\n";
coef = actual_coef;
shrinked_blocks /= SafeDivisor(coef);
axis->block_constraints.map_extent_ = actual_block;
} else {
shrinked_threads /= coef;
axis->thread_constraints.map_extent_ = before_shrink / SafeDivisor(coef);
}
ss << "axis " << axis->dim_axis << " before shrink " << before_shrink << " shrink size " << coef;
axis->TileRestrainToSingleValue(tile_size * coef, TileLevel::CACHE1);
}
}
WriteConfigBackInjective();
analyzer_->GetTileLogger().AppendLog(GPU_MAPPING, ss);
}
const void GpuStrategy::TransposeSpeedup() {
analyzer_->GetTileLogger().AppendLine(GPU_MAPPING, "TransposeSpeedup");
if (!analyzer_->scop_info_.user_config_.EnableStitchFusion()) {
analyzer_->scop_info_.user_config_.SetEnableOneDimThread(true);
}
current_outer_bn_->use_shared_memory = true;
auto inner_axes = analyzer_->GetAxesOfAttr(AT_TRANSPOSE_INNERMOST_AXIS);
if (inner_axes.size() == 1) {
inner_axes[0]->TileRestrainLower(tranpose_tiling_constraints_, TileLevel::CACHE1);
inner_axes[0]->thread_constraints.item_process_ = min_elem_for_io_bound_;
} else {
std::vector<TileAxis *> axes;
auto problem_size = 1;
auto curr_size = 1;
analyzer_->ForEachAxisTopDown([this, &axes, &problem_size, &inner_axes, &curr_size](TileAxis *axis) {
if (axis == analyzer_->RootAxis() || axis->range_extent.as<IntImm>() == nullptr || axis->index != band_index_) {
return;
}
(void)axes.emplace_back(axis);
problem_size *= static_cast<int>(axis->extent_val);
if (find(inner_axes.begin(), inner_axes.end(), axis) != inner_axes.end()) {
curr_size *= tranpose_tiling_constraints_;
}
});
auto parallel_size = GetProposalParallelSize(problem_size);
auto proposal_blocks = parallel_size.first;
auto total_elem_for = problem_size / SafeDivisor(curr_size * proposal_blocks);
std::stringstream ss;
ss << "Propose block size = " << proposal_blocks << ", curr size = " << curr_size
<< " problem size = " << problem_size << ", min_elem_for_io_bound_=" << min_elem_for_io_bound_
<< ", total_elem_for = " << total_elem_for;
auto cur_elem_for = 1;
for (int i = static_cast<int>(axes.size()) - 1; i >= 0; --i) {
if (total_elem_for / SafeDivisor(cur_elem_for) <= 1) {
ss << "stop allocate elem for at axis " << i;
break;
}
auto axis = axes[i];
if (find(inner_axes.begin(), inner_axes.end(), axis) != inner_axes.end()) {
axis->TileRestrainLower(tranpose_tiling_constraints_, TileLevel::CACHE1);
axis->thread_constraints.item_process_ = min_elem_for_io_bound_;
cur_elem_for *= min_elem_for_io_bound_;
} else {
axis->TileRestrainUpper(MIN_TILE, TileLevel::CACHE1);
}
}
analyzer_->GetTileLogger().AppendLog(GPU_MAPPING, ss);
}
}
void GpuStrategy::PadSpeedup() {
analyzer_->GetTileLogger().AppendLine(GPU_MAPPING, "PadSpeedup");
std::stringstream ss;
int64_t problem_size = 1;
std::vector<TileAxis *> axes;
analyzer_->ForEachAxisTopDown([this, &problem_size, &axes](TileAxis *axis) {
if (axis == analyzer_->RootAxis() || axis->range_extent.as<IntImm>() == nullptr || axis->index != band_index_) {
return;
}
problem_size *= axis->extent_val;
(void)axes.emplace_back(axis);
});
auto coef = std::max<int64_t>(
1, static_cast<int64_t>((problem_size / warp_sizes_) / SafeDivisor(num_sm_ * active_blocks_per_sm_.first)));
ss << "Total reduce coef = " << coef;
analyzer_->GetTileLogger().AppendLog(GPU_MAPPING, ss);
for (size_t i = axes.size() - 1; i > 0; --i) {
auto axis = axes[i];
axis->thread_constraints.item_process_ =
std::max<int64_t>(min_elem_for_io_bound_, TilingAnalyzer::GetLargestDivisor(coef, axis->extent_val));
CHECK(axis->thread_constraints.item_process_ != 0);
coef = std::max<int64_t>(1, coef / SafeDivisor(axis->thread_constraints.item_process_));
ss << "axis " << axis->index << "_" << axis->dim_axis
<< " set for-loop size = " << axis->thread_constraints.item_process_ << ", update coef = " << coef;
analyzer_->GetTileLogger().AppendLog(GPU_MAPPING, ss);
}
}
void GpuStrategy::BroadcastSpeedup() {
analyzer_->GetTileLogger().AppendLine(GPU_MAPPING, "BroadcastSpeedup");
std::stringstream ss;
if (!analyzer_->scop_info_.user_config_.EnableStitchFusion()) {
analyzer_->scop_info_.user_config_.SetEnableOneDimThread(true);
}
size_t depth = 0;
auto problem_size = 1;
analyzer_->ForEachAxisTopDown([this, &depth, &problem_size](TileAxis *axis) {
if (axis == analyzer_->RootAxis() || axis->range_extent.as<IntImm>() == nullptr || axis->index != band_index_) {
return;
}
++depth;
fused_size_ = axis->extent_val;
problem_size *= axis->extent_val;
});
auto IncreaseForLoop = [this, &depth, &problem_size, &ss]() {
TileAxis *first_axis = nullptr;
TileAxis *last_axis = nullptr;
auto parallel_size = GetProposalParallelSize(problem_size);
auto vectorized_loop_size = analyzer_->scop_info_.analysis_result_.GetVectorizedLoopSize();
analyzer_->ForEachAxisTopDown([this, &depth, &first_axis, &last_axis](TileAxis *axis) {
if (axis == analyzer_->RootAxis() || axis->range_extent.as<IntImm>() == nullptr || axis->index != band_index_) {
return;
}
axis->forbid_iso = true;
if (!axis->HasAttr(AT_BROADCAST_INNERMOST_AXIS) && depth != 1 &&
axis->extent_val > min_elem_for_io_bound_ * max_elem_per_thread_) {
return;
}
if (first_axis == nullptr) {
first_axis = axis;
}
last_axis = axis;
});
TileAxis *axis = nullptr;
if (analyzer_->scop_info_.user_config_.GetEnableOneDimThread()) {
axis = first_axis;
} else {
axis = last_axis;
}
ss << "\nProblem size = " << problem_size << " parallel size = " << parallel_size.first * parallel_size.second
<< " vec size " << vectorized_loop_size;
if (axis != nullptr && (!axis->HasAttr(AT_VECTORIZED) || !current_outer_bn_->enable_vectorization)) {
auto min_aligned = analyzer_->GetLargestDivisor(min_elem_for_io_bound_, axis->extent_val);
auto coef = current_outer_bn_->enable_vectorization ? 1 : double_;
auto max_aligned = analyzer_->GetLargestDivisor(coef * min_elem_for_io_bound_, axis->extent_val);
if (max_aligned > 1 &&
problem_size >= parallel_size.first * parallel_size.second * vectorized_loop_size * max_aligned) {
axis->thread_constraints.item_process_ = max_aligned;
} else if (min_aligned > 1 &&
problem_size >= parallel_size.first * parallel_size.second * vectorized_loop_size * min_aligned) {
axis->thread_constraints.item_process_ = min_aligned;
} else if (problem_size >=
parallel_size.first * parallel_size.second * vectorized_loop_size * min_elem_for_io_bound_) {
axis->thread_constraints.item_process_ = min_elem_for_io_bound_;
}
ss << "\nBroadcast item process = " << axis->thread_constraints.item_process_;
}
analyzer_->GetTileLogger().AppendLog(GPU_MAPPING, ss);
};
// Only deal with broadcast + elemwise cases that all axes are fused into one.
auto mod_axes = analyzer_->GetAxesContainsAttr(AT_MOD);
if (depth != 1 || mod_axes.size() > 1U) {
analyzer_->GetTileLogger().AppendLine(GPU_MAPPING,
"Cannot deal with this broadcast, make all axes tile divisible to speedup.");
IncreaseForLoop();
return;
}
AnalyzeBroadcastIdx();
if (mod_axes.empty() || broadcast_idx_.empty()) {
IncreaseForLoop();
GpuScalarBroadcastStrategy();
} else {
GpuVectorBroadcastStrategy();
}
}
void GpuStrategy::AnalyzeBroadcastIdx() {
for (const auto &attr : analyzer_->RootAxis()->attrs) {
if (attr.attr_key.find(AT_BROADCAST) == std::string::npos) {
continue;
}
auto op_types = common::Split(attr.attr_key, "_");
for (const auto &type : op_types) {
if (type.find(AT_BROADCAST) == std::string::npos) {
continue;
}
auto info = common::Split(type, "|");
if (info.size() == 2U) {
CHECK(!info[1].empty());
(void)broadcast_idx_.insert(StrToDecimalInt(info[1]));
}
}
}
std::stringstream ss;
ss << "Broadcast index = [";
for (auto idx : broadcast_idx_) {
ss << idx << ",";
}
ss << "]";
analyzer_->GetTileLogger().AppendLog(GPU_MAPPING, ss);
}
void GpuStrategy::GpuScalarBroadcastStrategy() {
if (template_ != Template::CUSTOM_CONFIG) {
template_ = Template::PURE_ELEM; // change template to enable injective speed up
}
auto broadcast_axes = analyzer_->GetAxesContainsAttr(AT_BROADCAST);
if (broadcast_axes.empty()) {
return;
}
current_outer_bn_->use_shared_memory = false;
}
void GpuStrategy::MapBroadcastElem(TileAxis *axis, std::vector<int> original_shape) {
// Mapping strategy specialized for broadcast + elementwise case
auto broadcast_innermost = broadcast_idx_.find(original_shape.size() - 1) != broadcast_idx_.end();
for (size_t i = 0; i < original_shape.size(); ++i) {
if (original_shape[i] * possible_threads_ <= max_x_y_dim_thread_) {
possible_threads_ *= original_shape[i];
}
auto rev_idx = (original_shape.size() - 1) - i;
if (broadcast_idx_.find(rev_idx) == broadcast_idx_.end()) {
total_injective_size_ *= original_shape[i];
coalesced_size_ = coalesced_size_ == 0 ? original_shape[i] : coalesced_size_;
if (broadcast_innermost) {
auto prev_extent = axis->thread_constraints.map_extent_ > 0 ? axis->thread_constraints.map_extent_ : 1;
auto thread_limit = max_x_y_dim_thread_ / SafeDivisor(prev_extent);
auto coef = TilingAnalyzer::GetLargestDivisor(thread_limit, original_shape[i]);
axis->thread_constraints.map_extent_ = prev_extent * coef;
possible_threads_ = static_cast<int>(axis->thread_constraints.map_extent_);
}
} else if (broadcast_innermost) {
auto prev_extent = axis->thread_constraints.map_extent_ > 0 ? axis->thread_constraints.map_extent_ : 1;
axis->thread_constraints.map_extent_ =
prev_extent * original_shape[i] <= max_x_y_dim_thread_ ? prev_extent * original_shape[i] : prev_extent;
possible_threads_ = static_cast<int>(axis->thread_constraints.map_extent_);
}
coalesced_size_ = coalesced_size_ == 0 ? 1 : coalesced_size_;
}
}
void GpuStrategy::GpuVectorBroadcastStrategy() {
// Disable share and local promotion since isl cannot perfectly handle fusion cases.
current_outer_bn_->use_shared_memory = false;
current_outer_bn_->use_register_memory = false;
auto interested_info = GetInterestedInfo(AT_MOD);
for (auto it : interested_info) {
TileAxis *axis = it.first;
std::stringstream ss;
// Reconstruct original shape from fused axis
std::vector<int> mod_values;
for (const auto &attr : it.second) {
CHECK(!attr.attr_value.empty());
(void)mod_values.emplace_back(StrToDecimalInt(attr.attr_value));
}
std::sort(mod_values.begin(), mod_values.end());
ss << "original shape before fused (in reversed order) :[";
std::vector<int> original_shape;
int prev_mod = 1;
for (const auto m : mod_values) {
CHECK_NE(prev_mod, 0);
(void)original_shape.emplace_back(m / SafeDivisor(prev_mod));
ss << original_shape.back() << ", ";
prev_mod = m;
}
CHECK_NE(prev_mod, 0);
(void)original_shape.emplace_back(fused_size_ / SafeDivisor(prev_mod));
ss << original_shape.back() << "]";
analyzer_->GetTileLogger().AppendLog(GPU_MAPPING, ss);
possible_threads_ = 1;
coalesced_size_ = 0;
total_injective_size_ = 1;
MapBroadcastElem(axis, original_shape);
int min_block = coalesced_size_ < warp_sizes_ ? 1024 : 512;
if (coalesced_size_ >= warp_sizes_) {
int elem_per_thread = 8;
axis->thread_constraints.item_process_ = std::min(
elem_per_thread,
std::max<int>((((fused_size_ / SafeDivisor(possible_threads_)) / SafeDivisor(min_block) + 1) / binary_factor_) *
binary_factor_,
1));
ss << "thread for-loop speedup = " << axis->thread_constraints.item_process_;
} else if (total_injective_size_ > min_block) {
while (possible_threads_ % warp_sizes_ != 0 && possible_threads_ < max_x_y_dim_thread_) {
++possible_threads_;
}
int elem_per_block = std::max<int>(16 / SafeDivisor(max_x_y_dim_thread_ / SafeDivisor(possible_threads_)), 1);
auto proposal_blocks = std::max(
min_block, std::max<int>((fused_size_ / SafeDivisor(possible_threads_)) / SafeDivisor(elem_per_block), 1));
axis->block_constraints.map_extent_ = proposal_blocks;
axis->thread_constraints.map_extent_ = possible_threads_;
ss << "block for-loop speedup = " << elem_per_block;
} else {
ss << "default mapping.";
}
analyzer_->GetTileLogger().AppendLog(GPU_MAPPING, ss);
ss << "possible_threads: " << possible_threads_ << ", coalesced_size: " << coalesced_size_
<< ", total_injective_size: " << total_injective_size_;
analyzer_->GetTileLogger().AppendLog(GPU_MAPPING, ss);
}
}
void CustomTilingStrategy::AddGpuConstraint() {
auto interested_info = GetInterestedInfo(interested_attr_key, false);
for (auto it : interested_info) {
TileAxis *axis = it.first;
for (auto attr : it.second) {
ParseConstraintStr(attr.attr_key, attr.attr_value);
ParseLevel();
for (const auto &con : constraints_) {
ApplyEachCustomConstraint(axis, con);
}
}
}
}
void ConvStrategy::AddGpuConstraint() {
if (!analyzer_->scop_info_.user_config_.GetEnableTensorCore() ||
analyzer_->scop_info_.analysis_result_.GetIsGpuDmaAnalysed() ||
!analyzer_->scop_info_.user_config_.GetEnableConvTensorCore()) {
return;
}
Mma mma = analyzer_->scop_info_.analysis_result_.GetMmaMode();
// Step 1. Collect M, H, W, N, K axis info.
std::unique_ptr<MmaConv> shape = InitGemmShape(mma);
if (shape == nullptr) {
return;
}
if (!analyzer_->scop_info_.user_config_.EnableStitchFusion()) {
analyzer_->scop_info_.user_config_.SetEnableOneDimThread(true);
}
MmaConv middle_band = {shape->m / SafeDivisor(mma.m), shape->h, shape->w, shape->n / SafeDivisor(mma.n),
shape->k / SafeDivisor(mma.k)};
std::stringstream ss;
ss << "[Conv] M = " << shape->m << " H = " << shape->h << " W = " << shape->w << " N = " << shape->n
<< " K = " << shape->k << ", middle band = [" << middle_band.m << ", " << middle_band.h << ", " << middle_band.w
<< middle_band.n << ", " << middle_band.k << "]";
analyzer_->GetTileLogger().AppendLog(GPU_MAPPING, ss);
// Step 2. Calculate macro M, H, W, N, K tile size.
CalculateMacroMma(*shape, mma);
// Step 3. Calculate possible number of warps.
auto warp_sizes = CalculateNumOfWarps(mma);
std::tie(w0_for_m_, w1_for_n_) = warp_sizes;
middle_band.m /= w0_for_m_;
middle_band.n /= w1_for_n_;
std::string warp_cfg = std::to_string(w0_for_m_) + " " + std::to_string(w1_for_n_);
analyzer_->scop_info_.user_config_.RecordReplaceConfig(WARP_COMPUTE, warp_cfg, MappingType::REPLACE_THREADS);
analyzer_->GetTileLogger().AppendLog(GPU_MAPPING, ss);
// Step 4. Set mapping and tiling config.
SetFinalConfig(macro_mma_, mma);
}
std::pair<int64_t, int64_t> ConvStrategy::CalculateNumOfWarps(const Mma &mma) {
int w0 = 1;
int w1 = 1;
// H and W do not participate in the calculation of the warp level
int use_local_group = static_cast<int>((macro_mma_.m / SafeDivisor(mma.m)) * (macro_mma_.n / SafeDivisor(mma.n)));
CHECK_GE(use_local_group, 1);
if (use_local_group >= use_local_group_high_) {
default_num_warps_ = num_warps_mid_;
} else if (use_local_group > 1) {
default_num_warps_ = num_warps_low_;
}
if ((macro_mma_.n / SafeDivisor(mma.n)) % binary_factor_ != 0) {
default_num_warps_ = num_warps_low_;
}
if (macro_mma_.k == double_warp_size_ && macro_mma_.n >= quadruple_warp_size_) {
default_num_warps_ = num_warps_high_;
}
std::tie(w0, w1) = GetDivisibleFactorForMN(macro_mma_.m, macro_mma_.n, default_num_warps_, mma);
std::stringstream ss;
ss << "[Conv] Try warp " << default_num_warps_ << " -> " << w0 << " * " << w1;
analyzer_->GetTileLogger().AppendLog(GPU_MAPPING, ss);
return std::make_pair(w0, w1);
}
std::unique_ptr<MmaConv> ConvStrategy::InitGemmShape(const Mma &mma) {
auto m_axes = analyzer_->GetAxesOfAttr(AttrInfo{AT_CONV, kDsami});
auto h_axes = analyzer_->GetAxesOfAttr(AttrInfo{AT_CONV, kDsahi});
auto w_axes = analyzer_->GetAxesOfAttr(AttrInfo{AT_CONV, kDsawi});
auto n_axes = analyzer_->GetAxesOfAttr(AttrInfo{AT_CONV, kDsaoc});
auto k_axes = analyzer_->GetAxesOfAttr(AttrInfo{AT_CONV, kDsaic});
if (m_axes.size() != 1U || h_axes.size() != 1U || w_axes.size() != 1U || n_axes.size() != 1U || k_axes.size() != 1U) {
return nullptr;
}
m_axis_ = m_axes[0];
h_axis_ = h_axes[0];
w_axis_ = w_axes[0];
n_axis_ = n_axes[0];
k_axis_ = k_axes[0];
if (m_axis_->range_extent.as<IntImm>() == nullptr || h_axis_->range_extent.as<IntImm>() == nullptr ||
w_axis_->range_extent.as<IntImm>() == nullptr || n_axis_->range_extent.as<IntImm>() == nullptr ||
k_axis_->range_extent.as<IntImm>() == nullptr) {
return nullptr;
}
auto shape_m = m_axis_->range_extent.as<IntImm>()->value;
auto shape_h = h_axis_->range_extent.as<IntImm>()->value;
auto shape_w = w_axis_->range_extent.as<IntImm>()->value;
auto shape_n = n_axis_->range_extent.as<IntImm>()->value;
auto shape_k = k_axis_->range_extent.as<IntImm>()->value;
CHECK_EQ(shape_m % mma.m, 0) << "Shape m " << shape_m << " should be multiples of mma.m " << mma.m
<< " to enable tensor core.";
CHECK_EQ(shape_n % mma.n, 0) << "Shape n " << shape_n << " should be multiples of mma.n " << mma.n
<< " to enable tensor core.";
CHECK_EQ(shape_k % mma.k, 0) << "Shape k " << shape_k << " should be multiples of mma.k " << mma.k
<< " to enable tensor core.";
return std::make_unique<MmaConv>(MmaConv{shape_m, shape_h, shape_w, shape_n, shape_k});
}
void ConvStrategy::CalculateMacroMma(const MmaConv &shape, const Mma &mma) {
std::stringstream ss;
MmaConv macro_mma = {std::min<int>(macro_mma_.m, shape.m), std::min<int>(macro_mma_.h, shape.h),
std::min<int>(macro_mma_.w, shape.w), std::min<int>(macro_mma_.n, shape.n),
std::min<int>(macro_mma_.k, shape.k)};
ss << "[Init macro mma]: [" << macro_mma.m << ", " << macro_mma.h << ", " << macro_mma.w << ", " << macro_mma.n
<< ", " << macro_mma.k << "]";
analyzer_->GetTileLogger().AppendLog(GPU_MAPPING, ss);
while (shape.m % SafeDivisor(macro_mma_.m) != 0 && macro_mma_.m / binary_factor_ >= mma.m) {
macro_mma_.m /= binary_factor_;
}
// If n is bigger than 128 and is not multiple of 128, the case is not supported now
if (shape.n % SafeDivisor(macro_mma_.n) != 0) {
macro_mma_.n = shape.n;
}
while (shape.k % SafeDivisor(macro_mma_.k) != 0 && macro_mma_.k / binary_factor_ >= mma.k) {
macro_mma_.k /= binary_factor_;
}
// Data volume in the M direction and data volume in the N direction should be close
// split h and w direction, increase the data volume
int temp_h = static_cast<int>(shape.h);
int temp_w = static_cast<int>(shape.w);
while (macro_mma_.m * macro_mma_.w * macro_mma_.h < quadruple_warp_size_) {
if (temp_w % binary_factor_ == 0) {
macro_mma_.w *= binary_factor_;
temp_w /= binary_factor_;
} else if (temp_h % binary_factor_ == 0) {
macro_mma_.h *= binary_factor_;
temp_h /= binary_factor_;
} else {
break;
}
}
while ((shape.m / SafeDivisor(macro_mma_.m)) * (shape.h / SafeDivisor(macro_mma_.h)) *
(shape.w / SafeDivisor(macro_mma_.w)) * (shape.n / SafeDivisor(macro_mma_.n)) <
(min_blocks_ - warp_sizes_) &&
(macro_mma_.m / SafeDivisor(macro_mma_.n)) * macro_mma_.h * macro_mma_.w > tensor_core_per_warp_) {
// decrease h and increase the use of block
if (macro_mma_.h % binary_factor_ == 0) {
macro_mma_.h /= binary_factor_;
continue;
}
// decrease w and increase the use of block
if (macro_mma_.w % binary_factor_ == 0) {
macro_mma_.w /= binary_factor_;
continue;
}
if (macro_mma_.m / binary_factor_ >= mma.m) {
macro_mma_.m /= binary_factor_;
}
}
real_blocks_ = (shape.m / SafeDivisor(macro_mma_.m)) * (shape.h / SafeDivisor(macro_mma_.h)) *
(shape.w / SafeDivisor(macro_mma_.w)) * (shape.n / SafeDivisor(macro_mma_.n));
if ((real_blocks_ > (min_blocks_ - warp_sizes_)) && (shape.k % SafeDivisor(macro_mma_.k * binary_factor_) == 0)) {
macro_mma_.k *= binary_factor_;
}
ss << "[Final macro mma]: [" << macro_mma.m << ", " << macro_mma.h << ", " << macro_mma.w << ", " << macro_mma.n
<< ", " << macro_mma.k << "]";
analyzer_->GetTileLogger().AppendLog(GPU_MAPPING, ss);
}
void ConvStrategy::SetFinalConfig(const MmaConv ¯o_mma, const Mma &mma) {
std::stringstream ss;
m_axis_->TileRestrainToSingleValue(CastIntToExpr(static_cast<int>(macro_mma.m)), CACHE1);
m_axis_->thread_constraints.map_min_ = w0_for_m_ * w1_for_n_;
m_axis_->thread_constraints.map_extent_ = w0_for_m_ * w1_for_n_;
m_axis_->TileRestrainToSingleValue(CastIntToExpr(static_cast<int>(mma.m)), CACHE0);
h_axis_->TileRestrainToSingleValue(CastIntToExpr(static_cast<int>(macro_mma.h)), CACHE1);
h_axis_->thread_constraints.map_min_ = MIN_TILE;
h_axis_->thread_constraints.map_extent_ = MIN_TILE;
h_axis_->TileRestrainToSingleValue(CastIntToExpr(1), CACHE0);
w_axis_->TileRestrainToSingleValue(CastIntToExpr(static_cast<int>(macro_mma.w)), CACHE1);
w_axis_->thread_constraints.map_min_ = MIN_TILE;
w_axis_->thread_constraints.map_extent_ = MIN_TILE;
w_axis_->TileRestrainToSingleValue(CastIntToExpr(1), CACHE0);
n_axis_->TileRestrainToSingleValue(CastIntToExpr(static_cast<int>(macro_mma.n)), CACHE1);
n_axis_->thread_constraints.map_min_ = warp_sizes_;
n_axis_->thread_constraints.map_extent_ = warp_sizes_;
n_axis_->TileRestrainToSingleValue(CastIntToExpr(static_cast<int>(mma.n)), CACHE0);
k_axis_->TileRestrainToSingleValue(CastIntToExpr(static_cast<int>(macro_mma.k)), CACHE1);
k_axis_->thread_constraints.map_min_ = MIN_TILE;
k_axis_->thread_constraints.map_extent_ = MIN_TILE;
k_axis_->TileRestrainToSingleValue(CastIntToExpr(static_cast<int>(mma.k)), CACHE0);
ss << "[Final config] : L1(M, H, W, N, K) = " << macro_mma.m << ", " << macro_mma.h << ", " << macro_mma.w << ", "
<< macro_mma.n << ", " << macro_mma.k;
ss << "; L0(M, H, W, N, K) = " << mma.m << ", " << 1 << ", " << 1 << ", " << mma.n << ", " << mma.k;
ss << "; Thread(W0, W1, TX) = " << w0_for_m_ << ", " << w1_for_n_ << ", " << warp_sizes_;
analyzer_->GetTileLogger().AppendLog(GPU_MAPPING, ss);
}
const std::pair<int64_t, int64_t> ConvStrategy::GetDivisibleFactorForMN(int64_t shape_m, int64_t shape_n,
int64_t total_factor, const Mma &mma) {
return GetTensorCoreDivisibleFactorForMN(shape_m, shape_n, total_factor, binary_factor_, mma);
}
void ShiftAxisStrategy::AddGpuConstraint() {
TileEntirely();
for (auto axis : shifted_axes_) {
axis->block_constraints.map_extent_ = 1;
axis->thread_constraints.map_extent_ = 1;
}
}
void CsrStrategy::AddConstraintND(std::vector<TileAxis *> &axes, int csr_thread_num, int feat_len) {
// CSR schedule with feature dimension (csr.values > 1d), axis has already been
// fused to outer axis (static boundary), and inner axis (dynamic boundary).
// Feature dimension will be mapped first
auto available_threads = total_available_thread_;
CHECK(axes.size() == GPU_CSR_FUSION_AXES_SIZE);
auto outer_axis = axes[OUTERMOST_AXIS];
auto inner_axis = axes[OUTERMOST_AXIS + 1];
bool use_reduce_lib = analyzer_->scop_info_.analysis_result_.GetUseGpuReduceLib();
csr_thread_num = use_reduce_lib ? analyzer_->scop_info_.user_config_.GetCsrThreadNum() : GPU_CSR_NO_TILE;
// For outer axis
CHECK(!analyzer_->scop_info_.analysis_result_.IsCsrDynamicExtent(outer_axis->range_extent));
if (csr_thread_num > outer_axis->extent_val) {
outer_axis->block_constraints.map_extent_ = std::ceil(static_cast<double>(outer_axis->extent_val) / feat_len);
outer_axis->thread_constraints.map_extent_ = feat_len;
csr_thread_num = std::min(static_cast<int>(available_threads) / feat_len, csr_thread_num);
} else {
available_threads /= feat_len;
int max_nodes_per_block = available_threads / csr_thread_num;
while (max_nodes_per_block < 1 && (csr_thread_num >> 1) > reduce_length_limit_) {
csr_thread_num >>= 1;
max_nodes_per_block = available_threads / csr_thread_num;
}
auto nodes_per_block = std::min(max_nodes_per_block, GPU_CSR_BEST_NUM_NODES_PER_BLOCK);
nodes_per_block = std::max(1, nodes_per_block);
outer_axis->block_constraints.map_extent_ =
std::ceil(static_cast<double>(outer_axis->extent_val) / feat_len / nodes_per_block);
outer_axis->thread_constraints.map_extent_ = feat_len * nodes_per_block;
}
// For inner axis
CHECK(analyzer_->scop_info_.analysis_result_.IsCsrDynamicExtent(inner_axis->range_extent));
inner_axis->block_constraints.map_extent_ = GPU_CSR_NO_TILE;
inner_axis->thread_constraints.map_extent_ = csr_thread_num;
inner_axis->c1_constraints.tile_min_ = GPU_CSR_NO_TILE;
inner_axis->c1_constraints.tile_extent_ = csr_thread_num;
analyzer_->scop_info_.user_config_.SetCsrThreadNum(csr_thread_num);
return;
}
void CsrStrategy::AddConstraint2D(std::vector<TileAxis *> &axes, int csr_thread_num,
std::unordered_map<int, int64_t> &index_mapping) {
auto available_threads = total_available_thread_;
std::sort(axes.begin(), axes.end(), [](TileAxis *a, TileAxis *b) {
if (a->dim_axis == b->dim_axis) {
return a->index < b->index;
}
return a->dim_axis > b->dim_axis;
});
for (size_t i = 0; i < axes.size(); ++i) {
// CSR schedule without dimension (csr.values = 1d)
auto axis = axes[i];
if (analyzer_->scop_info_.analysis_result_.IsCsrDynamicExtent(axis->range_extent)) {
if (csr_thread_num != -1) {
axis->block_constraints.map_extent_ = GPU_CSR_NO_TILE;
axis->thread_constraints.map_extent_ = csr_thread_num;
axis->c1_constraints.tile_extent_ = csr_thread_num;
} else {
int csr_avg_row = analyzer_->scop_info_.analysis_result_.GetCsrAvgRow();
if (csr_avg_row <= 0) {
csr_thread_num = analyzer_->scop_info_.user_config_.GetCsrThreadNum();
} else {
float warp_base_raw = std::log2(static_cast<float>(csr_avg_row) / WARP_SIZE);
int warp_base;
if (analyzer_->scop_info_.analysis_result_.GetOpTemplate() == Template::REDUCTION) {
warp_base = std::clamp(static_cast<int>(std::floor(warp_base_raw)), 0, warp_factor_reduction_);
} else {
warp_base = std::clamp(static_cast<int>(std::ceil(warp_base_raw)), 0, warp_factor_elemwise_);
}
csr_thread_num = static_cast<int>(std::exp2(warp_base)) * WARP_SIZE;
}
csr_thread_num = std::min(static_cast<int64_t>(csr_thread_num), available_threads);
axis->block_constraints.map_extent_ = GPU_CSR_NO_TILE;
axis->thread_constraints.map_extent_ = csr_thread_num;
axis->c1_constraints.tile_extent_ = csr_thread_num;
analyzer_->scop_info_.user_config_.SetCsrThreadNum(csr_thread_num);
available_threads /= SafeDivisor(csr_thread_num);
}
} else if (axis->dim_axis == 0) {
axis->thread_constraints.map_extent_ = GPU_CSR_NO_TILE;
} else {
if (index_mapping.count(axis->dim_axis)) {
auto prev_mapping = index_mapping[axis->dim_axis];
if (axis->extent_val > prev_mapping) {
auto additional_mapping =
static_cast<int64_t>(std::ceil(static_cast<float>(axis->extent_val) / prev_mapping));
additional_mapping = std::clamp<int64_t>(additional_mapping, 1, available_threads);
available_threads /= SafeDivisor(additional_mapping);
index_mapping[axis->dim_axis] = prev_mapping * additional_mapping;
}
} else {
auto thread_num = std::min(axis->extent_val, available_threads);
available_threads /= SafeDivisor(thread_num);
index_mapping[axis->dim_axis] = thread_num;
}
}
}
}
void CsrStrategy::AddGpuConstraint() {
if (!analyzer_->scop_info_.analysis_result_.GetCsr()) {
return;
}
std::vector<TileAxis *> axes;
int csr_axes_count = 0;
analyzer_->ForEachAxisTopDown([&axes, &csr_axes_count, this](TileAxis *axis) {
if (axis == this->analyzer_->RootAxis()) {
return;
}
if (analyzer_->scop_info_.analysis_result_.IsCsrDynamicExtent(axis->range_extent)) {
++csr_axes_count;
}
axes.push_back(axis);
});
int csr_thread_num = -1;
std::unordered_map<int, int64_t> index_mapping;
auto feat_len = analyzer_->scop_info_.analysis_result_.GetCsrFeatLen();
if (feat_len > 1) {
AddConstraintND(axes, csr_thread_num, feat_len);
return;
}
AddConstraint2D(axes, csr_thread_num, index_mapping);
return;
}
void CountStrategy::AddGpuConstraint() {
std::unordered_set<TileAxis *> count_axes;
for (int band_index = 0; band_index < static_cast<int>(analyzer_->RootAxis()->children.size()); ++band_index) {
auto count_axes_vec = analyzer_->GetAxesOfAttr(AT_COUNT_AXIS, band_index);
count_axes.insert(count_axes_vec.begin(), count_axes_vec.end());
}
analyzer_->ForEachAxisTopDown([this, count_axes](TileAxis *axis) {
if (axis == this->analyzer_->RootAxis()) {
return;
}
if (count_axes.count(axis)) {
axis->thread_constraints.map_extent_ = 1;
axis->block_constraints.map_extent_ = axis->extent_val;
} else {
axis->block_constraints.map_extent_ = 1;
}
});
}
void VectorizedStrategy::AddGpuConstraint() {
auto vectorized_loop_size = analyzer_->scop_info_.analysis_result_.GetVectorizedLoopSize();
if (!analyzer_->scop_info_.user_config_.GetEnableVectorization() || vectorized_loop_size == 0) {
return;
}
auto gpu_strategy = GpuStrategy(analyzer_);
gpu_strategy.CountGlobalBufferSize();
auto interested_info = GetInterestedInfo(interested_attr_key);
for (auto it : interested_info) {
TileAxis *axis = it.first;
auto curr_band = analyzer_->scop_info_.analysis_result_.GetOuterBandNode(axis->index);
if (!curr_band->enable_vectorization) {
continue;
}
if (gpu_strategy.global_buf_size_ < gpu_strategy.min_buf_size_to_enable_vectorization_ &&
analyzer_->RootAxis()->HasAttr(AT_HEAVY_ELTWISE)) {
curr_band->enable_vectorization = false;
continue;
}
auto parallel_size = gpu_strategy.GetProposalParallelSize(axis->extent_val);
auto curr_template = curr_band->template_type;
if (axis->extent_val % SafeDivisor(vectorized_loop_size) != 0 ||
(axis->extent_val < parallel_size.second * vectorized_loop_size && curr_template != Template::PAD_OP)) {
continue;
}
std::stringstream ss;
ss << "Enable Vectorization for " << axis->index << "_" << axis->dim_axis;
axis->thread_constraints.map_mod_ = vectorized_loop_size;
axis->c1_constraints.tile_mod_ = vectorized_loop_size;
axis->TileRestrainToSingleValue(CastIntToExpr(vectorized_loop_size), TileLevel::CACHE0);
if (axis->extent_val < parallel_size.first * parallel_size.second) {
auto min_threads = std::min<int64_t>(total_available_thread_, axis->extent_val);
axis->thread_constraints.map_extent_ = min_threads / SafeDivisor(vectorized_loop_size);
} else if (axis->extent_val > parallel_size.first * parallel_size.second * vectorized_loop_size) {
axis->thread_constraints.map_extent_ = total_available_thread_ / SafeDivisor(gpu_strategy.double_);
axis->thread_constraints.item_process_ = 1;
}
ss << ", set thread extent to " << axis->thread_constraints.map_extent_;
analyzer_->GetTileLogger().AppendLog(GPU_MAPPING, ss);
}
}
void TensorOfTensorStrategy::AddGpuConstraint() {
if (!analyzer_->scop_info_.analysis_result_.GetTensorOfTensorStmt().empty()) {
// In this case, we have tensor of tensor with atomic operation.
// Therefore, we disable shared-mem promotion to improve performance.
for (int i = 0; i < analyzer_->scop_info_.analysis_result_.GetOuterBandNumber(); ++i) {
auto band = analyzer_->scop_info_.analysis_result_.GetOuterBandNode(i);
band->use_shared_memory = false;
}
}
}
// No constraint found in cuda
void ModStrategy::AddGpuConstraint() {}
void ConflictTreeRangeStrategy::AddGpuConstraint() {}
void DmaAlignStrategy::AddGpuConstraint() {}
void PassDownAttrStrategy::AddGpuConstraint() {}
void DynamicShapeLimitStrategy::AddGpuConstraint() {}
void DynamicBoundStrategy::AddGpuConstraint() {}
void ModShiftAxisStrategy::AddGpuConstraint() {}
// end of null constraint
} // namespace poly
} // namespace ir
} // namespace akg
|
9de824f17323272ec4a7366d3dde139fee54d72d
|
0b50cc42b6065a1a0442e09a9836a443b97ec249
|
/thirdparty/sfs2x/Entities/Match/UserProperties.cpp
|
76ba10edde4723a76024b4c55a21d0b0ef95eafd
|
[
"MIT"
] |
permissive
|
godot-addons/godot-sfs2x
|
06dc177d8289898d487d12e01ac1023cc7a63395
|
a8d52aa9d548f6d45bbb64bfdaacab0df10e67c1
|
refs/heads/master
| 2021-07-12T02:01:23.368889
| 2020-05-31T19:25:12
| 2020-05-31T19:25:12
| 140,114,287
| 3
| 3
|
MIT
| 2018-07-07T20:44:16
| 2018-07-07T20:14:46
| null |
UTF-8
|
C++
| false
| false
| 1,287
|
cpp
|
UserProperties.cpp
|
// ===================================================================
//
// Description
// Contains the implementation of UserProperties
//
// Revision history
// Date Description
// 30-Nov-2012 First version
//
// ===================================================================
#include "UserProperties.h"
#include <boost/exception/exception.hpp>
#include <boost/exception/all.hpp>
namespace Sfs2X {
namespace Entities {
namespace Match {
boost::shared_ptr<string> UserProperties::NAME (new string("${N}"));
boost::shared_ptr<string> UserProperties::IS_PLAYER (new string("${ISP}"));
boost::shared_ptr<string> UserProperties::IS_SPECTATOR (new string("${ISS}"));
boost::shared_ptr<string> UserProperties::IS_NPC (new string("${ISN}"));
boost::shared_ptr<string> UserProperties::PRIVILEGE_ID (new string("${PRID}"));
boost::shared_ptr<string> UserProperties::IS_IN_ANY_ROOM (new string("${IAR}"));
// -------------------------------------------------------------------
// Constructor
// -------------------------------------------------------------------
UserProperties::UserProperties()
{
boost::throw_exception(boost::enable_error_info (std::runtime_error("This class cannot be instantiated")));
}
} // namespace Match
} // namespace Entities
} // namespace Sfs2X
|
8f40428788134779a7a81b0c07e88c84443ef0cf
|
93294d148df93b4378f59ac815476919273d425f
|
/src/Pigs/PigConfig/PigConfigSheet.h
|
e5959eea645127a821200c07fffab73717296d92
|
[
"MIT"
] |
permissive
|
FreeAllegiance/Allegiance
|
f1addb3b26efb6b8518705a0b0300974820333c3
|
3856ebcd8c35a6d63dbf398a4bc7f0264d6c823c
|
refs/heads/master
| 2023-07-06T17:53:24.363387
| 2023-06-29T00:24:26
| 2023-06-29T00:24:26
| 98,829,929
| 86
| 34
|
MIT
| 2023-06-28T03:57:34
| 2017-07-30T23:09:14
|
C++
|
UTF-8
|
C++
| false
| false
| 1,715
|
h
|
PigConfigSheet.h
|
#pragma once
/////////////////////////////////////////////////////////////////////////////
// PigConfigSheet.h : Declaration of the CPigConfigSheet class.
//
#include "PageGeneral.h"
#include "PageServers.h"
#include "PageEvents.h"
/////////////////////////////////////////////////////////////////////////////
// CPigConfigSheet dialog
class CPigConfigSheet : public CPropertySheet
{
// Declarations
protected:
DECLARE_MESSAGE_MAP()
// Construction
public:
CPigConfigSheet(CWnd* pParentWnd = NULL, UINT iSelectPage = 0);
bool Create();
// Attributes
public:
IPigSession* GetSession();
// Implementation
protected:
void InitSysMenu();
void InitIcon();
void InitButtons();
// Overrides
public:
// ClassWizard generate virtual function overrides
//{{AFX_VIRTUAL(CPigConfigSheet)
virtual void PostNcDestroy();
//}}AFX_VIRTUAL
// Message Handlers
protected:
// Generated message map functions
//{{AFX_MSG(CPigConfigSheet)
virtual BOOL OnInitDialog();
afx_msg void OnSysCommand(UINT nID, LPARAM lParam);
afx_msg void OnOK();
afx_msg void OnCancel();
//}}AFX_MSG
// Data Members
protected:
IPigSessionPtr m_spSession;
CPageGeneral m_PageGeneral;
CPageServers m_PageServers;
CPageEvents m_PageEvents;
};
/////////////////////////////////////////////////////////////////////////////
// Attributes
inline IPigSession* CPigConfigSheet::GetSession()
{
return m_spSession;
}
/////////////////////////////////////////////////////////////////////////////
//{{AFX_INSERT_LOCATION}}
// Microsoft Visual C++ will insert additional declarations immediately before the previous line.
/////////////////////////////////////////////////////////////////////////////
|
eae9268f82ae33e97029432c8fbc30d9aa8c41f8
|
6b2a8dd202fdce77c971c412717e305e1caaac51
|
/solutions_5753053697277952_1/C++/iejr/main.cpp
|
defa2a511c58628e61e8707d3cbacfd4664708ce
|
[] |
no_license
|
alexandraback/datacollection
|
0bc67a9ace00abbc843f4912562f3a064992e0e9
|
076a7bc7693f3abf07bfdbdac838cb4ef65ccfcf
|
refs/heads/master
| 2021-01-24T18:27:24.417992
| 2017-05-23T09:23:38
| 2017-05-23T09:23:38
| 84,313,442
| 2
| 4
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 2,915
|
cpp
|
main.cpp
|
//iejr Header files
#include <stdio.h>
#include <cstdio>
#include <cstdlib>
#include <iostream>
#include <stdlib.h>
#include <string>
#include <cstring>
#include <sstream>
#include <bitset>
#include <cmath>
#include <iomanip>
#include <vector>
#include <list>
#include <stack>
#include <queue>
#include <deque>
#include <set>
#include <map>
#include <algorithm>
#include <limits.h>
#include <ctime>
#include <cctype>
#include <functional>
#include <utility>
#include <numeric>
using namespace std;
//iejr: Type defination
typedef unsigned long long int ULLN;
typedef long long int LLN;
typedef vector<int> VI;
typedef vector<vector<int> > VVI;
typedef vector<string> VS;
typedef vector<vector<string> > VVS;
//iejr: Compile Options
//#define C11_Standard
//
#ifdef C11_Standard
#include <unordered_set>
#include <unordered_map>
#define HASHSET unordered_set
#define HASHMAP unordered_map;
#endif // C11_Standard
//iejr: Local Debug
#define INPUT_REDIRECTION
#define OUTPUT_REDIRECTION
struct Node{
int nIndex;
int nVote;
Node(): nIndex( 0 ), nVote( 0 ){};
};
bool cmp( const Node &n1, const Node &n2 ){
return n1.nVote > n2.nVote;
}
//iejr: Main Function
int main()
{
#ifdef INPUT_REDIRECTION
freopen( "A-large.in", "r", stdin );
#endif // INPUT_REDIRECTION
#ifdef OUTPUT_REDIRECTION
freopen( "out.txt", "w", stdout );
#endif // OUTPUT_REDIRECTION
int T = 0;
scanf( "%d", &T );
for( int i = 1;i <= T;++i ){
//your solution here
int N = 0;
scanf( "%d", &N );
Node * nArray = new Node[N];
int nSum = 0;
for( int i = 0;i < N;++i ){
nArray[i].nIndex = i;
scanf( "%d", &nArray[i].nVote );
nSum += nArray[i].nVote;
}
sort( nArray, nArray + N, cmp );
printf( "Case #%d: ", i );
while( nArray[0].nVote > 0 ){
if( (nArray[1].nVote -1) / (double)( nSum - 2 ) > 0.5 ){
printf( "%c ", nArray[0].nIndex + 'A' );
--nArray[0].nVote;
--nSum;
}
else if( N > 2 && nArray[2].nVote / (double)( nSum - 2 ) > 0.5 ){
printf( "%c ", nArray[0].nIndex + 'A' );
--nArray[0].nVote;
--nSum;
}
else{
printf( "%c%c ", nArray[0].nIndex + 'A', nArray[1].nIndex + 'A' );
--nArray[0].nVote;
--nArray[1].nVote;
--nSum;
--nSum;
}
sort( nArray, nArray + N, cmp );
}
printf( "\n" );
}
#ifdef INPUT_REDIRECTION
fclose( stdin );
#endif // INPUT_REDIRECTION
#ifdef OUTPUT_REDIRECTION
fclose( stdout );
#endif // OUTPUT_REDIRECTION
return 0;
}
|
544538187fa2c5baca4da4597102da0536db4982
|
a36ffb00d8699c3b3555a8abfbe2cf1fb16a8368
|
/src/socket/EzySocketAdapter.h
|
35989f3849abf898e6dc37e232ee650bce207b9a
|
[] |
no_license
|
sjb8100/ezyfox-server-cpp-client
|
6508aa5e6a01c9e5f675052400d002d017c3ca3b
|
ebda81ecf981aa8620c7f7350654e89b0c22e551
|
refs/heads/master
| 2020-04-02T15:23:04.754575
| 2018-10-23T09:26:18
| 2018-10-23T09:26:18
| null | 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 700
|
h
|
EzySocketAdapter.h
|
#pragma once
#include <queue>
#include <ctime>
#include <condition_variable>
#include "EzySocketCore.h"
#include "EzySocketPool.h"
#include "../base/EzyRef.h"
#include "../gc/EzyReleasePool.h"
EZY_NAMESPACE_START_WITH(socket)
class EzySocketAdapter {
protected:
bool mActive;
std::mutex mMutex;
EzySocketPool* mSocketPool;
protected:
virtual void update();
public:
EzySocketAdapter();
virtual ~EzySocketAdapter();
virtual void start();
virtual void run();
virtual void stop();
virtual bool isActive();
virtual void setActive(bool active);
virtual EzySocketData* popMessage();
virtual void pushMessage(EzySocketData* data);
};
EZY_NAMESPACE_END_WITH
|
067813150087b87ea2069507a5a7dc28ec27ebf7
|
75252daa56e54a129e6aa0275b980ecd675d4587
|
/services/surfaceflinger/CompositionEngine/src/Display.cpp
|
f9d70e3c91da9cff4464f6ac695bf6d309130479
|
[
"LicenseRef-scancode-unicode",
"Apache-2.0"
] |
permissive
|
crdroidandroid/android_frameworks_native
|
988870fcaeb1c28b5f73631afb52883c2c741c69
|
c15d4c3a6322c819bd417e8f8b03223f151771b6
|
refs/heads/10.0
| 2023-08-31T10:03:46.719048
| 2021-11-13T17:47:17
| 2021-11-13T17:47:17
| 277,143,821
| 6
| 53
|
NOASSERTION
| 2023-09-13T06:28:33
| 2020-07-04T16:11:59
|
C++
|
UTF-8
|
C++
| false
| false
| 3,870
|
cpp
|
Display.cpp
|
/*
* Copyright 2019 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <android-base/stringprintf.h>
#include <compositionengine/CompositionEngine.h>
#include <compositionengine/DisplayCreationArgs.h>
#include <compositionengine/DisplaySurface.h>
#include <compositionengine/impl/Display.h>
#include <compositionengine/impl/DisplayColorProfile.h>
#include <compositionengine/impl/DumpHelpers.h>
#include <compositionengine/impl/RenderSurface.h>
#include "DisplayHardware/HWComposer.h"
namespace android::compositionengine::impl {
std::shared_ptr<compositionengine::Display> createDisplay(
const compositionengine::CompositionEngine& compositionEngine,
compositionengine::DisplayCreationArgs&& args) {
return std::make_shared<Display>(compositionEngine, std::move(args));
}
Display::Display(const CompositionEngine& compositionEngine, DisplayCreationArgs&& args)
: compositionengine::impl::Output(compositionEngine),
mIsVirtual(args.isVirtual),
mId(args.displayId) {
editState().isSecure = args.isSecure;
}
Display::~Display() = default;
const std::optional<DisplayId>& Display::getId() const {
return mId;
}
bool Display::isSecure() const {
return getState().isSecure;
}
bool Display::isVirtual() const {
return mIsVirtual;
}
void Display::disconnect() {
if (!mId) {
return;
}
auto& hwc = getCompositionEngine().getHwComposer();
hwc.disconnectDisplay(*mId);
mId.reset();
}
void Display::setColorTransform(const mat4& transform) {
Output::setColorTransform(transform);
auto& hwc = getCompositionEngine().getHwComposer();
status_t result = hwc.setColorTransform(*mId, transform);
ALOGE_IF(result != NO_ERROR, "Failed to set color transform on display \"%s\": %d",
mId ? to_string(*mId).c_str() : "", result);
}
void Display::setColorMode(ui::ColorMode mode, ui::Dataspace dataspace,
ui::RenderIntent renderIntent) {
if (mode == getState().colorMode && dataspace == getState().dataspace &&
renderIntent == getState().renderIntent) {
return;
}
if (mIsVirtual) {
ALOGW("%s: Invalid operation on virtual display", __FUNCTION__);
return;
}
Output::setColorMode(mode, dataspace, renderIntent);
auto& hwc = getCompositionEngine().getHwComposer();
hwc.setActiveColorMode(*mId, mode, renderIntent);
}
void Display::dump(std::string& out) const {
using android::base::StringAppendF;
StringAppendF(&out, " Composition Display State: [\"%s\"]", getName().c_str());
out.append("\n ");
dumpVal(out, "isVirtual", mIsVirtual);
if (mId) {
dumpVal(out, "hwcId", to_string(*mId));
} else {
StringAppendF(&out, "no hwcId, ");
}
out.append("\n");
Output::dumpBase(out);
}
void Display::createDisplayColorProfile(DisplayColorProfileCreationArgs&& args) {
setDisplayColorProfile(compositionengine::impl::createDisplayColorProfile(std::move(args)));
}
void Display::createRenderSurface(RenderSurfaceCreationArgs&& args) {
setRenderSurface(compositionengine::impl::createRenderSurface(getCompositionEngine(), *this,
std::move(args)));
}
} // namespace android::compositionengine::impl
|
3b6b4cb7cb1ef7d699eb2f5bfd5cb3992473e81a
|
805f9f72b1d7f02943601ca372c78b56afabad08
|
/Dynamic Programming 2/Shortest_Sequence.cpp
|
4245231d46aaa7611f543e5337dda0efb1f05ac9
|
[] |
no_license
|
aSpanefRost/CodingNInjas
|
79644f16ca14fe8eb841c0ac86d705c08006d4c9
|
dc5f73023410a4fdf926aa1e9dea39edb891dbf2
|
refs/heads/main
| 2023-04-21T08:58:36.413161
| 2021-05-03T18:36:50
| 2021-05-03T18:36:50
| 363,832,006
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 674
|
cpp
|
Shortest_Sequence.cpp
|
Shortest Subsequence
Send Feedback
Gary has two string S and V. Now, Gary wants to know the length shortest subsequence in S, which is not a subsequence in V.
Note: The input data will be such that there will always be a solution.
Input Format :
The first line of input contains a string, that denotes the value of S. The following line contains a string, that denotes the value of V.
Output Format :
Length of shortest subsequence in S such that it is not a subsequence in V
Constraints:
1 <= N <= 1000
1 <= M <= 1000
Time Limit: 1 second
Sample Input 1:
babab
babba
Sample Output 1:
3
Explanation:
"aab" is the shortest subsequence which is present in S and absent in V.
|
cfd1b853555e8843f2f677b84742ada35f79c37e
|
227fe1226f59d6033e20ef456a1f8288091c5312
|
/src/lcbio/manager.h
|
8b66e1e34d62be85bb98419e9fdfbfa715180698
|
[
"Apache-2.0",
"LicenseRef-scancode-unknown-license-reference"
] |
permissive
|
couchbase/libcouchbase
|
697ca0f621bff80e242fa1099be8d0160dd2bc55
|
6e411d412ba3f5039d21ea4195dca86b0f82134b
|
refs/heads/master
| 2023-08-30T23:38:38.586108
| 2023-08-16T13:39:57
| 2023-08-16T14:41:12
| 2,077,002
| 120
| 100
|
Apache-2.0
| 2022-09-19T12:29:14
| 2011-07-20T08:43:46
|
C
|
UTF-8
|
C++
| false
| false
| 5,501
|
h
|
manager.h
|
/* -*- Mode: C; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
/*
* Copyright 2014-2020 Couchbase, Inc.
*
* 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 LCBIO_MANAGER_H
#define LCBIO_MANAGER_H
#include "connect.h"
#include "settings.h"
#include "list.h"
#include "ioutils.h"
#include <stdio.h>
/**
* @file
* @brief Socket pooling routines
*
* @details
* General purpose connection manager for LCB sockets. This object is
* responsible for maintaining and properly handling idle connections
* and pooling them (optionally).
*/
/**
* @ingroup lcbio
* @defgroup lcbio-mgr Socket Pooling
* @addtogroup lcbio-mgr
* @{
*/
#ifdef __cplusplus
#include <map>
namespace lcb
{
namespace io
{
/** @brief Socket Pool */
class Pool;
/** @brief Pooled connection */
struct PoolConnInfo;
/** @brief Cancellable pool request */
struct PoolRequest;
struct PoolHost;
} // namespace io
} // namespace lcb
typedef lcb::io::Pool lcbio_MGR;
extern "C" {
#else
/* C only */
typedef struct lcbio_MGR_CDUMMY lcbio_MGR;
#endif
#ifdef __cplusplus
}
namespace lcb
{
namespace io
{
class Pool
{
public:
/**
* Create a socket pool controlled by the given settings and IO structure.
* This function will increment the refcount on both the settings and table
* objects.
*/
Pool(lcb_settings *, lcbio_pTABLE);
/**
* Destroy the socket pool. Note that internally this just decrements the
* reference count. The object is only destroyed when its count hits zero.
*/
void shutdown();
/**
* Request a connection from the socket pool. The semantics and prototype
* of this function are by design similar to lcbio_connect() as they do the
* same things.
*
* @param dest the host to connect to
* @param timeout amount of time to wait for a connection to be estblished
* @param handler a callback to invoke when the result is ready
* @param arg an argument passed to the callback
* @return a request handle which may be cancelled
* @see lcbio_connect()
*/
ConnectionRequest *get(const lcb_host_t &, uint32_t, lcbio_CONNDONE_cb, void *);
/**
* Release a socket back into the pool. This means the socket is no longer
* used and shall be available for reuse for another request. To verify these
* constraints, the socket's reference count must be one. Once the socket
* has been released its reference count should not be modified.
*/
static void put(lcbio_SOCKET *sock);
/**
* Mark a slot as available but discard the current connection. This should be
* done if the connection itself is "dirty", i.e. has a protocol error on it
* or is otherwise not suitable for reuse
*/
static void discard(lcbio_SOCKET *sock);
/**
* Like lcbio_mgr_discard() except the source connection is left untouched. It
* is removed from the pool instead.
*
* Because the lcbio_MGR object itself has internal limits and thresholds on how
* many leased and/or open connections it can contain, when a connection receives
* an error it must either be discarded back to the pool (in which case the
* connection is cleaned up and is freed) or it must be detached (in which case
* the connection object itself still remains valid, but the pool does not know
* about it, and all its counters are restored, as with lcbio_mgr_discard()).
*
* lcbio_mgr_discard() itself is now implemented as the equivalent to:
* `lcbio_mgr_detach(mgr, conn)`;
*/
static void detach(lcbio_SOCKET *sock);
static bool is_from_pool(const lcbio_SOCKET *sock);
/**
* Dumps the connection manager state to stderr
*/
void dump(FILE *) const;
inline void ref();
inline void unref();
struct Options {
Options() : maxtotal(0), maxidle(0), tmoidle(0) {}
/** Maximum *total* number of connections opened by the pool. If this
* number is exceeded, the pool will black hole future requests until
* a new slot becomes available.
*/
unsigned maxtotal;
/**
* Maximum number of idle connections to keep around
*/
unsigned maxidle;
/**
* The amount of time the pool should wait before closing idle
* connections. In microseconds
*/
uint32_t tmoidle;
};
void set_options(const Options &opts)
{
options = opts;
}
Options &get_options()
{
return options;
}
void toJSON(hrtime_t now, Json::Value &node);
private:
friend struct PoolRequest;
friend struct PoolConnInfo;
friend struct PoolHost;
typedef std::map< std::string, PoolHost * > HostMap;
HostMap ht;
lcb_settings *settings;
lcbio_pTABLE io;
Options options;
unsigned refcount;
};
} // namespace io
} // namespace lcb
#endif
/**@}*/
#endif /* LCB_SOCKPOOL_H */
|
cf6dc93e5ecbba7f79efc5db6e12123778ce77b8
|
572580660d475027fa349e47a078479222066726
|
/Server/kennel/๏ฟฝ๏ฟฝ๏ฟฝ๏ฟฝ๏ฟฝ๏ฟฝ๏ฟฝฬจ/MonitorSchedule/StateConditionItem.h
|
95429d18781e85d9d1de23d49d21cf84663c0154
|
[] |
no_license
|
SiteView/ecc82Server
|
30bae118932435e226ade01bfbb05b662742e6dd
|
084b06af3a7ca6c5abf5064e0d1f3f8069856d25
|
refs/heads/master
| 2021-01-10T21:11:37.487455
| 2013-01-16T09:22:02
| 2013-01-16T09:22:02
| 7,639,874
| 6
| 3
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 375
|
h
|
StateConditionItem.h
|
//#pragma once
#ifndef DRAGONFLOW_STATECONDITIONITEM
#define DRAGONFLOW_STATECONDITIONITEM
#include "MonitorSchedule.h"
class StateConditionItem
{
public:
int m_ItemID;
CString m_ParamName;
char m_Operator[10];
CString m_ParamValue;
StateConditionItem(void);
~StateConditionItem(void);
};
typedef std::list<StateConditionItem *> CStateConditionItemList;
#endif
|
37ae1170cb8e15c608b475d6d7041317817eb73e
|
2fa764b33e15edd3b53175456f7df61a594f0bb5
|
/appseed/core/user/simple/simple_tab_ctrl.cpp
|
8c87f5626d1f9f8110ba940554918f7c7271a923
|
[] |
no_license
|
PeterAlfonsLoch/app
|
5f6ac8f92d7f468bc99e0811537380fcbd828f65
|
268d0c7083d9be366529e4049adedc71d90e516e
|
refs/heads/master
| 2021-01-01T17:44:15.914503
| 2017-07-23T16:58:08
| 2017-07-23T16:58:08
| 98,142,329
| 1
| 0
| null | 2017-07-24T02:44:10
| 2017-07-24T02:44:10
| null |
UTF-8
|
C++
| false
| false
| 756
|
cpp
|
simple_tab_ctrl.cpp
|
#include "framework.h"
//#include "simple_tab_control.h"
simple_tab_control::simple_tab_control(::aura::application * papp):
object(papp),
::user::interaction(papp),
::user::tab(papp),
place_holder_container(papp)
{
}
simple_tab_control::~simple_tab_control()
{
}
void simple_tab_control::_001OnDraw(::draw2d::graphics * pgraphics)
{
::user::tab::_001OnDraw(pgraphics);
}
void simple_tab_control::pre_subclass_window()
{
_001BaseWndInterfaceMap();
::user::interaction::pre_subclass_window();
}
void simple_tab_control::install_message_handling(::message::dispatch * pinterface)
{
::user::interaction::install_message_handling(pinterface);
::user::interaction_base::install_message_handling(pinterface);
}
|
04a06f3581143d74850b95dc3e9bdb6880fd7d40
|
387a33a39a9c3dd22603d5510de0eae86ce8250e
|
/zmmo_server/zmmo_server/game.h
|
aaa0d107c418c46097b58230633af6fce58cfde5
|
[] |
no_license
|
DuckMonster/zombiemmo
|
e873eb9023ad80e2a2b9625265277e17c07b632b
|
05e4ea604da64b5d0806757f7def2fc47e878de6
|
refs/heads/master
| 2020-04-24T02:14:50.810929
| 2016-12-07T13:59:21
| 2016-12-07T13:59:21
| 75,840,929
| 1
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 2,293
|
h
|
game.h
|
#pragma once
#include "map.h"
#include "entity.h"
#include "actor.h"
#include "player.h"
#include "collection.h"
#include "collision.h"
#include "playercontroller.h"
#include "chunk.h"
#include "line.h"
class CProgram;
class CGame {
public:
CGame( CProgram* program );
~CGame( );
void Update( float delta );
void PlayerJoin( const player_id id );
void PlayerPacket( const player_id id, const net::packet& pkt );
void PlayerLeave( const player_id id );
template<typename T>
T* SpawnEntity( );
void DestroyEntity( CEntity* ptr );
template<typename T>
T* GetEntity( size_t id ) { return dynamic_cast<T*>(GetEntity( id )); }
CEntity* GetEntity( size_t id ) { return m_EntityList[id]; }
template<typename T>
T* GetClosestEntity( const glm::ivec2& origin, int radius, T* entity );
CPlayer* GetPlayerEntity( player_id id ) { return GetEntity<CPlayer>( m_PlayerLookup[id] ); }
player_id_list GetAllPlayers( ) { return m_Players; }
CProgram* const GetProgram( ) { return m_Program; }
CMap* const GetMap( ) { return &m_Map; }
CChunk* const GetChunk( glm::ivec2 index );
CChunk* const FindChunk( glm::ivec2 world );
std::vector<CChunk*> const FindChunks( rect& r );
private:
CProgram* const m_Program;
CMap m_Map;
player_id_list m_Players;
CCollection<CEntity> m_EntityList;
std::array<entity_id, 1024> m_PlayerLookup;
std::vector<CChunk> m_ChunkList;
};
template<typename T>
inline T* CGame::SpawnEntity( ) {
size_t id = m_EntityList.GetNextID( );
T* entity = new T( this, id );
m_EntityList.Add( entity );
return entity;
}
template<typename T>
inline T* CGame::GetClosestEntity( const glm::ivec2 & origin, int radius, T * entity ) {
std::vector<CChunk*> chunks = FindChunks( rect( origin - glm::ivec2( radius ), glm::ivec2( radius * 2 + 1 ) ) );
T* best_Entity = NULL;
int best_Distance = 0;
for (size_t i = 0; i < chunks.size( ); i++) {
const std::vector<entity_id>& entities = chunks[i]->AllEntities( );
for (size_t j = 0; j < entities.size( ); j++) {
T* e = GetEntity<T>( entities[j] );
if (e) {
int distance = math::ilength( e->GetPosition( ) - origin );
if (best_Entity == NULL || best_Distance < distance) {
best_Entity = e;
best_Distance = distance;
}
}
}
}
return best_Entity;
}
|
d1648033e4b044cbccc2c43f700b76f53574b33f
|
fdbe0d1a03ca5b44ba83a7c386639ebbc2aca19e
|
/revision of c/palindromes in list.cpp
|
c71860333ac5398149cd0fa782b07cee10913f23
|
[] |
no_license
|
Mohanakhil/output-of-devc-
|
cdfbd89f41035ef2983d67b7924654de540403e3
|
aed25e14f79c4e0d207b5afb74e8f0c19d7f71f4
|
refs/heads/master
| 2023-03-07T13:24:25.237712
| 2021-02-09T11:11:52
| 2021-02-09T11:11:52
| 337,379,214
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 1,807
|
cpp
|
palindromes in list.cpp
|
#include<stdio.h>
#include<stdlib.h>
struct node
{
int data;
struct node *next;
};
void create(struct node **head,int newdata)
{ struct node *newnode=(struct node*)malloc(sizeof(struct node));
newnode->data=newdata;
newnode->next=*head;
*head=newnode;
}
int palindrome(struct node **head)
{ int c=0,i=1,s=1;
struct node *node1=*head;
while(node1!=NULL)
{ c=c+1;
node1=node1->next;
}
printf("count of ele is %d\n",c);
struct node *node2=*head;
while(i<=c/2)
{ node2=node2->next;
i++;
}
struct node *node3=NULL;
printf("mid ele is %d\n",node2->data); printf("value of c/2 is %d",c%2);
if(c%2==0)
{
while(node2!=NULL)
{
int newdata=node2->data;
struct node *newnode=(struct node*)malloc(sizeof(struct node));
newnode->data=newdata;
newnode->next=node3;
node3=newnode; printf("\n now node3 gas %d \n",node3->data);
node2=node2->next;
}
}
if(c%2!=0)
{ node2=node2->next;
while(node2!=NULL)
{
int newdata=node2->data;
struct node *newnode=(struct node*)malloc(sizeof(struct node));
newnode->data=newdata;
newnode->next=node3;
node3=newnode; printf("\n now node3 has %d \n",node3->data);
node2=node2->next;
}
}
struct node *node4=node3;
while(node4!=NULL)
{
printf("%d \n\n",node4->data);
node4=node4->next;
}
struct node *node5=*head;i=1;
while(node3!=NULL)
{
if(node3->data!=node5->data) s=0;
node3=node3->next;node5=node5->next;
}
return s;
}
main()
{
int a=0,b=0,s=0;
do{struct node *head=NULL;
do{
printf("enter ele\n");
scanf("%d",&a);
create(&head,a);
printf("press 2 to terminate\n");
scanf("%d",&b);
}while(b!=2);
struct node *node1=head;
while(node1!=NULL)
{
printf("%d ",node1->data);
node1=node1->next;
}
s=palindrome(&head);
if(s==0) printf("it is not a palindrome\n");
else
printf("it is a palindrome\n");
printf("press 2 to terminate\n");
scanf("%d",&b);
}while(b!=2);
}
|
9c05ad830110085c0c06b90a4e50368ca0841fc0
|
e3505cfd86c57b1869c2885a3a44550af552d483
|
/source/resource/pluginUtilities/cxServiceTrackerListener.h
|
934ad810badeca90b6d2c30ec542e56fb331fdfc
|
[
"BSD-3-Clause"
] |
permissive
|
leettran/CustusX
|
afb6a3bc6607bf28fa1c94f94b66cf9979728cd5
|
b4e64e0db364da189ee9eafa54ce0ab258f5105a
|
refs/heads/master
| 2021-07-14T03:33:55.038281
| 2017-02-09T09:29:57
| 2017-02-09T09:29:57
| null | 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 4,739
|
h
|
cxServiceTrackerListener.h
|
/*=========================================================================
This file is part of CustusX, an Image Guided Therapy Application.
Copyright (c) 2008-2014, SINTEF Department of Medical Technology
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
1. Redistributions of source code must retain the above copyright notice,
this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation
and/or other materials provided with the distribution.
3. Neither the name of the copyright holder nor the names of its contributors
may be used to endorse or promote products derived from this software
without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
=========================================================================*/
#ifndef CXSERVICETRACKERLISTENER_H_
#define CXSERVICETRACKERLISTENER_H_
#include <QSharedDataPointer>
#include <boost/function.hpp>
#include <boost/shared_ptr.hpp>
#undef REGISTERED //Needed on windows to avoid compiler error. Not sure why.
#include <ctkServiceEvent.h>
#include "ctkServiceTracker.h"
#include "ctkServiceTrackerCustomizer.h"
#include "ctkPluginContext.h"
#include <ctkPluginFramework.h>
#include "cxServiceTrackerCustomizer.h"
namespace cx
{
/**
* \brief Helper class for listening to services being added, modified and removed.
*
* Usage example:
* For listening to ReconstructionServices being added and removed, but ignoring if they are modified
*
* NB: This class can only be used with a valid plugin context.
* And plugin contexts are only valid when the plugin framework is in one of these states: ACTIVE, STARTING and STOPPING
*
* boost::shared_ptr<ServiceTrackerListener<ReconstructionService> > mServiceListener;
* mServiceListener.reset(new ServiceTrackerListener<ReconstructionService>(
* LogicManager::getInstance()->getPluginFramework(),
* boost::bind(&ReconstructManager::onServiceAdded, this, _1),
* boost::bind(&ReconstructManager::onServiceModified, this, _1),
* boost::bind(&ReconstructManager::onServiceRemoved, this, _1)
* ));
*
*
* \ingroup cx_logic
* \date May 14, 2014
* \author Janne Beate Bakeng, SINTEF
*/
template <class T >
class ServiceTrackerListener
{
public:
ServiceTrackerListener(ctkPluginContext* context,
boost::function<void (T*)> serviceAdded,
boost::function<void (T*)> serviceModified,
boost::function<void (T*)> serviceRemoved)
{
boost::shared_ptr<ServiceTrackerCustomizer<T> > customizer(new ServiceTrackerCustomizer<T>);
mServiceTrackerCustomizer = customizer;
mServiceTrackerCustomizer->setServiceAddedCallback(serviceAdded);
mServiceTrackerCustomizer->setServiceModifiedCallback(serviceModified);
mServiceTrackerCustomizer->setServiceRemovedCallback(serviceRemoved);
mServiceTracker.reset(new ctkServiceTracker<T*>(context, mServiceTrackerCustomizer.get()));
}
~ServiceTrackerListener()
{
// mServiceTracker->close();//For some reason this causes a crash if a service (that uses another service with a ServiceTrackerListener) have been removed
//If close is needed: A possible workasround may be to clear all functions in mServiceTrackerCustomizer?
// mServiceTracker.reset();
}
void open()
{
mServiceTracker->open();
}
T* getServiceFromName(QString name)
{
QList<T*> services = mServiceTracker->getServices();
foreach(T* temp, services)
if(temp->getName() == name)
return temp;
return NULL;
}
QList<T*> getServices()
{
return mServiceTracker->getServices();
}
private:
boost::shared_ptr<ServiceTrackerCustomizer<T> > mServiceTrackerCustomizer;
boost::shared_ptr<ctkServiceTracker<T*> > mServiceTracker;
};
}//namespace cx
#endif /* CXSERVICETRACKERLISTENER_H_ */
|
89081f4378c60e150cc4c7984f5291239b870cb1
|
54da97058e1319bf0bc1c60198558aeb6b004ecd
|
/Material/AceTable/AceReaction/EnergySampler.hpp
|
c71d0a922f4af8a13d4f4f667b89eadc26d3cecb
|
[
"BSD-3-Clause"
] |
permissive
|
khurrumsaleem/helios
|
202021d96490bd4ad117ccc1196799c019285e7a
|
fe7a06992abcf495d9b09d2d172b8cc6fdd67b80
|
refs/heads/master
| 2022-01-24T21:45:51.088917
| 2020-06-27T05:19:10
| 2020-06-27T05:19:10
| 205,647,629
| 0
| 0
| null | 2019-09-01T08:08:19
| 2019-09-01T08:08:19
| null |
UTF-8
|
C++
| false
| false
| 6,752
|
hpp
|
EnergySampler.hpp
|
/*
Copyright (c) 2012, Esteban Pellegrino
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
* Neither the name of the <organization> nor the
names of its contributors may be used to endorse or promote products
derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef ENERGYSAMPLER_HPP_
#define ENERGYSAMPLER_HPP_
#include <algorithm>
#include "../../../Common/Common.hpp"
#include "../../../Transport/Particle.hpp"
#include "../AceReader/EnergyDistribution.hpp"
#include "../AceModule.hpp"
namespace Helios {
namespace AceReaction {
/*
* Base class to deal with energy samplers
*/
class EnergySamplerBase {
public:
EnergySamplerBase() {/* */}
/* Exception */
class BadEnergySamplerCreation : public std::exception {
std::string reason;
public:
BadEnergySamplerCreation(const std::string& msg) {
reason = "Cannot create energy sampler : " + msg;
}
const char *what() const throw() {
return reason.c_str();
}
~BadEnergySamplerCreation() throw() {/* */};
};
/* Sample energy (and MU if information exists) using particle's information */
virtual void setEnergy(const Particle& particle, Random& random, double& energy, double& mu) const = 0;
/* Print internal data of the energy sampler */
virtual void print(std::ostream& out) const = 0;
virtual ~EnergySamplerBase() {/* */}
};
class EnergySamplerFactory {
const AceIsotopeBase* isotope;
public:
EnergySamplerFactory(const AceIsotopeBase* isotope) : isotope(isotope) {/* */}
/* Create law */
EnergySamplerBase* createLaw(const Ace::EnergyDistribution::EnergyLaw* ace_law, const Ace::NeutronReaction& ace_reaction) const;
/* Create a new energy sampler using information parsed from the ACE cross section file */
EnergySamplerBase* createSampler(const Ace::NeutronReaction& ace_reaction) const;
~EnergySamplerFactory() {/* */}
};
/* Sample energy (and MU if available) using one ACE law */
template<class LawPolicy>
class EnergySampler : public EnergySamplerBase, public LawPolicy {
typedef Ace::EnergyDistribution::EnergyLaw EnergyLaw;
public:
/* Constructor for using multiple laws */
template<class PolicyData>
EnergySampler(PolicyData ace_data) : LawPolicy(ace_data) {/* */}
/* Constructor for using multiple laws (and additional parameters) */
template<class PolicyData, class Additional>
EnergySampler(PolicyData ace_data, Additional additional) : LawPolicy(ace_data, additional) {/* */}
/* Constructor for using multiple laws (and additional parameters) */
template<class PolicyData, class Additional1, class Additional2>
EnergySampler(PolicyData ace_data, Additional1 additional1, Additional2 additional2) :
LawPolicy(ace_data, additional1, additional2) {/* */}
/* -- Overload base classes of the energy sampler */
/* Sample energy (and MU if information exists) using particle's information */
void setEnergy(const Particle& particle, Random& random, double& energy, double& mu) const {
LawPolicy::setEnergy(particle, random, energy, mu);
}
/* Print internal data of the energy sampler */
void print(std::ostream& out) const {
LawPolicy::print(out);
}
~EnergySampler() {/* */}
};
/* Sample energy (and MU if available) using more than one ACE law */
class MultipleLawsSampler : public EnergySamplerBase {
typedef Ace::EnergyDistribution::EnergyLaw EnergyLaw;
/* Law validity data */
struct LawValidity {
/* Tabulated energies */
std::vector<double> energy;
/* Probabilities */
std::vector<double> prob;
/* Law */
EnergySamplerBase* energy_law;
LawValidity(const std::vector<double>& energy, const std::vector<double>& prob, EnergySamplerBase* energy_law) :
energy(energy), prob(prob), energy_law(energy_law) {/* */}
/* Get probability at some energy */
double getProbability(double erg) const {
if(erg <= energy[0]) return prob[0];
else if(erg >= energy[energy.size() - 1]) return prob[prob.size() - 1];
/* Make an interpolation and return the value */
size_t idx = std::upper_bound(energy.begin(), energy.end(), erg) - energy.begin() - 1;
/* Energy bounds */
double low = energy[idx];
double high = energy[idx + 1];
/* Interpolation factor */
double factor = (erg - low) / (high - low);
/* Apply interpolation factor to the probability */
return prob[idx] + factor * (prob[idx + 1] - prob[idx]);
}
~LawValidity() {/* */}
};
/* Container of law data */
std::vector<LawValidity> law_table;
public:
/* Constructor (grab a vector of laws) */
MultipleLawsSampler(const vector<EnergyLaw*>& laws, const Ace::NeutronReaction& ace_reaction, const EnergySamplerFactory* factory);
/* -- Overload base classes of the energy sampler */
/* Sample energy (and MU if information exists) using particle's information */
void setEnergy(const Particle& particle, Random& random, double& energy, double& mu) const {
/* Random number */
double chi = random.uniform();
/* Sample law */
std::vector<LawValidity>::const_iterator it = law_table.begin();
for( ; it != law_table.end() - 1 ; ++it) {
chi -= (*it).getProbability(particle.getEnergy().second);
if(chi <= 0.0) {
(*it).energy_law->setEnergy(particle, random, energy, mu);
return;
}
}
(*it).energy_law->setEnergy(particle, random, energy, mu);
}
/* Print internal data of the energy sampler */
void print(std::ostream& out) const;
~MultipleLawsSampler() {/* */}
};
}
}
#endif /* ENERGYSAMPLER_HPP_ */
|
630a19389e52a2252340863e4e53a06e9e58494f
|
71b972e06defda5e5d61d95cf41b050d381931d9
|
/Libreria/FORMAS/Ayuda.cpp
|
5673d7330331e044f902dafc515d09d8d92aeb73
|
[] |
no_license
|
antoniocarrillo69/Alarma
|
c742d48be6fd6266294ffedd9e81cc5f51b5ae19
|
42cc1c42966ec2e6fcf9b9276fa6056feb435d50
|
refs/heads/master
| 2021-01-19T14:01:27.850391
| 2017-04-13T03:35:35
| 2017-04-13T03:35:35
| 88,121,492
| 0
| 1
| null | null | null | null |
ISO-8859-1
|
C++
| false
| false
| 2,875
|
cpp
|
Ayuda.cpp
|
// Autor: Antonio Carrillo Ledesma.
// R.F.C.: CALA-691229-TV5
// Direcciรณn: Amsterdam 312 col. Hipodromo Condesa
// Telรฉfono: 5-74-43-53
// Propiedad intelectual, todos los derechos reservados conforme a la ley, registro en trย mite
// Revisiรณn 1.0-A
#include <vcl.h>
#include <stdlib.h>
#include "d:\libreria\Formas\Ayuda.h"
#include "d:\Libreria\Formas\AcercaDe.h"
#pragma hdrstop
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
//---------------------------------------------------------------------------
__fastcall TAyudaForm::TAyudaForm(TComponent* Owner): TForm(Owner)
{
}
// Abre el archivo por omision
void TAyudaForm::Abrir_archivo(char *tit, char *arch)
{
TITULO = tit;
ARCHIVO = arch;
Caption = TITULO;
EditorAyuda->Clear();
if(arch[0]) EditorAyuda->Lines->LoadFromFile(ARCHIVO);
}
// Imprime el archivo
void __fastcall TAyudaForm::imprimir1Click(TObject *Sender)
{
EditorAyuda->Print(TITULO);
}
// Configura la impresora
void __fastcall TAyudaForm::Configurarimpresora1Click(TObject *Sender)
{
PrintDialog->Execute();
}
// Salir del programa
void __fastcall TAyudaForm::Salir1Click(TObject *Sender)
{
Close();
}
// Copia el texto seleccionado
void __fastcall TAyudaForm::Copiar1Click(TObject *Sender)
{
EditorAyuda->CopyToClipboard();
}
// Selecciona todo el texto
void __fastcall TAyudaForm::Seleccionartodo1Click(TObject *Sender)
{
EditorAyuda->SelectAll();
}
// Muestra la ventana de acerca de ...
void __fastcall TAyudaForm::Acercade1Click(TObject *Sender)
{
TAcercaDeForm *AcercaDeForm = new TAcercaDeForm(this);
AcercaDeForm->Muestra_ventana_AcercaDe(TITULO);
delete AcercaDeForm;
}
void __fastcall TAyudaForm::Buscar1Click(TObject *Sender)
{
FindDialog->FindText = EditorAyuda->SelText;
FindDialog->Execute();
}
void __fastcall TAyudaForm::FindDialogFind(TObject *Sender)
{
Show();
TSearchTypes st;
TFindDialog *cd;
int newpos;
if ((cd = dynamic_cast<TFindDialog *> (Sender)) == 0) MessageBox(NULL, "Error en solicitud de memoria dinรกmica", "Buscar", MB_OK + MB_ICONSTOP);
if (cd->Options.Contains(frMatchCase)) st << stMatchCase;
if (cd->Options.Contains(frWholeWord)) st << stWholeWord;
if (EditorAyuda->SelLength) EditorAyuda->SelStart += 1;
newpos = EditorAyuda->FindText(cd->FindText, EditorAyuda->SelStart, EditorAyuda->Text.Length(), st);
if (newpos != -1) {
EditorAyuda->SelStart = newpos;
EditorAyuda->SelLength = cd->FindText.Length();
} else {
MessageBox(NULL, "Fin del documento", "Buscar", MB_OK + MB_ICONINFORMATION);
EditorAyuda->SelStart = 0;
}
}
|
d899e617f05ad2b1fed36a7367d23f1afb580c97
|
5b965ace4c7a619e439ba32cbc811f2cb14d956d
|
/Basic/Array/Learning Output.cpp
|
9b8f62b8633e65a5c2d8aa62a026d03d03e05e47
|
[] |
no_license
|
R4GH4V/geeksforgeeks-Practise
|
96da525232c3665900ddbca2499e271bf1eb34b9
|
9cde59f68d3d6bd6a37e60ccf595808b9daabcd7
|
refs/heads/master
| 2020-12-30T14:56:58.629472
| 2018-01-01T05:15:00
| 2018-01-01T05:15:00
| 91,097,199
| 0
| 1
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 1,405
|
cpp
|
Learning Output.cpp
|
/*
Being a Programmer you have to learn how to make your output looks better. According to the company, its company programmers have to present its output in a different manner as : If your output is 10.000000 you can save the decimal places and thus your output becomes 10. Now u have the learn the way to output. You are given elements of an array A[N] and you have to divide N by total no. of +ve integers, N by total no. of -ve integers and N by total no. of zero value integers.
Input :
The first line of input contains an integer T denoting the no of test cases. Then T test cases follow.
Second line contains N - array size. Third line contains the elements of array.
Output :
For each test case in a new line print the division value of
N by Total no. of +ve integers
N by Total no. of -ve integers
N by Total no. of zero value integers
Constraints :
1 โค T โค 50
1 โค N โค 100
1 โค A[i] โค 1000
Input :
1
10
7 7 7 7 7 7 -9 -9 -9 0
Output :
1.66667
3.33333
10
*/
#include<iostream>
using namespace std;
int main()
{
int t,n,np,nn,nz,i;
cin>>t;
while(t--)
{
np=nn=nz=0;
cin>>n;
int a[n];
for(i=0;i<n;i++)
{
cin>>a[i];
if(a[i]>0)
np++;
else if(a[i]<0)
nn++;
else
nz++;
}
cout<<(double) n/np<<endl;
cout<<(double) n/nn<<endl;
cout<<(double) n/nz<<endl;
}
return 0;
}
|
6ab5cd8ea1fa8184892991bb57a6ce91ab2f5a4c
|
fb9bcf29dde6cf613852ae6caa6513b56d2447f4
|
/Uebung3/Uebung3/view/window.hpp
|
c2b0f3c79f917b3a9c463b0b15e9dd0bd56a6c3e
|
[] |
no_license
|
eliza90/cpp4cg3
|
3ed551aafebe86374ea6e0719d014d803ed9a95f
|
3caa87a2e60fe939d8140f423bf0e19fe0792524
|
refs/heads/master
| 2020-04-01T21:26:24.979304
| 2014-05-13T18:15:13
| 2014-05-13T18:15:13
| null | 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 863
|
hpp
|
window.hpp
|
#pragma once
#include "../stdafx.h"
#include <exception>
#include <memory>
namespace view{
class Window{
public:
Window(size_t width, size_t height, const std::string& name);
~Window(){}
unsigned int width() const{ return _width; }
unsigned int height() const{ return _height; }
// request window redisplay
void invalidate();
protected:
virtual bool display();
virtual void reshape(int width, int height);
virtual void keyboard(unsigned char glut_key, int mouse_x, int mouse_y);
private:
// make sure this Window is the current GLUT Window
void ensureCurrent() const;
static void glutDisplay();
static void glutReshape(int width, int height);
static void glutKeyboard(unsigned char glut_key, int mouse_x, int mouse_y);
std::string _name;
size_t _width;
size_t _height;
int _glut_win_id;
}; // Window
} // view::
|
31375b54ef47316f0b497e70df9219be37ac939e
|
8c2e7b8aad0d4a70178d3a6e3b5cbd9400db37a9
|
/DataFormats/CaloTowers/src/classes.h
|
01e8f9186d8fd0424c4d85d4b20245a1891de699
|
[
"Apache-2.0"
] |
permissive
|
cecilecaillol/cmssw
|
96961b5815d0d6e7127a6f59c882ec5b8e86feb8
|
3d70b56717b9b8d49aaffcdbef6fb68e3b81fddb
|
refs/heads/l1t-integration-CMSSW_10_3_1
| 2023-03-17T06:40:24.755366
| 2019-04-16T11:06:39
| 2019-04-16T11:06:39
| 331,005,975
| 0
| 2
|
Apache-2.0
| 2023-02-08T14:43:10
| 2021-01-19T14:25:16
|
C++
|
UTF-8
|
C++
| false
| false
| 1,595
|
h
|
classes.h
|
#include "Math/Cartesian3D.h"
#include "Math/Polar3D.h"
#include "Math/CylindricalEta3D.h"
#include "DataFormats/CaloTowers/interface/CaloTowerCollection.h"
#include "DataFormats/Common/interface/Wrapper.h"
#include "DataFormats/Common/interface/RefHolder.h"
#include "DataFormats/Common/interface/Holder.h"
#include "DataFormats/Common/interface/RefVectorHolder.h"
#include "DataFormats/Common/interface/VectorHolder.h"
#include "DataFormats/Common/interface/PtrVector.h"
#include "DataFormats/Common/interface/FwdRef.h"
#include "DataFormats/Common/interface/FwdPtr.h"
#include "DataFormats/Common/interface/AtomicPtrCache.h"
namespace DataFormats_CaloTowers {
struct dictionary {
std::vector<CaloTower> v1;
CaloTowerCollection c1;
CaloTowerPtr p1;
CaloTowerFwdPtr fp1;
CaloTowerRef r1;
CaloTowersRef rr1;
CaloTowerRefs rrr1;
CaloTowerFwdRef rrrr1;
CaloTowerFwdRefVector rrrrv1;
CaloTowerFwdPtr rrrrr1;
CaloTowerFwdPtrVector rrrrrv1;
edm::Wrapper<CaloTowerCollection> w1;
edm::Wrapper<CaloTowerFwdRefVector> w2;
edm::Wrapper<CaloTowerFwdPtrVector> w3;
edm::Wrapper< std::vector<CaloTower> > w4;
edm::reftobase::Holder<reco::Candidate, CaloTowerRef> rbh;
edm::reftobase::RefHolder<CaloTowerRef> rbrh;
edm::reftobase::VectorHolder<reco::Candidate, CaloTowerRefs> rbhs;
edm::reftobase::RefVectorHolder<CaloTowerRefs> rbrhs;
edm::PtrVector<CaloTower> ptrv;
std::vector<edm::Ptr<CaloTower> > vp1;
std::vector<CaloTowerDetId> vctdi;
edm::AtomicPtrCache<std::vector<CaloTowerPtr> > easvrp;
};
}
|
3143257bdd439f06f6f45a33393c38c5f28c7e9c
|
bca6d0ddae9475c6ffe6d5d9e31614abb63fce3e
|
/Code/src/ardrone_velocity_ekf/include/ardrone_velocity_ekf/pose_controller.hpp
|
8de1f6330236b988434c450225c7a2a5fb8844a3
|
[] |
no_license
|
Forener01/Drone_thesis_2017_old2
|
2860adfcd1705f632970e8ae59eef55ba5267940
|
c9f5845cde6dbaf52db602353c22cacad352b51d
|
refs/heads/master
| 2021-08-29T02:11:16.072982
| 2017-12-13T12:31:21
| 2017-12-13T12:31:21
| 108,832,385
| 1
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 817
|
hpp
|
pose_controller.hpp
|
#ifndef POSE_CONTROL_HPP
#define POSE_CONTROL_HPP
#include <geometry_msgs/Pose.h>
#include <geometry_msgs/Twist.h>
#include <math.h>
#include <nav_msgs/Odometry.h>
#include <ros/ros.h>
#include <stdio.h>
#include <ardrone_velocity_ekf/test_controller.hpp>
class Pose_Control {
public:
Pose_Control();
ros::NodeHandle nh;
ros::Subscriber odom_sub, poseref_sub;
ros::Publisher veltoPID_pub;
void poserefCb(const geometry_msgs::Pose &pose_in);
void odomCb(const nav_msgs::Odometry &odo);
void load_pose(double X, double Y, double Z);
void position_control(void);
int test_type;
private:
geometry_msgs::Twist velInPID;
geometry_msgs::Pose current_pose_ref, pose_out;
nav_msgs::Odometry odo_msg;
double K, tol, tolz;
double distX, distY, distZ, error_dist;
};
#endif // POSE_CONTROL_HPP
|
68f130fc387103ac3c8406b51fb7db3725e6a153
|
f1b4399af130b02b13a4d071ff832ed28ede151c
|
/src/ispdb/autotests/autoconfigkolabldaptest.cpp
|
b6c9b52edfe4da2cc930dc2f73faae47dbef95e6
|
[
"BSD-3-Clause"
] |
permissive
|
KDE/kmail-account-wizard
|
220a1ab089a744cab1592c3620ccf6b7f8535370
|
81f01fa5957b5df6c90c49cd38230e3121a85bcb
|
refs/heads/master
| 2023-08-17T09:59:37.859362
| 2023-08-08T01:52:18
| 2023-08-08T01:52:18
| 66,907,965
| 5
| 1
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 7,042
|
cpp
|
autoconfigkolabldaptest.cpp
|
/*
SPDX-FileCopyrightText: 2014 Sandro Knauร <knauss@kolabsys.com>
SPDX-License-Identifier: LGPL-2.0-or-later
*/
#include <QObject>
#include <QProcess>
#include <QTcpSocket>
#include <QTest>
#include "../autoconfigkolabldap.h"
class TAutoconfLdap : public AutoconfigKolabLdap
{
public:
void startJob(const QUrl &url) override
{
QCOMPARE(url, expectedUrls.takeFirst());
if (replace.contains(url)) {
AutoconfigKolabLdap::startJob(replace[url]);
} else {
AutoconfigKolabLdap::startJob(url);
}
}
QMap<QUrl, QUrl> replace;
QList<QUrl> expectedUrls;
};
class AutoconfLdapTest : public QObject
{
Q_OBJECT
public:
AutoconfigKolabLdap *execIspdb(const QString &file)
{
const QString filePath = QStringLiteral(AUTOCONFIG_DATA_DIR) + QLatin1Char('/') + file;
[](const QString &file) {
QVERIFY(QFile(file).exists());
}(filePath);
QEventLoop loop;
TAutoconfLdap *ispdb = new TAutoconfLdap();
connect(ispdb, &AutoconfigKolabLdap::finished, &loop, &QEventLoop::quit);
const QUrl url = QUrl::fromLocalFile(filePath);
ispdb->setEmail(QStringLiteral("john.doe@example.com"));
ispdb->expectedUrls.append(url);
ispdb->startJob(url);
loop.exec();
return ispdb;
}
void testLdapServer(const ldapServer &test, const ldapServer &expected) const
{
QCOMPARE(test.hostname, expected.hostname);
QCOMPARE(test.port, expected.port);
QCOMPARE(test.socketType, expected.socketType);
QCOMPARE(test.authentication, expected.authentication);
QCOMPARE(test.bindDn, expected.bindDn);
QCOMPARE(test.password, expected.password);
QCOMPARE(test.saslMech, expected.saslMech);
QCOMPARE(test.username, expected.username);
QCOMPARE(test.realm, expected.realm);
QCOMPARE(test.dn, expected.dn);
QCOMPARE(test.ldapVersion, expected.ldapVersion);
QCOMPARE(test.filter, expected.filter);
QCOMPARE(test.pageSize, expected.pageSize);
QCOMPARE(test.timeLimit, expected.timeLimit);
QCOMPARE(test.sizeLimit, expected.sizeLimit);
}
bool checkServerReady() const
{
QTcpSocket socket;
socket.connectToHost(QStringLiteral("localhost"), 8000);
return socket.waitForConnected(5000);
}
private Q_SLOTS:
void testLdapParsing()
{
AutoconfigKolabLdap *ispdb = execIspdb(QStringLiteral("ldap.xml"));
ldapServer s;
QCOMPARE(ispdb->ldapServers().count(), 2);
s.hostname = QStringLiteral("ldap.example.com");
s.port = 389;
s.socketType = KLDAP::LdapServer::None;
s.authentication = KLDAP::LdapServer::Simple;
s.bindDn = QStringLiteral("cn=Directory Manager");
s.password = QStringLiteral("Welcome2KolabSystems");
s.saslMech = QString();
s.username = QString();
s.realm = QString();
s.dn = QStringLiteral("dc=kolabsys,dc=com");
s.ldapVersion = 3;
s.filter = QString();
s.pageSize = -1;
s.timeLimit = -1;
s.sizeLimit = -1;
testLdapServer(ispdb->ldapServers()[QStringLiteral("ldap.example.com")], s);
s.hostname = QStringLiteral("ldap2.example.com");
s.port = 387;
s.socketType = KLDAP::LdapServer::SSL;
s.authentication = KLDAP::LdapServer::SASL;
s.bindDn = QStringLiteral("cn=Directory");
s.password = QStringLiteral("Welcome2KolabSystems");
s.saslMech = QStringLiteral("XXX");
s.username = QStringLiteral("john.doe");
s.realm = QStringLiteral("realm.example.com");
s.dn = QStringLiteral("dc=example,dc=com");
s.ldapVersion = 3;
s.filter = QString();
s.pageSize = 10;
s.timeLimit = -1;
s.sizeLimit = 9999999;
testLdapServer(ispdb->ldapServers()[QStringLiteral("ldap2.example.com")], s);
}
void testLdapCompleteFail()
{
QEventLoop loop;
TAutoconfLdap *ispdb = new TAutoconfLdap();
connect(ispdb, &AutoconfigKolabLdap::finished, &loop, &QEventLoop::quit);
connect(ispdb, &AutoconfigKolabLdap::finished, this, &AutoconfLdapTest::expectedReturn);
QUrl expected(QStringLiteral("http://autoconfig.example.com/ldap/config-v1.0.xml"));
QUrl expected2(QStringLiteral("http://example.com/.well-known/autoconfig/ldap/config-v1.0.xml"));
mReturn = false;
ispdb->setEmail(QStringLiteral("john.doe@example.com"));
ispdb->expectedUrls.append(expected);
ispdb->expectedUrls.append(expected2);
ispdb->replace[expected] = QStringLiteral("http://localhost:8000/500");
ispdb->replace[expected2] = QStringLiteral("http://localhost:8000/404");
ispdb->start();
loop.exec();
QCOMPARE(ispdb->expectedUrls.count(), 0);
}
void testLdapLogin()
{
const QString filePath = QStringLiteral(AUTOCONFIG_DATA_DIR) + QStringLiteral("/ldap.xml");
QVERIFY(QFile(filePath).exists());
QEventLoop loop;
TAutoconfLdap *ispdb = new TAutoconfLdap();
connect(ispdb, &AutoconfigKolabLdap::finished, &loop, &QEventLoop::quit);
connect(ispdb, &AutoconfigKolabLdap::finished, this, &AutoconfLdapTest::expectedReturn);
QUrl expected(QStringLiteral("http://autoconfig.example.com/ldap/config-v1.0.xml"));
QUrl expected2(QStringLiteral("https://john.doe%40example.com:xxx@autoconfig.example.com/ldap/config-v1.0.xml"));
QUrl expected3(QStringLiteral("http://example.com/.well-known/autoconfig/ldap/config-v1.0.xml"));
mReturn = true;
ispdb->setEmail(QStringLiteral("john.doe@example.com"));
ispdb->setPassword(QStringLiteral("xxx"));
ispdb->expectedUrls.append(expected);
ispdb->expectedUrls.append(expected2);
ispdb->expectedUrls.append(expected3);
ispdb->replace[expected] = QStringLiteral("http://localhost:8000/401");
ispdb->replace[expected2] = QStringLiteral("http://localhost:8000/500");
ispdb->replace[expected3] = QUrl::fromLocalFile(filePath);
ispdb->start();
loop.exec();
QCOMPARE(ispdb->expectedUrls.count(), 0);
}
void expectedReturn(bool ret)
{
QCOMPARE(ret, mReturn);
}
void initTestCase()
{
const QString filePath = QStringLiteral(CURRENT_SOURCE_DIR "/errorserver.py");
QVERIFY(QFile(filePath).exists());
process.start(QStringLiteral("python"), QStringList() << filePath);
process.waitForStarted();
QCOMPARE(process.state(), QProcess::Running);
// Wait for the server to start listening
QTRY_VERIFY(checkServerReady());
}
void cleanupTestCase()
{
process.terminate();
process.waitForFinished();
}
public:
bool mReturn;
QProcess process;
};
QTEST_MAIN(AutoconfLdapTest)
#include "autoconfigkolabldaptest.moc"
|
7ba5c59d59be58904234ad163887ba916169635a
|
1d9b94e8130b0a3018d8b9b808ea6a502c513f73
|
/src/libsinks/WavFileSink.cpp
|
8567d80eb1ee75be550ae4be233004ebc9292292
|
[] |
no_license
|
elerer/ns
|
57db28bc92957bc195571050f187bb996d97d6e1
|
f86514fcbd07dce564acc689cc81f86fdc954e54
|
refs/heads/master
| 2020-03-21T01:27:12.294856
| 2018-07-05T20:43:22
| 2018-07-05T20:43:22
| 137,943,414
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 2,671
|
cpp
|
WavFileSink.cpp
|
#include <WavFileSink.h>
#include <iostream>
WavFileSink::WavFileSink(const size_t &numchannels, const size_t &samplerate, const size_t &bitrate,
const std::string &filename, const std::string &tmpPath, const std::string &path) : _numchannels(numchannels),
_samplerate(samplerate),
_bitrate(bitrate),
_filename(filename),
_tmpPath(tmpPath),
_path(path),
_fs(_tmpPath + _filename, std::ios::out | std::ios::binary | std::ios::ate),
_ht("/home/eranl/WAV_FILES/attack.wav")
{
if (_fs.is_open())
{
std::cout << "file " << _tmpPath + _filename << " is open\n";
}
}
WavFileSink::WavFileSink(const size_t &numchannels, const size_t &samplerate, const size_t &bitrate) : WavFileSink(numchannels, samplerate, bitrate, "def.wav", "/var/tmp/", "/home/eranl/WAV_FILES/")
{
}
WavFileSink::~WavFileSink()
{
Close();
}
void WavFileSink::StreamBytes(char *src, const size_t &num)
{
_fs.write(src, num);
}
void WavFileSink::Run()
{
}
void WavFileSink::Close()
{
if (_fs.is_open())
{
size_t fsize = _fs.tellp();
_fs.close();
writeWavFromTmpFile(fsize);
}
}
void WavFileSink::writeWavFromTmpFile(size_t fsize)
{
_ht.SetTemplate(_numchannels, _samplerate, _bitrate, fsize);
std::ifstream fsi (_tmpPath + _filename, std::ios::in | std::ios::binary);
//open final file write header and then tmp file content.
std::ofstream fso(_path + _filename, std::ios::out | std::ios::binary | std::ios::ate);
if (!fso.is_open())
{
std::cout << "couldnt open file " << _path + _filename << "\n";
return;
}
fso.write(_ht.GetHeaderBuffer(), _ht.Wav_header_Size);
char buffer[256];
fsi.seekg(0);
size_t bn = 0;
while(fsize > 0)
{
bn = fsize > 256 ? 256 : fsize;
fsize -= bn;
fsi.read(buffer,bn);
fso.write(buffer,bn);
}
fso.close();
}
|
e0e456bdd97f61b475a29cef76b71c3285bf5318
|
e1f44d7946a63d3cbd23a5863f238302bc44b231
|
/core/src/ColorNames.h
|
8e9b5fd8e9ab9a618ad1ac77b61305a468658ab4
|
[
"BSD-3-Clause"
] |
permissive
|
frankencode/fluxkit
|
c3c89f64ce6274cafc1b4ba4b7a4b68449832e17
|
0436454f0791d8fddf8e0adc383ef7c54080245d
|
refs/heads/master
| 2021-01-10T20:47:09.542803
| 2015-10-28T18:13:09
| 2015-10-28T18:13:09
| 565,413
| 3
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 740
|
h
|
ColorNames.h
|
/*
* Copyright (C) 2007-2015 Frank Mertens.
*
* Use of this source is governed by a BSD-style license that can be
* found in the LICENSE file.
*
*/
#ifndef FLUX_COLORNAMES_H
#define FLUX_COLORNAMES_H
#include <flux/Color>
namespace flux {
template<class Char, class Value> class PrefixTree;
template<class SubClass> class Singleton;
/** \brief Lookup table for SVG standard color names
*/
class ColorNames: public Object
{
public:
bool lookup(const char *name, Color *color) const;
private:
friend class Singleton<ColorNames>;
ColorNames();
typedef PrefixTree<char, Color> ColorByName;
Ref<ColorByName> colorByName_;
};
const ColorNames *colorNames();
} // namespace flux
#endif // FLUX_COLORNAMES_H
|
e96867da0a90d0413c2c7ec2eaedff8c4556c750
|
dcbc92e7ea76c361e9c15f2ee8887c019c25c451
|
/Calc_hash_sim.h
|
a8f4190b149d5e163781a4cc8b24045beb6c3a32
|
[] |
no_license
|
hidekiS/Calc_hash_sim
|
ad8faffc5b7d66d6e6d34a66742bebaa7921187e
|
fa17da8e385974cc15618bdeb1a52028e4d30838
|
refs/heads/master
| 2016-08-11T00:12:14.445982
| 2016-03-02T07:36:28
| 2016-03-02T07:36:28
| 52,941,566
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 2,645
|
h
|
Calc_hash_sim.h
|
/*
* Calc_hash_sim.h
*
* Created on: 2015/11/02
* Author: shiroshita
*/
#ifndef CALC_HASH_SIM_H_
#define CALC_HASH_SIM_H_
#include <iostream>
#include <stdio.h>
#include <string>
#include <typeinfo>
#include <fstream>
#include <vector>
#include <math.h>
#include <boost/algorithm/string.hpp>
#include <boost/foreach.hpp>
#include <boost/lexical_cast.hpp>
#include <exception>
#include "Mydebug.h"
#include <bitset>
#define foreach BOOST_FOREACH
#define MINDIFFRATE_LEN 0.3 //ใทใงใใ้ทใฎ้กไผผๅบฆใใใใใใๅฐใใๅ ดๅใ้กไผผๅบฆ=0
#define MINDIFFRATE_LUM 0.4 //ใทใงใใใฎ่ผๅบฆๅคๆฏใซใใ้กไผผๅบฆใใใใใใๅฐใใๅ ดๅใ้กไผผๅบฆ=0
#define MINDIFFRATE_HASH 0.3 //ใใใทใฅๅคใฎ้ใใซใใ้กไผผๅบฆใฎ่ถณๅใ
using namespace std;
//ใทใงใใๆ
ๅ ฑใฎๆง้ ไฝ
struct shot{
size_t hash;
size_t len_shot;
double avg_lum;
};
// ๆฏ่ผๆผ็ฎๅญใฎใชใผใใผใญใผใ
bool operator<(const shot& left, const shot& right) {
return left.len_shot < right.len_shot;
}
//ๅ็ปใใผใฟใฏใฉใน
class ShotData{
private:
string fname;
size_t num_div;
size_t min_frame;
size_t num_shot;
vector <shot> lshot;
public:
ShotData(){
fname = "";
num_div=0;
min_frame = 0;
num_shot=0;
}
void setHeader(string Fname,size_t Num_div,size_t minFrame,size_t Num_shot){
fname = Fname;
num_div = Num_div;
min_frame = minFrame;
num_shot = Num_shot;
}
const string& getFname() const {
return fname;
}
void setFname(const string fname) {
this->fname = fname;
}
size_t getNumShot() const {
return num_shot;
}
void setNumShot(size_t numShot) {
num_shot = numShot;
}
size_t getNumDiv() const {
return num_div;
}
void setNumDiv(size_t numDiv) {
num_div = numDiv;
}
size_t getMinFreme() const {
return min_frame;
}
void setMinFreme(size_t minFrame) {
min_frame = minFrame;
}
vector<shot>& getShot(){
return lshot;
}
void preprocess();
void dump();
};
double calc_sim_time_series(vector<shot> Db,vector<shot> Key,size_t divnum);
double calc_sim_shot_len(vector<shot> Db,vector<shot> Key,size_t i,size_t j);
double calc_sim_hash(size_t div_num,vector<shot> Db,vector<shot> Key,size_t i,size_t j);
double calc_sim_lumA(vector<shot> Db,vector<shot> Key,size_t i,size_t j);
double calc_sim_lumB(vector<shot> Db,vector<shot> Key,size_t i,size_t j);
double calc_sim_shot_num(ShotData Db,ShotData Key);
void fwrite_sim(list< ShotData > lshotdata,
list<double> lsim_hash,
list<double> lsim_lum,
list<double> lsim_shot_num,
list<double> lsim_time_series,
char *fname);
int get_lum_block(size_t hash);
#endif /* CALC_HASH_SIM_H_ */
|
6d6f7392cc4aa6e7f09edf5a5fe6fe58e997c6a9
|
13e0832d81c3255b7abef4d5fc3c030cfdd31bc5
|
/FaceCheck/FaceCheck/EmbeddedMySQL.cpp
|
89d586e889ed97915d15dd08111fc28a57dbe6f5
|
[] |
no_license
|
kcb0126/FaceCheck
|
625ae690e3c833631c23e52f0d9da9f48be7367f
|
14678344bc24e6580bede6d3634819983ee27fdb
|
refs/heads/master
| 2021-01-23T16:53:23.056483
| 2017-10-11T12:12:49
| 2017-10-11T12:12:49
| 102,749,158
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 48,055
|
cpp
|
EmbeddedMySQL.cpp
|
#include "StdAfx.h"
#include "EmbeddedMySQL.h"
#include "FaceCheck.h"
#include "myDef.h"
#include "ExecutablePathInfo.h"
#include <ShlObj.h>
#include "DlgOfSetServer.h"
CString g_strUsername;
int g_nUserID;
int g_nMaxMugIndex;
CString g_strPlace;
CEmbeddedMySQL* g_pDBManager;
CEmbeddedMySQL::CEmbeddedMySQL(void)
{
mysql = NULL;
InitializeCriticalSectionAndSpinCount(&m_secEvent, 0x80000400);
//test code: connect_mysql_server(_T("127.0.0.1"), 3306, _T("FaceCheck_DB"), _T("root"), _T(""));
}
CEmbeddedMySQL::~CEmbeddedMySQL(void)
{
close_mysql();
DeleteCriticalSection(&m_secEvent);
}
bool CEmbeddedMySQL::connect_mysql_server(CString strServer, int nPort, CString strDBName, CString strUser, CString strPassword)
{
close_mysql();
mysql = mysql_init(NULL);
if (mysql == NULL)
{
MessageBox(NULL, _T("mysql_init fault"), _T("MySql error"), MB_OK);
return false;
}
if (mysql_real_connect(mysql, CW2A(strServer.GetBuffer()), CW2A(strUser.GetBuffer()), CW2A(strPassword.GetBuffer()), "information_schema",
nPort, NULL, 0) == NULL)
{
int nResponse = MessageBox(NULL, _T("Server connection failed. Do you want to set connection manually?"), _T("Connection error"), MB_YESNO);
if (nResponse == 6) //Clicked "Yes"
{
CDlgOfSetServer dlg;
dlg.m_strAddress = strServer;
dlg.m_nPort = nPort;
dlg.m_strUsername = strUser;
dlg.m_strPassword = strPassword;
dlg.m_strDBName = strDBName;
//dlg.UpdateData(false); //Don't need. I will do it in OnInitDialog();
if (dlg.DoModal() == IDCANCEL) {
mysql = NULL;
return false;
}
//dlg.UpdateData(TRUE); //Don't need. but i don't know the reason.
strServer = dlg.m_strAddress;
strUser = dlg.m_strUsername;
strPassword = dlg.m_strPassword;
nPort = dlg.m_nPort;
strDBName = dlg.m_strDBName;
AfxGetApp()->WriteProfileString(_T("Setting"), _T("Address"), strServer);
AfxGetApp()->WriteProfileInt(_T("Setting"), _T("Port"), nPort);
AfxGetApp()->WriteProfileString(_T("Setting"), _T("UserName"), strUser);
AfxGetApp()->WriteProfileString(_T("Setting"), _T("Password"), strPassword);
AfxGetApp()->WriteProfileString(_T("Setting"), _T("DBName"), strDBName);
return connect_mysql_server(strServer, nPort, strDBName, strUser, strPassword);
}
mysql = NULL;
return false;
}
// create facecheck_db DataBase
run_query("CREATE DATABASE IF NOT EXISTS FaceCheck_DB");
close_mysql();
mysql = mysql_init(NULL);
if (mysql == NULL)
{
MessageBox(NULL, _T("mysql_init fault"), _T("MySql error"), MB_OK);
return false;
}
if (mysql_real_connect(mysql, CW2A(strServer.GetBuffer()), CW2A(strUser.GetBuffer()), CW2A(strPassword.GetBuffer()), CW2A(strDBName.GetBuffer()),
nPort, NULL, 0) == NULL)
{
MessageBox(NULL, _T("Error occured in connecting FaceCheck_DB."), _T("Connection error"), MB_OK);
mysql = NULL;
return false;
}
mysql->reconnect = 1;
//MessageBox(NULL, _T("mysql_real_connect succeed"), _T("MySql "), MB_OK);
MYSQL_RES* resultTemp = runQuery(CW2A(L"SELECT MAX(IDX) from monitor_history"));
MYSQL_ROW recordTemp = g_pDBManager->fetch_row(resultTemp);
int nIdx = recordTemp[0] == NULL ? 0 : atoi(recordTemp[0]);
m_nMaxIDinMonitorHistory = nIdx;
return true;
}
void CEmbeddedMySQL::close_mysql()
{
if (mysql == NULL)
{
return;
}
mysql_close(mysql);
//comment by Robin mysql_server_end();
mysql = NULL;
}
bool CEmbeddedMySQL::isValid()
{
return mysql != NULL;
}
void CEmbeddedMySQL::run_query(const char * sql)
{
if (isValid() == false || mysql == NULL)
return;
mysql_query(mysql, sql);
}
MYSQL_RES * CEmbeddedMySQL::store_result()
{
if (isValid() == false)
return NULL;
return mysql_store_result(mysql);
}
MYSQL_ROW CEmbeddedMySQL::fetch_row(MYSQL_RES * results)
{
return mysql_fetch_row(results);
}
void CEmbeddedMySQL::free_result(MYSQL_RES * results)
{
mysql_free_result(results);
}
bool CEmbeddedMySQL::check_table(const char * name)
{
if (isValid() == false || name == 0)
return false;
bool ret = true;
char szSQL[0x100];
sprintf_s(szSQL, "CHECK TABLE %s", name);
MYSQL_RES * result = runQuery(szSQL);
if (result == 0)
return false;
MYSQL_ROW last_record = 0;
while (MYSQL_ROW record = fetch_row(result))
{
last_record = record;
}
freeSQLResult(result);
if (last_record == 0)
return false;
if (_stricmp(last_record[2], "status") != 0 || _stricmp(last_record[3], "OK") != 0)
ret = false;
return ret;
}
MYSQL_RES * CEmbeddedMySQL::runQuery(const char * szSQL)
{
EnterCriticalSection(&m_secEvent);
run_query(szSQL);
MYSQL_RES * results = store_result();
LeaveCriticalSection(&m_secEvent);
return results;
}
void CEmbeddedMySQL::freeSQLResult(MYSQL_RES * results)
{
if (results)
free_result(results);
}
void CEmbeddedMySQL::runQueryWithoutResult(const char * szSQL)
{
EnterCriticalSection(&m_secEvent);
run_query(szSQL);
// freeSQLResult(store_result());
LeaveCriticalSection(&m_secEvent);
}
void CEmbeddedMySQL::verifyTable(const char * name)
{
if (check_table(name))
return;
char szSQL[0x100];
sprintf_s(szSQL, "REPAIR TABLE %s", name);
runQueryWithoutResult(szSQL);
}
void CEmbeddedMySQL::checkTableContainsCamera(const char * name)
{
char szSQL[0x100];
sprintf_s(szSQL, "SHOW TABLES LIKE '%s'", name);
MYSQL_RES * result = runQuery(szSQL);
if (result == 0)
return;
bool is_table = false;
while (MYSQL_ROW record = fetch_row(result))
{
if (_stricmp(record[0], name) == 0)
{
is_table = true;
break;
}
}
freeSQLResult(result);
if (is_table == false)
return;
// there is the table.
// check the table contains camera filed.
sprintf_s(szSQL, "SHOW FIELDS FROM %s LIKE 'camera'", name);
bool is_camera = false;
result = runQuery(szSQL);
if (result)
{
while (MYSQL_ROW record = fetch_row(result))
{
if (_stricmp(record[0], "camera") == 0)
{
is_camera = true;
break;
}
}
freeSQLResult(result);
}
if (is_camera == false)
{
// drop the invalid table
sprintf_s(szSQL, "DROP TABLE %s", name);
runQueryWithoutResult(szSQL);
}
}
void CEmbeddedMySQL::alterDBEngine()
{
// retrieve table status
MYSQL_RES * result = runQuery("SHOW TABLE STATUS");
if (result == 0)
return;
while (MYSQL_ROW record = fetch_row(result))
{
if (_stricmp(record[1], "InnoDB") != 0)
{
char szSQL[0x100];
sprintf_s(szSQL, "ALTER TABLE %s TYPE = INNODB", record[0]);
runQueryWithoutResult(szSQL);
}
}
freeSQLResult(result);
}
bool CEmbeddedMySQL::loadPersonBinaryData()
{
CString strQuery;
CString strQuery2;
strQuery.Format(_T("SELECT * FROM person_list"));
MYSQL_RES* result = 0;
MYSQL_RES* result2 = 0;
result = runQuery(CW2A(strQuery.GetBuffer()));
if (result)
{
personDB().Clear();
while (MYSQL_ROW record = fetch_row(result))
{
CPerson person;
//Get person's ID
person.m_nID = atoi(record[0]);
person.m_strName = CString((record[1])) + _T(" ") + CString(record[2]);
//Get person's BinaryData with ID
strQuery2.Format(_T("SELECT * FROM person_binarydata WHERE id = %d"), person.m_nID);
result2 = runQuery(CW2A(strQuery2.GetBuffer()));
if (result2)
{
while (MYSQL_ROW record2 = fetch_row((result2)))
{
CMugshot mugshot;
mugshot.m_nIDX = atoi(record2[0]);
mugshot.m_photo.m_nBpp = atoi(record2[3]);
mugshot.m_photo.m_nEffWidth = atoi(record2[4]);
mugshot.m_photo.m_nHeight = atoi(record2[5]);
mugshot.m_photo.m_pbyBuf = new BYTE[mugshot.m_photo.m_nEffWidth * mugshot.m_photo.m_nHeight];
memcpy(mugshot.m_photo.m_pbyBuf, record2[2], mugshot.m_photo.m_nEffWidth * mugshot.m_photo.m_nHeight);
int nFeatureLen = atoi(record2[7]);
mugshot.m_pdwFeature = new DWORD[nFeatureLen / 4];
memcpy(mugshot.m_pdwFeature, record2[6], nFeatureLen);
person.Add(mugshot);
}
freeSQLResult(result2);
// add the person to compare db
personDB().Add(person);
}
else
{
CString strMsg;
strMsg.Format(_T("There's no binarydata of the person of ID: %d"), person.m_nID);
MessageBox(NULL, strMsg, _T("Message"), MB_OK);
}
}
freeSQLResult(result);
}
else
{
MessageBox(NULL, _T("There's no person in the list"), _T("Message"), MB_OK);
return false;
}
g_nMaxMugIndex = getLastMugIndex();
return true;
}
bool CEmbeddedMySQL::reloadPersonBinaryData()
{
int nCurrentMugIdx = getLastMugIndex();
if (nCurrentMugIdx <= g_nMaxMugIndex)
return false;
CString strQuery;
CString strQuery2;
MYSQL_RES* result = 0;
MYSQL_RES* result2 = 0;
int nAction = -1;
int nPersonId;
int nMugId;
strQuery.Format(_T("SELECT * FROM person_change_info WHERE IDX > %d"), g_nMaxMugIndex);
result = runQuery(CW2A(strQuery.GetBuffer()));
if (result)
{
while (MYSQL_ROW record = fetch_row(result))
{
nPersonId = atoi(record[1]);
nMugId = atoi(record[2]);
nAction = atoi(record[3]);
if (nAction == 0) //if deleted
{
if (nMugId != -2) //if mugshot deleted
personDB().DeleteMugshot(nPersonId, nMugId);
else //if person deleted
personDB().DeletePerson(nPersonId);
}
else if (nAction == 1) //if added
{
strQuery2.Format(_T("SELECT * FROM person_binarydata WHERE IDX = %d"), nMugId);
result2 = runQuery(CW2A(strQuery2.GetBuffer()));
if (result2)
{
MYSQL_ROW record2 = fetch_row((result2));
int idx = personDB().IsExist(nPersonId);
if (idx != -1) //if person exist
{
CMugshot mugshot;
mugshot.m_nIDX = atoi(record2[0]);
mugshot.m_photo.m_nBpp = atoi(record2[3]);
mugshot.m_photo.m_nEffWidth = atoi(record2[4]);
mugshot.m_photo.m_nHeight = atoi(record2[5]);
mugshot.m_photo.m_pbyBuf = new BYTE[mugshot.m_photo.m_nEffWidth * mugshot.m_photo.m_nHeight];
memcpy(mugshot.m_photo.m_pbyBuf, record2[2], mugshot.m_photo.m_nEffWidth * mugshot.m_photo.m_nHeight);
int nFeatureLen = atoi(record2[7]);
mugshot.m_pdwFeature = new DWORD[nFeatureLen / 4];
memcpy(mugshot.m_pdwFeature, record2[6], nFeatureLen);
personDB()[idx].Add(mugshot);
}
else
{
CPerson person;
person.m_nID = nPersonId;
person.m_strName = getPersonName(nPersonId);
CMugshot mugshot;
mugshot.m_nIDX = atoi(record2[0]);
mugshot.m_photo.m_nBpp = atoi(record2[3]);
mugshot.m_photo.m_nEffWidth = atoi(record2[4]);
mugshot.m_photo.m_nHeight = atoi(record2[5]);
mugshot.m_photo.m_pbyBuf = new BYTE[mugshot.m_photo.m_nEffWidth * mugshot.m_photo.m_nHeight];
memcpy(mugshot.m_photo.m_pbyBuf, record2[2], mugshot.m_photo.m_nEffWidth * mugshot.m_photo.m_nHeight);
int nFeatureLen = atoi(record2[7]);
mugshot.m_pdwFeature = new DWORD[nFeatureLen / 4];
memcpy(mugshot.m_pdwFeature, record2[6], nFeatureLen);
person.Add(mugshot);
personDB().Add(person);
}
freeSQLResult(result2);
}
else
{
CString strMsg;
strMsg.Format(_T("There's no binarydata of the person of IDX: %d"), nMugId);
MessageBox(NULL, strMsg, _T("Message"), MB_OK);
}
}
}
freeSQLResult(result);
}
else
{
MessageBox(NULL, _T("There's no person in the list"), _T("Message"), MB_OK);
return false;
}
g_nMaxMugIndex = getLastMugIndex();
return true;
}
int CEmbeddedMySQL::getPersonIdFromIdx(int nIDX)
{
CString strQuery;
MYSQL_RES* result = 0;
strQuery.Format(_T("SELECT id FROM monitor_history WHERE IDX = %d"), nIDX);
result = runQuery(CW2A(strQuery.GetBuffer()));
if (result == 0)
return NON_EMPLOYEE;
MYSQL_ROW record = mysql_fetch_row(result);
int ret = atoi(record[0]);
freeSQLResult(result);
return ret;
}
int CEmbeddedMySQL::getLastMugIndex()
{
CString strQuery;
MYSQL_RES* result = 0;
strQuery.Format(_T("SELECT MAX(IDX) FROM person_change_info"));
result = runQuery(CW2A(strQuery.GetBuffer()));
if (result == 0 || result->row_count == 0)
return 0;
MYSQL_ROW record = mysql_fetch_row(result);
if (record == NULL || record[0] == NULL)
return 0;
int ret = atoi(record[0]);
freeSQLResult(result);
return ret;
}
/*
func: add a person into person_list table
return value:
record's id: if successful
0: if unsuccessful
-1: if user refused to insert
*/
void CEmbeddedMySQL::escape(CString &strUnescaped)
{
strUnescaped.Replace(L"'", L"''");
// strUnescaped.Replace(L"%", L"/%");
// strUnescaped.Replace(L"_", L"/_");
}
long CEmbeddedMySQL::insertPerson(CString strFirstName, CString strLastName, CString strNickName, CString strBirthday, int nGender, CString strInfo)
{
CString strQuery;
escape(strFirstName);
escape(strLastName);
escape(strNickName);
escape(strBirthday);
escape(strInfo);
strQuery.Format(_T("SELECT id From person_list WHERE firstname = '%s' AND lastname = '%s'"), strFirstName, strLastName);
MYSQL_RES* result = 0;
result = runQuery(CW2A(strQuery.GetBuffer()));
if (result)
{
if (result->row_count > 0)
{
if (MessageBox(NULL, _T("The same name exists! Do you still want to continue?"), _T("Message"), MB_YESNO) == IDNO)
return -1;
}
freeSQLResult(result);
}
strQuery.Format(_T("INSERT INTO person_list (id, firstname, lastname, nickname, birthday, gender, information) VALUES (NULL, '%s', '%s', '%s', '%s', %d, '%s')"), strFirstName, strLastName, strNickName, strBirthday, nGender, strInfo);
runQueryWithoutResult(CW2A(strQuery.GetBuffer()));
return (long)(mysql_insert_id(mysql));
}
void CEmbeddedMySQL::insertPersonBinaryData(int nID, CPerson& arg_person)
{
CString strQuery;
int nSize = (int)arg_person.m_vecMugshot.size();
CString csPhoto, csFeature;
char* szPhoto;
char* szFeature;
int nPhotoRealSize, nPhotoSaveSize, nFeatureRealSize, nFeatureSaveSize;
for (int i = 0; i < nSize; i++)
{
if (arg_person.m_vecMugshot[i].m_nIDX != -1)
continue;
//change photo binary to string in order to save table
nPhotoRealSize = arg_person.m_vecMugshot[i].m_photo.m_nEffWidth * REG_IMAGE_H;
nPhotoSaveSize = nPhotoRealSize * 2 + 3; //+3 = '0','x',...'\0'
szPhoto = new char[nPhotoSaveSize];
strcpy(szPhoto, "0x");
mysql_hex_string(szPhoto + 2, (char *)(arg_person.m_vecMugshot[i].m_photo.m_pbyBuf), nPhotoRealSize);
csPhoto = szPhoto;
//change feature binary to string in order to save table
nFeatureRealSize = arg_person.m_vecMugshot[i].m_pdwFeature[0];
nFeatureSaveSize = nFeatureRealSize * 2 + 3; //+3 = '0','x',...'\0'
szFeature = new char[nFeatureSaveSize];
strcpy(szFeature, "0x");
mysql_hex_string(szFeature + 2, (char *)(arg_person.m_vecMugshot[i].m_pdwFeature), nFeatureRealSize);
csFeature = szFeature;
strQuery.Format(_T("INSERT INTO person_binarydata (id, photo_data, photo_bpp, photo_height, photo_effwidth, feature_data, feature_size) VALUES ( %d, %s, %d, %d, %d, %s, %d)")
, nID
, csPhoto
, arg_person.m_vecMugshot[i].m_photo.m_nBpp
, REG_IMAGE_H
, arg_person.m_vecMugshot[i].m_photo.m_nEffWidth
, csFeature
, nFeatureRealSize);
runQueryWithoutResult(CW2A(strQuery.GetBuffer()));
delete[] szPhoto;
delete[] szFeature;
long insertedID = (long)(mysql_insert_id(mysql));
insertPersonChangeInfo(nID, insertedID, 1);
}
}
void CEmbeddedMySQL::insertPersonChangeInfo(int nUserId, int nMugIdx, int nAction)
{
CString strQuery;
strQuery.Format(_T("INSERT INTO person_change_info (person_id, mug_id, action) VALUES (%d, %d, %d)"), nUserId, nMugIdx, nAction);
runQueryWithoutResult(CW2A(strQuery.GetBuffer()));
}
/*
func: add a personSecurityInfo into person_security_info table
*/
void CEmbeddedMySQL::insertPersonSecurityInfo(int nID, int nPlayerLevel, int nSecurityLevel, int nBlocked, int nBlockedType, CString strWhen, CString strWhere, CString strWhy)
{
CString strQuery;
escape(strWhen);
escape(strWhere);
escape(strWhy);
strQuery.Format(_T("INSERT INTO person_security_info (id, player_level, security_level, blocked, blocked_type, blocked_when, blocked_where, blocked_why) VALUES (%d, %d, %d, %d, %d, '%s', '%s', '%s')"), nID, nPlayerLevel, nSecurityLevel, nBlocked, nBlockedType, strWhen, strWhere, strWhy);
runQueryWithoutResult(CW2A(strQuery.GetBuffer()));
return;
}
/*
func: add a personUpdateLog into person_updatelog table
*/
void CEmbeddedMySQL::insertPersonUpdateLog(int nID, CString strUsername, CString strUseraction, CString strDateTime, CString strPlace, CString strFields)
{
CString strQuery;
escape(strUsername);
escape(strUseraction);
escape(strPlace);
escape(strFields);
strQuery.Format(_T("INSERT INTO person_updatelog (person_id, user_name, user_action, user_datetime, user_place, user_changedfields) VALUES (%d, '%s', '%s', '%s', '%s', '%s')"), nID, strUsername, strUseraction, strDateTime, strPlace, strFields);
runQueryWithoutResult(CW2A(strQuery.GetBuffer()));
return;
}
void CEmbeddedMySQL::insertUser(CString strUsername, CString strPassword, int nPriv, CString strCreator, CString strPhone)
{
CString strQuery;
strQuery.Format(_T("INSERT INTO user_list (username, password, privilege_id, creator, created_time, phone) VALUES ('%s', '%s', %d, '%s', '%s', '%s')"), strUsername, strPassword, nPriv, strCreator, CTime::GetCurrentTime().Format("%Y-%m-%d %H:%M:%S"), strPhone);
runQueryWithoutResult(CW2A(strQuery));
return;
}
/*
func: add a user history into user_history table
*/
void CEmbeddedMySQL::insertUserHistory(CString strAction, CString strInfo)
{
CString strQuery;
escape(strInfo);
strQuery.Format(_T("INSERT INTO user_history (user_id, taken_action, action_datetime, info) VALUES (%d, '%s', '%s', '%s')"), g_nUserID, strAction, CTime::GetCurrentTime().Format("%Y-%m-%d %H:%M:%S"), strInfo);
runQueryWithoutResult(CW2A(strQuery.GetBuffer()));
return;
}
CString CEmbeddedMySQL::getPersonName(int nPersonID)
{
CString strQuery;
CString strRet;
strQuery.Format(_T("SELECT firstname, lastname FROM person_list WHERE id = %d"), nPersonID);
MYSQL_RES* result = 0;
result = runQuery(CW2A(strQuery.GetBuffer()));
if (result)
{
while (MYSQL_ROW record = fetch_row(result))
{
strRet = CString(record[0]) + _T(" ") + CString(record[1]);
break;
}
freeSQLResult(result);
}
else
strRet.Format(_T("UnknownID-%d"), nPersonID);
return strRet;
}
int CEmbeddedMySQL::getUserPrivilege(int nUserID)
{
CString strQuery;
strQuery.Format(_T("SELECT privilege_id FROM user_list WHERE id = %d"), nUserID);
MYSQL_RES* result = 0;
result = runQuery(CW2A(strQuery.GetBuffer()));
int nRet = -1;
if (result)
{
while (MYSQL_ROW record = fetch_row(result))
{
nRet = atoi(record[0]);
break;
}
freeSQLResult(result);
}
else
return -1;
return nRet;
}
CString CEmbeddedMySQL::getUserPrivText(int priv_id)
{
CString strQuery;
strQuery.Format(_T("SELECT privilege_type FROM user_privilege_type WHERE id = %d"), priv_id);
MYSQL_RES* result = 0;
result = runQuery(CW2A(strQuery.GetBuffer()));
CString strRet;
if (result)
{
while (MYSQL_ROW record = fetch_row(result))
{
strRet = record[0];
break;
}
freeSQLResult(result);
}
else
return _T("");
return strRet;
}
int CEmbeddedMySQL::getUserPrivID(CString strPriv)
{
CString strQuery;
strQuery.Format(_T("SELECT id FROM user_privilege_type WHERE privileg_type = '%s'"), strPriv);
MYSQL_RES* result = 0;
result = runQuery(CW2A(strQuery.GetBuffer()));
int nRet = -1;
if (result)
{
while (MYSQL_ROW record = fetch_row(result))
{
nRet = atoi(record[0]);
break;
}
freeSQLResult(result);
}
else
return -1;
return nRet;
}
CString CEmbeddedMySQL::getUserName(int nUserId)
{
CString strQuery;
CString strRet;
strQuery.Format(_T("SELECT username FROM user_list WHERE id = %d"), nUserId);
MYSQL_RES* result = 0;
result = runQuery(CW2A(strQuery.GetBuffer()));
if (result)
{
while (MYSQL_ROW record = fetch_row(result))
{
strRet = record[0];
break;
}
freeSQLResult(result);
}
else
strRet.Format(_T("UnknownID-%d"), nUserId);
return strRet;
}
person_info CEmbeddedMySQL::getPersonInfoWithSecurity(int nID)
{
person_info retInfo;
CString strQuery;
strQuery.Format(_T("SELECT * FROM person_list AS t JOIN person_security_info AS tt ON t.id = tt.id AND t.id = %d "), nID);
MYSQL_RES* result = 0;
result = runQuery(CW2A(strQuery.GetBuffer()));
if (result)
{
while (MYSQL_ROW record = fetch_row(result))
{
retInfo.m_nID = atoi(record[0]);
retInfo.m_strFirstname = record[1];
retInfo.m_strLastname = record[2];
retInfo.m_strNickname = record[3];
retInfo.m_strBirthday = record[4];
retInfo.m_nGender = atoi(record[5]);
retInfo.m_strInfo = record[6];
retInfo.m_nPlayerLevel = atoi(record[9]);
retInfo.m_nSecurityLevel = atoi(record[10]);
retInfo.m_nBlocked = atoi(record[11]);
retInfo.m_nBlockedType = atoi(record[12]);
retInfo.m_strBlockedWhen = record[13];
retInfo.m_strBlockedWhere = record[14];
retInfo.m_strBlockedWhy = record[15];
break;
}
freeSQLResult(result);
}
return retInfo;
}
CxImage CEmbeddedMySQL::getHistoryImage(int nIDX)
{
CxImage imgReturn;
int nbpp, nEffWidth, nHeight;
CString strQuery;
MYSQL_RES* result = 0;
strQuery.Format(_T("SELECT * FROM monitor_history WHERE IDX = %d"), nIDX);
result = runQuery(CW2A(strQuery.GetBuffer()));
if (result)
{
MYSQL_ROW record = fetch_row(result);
nbpp = atoi(record[5]);
nEffWidth = atoi(record[6]);
nHeight = atoi(record[7]);
BYTE* pbyBuf = new BYTE[nEffWidth * nHeight];
memcpy(pbyBuf, record[4], nEffWidth * nHeight);
imgReturn.CreateFromArray(pbyBuf, CUSTOMER_PHOTO_WIDTH, CUSTOMER_PHOTO_HEIGHT, nbpp, nEffWidth, FALSE);
delete[] pbyBuf;
}
g_pDBManager->freeSQLResult(result);
return imgReturn;
}
BOOL CEmbeddedMySQL::verifyPasswordAndBlocked(CString strName, CString strPassword)
{
BOOL ret = FALSE;
CString strQuery;
strQuery.Format(_T("SELECT * FROM user_list WHERE username = '%s'"), strName);
MYSQL_RES * result = 0;
result = runQuery(CW2A(strQuery));
if (result)
{
MYSQL_ROW record;
if (result->row_count == 0)
{
MessageBox(NULL, _T("The user does not exit! Please type username correctly"), _T("Message"), MB_OK | MB_ICONINFORMATION);
ret = FALSE;
}
else
{
while (record = fetch_row(result))
{
if (strcmp(record[2], CW2A(strPassword.GetBuffer())) == 0)// if the password matches
{
CString strBlocked = CString(record[6]);
if (strBlocked == "blocked") {
MessageBox(NULL, _T("The user is blocked."), _T("Message"), MB_OK | MB_ICONINFORMATION);
freeSQLResult(result);
return FALSE;
}
if (g_strUsername != strName) // if another user logged
{
if (g_strUsername != _T("")) // if not startup case
insertUserHistory(LOG_USER_LOGOUT);
g_strUsername = strName;
g_nUserID = atoi(record[0]);
insertUserHistory(LOG_USER_LOGIN);
}
ret = TRUE;
}
else //if the password dismatches
{
MessageBox(NULL, _T("Wrong password!!! Please type password correctly"), _T("Message"), MB_OK);
ret = FALSE;
}
}
}
freeSQLResult(result);
}
else
{
MessageBox(NULL, _T("Error occured in verifying Password.\nPlease ensure 'user_list' table is exists in the DB"), _T("Error"), MB_OK);
return FALSE;
}
return ret;
}
void CEmbeddedMySQL::deletePerson(int nID)
{
CString strQuery;
strQuery.Format(_T("Delete From person_list WHERE id = %d"), nID);
runQueryWithoutResult(CW2A(strQuery.GetBuffer()));
strQuery.Format(_T("Delete From person_binarydata WHERE id = %d"), nID);
runQueryWithoutResult(CW2A(strQuery.GetBuffer()));
strQuery.Format(_T("Delete From person_security_info WHERE id = %d"), nID);
runQueryWithoutResult(CW2A(strQuery.GetBuffer()));
insertPersonChangeInfo(nID, -2, 0);// second parameter indicates all mugshot deleted
return;
}
void CEmbeddedMySQL::deletePersonBinaryData(int nPersonID, int nIdx)
{
CString strQuery;
strQuery.Format(_T("Delete From person_binarydata WHERE IDX = %d"), nIdx);
runQueryWithoutResult(CW2A(strQuery.GetBuffer()));
insertPersonChangeInfo(nPersonID, nIdx, 0);
return;
}
void CEmbeddedMySQL::addComment(int nIDX, CString strcomment)
{
CString strQuery;
escape(strcomment);
strQuery.Format(_T("Update monitor_history SET comment = '%s', comment_time = '%s' WHERE IDX = %d"), strcomment, CTime::GetCurrentTime().Format(_T("%Y-%m-%d %H:%M:%S")), nIDX);
runQueryWithoutResult(CW2A(strQuery.GetBuffer()));
return;
}
void CEmbeddedMySQL::updateUserId(int nOldId, int nNewId)
{
CString strQuery;
strQuery.Format(_T("Update monitor_history SET id = %d WHERE id = %d"), nNewId, nOldId);
runQueryWithoutResult(CW2A(strQuery.GetBuffer()));
return;
}
long CEmbeddedMySQL::updatePerson(int nID, CString strFirstName, CString strLastName, CString strNickName, CString strBirthday, int nGender, CString strInfor)
{
CString strQuery;
escape(strFirstName);
escape(strLastName);
escape(strNickName);
escape(strInfor);
strQuery.Format(_T("UPDATE person_list SET firstname = '%s', lastname = '%s', nickname = '%s', birthday = '%s', gender = %d, information = '%s' WHERE id = %d")
, strFirstName, strLastName, strNickName, strBirthday, nGender, strInfor, nID);
runQueryWithoutResult(CW2A(strQuery.GetBuffer()));
return (long)(mysql_insert_id(mysql));
}
void CEmbeddedMySQL::updateUser(CString strUsername, CString strPassword, int nPriv, CString strOldname, CString strPhone)
{
CString strQuery;
// escape(strUsername);
escape(strPassword);
strQuery.Format(_T("UPDATE user_list SET username = '%s', password = '%s', privilege_id = %d , phone = '%s' WHERE username = '%s'"), strUsername, strPassword, nPriv, strPhone, strOldname);
runQueryWithoutResult(CW2A(strQuery));
return;
}
void CEmbeddedMySQL::updatePersonSecurityInfo(int nID, int nPlayerLevel, int nSecurityLevel, int nBlocked, int nBlockedType, CString strWhen, CString strWhere, CString strWhy)
{
CString strQuery;
escape(strWhere);
escape(strWhy);
strQuery.Format(_T("UPDATE person_security_info SET player_level= %d, security_level = %d, blocked = %d, blocked_type = %d, blocked_when = '%s', blocked_where = '%s' , blocked_why = '%s' WHERE id = %d")
, nPlayerLevel, nSecurityLevel, nBlocked, nBlockedType, strWhen, strWhere, strWhy, nID);
runQueryWithoutResult(CW2A(strQuery.GetBuffer()));
}
int CEmbeddedMySQL::findPerson(CString strFirstName, CString strLastName)
{
CString strQuery;
strQuery.Format(_T("SELECT id From person_list WHERE firstname = '%s' AND lastname = '%s'"), strFirstName, strLastName);
MYSQL_RES* result = 0;
result = runQuery(CW2A(strQuery.GetBuffer()));
if (result)
{
MYSQL_ROW record;
while (record = fetch_row(result))
{
return atoi(record[0]);
}
freeSQLResult(result);
}
return -1;
}
int CEmbeddedMySQL::IsConnected(void)
/* ===========================================================================
NAME OF FUNCTION: CDatabaseManipulation::IsConnected
CREDIT: IRDS: Satish
PURPOSE: This function is used to check connection status of database.
Testing for connection status is simple -- you just check the value of the connection attribute.
It should be non-NULL for MySQL.
PARAMETERS: None
RETURN VALUE: Returns connection status of database.
CALLS TO: None
CALLED FROM: 1) Connect - with no parameter
2) Connect - with 4 parameters
3) CloseConnection
4) GetError
5) InsertData
6) UpdateData
7) DeleteData
8) SelectData
Added date: 12 March, 2015
Updated date:
============================================================================*/
{
return !(!mysql);
}
TCHAR *CEmbeddedMySQL::GetError(void)
/* ===========================================================================
NAME OF FUNCTION: CDatabaseManipulation::GetError
CREDIT: IRDS: Satish
PURPOSE: This function is used to return error occures during database connection and in database manipulation.
Retrieving error messages under mSQL is very simple and straightforward.
You just use the value of the msqlErrMsg global variable. This value is exactly what our GetError() method returns for mSQL.
MySQL, however, is a little more complicated. Being multithreaded, it needs to provide threadsafe access to any error messages.
It manages to make error handling work in a multithreaded environment by hiding error messages behind the mysql_error() function.
PARAMETERS: None
RETURN VALUE: Returns string containing error message.
CALLS TO: None
CALLED FROM: 1) InsertData
2) UpdateData
3) DeleteData
4) SelectData
5) Connect - with no parameter
6) Connect - with 4 parameters
Added date: 12 March, 2015
Updated date:
============================================================================*/
{
if (IsConnected())
{
return (TCHAR *)mysql_error(mysql);
}
else
{
return (TCHAR *)mysql_error(&mysqlInitial);
}
}
// At the moment, it is not used.
bool CEmbeddedMySQL::Connect(/*[IN]*/const TCHAR *ptchHost, /*[IN]*/const TCHAR *ptchUserID,
/*[IN]*/const TCHAR *ptchDatabase, /*[IN]*/const TCHAR *ptchPassword)
/* ===========================================================================
NAME OF FUNCTION: CDatabaseManipulation::Connect
CREDIT: IRDS: Satish
PURPOSE: This function is used to connect MYSQL database.
PARAMETERS: [IN] 1) TCHAR *ptchHost: Parameter passed as ptchHost may be either a host name or an IP address.
If host is NULL or the string "localhost", a connection to the local host is assumed.
For Windows, the client connects using a shared-memory connection,
if the server has shared-memory connections enabled. Otherwise, TCP/IP is used.
[IN] 2) TCHAR *ptchUserID: Parameter passed as ptchUserID contains the user's MySQL login ID.
[IN] 3) TCHAR *ptchDatabase: Parameter passed as ptchDatabase is the database name.
If ptchDatabase is not NULL, the connection sets the default database to this value.
[IN] 4) TCHAR *ptchPassword: Parameter passed as ptchPassword contains the password for user.
RETURN VALUE: None
CALLS TO: None
CALLED FROM:
Added date: 12 March, 2015
Updated date:
============================================================================*/
{
bool bConnectionSuccess = false;
if (/**/!IsConnected())
{
TRACE(_T("Connection has already been established."));
bConnectionSuccess = false;
}
//Allocates or initializes a MYSQL object suitable for mysql_real_connect()
//returns an initialized MYSQL* handle. Returns NULL if there was insufficient memory to allocate a new object.
MYSQL* mysqlinit = mysql_init(NULL);
// if (mysql_init(&mysqlInitial) == NULL)
if (!mysqlinit)
{
TRACE(_T("Failed to initiate MySQL connection"));
bConnectionSuccess = false;
}
//Establishes a connection to a database server. Returns a MYSQL * handle or NULL if an error occurred.
//mysql = mysql_real_connect(&mysqlInitial, (const char*)ptchHost, (const char*)ptchUserID, (const char*)ptchPassword, (const char*)ptchDatabase, 0, 0, 0);
mysql = mysql_real_connect(mysqlinit, (const char*)ptchHost, (const char*)ptchUserID, (const char*)ptchPassword, (const char*)ptchDatabase, 3306, 0, 0);
// Check if connection succeeded.
if (mysql == NULL)
{
LPTSTR lptstrError = new TCHAR[1024];
_stprintf_s(lptstrError, 1024, _T("%s %s"), _T("Couldn't connect to MySQL database server! Error: "), mysql_error(mysql));
TRACE(lptstrError);
delete[] lptstrError;
bConnectionSuccess = false;
}
else
{
TRACE(_T("Connect success."), _T("INFO"));
bConnectionSuccess = true;
}
if (!IsConnected())
{
TRACE(GetError());
bConnectionSuccess = false;
}
return bConnectionSuccess;
}
bool CEmbeddedMySQL::ImportDatabase(/*[IN]*/const TCHAR *ptchHost, /*[IN]*/const TCHAR *ptchUserID, /*[IN]*/const TCHAR *ptchPassword,
/*[IN]*/int nPort, /*[IN]*/const TCHAR *ptchDatabaseNameToImport, /*[IN]*/const TCHAR *ptchImportDatabaseFile)
/* ======================================================================================================
NAME OF FUNCTION: CDatabaseManipulation::ImportDatabase
CREDIT: IRDS: Satish
PURPOSE: This function is used to import database using import file into MySql database.
This function create vector of strings containing commands to import database.
This function then creates batch file.
This function then writes vector of commands into batch file.
This function then execute batch file using cmd.exe.
At the end after import of database, function removes batch file.
PARAMETERS: [IN] 1) TCHAR *ptchHost: Host or server name to connect and import database.
[IN] 2) TCHAR *ptchUserID: User name to connect and import database.
[IN] 3) TCHAR *ptchPassword: Password to connect and import database.
[IN] 4) TCHAR *ptchDatabaseNameToImport: MySql database name to import.
[IN] 5) TCHAR *ptchImportDatabaseFile: Database file to import into MySql database.
RETURN VALUE: None
CALLS TO: 1) WriteVectorInFile
2) GetExecutablePath
CALLED FROM: None
Added date: 17 March, 2015
Updated date:
=======================================================================================================*/
{
bool bImportDBSuccess = false;
//Database connection
connect_mysql_server(ptchHost, 3306, ptchDatabaseNameToImport, ptchUserID, ptchPassword); //Connect and create database if not exist.
if (!IsConnected())
{
TRACE(_T("MySql server is not connected."));
bImportDBSuccess = false;
}
else
{
/*TCHAR *strCreateDatabaseCommand = new TCHAR[MAX_PATH];
_tcscpy_s(strCreateDatabaseCommand, MAX_PATH, _T("CREATE DATABASE "));
_tcscat_s(strCreateDatabaseCommand, MAX_PATH, ptchDatabaseNameToImport);
mysql_query(mysql, (const char*)strCreateDatabaseCommand);
delete strCreateDatabaseCommand; */
//Creating batch file data to execute
TCHAR szDirectory[MAX_PATH] = L"";
::GetCurrentDirectory(sizeof(szDirectory) - 1, szDirectory);
TCHAR * strReturnSQLFilePath = new TCHAR[MAX_PATH];
_tcscpy_s(strReturnSQLFilePath, MAX_PATH, _T(""));
SearchForFilePath(szDirectory, _T("mysql.exe"), strReturnSQLFilePath);
if (!_tcscmp(strReturnSQLFilePath, _T("")))
{
return false;
}
//populate vector with import database command to write into batch file for import database
vector<TCHAR *> vecToWriteInFile;
vecToWriteInFile.push_back(_T("@echo off"));
vecToWriteInFile.push_back(_T("set MainDir = %CD%"));
vecToWriteInFile.push_back(_T("CD %MainDir%"));
TCHAR strSQLDrive[3];
strSQLDrive[0] = strReturnSQLFilePath[0];
strSQLDrive[1] = strReturnSQLFilePath[1];
strSQLDrive[2] = _T('\0');
vecToWriteInFile.push_back(strSQLDrive);
TCHAR * strTempPath = new TCHAR[MAX_PATH];
_tcscpy_s(strTempPath, MAX_PATH, _T("CD "));
_tcscat_s(strTempPath, MAX_PATH, strReturnSQLFilePath);
vecToWriteInFile.push_back(strTempPath);
TCHAR strImportCommand[1024];
_tcscpy_s(strImportCommand, MAX_PATH, _T("mysql --host="));
_tcscat_s(strImportCommand, ptchHost);
_tcscat_s(strImportCommand, _T(" --user="));
_tcscat_s(strImportCommand, ptchUserID);
_tcscat_s(strImportCommand, _T(" --password="));
_tcscat_s(strImportCommand, ptchPassword);
_tcscat_s(strImportCommand, _T(" -D"));
_tcscat_s(strImportCommand, ptchDatabaseNameToImport);
_tcscat_s(strImportCommand, _T(" < \""));
_tcscat_s(strImportCommand, ptchImportDatabaseFile);
_tcscat_s(strImportCommand, _T("\""));
vecToWriteInFile.push_back(strImportCommand);
vecToWriteInFile.push_back(_T("exit"));
//Create temporary import batch file
CExecutablePathInfo objExecutablePathInfo;
LPTSTR lptstrExecutableDirectory = new TCHAR[1024];
objExecutablePathInfo.GetExecutableDirectory(lptstrExecutableDirectory, 1024);
_tcscat_s(lptstrExecutableDirectory, MAX_PATH, _T("\\TempDatabaseManipulationImport.bat"));
//Write into temporary created import batch file
WriteVectorInFile(vecToWriteInFile, lptstrExecutableDirectory);
vecToWriteInFile.clear(); //clears the vector
vecToWriteInFile.shrink_to_fit(); //It requests the removal of unused capacity of vector
TCHAR strSystemDirPath[MAX_PATH] = _T("");
GetSystemDirectory(strSystemDirPath, sizeof(strSystemDirPath) / sizeof(_TCHAR));
// path to cmd.exe, path to batch file, plus some space for quotes, spaces, etc.
TCHAR strCommandLine[2 * MAX_PATH + 16] = _T("");
_sntprintf_s(strCommandLine, sizeof(strCommandLine) / sizeof(_TCHAR), _T("\"%s\\cmd.exe\" /C \"%s\""), strSystemDirPath, lptstrExecutableDirectory);
delete[] strTempPath;
strTempPath = NULL;
delete[] strReturnSQLFilePath;
strReturnSQLFilePath = NULL;
STARTUPINFO si = { 0 }; // alternative way to zero array
si.cb = sizeof(si);
PROCESS_INFORMATION pi = { 0 };
if (!CreateProcess(NULL,
strCommandLine,
NULL,
NULL,
FALSE,
0,
NULL,
NULL,
&si,
&pi)
)
{
LPTSTR lpstrError = new TCHAR[1024];
_stprintf_s(lpstrError, 1024, _T("CreateProcess failed (%d)\n"), GetLastError());
TRACE(lpstrError);
delete[] lpstrError;
bImportDBSuccess = false;
}
else
{
bImportDBSuccess = true;
}
WaitForSingleObject(pi.hProcess, INFINITE);
CloseHandle(pi.hProcess);
CloseHandle(pi.hThread);
//Remove batch file
remove((const char*)lptstrExecutableDirectory);
delete[] lptstrExecutableDirectory;
lptstrExecutableDirectory = NULL;
}
return bImportDBSuccess;
}
bool CEmbeddedMySQL::ExportDatabase(/*[IN]*/const TCHAR *ptchHost, /*[IN]*/const TCHAR *ptchUserID, /*[IN]*/const TCHAR *ptchPassword,
/*[IN]*/const TCHAR *ptchDatabaseNameToExport, /*[IN]*/const TCHAR *ptchExportDatabaseFileWithPath)
/* ======================================================================================================
NAME OF FUNCTION: CDatabaseManipulation::ExportDatabase
CREDIT: IRDS: Satish
PURPOSE: This function is used to export database to the specified path with specified file name.
PARAMETERS: [IN] 1) TCHAR *ptchHost: Host or server name to connect and import database.
[IN] 2) TCHAR *ptchUserID: User name to connect and import database.
[IN] 3) TCHAR *ptchPassword: Password to connect and import database.
[IN] 4) TCHAR *ptchDatabaseNameToExport: MySql database name to export.
[IN] 5) TCHAR *ptchExportDatabaseFileWithPath: Database filename with path to export MySql database.
RETURN VALUE: Returns true on success.
CALLS TO: 1) WriteVectorInFile
2) GetExecutablePath
CALLED FROM: None
Added date: 17 March, 2015
Updated date:
=======================================================================================================
%%%%%%%%%%%%%%%%%%%%%%%%%%%% T H A N K Y O U , S a t i s h %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
{
bool bExportDBSuccess = false;
//Database connection
//connect_mysql_server(_T("rwunhyok-note"), 3306, _T("FaceCheck_DB"), _T("facecheck"), _T("facecheck"));
//Connect(ptchHost, ptchUserID, ptchDatabaseNameToExport, ptchPassword);
if (!IsConnected())
{
TRACE(_T("MySql server is not connected."));
bExportDBSuccess = false;
}
else
{
//Creating batch file data to execute
TCHAR szDirectory[MAX_PATH] = L"";
::GetCurrentDirectory(sizeof(szDirectory) - 1, szDirectory);
TCHAR * strReturnSQLFilePath = new TCHAR[MAX_PATH];
_tcscpy_s(strReturnSQLFilePath, MAX_PATH, _T(""));
SearchForFilePath(szDirectory, _T("mysqldump.exe"), strReturnSQLFilePath);
if (!_tcscmp(strReturnSQLFilePath, _T("")))
{
return false;
}
//populate vector with export database command to write into batch file for export database
vector<TCHAR *> vecToWriteInFile;
vecToWriteInFile.push_back(_T("@echo off"));
vecToWriteInFile.push_back(_T("set MainDir = %CD%"));
vecToWriteInFile.push_back(_T("CD %MainDir%"));
TCHAR strSQLDrive[3];
strSQLDrive[0] = strReturnSQLFilePath[0];
strSQLDrive[1] = strReturnSQLFilePath[1];
strSQLDrive[2] = _T('\0');
vecToWriteInFile.push_back(strSQLDrive);
TCHAR * strTempPath = new TCHAR[MAX_PATH];
_tcscpy_s(strTempPath, MAX_PATH, _T("CD "));
_tcscat_s(strTempPath, MAX_PATH, strReturnSQLFilePath);
vecToWriteInFile.push_back(strTempPath);
TCHAR strImportCommand[1024];
_tcscpy_s(strImportCommand, MAX_PATH, _T("mysqldump --host="));
_tcscat_s(strImportCommand, ptchHost);
_tcscat_s(strImportCommand, _T(" --user="));
_tcscat_s(strImportCommand, ptchUserID);
_tcscat_s(strImportCommand, _T(" --password="));
_tcscat_s(strImportCommand, ptchPassword);
_tcscat_s(strImportCommand, _T(" --result-file="));
_tcscat_s(strImportCommand, _T("\""));
_tcscat_s(strImportCommand, ptchExportDatabaseFileWithPath);
_tcscat_s(strImportCommand, _T("\""));
_tcscat_s(strImportCommand, _T(" "));
_tcscat_s(strImportCommand, ptchDatabaseNameToExport);
vecToWriteInFile.push_back(strImportCommand);
vecToWriteInFile.push_back(_T("exit"));
//Create temporary import batch file
CExecutablePathInfo objExecutablePathInfo;
LPTSTR lptstrExecutableDirectory = new TCHAR[1024];
objExecutablePathInfo.GetExecutableDirectory(lptstrExecutableDirectory, 1024);
_tcscat_s(lptstrExecutableDirectory, MAX_PATH, _T("\\TempDatabaseManipulationExport.bat"));
//Write into temporary created import batch file
WriteVectorInFile(vecToWriteInFile, lptstrExecutableDirectory);
vecToWriteInFile.clear(); //clears the vector
vecToWriteInFile.shrink_to_fit(); //It requests the removal of unused capacity of vector
TCHAR strSystemDirPath[MAX_PATH] = _T("");
GetSystemDirectory(strSystemDirPath, sizeof(strSystemDirPath) / sizeof(_TCHAR));
// path to cmd.exe, path to batch file, plus some space for quotes, spaces, etc.
TCHAR strCommandLine[2 * MAX_PATH + 16] = _T("");
_sntprintf_s(strCommandLine, sizeof(strCommandLine) / sizeof(_TCHAR), _T("\"%s\\cmd.exe\" /C \"%s\""), strSystemDirPath, lptstrExecutableDirectory);
delete[] strTempPath;
strTempPath = NULL;
delete[] strReturnSQLFilePath;
strReturnSQLFilePath = NULL;
STARTUPINFO si = { 0 }; // alternative way to zero array
si.cb = sizeof(si);
PROCESS_INFORMATION pi = { 0 };
if (!CreateProcess(NULL,
strCommandLine,
NULL,
NULL,
FALSE,
0,
NULL,
NULL,
&si,
&pi)
)
{
LPTSTR lpstrError = new TCHAR[1024];
_stprintf_s(lpstrError, 1024, _T("CreateProcess failed (%d)\n"), GetLastError());
TRACE(lpstrError);
delete[] lpstrError;
bExportDBSuccess = false;
}
else
{
bExportDBSuccess = true;
}
WaitForSingleObject(pi.hProcess, INFINITE);
CloseHandle(pi.hProcess);
CloseHandle(pi.hThread);
//Remove batch file
remove((const char*)lptstrExecutableDirectory);
delete[] lptstrExecutableDirectory;
lptstrExecutableDirectory = NULL;
}
return bExportDBSuccess;
}
void CEmbeddedMySQL::SearchForFilePath(/*[IN]*/TCHAR *strStartingDirectoryPath, /*[IN]*/TCHAR *strFileNameToSearchForDirectory, /*[OUT]*/TCHAR *strReturnFileDirectoryPath)
/* =====================================================================================================================
NAME OF FUNCTION: CDatabaseManipulation::SearchForFilePath
CREDIT: IRDS: Satish
PURPOSE: This function is used to retrieve containing directory path of given file.
PARAMETERS: [IN] 1) TCHAR *strStartingDirectoryPath: Starting directory path to start search with.
[IN] 2) TCHAR *strFileNameToSearchForDirectory: File to search.
[OUT] 3) TCHAR *strReturnFileDirectoryPath: Containing directory path of given file.
RETURN VALUE: None
CALLS TO: None
CALLED FROM: 1) ImportDatabase(const TCHAR*, const TCHAR*)
2) ImportDatabase(const TCHAR*, const TCHAR*, const TCHAR*, const TCHAR*, const TCHAR*)
3) ExportDatabase(const TCHAR*, const TCHAR*)
4) ExportDatabase(const TCHAR*, const TCHAR*, const TCHAR*, const TCHAR*, const TCHAR*)
Added date: 17 March, 2015
Updated date:
======================================================================================================================*/
{
HANDLE hFind;
WIN32_FIND_DATA wfd;
TCHAR strTempStartingDirPath[MAX_PATH];
TCHAR strPathFound[MAX_PATH];
_stprintf_s(strTempStartingDirPath, MAX_PATH, _T("%s\\*"), strStartingDirectoryPath);
_tcsncpy_s(strPathFound, MAX_PATH, strTempStartingDirPath, (_tcslen(strTempStartingDirPath) - 2));
if ((hFind = FindFirstFile(strTempStartingDirPath, &wfd)) == INVALID_HANDLE_VALUE)
{
LPTSTR lpstrError = new TCHAR[1024];
_stprintf_s(lpstrError, 1024, _T("FindFirstFIle failed on path = \"%s\""), strTempStartingDirPath);
TRACE(lpstrError);
delete[] lpstrError;
return;
}
static BOOL bContinueSearch = TRUE;
static BOOL bFound = TRUE;
bContinueSearch = TRUE;
bFound = TRUE;
while (bContinueSearch)
{
if ((_tcsncmp(_T("."), wfd.cFileName, 1) != 0) && (_tcsncmp(_T(".."), wfd.cFileName, 2) != 0))
{
if (wfd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
{
_stprintf_s(strTempStartingDirPath, MAX_PATH, _T("%s\\%s"), strStartingDirectoryPath, wfd.cFileName);
SearchForFilePath(strTempStartingDirPath, strFileNameToSearchForDirectory, strReturnFileDirectoryPath);
}
else
{
TCHAR * strTemp = new TCHAR[MAX_PATH];
_tcscpy_s(strTemp, MAX_PATH, wfd.cFileName);
if (!_tcscmp(strTemp, strFileNameToSearchForDirectory))
{
_tcscpy_s(strReturnFileDirectoryPath, MAX_PATH, strPathFound);
_tcscpy_s(strTempStartingDirPath, MAX_PATH, _T(""));
bFound = false;
bContinueSearch = false;
hFind = NULL;
}
delete[] strTemp;
strTemp = NULL;
}
}
if (bFound)
{
bContinueSearch = FindNextFile(hFind, &wfd);
}
}
if (GetLastError() != ERROR_NO_MORE_FILES)
{
LPTSTR lpstrError = new TCHAR[1024];
_stprintf_s(lpstrError, 1024, _T("FindNextFile died for some reason; path = \"%s\""), strTempStartingDirPath);
TRACE(lpstrError);
delete[] lpstrError;
return;
}
if (FindClose(hFind) == FALSE)
{
LPTSTR lpstrError = new TCHAR[1024];
_stprintf_s(lpstrError, 1024, _T("FindClose failed"));
TRACE(lpstrError);
delete[] lpstrError;
return;
}
}
void CEmbeddedMySQL::WriteVectorInFile(/*[IN]*/vector<TCHAR *> vecSource, /*[IN]*/TCHAR * strFileName)
/* ===========================================================================
NAME OF FUNCTION: CDatabaseManipulation::WriteVectorInFile
CREDIT: IRDS: Satish
PURPOSE: This function is used to write vector of strings into file.
PARAMETERS: [IN] 1) vector<TCHAR *> vecSource: Vector of strings to write into file.
[IN] 2) TCHAR * strFileName: File to write.
RETURN VALUE: None
CALLS TO: None
CALLED FROM: None
Added date: 17 March, 2015
Updated date:
============================================================================*/
{
CString strOut;
int k = vecSource.size();
for (int i = 0; i < k; i++)
{
strOut.Append(vecSource[i]);
strOut.Append(L"\n");
}
CStdioFile file;
if (file.Open((LPCTSTR)strFileName, CFile::modeCreate | CFile::modeWrite))
{
file.WriteString(strOut);
}
}
|
416b571790154b7f9206866338a585cb0470281c
|
06a02b5ef783f14c6eccf4ccd391f488801ef8e6
|
/D3DXFrameWork/Engine/Headers/Buffer_Trail.h
|
d18354253d71548f5f1f608739b5977c8ab4e381
|
[] |
no_license
|
ancal258/D3DProject_DeadPool
|
a87231e7563452608b243a5e3dbb61f5a61f4e5e
|
3938e831bfdb466ed23ec8ea77d24ab3513a92a4
|
refs/heads/master
| 2021-10-10T03:13:56.104158
| 2019-01-06T04:42:00
| 2019-01-06T04:42:00
| 158,417,729
| 0
| 0
| null | null | null | null |
UHC
|
C++
| false
| false
| 902
|
h
|
Buffer_Trail.h
|
#pragma once
#include "VIBuffer.h"
// 2D : ViewPort Space
// 3D : Local Space
// 3์ฐจ์ ๋ก์ปฌ์คํ์ด์ค ์์ ์ ์๋๋ ์ ์ ๋ค์ด๋ค.
// ๋ค๋ชจ ํํ๋ฅผ ๊ทธ๋ฆฐ๋ค.
// ํ
์ค์ณ๊ฐ ๋งตํ๋๋ค.
_BEGIN(Engine)
class _ENGINE_DLL CBuffer_Trail final : public CVIBuffer
{
private:
explicit CBuffer_Trail(LPDIRECT3DDEVICE9 pGraphic_Device);
explicit CBuffer_Trail(const CBuffer_Trail& rhs);
virtual ~CBuffer_Trail() = default;
public:
HRESULT Ready_VIBuffer();
HRESULT Ready_TrailBuffer();
HRESULT Add_VertexBuffer(_vec3 vVertexBegin, _vec3 vVertexEnd);
virtual void Render_VIBuffer();
private:
vector<_vec3> m_vecVertex;
LPDIRECT3DVERTEXBUFFER9 m_pVB_Trail = nullptr;
LPDIRECT3DINDEXBUFFER9 m_pIB_Trail = nullptr;
public:
static CBuffer_Trail* Create(LPDIRECT3DDEVICE9 pGraphic_Device);
virtual CComponent* Clone_Component();
protected:
virtual void Free();
};
_END
|
7a8c9bf2b4a8244d855380bdfaf5c579f93663f0
|
f8a222de50e85dfd4de79856d8053f571efe9479
|
/Engine/Code/Engine/Network/NetConnection.cpp
|
4b3a7ca5c09da74450636596089eff6018f95401
|
[] |
no_license
|
ValhallaCode/Guildhall_Work
|
f813ec69f2230522446d57eb06d224abcd7a5be5
|
2020207299bd83ddc292f1c15f7ba9c85fa71cc0
|
refs/heads/master
| 2021-09-05T10:41:22.253563
| 2018-01-26T14:06:08
| 2018-01-26T14:06:08
| 119,058,534
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 178
|
cpp
|
NetConnection.cpp
|
#include "Engine/Network/NetConnection.hpp"
NetConnection::NetConnection()
:m_prev(nullptr)
, m_next(nullptr)
, m_owner(nullptr)
{
}
NetConnection::~NetConnection()
{
}
|
221cbf076dee5a1f1dd8ec5739c4a62fde68d33e
|
81b2279b2b24636ccaebb091d7543537142a9272
|
/ๅๆoffer/้ข่ฏ้ข57 - II. ๅไธบs็่ฟ็ปญๆญฃๆฐๅบๅ_easy/้ๅทๅๆoffer_ๆดๅๆณ_่ถ
ๆถ.cpp
|
e2ac08418e0feb1eac68f52ebaa61390265c670c
|
[] |
no_license
|
gwtak/My_Leetcode
|
be6a8d5a050bcd378ae8cfd38ea5b0e5d6f4f70d
|
bcbebcc8e6c9c58237698ab7534aa3718c489f21
|
refs/heads/master
| 2022-12-31T22:23:20.771120
| 2020-10-20T10:29:19
| 2020-10-20T10:29:19
| 263,764,562
| 1
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 537
|
cpp
|
้ๅทๅๆoffer_ๆดๅๆณ_่ถ
ๆถ.cpp
|
class Solution {
public:
vector<vector<int>> findContinuousSequence(int target) {
vector<vector<int>> res;
for(int i=1;i<=target/2;i++){
int sum=0;
for(int j=i;j<=(target/2+1);j++){
sum+=j;
if(sum==target){
vector<int> tmp;
for(int k=i;k<=j;k++){
tmp.push_back(k);
}
res.push_back(tmp);
}
}
}
return res;
}
};
|
d6620ba3dbf84c78568e95656f4670b13d066269
|
2b196a99a4af98f56828ce148a009a839a536e1f
|
/simulator/voxcad-code-2014/GeneratedFiles/release/moc_QVX_TensileTest.cpp
|
193e61682886b998d7e218c312995088b71bece0
|
[
"Apache-2.0"
] |
permissive
|
fgolemo/EC14-LargeSoftSim
|
f61d1f5e1abc0cde57325d33ba5c8bcc86113568
|
e61f0224303231ff8dc60fb00170c6ca874d3d69
|
refs/heads/master
| 2021-01-10T11:27:53.456877
| 2016-01-20T17:54:01
| 2016-01-20T17:54:01
| 49,879,380
| 0
| 1
| null | 2016-02-25T11:47:45
| 2016-01-18T13:43:54
|
C++
|
UTF-8
|
C++
| false
| false
| 5,331
|
cpp
|
moc_QVX_TensileTest.cpp
|
/****************************************************************************
** Meta object code from reading C++ file 'QVX_TensileTest.h'
**
** Created: Mon Aug 25 22:50:34 2014
** by: The Qt Meta Object Compiler version 63 (Qt 4.8.1)
**
** WARNING! All changes made in this file will be lost!
*****************************************************************************/
#include "../../VoxCad/QVX_TensileTest.h"
#if !defined(Q_MOC_OUTPUT_REVISION)
#error "The header file 'QVX_TensileTest.h' doesn't include <QObject>."
#elif Q_MOC_OUTPUT_REVISION != 63
#error "This file was generated using the moc from 4.8.1. It"
#error "cannot be used with the include files from this version of Qt."
#error "(The moc has changed too much.)"
#endif
QT_BEGIN_MOC_NAMESPACE
static const uint qt_meta_data_QVX_TensileTest[] = {
// content:
6, // revision
0, // classname
0, 0, // classinfo
8, 14, // methods
0, 0, // properties
0, 0, // enums/sets
0, 0, // constructors
0, // flags
2, // signalCount
// signals: signature, parameters, type, tag, flags
17, 16, 16, 16, 0x05,
44, 16, 16, 16, 0x05,
// slots: signature, parameters, type, tag, flags
122, 67, 16, 16, 0x0a,
240, 195, 16, 16, 0x2a,
343, 306, 16, 16, 0x2a,
423, 395, 16, 16, 0x2a,
470, 461, 16, 16, 0x0a,
495, 16, 16, 16, 0x2a,
0 // eod
};
static const char qt_meta_stringdata_QVX_TensileTest[] = {
"QVX_TensileTest\0\0StartExternalGLUpdate(int)\0"
"StopExternalGLUpdate()\0"
"pSim,NumStepIn,ConvThreshIn,MixRadIn,ModelIn,PolyExpIn\0"
"BeginTensileTest(QVX_Sim*,int,double,Vec3D<double>,MatBlendModel,doubl"
"e)\0"
"pSim,NumStepIn,ConvThreshIn,MixRadIn,ModelIn\0"
"BeginTensileTest(QVX_Sim*,int,double,Vec3D<double>,MatBlendModel)\0"
"pSim,NumStepIn,ConvThreshIn,MixRadIn\0"
"BeginTensileTest(QVX_Sim*,int,double,Vec3D<double>)\0"
"pSim,NumStepIn,ConvThreshIn\0"
"BeginTensileTest(QVX_Sim*,int,double)\0"
"pMessage\0RunTensileTest(QString*)\0"
"RunTensileTest()\0"
};
void QVX_TensileTest::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
if (_c == QMetaObject::InvokeMetaMethod) {
Q_ASSERT(staticMetaObject.cast(_o));
QVX_TensileTest *_t = static_cast<QVX_TensileTest *>(_o);
switch (_id) {
case 0: _t->StartExternalGLUpdate((*reinterpret_cast< int(*)>(_a[1]))); break;
case 1: _t->StopExternalGLUpdate(); break;
case 2: _t->BeginTensileTest((*reinterpret_cast< QVX_Sim*(*)>(_a[1])),(*reinterpret_cast< int(*)>(_a[2])),(*reinterpret_cast< double(*)>(_a[3])),(*reinterpret_cast< Vec3D<double>(*)>(_a[4])),(*reinterpret_cast< MatBlendModel(*)>(_a[5])),(*reinterpret_cast< double(*)>(_a[6]))); break;
case 3: _t->BeginTensileTest((*reinterpret_cast< QVX_Sim*(*)>(_a[1])),(*reinterpret_cast< int(*)>(_a[2])),(*reinterpret_cast< double(*)>(_a[3])),(*reinterpret_cast< Vec3D<double>(*)>(_a[4])),(*reinterpret_cast< MatBlendModel(*)>(_a[5]))); break;
case 4: _t->BeginTensileTest((*reinterpret_cast< QVX_Sim*(*)>(_a[1])),(*reinterpret_cast< int(*)>(_a[2])),(*reinterpret_cast< double(*)>(_a[3])),(*reinterpret_cast< Vec3D<double>(*)>(_a[4]))); break;
case 5: _t->BeginTensileTest((*reinterpret_cast< QVX_Sim*(*)>(_a[1])),(*reinterpret_cast< int(*)>(_a[2])),(*reinterpret_cast< double(*)>(_a[3]))); break;
case 6: _t->RunTensileTest((*reinterpret_cast< QString*(*)>(_a[1]))); break;
case 7: _t->RunTensileTest(); break;
default: ;
}
}
}
const QMetaObjectExtraData QVX_TensileTest::staticMetaObjectExtraData = {
0, qt_static_metacall
};
const QMetaObject QVX_TensileTest::staticMetaObject = {
{ &QWidget::staticMetaObject, qt_meta_stringdata_QVX_TensileTest,
qt_meta_data_QVX_TensileTest, &staticMetaObjectExtraData }
};
#ifdef Q_NO_DATA_RELOCATION
const QMetaObject &QVX_TensileTest::getStaticMetaObject() { return staticMetaObject; }
#endif //Q_NO_DATA_RELOCATION
const QMetaObject *QVX_TensileTest::metaObject() const
{
return QObject::d_ptr->metaObject ? QObject::d_ptr->metaObject : &staticMetaObject;
}
void *QVX_TensileTest::qt_metacast(const char *_clname)
{
if (!_clname) return 0;
if (!strcmp(_clname, qt_meta_stringdata_QVX_TensileTest))
return static_cast<void*>(const_cast< QVX_TensileTest*>(this));
if (!strcmp(_clname, "CVX_Sim"))
return static_cast< CVX_Sim*>(const_cast< QVX_TensileTest*>(this));
return QWidget::qt_metacast(_clname);
}
int QVX_TensileTest::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QWidget::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
if (_c == QMetaObject::InvokeMetaMethod) {
if (_id < 8)
qt_static_metacall(this, _c, _id, _a);
_id -= 8;
}
return _id;
}
// SIGNAL 0
void QVX_TensileTest::StartExternalGLUpdate(int _t1)
{
void *_a[] = { 0, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
QMetaObject::activate(this, &staticMetaObject, 0, _a);
}
// SIGNAL 1
void QVX_TensileTest::StopExternalGLUpdate()
{
QMetaObject::activate(this, &staticMetaObject, 1, 0);
}
QT_END_MOC_NAMESPACE
|
8dc2e6e64bf82d329ce4e34910e8c25d36fe7703
|
b28575448da2861779f714c0b4f9c68a0be6e9a9
|
/EBERGIA/number/number.ino
|
e3e7af960d2c737109eaec8798857f924846fa47
|
[] |
no_license
|
SijieChenXM/Study-Notes-of-MSP430
|
906ab6dd0872c1c3709e9289ad3e8084764d9f27
|
75e8f4f58d0869902908f65265ae89cc67a9a8c4
|
refs/heads/master
| 2020-06-16T05:25:47.922630
| 2019-07-06T09:03:52
| 2019-07-06T09:03:52
| 195,490,245
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 1,123
|
ino
|
number.ino
|
int a = P1_0;
int b = P1_1;
int c = P1_2;
int d = P2_0;
int e = P1_4;
int f = P1_5;
int g = P1_6;
int dp = P1_7;
char x=0;
int y=0;
int z=0;
const unsigned char LED8Pin[]={a,b,c,d,e,f,g,dp};
const unsigned char LED8Code[]= { 0xC0, 0xF9, 0xA4, 0xB0,0x99, 0x92,0x82, 0xF8, 0x80, 0x90, 0x88, 0x83,0xC6,0xA1,0x86,0x8E };
void setup() {
pinMode(P2_2,INPUT_PULLUP);
pinMode(P1_3,INPUT_PULLUP);
char i;
for(i=0;i<8;i++)
{
pinMode(LED8Pin[i], OUTPUT);
digitalWrite(LED8Pin[i],HIGH);
}
}
void LED8Display(char data)
{
char m;
char n;
char dis;
if((0<=data)&&(data<16))
{
dis = LED8Code[data];
for(m=0;m<8;m++)
{
n = bitRead(dis,m);
digitalWrite(LED8Pin[m], !n);
}
}
}
void loop() {
// put your main code here, to run repeatedly:
if(x==16){
x=0;
}
if(x==-1){
x=15;
}
if(digitalRead(P1_3)==LOW)
{
delay(10);
if(digitalRead(P1_3)==LOW&&z==0)
{
x--;
z++;
}
}
else
{
delay(10);
if(digitalRead(P1_3)==HIGH)
{
z=0;
}
}
if(digitalRead(P2_2)==LOW)
{
delay(10);
if(digitalRead(P2_2)==LOW&&y==0)
{
x++;
y++;
}
}
else
{
delay(10);
if(digitalRead(P2_2)==HIGH)
{
y=0;
}
}
LED8Display(x);
}
|
9d03c02b65a6b1187dc273c2635f560bed5606f2
|
9aed3609960b3879e13507a0009002c1d3a44088
|
/TheGame/T2.h
|
23e7fb62d4bcdc51b8ef7e2809aa1f8fdc3335c6
|
[
"MIT"
] |
permissive
|
Evildea/DinosaurGame
|
ebfec5bda4b9702c7766857007669a26332070ec
|
fe46e58b6aa1bcdd9ab726c182faf9fdbb06181f
|
refs/heads/master
| 2020-06-23T08:50:25.186445
| 2019-07-30T06:51:52
| 2019-07-30T06:51:52
| 198,575,532
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 936
|
h
|
T2.h
|
#pragma once
#include "Renderer2D.h"
#include "Global.h"
#include <math.h>
#include "V2.h"
#include "M3.h"
// The function of the T2 (Target Vector2) is to provide a target in 2D space to look towards or travel towards.
// This is primarily used to ensure that head of the dinosaur rotates smoothly between targets.
class T2
{
private:
V2<float> m_transform;
V2<float> m_velocity;
V2<float> m_avoid;
public:
T2();
~T2();
// These are custom update and draw functions. The draw function is only used for debugging.
void update(M3<float> a_transform, V2<float> a_target, float a_speed, float a_minDistance, float deltaTime);
void draw(aie::Renderer2D * a_renderer, float r, float g, float b);
// This returns the current position.
V2<float> getPosition();
// This sets the position.
void setPosition(V2<float> a_position);
// This ensures the target avoids a specific point.
void updateAvoid(V2<float> a_avoid);
};
|
78ddde2f67d3e9f9942493f0d9b701600964c4e0
|
15c6360b99546b2850230976aa37177a3925e930
|
/Pratice/arrfun3/arrfun3.cpp
|
5a4c939d5682b16b860af608d085c47b33ac88a7
|
[] |
no_license
|
Yyyye/CppPrimerPlus
|
d232915df0e0e20fbb4dd12894fee0cb32841a65
|
7478f738d943829764e3bce813295182de07c704
|
refs/heads/master
| 2021-09-03T20:09:11.440550
| 2018-01-11T16:35:56
| 2018-01-11T16:35:56
| 114,254,833
| 0
| 0
| null | null | null | null |
GB18030
|
C++
| false
| false
| 1,500
|
cpp
|
arrfun3.cpp
|
#include<iostream>
const int Max = 5;
int fill_array(double ar[], int limit);
void show_array(const double ar[], int n);
void revalue(double r, double ar[], int n);
int main()
{
using namespace std;
double properties[Max];
int size = fill_array(properties, Max);
show_array(properties, size);
if (size > 0)
{
cout << "Enter revalutation factor";
double factor;
while (!(cin >> factor))
{
cin.clear();
while (cin.get() != '\n');
continue;
cout << "Bad input : please enter a number ";
}
revalue(factor, properties, size);
show_array(properties, size);
}
cout << "Done !\n";
cin.get();
cin.get();
return 0;
}
int fill_array(double arr[], int limit) {
using namespace std;
double temp;
int i;
for ( i = 0; i < limit; i++)
{
cout << "Enter value #" << i + 1 << endl;
cin >> temp;
if (!cin)
{
cin.clear();
while (cin.get() != '\n')
continue;
cout << "Bad input , input process terminated\n";
break;
}
else if (temp < 0)
break;
arr[i] = temp;
}
return i;
}
void show_array(const double ar[], int n)
{
using namespace std;
for (int i = 0; i < n; i++)
{
cout << "Properties #" << (i + 1) << ":$";
cout << ar[i] << endl;
}
}
void revalue(double r, double ar[], int n)
{
for (int i = 0; i < n; i++)
{
ar[i] *= r;
}
}
//ๅฝๆฐ็ๅฝขๅผ:
//1.ๅฏ่ฝไฝฟ่ฟๆ ท็ void f(int ar[],int i); //ไฟฎๆนๅฝๆฐ็ๅฝขๅผ
//2.ๅฏ่ฝไฝฟ่ฟๆ ท็ void f(const int ar[], int i ) //ๆ ๆณไฟฎๆนๅฝๆฐ็ๅฝขๅผ
|
ca840308ed29f6fca9a5712f1dbcb6a718da29c1
|
00d59fc683ae26dbda511bab355836b9e2e6b43d
|
/poj/1001/11504061_AC_0MS_220K.cpp
|
7f0e2d3ed3e8f53754f2e4f051e8991becb9aa1e
|
[] |
no_license
|
howardchina/ACM-ICPC-solved-problem
|
01f8744c12b765ffc0ea23600fab79c58a5f6e0e
|
63805f390c754c4561d43c4902939eff26ad7cbd
|
refs/heads/master
| 2020-04-01T20:22:33.562335
| 2018-12-11T09:09:03
| 2018-12-11T09:09:03
| 153,601,172
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 1,888
|
cpp
|
11504061_AC_0MS_220K.cpp
|
#include<cstdio>
#include<iostream>
#include<cstdlib>
#include<queue>
#include<cstring>
using namespace std;
char s[7];
int len,len1,i,j,n,point,num;
int ans[200],result[200],a[7],ok,d,m;
void F() //ไนๆณๅฝๆฐ
{
for(i=0;i<len;i++)
for(j=0;j<len1;j++)
{
result[i+j]+=(a[i]*ans[j]%10);
result[i+j+1]+=(a[i]*ans[j]/10);
}
for(i=0;i<len+len1-1;i++)
{
if(result[i]>=10)
{
result[i+1]+=result[i]/10;
result[i]%=10;
}
}
if(result[len+len1-1]!=0) //ๅคๆญ้ซไฝๆๆฒก่ฟไฝ
len1=len1+len;
else len1=len1+len-1;
for(i=0;i<len1;i++) //ๆฟๆขๅ
ถไธญไธไธชๅ ๅญ๏ผๅฆไธไธช่ฏๅฎไธๅ
ans[i]=result[i];
}
int main()
{
while(scanf("%s%d",s,&n)!=EOF)
{
len=strlen(s);
if(n==1)
{
printf("%g\n",atof(s)); //nไธบ1๏ผๆ
ๅต็นๆฎ๏ผๅทๆ็จไบๅฝๆฐๅบ
continue;
}
point=0;
ok=0;
i=0;
j=len-1;
for(m=0;m<len;m++) //ๆฒกๅไปไนๅฐๆฐ้จๅๆดๆฐ้จๅ๏ผไธ่ตท่ฎก็ฎ๏ผๅช่ฆ่ฎฐๅฝๅฐๆฐ็นไฝ็ฝฎๅฐฑOK
{
if(s[m]=='.')
{
ok=1;
break;
}
}
if(ok==1)
{
while(s[j]=='0'&&j>=0)
j--;
while(s[j]!='.'&&j>=0)
a[i++]=s[j--]-48;
point=i;
j--;
}
num=point*n;
for(m=0;m<=j;m++)
if(s[m]!='0')
break;
while(j>=m)
a[i++]=s[j--]-48;
len=i;
len1=len;
memset(ans,0,sizeof(ans));
for(i=0;i<len;i++)
ans[i]=a[i];
for(int k=2;k<=n;k++)
{
memset(result,0,sizeof(result));
F();
}
d=num-1;
for(i=len1-1;i>=num;i--)
{
if(result[i]!=0)
{
d=i;
break;
}
}
if(d>=num)
{
for(i=len1-1;i>=num;i--)
printf("%d",result[i]);
}
if(point!=0&&ok==1) //่พๅบ็่ฆๆฑ่พ้ซ
printf(".");
for(i=num-1;i>=0;i--)
printf("%d",result[i]);
putchar(10);
}
system("pause");
return 0;
}
|
c84d9e1e8b451db06b94f7f0d81aee45330f4e7a
|
d56eae354ff88d550d467194b1b514b04cc37970
|
/557. Inverts the word III in a string/test.cpp
|
3fb66429e25287326ce24917641189a6863a3e78
|
[] |
no_license
|
yangxu1003/leetcode
|
ae7d0c067abf548429863327a0743d5caf2a38f1
|
64f998721e3a417fb6efa55eb421006aa24c3867
|
refs/heads/master
| 2023-07-13T17:14:46.640323
| 2021-08-12T15:29:11
| 2021-08-12T15:29:11
| 318,562,627
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 354
|
cpp
|
test.cpp
|
class Solution {
public:
string reverseWords(string s) {
size_t pos = 0;
int left = 0;//ๆฏๆฌก่ตฐ็ไฝ็ฝฎ
while((pos = s.find(' ', pos+1)) != string::npos)
{
reverse(s.begin()+left, s.begin()+pos);
left = pos+1;
}
reverse(s.begin()+ left, s.end());
return s;
}
};
|
d41141b25ba1ef70393d3987666f7a21ade97555
|
9d31ba5aac1d7686d2ee3e017521a54356082bf3
|
/lib/schwa/grfx/renderbuffer.h
|
185b69dc8f0a6bcb9c9b9547edb30799a4c3503f
|
[] |
no_license
|
schwa423/Sketchy
|
24bb0b2879af8200e778f6e0ebe8b6b560a676b9
|
daa1dff85c1166529d2f9787545b25305702d7e0
|
refs/heads/master
| 2020-04-06T23:17:43.953723
| 2014-05-31T21:18:27
| 2014-05-31T21:18:27
| 3,026,018
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 2,230
|
h
|
renderbuffer.h
|
//
// renderbuffer.h
// schwa::grfx
//
// Created by Josh Gargus on 9/23/12.
// Copyright (c) 2012 Schwaftwarez.
// Licensed under the Apache License, Version 2.0.
//
//
#ifndef __schwa__grfx__renderbuffer__
#define __schwa__grfx__renderbuffer__
#include "renderer.h"
#include "framebuffer.h"
#include "platform_gl.h"
// namespace schwa::grfx
namespace schwa {namespace grfx {
class Renderbuffer;
typedef shared_ptr<Renderbuffer> RenderbufferPtr;
class Renderbuffer : public Renderer::Resource, public Framebuffer::Attachment {
friend class Framebuffer;
public:
// "Constructors".
// TODO: consider making these instance-methods of Renderer.
static shared_ptr<Renderbuffer> NewColor(shared_ptr<Renderer> renderer,
uint width, uint height, int samples=1);
static shared_ptr<Renderbuffer> NewDepth(shared_ptr<Renderer> renderer,
uint width, uint height, int samples=1);
static shared_ptr<Renderbuffer> NewStencil(shared_ptr<Renderer> renderer,
uint width, uint height, int samples=1);
virtual ~Renderbuffer();
// Bind this as the current renderbuffer.
void bind() const;
// Access renderbuffer properties.
int width() const { return _width; }
int height() const { return _height; }
int samples() const { return _samples; }
// What type of renderbuffer is this, color/depth/stencil?
bool isColor() const;
bool isDepth() const;
bool isStencil() const;
protected:
static shared_ptr<Renderbuffer> New(shared_ptr<Renderer> renderer,
uint width, uint height,
int samples, GLenum format);
Renderbuffer(shared_ptr<Renderer> renderer, GLuint handle,
uint width, uint height, int samples, GLenum format);
// TODO: comment
virtual void attach(GLenum attachmentPoint) const;
// OpenGL renderbuffer ID
GLuint _handle;
// Number of multisamples.
int _samples;
// Pixel-format.
GLenum _format;
};
}} // namespace schwa::grfx
#endif // #ifndef __schwa__grfx__renderbuffer__
|
7fb0ec328010a6df764f532131f416c4dcb139d8
|
c5ba5268e6eca1bc3168f51bae91ba8ac1b5fb92
|
/unused/class_custom_cout.h
|
da0953695f43b3daae0660b242304f7342af3e96
|
[
"MIT"
] |
permissive
|
DavidAce/DMRG
|
ee77ad50812946ec272334e58d862298065ca4b0
|
e65be677bc4e3e61c8b38b982e5bbf5dad797063
|
refs/heads/master
| 2023-08-16T19:30:16.568518
| 2023-04-14T06:27:43
| 2023-04-14T06:27:43
| 98,307,786
| 11
| 2
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 1,188
|
h
|
class_custom_cout.h
|
//
// Created by david on 2018-01-16.
//
#ifndef DMRG_CLASS_CONSOLE_PRINTER_H
#define DMRG_CLASS_CONSOLE_PRINTER_H
#include <chrono>
#include <iostream>
class class_custom_cout
{
public:
int verbosity = 0;
int temp_verbosity = 0;
std::ostream &os;
explicit class_custom_cout(std::ostream &o = std::cout):os(o){};
explicit class_custom_cout(int verbosity_, std::ostream &o = std::cout):verbosity(verbosity_),temp_verbosity(verbosity_),os(o){};
void set_verbosity(int new_verbosity){verbosity = new_verbosity; temp_verbosity = new_verbosity;}
template <typename T>
class_custom_cout &operator<<(const T &a) {
if (temp_verbosity >= verbosity) {
os << a;
}else{
os.clear();
}
return *this;
}
class_custom_cout &operator<<(std::ostream& (*pf) (std::ostream&)){
if (temp_verbosity <= verbosity) {
os << pf;
}else{
os.clear();
}
temp_verbosity = verbosity;
return *this;
}
class_custom_cout& operator()(int level) {
temp_verbosity = level;
return *this;
}
};
#endif //DMRG_CLASS_CONSOLE_PRINTER_H
|
98c34e49a9f0ba90b52384547789f67b8ac0f4d4
|
32ac6dabcc8b2c872e03a8fedf2801dba76863ea
|
/Src/Strategy/Common/VirtualRosbee.h
|
c5f89aabef174adae0f7b62ac602d62940df6c93
|
[] |
no_license
|
CharanKoyalkar484/RoboRescueCproject
|
cf061e063942514062c06633922872f1dc84e032
|
f5e658468f4f3282f045e3afb60e944255adc06d
|
refs/heads/master
| 2021-02-18T04:03:29.210397
| 2020-04-13T07:14:40
| 2020-04-13T07:14:40
| 245,157,866
| 0
| 0
| null | 2020-04-13T07:14:41
| 2020-03-05T12:30:08
|
C++
|
WINDOWS-1252
|
C++
| false
| false
| 3,806
|
h
|
VirtualRosbee.h
|
/**
* __
* _________ / /_ ____ ________ ____________ _____
* /___/ __ \/ __ \/ __ \/ ___/ _ \/ ___/ ___/ / / / _ \
* / / / /_/ / /_/ / /_/ / / / __(__ ) /__/ /_/ / __/
* /_/ \____/_.___/\____/_/ \___/____/\___/\__,_/\___/
*
*
* @file VirtualRosbee.h
* @date Created: 4/28/2015
* @version 1.0
*
* @author Coen Andriessen
* @author Jeroen Steendam
*
* @section LICENSE
* License: newBSD
*
* Copyright ยฉ 2015, HU University of Applied Sciences Utrecht.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
* - Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
* - Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
* - Neither the name of the HU University of Applied Sciences Utrecht nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
* THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE HU UNIVERSITY OF APPLIED SCIENCES UTRECHT
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
* GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
**/
#ifndef VIRTUALROSBEE_H
#define VIRTUALROSBEE_H
#include <iostream>
#include "Rosbee.h"
class virtualRosbee
{
public:
/**
* @fn VirtualRosbee(int x, int y);
*
* @brief Constructor of the class VirtualRosbee.
*
* @param int x
* @param int y
*/
virtualRosbee(int x, int y, Rosbee* actual);
/**
* @fn ~VirtualRosbee();
*
* @brief Destructor of the class VirtualRosbee.
*/
~virtualRosbee();
/**
* @fn int getVirtualRosbeeLocationX();
*
* @brief Function that returns the x location of the VirtualRosbee.
*
* @return int rosbeeLocationX
*/
int getVirtualRosbeeLocationX();
/**
* @fn int getVirtualRosbeeLocationY();
*
* @brief Function that returns the y location of the VirtualRosbee.
*
* @return int rosbeeLocationY
*/
int getVirtualRosbeeLocationY();
/**
* @fn void set RosbeeLocationY();
*
* @brief Function that set the y location of the VirtualRosbee.
*
* @param y
*/
void setVirtualRosbeeLocationY(int y);
/**
* @fn void set RosbeeLocationX();
*
* @brief Function that set the x location of the VirtualRosbee.
*
* @param x
*/
void setVirtualRosbeeLocationX(int x);
/**
* @fn int getVirtualRosbeeFlank();
*
* @brief Function to get flank of the actual Rosbee.
*
* @return flank
*/
int getVirtualRosbeeFlank();
/**
* @fn void moveTo(int x, int y);
*
* @brief Function to move the virtualrosbee to location x and y.
*
* @param int x
* @param int y
*/
void moveTo(int x, int y);
private:
/**
* @brief Rosbee *rActual. Object for the actual Rosbee.
*/
Rosbee *rActual;
/**
* @brief int rosbeeLocationX variable to save virtualrosbee location x.
*/
int virtualRosbeeLocationX;
/**
* @brief int rosbeeLocationY variable to save virtualrosbee location y.
*/
int virtualRosbeeLocationY;
};
#endif // VIRTUALROSBEE_H
|
3e2c9d84e71372760db7f20f5272deeb3da5f4e8
|
83e240dc3127db4261ddc749c43a0062fe708799
|
/ITP1_10_C.cpp
|
381b11a444c8cf424eb761ecbee2307715f56296
|
[] |
no_license
|
Fujino-r7F/AOJ_ITP
|
f188bab60437b9ee6a861e0557a463374cf3053a
|
1a9605dbc41e28d0fafe03e514f410c472e7c2ac
|
refs/heads/master
| 2021-03-29T18:38:09.197278
| 2020-03-23T07:05:46
| 2020-03-23T07:05:46
| 247,976,336
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 463
|
cpp
|
ITP1_10_C.cpp
|
#include <bits/stdc++.h>
using namespace std;
int main(){
int n;
while(true){
cin >> n;
if(n == 0)break;
double S[n] = {0};
double sum = 0;
for(int i=0;i<n;++i){
cin >> S[i];
sum += S[i];
}
double ave = sum / n;
double var = 0;
for(int i=0;i<n;++i){
var += pow(S[i] - ave,2);
}
printf("%.8f\n",sqrt(var/n));
}
return 0;
}
|
7fc4af26ca2a60bf51e3cd5eb4eaa132c268af5d
|
2169f381976a72244245abda54f62d051d796464
|
/src/buffers/VertexBuffer.h
|
fd261517c4ecbab0641aabfa6446d35e08e35a4c
|
[] |
no_license
|
kanadas/graphX
|
e5be4d4d8ff69d178065229ad8a92aaa8cc91ef2
|
7f70fcd69f791debb9a9c98713ae955e64f12a9f
|
refs/heads/master
| 2023-02-26T07:33:48.311882
| 2021-02-01T12:08:20
| 2021-02-01T12:08:20
| 332,520,127
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 484
|
h
|
VertexBuffer.h
|
#ifndef __VERTEXBUFFER_H_
#define __VERTEXBUFFER_H_
#include "glad/glad.h"
class VertexBuffer {
private:
GLuint rendererID;
public:
VertexBuffer(const void* data, GLuint size, GLenum usage);
VertexBuffer(const void* data, GLuint size);
~VertexBuffer();
void bind() const;
void unbind() const;
void sendData(const void* data, GLuint size, GLuint offset = 0);
void reset(const void* data, GLuint size, GLenum usage);
};
#endif // __VERTEXBUFFER_H_
|
97745f6500264300ba04a43ff2b2b8913f5152a7
|
624a105dbe52630ac0cb123e69c0ace95fe9d34b
|
/2nd_semester/hw08/01/bag.h
|
aabdbc44edb3f84a70c9f0101151d3cf798a0a7e
|
[] |
no_license
|
Axroy/SPbSU_study
|
f6769618d5ca4279a1a8a6cf1c90f0153461e948
|
6bd43d1b3e4105f898d1960f823b44595be020f9
|
refs/heads/master
| 2020-12-25T17:03:59.820392
| 2016-06-01T14:33:10
| 2016-06-01T14:33:10
| 30,873,932
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 875
|
h
|
bag.h
|
#pragma once
#include "AVLTree.h"
///Class representing set with possibility of repeating elements.
///Based on the AVL tree.
class Bag
{
public:
Bag() : tree(new AVLTree){}
~Bag()
{
delete tree;
}
///Adds value to the bag.
void insert(int value)
{
tree->insert(value);
}
///Removes value from the bag.
void remove(int value)
{
tree->remove(value);
}
///Returns true if a value exists in the bag.
bool exists(int value)
{
return tree->exists(value);
}
///Returns string with structure of bag in following
///representation: (value left_subtree right_subtree).
QString print()
{
return tree->print();
}
///Returns true if the bag contains no elements.
bool isEmpty()
{
return tree->isEmpty();
}
private:
AVLTree *tree;
};
|
d7fcf4cc4e618e420e99e73835f8fb8797e3f718
|
e056199b86697d3b20eb76f34c324c822d5edd30
|
/Samples/08_Base_memory_management/MemoryMap/MemMap4/main.cpp
|
4faffaeeaed8762a7e7811abcfc0a98a1893561e
|
[
"MIT"
] |
permissive
|
MihailRomanov/System_Programming_Course
|
6fac57227e28568ecc6cce00d4c0ae96a114d28b
|
49ac442646b3c518b975ed89b412202d34d66bf1
|
refs/heads/master
| 2020-03-28T11:23:43.241667
| 2019-03-25T15:04:26
| 2019-03-25T15:04:26
| 148,208,170
| 3
| 2
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 567
|
cpp
|
main.cpp
|
#include <cstdio>
#include <Windows.h>
void step(int i, const char *comment)
{
printf("Step %d : %s\n", i, comment);
char b;
scanf_s("%c", &b, 1);
}
int main()
{
step(0, "Before reserv");
void * a = VirtualAlloc(0, 1000000, MEM_RESERVE, PAGE_READWRITE);
printf("%X\n", a);
step(1, "Before commit");
VirtualAlloc(a, 1000000, MEM_COMMIT, PAGE_READWRITE);
step(2, "Before decommit");
VirtualFree(a, 1000000, MEM_DECOMMIT);
step(3, "Before release");
VirtualFree(a, 0, MEM_RELEASE);
step(4, "After free");
}
|
97ad18d52f485dc80e99283eb65df1a7d0c4d6f9
|
5110db3788c0bfca4556d0105b229d573857b23d
|
/IO/ImageLoader.cpp
|
f7ae2c559c38ab70424e8d14ca672ad522e14b32
|
[] |
no_license
|
anton-brandl/RegistrationApp
|
b14b668f9c705d11f5bdb862cc234314988c2dab
|
d59b0af19d6daad65656815131d9e8c1cf194702
|
refs/heads/master
| 2023-03-09T20:57:59.251599
| 2015-07-15T10:16:25
| 2015-07-15T10:16:25
| null | 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 538
|
cpp
|
ImageLoader.cpp
|
/*#include "ImageLoader.h"
template <class PixelType>
itk::Image<PixelType, 2>* ImageLoader::loadDicomImage(std::string src)
{
const unsigned int ImageDimension = 2;
typedef itk::Image< PixelType, ImageDimension > ImageType;
typedef itk::ImageFileReader< ImageType > ImageReaderType;
ImageReaderType::Pointer imageReader = ImageReaderType::New();
imageReader->SetFileName(src);
return imageReader->GetOutput();
}
template <class PixelType>
itk::Image<PixelType, 3>* ImageLoader::loadDicomVolume(std::string src)
{
}*/
|
5b6760e1bc24ecef54f16001a54eae86f46dad05
|
dc5f5b7a0add1198678c27addde067e4413b8b3e
|
/Static.cpp
|
a00ef8c35fe8e73f2ed2f31306425733ee56d177
|
[] |
no_license
|
lalomx/learning-cpp
|
221a0a83e7e0651f6316864ae260efd0158971d0
|
6fe06a2f130b3f2e89abfeebc8e2b7d9ca7672d5
|
refs/heads/master
| 2023-08-27T06:44:24.654455
| 2021-10-10T00:29:53
| 2021-10-10T00:29:53
| 414,446,884
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 257
|
cpp
|
Static.cpp
|
static int s_Number = 5;
class Singleton {
public:
// gettting instance by creatin a local scoped static variable
// return the ref of it
Singleton& Get()
{
static Singleton instance;
return instance;
}
void Change(int a) {
s_Number = a;
}
};
|
3fd4da1cb45230beb2227ba02cbadde7f9e89711
|
8dfe4bef840a00972ebe18634bbf28636dec9949
|
/FKCWLib/FKCW_TMX/Source/FKCW_TMX_MapInfo.cpp
|
b037dab464aff52fc933783a32b361553af2345e
|
[] |
no_license
|
pingfanJerry/FKCocos2dxWrapper_2.x
|
ba644308746557e99f8fa201a832aafa7e806927
|
2ff906f10a030d7a2dbe968ba9d17798e2537a37
|
refs/heads/master
| 2020-03-10T16:58:40.391923
| 2017-03-16T06:43:05
| 2017-03-16T06:43:05
| 129,487,589
| 1
| 0
| null | 2018-04-14T06:12:13
| 2018-04-14T06:12:13
| null |
UTF-8
|
C++
| false
| false
| 2,619
|
cpp
|
FKCW_TMX_MapInfo.cpp
|
//-------------------------------------------------------------------------
#include "../Include/FKCW_TMX_MapInfo.h"
#include "../Include/FKCW_TMX_TileSetInfo.h"
//-------------------------------------------------------------------------
FKCW_TMX_MapInfo::FKCW_TMX_MapInfo()
{
}
//-------------------------------------------------------------------------
FKCW_TMX_MapInfo::~FKCW_TMX_MapInfo()
{
}
//-------------------------------------------------------------------------
FKCW_TMX_MapInfo* FKCW_TMX_MapInfo::create()
{
FKCW_TMX_MapInfo* m = new FKCW_TMX_MapInfo();
return (FKCW_TMX_MapInfo*)m->autorelease();
}
//-------------------------------------------------------------------------
string FKCW_TMX_MapInfo::getProperty(const string& key)
{
CCString* p = (CCString*)m_properties.objectForKey(key);
if(p)
return p->getCString();
else
return "";
}
//-------------------------------------------------------------------------
void FKCW_TMX_MapInfo::addProperty(const string& key, const string& value)
{
if(!m_properties.objectForKey(key)) {
m_properties.setObject(CCString::create(value), key);
}
}
//-------------------------------------------------------------------------
int FKCW_TMX_MapInfo::getTileSetIndex(int gid)
{
int pureGid = gid & eTMXTileFlagFlipMask;
int count = m_tilesets.count();
for(int i = 0; i < count; i++)
{
FKCW_TMX_TileSetInfo* tileset = (FKCW_TMX_TileSetInfo*)m_tilesets.objectAtIndex(i);
if(tileset->getFirstGid() > pureGid)
return i - 1;
}
return m_tilesets.count() - 1;
}
//-------------------------------------------------------------------------
string FKCW_TMX_MapInfo::getTileProperty(int gid, const string& key)
{
int pureGid = gid & eTMXTileFlagFlipMask;
char buf[32];
sprintf(buf, "%d", pureGid);
CCDictionary* props = (CCDictionary*)m_tileProperties.objectForKey(buf);
if(props) {
CCString* p = (CCString*)props->objectForKey(key);
if(p)
return p->getCString();
else
return "";
} else {
return "";
}
}
//-------------------------------------------------------------------------
void FKCW_TMX_MapInfo::addTileProperty(int gid, const string& key, const string& value)
{
int pureGid = gid & eTMXTileFlagFlipMask;
char buf[32];
sprintf(buf, "%d", pureGid);
CCDictionary* props = (CCDictionary*)m_tileProperties.objectForKey(buf);
if(!props) {
props = CCDictionary::create();
m_tileProperties.setObject(props, buf);
}
props->setObject(CCString::create(value), key);
}
//-------------------------------------------------------------------------
|
0074a4431f2e63384d31196936cac62594e45f2a
|
07d23cf641c9d606ae192da44672ce472f479abd
|
/ThreadPintar.cpp
|
933f491b3352c2720aaea21ed17fced8bf75af70
|
[] |
no_license
|
Strongc/Laser2D
|
bd2915c080fb6ed18ef8ac0048d0d1ec83735a7d
|
3effedb1da5639df45763c505e99cfa4794d5f4b
|
refs/heads/master
| 2021-01-12T22:08:39.925817
| 2015-09-29T08:05:44
| 2015-09-29T08:05:44
| null | 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 1,742
|
cpp
|
ThreadPintar.cpp
|
//---------------------------------------------------------------------------
#include <vcl.h>
#pragma hdrstop
#include "ThreadPintar.h"
#include "Windows.h"
//---------------------------------------------------------------------------
__fastcall ThreadPintar::ThreadPintar(): TThread(true)
{
Paint * pintar = new Paint();
}
//---------------------------------------------------------------------------
void __fastcall ThreadPintar::Execute()
{
while (!(fin)){
if (tipoDatos){
lectorDatos->leerDatos();
//tipoDatos=false;
}
else{
Cadena = conPuerto->ReadTrama();
NuevaCadena = true;
//Suspend();
}
}
}
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
}
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
char * Laser::LeerCadena(){
if (NuevaCadena){
NuevaCadena = false;
return Cadena;
}
char * salida = "\0";
return salida;
}
//---------------------------------------------------------------------------
void Laser::AcabarThread(){
fin = true;
Sleep(500);
// Resume();
}
#pragma package(smart_init)
|
06c55c5679bdf65bdc05c0370ba1f41f7c20dc63
|
ff4687622747a4e904c55bb06e8a6d9353c35566
|
/dilationExample/src/ofApp.cpp
|
7284100fecb1241711c84a99ffcd0c265fc38189
|
[] |
no_license
|
yusun-hci/RTP_MIT_FALL19
|
b69d1bfe3f982b0126e162af3adb601cbbd234f7
|
134286910c628642810fa3ad100eea6861949b29
|
refs/heads/master
| 2022-11-01T05:46:38.250152
| 2019-10-28T18:36:37
| 2019-10-28T18:36:37
| null | 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 4,650
|
cpp
|
ofApp.cpp
|
#include "ofApp.h"
void dilate( ofImage & imgA, ofImage & imgB){
for (int i = 0; i < imgA.getWidth(); i++){
for (int j = 0; j < imgA.getHeight(); j++){
ofColor nw = imgA.getColor( ofClamp(i-1, 0, imgA.getWidth()-1),
ofClamp(j-1, 0, imgA.getHeight()-1));
ofColor n_ = imgA.getColor( ofClamp(i, 0, imgA.getWidth()-1),
ofClamp(j-1, 0, imgA.getHeight()-1));
ofColor ne = imgA.getColor( ofClamp(i+1, 0, imgA.getWidth()-1),
ofClamp(j-1, 0, imgA.getHeight()-1));
ofColor e_ = imgA.getColor( ofClamp(i+1, 0, imgA.getWidth()-1),
ofClamp(j, 0, imgA.getHeight()-1));
ofColor se = imgA.getColor( ofClamp(i+1, 0, imgA.getWidth()-1),
ofClamp(j+1, 0, imgA.getHeight()-1));
ofColor s_ = imgA.getColor( ofClamp(i, 0, imgA.getWidth()-1),
ofClamp(j+1, 0, imgA.getHeight()-1));
ofColor sw = imgA.getColor( ofClamp(i-1, 0, imgA.getWidth()-1),
ofClamp(j+1, 0, imgA.getHeight()-1));
ofColor w_ = imgA.getColor( ofClamp(i-1, 0, imgA.getWidth()-1),
ofClamp(j, 0, imgA.getHeight()-1));
ofColor color = imgA.getColor(i,j);
if (color.getBrightness() < 127){
if (nw.getBrightness() > 127 ||
n_.getBrightness() > 127 ||
ne.getBrightness() > 127 ||
e_.getBrightness() > 127 ||
se.getBrightness() > 127 ||
s_.getBrightness() > 127 ||
sw.getBrightness() > 127 ||
w_.getBrightness() > 127){
imgB.setColor(i,j, ofColor(255));
} else {
imgB.setColor(i,j, ofColor(0));
}
} else {
imgB.setColor(i,j,color);
}
//imgB.setColor(i,j,color);
}
}
}
//--------------------------------------------------------------
void ofApp::setup(){
ken.load("Knowlton-Ken.jpg");
ken.setImageType(OF_IMAGE_GRAYSCALE);
ken2.allocate(ken.getWidth(), ken.getHeight(), OF_IMAGE_GRAYSCALE);
ken3.allocate(ken.getWidth(), ken.getHeight(), OF_IMAGE_GRAYSCALE);
for (int i = 0; i < ken.getWidth(); i++){
for (int j = 0; j < ken.getHeight(); j++){
ofColor color = ken.getColor(i,j);
if (color.getBrightness() > 150){
ken.setColor(i, j, ofColor(255));
} else {
ken.setColor(i,j,ofColor(0));
}
}
}
ken.update();
dilate(ken, ken2);
ken2.update();
}
//--------------------------------------------------------------
void ofApp::update(){
dilate(ken2, ken3);
ken2.setFromPixels(ken3.getPixels());
//dilate(ken3, ken2);
//ken2.update();
}
//--------------------------------------------------------------
void ofApp::draw(){
ken.draw(0,0);
ken2.draw(ken.getWidth(), 0);
ofDrawBitmapStringHighlight("press any key to reset", ofPoint(20,20));
}
//--------------------------------------------------------------
void ofApp::keyPressed(int key){
dilate(ken, ken2);
ken2.update();
}
//--------------------------------------------------------------
void ofApp::keyReleased(int key){
}
//--------------------------------------------------------------
void ofApp::mouseMoved(int x, int y ){
}
//--------------------------------------------------------------
void ofApp::mouseDragged(int x, int y, int button){
}
//--------------------------------------------------------------
void ofApp::mousePressed(int x, int y, int button){
}
//--------------------------------------------------------------
void ofApp::mouseReleased(int x, int y, int button){
}
//--------------------------------------------------------------
void ofApp::mouseEntered(int x, int y){
}
//--------------------------------------------------------------
void ofApp::mouseExited(int x, int y){
}
//--------------------------------------------------------------
void ofApp::windowResized(int w, int h){
}
//--------------------------------------------------------------
void ofApp::gotMessage(ofMessage msg){
}
//--------------------------------------------------------------
void ofApp::dragEvent(ofDragInfo dragInfo){
}
|
154a9fedfffa9f7b94bc958c308c5e2d8b3ed049
|
45295c45b050bad239793da196a46b5b67a4f7eb
|
/control.h
|
34d19ed68d178bdde61106606210e6240b7604f4
|
[] |
no_license
|
MichaelBurge/turret-defense
|
edfc39d574e4e21d0add19201e917b221bdc962b
|
d32cd615188506a57a41c6f0d840bf79da6ac889
|
refs/heads/master
| 2023-03-17T08:31:24.317908
| 2021-03-11T08:27:15
| 2021-03-11T08:27:15
| 346,630,348
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 1,694
|
h
|
control.h
|
// control.h: interface for the control class.
//
//////////////////////////////////////////////////////////////////////
#if !defined(AFX_CONTROL_H__E6FA119D_60D0_40B1_B372_FF81B103B66B__INCLUDED_)
#define AFX_CONTROL_H__E6FA119D_60D0_40B1_B372_FF81B103B66B__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000
struct Message {
int message,parameter1,parameter2;
};
enum StandardId {
StandardId_NonStandard,
StandardId_Button,
StandardId_Checkbox,
StandardId_Radio,
StandardId_Text,
StandardId_Window,
StandardId_Edit,
StandardId_ProgressBar
};
const int CONTROL_SETPOS =-1;
const int CONTROL_SETSIZE =-2;
const int CONTROL_ACTIVATE =-3;
const int CONTROL_EXTRAINFO =-4;
#include <deque>
using std::deque;
class control {
protected:
int x,y;
int width,height;
deque<Message> messages;
deque<control*> children;
control *parent;
bool active;
void virtual Process()=0;
public:
//void virtual Save(void);
//void virtual Load(void);
StandardId virtual IsStandard(void)=0;
void GiveMessage(int message,int parameter1,int parameter2);
int xpos(void) {return x+(parent?parent->xpos():0);}
int ypos(void) {return y+(parent?parent->ypos():0);}
void SetParent(control *target) {parent=target;}
int AddChild(control *target);
void SetChild(int child, control *target);
void RemoveChild(int child);
int GetWidth() {return width;}
int GetHeight(){return height;}
virtual ProcessAll(void) {
Process();
if (active)
for (int temp=0;temp<children.size();temp++)
children[temp]->ProcessAll();
}
};
#endif // !defined(AFX_CONTROL_H__E6FA119D_60D0_40B1_B372_FF81B103B66B__INCLUDED_)
|
c0b924dae6a8cf68d40ec837fa288d54b868edc5
|
3257329ee69286db567d00631469a3b9ccf44ab5
|
/aspen/aspen/walkers/MultiplicityTracker.h
|
cf455460d6ac668f35f7026e7321b56649f8839b
|
[
"BSD-2-Clause"
] |
permissive
|
ORNL/siena-mem
|
b9c6e2fbfa92ca177ff796ee58e73e2321744838
|
4fee8c4cf20dcbf42d5fe786ea6cc52f09b82de1
|
refs/heads/master
| 2020-05-16T05:15:27.569621
| 2019-04-22T15:07:45
| 2019-04-22T15:07:45
| 182,810,278
| 5
| 2
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 2,255
|
h
|
MultiplicityTracker.h
|
#ifndef MULTIPLICITY_TRACKER_H
#define MULTIPLICITY_TRACKER_H
#include "AspenTool.h"
// multiplicity is how many times a kernel is going to be called
// note: in Explicit mode, it never moves beyond 1, because each
// iterate/map call s done explicitly.
// in Implicit mode, it gets multiplied by iterate/map counts.
class MultiplicityTracker : public AspenTool
{
public:
bool debug;
vector<int> stack;
public:
MultiplicityTracker(ASTAppModel *app) : AspenTool(app)
{
debug = false;
stack.push_back(1);
}
int GetMultiplicity()
{
return stack.back();
}
protected:
virtual TraversalMode TraversalModeHint(const ASTControlStatement *here)
{
//return Explicit;
return Implicit;
}
virtual void StartKernel(TraversalMode mode, const ASTKernel *k)
{
if (debug) cerr << Indent(level) << "Starting kernel '"<<k->GetName()<<"' (mult="<<GetMultiplicity()<<")\n";
}
virtual void StartIterate(TraversalMode mode, const ASTControlIterateStatement *s)
{
if (debug) cerr << Indent(level) << "Starting iterate "<<s->GetLabel()<<"\n";
if (mode == AspenTool::Explicit)
return;
int c = s->GetQuantity()->Expanded(app->paramMap)->Evaluate();
int p = stack.back();
stack.push_back(c*p);
}
virtual void EndIterate(TraversalMode mode, const ASTControlIterateStatement *s)
{
if (debug) cerr << Indent(level) << "Ending iterate "<<s->GetLabel()<<"\n";
if (mode == AspenTool::Explicit)
return;
stack.pop_back();
}
virtual void StartMap(TraversalMode mode, const ASTControlMapStatement *s)
{
if (debug) cerr << Indent(level) << "Starting map "<<s->GetLabel()<<"\n";
if (mode == AspenTool::Explicit)
return;
int c = s->GetQuantity()->Expanded(app->paramMap)->Evaluate();
int p = stack.back();
stack.push_back(c*p);
}
virtual void EndMap(TraversalMode mode, const ASTControlMapStatement *s)
{
if (debug) cerr << Indent(level) << "Ending map "<<s->GetLabel()<<"\n";
if (mode == AspenTool::Explicit)
return;
stack.pop_back();
}
};
#endif
|
639aecd97a9e7a2cbc23a659a47b06943eddf004
|
a0b23b2f982179723a2eee098aa88d02f300e579
|
/MayLO 2/Hack WF/cDraw.h
|
f0f8627b35a42ad7c268b17f5c932f1426501184
|
[] |
no_license
|
WildeSE/D3D-Menu
|
12f703007b4f8b7f7d27c1c8dcc66a3509b29557
|
d33ab94b71a2ccebb486e52ec55b8045064b775d
|
refs/heads/master
| 2021-01-19T13:03:27.360902
| 2015-09-21T08:27:03
| 2015-09-21T08:27:03
| 42,853,419
| 7
| 2
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 2,204
|
h
|
cDraw.h
|
#pragma once
#include <d3d9.h>
#include <d3dx9.h>
#include <time.h>
#include <stdio.h>
#include <stdlib.h>
#include "cVar.h"
#define C_Text (DT_CENTER|DT_NOCLIP)
#define L_Text (DT_LEFT|DT_NOCLIP)
#define R_Text (DT_RIGHT|DT_NOCLIP)
static struct _Keys
{
bool bPressed;
DWORD dwStartTime;
}
kPressingKey[256];
class cDraw
{
public:
cDraw(void);
bool Show;
ID3DXFont* pFont;
ID3DXFont* pFonts;
LPD3DXLINE pLine;
void Engine_Button(int x, int y, int &Var, LPSTR text, IDirect3DDevice9* pDevice);
void Studio_Menu(int x, int y, LPSTR text, LPDIRECT3DDEVICE9 pDevice);
void __fastcall String(int x, int y, DWORD Color, DWORD Style, const char *Format, ...);
void __fastcall Line(float x, float y, float x2, float y2, float width, DWORD color);
void Draw_Box(int x, int y, int w, int h, D3DCOLOR color, LPDIRECT3DDEVICE9 mDevice);
void Draw_Border(int x, int y, int w, int h, int s, D3DCOLOR Color, IDirect3DDevice9* mDevice);
void __fastcall Box(int x, int y, int w, int h, D3DCOLOR Color, LPDIRECT3DDEVICE9 pDevice);
void __fastcall Border(int x, int y, int w, int h, int s, DWORD color, LPDIRECT3DDEVICE9 pDevice);
void InitFontA(CHAR* szFontFamily, int W, DWORD Stile, IDirect3DDevice9* mDevice);
void InitFont(CHAR* szFontFamily, int W, DWORD Stile, IDirect3DDevice9* mDevice);
void DrawBox(int x, int y, int w, int h, D3DCOLOR Color, IDirect3DDevice9* mDevice);
void DrawBorder(int x, int y, int w, int h, D3DCOLOR Color, IDirect3DDevice9* mDevice);
BOOL IsInBox(int x, int y, int w, int h);
void Draw_Text(int x, int y, DWORD Color, const char *Format, DWORD Style);
BOOL State_Key(int Key, DWORD dwTimeOut);
void _stdcall SHOW_MENU(LPDIRECT3DDEVICE9 pDevice);
void KeyMenu(DWORD KEY, LPDIRECT3DDEVICE9 pDevice);
void Engine_CheckBox(int x, int y, int &Var, LPSTR text, IDirect3DDevice9* pDevice);
void M1Chams(int x, int y, char *Text, int &Var, DWORD CoLoR1, DWORD CoLoR2, DWORD CoLoR3, DWORD CoLoR4, DWORD CoLoR5, DWORD CoLoR6, DWORD CoLoR7, DWORD CoLoR8, DWORD CoLoR9, DWORD CoLoR10, LPDIRECT3DDEVICE9 pDevice);
void cDraw::Engine_Scroll(int x, int y, int &studio, char **typ, int max, LPSTR text, IDirect3DDevice9* pDevice);
private:
};
|
5fcfd9486a9cba0bc058979d9298c7187b1b4f22
|
0453ffb96e2c233fb04bb78e59ee70d1e66c22a3
|
/tree/maximum-binary-tree.cpp
|
d0690943400d7b22dd9e3b7380ed1684b40ce333
|
[] |
no_license
|
rakshith53/LeetCode-Solution
|
4f8f08283610c54bf61135d16befad1c264eb054
|
bba00e9314b4ad36f1831387a9f9fab802562b8b
|
refs/heads/main
| 2023-02-15T14:13:04.870369
| 2021-01-13T08:15:38
| 2021-01-13T08:15:38
| 325,224,507
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 652
|
cpp
|
maximum-binary-tree.cpp
|
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode(int x) : val(x), left(NULL), right(NULL) {}
* };
*/
class Solution {
public:
TreeNode* help(int l,int r,vector<int>& a){
if(l==r) return NULL;
int mid = max_element(a.begin()+l,a.begin()+r)-a.begin(),val = a[mid];
TreeNode* tmp = new TreeNode(val);
tmp->left = help(l,mid,a);
tmp->right = help(mid+1,r,a);
return tmp;
}
TreeNode* constructMaximumBinaryTree(vector<int>& a) {
int l = 0,r = a.size();
return (help(l,r,a));
}
};
|
0abc80ee44f923abdd30e3975ee2cc2cf0c2559e
|
370fc92f69a442f3be5fd6d79d11ce65dae64b68
|
/examples/MovingAverage/client/cpp/BasicStatic/MovingAverageClient.cpp
|
2898bb6f8a5fa783cc511d28ec1c26c47fd574f2
|
[
"BSD-2-Clause"
] |
permissive
|
YogeshMahera-SerpentCS/maxskins
|
82d35926fce4cb531d0ddb49b9eaeb06bab57903
|
dc85b6c600cb29ef2d2a5d12ec4ae9c84d33d180
|
refs/heads/master
| 2020-03-27T12:37:53.323512
| 2016-06-02T16:48:36
| 2016-06-02T16:48:36
| null | 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 5,987
|
cpp
|
MovingAverageClient.cpp
|
/* Copyright 2015 Maxeler Technologies */
#include <thrift/protocol/TBinaryProtocol.h>
#include <thrift/transport/TSocket.h>
#include <thrift/transport/TTransportUtils.h>
#include <stdlib.h>
#include <sys/time.h>
#include <vector>
#include "../gen-cpp/MovingAverageService.h"
using std::cout;
using std::endl;
using apache::thrift::TException;
using apache::thrift::protocol::TBinaryProtocol;
using apache::thrift::protocol::TProtocol;
using apache::thrift::transport::TBufferedTransport;
using apache::thrift::transport::TSocket;
using apache::thrift::transport::TTransport;
using ::com::maxeler::MovingAverage::MovingAverageServiceClient;
using ::com::maxeler::MovingAverage::remote_ptr;
double calcTime(struct timeval startTime) {
struct timeval endTime;
gettimeofday(&endTime, NULL);
double seconds = endTime.tv_sec - startTime.tv_sec;
double useconds = endTime.tv_usec - startTime.tv_usec;
return (((seconds) * 1000 + useconds/1000.0) + 0.5) / 1000;
}
/**
* Generates random data.
*
* @param size Size
*
* @return Random data
*/
std::vector<double> randomData(int size) {
std::vector<double> dataIn;
for (int i = 0; i < size; i++) {
dataIn.push_back(random() % 100);
}
return dataIn;
}
/**
* Checks if MovingAverageDFE and MovingAverageCPU return the same value.
*
* @param dataOutDfe Data output from DFE
* @param dataOutCpu Data output from CPU
* @param size Size
*/
void check(std::vector<double> dataOutCPU,
std::vector<double> dataOutDFE, int size) {
for (int i = 1; i < size - 1; i++) {
if (dataOutDFE[i] != dataOutCPU[i]) {
cout << "Output data @ " << i << " = " << dataOutDFE[i];
cout << " (expected " << dataOutCPU[i] << ")" << endl;
cout << "Test failed!" << endl;
exit(-1);
}
}
cout << "Test successful!" << endl;
}
/**
* MovingAverage on CPU.
*
* @param size Size
* @param dataIn Data input
*
* @return Data output
*/
std::vector<double> MovingAverageCPU(std::vector<double> dataIn, int size) {
std::vector<double> dataOut(size);
for (int i = 1; i < size - 1; i++) {
float x = dataIn[i - 1];
float y = dataIn[i];
float z = dataIn[i + 1];
float tmp = (x + y + z) / 3;
dataOut[i] = tmp;
}
return dataOut;
}
/**
* MovingAverage on DFE.
*
* @param size Size
* @param dataIn Data input
*
* @return Data output
*/
std::vector<double> MovingAverageDFE(std::vector<double> dataIn, int size) {
struct timeval startTime;
gettimeofday(&startTime, NULL);
// Make socket
boost::shared_ptr<TTransport> socket(new TSocket("localhost", 9090));
// Buffering is critical. Raw sockets are very slow
boost::shared_ptr<TTransport> transport(new TBufferedTransport(socket));
// Wrap in a protocol
boost::shared_ptr<TProtocol> protocol(new TBinaryProtocol(transport));
// Create a client to use the protocol encoder
MovingAverageServiceClient client(protocol);
double currentTime = calcTime(startTime);
cout << "Creating a client:\t\t\t\t" << currentTime << "s" << endl;
std::vector<double> dataOut(size);
try {
// Connect!
gettimeofday(&startTime, NULL);
transport->open();
currentTime = calcTime(startTime);
cout << "Opening connection:\t\t\t\t" << currentTime << "s" << endl;
// Allocate and send input streams to server
gettimeofday(&startTime, NULL);
remote_ptr address_dataIn = client.malloc_float(size);
client.send_data_float(address_dataIn, dataIn);
currentTime = calcTime(startTime);
cout << "Sending input data:\t\t\t\t" << currentTime << "s" << endl;
// Allocate memory for output stream on server
gettimeofday(&startTime, NULL);
remote_ptr address_dataOut = client.malloc_float(size);
currentTime = calcTime(startTime);
cout << "Allocating memory for output stream on server:\t";
cout << currentTime << "s" << endl;
// Action default
gettimeofday(&startTime, NULL);
client.MovingAverage(size, address_dataIn, address_dataOut);
currentTime = calcTime(startTime);
cout << "Moving average time:\t\t\t\t" << currentTime << "s" << endl;
// Get output stream from server
gettimeofday(&startTime, NULL);
client.receive_data_float(dataOut, address_dataOut, size);
currentTime = calcTime(startTime);
cout << "Getting output stream:\t(size = " << size * 32 << " bit)\t";
cout << currentTime << "s" << endl;
// Free allocated memory for streams on server
gettimeofday(&startTime, NULL);
client.free(address_dataIn);
client.free(address_dataOut);
currentTime = calcTime(startTime);
cout << "Freeing allocated memory for streams on server:\t";
cout << currentTime << "s" << endl;
// Close!
gettimeofday(&startTime, NULL);
transport->close();
currentTime = calcTime(startTime);
cout << "Closing connection:\t\t\t\t" << currentTime << "s" << endl;
} catch (TException& tx) {
cout << "ERROR: " << tx.what() << endl;
exit(-1);
}
return dataOut;
}
/**
* Calculates MovingAverageDFE and MovingAverageCPU and
* checks if they return the same value.
*/
int main() {
struct timeval startTime;
// Generate input data
gettimeofday(&startTime, NULL);
const int size = 384;
std::vector<double> dataIn = randomData(size);
double currentTime = calcTime(startTime);
cout << "Generating input data:\t\t\t\t" << currentTime << "s" << endl;
// DFE Output
gettimeofday(&startTime, NULL);
std::vector<double> dataOutDFE = MovingAverageDFE(dataIn, size);
currentTime = calcTime(startTime);
cout << "DFE moving average total time:\t\t\t" << currentTime << "s" << endl;
// CPU Output
gettimeofday(&startTime, NULL);
std::vector<double> dataOutCPU = MovingAverageCPU(dataIn, size);
currentTime = calcTime(startTime);
cout << "CPU moving average total time:\t\t\t" << currentTime << "s" << endl;
// Checking results
check(dataOutCPU, dataOutDFE, size);
return 0;
}
|
4d021525021738e50fe8dcfc016f1625711599cd
|
bc3af944af7948c882ad1f09582ba3431700835f
|
/shared/CelebrationOverlay.cpp
|
c64c3482f0ec4f46e99ceb31a21107817a80e5a1
|
[] |
no_license
|
wearecollins/Gel2015
|
16f455c482374bf97eaad714021666f11a9ce26f
|
dce715ebf0b2342bb24e65ee5d66e3a1ba0d1d29
|
refs/heads/master
| 2020-04-10T12:23:46.092948
| 2015-04-17T15:41:34
| 2015-04-17T15:41:34
| 32,529,994
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 126
|
cpp
|
CelebrationOverlay.cpp
|
//
// CelebrationOverlay.cpp
// GelOutput
//
// Created by Brett Renfer on 3/26/15.
//
//
#include "CelebrationOverlay.h"
|
93f439d63b2caf8ee7de7cda0c948dc37374fc4e
|
e285c54c7f334dd98ee9beef53750499683299e6
|
/matrixu/matrixu_test.cpp
|
00c2f5b14bf648b2cd09ba1a1b9c7b7c7335c6da
|
[] |
no_license
|
ladaisakova/isakova_l_m
|
1db42b11c7c110b4b158c059c1129e7b46382ac7
|
13e2832ef6b3c7e8fa9dac2f76fae56d2063554f
|
refs/heads/master
| 2021-09-11T14:14:45.577933
| 2018-04-08T17:50:18
| 2018-04-08T17:50:18
| 104,116,600
| 0
| 2
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 1,169
|
cpp
|
matrixu_test.cpp
|
#include "matrixu.h"
int main()
{
using namespace std;
Matrixu m(3, 2);
m.at(0, 0) = 0; m.at(0, 1) = 1;
m.at(1, 0) = 4; m.at(1, 1) = 5;
m.at(2, 0) = 8; m.at(2, 1) = 9;
cout << "m = " << "\n" << m << endl;
Matrixu k(3, 2);
k.at(0, 0) = 1; k.at(0, 1) = 3;
k.at(1, 0) = 1; k.at(1, 1) = 1;
k.at(2, 0) = 8; k.at(2, 1) = 5;
cout << "k = " << "\n" << k << endl;
m += k;
cout << " m + k = " << "\n" << m << endl;
Matrixu l(2, 3);
l.at(0, 0) = 1; l.at(0, 1) = 3; l.at(0, 2) = 0;
l.at(1, 0) = 2; l.at(1, 1) = 7; l.at(1, 2) = 3;
cout << " l = " << "\n" << l << endl;
Matrixu res(m * l);
cout << " m * res = " << "\n" << res << endl;
res *= 3;
cout << " res * 3 = " << "\n" << res << endl;
res /= 2;
cout << " res / 2 = " << "\n" << res << endl;
}
std::ostream& Matrixu::writeTo(std::ostream& ostrm) const
{
int t;
for (int i = 0; i < nRow_; i += 1)
{
t = i;
for (int j = t * nCol_; j < nCol_ + t * nCol_; j += 1)
{
ostrm << pdata_[j] << " ";
}
ostrm << "\n";
}
return ostrm;
}
|
34ca261be947aa3b14354b7999d24fbe6e31c651
|
f00d7bce1ca4b7db0fe00e6d2e2256610cc4bc3f
|
/Quine McCluskey/parser.h
|
ebee62224cb5272e4bec9348a9e5edd8122842ba
|
[] |
no_license
|
ChienLing/CAD
|
fd0e3c38b7bf6687deecca801aced42c09d483ae
|
0cd1c27dfc864ce0e90c0a5b5c5a4a7111833fa1
|
refs/heads/master
| 2023-03-21T21:40:10.741966
| 2021-03-07T13:03:19
| 2021-03-07T13:03:19
| 344,043,175
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 5,984
|
h
|
parser.h
|
#ifndef _PARSER_H_
#define _PARSER_H_
#include <bits/stdc++.h>
#include "TableElement.h"
#include "littleP.h"
using namespace std;
class Parser {
public:
std::vector<TableElement> onSet, dcSet;
std::string InFileName;
std::string OutFileName;
std::ifstream input;
std::ofstream output;
int var;
Parser() {}
Parser(std::string s);
void readInputFile();
void readInputFile(const std::string fileName);
int printImplicant(const tuple<int,int,int> &idx, std::map<int, std::map<int, std::vector<TableElement>>> &Table);
void writeOutputFile(const std::string fileName, const std::vector<tuple<int,int,int>> &ID, std::map<int, std::map<int, std::vector<TableElement>>> &Table, const std::vector<std::vector<littleP>>& funcP);
};
/////////////////////////////Constructor//////////////////////////////
Parser::Parser(std::string s):InFileName(s) {
}
//////////////////////////////Read File///////////////////////////////
void Parser::readInputFile(const std::string fileName) {
int dcterm, minterm;
std::string trash, S;
// std::cout<<"file name: "<<fileName<<"\n";
InFileName = fileName;
input.open(InFileName);
if(!input) { //test if file opened
std::cerr << "Can't open "<<fileName<<"!\n";
exit(1); //if unusual, close it
}
getline(input,S);
{
std::stringstream SS(S);
SS>>trash>>var;
}
// std::cout<<"var: "<<var<<"\n";
getline(input,S);
getline(input,S);
{
std::stringstream SS(S);
while (SS>>minterm){
TableElement TE;
TE.value.insert(minterm);
onSet.push_back(TE);
}
}
// std::cout<<"On Set:\n";
// for (int i=0; i<onSet.size(); i++) {
// std::cout<<*onSet[i].value.begin()<<" ";
// }
getline(input,S);
getline(input,S);
std::stringstream SS(S);
while (SS>>dcterm) {
TableElement TE;
TE.value.insert(dcterm);
dcSet.push_back(TE);
}
// std::cout<<"\ndc set\n";
// for (int i=0; i<dcSet.size(); i++) {
// std::cout<<*dcSet[i].value.begin()<<" ";
// }
// std::cout<<"\n";
return;
}
void Parser::readInputFile() {
int dcterm, minterm;
std::string trash, S;
// std::cout<<"file name: "<<InFileName<<"/"<<"\n";
input.open(InFileName);
if(!input) { //test if file opened
std::cerr << "Can't open "<<InFileName<<"!\n";
exit(1); //if unusual, close it
}
getline(input,S);
{
std::stringstream SS(S);
SS>>trash>>var;
}
// std::cout<<"var: "<<var<<"\n";
getline(input,S);
getline(input,S);
{
std::stringstream SS(S);
while (SS>>minterm){
std::cout<<minterm<<"\n";
TableElement TE;
TE.value.insert(minterm);
onSet.push_back(TE);
}
}
// std::cout<<"On Set:\n";
// for (int i=0; i<onSet.size(); i++) {
// std::cout<<*onSet[i].value.begin()<<" ";
// }
getline(input,S);
getline(input,S);
std::stringstream SS(S);
while (SS>>dcterm) {
TableElement TE;
TE.value.insert(dcterm);
dcSet.push_back(TE);
}
// std::cout<<"\ndc set\n";
// for (int i=0; i<dcSet.size(); i++) {
//std::cout<<*dcSet[i].value.begin()<<" ";
// }
// std::cout<<"\n";
return;
}
///////////////////////////////Output File/////////////////////////////
void Parser::writeOutputFile(const std::string fileName, const std::vector<tuple<int,int,int>> &ID,
std::map<int, std::map<int, std::vector<TableElement>>> &Table, const std::vector<std::vector<littleP>>& funcP) {
OutFileName = fileName;
output.open(OutFileName);
std::set<int>::iterator it;
output<<".pi "<<ID.size()<<"\n";
// std::cout<<".pi "<<ID.size()<<"\n";
if (ID.size() > 20) {
for (int i=ID.size()-1; i>=ID.size()-20; i--)
printImplicant(ID[i],Table);
}
else
{
for (int i=0; i<ID.size(); i++)
printImplicant(ID[i],Table);
}
int MinImpli(INT32_MAX);
int MinInpliItem(0);
for (int i=0; i<funcP[0].size(); i++) {
if (funcP[0][i].bit1Num < MinImpli) {
MinImpli = funcP[0][i].bit1Num;
MinInpliItem = i;
}
}
output<<"mc. "<<MinImpli<<"\n";///////////////////////////////////////////
// std::cout<<"mc. "<<MinImpli<<"\n";
int count(0);
for (int i=0; i<funcP[0][MinInpliItem].implicant.size(); i++) {
if (funcP[0][MinInpliItem].implicant[i]) {
count += printImplicant(ID[i],Table);
}
}
output<<"cost="<<count<<"\n";
// cout<<"cost="<<count<<"\n";
output.close();
}
int Parser::printImplicant(const tuple<int,int,int>& idx, std::map<int,std::map<int, std::vector<TableElement>>>& Table) {
std::set<int>::iterator it;
int count(0);
// if (Table[get<0>(idx)][get<1>(idx)][get<2>(idx)].hyphenPos.size() != 0)
it = Table[get<0>(idx)][get<1>(idx)][get<2>(idx)].hyphenPos.begin();
int CurValue = *Table[get<0>(idx)][get<1>(idx)][get<2>(idx)].value.begin();
vector<int> vec(var);
for (int i=0; i<var; i++) {
if (it!=Table[get<0>(idx)][get<1>(idx)][get<2>(idx)].hyphenPos.end() && *it == i) {
vec[i] = 2;
CurValue = CurValue>>1;
it++;
}
else {
count++;
if (CurValue&1)
vec[i] = 1;
else
vec[i] = 0;
CurValue = CurValue>>1;
}
}
for (int i=var-1; i>=0; i--) {
if (vec[i] == 0) {
output<<"0";
// std::cout<<"0";
}
else if (vec[i] == 1) {
output<<"1";
// std::cout<<"1";
}
else {
output<<"-";
// std::cout<<"-";
}
}
// std::cout<<"\n";
output<<"\n";
return count;
}
#endif
|
bec3cb5207af4156b0f9335114899cf456d41701
|
9dab836feab74b135be8208e3e727c6435dd5bec
|
/gmsv_extra/Source SDK/server/baseentity.h
|
cccc60c26e10550c5648a7b315fda23d471c597b
|
[
"Apache-2.0"
] |
permissive
|
11Lee1/gmsv_extra
|
56fe3db4e11f648ef640343470d0f631c90168c7
|
294dbc1e31eca6f086605767e0495cf64348bd85
|
refs/heads/master
| 2020-04-29T20:19:26.189875
| 2019-05-08T01:20:18
| 2019-05-08T01:20:18
| 176,380,702
| 11
| 3
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 33,341
|
h
|
baseentity.h
|
#ifndef BASEENTITY_H
#define BASEENTITY_H
#ifdef _WIN32
#pragma once
#endif
#define TEAMNUM_NUM_BITS 6
#include "../string_t.h"
#include "../iserverentity.h"
#include "ServerNetworkProperty.h"
#include "../shareddefs.h"
#include "../predictableid.h"
#include "variant_t.h"
#include "../tier1/utllinkedlist.h"
#include "../collisionproperty.h"
#include "../entityoutput.h"
#include "../takedamageinfo.h"
#include "../../Garry's Mod/GLUA/LuaObject/CLuaGameObject.h"
#include "../baseentity_shared.h"
#include "../entitylist_base.h"
#include "../worldsize.h"
#define DECLARE_PREDICTABLE() \
public: \
static typedescription_t m_PredDesc[]; \
static datamap_t m_PredMap; \
virtual datamap_t *GetPredDescMap( void ); \
template <typename T> friend datamap_t *PredMapInit(T *)
class CDamageModifier;
//-----------------------------------------------------------------------------
// Entity events... targetted to a particular entity
// Each event has a well defined structure to use for parameters
//-----------------------------------------------------------------------------
enum EntityEvent_t
{
ENTITY_EVENT_WATER_TOUCH = 0, // No data needed
ENTITY_EVENT_WATER_UNTOUCH, // No data needed
ENTITY_EVENT_PARENT_CHANGED, // No data needed
};
//-----------------------------------------------------------------------------
typedef void (CBaseEntity::*BASEPTR)(void);
typedef void (CBaseEntity::*ENTITYFUNCPTR)(CBaseEntity *pOther);
typedef void (CBaseEntity::*USEPTR)(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value);
#define DEFINE_THINKFUNC( function ) DEFINE_FUNCTION_RAW( function, BASEPTR )
#define DEFINE_ENTITYFUNC( function ) DEFINE_FUNCTION_RAW( function, ENTITYFUNCPTR )
#define DEFINE_USEFUNC( function ) DEFINE_FUNCTION_RAW( function, USEPTR )
// For CLASSIFY
enum Class_T
{
CLASS_NONE = 0,
CLASS_PLAYER,
CLASS_PLAYER_ALLY,
CLASS_PLAYER_ALLY_VITAL,
CLASS_ANTLION,
CLASS_BARNACLE,
CLASS_BULLSEYE,
//CLASS_BULLSQUID,
CLASS_CITIZEN_PASSIVE,
CLASS_CITIZEN_REBEL,
CLASS_COMBINE,
CLASS_COMBINE_GUNSHIP,
CLASS_CONSCRIPT,
CLASS_HEADCRAB,
//CLASS_HOUNDEYE,
CLASS_MANHACK,
CLASS_METROPOLICE,
CLASS_MILITARY,
CLASS_SCANNER,
CLASS_STALKER,
CLASS_VORTIGAUNT,
CLASS_ZOMBIE,
CLASS_PROTOSNIPER,
CLASS_MISSILE,
CLASS_FLARE,
CLASS_EARTH_FAUNA,
CLASS_HACKED_ROLLERMINE,
CLASS_COMBINE_HUNTER,
NUM_AI_CLASSES
};
struct thinkfunc_t
{
BASEPTR m_pfnThink;
string_t m_iszContext;
int m_nNextThinkTick;
int m_nLastThinkTick;
DECLARE_SIMPLE_DATADESC();
};
//
// Structure passed to input handlers.
//
struct inputdata_t
{
CBaseEntity *pActivator; // The entity that initially caused this chain of output events.
CBaseEntity *pCaller; // The entity that fired this particular output.
variant_t value; // The data parameter for this output.
int nOutputID; // The unique ID of the output that was fired.
};
// Serializable list of context as set by entity i/o and used for deducing proper
// speech state, et al.
struct ResponseContext_t
{
DECLARE_SIMPLE_DATADESC();
string_t m_iszName;
string_t m_iszValue;
float m_fExpirationTime; // when to expire context (0 == never)
};
struct TimedOverlay_t
{
char *msg;
int msgEndTime;
int msgStartTime;
TimedOverlay_t *pNextTimedOverlay;
};
class CBasePlayer;
class CStudioHdr;
class CEntityMapData;
class IEntitySaveUtils;
class CBaseAnimating;
class CBaseAnimatingOverlay;
class IResponseSystem;
class CDmgAccumulator;
class CBaseCombatCharacter;
class INextBot;
class CBaseCombatWeapon;
class IServerVehicle;
class AI_CriteriaSet;
class CAI_BaseNPC;
class gamevcollisionevent_t;
class ILuaObject;
class CTeam;
struct notify_system_event_params_t;
enum notify_system_event_t;
class CBaseEntity;
inline CBaseEntity *GetContainingEntity(edict_t *pent)
{
if (pent && pent->GetUnknown())
{
return (CBaseEntity*)pent->GetUnknown();
}
return NULL;
}
class CBaseEntity : public IServerEntity
{
public:
DECLARE_CLASS_NOBASE(CBaseEntity);
virtual ~CBaseEntity();
// network data
DECLARE_SERVERCLASS();
// data description
DECLARE_DATADESC();
/*
GetDataDescMap() // index 11
*/
/*12*/virtual void SetModelIndexOverride(int index, int nValue);
/*13*/virtual bool TestCollision(const Ray_t& ray, unsigned int mask, trace_t& trace);
/*14*/virtual bool TestHitboxes(const Ray_t &ray, unsigned int fContentsMask, trace_t& tr);
/*15*/virtual void ComputeWorldSpaceSurroundingBox(Vector *pWorldMins, Vector *pWorldMaxs);
/*16*/virtual bool ShouldCollide(int collisionGroup, int contentsMask) const;
/*17*/virtual void SetOwnerEntity(CBaseEntity* pOwner);
/*18*/virtual int ShouldTransmit(const CCheckTransmitInfo *pInfo);
/*19*/virtual int UpdateTransmitState();
/*20*/virtual void SetTransmit(CCheckTransmitInfo *pInfo, bool bAlways);
/*21*/virtual const char* GetTracerType(void);
// initialization
/*22*/virtual void Spawn(void);
/*23*/virtual void Precache(void) {}
/*24*/virtual void SetModel(const char *szModelName);
/*25*/virtual CStudioHdr * OnNewModel();
/*26*/virtual void PostConstructor(const char *szClassname);
/*27*/virtual void PostClientActive(void);
/*28*/virtual void ParseMapData(CEntityMapData *mapData);
/*29*/virtual bool KeyValue(const char *szKeyName, const char *szValue);
/*30*/virtual bool KeyValue(const char *szKeyName, float flValue);
/*31*/virtual bool KeyValue(const char *szKeyName, const Vector &vecValue);
/*32*/virtual bool GetKeyValue(const char *szKeyName, char *szValue, int iMaxLen);
// Activate - called for each entity after each load game and level load
/*33*/virtual void Activate(void);
/*34*/virtual void SetParent(CBaseEntity* pNewParent, int iAttachment = -1);
/*35*/virtual int ObjectCaps(void);
/*36*/virtual bool AcceptInput(const char *szInputName, CBaseEntity *pActivator, CBaseEntity *pCaller, variant_t Value, int outputID);
/*37*/virtual void GetInputDispatchEffectPosition(const char *sInputString, Vector &pOrigin, QAngle &pAngles);
/*38*/virtual void DrawDebugGeometryOverlays(void);
/*39*/virtual int DrawDebugTextOverlays(void);
// save/restore
// only overload these if you have special data to serialize
/*40*/virtual int Save(ISave &save);
/*41*/virtual int Restore(IRestore &restore);
/*42*/virtual bool ShouldSavePhysics();
// handler to reset stuff before you are restored
// NOTE: Always chain to base class when implementing this!
/*43*/virtual void OnSave(IEntitySaveUtils *pSaveUtils);
// handler to reset stuff after you are restored
// called after all entities have been loaded from all affected levels
// called before activate
// NOTE: Always chain to base class when implementing this!
/*44*/virtual void OnRestore();
/*45*/virtual int RequiredEdictIndex(void) { return -1; }
/*46*/virtual void MoveDone(void);
/*47*/virtual void Think(void);
/*48*/virtual void NetworkStateChanged_m_nNextThinkTick();
/*49*/virtual void NetworkStateChanged_m_nNextThinkTick(void*);
/*50*/virtual CBaseAnimating* GetBaseAnimating() { return 0; }
/*51*/virtual CBaseAnimatingOverlay* GetBaseAnimatingOverlay() { return 0; }
/*52*/virtual IResponseSystem *GetResponseSystem();
/*53*/virtual void DispatchResponse(const char *conceptName);
// Classify - returns the type of group (i.e, "houndeye", or "human military" so that NPCs with different classnames
// still realize that they are teammates. (overridden for NPCs that form groups)
/*54*/virtual Class_T Classify(void);
/*55*/virtual void DeathNotice(CBaseEntity *pVictim) {}// NPC maker children use this to tell the NPC maker that they have died.
/*56*/virtual bool ShouldAttractAutoAim(CBaseEntity *pAimingEnt) { }
/*57*/virtual float GetAutoAimRadius();
/*58*/virtual Vector GetAutoAimCenter() { }
/*59*/virtual ITraceFilter* GetBeamTraceFilter(void);
/*60*/virtual bool PassesDamageFilter(const CTakeDamageInfo &info);
/*61*/virtual void TraceAttack(const CTakeDamageInfo &info, const Vector &vecDir, trace_t *ptr, CDmgAccumulator *pAccumulator = NULL);
/*62*/virtual bool CanBeHitByMeleeAttack(CBaseEntity *pAttacker) { return true; }
/*63*/virtual int OnTakeDamage(const CTakeDamageInfo &info);
/*64*/virtual void AdjustDamageDirection(const CTakeDamageInfo &info, Vector &dir, CBaseEntity *pEnt) {}
/*65*/virtual int TakeHealth(float flHealth, int bitsDamageType);
/*66*/virtual bool IsAlive(void);
// Entity killed (only fired once)
/*67*/virtual void Event_Killed(const CTakeDamageInfo &info);
/*68*/virtual void Event_KilledOther(CBaseEntity *pVictim, const CTakeDamageInfo &info) { return; }
/*69*/virtual int BloodColor(void);
/*70*/virtual bool IsTriggered(CBaseEntity *pActivator) { return true; }
/*71*/virtual bool IsNPC(void) const { return false; }
/*72*/virtual CBaseCombatCharacter *MyCombatCharacterPointer(void) { return NULL; }
/*73*/virtual INextBot * MyNextBotPointer(void) { return NULL; }
/*74*/virtual float GetDelay(void) { return 0; }
/*75*/virtual bool IsMoving(void);
/*76*/virtual char const* DamageDecal(int bitsDamageType, int gameMaterial);
/*77*/virtual void DecalTrace(trace_t *pTrace, char const *decalName);
/*78*/virtual void ImpactTrace(trace_t *pTrace, int iDamageType, const char *pCustomImpactName = NULL);
/*79*/virtual bool OnControls(CBaseEntity *pControls) { return false; }
/*80*/virtual bool HasTarget(string_t targetname);
/*81*/virtual bool IsPlayer(void) const { return false; }
/*82*/virtual bool IsNetClient(void) const { return false; }
/*83*/virtual bool IsTemplate(void) { return false; }
/*84*/virtual bool IsBaseObject(void) const { return false; }
/*85*/virtual bool IsBaseTrain(void) const { return false; }
/*86*/virtual bool IsCombatItem(void) const { return false; }
/*87*/virtual bool IsBaseCombatWeapon(void) const { return false; }
/*88*/virtual bool IsWearable(void) const { return false; }
/*89*/virtual CBaseCombatWeapon *MyCombatWeaponPointer(void) { return NULL; }
// If this is a vehicle, returns the vehicle interface
/*90*/virtual IServerVehicle* GetServerVehicle() { return NULL; }
// UNDONE: Make this data instead of procedural?
/*91*/virtual bool IsViewable(void); // is this something that would be looked at (model, sprite, etc.)?
/*92*/virtual void ChangeTeam(int iTeamNum); // Assign this entity to a team.
/*93*/virtual void OnEntityEvent(EntityEvent_t event, void *pEventData);
// UNDONE: Do these three functions actually need to be virtual???
/*94*/virtual bool CanStandOn(CBaseEntity *pSurface);
/*95*/virtual bool CanStandOn(edict_t *ent);
/*96*/virtual CBaseEntity *GetEnemy(void) { return NULL; }
/*97*/virtual CBaseEntity *GetEnemy(void) const { return NULL; }
/*98*/virtual void ViewPunch(const QAngle &angleOffset);
/*99*/virtual void Use(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value);
/*100*/virtual void StartTouch(CBaseEntity *pOther);
/*101*/virtual void Touch(CBaseEntity *pOther);
/*102*/virtual void EndTouch(CBaseEntity *pOther);
/*103*/virtual void StartBlocked(CBaseEntity *pOther) {}
/*104*/virtual void Blocked(CBaseEntity *pOther);
/*105*/virtual void EndBlocked(void) {}
// Physics simulation
/*106*/virtual void PhysicsSimulate(void);
/*107*/virtual void UpdateOnRemove(void);
/*108*/virtual void StopLoopingSounds(void) {}
/*109*/virtual bool SUB_AllowedToFade(void);
// change position, velocity, orientation instantly
// passing NULL means no change
/*110*/virtual void Teleport(const Vector *newPosition, const QAngle *newAngles, const Vector *newVelocity);
// notify that another entity (that you were watching) was teleported
/*111*/virtual void NotifySystemEvent(CBaseEntity *pNotify, notify_system_event_t eventType, const notify_system_event_params_t ¶ms);
/*112*/virtual void MakeTracer(const Vector &vecTracerSrc, const trace_t &tr, int iTracerType);
/*113*/virtual int GetTracerAttachment(void);
/*114*/virtual void FireBullets(const FireBulletsInfo_t &info);
/*115*/virtual void DoImpactEffect(trace_t &tr, int nDamageType); // give shooter a chance to do a custom impact.
/*116*/virtual void ModifyFireBulletsDamage(CTakeDamageInfo* dmgInfo) {}
/*117*/virtual CBaseEntity *Respawn(void) { return NULL; }
/*118*/virtual bool IsLockedByMaster(void) { return false; }
/*119*/virtual int GetMaxHealth() const { return m_iMaxHealth; }
/*120*/virtual void ModifyOrAppendCriteria(AI_CriteriaSet& set);
/*121*/virtual void NetworkStateChanged_m_iMaxHealth(void);
/*122*/virtual void NetworkStateChanged_m_iMaxHealth(void*);
/*123*/virtual void NetworkStateChanged_m_iHealth(void);
/*124*/virtual void NetworkStateChanged_m_iHealth(void*);
/*125*/virtual void NetworkStateChanged_m_lifeState(void);
/*126*/virtual void NetworkStateChanged_m_lifeState(void*);
/*127*/virtual void NetworkStateChanged_m_takedamage(void);
/*128*/virtual void NetworkStateChanged_m_takedamage(void*);
// Damage accessors
/*129*/virtual int GetDamageType() const;
/*130*/virtual float GetDamage() { return 0; }
/*131*/virtual void SetDamage(float flDamage) {}
/*132*/virtual Vector EyePosition(void); // position of eyes
/*133*/virtual const QAngle &EyeAngles(void); // Direction of eyes in world space
/*134*/virtual const QAngle &LocalEyeAngles(void); // Direction of eyes
/*135*/virtual Vector EarPosition(void); // position of ears
/*136*/virtual Vector BodyTarget(const Vector &posSrc, bool bNoisy = true); // position to shoot at
/*137*/virtual Vector HeadTarget(const Vector &posSrc);
/*138*/virtual void GetVectors(Vector* forward, Vector* right, Vector* up) const;
/*139*/virtual const Vector&GetViewOffset() const;
/*140*/virtual void SetViewOffset(const Vector &v);
/*141*/virtual Vector GetSmoothedVelocity(void);
// FIXME: Figure out what to do about this
/*142*/virtual void GetVelocity(Vector *vVelocity, AngularImpulse *vAngVelocity = NULL);
/*143*/virtual bool FVisible(CBaseEntity *pEntity, int traceMask = MASK_BLOCKLOS, CBaseEntity **ppBlocker = NULL);
/*144*/virtual bool FVisible(const Vector &vecTarget, int traceMask = MASK_BLOCKLOS, CBaseEntity **ppBlocker = NULL);
/*145*/virtual bool CanBeSeenBy(CAI_BaseNPC *pNPC) { return true; } // allows entities to be 'invisible' to NPC senses.
// This function returns a value that scales all damage done by this entity.
// Use CDamageModifier to hook in damage modifiers on a guy.
/*146*/virtual float GetAttackDamageScale(CBaseEntity *pVictim);
// This returns a value that scales all damage done to this entity
// Use CDamageModifier to hook in damage modifiers on a guy.
/*147*/virtual float GetReceivedDamageScale(CBaseEntity *pAttacker);
// Gets the velocity we impart to a player standing on us
/*148*/virtual void GetGroundVelocityToApply(Vector &vecGroundVel) { vecGroundVel = vec3_origin; }
/*149*/virtual bool PhysicsSplash(const Vector ¢erPoint, const Vector &normal, float rawSpeed, float scaledSpeed) { return false; }
/*150*/virtual void Splash() {}
/*151*/virtual const Vector&WorldSpaceCenter() const;
/*152*/virtual Vector GetSoundEmissionOrigin() const;
/*153*/virtual void ModifyEmitSoundParams(EmitSound_t ¶ms);
/*154*/virtual bool IsDeflectable() { return false; }
/*155*/virtual void Deflected(CBaseEntity *pDeflectedBy, Vector &vecDir) {}
/*156*/virtual bool CreateVPhysics();
/*157*/virtual bool ForceVPhysicsCollide(CBaseEntity *pEntity) { return false; }
/*158*/virtual void VPhysicsDestroyObject(void);
/*159*/virtual bool GMOD_VPhysicsTest(IPhysicsObject *pPhysics);
/*160*/virtual void VPhysicsUpdate(IPhysicsObject *pPhysics);
/*161*/virtual int VPhysicsTakeDamage(const CTakeDamageInfo &info);
/*162*/virtual void VPhysicsShadowCollision(int index, gamevcollisionevent_t *pEvent);
/*163*/virtual void VPhysicsShadowUpdate(IPhysicsObject *pPhysics) {}
/*164*/virtual void VPhysicsCollision(int index, gamevcollisionevent_t *pEvent);
/*165*/virtual void GMOD_VPhysicsCollision(int index, gamevcollisionevent_t *pEvent);
/*166*/virtual void GMOD_GetPhysBoneMatrix(int); /////////////////////////////////////////////////////////////////////////// <---- look into
/*167*/virtual void VPhysicsFriction(IPhysicsObject *pObject, float energy, int surfaceProps, int surfacePropsHit);
/*168*/virtual void UpdatePhysicsShadowToCurrentPosition(float deltaTime);
/*169*/virtual int VPhysicsGetObjectList(IPhysicsObject **pList, int listMax);
/*170*/virtual bool VPhysicsIsFlesh(void);
/*171*/virtual CBasePlayer *HasPhysicsAttacker(float dt) { return NULL; }
// UNDONE: Make this data?
/*172*/virtual unsigned int PhysicsSolidMaskForEntity(void) const;
/*173*/virtual void ResolveFlyCollisionCustom(trace_t &trace, Vector &vecVelocity);
/*174*/virtual void PerformCustomPhysics(Vector *pNewPosition, Vector *pNewVelocity, QAngle *pNewAngles, QAngle *pNewAngVelocity);
/*175*/virtual Vector GetStepOrigin(void) const;
/*176*/virtual QAngle GetStepAngles(void) const;
/*177*/virtual bool ShouldDrawWaterImpacts() { return true; }
/*178*/virtual void NetworkStateChanged_m_fFlags(void);
/*179*/virtual void NetworkStateChanged_m_fFlags(void*);
/*180*/virtual void NetworkStateChanged_m_nWaterLevel(void);
/*181*/virtual void NetworkStateChanged_m_nWaterLevel(void*);
/*182*/virtual void NetworkStateChanged_m_hGroundEntity(void);
/*183*/virtual void NetworkStateChanged_m_hGroundEntity(void*);
/*184*/virtual void NetworkStateChanged_m_vecBaseVelocity(void);
/*185*/virtual void NetworkStateChanged_m_vecBaseVelocity(void*);
/*186*/virtual void NetworkStateChanged_m_flFriction(void);
/*187*/virtual void NetworkStateChanged_m_flFriction(void*);
/*188*/virtual void NetworkStateChanged_m_vecViewOffset(void);
/*189*/virtual void NetworkStateChanged_m_vecViewOffset(void*);
/*190*/virtual bool ShouldBlockNav() const { return true; }
/*191*/virtual bool ShouldForceTransmitsForTeam(int iTeamNum);
/*192*/virtual void VPhysicsGetElement(int);
/*193*/virtual void OnOwnerChanged(void);
/*194*/virtual bool IsARagdoll(void);
/*195*/virtual void SetMaterialOverride(char const*);
/*196*/virtual char const* GetMaterialOverride(void);
/*197*/virtual bool IsPredicted(void);
/*198*/virtual bool IsWeapon(void);
/*199*/virtual bool IsVehicle(void);
/*200*/virtual bool IsJeep(void);
/*201*/virtual int UsesLua(void);
/*202*/virtual int GetLuaEntityType(void);
/*203*/virtual void PushEntity(void);
/*204*/virtual void Push_This_Entity(void);
/*205*/virtual void SetPhysObject(int, IPhysicsObject*);
/*206*/virtual void SetEntity(char const*, CBaseEntity*);
/*207*/virtual void DeleteOnRemove(CBaseEntity*);
/*208*/virtual void DontDeleteOnRemove(CBaseEntity*);
/*209*/virtual int GetParentPhysicsNum(void);
/*210*/virtual void SetParentPhysicsNum(int);
/*211*/virtual float GetCreationTime(void);
/*212*/virtual void StartMotionController(void);
/*213*/virtual void StopMotionController(void);
/*214*/virtual void AttachObjectToMotionController(IPhysicsObject* pPhysics);
/*215*/virtual void DetachObjectFromMotionController(IPhysicsObject* pPhysics);
/*216*/virtual void SaveLua(ISave*);
/*217*/virtual void LoadLua(IRestore*);
/*218*/virtual void SetUseType(USE_TYPE type);
/*219*/virtual void UpdateBeforeRemove(int);
/*220*/virtual char const* GetLuaScriptName(void);
/*221*/virtual bool SpawnedViaLua(void);
/*222*/virtual void OverridePosition(void);
/*223*/virtual void InitializeScriptedEntity(char const*);
/*224*/virtual void ClearLuaData(void);
/*225*/virtual void* GetLuaTable(void); /////////////////////// FIX ME
/*226*/virtual void* GetLuaEntity(void); /////////////////////// FIX ME
/*227*/virtual void Lua_OnEntityInitialized(void);
/*228*/virtual void SetLuaTable(ILuaObject*);
/*229*/virtual bool HasLuatable(void);
/*230*/virtual void ForcePhysicsDropObject(void);
/*231*/virtual void StartDriving(CBasePlayer*);
/*232*/virtual void FinishDriving(CBasePlayer*);
/*233*/virtual bool GMOD_ShouldPreventTransmitToPlayer(CBasePlayer* pPlayer);
/*234*/virtual bool GMOD_SetShouldPreventTransmitToPlayer(CBasePlayer* pPlayer, bool state);
/*235*/virtual bool GMOD_ShouldPlayPhysicsSounds(void);
/*236*/virtual void* Lua_GetLuaClass(void); /////////////////////// FIX ME
/*237*/virtual INextBot* GetNextBot(void);
public:
// Why do we have two separate static Instance functions?
static CBaseEntity *Instance(const CBaseHandle &hEnt);
static CBaseEntity *Instance(const edict_t *pent);
static CBaseEntity *Instance(edict_t *pent);
static CBaseEntity* Instance(int iEnt);
inline const char* GetClassname()
{
return STRING(m_iClassname);
}
inline CCollisionProperty *CollisionProp()
{
return &m_Collision;
}
inline const CCollisionProperty *CollisionProp() const
{
return &m_Collision;
}
Vector& GetAbsVelocity() {
return this->m_vecAbsVelocity;
}
bool IsWorld() { return this->entindex() == 0; }
inline void AddSpawnFlags(int nFlags);
inline void RemoveSpawnFlags(int nFlags);
inline int GetFlags() { return this->m_fFlags; }
inline bool IsMarkedForDeletion(void) { return (m_iEFlags & EFL_KILLME); }
FORCEINLINE bool NamesMatch(const char *pszQuery, string_t nameToMatch)
{
if (nameToMatch == NULL_STRING)
return (!pszQuery || *pszQuery == 0 || *pszQuery == '*');
const char *pszNameToMatch = STRING(nameToMatch);
// If the pointers are identical, we're identical
if (pszNameToMatch == pszQuery)
return true;
while (*pszNameToMatch && *pszQuery)
{
unsigned char cName = *pszNameToMatch;
unsigned char cQuery = *pszQuery;
// simple ascii case conversion
if (cName == cQuery)
;
else if (cName - 'A' <= (unsigned char)'Z' - 'A' && cName - 'A' + 'a' == cQuery)
;
else if (cName - 'a' <= (unsigned char)'z' - 'a' && cName - 'a' + 'A' == cQuery)
;
else
break;
++pszNameToMatch;
++pszQuery;
}
if (*pszQuery == 0 && *pszNameToMatch == 0)
return true;
// @TODO (toml 03-18-03): Perhaps support real wildcards. Right now, only thing supported is trailing *
if (*pszQuery == '*')
return true;
return false;
}
bool NameMatchesComplex(const char *pszNameOrWildcard)
{
if (!Q_stricmp("!player", pszNameOrWildcard))
return IsPlayer();
return NamesMatch(pszNameOrWildcard, m_iName);
}
bool ClassMatchesComplex(const char *pszClassOrWildcard)
{
return NamesMatch(pszClassOrWildcard, m_iClassname);
}
inline bool ClassMatches(const char *pszClassOrWildcard)
{
if (IDENT_STRINGS(m_iClassname, pszClassOrWildcard))
return true;
return ClassMatchesComplex(pszClassOrWildcard);
}
inline bool NameMatches(const char *pszNameOrWildcard)
{
if (IDENT_STRINGS(m_iName, pszNameOrWildcard))
return true;
return NameMatchesComplex(pszNameOrWildcard);
}
inline bool IsEFlagSet(int nEFlagMask) const
{
return (m_iEFlags & nEFlagMask) != 0;
}
int GetFirstThinkTick()
{
int minTick = TICK_NEVER_THINK;
if (m_nNextThinkTick > 0)
{
minTick = m_nNextThinkTick;
}
for (int i = 0; i < m_aThinkFunctions.Count(); i++)
{
int next = m_aThinkFunctions[i].m_nNextThinkTick;
if (next > 0)
{
if (next < minTick || minTick == TICK_NEVER_THINK)
{
minTick = next;
}
}
}
return minTick;
}
inline CServerNetworkProperty *NetworkProp()
{
return &m_Network;
}
inline edict_t *edict(void) { return NetworkProp()->edict(); }
int DispatchUpdateTransmitState()
{
edict_t *ed = edict();
if (m_nTransmitStateOwnedCounter != 0)
return ed ? ed->m_fStateFlags : 0;
int ret = UpdateTransmitState();
return ret;
}
inline const Vector& GetLocalOrigin(void) const
{
return m_vecOrigin;
}
void SetLocalOrigin(const Vector& origin)
{
// Safety check against NaN's or really huge numbers
if (!IsEntityPositionReasonable(origin))
{
return;
}
if (m_vecOrigin != origin)
{
m_vecOrigin = origin;
}
}
bool IsInWorld(void)
{
if (!this)
return true;
// position
if (GetAbsOrigin().x >= MAX_COORD_INTEGER) return false;
if (GetAbsOrigin().y >= MAX_COORD_INTEGER) return false;
if (GetAbsOrigin().z >= MAX_COORD_INTEGER) return false;
if (GetAbsOrigin().x <= MIN_COORD_INTEGER) return false;
if (GetAbsOrigin().y <= MIN_COORD_INTEGER) return false;
if (GetAbsOrigin().z <= MIN_COORD_INTEGER) return false;
// speed
if (GetAbsVelocity().x >= 2000) return false;
if (GetAbsVelocity().y >= 2000) return false;
if (GetAbsVelocity().z >= 2000) return false;
if (GetAbsVelocity().x <= -2000) return false;
if (GetAbsVelocity().y <= -2000) return false;
if (GetAbsVelocity().z <= -2000) return false;
return true;
}
inline int GetTeamNumber() const { return m_iTeamNum; }
inline int entindex() const { return m_Network.entindex(); };
soundlevel_t LookupSoundLevel(char const* soundname) { soundlevel_t nothing; return nothing; }
CAI_BaseNPC *MyNPCPointer(void) {
if (this->IsNPC())
return (CAI_BaseNPC*)this;
return nullptr;
}
Vector& GetAbsOrigin() { return m_vecAbsOrigin; }
inline bool HasSpawnFlags(int nFlags) const
{
return (m_spawnflags & nFlags) != 0;
}
inline void AddEFlags(int nEFlagMask)
{
m_iEFlags |= nEFlagMask;
if (nEFlagMask & (EFL_FORCE_CHECK_TRANSMIT | EFL_IN_SKYBOX))
{
DispatchUpdateTransmitState();
}
}
void PhysicsCheckForEntityUntouch() {}
inline bool GetCheckUntouch() const
{
return IsEFlagSet(EFL_CHECK_UNTOUCH);
}
inline bool IsPointSized() const
{
return CollisionProp()->BoundingRadius() == 0.0f;
}
#ifdef _WIN32 // feels ghetto holy shit lol.
bool IsSWEP() {
if (!this || !this->UsesLua() || !this->IsWeapon())
return false;
if (this->GetServerClass()->m_ClassID != 234)
return false;
return true;
}
bool IsSENT_anim() { // ENT.Type = "anim" btw
if (!this || !this->UsesLua())
return false;
if (this->GetServerClass()->m_ClassID != 131)
return false;
return true;
}
#endif
public:
BYTE pad_unk00[0x8];
CServerNetworkProperty m_Network;
// members
string_t m_iClassname; // identifier for entity creation and save/restore
string_t m_iGlobalname; // identifier for carrying entity across level transitions
string_t m_iParent; // the name of the entities parent; linked into m_pParent during Activate()
int m_iHammerID; // Hammer unique edit id number
// was pev->speed
float m_flSpeed;
// was pev->renderfx
unsigned char m_nRenderFX;
// was pev->rendermode
unsigned char m_nRenderMode;
short m_nModelIndex;
// was pev->rendercolor
color32 m_clrRender;
// was pev->animtime: consider moving to CBaseAnimating
float m_flPrevAnimTime;
float m_flAnimTime;
float m_flSimulationTime;
int m_ubInterpolationFrame;
int m_nLastThinkTick;
// Certain entities (projectiles) can be created on the client and thus need a matching id number
CPredictableId m_PredictableID;
// used so we know when things are no longer touching
int touchStamp;
CUtlVector< thinkfunc_t > m_aThinkFunctions;
int m_iCurrentThinkContext;
CUtlVector< ResponseContext_t > m_ResponseContexts;
BYTE pad_unk01[0x8];
// Map defined context sets
string_t m_iszResponseContext;
// was pev->nextthink
int m_nNextThinkTick;
// was pev->effects
int m_fEffects;
CBaseEntity* m_pLink;// used for temporary link-list operations.
// variables promoted from edict_t
string_t m_target;
int m_iMaxHealth; // CBaseEntity doesn't care about changes to this variable, but there are derived classes that do.
int m_iHealth;
char m_lifeState;
char m_takedamage;
// Damage filtering
string_t m_iszDamageFilterName; // The name of the entity to use as our damage filter.
EHANDLE m_hDamageFilter; // The entity that controls who can damage us.
// Debugging / devolopment fields
int m_debugOverlays; // For debug only (bitfields)
TimedOverlay_t* m_pTimedOverlay; // For debug only
// Which frame did I simulate?
int m_nSimulationTick;
// FIXME: Make this private! Still too many references to do so...
int m_spawnflags;
int m_iEFlags; // entity flags EFL_*
// was pev->flags
int m_fFlags;
string_t m_iName;
CUtlLinkedList<CDamageModifier*, int> m_DamageModifiers;
EHANDLE m_pParent; // for movement hierarchy
BYTE m_nTransmitStateOwnedCounter;
unsigned char m_iParentAttachment;
unsigned char m_MoveType;
unsigned char m_MoveCollide;
// Our immediate parent in the movement hierarchy.
// FIXME: clarify m_pParent vs. m_pMoveParent
EHANDLE m_hMoveParent;
// cached child list
EHANDLE m_hMoveChild;
// generated from m_pMoveParent
EHANDLE m_hMovePeer;
CCollisionProperty m_Collision;
EHANDLE m_hOwnerEntity; // only used to point to an edict it won't collide with
EHANDLE m_hEffectEntity; // Fire/Dissolve entity.
int m_CollisionGroup; // used to cull collision tests
IPhysicsObject *m_pPhysicsObject; // pointer to the entity's physics object (vphysics.dll)
float m_flShadowCastDistance;
float m_flDesiredShadowCastDistance;
// Team handling
int m_iInitialTeamNum; // Team number of this entity's team read from file
int m_iTeamNum; // Team number of this entity's team.
// Sets water type + level for physics objects
unsigned char m_nWaterTouch;
unsigned char m_nSlimeTouch;
unsigned char m_nWaterType;
unsigned char m_nWaterLevel;
float m_flNavIgnoreUntilTime;
EHANDLE m_hGroundEntity;
float m_flGroundChangeTime; // Time that the ground entity changed
string_t m_ModelName;
// Velocity of the thing we're standing on (world space)
Vector m_vecBaseVelocity;
// Global velocity
Vector m_vecAbsVelocity;
// Local angular velocity
QAngle m_vecAngVelocity;
// local coordinate frame of entity
matrix3x4_t m_rgflCoordinateFrame;
// Physics state
EHANDLE m_pBlocker;
// was pev->gravity;
float m_flGravity; // rename to m_flGravityScale;
// was pev->friction
float m_flFriction;
float m_flElasticity;
// was pev->ltime
float m_flLocalTime;
// local time at the beginning of this frame
float m_flVPhysicsUpdateLocalTime;
// local time the movement has ended
float m_flMoveDoneTime;
// A counter to help quickly build a list of potentially pushed objects for physics
int m_nPushEnumCount;
Vector m_vecAbsOrigin;
Vector m_vecVelocity;
unsigned char m_iTextureFrameIndex;
bool m_bSimulatedEveryTick;
bool m_bAnimatedEveryTick;
bool m_bAlternateSorting;
// User outputs. Fired when the "FireInputX" input is triggered.
COutputEvent m_OnUser1;
COutputEvent m_OnUser2;
COutputEvent m_OnUser3;
COutputEvent m_OnUser4;
QAngle m_angAbsRotation;
Vector m_vecOrigin;
QAngle m_angRotation;
CBaseHandle m_RefEHandle;
// was pev->view_ofs ( FIXME: Move somewhere up the hierarch, CBaseAnimating, etc. )
Vector m_vecViewOffset;
// dynamic model state tracking
bool m_bDynamicModelAllowed;
bool m_bDynamicModelPending;
bool m_bDynamicModelSetBounds;
bool m_bIsPlayerSimulated;
CHandle< CBasePlayer > m_hPlayerSimulationOwner;
int m_fDataObjectTypes; // 0x334
BYTE pad_unk02[0x328];
GarrysMod::Lua::CLuaObject m_LuaObject; // 0x660
GarrysMod::Lua::CLuaGameObject* m_LuaGameObject_LuaTable; // idk type is table
GarrysMod::Lua::CLuaGameObject* m_LuaGameObject_Entity; // idk type is entity
BYTE pad_unk03[0xD14]; //0x1390 End of BaseEntity
};
inline void CBaseEntity::AddSpawnFlags(int nFlags)
{
m_spawnflags |= nFlags;
}
inline void CBaseEntity::RemoveSpawnFlags(int nFlags)
{
m_spawnflags &= ~nFlags;
}
inline CBaseEntity *CBaseEntity::Instance(const edict_t *pent)
{
return GetContainingEntity(const_cast<edict_t*>(pent));
}
#include "util.h"
inline CBaseEntity *CBaseEntity::Instance(edict_t *pent)
{
if (!pent)
{
pent = INDEXENT(0);
}
return GetContainingEntity(pent);
}
inline CBaseEntity* CBaseEntity::Instance(int iEnt)
{
return Instance(INDEXENT(iEnt));
}
class CPointEntity : public CBaseEntity
{
public:
DECLARE_CLASS(CPointEntity, CBaseEntity);
void Spawn(void);
virtual int ObjectCaps(void) { return BaseClass::ObjectCaps() & ~FCAP_ACROSS_TRANSITION; }
virtual bool KeyValue(const char *szKeyName, const char *szValue);
private:
};
// Has a position + size
class CServerOnlyEntity : public CBaseEntity
{
DECLARE_CLASS(CServerOnlyEntity, CBaseEntity);
public:
//CServerOnlyEntity() : CBaseEntity(true) {}
virtual int ObjectCaps(void) { return (BaseClass::ObjectCaps() & ~FCAP_ACROSS_TRANSITION); }
};
// Has only a position, no size
class CServerOnlyPointEntity : public CServerOnlyEntity
{
DECLARE_CLASS(CServerOnlyPointEntity, CServerOnlyEntity);
public:
virtual bool KeyValue(const char *szKeyName, const char *szValue);
};
// Has no position or size
class CLogicalEntity : public CServerOnlyEntity
{
DECLARE_CLASS(CLogicalEntity, CServerOnlyEntity);
public:
virtual bool KeyValue(const char *szKeyName, const char *szValue);
};
inline bool FClassnameIs(CBaseEntity *pEntity, const char *szClassname)
{
return pEntity->ClassMatches(szClassname);
}
#endif
|
2f09897aafc5229c1f556aed61071b6571592de4
|
913a56012739e40a17bb5309b40d5ef6971e28d5
|
/Source/Runtime/Public/Containers/StrArray.h
|
0a9ed26b8b816ec00358aee9758f9411e6e06783
|
[
"LicenseRef-scancode-free-unknown",
"Apache-2.0",
"LicenseRef-scancode-unknown-license-reference"
] |
permissive
|
davchezt/BlueshiftEngine
|
4265b0bf4ef7a2dbd0d726977f0bae333d1025bb
|
fbc374cbc391e1147c744649f405a66a27c35d89
|
refs/heads/master
| 2020-12-05T22:42:44.353929
| 2020-11-28T22:37:08
| 2020-11-28T22:37:08
| 232,265,027
| 2
| 0
|
Apache-2.0
| 2020-11-29T01:38:17
| 2020-01-07T07:10:48
| null |
UTF-8
|
C++
| false
| false
| 1,772
|
h
|
StrArray.h
|
// Copyright(c) 2017 POLYGONTEK
//
// 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.
#pragma once
/*
-------------------------------------------------------------------------------
StrArray
-------------------------------------------------------------------------------
*/
#include "Array.h"
#include "Core/Str.h"
BE_NAMESPACE_BEGIN
using StrArray = Array<Str>;
BE_INLINE void SplitStringIntoList(StrArray &array, const char *string, const char *separator = "|") {
int separatorLength = Str::Length(separator);
assert(separatorLength > 0);
Str str(string);
// append a terminator there's no terminating one
if (Str::Icmp(str.Mid(str.Length() - separatorLength, separatorLength), separator) != 0) {
str += separator;
}
int startIndex = 0;
int endIndex = str.Find(separator);
while (endIndex != -1 && endIndex < str.Length()) {
array.Append(str.Mid(startIndex, endIndex - startIndex));
startIndex = endIndex + separatorLength;
endIndex = str.Find(separator, false, startIndex);
}
}
template <>
BE_INLINE size_t StrArray::Size() const {
size_t s = sizeof(*this);
for (int i = 0; i < Count(); i++) {
s += (*this)[i].Size();
}
return s;
}
BE_NAMESPACE_END
|
9ed415cec100507fb97475efffc4dcac107f66dc
|
18a3f93e4b94f4f24ff17280c2820497e019b3db
|
/BOSS/CalibData/Tof/TofSimData.h
|
7c3a4fe039be6e3ca20157327fda5deafd710c56
|
[] |
no_license
|
jjzhang166/BOSS_ExternalLibs
|
0e381d8420cea17e549d5cae5b04a216fc8a01d7
|
9b3b30f7874ed00a582aa9526c23ca89678bf796
|
refs/heads/master
| 2023-03-15T22:24:21.249109
| 2020-11-22T15:11:45
| 2020-11-22T15:11:45
| null | 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 1,913
|
h
|
TofSimData.h
|
// $Header: /bes/bes/BossCvs/Calibration/CalibData/CalibData/Tof/TofSimData.h,v 1.10 2010/01/08
#ifndef CalibData_TofSimData_h
#define CalibData_TofSimData_h
/* @class CalibData_TofSimData_h
calibration data class
calibration infrastructure
@author sunss
*/
#include "GaudiKernel/DataObject.h"
#include "CalibData/CalibModel.h"
#include "CalibData/CalibBase1.h"
#include "CalibData/Tof/TofSimConstBase.h"
#include "CalibData/Tof/BTofSimBase.h"
#include "CalibData/Tof/ETofSimBase.h"
namespace CalibData {
class TofSimData: public CalibBase1{
public:
TofSimData(){};
TofSimData(std::vector<TofSimConstBase>* fTofConst,std::vector<BTofSimBase>* fBTofSim,std::vector<ETofSimBase>* fETofSim);
virtual ~TofSimData() {
delete m_TofSimConstData;
delete m_BTofSimData;
delete m_ETofSimData;
}
// Re-implemented from DataObject
inline virtual const CLID& clID() const { return classID(); }
inline static const CLID& classID() { return CLID_Calib_TofSim; }
virtual StatusCode update(CalibBase1& other, MsgStream* log);
//get the Simulation Constants
TofSimConstBase getTofConst() const;
double getBarLowThres();
double getBarHighThres();
double getEndLowThres();
double getEndHighThres();
double getBarPMTGain();
double getEndPMTGain();
double getBarConstant();
double getEndConstant();
double getEndNoiseSwitch();
BTofSimBase getBTofSim(int cnt) const;
double getBarGain(int cnt);
double getBarRatio(int cnt);
double getBarAttenLength(int cnt);
ETofSimBase getETofSim(int cnt) const;
double getEndGain(int cnt);
double getEndAttenLength(int cnt);
double getEndNoiseSmear(int cnt);
private:
std::vector<TofSimConstBase>* m_TofSimConstData;
std::vector<BTofSimBase>* m_BTofSimData;
std::vector<ETofSimBase>* m_ETofSimData;
};
}
#endif
|
65204f8e820c22a2e9a9c98f82c7b543fd18fb88
|
3f6c6d8c0d75ee690a67d80d33bd71fd734e0153
|
/Library/InputWrapper/DirectInputWrapper.h
|
e17f4f3fbeaca74d8578054af789773aeb177b41
|
[] |
no_license
|
TGAHobbyists/HobbyTurnbased
|
ea67014512e2f536d54d397e2ce438436df2bfb8
|
71d0f00b52cd1fd7684d595d7f645043e29a8b48
|
refs/heads/master
| 2016-09-11T02:56:22.346408
| 2014-08-17T20:37:01
| 2014-08-17T20:37:01
| null | 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 3,840
|
h
|
DirectInputWrapper.h
|
#ifndef _INPUT_MANAGER_H
#define _INPUT_MANAGER_H
#define DIRECTINPUT_VERSION 0x0800
#include <Windows.h>
#include "dinput.h"
#include "Vector.h"
namespace Input
{
enum MouseButton
{
LeftMouseButton,
RightMouseButton,
MiddleMouseButton,
NumberOfMouseButtons
};
class DirectInputWrapper
{
public:
static const int ourNumberOfCharsInKeyboardBuffer = 256;
static const int ourSizeOfCharBuffer = sizeof(char)*ourNumberOfCharsInKeyboardBuffer;
static const DWORD ourInputFlags = DISCL_NONEXCLUSIVE | DISCL_FOREGROUND;
public:
DirectInputWrapper();
~DirectInputWrapper();
void Initialize(HWND aWindowHandle);
void Poll();
void SwapBuffers();
inline bool GetKeyPress(unsigned char aKey);
inline bool GetKeyRelease(unsigned char aKey);
inline bool GetMousePress(MouseButton aKey);
inline bool GetMouseRelease(MouseButton aKey);
inline int GetMouseX();
inline int GetMouseY();
inline int GetMouseZ();
inline bool IsMouseWheelScrolledForward();
inline bool IsMouseWheelScrolledBackward();
private:
void InitializeObject();
void InitializeKeyboard(HWND aWindowHandle);
void InitializeMouse(HWND aWindowHandle);
inline bool IsKeyDown(unsigned char aKey, unsigned char* aKeyboardState);
inline bool IsKeyUp(unsigned char aKey, unsigned char* aKeyboardState);
inline bool IsMouseButtonDown(int aButton, DIMOUSESTATE2 &aMouseState);
inline bool IsMouseButtonUp(int aButton, DIMOUSESTATE2 &aMouseState);
inline void GetMouseState();
inline void GetKeyboardState();
DirectInputWrapper(const DirectInputWrapper &aInputWrapper);
DirectInputWrapper& operator=(const DirectInputWrapper &aInputWrapper);
private:
DIMOUSESTATE2 myCurrentMouseState;
DIMOUSESTATE2 myPreviousMouseState;
unsigned char *myCurrentKeyboardState;
unsigned char *myPreviousKeyboardState;
LPDIRECTINPUT8 myDirectInput;
LPDIRECTINPUTDEVICE8 myKeyboardDevice;
LPDIRECTINPUTDEVICE8 myMouseDevice;
};
bool DirectInputWrapper::GetKeyRelease(unsigned char aKey)
{
if (IsKeyUp(aKey, myCurrentKeyboardState) == true)
{
return IsKeyDown(aKey, myPreviousKeyboardState);
}
return false;
}
bool DirectInputWrapper::GetKeyPress(unsigned char aKey)
{
if (IsKeyDown(aKey, myCurrentKeyboardState) == true)
{
return IsKeyUp(aKey, myPreviousKeyboardState);
}
return false;
}
bool DirectInputWrapper::IsKeyDown(unsigned char aKey, unsigned char* aKeyboardState)
{
return((aKeyboardState[aKey] & 0x80) != 0);
}
bool DirectInputWrapper::IsKeyUp(unsigned char aKey, unsigned char* aKeyboardState)
{
return(!IsKeyDown(aKey,aKeyboardState));
}
bool DirectInputWrapper::GetMouseRelease(MouseButton aKey)
{
if (IsMouseButtonUp(aKey, myCurrentMouseState) == true)
{
return IsMouseButtonDown(aKey, myPreviousMouseState);
}
return false;
}
bool DirectInputWrapper::GetMousePress(MouseButton aKey)
{
if (IsMouseButtonDown(aKey, myCurrentMouseState))
{
return IsMouseButtonUp(aKey, myPreviousMouseState);
}
return false;
}
bool DirectInputWrapper::IsMouseButtonDown(int aButton, DIMOUSESTATE2 &aMouseState)
{
return((aMouseState.rgbButtons[aButton] & 0x80) != 0);
}
bool DirectInputWrapper::IsMouseButtonUp(int aButton, DIMOUSESTATE2 &aMouseState)
{
return(!IsMouseButtonDown(aButton,aMouseState));
}
bool DirectInputWrapper::IsMouseWheelScrolledForward()
{
if( myCurrentMouseState.lZ > 0 )
{
return true;
}
return false;
}
bool DirectInputWrapper::IsMouseWheelScrolledBackward()
{
if( myCurrentMouseState.lZ < 0 )
{
return true;
}
return false;
}
int DirectInputWrapper::GetMouseX()
{
return(myCurrentMouseState.lX);
}
int DirectInputWrapper::GetMouseY()
{
return(myCurrentMouseState.lY);
}
int DirectInputWrapper::GetMouseZ()
{
return(myCurrentMouseState.lZ);
}
}
#endif
|
39b02015cef2288501a3a1806011f82a754e883d
|
f4473e90491e419f72f03ae55f62ad0e43b79514
|
/Contests/CF015_1113/A/1113A_1.cpp
|
9205658438a34d19899af5797d687e2535dd32e6
|
[] |
no_license
|
nishitkshah/My-Codeforces-Submissions
|
443c2ae476c10bd14a9733cf39e5ad0da591be9a
|
9671ab0ed70cece4a062ec07b58d8ded5d729c50
|
refs/heads/master
| 2020-06-29T14:50:57.749663
| 2019-08-05T01:55:52
| 2019-08-05T01:55:52
| 200,563,917
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 422
|
cpp
|
1113A_1.cpp
|
//22:05 16-02-2019
//22:10 16-02-2019
#include<iostream>
#include<vector>
#include<algorithm>
#include<set>
#include<utility>
using namespace std;
#define RE(a, b, c) for(int a=(b); a<(c); a++)
int n, v;
main(){
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> v;
n--; v--;
int ans;
if(v>=n)
ans = n;
else
ans = v + ((n-v)*(n-v+1)/2);
cout << ans << '\n';
}
//22:12 16-02-2019
//22:13 16-02-2019
|
0a3adf1295884e72802cbff9832701cf18c74bed
|
ac6b48c86210a764305e213968f59dc5874effb6
|
/vector.hpp
|
42099d4e0d2e96c207a8fc9ec71787d58cc6a49b
|
[] |
no_license
|
mavileo/ft_containers-42
|
553040bf9da38d524b0cbac5ca63ee501709c8a6
|
8deb86003774edb855e682569669df0990f35d9a
|
refs/heads/master
| 2023-06-01T15:59:27.406696
| 2021-06-13T13:51:50
| 2021-06-13T13:51:50
| 319,797,449
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 18,649
|
hpp
|
vector.hpp
|
#include "stack.hpp"
namespace ft {
template < class T >
class vector_iterator {
public :
typedef T value_type;
typedef value_type& reference;
typedef const value_type& const_reference;
typedef value_type* pointer;
typedef const value_type* const_pointer;
typedef typename std::ptrdiff_t difference_type;
vector_iterator(void) {}
vector_iterator(pointer ptr) { _ptr = ptr; }
vector_iterator(vector_iterator const &src) { *this = src; } ;
vector_iterator &operator=(vector_iterator const &src) { _ptr = src.operator->(); return (*this); }
~vector_iterator() {}
vector_iterator operator ++() {
_ptr++;
return (*this);
}
vector_iterator operator ++(int) {
_ptr++;
return (vector_iterator(_ptr - 1));
}
vector_iterator operator --() {
_ptr--;
return (*this);
}
vector_iterator operator --(int) {
_ptr--;
return (vector_iterator(_ptr + 1));
}
void operator +=(difference_type v) { _ptr += v; }
void operator -=(difference_type v) { _ptr -= v; }
bool operator ==(vector_iterator const& v) const { return _ptr == v._ptr; }
bool operator !=(vector_iterator const& v) const { return _ptr != v._ptr; }
bool operator <(vector_iterator const& v) const { return _ptr < v._ptr; }
bool operator <=(vector_iterator const& v) const { return _ptr <= v._ptr; }
bool operator >(vector_iterator const& v) const { return _ptr > v._ptr; }
bool operator >=(vector_iterator const& v) const { return _ptr >= v._ptr; }
vector_iterator operator +(difference_type v) { return vector_iterator(_ptr + v); }
vector_iterator operator -(difference_type v) { return vector_iterator(_ptr - v); }
difference_type operator +(vector_iterator v) { return _ptr + v._ptr; }
difference_type operator -(vector_iterator v) { return _ptr - v._ptr; }
reference operator *() { return *_ptr; }
const_reference operator *() const { return *_ptr; }
pointer operator ->() { return _ptr; }
pointer operator ->() const { return _ptr; }
reference operator [](difference_type n) { return *(_ptr + n); }
const_reference operator [](difference_type n) const { return *(_ptr + n); }
pointer get_ptr() { return _ptr; }
private :
pointer _ptr;
};
template < class T >
class vector_const_iterator {
public :
typedef T value_type;
typedef value_type& reference;
typedef const value_type& const_reference;
typedef value_type* pointer;
typedef const value_type* const_pointer;
typedef typename std::ptrdiff_t difference_type;
vector_const_iterator(void) {}
vector_const_iterator(pointer ptr) { _ptr = ptr; }
vector_const_iterator(vector_iterator<T> const &src) { _ptr = src.operator->(); }
vector_const_iterator(vector_const_iterator const &src) { *this = src; }
vector_const_iterator &operator=(vector_const_iterator const &src) { _ptr = src.operator->(); return (*this); }
~vector_const_iterator() {}
vector_const_iterator operator ++() {
_ptr++;
return (*this);
}
vector_const_iterator operator ++(int) {
_ptr++;
return (vector_const_iterator(_ptr - 1));
}
vector_const_iterator operator --() {
_ptr--;
return (*this);
}
vector_const_iterator operator --(int) {
_ptr--;
return (vector_const_iterator(_ptr + 1));
}
bool operator ==(vector_const_iterator const& v) const { return _ptr == v._ptr; }
bool operator !=(vector_const_iterator const& v) const { return _ptr != v._ptr; }
bool operator <(vector_const_iterator const& v) const { return _ptr < v._ptr; }
bool operator <=(vector_const_iterator const& v) const { return _ptr <= v._ptr; }
bool operator >(vector_const_iterator const& v) const { return _ptr > v._ptr; }
bool operator >=(vector_const_iterator const& v) const { return _ptr >= v._ptr; }
vector_const_iterator operator +(difference_type v) { return vector_const_iterator(_ptr + v); }
vector_const_iterator operator -(difference_type v) { return vector_const_iterator(_ptr - v); }
difference_type operator +(vector_const_iterator v) { return _ptr + v._ptr; }
difference_type operator -(vector_const_iterator v) { return _ptr - v._ptr; }
const_reference operator *() const { return *_ptr; }
pointer operator ->() { return _ptr; }
pointer operator ->() const { return _ptr; }
const_reference operator [](difference_type n) const { return *(_ptr + n); }
pointer get_ptr() { return _ptr; }
private :
pointer _ptr;
};
template < class iterator >
class vector_reverse_iterator {
public :
typedef iterator iterator_type;
typedef typename iterator::value_type value_type;
typedef typename iterator::reference reference;
typedef typename iterator::const_reference const_reference;
typedef typename iterator::pointer pointer;
typedef typename iterator::const_pointer const_pointer;
typedef typename iterator::difference_type difference_type;
vector_reverse_iterator(void) {}
vector_reverse_iterator(pointer ptr) { _ptr = ptr; }
vector_reverse_iterator(vector_iterator<value_type> const &src) { _ptr = src.operator->(); }
vector_reverse_iterator(vector_reverse_iterator const &src) { *this = src; } ;
vector_reverse_iterator &operator=(vector_reverse_iterator const &src) { _ptr = src.operator->(); return (*this); }
~vector_reverse_iterator() {}
vector_reverse_iterator operator ++() {
_ptr--;
return (*this);
}
vector_reverse_iterator operator ++(int) {
_ptr--;
return (vector_reverse_iterator(_ptr + 1));
}
vector_reverse_iterator operator --() {
_ptr++;
return (*this);
}
vector_reverse_iterator operator --(int) {
_ptr++;
return (vector_reverse_iterator(_ptr - 1));
}
void operator +=(difference_type v) { _ptr -= v; }
void operator -=(difference_type v) { _ptr += v; }
bool operator ==(vector_reverse_iterator const& v) const { return _ptr == v._ptr; }
bool operator !=(vector_reverse_iterator const& v) const { return _ptr != v._ptr; }
bool operator <(vector_reverse_iterator const& v) const { return _ptr < v._ptr; }
bool operator <=(vector_reverse_iterator const& v) const { return _ptr <= v._ptr; }
bool operator >(vector_reverse_iterator const& v) const { return _ptr > v._ptr; }
bool operator >=(vector_reverse_iterator const& v) const { return _ptr >= v._ptr; }
vector_reverse_iterator operator +(difference_type v) { return vector_reverse_iterator(_ptr - v); }
vector_reverse_iterator operator -(difference_type v) { return vector_reverse_iterator(_ptr + v); }
difference_type operator +(vector_reverse_iterator v) { return _ptr - v._ptr; }
difference_type operator -(vector_reverse_iterator v) { return _ptr + v._ptr; }
reference operator *() { return *_ptr; }
const_reference operator *() const { return *_ptr; }
pointer operator ->() { return _ptr; }
pointer operator ->() const { return _ptr; }
reference operator [](difference_type n) { return *(_ptr + n); }
const_reference operator [](difference_type n) const { return *(_ptr + n); }
pointer get_ptr() { return _ptr; }
private :
pointer _ptr;
};
template < class iterator >
class vector_const_reverse_iterator {
public :
typedef iterator iterator_type;
typedef typename iterator::value_type value_type;
typedef typename iterator::reference reference;
typedef typename iterator::const_reference const_reference;
typedef typename iterator::pointer pointer;
typedef typename iterator::const_pointer const_pointer;
typedef typename iterator::difference_type difference_type;
vector_const_reverse_iterator(void) {}
vector_const_reverse_iterator(pointer ptr) { _ptr = ptr; }
vector_const_reverse_iterator(vector_iterator<value_type> const &src) { _ptr = src.operator->(); }
vector_const_reverse_iterator(vector_const_reverse_iterator const &src) { *this = src; } ;
vector_const_reverse_iterator &operator=(vector_const_reverse_iterator const &src) { _ptr = src.operator->(); return (*this); }
~vector_const_reverse_iterator() {}
vector_const_reverse_iterator operator ++() {
_ptr--;
return (*this);
}
vector_const_reverse_iterator operator ++(int) {
_ptr--;
return (vector_const_reverse_iterator(_ptr + 1));
}
vector_const_reverse_iterator operator --() {
_ptr++;
return (*this);
}
vector_const_reverse_iterator operator --(int) {
_ptr++;
return (vector_const_reverse_iterator(_ptr - 1));
}
bool operator ==(vector_const_reverse_iterator const& v) const { return _ptr == v._ptr; }
bool operator !=(vector_const_reverse_iterator const& v) const { return _ptr != v._ptr; }
bool operator <(vector_const_reverse_iterator const& v) const { return _ptr < v._ptr; }
bool operator <=(vector_const_reverse_iterator const& v) const { return _ptr <= v._ptr; }
bool operator >(vector_const_reverse_iterator const& v) const { return _ptr > v._ptr; }
bool operator >=(vector_const_reverse_iterator const& v) const { return _ptr >= v._ptr; }
vector_const_reverse_iterator operator +(difference_type v) { return vector_const_reverse_iterator(_ptr - v); }
vector_const_reverse_iterator operator -(difference_type v) { return vector_const_reverse_iterator(_ptr + v); }
difference_type operator +(vector_const_reverse_iterator v) { return _ptr - v._ptr; }
difference_type operator -(vector_const_reverse_iterator v) { return _ptr + v._ptr; }
const_reference operator *() const { return *_ptr; }
pointer operator ->() { return _ptr; }
pointer operator ->() const { return _ptr; }
const_reference operator [](difference_type n) const { return *(_ptr + n); }
pointer get_ptr() { return _ptr; }
private :
pointer _ptr;
};
template < class T, class Alloc = std::allocator<T> >
class vector {
public :
typedef T value_type;
typedef Alloc allocator_type;
typedef typename std::size_t size_type;
typedef typename std::ptrdiff_t difference_type;
typedef typename Alloc::reference reference;
typedef typename Alloc::const_reference const_reference;
typedef typename Alloc::pointer pointer;
typedef typename Alloc::const_pointer const_pointer;
typedef typename ft::vector_iterator<T> iterator;
typedef typename ft::vector_const_iterator<T> const_iterator;
typedef typename ft::vector_reverse_iterator<iterator> reverse_iterator;
typedef typename ft::vector_const_reverse_iterator<iterator> const_reverse_iterator;
explicit vector (const allocator_type& alloc = allocator_type()) {
_alloc = alloc;
_ptr = NULL;
_size = 0;
_size_alloc = 0;
}
template <class InputIterator>
vector (InputIterator first, InputIterator last, const allocator_type& alloc = allocator_type()) {
_alloc = alloc;
_ptr = NULL;
_size = 0;
_size_alloc = 0;
while (first != last) {
push_back(*first);
first++;
}
}
explicit vector (size_type n, const value_type& val = value_type(), const allocator_type& alloc = allocator_type()) {
_alloc = alloc;
_ptr = NULL;
_size = 0;
_size_alloc = 0;
while (n--)
push_back(val);
}
vector (const vector& x) { *this = x; }
~vector () {
clear();
//if (_size_alloc > 0)
//_alloc.deallocate(_ptr, _size_alloc);
//_size_alloc = 0;
}
// ITERATORS
iterator begin() { return iterator(_ptr); }
const_iterator begin() const { return const_iterator(_ptr); }
iterator end() { return iterator(_ptr + _size); }
const_iterator end() const { return const_iterator(_ptr + _size); }
reverse_iterator rbegin() { return reverse_iterator(_ptr + _size - 1); }
const_reverse_iterator rbegin() const { return rbegin(); }
reverse_iterator rend() { return reverse_iterator(_ptr - 1); }
const_reverse_iterator rend() const { return rend(); }
// CAPACITY
size_type size() const { return _size; }
size_type max_size() const { return std::numeric_limits<size_type>::max(); }
void resize (size_type n, value_type val = value_type()) {
value_type *new_ptr;
new_ptr = _alloc.allocate(n);
if (n > _size) {
for (size_t i = 0; i < _size; i++)
_alloc.construct(new_ptr + i, *(_ptr + i));
for (size_t i = 0; i < n - _size; i++)
_alloc.construct(new_ptr + _size + i, val);
}
else {
for (size_t i = 0; i < n; i++)
_alloc.construct(new_ptr + i, *(_ptr + i));
}
if (_size) {
_alloc.destroy(_ptr);
_alloc.deallocate(_ptr, _size_alloc);
}
_size_alloc = n;
_size = n;
_ptr = new_ptr;
}
size_type capacity() const { return _size_alloc; }
bool empty() const { return (_size == 0); }
void reserve(size_type n) {
value_type *new_ptr;
if (n <= _size_alloc)
return ;
new_ptr = _alloc.allocate(n);
for (size_t i = 0; i < _size; i++)
_alloc.construct(new_ptr + i, *(_ptr + i));
_size_alloc = n;
_ptr = new_ptr;
}
// ELEMENT ACCESS
reference operator[] (size_type n) { return _ptr[n]; }
const_reference operator[] (size_type n) const { return _ptr[n]; }
reference at(size_type n) {
if (n >= _size)
throw std::out_of_range(std::to_string(n));
return (_ptr[n]);
}
const_reference at(size_type n) const {
if (n >= _size)
throw std::out_of_range(std::to_string(n));
return (_ptr[n]);
}
reference front() { return *_ptr; }
const_reference front() const { return *_ptr; }
reference back() { return *(_ptr + (_size - 1)); }
const_reference back() const { return *(_ptr + (_size - 1)); }
// MODIFIERS
template <class InputIterator>
void assign (InputIterator first, InputIterator last) {
clear();
while (first != last)
push_back(first++);
}
void assign (size_type n, const value_type& val) {
clear();
while (n--)
push_back(val);
}
void push_back (const value_type& val) {
if (_size == _size_alloc)
_extend();
_alloc.construct(_ptr + _size, val);
_size++;
}
void pop_back () {
if (!_size)
return ;
_alloc.destroy(_ptr + _size - 1);
_size--;
}
iterator insert(iterator position, const value_type& val) {
iterator fit;
difference_type diff = position - begin();
if (capacity() == size())
_extend();
fit = begin() + diff;
vector tmp(fit, end());
for (size_t i = 0; i < tmp.size(); i++)
pop_back();
push_back(val);
iterator it = tmp.begin();
for (size_t i = 0; i < tmp.size(); i++, it++)
push_back(*it);
return begin() + diff;
};
void insert(iterator position, size_type n, const value_type& val) {
difference_type diff = position - begin();
while (_size_alloc - _size < n)
_extend();
vector tmp(begin() + diff, end());
for (size_t i = 0; i < tmp.size(); i++)
pop_back();
while (n-- > 0)
push_back(val);
for (iterator it = tmp.begin(); it != tmp.end(); it++)
push_back(*it);
}
template <class InputIterator>
void insert (iterator position, InputIterator first, InputIterator last) {
size_t i = 0;
difference_type diff = position - this->begin();
while (first != last) {
first++;
i++;
}
first -= i;
while (_size_alloc - _size < i)
_extend();
vector tmp(begin() + diff, end());
for (size_t j = 0; j < tmp.size(); j++)
pop_back();
while (first != last)
push_back(*(first++));
for (iterator it = tmp.begin(); it != tmp.end(); it++)
push_back(*it);
}
iterator erase (iterator position) {
vector tmp(position + 1, end());
for (size_t i = 0; i <= tmp.size(); i++)
pop_back();
for (iterator it = tmp.begin(); it != tmp.end(); it++)
push_back(*it);
return (position);
}
iterator erase (iterator first, iterator last) {
iterator tmp(first);
while (tmp++ != last)
erase(first);
return (first);
}
void swap (vector& x) {
T *tmp_ptr = x._ptr;
size_t tmp_size = x._size;
size_t tmp_size_alloc = x._size_alloc;
x._ptr = _ptr;
x._size = _size;
x._size_alloc = _size_alloc;
_ptr = tmp_ptr;
_size = tmp_size;
_size_alloc = tmp_size_alloc;
}
void clear()
{
if (_size > 0)
{
iterator it = this->begin();
while (it != this->end())
_alloc.destroy(&(*it++));
_size = 0;
}
}
private :
allocator_type _alloc;
value_type *_ptr;
size_t _size_alloc;
size_t _size;
void _extend(void) {
if (_size_alloc == 0) {
_ptr = _alloc.allocate(1);
_size_alloc++;
}
else {
T *new_arr = _alloc.allocate(_size_alloc * 2);
for (size_t i = 0; i < _size; i++) {
_alloc.construct(new_arr + i, *(_ptr + i));
_alloc.destroy(_ptr + i);
}
_alloc.deallocate(_ptr, _size_alloc);
_ptr = new_arr;
_size_alloc *= 2;
}
};
};
template <class T, class Alloc>
bool operator== (const vector<T,Alloc>& lhs, const vector<T,Alloc>& rhs)
{
typename ft::vector<T>::const_iterator it_lhs = lhs.begin();
typename ft::vector<T>::const_iterator it_rhs = rhs.begin();
if (lhs.size() != rhs.size())
return (false);
while (it_lhs != lhs.end() && it_rhs != rhs.end() && *it_lhs == *it_rhs) {
it_lhs++;
it_rhs++;
}
return (it_lhs == lhs.end() && it_rhs == rhs.end());
}
template <class T, class Alloc>
bool operator!= (const vector<T,Alloc>& lhs, const vector<T,Alloc>& rhs) {
return (!(lhs == rhs));
}
template <class T, class Alloc>
bool operator<(const vector<T,Alloc>& lhs, const vector<T,Alloc>& rhs) {
typename ft::vector<T>::const_iterator it_lhs = lhs.begin();
typename ft::vector<T>::const_iterator it_rhs = rhs.begin();
if (lhs == rhs)
return (false);
while (it_lhs != lhs.end() && it_rhs != rhs.end() && *it_lhs == *it_rhs) {
it_lhs++;
it_rhs++;
}
if (it_rhs != rhs.end())
return (true);
return (false);
}
template <class T, class Alloc>
bool operator<= (const vector<T,Alloc>& lhs, const vector<T,Alloc>& rhs) {
return (lhs == rhs || lhs < rhs) ? true : false;
}
template <class T, class Alloc>
bool operator>(const vector<T,Alloc>& lhs, const vector<T,Alloc>& rhs) {
return (!(lhs == rhs) && !(lhs < rhs)) ? true : false;
}
template <class T, class Alloc>
bool operator>= (const vector<T,Alloc>& lhs, const vector<T,Alloc>& rhs) {
return (!(lhs < rhs)) ? true : false;
}
template <class T, class Alloc>
void swap (vector<T,Alloc>& x, vector<T,Alloc>& y) {
x.swap(y);
}
}
|
99a9d4f96f03231ddb908da1b27089d6d1bb9e92
|
5b04e8d5284c969834377c4fb4682b7b180cba6a
|
/loop-vectorizer-skeleton/simple-vectorizer/SimpleVectorizer.cpp
|
30a586471025aba7e7433210003c38bfdcfea382
|
[
"MIT"
] |
permissive
|
pramodk/llvm-summer-school-2017
|
3c29043926e431f6c49c6ceccc718c638e6685d7
|
dcd09380ee3c2b76ba913c2ccc3b986e5ba88c4f
|
refs/heads/master
| 2021-06-20T03:34:03.413831
| 2017-06-17T15:29:07
| 2017-06-17T16:44:59
| null | 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 7,707
|
cpp
|
SimpleVectorizer.cpp
|
#include "llvm/Analysis/LoopInfo.h"
#include "llvm/Analysis/ScalarEvolution.h"
#include "llvm/Analysis/ScalarEvolutionExpressions.h"
#include "llvm/IR/Function.h"
#include "llvm/IR/IRBuilder.h"
#include "llvm/IR/LegacyPassManager.h"
#include "llvm/Pass.h"
#include "llvm/Support/raw_ostream.h"
#include "llvm/Transforms/IPO/PassManagerBuilder.h"
#include "llvm/Transforms/Utils/BasicBlockUtils.h"
#include <llvm/Analysis/ScalarEvolutionExpressions.h>
#include <iostream>
#include <algorithm>
#include <vector>
using namespace llvm;
namespace {
struct SimpleVectorizer : public FunctionPass {
static char ID;
static const int VectorWidth = 4;
LoopInfo *LI;
ScalarEvolution *SE;
// The set of loops we want to vectorize.
std::vector<Loop *> LoopsToVectorize;
// A map that contains for each original value the corresponding new
// scalarized value for a given scalar iteration.
std::map<std::pair<int, Value *>, Value *> ValueMap;
// A map that contains for each original value the corresponding new
// vector value.
std::map<Value *, Value *> VectorMap;
SimpleVectorizer() : FunctionPass(ID) {}
// Return true if the loop is innermost.
bool isInnermostLoop(Loop *L);
// Return true if we are capable of vectorizing the loop.
bool isValidLoop(Loop *L);
// Collect loops that can be vectorized.
void collectLoops(Function &F);
// Print loops that should be vectorized.
void printLoops(Function &F);
// Transform the loops that should be vectorized.
void transformLoops();
// Transform the Loop *L
void transformLoop(Loop *L);
// Return the single basic block that represents the body of @p L.
BasicBlock *getSingleBodyBlock(Loop *L);
// Check if the loop structure of @p L is simple (canonical).
bool isSimpleLoopStructure(Loop *L);
// Get the new value for a given original value in the scalar lane @p Lane.
Value *getNewValue(int Lane, Value *V);
// Get the PHI node which serves as induction variable for @p L.
Value *getIndVar(Loop *L);
// Check if the loop body of @p L only contains instructions we can vectorize.
bool isValidBody(Loop *L);
// Get a scalar evolution expression that represents the memory access
// location of @p Inst.
const SCEV *getPointerSCEV(Instruction *Inst);
// Get the size of the elements (in bytes) loaded or stored by Inst.
size_t getElementSize(Instruction *Inst);
// Check if an instruction @p Inst has stride one access in loop @p L.
bool isStrideOneAccess(Instruction *Inst, Loop *L);
virtual bool runOnFunction(Function &F) {
LoopsToVectorize.clear();
ValueMap.clear();
LI = &getAnalysis<LoopInfoWrapperPass>().getLoopInfo();
SE = &getAnalysis<ScalarEvolutionWrapperPass>().getSE();
errs() << "==> See function with name " << F.getName() << "!\n";
collectLoops(F);
printLoops(F);
transformLoops();
return false;
}
void getAnalysisUsage(AnalysisUsage &AU) const {
AU.addRequired<LoopInfoWrapperPass>();
AU.addRequired<ScalarEvolutionWrapperPass>();
}
};
bool SimpleVectorizer::isInnermostLoop(Loop *L) {
auto innerLoops = L->getSubLoops();
return innerLoops.size() == 0;
}
void SimpleVectorizer::collectLoops(Function &F) {
for (auto &bb : F) {
auto loop = LI->getLoopFor(&bb);
if(loop != nullptr) {
// multiple basic blocks are part of same loop and hence check if
// loop is already added to the vector
bool exist = std::find(LoopsToVectorize.begin(), LoopsToVectorize.end(), loop) != LoopsToVectorize.end();
if (!exist) {
// need to vectorize only innermost loop
if(isInnermostLoop(loop)) {
LoopsToVectorize.push_back(loop);
}
}
}
}
}
void SimpleVectorizer::printLoops(Function &F) {
errs() << "==> Collected loops with iteration count (SCEV) => \n";
for(auto loop: LoopsToVectorize) {
loop->dump();
SE->getBackedgeTakenCount(loop)->dump();
}
}
void SimpleVectorizer::transformLoops() {
for(auto loop: LoopsToVectorize) {
auto body = getSingleBodyBlock(loop);
if(body) {
errs() << "==> Body of the loop is : \n";
body->dump();
for (auto &I : *body) {
if (LoadInst *LI = dyn_cast<LoadInst>(&I)) {
errs() << "==> Load Instruction in the loop : \n";
LI->dump();
// we have load from memory, ged directly the first operand
auto *operand = LI->getOperand(0);
auto *scev = (SCEVAddRecExpr *) SE->getSCEV(operand);
errs() << "==> SCEV for load instruction is : \n";
scev->dump();
if (scev->isAffine()) {
std::cout << "==> SCEV is Affine expression !\n";
} else {
std::cout << "==> SCEV is NOT Affine expression !\n";
}
}
}
}
}
}
BasicBlock *SimpleVectorizer::getSingleBodyBlock(Loop *L) {
auto blocks = L->getBlocks();
auto exitBlock = L->getExitBlock();
// assuming simple case where we have only two blocks i.e. body and exit block
for(auto block: blocks) {
if(block != exitBlock)
return block;
}
std::cout << "\n Error : Can't find body block! \n";
return nullptr;
}
bool SimpleVectorizer::isValidBody(Loop *L) {
// todo
return true;
}
bool SimpleVectorizer::isSimpleLoopStructure(Loop *L) {
// todo
return true;
}
Value *SimpleVectorizer::getNewValue(int Lane, Value *V) {
// todo
return nullptr;
}
Value *SimpleVectorizer::getIndVar(Loop *L) {
// todo
return nullptr;
}
void SimpleVectorizer::transformLoop(Loop *L) {
// todo
}
bool SimpleVectorizer::isValidLoop(Loop *L) {
// todo
return true;
}
const SCEV *SimpleVectorizer::getPointerSCEV(Instruction *Inst) {
// todo
return nullptr;
}
size_t SimpleVectorizer::getElementSize(Instruction *Inst) {
// todo
return 0;
}
bool SimpleVectorizer::isStrideOneAccess(Instruction *Inst, Loop *L) {
// todo
return true;
}
} // namespace
char SimpleVectorizer::ID = 0;
namespace llvm {
void initializeSimpleVectorizerPass(llvm::PassRegistry &);
}
class StaticInitializer {
public:
StaticInitializer() {
llvm::PassRegistry &Registry = *llvm::PassRegistry::getPassRegistry();
llvm::initializeSimpleVectorizerPass(Registry);
}
};
static StaticInitializer InitializeEverything;
INITIALIZE_PASS_BEGIN(SimpleVectorizer, "simple-vectorizer", "Simple Vectorizer", false, false);
INITIALIZE_PASS_DEPENDENCY(LoopInfoWrapperPass);
INITIALIZE_PASS_DEPENDENCY(ScalarEvolutionWrapperPass);
INITIALIZE_PASS_END(SimpleVectorizer, "simple-vectorizer", "Simple Vectorizer", false, false)
|
188693bed79f389b428eb532862e2d760e4c60af
|
8a4ad95d5a4f5aed907bcae6b99cdb6a9ed1adf1
|
/phys_corr/src/absorption_mult_scatt.hpp
|
53a97bebf25594426ac782df9d199dae559326d0
|
[] |
no_license
|
ornl-ndav/reduction
|
7586ce882786c243d6fb1e23b321220b2c09f2f4
|
97686db6259b42d69ff1667dbd5d577737b08c7b
|
refs/heads/master
| 2020-12-24T10:24:19.620137
| 2010-02-15T15:18:34
| 2010-02-15T15:18:34
| 73,083,062
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 1,785
|
hpp
|
absorption_mult_scatt.hpp
|
/*
* SNS Common Libraries
* A part of the SNS Analysis Software Suite.
*
* Spallation Neutron Source
* Oak Ridge National Laboratory, Oak Ridge TN.
*
*
* NOTICE
*
* For this software and its associated documentation, permission is granted
* to reproduce, prepare derivative works, and distribute copies to the public
* for any purpose and without fee.
*
* This material was prepared as an account of work sponsored by an agency of
* the United States Government. Neither the United States Government nor the
* United States Department of Energy, nor any of their employees, makes any
* warranty, express or implied, or assumes any legal liability or
* responsibility for the accuracy, completeness, or usefulness of any
* information, apparatus, product, or process disclosed, or represents that
* its use would not infringe privately owned rights.
*
*/
/**
* $Id$
*
* \file phys_corr/src/absorption_mult_scatt.hpp
*/
#ifndef _ABSORPTION_MULT_SCATT_HPP
#define _ABSORPTION_MULT_SCATT_HPP 1
#include "physcorr.hpp"
#include <stdexcept>
namespace PhysCorr
{
// 3.36
template <typename NumT>
std::string
absorption_mult_scatt(const Nessi::Vector<NumT> & axis_in,
const Nessi::Vector<NumT> & input,
const Nessi::Vector<NumT> & input_err2,
NumT pathlength,
NumT polar_angle,
Nessi::Vector<NumT> & output,
Nessi::Vector<NumT> & output_err2,
void *temp=NULL)
{
throw std::runtime_error("Function [absorption_mult_scatt] not implemented");
}
} // PhysCorr
#endif // _ABSORPTION_MULT_SCATT_HPP
|
10d0b2dac2af14fe6183e1ff2a3c124cbff52f96
|
52c0949315583ba8898694cceacfaafaeab6f902
|
/test/include/test_util/tpcc/schemas.h
|
484a26afc405e2ee417bd729e0b0cacd0634d25a
|
[
"MIT"
] |
permissive
|
cmu-db/noisepage
|
97093adcc9474419e063fdd97a5aa7a7ea6f3150
|
79276e68fe83322f1249e8a8be96bd63c583ae56
|
refs/heads/master
| 2023-08-29T05:51:04.628704
| 2021-11-05T14:12:08
| 2021-11-05T14:12:08
| 140,325,970
| 1,245
| 287
|
MIT
| 2022-11-08T02:06:48
| 2018-07-09T18:22:34
|
C++
|
UTF-8
|
C++
| false
| false
| 43,371
|
h
|
schemas.h
|
#pragma once
#include <utility>
#include <vector>
#include "catalog/catalog_defs.h"
#include "catalog/index_schema.h"
#include "catalog/schema.h"
#include "common/macros.h"
#include "parser/expression/column_value_expression.h"
#include "parser/expression/constant_value_expression.h"
#include "storage/index/index_defs.h"
namespace noisepage::tpcc {
/**
* Schemas is a utility class that defines all 9 table schemas and 8 index schemas according to section 1.3 of the TPC-C
* specification. It also defines 2 secondary indexes that improve query performance.
*/
class Schemas {
public:
Schemas() = delete;
/**
* @param oid_counter global OID counter to be incremented
* @return Warehouse table schema
*/
static catalog::Schema BuildWarehouseTableSchema() {
std::vector<catalog::Schema::Column> warehouse_columns;
warehouse_columns.reserve(NUM_WAREHOUSE_TABLE_COLS);
// 2*W unique IDs
warehouse_columns.emplace_back("w_id", execution::sql::SqlTypeId::TinyInt, false,
parser::ConstantValueExpression(execution::sql::SqlTypeId::TinyInt));
// variable text, size 10
warehouse_columns.emplace_back("w_name", execution::sql::SqlTypeId::Varchar, 10, false,
parser::ConstantValueExpression(execution::sql::SqlTypeId::Varchar));
// variable text, size 20
warehouse_columns.emplace_back("w_street_1", execution::sql::SqlTypeId::Varchar, 20, false,
parser::ConstantValueExpression(execution::sql::SqlTypeId::Varchar));
// variable text, size 20
warehouse_columns.emplace_back("w_street_2", execution::sql::SqlTypeId::Varchar, 20, false,
parser::ConstantValueExpression(execution::sql::SqlTypeId::Varchar));
// variable text, size 20
warehouse_columns.emplace_back("w_city", execution::sql::SqlTypeId::Varchar, 20, false,
parser::ConstantValueExpression(execution::sql::SqlTypeId::Varchar));
// fixed text, size 2
warehouse_columns.emplace_back("w_state", execution::sql::SqlTypeId::Varchar, 2, false,
parser::ConstantValueExpression(execution::sql::SqlTypeId::Varchar));
// fixed text, size 9
warehouse_columns.emplace_back("w_zip", execution::sql::SqlTypeId::Varchar, 9, false,
parser::ConstantValueExpression(execution::sql::SqlTypeId::Varchar));
// signed numeric(4,4)
warehouse_columns.emplace_back("w_tax", execution::sql::SqlTypeId::Double, false,
parser::ConstantValueExpression(execution::sql::SqlTypeId::Double));
// signed numeric(12,2)
warehouse_columns.emplace_back("w_ytd", execution::sql::SqlTypeId::Double, false,
parser::ConstantValueExpression(execution::sql::SqlTypeId::Double));
NOISEPAGE_ASSERT(warehouse_columns.size() == NUM_WAREHOUSE_TABLE_COLS,
"Wrong number of columns for Warehouse table schema.");
return catalog::Schema(warehouse_columns);
}
/**
* @param schema Warehouse table schema
* @param oid_counter global OID counter to be incremented
* @return Warehouse primary index schema
*/
static catalog::IndexSchema BuildWarehousePrimaryIndexSchema(const catalog::Schema &schema,
const storage::index::IndexType index_type,
const catalog::db_oid_t db_oid,
const catalog::table_oid_t table_oid) {
std::vector<catalog::IndexSchema::Column> warehouse_key_schema;
warehouse_key_schema.reserve(NUM_WAREHOUSE_PRIMARY_INDEX_COLS);
// Primary Key: W_ID
warehouse_key_schema.emplace_back(schema.GetColumn(0).Name(), schema.GetColumn(0).Type(),
schema.GetColumn(0).Nullable(),
parser::ColumnValueExpression(db_oid, table_oid, schema.GetColumn(0).Oid()));
NOISEPAGE_ASSERT(warehouse_key_schema.size() == NUM_WAREHOUSE_PRIMARY_INDEX_COLS,
"Wrong number of columns for Warehouse primary index schema.");
catalog::IndexOptions options;
return catalog::IndexSchema(warehouse_key_schema, index_type, true, true, false, true, options);
}
/**
* @param oid_counter global OID counter to be incremented
* @return District table schema
*/
static catalog::Schema BuildDistrictTableSchema() {
std::vector<catalog::Schema::Column> district_columns;
district_columns.reserve(NUM_DISTRICT_TABLE_COLS);
// 20 unique IDs
district_columns.emplace_back("d_id", execution::sql::SqlTypeId::TinyInt, false,
parser::ConstantValueExpression(execution::sql::SqlTypeId::TinyInt));
// 2*W unique IDs
district_columns.emplace_back("d_w_id", execution::sql::SqlTypeId::TinyInt, false,
parser::ConstantValueExpression(execution::sql::SqlTypeId::TinyInt));
// variable text, size 10
district_columns.emplace_back("d_name", execution::sql::SqlTypeId::Varchar, 10, false,
parser::ConstantValueExpression(execution::sql::SqlTypeId::Varchar));
// variable text, size 20
district_columns.emplace_back("d_street_1", execution::sql::SqlTypeId::Varchar, 20, false,
parser::ConstantValueExpression(execution::sql::SqlTypeId::Varchar));
// variable text, size 20
district_columns.emplace_back("d_street_2", execution::sql::SqlTypeId::Varchar, 20, false,
parser::ConstantValueExpression(execution::sql::SqlTypeId::Varchar));
// variable text, size 20
district_columns.emplace_back("d_city", execution::sql::SqlTypeId::Varchar, 20, false,
parser::ConstantValueExpression(execution::sql::SqlTypeId::Varchar));
// fixed text, size 2
district_columns.emplace_back("d_state", execution::sql::SqlTypeId::Varchar, 2, false,
parser::ConstantValueExpression(execution::sql::SqlTypeId::Varchar));
// fixed text, size 9
district_columns.emplace_back("d_zip", execution::sql::SqlTypeId::Varchar, 9, false,
parser::ConstantValueExpression(execution::sql::SqlTypeId::Varchar));
// signed numeric(4,4)
district_columns.emplace_back("d_tax", execution::sql::SqlTypeId::Double, false,
parser::ConstantValueExpression(execution::sql::SqlTypeId::Double));
// signed numeric(12,2)
district_columns.emplace_back("d_ytd", execution::sql::SqlTypeId::Double, false,
parser::ConstantValueExpression(execution::sql::SqlTypeId::Double));
// 10,000,000 unique IDs
district_columns.emplace_back("d_next_o_id", execution::sql::SqlTypeId::Integer, false,
parser::ConstantValueExpression(execution::sql::SqlTypeId::Integer));
NOISEPAGE_ASSERT(district_columns.size() == NUM_DISTRICT_TABLE_COLS,
"Wrong number of columns for District table schema.");
return catalog::Schema(district_columns);
}
/**
* @param schema District table schema
* @param oid_counter global OID counter to be incremented
* @return District primary index schema
*/
static catalog::IndexSchema BuildDistrictPrimaryIndexSchema(const catalog::Schema &schema,
const storage::index::IndexType index_type,
const catalog::db_oid_t db_oid,
const catalog::table_oid_t table_oid) {
std::vector<catalog::IndexSchema::Column> district_key_schema;
district_key_schema.reserve(NUM_DISTRICT_PRIMARY_INDEX_COLS);
// Primary Key: (D_W_ID, D_ID)
district_key_schema.emplace_back(schema.GetColumn(1).Name(), schema.GetColumn(1).Type(),
schema.GetColumn(1).Nullable(),
parser::ColumnValueExpression(db_oid, table_oid, schema.GetColumn(1).Oid()));
district_key_schema.emplace_back(schema.GetColumn(0).Name(), schema.GetColumn(0).Type(),
schema.GetColumn(0).Nullable(),
parser::ColumnValueExpression(db_oid, table_oid, schema.GetColumn(0).Oid()));
NOISEPAGE_ASSERT(district_key_schema.size() == NUM_DISTRICT_PRIMARY_INDEX_COLS,
"Wrong number of columns for District primary index schema.");
catalog::IndexOptions options;
return catalog::IndexSchema(district_key_schema, index_type, true, true, false, true, options);
}
/**
* @param oid_counter global OID counter to be incremented
* @return Customer table schema
*/
static catalog::Schema BuildCustomerTableSchema() {
std::vector<catalog::Schema::Column> customer_columns;
customer_columns.reserve(NUM_CUSTOMER_TABLE_COLS);
// 96,000 unique IDs
customer_columns.emplace_back("c_id", execution::sql::SqlTypeId::Integer, false,
parser::ConstantValueExpression(execution::sql::SqlTypeId::Integer));
// 20 unique IDs
customer_columns.emplace_back("c_d_id", execution::sql::SqlTypeId::TinyInt, false,
parser::ConstantValueExpression(execution::sql::SqlTypeId::TinyInt));
// 2*W unique IDs
customer_columns.emplace_back("c_w_id", execution::sql::SqlTypeId::TinyInt, false,
parser::ConstantValueExpression(execution::sql::SqlTypeId::TinyInt));
// variable text, size 16
customer_columns.emplace_back("c_first", execution::sql::SqlTypeId::Varchar, 16, false,
parser::ConstantValueExpression(execution::sql::SqlTypeId::Varchar));
// fixed text, size 2
customer_columns.emplace_back("c_middle", execution::sql::SqlTypeId::Varchar, 2, false,
parser::ConstantValueExpression(execution::sql::SqlTypeId::Varchar));
// variable text, size 16
customer_columns.emplace_back("c_last", execution::sql::SqlTypeId::Varchar, 16, false,
parser::ConstantValueExpression(execution::sql::SqlTypeId::Varchar));
// variable text, size 20
customer_columns.emplace_back("c_street_1", execution::sql::SqlTypeId::Varchar, 20, false,
parser::ConstantValueExpression(execution::sql::SqlTypeId::Varchar));
// variable text, size 20
customer_columns.emplace_back("c_street_2", execution::sql::SqlTypeId::Varchar, 20, false,
parser::ConstantValueExpression(execution::sql::SqlTypeId::Varchar));
// variable text, size 20
customer_columns.emplace_back("c_city", execution::sql::SqlTypeId::Varchar, 20, false,
parser::ConstantValueExpression(execution::sql::SqlTypeId::Varchar));
// fixed text, size 2
customer_columns.emplace_back("c_state", execution::sql::SqlTypeId::Varchar, 2, false,
parser::ConstantValueExpression(execution::sql::SqlTypeId::Varchar));
// fixed text, size 9
customer_columns.emplace_back("c_zip", execution::sql::SqlTypeId::Varchar, 9, false,
parser::ConstantValueExpression(execution::sql::SqlTypeId::Varchar));
// fixed text, size 16
customer_columns.emplace_back("c_phone", execution::sql::SqlTypeId::Varchar, 16, false,
parser::ConstantValueExpression(execution::sql::SqlTypeId::Varchar));
// date and time
customer_columns.emplace_back("c_since", execution::sql::SqlTypeId::Timestamp, false,
parser::ConstantValueExpression(execution::sql::SqlTypeId::Timestamp));
// fixed text, size 2
customer_columns.emplace_back("c_credit", execution::sql::SqlTypeId::Varchar, 2, false,
parser::ConstantValueExpression(execution::sql::SqlTypeId::Varchar));
// signed numeric(12,2)
customer_columns.emplace_back("c_credit_lim", execution::sql::SqlTypeId::Double, false,
parser::ConstantValueExpression(execution::sql::SqlTypeId::Double));
// signed numeric(4,4)
customer_columns.emplace_back("c_discount", execution::sql::SqlTypeId::Double, false,
parser::ConstantValueExpression(execution::sql::SqlTypeId::Double));
// signed numeric(12,2)
customer_columns.emplace_back("c_balance", execution::sql::SqlTypeId::Double, false,
parser::ConstantValueExpression(execution::sql::SqlTypeId::Double));
// signed numeric(12,2)
customer_columns.emplace_back("c_ytd_payment", execution::sql::SqlTypeId::Double, false,
parser::ConstantValueExpression(execution::sql::SqlTypeId::Double));
// numeric(4)
customer_columns.emplace_back("c_payment_cnt", execution::sql::SqlTypeId::SmallInt, false,
parser::ConstantValueExpression(execution::sql::SqlTypeId::SmallInt));
// numeric(4)
customer_columns.emplace_back("c_delivery_cnt", execution::sql::SqlTypeId::SmallInt, false,
parser::ConstantValueExpression(execution::sql::SqlTypeId::SmallInt));
// variable text, size 500
customer_columns.emplace_back("c_data", execution::sql::SqlTypeId::Varchar, 500, false,
parser::ConstantValueExpression(execution::sql::SqlTypeId::Varchar));
NOISEPAGE_ASSERT(customer_columns.size() == NUM_CUSTOMER_TABLE_COLS,
"Wrong number of columns for Customer table schema.");
return catalog::Schema(customer_columns);
}
/**
* @param schema Customer table schema
* @param oid_counter global OID counter to be incremented
* @return Customer primary index schema
*/
static catalog::IndexSchema BuildCustomerPrimaryIndexSchema(const catalog::Schema &schema,
const storage::index::IndexType index_type,
const catalog::db_oid_t db_oid,
const catalog::table_oid_t table_oid) {
std::vector<catalog::IndexSchema::Column> customer_key_schema;
customer_key_schema.reserve(NUM_CUSTOMER_PRIMARY_INDEX_COLS);
// Primary Key: (C_W_ID, C_D_ID, C_ID)
customer_key_schema.emplace_back(schema.GetColumn(2).Name(), schema.GetColumn(2).Type(),
schema.GetColumn(2).Nullable(),
parser::ColumnValueExpression(db_oid, table_oid, schema.GetColumn(2).Oid()));
customer_key_schema.emplace_back(schema.GetColumn(1).Name(), schema.GetColumn(1).Type(),
schema.GetColumn(1).Nullable(),
parser::ColumnValueExpression(db_oid, table_oid, schema.GetColumn(1).Oid()));
customer_key_schema.emplace_back(schema.GetColumn(0).Name(), schema.GetColumn(0).Type(),
schema.GetColumn(0).Nullable(),
parser::ColumnValueExpression(db_oid, table_oid, schema.GetColumn(0).Oid()));
NOISEPAGE_ASSERT(customer_key_schema.size() == NUM_CUSTOMER_PRIMARY_INDEX_COLS,
"Wrong number of columns for Customer primary index schema.");
catalog::IndexOptions options;
return catalog::IndexSchema(customer_key_schema, index_type, true, true, false, true, options);
}
/**
* @param schema Customer table schema
* @param oid_counter global OID counter to be incremented
* @return Customer secondary index schema
*/
static catalog::IndexSchema BuildCustomerSecondaryIndexSchema(const catalog::Schema &schema,
const storage::index::IndexType index_type,
const catalog::db_oid_t db_oid,
const catalog::table_oid_t table_oid) {
std::vector<catalog::IndexSchema::Column> customer_secondary_key_schema;
customer_secondary_key_schema.reserve(NUM_CUSTOMER_SECONDARY_INDEX_COLS);
// C_W_ID, C_D_ID, C_LAST for Order Status and Payment transactions
customer_secondary_key_schema.emplace_back(
schema.GetColumn(2).Name(), schema.GetColumn(2).Type(), schema.GetColumn(2).Nullable(),
parser::ColumnValueExpression(db_oid, table_oid, schema.GetColumn(2).Oid()));
customer_secondary_key_schema.emplace_back(
schema.GetColumn(1).Name(), schema.GetColumn(1).Type(), schema.GetColumn(1).Nullable(),
parser::ColumnValueExpression(db_oid, table_oid, schema.GetColumn(1).Oid()));
customer_secondary_key_schema.emplace_back(
schema.GetColumn(5).Name(), schema.GetColumn(5).Type(), schema.GetColumn(5).TypeModifier(),
schema.GetColumn(5).Nullable(), parser::ColumnValueExpression(db_oid, table_oid, schema.GetColumn(5).Oid()));
NOISEPAGE_ASSERT(customer_secondary_key_schema.size() == NUM_CUSTOMER_SECONDARY_INDEX_COLS,
"Wrong number of columns for Customer secondary index schema.");
catalog::IndexOptions options;
return catalog::IndexSchema(customer_secondary_key_schema, index_type, false, false, false, true, options);
}
/**
* @param oid_counter global OID counter to be incremented
* @return History table schema
*/
static catalog::Schema BuildHistoryTableSchema() {
std::vector<catalog::Schema::Column> history_columns;
history_columns.reserve(NUM_HISTORY_TABLE_COLS);
// 96,000 unique IDs
history_columns.emplace_back("h_c_id", execution::sql::SqlTypeId::Integer, false,
parser::ConstantValueExpression(execution::sql::SqlTypeId::Integer));
// 20 unique IDs
history_columns.emplace_back("h_c_d_id", execution::sql::SqlTypeId::TinyInt, false,
parser::ConstantValueExpression(execution::sql::SqlTypeId::TinyInt));
// 2*W unique IDs
history_columns.emplace_back("h_c_w_id", execution::sql::SqlTypeId::TinyInt, false,
parser::ConstantValueExpression(execution::sql::SqlTypeId::TinyInt));
// 20 unique IDs
history_columns.emplace_back("h_d_id", execution::sql::SqlTypeId::TinyInt, false,
parser::ConstantValueExpression(execution::sql::SqlTypeId::TinyInt));
// 2*W unique IDs
history_columns.emplace_back("h_w_id", execution::sql::SqlTypeId::TinyInt, false,
parser::ConstantValueExpression(execution::sql::SqlTypeId::TinyInt));
// date and time
history_columns.emplace_back("h_date", execution::sql::SqlTypeId::Timestamp, false,
parser::ConstantValueExpression(execution::sql::SqlTypeId::Timestamp));
// signed numeric(6,2)
history_columns.emplace_back("h_amount", execution::sql::SqlTypeId::Double, false,
parser::ConstantValueExpression(execution::sql::SqlTypeId::Double));
// variable text, size 24
history_columns.emplace_back("h_data", execution::sql::SqlTypeId::Varchar, 24, false,
parser::ConstantValueExpression(execution::sql::SqlTypeId::Varchar));
NOISEPAGE_ASSERT(history_columns.size() == NUM_HISTORY_TABLE_COLS,
"Wrong number of columns for History table schema.");
return catalog::Schema(history_columns);
}
/**
* @param oid_counter global OID counter to be incremented
* @return New Order table schema
*/
static catalog::Schema BuildNewOrderTableSchema() {
std::vector<catalog::Schema::Column> new_order_columns;
new_order_columns.reserve(NUM_NEW_ORDER_TABLE_COLS);
// 10,000,000 unique IDs
new_order_columns.emplace_back("no_o_id", execution::sql::SqlTypeId::Integer, false,
parser::ConstantValueExpression(execution::sql::SqlTypeId::Integer));
// 20 unique IDs
new_order_columns.emplace_back("no_d_id", execution::sql::SqlTypeId::TinyInt, false,
parser::ConstantValueExpression(execution::sql::SqlTypeId::TinyInt));
// 2*W unique IDs
new_order_columns.emplace_back("no_w_id", execution::sql::SqlTypeId::TinyInt, false,
parser::ConstantValueExpression(execution::sql::SqlTypeId::TinyInt));
NOISEPAGE_ASSERT(new_order_columns.size() == NUM_NEW_ORDER_TABLE_COLS,
"Wrong number of columns for New Order table schema.");
return catalog::Schema(new_order_columns);
}
/**
* @param schema New Order table schema
* @param oid_counter global OID counter to be incremented
* @return New Order primary index schema
*/
static catalog::IndexSchema BuildNewOrderPrimaryIndexSchema(const catalog::Schema &schema,
const storage::index::IndexType index_type,
const catalog::db_oid_t db_oid,
const catalog::table_oid_t table_oid) {
std::vector<catalog::IndexSchema::Column> new_order_key_schema;
new_order_key_schema.reserve(NUM_NEW_ORDER_PRIMARY_INDEX_COLS);
// Primary Key: (NO_W_ID, NO_D_ID, NO_O_ID)
new_order_key_schema.emplace_back(schema.GetColumn(2).Name(), schema.GetColumn(2).Type(),
schema.GetColumn(2).Nullable(),
parser::ColumnValueExpression(db_oid, table_oid, schema.GetColumn(2).Oid()));
new_order_key_schema.emplace_back(schema.GetColumn(1).Name(), schema.GetColumn(1).Type(),
schema.GetColumn(1).Nullable(),
parser::ColumnValueExpression(db_oid, table_oid, schema.GetColumn(1).Oid()));
new_order_key_schema.emplace_back(schema.GetColumn(0).Name(), schema.GetColumn(0).Type(),
schema.GetColumn(0).Nullable(),
parser::ColumnValueExpression(db_oid, table_oid, schema.GetColumn(0).Oid()));
NOISEPAGE_ASSERT(new_order_key_schema.size() == NUM_NEW_ORDER_PRIMARY_INDEX_COLS,
"Wrong number of columns for New Order primary index schema.");
catalog::IndexOptions options;
return catalog::IndexSchema(new_order_key_schema, index_type, true, true, false, true, options);
}
/**
* @param oid_counter global OID counter to be incremented
* @return Order table schema
*/
static catalog::Schema BuildOrderTableSchema() {
std::vector<catalog::Schema::Column> order_columns;
order_columns.reserve(NUM_ORDER_TABLE_COLS);
// 10,000,000 unique IDs
order_columns.emplace_back("o_id", execution::sql::SqlTypeId::Integer, false,
parser::ConstantValueExpression(execution::sql::SqlTypeId::Integer));
// 20 unique IDs
order_columns.emplace_back("o_d_id", execution::sql::SqlTypeId::TinyInt, false,
parser::ConstantValueExpression(execution::sql::SqlTypeId::TinyInt));
// 2*W unique IDs
order_columns.emplace_back("o_w_id", execution::sql::SqlTypeId::TinyInt, false,
parser::ConstantValueExpression(execution::sql::SqlTypeId::TinyInt));
// 96,000 unique IDs
order_columns.emplace_back("o_c_id", execution::sql::SqlTypeId::Integer, false,
parser::ConstantValueExpression(execution::sql::SqlTypeId::Integer));
// date and time
order_columns.emplace_back("o_entry_d", execution::sql::SqlTypeId::Timestamp, false,
parser::ConstantValueExpression(execution::sql::SqlTypeId::Timestamp));
// 10 unique IDs, or null
order_columns.emplace_back("o_carrier_id", execution::sql::SqlTypeId::TinyInt, true,
parser::ConstantValueExpression(execution::sql::SqlTypeId::TinyInt));
// numeric(2)
order_columns.emplace_back("o_ol_cnt", execution::sql::SqlTypeId::TinyInt, false,
parser::ConstantValueExpression(execution::sql::SqlTypeId::TinyInt));
// numeric(1)
order_columns.emplace_back("o_all_local", execution::sql::SqlTypeId::TinyInt, false,
parser::ConstantValueExpression(execution::sql::SqlTypeId::TinyInt));
NOISEPAGE_ASSERT(order_columns.size() == NUM_ORDER_TABLE_COLS, "Wrong number of columns for Order table schema.");
return catalog::Schema(order_columns);
}
/**
* @param schema Order table schema
* @param oid_counter global OID counter to be incremented
* @return Order primary index schema
*/
static catalog::IndexSchema BuildOrderPrimaryIndexSchema(const catalog::Schema &schema,
const storage::index::IndexType index_type,
const catalog::db_oid_t db_oid,
const catalog::table_oid_t table_oid) {
std::vector<catalog::IndexSchema::Column> order_key_schema;
order_key_schema.reserve(NUM_ORDER_PRIMARY_INDEX_COLS);
// Primary Key: (O_W_ID, O_D_ID, O_ID)
order_key_schema.emplace_back(schema.GetColumn(2).Name(), schema.GetColumn(2).Type(),
schema.GetColumn(2).Nullable(),
parser::ColumnValueExpression(db_oid, table_oid, schema.GetColumn(2).Oid()));
order_key_schema.emplace_back(schema.GetColumn(1).Name(), schema.GetColumn(1).Type(),
schema.GetColumn(1).Nullable(),
parser::ColumnValueExpression(db_oid, table_oid, schema.GetColumn(1).Oid()));
order_key_schema.emplace_back(schema.GetColumn(0).Name(), schema.GetColumn(0).Type(),
schema.GetColumn(0).Nullable(),
parser::ColumnValueExpression(db_oid, table_oid, schema.GetColumn(0).Oid()));
NOISEPAGE_ASSERT(order_key_schema.size() == NUM_ORDER_PRIMARY_INDEX_COLS,
"Wrong number of columns for Order primary index schema.");
catalog::IndexOptions options;
return catalog::IndexSchema(order_key_schema, index_type, true, true, false, true, options);
}
/**
* @param schema Order table schema
* @param oid_counter global OID counter to be incremented
* @return Order secondary index schema
*/
static catalog::IndexSchema BuildOrderSecondaryIndexSchema(const catalog::Schema &schema,
const storage::index::IndexType index_type,
const catalog::db_oid_t db_oid,
const catalog::table_oid_t table_oid) {
std::vector<catalog::IndexSchema::Column> order_secondary_key_schema;
order_secondary_key_schema.reserve(NUM_ORDER_SECONDARY_INDEX_COLS);
// O_W_ID, O_D_ID, O_C_ID, O_ID for Order Status transaction
order_secondary_key_schema.emplace_back(
schema.GetColumn(2).Name(), schema.GetColumn(2).Type(), schema.GetColumn(2).Nullable(),
parser::ColumnValueExpression(db_oid, table_oid, schema.GetColumn(2).Oid()));
order_secondary_key_schema.emplace_back(
schema.GetColumn(1).Name(), schema.GetColumn(1).Type(), schema.GetColumn(1).Nullable(),
parser::ColumnValueExpression(db_oid, table_oid, schema.GetColumn(1).Oid()));
order_secondary_key_schema.emplace_back(
schema.GetColumn(3).Name(), schema.GetColumn(3).Type(), schema.GetColumn(3).Nullable(),
parser::ColumnValueExpression(db_oid, table_oid, schema.GetColumn(3).Oid()));
order_secondary_key_schema.emplace_back(
schema.GetColumn(0).Name(), schema.GetColumn(0).Type(), schema.GetColumn(0).Nullable(),
parser::ColumnValueExpression(db_oid, table_oid, schema.GetColumn(0).Oid()));
NOISEPAGE_ASSERT(order_secondary_key_schema.size() == NUM_ORDER_SECONDARY_INDEX_COLS,
"Wrong number of columns for Order secondary index schema.");
catalog::IndexOptions options;
return catalog::IndexSchema(order_secondary_key_schema, index_type, true, false, false, true, options);
}
/**
* @param oid_counter global OID counter to be incremented
* @return Order Line table schema
*/
static catalog::Schema BuildOrderLineTableSchema() {
std::vector<catalog::Schema::Column> order_line_columns;
order_line_columns.reserve(NUM_ORDER_LINE_TABLE_COLS);
// 10,000,000 unique IDs
order_line_columns.emplace_back("ol_o_id", execution::sql::SqlTypeId::Integer, false,
parser::ConstantValueExpression(execution::sql::SqlTypeId::Integer));
// 20 unique IDs
order_line_columns.emplace_back("ol_d_id", execution::sql::SqlTypeId::TinyInt, false,
parser::ConstantValueExpression(execution::sql::SqlTypeId::TinyInt));
// 2*W unique IDs
order_line_columns.emplace_back("ol_w_id", execution::sql::SqlTypeId::TinyInt, false,
parser::ConstantValueExpression(execution::sql::SqlTypeId::TinyInt));
// 15 unique IDs
order_line_columns.emplace_back("ol_number", execution::sql::SqlTypeId::TinyInt, false,
parser::ConstantValueExpression(execution::sql::SqlTypeId::TinyInt));
// 200,000 unique IDs
order_line_columns.emplace_back("ol_i_id", execution::sql::SqlTypeId::Integer, false,
parser::ConstantValueExpression(execution::sql::SqlTypeId::Integer));
// 2*W unique IDs
order_line_columns.emplace_back("ol_supply_w_id", execution::sql::SqlTypeId::TinyInt, false,
parser::ConstantValueExpression(execution::sql::SqlTypeId::TinyInt));
// date and time, or null
order_line_columns.emplace_back("ol_delivery_d", execution::sql::SqlTypeId::Timestamp, true,
parser::ConstantValueExpression(execution::sql::SqlTypeId::Timestamp));
// numeric(2)
order_line_columns.emplace_back("ol_quantity", execution::sql::SqlTypeId::TinyInt, false,
parser::ConstantValueExpression(execution::sql::SqlTypeId::TinyInt));
// signed numeric(6,2)
order_line_columns.emplace_back("ol_amount", execution::sql::SqlTypeId::Double, false,
parser::ConstantValueExpression(execution::sql::SqlTypeId::Double));
// fixed text, size 24
order_line_columns.emplace_back("ol_dist_info", execution::sql::SqlTypeId::Varchar, 24, false,
parser::ConstantValueExpression(execution::sql::SqlTypeId::Varchar));
NOISEPAGE_ASSERT(order_line_columns.size() == NUM_ORDER_LINE_TABLE_COLS,
"Wrong number of columns for Order Line table schema.");
return catalog::Schema(order_line_columns);
}
/**
* @param schema Order Line table schema
* @param oid_counter global OID counter to be incremented
* @return Order Line primary index schema
*/
static catalog::IndexSchema BuildOrderLinePrimaryIndexSchema(const catalog::Schema &schema,
const storage::index::IndexType index_type,
const catalog::db_oid_t db_oid,
const catalog::table_oid_t table_oid) {
std::vector<catalog::IndexSchema::Column> order_line_key_schema;
order_line_key_schema.reserve(NUM_ORDER_LINE_PRIMARY_INDEX_COLS);
// Primary Key: (OL_W_ID, OL_D_ID, OL_O_ID, OL_NUMBER)
order_line_key_schema.emplace_back(schema.GetColumn(2).Name(), schema.GetColumn(2).Type(),
schema.GetColumn(2).Nullable(),
parser::ColumnValueExpression(db_oid, table_oid, schema.GetColumn(2).Oid()));
order_line_key_schema.emplace_back(schema.GetColumn(1).Name(), schema.GetColumn(1).Type(),
schema.GetColumn(1).Nullable(),
parser::ColumnValueExpression(db_oid, table_oid, schema.GetColumn(1).Oid()));
order_line_key_schema.emplace_back(schema.GetColumn(0).Name(), schema.GetColumn(0).Type(),
schema.GetColumn(0).Nullable(),
parser::ColumnValueExpression(db_oid, table_oid, schema.GetColumn(0).Oid()));
order_line_key_schema.emplace_back(schema.GetColumn(3).Name(), schema.GetColumn(3).Type(),
schema.GetColumn(3).Nullable(),
parser::ColumnValueExpression(db_oid, table_oid, schema.GetColumn(3).Oid()));
NOISEPAGE_ASSERT(order_line_key_schema.size() == NUM_ORDER_LINE_PRIMARY_INDEX_COLS,
"Wrong number of columns for Order Line key schema.");
catalog::IndexOptions options;
return catalog::IndexSchema(order_line_key_schema, index_type, true, true, false, true, options);
}
/**
* @param oid_counter global OID counter to be incremented
* @return Item table schema
*/
static catalog::Schema BuildItemTableSchema() {
std::vector<catalog::Schema::Column> item_columns;
item_columns.reserve(NUM_ITEM_TABLE_COLS);
// 200,000 unique IDs
item_columns.emplace_back("i_id", execution::sql::SqlTypeId::Integer, false,
parser::ConstantValueExpression(execution::sql::SqlTypeId::Integer));
// 200,000 unique IDs
item_columns.emplace_back("i_im_id", execution::sql::SqlTypeId::Integer, false,
parser::ConstantValueExpression(execution::sql::SqlTypeId::Integer));
// variable text, size 24
item_columns.emplace_back("i_name", execution::sql::SqlTypeId::Varchar, 24, false,
parser::ConstantValueExpression(execution::sql::SqlTypeId::Varchar));
// numeric(5,2)
item_columns.emplace_back("i_price", execution::sql::SqlTypeId::Double, false,
parser::ConstantValueExpression(execution::sql::SqlTypeId::Double));
// variable text, size 50
item_columns.emplace_back("i_data", execution::sql::SqlTypeId::Varchar, 50, false,
parser::ConstantValueExpression(execution::sql::SqlTypeId::Varchar));
NOISEPAGE_ASSERT(item_columns.size() == NUM_ITEM_TABLE_COLS, "Wrong number of columns for Item table schema.");
return catalog::Schema(item_columns);
}
/**
* @param schema Item table schema
* @param oid_counter global OID counter to be incremented
* @return Item primary index schema
*/
static catalog::IndexSchema BuildItemPrimaryIndexSchema(const catalog::Schema &schema,
const storage::index::IndexType index_type,
const catalog::db_oid_t db_oid,
const catalog::table_oid_t table_oid) {
std::vector<catalog::IndexSchema::Column> item_key_schema;
item_key_schema.reserve(NUM_ITEM_PRIMARY_INDEX_COLS);
// Primary Key: I_ID
item_key_schema.emplace_back(schema.GetColumn(0).Name(), schema.GetColumn(0).Type(), schema.GetColumn(0).Nullable(),
parser::ColumnValueExpression(db_oid, table_oid, schema.GetColumn(0).Oid()));
NOISEPAGE_ASSERT(item_key_schema.size() == NUM_ITEM_PRIMARY_INDEX_COLS,
"Wrong number of columns for Item primary index schema.");
catalog::IndexOptions options;
return catalog::IndexSchema(item_key_schema, index_type, true, true, false, true, options);
}
/**
* @param oid_counter global OID counter to be incremented
* @return Stock table schema
*/
static catalog::Schema BuildStockTableSchema() {
std::vector<catalog::Schema::Column> stock_columns;
stock_columns.reserve(NUM_STOCK_TABLE_COLS);
// 200,000 unique IDs
stock_columns.emplace_back("s_i_id", execution::sql::SqlTypeId::Integer, false,
parser::ConstantValueExpression(execution::sql::SqlTypeId::Integer));
// 2*W unique IDs
stock_columns.emplace_back("s_w_id", execution::sql::SqlTypeId::TinyInt, false,
parser::ConstantValueExpression(execution::sql::SqlTypeId::TinyInt));
// signed numeric(4)
stock_columns.emplace_back("s_quantity", execution::sql::SqlTypeId::SmallInt, false,
parser::ConstantValueExpression(execution::sql::SqlTypeId::SmallInt));
// fixed text, size 24
stock_columns.emplace_back("s_dist_01", execution::sql::SqlTypeId::Varchar, 24, false,
parser::ConstantValueExpression(execution::sql::SqlTypeId::Varchar));
// fixed text, size 24
stock_columns.emplace_back("s_dist_02", execution::sql::SqlTypeId::Varchar, 24, false,
parser::ConstantValueExpression(execution::sql::SqlTypeId::Varchar));
// fixed text, size 24
stock_columns.emplace_back("s_dist_03", execution::sql::SqlTypeId::Varchar, 24, false,
parser::ConstantValueExpression(execution::sql::SqlTypeId::Varchar));
// fixed text, size 24
stock_columns.emplace_back("s_dist_04", execution::sql::SqlTypeId::Varchar, 24, false,
parser::ConstantValueExpression(execution::sql::SqlTypeId::Varchar));
// fixed text, size 24
stock_columns.emplace_back("s_dist_05", execution::sql::SqlTypeId::Varchar, 24, false,
parser::ConstantValueExpression(execution::sql::SqlTypeId::Varchar));
// fixed text, size 24
stock_columns.emplace_back("s_dist_06", execution::sql::SqlTypeId::Varchar, 24, false,
parser::ConstantValueExpression(execution::sql::SqlTypeId::Varchar));
// fixed text, size 24
stock_columns.emplace_back("s_dist_07", execution::sql::SqlTypeId::Varchar, 24, false,
parser::ConstantValueExpression(execution::sql::SqlTypeId::Varchar));
// fixed text, size 24
stock_columns.emplace_back("s_dist_08", execution::sql::SqlTypeId::Varchar, 24, false,
parser::ConstantValueExpression(execution::sql::SqlTypeId::Varchar));
// fixed text, size 24
stock_columns.emplace_back("s_dist_09", execution::sql::SqlTypeId::Varchar, 24, false,
parser::ConstantValueExpression(execution::sql::SqlTypeId::Varchar));
// fixed text, size 24
stock_columns.emplace_back("s_dist_10", execution::sql::SqlTypeId::Varchar, 24, false,
parser::ConstantValueExpression(execution::sql::SqlTypeId::Varchar));
// numeric(8)
stock_columns.emplace_back("s_ytd", execution::sql::SqlTypeId::Integer, false,
parser::ConstantValueExpression(execution::sql::SqlTypeId::Integer));
// numeric(4)
stock_columns.emplace_back("s_order_cnt", execution::sql::SqlTypeId::SmallInt, false,
parser::ConstantValueExpression(execution::sql::SqlTypeId::SmallInt));
// numeric(4)
stock_columns.emplace_back("s_remote_cnt", execution::sql::SqlTypeId::SmallInt, false,
parser::ConstantValueExpression(execution::sql::SqlTypeId::SmallInt));
// variable text, size 50
stock_columns.emplace_back("s_data", execution::sql::SqlTypeId::Varchar, 50, false,
parser::ConstantValueExpression(execution::sql::SqlTypeId::Varchar));
NOISEPAGE_ASSERT(stock_columns.size() == NUM_STOCK_TABLE_COLS, "Wrong number of columns for Stock table schema.");
return catalog::Schema(stock_columns);
}
/**
* @param schema Stock table schema
* @param oid_counter global OID counter to be incremented
* @return Stock primary index schema
*/
static catalog::IndexSchema BuildStockPrimaryIndexSchema(const catalog::Schema &schema,
const storage::index::IndexType index_type,
const catalog::db_oid_t db_oid,
const catalog::table_oid_t table_oid) {
std::vector<catalog::IndexSchema::Column> stock_key_schema;
stock_key_schema.reserve(NUM_STOCK_PRIMARY_INDEX_COLS);
// Primary Key: (S_W_ID, S_I_ID)
stock_key_schema.emplace_back(schema.GetColumn(1).Name(), schema.GetColumn(1).Type(),
schema.GetColumn(1).Nullable(),
parser::ColumnValueExpression(db_oid, table_oid, schema.GetColumn(1).Oid()));
stock_key_schema.emplace_back(schema.GetColumn(0).Name(), schema.GetColumn(0).Type(),
schema.GetColumn(0).Nullable(),
parser::ColumnValueExpression(db_oid, table_oid, schema.GetColumn(0).Oid()));
NOISEPAGE_ASSERT(stock_key_schema.size() == NUM_STOCK_PRIMARY_INDEX_COLS,
"Wrong number of columns for Stock primary index schema.");
catalog::IndexOptions options;
return catalog::IndexSchema(stock_key_schema, index_type, true, true, false, true, options);
}
private:
// The values below are just to sanity check the schema functions
static constexpr uint8_t NUM_WAREHOUSE_TABLE_COLS = 9;
static constexpr uint8_t NUM_DISTRICT_TABLE_COLS = 11;
static constexpr uint8_t NUM_CUSTOMER_TABLE_COLS = 21;
static constexpr uint8_t NUM_HISTORY_TABLE_COLS = 8;
static constexpr uint8_t NUM_NEW_ORDER_TABLE_COLS = 3;
static constexpr uint8_t NUM_ORDER_TABLE_COLS = 8;
static constexpr uint8_t NUM_ORDER_LINE_TABLE_COLS = 10;
static constexpr uint8_t NUM_ITEM_TABLE_COLS = 5;
static constexpr uint8_t NUM_STOCK_TABLE_COLS = 17;
static constexpr uint8_t NUM_WAREHOUSE_PRIMARY_INDEX_COLS = 1;
static constexpr uint8_t NUM_DISTRICT_PRIMARY_INDEX_COLS = 2;
static constexpr uint8_t NUM_CUSTOMER_PRIMARY_INDEX_COLS = 3;
static constexpr uint8_t NUM_CUSTOMER_SECONDARY_INDEX_COLS = 3;
static constexpr uint8_t NUM_NEW_ORDER_PRIMARY_INDEX_COLS = 3;
static constexpr uint8_t NUM_ORDER_PRIMARY_INDEX_COLS = 3;
static constexpr uint8_t NUM_ORDER_SECONDARY_INDEX_COLS = 4;
static constexpr uint8_t NUM_ORDER_LINE_PRIMARY_INDEX_COLS = 4;
static constexpr uint8_t NUM_ITEM_PRIMARY_INDEX_COLS = 1;
static constexpr uint8_t NUM_STOCK_PRIMARY_INDEX_COLS = 2;
};
} // namespace noisepage::tpcc
|
8f4cf4689411d5b4b8e9d0a6042b97c6de808c86
|
9ab182e1b6c57d281a618a65f9308e9d453835ea
|
/CS1C-Project-2-Bulk-Club-prebillybuild/adminpage.cpp
|
c4137ffa6d6c113e9050cd012741887d0daba003
|
[] |
no_license
|
mattjang1101/CS1C-Project-2-Bulk-Club
|
72746d51218f13df9ffd4cff1fb5668a470032c4
|
16b9fefdfade85144830ad45ee98ad5b25555b4f
|
refs/heads/master
| 2020-09-06T21:09:14.893336
| 2020-03-21T23:42:26
| 2020-03-21T23:42:26
| 220,552,845
| 0
| 1
| null | 2019-12-09T18:00:36
| 2019-11-08T21:48:08
|
C++
|
UTF-8
|
C++
| false
| false
| 16,000
|
cpp
|
adminpage.cpp
|
#include "adminpage.h"
#include "yesno.h"
#include "QDebug"
#include <iostream>
#include <string>
AdminPage::AdminPage(QWidget *parent) :
QMainWindow(parent),
ui(new Ui::AdminPage)
{
ui->setupUi(this);
// Sets default page to be the home page
ui->stackedWidget->setCurrentWidget(ui->adminHomePage);
setupConnections();
// Sets the items for item combo box
ShowItemsInComboBox(databaseObj.loadItemsOnly());
ShowQuantityInComboBox(); // sets the number of quantities for qty combo box
ShowCustomerTypeInComboBox(); // sets the types of customers in customer combo box
}
AdminPage::~AdminPage()
{
delete ui;
}
void AdminPage::setupConnections()
{
connect(ui->addCustomersBttn, &QPushButton::clicked, this, &AdminPage::ChangeToaddCustomers);
connect(ui->addItemBttn,&QPushButton::clicked, this, &AdminPage::ChangeToaddItem);
connect(ui->createPurchasesBtn, &QPushButton::clicked, this, &AdminPage::ChangeToCreatePurchasesPage);
connect(ui->createPurchaseBackBtn, &QPushButton::clicked, this, &AdminPage::ChangeToAdminHomePage);
}
void AdminPage::ChangeToaddCustomers()
{
ui->stackedWidget->setCurrentWidget(ui->addCustomer);
}
void AdminPage::ChangeToaddItem()
{
ui->stackedWidget->setCurrentWidget(ui->addItem);
}
void AdminPage::on_deleteCustomersBttn_clicked()
{
QSqlQuery data;
QString deleteCustomer = QInputDialog::getText(this, tr("QInputDialog::getText()"),
tr("Customer name:"), QLineEdit::Normal,
QDir::home().dirName());
data.prepare("DELETE FROM Customers WHERE name == '"+deleteCustomer+"'");
if (data.exec() == false)
{
QMessageBox::about(this, "", "this customer does not exist in the database");
}
data.exec();
if(data.exec())
{
QMessageBox::about(this, "", "The customer was deleted. double check if error occured");
}
/*else
{
QMessageBox::about(this, "", "This customer does not exist in the database.");
}*/
}
void AdminPage::on_addButton_clicked()
{
QSqlQuery data;
QString name = ui->addName ->text();
QString ID = ui->addID->text();
QString customerType = ui->typeComboBox_2->currentText();
QString expDay = ui->dayComboBox_2->currentText();
QString expMonth = ui->monthComboBox_2->currentText();
QString expYear = ui->yearComboBox_2->currentText();
bool check = false;
for (int i = 0; i < ID.length(); i++)
{
if(ID[i] != '0' && ID[i] != '1' && ID[i] != '2' && ID[i] != '3' && ID[i] != '4'
&& ID[i] != '5' && ID[i] != '6' && ID[i] != '7' && ID[i] != '8' && ID[i] != '9')
{
check = true;
break;
}
}
if(check == true)
{
QMessageBox::about(this, "Invalid Entry", "There were invalid inputs for your ID. Please enter only numerals (0-9)");
ui->stackedWidget->setCurrentWidget(ui->adminHomePage);
return;
}
data.prepare("INSERT INTO Customers (name, ID, type, expMonth, expDay, expYear) VALUES('"+name+"', '"+ID+"', '"+customerType+"', '"+expMonth+"', '"+expDay+"', '"+expYear+"')");
if(data.exec())
{
QMessageBox::about(this, "", "The Customer was added. be sure to double check if added correctly");
}
else
{
QMessageBox::about(this, "Error", "Database not found. double check connection");
}
ui->stackedWidget->setCurrentWidget(ui->adminHomePage);
}
void AdminPage::on_cancelButton_clicked()
{
ui->stackedWidget->setCurrentWidget(ui->adminHomePage);
}
void AdminPage::on_addItemConfirm_clicked()
{
QSqlQuery data;
QString itemName = ui->addItemName->text();
QString itemPrice = ui->addItemPrice->text();
QString itemQuantity = ui->addItemQty->text();
bool check1 = false;
bool check2 = false;
int count = 0;
for (int i = 0; i < itemPrice.length(); i++)\
{
if(itemPrice[i] != '0' && itemPrice[i] != '1' && itemPrice[i] != '2' && itemPrice[i] != '3'
&& itemPrice[i] != '4' && itemPrice[i] != '5'
&& itemPrice[i] != '6' && itemPrice[i] != '7'
&& itemPrice[i] != '8' && itemPrice[i] != '9' && itemPrice[i] != '.')
{
check1 = true;
break;
}
if(itemPrice[i] == '.')
{
count++;
}
}
for (int i = 0; i < itemQuantity.length(); i++)\
{
if(itemQuantity[i] != '0' && itemQuantity[i] != '1' && itemQuantity[i] != '2' && itemQuantity[i] != '3'
&& itemQuantity[i] != '4' && itemQuantity[i] != '5'
&& itemQuantity[i] != '6' && itemQuantity[i] != '7'
&& itemQuantity[i] != '8' && itemQuantity[i] != '9')
{
check2 = true;
break;
}
}
if(check1 == true)
{
QMessageBox::about(this, "Invalid Input", "There was an invalid input. Please use only Numerals(0-9) and the . ");
ui->stackedWidget->setCurrentWidget(ui->adminHomePage);
return;
}
data.prepare("INSERT INTO inventory (item, price, quantity) VALUES ('"+itemName+"', '"+itemPrice+"', '"+itemQuantity+"')");
if(check2 == true)
{
QMessageBox::about(this, "Invalid Input", "There was an invalid input. Please use only Numerals(0-9) and the . ");
ui->stackedWidget->setCurrentWidget(ui->adminHomePage);
return;
}
if(check1 == true && check2 == true)
{
QMessageBox::about(this, "Invalid Input", "both itemName and ItemQuantity have invalid inputs\nPlease use numerals and a . for the price\nPlease use only numerals for the quantity");
ui->stackedWidget->setCurrentWidget(ui->adminHomePage);
return;
}
if (count > 1)
{
QMessageBox::about(this,"", "Invalid input. Use only one . for price");
ui->stackedWidget->setCurrentWidget(ui->adminHomePage);
return;
}
if(data.exec())
{
QMessageBox::about(this, "", "The item was added. double check if error occured");
}
else
{
QMessageBox::about(this, "Error", "Database not found double check path to database");
}
ui->stackedWidget->setCurrentWidget(ui->adminHomePage);
}
void AdminPage::on_cancelButton_3_clicked()
{
ui->stackedWidget->setCurrentWidget(ui->adminHomePage);
}
void AdminPage::on_deleteItemBttn_clicked()
{
QSqlQuery data;
QString deleteItem = QInputDialog::getText(this, tr("QInputDialog::getText()"),
tr("Item to be deleted:"), QLineEdit::Normal,
QDir::home().dirName());
data.prepare("DELETE FROM inventory WHERE item == '"+deleteItem+"'");
if (data.exec() == false)
{
QMessageBox::about(this, "", "this item does not exist in the database");
}
data.exec();
if(data.exec() == true)
{
QMessageBox::about(this, "", "The item was deleted. double check if error occured");
}
/*{
QMessageBox::about(this, "", "This item does not exist in the database.");
}*/
}
void AdminPage::on_addCustomersBttn_clicked()
{
ui->stackedWidget->setCurrentWidget(ui->addCustomer);
}
void AdminPage::on_addItemBttn_clicked()
{
ui->stackedWidget->setCurrentWidget(ui->addItem);
}
void AdminPage::on_Close_clicked()
{
this->close();
}
void AdminPage::ChangeToAdminHomePage() // changes to admin home page
{
ui->stackedWidget->setCurrentWidget(ui->adminHomePage);
}
// -------------------------STORY 7 CODE-------------------------------//
void AdminPage::ChangeToCreatePurchasesPage() // changes to create purchases page
{
ui->stackedWidget->setCurrentWidget(ui->CreatePurchasesPage);
QLineEdit *lineEdit = new QLineEdit; // Item is used for item combo box
lineEdit->setPlaceholderText("SELECT ITEMS"); // Sets default date for combobox(will turn into lineedit)
// Changes item combo box to be a line edit in order to set the current text to be empty
ui->pickItemComboBox->setLineEdit(lineEdit);
ui->pickItemComboBox->setCurrentText("");
// Clears all the line edits
ui->addNameLineEdit->clear();
ui->addIdLineEdit->clear();
ui->addMonthLineEdit->clear();
ui->addDayLineEdit->clear();
ui->addYearLineEdit->clear();
// sets new place holder/line edit text for quantity combo box
lineEdit = new QLineEdit;
lineEdit->setPlaceholderText("SELECT QTY");
ui->pickQtyLComboBox->setLineEdit(lineEdit);
ui->pickQtyLComboBox->setCurrentText("");
// sets new place holder/line edit text for customer combo box
lineEdit = new QLineEdit;
lineEdit->setPlaceholderText("SELECT TYPE");
ui->customerTypeComboBox->setLineEdit(lineEdit);
ui->customerTypeComboBox->setCurrentText("");
}
void AdminPage::ShowItemsInComboBox(QSqlQueryModel *model) // sets the item combo box to be the item values from inventory table
{
ui->pickItemComboBox->setModel(model);
}
// Sets the quantity combo box to be quantities: 1-100
void AdminPage::ShowQuantityInComboBox()
{
int i; // used for quantity items
for(i = 1; i <=100; i++)
{
ui->pickQtyLComboBox->addItem(QString::number(i));
}
}
// Sets the types of customers in customers combo box
void AdminPage::ShowCustomerTypeInComboBox()
{
QString regular = "Regular";
QString executive = "Executive";
ui->customerTypeComboBox->addItem(regular);
ui->customerTypeComboBox->addItem(executive);
}
// Story 7 slot, will allow purchases to happen after admin clicks on the button
void AdminPage::on_createPurchasePushBtn_clicked()
{
QString name, item, type, id;
int month, day, year, quantity;
bool valid = true;
QIntValidator v(100000, 200000, this); // Used for checking id from line edit, will only accept id between 100000 to 200000
int pos = 0;
// INPUT - Obtains input from line edits/combo boxes from each variables' respective values
name = ui->addNameLineEdit->text();
item = ui->pickItemComboBox->currentText();
month = ui->addMonthLineEdit->text().toInt();
day = ui->addDayLineEdit->text().toInt();
year = ui->addYearLineEdit->text().toInt();
quantity = ui->pickQtyLComboBox->currentText().toInt();
type = ui->customerTypeComboBox->currentText();
id = ui->addIdLineEdit->text();
// PROCESSING - Checks for valid conditions
// Validates id, if the value entered does not meet the specifications, then will set valid to false
if(!v.validate(id, pos))
{
valid = false;
}
// First check if any of the line edits/combo boxes are empty, if they are then valid is false
if(name == "" || item == "" || type == "" || ui->addMonthLineEdit->text() == "" ||
ui->addDayLineEdit->text() == "" || ui->addYearLineEdit->text() == "" ||
ui->pickQtyLComboBox->currentText() == "" || id == "")
{
valid = false;
}
// Checks for valid month, if valid month, then will check for valid days of each month
if(month < 1 || month > 12)
{
valid = false;
}
else
{
if(month == 2)
{
if(day < 1 || day > 28)
{
valid = false;
}
}
else if(month % 2 == 0)
{
if(day < 1 || day > 31)
{
valid = false;
}
}
else
{
if(day < 1 || day > 30)
{
valid = false;
}
}
}
// Checks for valid year
if(year < 2019 || year > 2023)
{
valid = false;
}
// If the final value of valid is false, then it will display an error message
// Otherwise, the new customer purchase will be stored in the database along with a successful message
if(valid == false)
{
QMessageBox::warning(this, "Invalid", "Please input valid information");
}
else
{
databaseObj.AddToCustomersTable(name, id, type, month, day, year); // adds new info to customers table
databaseObj.AddToDailySalesReport(id, item, quantity); // adds new info to dailySalesReport table
QMessageBox::information(this, "Success", "Purchase has been created");
AdminPage::ChangeToAdminHomePage();
}
}
//---------------------END of story 7 code ----------------------------------------//
void AdminPage::on_ViewCustomers_clicked()
{
QSqlQueryModel* modal=new QSqlQueryModel();
QSqlQuery* view=new QSqlQuery();
view->prepare("SELECT * FROM Customers ORDER by name ASC");
view->exec();
modal->setQuery(*view);
ui->tableView->setModel(modal);
ui->tableView->setColumnWidth(0, 120);
}
void AdminPage::on_ChangeMembership_clicked()
{
QSqlQuery qry;
yesno yesno;
bool confirm = false;
QString search = QInputDialog::getText(this, tr("QInputDialog::getText()"),
tr("Customer name:"), QLineEdit::Normal);
qDebug() << search;
qry.prepare("SELECT name, type FROM Customers WHERE name == '" + search + "'");
QString data;
data = qry.exec();
qry.last();
int rowCount = qry.at() + 1;
qDebug() << "getNoteCounts = " << rowCount;
if (rowCount > 0)
{
yesno.setModal(true);
yesno.exec();
qDebug() << qry.record().count();
confirm=yesno.getData();
if(confirm)
{
QSqlQuery updateExe;
QSqlQuery updateReg;
QSqlQuery find;
qDebug() << "confirm";
// std::string custType = "";
// QString aType;
// while (qry.next())
// {
// QSqlRecord record = qry.record();
// aType = qry.record().value((type).toString();
// qDebug() << custType;
// qDebug() << "Type : " << record.value(type).toString();
// }
updateExe.prepare("update customers set type = 'Executive' where name = '" + search + "'");
updateReg.prepare("update customers set type = 'Regular' where name = '" + search + "'");
find.prepare("select type from customers where name = '" + search + "'");
find.exec();
if(find.next())
{
QString aType;
aType = qry.value(0).toString();
}
QSqlRecord record;
record = qry.record();
while(qry.next())
{
record.value(data).toString();
}
if(true)
{
updateReg.exec();
qDebug() << "updating to regular";
}
else
{
updateExe.exec();
qDebug() << "updating to executive";
}
QSqlQueryModel* modal=new QSqlQueryModel();
QSqlQuery* view=new QSqlQuery();
view->prepare("SELECT * FROM Customers ORDER by name ASC");
view->exec();
modal->setQuery(*view);
ui->tableView->setModel(modal);
ui->tableView->setColumnWidth(0, 120);
}
else
{
ui->adminHomePage->show();
}
}
else
{
QMessageBox::warning(this, "Invalid", "That Customer does not exist.");
}
}
|
7ebdd0c5f9d80137285f4bd241dfec85239e6c76
|
2480ceee9f28f5e8a69fb6f5ed42fd63c22b4205
|
/src/Experimental/TexturePacker/TextureAtlasGenerator.cpp
|
7f321778259f47ec10c45e89633c7a6ddf130cc8
|
[
"MIT"
] |
permissive
|
rokrepo/pomdog
|
165db7884598c74bd530a4b7a1e83bc1e315c945
|
b21fd4fef295aaa3e06ca15e5952109cd8e93f00
|
refs/heads/master
| 2022-10-25T04:09:09.721827
| 2020-06-18T05:33:25
| 2020-06-18T05:33:25
| null | 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 7,673
|
cpp
|
TextureAtlasGenerator.cpp
|
// Copyright (c) 2013-2020 mogemimi. Distributed under the MIT license.
#include "Pomdog/Experimental/TexturePacker/TextureAtlasGenerator.hpp"
#include "Pomdog/Experimental/Image/Image.hpp"
#include "Pomdog/Utility/Assert.hpp"
#include <array>
#include <cstring>
#include <functional>
#include <unordered_map>
namespace Pomdog {
namespace TexturePacker {
namespace {
struct TexturePackNode {
std::array<std::shared_ptr<TexturePackNode>, 2> children;
std::shared_ptr<Image> image;
Rectangle rect;
Rectangle clipBounds;
explicit TexturePackNode(const Rectangle& rectIn)
: rect(rectIn)
{
}
};
std::shared_ptr<TexturePackNode> Insert(
const std::shared_ptr<TexturePackNode>& node, int width, int height)
{
POMDOG_ASSERT(width > 0);
POMDOG_ASSERT(height > 0);
const bool isLeaf = (!node->children[0] && !node->children[1]);
if (!isLeaf) {
auto newNode = Insert(node->children[0], width, height);
if (newNode) {
return newNode;
}
return Insert(node->children[1], width, height);
}
POMDOG_ASSERT(isLeaf);
constexpr int marginPixels = 2;
const auto w = width + marginPixels;
const auto h = height + marginPixels;
const auto dw = node->rect.Width - w;
const auto dh = node->rect.Height - h;
if ((w > node->rect.Width) || (h > node->rect.Height)) {
// NOTE: This node is too small.
return nullptr;
}
if (dw > dh) {
node->children[0] = std::make_shared<TexturePackNode>(Rectangle{
node->rect.X,
node->rect.Y + h,
w,
dh
});
node->children[1] = std::make_shared<TexturePackNode>(Rectangle{
node->rect.X + w,
node->rect.Y,
dw,
node->rect.Height
});
}
else {
node->children[0] = std::make_shared<TexturePackNode>(Rectangle{
node->rect.X + w,
node->rect.Y,
dw,
h
});
node->children[1] = std::make_shared<TexturePackNode>(Rectangle{
node->rect.X,
node->rect.Y + h,
node->rect.Width,
dh
});
}
return node;
}
void Traverse(
const std::shared_ptr<TexturePackNode>& node,
const std::function<void(const TexturePackNode&)>& func)
{
if (!node) {
return;
}
if (node->image) {
func(*node);
}
Traverse(node->children[0], func);
Traverse(node->children[1], func);
}
Rectangle Clip(const std::shared_ptr<Image>& image)
{
Rectangle bounds;
bounds.X = 0;
bounds.Y = 0;
bounds.Width = image->GetWidth();
bounds.Height = image->GetHeight();
bool hasPixels = false;
int left = image->GetWidth();
int right = 0;
int top = image->GetHeight();
int bottom = 0;
for (int y = 0; y < image->GetHeight(); ++y) {
for (int x = 0; x < image->GetWidth(); ++x) {
auto pixel = image->GetPixel(x, y);
POMDOG_ASSERT(pixel.A >= 0);
if (pixel.A != 0) {
left = std::min(x, left);
right = std::max(x, right);
top = std::min(y, top);
bottom = std::max(y, bottom);
hasPixels = true;
}
}
}
if (!hasPixels) {
bounds.X = 0;
bounds.Y = 0;
bounds.Width = 1;
bounds.Height = 1;
return bounds;
}
POMDOG_ASSERT(left <= right);
POMDOG_ASSERT(top <= bottom);
bounds.X = left;
bounds.Y = top;
bounds.Width = (right - left) + 1;
bounds.Height = (bottom - top) + 1;
POMDOG_ASSERT(bounds.Width <= image->GetWidth());
POMDOG_ASSERT(bounds.Height <= image->GetHeight());
return bounds;
}
} // unnamed namespace
TextureAtlasGeneratorResult TextureAtlasGenerator::Generate(
const std::vector<TextureAtlasGeneratorSource>& sources,
int width,
int height)
{
POMDOG_ASSERT(width > 0);
POMDOG_ASSERT(height > 0);
TextureAtlasGeneratorResult result;
auto& regions = result.Atlas.regions;
std::unordered_map<std::shared_ptr<Image>, int> indices;
for (auto& source : sources) {
POMDOG_ASSERT(!source.Name.empty());
TextureAtlasRegion region;
region.Name = source.Name;
regions.push_back(region);
indices.emplace(source.Image, static_cast<int>(regions.size()) - 1);
POMDOG_ASSERT(regions.at(indices[source.Image]).Name == source.Name);
}
result.HasError = false;
auto root = std::make_shared<TexturePackNode>(Rectangle{0, 0, width, height});
for (auto& source : sources) {
auto& image = source.Image;
auto clipBounds = Clip(image);
auto node = Insert(root, clipBounds.Width, clipBounds.Height);
POMDOG_ASSERT(node);
if (!node) {
// TODO: error handling
result.HasError = true;
#if defined(DEBUG)
std::printf("Cannot pack the texture '%s'", regions[indices[image]].Name.c_str());
#endif
break;
}
node->image = image;
node->clipBounds = clipBounds;
}
std::vector<Color> pixelData(width * height);
std::fill(pixelData.begin(), pixelData.end(), Color{0, 0, 0, 0});
Traverse(root, [&](const TexturePackNode& node) {
const auto image = node.image;
auto& region = regions[indices[image]].Region;
region.Subrect.X = static_cast<int>(node.rect.X);
region.Subrect.Y = static_cast<int>(node.rect.Y);
region.Subrect.Width = node.clipBounds.Width;
region.Subrect.Height = node.clipBounds.Height;
static_assert(std::is_same<decltype(node.clipBounds.X), std::int32_t>::value, "");
static_assert(std::is_same<decltype(node.clipBounds.Y), std::int32_t>::value, "");
static_assert(std::is_same<decltype(region.XOffset), std::int16_t>::value, "");
static_assert(std::is_same<decltype(region.YOffset), std::int16_t>::value, "");
static_assert(std::is_same<decltype(image->GetWidth()), int>::value, "");
static_assert(std::is_same<decltype(image->GetHeight()), int>::value, "");
static_assert(std::is_same<decltype(region.Width), std::int16_t>::value, "");
static_assert(std::is_same<decltype(region.Height), std::int16_t>::value, "");
POMDOG_ASSERT(node.clipBounds.X <= std::numeric_limits<std::int16_t>::max());
POMDOG_ASSERT(node.clipBounds.Y <= std::numeric_limits<std::int16_t>::max());
POMDOG_ASSERT(image->GetWidth() <= std::numeric_limits<std::int16_t>::max());
POMDOG_ASSERT(image->GetHeight() <= std::numeric_limits<std::int16_t>::max());
region.XOffset = static_cast<std::int16_t>(node.clipBounds.X);
region.YOffset = static_cast<std::int16_t>(node.clipBounds.Y);
region.Width = static_cast<std::int16_t>(image->GetWidth());
region.Height = static_cast<std::int16_t>(image->GetHeight());
const auto start = region.Subrect.X + region.Subrect.Y * width;
for (int y = 0; y < region.Subrect.Height; ++y) {
const auto offset = region.XOffset + ((region.YOffset + y) * image->GetWidth());
static_assert(sizeof(decltype(*image->GetData())) == sizeof(Color), "");
std::memcpy(
pixelData.data() + start + (y * width),
image->GetData() + offset,
sizeof(Color) * region.Subrect.Width);
}
});
result.Image = std::make_shared<Image>(width, height);
result.Image->SetData(std::move(pixelData));
return result;
}
} // namespace TexturePacker
} // namespace Pomdog
|
0538e5acee570d517223e04a8e3c5f46ff1daf2f
|
49b4a2dfd6ea6c48886f2bed9386fd1dda76c128
|
/notes/cpp/5 - Graph/Prim.cpp
|
e51a1b380898943d1d1c57a435e035963f81343f
|
[] |
no_license
|
martinezdiego/competitive-programming
|
8424c7ebfe4faeed3ee1254425523ce2200d05f2
|
a62da584233c81dcd0f4c503646a8482c43fec53
|
refs/heads/master
| 2023-06-25T07:30:13.254583
| 2021-07-31T00:51:21
| 2021-07-31T00:51:21
| 236,019,355
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 928
|
cpp
|
Prim.cpp
|
// Dado un grafo halla el costo total de su arbol cobertor mรญnimo.
#define MAX 100005
struct edge {
int v;
long long w;
bool operator < (const edge & b) const {
return w < b.w;
}
};
vector<edge> g[MAX];
bool visited[MAX];
long long ans;
int N, M;
void prim() {
priority_queue<edge> pq;
visited[0] = true;
for (const auto & v : g[0]) {
if (not visited[v.v])
pq.push(v);
}
while (not pq.empty()) {
edge e = pq.top();
pq.pop();
int u = e.v;
if (not visited[u]) {
ans += e.w;
visited[u] = true;
for (const auto & v : g[u]) {
if (not visited[v.v])
pq.push(v);
}
}
}
}
void init() {
ans = 0;
for(int i = 0; i <= N; i++) {
g[i].clear();
visited[i] = false;
}
}
|
7b05acad2d3db3d8348089d4594eb1dbde68989d
|
a86fb7f5a70c6d80c1f03461fa0f0b5a09c1c5e7
|
/src/geometry/cube.cpp
|
c7aeefc1857826151d16c56f1bc047562c00629f
|
[] |
no_license
|
vn-os/Solar-System
|
1da630e686bc0416c84e07316230d17ab24eaa6f
|
6ee40ddb81a3fc948c717200a13198c290fe9692
|
refs/heads/master
| 2022-01-16T20:20:26.419481
| 2019-01-21T22:40:36
| 2019-01-21T22:40:36
| null | 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 2,052
|
cpp
|
cube.cpp
|
#include "cube.hpp"
#define BUFFER_OFFSET(bytes) ((GLubyte*) NULL + (bytes))
/**
* @brief Construct a new Cube:: Cube object
*
*/
Cube::Cube() {
vertex_count = normal_count = 24;
//! Init the vertices vector
vertices = new GLfloat[vertex_count * 3] {
//! front
1, 1, 1,
1, -1, 1,
-1, -1, 1,
-1, 1, 1,
//! right
1, 1, -1,
1, -1, -1,
1, -1, 1,
1, 1, 1,
//! back
-1, 1, -1,
-1, -1, -1,
1, -1, -1,
1, 1, -1,
//! left
-1, 1, 1,
-1, -1, 1,
-1, -1, -1,
-1, 1, -1,
//! top
1, 1, 1,
-1, 1, 1,
-1, 1, -1,
1, 1, -1,
//! bottom
1, -1, 1,
-1, -1, 1,
-1, -1, -1,
1, -1, -1
};
//! Init the normals vector
normals = new GLfloat[normal_count * 3] {
//! front
0, 0, 1,
0, 0, 1,
0, 0, 1,
0, 0, 1,
//! right
1, 0, 0,
1, 0, 0,
1, 0, 0,
1, 0, 0,
//! back
0, 0, -1,
0, 0, -1,
0, 0, -1,
0, 0, -1,
//! left
-1, 0, 0,
-1, 0, 0,
-1, 0, 0,
-1, 0, 0,
//! top
0, 1, 0,
0, 1, 0,
0, 1, 0,
0, 1, 0,
//! bottom
0, -1, 0,
0, -1, 0,
0, -1, 0,
0, -1, 0
};
buffers = new GLuint[2];
glGenBuffers(2, buffers);
glBindBuffer(GL_ARRAY_BUFFER, buffers[0]);
glBufferData(
GL_ARRAY_BUFFER,
vertex_count * 3 * sizeof(GLfloat),
vertices,
GL_STATIC_DRAW
);
glBindBuffer(GL_ARRAY_BUFFER, buffers[1]);
glBufferData(
GL_ARRAY_BUFFER,
normal_count * 3 * sizeof(GLfloat),
normals,
GL_STATIC_DRAW
);
delete normals;
delete vertices;
}
/**
* @brief Draw a new cube
*
*/
void Cube::draw() {
glEnableVertexAttribArray(0);
glBindBuffer(GL_ARRAY_BUFFER, buffers[0]);
glVertexAttribPointer(
0,
3,
GL_FLOAT,
GL_FALSE,
0,
BUFFER_OFFSET(0)
);
glEnableVertexAttribArray(1);
glBindBuffer(GL_ARRAY_BUFFER, buffers[1]);
glVertexAttribPointer(
1,
3,
GL_FLOAT,
GL_FALSE,
0,
BUFFER_OFFSET(1)
);
glDrawArrays(GL_QUADS, 0, vertex_count);
glDisableVertexAttribArray(0);
glDisableVertexAttribArray(1);
}
/**
* @brief Destroy the Cube:: Cube object
*
*/
Cube::~Cube() {
delete buffers;
}
|
160b52390358793b6e7fef30fe3b35a3da572eb7
|
90e4fe85b70221ae82f99ca6930da980ef8f674a
|
/Anul_1/Semestru_2/dataStructs/Red_Back/DataStructures/Stack/Stack.h
|
79519524e1dc58289243b775d4237fd2865fa84a
|
[] |
no_license
|
stefangeorgescu970/university-assignments
|
108235e047b963efb6cd1b952f6b96849e1dc3d3
|
9253cc084b74a62035c96a4a2accfbba43812c16
|
refs/heads/master
| 2022-12-10T14:49:20.299356
| 2020-04-28T14:05:41
| 2020-04-28T14:05:41
| 259,648,446
| 0
| 0
| null | 2022-12-07T20:33:05
| 2020-04-28T13:43:02
|
C++
|
UTF-8
|
C++
| false
| false
| 1,360
|
h
|
Stack.h
|
//
// Created by Georgescu Stefan on 02/06/2017.
//
#ifndef RED_BACK_STACK_H
#define RED_BACK_STACK_H
#include <string>
typedef struct StackNode{
/*
* Structure used to keep all the info required for a node in a Singly Linked List with Dynamic Allocation.
* Colour of a cards as a string.
* The address of the next node as a pointer to StackNode.
*/
std::string colour;
StackNode* next;
}StackNode;
class Stack {
/*
* Class representing a Stack implemented on a singly linked list with dynamic allocation.
* We have the address of the first element of the list as a pointer to StackNode.
* The capacity and current size of the stack are given as integers.
*/
private:
StackNode* head;
int capacity;
int size;
public:
Stack(int capacity);
// Constructor for Data Type Stack.
~Stack();
// Destructor for Data Type Stack.
void push(std::string colour);
// Function for pushing a new element on the stack.
std::string pop();
// Function for popping an element from the top of the stack.
std::string top();
// Function for checking the element on the top of the stack.
bool is_empty();
// Function for checking if the Stack is empty.
bool is_full();
// Function for checking if the Stack is full.
};
#endif //RED_BACK_STACK_H
|
9eef71c50078f64038e0efe7ce05062956a304a7
|
e43f624cdfec91dc2f7137bf9f774c82885b1d4e
|
/Practica9/18-Skybox/src/main.cpp
|
94c1f8cd418231692d725c65f4a5c129c3f67209
|
[] |
no_license
|
felixRosas/LabCGeIHC
|
982304de0836a7cd80f9a13ebba73f7cda12c960
|
74cbc8b877b27c8f852dd796ae6b6847def95021
|
refs/heads/master
| 2020-04-21T11:07:38.919667
| 2019-05-10T22:04:23
| 2019-05-10T22:04:23
| 169,511,378
| 1
| 0
| null | 2019-02-07T02:57:46
| 2019-02-07T02:57:46
| null |
ISO-8859-1
|
C++
| false
| false
| 40,082
|
cpp
|
main.cpp
|
//glew include
#include <GL/glew.h>
//std includes
#include <string>
#include <iostream>
#define _USE_MATH_DEFINES
#include <math.h>
//glfw include
#include <GLFW/glfw3.h>
//GLM include
#define GLM_FORCE_RADIANS
#include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp>
#include <glm/gtc/type_ptr.hpp>
// program include
#include "Headers/TimeManager.h"
#include "Headers/Shader.h"
// Geometry primitives
#include "Headers/Sphere.h"
#include "Headers/Cylinder.h"
#include "Headers/Box.h"
#include "Headers/FirstPersonCamera.h"
//Texture includes
#include "Headers/Texture.h"
#define ARRAY_SIZE_IN_ELEMENTS(a) (sizeof(a)/sizeof(a[0]))
std::shared_ptr<FirstPersonCamera> camera(new FirstPersonCamera());
Sphere sphere(20, 20);
Sphere sphere2(20, 20);
Cylinder cylinder(20, 20, 0.5, 0.5);
Cylinder cylinder2(20, 20, 0.5, 0.5);
Box box;
Box box2;
Shader shaderColor;
Shader shaderTexture;
Shader shaderCubeTexture;
Shader shaderMateriales;
Shader shaderDirectionLight;
Shader shaderPointLight;
Shader shaderPointLight2;
Shader shaderSpotLight;
GLuint textureCubeTexture;
GLuint textureID1, textureID2, textureID3, textureID4, textureID5, textureID6, textureID7, textureID8, textureID9, textureID10, textureID11;
GLuint textureID12, textureID13, textureID14, textureID15, textureID16;
GLuint cubeTextureID;
GLenum types[6] = {
GL_TEXTURE_CUBE_MAP_POSITIVE_X,
GL_TEXTURE_CUBE_MAP_NEGATIVE_X,
GL_TEXTURE_CUBE_MAP_POSITIVE_Y,
GL_TEXTURE_CUBE_MAP_NEGATIVE_Y,
GL_TEXTURE_CUBE_MAP_POSITIVE_Z,
GL_TEXTURE_CUBE_MAP_NEGATIVE_Z
};
std::string fileNames[6] = {
"../../Textures/mp_deviltooth/devils-tooth_ft.tga",
"../../Textures/mp_deviltooth/devils-tooth_bk.tga",
"../../Textures/mp_deviltooth/devils-tooth_up.tga",
"../../Textures/mp_deviltooth/devils-tooth_dn.tga",
"../../Textures/mp_deviltooth/devils-tooth_rt.tga",
"../../Textures/mp_deviltooth/devils-tooth_lf.tga"
};
int screenWidth;
int screenHeight;
GLFWwindow * window;
bool exitApp = false;
int lastMousePosX, offsetX;
int lastMousePosY, offsetY;
bool light = true;
double deltaTime;
// Se definen todos las funciones.
void reshapeCallback(GLFWwindow* Window, int widthRes, int heightRes);
void keyCallback(GLFWwindow* window, int key, int scancode, int action, int mode);
void mouseCallback(GLFWwindow* window, double xpos, double ypos);
void mouseButtonCallback(GLFWwindow* window, int button, int state, int mod);
void init(int width, int height, std::string strTitle, bool bFullScreen);
void destroyWindow();
void destroy();
bool processInput(bool continueApplication = true);
// Implementacion de todas las funciones.
void init(int width, int height, std::string strTitle, bool bFullScreen) {
if (!glfwInit()) {
std::cerr << "Failed to initialize GLFW" << std::endl;
exit(-1);
}
screenWidth = width;
screenHeight = height;
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
if (bFullScreen)
window = glfwCreateWindow(width, height, strTitle.c_str(),
glfwGetPrimaryMonitor(), nullptr);
else
window = glfwCreateWindow(width, height, strTitle.c_str(), nullptr,
nullptr);
if (window == nullptr) {
std::cerr
<< "Error to create GLFW window, you can try download the last version of your video card that support OpenGL 3.3+"
<< std::endl;
destroyWindow();
exit(-1);
}
glfwMakeContextCurrent(window);
glfwSwapInterval(0);
glfwSetWindowSizeCallback(window, reshapeCallback);
glfwSetKeyCallback(window, keyCallback);
glfwSetCursorPosCallback(window, mouseCallback);
glfwSetMouseButtonCallback(window, mouseButtonCallback);
glfwSetInputMode(window, GLFW_STICKY_KEYS, GL_TRUE);
// Init glew
glewExperimental = GL_TRUE;
GLenum err = glewInit();
if (GLEW_OK != err) {
std::cerr << "Failed to initialize glew" << std::endl;
exit(-1);
}
glViewport(0, 0, screenWidth, screenHeight);
glClearColor(0.0f, 0.0f, 0.4f, 0.0f);
glEnable(GL_DEPTH_TEST);
shaderColor.initialize("../../Shaders/transformaciones.vs", "../../Shaders/transformaciones.fs");
shaderTexture.initialize("../../Shaders/texturizado_res.vs", "../../Shaders/texturizado_res.fs");
shaderCubeTexture.initialize("../../Shaders/cubeTexture.vs", "../../Shaders/cubeTexture.fs");
shaderMateriales.initialize("../../Shaders/iluminacion_materiales_res.vs", "../../Shaders/iluminacion_materiales_res.fs");
shaderDirectionLight.initialize("../../Shaders/typeLight.vs", "../../Shaders/directionalLight.fs");
shaderPointLight.initialize("../../Shaders/typeLight.vs", "../../Shaders/pointLight.fs");
shaderPointLight2.initialize("../../Shaders/typeLight.vs", "../../Shaders/pointLight.fs");
shaderSpotLight.initialize("../../Shaders/typeLight.vs", "../../Shaders/spotLight.fs");
sphere2.init();
sphere.init();
cylinder.init();
cylinder2.init();
box.init();
box2.init();
camera->setPosition(glm::vec3(0.0f, 0.0f, 0.4f));
// Textura Pared de piedra
int imageWidth, imageHeight;
Texture texture("../../Textures/pared_piedra.png");
FIBITMAP* bitmap = texture.loadImage(false);
unsigned char * data = texture.convertToData(bitmap, imageWidth, imageHeight);
glGenTextures(1, &textureID1);
glBindTexture(GL_TEXTURE_2D, textureID1);
// set the texture wrapping parameters
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); // set texture wrapping to GL_REPEAT (default wrapping method)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
// set texture filtering parameters
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
if (data){
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, imageWidth, imageHeight, 0, GL_BGRA, GL_UNSIGNED_BYTE, data);
glGenerateMipmap(GL_TEXTURE_2D);
}
else
std::cout << "Failed to load texture" << std::endl;
texture.freeImage(bitmap);
// Texture fachada interior
texture = Texture("../../Textures/fachadar.jpg");
bitmap = texture.loadImage(false);
data = texture.convertToData(bitmap, imageWidth, imageHeight);
glGenTextures(1, &textureID2);
glBindTexture(GL_TEXTURE_2D, textureID2);
// set the texture wrapping parameters
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); // set texture wrapping to GL_REPEAT (default wrapping method)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
// set texture filtering parameters
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
if (data) {
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, imageWidth, imageHeight, 0, GL_BGRA, GL_UNSIGNED_BYTE, data);
glGenerateMipmap(GL_TEXTURE_2D);
}
else
std::cout << "Failed to load texture" << std::endl;
texture.freeImage(bitmap);
// Textura cuadritos
texture = Texture("../../Textures/test.png");
bitmap = texture.loadImage(false);
data = texture.convertToData(bitmap, imageWidth, imageHeight);
glGenTextures(1, &textureID3);
glBindTexture(GL_TEXTURE_2D, textureID3);
// set the texture wrapping parameters
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); // set texture wrapping to GL_REPEAT (default wrapping method)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
// set texture filtering parameters
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
if (data) {
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, imageWidth, imageHeight, 0, GL_BGRA, GL_UNSIGNED_BYTE, data);
glGenerateMipmap(GL_TEXTURE_2D);
}
else
std::cout << "Failed to load texture" << std::endl;
texture.freeImage(bitmap);
// Textura Madera mesa
texture = Texture("../../Textures/madera_mesa.jpg");
bitmap = texture.loadImage(false);
data = texture.convertToData(bitmap, imageWidth, imageHeight);
glGenTextures(1, &textureID4);
glBindTexture(GL_TEXTURE_2D, textureID4);
// set the texture wrapping parameters
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); // set texture wrapping to GL_REPEAT (default wrapping method)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
// set texture filtering parameters
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
if (data) {
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, imageWidth, imageHeight, 0, GL_BGRA, GL_UNSIGNED_BYTE, data);
glGenerateMipmap(GL_TEXTURE_2D);
}
else
std::cout << "Failed to load texture" << std::endl;
texture.freeImage(bitmap);
// Textura Pared de ladrillos
texture = Texture("../../Textures/pared_ladrillos.jpg");
bitmap = texture.loadImage(false);
data = texture.convertToData(bitmap, imageWidth, imageHeight);
glGenTextures(1, &textureID5);
glBindTexture(GL_TEXTURE_2D, textureID5);
// set the texture wrapping parameters
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); // set texture wrapping to GL_REPEAT (default wrapping method)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
// set texture filtering parameters
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
if (data) {
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, imageWidth, imageHeight, 0, GL_BGRA, GL_UNSIGNED_BYTE, data);
glGenerateMipmap(GL_TEXTURE_2D);
}
else
std::cout << "Failed to load texture" << std::endl;
texture.freeImage(bitmap);
// Textura Fachada
texture = Texture("../../Textures/fachada.jpg");
bitmap = texture.loadImage(false);
data = texture.convertToData(bitmap, imageWidth, imageHeight);
glGenTextures(1, &textureID6);
glBindTexture(GL_TEXTURE_2D, textureID6);
// set the texture wrapping parameters
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); // set texture wrapping to GL_REPEAT (default wrapping method)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
// set texture filtering parameters
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
if (data) {
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, imageWidth, imageHeight, 0, GL_BGRA, GL_UNSIGNED_BYTE, data);
glGenerateMipmap(GL_TEXTURE_2D);
}
else
std::cout << "Failed to load texture" << std::endl;
texture.freeImage(bitmap);
// Textura Techo
texture = Texture("../../Textures/techo.jpg");
bitmap = texture.loadImage(false);
data = texture.convertToData(bitmap, imageWidth, imageHeight);
glGenTextures(1, &textureID7);
glBindTexture(GL_TEXTURE_2D, textureID7);
// set the texture wrapping parameters
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); // set texture wrapping to GL_REPEAT (default wrapping method)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
// set texture filtering parameters
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
if (data) {
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, imageWidth, imageHeight, 0, GL_BGRA, GL_UNSIGNED_BYTE, data);
glGenerateMipmap(GL_TEXTURE_2D);
}
else
std::cout << "Failed to load texture" << std::endl;
texture.freeImage(bitmap);
// Textura de piel para sillon
texture = Texture("../../Textures/sillon_piel.jpg");
bitmap = texture.loadImage(false);
data = texture.convertToData(bitmap, imageWidth, imageHeight);
glGenTextures(1, &textureID8);
glBindTexture(GL_TEXTURE_2D, textureID8);
// set the texture wrapping parameters
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); // set texture wrapping to GL_REPEAT (default wrapping method)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
// set texture filtering parameters
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
if (data) {
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, imageWidth, imageHeight, 0, GL_BGRA, GL_UNSIGNED_BYTE, data);
glGenerateMipmap(GL_TEXTURE_2D);
}
else
std::cout << "Failed to load texture" << std::endl;
texture.freeImage(bitmap);
// Textura gris
texture = Texture("../../Textures/gris.jpg");
bitmap = texture.loadImage(false);
data = texture.convertToData(bitmap, imageWidth, imageHeight);
glGenTextures(1, &textureID9);
glBindTexture(GL_TEXTURE_2D, textureID9);
// set the texture wrapping parameters
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); // set texture wrapping to GL_REPEAT (default wrapping method)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
// set texture filtering parameters
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
if (data) {
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, imageWidth, imageHeight, 0, GL_BGRA, GL_UNSIGNED_BYTE, data);
glGenerateMipmap(GL_TEXTURE_2D);
}
else
std::cout << "Failed to load texture" << std::endl;
texture.freeImage(bitmap);
// Textura cuadro Beso
texture = Texture("../../Textures/beso.jpg");
bitmap = texture.loadImage(false);
data = texture.convertToData(bitmap, imageWidth, imageHeight);
glGenTextures(1, &textureID10);
glBindTexture(GL_TEXTURE_2D, textureID10);
// set the texture wrapping parameters
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); // set texture wrapping to GL_REPEAT (default wrapping method)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
// set texture filtering parameters
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
if (data) {
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, imageWidth, imageHeight, 0, GL_BGRA, GL_UNSIGNED_BYTE, data);
glGenerateMipmap(GL_TEXTURE_2D);
}
else
std::cout << "Failed to load texture" << std::endl;
texture.freeImage(bitmap);
// Textura pantalla
texture = Texture("../../Textures/pantalla.jpg");
bitmap = texture.loadImage(false);
data = texture.convertToData(bitmap, imageWidth, imageHeight);
glGenTextures(1, &textureID11);
glBindTexture(GL_TEXTURE_2D, textureID11);
// set the texture wrapping parameters
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); // set texture wrapping to GL_REPEAT (default wrapping method)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
// set texture filtering parameters
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
if (data) {
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, imageWidth, imageHeight, 0, GL_BGRA, GL_UNSIGNED_BYTE, data);
glGenerateMipmap(GL_TEXTURE_2D);
}
else
std::cout << "Failed to load texture" << std::endl;
texture.freeImage(bitmap);
// Textura refri
texture = Texture("../../Textures/refri.jpg");
bitmap = texture.loadImage(false);
data = texture.convertToData(bitmap, imageWidth, imageHeight);
glGenTextures(1, &textureID12);
glBindTexture(GL_TEXTURE_2D, textureID12);
// set the texture wrapping parameters
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); // set texture wrapping to GL_REPEAT (default wrapping method)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
// set texture filtering parameters
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
if (data) {
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, imageWidth, imageHeight, 0, GL_BGRA, GL_UNSIGNED_BYTE, data);
glGenerateMipmap(GL_TEXTURE_2D);
}
else
std::cout << "Failed to load texture" << std::endl;
texture.freeImage(bitmap);
// Textura estufa
texture = Texture("../../Textures/estufa.jpg");
bitmap = texture.loadImage(false);
data = texture.convertToData(bitmap, imageWidth, imageHeight);
glGenTextures(1, &textureID13);
glBindTexture(GL_TEXTURE_2D, textureID13);
// set the texture wrapping parameters
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); // set texture wrapping to GL_REPEAT (default wrapping method)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
// set texture filtering parameters
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
if (data) {
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, imageWidth, imageHeight, 0, GL_BGRA, GL_UNSIGNED_BYTE, data);
glGenerateMipmap(GL_TEXTURE_2D);
}
else
std::cout << "Failed to load texture" << std::endl;
texture.freeImage(bitmap);
// Textura librero
texture = Texture("../../Textures/librero.jpg");
bitmap = texture.loadImage(false);
data = texture.convertToData(bitmap, imageWidth, imageHeight);
glGenTextures(1, &textureID14);
glBindTexture(GL_TEXTURE_2D, textureID14);
// set the texture wrapping parameters
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); // set texture wrapping to GL_REPEAT (default wrapping method)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
// set texture filtering parameters
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
if (data) {
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, imageWidth, imageHeight, 0, GL_BGRA, GL_UNSIGNED_BYTE, data);
glGenerateMipmap(GL_TEXTURE_2D);
}
else
std::cout << "Failed to load texture" << std::endl;
texture.freeImage(bitmap);
// Textura cocina integral
texture = Texture("../../Textures/cocina_integral.jpg");
bitmap = texture.loadImage(false);
data = texture.convertToData(bitmap, imageWidth, imageHeight);
glGenTextures(1, &textureID15);
glBindTexture(GL_TEXTURE_2D, textureID15);
// set the texture wrapping parameters
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); // set texture wrapping to GL_REPEAT (default wrapping method)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
// set texture filtering parameters
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
if (data) {
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, imageWidth, imageHeight, 0, GL_BGRA, GL_UNSIGNED_BYTE, data);
glGenerateMipmap(GL_TEXTURE_2D);
}
else
std::cout << "Failed to load texture" << std::endl;
texture.freeImage(bitmap);
// Textura Madera mesa
texture = Texture("../../Textures/madera_clara.jpg");
bitmap = texture.loadImage(false);
data = texture.convertToData(bitmap, imageWidth, imageHeight);
glGenTextures(1, &textureID16);
glBindTexture(GL_TEXTURE_2D, textureID16);
// set the texture wrapping parameters
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); // set texture wrapping to GL_REPEAT (default wrapping method)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
// set texture filtering parameters
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
if (data) {
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, imageWidth, imageHeight, 0, GL_BGRA, GL_UNSIGNED_BYTE, data);
glGenerateMipmap(GL_TEXTURE_2D);
}
else
std::cout << "Failed to load texture" << std::endl;
texture.freeImage(bitmap);
glGenTextures(1, &cubeTextureID);
glBindTexture(GL_TEXTURE_CUBE_MAP, cubeTextureID);
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); // set texture wrapping to GL_REPEAT (default wrapping method)
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); // set texture wrapping to GL_REPEAT (default wrapping method)
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
for (int i = 0; i < ARRAY_SIZE_IN_ELEMENTS(types); i++) {
texture = Texture(fileNames[i]);
FIBITMAP* bitmap = texture.loadImage(true);
data = texture.convertToData(bitmap, imageWidth, imageHeight);
if (data) {
glTexImage2D(types[i], 0, GL_RGBA, imageWidth, imageHeight, 0, GL_BGRA, GL_UNSIGNED_BYTE, data);
}
else
std::cout << "Failed to load texture" << std::endl;
texture.freeImage(bitmap);
}
}
void destroyWindow() {
glfwDestroyWindow(window);
glfwTerminate();
}
void destroy() {
destroyWindow();
shaderColor.destroy();
shaderTexture.destroy();
shaderCubeTexture.destroy();
shaderMateriales.destroy();
shaderDirectionLight.destroy();
shaderPointLight.destroy();
shaderPointLight2.destroy();
shaderSpotLight.destroy();
sphere.destroy();
cylinder.destroy();
box.destroy();
box2.destroy();
}
void reshapeCallback(GLFWwindow* Window, int widthRes, int heightRes) {
screenWidth = widthRes;
screenHeight = heightRes;
glViewport(0, 0, widthRes, heightRes);
}
void keyCallback(GLFWwindow* window, int key, int scancode, int action, int mode) {
if (action == GLFW_PRESS) {
switch (key) {
case GLFW_KEY_ESCAPE:
exitApp = true;
break;
case GLFW_KEY_L:
if (light == true) {
light = false;
}
else
light = true;
}
}
}
void mouseCallback(GLFWwindow* window, double xpos, double ypos) {
offsetX = xpos - lastMousePosX;
offsetY = ypos - lastMousePosY;
lastMousePosX = xpos;
lastMousePosY = ypos;
if (glfwGetMouseButton(window, GLFW_MOUSE_BUTTON_LEFT) == GLFW_PRESS)
camera->mouseMoveCamera(offsetX, offsetY, deltaTime);
}
void mouseButtonCallback(GLFWwindow* window, int button, int state, int mod) {
if (state == GLFW_PRESS) {
switch (button) {
case GLFW_MOUSE_BUTTON_RIGHT:
std::cout << "lastMousePos.y:" << lastMousePosY << std::endl;
break;
case GLFW_MOUSE_BUTTON_LEFT:
std::cout << "lastMousePos.x:" << lastMousePosX << std::endl;
break;
case GLFW_MOUSE_BUTTON_MIDDLE:
std::cout << "lastMousePos.x:" << lastMousePosX << std::endl;
std::cout << "lastMousePos.y:" << lastMousePosY << std::endl;
break;
}
}
}
bool processInput(bool continueApplication) {
if (exitApp || glfwWindowShouldClose(window) != 0) {
return false;
}
TimeManager::Instance().CalculateFrameRate(false);
deltaTime = TimeManager::Instance().DeltaTime;
if (glfwGetKey(window, GLFW_KEY_W) == GLFW_PRESS)
camera->moveFrontCamera(true, deltaTime);
if (glfwGetKey(window, GLFW_KEY_S) == GLFW_PRESS)
camera->moveFrontCamera(false, deltaTime);
if (glfwGetKey(window, GLFW_KEY_A) == GLFW_PRESS)
camera->moveRightCamera(false, deltaTime);
if (glfwGetKey(window, GLFW_KEY_D) == GLFW_PRESS)
camera->moveRightCamera(true, deltaTime);
glfwPollEvents();
return continueApplication;
}
void applicationLoop() {
bool psi = true;
double lastTime = TimeManager::Instance().GetTime();
glm::vec3 objPosition = glm::vec3(0.0f, 0.0f, -3.0f);
float angle = 0.0;
float ratio = 20.0;
while (psi) {
psi = processInput(true);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glClearColor(0.2f, 0.3f, 0.3f, 1.0f);
// Matrix de proyeccion en perspectiva
glm::mat4 projection = glm::perspective(glm::radians(45.0f),
(float)screenWidth / screenWidth, 0.01f, 100.0f);
// matrix de vista
glm::mat4 view = camera->getViewMatrix();
glm::mat4 cubeModelMatrix = glm::translate(glm::mat4(1.0f), objPosition);
glm::mat4 lightModelmatrix = glm::rotate(cubeModelMatrix, angle, glm::vec3(0.0f, 1.0f, 0.0f));
lightModelmatrix = glm::translate(lightModelmatrix, glm::vec3(0.0f, 0.0f, -ratio));
if (light) {
//CREACION DE LAS FIGURAS
// Iluminaciรณn
shaderSpotLight.turnOn();
glUniform3fv(shaderSpotLight.getUniformLocation("light.position"), 1, glm::value_ptr(camera->getPosition()));
glUniform3fv(shaderSpotLight.getUniformLocation("light.direction"), 1, glm::value_ptr(camera->getFront()));
glUniform3fv(shaderSpotLight.getUniformLocation("viewPos"), 1, glm::value_ptr(camera->getPosition()));
glUniform3f(shaderSpotLight.getUniformLocation("light.ambient"), 0.2, 0.2, 0.2);
glUniform3f(shaderSpotLight.getUniformLocation("light.diffuse"), 0.2, 0.3, 0.6);
glUniform3f(shaderSpotLight.getUniformLocation("light.specular"), 0.5, 0.3, 0.2);
glUniform3f(shaderSpotLight.getUniformLocation("material.ambient"), 1.0, 0.2, 0.6);
glUniform3f(shaderSpotLight.getUniformLocation("material.diffuse"), 0.4, 0.5, 0.8);
glUniform3f(shaderSpotLight.getUniformLocation("material.specular"), 0.5, 0.3, 0.2);
glUniform1f(shaderSpotLight.getUniformLocation("light.cutOff"), glm::cos(glm::radians(12.5f)));
glUniform1f(shaderSpotLight.getUniformLocation("light.outerCutOff"), glm::cos(glm::radians(15.0f)));
glUniform1f(shaderSpotLight.getUniformLocation("light.constant"), 1.0f);
glUniform1f(shaderSpotLight.getUniformLocation("light.linear"), 0.7f);
glUniform1f(shaderSpotLight.getUniformLocation("light.quadratics"), 1.8f);
glUniform1f(shaderSpotLight.getUniformLocation("material.shininess"), 128.0);
//RENDERIZACION DE LAS FIGURAS
glBindTexture(GL_TEXTURE_2D, textureID4); //BASE
box.setShader(&shaderTexture);
box.setProjectionMatrix(projection);
box.setViewMatrix(view);
box.setPosition(glm::vec3(0.0, -0.8, -20.0));
box.setScale(glm::vec3(10.0, 0.4, 20.0));
box.render();
box.setShader(&shaderSpotLight); //pared delantera
glBindTexture(GL_TEXTURE_2D, textureID2);
box.setPosition(glm::vec3(0.0, 1.0, -10.0));
box.setScale(glm::vec3(10.0, 4.0, 0.4));
box.render(6, 12);
glBindTexture(GL_TEXTURE_2D, textureID6);
box.render(0,6);
box.render(12,36);
glBindTexture(GL_TEXTURE_2D, textureID1); //pared izquierda
box.setPosition(glm::vec3(-5.0, 1.0, -20.0));
box.setScale(glm::vec3(0.4, 4.0, 20.0));
box.render();
glBindTexture(GL_TEXTURE_2D, textureID1); //pared derecha
box.setPosition(glm::vec3(5.0, 1.0, -20.0));
box.setScale(glm::vec3(0.4, 4.0, 20.0));
box.render();
glBindTexture(GL_TEXTURE_2D, textureID1); //pared trasera
box.setPosition(glm::vec3(0.0, 1.0, -30.0));
box.setScale(glm::vec3(10.0, 4.0, 0.4));
box.render();
glBindTexture(GL_TEXTURE_2D, textureID5); //pared separacion
box.setPosition(glm::vec3(-1.0, 1.0, -23.0));
box.setScale(glm::vec3(8.0, 4.0, 0.4));
box.render();
glBindTexture(GL_TEXTURE_2D, textureID7); //techo
box.setPosition(glm::vec3(0.0, 3.0, -20.0));
box.setScale(glm::vec3(12.0, 0.4, 22.0));
box.render();
glBindTexture(GL_TEXTURE_2D, textureID16); //mesa de centro
cylinder2.setShader(&shaderSpotLight);
cylinder2.setProjectionMatrix(projection);
cylinder2.setViewMatrix(view);
cylinder2.setPosition(glm::vec3(-1.0, -0.3, -18.0));
cylinder2.setScale(glm::vec3(0.6, 0.6, 0.6));
cylinder2.render(0, cylinder.getSlices() * cylinder.getStacks() * 2 * 3);
glBindTexture(GL_TEXTURE_2D, textureID16);
cylinder2.render(cylinder2.getSlices() * cylinder2.getStacks() * 2 * 3, cylinder2.getSlices() * 3);
glBindTexture(GL_TEXTURE_2D, textureID16);
cylinder2.render(cylinder2.getSlices() * cylinder2.getStacks() * 2 * 3 + cylinder2.getSlices() * 3, cylinder2.getSlices() * 3);
glBindTexture(GL_TEXTURE_2D, textureID8); //sillon grande
box.setPosition(glm::vec3(-2.5, -0.35, -18.0));
box.setScale(glm::vec3(1.0, 0.5, 3.0));
box.render();
box.setPosition(glm::vec3(-2.85, 0.15, -18.0));
box.setScale(glm::vec3(0.3, 0.5, 3.0));
box.render();
box.setPosition(glm::vec3(0.5, -0.35, -18.0));
box.setScale(glm::vec3(1.0, 0.5, 3.0));
box.render();
box.setPosition(glm::vec3(0.85, 0.15, -18.0));
box.setScale(glm::vec3(0.3, 0.5, 3.0));
box.render();
glBindTexture(GL_TEXTURE_2D, textureID8); //sillon pequeรฑo
box.setPosition(glm::vec3(-1.0, -0.35, -16.5));
box.setScale(glm::vec3(1.0, 0.5, 1.0));
box.render();
glBindTexture(GL_TEXTURE_2D, textureID16); //mueble pantalla
box.setPosition(glm::vec3(-1.0, 0.15, -22.3));
box.setScale(glm::vec3(3.0, 1.5, 1.0));
box.render();
glBindTexture(GL_TEXTURE_2D, textureID11); //pantalla
box.setPosition(glm::vec3(-1.0, 1.7, -22.3));
box.setScale(glm::vec3(2.5, 1.5, 0.05));
box.render();
//librero
glBindTexture(GL_TEXTURE_2D, textureID14);
box.setPosition(glm::vec3(-4.2, 1.0, -13.5));
box.setScale(glm::vec3(1.0, 3.0, 4.0));
box.render(6, 12);
glBindTexture(GL_TEXTURE_2D, textureID16);
box.render(0, 6);
box.render(12, 36);
glBindTexture(GL_TEXTURE_2D, textureID10); //cuadro
box.setPosition(glm::vec3(-4.8, 1.5, -19.0));
box.setScale(glm::vec3(0.1, 2.0, 1.5));
box.render();
glBindTexture(GL_TEXTURE_2D, textureID15); //cocina integral
box.setPosition(glm::vec3(-3.7, 1.0, -26.5));
box.setScale(glm::vec3(2.0, 3.0, 5.0));
box.render(6, 12);
glBindTexture(GL_TEXTURE_2D, textureID9);
box.render(0, 6);
box.render(12, 36);
glBindTexture(GL_TEXTURE_2D, textureID12); //refri
box.setPosition(glm::vec3(0.0, 0.6, -23.8));
box.setScale(glm::vec3(2.0, 2.5, 1.5));
box.render(12, 18);
glBindTexture(GL_TEXTURE_2D, textureID9);
box.render(0, 12);
box.render(18, 36);
glBindTexture(GL_TEXTURE_2D, textureID13); //estufa
box.setPosition(glm::vec3(0.0, 0.15, -29.1));
box.setScale(glm::vec3(1.2, 1.5, 1.5));
box.render(0, 6);
glBindTexture(GL_TEXTURE_2D, textureID9);
box.render(6, 36);
/* //cubo de prueba
box.setPosition(glm::vec3(0.0, 0.0, 0.0));
box.setScale(glm::vec3(1.0, 1.0, 1.0));
glBindTexture(GL_TEXTURE_2D, textureID1);
box.render(0,6);
glBindTexture(GL_TEXTURE_2D, 0);
glBindTexture(GL_TEXTURE_2D, textureID2);
box.render(6,9);
glBindTexture(GL_TEXTURE_2D, 0);
glBindTexture(GL_TEXTURE_2D, textureID3);
box.render(12,18);
glBindTexture(GL_TEXTURE_2D, 0);
glBindTexture(GL_TEXTURE_2D, textureID4);
box.render(18,24);
glBindTexture(GL_TEXTURE_2D, 0);
glBindTexture(GL_TEXTURE_2D, textureID5);
box.render(24,30);
glBindTexture(GL_TEXTURE_2D, 0);
glBindTexture(GL_TEXTURE_2D, textureID6);
box.render(30,36);
glBindTexture(GL_TEXTURE_2D, 0);
*/
shaderSpotLight.turnOff();
glBindTexture(GL_TEXTURE_2D, 0);
}else{
//LUZ POSICIONAL
// Iluminaciรณn
shaderPointLight.turnOn();
glUniform3fv(shaderPointLight.getUniformLocation("light.position"), 1, glm::value_ptr(glm::vec3(0.0, 5.0, -25.0)));
glUniform3fv(shaderPointLight.getUniformLocation("light.direction"), 1, glm::value_ptr(glm::vec3(-0.3f, -1.0f, -0.2f)));
glUniform3fv(shaderPointLight.getUniformLocation("viewPos"), 1, glm::value_ptr(camera->getPosition()));
glUniform3f(shaderPointLight.getUniformLocation("light.ambient"), 0.2, 0.2, 0.2);
glUniform3f(shaderPointLight.getUniformLocation("light.diffuse"), 0.2, 0.3, 0.6);
glUniform3f(shaderPointLight.getUniformLocation("light.specular"), 0.5, 0.3, 0.2);
glUniform3f(shaderPointLight.getUniformLocation("material.ambient"), 1.0, 0.2, 0.6);
glUniform3f(shaderPointLight.getUniformLocation("material.diffuse"), 0.4, 0.5, 0.8);
glUniform3f(shaderPointLight.getUniformLocation("material.specular"), 0.5, 0.3, 0.2);
glUniform1f(shaderPointLight.getUniformLocation("light.constant"), 1.0f);
glUniform1f(shaderPointLight.getUniformLocation("light.linear"), 0.7f);
glUniform1f(shaderPointLight.getUniformLocation("light.quadratics"), 1.8f);
glUniform1f(shaderPointLight.getUniformLocation("material.shininess"), 32.0);
//LUZ EXTERNA
shaderPointLight2.turnOn();
glUniform3fv(shaderPointLight2.getUniformLocation("light.position"), 1, glm::value_ptr(glm::vec3(0.0, 5.0, -9.0)));
glUniform3fv(shaderPointLight2.getUniformLocation("light.direction"), 1, glm::value_ptr(glm::vec3(-0.3f, -1.0f, -0.2f)));
glUniform3fv(shaderPointLight2.getUniformLocation("viewPos"), 1, glm::value_ptr(camera->getPosition()));
glUniform3f(shaderPointLight2.getUniformLocation("light.ambient"), 0.2, 0.2, 0.2);
glUniform3f(shaderPointLight2.getUniformLocation("light.diffuse"), 0.2, 0.3, 0.6);
glUniform3f(shaderPointLight2.getUniformLocation("light.specular"), 0.5, 0.3, 0.2);
glUniform3f(shaderPointLight2.getUniformLocation("material.ambient"), 1.0, 0.2, 0.6);
glUniform3f(shaderPointLight2.getUniformLocation("material.diffuse"), 0.4, 0.5, 0.8);
glUniform3f(shaderPointLight2.getUniformLocation("material.specular"), 0.5, 0.3, 0.2);
glUniform1f(shaderPointLight2.getUniformLocation("light.constant"), 1.0f);
glUniform1f(shaderPointLight2.getUniformLocation("light.linear"), 0.7f);
glUniform1f(shaderPointLight2.getUniformLocation("light.quadratics"), 1.8f);
glUniform1f(shaderPointLight2.getUniformLocation("material.shininess"), 32.0);
//RENDERIZACION DE LAS FIGURAS
glBindTexture(GL_TEXTURE_2D, textureID4); //BASE
box.setShader(&shaderTexture);
box.setProjectionMatrix(projection);
box.setViewMatrix(view);
box.setPosition(glm::vec3(0.0, -0.8, -20.0));
box.setScale(glm::vec3(10.0, 0.4, 20.0));
box.render();
box.setShader(&shaderPointLight2); //pared delantera
glBindTexture(GL_TEXTURE_2D, textureID2);
box.setPosition(glm::vec3(0.0, 1.0, -10.0));
box.setScale(glm::vec3(10.0, 4.0, 0.4));
box.render(6, 12);
glBindTexture(GL_TEXTURE_2D, textureID6);
box.render(0, 6);
box.render(12, 36);
//ILUMINACION LUZ INTERNA
box.setShader(&shaderPointLight); //pared delantera
glBindTexture(GL_TEXTURE_2D, textureID2);
box.setPosition(glm::vec3(0.0, 1.0, -10.0));
box.setScale(glm::vec3(10.0, 4.0, 0.4));
box.render(6, 12);
glBindTexture(GL_TEXTURE_2D, textureID6);
box.render(0, 6);
box.render(12, 36);
glBindTexture(GL_TEXTURE_2D, textureID1); //pared izquierda
box.setPosition(glm::vec3(-5.0, 1.0, -20.0));
box.setScale(glm::vec3(0.4, 4.0, 20.0));
box.render();
glBindTexture(GL_TEXTURE_2D, textureID1); //pared derecha
box.setPosition(glm::vec3(5.0, 1.0, -20.0));
box.setScale(glm::vec3(0.4, 4.0, 20.0));
box.render();
glBindTexture(GL_TEXTURE_2D, textureID1); //pared trasera
box.setPosition(glm::vec3(0.0, 1.0, -30.0));
box.setScale(glm::vec3(10.0, 4.0, 0.4));
box.render();
glBindTexture(GL_TEXTURE_2D, textureID5); //pared separacion
box.setPosition(glm::vec3(-1.0, 1.0, -23.0));
box.setScale(glm::vec3(8.0, 4.0, 0.4));
box.render();
glBindTexture(GL_TEXTURE_2D, textureID7); //techo
box.setPosition(glm::vec3(0.0, 3.0, -20.0));
box.setScale(glm::vec3(12.0, 0.4, 22.0));
box.render();
glBindTexture(GL_TEXTURE_2D, textureID16); //mesa de centro
cylinder2.setShader(&shaderPointLight);
cylinder2.setProjectionMatrix(projection);
cylinder2.setViewMatrix(view);
cylinder2.setPosition(glm::vec3(-1.0, -0.3, -18.0));
cylinder2.setScale(glm::vec3(0.6, 0.6, 0.6));
cylinder2.render(0, cylinder.getSlices() * cylinder.getStacks() * 2 * 3);
glBindTexture(GL_TEXTURE_2D, textureID16);
cylinder2.render(cylinder2.getSlices() * cylinder2.getStacks() * 2 * 3, cylinder2.getSlices() * 3);
glBindTexture(GL_TEXTURE_2D, textureID16);
cylinder2.render(cylinder2.getSlices() * cylinder2.getStacks() * 2 * 3 + cylinder2.getSlices() * 3, cylinder2.getSlices() * 3);
glBindTexture(GL_TEXTURE_2D, textureID8); //sillon grande
box.setPosition(glm::vec3(-2.5, -0.35, -18.0));
box.setScale(glm::vec3(1.0, 0.5, 3.0));
box.render();
box.setPosition(glm::vec3(-2.85, 0.15, -18.0));
box.setScale(glm::vec3(0.3, 0.5, 3.0));
box.render();
box.setPosition(glm::vec3(0.5, -0.35, -18.0));
box.setScale(glm::vec3(1.0, 0.5, 3.0));
box.render();
box.setPosition(glm::vec3(0.85, 0.15, -18.0));
box.setScale(glm::vec3(0.3, 0.5, 3.0));
box.render();
glBindTexture(GL_TEXTURE_2D, textureID8); //sillon pequeรฑo
box.setPosition(glm::vec3(-1.0, -0.35, -16.5));
box.setScale(glm::vec3(1.0, 0.5, 1.0));
box.render();
glBindTexture(GL_TEXTURE_2D, textureID16); //mueble pantalla
box.setPosition(glm::vec3(-1.0, 0.15, -22.3));
box.setScale(glm::vec3(3.0, 1.5, 1.0));
box.render();
glBindTexture(GL_TEXTURE_2D, textureID11); //pantalla
box.setPosition(glm::vec3(-1.0, 1.7, -22.3));
box.setScale(glm::vec3(2.5, 1.5, 0.05));
box.render();
//librero
glBindTexture(GL_TEXTURE_2D, textureID14);
box.setPosition(glm::vec3(-4.2, 1.0, -13.5));
box.setScale(glm::vec3(1.0, 3.0, 4.0));
box.render(6, 12);
glBindTexture(GL_TEXTURE_2D, textureID16);
box.render(0, 6);
box.render(12, 36);
glBindTexture(GL_TEXTURE_2D, textureID10); //cuadro
box.setPosition(glm::vec3(-4.8, 1.5, -19.0));
box.setScale(glm::vec3(0.1, 2.0, 1.5));
box.render();
box.setShader(&shaderPointLight);
glBindTexture(GL_TEXTURE_2D, textureID15); //cocina integral
box.setPosition(glm::vec3(-3.7, 1.0, -26.5));
box.setScale(glm::vec3(2.0, 3.0, 5.0));
box.render(6, 12);
glBindTexture(GL_TEXTURE_2D, textureID9);
box.render(0, 6);
box.render(12, 36);
glBindTexture(GL_TEXTURE_2D, textureID12); //refri
box.setPosition(glm::vec3(0.0, 0.6, -23.8));
box.setScale(glm::vec3(2.0, 2.5, 1.5));
box.render(12, 18);
glBindTexture(GL_TEXTURE_2D, textureID9);
box.render(0, 12);
box.render(18, 36);
glBindTexture(GL_TEXTURE_2D, textureID13); //estufa
box.setPosition(glm::vec3(0.0, 0.15, -29.1));
box.setScale(glm::vec3(1.2, 1.5, 1.5));
box.render(0, 6);
glBindTexture(GL_TEXTURE_2D, textureID9);
box.render(6, 36);
// shaderPointLight.turnOff();
glBindTexture(GL_TEXTURE_2D, 0);
//LUZ EXTERNA
shaderPointLight2.turnOn();
glUniform3fv(shaderPointLight2.getUniformLocation("light.position"), 1, glm::value_ptr(glm::vec3(0.0, 5.0, -5.0)));
glUniform3fv(shaderPointLight2.getUniformLocation("light.direction"), 1, glm::value_ptr(glm::vec3(-0.3f, -1.0f, -0.2f)));
glUniform3fv(shaderPointLight2.getUniformLocation("viewPos"), 1, glm::value_ptr(camera->getPosition()));
glUniform3f(shaderPointLight2.getUniformLocation("light.ambient"), 0.2, 0.2, 0.2);
glUniform3f(shaderPointLight2.getUniformLocation("light.diffuse"), 0.2, 0.3, 0.6);
glUniform3f(shaderPointLight2.getUniformLocation("light.specular"), 0.5, 0.3, 0.2);
glUniform3f(shaderPointLight2.getUniformLocation("material.ambient"), 1.0, 0.2, 0.6);
glUniform3f(shaderPointLight2.getUniformLocation("material.diffuse"), 0.4, 0.5, 0.8);
glUniform3f(shaderPointLight2.getUniformLocation("material.specular"), 0.5, 0.3, 0.2);
glUniform1f(shaderPointLight2.getUniformLocation("light.constant"), 1.0f);
glUniform1f(shaderPointLight2.getUniformLocation("light.linear"), 0.7f);
glUniform1f(shaderPointLight2.getUniformLocation("light.quadratics"), 1.8f);
glUniform1f(shaderPointLight2.getUniformLocation("material.shininess"), 32.0);
shaderPointLight.turnOff();
shaderPointLight2.turnOff();
glBindTexture(GL_TEXTURE_2D, 0);
}
if (angle > 2 * M_PI)
angle = 0.0;
else
angle += 0.004;
/*sphere.setShader(&shaderColor);
sphere.setColor(glm::vec3(0.4f, 0.3f, 0.6f));
sphere.setProjectionMatrix(projection);
sphere.setViewMatrix(view);
sphere.setScale(glm::vec3(1.0f, 1.0f, 1.0f));
sphere.enableWireMode();
sphere.render(lightModelmatrix);
*/
//rendrizado de Skybox
// Se Dibuja el Skybox
GLint oldCullFaceMode;
GLint oldDepthFuncMode;
glGetIntegerv(GL_CULL_FACE_MODE, &oldCullFaceMode);
glGetIntegerv(GL_DEPTH_FUNC, &oldDepthFuncMode);
shaderCubeTexture.turnOn();
GLuint cubeTextureId = shaderCubeTexture.getUniformLocation("skybox");
glUniform1f(cubeTextureId, 0);
glCullFace(GL_FRONT);
glDepthFunc(GL_LEQUAL);
sphere.setShader(&shaderCubeTexture);
sphere.setProjectionMatrix(projection);
sphere.setViewMatrix(glm::mat4(glm::mat3(view)));
sphere.setScale(glm::vec3(20.0f, 20.0f, 20.0f));
sphere.render();
glCullFace(oldCullFaceMode);
glDepthFunc(oldDepthFuncMode);
shaderCubeTexture.turnOff();
glfwSwapBuffers(window);
}
}
int main(int argc, char ** argv) {
init(800, 700, "Window GLFW", false);
applicationLoop();
destroy();
return 1;
}
|
d19b4ab736b0b3a7122dcde234a82ade9e7b527e
|
71ef8e94ca186e048e900f0e0d1401b25245bbfb
|
/Queue (Linked)/Queue.cpp
|
ce947e306a18af628d4ac4564a92cb9dc05fa8a6
|
[] |
no_license
|
AmrBumadian/Data-Structures-Implementation
|
7c3cbf027c637b1a2d6ec56ffae8c167d9721372
|
814ad3d37fd2840cfbca097b3687d88e56507b7d
|
refs/heads/master
| 2023-02-11T05:01:57.388522
| 2021-01-09T05:59:41
| 2021-01-09T05:59:41
| 267,096,161
| 1
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 2,651
|
cpp
|
Queue.cpp
|
#include "Queue.h"
#include <assert.h>
#include <iostream>
using namespace std;
template<class T>
void Queue<T>::copy(const Queue<T> &other) {
length = other.length;
head = new Node<T>(other.head->value); // deep copy for head;
tail = head;
Node<T> *current = other.head->next; // pointer to the next node in other to be copied
while (current != nullptr) {
Node<T> *newNode = new Node<T>(current->value);
tail->next = newNode; // point the tail next to the new node
tail = newNode; // make the new node the tail
current = current->next; // get next element ot be copied
}
}
template<class T>
Queue<T>::Queue() : length(0), head(nullptr), tail(nullptr) {}
template<class T>
Queue<T>::Queue(const Queue<T> &other) {
if (other.head != nullptr) { copy(other); } // avoid method call for empty Queue
else {
head = tail = nullptr;
}
}
template<class T>
Queue<T> &Queue<T>::operator=(const Queue<T> &other) {
if (this != &other && other.head != nullptr) { // avoid self-assignemnt and method call for empty Queue
clear(); // de-allocate
copy(other);
}
return *this; // return this object by reference
}
template<class T>
Queue<T>::~Queue() {
Node<T> *garbage;
while (head != nullptr) {
Node<T> *garbage = head;
head = head->next;
delete garbage;
}
}
template<class T>
void Queue<T>::push(T value) {
Node<T> *newNode = new Node<T>(value);
if (length == 0) {
head = tail = newNode;
} else {
tail->next = newNode; // point the tail next to the new node
tail = newNode; // make the new node the tail
}
++length;
}
template<class T>
T Queue<T>::pop() {
if (length != 0) {
T value = head->value; // value to be returned
Node<T> *garbage = head; // point to the front element
head = head->next; // make the next element the front
delete garbage; // delete the node
--length;
return value;
} else {
cerr << "\ncannot delete from empty Queue\n";
}
}
template<class T>
T Queue<T>::front() {
assert(length != 0);
return head->value;
}
template<class T>
T Queue<T>::back() {
assert(length != 0);
return tail->value;
}
template<class T>
int Queue<T>::size() {
return length;
}
template<class T>
bool Queue<T>::empty() {
return (length == 0);
}
template<class T>
void Queue<T>::clear() { // reset all
Node<T> *garbage;
while (head != nullptr) {
Node<T> *garbage = head;
head = head->next;
delete garbage;
}
tail = nullptr;
length = 0;
}
|
50349c4d4055b1fbc9a1af5b7f7c165812d91f6c
|
11983471fa3c97ae4170a9e598c0d058102470b2
|
/workshop1/at_home/School.cpp
|
32abb7ad2f66a57a1427ac92e5a1b18d76386494
|
[] |
no_license
|
anmol-garg-001/OOP244
|
85bc7978ab461b9079bbc21c3a8e0a6aa42bef23
|
2a072e0470a9b1bd770d6f02d09f967856a73e36
|
refs/heads/main
| 2023-01-18T22:34:08.332691
| 2020-11-21T02:36:25
| 2020-11-21T02:36:25
| 311,226,267
| 2
| 1
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 1,480
|
cpp
|
School.cpp
|
//I have done all the coding by myself and only copied the code that my professor provided to complete my workshops and assignments.
// Name : Anmol Garg
// Student ID: 149916199
// Student email: agarg15@myseneca.ca
// Date : 27 Sept, 2020
#include <iostream>
#include <cstring>
#include "School.h"
#include "File.h"
using namespace std;
namespace sdds {
School schools[NUMSCHOOLS];
// loads all the school codes and extensions into the global array of structures.
bool loadSchools() {
School sch;
int snum = 0; // number of school codes read
bool ok = true;
if (openFile("schools.dat")) {
while (ok && snum < NUMSCHOOLS) {
ok = readCode(sch.schoolCode) && readExtension(&sch.extensionNumber);
if (ok) schools[snum++] = sch;
}
closeFile();
}
return snum == NUMSCHOOLS;
}
// returns true is the school code matches with any of the records
bool hasSchoolCode(const School* schp, const char schCode[]) {
bool found = false;
if (!strcmp(schp->schoolCode, schCode)) {
found = true;
}
return found;
}
// displays the extension number associated with the school code
void displaySchoolExtension(const char schoolCode[]) {
int i;
bool flag = true;
for (i = 0; i < NUMSCHOOLS && flag; i++) {
if (hasSchoolCode(&schools[i], schoolCode)) {
cout << "416 491 5050 x " << schools[i].extensionNumber << endl;
flag = false;
}
}
if (flag == true) {
cout << schoolCode << " School code not found!" << endl;
}
}
}
|
75feaa7275a63b901595fbb1b9f89b0a0e6245b0
|
6b268094525802d5412921f037e38fc87a87b511
|
/Classes/extension/advance/DiTranslation.cpp
|
05cc4a9e08df24b5f9bd60e874501605c702d836
|
[] |
no_license
|
dianzihe/congship
|
ab2fa1815acef56d624c32a782406d37a43f72e7
|
321b7cab186d46527bddc26b3838de68ed25584c
|
refs/heads/master
| 2021-05-02T15:53:47.122626
| 2018-12-14T13:06:24
| 2018-12-14T13:06:24
| 120,702,879
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 3,756
|
cpp
|
DiTranslation.cpp
|
//
// DiTranslation.cpp
// SanguoHeros
//
// Created by ไผ ๆ on 12-11-30.
// Copyright (c) 2012ๅนด __MyCompanyName__. All rights reserved.
//
#include <iostream>
#include "DiTranslation.h"
DiTranslation::DiTranslation():m_pDelegates(NULL),m_pBuffer(NULL),m_bEnable(true)
{
m_pDelegates = new CCArray();
m_pBuffer = new CCArray();
}
DiTranslation::~DiTranslation()
{
CC_SAFE_RELEASE_NULL(m_pDelegates);
CC_SAFE_RELEASE_NULL(m_pBuffer);
}
bool DiTranslation::init()
{
if(!CCLayer::init())
return false;
setTouchEnabled(true);
return true;
}
void DiTranslation::registerWithTouchDispatcher()
{
CCDirector::sharedDirector()->getTouchDispatcher()->addTargetedDelegate(this, -99, true);
}
bool DiTranslation::ccTouchBegan(cocos2d::CCTouch *pTouch, cocos2d::CCEvent *pEvent)
{
if(!m_bEnable)
return false;
if(!isAllParentVisible())
return false;
CCObject* pObj = NULL;
CCARRAY_FOREACH(m_pDelegates, pObj)
{
CCTouchDelegate* delegate = dynamic_cast<CCTouchDelegate*>(pObj);
if(delegate)
{
assert(delegate != this);
if(delegate->ccTouchBegan(pTouch, pEvent))
{
m_pBuffer->addObject(pObj);
}
}
}
return true;
}
void DiTranslation::ccTouchMoved(cocos2d::CCTouch *pTouch, cocos2d::CCEvent *pEvent)
{
CCObject* pObj = NULL;
CCARRAY_FOREACH(m_pBuffer, pObj)
{
CCTouchDelegate* delegate = dynamic_cast<CCTouchDelegate*>(pObj);
if(delegate)
{
delegate->ccTouchMoved(pTouch, pEvent);
}
}
}
void DiTranslation::ccTouchEnded(cocos2d::CCTouch *pTouch, cocos2d::CCEvent *pEvent)
{
CCObject* pObj = NULL;
CCARRAY_FOREACH(m_pBuffer, pObj)
{
CCTouchDelegate* delegate = dynamic_cast<CCTouchDelegate*>(pObj);
if(delegate)
{
delegate->ccTouchEnded(pTouch, pEvent);
}
}
m_pBuffer->removeAllObjects();
}
void DiTranslation::ccTouchCancelled(cocos2d::CCTouch *pTouch, cocos2d::CCEvent *pEvent)
{
CCObject* pObj = NULL;
CCARRAY_FOREACH(m_pBuffer, pObj)
{
CCTouchDelegate* delegate = dynamic_cast<CCTouchDelegate*>(pObj);
if(delegate)
{
delegate->ccTouchCancelled(pTouch, pEvent);
}
}
m_pBuffer->removeAllObjects();
}
void DiTranslation::addDelegate(CCObject* delegate, ...)
{
assert(delegate);
va_list params;
va_start(params, delegate);
CCObject* next = delegate;
do
{
if(!m_pDelegates->containsObject(next) && dynamic_cast<CCTouchDelegate*>(next))
{
assert(next != this);
m_pDelegates->addObject(next);
}
next = va_arg(params, CCObject*);
} while (next);
va_end(params);
}
void DiTranslation::removeDelegate(cocos2d::CCObject *delegate, ...)
{
assert(delegate);
va_list params;
va_start(params, delegate);
CCObject* next = delegate;
do
{
if(m_pDelegates->containsObject(next) && dynamic_cast<CCTouchDelegate*>(next))
{
m_pDelegates->removeObject(next);
}
next = va_arg(params, CCObject*);
} while (next);
va_end(params);
}
void DiTranslation::removeAllDelegate()
{
m_pDelegates->removeAllObjects();
}
void DiTranslation::setEnable(bool var)
{
m_bEnable = var;
}
bool DiTranslation::getEnable()
{
return m_bEnable;
}
bool DiTranslation::isAllParentVisible()
{
CCNode* parent = getParent();
while (parent)
{
if(parent->isVisible())
{
parent = parent->getParent();
}
else
{
return false;
}
}
return true;
}
|
b499f1d250262e08c615efb69b4df35a05012fbe
|
e090a7a4de62bef5cb2a4a272ea768abeee1ba9d
|
/Graduation/Client/DustLayer.cpp
|
98f9d43dc63cc40bf8f16714beee09173ae68e5b
|
[] |
no_license
|
ParkJWoo/graduationProject
|
280e0a6b75a439e926073bdf21bbf874cc91a640
|
f29766b2c34622a2d73397d258306f4aa390638d
|
refs/heads/main
| 2023-01-08T11:36:03.018859
| 2020-11-19T13:01:10
| 2020-11-19T13:01:10
| 314,222,736
| 0
| 0
| null | null | null | null |
UHC
|
C++
| false
| false
| 1,573
|
cpp
|
DustLayer.cpp
|
#include "stdafx.h"
#include "DustLayer.h"
CDustLayer::CDustLayer()
{
}
CDustLayer::~CDustLayer()
{
Release();
}
HRESULT CDustLayer::Initialize()
{
if (FAILED(CTextureMgr::GetInstance()->InsertTexture(L"../Texture/Dialog/Partical_Layer.png", L"Dust", TEX_SINGLE)))
{
ERR_MSG(L"Dust Layer Image Insert Failed!!!");
return E_FAIL;
}
//m_tInfo.vPos = D3DXVECTOR3(500.f, 500.f, 0.f);
return S_OK;
}
int CDustLayer::Update()
{
D3DXMATRIX matScale, matRotZ, matTrans;
D3DXMatrixScaling(&matScale, 1.f, 1.f, 1.f);
D3DXMatrixTranslation(&matTrans, m_tInfo.vPos.x, m_tInfo.vPos.y - CScrollMgr::GetScroll().y, 0.f);
m_tInfo.matWorld = matScale * matTrans;
m_tInfo.vPos += D3DXVECTOR3(0.004f, 0.004f, 0.f);
return NO_EVENT;
}
void CDustLayer::LateUpdate()
{
}
void CDustLayer::Render()
{
const TEXINFO* pTexInfo = CTextureMgr::GetInstance()->GetTexture(L"Dust");
//// SetTransform: ํ๋ ฌ์ ๋ฐ์ํ๋ ํจ์.
CDevice::GetInstance()->GetSprite()->SetTransform(&m_tInfo.matWorld);
// ์ด๋ฏธ์ง์ ์ค์ ๊ตฌํ๊ธฐ.
int iCenterX = pTexInfo->tImgInfo.Width / 2;
int iCenterY = pTexInfo->tImgInfo.Height / 2;
//// ์์ผ๋ก ๋ชจ๋ ์ค๋ธ์ ํธ์ ๋ ๋๋ง์ ์ด ์ฌ์ด์์ ์งํ.
CDevice::GetInstance()->GetSprite()->Draw(pTexInfo->pTexture,
nullptr /*์ถ๋ ฅํ ์ด๋ฏธ์ง ์์ญ์ RECT*/,
&D3DXVECTOR3((float)iCenterX - 100.f, (float)iCenterY - 100.f, 0.f) /*์ถ๋ ฅํ ์ด๋ฏธ์ง์ ์ค์ฌ ์ขํ D3DXVECTOR3*/,
nullptr /*์ถ๋ ฅํ ์์น ์ขํ D3DXVECTOR3*/,
D3DCOLOR_ARGB(100, 255, 255, 255));
}
void CDustLayer::Release()
{
}
|
9240e090a2981256f1497d34854231c4d2b7c918
|
f30aa53705fd826840bf00b119aabfb0bd2ed1fa
|
/ArduinoDoorSensor.ino
|
b81336395ae4e5f9d1643440ed8bd9ff9d497068
|
[] |
no_license
|
AlexanderLutz75/ArduinoDoorSensor
|
3798191afeadb18d594c65e8b8a33a55b550aa25
|
ea1a2f516dd72aea6393a877c94e9876dc875423
|
refs/heads/master
| 2020-04-27T19:50:43.921687
| 2019-03-09T01:57:50
| 2019-03-09T01:57:50
| null | 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 6,314
|
ino
|
ArduinoDoorSensor.ino
|
#include <RCSwitch.h>
#include <EEPROM.h>
RCSwitch mySwitch = RCSwitch();
const int MAXSTORAGE = 100;
const int EEPROMLocation = 0;
unsigned long codeArray[MAXSTORAGE]; //create Array for saved codes
unsigned long timerArray[MAXSTORAGE];
int arraylength = sizeof(codeArray) / sizeof(codeArray[0]); //The actual length of storage
const unsigned long debouncePeriod = 1000; //the time we wait for debouncing in millis
const unsigned long savePeriod = 5000; //save if held for 5 seconds
const unsigned long clearPeriod = 10000; //delete if held for 10 seconds
unsigned long pressMillis; //time when button is pressed
unsigned long holdMillis; //measures duration of the hold
unsigned long debounceMillis; //Measures the time when a key is recieved
const int buttonPin = 12; // the number of the pushbutton pin
const int ledPin = 13; // the number of the LED pin
int buttonState = HIGH; // variable for reading the pushbutton status
unsigned long value = 0; //Storage for recieved keys
String message = "AT!GX APP SENDGNXMSG";
String command = "";
String key = "";
void setup() {
Serial.begin(9600);
Serial.println("Powered on");
mySwitch.enableReceive(0); // Receiver on interrupt 0 => that is pin #2
pinMode(ledPin, OUTPUT); // initialize the LED pin as an output:
pinMode(buttonPin, INPUT_PULLUP); // initialize the pushbutton pin as an input:
EEPROM.get( EEPROMLocation, codeArray ); //first thing we do during start up is to load EEPROM into a local array.
buttonState = digitalRead(buttonPin);
if(buttonState == LOW){
pressMillis = millis(); //Static time that is measure when button is pressed ex)pressMillis = 0
}
while(buttonState == LOW){
holdMillis = millis(); //this timer will grow after each loop until ex)holdMillis = 10000
if(holdMillis - pressMillis >= clearPeriod){
clearKeys();
break;
}
}
}
void loop() {
buttonState = digitalRead(buttonPin);
if(buttonState == LOW){
pressMillis = millis(); //ex)pressMillis = 0
}
while(buttonState == LOW){
buttonState = digitalRead(buttonPin);
holdMillis = millis(); //check how long is held. ex)holdMillis = 5000
if(holdMillis - pressMillis >= savePeriod){
saveKey();
mySwitch.resetAvailable();
}
}
if (mySwitch.available()){
recieveKey();
mySwitch.resetAvailable();
}
}
void clearKeys(){
Serial.println("now clearing keys");
for (int i=0 ; i<30 ; i++){
digitalWrite(ledPin, HIGH); //LED ON
delay(50);
digitalWrite(ledPin, LOW); //LED OFF
delay(50);
}
for(int i=0; i<arraylength; i++){
codeArray[i]=0; //clear the local array
EEPROM.put(EEPROMLocation, codeArray); //Saves cleared array to EEPROM
}
}
void saveKey(){
Serial.println("now saving keys");
for (int i=0 ; i<3 ; i++){
digitalWrite(ledPin, HIGH); //LED ON
delay(750);
digitalWrite(ledPin, LOW); //LED OFF
delay(750);
}
unsigned long value = mySwitch.getReceivedValue();
if (value == 0) {
Serial.println("Unknown encoding");
return;
}
//Check our code array to see if valid input
for(int i=0; i < arraylength; i++){
if(codeArray[i]==value){ //if we found it
Serial.println("Key already exists");
return;
}
}
for(int i=0; i<arraylength; i++){
if(codeArray[i] == 0){
codeArray[i] = value; //Any time we modify the local the array it needs to be saved
EEPROM.put(EEPROMLocation, codeArray); //Saves the current code array into EEPROM
Serial.println("key saved");
return;
}
}
Serial.println("Key storage is full");
}
void serialSave(){
Serial.println("saving key from serial input");
if(key != NULL){
value = key.toInt(); //handles Serial commands
}
if (value == 0) {
Serial.println("Unknown encoding");
return;
}
//Check our code array to see if valid input
for(int i=0; i < arraylength; i++){
if(codeArray[i]==value){ //if we found it
Serial.println("key already exists");
return;
}
}
for(int i=0; i<arraylength; i++){
if(codeArray[i] == 0){
codeArray[i] = value; //Any time we modify the local the array it needs to be saved
EEPROM.put(EEPROMLocation, codeArray); //Saves the current code array into EEPROM
Serial.println("key saved");
return;
}
}
Serial.println("Key storage is full");
}
void deleteKey(){
Serial.println("deleting key");
if(key != NULL){
value = key.toInt(); //handles Serial commands
}
if (value == 0) {
Serial.println("Unknown encoding");
return;
}
//Check our code array to see if valid input
for(int i=0; i < arraylength; i++){
if(codeArray[i]==value){ //if we found it
codeArray[i]=0;
EEPROM.put(EEPROMLocation, codeArray); //Saves the current code array into EEPROM
Serial.println("key deleted");
return;
}
}
Serial.println("The selected Key doesnt exist");
}
void recieveKey(){
unsigned long debounceMillis = millis();
unsigned long value = mySwitch.getReceivedValue();
if (value == 0) {
Serial.println("Unknown encoding");
} else {
//Check our code array to see if valid input
for(int i=0; i < arraylength; i++){
if(codeArray[i]==value){ //if we found it
if(timerArray[i]==0){ //check the timer if this is first time we make a timer
Serial.println(message + value);
timerArray[i] = debounceMillis + 1000;
}
else if(debounceMillis >= timerArray[i]){
Serial.println(message + value);
timerArray[i] = debounceMillis + 1000;
}
}
}
}
}
void serialEvent() { //Logic for taking serial ATCommands
if (Serial.available()) {
command="";
key = "";
command = Serial.readStringUntil(';'); //commands are delimited by semicolon
if(command.substring(0,7) == "ATLEARN"){
key = command.substring(8);
serialSave();
}
if(command.substring(0,7) == "ATCLEAR"){
key = command.substring(8);
deleteKey();
}
if (command.substring(0,9) == "ATFACTORY") {
clearKeys();
}
}
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.