hexsha
stringlengths 40
40
| size
int64 7
1.05M
| ext
stringclasses 13
values | lang
stringclasses 1
value | max_stars_repo_path
stringlengths 4
269
| max_stars_repo_name
stringlengths 5
108
| max_stars_repo_head_hexsha
stringlengths 40
40
| max_stars_repo_licenses
listlengths 1
9
| max_stars_count
int64 1
191k
⌀ | max_stars_repo_stars_event_min_datetime
stringlengths 24
24
⌀ | max_stars_repo_stars_event_max_datetime
stringlengths 24
24
⌀ | max_issues_repo_path
stringlengths 4
269
| max_issues_repo_name
stringlengths 5
116
| max_issues_repo_head_hexsha
stringlengths 40
40
| max_issues_repo_licenses
listlengths 1
9
| max_issues_count
int64 1
67k
⌀ | max_issues_repo_issues_event_min_datetime
stringlengths 24
24
⌀ | max_issues_repo_issues_event_max_datetime
stringlengths 24
24
⌀ | max_forks_repo_path
stringlengths 4
269
| max_forks_repo_name
stringlengths 5
116
| max_forks_repo_head_hexsha
stringlengths 40
40
| max_forks_repo_licenses
listlengths 1
9
| max_forks_count
int64 1
105k
⌀ | max_forks_repo_forks_event_min_datetime
stringlengths 24
24
⌀ | max_forks_repo_forks_event_max_datetime
stringlengths 24
24
⌀ | content
stringlengths 7
1.05M
| avg_line_length
float64 1.21
330k
| max_line_length
int64 6
990k
| alphanum_fraction
float64 0.01
0.99
| author_id
stringlengths 2
40
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
d609367837cf3353590aa149bec33ad2091ee04c
| 386
|
cpp
|
C++
|
Chapter13/drills/Drill_01.cpp
|
JohnWoods11/learning_c-
|
094509a4e96518e1aa12205615ca50849932f9fa
|
[
"Apache-2.0"
] | null | null | null |
Chapter13/drills/Drill_01.cpp
|
JohnWoods11/learning_c-
|
094509a4e96518e1aa12205615ca50849932f9fa
|
[
"Apache-2.0"
] | null | null | null |
Chapter13/drills/Drill_01.cpp
|
JohnWoods11/learning_c-
|
094509a4e96518e1aa12205615ca50849932f9fa
|
[
"Apache-2.0"
] | null | null | null |
#include "GUI/Graph.h"
#include "GUI/Simple_window.h"
#include "GUI/std_lib_facilities.h"
#include <iostream>
void drill_1()
{
const Point py(50,50);
Simple_window win(py, 1000, 800, "Drill 1");
win.wait_for_button();
}
int main()
{
try
{
drill_1();
}
catch (...)
{
cout << "MAJOR ERROR!";
return -1;
}
return 0;
}
| 14.296296
| 48
| 0.544041
|
JohnWoods11
|
d61643ba5639fa71ed176aef294c2198c0a17df3
| 1,207
|
cpp
|
C++
|
special/2/2.cpp
|
249606097/Cpp-Experiment
|
6d97388664f125853193e9d00a1f9ee53ffde21c
|
[
"MIT"
] | null | null | null |
special/2/2.cpp
|
249606097/Cpp-Experiment
|
6d97388664f125853193e9d00a1f9ee53ffde21c
|
[
"MIT"
] | null | null | null |
special/2/2.cpp
|
249606097/Cpp-Experiment
|
6d97388664f125853193e9d00a1f9ee53ffde21c
|
[
"MIT"
] | null | null | null |
#include <iostream>
#include <ctime>
#include <cstdlib>
#include <cmath>
#include <ctime>
using namespace std;
bool in_circle(double x, double y);
int main()
{
double e = 0.01;
int n = 1000;
double pi = 100.0;
double residual = 100.0;
int count = 0;
while (residual > e)
{
int m=0;
srand(unsigned(time(0)));
for (int i=0; i<n; i++)
{
int x = rand();
int y = rand();
if (in_circle(double(x)/double(RAND_MAX), double(y)/double(RAND_MAX)))
m += 1;
}
residual = fabs(pi - 4.0 * double(m) / double(n));
if (count == 1)
{
pi = 4.0 * double(m) / double(n);
}
else
{
pi = (pi * count + 4.0 * double(m) / double(n)) / (count + 1);
}
count++;
}
cout << pi << endl;
system("PAUSE");
return 0;
}
bool in_circle(double x, double y)
{
double distance;
bool is_in_circle = false;
distance = (x-0.5)*(x-0.5) + (y-0.5)*(y-0.5);
if (distance<=0.25)
is_in_circle = true;
return is_in_circle;
}
| 21.175439
| 83
| 0.451533
|
249606097
|
d61ba495fd2b7c347312e10be17db6a4d5d4f7ad
| 3,409
|
cpp
|
C++
|
src/system.cpp
|
MisaghM/Doodle-Jump
|
850e529547e83e7a3a0607fea635517bf2e3bcc4
|
[
"MIT"
] | 2
|
2021-09-02T20:05:34.000Z
|
2021-11-05T19:38:15.000Z
|
src/system.cpp
|
MisaghM/Doodle-Jump
|
850e529547e83e7a3a0607fea635517bf2e3bcc4
|
[
"MIT"
] | null | null | null |
src/system.cpp
|
MisaghM/Doodle-Jump
|
850e529547e83e7a3a0607fea635517bf2e3bcc4
|
[
"MIT"
] | null | null | null |
#include "system.hpp"
#include "enemies/enemy_normal.hpp"
#include "items/spring.hpp"
#include "platforms/platform_breakable.hpp"
#include "platforms/platform_movable.hpp"
#include "platforms/platform_normal.hpp"
#include "spritesheet.hpp"
System::System(Window* win_)
: win_(win_),
menuScene_(&inputMan_),
pauseScene_(&inputMan_) {
scenes_.push_back(&menuScene_);
}
bool System::update() {
inputMan_.reset();
while (win_->has_pending_event()) {
Event e = win_->poll_for_event();
switch (e.get_type()) {
case Event::EventType::QUIT: return false;
case Event::EventType::KEY_PRESS:
inputMan_.keyPressed(e.get_pressed_key());
break;
case Event::EventType::KEY_RELEASE:
inputMan_.keyReleased(e.get_pressed_key());
break;
case Event::EventType::MMOTION:
inputMan_.setMousePos(e.get_mouse_position());
break;
case Event::EventType::LCLICK:
inputMan_.mouseHandle(InputMouse::Lclick);
break;
case Event::EventType::LRELEASE:
inputMan_.mouseHandle(InputMouse::Lrelease);
break;
default: break;
}
}
if (state_ == SceneState::gameover) scenes_[1]->update(win_, deltaTime, this);
return scenes_.back()->update(win_, deltaTime, this);
}
void System::draw() {
if (state_ == SceneState::pause ||
state_ == SceneState::gameover) scenes_[1]->draw(win_);
scenes_.back()->draw(win_);
}
void System::changeScene(SceneState to) {
switch (state_) {
case SceneState::menu:
if (to == SceneState::game) {
state_ = SceneState::game;
makeGameScene();
scenes_.push_back(gameScene_);
}
break;
case SceneState::game:
if (to == SceneState::pause) {
state_ = SceneState::pause;
scenes_.push_back(&pauseScene_);
}
else if (to == SceneState::gameover) {
state_ = SceneState::gameover;
int height = gameScene_->getScoreHeight();
if (height > recordHeight_) recordHeight_ = height;
gameoverScene_ = new GameoverScene(&inputMan_, height, recordHeight_);
scenes_.push_back(gameoverScene_);
}
break;
case SceneState::pause:
if (to == SceneState::game) {
state_ = SceneState::game;
scenes_.pop_back();
}
break;
case SceneState::gameover:
if (to == SceneState::game) {
state_ = SceneState::game;
delete scenes_.back();
scenes_.pop_back();
delete scenes_.back();
scenes_.pop_back();
makeGameScene();
scenes_.push_back(gameScene_);
}
else if (to == SceneState::menu) {
state_ = SceneState::menu;
delete scenes_.back();
scenes_.pop_back();
delete scenes_.back();
scenes_.pop_back();
}
break;
}
}
void System::makeGameScene() {
int doodleWidth = sprite::doodle[sprite::Doodle::LEFT].w;
int doodleHeight = sprite::doodle[sprite::Doodle::LEFT].h;
gameScene_ = new GameScene(&inputMan_,
RectangleF(win_->get_width() / 2 - doodleWidth / 2, win_->get_height() - doodleHeight, doodleWidth, doodleHeight));
}
| 30.4375
| 146
| 0.581989
|
MisaghM
|
d62204e616f8edb2f0032058d3f6ad907800fbb3
| 1,091
|
cc
|
C++
|
test/test_flann.cc
|
mozuysal/virg-workspace
|
ff0df41ceb288609c5279a85d9d04dbbc178d33e
|
[
"BSD-3-Clause"
] | null | null | null |
test/test_flann.cc
|
mozuysal/virg-workspace
|
ff0df41ceb288609c5279a85d9d04dbbc178d33e
|
[
"BSD-3-Clause"
] | 3
|
2017-02-07T11:26:33.000Z
|
2017-02-07T12:43:41.000Z
|
test/test_flann.cc
|
mozuysal/virg-workspace
|
ff0df41ceb288609c5279a85d9d04dbbc178d33e
|
[
"BSD-3-Clause"
] | null | null | null |
#include "gtest/gtest.h"
#include "flann/flann.hpp"
using flann::Matrix;
using flann::Index;
using flann::LinearIndexParams;
using flann::L2;
using flann::SearchParams;
TEST(flann, linear_index) {
int nn = 2;
float data[4] = { 0.0f, 0.0f,
1.0, 0.5};
Matrix<float> dataset(&data[0], 2, 2);
Index<L2<float> > index(dataset, LinearIndexParams());
index.buildIndex();
float qdata[2] = { 1.0f, 0.0f };
Matrix<float> query(&qdata[0], 1, 2);
Matrix<int> indices(new int[query.rows*nn], query.rows, nn);
Matrix<float> dists(new float[query.rows*nn], query.rows, nn);
index.knnSearch(query, indices, dists, nn, SearchParams());
EXPECT_EQ(1, indices.ptr()[0]);
EXPECT_FLOAT_EQ(0.25f, dists.ptr()[0]);
EXPECT_EQ(0, indices.ptr()[1]);
EXPECT_FLOAT_EQ(1.0f, dists.ptr()[1]);
delete [] indices.ptr();
delete [] dists.ptr();
}
int main(int argc, char **argv) {
::testing::InitGoogleTest(&argc, argv);
return RUN_ALL_TESTS();
}
| 27.275
| 70
| 0.578368
|
mozuysal
|
d628062af287155a56565c17c207e7965ee5875c
| 1,315
|
cpp
|
C++
|
COURSE_WHITE/WEEK_2/CONTAINER/Middle_temperature/main.cpp
|
diekaltesonne/c-plus-plus-modern-development
|
d569bd20465e76aab97111bcd316cd02ebca41dd
|
[
"MIT"
] | null | null | null |
COURSE_WHITE/WEEK_2/CONTAINER/Middle_temperature/main.cpp
|
diekaltesonne/c-plus-plus-modern-development
|
d569bd20465e76aab97111bcd316cd02ebca41dd
|
[
"MIT"
] | null | null | null |
COURSE_WHITE/WEEK_2/CONTAINER/Middle_temperature/main.cpp
|
diekaltesonne/c-plus-plus-modern-development
|
d569bd20465e76aab97111bcd316cd02ebca41dd
|
[
"MIT"
] | null | null | null |
#include <iostream>
#include <vector>
using namespace std;
/*
* Даны значения температуры, наблюдавшиеся в течение N подряд идущих дней.
* Найдите номера дней (в нумерации с нуля) со значением температуры выше среднего арифметического за все N дней.
* Гарантируется, что среднее арифметическое значений температуры является целым числом.
* Формат ввода
* Вводится число N, затем N неотрицательных целых чисел — значения температуры в 0-й, 1-й, ... (N−1)-й день.
* Формат вывода
* Первое число K — количество дней, значение температуры в которых выше среднего арифметического. Затем K целых чисел — номера этих дней.
* Реализуйте функцию vector<int> Reversed(const vector<int>& v), возвращающую копию вектора v, в которой числа переставлены в обратном порядке.
*
*/
int main(){
int n;
cin >> n;
vector<int> temperatures(n);
int sum = 0;
for (int& temperature : temperatures) {
cin >> temperature;
sum += temperature;
}
int average = sum / n;
vector<int> result_indices;
for (int i = 0; i < n; ++i) {
if (temperatures[i] > average) {
result_indices.push_back(i);
}
}
cout << result_indices.size() << endl;
for (int result_index : result_indices) {
cout << result_index << " ";
}
cout << endl;
return 0;
}
| 30.581395
| 144
| 0.669202
|
diekaltesonne
|
d62869904cc8110964fdb3a0ea0fd9355c5e0066
| 44,630
|
cc
|
C++
|
tacacsAuthProxy/src/proxy_server.cc
|
gkumar78/tacacs_auth_proxy
|
bffdfde75e67e075e47f345580bd6adbea8930d5
|
[
"Apache-2.0"
] | null | null | null |
tacacsAuthProxy/src/proxy_server.cc
|
gkumar78/tacacs_auth_proxy
|
bffdfde75e67e075e47f345580bd6adbea8930d5
|
[
"Apache-2.0"
] | null | null | null |
tacacsAuthProxy/src/proxy_server.cc
|
gkumar78/tacacs_auth_proxy
|
bffdfde75e67e075e47f345580bd6adbea8930d5
|
[
"Apache-2.0"
] | null | null | null |
/*
* Copyright 2018-present Open Networking Foundation
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
* http://www.apache.org/licenses/LICENSE-2.0
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <iostream>
#include <memory>
#include <string>
#include <sstream>
#include <grpcpp/health_check_service_interface.h>
#include <grpcpp/ext/proto_server_reflection_plugin.h>
#include <grpcpp/grpcpp.h>
#include <voltha_protos/openolt.grpc.pb.h>
#include <voltha_protos/tech_profile.grpc.pb.h>
#include <voltha_protos/ext_config.grpc.pb.h>
#include "tacacs_controller.h"
#include "logger.h"
using grpc::Channel;
using grpc::ChannelArguments;
using grpc::Server;
using grpc::ServerBuilder;
using grpc::ServerContext;
using grpc::ServerWriter;
using grpc::Status;
using grpc::ClientContext;
using namespace std;
static const std::string base64_chars =
"ABCDEFGHIJKLMNOPQRSTUVWXYZ"
"abcdefghijklmnopqrstuvwxyz"
"0123456789+/";
static inline bool is_base64(unsigned char c) {
return (isalnum(c) || (c == '+') || (c == '/'));
}
static Server* ServerInstance;
std::string base64_decode(std::string const& encoded_string);
class ProxyServiceImpl final : public openolt::Openolt::Service {
TaccController *taccController;
unique_ptr<openolt::Openolt::Stub> openoltClientStub;
public:
TacacsContext extractDataFromGrpc(ServerContext* context) {
LOG_F(MAX, "Extracting the gRPC credentials");
const std::multimap<grpc::string_ref, grpc::string_ref> metadata = context->client_metadata();
std::multimap<grpc::string_ref, grpc::string_ref>::const_iterator data_iter = metadata.find("authorization");
TacacsContext tacCtx;
if(data_iter != metadata.end()) {
string str_withBasic((data_iter->second).data(),(data_iter->second).length());
std::string str_withoutBasic = str_withBasic.substr(6);
std::string decoded_str = base64_decode(str_withoutBasic);
int pos = decoded_str.find(":");
tacCtx.username = decoded_str.substr(0,pos);
tacCtx.password = decoded_str.substr(pos+1);
tacCtx.remote_addr = context->peer();
LOG_F(INFO, "Received gRPC credentials username=%s, password=%s from Remote %s", tacCtx.username.c_str(), tacCtx.password.c_str(), tacCtx.remote_addr.c_str());
} else {
LOG_F(WARNING, "Unable to find or extract credentials from incoming gRPC request");
tacCtx.username = "";
}
return tacCtx;
}
Status processTacacsAuth(TacacsContext* tacCtx){
LOG_F(MAX, "Calling Authenticate");
Status status = taccController->Authenticate(tacCtx);
if(status.error_code() == StatusCode::OK) {
LOG_F(MAX, "Calling Authorize");
status = taccController->Authorize(tacCtx);
}
return status;
}
Status DisableOlt(
ServerContext* context,
const openolt::Empty* request,
openolt::Empty* response) override {
LOG_F(INFO, "DisableOlt invoked");
if (taccController->IsTacacsEnabled()) {
TacacsContext tacCtx = extractDataFromGrpc(context);
if (tacCtx.username.empty()) {
return Status(grpc::INVALID_ARGUMENT,"Unable to find or extract credentials from incoming gRPC request");
}
tacCtx.method_name = "disableolt";
taccController->StartAccounting(&tacCtx);
Status status = processTacacsAuth(&tacCtx);
if(status.error_code() == StatusCode::OK) {
ClientContext ctx;
LOG_F(INFO, "Calling DisableOlt");
status = openoltClientStub->DisableOlt(&ctx, *request, response);
}
string error_msg = "no error";
if(status.error_code() != StatusCode::OK) {
error_msg = status.error_message();
}
taccController->StopAccounting(&tacCtx, error_msg);
return status;
} else {
ClientContext ctx;
LOG_F(INFO, "Tacacs disabled.. Calling DisableOlt");
return openoltClientStub->DisableOlt(&ctx, *request, response);
}
}
Status ReenableOlt(
ServerContext* context,
const openolt::Empty* request,
openolt::Empty* response) override {
LOG_F(INFO, "ReenableOlt invoked");
if (taccController->IsTacacsEnabled()) {
TacacsContext tacCtx = extractDataFromGrpc(context);
if (tacCtx.username.empty()) {
return Status(grpc::INVALID_ARGUMENT,"Unable to find or extract credentials from incoming gRPC request");
}
tacCtx.method_name = "reenableolt";
taccController->StartAccounting(&tacCtx);
Status status = processTacacsAuth(&tacCtx);
if(status.error_code() == StatusCode::OK) {
ClientContext ctx;
LOG_F(INFO, "Calling ReenableOlt");
status = openoltClientStub->ReenableOlt(&ctx, *request, response);
}
string error_msg = "no error";
if(status.error_code() != StatusCode::OK) {
error_msg = status.error_message();
}
taccController->StopAccounting(&tacCtx, error_msg);
return status;
} else {
ClientContext ctx;
LOG_F(INFO, "Tacacs disabled.. Calling ReenableOlt");
return openoltClientStub->ReenableOlt(&ctx, *request, response);
}
}
Status ActivateOnu(
ServerContext* context,
const openolt::Onu* request,
openolt::Empty* response) override {
LOG_F(INFO, "ActivateOnu invoked");
if (taccController->IsTacacsEnabled()) {
TacacsContext tacCtx = extractDataFromGrpc(context);
if (tacCtx.username.empty()) {
return Status(grpc::INVALID_ARGUMENT,"Unable to find or extract credentials from incoming gRPC request");
}
tacCtx.method_name = "activateonu";
taccController->StartAccounting(&tacCtx);
Status status = processTacacsAuth(&tacCtx);
if(status.error_code() == StatusCode::OK) {
ClientContext ctx;
LOG_F(INFO, "Calling ActivateOnu");
status = openoltClientStub->ActivateOnu(&ctx, *request, response);
}
string error_msg = "no error";
if(status.error_code() != StatusCode::OK) {
error_msg = status.error_message();
}
taccController->StopAccounting(&tacCtx, error_msg);
return status;
} else {
ClientContext ctx;
LOG_F(INFO, "Tacacs disabled.. Calling ActivateOnu");
return openoltClientStub->ActivateOnu(&ctx, *request, response);
}
}
Status DeactivateOnu(
ServerContext* context,
const openolt::Onu* request,
openolt::Empty* response) override {
LOG_F(INFO, "DeactivateOnu invoked");
if (taccController->IsTacacsEnabled()) {
TacacsContext tacCtx = extractDataFromGrpc(context);
if (tacCtx.username.empty()) {
return Status(grpc::INVALID_ARGUMENT,"Unable to find or extract credentials from incoming gRPC request");
}
tacCtx.method_name = "deactivateonu";
taccController->StartAccounting(&tacCtx);
Status status = processTacacsAuth(&tacCtx);
if(status.error_code() == StatusCode::OK) {
ClientContext ctx;
LOG_F(INFO, "Calling DeactivateOnu");
status = openoltClientStub->DeactivateOnu(&ctx, *request, response);
}
string error_msg = "no error";
if(status.error_code() != StatusCode::OK) {
error_msg = status.error_message();
}
taccController->StopAccounting(&tacCtx, error_msg);
return status;
} else {
ClientContext ctx;
LOG_F(INFO, "Tacacs disabled.. Calling DeactivateOnu");
return openoltClientStub->DeactivateOnu(&ctx, *request, response);
}
}
Status DeleteOnu(
ServerContext* context,
const openolt::Onu* request,
openolt::Empty* response) override {
LOG_F(INFO, "DeleteOnu invoked");
if (taccController->IsTacacsEnabled()) {
TacacsContext tacCtx = extractDataFromGrpc(context);
if (tacCtx.username.empty()) {
return Status(grpc::INVALID_ARGUMENT,"Unable to find or extract credentials from incoming gRPC request");
}
tacCtx.method_name = "deleteonu";
taccController->StartAccounting(&tacCtx);
Status status = processTacacsAuth(&tacCtx);
if(status.error_code() == StatusCode::OK) {
ClientContext ctx;
LOG_F(INFO, "Calling DeleteOnu");
status = openoltClientStub->DeleteOnu(&ctx, *request, response);
}
string error_msg = "no error";
if(status.error_code() != StatusCode::OK) {
error_msg = status.error_message();
}
taccController->StopAccounting(&tacCtx, error_msg);
return status;
} else {
ClientContext ctx;
LOG_F(INFO, "Tacacs disabled.. Calling DeleteOnu");
return openoltClientStub->DeleteOnu(&ctx, *request, response);
}
}
Status OmciMsgOut(
ServerContext* context,
const openolt::OmciMsg* request,
openolt::Empty* response) override {
LOG_F(INFO, "OmciMsgOut invoked");
if (taccController->IsTacacsEnabled()) {
TacacsContext tacCtx = extractDataFromGrpc(context);
if (tacCtx.username.empty()) {
return Status(grpc::INVALID_ARGUMENT,"Unable to find or extract credentials from incoming gRPC request");
}
tacCtx.method_name = "omcimsgout";
taccController->StartAccounting(&tacCtx);
Status status = processTacacsAuth(&tacCtx);
if(status.error_code() == StatusCode::OK) {
ClientContext ctx;
LOG_F(INFO, "Calling OmciMsgOut");
status = openoltClientStub->OmciMsgOut(&ctx, *request, response);
}
string error_msg = "no error";
if(status.error_code() != StatusCode::OK) {
error_msg = status.error_message();
}
taccController->StopAccounting(&tacCtx, error_msg);
return status;
} else {
ClientContext ctx;
LOG_F(INFO, "Tacacs disabled.. Calling OmciMsgOut");
return openoltClientStub->OmciMsgOut(&ctx, *request, response);
}
}
Status OnuPacketOut(
ServerContext* context,
const openolt::OnuPacket* request,
openolt::Empty* response) override {
LOG_F(INFO, "OnuPacketOut invoked");
if (taccController->IsTacacsEnabled()) {
TacacsContext tacCtx = extractDataFromGrpc(context);
if (tacCtx.username.empty()) {
return Status(grpc::INVALID_ARGUMENT,"Unable to find or extract credentials from incoming gRPC request");
}
tacCtx.method_name = "onupacketout";
taccController->StartAccounting(&tacCtx);
Status status = processTacacsAuth(&tacCtx);
if(status.error_code() == StatusCode::OK) {
ClientContext ctx;
LOG_F(INFO, "Calling OnuPacketOut");
status = openoltClientStub->OnuPacketOut(&ctx, *request, response);
}
string error_msg = "no error";
if(status.error_code() != StatusCode::OK) {
error_msg = status.error_message();
}
taccController->StopAccounting(&tacCtx, error_msg);
return status;
} else {
ClientContext ctx;
LOG_F(INFO, "Tacacs disabled.. Calling OnuPacketOut");
return openoltClientStub->OnuPacketOut(&ctx, *request, response);
}
}
Status UplinkPacketOut(
ServerContext* context,
const openolt::UplinkPacket* request,
openolt::Empty* response) override {
LOG_F(INFO, "UplinkPacketOut invoked");
if (taccController->IsTacacsEnabled()) {
TacacsContext tacCtx = extractDataFromGrpc(context);
if (tacCtx.username.empty()) {
return Status(grpc::INVALID_ARGUMENT,"Unable to find or extract credentials from incoming gRPC request");
}
tacCtx.method_name = "uplinkpacketout";
taccController->StartAccounting(&tacCtx);
Status status = processTacacsAuth(&tacCtx);
if(status.error_code() == StatusCode::OK) {
ClientContext ctx;
LOG_F(INFO, "Calling UplinkPacketOut");
status = openoltClientStub->UplinkPacketOut(&ctx, *request, response);
}
string error_msg = "no error";
if(status.error_code() != StatusCode::OK) {
error_msg = status.error_message();
}
taccController->StopAccounting(&tacCtx, error_msg);
return status;
} else {
ClientContext ctx;
LOG_F(INFO, "Tacacs disabled.. Calling UplinkPacketOut");
return openoltClientStub->UplinkPacketOut(&ctx, *request, response);
}
}
Status FlowAdd(
ServerContext* context,
const openolt::Flow* request,
openolt::Empty* response) override {
LOG_F(INFO, "FlowAdd invoked");
if (taccController->IsTacacsEnabled()) {
TacacsContext tacCtx = extractDataFromGrpc(context);
if (tacCtx.username.empty()) {
return Status(grpc::INVALID_ARGUMENT,"Unable to find or extract credentials from incoming gRPC request");
}
tacCtx.method_name = "flowadd";
taccController->StartAccounting(&tacCtx);
Status status = processTacacsAuth(&tacCtx);
if(status.error_code() == StatusCode::OK) {
ClientContext ctx;
LOG_F(INFO, "Calling FlowAdd");
status = openoltClientStub->FlowAdd(&ctx, *request, response);
}
string error_msg = "no error";
if(status.error_code() != StatusCode::OK) {
error_msg = status.error_message();
}
taccController->StopAccounting(&tacCtx, error_msg);
return status;
} else {
ClientContext ctx;
LOG_F(INFO, "Tacacs disabled.. Calling FlowAdd");
return openoltClientStub->FlowAdd(&ctx, *request, response);
}
}
Status FlowRemove(
ServerContext* context,
const openolt::Flow* request,
openolt::Empty* response) override {
LOG_F(INFO, "FlowRemove invoked");
if (taccController->IsTacacsEnabled()) {
TacacsContext tacCtx = extractDataFromGrpc(context);
if (tacCtx.username.empty()) {
return Status(grpc::INVALID_ARGUMENT,"Unable to find or extract credentials from incoming gRPC request");
}
tacCtx.method_name = "flowremove";
taccController->StartAccounting(&tacCtx);
Status status = processTacacsAuth(&tacCtx);
if(status.error_code() == StatusCode::OK) {
ClientContext ctx;
LOG_F(INFO, "Calling FlowRemove");
status = openoltClientStub->FlowRemove(&ctx, *request, response);
}
string error_msg = "no error";
if(status.error_code() != StatusCode::OK) {
error_msg = status.error_message();
}
taccController->StopAccounting(&tacCtx, error_msg);
return status;
} else {
ClientContext ctx;
LOG_F(INFO, "Tacacs disabled.. Calling FlowRemove");
return openoltClientStub->FlowRemove(&ctx, *request, response);
}
}
Status EnableIndication(
ServerContext* context,
const ::openolt::Empty* request,
ServerWriter<openolt::Indication>* writer) override {
LOG_F(INFO, "EnableIndication invoked");
if (taccController->IsTacacsEnabled()) {
TacacsContext tacCtx = extractDataFromGrpc(context);
if (tacCtx.username.empty()) {
return Status(grpc::INVALID_ARGUMENT,"Unable to find or extract credentials from incoming gRPC request");
}
tacCtx.method_name = "enableindication";
taccController->StartAccounting(&tacCtx);
Status status = processTacacsAuth(&tacCtx);
if(status.error_code() == StatusCode::OK) {
ClientContext ctx;
LOG_F(INFO, "Calling EnableIndication");
std::unique_ptr<ClientReader<openolt::Indication> > reader = openoltClientStub->EnableIndication(&ctx, *request);
openolt::Indication indication;
while( reader->Read(&indication) ) {
LOG_F(INFO, "Sending out Indication type %d", indication.data_case());
if( !writer->Write(indication) ) {
LOG_F(WARNING, "Grpc Stream broken while sending out Indication");
break;
}
}
status = reader->Finish();
}
string error_msg = "no error";
if(status.error_code() != StatusCode::OK) {
error_msg = status.error_message();
}
taccController->StopAccounting(&tacCtx, error_msg);
return status;
} else {
ClientContext ctx;
LOG_F(INFO, "Tacacs disabled.. Calling EnableIndication");
std::unique_ptr<ClientReader<openolt::Indication> > reader = openoltClientStub->EnableIndication(&ctx, *request);
openolt::Indication indication;
while( reader->Read(&indication) ) {
LOG_F(INFO, "Sending out Indication type %d", indication.data_case());
if( !writer->Write(indication) ) {
LOG_F(WARNING, "Grpc Stream broken while sending out Indication");
break;
}
}
return reader->Finish();
}
}
Status HeartbeatCheck(
ServerContext* context,
const openolt::Empty* request,
openolt::Heartbeat* response) override {
LOG_F(INFO, "HeartbeatCheck invoked");
if (taccController->IsTacacsEnabled()) {
TacacsContext tacCtx = extractDataFromGrpc(context);
if (tacCtx.username.empty()) {
return Status(grpc::INVALID_ARGUMENT,"Unable to find or extract credentials from incoming gRPC request");
}
tacCtx.method_name = "heartbeatcheck";
taccController->StartAccounting(&tacCtx);
Status status = processTacacsAuth(&tacCtx);
if(status.error_code() == StatusCode::OK) {
ClientContext ctx;
LOG_F(INFO, "Calling HeartbeatCheck");
status = openoltClientStub->HeartbeatCheck(&ctx, *request, response);
}
string error_msg = "no error";
if(status.error_code() != StatusCode::OK) {
error_msg = status.error_message();
}
taccController->StopAccounting(&tacCtx, error_msg);
return status;
} else {
ClientContext ctx;
LOG_F(INFO, "Tacacs disabled.. Calling HeartbeatCheck");
return openoltClientStub->HeartbeatCheck(&ctx, *request, response);
}
}
Status EnablePonIf(
ServerContext* context,
const openolt::Interface* request,
openolt::Empty* response) override {
LOG_F(INFO, "EnablePonIf invoked");
if (taccController->IsTacacsEnabled()) {
TacacsContext tacCtx = extractDataFromGrpc(context);
if (tacCtx.username.empty()) {
return Status(grpc::INVALID_ARGUMENT,"Unable to find or extract credentials from incoming gRPC request");
}
tacCtx.method_name = "enableponif";
taccController->StartAccounting(&tacCtx);
Status status = processTacacsAuth(&tacCtx);
if(status.error_code() == StatusCode::OK) {
ClientContext ctx;
LOG_F(INFO, "Calling EnablePonIf");
status = openoltClientStub->EnablePonIf(&ctx, *request, response);
}
string error_msg = "no error";
if(status.error_code() != StatusCode::OK) {
error_msg = status.error_message();
}
taccController->StopAccounting(&tacCtx, error_msg);
return status;
} else {
ClientContext ctx;
LOG_F(INFO, "Tacacs disabled.. Calling EnablePonIf");
return openoltClientStub->EnablePonIf(&ctx, *request, response);
}
}
Status DisablePonIf(
ServerContext* context,
const openolt::Interface* request,
openolt::Empty* response) override {
LOG_F(INFO, "DisablePonIf invoked");
if (taccController->IsTacacsEnabled()) {
TacacsContext tacCtx = extractDataFromGrpc(context);
if (tacCtx.username.empty()) {
return Status(grpc::INVALID_ARGUMENT,"Unable to find or extract credentials from incoming gRPC request");
}
tacCtx.method_name = "disableponif";
taccController->StartAccounting(&tacCtx);
Status status = processTacacsAuth(&tacCtx);
if(status.error_code() == StatusCode::OK) {
ClientContext ctx;
LOG_F(INFO, "Calling DisablePonIf");
status = openoltClientStub->DisablePonIf(&ctx, *request, response);
}
string error_msg = "no error";
if(status.error_code() != StatusCode::OK) {
error_msg = status.error_message();
}
taccController->StopAccounting(&tacCtx, error_msg);
return status;
} else {
ClientContext ctx;
LOG_F(INFO, "Tacacs disabled.. Calling DisablePonIf");
return openoltClientStub->DisablePonIf(&ctx, *request, response);
}
}
Status CollectStatistics(
ServerContext* context,
const openolt::Empty* request,
openolt::Empty* response) override {
LOG_F(INFO, "CollectStatistics invoked");
if (taccController->IsTacacsEnabled()) {
TacacsContext tacCtx = extractDataFromGrpc(context);
if (tacCtx.username.empty()) {
return Status(grpc::INVALID_ARGUMENT,"Unable to find or extract credentials from incoming gRPC request");
}
tacCtx.method_name = "collectstatistics";
taccController->StartAccounting(&tacCtx);
Status status = processTacacsAuth(&tacCtx);
if(status.error_code() == StatusCode::OK) {
ClientContext ctx;
LOG_F(INFO, "Calling CollectStatistics");
status = openoltClientStub->CollectStatistics(&ctx, *request, response);
}
string error_msg = "no error";
if(status.error_code() != StatusCode::OK) {
error_msg = status.error_message();
}
taccController->StopAccounting(&tacCtx, error_msg);
return status;
} else {
ClientContext ctx;
LOG_F(INFO, "Tacacs disabled.. Calling CollectStatistics");
return openoltClientStub->CollectStatistics(&ctx, *request, response);
}
}
Status Reboot(
ServerContext* context,
const openolt::Empty* request,
openolt::Empty* response) override {
LOG_F(INFO, "Reboot invoked");
if (taccController->IsTacacsEnabled()) {
TacacsContext tacCtx = extractDataFromGrpc(context);
if (tacCtx.username.empty()) {
return Status(grpc::INVALID_ARGUMENT,"Unable to find or extract credentials from incoming gRPC request");
}
tacCtx.method_name = "reboot";
taccController->StartAccounting(&tacCtx);
Status status = processTacacsAuth(&tacCtx);
if(status.error_code() == StatusCode::OK) {
ClientContext ctx;
LOG_F(INFO, "Calling Reboot");
status = openoltClientStub->Reboot(&ctx, *request, response);
}
string error_msg = "no error";
if(status.error_code() != StatusCode::OK) {
error_msg = status.error_message();
}
taccController->StopAccounting(&tacCtx, error_msg);
return status;
} else {
ClientContext ctx;
LOG_F(INFO, "Tacacs disabled.. Calling Reboot");
return openoltClientStub->Reboot(&ctx, *request, response);
}
}
Status GetDeviceInfo(
ServerContext* context,
const openolt::Empty* request,
openolt::DeviceInfo* response) override {
LOG_F(MAX, "GetDeviceInfo invoked");
if (taccController->IsTacacsEnabled()) {
TacacsContext tacCtx = extractDataFromGrpc(context);
if (tacCtx.username.empty()) {
return Status(grpc::INVALID_ARGUMENT,"Unable to find or extract credentials from incoming gRPC request");
}
tacCtx.method_name = "getdeviceinfo";
taccController->StartAccounting(&tacCtx);
Status status = processTacacsAuth(&tacCtx);
if(status.error_code() == StatusCode::OK) {
ClientContext ctx;
LOG_F(INFO, "Calling GetDeviceInfo");
status = openoltClientStub->GetDeviceInfo(&ctx, *request, response);
}
string error_msg = "no error";
if(status.error_code() != StatusCode::OK) {
error_msg = status.error_message();
}
taccController->StopAccounting(&tacCtx, error_msg);
return status;
} else {
ClientContext ctx;
LOG_F(INFO, "Tacacs disabled.. Calling GetDeviceInfo");
return openoltClientStub->GetDeviceInfo(&ctx, *request, response);
}
}
Status CreateTrafficSchedulers(
ServerContext* context,
const tech_profile::TrafficSchedulers* request,
openolt::Empty* response) override {
LOG_F(INFO, "CreateTrafficSchedulers invoked");
if (taccController->IsTacacsEnabled()) {
TacacsContext tacCtx = extractDataFromGrpc(context);
if (tacCtx.username.empty()) {
return Status(grpc::INVALID_ARGUMENT,"Unable to find or extract credentials from incoming gRPC request");
}
tacCtx.method_name = "createtrafficschedulers";
taccController->StartAccounting(&tacCtx);
Status status = processTacacsAuth(&tacCtx);
if(status.error_code() == StatusCode::OK) {
ClientContext ctx;
LOG_F(INFO, "Calling CreateTrafficSchedulers");
status = openoltClientStub->CreateTrafficSchedulers(&ctx, *request, response);
}
string error_msg = "no error";
if(status.error_code() != StatusCode::OK) {
error_msg = status.error_message();
}
taccController->StopAccounting(&tacCtx, error_msg);
return status;
} else {
ClientContext ctx;
LOG_F(INFO, "Tacacs disabled.. Calling CreateTrafficSchedulers");
return openoltClientStub->CreateTrafficSchedulers(&ctx, *request, response);
}
}
Status RemoveTrafficSchedulers(
ServerContext* context,
const tech_profile::TrafficSchedulers* request,
openolt::Empty* response) override {
LOG_F(INFO, "RemoveTrafficSchedulers invoked");
if (taccController->IsTacacsEnabled()) {
TacacsContext tacCtx = extractDataFromGrpc(context);
if (tacCtx.username.empty()) {
return Status(grpc::INVALID_ARGUMENT,"Unable to find or extract credentials from incoming gRPC request");
}
tacCtx.method_name = "removetrafficschedulers";
taccController->StartAccounting(&tacCtx);
Status status = processTacacsAuth(&tacCtx);
if(status.error_code() == StatusCode::OK) {
ClientContext ctx;
LOG_F(INFO, "Calling RemoveTrafficSchedulers");
status = openoltClientStub->RemoveTrafficSchedulers(&ctx, *request, response);
}
string error_msg = "no error";
if(status.error_code() != StatusCode::OK) {
error_msg = status.error_message();
}
taccController->StopAccounting(&tacCtx, error_msg);
return status;
} else {
ClientContext ctx;
LOG_F(INFO, "Tacacs disabled.. Calling RemoveTrafficSchedulers");
return openoltClientStub->RemoveTrafficSchedulers(&ctx, *request, response);
}
}
Status CreateTrafficQueues(
ServerContext* context,
const tech_profile::TrafficQueues* request,
openolt::Empty* response) override {
LOG_F(INFO, "CreateTrafficQueues invoked");
if (taccController->IsTacacsEnabled()) {
TacacsContext tacCtx = extractDataFromGrpc(context);
if (tacCtx.username.empty()) {
return Status(grpc::INVALID_ARGUMENT,"Unable to find or extract credentials from incoming gRPC request");
}
tacCtx.method_name = "createtrafficqueues";
taccController->StartAccounting(&tacCtx);
Status status = processTacacsAuth(&tacCtx);
if(status.error_code() == StatusCode::OK) {
ClientContext ctx;
LOG_F(INFO, "Calling CreateTrafficQueues");
status = openoltClientStub->CreateTrafficQueues(&ctx, *request, response);
}
string error_msg = "no error";
if(status.error_code() != StatusCode::OK) {
error_msg = status.error_message();
}
taccController->StopAccounting(&tacCtx, error_msg);
return status;
} else {
ClientContext ctx;
LOG_F(INFO, "Tacacs disabled.. Calling CreateTrafficQueues");
return openoltClientStub->CreateTrafficQueues(&ctx, *request, response);
}
}
Status RemoveTrafficQueues(
ServerContext* context,
const tech_profile::TrafficQueues* request,
openolt::Empty* response) override {
LOG_F(INFO, "RemoveTrafficQueues invoked");
if (taccController->IsTacacsEnabled()) {
TacacsContext tacCtx = extractDataFromGrpc(context);
if (tacCtx.username.empty()) {
return Status(grpc::INVALID_ARGUMENT,"Unable to find or extract credentials from incoming gRPC request");
}
tacCtx.method_name = "removetrafficqueues";
taccController->StartAccounting(&tacCtx);
Status status = processTacacsAuth(&tacCtx);
if(status.error_code() == StatusCode::OK) {
ClientContext ctx;
LOG_F(INFO, "Calling RemoveTrafficQueues");
status = openoltClientStub->RemoveTrafficQueues(&ctx, *request, response);
}
string error_msg = "no error";
if(status.error_code() != StatusCode::OK) {
error_msg = status.error_message();
}
taccController->StopAccounting(&tacCtx, error_msg);
return status;
} else {
ClientContext ctx;
LOG_F(INFO, "Tacacs disabled.. Calling RemoveTrafficQueues");
return openoltClientStub->RemoveTrafficQueues(&ctx, *request, response);
}
}
Status PerformGroupOperation(
ServerContext* context,
const openolt::Group* request,
openolt::Empty* response) override {
LOG_F(INFO, "PerformGroupOperation invoked");
if (taccController->IsTacacsEnabled()) {
TacacsContext tacCtx = extractDataFromGrpc(context);
if (tacCtx.username.empty()) {
return Status(grpc::INVALID_ARGUMENT,"Unable to find or extract credentials from incoming gRPC request");
}
tacCtx.method_name = "performgroupoperation";
taccController->StartAccounting(&tacCtx);
Status status = processTacacsAuth(&tacCtx);
if(status.error_code() == StatusCode::OK) {
ClientContext ctx;
LOG_F(INFO, "Calling PerformGroupOperation");
status = openoltClientStub->PerformGroupOperation(&ctx, *request, response);
}
string error_msg = "no error";
if(status.error_code() != StatusCode::OK) {
error_msg = status.error_message();
}
taccController->StopAccounting(&tacCtx, error_msg);
return status;
} else {
ClientContext ctx;
LOG_F(INFO, "Tacacs disabled.. Calling PerformGroupOperation");
return openoltClientStub->PerformGroupOperation(&ctx, *request, response);
}
}
Status DeleteGroup(
ServerContext* context,
const openolt::Group* request,
openolt::Empty* response) override {
LOG_F(INFO, "DeleteGroup invoked");
if (taccController->IsTacacsEnabled()) {
TacacsContext tacCtx = extractDataFromGrpc(context);
if (tacCtx.username.empty()) {
return Status(grpc::INVALID_ARGUMENT,"Unable to find or extract credentials from incoming gRPC request");
}
tacCtx.method_name = "deletegroup";
taccController->StartAccounting(&tacCtx);
Status status = processTacacsAuth(&tacCtx);
if(status.error_code() == StatusCode::OK) {
ClientContext ctx;
LOG_F(INFO, "Calling DeleteGroup");
status = openoltClientStub->DeleteGroup(&ctx, *request, response);
}
string error_msg = "no error";
if(status.error_code() != StatusCode::OK) {
error_msg = status.error_message();
}
taccController->StopAccounting(&tacCtx, error_msg);
return status;
} else {
ClientContext ctx;
LOG_F(INFO, "Tacacs disabled.. Calling DeleteGroup");
return openoltClientStub->DeleteGroup(&ctx, *request, response);
}
}
Status OnuItuPonAlarmSet(
ServerContext* context,
const config::OnuItuPonAlarm* request,
openolt::Empty* response) override {
LOG_F(INFO, "OnuItuPonAlarmSet invoked");
if (taccController->IsTacacsEnabled()) {
TacacsContext tacCtx = extractDataFromGrpc(context);
if (tacCtx.username.empty()) {
return Status(grpc::INVALID_ARGUMENT,"Unable to find or extract credentials from incoming gRPC request");
}
tacCtx.method_name = "onuituponalarmset";
taccController->StartAccounting(&tacCtx);
Status status = processTacacsAuth(&tacCtx);
if(status.error_code() == StatusCode::OK) {
ClientContext ctx;
LOG_F(INFO, "Calling OnuItuPonAlarmSet");
status = openoltClientStub->OnuItuPonAlarmSet(&ctx, *request, response);
}
string error_msg = "no error";
if(status.error_code() != StatusCode::OK) {
error_msg = status.error_message();
}
taccController->StopAccounting(&tacCtx, error_msg);
return status;
} else {
ClientContext ctx;
LOG_F(INFO, "Tacacs disabled.. Calling OnuItuPonAlarmSet");
return openoltClientStub->OnuItuPonAlarmSet(&ctx, *request, response);
}
}
Status GetLogicalOnuDistanceZero(
ServerContext* context,
const openolt::Onu* request,
openolt::OnuLogicalDistance* response) override {
LOG_F(INFO, "GetLogicalOnuDistanceZero invoked");
if (taccController->IsTacacsEnabled()) {
TacacsContext tacCtx = extractDataFromGrpc(context);
if (tacCtx.username.empty()) {
return Status(grpc::INVALID_ARGUMENT,"Unable to find or extract credentials from incoming gRPC request");
}
tacCtx.method_name = "getlogicalonudistancezero";
taccController->StartAccounting(&tacCtx);
Status status = processTacacsAuth(&tacCtx);
if(status.error_code() == StatusCode::OK) {
ClientContext ctx;
LOG_F(INFO, "Calling GetLogicalOnuDistanceZero");
status = openoltClientStub->GetLogicalOnuDistanceZero(&ctx, *request, response);
}
string error_msg = "no error";
if(status.error_code() != StatusCode::OK) {
error_msg = status.error_message();
}
taccController->StopAccounting(&tacCtx, error_msg);
return status;
} else {
ClientContext ctx;
LOG_F(INFO, "Tacacs disabled.. Calling GetLogicalOnuDistanceZero");
return openoltClientStub->GetLogicalOnuDistanceZero(&ctx, *request, response);
}
}
Status GetLogicalOnuDistance(
ServerContext* context,
const openolt::Onu* request,
openolt::OnuLogicalDistance* response) override {
LOG_F(INFO, "GetLogicalOnuDistance invoked");
if (taccController->IsTacacsEnabled()) {
TacacsContext tacCtx = extractDataFromGrpc(context);
if (tacCtx.username.empty()) {
return Status(grpc::INVALID_ARGUMENT,"Unable to find or extract credentials from incoming gRPC request");
}
tacCtx.method_name = "getlogicalonudistance";
taccController->StartAccounting(&tacCtx);
Status status = processTacacsAuth(&tacCtx);
if(status.error_code() == StatusCode::OK) {
ClientContext ctx;
LOG_F(INFO, "Calling GetLogicalOnuDistance");
status = openoltClientStub->GetLogicalOnuDistance(&ctx, *request, response);
}
string error_msg = "no error";
if(status.error_code() != StatusCode::OK) {
error_msg = status.error_message();
}
taccController->StopAccounting(&tacCtx, error_msg);
return status;
} else {
ClientContext ctx;
LOG_F(INFO, "Tacacs disabled.. Calling GetLogicalOnuDistance");
return openoltClientStub->GetLogicalOnuDistance(&ctx, *request, response);
}
}
ProxyServiceImpl(TaccController* tacctrl, const char* addr) {
taccController = tacctrl;
LOG_F(INFO, "Creating GRPC Channel to Openolt Agent on %s", addr);
openoltClientStub = openolt::Openolt::NewStub(grpc::CreateChannel(addr, grpc::InsecureChannelCredentials()));
}
};
std::string base64_decode(std::string const& encoded_string) {
int in_len = encoded_string.size();
int i = 0;
int j = 0;
int in_ = 0;
unsigned char char_array_4[4], char_array_3[3];
std::string ret;
while (in_len-- && ( encoded_string[in_] != '=') && is_base64(encoded_string[in_])) {
char_array_4[i++] = encoded_string[in_]; in_++;
if (i ==4) {
for (i = 0; i <4; i++)
char_array_4[i] = base64_chars.find(char_array_4[i]);
char_array_3[0] = (char_array_4[0] << 2) + ((char_array_4[1] & 0x30) >> 4);
char_array_3[1] = ((char_array_4[1] & 0xf) << 4) + ((char_array_4[2] & 0x3c) >> 2);
char_array_3[2] = ((char_array_4[2] & 0x3) << 6) + char_array_4[3];
for (i = 0; (i < 3); i++)
ret += char_array_3[i];
i = 0;
}
}
if (i) {
for (j = i; j <4; j++)
char_array_4[j] = 0;
for (j = 0; j <4; j++)
char_array_4[j] = base64_chars.find(char_array_4[j]);
char_array_3[0] = (char_array_4[0] << 2) + ((char_array_4[1] & 0x30) >> 4);
char_array_3[1] = ((char_array_4[1] & 0xf) << 4) + ((char_array_4[2] & 0x3c) >> 2);
char_array_3[2] = ((char_array_4[2] & 0x3) << 6) + char_array_4[3];
for (j = 0; (j < i - 1); j++) ret += char_array_3[j];
}
return ret;
}
void RunServer(int argc, char** argv) {
const char* tacacs_server_address = NULL;
const char* tacacs_secure_key = NULL;
bool tacacs_fallback_pass = true;
const char* interface_address = NULL;
const char* openolt_agent_address = NULL;
TaccController* taccController = NULL;
LOG_F(INFO, "Starting up TACACS Proxy");
for (int i = 1; i < argc; ++i) {
if(strcmp(argv[i-1], "--tacacs_server_address") == 0 ) {
tacacs_server_address = argv[i];
} else if(strcmp(argv[i-1], "--tacacs_secure_key") == 0 ) {
tacacs_secure_key = argv[i];
} else if(strcmp(argv[i-1], "--tacacs_fallback_pass") == 0 ) {
tacacs_fallback_pass = ( *argv[i] == '0') ? false : true;
} else if(strcmp(argv[i-1], "--interface_address") == 0 ) {
interface_address = argv[i];
} else if(strcmp(argv[i-1], "--openolt_agent_address") == 0 ) {
openolt_agent_address = argv[i];
}
}
if(!interface_address || interface_address == ""){
LOG_F(FATAL, "Server Interface Bind address is missing. TACACS Proxy startup failed");
return;
}
if(!openolt_agent_address || openolt_agent_address == ""){
LOG_F(FATAL, "Openolt Agent address is missing. TACACS Proxy startup failed");
return;
}
if(!tacacs_server_address || tacacs_server_address == ""){
LOG_F(WARNING, "TACACS+ Server address is missing. TACACS+ AAA will be disabled");
}
LOG_F(INFO, "TACACS+ Server configured as %s", tacacs_server_address);
LOG_F(INFO, "TACACS Fallback configured as %s", tacacs_fallback_pass ? "PASS": "FAIL");
if(!tacacs_secure_key){
LOG_F(ERROR, "TACACS Secure Key is missing. No encryption will be used for TACACS channel");
tacacs_secure_key = "";
}
LOG_F(MAX, "Creating TaccController");
taccController = new TaccController(tacacs_server_address, tacacs_secure_key, tacacs_fallback_pass);
LOG_F(MAX, "Creating Proxy Server");
ProxyServiceImpl service(taccController, openolt_agent_address);
grpc::EnableDefaultHealthCheckService(true);
ServerBuilder builder;
LOG_F(INFO, "Starting Proxy Server");
builder.AddListeningPort(interface_address, grpc::InsecureServerCredentials());
builder.RegisterService(&service);
std::unique_ptr<Server> server(builder.BuildAndStart());
ServerInstance = server.get();
LOG_F(INFO, "TACACS Proxy listening on %s", interface_address);
server->Wait();
}
void StopServer(int signum) {
LOG_F(INFO, "Received Signal %d", signum);
if( ServerInstance != NULL ) {
LOG_F(INFO, "Shutting down TACACS Proxy");
ServerInstance->Shutdown();
}
exit(0);
}
| 39.741763
| 171
| 0.588438
|
gkumar78
|
d62dd8cb0d504f37e451cdaf048bda0c3a22a3cc
| 6,116
|
cpp
|
C++
|
src/jet/grid_forward_euler_diffusion_solver3.cpp
|
PavelBlend/fluid-engine-dev
|
45b4bdbdb4c6d8c0beebc682180469198203b0ef
|
[
"MIT"
] | 1,355
|
2016-05-08T07:29:22.000Z
|
2022-03-30T13:59:35.000Z
|
src/jet/grid_forward_euler_diffusion_solver3.cpp
|
Taiyuan-Zhang/fluid-engine-dev
|
45b4bdbdb4c6d8c0beebc682180469198203b0ef
|
[
"MIT"
] | 208
|
2016-05-25T19:47:27.000Z
|
2022-01-17T04:18:29.000Z
|
src/jet/grid_forward_euler_diffusion_solver3.cpp
|
Taiyuan-Zhang/fluid-engine-dev
|
45b4bdbdb4c6d8c0beebc682180469198203b0ef
|
[
"MIT"
] | 218
|
2016-08-23T16:51:10.000Z
|
2022-03-31T03:55:48.000Z
|
// Copyright (c) 2018 Doyub Kim
//
// I am making my contributions/submissions to this project solely in my
// personal capacity and am not conveying any rights to any intellectual
// property of any third parties.
#include <pch.h>
#include <jet/fdm_utils.h>
#include <jet/grid_forward_euler_diffusion_solver3.h>
#include <jet/level_set_utils.h>
using namespace jet;
static const char kFluid = 0;
static const char kAir = 1;
static const char kBoundary = 2;
template <typename T>
T laplacian(
const ConstArrayAccessor3<T>& data,
const Array3<char>& marker,
const Vector3D& gridSpacing,
size_t i,
size_t j,
size_t k) {
const T center = data(i, j, k);
const Size3 ds = data.size();
JET_ASSERT(i < ds.x && j < ds.y && k < ds.z);
T dleft = zero<T>();
T dright = zero<T>();
T ddown = zero<T>();
T dup = zero<T>();
T dback = zero<T>();
T dfront = zero<T>();
if (i > 0 && marker(i - 1, j, k) == kFluid) {
dleft = center - data(i - 1, j, k);
}
if (i + 1 < ds.x && marker(i + 1, j, k) == kFluid) {
dright = data(i + 1, j, k) - center;
}
if (j > 0 && marker(i, j - 1, k) == kFluid) {
ddown = center - data(i, j - 1, k);
}
if (j + 1 < ds.y && marker(i, j + 1, k) == kFluid) {
dup = data(i, j + 1, k) - center;
}
if (k > 0 && marker(i, j, k - 1) == kFluid) {
dback = center - data(i, j, k - 1);
}
if (k + 1 < ds.z && marker(i, j, k + 1) == kFluid) {
dfront = data(i, j, k + 1) - center;
}
return (dright - dleft) / square(gridSpacing.x)
+ (dup - ddown) / square(gridSpacing.y)
+ (dfront - dback) / square(gridSpacing.z);
}
GridForwardEulerDiffusionSolver3::GridForwardEulerDiffusionSolver3() {
}
void GridForwardEulerDiffusionSolver3::solve(
const ScalarGrid3& source,
double diffusionCoefficient,
double timeIntervalInSeconds,
ScalarGrid3* dest,
const ScalarField3& boundarySdf,
const ScalarField3& fluidSdf) {
auto src = source.constDataAccessor();
Vector3D h = source.gridSpacing();
auto pos = source.dataPosition();
buildMarkers(source.resolution(), pos, boundarySdf, fluidSdf);
source.parallelForEachDataPointIndex(
[&](size_t i, size_t j, size_t k) {
if (_markers(i, j, k) == kFluid) {
(*dest)(i, j, k)
= source(i, j, k)
+ diffusionCoefficient
* timeIntervalInSeconds
* laplacian(src, _markers, h, i, j, k);
} else {
(*dest)(i, j, k) = source(i, j, k);
}
});
}
void GridForwardEulerDiffusionSolver3::solve(
const CollocatedVectorGrid3& source,
double diffusionCoefficient,
double timeIntervalInSeconds,
CollocatedVectorGrid3* dest,
const ScalarField3& boundarySdf,
const ScalarField3& fluidSdf) {
auto src = source.constDataAccessor();
Vector3D h = source.gridSpacing();
auto pos = source.dataPosition();
buildMarkers(source.resolution(), pos, boundarySdf, fluidSdf);
source.parallelForEachDataPointIndex(
[&](size_t i, size_t j, size_t k) {
if (_markers(i, j, k) == kFluid) {
(*dest)(i, j, k)
= src(i, j, k)
+ diffusionCoefficient
* timeIntervalInSeconds
* laplacian(src, _markers, h, i, j, k);
} else {
(*dest)(i, j, k) = source(i, j, k);
}
});
}
void GridForwardEulerDiffusionSolver3::solve(
const FaceCenteredGrid3& source,
double diffusionCoefficient,
double timeIntervalInSeconds,
FaceCenteredGrid3* dest,
const ScalarField3& boundarySdf,
const ScalarField3& fluidSdf) {
auto uSrc = source.uConstAccessor();
auto vSrc = source.vConstAccessor();
auto wSrc = source.wConstAccessor();
auto u = dest->uAccessor();
auto v = dest->vAccessor();
auto w = dest->wAccessor();
auto uPos = source.uPosition();
auto vPos = source.vPosition();
auto wPos = source.wPosition();
Vector3D h = source.gridSpacing();
buildMarkers(source.uSize(), uPos, boundarySdf, fluidSdf);
source.parallelForEachUIndex(
[&](size_t i, size_t j, size_t k) {
if (!isInsideSdf(boundarySdf.sample(uPos(i, j, k)))) {
u(i, j, k)
= uSrc(i, j, k)
+ diffusionCoefficient
* timeIntervalInSeconds
* laplacian3(uSrc, h, i, j, k);
}
});
buildMarkers(source.vSize(), vPos, boundarySdf, fluidSdf);
source.parallelForEachVIndex(
[&](size_t i, size_t j, size_t k) {
if (!isInsideSdf(boundarySdf.sample(vPos(i, j, k)))) {
v(i, j, k)
= vSrc(i, j, k)
+ diffusionCoefficient
* timeIntervalInSeconds
* laplacian3(vSrc, h, i, j, k);
}
});
buildMarkers(source.wSize(), wPos, boundarySdf, fluidSdf);
source.parallelForEachWIndex(
[&](size_t i, size_t j, size_t k) {
if (!isInsideSdf(boundarySdf.sample(wPos(i, j, k)))) {
w(i, j, k)
= wSrc(i, j, k)
+ diffusionCoefficient
* timeIntervalInSeconds
* laplacian3(wSrc, h, i, j, k);
}
});
}
void GridForwardEulerDiffusionSolver3::buildMarkers(
const Size3& size,
const std::function<Vector3D(size_t, size_t, size_t)>& pos,
const ScalarField3& boundarySdf,
const ScalarField3& fluidSdf) {
_markers.resize(size);
_markers.forEachIndex(
[&](size_t i, size_t j, size_t k) {
if (isInsideSdf(boundarySdf.sample(pos(i, j, k)))) {
_markers(i, j, k) = kBoundary;
} else if (isInsideSdf(fluidSdf.sample(pos(i, j, k)))) {
_markers(i, j, k) = kFluid;
} else {
_markers(i, j, k) = kAir;
}
});
}
| 31.045685
| 72
| 0.552158
|
PavelBlend
|
d6320ffbbb1fd3681cb234be4d0f345d770834d1
| 3,724
|
cpp
|
C++
|
vnext/Microsoft.ReactNative/ReactNativeHost.cpp
|
tom-un/react-native-windows
|
c09b55cce76604fe0b379b10206a974915dafc25
|
[
"MIT"
] | 2
|
2021-09-05T18:12:44.000Z
|
2021-09-06T02:08:25.000Z
|
vnext/Microsoft.ReactNative/ReactNativeHost.cpp
|
zchronoz/react-native-windows
|
111b727c50b4349b60ffe98f7ff70d487624add3
|
[
"MIT"
] | 2
|
2021-05-09T03:34:28.000Z
|
2021-09-02T14:49:43.000Z
|
vnext/Microsoft.ReactNative/ReactNativeHost.cpp
|
t0rr3sp3dr0/react-native-windows
|
5ed2c5626fb2d126022ba215a71a1cb92f7337b3
|
[
"MIT"
] | null | null | null |
// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License.
#include "pch.h"
#include "ReactNativeHost.h"
#include "ReactNativeHost.g.cpp"
#include "ReactInstanceManager.h"
#include "ReactInstanceManagerBuilder.h"
#include "ReactInstanceSettings.h"
#include "ReactRootView.h"
#include "ReactSupport.h"
#include <NativeModuleProvider.h>
#include <ViewManager.h>
#include <ViewManagerProvider.h>
using namespace winrt;
using namespace Windows::UI::Xaml;
using namespace Windows::UI::Xaml::Controls;
namespace winrt::Microsoft::ReactNative::implementation {
ReactNativeHost::ReactNativeHost() noexcept {
Init();
}
void ReactNativeHost::Init() noexcept {
#if _DEBUG
facebook::react::InitializeLogging([](facebook::react::RCTLogLevel /*logLevel*/, const char *message) {
std::string str = std::string("ReactNative:") + message;
OutputDebugStringA(str.c_str());
});
#endif
}
Microsoft::ReactNative::ReactInstanceManager ReactNativeHost::CreateReactInstanceManager() noexcept {
auto builder = ReactInstanceManagerBuilder();
builder.InstanceSettings(InstanceSettings());
builder.UseDeveloperSupport(UseDeveloperSupport());
builder.InitialLifecycleState(LifecycleState::BeforeCreate);
builder.JavaScriptBundleFile(JavaScriptBundleFile());
builder.JavaScriptMainModuleName(JavaScriptMainModuleName());
builder.PackageProviders(PackageProviders().GetView());
return builder.Build();
}
std::shared_ptr<ReactRootView> ReactNativeHost::CreateRootView() noexcept {
auto rootView = std::make_shared<ReactRootView>();
return rootView;
}
Microsoft::ReactNative::ReactInstanceManager ReactNativeHost::ReactInstanceManager() noexcept {
if (m_reactInstanceManager == nullptr) {
m_reactInstanceManager = CreateReactInstanceManager();
}
return m_reactInstanceManager;
}
UIElement ReactNativeHost::GetOrCreateRootView(IInspectable initialProps) noexcept {
if (m_reactRootView != nullptr) {
return *m_reactRootView;
}
folly::dynamic props = Microsoft::ReactNative::Bridge::ConvertToDynamic(initialProps);
m_reactRootView = CreateRootView();
assert(m_reactRootView != nullptr);
m_reactRootView->OnCreate(*this);
m_reactRootView->StartReactApplicationAsync(ReactInstanceManager(), MainComponentName(), props);
return *m_reactRootView;
}
auto ReactNativeHost::InstanceSettings() noexcept -> Microsoft::ReactNative::ReactInstanceSettings {
if (!m_instanceSettings) {
m_instanceSettings = make<ReactInstanceSettings>();
m_instanceSettings.UseWebDebugger(false);
m_instanceSettings.UseLiveReload(true);
m_instanceSettings.UseJsi(true);
m_instanceSettings.EnableDeveloperMenu(REACT_DEFAULT_ENABLE_DEVELOPER_MENU);
}
return m_instanceSettings;
}
auto ReactNativeHost::PackageProviders() noexcept -> IVector<IReactPackageProvider> {
if (!m_packageProviders) {
m_packageProviders = single_threaded_vector<IReactPackageProvider>();
}
return m_packageProviders;
}
void ReactNativeHost::OnSuspend() noexcept {
if (HasInstance()) {
ReactInstanceManager().OnSuspend();
}
}
void ReactNativeHost::OnEnteredBackground() noexcept {
if (HasInstance()) {
ReactInstanceManager().OnEnteredBackground();
}
}
void ReactNativeHost::OnLeavingBackground() noexcept {
if (HasInstance()) {
ReactInstanceManager().OnLeavingBackground();
}
}
void ReactNativeHost::OnResume(Microsoft::ReactNative::OnResumeAction const &action) noexcept {
if (HasInstance()) {
ReactInstanceManager().OnResume(action);
}
}
} // namespace winrt::Microsoft::ReactNative::implementation
| 30.276423
| 106
| 0.747046
|
tom-un
|
d63398010a208af19e5347957d12dcf82055b812
| 698
|
cpp
|
C++
|
Utils/StringUtils.cpp
|
paulross80/myoga-utils
|
ecdff503690bb0b3a521e7af66bb84dfbd899799
|
[
"MIT"
] | null | null | null |
Utils/StringUtils.cpp
|
paulross80/myoga-utils
|
ecdff503690bb0b3a521e7af66bb84dfbd899799
|
[
"MIT"
] | null | null | null |
Utils/StringUtils.cpp
|
paulross80/myoga-utils
|
ecdff503690bb0b3a521e7af66bb84dfbd899799
|
[
"MIT"
] | null | null | null |
#include <stdexcept>
#include <algorithm>
#include <cctype>
#include "StringUtils.hpp"
namespace myoga
{
// String to lowercase
auto lowercase(std::string_view str) -> std::string
{
std::string ret(str);
for (std::size_t i = 0U; i < ret.length(); i++)
ret[i] = charToLower(ret[i]);
return ret;
}
// String -> Boolean
auto boolFromStr(std::string_view str) -> bool
{
// Why this always returns false???
//std::istringstream(value.data()) >> std::boolalpha >> boolValue;
auto lowTrim = myoga::lowercase(myoga::trimStr(str.substr(0, 5))); // "false" -> 5 chars
if (lowTrim == "1" || lowTrim == "true")
return true;
return false;
}
} // myoga
| 19.388889
| 93
| 0.617479
|
paulross80
|
d634459a8057739295b11d8375cfb44714bf6d9b
| 4,816
|
cpp
|
C++
|
motif4struct_bin.cpp
|
devuci/bct-cpp
|
bbb33f476bffbb5669e051841f00c3241f4d6f69
|
[
"MIT"
] | null | null | null |
motif4struct_bin.cpp
|
devuci/bct-cpp
|
bbb33f476bffbb5669e051841f00c3241f4d6f69
|
[
"MIT"
] | null | null | null |
motif4struct_bin.cpp
|
devuci/bct-cpp
|
bbb33f476bffbb5669e051841f00c3241f4d6f69
|
[
"MIT"
] | null | null | null |
#include "bct.h"
/*
* Counts occurrences of four-node structural motifs in a binary graph.
*/
VECTOR_T* BCT_NAMESPACE::motif4struct_bin(const MATRIX_T* A, MATRIX_T** F) {
if (safe_mode) check_status(A, SQUARE | BINARY, "motif4struct_bin");
// load motif34lib M4n ID4
VECTOR_T* ID4;
MATRIX_T* M4 = motif4generate(&ID4);
// n=length(A);
int n = length(A);
// F=zeros(199,n);
if (F != NULL) {
*F = zeros(199, n);
}
// f=zeros(199,1);
VECTOR_T* f = zeros_vector(199);
// As=A|A.';
MATRIX_T* A_transpose = MATRIX_ID(alloc)(A->size2, A->size1);
MATRIX_ID(transpose_memcpy)(A_transpose, A);
MATRIX_T* As = logical_or(A, A_transpose);
MATRIX_ID(free)(A_transpose);
// for u=1:n-3
for (int u = 0; u < n - 3; u++) {
// V1=[false(1,u) As(u,u+1:n)];
VECTOR_T* V1 = VECTOR_ID(alloc)(n);
MATRIX_ID(get_row)(V1, As, u);
for (int i = 0; i <= u; i++) {
VECTOR_ID(set)(V1, i, 0.0);
}
// for v1=find(V1)
VECTOR_T* find_V1 = find(V1);
if (find_V1 != NULL) {
for (int i_find_V1 = 0; i_find_V1 < (int)find_V1->size; i_find_V1++) {
int v1 = (int)VECTOR_ID(get)(find_V1, i_find_V1);
// V2=[false(1,u) As(v1,u+1:n)];
VECTOR_T* V2 = VECTOR_ID(alloc)(n);
MATRIX_ID(get_row)(V2, As, v1);
for (int i = 0; i <= u; i++) {
VECTOR_ID(set)(V2, i, 0.0);
}
// V2(V1)=0;
logical_index_assign(V2, V1, 0.0);
// V2=V2|([false(1,v1) As(u,v1+1:n)]);
VECTOR_T* V2_1 = V2;
VECTOR_T* V2_2 = VECTOR_ID(alloc)(n);
MATRIX_ID(get_row)(V2_2, As, u);
for (int i = 0; i <= v1; i++) {
VECTOR_ID(set)(V2_2, i, 0.0);
}
V2 = logical_or(V2_1, V2_2);
VECTOR_ID(free)(V2_1);
VECTOR_ID(free)(V2_2);
// for v2=find(V2)
VECTOR_T* find_V2 = find(V2);
if (find_V2 != NULL) {
for (int i_find_V2 = 0; i_find_V2 < (int)find_V2->size; i_find_V2++) {
int v2 = (int)VECTOR_ID(get)(find_V2, i_find_V2);
// vz=max(v1,v2);
int vz = (v1 > v2) ? v1 : v2;
// V3=([false(1,u) As(v2,u+1:n)]);
VECTOR_T* V3 = VECTOR_ID(alloc)(n);
MATRIX_ID(get_row)(V3, As, v2);
for (int i = 0; i <= u; i++) {
VECTOR_ID(set)(V3, i, 0.0);
}
// V3(V2)=0;
logical_index_assign(V3, V2, 0.0);
// V3=V3|([false(1,v2) As(v1,v2+1:n)]);
VECTOR_T* V3_1 = V3;
VECTOR_T* V3_2 = VECTOR_ID(alloc)(n);
MATRIX_ID(get_row)(V3_2, As, v1);
for (int i = 0; i <= v2; i++) {
VECTOR_ID(set)(V3_2, i, 0.0);
}
V3 = logical_or(V3_1, V3_2);
VECTOR_ID(free)(V3_1);
VECTOR_ID(free)(V3_2);
// V3(V1)=0;
logical_index_assign(V3, V1, 0.0);
// V3=V3|([false(1,vz) As(u,vz+1:n)]);
V3_1 = V3;
V3_2 = VECTOR_ID(alloc)(n);
MATRIX_ID(get_row)(V3_2, As, u);
for (int i = 0; i <= vz; i++) {
VECTOR_ID(set)(V3_2, i, 0.0);
}
V3 = logical_or(V3_1, V3_2);
VECTOR_ID(free)(V3_1);
VECTOR_ID(free)(V3_2);
// for v3=find(V3)
VECTOR_T* find_V3 = find(V3);
if (find_V3 != NULL ) {
for (int i_find_V3 = 0; i_find_V3 < (int)find_V3->size; i_find_V3++) {
int v3 = (int)VECTOR_ID(get)(find_V3, i_find_V3);
// s=uint32(sum(10.^(11:-1:0).*[A(v1,u) A(v2,u) A(v3,u) A(u,v1) A(v2,v1) A(v3,v1) A(u,v2) A(v1,v2) A(v3,v2) A(u,v3) A(v1,v3) A(v2,v3)]));
int A_rows[] = { v1, v2, v3, u, v2, v3, u, v1, v3, u, v1, v2 };
int A_cols[] = { u, u, u, v1, v1, v1, v2, v2, v2, v3, v3, v3 };
VECTOR_T* s = VECTOR_ID(alloc)(12);
for (int i = 0; i < 12; i++) {
VECTOR_ID(set)(s, i, MATRIX_ID(get)(A, A_rows[i], A_cols[i]));
}
// ind=ID4(s==M4n);
int i_M4 = 0;
for ( ; i_M4 < (int)M4->size1; i_M4++) {
VECTOR_ID(view) M4_row_i_M4 = MATRIX_ID(row)(M4, i_M4);
if (compare_vectors(s, &M4_row_i_M4.vector) == 0) {
break;
}
}
VECTOR_ID(free)(s);
if (i_M4 < (int)M4->size1) {
int ind = (int)VECTOR_ID(get)(ID4, i_M4) - 1;
// if nargout==2; F(ind,[u v1 v2 v3])=F(ind,[u v1 v2 v3])+1; end
if (F != NULL) {
int F_cols[] = { u, v1, v2, v3 };
for (int i = 0; i < 4; i++) {
MATRIX_ID(set)(*F, ind, F_cols[i], MATRIX_ID(get)(*F, ind, F_cols[i]) + 1.0);
}
}
// f(ind)=f(ind)+1;
VECTOR_ID(set)(f, ind, VECTOR_ID(get)(f, ind) + 1.0);
}
}
VECTOR_ID(free)(find_V3);
}
VECTOR_ID(free)(V3);
}
VECTOR_ID(free)(find_V2);
}
VECTOR_ID(free)(V2);
}
VECTOR_ID(free)(find_V1);
}
VECTOR_ID(free)(V1);
}
VECTOR_ID(free)(ID4);
MATRIX_ID(free)(M4);
MATRIX_ID(free)(As);
return f;
}
| 27.83815
| 145
| 0.508721
|
devuci
|
d64117aa915e6ae0b088b4a29488fb5f0d38fad0
| 285
|
cpp
|
C++
|
Primer/Trials/check.cpp
|
siddheshpai/hello-world
|
291456962d46c6ce857d75be86bc23634625925f
|
[
"Apache-2.0"
] | null | null | null |
Primer/Trials/check.cpp
|
siddheshpai/hello-world
|
291456962d46c6ce857d75be86bc23634625925f
|
[
"Apache-2.0"
] | null | null | null |
Primer/Trials/check.cpp
|
siddheshpai/hello-world
|
291456962d46c6ce857d75be86bc23634625925f
|
[
"Apache-2.0"
] | 1
|
2020-05-30T04:30:16.000Z
|
2020-05-30T04:30:16.000Z
|
#include <iostream>
int main()
{
int n = 5;
void *p = &n;
int *pi = static_cast<int*>(p);
++*pi;
std::cout << *pi << std::endl;
//Checking ref to const
std::string const &s = "9-99-999-9999";
std::cout << s << std::endl;
return 0;
}
| 15.833333
| 43
| 0.477193
|
siddheshpai
|
d64493de84c9e0f4f5f00dcbf845a5fd22bea3d7
| 1,798
|
cxx
|
C++
|
dicom2rawiv/zipextract/gdcm-2.6.3/Testing/Source/Common/Cxx/TestDirectory.cxx
|
chipbuster/skull-atlas
|
7f3ee009e1d5f65f101fe853a2cf6e12662970ee
|
[
"BSD-3-Clause"
] | 47
|
2020-03-30T14:36:46.000Z
|
2022-03-06T07:44:54.000Z
|
dicom2rawiv/zipextract/gdcm-2.6.3/Testing/Source/Common/Cxx/TestDirectory.cxx
|
chipbuster/skull-atlas
|
7f3ee009e1d5f65f101fe853a2cf6e12662970ee
|
[
"BSD-3-Clause"
] | null | null | null |
dicom2rawiv/zipextract/gdcm-2.6.3/Testing/Source/Common/Cxx/TestDirectory.cxx
|
chipbuster/skull-atlas
|
7f3ee009e1d5f65f101fe853a2cf6e12662970ee
|
[
"BSD-3-Clause"
] | 8
|
2020-04-01T01:22:45.000Z
|
2022-01-02T13:06:09.000Z
|
/*=========================================================================
Program: GDCM (Grassroots DICOM). A DICOM library
Copyright (c) 2006-2011 Mathieu Malaterre
All rights reserved.
See Copyright.txt or http://gdcm.sourceforge.net/Copyright.html for details.
This software is distributed WITHOUT ANY WARRANTY; without even
the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
PURPOSE. See the above copyright notice for more information.
=========================================================================*/
#include "gdcmDirectory.h"
#include "gdcmTesting.h"
#include "gdcmSystem.h"
#include <stdlib.h> // atoi
int TestOneDirectory(const char *path, bool recursive = false )
{
if( !gdcm::System::FileIsDirectory(path) )
{
std::cerr << path << " is not a directory" << std::endl;
return 1;
}
gdcm::Directory d;
d.Load( path, recursive );
//d.Print( std::cout );
if( d.GetToplevel() != path )
{
std::cerr << d.GetToplevel() << " != " << path << std::endl;
return 1;
}
gdcm::Directory::FilenamesType const &files = d.GetFilenames();
for(gdcm::Directory::FilenamesType::const_iterator it = files.begin(); it != files.end(); ++it )
{
const char *filename = it->c_str();
if( !gdcm::System::FileExists(filename) )
{
return 1;
}
}
return 0;
}
int TestDirectory(int argc, char *argv[])
{
int res = 0;
if( argc > 1 )
{
bool recursive = false;
if ( argc > 2 )
{
recursive = (atoi(argv[2]) > 0 ? true : false);
}
res += TestOneDirectory( argv[1], recursive);
}
else
{
const char *path = gdcm::Testing::GetDataRoot();
res += TestOneDirectory( path );
}
//res += TestOneDirectory( "" );
return res;
}
| 24.972222
| 98
| 0.565628
|
chipbuster
|
d6460c3cda3662f4730f91a14731321247e446ed
| 258
|
cpp
|
C++
|
PETCS/Intermediate/aplusb.cpp
|
dl4us/Competitive-Programming-1
|
d42fab3bd68168adbe4b5f594f19ee5dfcd1389b
|
[
"MIT"
] | null | null | null |
PETCS/Intermediate/aplusb.cpp
|
dl4us/Competitive-Programming-1
|
d42fab3bd68168adbe4b5f594f19ee5dfcd1389b
|
[
"MIT"
] | null | null | null |
PETCS/Intermediate/aplusb.cpp
|
dl4us/Competitive-Programming-1
|
d42fab3bd68168adbe4b5f594f19ee5dfcd1389b
|
[
"MIT"
] | null | null | null |
#include <bits/stdc++.h>
using namespace std;
int N;
int main() {
cin.sync_with_stdio(0);
cin.tie(0); cout.tie(0);
cin >> N;
int a, b;
for(int i = 0; i < N; i++) {
cin >> a >> b;
cout << a+b << "\n";
}
return 0;
}
| 17.2
| 32
| 0.453488
|
dl4us
|
d6468e7220e5b770459d2c4cff62b1dff129a89a
| 9,676
|
cpp
|
C++
|
Widgets/Datalog/dialogplotchannelchoose.cpp
|
cyferc/Empro-Datalog-Viewer
|
8d66cefe64aa254c283e72034f9ea452938ad212
|
[
"MIT"
] | 6
|
2017-03-29T14:44:06.000Z
|
2021-08-17T06:11:09.000Z
|
Widgets/Datalog/dialogplotchannelchoose.cpp
|
cyferc/Empro-Datalog-Viewer
|
8d66cefe64aa254c283e72034f9ea452938ad212
|
[
"MIT"
] | 1
|
2018-11-24T11:12:08.000Z
|
2018-11-24T11:12:08.000Z
|
Widgets/Datalog/dialogplotchannelchoose.cpp
|
cyferc/Empro-Datalog-Viewer
|
8d66cefe64aa254c283e72034f9ea452938ad212
|
[
"MIT"
] | 3
|
2018-01-20T21:53:03.000Z
|
2020-09-23T19:02:42.000Z
|
#include "dialogplotchannelchoose.h"
#include "ui_dialogplotchannelchoose.h"
#include <QGridLayout>
#include <QCheckBox>
#include <QDebug>
#include "plotdatalog.h"
DialogPlotChannelChoose::DialogPlotChannelChoose(std::vector<PointList *> vecOfPointLists, QSplitter *pSplitterPlots, QWidget *pParent) :
QDialog(pParent),
m_pUi(new Ui::DialogPlotChannelChoose),
m_pSplitterPlots(pSplitterPlots),
m_VecOfPointLists(vecOfPointLists)
{
m_pUi->setupUi(this);
setWindowFlags(windowFlags() & ~Qt::WindowContextHelpButtonHint);
// Add stacked widget for tables
m_pStackedTablesWidget = new QStackedWidget();
QGridLayout *stackedLayout = new QGridLayout(m_pUi->widgetTableContainer);
stackedLayout->setSpacing(0);
stackedLayout->setContentsMargins(0, 0, 0, 0);
stackedLayout->addWidget(m_pStackedTablesWidget);
connect(m_pUi->comboBoxPlotNumber,
static_cast<void (QComboBox::*)(int)>(&QComboBox::activated),
m_pStackedTablesWidget,
&QStackedWidget::setCurrentIndex);
// Create table for each plot
for (int plotIndex = 0; plotIndex < pSplitterPlots->count(); plotIndex++)
{
PlotDatalog* plot = qobject_cast<PlotDatalog *>(pSplitterPlots->children().at(plotIndex));
// Add plot number to drop down list
m_pUi->comboBoxPlotNumber->addItem(QString::number(plotIndex + 1));
// Create table for each plot
QTableWidget *table = new QTableWidget(vecOfPointLists.size(), 3, this);
table->setVerticalScrollMode(QAbstractItemView::ScrollPerPixel);
table->setHorizontalScrollMode(QAbstractItemView::ScrollPerPixel);
table->setSelectionMode(QAbstractItemView::NoSelection);
table->setAlternatingRowColors(true);
table->verticalHeader()->hide();
table->verticalHeader()->setDefaultSectionSize(17);
table->setHorizontalHeaderItem(cColumnChannel, new QTableWidgetItem("Channel"));
table->setColumnWidth(cColumnChannel, 228);
table->setHorizontalHeaderItem(cColumnPlot, new QTableWidgetItem("Plot"));
table->setColumnWidth(cColumnPlot, 40);
table->setHorizontalHeaderItem(cColumnYAxis, new QTableWidgetItem("Y Axis"));
table->setColumnWidth(cColumnYAxis, 40);
// Add channels to table
int vecOfPointListsSize = static_cast<int>(vecOfPointLists.size());
for (int channel = 0; channel < vecOfPointListsSize; channel++)
{
// Column: Channel
PointList *pList = vecOfPointLists[channel];
QTableWidgetItem *itemName = new QTableWidgetItem(pList->getName());
itemName->setFlags(itemName->flags() ^ Qt::ItemIsEditable);
table->setItem(channel, cColumnChannel, itemName);
// Column: Plot
QWidget *chBoxContainerWidget = new QWidget();
QCheckBox *chBoxDraw = new QCheckBox(chBoxContainerWidget);
chBoxDraw->setChecked(plot->vecChannelsDraw[channel]);
QObject::connect(chBoxDraw,
&QCheckBox::stateChanged,
this,
&DialogPlotChannelChoose::checkBoxPlotStateChanged);
// Centre the checkbox
QHBoxLayout *pLayout = new QHBoxLayout(chBoxContainerWidget);
pLayout->addWidget(chBoxDraw);
pLayout->setAlignment(Qt::AlignCenter);
pLayout->setContentsMargins(0, 0, 0, 0);
table->setCellWidget(channel, cColumnPlot, chBoxContainerWidget);
// Column: Y Axis
QWidget *chBoxContainerWidgetYAxis = new QWidget();
QCheckBox *chBoxYAxis = new QCheckBox(chBoxContainerWidgetYAxis);
if (chBoxDraw->isChecked())
{
chBoxYAxis->setChecked(plot->vecChannelsYAxis[channel]);
}
else
{
chBoxYAxis->setEnabled(false);
}
QObject::connect(chBoxYAxis,
&QCheckBox::stateChanged,
this,
&DialogPlotChannelChoose::checkBoxYAxisStateChanged);
// Centre the checkbox
QHBoxLayout *pLayoutYAxis = new QHBoxLayout(chBoxContainerWidgetYAxis);
pLayoutYAxis->addWidget(chBoxYAxis);
pLayoutYAxis->setAlignment(Qt::AlignCenter);
pLayoutYAxis->setContentsMargins(0, 0, 0, 0);
table->setCellWidget(channel, cColumnYAxis, chBoxContainerWidgetYAxis);
}
table->setFocus();
table->selectRow(0);
// Add widget to bottom of stack
m_pStackedTablesWidget->insertWidget(0, table);
m_pStackedTablesWidget->setCurrentIndex(0);
}
}
DialogPlotChannelChoose::~DialogPlotChannelChoose()
{
delete m_pUi;
}
///
/// \brief DialogPlotChannelChoose::getCurrentTable
/// \param index
/// \return Returns table at index. If index is not provided, current table is returned.
///
QTableWidget *DialogPlotChannelChoose::getCurrentTable(int index)
{
QWidget *table;
if (index >= 0)
{
table = m_pStackedTablesWidget->widget(index);
}
else
{
table = m_pStackedTablesWidget->widget(m_pUi->comboBoxPlotNumber->currentIndex());
}
return qobject_cast<QTableWidget*>(table);
}
void DialogPlotChannelChoose::checkBoxPlotStateChanged(int state)
{
int senderRow = -1;
QCheckBox* senderCheckBox = qobject_cast<QCheckBox*>(sender());
// Get the sender row in the table
for (int i = 0; i < getCurrentTable()->rowCount(); i++)
{
if (getCurrentTable()->cellWidget(i, cColumnPlot)->children().at(0) == senderCheckBox)
{
senderRow = i;
break;
}
}
if (senderRow < 0)
{
qDebug() << "sender row not found";
return;
}
QCheckBox *chBoxYAxis = qobject_cast<QCheckBox *>(getCurrentTable()->cellWidget(senderRow, cColumnYAxis)->children().at(0));
if (state == false)
{
chBoxYAxis->setChecked(false);
}
chBoxYAxis->setEnabled(state);
}
void DialogPlotChannelChoose::checkBoxYAxisStateChanged(int /*state*/)
{
int senderRow = -1;
QCheckBox* senderCheckBox = qobject_cast<QCheckBox*>(sender());
// Get the sender row in the table
for (int i = 0; i < getCurrentTable()->rowCount(); i++)
{
if (getCurrentTable()->cellWidget(i, cColumnPlot)->children().at(0) == senderCheckBox)
{
senderRow = i;
break;
}
}
if (senderRow < 0)
{
qDebug() << "sender row not found";
return;
}
}
/*
QVector<QVector<bool>> DialogPlotChannelChoose::getSelectedPlotIndices()
{
// Create / resize 2d vector
QVector<QVector<bool>> isSelectedVector2d(_stackedTables->count());
for(int outer = 0; outer < isSelectedVector2d.size(); outer++)
{
isSelectedVector2d[outer].resize(getCurrentTable()->rowCount());
}
for (int tableIndex = 0; tableIndex < _stackedTables->count(); tableIndex++)
{
for (int channel = 0; channel < getCurrentTable(tableIndex)->rowCount(); channel++)
{
QCheckBox *chBox = qobject_cast<QCheckBox *>(getCurrentTable(tableIndex)->cellWidget(channel, ColumnPlot)->children().at(0));
if (chBox->isChecked())
{
isSelectedVector2d[tableIndex][channel] = true;
}
else
{
isSelectedVector2d[tableIndex][channel] = false;
}
}
}
return isSelectedVector2d;
}
QList<int> DialogPlotChannelChoose::getSelectedYAxisIndices()
{
QList<int> selectedIndices;
for (int row = 0; row < getCurrentTable()->rowCount(); row++)
{
QCheckBox *chBox = qobject_cast<QCheckBox *>(getCurrentTable()->cellWidget(row, ColumnYAxis)->children().at(0));
if (chBox->isChecked())
{
//qDebug() << row;
selectedIndices.append(row);
}
}
return selectedIndices;
}
*/
void DialogPlotChannelChoose::on_btnSelectAll_clicked()
{
for (int row = 0; row < getCurrentTable()->rowCount(); row++)
{
QCheckBox *chBox = qobject_cast<QCheckBox *>(getCurrentTable()->cellWidget(row, cColumnPlot)->children().at(0));
chBox->setChecked(true);
}
}
void DialogPlotChannelChoose::on_btnDeselectAll_clicked()
{
for (int row = 0; row < getCurrentTable()->rowCount(); row++)
{
QCheckBox *chBox = qobject_cast<QCheckBox *>(getCurrentTable()->cellWidget(row, cColumnPlot)->children().at(0));
chBox->setChecked(false);
}
}
void DialogPlotChannelChoose::on_buttonBox_accepted()
{
for (int plotIndex = 0; plotIndex < m_pSplitterPlots->count(); plotIndex++)
{
PlotDatalog* plot = qobject_cast<PlotDatalog*>(m_pSplitterPlots->widget(plotIndex));
// Clear all points from all plots
plot->clearPointLists();
for (int channel = 0; channel < getCurrentTable(plotIndex)->rowCount(); channel++)
{
QCheckBox *chBoxDrawChannel = qobject_cast<QCheckBox *>(getCurrentTable(plotIndex)->cellWidget(channel, cColumnPlot)->children().at(0));
QCheckBox *chBoxYAxis = qobject_cast<QCheckBox *>(getCurrentTable(plotIndex)->cellWidget(channel, cColumnYAxis)->children().at(0));
if (chBoxDrawChannel->isChecked())
{
plot->addPointList(m_VecOfPointLists.at(channel));
}
plot->vecChannelsDraw[channel] = chBoxDrawChannel->isChecked();
plot->vecChannelsYAxis[channel] = chBoxYAxis->isChecked();
}
}
}
| 33.597222
| 148
| 0.632906
|
cyferc
|
d6477a936a53840c19a74bddb1f90eb57f8b9541
| 9,898
|
cpp
|
C++
|
test/hotspot/gtest/metaspace/test_chunkManager_stress.cpp
|
1690296356/jdk
|
eaf668d1510c28d51e26c397b582b66ebdf7e263
|
[
"Apache-2.0"
] | null | null | null |
test/hotspot/gtest/metaspace/test_chunkManager_stress.cpp
|
1690296356/jdk
|
eaf668d1510c28d51e26c397b582b66ebdf7e263
|
[
"Apache-2.0"
] | null | null | null |
test/hotspot/gtest/metaspace/test_chunkManager_stress.cpp
|
1690296356/jdk
|
eaf668d1510c28d51e26c397b582b66ebdf7e263
|
[
"Apache-2.0"
] | null | null | null |
/*
* Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2020 SAP SE. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*
*/
#include "precompiled.hpp"
#include "memory/metaspace/chunkManager.hpp"
#include "memory/metaspace/metaspaceSettings.hpp"
#include "memory/metaspace/virtualSpaceList.hpp"
//#define LOG_PLEASE
#include "metaspaceGtestCommon.hpp"
#include "metaspaceGtestContexts.hpp"
#include "metaspaceGtestRangeHelpers.hpp"
#include "metaspaceGtestSparseArray.hpp"
using metaspace::ChunkManager;
using metaspace::Settings;
class ChunkManagerRandomChunkAllocTest {
static const size_t max_footprint_words = 8 * M;
ChunkGtestContext _context;
// All allocated live chunks
typedef SparseArray<Metachunk*> SparseArrayOfChunks;
SparseArrayOfChunks _chunks;
const ChunkLevelRange _chunklevel_range;
const float _commit_factor;
// Depending on a probability pattern, come up with a reasonable limit to number of live chunks
static int max_num_live_chunks(ChunkLevelRange r, float commit_factor) {
// Assuming we allocate only the largest type of chunk, committed to the fullest commit factor,
// how many chunks can we accomodate before hitting max_footprint_words?
const size_t largest_chunk_size = word_size_for_level(r.lowest());
int max_chunks = (max_footprint_words * commit_factor) / largest_chunk_size;
// .. but cap at (min) 50 and (max) 1000
max_chunks = MIN2(1000, max_chunks);
max_chunks = MAX2(50, max_chunks);
return max_chunks;
}
// Return true if, after an allocation error happened, a reserve error seems likely.
bool could_be_reserve_error() {
return _context.vslist().is_full();
}
// Return true if, after an allocation error happened, a commit error seems likely.
bool could_be_commit_error(size_t additional_word_size) {
// could it be commit limit hit?
if (Settings::new_chunks_are_fully_committed()) {
// For all we know we may have just failed to fully-commit a new root chunk.
additional_word_size = MAX_CHUNK_WORD_SIZE;
}
// Note that this is difficult to verify precisely, since there are
// several layers of truth:
// a) at the lowest layer (RootChunkArea) we have a bitmap of committed granules;
// b) at the vslist layer, we keep running counters of committed/reserved words;
// c) at the chunk layer, we keep a commit watermark (committed_words).
//
// (a) should mirror reality.
// (a) and (b) should be precisely in sync. This is tested by
// VirtualSpaceList::verify().
// (c) can be, by design, imprecise (too low).
//
// Here, I check (b) and trust it to be correct. We also call vslist::verify().
DEBUG_ONLY(_context.verify();)
const size_t commit_add = align_up(additional_word_size, Settings::commit_granule_words());
if (_context.commit_limit() <= (commit_add + _context.vslist().committed_words())) {
return true;
}
return false;
}
// Given a chunk level and a factor, return a random commit size.
static size_t random_committed_words(chunklevel_t lvl, float commit_factor) {
const size_t sz = word_size_for_level(lvl) * commit_factor;
if (sz < 2) {
return 0;
}
return MIN2(SizeRange(sz).random_value(), sz);
}
//// Chunk allocation ////
// Given an slot index, allocate a random chunk and set it into that slot. Slot must be empty.
// Returns false if allocation fails.
bool allocate_random_chunk_at(int slot) {
DEBUG_ONLY(_chunks.check_slot_is_null(slot);)
const ChunkLevelRange r = _chunklevel_range.random_subrange();
const chunklevel_t pref_level = r.lowest();
const chunklevel_t max_level = r.highest();
const size_t min_committed = random_committed_words(max_level, _commit_factor);
Metachunk* c = NULL;
_context.alloc_chunk(&c, r.lowest(), r.highest(), min_committed);
if (c == NULL) {
EXPECT_TRUE(could_be_reserve_error() ||
could_be_commit_error(min_committed));
LOG("Alloc chunk at %d failed.", slot);
return false;
}
_chunks.set_at(slot, c);
LOG("Allocated chunk at %d: " METACHUNK_FORMAT ".", slot, METACHUNK_FORMAT_ARGS(c));
return true;
}
// Allocates a random number of random chunks
bool allocate_random_chunks() {
int to_alloc = 1 + IntRange(MAX2(1, _chunks.size() / 8)).random_value();
bool success = true;
int slot = _chunks.first_null_slot();
while (to_alloc > 0 && slot != -1 && success) {
success = allocate_random_chunk_at(slot);
slot = _chunks.next_null_slot(slot);
to_alloc --;
}
return success && to_alloc == 0;
}
bool fill_all_slots_with_random_chunks() {
bool success = true;
for (int slot = _chunks.first_null_slot();
slot != -1 && success; slot = _chunks.next_null_slot(slot)) {
success = allocate_random_chunk_at(slot);
}
return success;
}
//// Chunk return ////
// Given an slot index, return the chunk in that slot to the chunk manager.
void return_chunk_at(int slot) {
Metachunk* c = _chunks.at(slot);
LOG("Returning chunk at %d: " METACHUNK_FORMAT ".", slot, METACHUNK_FORMAT_ARGS(c));
_context.return_chunk(c);
_chunks.set_at(slot, NULL);
}
// return a random number of chunks (at most a quarter of the full slot range)
void return_random_chunks() {
int to_free = 1 + IntRange(MAX2(1, _chunks.size() / 8)).random_value();
int index = _chunks.first_non_null_slot();
while (to_free > 0 && index != -1) {
return_chunk_at(index);
index = _chunks.next_non_null_slot(index);
to_free --;
}
}
void return_all_chunks() {
for (int slot = _chunks.first_non_null_slot();
slot != -1; slot = _chunks.next_non_null_slot(slot)) {
return_chunk_at(slot);
}
}
// adjust test if we change levels
STATIC_ASSERT(HIGHEST_CHUNK_LEVEL == CHUNK_LEVEL_1K);
STATIC_ASSERT(LOWEST_CHUNK_LEVEL == CHUNK_LEVEL_4M);
void one_test() {
fill_all_slots_with_random_chunks();
_chunks.shuffle();
IntRange rand(100);
for (int j = 0; j < 1000; j++) {
bool force_alloc = false;
bool force_free = true;
bool do_alloc =
force_alloc ? true :
(force_free ? false : rand.random_value() >= 50);
force_alloc = force_free = false;
if (do_alloc) {
if (!allocate_random_chunks()) {
force_free = true;
}
} else {
return_random_chunks();
}
_chunks.shuffle();
}
return_all_chunks();
}
public:
// A test with no limits
ChunkManagerRandomChunkAllocTest(ChunkLevelRange r, float commit_factor) :
_context(),
_chunks(max_num_live_chunks(r, commit_factor)),
_chunklevel_range(r),
_commit_factor(commit_factor)
{}
// A test with no reserve limit but commit limit
ChunkManagerRandomChunkAllocTest(size_t commit_limit,
ChunkLevelRange r, float commit_factor) :
_context(commit_limit),
_chunks(max_num_live_chunks(r, commit_factor)),
_chunklevel_range(r),
_commit_factor(commit_factor)
{}
// A test with both reserve and commit limit
// ChunkManagerRandomChunkAllocTest(size_t commit_limit, size_t reserve_limit,
// ChunkLevelRange r, float commit_factor)
// : _helper(commit_limit, reserve_limit),
// _chunks(max_num_live_chunks(r, commit_factor)),
// _chunklevel_range(r),
// _commit_factor(commit_factor)
// {}
void do_tests() {
const int num_runs = 5;
for (int n = 0; n < num_runs; n++) {
one_test();
}
}
};
#define DEFINE_TEST(name, range, commit_factor) \
TEST_VM(metaspace, chunkmanager_random_alloc_##name) { \
ChunkManagerRandomChunkAllocTest test(range, commit_factor); \
test.do_tests(); \
}
DEFINE_TEST(test_nolimit_1, ChunkLevelRanges::small_chunks(), 0.0f)
DEFINE_TEST(test_nolimit_2, ChunkLevelRanges::small_chunks(), 0.5f)
DEFINE_TEST(test_nolimit_3, ChunkLevelRanges::small_chunks(), 1.0f)
DEFINE_TEST(test_nolimit_4, ChunkLevelRanges::all_chunks(), 0.0f)
DEFINE_TEST(test_nolimit_5, ChunkLevelRanges::all_chunks(), 0.5f)
DEFINE_TEST(test_nolimit_6, ChunkLevelRanges::all_chunks(), 1.0f)
#define DEFINE_TEST_2(name, range, commit_factor) \
TEST_VM(metaspace, chunkmanager_random_alloc_##name) { \
const size_t commit_limit = 256 * K; \
ChunkManagerRandomChunkAllocTest test(commit_limit, range, commit_factor); \
test.do_tests(); \
}
DEFINE_TEST_2(test_with_limit_1, ChunkLevelRanges::small_chunks(), 0.0f)
DEFINE_TEST_2(test_with_limit_2, ChunkLevelRanges::small_chunks(), 0.5f)
DEFINE_TEST_2(test_with_limit_3, ChunkLevelRanges::small_chunks(), 1.0f)
DEFINE_TEST_2(test_with_limit_4, ChunkLevelRanges::all_chunks(), 0.0f)
DEFINE_TEST_2(test_with_limit_5, ChunkLevelRanges::all_chunks(), 0.5f)
DEFINE_TEST_2(test_with_limit_6, ChunkLevelRanges::all_chunks(), 1.0f)
| 33.666667
| 99
| 0.703071
|
1690296356
|
d64e446dff7144ca8d332cb99165bcb8e195f0bd
| 707
|
cpp
|
C++
|
src/axl_fsm/axl_fsm_StdRegexNameMgr.cpp
|
wandns/axl
|
5686b94b18033df13a9e1656e1aaaf086c442a21
|
[
"MIT"
] | null | null | null |
src/axl_fsm/axl_fsm_StdRegexNameMgr.cpp
|
wandns/axl
|
5686b94b18033df13a9e1656e1aaaf086c442a21
|
[
"MIT"
] | null | null | null |
src/axl_fsm/axl_fsm_StdRegexNameMgr.cpp
|
wandns/axl
|
5686b94b18033df13a9e1656e1aaaf086c442a21
|
[
"MIT"
] | null | null | null |
//..............................................................................
//
// This file is part of the AXL library.
//
// AXL is distributed under the MIT license.
// For details see accompanying license.txt file,
// the public copy of which is also available at:
// http://tibbo.com/downloads/archive/axl/license.txt
//
//..............................................................................
#include "pch.h"
#include "axl_fsm_StdRegexNameMgr.h"
namespace axl {
namespace fsm {
//..............................................................................
//..............................................................................
} // namespace fsm
} // namespace axl
| 29.458333
| 80
| 0.381895
|
wandns
|
d64e7ea4e4dabafa189a4fea5e17aaaaaa8ecd54
| 4,641
|
hpp
|
C++
|
ext/tatara/array/integer/int_array.hpp
|
S-H-GAMELINKS/tatara
|
b849be7c7a9d097b2c0bd0b5df5bbb21ec96d3c0
|
[
"MIT"
] | 6
|
2019-08-16T11:35:43.000Z
|
2019-11-16T07:57:06.000Z
|
ext/tatara/array/integer/int_array.hpp
|
S-H-GAMELINKS/tatara
|
b849be7c7a9d097b2c0bd0b5df5bbb21ec96d3c0
|
[
"MIT"
] | 378
|
2019-08-15T07:55:18.000Z
|
2020-02-16T12:22:34.000Z
|
ext/tatara/array/integer/int_array.hpp
|
S-H-GAMELINKS/tatara
|
b849be7c7a9d097b2c0bd0b5df5bbb21ec96d3c0
|
[
"MIT"
] | 1
|
2019-09-02T15:32:58.000Z
|
2019-09-02T15:32:58.000Z
|
#ifndef INT_ARRAY_HPP_
#define INT_ARRAY_HPP_
#include <ruby.h>
#include <vector>
#include <algorithm>
#include <iterator>
#include <iostream>
static VALUE int_array_init(VALUE self) {
return self;
}
static VALUE int_array_first(VALUE self) {
return rb_ary_entry(self, 0);
}
static VALUE int_array_last(VALUE self) {
const long length = RARRAY_LEN(self);
if (length == 0) return Qnil;
return rb_ary_entry(self, length - 1);
}
static VALUE int_array_bracket(VALUE self, VALUE index) {
return rb_ary_entry(self, NUM2LONG(index));
}
static VALUE int_array_bracket_equal(VALUE self, VALUE index, VALUE value) {
if (FIXNUM_P(value)) {
long i = NUM2LONG(index);
rb_ary_store(self, i, value);
return value;
} else {
rb_raise(rb_eTypeError, "Worng Type! This Value type is %s !", rb_class_name(value));
return Qnil;
}
}
static VALUE int_array_push(VALUE self, VALUE value) {
if (FIXNUM_P(value)) {
rb_ary_push(self, value);
return self;
} else {
rb_raise(rb_eTypeError, "Worng Type! This Value type is %s !", rb_class_name(value));
return Qnil;
}
}
static VALUE int_array_size(VALUE self) {
return LONG2NUM(RARRAY_LEN(self));
}
static VALUE int_array_clear(VALUE self) {
rb_ary_clear(self);
return self;
}
static VALUE int_array_map(VALUE self) {
std::size_t size = RARRAY_LEN(self);
VALUE collection = rb_obj_dup(self);
for(int i = 0; i < size; i++) {
VALUE val = int_array_bracket(self, INT2NUM(i));
int_array_bracket_equal(collection, INT2NUM(i), rb_yield(val));
}
return collection;
}
static VALUE int_array_destructive_map(VALUE self) {
std::size_t size = RARRAY_LEN(self);
for(int i = 0; i < size; i++) {
VALUE val = int_array_bracket(self, INT2NUM(i));
int_array_bracket_equal(self, INT2NUM(i), rb_yield(val));
}
return self;
}
static VALUE int_array_each_with_index(VALUE self) {
std::size_t size = RARRAY_LEN(self);
VALUE collection = rb_obj_dup(self);
for(int i = 0; i < size; i++) {
VALUE val = int_array_bracket(self, INT2NUM(i));
VALUE key_value = rb_ary_new2(2);
rb_ary_push(key_value, val);
rb_ary_push(key_value, INT2NUM(i));
rb_ary_push(collection, rb_yield(key_value));
}
return collection;
}
static VALUE int_array_convert_array(VALUE self) {
std::size_t size = RARRAY_LEN(self);
VALUE collection = rb_ary_new2(size);
for(int i = 0; i < size; i++) {
VALUE val = int_array_bracket(self, INT2NUM(i));
rb_ary_push(collection, val);
}
return collection;
}
static VALUE int_array_import_array(VALUE self, VALUE ary) {
std::size_t size = RARRAY_LEN(ary);
for(int i = 0; i < size; i++) {
VALUE val = rb_ary_entry(ary, i);
int_array_push(self, val);
}
return self;
}
static VALUE int_array_sum(VALUE self) {
std::size_t size = RARRAY_LEN(self);
long result = 0;
for (int i = 0; i < size; i++) {
VALUE val = int_array_bracket(self, INT2NUM(i));
result += NUM2LONG(val);
}
return LONG2NUM(result);
}
static VALUE int_array_sort(VALUE self) {
return rb_ary_sort(self);
}
extern "C" {
inline void Init_int_array(VALUE mTatara) {
VALUE rb_cIntArray = rb_define_class_under(mTatara, "IntArray", rb_cArray);
rb_define_private_method(rb_cIntArray, "initialize", int_array_init, 0);
rb_define_method(rb_cIntArray, "first", int_array_first, 0);
rb_define_method(rb_cIntArray, "last", int_array_last, 0);
rb_define_method(rb_cIntArray, "[]", int_array_bracket, 1);
rb_define_method(rb_cIntArray, "[]=", int_array_bracket_equal, 2);
rb_define_method(rb_cIntArray, "push", int_array_push, 1);
rb_define_method(rb_cIntArray, "size", int_array_size, 0);
rb_define_method(rb_cIntArray, "clear", int_array_clear, 0);
rb_define_alias(rb_cIntArray, "<<", "push");
rb_define_method(rb_cIntArray, "map", int_array_map, 0);
rb_define_method(rb_cIntArray, "map!", int_array_destructive_map, 0);
rb_define_alias(rb_cIntArray, "each", "map");
rb_define_method(rb_cIntArray, "each_with_index", int_array_each_with_index, 0);
rb_define_method(rb_cIntArray, "to_array", int_array_convert_array, 0);
rb_define_method(rb_cIntArray, "import_array", int_array_import_array, 1);
rb_define_method(rb_cIntArray, "sum", int_array_sum, 0);
rb_define_method(rb_cIntArray, "sort", int_array_sort, 0);
}
}
#endif
| 27.3
| 93
| 0.664081
|
S-H-GAMELINKS
|
d65105f7124e34e006397ffc4eb686cf9b87ab8c
| 627
|
hpp
|
C++
|
src/include/helper.hpp
|
allen880117/Simulated-Quantum-Annealing
|
84ce0a475a9f132502c4bb4e9b4ca5824cdb7630
|
[
"MIT"
] | 2
|
2021-09-08T08:01:27.000Z
|
2021-11-21T00:08:56.000Z
|
src/include/helper.hpp
|
allen880117/Simulated-Quantum-Annealing
|
84ce0a475a9f132502c4bb4e9b4ca5824cdb7630
|
[
"MIT"
] | null | null | null |
src/include/helper.hpp
|
allen880117/Simulated-Quantum-Annealing
|
84ce0a475a9f132502c4bb4e9b4ca5824cdb7630
|
[
"MIT"
] | null | null | null |
#ifndef _HELPER_HPP_
#define _HELPER_HPP_
#include "sqa.hpp"
/* Progress Bar */
#define PBSTR "||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||"
#define PBWIDTH 60
/* Print the progress bar */
void printProgress(double percentage);
/* Generate Random Initial State */
void generateRandomState(spin_t trotters[MAX_NTROT][MAX_NSPIN], int nTrot,
int nSpin);
/* Compute Energy Summation of A Trotter*/
fp_t computeEnergyPerTrotter(int nSpin, spin_t trotter[MAX_NSPIN],
fp_t Jcoup[MAX_NSPIN][MAX_NSPIN],
fp_t h[MAX_NSPIN]);
#endif
| 27.26087
| 76
| 0.590112
|
allen880117
|
d651893644eb14548298ed0bad64c2821f706b20
| 3,457
|
cpp
|
C++
|
RandPass.cpp
|
abdulrahmanabdulazeez/RandPass
|
e7b11c2f577d3ca460358bfa826e7939825cccc4
|
[
"MIT"
] | 2
|
2021-09-13T15:34:30.000Z
|
2021-09-30T22:16:44.000Z
|
RandPass.cpp
|
abdulrahmanabdulazeez/RandPass
|
e7b11c2f577d3ca460358bfa826e7939825cccc4
|
[
"MIT"
] | null | null | null |
RandPass.cpp
|
abdulrahmanabdulazeez/RandPass
|
e7b11c2f577d3ca460358bfa826e7939825cccc4
|
[
"MIT"
] | null | null | null |
//Do not copy:
//More Advanced Version:
//Random Password Generator:
#include <iostream>
#include <cstdlib>
#include <ctime>
#include <fstream>
using namespace std;
void help();
void PASSINTRO(){
cout << "------------------------------------------------------------\n\n";
cout << " RANDOM PASSWORD GENERATOR\n";
cout << "\n\nIf you notice any bug, contact me @ \n"
<< "https://web.facebook.com/abdulrahman.abdulazeez.5243/ \n\n";
cout << "----------------------------------------------------------V2.0\n";
cout << "\n\n";
}
int main(){
system("COLOR A");
srand(time(0));
PASSINTRO();
string optionSelect;
cout << "\n [1] Generate Random Password.\n";
cout << " [2] Help.\n";
cout << " [3] Exit.\n\n";
cout << "Select an option: ";
cin >> optionSelect;
while (optionSelect != "1"){
if (optionSelect == "3"){
return 0;
}
else if (optionSelect == "2"){
help();
string key;
cout << "\n\nEnter any key to continue!";
cin >> key;
system ("CLS");
main();
}
cout << "Wrong Option!";
system ("CLS");
main();
}
if (optionSelect == "1"){
//Nothing;
}
else if (optionSelect == "2"){
return 0;
}
else {
return 0;
}
char NumLetSym[] = "zxcvbnmqpwoeirutyalskdjfhgQWERTYUIOPASDFGHJKLMNBVCZ1234567890:/.,()[]';?>|<!@#$%^&*";
int conv = sizeof(NumLetSym);
cout << "\nWhat do you want to generate a password for? \n\n"
<< "Hint: It could be Facebook, Google, name it and we would do just that \n"
<< "for you. \n\n";
string reason;
cout << "Reason: ";
cin >> reason;
cout << "\nEnter the length of password you want to generate: ";
int n;
cin >>n;
int load;
for (load=0; load <= 100; load++){
system("cls");
PASSINTRO();
cout << "Generating Password......." << load << "%";
cout << "\n\n";
}
int i;
ofstream RandomPass(reason + ".html");
for(i = 0; i < n; i++){
RandomPass << NumLetSym[rand() % conv];
}
RandomPass.close();
string Reader;
ifstream RandomPasser(reason + ".html");
while (getline (RandomPasser, Reader)) {
cout << "===================================================\n";
cout << " " << reason << " generated password: ";
cout << Reader;
cout << "\n===================================================\n\n";
}
cout << "Generated password has been saved in " << reason << ".html on your desktop.\n";
cout << "Note: You are to open it with any text viewer you have available.\n\n";
RandomPasser.close();
cout << "Do you want to re-generate another Password?[Y/N]: ";
string yesNo;
cin >> yesNo;
while (yesNo != "Y"){
if (yesNo == "N"){
return 0;
}
else if (yesNo == "y"){
system ("CLS");
}
else if (yesNo == "n"){
return 0;
}
cout << " Wrong option!!\n\n";
cout << "Do you want to re-generate another Password?[Y/N]: ";
cin >> yesNo;
}
if (yesNo == "Y"){
system("CLS");
cout << "\n";
main();
}
else if (yesNo == "N"){
return 0;
}
else if (yesNo == "y"){
system("CLS");
cout << "\n";
main();
}
else if (yesNo == "n"){
return 0;
}
else {
return 0;
}
return 0;
}
void help(){
cout << "\n\nAn advanced Random Password generator which generates very strong passwords \n"
<< "containing Letters(Small & Capital), Symbols and Numbers. This program also gives \n"
<< "you an option to specify the reason for the password to be created and stores the \n"
<< "generated password on your desktop with the reason you specified as filename \n"
<< "thereby making it easy to check on incase you forget the password generated \n"
<< "\nNote: The password stored on your desktop is in a HTML format. You can choose to \n"
<< "open with any text viewer of your choice.!";
}
| 24.174825
| 105
| 0.596182
|
abdulrahmanabdulazeez
|
d6618d5c25345e95ecb195b5f0d64cc65ad2cd5f
| 275
|
cpp
|
C++
|
2021.10.03-homework-3/Project3/Source.cpp
|
st095227/homework_2021-2022
|
7b3abd8848ead7456972c5d2f0f4404532e299bc
|
[
"Apache-2.0"
] | null | null | null |
2021.10.03-homework-3/Project3/Source.cpp
|
st095227/homework_2021-2022
|
7b3abd8848ead7456972c5d2f0f4404532e299bc
|
[
"Apache-2.0"
] | null | null | null |
2021.10.03-homework-3/Project3/Source.cpp
|
st095227/homework_2021-2022
|
7b3abd8848ead7456972c5d2f0f4404532e299bc
|
[
"Apache-2.0"
] | null | null | null |
#include <iostream>
using namespace std;
int main(int argv, char* argc[])
{
int n = 0;
cin >> n;
int i = 0;
int b = 0;
while (n != 0)
{
++i;
for (int j = 0; j < i && n>0; ++j)
{
++b;
cout << b << ' ';
--n;
}
cout << endl;
}
return EXIT_SUCCESS;
}
| 11.956522
| 36
| 0.461818
|
st095227
|
d666f64f883dacdd4b5404cdaeb89b92e1ea7a87
| 3,030
|
cpp
|
C++
|
portable-executable/portable-executable-library2/tests/test_resource_message_table/main.cpp
|
psneo/Pesidious
|
c36647d1b3ba86a9a4e6e1a0bda2a371d8875781
|
[
"MIT"
] | 83
|
2020-09-14T16:51:42.000Z
|
2022-03-31T23:23:02.000Z
|
portable-executable/portable-executable-library2/tests/test_resource_message_table/main.cpp
|
bedangSen/Pesidious-1
|
3348a8977951074eef41dbd8460934ef7a9093fd
|
[
"MIT"
] | 9
|
2020-11-13T19:08:15.000Z
|
2022-03-12T00:50:20.000Z
|
portable-executable/portable-executable-library2/tests/test_resource_message_table/main.cpp
|
bedangSen/Pesidious-1
|
3348a8977951074eef41dbd8460934ef7a9093fd
|
[
"MIT"
] | 30
|
2020-09-13T15:05:22.000Z
|
2022-03-28T05:51:05.000Z
|
#include <iostream>
#include <fstream>
#include <pe_bliss.h>
#include <pe_bliss_resources.h>
#include "test.h"
#ifdef PE_BLISS_WINDOWS
#include "lib.h"
#endif
using namespace pe_bliss;
int main(int argc, char* argv[])
{
PE_TEST_START
std::auto_ptr<std::ifstream> pe_file;
if(!open_pe_file(argc, argv, pe_file))
return -1;
pe_base image(pe_factory::create_pe(*pe_file));
resource_directory root(get_resources(image));
pe_resource_manager res(root);
resource_message_list_reader msg(res);
resource_message_list messages;
//Unicode tests
PE_TEST_EXCEPTION(messages = msg.get_message_table_by_id_lang(1049, 1), "Message Table Parser test 1", test_level_critical);
PE_TEST(messages.size() == 2, "Message Table Parser test 2", test_level_critical);
PE_TEST(messages.find(0x01000000) != messages.end()
&& messages.find(0xC1000001) != messages.end(), "Message Table Parser test 3", test_level_critical);
PE_TEST(messages[0xC1000001].is_unicode(), "Message Table Parser test 4", test_level_normal);
PE_TEST(messages[0xC1000001].get_unicode_string() == L"Ошибка!\r\n", "Message Table Parser test 5", test_level_normal);
PE_TEST_EXCEPTION(messages = msg.get_message_table_by_id_lang(1033, 1), "Message Table Parser test 6", test_level_critical);
PE_TEST(messages.size() == 2, "Message Table Parser test 7", test_level_critical);
PE_TEST(messages.find(0x01000000) != messages.end()
&& messages.find(0xC1000001) != messages.end(), "Message Table Parser test 8", test_level_critical);
PE_TEST(messages[0xC1000001].is_unicode(), "Message Table Parser test 9", test_level_normal);
PE_TEST(messages[0xC1000001].get_unicode_string() == L"Error!\r\n", "Message Table Parser test 10", test_level_normal);
//ANSI Tests
PE_TEST_EXCEPTION(messages = msg.get_message_table_by_id_lang(1049, 2), "Message Table Parser test 11", test_level_critical);
PE_TEST(messages.size() == 2, "Message Table Parser test 12", test_level_critical);
PE_TEST(messages.find(0x01000000) != messages.end()
&& messages.find(0xC1000001) != messages.end(), "Message Table Parser test 13", test_level_critical);
PE_TEST(!messages[0xC1000001].is_unicode(), "Message Table Parser test 14", test_level_normal);
PE_TEST(messages[0xC1000001].get_ansi_string() == "\xCE\xF8\xE8\xE1\xEA\xE0!\r\n", "Message Table Parser test 15", test_level_normal); //"Ошибка!\r\n"
PE_TEST_EXCEPTION(messages = msg.get_message_table_by_id_lang(1033, 2), "Message Table Parser test 16", test_level_critical);
PE_TEST(messages.size() == 2, "Message Table Parser test 17", test_level_critical);
PE_TEST(messages.find(0x01000000) != messages.end()
&& messages.find(0xC1000001) != messages.end(), "Message Table Parser test 18", test_level_critical);
PE_TEST(!messages[0xC1000001].is_unicode(), "Message Table Parser test 19", test_level_normal);
PE_TEST(messages[0xC1000001].get_ansi_string() == "Error!\r\n", "Message Table Parser test 20", test_level_normal);
PE_TEST_END
return 0;
}
| 48.095238
| 152
| 0.744884
|
psneo
|
d66735c18595db157d264abb51aafadb8eb3a8f3
| 2,361
|
cpp
|
C++
|
plugins/community/repos/BaconMusic/src/SampleDelay.cpp
|
guillaume-plantevin/VeeSeeVSTRack
|
76fafc8e721613669d6f5ae82a0f58ce923a91e1
|
[
"Zlib",
"BSD-3-Clause"
] | 233
|
2018-07-02T16:49:36.000Z
|
2022-02-27T21:45:39.000Z
|
plugins/community/repos/BaconMusic/src/SampleDelay.cpp
|
guillaume-plantevin/VeeSeeVSTRack
|
76fafc8e721613669d6f5ae82a0f58ce923a91e1
|
[
"Zlib",
"BSD-3-Clause"
] | 24
|
2018-07-09T11:32:15.000Z
|
2022-01-07T01:45:43.000Z
|
plugins/community/repos/BaconMusic/src/SampleDelay.cpp
|
guillaume-plantevin/VeeSeeVSTRack
|
76fafc8e721613669d6f5ae82a0f58ce923a91e1
|
[
"Zlib",
"BSD-3-Clause"
] | 24
|
2018-07-14T21:55:30.000Z
|
2021-05-04T04:20:34.000Z
|
#include "BaconPlugs.hpp"
#include "SampleDelay.hpp"
namespace rack_plugin_BaconMusic {
struct SampleDelayWidget : ModuleWidget {
typedef SampleDelay< Module > SD;
SampleDelayWidget( SD *module);
};
SampleDelayWidget::SampleDelayWidget( SD *module ) : ModuleWidget( module )
{
box.size = Vec( SCREW_WIDTH * 5, RACK_HEIGHT );
BaconBackground *bg = new BaconBackground( box.size, "SampDelay" );
addChild( bg->wrappedInFramebuffer());
int outy = 30;
int gap = 10;
int margin = 3;
// plug label is 29 x 49
Vec ppos = Vec( bg->cx( SizeTable<PJ301MPort>::X ), outy + 20 );
bg->addPlugLabel( ppos, BaconBackground::SIG_IN, "in" );
addInput( Port::create< PJ301MPort >( ppos, Port::INPUT,
module, SD::SIGNAL_IN ) );
outy += 49 + gap + margin;
bg->addRoundedBorder( Vec( bg->cx() - 14 * 1.5 - margin, outy - margin ),
Vec( 14 * 3 + 2 * margin , 14 + SizeTable<RoundBlackSnapKnob>::Y + 2 * margin + 22 + margin + 2 * margin) );
bg->addLabel( Vec( bg->cx(), outy ), "# samples", 11, NVG_ALIGN_CENTER | NVG_ALIGN_TOP );
outy += 14;
addParam( ParamWidget::create< RoundBlackSnapKnob >( Vec( bg->cx( SizeTable< RoundBlackSnapKnob >::X ), outy ),
module,
SD::DELAY_KNOB,
1, 99, 1 ) );
outy += SizeTable<RoundBlackSnapKnob>::Y + 2 * margin;
addChild( MultiDigitSevenSegmentLight<BlueLight, 2, 3>::create( Vec( bg->cx() - 14 * 1.5, outy ),
module,
SD::DELAY_VALUE_LIGHT ) );
outy += 22 + gap + margin;
ppos = Vec( bg->cx( SizeTable<PJ301MPort>::X ), outy + 20 );
bg->addPlugLabel( ppos, BaconBackground::SIG_OUT, "out" );
addOutput( Port::create< PJ301MPort >( ppos, Port::OUTPUT,
module, SD::SIGNAL_OUT ) );
}
} // namespace rack_plugin_BaconMusic
using namespace rack_plugin_BaconMusic;
RACK_PLUGIN_MODEL_INIT(BaconMusic, SampleDelay) {
Model *modelSampleDelay = Model::create<SampleDelayWidget::SD, SampleDelayWidget>("Bacon Music", "SampleDelay", "SampleDelay", DELAY_TAG );
return modelSampleDelay;
}
| 38.704918
| 143
| 0.565862
|
guillaume-plantevin
|
d66c414f4a81ebcad706510e5398609143c5fec0
| 355
|
cpp
|
C++
|
src/ai/context/RedLine.cpp
|
elikos/elikos_decisionmaking
|
d48379643e69ad5fa5dfb2fc79034ca259cf0012
|
[
"MIT"
] | 1
|
2019-02-24T08:29:06.000Z
|
2019-02-24T08:29:06.000Z
|
src/ai/context/RedLine.cpp
|
elikos/elikos_decisionmaking
|
d48379643e69ad5fa5dfb2fc79034ca259cf0012
|
[
"MIT"
] | null | null | null |
src/ai/context/RedLine.cpp
|
elikos/elikos_decisionmaking
|
d48379643e69ad5fa5dfb2fc79034ca259cf0012
|
[
"MIT"
] | 1
|
2019-02-12T23:06:13.000Z
|
2019-02-12T23:06:13.000Z
|
//
// Created by olivier on 01/07/16.
//
#include "TargetRobot.h"
#include "RedLine.h"
namespace ai
{
RedLine::RedLine(tf::Point& cornerA, tf::Point& cornerB)
: AbstractLine(cornerA, cornerB)
{
}
RedLine::~RedLine()
{
}
bool RedLine::isGoodLineIntersection(const TargetRobot& target)
{
// TODO: check target color
return false;
}
}
| 12.678571
| 63
| 0.667606
|
elikos
|
698fc27608fd90d3e1f3a9d36213e8ef85c75628
| 1,507
|
cpp
|
C++
|
app/UseSelectionDialog.cpp
|
Toysoft/ciderpress
|
640959dad551ba75a48bd3c49629579730ead351
|
[
"BSD-3-Clause"
] | 84
|
2015-01-01T00:27:18.000Z
|
2022-03-28T22:55:56.000Z
|
app/UseSelectionDialog.cpp
|
Toysoft/ciderpress
|
640959dad551ba75a48bd3c49629579730ead351
|
[
"BSD-3-Clause"
] | 49
|
2015-01-11T19:58:57.000Z
|
2022-01-08T00:27:12.000Z
|
app/UseSelectionDialog.cpp
|
Toysoft/ciderpress
|
640959dad551ba75a48bd3c49629579730ead351
|
[
"BSD-3-Clause"
] | 19
|
2015-06-06T15:23:18.000Z
|
2022-01-12T23:26:43.000Z
|
/*
* CiderPress
* Copyright (C) 2007 by faddenSoft, LLC. All Rights Reserved.
* See the file LICENSE for distribution terms.
*/
#include "stdafx.h"
#include "UseSelectionDialog.h"
BEGIN_MESSAGE_MAP(UseSelectionDialog, CDialog)
ON_WM_HELPINFO()
//ON_COMMAND(IDHELP, OnHelp)
END_MESSAGE_MAP()
BOOL UseSelectionDialog::OnInitDialog(void)
{
CString str;
CString selStr;
CWnd* pWnd;
CDialog::OnInitDialog();
/* grab the radio button with the selection count */
pWnd = GetDlgItem(IDC_USE_SELECTED);
ASSERT(pWnd != NULL);
/* set the string using a string table entry */
if (fSelectedCount == 1) {
CheckedLoadString(&str, fSelCountID);
pWnd->SetWindowText(str);
} else {
CheckedLoadString(&str, fSelCountsID);
selStr.Format((LPCWSTR) str, fSelectedCount);
pWnd->SetWindowText(selStr);
if (fSelectedCount == 0)
pWnd->EnableWindow(FALSE);
}
/* set the other strings */
CheckedLoadString(&str, fTitleID);
SetWindowText(str);
pWnd = GetDlgItem(IDC_USE_ALL);
ASSERT(pWnd != NULL);
CheckedLoadString(&str, fAllID);
pWnd->SetWindowText(str);
pWnd = GetDlgItem(IDOK);
ASSERT(pWnd != NULL);
CheckedLoadString(&str, fOkLabelID);
pWnd->SetWindowText(str);
return TRUE;
}
void UseSelectionDialog::DoDataExchange(CDataExchange* pDX)
{
DDX_Radio(pDX, IDC_USE_SELECTED, fFilesToAction);
}
| 24.704918
| 64
| 0.640345
|
Toysoft
|
6992ef5cb96dee2ed33ecffa86cf2fea2bbada98
| 1,054
|
cpp
|
C++
|
drake/util/closestExpmapmex.cpp
|
ericmanzi/double_pendulum_lqr
|
76bba3091295abb7d412c4a3156258918f280c96
|
[
"BSD-3-Clause"
] | 4
|
2018-04-16T09:54:52.000Z
|
2021-03-29T21:59:27.000Z
|
drake/util/closestExpmapmex.cpp
|
ericmanzi/double_pendulum_lqr
|
76bba3091295abb7d412c4a3156258918f280c96
|
[
"BSD-3-Clause"
] | null | null | null |
drake/util/closestExpmapmex.cpp
|
ericmanzi/double_pendulum_lqr
|
76bba3091295abb7d412c4a3156258918f280c96
|
[
"BSD-3-Clause"
] | 1
|
2017-08-24T20:32:03.000Z
|
2017-08-24T20:32:03.000Z
|
#include "mex.h"
#include "drakeMexUtil.h"
#include "drakeGradientUtil.h"
#include "drakeGeometryUtil.h"
using namespace std;
using namespace Eigen;
void mexFunction(int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[])
{
if (nrhs != 2) {
mexErrMsgIdAndTxt("Drake:closestExpmapmex:InvalidInputs","Usage is closestExpmap(expmap1,expmap2)");
}
if (mxGetM(prhs[0]) != 3 || mxGetN(prhs[0]) != 1) {
mexErrMsgIdAndTxt("Drake:closestExpmapmex:InvalidInputs","expmap1 should be a 3 x 1 vector");
}
Map<Vector3d> expmap1(mxGetPr(prhs[0]));
if (mxGetM(prhs[1]) != 3 || mxGetN(prhs[1]) != 1) {
mexErrMsgIdAndTxt("Drake:closestExpmapmex:InvalidInputs","expmap2 should be a 3 x 1 vector");
}
Map<Vector3d> expmap2(mxGetPr(prhs[1]));
int gradient_order;
if (nlhs>1) {
gradient_order = 1;
}
else {
gradient_order = 0;
}
GradientVar<double,3,1> ret = closestExpmap(expmap1, expmap2,gradient_order);
plhs[0] = eigenToMatlab(ret.value());
if (nlhs>1) {
plhs[1] = eigenToMatlab(ret.gradient().value());
}
}
| 30.114286
| 104
| 0.680266
|
ericmanzi
|
69936abdf09f2bb3af3d7e3ffd4be62b0809830e
| 1,283
|
cpp
|
C++
|
ReactionPlus/Exec/InputDevice.cpp
|
stricq/AmigaSynergy
|
fd81da853b3c5a50a2bb5c160c5f7320daaa7571
|
[
"MIT"
] | 1
|
2022-03-05T11:30:18.000Z
|
2022-03-05T11:30:18.000Z
|
ReactionPlus/Exec/InputDevice.cpp
|
stricq/AmigaSynergy
|
fd81da853b3c5a50a2bb5c160c5f7320daaa7571
|
[
"MIT"
] | null | null | null |
ReactionPlus/Exec/InputDevice.cpp
|
stricq/AmigaSynergy
|
fd81da853b3c5a50a2bb5c160c5f7320daaa7571
|
[
"MIT"
] | 1
|
2022-03-06T11:22:44.000Z
|
2022-03-06T11:22:44.000Z
|
#include "InputDevice.hpp"
#include <proto/exec.h>
namespace RAPlus {
namespace Exec {
InputDevice::InputDevice() {
stdRequest = new StandardIORequest();
inputBit = stdRequest->getSignal();
inputStat = IExec->OpenDevice("input.device",0,stdRequest->getIORequest(),0);
if (inputStat != 0) {
delete stdRequest;
throw InputDeviceException();
}
}
InputDevice::~InputDevice() {
if (inputStat == 0) IExec->CloseDevice(stdRequest->getIORequest());
delete stdRequest;
}
void InputDevice::addEvent(InputEvent &event) {
stdRequest->setCommand(IND_ADDEVENT);
stdRequest->setData(event.getInputEvent());
stdRequest->setLength(event.getLength());
IExec->DoIO(stdRequest->getIORequest());
}
void InputDevice::writeEvent(InputEvent &event) {
stdRequest->setCommand(IND_WRITEEVENT);
stdRequest->setData(event.getInputEvent());
stdRequest->setLength(event.getLength());
IExec->DoIO(stdRequest->getIORequest());
}
void InputDevice::addHandler(Interrupt &interrupt) {
stdRequest->setCommand(IND_ADDHANDLER);
stdRequest->setData(interrupt.getInterrupt());
IExec->DoIO(stdRequest->getIORequest());
}
}
}
| 18.328571
| 83
| 0.64926
|
stricq
|
6996320db8fe0598e39bb64e6787114c0b66766d
| 1,275
|
hpp
|
C++
|
vcl/math/interpolation/interpolation.hpp
|
PPonc/inf443-vcl
|
4d7bb0130c4bc44e089059464223eca318fdbd00
|
[
"MIT"
] | null | null | null |
vcl/math/interpolation/interpolation.hpp
|
PPonc/inf443-vcl
|
4d7bb0130c4bc44e089059464223eca318fdbd00
|
[
"MIT"
] | null | null | null |
vcl/math/interpolation/interpolation.hpp
|
PPonc/inf443-vcl
|
4d7bb0130c4bc44e089059464223eca318fdbd00
|
[
"MIT"
] | null | null | null |
#pragma once
#include "../../containers/containers.hpp"
namespace vcl
{
/** Interpolate value(x,y) using bilinear interpolation
* - value: grid_2D - coordinates assumed to be its indices
* - (x,y): coordinates assumed to be \in [0,value.dimension.x-1] X [0,value.dimension.y]
*/
template <typename T>
T interpolation_bilinear(grid_2D<T> const& value, float x, float y);
}
namespace vcl
{
template <typename T>
T interpolation_bilinear(grid_2D<T> const& value, float x, float y)
{
int const x0 = int(std::floor(x));
int const y0 = int(std::floor(y));
int const x1 = x0+1;
int const y1 = y0+1;
assert_vcl_no_msg(x0>=0 && x0<value.dimension.x);
assert_vcl_no_msg(x1>=0 && x1<value.dimension.x);
assert_vcl_no_msg(y0>=0 && y0<value.dimension.y);
assert_vcl_no_msg(y1>=0 && y1<value.dimension.y);
float const dx = x-x0;
float const dy = y-y0;
assert_vcl_no_msg(dx>=0 && dx<1);
assert_vcl_no_msg(dy>=0 && dy<1);
T const v =
(1-dx)*(1-dy)*value(x0,y0) +
(1-dx)*dy*value(x0,y1) +
dx*(1-dy)*value(x1,y0) +
dx*dy*value(x1,y1);
return v;
}
}
| 28.333333
| 93
| 0.561569
|
PPonc
|
6997e7c2e38f14160b33edd8880fd941a466dad3
| 2,799
|
cpp
|
C++
|
libraries/palindrome/palindrome.cpp
|
AndreTeixeira1998/Arduino
|
16918bada3cf9dfee0f6baa72ee1de87602b84ca
|
[
"MIT"
] | 1,253
|
2015-01-03T17:07:53.000Z
|
2022-03-22T11:46:42.000Z
|
libraries/palindrome/palindrome.cpp
|
AndreTeixeira1998/Arduino
|
16918bada3cf9dfee0f6baa72ee1de87602b84ca
|
[
"MIT"
] | 134
|
2015-01-21T20:33:13.000Z
|
2022-01-05T08:59:33.000Z
|
libraries/palindrome/palindrome.cpp
|
AndreTeixeira1998/Arduino
|
16918bada3cf9dfee0f6baa72ee1de87602b84ca
|
[
"MIT"
] | 3,705
|
2015-01-02T17:03:16.000Z
|
2022-03-31T13:20:30.000Z
|
//
// FILE: palindrome.cpp
// AUTHOR: Rob Tillaart
// VERSION: 0.1.1
// PURPOSE: Arduino library to do palindrome experiments.
// URL: https://github.com/RobTillaart/palindrome
//
// HISTORY:
// 0.1.0 2021-12-02 initial version
// 0.1.1 2021-12-03 add palindromeCount(), palindromePercentage()
#include "palindrome.h"
palindrome::palindrome()
{
}
bool palindrome::isPalindrome(const char * str)
{
if (str == NULL) return false;
int sl = strlen(str);
if (sl == 0) return false;
int j = 0;
int k = sl - 1;
bool palin = (str[j++] == str[k--]);
while (palin & ( j < k ))
{
palin = (str[j++] == str[k--]);
}
return palin;
}
int palindrome::findPalindrome(const char * str, int & position, int & length)
{
if (str == NULL) return 0;
int posOdd = 0, lengthOdd = 0;
int posEven = 0, lengthEven = 0;
findOddPalindrome(str, posOdd, lengthOdd);
findEvenPalindrome(str, posEven, lengthEven);
if (lengthEven > lengthOdd)
{
position = posEven;
length = lengthEven;
return length;
}
position = posOdd;
length = lengthOdd;
return length;
}
int palindrome::findEvenPalindrome(const char * str, int & position, int & length)
{
if (str == NULL) return 0;
int sl = strlen(str);
if (sl == 0) return -1;
int newpos = 0;
int newlen = 1;
for (int i = 0; i < sl; i++)
{
if (str[i] != str[i + 1]) continue;
int j = i - 1;
int k = i + 2;
while (0 <= j && k < sl)
{
if (str[j] != str[k]) break;
j--;
k++;
}
int pos = j + 1;
int len = k - j - 1;
if (len > newlen)
{
newlen = len;
newpos = pos;
}
}
position = newpos;
length = newlen;
return length;
}
int palindrome::findOddPalindrome(const char * str, int & position, int & length)
{
if (str == NULL) return 0;
int sl = strlen(str);
if (sl == 0) return -1;
int newpos = 0;
int newlen = 1;
for (int i = 1; i < sl; i++)
{
int j = i - 1;
int k = i + 1;
while (0 <= j && k < sl)
{
if (str[j] != str[k]) break;
j--;
k++;
}
int pos = j + 1;
int len = k - j - 1;
if (len > newlen)
{
newlen = len;
newpos = pos;
}
}
position = newpos;
length = newlen;
return length;
}
int palindrome::palindromeCount(const char * str)
{
if (str == NULL) return 0;
int sl = strlen(str);
if (sl == 0) return 0;
int j = 0;
int k = sl - 1;
int count = 0;
while (j <= k)
{
if (str[j++] == str[k--]) count++;
}
return count;
}
float palindrome::palindromePercentage(const char * str)
{
if (str == NULL) return 0;
int sl = strlen(str);
if (sl == 0) return 0;
if (sl % 2 == 1) sl++; // correction for odd length strings
return (200.0 * palindromeCount(str)) / sl;
}
// -- END OF FILE --
| 18.175325
| 82
| 0.548053
|
AndreTeixeira1998
|
699a62f6968b573dd616ee87b0562dfe71ffd169
| 413
|
cpp
|
C++
|
AIBattleground/Src/AISystemBase.cpp
|
CerberusDev/AIBattleground
|
78cb72aeb9f33ff630a01df26c3056b7b7027c69
|
[
"MIT"
] | null | null | null |
AIBattleground/Src/AISystemBase.cpp
|
CerberusDev/AIBattleground
|
78cb72aeb9f33ff630a01df26c3056b7b7027c69
|
[
"MIT"
] | null | null | null |
AIBattleground/Src/AISystemBase.cpp
|
CerberusDev/AIBattleground
|
78cb72aeb9f33ff630a01df26c3056b7b7027c69
|
[
"MIT"
] | null | null | null |
// ----------------------------------------------------------------------------
// ------------- AI Battleground, Copyright(C) Maciej Pryc, 2016 --------------
// ----------------------------------------------------------------------------
#include "AISystemBase.h"
AISystemBase::AISystemBase(class Blackboard* argBlackboard) :
Blackboard(argBlackboard)
{
}
AISystemBase::~AISystemBase()
{
}
| 24.294118
| 80
| 0.380145
|
CerberusDev
|
699bc77460deebc1e54bc9ee3786f9836cedec3b
| 1,959
|
cc
|
C++
|
src/abc154/e.cc
|
nryotaro/at_c
|
8d7d3aecb4e3c768aefdf0ceaeefb269ca9ab34c
|
[
"MIT"
] | null | null | null |
src/abc154/e.cc
|
nryotaro/at_c
|
8d7d3aecb4e3c768aefdf0ceaeefb269ca9ab34c
|
[
"MIT"
] | null | null | null |
src/abc154/e.cc
|
nryotaro/at_c
|
8d7d3aecb4e3c768aefdf0ceaeefb269ca9ab34c
|
[
"MIT"
] | null | null | null |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
ll dp[101][2][5];
ll solve(string s, ll k) {
int n = s.size();
ll c = s[0] - '0';
dp[1][1][0] = 1ll;
dp[1][1][1] = c - 1ll;
dp[1][0][1] = 1ll;
for(int i = 1; i < n; i++) {
c = s[i] - '0';
for(int j = 0; j <= k; j++) {
// dp[i+1][0][j]
if(c == 0) {
dp[i + 1][0][j] = dp[i][0][j];
} else { // c > 0
dp[i + 1][0][j] = j > 0ll ? dp[i][0][j - 1] : 0ll;
}
// dp[i+1][1][j]
if(c == 0) {
dp[i + 1][1][j] = dp[i][1][j];
if(j > 0)
dp[i + 1][1][j] += dp[i][1][j - 1] * 9ll;
else
dp[i + 1][1][1] += 9ll;
} else { // c > 0
// 1以上の値にする
dp[i + 1][1][j] = j == 0 ? 0ll : (dp[i][0][j - 1] * (c - 1ll));
// 0にする
dp[i + 1][1][j] += dp[i][0][j];
// 0にする
dp[i + 1][1][j] +=
dp[i][1][j] + (j == 0 ? 0ll : dp[i][1][j - 1] * 9ll);
}
}
}
// 8 0 は0
/*
for(int i = 0; i <= n; i++) {
for(int j = 0; j <= k; j++) {
cout << "dp[" << i << "][" << 0 << "][" << j << "] -> "
<< dp[i][0][j] << endl;
cout << "dp[" << i << "][" << 1 << "][" << j << "] -> "
<< dp[i][1][j] << endl;
}
}
*/
return dp[n][0][k] + dp[n][1][k];
}
#ifndef _debug
int main() {
string s;
cin >> s;
int k;
cin >> k;
cout << solve(s, k) << endl;
return 0;
}
#endif
/*
dp[0][0][0] -> 0
dp[0][1][0] -> 0
dp[0][0][1] -> 0
dp[0][1][1] -> 0
dp[1][0][0] -> 0
dp[1][1][0] -> 1
dp[1][0][1] -> 1
dp[1][1][1] -> 0
dp[2][0][0] -> 0
dp[2][1][0] -> 1
dp[2][0][1] -> 1
dp[2][1][1] -> 9
dp[3][0][0] -> 0
dp[3][1][0] -> 1
dp[3][0][1] -> 1
dp[3][1][1] -> 18
*/
| 23.60241
| 79
| 0.28586
|
nryotaro
|
69a07f728b17bc1b66924920a2d4d4642b548472
| 5,304
|
cpp
|
C++
|
nau/src/nau/render/materialSortRenderQueue.cpp
|
Khirion/nau
|
47a2ad8e0355a264cd507da5e7bba1bf7abbff95
|
[
"MIT"
] | 29
|
2015-09-16T22:28:30.000Z
|
2022-03-11T02:57:36.000Z
|
nau/src/nau/render/materialSortRenderQueue.cpp
|
Khirion/nau
|
47a2ad8e0355a264cd507da5e7bba1bf7abbff95
|
[
"MIT"
] | 1
|
2017-03-29T13:32:58.000Z
|
2017-03-31T13:56:03.000Z
|
nau/src/nau/render/materialSortRenderQueue.cpp
|
Khirion/nau
|
47a2ad8e0355a264cd507da5e7bba1bf7abbff95
|
[
"MIT"
] | 10
|
2015-10-15T14:20:15.000Z
|
2022-02-17T10:37:29.000Z
|
#include "nau/render/materialSortRenderQueue.h"
#include "nau.h"
#include "nau/render/iRenderable.h"
#include "nau/geometry/boundingBox.h"
#include "nau/debug/profile.h"
using namespace nau::render;
using namespace nau::scene;
using namespace nau::material;
using namespace nau::math;
using namespace nau;
typedef std::pair<std::shared_ptr<MaterialGroup>, mat4*> pair_MatGroup_Transform;
#pragma warning( disable : 4503)
MaterialSortRenderQueue::MaterialSortRenderQueue(void) {
}
MaterialSortRenderQueue::~MaterialSortRenderQueue(void) {
clearQueue();
}
void
MaterialSortRenderQueue::clearQueue (void) {
std::map<int, std::map<std::shared_ptr<Material>, std::vector<pair_MatGroup_Transform >* >* >::iterator mapIter;
mapIter = m_RenderQueue.begin();
for ( ; mapIter != m_RenderQueue.end(); mapIter++) {
std::map <std::shared_ptr<Material>, std::vector<pair_MatGroup_Transform >* > *aMap;
std::map <std::shared_ptr<Material>, std::vector<pair_MatGroup_Transform >* >::iterator mapIter2;
aMap = (*mapIter).second;
mapIter2 = aMap->begin();
for ( ; mapIter2 != aMap->end(); mapIter2++) {
//if ((*mapIter2).second != NULL)
delete (*mapIter2).second;
}
delete aMap;
}
m_RenderQueue.clear(); /***MARK***/ //Possible memory leak
}
void
MaterialSortRenderQueue::addToQueue (std::shared_ptr<SceneObject> &aObject,
std::map<std::string, MaterialID> &materialMap) {
PROFILE ("Queue add");
int order;
std::shared_ptr<Material> aMaterial;
std::shared_ptr<IRenderable> &aRenderable = aObject->getRenderable();
std::vector<std::shared_ptr<MaterialGroup>> vMaterialGroups = aRenderable->getMaterialGroups();
for (auto &aGroup: vMaterialGroups) {
std::shared_ptr<nau::geometry::IndexData> &indexData = aGroup->getIndexData();
{
PROFILE ("Get material");
aMaterial = materialMap[aGroup->getMaterialName()].m_MatPtr;
}
order = aMaterial->getState()->getPropi(IState::ORDER);
if ((order >= 0) && (aMaterial) && (true == aMaterial->isEnabled())) {
if (0 == m_RenderQueue.count (order)){
m_RenderQueue[order] = new std::map <std::shared_ptr<Material>, std::vector<pair_MatGroup_Transform >* >;
}
std::map<std::shared_ptr<Material>, std::vector<pair_MatGroup_Transform >* > *materialMap = m_RenderQueue[order];
if (0 == materialMap->count (aMaterial)) {
(*materialMap)[aMaterial] = new std::vector<pair_MatGroup_Transform >;
}
std::vector<pair_MatGroup_Transform > *matGroupVec = (*materialMap)[aMaterial];
matGroupVec->push_back (pair_MatGroup_Transform(aGroup, aObject->_getTransformPtr()));
}
}
// ADD BOUNDING BOXES TO QUEUE
#ifdef NAU_RENDER_FLAGS
if (NAU->getRenderFlag(Nau::BOUNDING_BOX_RENDER_FLAG)) {
Profile("Enqueue Bounding Boxes");
vMaterialGroups = nau::geometry::BoundingBox::getGeometry()->getMaterialGroups();
for (auto& aGroup: vMaterialGroups) {
std::shared_ptr<Material> &aMaterial = MATERIALLIBMANAGER->getMaterial(aGroup->getMaterialName());
mat4 *trans = &((nau::geometry::BoundingBox *)(aObject->getBoundingVolume()))->getTransform();
if (0 == m_RenderQueue.count (0)){
m_RenderQueue[0] = new std::map <std::shared_ptr<Material>, std::vector<pair_MatGroup_Transform >* >;
}
std::map<std::shared_ptr<Material>, std::vector<pair_MatGroup_Transform >* > *materialMap = m_RenderQueue[aMaterial->getState()->getPropi(IState::ORDER)];
if (0 == materialMap->count (aMaterial)) {
(*materialMap)[aMaterial] = new std::vector<pair_MatGroup_Transform >;
}
std::vector<pair_MatGroup_Transform > *matGroupVec = (*materialMap)[aMaterial];
nau::geometry::BoundingBox *bb = (nau::geometry::BoundingBox *)(aObject->getBoundingVolume());
matGroupVec->push_back( pair_MatGroup_Transform(aGroup, &(bb->getTransform())));
}
}
#endif
}
void
MaterialSortRenderQueue::processQueue (void) {
PROFILE ("Process queue");
IRenderer *renderer = RENDERER;
std::map <int, std::map<std::shared_ptr<Material>, std::vector<pair_MatGroup_Transform >* >* >::iterator renderQueueIter;
renderQueueIter = m_RenderQueue.begin();
for (; renderQueueIter != m_RenderQueue.end(); ++renderQueueIter) {
std::map<std::shared_ptr<Material>, std::vector<pair_MatGroup_Transform >* >::iterator materialMapIter;
materialMapIter = (*renderQueueIter).second->begin();
for (; materialMapIter != (*renderQueueIter).second->end(); materialMapIter++) {
const std::shared_ptr<Material> &aMat = (*materialMapIter).first;
{
PROFILE ("Material prepare");
RENDERER->setMaterial(aMat);
//aMat->prepare();
}
std::vector<pair_MatGroup_Transform >::iterator matGroupsIter;
matGroupsIter = (*materialMapIter).second->begin();
{
PROFILE ("Geometry rendering");
for (; matGroupsIter != (*materialMapIter).second->end(); ++matGroupsIter) {
bool b = (*matGroupsIter).second->isIdentity();
if (!b) {
renderer->pushMatrix(IRenderer::MODEL_MATRIX);
renderer->applyTransform(IRenderer::MODEL_MATRIX, *(*matGroupsIter).second);
aMat->setUniformValues();
aMat->setUniformBlockValues();
}
{
PROFILE("Draw");
renderer->drawGroup ((*matGroupsIter).first);
}
if (!b)
renderer->popMatrix(IRenderer::MODEL_MATRIX);
}
}
aMat->restore();
}
}
}
| 31.384615
| 158
| 0.697775
|
Khirion
|
69a195aec5b82d7c089d79f41e41520f1653bee4
| 430
|
cpp
|
C++
|
Classes/Retan_class/main.cpp
|
Bernardo1411/Programacao_Avancada
|
5005b60155648872ca9d4f374b3d9ea035aa33a3
|
[
"MIT"
] | null | null | null |
Classes/Retan_class/main.cpp
|
Bernardo1411/Programacao_Avancada
|
5005b60155648872ca9d4f374b3d9ea035aa33a3
|
[
"MIT"
] | null | null | null |
Classes/Retan_class/main.cpp
|
Bernardo1411/Programacao_Avancada
|
5005b60155648872ca9d4f374b3d9ea035aa33a3
|
[
"MIT"
] | null | null | null |
#include <iostream>
#include "ponto.h"
using namespace std;
int main()
{
ponto p1(2,3), p2(5,6);
cout << p1;
cout << p2;
cout << "distancia P1 e P2: " << p1.dist(p2) << endl;
cout << "area P1 e P2: " << p1.area(p2) << endl;
ponto p3 = p1;
cout << p3;
cout << "distancia P3 e P2: " << p3.dist(p2) << endl;
cout << "area P3 e P2: " << p3.area(p2) << endl;
cin.get();
return 0;
}
| 15.925926
| 57
| 0.5
|
Bernardo1411
|
69a390cc0c446131353ccbc58108b6fc8dd3316a
| 26,342
|
cpp
|
C++
|
Testbed/Framework/Main.cpp
|
louis-langholtz/Box2D
|
7c74792bf177cf36640d735de2bba0225bf7f852
|
[
"Zlib"
] | 32
|
2016-10-20T05:55:04.000Z
|
2021-11-25T16:34:41.000Z
|
Testbed/Framework/Main.cpp
|
louis-langholtz/Box2D
|
7c74792bf177cf36640d735de2bba0225bf7f852
|
[
"Zlib"
] | 50
|
2017-01-07T21:40:16.000Z
|
2018-01-31T10:04:05.000Z
|
Testbed/Framework/Main.cpp
|
louis-langholtz/Box2D
|
7c74792bf177cf36640d735de2bba0225bf7f852
|
[
"Zlib"
] | 7
|
2017-02-09T10:02:02.000Z
|
2020-07-23T22:49:04.000Z
|
/*
* Original work Copyright (c) 2006-2013 Erin Catto http://www.box2d.org
* Modified work Copyright (c) 2017 Louis Langholtz https://github.com/louis-langholtz/Box2D
*
* This software is provided 'as-is', without any express or implied
* warranty. In no event will the authors be held liable for any damages
* arising from the use of this software.
* Permission is granted to anyone to use this software for any purpose,
* including commercial applications, and to alter it and redistribute it
* freely, subject to the following restrictions:
* 1. The origin of this software must not be misrepresented; you must not
* claim that you wrote the original software. If you use this software
* in a product, an acknowledgment in the product documentation would be
* appreciated but is not required.
* 2. Altered source versions must be plainly marked as such, and must not be
* misrepresented as being the original software.
* 3. This notice may not be removed or altered from any source distribution.
*/
#include "imgui.h"
#include "RenderGL3.h"
#include "DebugDraw.hpp"
#include "Test.hpp"
#include "TestEntry.hpp"
#include <sstream>
#include <iostream>
#include <iomanip>
#include <memory>
#include <string>
#if defined(__APPLE__)
#include <OpenGL/gl3.h>
#else
#include <GL/glew.h>
#endif
#include <GLFW/glfw3.h>
#include <cstdio>
#if defined(_WIN32) || defined(_WIN64)
#include <direct.h>
#else
#include <cstdlib>
#include <cerrno>
#include <unistd.h>
#endif
#ifdef _MSC_VER
#define snprintf _snprintf
#endif
using namespace box2d;
//
struct UIState
{
bool showMenu;
int scroll;
int scrollarea1;
bool mouseOverMenu;
bool chooseTest;
};
class Selection
{
public:
using size_type = std::size_t;
Selection(size_type size, size_type selection = 0):
m_size(size),
m_selection(selection < size? selection: 0)
{
assert(size > 0);
assert(selection < size);
}
size_type Get() const
{
return m_selection;
}
void Set(size_type selection)
{
assert(selection < m_size);
if (selection < m_size)
{
m_selection = selection;
}
}
void Increment()
{
const auto next = m_selection + 1;
m_selection = (next < m_size)? next: 0;
}
void Decrement()
{
m_selection = (m_selection > 0)? m_selection - 1: m_size - 1;
}
private:
size_type m_selection = 0;
size_type m_size = 0;
};
class TestSuite
{
public:
using size_type = std::size_t;
TestSuite(Span<const TestEntry> testEntries, size_type index = 0):
m_testEntries(testEntries),
m_testIndex(index < testEntries.size()? index: 0)
{
assert(testEntries.size() > 0);
m_test = testEntries[m_testIndex].createFcn();
}
size_type GetTestCount() const
{
return m_testEntries.size();
}
Test* GetTest() const
{
return m_test.get();
}
size_type GetIndex() const
{
return m_testIndex;
}
const char* GetName(std::size_t index) const
{
return m_testEntries[index].name;
}
const char* GetName() const
{
return m_testEntries[m_testIndex].name;
}
void SetIndex(size_type index)
{
assert(index < GetTestCount());
m_testIndex = index;
RestartTest();
}
void RestartTest()
{
m_test = m_testEntries[m_testIndex].createFcn();
}
private:
Span<const TestEntry> m_testEntries;
size_type m_testIndex;
std::unique_ptr<Test> m_test;
};
//
namespace
{
TestSuite *g_testSuite = nullptr;
Selection *g_selection = nullptr;
Camera camera;
UIState ui;
Settings settings;
auto rightMouseDown = false;
auto leftMouseDown = false;
Length2D lastp;
Coord2D mouseScreen = Coord2D{0.0, 0.0};
Length2D mouseWorld = Length2D{0, 0};
const auto menuY = 10;
const auto menuWidth = 200;
auto menuX = 0;
auto menuHeight = 0;
}
static auto GetCwd()
{
// In C++17 this implementation should be replaced with fs::current_path()
auto retval = std::string();
#if defined(_WIN32) || defined(_WIN64)
const auto buffer = _getcwd(NULL, 0);
if (buffer)
{
retval += std::string(buffer);
std::free(buffer);
}
#else
char buffer[1024];
if (getcwd(buffer, sizeof(buffer)))
{
retval += buffer;
}
#endif
return retval;
}
static void CreateUI()
{
ui.showMenu = true;
ui.scroll = 0;
ui.scrollarea1 = 0;
ui.chooseTest = false;
ui.mouseOverMenu = false;
// Init UI
const char* fontPaths[] = {
// Path if Testbed running from MSVS or Xcode Build folder.
"../../Testbed/Data/DroidSans.ttf",
// This is the original path...
"../Data/DroidSans.ttf",
// Path if Testbed app running from Testbed folder
"Data/DroidSans.ttf",
// Possibly a relative path for windows...
"../../../../Data/DroidSans.ttf",
// Try the current working directory...
"./DroidSans.ttf",
};
const auto cwd = GetCwd();
if (cwd.empty())
{
std::perror("GetCwd");
}
for (auto&& fontPath: fontPaths)
{
fprintf(stderr, "Attempting to load font from \"%s/%s\", ", cwd.c_str(), fontPath);
if (RenderGLInitFont(fontPath))
{
fprintf(stderr, "succeeded.\n");
break;
}
fprintf(stderr, " failed.\n");
}
if (!RenderGLInit())
{
fprintf(stderr, "Could not init GUI renderer.\n");
assert(false);
return;
}
}
static void ResizeWindow(GLFWwindow*, int width, int height)
{
camera.m_width = width;
camera.m_height = height;
menuX = camera.m_width - menuWidth - 10;
menuHeight = camera.m_height - 20;
}
static Test::Key GlfwKeyToTestKey(int key)
{
switch (key)
{
case GLFW_KEY_SPACE: return Test::Key_Space;
case GLFW_KEY_COMMA: return Test::Key_Comma;
case GLFW_KEY_MINUS: return Test::Key_Minus;
case GLFW_KEY_PERIOD: return Test::Key_Period;
case GLFW_KEY_EQUAL: return Test::Key_Equal;
case GLFW_KEY_0: return Test::Key_0;
case GLFW_KEY_1: return Test::Key_1;
case GLFW_KEY_2: return Test::Key_2;
case GLFW_KEY_3: return Test::Key_3;
case GLFW_KEY_4: return Test::Key_4;
case GLFW_KEY_5: return Test::Key_5;
case GLFW_KEY_6: return Test::Key_6;
case GLFW_KEY_7: return Test::Key_7;
case GLFW_KEY_8: return Test::Key_8;
case GLFW_KEY_9: return Test::Key_9;
case GLFW_KEY_A: return Test::Key_A;
case GLFW_KEY_B: return Test::Key_B;
case GLFW_KEY_C: return Test::Key_C;
case GLFW_KEY_D: return Test::Key_D;
case GLFW_KEY_E: return Test::Key_E;
case GLFW_KEY_F: return Test::Key_F;
case GLFW_KEY_G: return Test::Key_G;
case GLFW_KEY_H: return Test::Key_H;
case GLFW_KEY_I: return Test::Key_I;
case GLFW_KEY_J: return Test::Key_J;
case GLFW_KEY_K: return Test::Key_K;
case GLFW_KEY_L: return Test::Key_L;
case GLFW_KEY_M: return Test::Key_M;
case GLFW_KEY_N: return Test::Key_N;
case GLFW_KEY_O: return Test::Key_O;
case GLFW_KEY_P: return Test::Key_P;
case GLFW_KEY_Q: return Test::Key_Q;
case GLFW_KEY_R: return Test::Key_R;
case GLFW_KEY_S: return Test::Key_S;
case GLFW_KEY_T: return Test::Key_T;
case GLFW_KEY_U: return Test::Key_U;
case GLFW_KEY_V: return Test::Key_V;
case GLFW_KEY_W: return Test::Key_W;
case GLFW_KEY_X: return Test::Key_X;
case GLFW_KEY_Y: return Test::Key_Y;
case GLFW_KEY_Z: return Test::Key_Z;
case GLFW_KEY_BACKSPACE: return Test::Key_Backspace;
case GLFW_KEY_KP_SUBTRACT: return Test::Key_Subtract;
case GLFW_KEY_KP_ADD: return Test::Key_Add;
}
return Test::Key_Unknown;
}
static void KeyCallback(GLFWwindow* window, int key, int scancode, int action, int mods)
{
NOT_USED(scancode);
if (action == GLFW_PRESS)
{
switch (key)
{
case GLFW_KEY_ESCAPE:
// Quit
glfwSetWindowShouldClose(window, GL_TRUE);
break;
case GLFW_KEY_LEFT:
// Pan left
if (mods == GLFW_MOD_CONTROL)
{
g_testSuite->GetTest()->ShiftOrigin(Length2D(2.0f * Meter, 0.0f * Meter));
}
else
{
camera.m_center.x -= 0.5f;
}
break;
case GLFW_KEY_RIGHT:
// Pan right
if (mods == GLFW_MOD_CONTROL)
{
g_testSuite->GetTest()->ShiftOrigin(Length2D(-2.0f * Meter, 0.0f * Meter));
}
else
{
camera.m_center.x += 0.5f;
}
break;
case GLFW_KEY_DOWN:
// Pan down
if (mods == GLFW_MOD_CONTROL)
{
g_testSuite->GetTest()->ShiftOrigin(Length2D(0.0f * Meter, 2.0f * Meter));
}
else
{
camera.m_center.y -= 0.5f;
}
break;
case GLFW_KEY_UP:
// Pan up
if (mods == GLFW_MOD_CONTROL)
{
g_testSuite->GetTest()->ShiftOrigin(Length2D(0.0f * Meter, -2.0f * Meter));
}
else
{
camera.m_center.y += 0.5f;
}
break;
case GLFW_KEY_HOME:
// Reset view
camera.m_zoom = 1.0f;
camera.m_center = Coord2D{0.0f, 20.0f};
break;
case GLFW_KEY_Z:
// Zoom out
camera.m_zoom = Min(1.1f * camera.m_zoom, 20.0f);
break;
case GLFW_KEY_X:
// Zoom in
camera.m_zoom = Max(0.9f * camera.m_zoom, 0.02f);
break;
case GLFW_KEY_R:
// Reset test
g_testSuite->RestartTest();
break;
case GLFW_KEY_SPACE:
// Launch a bomb.
if (g_testSuite->GetTest())
{
g_testSuite->GetTest()->LaunchBomb();
}
break;
case GLFW_KEY_P:
// Pause
settings.pause = !settings.pause;
break;
case GLFW_KEY_LEFT_BRACKET:
// Switch to previous test
g_selection->Decrement();
break;
case GLFW_KEY_RIGHT_BRACKET:
// Switch to next test
g_selection->Increment();
break;
case GLFW_KEY_TAB:
ui.showMenu = !ui.showMenu;
default:
if (g_testSuite->GetTest())
{
g_testSuite->GetTest()->KeyboardDown(GlfwKeyToTestKey(key));
}
}
}
else if (action == GLFW_RELEASE)
{
g_testSuite->GetTest()->KeyboardUp(GlfwKeyToTestKey(key));
}
// else GLFW_REPEAT
}
static void MouseButton(GLFWwindow*, const int button, const int action, const int mods)
{
const auto forMenu = (mouseScreen.x >= menuX);
switch (button)
{
case GLFW_MOUSE_BUTTON_LEFT:
{
switch (action)
{
case GLFW_PRESS:
leftMouseDown = true;
if (!forMenu)
{
if (mods == GLFW_MOD_SHIFT)
{
g_testSuite->GetTest()->ShiftMouseDown(mouseWorld);
}
else
{
g_testSuite->GetTest()->MouseDown(mouseWorld);
}
}
break;
case GLFW_RELEASE:
leftMouseDown = false;
if (!forMenu)
{
g_testSuite->GetTest()->MouseUp(mouseWorld);
}
break;
default:
break;
}
break;
}
case GLFW_MOUSE_BUTTON_RIGHT:
{
switch (action)
{
case GLFW_PRESS:
lastp = mouseWorld;
rightMouseDown = true;
break;
case GLFW_RELEASE:
rightMouseDown = false;
break;
default:
break;
}
}
default:
break;
}
}
static void MouseMotion(GLFWwindow*, double xd, double yd)
{
// Expects that xd and yd are the new mouse position coordinates,
// in screen coordinates, relative to the upper-left corner of the
// client area of the window.
mouseScreen = Coord2D{static_cast<float>(xd), static_cast<float>(yd)};
mouseWorld = ConvertScreenToWorld(camera, mouseScreen);
g_testSuite->GetTest()->MouseMove(mouseWorld);
if (rightMouseDown)
{
const auto movement = mouseWorld - lastp;
camera.m_center.x -= static_cast<float>(Real{movement.x / Meter});
camera.m_center.y -= static_cast<float>(Real{movement.y / Meter});
lastp = ConvertScreenToWorld(camera, mouseScreen);
}
}
static void ScrollCallback(GLFWwindow*, double, double dy)
{
if (ui.mouseOverMenu)
{
ui.scroll = -int(dy);
}
else
{
if (dy > 0)
{
camera.m_zoom /= 1.1f;
}
else
{
camera.m_zoom *= 1.1f;
}
}
}
static void Simulate(Drawer& drawer)
{
glEnable(GL_DEPTH_TEST);
settings.dt = (settings.hz != 0)? 1 / settings.hz : 0;
if (settings.pause)
{
if (!settings.singleStep)
{
settings.dt = 0.0f;
}
}
g_testSuite->GetTest()->DrawTitle(drawer, g_testSuite->GetName());
g_testSuite->GetTest()->Step(settings, drawer);
glDisable(GL_DEPTH_TEST);
if (settings.pause)
{
if (settings.singleStep)
{
settings.singleStep = false;
}
}
if (g_testSuite->GetIndex() != g_selection->Get())
{
g_testSuite->SetIndex(g_selection->Get());
camera.m_zoom = 1.0f;
camera.m_center = Coord2D{0.0f, 20.0f};
}
}
static bool UserInterface(int mousex, int mousey, unsigned char mousebutton, int mscroll)
{
auto shouldQuit = false;
imguiBeginFrame(mousex, mousey, mousebutton, mscroll);
ui.mouseOverMenu = false;
if (ui.showMenu)
{
const auto over = imguiBeginScrollArea("Testbed Controls",
menuX, menuY, menuWidth, menuHeight,
&ui.scrollarea1);
if (over) ui.mouseOverMenu = true;
imguiLabel("Test:");
if (imguiButton(g_testSuite->GetName(), true))
{
ui.chooseTest = !ui.chooseTest;
}
imguiSeparatorLine();
const auto defaultLinearSlop = StripUnit(DefaultLinearSlop);
imguiSlider("Reg Vel Iters", &settings.regVelocityIterations, 0, 100, 1, true);
imguiSlider("Reg Pos Iters", &settings.regPositionIterations, 0, 100, 1, true);
imguiSlider("TOI Vel Iters", &settings.toiVelocityIterations, 0, 100, 1, true);
imguiSlider("TOI Pos Iters", &settings.toiPositionIterations, 0, 100, 1, true);
imguiSlider("Max Sub Steps", &settings.maxSubSteps, 0, 100, 1, true);
imguiSlider("Hertz", &settings.hz, -120.0f, 120.0f, 5.0f, true);
imguiSlider("Linear Slop", &settings.linearSlop,
static_cast<float>(defaultLinearSlop / 10),
static_cast<float>(defaultLinearSlop),
static_cast<float>(defaultLinearSlop / 100),
true);
imguiSlider("Angular Slop", &settings.angularSlop,
static_cast<float>(Pi * 2 / 1800.0),
static_cast<float>(Pi * 2 / 18.0), 0.001f,
true);
imguiSlider("Reg Min Sep", &settings.regMinSeparation,
-5 * static_cast<float>(defaultLinearSlop),
-0 * static_cast<float>(defaultLinearSlop),
static_cast<float>(defaultLinearSlop) / 20,
true);
imguiSlider("TOI Min Sep", &settings.toiMinSeparation,
-5 * static_cast<float>(defaultLinearSlop),
-0 * static_cast<float>(defaultLinearSlop),
static_cast<float>(defaultLinearSlop) / 20,
true);
imguiSlider("Max Translation", &settings.maxTranslation, 0.0f, 12.0f, 0.05f, true);
imguiSlider("Max Rotation", &settings.maxRotation, 0.0f, 360.0f, 1.0f, true);
imguiSlider("Max Lin Correct", &settings.maxLinearCorrection, 0.0f, 1.0f, 0.01f, true);
imguiSlider("Max Ang Correct", &settings.maxAngularCorrection, 0.0f, 90.0f, 1.0f, true);
imguiSlider("Reg Resol % Rate", &settings.regPosResRate, 0, 100, 1, true);
imguiSlider("TOI Resol % Rate", &settings.toiPosResRate, 0, 100, 1, true);
if (imguiCheck("Sleep", settings.enableSleep, true))
settings.enableSleep = !settings.enableSleep;
if (imguiCheck("Warm Starting", settings.enableWarmStarting, true))
settings.enableWarmStarting = !settings.enableWarmStarting;
if (imguiCheck("Time of Impact", settings.enableContinuous, true))
settings.enableContinuous = !settings.enableContinuous;
if (imguiCheck("Sub-Stepping", settings.enableSubStepping, true))
settings.enableSubStepping = !settings.enableSubStepping;
imguiSeparatorLine();
if (imguiCheck("Shapes", settings.drawShapes, true))
settings.drawShapes = !settings.drawShapes;
if (imguiCheck("Joints", settings.drawJoints, true))
settings.drawJoints = !settings.drawJoints;
if (imguiCheck("Skins", settings.drawSkins, true))
settings.drawSkins = !settings.drawSkins;
if (imguiCheck("AABBs", settings.drawAABBs, true))
settings.drawAABBs = !settings.drawAABBs;
if (imguiCheck("Contact Points", settings.drawContactPoints, true))
settings.drawContactPoints = !settings.drawContactPoints;
if (imguiCheck("Contact Normals", settings.drawContactNormals, true))
settings.drawContactNormals = !settings.drawContactNormals;
if (imguiCheck("Contact Impulses", settings.drawContactImpulse, true))
settings.drawContactImpulse = !settings.drawContactImpulse;
if (imguiCheck("Friction Impulses", settings.drawFrictionImpulse, true))
settings.drawFrictionImpulse = !settings.drawFrictionImpulse;
if (imguiCheck("Center of Masses", settings.drawCOMs, true))
settings.drawCOMs = !settings.drawCOMs;
if (imguiCheck("Statistics", settings.drawStats, true))
settings.drawStats = !settings.drawStats;
if (imguiCheck("Pause", settings.pause, true))
settings.pause = !settings.pause;
if (imguiButton("Single Step", true))
settings.singleStep = !settings.singleStep;
if (imguiButton("Restart", true))
g_testSuite->RestartTest();
if (imguiButton("Quit", true))
shouldQuit = true;
imguiEndScrollArea();
}
const auto testMenuWidth = 200;
if (ui.chooseTest)
{
static int testScroll = 0;
const auto over = imguiBeginScrollArea("Choose Sample",
camera.m_width - menuWidth - testMenuWidth - 20, 10,
testMenuWidth, camera.m_height - 20,
&testScroll);
if (over) ui.mouseOverMenu = true;
const auto testCount = g_testSuite->GetTestCount();
for (auto i = decltype(testCount){0}; i < testCount; ++i)
{
if (imguiItem(g_testSuite->GetName(i), true))
{
g_selection->Set(i);
g_testSuite->SetIndex(i);
ui.chooseTest = false;
}
}
imguiEndScrollArea();
}
imguiEndFrame();
return !shouldQuit;
}
static void GlfwErrorCallback(int code, const char* str)
{
fprintf(stderr, "GLFW error (%d): %s\n", code, str);
}
static void ShowFrameInfo(double frameTime, double fps)
{
std::stringstream stream;
const auto viewport = ConvertScreenToWorld(camera);
stream << "Zoom=" << camera.m_zoom;
stream << " Center=";
stream << "{" << camera.m_center.x << "," << camera.m_center.y << "}";
stream << " Viewport=";
stream << "{";
stream << viewport.GetLowerBound().x << "..." << viewport.GetUpperBound().x;
stream << ", ";
stream << viewport.GetLowerBound().y << "..." << viewport.GetUpperBound().y;
stream << "}";
stream << std::setprecision(1);
stream << std::fixed;
stream << " Refresh=" << (1000.0 * frameTime) << "ms";
stream << std::setprecision(0);
stream << " FPS=" << fps;
AddGfxCmdText(5, 5, TEXT_ALIGN_LEFT, stream.str().c_str(), static_cast<unsigned int>(WHITE));
}
int main()
{
TestSuite testSuite(GetTestEntries());
Selection selection(testSuite.GetTestCount());
g_testSuite = &testSuite;
g_selection = &selection;
#if defined(_WIN32)
// Enable memory-leak reports
_CrtSetDbgFlag(_CRTDBG_LEAK_CHECK_DF | _CrtSetDbgFlag(_CRTDBG_REPORT_FLAG));
#endif
camera.m_width = 1280; // 1152;
camera.m_height = 960; // 864;
menuX = camera.m_width - menuWidth - 10;
menuHeight = camera.m_height - 20;
if (glfwSetErrorCallback(GlfwErrorCallback))
{
fprintf(stderr, "Warning: overriding previously installed GLFW error callback function.\n");
}
if (glfwInit() == 0)
{
fprintf(stderr, "Failed to initialize GLFW\n");
return -1;
}
const auto buildVersion = GetVersion();
const auto buildDetails = GetBuildDetails();
char title[64];
sprintf(title, "Box2D Testbed Version %d.%d.%d",
buildVersion.major, buildVersion.minor, buildVersion.revision);
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
const auto mainWindow = glfwCreateWindow(camera.m_width, camera.m_height, title,
nullptr, nullptr);
if (mainWindow == nullptr)
{
fprintf(stderr, "Failed to open GLFW main window.\n");
glfwTerminate();
return -1;
}
glfwMakeContextCurrent(mainWindow);
printf("Box2D %d.%d.%d (%s), OpenGL %s, GLSL %s\n",
buildVersion.major, buildVersion.minor, buildVersion.revision, buildDetails.c_str(),
glGetString(GL_VERSION), glGetString(GL_SHADING_LANGUAGE_VERSION));
glfwSetScrollCallback(mainWindow, ScrollCallback);
glfwSetWindowSizeCallback(mainWindow, ResizeWindow);
glfwSetKeyCallback(mainWindow, KeyCallback);
glfwSetMouseButtonCallback(mainWindow, MouseButton);
glfwSetCursorPosCallback(mainWindow, MouseMotion);
glfwSetScrollCallback(mainWindow, ScrollCallback);
#if !defined(__APPLE__)
//glewExperimental = GL_TRUE;
GLenum err = glewInit();
if (GLEW_OK != err)
{
fprintf(stderr, "Error: %s\n", glewGetErrorString(err));
exit(EXIT_FAILURE);
}
#endif
CreateUI();
// Control the frame rate. One draw per monitor refresh.
glfwSwapInterval(1);
auto time1 = glfwGetTime();
auto frameTime = 0.0;
auto fps = 0.0;
glClearColor(0.3f, 0.3f, 0.3f, 1.f);
{
DebugDraw drawer(camera);
while (!glfwWindowShouldClose(mainWindow))
{
glViewport(0, 0, camera.m_width, camera.m_height);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
const auto mscroll = ui.scroll;
ui.scroll = 0;
const auto mousex = int(mouseScreen.x);
const auto mousey = camera.m_height - int(mouseScreen.y);
unsigned char mousebutton = (leftMouseDown)? IMGUI_MBUT_LEFT: 0;
if (!UserInterface(mousex, mousey, mousebutton, mscroll))
glfwSetWindowShouldClose(mainWindow, GL_TRUE);
Simulate(drawer);
// Measure speed
const auto time2 = glfwGetTime();
const auto timeElapsed = time2 - time1;
const auto alpha = 0.9;
frameTime = alpha * frameTime + (1.0 - alpha) * timeElapsed;
fps = 0.99 * fps + (1.0 - 0.99) / timeElapsed;
time1 = time2;
ShowFrameInfo(frameTime, fps);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glDisable(GL_DEPTH_TEST);
RenderGLFlush(camera.m_width, camera.m_height);
glfwSwapBuffers(mainWindow);
glfwPollEvents();
}
}
RenderGLDestroy();
glfwTerminate();
return 0;
}
| 31.100354
| 101
| 0.558879
|
louis-langholtz
|
69a86172d7133a45894a91551431a5804b3d5263
| 17,851
|
cpp
|
C++
|
src/predefined/FaceDetector.cpp
|
djinn-technologies/depthai-unity
|
4064a0f3ea374e30203ee9a0a2c42f1e59791519
|
[
"MIT"
] | null | null | null |
src/predefined/FaceDetector.cpp
|
djinn-technologies/depthai-unity
|
4064a0f3ea374e30203ee9a0a2c42f1e59791519
|
[
"MIT"
] | null | null | null |
src/predefined/FaceDetector.cpp
|
djinn-technologies/depthai-unity
|
4064a0f3ea374e30203ee9a0a2c42f1e59791519
|
[
"MIT"
] | null | null | null |
/**
* This file contains face detector pipeline and interface for Unity scene called "Face Detector"
* Main goal is to perform face detection + depth
*/
#pragma GCC diagnostic ignored "-Wreturn-type-c-linkage"
#pragma GCC diagnostic ignored "-Wdouble-promotion"
#if _MSC_VER // this is defined when compiling with Visual Studio
#define EXPORT_API __declspec(dllexport) // Visual Studio needs annotating exported functions with this
#else
#define EXPORT_API // XCode does not need annotating exported functions, so define is empty
#endif
// ------------------------------------------------------------------------
// Plugin itself
#include <iostream>
#include <cstdio>
#include <random>
#include "../utility.hpp"
// Common necessary includes for development using depthai library
#include "depthai/depthai.hpp"
#include "depthai/device/Device.hpp"
#include "depthai-unity/predefined/FaceDetector.hpp"
#include "spdlog/sinks/stdout_color_sinks.h"
#include "spdlog/spdlog.h"
#include "nlohmann/json.hpp"
/**
* Pipeline creation based on streams template
*
* @param config pipeline configuration
* @returns pipeline
*/
dai::Pipeline createFaceDetectorPipeline(PipelineConfig *config)
{
dai::Pipeline pipeline;
std::shared_ptr<dai::node::XLinkOut> xlinkOut;
auto colorCam = pipeline.create<dai::node::ColorCamera>();
// Color camera preview
if (config->previewSizeWidth > 0 && config->previewSizeHeight > 0)
{
xlinkOut = pipeline.create<dai::node::XLinkOut>();
xlinkOut->setStreamName("preview");
colorCam->setPreviewSize(config->previewSizeWidth, config->previewSizeHeight);
colorCam->preview.link(xlinkOut->input);
}
// Color camera properties
colorCam->setResolution(dai::ColorCameraProperties::SensorResolution::THE_1080_P);
if (config->colorCameraResolution == 1) colorCam->setResolution(dai::ColorCameraProperties::SensorResolution::THE_4_K);
if (config->colorCameraResolution == 2) colorCam->setResolution(dai::ColorCameraProperties::SensorResolution::THE_12_MP);
if (config->colorCameraResolution == 3) colorCam->setResolution(dai::ColorCameraProperties::SensorResolution::THE_13_MP);
colorCam->setInterleaved(config->colorCameraInterleaved);
colorCam->setColorOrder(dai::ColorCameraProperties::ColorOrder::BGR);
if (config->colorCameraColorOrder == 1) colorCam->setColorOrder(dai::ColorCameraProperties::ColorOrder::RGB);
colorCam->setFps(config->colorCameraFPS);
// neural network
auto nn1 = pipeline.create<dai::node::NeuralNetwork>();
nn1->setBlobPath(config->nnPath1);
colorCam->preview.link(nn1->input);
// output of neural network
auto nnOut = pipeline.create<dai::node::XLinkOut>();
nnOut->setStreamName("detections");
nn1->out.link(nnOut->input);
// Depth
if (config->confidenceThreshold > 0)
{
auto left = pipeline.create<dai::node::MonoCamera>();
auto right = pipeline.create<dai::node::MonoCamera>();
auto stereo = pipeline.create<dai::node::StereoDepth>();
// For RGB-Depth align
if (config->ispScaleF1 > 0 && config->ispScaleF2 > 0) colorCam->setIspScale(config->ispScaleF1, config->ispScaleF2);
if (config->manualFocus > 0) colorCam->initialControl.setManualFocus(config->manualFocus);
// Mono camera properties
left->setResolution(dai::MonoCameraProperties::SensorResolution::THE_400_P);
if (config->monoLCameraResolution == 1) left->setResolution(dai::MonoCameraProperties::SensorResolution::THE_720_P);
if (config->monoLCameraResolution == 2) left->setResolution(dai::MonoCameraProperties::SensorResolution::THE_800_P);
if (config->monoLCameraResolution == 3) left->setResolution(dai::MonoCameraProperties::SensorResolution::THE_480_P);
left->setBoardSocket(dai::CameraBoardSocket::LEFT);
right->setResolution(dai::MonoCameraProperties::SensorResolution::THE_400_P);
if (config->monoRCameraResolution == 1) right->setResolution(dai::MonoCameraProperties::SensorResolution::THE_720_P);
if (config->monoRCameraResolution == 2) right->setResolution(dai::MonoCameraProperties::SensorResolution::THE_800_P);
if (config->monoRCameraResolution == 3) right->setResolution(dai::MonoCameraProperties::SensorResolution::THE_480_P);
right->setBoardSocket(dai::CameraBoardSocket::RIGHT);
// Stereo properties
stereo->setConfidenceThreshold(config->confidenceThreshold);
// LR-check is required for depth alignment
stereo->setLeftRightCheck(config->leftRightCheck);
if (config->depthAlign > 0) stereo->setDepthAlign(dai::CameraBoardSocket::RGB);
stereo->setSubpixel(config->subpixel);
stereo->initialConfig.setMedianFilter(dai::MedianFilter::MEDIAN_OFF);
if (config->medianFilter == 1) stereo->initialConfig.setMedianFilter(dai::MedianFilter::KERNEL_3x3);
if (config->medianFilter == 2) stereo->initialConfig.setMedianFilter(dai::MedianFilter::KERNEL_5x5);
if (config->medianFilter == 3) stereo->initialConfig.setMedianFilter(dai::MedianFilter::KERNEL_7x7);
// Linking
left->out.link(stereo->left);
right->out.link(stereo->right);
auto xoutDepth = pipeline.create<dai::node::XLinkOut>();
xoutDepth->setStreamName("depth");
stereo->depth.link(xoutDepth->input);
}
// SYSTEM INFORMATION
if (config->rate > 0.0f)
{
// Define source and output
auto sysLog = pipeline.create<dai::node::SystemLogger>();
auto xout = pipeline.create<dai::node::XLinkOut>();
xout->setStreamName("sysinfo");
// Properties
sysLog->setRate(config->rate); // 1 hz updates
// Linking
sysLog->out.link(xout->input);
}
// IMU
if (config->freq > 0)
{
auto imu = pipeline.create<dai::node::IMU>();
auto xlinkOutImu = pipeline.create<dai::node::XLinkOut>();
xlinkOutImu->setStreamName("imu");
// enable ROTATION_VECTOR at 400 hz rate
imu->enableIMUSensor(dai::IMUSensor::ROTATION_VECTOR, config->freq);
// above this threshold packets will be sent in batch of X, if the host is not blocked and USB bandwidth is available
imu->setBatchReportThreshold(config->batchReportThreshold);
// maximum number of IMU packets in a batch, if it's reached device will block sending until host can receive it
// if lower or equal to batchReportThreshold then the sending is always blocking on device
// useful to reduce device's CPU load and number of lost packets, if CPU load is high on device side due to multiple nodes
imu->setMaxBatchReports(config->maxBatchReports);
// Link plugins IMU -> XLINK
imu->out.link(xlinkOutImu->input);
}
return pipeline;
}
extern "C"
{
/**
* Pipeline creation based on streams template
*
* @param config pipeline configuration
* @returns pipeline
*/
EXPORT_API bool InitFaceDetector(PipelineConfig *config)
{
dai::Pipeline pipeline = createFaceDetectorPipeline(config);
// If deviceId is empty .. just pick first available device
bool res = false;
if (strcmp(config->deviceId,"NONE")==0 || strcmp(config->deviceId,"")==0) res = DAIStartPipeline(pipeline,config->deviceNum,NULL);
else res = DAIStartPipeline(pipeline,config->deviceNum,config->deviceId);
return res;
}
/**
* Pipeline results
*
* @param frameInfo camera images pointers
* @param getPreview True if color preview image is requested, False otherwise. Requires previewSize in pipeline creation.
* @param useDepth True if depth information is requested, False otherwise. Requires confidenceThreshold in pipeline creation.
* @param retrieveInformation True if system information is requested, False otherwise. Requires rate in pipeline creation.
* @param useIMU True if IMU information is requested, False otherwise. Requires freq in pipeline creation.
* @param deviceNum Device selection on unity dropdown
* @returns Json with results or information about device availability.
*/
/**
* Example of json returned
* { "faces": [ {"label":0,"score":0.0,"xmin":0.0,"ymin":0.0,"xmax":0.0,"ymax":0.0,"xcenter":0.0,"ycenter":0.0},{"label":1,"score":1.0,"xmin":0.0,"ymin":0.0,"xmax":0.0,* "ymax":0.0,"xcenter":0.0,"ycenter":0.0}],"best":{"label":1,"score":1.0,"xmin":0.0,"ymin":0.0,"xmax":0.0,"ymax":0.0,"xcenter":0.0,"ycenter":0.0},"fps":0.0}
*/
EXPORT_API const char* FaceDetectorResults(FrameInfo *frameInfo, bool getPreview, bool drawBestFaceInPreview, bool drawAllFacesInPreview, float faceScoreThreshold, bool useDepth, bool retrieveInformation, bool useIMU, int deviceNum)
{
using namespace std;
using namespace std::chrono;
// Get device deviceNum
std::shared_ptr<dai::Device> device = GetDevice(deviceNum);
// Device no available
if (device == NULL)
{
char* ret = (char*)::malloc(strlen("{\"error\":\"NO_DEVICE\"}"));
::memcpy(ret, "{\"error\":\"NO_DEVICE\"}",strlen("{\"error\":\"NO_DEVICE\"}"));
ret[strlen("{\"error\":\"NO_DEVICE\"}")] = 0;
return ret;
}
// If device deviceNum is running pipeline
if (IsDeviceRunning(deviceNum))
{
// preview image
cv::Mat frame;
std::shared_ptr<dai::ImgFrame> imgFrame;
// other images
cv::Mat depthFrame, depthFrameOrig, dispFrameOrig, dispFrame, monoRFrameOrig, monoRFrame, monoLFrameOrig, monoLFrame;
// face info
nlohmann::json faceDetectorJson = {};
std::shared_ptr<dai::DataOutputQueue> preview;
std::shared_ptr<dai::DataOutputQueue> depthQueue;
// face detector results
auto detections = device->getOutputQueue("detections",1,false);
// if preview image is requested. True in this case.
if (getPreview) preview = device->getOutputQueue("preview",1,false);
// if depth images are requested. All images.
if (useDepth) depthQueue = device->getOutputQueue("depth", 1, false);
int countd;
if (getPreview)
{
auto imgFrames = preview->tryGetAll<dai::ImgFrame>();
countd = imgFrames.size();
if (countd > 0) {
auto imgFrame = imgFrames[countd-1];
if(imgFrame){
frame = toMat(imgFrame->getData(), imgFrame->getWidth(), imgFrame->getHeight(), 3, 1);
}
}
}
vector<std::shared_ptr<dai::ImgFrame>> imgDepthFrames,imgDispFrames,imgMonoRFrames,imgMonoLFrames;
std::shared_ptr<dai::ImgFrame> imgDepthFrame,imgDispFrame,imgMonoRFrame,imgMonoLFrame;
int count;
// In this case we allocate before Texture2D (ARGB32) and memcpy pointer data
if (useDepth)
{
// Depth
imgDepthFrames = depthQueue->tryGetAll<dai::ImgFrame>();
count = imgDepthFrames.size();
if (count > 0)
{
imgDepthFrame = imgDepthFrames[count-1];
depthFrameOrig = imgDepthFrame->getFrame();
cv::normalize(depthFrameOrig, depthFrame, 255, 0, cv::NORM_INF, CV_8UC1);
cv::equalizeHist(depthFrame, depthFrame);
cv::cvtColor(depthFrame, depthFrame, cv::COLOR_GRAY2BGR);
}
}
// Face detection results
struct Detection {
unsigned int label;
float score;
float x_min;
float y_min;
float x_max;
float y_max;
};
vector<Detection> dets;
auto det = detections->get<dai::NNData>();
std::vector<float> detData = det->getFirstLayerFp16();
float maxScore = 0.0;
int maxPos = 0;
nlohmann::json facesArr = {};
nlohmann::json bestFace = {};
if(detData.size() > 0){
int i = 0;
while (detData[i*7] != -1.0f && i*7 < (int)detData.size()) {
Detection d;
d.label = detData[i*7 + 1];
d.score = detData[i*7 + 2];
if (d.score > maxScore)
{
maxScore = d.score;
maxPos = i;
}
d.x_min = detData[i*7 + 3];
d.y_min = detData[i*7 + 4];
d.x_max = detData[i*7 + 5];
d.y_max = detData[i*7 + 6];
i++;
dets.push_back(d);
nlohmann::json face;
face["label"] = d.label;
face["score"] = d.score;
face["xmin"] = d.x_min;
face["ymin"] = d.y_min;
face["xmax"] = d.x_max;
face["ymax"] = d.y_max;
int x1 = d.x_min * frame.cols;
int y1 = d.y_min * frame.rows;
int x2 = d.x_max * frame.cols;
int y2 = d.y_max * frame.rows;
int mx = x1 + ((x2 - x1) / 2);
int my = y1 + ((y2 - y1) / 2);
face["xcenter"] = mx;
face["ycenter"] = my;
if (faceScoreThreshold <= d.score)
{
if (getPreview && countd > 0 && drawAllFacesInPreview) cv::rectangle(frame, cv::Rect(cv::Point(x1, y1), cv::Point(x2, y2)), cv::Scalar(255,255,255));
if (useDepth && count>0)
{
auto spatialData = computeDepth(mx,my,frame.rows,depthFrameOrig);
for(auto depthData : spatialData) {
auto roi = depthData.config.roi;
roi = roi.denormalize(depthFrame.cols, depthFrame.rows);
face["X"] = (int)depthData.spatialCoordinates.x;
face["Y"] = (int)depthData.spatialCoordinates.y;
face["Z"] = (int)depthData.spatialCoordinates.z;
}
}
facesArr.push_back(face);
}
}
}
int i = 0;
for(const auto& d : dets){
if (i == maxPos)
{
int x1 = d.x_min * frame.cols;
int y1 = d.y_min * frame.rows;
int x2 = d.x_max * frame.cols;
int y2 = d.y_max * frame.rows;
int mx = x1 + ((x2 - x1) / 2);
int my = y1 + ((y2 - y1) / 2);
// m_mx = mx;
// m_my = my;
if (faceScoreThreshold <= d.score)
{
bestFace["label"] = d.label;
bestFace["score"] = d.score;
bestFace["xmin"] = d.x_min;
bestFace["ymin"] = d.y_min;
bestFace["xmax"] = d.x_max;
bestFace["ymax"] = d.y_max;
bestFace["xcenter"] = mx;
bestFace["ycenter"] = my;
if (useDepth && count>0)
{
auto spatialData = computeDepth(mx,my,frame.rows,depthFrameOrig);
for(auto depthData : spatialData) {
auto roi = depthData.config.roi;
roi = roi.denormalize(depthFrame.cols, depthFrame.rows);
bestFace["X"] = (int)depthData.spatialCoordinates.x;
bestFace["Y"] = (int)depthData.spatialCoordinates.y;
bestFace["Z"] = (int)depthData.spatialCoordinates.z;
}
}
if (getPreview && countd > 0 && drawBestFaceInPreview) cv::rectangle(frame, cv::Rect(cv::Point(x1, y1), cv::Point(x2, y2)), cv::Scalar(255,255,255));
}
}
i++;
}
if (getPreview && countd>0) toARGB(frame,frameInfo->colorPreviewData);
faceDetectorJson["faces"] = facesArr;
faceDetectorJson["best"] = bestFace;
// SYSTEM INFORMATION
if (retrieveInformation) faceDetectorJson["sysinfo"] = GetDeviceInfo(device);
// IMU
if (useIMU) faceDetectorJson["imu"] = GetIMU(device);
char* ret = (char*)::malloc(strlen(faceDetectorJson.dump().c_str())+1);
::memcpy(ret, faceDetectorJson.dump().c_str(),strlen(faceDetectorJson.dump().c_str()));
ret[strlen(faceDetectorJson.dump().c_str())] = 0;
return ret;
}
char* ret = (char*)::malloc(strlen("{\"error\":\"DEVICE_NOT_RUNNING\"}"));
::memcpy(ret, "{\"error\":\"DEVICE_NOT_RUNNING\"}",strlen("{\"error\":\"DEVICE_NOT_RUNNING\"}"));
ret[strlen("{\"error\":\"DEVICE_NOT_RUNNING\"}")] = 0;
return ret;
}
}
| 42.808153
| 327
| 0.563554
|
djinn-technologies
|
69a9b34733d8e2c7b1fb7c8680cde5cc71073bb5
| 37,002
|
cpp
|
C++
|
packages/monte_carlo/active_region/core/test/tstIndependentPhaseSpaceDimensionDistribution.cpp
|
bam241/FRENSIE
|
e1760cd792928699c84f2bdce70ff54228e88094
|
[
"BSD-3-Clause"
] | 10
|
2019-11-14T19:58:30.000Z
|
2021-04-04T17:44:09.000Z
|
packages/monte_carlo/active_region/core/test/tstIndependentPhaseSpaceDimensionDistribution.cpp
|
bam241/FRENSIE
|
e1760cd792928699c84f2bdce70ff54228e88094
|
[
"BSD-3-Clause"
] | 43
|
2020-03-03T19:59:20.000Z
|
2021-09-08T03:36:08.000Z
|
packages/monte_carlo/active_region/core/test/tstIndependentPhaseSpaceDimensionDistribution.cpp
|
bam241/FRENSIE
|
e1760cd792928699c84f2bdce70ff54228e88094
|
[
"BSD-3-Clause"
] | 6
|
2020-02-12T17:37:07.000Z
|
2020-09-08T18:59:51.000Z
|
//---------------------------------------------------------------------------//
//!
//! \file tstIndependentPhaseSpaceDimensionDistribution.cpp
//! \author Alex Robinson
//! \brief Independent phase space dimension distribution unit tests
//!
//---------------------------------------------------------------------------//
// Std Lib Includes
#include <iostream>
#include <memory>
// FRENSIE Includes
#include "MonteCarlo_IndependentPhaseSpaceDimensionDistribution.hpp"
#include "MonteCarlo_PhaseSpaceDimensionTraits.hpp"
#include "Utility_BasicCartesianCoordinateConversionPolicy.hpp"
#include "Utility_UniformDistribution.hpp"
#include "Utility_DeltaDistribution.hpp"
#include "Utility_DiscreteDistribution.hpp"
#include "Utility_ExponentialDistribution.hpp"
#include "Utility_RandomNumberGenerator.hpp"
#include "Utility_UnitTestHarnessWithMain.hpp"
#include "ArchiveTestHelpers.hpp"
//---------------------------------------------------------------------------//
// Testing Types
//---------------------------------------------------------------------------//
using namespace MonteCarlo;
typedef std::tuple<std::integral_constant<PhaseSpaceDimension,PRIMARY_SPATIAL_DIMENSION>,
std::integral_constant<PhaseSpaceDimension,SECONDARY_SPATIAL_DIMENSION>,
std::integral_constant<PhaseSpaceDimension,TERTIARY_SPATIAL_DIMENSION>,
std::integral_constant<PhaseSpaceDimension,PRIMARY_DIRECTIONAL_DIMENSION>,
std::integral_constant<PhaseSpaceDimension,SECONDARY_DIRECTIONAL_DIMENSION>,
std::integral_constant<PhaseSpaceDimension,TERTIARY_DIRECTIONAL_DIMENSION>,
std::integral_constant<PhaseSpaceDimension,ENERGY_DIMENSION>,
std::integral_constant<PhaseSpaceDimension,TIME_DIMENSION>
> TestPhaseSpaceDimensionsNoWeight;
typedef decltype(std::tuple_cat(TestPhaseSpaceDimensionsNoWeight(),std::make_tuple(std::integral_constant<PhaseSpaceDimension,WEIGHT_DIMENSION>()))) TestPhaseSpaceDimensions;
typedef TestArchiveHelper::TestArchives TestArchives;
//---------------------------------------------------------------------------//
// Testing Variables.
//---------------------------------------------------------------------------//
std::shared_ptr<const Utility::SpatialCoordinateConversionPolicy>
spatial_coord_conversion_policy( new Utility::BasicCartesianCoordinateConversionPolicy );
std::shared_ptr<const Utility::DirectionalCoordinateConversionPolicy>
directional_coord_conversion_policy( new Utility::BasicCartesianCoordinateConversionPolicy );
//---------------------------------------------------------------------------//
// Tests.
//---------------------------------------------------------------------------//
// Test that the dimension can be returned
FRENSIE_UNIT_TEST_TEMPLATE( IndependentPhaseSpaceDimensionDistribution,
getDimension,
TestPhaseSpaceDimensions )
{
FETCH_TEMPLATE_PARAM( 0, WrappedDimension );
constexpr PhaseSpaceDimension Dimension = WrappedDimension::value;
std::shared_ptr<const Utility::UnivariateDistribution> basic_distribution(
new Utility::UniformDistribution( 0.5, 1.5, 0.5 ) );
std::shared_ptr<const MonteCarlo::PhaseSpaceDimensionDistribution>
dimension_distribution( new MonteCarlo::IndependentPhaseSpaceDimensionDistribution<Dimension>( basic_distribution ) );
FRENSIE_CHECK_EQUAL( dimension_distribution->getDimension(), Dimension );
}
//---------------------------------------------------------------------------//
// Test that the dimension class can be returned
FRENSIE_UNIT_TEST_TEMPLATE( IndependentPhaseSpaceDimensionDistribution,
getDimensionClass,
TestPhaseSpaceDimensions )
{
FETCH_TEMPLATE_PARAM( 0, WrappedDimension );
constexpr PhaseSpaceDimension Dimension = WrappedDimension::value;
std::shared_ptr<const Utility::UnivariateDistribution> basic_distribution(
new Utility::UniformDistribution( 0.5, 1.5, 0.5 ) );
std::shared_ptr<const MonteCarlo::PhaseSpaceDimensionDistribution>
dimension_distribution( new MonteCarlo::IndependentPhaseSpaceDimensionDistribution<Dimension>( basic_distribution ) );
FRENSIE_CHECK_EQUAL( dimension_distribution->getDimensionClass(),
MonteCarlo::PhaseSpaceDimensionTraits<Dimension>::getClass() );
}
//---------------------------------------------------------------------------//
// Test that the distribution type name can be returned
FRENSIE_UNIT_TEST_TEMPLATE( IndependentPhaseSpaceDimensionDistribution,
getDistributionTypeName,
TestPhaseSpaceDimensions )
{
FETCH_TEMPLATE_PARAM( 0, WrappedDimension );
constexpr PhaseSpaceDimension Dimension = WrappedDimension::value;
std::shared_ptr<const Utility::UnivariateDistribution> basic_distribution(
new Utility::UniformDistribution( 0.5, 1.5, 0.5 ) );
std::shared_ptr<const MonteCarlo::PhaseSpaceDimensionDistribution>
dimension_distribution( new MonteCarlo::IndependentPhaseSpaceDimensionDistribution<Dimension>( basic_distribution ) );
FRENSIE_CHECK_EQUAL( dimension_distribution->getDistributionTypeName(),
"Uniform Distribution" );
}
//---------------------------------------------------------------------------//
// Test if the distribution is independent
FRENSIE_UNIT_TEST_TEMPLATE( IndependentPhaseSpaceDimensionDistribution,
isIndependent,
TestPhaseSpaceDimensions )
{
FETCH_TEMPLATE_PARAM( 0, WrappedDimension );
constexpr PhaseSpaceDimension Dimension = WrappedDimension::value;
std::shared_ptr<const Utility::UnivariateDistribution> basic_distribution(
new Utility::UniformDistribution( 0.5, 1.5, 0.5 ) );
std::shared_ptr<const MonteCarlo::PhaseSpaceDimensionDistribution>
dimension_distribution( new MonteCarlo::IndependentPhaseSpaceDimensionDistribution<Dimension>( basic_distribution ) );
FRENSIE_CHECK( dimension_distribution->isIndependent() );
}
//---------------------------------------------------------------------------//
// Test if the distribution is dependent on another dimension
FRENSIE_UNIT_TEST_TEMPLATE( IndependentPhaseSpaceDimensionDistribution,
isDependentOnDimension,
TestPhaseSpaceDimensions )
{
FETCH_TEMPLATE_PARAM( 0, WrappedDimension );
constexpr PhaseSpaceDimension Dimension = WrappedDimension::value;
std::shared_ptr<const Utility::UnivariateDistribution> basic_distribution(
new Utility::UniformDistribution( 0.5, 1.5, 0.5 ) );
std::shared_ptr<const MonteCarlo::PhaseSpaceDimensionDistribution>
dimension_distribution( new MonteCarlo::IndependentPhaseSpaceDimensionDistribution<Dimension>( basic_distribution ) );
FRENSIE_CHECK( !dimension_distribution->isDependentOnDimension( MonteCarlo::PRIMARY_SPATIAL_DIMENSION ) );
FRENSIE_CHECK( !dimension_distribution->isDependentOnDimension( MonteCarlo::SECONDARY_SPATIAL_DIMENSION ) );
FRENSIE_CHECK( !dimension_distribution->isDependentOnDimension( MonteCarlo::TERTIARY_SPATIAL_DIMENSION ) );
FRENSIE_CHECK( !dimension_distribution->isDependentOnDimension( MonteCarlo::PRIMARY_DIRECTIONAL_DIMENSION ) );
FRENSIE_CHECK( !dimension_distribution->isDependentOnDimension( MonteCarlo::SECONDARY_DIRECTIONAL_DIMENSION ) );
FRENSIE_CHECK( !dimension_distribution->isDependentOnDimension( MonteCarlo::TERTIARY_DIRECTIONAL_DIMENSION ) );
FRENSIE_CHECK( !dimension_distribution->isDependentOnDimension( MonteCarlo::ENERGY_DIMENSION ) );
FRENSIE_CHECK( !dimension_distribution->isDependentOnDimension( MonteCarlo::TIME_DIMENSION ) );
FRENSIE_CHECK( !dimension_distribution->isDependentOnDimension( MonteCarlo::WEIGHT_DIMENSION ) );
}
//---------------------------------------------------------------------------//
// Test if the distribution is continuous
FRENSIE_UNIT_TEST_TEMPLATE( IndependentPhaseSpaceDimensionDistribution,
isContinuous,
TestPhaseSpaceDimensions )
{
FETCH_TEMPLATE_PARAM( 0, WrappedDimension );
constexpr PhaseSpaceDimension Dimension = WrappedDimension::value;
std::shared_ptr<const Utility::UnivariateDistribution> basic_distribution(
new Utility::UniformDistribution( 0.5, 1.5, 0.5 ) );
std::shared_ptr<const MonteCarlo::PhaseSpaceDimensionDistribution>
dimension_distribution( new MonteCarlo::IndependentPhaseSpaceDimensionDistribution<Dimension>( basic_distribution ) );
FRENSIE_CHECK( dimension_distribution->isContinuous() );
basic_distribution.reset( new Utility::DeltaDistribution( 1.0 ) );
dimension_distribution.reset( new MonteCarlo::IndependentPhaseSpaceDimensionDistribution<Dimension>( basic_distribution ) );
FRENSIE_CHECK( !dimension_distribution->isContinuous() );
}
//---------------------------------------------------------------------------//
// Test if the distribution is tabular
FRENSIE_UNIT_TEST_TEMPLATE( IndependentPhaseSpaceDimensionDistribution,
isTabular,
TestPhaseSpaceDimensions )
{
FETCH_TEMPLATE_PARAM( 0, WrappedDimension );
constexpr PhaseSpaceDimension Dimension = WrappedDimension::value;
std::shared_ptr<const Utility::UnivariateDistribution> basic_distribution(
new Utility::UniformDistribution( 0.5, 1.5, 0.5 ) );
std::shared_ptr<const MonteCarlo::PhaseSpaceDimensionDistribution>
dimension_distribution( new MonteCarlo::IndependentPhaseSpaceDimensionDistribution<Dimension>( basic_distribution ) );
FRENSIE_CHECK( dimension_distribution->isTabular() );
basic_distribution.reset( new Utility::ExponentialDistribution( 1.0, 1.0 ) );
dimension_distribution.reset( new MonteCarlo::IndependentPhaseSpaceDimensionDistribution<Dimension>( basic_distribution ) );
FRENSIE_CHECK( !dimension_distribution->isTabular() );
}
//---------------------------------------------------------------------------//
// Test if the distribution is uniform
FRENSIE_UNIT_TEST_TEMPLATE( IndependentPhaseSpaceDimensionDistribution,
isUniform,
TestPhaseSpaceDimensions )
{
FETCH_TEMPLATE_PARAM( 0, WrappedDimension );
constexpr PhaseSpaceDimension Dimension = WrappedDimension::value;
std::shared_ptr<const Utility::UnivariateDistribution> basic_distribution(
new Utility::UniformDistribution( 0.5, 1.5, 0.5 ) );
std::shared_ptr<const MonteCarlo::PhaseSpaceDimensionDistribution>
dimension_distribution( new MonteCarlo::IndependentPhaseSpaceDimensionDistribution<Dimension>( basic_distribution ) );
FRENSIE_CHECK( dimension_distribution->isUniform() );
basic_distribution.reset( new Utility::ExponentialDistribution( 1.0, 1.0 ) );
dimension_distribution.reset( new MonteCarlo::IndependentPhaseSpaceDimensionDistribution<Dimension>( basic_distribution ) );
FRENSIE_CHECK( !dimension_distribution->isUniform() );
}
//---------------------------------------------------------------------------//
// Test if the distribution has the specified form
FRENSIE_UNIT_TEST_TEMPLATE( IndependentPhaseSpaceDimensionDistribution,
hasForm,
TestPhaseSpaceDimensions )
{
FETCH_TEMPLATE_PARAM( 0, WrappedDimension );
constexpr PhaseSpaceDimension Dimension = WrappedDimension::value;
std::shared_ptr<const Utility::UnivariateDistribution> basic_distribution(
new Utility::UniformDistribution( 0.5, 1.5, 0.5 ) );
std::shared_ptr<const MonteCarlo::PhaseSpaceDimensionDistribution>
dimension_distribution( new MonteCarlo::IndependentPhaseSpaceDimensionDistribution<Dimension>( basic_distribution ) );
FRENSIE_CHECK( dimension_distribution->hasForm( Utility::UNIFORM_DISTRIBUTION ) );
FRENSIE_CHECK( !dimension_distribution->hasForm( Utility::EXPONENTIAL_DISTRIBUTION ) );
basic_distribution.reset( new Utility::ExponentialDistribution( 1.0, 1.0 ) );
dimension_distribution.reset( new MonteCarlo::IndependentPhaseSpaceDimensionDistribution<Dimension>( basic_distribution ) );
FRENSIE_CHECK( !dimension_distribution->hasForm( Utility::UNIFORM_DISTRIBUTION ) );
FRENSIE_CHECK( dimension_distribution->hasForm( Utility::EXPONENTIAL_DISTRIBUTION ) );
}
//---------------------------------------------------------------------------//
// Test if the distribution can be evaluated without a cascade
FRENSIE_UNIT_TEST_TEMPLATE( IndependentPhaseSpaceDimensionDistribution,
evaluateWithoutCascade,
TestPhaseSpaceDimensions )
{
FETCH_TEMPLATE_PARAM( 0, WrappedDimension );
constexpr PhaseSpaceDimension Dimension = WrappedDimension::value;
std::shared_ptr<const Utility::UnivariateDistribution> basic_distribution(
new Utility::UniformDistribution( 0.5, 0.9, 0.5 ) );
std::shared_ptr<const MonteCarlo::PhaseSpaceDimensionDistribution>
dimension_distribution( new MonteCarlo::IndependentPhaseSpaceDimensionDistribution<Dimension>( basic_distribution ) );
MonteCarlo::PhaseSpacePoint point( spatial_coord_conversion_policy,
directional_coord_conversion_policy );
setCoordinate<Dimension>( point, 0.1 );
FRENSIE_CHECK_EQUAL( dimension_distribution->evaluateWithoutCascade( point ),
0.0 );
setCoordinate<Dimension>( point, 0.5 );
FRENSIE_CHECK_EQUAL( dimension_distribution->evaluateWithoutCascade( point ),
0.5 );
setCoordinate<Dimension>( point, 0.7 );
FRENSIE_CHECK_EQUAL( dimension_distribution->evaluateWithoutCascade( point ),
0.5 );
setCoordinate<Dimension>( point, 0.9 );
FRENSIE_CHECK_EQUAL( dimension_distribution->evaluateWithoutCascade( point ),
0.5 );
setCoordinate<Dimension>( point, 1.0 );
FRENSIE_CHECK_EQUAL( dimension_distribution->evaluateWithoutCascade( point ),
0.0 );
}
//---------------------------------------------------------------------------//
// Test if the distribution can be sampled without a cascade
FRENSIE_UNIT_TEST_TEMPLATE( IndependentPhaseSpaceDimensionDistribution,
sampleWithoutCascade,
TestPhaseSpaceDimensionsNoWeight )
{
FETCH_TEMPLATE_PARAM( 0, WrappedDimension );
constexpr PhaseSpaceDimension Dimension = WrappedDimension::value;
std::shared_ptr<const Utility::UnivariateDistribution> basic_distribution(
new Utility::UniformDistribution( 0.1, 0.9, 0.5 ) );
std::shared_ptr<const MonteCarlo::PhaseSpaceDimensionDistribution>
dimension_distribution( new MonteCarlo::IndependentPhaseSpaceDimensionDistribution<Dimension>( basic_distribution ) );
MonteCarlo::PhaseSpacePoint point( spatial_coord_conversion_policy,
directional_coord_conversion_policy );
std::vector<double> fake_stream( 3 );
fake_stream[0] = 0.0;
fake_stream[1] = 0.5;
fake_stream[2] = 1.0 - 1e-15;
Utility::RandomNumberGenerator::setFakeStream( fake_stream );
dimension_distribution->sampleWithoutCascade( point );
FRENSIE_CHECK_EQUAL( getCoordinate<Dimension>( point ), 0.1 );
FRENSIE_CHECK_EQUAL( getCoordinateWeight<Dimension>( point ), 1.0 );
dimension_distribution->sampleWithoutCascade( point );
FRENSIE_CHECK_EQUAL( getCoordinate<Dimension>( point ), 0.5 );
FRENSIE_CHECK_EQUAL( getCoordinateWeight<Dimension>( point ), 1.0 );
dimension_distribution->sampleWithoutCascade( point );
FRENSIE_CHECK_FLOATING_EQUALITY( getCoordinate<Dimension>( point ), 0.9, 1e-15 );
FRENSIE_CHECK_EQUAL( getCoordinateWeight<Dimension>( point ), 1.0 );
}
//---------------------------------------------------------------------------//
// Test if the distribution can be sampled without a cascade and the
// trials can be counted
FRENSIE_UNIT_TEST_TEMPLATE( IndependentPhaseSpaceDimensionDistribution,
sampleAndRecordTrialsWithoutCascade,
TestPhaseSpaceDimensionsNoWeight )
{
FETCH_TEMPLATE_PARAM( 0, WrappedDimension );
constexpr PhaseSpaceDimension Dimension = WrappedDimension::value;
std::shared_ptr<const Utility::UnivariateDistribution> basic_distribution(
new Utility::UniformDistribution( 0.1, 0.9, 0.5 ) );
std::shared_ptr<const MonteCarlo::PhaseSpaceDimensionDistribution>
dimension_distribution( new MonteCarlo::IndependentPhaseSpaceDimensionDistribution<Dimension>( basic_distribution ) );
MonteCarlo::PhaseSpacePoint point( spatial_coord_conversion_policy,
directional_coord_conversion_policy );
typename MonteCarlo::IndependentPhaseSpaceDimensionDistribution<Dimension>::Counter trials = 0;
std::vector<double> fake_stream( 3 );
fake_stream[0] = 0.0;
fake_stream[1] = 0.5;
fake_stream[2] = 1.0 - 1e-15;
Utility::RandomNumberGenerator::setFakeStream( fake_stream );
dimension_distribution->sampleAndRecordTrialsWithoutCascade( point, trials );
FRENSIE_CHECK_EQUAL( getCoordinate<Dimension>( point ), 0.1 );
FRENSIE_CHECK_EQUAL( getCoordinateWeight<Dimension>( point ), 1.0 );
FRENSIE_CHECK_EQUAL( trials, 1 );
dimension_distribution->sampleAndRecordTrialsWithoutCascade( point, trials );
FRENSIE_CHECK_EQUAL( getCoordinate<Dimension>( point ), 0.5 );
FRENSIE_CHECK_EQUAL( getCoordinateWeight<Dimension>( point ), 1.0 );
FRENSIE_CHECK_EQUAL( trials, 2 );
dimension_distribution->sampleAndRecordTrialsWithoutCascade( point, trials );
FRENSIE_CHECK_FLOATING_EQUALITY( getCoordinate<Dimension>( point ), 0.9, 1e-15 );
FRENSIE_CHECK_EQUAL( getCoordinateWeight<Dimension>( point ), 1.0 );
FRENSIE_CHECK_EQUAL( trials, 3 );
}
//---------------------------------------------------------------------------//
// Test that the dimension value can be set and weighted appropriately
FRENSIE_UNIT_TEST_TEMPLATE( IndependentPhaseSpaceDimensionDistribution,
setDimensionValueAndApplyWeight,
TestPhaseSpaceDimensionsNoWeight )
{
FETCH_TEMPLATE_PARAM( 0, WrappedDimension );
constexpr PhaseSpaceDimension Dimension = WrappedDimension::value;
std::shared_ptr<const Utility::UnivariateDistribution> basic_distribution(
new Utility::UniformDistribution( 0.1, 0.9, 0.5 ) );
std::shared_ptr<const MonteCarlo::PhaseSpaceDimensionDistribution>
dimension_distribution( new MonteCarlo::IndependentPhaseSpaceDimensionDistribution<Dimension>( basic_distribution ) );
MonteCarlo::PhaseSpacePoint point( spatial_coord_conversion_policy,
directional_coord_conversion_policy );
dimension_distribution->setDimensionValueAndApplyWeight( point, 0.1 );
FRENSIE_CHECK_EQUAL( getCoordinate<Dimension>( point ), 0.1 );
FRENSIE_CHECK_EQUAL( getCoordinateWeight<Dimension>( point ), 1.25 );
dimension_distribution->setDimensionValueAndApplyWeight( point, 0.5 );
FRENSIE_CHECK_EQUAL( getCoordinate<Dimension>( point ), 0.5 );
FRENSIE_CHECK_EQUAL( getCoordinateWeight<Dimension>( point ), 1.25 );
dimension_distribution->setDimensionValueAndApplyWeight( point, 0.9 );
FRENSIE_CHECK_EQUAL( getCoordinate<Dimension>( point ), 0.9 );
FRENSIE_CHECK_EQUAL( getCoordinateWeight<Dimension>( point ), 1.25 );
}
//---------------------------------------------------------------------------//
// Check that the distribution can be archived
FRENSIE_UNIT_TEST_TEMPLATE_EXPAND( PhaseSpaceDimension,
archive,
TestArchives )
{
FETCH_TEMPLATE_PARAM( 0, RawOArchive );
FETCH_TEMPLATE_PARAM( 1, RawIArchive );
typedef typename std::remove_pointer<RawOArchive>::type OArchive;
typedef typename std::remove_pointer<RawIArchive>::type IArchive;
std::string archive_base_name( "test_independent_phase_dimension_distribution" );
std::ostringstream archive_ostream;
{
std::unique_ptr<OArchive> oarchive;
createOArchive( archive_base_name, archive_ostream, oarchive );
std::shared_ptr<const Utility::UnivariateDistribution> basic_distribution(
new Utility::UniformDistribution( 0.5, 0.9, 0.5 ) );
std::shared_ptr<const MonteCarlo::PhaseSpaceDimensionDistribution>
primary_spatial_dimension_distribution( new MonteCarlo::IndependentPrimarySpatialDimensionDistribution( basic_distribution ) );
std::shared_ptr<const MonteCarlo::PhaseSpaceDimensionDistribution>
secondary_spatial_dimension_distribution( new MonteCarlo::IndependentSecondarySpatialDimensionDistribution( basic_distribution ) );
std::shared_ptr<const MonteCarlo::PhaseSpaceDimensionDistribution>
tertiary_spatial_dimension_distribution( new MonteCarlo::IndependentTertiarySpatialDimensionDistribution( basic_distribution ) );
std::shared_ptr<const MonteCarlo::PhaseSpaceDimensionDistribution>
primary_directional_dimension_distribution( new MonteCarlo::IndependentPrimaryDirectionalDimensionDistribution( basic_distribution ) );
std::shared_ptr<const MonteCarlo::PhaseSpaceDimensionDistribution>
secondary_directional_dimension_distribution( new MonteCarlo::IndependentSecondaryDirectionalDimensionDistribution( basic_distribution ) );
std::shared_ptr<const MonteCarlo::PhaseSpaceDimensionDistribution>
tertiary_directional_dimension_distribution( new MonteCarlo::IndependentTertiaryDirectionalDimensionDistribution( basic_distribution ) );
std::shared_ptr<const MonteCarlo::PhaseSpaceDimensionDistribution>
energy_dimension_distribution( new MonteCarlo::IndependentEnergyDimensionDistribution( basic_distribution ) );
std::shared_ptr<const MonteCarlo::PhaseSpaceDimensionDistribution>
time_dimension_distribution( new MonteCarlo::IndependentTimeDimensionDistribution( basic_distribution ) );
std::shared_ptr<const MonteCarlo::PhaseSpaceDimensionDistribution>
weight_dimension_distribution( new MonteCarlo::IndependentWeightDimensionDistribution( basic_distribution ) );
FRENSIE_REQUIRE_NO_THROW( (*oarchive) << BOOST_SERIALIZATION_NVP(primary_spatial_dimension_distribution) );
FRENSIE_REQUIRE_NO_THROW( (*oarchive) << BOOST_SERIALIZATION_NVP(secondary_spatial_dimension_distribution) );
FRENSIE_REQUIRE_NO_THROW( (*oarchive) << BOOST_SERIALIZATION_NVP(tertiary_spatial_dimension_distribution) );
FRENSIE_REQUIRE_NO_THROW( (*oarchive) << BOOST_SERIALIZATION_NVP(primary_directional_dimension_distribution) );
FRENSIE_REQUIRE_NO_THROW( (*oarchive) << BOOST_SERIALIZATION_NVP(secondary_directional_dimension_distribution) );
FRENSIE_REQUIRE_NO_THROW( (*oarchive) << BOOST_SERIALIZATION_NVP(tertiary_directional_dimension_distribution) );
FRENSIE_REQUIRE_NO_THROW( (*oarchive) << BOOST_SERIALIZATION_NVP(energy_dimension_distribution) );
FRENSIE_REQUIRE_NO_THROW( (*oarchive) << BOOST_SERIALIZATION_NVP(time_dimension_distribution) );
FRENSIE_REQUIRE_NO_THROW( (*oarchive) << BOOST_SERIALIZATION_NVP(weight_dimension_distribution) );
}
// Copy the archive ostream to an istream
std::istringstream archive_istream( archive_ostream.str() );
// Load the archived distributions
std::unique_ptr<IArchive> iarchive;
createIArchive( archive_istream, iarchive );
std::shared_ptr<const MonteCarlo::PhaseSpaceDimensionDistribution>
primary_spatial_dimension_distribution,
secondary_spatial_dimension_distribution,
tertiary_spatial_dimension_distribution,
primary_directional_dimension_distribution,
secondary_directional_dimension_distribution,
tertiary_directional_dimension_distribution,
energy_dimension_distribution,
time_dimension_distribution,
weight_dimension_distribution;
FRENSIE_REQUIRE_NO_THROW( (*iarchive) >> BOOST_SERIALIZATION_NVP(primary_spatial_dimension_distribution) );
FRENSIE_REQUIRE_NO_THROW( (*iarchive) >> BOOST_SERIALIZATION_NVP(secondary_spatial_dimension_distribution) );
FRENSIE_REQUIRE_NO_THROW( (*iarchive) >> BOOST_SERIALIZATION_NVP(tertiary_spatial_dimension_distribution) );
FRENSIE_REQUIRE_NO_THROW( (*iarchive) >> BOOST_SERIALIZATION_NVP(primary_directional_dimension_distribution) );
FRENSIE_REQUIRE_NO_THROW( (*iarchive) >> BOOST_SERIALIZATION_NVP(secondary_directional_dimension_distribution) );
FRENSIE_REQUIRE_NO_THROW( (*iarchive) >> BOOST_SERIALIZATION_NVP(tertiary_directional_dimension_distribution) );
FRENSIE_REQUIRE_NO_THROW( (*iarchive) >> BOOST_SERIALIZATION_NVP(energy_dimension_distribution) );
FRENSIE_REQUIRE_NO_THROW( (*iarchive) >> BOOST_SERIALIZATION_NVP(time_dimension_distribution) );
FRENSIE_REQUIRE_NO_THROW( (*iarchive) >> BOOST_SERIALIZATION_NVP(weight_dimension_distribution) );
iarchive.reset();
{
FRENSIE_CHECK_EQUAL( primary_spatial_dimension_distribution->getDimension(),
PRIMARY_SPATIAL_DIMENSION );
MonteCarlo::PhaseSpacePoint point( spatial_coord_conversion_policy,
directional_coord_conversion_policy );
setCoordinate<PRIMARY_SPATIAL_DIMENSION>( point, 0.1 );
FRENSIE_CHECK_EQUAL( primary_spatial_dimension_distribution->evaluateWithoutCascade( point ),
0.0 );
setCoordinate<PRIMARY_SPATIAL_DIMENSION>( point, 0.5 );
FRENSIE_CHECK_EQUAL( primary_spatial_dimension_distribution->evaluateWithoutCascade( point ),
0.5 );
setCoordinate<PRIMARY_SPATIAL_DIMENSION>( point, 0.7 );
FRENSIE_CHECK_EQUAL( primary_spatial_dimension_distribution->evaluateWithoutCascade( point ),
0.5 );
setCoordinate<PRIMARY_SPATIAL_DIMENSION>( point, 0.9 );
FRENSIE_CHECK_EQUAL( primary_spatial_dimension_distribution->evaluateWithoutCascade( point ),
0.5 );
setCoordinate<PRIMARY_SPATIAL_DIMENSION>( point, 1.0 );
FRENSIE_CHECK_EQUAL( primary_spatial_dimension_distribution->evaluateWithoutCascade( point ),
0.0 );
}
{
FRENSIE_CHECK_EQUAL( secondary_spatial_dimension_distribution->getDimension(),
SECONDARY_SPATIAL_DIMENSION );
MonteCarlo::PhaseSpacePoint point( spatial_coord_conversion_policy,
directional_coord_conversion_policy );
setCoordinate<SECONDARY_SPATIAL_DIMENSION>( point, 0.1 );
FRENSIE_CHECK_EQUAL( secondary_spatial_dimension_distribution->evaluateWithoutCascade( point ),
0.0 );
setCoordinate<SECONDARY_SPATIAL_DIMENSION>( point, 0.5 );
FRENSIE_CHECK_EQUAL( secondary_spatial_dimension_distribution->evaluateWithoutCascade( point ),
0.5 );
setCoordinate<SECONDARY_SPATIAL_DIMENSION>( point, 0.7 );
FRENSIE_CHECK_EQUAL( secondary_spatial_dimension_distribution->evaluateWithoutCascade( point ),
0.5 );
setCoordinate<SECONDARY_SPATIAL_DIMENSION>( point, 0.9 );
FRENSIE_CHECK_EQUAL( secondary_spatial_dimension_distribution->evaluateWithoutCascade( point ),
0.5 );
setCoordinate<SECONDARY_SPATIAL_DIMENSION>( point, 1.0 );
FRENSIE_CHECK_EQUAL( secondary_spatial_dimension_distribution->evaluateWithoutCascade( point ),
0.0 );
}
{
FRENSIE_CHECK_EQUAL( tertiary_spatial_dimension_distribution->getDimension(),
TERTIARY_SPATIAL_DIMENSION );
MonteCarlo::PhaseSpacePoint point( spatial_coord_conversion_policy,
directional_coord_conversion_policy );
setCoordinate<TERTIARY_SPATIAL_DIMENSION>( point, 0.1 );
FRENSIE_CHECK_EQUAL( tertiary_spatial_dimension_distribution->evaluateWithoutCascade( point ),
0.0 );
setCoordinate<TERTIARY_SPATIAL_DIMENSION>( point, 0.5 );
FRENSIE_CHECK_EQUAL( tertiary_spatial_dimension_distribution->evaluateWithoutCascade( point ),
0.5 );
setCoordinate<TERTIARY_SPATIAL_DIMENSION>( point, 0.7 );
FRENSIE_CHECK_EQUAL( tertiary_spatial_dimension_distribution->evaluateWithoutCascade( point ),
0.5 );
setCoordinate<TERTIARY_SPATIAL_DIMENSION>( point, 0.9 );
FRENSIE_CHECK_EQUAL( tertiary_spatial_dimension_distribution->evaluateWithoutCascade( point ),
0.5 );
setCoordinate<TERTIARY_SPATIAL_DIMENSION>( point, 1.0 );
FRENSIE_CHECK_EQUAL( tertiary_spatial_dimension_distribution->evaluateWithoutCascade( point ),
0.0 );
}
{
FRENSIE_CHECK_EQUAL( primary_directional_dimension_distribution->getDimension(),
PRIMARY_DIRECTIONAL_DIMENSION );
MonteCarlo::PhaseSpacePoint point( spatial_coord_conversion_policy,
directional_coord_conversion_policy );
setCoordinate<PRIMARY_DIRECTIONAL_DIMENSION>( point, 0.1 );
FRENSIE_CHECK_EQUAL( primary_directional_dimension_distribution->evaluateWithoutCascade( point ),
0.0 );
setCoordinate<PRIMARY_DIRECTIONAL_DIMENSION>( point, 0.5 );
FRENSIE_CHECK_EQUAL( primary_directional_dimension_distribution->evaluateWithoutCascade( point ),
0.5 );
setCoordinate<PRIMARY_DIRECTIONAL_DIMENSION>( point, 0.7 );
FRENSIE_CHECK_EQUAL( primary_directional_dimension_distribution->evaluateWithoutCascade( point ),
0.5 );
setCoordinate<PRIMARY_DIRECTIONAL_DIMENSION>( point, 0.9 );
FRENSIE_CHECK_EQUAL( primary_directional_dimension_distribution->evaluateWithoutCascade( point ),
0.5 );
setCoordinate<PRIMARY_DIRECTIONAL_DIMENSION>( point, 1.0 );
FRENSIE_CHECK_EQUAL( primary_directional_dimension_distribution->evaluateWithoutCascade( point ),
0.0 );
}
{
FRENSIE_CHECK_EQUAL( secondary_directional_dimension_distribution->getDimension(),
SECONDARY_DIRECTIONAL_DIMENSION );
MonteCarlo::PhaseSpacePoint point( spatial_coord_conversion_policy,
directional_coord_conversion_policy );
setCoordinate<SECONDARY_DIRECTIONAL_DIMENSION>( point, 0.1 );
FRENSIE_CHECK_EQUAL( secondary_directional_dimension_distribution->evaluateWithoutCascade( point ),
0.0 );
setCoordinate<SECONDARY_DIRECTIONAL_DIMENSION>( point, 0.5 );
FRENSIE_CHECK_EQUAL( secondary_directional_dimension_distribution->evaluateWithoutCascade( point ),
0.5 );
setCoordinate<SECONDARY_DIRECTIONAL_DIMENSION>( point, 0.7 );
FRENSIE_CHECK_EQUAL( secondary_directional_dimension_distribution->evaluateWithoutCascade( point ),
0.5 );
setCoordinate<SECONDARY_DIRECTIONAL_DIMENSION>( point, 0.9 );
FRENSIE_CHECK_EQUAL( secondary_directional_dimension_distribution->evaluateWithoutCascade( point ),
0.5 );
setCoordinate<SECONDARY_DIRECTIONAL_DIMENSION>( point, 1.0 );
FRENSIE_CHECK_EQUAL( secondary_directional_dimension_distribution->evaluateWithoutCascade( point ),
0.0 );
}
{
FRENSIE_CHECK_EQUAL( tertiary_directional_dimension_distribution->getDimension(),
TERTIARY_DIRECTIONAL_DIMENSION );
MonteCarlo::PhaseSpacePoint point( spatial_coord_conversion_policy,
directional_coord_conversion_policy );
setCoordinate<TERTIARY_DIRECTIONAL_DIMENSION>( point, 0.1 );
FRENSIE_CHECK_EQUAL( tertiary_directional_dimension_distribution->evaluateWithoutCascade( point ),
0.0 );
setCoordinate<TERTIARY_DIRECTIONAL_DIMENSION>( point, 0.5 );
FRENSIE_CHECK_EQUAL( tertiary_directional_dimension_distribution->evaluateWithoutCascade( point ),
0.5 );
setCoordinate<TERTIARY_DIRECTIONAL_DIMENSION>( point, 0.7 );
FRENSIE_CHECK_EQUAL( tertiary_directional_dimension_distribution->evaluateWithoutCascade( point ),
0.5 );
setCoordinate<TERTIARY_DIRECTIONAL_DIMENSION>( point, 0.9 );
FRENSIE_CHECK_EQUAL( tertiary_directional_dimension_distribution->evaluateWithoutCascade( point ),
0.5 );
setCoordinate<TERTIARY_DIRECTIONAL_DIMENSION>( point, 1.0 );
FRENSIE_CHECK_EQUAL( tertiary_directional_dimension_distribution->evaluateWithoutCascade( point ),
0.0 );
}
{
FRENSIE_CHECK_EQUAL( energy_dimension_distribution->getDimension(),
ENERGY_DIMENSION );
MonteCarlo::PhaseSpacePoint point( spatial_coord_conversion_policy,
directional_coord_conversion_policy );
setCoordinate<ENERGY_DIMENSION>( point, 0.1 );
FRENSIE_CHECK_EQUAL( energy_dimension_distribution->evaluateWithoutCascade( point ),
0.0 );
setCoordinate<ENERGY_DIMENSION>( point, 0.5 );
FRENSIE_CHECK_EQUAL( energy_dimension_distribution->evaluateWithoutCascade( point ),
0.5 );
setCoordinate<ENERGY_DIMENSION>( point, 0.7 );
FRENSIE_CHECK_EQUAL( energy_dimension_distribution->evaluateWithoutCascade( point ),
0.5 );
setCoordinate<ENERGY_DIMENSION>( point, 0.9 );
FRENSIE_CHECK_EQUAL( energy_dimension_distribution->evaluateWithoutCascade( point ),
0.5 );
setCoordinate<ENERGY_DIMENSION>( point, 1.0 );
FRENSIE_CHECK_EQUAL( energy_dimension_distribution->evaluateWithoutCascade( point ),
0.0 );
}
{
FRENSIE_CHECK_EQUAL( time_dimension_distribution->getDimension(),
TIME_DIMENSION );
MonteCarlo::PhaseSpacePoint point( spatial_coord_conversion_policy,
directional_coord_conversion_policy );
setCoordinate<TIME_DIMENSION>( point, 0.1 );
FRENSIE_CHECK_EQUAL( time_dimension_distribution->evaluateWithoutCascade( point ),
0.0 );
setCoordinate<TIME_DIMENSION>( point, 0.5 );
FRENSIE_CHECK_EQUAL( time_dimension_distribution->evaluateWithoutCascade( point ),
0.5 );
setCoordinate<TIME_DIMENSION>( point, 0.7 );
FRENSIE_CHECK_EQUAL( time_dimension_distribution->evaluateWithoutCascade( point ),
0.5 );
setCoordinate<TIME_DIMENSION>( point, 0.9 );
FRENSIE_CHECK_EQUAL( time_dimension_distribution->evaluateWithoutCascade( point ),
0.5 );
setCoordinate<TIME_DIMENSION>( point, 1.0 );
FRENSIE_CHECK_EQUAL( time_dimension_distribution->evaluateWithoutCascade( point ),
0.0 );
}
{
FRENSIE_CHECK_EQUAL( weight_dimension_distribution->getDimension(),
WEIGHT_DIMENSION );
MonteCarlo::PhaseSpacePoint point( spatial_coord_conversion_policy,
directional_coord_conversion_policy );
setCoordinate<WEIGHT_DIMENSION>( point, 0.1 );
FRENSIE_CHECK_EQUAL( weight_dimension_distribution->evaluateWithoutCascade( point ),
0.0 );
setCoordinate<WEIGHT_DIMENSION>( point, 0.5 );
FRENSIE_CHECK_EQUAL( weight_dimension_distribution->evaluateWithoutCascade( point ),
0.5 );
setCoordinate<WEIGHT_DIMENSION>( point, 0.7 );
FRENSIE_CHECK_EQUAL( weight_dimension_distribution->evaluateWithoutCascade( point ),
0.5 );
setCoordinate<WEIGHT_DIMENSION>( point, 0.9 );
FRENSIE_CHECK_EQUAL( weight_dimension_distribution->evaluateWithoutCascade( point ),
0.5 );
setCoordinate<WEIGHT_DIMENSION>( point, 1.0 );
FRENSIE_CHECK_EQUAL( weight_dimension_distribution->evaluateWithoutCascade( point ),
0.0 );
}
}
//---------------------------------------------------------------------------//
// Custom setup
//---------------------------------------------------------------------------//
FRENSIE_CUSTOM_UNIT_TEST_SETUP_BEGIN();
FRENSIE_CUSTOM_UNIT_TEST_INIT()
{
// Initialize the random number generator
Utility::RandomNumberGenerator::createStreams();
}
FRENSIE_CUSTOM_UNIT_TEST_SETUP_END();
//---------------------------------------------------------------------------//
// end tstIndependentPhaseSpaceDimensionDistribution.cpp
//---------------------------------------------------------------------------//
| 45.345588
| 174
| 0.690125
|
bam241
|
69af7ff8dd01d5795b5aad136359bafcaa259e47
| 2,604
|
cc
|
C++
|
projects/src/filesystem.cc
|
oliverlee/phobos
|
eba4adcca8f9f6afb060904b056596f383b52d8d
|
[
"BSD-2-Clause"
] | 2
|
2016-12-14T01:21:34.000Z
|
2018-09-04T10:43:10.000Z
|
projects/src/filesystem.cc
|
oliverlee/phobos
|
eba4adcca8f9f6afb060904b056596f383b52d8d
|
[
"BSD-2-Clause"
] | 182
|
2016-04-25T13:36:52.000Z
|
2020-07-20T10:24:18.000Z
|
projects/src/filesystem.cc
|
oliverlee/phobos
|
eba4adcca8f9f6afb060904b056596f383b52d8d
|
[
"BSD-2-Clause"
] | 6
|
2016-04-25T13:20:53.000Z
|
2021-02-18T18:25:32.000Z
|
#include "filesystem.h"
#include "hal.h"
namespace {
FATFS SDC_FS;
bool fs_ready = false;
const unsigned int sdc_polling_interval = 10;
const unsigned int sdc_polling_delay = 10;
virtual_timer_t card_monitor_timer;
unsigned int debounce_counter;
/* SD card event sources */
event_source_t sdc_inserted_event;
event_source_t sdc_removed_event;
/* SD card event listeners */
event_listener_t el0;
event_listener_t el1;
void insertion_monitor_timer_callback(void *p) {
BaseBlockDevice *bbdp = reinterpret_cast<BaseBlockDevice*>(p);
chSysLockFromISR();
if (debounce_counter > 0) {
if (blkIsInserted(bbdp)) {
if (--debounce_counter == 0) {
chEvtBroadcastI(&sdc_inserted_event);
}
} else {
debounce_counter = sdc_polling_interval;
}
} else {
if (!blkIsInserted(bbdp)) {
debounce_counter = sdc_polling_interval;
chEvtBroadcastI(&sdc_removed_event);
}
}
chVTSetI(&card_monitor_timer, MS2ST(sdc_polling_delay), insertion_monitor_timer_callback, bbdp);
chSysUnlockFromISR();
}
void polling_monitor_timer_init(void *p) {
chEvtObjectInit(&sdc_inserted_event);
chEvtObjectInit(&sdc_removed_event);
chSysLock();
debounce_counter = sdc_polling_interval;
chVTSetI(&card_monitor_timer, MS2ST(sdc_polling_delay), insertion_monitor_timer_callback, p);
chSysUnlock();
}
/* Card insertion event. */
void InsertHandler(eventid_t id) {
FRESULT err;
(void)id;
/* On insertion SDC initialization and FS mount. */
if (sdcConnect(&SDCD1))
return;
err = f_mount(&SDC_FS, "/", 1);
if (err != FR_OK) {
sdcDisconnect(&SDCD1);
return;
}
fs_ready = TRUE;
}
/* Card removal event. */
void RemoveHandler(eventid_t id) {
(void)id;
sdcDisconnect(&SDCD1);
fs_ready = FALSE;
}
}
namespace filesystem {
const evhandler_t sdc_eventhandlers[] = {
InsertHandler,
RemoveHandler
};
void init() {
sdcStart(&SDCD1, nullptr); // Activate SDC driver 1, default configuration
polling_monitor_timer_init(&SDCD1); // Activate card insertion monitor
chEvtRegister(&sdc_inserted_event, &el0, 0);
chEvtRegister(&sdc_removed_event, &el1, 1);
}
bool ready() {
return fs_ready;
}
} // filesystem
| 26.571429
| 104
| 0.605991
|
oliverlee
|
69b9905adc72eba720b32122f1980ce4698e364f
| 10,627
|
cpp
|
C++
|
src/extern/inventor/lib/database/src/so/nodes/nurbs/libnurbs/mesher.cpp
|
OpenXIP/xip-libraries
|
9f0fef66038b20ff0c81c089d7dd0038e3126e40
|
[
"Apache-2.0"
] | 2
|
2020-05-21T07:06:07.000Z
|
2021-06-28T02:14:34.000Z
|
src/extern/inventor/lib/database/src/so/nodes/nurbs/libnurbs/mesher.cpp
|
OpenXIP/xip-libraries
|
9f0fef66038b20ff0c81c089d7dd0038e3126e40
|
[
"Apache-2.0"
] | null | null | null |
src/extern/inventor/lib/database/src/so/nodes/nurbs/libnurbs/mesher.cpp
|
OpenXIP/xip-libraries
|
9f0fef66038b20ff0c81c089d7dd0038e3126e40
|
[
"Apache-2.0"
] | 6
|
2016-03-21T19:53:18.000Z
|
2021-06-08T18:06:03.000Z
|
/*
*
* Copyright (C) 2000 Silicon Graphics, Inc. All Rights Reserved.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* Further, this software is distributed without any warranty that it is
* free of the rightful claim of any third person regarding infringement
* or the like. Any license provided herein, whether implied or
* otherwise, applies only to this software file. Patent licenses, if
* any, provided herein do not apply to combinations of this program with
* other software, or any other product whatsoever.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
* Contact information: Silicon Graphics, Inc., 1600 Amphitheatre Pkwy,
* Mountain View, CA 94043, or:
*
* http://www.sgi.com
*
* For further information regarding this notice, see:
*
* http://oss.sgi.com/projects/GenInfo/NoticeExplan/
*
*/
/*
* mesher.c++ - $Revision: 1.2 $
* Derrick Burns - 1991
*/
#include "glimports.h"
#include "myassert.h"
#include "mystdio.h"
#include "mesher.h"
#include "gridvertex.h"
#include "gridtrimvertex.h"
#include "jarcloc.h"
#include "gridline.h"
#include "trimline.h"
#include "uarray.h"
#include "backend.h"
const float Mesher::ZERO = 0.0;
Mesher::Mesher( Backend& b )
: backend( b ),
p( sizeof( GridTrimVertex ), 100, "GridTrimVertexPool" )
{
stacksize = 0;
vdata = 0;
lastedge = 0;
}
Mesher::~Mesher( void )
{
if( vdata ) delete[] vdata;
}
void
Mesher::init( unsigned int npts )
{
p.clear();
if( stacksize < npts ) {
stacksize = 2 * npts;
if( vdata ) delete[] vdata;
vdata = new GridTrimVertex_p[stacksize];
}
}
inline void
Mesher::push( GridTrimVertex *gt )
{
assert( itop+1 != stacksize );
vdata[++itop] = gt;
}
inline void
Mesher::pop( long )
{
}
inline void
Mesher::openMesh()
{
backend.bgntmesh( "addedge" );
}
inline void
Mesher::closeMesh()
{
backend.endtmesh();
}
inline void
Mesher::swapMesh()
{
backend.swaptmesh();
}
inline void
Mesher::clearStack()
{
itop = -1;
last[0] = 0;
}
void
Mesher::finishLower( GridTrimVertex *gtlower )
{
for( push(gtlower);
nextlower( gtlower=new(p) GridTrimVertex );
push(gtlower) )
addLower();
addLast();
}
void
Mesher::finishUpper( GridTrimVertex *gtupper )
{
for( push(gtupper);
nextupper( gtupper=new(p) GridTrimVertex );
push(gtupper) )
addUpper();
addLast();
}
void
Mesher::mesh( void )
{
GridTrimVertex *gtlower, *gtupper;
Hull::init( );
nextupper( gtupper = new(p) GridTrimVertex );
nextlower( gtlower = new(p) GridTrimVertex );
clearStack();
openMesh();
push(gtupper);
nextupper( gtupper = new(p) GridTrimVertex );
nextlower( gtlower );
assert( gtupper->t && gtlower->t );
if( gtupper->t->param[0] < gtlower->t->param[0] ) {
push(gtupper);
lastedge = 1;
if( nextupper( gtupper=new(p) GridTrimVertex ) == 0 ) {
finishLower(gtlower);
return;
}
} else if( gtupper->t->param[0] > gtlower->t->param[0] ) {
push(gtlower);
lastedge = 0;
if( nextlower( gtlower=new(p) GridTrimVertex ) == 0 ) {
finishUpper(gtupper);
return;
}
} else {
if( lastedge == 0 ) {
push(gtupper);
lastedge = 1;
if( nextupper(gtupper=new(p) GridTrimVertex) == 0 ) {
finishLower(gtlower);
return;
}
} else {
push(gtlower);
lastedge = 0;
if( nextlower( gtlower=new(p) GridTrimVertex ) == 0 ) {
finishUpper(gtupper);
return;
}
}
}
while ( 1 ) {
if( gtupper->t->param[0] < gtlower->t->param[0] ) {
push(gtupper);
addUpper();
if( nextupper( gtupper=new(p) GridTrimVertex ) == 0 ) {
finishLower(gtlower);
return;
}
} else if( gtupper->t->param[0] > gtlower->t->param[0] ) {
push(gtlower);
addLower();
if( nextlower( gtlower=new(p) GridTrimVertex ) == 0 ) {
finishUpper(gtupper);
return;
}
} else {
if( lastedge == 0 ) {
push(gtupper);
addUpper();
if( nextupper( gtupper=new(p) GridTrimVertex ) == 0 ) {
finishLower(gtlower);
return;
}
} else {
push(gtlower);
addLower();
if( nextlower( gtlower=new(p) GridTrimVertex ) == 0 ) {
finishUpper(gtupper);
return;
}
}
}
}
}
inline int
Mesher::isCcw( int ilast )
{
REAL area = det3( vdata[ilast]->t, vdata[itop-1]->t, vdata[itop-2]->t );
return (area < ZERO) ? 0 : 1;
}
inline int
Mesher::isCw( int ilast )
{
REAL area = det3( vdata[ilast]->t, vdata[itop-1]->t, vdata[itop-2]->t );
return (area > -ZERO) ? 0 : 1;
}
inline int
Mesher::equal( int x, int y )
{
return( last[0] == vdata[x] && last[1] == vdata[y] );
}
inline void
Mesher::copy( int x, int y )
{
last[0] = vdata[x]; last[1] = vdata[y];
}
inline void
Mesher::move( int x, int y )
{
vdata[x] = vdata[y];
}
inline void
Mesher::output( int x )
{
backend.tmeshvert( vdata[x] );
}
/*---------------------------------------------------------------------------
* addedge - addedge an edge to the triangulation
*
* This code has been re-written to generate large triangle meshes
* from a monotone polygon. Although smaller triangle meshes
* could be generated faster and with less code, larger meshes
* actually give better SYSTEM performance. This is because
* vertices are processed in the backend slower than they are
* generated by this code and any decrease in the number of vertices
* results in a decrease in the time spent in the backend.
*---------------------------------------------------------------------------
*/
void
Mesher::addLast( )
{
register int ilast = itop;
if( lastedge == 0 ) {
if( equal( 0, 1 ) ) {
output( ilast );
swapMesh();
for( register int i = 2; i < ilast; i++ ) {
swapMesh();
output( i );
}
copy( ilast, ilast-1 );
} else if( equal( ilast-2, ilast-1) ) {
swapMesh();
output( ilast );
for( register int i = ilast-3; i >= 0; i-- ) {
output( i );
swapMesh();
}
copy( 0, ilast );
} else {
closeMesh(); openMesh();
output( ilast );
output( 0 );
for( register int i = 1; i < ilast; i++ ) {
swapMesh();
output( i );
}
copy( ilast, ilast-1 );
}
} else {
if( equal( 1, 0) ) {
swapMesh();
output( ilast );
for( register int i = 2; i < ilast; i++ ) {
output( i );
swapMesh();
}
copy( ilast-1, ilast );
} else if( equal( ilast-1, ilast-2) ) {
output( ilast );
swapMesh();
for( register int i = ilast-3; i >= 0; i-- ) {
swapMesh();
output( i );
}
copy( ilast, 0 );
} else {
closeMesh(); openMesh();
output( 0 );
output( ilast );
for( register int i = 1; i < ilast; i++ ) {
output( i );
swapMesh();
}
copy( ilast-1, ilast );
}
}
closeMesh();
//for( register long k=0; k<=ilast; k++ ) pop( k );
}
void
Mesher::addUpper( )
{
register int ilast = itop;
if( lastedge == 0 ) {
if( equal( 0, 1 ) ) {
output( ilast );
swapMesh();
for( register int i = 2; i < ilast; i++ ) {
swapMesh();
output( i );
}
copy( ilast, ilast-1 );
} else if( equal( ilast-2, ilast-1) ) {
swapMesh();
output( ilast );
for( register int i = ilast-3; i >= 0; i-- ) {
output( i );
swapMesh();
}
copy( 0, ilast );
} else {
closeMesh(); openMesh();
output( ilast );
output( 0 );
for( register int i = 1; i < ilast; i++ ) {
swapMesh();
output( i );
}
copy( ilast, ilast-1 );
}
lastedge = 1;
//for( register long k=0; k<ilast-1; k++ ) pop( k );
move( 0, ilast-1 );
move( 1, ilast );
itop = 1;
} else {
if( ! isCcw( ilast ) ) return;
do {
itop--;
} while( (itop > 1) && isCcw( ilast ) );
if( equal( ilast-1, ilast-2 ) ) {
output( ilast );
swapMesh();
for( register int i=ilast-3; i>=itop-1; i-- ) {
swapMesh();
output( i );
}
copy( ilast, itop-1 );
} else if( equal( itop, itop-1 ) ) {
swapMesh();
output( ilast );
for( register int i = itop+1; i < ilast; i++ ) {
output( i );
swapMesh();
}
copy( ilast-1, ilast );
} else {
closeMesh(); openMesh();
output( ilast );
output( ilast-1 );
for( register int i=ilast-2; i>=itop-1; i-- ) {
swapMesh();
output( i );
}
copy( ilast, itop-1 );
}
//for( register int k=itop; k<ilast; k++ ) pop( k );
move( itop, ilast );
}
}
void
Mesher::addLower()
{
register int ilast = itop;
if( lastedge == 1 ) {
if( equal( 1, 0) ) {
swapMesh();
output( ilast );
for( register int i = 2; i < ilast; i++ ) {
output( i );
swapMesh();
}
copy( ilast-1, ilast );
} else if( equal( ilast-1, ilast-2) ) {
output( ilast );
swapMesh();
for( register int i = ilast-3; i >= 0; i-- ) {
swapMesh();
output( i );
}
copy( ilast, 0 );
} else {
closeMesh(); openMesh();
output( 0 );
output( ilast );
for( register int i = 1; i < ilast; i++ ) {
output( i );
swapMesh();
}
copy( ilast-1, ilast );
}
lastedge = 0;
//for( register long k=0; k<ilast-1; k++ ) pop( k );
move( 0, ilast-1 );
move( 1, ilast );
itop = 1;
} else {
if( ! isCw( ilast ) ) return;
do {
itop--;
} while( (itop > 1) && isCw( ilast ) );
if( equal( ilast-2, ilast-1) ) {
swapMesh();
output( ilast );
for( register int i=ilast-3; i>=itop-1; i--) {
output( i );
swapMesh( );
}
copy( itop-1, ilast );
} else if( equal( itop-1, itop) ) {
output( ilast );
swapMesh();
for( register int i=itop+1; i<ilast; i++ ) {
swapMesh( );
output( i );
}
copy( ilast, ilast-1 );
} else {
closeMesh(); openMesh();
output( ilast-1 );
output( ilast );
for( register int i=ilast-2; i>=itop-1; i-- ) {
output( i );
swapMesh( );
}
copy( itop-1, ilast );
}
//for( register int k=itop; k<ilast; k++ ) pop( k );
move( itop, ilast );
}
}
| 21.732106
| 77
| 0.56347
|
OpenXIP
|
69baeb7d6ebe81751f6ae3ba6556c8840ebc1edb
| 533
|
cpp
|
C++
|
cpp/11973.cpp
|
jinhan814/BOJ
|
47d2a89a2602144eb08459cabac04d036c758577
|
[
"MIT"
] | 9
|
2021-01-15T13:36:39.000Z
|
2022-02-23T03:44:46.000Z
|
cpp/11973.cpp
|
jinhan814/BOJ
|
47d2a89a2602144eb08459cabac04d036c758577
|
[
"MIT"
] | 1
|
2021-07-31T17:11:26.000Z
|
2021-08-02T01:01:03.000Z
|
cpp/11973.cpp
|
jinhan814/BOJ
|
47d2a89a2602144eb08459cabac04d036c758577
|
[
"MIT"
] | null | null | null |
#include <bits/stdc++.h>
#define fastio cin.tie(0)->sync_with_stdio(0)
using namespace std;
int n, k, v[50'000];
inline bool Check(const int mid) {
int cnt = 0;
for (int i = 0; i < n;) {
const int j = i;
while (i < n && v[i] - v[j] <= mid << 1) i++;
cnt++;
}
return cnt <= k;
}
int main() {
fastio;
cin >> n >> k;
for (int i = 0; i < n; i++) cin >> v[i];
sort(v, v + n);
int lo = -1, hi = 1e9;
while (lo + 1 < hi) {
int mid = lo + hi >> 1;
if (!Check(mid)) lo = mid;
else hi = mid;
}
cout << hi << '\n';
}
| 17.766667
| 47
| 0.497186
|
jinhan814
|
69c1c472367f84931449ade7a28833db0e376d5c
| 890
|
cpp
|
C++
|
sealtk/core/TrackUtils.cpp
|
BetsyMcPhail/seal-tk
|
49eccad75e501450fbb63524062706968f5f3bef
|
[
"BSD-3-Clause"
] | null | null | null |
sealtk/core/TrackUtils.cpp
|
BetsyMcPhail/seal-tk
|
49eccad75e501450fbb63524062706968f5f3bef
|
[
"BSD-3-Clause"
] | null | null | null |
sealtk/core/TrackUtils.cpp
|
BetsyMcPhail/seal-tk
|
49eccad75e501450fbb63524062706968f5f3bef
|
[
"BSD-3-Clause"
] | null | null | null |
/* This file is part of SEAL-TK, and is distributed under the OSI-approved BSD
* 3-Clause License. See top-level LICENSE file or
* https://github.com/Kitware/seal-tk/blob/master/LICENSE for details. */
#include <sealtk/core/TrackUtils.hpp>
#include <vital/range/indirect.h>
#include <qtStlUtil.h>
#include <QVariantHash>
namespace kv = kwiver::vital;
namespace kvr = kwiver::vital::range;
namespace sealtk
{
namespace core
{
// ----------------------------------------------------------------------------
kv::detected_object_type_sptr classificationToDetectedObjectType(
QVariantHash const& in)
{
if (in.isEmpty())
{
return nullptr;
}
auto out = std::make_shared<kv::detected_object_type>();
for (auto const& c : in | kvr::indirect)
{
out->set_score(stdString(c.key()), c.value().toDouble());
}
return out;
}
} // namespace core
} // namespace sealtk
| 21.190476
| 79
| 0.641573
|
BetsyMcPhail
|
69c266b24d7f83d369054b9fdb7489b66410c97b
| 2,524
|
cpp
|
C++
|
two-pointers/3-I.cpp
|
forestLoop/Learning-ITMO-Academy-Pilot-Course
|
b70ea387cb6a7c26871d99ecf7109fd8f0237c3e
|
[
"MIT"
] | 6
|
2021-07-04T08:47:48.000Z
|
2022-01-12T09:34:20.000Z
|
two-pointers/3-I.cpp
|
forestLoop/Learning-ITMO-Academy-Pilot-Course
|
b70ea387cb6a7c26871d99ecf7109fd8f0237c3e
|
[
"MIT"
] | null | null | null |
two-pointers/3-I.cpp
|
forestLoop/Learning-ITMO-Academy-Pilot-Course
|
b70ea387cb6a7c26871d99ecf7109fd8f0237c3e
|
[
"MIT"
] | 2
|
2021-11-24T12:18:58.000Z
|
2022-02-06T00:18:51.000Z
|
// I. Segment with the Required Subset
// https://codeforces.com/edu/course/2/lesson/9/3/practice/contest/307094/problem/I
#include <bitset>
#include <iostream>
#include <stack>
#include <vector>
constexpr int MAX_SUM = 1000;
constexpr int BITSET_SIZE = MAX_SUM + 1;
class KnapsackStack {
public:
KnapsackStack() {
bitsets_.push(1);
}
void Push(int value) {
values_.push(value);
const auto &last = bitsets_.top();
bitsets_.push(last | last << value);
}
int TopVal() const {
return values_.top();
}
std::bitset<BITSET_SIZE> TopBitset() const {
return bitsets_.top();
}
void Pop() {
bitsets_.pop();
values_.pop();
}
bool Empty() const {
return values_.empty();
}
private:
std::stack<int> values_{};
std::stack<std::bitset<BITSET_SIZE>> bitsets_{};
};
bool good(KnapsackStack &stack, KnapsackStack &stack_rev, const int expected_sum) {
const auto &bits1 = stack.TopBitset(), &bits2 = stack_rev.TopBitset();
for (int i = 0; i <= expected_sum; ++i) {
if (bits1[i] && bits2[expected_sum - i]) {
return true;
}
}
return false;
}
void add(KnapsackStack &stack, const int value) {
stack.Push(value);
}
void remove(KnapsackStack &stack, KnapsackStack &stack_rev) {
if (stack_rev.Empty()) {
while (!stack.Empty()) {
stack_rev.Push(stack.TopVal());
stack.Pop();
}
}
stack_rev.Pop();
}
// Time: O(NS)
// Space: O(N)
int min_good_segment(const std::vector<int> &arr, const int expected_sum) {
KnapsackStack stack, stack_rev;
const int n = arr.size();
int res = n + 1;
for (int lo = 0, hi = 0; lo < n; ++lo) {
while (hi < n && !good(stack, stack_rev, expected_sum)) {
add(stack, arr[hi++]);
}
if (hi >= n && !good(stack, stack_rev, expected_sum)) {
break;
}
// hi > lo must hold as expected_sum != 0
res = std::min(res, hi - lo);
remove(stack, stack_rev);
}
return (res > n) ? -1 : res;
}
int main() {
int n, s;
while (std::cin >> n >> s) {
std::vector<int> arr(n);
for (int i = 0; i < n; ++i) {
std::cin >> arr[i];
}
std::cout << min_good_segment(arr, s) << std::endl;
}
return 0;
}
static const auto speedup = []() {
std::ios::sync_with_stdio(false);
std::cin.tie(nullptr);
std::cout.tie(nullptr);
return 0;
}();
| 24.504854
| 83
| 0.554279
|
forestLoop
|
69c44787494404b19eca8b6232646ae83313c677
| 4,925
|
cpp
|
C++
|
Retired_Proj/4_Unmap/unmap.cpp
|
billkarsh/Alignment_Projects
|
f2ce48477da866b09a13fd33f1a53a8af644b35b
|
[
"BSD-3-Clause"
] | 11
|
2015-07-24T14:41:25.000Z
|
2022-03-19T13:27:51.000Z
|
Retired_Proj/4_Unmap/unmap.cpp
|
billkarsh/Alignment_Projects
|
f2ce48477da866b09a13fd33f1a53a8af644b35b
|
[
"BSD-3-Clause"
] | 1
|
2016-05-14T22:26:25.000Z
|
2016-05-14T22:26:25.000Z
|
Retired_Proj/4_Unmap/unmap.cpp
|
billkarsh/Alignment_Projects
|
f2ce48477da866b09a13fd33f1a53a8af644b35b
|
[
"BSD-3-Clause"
] | 18
|
2015-03-10T18:45:58.000Z
|
2021-08-16T13:56:48.000Z
|
#include "File.h"
#include "ImageIO.h"
#include "TAffine.h"
#include <string.h>
// structure for unmapping a global image
struct orig_image {
public:
char *fname;
int w,h;
int xmin, ymin, xmax, ymax; // bounding box in global image of all point that map to this
orig_image(){fname = NULL; xmin = ymin = 1000000000; xmax = ymax = -1000000000;}
orig_image(char *f){fname = f; xmin = ymin = 1000000000; xmax = ymax = -1000000000;}
};
struct one_tform {
public:
int image_id; // which image
TAffine tr; // maps from global space to individual image
};
int main(int argc, char **argv)
{
vector<char *>noa; // non-option arguments
for(int i=1; i<argc; i++) {
// process arguments here
if( argv[i][0] != '-' )
noa.push_back(argv[i]);
else
printf("Ignored option '%s'\n", argv[i]);
}
if( noa.size() < 3 ) {
printf("Usage: unmap <image file> <map file> <file-of-transforms> [<where-to-put>] \n");
exit( 42 );
}
// step 1 - read the image file
uint32 w,h;
uint16* raster = Raster16FromPng(noa[0], w, h);
printf("width is %d, height %d\n", w, h);
// step 2 - read the mapping file
uint32 wm,hm;
uint16* map = Raster16FromPng(noa[1], wm, hm);
printf("width of map is %d, height %d\n", wm, hm);
// Step 3 - read the file of images and transforms
vector<orig_image> images;
vector<one_tform> tforms(1);
FILE *fp = FileOpenOrDie( noa[2], "r" );
{
CLineScan LS;
for(;;) {
if( LS.Get( fp ) <= 0 )
break;
if(strncmp(LS.line,"IMAGE",5) == 0) {
int id;
char fname[2048];
sscanf(LS.line+5, "%d %s", &id, fname);
printf("id %3d name %s\n", id, fname);
if( id != images.size() ) {
printf("Oops - bad image sequence number %d\n", id);
return 42;
}
images.push_back(orig_image(strdup(strtok(fname," '\n"))));
}
else if(strncmp(LS.line,"TRANS",5) == 0) {
int id, image_no;
double a,b,c,d,e,f;
sscanf(LS.line+5,"%d %d %lf %lf %lf %lf %lf %lf", &id, &image_no, &a, &b, &c, &d, &e, &f);
if( id != tforms.size() ) {
printf("Oops - bad transform sequence number %d\n", id);
return 42;
}
one_tform o;
o.image_id = image_no;
o.tr = TAffine(a,b,c,d,e,f);
tforms.push_back(o);
}
else {
printf("UNknown line %s\n", LS.line);
}
}
}
fclose(fp);
// OK, find the bounding bozes for all the images
for(int y=0; y<h; y++) {
for(int x=0; x<w; x++) {
uint16 t = map[x + w*y];
if( t != 0 ) {
int im = tforms[t].image_id;
images[im].xmin = min(images[im].xmin, x);
images[im].ymin = min(images[im].ymin, y);
images[im].xmax = max(images[im].xmax, x);
images[im].ymax = max(images[im].ymax, y);
}
}
}
//Now compute each image one at a time
for(int i=0; i<images.size(); i++) {
int x0 = images[i].xmin;
int x1 = images[i].xmax;
int y0 = images[i].ymin;
int y1 = images[i].ymax;
printf("Image %d, x=[%6d %6d] y = [%6d %6d]\n", i, x0, x1, y0, y1);
uint32 w, h;
//uint8* junk = Raster8FromTif( images[i].fname, w, h );
//RasterFree(junk);
vector<uint8> recon_raster(w*h,0); // create an empty raster
printf("Original size was %d wide by %d tall\n", w, h);
for(int y=y0; y<=y1; y++) {
for(int x=x0; x<=x1; x++) {
uint16 t = map[x + wm*y];
if( t != 0 && tforms[t].image_id == i ) { // maps to image i
Point pt(x,y);
tforms[t].tr.Transform( pt );
if( x == 8557 && y == 431 ) { // just for debugging
printf("X and Y in original image: %d %d. Pixel value is %d\n", x, y, t);
printf("Image id is %d. Transformation is", tforms[t].image_id);
tforms[t].tr.TPrint();
printf("Point in image: x=%f y=%f\n", pt.x, pt.y);
}
// This should be within the image, but double check
if( pt.x > -0.5 && pt.x < w-0.5 && pt.y > -0.5 && pt.y < h-0.5 ) { // it will round to a legal value
int ix = int(pt.x+0.5);
int iy = int(pt.y+0.5);
recon_raster[ix + w*iy] = raster[x + wm*y];
}
else {
printf("X and Y in original image: %d %d. Pixel value is %d\n", x, y, t);
printf("Image id is %d. Transformation is", tforms[t].image_id);
tforms[t].tr.TPrint();
printf("Point out of image: x=%f y=%f\n", pt.x, pt.y);
//return 42;
}
}
}
}
char fname[256];
sprintf(fname,"/tmp/%d.png", i);
Raster8ToPng8(fname, &recon_raster[0], w, h);
}
return 0;
}
| 30.974843
| 116
| 0.503959
|
billkarsh
|
69c599470a13c2e342ab128a7a880c640282ced4
| 4,489
|
cpp
|
C++
|
demos/dox/index/mummy.cpp
|
h-2/SeqAnHTS
|
a1923897fe1bd359136cfd09f0d4c245978c0fce
|
[
"BSD-3-Clause"
] | 409
|
2015-01-12T22:02:01.000Z
|
2022-03-29T06:17:05.000Z
|
demos/dox/index/mummy.cpp
|
h-2/SeqAnHTS
|
a1923897fe1bd359136cfd09f0d4c245978c0fce
|
[
"BSD-3-Clause"
] | 1,269
|
2015-01-02T22:42:25.000Z
|
2022-03-08T13:31:46.000Z
|
demos/dox/index/mummy.cpp
|
h-2/SeqAnHTS
|
a1923897fe1bd359136cfd09f0d4c245978c0fce
|
[
"BSD-3-Clause"
] | 193
|
2015-01-14T16:21:27.000Z
|
2022-03-19T22:47:02.000Z
|
#include <iostream>
#include <fstream>
#include <seqan/index.h>
#include <seqan/seq_io.h>
using namespace seqan;
template <typename TIndex>
void findMUMs(TIndex & esa, unsigned minLen)
{
typename Iterator<TIndex, Mums>::Type it(esa, minLen); // set minimum MUM length
String<typename SAValue<TIndex>::Type> occs; // temp. string storing the hit positions
std::cout << std::resetiosflags(std::ios::left);
while (!atEnd(it))
{
occs = getOccurrences(it); // gives hit positions (seqNo,seqOfs)
orderOccurrences(occs); // order them by seqNo
for (unsigned i = 0; i < length(occs); ++i)
std::cout << std::setw(8)
<< getValueI2(occs[i]) + 1 // output them in MUMmer's output format
<< " ";
std::cout << std::setw(8)
<< repLength(it)
<< "\n";
++it;
}
std::cout << std::setiosflags(std::ios::left) << "\n";
}
template <typename TSpec>
int runMummy(int argc, const char * argv[], unsigned seqCount, unsigned minLen)
{
typedef String<Dna5, TSpec> TString;
typedef StringSet<TString> TStringSet;
typedef Index<TStringSet> TIndex;
TIndex index;
// import sequences
StringSet<CharString> meta;
for (int arg = 1, seq = 0; arg < argc; ++arg)
{
// skip two argument options
if (strcmp(argv[arg], "-p") == 0 || strcmp(argv[arg], "--profile") == 0 ||
strcmp(argv[arg], "-l") == 0 || strcmp(argv[arg], "--minlen") == 0)
{
++arg;
continue;
}
if (argv[arg][0] != '-')
{
SeqFileIn file;
if (!open(file, argv[arg]))
{
std::cout << "Import of sequence " << argv[arg] << " failed.\n";
return 1;
}
readRecords(meta, indexText(index), file);
clear(meta);
close(file);
++seq;
}
}
std::cout << lengthSum(indexText(index)) << " bps sequence imported.\n";
findMUMs(index, minLen);
return 0;
}
void printHelp(int, const char *[], bool longHelp = false)
{
std::cout << "***************************************\n";
std::cout << "*** Simple MUM finder ***\n";
std::cout << "*** written by David Weese (c) 2007 ***\n";
std::cout << "***************************************\n\n";
std::cout << "Usage: mummy [OPTION]... <SEQUENCE FILE> ... <SEQUENCE FILE>\n";
if (longHelp)
{
std::cout << "\nOptions:\n";
std::cout << " -e, --extern \tuse external memory (for large datasets)\n";
std::cout << " -l, --minlen \tset minimum MUM length\n";
std::cout << " \tif not set, default value is 20\n";
std::cout << " -h, --help \tprint this help\n";
}
else
{
std::cout << "Try 'mummy --help' for more information.\n";
}
}
int main(int argc, const char * argv[])
{
if (argc < 2)
{
printHelp(argc, argv);
return 0;
}
unsigned optMinLen = 20;
bool optExtern = false;
unsigned seqCount = 0;
for (int arg = 1; arg < argc; ++arg)
{
if (argv[arg][0] == '-')
{
// parse option
if (strcmp(argv[arg], "-e") == 0 || strcmp(argv[arg], "--extern") == 0)
{
// use external memory algorithms
optExtern = true;
continue;
}
if (strcmp(argv[arg], "-l") == 0 || strcmp(argv[arg], "--minlen") == 0)
{
// minimum match length
if (arg + 1 == argc)
{
printHelp(argc, argv);
return 0;
}
++arg;
optMinLen = atoi(argv[arg]);
continue;
}
if (strcmp(argv[arg], "-h") == 0 || strcmp(argv[arg], "--help") == 0)
{
// print help
printHelp(argc, argv, true);
return 0;
}
}
else
{
// parse sequence file
++seqCount;
}
}
if (optExtern)
return runMummy<External<> >(argc, argv, seqCount, optMinLen);
else
return runMummy<Alloc<> >(argc, argv, seqCount, optMinLen);
}
| 29.339869
| 101
| 0.456672
|
h-2
|
69ca23742bc0f6e2b542a9f6253860cb03a2ef3f
| 59,067
|
cc
|
C++
|
src/table_file.cc
|
LaudateCorpus1/Jungle-2
|
20b80ddaa2cd2e382e3ffd9e79e7d623e29a7f7c
|
[
"Apache-2.0"
] | 157
|
2019-12-27T18:12:19.000Z
|
2022-03-27T13:34:52.000Z
|
src/table_file.cc
|
LaudateCorpus1/Jungle-2
|
20b80ddaa2cd2e382e3ffd9e79e7d623e29a7f7c
|
[
"Apache-2.0"
] | 11
|
2020-01-02T18:30:33.000Z
|
2021-09-28T03:10:09.000Z
|
src/table_file.cc
|
LaudateCorpus1/Jungle-2
|
20b80ddaa2cd2e382e3ffd9e79e7d623e29a7f7c
|
[
"Apache-2.0"
] | 32
|
2019-12-28T18:17:27.000Z
|
2021-12-24T02:05:10.000Z
|
/************************************************************************
Copyright 2017-2019 eBay 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
https://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 "table_file.h"
#include "bloomfilter.h"
#include "db_mgr.h"
#include "internal_helper.h"
#include "table_mgr.h"
#include <third_party/forestdb/include/libforestdb/fdb_types.h>
#include _MACRO_TO_STR(LOGGER_H)
namespace jungle {
static inline fdb_compact_decision fdb_cb_bridge
( fdb_file_handle *fhandle,
fdb_compaction_status status,
const char *kv_store_name,
fdb_doc *doc,
uint64_t last_oldfile_offset,
uint64_t last_newfile_offset,
void *ctx)
{
CompactionCbParams params;
params.rec.kv.key = SizedBuf(doc->keylen, doc->key);
params.rec.kv.value = SizedBuf(doc->bodylen, doc->body);
params.rec.meta = SizedBuf(doc->metalen, doc->meta);
params.rec.seqNum = doc->seqnum;
const DBConfig* db_config = (const DBConfig*)(ctx);
CompactionCbDecision dec = db_config->compactionCbFunc(params);
if (dec == CompactionCbDecision::DROP) return FDB_CS_DROP_DOC;
return FDB_CS_KEEP_DOC;
}
static inline void fdb_log_cb(int level,
int ec,
const char* file,
const char* func,
size_t line,
const char* err_msg,
void* ctx)
{
SimpleLogger* my_log = (SimpleLogger*)ctx;
my_log->put(level, file, func, line, "[FDB][%d] %s", ec, err_msg);
}
TableFile::FdbHandle::FdbHandle(TableFile* _parent,
const DBConfig* db_config,
const TableFileOptions& t_file_opt)
: parent(_parent)
, dbConfig(db_config)
, tFileOpt(t_file_opt)
, dbFile(nullptr)
, db(nullptr)
, config(getFdbSettings(db_config))
, kvsConfig(getKvsSettings())
{}
TableFile::FdbHandle::~FdbHandle() {
close();
}
fdb_config TableFile::FdbHandle::getFdbSettings(const DBConfig* db_config) {
fdb_config config = fdb_get_default_config();
DBMgr* mgr = DBMgr::getWithoutInit();
if (mgr) {
config.buffercache_size = mgr->getGlobalConfig()->fdbCacheSize;
fdb_set_log_callback_ex_global(fdb_log_cb,
mgr->getLogger());
}
// FIXME: `bulkLoading` should be deprecated.
(void)db_config->bulkLoading;
// NOTE:
// We enable "WAL flush before commit" option to reduce memory
// pressure, and those uncommitted data will not be seen by
// user since we set `do_not_search_wal` option.
//
// We also enable `bulk_load_mode` always on, as we don't want to
// keep dirty B+tree nodes in memory, that brings unnecessary
// memcpy overhead.
config.wal_flush_before_commit = true;
config.bulk_load_mode = true;
config.do_not_search_wal = true;
if (!db_config->directIoOpt.enabled) {
// NOTE:
// During compaction, Jungle manually reads records and copies it
// to new file, which may spoil the block cache of ForestDB,
// due to unnecessary doc block caching that will not be read again.
// We should disable caching doc block.
config.do_not_cache_doc_blocks = true;
config.num_blocks_readahead = 0;
} else {
// Direct-IO mode.
config.do_not_cache_doc_blocks = false;
config.durability_opt = FDB_DRB_ODIRECT;
config.num_blocks_readahead = db_config->directIoOpt.readaheadSize / 4096;
}
// Disable auto compaction,
// temporarily enable block reuse.
config.compaction_threshold = 0;
if ( db_config->blockReuseFactor &&
db_config->blockReuseFactor > 100 ) {
size_t F = db_config->blockReuseFactor;
// 300% -> 66.6% stale ratio.
// 333% -> 70% stale ratio.
config.block_reusing_threshold = (F - 100) * 100 / F;
} else {
// Disabled.
config.block_reusing_threshold = 100;
}
config.max_block_reusing_cycle = db_config->maxBlockReuseCycle;
config.min_block_reuse_filesize = tFileOpt.minBlockReuseFileSize;
config.seqtree_opt = FDB_SEQTREE_USE;
config.purging_interval = 0; // Disable.
config.num_keeping_headers = 10;
config.do_not_move_to_compacted_file = true;
//config.enable_reusable_block_reservation = true;
// If compaction callback function is given, enable it.
if (db_config->compactionCbFunc) {
config.compaction_cb = fdb_cb_bridge;
config.compaction_cb_ctx = (void*)db_config;
// Callback function will be invoked for every document.
config.compaction_cb_mask = FDB_CS_MOVE_DOC;
}
// We SHOULD have at least one ForestDB background compactor,
// to do lazy file deletion.
// NOTE:
// We can also disable both compactor and lazy deletion,
// but deleting large size file may have bad impact on latency,
// as foreground deletion usually happens on close of iterator.
config.enable_background_compactor = true;
config.num_compactor_threads = 1;
size_t upper_prime = PrimeNumber::getUpper(db_config->numExpectedUserThreads);
config.num_wal_partitions = upper_prime;
config.num_bcache_partitions = upper_prime;
config.log_msg_level = 4;
return config;
}
fdb_kvs_config TableFile::FdbHandle::getKvsSettings() {
return fdb_get_default_kvs_config();
}
void TableFile::FdbHandle::refreshSettings() {
config = getFdbSettings(dbConfig);
kvsConfig = getKvsSettings();
}
Status TableFile::FdbHandle::open(const std::string& filename) {
fdb_status fs;
fs = fdb_open(&dbFile, filename.c_str(), &config);
if (fs != FDB_RESULT_SUCCESS) return Status::FDB_OPEN_FILE_FAIL;
fs = fdb_kvs_open(dbFile, &db, NULL, &kvsConfig);
if (fs != FDB_RESULT_SUCCESS) return Status::FDB_OPEN_KVS_FAIL;
return Status();
}
Status TableFile::FdbHandle::openCustomCmp(const std::string& filename,
fdb_custom_cmp_variable cmp_func,
void* cmp_func_param)
{
fdb_status fs;
char* kvs_names[1] = {nullptr};
fdb_custom_cmp_variable functions[1] = {cmp_func};
void* user_params[1] = {cmp_func_param};
fs = fdb_open_custom_cmp(&dbFile, filename.c_str(), &config,
1, kvs_names, functions, user_params);
if (fs != FDB_RESULT_SUCCESS) return Status::FDB_OPEN_FILE_FAIL;
fs = fdb_kvs_open(dbFile, &db, NULL, &kvsConfig);
if (fs != FDB_RESULT_SUCCESS) return Status::FDB_OPEN_KVS_FAIL;
return Status();
}
Status TableFile::FdbHandle::commit() {
fdb_status fs;
fs = fdb_commit(dbFile, FDB_COMMIT_MANUAL_WAL_FLUSH);
if (fs != FDB_RESULT_SUCCESS) return Status::FDB_COMMIT_FAIL;
return Status();
}
Status TableFile::FdbHandle::close() {
fdb_status fs = FDB_RESULT_SUCCESS;
if (db) {
fs = fdb_kvs_close(db);
if (fs != FDB_RESULT_SUCCESS) return Status::FDB_KVS_CLOSE_FAIL;
db = nullptr;
}
if (dbFile) {
fdb_close(dbFile);
if (fs != FDB_RESULT_SUCCESS) return Status::FDB_CLOSE_FAIL;
dbFile = nullptr;
}
return Status();
}
TableFile::FdbHandleGuard::FdbHandleGuard( TableFile* _t_file,
FdbHandle* _handle )
: tFile(_t_file), handle(_handle)
{}
TableFile::FdbHandleGuard::~FdbHandleGuard() {
if (handle) tFile->returnHandle(handle);
}
TableFile::TableFile(const TableMgr* table_mgr)
: myNumber(NOT_INITIALIZED)
, fOps(nullptr)
, tableMgr(table_mgr)
, tableInfo(nullptr)
, writer(nullptr)
, bfByKey(nullptr)
, tlbByKey(nullptr)
, myLog(nullptr)
{}
TableFile::~TableFile() {
assert(snapHandles.size() == 0);
{ std::lock_guard<std::mutex> l(latestSnapshotLock);
for (Snapshot*& cur_snp: latestSnapshot) {
// Remaining snapshot's reference counter should be 1,
// which is referred to by this file.
// Note that all iterators derived from this file
// should be closed before calling this destructor.
assert(cur_snp->refCount == 1);
fdb_kvs_close(cur_snp->fdbSnap);
delete cur_snp;
}
}
if (writer) {
DELETE(writer);
}
for (auto& entry: readers) {
delete entry;
}
DELETE(bfByKey);
DELETE(tlbByKey);
}
std::string TableFile::getTableFileName(const std::string& path,
uint64_t prefix_num,
uint64_t table_file_num)
{
// Table file name example: table0001_00000001
// table0001_00000002
// ...
char p_num[16];
char t_num[16];
sprintf(p_num, "%04" PRIu64, prefix_num);
sprintf(t_num, "%08" PRIu64, table_file_num);
std::string t_filename = path + "/table" + p_num + "_" + t_num;
return t_filename;
}
TableFile::FdbHandle* TableFile::getIdleHandle() {
mGuard l(readersLock);
FdbHandle* ret = nullptr;
auto entry = readers.begin();
if (entry == readers.end()) {
l.unlock();
ret = new FdbHandle(this, tableMgr->getDbConfig(), myOpt);
openFdbHandle(tableMgr->getDbConfig(), filename, ret);
l.lock();
} else {
ret = *entry;
readers.pop_front();
}
return ret;
}
void TableFile::returnHandle(FdbHandle* f_handle) {
mGuard l(readersLock);
readers.push_front(f_handle);
}
Status TableFile::openFdbHandle(const DBConfig* db_config,
const std::string& f_name,
FdbHandle* f_handle)
{
Status s;
if (db_config->cmpFunc) {
// Custom cmp mode.
EP( f_handle->openCustomCmp( f_name,
db_config->cmpFunc,
db_config->cmpFuncParam ) );
} else {
EP( f_handle->open(f_name) );
}
return Status::OK;
}
uint64_t TableFile::getBfSizeByLevel(const DBConfig* db_config, size_t level) {
uint64_t MAX_TABLE_SIZE = db_config->getMaxTableSize(level);
uint64_t bf_bitmap_size = MAX_TABLE_SIZE / 1024 *
db_config->bloomFilterBitsPerUnit;
return bf_bitmap_size;
}
uint64_t TableFile::getBfSizeByWss(const DBConfig* db_config, uint64_t wss) {
uint64_t bf_bitmap_size = wss / 1024 *
db_config->bloomFilterBitsPerUnit;
return bf_bitmap_size;
}
uint64_t TableFile::getBfSize() const {
if (!bfByKey) return 0;
return bfByKey->size();
}
void TableFile::initBooster(size_t level, const DBConfig* db_config) {
uint64_t limit = tableMgr->getBoosterLimit(level);
if (!limit) return;
tlbByKey = new TableLookupBooster( limit, tableMgr, this );
}
Status TableFile::create(size_t level,
uint64_t table_number,
const std::string& f_name,
FileOps* f_ops,
const TableFileOptions& opt)
{
if (writer) return Status::ALREADY_INITIALIZED;
Status s;
filename = f_name;
myNumber = table_number;
fOps = f_ops;
myOpt = opt;
if (fOps->exist(filename)) {
// Previous file exists, which means that there is a legacy log file.
// We should overwrite it.
_log_warn(myLog, "table %s already exists, remove it", filename.c_str());
fOps->remove(filename);
}
const DBConfig* db_config = tableMgr->getDbConfig();
// Create a ForestDB file.
writer = new FdbHandle(this, tableMgr->getDbConfig(), myOpt);
EP( openFdbHandle(db_config, filename, writer) );
// Bloom filter (LSM mode only).
if ( db_config->bloomFilterBitsPerUnit > 0.0 &&
!bfByKey ) {
uint64_t bf_bitmap_size = myOpt.bloomFilterSize;
if (!bf_bitmap_size) bf_bitmap_size = getBfSizeByLevel(db_config, level);
bfByKey = new BloomFilter(bf_bitmap_size, 3);
// Initial save.
saveBloomFilter(filename + ".bf", bfByKey, true);
}
// Lookup booster.
initBooster(level, db_config);
// Initial commit.
EP( writer->commit() );
updateSnapshot();
return Status();
}
Status TableFile::load(size_t level,
uint64_t table_number,
const std::string& f_name,
FileOps* f_ops,
const TableFileOptions& opt)
{
if (writer) return Status::ALREADY_INITIALIZED;
if (!f_ops->exist(f_name.c_str())) return Status::FILE_NOT_EXIST;
Status s;
filename = f_name;
myNumber = table_number;
fOps = f_ops;
myOpt = opt;
const DBConfig* db_config = tableMgr->getDbConfig();
// Handle for writer.
writer = new FdbHandle(this, tableMgr->getDbConfig(), myOpt);
EP( openFdbHandle(db_config, filename, writer) );
// Bloom filter (LSM mode only).
if ( db_config->bloomFilterBitsPerUnit > 0.0 &&
!bfByKey ) {
std::string bf_filename = filename + ".bf";
loadBloomFilter(bf_filename, bfByKey);
}
// Lookup booster.
initBooster(level, db_config);
// Pre-load snapshot.
updateSnapshot();
return Status();
}
Status TableFile::loadBloomFilter(const std::string& filename,
BloomFilter*& bf_out)
{
// Bloom filter file doesn't exist, just OK.
if (!fOps->exist(filename)) {
bf_out = nullptr;
return Status::OK;
}
Status s;
FileHandle* b_file = nullptr;
EP( fOps->open(&b_file, filename.c_str()) );
try {
size_t file_size = fOps->eof(b_file);
if (!file_size) throw Status();
SizedBuf header( sizeof(uint32_t) * 2 );
SizedBuf::Holder h_header(header);
SizedBuf buf(file_size - header.size);
TC( fOps->pread(b_file, header.data, header.size, 0) );
RwSerializer ss(header);
// << Format >>
// Version 4 bytes
// Length (X) 4 bytes
// Bitmap X bytes
uint32_t ver = ss.getU32(s);
(void)ver;
uint32_t data_size = ss.getU32();
(void)data_size;
assert(data_size == buf.size);
TC( fOps->pread(b_file, buf.data, data_size, header.size) );
bf_out = new BloomFilter(0, 3);
// Memory region of `buf` will be moved to Bloom filter.
bf_out->moveBitmapFrom(buf.data, buf.size);
EP( fOps->close(b_file) );
DELETE(b_file);
return Status::OK;
} catch (Status s) {
EP( fOps->close(b_file) );
DELETE(b_file);
return Status::OK;
}
}
Status TableFile::saveBloomFilter(const std::string& filename,
BloomFilter* bf,
bool call_fsync)
{
if (filename.empty() || !bf || !bf->size()) return Status::OK;
Status s;
FileHandle* b_file = nullptr;
EP( fOps->open(&b_file, filename.c_str()) );
try {
size_t data_size = bf->size() / 8;
SizedBuf buf( sizeof(uint32_t) * 2);
SizedBuf::Holder h_buf(buf);
RwSerializer ss(buf);
ss.putU32(0);
ss.putU32(data_size);
TC( fOps->pwrite(b_file, buf.data, buf.size, 0) );
TC( fOps->pwrite(b_file, bf->getPtr(), data_size, buf.size) );
if (call_fsync) fOps->fsync(b_file);
EP( fOps->close(b_file) );
DELETE(b_file);
return Status::OK;
} catch (Status s) {
EP( fOps->close(b_file) );
DELETE(b_file);
return Status::OK;
}
}
Status TableFile::changeOptions(const TableFileOptions& new_opt) {
Status s;
_log_info(myLog, "table %zu_%zu changed minBlockReuseFileSize %zu -> %zu",
tableMgr->getTableMgrOptions()->prefixNum, myNumber,
myOpt.minBlockReuseFileSize, new_opt.minBlockReuseFileSize);
myOpt = new_opt;
// Close and reopen to apply the new configuration.
writer->close();
writer->refreshSettings();
EP( openFdbHandle(tableMgr->getDbConfig(), filename, writer) );
return Status();
}
Status TableFile::openSnapshot(DB* snap_handle,
const uint64_t checkpoint)
{
Status s;
uint64_t snap_seqnum = 0;
bool clone_from_latest = false;
{ mGuard l(chkMapLock);
auto entry = chkMap.find(checkpoint);
if (entry == chkMap.end()) {
// Exact match doesn't exist.
auto e_max = chkMap.rbegin();
if ( e_max == chkMap.rend() ||
checkpoint > e_max->second ) {
// Beyond the table's checkpoint.
// Take the latest marker.
clone_from_latest = true;
} else {
// Find greatest one smaller than chk.
auto entry = chkMap.begin();
while (entry != chkMap.end()) {
if (entry->first <= checkpoint) {
snap_seqnum = entry->second;
}
entry++;
}
}
} else {
// Exact match exists.
snap_seqnum = entry->second;
}
}
if (!clone_from_latest && !snap_seqnum) return Status::INVALID_CHECKPOINT;
fdb_status fs;
fdb_kvs_handle* fdbSnap = nullptr;
if (clone_from_latest) {
// Clone snapshot from the latest one.
Snapshot* snp = nullptr;
leaseSnapshot(snp);
fs = fdb_snapshot_open(snp->fdbSnap, &fdbSnap, snp->fdbSeqnum);
returnSnapshot(snp);
} else {
// Otherwise: open snapshot based on seq number.
FdbHandleGuard g(this, getIdleHandle());
fdb_kvs_handle* kvs_db = g.handle->db;
fs = fdb_snapshot_open(kvs_db, &fdbSnap, snap_seqnum);
}
if (fs != FDB_RESULT_SUCCESS) return Status::FDB_OPEN_KVS_FAIL;
{ mGuard l(snapHandlesLock);
snapHandles.insert( std::make_pair(snap_handle, fdbSnap) );
}
return Status();
}
Status TableFile::closeSnapshot(DB* snap_handle) {
Status s;
fdb_kvs_handle* fdb_snap = nullptr;
{ mGuard l(snapHandlesLock);
auto entry = snapHandles.find(snap_handle);
if (entry == snapHandles.end()) return Status::INVALID_SNAPSHOT;
fdb_snap = entry->second;
snapHandles.erase(entry);
}
fdb_status fs = fdb_kvs_close(fdb_snap);
if (fs != FDB_RESULT_SUCCESS) return Status::FDB_CLOSE_FAIL;
return Status();
}
void TableFile::addCheckpoint(uint64_t chk, uint64_t commit_seqnum) {
if (tableInfo) {
_log_info(myLog, "file lv %zu num %zu hash %zu checkpoint %zu %zu",
tableInfo->level, tableInfo->number, tableInfo->hashNum,
chk, commit_seqnum);
}
const DBConfig* db_config = tableMgr->getDbConfig();
mGuard l(chkMapLock);
chkMap.insert( std::make_pair(chk, commit_seqnum) );
// Remove old checkpoints if it exceeds the limit.
while (chkMap.size() > db_config->maxKeepingCheckpoints) {
auto entry = chkMap.begin();
if (entry == chkMap.end()) break;
chkMap.erase(entry);
}
}
Status TableFile::setCheckpoint(Record* rec,
uint64_t prev_seqnum,
std::list<uint64_t>& checkpoints,
bool remaining_all)
{
Status s;
for (auto& chk_entry: checkpoints) {
uint64_t chk = chk_entry;
if ( prev_seqnum == chk ||
(prev_seqnum < chk && rec && chk < rec->seqNum) ||
(prev_seqnum <= chk && remaining_all) ) {
// Commit for the checkpoint.
fdb_seqnum_t commit_seqnum;
fdb_get_kvs_seqnum(writer->db, &commit_seqnum);
EP( writer->commit() );
addCheckpoint(chk, commit_seqnum);
}
if (chk > prev_seqnum && rec && chk > rec->seqNum) break;
}
return Status();
}
void TableFile::userMetaToRawMeta(const SizedBuf& user_meta,
const InternalMeta& internal_meta,
SizedBuf& raw_meta_out)
{
// Add 9+ bytes in front:
// identifier 1 byte
// version 4 bytes
// flags 4 bytes
// [ original value length 4 bytes ] only if compressed
// NOTE: Even though `user_meta` is empty, we should put 9 bytes.
const size_t I_META_SIZE = getInternalMetaLen(internal_meta);
if (!raw_meta_out.size) {
raw_meta_out.alloc(user_meta.size + I_META_SIZE);
}
RwSerializer rw(raw_meta_out);
// Put 0x1 as an identifier.
rw.putU8(0x1);
// Version 1.
rw.putU32(0x0);
// Flags.
uint32_t flags = 0x0;
if (internal_meta.isTombstone) flags |= TF_FLAG_TOMBSTONE;
if (internal_meta.isCompressed) flags |= TF_FLAG_COMPRESSED;
rw.putU32(flags);
// Original value length (if compressed).
if (internal_meta.isCompressed) {
rw.putU32(internal_meta.originalValueLen);
}
// User meta.
rw.put(user_meta.data, user_meta.size);
}
void TableFile::rawMetaToUserMeta(const SizedBuf& raw_meta,
InternalMeta& internal_meta_out,
SizedBuf& user_meta_out)
{
if (raw_meta.empty()) return;
RwSerializer rw(raw_meta);
// Check identifier.
uint8_t identifier = rw.getU8();
if (identifier != 0x1) {
// No conversion.
raw_meta.copyTo(user_meta_out);
return;
}
// Version.
uint32_t version = rw.getU32();
(void)version; // TODO: version.
// Flags.
uint32_t flags = rw.getU32();
if (flags & TF_FLAG_TOMBSTONE) internal_meta_out.isTombstone = true;
if (flags & TF_FLAG_COMPRESSED) internal_meta_out.isCompressed = true;
if (internal_meta_out.isCompressed) {
// Original value length (if compressed).
internal_meta_out.originalValueLen = rw.getU32();
}
// User meta.
if (rw.pos() >= raw_meta.size) {
// Empty user meta.
return;
}
user_meta_out.alloc(raw_meta.size - rw.pos());
rw.get(user_meta_out.data, user_meta_out.size);
}
void TableFile::readInternalMeta(const SizedBuf& raw_meta,
InternalMeta& internal_meta_out)
{
if (raw_meta.empty()) return;
RwSerializer rw(raw_meta);
// Check identifier.
uint8_t identifier = rw.getU8();
if (identifier != 0x1) {
// No conversion.
return;
}
// Version.
uint32_t version = rw.getU32();
(void)version; // TODO: version.
// Flags.
uint32_t flags = rw.getU32();
if (flags & TF_FLAG_TOMBSTONE) internal_meta_out.isTombstone = true;
if (flags & TF_FLAG_COMPRESSED) internal_meta_out.isCompressed = true;
if (internal_meta_out.isCompressed) {
// Original value length (if compressed).
internal_meta_out.originalValueLen = rw.getU32();
}
}
uint32_t TableFile::tfExtractFlags(const SizedBuf& raw_meta) {
RwSerializer rw(raw_meta);
rw.getU8();
rw.getU32();
return rw.getU32();
}
bool TableFile::tfIsTombstone(uint32_t flags) {
return (flags & TF_FLAG_TOMBSTONE);
}
bool TableFile::tfIsCompressed(uint32_t flags) {
return (flags & TF_FLAG_COMPRESSED);
}
Status TableFile::sync() {
fdb_status fs = fdb_sync_file(writer->dbFile);
if (fs != FDB_RESULT_SUCCESS) return Status::FDB_COMMIT_FAIL;
return Status();
}
size_t TableFile::getInternalMetaLen(const InternalMeta& meta) {
return sizeof(uint8_t) + // Identifier
sizeof(uint32_t) + // Version
sizeof(uint32_t) + // Flags
(meta.isCompressed ? sizeof(uint32_t) : 0); // Length (if compressed)
}
Status TableFile::setSingle(uint32_t key_hash_val,
const Record& rec,
uint64_t& offset_out,
bool set_as_it_is,
bool is_last_level,
bool force_delete)
{
fdb_doc doc;
fdb_status fs;
fdb_kvs_handle* kvs_db = writer->db;
memset(&doc, 0x0, sizeof(doc));
doc.key = rec.kv.key.data;
doc.keylen = rec.kv.key.size;
DB* parent_db = tableMgr->getParentDb();
const DBConfig* db_config = tableMgr->getDbConfig();
const bool COMPRESSION = tableMgr->isCompressionEnabled();
InternalMeta i_meta;
i_meta.isTombstone = rec.isDel();
const size_t TMP_BUF_SIZE = 512;
char tmp_buf[TMP_BUF_SIZE];
SizedBuf raw_meta_static;
SizedBuf raw_meta_alloc;
SizedBuf::Holder h_raw_meta(raw_meta_alloc);
size_t original_value_size = rec.kv.value.size;
ssize_t comp_buf_size = 0; // Output buffer size.
ssize_t comp_size = 0; // Actual compressed size.
// Local compression buffer to avoid frequent memory allocation.
const ssize_t LOCAL_COMP_BUF_SIZE = 4096;
char local_comp_buf[LOCAL_COMP_BUF_SIZE];
SizedBuf comp_buf;
SizedBuf::Holder h_comp_buf(comp_buf);
// Refer to the local buffer by default.
comp_buf.referTo( SizedBuf(LOCAL_COMP_BUF_SIZE, local_comp_buf) );
if (set_as_it_is) {
// Store the given meta as it is.
doc.meta = rec.meta.data;
doc.metalen = rec.meta.size;
} else {
// Otherwise: prepend internal meta and do compression if enabled.
if (COMPRESSION && !i_meta.isTombstone) {
// If compression is enabled, ask if we compress this record.
comp_buf_size = db_config->compOpt.cbGetMaxSize(parent_db, rec);
if (comp_buf_size > 0) {
if (comp_buf_size > LOCAL_COMP_BUF_SIZE) {
// Bigger than the local buffer size, allocate a new.
comp_buf.alloc(comp_buf_size);
}
// Do compression.
comp_size = db_config->compOpt.cbCompress(parent_db, rec, comp_buf);
if (comp_size > 0) {
// Compression succeeded, set the flag.
i_meta.isCompressed = true;
i_meta.originalValueLen = original_value_size;
} else if (comp_size < 0) {
_log_err( myLog, "compression failed: %zd, db %s, key %s",
comp_size,
parent_db->getPath().c_str(),
rec.kv.key.toReadableString().c_str() );
}
// Otherwise: if `comp_size == 0`,
// that implies cancelling compression.
}
}
const size_t INTERNAL_META_SIZE = getInternalMetaLen(i_meta);
if (rec.meta.size + INTERNAL_META_SIZE < TMP_BUF_SIZE) {
// Use `tmp_buf`.
raw_meta_static.referTo
( SizedBuf(rec.meta.size + INTERNAL_META_SIZE, tmp_buf) );
userMetaToRawMeta(rec.meta, i_meta, raw_meta_static);
doc.meta = raw_meta_static.data;
doc.metalen = raw_meta_static.size;
} else {
// Metadata is too big. Allocate a new.
userMetaToRawMeta(rec.meta, i_meta, raw_meta_alloc);
doc.meta = raw_meta_alloc.data;
doc.metalen = raw_meta_alloc.size;
}
}
if (i_meta.isCompressed) {
doc.body = comp_buf.data;
doc.bodylen = comp_size;
} else {
doc.body = rec.kv.value.data;
doc.bodylen = rec.kv.value.size;
}
doc.seqnum = rec.seqNum;
doc.flags = FDB_CUSTOM_SEQNUM;
bool deletion_executed = false;
if ( ( db_config->purgeDeletedDocImmediately &&
tableInfo &&
tableInfo->level &&
is_last_level ) ||
force_delete ) {
// Immediate purging option,
// only for the bottom-most non-zero level.
InternalMeta i_meta_from_rec;
readInternalMeta(rec.meta, i_meta_from_rec);
if (i_meta_from_rec.isTombstone || force_delete) {
fs = fdb_del(kvs_db, &doc);
deletion_executed = true;
}
}
if (!deletion_executed) {
fs = fdb_set(kvs_db, &doc);
}
if (fs != FDB_RESULT_SUCCESS) {
return Status::FDB_SET_FAIL;
}
offset_out = doc.offset;
if (rec.isIns()) {
// Set bloom filter if exists.
if (bfByKey) {
uint64_t hash_pair[2];
get_hash_pair(db_config, rec.kv.key, false, hash_pair);
bfByKey->set(hash_pair);
}
}
// Put into booster if exists.
if (tlbByKey) {
TableLookupBooster::Elem ee( key_hash_val, rec.seqNum, offset_out );
tlbByKey->setIfNew(ee);
}
return Status();
}
Status TableFile::setBatch(std::list<Record*>& batch,
std::list<uint64_t>& checkpoints,
const SizedBuf& min_key,
const SizedBuf& min_key_next_table,
uint32_t target_hash,
bool bulk_load_mode)
{
Timer tt;
const DBConfig* db_config = tableMgr->getDbConfig();
uint64_t prev_seqnum = 0;
size_t num_l0 = tableMgr->getNumL0Partitions();
size_t set_count = 0;
size_t del_count = 0;
uint64_t total_dirty = 0;
uint64_t time_for_flush_us = 0;
for (auto& entry: batch) {
Record* rec = entry;
// If hash is given, check hash.
uint32_t hash_val = tableMgr->getKeyHash(rec->kv.key);
if (target_hash != _SCU32(-1)) {
size_t key_hash = hash_val % num_l0;
if (key_hash != target_hash) continue;
}
// If range is given, check range:
// [min_key, min_key_next_table)
if ( !min_key.empty() &&
rec->kv.key < min_key) continue;
if ( !min_key_next_table.empty() &&
rec->kv.key >= min_key_next_table ) continue;
// Append all checkpoints that
// `record[n-1] seqnum <= chk < record[n] seqnum`
setCheckpoint(rec, prev_seqnum, checkpoints);
if (rec->isCmd()) continue;
uint64_t offset_out = 0;
Status s = setSingle(hash_val, *rec, offset_out);
if (!s) return s;
if (rec->isDel()) del_count++;
else set_count++;
total_dirty += rec->size();
prev_seqnum = rec->seqNum;
if ( db_config->preFlushDirtySize &&
db_config->preFlushDirtySize < total_dirty ) {
Timer flush_time;
fdb_sync_file(writer->dbFile);
total_dirty = 0;
time_for_flush_us += flush_time.getUs();
}
}
// Set all remaining (record[n] <= chk) checkpoints.
setCheckpoint(nullptr, prev_seqnum, checkpoints, true);
// Save bloom filter.
// WARNING: Writing bloom filter SHOULD BE DONE BEFORE COMMIT.
Timer tt_bf;
if (bfByKey) saveBloomFilter(filename + ".bf", bfByKey, true);
uint64_t bf_elapsed = tt_bf.getUs();
if (!bulk_load_mode) {
// Commit and update index node (not in bulk load mode).
writer->commit();
// Pre-load & keep the snapshot of latest table file data.
updateSnapshot();
}
SimpleLogger::Levels ll = SimpleLogger::INFO;
if (tableInfo) {
if (tableInfo->level) {
_log_( ll, myLog,
"L%zu: file %zu_%zu, set %zu del %zu, %zu us, %zu us, %zu us",
tableInfo->level,
tableMgr->getTableMgrOptions()->prefixNum,
myNumber,
set_count, del_count, tt.getUs(), bf_elapsed,
time_for_flush_us );
} else {
_log_( ll, myLog,
"L%zu: hash %zu, file %zu_%zu, set %zu del %zu, %zu us, %zu us, "
"%zu us",
tableInfo->level,
tableInfo->hashNum,
tableMgr->getTableMgrOptions()->prefixNum,
myNumber,
set_count, del_count, tt.getUs(), bf_elapsed,
time_for_flush_us );
}
} else {
_log_( ll, myLog,
"brand new table: file %zu_%zu, set %zu del %zu, %zu us, %zu us, %zu us",
tableMgr->getTableMgrOptions()->prefixNum,
myNumber,
set_count, del_count, tt.getUs(), bf_elapsed,
time_for_flush_us );
}
// Bulk load mode: all done here.
if (bulk_load_mode) return Status();
{
// Remove all checkpoints earlier than the oldest seqnum.
uint64_t oldest_seq = 0;
getOldestSnapMarker(oldest_seq);
mGuard l(chkMapLock);
auto entry = chkMap.begin();
while (entry != chkMap.end()) {
if ( entry->first < oldest_seq ||
entry->second < oldest_seq ) {
if (tableInfo) {
_log_debug( myLog,
"file lv %zu num %zu hash %zu removed "
"checkpoint %zu %zu",
tableInfo->level, tableInfo->number,
tableInfo->hashNum,
entry->first, entry->second );
}
entry = chkMap.erase(entry);
} else {
entry++;
}
}
}
return Status();
}
Status TableFile::get(DB* snap_handle,
Record& rec_io,
bool meta_only)
{
DB* parent_db = tableMgr->getParentDb();
const DBConfig* db_config = tableMgr->getDbConfig();
SizedBuf data_to_hash = get_data_to_hash(db_config, rec_io.kv.key, false);
// Search bloom filter first if exists.
if ( bfByKey &&
db_config->useBloomFilterForGet &&
!bfByKey->check(data_to_hash.data, data_to_hash.size) ) {
return Status::KEY_NOT_FOUND;
}
fdb_status fs;
fdb_doc doc_base;
fdb_doc doc_by_offset;
memset(&doc_base, 0x0, sizeof(doc_base));
doc_base.key = rec_io.kv.key.data;
doc_base.keylen = rec_io.kv.key.size;
fdb_doc* doc = &doc_base;
if (snap_handle) {
// Snapshot (does not use booster).
fdb_kvs_handle* kvs_db = nullptr;
{ mGuard l(snapHandlesLock);
auto entry = snapHandles.find(snap_handle);
if (entry == snapHandles.end()) return Status::SNAPSHOT_NOT_FOUND;
kvs_db = entry->second;
}
if (meta_only) {
fs = fdb_get_metaonly(kvs_db, doc);
} else {
fs = fdb_get(kvs_db, doc);
}
} else {
// Normal.
FdbHandleGuard g(this, getIdleHandle());
fdb_kvs_handle* kvs_db = g.handle->db;
bool skip_normal_search = false;
uint32_t key_hash = get_murmur_hash_32(data_to_hash);
IF ( !meta_only && tlbByKey ) {
// Search booster if exists.
memset(&doc_by_offset, 0x0, sizeof(doc_by_offset));
Status s = tlbByKey->get( key_hash, doc_by_offset.offset );
if (!s) break;
fs = fdb_get_byoffset_raw(kvs_db, &doc_by_offset);
if (fs != FDB_RESULT_SUCCESS) {
break;
}
if ( rec_io.kv.key == SizedBuf( doc_by_offset.keylen,
doc_by_offset.key ) ) {
skip_normal_search = true;
free(doc_by_offset.key);
doc_by_offset.key = rec_io.kv.key.data;
doc_by_offset.keylen = rec_io.kv.key.size;
doc = &doc_by_offset;
} else {
free(doc_by_offset.key);
free(doc_by_offset.meta);
free(doc_by_offset.body);
}
};
if (!skip_normal_search) {
if (meta_only) {
fs = fdb_get_metaonly(kvs_db, doc);
} else {
fs = fdb_get(kvs_db, doc);
if ( fs == FDB_RESULT_SUCCESS && tlbByKey ) {
// Put into booster if exists.
tlbByKey->setIfNew( TableLookupBooster::Elem
( key_hash, doc->seqnum, doc->offset ) );
}
}
}
}
if (fs != FDB_RESULT_SUCCESS) {
return Status::KEY_NOT_FOUND;
}
try {
Status s;
if (!meta_only) {
rec_io.kv.value.set(doc->bodylen, doc->body);
rec_io.kv.value.setNeedToFree();
}
// Decode meta.
SizedBuf user_meta_out;
SizedBuf raw_meta(doc->metalen, doc->meta);;
SizedBuf::Holder h_raw_meta(raw_meta); // auto free raw meta.
raw_meta.setNeedToFree();
InternalMeta i_meta_out;
rawMetaToUserMeta(raw_meta, i_meta_out, user_meta_out);
user_meta_out.moveTo( rec_io.meta );
// Decompress if needed.
TC( decompressValue(parent_db, db_config, rec_io, i_meta_out) );
rec_io.seqNum = doc->seqnum;
rec_io.type = (i_meta_out.isTombstone || doc->deleted)
? Record::DELETION
: Record::INSERTION;
return Status();
} catch (Status s) {
rec_io.kv.value.free();
rec_io.meta.free();
return s;
}
}
Status TableFile::getNearest(DB* snap_handle,
const SizedBuf& key,
Record& rec_out,
SearchOptions s_opt,
bool meta_only)
{
DB* parent_db = tableMgr->getParentDb();
const DBConfig* db_config = tableMgr->getDbConfig();
fdb_status fs;
fdb_doc doc_base;
fdb_doc doc_by_offset;
memset(&doc_base, 0x0, sizeof(doc_base));
fdb_doc* doc = &doc_base;
fdb_get_nearest_opt_t nearest_opt;
switch (s_opt) {
default:
case SearchOptions::GREATER_OR_EQUAL:
nearest_opt = FDB_GET_GREATER_OR_EQUAL;
break;
case SearchOptions::GREATER:
nearest_opt = FDB_GET_GREATER;
break;
case SearchOptions::SMALLER_OR_EQUAL:
nearest_opt = FDB_GET_SMALLER_OR_EQUAL;
break;
case SearchOptions::SMALLER:
nearest_opt = FDB_GET_SMALLER;
break;
};
if (snap_handle) {
// Snapshot (does not use booster).
fdb_kvs_handle* kvs_db = nullptr;
{ mGuard l(snapHandlesLock);
auto entry = snapHandles.find(snap_handle);
if (entry == snapHandles.end()) return Status::SNAPSHOT_NOT_FOUND;
kvs_db = entry->second;
}
if (meta_only) {
// FIXME.
fs = fdb_get_nearest(kvs_db, key.data, key.size, doc, nearest_opt);
} else {
fs = fdb_get_nearest(kvs_db, key.data, key.size, doc, nearest_opt);
}
} else {
// Normal.
FdbHandleGuard g(this, getIdleHandle());
fdb_kvs_handle* kvs_db = g.handle->db;
// NOTE:
// Unlike Bloom filter, we can still use table lookup booster
// as it returns true if exact match exists.
bool skip_normal_search = false;
uint32_t key_hash = tableMgr->getKeyHash(key);
IF ( s_opt.isExactMatchAllowed() && !meta_only && tlbByKey ) {
// Search booster if exists.
memset(&doc_by_offset, 0x0, sizeof(doc_by_offset));
Status s = tlbByKey->get( key_hash, doc_by_offset.offset );
if (!s) break;
fs = fdb_get_byoffset_raw(kvs_db, &doc_by_offset);
if (fs != FDB_RESULT_SUCCESS) {
break;
}
if ( key == SizedBuf( doc_by_offset.keylen,
doc_by_offset.key ) ) {
skip_normal_search = true;
doc = &doc_by_offset;
} else {
free(doc_by_offset.key);
free(doc_by_offset.meta);
free(doc_by_offset.body);
}
};
if (!skip_normal_search) {
if (meta_only) {
// FIXME.
fs = fdb_get_nearest(kvs_db, key.data, key.size, doc, nearest_opt);
} else {
fs = fdb_get_nearest(kvs_db, key.data, key.size, doc, nearest_opt);
}
}
}
if (fs != FDB_RESULT_SUCCESS) {
return Status::KEY_NOT_FOUND;
}
try {
Status s;
rec_out.kv.key.set(doc->keylen, doc->key);
rec_out.kv.key.setNeedToFree();
if (!meta_only) {
rec_out.kv.value.set(doc->bodylen, doc->body);
rec_out.kv.value.setNeedToFree();
}
// Decode meta.
SizedBuf user_meta_out;
SizedBuf raw_meta(doc->metalen, doc->meta);;
SizedBuf::Holder h_raw_meta(raw_meta); // auto free raw meta.
raw_meta.setNeedToFree();
InternalMeta i_meta_out;
rawMetaToUserMeta(raw_meta, i_meta_out, user_meta_out);
user_meta_out.moveTo( rec_out.meta );
// Decompress if needed.
TC( decompressValue(parent_db, db_config, rec_out, i_meta_out) );
rec_out.seqNum = doc->seqnum;
rec_out.type = (i_meta_out.isTombstone || doc->deleted)
? Record::DELETION
: Record::INSERTION;
return Status();
} catch (Status s) {
rec_out.kv.value.free();
rec_out.meta.free();
return s;
}
}
Status TableFile::getPrefix(DB* snap_handle,
const SizedBuf& prefix,
SearchCbFunc cb_func)
{
DB* parent_db = tableMgr->getParentDb();
const DBConfig* db_config = tableMgr->getDbConfig();
if ( bfByKey &&
db_config->useBloomFilterForGet ) {
uint64_t hash_pair[2];
bool used_custom_hash = get_hash_pair(db_config, prefix, true, hash_pair);
if ( used_custom_hash &&
!bfByKey->check(hash_pair) ) {
// Unlike point get, use bloom filter only when custom hash is used.
return Status::KEY_NOT_FOUND;
}
}
fdb_status fs;
fdb_doc doc_base;
memset(&doc_base, 0x0, sizeof(doc_base));
fdb_doc* doc = &doc_base;
fdb_get_nearest_opt_t nearest_opt = FDB_GET_GREATER_OR_EQUAL;
auto is_prefix_match = [&](const SizedBuf& key) -> bool {
if (key.size < prefix.size) return false;
return (SizedBuf::cmp( SizedBuf(prefix.size, key.data),
prefix ) == 0);
};
FdbHandleGuard g(this, snap_handle ? nullptr: getIdleHandle());
fdb_kvs_handle* kvs_db = nullptr;
if (snap_handle) {
mGuard l(snapHandlesLock);
auto entry = snapHandles.find(snap_handle);
if (entry == snapHandles.end()) return Status::SNAPSHOT_NOT_FOUND;
kvs_db = entry->second;
} else {
kvs_db = g.handle->db;
}
SizedBuf last_returned_key;
SizedBuf::Holder h_last_returned_key(last_returned_key);
prefix.copyTo(last_returned_key);
do {
// TODO: Not sure we can use table lookup booster.
fs = fdb_get_nearest(kvs_db,
last_returned_key.data,
last_returned_key.size,
doc,
nearest_opt);
if (fs != FDB_RESULT_SUCCESS) {
return Status::KEY_NOT_FOUND;
}
// Find next greater key.
nearest_opt = FDB_GET_GREATER;
Status s;
Record rec_out;
Record::Holder h_rec_out(rec_out);
rec_out.kv.key.set(doc->keylen, doc->key);
rec_out.kv.key.setNeedToFree();
rec_out.kv.value.set(doc->bodylen, doc->body);
rec_out.kv.value.setNeedToFree();
// Decode meta.
SizedBuf user_meta_out;
SizedBuf raw_meta(doc->metalen, doc->meta);;
SizedBuf::Holder h_raw_meta(raw_meta); // auto free raw meta.
raw_meta.setNeedToFree();
InternalMeta i_meta_out;
rawMetaToUserMeta(raw_meta, i_meta_out, user_meta_out);
user_meta_out.moveTo( rec_out.meta );
// Decompress if needed.
s = decompressValue(parent_db, db_config, rec_out, i_meta_out);
if (!s) {
_log_err(myLog, "decompression failed: %d, key %s",
s, rec_out.kv.key.toReadableString().c_str());
continue;
}
rec_out.seqNum = doc->seqnum;
rec_out.type = (i_meta_out.isTombstone || doc->deleted)
? Record::DELETION
: Record::INSERTION;
if (!is_prefix_match(rec_out.kv.key)) {
// Prefix doesn't match, exit.
break;
}
SearchCbDecision dec = cb_func({rec_out});
if (dec == SearchCbDecision::STOP) {
return Status::OPERATION_STOPPED;
}
last_returned_key.free();
rec_out.kv.key.copyTo(last_returned_key);
} while (true);
return Status::OK;
}
fdb_index_traversal_decision cb_fdb_index_traversal( fdb_kvs_handle *fhandle,
void* key,
size_t keylen,
uint64_t offset,
void *ctx )
{
TableFile::IndexTraversalCbFunc* cb_func = (TableFile::IndexTraversalCbFunc*)ctx;
TableFile::IndexTraversalParams params;
params.key = SizedBuf(keylen, key);
params.offset = offset;
TableFile::IndexTraversalDecision dec = (*cb_func)(params);
if (dec == TableFile::IndexTraversalDecision::STOP) {
return FDB_IT_STOP;
}
return FDB_IT_NEXT;
}
Status TableFile::traverseIndex(DB* snap_handle,
const SizedBuf& start_key,
IndexTraversalCbFunc cb_func)
{
FdbHandleGuard g(this, snap_handle ? nullptr: getIdleHandle());
fdb_kvs_handle* kvs_db = nullptr;
if (snap_handle) {
mGuard l(snapHandlesLock);
auto entry = snapHandles.find(snap_handle);
if (entry == snapHandles.end()) return Status::SNAPSHOT_NOT_FOUND;
kvs_db = entry->second;
} else {
kvs_db = g.handle->db;
}
fdb_traverse_index( kvs_db,
start_key.data,
start_key.size,
cb_fdb_index_traversal,
(void*)&cb_func );
return Status::OK;
}
Status TableFile::decompressValue(DB* parent_db,
const DBConfig* db_config,
Record& rec_io,
const InternalMeta& i_meta)
{
if (!i_meta.isCompressed) return Status::OK;
// Output buffer may not be given in meta-only mode.
// In such cases, just ignore.
if (rec_io.kv.value.empty()) return Status::OK;
if (!db_config->compOpt.cbDecompress) {
_log_fatal(myLog, "found compressed record %s, but decompression "
"function is not given",
rec_io.kv.key.toReadableString().c_str());
return Status::INVALID_CONFIG;
}
SizedBuf decomp_buf(i_meta.originalValueLen);
ssize_t output_len =
db_config->compOpt.cbDecompress(parent_db, rec_io.kv.value, decomp_buf);
if (output_len != i_meta.originalValueLen) {
_log_fatal(myLog, "decompression failed: %zd, db %s, key %s",
output_len,
parent_db->getPath().c_str(),
rec_io.kv.key.toReadableString().c_str());
return Status::DECOMPRESSION_FAILED;
}
// Switch value and free the previous (compressed) one.
SizedBuf prev_buf = rec_io.kv.value;
rec_io.kv.value = decomp_buf;
prev_buf.free();
return Status::OK;
}
// WARNING:
// For performance gaining purpose, `rec_out` returned by
// this function will have RAW meta including internal flags.
Status TableFile::getByOffset(DB* snap_handle,
uint64_t offset,
Record& rec_out)
{
fdb_status fs;
fdb_doc doc_by_offset;
memset(&doc_by_offset, 0x0, sizeof(doc_by_offset));
doc_by_offset.offset = offset;
fdb_doc* doc = &doc_by_offset;
if (snap_handle) {
// Snapshot (does not use booster).
fdb_kvs_handle* kvs_db = nullptr;
{ mGuard l(snapHandlesLock);
auto entry = snapHandles.find(snap_handle);
if (entry == snapHandles.end()) return Status::SNAPSHOT_NOT_FOUND;
kvs_db = entry->second;
}
fs = fdb_get_byoffset_raw(kvs_db, &doc_by_offset);
} else {
// Normal.
FdbHandleGuard g(this, getIdleHandle());
fdb_kvs_handle* kvs_db = g.handle->db;
fs = fdb_get_byoffset_raw(kvs_db, &doc_by_offset);
}
if (fs != FDB_RESULT_SUCCESS) {
return Status::INVALID_OFFSET;
}
rec_out.kv.key.set(doc->keylen, doc->key);
rec_out.kv.key.setNeedToFree();
rec_out.kv.value.set(doc->bodylen, doc->body);
rec_out.kv.value.setNeedToFree();
rec_out.meta.set(doc->metalen, doc->meta);
rec_out.meta.setNeedToFree();
rec_out.seqNum = doc->seqnum;
rec_out.type = tfIsTombstone(0)
? Record::DELETION
: Record::INSERTION;
return Status();
}
Status TableFile::appendCheckpoints(RwSerializer& file_s)
{
mGuard l(chkMapLock);
file_s.putU32(chkMap.size());
for (auto& entry: chkMap) {
uint64_t chk = entry.first;
uint64_t fdb_seq = entry.second;
file_s.putU64(chk);
file_s.putU64(fdb_seq);
}
return Status();
}
Status TableFile::loadCheckpoints(RwSerializer& file_s)
{
mGuard l(chkMapLock);
Status s;
uint32_t num_chks = file_s.getU32(s);
for (size_t ii=0; ii<num_chks; ++ii) {
uint64_t chk = file_s.getU64(s);
uint64_t fdb_seq = file_s.getU64(s);
chkMap.insert( std::make_pair(chk, fdb_seq) );
}
return Status();
}
Status TableFile::getAvailCheckpoints(std::list<uint64_t>& chk_out) {
mGuard l(chkMapLock);
for (auto& entry: chkMap) {
uint64_t chk_num = entry.first;
chk_out.push_back(chk_num);
}
return Status();
}
Status TableFile::getCheckpointSeqnum(uint64_t chk, uint64_t& seqnum_out) {
mGuard l(chkMapLock);
auto entry = chkMap.find(chk);
if (entry != chkMap.end()) {
seqnum_out = entry->second;
return Status();
}
return Status::ERROR;
}
Status TableFile::destroySelf() {
if (fOps->exist(filename.c_str())) {
// Instead removing it immediately,
// put it into remove list.
DBMgr* dbm = DBMgr::getWithoutInit();
std::string bf_filename = filename + ".bf";
if (!dbm) {
fOps->remove(filename.c_str());
fOps->remove(bf_filename.c_str());
} else {
dbm->addFileToRemove(filename);
dbm->addFileToRemove(bf_filename);
}
}
return Status();
}
Status TableFile::getLatestSnapMarker(uint64_t& last_snap_seqnum) {
FdbHandleGuard g(this, this->getIdleHandle());
fdb_file_handle* db_file = g.handle->dbFile;
// Get last snap marker.
fdb_snapshot_info_t* markers = nullptr;
uint64_t num_markers = 0;
fdb_status fs = fdb_get_all_snap_markers(db_file, &markers, &num_markers);
if (fs != FDB_RESULT_SUCCESS) return Status::ERROR;
if (!markers || !num_markers) return Status::SNAPSHOT_NOT_FOUND;
last_snap_seqnum = markers[0].kvs_markers[0].seqnum;
fdb_free_snap_markers(markers, num_markers);
return Status();
}
Status TableFile::getSnapMarkerUpto(uint64_t upto,
uint64_t& snap_seqnum_out)
{
FdbHandleGuard g(this, this->getIdleHandle());
fdb_file_handle* db_file = g.handle->dbFile;
// Get last snap marker.
fdb_snapshot_info_t* markers = nullptr;
uint64_t num_markers = 0;
fdb_status fs = fdb_get_all_snap_markers(db_file, &markers, &num_markers);
if (fs != FDB_RESULT_SUCCESS) return Status::ERROR;
if (!markers || !num_markers) return Status::SNAPSHOT_NOT_FOUND;
snap_seqnum_out = 0;
for (size_t ii=0; ii<num_markers; ++ii) {
if (upto >= markers[ii].kvs_markers[0].seqnum) {
snap_seqnum_out = markers[ii].kvs_markers[0].seqnum;
break;
}
}
fdb_free_snap_markers(markers, num_markers);
return Status();
}
Status TableFile::getOldestSnapMarker(uint64_t& oldest_snap_seqnum) {
FdbHandleGuard g(this, this->getIdleHandle());
fdb_file_handle* db_file = g.handle->dbFile;
// Get first snap marker.
fdb_snapshot_info_t* markers = nullptr;
uint64_t num_markers = 0;
fdb_status fs = fdb_get_all_snap_markers(db_file, &markers, &num_markers);
if (fs != FDB_RESULT_SUCCESS) return Status::ERROR;
if (!markers || !num_markers) return Status::SNAPSHOT_NOT_FOUND;
oldest_snap_seqnum = markers[num_markers-1].kvs_markers[0].seqnum;
fdb_free_snap_markers(markers, num_markers);
return Status();
}
Status TableFile::getStats(TableStats& stats_out) {
FdbHandleGuard g(this, this->getIdleHandle());
fdb_file_handle* db_file = g.handle->dbFile;
fdb_kvs_handle* kvs_db = g.handle->db;
fdb_file_info info;
fdb_status fs = fdb_get_file_info(db_file, &info);
if (fs != FDB_RESULT_SUCCESS) return Status::ERROR;
fdb_kvs_info kvs_info;
fs = fdb_get_kvs_info(kvs_db, &kvs_info);
stats_out.numKvs = info.doc_count;
stats_out.workingSetSizeByte = info.space_used;
stats_out.totalSizeByte = info.file_size;
// This should be a bug.
assert(stats_out.workingSetSizeByte < stats_out.totalSizeByte * 10);
if (stats_out.workingSetSizeByte > stats_out.totalSizeByte * 10) {
_log_fatal(myLog, "found wrong WSS, %s, %zu / %zu",
filename.c_str(),
stats_out.workingSetSizeByte,
stats_out.totalSizeByte);
DBMgr* dbm = DBMgr::getWithoutInit();
if (dbm) {
_log_fatal(dbm->getLogger(),
"found wrong WSS, %s, %zu / %zu",
filename.c_str(),
stats_out.workingSetSizeByte,
stats_out.totalSizeByte);
}
// Make it small so as to compact quickly
stats_out.workingSetSizeByte = stats_out.totalSizeByte / 10;
}
stats_out.blockReuseCycle = info.sb_bmp_revnum;
stats_out.numIndexNodes = info.num_live_nodes;
stats_out.lastSeqnum = kvs_info.last_seqnum;
stats_out.approxDocCount = kvs_info.doc_count;
stats_out.approxDelCount = kvs_info.deleted_count;
return Status();
}
Status TableFile::getMaxKey(SizedBuf& max_key_out) {
Status s;
TableFile::Iterator itr;
EP( itr.init(nullptr, this, SizedBuf(), SizedBuf()) );
try {
TC( itr.gotoEnd() );
Record rec_out;
Record::Holder h_rec_out(rec_out);
TC( itr.get(rec_out) );
rec_out.kv.key.moveTo(max_key_out);
return Status();
} catch (Status s) {
return s;
}
}
bool TableFile::isEmpty() {
Status s;
TableFile::Iterator itr;
EP(itr.init(nullptr, this, SizedBuf(), SizedBuf()));
try {
Record rec_out;
Record::Holder h_rec_out(rec_out);
TC(itr.get(rec_out));
} catch (Status s) {
return true;
}
return false;
}
Status TableFile::getMinKey(SizedBuf& min_key_out) {
Status s;
TableFile::Iterator itr;
EP( itr.init(nullptr, this, SizedBuf(), SizedBuf()) );
try {
Record rec_out;
Record::Holder h_rec_out(rec_out);
TC( itr.get(rec_out) );
rec_out.kv.key.moveTo(min_key_out);
return Status();
} catch (Status s) {
return s;
}
}
Status TableFile::updateSnapshot() {
fdb_seqnum_t snap_seqnum = 0;
getLatestSnapMarker(snap_seqnum);
FdbHandleGuard g(this, getIdleHandle());
fdb_kvs_handle* kvs_db = g.handle->db;
fdb_kvs_handle* snap_handle = nullptr;
fdb_status fs = fdb_snapshot_open(kvs_db, &snap_handle, snap_seqnum);
if (fs != FDB_RESULT_SUCCESS) return Status::FDB_OPEN_KVS_FAIL;
Snapshot* new_snp = new Snapshot(this, snap_handle, snap_seqnum);
std::list<Snapshot*> stale_snps;
{ std::lock_guard<std::mutex> l(latestSnapshotLock);
auto entry = latestSnapshot.begin();
// Decrease the reference count of the previously latest one.
if (entry != latestSnapshot.end()) {
Snapshot*& latest_snp = *entry;
latest_snp->refCount--;
}
while (entry != latestSnapshot.end()) {
Snapshot*& cur_snp = *entry;
if (!cur_snp->refCount) {
stale_snps.push_back(cur_snp);
entry = latestSnapshot.erase(entry);
} else {
entry++;
}
}
latestSnapshot.push_front(new_snp);
}
// Close all stale snapshots (refCount == 0).
for (Snapshot*& cur_snp: stale_snps) {
_log_trace(myLog, "delete snapshot %p refcount %zu",
cur_snp, cur_snp->refCount);
fdb_kvs_close(cur_snp->fdbSnap);
delete cur_snp;
}
return Status();
}
Status TableFile::leaseSnapshot(TableFile::Snapshot*& snp_out) {
std::lock_guard<std::mutex> l(latestSnapshotLock);
auto entry = latestSnapshot.begin();
assert(entry != latestSnapshot.end());
Snapshot* snp = *entry;
snp->refCount++;
_log_trace(myLog, "lease snapshot %p refcount %zu",
snp, snp->refCount);
snp_out = snp;
return Status();
}
Status TableFile::returnSnapshot(TableFile::Snapshot* snapshot) {
std::list<Snapshot*> stale_snps;
{ std::lock_guard<std::mutex> l(latestSnapshotLock);
snapshot->refCount--;
_log_trace(myLog, "return snapshot %p refcount %zu",
snapshot, snapshot->refCount);
auto entry = latestSnapshot.begin();
while (entry != latestSnapshot.end()) {
Snapshot*& cur_snp = *entry;
if (!cur_snp->refCount) {
stale_snps.push_back(cur_snp);
entry = latestSnapshot.erase(entry);
} else {
entry++;
}
}
}
// Close all stale snapshots (refCount == 0).
for (Snapshot*& cur_snp: stale_snps) {
_log_trace(myLog, "delete snapshot %p refcount %zu",
cur_snp, cur_snp->refCount);
fdb_kvs_close(cur_snp->fdbSnap);
delete cur_snp;
}
return Status();
}
} // namespace jungle
| 31.773534
| 88
| 0.5884
|
LaudateCorpus1
|
69cd59d6cc01fd94fd58d9248686ed83ccedd3b1
| 134,375
|
inl
|
C++
|
src/fonts/stb_font_arial_50_latin1.inl
|
stetre/moonfonts
|
5c8010c02ea62edcf42902e09478b0cd14af56ea
|
[
"MIT"
] | 3
|
2018-03-13T12:51:57.000Z
|
2021-10-11T11:32:17.000Z
|
src/fonts/stb_font_arial_50_latin1.inl
|
stetre/moonfonts
|
5c8010c02ea62edcf42902e09478b0cd14af56ea
|
[
"MIT"
] | null | null | null |
src/fonts/stb_font_arial_50_latin1.inl
|
stetre/moonfonts
|
5c8010c02ea62edcf42902e09478b0cd14af56ea
|
[
"MIT"
] | null | null | null |
// Font generated by stb_font_inl_generator.c (4/1 bpp)
//
// Following instructions show how to use the only included font, whatever it is, in
// a generic way so you can replace it with any other font by changing the include.
// To use multiple fonts, replace STB_SOMEFONT_* below with STB_FONT_arial_50_latin1_*,
// and separately install each font. Note that the CREATE function call has a
// totally different name; it's just 'stb_font_arial_50_latin1'.
//
/* // Example usage:
static stb_fontchar fontdata[STB_SOMEFONT_NUM_CHARS];
static void init(void)
{
// optionally replace both STB_SOMEFONT_BITMAP_HEIGHT with STB_SOMEFONT_BITMAP_HEIGHT_POW2
static unsigned char fontpixels[STB_SOMEFONT_BITMAP_HEIGHT][STB_SOMEFONT_BITMAP_WIDTH];
STB_SOMEFONT_CREATE(fontdata, fontpixels, STB_SOMEFONT_BITMAP_HEIGHT);
... create texture ...
// for best results rendering 1:1 pixels texels, use nearest-neighbor sampling
// if allowed to scale up, use bilerp
}
// This function positions characters on integer coordinates, and assumes 1:1 texels to pixels
// Appropriate if nearest-neighbor sampling is used
static void draw_string_integer(int x, int y, char *str) // draw with top-left point x,y
{
... use texture ...
... turn on alpha blending and gamma-correct alpha blending ...
glBegin(GL_QUADS);
while (*str) {
int char_codepoint = *str++;
stb_fontchar *cd = &fontdata[char_codepoint - STB_SOMEFONT_FIRST_CHAR];
glTexCoord2f(cd->s0, cd->t0); glVertex2i(x + cd->x0, y + cd->y0);
glTexCoord2f(cd->s1, cd->t0); glVertex2i(x + cd->x1, y + cd->y0);
glTexCoord2f(cd->s1, cd->t1); glVertex2i(x + cd->x1, y + cd->y1);
glTexCoord2f(cd->s0, cd->t1); glVertex2i(x + cd->x0, y + cd->y1);
// if bilerping, in D3D9 you'll need a half-pixel offset here for 1:1 to behave correct
x += cd->advance_int;
}
glEnd();
}
// This function positions characters on float coordinates, and doesn't require 1:1 texels to pixels
// Appropriate if bilinear filtering is used
static void draw_string_float(float x, float y, char *str) // draw with top-left point x,y
{
... use texture ...
... turn on alpha blending and gamma-correct alpha blending ...
glBegin(GL_QUADS);
while (*str) {
int char_codepoint = *str++;
stb_fontchar *cd = &fontdata[char_codepoint - STB_SOMEFONT_FIRST_CHAR];
glTexCoord2f(cd->s0f, cd->t0f); glVertex2f(x + cd->x0f, y + cd->y0f);
glTexCoord2f(cd->s1f, cd->t0f); glVertex2f(x + cd->x1f, y + cd->y0f);
glTexCoord2f(cd->s1f, cd->t1f); glVertex2f(x + cd->x1f, y + cd->y1f);
glTexCoord2f(cd->s0f, cd->t1f); glVertex2f(x + cd->x0f, y + cd->y1f);
// if bilerping, in D3D9 you'll need a half-pixel offset here for 1:1 to behave correct
x += cd->advance;
}
glEnd();
}
*/
#ifndef STB_FONTCHAR__TYPEDEF
#define STB_FONTCHAR__TYPEDEF
typedef struct
{
// coordinates if using integer positioning
float s0,t0,s1,t1;
signed short x0,y0,x1,y1;
int advance_int;
// coordinates if using floating positioning
float s0f,t0f,s1f,t1f;
float x0f,y0f,x1f,y1f;
float advance;
} stb_fontchar;
#endif
#define STB_FONT_arial_50_latin1_BITMAP_WIDTH 256
#define STB_FONT_arial_50_latin1_BITMAP_HEIGHT 580
#define STB_FONT_arial_50_latin1_BITMAP_HEIGHT_POW2 1024
#define STB_FONT_arial_50_latin1_FIRST_CHAR 32
#define STB_FONT_arial_50_latin1_NUM_CHARS 224
#define STB_FONT_arial_50_latin1_LINE_SPACING 32
static unsigned int stb__arial_50_latin1_pixels[]={
0x10266620,0x20001333,0x30000cca,0x64403333,0x8800002c,0x009acba9,
0x5dd4c000,0xccb8009a,0x54c00002,0x019abcca,0xba880000,0xacc8003c,
0x5997000a,0x98000000,0xfd800199,0x7ffdc2ff,0x5ff98004,0xffff3000,
0x01ffd80b,0xfffb5000,0x19ffffff,0x7ffd4000,0x00cfffff,0x0000fffa,
0xffffffb5,0x39ffffff,0xff900000,0xfff80dff,0x07fffff6,0x3fe7ffd0,
0x15ffffff,0xffffffff,0x3fffee07,0x7ffec005,0x027ffdc2,0x0007ff40,
0x806fffd8,0x40006ff8,0xfffffffb,0xcfffffff,0x3ff62000,0xffffffff,
0x07ffd01f,0xfffd7100,0xffffffff,0x07dfffff,0x3fff2000,0x7ffc06ff,
0x9ffffff6,0xff3ffe80,0x2bffffff,0xfffffff8,0xffff983f,0x3f6003ff,
0x7ffdc2ff,0x1ffdc004,0xffff9800,0x07ff9000,0xffffb100,0xffffffff,
0x001dffff,0x3bfffff6,0x0ffffffd,0x4003ffe8,0xfffffffc,0xfedccdef,
0x1effffff,0x3ffea000,0x7fc05fff,0xfffffb6f,0x9fff401f,0xffffffff,
0xffffff15,0xffe887ff,0x002fffdf,0xfb85fffb,0x3e6004ff,0xf90000ff,
0x7c4005ff,0x3e6001ff,0x9acfffff,0xfffca988,0x7d400eff,0x2e21bfff,
0xfe86fffe,0xffd1003f,0x0015bfff,0xfffffd71,0x3ff20007,0x3ffe003f,
0x1fffe446,0x3fe7ffd0,0x209999ff,0xfffb9999,0xe9fffec3,0x98800fff,
0x4ccc4099,0x0fffa000,0x27ffc400,0x037fdc00,0xcfffff88,0xfffc8800,
0x3ff600ef,0x3ffe603f,0x01fff41f,0x67ffff44,0x3f660000,0xe8005fff,
0x664006ff,0x6fff883c,0x7fcfffa0,0x7fd4007f,0x97ffee3f,0x0006fff9,
0x3fea0000,0x3ff20007,0x3ffe0005,0xffffd802,0xfffc8002,0x3fffe03f,
0x1fffe400,0xf300fffa,0x0001bfff,0x1ffffdc0,0x09fff100,0xfffb0000,
0xff9fff40,0x7fd4007f,0x1ffff33f,0x005fffc8,0xffd00000,0x00000009,
0xb80dff90,0x0002ffff,0xf81ffff6,0xffa806ff,0x01fff46f,0x007ffff3,
0x3ffa2000,0xfff1002f,0xf9000007,0x9fff40ff,0x54007fff,0x00003fff,
0x4c000000,0x00001fff,0xfff98000,0x13fffe01,0xffff1000,0x07fffa05,
0xfd033510,0x7fff407f,0x44000002,0x8800fffe,0x00003fff,0xd00fffc8,
0x1fffe7ff,0x07fff500,0x0cccc000,0x81999800,0x4cc06ffd,0x33300019,
0x82fffc03,0x000ffffa,0x05fffd80,0x001bfff9,0xb81fff40,0xa8802fff,
0xf98001cc,0xff9805ff,0x4ccc003f,0x01fff900,0x7ffcfffa,0x7ffd4007,
0x0bfffa03,0x003ffff0,0x445fff98,0x7fc04fff,0x7cc001ff,0x3ff205ff,
0x5fffd80f,0x15930000,0x77fffc40,0x7ffd0000,0x809fff10,0xffffffd9,
0x07fff60d,0x9801fff7,0x7c003fff,0xfff906ff,0x7cfffa01,0x7d4007ff,
0x3ffa03ff,0x7ffe402f,0x7ffe4004,0x00fffe42,0x0013fff2,0x4c05fff9,
0x7fc44fff,0x000003ff,0xfffffa80,0x3ffe8002,0x5c06ffd8,0xffffffff,
0x0fffd0ef,0xf300fffe,0xff8005ff,0x1fff706f,0x7fcfffa0,0x7fd4007f,
0x3fffa03f,0x37ffcc02,0x21fffe00,0xf9806ffe,0x7fc006ff,0x6fff807f,
0x00ffffd4,0xfc800000,0x000dffff,0xff30fffa,0x7ffe403f,0xfffeceff,
0x706fff8e,0xff980fff,0x7ffc002f,0x03fff706,0x7ffcfffa,0x7ffd4007,
0x0bfffa03,0x007fffa0,0x2227ffcc,0xfd004fff,0x3e6003ff,0xffd804ff,
0x3fffee0f,0x40000000,0xffffffd9,0xffd002ff,0x205ffd87,0x40bffffc,
0xffffffe8,0x03fff104,0x0017ffcc,0x7d41bffe,0x7ffd01ff,0x5001fffe,
0x7f407fff,0xffb802ff,0xfff9004f,0x03fffa83,0x009fff70,0x2007fff2,
0x3ee2fffc,0x000007ff,0x5ffffcc0,0x0dfffffe,0x3e1fff40,0xfff302ff,
0xfffe807f,0x3ffa02ff,0x07ffea02,0x20dfff00,0xfd01fffa,0x01fffe7f,
0x407fff50,0x8802fffe,0xf8807fff,0xfffc86ff,0xffff1002,0x0dfff100,
0xc93ffee0,0x00006fff,0x3bffe200,0x3fffff20,0x8fffa03f,0x3fa07ffa,
0xff9803ff,0x3f600fff,0x3ffee03f,0x37ffc001,0xd02fff98,0x1fffe7ff,
0x07fff500,0x8017fff4,0x5402fffd,0xffe83fff,0x3ff6002f,0x7ffd402f,
0xdfff5003,0x0027ffec,0xfff50000,0xffffd301,0x7ffd01df,0xfb827fe4,
0x3fa006ff,0x7fe407ff,0x01bff604,0xf81bffe0,0x7ffd04ff,0x5001fffe,
0x7f407fff,0xff5002ff,0xfffd80bf,0x01ffff80,0x017ffea0,0x2001fffb,
0x3f67fff9,0x000004ff,0x7013ff60,0x81ffffff,0x3ffe2ccb,0x05fffd01,
0x02fffec0,0x7cc17fee,0xff8003ff,0x3fff606f,0xff3ffe81,0xffa800ff,
0x3fffa03f,0x3fffe002,0x0bfff100,0x0003fffe,0x2201ffff,0x22005fff,
0x3ff27fff,0x0000005f,0x3005fff1,0x01dffffd,0xa80fff88,0x64006fff,
0x7e403fff,0xfffe883f,0x6fff8000,0x037ffe60,0x3ffe7ffd,0x7ffd4007,
0x0bfffa03,0x02fffc80,0xf105fff7,0xf9000fff,0x3fee05ff,0x7ffc002f,
0x0dfff70f,0x3e200000,0x3f2005ff,0x7cc05fff,0x7fffb07f,0x2fffc800,
0xb517fec0,0x0007ffff,0xf701bffe,0x3fa5bfff,0x00ffff3f,0x203fffa8,
0x2002fffe,0xfd05fff9,0x3ffe60ff,0xfff98006,0x00fffd05,0x2a3fffd0,
0x00006fff,0x03fffa00,0x1ffffb80,0x741bfea0,0x74001fff,0x7f400fff,
0x3bfff60f,0x3ffe0001,0xffffa806,0x3fe7ffd4,0x7fd4007f,0x3fffa03f,
0x7fff4002,0x827ffcc0,0x0005fff9,0xf981fffd,0xfd8004ff,0xffff31ff,
0x00400001,0x800bfff9,0x2e03fffd,0xffff05ff,0x6fff8001,0x363ffcc0,
0x40001fff,0xf5006fff,0x4fffa9ff,0x54007fff,0x3fa03fff,0x7dc002ff,
0x7ffe43ff,0x0dfff101,0x0fffee00,0x0003fff9,0x7fc1fffd,0x200002ff,
0x3e20bdff,0x5000efff,0x7dc0bfff,0x7fff885f,0x2fffcc00,0xfb17ff20,
0x40009fff,0xfa806fff,0x7ffd4fff,0x5001fffe,0x7f407fff,0x7c4002ff,
0x37ffc6ff,0x00dfff10,0xf1bffe20,0x3a000dff,0x3ff20fff,0xf300004f,
0xffa83fff,0xff003fff,0x2ffdc0bf,0x0037ffc4,0x880fffee,0x7e4c3fff,
0xf0004fff,0xffc80dff,0x7ffd1cef,0x5001fffe,0x7f407fff,0xfd8002ff,
0x7fff30ff,0x007fff80,0x4c3fff60,0xf0003fff,0xfffa8fff,0xfc80000f,
0xfff906ff,0x7cc01bff,0x3fea03ff,0x00ffff06,0x00ffffc4,0xfd80dff9,
0xff8001ff,0x3ffe606f,0xff3ffe85,0xffa800ff,0x3fffa03f,0xfffa8002,
0x801fff93,0x20007ffe,0xff93fffa,0x3fe0001f,0x5ffff86f,0x7ffc4000,
0x3ffea03f,0xff903fff,0x4cbbb63f,0xfffb07ff,0x3fffe400,0x803fff30,
0x8004fff9,0x3f206fff,0x3ffe80ff,0xa800ffff,0x3fa03fff,0xff0002ff,
0x017ffadf,0x0003fffa,0xffd6fff8,0x3fe2000b,0xffffa85f,0xffd10002,
0xfe8801ff,0x321effff,0x3ffa4fff,0x701fff33,0xf1005fff,0x3e60dfff,
0xff9004ff,0xdfff000f,0xe827ffc0,0x0ffff3ff,0x03fffa80,0x000bfffa,
0x7fcfffe4,0xfffc802f,0x3ff20002,0x002fff9f,0x209fff50,0x003ffffe,
0x04ffffd8,0x3ffffee0,0x44fffdcf,0xfff13ffe,0x0dfff503,0x4ffffe88,
0x00ffff98,0x003fff70,0xf306fff8,0x3ffa05ff,0x800ffff3,0x3a03fffa,
0x30002fff,0x1fffdfff,0x09fff500,0x77ffcc00,0x90000fff,0x3e605fff,
0x800cffff,0x05ffffea,0xffffd880,0xfe81efff,0x217ff63f,0x304ffff8,
0x8bffffff,0x002ffffb,0x0007ffea,0x3ea0dfff,0x7ffd01ff,0x5001fffe,
0x7f407fff,0x3a0002ff,0x004fffff,0x0001bffe,0x09fffffd,0x03fff400,
0x3fffffea,0xdba989ad,0x006fffff,0x7ffffd40,0x47ffd01f,0xf980fffb,
0xdb9adfff,0xffffefff,0x1fffffdd,0x17ffcc00,0x41bffe00,0xfd01fffb,
0x01fffe7f,0x407fff50,0x0002fffe,0x07ffffee,0x007ffd80,0x7ffffdc0,
0x3ffe0001,0xffff9805,0xffffffff,0x00efffff,0xfffd8800,0x3ffe81ff,
0x540fffe2,0xffffffff,0xffffa9ef,0x00efffff,0x02fff980,0xb837ffc0,
0xffd01fff,0x001fffe7,0x7407fff5,0x20002fff,0x006ffff8,0x000fffdc,
0x0dffff10,0x17ffcc00,0xffffd880,0xffffffff,0x800003ff,0x40effffb,
0x7fec3ffe,0x3fffee06,0xfd10dfff,0x0bffffff,0x1fffcc00,0x41bffe00,
0xfd00fffb,0x01fffe7f,0x407fff50,0x0002fffe,0x001fffec,0x0013ffe2,
0x007fffb0,0x007ffe40,0x3ffff220,0x0cffffff,0x3e600000,0x7ff44fff,
0x02fffcc3,0x037dfb51,0x159dfdb1,0x406aaa20,0x4003fff9,0xff706fff,
0x4fffa01f,0x54007fff,0x3fa03fff,0x640002ff,0xd8000fff,0x640007ff,
0x20000fff,0x40004fff,0x01acffd8,0x7d400000,0x1fff46ff,0x0027ffe4,
0x7f440000,0xfff301ff,0x6fff8007,0x201fff70,0xffff3ffe,0x3fffa800,
0x00bfffa0,0x00bfff00,0x00bffe60,0x005fff80,0x003ffea0,0x001ffa00,
0x00ff65c0,0x3a0fffe8,0xfff883ff,0x0000002f,0x813fffa2,0x2003fff8,
0xf706fff8,0x3ffa01ff,0x800ffff3,0x3a03fffa,0x20002fff,0x0002fffa,
0x40017ff6,0x0002fffa,0x00017ff6,0x02fbffe2,0x4fffc800,0x43fffb00,
0xff303ffe,0x000019ff,0x5fffe980,0x01fffc40,0x20bfff10,0xfd00fffc,
0x01fffe7f,0x407fff50,0x0002fffe,0x0001bffa,0x0001fff3,0x4000dffd,
0x0001fff8,0x6fffcb88,0x3ffe6000,0x7ffc400e,0x301fff47,0x005fffff,
0xfff91000,0x3ffe00bf,0x3ffe6004,0x40fffb05,0xffff3ffe,0x3fffa800,
0x00bfffa0,0x01fffe40,0x027fec00,0x00ffff20,0x005ffc80,0x2fff8800,
0x3fffe000,0x27ffe405,0xf300fffa,0x015bffff,0xfffb9800,0x3fe004ff,
0xff7000ff,0x17ffe09f,0xfff3ffe8,0xfffa800f,0x0bfffa03,0x3fb2b2e0,
0x80000fff,0x9700fff8,0x1ffffd95,0x3ffe2000,0xfa800000,0x2a0003ff,
0x4c1dffff,0x742ffffd,0xfd8803ff,0x9befffff,0x3ae66201,0x02ffffff,
0x0e7ffe40,0x7ff5c4c4,0x3ff6622f,0x4fffa03f,0xaaaaffff,0x3f2aaaa1,
0x3ffa03ff,0xfffb802f,0x0001ffff,0x5c17fee0,0x1fffffff,0x0fff6000,
0x3732a000,0x001fffff,0x7ffffe40,0xffffffff,0x003ffe83,0x3fffffaa,
0xfeefffff,0xffffffff,0x88000cff,0x26ffffff,0x7ffffffb,0x3ffffffe,
0x7cfffa00,0x5fffffff,0xfffffff1,0x7fff407f,0xffffa802,0x800002ff,
0xffa81ffe,0x0002ffff,0x0001bfe6,0x7fffffec,0xf900003f,0xffffffff,
0x3ffa05ff,0xffda8003,0xffffffff,0xffffffff,0x640000cf,0x366fffff,
0x22ffffff,0x03ffffff,0xfff9fff4,0xf15fffff,0x7fffffff,0x017fff40,
0x1f7fffcc,0xff880000,0xeffff985,0x7fec0003,0xffb00000,0x0003bfff,
0xffffc880,0x3a01ceff,0x220003ff,0xfffffeca,0xbeffffff,0x7d400001,
0x3ffe6fff,0x7ffc2fff,0xffe802ef,0xddddddb3,0x3bbba29d,0x0002eeee,
0x000a9880,0x02a98000,0x00001531,0x000006aa,0x00000062,0x2001a988,
0x00001aaa,0x4d554ccc,0x00000019,0x54c45533,0x0355500a,0x000d5540,
0x00000000,0x00000000,0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00066660,0x00000000,0x98000000,
0x00001999,0x33330000,0x10000001,0x00001333,0x02666620,0x31000000,
0x00001333,0x99988000,0x7ffe4000,0x0000003f,0x5c40077a,0xffffffec,
0xffffffff,0x7fec000f,0x000002ff,0x7fffe400,0x4c000002,0x0006ffff,
0xfffff100,0xf8000000,0xf000efff,0x40000dff,0x2005fffd,0x2ffffffa,
0xf8800000,0x7fe4403f,0xffffffff,0xffffffff,0xffe8000f,0x0000006f,
0x13fffe20,0xff100000,0x000bffff,0x3fffe600,0x70000003,0x4003ffff,
0x00006fff,0x4017fff6,0xffdefff9,0x4000000f,0x3e600ffb,0xffffffff,
0xffffffff,0x8000ffff,0x002ffff8,0xff700000,0x000000bf,0xfff9fffb,
0x2a000007,0x00007fff,0x07fffd00,0x006fff80,0x17fff600,0x27fffa20,
0x000efff8,0x81bf6000,0xfffffff8,0xeeeeefff,0x0eeeffff,0xbfff3000,
0x20000000,0x0000ffff,0xa7ffe400,0x0001fffd,0x07fff900,0xffa80000,
0xfff8004f,0x3f600006,0xffd805ff,0x17ffee4f,0x4ff80000,0x3fffff60,
0xc83fffff,0x200007ff,0x0001fffa,0x7ffdc000,0x54000001,0x3fe26fff,
0x000000ff,0x0000dffb,0x006ffe80,0x000dfff0,0x004ccc40,0x3a1bffee,
0x00003fff,0xf301ff98,0xffffffff,0xfff907ff,0xffc80000,0x40000005,
0x00003fff,0x0ffffc40,0x001bffee,0x17ff4400,0xffa80000,0xfff0000f,
0x0000000d,0x00000000,0x7dc0ff90,0xffffffff,0x7ffc83ff,0x00000000,
0x00000000,0x00000000,0x00000000,0xf8000000,0x000006ff,0x00000000,
0x205fe800,0xfffffffd,0xfc83ffff,0x2600007f,0x0009abca,0x79530000,
0x00000135,0x26af2a60,0x00000000,0x00000000,0x0037ffc0,0xfb826200,
0xb80005ff,0xb9805fff,0x02ffccdc,0x3ffffffa,0xc83fffff,0x2e0007ff,
0xffffffed,0x00002dff,0x7ffff6dc,0x002dffff,0x7ff6dc00,0x2dffffff,
0x17ffee00,0x3ffee000,0x00bfff75,0x4bfff700,0x65446fff,0xfd000acd,
0x02fffdcb,0x2fffdc00,0xfffffb50,0x7f40bfff,0xffffffff,0x7ffc83ff,
0xfffe9800,0xffffffff,0x40003eff,0xffffffe9,0xefffffff,0x7f4c0003,
0xffffffff,0x803effff,0x0005fffb,0xf75fffb8,0x70000bff,0x7ffcbfff,
0xfffffd16,0xfe8019ff,0x017ffee6,0x17ffee00,0x7fffffe4,0x80efffff,
0xfffffffd,0xfc83ffff,0x7fdc007f,0xffffffff,0x4fffffff,0xffff7000,
0xffffffff,0x009fffff,0x3ffffee0,0xffffffff,0x5c04ffff,0x80005fff,
0xff75fffb,0xf70000bf,0x77ffcbff,0xfffffff9,0x3e01ffff,0x17ffee7f,
0x3ffee000,0xfffffd85,0xfffffbbd,0x7fffe42f,0x3fffffff,0x1007ffc8,
0x9dfffffb,0x3faea635,0x000effff,0xdfffffb1,0x3aea6359,0x00efffff,
0xfffffb10,0x2ea6359d,0x0efffffe,0x00bfff70,0x2bfff700,0x0005fffb,
0x3e5fffb8,0xdfffffff,0xfffffdbb,0x7dcfff02,0xb80005ff,0x7fdc5fff,
0x3fea0bff,0x7d46fffe,0xffffffff,0x7ffc83ff,0xfffffd00,0x3ffaa005,
0xffd006ff,0x2a005fff,0x006ffffe,0x05fffffd,0x3ffffaa0,0x0bfff706,
0xbfff7000,0x0017ffee,0xf97ffee0,0x80dfffff,0x40ffffe8,0x3fee7ff8,
0xfb80005f,0x3ffe25ff,0xe8ffc84f,0x7ff41fff,0xffffffff,0x807ffc83,
0x00dffffb,0x4ffffd80,0x6ffffdc0,0xfffd8000,0x7ffdc04f,0xfd8000df,
0xffb84fff,0xfb80005f,0xbfff75ff,0xfff70000,0x27ffffcb,0x13fffa20,
0x3ee1fff1,0xb80005ff,0x3ff25fff,0x269ff06f,0x7fcc5fff,0xffffffff,
0x407ffc83,0x004ffff8,0x0ffffe40,0x04ffff88,0x7fffe400,0x9ffff101,
0xfffc8000,0x2fffdc1f,0x7ffdc000,0x00bfff75,0x4bfff700,0x800fffff,
0x7cc7fff9,0xbfff71ff,0xfff70000,0x40ffff4b,0x3bfa2ff9,0xfffffb85,
0xfc83ffff,0x7ffec07f,0xffd00006,0x3fff60df,0xffd00006,0x3fff60df,
0xffd00006,0x5fffb8df,0xfffb8000,0x00bfff75,0x4bfff700,0x2003ffff,
0x3e61fffd,0xbfff71ff,0xfff70000,0x41fffe6b,0x20020ffb,0xffffffe8,
0x07ffc83f,0x00bfffe6,0x7fffd400,0x17fffcc1,0xfffa8000,0x7fffcc1f,
0xff500002,0x7ffdc3ff,0xffb80005,0x0bfff75f,0xbfff7000,0x0007fffc,
0x7d45fff5,0xbfff72ff,0xfff70000,0x41bffeab,0x2a0006fd,0x83ffffdc,
0x3f607ffc,0x400005ff,0x7ec4fffe,0x400005ff,0x7ec4fffe,0x400005ff,
0x3ee4fffe,0xb80005ff,0xfff75fff,0xff70000b,0x037ffcbf,0xa93ffe60,
0xfff72fff,0xff70000b,0x13ffeebf,0x0000ffe2,0x641fffc4,0x3ffe07ff,
0x5c00002f,0x7ffc7fff,0x5c00002f,0x7ffc7fff,0x5c00002f,0x3fee7fff,
0xfb80005f,0xbfff75ff,0xfff70000,0x002fffcb,0xfb97ffe2,0xbfff73ff,
0xfff70000,0x20ffff2b,0x00001ffa,0xf907fff1,0x3ffe20ff,0x4400000f,
0xff11ffff,0x800001ff,0xf11ffff8,0x00001fff,0x71ffff88,0x0000bfff,
0x3eebfff7,0xb80005ff,0x3ffe5fff,0x7fff8004,0x7dcfffee,0xb80005ff,
0xfff95fff,0x000ff905,0x41fffc40,0xff307ffc,0x200000ff,0xff33fffe,
0x200000ff,0xff33fffe,0x200000ff,0xff73fffe,0xf70000bf,0x3ffeebff,
0xffb80005,0x00fffe5f,0xfc9fffe0,0xbfff74ff,0xfff70000,0x20ffff2b,
0x200004ff,0xfc83fff8,0xffff507f,0x3f600000,0xffff53ff,0x3f600000,
0xffff53ff,0x3f600000,0xbfff73ff,0xfff70000,0x017ffeeb,0x97ffee00,
0xf8004fff,0x3fff27ff,0x00bfff75,0x2bfff700,0x7cc5fffb,0x2200002f,
0xffc83fff,0x0dfff707,0x3ff60000,0x0dfff74f,0x3ff60000,0x0dfff74f,
0x3ff60000,0x0bfff74f,0xbfff7000,0x0017ffee,0xf97ffee0,0x7c4005ff,
0x3fff66ff,0x00bfff75,0x2bfff700,0x7dc6fffa,0x019a880f,0x20fffe20,
0xff907ffc,0x2000009f,0xff95fffc,0x2000009f,0xff95fffc,0x2000009f,
0xff75fffc,0xf70000bf,0x3ffeebff,0xffb80005,0x01bffe5f,0x6cbfff30,
0xfff76fff,0xff70000b,0x1fffe6bf,0x3ff20bfd,0xfff1002f,0x20fff907,
0x0004fffd,0x2bfff900,0x0004fffd,0x2bfff900,0x0004fffd,0x2bfff900,
0x0005fffb,0xf75fffb8,0x70000bff,0x7ffcbfff,0x7ffdc007,0x5dbfffa3,
0x80005fff,0x3fa5fffb,0x07ff11ff,0x4003fffa,0xfc83fff8,0xbfffb07f,
0x3f600000,0xbfffb4ff,0x3f600000,0xbfffb4ff,0x3f600000,0xbfff74ff,
0xfff70000,0x017ffeeb,0x97ffee00,0x2003ffff,0x3fe0ffff,0xbfff77ff,
0xfff70000,0x477ffdcb,0xffa81ffa,0x3fe2005f,0x07ffc83f,0x000dfff9,
0x4ffffa00,0x0006fffc,0x27fffd00,0x0006fffc,0x27fffd00,0x0005fffb,
0xf75fffb8,0x70000bff,0x7ffcbfff,0xfff7007f,0x57ffff8d,0x0000dfff,
0x7c49fff9,0x87fccfff,0x002ffff8,0x320fffe2,0xfff707ff,0x3e00000f,
0xfff73fff,0x3e00000f,0xfff73fff,0x3e00000f,0xfff53fff,0xff90000d,
0x1bffea9f,0x3fff2000,0x17ffffe4,0x83ffff50,0xff57ffff,0xfb0000df,
0xfffa89ff,0x7fd44fff,0x7c4004ff,0x7ffc83ff,0x01ffff50,0xfff88000,
0x1ffff52f,0xff880000,0xffff52ff,0xf8800001,0xfff52fff,0xffb0000d,
0x1bffea9f,0x3fff6000,0x3fffffe4,0x7ffdc41e,0x7ffff84f,0x000dfff3,
0x907fffd0,0xb9dfffff,0x00bfffff,0x907fff10,0x7ffc0fff,0x5400001f,
0x7ffc7fff,0x5400001f,0x7ffc7fff,0x5400001f,0x3fe67fff,0xfe80006f,
0xdfff33ff,0xfffd0000,0x7fffffc7,0xfffeefff,0xfff80dff,0x0ffff37f,
0x7fffd000,0x3ffffee0,0x0dffffff,0x3fff8800,0x3207ffc8,0x00006fff,
0x3227fff4,0x00006fff,0x3227fff4,0x00006fff,0xf327fff4,0xd0000fff,
0x3fe67fff,0xfe80007f,0x3bffe3ff,0xffffffe8,0x3fe04fff,0x3fffe7ff,
0x7ffc0001,0x3ffe601f,0x01efffff,0x0fffe200,0xfa81fff2,0x00002fff,
0xa83ffff7,0x0002ffff,0x83ffff70,0x002ffffa,0x3ffff700,0x001ffff8,
0xf0ffffc0,0x80003fff,0x3fe1ffff,0x3ffff26f,0x76c01dff,0x3fff65ee,
0x3fee0003,0x67fcc07f,0x0000abca,0xc83fff88,0x7ff407ff,0x440000ff,
0xfd06ffff,0x80001fff,0xd06ffff8,0x0001ffff,0x86ffff88,0x0003fffd,
0xfb1fffee,0x5c0007ff,0x7ffc7fff,0x00aba986,0xffffb800,0xffff0000,
0x01ffb80b,0xfff10000,0x80fff907,0x004ffff9,0x0ffffec0,0x04ffff98,
0x7fffec00,0x9ffff301,0xfffd8000,0xffffb81f,0xffff0000,0x0ffffb8b,
0xbffff000,0x0006fff8,0xffff3000,0xfff7000b,0x06fe805f,0x3fe20000,
0x07ffc83f,0x0dffffc8,0x7fff4400,0x7ffe404f,0x744000df,0x6404ffff,
0x000dffff,0x27ffff44,0x05ffff98,0x2ffffb80,0x02ffffcc,0x17fffdc0,
0x0001bffe,0x643ffff8,0x801effff,0x06ffffe9,0x00027fc4,0x07fff100,
0x3a00fff9,0x002fffff,0x0dfffff5,0x3fffffa0,0xffff5002,0x3ffa00df,
0xf5002fff,0xc80dffff,0x801effff,0x06ffffe9,0x03dffff9,0xdffffd30,
0x000dfff0,0x21ffffc0,0xfffffff8,0xfecbaace,0x401fffff,0x00001ffa,
0x20fffe20,0xb1007ffc,0x79dfffff,0xffd97313,0x2001dfff,0xefffffd8,
0xecb989bc,0x00efffff,0xfffffb10,0x9731379d,0x1dfffffd,0xfffff880,
0xcbaaceff,0x1ffffffe,0xffffff10,0xd97559df,0x03ffffff,0x0000dfff,
0x4c1ffffc,0xfffffffe,0xffffffff,0x7fc801ff,0x7c400000,0x7ffc83ff,
0x7fffe400,0xffffffff,0x004fffff,0xffffff90,0xffffffff,0x20009fff,
0xfffffffc,0xffffffff,0x3a6004ff,0xffffffff,0xffffffff,0x7ff4c01f,
0xffffffff,0x1fffffff,0x000dfff0,0x81ffffc0,0xffffffd8,0xffffffff,
0x0bff000e,0xff880000,0x07ffc83f,0xffffea80,0xffffffff,0x540002ef,
0xfffffffe,0x2effffff,0x7ff54000,0xffffffff,0x8002efff,0xffffffd8,
0xffffffff,0xffb1000e,0xffffffff,0x401dffff,0x00006fff,0x3006eeee,
0xfffffff9,0x40039fff,0x00002ff9,0x41fffc40,0x20007ffc,0xffffffd9,
0x0001cfff,0x7fffecc0,0x01cfffff,0x7fecc000,0xcfffffff,0xfc980001,
0xffffffff,0x930001cf,0xffffffff,0xff0039ff,0x000000df,0x2eea6600,
0x8800099a,0x000000eb,0x5c177744,0x300006ee,0x00335953,0x2a660000,
0x000019ac,0x35953300,0x4c000003,0x099abba9,0x2a660000,0x00099abb,
0x00017bba,0x00000000,0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,0x4ccc0000,0x00000019,
0x00999988,0x99980000,0x80000009,0x00009998,0x13333100,0x30000000,
0x00003333,0x00266620,0x01333310,0x3f6a0000,0x2ffcc0ce,0x7fec0000,
0x000002ff,0x1bfffe20,0x3f200000,0x00002fff,0x77fffcc0,0xf8800000,
0x00006fff,0x7fffcc00,0xf9800005,0x54006fff,0xfe85ffff,0x7e4002ff,
0x9bdfffff,0x00004ffd,0x00dfffd0,0x7fe40000,0x000000ff,0x027fffc4,
0x3fa20000,0x0005ffff,0x5ffff500,0x6c000000,0x0000efff,0x7ffffc40,
0x7fdc005f,0x7fff41ff,0x3ffe6002,0xffffffff,0x000001ff,0x003ffff1,
0xfff10000,0x0000003f,0x000dfff7,0x9fffb000,0x00007fff,0x01bffee0,
0x7fcc0000,0x800000ff,0xfffcfffd,0x7ffe4003,0x017fff45,0x9319ff90,
0x09ffffff,0xff980000,0x8000005f,0x0003fffb,0x1ffff000,0xfb800000,
0x5fffb5ff,0x3f200000,0x000002ff,0x002fffd8,0x4fffc800,0x8003fffb,
0x3fa0fffe,0x3f6002ff,0x2dedb81f,0xf5000000,0x000003ff,0x0005fff8,
0x3fff7000,0xf9800000,0xfff10fff,0x2000003f,0x00006ffe,0x027ffc40,
0x7ffd4000,0x1ffff10e,0x27ff4400,0x0005fffd,0x00000000,0x0017ff20,
0x0effb800,0xfd000000,0x8000007f,0x542ffff8,0x0000efff,0x02ffe880,
0x3ff20000,0xf8800005,0x7fdc1fff,0x7fcc006f,0x05fffd0f,0xabca9800,
0x00000009,0x00000000,0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x17fff400,0x3ffb6e00,0x2dffffff,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,0x00000000,0x2005fffd,
0xffffffe9,0xefffffff,0xff000003,0x5c000fff,0xffffffff,0xffffffff,
0x05ffffff,0x3ffffc00,0x3e000000,0x20007fff,0xfffffffb,0xffffffff,
0x5fffffff,0x013fffee,0xffffd800,0xffffff70,0xffffffff,0xffffffff,
0x8bfffa0b,0xb802fffe,0xffffffff,0xffffffff,0x5400004f,0x002fffff,
0xffffff70,0xffffffff,0xffffffff,0x7fd4000b,0x00002fff,0xfffff500,
0x3fee0005,0xffffffff,0xffffffff,0x7f45ffff,0x80001fff,0x2e3ffffb,
0xffffffff,0xffffffff,0x05ffffff,0x7f45fffd,0x3f6202ff,0x1aceffff,
0xffffd753,0x200001df,0x06fffffd,0xfffff700,0xffffffff,0xffffffff,
0x7ec000bf,0x0006ffff,0xffffb000,0x3ee000df,0xffffffff,0xffffffff,
0x4c5fffff,0x0006ffff,0x22ffffc4,0xfffffffb,0xffffffff,0x5fffffff,
0x745fffd0,0x3fa02fff,0x5002ffff,0x00dffffd,0xfdfff100,0xf70003ff,
0xdddddfff,0xdddddddd,0x009ddddd,0x3fbffe20,0x000001ff,0x7ff7ffc4,
0xffb8001f,0xeeeeeeff,0xeeeeeeee,0xfb84eeee,0x20004fff,0x5c0ffffd,
0xeeeeffff,0xeeeeeeee,0x04eeeeee,0x7f45fffd,0xfff702ff,0xfb0001bf,
0x80009fff,0xfff9fffb,0xfffb8004,0x00000005,0xff9fffb8,0x4000004f,
0xfff9fffb,0xfffb8004,0xe8000005,0x8001ffff,0xb82ffffa,0x00005fff,
0x22fffe80,0xf882fffe,0x40004fff,0x001ffffc,0x7f5bffa0,0x7dc000ff,
0x000005ff,0xd6ffe800,0x00001fff,0xfeb7ff40,0x7dc000ff,0x000005ff,
0x06ffff98,0x2ffffc40,0x005fffb8,0xfffe8000,0x20bfffa2,0x0006fffd,
0x00dfffd0,0x64fffe60,0x5c003fff,0x00005fff,0x7ffcc000,0x007fff93,
0x3ffe6000,0x007fff93,0x005fffb8,0xfff70000,0x7fec007f,0xfff700ef,
0xd000000b,0x7ff45fff,0x7fffcc2f,0xff500002,0xf90003ff,0x3ffe63ff,
0x7ffdc006,0x00000005,0xf98fffe4,0x000006ff,0x3e63fff9,0x7dc006ff,
0x000005ff,0x07ffffa0,0x07fffea0,0x005fffb8,0xfffe8000,0xb0bfffa2,
0x0000bfff,0x004fffe8,0x7f47fff8,0x3ee001ff,0x000005ff,0x23fffc00,
0x0001fffe,0x747fff80,0x2e001fff,0x00005fff,0x3fffe600,0x7fffc406,
0x2fffdc04,0x7f400000,0x3fffa2ff,0x017fffc2,0x3ffee000,0x7ffd4007,
0x027ffdc4,0x00bfff70,0x7d400000,0x7ffdc4ff,0x7d400004,0x7ffdc4ff,
0x3ffee004,0x40000005,0x203ffffb,0xb806fffd,0x00005fff,0x22fffe80,
0x3e22fffe,0x00000fff,0x00ffffc4,0x883fffb0,0x7000ffff,0x0000bfff,
0x7ffec000,0x07fffc41,0xfffb0000,0x0ffff883,0x0bfff700,0xfd000000,
0xff501fff,0xff7003ff,0x000000bf,0x7f45fffd,0x3ffe62ff,0xfd000007,
0x3e2007ff,0xfffb06ff,0x3ffee007,0x00000005,0x360dfff1,0x00003fff,
0x360dfff1,0xf7003fff,0x00000bff,0xbffff300,0x009fffd0,0x0017ffee,
0x3fffa000,0xa8bfffa2,0x00007fff,0x007fffb0,0x5413ffee,0xf7006fff,
0x00000bff,0x13ffee00,0x0037ffd4,0x04fffb80,0x200dfff5,0x0005fffb,
0xfff70000,0x37ffe45f,0x0bfff700,0xffd00000,0x17fff45f,0x000dfff7,
0x13fff600,0x00ffff40,0x7003ffff,0x5555dfff,0x55555555,0x00355555,
0x201fffe8,0x0001ffff,0x201fffe8,0xb801ffff,0xaaaaefff,0xaaaaaaaa,
0x001aaaaa,0xf36fffe8,0x5c003fff,0xaaaaefff,0xaaaaaaaa,0x201aaaaa,
0x3fa2fffe,0x3fff22ff,0xf9000004,0xff300bff,0xfffc80df,0xffffb805,
0xffffffff,0xffffffff,0x3fe6003f,0x7ffe406f,0x7fcc0005,0x7ffe406f,
0xffffb805,0xffffffff,0xffffffff,0xff98003f,0x3fffdbff,0x7fffdc00,
0xffffffff,0xffffffff,0x3fffa03f,0xd8bfffa2,0x00004fff,0x00bfff90,
0x9807fff9,0x5c00ffff,0xffffffff,0xffffffff,0x003fffff,0x300ffff2,
0x0001ffff,0x201fffe4,0x400ffff9,0xfffffffb,0xffffffff,0x03ffffff,
0xfffff700,0xf7000bff,0xffffffff,0xffffffff,0x7407ffff,0x3ffa2fff,
0x17fff62f,0x7fec0000,0x7ffc404f,0xfffe800f,0x7fffdc03,0xffffffff,
0xffffffff,0xfff1003f,0xfffd001f,0x3fe20007,0xffe800ff,0x7ffdc03f,
0xffffffff,0xffffffff,0x3a0003ff,0x00ffffff,0xfffffb80,0xffffffff,
0xffffffff,0x8bfffa03,0x3f22fffe,0x000006ff,0xb807fffd,0xf7005fff,
0xffb80dff,0xaaaaaaef,0xaaaaaaaa,0xf7001aaa,0x3ee00bff,0xf70006ff,
0x3ee00bff,0x7fdc06ff,0xaaaaaaef,0xaaaaaaaa,0x20001aaa,0x02fffff9,
0x5dfff700,0x55555555,0x55555555,0x17fff403,0x7dc5fffd,0x000007ff,
0xe807ffff,0x9999bfff,0xff999999,0x3fee02ff,0x0000005f,0x4cdffff4,
0x99999999,0x8002ffff,0x999bfffe,0xf9999999,0x3ee02fff,0x000005ff,
0xdfff9000,0x7ffdc000,0xe8000005,0x3ffa2fff,0x3fffea2f,0x7c400000,
0x3e602fff,0xffffffff,0xffffffff,0x3fee05ff,0x0000005f,0x3fffffe6,
0xffffffff,0x005fffff,0x7fffffcc,0xffffffff,0x205fffff,0x0005fffb,
0xff700000,0x7dc000bf,0x000005ff,0x3a2fffe8,0x7ffc2fff,0x5400001f,
0x7e407fff,0xffffffff,0xffffffff,0xff700fff,0x000000bf,0x7fffffe4,
0xffffffff,0x00ffffff,0x3fffff20,0xffffffff,0x0fffffff,0x00bfff70,
0x2e000000,0x20005fff,0x0005fffb,0x2fffe800,0xf90bfffa,0x80000dff,
0x7c04fffe,0xffffffff,0xffffffff,0xf703ffff,0x00000bff,0x7fffffc0,
0xffffffff,0x3fffffff,0x3ffffe00,0xffffffff,0xffffffff,0x0bfff703,
0x20000000,0x0005fffb,0x0017ffee,0x3fffa000,0x50bfffa2,0x0005ffff,
0x07fffee0,0x99efffa8,0x99999999,0x6fffc999,0x00bfff70,0x3fea0000,
0x999999ef,0xc9999999,0xf5006fff,0x33333dff,0x33333333,0x2e0dfff9,
0x00005fff,0xfff70000,0x7fdc000b,0x8000005f,0x3fa2fffe,0xfffe82ff,
0x7c40000f,0x7ec06fff,0xf10003ff,0xff705fff,0x000000bf,0x000ffff6,
0x017fffc4,0x001fffec,0x82ffff88,0x0005fffb,0xff700000,0x7dc000bf,
0x000005ff,0x3a2fffe8,0xff982fff,0x6c0004ff,0x2201ffff,0x0000ffff,
0x2e17fffa,0x00005fff,0x0ffff880,0x3fffa000,0x7fffc405,0x3ffa0000,
0x5fffb85f,0x00000000,0x000bfff7,0x002fffdc,0x7fff4000,0xfffc8002,
0x744000df,0x5c04ffff,0x40005fff,0x5c0ffffa,0x00005fff,0x05fffb80,
0x7fffd400,0x17ffee00,0xffff5000,0x05fffb81,0x70000000,0x4000bfff,
0x0005fffb,0x2fffe800,0xe806eeea,0x002fffff,0x0dfffff5,0x005fffd0,
0x4ffff880,0x002fffdc,0x7fff4000,0x7fc40002,0x3ffa04ff,0x7c40002f,
0x7fdc4fff,0x0000005f,0x0bfff700,0x2fffdc00,0x7f400000,0x3fffa2ff,
0x3fff6203,0x989bceff,0xfffffecb,0x7ffcc00e,0xfc80000f,0x7ffdc7ff,
0x4c000005,0x0000ffff,0x307fffc8,0x0001ffff,0xb8ffff90,0x00005fff,
0xfff70000,0x7fdc000b,0x8000005f,0x3fa2fffe,0xffc803ff,0xffffffff,
0x4fffffff,0x0bfff900,0x3ffe6000,0x3fffee2f,0xeeeeeeee,0xeeeeeeee,
0x7fe42eee,0xf300005f,0xff905fff,0x260000bf,0x3ee2ffff,0xeeeeefff,
0xeeeeeeee,0x02eeeeee,0x0bfff700,0x7fffdc00,0xeeeeeeee,0xeeeeeeee,
0xffe82eee,0x0ffffa2f,0x7ffff540,0xffffffff,0x3fe002ef,0x200002ff,
0x3ee5fffe,0xffffffff,0xffffffff,0x43ffffff,0x0002ffff,0x217fffa0,
0x0002ffff,0xb97fffa0,0xffffffff,0xffffffff,0x3fffffff,0xbfff7000,
0x7ffdc000,0xffffffff,0xffffffff,0xfe83ffff,0x3fffa2ff,0x7fecc003,
0xcfffffff,0x7ffd4001,0x7dc00007,0xfff70fff,0xffffffff,0xffffffff,
0x7d47ffff,0x400007ff,0x2a0ffffb,0x00007fff,0xb87fffdc,0xffffffff,
0xffffffff,0x3fffffff,0xbfff7000,0x7ffdc000,0xffffffff,0xffffffff,
0xfe83ffff,0x000002ff,0x03359533,0x27ffec00,0x3fe20000,0xffff74ff,
0xffffffff,0xffffffff,0x7fec7fff,0x4400004f,0x3f64ffff,0x400004ff,
0xf74ffff8,0xffffffff,0xffffffff,0x07ffffff,0x17ffee00,0xffffb800,
0xffffffff,0xffffffff,0xffe83fff,0x0000002f,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,0x00000000,0x26660000,
0x3fe80019,0x55550000,0x00155550,0x00000000,0x4c0aaa98,0x00001aaa,
0x80000000,0x54c0aaa9,0x555401aa,0x05554c0a,0x81555300,0x0001aaa9,
0x05edc400,0x3ffe6000,0x3fe8004f,0xfff88000,0x00ffff87,0x677ecc00,
0x0007ff81,0x3217ffec,0x00003fff,0x82deec88,0x20000ffd,0x7e42fffd,
0x7ff403ff,0x17ffec0f,0x85fffb00,0x0003fffc,0x3fbfea00,0x3f60001f,
0xb73006ff,0x059dffff,0x1fffe200,0x0003fffe,0xffffffa8,0x05ffc9be,
0x17ffec00,0x000ffff2,0xfffff300,0xfff539df,0xfffd8000,0x01fffe42,
0xfb03fffa,0x7ec005ff,0x7ffe42ff,0x3a000003,0x000bd10e,0x003fffe6,
0xffffffb1,0x005dffff,0xf87fff88,0x10000fff,0xffffffff,0x007fffff,
0x42fffd80,0x0003fffc,0x7ffffec0,0x4fffffff,0x7ffec000,0x01fffe42,
0xfb03fffa,0x7ec005ff,0x7ffe42ff,0xf3000003,0x8000fa85,0x4402fffd,
0xffffffff,0x02ffffff,0x21fffe20,0x0000ffff,0xd711dff5,0x00dfffff,
0x85fffb00,0x0003fffc,0x227ffe20,0xffffffda,0x7fec0000,0x1fffe42f,
0xb03fffa0,0x6c005fff,0x7fe42fff,0x3000003f,0x001fa85f,0x401fffcc,
0xeadffffe,0xfffffdcf,0x00000001,0xa83ffb80,0x00003eed,0x80000000,
0xec984ff9,0x000000ce,0x00000000,0x00000000,0x0db17a00,0x00bff900,
0x743dfff9,0xdfffd53f,0x00000000,0x00000000,0x4d5e54c0,0x00000000,
0x00000000,0x00000000,0x00000000,0x2ffcffb8,0x7c400000,0x1ff41fff,
0x5c3ffff3,0x80005fff,0x0005fffb,0xb7000000,0xfffffffd,0x000005bf,
0x7dc00000,0xffffffff,0xffffffff,0x205fffff,0x0002fffe,0x01ffffe0,
0xfff00000,0x000000ff,0xfd09fff3,0x24fffe87,0x0005fffb,0xf95fffb8,
0x80001fff,0x9804fffa,0xfffffffe,0x3effffff,0xfff00000,0x7dc000ff,
0xffffffff,0xffffffff,0x205fffff,0x0002fffe,0x5fffff50,0x2a000000,
0x002fffff,0x205fffd0,0xfe82fffb,0x72fffdc3,0x0000bfff,0x3f2bfff7,
0x40005fff,0x5c04fffa,0xffffffff,0xffffffff,0x5400004f,0x002fffff,
0xffffff70,0xffffffff,0xffffffff,0x17fff40b,0xfffd8000,0x000006ff,
0xdfffffb0,0x3fffa000,0x03fff902,0x701507fd,0x0000bfff,0x3f2bfff7,
0x0003ffff,0x4413ffea,0xcefffffd,0xffd7531a,0x0001dfff,0x3fffff60,
0xfff70006,0xdddddddf,0xdddddddd,0x7f409ddd,0x880002ff,0x1fffefff,
0x7c400000,0x01fffeff,0x02fffe80,0xfd07fff9,0x7ffdc007,0xffb80005,
0xfffff95f,0x3ea0001f,0xfffd04ff,0x3aa005ff,0x0006ffff,0xffefff88,
0xffb8001f,0x0000005f,0x0005fffd,0xff3fff70,0x8000009f,0xfff9fffb,
0xfffe8004,0x0dfff502,0x7dc007fd,0xb80005ff,0xfff95fff,0x2000bfff,
0xfb84fffa,0x8000dfff,0x004ffffd,0x7cfffdc0,0xfb8004ff,0x000005ff,
0x005fffd0,0x3adffd00,0x00000fff,0x7f5bffa0,0x7f4000ff,0xfff102ff,
0x003fe81f,0x0017ffee,0x657ffee0,0x3fffffff,0x4fffa800,0x027fffc4,
0x3ffff200,0x3ffa0001,0x001fffd6,0x005fffb8,0xfffd0000,0xff980005,
0x07fff93f,0x3fe60000,0x07fff93f,0x02fffe80,0xe87bfffa,0x3fee003f,
0xfb80005f,0xffff95ff,0x8001ffff,0x7ec4fffa,0xd00006ff,0x2000dfff,
0xff93fff9,0xffb8007f,0x0000005f,0x0005fffd,0xf31fffc8,0x00000dff,
0x7cc7fff2,0x7f4006ff,0x3fe602ff,0x3fe9cfff,0x17ffee00,0x3ffee000,
0xff9fff95,0xfa800bff,0x3ffe64ff,0xf500002f,0x90003fff,0x3fe63fff,
0x7fdc006f,0x0000005f,0x0005fffd,0x7f47fff8,0x800001ff,0x7ff47fff,
0x3ffa001f,0x7ffcc02f,0x00cfffff,0x00bfff70,0x2bfff700,0xffabfffc,
0x3ea003ff,0x3fff64ff,0x7f400005,0xff8004ff,0x0ffff47f,0x0bfff700,
0x3fa00000,0x2a0002ff,0x7fdc4fff,0x5400004f,0x7fdc4fff,0x3ffa004f,
0xfff9802f,0xceffffff,0x17ffee01,0x3ffee000,0x367fff95,0x5000ffff,
0x7ffc9fff,0x5c00002f,0x54007fff,0x7fdc4fff,0x3fee004f,0x0000005f,
0x0005fffd,0x220fffec,0x0000ffff,0x107fff60,0x2001ffff,0x1002fffe,
0xffffffd7,0x3ee09fff,0xb80005ff,0xfff95fff,0x17fffe27,0x8a7ffd40,
0x0000ffff,0x0ffffc40,0x83fffb00,0x000ffff8,0x000bfff7,0x3fffa000,
0xfff10002,0x0ffff60d,0x7ffc4000,0x07fffb06,0x00bfffa0,0x3ffff260,
0x5c1effff,0x80005fff,0xff95fffb,0x7fffd47f,0x4fffa803,0x000ffff3,
0x0ffffa00,0x837ffc40,0x7003fffd,0x0000bfff,0x0bfffa00,0x27ffdc00,
0x006fffa8,0x09fff700,0x401bffea,0x0002fffe,0x3fffb7fa,0x7ffdc6ff,
0xffb80005,0x87fff95f,0x400ffffd,0xff54fffa,0x200000ff,0x7003fffd,
0x3ea09fff,0xff7006ff,0x555555df,0x55555555,0xfe803555,0xfd0002ff,
0x7ffc03ff,0xfe80001f,0x3ffe01ff,0xfffe801f,0x4ffa0002,0x23ffffd9,
0x0005fffb,0xf95fffb8,0xfff887ff,0x7ffd405f,0x00dfff74,0x3fff6000,
0x3fffd004,0x00ffffc0,0x7fffffdc,0xffffffff,0x3fffffff,0x017fff40,
0x037ffcc0,0x0017fff2,0x80dfff30,0xe805fffc,0x20002fff,0x7ffe43fe,
0x0bfff70f,0xbfff7000,0x2a0ffff2,0x2a03ffff,0xfff94fff,0x32000009,
0xf9805fff,0x7fe406ff,0xfffb805f,0xffffffff,0xffffffff,0x7ff403ff,
0xffc8002f,0x7ffcc03f,0x3f20000f,0x7fcc03ff,0x7ff400ff,0x3fa0002f,
0x97fffc43,0x0005fffb,0xf95fffb8,0x3ff607ff,0xfff500ff,0x013fff69,
0x7ffe4000,0x3fffc805,0x07fffcc0,0x3ffffee0,0xffffffff,0xffffffff,
0x17fff403,0x3fffe200,0x3fffe800,0xffff1000,0x7fffd001,0x02fffe80,
0x360ffa00,0xfff73fff,0xff70000b,0x0ffff2bf,0x837fffc4,0xffb4fffa,
0x200000bf,0x4404fffd,0xe800ffff,0x7dc03fff,0xaaaaaeff,0xaaaaaaaa,
0x7401aaaa,0x5c002fff,0xf7005fff,0x2e000dff,0xf7005fff,0xffe80dff,
0x40ae602f,0xfffb83fe,0x00bfff75,0x2bfff700,0x2e03fffc,0xfa83ffff,
0xdfff94ff,0x3fa00000,0x7fdc03ff,0xfff7005f,0x5fffb80d,0xfd000000,
0xfe8005ff,0x99999bff,0xfff99999,0xffe8002f,0x999999bf,0xffff9999,
0x0bfffa02,0x741bffea,0x5fffa83f,0x000dfff5,0x329fff90,0x7ec03fff,
0x7fd40fff,0x0ffff74f,0x3ffe0000,0x7fff403f,0x9999999b,0x2ffff999,
0x017ffee0,0x7ff40000,0x3fe6002f,0xffffffff,0xffffffff,0x7fcc005f,
0xffffffff,0xffffffff,0x3fffa05f,0x07fff882,0xfff707fd,0x01bffea7,
0x53fff600,0x4403fffc,0x7d46ffff,0xffff54ff,0xf8800001,0x3e602fff,
0xffffffff,0xffffffff,0x3fee05ff,0x0000005f,0x4005fffd,0xfffffffc,
0xffffffff,0x000fffff,0x3ffffff2,0xffffffff,0x00ffffff,0x3e05fffd,
0x3fe82fff,0xf32fffd8,0xd0000dff,0x3ff27fff,0xfffb803f,0x93ffea3f,
0x0001ffff,0x03fffd40,0x3ffffff2,0xffffffff,0x00ffffff,0x000bfff7,
0x3fffa000,0x3fffe002,0xffffffff,0xffffffff,0x3ffe003f,0xffffffff,
0xffffffff,0xfffd03ff,0x1bfff205,0xfff30ffa,0x1fffe61f,0x3fffa000,
0x007fff93,0x543ffff6,0x3ff24fff,0x7400006f,0x7fc04fff,0xffffffff,
0xffffffff,0xff703fff,0x000000bf,0x400bfffa,0x999efffa,0x99999999,
0x06fffc99,0x33dfff50,0x33333333,0xdfff9333,0x40bfffa0,0x744ffff9,
0x3fffa23f,0x00ffffc4,0x47fffe00,0x1003fffc,0x3eadffff,0x3ffea4ff,
0xf700002f,0x7d403fff,0x99999eff,0x99999999,0xf706fffc,0x00000bff,
0x00bfffa0,0x001fffec,0x02ffff88,0x003fffd8,0x05ffff10,0x6405fffd,
0xfd0dffff,0x1bfffea7,0x000ffff6,0x327fffb8,0x2e003fff,0xffabffff,
0x7ffff44f,0x7fc40000,0x7fec06ff,0xff10003f,0xfff705ff,0x2000000b,
0x8802fffe,0x0000ffff,0x1017fffa,0x0001ffff,0x742ffff4,0x7e402fff,
0xeffeffff,0x81ffffff,0x000ffffb,0x64bffff0,0x6c003fff,0xfffcffff,
0x27fffcc4,0x3fff6000,0x3ffe201f,0x3fa0000f,0xfffb85ff,0xd0000005,
0xf7005fff,0xa8000bff,0x2e00ffff,0x40005fff,0x740ffffa,0xfc802fff,
0xffffffff,0xf301efff,0x7000bfff,0x7e45ffff,0x7c4003ff,0x4fffffff,
0x0dffffc8,0x7fff4400,0x7ffdc04f,0x7fd40005,0x7ffdc0ff,0xd0000005,
0xfd005fff,0x880005ff,0x3a04ffff,0x40002fff,0x744ffff8,0xb5002fff,
0xffffffff,0xfff9009f,0xfd3003df,0xffc8dfff,0xffb8003f,0xd04fffff,
0x005fffff,0x1bffffea,0x00bfffa0,0x9ffff100,0x005fffb8,0xfffd0000,
0xffff9805,0xffc80000,0xffff307f,0xff900001,0x2fffe8ff,0xdffb9800,
0x3fe2000a,0xacefffff,0xffffecba,0x7ffe41ff,0xfffb0003,0x36209fff,
0xbcefffff,0xffecb989,0x4c00efff,0x0000ffff,0x5c7fffc8,0xeeeeffff,
0xeeeeeeee,0x2eeeeeee,0x805fffd0,0x0005fffc,0x05ffff30,0x000bfff9,
0x8bfffe60,0x0002fffe,0x4c000ffa,0xfffffffe,0xffffffff,0xfffc81ff,
0xfff10003,0xfc809fff,0xffffffff,0xffffffff,0xbfff9004,0x3fe60000,
0x3ffee2ff,0xffffffff,0xffffffff,0xfd03ffff,0xfff805ff,0x3a00002f,
0xfff85fff,0x3a00002f,0x3ffa5fff,0x3fa0002f,0x3f620003,0xffffffff,
0x00efffff,0x0007fff9,0x27ffffdc,0x7ffff540,0xffffffff,0x3fe002ef,
0x200002ff,0x3ee5fffe,0xffffffff,0xffffffff,0x03ffffff,0x5405fffd,
0x00007fff,0x507fffdc,0x0000ffff,0xd0ffffb8,0x40005fff,0x980003fe,
0xfffffffc,0x6401cfff,0x40003fff,0x004ffffd,0x3fffff66,0x001cffff,
0x003fffd4,0x3fffee00,0xffffff70,0xffffffff,0xffffffff,0x3fffa07f,
0x13fff602,0xfff10000,0x27ffec9f,0x3fe20000,0x5fffd4ff,0x00e5c000,
0x2ea66000,0x900099ab,0x80007fff,0x004ffff8,0x33595330,0x7ffec000,
0x7c400004,0x00004fff,0x00000000,0x00000000,0xfd000000,0x000005ff,
0x00000000,0x00000000,0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x5d4c4000,0x00001aac,0x00000000,
0x00015510,0x00333220,0x0000aa88,0x000f32a0,0x54c00000,0x400001aa,
0x26003cca,0x20000aca,0x00004cc8,0x2000732e,0xfffffeb8,0x001cffff,
0x5d4c4000,0xb90009ac,0x17ff4401,0x5ffd8000,0x0bffa200,0x7ffcc000,
0x3faa0001,0xffb8001c,0x003effff,0x01fff980,0xfffffe98,0xffc8000d,
0x3fe00004,0x7fe4000f,0xffffffff,0x001effff,0x7ffed400,0x1dffffff,
0x220dff70,0x0002fffe,0x000effa8,0x005fffd1,0x00fffa00,0xffcefd80,
0x3fff2001,0x03ffffff,0x01fff400,0x7fffffd4,0x22001fff,0x00000fff,
0x4400dff3,0xfffffffe,0xffffffff,0xb80003ff,0xffffffff,0x0dffffff,
0x2e0bffee,0x002fffff,0x00fffc40,0x2fffffb8,0x5ffc8000,0xd13e2000,
0x3ffe600b,0xfffea89b,0xbff90000,0x33fffe00,0x006fffc9,0x00013ff2,
0x5004ffc8,0x9bffffff,0x3feea635,0x0005ffff,0xffffffb1,0xffffffff,
0xfff59fff,0xfffffa87,0x740002ff,0xffa804ff,0x002fffff,0x007ffcc0,
0xfb81f700,0x85ffc800,0x8001fff9,0xb800fffa,0x7fcc0fff,0xfff8802f,
0x3fa00000,0xfff9801f,0xf7000eff,0x800bffff,0xefffffe9,0xeba989ac,
0xffffffff,0xd9dffc84,0x2e0002ff,0xff9006ff,0x005ffb3b,0x017ffc40,
0xf907ea00,0xff500800,0xff88001f,0x7fff002f,0x201bff20,0x00004ffc,
0x7401ffe2,0x8003ffff,0x02ffffe8,0xdfffff10,0x3ffee003,0x3b905fff,
0x80017fec,0x9000fff9,0x017fec3b,0x00bffb00,0x7cc37e00,0x75440004,
0xfd8004ff,0xfff1005f,0x01ffea03,0x0001fff1,0x402ffd40,0x002ffffc,
0x3ffffa20,0xffffd800,0x7ec4000c,0xb0104fff,0xd10005ff,0x404007ff,
0x50002ffd,0x00001dff,0x03ffbfee,0xffffb800,0xeffb8003,0x1fff3000,
0x803ffe60,0x00003ffd,0x2601ffec,0x0005ffff,0x05ffff98,0x01ffffd4,
0xfffffd00,0x0bff6003,0x017ff600,0x00bff600,0x007ffe20,0x05b71000,
0xbfffb000,0xfff88003,0x3ffea001,0x03fff100,0x0003ffe6,0x801fff00,
0x000ffffb,0x1ffff900,0x1bfffe20,0xffffd800,0xffb006ff,0xfffa8005,
0xffd80000,0x4ffe8002,0x00000000,0xfffecb80,0x9ffd000c,0x07ff9800,
0x6c07ffe2,0x400003ff,0xfe806ff9,0x400004ff,0xf502ffff,0x20003fff,
0xfffbfffc,0x2ffd801f,0x0bffe200,0x17fec000,0x01bfee00,0x36ea6000,
0x80001abc,0xc803ffe8,0xf88006ff,0xfff300ff,0x00fff301,0x09ff7000,
0x00ffff98,0x7ffec000,0x0bfffb05,0x47fff200,0xd805ffff,0x3f6002ff,
0x3600004f,0x3e6002ff,0x300000ff,0xfffffffd,0x80007fff,0x7cc06ffb,
0xff0000ff,0x1ffea03f,0x0001ffec,0x2017fec0,0x0006fffc,0x0ffffa80,
0x00ffffc4,0x917ffdc0,0xfb00ffff,0x3fee005f,0x7ec00006,0xffd1002f,
0x3ee00007,0xffffffff,0x440dffff,0xff900cba,0x1fff440f,0x09ffd000,
0x3e617ff6,0x8800007f,0x7ec00fff,0x800005ff,0x541ffff8,0xa8007fff,
0x7fcc3fff,0x7fec00ff,0x1fff9802,0x7fec0000,0x0bff9002,0x3fffa000,
0xfedccdef,0xff84ffff,0x0dfff04f,0x0002ffec,0xf70bffea,0x7ffb03ff,
0xff500000,0x9fffd00b,0x3fe00000,0x7ffdc1ff,0x7ffcc007,0x03ffff04,
0xe802ffd8,0x800003ff,0xfa802ffd,0xb80000ff,0x2602ffff,0x640ffffd,
0xfc9adfff,0xff503fff,0xfd00001f,0xfffd7dff,0x00dff309,0x0fff2000,
0x00ffffa0,0x7fffc000,0x02fffe42,0x409fff10,0x6c02ffff,0x7fe402ff,
0xfb000005,0xfff8805f,0xffd00002,0x3ffa003f,0xffffd83f,0x104fffff,
0x00005fff,0x3fffffa2,0xffe80dff,0xfd000003,0xffff003f,0x3a000005,
0x7fec3fff,0xffd1004f,0x3fffe80b,0x5017fec0,0x00001fff,0xb00bff60,
0x200009ff,0x2005fff9,0xf704fffb,0x05dfffff,0x00027ff4,0x7ffffe40,
0x00dff503,0x1ffe2000,0x017fffc0,0xfffe8000,0x01ffff43,0x400effe8,
0x0004fffd,0x202fff88,0x00bcdcca,0x37fdc000,0x305dd700,0x54003db9,
0x4cc05fff,0x7fdc009a,0x0bbae006,0x3a004c40,0xb97302ff,0x7fdc0037,
0x7ffff004,0x3fe00000,0x7fff43ff,0x0effd803,0x04fffd80,0x04ffd800,
0xfffffff5,0x2600009f,0xf5001fff,0x800005ff,0x0005fff9,0x007ffe60,
0x0017ffd4,0x20dff500,0xdffffffc,0x02ffd800,0x009fffd0,0xffff3000,
0x04fffd85,0x8007ffe4,0x0004fffe,0x54077fdc,0xffffffff,0xe80004ff,
0xff3003ff,0x200005ff,0x05fffda8,0x0fffa000,0x17fffcc0,0x5ffd0000,
0xffffffb0,0xff801dff,0xfffb000f,0xf500000b,0xffc83fff,0x3fff205f,
0x3fffe001,0x3fe60003,0x3bfff01f,0x007fff54,0x00bff900,0x0bffffa2,
0xfd975100,0x0bffffff,0x17ff2000,0x7ffff440,0xff500002,0x3dfff50d,
0x409fff91,0x32006ff9,0x00006fff,0xb87fffb8,0xff706fff,0x7fc4005f,
0x3a0002ff,0xfff503ff,0x05fff503,0x03ffea00,0x7fffff40,0xfffeb802,
0xffffffff,0xa80005ff,0xfd000fff,0x0005ffff,0x3a0bffa0,0xfff984ff,
0x009ff901,0x007fffcc,0x3fff2000,0x87fffa85,0x4003fffa,0x001ffff9,
0x880dff90,0x1fff1019,0x5fff1000,0x3bbff600,0x3fee02ff,0xffffffff,
0x05fffcdf,0x17ffc400,0xfeeffd80,0xfb80002f,0x1fff986f,0x3a09ffd0,
0x7f4001ff,0x200004ff,0x983ffff8,0x3e62ffff,0xfb8004ff,0xf30006ff,
0xb80001ff,0xfb0005ff,0x3ff2009f,0x702ffd8f,0xdfffffff,0x7ffcc379,
0x7fec0005,0x1fff9004,0x00005ffb,0xff505ffd,0x42ffe40f,0xb8007ff8,
0x9001ffff,0x3fff6017,0xbfffd00f,0x0013ffe2,0x00ffffe2,0x00bffe20,
0x05fff300,0x00dff700,0x7ec7ffea,0xffffa82f,0x7fcc00be,0x3ee0005f,
0xfff5006f,0x000bff63,0x2e0dff70,0x3fee06ff,0x005ffa86,0x05ffff88,
0x20cfff88,0x204ffffa,0xfe9ffffa,0xff90005f,0xfb0001ff,0xfb8000bf,
0xf98005ff,0xff9801ff,0x20bff62f,0x000dfffd,0x000bfff5,0x2007ffe6,
0x3f62fff9,0x7fc0002f,0x0bff902f,0x7ec3ffd4,0xff70003f,0xffa805ff,
0xfff8afff,0x7ff400ff,0x000effff,0x06ffff88,0x00fffa80,0xbfffb100,
0x0fffa000,0xb0fffe20,0xffff05ff,0x7ffdc001,0x7ffd0005,0x87fff100,
0x20002ffd,0x3ee06ffb,0x1ffee06f,0x80003ffe,0x204ffffe,0xffffffd9,
0xa803ffff,0x00efffff,0x3ffffb00,0x1fff8800,0xfffd3000,0x3ff20007,
0x09ffd006,0xff985ffb,0x7ff4006f,0xffc8005f,0x09ffd006,0x20005ffb,
0x2e01fff8,0x3fee06ff,0x0037fcc5,0x3ffffe20,0x3ff2201e,0x004fffff,
0x013ffff6,0x3ffffa60,0x4ffe8003,0xffff5000,0x3fe60005,0xfff8800f,
0xffffffff,0xffff34ff,0x3fff2001,0x7fd4005f,0xfff8800f,0xffffffff,
0x7dc004ff,0x3ffd405f,0xfb89ffb0,0xe980004f,0xacefffff,0xfffdba89,
0x2000ffff,0x2efffffc,0xfffff700,0xdff7000b,0x3ffee000,0xfd10000e,
0x3fe2005f,0xffffffff,0xfff14fff,0xfff7009f,0x7c400dff,0xff1002ff,
0xffffffff,0x44009fff,0x7c401fff,0xfff882ff,0x0017ff42,0xffffd880,
0xffffffff,0xffffffff,0xffffb803,0x9aceffff,0xfffedb98,0x4c000dff,
0xa8001fff,0x40005fff,0x54005ffd,0xeaaaaaaa,0x3fa1acff,0xf9302fff,
0x00ffffff,0x2002ffec,0xaaaaaaaa,0x001acffe,0x64017ff2,0x3f662fff,
0x07ffc46f,0x3fee0000,0xffffffff,0xffedffff,0xff502eff,0xfffff97f,
0xffffffff,0x0007ffff,0x0007ffd1,0xfffffff1,0x407fffff,0x0000effa,
0x4c17fec0,0xcdefffff,0xebfffffe,0xfb800fff,0x400000ef,0x44002ffd,
0xf1001fff,0xfffbdfff,0x05ffa85f,0x3faa0000,0xffffffff,0x3fffee0c,
0x1fffd46f,0xffffffd3,0xdfffffff,0x3ff20003,0xfff90005,0xffffffff,
0x3ffe207f,0xfd800001,0xffff502f,0xbfffffff,0x00fffee1,0x0003fff1,
0x005ffb00,0x4005ffc8,0xffffffe9,0x03ffc82f,0xa9880000,0x26009abb,
0x7f45fffe,0xfffb504f,0x39ffffff,0x7ffd4000,0x99970000,0x99999999,
0x13ffa059,0x665c0000,0x3fff6201,0x4c2effff,0x7f406fff,0x7000004f,
0x7c400399,0xc88001ff,0x700deffe,0x00000199,0xfd500000,0x1004e885,
0x00335753,0x00266200,0x4c000000,0x00000019,0x2aea6200,0x26600001,
0x00000001,0x00099880,0x00000100,0x00000000,0x0000000c,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x13333000,0x2e620000,0x100001ab,0x00013333,0x00666660,
0x4cccc000,0x4cccc000,0x33000001,0x00000133,0x26620000,0x04ccc409,
0x0ccccc00,0x33310000,0x00999881,0x3fffea00,0xd930000e,0x3dffffff,
0xffe88000,0xfb00007f,0x00003fff,0x02ffffb8,0x17fffe40,0x3fee0000,
0x320006ff,0xea81efff,0x3fff6000,0x01fffe42,0x17fffe40,0xfffd8000,
0x01fffe42,0xfffff880,0xffc8005f,0xffffffff,0x7cc0005f,0x00003fff,
0x000bfffd,0x04ffff80,0x0dfffb00,0x7ffcc000,0x20004fff,0xd52ffffa,
0x7ec007ff,0x7ffe42ff,0xfffb0003,0x3f60000d,0x7ffe42ff,0xfffd0003,
0x4007fff9,0xdefffffc,0x04ffffff,0x3fffd400,0xfff88000,0xf700001f,
0x44000dff,0x0002fffe,0xfcfffe88,0x260003ff,0xfffffffe,0x3ff6002e,
0x1fffe42f,0xfffe8800,0xffd80002,0x1fffe42f,0x9fffec00,0xa802fffd,
0x4c0cffff,0x001ffffc,0x01fffdc0,0x5fff9800,0xfffd0000,0xff980001,
0xfd80006f,0x3fffd3ff,0x7ffcc000,0xd8002eff,0x7fe42fff,0x3e60003f,
0xd80006ff,0x7fe42fff,0x7fdc003f,0x3fffe26f,0x27fff400,0x00ffffa0,
0x01bff600,0x1fffb800,0x7ffd4000,0xff500001,0x7dc0005f,0x3ffe65ff,
0x7e44000f,0x003fffff,0x88133310,0x40000999,0x0001fffa,0x2204ccc4,
0x26000999,0x7dc1ffff,0xff100eff,0xffa801ff,0xfd00005f,0x6400005f,
0x740005ff,0x400003ff,0x30005ffb,0xfb81ffff,0xfb3006ff,0xfffd9fff,
0x00000003,0x17fee000,0x00000000,0xfa800000,0xff8804ff,0x0000004f,
0x00000000,0x00000000,0x00000000,0x2219fffb,0x0000efff,0x00000000,
0x00000000,0x2e000000,0xfa803fff,0x000003ff,0x00000000,0x00000000,
0x00000000,0xf5017f30,0x00000bff,0x00000000,0x00000000,0x2af72a62,
0x7fff7000,0x01fffb00,0x66dd4c00,0x999801ab,0x04ccc000,0x98001333,
0xa9880099,0x2000abdc,0x4c000999,0x04c00099,0x0005fffb,0x157b9531,
0x32a60000,0x00000abc,0x01579953,0xffffc800,0x402fffff,0x4c02fffc,
0x98004fff,0xfffffffe,0xff103fff,0x7fcc00bf,0x0bfff14f,0x027ffcc0,
0x3ffffff2,0x7c402fff,0x3e6005ff,0x764c04ff,0xffacffff,0x7fe4006f,
0x2fffffff,0xffff7000,0x005fffff,0x3ffffee0,0x4002ffff,0xfffffffa,
0x00dfffff,0xd803fff9,0x5c001fff,0xffffffff,0x40dfffff,0x2005fff8,
0xff14fff9,0x7fcc00bf,0xffff504f,0xffffffff,0x3ffe201b,0x3ffe6005,
0x3ffff204,0xffffffff,0xfffa803f,0xffffffff,0xfb1000df,0xffffffff,
0x22001bff,0xfffffffd,0x800dffff,0xdefffffa,0xffffffdc,0x01fffc81,
0x0017ffe6,0x9bdffffd,0xfffffdb9,0x05fff889,0x453ffe60,0x26005fff,
0xffa84fff,0xfdcdefff,0x881fffff,0x26005fff,0xfe984fff,0xffefffff,
0x407fffff,0xdefffffa,0xffffffdc,0x7fffcc01,0xfffdcdef,0x7cc00eff,
0xdcdeffff,0x00efffff,0x07bfffe2,0x437fffdc,0x3601fffc,0x2e000fff,
0x2602ffff,0x220ffffd,0x26005fff,0xfff14fff,0x7ffcc00b,0x77fffc44,
0xdffff701,0x00bfff10,0x7427ffcc,0x220bffff,0x3fffffe9,0x3dffff10,
0x1bfffee0,0x03dfffd0,0x017fffe6,0x203dfffd,0x205ffff9,0x400dfffd,
0x643fffe9,0xff301fff,0xffe800bf,0xfffd001f,0x02fffc47,0x229fff30,
0x26005fff,0x7fec4fff,0x7f4c00df,0x7ffc43ff,0x3ffe6005,0x0f7ffdc4,
0x17ffff20,0x006fffec,0x40ffffa6,0x8806fffb,0xf701fffe,0xfd100dff,
0xfff503ff,0x3fea001f,0x3fff20ff,0x07fff701,0x02fffcc0,0x449fff70,
0x26005fff,0xfff14fff,0x7ffcc00b,0x03fffea4,0x07fffd40,0x400bfff1,
0x3e24fff9,0xfb001fff,0xffa81fff,0xff5000ff,0xfff881ff,0xfff3000f,
0x1ffff10d,0x1bffe600,0x000ffff6,0x7e47fffd,0xfff701ff,0x76e4c00b,
0x3ffea001,0x017ffe25,0xf14fff98,0x7cc00bff,0x3fff64ff,0x7fff4003,
0x017ffe23,0x324fff98,0x22005fff,0x7ec2ffff,0x7f4003ff,0x7ffe43ff,
0x7ffec003,0x01fffe41,0xd07fff60,0xa8001fff,0x3ff24fff,0xffff101f,
0x30000007,0x7fc4bfff,0x3fe6005f,0x0bfff14f,0xd27ffcc0,0xa8001fff,
0x3fe24fff,0x3fe6005f,0x07fffa4f,0x89fff900,0x4000fffe,0x7ec4fffa,
0x7dc001ff,0x7ffec3ff,0x7ffdc001,0x0037ffc3,0xf937ffc4,0x7fec03ff,
0x00000dff,0x5fffda88,0x8017ffe2,0xff14fff9,0x7fcc00bf,0x01bffe4f,
0x89bffe20,0x26005fff,0x3ffe4fff,0xfffa8007,0x0037ffc5,0x3a37ffc4,
0x4c000fff,0x7ff44fff,0x7fcc000f,0x17ffe64f,0x93fffc00,0x74403fff,
0x001effff,0xffd97510,0x44bfffff,0x26005fff,0xfff14fff,0x7ffcc00b,
0x00bfff34,0xf89fffe0,0x3e6005ff,0xdfff14ff,0xdfff3000,0x002fffcc,
0x7fc7fff8,0xeeeeeeff,0xfeeeeeee,0x7fffc5ff,0xeeeeeeee,0xfffeeeee,
0x013ffea5,0xc87fffc0,0x6c401fff,0x004fffff,0xffffffd7,0xbfffffff,
0x002fffc4,0x3e29fff3,0x3e6005ff,0x9fff54ff,0x3fffe000,0x00bfff10,
0xf9a7ffcc,0xf88005ff,0x3ffea7ff,0xffff0004,0x3ffffe21,0xffffffff,
0x6fffffff,0x3fffffe2,0xffffffff,0x26ffffff,0x0004fffb,0x3f23fffd,
0xff7001ff,0x7dc0bfff,0xffffffff,0x5fffcdff,0x8017ffe2,0xff14fff9,
0x7fcc00bf,0x09fff74f,0x47fffa00,0x2005fff8,0xff54fff9,0x3fe0009f,
0x13ffee7f,0x8ffff400,0xfffffff9,0xffffffff,0x267fffff,0xffffffff,
0xffffffff,0x3ea7ffff,0xff0004ff,0x3fff21ff,0x3ffe6001,0xfffb85ff,
0x1bceffff,0xf897ffe6,0x3e6005ff,0xbfff14ff,0xa7ffcc00,0x0004fffa,
0x3e21ffff,0x3e6005ff,0xbfff34ff,0xffff1000,0x0027ffd4,0xf30ffff8,
0x55555dff,0x55555555,0x7fcc5555,0xaaaaaaef,0xaaaaaaaa,0x3ffe62aa,
0xfff88005,0x007fff27,0x3ffffb10,0x5f7fffd4,0x2fffcc00,0x400dfff1,
0xff14fffa,0x7fd400df,0x0bfff34f,0x4ffff100,0x2006fff8,0xff34fffa,
0xff3000df,0x2fffccdf,0x3fffc400,0x000dfff1,0x06fff880,0x7ffc4000,
0xfff98006,0x007fff27,0xb27ffec0,0x2001bfff,0x3e25fffa,0x3ea006ff,
0xdfff14ff,0xa7ffd400,0x8006fff8,0x3e27fff9,0x3ea006ff,0xffff14ff,
0x9fff5000,0x0037ffc4,0x3e3fffcc,0x00000fff,0x0007fffc,0x03fffe00,
0x4bfff700,0x0001fffc,0x7fcdfff5,0x3ee000ff,0x37ffc5ff,0x49fff900,
0x32006fff,0x3ffe4fff,0x7fdc000f,0x037ffc5f,0x7c9fff90,0x64000fff,
0x7ffc3fff,0x7fdc000f,0x0fffec5f,0x2026a200,0x4001fffd,0xffd809a8,
0x7ff4004f,0x07fff22f,0x3ffe2004,0x00dfff36,0x7c5fffe8,0x3fa007ff,
0x1fffe4ff,0x24fffe80,0x4004fffd,0x7fc2fffe,0x3ffa007f,0x13fff24f,
0x1ffff880,0x0027ffec,0xf90bfffa,0xfc800bff,0x7ffe45ff,0x7ffe4005,
0x07fffcc5,0x0ffffb80,0xd507fff2,0x7ffdc01f,0x01ffff34,0x17ffff20,
0x9007fffd,0x7f49ffff,0xffc803ff,0x3ffe64ff,0xfff7000f,0x3fffe81f,
0x4ffffc80,0x003fffe6,0x4c2fffe4,0x7000ffff,0xf881ffff,0xf1002fff,
0xff883fff,0xff1002ff,0xfff903ff,0xfffa801d,0x0fffe44f,0x7c0bfffb,
0xfff13fff,0xfff7009f,0xfffc8dff,0x3ffee00f,0x3fff24ff,0x3ffee00f,
0x7ffe44ff,0x7ffd400e,0xffffc84f,0x3fffee00,0x77ffec4f,0x7fffdc00,
0x1dfff900,0x4ffffa80,0x03ffff70,0x06fffe88,0x803ffff7,0x106fffe8,
0x815fffff,0x86ffffc8,0x3a21fffc,0x36a0cfff,0x3fa0ffff,0xf9302fff,
0x98ffffff,0x10beffff,0xffffff95,0x77fffcc9,0xfff9510b,0xff889fff,
0x6440afff,0xf306ffff,0x2217dfff,0xffffffca,0x7ffffcc4,0xffffd882,
0x3fffe204,0x7fe440af,0x7ff406ff,0x764c0cff,0x3a01ffff,0x4c0cffff,
0x01ffffec,0x3fffffea,0xffffffee,0x1fffc80e,0x77ffffcc,0x42fffffe,
0xdefffff9,0xbfffffec,0x7ec0fffe,0xffffffff,0x4ffe9fff,0x7fffffec,
0xe9ffffff,0xfffa84ff,0xfffeefff,0x3600efff,0xffffffff,0xffe9ffff,
0xffffe884,0xfffffdef,0xfffa805f,0xfffeefff,0x4c00efff,0xeffffffe,
0x2fffffff,0x7ffff4c0,0xfffffeff,0xfd8802ff,0xffffffff,0xff900dff,
0xffff503f,0x07ffffff,0x3fffffea,0x70dfffff,0xff907fff,0xdfffffff,
0x3213ffa3,0xffffffff,0x09ffd1ef,0x3fffff62,0x0dffffff,0xfffffc80,
0xfd1effff,0x7ffec09f,0xffffffff,0x3ff62003,0xffffffff,0xf91000df,
0xffffffff,0x22005fff,0xfffffffc,0x002fffff,0x7fffff5c,0x7e401dff,
0xffb301ff,0x801bffff,0xffffffd8,0x7ffcc2ef,0xffffd506,0x7ff419df,
0xffffd504,0x7ff419df,0x7fff5c04,0x001dffff,0x7fffff54,0x13ffa0ce,
0xfffffb70,0x20001bff,0xffffffeb,0xb50001df,0xffffffff,0x3f6a0007,
0x3fffffff,0xaba98000,0x10000009,0x80013775,0x001aba98,0x0055cc00,
0x00ab9800,0x55d4c000,0xb9800009,0x4400000a,0x00000aba,0x004d5d4c,
0x35751000,0x54400001,0x000009ab,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,0x88000000,0x99988199,
0x26660000,0x32000009,0x332e00cc,0x4ccc4001,0x26000001,0x00001999,
0x000ccccc,0x004cccc0,0x5dd4c000,0x0000000a,0x40033333,0x99881998,
0x00ccc809,0x0ffff400,0x000ffff2,0x037fffd4,0x07ff9800,0x0007ffe2,
0x000ffff7,0x3fffe600,0x3e600005,0x40004fff,0x006ffffa,0x3fffa600,
0x0000dfff,0x3fffe600,0x3fffa004,0x417ffec1,0x40003ffd,0x7e41fffe,
0xf98003ff,0x005fffff,0x206ffb80,0xb8007ff9,0x00007fff,0x00dfffb0,
0x6fffd800,0x7ffcc000,0x80005fff,0xfffffffc,0x00001fff,0x00dfffb0,
0x6c1fffe8,0xffa82fff,0x7ff40005,0x1fffe41f,0x3fffa200,0x0003fffc,
0xf7027fe4,0xff7000df,0x300000ff,0x0001ffff,0x07fffcc0,0xfffd1000,
0x0007fff9,0x6fffffdc,0x00ffffff,0x7ffcc000,0x7ff4000f,0x17ffec1f,
0x0003ffc4,0xf907fffa,0xfd8007ff,0x3fffb3ff,0x1fff4000,0x0009ff90,
0x000ffff7,0x05fff900,0xfffd8000,0x7fec0002,0x03fffb3f,0x7ffff300,
0x2ffff541,0x3ff60000,0xffe8001f,0x17ffec1f,0x0001ffe8,0x26206662,
0x3ee00099,0x3ffe26ff,0xfff0000f,0x017ff403,0x00cccc40,0x3ffe2000,
0x7c400004,0x5c0003ff,0x3fe26fff,0x7e4000ff,0xfff505ff,0x7cc0000f,
0x310003ff,0x13331033,0x0013ff20,0x26000000,0x7dc0ffff,0xf98006ff,
0x3ffe207f,0x00000001,0x005ffc80,0x05ffc800,0x7fffcc00,0x037ffdc1,
0x807fffa0,0x0001ffff,0x000bffb0,0xff300000,0x0000000d,0x00000000,
0xf3037fdc,0x000000ff,0x00000000,0x00000000,0x3ffe0000,0x0fffec07,
0x00000000,0xfff00000,0x00000001,0x00000000,0xfb813ff2,0x2aa0006f,
0x0000001a,0x00000000,0x40000000,0x3e01fffe,0x00000fff,0x00000000,
0x000bff60,0x2f36ea60,0x54c0001a,0x401abcdb,0xe9999998,0x99999cff,
0x999dffd9,0xbfff1000,0x2a620000,0x0000abdc,0x15799530,0x32a60000,
0x20000abc,0xf506fffc,0x20000dff,0x1abcdba9,0x00099980,0x3ee04ccc,
0xfd30005f,0xffffffff,0x7f4c007f,0xffffffff,0xffff703f,0xffffffff,
0xffffffff,0x22005fff,0x80004fff,0xfffffffc,0xf70002ff,0xffffffff,
0x3fee0005,0x2fffffff,0xffffa800,0x17fff443,0xfffd3000,0x7fffffff,
0x017ffe20,0x4c4fff98,0xfb8007ff,0xffffffff,0x400dffff,0xfffffffb,
0x0dffffff,0x7fffffdc,0xffffffff,0xffffffff,0xfff3002f,0x7fd40007,
0xffffffff,0xb1000dff,0xffffffff,0x2001bfff,0xffffffd8,0x00dfffff,
0x97fffec0,0x005fffe9,0x3ffffee0,0xffffffff,0x2fffc40d,0x09fff300,
0x74003ffd,0xccdeffff,0x4fffffed,0x3bffffa0,0xfffedccd,0x7ffdc4ff,
0xffffffff,0xffffffff,0x7002ffff,0x20005fff,0xdefffffa,0xffffffdc,
0x7fffcc01,0xfffdcdef,0x7cc00eff,0xdcdeffff,0x00efffff,0x3ffffe20,
0x005ffffd,0x3bffffa0,0xfffedccd,0x7ffc44ff,0x3ffe6005,0x003ffc84,
0x405ffff7,0x80ffffd9,0x202ffffb,0x00ffffd9,0x2e04ffc8,0x3e0005ff,
0x88001fff,0x701effff,0xe80dffff,0xf301efff,0xfe80bfff,0xff301eff,
0xfa800bff,0x4fffffff,0x3ffee000,0x3ff6602f,0x3ffe20ff,0x3ffe6005,
0x006ffa84,0x2003fffd,0xfe83fffe,0xffd001ff,0x5ffd007f,0x0027fec0,
0x005fffd8,0x01bfffb0,0x03fffe98,0x100dfff7,0x2e03fffd,0xe8806fff,
0x6c001fff,0x01efffff,0x0ffff400,0x23fffe80,0x2005fff8,0xf884fff9,
0x7fcc00ff,0x3fee005f,0x2fffcc4f,0x09fff700,0x201fff88,0xc8002ffe,
0x8000ffff,0x000ffffa,0x881ffff5,0x3000ffff,0xff10dfff,0x3e6001ff,
0xfb3006ff,0x009fffff,0x05fff980,0x893ffee0,0x26005fff,0xffd04fff,
0x1edc9805,0x17ffea00,0x4003db93,0x4c05fffa,0x3fe207ff,0x7fec000f,
0xfb0003ff,0xfe8007ff,0x7ffe43ff,0x7ffec003,0x01fffe41,0x007fff60,
0xfffffff9,0x4c0005ff,0x2a001edc,0x3fe25fff,0x3fe6005f,0x09ff704f,
0x7fcc0000,0x2600005f,0x7dc05fff,0x1ffea06f,0x7ffffb00,0x7fff4000,
0x7ffd4000,0x00fffec4,0xb0fffee0,0xb8003fff,0x3f603fff,0xfffaefff,
0x000001ff,0x25fff980,0x2005fff8,0xf304fff9,0x100000df,0x00bfffb5,
0xfffb5100,0x04ffc80b,0xd8017fee,0x0003ffff,0x40037ffc,0x7f46fff8,
0x7cc000ff,0x7fff44ff,0x7ffcc000,0x9ffffb04,0x077fffd4,0x0002f3b2,
0x7ffed440,0x017ffe25,0x204fff98,0x10001fff,0xffffd975,0x4400bfff,
0xffffecba,0x7f405fff,0x13ff602f,0x17fffe40,0x3ffe6000,0xffff0005,
0xeeeffff8,0xeeeeeeee,0x7c5fffee,0xeeeeefff,0xeeeeeeee,0xffc85fff,
0xfffb83ff,0x17fffc5f,0x3b2ea200,0x5fffffff,0x8017ffe2,0x3604fff9,
0x3ae003ff,0xffffffff,0x405fffff,0xffffffeb,0x5fffffff,0x807ffe20,
0xfa802fff,0x80002fff,0x0004fffa,0x3e21ffff,0xffffffff,0xffffffff,
0x3fe26fff,0xffffffff,0xffffffff,0x7ffc46ff,0x3fff603f,0x1ffff33f,
0xffffd700,0xffffffff,0x2fffc4bf,0x09fff300,0x5c02ffd4,0xffffffff,
0xfffcdfff,0xfffff705,0x9bffffff,0x7fdcbfff,0xffffffff,0xffffffff,
0x362fffff,0x00003fff,0x0009fff7,0x7cc7fffa,0xffffffff,0xffffffff,
0x3fe67fff,0xffffffff,0xffffffff,0x7ffe47ff,0x7fff4407,0x05fffcaf,
0x7fffffdc,0xfcdfffff,0x3ffe25ff,0x3ffe6005,0x01ffe204,0xfffffff7,
0x7fcc379d,0xffffb85f,0x21bcefff,0x3ee5fff9,0xffffffff,0xffffffff,
0x22ffffff,0x00007fff,0x0013ffea,0xf987fffc,0xaaaaaeff,0xaaaaaaaa,
0x3fe62aaa,0xaaaaaaef,0xaaaaaaaa,0x7ffec2aa,0xffff8804,0x203fffff,
0xfffffffb,0x3fe61bce,0x17ffe25f,0x04fff980,0xfa817ff4,0x400befff,
0x7d45fff9,0x400befff,0x3ee5fff9,0xffffffff,0xffffffff,0x32ffffff,
0x3000bfff,0x0bfff303,0x4ffff100,0x0006fff8,0x037ffc40,0x7fffc000,
0xffff5001,0x7d40ffff,0x400befff,0x3e25fff9,0x3ea006ff,0x7fe404ff,
0x1bfffb04,0x17ffea00,0x001bfffb,0x9897ffea,0x99bfff99,0xcffe9999,
0x70999999,0x88007fff,0x3fe27fff,0xff98006f,0x07fffc7f,0x3ffe0000,
0x7c00000f,0x2e001fff,0x03ffffff,0x0037fff6,0xf12fffd4,0x7d400dff,
0x7fcc04ff,0x01ffff06,0x22fffdc0,0x2000ffff,0xf105fffb,0x7ffc01ff,
0x5fffa802,0x2fffdc00,0x0003fffe,0xfd8bfff7,0x544001ff,0x1fffd809,
0x404d4400,0x4003fffe,0x407ffffd,0x2000ffff,0x7fc5fffb,0x3ff2006f,
0x0fff804f,0x0037ffcc,0xf997fffa,0x7f4006ff,0xfff305ff,0x007ffc40,
0x003fffc4,0xfb0ffff6,0xfe8009ff,0x7ffe42ff,0x7ffe4005,0x02fffe45,
0x917fff20,0xc800dfff,0x304fffff,0xe800dfff,0x7ffc5fff,0x3fffa007,
0x42ffd804,0x000ffff9,0x4cbffff9,0x9000ffff,0x2e0bffff,0x3fea05ff,
0x3fffe007,0xffff5004,0x0ffff981,0x1ffff700,0x02ffff88,0x83ffff10,
0x002ffff8,0xa83ffff1,0x9003ffff,0x9fffffff,0x01ffff30,0x17ffff20,
0x9007fffd,0x7009ffff,0xfff88bff,0xfffb804f,0x3ffe26ff,0xfffb804f,
0x9ffb06ff,0x002ffe40,0x807ffff7,0x905ffff9,0xa801dfff,0xf704ffff,
0xe8803fff,0xff706fff,0xfe8803ff,0xfffb06ff,0xfffd805f,0x44ffffff,
0x804ffff8,0x46fffffb,0x200ffffc,0x04fffffb,0xfe87ff88,0xf9302fff,
0xe8ffffff,0x9302ffff,0x0fffffff,0xfd80bffa,0x7fec003f,0x32209dff,
0x100effff,0x815fffff,0x06ffffc8,0x067ffff4,0x3ffffb26,0x3ffffa01,
0x7ff64c0c,0xfff301ff,0x32a239ff,0xfbdfffff,0x7f44ffff,0xf9302fff,
0x98ffffff,0x10beffff,0xffffff95,0x07ffa009,0xbdfffff3,0x7fffffd9,
0x7cc1fffd,0xecdeffff,0xfebfffff,0x7ffc40ff,0x00bffe00,0xfffffd10,
0xffffffdf,0xfffa803f,0xfffeefff,0x4c00efff,0xeffffffe,0x2fffffff,
0x7ffff4c0,0xfffffeff,0x7fd402ff,0xffffffff,0x3ee4ffff,0x3e64ffff,
0xecdeffff,0xfebfffff,0x7ffec0ff,0xffffffff,0x004ffe9f,0xff507ff9,
0xffffffff,0x3ffee1bf,0x7ffffd43,0x0dffffff,0xf987fff7,0x3ffe207f,
0xfff90000,0xffffffff,0x3f62001b,0xffffffff,0x91000dff,0xffffffff,
0x2005ffff,0xffffffc8,0x02ffffff,0xfffffd10,0x05ffffff,0xa81ffff9,
0xffffffff,0xff70dfff,0xffff907f,0x23dfffff,0xf5004ffe,0x3ff620df,
0x42efffff,0xd886fff9,0xefffffff,0x237ffcc2,0x3ea05ffb,0x6c40007f,
0xdffffffe,0xffd70002,0x03bfffff,0x3fff6a00,0x003fffff,0xfffffb50,
0x20007fff,0xffffffec,0x3fea00ce,0xffffb101,0xf985dfff,0xffd506ff,
0x7419dfff,0xff1004ff,0x5d4c401f,0x3100001a,0x40003575,0x32a02cca,
0x4c00003c,0x4000009a,0x0009aba9,0x26aea200,0x2a200000,0x000009ab,
0x30006ee6,0x57531005,0xb9800003,0x5c00000a,0x000001cc,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,0x00000000,0x00000000,
0x00200000,0x5dd4c000,0x4000009a,0x09acba98,0x01999800,0x00333300,
0x00000008,0x01357953,0x00000000,0x00008000,0x5e554c00,0x0000001a,
0xeda80131,0x000bceff,0x3fffee20,0x000cffff,0x7fffed40,0x00cfffff,
0x003ffff0,0x405fff98,0xcdfffec8,0xdb80000a,0xfffffffe,0x3ee002df,
0xb80005ff,0xa8805fff,0x0cefffec,0xffc98000,0xdfffffff,0xf3000002,
0x3ffa609f,0x3fffffff,0xffffa800,0xffffffff,0xfffb8003,0xffffffff,
0x6400cfff,0x64004fff,0x3ee02fff,0xffffffff,0xfd30002f,0xffffffff,
0x007dffff,0x000bfff7,0x80bfff70,0xfffffffa,0x50003fff,0xfffffffd,
0x7dffffff,0xffe80000,0xfffff984,0x4fffffff,0x3fffe600,0xfffeddff,
0xfb1002ff,0xffffffff,0xdfffffff,0x37ffcc01,0x81fffe00,0xfffffffe,
0x002fffff,0x7fffffdc,0xffffffff,0x7dc04fff,0xb80005ff,0x3f205fff,
0xffffffff,0x22005fff,0xaceffffd,0xffeca999,0x80000eff,0x7c44fffd,
0xa89befff,0x804ffffd,0x81effff8,0x01ffffe9,0x7fffffcc,0xca9889ac,
0x00efffff,0x4007fffa,0xf904fff9,0x5115bfff,0x007ffffb,0xdfffffb1,
0x3aea6359,0x00efffff,0x000bfff7,0x20bfff70,0x9beffffd,0x3ffffda8,
0xcfffe980,0xfff93001,0x7ec0005f,0x7fec4fff,0xfff500ef,0xfffe803f,
0x6fffd805,0x3ffffe20,0xffc8800c,0xff700eff,0x3ff2009f,0xffffa81f,
0x3fffea01,0x7ffff401,0xffd5002f,0x3fee0dff,0xfb80005f,0xfffb85ff,
0x3ffee01f,0x3ffea01f,0xfb10000e,0xd88007ff,0x264fffff,0xfa806fff,
0x3fe205ff,0xff8800ff,0xfffb00ff,0xff90005f,0x3fe207ff,0xfff8807f,
0x07fffd06,0x407fff70,0x00dffffb,0x4ffffd80,0x005fffb8,0x45fffb80,
0x801ffff8,0xf104fffd,0x200009ff,0x7001fffb,0x9fffffff,0x801fffec,
0xf500fffd,0x7e400bff,0xfffb82ff,0x3f60002f,0x3ff607ff,0x7ffd402f,
0x06fff883,0x441bffe0,0x0004ffff,0x20ffffe4,0x0005fffb,0x645fffb8,
0xf5004fff,0x3ffa0dff,0x7dc00004,0x3fa600ef,0x4fffffff,0x001ffff1,
0x640fffe6,0x2a003fff,0xfff84eff,0x7c40004f,0xff502fff,0xfffd80bf,
0x04fffb80,0x203fffa0,0x0006fffd,0xb8dfffd0,0x80005fff,0x7fc5fffb,
0x3fa000ff,0x2ffe40ef,0x37bbbbae,0x7ec02bcc,0xffff705f,0x29fff5df,
0x4006fff9,0xffb07fff,0x2018007f,0x000ffffa,0x05fffd80,0x4403fffe,
0x75105fff,0x7ff4003b,0x7fffcc0f,0xff500002,0x7ffdc3ff,0xffb80005,
0x13ffe65f,0xfff88000,0x7ffffe40,0x00dfffff,0xf881ffd1,0xff33ffff,
0x0fffee9f,0x01fffd00,0x0009fffb,0x02fffec0,0x00ac9800,0xb817ffe4,
0x00002fff,0xfd86fff8,0x400005ff,0x3ee4fffe,0xb80005ff,0x3fee5fff,
0x2e00002f,0xdffc83ff,0xfffeedcc,0x89ff500f,0x261efff8,0xfffb4fff,
0xfffc8005,0x05fffc82,0xffff1000,0x00000007,0x3a0bfff3,0x800007ff,
0xff84fffa,0x400002ff,0x3ee7fffb,0xb80005ff,0x3ff65fff,0x3a00000f,
0x0ffc80ff,0x407ffd10,0x177c47ff,0xfea7ffcc,0x7dc001ff,0xfffa83ff,
0xff500006,0x000003ff,0x03fffa00,0x0009fff3,0x1ffff980,0x007fffc4,
0x3ffe2000,0x0bfff71f,0xbfff7000,0x54437ff4,0x4c00acdc,0x1ff904ff,
0x7037fcc0,0x301445ff,0x3ffe9fff,0x7fd4001f,0xffff884f,0xffb80000,
0x000000ff,0x87fff700,0x0001fffc,0x7ffff910,0x00ffff30,0x3fffa000,
0x00bfff73,0x4bfff700,0x3fa66fff,0x0dffffff,0x3203ff70,0x3fe200ff,
0x013fe207,0xff4fff98,0xfa8001ff,0xfffd04ff,0xff700005,0x000000ff,
0x237ffc40,0x40006fff,0xfffffedc,0x0ffff502,0x3ff60000,0x0bfff73f,
0xbfff7000,0x7cd7ffe2,0xffffffff,0x0ffc81ef,0x6401ff90,0x2ffc05ff,
0x29fff300,0xa8007fff,0x33324fff,0xcccefffe,0xf9002ccc,0x00000dff,
0x0fffd800,0x0007fff3,0xfffffff8,0x1bffee01,0x7fec0000,0x0bfff74f,
0xbfff7000,0x3eb3ffe2,0xffedefff,0x7ec1ffff,0x203ff207,0x401fffb8,
0x3e6006fe,0x7fff8cff,0x5fffa800,0x3ffffffe,0x3fffffff,0x09fffb00,
0xa8000000,0xfff93fff,0x7fc40001,0x1dffffff,0x004fffc8,0xbfff9000,
0x0017ffee,0x4d7ffee0,0xcfffefff,0x7fffdc40,0xf9037f46,0xffffffff,
0xffb007ff,0x67ffcc00,0x8007fff8,0x3fe5fffa,0xffffffff,0xb003ffff,
0x00009fff,0xdfff0000,0x00017ffa,0xffb959b3,0xffd85fff,0x9000004f,
0x3feebfff,0xfb80005f,0xffff35ff,0xff9803ff,0x81bfa3ff,0xfffffffc,
0xfb001dff,0x7ffcc00f,0x007fff8c,0x325fffa8,0xdfffeccc,0x002ccccc,
0x000bfff9,0xff900000,0x005fff3f,0x3ffa6000,0x3fff61ff,0xfb000005,
0x3ffee9ff,0xffb80005,0xfffff35f,0x3ffee007,0x640ffb0f,0xfffcabff,
0x037f4003,0x3e9fff30,0xfb8007ff,0x3ff204ff,0x7dc0003f,0x000006ff,
0xefff9800,0x00000fff,0x937fff40,0x0000dfff,0x5cffffa0,0x80005fff,
0xff35fffb,0xfe800dff,0x01ff92ff,0xff703ff2,0x02ffc00d,0x3e9fff30,
0x5c000fff,0x3ee04fff,0x540005ff,0x00006fff,0xfffd0000,0x000009ff,
0x25ffff30,0x0007fffb,0x27ffff00,0x0006fffa,0xf34fffc8,0xb8009fff,
0x3ff73fff,0x3203ff20,0xff9804ff,0x3ffe6004,0x003ffff4,0x203fffc8,
0x0003fffa,0x007fffcc,0x20001000,0x01fffffb,0xffb00000,0x3fffea9f,
0x7c400000,0xfff52fff,0xffb0000d,0x3fffe29f,0x7ffd4002,0x320bff34,
0x5ffd00ff,0x002ffc80,0x7ed3ffe6,0x7e4001ff,0x3fee02ff,0xff80001f,
0x200002ff,0x1000bdff,0x000dffff,0x7ffdc000,0x007fffe5,0xffff5000,
0x0037ffcc,0xf1ffff40,0x98003fff,0x3ffa5fff,0x300ffc80,0x7fc01fff,
0x7ffcc006,0x005fff94,0x201fffd8,0x0000fffc,0x004fffc8,0x3ffff300,
0x1fffec00,0xf5000000,0x7ffe4dff,0x7f400006,0x3ffe64ff,0xffe80007,
0x0bfffa3f,0x49fff300,0xffc83ffa,0x413ff600,0x4c003ffa,0xfff54fff,
0x7fff8009,0x002fff40,0x0ffffa80,0xfffc8000,0x7ffe4006,0x1bb32000,
0x93ffee00,0x002ffffa,0x3ffff700,0x001ffff8,0x90ffffc0,0xa8009fff,
0x7ffc2fff,0x1007fe41,0xff883fff,0x7fcc000f,0x0ffff14f,0x02fffd40,
0x0001fff5,0x02ffffc0,0x3fffe200,0x2fffc003,0x07fffa00,0x87fff900,
0x000ffffe,0x37fffc40,0x001fffec,0xa8ffff70,0x64006fff,0x7fdc0fff,
0x2007fe46,0x7fec6ffc,0xfff98004,0x007fffa4,0xd01fffec,0x800007ff,
0x002ffffa,0x1ffffd10,0x17ffd400,0x13fff200,0x1fffe880,0x027fffcc,
0x3ffff600,0x0ffffb81,0xbffff000,0x00ffff88,0x6c1fffa0,0x400005ff,
0x30006ffc,0x7fdc9fff,0xfff8805f,0x5ffe880f,0xffd00000,0xfb0007ff,
0xe8009fff,0xfa8006ff,0xf9000fff,0x3ff20fff,0x44000dff,0x304ffffe,
0x000bffff,0xb05ffff7,0x2e00dfff,0xfd105fff,0x880001df,0x0000fffd,
0x7c49fff3,0x3a204fff,0xfe884fff,0xabccaaff,0xf3008801,0x0019ffff,
0x0bffffd5,0x03fffc80,0x0dfffd00,0x05ffff70,0x17fffff4,0xfffffa80,
0x7fffe406,0xffe9801e,0xfff106ff,0xfff980bf,0x3ffe602f,0xfd30002f,
0x4c0005ff,0x7fd44fff,0x7f4c0cff,0x7f440eff,0xffffffff,0x99acefff,
0x3ea05fda,0x9adfffff,0xfffdba98,0x565c06ff,0x00ffffec,0xdffff100,
0xffffb105,0xfffd8809,0x989bceff,0xfffffecb,0x7ffc400e,0xaaceffff,
0xfffffecb,0x3ffee01f,0x3ee20adf,0xe8804fff,0x5002efff,0x003dfffb,
0x84fff980,0xdefffffc,0x81ffffff,0xfffffff8,0xffffffff,0x0fffffff,
0x3ffffe60,0xffffffff,0x400effff,0xfffffffb,0x7fd40001,0xffdeffff,
0x2006ffff,0xfffffffc,0xffffffff,0x3a6004ff,0xffffffff,0xffffffff,
0xfffb801f,0xfffedfff,0x32000eff,0xbcdfffff,0xffffdcba,0xf300005f,
0x3fea09ff,0xffffffff,0x3fff601f,0xffdccdff,0xffffffff,0x7ec402ff,
0xffffffff,0x003fffff,0x5ffffff5,0x3faa0000,0xffffffff,0xea8003ff,
0xffffffff,0x02efffff,0xffffd880,0xffffffff,0x26000eff,0xfffffffe,
0x30005fff,0xfffffffb,0x5bffffff,0x7fcc0000,0x3ff6604f,0x00bfffff,
0x3005ffd4,0xffffffd7,0x3220019f,0xffffffff,0x26000cff,0x003effff,
0xffffb800,0x000dffff,0x7fffecc0,0x01cfffff,0xfffc9800,0xcfffffff,
0xfd910001,0x05bfffff,0xffd71000,0x17dfffff,0xff300000,0x2ea2009f,
0x00a0009a,0x06aeea20,0x75531000,0x98800035,0x8000000a,0x000abba8,
0x59533000,0x40000033,0x99abba99,0x26200000,0x00000abb,0x0026a620,
0x00000000,0x00000000,0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x40000000,0x00aabca9,0x00010000,0x00002200,
0x2f2aa600,0x2000001a,0x409bdcb9,0x00000998,0x00000000,0x30000000,
0x00359753,0x33332600,0xcccccccc,0x50002ccc,0xffffffd9,0x00017dff,
0x77fff6dc,0xb710001c,0x007dfffd,0x7ffe4c00,0x2dffffff,0xffd50000,
0x6cbfffff,0x300006ff,0x40009fff,0x3fe6fffa,0x0000006f,0x7ffffe4c,
0x0bceffff,0xffffb800,0xffffffff,0x4c004fff,0xfffffffe,0x2fffffff,
0x7fff5400,0x0dffffff,0x3fffea00,0x03ffffff,0x3fffaa00,0xffffffff,
0x20003eff,0xfffffffc,0xffd8efff,0xff300006,0x7d40009f,0x1bffe6ff,
0x74c00000,0xffffffff,0x3fffffff,0x7fffec00,0xffffffff,0x26004fff,
0xffffffff,0xffffffff,0xfff9004f,0xffffffff,0xfd8803ff,0xffffffff,
0x44005fff,0xaceffffd,0xffeca999,0x6c000eff,0xdcefffff,0xffeffffe,
0xff300006,0x7d40009f,0x1bffe6ff,0x3ee00000,0xffffffff,0xffffffff,
0xffd000df,0xffffffff,0x009fffff,0x3bffffe6,0xeba999ab,0x404fffff,
0x9beffff9,0x6ffffb98,0x77fffec0,0xfffba89b,0xffd3005f,0x3260039f,
0x5002ffff,0x301bffff,0x0dffffff,0x3ffe6000,0x3fea0004,0x01bffe6f,
0xffd88000,0x9acdffff,0xfffecb98,0x7c400eff,0x99999dff,0x09999999,
0x5ffffb00,0x3fffaa00,0xfffd101f,0x7fff4c09,0xbffff504,0x3fffa201,
0x77ffd403,0xffb10000,0xfffd007f,0xfffe8809,0xf300006f,0x540009ff,
0x3ffe6fff,0x36000006,0x004fffff,0x13ffffea,0x007fff30,0x3ffe6000,
0x7fc4001f,0xfff505ff,0xffff300d,0x0bfffd01,0x01ffff10,0x0013ffe2,
0x00fffdc0,0x200dfff5,0x006ffff9,0x09fff300,0x37ffd400,0x0000dfff,
0x3bfffea0,0xffe88001,0x3fee01ff,0x7000002f,0x20009fff,0xc80ffffa,
0xfb002fff,0xfffb83ff,0xfff7000f,0x013ffa09,0x3ee004cc,0xfff900ef,
0x7ffec005,0xff300006,0x7d40009f,0x1bffe6ff,0x3fe20000,0xe80006ff,
0x3f205fff,0x000000ff,0x0005fff9,0x6c0ffffc,0xf9001fff,0xfffc87ff,
0x37ff4003,0x9502ffe4,0x07fffffd,0xfe82ffec,0x7fcc007f,0xf300006f,
0x540009ff,0x3ffe6fff,0xfc800006,0x80001fff,0x3a07fffb,0x000007ff,
0x000ffff6,0xd83fffd8,0xf7001fff,0xfffd87ff,0x7ffec001,0x203ffe20,
0xffffffd8,0xe880efff,0x5fff80ff,0x37ffc400,0x0dee5cc0,0x0013ffe6,
0x3e6fffa8,0x665446ff,0x3fe2001b,0x200004ff,0xff02ffff,0x400000bf,
0x0007fffa,0xffb80662,0xfff9002f,0x00ffff83,0x717ffe40,0x3ffa07ff,
0xffca9acf,0x4ffa80ef,0x0027ffcc,0xd5037ffc,0x7fffffff,0x0013ffe6,
0x3e6fffa8,0xfffb16ff,0x5009ffff,0x0000ffff,0xf301bdb8,0x001107ff,
0x7ffff100,0x7c400000,0xff8805ff,0x3fffc46f,0x27ffdc00,0xff901ffd,
0x27ff403d,0x7fd47ff8,0xffe8003f,0xfffff906,0xf39fffff,0x540009ff,
0x3ffe6fff,0xfffffe8e,0x200effff,0x0005fffd,0xfffa8000,0xdffffd72,
0x3fa00039,0x0001dfff,0x07fffd00,0xf84fffd8,0xfc8007ff,0x09ff34ff,
0x8803fff1,0x5ff707ff,0x001fffdc,0x7ec37ff4,0xfdcdffff,0x4fffefff,
0x3ffea000,0x3fffffe6,0xffecceff,0xff881fff,0x000004ff,0xfbfffc80,
0xffffffff,0xffa8003f,0x01ceffff,0x3ffe6000,0x3faa21df,0xffe80eff,
0x7fec000f,0x303ff75f,0x066009ff,0x3ea4ff88,0xff8004ff,0x7fffd46f,
0xfffff505,0x7d40009f,0x3fffe6ff,0xff980eff,0xfff986ff,0x0000002f,
0xffffffd8,0xffffffff,0x7cc000ef,0xffffffff,0x4c0001bd,0xfffffffe,
0xb00dffff,0xe8005fff,0x1ff96fff,0x0003ff70,0xff32ffc0,0xfff000bf,
0x04fffe8d,0x27ffff4c,0xdfff5000,0x02fffffc,0x50bfffa2,0x0003ffff,
0xffff0000,0x97559dff,0x00bfffff,0xfffffd10,0x5bffffff,0x3ff20001,
0x2fffffff,0x037ffdc0,0x2dffff70,0x1ffb07fd,0x37f40000,0x800dfff1,
0x3ea6fff8,0xff5006ff,0x540009ff,0x3ffe6fff,0xffa800ff,0x3fffdc6f,
0x44000000,0x201fffff,0x02ffffe8,0xfffeb880,0xffffffff,0xfb5000cf,
0xffffffff,0x3e2019ff,0xf8804fff,0xdfd6ffff,0x0001ffe0,0xfff8ffb0,
0x3fee001f,0x0ffff26f,0x04fffe80,0x9bffea00,0x2003ffff,0x3ee2fffe,
0x54c006ff,0xaaaaaaaa,0x7fcc2aaa,0xffb001ff,0x4c0001ff,0xffffffeb,
0x402fffff,0xbcfffffb,0xfffffdca,0xbffff701,0x3fffea01,0x20dfd6ff,
0x400007ff,0x7ffdc7fd,0x3fffe005,0x001fff66,0x0009fff7,0xff37ffd4,
0xffb800ff,0x1bfff23f,0xfffff900,0xffffffff,0x88002620,0x0003ffff,
0xfffd9510,0x205fffff,0x204ffffb,0x00ffffe9,0x7bfffffd,0xf5fffb95,
0x41ff6bff,0x00000ffe,0x3ffe1bfa,0xfffc801f,0x01bffe6f,0x009fff30,
0xf37ffd40,0xf9800dff,0x3ffee4ff,0x7ffe4006,0xffffffff,0x6400007f,
0x00004fff,0xffffb510,0xfff883ff,0xfffb003f,0x3fffa20b,0xffffffff,
0xf95fff8a,0x03ffb01f,0xbff00620,0x05ffff70,0xb7ffffe4,0x4005fff8,
0x0004fff8,0xff9bffea,0x7fc4005f,0x1fffea6f,0xfffff900,0xffffffff,
0xffa80000,0x8000006f,0x45ffffea,0x2005fffc,0x201ffff8,0xfffffffc,
0xbfff31ff,0x3ee07fee,0x3ffb004f,0x3a09ff30,0xaabdffff,0xffffffec,
0x009fff36,0x004fff88,0xf9bffea0,0x7c4004ff,0x3ffe67ff,0x2aa6000f,
0xfbaaaaaa,0x400007ff,0x0007fff9,0xfffb1000,0x0ffff41f,0x13fff200,
0x9dffb930,0x34fffa85,0xfff10bff,0x0fffa801,0x3602ffc8,0xffffffff,
0x6fffafff,0x0009fff5,0x40009fff,0x3fe6fffa,0xfff8004f,0x0bfffe27,
0xfff10000,0xf880000f,0x2eaa07ff,0x7c40000c,0x3ffe1fff,0x7fd4000f,
0x7004005f,0x7ff47fff,0x00effb80,0x3e09fff3,0xfffb806f,0x88efffff,
0xfff55fff,0x9fff000b,0x7ffd4000,0x0013ffe6,0xfe8dfff1,0x400005ff,
0x0007fff8,0x037ffcc0,0x0005fffd,0x227fffd0,0x88007fff,0x00006fff,
0xfa87fff2,0x9fffd03f,0xdfffd735,0x007ff501,0x337fb2a2,0x4d7ffe22,
0x44006fff,0x75314fff,0xdfff5001,0x2002fffc,0x7dc5fff9,0x400007ff,
0x6547fff8,0xffa8005c,0x3fff605f,0xffc80005,0x01fffe3f,0x017ffe60,
0x87fff800,0xfc881fff,0xffffffff,0x0fff880e,0x7fcc0000,0x0ffff15f,
0x94fff980,0xf5003fff,0x2fffcbff,0x13ffea00,0x007ffff1,0x3fffc400,
0x000bfffa,0x5c09fff9,0x80007fff,0x3fa1ffff,0x7d4001ff,0x372e64ff,
0x3ffea001,0x206ffb85,0xefffffda,0x013ff602,0x3ffea000,0x003fffa4,
0xf74fffa8,0xff7005ff,0x07fffcbf,0x07fff900,0x003ffffb,0x1fffe200,
0x4009fff9,0x201ffff8,0x004ffff8,0x83fffe60,0x4003fffc,0x3e62fffc,
0x3f6004ff,0xbffb02ff,0x80135100,0x3b206ffc,0x3f6000cd,0x3fff22ff,
0x3fffa004,0x009fff54,0x7fc9fff9,0xff1002ff,0xfff103ff,0x700001df,
0xffa8ffff,0xff9001ff,0xfffb00bf,0xe98001bf,0x7fdc4fff,0xff3000ff,
0x6fff81ff,0x0dfff300,0x0077ff44,0x3fff6200,0x13ffee00,0x07fffd40,
0x001ffff3,0x269ffff5,0x2200ffff,0x3fe2ffff,0xfc800eff,0x3fea04ff,
0x30002fff,0x88fffffd,0xb806fffe,0x9801ffff,0x02efffff,0x1fffff70,
0x01ffffd0,0x84fffe88,0x5404fffd,0x4c02ffff,0x0002ffff,0x805fffd3,
0x400ffffa,0xd85ffff8,0x2600efff,0xf14ffffe,0x3a209fff,0x3fe0ffff,
0x7d406fff,0x7e400fff,0x002dffff,0xffffffb3,0xdffff30d,0xffffb305,
0x7ffd4009,0x9bceffff,0xfffffdca,0xffff102f,0xfff7017d,0x3ffe60df,
0x7fdcc0cf,0xfd1005ff,0x2a005dff,0x801efffd,0x02efffe8,0x01ffffd5,
0x85fffff1,0xffffffb8,0x3bfffee4,0xffffca9b,0x7ffffc4f,0x7fe441df,
0xff9003ff,0x579fffff,0xffffd975,0x5c05ffff,0xdeffffff,0x03ffffff,
0xfffffa80,0xffffffff,0x403fffff,0xeffffffa,0xffffffed,0x3fffea01,
0xfffffdef,0xffc8005f,0xbabcdfff,0x5fffffdc,0x7fffcc00,0xffffefff,
0x3e602fff,0xfeefffff,0x4fffbfff,0x7ffffff4,0x0effffff,0x7ff6fffc,
0xffffeeff,0x7fd4005f,0xffffffff,0xffffffff,0xfea800cf,0xffffffff,
0x220002ff,0xfffffffd,0xefffffff,0xfffd3001,0xffffffff,0xfff7001b,
0xffffffff,0x7ecc0009,0xffffffff,0x002dffff,0xffffff50,0x3dffffff,
0xfffff300,0x3e7fffff,0x7ff444ff,0xffffffff,0x8cfff80e,0xfffffffe,
0x910003ff,0xffffffff,0xbfffffff,0xfff70001,0x019dffff,0x3fb26000,
0xffffffff,0xff70002d,0x5dffffff,0xfffd8800,0x001dffff,0xfffd7100,
0x017dffff,0x3ffaa000,0x02dfffff,0x7fffdc40,0x3ffe2eff,0xfffff704,
0x7fc07bff,0x3ffff24f,0x00001dff,0xffffffb5,0x0037bdff,0x13773100,
0x98800000,0x009abcaa,0x57531000,0x53100003,0x00001357,0x009a9880,
0xaa980000,0x9800009a,0x400009ba,0x0000aba8,0x00037510,0xaba99800,
0x00000001,0x00000000,0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,0x00000000,0x00000000,
0x10000000,0x00000000,0x00099988,0x00006662,0x00000000,0x00000000,
0x04fffd80,0x3fffe600,0xffe80003,0xffffffff,0xffffffff,0x5fffffff,
0x7fffc000,0xb8800007,0xbdefffed,0xf9800000,0xfff702ff,0x7ffe4005,
0x00bfff71,0x3fee0000,0xffffffff,0x02ceffff,0x3ffffee0,0xffffffff,
0xffffffff,0x3fffe65f,0xfffb0000,0xff30000d,0xffffffff,0xffffffff,
0xffffffff,0x7fd4000b,0x00002fff,0x3fffffee,0x002fffff,0x17fff400,
0x002fffb8,0x7dc7fff2,0x000005ff,0xffffff70,0xffffffff,0x7007dfff,
0xffffffff,0xffffffff,0x8bffffff,0x8005fffc,0x002ffff9,0xfffffd80,
0xffffffff,0xffffffff,0x005fffff,0x3fffff60,0xfe880006,0xffffffff,
0x0005ffff,0x05ffff90,0x800bffee,0xff71fffc,0x000000bf,0x3fffffee,
0xffffffff,0x03ffffff,0x3fffffee,0xffffffff,0xffffffff,0x0ffffc45,
0x17fffa00,0x3ffe6000,0xffffeeef,0xeeeeeeef,0xeeeeeeee,0xfff10004,
0x0003fffd,0xadffffd8,0xfffeb989,0x7cc0004f,0xf702ffff,0x7e4005ff,
0xbfff71ff,0x2e000000,0xeeeeffff,0xffeeeeee,0x704fffff,0xddddffff,
0xdddddddd,0x09dddddd,0x400dfff7,0x001ffffa,0x46fffd80,0x0004fffc,
0xfff70000,0x0009fff3,0x017fffdc,0x007ffff2,0x7ffff440,0x5fff702f,
0x8fffe400,0x0005fffb,0xbfff7000,0x7ff54400,0xffb83fff,0x8000005f,
0xd002fffe,0x00009fff,0xc85ffff3,0x00004fff,0x2dffd000,0x0000fffe,
0x2005ffff,0x0006fffc,0x5ffffffb,0x00bffee0,0xf71fffc8,0x00000bff,
0x017ffee0,0x7ffffdc0,0x02fffdc1,0x7fd40000,0xfffa807f,0xfd80000f,
0xfffc86ff,0x80000004,0xff93fff9,0xff30007f,0x7fc400bf,0xffa8007f,
0x702fffef,0x64005fff,0xfff71fff,0x9999999d,0x00155579,0x00bfff70,
0x2ffffcc0,0x0017ffee,0x7ffec000,0x1ffff403,0x7ffc4000,0x4fffc82f,
0xc8000000,0xfff31fff,0xfff7000d,0xfffd8007,0x3ffe2001,0x702fffbc,
0x64005fff,0xfff71fff,0xffffffff,0x5dffffff,0x3ffee001,0x7fe40005,
0x3ffee1ff,0x30000005,0x2e01ffff,0x00006fff,0x320dfff9,0x00004fff,
0x47fff800,0x4001fffe,0x4001fffd,0x2002fffc,0xfff76ffd,0x0bffee05,
0x71fffc80,0xffffffff,0xffffffff,0x7007ffff,0x8000bfff,0x2e5ffff8,
0x00005fff,0x13fff200,0x00bfffe2,0x3fffe200,0x09fff902,0xfa800000,
0x7ffdc4ff,0x554c4004,0x7ffec000,0x3fff7002,0x5c0bffee,0x32002fff,
0xfff71fff,0xffffffff,0xffffffff,0xffb805ff,0xfb80005f,0x3ffee7ff,
0x20000005,0x641ffff8,0x00005fff,0x640dfff9,0x00004fff,0x0fffec00,
0x003fffe2,0xffe80000,0xfff9800f,0x40bffee3,0x2002fffb,0xff71fffc,
0x333333bf,0xff755333,0x5c03ffff,0x80005fff,0xf71ffff8,0x00000bff,
0x25fffb80,0x001ffff8,0x2ffff880,0x013fff20,0xff880000,0x7fffb06f,
0x2a000000,0xfd006fff,0x2fffb8df,0x007fff70,0xfb8fffe4,0xd88005ff,
0x2e06ffff,0x00005fff,0x3ee7fffd,0x000005ff,0x91fffe80,0x00009fff,
0x901bfff2,0x00009fff,0x27ffdc00,0x006fffa8,0xfffd0000,0x1fff9009,
0x702fffb8,0x6c007fff,0xfff71fff,0x7fe4000b,0xfff700ff,0x3f20000b,
0xbfff75ff,0x50000000,0xfff1bfff,0xf100001f,0xfc807fff,0xaaaaadff,
0xaaaaaaaa,0x7ff4001a,0x3fffe01f,0x5c000001,0x5400ffff,0xffb83fff,
0x7fff702f,0x8fffec00,0x0005fffb,0x40bfffe2,0x0005fffb,0x2ebfff90,
0xaaaaefff,0xaaaaaaaa,0x001aaaaa,0x7ff7fff4,0xf700003f,0xff900fff,
0xffffffff,0xffffffff,0x7ffcc009,0x2fffe406,0xff500000,0xff8805ff,
0x5fff705f,0x013ffee0,0xf71fffe8,0xe8000bff,0x2aaa4fff,0xaaaefffd,
0x801aaaaa,0xff76fffb,0xffffffff,0xffffffff,0x55307fff,0xfff95555,
0x5557ffff,0x7c001555,0xfc803fff,0xffffffff,0xffffffff,0x3ff2004f,
0x7ffcc03f,0xa800000f,0xd805ffff,0xff700fff,0x3ffee05f,0x3fffe005,
0x00bfff71,0x26fffc80,0xffffffff,0xffffffff,0x6fffb803,0xfffffff7,
0xffffffff,0x07ffffff,0xfffffff9,0xffffffff,0x05ffffff,0x01fffee0,
0x7fffffe4,0xffffffff,0x1004ffff,0xd001ffff,0x00007fff,0x0effffa8,
0x017ffdc0,0x2e05fff7,0xf3007fff,0x3fee3fff,0x7e40005f,0x3fffe5ff,
0xffffffff,0xb803ffff,0xfff76fff,0xffffffff,0xffffffff,0xfff907ff,
0xffffffff,0xffffffff,0x3fe005ff,0xff9003ff,0x555555bf,0x55555555,
0x3ffee003,0xdfff7005,0x7fd40000,0x7c400eff,0x7fdc05ff,0xffff702f,
0xfffe8809,0x0bfff71f,0x4fffd800,0x3fff6aaa,0xaaaaaaae,0xfffb801a,
0x55dfff75,0x55555555,0x35555555,0xdddddd70,0xddffffdd,0x3ddddddd,
0x1ffff700,0x13fff200,0x3fa00000,0x99999bff,0xfff99999,0xfb80002f,
0xe800efff,0x7dc00eff,0xfff702ff,0x7fec05ff,0xfff71fff,0x7fc4000b,
0xfff703ff,0x3f20000b,0xbfff75ff,0x80000000,0x0002fffc,0xffffffd0,
0xffffffff,0x0009ffff,0xffff9800,0xffffffff,0x5fffffff,0x7ffe4000,
0xffb800ef,0xfffb801f,0xfffff702,0xfd7315bf,0x2e3fffff,0x20005fff,
0x701ffffd,0x0000bfff,0x7dd3fff6,0x000005ff,0x17ffe400,0x7ffd4000,
0xffffffff,0xffffffff,0x64000004,0xffffffff,0xffffffff,0x8000ffff,
0x05ffffd8,0x33bfff30,0x93333333,0x13337fff,0x3fffffee,0xffffffff,
0xff71fffd,0xfb1000bf,0x7dc09fff,0xf00005ff,0x3fee7fff,0x2000005f,
0x99999998,0x99bfffc9,0x00999999,0x7ffffff4,0xffffffff,0x004fffff,
0x7fffc000,0xffffffff,0xffffffff,0x7f44003f,0x2e004fff,0xffffffff,
0xffffffff,0xf75fffff,0xffffb5ff,0xff39ffff,0x37ffee3f,0x99999999,
0xffffdcaa,0x3fee00ff,0xf880005f,0xfff71fff,0x6400000b,0xffffffff,
0xffffffff,0x202fffff,0xeeeffffa,0xeeeeeeee,0x004ffffe,0x3ffea000,
0x9999999e,0xfc999999,0x3e6006ff,0x4003ffff,0xfffffffb,0xffffffff,
0x75ffffff,0x3ff25fff,0xff33efff,0x3fffee3f,0xffffffff,0xffffffff,
0x7ffdc02f,0xffc80005,0x17ffee6f,0xffc80000,0xffffffff,0xffffffff,
0x3fa02fff,0xfc8004ff,0x000004ff,0x000ffff6,0x017fffc4,0x17ffffcc,
0x7fffdc00,0xffffffff,0xffffffff,0x85fff75f,0xf7000ab9,0xffffffff,
0xffffffff,0xf7001bff,0x98000bff,0x3ee4ffff,0x000005ff,0x3bbbbbae,
0xeeffffee,0x1eeeeeee,0x01ffff30,0x09fff900,0x3fe20000,0x3a0000ff,
0x7c405fff,0x0001ffff,0x55555551,0xfb555555,0x235559ff,0x0002fffb,
0xffffffb8,0xffffffff,0x2001dfff,0x0005fffb,0x70ffffec,0x0000bfff,
0xfffc8000,0x3ff60002,0xff90005f,0x2000009f,0x0005fffb,0x007fffd4,
0x003ffffd,0xff700000,0x3ffee05f,0xffb80002,0xaaaaaaef,0x00019aaa,
0x0017ffee,0x45ffffa8,0x0005fffb,0x7fe40000,0xff30002f,0x320003ff,
0x00004fff,0x005fffd0,0x4ffff880,0x03ffff70,0x2e000000,0xff702fff,
0xf700005f,0x00000bff,0x017ffee0,0x7ffffdc0,0x02fffdc0,0x32000000,
0xb0002fff,0x4000bfff,0x0004fffc,0x0ffff980,0xfffc8000,0x2ffff887,
0x20000000,0xf702fffb,0x700005ff,0x0000bfff,0x17ffee00,0xfffea880,
0xfffb83ff,0x00000005,0x0017ffe4,0x00ffffcc,0xdffff900,0xdddddddd,
0x3ddddddd,0x005fffc8,0x5ffff300,0xeeffffd8,0xeeeeeeee,0x002eeeee,
0x817ffdc0,0x0002fffb,0x005fffb8,0xfff70000,0xdddddddf,0xffffffdd,
0x3fee07ff,0xeeeeeeff,0xeeeeeeee,0x002eeeee,0x0017ffe4,0x0037ffec,
0x3fffff20,0xffffffff,0x1fffffff,0x0017fffc,0x4bfffd00,0xfffffff9,
0xffffffff,0x003fffff,0x817ffdc0,0x0002fffb,0x005fffb8,0xfff70000,
0xffffffff,0xffffffff,0x7ffdc05d,0xffffffff,0xffffffff,0x4003ffff,
0x4002fffc,0x002ffff8,0x7ffffe40,0xffffffff,0x1fffffff,0x001fffea,
0x1ffff700,0x3fffffea,0xffffffff,0x03ffffff,0x17ffdc00,0x002fffb8,
0x05fffb80,0xff700000,0xffffffff,0xdfffffff,0xffff7005,0xffffffff,
0xffffffff,0xc8007fff,0x64002fff,0x80006fff,0xfffffffc,0xffffffff,
0x361fffff,0x00004fff,0xca7fffc4,0xffffffff,0xffffffff,0x0003ffff,
0xa817ffdc,0x80001eee,0x0005fffb,0xffff7000,0xffffffff,0x40039dff,
0xfffffffb,0xffffffff,0xffffffff,0x00000003,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x88000000,0x0009acba,0x00000000,0x206f72e6,0x26660998,
0x566dd440,0x32e20000,0x02cc980a,0x00000000,0x26206662,0x7fdc0099,
0xffffffff,0x02ceffff,0x3ffffea0,0xffffffff,0xffffffff,0xffffff71,
0xffffffff,0x0159ddff,0x7fffdc00,0x202fffff,0x0006fffa,0x205fffb8,
0xffffffea,0xf93ffa3f,0xfffd13ff,0x0019ffff,0xdfffffa8,0x360fff22,
0x20003fff,0x24fffff8,0xffb5fff8,0x3fffc83f,0x7fddbffe,0xffffffff,
0xefffffff,0xffffa803,0xffffffff,0xffffffff,0xfffff71f,0xffffffff,
0xffffffff,0xffea8005,0xffffffff,0xfffa81ef,0xffb80006,0xffff905f,
0x29ffffff,0x3ffe4ffe,0xfffffe8b,0x001fffff,0xfffffff3,0x03fffdff,
0x0007fffb,0x13ffffe2,0x3f6bfff1,0x7ffe41ff,0x7ddbffe3,0xffffffff,
0xffffffff,0x3ea03fff,0xffffffff,0xffffffff,0xff71ffff,0xffffffff,
0xffffffff,0x2009ffff,0xeffffffa,0xffffffed,0x037ffd41,0x2fffdc00,
0x677fffec,0xedfffebb,0x37ffe4ff,0xdbbdffff,0x802fffff,0xffcadffd,
0xb04fffff,0x10007fff,0x107fffff,0x3ff6bfff,0x1fffe41f,0x3feedfff,
0xeeeeeeff,0xffffeeee,0xff504fff,0xddddddff,0xdddddddd,0x3fee3ddd,
0xccccccef,0xfedccccc,0x403fffff,0x02fffff8,0x41dffff7,0x0006fffa,
0x545fffb8,0xf304ffff,0x7c9fffff,0x80dfffff,0x00ffffe8,0x3aa07ff4,
0x3f604fff,0x7cc003ff,0xf103ffff,0x3fff6bff,0xf1fffe41,0x3ffeedff,
0x3f6a2005,0xfa83ffff,0x400006ff,0x0005fffb,0x1fffff91,0x07fffec0,
0x97fffe60,0x0006fffa,0x745fffb8,0x74403fff,0x3fe4ffff,0x74404fff,
0x55404fff,0xb0026202,0x4c007fff,0x203fffff,0x3315fff8,0x41333103,
0xfff72aaa,0x3fea000b,0x7fd41fff,0x5c00006f,0x40005fff,0x103ffffb,
0x2005ffff,0xf50ffffa,0x70000dff,0x7fd4bfff,0xfff5006f,0x7ffffc9f,
0x7fff9800,0x36000000,0xf3003fff,0x8807ffff,0x00005fff,0x00bfff70,
0x2ffffd40,0x001bffea,0x0bfff700,0xdfffb000,0x017ffee0,0x2a3fffd0,
0x80006fff,0x3f65fffb,0x3fa003ff,0x3fffe4ff,0x3fff6003,0xb0000001,
0xf3007fff,0x1005ffff,0x0000bfff,0x017ffee0,0x3ffff700,0x0037ffd4,
0x17ffee00,0x3ffee000,0x07fffb07,0x53fffc80,0x0000dfff,0x7fcbfff7,
0x7fd4007f,0x03fffe4f,0x02fffa80,0x2f36ea60,0x7ffec01a,0x7fffcc03,
0xfff1002f,0x2e00000b,0x80005fff,0x3ea5fffe,0x400006ff,0x0005fffb,
0x80ffff98,0x4001ffed,0xff53fffb,0xf70000df,0x3ffe2bff,0x7ffcc007,
0x001bffe4,0x9809fff3,0xfffffffe,0xffb03fff,0x7ffcc07f,0x3e2002ff,
0x333105ff,0xf7099980,0x70000bff,0x7fd4ffff,0x5c00006f,0x80005fff,
0x0807fffb,0x1fffd800,0x000dfff5,0x26bfff70,0x44006fff,0x3ffe4fff,
0x7ffc4005,0x3fffee05,0xffffffff,0x7ffec0df,0xfffff303,0xfff88005,
0x03fff905,0xffbb7ffc,0xf880005f,0xfff51fff,0xfb80000d,0xd80005ff,
0x00006fff,0x7d4ffff0,0xb80006ff,0xfff55fff,0x9fff000b,0x40027ffc,
0xffd07fff,0xdb99bdff,0xd89fffff,0xff983fff,0x88001fff,0xff905fff,
0xb7ffc03f,0x0005fffb,0x2a7fffd0,0x00006fff,0x002fffdc,0x13fffe20,
0x3ff20000,0x1bffea5f,0x3ffee000,0x009fff55,0x7fc9ffd0,0xfff8003f,
0x2ffffb87,0x3ffff660,0x30ffff60,0x003fffff,0x417ffe20,0x3e01fffc,
0xbfff76ff,0x3ff60000,0x0dfff55f,0xfffb8000,0x3fea0005,0x00000fff,
0x50ffffdc,0x0000dfff,0x3e6bfff7,0xff8005ff,0x013ffe4f,0x3a1fffe0,
0xfd001fff,0x7ffec7ff,0x3ffffe63,0x3fe20001,0x3fff905f,0xfbb7ffc0,
0x900005ff,0x3feabfff,0xaaaaaaff,0xaaaaaaaa,0x05fffb82,0x3ff2a620,
0x00003fff,0x227fffdc,0xeeeffffa,0xeeeeeeee,0xffeeeeee,0x0dfff15f,
0x24fff880,0x44005fff,0x7fcc6fff,0x3fee005f,0x4ffff64f,0x0ffffff9,
0x3ffe2000,0x03fff905,0xffbb7ffc,0xf700005f,0x3ffeadff,0xffffffff,
0x7fffffff,0xeeffffb8,0xfeeeeeee,0xffffffff,0x7e400005,0xffa84fff,
0xffffffff,0xffffffff,0x25ffffff,0x4c007fff,0x3ffe4fff,0x7ffcc006,
0x00f6e4c5,0x6cbfff50,0xfff9bfff,0x0006ffff,0x6417ffe2,0x3fe01fff,
0x0bfff76f,0x3ffee000,0xffffff56,0xffffffff,0xf70fffff,0xffffffff,
0xffffffff,0x0005ffff,0x4ffffc80,0xffffff50,0xffffffff,0xffffffff,
0x7fff4bff,0x3ffea001,0x001fffe4,0x0007fff7,0xb2fffcc0,0xffffbfff,
0x009fffff,0x417ffe20,0x3e01fffc,0xbfff76ff,0x3fee0000,0xfffff56f,
0xffffffff,0x70ffffff,0xffffffff,0xffffffff,0x00017bff,0x4ffffb80,
0x3bfffea0,0xeeeeeeee,0xeeeeeeee,0x3ff25fff,0x3ffa005f,0x0ffffe4f,
0x00ffff80,0xffda8800,0x3ffff65f,0xffd8efff,0xf88002ff,0xfff905ff,
0xbb7ffc03,0x00005fff,0x3eabfff9,0xaaaaafff,0xaaaaaaaa,0xffffb82a,
0xfeeeeeee,0x000cffff,0xffff3000,0x6fffa809,0xfffb8000,0x07fffe25,
0x93fffea0,0x7007ffff,0x8800dfff,0xffffecba,0x3ff65fff,0xf10effff,
0x8001ffff,0xf905fff8,0x7ffc03ff,0x00bfff76,0x53fffa00,0x0006fffa,
0x02fffdc0,0x37ffff22,0xfd800000,0xffa804ff,0xfb80006f,0x7ffdc5ff,
0x3ffa600e,0x3fffe4ff,0x7ffd405f,0xffeb801f,0xffffffff,0x3ff65fff,
0x7d40efff,0x44005fff,0xff905fff,0xb7ffc03f,0x0005fffb,0x2a7ffff0,
0x00006fff,0x802fffdc,0x00fffffa,0x3ffe2000,0xdfff5007,0xfff70000,
0x5ffffd0b,0xffffff50,0x7fffffc9,0x7ffdc41e,0x7ffdc04f,0xffffffff,
0x365fffcd,0x900effff,0x4007ffff,0xf905fff8,0x7ffc03ff,0x00bfff76,
0x5ffff100,0x001bffea,0x0bfff700,0x37fffd40,0xfff30000,0x3ffea007,
0xffb80006,0xfffe985f,0xffffeeff,0x3fe4fffe,0xefffffff,0x0dfffffe,
0x3ffffee0,0x261bceff,0x3ff65fff,0x7ff400ef,0xff1001ff,0x3fff20bf,
0x5dbffe01,0x80005fff,0xf51ffff9,0x80000dff,0x4005fffb,0x005ffffb,
0x05fff700,0x01bffea0,0x17ffee00,0x7ffffec4,0xff9cffff,0x23bffe4f,
0xfffffffe,0x7fd404ff,0x4c00beff,0x3ff65fff,0xfff9803f,0xff8800ef,
0x3fff905f,0xfbb7ffc0,0xc80005ff,0x3fea7fff,0x5c00006f,0xd8005fff,
0x0003ffff,0x001fffc8,0x000dfff5,0x80bfff70,0xefffffeb,0x7c9fff32,
0xfff916ff,0xb003bfff,0x2001bfff,0x3f65fffa,0xff7003ff,0xff100bff,
0x3fff20bf,0x5dbffe01,0x40005fff,0x2a3ffff9,0x00006fff,0x002fffdc,
0x0fffffc4,0x3fff6000,0xdfff5000,0xfff70000,0x055cc00b,0xff93ffe6,
0x0aba886f,0x03fffe00,0x25fffb80,0x2003fffd,0x403ffffd,0xf905fff8,
0x7ffc03ff,0x00bfff76,0x0ffffd80,0x001bffea,0x0bfff700,0x3fffea00,
0x4cc40006,0x3ffea001,0xffb80006,0xf300005f,0x37ffc9ff,0xfff30000,
0xfffe800d,0x00ffff65,0x1fffff88,0x417ffe20,0x3e01fffc,0xbfff76ff,
0x7ffd4000,0x37ffd44f,0x3fee0000,0x3f60005f,0x00004fff,0x6fffa800,
0xfffb8000,0xff300005,0x037ffc9f,0xffff3000,0x3fff2001,0x0ffff65f,
0xdffff500,0x82fffc40,0x3e01fffc,0xbfff76ff,0x3ffee000,0x7ffd40ff,
0x7dc00006,0x220005ff,0x001fffff,0x7fd40000,0xfb80006f,0x300005ff,
0x7ffc9fff,0x3e200006,0xfb804fff,0x3f66ffff,0xfd8003ff,0xff104fff,
0x3fff20bf,0x5dbffe01,0x22005fff,0x2fffffea,0x006fffa8,0x2fffdc00,
0x3ffee000,0x5550006f,0x3fea0035,0xfb80006f,0x300005ff,0x7ffc9fff,
0x7f400006,0xf9302fff,0x6cffffff,0x88003fff,0x882ffffe,0xff905fff,
0xb7ffc03f,0xeeeffffb,0xffeeeeee,0x02ffffff,0x000dfff5,0x05fffb80,
0xffffd800,0xffff8003,0xdfff5004,0xfff70000,0x3e60000b,0x1bffe4ff,
0xfff30000,0xffd9bdff,0xfffd7fff,0x00ffff61,0x7ffffcc0,0x82fffc40,
0x3e01fffc,0xffff76ff,0xffffffff,0xffffffff,0x37ffd405,0x3fee0000,
0xf880005f,0x4000ffff,0x5004ffff,0x0000dfff,0x000bfff7,0xf93ffe60,
0x800006ff,0xfffffffa,0xf70dffff,0x3fff67ff,0x3ff20003,0x7ffc46ff,
0x03fff905,0xffbb7ffc,0xffffffff,0xefffffff,0x7ffd400b,0x7dc00006,
0x700005ff,0x800bffff,0x5004ffff,0x0000dfff,0x000bfff7,0xf93ffe60,
0x000006ff,0xffffffb1,0xfff985df,0x007fffb6,0x4ffffe80,0x6417ffe2,
0x3fe01fff,0xfffff76f,0xdfffffff,0x5400379b,0x00006fff,0x002fffdc,
0x5ffffd00,0x27fffc00,0x06fffa80,0x5fffb800,0xddd30000,0x002f7747,
0x2ea62000,0xffd8001a,0x7cc0003f,0xff12ffff,0x3fff20bf,0x01bffe01,
0x00000000,0x00000000,0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0xcdcba800,0x2a20001a,0x0001aacb,
0x19999800,0x00000000,0x00ccccc0,0x10000000,0x00001333,0x00000000,
0x84cccc00,0x00006fff,0x0001bffe,0x7fffe440,0x002effff,0x7fffffe4,
0x007fffb6,0x7fffe400,0x7ffffe42,0x3fe00006,0x7fcc6fff,0x3fff24ff,
0x7d40000f,0xfff304ff,0x3fee01ff,0xffffffff,0x2defffff,0x7ffffec0,
0xffffffff,0xff801bde,0x0dfff3ff,0x37ffc000,0x7fcc0000,0xffffffff,
0xff9005ff,0x36bfffff,0x00003fff,0x3237fff4,0x01ffffff,0xffffa800,
0x37ffec6f,0x017ffff2,0x09fff500,0xdfffffd1,0x3ffffee0,0xffffffff,
0x0bffffff,0xffffffd8,0xffffffff,0x3e01efff,0xdfff3fff,0x7ffc0000,
0x7d400006,0xecdeffff,0x404fffff,0xfffffffa,0x07fffb3f,0xffe88000,
0x3ffff22f,0xd80003ff,0x266fffff,0x7e40ffff,0x0003ffff,0x3613ffea,
0x5fffcfff,0xffffffb8,0xffffffff,0x0effffff,0x7fffffec,0xffffffff,
0xf02fffff,0x3ffe7fff,0x3fe00006,0x2200006f,0x981effff,0x202ffffc,
0x31befffd,0x00ffff61,0x3ffe6000,0x3fffff26,0xff80006f,0x3f66ffff,
0xfffc81ff,0x50000fff,0xffb89fff,0x87fff95f,0xeeeffffb,0xeeeeeeee,
0x45ffffff,0xeeeefffd,0xffeeeeee,0xf81fffff,0xdfff3fff,0x7ffc0000,
0x3f600006,0x7dc00dff,0x3ffa06ff,0x3fff600f,0xf5000003,0x3fff23ff,
0x0001ffff,0x3fffffea,0x207fff36,0x5ffffffc,0x9fff5000,0xd07fffcc,
0x7fdc5fff,0xffb8005f,0x3ff64fff,0x3f62003f,0x99986fff,0x00dfff09,
0x037ffc00,0xffff8800,0x1fffd001,0xb01fffe0,0x00007fff,0xfcaffdc0,
0x03fffdff,0x3fbff600,0x0bff96ff,0x7fffffe4,0xffa8003f,0x5ffff14f,
0x70ffff98,0x2000bfff,0xb0ffffe9,0x70007fff,0x2001ffff,0x00006fff,
0x0001bffe,0x002fffdc,0xf103dff7,0xffd80dff,0x0000003f,0x7fdfffe4,
0xff10006f,0x00dfff7f,0xffffffc8,0x7d4000ff,0x700004ff,0x4000bfff,
0xfb1ffffa,0x3a0007ff,0xff002fff,0x7c0000df,0xb00006ff,0x08003fff,
0x02fffc40,0x000ffff6,0xfff90000,0x003fff95,0xff3fff50,0xffc800df,
0x05ffffcf,0x027ffd40,0x5fffb800,0x7fffc000,0x007fffb3,0x017fff20,
0x88037ffc,0xfff81999,0x0accb986,0x007fffc0,0x7cccc400,0x09999eff,
0x000ffff6,0x90ccc400,0xfff55fff,0x9ffb0007,0x262dfff1,0x3fff2019,
0x03ffffab,0x813ffea0,0x7dc01998,0x6c0005ff,0xfffb5fff,0x3fea0007,
0xdfff006f,0x9ffff700,0x7dcdfff0,0x3effffff,0x007fff88,0xfffff900,
0x45ffffff,0x0003fffd,0x23fff900,0xfff2fffc,0xfff8800d,0xf96fff89,
0x3ff203ff,0x1ffffb3f,0x13ffea00,0x201fffc8,0x0005fffb,0xfdb7ffdc,
0xf70003ff,0x3fe007ff,0x7ffdc06f,0x1dfff03f,0xfffffffb,0xff887fff,
0xf900006f,0xffffffff,0x7ffec5ff,0xf9000003,0x3fff23ff,0x003fff92,
0xff8bffd4,0x03fff96f,0x7c4ffff2,0xf5005fff,0x7fe409ff,0x3ffee01f,
0x7fe40005,0x07fffb5f,0x07fff600,0x7037ffc0,0x7c07ffff,0xffffefff,
0xfffffede,0x01bffe63,0x7f775c00,0x1eeeefff,0x000ffff6,0x8fffe400,
0xff32fffc,0x7fec007f,0x32dfff14,0xff901fff,0x7fffd47f,0x4fffa803,
0x807fff20,0x0005fffb,0xfd9ffff4,0xf98003ff,0x3fe007ff,0xffff506f,
0xfffff807,0x7f4c0aef,0xfff10fff,0xf100000d,0xffd80bff,0x9000003f,
0x3ff23fff,0x01bffe2f,0xf88fffc4,0x3fff96ff,0xb0ffff20,0xa801ffff,
0x3f204fff,0x3fee01ff,0x3ea0005f,0xfffb2fff,0xfffc8007,0x3ffe001f,
0x3ffffa86,0x6fffff80,0x17fffc40,0x0000ffff,0x80bfff10,0x0003fffd,
0x23fff900,0x3f22fffc,0xffb801ff,0x65bffe26,0xff901fff,0xffff887f,
0x27ffd405,0x403fff90,0x0005fffb,0x6cdffff3,0xccccefff,0xffdccccc,
0x7c001eff,0x7ffd46ff,0xffff002f,0xfff9001d,0x007fff49,0x7c406aa0,
0x7fec05ff,0x9000003f,0x3ff23fff,0x0fffe62f,0xf893ff60,0x3fff96ff,
0x20ffff20,0x203ffffa,0x3204fffa,0x3ee01fff,0x262005ff,0x22fffffd,
0xfffffffd,0xffffffff,0xf8000eff,0x3ffea6ff,0x3ffe002f,0xfff3003f,
0x00fffecb,0x10dfff10,0xfd80bfff,0x000003ff,0x3f23fff9,0x37ffc2ff,
0x887ffe20,0xfff96fff,0x0ffff203,0x807fffec,0x3204fffa,0x3ee01fff,
0xeeeeefff,0xffffeeee,0x7ec5ffff,0xffffffff,0xffffffff,0x7fc000cf,
0x5ffff56f,0x2ffff800,0x4bfff100,0x2005fffb,0xf883fffb,0x7fec05ff,
0x9000003f,0x3ff23fff,0x0fffe42f,0xf88dff70,0x3fff96ff,0x40ffff20,
0x506ffff8,0x7e409fff,0x3fee01ff,0xffffffff,0xffffffff,0x7fec0cff,
0xffffffff,0xffffffff,0x3fe002ff,0x4ffffaef,0x0ffff800,0x4dfff100,
0x001ffff8,0xf101fffd,0xffd80bff,0x9000003f,0x3ff23fff,0x1fffcc2f,
0xf887ffd0,0x3fff96ff,0x80ffff20,0xa83ffffb,0x3f204fff,0x3fee01ff,
0xffffffff,0xffffffff,0x9fffb01d,0x33333333,0xffffb753,0x3ffe007f,
0x0fffffff,0x03fffc00,0xb8dfff10,0x6400efff,0xff106fff,0xfffd80bf,
0xf9000003,0x3fff23ff,0x106fff82,0xff881fff,0x03fff96f,0xb00ffff2,
0xfa81ffff,0x3ff204ff,0x3ffee01f,0xffffffff,0x01acceef,0x001fffec,
0x0fffffd4,0x3fe35555,0xffffffff,0x37ffc006,0x0dfff100,0x815ffffd,
0x00ffffd8,0xd80bfff1,0x00003fff,0x323fff90,0xffc82fff,0x86ffb80f,
0xff96fff8,0x3fff203f,0x7fffc403,0x027ffd46,0x5c03fff9,0x00005fff,
0x007fffb0,0x97fffa20,0xfff3ffff,0xffff7fff,0x37ffc007,0x0dfff100,
0xdffffff3,0x5ffffffd,0x02fffc40,0x000ffff6,0x8fffe400,0xf982fffc,
0x3ffe83ff,0xf96fff88,0x3ff203ff,0xfffb803f,0x13ffea3f,0x201fffc8,
0x0005fffb,0x07fffb00,0x7fffe400,0x3e7ffff0,0xff71ffff,0x3fe003ff,
0x3fe2006f,0xfffb106f,0xffffffff,0x5fff8805,0x01fffec0,0xfffc8000,
0x205fff91,0x7fc46fff,0x6fff880f,0x3203fff9,0xfb003fff,0x3fea1fff,
0x3fff204f,0x17ffee01,0x7fec0000,0x3e60003f,0xffff1fff,0xb07fffe7,
0x3e00dfff,0x3e2006ff,0x7f5406ff,0x04ffffff,0x80bfff10,0x0003fffd,
0x23fff900,0xf902fffc,0x37fdc3ff,0xf96fff88,0x3ff203ff,0xfff1003f,
0x13ffeadf,0x201fffc8,0x0005fffb,0x07fffb00,0x2ffff800,0x3fe7ffff,
0xffff886f,0x06fff803,0x01bffe20,0x00d6ffcc,0x017ffe20,0x0007fffb,
0x47fff200,0xf302fffc,0x1fff49ff,0xf96fff88,0x3ff203ff,0x3fee003f,
0x4fffabff,0x807fff20,0x0005fffb,0x07fffb00,0x7fffc400,0x837ffc01,
0x401ffffb,0x22006fff,0xf9006fff,0xf100019f,0xffd80bff,0x9000003f,
0x3ff23fff,0x5bffa02f,0xf100fff9,0x3fff2dff,0x07fff901,0xcffffd80,
0x3f204fff,0x3fee01ff,0xb000005f,0x40007fff,0x400ffffa,0x3fa06fff,
0x7ffc06ff,0x3ffe2006,0xffffd006,0x7fc4001b,0x7ffec05f,0xf9000003,
0x3fff23ff,0x27fff202,0x3e205ffc,0x3fff96ff,0x00ffff20,0xffffff10,
0x7fe409ff,0x3ffee01f,0xfb000005,0x6c0007ff,0xff806fff,0x3ffe606f,
0x1bffe03f,0x06fff880,0x0fffea20,0x05fff880,0x001fffec,0x1fffc800,
0x4c05fff9,0x2ffebfff,0x65bffe20,0xff901fff,0xff70007f,0x409fffff,
0x2e01fffc,0x00005fff,0x007fffb0,0x13fffee0,0x901bffe0,0x3e03ffff,
0x3e2006ff,0xfd8006ff,0x3fe2007f,0x7ffec05f,0xf9000003,0x3fff23ff,
0x7ffff402,0x3fe200ff,0x03fff96f,0x000ffff2,0x7fffffec,0x07fff204,
0x005fffb8,0x7fffb000,0xfffda800,0xfff800ff,0x6fffe806,0x400dfff0,
0x1006fff8,0x00dfff73,0x202fffc4,0xeeeefffd,0xeeeeeeee,0xf901eeee,
0x3fff23ff,0x7fffe402,0x7ffc405f,0x203fff96,0x0003fffc,0x9ffffff1,
0x00fffe40,0x000bfff7,0x3bfff600,0xeeeeeeee,0xffffffee,0xdfff001f,
0x7ffff300,0x400dfff0,0x2606fff8,0xffffffff,0x3ffe2002,0x7fffec05,
0xffffffff,0x1fffffff,0x323fff90,0x7cc02fff,0x4402ffff,0xfff96fff,
0x0ffff203,0xffffb800,0x3fff204f,0x17ffee01,0x7fec0000,0xffffffff,
0xffffffff,0x3fe003ff,0xfff9006f,0x06fff83f,0x81bffe20,0xfffffff9,
0x7ffc4002,0x7fffec05,0xffffffff,0x1fffffff,0x323fff90,0xfe802fff,
0xff8807ff,0x03fff96f,0x000ffff2,0x09ffffb0,0x700fffe4,0x0000bfff,
0x3fffff60,0xffffffff,0x00cfffff,0x8037ffc0,0x7c6ffff8,0x3e2006ff,
0x332606ff,0x10002cce,0xfd80bfff,0xffffffff,0xffffffff,0xfff901ff,
0x00bfff23,0x2017fff2,0xff96fff8,0x3fff203f,0x7fc40003,0x3ff204ff,
0x3ffee01f,0xfb000005,0xffffffff,0x79bddfff,0x00000001,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,0x00000000,0x00000000,
0x97100000,0x05991017,0x00000100,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x26000000,0x2a200999,0x7ffd400a,0x3ff22dff,
0x81322003,0x4c5ffff8,0xffffffff,0xffffffff,0x25ffffff,0x004ffffb,
0x3ffff600,0x3ffffa20,0x7fd40000,0x3ffe61ff,0xfff70007,0x3f2000ff,
0xfffff4ff,0xffffffff,0xffffffff,0x3f27ffff,0x800007ff,0x3fe1ffff,
0xffd103ff,0x7fffc405,0xffefffff,0x9ff7001f,0x2ffffc40,0x3fffffe6,
0xffffffff,0xffffffff,0x0fffff45,0x7ffdc000,0xffff983f,0x3fe20005,
0xffff83ff,0xfffd8001,0xfe8001ff,0xfffff2ff,0xffffffff,0xffffffff,
0x3e67ffff,0x00002fff,0xff1bffea,0xffd107ff,0x77fe405f,0xffffffca,
0xfff5005f,0x7fffc409,0x7ffffcc5,0xffffffff,0xffffffff,0x7fffcc5f,
0x7fc40006,0x3fee05ff,0xfd0003ff,0x3ff60bff,0xfff8003f,0x44003fff,
0x3ffe7fff,0xffffffff,0xffffffff,0x23ffffff,0x0005fffe,0xf0ffff60,
0xffb87fff,0x3fa02fff,0x7fff541f,0xfff5000d,0x7fffc409,0x777774c5,
0xeeeeeeee,0xfffeeeee,0xffffb84f,0x3ff60004,0x7ff400ff,0x7e4001ff,
0xff700fff,0xffa800bf,0x4005ffff,0x3b65fffa,0xeeeeeeee,0xeeeffffe,
0x2eeeeeee,0x003fffee,0x3fffe200,0xa9ffffc0,0x2fffffff,0x9880aaa0,
0x7ffd4000,0x3fffe204,0xe8800005,0xfd00ffff,0x50003fff,0x1005ffff,
0x400dffff,0x202ffffa,0x4007fff9,0x7ffdfffc,0x1fffe400,0x37ffd400,
0xffff8800,0xffb80002,0x0999985f,0xffb3bff9,0x00000005,0x8813ffea,
0x0005ffff,0x1ffffe80,0x1bfffe60,0xbffff100,0x7fffd400,0xffff8804,
0x0ffff804,0x2f7ffa00,0x3a002fff,0xa8001fff,0x20006fff,0x0005fffc,
0x002fffe8,0x2ffd8772,0x50000000,0x7c409fff,0x00005fff,0x01ffffec,
0x01ffffdc,0x01dfffb0,0x1ffffd80,0x037fff40,0x002fffd8,0xff17fff1,
0x3fe2009f,0xff50007f,0x7cc000df,0x20000fff,0x4007fff9,0x002ffd80,
0x157b9531,0x7fdccc00,0x220999cf,0x0005ffff,0x13ffff20,0x1ffffe80,
0x1ffffa80,0xfffe8800,0xffff900f,0x3ffee001,0x3fff7004,0x5401bffa,
0x50004fff,0x8000dfff,0x0003fffe,0x0013fff2,0x200bff60,0xfffffffc,
0x7fcc02ff,0xffffffff,0x027fffc3,0xffffb800,0x7ffcc006,0x7ffc406f,
0x3e60004f,0xffa85fff,0x3e6002ff,0xffb006ff,0x007ffe4d,0x0017ffe4,
0x006fffa8,0x037ffdc0,0x01ffff00,0x05ffb000,0x7fffffd4,0x0dffffff,
0xffffff30,0xff87ffff,0x980004ff,0x000fffff,0x03ffffb8,0x001bfff6,
0x8bffff20,0x004ffff8,0x800ffff8,0x3fea4fff,0xfffe802f,0xfff50000,
0xff88000d,0xfa8000ff,0xb00005ff,0x3fea05ff,0xfdcdefff,0x881fffff,
0xeffffeee,0x7fff42ee,0x7fc40003,0x20001fff,0xa80ffffe,0x0001ffff,
0x21ffffd0,0x0006fffd,0x9803fff9,0x3fe22fff,0x7ffc405f,0x3fea0006,
0xfd80006f,0xfd8003ff,0xb00002ff,0xfff105ff,0x3fee03df,0x7fd406ff,
0x7fff404f,0x7ff40003,0x4c0003ff,0xfe85ffff,0x200004ff,0xfbdffff9,
0x50000fff,0xfb807fff,0x3fff40ff,0x013ffea0,0x06fffa80,0x6fffa800,
0x3fffc400,0x5ffb0000,0x01bfffb0,0x03fffe98,0xb013ffea,0x40005fff,
0x004ffffc,0x5ffff700,0x0037ffe4,0x7fffdc00,0x0002ffff,0xd017ffe2,
0xfff70dff,0x0fffe403,0xdfff5000,0x3ffe0000,0x3fee001f,0x3600004f,
0x7ffd42ff,0xfff5000f,0x3ffea01f,0x0fffec04,0xffffa800,0x7f400006,
0xffff36ff,0x36000003,0x04ffffff,0x07ffe800,0x260fffe2,0x3fa03fff,
0x7d40007f,0x900006ff,0x74009fff,0x00001fff,0xffb0bff6,0xffe8007f,
0x9fff503f,0x01fffc80,0xfffff980,0x7cc00000,0xfffdbfff,0x22000003,
0x006fffff,0x03fff900,0x7c07ffea,0xfff106ff,0xffa8000b,0xf300006f,
0x3e600fff,0x400006ff,0x7ff42ffd,0x7fd4000f,0x9fff504f,0x00fffc80,
0x7ffff440,0xf7000001,0x0bffffff,0xff900000,0x20000bff,0xf903fffa,
0x7ffec0ff,0x03fffa80,0x37ffd400,0xfffd0000,0x5fff9005,0xffd80000,
0x0037ffc2,0xa837ffc4,0x7dc04fff,0x7ec000ff,0x00002fff,0x7fffff40,
0x4000000f,0x3ffffff9,0xfff88000,0x40bfff05,0xfc82fffb,0x540001ff,
0x00006fff,0x2017ffea,0x0000ffff,0xbfff3000,0x1fffe000,0x2027ffd4,
0x64007ffb,0x0004ffff,0xffff9800,0x4000002f,0xfffffff8,0xfe80001f,
0x2fff986f,0x213ffe20,0x80007ffe,0x0006fffa,0x203fffc0,0x0004fffa,
0x3ffea000,0xffff0004,0x09fff501,0x2007ffa8,0x005ffffa,0x3ff20000,
0x8000006f,0xfffefffd,0xfc80006f,0x7ffdc0ff,0x437ff400,0x80004fff,
0x0006fffa,0x017ffe40,0x2003fffb,0x3fe0aaaa,0xfff703ff,0x3ffa0009,
0x4fffa81f,0x803ffcc0,0x00effff9,0x3ee00000,0x000005ff,0x5cffffdc,
0x0004ffff,0x3617ffcc,0xffc806ff,0x0bffe60f,0x3ffea000,0x7cc00006,
0xfff105ff,0x7fffc00d,0x40ffffe3,0x0004fffa,0xf501ffff,0xff9809ff,
0xfffe8806,0x0000001f,0x002fffdc,0xffff3000,0x0ffffec7,0x13ffe000,
0xf5009fff,0x7ffdc3ff,0xffa80000,0xe800006f,0xffb80fff,0x3ffe003f,
0x0ffffe3f,0x002fffcc,0xa83fffc4,0x7c404fff,0xfffd806f,0x0000002f,
0x005fffb8,0xfffd1000,0xfffff88d,0x3ff60000,0x007ffea6,0xfd8fffe2,
0xf500006f,0x00000dff,0xfd07fff7,0x7fc001ff,0x3fffe3ff,0x0dfff103,
0x0ffff300,0x1013ffea,0xffc80bff,0x000004ff,0x0bfff700,0x3ff60000,
0xfffa80ff,0x3ee0005f,0x0fff90ff,0xff2fff40,0x2a00009f,0x00006fff,
0x446fff88,0x7c005fff,0x3ffe3fff,0x3fffe03f,0x7ffdc000,0x09fff505,
0x7d409ff0,0x00005fff,0x3ffee000,0xfb800005,0x3f602fff,0x30003fff,
0x3ffa3fff,0x5ffee005,0x0001fff9,0x00dfff50,0x3fff6000,0x007fff20,
0xfff17f40,0x7ffec05f,0x7fff4004,0x09fff502,0xffff3000,0x0000001d,
0x02fffdc0,0x3ffe6000,0x7ff4405f,0xff0000ff,0x07fff17f,0x547ffcc0,
0x200007ff,0x0006fffa,0x47fff500,0x10006ffe,0x7fff41ff,0x3fffe601,
0xffff7000,0x13ffe601,0xfffd1000,0x0000003f,0x05fffb80,0x7fff4000,
0xfff9800e,0xffb0006f,0x001fff5b,0xffcafff8,0x3ea00005,0x000006ff,
0x7fcdbffe,0xdf50003f,0x400fffc8,0x400efffc,0x204ffffa,0x0006fff9,
0x00ffffec,0x5c000000,0x00005fff,0x007ffff2,0x04ffffc8,0xfceffb80,
0xffd8006f,0x0003ffec,0x01bffea0,0xfffc8000,0x000fffb8,0x7dc5fe88,
0xfff8806f,0x7e440aff,0x7c406fff,0x41abdfff,0x3f21aaaa,0x00002fff,
0xfff70000,0x3ea0000b,0xe8003fff,0x4001ffff,0x4ffffff9,0xfeffb800,
0x200001ff,0x0006fffa,0x2fffe200,0x88005ffe,0x7fd40efe,0xffff5005,
0xffffddff,0xff001dff,0xf8bfffff,0xfff13fff,0xddddddff,0xdddddddd,
0x01dddddd,0x17ffee00,0x3ffe2000,0xff10006f,0xf8001fff,0x002fffff,
0x7fffff88,0x7fd40000,0x4000006f,0x2fffeffd,0x220bb000,0x362004ff,
0xffffffff,0x3000dfff,0x8dffffff,0xff13ffff,0xffffffff,0xffffffff,
0x3fffffff,0x3ffee000,0xffe80005,0x2e0000ff,0x4005ffff,0x00fffffc,
0x9ffffd00,0xffa80000,0x4000006f,0x07fffffa,0x15500200,0xfffd7000,
0x003bffff,0xfffffb30,0xf13ffff8,0xffffffff,0xffffffff,0xffffffff,
0x3fee0003,0x7e40005f,0x80002fff,0x003ffffd,0x017fffea,0x2ffffc80,
0x7fd40000,0x8000006f,0x004fffff,0x80000000,0x0009aba9,0xff013100,
0x3ffe27ff,0xffffffff,0xffffffff,0x01ffffff,0x0bfff700,0x7fffd400,
0xff100004,0x22001fff,0x0003ffff,0x003fffea,0xdfff5000,0xf9000000,
0x00001fff,0x00000000,0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0xcb980000,0x5c199502,0xcccccccc,
0xcccccccc,0xddd53ccc,0xdddddddd,0xdddddddd,0x75c00ddd,0x000000ee,
0x4c400500,0x00accdcb,0x15e6dd44,0x6dd4c000,0x40001abc,0x01acdcba,
0x5e654c00,0x2666000a,0x04ccc000,0xfff90000,0x7ff439ff,0x3fffffa0,
0xffffffff,0x56ffffff,0x0b000003,0x007ffe40,0xcdba8800,0x00dfc82b,
0x3fffffea,0x4c1effff,0xffffffff,0x3a6000bf,0xffffffff,0x322003ff,
0xffffffff,0x7fdc002e,0x2fffffff,0x02fffc40,0x3e9fff30,0x3ff63fff,
0xffffb85f,0xfffeffff,0x7fffff47,0xffffffff,0x56ffffff,0x0b000003,
0x007ffe40,0x3fffea00,0xa8bfffff,0xffb106ff,0xffffffff,0x3fee3fff,
0xffffffff,0xffb800ef,0xffffffff,0x4c00dfff,0xffffffff,0x8805ffff,
0xfffffffd,0x100dffff,0x4c00bfff,0xffff4fff,0x42fffec7,0xffdacfff,
0x742fffff,0xffffffff,0xffffffff,0x00355fff,0x6400b000,0x10000fff,
0xfffffffb,0xffffffff,0xffffd101,0xffd999bd,0xffffdfff,0xfffd99bd,
0x7ff401df,0xedccdeff,0x204fffff,0xdefffffa,0x4fffffec,0x3ffffe60,
0xffffdcde,0xfff880ef,0x3ffe6005,0x6c7ffff4,0x7fc45fff,0x7fffe446,
0x99999883,0x99999999,0x50efffc9,0x0b000003,0x007ffe40,0x7ffffc40,
0xfffeccdf,0xff902fff,0x7f4c03df,0x02ffffff,0x20dfffd3,0x202ffffb,
0x80ffffd9,0x81effff8,0x02ffffc9,0x203dfffd,0x885ffff9,0x26005fff,
0xffff4fff,0x22fffec7,0x06601aa8,0x3fe60000,0x0006a1ff,0xfc801600,
0xfd8000ff,0xfd303fff,0x3fe05fff,0xfff5006f,0xfb001dff,0xfffd05ff,
0x3fffa003,0x0dfffd83,0x437ffdc0,0x8806fffb,0x7c41fffe,0x3e6005ff,
0x7ffff4ff,0x002fffec,0xd1000000,0x01a85fff,0x20058000,0x4000fffc,
0x401ffffa,0xa86ffffb,0x3e003fff,0x1002ffff,0xff98dfff,0x3fee005f,
0x7fffc44f,0x1fffd001,0x007fffc4,0x446fff98,0x26005fff,0xfffd4fff,
0x02fffe47,0xb0000000,0x03509fff,0x400b0000,0x2000fffc,0x402ffff8,
0x2ffffff9,0x0007f6dc,0x800bfffd,0x3260fffc,0x3ea001ed,0x7ffdc5ff,
0x3bfee005,0x00ffff21,0x443fffb0,0x26005fff,0xfffb4fff,0x9a7ffdc5,
0xccb98099,0x2a00001a,0x1a80ffff,0x26580000,0xc9999999,0x9999afff,
0x3fee0999,0x7ff4406f,0x0006fffc,0x00ffff60,0x003fff50,0x17ffe600,
0x8003fffb,0x03fffb00,0x23fffb80,0x2005fff8,0xff74fff9,0x97ffcc1f,
0x3ff23fff,0x02ffffff,0x7fffc400,0x00003502,0x3fffe6b0,0xffffffff,
0xffffffff,0x00bfff26,0xfff17ffb,0xb988000f,0x4002fffe,0x0003fff9,
0x2fffed44,0x0003fffe,0x007fff40,0x893ffe60,0x26005fff,0xfff54fff,
0xff1fff88,0x3ffff67f,0x04ffffff,0x17fff200,0x800001a8,0xffffff35,
0xffffffff,0x4dffffff,0x2e01fffd,0x3fff65ff,0xdb751000,0xdfffffff,
0xdddddddd,0x9fffdddd,0x3b2ea200,0x5fffffff,0x001fffe2,0xeeffff80,
0xeeeeeeee,0x25fffeee,0x2005fff8,0xff14fff9,0x7fcfff0d,0xdffffdcf,
0x4ffffffe,0xffff9800,0x00006a00,0x7fffcd60,0xffffffff,0xffffffff,
0x403fffa6,0x3f20eff9,0xfb7101ff,0xffffffff,0xffffffff,0xffffffff,
0x5c0dffff,0xfffffffe,0x25ffffff,0x0006fff8,0xffffff10,0xffffffff,
0x4dffffff,0x2005fff8,0x3fe4fff9,0x3fe6fd85,0x441dffff,0x007ffffa,
0x404fffd8,0x5800001a,0x99999991,0x999fffd9,0x7c799999,0xfff107ff,
0x82fffb83,0xfffffff9,0xffecefff,0xffffffff,0xffffffff,0xffffb87f,
0xdfffffff,0x3e65fffc,0x300006ff,0xffffffff,0xffffffff,0x7c4fffff,
0x3e6005ff,0x206aa4ff,0x3fffe1a9,0x7ffcc04f,0x3fe6002f,0x00d401ff,
0x9002c000,0x22001fff,0xffd06fff,0x87fff705,0xeffffffa,0x3ff60abd,
0xaaaaaabf,0xaaaaaaaa,0x7fffdc2a,0x21bcefff,0x3e25fff9,0x300006ff,
0x5555dfff,0x55555555,0x7c455555,0x3e6005ff,0x3e0004ff,0xf9006fff,
0x7e4009ff,0x01a805ff,0x20058000,0x2000fffc,0xffc87fff,0x45fff904,
0x0adffffa,0x00fffec0,0xffff5000,0xff98017d,0x03fffc5f,0x6fff8800,
0x7fc40000,0x3fea006f,0x02cc884f,0x400bfffe,0x2005fffa,0xa802ffff,
0x05800001,0x003fff20,0x7d47ffe8,0x3fff606f,0x013fff61,0x002fffd8,
0x37fff600,0xbfff5000,0x000fffe8,0x3ffe0d54,0x2200000f,0x2a006fff,
0xffb84fff,0x07fffe03,0x02fffcc0,0x007fffa8,0xb0000035,0x07ffe400,
0x23fffb00,0x3a00fff8,0x3ffe27ff,0x7fff4007,0x4d64c003,0x003fffe0,
0x6c5fffb8,0x22001fff,0x3ff66fff,0x4d44001f,0x006fff80,0x3613fff2,
0x3ffe01ff,0xfff1000f,0x3fff600b,0x00035003,0x7e400b00,0x3f2000ff,
0x05ffd3ff,0xf537ffc4,0x7cc00bff,0x64005fff,0xfff34fff,0xfffe800d,
0x02fffdc5,0x647fff70,0x64005fff,0x7ffc5fff,0x3fffa007,0x0cffff84,
0x2007fff8,0x8806fff8,0x5000ffff,0x0b000003,0x007ffe40,0xf9dfff50,
0xfffc809f,0x01fffea5,0x3fffffd8,0x1ffff100,0x003fffe6,0x22ffffe4,
0x001ffff8,0x7c41fffd,0xf1002fff,0xffe83fff,0xfffc803f,0x7f65444f,
0x37ffc0ff,0x0dfff100,0x00bfff90,0x400000d4,0x3fff2005,0x3ffe2000,
0x7c406fff,0x3fe22fff,0xffc802ff,0x403fffff,0x225fffe8,0xb804ffff,
0xb86fffff,0x6400efff,0xffb86fff,0x7f4401ff,0xfffc86ff,0x3ffee00f,
0x7ffc04ff,0x0037ffc3,0xf00dfff1,0x54003fff,0x05800001,0x003fff20,
0x1fffff70,0x27fff440,0x80f7fff4,0xfccfffea,0x540acfff,0x740ffffe,
0x9302ffff,0x0fffffff,0x02bffffa,0x01ffffb1,0x033ffffa,0x3ffffd93,
0x7dffff30,0x3fff2a21,0x3e604fff,0x37ffc5ff,0x0dfff100,0x006fffa8,
0x400000d4,0x0aaa6005,0x7ffff400,0x7ffd440c,0xfff980ef,0xfedcceff,
0x3fee1eff,0xffeeffff,0xf981ffff,0xecdeffff,0xfebfffff,0xfff980ff,
0xfffeefff,0x3a602fff,0xfeffffff,0x02ffffff,0x3ffffff6,0xe9ffffff,
0xdb9934ff,0xff85ffff,0x3fe2006f,0x7ffec06f,0x000d4003,0x00002c00,
0x3ffff600,0xfffeeeff,0x3ee01fff,0xffffffff,0xffa80dff,0xffffffff,
0x3fea01ef,0xffffffff,0x7fff70df,0x3ffff620,0x2fffffff,0xffffc880,
0xffffffff,0xffffc802,0xd1efffff,0x3ffee9ff,0xff84ffff,0x3fe2006f,
0x7fffc06f,0x000d4000,0xccc8ac00,0xcccccccc,0xcccccccc,0x7fffdc3c,
0xffffffff,0xd8801eff,0xceffffff,0x7ff64c02,0x002effff,0xffffffb1,
0xfff985df,0x7fff5406,0x8004ffff,0xffffffda,0x754003ff,0x0cefffff,
0x7fe53ffa,0xff01dfff,0x7fc400df,0x3ffe606f,0x001a8007,0xfff35800,
0xffffffff,0xffffffff,0x477fccdf,0xffffffd9,0x988002ef,0x200009ba,
0x00009ab9,0x00357531,0x2aea6000,0x75100001,0x30000135,0x31000157,
0x0dfff001,0x037ffc40,0x000bfff7,0xb0000035,0x3fffffe6,0xffffffff,
0x26ffffff,0x54c41ffa,0x000009ab,0x00000000,0x00000000,0x00000000,
0x00000000,0x801bffe0,0x3606fff8,0xa8004fff,0x35800001,0xffffffff,
0xffffffff,0x298dffff,0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x4400dfff,0x3fa06fff,0xda8002ff,0xcccccccc,0xcccccccc,
0x0006cccc,0x00000000,0x00000000,0x00000000,0x00000000,0x00000000,
0xdfff0000,0x37ffc400,0x003ffff0,0x20000000,0x88888888,0x88888888,
0x88888888,0x3fffff20,0xffffffff,0xffffffff,0x0002ffff,0x00000000,
0x00000000,0x00000000,0xff000000,0x7fc400df,0xffff106f,0x00000001,
0xfffff900,0xffffffff,0xffffffff,0x3f25ffff,0xffffffff,0xffffffff,
0xffffffff,0x00000002,0x00000000,0x00000000,0x00000000,0x00dfff00,
0x9837ffc4,0x00006fff,0xff900000,0xffffffff,0xffffffff,0x5fffffff,
0x3bbbbbb2,0xeeeeeeee,0xeeeeeeee,0x00002eee,0x00000000,0x00000000,
0x00000000,0xfff00000,0x7ffc400d,0x0bfff506,0x00000000,0x3bbbbbae,
0xeeeeeeee,0xeeeeeeee,0x00001eee,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0xca980000,0x00009acd,0x2af72a62,
0x82666000,0x9980acb8,0x26200199,0x4ccc0999,0x0bcdb980,0x0abcb980,
0x00133310,0x4c426660,0x26620019,0x86662001,0xcb980999,0x999801ac,
0x99999999,0x09999999,0x0a200000,0x200ddd44,0xffffffb8,0x4000efff,
0xfffffffc,0x7fc402ff,0xfffff73f,0x7fffdc3b,0xdfffb002,0x7ec7fff0,
0x85ffffff,0xffffffd8,0x7fff883f,0x4fffb800,0x2005fff9,0x8802ffff,
0x3ffe5fff,0x3fffff23,0xff302fff,0xffffffff,0xffffffff,0xb300000b,
0xffff709f,0x3ffa03df,0xffffffff,0xffa803ff,0xffffffff,0xff100dff,
0xfffff57f,0xfffe81ff,0x7ffdc00f,0x8bfff81f,0xfffffffe,0x3ffa24ff,
0x5fffffff,0x002fffd8,0xfa8ffff4,0xff9804ff,0xffa804ff,0x6cfffe3f,
0xffffffff,0xfff984ff,0xffffffff,0x5fffffff,0xfd710000,0xfffc89ff,
0x6c2fffff,0xcccdffff,0x03fffffd,0x3bffffea,0xfffffdcd,0xbfff881f,
0x5fffffff,0x04ffff88,0x40ffffe6,0xfffecfff,0xfffffedf,0xdefffe8a,
0x41ffffff,0x2005fffa,0x7fc6fff8,0xfffc807f,0xfffc806f,0x3f73ffe0,
0xfffedfff,0x7fcc4fff,0xffffffff,0xffffeeff,0x7e4c0004,0x2a4fffff,
0xfd712dff,0x3bffea1f,0xdfffb100,0x3bfffe20,0xdffff701,0xffffff10,
0x205fb79f,0xd01ffffa,0x7fc0bfff,0x441dffff,0xfffffffd,0x6ffff983,
0x000ffff8,0xfd87fff7,0x7ff401ff,0x7fc00fff,0x7ffffc6f,0x7fd441df,
0x880007ff,0x0005fffe,0x3fffff6a,0x1ffa1dff,0xffc9ffcc,0x7ffc402f,
0xdfffd81f,0x7fff4c00,0x7ffffc43,0xfffd8005,0x0efffc86,0x17ffffe0,
0x3ffffff0,0x43fffd40,0xd002fffc,0xffb81fff,0x3ffe203f,0x3e602fff,
0x7fffc3ff,0x7ffcc04f,0x7ec0002f,0x44000eff,0xffffffeb,0x04ff80cf,
0x3fff57fa,0x43fffb80,0x000ffffa,0x441ffff5,0x000fffff,0x24ffff88,
0x401ffffa,0x400effff,0x804ffffc,0x7cc0fffe,0xff9805ff,0x5fff885f,
0x3fbffea0,0x3ffee04f,0x037fffc0,0x004fffc8,0x03ffff20,0xffffc980,
0x2202efff,0x5bf201ff,0x3000fffe,0x0ffff601,0x47fffd00,0x003ffff8,
0x27fffea0,0x803ffff8,0xa802ffff,0xd800ffff,0xffe81fff,0x7ffe400f,
0x40fffd02,0x6ffcdffc,0x3e1bffa0,0xf5002fff,0x2e000bff,0x5001ffff,
0xfffffffd,0x13fe0039,0xfff75fe8,0xfe80003d,0x7d4000ff,0x3ffe24ff,
0x7e40002f,0x5fffdeff,0x03ffff00,0x00ffff30,0x2e0bfff2,0x7fc03fff,
0x3ffee07f,0xf55ffd01,0xfff101ff,0x03ffff09,0x017ffe60,0x0bfffea0,
0xfffff710,0x80017dff,0x7ff307fe,0x3bffffe6,0xfff8001c,0xfff88006,
0x03fffe26,0x3fffa000,0xf000ffff,0x3e600fff,0xff7006ff,0xdfff105f,
0x027ffd40,0xf109fff3,0x5fff31ff,0xf03fff50,0x22001fff,0x4c005fff,
0x5c03ffff,0xdfffffff,0x3fe60001,0x1ffd712e,0x7fffffe4,0x4c00bdff,
0xf0005fff,0x7ffc4fff,0xff300007,0x4005ffff,0xf3007fff,0x3ee00bff,
0xfffb02ff,0x07fff601,0xf70dfff0,0x427ffcdf,0xfff07ffd,0x7ffc400f,
0x3ffe2006,0xfffc804f,0x00000bef,0xfffffff9,0xffff705f,0x7dffffff,
0x013ffea0,0x887fffc0,0x00006fff,0x013fffee,0x200dfff0,0x7004fff9,
0x3ea05fff,0xfff883ff,0x0fffc806,0xffb27fec,0x209fff0d,0x22006fff,
0xd1006fff,0x3200bfff,0x000cffff,0x7fffd400,0x3f6601ef,0xffffffff,
0x7ffdc0ef,0xfffd0004,0x01bffe23,0xffffc800,0x3ffe000e,0x9fff3006,
0x0bffee00,0xfa86fff8,0xffa803ff,0x517ffc2f,0x7fcc1fff,0x0dfff01f,
0x037ffc40,0x00efffe8,0xffffff90,0x4400003b,0x22001ab9,0xfffffeca,
0x3fea2fff,0xfff0004f,0x1bffe21f,0x7ffcc000,0x3e004fff,0xff3006ff,
0x3fee009f,0x3fff202f,0x007ffec1,0x3e64fff8,0x3ffe20ff,0xf81fff22,
0x3e2006ff,0xffd806ff,0x75c000ff,0xbeffffff,0x00000000,0x3fff6e20,
0x3ffe66ff,0xfff88005,0x01bffe27,0x3fffa200,0xf002ffff,0x3e600dff,
0xff7004ff,0x7ffcc05f,0x017ffe24,0x3ee7ffd8,0x25ffe86f,0x3fe05ffe,
0x3fe2006f,0x7ffe406f,0x3660001f,0xcfffffff,0x33330001,0x32200001,
0xff10ffff,0xff3000df,0x37ffc4ff,0x7ffec000,0x00ffffad,0x3006fff8,
0x2e009fff,0x7f402fff,0x0bffee7f,0xd1fffa80,0xfff909ff,0xf80bffe6,
0x3e2006ff,0x3fee06ff,0x100002ff,0xfffffff9,0x7fdc005d,0x353102ff,
0x3fffe200,0x003fffe3,0x44bfff70,0x40006fff,0xfb0ffffa,0xfff00bff,
0x3ffe600d,0x5fff7004,0xd1fffb80,0xf8800fff,0x2fff8bff,0xfb9fffa8,
0x3ffe00ff,0x3ffe2006,0x9ffff506,0x3ae00000,0xcfffffff,0x3fffe200,
0x09fff704,0xb1fffdc0,0xe8009fff,0x3fe22fff,0x3e20006f,0x3fe22fff,
0x7ffc03ff,0x9fff3006,0x0bffee00,0xf19fff10,0xfd0009ff,0x01fff3bf,
0xffb7fff1,0x06fff80b,0x21bffe20,0x005ffff9,0xffd98000,0x82dfffff,
0x2205fffb,0x3a006fff,0x3fe61fff,0xff7000ff,0x7ffc41ff,0x3ff60006,
0xffffa85f,0x01bffe00,0x8027ffcc,0xd802fffb,0x1fffbeff,0xcfffb800,
0x3ffa06ff,0x7c03fffe,0x3e2006ff,0x7ffc46ff,0x0000005f,0x7ffffe44,
0x77ffc4ff,0x27fff400,0x43fffd40,0x400efffc,0x444ffffa,0x70006fff,
0x3601ffff,0x3fe06fff,0xfff3006f,0x3ffee009,0xffffa802,0xf30006ff,
0x409fffff,0x0ffffffc,0x0037ffc0,0x744dfff1,0x0000efff,0x3faa0000,
0x3fea4fff,0xfffa801f,0xffd501df,0xffff109f,0xffc8815f,0xfff886ff,
0xfff98006,0x3ffe202f,0x0dfff03f,0x013ffe60,0x8017ffdc,0x03ffffff,
0x3ffffa00,0x3ffea02f,0xfff806ff,0x3ffe2006,0x2bffff66,0xaaaaaa99,
0x00aaaaaa,0x3ff66000,0x800fffa4,0xeffffffc,0x5fffffee,0x3ffffea0,
0xfffffeef,0xfff880ef,0xfffe8006,0xffffb805,0x006fff81,0x2009fff3,
0x9002fffb,0x001fffff,0x7ffffe40,0x7ffffc00,0x06fff803,0x45bffe20,
0xffffffff,0xffffffff,0x0002ffff,0x0004c880,0xffffff90,0x07ffffff,
0xfffffb10,0x1bffffff,0x01bffe20,0x01ffff90,0x21bfff60,0xf3006fff,
0x3ee009ff,0xff3002ff,0x98000bff,0xd806ffff,0xf800ffff,0x3e2006ff,
0xffff16ff,0xffffffff,0xffffffff,0x00000005,0x3ff22000,0x2defffff,
0x7fff5c00,0x401dffff,0x2006fff8,0x003ffff9,0xf13fffe2,0x3e600dff,
0xff7004ff,0x7ff4005f,0xff80002f,0xffb803ff,0xdfff006f,0xb7ffc400,
0xfffffff8,0xffffffff,0x002fffff,0x00000000,0x009baa98,0x35753000,
0x00000001,0x00000000,0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x30000000,0x88000003,0x00140001,0x0002aaa8,
0x2e099910,0x039972cc,0x08009991,0x90000800,0x00003999,0x00019991,
0x8006aaa6,0x00aacba8,0x026aa660,0x0abb9880,0x00555540,0x00016fe4,
0x000ff440,0xd8004fb8,0xb00007ff,0xfff509ff,0x203ffea1,0xd9003ffe,
0x02f44001,0x01ffffc0,0x1fffe400,0x3fffee00,0x36603eff,0xcfffffff,
0x3fffaa00,0x5c00cfff,0x0dffffff,0x007ffff0,0x017dfff9,0x3fffa000,
0xdfffd911,0x13ffee17,0x00fffb00,0x81fff700,0x7ec3fff8,0x1fff985f,
0x0077fe40,0x002fff44,0x000ffffe,0x0fffff10,0x7ffffe40,0xf983ffff,
0xffffffff,0xffff706f,0x01ffffff,0x3ffffff6,0xfff81eff,0xfffc803f,
0x0001cfff,0x37ffffa2,0xffffffff,0x04ffffdf,0x003ffec0,0x20bffe60,
0xff986ffd,0x06ffd82f,0x03bfffe6,0x1ffffe88,0x0ffffe00,0xffff7000,
0xfff3005f,0xfffd5137,0x0beffe81,0x985fff93,0xda9bdfff,0xffb85fff,
0xfffcabdf,0x03ffff86,0xfffffd98,0x10002eff,0xfffffffd,0xffffffff,
0xfb0009ff,0xfe8000ff,0x2fffa86f,0x881fff90,0x3e604fff,0xe880efff,
0x4002ffff,0x0002eeed,0x37fffff4,0x4c2ffe40,0x3fe61fff,0x89ff901f,
0xffd06ffc,0x83fff88f,0x7fc2fff9,0x2e2003ff,0xffffffff,0x7ec4000c,
0xdbceffff,0x04fffffe,0x00fffb00,0x20fffe40,0x2205fff8,0xffc85fff,
0x3ffe601f,0x3ffa20ef,0x000002ff,0x5fffd400,0x01001fff,0x7103ffea,
0x22ffdc07,0xff701caa,0x206ffb8d,0x5fd06ffc,0x3ff6a000,0x01dfffff,
0x0bffff20,0x00ffffe4,0x007ffd80,0xb0bfff30,0xfb803fff,0x7ffc43ff,
0x3ffe600f,0xfffe88ef,0x0000002f,0xfd6ffd80,0x2a2000bf,0x22004ffe,
0x006ffdb9,0x7ec3ffd8,0x1ffe203f,0x00003fe2,0xffffff91,0xff8807df,
0x7fd400ff,0xffb0005f,0xffd1000f,0x4fffb81f,0x83fffd00,0x5405fffa,
0xffeeffff,0x999102ff,0x99999999,0x99999999,0x3ffe6079,0x001fff72,
0x03ffffb8,0x7fffee54,0x54006fff,0x7ff40fff,0x207ffc02,0x400006fa,
0xffffffea,0xfffb80cf,0x1fffb002,0x0fffb000,0x89fffb00,0x000ffff8,
0xfd0dfff5,0xffa805ff,0x02ffffff,0x3fffffe6,0xffffffff,0x06ffffff,
0x7fc4fff9,0x7fec004f,0xffd501df,0xffffffff,0x7ffdc00d,0x401fff85,
0x3fa21fff,0x93000005,0x7fffffff,0x2007ffc8,0x64c2fffa,0xfccccccc,
0xcccccfff,0x3fea2ccc,0x7ffec0ff,0x7ffec003,0x07fffcc4,0x3ffffea0,
0x7ffcc02f,0xffffffff,0xffffffff,0x4fff886f,0x0007ffe4,0x19fffd97,
0x67ffffcc,0x06ffa8ab,0x05fffd88,0xff805ffd,0x01dfd10f,0xeb880000,
0x7ec4ffff,0x3fe2005f,0x7fffdc3f,0xffffffff,0xffffffff,0x513fffa4,
0x5000ffff,0xfe81ffff,0x7f4404ff,0x4c00ffff,0xffffffff,0xffffffff,
0xfb86ffff,0x7ffcc1ff,0xffd10003,0x8177fec7,0x74c06ffb,0x3f603fff,
0x1ffe202f,0x000000bb,0x27fffdc4,0x88017ffa,0x7fdc3fff,0xffffffff,
0xffffffff,0x3ffea4ff,0x1fffec0f,0x0ffff600,0x401ffff3,0xffffffe8,
0x0000000e,0xd06fff80,0x5c000dff,0x0fffa6ff,0x2a06ffd8,0x6401ffff,
0x3fee05ff,0x00000046,0xfffffd98,0x037fec4f,0xb85fff30,0xffffffff,
0xffffffff,0x7e44ffff,0x7ffc44ff,0xfff5000f,0x05fffd0b,0x7fffff44,
0x0000efff,0x3fea0000,0x5fff502f,0x900cba88,0x27ff4fff,0x706fffb8,
0x3001dfff,0xfd103fff,0x0000009f,0xfffffeb8,0x7fdc0bef,0xfff9001f,
0xfffb0003,0x3fffa000,0x027ffd40,0x540fffe8,0x3a204fff,0xff9affff,
0x50000eff,0xe8003555,0x7ffc07ff,0xf04fff86,0x7ffe4dff,0xffff950a,
0x0bfff70d,0x9bfffd80,0x007ffea8,0xff930000,0x05bfffff,0x4037ffc4,
0x0006fff9,0x2000fffb,0xfd85fff9,0x7fdc01ff,0x77ffc43f,0xffffd100,
0x77fffcc5,0xffff8000,0x3ffe6003,0x0fffe404,0x26b7fff2,0x223ffffc,
0xffffffff,0x7d47ffcf,0xcccccfff,0x7fc40ccc,0xffffffff,0x54000002,
0xfffffffd,0xfffb001c,0x3ffa601b,0xffb0002f,0x7fdc000f,0x2fffc41f,
0x90bfff10,0x3a203fff,0xf982ffff,0x4000efff,0x2003ffff,0x4401fffd,
0xffd85fff,0x4fffffff,0xffffffa8,0x745ffb1e,0xffffffff,0xd880ffff,
0x1effffff,0xf7100000,0x7dffffff,0xfffc8001,0xfda9abff,0x0002ffff,
0x8000fffb,0xffa86ffe,0x1fff902f,0x104fff88,0x405ffffd,0x00effffa,
0x00ffffe0,0x8037ffc4,0xfb80fffd,0x02efffff,0x260de654,0xffff31aa,
0xffffffff,0x6edd401f,0x3000002c,0xfffffffb,0x3f20005b,0xffffffff,
0xffffffff,0x7ffd8002,0x7ffc4000,0x986ffd82,0xffd82fff,0x3fffa206,
0xffffa802,0x3fffe000,0x5fff9003,0x13ffea00,0x0009a998,0x00000000,
0x70000000,0x9fffffff,0x7fe40003,0xffffffff,0xffffffff,0x7fec002f,
0xffb80007,0x43fff887,0xff985ffd,0x17f4401f,0x001ff500,0x00000000,
0x00000000,0x00000000,0xff900000,0x00017dff,0x73ffff88,0x5dffffff,
0x0017fff6,0x0000fffb,0x3ea0fff6,0x1dff50ff,0x2007ffd0,0x00980028,
0xc8000000,0x332600cc,0xcccccccc,0xcccccccc,0x999932cc,0x99999999,
0x99999999,0x00019805,0x80666660,0x0002dffc,0x441ffcc0,0xefd809a9,
0x3ffec000,0x2aa88000,0x2aa35550,0x02aa881a,0x00000000,0x3fe00000,
0x3ffee00f,0xffffffff,0xffffffff,0xfffff74f,0xffffffff,0x9fffffff,
0xfffffd70,0x87620039,0x703ffffb,0x40000039,0x06400039,0x02f76400,
0x00000000,0x00000000,0x80000000,0x7fdc07fe,0xffffffff,0xffffffff,
0xffff74ff,0xffffffff,0xffffffff,0x7ffff449,0x0befffff,0xfc83fd30,
0x000007ff,0x00000000,0x00000000,0x00000000,0x00000000,0xdfb01000,
0x7fffdc10,0xffffffff,0xffffffff,0xffffff74,0xffffffff,0x29ffffff,
0xfffffff8,0xdfffffff,0x1fffecab,0x003fffd8,0x00000000,0x00000000,
0x00000000,0x00000000,0xee800000,0x6d4df90b,0x3333310f,0x33333333,
0x9fff3333,0x26666662,0x99999999,0x10999999,0xffdfffff,0xffffffff,
0x03ffffff,0x000dffd1,0x00000000,0x00000000,0x00000000,0x00000000,
0xff880000,0xebdfdcff,0x00002fff,0x00027ffc,0x56ffc400,0x3fffae20,
0xffffffff,0x5fff300d,0x00000000,0x00000000,0x00000000,0x00000000,
0x40000000,0xfffffffa,0x04ffffff,0x27ffc000,0x7c400000,0xfffd9804,
0x803fffff,0x00005ffa,0x00000000,0x00000000,0x00000000,0x00000000,
0x6dd44000,0xacefffff,0xff800000,0x8000004f,0x65440028,0x0000acdd,
0x00000000,0x00000000,0x00000000,0x00000000,0x00000000,0x005fffc8,
0x4fff8000,0x00000000,0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0xc8000000,0x005ffdff,0x27ffc000,0x4c400000,0x4ccc4099,
0x99999950,0x00399999,0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x3ff6dff7,0x3e000005,0xdddd54ff,0xdddddddd,0xdddddddd,
0x70bfff27,0x3fee9fff,0xffffffff,0x0000003f,0x00000000,0x00000000,
0x00000000,0x00000000,0x7ffcc000,0x009fff12,0x53ffe000,0xfffffffb,
0xffffffff,0xf94fffff,0xfffb85ff,0xffffff74,0x007fffff,0x00000000,
0x00000000,0x00000000,0x00000000,0x80000000,0x7fdc5ffa,0xff000004,
0x3fffee9f,0xffffffff,0xffffffff,0xb85fff94,0xfff74fff,0xffffffff,
0x00000007,0x00000000,0x00000000,0x00000000,0x00000000,0xb01d3000,
0x74000005,0xdddd53ee,0xdddddddd,0xdddddddd,0x70bfff27,0x2aa69fff,
0xaaaaaaaa,0x0000001a,0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x04ccc400,0x00026662,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,
};
static signed short stb__arial_50_latin1_x[224]={ 0,3,2,0,1,2,1,1,2,2,1,2,3,1,
4,0,1,4,1,1,0,1,1,2,1,1,4,3,2,2,2,1,2,-1,3,2,3,3,3,2,3,4,1,3,
3,3,3,2,3,1,3,2,1,3,0,0,0,0,0,3,0,0,1,-1,1,1,2,1,1,1,0,1,2,2,
-3,2,2,2,2,1,2,1,2,1,0,2,0,0,0,0,0,1,4,1,1,5,5,5,5,5,5,5,5,5,
5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,0,5,2,0,1,-1,
4,1,1,0,1,2,2,1,0,-1,2,1,0,0,4,3,0,4,2,2,0,3,2,2,0,3,-1,-1,-1,-1,
-1,-1,0,2,3,3,3,3,1,3,-1,0,-1,3,2,2,2,2,2,3,1,3,3,3,3,0,3,3,1,1,
1,1,1,1,1,1,1,1,1,1,0,4,-1,0,1,2,1,1,1,1,1,1,2,2,2,2,2,0,2,0,
};
static signed short stb__arial_50_latin1_y[224]={ 40,7,7,7,5,7,7,7,7,7,7,13,35,26,
35,7,7,7,7,7,7,8,7,8,7,7,16,16,13,17,13,7,7,7,7,7,7,7,7,7,7,7,7,7,
7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,46,7,16,7,16,7,16,7,16,7,7,
7,7,7,16,16,16,16,16,16,16,8,16,16,16,16,16,16,7,7,7,20,12,12,12,12,12,12,12,12,12,
12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,40,16,7,7,13,7,
7,7,7,7,7,18,17,26,7,2,7,13,7,7,7,16,7,21,39,7,7,18,7,7,7,16,-1,-1,-1,0,
1,1,7,7,-1,-1,-1,1,-1,-1,-1,1,7,0,-1,-1,-1,0,1,14,6,-1,-1,-1,1,-1,7,7,7,7,
7,8,7,6,16,16,7,7,7,7,7,7,7,7,7,8,7,7,7,8,7,15,15,7,7,7,7,7,7,7,
};
static unsigned short stb__arial_50_latin1_w[224]={ 0,6,12,25,22,36,28,6,12,12,15,22,6,13,
5,13,22,13,22,22,23,23,22,21,22,22,5,6,22,22,22,22,42,31,25,29,27,25,23,31,26,5,18,27,
21,31,26,31,25,33,29,26,26,26,30,42,30,30,27,9,13,10,19,27,10,22,22,21,21,23,14,21,20,5,
10,21,5,33,20,23,22,21,14,20,13,20,22,32,23,22,22,13,4,13,24,23,23,23,23,23,23,23,23,23,
23,23,23,23,23,23,23,23,23,23,23,23,23,23,23,23,23,23,23,23,23,23,23,23,0,5,21,24,23,26,
4,22,13,34,15,20,22,13,34,27,13,22,15,15,9,20,25,5,10,9,16,19,35,35,37,22,31,31,31,31,
31,31,43,29,25,25,25,25,9,9,15,13,31,26,31,31,31,31,31,20,33,26,26,26,26,30,25,23,22,22,
22,22,22,22,37,21,23,23,23,23,9,9,15,13,23,20,23,23,23,23,23,22,23,20,20,20,20,22,22,22,
};
static unsigned short stb__arial_50_latin1_h[224]={ 0,33,13,34,40,35,34,13,43,43,15,22,12,5,
5,34,34,33,33,34,33,33,34,32,34,34,24,31,23,14,23,33,43,33,33,34,33,33,33,34,33,33,34,33,
33,33,33,34,33,36,33,34,33,34,33,33,33,33,33,42,34,42,18,3,7,25,34,25,34,25,33,34,33,33,
43,33,33,24,24,25,33,33,24,25,33,25,24,24,24,34,24,43,43,43,8,28,28,28,28,28,28,28,28,28,
28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,0,33,42,34,22,33,
43,43,6,34,17,21,14,5,34,4,13,27,17,18,7,33,42,6,11,17,17,21,35,35,35,34,41,41,41,40,
39,39,33,43,41,41,41,39,41,41,41,39,33,40,42,42,42,41,40,20,36,42,42,42,40,41,33,34,34,34,
34,33,34,35,25,33,34,34,34,34,33,33,33,33,34,32,34,34,34,33,34,19,27,34,34,34,34,43,42,43,
};
static unsigned short stb__arial_50_latin1_s[224]={ 255,39,243,47,11,202,168,244,24,60,156,
48,241,232,248,239,1,242,104,102,127,227,184,22,28,51,250,237,219,195,1,
83,131,72,224,49,1,230,29,195,106,248,153,201,81,113,155,125,198,1,53,
1,179,157,206,136,105,74,46,218,241,228,156,96,243,153,172,176,131,198,66,
109,23,249,188,1,229,85,175,22,155,133,46,1,25,222,119,142,61,79,196,
174,213,199,218,44,44,44,44,44,44,44,44,44,44,44,44,44,44,44,44,
44,44,44,44,44,44,44,44,44,44,44,44,44,44,44,44,44,255,249,28,
24,24,1,126,103,218,74,192,71,172,232,207,68,242,68,208,176,242,151,50,
249,243,244,224,92,105,69,164,73,33,91,123,120,192,224,28,73,155,65,212,
152,238,1,239,178,198,61,76,108,140,1,88,112,35,172,199,1,34,181,172,
25,49,197,24,178,1,141,115,44,207,120,144,231,103,145,182,235,159,1,114,
96,1,1,183,133,91,72,93,138,220,37,226,1, };
static unsigned short stb__arial_50_latin1_t[224]={ 1,451,485,244,130,172,244,469,1,1,563,
544,544,572,122,172,279,279,349,279,349,314,279,485,314,314,417,451,518,563,544,
383,1,349,417,279,383,349,383,314,383,88,314,383,417,417,417,279,417,172,383,
314,451,279,451,451,451,451,451,1,244,1,544,513,563,485,314,485,314,485,417,
314,417,383,1,417,383,518,518,518,383,383,518,518,451,485,518,518,518,279,518,
1,1,1,563,485,485,485,485,485,485,485,485,485,485,485,485,485,485,485,485,
485,485,485,485,485,485,485,485,485,485,485,485,485,485,485,485,485,1,45,45,
279,544,349,1,1,572,314,544,544,563,572,279,513,518,485,544,544,532,349,45,
79,499,451,544,544,172,172,172,244,88,88,88,130,130,130,349,1,88,88,88,
130,88,130,1,130,349,130,45,45,45,88,130,544,172,45,45,45,130,88,349,
209,209,244,244,383,244,172,485,417,209,244,244,209,417,417,417,383,209,485,209,
244,209,451,209,544,485,209,209,209,244,1,45,1, };
static unsigned short stb__arial_50_latin1_a[224]={ 199,199,254,398,398,637,478,137,
238,238,279,418,199,238,199,199,398,398,398,398,398,398,398,398,
398,398,199,199,418,418,418,398,727,478,478,517,517,478,437,557,
517,199,358,478,398,597,517,557,478,557,517,478,437,517,478,676,
478,478,437,199,199,199,336,398,238,398,398,358,398,398,199,398,
398,159,159,358,159,597,398,398,398,398,238,358,199,398,358,517,
358,358,358,239,186,239,418,537,537,537,537,537,537,537,537,537,
537,537,537,537,537,537,537,537,537,537,537,537,537,537,537,537,
537,537,537,537,537,537,537,537,199,238,398,398,398,398,186,398,
238,528,265,398,418,238,528,395,286,393,238,238,238,413,385,199,
238,238,262,398,597,597,597,437,478,478,478,478,478,478,716,517,
478,478,478,478,199,199,199,199,517,517,557,557,557,557,557,418,
557,517,517,517,517,478,478,437,398,398,398,398,398,398,637,358,
398,398,398,398,199,199,199,199,398,398,398,398,398,398,398,393,
437,398,398,398,398,358,398,358, };
// Call this function with
// font: NULL or array length
// data: NULL or specified size
// height: STB_FONT_arial_50_latin1_BITMAP_HEIGHT or STB_FONT_arial_50_latin1_BITMAP_HEIGHT_POW2
// return value: spacing between lines
static void stb_font_arial_50_latin1(stb_fontchar font[STB_FONT_arial_50_latin1_NUM_CHARS],
unsigned char data[STB_FONT_arial_50_latin1_BITMAP_HEIGHT][STB_FONT_arial_50_latin1_BITMAP_WIDTH],
int height)
{
int i,j;
if (data != 0) {
unsigned int *bits = stb__arial_50_latin1_pixels;
unsigned int bitpack = *bits++, numbits = 32;
for (i=0; i < STB_FONT_arial_50_latin1_BITMAP_WIDTH*height; ++i)
data[0][i] = 0; // zero entire bitmap
for (j=1; j < STB_FONT_arial_50_latin1_BITMAP_HEIGHT-1; ++j) {
for (i=1; i < STB_FONT_arial_50_latin1_BITMAP_WIDTH-1; ++i) {
unsigned int value;
if (numbits==0) bitpack = *bits++, numbits=32;
value = bitpack & 1;
bitpack >>= 1, --numbits;
if (value) {
if (numbits < 3) bitpack = *bits++, numbits = 32;
data[j][i] = (bitpack & 7) * 0x20 + 0x1f;
bitpack >>= 3, numbits -= 3;
} else {
data[j][i] = 0;
}
}
}
}
// build font description
if (font != 0) {
float recip_width = 1.0f / STB_FONT_arial_50_latin1_BITMAP_WIDTH;
float recip_height = 1.0f / height;
for (i=0; i < STB_FONT_arial_50_latin1_NUM_CHARS; ++i) {
// pad characters so they bilerp from empty space around each character
font[i].s0 = (stb__arial_50_latin1_s[i]) * recip_width;
font[i].t0 = (stb__arial_50_latin1_t[i]) * recip_height;
font[i].s1 = (stb__arial_50_latin1_s[i] + stb__arial_50_latin1_w[i]) * recip_width;
font[i].t1 = (stb__arial_50_latin1_t[i] + stb__arial_50_latin1_h[i]) * recip_height;
font[i].x0 = stb__arial_50_latin1_x[i];
font[i].y0 = stb__arial_50_latin1_y[i];
font[i].x1 = stb__arial_50_latin1_x[i] + stb__arial_50_latin1_w[i];
font[i].y1 = stb__arial_50_latin1_y[i] + stb__arial_50_latin1_h[i];
font[i].advance_int = (stb__arial_50_latin1_a[i]+8)>>4;
font[i].s0f = (stb__arial_50_latin1_s[i] - 0.5f) * recip_width;
font[i].t0f = (stb__arial_50_latin1_t[i] - 0.5f) * recip_height;
font[i].s1f = (stb__arial_50_latin1_s[i] + stb__arial_50_latin1_w[i] + 0.5f) * recip_width;
font[i].t1f = (stb__arial_50_latin1_t[i] + stb__arial_50_latin1_h[i] + 0.5f) * recip_height;
font[i].x0f = stb__arial_50_latin1_x[i] - 0.5f;
font[i].y0f = stb__arial_50_latin1_y[i] - 0.5f;
font[i].x1f = stb__arial_50_latin1_x[i] + stb__arial_50_latin1_w[i] + 0.5f;
font[i].y1f = stb__arial_50_latin1_y[i] + stb__arial_50_latin1_h[i] + 0.5f;
font[i].advance = stb__arial_50_latin1_a[i]/16.0f;
}
}
}
#ifndef STB_SOMEFONT_CREATE
#define STB_SOMEFONT_CREATE stb_font_arial_50_latin1
#define STB_SOMEFONT_BITMAP_WIDTH STB_FONT_arial_50_latin1_BITMAP_WIDTH
#define STB_SOMEFONT_BITMAP_HEIGHT STB_FONT_arial_50_latin1_BITMAP_HEIGHT
#define STB_SOMEFONT_BITMAP_HEIGHT_POW2 STB_FONT_arial_50_latin1_BITMAP_HEIGHT_POW2
#define STB_SOMEFONT_FIRST_CHAR STB_FONT_arial_50_latin1_FIRST_CHAR
#define STB_SOMEFONT_NUM_CHARS STB_FONT_arial_50_latin1_NUM_CHARS
#define STB_SOMEFONT_LINE_SPACING STB_FONT_arial_50_latin1_LINE_SPACING
#endif
| 69.768951
| 115
| 0.816283
|
stetre
|
69cf159f7d5b64cc24ca1479796d1679dc4f0c94
| 6,136
|
cpp
|
C++
|
Plugins/uPacketDivision/uPacketDivision/Assembler.cpp
|
hecomi/uPacketDivision
|
264a9dbe77a03f8534c2e087d7b33143478c6822
|
[
"MIT"
] | 4
|
2021-11-28T23:54:15.000Z
|
2022-02-20T10:50:28.000Z
|
Plugins/uPacketDivision/uPacketDivision/Assembler.cpp
|
hecomi/uPacketDivision
|
264a9dbe77a03f8534c2e087d7b33143478c6822
|
[
"MIT"
] | null | null | null |
Plugins/uPacketDivision/uPacketDivision/Assembler.cpp
|
hecomi/uPacketDivision
|
264a9dbe77a03f8534c2e087d7b33143478c6822
|
[
"MIT"
] | null | null | null |
#include <chrono>
#include <algorithm>
#include "Assembler.h"
#include "Log.h"
namespace uPacketDivision
{
void Frame::AddChunkData(const void *pData, uint32_t)
{
const auto &header = *reinterpret_cast<const PacketHeader*>(pData);
if (header.version != GetPacketHeaderVersion())
{
DebugLog("Packet version (%u) is wrong.", header.version);
return;
}
if (header.type != static_cast<uint32_t>(PacketType::Chunk))
{
DebugLog("Packet type (%u) is wrong.", header.type);
return;
}
if (!buf_)
{
Initialize(header);
}
if (header.chunkCount != chunkCount_ ||
header.timestamp != timestamp_ ||
header.totalSize != totalSize_ ||
header.chunkIndex > chunkCount_)
{
DebugLog("Detected a wrong packet (count: %u / %u, time: %u / %u, size: %u / %u, index: %u).",
header.chunkCount, chunkCount_,
header.timestamp, timestamp_,
header.totalSize, totalSize_,
header.chunkIndex);
return;
}
bool &flag = receivedChunkIndices_.at(header.chunkIndex);
if (flag)
{
DebugLog("Received a same chunkIndex data.");
return;
}
flag = true;
const auto offset = header.offsetSize;
if (offset + header.chunkSize > totalSize_)
{
DebugLog("Received data exceeds the buffer size.");
return;
}
auto *pDst = buf_.get() + offset;
const auto *pSrc = reinterpret_cast<const char*>(pData) + sizeof(PacketHeader);
memcpy(pDst, pSrc, header.chunkSize);
receivedSize_ += header.chunkSize;
}
bool Frame::IsCompleted() const
{
if (receivedChunkIndices_.empty()) return false;
for (const auto &pair : receivedChunkIndices_)
{
if (!pair.second) return false;
}
if (receivedSize_ != totalSize_)
{
DebugLog("Receive size is wrong.");
return false;
}
return true;
}
void Frame::Initialize(const PacketHeader &header)
{
totalSize_ = header.totalSize;
timestamp_ = header.timestamp;
chunkCount_ = header.chunkCount;
for (uint32_t i = 0; i < chunkCount_; ++i)
{
receivedChunkIndices_.emplace(i, false);
}
buf_ = std::make_unique<char[]>(totalSize_);
}
// ---
void Assembler::AddChunkData(const void* pData, uint32_t size)
{
constexpr uint32_t headerSize = sizeof(PacketHeader);
if (size < headerSize)
{
DebugLog("Received data size (%u) is smaller than header (%u).",
size, headerSize);
return;
}
const auto &header = *reinterpret_cast<const PacketHeader*>(pData);
if (header.version != GetPacketHeaderVersion())
{
DebugLog("Packet version is wrong.");
return;
}
if (header.chunkSize + headerSize != size)
{
DebugLog("Packet size is wrong (size: %u, chunk: %u, header: %u).",
size, header.chunkSize, headerSize);
return;
}
if (header.type != static_cast<uint32_t>(PacketType::Chunk))
{
DebugLog("Header type is not supported (%u).", header.type);
return;
}
const auto index = header.frameIndex;
if (index > latestFrameIndex_ || latestFrameIndex_ == -1)
{
latestFrameIndex_ = index;
latestTimestamp_ = header.timestamp;
}
if (oldestFrameIndex_ == -1)
{
oldestFrameIndex_ = index;
}
auto it = frames_.find(index);
if (it == frames_.end())
{
auto frame = std::make_unique<Frame>();
frame->AddChunkData(pData, size);
frames_.emplace(index, std::move(frame));
}
else
{
const auto &frame = it->second;
frame->AddChunkData(pData, size);
}
CheckAll();
}
void Assembler::CheckAll()
{
using namespace std::chrono;
eventType_ = EventType::None;
lossType_ = LossType::None;
if (frames_.empty()) return;
auto it = frames_.find(oldestFrameIndex_);
if (it == frames_.end())
{
DebugLog("packet loss.");
eventType_ = EventType::PacketLoss;
lossType_ = LossType::NotReceived;
if (latestFrameIndex_ > oldestFrameIndex_)
{
++oldestFrameIndex_;
}
return;
}
const auto &packet = it->second;
if (packet->IsCompleted())
{
assembledFrameIndices_.push_back(oldestFrameIndex_);
eventType_ = EventType::FrameCompleted;
++oldestFrameIndex_;
}
else
{
const auto dt = latestTimestamp_ - packet->GetTimestamp();
if (dt > timeout_)
{
DebugLog("packet timeout (> %u ms, %u / %u).",
timeout_, packet->GetReceivedSize(), packet->GetTotalSize());
eventType_ = EventType::PacketLoss;
lossType_ = LossType::Timeout;
frames_.erase(oldestFrameIndex_);
if (latestFrameIndex_ > oldestFrameIndex_)
{
++oldestFrameIndex_;
}
return;
}
}
}
uint64_t Assembler::GetAssembledFrameIndex() const
{
return !assembledFrameIndices_.empty() ?
*assembledFrameIndices_.begin() :
-1;
}
const char * Assembler::GetFrameData(uint64_t index) const
{
const auto it = frames_.find(index);
return (it != frames_.end()) ?
it->second->GetData() :
nullptr;
}
uint32_t Assembler::GetFrameSize(uint64_t index) const
{
const auto it = frames_.find(index);
return (it != frames_.end()) ?
it->second->GetTotalSize() :
0;
}
void Assembler::RemoveFrame(uint64_t index)
{
const auto it = frames_.find(index);
if (it != frames_.end())
{
frames_.erase(it);
}
auto &indices = assembledFrameIndices_;
indices.erase(
std::remove(indices.begin(), indices.end(), index),
indices.end());
}
}
| 23.330798
| 103
| 0.564211
|
hecomi
|
69d86305d9ebc709378d6fa463a2778b4555147f
| 671
|
hpp
|
C++
|
incs/Borders.hpp
|
paribro/hydrodynamic-simulator
|
63f16099a4b60bd6240d2c7a6950009637197382
|
[
"MIT"
] | 2
|
2020-08-12T11:41:04.000Z
|
2021-02-20T20:02:44.000Z
|
incs/Borders.hpp
|
prdbrg/hydrodynamic-simulator
|
63f16099a4b60bd6240d2c7a6950009637197382
|
[
"MIT"
] | null | null | null |
incs/Borders.hpp
|
prdbrg/hydrodynamic-simulator
|
63f16099a4b60bd6240d2c7a6950009637197382
|
[
"MIT"
] | null | null | null |
#ifndef BORDERS_CLASS_HPP
# define BORDERS_CLASS_HPP
# include <glm/glm.hpp>
# include <Define.hpp>
# include <AModule.hpp>
class Borders: public AModule
{
public:
Borders(Model & model);
~Borders(void);
private:
Borders(void);
Borders(Borders const & model);
Borders & operator=(Borders const & rhs);
void assignVertices(GLfloat x, int y, GLfloat z);
void assignNormals(GLfloat x, GLfloat y, GLfloat z);
void createVertices(void);
void createColors(void);
void createElements(void);
void createNormals(void);
GLfloat _bordersTop;
GLfloat * _terrainVertices;
GLfloat _thickness;
};
#endif /* ! BORDERS_CLASS_HPP */
| 20.96875
| 56
| 0.700447
|
paribro
|
69d8aab470b3a352c977d76a1eaee5315661a965
| 2,141
|
cpp
|
C++
|
Code/Client/ClientUI/Source/ZlibUtil.cpp
|
MarvinGeng/TinyIM
|
01c1c2e257e85caf8afa5ac5ecc4d5295fb0d710
|
[
"MIT"
] | null | null | null |
Code/Client/ClientUI/Source/ZlibUtil.cpp
|
MarvinGeng/TinyIM
|
01c1c2e257e85caf8afa5ac5ecc4d5295fb0d710
|
[
"MIT"
] | null | null | null |
Code/Client/ClientUI/Source/ZlibUtil.cpp
|
MarvinGeng/TinyIM
|
01c1c2e257e85caf8afa5ac5ecc4d5295fb0d710
|
[
"MIT"
] | 1
|
2022-01-15T03:18:26.000Z
|
2022-01-15T03:18:26.000Z
|
/*
* 压缩工具类，ZlibUtil.cpp
* zhangyl 2018.03.09
*/
#include "stdafx.h"
#include "../zlib1.2.11/zlib.h"
#include <string.h>
#include "ZlibUtil.h"
//最大支持压缩10M
#define MAX_COMPRESS_BUF_SIZE 10*1024*1024
bool ZlibUtil::CompressBuf(const char* pSrcBuf, size_t nSrcBufLength, char* pDestBuf, size_t& nDestBufLength)
{
if (pSrcBuf == NULL || nSrcBufLength == 0 || nSrcBufLength > MAX_COMPRESS_BUF_SIZE || pDestBuf == NULL)
return false;
//计算缓冲区大小，并为其分配内存
//压缩后的长度是不会超过nDestBufLength的
nDestBufLength = compressBound(nSrcBufLength);
//压缩
int ret = compress((Bytef*)pDestBuf, (uLongf*)&nDestBufLength, (const Bytef*)pSrcBuf, nSrcBufLength);
if (ret != Z_OK)
return false;
return true;
}
bool ZlibUtil::CompressBuf(const std::string& strSrcBuf, std::string& strDestBuf)
{
if (strSrcBuf.empty())
return false;
int nSrcLength = strSrcBuf.length();
if (nSrcLength > MAX_COMPRESS_BUF_SIZE)
return false;
int nDestBufLength = compressBound(nSrcLength);
if (nDestBufLength <= 0)
return false;
char* pDestBuf = new char[nDestBufLength];
memset(pDestBuf, 0, nDestBufLength * sizeof(char));
//压缩
int ret = compress((Bytef*)pDestBuf, (uLongf*)&nDestBufLength, (const Bytef*)strSrcBuf.c_str(), nSrcLength);
if (ret != Z_OK)
{
delete[] pDestBuf;
return false;
}
strDestBuf.append(pDestBuf, nDestBufLength);
delete[] pDestBuf;
return true;
}
bool ZlibUtil::UncompressBuf(const std::string& strSrcBuf, std::string& strDestBuf, size_t nDestBufLength)
{
char* pDestBuf = new char[nDestBufLength];
memset(pDestBuf, 0, nDestBufLength * sizeof(char));
int nPrevDestBufLength = nDestBufLength;
//解压缩
int ret = uncompress((Bytef*)pDestBuf, (uLongf*)&nDestBufLength, (const Bytef*)strSrcBuf.c_str(), strSrcBuf.length());
if (ret != Z_OK)
{
delete[] pDestBuf;
return false;
}
if (nPrevDestBufLength == nDestBufLength)
{
int k = 0;
k++;
}
strDestBuf.append(pDestBuf, nDestBufLength);
delete[] pDestBuf;
return true;
}
| 25.795181
| 122
| 0.657637
|
MarvinGeng
|
69d8c36761d3a233b51e22bbde23d7dd80b3438d
| 1,690
|
cc
|
C++
|
benchmarks/svf/svf.cc
|
wolvre/maple
|
c856c70e224a1354f40bbc16b43ff31b96141f75
|
[
"Apache-2.0"
] | 5
|
2015-07-20T09:42:22.000Z
|
2021-08-30T06:24:17.000Z
|
benchmarks/svf/svf.cc
|
wolvre/maple
|
c856c70e224a1354f40bbc16b43ff31b96141f75
|
[
"Apache-2.0"
] | null | null | null |
benchmarks/svf/svf.cc
|
wolvre/maple
|
c856c70e224a1354f40bbc16b43ff31b96141f75
|
[
"Apache-2.0"
] | 2
|
2017-05-23T11:57:07.000Z
|
2017-06-30T11:30:44.000Z
|
#include <pthread.h>
#include <iostream>
#include <stdlib.h>
#include <assert.h>
#include "sync01.h"
#include "sync02.h"
#include "stateful001.h"
#include "stateful002.h"
int inputX = 0;
int inputY = 0;
int data1 = -1, data2 = -1, data3 = -1, data4 = -1;
pthread_mutex_t m;
void add1()
{
data1++;
sync01();
}
void add2()
{
data2++;
sync02();
}
void add3()
{
data3++;
stateful001();
}
void add4()
{
data4++;
stateful002();
}
void lock()
{
pthread_mutex_lock(&m);
}
void unlock()
{
pthread_mutex_unlock(&m);
}
void *thread1(void *arg){
lock();
data1++;
data2++;
data3++;
data4++;
unlock();
}
void *thread2(void *arg){
if(inputX > 0 && inputY > 0)
{
add1();
lock();
add3();
unlock();
}
else if(inputX > 0 && inputY <= 0)
{
lock();
add1();
unlock();
lock();
add4();
unlock();
}
else if(inputX <= 0 && inputY > 0)
{
lock();
add2();
unlock();
lock();
add3();
unlock();
}
else
{
lock();
add2();
unlock();
lock();
add4();
unlock();
}
}
int main(int argc, char ** argv) {
inputX = atoi(argv[1]);
inputY = atoi(argv[2]);
pthread_t t1,t2;
pthread_create(&t1, 0, thread1, 0);
pthread_create(&t2, 0, thread2, 0);
pthread_join(t1, 0);
pthread_join(t2, 0);
int sum = data1+data2+data3+data4;
if(sum != 2){
std::cout << "sum = " << sum << std::endl;
}
assert(sum==2);
return 0;
}
| 14.322034
| 51
| 0.457396
|
wolvre
|
69d9f8142a17782cacd9ada58f37b6100053badf
| 1,730
|
hh
|
C++
|
src/interface/MiniMap.hh
|
zermingore/warevolved
|
efd0c506658ce6e4ecb6c7eb5bb7d620bc05fd52
|
[
"MIT"
] | 1
|
2019-09-23T18:16:27.000Z
|
2019-09-23T18:16:27.000Z
|
src/interface/MiniMap.hh
|
zermingore/warevolved
|
efd0c506658ce6e4ecb6c7eb5bb7d620bc05fd52
|
[
"MIT"
] | 2
|
2018-11-12T18:48:03.000Z
|
2018-11-15T21:10:02.000Z
|
src/interface/MiniMap.hh
|
zermingore/warevolved
|
efd0c506658ce6e4ecb6c7eb5bb7d620bc05fd52
|
[
"MIT"
] | null | null | null |
/**
* \file
* \date August 22, 2017
* \author Zermingore
* \namespace interface
* \brief Side panel's MiniMap class declaration
*/
#ifndef INTERFACE_MINIMAP_HH_
# define INTERFACE_MINIMAP_HH_
# include <memory>
# include <vector>
# include <utility>
# include <graphics/graphic_types.hh>
# include <interface/InterfaceElement.hh>
# include <common/using.hh>
class Map;
namespace interface {
class Cursor;
/**
* \class MiniMap
* \brief In charge of the build / display of the minimap in the side panel
*/
class MiniMap final: public InterfaceElement
{
public:
/**
* \brief Constructor: needs the Map and Cursor to check what is hovered
* \param size Minimap's frame size
* \param map Game's map
* \param cursor Cursor of the player (needed to put a mark on the minimap)
*/
MiniMap(const graphics::Size2& size,
const std::shared_ptr<const Map>& map,
const std::shared_ptr<const Cursor>& cursor);
/**
* \brief Update the minimap content
* \todo Don't rebuild the minimap if the map / cursor position didn't change
*/
void update() override final;
/**
* \brief Draw the minimap in the side panel
*/
void draw() override final;
/**
* \brief Set the MiniMap position
* \param pos New position
*/
void setPosition(const graphics::Pos2& pos);
/**
* \brief Set the MiniMap frame size
* \param size New size
*/
void setFrameSize(const graphics::Size2& size);
private:
graphics::Size2 _frameSize; ///< Draw area size
const Map& _map; ///< Pointer on the game's map
/// The cursor's position is displayed on the minimap
const Cursor& _playerCursor;
};
} // namespace interface
#endif /* !INTERFACE_MINIMAP_HH_ */
| 20.116279
| 79
| 0.678613
|
zermingore
|
69db2db1e436f63c84fa746623f66d4ebd6aa610
| 3,004
|
cpp
|
C++
|
engine/src/app/Window.cpp
|
Dino97/Kinemo
|
4aeee2c960961f2e5d453734b9fb1a8e7c717cdf
|
[
"MIT"
] | 2
|
2019-10-14T02:19:55.000Z
|
2019-10-15T01:24:53.000Z
|
engine/src/app/Window.cpp
|
Dino97/Kinemo
|
4aeee2c960961f2e5d453734b9fb1a8e7c717cdf
|
[
"MIT"
] | null | null | null |
engine/src/app/Window.cpp
|
Dino97/Kinemo
|
4aeee2c960961f2e5d453734b9fb1a8e7c717cdf
|
[
"MIT"
] | null | null | null |
#include "Window.h"
#include "glad/glad.h"
#include "GLFW/glfw3.h"
#include <iostream>
namespace Kinemo
{
void OpenGLDebugCallback(GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar* message, const void* userParam);
Window::Window(const WindowProperties& properties)
{
glfwInit();
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
GLFWmonitor* monitor = properties.Mode == WindowMode::Windowed ? nullptr : glfwGetPrimaryMonitor();
m_Window = glfwCreateWindow(properties.Width, properties.Height, properties.Title.c_str(), monitor, nullptr);
glfwMakeContextCurrent(m_Window);
if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress))
{
}
glfwSetWindowUserPointer(m_Window, &m_Data);
glfwSetKeyCallback(m_Window, [](GLFWwindow* window, int key, int scancode, int action, int mods) {
WindowData& data = *(WindowData*)glfwGetWindowUserPointer(window);
switch(action)
{
case GLFW_PRESS:
{
Events::KeyPressedEvent event(key, 0);
data.EventCallback(event);
break;
}
case GLFW_RELEASE:
{
Events::KeyReleasedEvent event(key);
data.EventCallback(event);
break;
}
case GLFW_REPEAT:
{
Events::KeyPressedEvent event(key, 1);
data.EventCallback(event);
break;
}
}
});
glfwSetMouseButtonCallback(m_Window, [](GLFWwindow* window, int button, int action, int mods) {
WindowData& data = *(WindowData*)glfwGetWindowUserPointer(window);
switch (action)
{
case GLFW_PRESS:
{
Events::MouseButtonPressedEvent event(button);
data.EventCallback(event);
break;
}
case GLFW_RELEASE:
{
Events::MouseButtonReleasedEvent event(button);
data.EventCallback(event);
break;
}
}
});
glEnable(GL_DEPTH_TEST);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glEnable(GL_DEBUG_OUTPUT);
glDebugMessageCallbackARB(OpenGLDebugCallback, nullptr);
}
void OpenGLDebugCallback(GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar* message, const void* userParam)
{
std::cerr << "[OpenGL Debug]: " << message << std::endl;
}
Window::~Window()
{
glfwDestroyWindow(m_Window);
}
void Window::Clear() const
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glClearColor(0.1f, 0.1f, 0.1f, 1.0f); // dark gray
}
void Window::Update() const
{
glfwPollEvents();
glfwSwapBuffers(m_Window);
}
void Window::SetEventCallback(const EventCallbackFn& callback)
{
m_Data.EventCallback = callback;
}
void Window::SetVSync(bool vsync)
{
glfwSwapInterval(vsync ? 1 : 0);
}
bool Window::IsClosing() const
{
return glfwWindowShouldClose(m_Window);
}
void Window::SetTitle(const std::string& title)
{
m_WindowProperties.Title = title;
glfwSetWindowTitle(m_Window, title.c_str());
}
}
| 23.84127
| 151
| 0.704394
|
Dino97
|
69dcb8ac6bb044141d4a7ebe874e5ff1b71122c7
| 3,070
|
cpp
|
C++
|
push-3.1.0/test/test_name.cpp
|
emilydolson/eco-ea-mancala
|
f9c42611547205c97524830ea3ad33e675aaadbd
|
[
"MIT"
] | null | null | null |
push-3.1.0/test/test_name.cpp
|
emilydolson/eco-ea-mancala
|
f9c42611547205c97524830ea3ad33e675aaadbd
|
[
"MIT"
] | null | null | null |
push-3.1.0/test/test_name.cpp
|
emilydolson/eco-ea-mancala
|
f9c42611547205c97524830ea3ad33e675aaadbd
|
[
"MIT"
] | null | null | null |
/***************************************************************************
* Copyright (C) 2004 by Maarten Keijzer *
* mkeijzer@xs4all.nl *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
* This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/
#include <iostream>
#include <string>
#include "StaticInit.h"
#include "Literal.h"
#include "CodeUtils.h"
#include "Word.h"
using namespace std;
using namespace push;
int main()
{
Code code = parse("(fib : fib)");
{
Env env;
push_call(env, code);
env.go(100);
}
if (dict_size() != 1) return 1;
collect_garbage();
if (dict_size() != 1) return 1;
code = nil;
collect_garbage();
if (dict_size() != 0) return 1;
code = parse("(foo : bar bar : (foo bar) )");
{
Env env;
push_call(env, code);
env.go(100);
cout << env << endl;
}
if (dict_size() != 2) return 1;
collect_garbage();
if (dict_size() != 2) return 1;
cout << "before destroy " << dict_size() << endl;
code = nil;
collect_garbage();
if (dict_size() != 0) return 1;
code = parse("(foo : bar bar : baz baz : (foo baz) )");
{
Env env;
push_call(env, code);
env.go(100);
}
Code baz = parse("baz");
cout << "Baz is bound to " << get_code(static_cast<Literal<name_t>*>(baz.get())->get()) << endl;
collect_garbage();
if (dict_size() != 3) return 1;
code = nil;
collect_garbage();
if (dict_size() != 1) return 1;
baz = nil;
collect_garbage();
if (dict_size() != 0) return 1;
code = parse("(foo : (baz baz))");
collect_garbage();
if (dict_size() != 2) {
cout << "Err: dict size = " << endl;
return 1;
}
code = nil;
collect_garbage();
if (dict_size() != 0) return 1;
return 0;
}
| 26.016949
| 100
| 0.461889
|
emilydolson
|
69e19dddbc67b1ad175a8e49a731c6b4c6bf12d0
| 6,839
|
hpp
|
C++
|
posu/units/system/si/electric_current.hpp
|
zhu48/posu
|
4872bd7572485c1c352aaf5db7a99d578a682113
|
[
"MIT"
] | null | null | null |
posu/units/system/si/electric_current.hpp
|
zhu48/posu
|
4872bd7572485c1c352aaf5db7a99d578a682113
|
[
"MIT"
] | 33
|
2020-12-14T02:50:22.000Z
|
2022-03-08T03:20:15.000Z
|
posu/units/system/si/electric_current.hpp
|
zhu48/posu
|
4872bd7572485c1c352aaf5db7a99d578a682113
|
[
"MIT"
] | null | null | null |
#ifndef POSU_UNITS_SI_ELECTRIC_CURRENT_HPP
#define POSU_UNITS_SI_ELECTRIC_CURRENT_HPP
#include "posu/units/base_unit.hpp"
#include "posu/units/system/electric_current.hpp"
namespace posu::units::si {
struct electric_current : public posu::units::electric_current {
using type = electric_current;
using kind_type = posu::units::electric_current;
using period = std::ratio<1>;
};
} // namespace posu::units::si
namespace posu::units {
template<>
inline constexpr bool enable_as_unit<si::electric_current> = true;
}
namespace posu::units::si {
template<typename Rep, typename Period>
using basic_ampere = quantity<Rep, Period, electric_current>;
using attoamperes = basic_ampere<int, std::atto>;
using femtoamperes = basic_ampere<int, std::femto>;
using picoamperes = basic_ampere<int, std::pico>;
using nanoamperes = basic_ampere<int, std::nano>;
using microamperes = basic_ampere<int, std::micro>;
using milliamperes = basic_ampere<int, std::milli>;
using centiamperes = basic_ampere<int, std::centi>;
using deciamperes = basic_ampere<int, std::deci>;
using amperes = basic_ampere<int, std::ratio<1>>;
using decaamperes = basic_ampere<int, std::deca>;
using hectoamperes = basic_ampere<int, std::hecto>;
using kiloamperes = basic_ampere<int, std::kilo>;
using megaamperes = basic_ampere<int, std::mega>;
using gigaamperes = basic_ampere<int, std::giga>;
using teraamperes = basic_ampere<int, std::tera>;
using petaamperes = basic_ampere<int, std::peta>;
using exaamperes = basic_ampere<int, std::exa>;
inline namespace literals {
inline namespace electric_current_literals {
[[nodiscard]] constexpr auto operator""_aA(unsigned long long value) -> attoamperes;
[[nodiscard]] constexpr auto operator""_aA(long double value)
-> basic_ampere<double, std::atto>;
[[nodiscard]] constexpr auto operator""_fA(unsigned long long value) -> femtoamperes;
[[nodiscard]] constexpr auto operator""_fA(long double value)
-> basic_ampere<double, std::femto>;
[[nodiscard]] constexpr auto operator""_pA(unsigned long long value) -> picoamperes;
[[nodiscard]] constexpr auto operator""_pA(long double value)
-> basic_ampere<double, std::pico>;
[[nodiscard]] constexpr auto operator""_nA(unsigned long long value) -> nanoamperes;
[[nodiscard]] constexpr auto operator""_nA(long double value)
-> basic_ampere<double, std::nano>;
[[nodiscard]] constexpr auto operator""_uA(unsigned long long value) -> microamperes;
[[nodiscard]] constexpr auto operator""_uA(long double value)
-> basic_ampere<double, std::micro>;
[[nodiscard]] constexpr auto operator""_mA(unsigned long long value) -> milliamperes;
[[nodiscard]] constexpr auto operator""_mA(long double value)
-> basic_ampere<double, std::milli>;
[[nodiscard]] constexpr auto operator""_cA(unsigned long long value) -> centiamperes;
[[nodiscard]] constexpr auto operator""_cA(long double value)
-> basic_ampere<double, std::centi>;
[[nodiscard]] constexpr auto operator""_dA(unsigned long long value) -> deciamperes;
[[nodiscard]] constexpr auto operator""_dA(long double value)
-> basic_ampere<double, std::deci>;
[[nodiscard]] constexpr auto operator""_A(unsigned long long value) -> amperes;
[[nodiscard]] constexpr auto operator""_A(long double value)
-> basic_ampere<double, std::ratio<1>>;
[[nodiscard]] constexpr auto operator""_daA(unsigned long long value) -> decaamperes;
[[nodiscard]] constexpr auto operator""_daA(long double value)
-> basic_ampere<double, std::deca>;
[[nodiscard]] constexpr auto operator""_hA(unsigned long long value) -> hectoamperes;
[[nodiscard]] constexpr auto operator""_hA(long double value)
-> basic_ampere<double, std::hecto>;
[[nodiscard]] constexpr auto operator""_kA(unsigned long long value) -> kiloamperes;
[[nodiscard]] constexpr auto operator""_kA(long double value)
-> basic_ampere<double, std::kilo>;
[[nodiscard]] constexpr auto operator""_MA(unsigned long long value) -> megaamperes;
[[nodiscard]] constexpr auto operator""_MA(long double value)
-> basic_ampere<double, std::mega>;
[[nodiscard]] constexpr auto operator""_GA(unsigned long long value) -> gigaamperes;
[[nodiscard]] constexpr auto operator""_GA(long double value)
-> basic_ampere<double, std::giga>;
[[nodiscard]] constexpr auto operator""_TA(unsigned long long value) -> teraamperes;
[[nodiscard]] constexpr auto operator""_TA(long double value)
-> basic_ampere<double, std::tera>;
[[nodiscard]] constexpr auto operator""_PA(unsigned long long value) -> petaamperes;
[[nodiscard]] constexpr auto operator""_PA(long double value)
-> basic_ampere<double, std::peta>;
[[nodiscard]] constexpr auto operator""_EA(unsigned long long value) -> exaamperes;
[[nodiscard]] constexpr auto operator""_EA(long double value)
-> basic_ampere<double, std::exa>;
} // namespace electric_current_literals
} // namespace literals
using namespace literals::electric_current_literals;
} // namespace posu::units::si
#include "posu/units/system/si/ipp/electric_current.ipp"
namespace posu::units::si {
inline namespace references {
inline namespace electric_current_references {
inline constexpr auto aA = 1_aA;
inline constexpr auto fA = 1_fA;
inline constexpr auto pA = 1_pA;
inline constexpr auto nA = 1_nA;
inline constexpr auto uA = 1_uA;
inline constexpr auto mA = 1_mA;
inline constexpr auto cA = 1_cA;
inline constexpr auto dA = 1_dA;
inline constexpr auto A = 1_A;
inline constexpr auto daA = 1_daA;
inline constexpr auto hA = 1_hA;
inline constexpr auto kA = 1_kA;
inline constexpr auto MA = 1_MA;
inline constexpr auto GA = 1_GA;
inline constexpr auto TA = 1_TA;
inline constexpr auto PA = 1_PA;
inline constexpr auto EA = 1_EA;
} // namespace electric_current_references
} // namespace references
} // namespace posu::units::si
#endif // #ifndef POSU_UNITS_SI_ELECTRIC_CURRENT_HPP
| 47.165517
| 97
| 0.639421
|
zhu48
|
69e2b63845fe337ad0c8eb2d1646301809720d44
| 496
|
cpp
|
C++
|
source/code/scratch/old_repos/Jstd/Jstd/project/src/jstd-tool/jstd-tool/database_dumper.cpp
|
luxe/CodeLang-compiler
|
78837d90bdd09c4b5aabbf0586a5d8f8f0c1e76a
|
[
"MIT"
] | 33
|
2019-05-30T07:43:32.000Z
|
2021-12-30T13:12:32.000Z
|
source/code/scratch/old_repos/Jstd/Jstd/project/src/jstd-tool/jstd-tool/database_dumper.cpp
|
luxe/CodeLang-compiler
|
78837d90bdd09c4b5aabbf0586a5d8f8f0c1e76a
|
[
"MIT"
] | 371
|
2019-05-16T15:23:50.000Z
|
2021-09-04T15:45:27.000Z
|
source/code/scratch/old_repos/Jstd/Jstd/project/src/jstd-tool/jstd-tool/database_dumper.cpp
|
UniLang/compiler
|
c338ee92994600af801033a37dfb2f1a0c9ca897
|
[
"MIT"
] | 6
|
2019-08-22T17:37:36.000Z
|
2020-11-07T07:15:32.000Z
|
#include "database_dumper.hpp"
#include "utilities.hpp"
#include "global.hpp"
#include <cstdlib>
#include <fstream>
void Database_Dumper::Dump_Database_If_Needed(Program_Options const& program_options, std::time_t const& last_run_time) {
if (program_options.Database()){
Perform_Timed_Database_Dumping(program_options, last_run_time);
}
return;
}
void Database_Dumper::Perform_Timed_Database_Dumping(Program_Options const& program_options, std::time_t const& last_run_time){
return;
}
| 24.8
| 127
| 0.802419
|
luxe
|
69e2c03aba56f1945d3b65501dd6a53b7fa545cf
| 2,771
|
hpp
|
C++
|
modules/core/reduction/include/nt2/core/functions/scalar/inner_fold.hpp
|
pbrunet/nt2
|
2aeca0f6a315725b335efd5d9dc95d72e10a7fb7
|
[
"BSL-1.0"
] | 2
|
2016-09-14T00:23:53.000Z
|
2018-01-14T12:51:18.000Z
|
modules/core/reduction/include/nt2/core/functions/scalar/inner_fold.hpp
|
pbrunet/nt2
|
2aeca0f6a315725b335efd5d9dc95d72e10a7fb7
|
[
"BSL-1.0"
] | null | null | null |
modules/core/reduction/include/nt2/core/functions/scalar/inner_fold.hpp
|
pbrunet/nt2
|
2aeca0f6a315725b335efd5d9dc95d72e10a7fb7
|
[
"BSL-1.0"
] | null | null | null |
//==============================================================================
// Copyright 2003 - 2011 LASMEA UMR 6602 CNRS/Univ. Clermont II
// Copyright 2009 - 2011 LRI UMR 8623 CNRS/Univ Paris Sud XI
//
// Distributed under the Boost Software License, Version 1.0.
// See accompanying file LICENSE.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt
//==============================================================================
#ifndef NT2_CORE_FUNCTIONS_SCALAR_INNER_FOLD_HPP_INCLUDED
#define NT2_CORE_FUNCTIONS_SCALAR_INNER_FOLD_HPP_INCLUDED
#include <nt2/core/functions/inner_fold.hpp>
#include <boost/fusion/include/pop_front.hpp>
#include <nt2/include/functions/scalar/numel.hpp>
namespace nt2 { namespace details
{
template <class X, class N, class B, class U>
BOOST_FORCEINLINE typename X::value_type
inner_fold_step(X const& in, const std::size_t& p, N const& neutral, B const& bop, U const&)
{
typedef typename X::value_type value_type;
typedef typename X::extent_type extent_type;
extent_type ext = in.extent();
std::size_t ibound = boost::fusion::at_c<0>(ext);
value_type out = neutral(nt2::meta::as_<value_type>());
for(std::size_t i = 0; i < ibound; ++i)
{
out = bop(out, nt2::run(in, i+p, meta::as_<value_type>()));
}
return out;
}
} }
namespace nt2 { namespace ext
{
//============================================================================
// Generates inner_fold
//============================================================================
NT2_FUNCTOR_IMPLEMENTATION( nt2::tag::inner_fold_, tag::cpu_, (A0)(A1)(A2)(A3)(A4)
, ((ast_< A0, nt2::container::domain>))
((ast_< A1, nt2::container::domain>))
(unspecified_<A2>)
(unspecified_<A3>)
(unspecified_<A4>)
)
{
typedef void result_type;
typedef typename A0::value_type value_type;
typedef typename boost::remove_reference<A1>::type::extent_type extent_type;
BOOST_FORCEINLINE result_type operator()(A0& out, A1& in, A2 const& neutral, A3 const& bop, A4 const& uop) const
{
extent_type ext = in.extent();
std::size_t ibound = boost::fusion::at_c<0>(ext);
std::size_t obound = nt2::numel(boost::fusion::pop_front(ext));
for(std::size_t j = 0, k = 0; j < obound; ++j, k+=ibound)
{
nt2::run(out, j, details::inner_fold_step(in,k, neutral, bop, uop));
}
}
};
} }
#endif
| 37.445946
| 116
| 0.510646
|
pbrunet
|
69e7b9f35f2749d9ec18ec50f7ad54aa4218466f
| 421
|
cc
|
C++
|
confonnx/server/enclave/props.cc
|
kapilvgit/onnx-server-openenclave
|
974e747c9ba08d6a4fc5cc9943acc1b937a933df
|
[
"MIT"
] | null | null | null |
confonnx/server/enclave/props.cc
|
kapilvgit/onnx-server-openenclave
|
974e747c9ba08d6a4fc5cc9943acc1b937a933df
|
[
"MIT"
] | null | null | null |
confonnx/server/enclave/props.cc
|
kapilvgit/onnx-server-openenclave
|
974e747c9ba08d6a4fc5cc9943acc1b937a933df
|
[
"MIT"
] | null | null | null |
// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License.
#include <openenclave/enclave.h>
// Default parameters, can be overridden during signing.
OE_SET_ENCLAVE_SGX(
1, /* ProductID */
1, /* SecurityVersion */
true, /* AllowDebug */
609600 / 10, /* HeapPageCount */
131072 / 10, /* StackPageCount */
8); /* TCSCount */
| 30.071429
| 60
| 0.603325
|
kapilvgit
|
69edef0a4d42fd8bcf2bb492b6894147cd714fd4
| 2,676
|
cpp
|
C++
|
main.cpp
|
finn-harman/Enigma
|
db9438a7efd24b3d47ed6bf0dfaa8fbb13f7872a
|
[
"MIT"
] | null | null | null |
main.cpp
|
finn-harman/Enigma
|
db9438a7efd24b3d47ed6bf0dfaa8fbb13f7872a
|
[
"MIT"
] | null | null | null |
main.cpp
|
finn-harman/Enigma
|
db9438a7efd24b3d47ed6bf0dfaa8fbb13f7872a
|
[
"MIT"
] | null | null | null |
#include <iostream>
#include <fstream>
#include "errors.h"
#include "plugboard.h"
#include "rotor.h"
#include "reflector.h"
#include "enigma.h"
using namespace std;
int const alphabet_size = 26;
void organise_inputs(int argc, char** argv);
int main(int argc, char** argv)
{
int input, pb_output0, rf_output, rot_output0 = 0, rot_output1 = 0, pb_output1;
int input_number = argc;
int file_number = input_number - 1;
int rotor_number = file_number - 3;
if (test_INSUFFICIENT_NUMBER_OF_PARAMETERS(file_number) != 0) {
cerr << "Insufficient number of parameters. Usage: enigma plugboard-file reflector-file (<rotor_file>)* rotor_positions";
return 1;
}
char* plugboard_file = argv[1];
char* reflector_file = argv[2];
char* position_file = argv[input_number - 1];
char** rotor_files;
rotor_files = new char*[rotor_number];
for (int i = 0 ; i < rotor_number ; i++)
rotor_files[i] = argv[i+3];
Enigma enig(alphabet_size, rotor_number, plugboard_file, reflector_file, rotor_files, position_file);
enig.load();
enig.error_check();
if (enig.error_code != 0) {
cerr << enig.error_comment;
delete [] rotor_files;
return enig.error_code;
}
enig.map();
int MAX_LENGTH = 100;
char phrase[MAX_LENGTH];
char output[MAX_LENGTH];
cin.getline(phrase, MAX_LENGTH);
int array_length = 0;
int i = 0;
while(phrase[i] != '\0') {
array_length++;
i++;
}
int output_length = 0;
for (int i = 0 ; i < array_length ; i++) {
if (test_INVALID_INPUT_CHARACTER(phrase[i]) != 0) {
for (int j = 0 ; j < output_length ; j++)
if (output[j] != ' ')
cerr << output[j];
cerr << endl;
cerr << "Invalid input character. Input must be capital letter or white space";
return 2;
}
if ((phrase[i] == ' ') || (phrase[i] == '\n') || (phrase[i] == 9) || (phrase[i] == 13)) {
output[i] = ' ';
output_length++;
}
else {
input = phrase[i] - 'A';
int pb_input0 = input;
if (rotor_number > 0) {
enig.rotate_rotors();
enig.pass_plugboard(pb_input0, pb_output0);
enig.pass_rotors0(pb_output0, rot_output0);
enig.pass_reflector(rot_output0, rf_output);
enig.pass_rotors1(rf_output, rot_output1);
enig.pass_plugboard(rot_output1, pb_output1);
}
else {
enig.pass_plugboard(pb_input0, pb_output0);
enig.pass_reflector(pb_output0, rf_output);
enig.pass_plugboard(rf_output, pb_output1);
}
output[i] = pb_output1 + 'A';
output_length++;
}
}
for (int i = 0 ; i < output_length ; i++)
if (output[i] != ' ')
cout << output[i];
delete [] rotor_files;
return 0;
}
| 22.677966
| 125
| 0.631913
|
finn-harman
|
69eeca25028549bfb8a4c1f3122fdd82dded221b
| 709
|
cpp
|
C++
|
src/utils/common/physdll.cpp
|
cstom4994/SourceEngineRebuild
|
edfd7f8ce8af13e9d23586318350319a2e193c08
|
[
"MIT"
] | 6
|
2022-01-23T09:40:33.000Z
|
2022-03-20T20:53:25.000Z
|
src/utils/common/physdll.cpp
|
cstom4994/SourceEngineRebuild
|
edfd7f8ce8af13e9d23586318350319a2e193c08
|
[
"MIT"
] | null | null | null |
src/utils/common/physdll.cpp
|
cstom4994/SourceEngineRebuild
|
edfd7f8ce8af13e9d23586318350319a2e193c08
|
[
"MIT"
] | 1
|
2022-02-06T21:05:23.000Z
|
2022-02-06T21:05:23.000Z
|
//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
// $NoKeywords: $
//
//=============================================================================//
#include <stdio.h>
#include "physdll.h"
#include "filesystem_tools.h"
static CSysModule *pPhysicsModule = NULL;
CreateInterfaceFn GetPhysicsFactory(void) {
if (!pPhysicsModule) {
pPhysicsModule = g_pFullFileSystem->LoadModule("engine.dll");
if (!pPhysicsModule)
return NULL;
}
return Sys_GetFactory(pPhysicsModule);
}
void PhysicsDLLPath(const char *pPathname) {
if (!pPhysicsModule) {
pPhysicsModule = g_pFullFileSystem->LoadModule(pPathname);
}
}
| 24.448276
| 81
| 0.57969
|
cstom4994
|
69f3b7b6da6023a0b52386197d29b1e5bcd2c290
| 509
|
cpp
|
C++
|
WeeklyHomework/0310_Above_Average.cpp
|
Ping6666/Algorithm-Project
|
cdf0b56cd277badcdd964982f5c033fd4888274a
|
[
"MIT"
] | 1
|
2021-04-12T05:08:07.000Z
|
2021-04-12T05:08:07.000Z
|
WeeklyHomework/0310_Above_Average.cpp
|
Ping6666/Algorithm-Projects
|
cdf0b56cd277badcdd964982f5c033fd4888274a
|
[
"MIT"
] | null | null | null |
WeeklyHomework/0310_Above_Average.cpp
|
Ping6666/Algorithm-Projects
|
cdf0b56cd277badcdd964982f5c033fd4888274a
|
[
"MIT"
] | null | null | null |
#include <iostream>
#include <iomanip>
using namespace std;
int main()
{
int N,score[100][100],sum[100],ans[100];
cin>>N;
for(int i=0;i<N;i++)
{
cin>>score[i][0];
sum[i]=0;
ans[i]=0;
for(int j=0;j<score[i][0];j++)
{
cin>>score[i][j+1];
sum[i]+=score[i][j+1];
}
for(int j=0;j<score[i][0];j++)
{
if(score[i][j+1]*score[i][0]>sum[i])
{
ans[i]+=1;
}
}
ans[i]*=100;
cout<<fixed<<setprecision(3)<<float(ans[i])/score[i][0]<<"%"<<endl;
}
}
| 16.966667
| 70
| 0.485265
|
Ping6666
|
69f43de5ad9383ee1aba2396742ee1fc7628b0e5
| 2,067
|
cpp
|
C++
|
jogo/src/utils/classes/menu.cpp
|
Hyodar/jogo-tecprog
|
3a8cdf2cae583ad88a9377d0fbf796ba45d9d408
|
[
"MIT"
] | null | null | null |
jogo/src/utils/classes/menu.cpp
|
Hyodar/jogo-tecprog
|
3a8cdf2cae583ad88a9377d0fbf796ba45d9d408
|
[
"MIT"
] | null | null | null |
jogo/src/utils/classes/menu.cpp
|
Hyodar/jogo-tecprog
|
3a8cdf2cae583ad88a9377d0fbf796ba45d9d408
|
[
"MIT"
] | null | null | null |
// Libraries
// ---------------------------------------------------------------------------
// Class header
// ---------------------
#include "menu.hpp"
// Internal libraries
// ---------------------
#include "graphics_manager.hpp"
using namespace bardadv::core;
using namespace bardadv::menus;
// Methods
// ---------------------------------------------------------------------------
Menu::Menu() : Ent(0, 0) {
// noop
}
// ---------------------------------------------------------------------------
Menu::~Menu() {
// noop
}
// ---------------------------------------------------------------------------
void Menu::addButton(int left, int top, int width, int height, MenuCommand action) {
MenuItem button;
button.rect.left = left;
button.rect.top = top;
button.rect.width = width;
button.rect.height = height;
button.action = action;
menuItems.push_back(button);
}
// ---------------------------------------------------------------------------
void Menu::render(sf::RenderWindow& renderWindow) {
renderWindow.draw(sprite);
renderWindow.display();
}
// ---------------------------------------------------------------------------
MenuCommand Menu::handleClick(int x, int y) {
std::list<MenuItem>::iterator item;
for(item = menuItems.begin(); item != menuItems.end(); item++) {
sf::Rect<int> menuItemRect = item->rect;
if(menuItemRect.contains(x, y)){
return item->action;
}
}
return MenuCommand::NOOP;
}
// ---------------------------------------------------------------------------
MenuCommand Menu::getMenuResponse(sf::RenderWindow& renderWindow) {
sf::Event event;
while(true) {
while(renderWindow.pollEvent(event)) {
switch(event.type) {
case sf::Event::MouseButtonPressed:
return handleClick(event.mouseButton.x, event.mouseButton.y);
case sf::Event::Closed:
return MenuCommand::EXIT;
default:;
}
}
}
}
| 24.607143
| 84
| 0.426222
|
Hyodar
|
69f9c008f5133233c43e173c9ac827b31ad70ca4
| 4,489
|
cxx
|
C++
|
test/itkHDF5UltrasoundImageIOTest.cxx
|
tbirdso/ITKUltrasound
|
fb5915978de73a71b0fc43b9ce1c9d32dfa19783
|
[
"Apache-2.0"
] | 38
|
2015-01-20T14:16:22.000Z
|
2022-03-16T09:23:09.000Z
|
test/itkHDF5UltrasoundImageIOTest.cxx
|
thewtex/ITKUltrasound
|
9ab459466ffe155840fdf3de30aafb3660dba800
|
[
"Apache-2.0"
] | 83
|
2015-08-05T14:09:42.000Z
|
2022-03-30T20:28:03.000Z
|
test/itkHDF5UltrasoundImageIOTest.cxx
|
thewtex/ITKUltrasound
|
9ab459466ffe155840fdf3de30aafb3660dba800
|
[
"Apache-2.0"
] | 29
|
2015-03-27T23:23:20.000Z
|
2022-01-04T22:44:57.000Z
|
/*=========================================================================
*
* Copyright NumFOCUS
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0.txt
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*=========================================================================*/
#include "itkArray.h"
#include "itkHDF5UltrasoundImageIO.h"
#include "itkHDF5UltrasoundImageIOFactory.h"
#include "itkMetaDataObject.h"
#include "itkTestingMacros.h"
#include "itkMath.h"
#include "itkImageIORegion.h"
int
itkHDF5UltrasoundImageIOTest(int argc, char * argv[])
{
if (argc < 2)
{
std::cerr << "Usage: " << argv[0] << " inputImage" << std::endl;
return EXIT_FAILURE;
}
const char * inputImageFileName = argv[1];
itk::HDF5UltrasoundImageIO::Pointer imageIO = itk::HDF5UltrasoundImageIO::New();
ITK_EXERCISE_BASIC_OBJECT_METHODS(imageIO, HDF5UltrasoundImageIO, StreamingImageIOBase);
ITK_TEST_EXPECT_TRUE(!imageIO->CanReadFile("AMINCFile.mnc"));
ITK_TEST_EXPECT_TRUE(imageIO->CanReadFile(inputImageFileName));
imageIO->SetFileName(inputImageFileName);
imageIO->ReadImageInformation();
const unsigned int Dimension = 3;
itk::SizeValueType dimensions[Dimension];
for (unsigned int ii = 0; ii < Dimension; ++ii)
{
dimensions[ii] = imageIO->GetDimensions(ii);
}
std::cout << "Dimensions: [ " << dimensions[0] << ", " << dimensions[1] << ", " << dimensions[2] << " ]" << std::endl;
ITK_TEST_EXPECT_EQUAL(dimensions[0], 240);
ITK_TEST_EXPECT_EQUAL(dimensions[1], 328);
ITK_TEST_EXPECT_EQUAL(dimensions[2], 125);
std::cout << "ComponentType: " << imageIO->GetComponentTypeAsString(imageIO->GetComponentType()) << std::endl;
ITK_TEST_EXPECT_EQUAL(imageIO->GetComponentType(), itk::IOComponentEnum::FLOAT);
const itk::MetaDataDictionary & metaDataDict = imageIO->GetMetaDataDictionary();
std::string sliceType;
itk::ExposeMetaData<std::string>(metaDataDict, "SliceType", sliceType);
std::cout << "SliceType: " << sliceType << std::endl;
ITK_TEST_EXPECT_EQUAL(sliceType, "Image");
using SliceSpacingType = itk::Array<double>;
SliceSpacingType sliceSpacing(2);
itk::ExposeMetaData<SliceSpacingType>(metaDataDict, "SliceSpacing", sliceSpacing);
std::cout << "SliceSpacing: [ " << sliceSpacing[0] << ", " << sliceSpacing[1] << " ]" << std::endl;
ITK_TEST_EXPECT_TRUE(itk::Math::FloatAlmostEqual(sliceSpacing[0], 0.1925));
ITK_TEST_EXPECT_TRUE(itk::Math::FloatAlmostEqual(sliceSpacing[1], 0.167811, 10, 1e-6));
using SliceOriginType = itk::Array<double>;
SliceOriginType sliceOrigin(2);
itk::ExposeMetaData<SliceOriginType>(metaDataDict, "SliceOrigin", sliceOrigin);
std::cout << "SliceOrigin: [ " << sliceOrigin[0] << ", " << sliceOrigin[1] << " ]" << std::endl;
ITK_TEST_EXPECT_TRUE(itk::Math::FloatAlmostEqual(sliceOrigin[0], 0.0));
ITK_TEST_EXPECT_TRUE(itk::Math::FloatAlmostEqual(sliceOrigin[1], -27.2693, 10, 1e-3));
using ElevationalSliceAnglesType = itk::Array<double>;
ElevationalSliceAnglesType elevationalSliceAngles(imageIO->GetDimensions(2));
itk::ExposeMetaData<ElevationalSliceAnglesType>(metaDataDict, "ElevationalSliceAngles", elevationalSliceAngles);
std::cout << "ElevationalSliceAngles: [ " << elevationalSliceAngles[0] << ", " << elevationalSliceAngles[1] << ", "
<< elevationalSliceAngles[2] << " ..." << std::endl;
ITK_TEST_EXPECT_TRUE(itk::Math::FloatAlmostEqual(elevationalSliceAngles[0], -1.0821, 10, 1e-3));
ITK_TEST_EXPECT_TRUE(itk::Math::FloatAlmostEqual(elevationalSliceAngles[1], -1.06465, 10, 1e-4));
float * buffer = new float[10 * 10 * 10];
itk::ImageIORegion ioRegion(Dimension);
for (unsigned int ii = 0; ii < Dimension; ++ii)
{
ioRegion.SetIndex(ii, 0);
ioRegion.SetSize(ii, 10);
}
imageIO->SetIORegion(ioRegion);
imageIO->Read(static_cast<void *>(buffer));
ITK_TEST_EXPECT_EQUAL(buffer[0], 88.0);
ITK_TEST_EXPECT_EQUAL(buffer[1], 78.0);
ITK_TEST_EXPECT_EQUAL(buffer[2], 77.0);
delete[] buffer;
return EXIT_SUCCESS;
}
| 41.564815
| 120
| 0.689686
|
tbirdso
|
69fde02f06219de5181fed4b4211e703e0b110ab
| 1,281
|
cpp
|
C++
|
algorithmic-toolbox/week5_dynamic_programming1/2_primitive_calculator/primitive_calculator.cpp
|
hsgrewal/algorithms
|
b7532cc14221490128bb6aa12b06d20656855b8d
|
[
"MIT"
] | null | null | null |
algorithmic-toolbox/week5_dynamic_programming1/2_primitive_calculator/primitive_calculator.cpp
|
hsgrewal/algorithms
|
b7532cc14221490128bb6aa12b06d20656855b8d
|
[
"MIT"
] | null | null | null |
algorithmic-toolbox/week5_dynamic_programming1/2_primitive_calculator/primitive_calculator.cpp
|
hsgrewal/algorithms
|
b7532cc14221490128bb6aa12b06d20656855b8d
|
[
"MIT"
] | null | null | null |
#include <iostream>
#include <vector>
#include <algorithm>
#include <limits>
using std::vector;
vector<int> optimal_sequence(int n) {
std::vector<int> sequence;
vector<int> array(n + 1);
int a1, m2, m3;
for (int i = 2; i <= n; ++i) {
a1 = m2 = m3 = std::numeric_limits<int>::max();
if (i - 1 >= 0) {
a1 = 1 + array.at(i - 1);
}
if (i % 2 == 0 and i / 2 >= 0) {
m2 = 1 + array.at(i / 2);
}
if (i % 3 == 0 and i / 3 >= 0) {
m3 = 1 + array.at(i / 3);
}
array[i] = std::min(a1, std::min(m2, m3));
}
while (n > 1) {
sequence.push_back(n);
if (n % 3 == 0 and array.at(n / 3) + 1 == array.at(n)) {
n /= 3;
} else if (n % 2 == 0 and array.at(n / 2) + 1 == array.at(n)) {
n /= 2;
} else if (array.at(n - 1) + 1 == array.at(n)) {
n = n - 1;
}
}
sequence.push_back(1);
reverse(sequence.begin(), sequence.end());
return sequence;
}
int main() {
int n;
std::cin >> n;
vector<int> sequence = optimal_sequence(n);
std::cout << sequence.size() - 1 << std::endl;
for (size_t i = 0; i < sequence.size(); ++i) {
std::cout << sequence[i] << " ";
}
}
| 26.142857
| 71
| 0.442623
|
hsgrewal
|
0e0151bb98ff6cfa3a739a80ed8b0665eeaa33e4
| 309
|
hpp
|
C++
|
epoch/ayla/include/ayla/serialization/cylinder_serializer.hpp
|
oprogramadorreal/vize
|
042c16f96d8790303563be6787200558e1ec00b2
|
[
"MIT"
] | 47
|
2020-03-30T14:36:46.000Z
|
2022-03-06T07:44:54.000Z
|
epoch/ayla/include/ayla/serialization/cylinder_serializer.hpp
|
oprogramadorreal/vize
|
042c16f96d8790303563be6787200558e1ec00b2
|
[
"MIT"
] | null | null | null |
epoch/ayla/include/ayla/serialization/cylinder_serializer.hpp
|
oprogramadorreal/vize
|
042c16f96d8790303563be6787200558e1ec00b2
|
[
"MIT"
] | 8
|
2020-04-01T01:22:45.000Z
|
2022-01-02T13:06:09.000Z
|
#ifndef AYLA_CYLINDER_SERIALIZER_HPP
#define AYLA_CYLINDER_SERIALIZER_HPP
namespace ayla {
class Cylinder;
}
namespace boost {
namespace serialization {
template <class Archive>
void serialize(Archive& ar, ayla::Cylinder& cylinder, const unsigned int version);
}
}
#endif // AYLA_CYLINDER_SERIALIZER_HPP
| 18.176471
| 82
| 0.802589
|
oprogramadorreal
|
0e032a6fdb93400c1863fd8f936662b9b3d24266
| 2,893
|
cpp
|
C++
|
tests/util_scoped_timer.cpp
|
extcpp/base
|
26b1384cbbd5cb3171e4cd22c8eb5f09ec0c5732
|
[
"MIT"
] | null | null | null |
tests/util_scoped_timer.cpp
|
extcpp/base
|
26b1384cbbd5cb3171e4cd22c8eb5f09ec0c5732
|
[
"MIT"
] | 22
|
2019-10-15T20:47:02.000Z
|
2020-01-26T20:26:19.000Z
|
tests/util_scoped_timer.cpp
|
extcpp/base
|
26b1384cbbd5cb3171e4cd22c8eb5f09ec0c5732
|
[
"MIT"
] | 1
|
2020-09-24T08:53:15.000Z
|
2020-09-24T08:53:15.000Z
|
// Copyright - 2020 - Jan Christoph Uhde <Jan@UhdeJC.com>
// Please see LICENSE.md for license or visit https://github.com/extcpp/basics
#include <ext/macros/compiler.hpp>
#include <ext/util/scoped_timer.hpp>
#include <gtest/gtest.h>
#include <iostream>
#include <thread>
using namespace ext::util;
constexpr auto ms = std::chrono::milliseconds(1);
void assert_time_eq(std::size_t ms_expected, std::pair<std::uint64_t, std::string> const& in, std::size_t steps = 1) {
#ifndef EXT_TESTS_NO_TIME_CRITICAL
#ifdef EXT_COMPILER_VC
ms_expected += 2 * steps;
#else
ms_expected += steps;
#endif
ASSERT_LE(in.first / (1000 * 1000), ms_expected);
#else
(void) ms_expected;
(void) in;
(void) steps;
std::cerr << "time not asserted\n";
#endif // EXT_TESTS_NO_TIME_CRITICAL
}
TEST(util_scoped_timer, nostep) {
scoped_timer_res result;
auto callback = [&result](scoped_timer_res const& in) {
result = in;
return in;
};
{
scoped_timer timer(callback);
std::this_thread::sleep_for(ms);
}
assert_time_eq(1, result.front());
}
TEST(util_scoped_timer, steps) {
scoped_timer_res result;
auto callback = [&result](scoped_timer_res const& in) {
result = in;
return in;
};
{
scoped_timer timer(callback);
std::this_thread::sleep_for(ms);
timer.add_step();
std::this_thread::sleep_for(ms);
timer.add_step();
std::this_thread::sleep_for(ms);
}
assert_time_eq(3, result[0], 3);
assert_time_eq(1, result[1], 1);
assert_time_eq(1, result[2], 2);
assert_time_eq(1, result[3], 3);
ASSERT_STREQ("destructor", result.back().second.c_str());
}
TEST(util_scoped_timer, no_dtor) {
scoped_timer_res result;
auto callback = [&result](scoped_timer_res const& in) {
result = in;
return in;
};
{
scoped_timer timer(callback);
timer.disable_dtor_entry();
std::this_thread::sleep_for(ms);
timer.add_step();
std::this_thread::sleep_for(ms);
timer.add_step();
std::this_thread::sleep_for(ms);
}
assert_time_eq(2, result[0], 2);
assert_time_eq(1, result[1], 1);
assert_time_eq(1, result[2], 2);
ASSERT_STREQ("", result.back().second.c_str());
}
TEST(util_scoped_timer, dismiss) {
scoped_timer_res result;
auto callback = [&result](scoped_timer_res const& in) {
result = in;
return in;
};
{
scoped_timer timer(callback);
timer.disable_dtor_entry();
timer.dismiss();
timer.init("", 1);
std::this_thread::sleep_for(ms);
timer.add_step("fin");
std::this_thread::sleep_for(ms);
timer.run();
}
assert_time_eq(1, result[0], 1);
assert_time_eq(1, result[1], 1);
ASSERT_STREQ("fin", result[1].second.c_str());
}
| 25.830357
| 118
| 0.622883
|
extcpp
|
0e0a5d6325e483fccf2b291a21ec1f3da9682996
| 2,042
|
cpp
|
C++
|
src/ParamGen.cpp
|
Jesusausage/ZKP_Voting
|
c98658ac533522a146b0be5a976cb215f130a4ec
|
[
"MIT"
] | 1
|
2019-07-04T18:54:07.000Z
|
2019-07-04T18:54:07.000Z
|
src/ParamGen.cpp
|
Jesusausage/ZKP_Voting
|
c98658ac533522a146b0be5a976cb215f130a4ec
|
[
"MIT"
] | null | null | null |
src/ParamGen.cpp
|
Jesusausage/ZKP_Voting
|
c98658ac533522a146b0be5a976cb215f130a4ec
|
[
"MIT"
] | 1
|
2019-09-10T00:15:30.000Z
|
2019-09-10T00:15:30.000Z
|
#include "ParamGen.hpp"
void generateParams()
{
auto ecg = GenerateECGroup();
auto base = GenerateECBase();
std::ofstream token_out(TOKEN_FILE);
std::ofstream id_out(ID_FILE);
CryptoPP::Integer token_keys[10][5];
CryptoPP::ECPPoint tokens[10][5];
CryptoPP::ECPPoint token_sums[5];
CryptoPP::Integer id_keys[10];
CryptoPP::ECPPoint ids[10];
CryptoPP::ECPPoint id_sum;
for (int i = 0; i < 10; i++) {
for (int option = 0; option < 5; option++) {
token_keys[i][option] = RandomInteger(1, ecg.order);
tokens[i][option] = ecg.curve.Multiply(token_keys[i][option], base);
token_sums[option] = ecg.curve.Add(token_sums[option], tokens[i][option]);
}
WriteTokens(tokens[i], 5, token_out);
id_keys[i] = RandomInteger(1, ecg.order);
ids[i] = ecg.curve.Multiply(id_keys[i], base);
id_sum = ecg.curve.Add(id_sum, ids[i]);
WriteID(ids[i], id_out);
}
token_out.close();
id_out.close();
std::ofstream priv_out("private_keys.txt");
priv_out << id_keys[0] << std::endl;
for (int i = 0; i < 5; ++i)
priv_out << token_keys[0][i] << std::endl;
priv_out.close();
priv_out.open("private_keys1.txt");
priv_out << id_keys[1] << std::endl;
for (int i = 0; i < 5; ++i)
priv_out << token_keys[1][i] << std::endl;
priv_out.close();
PublicData pub(ecg, 10, 5);
PrivateData priv(5);
VoteData data(ecg, base, pub, priv);
for (int i = 1; i < 10; ++i) {
Voter voter(ecg, base, id_sum, tokens[i], 5);
voter.setTokenKeys(token_keys[i]);
voter.castVote(i % 5);
Vote vote = voter.getVoteAndProofs();
KeyGen key_gen(ecg, base, token_sums, ids[i], 5);
key_gen.setIDKey(id_keys[i]);
Key key = key_gen.getKeysAndProofs();
CryptoPP::byte output[2445];
int n;
vote.serialise(output, n);
key.serialise(output + 1630, n);
data.processVKPair(output, i);
}
}
| 29.171429
| 86
| 0.582272
|
Jesusausage
|
0e0bb2f4f3904d3a93316a4ef605060e6fc4bfc1
| 3,860
|
cpp
|
C++
|
SampleFoundation/Triangulation/Triangulation.cpp
|
wjezxujian/WildMagic4
|
249a17f8c447cf57c6283408e01009039810206a
|
[
"BSL-1.0"
] | 3
|
2021-08-02T04:03:03.000Z
|
2022-01-04T07:31:20.000Z
|
SampleFoundation/Triangulation/Triangulation.cpp
|
wjezxujian/WildMagic4
|
249a17f8c447cf57c6283408e01009039810206a
|
[
"BSL-1.0"
] | null | null | null |
SampleFoundation/Triangulation/Triangulation.cpp
|
wjezxujian/WildMagic4
|
249a17f8c447cf57c6283408e01009039810206a
|
[
"BSL-1.0"
] | 5
|
2019-10-13T02:44:19.000Z
|
2021-08-02T04:03:10.000Z
|
// Geometric Tools, Inc.
// http://www.geometrictools.com
// Copyright (c) 1998-2006. All Rights Reserved
//
// The Wild Magic Version 4 Restricted Libraries source code is supplied
// under the terms of the license agreement
// http://www.geometrictools.com/License/Wm4RestrictedLicense.pdf
// and may not be copied or disclosed except in accordance with the terms
// of that agreement.
#include "Triangulation.h"
WM4_WINDOW_APPLICATION(Triangulation);
const int g_iSize = 256;
//----------------------------------------------------------------------------
Triangulation::Triangulation ()
:
WindowApplication2("Triangulation",0,0,g_iSize,g_iSize,
ColorRGBA(1.0f,1.0f,1.0f,1.0f))
{
m_akVertex = 0;
m_aiIndex = 0;
}
//----------------------------------------------------------------------------
bool Triangulation::OnInitialize ()
{
if (!WindowApplication2::OnInitialize())
{
return false;
}
// select a polygon
m_iVQuantity = 10;
m_akVertex = WM4_NEW Vector2f[m_iVQuantity];
m_akVertex[0][0] = 29.0f; m_akVertex[0][1] = 139.0f;
m_akVertex[1][0] = 78.0f; m_akVertex[1][1] = 99.0f;
m_akVertex[2][0] = 125.0f; m_akVertex[2][1] = 141.0f;
m_akVertex[3][0] = 164.0f; m_akVertex[3][1] = 116.0f;
m_akVertex[4][0] = 201.0f; m_akVertex[4][1] = 168.0f;
m_akVertex[5][0] = 157.0f; m_akVertex[5][1] = 163.0f;
m_akVertex[6][0] = 137.0f; m_akVertex[6][1] = 200.0f;
m_akVertex[7][0] = 98.0f; m_akVertex[7][1] = 134.0f;
m_akVertex[8][0] = 52.0f; m_akVertex[8][1] = 146.0f;
m_akVertex[9][0] = 55.0f; m_akVertex[9][1] = 191.0f;
// construct the triangulation
m_iTQuantity = m_iVQuantity-2;
TriangulateEC<float>(m_iVQuantity,m_akVertex,Query::QT_FILTERED,
0.001f,m_aiIndex);
OnDisplay();
return true;
}
//----------------------------------------------------------------------------
void Triangulation::OnTerminate ()
{
WM4_DELETE[] m_akVertex;
WM4_DELETE[] m_aiIndex;
WindowApplication2::OnTerminate();
}
//----------------------------------------------------------------------------
void Triangulation::OnDisplay ()
{
ClearScreen();
Color kBlue(0,0,255), kBlack(0,0,0), kGray(128,128,128);
int i, iX0, iY0, iX1, iY1;
// draw the triangulation edges
const int* piIndex = m_aiIndex;
for (i = 0; i < m_iTQuantity; i++)
{
int iV0 = *piIndex++;
int iV1 = *piIndex++;
int iV2 = *piIndex++;
iX0 = (int)m_akVertex[iV0][0];
iY0 = (int)m_akVertex[iV0][1];
iX1 = (int)m_akVertex[iV1][0];
iY1 = (int)m_akVertex[iV1][1];
DrawLine(iX0,iY0,iX1,iY1,kGray);
iX0 = (int)m_akVertex[iV1][0];
iY0 = (int)m_akVertex[iV1][1];
iX1 = (int)m_akVertex[iV2][0];
iY1 = (int)m_akVertex[iV2][1];
DrawLine(iX0,iY0,iX1,iY1,kGray);
iX0 = (int)m_akVertex[iV2][0];
iY0 = (int)m_akVertex[iV2][1];
iX1 = (int)m_akVertex[iV0][0];
iY1 = (int)m_akVertex[iV0][1];
DrawLine(iX0,iY0,iX1,iY1,kGray);
}
// draw the polygon edges
for (int i0 = m_iVQuantity-1, i1 = 0; i1 < m_iVQuantity; i0 = i1++)
{
iX0 = (int)m_akVertex[i0][0];
iY0 = (int)m_akVertex[i0][1];
iX1 = (int)m_akVertex[i1][0];
iY1 = (int)m_akVertex[i1][1];
DrawLine(iX0,iY0,iX1,iY1,kBlue);
}
// draw the polygon vertices
for (i = 0; i < m_iVQuantity; i++)
{
iX0 = (int)m_akVertex[i][0];
iY0 = (int)m_akVertex[i][1];
for (int iDY = -1; iDY <= 1; iDY++)
{
for (int iDX = -1; iDX <= 1; iDX++)
{
SetPixel(iX0+iDX,iY0+iDY,kBlack);
}
}
}
WindowApplication2::OnDisplay();
}
//----------------------------------------------------------------------------
| 30.634921
| 78
| 0.525907
|
wjezxujian
|
0e0c6135bb6004a72f5cf58ea0ed1409e1f9f9be
| 3,634
|
cpp
|
C++
|
src/elements/cube.cpp
|
jamillosantos/imu-mock
|
3d314e8ef37263d72fda412d6d40e522005405f8
|
[
"MIT"
] | 1
|
2018-01-21T05:38:04.000Z
|
2018-01-21T05:38:04.000Z
|
src/elements/cube.cpp
|
mote-robotics/imu-mock
|
3d314e8ef37263d72fda412d6d40e522005405f8
|
[
"MIT"
] | null | null | null |
src/elements/cube.cpp
|
mote-robotics/imu-mock
|
3d314e8ef37263d72fda412d6d40e522005405f8
|
[
"MIT"
] | null | null | null |
/**
* @author J. Santos <jamillo@gmail.com>
* @date October 06, 2016
*/
#include "cube.h"
draw::Colour elements::Cube::lineColour(1.0f, 1.0f, 1.0f, 0.6f);
elements::CubeColours::CubeColours() :
_top(draw::Colour::RED), _bottom(draw::Colour::ORANGE), _left(draw::Colour::YELLOW),
_right(draw::Colour::WHITE), _front(draw::Colour::BLUE), _back(draw::Colour::GREEN)
{ }
draw::Colour &elements::CubeColours::top()
{
return this->_top;
}
void elements::CubeColours::top(draw::Colour &top)
{
this->_top = top;
}
draw::Colour &elements::CubeColours::bottom()
{
return this->_bottom;
}
void elements::CubeColours::bottom(draw::Colour &bottom)
{
this->_bottom = bottom;
}
draw::Colour &elements::CubeColours::left()
{
return this->_left;
}
void elements::CubeColours::left(draw::Colour &left)
{
this->_left = left;
}
draw::Colour &elements::CubeColours::right()
{
return this->_right;
}
void elements::CubeColours::right(draw::Colour &right)
{
this->_right = right;
}
draw::Colour &elements::CubeColours::front()
{
return this->_front;
}
void elements::CubeColours::front(draw::Colour &front)
{
this->_front = front;
}
draw::Colour &elements::CubeColours::back()
{
return this->_back;
}
void elements::CubeColours::back(draw::Colour &back)
{
this->_back = back;
}
void elements::CubeColours::colour(const draw::Colour &colour)
{
this->_top = colour;
this->_bottom = colour;
this->_left = colour;
this->_right = colour;
this->_front = colour;
this->_back = colour;
}
void elements::Cube::draw()
{
glBegin(GL_QUADS);
{
// Top
this->_colour.top().draw();
glVertex3f(-0.5f, -0.5f, -0.5f);
glVertex3f(-0.5f, 0.5f, -0.5f);
glVertex3f(0.5f, 0.5f, -0.5f);
glVertex3f(0.5f, -0.5f, -0.5f);
// Bottom
this->_colour.bottom().draw();
glVertex3f(-0.5f, -0.5f, 0.5f);
glVertex3f(-0.5f, 0.5f, 0.5f);
glVertex3f(0.5f, 0.5f, 0.5f);
glVertex3f(0.5f, -0.5f, 0.5f);
// Left
this->_colour.left().draw();
glVertex3f(-0.5f, -0.5f, -0.5f);
glVertex3f(-0.5f, 0.5f, -0.5f);
glVertex3f(-0.5f, 0.5f, 0.5f);
glVertex3f(-0.5f, -0.5f, 0.5f);
// Right
this->_colour.right().draw();
glVertex3f(0.5f, -0.5f, -0.5f);
glVertex3f(0.5f, 0.5f, -0.5f);
glVertex3f(0.5f, 0.5f, 0.5f);
glVertex3f(0.5f, -0.5f, 0.5f);
// Front
this->_colour.front().draw();
glVertex3f(-0.5f, -0.5f, -0.5f);
glVertex3f(0.5f, -0.5f, -0.5f);
glVertex3f(0.5f, -0.5f, 0.5f);
glVertex3f(-0.5f, -0.5f, 0.5f);
// Back
this->_colour.back().draw();
glVertex3f(-0.5f, 0.5f, -0.5f);
glVertex3f(0.5f, 0.5f, -0.5f);
glVertex3f(0.5f, 0.5f, 0.5f);
glVertex3f(-0.5f, 0.5f, 0.5f);
}
glEnd();
// Draws the line contour of the cube.
glBegin(GL_LINES);
{
lineColour.draw();
glVertex3f(-0.5f, -0.5f, -0.5f);
glVertex3f(-0.5f, 0.5f, -0.5f);
glVertex3f( 0.5f, 0.5f, -0.5f);
glVertex3f( 0.5f, -0.5f, -0.5f);
glVertex3f(-0.5f, -0.5f, 0.5f);
glVertex3f(-0.5f, 0.5f, 0.5f);
glVertex3f( 0.5f, 0.5f, 0.5f);
glVertex3f( 0.5f, -0.5f, 0.5f);
glVertex3f(-0.5f, -0.5f, -0.5f);
glVertex3f(-0.5f, 0.5f, -0.5f);
glVertex3f(-0.5f, 0.5f, 0.5f);
glVertex3f(-0.5f, -0.5f, 0.5f);
glVertex3f( 0.5f, -0.5f, -0.5f);
glVertex3f( 0.5f, 0.5f, -0.5f);
glVertex3f( 0.5f, 0.5f, 0.5f);
glVertex3f( 0.5f, -0.5f, 0.5f);
glVertex3f(-0.5f, -0.5f, -0.5f);
glVertex3f( 0.5f, -0.5f, -0.5f);
glVertex3f( 0.5f, -0.5f, 0.5f);
glVertex3f(-0.5f, -0.5f, 0.5f);
glVertex3f(-0.5f, 0.5f, -0.5f);
glVertex3f( 0.5f, 0.5f, -0.5f);
glVertex3f( 0.5f, 0.5f, 0.5f);
glVertex3f(-0.5f, 0.5f, 0.5f);
}
glEnd();
}
elements::CubeColours &elements::Cube::colour()
{
return this->_colour;
}
| 22.294479
| 85
| 0.61585
|
jamillosantos
|
0e0db1fd0bd8ee19cec18d6339686fa9b66a0ebc
| 1,052
|
cpp
|
C++
|
aws-cpp-sdk-servicecatalog/source/model/DescribePortfolioShareStatusRequest.cpp
|
Neusoft-Technology-Solutions/aws-sdk-cpp
|
88c041828b0dbee18a297c3cfe98c5ecd0706d0b
|
[
"Apache-2.0"
] | 1
|
2022-02-12T08:09:30.000Z
|
2022-02-12T08:09:30.000Z
|
aws-cpp-sdk-servicecatalog/source/model/DescribePortfolioShareStatusRequest.cpp
|
Neusoft-Technology-Solutions/aws-sdk-cpp
|
88c041828b0dbee18a297c3cfe98c5ecd0706d0b
|
[
"Apache-2.0"
] | 1
|
2021-10-14T16:57:00.000Z
|
2021-10-18T10:47:24.000Z
|
aws-cpp-sdk-servicecatalog/source/model/DescribePortfolioShareStatusRequest.cpp
|
ravindra-wagh/aws-sdk-cpp
|
7d5ff01b3c3b872f31ca98fb4ce868cd01e97696
|
[
"Apache-2.0"
] | 1
|
2021-11-09T11:58:03.000Z
|
2021-11-09T11:58:03.000Z
|
/**
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
* SPDX-License-Identifier: Apache-2.0.
*/
#include <aws/servicecatalog/model/DescribePortfolioShareStatusRequest.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <utility>
using namespace Aws::ServiceCatalog::Model;
using namespace Aws::Utils::Json;
using namespace Aws::Utils;
DescribePortfolioShareStatusRequest::DescribePortfolioShareStatusRequest() :
m_portfolioShareTokenHasBeenSet(false)
{
}
Aws::String DescribePortfolioShareStatusRequest::SerializePayload() const
{
JsonValue payload;
if(m_portfolioShareTokenHasBeenSet)
{
payload.WithString("PortfolioShareToken", m_portfolioShareToken);
}
return payload.View().WriteReadable();
}
Aws::Http::HeaderValueCollection DescribePortfolioShareStatusRequest::GetRequestSpecificHeaders() const
{
Aws::Http::HeaderValueCollection headers;
headers.insert(Aws::Http::HeaderValuePair("X-Amz-Target", "AWS242ServiceCatalogService.DescribePortfolioShareStatus"));
return headers;
}
| 23.909091
| 121
| 0.789924
|
Neusoft-Technology-Solutions
|
97b98fef6f27bb72b87edcde7566c85b1db11509
| 5,127
|
cc
|
C++
|
chromeos/dbus/upstart_client.cc
|
metux/chromium-deb
|
3c08e9b89a1b6f95f103a61ff4f528dbcd57fc42
|
[
"BSD-3-Clause-No-Nuclear-License-2014",
"BSD-3-Clause"
] | null | null | null |
chromeos/dbus/upstart_client.cc
|
metux/chromium-deb
|
3c08e9b89a1b6f95f103a61ff4f528dbcd57fc42
|
[
"BSD-3-Clause-No-Nuclear-License-2014",
"BSD-3-Clause"
] | null | null | null |
chromeos/dbus/upstart_client.cc
|
metux/chromium-deb
|
3c08e9b89a1b6f95f103a61ff4f528dbcd57fc42
|
[
"BSD-3-Clause-No-Nuclear-License-2014",
"BSD-3-Clause"
] | null | null | null |
// Copyright 2016 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "chromeos/dbus/upstart_client.h"
#include "base/bind.h"
#include "base/memory/weak_ptr.h"
#include "dbus/bus.h"
#include "dbus/message.h"
#include "dbus/object_proxy.h"
namespace chromeos {
namespace {
const char kUpstartServiceName[] = "com.ubuntu.Upstart";
const char kUpstartJobInterface[] = "com.ubuntu.Upstart0_6.Job";
const char kUpstartStartMethod[] = "Start";
const char kUpstartRestartMethod[] = "Restart";
const char kUpstartStopMethod[] = "Stop";
const char kUpstartAuthPolicyPath[] = "/com/ubuntu/Upstart/jobs/authpolicyd";
const char kUpstartMediaAnalyticsPath[] =
"/com/ubuntu/Upstart/jobs/rtanalytics";
class UpstartClientImpl : public UpstartClient {
public:
UpstartClientImpl() : weak_ptr_factory_(this) {}
~UpstartClientImpl() override {}
// UpstartClient override.
void StartAuthPolicyService() override {
dbus::MethodCall method_call(kUpstartJobInterface, kUpstartStartMethod);
dbus::MessageWriter writer(&method_call);
writer.AppendArrayOfStrings(std::vector<std::string>());
writer.AppendBool(true); // Wait for response.
auth_proxy_->CallMethod(&method_call,
dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
base::Bind(&UpstartClientImpl::HandleAuthResponse,
weak_ptr_factory_.GetWeakPtr()));
}
void RestartAuthPolicyService() override {
dbus::MethodCall method_call(kUpstartJobInterface, kUpstartRestartMethod);
dbus::MessageWriter writer(&method_call);
writer.AppendArrayOfStrings(std::vector<std::string>());
writer.AppendBool(true); // Wait for response.
auth_proxy_->CallMethod(&method_call,
dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
base::Bind(&UpstartClientImpl::HandleAuthResponse,
weak_ptr_factory_.GetWeakPtr()));
}
void StartMediaAnalytics(const UpstartCallback& callback) override {
dbus::MethodCall method_call(kUpstartJobInterface, kUpstartStartMethod);
dbus::MessageWriter writer(&method_call);
writer.AppendArrayOfStrings(std::vector<std::string>());
writer.AppendBool(true); // Wait for response.
ma_proxy_->CallMethod(
&method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
base::Bind(&UpstartClientImpl::HandleStartMediaAnalyticsResponse,
weak_ptr_factory_.GetWeakPtr(), callback));
}
void RestartMediaAnalytics(const UpstartCallback& callback) override {
dbus::MethodCall method_call(kUpstartJobInterface, kUpstartRestartMethod);
dbus::MessageWriter writer(&method_call);
writer.AppendArrayOfStrings(std::vector<std::string>());
writer.AppendBool(true); // Wait for response.
ma_proxy_->CallMethod(
&method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
base::Bind(&UpstartClientImpl::HandleStartMediaAnalyticsResponse,
weak_ptr_factory_.GetWeakPtr(), callback));
}
void StopMediaAnalytics() override {
dbus::MethodCall method_call(kUpstartJobInterface, kUpstartStopMethod);
dbus::MessageWriter writer(&method_call);
writer.AppendArrayOfStrings(std::vector<std::string>());
writer.AppendBool(true); // Wait for response.
ma_proxy_->CallMethod(
&method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
base::Bind(&UpstartClientImpl::HandleStopMediaAnalyticsResponse,
weak_ptr_factory_.GetWeakPtr()));
}
protected:
void Init(dbus::Bus* bus) override {
bus_ = bus;
auth_proxy_ = bus_->GetObjectProxy(
kUpstartServiceName, dbus::ObjectPath(kUpstartAuthPolicyPath));
ma_proxy_ = bus_->GetObjectProxy(
kUpstartServiceName, dbus::ObjectPath(kUpstartMediaAnalyticsPath));
}
private:
void HandleAuthResponse(dbus::Response* response) {
LOG_IF(ERROR, !response) << "Failed to signal Upstart, response is null";
}
void HandleStartMediaAnalyticsResponse(const UpstartCallback& callback,
dbus::Response* response) {
if (!response) {
LOG(ERROR) << "Failed to signal Upstart, response is null.";
callback.Run(false);
return;
}
callback.Run(true);
}
void HandleStopMediaAnalyticsResponse(dbus::Response* response) {
LOG_IF(ERROR, !response) << "Failed to signal Upstart, response is null";
}
dbus::Bus* bus_ = nullptr;
dbus::ObjectProxy* auth_proxy_ = nullptr;
dbus::ObjectProxy* ma_proxy_ = nullptr;
// Note: This should remain the last member so it'll be destroyed and
// invalidate its weak pointers before any other members are destroyed.
base::WeakPtrFactory<UpstartClientImpl> weak_ptr_factory_;
DISALLOW_COPY_AND_ASSIGN(UpstartClientImpl);
};
} // namespace
UpstartClient::UpstartClient() {}
UpstartClient::~UpstartClient() {}
// static
UpstartClient* UpstartClient::Create() {
return new UpstartClientImpl();
}
} // namespace chromeos
| 36.621429
| 78
| 0.704115
|
metux
|
97bb897a388326c6e4f0d84a8a136f3b232f9348
| 10,399
|
cpp
|
C++
|
light_caster/main.cpp
|
raylib-extras/examples-cpp
|
1cac8ea52805c03d4fd29e924c854400f8ba72ef
|
[
"Zlib"
] | 10
|
2021-11-18T06:19:32.000Z
|
2022-03-08T04:44:19.000Z
|
light_caster/main.cpp
|
raylib-extras/examples-cpp
|
1cac8ea52805c03d4fd29e924c854400f8ba72ef
|
[
"Zlib"
] | 1
|
2022-01-02T05:27:00.000Z
|
2022-03-24T04:42:40.000Z
|
light_caster/main.cpp
|
raylib-extras/examples-cpp
|
1cac8ea52805c03d4fd29e924c854400f8ba72ef
|
[
"Zlib"
] | null | null | null |
#include "raylib.h"
#include "raymath.h"
#include "rlgl.h"
// constants from OpenGL
#define GL_SRC_ALPHA 0x0302
#define GL_MIN 0x8007
#define GL_MAX 0x8008
#include <vector>
// Draw a gradient-filled circle
// NOTE: Gradient goes from inner radius (color1) to border (color2)
void DrawLightGradient(int centerX, int centerY, float innerRadius, float outterRadius, Color color1, Color color2)
{
rlCheckRenderBatchLimit(3 * 3 * 36);
if (innerRadius == 0)
{
DrawCircleGradient(centerX, centerY, outterRadius, color1, color2);
return;
}
rlBegin(RL_TRIANGLES);
for (int i = 0; i < 360; i += 10)
{
// inner triangle at color1
rlColor4ub(color1.r, color1.g, color1.b, color1.a);
rlVertex2f((float)centerX, (float)centerY);
rlVertex2f((float)centerX + sinf(DEG2RAD * i) * innerRadius, (float)centerY + cosf(DEG2RAD * i) * innerRadius);
rlVertex2f((float)centerX + sinf(DEG2RAD * (i + 10)) * innerRadius, (float)centerY + cosf(DEG2RAD * (i + 10)) * innerRadius);
if (outterRadius > innerRadius)
{
rlVertex2f((float)centerX + sinf(DEG2RAD * (i + 10)) * innerRadius, (float)centerY + cosf(DEG2RAD * (i + 10)) * innerRadius);
rlVertex2f((float)centerX + sinf(DEG2RAD * i) * innerRadius, (float)centerY + cosf(DEG2RAD * i) * innerRadius);
rlColor4ub(color2.r, color2.g, color2.b, color2.a);
rlVertex2f((float)centerX + sinf(DEG2RAD * i) * outterRadius, (float)centerY + cosf(DEG2RAD * i) * outterRadius);
rlColor4ub(color1.r, color1.g, color1.b, color1.a);
rlVertex2f((float)centerX + sinf(DEG2RAD * (i + 10)) * innerRadius, (float)centerY + cosf(DEG2RAD * (i + 10)) * innerRadius);
rlColor4ub(color2.r, color2.g, color2.b, color2.a);
rlVertex2f((float)centerX + sinf(DEG2RAD * i) * outterRadius, (float)centerY + cosf(DEG2RAD * i) * outterRadius);
rlVertex2f((float)centerX + sinf(DEG2RAD * (i + 10)) * outterRadius, (float)centerY + cosf(DEG2RAD * (i + 10)) * outterRadius);
}
}
rlEnd();
}
class LightInfo
{
public:
Vector2 Position = { 0,0 };
RenderTexture ShadowMask;
RenderTexture GlowTexture;
bool Valid = false;
bool HasColor = false;
Color LightColor = WHITE;
LightInfo()
{
ShadowMask = LoadRenderTexture(GetScreenWidth(), GetScreenHeight());
GlowTexture = LoadRenderTexture(GetScreenWidth(), GetScreenHeight());
UpdateLightMask();
}
LightInfo(const Vector2& pos)
{
ShadowMask = LoadRenderTexture(GetScreenWidth(), GetScreenHeight());
GlowTexture = LoadRenderTexture(GetScreenWidth(), GetScreenHeight());
UpdateLightMask();
Position = pos;
}
void Move(const Vector2& position)
{
Position = position;
Dirty = true;
}
void SetRadius(float outerRadius)
{
OuterRadius = outerRadius;
Dirty = true;
}
void SetColor(Color color)
{
HasColor = true;
LightColor = color;
}
bool BoxInLight(const Rectangle& box)
{
return CheckCollisionRecs(Bounds, box);
}
void ShadowEdge(const Vector2& sp, const Vector2& ep)
{
float extension = OuterRadius*2;
Vector2 spVector = Vector2Normalize(Vector2Subtract(sp, Position));
Vector2 spProjection = Vector2Add(sp, Vector2Scale(spVector, extension));
Vector2 epVector = Vector2Normalize(Vector2Subtract(ep, Position));
Vector2 epProjection = Vector2Add(ep, Vector2Scale(epVector, extension));
std::vector<Vector2> polygon;
polygon.push_back(sp);
polygon.push_back(ep);
polygon.push_back(epProjection);
polygon.push_back(spProjection);
Shadows.push_back(polygon);
}
void UpdateLightMask()
{
BeginTextureMode(ShadowMask);
ClearBackground(WHITE);
// force the blend mode to only set the alpha of the destination
rlSetBlendFactors(GL_SRC_ALPHA, GL_SRC_ALPHA, GL_MIN);
rlSetBlendMode(BLEND_CUSTOM);
if (Valid)
DrawLightGradient(Position.x, Position.y, InnerRadius, OuterRadius, ColorAlpha(WHITE,0), WHITE);
rlDrawRenderBatchActive();
rlSetBlendMode(BLEND_ALPHA);
rlSetBlendFactors(GL_SRC_ALPHA, GL_SRC_ALPHA, GL_MAX);
rlSetBlendMode(BLEND_CUSTOM);
for (std::vector<Vector2> shadow : Shadows)
{
DrawTriangleFan(&shadow[0], 4, WHITE);
}
rlDrawRenderBatchActive();
// go back to normal
rlSetBlendMode(BLEND_ALPHA);
EndTextureMode();
BeginTextureMode(GlowTexture);
ClearBackground(BLANK);
if (Valid)
DrawLightGradient(Position.x, Position.y, InnerRadius, OuterRadius, ColorAlpha(LightColor, 0.75f), ColorAlpha(LightColor, 0));
rlDrawRenderBatchActive();
rlSetBlendFactors(GL_SRC_ALPHA, GL_SRC_ALPHA, GL_MIN);
rlSetBlendMode(BLEND_CUSTOM);
for (std::vector<Vector2> shadow : Shadows)
{
DrawTriangleFan(&shadow[0], 4, BLANK);
}
rlDrawRenderBatchActive();
// go back to normal
rlSetBlendMode(BLEND_ALPHA);
EndTextureMode();
}
void Update(const std::vector<Rectangle>& boxes)
{
if (!Dirty)
return;
Dirty = false;
Bounds.x = Position.x - OuterRadius;
Bounds.y = Position.y - OuterRadius;
Bounds.width = OuterRadius * 2;
Bounds.height = OuterRadius * 2;
Shadows.clear();
for (const auto& box : boxes)
{
// are we in a box
if (CheckCollisionPointRec(Position, box))
return;
if (!CheckCollisionRecs(box, Bounds))
continue;
// compute shadow volumes for the faces we are opposite to
// top
Vector2 sp = { box.x, box.y };
Vector2 ep = { box.x + box.width, box.y };
if (Position.y > ep.y)
ShadowEdge(sp, ep);
// right
sp = ep;
ep.y += box.height;
if (Position.x < ep.x)
ShadowEdge(sp, ep);
// bottom
sp = ep;
ep.x -= box.width;
if (Position.y < ep.y)
ShadowEdge(sp, ep);
// left
sp = ep;
ep.y -= box.height;
if (Position.x > ep.x)
ShadowEdge(sp, ep);
// add the actual box as a shadow to get the corner of it.
// If the map is going to draw the box, then don't do this
std::vector<Vector2> polygon;
polygon.emplace_back(Vector2{ box.x, box.y });
polygon.emplace_back(Vector2{ box.x, box.y + box.height });
polygon.emplace_back(Vector2{ box.x + box.width, box.y + box.height });
polygon.emplace_back(Vector2{ box.x + box.width, box.y });
Shadows.push_back(polygon);
}
Valid = true;
UpdateLightMask();
}
float OuterRadius = 200;
float InnerRadius = 50;
Rectangle Bounds = { -150,-150,300,300 };
std::vector<std::vector<Vector2>> Shadows;
bool Dirty = true;
};
std::vector<Rectangle> Boxes;
Rectangle RandomBox()
{
float x = GetRandomValue(0, GetScreenWidth());
float y = GetRandomValue(0, GetScreenHeight());
float w = GetRandomValue(10,100);
float h = GetRandomValue(10,100);
return Rectangle{ x,y,w,h };
}
void SetupBoxes(const Vector2& startPos)
{
Boxes.emplace_back(Rectangle{ 50,50, 40, 40 });
Boxes.emplace_back(Rectangle{ 1200, 700, 40, 40 });
Boxes.emplace_back(Rectangle{ 200, 600, 40, 40 });
Boxes.emplace_back(Rectangle{ 1000, 50, 40, 40 });
Boxes.emplace_back(Rectangle{ 500, 350, 40, 40 });
for (int i = 0; i < 50; i++)
{
Rectangle rect = RandomBox();
while (CheckCollisionPointRec(startPos,rect))
rect = RandomBox();
Boxes.emplace_back(rect);
}
}
int main()
{
SetConfigFlags(/*FLAG_VSYNC_HINT ||*/ FLAG_MSAA_4X_HINT);
InitWindow(1280, 800, "LightCaster");
// SetTargetFPS(144);
RenderTexture LightMask = LoadRenderTexture(GetScreenWidth(), GetScreenHeight());
std::vector<LightInfo> Lights;
Lights.emplace_back();
Lights[0].Move(Vector2{ 600, 400 });
SetupBoxes(Lights[0].Position);
Image img = GenImageChecked(64, 64, 32, 32, GRAY, DARKGRAY);
Texture2D tile = LoadTextureFromImage(img);
UnloadImage(img);
bool showLines = false;
while (!WindowShouldClose())
{
if (IsMouseButtonDown(MOUSE_BUTTON_LEFT))
Lights[0].Move(GetMousePosition());
if (IsMouseButtonPressed(MOUSE_BUTTON_RIGHT))
{
Lights.emplace_back(GetMousePosition());
switch ((Lights.size() - 1) % 3)
{
default:
Lights.rbegin()->SetColor(YELLOW);
break;
case 1:
Lights.rbegin()->SetColor(BLUE);
break;
case 2:
Lights.rbegin()->SetColor(RED);
break;
case 3:
Lights.rbegin()->SetColor(GREEN);
break;
}
}
float delta = GetMouseWheelMove();
if (delta != 0)
{
float newRad = Lights[0].OuterRadius;
newRad += delta * 10;
if (newRad > Lights[0].InnerRadius)
Lights[0].SetRadius(newRad);
}
if (IsKeyPressed(KEY_F1))
showLines = !showLines;
bool dirtyLights = false;
for (auto& light : Lights)
{
if (light.Dirty)
dirtyLights = true;
light.Update(Boxes);
}
// update the light mask
if (dirtyLights)
{
// build up the light mask
BeginTextureMode(LightMask);
ClearBackground(BLACK);
// force the blend mode to only set the alpha of the destination
rlSetBlendFactors(GL_SRC_ALPHA, GL_SRC_ALPHA, GL_MIN);
rlSetBlendMode(BLEND_CUSTOM);
for (auto& light : Lights)
{
// if (light.Valid)
DrawTextureRec(light.ShadowMask.texture, Rectangle{ 0, 0, (float)GetScreenWidth(), -(float)GetScreenHeight() }, Vector2Zero(), WHITE);
}
rlDrawRenderBatchActive();
// go back to normal
rlSetBlendMode(BLEND_ALPHA);
EndTextureMode();
}
BeginDrawing();
ClearBackground(BLACK);
DrawTextureRec(tile, Rectangle{ 0,0,(float)GetScreenWidth(),(float)GetScreenHeight() }, Vector2Zero(), WHITE);
rlSetBlendMode(BLEND_ADDITIVE);
for (auto& light : Lights)
{
if (light.HasColor)
DrawTextureRec(light.GlowTexture.texture, Rectangle{ 0, 0, (float)GetScreenWidth(), -(float)GetScreenHeight() }, Vector2Zero(), WHITE);
}
rlDrawRenderBatchActive();
rlSetBlendMode(BLEND_ALPHA);
DrawTextureRec(LightMask.texture, Rectangle{ 0, 0, (float)GetScreenWidth(), -(float)GetScreenHeight() }, Vector2Zero(), ColorAlpha(WHITE, showLines ? 0.75f : 1.0f));
for (auto& light : Lights)
DrawCircle(int(light.Position.x), int(light.Position.y), 10, light.LightColor);
if (showLines)
{
for (std::vector<Vector2> shadow : Lights[0].Shadows)
{
DrawTriangleFan(&shadow[0], 4, DARKPURPLE);
}
for (const auto& box : Boxes)
{
if (Lights[0].BoxInLight(box))
DrawRectangleRec(box, PURPLE);
}
for (const auto& box : Boxes)
{
DrawRectangleLines(box.x,box.y, box.width, box.height, DARKBLUE);
}
DrawText("(F1) Hide Shadow Volumes", 0, 0, 20, GREEN);
}
else
{
DrawText("(F1) Show Shadow Volumes", 0, 0, 20, GREEN);
}
DrawFPS(1200, 0);
DrawText(TextFormat("Lights %d", (int)Lights.size()), 1050, 20, 20, GREEN);
EndDrawing();
}
CloseWindow();
return 0;
}
| 24.64218
| 167
| 0.683623
|
raylib-extras
|
97bc92512489c19bd54536f23f947fe46fb8292e
| 591
|
cpp
|
C++
|
src/J/J102.cpp
|
wlhcode/lscct
|
7fd112a9d1851ddcf41886d3084381a52e84a3ce
|
[
"MIT"
] | null | null | null |
src/J/J102.cpp
|
wlhcode/lscct
|
7fd112a9d1851ddcf41886d3084381a52e84a3ce
|
[
"MIT"
] | null | null | null |
src/J/J102.cpp
|
wlhcode/lscct
|
7fd112a9d1851ddcf41886d3084381a52e84a3ce
|
[
"MIT"
] | null | null | null |
#include<bits/stdc++.h>
using namespace std;
int r[200005][4];
int main(){
int x,y,n,a=0,q=0;
bool small=0;
cin>>y>>x>>n;
for(int i=1;i<=n;i++){
cin>>r[i][0]>>r[i][1]>>r[i][2];
if(r[i][0]>=y&&q==0) q=i-1;
if(r[i][0]<y) small=1;
}
if(q==0&&small) q=n;
if(!small) q=0;
while(q>0){
y=r[q][0];
bool gone=0;
while(r[q][0]==y){
if(!gone&&r[q][1]>r[q][2]&&x<=r[q][1]&&x>=r[q][2]){
x=r[q][2];
a++;
gone=1;
}
else if(!gone&&r[q][1]<r[q][2]&&x>=r[q][1]&&x<=r[q][2]){
x=r[q][2];
a++;
gone=1;
}
q--;
if(q<=0) break;
}
}
cout<<a<<endl;
}
| 16.885714
| 59
| 0.431472
|
wlhcode
|
97c34395c7e4e97ef721670fb96a4cc1f4e2fcac
| 2,765
|
cpp
|
C++
|
src/installerapplication.cpp
|
CommitteeOfZero/noidget
|
1ba0b37f7552c1659a8a7c8dd62893c9eece702a
|
[
"MIT"
] | null | null | null |
src/installerapplication.cpp
|
CommitteeOfZero/noidget
|
1ba0b37f7552c1659a8a7c8dd62893c9eece702a
|
[
"MIT"
] | null | null | null |
src/installerapplication.cpp
|
CommitteeOfZero/noidget
|
1ba0b37f7552c1659a8a7c8dd62893c9eece702a
|
[
"MIT"
] | null | null | null |
#include "installerapplication.h"
#include "installerwindow.h"
#include <api/apihost.h>
#include "fs.h"
#include <tx/transaction.h>
#include "receiptwriter.h"
#include "win32_registry.h"
#include <QFile>
#include <QTextStream>
#include <QStyleFactory>
#include <QResource>
#include <QMessageBox>
#include <QScriptEngineAgent>
#ifdef SCRIPT_DEBUG
#include <QScriptEngineDebugger>
#include <QAction>
#endif
class ErrorAgent : public QScriptEngineAgent {
public:
ErrorAgent(QScriptEngine* engine) : QScriptEngineAgent(engine) {}
void exceptionThrow(qint64 scriptId, const QScriptValue& exception,
bool hasHandler) override {
if (hasHandler) return;
QMessageBox mb(ngApp->window());
mb.setText(
QString("Script error (please send this to patch developers):\n%1")
.arg(exception.toString()));
mb.setDetailedText(engine()->currentContext()->backtrace().join('\n'));
mb.setWindowTitle("Script error");
mb.exec();
}
};
InstallerApplication::InstallerApplication(int& argc, char** argv)
: QApplication(argc, argv) {
// Despite Q_ENUM this is apparently required for use in signals
qRegisterMetaType<InstallerApplication::State>(
"InstallerApplication::State");
_currentState = State::Preparation;
if (!QResource::registerResource("userdata.rcc")) {
QMessageBox::critical(0, "Error",
"Could not load userdata.rcc (are you running "
"the installer out of its directory?)");
exit(1);
return;
}
w = new InstallerWindow(0);
// we do not set these globally so that we can have unthemed dialogs
w->setStyle(QStyleFactory::create("windows"));
QFile qssFile(":/kofuna/style.qss");
qssFile.open(QFile::ReadOnly | QFile::Text);
QTextStream ts(&qssFile);
w->setStyleSheet(ts.readAll());
h = new api::ApiHost(0);
_fs = new Fs(this);
#ifdef Q_OS_WIN32
_registry = new Registry(this);
#endif
_receipt = new ReceiptWriter(this);
_tx = new Transaction(this);
QFile scriptFile(":/userdata/script.js");
scriptFile.open(QFile::ReadOnly | QFile::Text);
QTextStream ts2(&scriptFile);
#ifdef SCRIPT_DEBUG
QScriptEngineDebugger* debugger = new QScriptEngineDebugger(this);
debugger->attachTo(h->engine());
debugger->action(QScriptEngineDebugger::InterruptAction)->trigger();
#else
ErrorAgent* agent = new ErrorAgent(h->engine());
h->engine()->setAgent(agent);
#endif
h->engine()->evaluate(ts2.readAll(), "script.js");
}
InstallerApplication::~InstallerApplication() {
if (w) delete w;
if (h) delete h;
}
void InstallerApplication::showWindow() { w->show(); }
| 29.414894
| 79
| 0.662929
|
CommitteeOfZero
|
97c48b8a9788a1ab9232e0d8f1621cfa722de560
| 99
|
hpp
|
C++
|
templates/include/Quote.hpp
|
mcqueen256/mql4dllft
|
2b918da25efa8056eca967e4d40d07487f030ee8
|
[
"MIT"
] | null | null | null |
templates/include/Quote.hpp
|
mcqueen256/mql4dllft
|
2b918da25efa8056eca967e4d40d07487f030ee8
|
[
"MIT"
] | 11
|
2017-07-11T22:26:44.000Z
|
2017-07-20T04:14:54.000Z
|
templates/include/Quote.hpp
|
mcqueen256/mql4dllft
|
2b918da25efa8056eca967e4d40d07487f030ee8
|
[
"MIT"
] | null | null | null |
#ifndef QUOTE_HPP
#define QUOTE_HPP
class Quote {
private:
public:
Quote();
~Quote();
};
#endif
| 9
| 17
| 0.686869
|
mcqueen256
|
97c5775757ddabd48f6c0aadaef9348ed40d34f0
| 7,770
|
cpp
|
C++
|
src/protocol/websocket/client.cpp
|
cysme/pump
|
d91cfdf3e09ebca1e90f0c1395a3b3fba1158a0c
|
[
"Apache-2.0"
] | 2
|
2020-07-16T04:57:40.000Z
|
2020-11-24T10:33:48.000Z
|
src/protocol/websocket/client.cpp
|
jimi36/pump
|
d91cfdf3e09ebca1e90f0c1395a3b3fba1158a0c
|
[
"Apache-2.0"
] | 2
|
2020-12-23T09:40:16.000Z
|
2021-03-03T09:49:36.000Z
|
src/protocol/websocket/client.cpp
|
cysme/pump
|
d91cfdf3e09ebca1e90f0c1395a3b3fba1158a0c
|
[
"Apache-2.0"
] | 3
|
2020-11-24T10:33:35.000Z
|
2021-04-19T01:53:24.000Z
|
/*
* Copyright (C) 2015-2018 ZhengHaiTao <ming8ren@163.com>
*
* 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.
*/
// Import std::find function
#include <algorithm>
#include "pump/transport/tcp_dialer.h"
#include "pump/transport/tls_dialer.h"
#include "pump/protocol/websocket/utils.h"
#include "pump/protocol/websocket/client.h"
namespace pump {
namespace protocol {
namespace websocket {
client::client(const std::string &url,
const std::map<std::string, std::string> &headers) noexcept
: started_(false),
sv_(nullptr),
is_upgraded_(false),
upgrade_url_(url),
upgrade_req_headers_(headers) {
}
bool client::start(service_ptr sv,const client_callbacks &cbs) {
// Check service.
if (!sv) {
return false;
}
// Check callbacks.
if (!cbs.started_cb ||!cbs.data_cb || !cbs.error_cb) {
return false;
}
// Set and check started state.
if (started_.exchange(true)) {
return false;
}
sv_ = sv;
cbs_ = cbs;
if (!__start()) {
return false;
}
return true;
}
void client::stop() {
// Set and check started state.
if (!started_.exchange(false)) {
return;
}
// Stop dialer.
if (dialer_ && dialer_->is_started()) {
dialer_->stop();
}
// Stop connection.
if (conn_ && conn_->is_valid()) {
conn_->stop();
}
}
bool client::send(const block_t *b, int32_t size) {
// Check started state.
if (!started_.load()) {
return false;
}
// Check connection.
if (!conn_ || !conn_->is_valid()) {
return false;
}
return conn_->send(b, size);
}
void client::on_dialed(client_wptr wptr,
transport::base_transport_sptr &transp,
bool succ) {
PUMP_LOCK_WPOINTER(cli, wptr);
if (cli) {
if (!succ) {
cli->cbs_.error_cb("client dial error");
return;
}
upgrade_callbacks ucbs;
ucbs.pocket_cb = pump_bind(&client::on_upgrade_response, wptr, _1);
ucbs.error_cb = pump_bind(&client::on_error, wptr, _1);
cli->conn_.reset(new connection(cli->sv_, transp, true));
if (cli->conn_->start_upgrade(true, ucbs)) {
cli->cbs_.error_cb("client transport start error");
return;
}
std::string data;
PUMP_ASSERT(cli->upgrade_req_);
cli->upgrade_req_->serialize(data);
if (!cli->conn_->send_buffer(data.c_str(), (int32_t)data.size())) {
cli->cbs_.error_cb("client connection send upgrade request error");
}
// Check started state
if (!cli->started_.load()) {
cli->conn_->stop();
}
}
}
void client::on_dial_timeouted(client_wptr wptr) {
PUMP_LOCK_WPOINTER(cli, wptr);
if (cli) {
cli->cbs_.error_cb("client dial timeouted");
}
}
void client::on_dial_stopped(client_wptr wptr) {
PUMP_LOCK_WPOINTER(cli, wptr);
if (cli) {
cli->cbs_.error_cb("client dial stopped");
}
}
void client::on_upgrade_response(client_wptr wptr, http::pocket_sptr pk) {
PUMP_LOCK_WPOINTER(cli, wptr);
if (cli) {
auto resp = std::static_pointer_cast<http::response>(pk);
if (!cli->__check_upgrade_response(resp)) {
cli->cbs_.error_cb("client connection upgrade response invalid");
return;
}
cli->cbs_.started_cb();
connection_callbacks cbs;
cbs.frame_cb = pump_bind(&client::on_frame, wptr, _1, _2, _3);
cbs.error_cb = pump_bind(&client::on_error, wptr, _1);
if (!cli->conn_->start(cbs)) {
cli->cbs_.error_cb("client connection start error");
}
}
}
void client::on_frame(client_wptr wptr, const block_t *b, int32_t size, bool end) {
PUMP_LOCK_WPOINTER(cli, wptr);
if (cli) {
cli->cbs_.data_cb(b, size, end);
}
}
void client::on_error(client_wptr wptr, const std::string &msg) {
PUMP_LOCK_WPOINTER(cli, wptr);
if (cli) {
cli->conn_.reset();
cli->cbs_.error_cb(msg);
}
}
bool client::__start() {
// Create upgrade request
upgrade_req_.reset(new http::request(upgrade_url_));
upgrade_req_->set_http_version(http::VERSION_11);
upgrade_req_->set_method(http::METHOD_GET);
for (auto &h : upgrade_req_headers_) {
upgrade_req_->set_head(h.first, h.second);
}
auto u = upgrade_req_->get_uri();
if (!upgrade_req_->has_head("Host")) {
upgrade_req_->set_unique_head("Host", u->get_host());
}
upgrade_req_->set_unique_head("Connection", "Upgrade");
upgrade_req_->set_unique_head("Upgrade", "websocket");
upgrade_req_->set_unique_head("Sec-WebSocket-Version", "13");
upgrade_req_->set_unique_head("Sec-WebSocket-Key", compute_sec_key());
// Init bind address
transport::address bind_address("0.0.0.0", 0);
// Create transport dialer
if (u->get_type() == http::URI_WSS) {
auto peer_address = http::host_to_address(true, u->get_host());
dialer_ = transport::tcp_dialer::create(bind_address, peer_address, 3000);
} else if (u->get_type() == http::URI_WS) {
auto peer_address = http::host_to_address(false, u->get_host());
dialer_ = transport::tls_dialer::create(bind_address, peer_address, 3000, 3000);
} else {
return false;
}
// Start transport dialer
transport::dialer_callbacks cbs;
cbs.dialed_cb = pump_bind(&client::on_dialed, shared_from_this(), _1, _2);
cbs.timeouted_cb = pump_bind(&client::on_dial_timeouted, shared_from_this());
cbs.stopped_cb = pump_bind(&client::on_dial_stopped, shared_from_this());
if (!dialer_->start(sv_, cbs)) {
return false;
}
return true;
}
bool client::__check_upgrade_response(http::response_sptr &resp) {
if (resp->get_status_code() != 101 ||
resp->get_http_version() != http::VERSION_11) {
return false;
}
std::string upgrade;
if (!resp->get_head("Upgrade", upgrade) || upgrade != "websocket") {
return false;
}
std::vector<std::string> connection;
if (!resp->get_head("Connection", connection) ||
std::find(connection.begin(), connection.end(), "Upgrade") ==
connection.end()) {
return false;
}
std::string sec_accept;
if (!resp->get_head("Sec-WebSocket-Accept", sec_accept)) {
return false;
}
return true;
}
} // namespace websocket
} // namespace protocol
} // namespace pump
| 31.714286
| 92
| 0.563964
|
cysme
|
97c76b6ded2d81f894df6d6bec179d34d02bd5ed
| 5,538
|
cpp
|
C++
|
packages/monte_carlo/event/estimator/test/tstSurfaceFluxEstimatorDagMC.cpp
|
bam241/FRENSIE
|
e1760cd792928699c84f2bdce70ff54228e88094
|
[
"BSD-3-Clause"
] | 10
|
2019-11-14T19:58:30.000Z
|
2021-04-04T17:44:09.000Z
|
packages/monte_carlo/event/estimator/test/tstSurfaceFluxEstimatorDagMC.cpp
|
bam241/FRENSIE
|
e1760cd792928699c84f2bdce70ff54228e88094
|
[
"BSD-3-Clause"
] | 43
|
2020-03-03T19:59:20.000Z
|
2021-09-08T03:36:08.000Z
|
packages/monte_carlo/event/estimator/test/tstSurfaceFluxEstimatorDagMC.cpp
|
bam241/FRENSIE
|
e1760cd792928699c84f2bdce70ff54228e88094
|
[
"BSD-3-Clause"
] | 6
|
2020-02-12T17:37:07.000Z
|
2020-09-08T18:59:51.000Z
|
//---------------------------------------------------------------------------//
//!
//! \file tstSurfaceFluxEstimatorDagMC.cpp
//! \author Alex Robinson
//! \brief Surface flux estimator using DagMC unit tests.
//!
//---------------------------------------------------------------------------//
// Std Lib Includes
#include <iostream>
// FRENSIE Includes
#include "MonteCarlo_SurfaceFluxEstimator.hpp"
#include "MonteCarlo_PhotonState.hpp"
#include "Geometry_DagMCModel.hpp"
#include "Utility_UnitTestHarnessWithMain.hpp"
//---------------------------------------------------------------------------//
// Testing Variables
//---------------------------------------------------------------------------//
std::shared_ptr<const Geometry::Model> model;
//---------------------------------------------------------------------------//
// Tests.
//---------------------------------------------------------------------------//
// Check that the surface areas can be extracted if a DagMC model is used
FRENSIE_UNIT_TEST_TEMPLATE( SurfaceFluxEstimator,
constructor,
MonteCarlo::WeightMultiplier,
MonteCarlo::WeightAndEnergyMultiplier,
MonteCarlo::WeightAndChargeMultiplier )
{
FETCH_TEMPLATE_PARAM( 0, ContributionMultiplierPolicy );
std::shared_ptr<MonteCarlo::Estimator> estimator;
std::vector<MonteCarlo::StandardSurfaceEstimator::SurfaceIdType>
surface_ids( {46, 53, 55, 57, 58, 83, 86, 89, 92, 425, 434} );
FRENSIE_REQUIRE_NO_THROW( estimator.reset( new MonteCarlo::SurfaceFluxEstimator<ContributionMultiplierPolicy>(
0u,
10.0,
surface_ids,
*model ) ) );
FRENSIE_REQUIRE( estimator->isEntityAssigned( 46 ) );
FRENSIE_CHECK_FLOATING_EQUALITY( estimator->getEntityNormConstant( 46 ),
2.848516339523823717e+02,
1e-15 );
FRENSIE_REQUIRE( estimator->isEntityAssigned( 53 ) );
FRENSIE_CHECK_FLOATING_EQUALITY( estimator->getEntityNormConstant( 53 ),
9.773235727898624248e+01,
1e-15 );
FRENSIE_REQUIRE( estimator->isEntityAssigned( 55 ) );
FRENSIE_CHECK_FLOATING_EQUALITY( estimator->getEntityNormConstant( 55 ),
1.666730003051475251e+01,
1e-15 );
FRENSIE_REQUIRE( estimator->isEntityAssigned( 57 ) );
FRENSIE_CHECK_FLOATING_EQUALITY( estimator->getEntityNormConstant( 57 ),
2.594277176251208061e+02,
1e-15 );
FRENSIE_REQUIRE( estimator->isEntityAssigned( 58 ) );
FRENSIE_CHECK_FLOATING_EQUALITY( estimator->getEntityNormConstant( 58 ),
3.715085987553494107e+01,
1e-15 );
FRENSIE_REQUIRE( estimator->isEntityAssigned( 83 ) );
FRENSIE_CHECK_FLOATING_EQUALITY( estimator->getEntityNormConstant( 83 ),
6.714270351030512529e+01,
1e-15 );
FRENSIE_REQUIRE( estimator->isEntityAssigned( 86 ) );
FRENSIE_CHECK_FLOATING_EQUALITY( estimator->getEntityNormConstant( 86 ),
3.165650076907713384e-01,
1e-15 );
FRENSIE_REQUIRE( estimator->isEntityAssigned( 89 ) );
FRENSIE_CHECK_FLOATING_EQUALITY( estimator->getEntityNormConstant( 89 ),
3.165650076907712274e-01,
1e-15 );
FRENSIE_REQUIRE( estimator->isEntityAssigned( 92 ) );
FRENSIE_CHECK_FLOATING_EQUALITY( estimator->getEntityNormConstant( 92 ),
3.165650076907711163e-01,
1e-15 );
FRENSIE_REQUIRE( estimator->isEntityAssigned( 425 ) );
FRENSIE_CHECK_FLOATING_EQUALITY( estimator->getEntityNormConstant( 425 ),
8.970071513450820433,
1e-15 );
FRENSIE_REQUIRE( estimator->isEntityAssigned( 434 ) );
FRENSIE_CHECK_FLOATING_EQUALITY( estimator->getEntityNormConstant( 434 ),
4.002587201643236448,
1e-15 );
}
//---------------------------------------------------------------------------//
// Custom setup
//---------------------------------------------------------------------------//
FRENSIE_CUSTOM_UNIT_TEST_SETUP_BEGIN();
std::string test_dagmc_geom_file_name;
FRENSIE_CUSTOM_UNIT_TEST_COMMAND_LINE_OPTIONS()
{
ADD_STANDARD_OPTION_AND_ASSIGN_VALUE( "test_cad_file",
test_dagmc_geom_file_name, "",
"Test CAD file name" );
}
FRENSIE_CUSTOM_UNIT_TEST_INIT()
{
Geometry::DagMCModelProperties local_properties( test_dagmc_geom_file_name );
local_properties.setTerminationCellPropertyName( "graveyard" );
local_properties.setMaterialPropertyName( "mat" );
local_properties.setDensityPropertyName( "rho" );
local_properties.setEstimatorPropertyName( "tally" );
model.reset( new Geometry::DagMCModel( local_properties ) );
}
FRENSIE_CUSTOM_UNIT_TEST_SETUP_END();
//---------------------------------------------------------------------------//
// end tstSurfaceFluxEstimatorDagMC.cpp
//---------------------------------------------------------------------------//
| 41.328358
| 112
| 0.524016
|
bam241
|
97c7fe1215edf4b42686f017ef6d2281e3ab6088
| 22,669
|
cpp
|
C++
|
apc_grasping/src/fill_bins_and_tote.cpp
|
Juxi/apb-baseline
|
fd47a5fd78cdfd75c68601a40ca4726d7d20c9ce
|
[
"BSD-3-Clause"
] | 9
|
2017-02-06T10:24:56.000Z
|
2022-02-27T20:59:52.000Z
|
apc_grasping/src/fill_bins_and_tote.cpp
|
Juxi/apb-baseline
|
fd47a5fd78cdfd75c68601a40ca4726d7d20c9ce
|
[
"BSD-3-Clause"
] | null | null | null |
apc_grasping/src/fill_bins_and_tote.cpp
|
Juxi/apb-baseline
|
fd47a5fd78cdfd75c68601a40ca4726d7d20c9ce
|
[
"BSD-3-Clause"
] | 2
|
2017-10-15T08:33:37.000Z
|
2019-03-05T07:29:38.000Z
|
/*
Copyright 2016 Australian Centre for Robotic Vision
*/
#include <geometry_msgs/Pose.h>
#include <ros/ros.h>
#include <moveit_msgs/CollisionObject.h>
#include <moveit_msgs/PlanningScene.h>
#include <apc_msgs/FillUnfillBinsCollisionModel.h>
#include <std_srvs/SetBool.h>
#include <std_srvs/Trigger.h>
#include <xmlrpc.h>
#include <tf/tf.h>
#include <tf/transform_datatypes.h>
#include <tf/transform_broadcaster.h>
std::vector<std::string> BINS = {
"bin_A", "bin_B", "bin_C", "bin_D", "bin_E", "bin_F",
"bin_G", "bin_H", // "bin_I", "bin_J", "bin_K", "bin_L",
};
double SHELF_LIP_THICKNESS = 0.0;
tf::Transform tote_tf;
bool publish_tf = false;
bool tf_published = false;
tf::TransformBroadcaster *br;
class CollisionInterface {
private:
std::string planning_scene_topic_;
XmlRpc::XmlRpcValue shelf_layout_;
XmlRpc::XmlRpcValue tote_information_;
bool tote_on_;
bool pillar_on_;
ros::Publisher planning_scene_publisher_;
ros::NodeHandle nh_;
std::string current_bin;
public:
// Constuctor
CollisionInterface() {
ROS_INFO("[Constructor] we need a node handle at least...");
exit(1);
}
CollisionInterface(ros::NodeHandle& nh, std::string scene_topic) {
nh_ = nh;
planning_scene_topic_ = scene_topic;
init();
}
CollisionInterface(ros::NodeHandle& nh) {
nh_ = nh;
init();
}
~CollisionInterface() {}
// create and advertise the publisher to the planning scene
void createPublisher() {
planning_scene_publisher_ = nh_.advertise<moveit_msgs::PlanningScene>(
planning_scene_topic_.c_str(), 1);
}
// get shelf layout from parameter server
void getShelfLayout() {
nh_.getParam("shelf_layout", shelf_layout_);
}
// get tote information from parameter server
void getToteInformation() {
nh_.getParam("tote_information", tote_information_);
}
// initialise various bits and pieces
void init() {
tote_on_ = false;
pillar_on_ = false;
createPublisher();
getShelfLayout();
getToteInformation();
}
// setters and getters
std::string getPlanningSceneTopic() {
return planning_scene_topic_;
}
void setPlanningSceneTopic(std::string scene_topic) {
planning_scene_topic_ = scene_topic;
}
int getNumSubscribers() {
return planning_scene_publisher_.getNumSubscribers();
}
bool toggleLipFillbox(std_srvs::SetBool::Request & req,
std_srvs::SetBool::Response& res) {
// getShelfLayout();
// std::string bin_name = current_bin;
// moveit_msgs::PlanningScene planning_scene_diff;
//
// if (req.data) {
// moveit_msgs::CollisionObject collision_object;
//
// collision_object.operation = moveit_msgs::CollisionObject::ADD;
//
// shape_msgs::SolidPrimitive primitive;
// primitive.type = primitive.BOX;
//
// geometry_msgs::Pose pose;
//
// planning_scene_diff.is_diff = true;
//
// planning_scene_diff.world.collision_objects.clear();
//
// double side_h = 0.08;
// double side_w = shelf_layout_[bin_name]["bin_width"];
// double side_d = 0.05;
// collision_object.id = bin_name + "_lip_fillbox";
// collision_object.header.frame_id = bin_name;
// primitive.dimensions = { side_h, side_w, side_d };
// collision_object.primitives.clear();
// collision_object.primitives.push_back(primitive);
// collision_object.primitive_poses.clear();
// setGeometry(pose, side_h, -1.0 * side_w, -1.0 * side_d);
// double bin_height = shelf_layout_[bin_name]["bin_height"];
// pose.position.x += bin_height - 0.04;
// ROS_INFO_STREAM(pose);
// collision_object.primitive_poses.push_back(pose);
// ROS_INFO_STREAM(collision_object);
// planning_scene_diff.world.collision_objects.push_back(
// collision_object);
// } else {
// moveit_msgs::CollisionObject detach_object;
// detach_object.operation = moveit_msgs::CollisionObject::REMOVE;
// moveit_msgs::PlanningScene planning_scene;
// planning_scene_diff.is_diff = true;
// planning_scene_diff.world.collision_objects.clear();
//
// detach_object.id = current_bin + "_lip_fillbox";
//
// ROS_INFO_STREAM(detach_object.id);
// detach_object.header.frame_id = current_bin;
// ROS_INFO_STREAM(detach_object);
// planning_scene_diff.world.collision_objects.push_back(
// detach_object);
// }
try {
// planning_scene_publisher_.publish(planning_scene_diff);
res.success = true;
return true;
// if any errors, return unsuccessful, should probably handle this
// better
} catch (...) {
res.success = false;
return false;
}
}
bool fillBins(apc_msgs::FillUnfillBinsCollisionModel::Request & req,
apc_msgs::FillUnfillBinsCollisionModel::Response& res) {
getShelfLayout();
// in case unfill not previously called, remove box in current bin
std_srvs::Trigger unfillSrvMsg;
if (!unfillBins(unfillSrvMsg.request, unfillSrvMsg.response)) {
ROS_INFO_STREAM("Unable to remove previous collision objects");
res.success.data = false;
return true;
}
if (req.bin_id.data.empty()) {
ROS_INFO_STREAM("No bin_id provided!");
res.success.data = false;
return true;
}
std::string bin_name = req.bin_id.data;
current_bin = bin_name;
// create a collision object to be used to fill bins
moveit_msgs::CollisionObject collision_object;
collision_object.operation = moveit_msgs::CollisionObject::ADD;
moveit_msgs::PlanningScene planning_scene_diff;
geometry_msgs::Pose pose;
planning_scene_diff.is_diff = true;
planning_scene_diff.world.collision_objects.clear();
double side_h = 0.04;
double side_w = shelf_layout_[bin_name]["bin_width"];
double side_d = 0.5;
collision_object.id = bin_name + "_fillbox";
collision_object.header.frame_id = bin_name;
shape_msgs::SolidPrimitive primitive;
primitive.type = primitive.BOX;
primitive.dimensions = { side_h, side_w, side_d };
collision_object.primitives.push_back(primitive);
collision_object.primitive_poses.clear();
setGeometry(pose, -1.0 * side_h, -1.0 * side_w, side_d);
pose.position.x += SHELF_LIP_THICKNESS;
collision_object.primitive_poses.push_back(pose);
planning_scene_diff.world.collision_objects.push_back(collision_object);
// lip fillbox
// side_h = 0.08;
// side_w =
// shelf_layout_[bin_name]["bin_width"];
// side_d = 0.05;
// collision_object.id = bin_name + "_lip_fillbox";
// collision_object.header.frame_id = bin_name;
// primitive.dimensions = { side_h, side_w, side_d };
// collision_object.primitives.clear();
// collision_object.primitives.push_back(primitive);
// collision_object.primitive_poses.clear();
// setGeometry(pose, side_h, -1.0 * side_w, -1.0 * side_d);
// double bin_height = shelf_layout_[bin_name]["bin_height"];
// pose.position.x += bin_height - 0.04;
// ROS_INFO_STREAM(pose);
// collision_object.primitive_poses.push_back(pose);
// ROS_INFO_STREAM(collision_object);
// planning_scene_diff.world.collision_objects.push_back(collision_object);
// generate collision objects within shelves
for (int i = 0; i < 8; i++) {
if (BINS[i] == bin_name) continue;
collision_object.id = BINS[i] + "_fillbox";
collision_object.header.frame_id = BINS[i];
fillCollisionModel(collision_object, i);
planning_scene_diff.world.collision_objects.push_back(
collision_object);
}
// thicken left wall of shelf
side_h = 0.351 * 4;
side_w = 0.05;
side_d = 0.5;
collision_object.id = "left_fillbox";
collision_object.header.frame_id = "/bin_A";
collision_object.primitives[0].dimensions.clear();
collision_object.primitives[0].dimensions = { side_h, side_w, side_d };
collision_object.primitive_poses.clear();
setGeometry(pose, side_h, side_w, side_d);
collision_object.primitive_poses.push_back(pose);
planning_scene_diff.world.collision_objects.push_back(collision_object);
// thicken right wall of shelf
setGeometry(pose, side_h, -1.0 * side_w, side_d);
collision_object.id = "right_fillbox";
collision_object.header.frame_id = "/bin_B";
collision_object.primitive_poses.clear();
double offset = shelf_layout_["bin_B"]["bin_width"];
pose.position.y -= offset;
collision_object.primitive_poses.push_back(pose);
planning_scene_diff.world.collision_objects.push_back(collision_object);
// thicken top of shelf
side_h = 0.05;
side_w = 0.351 * 2;
side_d = 0.5;
setGeometry(pose, -1.0 * side_h, -1.0 * side_w, side_d);
collision_object.id = "top_fillbox";
collision_object.header.frame_id = "/bin_A";
collision_object.primitives[0].dimensions.clear();
collision_object.primitives[0].dimensions = { side_h, side_w, side_d };
collision_object.primitive_poses.clear();
collision_object.primitive_poses.push_back(pose);
planning_scene_diff.world.collision_objects.push_back(collision_object);
// // thicken botto lip
// setGeometry(pose, side_h, -1.0 * side_w, side_d);
// offset =
// shelf_layout_["bin_J"]["bin_height"];
// pose.position.x += offset;
// collision_object.id = "bottom_fillbox";
// collision_object.header.frame_id = "/bin_J";
// collision_object.primitives[0].dimensions.clear();
// collision_object.primitives[0].dimensions = { side_h, side_w, side_d
// };
// collision_object.primitive_poses.clear();
// collision_object.primitive_poses.push_back(pose);
// planning_scene_diff.world.collision_objects.push_back(collision_object);
ROS_INFO("[fillBins] filling all bins except %s", bin_name.c_str());
// publish scene
try {
planning_scene_publisher_.publish(planning_scene_diff);
res.success.data = true;
} catch (...) {
res.success.data = false;
}
ROS_INFO("Bins filled!");
return true;
}
void fillCollisionModel(moveit_msgs::CollisionObject& obj, int bin_id) {
geometry_msgs::Pose pose;
shape_msgs::SolidPrimitive primitive;
primitive.type = primitive.BOX;
ROS_INFO_STREAM("YOOOOOO bin_id is: " << bin_id);
double height = shelf_layout_[BINS[bin_id]]["bin_height"];
double width = shelf_layout_[BINS[bin_id]]["bin_width"];
double depth = 0.5;
// use bin row heights and column widths
primitive.dimensions = { height, width, depth };
setGeometry(pose, height, -1.0 * width, depth);
obj.primitives.clear();
obj.primitive_poses.clear();
obj.primitives.push_back(primitive);
obj.primitive_poses.push_back(pose);
}
// add appropriate offset with respect to bin TFs
void setGeometry(geometry_msgs::Pose& pose, double x, double y, double z) {
pose.position.x = x;
pose.position.x /= 2.0f;
pose.position.x -= SHELF_LIP_THICKNESS;
pose.position.y = y;
pose.position.y /= 2.0f;
pose.position.z = z;
pose.position.z /= 2.0f;
}
void loadCollisionGeometry(int id, geometry_msgs::Pose& pose,
shape_msgs::SolidPrimitive& primitive) {
ROS_ERROR("loadCollisionGeometry() not implemented yet.");
}
// remove all bin fills and wall thickeners
bool unfillBins(std_srvs::Trigger::Request & req,
std_srvs::Trigger::Response& res) {
getShelfLayout();
moveit_msgs::CollisionObject detach_object;
detach_object.operation = moveit_msgs::CollisionObject::REMOVE;
moveit_msgs::PlanningScene planning_scene;
planning_scene.is_diff = true;
planning_scene.world.collision_objects.clear();
// remove all bin fillers
for (int i = 0; i < 8; i++) {
detach_object.id = BINS[i] + "_fillbox";
detach_object.header.frame_id = BINS[i];
planning_scene.world.collision_objects.push_back(detach_object);
detach_object.id = BINS[i] + "_lip_fillbox";
detach_object.header.frame_id = BINS[i];
planning_scene.world.collision_objects.push_back(detach_object);
}
// remove wall thickeners
detach_object.id = "left_fillbox";
detach_object.header.frame_id = "bin_A";
planning_scene.world.collision_objects.push_back(detach_object);
detach_object.id = "top_fillbox";
planning_scene.world.collision_objects.push_back(detach_object);
detach_object.id = "right_fillbox";
detach_object.header.frame_id = "bin_C";
planning_scene.world.collision_objects.push_back(detach_object);
// detach_object.id = "bottom_fillbox";
// detach_object.header.frame_id = "bin_J";
// planning_scene.world.collision_objects.push_back(detach_object);
// publish object removals
try {
planning_scene_publisher_.publish(planning_scene);
res.success = true;
ROS_INFO_STREAM("Bin fill collision objects removed!");
} catch (...) {
res.success = false;
}
return true;
}
// add and remove the tote and tote pillar
bool moveTote(apc_msgs::FillUnfillBinsCollisionModel::Request & req,
apc_msgs::FillUnfillBinsCollisionModel::Response& res) {
// Get the pose of the tote with respect to torso from the parameter
// server
XmlRpc::XmlRpcValue tote = tote_information_["tote"];
geometry_msgs::Pose tote_pose;
double pos_x = tote["position_x"];
double box_x = tote["box_x"];
double pos_y = tote["position_y"];
double box_y = tote["box_y"];
double pos_z = tote["position_z"];
double box_z = tote["box_z"];
tote_pose.position.x = pos_x;
tote_pose.position.y = pos_y;
tote_pose.position.z = pos_z;
tf::Quaternion tote_orientation;
tote_orientation.setRPY(((double)tote["orientation_roll"]),
((double)tote["orientation_pitch"]),
((double)tote["orientation_yaw"]));
tf::quaternionTFToMsg(tote_orientation, tote_pose.orientation);
tf::poseMsgToTF(tote_pose, tote_tf);
geometry_msgs::Pose not_tote_pose;
not_tote_pose.position.x = box_x / 2.0;
not_tote_pose.position.y = box_y / 2.0;
not_tote_pose.position.z = -box_z / 2.0;
not_tote_pose.orientation.x = 0.0;
not_tote_pose.orientation.y = 0.0;
not_tote_pose.orientation.z = 0.0;
not_tote_pose.orientation.w = 1.0;
tf::Transform not_tote_tf;
tf::poseMsgToTF(not_tote_pose, not_tote_tf);
not_tote_tf = tote_tf * not_tote_tf;
tf::poseTFToMsg(not_tote_tf, not_tote_pose);
publish_tf = true;
bool tote_on = false;
bool pillar_on = false;
moveit_msgs::CollisionObject obj;
obj.header.frame_id = "/torso"; // Always publish with respect to torso
tote_on = tote_on_;
pillar_on = pillar_on_;
if (req.bin_id.data == "tote_on") {
ROS_INFO_STREAM("tote_on");
tote_on = true;
} else if (req.bin_id.data == "tote_off") {
ROS_INFO_STREAM("tote_off");
tote_on = false;
} else if (req.bin_id.data == "pillar_on") {
ROS_INFO_STREAM("pillar_on");
pillar_on = true;
} else if (req.bin_id.data == "pillar_off") {
ROS_INFO_STREAM("pillar_off");
pillar_on = false;
} else if (req.bin_id.data == "all_on") {
ROS_INFO_STREAM("all_on");
tote_on = true;
pillar_on = true;
} else if (req.bin_id.data == "all_off") {
ROS_INFO_STREAM("all_off");
tote_on = false;
pillar_on = false;
}
moveit_msgs::PlanningScene planning_scene;
planning_scene.world.collision_objects.clear();
planning_scene.is_diff = true;
nh_.getParam("tote_information", tote_information_);
// geometry_msgs::Pose pose;
shape_msgs::SolidPrimitive primitive;
primitive.type = primitive.BOX;
if (tote_on) {
obj.id = "tote";
obj.operation = moveit_msgs::CollisionObject::ADD;
// add tote
// dimensions
primitive.dimensions = { box_x, box_y,
box_z };
// // position
// tote_pose.position.x = pos_x +
// box_x*sin((double)tote["orientation_yaw"]) / 2.0;
// tote_pose.position.y = pos_y +
// box_y*sin((double)tote["orientation_yaw"]) / 2.0;
// tote_pose.position.z = pos_z - box_z / 2.0;
ROS_INFO_STREAM("Tote position: " << not_tote_pose);
// add obj to scene
obj.primitives.push_back(primitive);
obj.primitive_poses.push_back(not_tote_pose);
planning_scene.world.collision_objects.push_back(obj);
ROS_INFO_STREAM("Tote added to Collision Scene!");
} else {
obj.id = "tote";
obj.operation = moveit_msgs::CollisionObject::REMOVE;
planning_scene.world.collision_objects.push_back(obj);
ROS_INFO_STREAM("Tote removed from Collision Scene!");
}
obj.primitives.clear();
obj.primitive_poses.clear();
if (pillar_on) {
// obj.id = "tote_pillar";
// obj.operation = moveit_msgs::CollisionObject::ADD;
// // add tote_pillar
// XmlRpc::XmlRpcValue tote_pillar =
// tote_information_["tote_pillar"];
// // dimensions
// primitive.dimensions = {tote_pillar["box_x"],
// tote_pillar["box_y"],
// tote_pillar["box_z"]};
// // position
// pose.position.x = -((double)tote_pillar["position_x"]) / 2.0;
// pose.position.y = -((double)tote_pillar["position_y"]) / 2.0;
// pose.position.z = ((double)tote_pillar["position_z"]) / 2.0 +
// ((double)tote["box_z"]) / 2.0;
// // add obj to scene
// obj.id = "tote_pillar";
// obj.primitives.push_back(primitive);
// obj.primitive_poses.push_back(pose);
// planning_scene.world.collision_objects.push_back(obj);
// ROS_INFO_STREAM("Tote pillar added to Collision Scene!");
// if tote is in place, remove from scene
} else {
// obj.id = "tote_pillar";
// obj.operation = moveit_msgs::CollisionObject::REMOVE;
// planning_scene.world.collision_objects.push_back(obj);
// ROS_INFO_STREAM("Tote pillar removed from Collision Scene!");
}
// publish scene
try {
planning_scene_publisher_.publish(planning_scene);
res.success.data = true;
tote_on_ = tote_on;
pillar_on_ = pillar_on;
// if any errors, return unsuccessful, should probably handle this
// better
} catch (...) {
res.success.data = false;
return false;
}
return true;
}
};
int main(int argc, char **argv) {
ros::init(argc, argv, "fill_bins_and_tote");
ROS_INFO("Starting bin filling and tote placement node!");
ros::AsyncSpinner spinner(1);
spinner.start();
ros::NodeHandle node_hdl;
br = new tf::TransformBroadcaster();
std::string scene_topic;
node_hdl.param<std::string>("apc_planning_scene_topic", scene_topic,
"planning_scene");
CollisionInterface object_collision_service(node_hdl, scene_topic);
// Advertise Services to be used (and implementd here)
ros::ServiceServer srv_attach_ = node_hdl.advertiseService(
"apc_grasping/fill_bins", &CollisionInterface::fillBins,
&object_collision_service);
ros::ServiceServer srv_detach_ = node_hdl.advertiseService(
"apc_grasping/unfill_bins", &CollisionInterface::unfillBins,
&object_collision_service);
ros::ServiceServer srv_tote_inplace_ = node_hdl.advertiseService(
"apc_grasping/move_tote", &CollisionInterface::moveTote,
&object_collision_service);
ros::ServiceServer srv_toggle_lipfillbox_ = node_hdl.advertiseService(
"apc_grasping/toggle_lip", &CollisionInterface::toggleLipFillbox,
&object_collision_service);
ROS_INFO(
"fill_bins_and_tote node started! ready to add toggle collision "
"objects to the scene...");
while (ros::ok()) {
if (publish_tf) {
br->sendTransform(tf::StampedTransform(tote_tf, ros::Time::now(),
"torso", "tote"));
tf_published = true;
}
ros::spinOnce();
}
ros::shutdown();
return 0;
}
| 37.908027
| 83
| 0.5961
|
Juxi
|
97c9998964e85bfb4e70b1f99c3c4b490be2c22a
| 235
|
cpp
|
C++
|
docs/mfc/reference/codesnippet/CPP/cmfcpopupmenu-class_2.cpp
|
jmittert/cpp-docs
|
cea5a8ee2b4764b2bac4afe5d386362ffd64e55a
|
[
"CC-BY-4.0",
"MIT"
] | 14
|
2018-01-28T18:10:55.000Z
|
2021-11-16T13:21:18.000Z
|
docs/mfc/reference/codesnippet/CPP/cmfcpopupmenu-class_2.cpp
|
jmittert/cpp-docs
|
cea5a8ee2b4764b2bac4afe5d386362ffd64e55a
|
[
"CC-BY-4.0",
"MIT"
] | null | null | null |
docs/mfc/reference/codesnippet/CPP/cmfcpopupmenu-class_2.cpp
|
jmittert/cpp-docs
|
cea5a8ee2b4764b2bac4afe5d386362ffd64e55a
|
[
"CC-BY-4.0",
"MIT"
] | 2
|
2018-10-10T07:37:30.000Z
|
2019-06-21T15:18:07.000Z
|
CMFCPopupMenu* pPopupMenu = new CMFCPopupMenu;
// CPoint point
// CMenu* pPopup
// The this pointer points to CMainFrame class which extends the CFrameWnd class.
pPopupMenu->Create (this, point.x, point.y, pPopup->Detach ());
| 47
| 83
| 0.72766
|
jmittert
|
97cd01b4141bf5cca6925538f0cc7b863578db68
| 4,656
|
cpp
|
C++
|
src/generate-random-inputs-euclidean.cpp
|
maumueller/random-inputs
|
12d876dfbf06a54af3e876123905a082b41e04dc
|
[
"MIT"
] | 1
|
2019-07-31T07:33:26.000Z
|
2019-07-31T07:33:26.000Z
|
src/generate-random-inputs-euclidean.cpp
|
maumueller/random-inputs
|
12d876dfbf06a54af3e876123905a082b41e04dc
|
[
"MIT"
] | null | null | null |
src/generate-random-inputs-euclidean.cpp
|
maumueller/random-inputs
|
12d876dfbf06a54af3e876123905a082b41e04dc
|
[
"MIT"
] | null | null | null |
/**
* @file generate-random-inputs-euclidean.cpp
* @author Martin Aumüller
*
*/
#include <algorithm>
#include <cmath>
#include <random>
#include <utility>
#include <fstream>
#include <iostream>
#include <set>
#include <tclap/CmdLine.h>
std::random_device rd;
std::mt19937_64 gen(rd());
std::normal_distribution<double> distribution(0.0, 1.0);
using vecType = std::vector<double>;
double length(const vecType& v) {
double t = 0.0;
for (auto e: v) {
t += e * e;
}
return sqrt(t);
}
void normalize(vecType& v) {
auto len = length(v);
for (size_t i = 0; i < v.size(); i++) {
v[i] /= len;
}
}
vecType generateRandomVector(size_t d, bool unit) {
vecType v(d);
for (size_t i = 0; i < d; i++)
v[i] = distribution(gen) / sqrt(d);
if (unit)
normalize(v);
return v;
}
vecType distortPoint(const vecType& v, float targetDistance, bool unit) {
size_t d = v.size();
vecType w(d);
for (size_t i = 0; i < d; i++)
w[i] = v[i] + distribution(gen) * targetDistance/sqrt(d);
if (unit)
normalize(w);
return w;
}
template <typename T>
void writeFile(std::string filename, std::set<T>& set) {
std::ofstream outputFile;
outputFile.open(filename);
for (auto& q: set) {
for (auto& e: q) {
outputFile << e << " ";
}
outputFile << std::endl;
}
outputFile.close();
}
int main(int argc, char** argv) {
TCLAP::CmdLine cmd("This program generates random inputs in Euclidean space.", ' ', "0.9");
TCLAP::ValueArg<size_t> numberOfPointsArg("n", "numpoints", "Total number of points", true, 10, "integer");
TCLAP::ValueArg<size_t> numberOfDimensionsArg("d", "dimension", "Number of dimensions", true, 15, "integer");
TCLAP::ValueArg<size_t> numberOfClusters("c", "numclusters", "Number of clusters", true, 15, "integer");
TCLAP::ValueArg<size_t> pointsPerCluster("p", "pointscluster", "Number of points per cluster", true, 15, "integer");
TCLAP::ValueArg<std::string> outputFileArg("o", "outputfile", "File the output should be written to. ", true, "input.txt", "string");
TCLAP::ValueArg<std::string> queryOutFileArg("q", "queryoutfile", "File the query set should be written to. ", true, "input.txt", "string");
TCLAP::ValueArg<size_t> seedArg("s", "seed", "Seed for random generator", false, 1234, "integer");
TCLAP::SwitchArg randomQueryArg("g", "randomqueries", "Should random query points (without close neighbors) be added?");
TCLAP::SwitchArg normalizeArg("N", "normalize", "Normalize vectors to unit length?");
cmd.add(numberOfPointsArg);
cmd.add(numberOfDimensionsArg);
cmd.add(numberOfClusters);
cmd.add(pointsPerCluster);
cmd.add(outputFileArg);
cmd.add(queryOutFileArg);
cmd.add(seedArg);
cmd.add(randomQueryArg);
cmd.add(normalizeArg);
cmd.parse(argc, argv);
auto d = numberOfDimensionsArg.getValue();
auto n = numberOfPointsArg.getValue();
auto numClusters = numberOfClusters.getValue();
auto numPoints = pointsPerCluster.getValue();
size_t numNoisePoints = 2 * numPoints;
bool unit = normalizeArg.isSet();
if (seedArg.isSet()) {
gen.seed(seedArg.getValue());
}
std::set<vecType> set;
std::set<vecType> querySet;
for (size_t i = 0; i < numClusters; i++) {
querySet.insert(generateRandomVector(d, unit));
}
std::cout << "Generated " << querySet.size() << " clusters ... " << std::endl;
double windowSize = sqrt(2) / (3.0 * numClusters);
int curQuery = 0;
for (auto& q: querySet) {
curQuery++;
double targetDistance = curQuery * windowSize;
// Compute points at target distance around query.
for (size_t i = 0; i < numPoints; i++) {
set.insert(distortPoint(q, targetDistance, unit));
}
// Compute some noise.
targetDistance *= 2;
for (size_t i = 0; i < numNoisePoints; i++) {
set.insert(distortPoint(q, targetDistance, unit));
}
}
// Add random query points
if (randomQueryArg.isSet()) {
for (size_t i = 0; i < numClusters; i++) {
querySet.insert(generateRandomVector(d, unit));
}
}
std::cout << "Created clusters with a total number of " << set.size() << " points." << std::endl;
std::cout << "Fill with random points..." << std::endl;
// Fill with random points
while (set.size() < n) {
set.insert(generateRandomVector(d, unit));
}
std::cout << "Writing result to file" << std::endl;
writeFile(outputFileArg.getValue(), set);
writeFile(queryOutFileArg.getValue(), querySet);
return 0;
}
| 30.03871
| 141
| 0.624785
|
maumueller
|
97ce52b8c973ca389d67b354274bf9b4de93785e
| 23,632
|
cpp
|
C++
|
src/clustering/louvain.cpp
|
zlthinker/STBA
|
c0034d67018c9b7a72459821e9e9ad46870b6292
|
[
"MIT"
] | 175
|
2020-08-02T11:48:11.000Z
|
2022-02-28T04:54:36.000Z
|
src/clustering/louvain.cpp
|
zlthinker/STBA
|
c0034d67018c9b7a72459821e9e9ad46870b6292
|
[
"MIT"
] | 1
|
2020-10-02T08:42:11.000Z
|
2020-10-02T08:42:11.000Z
|
src/clustering/louvain.cpp
|
zlthinker/STBA
|
c0034d67018c9b7a72459821e9e9ad46870b6292
|
[
"MIT"
] | 25
|
2020-08-02T13:04:15.000Z
|
2022-02-28T04:54:28.000Z
|
#include "STBA/clustering/louvain.h"
#include "STBA/utility.h"
#include <queue>
#include <chrono>
#include <unordered_map>
#include <iostream>
size_t RandomPick(std::unordered_map<size_t, double> const & prob_map)
{
assert(!prob_map.empty());
double sum = 0.0;
std::unordered_map<size_t, double>::const_iterator it = prob_map.begin();
for (; it != prob_map.end(); it++)
{
sum += it->second;
}
double r = ((double) rand() / (RAND_MAX)) * sum;
double accu_sum = 0.0;
it = prob_map.begin();
size_t index = it->first;
for (; it != prob_map.end(); it++)
{
accu_sum += it->second;
if (accu_sum >= r)
{
index = it->first;
break;
}
}
return index;
}
Louvain::Louvain() : max_community_(std::numeric_limits<size_t>::max()), temperature_(10.0)
{
}
Louvain::Louvain(std::vector<size_t> const & nodes,
std::unordered_map<size_t, std::unordered_map<size_t, double> > const & edges)
: max_community_(std::numeric_limits<size_t>::max()), temperature_(10.0)
{
Initialize(nodes, edges);
}
Louvain::Louvain(std::vector<size_t> const & nodes,
std::vector<std::pair<size_t, size_t> > const & edges)
: max_community_(std::numeric_limits<size_t>::max()), temperature_(10.0)
{
Initialize(nodes, edges);
}
Louvain::~Louvain()
{
}
void Louvain::Initialize(std::vector<size_t> const & nodes,
std::vector<std::pair<size_t, size_t> > const & edges)
{
size_t node_num = nodes.size();
graph_.Resize(node_num);
node_graph_.Resize(node_num);
node_map_.resize(node_num);
community_map_.resize(node_num);
community_size_.resize(node_num);
community_in_weight_.resize(node_num);
community_total_weight_.resize(node_num);
std::unordered_map<size_t, size_t> node_index_map;
for (size_t i = 0; i < node_num; i++)
{
node_index_map[nodes[i]] = i;
double node_weight = 0.0;
graph_.AddSelfEdge(node_weight);
node_graph_.AddSelfEdge(node_weight);
node_map_[i] = i;
community_map_[i] = i;
community_size_[i] = 1;
community_in_weight_[i] = node_weight * 2;
community_total_weight_[i] = node_weight * 2;
}
sum_edge_weight_ = 0.0;
for (size_t i = 0; i < edges.size(); i++)
{
std::pair<size_t, size_t> const & edge = edges[i];
size_t index1 = edge.first;
size_t index2 = edge.second;
assert(node_index_map.find(index1) != node_index_map.end());
assert(node_index_map.find(index2) != node_index_map.end());
size_t node_index1 = node_index_map[index1];
size_t node_index2 = node_index_map[index2];
if (node_index1 > node_index2) continue;
double weight = 1.0;
graph_.AddUndirectedEdge(node_index1, node_index2, weight);
node_graph_.AddUndirectedEdge(node_index1, node_index2, weight);
sum_edge_weight_ += 2 * weight;
community_total_weight_[node_index1] += weight;
community_total_weight_[node_index2] += weight;
}
double avg_weight = sum_edge_weight_ / edges.size();
for (size_t i = 0; i < node_num; i++)
{
node_graph_.AddSelfEdge(i, avg_weight);
graph_.AddSelfEdge(i, avg_weight);
}
std::cout << "------------------ Build graph --------------------\n"
<< "# nodes: " << graph_.NodeNum() << ", # edges: " << edges.size() << "\n"
<< "---------------------------------------------------\n";
}
void Louvain::Initialize(std::vector<size_t> const & nodes,
std::unordered_map<size_t, std::unordered_map<size_t, double> > const & edges)
{
size_t node_num = nodes.size();
graph_.Resize(node_num);
node_graph_.Resize(node_num);
node_map_.resize(node_num);
community_map_.resize(node_num);
community_size_.resize(node_num);
community_in_weight_.resize(node_num);
community_total_weight_.resize(node_num);
std::unordered_map<size_t, size_t> node_index_map;
for (size_t i = 0; i < node_num; i++)
{
node_index_map[nodes[i]] = i;
double node_weight = 0.0;
graph_.AddSelfEdge(node_weight);
node_graph_.AddSelfEdge(node_weight);
node_map_[i] = i;
community_map_[i] = i;
community_size_[i] = 1;
community_in_weight_[i] = node_weight * 2;
community_total_weight_[i] = node_weight * 2;
}
sum_edge_weight_ = 0.0;
size_t edge_num = 0;
std::unordered_map<size_t, std::unordered_map<size_t, double> >::const_iterator it1 = edges.begin();
for (; it1 != edges.end(); it1++)
{
size_t index1 = it1->first;
assert(node_index_map.find(index1) != node_index_map.end());
size_t node_index1 = node_index_map[index1];
std::unordered_map<size_t, double> const & submap = it1->second;
std::unordered_map<size_t, double>::const_iterator it2 = submap.begin();
for (; it2 != submap.end(); it2++)
{
size_t index2 = it2->first;
if (index1 == index2) continue;
edge_num++;
assert(node_index_map.find(index2) != node_index_map.end());
size_t node_index2 = node_index_map[index2];
if (node_index1 > node_index2) continue;
double weight = it2->second;
graph_.AddUndirectedEdge(node_index1, node_index2, weight);
node_graph_.AddUndirectedEdge(node_index1, node_index2, weight);
sum_edge_weight_ += 2 * weight;
community_total_weight_[node_index1] += weight;
community_total_weight_[node_index2] += weight;
}
}
double avg_weight = sum_edge_weight_ / edge_num;
for (size_t i = 0; i < node_num; i++)
{
node_graph_.AddSelfEdge(i, avg_weight);
graph_.AddSelfEdge(i, avg_weight);
}
std::cout << "------------------ Build graph --------------------\n"
<< "# nodes: " << nodes.size() << ", # edges: " << edge_num << "\n"
<< "---------------------------------------------------\n";
}
void Louvain::Reinitialize()
{
graph_ = node_graph_;
size_t node_num = node_graph_.NodeNum();
node_map_.resize(node_num);
community_map_.resize(node_num);
community_size_.resize(node_num);
community_in_weight_.resize(node_num);
community_total_weight_.resize(node_num);
for (size_t i = 0; i < node_num; i++)
{
double node_weight = 0.0;
node_map_[i] = i;
community_map_[i] = i;
community_size_[i] = 1;
community_in_weight_[i] = node_weight * 2;
community_total_weight_[i] = node_weight * 2;
}
}
double Louvain::Modularity(size_t const community) const
{
assert(community < community_in_weight_.size());
double in_weight = community_in_weight_[community];
double total_weight = community_total_weight_[community];
double modularity = in_weight / sum_edge_weight_ - std::pow(total_weight / sum_edge_weight_, 2);
return modularity;
}
double Louvain::Modularity() const
{
double modularity = 0.0;
size_t num_communities = community_in_weight_.size();
for (size_t i = 0; i < num_communities; i++)
{
double in_weight = community_in_weight_[i];
double total_weight = community_total_weight_[i];
modularity += in_weight / sum_edge_weight_ - std::pow(total_weight / sum_edge_weight_, 2);
}
return modularity;
}
double Louvain::EdgeWeight(size_t const index1, size_t const index2) const
{
return node_graph_.EdgeWeight(index1, index2);
}
void Louvain::GetClusters(std::vector<std::vector<size_t> > & clusters) const
{
clusters.clear();
size_t num_communities = community_in_weight_.size();
size_t num_nodes = node_map_.size();
clusters.resize(num_communities, std::vector<size_t>());
for (size_t i = 0; i < num_nodes; i++)
{
size_t community_index = node_map_[i];
assert(community_index < num_communities && "[GetClusters] Community index out of range");
clusters[community_index].push_back(i);
}
}
void Louvain::GetEdgesAcrossClusters(std::vector<std::pair<size_t, size_t> > & pairs) const
{
pairs.clear();
size_t node_num = node_graph_.NodeNum();
for (size_t i = 0; i < node_num; i++)
{
size_t node_index1 = i;
size_t community_index1 = node_map_[node_index1];
std::vector<EdgeData> const & edges = node_graph_.GetIncidentEdges(i);
for (size_t j = 0; j < edges.size(); j++)
{
EdgeData const & edge = edges[j];
size_t node_index2 = edge.node;
size_t community_index2 = node_map_[node_index2];
if (node_index1 > node_index2)
continue;
if (community_index1 != community_index2)
{
pairs.push_back(std::make_pair(node_index1, node_index2));
}
}
}
}
void Louvain::Print()
{
std::cout << "------------------------ Print ------------------------\n";
std::cout << "# communities = " << community_in_weight_.size() << ", modularity = " << Modularity() << "\n";
std::vector<std::vector<size_t> > clusters;
GetClusters(clusters);
for (size_t i = 0; i < clusters.size(); i++)
{
std::vector<size_t> const & nodes = clusters[i];
std::cout << "Community " << i << " of size " << nodes.size() << ": ";
for (size_t j = 0; j < nodes.size(); j++)
{
size_t node_index = nodes[j];
std::cout << node_index << " ";
}
std::cout << "\n";
}
std::cout << "-------------------------------------------------------\n";
}
void Louvain::Cluster()
{
size_t pass = 0;
while(Merge())
{
Rebuild();
pass++;
}
}
/*!
* @param initial_pairs - The end points of initial pairs must be in the same cluster.
*/
void Louvain::Cluster(std::vector<std::pair<size_t, size_t> > const & initial_pairs)
{
size_t pass = 0;
Merge(initial_pairs);
Rebuild();
while(Merge())
{
Rebuild();
pass++;
}
}
/*!
* @brief StochasticCluster introduces stochasticity to clustering by merging clusters with some probability
* rather than greedily like louvain's algorithm.
*/
void Louvain::StochasticCluster()
{
size_t pass = 0;
std::srand(unsigned(std::time(0)));
while (StochasticMerge())
{
Rebuild();
pass++;
}
}
void Louvain::StochasticCluster(std::vector<std::pair<size_t, size_t> > const & initial_pairs)
{
size_t pass = 0;
Merge(initial_pairs);
Rebuild();
std::srand(unsigned(std::time(0)));
while (StochasticMerge())
{
Rebuild();
pass++;
}
}
bool Louvain::Merge()
{
bool improved = false;
std::queue<size_t> queue;
size_t node_num = graph_.NodeNum();
std::unordered_map<size_t, bool> visited;
for (size_t i = 0; i < node_num; i++)
{
size_t community_index = i;
if (community_size_[community_index] < max_community_)
{
queue.push(community_index);
visited[community_index] = false;
}
else
{
visited[community_index] = true;
}
}
std::vector<size_t> prev_community_size = community_size_;
size_t loop_count = 0;
while(!queue.empty())
{
size_t node_index = queue.front();
queue.pop();
visited[node_index] = true;
double self_weight = graph_.GetSelfWeight(node_index);
double total_weight = self_weight;
std::vector<EdgeData> const & edges = graph_.GetIncidentEdges(node_index);
std::unordered_map<size_t, double> neighb_weights;
for (size_t i = 0; i < edges.size(); i++)
{
EdgeData const & edge = edges[i];
size_t neighb_index = edge.node;
size_t neighb_community_index = community_map_[neighb_index];
neighb_weights[neighb_community_index] += edge.weight;
total_weight += edge.weight;
}
size_t prev_community = community_map_[node_index];
double prev_neighb_weight = neighb_weights[prev_community];
community_map_[node_index] = -1;
community_size_[prev_community] -= prev_community_size[node_index];
community_in_weight_[prev_community] -= 2 * prev_neighb_weight + self_weight;
community_total_weight_[prev_community] -= total_weight;
double max_inc = 0.0;
size_t best_community = prev_community;
double best_neighb_weight = prev_neighb_weight;
std::unordered_map<size_t, double>::const_iterator it = neighb_weights.begin();
for (; it != neighb_weights.end(); it++)
{
size_t neighb_community_index = it->first;
if (community_size_[neighb_community_index] >= max_community_)
continue;
double neighb_weight = it->second;
double neighb_community_total_weight = community_total_weight_[neighb_community_index];
double inc = (neighb_weight - (neighb_community_total_weight * total_weight) / sum_edge_weight_) / sum_edge_weight_ * 2;
if (inc > max_inc)
{
max_inc = inc;
best_community = neighb_community_index;
best_neighb_weight = neighb_weight;
}
}
community_map_[node_index] = best_community;
community_size_[best_community] += prev_community_size[node_index];
community_in_weight_[best_community] += 2 * best_neighb_weight + self_weight;
community_total_weight_[best_community] += total_weight;
if (best_community != prev_community)
{
for (size_t i = 0; i < edges.size(); i++)
{
EdgeData const & edge = edges[i];
size_t neighb_index = edge.node;
size_t neighb_community_index = community_map_[neighb_index];
if (visited[neighb_index] && community_size_[neighb_community_index] < max_community_)
{
queue.push(neighb_index);
visited[neighb_index] = false;
}
}
improved = true;
}
if (++loop_count > 3 * node_num)
break;
}
return improved;
}
bool Louvain::Merge(std::vector<std::pair<size_t, size_t> > const & initial_pairs)
{
size_t node_num = graph_.NodeNum();
std::vector<double> weights;
weights.reserve(initial_pairs.size());
for (size_t i = 0; i < initial_pairs.size(); i++)
{
size_t node_index1 = initial_pairs[i].first;
size_t node_index2 = initial_pairs[i].second;
double weight = graph_.EdgeWeight(node_index1, node_index2);
weights.push_back(weight);
}
std::vector<size_t> pair_indexes = SortIndexes(weights, false);
UnionFind union_find;
union_find.InitSets(node_num);
std::vector<size_t> node_visit_times;
node_visit_times.resize(node_num, 0);
for (size_t i = 0; i < pair_indexes.size(); i++)
{
size_t pair_index = pair_indexes[i];
size_t node_index1 = initial_pairs[pair_index].first;
size_t node_index2 = initial_pairs[pair_index].second;
if (node_visit_times[node_index1] < 1 && node_visit_times[node_index2] < 1)
{
union_find.Union(node_index1, node_index2);
node_visit_times[node_index1]++;
node_visit_times[node_index2]++;
}
}
for (size_t i = 0; i < node_num; i++)
{
size_t node_index = i;
community_in_weight_[node_index] = 0.0;
community_total_weight_[node_index] = 0.0;
community_size_[node_index] = 0;
}
for (size_t i = 0; i < node_num; i++)
{
size_t node_index = i;
size_t community_index = union_find.Find(node_index);
community_map_[node_index] = community_index;
community_in_weight_[community_index] += graph_.GetSelfWeight(node_index);
community_total_weight_[community_index] += graph_.GetSelfWeight(node_index);
community_size_[community_index] += 1;
}
for (size_t i = 0; i < node_num; i++)
{
size_t node_index1 = i;
size_t community_index1 = community_map_[node_index1];
std::vector<EdgeData> const & edges = graph_.GetIncidentEdges(node_index1);
for (size_t j = 0; j < edges.size(); j++)
{
EdgeData const & edge = edges[j];
size_t node_index2 = edge.node;
if (node_index1 > node_index2) continue;
size_t community_index2 = community_map_[node_index2];
double weight = edge.weight;
if (community_index1 == community_index2)
{
community_in_weight_[community_index1] += 2 * weight;
community_total_weight_[community_index1] += 2 * weight;
}
else
{
community_total_weight_[community_index1] += weight;
community_total_weight_[community_index2] += weight;
}
}
}
return true;
}
bool Louvain::StochasticMerge()
{
bool improve = false;
std::queue<size_t> queue;
size_t community_num = graph_.NodeNum();
for (size_t i = 0; i < community_num; i++)
{
size_t community_index = i;
if (community_size_[community_index] < max_community_)
{
queue.push(community_index);
}
}
size_t node_num = node_graph_.NodeNum();
size_t node_edge_num = node_graph_.EdgeNum();
size_t community_edge_num = graph_.EdgeNum();
double factor = (community_num + community_edge_num) / double(node_num + node_edge_num);
std::vector<size_t> prev_community_size = community_size_;
while(!queue.empty())
{
size_t node_index = queue.front();
queue.pop();
double self_weight = graph_.GetSelfWeight(node_index);
double total_weight = self_weight;
std::unordered_map<size_t, double> neighb_weights; // the weight of edge to neighboring community
std::vector<EdgeData> const & edges = graph_.GetIncidentEdges(node_index);
for (size_t i = 0; i < edges.size(); i++)
{
EdgeData const & edge = edges[i];
size_t neighb_index = edge.node;
size_t neighb_community_index = community_map_[neighb_index];
neighb_weights[neighb_community_index] += edge.weight;
total_weight += edge.weight;
}
size_t prev_community = community_map_[node_index];
double prev_neighb_weight = neighb_weights[prev_community];
community_map_[node_index] = -1;
community_size_[prev_community] -= prev_community_size[node_index];
community_in_weight_[prev_community] -= 2 * prev_neighb_weight + self_weight;
community_total_weight_[prev_community] -= total_weight;
std::unordered_map<size_t, double> prob_map;
std::unordered_map<size_t, double>::const_iterator it = neighb_weights.begin();
for (; it != neighb_weights.end(); it++)
{
size_t neighb_community_index = it->first;
size_t neighb_community_size = community_size_[neighb_community_index];
if (prev_community_size[node_index] + neighb_community_size >= max_community_)
continue;
double neighb_weight = it->second;
double neighb_community_total_weight = community_total_weight_[neighb_community_index];
double inc = factor * (neighb_weight - (neighb_community_total_weight * total_weight) / sum_edge_weight_);
double prob = std::exp(temperature_ * inc);
prob_map[neighb_community_index] = prob;
}
assert(!prob_map.empty());
size_t best_community = RandomPick(prob_map);
double best_neighb_weight = neighb_weights[best_community];
if (best_community != prev_community)
improve = true;
community_map_[node_index] = best_community;
community_size_[best_community] += prev_community_size[node_index];
community_in_weight_[best_community] += 2 * best_neighb_weight + self_weight;
community_total_weight_[best_community] += total_weight;
}
return improve;
}
void Louvain::RearrangeCommunities()
{
std::unordered_map<size_t, size_t> renumbers; // map from old cluster index to organized cluster index
size_t num = 0;
for (size_t i = 0; i < community_map_.size(); i++)
{
std::unordered_map<size_t, size_t>::const_iterator it = renumbers.find(community_map_[i]);
if (it == renumbers.end())
{
renumbers[community_map_[i]] = num;
community_map_[i] = num;
num++;
}
else
{
community_map_[i] = it->second;
}
}
for (size_t i = 0; i < node_map_.size(); i++)
{
node_map_[i] = community_map_[node_map_[i]];
}
std::vector<size_t> community_size_new(num);
std::vector<double> community_in_weight_new(num);
std::vector<double> community_total_weight_new(num);
for (size_t i = 0; i < community_in_weight_.size(); i++)
{
std::unordered_map<size_t, size_t>::const_iterator it = renumbers.find(i);
if (it != renumbers.end())
{
size_t new_community_index = it->second;
community_size_new[new_community_index] = community_size_[i];
community_in_weight_new[new_community_index] = community_in_weight_[i];
community_total_weight_new[new_community_index] = community_total_weight_[i];
}
}
community_size_new.swap(community_size_);
community_in_weight_new.swap(community_in_weight_);
community_total_weight_new.swap(community_total_weight_);
}
void Louvain::Rebuild()
{
RearrangeCommunities();
size_t num_communities = community_in_weight_.size();
std::vector<std::vector<size_t>> community_nodes(num_communities);
for (size_t i = 0; i < graph_.NodeNum(); i++)
{
community_nodes[community_map_[i]].push_back(i);
}
Graph graph_new;
graph_new.Resize(num_communities);
for (size_t i = 0; i < num_communities; i++)
{
std::vector<size_t> const & nodes = community_nodes[i];
double self_weight = 0.0;
std::unordered_map<size_t, double> edges_new;
for (size_t j = 0; j < nodes.size(); j++)
{
size_t node_index = nodes[j];
self_weight += graph_.GetSelfWeight(node_index);
std::vector<EdgeData> const & edges = graph_.GetIncidentEdges(node_index);
for (size_t k = 0; k < edges.size(); k++)
{
EdgeData const & edge = edges[k];
edges_new[community_map_[edge.node]] += edge.weight;
}
}
self_weight += edges_new[i];
graph_new.AddSelfEdge(i, self_weight);
std::unordered_map<size_t, double>::const_iterator it = edges_new.begin();
for (; it != edges_new.end(); it++)
{
size_t neighb_community_index = it->first;
double weight = it->second;
if (i != neighb_community_index)
{;
graph_new.AddDirectedEdge(i, neighb_community_index, weight);
}
}
}
graph_.Swap(graph_new);
community_map_.resize(num_communities);
for (size_t i = 0; i < num_communities; i++)
{
community_map_[i] = i;
}
}
| 33.663818
| 132
| 0.609047
|
zlthinker
|
97ce6d330d558ae100db503d62572da03fa4e46a
| 1,593
|
cpp
|
C++
|
3rdparty/libcxx/libcxx/test/std/language.support/support.limits/support.limits.general/exception.version.pass.cpp
|
jbdelcuv/openenclave
|
c2e9cfabd788597f283c8dd39edda5837b1b1339
|
[
"MIT"
] | 15
|
2019-08-05T01:24:20.000Z
|
2022-01-12T08:19:55.000Z
|
3rdparty/libcxx/libcxx/test/std/language.support/support.limits/support.limits.general/exception.version.pass.cpp
|
jbdelcuv/openenclave
|
c2e9cfabd788597f283c8dd39edda5837b1b1339
|
[
"MIT"
] | 21
|
2020-02-05T11:09:56.000Z
|
2020-03-26T18:09:09.000Z
|
3rdparty/libcxx/libcxx/test/std/language.support/support.limits/support.limits.general/exception.version.pass.cpp
|
jbdelcuv/openenclave
|
c2e9cfabd788597f283c8dd39edda5837b1b1339
|
[
"MIT"
] | 9
|
2019-09-24T06:26:58.000Z
|
2021-11-22T08:54:00.000Z
|
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// WARNING: This test was generated by generate_feature_test_macro_components.py
// and should not be edited manually.
// <exception>
// Test the feature test macros defined by <exception>
/* Constant Value
__cpp_lib_uncaught_exceptions 201411L [C++17]
*/
#include <exception>
#include "test_macros.h"
#if TEST_STD_VER < 14
# ifdef __cpp_lib_uncaught_exceptions
# error "__cpp_lib_uncaught_exceptions should not be defined before c++17"
# endif
#elif TEST_STD_VER == 14
# ifdef __cpp_lib_uncaught_exceptions
# error "__cpp_lib_uncaught_exceptions should not be defined before c++17"
# endif
#elif TEST_STD_VER == 17
# ifndef __cpp_lib_uncaught_exceptions
# error "__cpp_lib_uncaught_exceptions should be defined in c++17"
# endif
# if __cpp_lib_uncaught_exceptions != 201411L
# error "__cpp_lib_uncaught_exceptions should have the value 201411L in c++17"
# endif
#elif TEST_STD_VER > 17
# ifndef __cpp_lib_uncaught_exceptions
# error "__cpp_lib_uncaught_exceptions should be defined in c++2a"
# endif
# if __cpp_lib_uncaught_exceptions != 201411L
# error "__cpp_lib_uncaught_exceptions should have the value 201411L in c++2a"
# endif
#endif // TEST_STD_VER > 17
int main() {}
| 27.947368
| 80
| 0.666667
|
jbdelcuv
|
97d12936cf4bb7640cd2bd31ab0c547dd7ffbc28
| 8,751
|
cc
|
C++
|
src/catkin_projects/drake_iiwa_sim/src/ros_scene_graph_visualizer.cc
|
mehrdad-shokri/spartan
|
854b26e3af75910ef57b874db7853abd4249543e
|
[
"BSD-3-Clause-Clear"
] | 32
|
2017-09-09T12:02:02.000Z
|
2022-01-26T10:46:31.000Z
|
src/catkin_projects/drake_iiwa_sim/src/ros_scene_graph_visualizer.cc
|
mehrdad-shokri/spartan
|
854b26e3af75910ef57b874db7853abd4249543e
|
[
"BSD-3-Clause-Clear"
] | 235
|
2017-06-06T18:14:17.000Z
|
2020-10-01T15:09:21.000Z
|
src/catkin_projects/drake_iiwa_sim/src/ros_scene_graph_visualizer.cc
|
mehrdad-shokri/spartan
|
854b26e3af75910ef57b874db7853abd4249543e
|
[
"BSD-3-Clause-Clear"
] | 32
|
2017-06-09T15:27:59.000Z
|
2021-07-13T02:58:58.000Z
|
#include "drake_iiwa_sim/ros_scene_graph_visualizer.h"
#include "drake/multibody/shapes/geometry.h"
#include "drake/common/drake_assert.h"
#include "drake/geometry/geometry_visualization.h"
#include "drake/math/rigid_transform.h"
#include "drake/math/rotation_matrix.h"
#include "drake/math/quaternion.h"
#include "drake/lcm/drake_mock_lcm.h"
#include "drake_lcmtypes/drake/lcmt_viewer_load_robot.hpp"
namespace drake_iiwa_sim {
using drake::geometry::SceneGraph;
using drake::math::RigidTransform;
using drake::math::RotationMatrix;
using drake::systems::Context;
using drake::systems::EventStatus;
using drake::systems::rendering::PoseBundle;
using drake::systems::Value;
using Eigen::Quaternion;
using DrakeShapes::Mesh;
using DrakeShapes::TrianglesVector;
using DrakeShapes::PointsVector;
/// Heavily references Drake's meshcat_visualizer,
/// especially for the initialization / load hack
/// that abuses the LCM draw_robot call to do the
/// scenegraph-interaction heavy lifting.
RosSceneGraphVisualizer::RosSceneGraphVisualizer(
const SceneGraph<double>& scene_graph,
std::string server_name,
double draw_period)
: server_(server_name),
scene_graph_(scene_graph),
pose_bundle_input_port_(DeclareAbstractInputPort(
drake::systems::kUseDefaultName, Value<PoseBundle<double>>()).get_index())
{
DeclareInitializationPublishEvent(&RosSceneGraphVisualizer::DoInitialization);
DeclarePeriodicPublishEvent(draw_period, 0.0, &RosSceneGraphVisualizer::DoPeriodicPublish);
}
std::string RosSceneGraphVisualizer::MakeFullName(const std::string& input_name,
int robot_num) const {
std::string source_name, frame_name;
if (input_name == "world") {
// Not sure the history of this, but all geometry *but*
// world geometry comes in with "source_name::frame_name",
// while world geometry is just named "world".
source_name = "world";
frame_name = "world";
} else {
auto offset = input_name.find("::");
if (offset == std::string::npos) {
return "";
}
source_name = input_name.substr(0, offset);
frame_name = input_name.substr(offset + 2);
}
std::stringstream full_name;
full_name << source_name << "::" << robot_num << "::" << frame_name;
return full_name.str();
}
EventStatus RosSceneGraphVisualizer::DoInitialization(const Context<double>& context) const {
drake::lcm::DrakeMockLcm mock_lcm;
drake::geometry::DispatchLoadMessage(scene_graph_, &mock_lcm);
auto load_robot_msg = mock_lcm.DecodeLastPublishedMessageAs
<drake::lcmt_viewer_load_robot>("DRAKE_VIEWER_LOAD_ROBOT");
for (const auto link : load_robot_msg.link){
std::string full_name = MakeFullName(link.name, link.robot_num);
if (full_name == ""){
printf("Couldn't find separator, this name is malformed. Skipping...\n");
printf("Name in question was: %s\n", link.name.c_str());
continue;
}
visualization_msgs::InteractiveMarker int_marker;
int_marker.header.frame_id = "base";
int_marker.header.stamp = ros::Time();
int_marker.name = full_name.c_str();
visualization_msgs::InteractiveMarkerControl control_marker;
control_marker.always_visible = true;
for (const auto geom : link.geom){
// MBT current sets alpha = 0 to make collision geometry
// "invisible", so don't draw them.
if (geom.color[3] == 0){
continue;
}
visualization_msgs::Marker geom_marker;
switch (geom.type){
case geom.BOX:
if (geom.num_float_data != 3){
printf("Malformed geom.BOX, skipping.");
break;
}
geom_marker.type = visualization_msgs::Marker::CUBE;
geom_marker.scale.x = geom.float_data[0];
geom_marker.scale.y = geom.float_data[1];
geom_marker.scale.z = geom.float_data[2];
geom_marker.color.r = geom.color[0];
geom_marker.color.g = geom.color[1];
geom_marker.color.b = geom.color[2];
geom_marker.color.a = geom.color[3];
break;
case geom.SPHERE:
if (geom.num_float_data != 1){
printf("Malformed geom.SPHERE, skipping.");
break;
}
geom_marker.type = visualization_msgs::Marker::SPHERE;
geom_marker.scale.x = geom.float_data[0];
geom_marker.scale.y = geom.float_data[0];
geom_marker.scale.z = geom.float_data[0];
geom_marker.color.r = geom.color[0];
geom_marker.color.g = geom.color[1];
geom_marker.color.b = geom.color[2];
geom_marker.color.a = geom.color[3];
break;
case geom.CYLINDER:
if (geom.num_float_data != 2){
printf("Malformed geom.CYLINDER, skipping.");
break;
}
geom_marker.type = visualization_msgs::Marker::CYLINDER;
geom_marker.scale.x = geom.float_data[1];
geom_marker.scale.y = geom.float_data[1];
geom_marker.scale.z = geom.float_data[0];
geom_marker.color.r = geom.color[0];
geom_marker.color.g = geom.color[1];
geom_marker.color.b = geom.color[2];
geom_marker.color.a = geom.color[3];
break;
case geom.MESH:
if (geom.num_float_data != 3 || geom.string_data.size() < 4){
printf("Malformed geom.MESH, skipping.");
break;
}
// Unfortunately Rviz seems to only want package-relative
// paths, not absolute paths. So instead, load in the appropriate
// geometry and send it over as triangles.
{
Mesh mesh("", geom.string_data.substr(
0, geom.string_data.size()-3) + std::string("obj"));
PointsVector points;
TrianglesVector faces;
mesh.LoadObjFile(&points, &faces);
geom_marker.type = visualization_msgs::Marker::TRIANGLE_LIST;
geom_marker.scale.x = geom.float_data[0];
geom_marker.scale.y = geom.float_data[1];
geom_marker.scale.z = geom.float_data[2];
geom_marker.color.r = geom.color[0];
geom_marker.color.g = geom.color[1];
geom_marker.color.b = geom.color[2];
geom_marker.color.a = geom.color[3];
for (const auto face : faces){
for (int i=0; i<3; i++) {
const Eigen::Vector3d& pt = points[face[i]];
geom_marker.points.emplace_back();
geometry_msgs::Point * new_point_msg = &geom_marker.points.back();
new_point_msg->x = pt[0];
new_point_msg->y = pt[1];
new_point_msg->z = pt[2];
}
}
}
break;
default:
printf("UNSUPPORTED GEOMETRY TYPE %d IGNORED\n", geom.type);
break;
}
// Set geom marker offset in its parent marker
geom_marker.pose.position.x = geom.position[0];
geom_marker.pose.position.y = geom.position[1];
geom_marker.pose.position.z = geom.position[2];
geom_marker.pose.orientation.w = geom.quaternion[0];
geom_marker.pose.orientation.x = geom.quaternion[1];
geom_marker.pose.orientation.y = geom.quaternion[2];
geom_marker.pose.orientation.z = geom.quaternion[3];
control_marker.markers.push_back(geom_marker);
}
int_marker.controls.push_back(control_marker);
server_.insert(int_marker);
}
server_.applyChanges();
return EventStatus::Succeeded();
}
EventStatus RosSceneGraphVisualizer::DoPeriodicPublish(
const Context<double>& context) const {
const drake::systems::AbstractValue* input =
this->EvalAbstractInput(context, 0);
DRAKE_ASSERT(input != nullptr);
const auto& pose_bundle = input->GetValue<PoseBundle<double>>();
for (int frame_i = 0; frame_i < pose_bundle.get_num_poses(); frame_i++) {
const RigidTransform<double> tf(pose_bundle.get_pose(frame_i));
const Eigen::Vector3d t = tf.translation();
const Quaternion<double> q = tf.rotation().ToQuaternion();
geometry_msgs::Pose pose_msg;
pose_msg.position.x = t[0];
pose_msg.position.y = t[1];
pose_msg.position.z = t[2];
pose_msg.orientation.w = q.w();
pose_msg.orientation.x = q.x();
pose_msg.orientation.y = q.y();
pose_msg.orientation.z = q.z();
int robot_num = pose_bundle.get_model_instance_id(frame_i);
std::string full_name = MakeFullName(pose_bundle.get_name(frame_i), robot_num);
server_.setPose(full_name, pose_msg);
}
server_.applyChanges();
ros::spinOnce();
return EventStatus::Succeeded();
}
} // namespace drake_iiwa_sim
| 38.893333
| 93
| 0.642898
|
mehrdad-shokri
|
97d2074f21a845e1b6b7ec12ba6a27e54cc3cf51
| 136,210
|
cpp
|
C++
|
capPaintPlayerWav2Sketch/AudioSampleYeahwav.cpp
|
Drc3p0/TouchSound
|
3748d161a3706918ce75934cd64543347426545e
|
[
"MIT"
] | 1
|
2019-10-23T17:47:05.000Z
|
2019-10-23T17:47:05.000Z
|
capPaintPlayerWav2Sketch/AudioSampleYeahwav.cpp
|
Drc3p0/TouchSound
|
3748d161a3706918ce75934cd64543347426545e
|
[
"MIT"
] | null | null | null |
capPaintPlayerWav2Sketch/AudioSampleYeahwav.cpp
|
Drc3p0/TouchSound
|
3748d161a3706918ce75934cd64543347426545e
|
[
"MIT"
] | null | null | null |
// Audio data converted from WAV file by wav2sketch
#include "AudioSampleYeahwav.h"
// Converted from YEAHwav.wav, using 11025 Hz, u-law encoding
const unsigned int AudioSampleYeahwav[12089] = {
0x0300BCDD,0x00020380,0x01010480,0x81808282,0x83868180,0x85878002,0x80018500,0x0003808A,
0x81000082,0x01018301,0x83820400,0x82000083,0x80810185,0x00038801,0x01800082,0x88810082,
0x84810203,0x83850300,0x81848484,0x01058687,0x02808780,0x03880205,0x84838103,0x84050085,
0x00030185,0x02818283,0x81848100,0x84848005,0x85800300,0x02020582,0x01808383,0x82018883,
0x84838184,0x81848183,0x02810002,0x00038001,0x84000186,0x028A8483,0x00868483,0x81038101,
0x81830501,0x01008883,0x81848186,0x83828600,0x84840202,0x81858280,0x82818400,0x81040285,
0x03050001,0x01038080,0x80018203,0x80850080,0x00848981,0x89828386,0x84890584,0x81838102,
0x83808385,0x82808187,0x02878284,0x01828502,0x00818200,0x03828202,0x02020283,0x01008403,
0x84010181,0x81870001,0x80818482,0x85008486,0x80858380,0x03858300,0x03858400,0x01038601,
0x85038187,0x02830481,0x04018206,0x00000284,0x01818582,0x81818484,0x81858384,0x87808681,
0x81830400,0x02020301,0x83068080,0x01850101,0x87008583,0x82870184,0x81838581,0x01008885,
0x8403858A,0x06888381,0x82838A04,0x89860386,0x86858181,0x00840481,0x83018282,0x03828000,
0x88858280,0x03878106,0x85058080,0x80018082,0x82008680,0x85068186,0x87810182,0x04888101,
0x81858201,0x86028482,0x87000188,0x87838085,0x00858501,0x81868384,0x83828883,0x80818582,
0x80850103,0x0081840A,0x87030280,0x8B810486,0x03860100,0x08838906,0x81038683,0x87850084,
0x888A8184,0x01828701,0x02820083,0x00028203,0x00848300,0x86048683,0x84838088,0x81808102,
0x02870800,0x87028103,0x01828101,0x8406848A,0x838B0586,0x00848B05,0x01868584,0x02878601,
0x02858202,0x82828602,0x81870104,0x87828082,0x80818389,0x8004868A,0x04838583,0x01028183,
0x04840305,0x03800305,0x82850503,0x83858603,0x8F848691,0x8483898F,0x05078588,0x03078085,
0x0D81040B,0x0983020D,0x81808307,0x91028188,0x89848089,0x88880484,0x81820282,0x03048101,
0x82090688,0x0D090306,0x01028581,0x828A8401,0x8D878885,0x8A8C8186,0x80878C05,0x81048083,
0x060D0500,0x00070F86,0x01848508,0x8A019000,0x83898685,0x81868985,0x86880886,0x05008005,
0x03030B80,0x0208070F,0x08810309,0x900C8B89,0x858A808D,0x01888883,0x09880283,0x00038500,
0x02000703,0x02030708,0x070A010B,0x8F020387,0x8B839185,0x86868B8E,0x03898886,0x07808881,
0x07810788,0x1004820E,0x800B0280,0x8C818282,0x8C8B8C85,0x8A849189,0x048A8586,0x81020281,
0x04801304,0x0E060610,0x030D0580,0x90880B8A,0x8E8A8788,0x80848C86,0x0F019085,0x81108492,
0x10048286,0x0C0B0802,0x8303020B,0x81900205,0x8F828B82,0x858A008B,0x89028D81,0x028D8187,
0x030B8902,0x0F050A07,0x8D040E09,0x888C840E,0x89908188,0x07908402,0x8D02878A,0x80840100,
0x010C1089,0x10060910,0x0C01870C,0x8984828F,0x89878B86,0x8D839185,0x038F8984,0x8805048C,
0x07030D0B,0x0107070A,0x04910D82,0x92098A89,0x8A8A0086,0x87878F83,0x028B818D,0x020D8100,
0x10040B11,0x0D8A0310,0x9387818D,0x89889005,0x85008F88,0x808A028B,0x85078184,0x10030510,
0x880F0506,0x128F8410,0x91018495,0x8F8E8B83,0x858E8E00,0x108A8700,0x82130281,0x0E85110A,
0x950D8785,0x048F8480,0x8581888F,0x06918388,0x8E099485,0x11860401,0x85100B81,0x10868215,
0x878E0E92,0x87028802,0x8C0A8B85,0x0B858A87,0x8A040C94,0x0E090416,0x0C901205,0x95039184,
0x038E9007,0x8485818A,0x05900687,0x84098A02,0x0D020C07,0x81061004,0x8A0E9411,0x80900B8D,
0x848A0787,0x8A838486,0x02068B05,0x08000D86,0x8F0D0306,0x068C8A10,0x02920890,0x03828708,
0x89098E82,0x06078A85,0x07030C8C,0x9210850C,0x12958112,0x82910D93,0x870A8708,0x89098202,
0x07018582,0x02820D89,0x9009030C,0x0C908607,0x8284059A,0x810F8980,0x0005850A,0x1086870D,
0x09820501,0x97108206,0x0093860C,0x83970F99,0x810D9007,0x00080081,0x0F068408,0x10000485,
0x8905000A,0x878A9512,0x069C0691,0x87858388,0x88058204,0x0806850D,0x07810E82,0x808E0601,
0x93099700,0x0E908B83,0x0109068B,0x88821001,0x8B038807,0x08850081,0x108F0787,0x90008888,
0x800F9213,0x81820F82,0x028A8387,0x85000793,0x0B05000B,0x0C0A8911,0x09910F8A,0x900C8B05,
0x88929005,0x8C899293,0x08880591,0x070C0E82,0x981B840D,0x14890A13,0x02041394,0x91048B89,
0x89018F91,0x01038292,0x07068504,0x0A961386,0x93100100,0x03070118,0x92880989,0x05888906,
0x06001087,0x910B0D03,0x87059714,0x199D108E,0x80808001,0x8E8D8D04,0x87839205,0x09890808,
0x00059011,0x11950F91,0x8E1A8406,0x0190100C,0x93038D93,0x83038890,0x070B0187,0x8D8F1492,
0x92158E03,0x110C0313,0x8A8F1192,0x928A8983,0x87850D00,0x09910F09,0x9A119500,0x13079215,
0x07871493,0x8906918B,0x0582888B,0x080A8300,0x94881189,0x94189A16,0x17901607,0x92800E92,
0x82938903,0x82858784,0x0C960A06,0x950F8F86,0x0B10921A,0x028E118A,0x87829288,0x0A8F0692,
0x921C8F00,0x16981581,0x98161091,0x84019219,0x859B0E94,0x90058C8A,0x068D1389,0x8C1A9412,
0x20961F03,0x9613868C,0x8A918380,0x92850693,0x8B888386,0x13950B8A,0x8D1B8A0C,0x068B8310,
0x898B8A8B,0x0A849009,0x82868682,0x8E128C07,0x1498131A,0x98940389,0x8892940C,0x0A8C078B,
0x01030E8A,0x1D0E1289,0x9311149A,0x89059702,0x858B809A,0x8B808289,0x11880406,0x86091909,
0x8A89911D,0x87A00392,0x8790828B,0x010D910B,0x1D051400,0x0013870C,0x03879980,0x81928DA1,
0x981B9A94,0x16828382,0x8C1E1381,0x86901610,0x889A0105,0x9B819A02,0x0E909C13,0x20810D8A,
0x19148F14,0x11858587,0x90920A94,0xA71EA50E,0x15998E81,0x8E811B98,0x12860912,0x0E88188B,
0x8682100C,0x9718A315,0x22938485,0x8E8382A1,0x09889985,0x81000991,0x8F030717,0x881A9D21,
0x23A41316,0x86938B96,0x118C9583,0x0A808291,0x00010687,0x9A20971C,0x169D8211,0x819A13A0,
0x19898A0F,0x03841091,0x1B83051C,0xA721A211,0x149A9C14,0x00931AA4,0x07010304,0x19821B86,
0x1C961315,0xA70F9F97,0x8614AB19,0x10971D9C,0x1A1B8D0A,0x108B2488,0x1A959D18,0x91A30CAC,
0x9E22AD0F,0x1618930F,0x10221E0E,0x1D931717,0x9F0D9C92,0x21AD019E,0x96018CAE,0x19190112,
0x981F1D87,0x1310041F,0xAD1E1091,0x8991A322,0x069520A5,0x9C17018D,0x848B1603,0x92201206,
0x1EAA2981,0xA8249401,0xA012A223,0xA082918C,0x038D0514,0x9C021B0D,0x28819530,0x0FA11F9A,
0x09979B00,0x839A129E,0x8D85A017,0x30A4121B,0xAC2AA495,0x2184A924,0x031B19A0,0x25169525,
0x1D0C1A9D,0xA92AAB91,0x0FA98DA7,0x86070CB1,0x220A2296,0x0530211A,0xA51E1A04,0xA8A81EA3,
0xA704A08C,0x129F1A8E,0x11292120,0x988C2A23,0xABA4121A,0xA1A1AD26,0x12B281A1,0x200E0D0C,
0x1F973013,0x8922A42E,0x298BA52C,0x1AA900AD,0x9E19AB98,0x23A5868E,0x20149688,0x241B8C0B,
0x992B979B,0x95138617,0x819C8F99,0x180E8C9E,0x8019208F,0xA7300292,0x11B12F92,0xB21DA5A2,
0x1B040692,0x0A1F32A0,0x8622291B,0x99B43481,0xB827C026,0x0CB00AA4,0x8F2C8C08,0x31903826,
0x8B09902E,0x28B9A60F,0xB59698BC,0x250DB233,0x3382341B,0x1930AC38,0x1CBB02A8,0xB22DC39C,
0x38C02FB0,0x2F389E27,0x3005322D,0xAA10A623,0x0DA9B598,0x9DBD30C4,0x1C3ABB37,0x2B9A3B94,
0x8030AA34,0xA1A80110,0xB0B421A8,0x1F2DC143,0x21BA3CA6,0x221EB338,0x20B932A2,0x2FA5B61A,
0xB343C522,0x3AB42580,0x1C37B502,0x37B32AA3,0x9429A1A1,0xBF9B31A8,0x2B11C145,0xB2AA40BE,
0x289BA73B,0x1BA53AA6,0x3B16B41F,0xC83834CA,0x3490A641,0xB32823B8,0x311CAB3A,0xC0AA30B8,
0x50C1C34B,0x869429C3,0x42AEB63A,0x9F10869E,0x2DBFA739,0xB1C135B1,0x2A21C750,0x8BA02421,
0x9FA7933B,0x9AB5A227,0xB337B5AD,0x33BF4CBC,0x10412816,0x94943EA3,0xA725B493,0x3A1DB3C2,
0xB54900CC,0x3842841A,0x2037B1AD,0x1129BFC0,0x382ABCBA,0x454CC72D,0x472F38AF,0x2DA4BFAE,
0xA2B4C5C9,0x119BC0B4,0x53B19D43,0x2D3D3029,0x13B2B941,0xABB8B7BA,0xB3A90BA5,0x83BD4530,
0xB1248D4C,0xC9A90320,0xB2B127A2,0x92244421,0xCF3450A9,0xBAAF2747,0xD1AF36C5,0xA2233194,
0x92434630,0xC84E3411,0xB1C747B4,0xB7B6A0C3,0x302417B7,0x2F3B3921,0x403AB38F,0xA02128D1,
0x4039C08A,0x3C45B3A4,0x812DB5A2,0x46B8CBBA,0xB652D1D0,0x45422699,0x36412C21,0x0714A891,
0x9DC4B4B0,0x252CC932,0x22B64204,0x9EC29440,0x04B8AD19,0xA2C1063B,0x51C5B954,0x32A41D31,
0xA9C3A133,0x98B3A015,0xC092BB2F,0x43D246A1,0xA741A327,0x9E983D2F,0xAE382E37,0xCEA740B4,
0xC8C44DB2,0xB634A54C,0xC5112CA1,0xC0B53B90,0x00B53131,0xC3284DA8,0x28209652,0xBC9530B7,
0x37BDA994,0x2E32B3AC,0xD054B4BF,0x37C13D03,0x293AA1AA,0x9144B1BF,0x944514BB,0xC153A5C0,
0x36B64CC6,0xAD43B198,0xAB9B3CCC,0xB0392C11,0x9B41BA8B,0xB3A143D2,0x13A1A330,0x3523B404,
0x443AA246,0x3A3DC18B,0x960A44D2,0x42BCC13A,0x2E21CFC3,0x3823C0B2,0x4D2BCAB9,0x2F4B37CB,
0x34412032,0x2D45B426,0xAC982813,0x44BDD3B2,0xCA2C1AD7,0x99BB2122,0x4110083D,0x3D223946,
0x53A0AF2A,0xC23623C3,0x0DC5C044,0x2DC3CE26,0xA1B6BE9C,0x54A0B997,0x3151B2B8,0x493C2C30,
0x2439B81F,0x80C0B0B0,0x49B0C4BA,0xCF50BAD7,0x993035AE,0x2D2F261C,0x37342E22,0x412CAC32,
0xC63921C6,0x94BD3638,0xA4BCC534,0x1E8284B6,0x51C3BB25,0x1043BCC8,0x46238045,0x30A0C333,
0x38212605,0x4E37D121,0xAE48A1D8,0x9823A4A7,0x2EB0CCAC,0x3C27170A,0x084CC0C6,0xAA4352CF,
0x2A233345,0x3A31C398,0xC0062A29,0xB89FCE9E,0x8EC644CA,0x2AB2C13E,0x3B43B4B4,0x489C4049,
0x374FC934,0x3FB545B3,0xB4B8CBA5,0xA412C2C4,0x1EA2C996,0xB156C0D0,0x49365112,0x42279935,
0x3540341A,0xCA9C1AB7,0xDA332AD5,0x9EC63033,0x40A2C0B3,0x81443D87,0xA5234442,0xC2915801,
0x21B1C256,0xB529C6CC,0xAEC719C4,0xB5B8C6A8,0x49B14F2A,0x9046874D,0x8C4533A4,0x85940913,
0xC0A8C5BE,0x40C332A2,0xC21BA0AA,0x9B2E4026,0xA23CA221,0xB01992B7,0x49A6B849,0x95A4A3C6,
0x21243D35,0xBB288E1C,0x29B30CB7,0x373BCD4B,0xBFAFA8CF,0x1CBA2430,0x9A823792,0x50A63B34,
0xB152BD3F,0x20A61DB9,0xC4BDB881,0xC0CAA9B9,0x539BBB30,0xC34A35C2,0x47434034,0x0AB03941,
0xB3C7C333,0x3039CE1B,0xC6BC43D1,0x362026A8,0x431BB137,0x4923B236,0xCD549FB2,0xBACE4680,
0x33862A2A,0x20ABCCB2,0x3833BAC2,0xD03E51C2,0x85C4B44D,0x39434232,0xAE3D00BC,0xB238B2C0,
0xB2CB57AF,0xB1BCD048,0xC1343083,0xC93534C5,0xB7383EAC,0x52CA4A51,0x1836970D,0xD09D4742,
0xCDCD18C0,0xBD1CA4C3,0x36B3C04A,0x44079CC7,0x81305251,0xBBC24740,0x45AB2616,0xCA49D123,
0xA0BFB5D3,0x85C2B13B,0xA3B52023,0x54413D31,0xC14838B9,0x45428D95,0xC0B1B93F,0xB6CFC1C0,
0xAA4F15A0,0xC2CF44C5,0x5242AEB9,0xAD493933,0xA4BAA926,0xC2504C15,0xBBCAA745,0x3540B5D2,
0xBCAC31C4,0xA9A2C2B9,0x28945A2C,0xB134C64C,0x215544B0,0xC3CC3E19,0xBAC5D0C0,0x3AC54E4E,
0xCDC4C5BA,0x345450B6,0xB4BA454D,0x45C6BBBB,0x4144B460,0xDBD1ACD1,0x349245B2,0xAEC90736,
0x5EBECBC2,0x265FBB55,0xC0C822B0,0x30205342,0xCAD5D02D,0x5C37D6D7,0xC84E44B5,0x94CCC5B8,
0x52565252,0xC3D4B64B,0x515BD3D5,0xCE1A5FB8,0xBFD8D9C7,0x425344A3,0xC8D0C221,0x435A11D2,
0x3D305A5B,0x92B1C8C3,0xB04C53AA,0xDBE2D5C4,0x46253BD5,0x152CAD63,0x2901C0D0,0x46586454,
0xDCE0D13B,0x51B945CF,0xD4A3105B,0xD0C7DADA,0x4E515F4E,0xD1DCC24B,0x65AB2154,0xC7262959,
0xD2C9D2D7,0x11465632,0xCDE2DBA0,0x6549CB52,0xCE224B51,0x12C7B3CE,0x25566155,0xD1E4D7B2,
0x5155D9B3,0xDABF3E50,0x45D6CEAF,0x4E5B6055,0xC1E0CA26,0x475ABFC3,0xD9BA425A,0xA5D5DCC8,
0x34525831,0xBEC7D4A9,0x575940D1,0xB18A4C5F,0xC0D0DFC4,0x444B474B,0xE0B6D7C2,0x544D48DB,
0x3E41524F,0x37A6D2D2,0x485A3F44,0xE9A1C1CA,0x43BF4FD2,0xC03A4A4B,0x420EC7D8,0x51595036,
0xE6CAA191,0x4CB2382D,0xC6184A50,0xA9C6D2E0,0x535B5222,0xE2CB4BAC,0x518184AE,0xB7395357,
0xC1D1D6D4,0x525242C6,0xC9DF4446,0x5432CCB8,0xB64B5253,0xC9CECEC6,0x265342A3,0xAFE03550,
0x2D4026DA,0xCC405953,0xB0CAD5C6,0x5954321B,0xC1DAC25D,0x5305C6E0,0xBB435E45,0xD2D4D8BD,
0x5A5147A5,0xB6BEC35F,0x0BA3D2E1,0x41265F55,0xB9D9D60B,0x6042BDCA,0xBD43CB57,0xB347B6DE,
0x20405738,0xB3C6CEB6,0x613FA2BB,0xCFB1D037,0x2C49B6D7,0x2D2B5357,0xB6D0D9C8,0x634F4398,
0xE2A1883F,0x4637C5DE,0xA24E584B,0xCED9DE24,0x67529E19,0xDC084433,0x2AA5C0D8,0xC9525451,
0xC3DED12F,0x614EA7C3,0xD2A94F3E,0x3434CFD4,0xB851524D,0xD1D4C9B2,0x415E14B9,0xCCCE4D83,
0x494DB6DD,0xB4565646,0xB2C9DEC7,0x566225BB,0xD0E12743,0x4635D2E2,0x3C53605B,0xC0D8E0B2,
0x5B6593D3,0xCAD24B57,0xC1D0D5E1,0x483E6254,0xCED5D623,0x49600FCC,0xC4A74F5B,0x982ACFDB,
0x3C475380,0xD2CDD4C3,0x505943C9,0xC0C08C52,0x4645C7D6,0x974F5946,0xCEDAD7D1,0x545155C9,
0xD8C6A85F,0x5134D5E0,0x415C6050,0xE0E3D5BB,0x504B5DD6,0xD2CD4366,0x0EB7DCDA,0x3E626241,
0xDCDABE26,0x442050DE,0xAA1B4963,0xBB12E0DC,0x0A545205,0xD1D0BB4F,0x4D4558CB,0xBFA9AF4E,
0x3B4AD8DE,0x0351514F,0xD5D6DEC1,0x62495ACB,0xD8A44C5E,0xAD30DFE2,0x4C5B5B4D,0xE1DED534,
0x65383CD4,0xC3444054,0xB9C3DDD6,0x31525B53,0xDCDAC73C,0x64C039C3,0xC7A03C5B,0x0795DBDC,
0x3F565C4C,0xE1DFC340,0x68B288B5,0xBA472151,0xD3CED4E0,0x2C575F58,0xE1D7313C,0x65A6BAAE,
0xC9402F4D,0xBD92CCDC,0xBC505151,0xDBE19F31,0x6444A146,0xD4284251,0xA7C1D8DE,0x33596157,
0xE2E1D0A3,0x6540B3B4,0xC948485D,0xC6C3DBE1,0x50605444,0xDEDFBB3E,0x61A4D22E,0xD0434C51,
0xBA02D4D7,0x32575743,0xD6DFBC2D,0x6327D32F,0xCAA34E5C,0xD1B1DCE0,0x4E616141,0xD6D9C382,
0x62B4D8A6,0x15403E5A,0xC8D4D8C9,0x3B5B4D06,0xD5D6323A,0x60B8C128,0xC12E0F57,0x2FB2DAD5,
0x40585947,0xD9D6D2C6,0x6926CCB0,0xC1373B62,0xC3DDE1DF,0x5A63634E,0xE6E29449,0x613AE1D4,
0x405F6357,0xD3E2E3D3,0x615343C1,0xD4D1415F,0x51DBDDAB,0x34524252,0xAAD7B1B6,0x394F4DA4,
0xD4D0B7AA,0x64ADC194,0xC9034B5B,0x97D2E4E2,0x62616444,0xE7E5C544,0x64BFD6D0,0x37576166,
0xE3EDDFDA,0x616457B1,0xE1CD5157,0x60DAE1DC,0x54585B5D,0xD5E4D3B7,0x56494382,0xE1AD1A48,
0x63D1C2C8,0x3F4D5551,0xC0E3DCD9,0x5C605751,0xEADFB758,0x60B8CDE5,0x45626564,0xE5E7E5E2,
0x6B6556C4,0xE4A54266,0x4FE7E1E6,0x506B654F,0xEAE0D03C,0x564B32D8,0xD7485463,0x3EDDB5DC,
0xB25D5253,0xE4D38DD3,0x4D5F473A,0xE1C81D52,0x62C0BEE3,0x46615A63,0xF0E8E5D4,0x655B673C,
0xEAC55364,0x1CD1E1F0,0x616E6769,0xEDE6E0C5,0x61498BE2,0xC8B66172,0xE0E0D9EB,0x62675F4F,
0xE5C2C04C,0x504324E3,0xA8BF5358,0xBFB7E4CD,0x3C4A5C5E,0xDEDFC794,0x5A6059D8,0xE01B505C,
0x55CEEBE8,0x5D66625A,0xE5EDE049,0x6360B1E3,0xD849656D,0xDEDEECE3,0x696C600E,0xE0E39A50,
0x5D47E7E6,0x3A5F6163,0xC8DEEBC9,0x535057A9,0xE3994F54,0x6251E4D8,0x3457354A,0x40D9E2D3,
0x51605443,0xE6E4CE51,0x610DAED1,0xCC605F60,0xC9E4E4E5,0x636C5A4B,0xE5DC3158,0x64DAEBE7,
0x5C5F5D6F,0xEBEEDDD8,0x675C4C2E,0xE0AA6464,0x44E2E2E4,0x6957564E,0xEAE3D412,0x60D24340,
0xC8485C5D,0xB2E1CADB,0x49545451,0xE139D4C3,0x56C762CF,0xAFA59D53,0x149DD0D6,0x3F4A5556,
0xE5E3D82D,0x39506DD2,0xE0223B65,0x40B7E2E3,0x52646351,0xE5E1D211,0x4F56A1E3,0x24315B6D,
0xD3E4E1DE,0x5D645CB1,0xE3D24C52,0x4B46D1E4,0x5E5F62BA,0xCEDCD9D5,0x654CD3C7,0xC8964C54,
0x50D3D0D9,0x2453458B,0xD71C35AE,0x5243B7BA,0x013D34BE,0x4537B1DC,0x4254C54E,0xCED4CCCC,
0x54AF464F,0xDAA74845,0xC539ADDA,0x5D4B4D51,0xC1BFD2C0,0x5D41D6D7,0xC644465A,0xD7CCD1C3,
0x443B578E,0xC1C4C162,0xBF42E0D1,0xCB6661A7,0xD3B7BCB0,0xBA5830DB,0x21425057,0x3FC9E2D0,
0x425342A9,0xCFC74047,0xB545B7D8,0x2A286341,0xD1D3CFAA,0x4D5D47D3,0x4A478BBB,0x57BCE0DA,
0xB052413A,0xCDE2C858,0x51AF1F35,0xDA4E4B50,0xD4AA94DA,0x56603952,0xD2D6B4D1,0x4A3839C7,
0x8957254D,0xDAD2D6D7,0x61C3625B,0xE5DCB84D,0x27489BC0,0xC853535E,0xD1D2CDD7,0x5B6352D2,
0xDDCAB956,0x56BAE3C9,0x5951485B,0xDADAD6BE,0x3E5640C2,0xE5A16824,0x42B0C7CD,0x62562287,
0xC7CDD3C4,0x61A1C0C4,0xE19AB35A,0x9CD90A28,0x50BD5855,0xC9D0C939,0x2F4034C2,0xC8D45360,
0x54C8C0E5,0x484A5A37,0xB0DDDD45,0x564318C2,0xE0CD6455,0xD3D5D3C1,0x17606222,0xD4CEB950,
0x4F55C0E3,0xB1674E0F,0x2CCCB0E4,0x50BEB4A5,0xB2DBB068,0xBECE9EB5,0x4933474A,0xD156C8D3,
0xB6953C07,0x56BCD14E,0x232CC912,0xD2C6274B,0x5A25D343,0xC2263F02,0xD0DC1F35,0xB5515243,
0xDA9D4241,0xC32C4CE4,0x11525262,0xC7C8D4C7,0x5849B0C9,0xCBCB4D60,0xC63CDFE2,0x41596834,
0xDFDB1F1F,0x6043A6CD,0x52493548,0x4CD7E9E1,0x335A0B52,0xE5D24958,0x55C508A8,0xC0534859,
0xDFAEDCE1,0x5C335B56,0xE03E3FD2,0x52223DD6,0x414D4858,0xCAD8E5D4,0x445E62C3,0xE1B02A45,
0x483CD0DF,0x3C5E5C58,0xC3D7DFD0,0x7051CDD4,0xD53DB32A,0xAADFC6C6,0x51475260,0xC1E0D335,
0x4F2B2AB4,0xB260D254,0x4FC0C3E5,0x5BA94F46,0xC2E1D64C,0x43353AB1,0xC9D66047,0xCCC788C7,
0xCE5A5C2E,0xCEC64BA3,0x5654CACE,0x3862C7B3,0x08D6C7DE,0x5A319954,0x17DBC941,0x38C3AB20,
0x5CD43B48,0xC54CD945,0x5028ADC7,0x15D0372F,0x41ABD551,0xC8D0B543,0x55DC3C5E,0xD6B3274A,
0xE09957C9,0x844F4956,0xCDA7CAC1,0xBD6233CB,0xC2C25139,0xC2C8D8B8,0x4F505751,0xE0CF0FB8,
0x6681CEC1,0xD85D494A,0xD5DFCED2,0x613DB95C,0xE2C1D163,0xB8DCA6B4,0x550A5E66,0xE2D5CEBB,
0x334750C8,0x8A11315C,0x21CBB9DA,0xA5624B9B,0xD5D6AE48,0x5048C3A4,0xE0C15147,0xBBC654DD,
0x5A535050,0xE051D0E0,0x5D4940D8,0xBB033A5E,0xD8DAD8E0,0x4E466454,0xD6DC3354,0x4342A9E5,
0xA1546647,0xD8C8A6D5,0x5E2DB4D0,0xE05C2052,0xB0DE83C7,0x4D5D4A31,0xC44236D2,0x4323A9C9,
0x68BAD1AF,0x8151D2E0,0x3FB4B296,0x1F3ABC41,0xB638A934,0xD7C83E24,0x288B59C2,0x9948CA3C,
0x2C59C2DE,0x44524DA7,0x43C3D6C8,0x9A5AD8C9,0x0BD65756,0x5031E3CB,0x4A5749BC,0xD5D33632,
0x5EC2CBC5,0x4448D157,0x44D6E543,0x55CEA058,0xD8D3025F,0xB9C20A8D,0xCFAF6847,0x4BC7E488,
0x585951D1,0xD7C5B43D,0x4FC6C9CB,0x5663444D,0xDDE1C0E0,0x5C5D42CD,0xC024345E,0x37DBE1DE,
0x47525652,0xBDE3CE5F,0x4AC1D8CC,0xBC816266,0xD7E59AC4,0x45455745,0xEB404F2C,0x30BA1D87,
0x5C533F31,0xCD9DD9D3,0x5594B444,0xB4E0AE60,0xC50FD341,0xC7395251,0xD13FC1BC,0x44523A87,
0xD720ADA3,0x29C661D5,0x9842B65D,0xE1B3C7D6,0x474E65AF,0xDBBBBA57,0x5257D1E5,0xAB5A651B,
0xC4DBDEBB,0x5F439CD8,0xD2234665,0xD2D7D5DC,0x624D5860,0xDCD5C41F,0x314245DE,0x4756554B,
0x39B1E0E4,0x4F65B5CB,0xB8DD2C52,0x5730DDCB,0xAD53514F,0x8ACAD4DB,0x5C53A99F,0xBA96DB59,
0x50A8D5DB,0x41395B59,0xCBE8DF36,0x551E5546,0xEAC0604A,0x43DBC9B1,0x4A636039,0xE1DDA5C6,
0x65B2C2C1,0x1DBB3861,0xD1DFE1C8,0x514E5E55,0xE4DE3A5B,0xA53C94C3,0xB95C5A49,0xDED94EE4,
0x5B5EB52D,0xE0553921,0x3E83ADE2,0x14525253,0x95C1D0D7,0x366037D6,0x16B7102B,0x5332DBC5,
0x3D594030,0xE0D7D6C2,0x60CC5F4A,0xE0B14253,0xCF45A5E1,0x46546052,0xC3D7DC1C,0x6C5ADDDF,
0xD64D5148,0x4FDAE9BE,0x5B5E3056,0xE1D6BF4F,0x932FD3D3,0x50545F58,0x21D7E2D5,0x605D42D5,
0xC5D34658,0x58D5E2D0,0x5656214F,0xDBE04EDB,0x582EB144,0xCD9A4E55,0xC5D5B7C9,0x87495552,
0xCEEECA56,0x4F02CC59,0xE2306451,0xDDD224B5,0x445B5C42,0xDA3EC634,0x54C737E4,0x3B524553,
0xCECADCBA,0x515552C3,0xE0D23352,0x48DD40AA,0x92654042,0xD0C0AADE,0x5C5C98DA,0xC1373E4B,
0x4049D8E3,0x1D4D5DA9,0xA2D4BFBD,0x545FE1C0,0xC82E4C4B,0xD2ABD6D3,0x5F216053,0xD0DDDE43,
0x54BDD630,0xBEB96261,0xCFD1D2D2,0x636153CE,0xD8D05030,0x61E4E1D5,0x5C575260,0xD6DEE090,
0x4F5296D4,0xD2D16761,0xE1DAD6A2,0x4B6D59CC,0xD0CA404A,0x5746E7E3,0x655B4947,0xE1CCD6D3,
0x45A010D0,0xA2D36364,0xD4CFE036,0x415650B6,0xE1985F39,0x3142D4D0,0x5040BA8D,0xC0C8C85D,
0x20C0B638,0x4CB92245,0x2437DF38,0xD9B05134,0x49C840C0,0x44414621,0x30B4CE31,0xC03209D3,
0x2B184855,0xD2C1C4C8,0xC16352D8,0xA82C4053,0x9FCBD8D6,0x584C0960,0xD543CACC,0x2D4AC3E2,
0x4E9C585C,0xE1D7C8C7,0x5D614EC1,0x953C4AB7,0x36CFE1E1,0x6524514B,0xDBDCD357,0x48BFC6D5,
0x50D16466,0xD8E1E249,0x535747C8,0xCF455156,0x2ECBE0E0,0x674B2F44,0xD5AED852,0x8CB3C7C8,
0xB444595D,0xD5C3C9D5,0x004C4A3B,0xE21A5783,0x4C91B9AD,0x425A4C15,0xE3D9D1D0,0x5008574C,
0xDED35A51,0x48C7D48B,0x3B5B5918,0xD4C5BCA9,0x579EB9D7,0xD0524D51,0x35B0DBD5,0x585654C4,
0xD1D6C543,0x4F55C3D3,0x42620711,0xBBDED7DF,0x62044D42,0xD0CFC463,0x52B5E2D8,0x5254565B,
0xE9CDAED7,0x614212C1,0xC852285A,0xC2DFDBD9,0x62505853,0xE8D9CC56,0x4ACD41C1,0xE3626651,
0xE0E1B4D0,0x5E5454AD,0xCD40205D,0x47D2DEE8,0x4060555F,0xCEEAD454,0x494B2FDC,0xC200605E,
0xC4D3D1CF,0x66623DC9,0xB194C7B9,0x513FDEE5,0x1136595A,0xC6E2D742,0x503F1A4A,0xDD48324E,
0x12DA3EDB,0x45555353,0xCCC6C8C2,0x52532ACF,0xDBAA4A50,0xC9D735DD,0x4E6A945B,0xDEBFBBD4,
0x574C1FD7,0xB3524E60,0xD2DAE3DB,0x6C6220AA,0xD8CD50BB,0x4BD8DDDA,0x55595A63,0xD9D7C2C1,
0x64C1D6E1,0xB1BC526B,0xD7E6E041,0x545E563C,0xDBCC5055,0x28DED5D1,0x63392363,0xE2B1D318,
0x43443ED1,0xC19C5B5C,0xD9CFDCC6,0x12515F48,0xE162ABC2,0x564544E7,0x5E50859F,0xCDBFD7C3,
0x4A5352E0,0xD3C03848,0x37D651D6,0xA1528955,0xD0372CC2,0x445DBED1,0x303DA23A,0x46E4E1C2,
0x5950C666,0xE1D9303D,0x5CC6B5C7,0x424C5457,0xDADABFCB,0x604DC1C8,0xD138574B,0x1FE3DACD,
0x58532E5C,0xE0C53645,0xCEC13AC2,0x48455744,0xD6D7CA93,0x51513CB5,0xD1285042,0x1B32CDD1,
0x49153A3E,0xD54BD644,0x503BB9D5,0x46474535,0x92C3D4B6,0x514B33BE,0xD214C12B,0xC8CA62E3,
0x32444E51,0xA0A7D09D,0x51468CC3,0xCDC03F42,0xDDD1A4D3,0x49394866,0xD5C02034,0x343634D5,
0x3E545052,0xAFD2DCD1,0x6923D5B2,0xAF3BB634,0xC3DDCDA0,0x5E254A57,0xC8D9C151,0x5C17D9A6,
0xBC5A23C0,0xC4DD46C2,0x5409C347,0xDCB74455,0xC9DE2635,0xD6575D51,0xE13453C2,0x4E5DC5D2,
0xA3614AD2,0xCFC8AED3,0x524440C6,0xC2C43653,0x30C391DB,0xBF535715,0xC71D34AD,0x5448CBDC,
0x6348C346,0xC5DEE8C4,0x584A2860,0x02D7D054,0x40C6D3C0,0x21445353,0xE2B99C15,0x6737B4DA,
0x422E484A,0xCDD6E2C6,0x51335450,0xE4DA4C5C,0xBAD846C6,0x30674A3F,0xD4CEC632,0x524942DF,
0xBF4D5150,0x46D6E0D7,0x2E46CD5D,0xE1CE6322,0x3949C8D4,0x44625343,0xD4D4D7D6,0x5D6030C9,
0xDBBB56C9,0x4DE4D138,0x5A564754,0xDDD7BB27,0x3A4026CD,0xDB556145,0xBED9D5CC,0x5E5FAB44,
0xDDCC1B53,0x43BFD5D3,0x59585150,0xC9DFDE3B,0x6457D7E0,0xB438624F,0x31E2E2C0,0x61498735,
0xB9CBC35A,0x8BBBD5DC,0xB15E5A3F,0xC3E0CD4C,0x3E40A4C0,0xD5C65E60,0xE0C7C8D1,0xA5536454,
0xDBC14FC9,0xAF61BDDB,0xB35A61B2,0xD6D0CACB,0x66534ED8,0xD4BAC443,0x41C6D0CC,0x2F576036,
0xCCD1C6A2,0x65A7D9C7,0xB255BC61,0xC7E8DECE,0x62503B60,0xDEDBB25F,0xB8C5B5D5,0x4A615855,
0xE1D440D5,0x6D31D3DF,0x39574458,0xD4E3DFD4,0x424B5841,0xDAB3574F,0xA4D1DCB8,0x5A642944,
0xD5D6319F,0x5A25D6C7,0xC5BA4754,0xC2E1C554,0xA440529B,0xDD535ABC,0xA6B9ADC0,0x475E4DC3,
0x48C7C1D1,0x385FC7DA,0xD3B09E35,0x45CA5022,0x2656CEC1,0xCD4709B9,0x5364D4D5,0x3E2C45C5,
0x21DCD6C9,0x55A5B860,0xD4CF4B39,0xC4DFA5B1,0x4330635B,0xD5C4C849,0x8ACBA7D4,0x17415163,
0xE0E1B83E,0x5CC00B2F,0xB63B2265,0xDBA5A3D4,0x604043CF,0xD336B047,0xBAC4BAD1,0x59604787,
0xD09513D1,0x53C1D2C5,0x5052BB52,0xC1C4BADA,0x4E40C2AB,0xD1504F4A,0xC3D5CBBC,0x51514C3C,
0xD957B5C8,0x4F09CBD3,0x4A453098,0xB1DA8B50,0x4646BAD2,0xC2B13F4A,0xA3D438BB,0xB74D3142,
0x41AF3799,0x5329E3B4,0xA6B40852,0xD6E3A956,0x41BE4A57,0xD83A5835,0xDA3291D0,0x904761C9,
0xD03555A5,0x41BECED2,0x43568953,0xD4C811C8,0xB24350D2,0x3251944C,0x3139D0DA,0x643FBDB8,
0xB3B8D642,0x52E0DA3E,0x60B6C465,0xD4D4D22E,0xB0B65393,0x90454359,0xBDC4A8DC,0x6432B7BB,
0xC023A834,0xB3BECDCB,0x4D3C4956,0xD748C5D2,0x2F5496CF,0xCA504FB4,0x40CACCA5,0x584D30BD,
0xDCBC9630,0xC2DA49D2,0xD6565E5F,0xCCDD3296,0x485736C4,0xC94D5340,0xE1D3C1D2,0x665A4EC8,
0xB3B5A387,0x3615E0D8,0x464E4F51,0xC1BEA741,0x60D6E5D3,0x4D469465,0xDAD9D1C4,0x44AB5B3E,
0xB5CE4555,0xD5D7B7A7,0x60B64454,0xE2A09242,0x09C151D4,0x2E4B3B5B,0xD4B2D0BA,0xB8525ADB,
0x525BBA24,0x4FC4D8DE,0x5929D454,0xCFC00934,0x4485B8D0,0x13C62759,0xC53CC9AC,0x5B4B9C04,
0xB94144D1,0x37C0D3D0,0x57543121,0xCDC4D1BA,0xC41351D2,0xC85B5948,0x09D0D28D,0x5A4CD78B,
0xC4403812,0xD3D2B4C1,0x31D15150,0xD4D44C62,0xD6D34FA8,0xB3536048,0xC8292DC6,0x3AA1C2D7,
0x56329755,0xDA41B4D7,0x4B523FD3,0x4C258F52,0xC5B0D4CE,0x5B03ACB4,0xC15ECE44,0x2BE2D2CD,
0x592E3454,0xD7D2915B,0xBAD03627,0x58281A34,0xCBD54B24,0x311BC5C9,0xB0534F44,0x34C3BEC2,
0xB7B5B543,0x45371036,0x41A1DBAF,0x37432AAD,0xC4CF163B,0x3B412600,0xD9254943,0xDF5A2CD3,
0x564352C6,0x413CC3CF,0x453CCFD4,0x4E4F393A,0xD5CBCEC1,0x52B65BD4,0x1241CA5A,0xC60DD7D2,
0x5B465104,0xABCBC857,0xB8DCDCD3,0x2A35546E,0xE3D13CC4,0xA1AC51D0,0x20386163,0xDAC2D1D0,
0x586229E0,0xB4B23452,0xA3DAD6D3,0x5359533A,0xD7C73C4C,0x04C6C3D8,0x49325D48,0xD5D1DA53,
0x5250CAB8,0xB74F5341,0xC7D3CFC0,0x4C3D429C,0x5442DB56,0x41C9D3E4,0x51A83C56,0xC0D2B059,
0x4CCBCEBB,0x503AB654,0xDE43BAD5,0x37C35220,0x5529BB42,0xC82915B7,0xB32C4CD2,0xD83653C3,
0xC4534CD2,0xC74B9730,0x425C30D8,0x5534CDC7,0x4EC6CF2F,0x37CEE250,0x29B65538,0xCFBF2131,
0xD2AB4B46,0x103F44B0,0x365127BD,0xB6C3AED7,0x51B8C355,0xA7231B35,0x13C3C4B6,0xAA234BA1,
0xE09D5FB4,0x4ED1B13A,0x0059C94B,0xD8C343C2,0x36C5303E,0x0A3A134A,0xB8C8C430,0x5F4B9FCA,
0xBB2F3CB2,0x4DC5E0AB,0x5A1FC348,0x41BED242,0xB3B2A2D1,0x2F573F2C,0xADC7A6B9,0xA8A4AE98,
0xD0B25D42,0xD3B047C6,0x2349844D,0xDB4D33D1,0x405840D0,0x3A5596C9,0xA6D0D5BE,0x64B3B853,
0xD4C0B72D,0xC0D844D7,0x45483A63,0xD6B31CB6,0x554309D2,0x0F564807,0xDCD9D3CF,0x60373B42,
0xD1B83D57,0xB0CAC6D5,0xB7606039,0xD9D0994F,0x3AE0D8D5,0x86595E69,0xE2E3B417,0x553629C2,
0x45335962,0xDECDCFDB,0x6A5EC7E2,0xC251A655,0x39DEE0D6,0x65422F53,0xD430C044,0xC3E0C7CD,
0x6149395E,0xE0CFB405,0x4624ADC0,0x9E5B3E4C,0xDCD421C3,0x3C304FBD,0xAD619B3C,0x4BA8CEDF,
0x4F37C4C1,0x40D05041,0x39C3D5A7,0x1840B340,0xD6A35004,0xAA238E36,0x314434C3,0x3745CFB7,
0x244225C6,0xC74318B4,0x93B752C5,0xB13CB83F,0xC851B5C2,0x35D24CC1,0x44BFBB4C,0xD9C21A51,
0x1ED35047,0xD3215419,0xDD3E60D1,0xB14F45C4,0x5259C7C9,0x28C0C9CB,0x461BCC54,0x32D4C839,
0x52D2D15A,0xC4CC4140,0xD1C35344,0x53CFB630,0xCB3E304B,0xB0D7BD37,0x105550C5,0xCB403B01,
0x38C3B0AA,0x5D53D0B9,0xBE2636CE,0x36C9D9BC,0x52C89760,0x9DD0CD4D,0xB135301E,0x185B18A9,
0xCCC4B7D2,0x563152D1,0xC0332538,0x4E52D1E0,0x3A113C3C,0xCEC73030,0x50D2D428,0xB958324B,
0xD8D6C434,0x40405491,0xDA375548,0xD0D14CC7,0x4C6437C9,0xD4914DD2,0x51C1D4D4,0x5B608C52,
0xD6DCD1C4,0x59DCA348,0xD8296257,0xD5D8C242,0x553C0CB8,0xCC3E5355,0xC6D9D3C7,0x345A411B,
0xC2D34E57,0xB0BFCBCE,0x1F5560AB,0xC6D63533,0x65C5DBCF,0x45A9B251,0xD1D9D752,0x3F418646,
0xB7315653,0xD0D2CBC7,0x5A60C0C5,0x2F5617D1,0x53DDD5D8,0x6012C154,0xC3B4BB54,0xC6D7B3C2,
0xB9574323,0xDEBD58A3,0x01332DC3,0x525D31B2,0xA7388AD0,0xBC32D1D2,0xC75051A5,0x3ABAC445,
0xB848A3D7,0x154C5889,0xB2D7CA42,0xB9C9BA3E,0x4CD95B50,0xD237D851,0xC7143BC4,0xCC006157,
0x9D49CFCD,0xC641B5C5,0x55C84251,0xC2A503D0,0x5231A6AB,0xCAC9B451,0xB0060434,0xCC163BB3,
0xCD54A344,0x1EC53585,0x4E398D33,0xAA4DC8CD,0x52C115B5,0x51DCDA45,0xC6B94748,0xD2D03B55,
0xC8413138,0xD4B4553F,0xC0CF5641,0x4B94D6B7,0x46512742,0xACD5CFC2,0x53480688,0x303EB043,
0x83D1CEC3,0x6746D19E,0xC186C03B,0xB0D2DFC5,0x5BB15759,0xD6C2944E,0xC905C5D1,0x40695021,
0xB3C42BD8,0x5D27E1E2,0x4F2C4F59,0xCCE1CB48,0x1740A7BC,0xE05965AB,0xD5BEC508,0x496946E2,
0xC1544CD2,0x4BC0D5D2,0x2688BF3B,0xAFE16443,0x34DAD804,0xA2524E55,0xE1D3394A,0xA1914C30,
0xD4884B1D,0xC1D0915C,0xBC3E4FDA,0x2E375443,0x2E08C7C4,0x234121BB,0x59D0B2C0,0x9F44E44C,
0xB2C7363A,0x88DC3060,0xAAB0AB4C,0xD5385622,0x5AB0D0C2,0x4C57D1D3,0x4FB4C3A7,0x22C4C245,
0xACB79142,0xD4C34E4D,0xD355B8D0,0xC5B85EB9,0x4F4E2AA8,0x3248C5D3,0x4831B10C,0x37C4D343,
0x2559C2DE,0x51CCA43A,0x34B4D24A,0x3EB7370C,0xAEC53D4D,0xE3D2864F,0xD03567D9,0xBC565521,
0xBC4CB9DD,0x484840BF,0x414C8EB6,0xCCD5D1CE,0x55B9354D,0xC122C34A,0xA9A137CE,0x42AB4050,
0xBB45AD30,0xB487A9E0,0x363B3A52,0xC5B4CCC2,0x261C3E3E,0xD4C3574F,0xD6C79F25,0x50453B3F,
0xCDA72D35,0xAA8036D8,0x5658A53B,0xD4BBB1B5,0x4E3ACDD0,0x5850C141,0xC1D2D5AA,0x4AD81A42,
0x22B13A65,0xDEDBB509,0x0A9860A6,0xCB4957A8,0xBB32D0D4,0x54534233,0x15B6C118,0x51C7D9BE,
0x43210A39,0xB4C3A230,0x5DD1C6BC,0x2C4F8654,0xCEC39ECA,0x495323C4,0xCE33C932,0xBB40C2C0,
0x590A49A8,0xBEA6AF31,0x2DC1CBB5,0x334B4F43,0xD9D4B8B0,0xAD592EC4,0xBE5A4E96,0xC40BA2CE,
0x5146D3BD,0x51503633,0x9DE2D5D0,0x39883F4D,0xD9354151,0xD5D14A9E,0xC6A4573E,0xD6445243,
0x2944BDD8,0x4A2648A5,0xC1C039A0,0x53C2C9B0,0x39BD313C,0x01D3C449,0x4786D822,0x25BC4056,
0xD3DB5043,0x29532DC2,0xB4453CA1,0xB9C634C3,0x5449CDD0,0x373EC448,0xADDBC647,0x1F43304A,
0x0527B541,0xC2C2B8C6,0x464B4CD0,0x8342BA30,0x563FE2C2,0x4C30411E,0xB5D4CD52,0xA1BDCF18,
0xBE47578D,0xC4CE35B0,0x39549CC9,0xB85655C3,0x9FB1B6C9,0x3834C5A3,0xC0A5421C,0x56C6C9C8,
0x4C2AA319,0xBDD1C253,0x428408A3,0xD6155149,0xD6D24221,0x155F3BD5,0xC95858CF,0x15C4CFC6,
0x5C55B1B1,0xD4D09639,0xC3DCC856,0x2C4C464D,0xD2B250B5,0xAB06AACF,0x40565245,0x9CDAD0CB,
0x54A4D64A,0xCCC6525C,0xC9D9AE34,0x3B5344BF,0xD33B5445,0x42DACBD3,0x4B622CC3,0xD3B04935,
0x4FCED5BA,0x4E4B3440,0xD1C81C22,0x64D9DDC4,0x3B49A354,0xD7DDA450,0x421E3640,0xBB2B444C,
0xDFC82E87,0x5A5EC8D6,0x4C5641CE,0x47D5DDC4,0x4B43C144,0xBDB93251,0xC5D1CA42,0x2B5FC8CD,
0x26285BC5,0x50D0D792,0x4E46BC21,0xA5C7A640,0x44D8C248,0xCD59B6C3,0xAA98560E,0x4FB8D2BB,
0x2B40429B,0xB44129C8,0x3346C1D1,0xC76047DA,0x90B2B445,0x534DD3D0,0x488A26AC,0xAED0D043,
0xC4A9C227,0xD52F68A3,0xC1B1B24B,0xC35894D0,0xD3505FCD,0x4C41C9CA,0x2940D2CC,0x15CD5DBF,
0xC113BF50,0x8757A1BF,0xD0933FC5,0x1F3647C7,0xDE11332C,0x4AD058C3,0xC9414149,0xC91340AE,
0x33C10A9C,0x1D403130,0xE8D7AC45,0x52C76143,0xD3575017,0xD22F41DE,0x5750BCAC,0x9A441244,
0xDDDAD9D1,0x61C55760,0xDBCF895A,0xD9C830D0,0x23506251,0xD3B44539,0xD7D3D0D6,0x55525B62,
0xDCD513B1,0x57C8BCD2,0x33424E58,0xD2D0B331,0x52D5C5C8,0x4222B86D,0xE1DE2DC7,0x454655B1,
0xA643404D,0xCBBACCD1,0x54D84821,0x29A8D56D,0xDEDDC0C0,0x21955D50,0xCBBA5254,0x2951CDDB,
0x61C717C7,0x0727DB63,0x38D5D5AB,0x55BC074A,0xC3DAA753,0xBBCD204E,0x61D6BA40,0xD554B951,
0xB0BF29CE,0x373E4045,0xB81EC4C2,0x80B34416,0x6CD4D930,0xC62FD633,0x11D1C151,0x49C72B5E,
0xC0B1C5A5,0xB7044A99,0x65B2D32B,0x324CD7D2,0x49C3D340,0x31CA2556,0xB3C2BD45,0xB927353C,
0x5B38D9C4,0x9E5155DD,0x4338D39F,0x534DD4C1,0x4BA9BB32,0xA2CCC74F,0x6498E4CD,0x41B751B7,
0xC4D8D457,0x4144AC2B,0xA64A533F,0xD2C9C2A9,0x636AE1DC,0x414E52DA,0x42D0E4D5,0x6052BC48,
0xC4B9B251,0xD9D0C8B3,0x5E669AC3,0xC3B755B5,0x369FE1E6,0x5C5E5545,0xC3CCC940,0x8AD6D7CA,
0x49654B21,0xD1D44621,0x4144CEE1,0x2B575140,0xBEAE21B7,0x4A4FD7D6,0x4567BED2,0x32D0C4C8,
0x523AC1C9,0xB83E8C42,0xD6D29FAB,0xC8B55555,0xD85452AE,0xB64644D8,0x445146D4,0xA249B5A6,
0x5125D0D7,0x9DC0B032,0x27242533,0xCBAD3123,0x973649C9,0xC4244539,0x3151B7C8,0xCE29A8B0,
0x4F39B3BA,0xBD0B4001,0xC4B534B9,0xD7474EB0,0xBD195139,0xD3C1442D,0x512EB312,0xC13D48CD,
0x43209ABD,0x4D8AD4A5,0x349CA02D,0xCED9914F,0x5493C557,0xDDCE55A5,0xD0C358B9,0x95514FB2,
0xB55635BF,0x3CCED0D6,0x6553D554,0xB5D0A0B7,0xD0D5C4C8,0x33A9575B,0xD5CC495A,0x42CECAD3,
0x5954C258,0xCAD8403A,0x49CBD8C7,0x50414E50,0xD0D7C548,0x58C6C8C2,0x5259BC51,0xD4D886BC,
0x4943A7C9,0x314E4353,0x96D1D6D2,0x6998D2C0,0x5813D754,0xD0DDD7B4,0xA2A2505A,0xC8C6475F,
0xD2B9B6C5,0x545740C7,0x562EC1C9,0x5F1BE5D1,0x4E3EC345,0x34CDD146,0x4BB6C632,0x1553C0AA,
0x51D3C3D4,0x3C52B407,0xC3419035,0x20A7C0BD,0x3A303E43,0xC354B8C6,0x44D7CBD1,0x1754AB4B,
0xD2973D41,0x4650A8D3,0xA65135A5,0xCC503AD5,0x58D7D712,0x5057D540,0xC7D1C221,0x42BB4148,
0xD0912249,0xD73460CA,0xB42893C1,0x955AB637,0xC63A96D8,0x45344AC1,0x98A7C745,0xD0CC462A,
0xC3C53E40,0x22C3465B,0xC4A9B2C3,0xC44654C1,0xC9C83846,0x4BD91649,0xD6BE1C43,0xC4D75D59,
0xC5C13D31,0xB35550AE,0xC3D3B3B9,0x5A46CC41,0xBD35BCAA,0x8ED251B7,0x2CBDA234,0xAF374454,
0xD1E1C5B7,0x4BB23257,0xDBD15055,0xC5B255CB,0x17544040,0xA6A1A124,0x41DBC4CB,0x5049CA5A,
0xD8D5C045,0x944D45C8,0x1F00475A,0x90C3C6A0,0x64C0D9CC,0x4832C75D,0xC4E1DB1B,0x38623CBF,
0xA5B3504A,0xC5CEBCCC,0x5C602BD8,0xB8443490,0x55D5E2C7,0x6157D136,0xB4C53AB3,0xACD6D2B3,
0x614EC855,0xD5C4409A,0x9ECAB1A5,0x61488A3A,0xCB34D3A7,0x2BC7C7C7,0x5D46B152,0xBAB2BAC2,
0x3129C3C1,0x5E3B2C2D,0x4333E332,0x9047D9D4,0x435245A0,0xA7CB2C9C,0x4C38D2C8,0x30B73E43,
0xCED7BE60,0xC4C348C2,0xC86757D3,0x09A82DCD,0x4A4AC7D3,0x554CBDBE,0x46E0BB3D,0x92D5B444,
0xDA554645,0x8AAA45BF,0x414B82C9,0xA117AF90,0x37928FC8,0xB9492C25,0xD64744C8,0x9A1242BA,
0x455C27D1,0xC394BEC3,0xB24F49D9,0xC93A1951,0x904445D7,0x333DB1B6,0x20A0A840,0xD0CDC9AD,
0xC35B5739,0xDCD24F08,0x132359D4,0xA3623700,0xAE2303D2,0x58CFDCC7,0x5743A652,0xD7CBB8D3,
0x43CE4A2F,0xA9308161,0xD0A739C7,0xB45044D1,0x47AB414B,0xD2C6E3C9,0x4F525248,0xD4D24B48,
0xB3B6C4B6,0xAE4D562C,0xD6C45443,0x42E1DCB2,0x5C40305E,0xDCD34790,0xB3D72136,0x262A4A5B,
0xE1C34F4C,0x24D24BD7,0x4646B55A,0xC183C9A4,0x5399C6BF,0x47AE3149,0xC0D1C247,0x41A8BBC0,
0xC338A15B,0xC0DA953B,0x2D523BCC,0xC0343F3F,0xC02B36B2,0x5B4AD3CD,0x404927BD,0xC5DDCE90,
0x4037343D,0x1BC73647,0xB7AA9D30,0x673DD4C6,0x3542AEB1,0x31DBE12A,0x3F16A754,0xD3C64150,
0xCAB640B6,0x5860A8B9,0x3742CDBB,0x59BCDDD0,0x5AAAB140,0xBBC7D34A,0xC7BD0CC1,0x12514645,
0xBFD85499,0x3154C9DA,0xAA585735,0xB2CCD1C3,0x49520DC5,0xBA54B0C3,0xD3D02FC6,0x524DBA43,
0xA6363A33,0xA1A1C3D6,0x40454248,0xC151B8CA,0x25A6D1DB,0x512F5238,0xD0D1964B,0xB050A5D1,
0xA8495A3E,0xD24886D4,0x6998DFD1,0x4A55CBC0,0xC2D4D33E,0x48C03047,0xD4984F55,0xE20551D3,
0x214850AA,0x2050B621,0x30A0C5D9,0x51353CBD,0xD0B71A5A,0xD1A807D2,0xA54B53A4,0xC0C158B6,
0xC422C4B2,0x3F5434C3,0xCBB13731,0xCFD651B2,0xB840B251,0xD75B55C4,0xBE3032CC,0x514042C3,
0xB33BCDBA,0x49C59CC5,0x3BA5C54E,0x3CA7BA32,0xB4A439C6,0xBC174232,0xDBD04B53,0x21023FCC,
0x2A5F3CB7,0x34C7C1C8,0x453ED73F,0x5341BD45,0xDED9A720,0x25C95432,0xC7484646,0xCE9DB8CE,
0x34B24C42,0xA0C5534F,0xE1CEC6B5,0x401E5D51,0xDA884E2D,0xBE2412D6,0x455B50C8,0xBE31A541,
0x2ADBDACB,0x508F5460,0xDAD0AB43,0xBCB3A7BA,0xA84B544F,0xCCAA43C1,0x2635BFD4,0x53463851,
0xC5D3BCC8,0x5641BF9B,0x38C2324B,0xB8CDD4BC,0x2C1B213F,0xAEB6305F,0xD3D0AED1,0x35405852,
0xD6C3354A,0xC4CBB52A,0x48CE5236,0xCA913255,0x9494C5D0,0x46464C91,0xB7C72741,0x1DCB9BCA,
0x42C6C158,0xCBD2CD5D,0x11D24C3C,0xC2344750,0xD0293DA4,0x4B56C5D1,0x5AAD21C3,0x3124DBB5,
0x4BC2C6B5,0x4FBD0455,0xC7D8AC50,0x51A4B5C6,0x4A40BD40,0xC3C6D74C,0x4EC4BB32,0x17324A45,
0xD0D6C63B,0x93C94546,0x510C0054,0xC2A7BCD3,0x5831ABAD,0x3B8ABA54,0x33DDD7C7,0x30C02454,
0xB0CE415E,0xCDA4C8C5,0x4D504238,0xC0A73F44,0x46BCD8CA,0x5251A3B4,0x3350D6BB,0x53C0B1DB,
0x5426BB41,0xBFC4C542,0x3991B0B5,0x9CB03157,0x5314D9D1,0x515599D3,0x262AD146,0x04CCD484,
0x44534C99,0xD7C3413C,0x3147CDD5,0x5B25263C,0x49B0D0AD,0x93D8CDBC,0x47821F62,0xDCD3194D,
0xCD5950D7,0xC14262B7,0xA048D3CE,0x5F57D1D4,0x4F2191B0,0xB8D5DA17,0x3B5E35BC,0xB44E272B,
0x2ECCB7DE,0x524BAB96,0xA045BB36,0xCCC7B6C2,0x315A53CC,0x4910B020,0xC254D3DA,0x263B45BF,
0x40103482,0xC4B9D0BE,0x235A56C6,0xC7D0B642,0x4CD4C938,0xB3904451,0xD5A25236,0xD5BE13C2,
0x395B5FC8,0xD75406AD,0x2844B3E7,0x57512E44,0xA3BAC519,0xCDCCC1C3,0xA1B05E40,0xDABA2F5F,
0x4459D1E1,0x445A59D0,0xAABAC5C3,0xB2B2CDB2,0xA9415E40,0xE1D02039,0x503E3CD8,0x26572857,
0xB6CBCCD1,0x2DA83AC1,0xB0D05462,0xE1D2CBAE,0xC43A5E36,0xD5C46247,0xC937B1C2,0x1A582BC3,
0x05C74F49,0x31CCCCD3,0x41452142,0xD99BB134,0x31CC46AF,0x15C64852,0xD0CCAD52,0xBD4A43CA,
0x2631513E,0x23CDC7C7,0x3A5AB2CA,0xA5C8AB42,0x36D8C955,0xB03549BF,0xCB3C4944,0xB8D2C3B8,
0x50C4425D,0xA4DBBB2F,0xD5B3B655,0xB4C8584C,0xD0B15043,0xC3471ED5,0xC25655AD,0x5AC5D219,
0x4CBADEB9,0x4DC6C04A,0xC4D90F60,0x87D3BA4B,0x44443938,0x40221FC1,0x29ABD3C4,0x51C4C749,
0xC33B2643,0x25C1B1B5,0x43C48045,0x541AD84D,0x2E3BC3CF,0x50C3CA23,0x19C8B358,0x36B3CAA6,
0xC19F5047,0xCB0B91C3,0x2A4A51CD,0x935DBBBD,0x912DA4D6,0x593FC7B7,0xA0A3BE4E,0xC757D7DC,
0x4CBD59C2,0x20CAAC4C,0x242BCFB6,0x41474C85,0xD2C42942,0xB08BA7DB,0x525DBD50,0xD0C0C4C3,
0x53B59AC8,0x3F523C51,0xD9C3C4BC,0xB7C049D1,0x2BB9595B,0xD8B5C2BE,0x11553CCA,0x113E5643,
0xD4CCC9BE,0x4E5433BF,0xCB5EA8B4,0x10D514D7,0x573E1430,0xC430A448,0xD3D6C4C8,0x46BB6053,
0xC8B73C27,0xC848C6C6,0x403B4591,0xB1C03E50,0x3FCCDBCF,0x39423852,0xD4DA4938,0x46D2453D,
0x263A1343,0xDAA8432E,0x46D82EC6,0x3939B85A,0xC7B2C441,0x285331C9,0x472A42B9,0x37C9BF1B,
0x5AABE1C2,0x2DA53019,0x95D8BA53,0x50BEC242,0xA743A44A,0xD2A8373C,0x5851D7D2,0x544BAAC4,
0x2CBEDACA,0x46A5B418,0x47D24453,0xCDC2C150,0xC364ADDF,0x3E47578C,0x35B1DBD4,0x4A53BFC4,
0x345DB9AD,0xD4C4B1D1,0x335456DF,0xA353424E,0xA4B7D1E0,0x46183826,0x10C43D4F,0xE1B0D20F,
0xA33F63B6,0xD337524C,0x813EACDA,0x545827C5,0xCAA90CBB,0xCFDA18D8,0x31B25A65,0xE2C9954E,
0xB92E53CA,0xB14F6040,0xD3A1B6B6,0x5225D6DD,0x55AD5355,0xD7D9C8B2,0x47B0A743,0x9E354F5C,
0xD9CC2499,0x59BECBCC,0x3F1DCB66,0xD1E1B6C1,0x2A48548C,0xC8395050,0xC0C0BCC2,0x5C52C3D2,
0xBF442445,0xCFE3D71E,0x4AC3465F,0xCEC45155,0xD6BE24BF,0x605532CF,0x9757C1A2,0x54CAD9D9,
0x5040A536,0x94C7C648,0xC8D5C54B,0x5C5024BD,0xD1BF42A6,0x3CC4D231,0x4B3E414E,0xB5A515B3,
0xDBC2BAB7,0x525F44B8,0xA9CA3EB4,0x3689D7CE,0x21513E51,0x91C63C49,0xBBDBD1C6,0x45613035,
0xCB8E341A,0x5635D7DD,0x575545B1,0xB507CD3B,0x23D4D8BE,0xA0555218,0xC9D52651,0x3314D5D5,
0x4F515754,0xC3CFB199,0x39B2D4D0,0x4B5D5939,0xD6D0D0B2,0x4422C3DE,0x99565F57,0xCDC1CCB0,
0x402DD0D9,0xB15A6932,0xD9D4D121,0x5A54C5DE,0x4A494D50,0xD0C5D3D2,0x4548D4D2,0x0E356060,
0xE1D3D1BE,0x4A5157C3,0xD0A94856,0xC4CEB6C1,0xB95630DB,0xC0306153,0xC8D0D5C0,0x565644A4,
0xD19B3C4C,0xDE92C3D1,0xA8AC5DBD,0xC0C05858,0xD11DC3DB,0x4F505637,0xC4C02249,0x2ECBD0CA,
0x3D84AD36,0xBDD33E60,0xBAD9BAC3,0x49535344,0xD1AB3A3F,0xDAC20CCE,0x42C2593E,0xC0B2C361,
0xC0BAC6D4,0x4D44523D,0xC5CDB245,0xCBD3B34B,0x5DA4AA32,0xCDAE3C55,0xC0D4C4CB,0x44514F4D,
0x03C8B52D,0xB6D4C4B9,0x61C3BD49,0xBBC1D264,0x1BD8C6CD,0x2F4B5A50,0xC9C1272F,0x2ED3CEBF,
0x6145A535,0xE03AB531,0x40C9CDBC,0x49345251,0xBDD0C04F,0x2BD1D0C5,0x60493A52,0xCACAD2A2,
0x4BA0CCC9,0x48503B53,0xB5C3CD0E,0x51D1D1C7,0x5C500F53,0xD9D6CDBA,0x51CAB43D,0x87455D49,
0xC3AECBB6,0x5A39D5CF,0x5E53C432,0xCFD6C9C7,0x4534CF96,0x2A854C61,0xC7C5CAC5,0x554B12CA,
0x4E4BC839,0x86D0CED2,0x6343D2B1,0x943CBC51,0xB1CED5BD,0x5C3FC438,0x3457B2A1,0xCCD3C0D7,
0x42403D80,0xAECA5558,0xB518C8CE,0x475BC0C9,0x4856C0C8,0x43D5CFCE,0x5019D044,0xBE43004A,
0xBDC93EB6,0x3B4DAAC1,0x836093CC,0x3221C5D8,0x5441BFC6,0x53C1C63D,0x32A1DB46,0x1641B2AD,
0xA15139C9,0xADC03CCB,0x4A43BDB5,0xB14628AB,0xB9B644D0,0x2A4BBBA7,0x4255C2C0,0x43C4C6B7,
0x4B2ECDBA,0x020C4148,0x499AD3AF,0x124C9AD3,0x3363B1D1,0x05BCC2CC,0x5532C7C2,0x2B3B2250,
0xBEC5D0C8,0x27261C31,0xBA5452B4,0x98C2B3D1,0x5655C2CC,0x93382939,0x9DADC8C9,0xA85424D4,
0xC05C26AD,0x29CEB2CD,0x503A32A1,0x962EB240,0x8C46B9CD,0x474FBAD3,0xBC5DC1CF,0x4AB7C8BE,
0x5145C2B4,0xB403068C,0xC7983BAF,0xC9354AC7,0xC35553C8,0x273BBCCA,0x5249C6C8,0x4228BE2B,
0x42B7C2C6,0xA93CBCA9,0xA15D94CD,0x2DBA3FC4,0x4649C9C7,0xAB478936,0xC536A4BD,0xAF4814D4,
0x2C591BD0,0x44C8C03A,0x471EC0CC,0xB8404139,0xD1AD4C32,0xC93AAAD1,0xB16752DB,0xC349AACC,
0x5642CDDA,0x59331392,0xBAC4C646,0xC507C3CA,0xB65E56A7,0x2EC6CBC3,0x4C58D5CF,0x33532127,
0xBCC20EC8,0x4246B0CD,0xBA6146BE,0xBBD1D0CA,0x34423CD0,0xB8474C51,0xBCC2C5B5,0x305B22D7,
0xB55E53CB,0x31C8D3CE,0x6241D2CD,0x2934B543,0xC9C2C7A8,0x8F3B2802,0xBF5F4FBE,0xB9B4ABC9,
0x3F51C4D3,0x37A54B40,0x90BDC0C4,0xA75ABCCF,0xB65F46CE,0x18C4C7C2,0x423935BC,0xB34B2440,
0xB13221D4,0x4350B2DB,0x356012CD,0x42D0D4C2,0x5434C720,0xB2B1A346,0xA4CAA451,0xA821A9C7,
0xB2624ED4,0x4130C7CF,0x4A49C7D0,0x3C1E112B,0xBF4BA6B1,0x2342C6D2,0xA75848D3,0xA8BE38C5,
0x449CB5BC,0x2A4E2831,0x818F34C2,0x3E40D9C4,0x4E59A2CC,0x22D3BA32,0x3193C6CA,0xB5435A46,
0xC4919A92,0x2157C8DF,0x3B6736D2,0x84CABBCC,0x570FC8D5,0x38403550,0xB7B2BCB8,0x44B5C9D0,
0x1A5F49B2,0xABD1CC26,0x4C4C9CD3,0xBF46573A,0x23A4C7D0,0x5514D6C9,0xC85847AE,0xD0C4C10F,
0x474241C0,0x9D2C4648,0x2B3CBECC,0x4643D2CC,0x45522DD3,0x8BC6D030,0x4646CABF,0xAB2D5239,
0xBEBA0DC1,0x16AF27A9,0xC55449C1,0xD04E36C9,0x095216D6,0x413A391E,0x47B4CDC0,0x42B6D123,
0xA64E2CB9,0xB6D0A64A,0x313FD022,0x21524C3F,0xB739C0D1,0x1189BAD1,0x34503FB0,0xC2BFBD4A,
0xC44F8DD8,0xBF49554A,0xB4BA43BD,0x28C5C5CA,0xA05A4AAD,0xCDB79C32,0x493DC1DA,0x544EAC52,
0x8CC7D237,0xC0D7C2C3,0xB7555A50,0xD3BF0243,0x194FB3DD,0x246749C1,0xBBA3A1CC,0x30D5CBCC,
0x225A5337,0xCAC21214,0x3931C9D9,0x344A524A,0xBAD1B043,0xC7C896C8,0xBD605EBB,0xBBBD2D0A,
0x572CD7E0,0x40523D4B,0xC0B1C6AA,0xC3CA36C5,0x935854B9,0xC58B2C30,0x434FCBE0,0x405444A8,
0x109BCBBE,0xC7C83BAE,0xC25549CB,0xBB9B4540,0x3F13BDCB,0x3C43222A,0xB64712C4,0xA6C81AB5,
0x2E59B7CF,0x4C3294AB,0x46B0DBC4,0x373BA03A,0xB4A03644,0xD4C29C30,0xC16536DE,0x935A52C9,
0x3FC1DAD5,0x5D46C4AB,0xB1380A46,0xCDC1C4C0,0x3559B0D2,0x49C05047,0x2AD2DAB6,0x3F5341B6,
0xB72F4442,0xBAB0C4CA,0x625ED5D7,0x5541BEC2,0x37D6DCCC,0x4C903850,0xB59AAF55,0xC9B5B0B6,
0x555DC3D4,0x133C22CB,0x22B6D0C9,0x40442C47,0xA4ACB23D,0x93BCB196,0x6091D437,0xBFA6BCB7,
0xA5C8B696,0x409A2E56,0x2FAC9A36,0x4130B3C0,0x6026D4C8,0x4715D3B7,0x3CD4D246,0x3B39C13C,
0xA72B48A1,0xC2904CAD,0x56CCD3AF,0x4041CE48,0xB2D3BF49,0xC1C72532,0xAFB95235,0xAE882557,
0x3ED2D7B6,0x303D3656,0xCDDA114A,0x2A3F1DA3,0x434216A5,0x8BB5CA34,0x4FD7D2B4,0x3DB44160,
0xD6D93343,0xBF3448B0,0x153A5634,0xA1A7C6A7,0x2FC3C9D4,0x34285355,0xCED61036,0x5091B718,
0x271F1D56,0xD3C9B71F,0xD7D252AF,0xBF98555C,0xD3193584,0x4A56A8D3,0x26384224,0x8BC2C0A1,
0xC9CBB924,0x25A54150,0xD5B94421,0xB6B652BE,0xB32E4C44,0xB74834B0,0xD4A731C5,0x404944CA,
0x352B1CC2,0x12ACC6C0,0xB1233340,0xBD804C4E,0xD0C1ACAF,0xBA544DD1,0xCF594DC1,0xC431AAD5,
0x5249A3C4,0x37463445,0xCEC7CAC8,0x2D5830D5,0x8AA15048,0xB3CBD4B8,0x414C43BF,0xB93B5426,
0xB8BEC3C5,0x5955CCD3,0x4428A42D,0x37B3D8CA,0x3E3E40B2,0xC0384440,0xC1B0C9A8,0x585DCAD4,
0x272A2AAF,0x2FC0D9C2,0x995449B7,0xA839082A,0x9BCCC435,0x56AEBFAF,0x95B20F3D,0x9F1BBCA0,
0xB08732A2,0x4FBDA440,0x50C7B831,0x49CAD8B0,0xABA6224A,0xAFCE1D53,0x39AA962D,0x4627AE88,
0xB149B3C1,0xA3C1CFBA,0x4792B04E,0x80C5354B,0x16B9B8B6,0x892C213F,0xD0204440,0xC9D8AD94,
0x3C404E20,0xB6A54B2F,0x38BECBAD,0x5427B843,0xC6C9C051,0xCADD9F0A,0xB8935458,0xD52F3431,
0x293C9DBB,0x434B221B,0xBE063C21,0xBED4CCC6,0x4745284D,0xD2912931,0xC0C836C9,0x13175B44,
0xB7A44040,0xCB3CA3C7,0x475138D2,0x4034A0CB,0x27C9C5C3,0x20A0A850,0xBC8C2248,0xC50B4323,
0xB13232C8,0xB45137B9,0x8E48C4CA,0x143C2DC3,0x4A011BB4,0x3216BF3A,0xA024CDCE,0x92194037,
0xC4C44640,0x951322C3,0x455813C2,0xA44294BB,0x45AFD7C9,0x46AEAD2C,0x47D2AF54,0x9CA9CE10,
0x2546321D,0xC0BE3F3D,0x41D1C6B1,0x4A481D27,0xC3BA8C23,0x3F27C9C0,0x493D373E,0xBCC49427,
0xBBD1BFA2,0xA7543141,0xCC964484,0x2D9DB6B6,0x1F224812,0xBA143437,0xD0D1C025,0x47A24246,
0xC1A13093,0x1F8B8CC1,0x99BA4840,0x2C99B949,0xADC1B5A6,0x0CC54519,0xC2221739,0xBE0A37A4,
0xB0333619,0x444EA61B,0xB23FA2D1,0xCA8043D5,0x42B1B54F,0x92278840,0xB58BAAC2,0x2D323EA3,
0xD53451A9,0xD6488CBE,0x4D2E42B1,0x3B44B5C0,0x35A0C5C0,0x489FB10A,0xCACB1A55,0x9696C92F,
0x004755D0,0xAD232CAD,0x40B3C1BA,0x5234C70C,0x932A984C,0x53B1D8CE,0x4551AAD0,0xA7BFB441,
0xB1CBB842,0x3232923F,0xB10C4026,0x4CC1BCC4,0x343DC832,0xB0C4931B,0xC8C54147,0xB7175029,
0xAF114423,0x91B6CBBF,0x41D19152,0xAEC2BA52,0xBAB33240,0xBFBA4722,0xB8414512,0xCBB61A99,
0xC7D44F3C,0x313E9B43,0x3C4C41CB,0xB936A9CF,0x3311A1A5,0xC8BC404A,0xDA8248BD,0xB94049AD,
0xAC5454D2,0xB43FB1CB,0x5646C6B0,0x9722B436,0xC547BFD1,0x284741D5,0x3C431EA3,0x31B9DA36,
0x5240C51D,0xBF304145,0x4428C7CB,0x2E39C7CD,0x44A70F33,0xB7B1C834,0x429740C5,0xA6A55344,
0x52C5CFBC,0x57B1DD38,0x29C8C34C,0xD1D40346,0xB1CA524A,0xB2B04F52,0xC2B3C496,0x3DC21247,
0xBEA89131,0xC3944228,0x46A18E9B,0x314A06C0,0xD40A25A0,0xD91D50A7,0xB6894E41,0x3B3D09C5,
0x2046B1C3,0xB74841CF,0xCCB21937,0xB04A310F,0x23383AD2,0x4A47C0B6,0x30AAC7AB,0x4BB0C2AE,
0x24BAC355,0x47C8C733,0x9645BAC8,0x85A14A19,0xADD03040,0x3F1BB231,0x2D45A009,0xA3C6C6AF,
0x4ED4C044,0xB7B24345,0xD3C7304C,0xBF2C463A,0xA04A44A4,0xC1C98887,0x30D140C5,0x29462C4E,
0xBD3D28C2,0xB8411ED0,0x2C5342B4,0xA33AB0B3,0x2841C7DC,0x443A4BC0,0x4199D036,0x27A5CD06,
0x2BC13945,0xC5C01C48,0x2FBE32B7,0xB14022BB,0x3F80B643,0x32C3CF3A,0x3BC5104D,0xC1B9364C,
0x93CEA4B0,0x3D3C9727,0xCE3933AC,0x31C081A8,0x31013247,0x0A993191,0xCBBF9530,0xCD8948BE,
0xCB443A4C,0xB33CA7B0,0x394931D0,0x463E07B2,0x22AABC32,0x44A2D3CC,0x3D9E9347,0xAE27BB2B,
0x092821D0,0x4E3F33B1,0x2BB4A737,0x38CFD2B3,0xBF480341,0xC7CA4C42,0x16C4169E,0x203A3420,
0xC7124740,0xCEC9B51C,0x158C3D32,0xB7C03F56,0x9DD0B7B2,0xA3424982,0xB7324933,0xC79CACC8,
0x494732D0,0x4E48B832,0xA5B8C2D6,0x261F4022,0x1A26B14E,0xC930B8AB,0x5150CBD5,0x3C3A2CB8,
0xA7CCB784,0x43A1AA42,0x4430B34A,0xC1C09E2D,0x2AC5C6C9,0x1D813D4C,0x3FD0B732,0x3742B5B1,
0xB9412F3C,0xC3C82F41,0xD7CF4243,0xC2B75731,0xCB493FB4,0xC8533FD3,0x96473AA2,0x34B3AB35,
0xBBC22527,0xB35122D2,0x304445B4,0x32C2C4C7,0x4C2CC741,0x4D35BC35,0xB4AFBE06,0x56BCD6CB,
0x432D2D44,0xCED6CD53,0x89489D1E,0x434A47A3,0x34AAA9C5,0x34D9D5C1,0x43C13762,0xD9CB4349,
0xCE9441C4,0x36445540,0x9EA731B2,0xCFB3CACB,0xB0515DAB,0xC0341E39,0x269BC6D0,0x474C3EA4,
0xB12C99BE,0xBB4113CB,0x5059CCD0,0x4D3088C4,0x3BD0D6B0,0x25C2364B,0xCBCA5147,0xC12E302C,
0x4EBDCFB0,0x4440C451,0xD0D9C13A,0xA2BA4A43,0x12A84545,0xB32A9D2A,0xD5C2B4A8,0x89975D28,
0xA52F3C2F,0x3646C6D2,0x423EBBC5,0xB3442533,0xD6C5A13E,0x435594D2,0x524D3ABD,0x44C2D9CE,
0x4F0CB200,0x28C4964F,0x91C4C546,0x53C9CFC1,0x2F440449,0xD5D31C25,0x39973C35,0x893C4250,
0x952EC2AA,0xD4D28BCA,0xC5966435,0xD4B4414B,0x255020D5,0x3E5848C2,0xB706B0C5,0xD0CA170B,
0x475138BD,0x9345AEA7,0x462DD5D1,0x453D2333,0x0EC4A642,0x45C4B4A2,0x51C2D814,0x3695C152,
0xD6D33D44,0xC3C35145,0x0E454746,0x1933B8C2,0xD415BDC9,0xB9425288,0x9BBD434D,0x4132C1CB,
0x44432AB8,0x3EAEBD95,0xC8B1C603,0x5426C5B7,0x433C9E49,0xA9D0CEB2,0x35113E39,0xAD0A3F44,
0xC6A82AC1,0x50A1D2C8,0x42404E31,0xD7C2A107,0xAC3A37B1,0x9D534640,0xBA9AB7C4,0xC3BAB0C2,
0x434847A3,0x8AA135A5,0x43AFD4BD,0x494A2E0B,0xBCCAAA49,0xA8B8B830,0x31A6C0C0,0x39A9B05A,
0xD2D0B508,0xB3AC5791,0xB52F5348,0x9F46A3C4,0xC6BFB3C2,0x345D93B0,0xC4A838C0,0x44B3ADCE,
0x50441629,0x25A6C198,0xBBBF1334,0x2AB3A3C1,0x81AD334D,0xB9D4C443,0x3F35A239,0xBA3E4D42,
0xABBC98B7,0x40BDC3BB,0x122E4589,0xC0C3CE53,0x1A34B6C4,0x92475334,0xA7A6971F,0xC7B6A8A2,
0x5711ABC2,0x4242C439,0xB0CEC6D2,0x42294344,0xC3B81452,0xA181AE1F,0x4037CBB9,0xC23F51BE,
0xD4B43BC1,0x3C4927B1,0x32403435,0x1C1EC4C3,0xB530B7BA,0x4D0027B1,0xAAAABB44,0x2CD7B52A,
0x49AD3543,0xD0993746,0xD23D3CC3,0x143A8CBC,0x3D4243B1,0x32BCC5A8,0x413EC5B2,0xBF1D3936,
0xBAA33BB5,0xC39A2330,0x4F25ABC1,0xB843203D,0x44B1D2C8,0x474137B3,0xC9C93640,0xC2BE9D38,
0xA94721B4,0xAF4E50BE,0xB2C4B09D,0x323AC5CB,0x3F244E49,0xC3CBAA2B,0x8EB8BDA5,0x44BB1647,
0xB0A5094C,0xC3CAB4C3,0xA0505485,0xCDB03344,0x2313A5B2,0x2541B2B6,0x3954A2CE,0x45BFC1C8,
0x4789CE9E,0xB3C24D48,0xB1C78947,0xBEAFAE3B,0xC3AE3024,0x42BB403F,0xC5A0B1AB,0x17342BC2,
0x37B65051,0xB6B1C497,0x0D45C0C5,0x5853BCC6,0xB4ACB7BF,0x47CAD0B8,0x37284550,0xBCD29048,
0xB0C68521,0xC4364132,0xCA5154C9,0x9492B5C3,0x514BB3C3,0xBAA13035,0x03D3B634,0x453DA197,
0xAEB6A191,0x98BFA744,0xB9A69403,0x0440452F,0xCEB73A32,0xB9B545BC,0xB8334A2F,0x4D42C7C2,
0x0241BDB2,0x48C6CFB6,0x32A72A50,0xD1CB3430,0x24C0408E,0xB933344F,0xBD4DADBB,0x3A4601CE,
0x142BC3B3,0x31B63936,0xCECFB540,0x98583DC8,0xC91E4937,0xB69E3FC2,0x2318BE19,0x33354039,
0xBFAA9BAF,0x399EC9C8,0x4D398047,0xC7B5BCAC,0xA5AB3A81,0x9600334B,0xBC1C1E11,0xCE9149B9,
0x404C9CCC,0x343D210D,0x43D9D6B5,0x4BB89D5A,0xD5C73F45,0xC32E50A5,0xC7B22931,0x324434B3,
0xB2C03F9E,0x44A2C9C2,0x35A29852,0xB6D49235,0xA6284647,0xB81DB8B6,0x513582C8,0xB5B49B44,
0x4BC8D1C9,0x3B432E56,0xBEC6B812,0xBBA53CA2,0x30A22F24,0x1E41320A,0xC0C9C3B2,0x5A22BEA2,
0xB33B1250,0xCDCAB0C0,0x532F0BB0,0x952C8A45,0xB1C2BF9E,0x93B2A232,0x5139A40B,0xBD88B032,
0xB2A6C4C9,0x8D454D39,0x13C0C12C,0x4A3CACAB,0xBDBEA13E,0x43C7BEA1,0xA54C2E40,0xCBD2BCC4,
0x38194F43,0xC0AB284B,0x313B98C6,0xA4283A13,0x472CB8C8,0xC6B0A948,0x2DBDCDD0,0x40515448,
0xD2D395AC,0x272320B4,0xB4405449,0xC1C3B8B8,0xB5B7A636,0x1F1D3FB1,0xA7434B3E,0xC9CECCC2,
0x425451B9,0xD1C04150,0x86B2CAD0,0x30465410,0xB3A1C281,0x2635B6C1,0xBE004632,0x8B20258B,
0x3947A8A4,0xC127B7CA,0x4359ADCE,0x0CC2B80A,0x3BC6BE3C,0xB4C5A14A,0x1B154131,0xC3974D49,
0xBFCBCDCB,0x58B22E42,0xCAD09E5A,0xC0C6C2C0,0x1449573F,0xB0B52728,0x223692AB,0x41A3CCC7,
0x948D1344,0xD5C64632,0xA93F3BCF,0x334E5232,0xBA92C0C1,0x42A9C1C8,0x3935394A,0xBCB1B8A9,
0x5132C7C4,0x45B9BC32,0xB3CC9D4B,0x13CA9545,0x3EBEC240,0xAF991C41,0xBAB82B3D,0xCCBD2238,
0xC5375433,0x3B411ABC,0xAE44BAC4,0x422FC7CB,0x4F2CAA32,0xB2C0C441,0xB4B3A69A,0x573A8981,
0xA59FBF35,0x82D4D1BD,0x36134957,0xD2C33741,0x813321C3,0x4F4B1AB3,0xB028B9C4,0xB2428FC3,
0x5438CDC5,0x5133A82F,0xC9D7C937,0x453BA298,0xC5265249,0x91CAC6BD,0x279DAC22,0xC8865241,
0xC42433B5,0x345327CA,0x4545B9C9,0x4C0EC4B1,0x20A3C03C,0x36C8C6B6,0x28CF0346,0xCBB43B55,
0xCD9A2E9C,0x3D533CC4,0x314A34BE,0xB1B4C0C2,0x013301BB,0xBB424627,0xA5CBC3B9,0x4032AC35,
0xBDB02D40,0x91BC412E,0xB8C6C330,0x1B494825,0xCBB14037,0x3434BBCE,0x514592AF,0xB7C8BA49,
0xBFC4C1B4,0x20544BB4,0xB51E2BA9,0x2E37AFCB,0x3E4122B9,0x09AB0D3B,0xC0C7BE10,0xCBC75048,
0xC5B34327,0xA84C46C1,0x9E992EB9,0x4980C382,0x1C91B340,0xB1BE3840,0xA8C9C1A6,0x88534BB0,
0xB89981B5,0x4318C8B6,0xACB39E43,0x92B7333F,0xC5803023,0xB34C40C9,0x8F3B3C94,0x3BC0CAA8,
0x39C2CD1C,0x06B24554,0xD2C22D32,0xAC8D30C4,0x3D414447,0xC3BF9E2B,0x33AAB6C5,0x2C832B4A,
0xBDAE27B3,0xB4233EAB,0x4830BFC0,0x40258E31,0xB2D0BB17,0x289D2A40,0x96193024,0xA0A02805,
0xAACAC1A1,0x920E4540,0xBCBD3622,0x13369026,0x2137A1AC,0x3710940D,0xB1C19B42,0x18A4BEBB,
0x1827341F,0x9136BC1A,0x208BC2BE,0x3E9B3542,0xB1B62F4B,0xC7AA9CB8,0x474B8FCD,0x2833A440,
0xB8CEC9B9,0x2DBB303F,0xB8294F4E,0xBA1920BB,0x4CA3C4C3,0x2314AE4D,0xB9CCB986,0x25853625,
0x203B3825,0x2F3116B8,0x27C0C5AF,0x4445B3B5,0x319EA526,0x31C2C19F,0xB81E2931,0xC10E4080,
0x443A26B1,0xB9A4BA9E,0x22A623AC,0x06B53540,0xBA2A1516,0x3432B3BF,0x4D37B698,0xBABBBB28,
0x32C9C5B9,0x3E3F4650,0xC8BEB038,0x1F38A5BC,0x32473125,0x3138B3C6,0x22B4C8C0,0x403DC2B1,
0xA9813943,0xC9C9AD14,0x4742338A,0xAA1F4336,0x20B1B6BE,0xB309B085,0x3A2128A2,0xAEB4162A,
0x2E0AC2C0,0x324346A4,0x21A6AEA7,0x4414C28A,0x34B5BE30,0xB2C30435,0xB63F3D2E,0xC78E19C2,
0x384040B3,0x3342A003,0xB5B1C3B6,0xA62E25BC,0x27483608,0xB1B9B6B3,0x5028BDB6,0x31302946,
0xC2C8BC0B,0xBCB42A0E,0xAC484836,0xBCA11DBE,0x3F35C3CB,0x44441FB0,0x21031323,0xBCC6B226,
0x434503BD,0xA132322B,0x09B9C7C6,0x9627302E,0xBCBF363A,0xA9302F15,0xC6403AB6,0x9A4022CA,
0x43451206,0x1AB1C19B,0x2FB3B017,0xB5BD153F,0x8C472CB7,0xC3C0AC00,0x36219C9A,0xB13C4B3D,
0xB0B3B4C4,0x343D31AC,0x962B3A0D,0xB2B1BDAC,0x4730C0C3,0x87283823,0xC3BA2028,0xB5A1149C,
0x2C404928,0xC0B48A32,0xB8A5C0C7,0x244848A6,0x0D35182C,0xA5B9CAB6,0x38863D1B,0xB3BA2847,
0xB89F8193,0xC2B13511,0x1821322F,0xA524B1B4,0x310333B6,0x91AB1F37,0x24351509,0xA9242F20,
0x40BBCFC4,0x382FA130,0xCCCD2B43,0xB5AB270C,0xB4474D36,0xB93236A8,0x0D32B5C1,0x2D40B2C4,
0x2BA12F40,0xC2CBBC0A,0x26161CA7,0x9F3E5047,0xAABABDB1,0xA6BFBAB0,0xAEB65050,0xC7B53B20,
0x173E10CF,0x4242338B,0x3A26C19B,0x10C0C194,0x35D0BF3A,0xA21A3846,0xC90E3E2F,0xA71302B6,
0x2B392426,0xBC95A5A7,0xB68E372E,0x3041B3C0,0x2E3F32AC,0xAFC2A69F,0x3D8AB706,0xB2AF3141,
0xC1C62742,0xC5BF2708,0x803E4DAC,0xA7323A28,0x2700C0B6,0x3308AF15,0x10B23048,0xB1BCB692,
0xA7C3B5B3,0x2E244049,0xC0AD2E3A,0x9B20A7C8,0x4039403F,0x94A8B882,0xA727209D,0x1EC1B3AD,
0x3328A783,0xC1A39E1D,0x04940A2E,0x2A2C2F2D,0x001D3412,0xBAA6301C,0x2B3FB6C1,0x2A9AB4B3,
0x99C6A033,0xA6BB9F2C,0x99314937,0xBA113C29,0xB91EA0B4,0x1B4438C0,0x99131239,0xB6C5CCB9,
0x3B293523,0xB2AE4448,0xABA2A4A5,0xBFBEA5B0,0x20A8504C,0xC3B92020,0x8A3D28C6,0x312F3093,
0x3A18BCA5,0x9FACAA28,0x15CFB034,0xB2B60A4C,0xBF314334,0xB89238B9,0x413E21BE,0x2796B8A4,
0x89B69030,0x40BAC4AC,0x163E3D2D,0xC7B82D2D,0x323594B3,0xA88E232D,0xAFBC3822,0xC5A49A06,
0x415420D0,0x313136B0,0x2CC7C9B6,0x21A22830,0xC3B4504B,0xBDB09809,0xB2442EC1,0xB6493DCA,
0x413FABB9,0xB1C3BE88,0x16B93301,0xA9A14445,0x883795A5,0xC4B118B2,0x151E42B0,0xC0243F24,
0xAD200BBD,0x28189A30,0x3E31B7A1,0xA78E2825,0xAAC8BFB2,0xACA83D46,0xC727499C,0xA19421B6,
0x4D46AEB3,0xA9278C30,0x24ACB5A6,0x04BEB614,0xB62A1031,0xC2AE2C38,0x3B25B0C3,0x35453104,
0x10A1A5A0,0xB28C8F1A,0x4244B8C2,0x1989A128,0xA7BBC52F,0xB92C1A33,0x1E3833AB,0x8D3197A0,
0xAD41B2C0,0x403EA9C3,0x4DA8B7AA,0xABB4A441,0xB9B5AA19,0xB9263A39,0x054D9ABA,0xBE2712C4,
0x3637BEC2,0x4241243B,0x8AC0B6AF,0x33AD8010,0x32341F2E,0xC1A70EAD,0xC0C09FBA,0x8C45481D,
0xA73804A6,0x308BB9AF,0x4C32AC8A,0x0FA28498,0x98C18789,0xB8BE933D,0xB2A144AE,0xB3344320,
0x4012C5C2,0x423CB8A1,0xA3C1A737,0x2DA63641,0xC0C0B625,0x9DB13E93,0x2C974333,0x950CC4B3,
0x3013BCB3,0x362A3743,0xB0B7B032,0xA5BBB7B2,0x32AC3145,0xB3B29641,0xADAAA2B6,0x3E3C3D21,
0x0990B930,0xA805A401,0x86C9BFA8,0x3A16AC51,0xCEBE2243,0x882238C5,0x3837403B,0x2021B7AB,
0x1AA5BBAA,0x34C7BE38,0xB3A6B347,0xBB294037,0xBEB42B98,0x393834B8,0x852C2E22,0x80C0AA0A,
0x40C1C3B6,0x353D303B,0xCDC01E43,0x981B11B1,0xB727411A,0x25AC44A1,0xA987A6A1,0x471BC5C9,
0x3E233728,0xBFB89839,0xB9ADA39F,0xAB3A502D,0xC5B6332B,0x2E41B4CA,0x44409AC0,0x40A4A9B5,
0xB2B8B527,0xC033321E,0xB2203D3B,0x2A23000B,0xC21F23B0,0x403EC1CC,0x42402AAF,0xBC88C0A9,
0xA4AC9FA2,0x4139353D,0xB2280137,0xBEA895BA,0x3735B3BB,0x434A0CC2,0xB8AAA1BA,0x2EBEC0B7,
0x36423D49,0xB7958026,0xB1AE8CB2,0x4C3CB8B6,0x2A3512BB,0xA4C2ABBF,0x19A02A3E,0xAB272730,
0x102204A0,0x27AA9CA2,0x403AC7B9,0x3C8986B0,0xAFC52241,0xB4B2A2A1,0x9A414939,0x92B5AF24,
0x9DA2C112,0x3632C0BD,0x4019412E,0xB4C4AE26,0xB094A6A3,0xAE28423C,0x94B11646,0xC0BCB9AF,
0x42422DBF,0x3D9B332D,0xABBCBCA7,0xB5B1978C,0xA6954944,0xADAA8F08,0xB33336A4,0x410EB4C2,
0x4C2606AC,0xC8BF9535,0xC0B133AB,0x90313F3C,0x963D0B8B,0xAE129FC5,0x4E10BBBC,0x1D9D962E,
0xCA158B80,0xB89D302B,0x2B453936,0x0939AAB1,0xA8B1B9B8,0x3E97C1B4,0x2745A213,0xC9BB932C,
0x30918310,0x30433437,0x131F03A2,0xA4A6A087,0x42B5CCC2,0xA03C9D8C,0xC0B23540,0x23B5BA9A,
0x35413521,0x95143C35,0x31BDC1B5,0x34AAC8A0,0xB6891948,0xBEAC2E3B,0x862011B7,0x1C3938AA,
0x2AA9AB8F,0x21A5BA41,0xBBC1BA0B,0x01A73A43,0xAD824043,0x9F24ABC6,0x112628BD,0x23B1333A,
0xA2A2B025,0xB8BAACB9,0x360D4941,0x9E0C3C2C,0xB9B0B7CC,0x382D3BB4,0x8D293142,0xAD94BBB6,
0xA5B106B7,0x2F914731,0xB60B2F21,0xAB3EBBC9,0x29352E27,0x35ABC028,0x2C33A285,0xC5C0141A,
0xA63235B6,0x3D491095,0xAD94B9B1,0x3BBDC0B0,0x40332F45,0xC1C11931,0xBABA9799,0x44429FBF,
0x27420921,0xA2C5C3B1,0x41B61435,0xAF923B49,0xC00B3091,0xBAC0B2B4,0x4A36B32A,0x1A8E019B,
0xA2C1A3B0,0x279A3142,0xB721363C,0xB9A027A6,0xA09F4626,0x2EC2CAC4,0x424190B0,0xC3A93C4A,
0xB3BEC2B0,0x2C41412C,0xBF39452A,0xA1A2B4BC,0x430CC7B9,0xA20E9146,0xC4B82E30,0xB09920A2,
0x3E4723B6,0x343125B5,0x35BCC09B,0x10B8C121,0x94A6453E,0xBBB63B27,0x411ABDC6,0x3C4080B1,
0x85B6B89C,0x389A2042,0xCBC3A23C,0xAC383AC0,0x143D3D3A,0xA4C4C920,0x38A1BEB2,0x1B364645,
0xC0B61836,0xB7A4ACB7,0x20411CB3,0x30064092,0xB1C1B28B,0x121F9BAF,0x1A2A4434,0xA6A69631,
0xB912A7B3,0x3F3EB5C5,0x168A1531,0xA9AFB626,0x813C2501,0xA21B2917,0x1A289091,0x2D05B3AF,
0x8EC0C2C1,0x369F3145,0xB1A53D46,0xAB97A6C4,0x474433B6,0x32BDB532,0x87B8C429,0xC6BAB291,
0x91224D14,0xB13E4439,0x8B16C9C4,0x3815A68A,0x0AB9424A,0xC2C2A82D,0xBC200CB6,0x29493CA1,
0x412BC0C0,0x95B1B2A7,0xB20C16AC,0x9422433D,0x052C2125,0xB02691B4,0x42AFC1C4,0x3A308C38,
0xB0C0C710,0x99201BB0,0x0A303E31,0x322B1F20,0xB2A59BA7,0x26AEA6B8,0x3BBFA743,0xBAB10647,
0xC2AFA7C4,0x48454297,0xAEA6153F,0x8193C2C1,0xC0B91C29,0xB0904B2B,0xB139312E,0x2235B2C5,
0x3B0AA093,0x379EB523,0xC5A81233,0xC3221ABF,0x3E4229AF,0x48369CB2,0x08A4B8B1,0x14B7B58E,
0x9C0A4249,0x29A5B7AB,0x8529A3C1,0x37C0C1B0,0x3F28A24D,0xC5BCAA3F,0x832236B9,0x2D282B0A,
0x1293AE37,0xB4B2ACAB,0xB2B43004,0x9BB3453D,0xAA34349E,0xB9A1ABBF,0x393839B2,0x9C1B0138,
0x0E1ABAB1,0xB71D231D,0x313EB2BF,0x17312323,0x0989BFB9,0x368094B2,0x3DA21034,0xA0808338,
0xB0B5ACBA,0x40AB1F98,0x33ACC036,0x9D9ABD36,0xB2AD1A93,0x24374438,0xAAA89923,0x872D0FAC,
0xC5C3B0A4,0x26B8491E,0xC11E4138,0xA236AFC2,0x3B311A9D,0x35240D29,0xBDB2B22A,0xBA358EB5,
0x274624AE,0x4220B2BC,0x8AA0B6A9,0x28A4B3B4,0x890D3F46,0x2AACB5AF,0x2C3D84B5,0x31C0BEAA,
0x3098A34A,0xC0B99F42,0xB2842EB5,0x232116AA,0x399CA139,0xA8BBB602,0xB7B03516,0xBCA2482E,
0x2C493A17,0xB6A9BEBE,0x2F288FC4,0xB18D3C45,0xAAABB391,0xB3292D97,0x4736A9C5,0x382F9A0A,
0x98B3C79F,0x1323251E,0x12983834,0x2028B58C,0x292DB6B5,0xB8BCAB25,0x25C69D81,0x932A4447,
0xC5B0A8A2,0x424134A3,0x8EAE1341,0xA0B2ACA0,0xC3B78620,0x0F3332AA,0x24313683,0x9101B9C2,
0x11252286,0x29302C37,0xB404981D,0x1136B4C1,0xB0138AB5,0x40A91D28,0x15A8152D,0x15A6BDBD,
0x21383637,0x32B4BB96,0x371CB031,0xC5B8A329,0x382FB494,0x37932933,0xB2B4139E,0xB5B4A2B2,
0x1929463C,0xB2921230,0x1F338CC0,0xC1A5099D,0x26212238,0xB8B23234,0x1336B3CA,0x334034A7,
0x35A5B207,0x2F08AC1A,0xA9AA9C87,0x163496A0,0x459FB8B1,0x0FA1B90E,0xB4AE8B85,0x11273F40,
0x95ACA421,0xA6352C96,0xC2C1B4AF,0x33AD4240,0xB4AF3D3C,0x9817A1C7,0x15371D99,0x302F1C37,
0xAFA8BDA0,0x002FB8BE,0x18453283,0x38918AAD,0x1EB4A3A8,0x229384A8,0xB397393A,0x28B9B99D,
0x2D369034,0xC1BABDB2,0x37153A36,0x18983537,0xB293B0B9,0xAA1F27AA,0x23113F21,0x13A5AA24,
0xA984B5AD,0x3A32B1B5,0x3D10372D,0xC1C0B184,0x403AB4C0,0x0838403B,0xADB7B6B0,0x2AA30490,
0xB9A11237,0x99B83B14,0x25A70EAA,0x1C0BB237,0x9415988A,0x25203089,0x9B9D3432,0xB19BB9A8,
0x36A1B0BE,0x2D35459B,0xC4B4B035,0x1D80BDAD,0x29454432,0xA2AB1285,0x9589B5AF,0x30A3BAAB,
0x040D3C96,0xBD841727,0x2A2DB11B,0x290BA021,0x9A9C2020,0xAAB6A527,0x84A21D41,0xA7C1B2B3,
0x304B32A0,0xBEA2223C,0x1EAAB5C0,0x2535348A,0xAA3A2AA1,0xB2A3A80C,0x3190AAAA,0x04429EA1,
0x0A839119,0x10C0AD94,0x459CB5B3,0xA133353D,0xBAB18792,0x2B972626,0xB9ACB021,0x85052424,
0xAEB5361A,0x9FA33090,0x2234A3A2,0x293420A8,0xADB2121C,0xA1959598,0x312AA296,0x323A28B7,
0xBCB8AF96,0x3FA4BBA1,0x36372C41,0xB2AF9500,0x889E90B2,0x37ABBBA5,0x25323703,0xC5971824,
0x9194A587,0x2B221723,0xA3253120,0xC2C19D03,0x96834033,0xA1B6A2A3,0x3343A082,0xBDA1213D,
0x3096B1C2,0x28413806,0xA52CB0AD,0x1F06B3BB,0x39828D14,0x9B26B921,0x32258FA4,0x11BA299A,
0x3ABEBA9D,0x0A301C45,0xC0B0AEA5,0x2B244205,0xBFB29833,0x1DA123A8,0xB5A44098,0xB02538A7,
0x2E23B49D,0x2C2B9820,0xB19F2423,0xA491A29B,0x3F9EB8B1,0x404296A8,0xB6A8B118,0x2BB1B9A4,
0x1E2E3943,0xB20D8AAB,0x232E15B0,0x9EC4BC82,0x16229C2C,0xB532283C,0xA3B028AE,0x35922699,
0x261E0F2B,0xB89E8893,0xA52736B0,0xBFB6A28B,0x3D31AB15,0x1F223929,0xAAB8AEC2,0x3E392121,
0x2D9CAA25,0x2481A7AF,0xB0A90B15,0x36ABAE30,0x2A9B989B,0xB8060C22,0xBABAB108,0x3216403B,
0xA70F2528,0x8D3905BF,0xAC8E2320,0x202E00B4,0xB33D8D1A,0xB633B3C0,0x26A424B9,0x39951D35,
0x92139C32,0xA1959CA2,0x91B4098C,0x42AAB036,0xA59B1341,0xB1BAB4C2,0x3D383727,0x9FA2013C,
0xA1A2ADA8,0xBCB61693,0x35153194,0x24273216,0xA212B2B8,0x8610A092,0x162E3A31,0xB41C1106,
0x3639B5C3,0xA89598AB,0x2AA702C0,0x94372743,0xB3B1BA10,0x3A252BA1,0x15BB8B37,0x17A8B73C,
0xAC099426,0xB4B124B5,0x19232938,0x1D0B122B,0xB2B4A0BE,0x1A4240B4,0xB4202531,0x2FA0B5B8,
0x99233628,0x3AB3BEA9,0x3B21181C,0x06AEB5A4,0xA41EAAAC,0x8F2D3122,0x18A32536,0x1AA0B09A,
0xB214A2A1,0xB7222BB4,0x12253742,0xADBDC184,0x3D361CB3,0x9F224441,0x97B2BBAA,0xAC289CA2,
0xB7229AC0,0x8504373A,0x27B41E1E,0x1421A4B9,0x373A2794,0x99AA1A3C,0x2EC1BEA5,0xA4181B3E,
0x1ABDC0B3,0x403839A0,0xC0A9AD35,0x8393B5B0,0x97334233,0xAB243BA4,0xA39CA792,0x3303B6A0,
0xA43F92AA,0x8F121205,0x88BEA819,0x4507B7B2,0xA52C3129,0xACAFA7A8,0x302A3434,0xC1AFAF9F,
0x25243E95,0xACB42929,0x01A9AA8E,0x2A2DA10C,0x162B119A,0xA19A058B,0x01039111,0xA8B1B093,
0x2F44881B,0xBFA62429,0x27BBA7C0,0x3D3E433B,0xADABB087,0x1492A5AB,0xACB99E26,0x3812BC30,
0x3082259A,0xB2A732A6,0x0FA0A29C,0x343F3033,0xBDA08699,0x163405C3,0xB19CA135,0x2E2CA3BF,
0x223F1824,0xA8B5BC9D,0x39A20E82,0x2DB11026,0xB4029136,0xB4218B9B,0xB2922BAC,0x27A83135,
0x8D063A25,0xC0B59FBA,0x203F3BB1,0x8B87A72D,0x3D13C0B0,0xA7122130,0x25C1B1AF,0x3032173D,
0x1B9DB729,0x8194ABB4,0x1826310F,0xA8A62431,0x9099A6A5,0xAB932910,0x99B5BBA4,0x3D2D4626,
0xB9B28A10,0x3132B4BE,0x19353C3F,0xA7B4B283,0x22189E11,0x2635BEB8,0x2737AAC7,0x2720952B,
0xA4BCA839,0x33160EA6,0x92323F36,0xB5BFBB94,0x20052C29,0xC7B42491,0x143C42BB,0xA7303C1D,
0x9CA6C3B7,0x24338A0F,0x183F2511,0xABA022AE,0x20A5A3A7,0x02B7B31F,0x24201C3C,0xB0AA3430,
0x24C0BFC0,0x39303041,0xB3B4A12C,0x171523AF,0xAD8A302B,0x36B4BEB0,0xA2222833,0xC3301925,
0x0C1CA0B5,0x433220A6,0x1E908614,0x0491B586,0xA0A71D2B,0x40B0C5BA,0x42281439,0xBEC0B81F,
0x0A2429B3,0x962C423A,0x8A0CAE0E,0xAC1E13B7,0xAB3D2DB4,0x9D3A96B2,0x3724AA9B,0x9FB7A3A4,
0x98A721A1,0x11283E3D,0x15B7B8B4,0x28139533,0xC2B49923,0x923445B0,0xA3323023,0x2F94C3B5,
0x23A5AB86,0xAE254027,0xB3A6028C,0x3626B1A2,0xAAA4A089,0x0FA63525,0xAC9F3F34,0x15B6C3C1,
0x3E3E032C,0xBCAC8F3D,0x93A61AA7,0x9A2C361C,0x0CB0B8B1,0x99A38534,0xB6223D2F,0xACADA2B8,
0x493C90B3,0x2B27A830,0x96B4BDAB,0x9B953637,0x3EC0C0AE,0x3738A93D,0xC6B4B336,0x928618B3,
0x0B364133,0xA68781B3,0xA2088DAE,0xA3332D87,0x3198B8A8,0x451B95AA,0xB5A79735,0xA619AEB1,
0x93323F38,0x84C0C1A7,0x342E9932,0xBDB0A529,0x313DA0C5,0x35323927,0xA4BCB5A9,0x948F1793,
0x86413C27,0xAAA4A3AD,0x2E9BA3B6,0xB4981F3A,0xAA31AABA,0x233F3717,0xA9C5BEAC,0x3BA22E28,
0xB1AB3941,0x962C04B6,0x242317A0,0x81A7B692,0xAC3321AA,0x1C3980A5,0x8CB0AEB0,0x3EA8AEA8,
0x118E3246,0xB3A69E00,0x1C3532B1,0xC4B79CAB,0x201B46AE,0xB4982F35,0x2227C4B3,0x3C3C1420,
0x13A78F20,0x99A2998D,0x318E9DA9,0xBAB7A616,0x80A21BA0,0x983B4139,0xACB3BDB0,0x3F3C98A0,
0xBEA1303E,0xAF3118B8,0xA4282C22,0xA5C0BCAB,0x32103410,0xB2963928,0xA084AEB0,0x3F24B5A3,
0x91902645,0xB4BBB69F,0x28403B93,0xC2B59522,0x42A594A2,0xB0A02C3B,0x1012BEC1,0x333827A0,
0x92AD9B08,0x15A00D2F,0xAC852032,0xB6AA06A2,0x06AC0122,0x92194011,0xB2ADA7B8,0x42440E9A,
0xA7019434,0x29B3B7B5,0x920F303B,0xA0C4C2A8,0x29273040,0xB7B0911F,0x2A9594B4,0x35302F29,
0xAF0F8A21,0xB0A5979D,0x1A42328C,0xBDC0BA99,0x3FA1A42C,0xA69F3A3F,0x9694B8C5,0x3F44389B,
0xB4C1B224,0x23AB902D,0x9A011F2A,0x9D93B3B0,0x231B2B34,0x9E9C2D2A,0xB19CA3BD,0x473789B9,
0xAAAD062D,0xA4B4A4A1,0x982F3938,0xB8B4B4A1,0x39223026,0xC0BC3229,0xA72A28C1,0x333D1D0D,
0x329EB895,0x26A49720,0xAAA10523,0xBAB3A523,0x2CA91C20,0xA7A73C3A,0xA9B2B3B9,0x3B432CA8,
0xB382141B,0x1C8A01A3,0xA2292F2C,0x22A1C1BC,0x33863213,0xB0B42302,0x9E9CA087,0x31320121,
0x02909012,0xB8BEA821,0x89413A0A,0xC0B59694,0x3AA127B3,0x0C393D39,0xB3A0B9B1,0x38338592,
0xB1BAAA34,0xA6B2041C,0x9031329B,0x8F1FA2B3,0x1D0C25B5,0x952A2128,0xB2A2A229,0x4318B5B0,
0x8B22923F,0xC2BAAC91,0x9B254421,0xBEAB2D02,0x1E39A1C2,0xAB3B1D2C,0x170DB9B4,0x3C1E07AC,
0x02AD072E,0x9FA40A2F,0x1904111C,0xAC951E12,0xB919A2B7,0x863D3D29,0xB6B9A800,0x401FB0B7,
0x15233440,0xB1ACADA9,0x30312E8D,0xB5B0B8A0,0x2438ADAD,0x22223529,0x93B195B2,0x32220BA2,
0x1E183037,0xB8A0808A,0x3C2EA9C0,0xB7119513,0x96A2BCC0,0x3933442D,0xBABC0029,0x321BA6B5,
0xB2153A3F,0xAD2A11AE,0x01331EA6,0x97A9A69E,0x3EB1B4A8,0x2B071227,0xB7A1952D,0xABB5B2A2,
0x2E2C433D,0xB1B0A71C,0x303AA2B4,0xA0242C26,0x2AC1BFBC,0x333A1835,0x9FB0B825,0x0481AD89,
0x042C2221,0x90251A92,0x90999399,0x1F14220B,0xC0B7B194,0x3C3AAAA7,0xA7913E23,0x9EB8ABBE,
0x37413A2F,0xA0A29722,0x26938DA7,0xBAA9282D,0xBF9C0DA9,0x20912B99,0x289986A0,0x98A9AD18,
0x25302684,0x8A2B3631,0xA3BFBBA9,0x1F24393C,0xBEBDA305,0x383A22C6,0xA8382938,0x9CB8C2AB,
0x33312F0F,0x1DA0A411,0xA0ACB32B,0x8C221622,0xB2082D9C,0x1D36B2BD,0x38331930,0xBEC4A48A,
0x3E309CBF,0x92343B38,0xB1B6B5B3,0x39363214,0xB4A08929,0x3CA1C2BE,0x1581362C,0xB81397AA,
0x8E92B1B0,0x30063437,0xAA9F262B,0x20329EAA,0x1F271C20,0xABC8BCB3,0x8B3C3C31,0xBD1F0835,
0x34AABFC1,0x3B25292F,0xAF8FA220,0x252995AA,0x96B79C1A,0xC0C11232,0x04083D2B,0x2A3C32AB,
0x0986B8B3,0x3214A008,0xA5282E33,0x18AAB6BD,0x1A1D9135,0xC1BFAE22,0x284033C3,0x9A3D2E34,
0x91BABF9D,0x2E122404,0x2421130A,0xA6A2A49A,0x9A8C1A19,0xB0203520,0x3310BAB8,0x41222F81,
0xC6BF9920,0x2D35B4C0,0x26373A31,0xAFC4B4A5,0x3628252A,0xA11E1C3B,0x28C0BDBF,0xA621243E,
0xC3313436,0x120AA8C2,0x443120A4,0xB3B50038,0x0DAAB6A8,0x3538361D,0xC5C5C1A2,0x34134092,
0xB2274334,0x009BC3C0,0x3E371C2D,0xB4AB2639,0x9F90A4AF,0x8A2D9295,0xB0B22128,0x1E29B5BE,
0x3C401E0C,0xA6BCAB8A,0x29AA8FA7,0x9D314041,0xAAB5C0B3,0x312D2217,0xBBA22A26,0x34ABB2BB,
0x2334333A,0xBBADA632,0x060094A7,0x3E2B08A9,0x95AEB623,0xA3ACB292,0x1B2B3D25,0xBFBDA988,
0x362E34A6,0xB42D3A38,0x29A7C4C3,0x413C170E,0xBEB39231,0x9F822197,0x0C26322A,0xA3B1B1B0,
0x2E97C2B1,0x42361C18,0xB6B69080,0x0DA2B1B7,0x0E414546,0xB6B9AC98,0x3F3914B5,0xB7AE9434,
0xADA0C5C3,0x36404224,0xA5B422A3,0x11AAB0B2,0x34322A30,0xB29F1E35,0xA7B9B7B0,0x17443B80,
0xC5B1A11D,0x462EC0C8,0x38344144,0xBDC4BEA2,0x36382AB1,0xB68A3336,0xAD9194BB,0x152B2291,
0x2995AE21,0xBDC0B591,0x2228442A,0xB6064131,0xAFB7C6C3,0x403D452B,0xBAB61B34,0x3E2DBBB8,
0x012F263A,0xBCBB9FA0,0x3719B0B8,0x25A3A51E,0xB5C0003D,0x84B29199,0x324A422A,0xB195A8A5,
0x361B9FB4,0xAB822335,0x05C2C3B9,0x35323228,0xB71D942B,0xA51587B2,0x322E3111,0x9395912C,
0xB6BBB8A1,0x37401198,0xB59C2207,0x23B4B5C3,0x28403E48,0xBBB9AD21,0x2D2B0CBC,0x22202213,
0xB2B59731,0x8696139B,0x18332C21,0xB4B3B3A1,0x223120B5,0xB991918D,0x1A1E298E,0x0A933225,
0x21260788,0x1E0AAC91,0x2D97A112,0xBC8A3033,0x83ADBBBF,0x8F1B3638,0xABB29C90,0x27159DA5,
0x1E2A2009,0xAC9A1112,0x2726289C,0x8A030824,0xB8B9B7A9,0x41359BB9,0xB338443F,0x83B9C1C1,
0x292F383F,0xBFB9AB1C,0x2F2C37A1,0x8596A218,0x9707A5A1,0x88ABA49F,0x86263421,0xA1AAAEAF,
0x3F27961D,0x9888273C,0xA5A0A5A5,0x00242413,0xBDB6A99C,0x353D90A7,0xAE1E3B2C,0x2AAFC1C8,
0x27272740,0x0DB0B894,0x36403C1A,0xB1B7B683,0x89141BA5,0xA9992220,0x2A1A0F99,0x091A121D,
0xAFA6A687,0x1F32A3B7,0xB0A12301,0x3192A6AB,0x00202434,0x22298696,0x86A8A509,0x1BA2B5AD,
0x2302232F,0x9B2E382F,0xB292A5B7,0x1614308E,0xA0ACA882,0x2F88969C,0x96078920,0x96A8A224,
0x31262905,0xB4A9A022,0x88A8B8B3,0x19233D33,0x00212120,0xAAADB09B,0x9F87149E,0x0A849B1C,
0x2A203723,0xAAA38796,0x87010707,0x2C94A687,0xB5B7B513,0x302797AF,0xA3043234,0x341991A3,
0x11221633,0xA7B0A79A,0x160B11AC,0x153B3F0D,0xAFB4BFA4,0x3892B9A9,0xA1962017,0xB591A6B3,
0x3B3C2C24,0x9E952C35,0x11ACACAB,0xA1312002,0xB70899A8,0x898034B1,0xA5133329,0xAE068F24,
0x27ADA195,0x241A8290,0xA4919712,0xA3819A93,0x292795A4,0x15912B16,0x23C1C004,0x30282334,
0xA9B89922,0x18050F14,0x32228406,0x9D231D23,0x9D00A6AB,0x882F2482,0xAEC3B3B0,0x3710AFAE,
0x85271437,0x09A42114,0x14283412,0x01918F2A,0xADB4A99A,0xAAAC0515,0x121F3731,0x9D86108E,
0x2A06ABB1,0x049D0F8E,0x91B3B182,0x2A279535,0x8B901930,0x859594AB,0x15238BA8,0x2190A131,
0xB2B2812E,0x91939291,0x9F2C1AA0,0x218221A7,0xA41C231D,0x249E1025,0x21949596,0xA9AFB6AC,
0x251EAD8D,0x201F2C8E,0xA3959615,0x32960535,0x958F2284,0xB8181293,0x04282C9F,0x92A3870E,
0x1C97ABA8,0xB4A02A2D,0x97B1259D,0x8B811A2C,0x0707AE9D,0x941E1D20,0x09991F88,0x25111F2C,
0x9B0D9D15,0x1B8583AC,0xB2A32220,0xA3A7A9A4,0x951D2121,0x102813A5,0x1D89A598,0x03139299,
0xA7102A1B,0x96AA1980,0x3029A582,0x2426A78E,0x9E8A2A9B,0xA18C009A,0x16998925,0x05A91F26,
0xA29A9B0E,0x1931AAA1,0xA5A39BB2,0xAEAD2D8F,0x90222E31,0x32290090,0x2389A290,0x93A99505,
0xAE222614,0x1A0517A3,0x0E819C0C,0xA4B8A910,0x86A0212D,0x20191523,0x9414A2A7,0x9B978D9C,
0x9C0B2386,0x9F1A1612,0x21978890,0x26169B21,0xA020900A,0x02151F98,0x9D972087,0x99A6ACA2,
0x06131101,0xA411210A,0x98198495,0x1D041213,0x99B39F14,0x9C001F85,0x8A261814,0x9B0D10A3,
0x1A061707,0x18A01E29,0x1583A117,0x1724A195,0xA3A1919F,0x8FAFA2A9,0x90A09B28,0x1780029D,
0x122B1689,0x1C141E12,0x81051519,0x9A951887,0x83019219,0x089AA68B,0x1D0D85A1,0x96148495,
0x09079292,0x069D910D,0x0810991C,0x03808A00,0x991614A1,0xA08E8291,0x0C9DA2A2,0x15271886,
0x10251E0E,0x1E1783A2,0x0D089C18,0x99A29204,0x8693231A,0xA0891511,0xA09B9CA2,0xA49DA00B,
0x98951A8A,0x141E248B,0x1B231299,0x03201080,0x06221604,0x8C89158C,0x0494A492,0x84929310,
0xAEAB9806,0x92A0228A,0x130A0320,0x8A979FA0,0x1B00200E,0x150C1024,0x0E069C97,0x0F099990,
0x91969715,0x8FA38E9D,0x1B071621,0x0D8D0A22,0xA39B9915,0x931D179E,0x12141598,0x88089D94,
0x090B1B00,0xA2979000,0x9AA6A495,0x12988C17,0x15801420,0x819E890C,0x1124100A,0x03181580,
0x1000919D,0x8C009691,0x9A110F03,0xA3A8A095,0x16A40809,0x9E841B27,0xA5140E9A,0x1F1A169F,
0x8C1A1704,0x90939203,0x14130E89,0x8D118907,0x93A19390,0xA306269D,0x098A880E,0x968D9092,
0x10159C9E,0x2823819A,0x2203961E,0x08948923,0x8E881A92,0xA4A09C96,0xA2069FA3,0x871B2098,
0x1B1E9100,0x2084908C,0x0F0B1414,0x820E2121,0x928F9109,0x8D969BA2,0xA0A3A295,0x1907A495,
0x1D241394,0x1C20120E,0x138B9992,0x90979319,0xA09E191A,0x8C18168D,0x2020818D,0x92971016,
0x859F9392,0x0D0FA403,0x92A49A92,0x8A9D929B,0x13131425,0x13171C17,0x22211B00,0x9E8D9509,
0xA2A6A898,0x89A3989A,0x12839A8B,0x1A8B021F,0x11822323,0x86192825,0x930F929E,0x8980A299,
0x99A08E93,0x8F200799,0x08808112,0x91A81C23,0xA59E020D,0x950D9596,0x0B8D0CA0,0x22191688,
0x14242224,0x178C0E23,0x0991930B,0xACA3A3A2,0xA6A39CA9,0x988B1203,0x1413190E,0x26238700,
0x24190E20,0x9A828411,0x8C8F88A1,0x8F0D1095,0xA19E9D90,0x132411A4,0x1C10211F,0xA6A29811,
0x85039CA4,0x171A0997,0x06959609,0x231B2516,0x03222125,0xA4A6A38E,0x9299A5A4,0x941295A3,
0x1C83A0A2,0x1A81111C,0x1A1A2129,0x0A8A0115,0x95139007,0x98920B98,0xA2A0A0A6,0x12A0A097,
0x20162227,0x83111B1D,0x999A9189,0x979D908E,0x84170F81,0x10938782,0x1B181513,0x101C1C1C,
0x99A0A08A,0x99A29090,0xA4940813,0x959F9CA0,0x1F140A04,0x1F182A26,0x0A208705,0x81819A92,
0x99909096,0xA49D989D,0x810D03A2,0x1F1B2210,0x1502860E,0x1A099503,0xA6848A14,0x97A09299,
0x1C168A9E,0x1B060B23,0x0E0B121E,0x818C9383,0x99949B9C,0xA29FA4A3,0x12218299,0x22112116,
0x83131E19,0x00088410,0x85928404,0xA8A49594,0x9B8B9EA6,0x150F8797,0x0B871A20,0x0A87221A,
0x101D0509,0x93978207,0x97888D94,0x0D078E88,0x8891800E,0x948A8982,0x118D9696,0x06908E04,
0x910C8017,0x8793109B,0x08038B8C,0x131D2123,0x0305211B,0x858E9D93,0x8A9DA391,0xA0959791,
0x05849EA0,0x07191592,0x04191211,0x16018F96,0x1710131C,0x94970916,0x0D888293,0x8D879501,
0x95900981,0x962003A1,0x06A09902,0xA19B0087,0x81028891,0x1E1C1008,0x030D1215,0x09131304,
0x06918601,0x94999205,0x92978A86,0x8203A2A0,0x8F958A8F,0x1715130F,0x1115180A,0x96888481,
0x8D8A8C8B,0x11028F91,0x84979410,0x0D890320,0x0E100E8C,0x9092A18E,0x93901207,0x9080858C,
0x098C9798,0x92080584,0x11151201,0x1B068491,0x840D900C,0x89960D1A,0x0689939B,0x91010A14,
0x95871002,0x8787919A,0x038E9006,0x00908D03,0x17189193,0x848A1188,0x95868314,0x0202118A,
0x02840383,0x87838A0B,0x1304028B,0x81849687,0x8C808202,0x90101490,0x8B940292,0x92888809,
0x0501108F,0x8004040C,0x910C120F,0x0E88918A,0x8D93858C,0x96879009,0x8408138E,0x1690900E,
0x95909004,0x0810078A,0x14128997,0x919A9112,0x0B858385,0x848E9304,0x86938A03,0x8D861685,
0x080A9000,0x9E900F92,0x191D028A,0x13100382,0x97978485,0x90848689,0x13809886,0x958F978C,
0x1186160D,0x010C8F00,0x829E9612,0x88161500,0x06150B86,0x8C959F97,0x85838986,0x0F070F8B,
0x86859584,0x069C0F1B,0x930C0489,0x0C999704,0x10090780,0x02078013,0x8596918E,0x93818D83,
0x87808D8C,0x0C94908C,0x14880B17,0x94130304,0x88958802,0x83020E88,0x86810301,0x888E9890,
0x03080B81,0x0C0C858A,0x0E840B0E,0x05030B15,0x8E8F8B8D,0x939C9D95,0x8E838491,0x0C070187,
0x11858386,0x04040F1D,0x09058004,0x889A9093,0x85018312,0x8E870090,0x8391908A,0x0B141001,
0x010A0A05,0x908F9493,0x8A968A8B,0x9080928C,0x0E93918C,0x170F1616,0x8615140A,0x818B890D,
0x8B0E028C,0x908C8991,0x90919E9A,0x04890504,0x90120F83,0x028C9280,0x0D941417,0x890C8E8F,
0x85959F01,0x03151482,0x8D008581,0x828F0092,0x90078789,0x0388910B,0x889B8396,0x130F091F,
0x07110905,0x8E939088,0x01079183,0x03948A91,0x94809384,0x0D000A89,0x0D0D8184,0x918F8F86,
0x8C921012,0x05078A90,0x008E888F,0x0A058014,0x13080F08,0x8E008B86,0x958C9087,0x8F97849B,
0x96048F8B,0x130E200A,0x10050212,0x95960001,0x06889408,0x0A00828F,0x86038711,0x8C850C8E,
0x85809290,0x8B859105,0x8703178C,0x0F948310,0xA2090689,0x170B0104,0x1B040981,0x81928016,
0xA3889301,0x849599A2,0x858E9392,0x12201A03,0x14101519,0x95888706,0x8E958C96,0x0485968A,
0x05861012,0x8C050084,0x008D9393,0x8A8B040D,0x071C068D,0x85910492,0x998A830A,0x0A0C8B92,
0x1B8E098F,0x8A0A0319,0x86908506,0x9B979095,0x918E8C80,0x18028095,0x811E8281,0x06900714,
0x07839193,0x05040581,0x850E0A11,0x928E8B87,0x92979398,0x94919392,0x16810080,0x13188012,
0x82841200,0x890B9789,0x08830693,0x8410038B,0x88818505,0x93968A85,0x95969190,0x11858792,
0x02100210,0x830C1602,0x00839393,0x84828B91,0x05081218,0x85021002,0x96949C8E,0x9696929A,
0x07198896,0x18131A11,0x8F101811,0x948A850A,0x85988298,0x00019102,0x05818108,0x8697928A,
0x90939382,0x1110180C,0x12100C0F,0x8F838A06,0x92968783,0x850A9098,0x19818605,0x82820E12,
0x9D889281,0x02929BA0,0x09899291,0x0614110C,0x10128611,0x8692098F,0x90080086,0x83088C05,
0x83961187,0x9C899593,0x848D908F,0x01080C93,0x1117131A,0x82851387,0x8D8B900A,0x8D958980,
0x84000683,0x00888F81,0x84959489,0x02848509,0x10128A82,0x100A0903,0x80068683,0x948F9090,
0x868F8E01,0x8B891087,0x86818688,0x0805948C,0x05868191,0x92131102,0x060B0C00,0x8D88088D,
0x928D8F0E,0x888F0586,0x8A8A828F,0x86898588,0x0B848508,0x0E00840E,0x078E0308,0x07838B09,
0x88048D8B,0x03848481,0x90838392,0x85868C81,0x850B8393,0x8582808F,0x850F0D07,0x890B0704,
0x0A8D0A84,0x90860006,0x8B870A09,0x93968C90,0x89949190,0x08018909,0x180F8100,0x19820111,
0x8E068508,0x8C8B9284,0x00878493,0x9681848D,0x9184908E,0x88930988,0x120C070F,0x020F0405,
0x04888710,0x878D848F,0x92000603,0x85828901,0x90878E97,0x8B8F928E,0x88880D87,0x0F0F000F,
0x05081710,0x07840A0C,0x90049187,0x85928F8D,0x948E8992,0x91059792,0x10890295,0x8309140D,
0x10151719,0x8C850E0B,0x938C8501,0x938C8896,0x8A899A95,0x008A8181,0x06110B8C,0x0F860110,
0x05050916,0x82101682,0x81089088,0x95979192,0x918B8E95,0x05120098,0x81080E03,0x0606120B,
0x8C0C1200,0x89030700,0x8790030B,0x8A909186,0x949B9792,0x90108497,0x18840D01,0x04111016,
0x85020915,0x87850788,0x85800083,0x8A86878A,0x9A9A9684,0x9384098F,0x15800F81,0x09800214,
0x8701151D,0x830A0B01,0x05839495,0x99988A02,0x908C8A93,0x8996900B,0x1090030F,0x0D110D08,
0x0F120A15,0x80870711,0x8A8F8D88,0x9191998F,0x03998B86,0x0E889181,0x1903900C,0x160F0203,
0x12018216,0x85048808,0x8E87808C,0x93849899,0x07909A94,0x08129996,0x1410818A,0x14181180,
0x07110F0A,0x8E80078D,0x9B848185,0x94908D94,0x9085869B,0x86110690,0x0211180A,0x0A1A1901,
0x0282010D,0x96970380,0x96830C04,0x85939093,0x97A08514,0x8081080F,0x1A919284,0x03860E1B,
0x1A181313,0x0C908505,0x9B979303,0x91989E95,0x0897A19E,0x05069501,0x24231D81,0x1B1C141C,
0x07171617,0xA5979795,0xAEA8A5A8,0x1C1281A4,0x090B1112,0x1B252421,0x99970512,0x108D979D,
0x950E2020,0x0A0F1088,0xA4A2968C,0xA4A49F9D,0x06060F95,0x26978E15,0x111D2D33,0x16048913,
0xA0998E84,0xA2A3A2A0,0x041F0E94,0x1994A09B,0x89061019,0x25188485,0x1F1D1D1F,0xA69E8917,
0x1002A0AA,0x920B8393,0x232495A2,0xA7970111,0x9395A5B0,0x122D2F20,0x21202813,0xA4971826,
0x9BA1A2A2,0x0E100991,0xACA38A16,0x10A1A7A7,0x129CA39C,0x2F2E2F2F,0x1A263332,0xAFB0AB91,
0xB2A5A1AB,0x272220A4,0x09881326,0x9DA19C16,0x0AA0A7A8,0x33312825,0x0A191E2C,0xA99DA095,
0xA1A7AAAC,0x19210F97,0xA01B2315,0x97ACA4A7,0x070D9382,0x3431302A,0x861C302E,0xB6B4B092,
0x909FABB2,0x1E110C9D,0x1627252E,0x86A39583,0x80919F97,0x81162622,0x0D162D10,0xA7A3A916,
0x10A2A3A2,0x850B9BA8,0x23218412,0x24038D13,0x01210C8C,0x93222019,0x92931499,0xB39F9091,
0xA217A2B4,0x03A01D81,0x15142814,0x1C242533,0x83A20911,0x9FB0A20D,0x139F9126,0x1D869DA3,
0x8785B199,0x1B100186,0x22311C93,0x223198A1,0xAA9C2401,0xAB0610A5,0x12030F0D,0xA6A32013,
0xB5AB928C,0x219F1198,0x25191129,0x2F1C2032,0x0F151C1C,0xA1A7B098,0x83B0B0A7,0x891FA190,
0x1508849E,0x232A18A0,0x21302E31,0x951A2413,0x959EB2B0,0xACAC98AB,0xA41B9190,0x30861712,
0x99991A1B,0x9D100221,0x26311CA4,0x15921426,0xACA52188,0x9920A7A0,0x94AEA3A1,0xB2A60091,
0x27273288,0x2428172E,0x1F952735,0xA1872191,0xA2AAB7A3,0xADB8B2A2,0x26101209,0x3225819D,
0x1C299730,0x22233628,0x9013929E,0xA2B7B49D,0xB09B9D0E,0x239290AB,0x1690A1A4,0x1B292336,
0x32302D00,0x2790A404,0xB4988D21,0xAA95A8AC,0x8AAAA3BB,0x9922050F,0x222E3222,0x32270A8F,
0x9B0E2726,0xB017890F,0x80A49CAD,0xAEA698A8,0xAA8C8F8C,0x32278EA7,0x22203027,0x9E252A2D,
0x0D111618,0x9DA99499,0xB3ACAAA1,0x910EB2B5,0x2089249A,0x1C303223,0x2C2B2D37,0x9A9A2122,
0xB4B1AB9D,0xA28FB4B9,0x0BA59797,0x12202998,0x2C331E2C,0x17112D2B,0xB2A0181F,0x9B8DA5B3,
0x94B1B185,0x06961A9A,0x29320189,0x20141F21,0xAA991021,0x902129A7,0x9D9FB00E,0x1EAC8583,
0x882995A4,0x1F248092,0xA2921090,0x901F2C05,0x84898B17,0x8E960615,0xA011A5AC,0x9C089BA9,
0x841D2B94,0x2C2E2E26,0x9E9D2231,0xB4AD9C8B,0x90A2ACB4,0xAC00230C,0x949014A0,0x3A1E2823,
0x88193744,0x1A8AA294,0xB1C1C0AB,0xACB0881D,0x3410B2B3,0x39929332,0x2A3B363D,0x3726A39D,
0xBDAD9C18,0xAF1593B8,0x02AFC4C5,0x9C0B1D11,0x3B494108,0x23151621,0xB7813937,0xA291A1B5,
0xC1C3B4A5,0xB3012EA5,0x3D0AACAE,0x03A43442,0x363D3D37,0x2FA2B587,0xB8ADA128,0x9393BCC2,
0x9DB4C0BA,0x153B3721,0x40402FA3,0xA406353E,0xAD15351D,0xB7C1BBB0,0xC2C2A788,0x383411B5,
0x368F9136,0x11323E3E,0x322C96A2,0xBCB7A419,0xAD8FA4B4,0x12B0B5BD,0x9B27313B,0x38322C98,
0x82A39E2A,0x102A302A,0x2196C0B7,0xBEB39D9A,0x1B3B26B5,0x20A59C94,0xA21F3B39,0x342E88A3,
0xAFBCA131,0x8E06A0A3,0x27A4BCB2,0x9825322D,0x2A2285A6,0xA4B38733,0x9A19311D,0x1DAFB192,
0x929E9224,0x301CA49A,0x96212118,0x97218DA5,0xB6AD0BA2,0x0F263006,0x29A4A085,0x93861736,
0x2C17A6A6,0xA7049991,0xA51118A2,0xACA483A5,0x2B11281E,0x2B908A31,0x8986032E,0x8292B7B7,
0xA01D2592,0x942A2B9E,0xB4B7880B,0x17A40204,0x321C2534,0x24269227,0xB8A8B0A9,0x8E3125B6,
0x91961594,0xB1A73035,0x29A7AAA7,0x10050830,0x92322B86,0xAEA49BA6,0x069C09A1,0x0E922733,
0x25181720,0xA5B7BC91,0x952489AB,0x112B1EA2,0x80122C21,0x8FAF9321,0x2428282F,0x889F9E04,
0xC0A4A09D,0x9EA3A0BC,0x30233026,0x218A2F3C,0xAFAA0330,0x23A0B3B2,0xA5142728,0x101E21A2,
0xA5B4A810,0x2D11890D,0x151D1628,0xAB021680,0xACB197A4,0x1BA3908F,0x29202C35,0x2902A202,
0xB2ABA21D,0x232984B2,0x8CAD1C30,0x0B980225,0x249DB8A1,0x3126A7A3,0xA32B301F,0x9F10219C,
0x99B7B7A8,0x3322ABA2,0x24362F2A,0x1129129A,0xB0AE9387,0x14020198,0xA113A191,0x9E02A9B7,
0xB397209E,0x3235338E,0x05963038,0xA3212621,0xB0A8AAB3,0x98A5A3AE,0xA6A5252B,0x27141513,
0x09A8A521,0x91060514,0x82112E25,0x1F8E0081,0xA2B7B21C,0x260C958A,0x21258316,0x2A189590,
0xA5A49E21,0x09119CAA,0x139DA49F,0x0B101021,0x172195A0,0x3133A0AE,0xB0042E27,0xA5143211,
0xB3B6B3AE,0x1897AEAD,0x9326352C,0x182E3926,0xA2B8AC20,0x098F9780,0x95A5A995,0x1A84A1A1,
0x2AADAA08,0x3634353B,0x1825182C,0xAFA0A6A5,0xB9B9BCBC,0x323013AC,0x3632A290,0xAB20332F,
0xA1121BB0,0x851D271C,0x8CA8A399,0xBDA71011,0x879C10AD,0x312A3132,0x07980F30,0xB3B0A412,
0x3683B9BA,0x23A49630,0x182F232A,0x9D92A5AB,0x3120A5AB,0x9C202E30,0xA61D85A1,0xAFA0B3BE,
0x282C3195,0x81813033,0xA6102E2A,0xACB5BBB5,0x94A41B88,0x1A14373B,0x1A99A685,0x05B3B204,
0x20213032,0x2F1DA797,0x8518B19F,0xAD98A9B8,0x282F2E90,0x13332E24,0x9EB0AF9C,0xBDA32A85,
0x10172F95,0x27A2A60B,0xA9A20A30,0x00861194,0x2B208997,0x30A0B316,0xA7018A1C,0x1522219D,
0x2B290192,0xB5BDAB22,0xB81A308F,0x109589B3,0x2D1D1F29,0x1D828329,0xAC892127,0x2591AEB5,
0x3098B384,0xAEA10F28,0x9330318B,0x2E06A3AB,0xB1B10833,0xA680298D,0xA1A21210,0x2781B2AA,
0x23050515,0x95183033,0x3328A5A6,0x0A93B7A5,0xB5A61794,0x2229298F,0x192D2717,0x9AACAFA5,
0xB0C1A225,0x2A32282B,0x2A2EADB3,0xA6952214,0xABB2021C,0x2436258B,0x9C2726A1,0xABC1B086,
0x93AA9D20,0x3542341A,0x37289BA6,0xA5B3AC2A,0xC1B1B4B2,0x213338B1,0x2F170125,0x0BBEB132,
0x9F113235,0x2A372D8F,0x93A2B3A7,0xBAB6B3A8,0xA4262DA8,0x33433F0A,0x07013126,0xB4C6BA21,
0xA1B2AB87,0x2F29A19D,0x3D2D9109,0x8A84A316,0xB1192811,0x10343597,0x208AB0AF,0xAABFB111,
0x8BB1082F,0x2B391406,0x1C2A91A8,0xA6B39F8D,0xAEAD121A,0xA12F380C,0x238B1115,0x36B5AA2B,
0xA5A2B01C,0x9924901D,0x213D22B6,0x8F9C83AD,0xB4B51430,0xAF213020,0x91039BB4,0x3A07A79F,
0x0C0FA422,0xB1143127,0x2C362AAB,0x2596AE94,0x9CB7A523,0xA4ADB38C,0x08231098,0x342D01B4,
0x20019932,0xB4A7131D,0x24842B12,0x29280A2A,0xAAA5AFAE,0xA7A5A0AC,0xA7A80133,0x17273F87,
0x2A990B23,0x86ADBB1E,0xA31E1E0E,0xA9312EA2,0x2C2E9BBC,0xA6991B99,0xAFA12036,0x14821E91,
0x1C1A8094,0x3627B4AA,0xAD869C9B,0xBBB9141B,0x37301799,0x3F2D2007,0x92A8B530,0x12A5B287,
0xB13023AE,0x1C1B2DA2,0xA9A8AB98,0x96B58B06,0x29992F42,0x1F322C20,0x088ABABB,0x9AB4B188,
0xA022362E,0x06303F2A,0x26ABBBA7,0xADABBDB5,0x19202124,0xAE213582,0x082A30A1,0x36A18120,
0xACAAB032,0xAEB298A0,0x2A202214,0x293911AC,0xABA78527,0xADB7AA07,0x0B158AB2,0x3A39291E,
0x012F9488,0xB99697B1,0xA0B82F24,0x0C2B3522,0x049DA117,0x309CC1A7,0x912A04A1,0xAD8F3E27,
0x1583ACA1,0x81279BAD,0x32ACB113,0x07191E29,0xB0303F12,0x2F20A8A0,0xA1A9B1A2,0xB4C3A321,
0x3714801E,0x22431FA0,0x20A3002A,0xAAA2B2A8,0xA2B01BA5,0x3722303A,0x9C359420,0xA0A4ACBF,
0x12AA8F1E,0xB8892E12,0x20B01B27,0x231CB421,0x281899B7,0x2A1D2134,0xB3A70D1E,0xA5062092,
0x3C24A58B,0xB0A8A9B0,0x909F1222,0x99302A16,0xA7803183,0x90BBB315,0x20A6A398,0x331C852F,
0x98312137,0xA02727B5,0x24B3AEA2,0x9595AD13,0xA99C2F24,0xA73090AA,0x8D2130AB,0x07AC3222,
0xA1B5BA30,0x17972419,0x30342530,0x9C3889B3,0x0EB7ADB3,0xB792A122,0x912A369D,0x14892319,
0x8E26AAB3,0x10961798,0x8D8E2038,0xB9A0239F,0x3600878B,0x3931AFA3,0xB493821E,0xAEA7181C,
0x922F14B7,0x2296849E,0x0404A51C,0xA92C3896,0x93B01738,0xA48C10A4,0x18ABA7A7,0x3410B413,
0x1937322D,0xB3A83227,0xA592C1BF,0x14811CB4,0x3439202F,0xAF918311,0xACB4270F,0x122D0696,
0x231E1B9C,0x35B3B620,0xAB29A823,0x949A30B0,0x952F90A3,0x9A181AA7,0x38A7B001,0x90321D2A,
0xC3AA3914,0x2E069CB0,0x31249E8F,0x25B9AC3A,0xA114B295,0x9C2535B0,0x2630910C,0x97078FA7,
0x1DA1AEA7,0xA2A3012F,0xB0303CAA,0x2B22A594,0x18A6AE9E,0x34AF9B29,0x96322438,0xB19293B9,
0x1A2EB3BF,0x322F1302,0x95BE102E,0x9B190A32,0x94392FB2,0x268BB0A9,0xA1B2AEA3,0x2EB6133B,
0x2D269B29,0x9D3913B0,0x2422A9AD,0xA5A9A8AF,0x11B12123,0x81212B40,0xB0280DBC,0x32A4BBA5,
0x010B2B23,0x9DB81226,0x30251535,0x94341899,0x0CB1BCB0,0x2528B2B6,0xB0A4402E,0xA2831C35,
0x0231A3B8,0x28B2A504,0x198CA785,0x8884322F,0x07AA1637,0x8831B4AD,0x3D87A0B4,0xB210A314,
0xB9B32B87,0x39213232,0x01329B1B,0xB3C0B8B3,0x2A0B2391,0xB19C243E,0x27AE2F35,0x3138B5AB,
0x22A5B1B5,0xA191A72B,0xB9233C87,0x0E1123A3,0x21A1A404,0x042D93A0,0xADAD9011,0xB7AB1D1A,
0x343A4505,0x2DA4B037,0xB5BCBFAC,0x241C0716,0x8523209C,0xA6172D9B,0x2A18101F,0x0692A106,
0xA09A9C03,0xB59D2491,0x8F3925B5,0x1EB61930,0x11912531,0x979CB295,0xA2A793A8,0x29403119,
0xA4A92189,0x99C0B40B,0x1E391A1C,0x041A298E,0xA316AFA6,0xA0A1349D,0x24991031,0x8F219411,
0xB8A99BAA,0x2B3398B8,0x1A003330,0x06B1153B,0xAE30B1BA,0x0E841EA9,0x2337280E,0xB0B02D27,
0xA1C2C2AD,0x20281184,0x133C3830,0x85A10984,0x048E969B,0x9A848E97,0x99A0171D,0xB39D888C,
0x3A322D94,0x10120F09,0xB1B8B41C,0xAFB2A7A1,0x334323A8,0x23344026,0xBEC0B491,0x24A3A5AB,
0x2B363637,0xAB992C2F,0xB7A2B4BA,0x399D87A4,0x9230932E,0xAEB72C1C,0xB0A1AF9D,0x40402BA2,
0x32300028,0xBBB7B5A4,0xA7A18497,0x2B30398D,0x273C2B2C,0xB2BEBAB5,0x8FBAB99B,0x29213838,
0x90363122,0xACB3BFB7,0x372687B0,0x312D3340,0xBEA4312C,0xB7B1B3BC,0x402CA7B7,0x24212135,
0xA2A31033,0xBDAFA9B6,0x383306B0,0x302F2B2B,0xA0A30030,0xBDBDB8B3,0x283B2BB0,0x2C273D37,
0xB4A99B20,0xAFBCBAB3,0x35362798,0xA1833936,0xB0989CA2,0x22B0B8B1,0x36342F1E,0x1D8F2240,
0xBA9A0A83,0xA7B8B5BA,0x3C3282A4,0x258D223F,0xB3A71A19,0xB5AAADA6,0x373617B1,0x36291A31,
0xB4A81E87,0xB6B5B115,0x333030A7,0x2A2B1A2C,0x96B0B3B1,0xBFBAB090,0x302D311F,0x333C2E31,
0x1FA49FA1,0xACB0BDA0,0x9A9A239B,0x19373925,0x2318A0A4,0xA7ACBDB0,0x07B1A299,0x1D3D3E23,
0x98023234,0x9B9CB2B0,0x17AAB2A1,0x21292E11,0xAD803839,0xA09DA6B4,0x05A0B09B,0x2C1B8CA5,
0x981D2938,0x8CA7A4A7,0x82250F8A,0x332882AE,0x9C252736,0xB3BDAA9A,0xA21208A5,0x2E078CA8,
0x98242829,0xAAB6AA83,0x092405A2,0x2C202931,0x040F1D20,0x919EA90F,0x1F9FA9AD,0x8F248E26,
0xA5A7A0A7,0x062186A0,0x350C8C08,0x0D302A2A,0xAFAAA581,0x05161E99,0x1F030E23,0x11851593,
0xBCB3B593,0x04A002B5,0x2A34312E,0x23222D26,0xA78A9807,0x8AA7A69C,0x19202B14,0xACA39126,
0xAFA7A3B5,0x32A4B1A2,0x3229252E,0x9F102525,0x1D189498,0x17151518,0x8A9F9010,0xABAEA49B,
0x92A7AB91,0x20310CA1,0x1C120E1D,0x2089180B,0xA1112028,0x242293A0,0xA4021007,0x9FACB7B2,
0x1A032487,0x9E871625,0x9C0F1C0C,0x230682A9,0x2918102D,0xA3962130,0xA99E9A94,0xABABAFB4,
0x331D99A3,0x94212328,0x0B099015,0x18303723,0x97A3A7A2,0x9AA8A486,0x90A68989,0x8A918410,
0x858EA49E,0x1D251992,0x1E8A8220,0x2E223132,0xB3AC9724,0x2104AAB4,0x98130002,0x97A0A49F,
0xABA8A093,0x26253091,0x2A302A2A,0x220DA113,0xBCB19C0D,0x211698B1,0x22323223,0xA3A6B1A5,
0xABAEA49A,0x148A1C9D,0x1C313231,0x86900792,0xA0A09A14,0x30929A8D,0x93192632,0xB0B1B3B2,
0x0B16A3AB,0x38341D82,0x99962231,0xA08DA0A2,0xA8A59492,0x3135269E,0x96022930,0xB4AD99A2,
0xA9B1B1B1,0x3735200D,0x8F82222E,0x920C058A,0x95A1A098,0x26262097,0x921A2030,0xA5802194,
0xB0B4BDBD,0x27180285,0x222B3220,0x82190928,0x8FAE9D99,0x202F2204,0x18099121,0xA2801D17,
0xB5B2AFB2,0x2094AEAC,0x04132D27,0x8B313023,0x1EAEACA8,0x23242F2D,0x8B91832D,0x970F1B19,
0xB1B1B0B3,0x8083A29E,0x0100149A,0x06170D18,0x2493101A,0x2D252D29,0x14129423,0xA9A5A103,
0x1FA1B7BB,0xA986891A,0xA51B2A80,0x252092A4,0x2A15191A,0x16241E24,0x9DA1A4A3,0x978887AD,
0x23282318,0xA2A78118,0xA8B1B3A6,0x20208097,0x2531382E,0xA3979081,0x94ACAE8A,0x2C800198,
0x222A242C,0xB2A9AA89,0xA4A192B2,0x2D140899,0x8D1D2C32,0x11108914,0x1510A1A9,0x8E191213,
0x82181F8C,0xB1B3AA95,0x8611ADB3,0x3316211F,0x1730352F,0xA4A51220,0xADABA6A2,0x3633269B,
0x91A2AC29,0xBABB950F,0xA392A8B6,0x3B2D2516,0x0B2B2632,0x12A0A305,0x00100A11,0x86050813,
0x86A4150F,0x028FB3B4,0x0B809D19,0x9526301C,0xA5A5A0A3,0x139E9D86,0x1702272B,0x232E228B,
0x9491A413,0xA8A9800C,0x85901D82,0x231F9593,0x168E9F00,0xA298A0A3,0x0D13859E,0xA502178C,
0x881E288A,0x80111215,0x20101823,0x91181423,0xB1B0ACA4,0x919298AC,0x32332929,0x83A49A1E,
0xA6B0B4A2,0x202121A2,0x35382913,0xAEA88921,0xB9B1A2AD,0x271C2C87,0x2920222B,0xABAD952D,
0x2513B4AD,0x3117AD9E,0x9C1F0E24,0xB8A019A6,0x21281AB3,0x2814262C,0xA59A2434,0xA2B2B0AE,
0x2A2697A8,0x152B3327,0xB8A11217,0x91B6B7B5,0x2D1F1808,0x30393232,0xB2AFA888,0xA0A1A7A9,
0x323C2D92,0xA817362F,0xB2BDB8B0,0x22AEB0A5,0x37353336,0xAE822A2E,0xA9AFB7BB,0x3884A2A0,
0x31333239,0xBAAE1733,0xB1A5B0BC,0x253322A8,0x25203433,0xAEB9A920,0xA2B8B103,0x32273121,
0x8A2E1621,0x95A6B2B0,0x09179EA6,0x262A341C,0xA0A38521,0xAD9F8087,0x8A3118AA,0x262B91A2,
0xA2B6B5A1,0x8D941F24,0x2E20262A,0x15ABAA25,0x0E0BA498,0x31371C9D,0x8B2E06A7,0xB4B4AAA4,
0xAFB20B8C,0x16203427,0x96102C2E,0x14A2B2A3,0x3080AD8B,0x26262336,0x8C9DAF9E,0xA015B1B2,
0xAB333894,0xAC3237A7,0x82B3A9B3,0x28BCAC25,0x298C3042,0x9B110730,0x1825B9BF,0x28380EB3,
0xAB132524,0xBB9A0DAA,0x82A50EA5,0x2EA0303A,0xA9A02C3B,0x9E08AEB4,0x442CB9C0,0x301FA42E,
0xBE9C3230,0xBC8730AD,0x268D90A8,0x16B59635,0x22A10F35,0x3425B20A,0x2A25B4B2,0xB1919EAC,
0xBC1E3F06,0x9F393DB0,0x920886B0,0x15BCA327,0x9DAA213D,0x3228A511,0x30B1C0B2,0x22988E35,
0xAB31331F,0x0B28A1C0,0x308FAFAD,0xA9A42F3D,0xBF2B3294,0xA6A803B3,0x3210060B,0x9787273B,
0xB99314A0,0x4228B2C2,0x372BA32B,0xB9BB1630,0xB4A79897,0x45369DA9,0x9699043B,0xC6B72C27,
0x2F9EB0B9,0x45401B0C,0xAAA18435,0xC6BB8AAE,0x313696BA,0x2A3F341D,0xB9B31324,0xABB9AD98,
0x443B2B1F,0x2AA1B127,0xB2CAB92F,0x05228A98,0x34473799,0xAB8C8CA6,0xB9BCB2A5,0x30422FA3,
0x0A2F350E,0xB8C2B118,0x14B29515,0x2E3C372B,0x2999A496,0x23BDC394,0x20299E15,0x923B3923,
0xAAA1A0B0,0xB0B5B4A5,0xA9303E24,0x95233D0C,0x27AEB187,0x119CA30B,0xA134361D,0x3185A7B1,
0x2AB3C10F,0xA686A183,0x86262C03,0x292C8F98,0xAFA4A01A,0xB6233891,0x250E3389,0x22B0A82F,
0x97B6AC23,0xA2A31119,0x3D2AA6A2,0x0521B39A,0xA61F91B3,0x27333310,0x1E282E30,0xBDBDB6A7,
0xBBB12A06,0x2F2D4035,0x0994A821,0xAABFC1B2,0x2D1E2905,0x42453330,0x929EC1AC,0xB9B6A9B4,
0x26404011,0x07363517,0xC6C5C1B6,0xA5B72193,0x40384042,0x2399A82E,0xA3B2BDAD,0x32301A17,
0x34432A19,0xBB8AB7BF,0xA2B4B0C1,0x19263D30,0xB0243632,0x9BBDB2B8,0x31B48236,0x26233C4A,
0xAA13A396,0x19B0C5C1,0x191C202B,0x963D2C97,0xA726B9C5,0x13A622AE,0x932D4441,0xAC0B372C,
0x8FBFC0B7,0x399E9D30,0x8D920B41,0xBCB0B3B4,0x3320AFB8,0x3035312B,0xA03D3623,0xB89C9AC0,
0x3A8EA5B5,0x960A3342,0xBDA92B2C,0x96B5C4C7,0x40A19C34,0x2932323B,0xB09F1C2C,0x139DB5BA,
0x172C2C20,0xAC343317,0xB4B1A6BC,0x10A59EA5,0x2820042B,0x8C1F302B,0x19A2B8B1,0x2F9FA425,
0xA0253032,0x9B1187A1,0x2E06AFB4,0xA18A0A20,0xB421341B,0xB18DAAC1,0x371E230F,0xA4893032,
0x93902128,0x10B9BDB0,0x3A231C36,0x23333132,0xBDB3B7A8,0x83A3BBC6,0x31342F21,0xB0293936,
0xA22121B3,0x9AA1AAAF,0x25852D2C,0x95243D3D,0xB8BBBCB4,0x23BFBDB0,0x393B3B33,0x1981B028,
0x303594A8,0x92A4B3B2,0x272B1B05,0xAF312600,0x9F1426B0,0xBFBAA3A4,0x17093522,0x911E8E21,
0x9A9B2116,0x99B4262B,0x10119126,0x3D22B1B0,0x1C128931,0x9CB7A41E,0x0B8AB9A1,0x262598B1,
0x00270D24,0xA01B3196,0xA783A392,0x903A34AA,0xAD932A98,0xACAD1618,0x24AF9E1B,0x21A4A713,
0x0BACA620,0x25A3253A,0x331AB29B,0x292BA597,0xBCA32210,0xA0363DAA,0x2F25B4B7,0xAD0BA09A,
0xB1A309A9,0x352E2CA3,0x23A09D37,0xB1B48C2E,0xAC0722A2,0x2A283024,0x92B29727,0xABB0A721,
0x958C98A4,0x3B22A896,0x36A4B023,0x21388624,0x212CADB6,0xB6A69BA5,0x070484A1,0x14443DA2,
0xB21C99AE,0xBFB81DAD,0x0CB01015,0x39283437,0xAFB29736,0xAAC21332,0x2F8AB597,0x462F9B25,
0xA7298E2B,0xAD97B2BC,0x2798B8B8,0x333D2491,0xB22B3484,0xB08692A7,0x8393309C,0xA1992233,
0xB0892699,0x889296AE,0x829E2B36,0xA8B69625,0x3310B1A5,0x321F9915,0xA5A12836,0x9B929FA1,
0x311AA9A1,0x8D0E0913,0x9B24241A,0x23A9B3B1,0x1A13AD93,0xA22E3115,0xA92326A3,0x12B09398,
0x05948B30,0xA41D2A1E,0xA48982AA,0x19A69C91,0x18931922,0x1B342123,0xAAB7A1A0,0x92B3A787,
0x34202A35,0x1D15A31C,0x8114B6B3,0x200189A9,0x27231425,0x1D27B0AA,0xA323099B,0xB5042BAA,
0x0B0F1B9E,0x920A2123,0xB71C328A,0x9FB5009A,0x0AB9A027,0x31118238,0x341A9A22,0xA7B19F1E,
0x03A1A382,0x2E24A2A1,0x2929968E,0xA52B0D9A,0xA8198DB1,0x2A15B3B5,0x28310A9D,0xA9223424,
0xB7922997,0x8FB01C81,0xB0981730,0xB310299C,0x209421AC,0x10B3A52D,0x2E9F0A33,0x23341530,
0x10B4AFA6,0x93BAB710,0x2A320112,0x333688AE,0x9B279FAC,0xB4903018,0x8F259BB6,0x122181B0,
0xAEA22E28,0x9C033022,0x17A98720,0xA6A1AB02,0xA51A3083,0x8C052707,0x23A6A913,0x3319A322,
0x11049C18,0x83ACA79B,0x1BA2B108,0x231DA199,0x2E362083,0xA61A281B,0xA8A3859E,0x0F26A8B5,
0x022E04B4,0xAA132702,0x9FA22718,0x90A61E2B,0xACA9861D,0x11A52920,0x11A21033,0x2D90B381,
0x0302A30E,0x192492AA,0x240C9D83,0x8F8CB3A4,0xA2282395,0x032D29A7,0x9E17352A,0xB6AC8610,
0xA71890B8,0x8B8584AA,0x1B813233,0x11AB1733,0x240C9C15,0x93B3B49A,0x25A6802A,0x05088728,
0x262895A2,0xA804A2A6,0x122D3085,0x1009A8A1,0x8D19A5B1,0xAE940D95,0x232C3B1C,0xA3A02231,
0xA9AAAB9C,0xACB5A3A2,0x32292E2C,0x3291842E,0x8C95AA07,0xAFA2ABA7,0x2F2C179D,0x21278F9A,
0x9C0FA190,0x992024A9,0x92932717,0xA9A90C20,0xA6A69187,0x23978311,0x23252430,0x01A6A681,
0x112499A0,0x221C83A0,0x2723B0A6,0xABA09D97,0x1A1B13A7,0x91292D1E,0xA39F211F,0xC4B6290C,
0x199315A5,0x23172832,0x1721111E,0x099FB09C,0x351CAFB0,0x291DB186,0x8214A18C,0xA29D2A85,
0x90121320,0x9EA1211E,0xB49D1698,0x80971692,0x26162727,0x22149014,0x949EB5A0,0x262695A2,
0x80322497,0x9BA8A4A2,0xADA9840B,0x13212194,0x2F232320,0x13B3A22A,0xA0A7B117,0x0A05A5A5,
0x26302F87,0xAE9A8006,0xA516218F,0xAF103491,0x80200AA0,0x2096A5A0,0x1985A113,0x8E2E9591,
0x22312BAF,0xA2A3090F,0x90B7B017,0x199A9902,0x0C211E25,0x122B3424,0x9D8D9C9A,0x8DA9BAB1,
0x21A88D8E,0x18353130,0x1E168D08,0x138AB1B2,0x9E82081A,0xA396180E,0xADA9819C,0x981A1886,
0x201A3530,0xA1812C23,0xA5B0B292,0x81A5B1B0,0x282E271A,0x302A0312,0x12089407,0x9E01A092,
0xA6AE93A3,0x0E2492A3,0x100E241A,0xA28D250F,0x1C0F1119,0x86938A23,0xB49397A8,0x8D1A14B1,
0x31333219,0x9697902B,0xB5B4A89F,0x0207A6B2,0x3633228C,0x1C1C2130,0xA4B3A511,0x0B920A1A,
0x9C850610,0x9513B0B3,0x312B94AF,0x251D1726,0xA4951728,0x9E9B1494,0x909BA79F,0x21959F97,
0x17921222,0x9D9D2130,0x12081611,0x0208A19A,0xA4A19C9A,0xA1912284,0x1B2B2710,0x2124A09E,
0x14A6A392,0x99A68F24,0x91841915,0x171298A4,0x28949C16,0x05AB8C2E,0xA4121B21,0xA8200DAA,
0x29219FB5,0x2B0C8923,0xAEA02731,0xB29207A0,0x102C1AAB,0x311F93A1,0x1BADB219,0x91AD072F,
0xA606302C,0x9C2A2093,0x978DA9B6,0x2D10A8AB,0x31131C30,0xADA22335,0xB4A51399,0x2323A4B0,
0x32299AA3,0x13A59828,0xAAA80F26,0xA41E2397,0x15222490,0x0A93A198,0x08ADA312,0x00A50E2A,
0x9A811322,0x0F23029C,0x243214A9,0x1D13A09B,0x9DB3A412,0xADA20E1D,0x8324298A,0x23281F90,
0x1E179685,0x0EA8B1A1,0x989DA385,0x90152817,0x13222614,0x81060210,0x9EA69F8D,0x999B9E94,
0x24259EA2,0x2A2E1806,0x98041414,0xA3AA9083,0xA3AB0514,0x95891115,0x282A1687,0x2720A495,
0x94929689,0xA9A40A15,0x9D961098,0x30208B00,0x221F861A,0xA28E0C16,0xA7A3909F,0x9BA70C85,
0x889D1524,0x1924170A,0x0C2B2285,0x98828B91,0xA6959CA5,0x0E1982A5,0x20241506,0x1C0C8B02,
0x04A4A20B,0x8FA08624,0xA0950008,0x0F1A809B,0x2A32129F,0x181D0403,0x97A1A69C,0xACB39A83,
0xA5052B1E,0x8E1F2D0F,0x2725059C,0x2E9EA982,0x90B0A531,0x9289968B,0x962C17A7,0x1D230A9D,
0xA5A30784,0x8EA31319,0x10918922,0x21088906,0x220DA58B,0xA2161408,0xA42020A3,0xA28E17A0,
0x9F991707,0x08A78715,0x26088422,0x2990951B,0x919A9F1F,0x9C2282A3,0x942B22A3,0x900486A4,
0x10AEA38C,0x1CA30430,0x0E110D26,0x972D91A5,0x93278DB2,0x9C0813A3,0x10972623,0x97B38332,
0xA2A10A28,0x2F1DB0AF,0x282AA1A1,0x02200B07,0xB1A92217,0x98942609,0x23980D25,0x14A2B285,
0x3016B1A7,0x96232825,0xB417330E,0xA6A193AD,0x3119A19C,0x268F9E16,0x95188E22,0xA21B17B0,
0xAE852F0E,0xA6A32205,0x13B7AA10,0x35151835,0x231AA71D,0xA9A0A7A1,0x89311DB0,0x9F962917,
0x92AB801E,0x29ABB091,0x242C1B30,0xA22F98B0,0xA48182B1,0xA0823203,0x01B1862B,0x2C9DA32A,
0x2308AF06,0xA01E039A,0x9E2D11B2,0x9EA32119,0x08A62629,0x28A28E30,0x0C19AC91,0x0E14B7B5,
0x93202F92,0xA481310C,0x94B49E24,0x2A859029,0x2786AA18,0x04299AA9,0xA92317B0,0xB59A311D,
0x0EA81D95,0x31AB9E2B,0x2511A92B,0x1818A68D,0xA52812AB,0xAD0D04B0,0x85823317,0x15871D25,
0x13B6AF27,0x1C97A61A,0x09949C8D,0x072B8AA0,0x9E29229E,0x9D872C00,0x81AA9185,0x9CA90923,
0x23179225,0x1F9DA38F,0x92198A90,0xA21795A3,0x0C221F9C,0x8E95231D,0xA9A50D10,0x22038483,
0x97A31124,0x80071006,0x0C16A2A5,0x1C17988D,0x1E95978E,0xA21F1F20,0x131091A0,0x9B89869D,
0x011100A1,0xA102130C,0x97172491,0xA9AC1916,0x0C852191,0x1B150A10,0x87ACA52B,0x1F9F9285,
0x18320E21,0x2294A6A3,0xA8128AAA,0x1B29A584,0x108C22A1,0xAA23009C,0xA8972728,0xA18B27B2,
0x9C259820,0x18A52F19,0xABA2A38D,0x298E8421,0xA2A70783,0x03109433,0x2AA613A6,0x91279E23,
0x14A99300,0x8C17A09A,0x2C189784,0x8C158EA1,0x111C9899,0x981687A4,0x041B1312,0xA3A21007,
0x1111A58D,0x21802711,0x998C920E,0x9E8D1C93,0x1604A79E,0x9787241C,0x179DA488,0x12201281,
0x14219186,0x960A08A0,0x8B970611,0x95909296,0x25A28D1D,0x2304950A,0x93109787,0x95110D1D,
0x9508238E,0xA2AAA295,0x24231297,0x01A29E02,0x8A969101,0x981C2724,0x1E9AB08B,0x2D148FA2,
0xAE99062B,0x923001B5,0x23311AA6,0xB6A41916,0x96911EA2,0x2D272D29,0xB2B39D1B,0x91A0A19A,
0x152B362C,0x9AB8AE90,0x3014A3A0,0x16292E33,0x9BACBEA7,0x2B150C98,0x9E2A221C,0x96A2AFB4,
0x242C2695,0xB1892E30,0xA19B8FAF,0x2E22191A,0xB5B10E2A,0x8F0B10A2,0x2929251B,0xA7B29D88,
0x10819310,0x8A241E19,0x1BA1B0B1,0x181F1D25,0xA1831914,0x808FA4AC,0x2223138C,0xABA89C1E,
0x151F13A1,0x111F2019,0xAAACA28E,0x2E231899,0x840B232A,0x95A8B3A4,0x29261C8B,0xA6831523,
0x909483A9,0x171B1704,0x8299A607,0x23139780,0xA7882224,0x9F9F99A9,0x29221A14,0xAEAC9720,
0x132190A4,0x93263223,0xA4A49FAD,0x0AA0998B,0x16243317,0x9C02941C,0x269AB0A8,0x18211C18,
0xA3A89420,0x24079D8D,0xA11D9316,0x018919A9,0x11152411,0x02A7A309,0x85140A0C,0xA9A11213,
0x20128696,0x21939182,0x9F959221,0x9F93900D,0x1C2B2BA1,0x93861213,0x8DB1A796,0x1D22840E,
0xA69E1324,0x1F0285A0,0x0C1A800F,0xA08E96A6,0x0B161485,0x179D851C,0x0C1E0710,0x99938507,
0x8C979595,0x8F8F8011,0x1C032227,0xA59A001A,0x028EAAAC,0x22272484,0xA1A49719,0x1C829299,
0x101D1A10,0x9394958D,0x95948605,0x83021288,0x1384010B,0x15089986,0x061E8300,0x8B839B91,
0x13151699,0xA4988F96,0x9390098B,0x83222D22,0x1098A499,0x21089303,0x889D921E,0x151B9291,
0x94949300,0x89891192,0x97202311,0x0280A4AA,0x1711130F,0xA4AE0F22,0x10110D02,0xA28A0601,
0x1F03969E,0x08202223,0x9EA7AFA0,0x25231D91,0xA59B1023,0x058298A1,0x11242508,0x0496A389,
0x198A8F91,0x9B998F1A,0x07130997,0x16211A14,0x9493918B,0x200B9AA1,0x989D8420,0x9B950C83,
0x061A1F16,0x1B889D97,0x0B019189,0xA0A39C12,0x19050894,0x9E1A1A12,0x9291A1A8,0x24231D0A,
0xA4A79318,0x0F029198,0xA216261A,0x0F87A4AC,0x2D158E07,0xA4A58A28,0x940A1197,0x1A2C2685,
0x84A5AEA3,0x1F959E00,0xA588282D,0x84099AA7,0x30288D9A,0xA0A39F15,0x97998588,0x981C291F,
0x048FA2A6,0x271C130B,0xA59F0E26,0x918499A1,0x21251D85,0x949D9989,0x87918104,0x98102522,
0x99919B9F,0x20839F9B,0x98980519,0x9B8F878E,0x131C0697,0x8F918603,0x99979083,0x1413148D,
0x90979214,0x829E998A,0x10242119,0x92059394,0x240E8A9F,0xA2861E26,0x99A0A5A7,0x25261A05,
0xA39D1522,0x0D8A0592,0x1416090C,0x9293968A,0x0886888A,0x071A1580,0x12168684,0x9D998109,
0x08060A93,0x86949411,0x93948E91,0x1B231788,0x0C029484,0x9EA09A03,0x0208949B,0x21849997,
0x91861422,0xA2182084,0x810386A0,0x238EA992,0x1308221F,0xA3021C16,0x868E909A,0x1502A4A2,
0x20219012,0x93102B10,0xA9958286,0xA0A69AA2,0x1890A2A3,0x2B212930,0xA7831D23,0x9795AAB0,
0x129297A1,0x11160819,0x1E232613,0xA6940612,0x9CA7A3A1,0x298F9D9D,0x220A1636,0x081F2116,
0xA79DA5A3,0xA4B0AFAB,0x2C332902,0x24253332,0xA6A5A201,0xA9A7B6B0,0x2C2880B2,0x23202330,
0x9E92282E,0x93139DA7,0xA9B0A8A4,0x1D1D9AA7,0x39341716,0xB0863230,0xBAB3A2A0,0x22AFB9BF,
0x35353238,0xA7173433,0x9EAAB1B2,0x009CA48F,0x9F2991A4,0x301086A7,0x27273635,0xB3A2932E,
0xB1B8BFC1,0x3531240B,0x0C314440,0xB4B6B392,0x1CA6B2B2,0x162D1C1A,0x1B010385,0x242E3121,
0x9EA29223,0xB1B9BEB5,0x29260A94,0x37423C1D,0xADADA425,0xB3BCB3AD,0x21008D88,0x262F1D15,
0x96282C26,0x19119FA9,0xA7A7B0A9,0xA0981B9A,0x3330332A,0xAE932833,0xB7B6B9BA,0x2E208DB2,
0x1713313B,0x1632352B,0xACA68110,0xB0C1C0B2,0x2E13A7A4,0x34362725,0x21303432,0xABAC9508,
0xBCBDB9B1,0x13331FB3,0x362F3420,0x1B021E34,0xB8AB981F,0xAEABB2BA,0x2F211F92,0x32281626,
0x161B2534,0xB4A59295,0x9FBCBEB6,0x352B0F85,0x27333133,0x92818D80,0xA2A1A1A3,0x9A898F9F,
0x96989799,0x2E382B0B,0xA4871612,0xAEB1A9A6,0x07131192,0x23242117,0x22018C03,0x9EA3A214,
0x9AAFA79F,0x86212524,0x10292495,0x13870712,0xA3ACB0A0,0x2084988A,0x85132726,0x1B1F1192,
0x15169E8D,0x9D9EA497,0xA2A197A3,0x2317048C,0x2726252A,0xA59F8511,0xA293959A,0xA2A0A3A5,
0x2F2A12A1,0x222E312B,0xA69CA580,0xA3AAA3B0,0x9DA28211,0x2C160614,0x2F30332E,0xB19F8A23,
0xB7B4B1B3,0x251CA0B4,0x32332D23,0x322D232B,0xB9B3A41D,0xA3B2BAB7,0x2A2909A7,0x30313835,
0xB39F2632,0xAAB3AFB2,0x0F93ADA5,0x0C182922,0x2C333122,0x968A9A0B,0xABB8B5AB,0x820697A5,
0x3B322C23,0xA4902538,0xB1A6ADAC,0xA18A92AE,0x1C122099,0x16223030,0x85181615,0x0CA4B1AD,
0x8A99A189,0x02030E17,0x251A1203,0x018D8B21,0x9C990A19,0x9190889C,0xA9B1A99F,0x2C202422,
0x252F332D,0xA1A29D14,0xA5B4C1B5,0x0C1B20A3,0x33392B16,0x292B2B2B,0xB9B8AC0E,0xB5A4ACB9,
0x372293A7,0x35262C36,0xAF0A2A36,0xB102B0B8,0x1CA8B1BB,0x25151C26,0x932C3A39,0x909A9792,
0xA9B5B5B1,0xA5212613,0x0E253000,0x3716911B,0xA0A5B182,0xAE021B10,0x981F17AE,0x2FA1A39E,
0x9C9B0A31,0x94203834,0xA38692A4,0x91B8BCB7,0x001C2534,0x25343821,0x15300C9B,0xB9BBB4AB,
0xA1B5A995,0x3736392E,0x372E0A2D,0xB5BCB422,0xACB3B1A5,0x263219AC,0x4038198C,0xAAA6273C,
0xBDB39803,0x889BA7B8,0x361FA29D,0x1C860D32,0xA0243837,0xA004A2B4,0x0CB0BBB5,0x92A20524,
0xA50B3F3A,0x32332C84,0xA1B2B211,0xB7BAB9AA,0x24313097,0x343B3523,0x14110B1B,0xBABCB280,
0xA6A0ADB2,0x433E03B4,0x2C343137,0xB8B38D20,0xB9B1939F,0x2D19ABBC,0x3E0F9424,0x119A2C40,
0xAA9B912A,0x9C06ACB7,0x1291A2B1,0xA3A02A2B,0x0E313933,0xA4AB0003,0x03AFB3AC,0x20A5AB10,
0x18322521,0x303C3391,0xB49C8E0B,0xA8BFBEBC,0x2B1C1415,0x2E313134,0x2C20A212,0x97A5AD91,
0xB1B5B9B5,0x2E33308E,0x31323433,0x11B2B607,0xA7B3A113,0xA29F9493,0x2F3186A4,0x31302121,
0xB1BF9E29,0xA4960F15,0xAF811683,0x3124A1B0,0x312A3136,0xC2B51832,0xACA69EB2,0x8F851E96,
0x3392A89B,0x2F3A3A38,0xC4B18419,0x9DA6AAC4,0x2D30331F,0x15A59023,0x1A20202B,0xB7A5841C,
0x1810B9C4,0x343B3014,0xADACA223,0x2624210F,0xA315221F,0x22A8C3BF,0x35321415,0xAA83262D,
0x1E17259A,0xB1A30721,0x9DC0C1B5,0x3E322F30,0x90182E3C,0xA9A1A2A5,0xAB8106A3,0xA1B0A3AE,
0x372A2923,0xA3803540,0xA4ACB8B2,0x302D90A6,0xABA1A78E,0x131725A0,0x92323C32,0xA0A7A8A5,
0x219CA09B,0x80A9B483,0x2E31240C,0x152D2328,0xB2B1A3A0,0x809FADB0,0x8F942326,0x2E169280,
0x27383831,0xBFC0BBA7,0x2E228CB0,0x9A1B312F,0x1F8695A2,0x978E2026,0xA9A9A991,0x091C2297,
0x990C211E,0x27049FA5,0x911D2C33,0xA1A5ADA6,0x2884ABB0,0x178E0626,0x9B15292B,0x1B1E1699,
0x93A3A390,0x9EB3B5A1,0x26303128,0x21313023,0xAFACA9A4,0xAAA493A8,0x8E810C92,0x38342B0F,
0xA7AB9732,0x98A1ADAE,0x220A9B92,0x2481A300,0x2C282526,0xB2A60E27,0x9CADADB0,0x1C190703,
0x11130A13,0x1922220F,0x98191E11,0xB0AEA6A5,0x162518A4,0x030D1C19,0x21201503,0xA19B8320,
0xB2A6A09A,0x292383AF,0x9422302E,0x84A29897,0x14901526,0xACB6AC17,0x2F0CA4A4,0x24353331,
0xA699A193,0x1484A9B1,0xA5A41513,0x209BA095,0x272E2727,0x959C0117,0x98870792,0xA49D9A9B,
0x231294A1,0x9E213532,0xA0A79CA4,0x1782A0A0,0x1B090D1B,0x08959518,0x221D1814,0xA4A9AB03,
0x1B2487A7,0x0321170B,0x02898B96,0x988F1E18,0xA6A18E94,0x1D1E97A8,0x94122724,0x90931402,
0x1B88010D,0xA195980C,0x98A0A1A2,0x2234268F,0x94908892,0x1696A695,0x93841C20,0x898AA5A6,
0x242E2B12,0xADA99420,0x15868A9D,0x8D998D1A,0x0690A3A2,0x2622181C,0xA7851921,0x959197A9,
0x200E8497,0xA0A08E1B,0x1D111C05,0x871E2524,0xA3AFA9A2,0x12161914,0x9F920410,0x1E840305,
0x9C97031F,0x03A39C86,0x25268593,0x1A100A15,0x9208928B,0x9B8510A0,0x8E959B95,0x2218028D,
0x93181922,0x8B8D96A2,0x938D9592,0x85A2A38E,0x25191A89,0x0F1A1B27,0x9596A190,0x91068590,
0x939F8A95,0x1C100186,0x10101421,0x99918102,0x0592A69E,0x9A930608,0x10888386,0x23242D20,
0xA09E871C,0x9DA39792,0x8E0C079D,0x0C838100,0x1C232620,0xA2948813,0xA1A7A3A1,0x0088A1A2,
0x201A211B,0x1C192425,0x9686821A,0xA39AA4A9,0x09918D9E,0x16161A19,0x141F1A0B,0xA2A6950F,
0x8E9DA4A5,0x06191710,0x20211101,0x03071522,0xA8A69B92,0x019DA19E,0x29221386,0x15111526,
0x83050E12,0xABA18980,0x90A09DA7,0x221C1311,0x1A1D1C20,0x918F020F,0xA3979A94,0x928B9EA4,
0x21201888,0x181D2321,0xA0998911,0xA09B9595,0x0A96A1A1,0x2520818C,0x0C202725,0xA2968705,
0xA2A19BA2,0x87A2A39E,0x271C1617,0x20262528,0x9F949581,0xA09A96A0,0x9EA19A9A,0x271F1D0E,
0x20211B24,0xA1A49116,0x9595A1A1,0x9A92949A,0x1712158E,0x1B212526,0x9FA10315,0x989AA29A,
0x8E979698,0x1D16088B,0x1A1B1E23,0x9E970812,0x9C9FA49F,0x8492949E,0x14100083,0x2020221C,
0x978A1921,0x9EA0A5A0,0x818D8F97,0x0D080080,0x20211D19,0x99861417,0xA0A2A19E,0x0403919E,
0x11038401,0x1D1B1F1D,0x93880A1C,0x9BA19E9B,0x1B079898,0x08101217,0x111B1B0A,0x8E8D0911,
0xA0A3A39C,0x108C9796,0x09141517,0x0D160B83,0x908E070A,0x9CA19C92,0x838D8E8D,0x11131B13,
0x0D0A1012,0x8D010E0C,0x90909896,0x878E8E8C,0x0A151283,0x0B0B1110,0x00080485,0x9A999589,
0x8A949A9A,0x0F181085,0x11050E06,0x0D141014,0xA19A9083,0x8F969C9E,0x130E8086,0x1510050F,
0x10161616,0x9E928303,0xA0A1A4A3,0x1B108C98,0x1615191C,0x13161D1B,0x9F928008,0x989BA2A2,
0x0C909C9F,0x1A1D1F16,0x05151B1E,0xA0948D90,0x9DA2A19F,0x0A909799,0x27251D16,0x1A1D2324,
0xA598920A,0xA3A2A4A6,0x859098A1,0x26211911,0x191E262A,0xA19F9808,0x9FA3A6A4,0x0A0397A1,
0x221A1309,0x20222422,0xA3988A16,0xA1A4A5A8,0x1807949D,0x1B141517,0x1417181A,0x9B8D0512,
0xA5A6A5A3,0x1989949D,0x1F212120,0x1A1F1C1E,0x9E938613,0xABAEAFAA,0x1D10849B,0x201D1D21,
0x151C2121,0x94989706,0xA1A4A4A2,0x8091999C,0x1014150D,0x2F2D230E,0x9C991226,0xACAAA59C,
0x8F9AA4AA,0x2A292510,0x161A1C28,0xACA99702,0x8E0090A1,0x08849391,0x08040C05,0x21201D1B,
0x94801518,0xAAA6A497,0x8AA4ACB0,0x24282215,0x21232928,0xA1918214,0x9C9B9B9F,0x9DA0A3A1,
0x18079399,0x2A282921,0x901C2328,0xA7AAA49C,0x9FA3A8AA,0x2112008E,0x1F252217,0x070A1420,
0xA69F0707,0x999BA5A1,0x200A9098,0x1B251A1E,0x83081A1C,0xA49D9597,0x9CA4A9A8,0x21818E96,
0x2126292C,0x86172421,0xA1A6A9A1,0x92959699,0x94910485,0x05030688,0x23232111,0x8F031A25,
0xADAAA5A0,0x8987A2AB,0x2A2F2A17,0x91802026,0x99A0A2A0,0x0D038F97,0x99968A13,0x1E0F9FA2,
0x1D262A20,0xA6900519,0x9AAAADB0,0x1C181207,0x20211C1E,0x8204900A,0x8A988A92,0x9E818080,
0x989F9F9F,0x23019296,0x18212C30,0xA79E9105,0x8199A2A5,0x19111107,0xA3968514,0x05101395,
0x1E131013,0x9F948611,0x04899CA1,0x181A1812,0x960D0787,0x9293979C,0x05870100,0x01858213,
0x0A000401,0x200F0E10,0xA0949218,0xA3A397A5,0x26188994,0x11202127,0x969B9994,0x00860304,
0x8F948904,0x81849290,0x17058108,0x02130F12,0x9B060A88,0x90958795,0x8787150E,0x110C9082,
0x1519110B,0x9B939195,0x9494A39A,0x1E1A1B82,0x221B2120,0xA19B9F13,0x95978A97,0x9798140B,
0x0896AB9C,0x2127210B,0x1D202B24,0xB0A49D03,0x93A2A9A9,0x131E179B,0x01041820,0x201D0184,
0x0814121C,0xAFA99594,0x8EA1A9AB,0x32241614,0x001B292E,0x94A29E83,0x8E909AA0,0x0894A087,
0x8D9FA098,0x29292314,0x1520252D,0xB0ACA79F,0x929BA3A9,0x2B281C91,0x99141A23,0x02852012,
0x8B150789,0xA8B0AC9C,0x099799A3,0x2D2D231D,0x1013252F,0xAC909FA2,0x16909DA4,0x9D9B9895,
0x181F0C06,0x211C1F0F,0x9306211F,0xA1A8B09B,0x0EA4A4A8,0x1F25272A,0x191C1211,0x9B98948C,
0xA3020A93,0x0EA6A399,0x1F178591,0x132A2729,0x90931786,0xA6A6A595,0x1390A69C,0x14170D9E,
0x1E121221,0x1E202429,0xA291959B,0xA8AFA7A1,0x218E9391,0x2820121F,0x9615191C,0x02088783,
0x979A999F,0xA3948192,0x21888E82,0x22910423,0x86228E09,0x949099A0,0x03000993,0x10131817,
0x9B92978D,0x92A01313,0x1C109693,0x80079C92,0x80182415,0x17000704,0x9A989C82,0xAC870595,
0x1E130FA7,0x0A92091D,0x19192026,0x87158704,0xA3ADA6A2,0xA116099B,0x09042509,0x248D9314,
0x0D0B1728,0xA0969B9A,0x908C9EA0,0x04920E86,0x03171212,0x01090384,0x0F088F9B,0x8B8C1A22,
0x94A39791,0x242C9797,0xA7A01400,0x9E97148D,0x251E860B,0x22119185,0xAC8F1216,0x13949294,
0x15039695,0xA9A09615,0x272713A2,0x11292513,0xA2A2950C,0x8D94929F,0x989E9F96,0x0E181205,
0x26211708,0x830D840B,0xA793111B,0x1712A5B5,0x89848B82,0xA1A41820,0x27282515,0x8F939901,
0x9AA0A695,0x0D26208E,0x81919CA8,0x86161622,0x9892098B,0x13820F94,0x9F988125,0x801C159D,
0x1A07948A,0x8499A18E,0x98231788,0x16101198,0x9396131B,0xA4A50918,0x2C13A59C,0x9A110711,
0x9608109F,0x17202414,0x94A9A592,0x119B9F1B,0x83211E92,0x0E120304,0x9DA11420,0x140DA2A5,
0x1F0AA48F,0x9D92858E,0x842D3117,0x9DA19392,0x11909296,0xA6020B1A,0x201791B0,0x19121A25,
0xA1A6A382,0x22302592,0xA5B29B16,0x14999D90,0x92202226,0x1513A0AF,0x1E1D2423,0xA69F9302,
0x8E82969D,0x86A2A099,0x25211E13,0x921A1C29,0x111091A4,0xAC9E8A92,0x93A2A9A5,0x22232E13,
0x13841028,0x82820C1C,0xACA29596,0x1300A6AB,0x25201083,0x0A170911,0x0D161919,0xA2A39492,
0x859EA39A,0x8A090C11,0x0B161B94,0x0A11121D,0x97950702,0x0B130284,0x979BA8A1,0x1A8A0F8A,
0x980C1A26,0x19830588,0x91900A1E,0x960DA1A5,0x09121192,0x9392879B,0x151C2120,0x929A9012,
0x168E8E9E,0x97869918,0x21838D97,0x9711130C,0x90050283,0x149C0511,0x12109C91,0xA3018888,
0x0400208A,0x8C871915,0x100C9E85,0x938A8288,0x9000849E,0x01200988,0x01931A11,0x078D1114,
0x0401A590,0x94108997,0x0B9484A5,0x0B191E29,0x8592938B,0x1E11088A,0xA7A3A083,0x11120492,
0x08801610,0x20120308,0x9E95901D,0x8993959B,0x9100008F,0x18020185,0x1B1E1721,0x97888588,
0xA1A79D99,0x21919784,0x191A091F,0x1A261C84,0xA3A28008,0xA3A6A39C,0x0616168C,0x2E1A078B,
0x84171D2C,0xA59EA096,0x9F9A8BA7,0x12901015,0x20241D22,0x8A828504,0xA8A59B9C,0x2204A29C,
0x1F212122,0x9D841D17,0xA4068F9A,0x9BADADAD,0x261F271E,0x232B2929,0xA0939A09,0xB2B3ABAA,
0x16809BAD,0x332C2422,0x16273237,0xB2AFA29F,0xAFAEB2B4,0x2107929A,0x3D383026,0xA2112633,
0xB7B1A8A4,0x99AFB0B3,0x3323888A,0x2A353535,0xA791181E,0xB1B5B5B2,0x14889BA7,0x312F2720,
0x1824272C,0xB3ACA28E,0x99A6B0B6,0x2D231F1C,0x232D302E,0xA5A29804,0xAEB1B2AC,0x2115019F,
0x35343023,0xA0001C2D,0xB4B1AFA6,0x87ABAFB4,0x34312620,0x1C303537,0xAAACA594,0xB4B7B5AD,
0x2F2A87AC,0x35363631,0xA399132C,0xB6B3A8A2,0x1CA3B3B6,0x36322929,0x032A3535,0xB3AC9294,
0xA3B4BAB4,0x2C2B1998,0x31353632,0xADA01A28,0xB3B7B5B0,0x2495B0B0,0x34352F2A,0x97273633,
0xB1B2AFA5,0xAAB5B9B3,0x30282483,0x2D3B3A36,0xA7A7A011,0xB5B9B2AC,0x2219A1AE,0x36383322,
0x91932235,0xB6B3A896,0x10A5B2B5,0x32322920,0x81243234,0xB1AC9980,0x9FB3B6B7,0x31302014,
0x21293334,0xB0A78A10,0xACB2B6B4,0x2B2C1898,0x2C262E2B,0xA9961627,0xADB0B1AC,0x221A96AA,
0x23192323,0x9D00252C,0x9B99A5A5,0x0E1299A0,0x02871C08,0x96940C1A,0x008C9F97,0x1E20150F,
0x05800C05,0xA99D8512,0x809CA8A7,0x292B2085,0x82151F20,0xA3930014,0xA4AAA9AA,0x28211296,
0x20261725,0xA301201B,0xADAEA2AA,0x3008A3A1,0x13250825,0x951D311A,0xA4ACA49B,0x91A5ADA6,
0x23221B1A,0x28312D22,0xADA79983,0xA9ADA7A9,0x2908A093,0x30322921,0xA5891F2A,0xA8A9A4A5,
0x8EAAA7A5,0x302E1910,0x08242A2B,0xA3A09693,0xAAADA1A2,0x28149AA1,0x24272E2F,0x9C840C14,
0xAAA3A2A5,0x09A5A7A3,0x2D2C2620,0x0821231E,0xA4A2A000,0xA9AEA9A7,0x2325139E,0x262B2B24,
0x90978C24,0xB0A8ABA4,0x0E068EAF,0x25222020,0x170A2630,0xACA29584,0x919CABB1,0x1E0E8612,
0x231F2922,0xA2072022,0x96ACB1A3,0x16939483,0x05211795,0x1829231C,0x9BAE9A08,0x8C849098,
0x8B179C98,0x2415118B,0xA2861816,0x8B169097,0x82989092,0x10880E8A,0x97000224,0x210D919D,
0x9F0A0B8B,0x98939090,0x8095211F,0x1F949F94,0x881C8224,0x9593899B,0x0C081196,0x9A9AA090,
0x231A1C1A,0x848E0911,0x8A88A095,0xA0989F8F,0x231A199F,0x891D1A1D,0x01898D0D,0x9F9D8F91,
0x840390A5,0x16191820,0x078D120E,0x8F818A80,0xA09AA398,0x20151D85,0x97900905,0x8183001E,
0x9A931095,0x17959997,0x840C8323,0x15030697,0x060F8E82,0x9C98920E,0x1F17078F,0x97891085,
0x130B9C88,0x0A811611,0x94919390,0x13210F07,0x9AA78A03,0x18188A92,0x8D800020,0x160198A4,
0x9C182614,0x96A1ACA1,0x14062611,0xA0929310,0x26248A9A,0xABA91020,0x041591A9,0x1F161924,
0x94A29D97,0x0A222520,0xA3A7A601,0x251306A5,0x9D1A1627,0x88920F98,0x1381201F,0xA0A6B19C,
0x28231983,0x97131606,0x09929207,0x9194141B,0x979BACAE,0x2424211A,0xA0841A14,0x08A09E96,
0x89070C19,0x9B98A0A2,0x2825200E,0xA295950F,0x0EA09D9A,0x0821241D,0x939AA5A0,0x1C221908,
0x9792949E,0x1216110B,0x92051B1C,0x93A3A5A2,0x21250D80,0x09900A03,0x8E088A13,0x941F1889,
0x99AFA8A6,0x2E2B0B02,0x9C8E2326,0x9692A39E,0x86160E90,0x9B9F91A1,0x28210116,0x93962022,
0xA28B969E,0x0B8C9E8D,0x09072003,0x0A20938B,0x828A1B0D,0x97939A93,0x880C0B03,0x108B0E89,
0x11239286,0x0B971404,0x92A19A92,0x97211221,0x1E8297A8,0x10180006,0x90971C20,0x9B969082,
0x9607008F,0x20969F9E,0x03252324,0x8C960004,0x8F898C9D,0x9886920C,0x01988E9A,0x1C302287,
0x8B9A0225,0x8BA2A0AA,0x9B211315,0x8B991912,0x292297A7,0x9D93132E,0x92A092A2,0x88231A81,
0x88868D85,0x0400829D,0x0880242F,0x9FA1A0A0,0x1A1AA1A0,0x92922423,0x99118E9C,0x2E230F19,
0xAEAC140D,0x990CA5A7,0x12082220,0x87211BA3,0x18979821,0x908C2520,0xA192A6A5,0x271B928F,
0x8E0C2203,0x8595A21A,0x1D172286,0xAB979A93,0x1E02878E,0x85172622,0x9AA0A092,0x1488879A,
0x9F142327,0x0E9EA5A5,0x26298106,0xA2A4160A,0x9482A19E,0x242A2018,0xADAB8D98,0x20119F99,
0x10022722,0x9404A485,0x18131F8F,0xA7920F11,0x278DA3A0,0x801D0718,0xA2931012,0x201012A4,
0x84189F18,0x9AA6048E,0x0A211318,0x1A991706,0x9C85A798,0x10888210,0x9609208B,0x1A929309,
0x11150100,0xAB82111E,0x09A108AB,0x15149321,0x90811D11,0x0B11998B,0x1D801D00,0xA393A306,
0x2311130E,0x0C138191,0xA0A3998E,0x01171208,0x9109141B,0x141092AD,0x90991528,0xA68B0F18,
0x248699A6,0x0D1C1880,0x9EA6AC1D,0x1F19298C,0x1711900C,0xA19F9A9E,0x0622121B,0x859B2206,
0x0815A9A7,0x9B852620,0x9A101305,0x2795959A,0x950E0417,0x9BA59F19,0x122820A4,0x2499970F,
0xA4860E10,0x88178915,0x84941BA6,0x210AAE92,0x9F93241E,0x94288297,0x22A39097,0x958E860A,
0x84928722,0x092216A1,0x2196901E,0xA0961110,0x8913988A,0x118716A2,0x8D85A513,0x1F08211E,
0x84241394,0x9DABA796,0x03928792,0x8A241423,0x251613A1,0x96988012,0xA9A3A013,0x231990AC,
0x1F292317,0x93A69924,0x888D0198,0x9414A19C,0x188C91A3,0x22182327,0xA7030C23,0x1291A2B0,
0x8C8F8E8C,0x93121316,0x201C0D87,0x9C021E03,0x98A6A38D,0x8200098D,0x11131C17,0x8102928C,
0x148C0F22,0xA29C8600,0x009EA8AA,0x231F1121,0x141D2018,0x93899191,0xA3958683,0x83A6A7A3,
0x1C201590,0x1B2A292E,0x99A89495,0x9C9FA89C,0x8E899896,0x27131483,0x24312E28,0xAEA5A60C,
0xA2ACA8B1,0x15201E89,0x19241019,0x24202A1D,0xB0A0031C,0xA4B1B3B0,0x2826128C,0x1C16281C,
0x0D089424,0x9091160C,0xA7A8B0A9,0x1F1701A0,0x2120282D,0xA18C1407,0x0385A099,0xA1A2998D,
0x178F919E,0x24332521,0x009B0A10,0xA4A0A79C,0x8F151291,0x0994A092,0x25222887,0x97051831,
0xACAE94A1,0x24179DA4,0x96029321,0x1B8D1F92,0x882A221F,0x989FA2A0,0x849DA4AA,0x89222424,
0x138A0090,0x1C160281,0xA5A39318,0x9BA99896,0x2B2E0982,0x859C171B,0x95099410,0x93002085,
0xA38AA5A5,0x250195A0,0x8018322C,0x8A0C9F83,0x168B949E,0xA1A09E86,0x0B9D9883,0x24302C11,
0x96A19B1C,0x99998899,0x9E80030E,0x86968CA1,0x24271391,0x99921B32,0x979596AD,0x101C9995,
0x07A29200,0x07168E88,0x1E262C25,0xA1A7A89E,0x829B9191,0x9B821111,0x1109840C,0x281B2389,
0xAC989D25,0x029985A8,0x84238A89,0x129D838C,0x051A128E,0x00111727,0x97A4A3A9,0x1A0A911A,
0x93991687,0x81159C14,0x24092187,0xAA9A9F12,0x0A810E9F,0x8C1E8701,0x0C93118C,0x011A1088,
0x948C1322,0x839BA1A8,0x1A888A15,0x90080804,0x17138E13,0x100A2083,0xA2A2A681,0x9105129E,
0x12130F18,0x05901291,0x05219016,0xA1A31607,0x0B85A2A0,0x1E041181,0x96198A18,0x15910689,
0x8F030701,0x989CA190,0x071B0A91,0x13842115,0x9690948C,0x03128910,0x9C991290,0x1C899A8D,
0x0C1B1202,0x97848914,0x8096129E,0x080E9415,0x91939295,0x12138012,0x118A220E,0x9387A68F,
0x04890A83,0x99060B02,0x20948D00,0x87201400,0x9F989511,0x039208A4,0x1218851D,0x9492129A,
0x09169511,0x00981980,0x969BA694,0x1B131B10,0x90138385,0x089B900C,0x97151390,0x95998C0A,
0x181702A4,0x90120321,0x01951B02,0x01089993,0x87938704,0x94959790,0x181F1C1E,0x1E91018B,
0xA6939709,0x88000E91,0x85058494,0x211C9590,0x9194211D,0xA3160992,0x12A1A2A0,0x81820710,
0x8B00091A,0x18202208,0x90A0A194,0xA5A39910,0x1A1B1593,0x1A201086,0x0B848F14,0xA4A1171D,
0x8A0F9AA6,0x168D9B99,0x18102122,0x8D081B22,0x05819D97,0x96A8A5A0,0x98081408,0x2A231B16,
0x10141511,0xA6A4A385,0x9B908EA2,0x20138EA1,0x20211C23,0x8B051B1D,0xAAA49B8E,0x9296A2AC,
0x2010120D,0x20222327,0x9D0D1317,0xA0A8A3A4,0x98A2A4A0,0x2B211915,0x14202127,0x98811181,
0xA4ABA9A2,0x878F9A9F,0x2828200A,0x24252121,0xABAA9F11,0xA6A29FA0,0x251299A7,0x2124292B,
0x9B0A2221,0xA79DA5A1,0x05A0A2AB,0x1F222520,0x1B1D1121,0xA3A49481,0x88929EA1,0x11180D90,
0x0B84121E,0x95040500,0x0282919B,0x93968A8C,0x93071317,0x1B091586,0x87899108,0x9F9F9A0C,
0x108A8799,0x22171317,0x800E0F20,0xA7A49985,0x0190A7AF,0x29252316,0x16212629,0xABA6A100,
0x96A9ABB1,0x20211512,0x282E302A,0xA4A2980F,0xA8AAABA7,0x1F1E05A2,0x30292120,0xA2A08D24,
0xA69A8698,0x180EA0A8,0x110B1016,0x93082018,0x1119858B,0x96A5A09A,0x9C88110B,0x111D1183,
0x13061203,0x9E98041B,0x9984909A,0x17949DA2,0x1B1D2322,0x95811720,0xA2A5A4A0,0x0A929398,
0x1A2B2712,0x09100717,0xABAC9881,0x8E9699A5,0x2B281510,0x11182129,0xB4A70C8B,0x0196ADB0,
0x29130008,0x19242A2D,0xA68E130D,0xA5A9AFAE,0x11990186,0x272F2821,0x8B0E161E,0xACAAA7A5,
0x819B9F9B,0x27212312,0x8A181A29,0x9E9B999F,0x969AA4A4,0x19202104,0x060B1F22,0x9595968F,
0x9BA4A495,0x1B222103,0x0B161520,0x939B9396,0x99A1A499,0x1C1F1E0B,0x12101521,0x96988E8A,
0x9792979B,0x20009285,0x18141614,0x97880317,0x92998900,0x0C8C929E,0x8C15840E,0x20801103,
0x8E150913,0x929B8302,0x9F98A3A1,0x2816858D,0x101C2923,0x950A8F11,0xA4ACABA8,0x21129898,
0x24222A24,0x931F1A1F,0xB0B3A89D,0x1B0C97AE,0x2B252728,0x8A142027,0xB3ADAC98,0x1C09A1B2,
0x2B282729,0x0A122724,0xB1ADAB9A,0x189AA8AE,0x252B2923,0x10262829,0xAFB2A595,0x04A1ACAE,
0x292C2220,0x122A2A28,0xAEAF9B94,0x939CAEAB,0x2D15150E,0x23292121,0xA29E9818,0xA7979FAB,
0x06928A9B,0x211A2722,0x90980D2E,0x8897A1A3,0x969EA785,0x23191596,0x9320261D,0x10810A09,
0xAEB0A382,0x22199DA3,0x1E272D21,0x10120A1F,0xAEABA198,0x110AB0B3,0x2C272D20,0x111C2B2D,
0xB6AF9B10,0x85A6B6B9,0x3430231C,0x182D322F,0xB1A79C04,0xA6B7B9B7,0x2A302785,0x34343131,
0xACA9A521,0xB4B6B6B5,0x262911A7,0x322E3332,0xABA01D2D,0xA2B0B4A5,0x1B91ACAD,0x26302917,
0x911D302E,0xA8AD9695,0xA3A8AA98,0x291E8EA7,0x2B302F2B,0xA1908022,0xB0AAA3A5,0x08A4AFB3,
0x353B332B,0x8C02272F,0xB6B3A494,0x8BB0B8B5,0x3734311E,0x16303036,0xB1A9A1A1,0xB2B7B7B6,
0x342A228E,0x30343A39,0xADA49E1D,0xB7B7B7B3,0x302301B2,0x302A3336,0x9A062732,0xB2B0ADAA,
0x0CA9B4B3,0x31251E23,0x303A372D,0xB6A9A015,0xB3B3B1B5,0x2D1298AF,0x3E36323A,0xAE9B2133,
0xB3B0B6B6,0x92A0B0B5,0x32343B2A,0x05303235,0xB1B8B5A7,0xA7B4AFAB,0x3C351892,0x262D3034,
0xB1AD9C14,0xAB99AEB3,0x2F84A4AE,0x172B3437,0x91172922,0xACAEA6A3,0xA4AEB1AE,0x2E33311D,
0x302B2F27,0xAEB2A824,0xB3B3B3B0,0x313005AD,0x35363229,0xA7930B34,0xB8B7B3B3,0x159AA6B5,
0x38333430,0x11303134,0xB8B6B5AB,0xA4AEB1B5,0x352E2B13,0x24383332,0xB1AFA182,0xA4A9B1B5,
0x201D9399,0x28333424,0xAC922225,0xA6B2AAA8,0x108BA3A1,0x2F301B02,0x0417272E,0xA9A5A29A,
0xA49BA1A5,0x2F08009F,0x2025242C,0xA0A00D23,0x9A85A6AC,0x0A9EB0AB,0x22303320,0x80232121,
0x98B1ACA2,0xA2A9A591,0x33371E96,0x98132126,0xA8A88C80,0xA0999BA7,0x3092A59A,0x08223135,
0x94058782,0xA1A8ABA8,0x1397A2A2,0x2130372B,0xA0898E13,0xA9B2AB9E,0x07959891,0x35352E19,
0x8A979025,0xB0A7A395,0x9488A0B1,0x322B1290,0x941D3134,0xAEA69790,0x9FAEB2B3,0x2A131182,
0x28323737,0x9C97A386,0xAEB7B7AB,0x8A9381A2,0x393A321A,0x1915032D,0xB9B29D12,0xA3A5B1B5,
0x322495A0,0x21313735,0x9F192424,0xB1B8B5B1,0x90A7AEAC,0x3233311E,0x282D2E30,0xAFB1A712,
0xA9AEB2B0,0x292703AA,0x302B252B,0xA901202F,0xACA0A2AF,0x15A6A5A6,0x12141D25,0x161B2217,
0x8199A5A0,0x99000809,0x110D220C,0x918C940E,0xA1A1A39C,0x20221198,0x24211D1D,0x9D122119,
0xB1AE9A03,0x95A3A4A8,0x2C1E8301,0x2F292D26,0xA3071927,0xA9B4AFA9,0x99A1A7A8,0x302A2001,
0x232F332E,0xAA9E0E20,0xB0B1A9A7,0x049AA3A6,0x2E28191A,0x222C2131,0xA09C0D18,0xA3A7ACAA,
0x8D9EA3AD,0x1726248B,0x1E20272A,0x9D8A1B17,0x9A9EA49A,0x90A6A894,0x05159014,0x26171802,
0x1D101513,0xA4091A1B,0xA68388A4,0x9AA89DA3,0x198A0C86,0x2B29272A,0x04129020,0xABA39D81,
0xA0A19EB2,0x21849293,0x20242229,0x0C262926,0x90A4989E,0xA5ADB0A5,0x94859298,0x2A2F2111,
0x2624232D,0xB2A41D1C,0xA8ACABA6,0x17A4AAA7,0x2B2A1511,0x2A2E3421,0xA8939624,0xB1B09AA2,
0x9F97AAAD,0x331D2108,0x19312331,0x8C811B19,0xB0AAA1A5,0x8AABA9A8,0x1C270112,0x2A232523,
0x8212231F,0xA1AAA38C,0xA18B9DA3,0x1C079882,0x1F212092,0x0B232325,0x9B978493,0x87A79983,
0xA2969298,0x0F139193,0x20151D14,0x1E071E24,0xA202970A,0xA4A8A4A5,0x098D99A2,0x25231B13,
0x2132281D,0x92A11620,0xA9ADAEA5,0x0A93A1A1,0x1E231706,0x22232921,0xA21B011F,0xA9ABA3A3,
0x909C95A5,0x24041B15,0x292C2028,0x90940710,0x99A3A19B,0x9997A191,0x261B929A,0x0C242413,
0x888E090C,0x8F969903,0x80819B8C,0x82178B8F,0x1A05040B,0x03841280,0x92080682,0x9E9796A2,
0x14941308,0x8F1F9283,0x840A0993,0x8D071A18,0x02968E07,0x92819118,0x10980C97,0x20049002,
0x0B058316,0x160C058E,0x96028A88,0xA095A191,0x211A8394,0x10121012,0x05172315,0x81081818,
0x979EA2A0,0x0907959D,0x810C1702,0x16162116,0xA10D8080,0x96929698,0x9B9D9190,0x1C919889,
0x161D1D23,0x89902007,0x0B039606,0x8FA09880,0x1510829B,0x821C1417,0x958C8511,0x021495A0,
0x968E9494,0x08190A90,0x21851F0B,0x8C009794,0x87141487,0xA3939290,0x100F170D,0x15180B22,
0x07850B92,0x9902088D,0x94A19B97,0x81870E94,0x061D060B,0x0E0D0814,0x8D921008,0x8A8C9987,
0x0D891911,0x89920590,0x0E149012,0x93950414,0x0A800A88,0x8708811C,0x10A19CA1,0x81119597,
0x91059009,0x1C061682,0x9317120B,0x8A8E9182,0x809A8685,0x85849293,0x23279112,0x048B2092,
0x9D899592,0x9A86868F,0x91010E9E,0x821C211A,0x859B9221,0x0A929399,0xA0008791,0x20070F03,
0x200E2822,0x9E87A08A,0x8A93A49C,0x909A0386,0x1E200E14,0x0C191925,0x8BA18790,0x89899EA2,
0x83909F87,0x1D251C90,0x02801A11,0xA0A09117,0x81090594,0x9A888BA0,0x0B112115,0x140F8214,
0x889F9D0A,0xA1810A06,0x23949290,0x0E1B110B,0x89878617,0x8B8D909D,0x91928480,0x0C23158F,
0x0D11111C,0x9CA29593,0x040C838D,0x108F8E9C,0x0319141A,0x9D0E1F12,0x018FA0A3,0x93988214,
0x06221701,0x17121B8C,0xA7A59506,0x04100C8D,0x1C8C948E,0x038D061C,0x9E121D1C,0x0995A2A7,
0x8799920D,0x14201614,0x2322198E,0xA0A6A000,0x9406828D,0x1F1691A1,0x0D050A1B,0xA0831D21,
0x0696A0A2,0x8C998A83,0x021C241B,0x1C020E10,0xA2A3A488,0x94908E90,0x26180286,0x1C142021,
0xA89A8A16,0x869FA3A6,0x878C9282,0x19222015,0x1B1C2020,0xA1A9A597,0x9200A0A4,0x1B16059E,
0x24242121,0x9B030D22,0x99A3A4A5,0x91978493,0x1C1E1309,0x1C22231D,0xA3A29D8D,0x90919E9A,
0x0B8B8084,0x1D1E211C,0x9D831E21,0x00A3A9A0,0x8402978F,0x101D1A04,0x181D1910,0xA9A49105,
0x9093909C,0x22100486,0x1C080D17,0xA1111520,0x96A2A4A7,0x07138689,0x11191E10,0x20211F16,
0xAEA8920B,0x9691A3A7,0x20130996,0x211F1821,0x90142227,0xA9AAA5A2,0x939D9BA6,0x2221118B,
0x2C2A2422,0xA7921523,0xA5A4A2A4,0x909B9FA6,0x22151706,0x22282A28,0xA09B8C18,0xA4A09FA0,
0x87A09FA0,0x251B0708,0x031D2326,0x0C089102,0x969B8B90,0x918AA1A1,0x111A1988,0x908F8911,
0x1513100B,0x8A8E011B,0x0499898D,0x9D8A0312,0x9295A5A8,0x23211C84,0x171D2124,0x030A1314,
0xAEA8A08B,0x99A6A8AE,0x23201685,0x292A2C29,0x12161D28,0xB1B2AB95,0xA0A7AFB2,0x251A0596,
0x30312C2D,0x0B1D2730,0xAFADACA3,0xA9ABAFB3,0x24168AA3,0x32312E30,0x96162B31,0xA79F9E9E,
0xA7AFB0AD,0x1A878DA4,0x282E2C27,0x810B1716,0xA101010D,0x99A09EA0,0x1086938F,0x979C1419,
0x150B869B,0x1A10091B,0x0823211E,0x96128304,0xACB3B0AE,0x889293A1,0x33312C17,0x1E262B33,
0xB3AC9D1A,0xAAB1B1B3,0x2190A4A8,0x2D2F3027,0x0A263430,0xAEB1A88B,0xA2ABADA2,0x210A949A,
0x2D281C20,0x98002124,0x990B04A0,0xA3A2A4A0,0x0B141D0E,0x1A202324,0xA0AAA8A0,0x949A9591,
0x2B292488,0x23241B26,0xB0A99C18,0xAAA5A8AD,0x301892A7,0x30302F30,0xA21F302E,0xB5B3B4AE,
0x9DAFB2B4,0x31312F1D,0x32343534,0xB2ADA50E,0xB5B6B5B2,0x272282AD,0x36363330,0x93132733,
0xB6B3B0A8,0xA5ADB1B4,0x2F272001,0x2C303231,0xA69A8921,0xAAAEAEAC,0x201387A2,0x22212728,
0x9C091821,0x98A2A4A1,0x899197A1,0x1D1B1B13,0x04091512,0x98929D8A,0x099B9B97,0x1A1A8215,
0x03202511,0x9B959CA1,0x109B9E98,0x821C1914,0x16122420,0x9F829292,0x9CA9A99F,0x8A8583A1,
0x2E241920,0x1C1F1A20,0xA4910820,0xA1A7A8B1,0x039AA79A,0x19262D1B,0x29342B24,0xA2AC9A06,
0xB2AAA4A2,0x1F0C9CAC,0x2F221013,0x86172A35,0xA5939398,0x97A9B1B0,0x10890905,0x27343423,
0x89008611,0xB1B0A795,0x8F0C96A6,0x31210E91,0x8E112831,0xA7980713,0x8BA3AFB1,0x0C9C9A08,
0x212F3428,0x83140009,0xA9B3AC9A,0x9D8A95A1,0x352E1894,0x071A2530,0xAEA0801D,0x9DA5ADB3,
0x1A97A18B,0x252D3428,0x071D0F20,0xACB2ABA2,0x9C92A0A5,0x332D218B,0x0B14212C,0xADA69115,
0x9FA2A8B1,0x260C9393,0x242B3432,0x94038017,0xAFB3B1A9,0x9492A0AA,0x35322512,0x101F2A32,
0xB0AA9F09,0xA3ADB0B3,0x2410989B,0x2D323630,0x9C0D1624,0xB0B2B0A9,0x9997A2AE,0x332D2314,
0x16202B31,0xAAA39714,0xA2ADB2B2,0x1E028C92,0x2C33332A,0x8C86801D,0xB2B2A89F,0x8484A0AA,
0x3329188C,0x09202B34,0xA9A18300,0xA0A7B3B3,0x168D858A,0x2A333024,0x02011221,0xB3AEA69D,
0x8799A3A8,0x30240D91,0x1C252E32,0xA4901211,0xA6AEB3AE,0x8494889A,0x3031271C,0x13122127,
0xB2A8A005,0x92A3A8B0,0x23129599,0x2529312F,0x8F18171F,0xA9AEABA0,0x999CA1A8,0x312C1B85,
0x1526282F,0xAAA28C0D,0xA8A8ACAF,0x099A9FA3,0x2D312E23,0x191D252A,0xAFADA38E,0x9FA4A8AA,
0x251A0198,0x28292A29,0x980B1F23,0xAAACACA6,0x9AA3A5A7,0x251F118F,0x262B292A,0xA0910214,
0xA9A8A6A0,0x809399A6,0x27241E18,0x19212929,0xA3978F0F,0xA4A9AAA9,0x098C989E,0x23252317,
0x121A2324,0xA3A29704,0x9A9CA0A4,0x1B029093,0x20222320,0x02151921,0x99A1A095,0x9A9B9A96,
0x0A0A8496,0x17161411,0x86000611,0x9294938B,0x8891928F,0x06050502,0x0B12130D,0x0D080409,
0x91939487,0x978A8587,0x098A909B,0x130F0D13,0x04111617,0x868D928C,0x969B9B92,0x0505018F,
0x1A1A110D,0x80060F15,0x9B958F89,0x8B929BA0,0x13068080,0x13181E1D,0x830D0B0F,0x9DA09D96,
0x93949C9C,0x1C150D88,0x1114181C,0x92801012,0x9B989999,0x82959BA0,0x17100B0E,0x151B201D,
0x89820811,0xA09E9D96,0x9094999E,0x1E120788,0x14131620,0x90031316,0x9A969A9B,0x88949796,
0x12120D06,0x15131816,0x928E8010,0x94939394,0x0F818C90,0x10008608,0x040E1517,0x80058884,
0x91959290,0x85828484,0x130A0485,0x0383830C,0x8F860307,0x84858D94,0x81908D82,0x83050304,
0x05040581,0x90919101,0x95908487,0x02028290,0x15120705,0x10060510,0x82890513,0x918F8981,
0x8904068A,0x05080681,0x0E038683,0x85000C0E,0x86848482,0x80048B90,0x060A0789,0x03060402,
0x96978D82,0x8D840888,0x0C0D0D02,0x090F0603,0x9190958A,0x938B9298,0x06868990,0x190B0610,
0x09110616,0x93910182,0x9496958E,0x068B9293,0x161B1911,0x110E1A1E,0x96929388,0x858D9796,
0x01858592,0x161A0B0C,0x01131E0E,0x98988E0B,0x90A09C95,0x05059192,0x1D131210,0x021D1415,
0x97998388,0x979F9D9B,0x02919480,0x1710078A,0x1C19131F,0xA2920181,0x9A9E9E9B,0x03938995,
0x191A030E,0x140B1A17,0x90080015,0x9B960595,0x8A8F9693,0x20048200,0x1519141A,0x96008209,
0xA3958F9E,0x858E0795,0x14098707,0x1B0D0515,0x810F0810,0x9890908B,0x97929298,0x108A9090,
0x0E128606,0x81038686,0x83880383,0x92980D14,0x04069387,0x1B0E8490,0x01130003,0x93920807,
0x92958602,0x03808992,0x10129392,0x110A130D,0x83890E14,0x8696930E,0x06869C96,0x10110684,
0x03140B02,0x928B1007,0x9F958487,0x86929997,0x19138F91,0x0F1B1705,0x04021216,0x90968902,
0x90A1A191,0x12999B82,0x07128C84,0x0914150C,0x8B8D0E06,0x0E869506,0x0102018C,0x00119006,
0x9108089A,0x01120A8B,0x8D9A0211,0x91150389,0x98881B86,0x97028294,0x02858589,0x02171887,
0x02060C15,0x99060592,0x8F928492,0x9C958B90,0x05918380,0x050B0A80,0x8C031715,0x00001208,
0x09828A82,0x94038189,0x8D958301,0x0A8A0600,0x89028211,0x030A2200,0x8F919A83,0xA0988304,
0x8B900E8C,0x111D0387,0x85171E11,0x8C010A85,0x99989094,0x8E939490,0x00050980,0x02111E12,
0x86910D1F,0x9994908E,0x91939095,0x100C0E04,0x11131518,0x9101210E,0x9796930C,0x91919299,
0x0F810680,0x0E1D1207,0x92050F08,0x94988484,0x92919793,0x09878791,0x120E1615,0x1407111B,
0x9893800F,0x95A29490,0x8690998F,0x0C171702,0x121B180E,0x88051011,0x989D9487,0x909D9A91,
0x8A01888E,0x15151B13,0x0F151F20,0x95888902,0x919A9A9A,0x06919885,0x120B858B,0x15151516,
0x00870D14,0xA09B8F80,0x8994939A,0x08160389,0x08080C86,0x0B021315,0x8B8E880C,0x8A91868A,
0x0D089990,0x01140499,0x00820B11,0x8C8B0180,0x8D898202,0x85858E8B,0x9283008A,0x82000800,
0x12121206,0x8F810512,0x81009391,0x8C939192,0x13909384,0x04068309,0x03030E11,0x9108018E,
0x98968C86,0x92050094,0x0B121901,0x020E1213,0x84808A00,0x898B9091,0x86889292,0x81051106,
0x12060207,0x92890106,0x99958B85,0x038D8490,0x11140202,0x12120F0C,0x87088304,0x91918A8F,
0x888C9193,0x850D0786,0x0D070A87,0x0B810713,0x91929487,0x8B928A8D,0x09828103,0x12171208,
0x0F0C090A,0x908E8802,0x94949490,0x82858C98,0x080C1310,0x150D1814,0x87880417,0x8F919B98,
0x968F8992,0x14058792,0x151C1713,0x09100F0F,0x95969384,0x96969597,0x85868B92,0x16121503,
0x18161218,0x918C8310,0x9F9C999A,0x9090919A,0x1A151202,0x13181C16,0x8D880913,0x9B9F9887,
0x92979695,0x0D10058B,0x211A1013,0x11181619,0x9E939002,0x9F9E9FA0,0x0401929E,0x1D16150E,
0x18171F21,0x98968A09,0x9A99A0A0,0x01959596,0x1E150D0F,0x00171E1B,0x8F090804,0x9A9C9B99,
0x9391989A,0x04040301,0x1F201B11,0x090F0715,0x97939588,0x95A09A9C,0x0A07858F,0x1C121311,
0x040D171C,0x96938E86,0x8F90959B,0x8D91868F,0x010F1314,0x0114180F,0x00110B07,0x96918C8C,
0x8C969B96,0x0A048C8F,0x2211820C,0x17140D19,0x97938804,0x9C9C9094,0x8C948593,0x050F0E02,
0x07111710,0x0710130E,0x8981030B,0x93909A95,0x87929F98,0x1A019691,0x201C191E,0x91061019,
0x9F96888F,0x9A999CA1,0x10090C8E,0x16141111,0x06121614,0x8E929484,0x84949894,0x00959B87,
0x00021012,0x121A120B,0x00130609,0xA2A0929A,0x9F829399,0x221702A0,0x181D1C1E,0x83070E13,
0x9EA19794,0x8A9CA09E,0x10940E18,0x08131E22,0x938C820C,0x88951108,0x8F01A198,0x08818E92,
0x0C158E96,0x1C110B0D,0x0C0C181D,0x99840009,0xA1A49C99,0x989099A0,0x1D11148F,0x192A221E,
0x8212170B,0x97A4A49D,0x9292948C,0x8090140F,0x19100111,0x8C852022,0x98938008,0x818E9392,
0x8B969D98,0x17869480,0x1F1C0E05,0x200A811A,0x00868A10,0x9C93958E,0x8792929C,0x110F938C,
0x9B881280,0x191597A0,0x17151211,0x09151711,0x9D9F9507,0x0D02A2A2,0x00040207,0x1A1F0293,
0x82161311,0x86010791,0x95939584,0x92919D9E,0x8A820D8C,0x191E0596,0x19201B14,0x0D18150B,
0x9D9A9A92,0x819EA3A0,0x89018185,0x16148686,0x14130912,0x01141303,0x9C968F8E,0x0E91939C,
0x9998970C,0x0F051184,0x191D110E,0x201A191A,0xA19A9414,0x90849FA2,0x9499A0A5,0x19068C02,
0x1A262216,0x0D1E2116,0xA5A39600,0x998994A0,0x92A19199,0x100E0713,0x1414231F,0x0D121819,
0xA3A39F00,0x1B0A939E,0x8C9AA002,0x0D109289,0x150F0184,0x18210781,0x9F9A8010,0x84151390,
0x9C918984,0x9085919B,0x83070396,0x20241706,0x90840C0E,0x8612018D,0xA0871692,0x87959699,
0x95899594,0x1715250A,0x01171B21,0x938B0E05,0x8F959C96,0x8297A5A1,0x1285880B,0x04202218,
0x0E10201B,0x9C940004,0xA3A49E9B,0x88040298,0x21128592,0x12111B22,0x1092040D,0x8B908019,
0x98A49F8F,0x95989B99,0x15131B0C,0x1E231511,0x170F8787,0x1C979E12,0x999DA293,0x8695A09F,
0x1F039B96,0x1429291C,0x141A150F,0x03118590,0xA2A0A3A0,0x908B9A9F,0x150A939C,0x1E221414,
0x11171D19,0x9989131A,0xA9938998,0x949F8CA0,0x00029193,0x11101712,0x26221E1A,0x90939015,
0xA2A38F07,0x85A2A195,0x0983938A,0x14020D20,0x13161610,0x12178F03,0x969B9890,0x07859995,
0x90089AA0,0x1D0F020C,0x10090F10,0x8F128204,0x8B910C06,0x9E928489,0x91A38B90,0x88058F13,
0x18161685,0x170B070E,0x8082861D,0x9797908E,0x8D07A0A0,0x8F8080A2,0x0E17040D,0x170A1A0C,
0x82161B18,0x9C888008,0x92A7A1A3,0x0907A492,0x1E120787,0x211F1C0F,0x85161121,0x93020893,
0x9BA3A3A3,0x0B92A48A,0x11020F95,0x1F208010,0x18171016,0x87800788,0x959E9F90,0x84959C8B,
0x89880B91,0x1D208A84,0x13141010,0x95828191,0x848C8D88,0x94849094,0x808A0E81,0x0A179091,
0x0901028C,0x818D810A,0x85810308,0x00060D84,0x90928F81,0x93811788,0x958F8306,0x04818091,
0x1514120D,0x07110C14,0x95A09588,0x959A9685,0x8401868D,0x1213100C,0x0F1E1E11,0x928B000A,
0x069FA79F,0x969B9407,0x0405808C,0x1C221682,0x0E0E1D1B,0x9E93870B,0x9494989E,0x899D9A98,
0x0C13020A,0x1E21271A,0x0A16000E,0x9EA39E90,0x90969090,0x88859593,0x22140483,0x840B1321,
0x8F091300,0x02849A9A,0x94908587,0x89820689,0x19150388,0x08918E0F,0x968E0008,0x82040B8C,
0x0B868E86,0x02030801,0x850C1715,0x85899396,0x099A9682,0x05838A13,0x14150B83,0x8307010F,
0x878A8B8B,0x9B988F8C,0x84070490,0x06000203,0x0C0C0E0A,0x8003850B,0x00898E86,0x80919C94,
0x0A058880,0x16180B88,0x01080810,0x86848202,0x92949697,0x04838D91,0x060A0609,0x11121300,
0x8A02050F,0x98989389,0x89919698,0x10130F03,0x0E181B18,0x05908D0B,0x85898F86,0x9F9D9890,
0x060A0393,0x16161384,0x13131219,0x97958110,0x9D999499,0x10038F98,0x0F0B040A,0x01091D17,
0x958D8681,0x0D079092,0x9795928A,0x00070690,0x11131111,0x02868B84,0x908D0106,0x95830382,
0x02888C98,0x1710040E,0x02091117,0x90810285,0x91949695,0x9190888B,0x141B1905,0x12100407,
0x919B9104,0x9D928888,0x0A0D0197,0x0D8C948D,0x1310191A,0x8B131213,0x8E92999A,0x949C9D98,
0x828D9089,0x22242213,0x07141821,0xA09E9990,0xA1A1989A,0x10078693,0x22211205,0x1817181C,
0xA297840F,0x9E9D9AA0,0x04959D9F,0x211C120F,0x1921211E,0x85830111,0xA5A19D98,0x8E909BA3,
0x1D100384,0x2020191C,0x880B171B,0x9F939797,0x99979EA1,0x0C018694,0x1A1C211C,0x878B0E1B,
0x8B91998F,0x8C999D98,0x12088282,0x101C221A,0x8E86090E,0x95989894,0x95999595,0x10090887,
0x1D232118,0x8F8C0A14,0x9B9C9E99,0x979B9997,0x05090A87,0x20222115,0x8A0C0E17,0x979E9F96,
0xA09C9392,0x0B170599,0x1C201800,0x04870E1D,0x9C96080D,0x988D969C,0x1380939A,0x151A0100,
0x0F151B15,0x9E8A0606,0x99969498,0x1092949A,0x210C8D15,0x0F1A1213,0x900E0382,0x9187919D,
0x94969899,0x0B941011,0x1A121421,0x15118610,0x8B8FA195,0x9A969996,0x9911149A,0x15152211,
0x1288111B,0x829EA00D,0x8C989981,0x0C189A9D,0x0D24169B,0x9509180F,0x99952013,0x9B950084,
0x149DA196,0x2102A205,0x1B221610,0x98201A03,0xA08F8699,0x9EA296A0,0x12A08115,0x1D181223,
0x1E168914,0x81829998,0xA4939897,0xA286119F,0x14122003,0x16021F1F,0x8096951F,0x95A19C82,
0x0310A2A3,0x14230BA1,0x041E2017,0x98971D15,0xA29C8A8C,0x10A2A191,0x2310A103,0x1C201B17,
0x921F1081,0x9D8C8C96,0xA0A39AA4,0x0F9F0816,0x20191422,0x2017021D,0x88879697,0xA599A198,
0xA0840EA2,0x19142209,0x18052022,0x89989221,0x96A3A08C,0x020CA4A4,0x0E24149D,0x00202416,
0x95902118,0xA39E8A87,0x079FA295,0x200DA293,0x21221714,0x9621200F,0xA0878395,0xA3AAA2A6,
0x159B030F,0x221C1624,0x1F1F0B1D,0x8F949F9A,0xA495A2A1,0x9C001A9A,0x16081E10,0x1F801621,
0x03919321,0x949B9B85,0x9381A3A7,0x1024189D,0x101A1D11,0x96941C20,0xA3A2898B,0x1693A699,
0x21149A91,0x13211D18,0x98152008,0xA2938393,0x94A59D9E,0x1B948D0B,0x17171924,0x1A1F0207,
0x84819495,0xA59D9EA0,0x9D91138F,0x1F191F0D,0x2006121F,0x9097901E,0xA09DA091,0x8B0796A6,
0x15231F8C,0x81831D1E,0x96961720,0x95A08B03,0x0D8CA9A0,0x1D159B97,0x16211D13,0x9414271A,
0xA19A9591,0x8FA8A4A2,0x26949912,0x1C201624,0x0A22160D,0x94919FA0,0xA3A2A0A2,0x8A91110C,
0x1707201F,0x20121621,0x84989F17,0xA29DA3A0,0x898E8B9D,0x14222304,0x1316201F,0x93A2821D,
0xA1A19982,0x0E009BA2,0x181B0085,0x11211F13,0x96081F0E,0xA5A3928B,0x92A29A9D,0x230F0310,
0x24230F18,0x99170805,0xA18D809E,0xA2A096A2,0x09961210,0x27140A21,0x1C1A8D18,0x9885938C,
0xA8929CA5,0x8E0F1CA0,0x20122118,0x06850F25,0x8F958906,0x9191A095,0x0D1B91A5,0x15131286,
0x840F1721,0x91021388,0x969D9788,0x1092A19B,0x18138C83,0x191A1F1C,0x961B108E,0x9DA39796,
0x929E9D9A,0x20020915,0x1B1C1B1D,0x0E159701,0x9994959B,0x9A91949A,0x0C011701,0x1814181C,
0x1B848418,0x938E960F,0x9A95A0A1,0x0105839A,0x1D181F1A,0x0A86111A,0x909C9716,0x9194A1A0,
0x1212949A,0x13132416,0x8809101E,0x009C8208,0x9497A28F,0x08069296,0x88181F8A,0x84850F1B,
0x8D931002,0x8F999D03,0x0D869998,0x87261B8E,0x88812313,0x9D910C05,0x00A1940A,0x1B8E9C91,
0x1528830F,0x96101C9B,0x9C04078D,0x91A10E02,0x0C949307,0x24179A11,0x901D0D95,0x8F100286,
0xA3990D9B,0x82958F82,0x21858712,0x8F198C05,0x058D8795,0x9B058292,0x82900982,0x1D8D0013,
0x84148F0F,0x88000891,0x908A898D,0x898F9191,0x208C0614,0x051F8913,0x850A8798,0x9791058D,
0x03968705,0x12980112,0x1011A107,0x091089A2,0x91110282,0x888F200A,0x08971121,0x14919F10,
0x9792A7A0,0x8F05079D,0x89151687,0x210C251F,0x8D918524,0x969FA3A0,0x958FA19A,0x8C801095,
0x16071B19,0x1605801F,0x14118903,0x9A07038C,0x9D960688,0x968E1393,0x0D94990A,0x0C8F9C94,
0x1A1B1114,0x1B24231F,0x94951310,0xA2A8A305,0x9DA9ACA8,0x22039198,0x232A2524,0x22242D23,
0xA08D8A20,0xA7B0B0AC,0xA5A1A1A7,0x1F128A97,0x2628291F,0x120E1C2D,0x91928A00,0xA399A1A1,
0x959A9EA0,0x84090B8E,0x02001C11,0x15038612,0x15131719,0x030B1119,0x99949998,0xA3939097,
0x93A4A6A6,0x211D0C87,0x24272A2A,0x2122201E,0xB0A7A282,0xACAAACB0,0x8AA2A0A7,0x28221210,
0x2B2D3233,0x02131722,0xAFADABA1,0xA6A8A6AA,0x808F97A1,0x25201E12,0x2023252E,0x05989680,
0x98949785,0x9188939D,0x05899299,0x91939111,0x10060B84,0x21121012,0x16161320,0x03190913,
0xA7A5A3A2,0xA9A9ABAC,0x1B121D89,0x2E241D1A,0x23262530,0xA29B8816,0xB0ACB1B1,0x9BA4A3A7,
0x28251893,0x26262927,0x940A1F29,0xA0A49D99,0xA0A3A7A1,0x0F05939C,0x20241D0C,0x9C86141E,
0x03820895,0x02838B0B,0x0F0D120E,0x85018587,0xA1A5A493,0x908B93A1,0x25200F8C,0x1F212827,
0x8B122023,0xAAB0ACA0,0x9BA7A9AB,0x1B168895,0x2B272626,0x0A1B2528,0xA09FA297,0xA8ABA7A3,
0x048B99A1,0x232A2013,0x100C1C19,0x9A948A11,0x849C968D,0x1011968C,0x84121501,0x93868B90,
0x9EA09795,0x130A0F02,0x24272211,0x8B842326,0xA79EA194,0x95A1ABAB,0x87898591,0x252B2B13,
0x2312172B,0xA79B8810,0xA4A3ADAC,0x91A4A3A6,0x26222725,0x1C241017,0x989D8B0F,0x93828598,
0x0DA1A29A,0x08191122,0x0A1F1C92,0x98A1A398,0x95940A81,0x2F208C8A,0x931F1A23,0x9C8D1488,
0x9BA1A3A9,0x99A29C8A,0x2B291788,0x17202421,0xA1891825,0xA0A8A6AB,0x959FA9A2,0x10211B8A,
0x211F2518,0x96811221,0x95A09591,0x969DA5A2,0x131C1593,0x14092125,0x928A8A80,0x8F94A193,
0x92810396,0x1719210B,0x14930321,0x9E978813,0x9291A8AA,0x898A8490,0x24242E1F,0x19028B21,
0xA6A49811,0xA1029FA9,0x0C9EA1A3,0x20172A28,0x2622071D,0xA5A29D0B,0xA28A92A6,0x11868DA0,
0x23881522,0x1423171E,0x9A9D9E8D,0xA295939E,0x138B8393,0x231C2021,0x070F8F14,0xA59D918A,
0x959499A3,0x11880385,0x241C2126,0x161D0711,0xA7A7A795,0x980101A0,0x0D909099,0x21112029,
0x141D1015,0x9BA0A396,0xA49A9BA2,0x1B0A128B,0x18151D21,0x17100820,0x9F939F9B,0x9B95949B,
0x8C958F97,0x261D2622,0x09028D20,0x9F9B9C91,0x8F0B92A4,0x89918B8A,0x09052218,0x24121121,
0xA39DA006,0x8A8194A3,0x0411869F,0x04072420,0x819E821A,0x0B849008,0x9691A095,0x8E838B9E,
0x10252483,0x0A981A22,0xA1AAA112,0x2016989D,0x99899286,0x09221499,0x100E1E0F,0x949D0924,
0x9DA5A396,0x20119896,0x0C1C1512,0x030F8590,0x98081C11,0x8690120B,0x9BA4A08F,0x24039691,
0x11251A21,0x9B8C909F,0x99861A86,0x1081008D,0x87A29B0B,0x0F038411,0x1D230A88,0xA2908D84,
0x8884869F,0x83979388,0x07032221,0x1588930B,0x06819C90,0x85100188,0xA3948A97,0x100F1889,
0x1B8A1720,0x8F938023,0x0F90A8A6,0x8D0C898D,0x8A1C1C8C,0x8293038C,0x808C1E23,0x088C9210,
0x93A0A698,0x1B200592,0x931E1B0E,0x9D8A1692,0x0286008D,0x08968B12,0x869A9C02,0x20148D8A,
0x0F241D13,0xA49A8993,0x8491919B,0x06970512,0x1204101D,0x12019987,0x85110702,0x8B140D95,
0xA0A19693,0x88081909,0x17850B0D,0x1405821B,0x8288948D,0x9281908E,0x93088096,0x0D01098A,
0x85091D1A,0x07908905,0x92939106,0x10039694,0x8A078983,0x10130F8D,0x840F1507,0x94940B10,
0x92A29E91,0x190A8580,0x1C138111,0x8E088202,0x8B0D0792,0xA09C8B90,0x02828291,0x18040A0F,
0x0F0B1923,0x0486998C,0x948D9995,0x8E018896,0x020D0293,0x14192116,0x848B0D18,0x9DA09780,
0x80919E9F,0x170B0001,0x191B0F12,0x81120D08,0x9E900583,0x9AA09999,0x1084878B,0x1B141417,
0x10070E1B,0x02068F82,0x9C949493,0x908A939D,0x1611068B,0x091C231F,0x8A930411,0x949F9A88,
0x06889994,0x0C0A8187,0x1717100A,0x87111510,0x98938488,0x979C9797,0x09048188,0x160F1110,
0x0908161D,0x05808D02,0x9D989D96,0x8388929C,0x17181004,0x0D171918,0x92850803,0x979B9490,
0x90979693,0x13070083,0x1C131619,0x0F0F0419,0x9A899292,0x9A9596A0,0x01008493,0x1016180E,
0x10101A18,0x92968414,0x91979B94,0x818E9996,0x15110702,0x18161214,0x85040712,0x9A8F8E91,
0x9796949A,0x0E020387,0x10101415,0x070D1614,0x92958F06,0x8C949A95,0x04829394,0x1212150F,
0x0F0E0910,0x87040003,0x97918A91,0x91959092,0x11110186,0x02101511,0x8005120F,0x8C959000,
0x8A8D918C,0x06869392,0x11100D0C,0x1311030A,0x92810004,0x8D828A96,0x94938B8E,0x09090586,
0x090B0D07,0x860F1712,0x8C968984,0x87929281,0x07839390,0x090B0801,0x130E0C0E,0x8305800D,
0x94888B90,0x93908E96,0x0E810182,0x0E10070F,0x0513110A,0x928E8484,0x90928A89,0x83909591,
0x040E0E03,0x1105100D,0x00830614,0x8887908B,0x92919291,0x04838691,0x1406050F,0x0F120710,
0x88018585,0x948B8790,0x898E888F,0x05088083,0x030D1004,0x01021110,0x868D8802,0x888D9189,
0x00808D8E,0x04090C01,0x06010D0F,0x8885030A,0x818B8B86,0x878C8E86,0x09018083,0x11070009,
0x05090208,0x86818587,0x8C888C8D,0x86810187,0x08010080,0x080D0607,0x00050082,0x91878083,
0x8788828A,0x00898104,0x0E078106,0x02068200,0x84050600,0x8A858489,0x84870183,0x03828001,
0x05058102,0x82030282,0x85000500,0x85828285,0x85880081,0x80848201,0x04018482,0x00060082,
0x87810480,0x83840280,0x01838202,0x80818581,0x01028385,0x81030181,0x82020380,0x83810382,
0x82840302,0x81858300,0x02838783,0x03018480,0x01070281,0x80020282,0x84810000,0x85838284,
0x82868485,0x04818300,0x06068001,0x82050300,0x86010085,0x87868185,0x81868381,0x03820004,
0x08038104,0x01808003,0x80808200,0x86828486,0x86838287,0x00000500,0x05800809,0x8183010A,
0x81848884,0x80808A89,0x03060183,0x82040903,0x89830702,0x84898380,0x03878982,0x06008006,
0x00040507,0x8A010282,0x8B80808B,0x82828088,0x03800302,0x02010408,0x80058081,0x0101888C,
0x03818B87,0x82838481,0x83040481,0x01080B01,0x03818180,0x808A8D80,0x028A8A80,0x82010002,
0x02060481,0x01090500,0x01018284,0x83858A86,0x80858484,0x82830304,0x00030605,0x05050300,
0x03808500,0x00838A85,0x80868782,0x87010400,0x81050880,0x01040600,0x05818003,0x80858C82,
0x80898983,0x82000001,0x04080500,0x00080580,0x02028184,0x84898A84,0x81898782,0x81000303,
0x02060804,0x00050280,0x04828884,0x00818A85,0x81838482,0x85010700,0x83040901,0x82020381,
0x05828583,0x03818781,0x00808500,0x85000381,0x82040400,0x82030385,0x80808382,0x01020083,
0x01018180,0x85850101,0x83828000,0x00828182,0x80030200,0x01050400,0x82000083,0x83868480,
0x80828181,0x00000001,0x00820405,0x80000102,0x00818200,0x82008183,0x01818382,0x04018281,
0x05038200,0x01008002,0x84800080,0x83828182,0x83820083,0x81030280,0x04010300,0x81018000,
0x82808282,0x83818085,0x80828000,0x05828002,0x00808003,0x82800102,0x84820181,0x83810080,
0x01020081,0x04028082,0x02808301,0x03818201,0x82808080,0x82818080,0x00810281,0x81800003,
0x80800080,0x80000181,0x82000100,0x00808182,0x03018383,0x02018200,0x80818000,0x81820001,
0x82810001,0x82810180,0x81000180,0x02000000,0x00008180,0x00008100,0x01008181,0x00018080,
0x01818180,0x00008180,0x00000000,0x82810000,0x82800181,0x00020080,0x80008082,0x00808181,
0x01808000,0x80818001,0x80818000,0x81010180,0x80000080,0x80808181,0x00008000,0x00008080,
0x00818100,0x80818001,0x80808000,0x80808080,0x81800080,0x01000080,0x01018180,0x00008180,
0x81808081,0x80800081,0x80800000,0x80000000,0x00010080,0x80808080,0x81818000,0x80808000,
0x80000080,0x80010000,0x00010080,0x00008080,0x80808080,0x80800000,0x80800000,0x80000000,
0x00000080,0x00008080,0x00818100,0x80808080,0x80000000,0x80800000,0x80000000,0x00008000,
0x00808080,0x00808000,0x00008080,0x80000080,0x80000000,0x00000080,0x00808080,0x00808000,
0x00008000,0x80800000,0x00000000,0x00000000,0x00808000,0x00800000,0x00000000,0x00000000,
0x00000000,
};
| 89.611842
| 89
| 0.88865
|
Drc3p0
|
97d22cfa4d2c779f4392e9567e15715f18ec83b1
| 2,136
|
cpp
|
C++
|
user_models/src/coding/galois.cpp
|
uclanrl/dt-icansim
|
3d4288145abe4cafbbd75af2b0bc697c0bebe4e8
|
[
"bzip2-1.0.6"
] | null | null | null |
user_models/src/coding/galois.cpp
|
uclanrl/dt-icansim
|
3d4288145abe4cafbbd75af2b0bc697c0bebe4e8
|
[
"bzip2-1.0.6"
] | null | null | null |
user_models/src/coding/galois.cpp
|
uclanrl/dt-icansim
|
3d4288145abe4cafbbd75af2b0bc697c0bebe4e8
|
[
"bzip2-1.0.6"
] | null | null | null |
/*
* Copyright (c) 2006-2013, University of California, Los Angeles
* Coded by Joe Yeh/Uichin Lee
* Modified and extended by Seunghoon Lee/Sung Chul Choi
* 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 University of California, Los Angeles 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.
*/
#include "galois.h"
/*
unsigned char Galois::Mul(unsigned char a, unsigned char b, int ff)
{
if( a == 0 || b == 0 )
return 0;
else
//return ALog[(Log[a]+Log[b])%(GF-1)]; w/o optimization
return ALog[Log[a]+Log[b]];
}
unsigned char Galois::Div(unsigned char a, unsigned char b, int ff)
{
if( a == 0 || b == 0 )
return 0;
else
//return ALog[(Log[a]-Log[b]+GF-1)%(GF-1)]; w/o optimization
return ALog[Log[a]-Log[b]+GF-1];
}
*/
| 49.674419
| 188
| 0.740637
|
uclanrl
|
97d2306696381fd1499a05a90e0469bdcb40987b
| 1,978
|
cpp
|
C++
|
CPP/WebDev/bbws/WebFramework/Items/Request.cpp
|
michaelg29/Programming
|
2544a742393c6d94e93879f70246ce17d0997011
|
[
"MIT"
] | 2
|
2021-04-05T20:44:54.000Z
|
2022-01-13T05:25:11.000Z
|
CPP/WebDev/bbws/WebFramework/Items/Request.cpp
|
michaelg29/Programming
|
2544a742393c6d94e93879f70246ce17d0997011
|
[
"MIT"
] | 12
|
2020-02-17T05:19:01.000Z
|
2022-03-17T14:56:38.000Z
|
CPP/WebDev/bbws/WebFramework/Items/Request.cpp
|
michaelg29/Programming
|
2544a742393c6d94e93879f70246ce17d0997011
|
[
"MIT"
] | 1
|
2022-01-25T16:48:21.000Z
|
2022-01-25T16:48:21.000Z
|
#include "Request.h"
#include <istream>
#include <sstream>
#include <fstream>
#include <vector>
#include <iterator>
std::string Request::parse() {
std::istringstream iss(m_request);
std::vector<std::string> parsed((std::istream_iterator<std::string>(iss)), std::istream_iterator<std::string>());
method = Global::stoMethod[parsed[0]];
route = Global::getFilePath(parsed[1]);
protocol = parsed[3];
host = parsed[7];
std::string params = parsed[parsed.size() - 1];
if (params.find('=') < params.length() && params.find('=') > -1) {
std::string key = "", val = "";
bool addingToKey = true;
for (std::string::size_type i = 0; i < params.size(); ++i) {
char c = params[i];
if (c == '=') {
addingToKey = false;
continue;
}
else if (c == '&' || i == params.size() - 1) {
addingToKey = true;
data[key] = val + c;
key = "";
val = "";
continue;
}
if (addingToKey)
key += c;
else
val += c;
}
}
int code = 404;
std::string content = "";
// Read file
// Open the document in the local file system
std::ifstream f(route);
// Check if it opened and if it did, grab the entire contents
if (f.good())
{
std::string str((std::istreambuf_iterator<char>(f)), std::istreambuf_iterator<char>());
for (std::pair<std::string, std::string> pair : sendingClient.context) {
std::replace_all(str, "{{ " + pair.first + " }}", pair.second);
}
content = str;
code = 200;
if (route == Global::contextRoute + "/" + Global::errorFile)
code = 404;
}
f.close();
return sendBack(code, content);
}
std::string Request::sendBack(int code, std::string content) {
// write the document back to the client
std::ostringstream oss;
oss << "HTTP/1.1 " << code << " OK\r\n";
oss << "Cache-Control: no-cache, private\r\n";
oss << "Content-Type: text/html\r\n";
oss << "Content-Length: " << content.size() << "\r\n";
oss << "\r\n";
oss << content;
std::string output = oss.str();
return output;
}
| 23.270588
| 114
| 0.602629
|
michaelg29
|
97d25f3120d7c58bf0ce3edfff4aea1bb1ae8ec7
| 501
|
cpp
|
C++
|
common/tests/StringToIntMapTest.cpp
|
alexandru-andronache/adventofcode
|
ee41d82bae8b705818fda5bd43e9962bb0686fec
|
[
"Apache-2.0"
] | 3
|
2021-07-01T14:31:06.000Z
|
2022-03-29T20:41:21.000Z
|
common/tests/StringToIntMapTest.cpp
|
alexandru-andronache/adventofcode
|
ee41d82bae8b705818fda5bd43e9962bb0686fec
|
[
"Apache-2.0"
] | null | null | null |
common/tests/StringToIntMapTest.cpp
|
alexandru-andronache/adventofcode
|
ee41d82bae8b705818fda5bd43e9962bb0686fec
|
[
"Apache-2.0"
] | null | null | null |
#include "StringToIntMapTest.h"
#include <StringToIntMap.h>
using namespace stringtointmap;
TEST_F(StringToIntMapTest, add_string_test_get_index)
{
StringToIntMap t;
t.addString("aaa");
t.addString("bbb");
ASSERT_EQ(t.getIndex("aaa"), 0);
ASSERT_EQ(t.getIndex("ccc"), -1);
}
TEST_F(StringToIntMapTest, add_string_test_get_string)
{
StringToIntMap t;
t.addString("aaa");
t.addString("bbb");
ASSERT_EQ(t.getString(1), "bbb");
ASSERT_EQ(t.getString(2), "");
}
| 20.875
| 54
| 0.686627
|
alexandru-andronache
|
97d327047291fe0f38d38e90a1c8411abf3f7bd4
| 105,063
|
cc
|
C++
|
frontend/src/frontend.cc
|
robert-mijakovic/readex-ptf
|
5514b0545721ef27de0426a7fa0116d2e0bb5eef
|
[
"BSD-3-Clause-No-Nuclear-License-2014",
"BSD-3-Clause"
] | null | null | null |
frontend/src/frontend.cc
|
robert-mijakovic/readex-ptf
|
5514b0545721ef27de0426a7fa0116d2e0bb5eef
|
[
"BSD-3-Clause-No-Nuclear-License-2014",
"BSD-3-Clause"
] | null | null | null |
frontend/src/frontend.cc
|
robert-mijakovic/readex-ptf
|
5514b0545721ef27de0426a7fa0116d2e0bb5eef
|
[
"BSD-3-Clause-No-Nuclear-License-2014",
"BSD-3-Clause"
] | null | null | null |
/**
@file frontend.cc
@ingroup Frontend
@brief Front-end agent
@author Karl Fuerlinger
@verbatim
Revision: $Revision$
Revision date: $Date$
Committed by: $Author$
This file is part of the Periscope Tuning Framework.
See http://www.lrr.in.tum.de/periscope for details.
Copyright (c) 2005-2014, Technische Universitaet Muenchen, Germany
See the COPYING file in the base directory of the package for details.
@endverbatim
*/
#include <string>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <dlfcn.h>
#include "config.h"
#include "psc_config.h"
#include "stringutil.h"
#include "timing.h"
#include "frontend.h"
#define PSC_AUTOTUNE_GLOBALS
#include "IPlugin.h"
#include "autotune_services.h"
#include "frontend_accl_handler.h"
#include "frontend_statemachine.h"
#include <ctime>
#include <cmath>
#include <map>
#include "MetaProperty.h"
#include "PropertyID.h"
#include "application.h"
#include "global.h"
#include "selective_debug.h"
#include "TuningParameter.h"
#include <boost/lexical_cast.hpp>
using namespace std;
using namespace frontend_statemachine;
extern IPlugin* plugin;
extern bool search_done;
bool restart_requested_for_no_tuning;
int agent_pid = -1;
int application_pid;
char user_specified_environment[ 5000 ] = "\0";
PeriscopeFrontend::PeriscopeFrontend( ACE_Reactor* r ) :
PeriscopeAgent( r ),
plugin_context( new DriverContext() ),
fe_context( new DriverContext() ),
frontend_pool_set( new ScenarioPoolSet() ) {
automatic_mode = true;
need_restart = false;
shutdown_allowed = true;
interval = 0;
quit_fe = false;
badRegionsRemoved = false;
allRegionsCommented = false;
ACE_Event_Handler::reactor( r );
RequiredRegions.erase();
requiredRegionsListLastRun.clear();
timer_action = STARTUP;
*masteragent_cmd_string = 0;
*app_name_string = 0;
*app_cmd_line_string = 0;
*master_host_string = 0;
outfilename_string = " ";
*psc_reg_host = 0;
psc_reg_port = 0;
ompnumthreads_val = 1;
iter_count = 1; //sss
ompfinalthreads_val = 1; //sss
mpinumprocs_val = 1;
maxcluster_val = 3;
ranks_started = 0;
total_agents_number = 0;
started_agents_count = 0;
agent_hierarchy_started = false;
}
void PeriscopeFrontend::terminate_autotune() {
/*
* TODO do proper termination here
*
* 1. Call plugin terminate
* 2. Destroy shared pools
* 3. Destroy other frontend structures
* 4. Kill agent hierarchy
* - etc...
*/
if( plugin ) {
plugin->terminate();
delete plugin;
}
fe_context->unloadPlugins();
}
// #define HYBRID__MPI_PROC_ON_PROCESSOR
int PeriscopeFrontend::register_self() {
if( !regsrv_ ) {
psc_errmsg( "PeriscopeFrontend::register_self(): registry not set\n" );
return -1;
}
int pid, port;
pid = getpid();
port = get_local_port();
char hostname[ 200 ];
gethostname( hostname, 200 );
EntryData data;
data.id = -1;
data.app = fe->get_appname();
data.site = sitename();
data.mach = machinename();
data.node = hostname;
data.port = port;
data.pid = pid;
data.comp = "PeriscopeFrontend";
data.tag = get_local_tag();
regid_ = regsrv_->add_entry( data );
char buf[ 200 ];
sprintf( buf, "%s[%d]", data.tag.c_str(), regid_ );
data.tag = buf;
regsrv_->change_entry( data, regid_ );
return regid_;
}
void PeriscopeFrontend::register_master_agent( char* ma_cmd_string ) {
sprintf( masteragent_cmd_string, "%s", ma_cmd_string );
}
void PeriscopeFrontend::register_app_name( char* aname_string ) {
sprintf( app_name_string, "%s", aname_string );
}
void PeriscopeFrontend::register_app_cmd_line( char* acmdline_string ) {
sprintf( app_cmd_line_string, "%s", acmdline_string );
}
void PeriscopeFrontend::register_master_host( char* mhost_string ) {
sprintf( master_host_string, "%s", mhost_string );
}
void PeriscopeFrontend::register_reg_host( char* rhost_string ) {
sprintf( psc_reg_host, "%s", rhost_string );
}
void PeriscopeFrontend::register_reg_port( int reg_port ) {
psc_reg_port = reg_port;
}
void PeriscopeFrontend::set_outfilename( const std::string& outfn_string ) {
outfilename_string = outfn_string;
}
void PeriscopeFrontend::set_ompnumthreads( int ompnt_val ) {
ompnumthreads_val = ompnt_val;
}
void PeriscopeFrontend::set_ompfinalthreads( int ompfinal_val ) {
ompfinalthreads_val = ompfinal_val;
}
void PeriscopeFrontend::set_maxiterations( int iter_val ) {
iter_count = iter_val;
}
void PeriscopeFrontend::set_mpinumprocs( int mpinp_val ) {
mpinumprocs_val = mpinp_val;
}
void PeriscopeFrontend::set_maxcluster( int mcluster_val ) {
maxcluster_val = mcluster_val;
}
ACCL_Handler* PeriscopeFrontend::create_protocol_handler( ACE_SOCK_Stream& peer ) {
#ifdef __p575
sleep( 1 );
#endif
return new ACCL_Frontend_Handler( this, peer );
}
void PeriscopeFrontend::run() {
ranks_started = 0;
started_agents_count = 0;
if( opts.has_scalability_OMP ) {
sleep( 30 );
}
int cores_per_processor = 4;
char senvbuf[ 512 ];
ACE_Reactor* reactor = ACE_Event_Handler::reactor();
if( !reactor ) {
psc_errmsg( "Error: Reactor could not start.\n" );
exit( 0 );
}
// We branch here to start the autotune state machine
if( opts.has_strategy && !strcmp( opts.strategy, "tune" ) ) {
run_tuning_plugin( reactor );
}
else {
run_analysis( reactor );
}
}
/**
* @brief Drives tuning plugins execution
*
*/
void PeriscopeFrontend::run_tuning_plugin( ACE_Reactor* reactor ) {
psc_dbgmsg( PSC_SELECTIVE_DEBUG_LEVEL( FrontendStateMachines ),
"Autotuning application with %s processes...\n",
opts.mpinumprocs_string );
autotune_statemachine atmsm;
atmsm.start();
this->plugin_context->tuning_step = 0;
this->plugin_context->search_step = 0;
this->plugin_context->experiment_count = 0;
bool scenarios_executed = true;
try{
// starting to pass events to the state machine
atmsm.process_event( initialize_plugin( this, reactor, starter ) );
do {
atmsm.process_event( start_tuning_step() );
do {
StrategyRequest* strategy_request = NULL;
if( plugin->analysisRequired( &strategy_request ) ) {
if( strategy_request == NULL ) {
psc_abort( "Pre-analysis requested by plugin, with an invalid strategy request\n" );
}
// TODO find out why the strategy name needs to be set regardless of what is passed to perform analysis
strcpy( opts.strategy, strategy_request->getGeneralInfo()->strategy_name.c_str() );
atmsm.process_event( perform_analysis( strategy_request, this, reactor, starter,
this->plugin_context->tuning_step ) );
strcpy( opts.strategy, "tune" );
}
atmsm.process_event( create_scenarios( this ) );
while( !frontend_pool_set->csp->empty() ) {
atmsm.process_event( prepare_scenarios() );
do {
atmsm.process_event( define_experiment() );
atmsm.process_event( consider_restart( this, reactor, starter,
this->plugin_context->search_step ) );
do {
atmsm.process_event( run_phase_experiments( this, reactor, starter,
this->plugin_context->search_step,
&scenarios_executed,
this->plugin_context->experiment_count ) );
if( scenarios_executed ) {
psc_dbgmsg( PSC_SELECTIVE_DEBUG_LEVEL( FrontendStateMachines ),
"Scenarios executed\n" );
}
else {
psc_dbgmsg( PSC_SELECTIVE_DEBUG_LEVEL( FrontendStateMachines ),
"Scenarios NOT executed\n" );
}
}
while( !scenarios_executed );
psc_dbgmsg( PSC_SELECTIVE_DEBUG_LEVEL( FrontendStateMachines ),
"Prepared scenario pool empty = %d\n",
frontend_pool_set->psp->empty() );
if( !frontend_pool_set->psp->empty() ) {
psc_infomsg( "Prepared scenario pool not empty, still searching...\n" );
}
this->plugin_context->experiment_count++;
}
while( !frontend_pool_set->psp->empty() );
psc_dbgmsg( PSC_SELECTIVE_DEBUG_LEVEL( FrontendStateMachines ),
"Scenario pool empty = %d\n",
frontend_pool_set->csp->empty() );
if( !frontend_pool_set->csp->empty() ) {
psc_infomsg( "Scenario pool not empty, still searching...\n" );
}
}
this->plugin_context->search_step++;
}
while( !plugin->searchFinished() );
atmsm.process_event( finish_tuning_step() );
this->plugin_context->tuning_step++;
}
while( !plugin->tuningFinished() );
atmsm.process_event( create_tuning_advice() );
atmsm.process_event( finalize_autotuning( this ) );
}
catch( std::exception& ex ) {
psc_errmsg( "Exception caught from the Autotune State Machine: %s\n", ex.what() );
terminate_autotune();
abort();
}
}
void PeriscopeFrontend::run_analysis( ACE_Reactor* reactor ) {
set_shutdown_allowed( false );
psc_infomsg( "Starting application %s using %s MPI procs and %s OpenMP threads...\n",
opts.app_run_string,
( strlen( opts.mpinumprocs_string ) ? opts.mpinumprocs_string : "0" ),
( strlen( opts.ompnumthreads_string ) ? opts.ompnumthreads_string : "0" ) );
// TODO invert the order here, when in fast mode
if( get_fastmode() ) {
psc_infomsg( "Starting agents network...\n" );
starter->runAgents();
// TODO need to wait for the agents here first; this prevents connection retries that exhaust file descriptors
starter->runApplication();
psc_dbgmsg( 1, "Application started after %5.1f seconds\n", psc_wall_time() );
}
else {
starter->runApplication();
psc_dbgmsg( 1, "Application started after %5.1f seconds\n", psc_wall_time() );
psc_infomsg( "Starting agents network...\n" );
starter->runAgents();
}
init_analysis_strategy_requests();
print_StrategyRequestGeneralInfoQueue();
if( opts.has_scalability_OMP ) {
sleep( 30 ); //sss
}
reactor->reset_event_loop();
reactor->register_handler( 0, this, ACE_Event_Handler::READ_MASK );
reactor->register_handler( SIGINT, this );
//psc_dbgmsg(1, "STARTUP: run reactor\n");
#ifndef _BGP_PORT_HEARTBEAT_V1
set_timer( 2, 1, timeout_delta(), PeriscopeFrontend::STARTUP );
#endif
reactor->run_event_loop();
int max_runs = 40;
for( int runs = 1; need_restart && runs < max_runs && !quit_fe && restart_requested_for_no_tuning; runs++ ) {
fe->increment_global_timeout();
psc_dbgmsg( FRONTEND_GENERAL_DEBUG_LEVEL, "Restarting application\n" );
set_shutdown_allowed( runs == max_runs - 1 ); //Needrestart msg will be ignored
std::map<std::string, AgentInfo>::iterator it;
for( it = fe->get_child_agents()->begin(); it != fe->get_child_agents()->end(); it++ ) {
AgentInfo& ag = it->second;
if( ag.status != AgentInfo::CONNECTED && fe->connect_to_child( &ag ) == -1 ) {
psc_errmsg( "Error FE not connected to child\n" );
exit( 1 );
}
else {
ag.appl_terminated = false;
ag.handler->terminate();
}
}
psc_dbgmsg( FRONTEND_GENERAL_DEBUG_LEVEL, "RESTART_ACTION: waiting for application to terminate\n" );
reactor->reset_event_loop();
//evt.reactor->register_handler(0, evt.fe, ACE_Event_Handler::READ_MASK);
//evt.reactor->register_handler(SIGINT, evt.fe);
set_timer( 2, 1, timeout_delta(), PeriscopeFrontend::APPLICATION_TERMINATION );
reactor->run_event_loop();
psc_dbgmsg( FRONTEND_GENERAL_DEBUG_LEVEL, "RESTART_ACTION: application terminated.\n" );
starter->rerunApplication();
ACE_Reactor* reactor = ACE_Event_Handler::reactor();
if( !reactor ) {
psc_errmsg( "Error: Reactor could not start.\n" );
exit( 0 );
}
reactor->reset_event_loop();
//psc_dbgmsg(1, "register reactor\n");
reactor->register_handler( 0, this, ACE_Event_Handler::READ_MASK );
reactor->register_handler( SIGINT, this );
//psc_dbgmsg(1, "REINIT: run reactor\n");
set_timer( 2, 1, timeout_delta(), PeriscopeFrontend::STARTUP_REINIT );
reactor->run_event_loop();
//psc_dbgmsg(1, "finished reactor\n");
}
}
void PeriscopeFrontend::stop() {
ACE_Reactor* reactor = ACE_Event_Handler::reactor();
if( !get_fastmode() ) {
if( reactor ) {
psc_dbgmsg( PSC_SELECTIVE_DEBUG_LEVEL( HierarchySetup ), "Stopping the ACE Reactor (NOT fast mode)\n" );
reactor->end_event_loop();
}
}
#ifdef __p575
if( !get_fastmode() ) {
regsrv_->delete_entry( regid_ );
}
#endif
}
int PeriscopeFrontend::handle_input( ACE_HANDLE hdle ) {
int cnt;
const int bufsize = 200;
char buf[ bufsize ];
buf[ 0 ] = '\0';
buf[ 1 ] = '\0';
if( !read_line( hdle, buf, bufsize ) ) {
return -1;
}
handle_command( buf );
return 0;
}
int PeriscopeFrontend::handle_signal( int signum,
siginfo_t*,
ucontext_t* ) {
ACE_Reactor* reactor = ACE_Event_Handler::reactor();
if( reactor ) {
reactor->end_event_loop();
}
quit();
return 0;
}
void PeriscopeFrontend::handle_command( const std::string& line ) {
string cmd;
ssize_t pos;
pos = strskip_ws( line, 0 );
pos = get_token( line, pos, "\t \n", cmd );
if( cmd.compare( "graph" ) == 0 ) {
graph();
prompt();
return;
}
if( cmd.compare( "start" ) == 0 ) {
start();
return;
}
if( cmd.compare( "check" ) == 0 ) {
check();
prompt();
return;
}
if( cmd.compare( "help" ) == 0 ) {
help();
return;
}
if( cmd.compare( "quit" ) == 0 ) {
quit();
return;
}
if( cmd.compare( "properties" ) == 0 ) {
properties();
return;
}
fprintf( stdout, "Unknown command: '%s'\n", cmd.c_str() );
prompt();
}
// adds a started agent without tracking the processes it handles; there is no need to track the controlled processes here in fast mode, since the
// processes are specified before the launch explicitly
void PeriscopeFrontend::add_started_agent() {
psc_dbgmsg( PSC_SELECTIVE_DEBUG_LEVEL( HierarchySetup ),
"Entering add_started_agent(); started: %d; total %d; ready: %s;\n",
started_agents_count, total_agents_number,
agent_hierarchy_started ? "true" : "false" );
started_agents_count++;
if( !agent_hierarchy_started ) {
if( started_agents_count == total_agents_number ) {
agent_hierarchy_started = true;
}
}
}
// increases the number of started agents and if it equals to the total amount issues start command
// this version is used in the BGP style launchers
void PeriscopeFrontend::add_started_agent( int num_procs ) {
started_agents_count++;
ranks_started += num_procs;
if( num_procs != 0 ) {
psc_dbgmsg( 0, "Heartbeat received: (%d mpi processes out of %d ready for analysis)\n", ranks_started, get_mpinumprocs() );
}
if( ranks_started == get_mpinumprocs() ) {
psc_dbgmsg( 1, "Agent network UP and RUNNING. Starting search.\n\n" );
psc_dbgmsg( 1, "Agent network started in %5.1f seconds\n", psc_wall_time() );
if( !agent_hierarchy_started ) {
agent_hierarchy_started = true;
fe->set_startup_time( psc_wall_time() );
}
if( automatic_mode ) {
start();
}
else {
prompt();
}
}
}
void PeriscopeFrontend::remove_started_agent() { // increases the number of started agents and if it equals to the total amount issues start command
started_agents_count--;
total_agents_number--;
psc_dbgmsg( FRONTEND_HIGH_DEBUG_LEVEL, "One agent was dismissed\n" );
}
int PeriscopeFrontend::handle_timeout( const ACE_Time_Value& time,
const void* arg ) {
psc_dbgmsg( PSC_SELECTIVE_DEBUG_LEVEL( ACECommunication ),
"PeriscopeFrontend::handle_timeout() called\n" );
return handle_step( timer_action );
}
int PeriscopeFrontend::handle_step( TimerAction timer_action ) {
std::map<std::string, AgentInfo>::iterator it;
bool done;
psc_dbgmsg( PSC_SELECTIVE_DEBUG_LEVEL( ACECommunication ),
"PeriscopeFrontend::handle_step()\n" );
switch( timer_action ) {
case STARTUP:
psc_dbgmsg( PSC_SELECTIVE_DEBUG_LEVEL( ACECommunication ),
"PeriscopeFrontend::handle_step() STARTUP\n" );
done = true;
for( it = child_agents_.begin(); it != child_agents_.end(); it++ ) {
if( it->second.status != AgentInfo::STARTED ) {
psc_dbgmsg( PSC_SELECTIVE_DEBUG_LEVEL( HierarchySetup ),
"Child agent %s at (%s:%d) not started, still waiting...\n",
it->first.c_str(), it->second.hostname.c_str(), it->second.port );
done = false;
}
}
if( done ) {
if( !agent_hierarchy_started ) {
agent_hierarchy_started = true;
psc_dbgmsg( 1, "Agent network UP and RUNNING. Starting search.\n\n" );
psc_dbgmsg( 1, "Agent network started in %5.1f seconds\n", psc_wall_time() );
fe->set_startup_time( psc_wall_time() );
}
ACE_Reactor* reactor = ACE_Event_Handler::reactor();
reactor->cancel_timer( this );
if( automatic_mode ) {
// TODO in fast mode, the call to start() needs to occur after the application is launched with the starter
if( get_fastmode() ) {
search_done = true; // exit the comm phase in fast mode
}
else {
start();
}
}
else {
prompt();
}
}
else {
if( this->timed_out() ) {
psc_errmsg( "Timed out waiting for child agent(s)\n" );
quit();
}
}
psc_dbgmsg( PSC_SELECTIVE_DEBUG_LEVEL( ACECommunication ),
"PeriscopeFrontend::handle_step() STARTUP done!\n" );
break;
case STARTUP_REINIT:
// TODO check this are for the restart bug
psc_dbgmsg( PSC_SELECTIVE_DEBUG_LEVEL( ACECommunication ),
"PeriscopeFrontend::handle_step() STARTUP_REINIT\n" );
done = true;
for( it = child_agents_.begin(); it != child_agents_.end(); it++ ) {
if( it->second.status_reinit != AgentInfo::STARTED ) {
done = false;
}
}
if( done ) {
psc_dbgmsg( 0, "Analysis agents connected to new processes and ready for search.\n" );
ACE_Reactor* reactor = ACE_Event_Handler::reactor();
reactor->cancel_timer( this );
for( it = child_agents_.begin(); it != child_agents_.end(); it++ ) {
AgentInfo& ai = it->second;
if( fe->connect_to_child( &ai ) == -1 ) {
psc_errmsg( "Error connecting to child at %s:%d\n", ai.hostname.c_str(), ai.port );
}
else {
ai.search_status = AgentInfo::UNDEFINED;
ai.handler->startexperiment();
ai.properties_sent = false;
}
}
}
else { // Agent network still not running
// TODO verify why this is empty -IC
}
break;
case AGENT_STARTUP:
psc_dbgmsg( PSC_SELECTIVE_DEBUG_LEVEL( ACECommunication ),
"PeriscopeFrontend::handle_step() AGENT_STARTUP\n" );
done = true;
for( it = child_agents_.begin(); it != child_agents_.end(); it++ ) {
if( it->second.status != AgentInfo::STARTED ) {
done = false;
}
}
if( done ) {
//psc_dbgmsg(1,"....Done.....\n\n");
if( !agent_hierarchy_started ) {
agent_hierarchy_started = true;
psc_dbgmsg( 1, "Agent network UP and RUNNING. Starting search.\n\n" );
psc_dbgmsg( 1, "Agent network started in %5.1f seconds\n", psc_wall_time() );
fe->set_startup_time( psc_wall_time() );
}
ACE_Reactor* reactor = ACE_Event_Handler::reactor();
reactor->cancel_timer( this );
stop();
}
else {
if( this->timed_out() ) {
psc_errmsg( "Timed out waiting for child agent(s)\n" );
quit();
}
}
break;
case APPLICATION_TERMINATION:
psc_dbgmsg( PSC_SELECTIVE_DEBUG_LEVEL( ACECommunication ),
"PeriscopeFrontend::handle_step() APPLICATION_TERMINATION\n" );
done = true;
for( it = child_agents_.begin(); it != child_agents_.end(); it++ ) {
if( !it->second.appl_terminated ) {
done = false;
}
}
if( done ) {
RegistryService* regsrv = fe->get_registry();
EntryData query;
std::list< EntryData > rresult;
query.app = fe->get_appname();
query.comp = "MRIMONITOR";
query.tag = "none";
if( !fe->get_fastmode() ) {
rresult.clear();
if( regsrv->query_entries( rresult, query, false ) == -1 ) {
psc_errmsg( "Error querying registry for application\n" );
exit( 1 );
}
if( rresult.size() > 0 ) {
psc_dbgmsg( FRONTEND_GENERAL_DEBUG_LEVEL,
"%d processes of application %s still registered\n",
rresult.size(), fe->get_appname() );
}
else {
//psc_dbgmsg(1,"....All application processes terminated.....\n\n");
ACE_Reactor* reactor = ACE_Event_Handler::reactor();
reactor->cancel_timer( this );
stop();
}
}
// force elimination from registry
// if( !startup_finished ) {
// std::list<EntryData>::iterator entryit;
//
// for( entryit = rresult.begin(); entryit != rresult.end(); entryit++) {
// regsrv->delete_entry( ( *entryit ).id );
// }
}
else {
if( this->timed_out() ) {
psc_errmsg( "Timed out waiting for child agent(s)\n" );
quit();
}
}
break;
case CHECK:
psc_dbgmsg( PSC_SELECTIVE_DEBUG_LEVEL( ACECommunication ),
"PeriscopeFrontend::handle_step() CHECK\n" );
this->check();
break;
case SHUTDOWN:
psc_dbgmsg( PSC_SELECTIVE_DEBUG_LEVEL( ACECommunication ),
"PeriscopeFrontend::handle_step() SHUTDOWN\n" );
psc_dbgmsg( 1, "PERISCOPE shutdown requested [%d], restart needed [%d]\n",
shutdown_allowed, need_restart );
ACE_Reactor* reactor = ACE_Event_Handler::reactor();
reactor->cancel_timer( this );
if( shutdown_allowed || !need_restart ) {
// shutdown the agent hierarchy
quit();
}
else {
// only exit the reactor event loop
stop();
}
break;
}
return 0;
}
void PeriscopeFrontend::graph() {
char command_string[ 200 ];
RegistryService* regsrv = fe->get_registry();
EntryData query;
std::list<EntryData> result;
std::list<EntryData>::iterator entryit;
query.app = appname();
if( regsrv->query_entries( result, query ) == -1 ) {
psc_errmsg( "Error querying registry for application\n" );
exit( 1 );
}
char buf[ 200 ];
char* tmp, * last, * t, * parent;
FILE* graph;
graph = fopen( "/tmp/test.dot", "w" );
fprintf( graph, "digraph test {\n" );
std::map<std::string, std::list<std::string> > children;
std::map<std::string, std::string> label;
for( entryit = result.begin(); entryit != result.end(); entryit++ ) {
sprintf( buf, "fe[%d]", regid_ );
if( ( entryit->tag ).find( buf ) == std::string::npos ) {
continue;
}
if( entryit->comp == "Periscope Frontend" ) {
sprintf( buf,
"Frontend\\n%s:%d", entryit->node.c_str(), entryit->port );
}
if( entryit->comp == "Periscope HL Agent" ) {
sprintf( buf,
"HL-Agent\\n%s:%d", entryit->node.c_str(), entryit->port );
}
if( entryit->comp == "Periscope Node-Agent" ) {
sprintf( buf,
"Node-Agent\\n%s:%d", entryit->node.c_str(), entryit->port );
}
if( entryit->comp == "Monlib" ) {
sprintf( buf, "Monlib\\n%s %s",
entryit->app.c_str(), entryit->node.c_str() );
}
label[ entryit->tag ] = buf;
strcpy( buf, entryit->tag.c_str() );
tmp = strtok( buf, ":" );
last = tmp;
while( tmp != 0 ) {
last = tmp;
tmp = strtok( 0, ":" );
}
t = buf;
if( buf != last ) {
while( t != ( last - 1 ) ) {
if( *t == '\0' ) {
*t = ':';
}
t++;
}
parent = buf;
}
else {
parent = 0;
}
if( parent ) {
children[ parent ].push_back( entryit->tag );
}
}
std::map<std::string, std::list<std::string> >::iterator it1;
std::list<std::string>::iterator it2;
std::map<std::string, std::string>::iterator it3;
for( it1 = children.begin(); it1 != children.end(); it1++ ) {
for( it2 = it1->second.begin(); it2 != it1->second.end(); it2++ ) {
fprintf( graph, " \"%s\" -> \"%s\" ;\n", ( *it1 ).first.c_str(),
( *it2 ).c_str() );
}
}
for( it3 = label.begin(); it3 != label.end(); it3++ ) {
if( ( *it3 ).second.find( "Frontend" ) != string::npos ) {
fprintf( graph,
" \"%s\" [shape=\"ellipse\" style=\"filled\" fillcolor=yellow label =\"%s\"]\n",
( *it3 ).first.c_str(), ( *it3 ).second.c_str() );
}
if( ( *it3 ).second.find( "Node-Agent" ) != string::npos ) {
fprintf( graph,
" \"%s\" [shape=\"rect\" style=\"filled\" fillcolor=grey label =\"%s\"]\n",
( *it3 ).first.c_str(), ( *it3 ).second.c_str() );
}
if( ( *it3 ).second.find( "HL-Agent" ) != string::npos ) {
fprintf( graph, " \"%s\" [shape=\"octagon\" label =\"%s\"]\n",
( *it3 ).first.c_str(), ( *it3 ).second.c_str() );
}
if( ( *it3 ).second.find( "Monlib" ) != string::npos ) {
fprintf( graph, " \"%s\" [shape=\"rect\" label =\"%s\"]\n",
( *it3 ).first.c_str(), ( *it3 ).second.c_str() );
}
}
fprintf( graph, "}\n" );
fclose( graph );
sprintf( command_string, "%s",
"dot /tmp/test.dot -Tpng > /tmp/test.png 2> /dev/null ;"
"qiv /tmp/test.png &" );
psc_dbgmsg( FRONTEND_MEDIUM_DEBUG_LEVEL, "Going to execute: '%s'\n", command_string );
int retVal = system( command_string );
}
void PeriscopeFrontend::prompt() {
// TODO verify what is the purpose of this operation and why it is empty -IC
}
void PeriscopeFrontend::help() {
fprintf( stdout, " Periscope commands:\n" );
fprintf( stdout, " help -- show this help\n" );
fprintf( stdout, " start -- start target application\n" );
fprintf( stdout, " quit -- quit Periscope\n" );
fprintf( stdout, " graph -- show the agent network graph\n" );
fprintf( stdout, " check -- check properties\n" );
fflush( stdout );
prompt();
}
void PeriscopeFrontend::push_StrategyRequestGeneralInfo2Queue( const std::string& strategy_name,
bool pedantic,
int analysis_duration,
int delay_phases,
int delay_seconds ) {
StrategyRequestGeneralInfo* strategyRequestGeneralInfo = new StrategyRequestGeneralInfo;
strategyRequestGeneralInfo->strategy_name = strategy_name;
strategyRequestGeneralInfo->pedantic = pedantic;
strategyRequestGeneralInfo->delay_phases = delay_phases;
strategyRequestGeneralInfo->delay_seconds = delay_seconds;
strategyRequestGeneralInfo->analysis_duration = analysis_duration;
push_StrategyRequestGeneralInfo2Queue( strategyRequestGeneralInfo );
}
void PeriscopeFrontend::print_StrategyRequestQueue() {
psc_dbgmsg( 1, "Requested strategy request:\n\n" );
for( std::list<StrategyRequest*>::iterator sr_it = strategy_request_queue.begin();
sr_it != strategy_request_queue.end(); sr_it++ ) {
StrategyRequestGeneralInfo* srgi;
srgi = ( *sr_it )->getGeneralInfo();
psc_dbgmsg( 1, "Strategy name: %s, analysis duration %d, analysis delay %d/%d\n (phases/seconds)",
srgi->strategy_name.c_str(), srgi->analysis_duration,
srgi->delay_phases, srgi->delay_seconds );
if( ( *sr_it )->getTypeOfConfiguration() == strategy_configuration_type( TUNE ) ) {
std::list<Scenario*>* sc_list;
sc_list = ( *sr_it )->getConfiguration().configuration_union.TuneScenario_list;
for( std::list<Scenario*>::iterator sc_it = sc_list->begin(); sc_it != sc_list->end(); sc_it++ ) {
( *sc_it )->print();
}
}
else if( ( *sr_it )->getTypeOfConfiguration() == strategy_configuration_type( PERSYST ) ) {
std::list<int>* propID_list;
propID_list = ( *sr_it )->getConfiguration().configuration_union.PersystPropertyID_list;
psc_dbgmsg( 1, "Initial candidate properties:\n" );
for( std::list<int>::iterator propID_it = propID_list->begin(); propID_it != propID_list->end(); propID_it++ ) {
psc_dbgmsg( 1, "\t - %d", ( *propID_it ) );
}
}
}
}
void PeriscopeFrontend::init_analysis_strategy_requests() {
StrategyRequestGeneralInfo* strategyRequestGeneralInfo = new StrategyRequestGeneralInfo;
std::string sname = opts.strategy;
if( sname.compare( "tune" ) ) {
std::list<int> empty_list;
int delay_phases = 0;
if( opts.has_delay ) {
delay_phases = atoi( opts.delay_string );
}
int duration = 1;
if( opts.has_duration ) {
duration = atoi( opts.duration_string );
}
strategyRequestGeneralInfo->strategy_name = opts.strategy;
strategyRequestGeneralInfo->pedantic = opts.has_pedantic;
strategyRequestGeneralInfo->delay_phases = delay_phases;
strategyRequestGeneralInfo->delay_seconds = 0;
strategyRequestGeneralInfo->analysis_duration = duration;
StrategyRequest* strategy_request = new StrategyRequest( &empty_list, strategyRequestGeneralInfo );
serializeStrategyRequests( strategy_request );
}
}
void PeriscopeFrontend::start() {
std::vector<char> serializedStrategyRequest;
std::map<std::string, AgentInfo>::iterator it;
psc_dbgmsg( PSC_SELECTIVE_DEBUG_LEVEL( ACECommunication ), "PeriscopeFrontend::start() called\n" );
serializedStrategyRequest = get_SerializedStrategyRequestBuffer();
//RM: Should be cleaned up here and moved into run handle for both analysis and tuning.
if( serializedStrategyRequest.size() == 0 ) {
psc_dbgmsg( 1, "Search finished.\n" );
fe->stop();
return;
}
psc_dbgmsg( PSC_AUTOTUNE_ALL_DEBUG, "Start with next strategy request: time: %5.1f seconds\n", psc_wall_time() );
psc_dbgmsg( FRONTEND_HIGH_DEBUG_LEVEL, "Sending START with strategy request buffer size %d...\n",
serializedStrategyRequest.size() );
for( it = child_agents_.begin(); it != child_agents_.end(); it++ ) {
AgentInfo& ag = it->second;
if( ag.status != AgentInfo::CONNECTED ) {
if( connect_to_child( &ag ) == -1 ) {
psc_errmsg( "Error connecting to child\n" );
abort();
}
else {
ag.handler->start( serializedStrategyRequest.size(), ( unsigned char* )&serializedStrategyRequest[ 0 ] );
}
ag.properties_sent = false;
}
}
strategyRequestBuffer.clear();
}
/**
* @brief Terminates the frontend and all agents.
*
* This method is executed just before the frontend terminates.
* It stops all child agents, stops the communication routines,
* and exports the found properties to a file.
*
*/
void PeriscopeFrontend::quit() {
std::map<std::string, AgentInfo>::iterator it;
psc_dbgmsg( 5, "Frontend on quit!\n" );
quit_fe = true;
//Do scalability analysis only at the final run and export only the scalability-based properties
if( opts.has_scalability_OMP && fe->get_ompnumthreads() == fe->get_ompfinalthreads() ) {
do_pre_analysis();
export_scalability_properties();
}
else if( opts.has_scalability_OMP ) {
;
}
else {
export_properties();
if( psc_get_debug_level() >= 1 ) {
properties();
}
}
for( it = child_agents_.begin(); it != child_agents_.end(); it++ ) {
AgentInfo& ag = it->second;
if( connect_to_child( &ag ) == -1 ) {
psc_errmsg( "Error connecting to child\n" );
abort();
}
else {
psc_dbgmsg( 5, "Sending QUIT command...\n" );
ag.handler->quit();
//psc_dbgmsg(1, "Sending QUIT command...OK\n");
}
}
if( !get_fastmode() ) {
RegistryService* regsrv = fe->get_registry();
EntryData query;
std::list< EntryData > rresult;
std::list< EntryData >::iterator entry;
bool shutdown_finished = false;
double start_time, current_time;
PSC_WTIME( start_time );
while( !shutdown_finished && ( current_time - start_time ) < 60.0 ) {
sleep( 1 );
query.app = fe->get_appname();
query.comp = "MRIMONITOR";
query.tag = "none";
rresult.clear();
if( regsrv->query_entries( rresult, query, false ) == -1 ) {
psc_errmsg( "Error querying registry for application\n" );
exit( 1 );
}
if( rresult.size() > 0 ) {
psc_dbgmsg( 1, "%d processes of %s still registered\n", rresult.size(), query.app.c_str() );
}
shutdown_finished = ( rresult.size() == 0 );
PSC_WTIME( current_time );
}
if( !shutdown_finished ) {
psc_errmsg( "Not all application processes terminated on time! Cleaning registry.\n" );
for( entry = rresult.begin(); entry != rresult.end(); entry++ ) {
regsrv->delete_entry( ( *entry ).id );
}
}
else {
psc_dbgmsg( 1, "All application processes terminated.\n" );
}
}
psc_dbgmsg( FRONTEND_HIGH_DEBUG_LEVEL, "Sending STOP command...\n" );
stop();
}
void PeriscopeFrontend::terminate_agent_hierarchy() {
std::map<std::string, AgentInfo>::iterator it;
for( it = child_agents_.begin(); it != child_agents_.end(); it++ ) {
AgentInfo& ag = it->second;
if( connect_to_child( &ag ) == -1 ) {
psc_errmsg( "Error connecting to child\n" );
abort();
}
else {
psc_dbgmsg( 5, "Sending QUIT command...\n" );
ag.handler->quit();
}
}
double start_time, current_time;
int status;
PSC_WTIME( start_time );
psc_dbgmsg( 2, "size of child agents: %d\n", child_agents_.size() );
child_agents_.erase( child_agents_.begin(), child_agents_.end() );
if( get_fastmode() ) { // check for starters that work in fast mode
// TODO need to terminate the application and agents in fast mode -IC
// need a way to verify that the agents and MPI application terminated, before continuing
// instead of waiting, we can simply use new ports and execute asynchronously
if( agent_pid > 0 ) { // in interactive runs, this variable holds the PID of the current forked AA -IC
psc_dbgmsg( PSC_SELECTIVE_DEBUG_LEVEL( HierarchySetup ), "This is an interactive run.\n" );
psc_dbgmsg( PSC_SELECTIVE_DEBUG_LEVEL( HierarchySetup ), "Waiting for id of the Agent: %d\n\n", agent_pid );
waitpid( agent_pid, &status, 0 );
}
else { // agents in a distributed memory run
psc_dbgmsg( PSC_SELECTIVE_DEBUG_LEVEL( HierarchySetup ), "Running on a distributed system.\n" );
psc_errmsg( "Waiting for agents on distributed systems not yet implemented. "
"Throwing an exception at PeriscopeFrontend::terminate_agent_hierarchy()" );
throw 0;
// TODO need to verify the termination of agents in distributed systems
}
}
else {
RegistryService* regsrv = fe->get_registry();
EntryData query;
std::list< EntryData > rresult;
std::list< EntryData >::iterator entry;
bool shutdown_finished = false;
while( !shutdown_finished && ( current_time - start_time ) < 60.0 ) {
query.app = fe->get_appname();
query.comp = "MRIMONITOR";
query.tag = "none";
rresult.clear();
if( regsrv->query_entries( rresult, query, false ) == -1 ) {
psc_errmsg( "Error querying registry for application\n" );
exit( 1 );
}
if( rresult.size() > 0 ) {
psc_dbgmsg( 1, "%d processes of %s still registered\n", rresult.size(), query.app.c_str() );
}
shutdown_finished = ( rresult.size() == 0 );
PSC_WTIME( current_time );
}
if( !shutdown_finished ) {
psc_errmsg( "Not all application processes terminated on time! Cleaning registry.\n" );
for( entry = rresult.begin(); entry != rresult.end(); entry++ ) {
regsrv->delete_entry( ( *entry ).id );
}
//exit(1);
}
else {
psc_dbgmsg( 1, "All application processes terminated.\n" );
}
}
// the frontend will hold the PID of the MPI application (more accurately, the mpiexec/launcher's PID)
// the reason is that we fork a child that becomes an mpiexec process; this process terminates with the parallel
// job, regardless of whether it is running locally or on a distributed system -IC
psc_dbgmsg( PSC_SELECTIVE_DEBUG_LEVEL( HierarchySetup ), "Waiting for id of the MPI application: %d\n\n", application_pid );
waitpid( application_pid, &status, 0 );
psc_dbgmsg( PSC_SELECTIVE_DEBUG_LEVEL( HierarchySetup ), "Termination of the application and agents done (fast mode).\n" );
psc_dbgmsg( FRONTEND_HIGH_DEBUG_LEVEL, "Sending STOP command...\n" );
psc_dbgmsg( 2, "stopping the agents...\n" );
stop();
fe->set_agent_hierarchy_started( false );
}
/**
* @brief Pre-analysis for scalability tests in OpenMP codes
*
* Does speedup analysis, scalability tests, and inserts the appropriate properties
*
*/
void PeriscopeFrontend::do_pre_analysis() {
//initializations
properties_.clear();
property.clear();
property_threads.clear();
p_threads.clear();
PhaseTime_user.clear();
std::list<PropertyInfo>::iterator prop_it;
//Get the properties information
//for( int i = 0; std::list<MetaProperty>::iterator it = metaproperties_.begin(); it != metaproperties_.end(); it++ ){
for( int i = 0; i < metaproperties_.size(); i++ ) {
get_prop_info( metaproperties_[ i ] );
}
//Copy list of properties starting from thread no. 2
copy_properties_for_analysis();
//This function finds the existing properties for all runs
find_existing_properties();
//Determine if the user_region scales or not / Meantime find the deviation time, execution time for user region
bool user_flag = false;
for( prop_it = properties_.begin(); prop_it != properties_.end(); ++prop_it ) {
long double seq_user_time = 0.0;
if( ( *prop_it ).maxThreads == 1 ) {
if( ( *prop_it ).region == "USER_REGION" ) {
string phase_user_Region = "USER_REGION";
seq_user_time = find_sequential_time( *prop_it );
do_speedup_analysis( *prop_it, seq_user_time, phase_user_Region );
user_flag = true;
}
else {
;
}
}
else if( ( *prop_it ).maxThreads > 1 ) {
break;
}
else {
;
}
}
//If there is no user_region, then depend on main region, so..
if( !user_flag ) {
for( prop_it = properties_.begin(); prop_it != properties_.end(); ++prop_it ) {
long double seq_main_time = 0.0;
if( ( *prop_it ).maxThreads == 1 ) {
if( ( *prop_it ).region == "MAIN_REGION" ) {
string phase_main_Region = "MAIN_REGION";
seq_main_time = find_sequential_time( *prop_it );
do_speedup_analysis( *prop_it, seq_main_time, phase_main_Region );
}
else {
;
}
}
else if( ( *prop_it ).maxThreads > 1 ) {
break;
}
else {
;
}
}
}
//Find speedup for OpenMP regions
std::list<long double> RFL_history;
RFL_history.clear();
for( prop_it = properties_.begin(); prop_it != properties_.end(); ++prop_it ) {
long double seq_time = 0.0;
bool RFL_check = false;
RFL_history.push_back( ( *prop_it ).RFL );
if( ( *prop_it ).maxThreads == 1 ) {
if( ( int )count( RFL_history.begin(), RFL_history.end(), ( *prop_it ).RFL ) > 1 ) {
RFL_check = true;
}
if( ( ( *prop_it ).region == "PARALLEL_REGION" || ( *prop_it ).region == "WORKSHARE_DO" ||
( *prop_it ).region == "DO_REGION" || ( *prop_it ).region == "CALL_REGION"
|| ( *prop_it ).region == "SUB_REGION" ) && !RFL_check ) {
string phaseRegion = ( *prop_it ).region;
seq_time = find_sequential_time( *prop_it );
do_speedup_analysis( *prop_it, seq_time, phaseRegion );
}
else {
;
}
}
else if( ( *prop_it ).maxThreads > 1 ) {
break;
}
else {
;
}
}
//This function calculates the total deviation among the regions;
//it finds the maximum among them; it shows the region with its severity value.
for( int i = 1; i <= fe->get_ompfinalthreads(); i += i ) {
Check_severity_among_parallel_regions( i );
}
}
/**
* @brief Export scalability based found properties to a file
*
* Exports scalability based found properties to a file in XML format.
*
*/
void PeriscopeFrontend::export_scalability_properties() {
//initialization
std::list<PropertyInfo>::iterator prop_it, prop_itr, s_it, e_it, sc_it, sp_it, d_it, p_it;
double threshold_for_foundproperties = 0.0; //threshold above which the properties are displayed
std::string propfilename = fe->get_outfilename();
std::ofstream xmlfile( propfilename.c_str() );
if( ( !xmlfile ) && opts.has_propfile ) {
std::cout << "Cannot open xmlfile. \n";
exit( 1 );
}
if( xmlfile && fe->get_ompnumthreads() == fe->get_ompfinalthreads() ) {
psc_infomsg( "Exporting results to %s\n", propfilename.c_str() );
time_t rawtime;
tm* timeinfo;
time( &rawtime );
timeinfo = localtime( &rawtime );
xmlfile << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>" << std::endl;
xmlfile << "<Experiment xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" "
"xmlns=\"http://www.lrr.in.tum.de/Periscope\" "
"xsi:schemaLocation=\"http://www.lrr.in.tum.de/Periscope psc_properties.xsd \">"
<< std::endl << std::endl;
xmlfile << std::setfill( '0' );
xmlfile << " <date>" << std::setw( 4 ) << ( timeinfo->tm_year + 1900 )
<< "-" << std::setw( 2 ) << timeinfo->tm_mon + 1 << "-" << std::setw( 2 )
<< timeinfo->tm_mday << "</date>" << std::endl;
xmlfile << " <time>" << std::setw( 2 ) << timeinfo->tm_hour << ":"
<< std::setw( 2 ) << timeinfo->tm_min << ":" << std::setw( 2 )
<< timeinfo->tm_sec << "</time>" << std::endl;
// Wording directory for the experiment: can be used to find the data file(s)
char* cwd = getenv( "PWD" );
xmlfile << " <dir>" << cwd << "</dir>" << std::endl;
// Source revision
if( opts.has_srcrev ) {
// Source revision
xmlfile << " <rev>" << opts.srcrev << "</rev>" << std::endl;
}
// Empty line before the properties
xmlfile << std::endl;
/*
//The following lines should be removed sss
std::list<std::string>::iterator it;
//sss here we have to process the required properties.
for( it = xmlproperties_.begin(); it != xmlproperties_.end(); it++ ){
xmlfile << *it;
}
*/
}
if( xmlfile && fe->get_ompnumthreads() == fe->get_ompfinalthreads() ) {
// std::cout << std::endl;
//Export all properties other than exectime::::: properties to .psc file
for( p_it = properties_.begin(); p_it != properties_.end(); ++p_it ) {
string::size_type p_loc = ( ( *p_it ).name ).find( ":::::", 0 );
if( false && p_loc != string::npos ) {
;
}
else {
if( ( *p_it ).severity > threshold_for_foundproperties ) {
xmlfile << "<property cluster=\"" << ( *p_it ).cluster
<< "\" ID=\"" << ( *p_it ).ID << "\" >\n "
<< "\t<name>" << ( *p_it ).name << "</name>\n "
<< "\t<context FileID=\"" << ( *p_it ).fileid
<< "\" FileName=\"" << ( *p_it ).filename
<< "\" RFL=\"" << ( *p_it ).RFL << "\" Config=\""
<< ( *p_it ).maxProcs << "x" << ( *p_it ).maxThreads
<< "\" Region=\"" << ( *p_it ).region
<< "\" RegionId=\"" << ( *p_it ).RegionId
<< "\">\n " << "\t\t<execObj process=\""
<< ( *p_it ).process << "\" thread=\""
<< ( *p_it ).numthreads << "\"/>\n "
<< "\t</context>\n \t<severity>"
<< double( ( *p_it ).severity ) << "</severity>\n "
<< "\t<confidence>" << double( ( *p_it ).confidence )
<< "</confidence>\n \t<addInfo>\n " << "\t\t";
xmlfile << ( *p_it ).addInfo;
string::size_type p_loc = ( ( *p_it ).name ).find( ":::::", 0 );
if( p_loc != string::npos ) {
xmlfile << "\t<exectime>" << ( p_it->execTime / NANOSEC_PER_SEC_DOUBLE ) << "s </exectime> ";
}
xmlfile << "\n\t</addInfo>\n </property>\n";
}
}
}
// std::cout << std::endl;
//Export speedup based newly developed property to properties.psc file
for( sp_it = speedup_based_properties.begin(); sp_it != speedup_based_properties.end(); ++sp_it ) {
// std::cout << " speedup_based_properties " << " size = "
// << speedup_based_properties.size() << " config= "
// << ( *sp_it ).maxThreads << " RFL = " << ( *sp_it ).RFL
// << " " << ( *sp_it ).filename << " region = "
// << ( *sp_it ).region << " process = "
// << ( *sp_it ).process << " severity = "
// << double( ( *sp_it ).severity ) << " cluster = "
// << ( *sp_it ).cluster << " ID = " << ( *sp_it ).ID << " "
// << ( *sp_it ).name << " fileid = " << ( *sp_it ).fileid
// << std::endl;
if( ( *sp_it ).severity > threshold_for_foundproperties ) {
xmlfile << "<property cluster=\"" << ( *sp_it ).cluster
<< "\" ID=\""<< ( *sp_it ).ID << "\" >\n "
<< "\t<name>" << ( *sp_it ).name << "</name>\n "
<< "\t<context FileID=\"" << ( *sp_it ).fileid
<< "\" FileName=\"" << ( *sp_it ).filename
<< "\" RFL=\"" << ( *sp_it ).RFL << "\" Config=\""
<< ( *sp_it ).maxProcs << "x" << ( *sp_it ).maxThreads
<< "\" Region=\"" << ( *sp_it ).region
<< "\" RegionId=\"" << ( *sp_it ).RegionId << "\">\n "
<< "\t\t<execObj process=\"" << ( *sp_it ).process
<< "\" thread=\"" << ( *sp_it ).numthreads << "\"/>\n "
<< "\t</context>\n \t<severity>"
<< double( ( *sp_it ).severity ) << "</severity>\n "
<< "\t<confidence>" << double( ( *sp_it ).confidence )
<< "</confidence>\n \t<addInfo>\n " << "\t\t";
if( ( *sp_it ).addInfo == "" ) {
;
}
else {
xmlfile << ( *sp_it ).addInfo;
}
xmlfile << "\n\t</addInfo>\n </property>\n";
}
else {
;
}
}
// std::cout << std::endl;
//Export PropertyInfo from existing property list to properties.psc file
//Different approach for printing properties
for( prop_it = existing_properties.begin(); prop_it != existing_properties.end(); ++prop_it ) {
string::size_type e_loc = ( ( *prop_it ).name ).find( ":::::", 0 );
if( e_loc != string::npos ) {
;
}
else {
// std::cout << " existing_properties " << " size = "
// << existing_properties.size() << " exec = "
// << ( *prop_it ).execTime << " config= "
// << ( *prop_it ).maxThreads << " RFL = "
// << ( *prop_it ).RFL << " " << ( *prop_it ).filename
// << " region = " << ( *prop_it ).region
// << " process = " << ( *prop_it ).process
// << " severity = " << double( ( *prop_it ).severity )
// << " cluster = " << ( *prop_it ).cluster << " ID = "
// << ( *prop_it ).ID << " " << ( *prop_it ).name
// << " fileid = " << ( *prop_it ).fileid << std::endl;
string addinfo_name = ( *prop_it ).name; //get the property name which stays for all the configurations here
int id = Property_occurring_in_all_configurations_id();
string id_s = convertInt( id );
if( ( *prop_it ).severity > threshold_for_foundproperties ) {
xmlfile << "<property cluster=\"" << ( *prop_it ).cluster << "\" ID=\"" << id_s << "\" >\n "
<< "\t<name>" << " SCA -- Property occurring in all configurations " << "</name>\n "
<< "\t<context FileID=\"" << ( *prop_it ).fileid << "\" FileName=\"" << ( *prop_it ).filename
<< "\" RFL=\"" << ( *prop_it ).RFL << "\" Config=\"" << ( *prop_it ).maxProcs << "x" << ( *prop_it ).maxThreads
<< "\" Region=\"" << ( *prop_it ).region << "\" RegionId=\"" << ( *prop_it ).RegionId << "\">\n "
<< "\t\t<execObj process=\"" << ( *prop_it ).process << "\" thread=\"" << ( *prop_it ).numthreads
<< "\"/>\n " << "\t</context>\n \t<severity>" << double( ( *prop_it ).severity ) << "</severity>\n "
<< "\t<confidence>" << double( ( *prop_it ).confidence ) << "</confidence>\n \t<addInfo>\n "
<< "\t\t";
if( addinfo_name == "" ) {
;
}
else {
xmlfile << "<Property_Name>" << addinfo_name << "</Property_Name>";
}
xmlfile << "\n\t</addInfo>\n </property>\n";
}
else {
;
}
}
}
// std::cout << std::endl;
//Export severity based newly developed property to properties.psc file
for( s_it = severity_based_properties.begin(); s_it != severity_based_properties.end(); ++s_it ) {
// std::cout << " severity_based_properties " << " size = "
// << severity_based_properties.size() << " exec = "
// << ( *s_it ).execTime << " config= "
// << ( *s_it ).maxThreads << " RFL = " << ( *s_it ).RFL
// << " " << ( *s_it ).filename << " region = "
// << ( *s_it ).region << " process = "
// << ( *s_it ).process << " severity = "
// << double( ( *s_it ).severity ) << " cluster = "
// << ( *s_it ).cluster << " ID = " << ( *s_it ).ID << " "
// << ( *s_it ).name << " fileid = " << ( *s_it ).fileid
// << std::endl;
if( ( *s_it ).severity > threshold_for_foundproperties ) {
xmlfile << "<property cluster=\"" << ( *s_it ).cluster << "\" ID=\"" << ( *s_it ).ID << "\" >\n "
<< "\t<name>" << ( *s_it ).name << "</name>\n "
<< "\t<context FileID=\"" << ( *s_it ).fileid << "\" FileName=\"" << ( *s_it ).filename
<< "\" RFL=\"" << ( *s_it ).RFL << "\" Config=\"" << ( *s_it ).maxProcs << "x" << ( *s_it ).maxThreads
<< "\" Region=\"" << ( *s_it ).region << "\" RegionId=\"" << ( *s_it ).RegionId << "\">\n "
<< "\t\t<execObj process=\"" << ( *s_it ).process << "\" thread=\"" << ( *s_it ).numthreads
<< "\"/>\n " << "\t</context>\n \t<severity>" << double( ( *s_it ).severity ) << "</severity>\n "
<< "\t<confidence>" << double( ( *s_it ).confidence ) << "</confidence>\n \t<addInfo>\n "
<< "\t\t";
if( ( *s_it ).addInfo == "" ) {
;
}
else {
xmlfile << ( *s_it ).addInfo;
}
xmlfile << "\n\t</addInfo>\n </property>\n";
}
else {
;
}
}
// std::cout << std::endl;
for( d_it = DeviationProperties.begin(); d_it != DeviationProperties.end(); ++d_it ) {
// std::cout << " DeviationProperties " << " size = "
// << DeviationProperties.size() << " config= "
// << ( *d_it ).maxThreads << " RFL = "
// << ( *d_it ).RFL << " " << ( *d_it ).filename
// << " region = " << ( *d_it ).region
// << " process = " << ( *d_it ).process << " severity = "
// << double( ( *d_it ).severity ) << " cluster = "
// << ( *d_it ).cluster << " ID = " << ( *d_it ).ID << " "
// << ( *d_it ).name << " fileid = " << ( *d_it ).fileid
// << std::endl;
if( ( *d_it ).severity > threshold_for_foundproperties ) {
xmlfile << "<property cluster=\"" << ( *d_it ).cluster << "\" ID=\"" << ( *d_it ).ID << "\" >\n "
<< "\t<name>" << ( *d_it ).name << "</name>\n "
<< "\t<context FileID=\"" << ( *d_it ).fileid << "\" FileName=\"" << ( *d_it ).filename
<< "\" RFL=\"" << ( *d_it ).RFL << "\" Config=\"" << ( *d_it ).maxProcs << "x" << ( *d_it ).maxThreads
<< "\" Region=\"" << ( *d_it ).region << "\" RegionId=\"" << ( *d_it ).RegionId << "\">\n "
<< "\t\t<execObj process=\"" << ( *d_it ).process << "\" thread=\"" << ( *d_it ).numthreads
<< "\"/>\n " << "\t</context>\n \t<severity>" << double( ( *d_it ).severity ) << "</severity>\n "
<< "\t<confidence>" << double( ( *d_it ).confidence ) << "</confidence>\n \t<addInfo>\n "
<< "\t\t";
if( ( *d_it ).addInfo == "" ) {
;
}
else {
xmlfile << ( *d_it ).addInfo;
}
xmlfile << "\n\t</addInfo>\n </property>\n";
}
else {
;
}
}
xmlfile << "</Experiment>" << std::endl;
}
xmlfile.close();
}
//This function calculates the total deviation among the regions;
//it finds the maximum among them; it shows the region with its severity value.
void PeriscopeFrontend::Check_severity_among_parallel_regions( int config ) {
std::list<PropertyInfo>::iterator prop_it, ex_it, p_it;
std::list<PropertyInfo> prop_threadbased;
std::list<long double> RFL_history;
long double total_deviation_time = 0.0;
long double phaseTime = 0.0;
long double parallelTime = 0.0;
bool severity_check = false;
string userregion_filename;
int userregion_fileid;
string userregion_cluster;
string userregion_ID;
string userregion_context;
string userregion_region;
string userregion_RegionId;
double userregion_RFL = 0.0;
int userregion_maxThreads = 0;
int userregion_maxProcs = 0;
int userregion_numthreads = 0;
int userregion_process = 0;
double userregion_confidence = 0.0;
prop_threadbased.clear();
RFL_history.clear();
//Finds the right config based properties and add them in a list;
//calculates the sequential time for parallel regions in the program
for( p_it = properties_.begin(); p_it != properties_.end(); ++p_it ) {
//it should be restricted to only
if( ( *p_it ).maxThreads == config ) {
prop_threadbased.push_back( *p_it );
}
else {
;
}
if( ( ( *p_it ).maxThreads == 1 ) && ( ( *p_it ).region == "PARALLEL_REGION" ||
( *p_it ).region == "DO_REGION" ||
( *p_it ).region == "WORKSHARE_REGION" ) ) {
parallelTime += ( *p_it ).execTime;
}
else {
;
}
}
int config_thread_count = prop_threadbased.size();
//Finds the total deviation time among all the regions
for( ex_it = ExecAndDeviaProperties.begin(); ex_it != ExecAndDeviaProperties.end(); ++ex_it ) {
//convert config to equivalent array.
int config_equiv = 0;
int count = 0;
for( int i = 1; i <= fe->get_ompfinalthreads(); i += i ) {
if( i == config ) {
config_equiv = count;
}
count++;
}
//Get the phasetime for this configuration
if( ( *ex_it ).region == "USER_REGION" ) {
phaseTime = ( *ex_it ).exec_regions[ config_equiv ];
userregion_filename = ( *ex_it ).filename;
userregion_region = ( *ex_it ).region;
userregion_fileid = ( *ex_it ).fileid;
userregion_cluster = ( *ex_it ).cluster;
userregion_RFL = ( *ex_it ).RFL;
userregion_ID = ( *ex_it ).ID;
userregion_context = ( *ex_it ).context;
userregion_maxThreads = ( *ex_it ).maxThreads;
userregion_maxProcs = ( *ex_it ).maxProcs;
userregion_numthreads = ( *ex_it ).numthreads;
userregion_process = ( *ex_it ).process;
userregion_confidence = ( *ex_it ).confidence;
userregion_RegionId = ( *ex_it ).RegionId;
}
else if( ( *ex_it ).region == "MAIN_REGION" ) {
phaseTime = ( *ex_it ).exec_regions[ config_equiv ];
userregion_region = ( *ex_it ).region;
userregion_filename = ( *ex_it ).filename;
userregion_fileid = ( *ex_it ).fileid;
userregion_cluster = ( *ex_it ).cluster;
userregion_RFL = ( *ex_it ).RFL;
userregion_ID = ( *ex_it ).ID;
userregion_context = ( *ex_it ).context;
userregion_maxThreads = ( *ex_it ).maxThreads;
userregion_maxProcs = ( *ex_it ).maxProcs;
userregion_numthreads = ( *ex_it ).numthreads;
userregion_process = ( *ex_it ).process;
userregion_confidence = ( *ex_it ).confidence;
userregion_RegionId = ( *ex_it ).RegionId;
}
else {
;
}
total_deviation_time += ( *ex_it ).devia_regions[ config_equiv ];
}
long double max_deviation_time = 0.0;
PropertyInfo max_info;
for( prop_it = prop_threadbased.begin(); prop_it != prop_threadbased.end(); ++prop_it ) {
//First find for main_region / user_region
config_thread_count--;
bool RFL_check = false;
//Ensure that the RFL is unique
RFL_history.push_back( ( *prop_it ).RFL );
if( ( int )count( RFL_history.begin(), RFL_history.end(), ( *prop_it ).RFL ) > 1 ) {
RFL_check = true;
}
//if((*prop_it).region == "USER_REGION" || (*prop_it).region == "MAIN_REGION" ||
if( ( ( *prop_it ).region == "PARALLEL_REGION" ||
( *prop_it ).region == "WORKSHARE_DO" ||
( *prop_it ).region == "DO_REGION" ||
( *prop_it ).region == "CALL_REGION" ||
( *prop_it ).region == "SUB_REGION" ) && !RFL_check ) {
//check if it matches with devia_properties
string temp_region = ( *prop_it ).region;
double temp_process = ( *prop_it ).process;
int temp_maxThreads = ( *prop_it ).maxThreads;
double temp_RFL = ( *prop_it ).RFL;
int temp_fileid = ( *prop_it ).fileid;
for( ex_it = ExecAndDeviaProperties.begin(); ex_it != ExecAndDeviaProperties.end(); ++ex_it ) {
if( temp_process == ( *ex_it ).process && temp_RFL == ( *ex_it ).RFL
&& ( *ex_it ).fileid == temp_fileid && ( *ex_it ).region == temp_region ) {
//here we have to find the maximal deviation based region
int count = 0;
int config_equiv = 0;
long double devia_time_region = 0.0;
for( int i = 1; i <= fe->get_ompfinalthreads(); i += i ) {
if( i == config ) {
config_equiv = count;
}
count++;
}
devia_time_region = ( *ex_it ).devia_regions[ config_equiv ];
if( devia_time_region > max_deviation_time ) {
max_deviation_time = devia_time_region;
//store the maximal region and its context
max_info.filename = ( *prop_it ).filename;
max_info.context = ( *prop_it ).context;
max_info.region = ( *prop_it ).region;
max_info.cluster = ( *prop_it ).cluster;
int id = Code_region_with_the_lowest_speedup_in_the_run_id();
max_info.ID = convertInt( id );
max_info.fileid = ( *prop_it ).fileid;
max_info.RFL = ( *prop_it ).RFL;
max_info.confidence = ( double )( *prop_it ).confidence;
max_info.maxThreads = config; //config val
max_info.process = ( *prop_it ).process;
max_info.numthreads = ( *prop_it ).numthreads;
max_info.maxProcs = ( *prop_it ).maxProcs;
max_info.RegionId = ( *prop_it ).RegionId;
//here include the property saying that the region had maximal deviation with
//the severity calculated
double severity = 0.0;
double condition = 0.0;
if( config == 1 ) {
max_info.severity = 0.0; //because the deviation is always zero for config 1
}
else {
condition = ( devia_time_region / total_deviation_time ) * 100;
severity = ( devia_time_region / phaseTime ) * 100;
max_info.severity = severity;
}
max_info.name = " SCA -- Code region with the lowest speedup in the run ";
if( condition > 5 ) {
severity_check = true;
}
else {
severity_check = false;
}
}
else {
;
}
break;
}
else {
;
}
}
}
else {
; //for region checks
}
//We need to add in the list which has the maximal deviation
if( severity_check && config_thread_count == 0 ) { //ensure that we are in the final region check process
DeviationProperties.push_back( max_info );
}
}
//Add another property for finding the percentage of the parallelized code
if( config == 1 ) {
PropertyInfo s_info;
s_info.filename = userregion_filename;
s_info.context = userregion_context;
s_info.region = userregion_region;
s_info.cluster = userregion_cluster;
// char buf[ 5 ];
// itoa( Sequential_Computation_id(), buf, 10 );
int id = Sequential_Computation_id();
s_info.ID = convertInt( id );
// std::cout << " SEQUENTIALCOMPUTATION " << id << " s_info " << s_info.ID << std::endl;
s_info.fileid = userregion_fileid;
s_info.RFL = userregion_RFL;
s_info.confidence = userregion_confidence;
s_info.process = userregion_process;
s_info.numthreads = userregion_numthreads;
s_info.maxThreads = userregion_maxThreads;
s_info.maxProcs = userregion_maxProcs;
s_info.severity = ( ( phaseTime - parallelTime ) / phaseTime ) * 100;
s_info.RegionId = userregion_RegionId;
s_info.name = " SCA -- Sequential Computation ";
DeviationProperties.push_back( s_info );
}
else {
;
}
}
//This function find the sequential time for the forwarded existing property
long double PeriscopeFrontend::find_sequential_time( PropertyInfo prop_info ) {
std::list<PropertyInfo>::iterator seq_it;
string region_t = prop_info.region;
string ID_t = prop_info.ID;
string name_t = prop_info.name;
double process_t = prop_info.process;
double RFL_t = prop_info.RFL;
int fileid_t = prop_info.fileid;
//Check all the properties and if it identifies the same property, return its execution time.
for( seq_it = properties_.begin(); seq_it != properties_.end(); ++seq_it ) {
if( region_t == ( *seq_it ).region && process_t == ( *seq_it ).process
&& RFL_t == ( *seq_it ).RFL && fileid_t == ( *seq_it ).fileid
&& ID_t == ( *seq_it ).ID && name_t == ( *seq_it ).name ) {
return ( *seq_it ).execTime;
}
else {
;
}
}
return 0.0;
}
//This function copies properties from thread 2
void PeriscopeFrontend::copy_properties_for_analysis() {
std::list<PropertyInfo>::iterator copy_it;
//Check all the properties and add in the list if the threads are above 2
//Required because the OpenMP properties show up only after thread no. 2
for( copy_it = properties_.begin(); copy_it != properties_.end(); ++copy_it ) {
if( ( *copy_it ).maxThreads > 1 ) {
property_threads.push_back( *copy_it );
p_threads.push_back( *copy_it );
}
else {
;
}
}
}
//This function identifies the existing_properties among threads
void PeriscopeFrontend::find_existing_properties() {
std::list<PropertyInfo>::iterator prop_it, prop_itr;
existing_properties.clear();
int initial_thread = 2;
std::cout << std::endl;
long int count = 0;
for( prop_it = property_threads.begin(); prop_it != property_threads.end(); ++prop_it ) {
//surf within property infos...
//fixing on one propertyInfo, check if we have to include in the list of properties or not.
count++;
if( ( *prop_it ).maxThreads == initial_thread ) {
string temp_region = ( *prop_it ).region;
string temp_name = ( *prop_it ).name;
double temp_severity = double( ( *prop_it ).severity );
double temp_process = ( *prop_it ).process;
int temp_maxThreads = ( *prop_it ).maxThreads;
double temp_RFL = ( *prop_it ).RFL;
int temp_fileid = ( *prop_it ).fileid;
long int count_scaled = 0;
for( int th_number = initial_thread; th_number <= fe->get_ompfinalthreads(); th_number += th_number ) {
long int count_in = 0;
for( prop_itr = p_threads.begin(); prop_itr != p_threads.end(); ++prop_itr ) {
//after storing details, go through all the properties from the point of comparison to compare
//and determine whether that property should be in the list of scalable properties
count_in++; //
if( temp_name == ( *prop_itr ).name && temp_process == ( *prop_itr ).process
&& temp_RFL == ( *prop_itr ).RFL && count_in >= count && temp_fileid == ( *prop_itr ).fileid &&
( *prop_itr ).maxThreads == th_number && ( *prop_itr ).maxThreads != 1 ) {
//For existing_properties checks process here
count_scaled++;
if( ( count_scaled + 1 ) >= fe->get_maxiterations() ) {
string::size_type loc = ( ( *prop_it ).name ).find( ":::::", 0 );
if( loc != string::npos ) {
;
}
else {
existing_properties.push_back( *prop_it );
}
}
break; //need not check for other properties in that thread number
}
else {
;
}
}
}
}
else {
break;
} //not from initial thread
}
}
////Function that converts integer to string
//std::string PeriscopeFrontend::convertInt( int number )
//{
// if( number == 0 ) {
// return "0";
// }
// string temp = "";
// string returnvalue = "";
// while(number > 0) {
// temp += number % 10 + 48;
// number /= 10;
// }
// for( int i = 0; i < temp.length(); i++ ) {
// returnvalue += temp[ temp.length() - i - 1 ];
// }
// return returnvalue;
//}
//Function that converts integer to string
std::string PeriscopeFrontend::convertInt( int number ) {
stringstream ss; //create a stringstream
ss << number; //add number to the stream
return ss.str(); //return a string with the contents of the stream
}
//This function does speedup analysis for every parallel regions
void PeriscopeFrontend::do_speedup_analysis( PropertyInfo prop,
long double seq_time,
const std::string& phase_region ) {
std::list<PropertyInfo>::iterator prop_itr;
std::list<long double>::iterator rt_it;
std::list<long double> temp_PhaseTime;
temp_PhaseTime.clear();
string temp_region = prop.region;
string temp_name = prop.name;
double temp_severity = double( prop.severity );
double temp_process = prop.process;
int temp_maxThreads = prop.maxThreads;
double temp_RFL = prop.RFL;
double severity_for_initialthread = 0.0;
long double PhaseTime = 0.0;
int temp_fileid = prop.fileid;
string temp_ID = prop.ID;
int count_scaled = 0;
int count_execTime = 0;
int count_speedup = 0;
int count_severity = 0;
bool stop_speedup_check = false;
bool stop_tspeedup_check = false;
bool stop_severity_check = false;
bool need_not_list = false;
double t_execTime = 0.0;
double t_severity = 0.0;
int initial_thread = 2;
long double initial_execTime = seq_time;
double speedup_prop = 0.0;
double t_speedup = 0.0;
std::string string_name = " ";
//First initialization
int Max = 10000;
long double* execTime_regions = new long double[ Max ];
long double* deviationTime = new long double[ Max ];
execTime_regions[ 1 ] = initial_execTime;
deviationTime[ 1 ] = 0.0;
if( phase_region == "MAIN_REGION" || phase_region == "USER_REGION" ) {
PhaseTime_user.push_back( initial_execTime );
}
//make a temp list of phaseTime and remove the first one
else if( ( phase_region != "MAIN_REGION" || phase_region != "USER_REGION" )
&& PhaseTime_user.size() > 0 ) {
temp_PhaseTime.assign( PhaseTime_user.begin(), PhaseTime_user.end() );
temp_PhaseTime.pop_front();
}
else {
;
}
for( int th_number = initial_thread; th_number <= fe->get_ompfinalthreads(); th_number += th_number ) {
execTime_regions[ th_number ] = 0.0;
deviationTime[ th_number ] = 0.0;
//For each thread number, we have to calculate the phaseTime
PhaseTime = 0.0;
if( temp_PhaseTime.size() > 0 && PhaseTime_user.size() > 0 ) {
PhaseTime = temp_PhaseTime.front();
temp_PhaseTime.pop_front();
}
else {
;
}
for( prop_itr = property_threads.begin(); prop_itr != property_threads.end(); ++prop_itr ) {
need_not_list = false;
if( temp_process == ( *prop_itr ).process && temp_fileid == ( *prop_itr ).fileid
&& temp_RFL == ( *prop_itr ).RFL && ( *prop_itr ).maxThreads == th_number
&& ( *prop_itr ).maxThreads != 1 && temp_name == ( *prop_itr ).name
&& ( *prop_itr ).ID == temp_ID ) {
//We don't need to add the property relating to execTime
string p_name = ( *prop_itr ).name;
string::size_type loc = p_name.find( ":::::", 0 );
if( loc != string::npos ) {
need_not_list = true;
}
else {
;
}
//we need to get the severity for initial run
if( th_number == initial_thread ) {
severity_for_initialthread = ( *prop_itr ).severity;
}
else {
;
}
count_scaled++;
//the following property should be checked again
//here we have to check if the severity is increasing or not.
if( ( *prop_itr ).severity >= t_severity && stop_severity_check == false ) {
count_severity++;
if( ( count_severity + 1 ) >= fe->get_maxiterations() ) {
//if the severity has continuously increased
PropertyInfo s_info;
s_info.name = " SCA -- Property with increasing severity across configurations ";
s_info.filename = prop.filename;
s_info.context = prop.context;
s_info.region = prop.region;
s_info.cluster = prop.cluster;
int id = Property_with_increasing_severity_across_configurations_id();
s_info.ID = convertInt( id );
s_info.fileid = prop.fileid;
s_info.numthreads = prop.numthreads;
s_info.maxProcs = prop.maxProcs;
s_info.RegionId = prop.RegionId;
//make a definition here
//severity is defined based on how much it increased for this particular property for various threads
s_info.severity = ( prop.severity - severity_for_initialthread );
s_info.RFL = prop.RFL;
s_info.confidence = ( double )prop.confidence;
s_info.maxThreads = th_number; //the property increased till this thread number
string_name = "<prop_name>";
string string_name_end = "</prop_name>";
s_info.addInfo = string_name + prop.name + string_name_end;
s_info.process = prop.process;
if( !need_not_list ) {
severity_based_properties.push_back( s_info );
}
else {
;
}
}
t_severity = ( *prop_itr ).severity;
}
else {
;
}
//Speedup property requirements
speedup_prop = ( long double )initial_execTime / ( double )( *prop_itr ).execTime;
int rounded_speedup = speedup_prop;
double decimal_val = ( double )speedup_prop - rounded_speedup;
if( decimal_val > 0.5 ) {
rounded_speedup++;
}
else {
;
}
//Store the execution time & deviation time for regions
execTime_regions[ th_number ] = ( *prop_itr ).execTime;
if( phase_region == "MAIN_REGION" || phase_region == "USER_REGION" ) {
PhaseTime_user.push_back( ( *prop_itr ).execTime );
}
else {
;
}
if( ( ( *prop_itr ).execTime ) - ( initial_execTime / th_number ) > 0 ) {
deviationTime[ th_number ] = ( ( *prop_itr ).execTime ) - ( initial_execTime / th_number );
}
else {
deviationTime[ th_number ] = 0.0;
}
//Converting double to string
std::ostringstream sstream;
sstream << speedup_prop;
std::string speedup_str = sstream.str();
speedup_str += "";
string speedup_start = "<speedup>";
string speedup_end = "</speedup>";
//Check if this satisfies the linear speedup/superlinear speedup condition (RARELY OCCURS)
if( rounded_speedup == th_number ||
rounded_speedup > th_number &&
stop_speedup_check == false ) {
count_speedup++;
PropertyInfo s_info;
s_info.filename = prop.filename;
s_info.context = prop.context;
s_info.region = prop.region;
s_info.cluster = prop.cluster;
s_info.fileid = prop.fileid;
s_info.severity = 0.0; //severity should be 0.0
s_info.RFL = prop.RFL;
s_info.confidence = ( double )prop.confidence;
s_info.maxThreads = th_number;
s_info.addInfo = speedup_start + speedup_str + speedup_end;
s_info.process = prop.process;
s_info.numthreads = prop.numthreads;
s_info.maxProcs = prop.maxProcs;
s_info.RegionId = prop.RegionId;
if( rounded_speedup > th_number ) {
s_info.name = " SCA -- SuperLinear Speedup for all configurations ";
int id = SuperLinear_Speedup_for_all_configurations_id();
s_info.ID = convertInt( id );
speedup_based_properties.push_back( s_info );
}
else {
;
}
if( ( count_speedup + 1 ) >= fe->get_maxiterations() ) {
//now we shall include a new property saying that the speedup satisfied for all threads
// in the particular RFL
s_info.name = " SCA -- Linear Speedup for all configurations ";
int id = Linear_Speedup_for_all_configurations_id();
s_info.ID = convertInt( id );
speedup_based_properties.push_back( s_info );
}
}
else if( !stop_speedup_check ) {
//speedup fails in linear speedup condition once from the previous runs
stop_speedup_check = true;
//now we shall include a new property saying that the speedup is not satisfied due to these properties
// in the particular RFL
PropertyInfo s_info;
s_info.name = " SCA -- Linear speedup failed for the first time ";
s_info.filename = prop.filename;
s_info.context = prop.context;
s_info.region = prop.region;
s_info.cluster = prop.cluster;
int id = Linear_speedup_failed_for_the_first_time_id();
s_info.ID = convertInt( id );
s_info.fileid = prop.fileid;
if( s_info.region == "MAIN_REGION" || s_info.region == "USER_REGION" ) {
s_info.severity = ( deviationTime[ th_number ] / ( *prop_itr ).execTime ) * 100;
}
else {
s_info.severity = ( deviationTime[ th_number ] / PhaseTime ) * 100;
}
s_info.RFL = prop.RFL;
s_info.confidence = ( double )prop.confidence;
s_info.maxThreads = th_number;
s_info.addInfo = speedup_start + speedup_str + speedup_end;
s_info.process = prop.process;
s_info.numthreads = prop.numthreads;
s_info.maxProcs = prop.maxProcs;
s_info.RegionId = prop.RegionId;
speedup_based_properties.push_back( s_info );
}
else {
;
}
//We shall include a property that reports the low speedup considering every regions
PropertyInfo l_info;
long double l_condition = 0.0;
l_condition = ( deviationTime[ th_number ] / PhaseTime ) * 100;
if( l_condition > 0 ) { //Threshold set to zero (Increase later)
l_info.name = " SCA -- Low Speedup ";
l_info.filename = prop.filename;
l_info.context = prop.context;
l_info.region = prop.region;
l_info.cluster = prop.cluster;
int id = Low_Speedup_id();
l_info.ID = convertInt( id );
l_info.fileid = prop.fileid;
if( l_info.region == "MAIN_REGION" || l_info.region == "USER_REGION" ) {
l_info.severity = ( deviationTime[ th_number ] / ( *prop_itr ).execTime ) * 100;
}
else {
l_info.severity = ( deviationTime[ th_number ] / PhaseTime ) * 100;
}
l_info.RFL = prop.RFL;
l_info.confidence = ( double )prop.confidence;
l_info.maxThreads = th_number;
l_info.addInfo = speedup_start + speedup_str + speedup_end;
l_info.process = prop.process;
l_info.numthreads = prop.numthreads;
l_info.maxProcs = prop.maxProcs;
l_info.RegionId = prop.RegionId;
speedup_based_properties.push_back( l_info );
}
else {
;
}
//Find the thread when the speedup decreased
//if(rounded_speedup < t_speedup && th_number != initial_thread && !stop_tspeedup_check){
if( rounded_speedup < t_speedup && !stop_tspeedup_check ) {
//now we shall include a new property saying that the highest speedup reached until this threadno.
// in the particular RFL
stop_tspeedup_check = true;
PropertyInfo s_info;
s_info.name = " SCA -- Speedup Decreasing ";
s_info.filename = prop.filename;
s_info.context = prop.context;
s_info.region = prop.region;
s_info.cluster = prop.cluster;
int id = Speedup_Decreasing_id();
s_info.ID = convertInt( id );
s_info.fileid = prop.fileid;
if( s_info.region == "MAIN_REGION" || s_info.region == "USER_REGION" ) {
s_info.severity = 0.0;
}
else {
s_info.severity = ( deviationTime[ th_number ] / PhaseTime ) * 100;
}
s_info.RFL = prop.RFL;
s_info.confidence = ( double )prop.confidence;
s_info.maxThreads = th_number;
s_info.addInfo = speedup_start + speedup_str + speedup_end;
s_info.process = prop.process;
s_info.numthreads = prop.numthreads;
s_info.maxProcs = prop.maxProcs;
s_info.RegionId = prop.RegionId;
speedup_based_properties.push_back( s_info );
}
else {
t_speedup = rounded_speedup;
}
break; //need not check for other properties in that thread number
} //if(th_number==)
else {
;
}
} //for all properties_
} //for all threads
PropertyInfo d_info;
d_info.name = " ";
d_info.filename = prop.filename;
d_info.context = prop.context;
d_info.region = prop.region;
d_info.cluster = prop.cluster;
d_info.ID = prop.ID;
d_info.fileid = prop.fileid;
d_info.severity = 0.0;
d_info.RFL = prop.RFL;
d_info.confidence = ( double )prop.confidence;
d_info.maxThreads = prop.maxThreads;
d_info.addInfo = " ";
d_info.execTime = prop.execTime;
d_info.process = prop.process;
d_info.numthreads = prop.numthreads;
d_info.maxProcs = prop.maxProcs;
d_info.RegionId = prop.RegionId;
int count_exec = 0;
long double temp_execTime[ 30 ];
long double temp_deviaTime[ 30 ];
for( int i = 1; i <= fe->get_ompfinalthreads(); i += i ) {
temp_execTime[ count_exec ] = execTime_regions[ i ];
temp_deviaTime[ count_exec ] = deviationTime[ i ];
count_exec++;
}
for( int i = 0; i < count_exec; i++ ) {
d_info.exec_regions[ i ] = temp_execTime[ i ];
d_info.devia_regions[ i ] = temp_deviaTime[ i ];
}
ExecAndDeviaProperties.push_back( d_info );
delete[] execTime_regions;
delete[] deviationTime;
}
PropertyID PeriscopeFrontend::Property_with_increasing_severity_across_configurations_id() {
return PROPERTYWITHINCREASINGSEVERITYACROSSCONFIGURATIONS;
}
PropertyID PeriscopeFrontend::SuperLinear_Speedup_for_all_configurations_id() {
return SUPERLINEARSPEEDUPFORALLCONFIGURATIONS;
}
PropertyID PeriscopeFrontend::Linear_Speedup_for_all_configurations_id() {
return LINEARSPEEDUPFORALLCONFIGURATIONS;
}
PropertyID PeriscopeFrontend::Linear_speedup_failed_for_the_first_time_id() {
return LINEARSPEEDUPFAILEDFORTHEFIRSTTIME;
}
PropertyID PeriscopeFrontend::Low_Speedup_id() {
return LOWSPEEDUP;
}
PropertyID PeriscopeFrontend::Speedup_Decreasing_id() {
return SPEEDUPDECREASING;
}
PropertyID PeriscopeFrontend::Sequential_Computation_id() {
return SEQUENTIALCOMPUTATION;
}
PropertyID PeriscopeFrontend::Code_region_with_the_lowest_speedup_in_the_run_id() {
return CODEREGIONWITHTHELOWESTSPEEDUPINTHERUN;
}
PropertyID PeriscopeFrontend::Property_occurring_in_all_configurations_id() {
return PROPERTYOCCURRINGINALLCONFIGURATIONS;
}
/*
* This function returns the property info as a list using MetaProperty.cc
*/
void PeriscopeFrontend::get_prop_info( MetaProperty& prop ) {
PropertyInfo info;
info.filename = prop.getFileName();
info.name = prop.getName();
info.region = prop.getRegionType();
if( prop.getCluster() ) {
info.cluster = "true";
}
else {
info.cluster = "false";
}
info.ID = prop.getId();
info.RegionId = prop.getRegionId();
info.Config = prop.getConfiguration();
info.fileid = prop.getFileId();
info.RFL = prop.getStartPosition();
info.process = prop.getProcess();
info.numthreads = prop.getThread();
info.severity = prop.getSeverity();
info.confidence = prop.getConfidence();
info.maxThreads = prop.getMaxThreads();
info.maxProcs = prop.getMaxProcs();
info.purpose = prop.getPurpose();
//To find info.execTime
addInfoType addInfo = prop.getExtraInfo();
addInfoType::const_iterator it = addInfo.find( "ExecTime" );
string addInfo_ExecTime = it->second;
info.execTime = atof( addInfo_ExecTime.c_str() );
//To find info.addInfo
string addInfo_str;
for( addInfoType::const_iterator it = addInfo.begin(); it != addInfo.end(); ++it ) {
addInfo_str = "\t\t<";
addInfo_str += it->first;
addInfo_str += ">";
addInfo_str += it->second;
addInfo_str += "</";
addInfo_str += it->first;
addInfo_str += ">\n";
}
//Add in the list of properties
if( info.execTime == 0 && ( info.region == "SUB_REGION" || info.region == "CALL_REGION" ) ) {
;
}
else {
property.push_back( info );
properties_.push_back( info );
}
}
void PeriscopeFrontend::reinit( int map_len,
int map_from[ 8192 ],
int map_to[ 8192 ] ) {
std::map<std::string, AgentInfo>::iterator it;
for( it = child_agents_.begin(); it != child_agents_.end(); it++ ) {
AgentInfo& ag = it->second;
if( ag.status != AgentInfo::CONNECTED ) {
if( connect_to_child( &ag ) == -1 ) {
psc_errmsg( "Error connecting to child\n" );
abort();
}
else {
psc_dbgmsg( 5, "Sending REINIT command...\n" );
ag.handler->reinit( map_len, map_from, map_to );
psc_dbgmsg( 5, "Sending REINIT command...OK\n" );
}
}
}
}
std::ostream& operator<<( std::ostream& os,
const PropertyInfo& info ) {
os << endl;
os << "Property '" << info.name << "'" << endl;
os << " holds for '" << info.context << "'" << endl;
os << " on '" << info.host << "'" << endl;
os << " severity " << setprecision( 5 ) << info.severity << ", confidence " << info.confidence;
return os;
}
bool sevComparator( MetaProperty p1,
MetaProperty p2 ) {
return p1.getSeverity() > p2.getSeverity();
}
/**
* @brief Prints all found properties
*
*/
void PeriscopeFrontend::properties() {
int limitProps = 50;
if( opts.has_nrprops ) {
limitProps = opts.nrprops;
}
if( limitProps > 0 ) {
std::cout << std::endl << "ALL FOUND PROPERTIES" << std::endl;
std::cout << "-------------------------------------------------------------------------------\n";
// std::cout << std::setw(7) << "Procs\t" << std::setw(7) << "Threads\t"
// << std::setw(13) << "Region\t" << std::setw(12) << "Location\t"
// << std::setw(10) << "Severity\t" << "Description" << std::endl;
std::cout << std::setw(7) << "Procs\t" << std::setw(13) << "Region\t"
<< std::setw(12) << "Location\t" << std::setw(10)
<< "Severity\t" << "Description" << std::endl;
std::cout << "-------------------------------------------------------------------------------\n";
//metaproperties_.sort(sevComparator);
std::sort( metaproperties_.begin(), metaproperties_.end(), sevComparator );
//for(std::list<MetaProperty>::iterator it = metaproperties_.begin(); ( it != metaproperties_.end() && limitProps > 0) ; it++, limitProps-- ){
for( int i = 0; i < metaproperties_.size() && limitProps > 0; i++, limitProps-- ) {
string prop_string = ( metaproperties_[ i ] ).toString();
string::size_type p_loc = prop_string.find( ":::::", 0 );
// Exclude internal properties used to calculate the execution time for the scalability analysis
if( p_loc != string::npos ) {
;
}
else {
std::cout << prop_string << std::endl;
}
}
//prompt();
}
}
/**
* @brief Export all found properties to a file
*
* Exports all found properties to a file in XML format.
* The filename can be specified using the --propfile command argument.
*/
void PeriscopeFrontend::export_properties() {
std::string propfilename = fe->get_outfilename();
std::ofstream xmlfile( propfilename.c_str() );
if( !xmlfile && opts.has_propfile ) {
std::cout << "Cannot open xmlfile. \n";
exit( 1 );
}
if( xmlfile ) {
psc_infomsg( "Exporting results to %s\n", propfilename.c_str() );
time_t rawtime;
tm* timeinfo;
time( &rawtime );
timeinfo = localtime( &rawtime );
xmlfile << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>" << std::endl;
xmlfile << "<Experiment xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" "
"xmlns=\"http://www.lrr.in.tum.de/Periscope\" "
"xsi:schemaLocation=\"http://www.lrr.in.tum.de/Periscope psc_properties.xsd \">"
<< std::endl << std::endl;
xmlfile << std::setfill( '0' );
xmlfile << " <date>" << std::setw( 4 ) << ( timeinfo->tm_year + 1900 )
<< "-" << std::setw( 2 ) << timeinfo->tm_mon + 1 << "-" << std::setw( 2 )
<< timeinfo->tm_mday << "</date>" << std::endl;
xmlfile << " <time>" << std::setw( 2 ) << timeinfo->tm_hour << ":"
<< std::setw( 2 ) << timeinfo->tm_min << ":" << std::setw( 2 )
<< timeinfo->tm_sec << "</time>" << std::endl;
xmlfile << " <numProcs>" << opts.mpinumprocs_string << "</numProcs>" << std::endl;
xmlfile << " <numThreads>" << opts.ompnumthreads_string << "</numThreads>" << std::endl;
// Wording directory for the experiment: can be used to find the data file(s)
char* cwd = getenv( "PWD" );
xmlfile << " <dir>" << cwd << "</dir>" << std::endl;
// Source revision
if( opts.has_srcrev ) {
// Source revision
xmlfile << " <rev>" << opts.srcrev << "</rev>" << std::endl;
}
// Empty line before the properties
xmlfile << std::endl;
for( int i = 0; i < metaproperties_.size(); i++ ) {
string prop_string = ( metaproperties_[ i ] ).toString();
string::size_type p_loc = prop_string.find( ":::::", 0 );
// Exclude internal properties used to calculate the execution time for the scalability analysis
if( p_loc != string::npos ) {
;
}
else {
xmlfile << ( metaproperties_[ i ] ).toXML();
}
}
xmlfile << "</Experiment>" << std::endl;
}
xmlfile.close();
}
/**
* @brief Checks all child agents for new properties
*
* Triggers connection to all lower level agents and
* checks if new properties are available.
*/
void PeriscopeFrontend::check() {
std::map<std::string, AgentInfo>::iterator it;
for( it = child_agents_.begin(); it != child_agents_.end(); it++ ) {
AgentInfo& ag = it->second;
if( ag.status != AgentInfo::CONNECTED ) {
if( connect_to_child( &ag ) == -1 ) {
psc_errmsg( "Error connecting to child\n" );
abort();
}
else {
psc_dbgmsg( 1, "Checking properties...\n" );
ag.handler->check();
}
}
}
}
int PeriscopeFrontend::read_line( ACE_HANDLE hdle,
char* buf,
int len ) {
int eoln = 0;
while( !eoln && ( len > 0 ) && ( ACE::recv( hdle, buf, 1 ) == 1 ) ) {
eoln = ( *buf == '\n' );
buf++;
len--;
}
return eoln;
}
/**
* @deprecated Properties are transmitted/processed using XML
* @brief Prints the found performance property
*
* This method is called whenever a new performance property is found
*
* @param prop performance property to print
*/
void PeriscopeFrontend::found_property( PropertyInfo& prop ) {
std::cout << prop.name << "\t" << prop.context << "\t" << prop.host << "\t"
<< prop.severity << std::endl;
prompt();
}
/**
* @brief Processes the found performance property
*
* This method is called whenever a new performance property is found.
* This new property is added to a list containing all properties.
*
* @param propData performance property (as string)
*/
void PeriscopeFrontend::found_property( std::string& propData ) {
metaproperties_.push_back( MetaProperty::fromXML( propData ) );
}
void PeriscopeFrontend::set_timer( int init,
int inter,
int max,
TimerAction ta ) {
ACE_Reactor* reactor = ACE_Event_Handler::reactor();
ACE_Time_Value initial( init );
ACE_Time_Value interval( inter );
reactor->schedule_timer( this, 0, initial, interval );
ACE_Time_Value timeout = ACE_OS::gettimeofday();
timeout += max;
set_timeout( timeout );
timer_action = ta;
}
std::string region2string( int fid, int rfl ) {
std::stringstream info;
std::string str;
info << ":" << fid << ":" << rfl << ":";
str = info.str();
return str;
}
bool applUninstrumented() {
if( opts.has_uninstrumented ) {
return true;
}
if( psc_config_open() ) {
if( psc_config_uninstrumented() ) {
return true;
}
psc_config_close();
}
if( getenv( "PSC_UNINSTRUMENTED" ) ) {
return true;
}
return false;
}
| 39.63146
| 150
| 0.513987
|
robert-mijakovic
|
97d3a473e807c175f2b8a7b3a177cf074cb02032
| 734
|
cpp
|
C++
|
qpropgen/templates/template.cpp
|
agateau/qpropgen
|
2eaf65b3b75f63ab97560f86820542f5c17f8c31
|
[
"Apache-2.0"
] | 12
|
2018-11-12T17:03:55.000Z
|
2020-10-04T22:07:30.000Z
|
qpropgen/templates/template.cpp
|
agateau/qpropgen
|
2eaf65b3b75f63ab97560f86820542f5c17f8c31
|
[
"Apache-2.0"
] | 2
|
2021-03-25T21:40:45.000Z
|
2021-04-05T15:09:49.000Z
|
qpropgen/templates/template.cpp
|
agateau/qpropgen
|
2eaf65b3b75f63ab97560f86820542f5c17f8c31
|
[
"Apache-2.0"
] | 1
|
2018-11-12T17:03:55.000Z
|
2018-11-12T17:03:55.000Z
|
// {{ autogenerated_disclaimer }}
#include <{{ header }}>
{{ className }}::{{ className }}(QObject* parent)
: {{ baseClassName }}(parent) {
}
{% for property in properties if not property.impl == 'pure' %}
{{ property.type }} {{ className }}::{{ property.name }}() const {
return {{ property.varName }};
}
{%- if property.mutability != 'constant' %}
void {{ className }}::{{ property.setterName }}({{ property.argType }} value) {
{% if property.type == 'qreal' %}
if (qFuzzyCompare({{ property.varName }}, value)) {
{% else %}
if ({{ property.varName }} == value) {
{% endif %}
return;
}
{{ property.varName }} = value;
{{ property.name }}Changed(value);
}
{%- endif %}
{% endfor %}
| 27.185185
| 79
| 0.565395
|
agateau
|
97d8d86a5d670d77b6f886800afe52610252c49c
| 3,455
|
cpp
|
C++
|
tc 160+/StonesGame.cpp
|
ibudiselic/contest-problem-solutions
|
88082981b4d87da843472e3ca9ed5f4c42b3f0aa
|
[
"BSD-2-Clause"
] | 3
|
2015-05-25T06:24:37.000Z
|
2016-09-10T07:58:00.000Z
|
tc 160+/StonesGame.cpp
|
ibudiselic/contest-problem-solutions
|
88082981b4d87da843472e3ca9ed5f4c42b3f0aa
|
[
"BSD-2-Clause"
] | null | null | null |
tc 160+/StonesGame.cpp
|
ibudiselic/contest-problem-solutions
|
88082981b4d87da843472e3ca9ed5f4c42b3f0aa
|
[
"BSD-2-Clause"
] | 5
|
2015-05-25T06:24:40.000Z
|
2021-08-19T19:22:29.000Z
|
#include <algorithm>
#include <cassert>
#include <cstdio>
#include <iostream>
#include <sstream>
#include <string>
#include <vector>
#include <cstring>
using namespace std;
void bounds(int N, int M, int K, int &l, int &r) {
int rpoint = max(K, M);
int inpoint = M - rpoint + K;
l = M - 2*(inpoint-(K+1)/2) + (K+1)%2;
int lpoint = min(N-K+1, M);
inpoint = M - lpoint + 1;
r = M - 2*(inpoint-(K+1)/2) + (K+1)%2;
}
class StonesGame {
public:
string winner(int N, int M, int K, int L) {
int l, r, ll, rr;
bounds(N, M, K, l, r);
bounds(N, L, K, ll, rr);
if (K & 1) {
if ((L&1) != (M&1)) {
return "Draw";
}
if (l<=L && L<=r) {
return "Romeo";
}
if (ll<=l && r<=rr) {
return "Strangelet";
} else {
return "Draw";
}
} else {
if ((L&1) == (M&1)) {
if (ll<=l && r<=rr) {
return "Strangelet";
} else {
return "Draw";
}
} else {
if (l<=L && L<=r) {
return "Romeo";
} else {
return "Draw";
}
}
}
}
// BEGIN CUT HERE
public:
void run_test(int Case) { if ((Case == -1) || (Case == 0)) test_case_0(); if ((Case == -1) || (Case == 1)) test_case_1(); if ((Case == -1) || (Case == 2)) test_case_2(); if ((Case == -1) || (Case == 3)) test_case_3(); if ((Case == -1) || (Case == 4)) test_case_4(); if ((Case == -1) || (Case == 5)) test_case_5(); }
private:
template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
void verify_case(int Case, const string &Expected, const string &Received) { cerr << "Test Case #" << Case << "..."; if (Expected == Received) cerr << "PASSED" << endl; else { cerr << "FAILED" << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } }
void test_case_0() { int Arg0 = 3; int Arg1 = 1; int Arg2 = 1; int Arg3 = 2; string Arg4 = "Draw"; verify_case(0, Arg4, winner(Arg0, Arg1, Arg2, Arg3)); }
void test_case_1() { int Arg0 = 5; int Arg1 = 1; int Arg2 = 2; int Arg3 = 2; string Arg4 = "Romeo"; verify_case(1, Arg4, winner(Arg0, Arg1, Arg2, Arg3)); }
void test_case_2() { int Arg0 = 5; int Arg1 = 5; int Arg2 = 2; int Arg3 = 3; string Arg4 = "Strangelet"; verify_case(2, Arg4, winner(Arg0, Arg1, Arg2, Arg3)); }
void test_case_3() { int Arg0 = 5; int Arg1 = 5; int Arg2 = 2; int Arg3 = 2; string Arg4 = "Draw"; verify_case(3, Arg4, winner(Arg0, Arg1, Arg2, Arg3)); }
void test_case_4() { int Arg0 = 1000000; int Arg1 = 804588; int Arg2 = 705444; int Arg3 = 292263; string Arg4 = "Romeo"; verify_case(4, Arg4, winner(Arg0, Arg1, Arg2, Arg3)); }
void test_case_5() { int Arg0 = 1000000; int Arg1 = 100000; int Arg2 = 500000; int Arg3 = 600000; string Arg4 = "Strangelet"; verify_case(5, Arg4, winner(Arg0, Arg1, Arg2, Arg3)); }
// END CUT HERE
};
// BEGIN CUT HERE
int main()
{
StonesGame ___test;
___test.run_test(-1);
}
// END CUT HERE
| 39.712644
| 317
| 0.495224
|
ibudiselic
|
97da2f72108d65d88e60fdf55eb84c7142c85449
| 17,713
|
cpp
|
C++
|
imdexp/src/viewer/viewer.cpp
|
olivierchatry/iri3d
|
cae98c61d9257546d0fc81e69709297d04a17a14
|
[
"MIT"
] | 2
|
2022-01-02T08:12:29.000Z
|
2022-02-12T22:15:11.000Z
|
imdexp/src/viewer/viewer.cpp
|
olivierchatry/iri3d
|
cae98c61d9257546d0fc81e69709297d04a17a14
|
[
"MIT"
] | null | null | null |
imdexp/src/viewer/viewer.cpp
|
olivierchatry/iri3d
|
cae98c61d9257546d0fc81e69709297d04a17a14
|
[
"MIT"
] | 1
|
2022-01-02T08:09:51.000Z
|
2022-01-02T08:09:51.000Z
|
#include <stdafx.h>
const int grid_size = 80; // draw a 10x10 grid.
const int grid_primitive_count = grid_size * grid_size * 4; // eache sqaure take 4 lines.
const float grid_increment = 20.0f;
Viewer::Viewer() : _loger(0), _d3d_device(0), _d3d_object(0),
_d3d_backbuffer(0), _d3d_depthbuffer(0), _wnd(0),
_list_element(0), _list_material(0), _texture(0), _viewer_timer_event(0),
_capture_movement(false), _angle_x(0), _angle_y(0), _angle_z(0), _zoom(10),
_at(0.0f, 0.0f, 0.0f), _up(0.0f, 0.0f, 1.0f), _position(0.0f, -2.0f, 0.0f),
_thread_handle(0), _end_thread(false), _can_free(false)
{
}
//////////////////////////////////////////////////////////////////////////
// generate a vertex buffer containt line list for drawing a grid.
// !!!!!!! not efficient !!!!!!!!!
//////////////////////////////////////////////////////////////////////////
void Viewer::GenerateGrid(int size, float increment)
{
float middle = (float)size / 2.0f;
float inc_middle = increment / 2.0f;
_vb_grid.Allocate(_d3d_device, size * size * 8, D3DPT_LINELIST);
vertex3d_t *v = _vb_grid.Lock();
for (float x = -middle; x < middle; ++x)
{
for (float y = -middle; y < middle; ++y)
{
v->_color = 0xffffffff;
v->_pos = D3DXVECTOR3((x * increment) - inc_middle, (y * increment) - inc_middle, 0.0f);
v++;
v->_color = 0xffffffff;
v->_pos = D3DXVECTOR3((x * increment) - inc_middle, (y * increment) + inc_middle, 0.0f);
v++;
v->_color = 0xffffffff;
v->_pos = D3DXVECTOR3((x * increment) - inc_middle, (y * increment) + inc_middle, 0.0f);
v++;
v->_color = 0xffffffff;
v->_pos = D3DXVECTOR3((x * increment) + inc_middle, (y * increment) + inc_middle, 0.0f);
v++;
v->_color = 0xffffffff;
v->_pos = D3DXVECTOR3((x * increment) + inc_middle, (y * increment) + inc_middle, 0.0f);
v++;
v->_color = 0xffffffff;
v->_pos = D3DXVECTOR3((x * increment) + inc_middle, (y * increment) - inc_middle, 0.0f);
v++;
v->_color = 0xffffffff;
v->_pos = D3DXVECTOR3((x * increment) + inc_middle, (y * increment) - inc_middle, 0.0f);
v++;
v->_color = 0xffffffff;
v->_pos = D3DXVECTOR3((x * increment) - inc_middle, (y * increment) - inc_middle, 0.0f);
v++;
}
}
_vb_grid.Unlock();
}
void Viewer::StartD3DThread()
{
_thread_handle = CreateThread(NULL,
0,
(LPTHREAD_START_ROUTINE)D3DThread,
this,
0,
(LPDWORD)&_thread_id);
_can_free = false;
SetThreadPriority(_thread_handle, THREAD_PRIORITY_IDLE);
}
INT_PTR CALLBACK Viewer::WndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
static POINT old_mouse_pos = {0};
switch (msg)
{
case WM_COMMAND:
switch (LOWORD(wParam))
{
case IDOK:
Viewer::Get().Destroy();
EndDialog(hWnd, 1);
break;
}
break;
case WM_KEYDOWN:
if (wParam == VK_UP)
Viewer::Get().GoUp();
if (wParam == VK_DOWN)
Viewer::Get().GoDown();
if (wParam == VK_LEFT)
Viewer::Get().StrafeLeft();
if (wParam == VK_RIGHT)
Viewer::Get().StrafeRight();
break;
case WM_LBUTTONDOWN:
if (Viewer::Get()._capture_movement == false)
{
RECT rect;
ShowCursor(FALSE);
GetClientRect(hWnd, &rect);
Viewer::Get().SetWindowSize(&rect);
GetCursorPos(&Viewer::Get()._old_pos);
SetCursorPos(Viewer::Get()._wnd_middle_x,
Viewer::Get()._wnd_middle_y);
Viewer::Get()._capture_movement = true;
}
else
{
Viewer::Get()._capture_movement = false;
ShowCursor(TRUE);
SetCursorPos(Viewer::Get()._old_pos.x,
Viewer::Get()._old_pos.y);
}
break;
case WM_LBUTTONUP:
break;
case WM_MOUSEMOVE:
if (Viewer::Get()._capture_movement)
{
POINT new_pos;
GetCursorPos(&new_pos);
if ((new_pos.x == Viewer::Get()._wnd_middle_x) && (new_pos.y == Viewer::Get()._wnd_middle_y))
break;
int offset_y = Viewer::Get()._wnd_middle_x - new_pos.x;
int offset_z = Viewer::Get()._wnd_middle_y - new_pos.y;
SetCursorPos(Viewer::Get()._wnd_middle_x,
Viewer::Get()._wnd_middle_y);
if (offset_y != 0 || offset_z != 0)
{
Viewer::Get().SetCameraAngle(offset_y / 1000.0f, offset_z / 1000.0f);
}
}
break;
case WM_CLOSE:
case WM_QUIT:
case WM_DESTROY:
Viewer::Get().Destroy();
EndDialog(hWnd, 0);
break;
default:
return FALSE;
}
return TRUE;
}
Viewer::~Viewer()
{
Destroy();
}
void Viewer::DestroyTextures()
{
if (_texture)
{
for (uint i = 0; i < _texture_count; ++i)
if (_texture[i])
_texture[i]->Release();
delete[] _texture;
_texture = 0;
}
}
void Viewer::PrintIluError()
{
ILenum error;
while ((error = ilGetError()))
Debugf("+ ilu error: %s", iluErrorString(error));
}
typedef LPDIRECT3D8(__stdcall *DIRECT3DCREATE8)(uint);
bool Viewer::InitDirect3D(HWND hwnd, bool fullscreen, int size_x, int size_y)
{
// loading d3d8.dll
_d3d_object = Direct3DCreate8(D3D_SDK_VERSION);
ASSERT_VIEWER(_d3d_object != 0, "!!! Cannot create d3d object");
D3DCAPS8 dev_caps;
HRESULT hres;
// look for hardware card, if no exit.
hres = _d3d_object->GetDeviceCaps(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, &dev_caps);
ASSERT_VIEWER(SUCCEEDED(hres), "No 3d hardware");
D3DPRESENT_PARAMETERS pp = {0};
pp.BackBufferWidth = size_x;
pp.BackBufferHeight = size_y;
pp.BackBufferCount = 1;
// no faa
pp.MultiSampleType = D3DMULTISAMPLE_NONE; // no aa
pp.hDeviceWindow = hwnd;
pp.Windowed = !fullscreen;
// stencil for shadow
pp.EnableAutoDepthStencil = true;
pp.AutoDepthStencilFormat = D3DFMT_D16;
pp.FullScreen_RefreshRateInHz = D3DPRESENT_RATE_DEFAULT;
pp.SwapEffect = D3DSWAPEFFECT_DISCARD;
pp.FullScreen_PresentationInterval = fullscreen ? D3DPRESENT_INTERVAL_IMMEDIATE : D3DPRESENT_INTERVAL_DEFAULT;
if (!fullscreen)
{
// FIX ME : don't like voodoo card so ... don't really need this
ASSERT_VIEWER((dev_caps.Caps2 & D3DCAPS2_CANRENDERWINDOWED), "cannot render on windows");
D3DDISPLAYMODE current_displaye_mode;
hres = _d3d_object->GetAdapterDisplayMode(D3DADAPTER_DEFAULT, ¤t_displaye_mode);
ASSERT_VIEWER(SUCCEEDED(hres), "get display mode");
pp.BackBufferFormat = current_displaye_mode.Format;
}
else
{
int mode_count = _d3d_object->GetAdapterModeCount(D3DADAPTER_DEFAULT);
ASSERT_VIEWER(mode_count != 0, "no display mode");
D3DDISPLAYMODE new_mode, best_mode;
bool found = false;
do
{
hres = _d3d_object->EnumAdapterModes(D3DADAPTER_DEFAULT, mode_count - 1, &new_mode);
ASSERT_VIEWER(SUCCEEDED(hres), "adaptator enumeration");
if (new_mode.Height == size_y && new_mode.Width == size_x)
if ((found && (new_mode.Format < new_mode.Format)) || !found)
best_mode = new_mode, found = true;
} while (--mode_count);
ASSERT_VIEWER(found, "cannot find a suitable display mode");
pp.BackBufferFormat = best_mode.Format;
}
// look for hardware vertex proecesind
int flags = D3DCREATE_SOFTWARE_VERTEXPROCESSING;
if (dev_caps.DevCaps & D3DDEVCAPS_HWTRANSFORMANDLIGHT)
flags = (dev_caps.DevCaps & D3DDEVCAPS_PUREDEVICE) ? D3DCREATE_HARDWARE_VERTEXPROCESSING : D3DCREATE_MIXED_VERTEXPROCESSING;
hres = _d3d_object->CreateDevice(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, _wnd, flags | D3DCREATE_MULTITHREADED, &pp, &_d3d_device);
ASSERT_VIEWER(SUCCEEDED(hres), "device creation");
hres = _d3d_device->GetRenderTarget(&_d3d_backbuffer);
ASSERT_VIEWER(SUCCEEDED(hres), "set backbuffer");
hres = _d3d_device->GetDepthStencilSurface(&_d3d_depthbuffer);
ASSERT_VIEWER(SUCCEEDED(hres), "set stencil buffer");
return true;
}
void Viewer::SetImportedElements(ImdExp::element_list_t *list_element)
{
_list_element = list_element;
}
void Viewer::LoadTextures()
{
bool il_error = false;
DestroyTextures();
if (_list_material == 0)
return;
_texture_count = _list_material->_material_data.size();
_texture = new IDirect3DTexture8 *[_texture_count];
for (uint i = 0; i < _texture_count; ++i)
{
MaterialData *material = _list_material->_material_data[i];
ILuint il_id;
material->_data = 0;
if (material->_diffuse_map == 0)
continue;
ilGenImages(1, &il_id);
ilBindImage(il_id);
_texture[i] = 0;
if (ilLoadImage(material->_diffuse_map) == IL_TRUE)
{
if (ilConvertImage(IL_RGBA, IL_UNSIGNED_BYTE) == IL_TRUE)
{
ilutSetInteger(ILUT_D3D_POOL, D3DPOOL_MANAGED);
_texture[i] = ilutD3D8Texture(_d3d_device);
material->_data = (void *)(_texture[i]);
}
else
il_error = true;
}
else
il_error = true;
if (il_error)
{
PrintIluError();
}
ilDeleteImages(1, &il_id);
}
}
void Viewer::Debug(char *str)
{
Loger::Get().Print(str);
}
void Viewer::Debugf(char *str, ...)
{
va_list args;
TCHAR buffer[1024]; // FIXMEEE
va_start(args, str);
vsprintf(buffer, str, args);
Debug(buffer);
va_end(args);
}
void Viewer::UpdateCamera()
{
D3DXVECTOR3 axis, sub;
D3DXVec3Subtract(&_direction, &_at, &_position);
D3DXVec3Cross(&_inv_strafe_left, &_up, &_direction);
D3DXVec3Normalize(&_inv_strafe_left, &_inv_strafe_left);
RotateAt(_angle_z, &_inv_strafe_left);
RotateAt(_angle_y, &D3DXVECTOR3(0.0f, 0.0f, 1.0f));
D3DXVec3Normalize(&_direction, &_direction);
_inv_direction = -_direction;
_strafe_left = -_inv_strafe_left;
D3DXMATRIX view_matrix;
D3DXMatrixLookAtLH(&view_matrix,
&_position,
&_at,
&_up);
_angle_z = _angle_y = 0;
_d3d_device->SetTransform(D3DTS_VIEW, &view_matrix);
}
void Viewer::RotateAt(float angle, D3DXVECTOR3 *axis)
{
D3DXVECTOR3 tmp;
D3DXVECTOR3 direction;
D3DXVec3Subtract(&direction, &_at, &_position);
float c = cosf(angle);
float s = sinf(angle);
tmp.x = (c + (1 - c) * axis->x) * direction.x;
tmp.x += ((1 - c) * axis->x * axis->y - axis->z * s) * direction.y;
tmp.x += ((1 - c) * axis->x * axis->z + axis->y * s) * direction.z;
tmp.y = ((1 - c) * axis->x * axis->y + axis->z * s) * direction.x;
tmp.y += (c + (1 - c) * axis->y) * direction.y;
tmp.y += ((1 - c) * axis->y * axis->z - axis->x * s) * direction.z;
tmp.z = ((1 - c) * axis->x * axis->z - axis->y * s) * direction.x;
tmp.z += ((1 - c) * axis->y * axis->z + axis->x * s) * direction.y;
tmp.z += (c + (1 - c) * axis->z) * direction.z;
D3DXVec3Add(&_at, &_position, &tmp);
}
void Viewer::Render()
{
if (_d3d_device)
{
_d3d_device->Clear(0, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, D3DCOLOR_ARGB(0x00, 0x0, 0x0, 0x0), 1, 0);
_d3d_device->BeginScene();
_d3d_device->SetTexture(0, 0);
_d3d_device->SetTextureStageState(0, D3DTSS_MAGFILTER, D3DTEXF_LINEAR);
_d3d_device->SetTextureStageState(0, D3DTSS_MINFILTER, D3DTEXF_LINEAR);
_d3d_device->SetTextureStageState(0, D3DTSS_COLOROP, D3DTOP_MODULATE);
_d3d_device->SetTextureStageState(0, D3DTSS_COLORARG1, D3DTA_TEXTURE);
_d3d_device->SetTextureStageState(0, D3DTSS_COLORARG2, D3DTA_DIFFUSE);
_d3d_device->SetTextureStageState(0, D3DTSS_ALPHAOP, D3DTOP_DISABLE);
_vb_grid.Draw(_d3d_device, grid_primitive_count);
for (uint mesh = 0; mesh < _vb.size(); ++mesh)
{
_d3d_device->SetTexture(0, (IDirect3DBaseTexture8 *)_texture_list[mesh]);
_vb[mesh].DrawIndexed(_d3d_device, D3DPT_TRIANGLESTRIP);
}
_d3d_device->EndScene();
_d3d_device->Present(NULL, NULL, NULL, NULL);
}
}
void Viewer::Destroy()
{
DestroyThread();
if (_loger)
_loger = 0;
_d3d_device = 0;
_d3d_object = 0;
_wnd = 0;
}
void Viewer::DestroyThread()
{
if (_thread_handle)
{
Viewer::_end_thread = true;
WaitForSingleObject(_thread_handle, 2000);
CloseHandle(_thread_handle);
_thread_handle = 0;
Viewer::_end_thread = false;
}
}
bool Viewer::Create(HINSTANCE hinstance)
{
if (_wnd)
SendMessage(_wnd, WM_QUIT, 0, 0); // destroy our windows.
RECT rect;
_wnd = CreateDialog(hinstance, MAKEINTRESOURCE(IDD_DIALOGVIEWER), 0, WndProc);
ASSERT_VIEWER(_wnd != 0, "Cannot create window !!!");
GetClientRect(_wnd, &rect);
_wnd_height = rect.bottom - rect.top;
_wnd_width = rect.right - rect.left;
_wnd_middle_x = _wnd_width >> 1;
_wnd_middle_y = _wnd_height >> 1;
Loger::Get().Printf("Client window is %d %d", _wnd_width, _wnd_height);
ShowWindow(_wnd, SW_SHOW);
return true;
}
void Viewer::D3DThread(Viewer *viewer)
{
ilInit();
iluInit();
ilutInit();
if (ilGetInteger(IL_VERSION_NUM) < IL_VERSION ||
iluGetInteger(ILU_VERSION_NUM) < ILU_VERSION)
viewer->Debug("DevIL header version is different from lib version !!!!");
viewer->InitDirect3D(viewer->_wnd, false, viewer->_wnd_width, viewer->_wnd_height);
viewer->GenerateGrid(grid_size, grid_increment);
viewer->LoadTextures();
viewer->CreateD3dBuffer();
// default setting.
D3DXMATRIX projection_matrix;
D3DXMatrixPerspectiveFovLH(&projection_matrix, D3DX_PI / 3, (float)viewer->_wnd_width / (float)viewer->_wnd_height, 1.0f, 1000.0f);
viewer->_d3d_device->SetTransform(D3DTS_PROJECTION, &projection_matrix);
D3DMATERIAL8 material;
material.Ambient.a = 0;
material.Ambient.r = material.Ambient.g = material.Ambient.b = 0.0f;
material.Diffuse.r = material.Diffuse.g = material.Diffuse.b = 0.1f;
material.Specular.r = material.Specular.g = material.Specular.b = 0.1f;
material.Power = 0.0f;
viewer->_d3d_device->SetMaterial(&material);
// no lighting
viewer->_d3d_device->SetRenderState(D3DRS_LIGHTING, 0);
// no culling
viewer->_d3d_device->SetRenderState(D3DRS_CULLMODE, D3DCULL_NONE);
// set default material
viewer->_can_free = true;
while (!viewer->_end_thread)
{
viewer->UpdateCamera();
viewer->Render();
}
viewer->DestroyTextures();
for (uint i = 0; i < viewer->_vb.size(); ++i)
viewer->_vb[i].Deallocate();
viewer->_vb_grid.Deallocate();
if (viewer->_d3d_device)
viewer->_d3d_device->Release();
if (viewer->_d3d_object)
viewer->_d3d_object->Release();
}
//////////////////////////////////////////////////////////////////////////
// Create Vertex Buffer from imported element
//////////////////////////////////////////////////////////////////////////
void Viewer::CreateD3dBuffer()
{
// get number of vertex in totla mesh.
ImdExp::element_list_it_t it;
size_t num_indices_total = 0;
size_t num_vertex_total = 0;
size_t num_mesh = 0;
size_t num_strip = 0;
for (it = _list_element->begin(); it != _list_element->end(); ++it)
{
if ((*it)->_type == mesh_element)
{
ImportedMesh *mesh = (ImportedMesh *)(*it);
for (uint i = 0; i < mesh->_strip.size(); ++i)
num_indices_total += mesh->_strip[i]._face_index.size();
num_vertex_total += mesh->_mesh_data[0]._vertex.size();
num_strip += mesh->_strip.size();
num_mesh++;
}
}
// create our vertex buffer.
_vb.resize(num_mesh);
_texture_list.resize(num_mesh);
num_mesh = 0;
// fill our vertex buffer
for (it = _list_element->begin(); it != _list_element->end(); ++it)
{
if ((*it)->_type == mesh_element)
{
ImportedMesh *mesh = (ImportedMesh *)(*it);
MeshData *data = &(mesh->_mesh_data[0]);
MeshColorMapping *mapping_color = &(mesh->_mesh_color_mapping);
bool have_color = mapping_color->_color.size() > 0;
if (mesh->_material)
_texture_list[num_mesh] = mesh->_material->_data;
else
_texture_list[num_mesh] = 0;
_vb[num_mesh].Allocate(_d3d_device, (uint)data->_vertex.size(), D3DPT_TRIANGLESTRIP);
//////////////////////////////////////////////////////////////////////////
// fill our vertex buffer
vertex3d_t *v = _vb[num_mesh].Lock();
for (uint i = 0; i < data->_vertex.size(); ++i)
{
v->_pos.x = data->_vertex[i].x;
v->_pos.y = data->_vertex[i].y;
v->_pos.z = data->_vertex[i].z;
v->_norm.x = data->_normal[i].x;
v->_norm.y = data->_normal[i].y;
v->_norm.z = data->_normal[i].z;
v->_u = mapping_color->_mapping[i]._uv.x;
v->_v = 1.0f - mapping_color->_mapping[i]._uv.y;
uint r = (uint)(mapping_color->_color[i].x * 255) & 0xff;
uint g = (uint)(mapping_color->_color[i].y * 255) & 0xff;
uint b = (uint)(mapping_color->_color[i].z * 255) & 0xff;
v->_color = have_color ? (r << 16 | g << 8 | b) : 0;
v++;
}
_vb[num_mesh].Unlock();
//////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////
// fill our index buffer;
_vb[num_mesh].PrealocateIBList((uint)mesh->_strip.size());
for (i = 0; i < mesh->_strip.size(); ++i)
{
uword_list_t &indices = mesh->_strip[i]._face_index;
_vb[num_mesh].CreateIB(_d3d_device, i, (uint)indices.size(), (uint)indices.size() - 2);
WORD *ib = _vb[num_mesh]._ib[i].Lock();
for (uint f = 0; f < indices.size(); ++f)
{
*ib = indices[f];
ib++;
}
_vb[num_mesh]._ib[i].Unlock();
}
//////////////////////////////////////////////////////////////////////////
num_mesh++;
}
}
}
void Viewer::SetImportedMaterial(ImportedMaterial *list_material)
{
_list_material = list_material;
}
| 32.923792
| 133
| 0.616666
|
olivierchatry
|
97ded0faefa2f15836eacf1033fdbb91b50abc48
| 1,356
|
cpp
|
C++
|
algorithms/RANGETREELAZY.cpp
|
chinoxyz/guiafuentes
|
753d026d91ddcbabcccee7947a2ee6c581eb94eb
|
[
"MIT"
] | null | null | null |
algorithms/RANGETREELAZY.cpp
|
chinoxyz/guiafuentes
|
753d026d91ddcbabcccee7947a2ee6c581eb94eb
|
[
"MIT"
] | null | null | null |
algorithms/RANGETREELAZY.cpp
|
chinoxyz/guiafuentes
|
753d026d91ddcbabcccee7947a2ee6c581eb94eb
|
[
"MIT"
] | null | null | null |
#define MAXN 100000
#define T int
#define neutro 0
// entrada, arbol, acumulado(propagacion) elemento 0 se desperdicia
T input[MAXN]; T tree[MAXN*17]; T acum[MAXN*17];
T f(T a, T b) { return a + b; } // Funcion que mantiene el segment tree
// init(1,1,n)
void init(int node, int b, int e) {
acum[node] = 0;
if(b == e) tree[node] = input[b];
else {
int m = (b + e) >> 1, lt = node << 1, rt = lt | 1;
init(lt, b, m);
init(rt, m+1, e);
tree[node] = f(tree[lt], tree[rt]);
}
}
// query(1,1,N,i,j)
T query(int node, int b, int e, int i, int j) {
int m = (b + e) >> 1, lt = node << 1, rt = lt | 1;
tree[node] += acum[node] * (e - b + 1);
acum[lt] += acum[node];
acum[rt] += acum[node];
acum[node] = 0;
if(i > e || j < b) return neutro;
if (i <= b && e <= j) return tree[node];
else return f(query(lt, b, m, i, j), query(rt, m+1, e, i, j));
}
// modify(1,1,N,i,j,val)
void modify(int node, int b, int e, int i, int j, int v) {
int m = (b + e) >> 1, lt = node << 1, rt = lt | 1;
tree[node] += acum[node] * (e - b + 1);
acum[lt] += acum[node];
acum[rt] += acum[node];
acum[node] = 0;
if(i > e || j < b) return;
if (i <= b && e <= j) {
tree[node] += v * (e - b + 1);
acum[lt] += v;
acum[rt] += v;
return;
}
modify(lt, b, m, i, j, v);
modify(rt, m+1, e, i, j, v);
tree[node] = f(tree[lt], tree[rt]);
}
| 27.673469
| 71
| 0.514749
|
chinoxyz
|
97dfc4c86bb06a5524073a57fa567a120bd0c5e7
| 602
|
cc
|
C++
|
examples/channels.cc
|
kjdv/kthread
|
d606c2455e9db52c731f58b8b30ad37a55e956d6
|
[
"MIT"
] | 1
|
2021-05-09T16:12:56.000Z
|
2021-05-09T16:12:56.000Z
|
examples/channels.cc
|
kjdv/kthread
|
d606c2455e9db52c731f58b8b30ad37a55e956d6
|
[
"MIT"
] | null | null | null |
examples/channels.cc
|
kjdv/kthread
|
d606c2455e9db52c731f58b8b30ad37a55e956d6
|
[
"MIT"
] | 1
|
2021-05-09T16:12:57.000Z
|
2021-05-09T16:12:57.000Z
|
#include <channel.hh>
#include <threadpool.hh>
#include <iostream>
namespace {
using namespace std;
using namespace kthread;
void consume(receiver<int> tx)
{
while(tx.receive()
.map([](auto&& item) {
cout << "consuming " << item << '\n';
return 0;
})
.is_some())
;
}
void produce(int n, sender<int> tx)
{
for(int i = 0; i < n; ++i)
tx.send(i);
tx.close();
}
}
int main()
{
threadpool pool;
auto c = make_channel<int>();
pool.post([=] { produce(10, c.tx); });
pool.post([=] { consume(c.rx); });
return 0;
}
| 15.05
| 51
| 0.523256
|
kjdv
|
97e04a1132734684d8e4d05439fcae771b5c05c3
| 8,906
|
cpp
|
C++
|
tests/type_check_test.cpp
|
claremacrae/eml
|
d10eb7fcfc51abb277c1edbec8f15a7ed806ceb1
|
[
"MIT"
] | 3
|
2020-11-03T19:22:11.000Z
|
2021-05-05T13:16:15.000Z
|
tests/type_check_test.cpp
|
claremacrae/eml
|
d10eb7fcfc51abb277c1edbec8f15a7ed806ceb1
|
[
"MIT"
] | 2
|
2020-04-01T12:57:24.000Z
|
2021-02-19T10:17:30.000Z
|
tests/type_check_test.cpp
|
claremacrae/eml
|
d10eb7fcfc51abb277c1edbec8f15a7ed806ceb1
|
[
"MIT"
] | 2
|
2020-10-15T18:28:18.000Z
|
2020-10-25T16:44:17.000Z
|
#include "ast.hpp"
#include "compiler.hpp"
#include <catch2/catch.hpp>
auto parse_and_type_check(eml::Compiler& compiler, std::string_view s,
eml::GarbageCollector& gc)
{
return eml::parse(s, gc).and_then(
[&compiler](auto&& ast) { return compiler.type_check(ast); });
}
TEST_CASE("Type check on unary expressions")
{
eml::GarbageCollector gc{};
eml::Compiler compiler{gc};
GIVEN("- 2")
{
WHEN("Type check")
{
const auto checked_ast = parse_and_type_check(compiler, "-2", gc);
THEN("Passes the type check")
{
REQUIRE(checked_ast.has_value());
THEN("Gets `Number` as its type")
{
const auto& expr = dynamic_cast<eml::Expr&>(**checked_ast);
REQUIRE(eml::match(expr.type(), eml::NumberType{}));
}
}
}
}
GIVEN("(! 2)")
{
WHEN("Type check")
{
const auto checked_ast = parse_and_type_check(compiler, "!2", gc);
THEN("Failed the type check")
{
REQUIRE(!checked_ast.has_value());
}
}
}
}
TEST_CASE("Type check on binary arithmatic expressions")
{
eml::GarbageCollector gc{};
eml::Compiler compiler{gc};
GIVEN("(+ 1 1)")
{
WHEN("Type check")
{
const auto checked_ast = parse_and_type_check(compiler, "1 + 1", gc);
THEN("Passes the type check")
{
REQUIRE(checked_ast.has_value());
THEN("Gets `Number` as its type")
{
const auto& expr = dynamic_cast<eml::Expr&>(**checked_ast);
REQUIRE(eml::match(expr.type(), eml::NumberType{}));
}
}
}
}
GIVEN("(+ 1 true)")
{
WHEN("Type check")
{
const auto checked_ast = parse_and_type_check(compiler, "1 + true", gc);
THEN("Failed the type check")
{
REQUIRE(!checked_ast.has_value());
}
}
}
GIVEN("(* 1 1)")
{
WHEN("Type check")
{
const auto checked_ast = parse_and_type_check(compiler, "1 * 1", gc);
THEN("Passes the type check")
{
REQUIRE(checked_ast.has_value());
THEN("Gets `Number` as its type")
{
const auto& expr = dynamic_cast<eml::Expr&>(**checked_ast);
REQUIRE(eml::match(expr.type(), eml::NumberType{}));
}
}
}
}
GIVEN("(/ true 3)")
{
WHEN("Type check")
{
const auto checked_ast = parse_and_type_check(compiler, "true / 3", gc);
THEN("Failed the type check")
{
REQUIRE(!checked_ast.has_value());
}
}
}
}
TEST_CASE("Type check on binary comparison expressions")
{
eml::GarbageCollector gc{};
eml::Compiler compiler{gc};
GIVEN("(== 1 1)")
{
WHEN("Type check")
{
const auto checked_ast = parse_and_type_check(compiler, "1 == 1", gc);
THEN("Passes the type check")
{
REQUIRE(checked_ast.has_value());
THEN("Gets `Bool` as its type")
{
const auto& expr = dynamic_cast<eml::Expr&>(**checked_ast);
REQUIRE(eml::match(expr.type(), eml::BoolType{}));
}
}
}
}
GIVEN("(== true false)")
{
WHEN("Type check")
{
const auto checked_ast =
parse_and_type_check(compiler, "true == false", gc);
THEN("Passes the type check")
{
REQUIRE(checked_ast.has_value());
THEN("Gets `Bool` as its type")
{
const auto& expr = dynamic_cast<eml::Expr&>(**checked_ast);
REQUIRE(eml::match(expr.type(), eml::BoolType{}));
}
}
}
}
GIVEN("(== 1 true)")
{
WHEN("Type check")
{
const auto checked_ast = parse_and_type_check(compiler, "1 == true", gc);
THEN("Failed the type check")
{
REQUIRE(!checked_ast.has_value());
}
}
}
GIVEN("(!= 1 1)")
{
WHEN("Type check")
{
const auto checked_ast = parse_and_type_check(compiler, "1 != 1", gc);
THEN("Passes the type check")
{
REQUIRE(checked_ast.has_value());
THEN("Gets `Bool` as its type")
{
const auto& expr = dynamic_cast<eml::Expr&>(**checked_ast);
REQUIRE(eml::match(expr.type(), eml::BoolType{}));
}
}
}
}
GIVEN("(!= 1 true)")
{
WHEN("Type check")
{
const auto checked_ast = parse_and_type_check(compiler, "1 != true", gc);
THEN("Failed the type check")
{
REQUIRE(!checked_ast.has_value());
}
}
}
GIVEN("(< 1 1)")
{
WHEN("Type check")
{
const auto checked_ast = parse_and_type_check(compiler, "1 < 1", gc);
THEN("Passes the type check")
{
REQUIRE(checked_ast.has_value());
THEN("Gets `Bool` as its type")
{
const auto& expr = dynamic_cast<eml::Expr&>(**checked_ast);
REQUIRE(eml::match(expr.type(), eml::BoolType{}));
}
}
}
}
GIVEN("(< true true)")
{
WHEN("Type check")
{
const auto checked_ast =
parse_and_type_check(compiler, "true < true", gc);
THEN("Failed the type check")
{
REQUIRE(!checked_ast.has_value());
}
}
}
GIVEN("(<= 1 1)")
{
WHEN("Type check")
{
const auto checked_ast = parse_and_type_check(compiler, "1 <= 1", gc);
THEN("Passes the type check")
{
REQUIRE(checked_ast.has_value());
THEN("Gets `Bool` as its type")
{
const auto& expr = dynamic_cast<eml::Expr&>(**checked_ast);
REQUIRE(eml::match(expr.type(), eml::BoolType{}));
}
}
}
}
GIVEN("(<= true true)")
{
WHEN("Type check")
{
const auto checked_ast =
parse_and_type_check(compiler, "true <= true", gc);
THEN("Failed the type check")
{
REQUIRE(!checked_ast.has_value());
}
}
}
GIVEN("(> 1 1)")
{
WHEN("Type check")
{
const auto checked_ast = parse_and_type_check(compiler, "1 > 1", gc);
THEN("Passes the type check")
{
REQUIRE(checked_ast.has_value());
THEN("Gets `Bool` as its type")
{
const auto& expr = dynamic_cast<eml::Expr&>(**checked_ast);
REQUIRE(eml::match(expr.type(), eml::BoolType{}));
}
}
}
}
GIVEN("(>= 1 1)")
{
WHEN("Type check")
{
const auto checked_ast = parse_and_type_check(compiler, "1 >= 1", gc);
THEN("Passes the type check")
{
REQUIRE(checked_ast.has_value());
THEN("Gets `Bool` as its type")
{
const auto& expr = dynamic_cast<eml::Expr&>(**checked_ast);
REQUIRE(eml::match(expr.type(), eml::BoolType{}));
}
}
}
}
GIVEN("(>= true true)")
{
WHEN("Type check")
{
const auto checked_ast =
parse_and_type_check(compiler, "true >= true", gc);
THEN("Failed the type check")
{
REQUIRE(!checked_ast.has_value());
}
}
}
}
TEST_CASE("Correctly type infer the let declerations and identifiers")
{
constexpr auto s1 = "let x = true";
GIVEN(s1)
{
eml::GarbageCollector gc{};
eml::Compiler compiler{gc};
THEN("Type check should resolve the right hand side to type Bool")
{
const auto result = parse_and_type_check(compiler, s1, gc);
REQUIRE(result);
const auto bind_type =
dynamic_cast<eml::Definition&>(**result).binding_type();
REQUIRE(bind_type.has_value());
REQUIRE(eml::match(*bind_type, eml::BoolType{}));
const auto result2 = parse_and_type_check(compiler, "x", gc);
REQUIRE(result2.has_value());
const auto& id = dynamic_cast<eml::IdentifierExpr&>(**result2);
REQUIRE(id.has_type());
REQUIRE(eml::match(id.type(), eml::BoolType{}));
}
}
}
TEST_CASE("Type check for branches")
{
eml::GarbageCollector gc{};
eml::Compiler compiler{gc};
GIVEN("An if expression")
{
WHEN("Type check")
{
const auto checked_ast =
parse_and_type_check(compiler, "if (true) { 2 } else {3}", gc);
THEN("Resolve to the type of the branches")
{
REQUIRE(checked_ast.has_value());
const auto& if_expr = dynamic_cast<eml::IfExpr&>(**checked_ast);
REQUIRE(eml::match(if_expr.type(), if_expr.If().type()));
REQUIRE(eml::match(if_expr.type(), if_expr.Else().type()));
}
}
}
GIVEN("A mistyped if expression condition")
{
WHEN("Type check")
{
const auto checked_ast =
parse_and_type_check(compiler, "if (1) { 2 } else {3}", gc);
THEN("Failed the type check")
{
REQUIRE(!checked_ast.has_value());
}
}
}
GIVEN("Mismatched if expression branches")
{
WHEN("Type check")
{
const auto checked_ast =
parse_and_type_check(compiler, "if (1) { 2 } else {()}", gc);
THEN("Failed the type check")
{
REQUIRE(!checked_ast.has_value());
}
}
}
}
| 23.072539
| 79
| 0.548843
|
claremacrae
|
97e2a9ee82142776598131c22d6f79ad122e0f03
| 1,063
|
cpp
|
C++
|
solved/o-q/phone-list/uva/phone.cpp
|
abuasifkhan/pc-code
|
77ce51d692acf6edcb9e47aeb7b7f06bf56e4e90
|
[
"Unlicense"
] | 13
|
2015-09-30T19:18:04.000Z
|
2021-06-26T21:11:30.000Z
|
solved/o-q/phone-list/uva/phone.cpp
|
sbmaruf/pc-code
|
77ce51d692acf6edcb9e47aeb7b7f06bf56e4e90
|
[
"Unlicense"
] | null | null | null |
solved/o-q/phone-list/uva/phone.cpp
|
sbmaruf/pc-code
|
77ce51d692acf6edcb9e47aeb7b7f06bf56e4e90
|
[
"Unlicense"
] | 13
|
2015-01-04T09:49:54.000Z
|
2021-06-03T13:18:44.000Z
|
#include <cstdio>
#include <cstring>
#define ALPHABET 10
#define WORDS 10000
#define WORDLEN 10
#define Zero(v) memset(v, 0, sizeof(v))
#define NonZero(v) (memcmp(v, _zero, sizeof(_zero)) != 0)
static const int _zero[ALPHABET] = {0};
struct Trie {
struct Node {
int children[ALPHABET];
bool end;
};
int nxt;
Node nodes[WORDS * WORDLEN];
void init() { Zero(nodes); nxt = 1; }
void insert(const char *s, bool &c) {
int cur = 0;
while (*s) {
if (nodes[cur].end) { c = false; return; }
int idx = *s - '0';
if (! nodes[cur].children[idx])
nodes[cur].children[idx] = nxt++;
cur = nodes[cur].children[idx];
++s;
}
if (NonZero(nodes[cur].children)) { c = false; return; }
nodes[cur].end = true;
}
};
Trie t;
char num[WORDLEN + 1];
int main()
{
int T;
scanf("%d", &T);
while (T--) {
int n;
scanf("%d", &n);
t.init();
bool consistent = true;
while (n--) {
scanf("%s", num);
if (consistent)
t.insert(num, consistent);
}
if (consistent) puts("YES");
else puts("NO");
}
return 0;
}
| 15.185714
| 58
| 0.573848
|
abuasifkhan
|
97e3bb6c7ff45308e577587f3a2c2f82ec39c4c1
| 1,472
|
cpp
|
C++
|
Code/ecrireMemoire/ecirreMemoire.cpp
|
joabda/Robot
|
ce27e2e615cb87480c05f9e0ce32124648f9baff
|
[
"MIT"
] | 1
|
2020-01-26T15:36:07.000Z
|
2020-01-26T15:36:07.000Z
|
Code/ecrireMemoire/ecirreMemoire.cpp
|
joabda/Robot
|
ce27e2e615cb87480c05f9e0ce32124648f9baff
|
[
"MIT"
] | null | null | null |
Code/ecrireMemoire/ecirreMemoire.cpp
|
joabda/Robot
|
ce27e2e615cb87480c05f9e0ce32124648f9baff
|
[
"MIT"
] | null | null | null |
/*
* Code permettant d'ecrire sur la mémoire externe
* du microcontroleur ATMega16 de Atmel.
*
* Ecole Polytechnique de Montreal
* Departement de genie informatique
* Cours inf1900
*
* Joe Abdo, Mathurin Critin, Teo Quiquempoix et Philippe Babin,
* 2019
*
* Code qui n'est sous aucune license.
*
*/
#include "libCommune.h"
uint16_t getSizeFichier(Uart& uart)
{
uint16_t octet16 = ( uart.reception() << 8) | uart.reception();
return octet16; // Concatenantion des deux octet pour trouver la taille du fichiers transmit
}
void test(Memoire24CXXX memoire1, uint8_t adresse, Uart& uart)
// Avec serieViaUSB -l va recevoir le contenu de la memoire qui devrait etre le meme que ce qui a ete transmis
{
unsigned char donee[] = {0};
for(uint8_t i = 0; i <= adresse; i++)
{
memoire1.lecture(i, &donee[0],1);
uart.transmission(&donee[0]);
}
}
int main()
{
Uart uart1;
LED led1(A,ledRouge,0,1);
Memoire24CXXX memoire1;
uint16_t sizeFichier = getSizeFichier(uart1);
if(sizeFichier == 106)
led1.activer();
uint16_t adresse = 0;
for (; adresse != sizeFichier - 2; adresse++) // -2 car on lit les 2 premiers octets qui donnent la taille (on ne veut pas les ecrire )
{
unsigned char doneeRecue[] = {uart1.reception()};
memoire1.ecriture(adresse, &doneeRecue[0], 1);
}
test(memoire1, adresse, uart1); //Decommenter cette ligne pour tester le code
}
| 29.44
| 140
| 0.661005
|
joabda
|
97e7691f6689308ea11c838e4f93a9ed034a0db2
| 2,168
|
cpp
|
C++
|
parrot/src/parrot/renderer/Shader.cpp
|
MiloHX/Parrot
|
159f583b2e43396dcc42dc3456a9c5d3fb043133
|
[
"Apache-2.0"
] | null | null | null |
parrot/src/parrot/renderer/Shader.cpp
|
MiloHX/Parrot
|
159f583b2e43396dcc42dc3456a9c5d3fb043133
|
[
"Apache-2.0"
] | null | null | null |
parrot/src/parrot/renderer/Shader.cpp
|
MiloHX/Parrot
|
159f583b2e43396dcc42dc3456a9c5d3fb043133
|
[
"Apache-2.0"
] | null | null | null |
#include "prpch.h"
#include "parrot/renderer/Shader.h"
#include "parrot/renderer/Renderer.h"
#include "platform/OpenGL/OpenGLShader.h"
namespace parrot {
Ref<Shader> Shader::create(const std::string& file_path) {
switch (Renderer::getAPI()) {
case RendererAPI::API::None:
PR_CORE_ASSERT(false, "RendererAPI::None is not supported");
return nullptr;
case RendererAPI::API::OpenGL:
return createRef<OpenGLShader>(file_path);
}
PR_CORE_ASSERT(false, "Unknown RendererAPI when creating shader");
return nullptr;
}
Ref<Shader> Shader::create(const std::string& name, const std::string& vertex_source, const std::string& fragment_source) {
switch (Renderer::getAPI()) {
case RendererAPI::API::None:
PR_CORE_ASSERT(false, "RendererAPI::None is not supported");
return nullptr;
case RendererAPI::API::OpenGL:
return createRef<OpenGLShader>(name, vertex_source, fragment_source);
}
PR_CORE_ASSERT(false, "Unknown RendererAPI when creating shader");
return nullptr;
}
void ShaderLibrary::add(const Ref<Shader>& shader) {
auto& name = shader->getName();
add(name, shader);
}
void ShaderLibrary::add(const std::string& name, const Ref<Shader>& shader) {
PR_CORE_ASSERT(!exists(name), "Shader already exists")
m_shader_map[name] = shader;
}
Ref<Shader> ShaderLibrary::load(const std::string& file_path) {
auto shader = Shader::create(file_path);
add(shader);
return shader;
}
Ref<Shader> ShaderLibrary::load(const std::string& name, const std::string& file_path) {
auto shader = Shader::create(file_path);
add(name, shader);
return shader;
}
Ref<Shader> ShaderLibrary::get(const std::string& name) {
PR_CORE_ASSERT(exists(name), "Shader not found!")
return m_shader_map[name];
}
bool ShaderLibrary::exists(const std::string& name) const {
return m_shader_map.find(name) != m_shader_map.end();
}
}
| 34.967742
| 127
| 0.625
|
MiloHX
|
97e987f22301e3c4da2ea659edd61b2616906de1
| 4,525
|
cpp
|
C++
|
uppsrc/CtrlLib/DropTree.cpp
|
dreamsxin/ultimatepp
|
41d295d999f9ff1339b34b43c99ce279b9b3991c
|
[
"BSD-2-Clause"
] | 2
|
2016-04-07T07:54:26.000Z
|
2020-04-14T12:37:34.000Z
|
uppsrc/CtrlLib/DropTree.cpp
|
dreamsxin/ultimatepp
|
41d295d999f9ff1339b34b43c99ce279b9b3991c
|
[
"BSD-2-Clause"
] | 1
|
2021-04-06T21:57:39.000Z
|
2021-04-06T21:57:39.000Z
|
uppsrc/CtrlLib/DropTree.cpp
|
dreamsxin/ultimatepp
|
41d295d999f9ff1339b34b43c99ce279b9b3991c
|
[
"BSD-2-Clause"
] | 3
|
2017-08-26T12:06:05.000Z
|
2019-11-22T16:57:47.000Z
|
#include "CtrlLib.h"
namespace Upp {
CH_VALUE(TreeDropEdge, ChBorder(BlackBorder()));
CtrlFrame& TreeDropFrame()
{
static LookFrame m(TreeDropEdge);
return m;
}
PopUpTree::PopUpTree() {
SetFrame(TreeDropFrame());
Accel();
MouseMoveCursor();
NoPopUpEx();
SetDropLines(16);
open = autosize = false;
showpos = Null;
WhenOpen = WhenClose = THISBACK(OpenClose);
}
PopUpTree::~PopUpTree() {}
void PopUpTree::CancelMode() {
if(open) {
DoClose();
WhenCancel();
}
TreeCtrl::CancelMode();
}
void PopUpTree::DoClose() {
open = false;
Ctrl::Close();
}
void PopUpTree::Deactivate() {
if(open) {
DoClose();
IgnoreMouseClick();
WhenCancel();
}
}
void PopUpTree::Select() {
if(IsCursor() && !GetData().IsVoid()) {
DoClose();
WhenSelect();
}
}
bool PopUpTree::Key(dword key, int n) {
switch(key) {
case K_ENTER:
case K_ALT_DOWN:
DoClose();
WhenSelect();
return true;
case K_ESCAPE:
DoClose();
WhenCancel();
return true;
}
return TreeCtrl::Key(key, n);
}
void PopUpTree::PopUp(Ctrl *owner, int x, int top, int bottom, int width) {
DoClose();
Rect area = Ctrl::GetWorkArea();
int mh = min(maxheight, area.bottom - bottom);
int h = AddFrameSize(width, maxheight).cy;
showpos.x = x;
showpos.y = bottom;
showwidth = width;
up = false;
if(showpos.y + h > area.bottom) {
up = true;
showpos.y = top;
}
open = false;
int ht = AddFrameSize(width, min(mh, autosize ? GetTreeSize().cy : INT_MAX)).cy;
Rect rt = RectC(showpos.x, showpos.y - (up ? ht : 0), showwidth, ht);
if(GUI_PopUpEffect()) {
bool vis = sb.x.IsShown();
bool ah = sb.x.IsAutoHide();
sb.AutoHide(false);
sb.Hide();
sPaintRedirectCtrl pb;
pb.ctrl = this;
if(up) {
SetRect(Rect(rt.left, rt.bottom - 1, rt.right, rt.bottom));
Ctrl::Add(pb.TopPos(0, rt.Height()).LeftPos(0, rt.Width()));
}
else {
SetRect(Rect(rt.left, rt.top, rt.right, rt.top + 1));
Ctrl::Add(pb.BottomPos(0, rt.Height()).LeftPos(0, rt.Width()));
}
CenterCursor();
Ctrl::PopUp(owner, true, true, GUI_DropShadows());
SetFocus();
Ctrl::ProcessEvents();
Animate(*this, rt, GUIEFFECT_SLIDE);
Ctrl::Remove();
sb.Show(vis);
sb.AutoHide(ah);
pb.Remove();
open = true;
}
CenterCursor();
SetRect(rt);
if(!open)
Ctrl::PopUp(owner, true, true, GUI_DropShadows());
SetFocus();
open = true;
}
void PopUpTree::OpenClose(int)
{
if(autosize) {
SyncTree();
Rect area = Ctrl::GetWorkArea();
int mh = min(maxheight, area.bottom - showpos.y);
int ht = AddFrameSize(showwidth, min(mh, GetTreeSize().cy)).cy;
SetRect(RectC(showpos.x, showpos.y - (up ? ht : 0), showwidth, ht));
}
}
void PopUpTree::PopUp(Ctrl *owner, int width)
{
Rect r = owner->GetScreenRect();
r.right = r.left + width;
PopUp(owner, r.left, r.top, r.bottom, width);
if(IsNull(showpos))
showpos = r.TopLeft();
OpenClose(0);
}
void PopUpTree::PopUp(Ctrl *owner)
{
Rect r = owner->GetScreenRect();
PopUp(owner, r.left, r.top, r.bottom, r.Width());
}
void DropTree::Sync() {
Image icon;
if(tree.IsCursor())
icon = tree.GetNode(tree.GetCursor()).image;
icond.Set(valuedisplay ? *valuedisplay : tree.GetDisplay(tree.GetCursor()), icon);
MultiButton::SetDisplay(icond);
Set(tree.GetValue());
}
bool DropTree::Key(dword k, int) {
if(IsReadOnly()) return false;
if(k == K_ALT_DOWN) {
Drop();
return true;
}
return false;
}
void DropTree::Drop() {
if(IsReadOnly()) return;
if(dropfocus)
SetFocus();
WhenDrop();
tree.PopUp(this, GetRect().GetWidth());
}
void DropTree::Select() {
if(dropfocus)
SetFocus();
Sync();
UpdateAction();
}
void DropTree::Cancel() {
if(dropfocus)
SetFocus();
Sync();
}
void DropTree::Clear() {
tree.Clear();
tree <<= Null;
Sync();
Update();
}
void DropTree::SetData(const Value& data)
{
if(tree.Get() != data) {
tree <<= data;
Update();
Sync();
}
}
Value DropTree::GetData() const
{
return notnull && IsNull(tree.Get()) ? NotNullError() : tree.Get();
}
DropTree& DropTree::ValueDisplay(const Display& d)
{
valuedisplay = &d;
Sync();
return *this;
}
DropTree::DropTree()
{
displayall = false;
valuedisplay = NULL;
dropfocus = false;
notnull = false;
AddButton().Main().WhenPush = THISBACK(Drop);
NoInitFocus();
tree.WhenSelect = THISBACK(Select);
tree.WhenCancel = THISBACK(Cancel);
dropwidth = 0;
}
};
| 19.759825
| 84
| 0.615691
|
dreamsxin
|
97ea9746475e69d636022c161a72c557f296e6d9
| 2,318
|
cpp
|
C++
|
unittest/splitter/splitter.cpp
|
relick/tls
|
a9ef85384e0b6394d94daf7798891f8ee4aa31ac
|
[
"MIT"
] | null | null | null |
unittest/splitter/splitter.cpp
|
relick/tls
|
a9ef85384e0b6394d94daf7798891f8ee4aa31ac
|
[
"MIT"
] | null | null | null |
unittest/splitter/splitter.cpp
|
relick/tls
|
a9ef85384e0b6394d94daf7798891f8ee4aa31ac
|
[
"MIT"
] | null | null | null |
#include <execution>
#include <tls/splitter.h>
#include "../catch.hpp"
TEST_CASE("tls::splitter<> specification") {
SECTION("new instances are default initialized") {
struct test {
int x = 4;
};
REQUIRE(tls::splitter<int>().local() == int{});
REQUIRE(tls::splitter<double>().local() == double{});
REQUIRE(tls::splitter<test>().local().x == test{}.x);
}
SECTION("does not cause data races") {
std::vector<int> vec(1024 * 1024, 1);
tls::splitter<int> acc;
std::for_each(std::execution::par, vec.begin(), vec.end(), [&acc](int const& i) { acc.local() += i; });
int result = std::reduce(acc.begin(), acc.end());
REQUIRE(result == 1024 * 1024);
}
SECTION("clearing after use cleans up properly") {
std::vector<int> vec(1024, 1);
tls::splitter<int> acc;
std::for_each(std::execution::par, vec.begin(), vec.end(), [&acc](int const& i) { acc.local() += i; });
acc.clear();
int result = std::reduce(acc.begin(), acc.end());
REQUIRE(result == 0);
}
SECTION("multiple instances points to the same data") {
tls::splitter<int> s1, s2, s3;
s1.local() = 1;
s2.local() = 2;
s3.local() = 3;
CHECK(s1.local() == 3);
CHECK(s2.local() == 3);
CHECK(s3.local() == 3);
tls::splitter<int, bool> s4;
tls::splitter<int, char> s5;
tls::splitter<int, short> s6;
tls::splitter<int, void> s7; // same as splitter<int> s1,s2,s3
s4.local() = 1;
s5.local() = 2;
s6.local() = 3;
CHECK(s4.local() == 1);
CHECK(s5.local() == 2);
CHECK(s6.local() == 3);
CHECK(s7.local() == 3);
}
SECTION("tls::splitter<> variables can be copied") {
std::vector<int> vec(1024 * 1024, 1);
tls::splitter<int> acc;
std::for_each(std::execution::par, vec.begin(), vec.end(), [&acc](int const& i) { acc.local() += i; });
tls::splitter<int> const acc_copy = acc;
int const result = std::reduce(acc.begin(), acc.end());
acc.clear();
CHECK(result == 1024 * 1024);
int const result_copy = std::reduce(acc_copy.begin(), acc_copy.end());
CHECK(result == result_copy);
}
}
| 31.324324
| 111
| 0.52761
|
relick
|
97ebafe714b489aff42b63d3d3702660ca97c4c9
| 3,165
|
cxx
|
C++
|
bpkg/types-parsers.cxx
|
build2/bpkg
|
bd939839b44d90d027517e447537dd52539269ff
|
[
"MIT"
] | 19
|
2018-05-30T12:01:25.000Z
|
2022-01-29T21:37:23.000Z
|
bpkg/types-parsers.cxx
|
build2/bpkg
|
bd939839b44d90d027517e447537dd52539269ff
|
[
"MIT"
] | 2
|
2019-03-18T22:31:45.000Z
|
2020-07-28T06:44:03.000Z
|
bpkg/types-parsers.cxx
|
build2/bpkg
|
bd939839b44d90d027517e447537dd52539269ff
|
[
"MIT"
] | 1
|
2019-02-04T02:58:14.000Z
|
2019-02-04T02:58:14.000Z
|
// file : bpkg/types-parsers.cxx -*- C++ -*-
// license : MIT; see accompanying LICENSE file
#include <bpkg/types-parsers.hxx>
namespace bpkg
{
namespace cli
{
void parser<url>::
parse (url& x, bool& xs, scanner& s)
{
const char* o (s.next ());
if (!s.more ())
throw missing_value (o);
const char* v (s.next ());
try
{
x = url (v);
}
catch (const invalid_argument& e)
{
throw invalid_value (o, v, e.what ());
}
xs = true;
}
template <typename T>
static void
parse_path (T& x, scanner& s)
{
const char* o (s.next ());
if (!s.more ())
throw missing_value (o);
const char* v (s.next ());
try
{
x = T (v);
if (x.empty ())
throw invalid_value (o, v);
}
catch (const invalid_path&)
{
throw invalid_value (o, v);
}
}
void parser<path>::
parse (path& x, bool& xs, scanner& s)
{
xs = true;
parse_path (x, s);
}
void parser<dir_path>::
parse (dir_path& x, bool& xs, scanner& s)
{
xs = true;
parse_path (x, s);
}
void parser<uuid>::
parse (uuid& x, bool& xs, scanner& s)
{
xs = true;
const char* o (s.next ());
if (!s.more ())
throw missing_value (o);
const char* v (s.next ());
try
{
x = uuid (v);
if (x.nil ())
throw invalid_value (o, v);
}
catch (const invalid_argument&)
{
throw invalid_value (o, v);
}
}
void parser<butl::standard_version>::
parse (butl::standard_version& x, bool& xs, scanner& s)
{
using butl::standard_version;
xs = true;
const char* o (s.next ());
if (!s.more ())
throw missing_value (o);
const char* v (s.next ());
try
{
// Note that we allow all kinds of versions, so that the caller can
// restrict them as they wish after the parsing.
//
x = standard_version (v,
standard_version::allow_earliest |
standard_version::allow_stub);
}
catch (const invalid_argument& e)
{
throw invalid_value (o, v, e.what ());
}
}
void parser<auth>::
parse (auth& x, bool& xs, scanner& s)
{
xs = true;
const char* o (s.next ());
if (!s.more ())
throw missing_value (o);
const string v (s.next ());
if (v == "none")
x = auth::none;
else if (v == "remote")
x = auth::remote;
else if (v == "all")
x = auth::all;
else
throw invalid_value (o, v);
}
void parser<repository_type>::
parse (repository_type& x, bool& xs, scanner& s)
{
xs = true;
const char* o (s.next ());
if (!s.more ())
throw missing_value (o);
const string v (s.next ());
try
{
x = to_repository_type (v);
}
catch (const invalid_argument&)
{
throw invalid_value (o, v);
}
}
}
}
| 19.066265
| 75
| 0.473934
|
build2
|
97ecdd04a7d87b1c52a06075aa9abd8c6990c1b2
| 770
|
cc
|
C++
|
base/containers/flag_set_test.cc
|
mayah/base
|
aec046929938d2aaebaadce5c5abb58b5cf342b4
|
[
"MIT"
] | null | null | null |
base/containers/flag_set_test.cc
|
mayah/base
|
aec046929938d2aaebaadce5c5abb58b5cf342b4
|
[
"MIT"
] | null | null | null |
base/containers/flag_set_test.cc
|
mayah/base
|
aec046929938d2aaebaadce5c5abb58b5cf342b4
|
[
"MIT"
] | null | null | null |
#include "base/containers/flag_set.h"
#include <gtest/gtest.h>
TEST(FlagSetTest, basic)
{
base::FlagSet s;
EXPECT_TRUE(s.empty());
EXPECT_EQ(0, s.size());
s.set(0);
s.set(1);
s.set(5);
s.set(8);
s.set(16);
s.set(31);
s.set(31);
s.set(63);
EXPECT_EQ(7, s.size());
s.unset(8);
EXPECT_EQ(6, s.size());
EXPECT_EQ(0, s.smallest());
s.remove_smallest();
EXPECT_EQ(1, s.smallest());
s.remove_smallest();
EXPECT_EQ(5, s.smallest());
s.remove_smallest();
EXPECT_EQ(16, s.smallest());
s.remove_smallest();
EXPECT_EQ(31, s.smallest());
s.remove_smallest();
EXPECT_EQ(63, s.smallest());
s.remove_smallest();
EXPECT_TRUE(s.empty());
EXPECT_EQ(0, s.size());
}
| 16.73913
| 37
| 0.568831
|
mayah
|
97f349dfc87fcba4188322e893a6f26fd9c42b84
| 1,516
|
cpp
|
C++
|
core/vulkan/vk_memory_tracker_layer/cc/layer_helpers.cpp
|
isabella232/gapid
|
bee6c18117577f871a4737a6be77af04c6f11577
|
[
"Apache-2.0"
] | 2,100
|
2017-03-06T02:39:43.000Z
|
2022-03-30T07:49:26.000Z
|
core/vulkan/vk_memory_tracker_layer/cc/layer_helpers.cpp
|
isabella232/gapid
|
bee6c18117577f871a4737a6be77af04c6f11577
|
[
"Apache-2.0"
] | 1,994
|
2017-03-06T02:15:02.000Z
|
2022-03-29T22:06:12.000Z
|
core/vulkan/vk_memory_tracker_layer/cc/layer_helpers.cpp
|
isabella232/gapid
|
bee6c18117577f871a4737a6be77af04c6f11577
|
[
"Apache-2.0"
] | 351
|
2017-03-06T06:43:35.000Z
|
2022-03-30T01:14:27.000Z
|
/*
* Copyright (C) 2019 Google 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.
*
*/
#include "core/cc/log.h"
#include "core/cc/target.h"
extern "C" {
__attribute__((constructor)) void _layer_dummy_func__();
}
#if (TARGET_OS == GAPID_OS_WINDOWS) || (TARGET_OS == GAPID_OS_OSX)
class dummy_struct {};
#else
#include <dlfcn.h>
#include <cstdint>
#include <cstdio>
class dummy_struct {
public:
dummy_struct();
};
dummy_struct::dummy_struct() {
GAPID_ERROR("Loading dummy struct");
Dl_info info;
if (dladdr((void*)&_layer_dummy_func__, &info)) {
dlopen(info.dli_fname, RTLD_NODELETE);
}
}
#endif
extern "C" {
// _layer_dummy_func__ is marked __attribute__((constructor))
// this means on .so open, it will be called. Once that happens,
// we create a dummy struct, which on Android and Linux,
// Forces the layer to never be unloaded. There is some global
// state in perfetto producers that does not like being unloaded.
void _layer_dummy_func__() {
dummy_struct d;
(void)d;
}
}
| 28.074074
| 75
| 0.723615
|
isabella232
|
97fa2a64a9aba5feceda8a56215f77ef3f95c38c
| 10,789
|
cpp
|
C++
|
CommonWalkingControlModules/csrc/ActiveSetQP/QP.cpp
|
wxmerkt/ihmc-open-robotics-software
|
2c47c9a9bd999e7811038e99c3888683f9973a2a
|
[
"Apache-2.0"
] | 170
|
2016-02-01T18:58:50.000Z
|
2022-03-17T05:28:01.000Z
|
CommonWalkingControlModules/csrc/ActiveSetQP/QP.cpp
|
wxmerkt/ihmc-open-robotics-software
|
2c47c9a9bd999e7811038e99c3888683f9973a2a
|
[
"Apache-2.0"
] | 162
|
2016-01-29T17:04:29.000Z
|
2022-02-10T16:25:37.000Z
|
CommonWalkingControlModules/csrc/ActiveSetQP/QP.cpp
|
wxmerkt/ihmc-open-robotics-software
|
2c47c9a9bd999e7811038e99c3888683f9973a2a
|
[
"Apache-2.0"
] | 83
|
2016-01-28T22:49:01.000Z
|
2022-03-28T03:11:24.000Z
|
#include <math.h>
#include <iostream>
#include <Eigen/Cholesky>
#include <Eigen/LU>
#include <Eigen/SVD>
#include "fastQP.h"
#define _USE_MATH_DEFINES
extern "C"
{
int MAX_ITER = -1; // default: #equality constraints
}
using namespace Eigen;
using namespace std;
//template <typename tA, typename tB, typename tC, typename tD, typename tE, typename tF, typename tG>
//int fastQPThatTakesQinv(vector< MatrixBase<tA>* > QinvblkDiag, const MatrixBase<tB>& f, const MatrixBase<tC>& Aeq, const MatrixBase<tD>& beq, const MatrixBase<tE>& Ain, const MatrixBase<tF>& bin, set<int>& active, MatrixBase<tG>& x)
int fastQPThatTakesQinv(vector< MatrixXd* > QinvblkDiag, const VectorXd& f, const MatrixXd& Aeq, const VectorXd& beq, const MatrixXd& Ain, const VectorXd& bin, set<int>& active, VectorXd& x)
{
int max_iter = (MAX_ITER<0? (Aeq.rows()+Ain.rows()): MAX_ITER);
int i,d;
int iterCnt = 0;
int M_in = bin.size();
int M = Aeq.rows();
int N = Aeq.cols();
if (f.rows() != N) { cerr << "size of f (" << f.rows() << " by " << f.cols() << ") doesn't match cols of Aeq (" << Aeq.rows() << " by " << Aeq.cols() << ")" << endl; return -4; }
if (beq.rows() !=M) { cerr << "size of beq doesn't match rows of Aeq" << endl; return -4; }
if (Ain.cols() !=N) { cerr << "cols of Ain doesn't match cols of Aeq" << endl; return -4; };
if (bin.rows() != Ain.rows()) { cerr << "bin rows doesn't match Ain rows" << endl; return -4; };
if (x.rows() != N) { cerr << "x doesn't match Aeq" << endl; return -4; }
int n_active = active.size();
MatrixXd Aact = MatrixXd(n_active, N);
VectorXd bact = VectorXd(n_active);
MatrixXd QinvAteq(N,M);
VectorXd minusQinvf(N);
// calculate a bunch of stuff that is constant during each iteration
int startrow=0;
// for (typename vector< MatrixBase<tA>* >::iterator iterQinv=QinvblkDiag.begin(); iterQinv!=QinvblkDiag.end(); iterQinv++) {
// MatrixBase<tA> *thisQinv = *iterQinv;
for (vector< MatrixXd* >::iterator iterQinv=QinvblkDiag.begin(); iterQinv!=QinvblkDiag.end(); iterQinv++) {
MatrixXd *thisQinv = *iterQinv;
int numRow = thisQinv->rows();
int numCol = thisQinv->cols();
if (numRow == 1 || numCol == 1) { // it's a vector
d = numRow*numCol;
if (M>0) QinvAteq.block(startrow,0,d,M)= thisQinv->asDiagonal()*Aeq.block(0,startrow,M,d).transpose(); // Aeq.transpoODse().block(startrow,0,d,N)
minusQinvf.segment(startrow,d) = -thisQinv->cwiseProduct(f.segment(startrow,d));
startrow=startrow+d;
} else { // potentially dense matrix
d = numRow;
if (numRow!=numCol) {
cerr << "Q is not square! " << numRow << "x" << numCol << "\n";
return -2;
}
if (M>0)
QinvAteq.block(startrow,0,d,M) = thisQinv->operator*(Aeq.block(0,startrow,M,d).transpose()); // Aeq.transpose().block(startrow,0,d,N)
minusQinvf.segment(startrow,d) = -thisQinv->operator*(f.segment(startrow,d));
startrow=startrow+d;
}
if (startrow>N) {
cerr << "Q is too big!" << endl;
return -2;
}
}
if (startrow!=N) { cerr << "Q is the wrong size. Got " << startrow << "by" << startrow << " but needed " << N << "by" << N << endl; return -2; }
MatrixXd A;
VectorXd b;
MatrixXd QinvAt;
VectorXd lam, lamIneq;
VectorXd violated(M_in);
VectorXd violation;
while(1) {
iterCnt++;
n_active = active.size();
Aact.resize(n_active,N);
bact.resize(n_active);
i=0;
for (set<int>::iterator iter=active.begin(); iter!=active.end(); iter++) {
if (*iter<0 || *iter>=Ain.rows()) {
return -3; // active set is invalid. exit quietly, because this is expected behavior in normal operation (e.g. it means I should immediately kick out to gurobi)
}
Aact.row(i) = Ain.row(*iter);
bact(i++) = bin(*iter);
}
A.resize(Aeq.rows() + Aact.rows(),N);
b.resize(beq.size() + bact.size());
A << Aeq,Aact;
b << beq,bact;
if (A.rows() > 0) {
//Solve H * [x;lam] = [-f;b] using Schur complements, H = [Q,At';A,0];
QinvAt.resize(QinvAteq.rows(), QinvAteq.cols() + Aact.rows());
if (n_active>0) {
int startrow=0;
for (vector< MatrixXd* >::iterator iterQinv=QinvblkDiag.begin(); iterQinv!=QinvblkDiag.end(); iterQinv++) {
MatrixXd* thisQinv = (*iterQinv);
d = thisQinv->rows();
int numCol = thisQinv->cols();
if (numCol == 1) { // it's a vector
QinvAt.block(startrow,0,d,M+n_active) << QinvAteq.block(startrow,0,d,M), thisQinv->asDiagonal()*Aact.block(0,startrow,n_active,d).transpose();
} else { // it's a matrix
QinvAt.block(startrow,0,d,M+n_active) << QinvAteq.block(startrow,0,d,M), thisQinv->operator*(Aact.block(0,startrow,n_active,d).transpose());
}
startrow=startrow+d;
}
} else {
QinvAt = QinvAteq;
}
lam.resize(QinvAt.cols());
#if 1
lam = -(A*QinvAt).ldlt().solve(b + (f.transpose()*QinvAt).transpose());
//lam = -(A*QinvAt + MatrixXd::Identity(A.rows(),A.rows())*1e-4).ldlt().solve(b + (f.transpose()*QinvAt).transpose());
#else
JacobiSVD<MatrixXd> svd(A*QinvAt , ComputeThinU | ComputeThinV);
lam = -svd.solve(b + (f.transpose()*QinvAt).transpose());
SingularValueType sigmas=svd.singularValues();
#endif
x = minusQinvf - QinvAt*lam;
lamIneq = lam.tail(lam.size() - M);
} else {
x = minusQinvf;
lamIneq.resize(0);
}
if(Ain.rows() == 0) {
active.clear();
break;
}
set<int> new_active;
violation = Ain*x - bin;
for (i=0; i<M_in; i++)
if (violation(i) >= 1e-6)
new_active.insert(i);
bool all_pos_mults = true;
for (i=0; i<n_active; i++) {
if (lamIneq(i)<0) {
all_pos_mults = false;
break;
}
}
if (new_active.empty() && all_pos_mults) {
// existing active was AOK
break;
}
i=0;
set<int>::iterator iter=active.begin(), tmp;
while (iter!=active.end()) { // to accomodating inloop erase
tmp = iter++;
if (lamIneq(i++)<0) {
active.erase(tmp);
}
}
active.insert(new_active.begin(),new_active.end());
if (iterCnt > max_iter) {
return -1;
}
}
return iterCnt;
}
//template <typename tA, typename tB, typename tC, typename tD, typename tE, typename tF, typename tG>
//int fastQP(vector< MatrixBase<tA>* > QblkDiag, const MatrixBase<tB>& f, const MatrixBase<tC>& Aeq, const MatrixBase<tD>& beq, const MatrixBase<tE>& Ain, const MatrixBase<tF>& bin, set<int>& active, MatrixBase<tG>& x)
int fastQP(vector< MatrixXd* > QblkDiag, const VectorXd& f, const MatrixXd& Aeq, const VectorXd& beq, const MatrixXd& Ain, const VectorXd& bin, set<int>& active, VectorXd& x)
{
/* min 1/2 * x'QblkDiag'x + f'x s.t A x = b, Ain x <= bin
* using active set method. Iterative solve a linearly constrained
* quadratic minimization problem where linear constraints include
* Ain(active,:)x == bin(active). Quit if all dual variables associated
* with these equations are positive (i.e. they satisfy KKT conditions).
*
* Note:
* fails if QP is infeasible.
* active == initial rows of Ain to treat as equations.
* Frank Permenter - June 6th 2013
*
* @retval if feasible then iterCnt, else -1 for infeasible, -2 for input error
*/
int N = f.rows();
MatrixXd* Qinv = new MatrixXd[QblkDiag.size()];
vector< MatrixXd* > Qinvmap;
#define REG 0.0
// calculate a bunch of stuff that is constant during each iteration
int startrow=0;
//typedef typename vector< MatrixBase<tA> >::iterator Qiterator;
int i=0;
for (vector< MatrixXd* >::iterator iterQ=QblkDiag.begin(); iterQ!=QblkDiag.end(); iterQ++) {
MatrixXd* thisQ = *iterQ;
int numRow = thisQ->rows();
int numCol = thisQ->cols();
if (numCol == 1) { // it's a vector
VectorXd Qdiag_mod = thisQ->operator+(VectorXd::Constant(numRow,REG)); // regularize
Qinv[i] = Qdiag_mod.cwiseInverse();
Qinvmap.push_back( &Qinv[i] );
startrow=startrow+numRow;
}
else
{ // potentially dense matrix
if (numRow!=numCol) {
if (numRow==1)
cerr << "diagonal Q's must be set as column vectors" << endl;
else
cerr << "Q is not square! " << numRow << "x" << numCol << endl;
return -2;
}
MatrixXd Q_mod = thisQ->operator+(REG*MatrixXd::Identity(numRow,numRow));
Qinv[i] = Q_mod.inverse();
Qinvmap.push_back( &Qinv[i] );
startrow=startrow+numRow;
}
// cout << "Qinv{" << i << "} = " << Qinv[i] << endl;
if (startrow>N) {
cerr << "Q is too big!" << endl;
return -2;
}
i++;
}
if (startrow!=N) { cerr << "Q is the wrong size. Got " << startrow << "by" << startrow << " but needed " << N << "by" << N << endl; return -2; }
int info = fastQPThatTakesQinv(Qinvmap,f,Aeq,beq,Ain,bin,active,x);
delete[] Qinv;
return info;
}
/* Example call (allocate inequality matrix, call function, resize inequalites:
VectorXd binBnd = VectorXd(2*N);
AinBnd.setZero();
int numIneq = boundToIneq(ub,lb,AinBnd,binBnd);
AinBnd.resize(numIneq,N);
binBnd.resize(numIneq);
*/
/*
int boundToIneq(const VectorXd& uB,const VectorXd& lB, MatrixXd& Ain, VectorXd& bin)
{
int rCnt = 0;
int cCnt = 0;
if (uB.rows()+lB.rows() > A.rows() ) {
cerr << "not enough memory allocated";
}
if (uB.rows()+lB.rows() > b.rows() ) {
cerr << "not enough memory allocated";
}
for (int i = 0; i < lB.rows(); i++ ) {
if (!isinf(lB(i))) {
cout << lB(i);
cout << i;
Ain(rCnt,cCnt++) = -1;//lB(i);
bin(rCnt++) = -lB(i);
}
}
cCnt = 0;
for (int i = 0; i < uB.rows(); i++ ) {
if (!isinf(uB(i))) {
Ain(rCnt,cCnt++) = 1;//uB(i);
bin(rCnt++) = uB(i);
}
}
//resizing inside function all causes exception (why??)
//A.resize(rCnt,uB.rows());
return rCnt;
}
*/
/*
template int fastQP(vector< MatrixBase<MatrixXd>* > QblkDiag, const MatrixBase< Map<VectorXd> >&, const MatrixBase< Map<MatrixXd> >&, const MatrixBase< Map<VectorXd> >&, const MatrixBase< Map<MatrixXd> >&, const MatrixBase< Map<VectorXd> >&, set<int>&, MatrixBase< Map<VectorXd> >&);
template GRBmodel* gurobiQP(GRBenv *env, vector< MatrixBase<MatrixXd>* > QblkDiag, VectorXd& f, const MatrixBase< Map<MatrixXd> >& Aeq, const MatrixBase< Map<VectorXd> >& beq, const MatrixBase< Map<MatrixXd> >& Ain, const MatrixBase< Map<VectorXd> >&bin, VectorXd& lb, VectorXd& ub, set<int>&, VectorXd&);
template GRBmodel* gurobiQP(GRBenv *env, vector< MatrixBase<MatrixXd>* > QblkDiag, VectorXd& f, const MatrixBase< MatrixXd >& Aeq, const MatrixBase< VectorXd >& beq, const MatrixBase< MatrixXd >& Ain, const MatrixBase< VectorXd >&bin, VectorXd&lb, VectorXd&ub, set<int>&, VectorXd&);
*/
/*
template int fastQP(vector< MatrixBase< VectorXd > >, const MatrixBase< VectorXd >&, const MatrixBase< Matrix<double,-1,-1,RowMajor,1000,-1> >&, const MatrixBase< Matrix<double,-1,1,0,1000,1> >&, const MatrixBase< Matrix<double,-1,-1,RowMajor,1000,-1> >&, const MatrixBase< Matrix<double,-1,1,0,1000,1> >&, set<int>&, MatrixBase< VectorXd >&);
*/
| 33.927673
| 346
| 0.634721
|
wxmerkt
|