blob_id stringlengths 40 40 | directory_id stringlengths 40 40 | path stringlengths 2 247 | content_id stringlengths 40 40 | detected_licenses listlengths 0 57 | license_type stringclasses 2 values | repo_name stringlengths 4 111 | snapshot_id stringlengths 40 40 | revision_id stringlengths 40 40 | branch_name stringlengths 4 58 | visit_date timestamp[ns]date 2015-07-25 18:16:41 2023-09-06 10:45:08 | revision_date timestamp[ns]date 1970-01-14 14:03:36 2023-09-06 06:22:19 | committer_date timestamp[ns]date 1970-01-14 14:03:36 2023-09-06 06:22:19 | github_id int64 3.89k 689M ⌀ | star_events_count int64 0 209k | fork_events_count int64 0 110k | gha_license_id stringclasses 25 values | gha_event_created_at timestamp[ns]date 2012-06-07 00:51:45 2023-09-14 21:58:52 ⌀ | gha_created_at timestamp[ns]date 2008-03-27 23:40:48 2023-08-24 19:49:39 ⌀ | gha_language stringclasses 159 values | src_encoding stringclasses 34 values | language stringclasses 1 value | is_vendor bool 1 class | is_generated bool 2 classes | length_bytes int64 7 10.5M | extension stringclasses 111 values | filename stringlengths 1 195 | text stringlengths 7 10.5M |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
e17fd4ea554936a23d5024ce5a6771d89f7d2c14 | 953f6168be9b2792b94e94d69f5ce3cf4b954155 | /Box-volume-surfaceArea/Box.cpp | be1da509f372ff13787fe54a628cd72145efc425 | [] | no_license | bdcarter/Intro1CPPassignments-projects | 5ed851c95b2d2fd65df1030e08489f3e1ae6fa2d | ff7e0f26609e3115c31ecd5876dd28b9f66ddf18 | refs/heads/master | 2020-12-24T16:50:34.000318 | 2015-09-11T05:06:40 | 2015-09-11T05:06:40 | 42,286,267 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,125 | cpp | Box.cpp | /***********************************************************
* Author: Brianna Carter
* Date Created: 2/6/2015
* Date Edited: 2/6/2015
*
* This file contains the member function definitions and a
* program that calculates the volume and surface area for
* a box with given dimensions.
* ********************************************************/
#include <iomanip>
#include <iostream>
#include <cmath>
#include "Box.hpp"
using namespace std;
/****************************************
* Default constructor
* ************************************/
Box::Box()
{
height = 1;
length = 1;
width = 1;
}
/****************************************
* Box::Box(double h, double w, double L)
* Pass variables to set methods.
***************************************/
Box::Box(double heightIn, double widthIn, double lengthIn)
{
setHeight(heightIn);
setWidth(widthIn);
setLength(lengthIn);
}
/***************************************
* Box::setHeight(double heightIn)
* Check for negative input and assign
* variables
*************************************/
void Box::setHeight(double heightIn)
{
if (heightIn < 0)
{cout << "Negative numbers not accepted." << endl;
height = 0;
}
else
{height = heightIn;}
cout << "Height: " << height << endl;
}
/**************************************
* Box::setWidth(double widthIn)
* Test for negative input
* **********************************/
void Box::setWidth(double widthIn)
{
if(widthIn < 0)
{cout << "Negative numbers not accepted." << endl;
width = 0;
}
else
{width = widthIn;}
cout << "Width: " << width << endl;
}
/**************************************
* Box::setLength(double lengthIn)
* Test for negative input
* **********************************/
void Box::setLength(double lengthIn)
{
if(lengthIn < 0)
{cout << "negative numbers not accepted." << endl;
length = 0;
}
else
{length = lengthIn;}
cout << "Length: " << length << endl;
}
/*****************************************
* Box::getVolume()
* Calculates the volume of the box.
* **************************************/
double Box::getVolume()
{ return (length * height * width);}
/*****************************************
* Box::getSurfaceArea
* Calculates surface area of the box.
* *************************************/
double Box::getSurfaceArea()
{return ((2*length*width) + (2*length*height) + (2*width*height));}
/******************************************
* Main function
* **************************************/
main()
{
Box cube;
double heightIn;
double widthIn;
double lengthIn;
//get dimensions
cout << "Please enter the height." << endl;
cin >> heightIn;
cout << "Please enter the width." << endl;
cin >> widthIn;
cout << "Please enter the length." << endl;
cin >> lengthIn;
//Send dimensions to set members
cube.setHeight(heightIn);
cube.setWidth(widthIn);
cube.setLength(lengthIn);
cout << fixed << setprecision(1) << endl;
//Calculate volume and surface area
cout << "The volume of the box is: " << cube.getVolume();
cout << endl;
cout << "The Surface Area is: " << cube.getSurfaceArea();
cout << endl;
return 0;
}
|
fc26896e1555b441b18919365a552b0897d320cf | b357ff3668751152c3357d579e8db8c8ced2ee83 | /src/decode-task.cc | 7f222fa0dfb55ee4d0ceb10ddd48030d591fed90 | [] | no_license | xushoucai/xdecoder | da9a6ef74951cb945ddab82bfe8bcdbe1c26fc3b | 86c7decca886f4e4eaec28f8baf83086a709d797 | refs/heads/master | 2020-05-02T12:18:44.936618 | 2018-07-12T08:37:47 | 2018-07-12T08:37:47 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,226 | cc | decode-task.cc | // Copyright (c) 2018 Personal (Binbin Zhang)
// Created on 2018-06-28
//
// 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 <sstream>
#include <string>
#include <vector>
#include "decode-task.h"
namespace xdecoder {
void DecodeTask::operator() (void *resource) {
Net* net = reinterpret_cast<Net*>(resource);
FeaturePipeline feature_pipeline(feature_options_);
OnlineDecodable decodable(tree_, pdf_prior_, decodable_options_,
net, &feature_pipeline);
Vad vad(vad_options_);
FasterDecoder decoder(hclg_, decoder_options_);
decoder.InitDecoding();
bool done = false;
while (!done) {
std::vector<float> wav_data = audio_queue_.Get();
if (wav_data.size() == 0) {
// end of stream
done = true;
}
std::vector<float> speech_wav_data;
bool is_endpoint = vad.DoVad(wav_data, done, &speech_wav_data);
LOG("wav data %d speech data %d", static_cast<int>(wav_data.size()),
static_cast<int>(speech_wav_data.size()));
if (speech_wav_data.size() > 0) decodable.AcceptRawWav(speech_wav_data);
bool reset = false;
if (done || is_endpoint) {
decodable.SetDone();
reset = true;
}
decoder.AdvanceDecoding(&decodable);
std::vector<int32_t> result;
decoder.GetBestPath(&result);
std::ostringstream ss;
if (reset) {
ss << "final:";
decodable.Reset();
decoder.InitDecoding();
} else {
ss << "partial:";
}
for (size_t i = 0; i < result.size(); i++) {
ss << " " << words_table_.GetSymbol(result[i]);
}
result_queue_.Put(ss.str());
LOG("%s", ss.str().c_str());
}
LOG("Finish decoding");
}
} // namespace xdecoder
|
e8ced5dca6b945d57dbbc4715a5666a01428afa0 | 83bed2d9488a76e5f0c07e34cc697bc29b5a5401 | /Hackerrank/MarkAndToys.cpp | 22044b87537a5539faa7887b08d3b6f440fc3f04 | [] | no_license | akshayrajp/Competitive-Programming | 0d246e84ab342bbff27d432fcaeff171f5d4d911 | b83385ec686f17cfd042febac395d93030586ff1 | refs/heads/master | 2023-04-06T11:48:39.580392 | 2023-03-25T16:59:53 | 2023-03-25T16:59:53 | 220,184,179 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 377 | cpp | MarkAndToys.cpp | #include <iostream>
#include <algorithm>
using namespace std;
int main()
{
long long int n, k, i, c = 0;
cin >> n >> k;
long long int arr[n];
for (i = 0; i < n; i++)
cin >> arr[i];
sort(arr, arr + n);
for (i = 0; i < n; i++)
{
if (arr[i] <= k)
{
c++;
k -= arr[i];
}
}
cout << c;
} |
02576d3ed29735741baf21ae1633b2c90ad6f60b | 57206f5c4ad8d8a488a733cc1c4683ec7e614410 | /Lesson3.cpp | 5b3d900f9661537d76e2ed76ac1f020c4da2b1ca | [] | no_license | PenitentExile/-Tests | a2aa1b561e2354b991bed9662c055b096d1a06d6 | 4bc8116f9d7050120dd707f9bf619830268eec7d | refs/heads/master | 2021-01-10T16:06:45.980691 | 2016-04-29T10:21:42 | 2016-04-29T10:21:42 | 55,355,128 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,393 | cpp | Lesson3.cpp | #include <iostream>
#include <cmath>
#include <vector>
#include <cstring>
using namespace std;
double Fibonacci (double n)
{
const float aFibonacci = (1 + sqrt(5)) / 2;
const float bFibonacci = (1 - sqrt(5)) / 2;
double currentFibonacci = ((pow(aFibonacci, n)) - (pow(bFibonacci, n))) / sqrt(5);
return currentFibonacci;
}
void Reverse (char* first, int size)
{
if (size <= 1)
{
return;
}
char temp = first[0];
first[0] = first[size-1];
first[size-1] = temp;
Reverse (++first, size-2);
}
int MinimalNumber (int number, int minimum)
{
if (number > 0)
{
int a = number % 10;
if (a < minimum) minimum = a;
MinimalNumber (number / 10, minimum);
}
}
int main()
{
// 1. Реализовать вычисление n-го числа Фибоначчи через массив.
vector <long> fibonacciArr;
fibonacciArr.push_back(0);
fibonacciArr.push_back(1);
for (unsigned i = 2; i < 100; i++)
{
fibonacciArr.push_back((fibonacciArr[i-1])+(fibonacciArr[i-2]));
}
for (unsigned i = 0; i < fibonacciArr.size(); i++)
{
cout << fibonacciArr[i] << endl;
}
// 2. Реализовать вычисление n-го числа Фибоначчи с помощью переменных
cout << Fibonacci(6) << endl;
// 3. Написать рекурсивную функцию по перевороту массива (в обратном порядке).
// подумать как реализовать не используя никакие переменные!
char arr[]= "I am good boy!";
Reverse(arr, strlen(arr));
for (size_t i = 0; i < sizeof(arr); i++)
{
cout << arr[i] << endl;
}
// 4. Написать рекурсивную функцию по поиску минимальной цифры в числе.
int a;
cout << "Введите целое число: " << endl;
cin >> a;
cout << MinimalNumber (a, 9) << endl;
// 5. Реализовать алгоритм поиска любой возрастающей подпоследовательности: 5 1 2 3 7 -2 3 5 -> 1 2 3 7
// 6. Перевернуть каждый половину массива: 1 2 3 4 5 6 7 8 9 10 -> 5 4 3 2 1 10 9 8 7 6
}
|
23211d0ac1dbfd0ec195d9a6c751564c75ca14cf | 083973f506ea3a2d575e102acc2babd6dfa6bc93 | /leetcode/Easy/349. 两个数组的交集.cpp | 36169bded5879038923c94c1aa9726b1dd608bfc | [] | no_license | gsscsd/Code_Training | dd5ab4ef2a789ca84b372327b9a5a780d080f089 | 60efc5248c1bd30162b4b44b21cced66f4723059 | refs/heads/master | 2020-03-29T11:07:46.049496 | 2019-07-05T04:47:53 | 2019-07-05T04:47:53 | 149,837,404 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,345 | cpp | 349. 两个数组的交集.cpp | /**
给定两个数组，编写一个函数来计算它们的交集。
示例 1:
输入: nums1 = [1,2,2,1], nums2 = [2,2]
输出: [2]
示例 2:
输入: nums1 = [4,9,5], nums2 = [9,4,9,8,4]
输出: [9,4]
说明:
输出结果中的每个元素一定是唯一的。
我们可以不考虑输出结果的顺序。
*/
/**
解题思路：
1.map映射
2.双指针遍历
*/
#include <iostream>
#include <vector>
#include <map>
using namespace std;
// 空间为n，时间为n
class Solution {
public:
vector<int> intersection(vector<int>& nums1, vector<int>& nums2)
{
vector<int> vec;
map<int,int> mp1,mp2;
for(int i = 0;i < nums1.size();i++)
{
if(!mp1.count(nums1[i])) mp1[nums1[i]] = 1;
else mp1[nums1[i]] += 1;
}
for(int i = 0;i < nums2.size();i++)
{
if(!mp2.count(nums2[i])) mp2[nums2[i]] = 1;
else mp2[nums2[i]] += 1;
}
map<int,int>::iterator iter1 = mp1.begin();
map<int,int>::iterator iter2 = mp2.begin();
while(iter1 != mp1.end() && iter2 != mp2.end())
{
if(iter1 -> first == iter2 -> first)
{
vec.push_back(iter1 -> first);
iter1++,iter2++;
}
if(iter1 -> first < iter2 -> first) iter1++;
if(iter1 -> first > iter2 -> first) iter2++;
}
return vec;
}
};
// 使用排序加双指针算法
// 时间nlogn,空间为1
class Solution_ {
public:
vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
vector<int> res;
sort(nums1.begin(),nums1.end());
sort(nums2.begin(),nums2.end());
int a=0,b=0,n=0;
while(a<nums1.size()&&b<nums2.size())
{
if(nums1[a]<nums2[b]) a++;
else if(nums1[a]>nums2[b]) b++;
else
{
// 注意这里的技巧
if(res.empty()||res.back()!=nums1[a])
{
res.push_back(nums1[a]);
a++;
}
else a++;
}
}
return res;
}
};
int main(int argc, char const *argv[])
{
return 0;
}
|
05ea3f4418d03da1539b6272c40e7f0799c077df | 00da0f464ff5ae866f189713b05d32406e388495 | /structures-and-algorithms/project-metaheuristic-tsp/src/algorithms/GeneticAlgorithm.cpp | 032743b6968ad7decf9eef282418dc5006f55248 | [] | no_license | Wojciechowski-Marcin/studies | b47782f0c3816b8f9f387a0f6f7454adbbd4a3ec | 3a0c12dd63cf1f30688f819fb652032ffb07586a | refs/heads/master | 2022-12-31T10:41:47.132053 | 2020-10-24T16:52:23 | 2020-10-24T16:52:23 | 297,168,996 | 2 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,290 | cpp | GeneticAlgorithm.cpp | #include <vector>
#include <iostream>
#include <algorithm>
#include "GeneticAlgorithm.h"
#include "TimeMeasure.h"
using Vector2D = std::vector<std::vector<int>>;
unsigned GeneticAlgorithm::getGenerationNumber() { return generationNumber; }
/** ctor */
GeneticAlgorithm::GeneticAlgorithm(
const unsigned populationSize_,
const double crossFactor_,
const double mutationFactor_,
const std::shared_ptr<AtspFile> atsp,
const int stop_)
{
cities = atsp->getCities();
size = atsp->getSize();
optimal = atsp->getOptimal();
populationSize = populationSize_;
crossFactor = crossFactor_;
mutationFactor = mutationFactor_;
stop = stop_;
}
void GeneticAlgorithm::compute()
{
generationNumber = 0;
Vector2D population;
std::vector<int> path;
clearPath(path);
for (unsigned i = 0; i < populationSize; i++)
{
randomShuffle(path);
population.push_back(path);
}
cleanPopulation(population);
TimeMeasure time;
time.start();
while (time.getTime() < stop)
{
generationNumber++;
unsigned tmpSize = population.size();
for (unsigned i = 0; i < tmpSize; i++)
{
if (static_cast<double>(rand()) / RAND_MAX < mutationFactor)
{
int r1, r2;
getRandomValues(r1, r2, population[i].size());
invert(population[i], r1, r2);
}
if (static_cast<double>(rand()) / RAND_MAX < crossFactor)
{
int r1, r2;
getRandomValues(r1, r2, populationSize);
std::vector<int> child1 = PMCrossover(population[r1], population[r2]);
std::vector<int> child2 = PMCrossover(population[r2], population[r1]);
population.push_back(child1);
population.push_back(child2);
}
}
cleanPopulation(population);
time.end();
}
finalPath = population[0];
finalCost = calculatePathCost(finalPath);
}
void GeneticAlgorithm::cleanPopulation(Vector2D &population)
{
auto func = [&](std::vector<int> p1, std::vector<int> p2) -> bool {
return calculatePathCost(p1) < calculatePathCost(p2);
};
std::sort(population.begin(), population.end(), func);
while (population.size() != populationSize)
{
population.erase(population.end() - 1);
}
}
std::vector<int> GeneticAlgorithm::PMCrossover(const std::vector<int> &p1, const std::vector<int> &p2)
{
std::vector<int> child(p1.size(), -1);
int r1, r2;
getRandomValues(r1, r2, p1.size());
if (r2 < r1)
std::swap(r1, r2);
std::vector<int> blacklist;
for (auto i = r1; i < r2; i++)
child[i] = p1[i];
for (auto i = r1; i < r2; i++)
{
auto it3 = std::find(child.begin(), child.end(), p2[i]);
if (it3 == child.end())
{
int index = i;
while ((index >= r1 && index < r2))
{
auto it = std::find(p2.begin(), p2.end(), p1[index]);
index = it - p2.begin();
}
child[index] = p2[i];
}
}
for (unsigned i = 0; i < p2.size(); i++)
{
if (child[i] == -1)
child[i] = p2[i];
}
return child;
} |
d600c9475241151dc00ea113b60e9378bb337da8 | 23ed1b706ccf7bfa4d550a4cccdad9a8665b0f2c | /Tool73/MultiTexture.cpp | 0671e96c3f6e233c53994e1c6bcb0b0c5fbda7be | [] | no_license | codnsj81/BastionCopy | 7440cfeb3984faed0ee421dd93c1d24bc27d9475 | 0cf4a8e8bfa2729b8bb61e151dcef65da6e46eed | refs/heads/master | 2020-08-05T14:27:25.083493 | 2019-10-03T12:57:56 | 2019-10-03T12:57:56 | 212,577,656 | 0 | 0 | null | null | null | null | UHC | C++ | false | false | 2,638 | cpp | MultiTexture.cpp | #include "StdAfx.h"
#include "MultiTexture.h"
#include "Device.h"
//L"../Texture/Tile/Tile%d.png"
//L"Tile"
HRESULT CMultiTexture::InsertTexture(const TCHAR* pPath,
const TCHAR* pStateKey /*= L""*/,
const int& iCount /*= 0*/)
{
//printf("Count : %d ", i)
TCHAR szPath[MAX_STR] = L"";
vector<TEX_INFO*> vecTexture;
for(int i = 0; i < iCount; ++i)
{
wsprintf(szPath, pPath, i);
TEX_INFO* pTextInfo = new TEX_INFO;
ZeroMemory(pTextInfo, sizeof(TEX_INFO));
if(FAILED( D3DXGetImageInfoFromFile(szPath, &pTextInfo->ImageInfo) ))
{
MessageBox(g_hWnd, pPath, L"Not Load!", MB_OK);
return E_FAIL;
}
if(FAILED( D3DXCreateTextureFromFileEx(
CDevice::GetInstance()->GetDevice(),
szPath,
pTextInfo->ImageInfo.Width, //이미지 가로
pTextInfo->ImageInfo.Height, //이미지 세로
pTextInfo->ImageInfo.MipLevels, //3D에서 사용 : 이미지를 확대 / 축소
NULL,
pTextInfo->ImageInfo.Format, //이미지 상태
D3DPOOL_MANAGED,
D3DX_DEFAULT, //테두리 표현을 어떻게 할것인지에 대한 옵션.
D3DX_DEFAULT, //확대 / 축소하는 경우에 어떻게 처리를 할것인지에 대한 옵션
NULL, //제거할 이미지의 색상
&pTextInfo->ImageInfo, //이미지에 대한 정보를 어디에 담을 것인지?
NULL, //8비트 미만의 이미지
&pTextInfo->pTexture ) ) )
{
MessageBox(g_hWnd, szPath, L"Multi Texture Load Failed!", MB_OK);
return E_FAIL;
}
vecTexture.push_back(pTextInfo);
}
TCHAR* pKey = new TCHAR[MIN_STR];
lstrcpy(pKey, pStateKey);
m_mapMultiTexture.insert( make_pair(pKey, vecTexture) );
return S_OK;
}
const TEX_INFO* CMultiTexture::GetTexture(const TCHAR* pKey /*= L""*/,
const int& iCount /*= 0*/)
{
map<const TCHAR*, vector<TEX_INFO*>>::iterator Finditer;
Finditer = find_if( m_mapMultiTexture.begin(), m_mapMultiTexture.end(), STRING_COMPARE(pKey) );
if(Finditer == m_mapMultiTexture.end())
return NULL;
return Finditer->second[iCount];
}
void CMultiTexture::Release(void)
{
map<const TCHAR*, vector<TEX_INFO*>>::iterator iter;
map<const TCHAR*, vector<TEX_INFO*>>::iterator iter_end;
iter = m_mapMultiTexture.begin();
iter_end = m_mapMultiTexture.end();
for(iter; iter != iter_end; ++iter)
{
//delete [] iter->first;
SAFE_DELETE_ARRAY(iter->first);
for(size_t i = 0; i < iter->second.size(); ++i)
{
iter->second[i]->pTexture->Release();
safe_delete(iter->second[i]);
}
iter->second.clear();
}
m_mapMultiTexture.clear();
}
CMultiTexture::CMultiTexture(void)
{
}
CMultiTexture::~CMultiTexture(void)
{
Release();
}
|
bf9411e64268a39b158f77add68f2e0779befeb0 | 34b3623dbd185b9d8e6bc5af787ff656ebb8f837 | /finalProject/results/test/test_noslip/wedge05/18/phi | 584065c691f539974c637bba6ba98c6344ee011d | [] | no_license | kenneth-meyer/COE347 | 6426252133cdb94582b49337d44bdc5759d96cda | a4f1e5f3322031690a180d0815cc8272b6f89726 | refs/heads/master | 2023-04-25T04:03:37.617189 | 2021-05-16T02:40:23 | 2021-05-16T02:40:23 | 339,565,109 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 98,800 | phi | /*--------------------------------*- C++ -*----------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Version: 7
\\/ M anipulation |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class surfaceScalarField;
location "18";
object phi;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
dimensions [0 3 -1 0 0 0 0];
internalField nonuniform List<scalar>
11512
(
155.617
-510.098
354.482
-760.323
-16.1619
776.485
426.069
-391.017
-35.0525
650.961
269.391
-920.353
1548.99
-1097.94
-451.051
1206.24
-1515.55
309.315
-55.8068
497.769
-441.962
173.321
-863.578
690.257
980.765
-1647.48
666.714
-1777.74
1688.32
89.4283
-567.067
1773.3
-1168.59
1982.13
-813.534
618.759
182.733
-801.492
-23.0891
-1338.86
1361.95
225.967
-2003.71
1052
-390.472
-661.523
-175.415
331.031
493.173
186.373
-679.547
1186.48
-1346.34
159.864
-314.354
389.188
-74.8339
1027.79
-1334.02
306.234
1250.95
819.159
-2070.11
70.511
-1669.6
1599.09
-503.002
-1156.07
1659.07
479.713
172.608
-652.321
-199.045
-311.053
509.069
1039.92
1676.02
-1832.03
156.017
-105.034
-1687.15
1792.19
-1598.12
665.177
932.947
-313.348
671.612
-358.265
-117.7
-110.348
228.048
1307.36
-1236.85
367.878
-1442.55
1074.67
-1200.78
1200.78
96.6636
1555.37
-1652.04
-1103.06
-495.066
667.867
-723.674
-393.127
966.449
-573.322
1281.76
-1274.44
-7.31939
-1129.54
736.415
646.352
405.643
-392.928
-47.5377
440.466
-437.805
777.552
-339.747
-1057.07
1057.07
1235.24
-1385.66
150.42
-500.716
1751.66
1289.46
-323.009
1698.63
-1185.89
-512.746
86.918
-401.272
2115.12
-1162.02
-953.098
1842.33
-166.312
446.906
140.825
-587.731
-459.667
992.545
-532.878
-1188.79
1285.45
-582.856
997.234
-414.378
414.325
772.156
670.089
-496.768
-449.336
613.369
-164.033
1221.4
-853.522
2357.01
-1104.12
-1252.89
1191.85
-2057.22
865.366
-1629.09
1606
451.743
-1620.33
-687.713
1194.65
-506.933
-691.775
378.427
1699.21
-718.441
-1129.44
-888.911
2018.35
679.091
-369.252
-309.839
707.831
581.628
-266.458
1501.7
122.233
-330.743
208.51
-290.319
770.032
-310.248
503.551
-193.303
-331.917
825.09
-326.715
-155.417
482.132
339.215
86.8537
1479.94
-452.15
-991.085
497.904
493.181
290.081
91.2274
-381.308
970.642
-351.882
-1739.21
624.793
1114.41
28.3297
-870.724
842.395
-285.793
606.094
-320.301
162.296
-1122.5
960.206
929.203
-945.027
15.8243
383.889
532.064
-915.953
-246.605
693.511
-1129.62
-496.008
1625.63
-538.239
799.023
-260.784
1352.92
-1457.95
-636.342
288.388
347.953
-484.066
-1027.41
1511.47
-554.771
-811.69
1366.46
587.873
-1012.78
424.905
-140.461
-226.246
366.707
421.436
-299.203
-1061.29
601.621
980.644
-818.348
-105.28
825.925
-720.646
-198.481
403.036
-204.555
-628.099
-362.987
-397.062
984.935
1339.25
-1339.25
-462.005
-174.337
-948.33
1572.83
-624.503
376.165
-817.672
441.507
-948.964
366.108
-957.605
-1079.03
-1522.49
361.342
1161.15
-277.81
928.771
-308.787
627.628
-318.842
-1978.76
1021.16
-1156.94
-365.555
571.243
-1519.57
1768.2
-1767.01
-1.18203
225.617
-618.265
392.648
-1475.65
976.162
499.49
300.19
216.72
-516.91
307.647
-617.895
198.202
-324.14
125.937
2036.41
-839.119
-1197.29
-561.045
168.117
635.525
851.545
-1487.07
-165.08
363.283
443.866
897.757
-1341.62
-934.873
406.85
528.023
-1069.38
1483.7
-901.075
213.362
774.943
-103.33
549.083
-277.688
-271.395
1017.26
-519.357
611.515
-1439.57
828.054
-1376.54
246.927
-547.006
261.213
-1200.61
922.799
1998.84
-1127.35
-871.487
271.841
1067.41
-2143.37
914.634
1228.73
234.44
-17.8062
-216.634
-186.147
368.106
-181.958
-119.797
-385.817
505.614
-481.886
155.171
317.404
-64.8544
441.019
417.762
402.443
-820.206
-2049.31
1132.1
917.214
473.383
-549.426
76.0428
165.495
-250.081
84.5853
977.597
1058.81
1809.44
-254.07
728.086
-439.698
816.032
-1425.3
609.264
350.376
328.715
1069.2
-1040.87
-514.072
-245.447
759.519
494.022
-142.269
-351.753
761.262
-578.529
611.557
-799.7
188.143
518.027
1180.61
-1272.2
717.432
1034.85
-1537.85
2.28088
-1471.84
1469.56
333.648
846.529
-1180.18
630.513
263.261
-893.774
-2276.46
1171.86
1104.6
-1129.04
-1147.42
218.339
393.219
983.724
-650.076
735.165
-748.658
13.4937
-2142.82
1013.38
-101.379
-115.366
216.746
-44.4407
1812.64
-843.453
83.1305
-1051.07
-1092.3
-193.171
358.666
-673.444
211.439
-271.86
-427.571
699.431
1124.75
-1608.82
799.664
-1408.77
609.101
706.897
-437.506
1960.7
-1442.67
-358.749
-842.033
78.693
419.076
-544.995
528.833
2.95273
-576.004
573.051
587.527
-287.337
-603.561
284.031
319.53
800.451
-382.689
19.698
214.742
1215.84
-1213.56
187.106
234.33
395.906
-667.766
634.68
-1031.74
-2071.49
2071.49
-258.003
-452.939
710.942
719.084
410.843
-1129.93
595.082
179.861
403.707
396.745
-2245.45
1356.54
-948.7
-696.215
1644.92
-485.435
-715.173
-262.29
553.83
-291.54
861.16
-213.883
-647.277
-435.773
661.39
388.512
-697.298
-352.076
-146.314
498.39
-1346.18
-485.859
648.588
-1134.02
-351.499
-705.568
862.008
1495
249.572
-462.11
212.538
992.775
-346.424
1426.78
-815.267
459.814
-272.708
-339.791
-900.575
587.212
313.363
-347.089
-553.486
314.358
-434.156
-208.485
-136.525
345.01
-403.892
1122.98
418.335
-231.962
-363.561
1376.93
-181.429
-1195.5
-480.977
276.641
204.336
234.666
249.629
-484.296
9.85615
-809.556
607.18
-1768.21
1161.03
1517.48
-881.955
-1049.78
-425.868
-1085.86
588.524
497.34
1395.79
-419.627
951.072
-1447.08
-171.255
-221.27
392.525
-479.689
597.955
-1667.33
424.967
856.788
280.449
300.771
-581.22
521.866
678.917
1134.17
-736.011
-398.16
409.46
-219.996
-189.464
-1452.35
457.326
756.856
-1214.18
1510.33
-559.258
-489.794
937.122
-447.328
439.229
1208.73
-1647.96
21.7146
-559.953
-148.08
438.16
89.5666
-207.266
529.152
488.108
-661.783
58.4202
603.363
994.636
-1241.4
246.769
679.338
-275.631
482.636
-1482.37
999.73
422.42
1727.1
-535.242
848.183
1150.66
-681.167
-1725.99
777.293
585.867
395.298
-981.166
463.268
82.5888
1789.71
-1872.3
1411.26
-390.999
-1020.26
1737.98
-1782.42
-378.032
-523.683
738.599
-214.916
-520.914
192.076
301.946
-382.265
-1248.03
220.622
-786.575
-652.994
-622.414
1043.92
-421.509
-475.713
468.882
6.83122
581.21
-769.406
188.196
-287.419
85.6488
201.77
-665.177
-699.991
359.59
340.401
-951.714
1434.35
-418.237
904.9
-486.663
-2251.26
5.81258
189.83
-554.305
364.475
152.187
1224.74
-103.718
-569.726
166.544
-615.88
1523.68
-724.012
384.307
-479.723
95.4161
-142.499
142.499
700.086
356.981
1820.57
-1260.84
604.739
656.1
800.327
-39.0649
1323.29
791.83
-555.071
1371.1
295.913
310.18
291.909
-815.592
251.584
-689.389
223.836
-417.246
193.409
-243.557
596.85
-353.293
130.764
-374.32
-606.528
-580.316
1186.84
-364.346
537.097
-172.751
-1194.64
2059.9
-865.266
1323.46
-339.74
-184.934
44.4726
-1988.16
832.091
1548.65
-848.631
-700.015
2031.57
-897.885
-1133.68
732.211
591.254
-237.314
461.151
-676.944
1155.01
-478.069
-788.594
1232.46
565.073
946.815
-1766.96
820.143
-542.102
-81.1125
623.215
301.336
247.747
425.046
-106.813
-318.233
771.948
-73.9688
-697.979
927.478
-557.057
-370.421
1610.7
-485.951
908.658
-1666.08
757.422
1095.48
865.217
771.082
-458.881
-312.201
-1008.09
-266.341
567.371
599.384
-1166.75
-451.195
507.405
-56.21
595.029
-357.751
-237.278
-1006.78
588.541
612.683
904.796
-447.391
1028.6
1438.76
-784.003
-654.753
411.372
-951.603
540.232
-1037.84
409.741
565.307
-1055.1
466.53
-525.82
59.2899
482.55
295.002
-120.222
-22.2771
-814.8
-898.029
1712.83
198.526
210.934
-238.235
456.573
-42.7947
-548.719
591.514
492.807
891.472
-1384.28
-530.857
322.371
817.227
-45.2789
856.973
-1092.78
235.805
388.339
866.903
-1421.97
-451.147
853.59
2025.38
-1314.25
-711.128
246.576
488.589
240.847
688.356
99.0919
-983.766
884.674
1711.56
-1110.63
-600.926
-142.721
1932.43
-1907.73
-163.753
462.347
-583.409
121.062
-1042.66
540.22
502.443
-1709.32
514.679
-963.529
858.25
402.359
211.009
502.94
-253.369
-439.408
731.902
260.873
56.5286
778.743
-835.271
-1160.88
-870.96
2031.84
-535.687
1114.24
-578.551
-468.064
-129.199
27.8193
-1694.64
879.844
-841.828
-631.193
1473.02
-290.612
-283.441
574.052
369.172
-662.625
293.452
238.326
-621.015
313.133
221.112
-534.245
349.988
-612.278
632.241
-263.068
323.368
-478.785
677.921
411.261
-176.595
-391.512
-308.479
1241.12
-8.46046
-1232.66
1066.41
-431.728
574.114
423.12
-1799.42
863.798
935.623
511.461
553.048
-1064.51
-443.477
152.866
-269.584
1210.17
-940.583
-1574.35
1215.6
517.769
-1124.3
399.747
-15.4402
425.906
310.224
-736.129
381.864
-628.469
-28.8714
773.913
-745.042
-475.459
738.72
382.483
314.829
485.497
672.011
87.5733
-401.22
313.646
982.283
-577.477
-404.806
508.008
-1701.57
1193.56
-1163.62
1793.09
-629.469
1754.66
-1147.48
-341.091
625.122
-1184.45
1283.54
323.564
-819.521
1633.7
-814.176
-251.689
-229.288
-937.557
1506.61
1855.94
-626.986
-1228.95
-416.9
731.731
-1354.14
-75.1494
-40.3697
465.416
-696.39
-363.696
-1210.65
-233.491
471.817
887.253
-578.218
192.401
-1713.67
-73.6859
1787.35
-1078.73
543.042
587.652
-1210.92
623.273
923.863
932.075
626.658
567.989
696.173
240.949
-1150.65
473.71
-417.695
420.648
639.927
-528.628
260.785
-756.204
495.419
692.108
-341.733
-265.4
155.051
-607.061
226.299
380.762
-911.91
-754.169
1108.42
-2187.45
411.334
-701.652
-332.982
-612.045
855.96
582.796
-360.85
313.313
362.76
244.22
675.98
-920.199
527.371
627.642
-541.206
189.13
364.788
-622.791
-1128.51
-802.707
1931.22
-1831.13
161.537
1134.24
-1403.82
1179.33
-725.108
-454.222
-517.48
1384.38
-1529.99
646.014
883.98
-166.916
-154.762
321.678
1460.36
571.208
333.996
-480.311
-501.477
-576.601
1078.08
-427.654
617.484
1621.25
-1156.29
-464.962
-786.294
333.355
584.677
397.607
-1660.01
429.078
1230.93
-208.777
521.909
817.613
803.634
209.146
-694.122
484.976
203.165
199.871
-242.309
-96.3554
338.665
486.648
-3.34818
-483.299
-1653.33
603.543
-1616.95
1689.92
-72.9636
15.7329
-1632.69
1059.76
767.308
-341.402
-815.053
-222.786
-1164.52
-244.248
-319.47
701.334
-1856.39
-636.778
1236.16
211.574
780.971
-1362.23
-694.986
-478.788
611.907
-331.458
-1032.61
1381.01
-1977.68
596.673
662.021
1320.1
369.377
-1.27129
738.129
712.589
-1450.72
-658.75
349.924
308.826
346.146
-83.1706
-262.976
162.596
293.672
176.017
-469.689
-586.843
1172.71
464.157
-623.945
-472.445
-414.266
886.711
-354.968
183.713
-473.854
174.651
-314.938
-727.725
419.549
-73.4024
-582.48
993.852
368.79
-191.111
-177.679
469.036
-800.953
-664.131
439.755
-1152
-845.775
1207.12
-583.823
469.162
290.356
-453.212
83.96
1056.37
-202.279
422.338
-220.059
-524.441
1584.2
-761.61
242.175
386.691
-628.866
225.206
481.994
-24.0865
-457.907
-259.965
-213.888
872.648
1131.17
580.393
-884.287
961.43
-77.143
-224.957
58.0416
-738.264
310.693
-651.927
319.91
372.199
843.271
-1249.45
406.183
799.147
-828.019
-963.235
-568.137
1531.37
-163.334
464.105
-543.898
266.211
1356.52
784.151
-575.005
1334.32
-685.737
498.197
-693.337
-420.45
-434.721
-388.61
823.332
516.466
-868.348
-453.659
91.7341
361.925
-260.115
588.573
750.225
-338.891
-231.152
-170.984
402.136
-506.936
153.317
353.62
1492.07
81.3477
-1573.41
-766.683
1379.37
-1173.16
-474.315
553.345
-166.655
1179.4
-380.249
1104.33
506.371
712.662
-420.753
-904.168
-538.381
-1354.23
-31.7032
1010.52
-978.814
603.861
337.56
-941.421
-326.333
-234.712
-753.027
414.48
1657.01
-182.433
369.926
365.65
-735.575
-1882.06
-2151.29
1550.72
600.574
-2042.15
354.996
372.932
540.712
-913.644
-473.422
1047.54
-407.476
-675.238
1082.71
-2073.27
1419.53
653.733
602.612
-1010.09
59.8251
406.705
390.369
208.08
251.734
318.659
975.544
878.272
700.491
-336.844
-363.647
-303.918
640.102
-336.184
590.724
543.447
576.121
509.715
-1085.84
-811.61
-718.383
773.27
406.127
-423.979
717.431
-1216.74
1645.82
434.531
-1109.77
-329.109
550.221
-1412.22
908.086
504.135
-716.123
-327.507
-843.437
381.757
461.68
459.781
736.017
-1195.8
1095.68
-584.217
-403.582
674.95
-271.368
187.178
181.611
-480.674
-444.923
925.597
-251.09
558.096
-967.473
409.377
-472.436
613.551
-1717.67
435.682
687.686
-1123.37
539.052
88.5767
115.986
-2258.8
557.706
-88.544
1479.63
1813.68
-221.249
-1592.43
-448.697
1829.71
-2033.91
1222.21
811.7
417.371
353.711
-27.6932
883.653
-1316.75
736.438
-894.94
-845.57
813.867
322.048
53.7697
-375.817
101.444
110.887
-212.331
1585.52
-847.391
-1016.43
-322.814
484.769
-199.929
-284.84
402.288
367.744
250.429
361.478
-8.08163
1026.09
-1018.01
377.454
283.077
-660.531
-750.314
1857.81
-1107.5
-352.198
754.486
-1236.73
-415.312
-941.65
496.726
583.092
-794.108
211.016
784.647
-393.058
-391.589
-424.693
-459.594
451.591
1092.68
1267.33
-679.678
824.175
-355.14
388.276
322.665
-262.328
-217.395
-216.769
639.189
419.467
-872.494
453.028
217.067
362.185
-579.252
-435.565
855.032
773.842
-1177.73
894.824
-51.5531
-508.239
290.273
778.929
-97.8893
1417.99
1929.66
-74.6927
351.333
-322.966
410.539
-1112.27
1104.18
627.883
387.024
397.623
59.8994
424.87
278.508
497.977
-379.735
-279.015
-397.541
-78.1729
-366.064
379.846
-13.7819
-259.545
-287.461
1032.68
-1577.95
545.267
-202.307
-188.71
-387.193
670.27
-1665.3
1627.07
-981.06
267.208
-687.658
598.319
1248.97
-1847.29
625.131
1001.94
312.238
-1147.66
708.256
-290.143
-291.077
1397.13
-1476.6
838.559
638.036
415.736
-636.563
220.827
-366.388
488.904
-122.516
372.97
113.678
1765.97
456.669
-253.504
572.436
-1742.63
1170.19
-92.5411
400.658
351.771
348.72
-460.81
-630.935
1091.74
435.746
-886.893
-657.096
923.764
586.566
-147.684
-139.735
-452.191
-420.303
-317.5
-847.017
1302.15
-1302.15
-99.7755
-1605.78
1705.55
300.012
295.018
-936.962
-571.801
1508.76
-418.124
994.245
-614.224
-1039.1
688.167
404.673
-1092.84
492.351
-168.983
586.406
1244.84
-1831.24
-1051.25
2115.16
-1063.91
-383.06
-308.714
-494.008
827.363
-1789.17
1636.45
152.723
1789.17
-1638.58
-150.595
-250.834
534.122
-283.288
-551.62
1655.95
1586.21
-2001.52
1097.91
-287.158
-260.53
547.688
252.405
-581.513
-716.154
292.175
1374.32
651.059
591.238
499.962
-1091.2
294.227
418.435
893.101
515.265
-1408.37
543.148
-1044.63
1612.56
-579.884
-775.744
-372.607
-119.612
492.219
-503.775
1239.79
-764.006
337.485
356.026
364.353
268.037
-632.39
616.758
854.246
-618.441
279.856
681.574
-147.684
-321.962
-236.738
558.7
1192.17
-674.057
627.775
476.812
-1104.59
-1015.12
1015.12
-398.027
785.051
-296.907
-485.119
782.027
493.296
464.05
-957.346
397.406
-694.314
631.412
-891.771
260.36
-378.474
-510.59
1101.83
-679.794
-726.553
1406.35
-391.173
949.269
-1587.78
689.898
46.7507
-424.281
377.531
-505.636
717.075
259.399
337.45
177.571
314.779
-523.35
233.207
1914.86
-2012.75
282.257
-718.03
454.948
-843.895
388.948
-909.519
1432.51
-522.988
-442.24
-499.41
616.157
1148.56
-1764.72
-735.959
352.899
-471.662
1062.39
-784.451
1064.31
-356.682
-645.009
-484.443
736.027
493.575
-320.966
929.042
-307.825
-199.111
1633.29
-1854.54
-361.84
-605.633
-340.164
493.481
264.625
-596.082
-191.325
1080.09
-789.816
223.888
-292.634
-290.277
582.911
410.496
-897.568
487.072
-488.148
-454.556
-462.11
-341.519
584
-242.48
-460.465
-427.081
-329.789
-204.456
-388.6
656.636
-450.329
772.994
-1100.54
639.729
-1411.38
569.553
-28.0794
-1878.54
1906.61
586.714
-461.768
1235.3
-692.253
55.4251
-55.4251
686.668
-441.348
1039.07
-1653.3
-1182.63
-968.666
302.92
337.182
898.388
735.309
-493.793
-316.558
810.351
1696.64
-1724.71
-444.652
362.067
225.46
1165.1
-537.329
-963.501
1583.68
-620.182
458.954
-250.874
385.156
392.872
-778.028
536.228
490.633
-1026.86
-337.229
674.714
-39.0864
1953.95
1610.32
1014.72
-1738.73
744.742
-1208.18
463.439
-508.043
1401.14
858.122
-1375.6
-560.866
273.709
812
-416.702
570.929
-1217.75
646.826
-656.314
-1240.75
-711.816
1952.57
-212.128
560.395
-348.267
-181.138
294.896
-507.024
333.234
385.62
-718.854
-1515.7
777.641
738.061
899.778
-1467.91
849.343
-442.493
228.167
-376.246
-593.618
271.656
-686.215
-726.005
716.573
519.507
-1236.08
404.903
-209.98
-194.923
570.243
-984.621
-570.67
-428.769
739.462
-849.974
-1183.93
-1472.39
513.99
958.402
10.4456
-638.819
348.384
290.435
-1339.72
1072.17
267.552
-631.827
-468.711
-673.728
914.575
414.73
-211.757
-202.973
523.61
1001.45
-1525.06
1000.28
-367.48
123.796
243.684
-408.952
687.917
-405.661
-523.526
183.362
240.191
-1554.44
549.635
546.043
-759.082
253.446
164.648
-472.473
386.049
-840.605
1993.01
-1218.83
-774.177
412.011
-680.708
268.697
184.749
329.588
130.83
-460.418
-573.876
196.814
259.855
-711.746
1407.51
-695.762
435.473
481.637
-1197.76
274.577
1910.54
-1038.46
-872.081
756.29
-536.665
195.146
1427.97
-989.142
-438.824
350.095
-791.443
-632.839
1764
630.785
636.545
330.643
-8.59518
284.336
-1161.58
1764.45
-602.867
-1801.41
837.911
1775.55
-1702.7
-72.8536
-676.651
258.955
576.657
-722.419
237.976
1438.2
-580.077
406.44
447.151
-1901.16
1452.46
555.111
-424.653
-130.458
222.07
-551.858
-279.408
-188.656
-364.105
715.876
-586.973
214.366
617.12
570.666
-1187.79
1138.25
-1993.3
855.051
173.833
324.557
-1741.02
1701.94
331.285
-752.038
-168.196
396.363
766.457
698.92
-1465.38
1091.13
-1099.59
545.472
-1129.69
-650.035
262.907
387.128
528.038
-301.739
-625.354
-1027.94
310.971
-738.052
-930.524
194.006
171.422
233.481
388.836
309.3
-698.136
-639.996
-854.762
-1001.63
509.493
-1083.37
-287.197
491.534
552.331
654.786
-148.697
-36.237
-412.172
724.41
286.35
-1227.65
587.651
1337.94
-571.486
461.987
-1032.66
-222.099
168.96
386.151
1045.17
567.391
-1726.17
1626.4
1647.04
-588.265
-1058.77
1948.91
-1936.83
-12.0857
208.108
-531.074
-344.5
568.388
-773.824
-324.135
-352.515
1021.68
718.332
-1524.15
805.82
365.129
-25.9186
1659.21
-1100.06
426.001
-1256.19
480.445
-60.8151
1552.88
1229.23
-484.489
-335.841
-31.6395
-277.378
753.115
-1993.87
-731.949
356.017
-550.433
194.416
76.4956
-278.775
1165.42
687.315
-1852.74
-614.164
189.511
962.585
-1534.39
-217.807
673.268
-455.461
889.426
1110.57
-751.672
1382.46
609.812
-484.903
-124.91
-360.764
1199.32
1060.19
-1982.29
922.1
-1199.28
562.503
1525.77
-602.008
-377.691
-163.514
-1271.07
591.395
1191.39
-76.9704
969.268
794.5
-1763.77
-222.201
595.042
-1579.45
984.409
502.347
935.577
-1437.92
629.213
606.949
390.022
-1129.13
429.817
1133.46
627.925
-334.287
-293.639
-1211.26
-1794.42
-4.24375
-1721.93
-218.26
-418.303
1646.29
-640.766
-1005.53
-505.915
1132.57
-1349.2
654.777
694.427
-1393.5
1474.85
-1362.04
610.364
1557.63
-399.446
-578.267
200.576
-1497.78
240.729
179.937
232.151
377.661
434.629
411.748
-846.377
522.614
-958.756
921.883
-1481.14
-706.853
245.967
460.886
-1065.01
478.17
-479.473
885.913
715.733
33.6832
-535.982
187.715
-904.457
-1346.81
-737.131
361.733
375.397
418.092
-743.899
325.807
-439.853
-175.336
-573.322
734.384
1576.68
-607.411
827.341
758.18
1372.7
-857.431
-992.892
-586.559
-820.89
439.262
381.628
-1063.55
-662.222
315.064
347.158
-1429.38
-279.935
-814.114
410.515
403.599
-660.684
398.838
261.846
-690.297
284.636
425.265
500.332
401.153
453.878
490.688
396.023
610.55
-992.815
685.707
487.004
458.044
354.982
-813.026
1666.76
-1101.19
-565.578
-519.664
-285.462
-1054.26
467.195
356.136
421.192
608.643
-1029.83
-1413.9
773.13
-551.154
1174.43
364.65
-70.9783
424.006
-890.585
466.579
-1903.89
298.117
445.356
-723.838
278.482
-190.779
418.284
-227.505
-681.72
319.758
361.962
-694.93
331.283
381.32
403.732
628.365
-1046.49
773.012
677.528
-1450.54
450.639
641.105
333.469
356.077
-689.546
419.633
334.853
604.645
675.163
417.515
595.525
-1038.43
442.908
-1699.46
1185.73
513.73
1734.7
-554.096
638.091
-1177.67
539.583
-628.135
344.694
450.073
-961.299
511.227
759.132
-448.909
359.324
356.552
570.664
-932.504
667.686
-1286.41
618.723
384.264
752.728
-1256.5
788.281
523.757
-1312.04
485.805
423.769
-909.574
-516.515
-955.877
-314.374
647.608
362.624
551.916
-914.54
342.328
332.386
-515.679
1985.24
443.317
-855.103
411.786
-939.437
-827.521
-771.327
379.738
-1239.89
455.438
-1767.54
1638.58
128.962
1785.53
-1636.45
-149.079
-807.331
-610.753
275.924
334.829
-1775.55
2001.52
553.342
810.705
-1364.05
452.875
733.969
707.322
395.21
-1102.53
-64.6945
1655.26
-610.093
400.101
835.195
-610.332
319.936
290.396
-388.411
-252.148
439.326
-231.902
448.622
277.163
-636.934
359.771
274.322
-594.623
-292.868
454.912
-1060.64
605.726
552.05
1114.71
373.919
611.016
250.629
219.855
-470.484
1647.37
-929.042
1732.74
-1557.47
-175.266
-336.431
-847.399
427.096
871.491
-1089.3
-626.005
289.821
-1112.32
1664.37
-1602.69
-72.8654
1675.56
-350.08
-359.303
-379.866
549.995
615.109
-517.559
-31.8666
-552.687
519.779
-289.763
-230.016
1770.38
-1318.79
-641.495
309.156
332.339
416.506
369.798
753.178
-304.313
-409.593
-1785.53
1724.71
472.162
-1129.49
657.324
-40.9633
1667.36
584.763
478.585
-1063.35
86.4974
1170.99
-1488.49
-8.93968
-1894.95
236.491
-597.972
301.841
296.13
-950.374
617.392
-924.012
481.772
-1157.88
690.096
467.783
377.035
281.509
-775.302
-315.242
1249.31
907.058
718.567
-1216.63
474.625
742.009
508.112
718.044
-1226.16
-362.875
-254.977
426.399
-987.106
451.117
535.989
21.2253
-1922.38
1108.89
-477.48
-500.844
573.342
-1413.23
839.893
-430.564
819.512
-416.492
503.473
-984.881
1857.53
424.573
-191.092
178.266
-177.195
-252.839
430.034
1935.09
-515.561
-1718.52
1079
-538.037
285.889
-1041.1
567.676
-320.046
560.783
924.705
-1485.49
-1120.83
447.101
-20.7762
-1991.98
1717.39
-657.206
-531.15
474.212
-1221.77
747.556
195.247
219.483
-254.306
787.037
719.575
854.068
780.936
-425.954
1113.27
-497.89
490.577
-199.307
-291.27
-1969.82
-711.917
-320.809
-448.292
-2.08525
450.378
473.819
-277.005
579.469
1067.91
-816.782
950.405
1276.48
-436.884
-204.957
-247.379
452.336
948.755
-906.02
-341.153
-1095.77
627.056
1591.12
-813.476
553.706
955.057
-396.763
755.813
-359.05
1160.2
-260.391
326.266
1384.05
-722.525
-229.078
463.457
-1231.58
768.122
-993.486
-139.655
1133.14
454.002
-981.923
527.92
187.308
276.353
351.573
782.667
-106.687
877.884
-437.558
1197.43
-802.223
567.744
-1501.99
934.25
-1240.81
1839.13
-437.828
-1540.93
898.774
-1437.16
-317.083
-419.046
1493.62
-1560.33
806.158
1524.91
209.503
281.074
-358.879
-1767.54
-308.462
-1018.4
1597.87
-1795.4
1795.4
1586.21
-1030.82
-652.729
-341.643
375.429
618.816
-367.163
-367.07
-1423.6
915.562
1148.16
616.294
1228.05
1826.8
-1240.4
-620.698
274.512
1697.19
-1960.93
263.739
834.37
-1299.33
1580.14
-578.198
799.112
315.127
-337.268
569.939
814.444
640.648
1391.19
-224.788
-457.433
-359.444
425.389
-284.564
485.331
754.461
-299.715
-160.704
-329.94
582.451
-252.511
26.1093
-383.86
1130.5
-1759.97
-450.456
-490.51
-581.03
886.735
704.383
-1635.45
923.707
-464.573
-628.616
-527.443
1284.3
344.224
1762.87
-1741.64
-1696.64
1936.83
-1596.17
855.942
740.226
-367.706
-1838.5
940.469
598.79
839.409
-411.763
1836.64
-698.388
-410.698
681.092
445.828
-1126.92
-1127.75
457.737
771.495
-1652.81
488.028
919.48
181.22
-407.263
226.043
-1610.24
-393.472
-427.261
1006.93
-683.422
1478.41
-966.469
1855.9
247.378
-548.548
511.982
-302.478
489.813
911.331
559.098
998.528
-475.88
-440.899
590.002
903.622
-1389.76
-39.6169
1605.89
-847.712
535.542
989.367
-1512.56
-1117.92
1783.93
-1243.42
-540.506
1237.8
-329.148
-908.652
-196.592
465.373
-268.781
-471.223
-257.109
443.93
-186.822
153.205
-408.182
1743.66
-1747.9
-460.158
-547.841
-920.074
450.095
-208.319
-241.776
541.025
-453.723
-358.598
-318.045
676.643
-961.97
408.484
-1195.74
689.825
428.598
-642.314
-448.946
1606.64
-871.327
543.632
-470.855
-585.064
-475.574
62.9565
-59.8094
-3.14709
-1118.48
426.228
-682.07
-1056.35
1738.42
-603.027
-1459.05
732.495
577.621
-1633.68
1056.06
-383.121
-485.853
159.179
536.994
-1290.77
763.328
554.966
1025.18
-2172.19
1013.15
1159.04
-357.852
79.3183
-70.8837
-8.43453
1514.16
-380.424
462.472
1169.61
598.372
927.401
582.303
541.644
-1123.95
173.56
-441.066
-1702.7
272.257
1147.78
-620.196
533.707
1035.14
-1568.84
1114.71
-1680.29
183.64
711.184
551.689
-892.842
-1106.35
-140.697
367.755
-227.059
-574.945
-428.752
-652.113
-523.486
269.181
-1658.49
962.271
-489.758
218.421
-409.513
551.213
-314.722
-608.888
1227.64
-1294.48
928.045
366.439
-1033.53
-362.149
-770.641
-839.601
1726.34
-490.042
1798.59
-1590.42
-208.165
-1591.67
1038.62
553.055
-738.84
-181.298
328.651
-147.353
-596.366
393.566
285.052
-678.618
-538.459
1004.9
650.101
-360.28
-1654.15
1070.32
586.902
1125.81
-1712.71
-411.786
-305.144
-376.576
-759.119
-468.877
-339.606
517.178
1594.54
-1016.92
-794.108
1533.44
681.153
-319.086
743.767
1171.77
-1915.53
284.448
311.671
-500.555
-1978.74
1761.8
216.945
761.1
-487.056
-274.044
546.54
1081.81
-1628.35
62.9565
-1730.87
-238.488
1789.21
-1613.96
1097.23
516.722
-1734.26
3.39557
-536.06
79.3183
1741.02
-1761.8
961.718
640.949
-1602.67
292.997
-176.879
-116.118
-407.899
-282.398
64.3238
51.2846
-232.583
-446.698
-445.073
-421.315
230.536
1542.47
390.783
-229.891
-430.793
448.597
-188.742
327.29
1544.33
1095.65
-214.127
-881.518
-1127.9
1744.06
-1769.62
1087.55
-725.334
-1044.29
-1289.12
1883.45
-594.335
1179.89
-1811.49
631.601
187.954
-898.488
1714.07
44.4485
-1758.52
-505.169
-1103.65
-1743.66
-1008.26
567.363
1039.16
605.674
1155.99
-1761.66
295.81
-462.465
725.528
-394.245
373.254
946.77
698.145
-396.656
-641.776
598.473
1094.07
-1692.55
-406.855
-383.428
790.283
432.902
-1701.94
1557.47
144.465
600.713
-1072.37
558.003
1106.37
-1591.29
1013.1
-247.676
245.902
322.486
1948.91
420.485
-90.2265
1010.93
740.908
-1751.83
-714.295
1106.27
-1592.22
172.925
-585.142
196.999
251.598
-659.68
-580.208
598.548
1056.72
-721.114
-279.291
-1403.98
693.511
710.467
-412.874
805.626
92.0474
-897.673
576.995
-140.46
1592.92
-226.068
271.28
-787.197
-1978.74
1701.61
1021
85.6488
309.853
449.279
-953.76
-1016.06
-1804.8
656.473
1731.48
526.411
-487.89
1242.35
1111.3
-436.691
1055.51
-1005.65
508.679
496.971
717.686
1072.31
-1789.99
501.574
492.277
-1528.9
-767.693
31.6821
803.674
-423.936
-906.501
405.657
-553.07
-822.532
212.538
-592.839
1432.73
1079.39
176.196
191.559
-566.498
1655.24
-790.803
1563.82
-1766.24
590.257
1175.99
561.45
-907.874
-1773.56
1960.93
-187.374
1754.69
188.368
-557.449
171.789
-120.505
-495.325
1242.88
582.092
1152.61
-503.437
449.569
882.866
-477.222
-795.877
433.706
362.171
1453.23
1114.25
-534.029
1457.74
-513.407
-482.94
996.348
-618.635
500.394
-1225.5
1732.74
1876.52
-704.753
1624.41
-662.693
-1273.5
735.043
-578.306
146.029
-261.395
415.801
-215.93
-533.504
-1271.83
1910.33
-638.506
1204.1
-566.008
1143.08
-1697.18
1728.05
-589.733
-558.95
-564.264
1757.82
-325.654
-707.315
-488.364
1256.49
-1722.49
-1899.52
627.69
328.249
-975.526
175.15
222.218
-1756.72
1227.54
529.179
1184.41
570.281
-524.249
-481.636
1223.65
182.516
235.768
602.801
1273.72
-551.791
-1262.6
1814.39
-1049.33
1043.55
866.993
-208.314
-1697.19
1741.64
-525.806
1445.29
-1773.56
-378.865
15.9208
362.945
-276.157
603.314
-327.157
85.3819
501.83
803.773
-385.68
1280.49
1298.38
-426.885
876.902
-449.806
1858.35
-678.469
1622.41
-1762.87
-422.36
-752.886
301.479
451.407
-574.198
-579.418
69.8227
-1077.92
-1008.4
-686.714
1695.12
-957.35
-1214.84
155.991
-416.521
-664.237
721.917
1192.3
666.059
1445.89
-606.478
1677.58
1351.64
-588.313
-508.027
205.549
-519.18
1430.51
1272.2
-578.686
-967.437
918.373
53.7524
-972.125
595.058
-521.774
1437.34
1532.04
-604.64
-63.3896
63.3896
-605.391
1661.45
1272.33
-500.835
1156.66
-61.334
1853.52
-390.98
1526.56
-604.677
-524.319
1380.26
-670.393
1250.31
-579.914
1592.48
-608.066
756.4
593.101
-1349.5
-654.229
291.709
492.442
616.009
-1995.81
-1002.29
1622.41
63.4542
-63.4542
-76.8662
401.371
447.972
387.973
-15.0035
-314.731
909.352
-525.088
-436.48
837.851
-253.111
640.239
-423.972
1556.07
-460.187
-894.047
188.842
220.887
-409.729
615.951
1273.86
-1889.82
953.2
-471.428
-59.8094
128.83
-1985.3
1856.47
-466.352
193.644
1210.21
-455.838
-754.374
-318.976
-587.525
-503.874
-70.8837
-489.106
259.09
1188.96
-573.851
236.98
-395.75
158.77
-7.92723
-105.628
842.033
-736.405
18.0116
-415.552
-602.256
-91.4927
91.4927
-1262.97
2003.88
-1316.28
-228
-1826.94
236.518
-1045.75
-993.914
-193.248
-1678.06
724.303
1255
-1966.82
382.933
318.588
-701.521
-1888.92
1259.32
629.595
-145.488
145.488
-979.796
-12.1745
-1907.73
-572.785
1687.5
-694.675
1674.5
-617.78
-186.128
-1708.83
-603.191
-443.033
-610.253
-99.7283
99.7283
-1570.53
199.434
1371.09
164.601
200.526
-365.127
565.089
530.557
1024.12
-488.133
1787.21
789.109
-219.772
211.337
533.705
1741.01
-610.508
-567.238
1673.61
471.51
1853.13
-660.84
-1847.24
-1976.27
-662.928
-105.526
105.526
-601.812
242.368
-692.48
1046.6
-478.925
-1098.07
-291.701
1067.41
1889.67
1671.22
-1671.22
-281.445
759.245
1800.05
609.576
1300.76
142.489
150.508
600.299
589.067
1068.26
-1068.26
231.167
-360.967
-444.2
427.794
977.588
-468.909
-655.585
-1153.92
1744.18
290.798
-1666.75
627.644
-296.15
484.518
1783.27
-607.288
-178.111
-423.834
394.683
738.775
1777.36
-629.206
-525.791
-774.552
2000.39
-888.726
-1111.66
1679.81
-656.702
1248.7
-1864.24
615.54
345.748
-894.297
-185.013
-27.7547
1126.79
-499.737
126.86
636.135
-1664.08
455.348
619.666
-1847.24
-598.118
1825.66
905.259
-1186.49
1799.19
-612.706
1822.21
-590.176
-1232.03
455.419
936.085
-1747.9
944.383
-1480.32
239.518
1240.8
-853.553
-1279.34
-186.425
43.3114
143.113
596.787
279.959
1049.47
-459.528
870.504
-410.975
842.104
755.981
-1598.09
659.427
1092.24
-6.37599
-497.86
504.236
-1785.69
741.402
711.402
110.879
-1145.37
1977.65
-689.784
-1287.87
-552.22
1704.83
844.421
986.892
-1831.31
1253.26
699.306
-411.913
731.67
852.581
1056.08
-602.078
1800.05
642.312
1812.01
-1209.25
-602.76
-377.597
-334.91
712.507
115.797
-1136.06
1698.09
-555.004
-888.363
888.363
1274.13
609.328
1379.78
214.762
-567.896
291.087
-199.86
715.583
1137.55
498.062
-315.546
-890.91
-590.23
1744.51
-1744.51
593.16
-593.16
1008.05
1046.26
-2054.32
1877.24
-628.535
-596.066
834.342
-967.12
-1073.9
1021.75
708.053
-1729.8
-120.222
-360.875
-649.213
-825.781
2085.1
-1271.52
-627.998
1023.44
994.907
1316.42
661.232
337.117
1033.27
234.869
344.245
678.917
1794.88
-1794.88
684.025
28.8505
-206.53
-1017.53
-558.104
1714.77
987.907
1012.09
-1872.41
-232.319
-370.872
620.432
-348.175
1890.35
-1101.23
-789.12
382.396
-48.3996
-814.039
-1697.58
1697.58
931.93
1963.83
-663.073
581.597
-489.724
1743.78
-1254.06
747.027
1876.66
1176.59
-614.091
-591.454
1173.76
-791.934
-500.047
953.735
1128.83
393.406
387.529
374.379
700.086
-1159.17
-600.797
-659.826
-1237.54
1897.37
-113.935
-270.722
354.701
-559.658
1275.01
1013.06
783.599
-599.959
1918.72
-665.459
-391.426
676.477
1917
758.392
-568.75
387.182
-465.133
1486.69
-767.116
1195.87
603.318
-101.914
421.757
-319.843
-705.568
924.552
422.749
1676.06
-729.291
1069.11
923.511
798.57
783.967
605.722
774.85
1196.33
661.199
1876.24
-1005.21
-871.03
552.07
-337.583
46.5436
-46.5436
-189.572
-695.265
301.02
853.048
387.457
368.356
1929.96
-674.959
1120.26
17.1124
-852.384
1142.49
462.024
-597.893
597.893
1799.69
-688.387
754.98
468.665
-209.163
918.156
-660.523
1347.19
1224.09
906.192
1167.11
554.688
1118.92
-377.412
-70.88
-1112.15
1138.75
653.049
-1709.4
1221.83
-142.525
571.083
-428.558
210.775
-623.111
1896.98
535.389
-535.389
1018.89
621.187
-1640.08
647.223
664.262
634.115
1138.05
783.326
-684.301
1771.85
385.488
1086.18
135.217
1595.38
540.54
731.657
-1243.76
-733.919
-540.166
1956.78
-1416.62
1890.14
-616.016
1543.68
-1890.91
347.223
458.317
-458.317
1814.58
-700.328
54.0613
-512.943
343.015
-663.965
1387.13
-723.168
692.857
-648.195
59.0262
550.391
621.51
-1171.9
1523.59
-766.172
475.932
-475.932
439.344
-53.0497
53.0497
340.705
1165.19
-711.7
-918.021
1629.72
1258.89
1292.27
675.39
-1967.66
-1332.14
-726.462
1458.96
1332.14
-563.494
-1034.42
828.152
206.263
605.212
-605.212
1198.46
545.32
1228.42
-1889.26
1229.6
-489.153
489.153
1033.82
1066.06
789.835
600.843
-1801.63
1200.78
1113.31
-1773.51
1083.49
-605.324
-512.205
1038.62
-715.12
598.637
1318.36
1727.98
-846.229
-881.752
509.742
-509.742
-200.046
380.535
-180.489
-796.247
372.312
-1866.81
639.537
1227.28
-788.535
-777.835
1566.37
-339.354
-321.826
661.18
1145.87
1696.07
-733.801
263.478
208.032
350.941
-350.941
876.492
1719.95
-1060.53
650.43
-1310.95
1286.31
-1949.38
1156.72
-1835.19
-283.801
-411.464
1961.7
576.403
-576.403
1261.35
-1889.89
160.075
-160.075
376.277
-228.075
-148.202
630.01
979.491
-477.917
767.785
1810.25
-869.779
488.628
-338.918
338.918
1264.5
-1102.15
1280.18
-1908.18
1292.88
-1931.39
1146.73
1585.66
-779.505
-379.953
915.552
-1915.1
999.543
-352.102
544.503
-341.341
341.341
184.448
-476.15
1201.28
-1816.72
1213.96
-743.212
-1049.66
1792.88
577.85
-656.503
-192.648
-339.59
532.239
446.386
310.95
556.167
-361.751
651.206
1315.71
-1966.91
325.517
-325.517
1150.37
-1813.3
29.4492
-453.73
1683.09
1229.52
627.661
-1857.18
390.184
-267.628
267.628
654.625
-1892.17
1267.03
1082.3
-626.885
-125.765
125.765
1247.18
634.725
-1881.9
1183.96
-1791.25
1147.82
-1803.61
655.796
588.747
-1397.7
808.949
1260.89
636.085
-1810.16
1197.46
502.283
642.711
1254.66
-710.113
-1398.12
1812.6
239.961
-239.961
1119.23
-1774.78
655.548
-853.307
403.501
-736.871
1758.62
253.499
308.104
209.074
553.267
1247.05
449.036
-873.894
-824.796
1698.69
-1190.69
-676.129
571.027
-1016.43
-646.824
1088.55
-688.449
205.805
-205.805
452.22
-452.22
-620.842
919.715
-739.854
1916.6
-657.708
-210.987
178.495
188.199
-366.694
626.201
1135.24
-1761.44
1850.32
-589.432
-735.849
1937.13
1104.57
-1814.68
561.887
-372.756
-128.435
128.435
177.163
201.503
-378.666
1876.62
212.485
137.578
-350.063
-300.459
171.819
-171.819
-1239.17
1804.76
-565.592
702.956
-418.62
459.539
-229.003
189.929
127.529
-317.458
1841.62
-1855.18
-1784.44
1155.23
567.016
-379.3
200.452
179.615
-380.067
-1725.96
676.63
183.013
-183.013
577.556
537.845
-327.07
-2133.97
-1217.64
-691.577
1919.99
1157.77
-1760.64
-1254.34
637.036
1746.29
-1114.69
-1200.3
201.693
179.666
-381.358
-158.17
158.17
10.4045
696.475
1115.88
-1812.35
1147.7
1106.08
-663.169
301.59
254.134
-254.134
-1473.67
592.055
881.619
1106.22
-1716.73
1848.67
-619.078
407.327
-732.534
-1679.35
1061.57
-613.373
1835.2
277.932
147.573
-147.573
1671.94
-921.193
449.765
-227.52
227.52
-1124.81
-868.486
-462.937
193.755
190.382
-384.137
670.304
-1334.27
-401.924
-1692.65
1091.85
541.821
579.428
86.4262
91.4235
-177.85
-1228.25
1843.79
-624.139
-1306.43
-798.216
1640.32
284.228
534.36
-289.81
183.071
-183.071
1831.72
1525.23
325.096
-174.515
174.515
715.779
-453.934
584.538
-383.962
-199.719
463.198
-527.355
212.633
720.949
-474.982
-740.547
349.122
-1696.25
1141.24
1115.39
834.934
-556.426
1485.95
-1595.2
987.133
1026.35
-1713.06
626.67
1129.35
-1756.02
-1625.03
1045.14
176.182
-176.182
1245.83
643.84
-1145.84
1109.15
-653.71
728.496
-443.859
-1523.11
918.469
1056.24
-1666.33
-1206.55
-595.078
1963.15
-1027.56
539.429
1005.01
-1667.71
-172.318
-568.229
1640.19
-17.787
-684.821
1235.49
-1927.06
566.517
-1718.52
1126.19
-548.091
319.942
228.149
573.228
-1215.54
1881.91
-1566.21
979.655
-277.969
-246.006
523.976
237.749
-469.186
-394.014
1486.25
-765.103
-844.381
1609.48
758.153
-1880.46
1122.31
-312.966
497.414
-1962.93
1952.67
-1952.67
-1844.56
828.503
1922.8
-665.48
161.786
-430.563
-551.359
-356.985
-876.191
403.643
-607.031
2004.17
875.903
-504.959
-370.943
-1701.89
861.189
-1879.59
1056.2
727.722
1874.43
-289.983
1706.38
1825.63
-601.539
-1664.44
563.683
1100.76
892.285
-1657.39
-621.885
-684.38
-98.0975
663.667
-372.869
58.9202
83.5792
1012.49
466.433
-1478.92
1713.06
-557.832
-577.331
1644.5
-1705.84
941.608
-492.039
-1131.12
631.38
-25.6476
-1429.55
1667.84
-538.486
-1471.38
881.147
624.877
-1718.28
1093.4
1709.76
-603.539
-1313.18
-705.345
1960
-1657.01
-14.2128
-319.681
-1838.49
619.251
-1210.7
-1504.72
900.042
-517.718
945.929
790.821
-1736.75
1009.72
-1442.79
433.067
-51.4247
-113.707
-98.6241
-1395.25
401.762
287.443
-980.78
542.159
-1554.2
765.663
-1623.64
810.16
-1140.23
2055.78
9.50767
-623.54
1809.19
964.36
118.086
-1861.13
1195.65
-641.031
445.901
-457.683
1100
-110.401
-1082.24
1192.64
-499.429
1255.83
838.427
-1678.03
183.106
1219.76
780.104
-1570.91
161.791
1707.76
618.14
-1547.18
949.383
-1556.41
-569.674
230.32
-1435.81
934.979
461.18
-100.471
1229.44
-592.891
409.657
-735.405
1410.94
-675.535
-372.064
553.901
-339.534
-514.939
806.648
-1407.41
827.337
-498.142
-699.618
-378.382
-474.925
1890.89
-1088.92
-672.517
-646.099
1910.6
-736.405
482.84
-1271.74
815.907
-964.138
853.736
-1336.05
761.85
-836.183
-273.586
-735.927
316.881
-499.642
1233.67
623.111
1048.83
-8.49874
438.316
-116.687
411.583
-230.541
466.309
976.741
1087.87
173.69
-1449.85
843.371
-767.732
-1158.49
404.117
-1372.22
783.909
-1617.36
769.649
1291.03
354.971
-163.412
-744.531
1337.63
-1106.83
-667.952
480.031
-346.459
15.7156
1020.3
-1145.66
125.354
665.024
-718.999
228.997
-1786.54
-767.299
318.39
-248.08
1110.01
550.578
323.186
-873.763
-611.969
-809.903
366.87
-480.929
-12.6826
1478.74
966.781
258.814
292.529
-551.343
-703.649
1829.84
-80.8424
-446.157
687.106
164.904
364.934
291.539
-612.48
1711.38
1413.67
1868.99
377.615
1103.84
-1807.49
814.926
695.317
-1510.24
-1540.23
1120.24
-1084.72
1749.74
-668.15
323.004
-811.252
-577.439
-991.513
1568.95
-1030.61
238.461
-360.977
1088.65
-1557.83
719.433
-1533.61
-857.188
568.424
288.764
-598.556
555.897
753.165
1137.19
-1703.39
1703.39
-615.544
823.18
1169.83
949.421
-1564.97
-622.709
-975.521
-431.448
-489.745
-286.919
636.844
666.53
-1440.35
-1611.44
740.109
887.243
-1665.08
653.705
760.229
761.279
-1548.48
-500.203
1423.71
-749.295
-531.105
1280.4
-1284.74
706.052
958.53
-418.31
599.759
-1338.6
-1413.67
-1372.43
628.311
744.116
-589.473
640.53
-1304.66
-699.608
766.578
-429.462
829.601
569.9
702.833
435.362
-1184.66
350.526
477.71
-828.236
-437.392
-116.913
897.348
-1631.15
1702.53
-113.303
-1075.85
-642.428
376.28
300.197
1691.62
-571.354
1512.53
-594.062
513.653
663.007
-1546.34
883.334
-1262.5
682.582
-1241.57
-509.028
1149.56
1192.86
699.521
-1230.63
756.477
-1769.36
854.062
483.88
1037.43
-484.161
-182.467
-1079.51
-262.606
436.166
-486.894
689.883
-1607.9
-1212.17
530.998
1059.01
701.906
-1210.93
-618.329
-1672.11
0.153417
171.636
421.309
-922.889
1563.84
53.2031
815.266
-428.084
2.67069
1612.43
903.185
-354.063
332.748
21.3144
-485
1268.33
577.981
-1075.09
497.104
-53.2031
-6.60629
550.616
-1096.73
546.111
1210.18
-426.21
356.564
-768.477
51.8272
964.018
448.389
-228.906
-516.765
-1063.78
-1222.97
656.964
-730.981
-1629.09
-677.423
819.491
623.572
891.977
-1515.55
1061.9
-1108.92
1699.39
-637.823
-492.947
-323.009
1165.4
-266.163
369.503
-393.258
23.7551
-752.786
-608.845
-1435.65
807.038
-997.308
-642.769
-21.8084
-14.1733
-235.972
492.176
-1146.41
266.398
-292.659
26.2604
-1114.28
-604.236
-695.54
606.433
-1180.28
-186.831
367.493
-396.748
29.2556
433.567
396.033
-1118.78
-604.39
831.077
442.9
-508.487
938.712
645.422
-1584.13
898.659
227.053
888.88
-449.537
479.277
530.501
532.421
-1062.92
603.322
506.007
-1109.33
705.448
622.512
822.678
-1445.19
994.97
1128.29
-636.114
965.766
663.955
900.051
-22.7346
594.326
-1131.66
323.364
-356.05
32.6866
477.488
398.414
-392.257
347.695
44.5627
1135.03
529.819
-1042.02
-1666.08
886.571
1456.18
-778.655
-429.088
376.422
52.6656
1131.09
-704.862
208.252
-1096.56
1752.11
333.65
-389.4
55.7501
1514.55
-614.51
357.277
-415.056
57.7794
-644.893
272.024
-446.337
395.374
50.9626
387.047
-430.187
43.1403
388.056
-421.147
33.0911
448.703
-459.026
10.3225
-430.388
449.364
-18.9763
445.391
-419.067
-26.3239
422.416
-390.188
-32.2281
418.247
-381.472
-36.7748
403.504
-363.243
-40.2612
-379.542
426.151
-46.6088
403.629
-356.101
-47.5274
380.9
-332.963
-47.9365
-403.819
451.548
-47.7289
-11.2518
-824.399
501.39
-167.094
773.077
-701.939
487.129
532.078
666.999
-1494.55
827.548
-610.371
-662.224
439.22
398.63
408.729
-406.638
350.872
55.7654
377.38
-774.046
396.666
127.579
1609.28
-622.144
-758.944
214.386
-573.265
461.037
-954.255
493.218
553.831
412.07
-861.928
449.858
1728.33
-761.545
1537.4
-898.633
-1585.78
-809.486
1805
-689.613
498.875
-976.355
778.191
-1388.56
1137.05
1606
523.137
435.394
446.774
355.157
-413.074
57.9177
-919.007
473.934
-372.945
417.977
-45.0316
-774.094
-590.386
517.578
656.179
-427.842
-591.881
1684.15
-590.749
505.23
550.85
518.862
-1045.89
527.028
-1569.46
1197.4
-697.787
1707.51
1157.2
-617.617
-382.757
-393.154
403.503
-10.3483
-206.769
446.396
563.379
-1067.25
491.024
1187.82
-563.985
-559.962
-322.148
355.831
1080.61
-369.467
-650.454
-549.843
524.235
-1087.49
563.254
1461
-617.626
1434.32
-516.164
515.43
-1008.38
415.305
-372.345
-42.9597
210.144
-884.926
-687.25
985.03
317.119
-834.527
501.983
-970.892
1866.91
-974.629
-743.135
302.069
558.503
605.532
672.17
-1277.7
699.513
-1467.87
768.355
1091.52
487.87
-932.07
751.874
635.259
-519.987
1451.92
-1811.24
1538.67
272.569
291.17
1489.68
-1020.77
1520.26
199.737
-703.528
249.805
458.166
-886.008
-580.072
-1106.06
307.88
1148.96
-176.839
1322.65
-616.597
-1636.89
1119.17
1962.97
-1134.11
-828.862
-592.962
866.226
1064.71
437.805
-848.78
-818.961
-1151.01
-664.914
-513.973
-402.449
-1354.32
-248.373
317.282
-596.298
219.386
442.642
-851.014
225.732
-636.43
880.99
-1851.73
-858.116
196.581
186.198
-382.778
-932.097
467.609
-1125.33
915.996
1044.66
435.81
1451.39
-1545.18
722.329
290.156
805.879
1413.45
585.959
-1215.09
629.132
482.263
-867.868
-893.938
1881.84
-462.642
184.673
-572.941
1150.92
198.657
637.975
709.216
-212.002
-406.546
618.548
1612.15
-1008.61
-521.68
1177.86
322.214
-275.24
-46.9747
644.139
-1261.45
-851.38
343.321
508.059
-589.771
-1652.67
798.852
899.838
663.211
743.136
212.824
319.254
153.006
-532.766
379.76
560.498
-305.136
700.377
-1199.81
547.492
419.184
-804.864
-802.922
-642.267
10.0416
1610.34
-982.693
-836.912
990.284
1567.13
-872.05
-695.083
362.947
-711.717
348.77
-557.183
1332.03
1301.72
204.065
213.218
-1070.65
763.851
695.106
-526.919
165.168
-475.625
261.669
213.956
222.603
985.03
396.137
-757.104
667.819
968.658
-1546.1
204.913
342.373
338.708
-681.081
1220.23
-613.8
377.795
718.258
-370.212
623.711
787.47
483.022
-960.757
477.735
551.823
550.218
-1102.04
696.932
-1456.05
921.551
-462.874
-613.593
1714.35
-601.731
1789.87
-1188.13
-645.69
275.478
1545.44
-788.96
-363.362
907.551
309.876
-930.64
-394.118
694.315
842.668
-755.223
1310.14
448.204
-921.687
473.483
-1086.84
-774.29
-767.522
-1059.42
-997.817
-731.986
168.139
-168.139
-3.68027
-746.392
545.806
-1537.32
835.254
211.782
408.727
-775.729
367.001
672.881
894.252
-1296.44
1842.25
-892.003
1699.76
-735.396
1296.61
-867.079
476.643
-247.646
1438.24
326.244
-616.131
289.887
-1098.66
617.732
-956.303
1572.31
832.087
-43.3457
-472.397
871.027
431.453
450.654
-404.584
-46.0708
-1666.88
799.017
-561.78
177.818
1656.99
-887.341
589.771
8.12114
1556.39
-661.549
-1156.62
-408.638
-568.277
-862.426
-1717.89
1075.46
536.266
-634.244
97.9777
-275.446
354.139
-275.791
1853.09
10.16
298.406
-620.232
-1556.39
-141.184
1125.25
-683.976
-441.271
-248.595
-76.9221
597.319
283.363
-758.345
-605.204
1805.99
398.892
-757.723
1846.37
361.999
-876.938
277.145
311.406
-588.551
-55.2557
369.344
362.327
-1411.77
-378.22
242.096
234.547
839.058
-1123.4
469.686
1103.28
-36.3188
-590.72
1186.86
-567.606
-945.53
-452.167
-499.198
-810.68
1309.88
-627.859
73.3845
257.258
-229.058
-943.623
1378.43
-434.805
-506.394
-701.098
1329.41
271.269
-535.914
264.645
634.166
1421.61
626.79
-1558.89
1183.17
-816.735
-473.904
-560.699
302.281
-338.819
36.5386
-534.003
-35.6349
-16.9799
-644.543
-1145.94
689.252
456.684
-592.064
1125.33
-683.019
1427.13
-602.739
275.582
1659.89
-919.781
248.595
19.0331
-16.846
257.759
-503.765
822.464
-523.237
920.392
648.56
1049.31
-460.783
789.314
-829.337
437.418
-113.854
1078.24
-667.64
1181.63
-199.683
187.508
-576.908
-913.511
1637.81
275.791
1771.22
549.585
-336.952
-533.104
888.814
-511.434
864.078
634.984
376.91
-332.028
-44.8822
727.698
-1619.7
-405.69
992.931
-653.181
-856.292
-762.569
384.785
-341.252
-43.533
-450.418
-491.513
-399.221
381.447
1107.05
-627.777
870.341
-503.471
591.384
-429.596
1338.52
-1691.48
708.786
-1835.89
627.271
-537.506
506.937
-861.694
354.757
240.329
-560.518
320.19
-293.639
403.694
-354.314
170.295
574.726
-297.591
-478.815
1178.34
1124.5
-677.731
-602.221
-465.262
391.698
-413.598
21.9004
-502.421
208.516
461.336
-190.421
-335.399
-201.417
758.224
-1081.23
489.132
949.806
1054.36
-446.707
365.595
55.2557
501.73
1057.6
505.17
871.558
1091.41
822.461
-1488.33
665.872
473.412
-1291.63
699.748
-210.266
-265.358
157.401
-394.157
617.893
793.047
-609.047
-132.587
226.831
238.214
228.095
1677.5
-479.804
-735.738
-334.386
371.952
-37.5658
1176.33
-479.121
-697.207
451.549
-76.6759
126.295
311.123
-591.231
443.661
-713.905
1156.55
204.413
664.952
1428.83
-1229.4
740.931
-411.923
140.528
-130.208
-676.999
620.373
529.797
-317.725
1125.28
-656.698
1138.96
-511.183
1213.09
746.401
-633.721
375.446
-36.2306
1547.91
-787.685
1693.71
-1017.08
829.337
-1245.48
35.6349
-85.6568
615.017
-801.523
-796.563
-422.407
1276.47
-51.179
-528.073
-270.05
-1217.83
-605.966
753.97
-278.156
917.457
-467.692
-361.462
106.645
110.1
595.558
-239.551
-277.359
1262.28
-606.182
-558.26
598.338
-671.039
35.4765
19.9486
381.621
-339.571
-42.0499
237.122
-1100
785.592
294.254
-1029.99
362.41
221.777
-584.187
643.19
-252.838
708.775
-455.937
-770.491
-390.422
-1047.5
507.355
470.95
-1184.85
-877.749
354.512
-95.4376
195.919
934.617
-32.1233
513.365
-1170.06
1823.28
-920.091
-42.1318
28.0597
22.0316
24.7987
632.018
-490.425
106.842
-758.769
-447.229
-640.26
-494.563
777.926
-466.822
-986.365
-1218.86
-99.9328
-448.289
758.165
927.818
-434.599
176.871
-376.917
-11.2635
801.774
818.758
446.465
-341.22
380.206
-38.9861
-480.335
-635.449
265.983
-633.629
322.521
697.569
-238.384
325.238
1177.91
53.2057
-472.668
663.325
-1631.89
968.567
296.781
200.633
-405.727
571.529
-359.747
238.145
-686.434
-430.249
201.343
-265.903
-234.938
943.194
759.677
212.209
320.03
-974.859
544.974
-62.2021
297.982
-758.139
-685.508
-1010.42
796.295
-1245.21
-923.27
312.085
-515.826
164.497
-374.477
-376.187
912.682
-349.428
-499.126
710.7
23.0524
76.6759
468.901
1179.87
-734.781
52.0617
-385.24
660.718
-516.152
-646.472
276.353
-433.865
1233.92
-318.967
299.774
19.1929
1815.32
885.952
529.887
-325.823
863.912
-1456.23
-1880.61
875.405
766.978
-352.751
1640.19
527.77
126.888
-94.5712
-83.2411
177.812
1733.37
723.654
-1399.19
1727.64
-750.903
1060.26
-39.9599
1245.18
45.632
299.358
-728.111
-249.426
-62.1807
299.978
-791.491
1040.94
542.699
229.926
-657.187
-716.494
-144.014
1220.09
-234.14
-286.697
-133.477
-133.949
267.426
-1054.2
-231.823
-699.691
-612.871
-1313.16
538.605
-570.579
-1268.91
1118.31
757.752
-348.395
-75.4392
366.377
-325.861
-40.5154
1813.07
-511.505
74.8974
-238.309
-81.6048
-443.777
955.754
-649.52
490.603
546.033
-623.937
-70.1848
315.481
-122.025
293.897
166.696
213.84
-1179.87
-83.5792
-171.16
-154.918
326.078
-287.736
-827.022
-388.068
-131.05
-879.372
-1129.43
-1494.47
-547.925
-1494.47
1467.16
532.837
1467.16
62.1807
-331.202
117.313
1039.12
734.183
1295.82
-1143.09
-479.165
-859.434
-435.221
-688.968
-247.489
678.706
-400.805
312.261
-1792.32
-462.165
35.1056
-378.407
756.834
-593.522
421.675
-674.513
-473.602
652.246
-430.47
-1137.95
-742.51
675.916
-1706.53
-791.087
-703.46
1718.65
-520.663
243.304
1081.09
-418.296
-79.5644
-106.271
-1475.16
590.229
1604.84
207.801
-1452.08
-456.07
-1433.35
269.396
-1015.56
471.884
455.934
512.176
-883.016
-168.958
-214.634
383.592
-758.944
-348.309
457.912
-238.526
-777.841
-447.66
-607.535
1523.53
707.259
356.683
-764.68
453.077
1131.49
-695.683
-845.868
-637.998
270.836
-659.798
-34.5156
-491.856
1256.96
-855.2
1496.61
-392.424
-381.455
737.126
-392.901
-900.43
-880.561
-438.125
514.168
-348.96
-159.886
508.846
140.751
426.63
-459.137
1446.03
1610.77
-620.485
-627.837
1178.23
-994.496
275.029
-319.119
-436.941
1128.47
-539.463
-229.013
968
-431.455
-134.751
328.16
287.736
-1371.75
-24.7277
-377.197
-36.7697
36.7697
-339.638
-436.09
956.345
-630.157
1329.91
-431.036
-523.951
-1619.58
832.12
-345.048
-262.795
-1215.84
1207.32
-578.189
190.818
428.66
-918.405
-587.496
259.83
509.978
-296.023
-647.763
-476.811
-215.923
-176.403
392.326
-837.368
-174.347
-216.132
390.479
-218.099
-169.872
387.971
-135.186
20.0205
899.401
-1530.59
381.535
-193.336
187.957
-1040.34
1072.47
-513.97
-685.481
-412.213
1097.69
965.761
-224.565
-169.329
393.894
-382.311
427.943
1365.83
1700.98
787.47
-1493.57
728.892
147.094
303.284
29.2051
-65.9748
439.93
-130.553
811.051
-444.05
510.635
-713.309
-620.961
-113.665
130.683
505.146
-53.2693
-469.527
-399.574
-670.319
-1609.48
790.518
-225.92
-169.276
395.196
-909.758
-527.034
1646.21
-1537.4
-871.525
1095.66
-1131.98
1637.6
1074.59
-839.34
-912.494
131.271
-629.369
1709.98
900.079
936.684
699.252
-110.855
900.544
-359.511
-287.344
-371.468
733.795
398.599
503.171
616.711
548.279
-343.366
747.81
328.488
1615.08
1404.48
-469.866
201.303
-223.58
-688.083
-27.6732
135.362
-904.294
382.502
-810.462
946.791
843.075
35.4765
-266.592
494.741
265.8
-593.493
803.625
223.055
203.342
198.794
1597.7
50.4067
916.405
-966.812
486.952
-380.149
192.071
-1129.04
488.776
30.2237
841.033
929.469
-193.761
-199.969
-384.218
-375
-502.749
-627.37
265.908
-864.7
473.342
-481.395
-351.788
52.7565
768.431
-468.073
891.152
-103.751
-469.514
587.889
908.719
367.18
-187.399
287.24
953.851
618.461
55.0588
321.224
275.265
-1249.81
113.665
-898.135
587.456
310.679
1726.72
-441.776
-322.922
274.953
-413.484
795.234
119.462
344.196
1248.72
1551.13
-667.792
-685.182
753.046
-309.43
850.928
-541.499
-497.301
486.049
-425.999
842.801
383.865
609.862
-383.756
-1376.72
1066.25
-114.675
1895.38
-699.614
214.552
543.633
-228.194
758.751
-328.128
254.336
-1126
423.171
-1385.96
1371.31
416.045
-230.782
-165.429
396.211
-801.786
-1661.23
-925.176
186.521
41.0603
-625.724
1034.21
1217.83
-673.252
-765.367
-679.985
567.71
510.728
533.176
-1232.79
957.323
-254.208
1203.69
-542.926
796.779
-1321.03
1121.21
-26.2741
61.7506
-609.518
1411.29
235.303
-637.745
-908.352
395.442
1221.94
224.11
214.05
30.7313
-958.761
839.941
-891.365
-256.896
305.444
772.589
712.82
1177.41
356.787
-678.04
-342.748
-322.458
-303.951
-726.257
-465.281
548.349
-398.168
-35.9881
86.5976
-9.77384
-761.731
317.954
-1338.75
297.873
504.068
671.979
-1176.05
-1118.04
-369.033
-405.91
-512.176
-1165.93
-1551.53
631.697
-318.498
-1127.45
-381.572
-389.676
779.981
403.312
-1098.99
-47.9688
352.172
300.299
273.002
607.913
-1037.94
317.846
-426.279
364.951
-231.228
-246.355
-211.932
-1538.17
421.959
-1539.03
-1487.99
-229.146
1108.76
26.8055
-456.196
1087.18
-582.006
-672.843
1134.18
834.522
382.01
-787.7
674.485
-261.644
-398.155
-426.894
-558.337
1060.07
390.27
-212.287
-177.982
-338.318
-808.289
-417.036
1225.33
1956.31
54.345
371.865
170.878
-541.027
-320.667
269.789
343.814
-148.862
-194.952
-394.405
166.9
-388.925
440.987
-403.919
785.929
643.472
465.733
-435.002
-361.141
-104.662
-929.315
399.093
-243.685
-774.517
652.859
499.971
1175.59
1041.83
-1247.66
826.152
-556.089
-103.636
1580.91
-581.536
1126.51
-305.11
1685.97
-106.199
-232.62
354.223
864.909
426.677
-1401.31
-336.051
-1436.51
1347.73
-648.48
726.772
-1361.38
669.652
378.374
-440.507
-626.599
-551.072
505.494
-207.781
-975.622
-852.814
311.787
1127.67
1547.93
1028.42
234.862
498.106
39.0174
460.499
508.883
986.593
566.407
-329.284
-304.717
1557.17
-177.806
807.339
-1386.02
890.347
457.179
-622.295
-154.723
-342.578
331.929
-607.56
1153.09
545.748
-318.917
308.183
445.394
-304.643
246.504
-447.196
-125.014
-871.053
177.043
-613.047
-507.336
426.641
-1034.5
181.346
1019.52
509.769
803.235
372.82
-247.278
-413.422
1504.94
-755.821
-493.985
11.6543
-742.627
1173.72
-1744.94
1179.49
-204.035
1356.24
313.634
-387.057
-155.311
466.434
-338.445
478.472
1550.06
-154.243
328.117
-553.579
1423.59
-1198.31
-1336.81
432.851
413.653
-1096.19
214.676
-386.004
370.622
-400.969
472.453
1084.72
-505.518
-574.558
1230.94
-1214.68
528.941
320.54
-1219.29
-1272.67
-265.175
75.9129
-485.512
326.471
-766.666
310.596
-34.5908
-545.507
390.784
-395.249
271.146
-150.058
-922.148
-485.709
-373.825
1114.32
-393.747
-271.211
295.567
400.943
438.172
-547.548
276.06
1666.53
-1606.96
-120.629
549.602
-50.3552
-732.037
223.915
48.5481
-1102.63
-434.693
-903.228
269.506
965.195
-338.482
-982.546
-338.726
-0.0184036
208.916
-703.853
784.426
-701.296
489.675
-176.246
-236.69
412.935
-327.308
50.3712
-365.917
999.504
952.039
-415.661
199.017
173.803
-666.075
245.134
365.819
-388.553
1090.8
240.049
-400.058
1136.37
-630.88
-121.281
306.781
74.5881
-1708.4
376.528
1359.02
199.188
61.9974
-0.652064
-441.604
188.896
1508.21
185.96
-821.376
441.127
-1565.46
1544.93
271.017
-124.951
-290.601
-157.978
1090.95
177.891
-301.382
322.311
-325.965
654.453
507.622
301.218
-573.14
-997.695
191.76
-175.407
603.719
-345.011
673.128
336.193
324.525
-778.439
1217.21
40.3821
347.042
-494.835
786.931
316.077
735.348
361.409
104.007
-640.04
933.468
332.531
-448.712
291.283
256.209
-966.122
-281.539
17.3585
-160.92
1536.28
-300.486
1343.05
-197.589
375.48
340.719
-1164.94
415.418
-824.447
375.735
-348.348
-696.043
1038.24
673.146
-500.794
-764.454
252.949
395.064
109.515
-326.666
-169.793
358.689
-573.979
-1012.14
661.801
183.669
-621.803
-172.683
-781.101
-453.858
-203.785
-892.409
-303.922
1152.1
476.788
1753.88
-635.566
-84.0268
414.165
-668.367
-177.755
-170.593
-346.258
-151.753
-1469.32
424.628
-194.134
-304.238
-456.532
768.319
338.109
551.417
610.788
-299.249
579.291
222.66
1006.77
-806.704
1316.21
605.589
297.567
-235.569
-559.625
-27.3443
-442.17
-1083.16
38.8603
-373.104
-342.091
50.6062
-367.383
-798.906
184.535
-44.9008
97.4955
1138.41
-543.787
-135.742
823.629
282.853
-352.027
-1085.24
574.283
-301.284
291.428
824.788
362.21
31.0091
-437.132
-263.178
1477.65
495.102
249.454
-98.1251
1236.53
-209.702
-185.547
379.859
-870.565
-222.133
210.457
175.548
-353.53
1407.33
-496.024
-177.397
-144.234
62.0597
13.9763
-153.707
139.731
-21.1185
22.0995
-0.980997
-333.687
207.536
126.151
326.2
-42.5461
-283.654
-200.906
230.16
-29.2545
21.2455
150.907
-172.152
-4.68073
-8.77985
13.4606
26.5281
-13.9284
-12.5997
200.394
-186.417
23.8737
-224.78
213.427
-121.385
-92.0415
378.219
-397.182
18.9631
20.792
-13.5797
-7.21231
171.033
42.3938
-254.76
313.354
-58.5935
-55.218
67.8079
-12.5899
449.858
-188.31
-261.548
-195.985
119.796
76.1894
-44.6572
126.359
-81.7022
368.471
27.7395
-396.211
-479.26
451.529
27.7311
-5.69789
-46.9485
52.6464
-16.8077
-0.518091
17.3258
-100.837
122.082
64.6692
276.963
-341.632
-209.061
-16.1374
225.198
294.006
-420.292
126.286
-44.2058
134.063
-89.8568
-0.104234
0.642966
-0.538732
71.5778
81.0373
-152.615
-0.743368
0.857289
-0.113921
-0.743137
0.857133
-0.113996
-0.743423
0.857246
-0.113823
-0.736391
0.848344
-0.111953
0.736433
-0.846891
0.110458
-0.736414
0.848351
-0.111938
-202.572
158.366
-28.361
193.309
-164.948
-32.1499
22.2939
9.85595
182.018
267.841
-285.755
259.553
26.2018
0.918614
-1.02285
-14.7496
-0.776379
15.5259
33.5345
110.911
-144.446
7.3076
19.2205
377.417
-312.748
72.6158
-294.6
221.984
100.419
-109.723
9.30413
101.245
-133.006
31.7604
-3.04316
26.8999
-23.8567
209.187
-175.652
129.486
38.7314
-168.217
-122.403
-106.435
228.838
-10.5758
-10.5428
126.882
-155.243
47.9458
58.362
-106.308
278.779
59.8705
-338.649
19.9499
-24.6306
34.6189
-38.1303
3.51138
-19.6239
-12.5259
-92.2708
37.0529
-0.806453
0.653276
0.153176
106.307
-5.88863
63.1951
-62.7151
-0.480016
2.15232
-136.787
134.635
362.501
5.97047
-0.695255
0.695255
-291.904
-10.5799
302.484
3.03239
-0.252811
-2.77958
-0.876054
-0.0920075
0.968062
-264.13
-112.331
376.462
-275.288
20.5279
327.969
-1.76888
0.850311
0.110306
-0.960618
0.857983
0.103886
-0.961868
0.850987
0.11215
-0.963137
0.850965
0.112166
-0.963131
0.86902
0.0991896
-0.96821
0.85796
0.103852
-0.961812
-15.6421
0.892494
-3.01276
-13.795
25.8225
107.133
-132.955
0.822323
14.6968
-15.5191
-214.14
91.7365
159.087
-156.934
-29.8132
-161.462
191.275
-139.296
165.118
392.142
-98.136
9.75689
1.43697
-11.1939
-57.2709
-138.714
0.653202
-0.575616
-0.0775863
-448.91
321.049
127.86
-264.37
221.824
113.257
-105.28
-7.97764
-229.426
302.042
-40.6234
363.691
-323.068
-200.955
247.527
-46.5723
-283.627
105.288
178.339
-262.254
-71.4331
-0.819893
0.952361
-0.132469
-0.884882
0.141513
0.826609
-0.0901758
-0.884872
0.141734
-0.884991
0.141568
-0.831943
0.0955525
-0.831973
0.0955595
-27.5943
56.149
-28.5546
-77.1752
206.661
-185.252
322.989
-137.737
179.975
-411.573
231.598
452.943
-167.41
-285.533
-1.19648
1.20923
-0.0127457
35.257
342.962
-123.403
146.701
-23.2985
60.401
72.4045
-132.805
21.0997
-2.25101
49.2918
-47.0408
-41.466
-21.272
62.738
3.53457
327.183
-147.209
-34.3284
94.7294
11.5495
-12.4952
0.945693
-0.936675
0.116783
185.844
-205.865
20.0208
-0.739873
-0.0665801
112.347
-64.4011
0.497368
0.155834
0.136274
0.58017
-0.716444
9.8397
102.507
-229.452
289.586
-60.1348
127.215
-43.8496
-83.3656
15.8889
-4.33949
-190.147
375.594
-185.447
153.588
299.356
30.624
32.5711
67.6461
-112.303
-420.248
379.624
-320.983
178.558
142.425
140.281
-107.061
-33.2195
-126.675
-21.9854
148.66
4.53151
-4.53151
-27.5943
190.345
-296.779
-21.2106
93.6151
-1.87374
4.90613
-0.791613
0.895994
-0.104381
-0.798655
0.903618
-0.104963
-0.791616
0.896006
-0.10439
-0.772934
0.883612
-0.110678
-0.798417
0.903072
-0.104655
-0.798388
0.90304
-0.104653
-5.88516
11.5608
-344.706
333.146
-46.1231
-16.592
193.646
-237.348
43.7024
-66.6372
60.9393
253.293
-283.106
-22.8898
-22.5873
45.477
0.173251
-33.1754
33.0022
-273.72
-12.0357
239.751
142.601
-382.352
-1.05858
5.5901
301.004
-22.2249
115.481
-305.628
-422.648
158.518
11.9814
10.1182
157.612
64.0813
-221.693
88.857
-385.521
296.664
66.7448
-296.171
-389.754
58.7736
330.98
9.09926
-50.1656
207.778
-6.20224
26.1521
0.318717
-0.182443
47.879
237.96
-285.839
13.5759
7.21616
-10.4746
-276.536
287.01
-0.763961
0.0687057
226.021
-403.85
177.83
-27.2533
-97.342
-80.5077
-241.275
40.3198
0.776396
-0.881637
0.105241
-262.07
-120.709
0.034547
-1.23103
-47.5832
-102.201
149.785
118.197
-46.6194
-2.32667
59.8926
-57.566
-81.3929
139.755
-24.9229
-21.8887
46.8116
-16.035
0.227615
15.8074
-158.188
-262.104
122.943
20.4862
-143.429
-319.624
-159.635
-124.066
69.3656
54.7002
192.205
-6.36061
-313.652
128.401
-26.8217
203.255
-176.433
-372.227
183.918
-129.424
-9.51176
138.936
-119.157
-13.6481
-39.413
8.36559
31.0474
-269.444
221.97
47.4742
39.3348
-162.738
31.6278
-33.9545
-40.5637
34.3614
87.6761
19.101
-106.777
-287.479
-36.7187
324.198
-190.589
142.295
48.2938
57.7928
-45.969
4.50298
-113.612
-4.14254
117.755
280.312
-213.568
-99.0083
30.7725
68.2358
191.309
-80.3974
-175.263
-196.964
14.0592
-126.909
112.85
-140.673
-214.962
59.1563
155.805
-156.015
135.479
20.5363
12.6836
114.532
-266.84
25.5817
241.258
-273.208
43.7563
-81.6347
95.6939
-9.03792
-30.3751
-0.358824
0.358824
-178.404
-35.7362
89.7324
-2.05628
-2.99592
-7.57984
43.1053
-52.1432
-247.474
297.778
-50.3047
42.1129
-15.7489
4.273
11.4759
8.06421
45.2613
-53.3255
-0.24966
193.558
58.691
-318.994
260.303
-11.0102
-29.5535
11.5247
139.382
-6.13164
-149.883
44.8666
-55.8768
20.347
-135.962
-9.8679
145.83
221.242
-3.34337
-217.899
-1.20244
1.25837
-0.0559288
-21.8749
48.06
-51.1031
265.351
12.8118
-278.163
3.09456
-2.45159
-27.5943
1.24613
-0.33232
-0.913812
-12.3577
-64.5778
76.9355
-148.012
104.162
26.4196
-29.4324
-5.47163
-11.9201
-232.604
244.524
60.001
-59.8278
22.0634
-17.0044
-5.05904
292.21
-52.4588
-151.288
171.309
0.835129
0.273484
-1.10861
33.9466
0.672305
105.443
-91.7949
-13.6484
-0.887369
0.00248733
-0.88733
0.00245841
-0.956522
0.990894
-0.0343721
0.892565
-0.0659561
-0.945565
0.970233
-0.0246679
-0.953453
0.981985
-0.0285324
-0.887637
0.00264612
-0.893373
0.0614299
-0.955394
0.990677
-0.0352825
-0.893392
0.0614182
-0.945691
0.97112
-0.0254296
0.977456
-0.943019
-0.0344365
-0.954933
0.990699
-0.0357652
34.1563
49.2334
220.296
-269.529
0.252811
-0.389361
0.13655
154.323
-0.442766
-153.88
17.2774
352.648
-263.791
188.266
-36.8226
-151.444
204.859
118.13
-28.2024
-209.24
237.442
-10.0585
-256.781
-74.8788
-49.187
209.968
-0.780697
-33.371
0.163671
109.916
-24.0428
-21.4689
45.5117
331.999
120.094
-452.093
-126.207
28.8647
-37.7839
12.861
-18.7443
154.066
-135.322
242.818
-3.80152
36.6365
-32.8349
6.74988
29.9735
-36.7234
-232.927
71.4647
69.7192
-1.91131
-32.332
-80.8553
113.187
-118.835
-0.322133
-331.955
204.576
127.38
237.604
-43.9578
67.1303
-407.278
340.147
84.7496
-346.819
36.8514
-10.4317
220.809
-200.323
-159.485
32.8103
0.34017
-0.34017
77.0103
-95.7546
240.125
25.2258
33.221
234.06
-267.281
181.415
-208.237
104.237
-2.9912
327.438
-268.747
0.65549
-14.2352
-0.101546
-177.914
-105.713
231.146
-243.066
-5.5603
-12.048
17.6083
-2.77884
53.2622
-50.4834
-0.933013
-15.102
-362.194
373.755
-21.5909
69.6509
-0.810947
1.9305
-1.11955
-0.178669
-25.1409
25.3196
-253.503
-19.8452
273.349
2.09917
9.98813
-12.0873
68.5764
382.952
-90.9966
312.312
-221.315
235.834
-326.831
25.6667
-23.5675
216.844
-222.975
-56.5262
403.407
-346.881
-82.5132
100.491
-17.9781
45.4365
-45.6152
33.0998
-30.4647
-2.63515
0.330818
0.394264
-0.725082
9.77152
59.9476
0.817622
0.795605
-1.61323
-66.2928
-69.5149
135.808
0.251626
-0.827242
-313.367
380.498
362.868
-92.8355
-270.032
-209.841
-239.069
-99.0922
-14.5199
311.961
-24.3399
-287.621
-425.699
11.3785
-150.674
-117.278
224.43
-107.152
205.42
-236.004
30.5831
-11.6838
-275.159
286.843
37.4626
8.92563
-46.3883
25.033
-160.995
53.0549
-56.8565
-103.993
69.6642
-26.8361
-188.126
5.01892
40.5447
-45.5636
121.991
-113.447
-0.772673
0.676166
0.0965066
-0.77279
0.675283
0.0975069
0.761525
-0.670659
-0.0908659
-0.772835
0.675323
0.0975121
-0.848391
0.636856
0.211535
-0.762634
0.674426
0.0882081
-0.762638
0.674424
0.0882144
-1.80139
14.4627
-12.6613
-30.7589
31.5812
-78.5102
165.527
-87.0168
-47.853
35.4953
180.369
-202.355
13.6199
290.363
-303.983
-34.6094
11.7196
0.990595
-0.493227
93.894
-82.9334
-10.9606
321.477
-378.003
-117.194
-213.187
330.38
155.671
179.59
8.67662
-22.8589
30.9231
302.674
-289.862
243.06
-37.6392
-25.74
359.84
0.0649204
0.630334
-26.967
-7.92352
34.8905
168.761
-178.629
-19.1691
-18.9612
-5.8422
264.753
-258.911
-0.876054
426.625
-273.038
-175.627
79.8887
95.7384
137.766
-216.276
-187.502
22.5192
-0.45573
-26.3023
-150.938
177.241
1.49119
2.59549
-4.08668
-14.3314
5.34771
8.98368
0.850311
0.857983
0.85796
0.850966
0.86902
0.850987
9.88438
-184.442
160.942
23.4994
215.008
154.343
159.011
46.6589
-9.19624
-114.587
48.294
317.241
-284.02
339.351
-128.98
333.839
475.5
-355.88
-119.62
0.140074
-32.184
-66.8243
31.8108
1.28902
173.224
-182.736
90.6422
-147.913
-106.474
108.346
-1.87196
318.374
-95.4345
-222.939
341.158
10.9509
-352.109
-153.257
1.96878
-87.2154
65.6245
309.793
38.9184
95.1442
0.403209
-0.403209
271.286
-80.9418
-194.453
189.836
-47.5413
-160.071
159.628
-283.804
13.1903
270.614
-0.218138
-14.1132
69.5551
-9.66249
-83.7342
-20.2584
15.6438
-167.657
152.013
66.3066
-21.0453
306.314
-302.236
-4.07831
-238.446
-255.799
5.85595
249.943
23.3859
-276.889
-319.154
377.813
-58.6595
-273.985
-2.55083
-50.8052
371.855
315.023
-265.789
-454.818
370.815
84.0027
-212.818
233.755
-20.9375
202.35
89.8597
-154.823
166.202
20.8159
360.865
-381.68
154.507
-64.8746
-89.6326
-1.04478
-0.157666
0.884395
-1.69534
289.117
29.2574
-13.1396
40.8921
-27.7526
-33.8995
28.3392
0.296135
1.19506
-4.91394
-0.0148855
4.92883
0.745785
-0.414968
-0.52396
-220.129
220.653
-164.156
0.813853
-0.160577
-0.813169
-1.10543
1.9186
36.4038
-6.6632
-29.7406
59.3317
-14.4651
-5.03054
346.189
190.21
-109.173
55.1546
-12.0493
-139.673
-192.283
324.454
67.6877
59.4595
-343.798
284.339
371.512
-382.092
114.603
-32.3842
-82.2191
281.963
-301.808
-29.5835
-13.1757
42.7592
-11.7324
5.29598
6.43644
28.2579
-1.35801
-252.182
223.98
300.523
5.79093
-414.891
349.36
65.5306
17.0754
-18.4193
371.068
4.67194
-260.471
285.133
42.8357
-123.231
-166.347
289.578
-93.8333
425.833
-265.427
57.4735
-8.18165
-1.19506
-3.33645
96.1126
-18.0281
-135.679
-129.967
18.9664
111.001
-16.1058
-0.0186538
0.402718
0.587877
138.4
150.717
2.09907
38.3528
-14.2298
-24.123
0.836041
-1.14751
0.311469
15.9842
-1.28744
-163.836
-86.5146
156.719
-70.2047
-214.324
-104.702
319.026
0.95571
-0.00334841
177.176
-50.2937
251.445
-294.986
43.5407
-190.173
-264.644
-0.0853661
0.0857126
0.0844104
0.0857103
0.0843442
0.0846163
370.942
-312.168
39.7168
-8.08897
423.984
-366.191
120.555
-130.812
10.2565
47.2081
253.942
-33.6462
-212.631
245.219
-245.743
5.93917
-280.321
243.602
428.891
-269.419
275.275
145.464
-68.0632
-77.4009
0.763961
0.180308
-0.94427
29.8723
-32.6511
-85.6545
2.72108
166.552
-1.43384
-1.09349
0.120107
0.973384
255.268
-7.74035
45.608
-366.482
21.776
-22.889
-10.6951
33.5841
-313.329
369.959
-56.6298
4.21438
-94.8692
42.4144
294.578
-336.992
-3.66781
-419.678
22.4959
-207.747
-5.07037
306.959
1.17752
-0.359894
3.55296
11.0171
-14.5701
388.779
-367.964
-45.9849
16.0197
29.9652
-27.5466
23.8731
3.67344
13.5256
-120
-369.196
118.122
251.074
265.727
-0.687727
-0.688349
-0.687763
-0.673744
-0.686251
-0.686238
-42.1911
308.009
-265.818
-82.5177
-50.4881
-0.382733
0.656218
-3.16465
28.8313
-0.778622
273.749
-315.94
-16.307
-32.6746
27.5323
5.14228
-76.9979
-8.65658
1.54139
-64.3578
41.7706
-144.286
41.0131
103.273
-10.6722
79.0907
-68.4185
151.404
-126.745
-24.6588
0.93455
-0.0159359
-64.8697
51.7301
-170.165
224.188
-54.0229
-303.6
-9.72915
-0.802261
0.802261
0.836041
45.8679
11.6056
101.238
-138.89
36.6891
-52.1823
45.5191
-238.562
443.669
-385.636
-58.0331
13.4036
22.2287
-29.441
16.0698
-159.499
0.684388
-476.76
382.927
-23.6767
-257.442
281.118
-140.349
111.092
29.2568
-320.033
202.839
35.6508
-43.0533
7.40251
-32.88
284.325
100.396
-90.6248
13.0094
34.7299
-47.7392
-50.7007
42.7772
-17.3817
24.1316
-68.7261
46.8374
-249.789
309.249
278.956
-336.527
57.5714
28.9479
9.40491
162.985
263.64
-50.7871
36.5573
0.00210893
9.05289
-9.055
-0.0136038
-93.9495
11.4363
-90.2369
-3.71256
-96.2336
386.282
-343.867
-87.1185
324.871
-93.4917
-90.9499
48.4888
-18.5153
-37.5712
-121.914
-219.945
362.546
5.33704
7.24529
37.4548
-44.7001
-381.559
400.522
6.12586
33.2177
-39.3436
-242.224
131.569
110.655
243.417
-38.8412
-0.751995
-0.135335
-0.751983
-0.135386
-0.741349
-0.146288
-0.7578
-0.197133
-0.757776
-0.197618
-0.758111
-0.198411
35.2381
-2.80231
-21.5519
338.002
-59.0466
9.01136
-6.41587
-359.125
299.432
-183.951
-219.192
90.2865
-127.109
420.735
0.193879
-1.29931
-5.81214
-21.7344
-11.7324
17.3374
242.216
6.78467
-97.0216
5.20001
-22.5817
0.160031
1.75857
-5.08645
10.2865
319.003
-116.652
-25.1522
115.794
-413.105
50.9103
-269.501
222.929
267.463
-2.70995
72.8789
-12.8778
-217.65
-151.547
34.0889
-15.3734
-18.7156
11.1253
-18.0765
6.95116
1.1519
-18.1563
0.345663
-75.2079
223.154
-147.946
-0.22216
18.4418
-18.2196
-0.773001
0.971168
-0.198168
-0.769629
-0.925712
-351.102
-33.8894
-144.514
-15.1964
205.4
-208.744
12.181
-0.889218
-11.2918
24.3507
106.713
47.7942
102.709
115.641
-335.587
200.361
-275.569
-2.18797
26.6834
-24.4954
-218.062
-10.7485
228.811
26.9998
-20.8739
3.09667
-26.5163
-7.46943
21.0453
-0.0595133
9.59481
-9.53529
250.846
-283.726
-153.806
31.8926
31.596
-133.405
341.788
-208.383
54.5929
-8.725
88.5156
-244.685
156.17
-57.0974
74.4484
-17.351
326.239
36.6287
8.83073
-11.4812
39.0135
-0.0345386
33.4099
221.858
16.5021
-219.09
202.588
-200.507
11.9724
188.535
222.291
11.7687
53.1274
-18.3976
-113.196
-31.0902
188.5
-215.336
24.0607
76.3356
0.960819
42.5351
-6.88429
360.168
19.0333
-379.201
129.372
-75.4136
-53.9579
60.9059
-7.64371
9.95167
-11.2146
1.26294
-16.9936
70.0486
-134.331
-41.2963
5.84464
-5.65076
28.0446
15.6504
-43.695
-3.42073
-176.647
180.067
-18.8285
34.5694
-15.7409
-50.189
-9.63881
-112.624
96.5855
16.0389
-337.579
124.393
0.90808
-1.12574
0.217665
-12.9049
1.17249
9.94059
-117.002
-6.77646
38.3577
39.841
-3.20458
104.264
-88.6205
53.6097
-8.17317
52.0925
-36.3254
-15.7671
183.661
8.54422
-101.876
49.3081
-8.76337
12.1661
48.4898
-11.035
-57.4854
11.3623
267.786
-50.9426
0.103428
4.8254
-21.2801
-15.4433
42.4608
-9.24301
143.866
-145.211
1.34555
-6.81634
6.97638
0.683597
212.181
-30.7656
14.8844
-14.0323
-0.8521
-40.3471
-6.69369
-91.1629
-242.238
333.4
15.7815
253.775
-210.072
237.42
-258.972
-0.455406
10.0577
-9.60227
-3.3813
234.886
-14.077
-187.345
-20.8918
-62.4963
-24.7191
20.8414
-213.59
192.749
0.907653
72.8949
33.5922
11.8848
-75.9603
-118.003
193.963
-0.0813731
14.544
1.45775
-2.22737
-16.6626
72.0888
225.689
-184.166
-38.8087
49.6718
-82.8913
169.359
10.2313
-25.9153
-11.2012
37.1165
-49.4247
-8.14127
-344.385
-53.7076
398.092
-32.0197
263.63
-231.611
-20.6291
-12.8731
33.5023
137.898
-352.222
-27.7686
-7.61408
35.3827
-24.4875
-11.7495
36.237
-72.8729
8.2951
-42.9146
-7.56879
233.897
184.777
-282.714
-1.09
8.71016
-135.694
126.984
-0.29557
-0.0446005
122.733
-126.876
131.312
64.5181
-195.83
-263.748
-140.102
-29.6603
-21.1268
-23.2088
0.319735
-99.7179
-0.325721
8.34486
-8.01914
-48.2029
299.049
4.4039
-37.7275
-7.88766
199.34
-182.838
9.33955
-10.9765
1.63696
-386.711
-0.0121834
-0.0124445
0.0137291
-0.0124402
-0.0368887
-0.0118255
-0.0118134
-184.204
-2.21318
-135.024
131.603
-32.8204
282.763
317.586
-43.8372
145.17
0.791946
-145.962
135.346
-62.8828
311.299
-20.9362
-42.5316
-9.65064
95.6886
-0.467558
-0.679951
220.954
6.00193
-194.127
25.0909
-232.838
310.736
-8.06278
4.71709
28.0145
-37.059
-8.50462
0.14524
0.142263
0.145296
0.144011
0.144011
0.145507
-287.127
-28.8127
-268.748
-4.79655
273.544
-3.69044
13.6421
9.16975
-278.671
195.219
-336.888
141.669
-166.244
6.17326
37.0967
170
-1.239
33.4483
-120.988
87.5394
-287.06
-16.9234
47.4695
-19.4249
-171.346
170.905
0.440931
-42.1473
-9.99595
250.174
-161.659
12.1907
-32.8198
-202.798
0.442822
121.727
9.67228
90.8191
-0.768632
-0.113004
-38.148
-12.5527
-13.0996
-19.6691
-26.3158
-34.5963
-18.7291
-287.503
-2.35868
-17.6871
67.6244
-58.2782
-9.34617
319.711
-2.46978
-2.77731
-45.5133
-18.8445
-40.8914
-15.9651
-14.2722
18.5452
56.8721
-11.353
-232.511
-149.841
-38.3261
55.7464
-17.4203
-54.2369
-10.6328
32.5389
109.067
-141.606
91.8073
179.479
-31.63
7.14248
70.1065
120.104
11.7045
28.0122
331.379
-388.009
8.27675
-32.7377
6.82234
-6.34248
-27.0285
353.601
172.325
123.191
-0.45823
-4.79701
-19.8213
24.6183
-52.7607
25.7635
50.0756
-16.4834
137.113
87.3169
29.1202
43.2092
-72.3294
5.40173
-283.454
-0.566379
315.473
-0.450552
-187.128
4.39174
8.69004
-26.9437
26.0545
-78.221
-4.55896
82.7799
-171.884
4.22739
-10.4463
21.5716
147.793
4.22017
178.68
-184.252
5.57142
-48.5798
-160.13
5.30727
188.485
-118.378
3.22407
162.978
-118.527
165.453
3.90606
24.1721
13.6533
-14.7119
-179.727
144.597
35.1294
10.4862
11.5883
49.713
-61.3013
152.878
1.39556
-1.0013
-4.51954
-255.951
-12.8088
-9.7729
53.3234
320.432
236.119
151.576
7.51107
0.90808
4.82437
153.683
-159.493
5.81016
-8.34798
-21.765
30.113
-4.87209
-7.62306
0.618563
-0.773001
-1.12574
291.323
-9.35999
-0.864111
-0.864361
-0.8643
0.877195
-0.874922
-0.874924
-0.756674
-276.656
-118.895
198.783
112.527
-123.199
60.8019
84.6622
6.26456
-286.527
295.188
-8.66095
114.506
225.809
-340.316
32.2077
8.29565
-20.9282
-4.60077
249.82
8.93025
-10.579
1.64878
81.4481
127.333
9.59867
87.5099
-97.1086
0.164881
-16.6752
36.8754
-31.44
-5.43539
-50.311
-18.415
269.852
47.7339
-3.03678
-69.8362
349.65
-103.757
-245.894
-381.948
363.736
18.2122
2.40224
-3.12732
4.80841
-56.1742
107.102
-50.9281
-294.701
-42.2907
73.223
3.35637
-12.9049
372.36
-426.067
-13.2217
13.9563
-0.734604
6.44774
147.618
-17.3167
134.967
-145.928
11.9521
236.082
-341.268
105.186
75.074
-131.248
-265.102
-4.31684
-4.28155
-20.7066
24.9882
-28.6728
44.4542
-24.7767
11.2368
13.5399
274.328
0.94704
-109.261
-204.24
313.501
15.1901
-10.3816
134.071
-241.223
-23.6405
269.621
-7.32095
-262.3
-254.073
310.087
-56.0139
-127.985
323.204
8.61702
-8.36155
3.2751
6.79582
208.535
-337.516
32.6762
-119.191
-2.11759
7.70768
-5.5901
28.8511
196.487
-225.338
-253.68
-198.413
140.18
-33.0474
241.316
-246.386
-0.908488
23.6751
42.6315
-291.593
-142.397
-207.142
349.54
394.556
-1.39362
-393.163
-391.756
419.487
-214.372
328.878
-153.492
-212.991
5.29598
247.849
-113.778
4.56753
0.168908
47.9553
0.42963
-0.0839676
174.175
3.06578
33.2748
0.671833
-7.91516
-171.812
-80.0855
2.58049
15.8613
-12.5028
294.098
9.03555
-130.421
28.7792
4.49558
2.09278
164.499
-232.196
67.6971
0.342672
278.915
-99.4363
-5.11146
-3.25009
-110.392
9.55544
-345.82
384.463
-38.6428
402.966
-344.201
-58.7643
412.995
15.8957
-112.336
119.513
-7.17787
-0.959448
-0.149166
-146.42
31.6646
-47.1079
-20.9424
0.296135
-0.432321
-32.7431
0.773328
28.3146
-43.688
17.5384
-371.625
198.864
-386.366
136.842
-158.688
21.8456
0.877195
-0.8643
-0.874922
-0.874924
-0.756674
-0.864361
-0.864111
113.468
-2.77958
-13.7779
11.9042
238.399
-312.716
74.3166
-54.0599
35.5446
-9.44751
220.147
-210.699
63.1612
-53.5625
315.004
83.0882
423.322
10.3387
48.993
-222.357
0.522567
-1.44828
-249.687
0.00682582
-28.1148
6.38037
6.789
-0.710139
-67.9577
47.0295
-105.551
21.1146
1.74598
8.93262
-10.6786
0.368671
343.676
-107.594
8.29622
46.8584
-19.2936
182.608
22.6917
-205.299
-70.4421
2.02362
233.083
15.041
54.5141
-171.461
65.3069
106.154
39.4268
-60.5535
128.615
105.14
153.552
106.072
-122.379
375.58
-202.243
-30.5953
97.2568
-218.697
346.077
-323.632
-320.66
116.42
-338.553
389.463
394.818
-341.494
-115.459
-71.5048
81.0345
-98.3855
10.6434
-65.668
348.489
-282.821
215.959
-212.932
-3.02663
-63.3387
9.07847
19.7452
-28.8236
120.64
-156.561
35.9214
-0.971708
147.872
152.651
-302.276
-397.927
332.259
-65.292
46.5629
9.39553
-206.289
196.893
-88.7265
-0.825355
390.842
-65.9711
10.0279
22.2515
-32.2794
-65.4604
47.0628
-31.0308
167.873
108.429
-30.4351
-184.901
-84.8679
-86.593
-70.4053
51.5608
-125.173
214.292
-31.6848
154.767
-19.7995
93.5571
84.2552
20.3822
-22.4998
-131.28
-110.944
-282.719
64.0214
75.8201
-88.6979
50.0549
323.878
-373.933
160.356
59.1488
-219.505
297.787
-59.3881
29.765
24.9186
-103.14
0.509898
-163.81
155.833
19.9133
-9.8854
7.70768
-32.6755
71.594
-68.9294
51.5091
-113.172
-39.4429
3.65075
212.308
-280.539
56.8844
223.655
-66.046
50.2789
44.5807
-2.86814
-41.7126
64.1974
0.677597
0.114899
-0.792497
-143.499
30.3034
133.858
199.981
-70.3186
54.3535
-1.04276
80.3998
126.985
-207.385
191.083
23.2098
-38.8464
75.8915
-85.5303
329.196
-65.2078
52.6551
91.5297
20.9992
-112.529
-141.119
-69.8322
56.7326
-26.0922
-35.2567
61.3489
22.4562
-116.215
125.611
-63.5775
52.5425
-108.567
112.782
15.9002
-6.56062
72.8468
-81.5718
54.6099
-64.2606
-222.897
-111.003
86.2835
-70.3659
59.0129
-186.802
-65.5861
55.5902
54.7068
-63.4702
-59.0423
49.7993
0.0830473
-0.465781
-11.7298
20.3468
-80.0309
63.4389
190.212
125.575
-315.787
-75.8933
68.2496
49.933
260.154
-61.1236
52.6189
-62.2934
54.4057
338.568
-130.033
66.0536
-73.6224
-60.2662
-10.1759
-3.07061
64.0655
-55.1398
1.57785
-127.586
106.982
20.6035
351.08
-394.613
-137.496
63.6107
-71.7924
-13.0721
44.5807
31.2864
-293.39
-75.5081
67.3668
130.377
-66.0463
57.8732
-22.5014
64.272
-61.5342
54.6499
-34.2808
225.364
-72.1629
51.1177
378.112
-38.0893
226.2
-188.11
130.95
89.7908
-236.84
147.049
-74.3612
48.269
-63.271
56.5773
-19.8808
293.743
84.07
39.0641
-8.14099
-0.973732
-0.152012
59.1533
-72.8895
50.3882
78.7218
27.5854
-147.091
123.071
24.0198
-154.383
-81.1177
-89.5222
154.829
152.061
35.6165
-187.678
-1.01875
-74.2282
55.8132
-234.054
-132.713
-86.2229
-47.0979
133.321
258.487
42.8676
-13.965
-28.9026
14.682
-88.7762
106.054
184.21
-180.304
-176.793
182.966
-289.598
149.925
-75.6024
58.6087
99.7272
148.122
-36.0559
268.072
-26.756
249.844
-176.788
185.478
-24.0641
241.527
-336.961
-205.697
174.667
-217.82
-28.5662
-128.245
121.067
4.60951
-161.544
-119.083
186.554
163.184
-241.906
78.7222
-72.5738
58.1087
-178.257
181.322
20.1836
147.689
216.776
384.045
-123.652
28.243
-28.243
325.385
-1.08767
0.594438
26.6415
76.7651
-111.826
267.996
-68.1023
56.053
403.978
-372.692
34.5191
-222.141
187.622
-182.209
160.335
21.8738
222.74
-317.61
-174.921
180.731
-116.134
-123.387
239.521
17.325
25.5426
-0.0737932
96.6071
-53.3979
217.946
-227.393
-40.1091
-76.5577
65.9249
4.66108
13.9828
-18.6439
-218.332
197.441
33.2261
-223.234
190.007
-193.561
173.761
87.924
0.973733
0.0649204
10.017
-2.30935
-0.199479
-0.753974
-0.198228
-0.747337
-0.282451
-0.610922
0.26848
0.624086
-0.282252
-0.61114
-0.194589
-0.751101
-0.138248
-0.601624
-0.19145
-0.751569
0.387537
0.583584
0.386723
0.583509
0.21532
0.775357
0.211566
0.779328
0.20934
0.772645
0.217548
0.773151
-77.5825
67.92
195.238
-209.315
-21.162
-198.489
196.276
339.576
-140.712
49.778
106.941
-281.232
273.911
31.5381
-239.338
207.8
-196.136
195.356
-238.696
207.93
-55.5256
20.2689
-172.555
180.066
-176.424
181.732
-173.903
179.474
205.421
-222.084
-53.6359
178.947
-174.337
101.127
242.549
-179.128
183.355
-175.336
178.56
191.074
-186.357
-180.087
-311.713
18.7133
-9.63486
-74.5253
309.827
-191.697
-261.561
246.206
15.3551
-186.503
214.586
-28.083
-251.341
219.656
-205.802
188.115
202.347
-208.708
187.411
-187.661
-260.447
191.828
-191.385
111.871
-73.1394
223.973
-258.254
-199.883
194.411
189.496
-181.219
-157.166
27.4958
132.711
-280.426
276.109
-189.426
189.867
184.011
-179.619
28.7404
196.623
-187.714
186.475
-440.517
342.381
-180.336
184.556
15.345
-12.1627
-3.18238
13.1429
-4.21261
190.85
-229.908
39.0576
-268.093
39.4064
228.687
165.361
-184.311
-77.2493
-58.0363
214.916
31.3597
1.94581
0.45643
44.2315
0.349228
-332.123
311.187
-23.9612
8.22037
-292.492
242.187
198.911
22.3574
-221.268
27.1613
12.6798
89.3726
188.347
-179.042
-0.842426
-304.765
302.295
-292.909
297.733
-35.612
-0.548186
0.613106
309.627
-326.551
123.025
213.656
247.272
-460.929
156.122
357.05
292.737
-300.8
5.16242
-231.716
-48.823
-346.444
317.631
298.667
-299.233
-106.968
348.495
-15.6686
261.077
-245.408
1.24653
-239.693
-29.1098
337.685
-308.576
-18.2579
17.5478
-347.127
303.29
-294.086
291.728
-282.288
283.235
-291.753
295.109
44.2315
-49.3305
-288.576
286.025
-44.1203
-61.0287
-13.7019
24.3452
201.839
-30.9745
-163.153
-17.1695
-125.96
6.87443
119.085
-294.351
292.582
-295.42
294.969
-229.869
-62.6231
-38.5977
10.017
-248.613
209.805
-40.3102
31.9623
430.596
-55.0158
-317.755
309.094
111.53
-302.726
293.366
-127.878
265.644
-368.441
332.31
36.1312
42.6003
-294.319
251.719
-301.611
284.936
-305.952
49.6819
256.27
-198.446
-20.6442
4.25446
-0.992559
12.0097
186.111
-177.435
-120.068
336.8
-94.2504
-41.7126
-125.399
395.674
-256.019
323.366
-352.476
330.493
-140.282
-290.004
3.5263
0.981857
0.559533
-303.272
245.236
183.686
217.087
-135.677
236.03
118.709
105.559
-224.268
-84.8963
-272.319
357.215
47.919
289.766
23.4734
-140.183
-31.3763
171.559
43.03
274.05
-276.76
65.9378
-16.2249
198.191
197.483
117.566
44.1559
-162.159
21.4185
48.6301
-14.3705
0.575527
-21.4519
-301.915
323.367
-26.1045
-44.7883
330.897
-167.912
271.287
-67.2633
-195.996
-34.8293
34.8293
277.011
-369.846
344.478
-45.1226
-244.614
-141.751
88.894
99.5906
261.029
-129.46
-277.509
-60.0699
-202.483
-114.974
-375.067
287.949
-259.177
208.235
-288.757
244.637
41.9241
177.584
-373.58
37.3707
-17.6352
-19.7354
35.9027
217.792
-57.4362
-31.6796
-109.926
-6.01712
306.919
-300.902
-150.955
-368.891
416.81
-128.529
-268.743
205.861
247.175
-83.9917
-61.0852
62.864
-94.8569
379.808
-132.536
-279.692
198.75
-139.422
107.238
6.90103
-44.6392
37.7382
15.746
-97.3807
-245.727
15.345
340.725
-272.261
0.757543
-22.3953
-221.644
3.97178
-8.25706
4.28528
-82.6971
333.283
-378.406
-122.514
-71.4039
-347.143
206.469
317.205
-232.678
-18.7933
-28.5309
47.7886
-105.621
137.244
-87.4662
315.279
-354.265
-23.368
327.508
-363.739
0.615712
0.593514
-33.0014
-22.8289
318.485
-58.3305
-23.3424
-43.1374
112.296
-69.1588
180.476
199.333
20.3542
-25.6
-248.415
257.815
-109.694
-357.091
1.43752
-0.260001
229.832
27.2832
-25.0089
-27.7936
-15.8944
210.177
180.302
-57.0401
-43.7372
-54.6634
310.933
-21.1408
-152.926
217.444
24.1261
113.118
29.032
-29.032
-21.3288
-123.993
12.9057
0.736422
-101.354
257.246
261.978
-195.32
405.497
-19.2086
-20.0397
-24.2181
24.2181
19.2996
-17.176
-2.12353
256.648
52.9703
-309.619
-22.7191
-51.7494
-6.52881
0.4386
17.5496
-13.0466
85.879
197.006
19.2996
-182.584
290.137
-33.4884
7.5397
-80.2343
209.874
-129.64
-47.944
299.663
13.3913
-3.53537
-16.5777
-17.1771
-16.7225
-11.3923
-208.916
405.921
-49.9335
246.827
-21.2489
-31.2947
-1.15331
-48.0228
263.821
-14.0832
-159.132
173.215
5.6749
184.979
-168.638
255.805
-223.597
17.0014
-1.1401
-124.054
-178.549
-156.042
334.592
-15.8412
-14.5845
-29.9681
-13.0436
-327.37
46.0671
281.303
-12.1627
-305.556
349.09
-43.5336
-12.3705
13.3453
-0.974805
249.262
-334.158
-42.5559
233.406
121.226
-352.942
230.115
-4.70727
27.8934
-23.1861
16.6996
-76.5051
-272.961
257.292
23.1062
267.031
-360.672
231.99
-323.729
91.7388
-12.184
-22.5654
349.766
-50.3345
-41.228
70.1621
-28.9341
-15.756
-23.0118
27.6729
-94.1848
-244.429
338.613
-9.55378
-11.3242
245.049
26.2379
-303.8
-1.7565
-12.5121
-17.2571
16.8247
15
-10.8512
126.9
59.6544
-281.41
-64.1466
345.556
262.989
-29.1717
-97.7039
12.2942
-333.026
49.516
283.51
17.5496
-34.3558
5.68299
-189.407
-313.03
279.542
-264.539
0.481618
264.058
-14.7466
-314.594
258.58
49.5869
277.913
-327.5
243.49
-300.53
169.064
263.301
-321.632
-17.5447
16.115
-57.343
-31.2947
-12.8064
7.41716
44.6754
-62.6536
-10.5633
-148.353
-136.189
14.4302
-17.176
6.17799
-16.5034
61.756
-45.2526
-11.6406
41.0039
258.659
-25.4675
46.6352
-21.1677
-25.7705
-285.157
310.928
8.48058
216.296
132.793
75.2333
-319.662
-119.074
162.958
-7.25855
-15.7492
7.22143
5.80763
-143.743
222.465
-9.11011
7.97001
233.767
-294.853
0.677054
-10.2425
9.56542
-7.18226
135.297
314.816
-51.8272
-17.6656
-248.152
-351.795
257.544
-269.675
319.262
6.4017
69.3484
-61.3571
324.658
285.62
-6.51496
-17.5476
-17.9611
240.364
-345.066
-28.5242
45.1409
-2.14563
-7.02008
276.849
-277.937
256.485
-78.1081
-132.048
279.92
-8.62114
-10.2157
-66.8248
283.121
275.729
55.3078
-17.5696
338.195
-60.2817
-102.168
351.165
53.1777
-35.8526
167.089
-84.0523
-46.7595
-71.1043
286.053
-0.0788204
-63.0516
46.2855
-15.215
-287.38
-78.2146
365.595
253.701
259.397
268.763
-330.12
-58.1761
-274.85
-3.94239
-260.597
-0.984231
245.11
-352.705
1.18867
-93.8969
4.30659
226.072
-288.695
-215.875
63.7638
8.1736
-66.7626
332.526
320.47
0.552732
-11.8445
-0.863466
0.663987
-0.873326
0.675098
-1.06182
0.779371
-0.6519
-0.663986
-0.675098
-0.868667
0.674078
-1.06161
0.779363
-0.674079
-0.653347
-1.0555
0.917251
-0.78702
-0.871401
0.679951
-0.653854
216.884
-284.148
49.6546
-45.159
91.4964
-0.526946
271.893
-342.997
-6.17863
-288.267
188.831
2.89496
203.399
-274.803
57.3606
267.298
6.39168
-345.803
47.3246
7.98319
6.39552
6.16294
-343.175
321.182
4.22308
253.253
-368.712
-269.355
-58.1451
230.905
-31.9943
0.346521
-312.987
17.1521
295.835
-39.151
287.797
-365.905
31.1311
-66.1571
9.82296
56.3341
69.6255
-5.34089
-272.228
5.5736
14.3397
-5.72784
15.8408
73.0331
4.64468
54.8736
-54.2013
3.66756
-22.3831
199.781
-209.638
3.0196
0.757819
290.829
-10.5163
-68.7806
-101.357
-4.49377
10.0674
240.852
-366.251
-31.1311
0.907827
8.7841
1.83498
2.7918
202.996
110.505
185.257
32.3044
199.933
-320.098
251.317
-71.8109
4.93659
193.872
-271.121
215.814
-345.847
52.5926
-320.045
321.233
-80.7488
-1.83098
31.8672
-56.5261
-160.731
-239.176
218.532
146.476
-325.025
-9.02832
-351.252
-65.6323
-45.406
-5.06223
80.9307
-284.242
203.311
0.400802
-106.684
-262.299
178.307
94.6988
45.4814
-274.438
323.953
-3.13328
325.387
-58.0888
13.2465
-1.08037
5.47054
-17.7907
-24.3884
-22.1945
-2.95075
-26.3109
-1.51761
1.72703
8.84645
2.31385
-6.09816
-4.264
13.0466
133.151
-23.0941
-94.1231
114.477
-3.60699
-7.12137
291.846
-303.922
12.0755
-41.2555
-297.257
-15.7303
-3.89417
-249.855
8.20876
-37.2324
-5.97498
-4.12255
10.0975
0.170353
53.5938
-338.751
5.9125
-5.9125
-19.7366
88.9139
-310.229
-270.251
160.557
378.972
25.1354
0.91908
-33.8138
-99.4511
207.367
-343.044
-14.2966
-2.79053
112.718
-9.07203
-249.817
316.653
-66.8367
267.242
147.226
-261.003
89.6938
-80.0215
-298.327
249.504
130.254
87.1902
-32.208
27.7101
22.1945
40.2984
-283.838
243.54
95.0205
22.7342
-40.6831
151.909
243.286
-13.8192
0.041285
26.3109
272.404
-171.862
-29.7782
-283.252
254.886
-317.938
145.741
-268.255
-99.3404
339.766
-71.925
-29.4956
-268.107
-194.529
-4.10219
4.10219
221.594
-248.35
-48.2835
351.573
-46.0452
-92.814
-44.2781
72.1101
34.8317
-106.942
113.737
12.4222
-117.828
31.6051
6.80414
-95.5306
-132.771
156.72
-270.167
25.9034
3.82757
-3.82757
73.0112
39.285
37.452
-40.6344
203.291
-344.002
115.262
-111.973
6.42186
-55.686
7.00734
-76.8435
5.44306
-5.44306
212.724
-368.767
3.20391
-3.20391
-150.437
12.7384
-0.850949
0.919655
77.2964
-26.1787
28.6433
63.8821
-92.5254
118.317
-303.765
-3.7542
3.7542
-1.39055
15.3734
119.033
-3.54718
3.54718
197.146
-337.427
103.582
44.8887
-4.756
4.756
4.24702
287.599
340.66
-287.066
-17.885
10.3052
-298.542
3.75232
-3.75232
4.28968
-4.28968
-3.87582
3.87582
4.10051
-4.10051
-0.918836
-4.31624
4.31624
-3.64554
3.64554
-3.97046
3.97046
101.859
-38.4203
-128.519
0.274448
75.817
-25.4289
14.4725
-123.04
199.918
-341.669
-8.43248
-218.961
263.953
-360.278
-4.14961
4.14961
3.4916
-3.4916
76.3074
-28.0385
276.977
-18.1693
-283.574
301.743
-4.15616
4.15616
87.8905
104.234
78.5586
30.7025
-109.261
-49.3725
-255.541
226.975
9.71453
-138.48
125.326
-52.3146
3.46377
-3.46377
79.4214
-23.6083
125.831
-258.602
4.1819
-4.1819
27.6906
-4.03227
4.70933
-3.22334
3.22334
4.23934
-4.23934
4.05825
166.858
34.9795
-201.837
3.3761
-3.3761
6.07079
-60.5088
-11.2765
-6.6085
-65.7342
-4.17541
4.17541
124.464
-4.09404
4.09404
-38.8518
110.962
-5.32057
5.32057
0.552475
9.73399
5.66854
-60.8084
-5.08299
5.08299
-73.8316
-4.52195
4.52195
-89.5166
-4.10199
4.10199
-6.96634
-251.944
79.7729
-21.1641
0.279383
3.24692
355.484
-9.13217
-230.561
-19.4876
21.8666
-2.379
101.882
-231.522
-4.75743
4.75743
-22.9545
3.93631
-3.93631
-4.82881
4.82881
1.06513
-8.68819
-82.5222
53.5881
47.8486
-10.3966
-4.83563
4.83563
-9.927
1.14715
-31.2667
109.825
157.052
-230.597
212.931
305.461
-25.919
67.3414
-39.6313
-1.00905
1.00905
-11.5929
5.17701
-195.328
-297.39
325.13
3.80798
-3.80798
38.9984
28.3431
-3.70083
3.70083
-65.1744
86.1736
-107.731
167.386
-120.758
26.6348
84.9254
68.6266
-324.543
294.765
-265.971
-10.7883
-3.78107
3.78107
-276.397
-30.3396
82.9322
86.0027
-27.894
163.745
-7.80063
-140.41
3.11904
137.291
-34.2964
-214.119
25.8844
-271.715
245.83
4.55395
-4.55395
-0.5726
0.5726
-21.8871
288.918
5.01579
-5.01579
177.637
-78.5119
111.514
-33.002
-16.2042
-3.2906
19.4948
-5.00687
5.00687
7.57662
-6.15877
6.15877
-160.524
286.099
-116.183
48.8477
67.335
-5.70304
5.70304
-139.754
42.3352
-303.364
261.029
-7.06108
7.06108
63.0723
260.881
272.938
-15.6456
-17.5822
143.048
-35.8093
-3.72774
3.72774
-22.7085
-301.835
-255.992
33.1217
69.1312
-13.0782
-7.02735
7.02735
-330.573
-34.334
54.844
283.351
0.69553
-0.69553
118.411
-326.63
46.0176
4.83535
-4.83535
-4.63285
-229.657
-159.483
8.0391
-0.656218
31.357
309.303
292.413
-125.323
-5.18653
5.18653
-9.8561
5.88279
-5.88279
-181.152
3.7172
275.082
-53.2581
-26.2346
-272.308
-107.234
-43.5239
11.7366
0.708276
-0.708276
-2.11079
15.0165
28.1751
-288.772
-322.406
13.2181
-13.2181
-144.084
-315.56
0.0411036
-0.0411036
134.352
-214.86
-58.5058
-110.132
0.594438
-67.7524
22.4998
0.376554
-0.376554
78.372
-12.4471
-291.049
-21.3749
-0.390158
0.390158
-121.715
35.0778
31.8672
37.1101
-37.1101
-144.332
-356.474
-4.25595
29.7985
-1.35367
-9.66846
0.619484
-0.619484
175.618
136.178
-311.795
184.659
-46.2169
132.5
-177.74
141.931
-144.524
-29.9699
-69.4248
99.3947
-284.122
276.94
-28.9407
174.765
330.314
133.773
-13.778
1.17834
-33.3206
98.9452
-257.361
-46.0027
-3.53604
3.53604
-6.85409
6.85409
-130.212
-89.2931
-0.260679
0.00704536
0.253633
-6.6295
0.00720486
6.6223
-105.169
-14.9509
84.3166
194.422
140.169
173.113
-0.731252
-172.382
-122.097
-94.747
353.234
0.535999
-0.535999
-176.375
-88.5233
74.6529
-6.73288
-4.07089
7.49244
-3.42155
352.353
-102.509
54.4675
273.272
309.262
-140.135
52.9395
-13.1923
0.821753
-270.585
264.406
-75.571
-96.7637
75.4349
29
54.6762
142.761
-187.039
-95.9796
331.862
-235.883
-143.005
-3.33334
163.735
-157.927
72.0872
-238.434
12.4211
-214.119
267.09
222.738
-240.32
-189.623
196.845
28.8503
-107.362
70.7762
-61.0617
209.764
-353.849
-323.202
288.15
-55.3302
299.388
-283.672
58.122
-162.559
60.2128
-4.68501
0.549371
-0.549371
73.0089
66.1743
-99.1757
190.601
-1.3379
-189.263
-238.993
230.643
-12.1115
-108.037
66.9345
-88.1834
-7.78714
7.78714
-50.6566
76.56
-156.364
-1.3536
190.51
-23.6521
49.5758
86.3819
-3.53362
97.3824
-100.161
2.77864
63.1951
-7.80266
3.31103
4.49163
-100.804
-169.363
0.779363
-0.78702
0.917251
-0.653347
-0.653854
0.779371
0.722626
-0.722626
0.722731
-0.722731
-0.6519
0.722597
-0.722597
-76.4163
51.4074
-77.8732
62.032
-301.67
295.943
2.99868
4.76962
-15.7893
0.393823
-0.393823
11.6826
71.4183
143.594
-33.6028
-182.272
214.271
-347.705
204.699
2.86865
-143.004
-228.495
234.891
-29.9314
-96.8638
84.3517
10.1572
-10.6841
-57.0527
285.388
65.2573
-91.4361
270.296
-288.087
-10.1813
-72.3273
-1.16094
73.4882
-70.4511
-27.4349
97.8861
-18.8325
154.685
-284.145
-198.192
204.584
-74.6207
-27.4615
102.082
56.9472
-130.339
263.49
86.4741
-31.9315
97.1889
-272.019
-78.1653
67.3141
14.9646
-331.16
-15.446
-77.0794
-94.0594
290.863
-188.718
-3.54819
-28.6723
-62.3601
43.5668
27.8034
93.1971
-82.3904
120.827
-38.4361
-60.8727
-288.142
83.4004
-100.945
-31.4311
77.0391
-199.218
202.238
202.648
-200.813
-79.0303
-26.6409
105.671
0.511366
-0.511366
-0.0482448
-95.7849
-89.8824
61.844
-382.375
104.865
-194.764
203.548
24.0551
24.9738
-36.9859
37.905
-9.39838
36.0774
67.8087
0.535487
-229.873
20.4057
-188.829
188.098
267.439
0.205142
-3.57171
-299.543
1.53341
-1.54772
0.0143112
-0.216267
-71.175
0.458299
3.83652
-0.0983532
4.48607
1.52966
236.087
-308.862
304.598
-0.177921
3.42484
-183.4
-0.454972
-211.257
-149.021
-80.1503
299.012
35.7253
7.05192
-3.34143
-3.71049
-0.840989
-0.00143716
0.00145285
-0.828695
-28.9407
107.65
103.06
84.888
-95.1037
-94.3126
297.152
127.093
165.319
2.5164
193.703
271.234
-225.167
-268.451
276.66
79.379
27.0797
-214.741
213.223
-23.4734
-184.835
192.252
-227.393
224.259
15.4438
40.4753
50.0185
-90.4938
94.5243
-117.09
-7.66323
9.51486
-2.2987
67.6328
7.65592
1.85894
4.43401
-274.017
36.9287
-384.915
-219.084
-100.926
320.011
3.63669
-108.805
-257.606
369.721
-112.115
1.016
-4.78817
4.78817
-8.1134
1.4839
-101.327
-134.98
-0.689295
0.869603
-0.799307
-226.714
-349.737
-30.8114
273.093
-230.936
-97.7573
328.693
-1.22653
0.478723
-0.478723
0.237587
128.442
-52.6293
196.389
-216.126
121.208
255.253
218.545
-155.681
32.957
294.324
-33.2954
-271.495
264.98
5.53637
15.5089
12.005
-257.413
28.7816
-301.089
-31.3315
0.313842
-0.313842
7.3467
-335.904
49.1851
7.90287
-57.088
-50.3505
-64.2363
2.92937
266.97
-277.758
-190.346
0.988903
-0.994381
0.234223
-15.3362
-259.99
-138.258
99.1798
22.42
0.107154
-0.369771
0.369771
-0.0802406
181.576
-222.831
-254.188
159.875
6.42913
-6.42913
-169.381
257.255
56.6044
-82.2045
224.177
-344.885
50.9694
-104.367
-308.601
205.729
-199.551
-42.4667
0.565951
-43.1268
-189.551
62.3598
-85.7022
-44.7353
302.279
63.3569
-86.076
60.6614
1.66171
0.0089219
-99.2002
58.2139
-127.639
-285.235
279.894
-1.35804
-228.171
178.799
-3.45981
-155.672
-69.5487
12.0114
63.5643
-83.604
-95.8803
83.4332
-0.459377
0.12293
246.312
-35.394
36.061
97.2598
-153.952
76.5515
292.684
1.05015
97.6768
64.8879
-82.065
250.176
-292.466
-0.571402
-70.6035
3.0556
-21.0587
108.949
257.108
348.922
-330.71
200.692
-196.385
-0.161334
141.574
-368.282
228.528
-276.121
-24.9687
-0.351182
223.386
-241.805
346.698
80.7086
13.6384
-94.347
366.043
-56.74
187.182
-183.465
193.148
-192.801
-163.251
-101.882
71.5426
5.44513
-201.344
16.3613
240.178
-256.539
54.3488
-123.472
69.1233
62.4193
-73.7436
-4.30069
-56.5077
239.1
-212.586
11.5531
3.8203
34.4039
-108.287
73.8828
-10.3647
97.5176
3.2751
245.136
-132.418
-5.60539
-309.416
-194.908
195.815
-292.561
293.319
0.335451
9.6626
40.5454
226.988
4.36323
-4.36323
-41.4414
-4.94686
-110.315
-10.4429
-0.0887908
-0.0241852
1.02073
-0.99654
-197.553
202.49
224.937
118.457
48.9285
-0.971303
67.5141
198.073
-342.597
-78.6018
17.5401
-15.3266
21.2658
-12.4798
309.4
12.7059
-13.6776
-152.887
159.288
328.773
-0.942445
0.733896
-0.495851
-0.238044
66.8652
-83.4953
71.8547
-27.0545
-5.15359
62.8427
-20.829
18.4276
239.619
-146.188
0.833013
-22.3313
-155.775
-29.265
-15.3834
3.96424
-9.87673
-0.0834867
1.07404
48.0242
-3.34143
55.9858
-17.0935
30.3116
-313.697
307.599
-31.2347
-31.3998
331.087
345.506
-24.6191
-31.8541
26.4947
-101.908
131.072
-3.42155
-163.386
167.609
247.681
-23.3911
-0.220671
-3.88152
49.0208
-0.996695
88.9084
74.4949
-12.9853
65.9542
157.182
18.8698
83.2124
-1.22648
-76.6694
-3.12011
-7.29901
3.31103
-43.302
-63.4751
-0.933043
0.013372
160.493
-157.701
1.34337
-42.3326
-0.98819
88.9642
-80.4836
-3.25009
-14.6797
95.6567
-125.625
152.476
-17.2351
-22.1655
-2.66412
2.99868
-160.578
-33.951
36.3006
29.4784
-76.4679
2.92937
21.3247
93.207
1.97921
18.7993
-20.7785
35.7105
27.0275
211.083
-284.915
62.36
168.545
-0.143389
-155.531
-10.5854
-292.281
-3.08344
-3.54819
-12.5416
29.617
3.88152
0.640434
37.8681
58.7409
-30.3226
-28.4183
-42.6017
-16.7964
-70.2605
24.3248
-45.7421
-44.8037
-0.938442
-46.7165
-43.7772
26.8868
-0.466153
1.37381
1.05113
-102.026
-152.662
-3.62168
-1.25646
-1.31982
222.909
-20.775
-1.60816
-4.69715
-9.41609
-93.8744
-216.223
2.50737
-16.6041
-204.664
-2.50737
-125.719
-0.0380043
192.374
-3.81753
2.54494
64.0996
-32.0013
-1.32541
1.32541
-2.54494
5.02021
264.513
5.63474
-94.158
-391.205
68.1373
-15.6866
93.1624
0.265593
-1.03769
0.772094
-215.935
-180.275
-0.631555
0.631555
39.1481
-32.5307
10.8144
-187.41
-137.615
-0.482389
0.482389
-24.7898
-321.313
280.63
-23.426
0.250467
-0.250467
0.328543
-0.328543
0.219712
-0.219712
-0.35077
0.35077
-0.300996
0.300996
-0.353973
0.353973
-0.360108
0.360108
-0.330947
0.330947
-0.309005
0.309005
0.324775
-0.324775
0.364999
-0.364999
-0.300987
0.300987
-0.353076
0.353076
-0.327768
0.327768
-0.362427
0.362427
0.3563
-0.3563
0.329717
-0.329717
0.336959
-0.336959
-0.336185
0.336185
0.310457
-0.310457
0.329187
-0.329187
-0.316614
0.316614
0.32905
-0.32905
0.324359
-0.324359
-0.249649
0.249649
0.365318
-0.365318
-0.219812
0.219812
0.328409
-0.328409
0.324365
-0.324365
-0.216046
0.216046
-0.380843
0.380843
0.245026
-0.245026
0.335016
-0.335016
-0.336179
0.336179
0.362404
-0.362404
0.363776
-0.363776
-0.366263
0.366263
0.219704
-0.219704
0.219765
-0.219765
-0.364953
0.364953
-0.29557
-0.23287
0.23287
-0.250474
0.250474
-0.336599
0.336599
-0.219769
0.219769
0.316333
-0.316333
-0.366012
0.366012
0.221104
-0.221104
-0.363367
0.363367
0.321286
-0.321286
-0.336589
0.336589
0.32416
-0.32416
0.36624
-0.36624
0.252245
-0.252245
-0.248375
0.248375
0.368671
-0.363781
0.363781
0.324145
-0.324145
0.252343
-0.252343
-0.330488
0.330488
0.331782
-0.331782
0.252189
-0.252189
-0.294152
0.294152
-0.388704
0.388704
74.9151
15.904
0.449327
104.294
71.4332
53.2298
-19.2369
-1.32088
1.29669
0.719929
-15.4948
14.7749
-25.1433
292.495
-22.1987
316.017
-279.717
-19.8333
31.1006
118.684
-56.3184
18.2437
-2.49935
12.1935
-268.658
208.15
169.714
-3.81753
-6.70901
15.1313
96.9757
60.3952
69.362
-312.351
123.903
196.108
-13.0253
12.927
2.4573
18.1066
194.201
-2.4573
-0.871553
70.4223
-67.6568
-103.171
150.869
-2.13879
2.22896
-108.965
-2.22896
29.2667
-27.2875
2.49935
1.03669
24.1661
9.58388
28.2842
-361.549
1.73703
2.13879
-0.0326423
122.396
2.55459
20.461
150.561
0.0240519
312.733
5.16286
0.0236706
-5.16286
75.62
-8.30582
-1.82336
-18.9516
-0.0830474
-0.306314
56.6317
207.426
-0.672081
4.21719
278.616
3.49198
-16.788
-3.04532
-3.49198
211.935
-1.39904
1.36104
-225.244
-139.737
0.0854618
202.21
-41.0285
-219.418
-241.192
-196.634
255.871
-301.873
80.4006
-203.235
199.341
8.14604
53.5454
-333.262
33.3603
-6.84552
319.979
196.619
-75.6779
2.73519
-38.7805
-74.6851
51.941
-0.0841969
-247.39
70.8759
-31.7409
69.4008
74.4451
-0.633103
0.239281
129.672
66.0662
-156.724
35.9937
-13.6038
127.341
-96.9218
-91.3926
-9.16402
71.196
-31.6721
-29.6921
97.9057
282.996
-86.8885
-196.456
107.163
-0.27428
98.9522
-89.9002
-42.512
-0.566629
0.0707776
-199.585
234.273
176.454
-193.771
282.146
-51.2733
202.089
0.224793
-0.224793
-3.11508
20.1416
0.420179
-0.420179
90.2296
-26.8648
64.4966
-165.033
-0.250034
67.3114
-305.93
23.9079
0.14717
-0.939317
-63.7798
-0.693854
13.0051
87.3881
1.15334
-1.311
202.611
-10.5694
54.1362
16.5942
-9.63236
-191.96
-297.263
267.767
48.8423
-109.225
119.455
-14.441
0.862819
0.202253
-1.06507
53.4535
170.806
-57.447
9.51184
19.4866
-20.4579
108.641
-160.792
-224.123
-2.64329
3.69344
-16.7526
-8.17109
-375.828
273.319
29.1969
258.402
43.4647
233.195
81.2713
9.84534
95.7048
-352.93
203.909
56.9456
46.1146
-78.6813
9.13266
-1.62805
-2.73519
-0.48423
0.837335
-0.353105
-0.75726
179.877
-62.3299
79.87
-107.855
83.2361
79.8002
-2.55459
320.428
45.6993
-5.3032
-150.744
266.79
29.0455
-16.325
22.6514
145.381
-240.706
8.63086
106.748
-60.6338
36.1409
-21.4912
1.98195
19.5093
-0.163911
272.235
-69.8849
-0.250034
28.3283
-240.938
-95.1796
262.347
16.8484
-1.11757
0.146104
9.18142
-9.63639
-75.5893
-21.8431
-86.6813
8.38835
11.7532
33.8024
-19.4184
-240.796
-1.20105
-12.1675
-8.07305
202.959
19.4972
316.295
-11.1534
20.7372
0.645375
14.0632
-93.4689
1.30604
-205.97
-146.523
117.966
0.0272778
-1.35269
-9.90435
-17.104
-13.014
287.952
-229.68
-3.28145
-5.0538
-9.18882
82.2664
83.8545
-11.3028
-0.524091
-66.784
-62.0871
170.095
-152.486
109.885
-206.257
163.149
67.7122
-3.67307
109.724
-248.798
0.0275566
0.0274125
-0.0242562
-0.0215821
-0.0253537
-0.0253081
0.00732814
-0.0224612
-271.753
67.0293
-0.963158
154.477
-178.129
-1.01041
-15.9884
25.5028
173.838
-72.6501
-17.2501
-0.648642
-0.940741
0.465098
61.7461
-209.692
0.87386
192.043
0.562234
31.4822
30.3586
-0.496957
34.7872
-45.447
-49.7325
311.192
-35.0328
281.5
-58.2716
56.3226
-0.0342181
-0.517226
167.199
0.894883
-37.2088
310.528
-261.268
255.663
-22.0446
10.9667
289.5
-20.3841
-20.2022
-10.1856
0.578361
233.82
-99.5144
66.5124
6.5201
-0.908255
-0.292797
0.606788
15.223
112.701
7.83503
1.06356
-0.762136
-10.0784
-9.01488
-0.791478
-24.3685
1.08101
8.52769
-3.35664
58.4733
-105.233
50.6815
-16.2823
38.7203
-0.17426
)
;
boundaryField
{
frontAndBack
{
type empty;
value nonuniform 0();
}
bottom
{
type calculated;
value uniform 0;
}
inlet
{
type calculated;
value uniform -2000;
}
top
{
type calculated;
value uniform 0;
}
outlet
{
type calculated;
value nonuniform List<scalar>
14
(
2036.64
2038.94
2010.98
2034.31
2039.66
2026.04
2041.02
2040.98
2041.32
2041.17
1522.54
2042.13
2042.4
2041.88
)
;
}
car
{
type calculated;
value uniform 0;
}
}
// ************************************************************************* //
| |
6085e3d9746eb2f63f74e97c6147da0c4ec15c54 | 0fa622294d2118b4880adab6af385381dcb00cde | /src/views/mapview.cpp | 50af12508e8055553cd256803058b7748b20a4d8 | [] | no_license | shadowpho/alphacomplex | 26b2c9f01ff0625d7c5a01877b789c1c4725b17a | ad9dac90553295583aaa5ef81e4bfbd540550e98 | refs/heads/master | 2020-12-07T00:45:15.527266 | 2014-01-14T07:56:29 | 2014-01-14T07:56:29 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,124 | cpp | mapview.cpp | #include "views/mapview.hpp"
#include "graphics.hpp"
#include "city.hpp"
#include "clock.hpp"
#include "joblist.hpp"
#include "components/renderable.hpp"
const char prettywalls[16] = {
'+', HBAR, VBAR, CORNER_SE,
HBAR, HBAR, CORNER_SW, TEE_N,
VBAR, CORNER_NE, VBAR, TEE_W,
CORNER_NW, TEE_S, TEE_E, CROSS
};
void MapView::render(Graphics& g, render_box const& pos) {
prepare_buffer();
blit_buffer(g, pos);
}
void MapView::prepare_buffer() {
for (int y = vp.tly; y < vp.ysz; ++y) {
for (int x = vp.tlx; x < vp.xsz; ++x) {
if (city->designs(x, y) & 1) {
putChar(x, y, '%');
continue;
}
if (mode == DEFAULT) {
auto& s = city->ent(x, y);
auto it = s.begin();
auto end = s.end();
for (; it != end; ++it) {
if ((*it)->has<Renderable>()) {
putChar(x, y, (*it)->get<Renderable>()->render());
break;
}
}
if (it != end) {
continue;
}
} else if (mode == ENTCOUNT) {
if (city->ent(x, y).size() > 0 && city->ent(x, y).size() <= 9) {
putChar(x, y, (char)('0' + city->ent(x, y).size()));
continue;
}
}
if (city->tile(x, y).type == Tile::wall) {
int i = 0;
if (x > 0 && !city->tile(x - 1, y).walkable())
i += 1;
if (y > 0 && !city->tile(x, y - 1).walkable())
i += 2;
if (x < city->getXSize() - 1 && !city->tile(x + 1, y).walkable())
i += 4;
if (y < city->getYSize() - 1 && !city->tile(x, y + 1).walkable())
i += 8;
putChar(x, y, prettywalls[i]);
continue;
}
putChar(x, y, city->tile(x, y).type);
}
}
}
void MapView::blit_buffer(Graphics& g, render_box const& pos) {
// TODO: actually obey pos's w & h
for (int y = 0; y < vp.ysz; ++y) {
for (int x = 0; x < vp.xsz; ++x)
g.drawChar(pos.x + x, pos.y + y, buf[y * vp.xsz + x]);
}
}
void MapView::putChar(int x, int y, char c) {
x -= vp.tlx;
y -= vp.tly;
if (x >= 0 && x < vp.xsz && y >= 0 && y < vp.ysz)
buf[y*vp.xsz + x] = c;
}
|
dc6331223a48accbef7e58d3cb2e247e8d2f9288 | 27fbab0c197e1072086610dc3731089142e856d6 | /code/modules/io/ShowImageModule.cpp | aa13c349b2cfe353b4db32dd2392aedf2bc773f5 | [
"BSD-2-Clause"
] | permissive | TU-Berlin-CVRS/uipf | 59435cec863cbbd6e1c5c93e26a16c115ff31d83 | 57f4afcfdece904e82624453a938aafdfde8df41 | refs/heads/master | 2021-01-17T09:30:17.682911 | 2017-04-13T22:08:55 | 2017-04-13T22:08:55 | 38,701,010 | 8 | 6 | BSD-2-Clause | 2019-05-29T20:40:00 | 2015-07-07T16:37:37 | C++ | UTF-8 | C++ | false | false | 1,261 | cpp | ShowImageModule.cpp | #include "ShowImageModule.hpp"
using namespace std;
using namespace uipf;
/*
*/
void ShowImageModule::run( DataManager& data) const
{
using namespace cv;
Matrix::c_ptr oMatrix = data.getInputData<Matrix>("image");
if (oMatrix) {
string title = data.getParam<std::string>("title", "");
if (title.empty()) {
title = context_->getProcessingStepName();
}
context_->displayImage(title, *oMatrix, data.getParam<bool>("blocking",true),data.getParam<bool>("autoclose",false));
} else {
LOG_E("Failed to show image.");
}
}
MetaData ShowImageModule::getMetaData() const
{
map<string, DataDescription> input = {
{"image", DataDescription(MATRIX, "the image to show.") }
};
map<string, ParamDescription> params = {
{"title", ParamDescription("the title of the window, defaults to the current processing step name", true) },
{"blocking", ParamDescription("'true' or 'false' determines if the processing chain has to wait for this window to close or not.",true) },
{"autoclose", ParamDescription("'true' or 'false' determines if the window automatically closes after blocking has ended.",true) }
};
return MetaData(
"Show an image by opening a window.",
"I/O",
input,
map<string, DataDescription>(), // no outputs
params
);
}
|
ce4a0f01502070aa65def22ddf05b3a320938b27 | c70ffe04668c4e81622f30a6ff6db27df9c518e3 | /firestore/src/android/exception_android.h | 6a52c40c5dd965f954e445e60a161e3c8edbeede | [
"Apache-2.0",
"LicenseRef-scancode-proprietary-license"
] | permissive | firebase/firebase-cpp-sdk | 469a8514beb1425afdcc923e0f5f9fb64092cdc1 | f55c43c2485e91c67a52ce60e1191fa3b0c4df61 | refs/heads/main | 2023-09-01T11:50:35.258358 | 2023-08-31T00:35:26 | 2023-08-31T00:35:26 | 175,263,313 | 270 | 112 | Apache-2.0 | 2023-09-14T19:41:20 | 2019-03-12T17:23:01 | C++ | UTF-8 | C++ | false | false | 2,231 | h | exception_android.h | /*
* Copyright 2020 Google LLC
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef FIREBASE_FIRESTORE_SRC_ANDROID_EXCEPTION_ANDROID_H_
#define FIREBASE_FIRESTORE_SRC_ANDROID_EXCEPTION_ANDROID_H_
#include <string>
#if __cpp_exceptions
#include <exception>
#endif // __cpp_exceptions
#include "app/src/include/firebase/app.h"
#include "firebase/firestore/firestore_errors.h"
#include "firestore/src/jni/jni_fwd.h"
namespace firebase {
namespace firestore {
class ExceptionInternal {
public:
static void Initialize(jni::Loader& loader);
static Error GetErrorCode(jni::Env& env, const jni::Object& exception);
static std::string ToString(jni::Env& env, const jni::Object& exception);
static jni::Local<jni::Throwable> Create(jni::Env& env,
Error code,
const std::string& message);
static jni::Local<jni::Throwable> Wrap(
jni::Env& env, jni::Local<jni::Throwable>&& exception);
/** Returns true if the given object is a FirestoreException. */
static bool IsFirestoreException(jni::Env& env, const jni::Object& exception);
/**
* Returns true if the given object is a FirestoreException or any other type
* of exception thrown by a Firestore API.
*/
static bool IsAnyExceptionThrownByFirestore(jni::Env& env,
const jni::Object& exception);
};
void GlobalUnhandledExceptionHandler(jni::Env& env,
jni::Local<jni::Throwable>&& exception,
void* context);
} // namespace firestore
} // namespace firebase
#endif // FIREBASE_FIRESTORE_SRC_ANDROID_EXCEPTION_ANDROID_H_
|
1a9dc4f8596f57b10587ae8195914be4d6a219a0 | 36bb83633ee4deed991eadd975c36a1ba9605096 | /generichid/hiddatathread.cpp | 48e2877d5103d2322697814fd5428c3e87c0ce1c | [] | no_license | ftkalcevic/GenericHID | 1b07a26ecfb47f761164f124626baa80bc6f7d1b | 07c192710263871a3416d2e3e8bf7443d1b0e22f | refs/heads/master | 2021-01-10T20:54:01.824366 | 2019-10-23T10:01:04 | 2019-10-23T10:01:04 | 34,788,505 | 7 | 4 | null | 2015-08-05T20:14:35 | 2015-04-29T10:50:06 | C++ | UTF-8 | C++ | false | false | 3,789 | cpp | hiddatathread.cpp | // generichid, DIY HID device
// Copyright (C) 2009, Frank Tkalcevic, www.franksworkshop.com
// 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 3 of the License, or
// 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, see <http://www.gnu.org/licenses/>.
#include "stdafx.h"
#include "hiddatathread.h"
#ifdef _WIN32
#define TIMEOUT_ERROR -116
#else
#define TIMEOUT_ERROR -110
#endif
HIDDataThread::HIDDataThread( HIDDevice *pDevice )
: QThread()
, m_bRunning( false )
, m_pDevice( pDevice )
{
}
HIDDataThread::~HIDDataThread()
{
m_bRunning = false;
//wait(LOOP_TIMEOUT*2);
}
void HIDDataThread::stop()
{
m_bRunning = false;
}
void HIDDataThread::run()
{
if ( !m_pDevice->Open() )
return;
if ( !m_pDevice->Claim() )
{
m_pDevice->Close();
return;
}
// Find the largest report
int nLongestReport = 0;
int nMultiReport = 0;
std::map<byte, HID_ReportDetails_t>::iterator it;
for ( it = m_pDevice->ReportInfo().Reports.begin(); it != m_pDevice->ReportInfo().Reports.end(); it++ )
{
if ( it->second.InReportLength > nLongestReport )
nLongestReport = it->second.InReportLength;
}
// When there is more than one report, the report id is inserted before the packet.
if ( m_pDevice->ReportInfo().Reports.size() > 1 )
{
nLongestReport++;
nMultiReport = 1;
}
// Request an initial copy of the report(s)
// TODO:
QVector<byte> buf( nLongestReport, 0 );
m_bRunning = true;
std::map<byte, HID_ReportDetails_t>::iterator itReport = m_pDevice->ReportInfo().Reports.begin();
bool bInitialising = true;
while ( m_bRunning )
{
int nRead = 0;
memset( buf.data(), 0, buf.size() );
if ( bInitialising )
{
while ( itReport != m_pDevice->ReportInfo().Reports.end() && (itReport->second).InReportLength == 0 )
itReport++;
if ( itReport == m_pDevice->ReportInfo().Reports.end() )
{
bInitialising = false;
continue;
}
bool bGotData = m_pDevice->GetReport( (itReport->second).ReportId, REPORT_ITEM_TYPE_In, buf.data(), (byte)((itReport->second).InReportLength + nMultiReport) );
if ( bGotData )
nRead = (itReport->second).InReportLength + nMultiReport;
else
nRead = -1;
itReport++;
}
else
{
nRead = m_pDevice->InterruptRead( buf.data(), nLongestReport, LOOP_TIMEOUT );
}
if ( nRead == TIMEOUT_ERROR )
{
// Nothing to do.
}
else if ( nRead < 0 )
{
}
else if ( nRead > 0 )
{
{
//QWriteLocker lock(&m_queueLock);
//m_dataQueue.append( buf.mid(0,n) );
}
emit newData( buf.mid(0,nRead) );
//char s[1280];
//*s=0;
//for ( int i = 0; i < n; i++ )
//{
// char s1[10];
// _snprintf( s1, sizeof(s1), "%02X ", buf.data()[i] );
// strcat( s, s1 );
//}
//LOG_TRACE("%s\n", s);
}
//bRun = false;
}
m_pDevice->Unclaim();
m_pDevice->Close();
}
|
10a359545e782fa52f06da90c343775801ec0531 | 84355258fe8da005b75670e4ad71fe5a1d0c8ae0 | /CppWorkshop/CppWorkshopSamples/Demos/simpleraii.cpp | b6dce96cd7f9b86d1e05a7d7475a426c7b78a606 | [] | no_license | paumayr/cppexamples | 79b80a27c24586990532f0f017cdca1e924652e9 | 63ed21ef00c65d8f63652990140156db044d6536 | refs/heads/master | 2021-01-02T23:12:20.741167 | 2015-06-05T09:12:57 | 2015-06-05T09:12:57 | 9,764,509 | 0 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 313 | cpp | simpleraii.cpp | #include "stdafx.h"
class SimpleResource
{
int *heapmemory;
public:
SimpleResource()
: heapmemory(new int[1024 * 1024])
{
}
~SimpleResource()
{
delete[] heapmemory;
}
};
TEST_CLASS(TestSimpleRAII)
{
public:
TEST_METHOD(TestSimpleRAIIMain)
{
SimpleResource r1;
{
SimpleResource r2;
}
}
}; |
afbadd2e8d13035b5fbabdcbb09ce7712d0b561d | 2b1b459706bbac83dad951426927b5798e1786fc | /src/media/audio/audio_core/shared/profile_provider.cc | 9a69b754ef3977e0cc1ded759d6854ca390f4095 | [
"BSD-2-Clause"
] | permissive | gnoliyil/fuchsia | bc205e4b77417acd4513fd35d7f83abd3f43eb8d | bc81409a0527580432923c30fbbb44aba677b57d | refs/heads/main | 2022-12-12T11:53:01.714113 | 2022-01-08T17:01:14 | 2022-12-08T01:29:53 | 445,866,010 | 4 | 3 | BSD-2-Clause | 2022-10-11T05:44:30 | 2022-01-08T16:09:33 | C++ | UTF-8 | C++ | false | false | 3,262 | cc | profile_provider.cc | // Copyright 2020 The Fuchsia 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 "src/media/audio/audio_core/shared/profile_provider.h"
#include <lib/syslog/cpp/macros.h>
#include <sstream>
#include "src/media/audio/audio_core/shared/mix_profile_config.h"
namespace {
// TODO(fxbug.dev/40858): Use embedded selectors to forward parameters to the system profile
// provider until the new role API using FIDL parameters is implemented.
std::string MakeRoleSelector(const std::string& role_name, const zx::duration capacity,
const zx::duration deadline) {
// If the role name already contains selectors, append to the existing list.
const char prefix = role_name.find(':') == std::string::npos ? ':' : ',';
std::stringstream stream;
stream << role_name << prefix << "realm=media";
if (capacity > zx::duration{0} && deadline > zx::duration{0}) {
stream << ",capacity=" << capacity.get();
stream << ",deadline=" << deadline.get();
}
return stream.str();
}
} // anonymous namespace
namespace media::audio {
fidl::InterfaceRequestHandler<fuchsia::media::ProfileProvider>
ProfileProvider::GetFidlRequestHandler() {
return bindings_.GetHandler(this);
}
void ProfileProvider::RegisterHandlerWithCapacity(zx::thread thread_handle,
const std::string role_name, int64_t period,
float utilization,
RegisterHandlerWithCapacityCallback callback) {
if (!profile_provider_) {
profile_provider_ = context_.svc()->Connect<fuchsia::scheduler::ProfileProvider>();
}
const zx::duration interval = period ? zx::duration(period) : mix_profile_period_;
const float scaled_interval = static_cast<float>(interval.to_nsecs()) * utilization;
const zx::duration capacity(static_cast<zx_duration_t>(scaled_interval));
const std::string role_selector = MakeRoleSelector(role_name, capacity, interval);
profile_provider_->SetProfileByRole(
std::move(thread_handle), role_selector,
[interval, capacity, callback = std::move(callback), role_selector](zx_status_t status) {
if (status != ZX_OK) {
FX_PLOGS(WARNING, status) << "Failed to set role \"" << role_selector << "\" for thread";
callback(0, 0);
} else {
callback(interval.get(), capacity.get());
}
});
}
void ProfileProvider::UnregisterHandler(zx::thread thread_handle, const std::string name,
UnregisterHandlerCallback callback) {
if (!profile_provider_) {
profile_provider_ = context_.svc()->Connect<fuchsia::scheduler::ProfileProvider>();
}
const std::string role_name = "fuchsia.default";
profile_provider_->SetProfileByRole(
std::move(thread_handle), role_name,
[callback = std::move(callback), &role_name, &name](zx_status_t status) {
if (status != ZX_OK) {
FX_PLOGS(WARNING, status)
<< "Failed to set role \"" << role_name << "\" for thread \"" << name << "\"";
}
callback();
});
}
} // namespace media::audio
|
b2bb8e3786dd07e07b568b4fd8e13d01b4282d34 | 1b8e1ddcb86f0a5cd018bc6b3400c8c6fb1c1984 | /server/server/Notification/.svn/text-base/NotificationComponent.h.svn-base | ea1106426928331e352eaf34aadd8fa7d6ed375a | [] | no_license | yzfrs/ddianle_d1 | 5e9a3ab0ad646ca707368850c01f8117a09f5bfd | abffb574419cc2a8a361702e012cdd14f1102a6d | refs/heads/master | 2021-01-01T03:32:51.973703 | 2016-05-12T09:27:00 | 2016-05-12T09:27:00 | 58,615,329 | 0 | 2 | null | null | null | null | GB18030 | C++ | false | false | 3,211 | NotificationComponent.h.svn-base | #ifndef __NOTIFICATION_COMPONENT_H_H__
#define __NOTIFICATION_COMPONENT_H_H__ 1
#include "../logic/EntityComponent.h"
#include "../attribute/EntityAttributeComponent.h"
#include "../EntityNetComponent/EntityNetComponent.h"
#include "../../datastructure/DataStruct_DB.h"
#include "../../socket/SharedPtr.h"
#include "NotificationEvent.h"
class LazyMessage
{
public:
LazyMessage(GameMsg_Base *msg, int nPostTime = 3000, int nThresholdTime = 3000);
LazyMessage(SharedPtr<GameMsg_Base> &msg, int nPostTime = 3000, int nThresholdTime = 3000);
virtual ~LazyMessage();
void Elapsed(int nTime);
bool IsPostable() const;
GameMsg_Base *GetMsg();
protected:
SharedPtr<GameMsg_Base> m_msg;
int m_nElapsedTime;
int m_nThresholdTime;
int m_nPostTime;
};
class CNotificationComponent :
public CEntityComponent
{
public:
CNotificationComponent();
~CNotificationComponent();
public:
void LazyPost(GameMsg_Base *msg, int nMilliseconds);
void LazyPost(SharedPtr<GameMsg_Base> &msg, int nMilliseconds);
public:
void RegComponentNetMsgMap();
void OnNoPushRating(GameMsg_Base &msg, CSlotPeer &slotPeer);
void OnInfoCenterGetIDRes(GameMsg_Base &msg, CSlotPeer &slotPeer);
void InfoCenterMarkReaded(GameMsg_Base &msg, CSlotPeer &slotPeer);
public:
void Start();
void OnUpdate(const unsigned long &nTimeElapsed);
bool CreateFromDB(ROLEINFO_DB* pRoleInfoDB);
bool PacketToDB(ROLEINFO_DB *pRoleInforDB) const;
virtual bool PacketToCache(ROLEINFO_DB *pRoleInfoCache) const;
void OnLogin();
void OnLogout();
void SendExtraStaticData();
void SerializeComponent(CParamPool &IOBuff);
const char* SerializeName() { return "Notification"; }
virtual void PacketBuff(std::list<BuffData>& listBuff) {}
// 检测某个消息是否已经读取
bool HasReadInfoCenterInfo(unsigned int id, unsigned int lastUpdateTime); //
bool MarkInfoCenterRead(unsigned int id, unsigned int now); // 当前时间
void SendPlayerMsg(GameMsg_Base &msg);
public:
void AddEvent(CNotificationEvent &event);
protected:
void UpdatePushRating();
void PushRatingMessage(unsigned int nNow, int nPushReason);
void OnLazyPost(int nElapsedMilliseconds);
protected:
CEntityAttributeComponent * m_pAttr;
CEntityNetComponent * m_pNet;
protected:
CNotificationEventQueue m_ratingEventQueue;
int m_nUpdateInterval;
unsigned int m_nLoginTime;
unsigned int m_nLastPushRatingTime;
int m_nLastPushRatedLevel;
unsigned int m_nNoPushRatingTime;
unsigned int m_nPushRatedOnlineTime;
unsigned int m_nPushRatedDailyQuest;
unsigned int m_nPushRatedDailyShoping;
int m_nPushRatedCount; // 本周推送次数
unsigned int m_nPushRatedCountTime; // 本周记数时间
// <info id, read time>
typedef std::map<unsigned int, unsigned int> InfoCenterReadFlag;
InfoCenterReadFlag m_infoCenterReadFlag; // 记录什么时候，读取了什么消息
std::list<LazyMessage> m_listLazyMessage;
};
typedef CRoleComponentImpl<CNotificationComponent,CGetRoleProcessorObj,CGetRoleProcessorObj> CRoleNotification;
#endif //__NOTIFICATION_COMPONENT_H_H__
| |
61118a7e4719e4512356fa321e27745e6401d8bf | ea5c5082df21de760770f6228eb00c59fd19c4c4 | /DesignPatterns/Buy.h | fe2f4c16749e855c95275a787f9ebcc36fdf11b7 | [] | no_license | Magiczne/DesignPatterns | 012c1673093340d57390abf7bf19ca89c466e545 | 0655e90e717e19309c09eaa5892dd7f361b18c31 | refs/heads/master | 2021-01-21T16:04:11.721815 | 2017-05-28T12:34:55 | 2017-05-28T12:34:55 | 89,248,166 | 0 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 274 | h | Buy.h | #pragma once
#include "ICommand.h"
#include <memory>
namespace Command
{
class PhotosStock;
class Buy : public ICommand
{
private:
std::shared_ptr<PhotosStock> _stock;
public:
explicit Buy(std::shared_ptr<PhotosStock> stock);
void execute() override;
};
}
|
c33f95777a11e388a48ed3a330717471379430b8 | 682a576b5bfde9cf914436ea1b3d6ec7e879630a | /components/common/thirdparty/libzip/lib/zip_progress.cc | 31bf21420287e03cb47534c240bb7ebb0c53d485 | [
"MIT",
"BSD-3-Clause"
] | permissive | SBKarr/stappler | 6dc914eb4ce45dc8b1071a5822a0f0ba63623ae5 | 4392852d6a92dd26569d9dc1a31e65c3e47c2e6a | refs/heads/master | 2023-04-09T08:38:28.505085 | 2023-03-25T15:37:47 | 2023-03-25T15:37:47 | 42,354,380 | 10 | 3 | null | 2017-04-14T10:53:27 | 2015-09-12T11:16:09 | C++ | UTF-8 | C++ | false | false | 7,248 | cc | zip_progress.cc | /*
zip_progress.c -- progress reporting
Copyright (C) 2017-2020 Dieter Baron and Thomas Klausner
This file is part of libzip, a library to manipulate ZIP archives.
The authors can be contacted at <libzip@nih.at>
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in
the documentation and/or other materials provided with the
distribution.
3. The names of the authors may not be used to endorse or promote
products derived from this software without specific prior
written permission.
THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``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 AUTHORS 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 "libzip_impl.h"
struct zip_progress {
zip_t *za;
zip_progress_callback callback_progress;
void (*ud_progress_free)(void *);
void *ud_progress;
zip_cancel_callback callback_cancel;
void (*ud_cancel_free)(void *);
void *ud_cancel;
double precision;
/* state */
double last_update; /* last value callback function was called with */
double start; /* start of sub-progress section */
double end; /* end of sub-progress section */
};
static void _zip_progress_free_cancel_callback(zip_progress_t *progress);
static void _zip_progress_free_progress_callback(zip_progress_t *progress);
static zip_progress_t *_zip_progress_new(zip_t *za);
static void _zip_progress_set_cancel_callback(zip_progress_t *progress, zip_cancel_callback callback, void (*ud_free)(void *), void *ud);
static void _zip_progress_set_progress_callback(zip_progress_t *progress, double precision, zip_progress_callback callback, void (*ud_free)(void *), void *ud);
static void
_zip_progress_end(zip_progress_t *progress) {
_zip_progress_update(progress, 1.0);
}
static void
_zip_progress_free(zip_progress_t *progress) {
if (progress == NULL) {
return;
}
_zip_progress_free_progress_callback(progress);
_zip_progress_free_cancel_callback(progress);
free(progress);
}
static zip_progress_t *
_zip_progress_new(zip_t *za) {
zip_progress_t *progress = (zip_progress_t *)malloc(sizeof(*progress));
if (progress == NULL) {
zip_error_set(&za->error, ZIP_ER_MEMORY, 0);
return NULL;
}
progress->za = za;
progress->callback_progress = NULL;
progress->ud_progress_free = NULL;
progress->ud_progress = NULL;
progress->precision = 0.0;
progress->callback_cancel = NULL;
progress->ud_cancel_free = NULL;
progress->ud_cancel = NULL;
return progress;
}
static void
_zip_progress_free_progress_callback(zip_progress_t *progress) {
if (progress->ud_progress_free) {
progress->ud_progress_free(progress->ud_progress);
}
progress->callback_progress = NULL;
progress->ud_progress = NULL;
progress->ud_progress_free = NULL;
}
static void
_zip_progress_free_cancel_callback(zip_progress_t *progress) {
if (progress->ud_cancel_free) {
progress->ud_cancel_free(progress->ud_cancel);
}
progress->callback_cancel = NULL;
progress->ud_cancel = NULL;
progress->ud_cancel_free = NULL;
}
static void
_zip_progress_set_progress_callback(zip_progress_t *progress, double precision, zip_progress_callback callback, void (*ud_free)(void *), void *ud) {
_zip_progress_free_progress_callback(progress);
progress->callback_progress = callback;
progress->ud_progress_free = ud_free;
progress->ud_progress = ud;
progress->precision = precision;
}
static void
_zip_progress_set_cancel_callback(zip_progress_t *progress, zip_cancel_callback callback, void (*ud_free)(void *), void *ud) {
_zip_progress_free_cancel_callback(progress);
progress->callback_cancel = callback;
progress->ud_cancel_free = ud_free;
progress->ud_cancel = ud;
}
static int
_zip_progress_start(zip_progress_t *progress) {
if (progress == NULL) {
return 0;
}
if (progress->callback_progress != NULL) {
progress->last_update = 0.0;
progress->callback_progress(progress->za, 0.0, progress->ud_progress);
}
if (progress->callback_cancel != NULL) {
if (progress->callback_cancel(progress->za, progress->ud_cancel)) {
return -1;
}
}
return 0;
}
static int
_zip_progress_subrange(zip_progress_t *progress, double start, double end) {
if (progress == NULL) {
return 0;
}
progress->start = start;
progress->end = end;
return _zip_progress_update(progress, 0.0);
}
static int
_zip_progress_update(zip_progress_t *progress, double sub_current) {
double current;
if (progress == NULL) {
return 0;
}
if (progress->callback_progress != NULL) {
current = ZIP_MIN(ZIP_MAX(sub_current, 0.0), 1.0) * (progress->end - progress->start) + progress->start;
if (current - progress->last_update > progress->precision) {
progress->callback_progress(progress->za, current, progress->ud_progress);
progress->last_update = current;
}
}
if (progress->callback_cancel != NULL) {
if (progress->callback_cancel(progress->za, progress->ud_cancel)) {
return -1;
}
}
return 0;
}
ZIP_EXTERN int
zip_register_progress_callback_with_state(zip_t *za, double precision, zip_progress_callback callback, void (*ud_free)(void *), void *ud) {
if (callback != NULL) {
if (za->progress == NULL) {
if ((za->progress = _zip_progress_new(za)) == NULL) {
return -1;
}
}
_zip_progress_set_progress_callback(za->progress, precision, callback, ud_free, ud);
}
else {
if (za->progress != NULL) {
if (za->progress->callback_cancel == NULL) {
_zip_progress_free(za->progress);
za->progress = NULL;
}
else {
_zip_progress_free_progress_callback(za->progress);
}
}
}
return 0;
}
ZIP_EXTERN int
zip_register_cancel_callback_with_state(zip_t *za, zip_cancel_callback callback, void (*ud_free)(void *), void *ud) {
if (callback != NULL) {
if (za->progress == NULL) {
if ((za->progress = _zip_progress_new(za)) == NULL) {
return -1;
}
}
_zip_progress_set_cancel_callback(za->progress, callback, ud_free, ud);
}
else {
if (za->progress != NULL) {
if (za->progress->callback_progress == NULL) {
_zip_progress_free(za->progress);
za->progress = NULL;
}
else {
_zip_progress_free_cancel_callback(za->progress);
}
}
}
return 0;
}
|
6993514f9a609f8246e217000cc2c46242f6eec1 | 376e1818d427b5e4d32fa6dd6c7b71e9fd88afdb | /editors/codelite/patches/patch-CodeLite_tags_storage_sqlite3.h | f16102a52980f0beb969b16f87df075132293f82 | [] | no_license | NetBSD/pkgsrc | a0732c023519650ef821ab89c23ab6ab59e25bdb | d042034ec4896cc5b47ed6f2e5b8802d9bc5c556 | refs/heads/trunk | 2023-09-01T07:40:12.138283 | 2023-09-01T05:25:19 | 2023-09-01T05:25:19 | 88,439,572 | 321 | 138 | null | 2023-07-12T22:34:14 | 2017-04-16T20:04:15 | null | UTF-8 | C++ | false | false | 572 | h | patch-CodeLite_tags_storage_sqlite3.h | $NetBSD: patch-CodeLite_tags_storage_sqlite3.h,v 1.1 2022/10/17 16:50:03 andvar Exp $
Reorder <wx/filename.h> to fix the build in NetBSD.
--- CodeLite/tags_storage_sqlite3.h 2022-05-03 22:38:34.770034020 +0300
+++ CodeLite/tags_storage_sqlite3.h
@@ -25,6 +25,8 @@
#ifndef CODELITE_TAGS_DATABASE_H
#define CODELITE_TAGS_DATABASE_H
+#include <wx/filename.h>
+
#include "codelite_exports.h"
#include "entry.h"
#include "fileentry.h"
@@ -33,7 +35,6 @@
#include "wxStringHash.h"
#include <unordered_map>
-#include <wx/filename.h>
#include <wx/wxsqlite3.h>
/**
|
267fdecd90ec059641de541c3c145b415ffb79cd | cf413a0e9bf3d1d54a9dca23d17b3c63b0a0291c | /Solve/1992.cpp | 01b1195c6a45b3bf5f76f66b2635bdf6ceb9dfe1 | [] | no_license | ruru14/noj.am | 4d7dabf642f205bf901e595aaed1168469ef1b9f | b89b4f7372c357fbb8e567dafd8ba306fd01a200 | refs/heads/master | 2021-11-27T16:48:39.438279 | 2021-09-16T06:45:21 | 2021-09-16T06:45:21 | 130,633,719 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 362 | cpp | 1992.cpp | #include "1992.h"
int arr[64][64] = { {0,} };
void nojam1992::solution()
{
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
scanf("%d", &arr[i][j]);
}
}
printf("\n");
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
scanf("%d", &arr[i][j]);
printf("%d ", arr[i][j]);
}
printf("\n");
}
}
|
6d1227546fe33ce0c11bf303bfd395fe80a23b3f | 0c14ca4ca185653b37f49822cdce6c8b4e4c8d64 | /MgDocument.h | 04852b2fa6a26b229d6e378e6bd1ffe93b81ebdd | [] | no_license | marcelgit/mgMailTimer | e1e7ab336439b32559f43c2a0b3c1766f6aa9243 | 78df8ea52edf38f87bf76006e49f8b92411221fc | refs/heads/master | 2021-01-11T01:50:50.541436 | 2016-10-13T21:19:51 | 2016-10-13T21:19:51 | 70,848,302 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,053 | h | MgDocument.h | #ifndef MGDOCUMENT_H
#define MGDOCUMENT_H
/**
* @class MgDocument
* @author Alex
* @date 10/09/2016
* @file MgDocument.h
* @brief Interpreta el archivo cmv
* Ejemplo de fichero cmv
* IMPRIMIR=NO
* SELECCION=NO
* EMAIL=SI
* E_PLANTILLA=marce
* E_TO=direcciondelcliente(at)dominiodelcliente(dot)com
* E_FROM=administracion@pataleta.com
* E_CC=
* E_ASUNTO="Envio Facturas"
* E_CUERPO=
* E_SERVIDOR=smtp://mail.pataleta.com:587
* E_USUARIO=administracion@pataleta.com
* E_PASSWORD=encriptada
* E_ENCRIPTADO=SI
* VERSION=65
* FAX=NO
*/
#include <wx/string.h>
class MgDocument
{
public:
MgDocument(const wxString& docu);
wxString GetSubLine(wxString &from, size_t &offset);
void interpretaLinea(const wxString& sub_line);
wxString decriptPassword(const wxString& str);
wxString docuFile;
wxString docuTo;
wxString docuCC;
wxString docuFrom;
wxString docuSender;
wxString docuServer;
wxString docuPassword;
wxString docuSubject;
wxString docuBody;
};
#endif // MGDOCUMENT_H
|
41a42aee4a5cd2c713b1e8fbbbea29cd36c51aee | 9e5b086abad65730292b2dad52e3f1999351e318 | /test/unit/binlog/test_utils.cpp | 1c066088f1f4b85ed74858d3796105032d66e518 | [
"Apache-2.0"
] | permissive | morganstanley/binlog | 4cd5da5c4db9db70e3dfe94c0ccddf8a82748302 | 4cd8f78cfa371921583fa94132b10d68b50f0242 | refs/heads/main | 2023-06-25T17:51:30.753346 | 2023-06-19T12:04:31 | 2023-06-21T09:11:28 | 226,114,666 | 289 | 49 | Apache-2.0 | 2023-06-15T08:30:16 | 2019-12-05T13:59:09 | C++ | UTF-8 | C++ | false | false | 2,090 | cpp | test_utils.cpp | #include "test_utils.hpp"
#include <binlog/Entries.hpp> // Event
#include <binlog/EventStream.hpp>
#include <binlog/PrettyPrinter.hpp>
#include <doctest/doctest.h>
#include <ctime>
#include <sstream>
TestStream& TestStream::write(const char* data, std::streamsize size)
{
buffer.insert(buffer.end(), data, data + size);
return *this;
}
binlog::Range TestStream::nextEntryPayload()
{
binlog::Range input(buffer.data() + readPos, buffer.data() + buffer.size());
if (input.empty()) { return {}; }
const std::uint32_t size = input.read<std::uint32_t>();
binlog::Range result(input.view(size), size);
readPos += sizeof(size) + size;
return result;
}
std::vector<std::string> streamToEvents(TestStream& input, const char* eventFormat)
{
std::vector<std::string> result;
binlog::EventStream eventStream;
binlog::PrettyPrinter pp(eventFormat, "%Y.%m.%d %H:%M:%S");
while (const binlog::Event* event = eventStream.nextEvent(input))
{
std::ostringstream str;
pp.printEvent(str, *event, eventStream.writerProp(), eventStream.clockSync());
result.push_back(str.str());
}
return result;
}
std::vector<std::string> getEvents(binlog::Session& session, const char* eventFormat)
{
TestStream stream;
const binlog::Session::ConsumeResult cr = session.consume(stream);
CHECK(stream.buffer.size() == cr.bytesConsumed);
return streamToEvents(stream, eventFormat);
}
std::string timePointToString(std::chrono::system_clock::time_point tp)
{
char buffer[128] = {0};
const std::time_t tt = std::chrono::system_clock::to_time_t(tp);
const std::tm* tm = std::localtime(&tt); // NOLINT(concurrency-mt-unsafe)
(void)strftime(buffer, 128, "%Y.%m.%d %H:%M:%S", tm);
return buffer;
}
std::size_t countTags(TestStream& input, std::uint64_t tagToCount)
{
std::size_t result = 0;
const std::size_t oldReadPos = input.readPos;
while (binlog::Range payload = input.nextEntryPayload())
{
const std::uint64_t tag = payload.read<std::uint64_t>();
if (tag == tagToCount) { ++result; }
}
input.readPos = oldReadPos;
return result;
}
|
7337363ded7b1be709541f37e51a335709d72ee0 | af0ecafb5428bd556d49575da2a72f6f80d3d14b | /CodeJamCrawler/dataset/11_21809_40.cpp | 78e10cc20cce4f0604c52e6c8d42a492bcf82461 | [] | no_license | gbrlas/AVSP | 0a2a08be5661c1b4a2238e875b6cdc88b4ee0997 | e259090bf282694676b2568023745f9ffb6d73fd | refs/heads/master | 2021-06-16T22:25:41.585830 | 2017-06-09T06:32:01 | 2017-06-09T06:32:01 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,049 | cpp | 11_21809_40.cpp | #include <iostream>
#include <string>
#include <algorithm>
#include <cstdio>
#include <vector>
#include <cstring>
using namespace std;
#define PII pair<long long,long long>
#define MP make_pair
#define VI vector<int>
#define eps 1e-9
#define inf 1000000007
string a[200];
int t , n , m , i , j ;
int main()
{
freopen("c:/input.txt","r",stdin);
freopen("c:/output.txt","w",stdout);
cin>>t;
for (int tt = 1; tt <= t; tt++)
{
cin>>n>>m;
for (i = 0; i < n; i++)
cin>>a[i];
for (i = 0; i < n-1; i++)
{
for (j = 0; j < m-1; j++)
{
if (a[i][j] == '#' && a[i+1][j] == '#' && a[i][j+1] == '#' && a[i+1][j+1] == '#')
{
a[i][j] = a[i+1][j+1] = '/';
a[i+1][j] = a[i][j+1] = '\\';
}
}
}
int d = 0;
for (i = 0; i < n; i++)
for (j = 0; j < m; j++)
if (a[i][j] == '#')
d = 1;
cout<<"Case #"<<tt<<":\n";
if (d==1)
{
cout<<"Impossible\n";
} else
{
for (i = 0; i < n; i++)
cout<<a[i]<<endl;
}
}
return 0;
}
|
b507c4ec9ffb4ce215246d341cc22209b70fd565 | b107483b1c9834cc7b1df560d645cd3008364ed1 | /Games/Thesis/TSPhysicsObject.h | 49f21a29719c47200476d7f6d71890d083f49879 | [] | no_license | Goshido/GXEngine-Windows-OS | 1a420b109c047778c3eff1f97eb284254806df5e | 6745e3e86a94f90124300821d920073d54069644 | refs/heads/master | 2016-08-12T22:14:41.976336 | 2016-03-05T17:37:06 | 2016-03-05T17:37:06 | 47,348,608 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 746 | h | TSPhysicsObject.h | //version 1.1
#ifndef TS_PHYSICS_OBJECT
#define TS_PHYSICS_OBJECT
#include <GXEngineDLL/GXPhysX.h>
class TSPhysicsObject
{
friend GXVoid GXCALL TSPhysicsObjectOnPhysics ( GXFloat deltaTime );
friend GXVoid GXCALL TSPhysicsObjectDestroy ();
private:
TSPhysicsObject* prev;
TSPhysicsObject* next;
public:
TSPhysicsObject ();
virtual GXVoid Delete ();
virtual GXVoid OnPhysics ( GXFloat deltaTime ) = 0;
protected:
virtual ~TSPhysicsObject ();
};
//====================================================================================================
GXVoid GXCALL TSPhysicsObjectInit ();
GXVoid GXCALL TSPhysicsObjectOnPhysics ( GXFloat deltaTime );
GXVoid GXCALL TSPhysicsObjectDestroy ();
#endif //TS_PHYSICS_OBJECT |
15078fcbe78736550c945a253ca0dae8fb4c79d3 | f2a5ce61cf61226797e40a6ff87d7b34346fe062 | /BoundingVolumes/BoundingSphere.h | 9d0398922f7f49244a49899cc0c6ac951e2a9872 | [] | no_license | codedjinn/Barb2 | ff5ce510c752c32893d248a38d7e1e5165cc5519 | e7380db59fc8db62846e54e581c17d91a791bc34 | refs/heads/master | 2022-01-06T09:29:35.328038 | 2019-07-23T06:49:25 | 2019-07-23T06:49:25 | 193,832,244 | 1 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 1,282 | h | BoundingSphere.h | #ifndef BOUNDINGSPHERE_H_INCLUDED
#define BOUNDINGSPHERE_H_INCLUDED
#include "BoundingVolumeObjectSpace.h"
namespace BoundingVolumes
{
/**
* Simple bounding sphere.
*/
class BoundingSphere :
public BoundingVolumeObjectSpace
{
public:
BoundingSphere(ObjectSpaceMeshData const * objectSpaceMeshData);
BoundingSphere(const MathLib::vector4& position, const float radius);
virtual void GenerateInstanceBounds(const MathLib::vector4& position,
const MathLib::vector4& rotation,
const MathLib::vector4& scale,
const MathLib::matrix4x4& parentTransform);
virtual void GenerateInstanceBounds(const MathLib::vector4& position,
const MathLib::quaternion& orientation,
const float scale,
const MathLib::matrix4x4& parentTransform);
virtual bool IntersectsWithRay(const MathLib::ray& intersectRay, float* t) const;
virtual bool IsVisibleFromFrustum(const MathLib::plane frustum[]) const;
BOUNDINGVOLUMES_INLINE const MathLib::vector4& GetPosition() const
{
return worldSpacePosition;
}
BOUNDINGVOLUMES_INLINE float GetRadius() const
{
return worldSpaceRadius;
}
private:
MathLib::vector4 worldSpacePosition;
float worldSpaceRadius;
};
}
#endif // BOUNDINGSPHERE_H_INCLUDED
|
6f51135fb6722cc3c1b0e2d2c942dd27884f4498 | 17706804e57bd92680ed9c51a0a54f905c9e8028 | /Snake_the_game/Camera.cpp | 7807e26f80e8a3be2842cd10298a846e55b44ae2 | [] | no_license | EasyToFindName/Snake_the_game | 255955e2670a69a56c94d0a5aef2b763c99feb6a | 8938b5b15d1ae5578ea34d2f3b2d06594f9a4f50 | refs/heads/master | 2021-04-27T21:59:42.487090 | 2018-07-21T21:01:52 | 2018-07-21T21:01:52 | 122,409,490 | 0 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 1,241 | cpp | Camera.cpp | #include "Camera.h"
#include "GameObject.h"
//#include <iostream>
Camera::Camera(sf::RenderWindow & window, BaseScene& scene) : m_window(&window), m_scene(&scene)
{
m_view = std::make_unique<sf::View>(sf::FloatRect(0.0f, 0.0f, window.getSize().x, window.getSize().y));
m_view->setViewport(sf::FloatRect(0, 0, 1, 1));
m_window->setView(*m_view);
}
Camera::~Camera()
{
}
void Camera::update(float dt)
{
if (m_target) {
setCenterPosition(m_target->transform()->getPosition());
}
}
void Camera::setCenterPosition(const sf::Vector2f & pos)
{
m_view->setCenter(checkPosition(pos));
m_window->setView(*m_view);
}
void Camera::setTarget(GameObject * object)
{
m_target = object;
}
sf::Vector2f Camera::checkPosition(sf::Vector2f newCenterPos)
{
auto camPos = newCenterPos - (m_view->getSize() * 0.5f);
auto camSize = m_view->getSize();
auto sceneSize = m_scene->sceneSize();
if (camPos.x < 0.0f)
{
newCenterPos.x = camSize.x * 0.5f;
}
if (camPos.y < 0.0f)
{
newCenterPos.y = camSize.y * 0.5f;
}
if (camPos.x + camSize.x > sceneSize.x)
{
newCenterPos.x = sceneSize.x - camSize.x * 0.5f;
}
if (camPos.y + camSize.y > sceneSize.y)
{
newCenterPos.y = sceneSize.y - camSize.y * 0.5f;
}
return newCenterPos;
}
|
403b445640cbeefeb0ef74582a299ac425ee1280 | f23edace892c0ce7f33b35542f5137647be37176 | /chapter3/4.cc | 1f7541fb24f544b8ae3c519ac6ffd7c3bf302c41 | [] | no_license | xingfeT/ProgrammingPearls | d04b2b5c8c31fda588f424e29c9d9012a2fb3af6 | 4a78f0abdddea1a3b2dfd2c45861eafdf50688db | refs/heads/master | 2021-06-08T15:56:06.283853 | 2016-11-11T10:21:53 | 2016-11-11T10:21:53 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,398 | cc | 4.cc | #include <cstdio>
#include <vector>
using std::vector;
struct Date {
Date(int year_in, int month_in, int day_in) {
year = year_in;
month = month_in;
day = day_in;
}
int year;
int month;
int day;
};
const int kMonthDays[] = {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
const int KDaysOfWeek = 7;
enum YearDays {
kNormYearDays = 365,
kLeapYearDays = 366,
};
bool IsLeapYear(const int &year) {
if ((year % 400 == 0) ||
(((year % 4) == 0) && (year % 100) != 0)) {
return true;
} else {
return false;
}
}
int MonthDaysOfYear(int year, int month) {
int days = kMonthDays[month];
if (month == 2 && IsLeapYear(year)) {
days++;
}
return days;
}
int DaysOfYear(const Date &date) {
int days = 0;
days += date.day;
for (int i = 1; i < date.month; ++i) {
days += MonthDaysOfYear(date.year, i);
}
return days;
}
int DaysBetween(const Date &date_pre, const Date &date_next) {
int days = 0;
for (int year_ = date_pre.year; year_ < date_next.year; ++year_) {
days += (IsLeapYear(year_) ? kLeapYearDays : kNormYearDays);
}
days += DaysOfYear(date_next);
days -= DaysOfYear(date_pre);
return days;
}
void PrintCalendar(const vector<vector<int> > &calendar) {
printf("Sun Mon Tue Wed Thu Fri Sat\n");
int i;
for (i = 0; i < KDaysOfWeek - calendar[0].size(); ++i) {
printf(" ");
}
for (i = 0; i < calendar.size(); ++i) {
for (int j = 0; j < calendar[i].size(); ++j) {
printf("%-4d", calendar[i][j]);
}
printf("\n");
}
}
int DayOfWeek(const Date &date) {
const Date kFirstDate(1900, 1, 1); // Mon
return (DaysBetween(kFirstDate, date) % 7 + 1);
}
void CalendarOfMonth(int year, int month, vector<vector<int> > *calendar) {
Date first_of_month(year, month, 1);
int day_of_week = DayOfWeek(first_of_month);
vector<int> temp;
for (int i = 0; i < MonthDaysOfYear(year, month); ++i) {
temp.push_back(i);
if ((day_of_week + i) % KDaysOfWeek == 6) {
calendar->push_back(temp);
temp.clear();
}
}
printf("Year:%d Month:%d\n", year, month);
PrintCalendar(*calendar);
}
int main(int argc, char *argv[]) {
Date date_prev(2014, 5, 1);
Date date_next(2014, 6, 23);
printf("%d\n", DaysBetween(date_prev, date_next));
printf("%d\n", DayOfWeek(date_prev));
vector<vector<int> > calendar;
CalendarOfMonth(2014, 5, &calendar);
return 0;
}
|
0e0062a53e7a61395ce197ae20ec938532e71d07 | 694134bd4925129d42b778866adbf8d5b57a1e76 | /build-client_audio-Desktop_Qt_5_8_0_GCC_64bit-Debug/qrc_resources.cpp | ea0c324f2006f6cffc8e489078f0dfcfea577f0c | [] | no_license | JroLuttringer/IHM_Lecteur_Audio | 886422c2f55f39a73d61e0691cd44c1ca0516749 | 87ae5d7ff7d1b5cbfaaed0ee4cd55dbe5e7cbebd | refs/heads/master | 2020-08-28T15:23:19.404509 | 2017-05-04T21:22:27 | 2017-05-04T21:22:27 | 217,737,632 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 151,444 | cpp | qrc_resources.cpp | /****************************************************************************
** Resource object code
**
** Created by: The Resource Compiler for Qt version 5.8.0
**
** WARNING! All changes made in this file will be lost!
*****************************************************************************/
static const unsigned char qt_resource_data[] = {
// /home/cyrille/Documents/IHM/IHM_Lecteur_Audio/client_audio/resource/mute_3.png
0x0,0x0,0x8,0x1c,
0x89,
0x50,0x4e,0x47,0xd,0xa,0x1a,0xa,0x0,0x0,0x0,0xd,0x49,0x48,0x44,0x52,0x0,
0x0,0x0,0xe0,0x0,0x0,0x1,0x0,0x8,0x6,0x0,0x0,0x0,0xaa,0x1e,0x7a,0xd7,
0x0,0x0,0x0,0x4,0x73,0x42,0x49,0x54,0x8,0x8,0x8,0x8,0x7c,0x8,0x64,0x88,
0x0,0x0,0x0,0x9,0x70,0x48,0x59,0x73,0x0,0x0,0xb,0x13,0x0,0x0,0xb,0x13,
0x1,0x0,0x9a,0x9c,0x18,0x0,0x0,0x7,0xbe,0x49,0x44,0x41,0x54,0x78,0x9c,0xed,
0xdc,0xcd,0xaa,0x6d,0xc5,0x15,0xc5,0xf1,0x41,0x9a,0x3e,0x8a,0x69,0xb,0x82,0x8,
0x1,0x21,0x20,0xa4,0x21,0x4,0x84,0x34,0xc,0xab,0x11,0x34,0x28,0x12,0x12,0x31,
0x92,0x4,0xe3,0xf4,0x4d,0x7c,0xa9,0xfb,0x1e,0x7e,0x86,0x68,0x62,0x4c,0x43,0x8f,
0xf7,0x7c,0xec,0x8f,0xb5,0xf6,0xac,0xaa,0x51,0x73,0xad,0xff,0xf,0x46,0xf7,0x9e,
0x51,0x45,0xcd,0xcd,0xe4,0xc2,0xde,0x12,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x40,0x3f,0x2f,0x48,0xfa,0x4c,0xd2,0xf,0xc9,0x0,
0xd8,0xe8,0x97,0x92,0x9e,0x29,0x3f,0x7c,0xc,0x20,0xb0,0xd1,0x22,0xe9,0x1b,0xb5,
0x19,0x3e,0x6,0x10,0x58,0xa9,0xd5,0xca,0xc9,0x0,0x2,0x1b,0xb5,0x5c,0x39,0x19,
0x40,0x60,0x83,0x45,0x6d,0x57,0x4e,0x6,0x10,0x58,0xa1,0xd7,0xca,0xc9,0x0,0x2,
0x57,0xf4,0x5c,0x39,0x19,0x40,0xe0,0x82,0x45,0x7d,0x57,0x4e,0x6,0x10,0x38,0x61,
0xd4,0xca,0xc9,0x0,0x2,0x8f,0x8c,0x5c,0x39,0x19,0x40,0xe0,0x9e,0x45,0x63,0x57,
0x4e,0x6,0x10,0x90,0x6f,0xe5,0x64,0x0,0x71,0x78,0xce,0x95,0x93,0x1,0xc4,0xa1,
0x2d,0xf2,0xae,0x9c,0xc,0x20,0xe,0x69,0x96,0x95,0x93,0x1,0xc4,0xe1,0xcc,0xb4,
0x72,0x32,0x80,0x38,0x94,0x45,0x73,0xad,0x9c,0xc,0x20,0xe,0x61,0xd6,0x95,0x93,
0x1,0xc4,0xee,0xcd,0xbc,0x72,0x32,0x80,0xd8,0xb5,0x45,0x73,0xaf,0x9c,0xc,0x20,
0x76,0xa9,0xca,0xca,0xc9,0x0,0x62,0x77,0x2a,0xad,0x9c,0xc,0x20,0x76,0x65,0x51,
0xad,0x95,0x93,0x1,0xc4,0x2e,0x54,0x5d,0x39,0x19,0x40,0x94,0x57,0x79,0xe5,0x64,
0x0,0x51,0xda,0xa2,0xda,0x2b,0x27,0x3,0x88,0x92,0xf6,0xb2,0x72,0x32,0x80,0x28,
0x67,0x4f,0x2b,0x27,0x3,0x88,0x52,0x16,0xed,0x6b,0xe5,0x64,0x0,0x51,0xc2,0x5e,
0x57,0x4e,0x6,0x10,0xd3,0xdb,0xf3,0xca,0xc9,0x0,0x62,0x6a,0x8b,0xf6,0xbd,0x72,
0x32,0x80,0x98,0xd2,0x51,0x56,0x4e,0x6,0x10,0xd3,0x39,0xd2,0xca,0xc9,0x0,0x62,
0x2a,0x8b,0x8e,0xb5,0x72,0x32,0x80,0x98,0xc2,0x51,0x57,0x4e,0x6,0x10,0x76,0x47,
0x5e,0x39,0x19,0x40,0x58,0x2d,0x3a,0xf6,0xca,0xc9,0x0,0xc2,0x82,0x95,0x93,0x1,
0x84,0x9,0x2b,0x67,0xcd,0x1,0xfc,0x44,0x52,0xb8,0x4b,0x24,0x84,0x6a,0xf7,0x6f,
0x62,0x11,0x2b,0x67,0xc5,0x1,0xfc,0x58,0xcf,0x3b,0x86,0xb7,0xca,0x4d,0x42,0xb5,
0xfb,0xa7,0xb1,0x72,0xd6,0x1d,0xc0,0x7f,0xe8,0x69,0xcf,0x70,0x16,0xda,0x28,0x54,
0xbb,0x7f,0x1a,0x2b,0x67,0xdd,0x1,0xfc,0x9b,0xce,0x77,0xd,0x5f,0xad,0xd5,0x42,
0xb5,0xfb,0xa7,0x2d,0x62,0xe5,0xac,0x3a,0x80,0x1f,0xe9,0x7a,0xdf,0x70,0x95,0x5b,
0x21,0x54,0xbb,0x7f,0xa,0x2b,0x67,0xed,0x1,0xfc,0x50,0xeb,0x3b,0x87,0xa7,0xe2,
0x45,0xa1,0xda,0xfd,0x53,0x58,0x39,0x6b,0xf,0xe0,0x7,0xda,0xde,0x3b,0x1c,0x45,
0xcf,0x8,0xd5,0xee,0x9f,0xb2,0x88,0x95,0xb3,0xf2,0x0,0xfe,0x59,0xb7,0x77,0x8f,
0xf1,0x75,0x9f,0x8,0x99,0xfb,0xbb,0x1f,0x10,0xc9,0xc5,0xe9,0x4f,0xca,0xf7,0x8f,
0xd1,0xa5,0xef,0x89,0x13,0x7d,0x86,0xf7,0x77,0x3f,0x20,0x92,0x8b,0xcb,0xfb,0x57,
0x7a,0x6d,0x49,0x8c,0xad,0x2e,0xa9,0xcd,0xf0,0x35,0xe9,0xef,0x7e,0x40,0x24,0x17,
0x87,0xf7,0x36,0x76,0x5c,0x93,0x18,0xd8,0x3f,0x66,0xea,0xef,0x7e,0x40,0x24,0x97,
0xd1,0xde,0x4d,0xf6,0xbd,0x94,0x18,0xd0,0x3f,0x66,0xeb,0xef,0x7e,0x40,0x24,0x97,
0x91,0xfe,0x28,0xe9,0x7f,0xd,0xbb,0x9f,0x4a,0x74,0xec,0x1f,0x9d,0xbb,0xdf,0xd4,
0xdf,0xfd,0x80,0x48,0x2e,0xa3,0xbc,0xad,0xfe,0xc3,0x77,0x97,0xe8,0xd0,0x3f,0x6,
0x75,0xdf,0xdc,0xdf,0xfd,0x80,0x48,0x2e,0x23,0xfc,0x41,0xe3,0x86,0xef,0x2e,0xd1,
0xb0,0x7f,0xc,0xee,0xbe,0xa9,0xbf,0xfb,0x1,0x91,0x5c,0x7a,0xfb,0xbd,0xc6,0xf,
0xdf,0x5d,0xa2,0x41,0xff,0x30,0x75,0x5f,0xd5,0xff,0x17,0xd,0xe,0x88,0x7d,0x7b,
0x26,0xe9,0xb,0xd3,0xdf,0xfe,0x44,0xb9,0x21,0x8c,0x9f,0xfe,0x8d,0xa9,0xb9,0x3f,
0xc1,0x49,0x2e,0x23,0xbc,0x24,0xe9,0xf3,0x81,0x67,0x7a,0x9c,0xb8,0xa1,0x73,0x18,
0xfb,0x6e,0xea,0xec,0x7e,0x40,0x24,0x97,0x51,0x5e,0x96,0xf4,0x65,0xc7,0x73,0x5c,
0x4b,0x6c,0xe8,0x1a,0xc6,0x9e,0x5b,0xbb,0xda,0x1f,0x10,0xc9,0x65,0xa4,0x57,0x24,
0x7d,0xd5,0xb0,0xfb,0xd6,0xc4,0x8a,0x8e,0x61,0xec,0xb7,0xb6,0xe3,0x3,0xee,0x7,
0x44,0x72,0x19,0xed,0x55,0x49,0x5f,0x27,0xfa,0x66,0x13,0x17,0xba,0x85,0xb1,0xd7,
0xb5,0x6e,0x67,0xb9,0x1f,0x10,0xc9,0xc5,0xe1,0x57,0xf2,0x7e,0x83,0x25,0x4e,0x74,
0xa,0x63,0x9f,0x73,0x9d,0x56,0x71,0x3f,0x20,0x92,0x8b,0xcb,0x6b,0x92,0xfe,0x75,
0xa1,0x57,0xef,0xc4,0xbd,0x2e,0x61,0xec,0xf1,0xb8,0xcb,0x66,0xee,0x7,0x44,0x72,
0x71,0xfa,0xb5,0xa4,0x7f,0xcb,0x77,0xf6,0x50,0xf1,0xe1,0x93,0xb9,0x3c,0xc9,0xc7,
0xed,0x75,0x49,0xdf,0xca,0x7f,0xf,0x8e,0x44,0xfe,0xfa,0xfc,0x87,0x20,0xb9,0xcc,
0xe0,0x37,0x3a,0xde,0x10,0x46,0x8b,0x8b,0xd3,0x4,0x7,0x21,0xb9,0xcc,0xe2,0xd,
0x49,0xdf,0xc9,0x7f,0x1f,0x23,0x12,0x6d,0xae,0xec,0x47,0xee,0xc3,0x90,0x5c,0x66,
0xf2,0x5b,0x49,0xff,0x91,0xff,0x4e,0x7a,0x26,0x5a,0x5d,0xd6,0x1d,0xf7,0x81,0x48,
0x2e,0xb3,0x79,0x53,0xd2,0x7f,0xe5,0xbf,0x97,0x1e,0x89,0x76,0xd7,0xf4,0x9c,0xfb,
0x50,0x24,0x97,0x19,0xfd,0x4e,0xfb,0x1b,0xc2,0x68,0x79,0x41,0xf7,0xb9,0xf,0x46,
0x72,0x99,0xd5,0x5b,0x92,0xbe,0x97,0xff,0x7e,0x5a,0x24,0xda,0x5e,0xcd,0x43,0xee,
0xc3,0x91,0x5c,0x66,0xb6,0xc8,0xf7,0x5d,0xc2,0x56,0x89,0xc6,0x77,0xf2,0x84,0xfb,
0x80,0x24,0x97,0xd9,0x39,0xbe,0x4d,0xdf,0x2a,0xd1,0xfe,0x3a,0x9e,0x72,0x1f,0x92,
0xe4,0x52,0xc1,0x3b,0xaa,0x37,0x84,0xd1,0xe3,0x22,0x4e,0x71,0x1f,0x94,0xe4,0x52,
0x45,0x8f,0xdf,0x12,0xed,0x95,0xe8,0x73,0x5,0xa7,0xb9,0xf,0x4b,0x72,0xa9,0xa4,
0xc5,0x4f,0xd9,0xf7,0x4e,0xf4,0x3a,0xfc,0x39,0xee,0x3,0x93,0x5c,0xaa,0xf9,0x8b,
0xfc,0x77,0x76,0x2e,0xd1,0xef,0xd8,0xe7,0xb9,0xf,0x4d,0x72,0xa9,0xe8,0xaf,0xf2,
0xdf,0xdb,0xe3,0x44,0xcf,0x3,0x5f,0xe2,0x3e,0x38,0xc9,0xa5,0xaa,0xbf,0xcb,0x7f,
0x77,0x77,0x89,0xbe,0x47,0xbd,0xcc,0x7d,0x78,0x92,0x4b,0x65,0xff,0x94,0xff,0xfe,
0xa2,0xf7,0x21,0x2f,0xe1,0x77,0x41,0xe1,0xc4,0xfb,0x93,0xff,0x13,0x88,0xe4,0x52,
0x55,0xc8,0x7f,0x77,0x77,0x89,0xae,0x27,0xbd,0xc2,0x7d,0x78,0x92,0x4b,0x45,0x21,
0xff,0xbd,0x3d,0x4e,0x74,0x3c,0xef,0x45,0xee,0x83,0x93,0x5c,0xaa,0x9,0xf9,0xef,
0xec,0x5c,0xa2,0xdb,0xa9,0x2f,0x70,0x1f,0x9a,0xe4,0x52,0x49,0xc8,0x7f,0x5f,0xd7,
0x12,0x9d,0xce,0x7e,0x96,0xfb,0xc0,0x24,0x97,0x2a,0x42,0xfe,0xbb,0x5a,0x9b,0xe8,
0x72,0x3,0x67,0xb8,0xf,0x4b,0x72,0xa9,0x20,0xe4,0xbf,0xa7,0xad,0x89,0xe,0xf7,
0x70,0x92,0xfb,0xa0,0x24,0x97,0xd9,0x85,0xfc,0x77,0x74,0x6b,0xa2,0xf9,0x6d,0x9c,
0xe0,0x3e,0x24,0xc9,0x65,0x66,0x21,0xff,0xfd,0x64,0x13,0x8d,0xef,0xe4,0x9,0xf7,
0x1,0x49,0x2e,0xb3,0xa,0xf9,0xef,0xa6,0x55,0xa2,0xe9,0xcd,0x3c,0xe2,0x3e,0x1c,
0xc9,0x65,0x46,0x21,0xff,0xbd,0xb4,0x4e,0x34,0xbc,0x9f,0x7,0xdc,0x7,0x23,0xb9,
0xcc,0x26,0xe4,0xbf,0x93,0x5e,0x89,0x66,0xb7,0x74,0x8f,0xfb,0x50,0x24,0x97,0x99,
0x84,0xfc,0xf7,0xd1,0x3b,0xd1,0xe8,0xae,0x7e,0xe6,0x3e,0x10,0xc9,0x65,0x16,0x21,
0xff,0x5d,0x8c,0x4a,0x34,0xb9,0xb1,0x9f,0xb8,0xf,0x43,0x72,0x99,0x41,0xc8,0x7f,
0xf,0xa3,0x13,0xd,0xee,0x4d,0x9a,0xe0,0x20,0x24,0x17,0xb7,0x90,0xff,0xe,0x5c,
0x89,0xf4,0xed,0x4d,0x70,0x8,0x92,0x8b,0x53,0xc8,0x7b,0xf6,0x98,0xa4,0x43,0x8a,
0xfb,0x1,0x91,0x5c,0x5c,0xe2,0x42,0xa7,0x11,0x89,0x49,0xbb,0x6c,0xe6,0x7e,0x40,
0x24,0x17,0x87,0xd8,0xd0,0xaf,0x47,0xa2,0x48,0xa7,0x55,0xdc,0xf,0x88,0xe4,0x32,
0x5a,0x24,0xba,0xb6,0x48,0x14,0xed,0x76,0x96,0xfb,0x1,0x91,0x5c,0x46,0x8a,0x86,
0xbd,0x6f,0x49,0xec,0xa4,0xe3,0x3,0xee,0x7,0x44,0x72,0x19,0x25,0x3a,0x9e,0x61,
0x4d,0x62,0xa7,0x5d,0xed,0xf,0x88,0xe4,0x32,0x42,0xc,0x3c,0xcf,0xa9,0xc4,0x9e,
0x3b,0xbb,0x1f,0x10,0xc9,0xa5,0xb7,0x30,0x9e,0xed,0x7,0xe5,0xfe,0x87,0x71,0xfa,
0xee,0xfc,0x2e,0x23,0x66,0xf6,0xa9,0xf2,0x3,0xf8,0x69,0x93,0x26,0x1d,0xb9,0x3f,
0xc1,0x49,0x2e,0x23,0xc4,0xc0,0xf3,0xdc,0x25,0x8e,0xd2,0xdf,0xfd,0x80,0x48,0x2e,
0xa3,0x44,0xc7,0x33,0x3c,0x4e,0x1c,0xa9,0xbf,0xfb,0x1,0x91,0x5c,0x46,0x8a,0x86,
0xbd,0xcf,0x25,0x8e,0xd6,0xdf,0xfd,0x80,0x48,0x2e,0xa3,0x45,0xa2,0xeb,0xb5,0xc4,
0x11,0xfb,0xbb,0x1f,0x10,0xc9,0xc5,0x21,0x36,0xf4,0x5b,0x9b,0x38,0x6a,0x7f,0xf7,
0x3,0x22,0xb9,0xb8,0xc4,0x85,0x4e,0x5b,0x13,0x43,0x9b,0xff,0x28,0x6e,0xe8,0xd9,
0xa5,0xbf,0xfb,0x1,0x91,0x5c,0x9c,0x42,0xf9,0xfe,0x31,0xb8,0xf3,0x7d,0x71,0xa2,
0x4f,0xa5,0xfe,0x4d,0x2c,0x92,0xbe,0x91,0xff,0x21,0x57,0x8d,0x5b,0xa8,0xf6,0xe3,
0xd,0xd5,0xee,0xdf,0xc4,0x8b,0x92,0x9e,0xc9,0xff,0x98,0x2b,0x66,0x6,0xa1,0xda,
0x8f,0x37,0x54,0xbb,0x7f,0x13,0x2f,0x48,0xfa,0x4c,0xfe,0x7,0x5d,0x2d,0xb3,0x8,
0xd5,0x7e,0xbc,0xa1,0xda,0xfd,0x9b,0x59,0xc4,0x4a,0x5a,0x71,0x0,0xa5,0x75,0x8f,
0x38,0x4c,0xdd,0xd6,0x8,0xd5,0xee,0xdf,0xc,0x2b,0x69,0xcd,0x1,0x94,0x2e,0x3f,
0xe2,0xb0,0xb5,0x5a,0x2f,0x54,0xbb,0x7f,0x33,0xac,0xa4,0x35,0x7,0x50,0x3a,0xfd,
0x88,0xc3,0xd8,0x67,0xab,0x50,0xed,0xfe,0x4d,0x2d,0x62,0x25,0xad,0x36,0x80,0xd2,
0xc3,0x47,0x1c,0xd6,0x26,0xb7,0x9,0xd5,0xee,0xdf,0x14,0x2b,0x69,0xbd,0x1,0x94,
0x9e,0xff,0x6c,0x60,0x55,0xa1,0xda,0xfd,0x9b,0x62,0x25,0xad,0x37,0x80,0xd8,0xa1,
0x45,0xac,0xa4,0xc,0x20,0xac,0x58,0x49,0x19,0x40,0x98,0xb1,0x92,0x32,0x80,0x98,
0xc0,0xa2,0x63,0xaf,0xa4,0x80,0xdd,0x91,0x57,0x52,0x60,0xa,0x47,0x5d,0x49,0x81,
0xa9,0x2c,0x3a,0xd6,0x4a,0xa,0x4c,0xe7,0x48,0x2b,0x29,0x30,0xa5,0xa3,0xac,0xa4,
0xc0,0xd4,0x16,0xed,0x7b,0x25,0x5,0xa6,0xb7,0xe7,0x95,0x14,0x28,0x61,0xaf,0x2b,
0x29,0x50,0xca,0xa2,0x7d,0xad,0xa4,0x40,0x39,0x7b,0x5a,0x49,0x81,0x92,0xf6,0xb2,
0x92,0x2,0xa5,0x2d,0xaa,0xbd,0x92,0x2,0xe5,0x55,0x5e,0x49,0x81,0x5d,0xa8,0xba,
0x92,0x2,0xbb,0xb2,0xa8,0xd6,0x4a,0xa,0xec,0x4e,0xa5,0x95,0x14,0xd8,0xa5,0x2a,
0x2b,0x29,0xb0,0x6b,0x8b,0xe6,0x5e,0x49,0x81,0xdd,0x9b,0x79,0x25,0x5,0xe,0x61,
0xd6,0x95,0x14,0x38,0x94,0x45,0x73,0xad,0xa4,0xc0,0xe1,0xcc,0xb4,0x92,0x2,0x87,
0x34,0xcb,0x4a,0xa,0x1c,0xda,0x22,0xef,0x4a,0xa,0x1c,0x9e,0x73,0x25,0x5,0x20,
0xdf,0x4a,0xa,0xe0,0x9e,0x45,0x63,0x57,0x52,0x0,0x8f,0x8c,0x5c,0x49,0x1,0x9c,
0x30,0x6a,0x25,0x5,0x70,0xc1,0xa2,0xbe,0x2b,0x29,0x80,0x2b,0x7a,0xae,0xa4,0x0,
0x56,0xe8,0xb5,0x92,0x2,0xd8,0x60,0x51,0xdb,0x95,0x14,0xc0,0x46,0x2d,0x57,0x52,
0x0,0x37,0x68,0xb5,0x92,0x2,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x4c,0xed,0xff,0x42,0x72,0xdb,0xa7,0xb3,0xc,0x6a,0x84,0x0,
0x0,0x0,0x0,0x49,0x45,0x4e,0x44,0xae,0x42,0x60,0x82,
// /home/cyrille/Documents/IHM/IHM_Lecteur_Audio/client_audio/resource/mute.png
0x0,0x0,0x4,0x26,
0x89,
0x50,0x4e,0x47,0xd,0xa,0x1a,0xa,0x0,0x0,0x0,0xd,0x49,0x48,0x44,0x52,0x0,
0x0,0x0,0x80,0x0,0x0,0x0,0x80,0x8,0x6,0x0,0x0,0x0,0xc3,0x3e,0x61,0xcb,
0x0,0x0,0x0,0x4,0x73,0x42,0x49,0x54,0x8,0x8,0x8,0x8,0x7c,0x8,0x64,0x88,
0x0,0x0,0x0,0x9,0x70,0x48,0x59,0x73,0x0,0x0,0xb,0x13,0x0,0x0,0xb,0x13,
0x1,0x0,0x9a,0x9c,0x18,0x0,0x0,0x3,0xc8,0x49,0x44,0x41,0x54,0x78,0x9c,0xed,
0xdd,0xcb,0x8a,0x1c,0x55,0x0,0xc6,0xf1,0xbf,0x9a,0x28,0x4,0x11,0x44,0x9f,0x41,
0x98,0x40,0x7a,0xc0,0x24,0xba,0x51,0xd4,0x45,0xa2,0x20,0x98,0x59,0x88,0x4f,0xe0,
0xa3,0xc4,0x27,0xc8,0x33,0xb8,0x49,0xb2,0x70,0xe1,0x42,0x4,0x45,0x50,0x82,0xb,
0x57,0x2e,0x84,0x64,0x93,0x55,0x88,0xf7,0x24,0x90,0xcb,0x4,0xc5,0xb8,0xe8,0x29,
0x18,0x3a,0x3d,0x75,0x2e,0x75,0x3b,0xa7,0xea,0xff,0x83,0xda,0x74,0x57,0xd7,0x9c,
0xe2,0xfb,0xa6,0xbb,0x2e,0x5d,0xd5,0x20,0x49,0x92,0x24,0x49,0x92,0x24,0x49,0x92,
0x24,0x49,0x92,0x24,0x49,0x92,0x24,0x49,0x92,0x24,0x49,0x92,0x24,0x49,0x92,0x4a,
0xf7,0xcc,0xd4,0x3,0x28,0xd4,0x4b,0xc0,0x89,0x23,0x9e,0xfb,0x7,0xf8,0x6b,0xc4,
0xb1,0x68,0x64,0x6f,0x2,0x77,0x81,0x27,0x47,0x4c,0x3f,0x4d,0x37,0x34,0xd,0x2d,
0x14,0xbe,0x5,0x98,0xb1,0x37,0x8,0x87,0x9f,0x5b,0x80,0xd7,0x80,0x17,0xfa,0x19,
0xa6,0x86,0x10,0x1b,0x7e,0x4e,0x1,0x76,0x81,0x3f,0x81,0x2f,0xb1,0x4,0x45,0x4a,
0x9,0x3f,0xb5,0x0,0x4d,0xf8,0xcd,0x6b,0x2d,0x41,0x61,0xce,0x92,0x16,0x7e,0x4a,
0x1,0x36,0xc3,0xb7,0x4,0x85,0xc9,0x9,0x3f,0xb6,0x0,0x2b,0xb6,0x87,0x6f,0x9,
0xa,0x91,0x1b,0x7e,0x4c,0x1,0x42,0xe1,0x37,0xd3,0xd5,0x3e,0x57,0x48,0xf1,0xce,
0x2,0x77,0xc8,0xb,0x3f,0x54,0x80,0xd8,0xf0,0x1f,0x2,0xe7,0xfa,0x5d,0x2d,0xc5,
0x38,0x43,0xb7,0xf0,0xdb,0xa,0x60,0xf8,0x85,0x8b,0xd,0xff,0x3e,0xf0,0x4d,0xcb,
0xf3,0xdb,0xa,0xb0,0x2,0xfe,0x88,0x58,0xb6,0xe1,0x4f,0x24,0x25,0xfc,0x77,0x80,
0x8b,0x2d,0xf3,0x6c,0x16,0xc0,0xf0,0xb,0x97,0x1a,0x3e,0xc4,0x17,0x20,0x36,0xfc,
0x47,0x18,0xfe,0x24,0x4e,0x93,0x1e,0x3e,0xc4,0x15,0xe0,0x14,0x86,0x5f,0xb4,0xdc,
0xf0,0x21,0x5c,0x0,0xc3,0x2f,0xdc,0x69,0xe0,0x6f,0xc2,0x1,0x3d,0xe0,0xe9,0xf0,
0xa1,0xbd,0x0,0xb7,0x30,0xfc,0xa2,0x75,0xd,0x1f,0xda,0xb,0x10,0x33,0x19,0xfe,
0x44,0x5e,0xa7,0x7b,0xf8,0xd0,0xad,0x0,0x8f,0x80,0xf3,0xfd,0xae,0x96,0x62,0xf4,
0x15,0x3e,0xe4,0x17,0xc0,0xf0,0x27,0x92,0x12,0xfe,0xbb,0x11,0xcb,0xcb,0x29,0x80,
0xe1,0xf,0xe4,0x7,0xe0,0xdf,0xc0,0xf4,0x1f,0xfd,0x85,0xf,0xe9,0x5,0xa8,0x36,
0xfc,0x63,0x53,0xf,0x20,0xc2,0x31,0xe0,0xb9,0x8e,0xcb,0x78,0x8,0x7c,0x8,0x7c,
0xd7,0x79,0x34,0x4f,0xdb,0x7,0x2e,0x0,0x5f,0xf,0xb0,0xec,0xc1,0x3d,0x3b,0xf5,
0x0,0x46,0x30,0x74,0xf8,0x7b,0x54,0x1a,0x7e,0x2d,0x7e,0x24,0x7f,0x8b,0x3c,0xe5,
0x6d,0xbf,0x91,0x72,0x90,0xe7,0xfd,0xec,0xb5,0x52,0xb4,0xdc,0x2,0x3c,0x0,0xde,
0x4b,0xfc,0x5b,0x86,0x5f,0xa0,0x9c,0x2,0xc,0x19,0xfe,0x3e,0x86,0x3f,0xaa,0xd4,
0x2,0xe4,0x84,0x1f,0x7b,0x56,0xef,0x9,0x33,0xbb,0x30,0xa4,0x86,0xbd,0x80,0x36,
0x5f,0x0,0x9f,0x6f,0x3c,0x76,0x3,0xf8,0x39,0x61,0x19,0x2b,0xd6,0x5f,0x0,0x79,
0xb5,0xaf,0x41,0xd5,0xa4,0xf6,0x2,0x5c,0xa7,0xdb,0x97,0x2b,0x17,0x1d,0x3e,0x2c,
0x63,0x37,0xf0,0x28,0x8b,0xf,0x1f,0x96,0x5b,0x0,0xc3,0x3f,0x50,0xfb,0x47,0x40,
0x8e,0x15,0xf0,0x2d,0xf0,0xca,0xd4,0x3,0x29,0xc1,0xd2,0xde,0x1,0xc,0x7f,0xc3,
0x92,0xa,0xb0,0x4b,0x5c,0xf8,0x8f,0x81,0xef,0x87,0x1f,0x4e,0x19,0x6a,0xff,0x8,
0x58,0x1,0x9f,0x6e,0x3c,0xf6,0xb,0x70,0x6d,0xe3,0xb1,0x5d,0xd6,0x9f,0xf9,0x31,
0xe1,0xef,0x1,0x6f,0x1,0x6f,0xf7,0x31,0x40,0x75,0x97,0x7a,0x20,0xe8,0x31,0xeb,
0xb3,0x73,0x8d,0xa3,0xae,0xd2,0xdd,0x76,0x84,0xef,0x83,0x83,0xd7,0xa4,0x5c,0x17,
0x50,0xb5,0xda,0xdf,0x1,0xb6,0x79,0x1e,0xb8,0x2,0x7c,0x2,0xdc,0x24,0xed,0x3f,
0xff,0xab,0x61,0x87,0x56,0x9e,0x39,0x16,0x0,0xe0,0x38,0x70,0x99,0xf5,0x57,0xbe,
0x5f,0xe,0xcc,0xbb,0xd8,0xf0,0x61,0xde,0x1b,0x81,0xc7,0x31,0xfc,0xa0,0x39,0x17,
0x20,0x64,0xf1,0xe1,0xc3,0x72,0xb,0x60,0xf8,0x7,0x6a,0xd8,0x6,0xb8,0x4b,0xf8,
0xce,0x9c,0x2f,0x12,0x7f,0xcb,0x15,0xc3,0x9f,0xa1,0x8f,0x89,0xdf,0x4d,0xbc,0x18,
0xb1,0xbc,0xc5,0xec,0x6,0xce,0x41,0xec,0x37,0x79,0xe,0x1f,0x27,0xf8,0x28,0xb0,
0xcc,0xc5,0x14,0xa0,0xf6,0x6d,0x80,0x53,0xac,0xf,0xef,0xa6,0x9c,0xd5,0x6b,0x8e,
0x13,0x84,0x4a,0xb0,0x8,0x35,0x17,0xa0,0x39,0xb1,0x93,0x73,0x4a,0xd7,0x12,0x1c,
0xa8,0xb5,0x0,0x7d,0x9c,0xcf,0xb7,0x4,0xd4,0x59,0x80,0xd8,0xf0,0xf7,0x81,0xdf,
0x3,0xf3,0x2c,0xbe,0x4,0xb5,0x15,0x20,0x25,0xfc,0x3d,0xd6,0x17,0x85,0xfc,0x1a,
0x98,0x77,0xf1,0x25,0xa8,0x45,0xec,0x7d,0xf8,0x36,0x2f,0xda,0xd8,0x1,0x6e,0x47,
0xbc,0xee,0xf0,0xde,0xc1,0x62,0xf6,0x2,0x6a,0x91,0x12,0xfe,0xb6,0xab,0x74,0x53,
0x4b,0x60,0x1,0xa,0x12,0x7b,0x3e,0x3f,0x74,0x89,0xf6,0xe,0xeb,0x8f,0x83,0x98,
0x12,0x5c,0x6b,0x79,0xde,0x2,0x8c,0xa8,0xaf,0xf0,0x1b,0xb1,0x25,0x68,0x9b,0x2c,
0xc0,0x48,0xfa,0xe,0xbf,0xd1,0xb5,0x4,0x16,0x60,0x24,0x9f,0x11,0x17,0x7e,0xce,
0xdd,0xb8,0xba,0x94,0xc0,0x2,0x8c,0xe8,0x12,0xfd,0x87,0xdf,0x38,0x49,0x5e,0x9,
0x2c,0xc0,0xc8,0xb6,0x95,0xa0,0xaf,0x1b,0x2f,0xe7,0x94,0xc0,0x2,0x4c,0xe0,0x70,
0x9,0xfa,0xbe,0xeb,0x76,0x6a,0x9,0x2c,0xc0,0x44,0x2e,0x31,0xdc,0x2d,0xd7,0x4f,
0x2,0xbf,0x61,0x1,0x8a,0xb7,0x33,0xe0,0xb2,0x63,0x4b,0x60,0x1,0x66,0x2c,0xa6,
0x4,0x16,0x60,0xe6,0x42,0x25,0x98,0x55,0x1,0xfc,0xf9,0xf8,0xed,0x4e,0xd0,0xfe,
0xf3,0xf1,0xf7,0x46,0x1c,0x8b,0x24,0x49,0x92,0x24,0x49,0x92,0x24,0x49,0x92,0x24,
0x49,0x92,0x24,0x49,0x92,0x24,0x49,0x92,0x24,0x49,0x92,0x24,0x49,0x5a,0xb8,0xff,
0x1,0x0,0x66,0xc2,0x7c,0x2b,0xf0,0x9,0x68,0x0,0x0,0x0,0x0,0x49,0x45,0x4e,
0x44,0xae,0x42,0x60,0x82,
// /home/cyrille/Documents/IHM/IHM_Lecteur_Audio/client_audio/resource/sound_high_2.png
0x0,0x0,0xd,0x29,
0x89,
0x50,0x4e,0x47,0xd,0xa,0x1a,0xa,0x0,0x0,0x0,0xd,0x49,0x48,0x44,0x52,0x0,
0x0,0x0,0x80,0x0,0x0,0x0,0x80,0x8,0x6,0x0,0x0,0x0,0xc3,0x3e,0x61,0xcb,
0x0,0x0,0xc,0xf0,0x49,0x44,0x41,0x54,0x78,0x5e,0xed,0x9d,0x69,0x70,0x54,0x55,
0x1e,0xc5,0xbd,0x44,0x50,0x66,0xc0,0xb0,0x45,0x40,0x5c,0x46,0x5,0x74,0x5c,0x18,
0x17,0x10,0x49,0x8,0x24,0x4,0x12,0x13,0x20,0x2c,0x49,0x8,0x88,0x8e,0x94,0x3,
0x28,0x8e,0x5b,0x59,0x8a,0xca,0xb0,0x38,0xb8,0xa2,0x32,0xb8,0xe2,0x12,0x94,0x61,
0x5d,0x2,0x59,0x58,0xc3,0x1a,0x20,0x64,0x51,0xa2,0x23,0x23,0x3a,0x2a,0x25,0x33,
0x2e,0x50,0x80,0x10,0x24,0x82,0x6,0x21,0xd2,0xf3,0x9b,0xaa,0x9e,0x2a,0x3e,0x24,
0xe6,0x3c,0xea,0xa5,0xfb,0x75,0xe7,0x9e,0xaa,0x53,0xe7,0x51,0xc5,0x3b,0x7d,0xdf,
0xbb,0xa7,0xff,0xff,0xfb,0x5e,0x77,0xe7,0x19,0x9f,0xcf,0x77,0x56,0xc3,0x85,0x45,
0x23,0x18,0x76,0xb0,0xb0,0x1,0xb0,0xb0,0x1,0xb0,0xb0,0x1,0xb0,0xb0,0x1,0xb0,
0xb0,0x1,0xb0,0xb0,0x1,0xb0,0xb0,0x1,0xb0,0xb0,0x1,0xb0,0xb0,0x1,0xb0,0xb0,
0x1,0xb0,0xb0,0x1,0xb0,0xb0,0x1,0xb0,0xb0,0x1,0xb0,0xb0,0x1,0xb0,0x38,0x1b,
0x7a,0x0,0x16,0xd1,0x5d,0x7b,0x66,0x22,0xa9,0x30,0x1,0xee,0x85,0xeb,0xe1,0x2b,
0xa5,0x1f,0x14,0xef,0x43,0xeb,0xd,0x1e,0xf8,0x42,0x88,0x45,0x4c,0xb7,0xd8,0xbf,
0x22,0x93,0x6b,0x30,0xf8,0xa,0x26,0x95,0x94,0x6f,0xdb,0x15,0xbe,0x2d,0xc0,0x4e,
0xfe,0x58,0xff,0xe4,0xd7,0x84,0xdf,0xc1,0x2d,0x4,0xe4,0xbc,0xf0,0xd,0x80,0x45,
0x7a,0x1d,0x6,0xed,0xe1,0xe3,0x61,0xd8,0x2,0x2c,0x7a,0xde,0xd4,0xcb,0x20,0x15,
0xb0,0x65,0x1d,0x6,0xc7,0xe1,0x95,0xc5,0xdb,0x8b,0xbe,0xe,0xaf,0xa,0x60,0x61,
0x60,0xb5,0x60,0x70,0x2e,0x7c,0x36,0xcc,0x5a,0x80,0x5,0xef,0xe8,0x53,0x48,0x9e,
0x68,0x30,0x9c,0x8a,0xd1,0x3d,0xcc,0x2e,0x3,0x2d,0x8c,0x31,0xb,0x91,0xb1,0x62,
0xb5,0x98,0xe,0x7b,0x86,0x51,0x5,0xb0,0xd8,0xf6,0xfe,0xd6,0xad,0xc8,0x7a,0xd1,
0x20,0x26,0xb6,0x7b,0xef,0x74,0x8f,0x5,0xc0,0x82,0x49,0x69,0x2,0xfb,0xc2,0x3b,
0x61,0xe7,0x33,0xb0,0x78,0x18,0x9e,0x82,0xa,0xa6,0x11,0x82,0x26,0x1e,0xb9,0xa,
0xb0,0xe8,0x75,0x73,0xdc,0x24,0x64,0x3c,0x6c,0x76,0x9a,0xc1,0x4e,0x98,0x52,0xf4,
0xde,0x96,0x3d,0xe,0x7c,0xb2,0x90,0xd1,0x6a,0x60,0xf0,0x9e,0x1e,0xfc,0xa,0x60,
0x27,0xff,0x31,0x64,0xaa,0x7f,0xf2,0x4f,0xc7,0xb5,0xb0,0x94,0x70,0x5c,0x8e,0xaa,
0x98,0x4,0x8f,0x41,0x5,0x13,0xf1,0x6e,0x1d,0xd4,0x45,0xa0,0x9d,0xfc,0xf8,0x4b,
0x29,0xa0,0xbf,0x76,0x69,0x76,0x11,0x7c,0x3,0x26,0x2a,0x7e,0x54,0x8b,0xfd,0x78,
0x4e,0x63,0xf3,0x49,0x61,0x0,0x2d,0xe0,0x5f,0xe0,0x43,0x41,0x6a,0x1,0x16,0xbd,
0x7b,0xc4,0x67,0x20,0xd9,0x82,0x41,0xea,0xd6,0xb2,0xcd,0x2b,0x45,0xcf,0xa6,0xc8,
0x2e,0x78,0xa1,0xe0,0x5b,0x9,0xdb,0xe3,0x5d,0x15,0x9c,0x16,0x60,0x71,0xb5,0x68,
0xf0,0x22,0x61,0x69,0xac,0x18,0xfa,0x27,0x73,0x82,0xe8,0x1b,0x9,0xd3,0x1a,0x7a,
0xb,0xe0,0x5d,0xd3,0xa7,0x29,0x32,0x8,0x76,0x84,0x9b,0xb7,0x96,0x15,0x96,0xa0,
0x1,0x80,0x79,0x4f,0x34,0xe8,0xc,0xef,0x83,0x7f,0x13,0x7d,0xe7,0x23,0xf,0xc0,
0x1b,0x5,0xef,0x3b,0xe1,0xfc,0x6,0xdb,0x2,0xe2,0xa2,0xfb,0x24,0x23,0x73,0x61,
0x9b,0xd3,0xc,0x26,0x6f,0x29,0x2d,0x7c,0x32,0x0,0xaf,0xdd,0x18,0xf9,0xe,0xb6,
0x10,0xc,0x8e,0xc0,0x4e,0x8c,0xeb,0x90,0xe8,0x1d,0x8f,0x14,0xa,0xbe,0x3e,0xd8,
0x11,0xdf,0x7f,0x37,0xa8,0x16,0xc0,0xc4,0x47,0xc0,0x67,0xd8,0x5c,0xed,0x9f,0xfc,
0xd3,0x31,0x99,0x60,0x5c,0x8a,0xd6,0x2b,0x8,0xd9,0x49,0xe4,0x4d,0xd1,0xa0,0x5,
0x7c,0xd2,0x81,0xf7,0x66,0x64,0xa7,0x78,0x77,0xf0,0xce,0x6,0x55,0x1,0xe2,0x63,
0x12,0x2e,0x40,0x16,0xc3,0x58,0x58,0x1b,0x52,0x36,0x97,0x6c,0x2a,0x8,0xc0,0x58,
0x9a,0x23,0xbb,0x60,0x3b,0xc1,0xe0,0x17,0x78,0x3d,0xe3,0xda,0x29,0x7a,0x3f,0x80,
0xbc,0x24,0xf8,0xee,0x81,0x97,0xe0,0x7b,0x2a,0xec,0x2b,0x0,0x93,0x9f,0x88,0xec,
0x80,0xb1,0x75,0x18,0x34,0x71,0xe0,0x69,0xe0,0x35,0x90,0x52,0xee,0xc,0x84,0xec,
0xa8,0x83,0xcf,0xea,0x23,0xe0,0xc,0xa8,0x62,0x3e,0x3c,0x21,0xf8,0x5e,0x8,0x93,
0xc2,0xba,0x5,0x30,0x39,0x11,0xf0,0x29,0x36,0xd7,0xc2,0x28,0xc1,0xc0,0x8,0x9e,
0x4d,0xe1,0xcb,0x6c,0x7e,0x3,0x77,0xc2,0xc3,0xfc,0xfb,0x33,0xe8,0xf4,0x64,0xce,
0x81,0xe5,0x50,0x41,0x2,0xfe,0x5d,0xc5,0x70,0x55,0x20,0xcb,0x45,0xdf,0x3f,0x85,
0x6d,0xb,0xe8,0xd3,0xb3,0x6f,0x7b,0x64,0x11,0xec,0xd,0x55,0xc,0x29,0x2c,0xde,
0x98,0xff,0x2b,0x9e,0x11,0x48,0xe,0x1c,0x54,0x83,0x41,0x35,0x1c,0xc7,0xfe,0xb3,
0x1c,0x8c,0xb1,0x7,0x52,0xa2,0x4,0xf,0xbc,0x8d,0xf7,0x5d,0xa2,0x6f,0x12,0xb2,
0x56,0xf0,0x3c,0x1,0x3b,0xe0,0x7b,0x28,0xac,0x2a,0x0,0x13,0xd5,0x17,0xd9,0x21,
0x4f,0xbe,0x8e,0x9,0x70,0xd0,0xaf,0x5c,0x1a,0xbf,0x49,0x48,0xba,0xa8,0x66,0x84,
0xa5,0xc,0x59,0x8,0x15,0x8c,0xc0,0xbb,0x99,0x68,0xbd,0x1,0x7e,0x2b,0x78,0x36,
0x81,0xb7,0x87,0xcb,0x7d,0x0,0x92,0xdf,0xaf,0x11,0x32,0x85,0x2,0x35,0xb1,0x7e,
0x42,0x6a,0xe2,0x84,0x7e,0x3d,0x93,0x71,0xc4,0x16,0x16,0x6f,0xf0,0x89,0x9e,0x8f,
0x22,0x83,0xe1,0x6f,0xeb,0xf0,0x6e,0xe,0x87,0xc3,0x59,0x42,0xb0,0x4e,0x31,0x86,
0xd9,0x6c,0x4e,0x16,0xef,0x9,0xcc,0x8,0xf9,0x0,0x24,0xc4,0xf6,0x6b,0x67,0xc,
0xef,0x26,0xda,0x34,0xac,0x17,0x18,0x23,0xdd,0xc5,0x8b,0x81,0xa3,0xe0,0x6c,0xc5,
0x93,0xa0,0xec,0x65,0xec,0x59,0x6c,0x3e,0x28,0x78,0x8f,0x81,0xb3,0xc4,0xb1,0xce,
0x46,0x26,0x9,0xed,0xe5,0x1a,0x5e,0xbf,0xfd,0xa6,0x6d,0x1b,0xf6,0x85,0x6c,0xb,
0xe0,0x0,0xfa,0xf8,0x4b,0x7e,0x3c,0xac,0x4f,0x7c,0x27,0x1a,0x4c,0x63,0x4c,0x2d,
0x51,0x15,0x59,0xa2,0xef,0x4d,0xf8,0x4a,0x2d,0x86,0x9,0xfd,0xa,0x29,0x14,0x7d,
0xa3,0x43,0xb1,0x2,0x30,0xf1,0x89,0x8d,0x10,0x52,0x6e,0x26,0x7,0x26,0x94,0xe6,
0xef,0xc8,0x74,0xc1,0x20,0xa,0x3e,0x3,0xc7,0x89,0x93,0xf5,0x2f,0x8e,0xa5,0x54,
0x9c,0x88,0xb1,0xf0,0x5e,0x7,0xe3,0x4d,0x10,0x3,0x90,0x13,0x52,0x1,0xe8,0xdb,
0x2b,0xb1,0x2d,0x65,0x6e,0x81,0x70,0x80,0x6e,0xb6,0x80,0x79,0xc8,0x5f,0x61,0x33,
0x65,0xa2,0x18,0x63,0xd6,0xc6,0xa2,0xf5,0xff,0x10,0xbd,0xb3,0xc4,0x0,0x8c,0xc4,
0xf7,0x11,0x7c,0xab,0x4,0xcf,0xcd,0x88,0x82,0x98,0x90,0xba,0xa,0x60,0xf2,0xe3,
0x90,0x8f,0x84,0x74,0xbb,0xa,0x26,0xf3,0x20,0x32,0xc5,0xc1,0x39,0x7a,0x18,0xaa,
0xc8,0x86,0x95,0xe2,0xed,0xe1,0x74,0x71,0xbc,0x7b,0x91,0x6f,0x4,0xcf,0xeb,0x9,
0xd5,0xb9,0x5e,0xaf,0x0,0x4c,0x7c,0x52,0x23,0x64,0x2,0xd9,0x7e,0x2,0x8d,0x80,
0x41,0x80,0x79,0x5,0x19,0x5,0xaf,0x15,0xc,0xd2,0x18,0x73,0xdb,0x8d,0x45,0xeb,
0xe,0x8,0xe1,0xfa,0x89,0xe3,0x5b,0x28,0xb6,0x8d,0x24,0x38,0x4f,0x1c,0x6f,0x29,
0x72,0xb1,0x70,0x39,0xd8,0x15,0x16,0x7b,0x36,0x0,0xfd,0x7a,0x27,0x45,0xf9,0x4b,
0x7e,0x3f,0x18,0x34,0x30,0x99,0xd5,0x8c,0xe5,0x1e,0x36,0x8b,0xa0,0x11,0x4e,0xec,
0x68,0xf8,0xb4,0xda,0x6,0xc4,0x0,0xf4,0x74,0xd0,0xb6,0x4a,0x91,0xe1,0xe2,0x3a,
0xa0,0xd8,0x93,0x2d,0x80,0xc9,0xef,0x85,0xec,0x10,0x26,0x3f,0x20,0xd8,0xb0,0x75,
0x5d,0x31,0x32,0x47,0x34,0xb8,0x8b,0xf1,0x47,0x88,0xbe,0x1f,0x21,0x3b,0x4,0xcf,
0x4b,0xf0,0xec,0x80,0xa,0x20,0x0,0x1a,0xa2,0x3d,0xd9,0x2,0x12,0xe3,0x6e,0x99,
0x60,0x8c,0x99,0x2a,0x94,0xfc,0x80,0x82,0x31,0x4d,0x42,0x6e,0x17,0xc6,0x75,0x11,
0x4c,0x85,0x79,0xa2,0xef,0x46,0xe4,0x3a,0xb1,0xa,0x2c,0x11,0xfc,0xfe,0x89,0xfc,
0x28,0xdc,0x68,0xea,0xe1,0xb9,0x45,0x20,0x93,0x3f,0xc9,0x5f,0x3e,0x23,0xa0,0xa7,
0xb0,0x7e,0xcb,0xda,0x3d,0xe,0x3e,0x74,0xb9,0x47,0x36,0xd6,0xcb,0x70,0x8c,0x38,
0xce,0x6a,0x64,0xbb,0xe0,0x77,0x3e,0xe7,0xbb,0xa3,0x5c,0x1,0xf4,0x49,0x4c,0x4e,
0x44,0xee,0xaa,0x25,0x81,0x87,0xe1,0x4b,0xeb,0xb7,0x14,0x6c,0xaf,0x61,0xbf,0xa6,
0xe4,0xf7,0xf1,0xb3,0x3c,0xd,0xf3,0x3a,0x32,0x54,0x30,0x48,0xe0,0x78,0xda,0x70,
0x9c,0x87,0x4,0xcf,0x12,0x4,0x88,0xeb,0x0,0x7d,0x21,0x18,0x2f,0xb6,0x81,0x2f,
0x5d,0xb,0x40,0x52,0x7c,0x72,0x33,0x16,0x21,0xd9,0x6c,0x46,0xc2,0xda,0x70,0x1d,
0xbc,0xaa,0x86,0xc5,0xcb,0x55,0x8,0x21,0xf0,0x2e,0x8,0x6e,0x21,0xc7,0xf8,0x19,
0x9b,0xbf,0x17,0x3e,0x66,0x8e,0x85,0x79,0x82,0xe7,0x21,0x3c,0x3f,0x67,0xf3,0xca,
0x3a,0x3c,0xbb,0xf0,0xda,0xcd,0xd7,0x6d,0x2e,0x38,0x2a,0x2d,0x4,0x35,0x74,0x87,
0x73,0xdd,0x6c,0x1,0x17,0xc0,0xc8,0x3a,0xbc,0x3a,0xd5,0x62,0xf0,0x1b,0x18,0xa,
0x98,0x29,0x1a,0xf4,0x72,0xb9,0xd,0x44,0xc0,0x9b,0x45,0xbf,0x32,0xe8,0x13,0x3c,
0x3b,0xb8,0xdc,0x2,0x8c,0xf2,0xe,0xae,0xaa,0x65,0xdf,0x10,0x9,0x80,0x59,0x82,
0xbc,0xea,0x6e,0x0,0x4c,0x31,0x32,0x5a,0x5c,0x7,0x6c,0xa8,0xcb,0x8d,0x2a,0xf1,
0x7d,0x52,0x7c,0xca,0x1,0xe1,0x2b,0x68,0xad,0x5d,0xd,0x0,0xa5,0x47,0xa,0x80,
0xb0,0xaf,0x57,0xc1,0xc9,0x5d,0x73,0xf0,0x96,0x3e,0x29,0x4a,0xc9,0xbe,0x8e,0xff,
0x17,0xb9,0xb6,0x70,0x4d,0xa5,0x70,0xde,0xd4,0x85,0x60,0x17,0x28,0x1,0xcf,0xa,
0x21,0x0,0xad,0x5c,0xbe,0xa,0xd0,0x2,0x20,0xb4,0x0,0xaf,0x63,0x9b,0x72,0xce,
0xd4,0x95,0x3b,0x21,0xd9,0x8d,0x1c,0x14,0x3c,0xdb,0x40,0x15,0x15,0x82,0x5f,0x6b,
0xdb,0x2,0xce,0x8,0x66,0x1b,0x32,0x46,0x6c,0x3,0x6b,0x44,0xcf,0xbd,0x48,0x94,
0x30,0x61,0x22,0x8c,0x12,0x80,0x56,0xc1,0x68,0x1,0x3f,0x79,0xb9,0x5,0x88,0xc7,
0x59,0x24,0x1a,0x74,0x72,0x52,0xb2,0x95,0xa,0xe0,0xb2,0x5f,0xe3,0xe4,0x84,0xfe,
0xcd,0xb,0x36,0xad,0x3e,0xea,0x56,0xb,0x38,0xb7,0x21,0xb4,0x0,0x4e,0xd8,0xd7,
0xe2,0x97,0x45,0xa2,0x5c,0x2e,0xd9,0xad,0x5c,0xf0,0x13,0xaa,0x8a,0x6d,0x1,0x2,
0xcc,0x1,0xe4,0x7c,0x21,0x0,0x6e,0x96,0xec,0xb3,0x93,0x13,0x6,0x44,0x16,0x6c,
0x5a,0x55,0x29,0xf9,0xe9,0x1,0xf8,0xca,0xb,0x57,0x1,0x21,0x15,0x0,0xc6,0x7b,
0x48,0xaf,0x0,0x7a,0xc9,0x16,0xdb,0x40,0xa5,0x8b,0x7e,0xad,0x3c,0x52,0x1,0xd8,
0x37,0xa4,0x60,0x94,0x0,0xb4,0x4a,0xe9,0x3b,0x30,0x62,0xcd,0xc6,0x95,0xbf,0xb8,
0xfc,0x8e,0xdd,0x2d,0xf8,0x1d,0x56,0xfd,0xec,0x65,0xe0,0x99,0x41,0x9,0x80,0xd1,
0x17,0x6e,0x7a,0x5,0xf0,0xec,0x1a,0xc0,0x18,0xe9,0xb7,0x76,0x27,0x6a,0xd9,0xf7,
0x1c,0x24,0xd0,0xf0,0xb9,0xd0,0x2,0x94,0x36,0x70,0x40,0xf0,0x73,0x75,0xc2,0x8c,
0x9,0xce,0x22,0xf0,0x67,0xc1,0xab,0x96,0x89,0x36,0xc7,0x83,0x51,0xc7,0xcf,0xdc,
0xc0,0xf8,0xdc,0xbd,0x89,0x66,0x4e,0xa9,0x63,0xe,0xbc,0x9f,0x5e,0x1,0xaa,0x94,
0x36,0x21,0xec,0xeb,0x79,0x18,0x23,0x97,0xe2,0xef,0x44,0xbf,0xd6,0x6a,0x69,0xf,
0xbc,0x9f,0xbe,0x6,0x38,0xae,0x4,0x40,0xba,0x41,0xe4,0x7d,0xb4,0x11,0x5b,0xcc,
0x21,0x37,0x4b,0x71,0x3d,0xf8,0x55,0xb8,0xd9,0x2,0xce,0xb4,0x2,0x0,0x13,0x62,
0x1,0x30,0x4a,0x0,0x8e,0xac,0x5a,0xbf,0xbc,0x5a,0xf4,0x73,0x79,0x71,0x67,0xd4,
0x0,0x1c,0xf6,0x4a,0xb,0x8,0x9d,0x0,0xe8,0x25,0xf6,0xa0,0xee,0xe7,0x6e,0x5,
0x30,0x26,0xe4,0x2a,0x0,0xfb,0x86,0x14,0x4c,0x5b,0xb5,0xff,0xbb,0xf8,0x8e,0xfd,
0x5,0x56,0x8a,0x7e,0x41,0x59,0x3,0x54,0x35,0x84,0x35,0xc0,0xc0,0xa4,0xc1,0x1d,
0x90,0x76,0x6a,0x5,0x70,0xb1,0x67,0x57,0xac,0x5c,0x97,0xef,0x13,0xfd,0x6c,0xb,
0xa8,0xc7,0xf2,0xdf,0x4b,0x34,0xd8,0xed,0x72,0xb,0xa8,0x70,0xd9,0xaf,0x7a,0xc5,
0xda,0xfc,0x4a,0xbb,0x8,0x74,0xc,0x13,0x2b,0x7f,0x71,0x44,0x86,0x69,0xaf,0xf5,
0x7f,0xbd,0xa5,0xa8,0xef,0x7e,0xaf,0xb4,0x80,0x50,0x5a,0x3,0x28,0x1,0xf0,0xa9,
0x1,0x48,0xbd,0x65,0xc8,0x25,0x62,0x4b,0xa9,0x80,0x2a,0xf4,0x8a,0x62,0x5b,0x80,
0x8e,0x41,0xc9,0x43,0x5a,0x89,0x7f,0x39,0x64,0xe7,0xf2,0x82,0xbc,0xef,0xc5,0xf3,
0xd6,0x13,0x51,0xb0,0xd3,0xe5,0x16,0x70,0xd8,0xed,0xaf,0x84,0xed,0x41,0xe,0xc2,
0x28,0xe7,0x7,0x61,0x7e,0xc,0x91,0xf2,0x9f,0x26,0xde,0x3e,0x2d,0x72,0xe0,0xa9,
0x6,0xa0,0x44,0xb,0xe9,0xd0,0x48,0xf1,0x2a,0xa5,0xc2,0xd5,0x16,0xb0,0xbc,0x20,
0xb7,0xa,0x49,0x81,0x33,0xe1,0x9c,0x1a,0x38,0x3,0x8e,0xa8,0xc5,0xe0,0x53,0x78,
0x14,0x7a,0x1d,0x7f,0x86,0xc0,0xcd,0x0,0x48,0x15,0xe0,0x14,0x2c,0x13,0xfd,0x6e,
0x16,0xe7,0x6c,0x9f,0xa3,0xa,0x20,0x86,0xe0,0x3,0x4,0x3a,0x3,0xfb,0x9d,0x18,
0x9c,0x32,0xf4,0x31,0x36,0x5f,0x87,0x9e,0x4,0xe3,0x8b,0xa1,0xb4,0xfe,0x41,0xd,
0x80,0xe8,0xd9,0x52,0x6d,0x29,0xf9,0x6b,0x72,0x7f,0x10,0xcb,0x7f,0x34,0xa2,0x60,
0xbb,0xa7,0x7e,0x1d,0xcc,0x1,0xce,0x1c,0x9c,0x92,0x76,0x9c,0xcd,0xd7,0xbc,0xf9,
0x33,0x31,0x73,0xaf,0xba,0xfa,0xcf,0x5f,0x93,0x73,0x40,0xf4,0x8c,0x46,0x8c,0x5a,
0xfe,0x65,0x4f,0xd,0xa5,0x9e,0xfb,0x79,0x38,0x27,0xee,0xdd,0x21,0xfd,0xd3,0xb6,
0xb3,0xb9,0x14,0x5e,0x9,0x3d,0x1,0xc6,0xd4,0xce,0x18,0xf5,0xc1,0xb,0x7a,0x15,
0xc3,0x53,0xee,0xff,0xe2,0x38,0x1b,0xe1,0xd9,0x5d,0x5c,0x0,0x7e,0xe1,0xc9,0x7,
0x46,0xe4,0xad,0xce,0xf9,0x64,0x48,0xff,0xf4,0xae,0x6c,0xbe,0x5,0x47,0x42,0xf,
0xc0,0x4c,0x42,0x1a,0xb,0x6,0xfb,0x61,0xae,0x3,0xdf,0x4,0x77,0x7f,0x46,0x6e,
0xae,0x45,0x9a,0xb,0x7e,0x65,0x79,0xab,0x97,0xf9,0x3c,0xfb,0xbc,0x0,0x6,0xf7,
0x23,0xbc,0x8d,0xcd,0x31,0xc1,0xbe,0x47,0xe0,0xf,0xe3,0xdd,0xa2,0x41,0x16,0xe3,
0x3e,0x29,0xfa,0x5e,0x8d,0x74,0x13,0x3c,0xf7,0xe0,0xf9,0x8d,0xcb,0x7f,0xf9,0xa3,
0x24,0x24,0x1e,0x19,0x43,0x8,0x66,0xd,0x1d,0x90,0xfe,0xff,0x96,0xd0,0x19,0x6,
0x14,0xbc,0xf6,0xff,0x4a,0xea,0x4c,0xf1,0x4d,0x50,0xd,0xdf,0x76,0x50,0xfe,0xc7,
0xc8,0x93,0xa5,0x7b,0xca,0xfd,0x3f,0x64,0x9e,0x19,0x94,0xbb,0x6a,0xd9,0xc7,0x43,
0x7,0x64,0xdc,0xe8,0x3f,0xb9,0x23,0x60,0x0,0x61,0xc6,0x22,0xdd,0x44,0x83,0x15,
0xb9,0xab,0x96,0xee,0xd1,0x82,0x95,0x71,0xe,0xde,0xb7,0x8b,0xbe,0xeb,0x5d,0x5e,
0x0,0x56,0xc3,0xf2,0x90,0x7a,0x5e,0x0,0x27,0xf6,0x18,0xbc,0xd5,0x5f,0x8a,0x8f,
0xc3,0x7a,0x7,0xa1,0x6b,0x83,0x3c,0x3,0x55,0x4c,0x77,0x62,0x2f,0x7e,0x27,0xff,
0x18,0xcc,0x16,0xc7,0xdb,0x16,0xb9,0x4c,0xf0,0xdc,0x41,0x50,0x7f,0xf2,0x56,0x5,
0xd0,0x83,0xf0,0x56,0xda,0xc0,0x8c,0xf7,0xfd,0x27,0xa5,0x53,0x3d,0x7f,0xea,0x37,
0x1e,0x69,0x29,0x1a,0xcc,0xc9,0x59,0xb9,0xb4,0xb4,0x1e,0xca,0xff,0x22,0x7c,0x8f,
0x89,0x9e,0x71,0x6a,0xf9,0xf,0xe9,0xc7,0xc6,0x71,0x42,0x76,0xa4,0xd,0x1c,0x76,
0x23,0x9b,0x59,0x30,0xb3,0x1e,0x23,0xa0,0x2e,0xfc,0xbe,0x87,0x8f,0xa8,0xae,0x8c,
0xbd,0x23,0xde,0xea,0x64,0x65,0x41,0x11,0xe6,0x8f,0x4e,0x2,0xe0,0xc9,0x16,0xa0,
0x87,0x20,0xfb,0x28,0x1c,0xce,0xe6,0x3d,0xf0,0x67,0xb7,0xfd,0x9,0x58,0x13,0xa4,
0xb9,0x68,0x30,0x81,0xb1,0x1c,0x44,0x55,0x8c,0x86,0x46,0x29,0xd5,0xf8,0x96,0x8b,
0xe3,0xed,0x80,0x24,0x85,0x4f,0x5,0xd0,0x83,0xf0,0x46,0x7a,0xea,0xb0,0xf7,0xfc,
0x57,0x9,0x97,0xbb,0x58,0xfe,0x7d,0xc8,0x51,0x21,0x4,0xe5,0x4e,0x56,0xfe,0x8c,
0x35,0xca,0x18,0xfd,0x92,0xd2,0xc1,0x78,0x47,0x89,0x7f,0x5e,0xef,0x8b,0x65,0x2b,
0xb2,0xbf,0xd,0xab,0x27,0x87,0x72,0x40,0x1f,0xa5,0xa7,0x66,0xde,0xc0,0xe6,0x3b,
0x30,0xdd,0x25,0xcf,0x93,0x78,0xe6,0xb0,0x39,0xaa,0x8e,0xf,0x68,0xc6,0x2d,0x5b,
0xb1,0x4,0x55,0x61,0x9e,0x46,0x22,0xc5,0xbf,0xa3,0xb0,0x40,0xb,0x55,0xa6,0xc1,
0x57,0x7d,0x2e,0xe0,0xec,0xb0,0x7c,0x6a,0x18,0x93,0xf0,0x3,0xcc,0x60,0xf3,0x3e,
0x78,0xc2,0x25,0xdb,0xa9,0x70,0x3f,0xac,0xd,0x13,0x79,0xcd,0xf,0x55,0x33,0x2,
0x75,0xbd,0x83,0x27,0x77,0x65,0xe3,0x5d,0x29,0x5a,0xc7,0x89,0xab,0xff,0x6a,0x38,
0x37,0xac,0x9f,0x1d,0x4c,0x8,0x5e,0xcb,0x18,0x34,0xbc,0x8c,0xcd,0x6c,0xe1,0xa4,
0xf8,0xea,0xf0,0xfa,0xf,0x5e,0x49,0xfe,0xca,0xd2,0xf5,0x34,0x83,0x1f,0xe0,0x73,
0x4b,0x97,0x2f,0x7e,0xd6,0x59,0x5b,0x31,0x2f,0x23,0x8d,0xdc,0x2f,0xff,0x46,0xd,
0x55,0x1,0x63,0xde,0x17,0xf6,0xf,0x8e,0xe4,0x20,0x3f,0x44,0x6e,0x10,0xee,0xc9,
0xef,0x17,0xbc,0x3e,0x86,0xdd,0xfc,0x9f,0xb1,0xa7,0xc3,0x41,0xb0,0xbd,0xd3,0xc9,
0x27,0x48,0x99,0x48,0x2c,0x54,0x50,0x82,0x7f,0xa9,0xe8,0xdb,0x2,0x19,0x2a,0xfa,
0xbe,0xd3,0x60,0x9e,0x1e,0x4e,0x8,0x2a,0x91,0x34,0x4e,0xd0,0xfd,0xe8,0xb,0xb0,
0x49,0xd,0x3d,0x76,0x97,0x3,0xbf,0xf7,0x11,0xe8,0x1c,0x8c,0xa1,0x29,0xf2,0x3c,
0x54,0xe0,0x83,0xf,0x42,0x15,0x23,0xc4,0x8f,0xce,0xf,0xc0,0xd5,0xd,0xf2,0xe9,
0xe1,0xc3,0x6,0x8f,0xe8,0x86,0x2c,0x80,0x9d,0x4e,0x5b,0xbc,0xa5,0x65,0xe7,0x2f,
0xca,0xf,0xd0,0xeb,0x4f,0x41,0x9e,0x10,0xd,0xe6,0x30,0xae,0x51,0xe,0xbc,0x3f,
0x10,0x1f,0x21,0xff,0x2,0xbe,0xe3,0xc3,0xe8,0xd1,0xb1,0x3a,0x38,0xf0,0x72,0xe4,
0xa,0x18,0xd,0x33,0x61,0x87,0x0,0x4e,0xfe,0x79,0xc8,0x43,0xa2,0xc1,0x31,0xf8,
0xb8,0x3,0xef,0x1e,0xfe,0xc9,0x57,0xf0,0x2e,0x4,0xe1,0xd6,0x2,0xf4,0x10,0xf8,
0x90,0x32,0x8,0x3,0xfa,0x23,0x92,0x3b,0x10,0x42,0x20,0xe1,0xb9,0x25,0x79,0x8b,
0xf6,0x39,0xf0,0x7e,0x51,0x5d,0x53,0xe0,0xfb,0x79,0x50,0x2,0x60,0x61,0x2e,0x16,
0xd,0xbe,0x76,0xf2,0x61,0x52,0xe6,0x90,0x5b,0xd3,0xf1,0x8e,0x76,0xfa,0xee,0xf,
0x7c,0xb,0xb0,0xa8,0x16,0xd,0xc6,0x2f,0xc9,0x5b,0x78,0x5c,0x9c,0xfc,0x26,0xc8,
0x34,0x8,0x1c,0x7f,0x9a,0x68,0x2b,0x40,0x80,0x5b,0x40,0x2e,0xf2,0x58,0x1d,0x6,
0xc5,0x8b,0x73,0x17,0x66,0x3b,0xf0,0xbc,0xf,0xb9,0xc,0x2a,0x98,0x87,0xf7,0xb1,
0x20,0x5,0xc0,0x82,0x89,0x2d,0x1f,0x3e,0x74,0xe4,0x2a,0x36,0x7,0xd4,0x62,0x70,
0x4,0xde,0xad,0xfa,0xe1,0xd5,0x9a,0x8,0x4c,0x74,0xf0,0xee,0x9f,0xa,0x41,0x30,
0x5b,0x80,0x45,0x46,0x2d,0x37,0xa5,0xf6,0xc2,0xc4,0xc5,0xb9,0xb,0x3e,0x45,0x55,
0x4c,0x81,0x2d,0xd4,0x45,0x25,0xde,0xfb,0x5,0xcf,0x40,0xdc,0x7,0xb0,0x18,0x91,
0x76,0x5b,0x17,0x24,0xd5,0x5f,0x51,0x77,0xc1,0xa5,0x8b,0x72,0xe6,0x9f,0x74,0xb0,
0x7f,0x67,0xe4,0x13,0xf1,0xdb,0xc9,0xdf,0xc2,0x2b,0xf0,0xaf,0x42,0x41,0xd0,0x5b,
0x80,0x5,0x93,0xf1,0x31,0x2,0xcf,0x18,0xcf,0x43,0x26,0x5f,0xc2,0x4,0x61,0xf2,
0x43,0xa8,0x5,0xd8,0xea,0x11,0x83,0xc,0x12,0xd,0xca,0x85,0x8f,0x92,0x43,0xa9,
0x2,0x58,0x18,0x63,0xee,0x47,0x54,0x3c,0xb4,0x70,0xd9,0x3c,0x1f,0xa,0xc2,0xa5,
0x2,0x58,0xf4,0x17,0xd,0x72,0x98,0xfc,0x62,0x14,0x84,0x47,0x0,0x2c,0xf4,0x2a,
0x7c,0x2,0x3e,0x1a,0x80,0x17,0xf,0x2,0x6c,0xb,0xf8,0x1c,0xa9,0xeb,0xa7,0xe9,
0xaf,0x2e,0x58,0x3a,0x77,0x37,0xa,0xc2,0xad,0x2,0x58,0xbc,0x24,0xfc,0x49,0xba,
0xa7,0x20,0x8,0xc7,0xa,0x60,0x6f,0x29,0xcf,0x41,0x6e,0x82,0xe3,0x6a,0x30,0xa8,
0x84,0xc9,0xf3,0xb3,0xe7,0x1e,0x11,0xac,0x42,0xf5,0x46,0x90,0xc5,0x6d,0xc3,0xee,
0x30,0xc8,0x48,0x38,0x6,0x5e,0x1,0xab,0xe1,0x72,0x38,0x63,0x7e,0xf6,0x9c,0x2f,
0x51,0x19,0x36,0x0,0x16,0x76,0xd,0x60,0x61,0x3,0x60,0x61,0x3,0x60,0x61,0x3,
0x60,0x61,0x3,0x60,0x61,0x3,0x60,0x61,0x3,0x60,0x61,0x3,0x60,0x61,0x3,0x60,
0x61,0x3,0x60,0x61,0x3,0x60,0x61,0x3,0x60,0x61,0x3,0x60,0x61,0x3,0x60,0x61,
0x3,0x60,0xf1,0x5f,0xc0,0x3d,0xd3,0xec,0xbd,0x88,0x41,0xb4,0x0,0x0,0x0,0x0,
0x49,0x45,0x4e,0x44,0xae,0x42,0x60,0x82,
// /home/cyrille/Documents/IHM/IHM_Lecteur_Audio/client_audio/resource/pause.png
0x0,0x0,0x2,0x15,
0x89,
0x50,0x4e,0x47,0xd,0xa,0x1a,0xa,0x0,0x0,0x0,0xd,0x49,0x48,0x44,0x52,0x0,
0x0,0x0,0x80,0x0,0x0,0x0,0x80,0x8,0x6,0x0,0x0,0x0,0xc3,0x3e,0x61,0xcb,
0x0,0x0,0x0,0x4,0x73,0x42,0x49,0x54,0x8,0x8,0x8,0x8,0x7c,0x8,0x64,0x88,
0x0,0x0,0x0,0x9,0x70,0x48,0x59,0x73,0x0,0x0,0xb,0x13,0x0,0x0,0xb,0x13,
0x1,0x0,0x9a,0x9c,0x18,0x0,0x0,0x1,0xb7,0x49,0x44,0x41,0x54,0x78,0x9c,0xed,
0xd5,0xb1,0x89,0x96,0x41,0x0,0x45,0xd1,0xa7,0xb1,0x16,0xb1,0x5a,0xc4,0xb6,0xa4,
0x8,0x16,0x61,0x60,0x3,0xa,0x76,0x62,0x60,0x1,0x62,0x11,0xa2,0x60,0xd,0x62,
0xe8,0x1a,0xac,0xd9,0xa2,0x7c,0xc1,0xef,0xfe,0xbb,0xde,0x73,0x60,0xb2,0x9,0x1e,
0xc3,0x85,0xd9,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x80,0xff,0xc7,0x83,0x73,
0xf,0x38,0xe8,0xf1,0xb6,0x77,0xdb,0x2e,0x77,0x73,0xf3,0xd5,0xb6,0x2f,0xdb,0x9e,
0x6d,0xfb,0x7a,0xcb,0xbb,0x9e,0xfe,0xde,0x75,0xf1,0x87,0x5d,0x9f,0xb6,0x3d,0xdf,
0xf6,0xfd,0x96,0x77,0xfd,0x77,0x5e,0xef,0xfa,0x41,0xff,0x76,0xde,0x9f,0x61,0xd7,
0x87,0x3,0xbb,0x5e,0x9d,0x61,0xd7,0x61,0xf,0xcf,0x3d,0xe0,0xa0,0x8b,0x13,0xdd,
0x39,0xb5,0xbb,0xba,0xeb,0xb0,0xfb,0x12,0xc0,0x91,0xaf,0xea,0x1c,0xdf,0xd9,0x5d,
0xdd,0x75,0xd8,0x7d,0x9,0x80,0x7f,0x44,0x0,0x71,0x2,0x88,0x13,0x40,0x9c,0x0,
0xe2,0x4,0x10,0x27,0x80,0x38,0x1,0xc4,0x9,0x20,0x4e,0x0,0x71,0x2,0x88,0x13,
0x40,0x9c,0x0,0xe2,0x4,0x10,0x27,0x80,0x38,0x1,0xc4,0x9,0x20,0x4e,0x0,0x71,
0x2,0x88,0x13,0x40,0x9c,0x0,0xe2,0x4,0x10,0x27,0x80,0x38,0x1,0xc4,0x9,0x20,
0x4e,0x0,0x71,0x2,0x88,0x13,0x40,0x9c,0x0,0xe2,0x4,0x10,0x27,0x80,0x38,0x1,
0xc4,0x9,0x20,0x4e,0x0,0x71,0x2,0x88,0x13,0x40,0x9c,0x0,0xe2,0x4,0x10,0x27,
0x80,0x38,0x1,0xc4,0x9,0x20,0x4e,0x0,0x71,0x2,0x88,0x13,0x40,0x9c,0x0,0xe2,
0x4,0x10,0x27,0x80,0x38,0x1,0xc4,0x9,0x20,0x4e,0x0,0x71,0x2,0x88,0x13,0x40,
0x9c,0x0,0xe2,0x4,0x10,0x27,0x80,0x38,0x1,0xc4,0x9,0x20,0x4e,0x0,0x71,0x2,
0x88,0x13,0x40,0x9c,0x0,0xe2,0x4,0x10,0x27,0x80,0x38,0x1,0xc4,0x9,0x20,0x4e,
0x0,0x71,0x2,0x88,0x13,0x40,0x9c,0x0,0xe2,0x4,0x10,0x27,0x80,0x38,0x1,0xc4,
0x9,0x20,0x4e,0x0,0x71,0x2,0x88,0x13,0x40,0x9c,0x0,0xe2,0x4,0x10,0x27,0x80,
0x38,0x1,0xc4,0x9,0x20,0x4e,0x0,0x71,0x2,0x88,0x13,0x40,0x9c,0x0,0xe2,0xee,
0x4b,0x0,0x57,0x27,0xba,0x73,0x6a,0x77,0x75,0xd7,0x61,0xf7,0x25,0x80,0x2f,0x7,
0xee,0x7c,0xfe,0xe7,0x2b,0x6e,0xba,0xab,0xbb,0xe,0x7b,0x70,0xee,0x1,0x7,0x3d,
0xda,0xf6,0x66,0xdb,0xe5,0x6e,0x46,0x7b,0xb5,0xeb,0x47,0x7e,0xb1,0xed,0xdb,0x2d,
0xef,0xba,0xd8,0xf6,0x76,0xdb,0x93,0xdd,0x7c,0xcb,0x9f,0xdb,0x3e,0x6e,0x7b,0xb9,
0xed,0xc7,0x2d,0xef,0x2,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x92,0x7e,0x1,
0x2c,0x8f,0x2b,0x15,0x9a,0xeb,0x40,0x6c,0x0,0x0,0x0,0x0,0x49,0x45,0x4e,0x44,
0xae,0x42,0x60,0x82,
// /home/cyrille/Documents/IHM/IHM_Lecteur_Audio/client_audio/resource/back_2.png
0x0,0x0,0x3,0x68,
0x89,
0x50,0x4e,0x47,0xd,0xa,0x1a,0xa,0x0,0x0,0x0,0xd,0x49,0x48,0x44,0x52,0x0,
0x0,0x0,0x80,0x0,0x0,0x0,0x80,0x8,0x6,0x0,0x0,0x0,0xc3,0x3e,0x61,0xcb,
0x0,0x0,0x0,0x4,0x73,0x42,0x49,0x54,0x8,0x8,0x8,0x8,0x7c,0x8,0x64,0x88,
0x0,0x0,0x0,0x9,0x70,0x48,0x59,0x73,0x0,0x0,0xb,0x13,0x0,0x0,0xb,0x13,
0x1,0x0,0x9a,0x9c,0x18,0x0,0x0,0x3,0xa,0x49,0x44,0x41,0x54,0x78,0x9c,0xed,
0xdd,0xbb,0x6a,0x54,0x51,0x14,0x87,0xf1,0xcf,0x4b,0xa1,0x78,0xeb,0x2c,0x2d,0x34,
0xe0,0x3,0x88,0x6f,0x60,0x6d,0x1a,0xd1,0xf4,0x82,0x20,0xe6,0x19,0xf4,0xd,0xb4,
0x50,0xb0,0x51,0x6c,0x2c,0x2c,0x4,0x53,0x59,0xf8,0x6,0x16,0xa9,0x4,0x7b,0xdf,
0x41,0x85,0x8,0x1a,0x8b,0xf1,0x92,0xcb,0xc9,0x9c,0x73,0x66,0xf6,0xc9,0xce,0xda,
0xeb,0xfb,0xc1,0x54,0x33,0x90,0x45,0xfe,0x5f,0x86,0xa9,0x26,0x20,0x49,0x92,0x24,
0x49,0x92,0x24,0x49,0x92,0x24,0x49,0x92,0x24,0xa9,0x1d,0xc7,0x6a,0x1f,0x0,0xac,
0x2,0x8f,0x80,0xf3,0x1d,0xcf,0x6d,0x1,0x2f,0x81,0xc7,0x87,0x7a,0x91,0xe,0xcd,
0x39,0xe0,0x3b,0xb0,0xdd,0xf3,0xb8,0x5e,0xeb,0xc0,0xd6,0x1d,0xaf,0xfc,0xf3,0x2f,
0x2,0xa7,0x7,0xbc,0xee,0xf2,0xd4,0x87,0x2c,0xe1,0x2a,0xf0,0xc,0xd8,0x4,0x3e,
0x3,0xef,0x80,0x5b,0x1c,0x8d,0x77,0xd7,0x23,0x6f,0x85,0xfe,0xbf,0xfe,0x6d,0x60,
0xad,0xd6,0x81,0x3d,0xee,0x1,0x3f,0xe8,0xbe,0xf9,0x3d,0x70,0xa6,0xde,0x69,0x31,
0x44,0xe,0x60,0x9d,0xfe,0xbb,0xdf,0x54,0xbb,0x2e,0x88,0xa8,0x1,0xc,0x19,0x3f,
0xc4,0xe7,0x97,0xda,0x9f,0x1,0x22,0x5a,0x7,0x9e,0x8e,0x78,0xfd,0xcd,0xa9,0xe,
0x29,0xc1,0x0,0xc6,0x19,0x3b,0x3e,0xc0,0xa5,0x29,0xe,0x29,0xc5,0x0,0x86,0x5b,
0x64,0x7c,0x80,0x13,0xa5,0xf,0x29,0xc9,0x0,0x86,0x59,0x74,0xfc,0x23,0xcf,0x0,
0xfa,0x35,0x3b,0x3e,0x18,0x40,0x9f,0xa6,0xc7,0x7,0x3,0x98,0xa7,0xf9,0xf1,0xc1,
0x0,0xe,0x92,0x62,0x7c,0x30,0x80,0x2e,0x69,0xc6,0x7,0x3,0xd8,0x2b,0xd5,0xf8,
0x60,0x0,0x3b,0xa5,0x1b,0x1f,0xc,0xe0,0xaf,0x94,0xe3,0x83,0x1,0x40,0xe2,0xf1,
0xc1,0x0,0x52,0x8f,0xf,0xb9,0x3,0x48,0x3f,0x3e,0xe4,0xd,0xc0,0xf1,0xff,0xc8,
0x18,0x80,0xe3,0xef,0x90,0x2d,0x0,0xc7,0xdf,0x23,0x53,0x0,0x8e,0xdf,0x21,0x4b,
0x0,0x8e,0x7f,0x80,0xc,0x1,0x38,0xfe,0x1c,0xad,0x7,0xe0,0xf8,0x3d,0x5a,0xe,
0xc0,0xf1,0x7,0x68,0x35,0x0,0xc7,0x1f,0xa8,0xc5,0x0,0x1c,0x7f,0x84,0xd6,0x2,
0x70,0xfc,0x91,0x5a,0xa,0xc0,0xf1,0x17,0xd0,0x4a,0x0,0x8e,0xbf,0xa0,0x16,0x2,
0x70,0xfc,0x25,0x44,0xf,0xc0,0xf1,0x97,0x14,0x39,0x0,0xc7,0x2f,0x20,0x6a,0x0,
0x8e,0x5f,0x48,0xc4,0x0,0x1c,0xbf,0xa0,0x68,0x1,0x38,0x7e,0x61,0x91,0x2,0x70,
0xfc,0x9,0x9c,0xac,0x7d,0xc0,0x40,0x77,0x81,0x1b,0xb5,0x8f,0x68,0x51,0x94,0x77,
0x0,0xc7,0x9f,0x48,0x94,0x0,0x34,0x11,0x3,0x48,0xce,0x0,0x92,0x33,0x80,0xe4,
0xc,0x20,0x39,0x3,0x48,0xce,0x0,0x92,0x8b,0x12,0xc0,0x7,0x66,0x5f,0xbc,0xac,
0xc2,0xa2,0x4,0xf0,0xa,0x78,0x80,0x11,0x14,0x17,0x25,0x0,0x80,0xe7,0x18,0x41,
0x71,0x91,0x2,0x0,0x23,0x28,0x2e,0x5a,0x0,0x60,0x4,0x45,0x45,0xc,0x0,0x8c,
0xa0,0x98,0xa8,0x1,0x80,0x11,0x14,0x11,0x39,0x0,0x30,0x82,0xa5,0x45,0xf,0x0,
0x8c,0x60,0x29,0x2d,0x4,0x0,0x46,0xb0,0xb0,0x56,0x2,0x0,0x23,0x58,0x48,0x4b,
0x1,0x80,0x11,0x8c,0xd6,0x5a,0x0,0x60,0x4,0xa3,0xb4,0x18,0x0,0x18,0xc1,0x60,
0xad,0x6,0x0,0x46,0x30,0x48,0xcb,0x1,0x80,0x11,0xf4,0x6a,0x3d,0x0,0x30,0x82,
0xb9,0x32,0x4,0x0,0x46,0x70,0xa0,0x2c,0x1,0x80,0x11,0x74,0xca,0x14,0x0,0x18,
0xc1,0x3e,0xd9,0x2,0x0,0x23,0xd8,0x25,0x63,0x0,0x60,0x4,0xff,0x64,0xd,0x0,
0x8c,0x0,0xc8,0x1d,0x0,0x18,0x41,0xfa,0x0,0x20,0x79,0x4,0x6,0x30,0x93,0x36,
0x2,0x3,0xf8,0x2f,0x65,0x4,0x6,0xb0,0x5b,0xba,0x8,0xc,0x60,0xbf,0x54,0x11,
0x18,0x40,0xb7,0x34,0x11,0x18,0xc0,0xc1,0x52,0x44,0x60,0x0,0xf3,0x35,0x1f,0x81,
0x1,0xf4,0x6b,0x3a,0x2,0x3,0x18,0xa6,0xd9,0x8,0xc,0x60,0xb8,0x45,0x23,0xf8,
0x39,0xc1,0x2d,0xc5,0x18,0xc0,0x38,0x8b,0x44,0xf0,0x65,0xa2,0x5b,0x8a,0x30,0x80,
0xf1,0xc6,0x46,0xb0,0x31,0xe1,0x2d,0xe1,0xad,0x30,0xfb,0x45,0xf6,0x3d,0xd6,0x6a,
0x1d,0x38,0xc7,0x7d,0xe0,0x17,0xf3,0xef,0x7e,0x5d,0xed,0xba,0x20,0x22,0x7,0x0,
0xb3,0xaf,0xb1,0xdf,0xa2,0xfb,0xe6,0xd,0xe0,0x54,0xbd,0xd3,0x62,0xb8,0xc2,0xb0,
0x0,0xee,0xd4,0x3a,0x70,0x80,0x15,0xe0,0x9,0xf0,0x11,0xf8,0x4,0xbc,0x5,0x56,
0xab,0x5e,0x14,0xc8,0x59,0xe0,0x1b,0xfd,0x1,0x5c,0xab,0x75,0x60,0xeb,0x6a,0xff,
0xc7,0x90,0xaf,0xc0,0x6d,0xe0,0x21,0x70,0xa1,0xe3,0xf9,0x2d,0xe0,0x5,0xb0,0x79,
0x98,0x47,0x49,0x92,0x24,0x49,0x92,0x24,0x49,0x92,0x24,0x49,0x92,0x24,0x49,0x52,
0x4c,0xbf,0x1,0x6f,0xab,0xf5,0x5a,0xb3,0xa1,0x56,0xed,0x0,0x0,0x0,0x0,0x49,
0x45,0x4e,0x44,0xae,0x42,0x60,0x82,
// /home/cyrille/Documents/IHM/IHM_Lecteur_Audio/client_audio/resource/volume_mixer.png
0x0,0x0,0x4,0xb9,
0x89,
0x50,0x4e,0x47,0xd,0xa,0x1a,0xa,0x0,0x0,0x0,0xd,0x49,0x48,0x44,0x52,0x0,
0x0,0x0,0x80,0x0,0x0,0x0,0x80,0x8,0x6,0x0,0x0,0x0,0xc3,0x3e,0x61,0xcb,
0x0,0x0,0x0,0x4,0x73,0x42,0x49,0x54,0x8,0x8,0x8,0x8,0x7c,0x8,0x64,0x88,
0x0,0x0,0x0,0x9,0x70,0x48,0x59,0x73,0x0,0x0,0xb,0x13,0x0,0x0,0xb,0x13,
0x1,0x0,0x9a,0x9c,0x18,0x0,0x0,0x4,0x5b,0x49,0x44,0x41,0x54,0x78,0x9c,0xed,
0xdd,0xcd,0x8b,0x1c,0x45,0x1c,0xc6,0xf1,0xaf,0x31,0x82,0x51,0xcc,0x6a,0xd8,0x8d,
0xec,0xfa,0x72,0x33,0x8,0xf1,0xa0,0xc9,0x21,0x28,0x88,0x8,0x5e,0xfd,0x3,0x54,
0x84,0x28,0x6,0x43,0x30,0xe8,0x9f,0xb0,0xe2,0xc9,0x28,0xe2,0x21,0x1e,0x24,0x4,
0xf4,0xa6,0x1e,0x4,0xd1,0xa3,0x87,0x15,0x11,0x23,0x12,0x45,0x41,0x93,0x5,0xc1,
0x97,0xc4,0xf8,0x96,0x20,0x6a,0x36,0x7a,0xc9,0x8e,0x87,0xda,0x26,0xeb,0x62,0x7a,
0xaa,0xaa,0x7f,0xd5,0x3d,0x35,0xbf,0xe7,0x3,0x73,0xeb,0x9a,0xa7,0x6a,0xf7,0x49,
0x57,0x4f,0xa6,0xd3,0x1,0x11,0x11,0x11,0x11,0x11,0x11,0x11,0x11,0x11,0x11,0x11,
0x11,0x11,0x11,0x11,0x11,0x11,0x11,0x11,0x99,0x6,0x57,0x1a,0xbf,0xdf,0x3c,0xb0,
0x1b,0xd8,0x6,0x9c,0x5,0x56,0x8d,0xdf,0x7f,0xa3,0xab,0x80,0xbb,0x80,0x1d,0xc0,
0x3f,0xc0,0x4a,0xe1,0xbc,0xc6,0x2,0x97,0xd6,0xf9,0x1b,0xd3,0xbb,0xce,0x68,0xf3,
0xc0,0x3b,0x84,0x1f,0xc4,0x68,0xed,0x75,0x6,0x78,0xa4,0x60,0xe6,0x63,0xc0,0x2f,
0xeb,0xf2,0x56,0x81,0xb7,0x81,0x1b,0xb,0x66,0x2e,0x0,0xef,0xae,0xcb,0x1c,0x1,
0x3f,0x1,0x8f,0x16,0xcc,0x1c,0x62,0x9d,0x49,0x6e,0x0,0xbe,0xe1,0xbf,0x3f,0x94,
0xf5,0xaf,0xfd,0x5,0x32,0x9f,0x6e,0xc9,0x5b,0x6,0x66,0xa,0x64,0x6e,0xa3,0x7d,
0x9d,0x7,0xa,0x64,0xe,0xb1,0xce,0x64,0x2f,0x71,0xf9,0x49,0x8e,0x8,0xa7,0xab,
0x59,0xc3,0xbc,0x79,0xc2,0x69,0xb0,0x2d,0xf3,0x5,0xc3,0xbc,0xc6,0xcb,0x63,0x32,
0x2f,0x0,0x73,0x86,0x79,0x43,0xad,0x33,0xd9,0x69,0xda,0x27,0x39,0x2,0xf6,0x1a,
0xe6,0x3d,0x19,0x91,0xf7,0xbd,0x61,0x5e,0x23,0x66,0x9d,0x8f,0x1b,0xe6,0xf5,0xb2,
0xce,0x4d,0x5d,0xdf,0x80,0xb0,0x2f,0x8e,0x73,0xab,0x41,0x4e,0xe3,0xa6,0x88,0x63,
0x6e,0x31,0xcc,0x4b,0xc9,0xbd,0xb9,0xe7,0xbc,0xce,0xeb,0xb4,0x28,0xc0,0x15,0x3d,
0xe5,0xa4,0xbc,0x57,0xcc,0x9c,0x4a,0xa8,0x6e,0x9d,0x96,0x13,0x96,0xa,0xa9,0x0,
0xce,0xa9,0x0,0xce,0x6d,0x1e,0x7a,0x2,0x15,0x79,0x36,0xe2,0x98,0xa5,0xd2,0x93,
0xb0,0xa6,0x2,0xc4,0x5b,0x1c,0x7a,0x2,0x25,0x68,0xb,0x70,0x4e,0x5,0x70,0x4e,
0x5,0x70,0x4e,0xd7,0x0,0xed,0x76,0x2,0x4f,0x1,0x5b,0x12,0xc6,0x8c,0x80,0xe3,
0xc0,0xe1,0x22,0x33,0x32,0xa6,0x2,0xb4,0x3b,0x2,0xdc,0x9d,0x31,0x6e,0x2f,0xf0,
0x5,0xf0,0xa1,0xe9,0x6c,0xa,0xd0,0x16,0xd0,0x6e,0x6b,0x87,0xb1,0x13,0xf1,0x55,
0xed,0x38,0x2a,0x80,0x73,0x2a,0x80,0x73,0x2a,0x80,0x73,0x2a,0x80,0x73,0x2a,0x80,
0x73,0x2a,0x80,0x73,0x2a,0x80,0x73,0x2a,0x80,0x73,0x2a,0x80,0x73,0x2a,0x80,0x73,
0x2a,0x80,0x73,0x2a,0x80,0x73,0x2a,0x80,0x73,0x2a,0x80,0x73,0x2a,0x80,0x73,0x2a,
0x80,0x73,0x2a,0x40,0xbb,0x3f,0x3a,0x8c,0xfd,0xdd,0x6c,0x16,0x5,0xe9,0x96,0xb0,
0x76,0x4f,0x0,0x7,0x81,0x6b,0x12,0xc6,0x8c,0x80,0x4f,0x80,0x8f,0x8a,0xcc,0xc8,
0x98,0xa,0xd0,0xee,0x4,0x65,0x9e,0xfc,0x31,0x31,0xb4,0x5,0x38,0xa7,0x2,0x38,
0xa7,0x2,0x38,0x57,0xe3,0x35,0xc0,0x51,0xe0,0xfd,0x1,0x72,0x97,0x22,0x8e,0x79,
0x6d,0xed,0x55,0x8d,0x1a,0xb,0xf0,0xed,0xda,0xab,0x6f,0xf7,0x45,0x1c,0xb3,0x54,
0x7a,0x12,0xd6,0xb4,0x5,0x38,0xa7,0x2,0x38,0x57,0xe3,0x16,0xe0,0x45,0x2f,0xd7,
0x3a,0xb5,0x14,0x60,0x33,0xe1,0xa9,0x98,0x77,0x92,0xf6,0x68,0xb4,0xb,0xc0,0x73,
0xc0,0xc7,0x25,0x26,0x55,0x58,0x2f,0xd7,0x3a,0xb5,0x14,0xe0,0x1,0xe0,0x99,0xcc,
0xb1,0xd7,0x3,0xf7,0x18,0xce,0x65,0xaa,0x58,0x14,0xe0,0xfe,0x88,0x63,0xbe,0xeb,
0x98,0x71,0x75,0x87,0xb1,0x29,0x7f,0x8f,0xef,0x8e,0x45,0x1,0x96,0xc,0xde,0x43,
0x2e,0x59,0x0,0x6e,0x23,0x7d,0xab,0xfb,0x94,0xf0,0x45,0x54,0x92,0x5a,0xb6,0x0,
0x2f,0x6e,0x7,0x3e,0x23,0xed,0x89,0x24,0x8d,0x57,0x8,0x4f,0x33,0x49,0xa2,0x8f,
0x81,0x93,0xe5,0xe,0xf2,0x7e,0xf9,0x0,0x7b,0x72,0x6,0xa9,0x0,0xd3,0x23,0xeb,
0xc1,0xd1,0xb9,0x5,0x38,0x8,0xfc,0xcd,0xf8,0xe7,0xd9,0x6f,0x7c,0x1d,0x27,0xfc,
0xf,0x23,0x32,0x21,0x72,0xb,0xb0,0x8f,0xbc,0x2b,0xf3,0x5d,0xc0,0xbd,0x99,0x99,
0x52,0x40,0x6e,0x1,0xba,0x6c,0x1d,0xda,0x76,0x26,0x88,0x7e,0x19,0xce,0xa9,0x0,
0xce,0xa9,0x0,0xce,0xa9,0x0,0xce,0xa9,0x0,0xce,0xa9,0x0,0xce,0xa9,0x0,0xce,
0xa9,0x0,0xce,0xa9,0x0,0xce,0xd5,0x52,0x80,0x9f,0x3b,0x8c,0x3d,0x63,0x36,0x8b,
0x29,0x54,0xcb,0xfd,0x0,0xc7,0x80,0x7,0x81,0xdd,0xa4,0x7d,0xeb,0x75,0x1e,0x78,
0xbd,0xc8,0x8c,0xa6,0x44,0x2d,0x5,0x0,0x78,0x6f,0xed,0x25,0x86,0x6a,0xd9,0x2,
0xbc,0x58,0xed,0x30,0xf6,0x62,0xce,0x20,0x15,0x60,0xb2,0x7c,0x0,0x7c,0x9e,0x31,
0x6e,0x5,0x78,0x35,0x27,0xb0,0xa6,0x2d,0xc0,0x83,0x73,0x84,0x7b,0x26,0x7a,0x33,
0xc4,0x19,0x20,0xf9,0xce,0xd5,0xd,0x16,0x89,0xbb,0xfb,0x48,0x22,0xe4,0x16,0xe0,
0x58,0xe6,0xb8,0xf3,0xc0,0x97,0x99,0x63,0xa5,0x80,0xdc,0x2d,0x60,0x1f,0x61,0xcf,
0xb9,0x36,0x61,0xcc,0x88,0xf0,0xcc,0x9d,0x5f,0x33,0x33,0xa5,0x80,0xdc,0x2,0x8c,
0x8,0xff,0x10,0x41,0x2a,0xa7,0x4f,0x1,0x93,0x6b,0x91,0x1e,0xae,0x75,0x54,0x0,
0xe7,0x54,0x0,0xe7,0x2c,0xa,0x10,0x73,0x9a,0x5a,0x34,0xc8,0x91,0x2,0x74,0x6,
0x70,0x4e,0x5,0x70,0x4e,0x5,0x70,0x4e,0x5,0x70,0xce,0xea,0x22,0x70,0x9c,0x2e,
0x5f,0x73,0xe6,0xe4,0x95,0xf8,0x2e,0x60,0x2a,0xd7,0x69,0x51,0x80,0xd3,0x11,0xc7,
0x9c,0x32,0xc8,0x19,0x2a,0xaf,0xf1,0x63,0xc4,0x31,0x3f,0x18,0xe6,0xd,0xb5,0xce,
0x64,0x2f,0xd2,0xfe,0x11,0x70,0x5,0x98,0x33,0xcc,0xdb,0x4e,0x78,0x26,0x4e,0x5b,
0xe6,0x21,0xc3,0xbc,0x46,0xcc,0x3a,0x67,0xd,0xf3,0x62,0xd6,0xf9,0xbc,0x61,0x5e,
0xb6,0x19,0xe0,0x24,0x97,0x9f,0xe4,0xfe,0x2,0x99,0x7,0x5a,0xf2,0x4e,0x2,0x5b,
0xb,0x64,0xce,0x0,0xcb,0x2d,0xb9,0x7d,0xaf,0xf3,0x4,0x65,0xd6,0x99,0x65,0xe,
0x78,0x8b,0x70,0x5b,0x52,0x33,0xc1,0x53,0xc0,0x43,0x5,0x33,0x1f,0x26,0x9c,0x26,
0x9b,0xbc,0x8b,0xc0,0x9b,0xd8,0x9e,0x6d,0x36,0xda,0xce,0x64,0xac,0xf3,0xd,0x8c,
0xce,0x36,0x59,0xcf,0x95,0x69,0x31,0xb,0xec,0x0,0xfe,0x2,0xbe,0xc2,0xf6,0xa2,
0xe8,0xff,0x6c,0x2,0x76,0x12,0xfe,0x24,0x2c,0x3,0x67,0xb,0xe7,0x35,0x9a,0x75,
0xfe,0x9,0x7c,0x4d,0x7f,0xeb,0xbc,0x8e,0xb0,0xce,0x73,0x85,0xf3,0x44,0x44,0x44,
0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,
0xa4,0x32,0xff,0x2,0xfe,0x58,0x53,0x86,0xbf,0x88,0x61,0xf7,0x0,0x0,0x0,0x0,
0x49,0x45,0x4e,0x44,0xae,0x42,0x60,0x82,
// /home/cyrille/Documents/IHM/IHM_Lecteur_Audio/client_audio/resource/play.png
0x0,0x0,0x5,0x48,
0x89,
0x50,0x4e,0x47,0xd,0xa,0x1a,0xa,0x0,0x0,0x0,0xd,0x49,0x48,0x44,0x52,0x0,
0x0,0x0,0x80,0x0,0x0,0x0,0x80,0x8,0x6,0x0,0x0,0x0,0xc3,0x3e,0x61,0xcb,
0x0,0x0,0x0,0x4,0x73,0x42,0x49,0x54,0x8,0x8,0x8,0x8,0x7c,0x8,0x64,0x88,
0x0,0x0,0x0,0x9,0x70,0x48,0x59,0x73,0x0,0x0,0xb,0x13,0x0,0x0,0xb,0x13,
0x1,0x0,0x9a,0x9c,0x18,0x0,0x0,0x4,0xea,0x49,0x44,0x41,0x54,0x78,0x9c,0xed,
0xdd,0x7b,0xc8,0x9f,0x63,0x1c,0xc7,0xf1,0xf7,0x36,0x9b,0x73,0xf,0x5b,0x6c,0x8e,
0xe5,0xb0,0x34,0x61,0x31,0x4c,0x22,0x22,0xa5,0x44,0x24,0xa4,0x49,0x21,0xa5,0xc8,
0x21,0xfe,0x20,0x87,0x22,0x9a,0x22,0x21,0x2b,0x45,0x4a,0xa8,0xad,0x85,0xd4,0x94,
0x12,0x4b,0xb3,0x96,0x4c,0xe,0xad,0xd9,0x2c,0x6d,0xcd,0x66,0x9a,0xd3,0xd8,0xda,
0x9e,0x9d,0x9e,0x9f,0x3f,0xae,0xae,0x79,0xb6,0x3d,0x87,0x3d,0xcf,0xef,0xfa,0x5e,
0xc7,0xcf,0xab,0xbe,0xff,0xde,0xf7,0x75,0xf8,0x3c,0xf7,0x7d,0xff,0x9e,0xdf,0x75,
0xdd,0x3f,0x10,0x11,0x11,0x11,0x11,0x11,0x11,0x11,0x11,0x11,0x11,0x11,0x11,0x11,
0x11,0x91,0xda,0x8c,0x89,0x7c,0xbe,0x29,0xc0,0xcd,0xc0,0x15,0xc0,0x19,0x40,0xf,
0xb0,0x19,0x58,0x1,0x2c,0x4,0xe6,0x1,0x1b,0x22,0xb7,0x49,0x22,0xe8,0x1,0x5e,
0x5,0x76,0x0,0x9d,0x21,0x6a,0x3b,0xf0,0x32,0x30,0x29,0x4d,0x33,0xc5,0xc2,0xc,
0x60,0x2d,0x43,0x4f,0xfc,0xbe,0xf5,0x17,0x70,0x3f,0x30,0x3e,0x41,0x7b,0x25,0xa0,
0x99,0xc0,0x16,0x46,0x36,0xf9,0xfd,0x6b,0x39,0x70,0x75,0xf4,0x56,0x4b,0x10,0x53,
0x80,0x8d,0x8c,0x7e,0xf2,0xfb,0xd7,0x2,0xdc,0x33,0x83,0x14,0x64,0x3e,0x61,0x26,
0xdf,0xd7,0x4e,0xe0,0x25,0xe0,0xa8,0x98,0x9d,0x90,0xd1,0x39,0x97,0xb0,0x93,0xdf,
0xbf,0x7e,0x7,0xee,0x1,0xc6,0x45,0xeb,0x8d,0x8c,0xd8,0x1c,0xec,0x2,0xe0,0xeb,
0x7,0xdc,0xc7,0x49,0xc9,0xd0,0x1a,0xec,0x3,0xe0,0xeb,0x3,0xe0,0xd4,0x28,0xbd,
0x92,0x3,0x32,0x91,0x78,0x93,0xef,0x6b,0x3b,0x30,0x1b,0x38,0x32,0x42,0xff,0x64,
0x18,0xd3,0x88,0x1f,0x0,0x5f,0x1b,0x80,0x3b,0x80,0xb1,0xe6,0xbd,0x94,0x41,0x9d,
0x4f,0xba,0x0,0xf8,0x5a,0xa,0x5c,0x62,0xdd,0x51,0x19,0x58,0xe,0x1,0xf0,0x35,
0x17,0x38,0xd9,0xb6,0xbb,0xb2,0xaf,0x9c,0x2,0xd0,0x1,0xb6,0x1,0x4f,0x3,0x87,
0x5b,0x76,0x5a,0xfe,0x97,0x5b,0x0,0x7c,0xad,0x3,0x66,0x11,0xff,0x1b,0xd0,0xe6,
0xe4,0x1a,0x0,0x5f,0x4b,0x80,0xb,0xcd,0x7a,0x2f,0xd9,0x7,0xc0,0xd7,0xdb,0xc0,
0xf1,0x46,0x63,0xd0,0xb4,0x52,0x2,0xd0,0xc1,0x7d,0x53,0xf9,0x38,0x70,0xa8,0xc9,
0x48,0x34,0xaa,0xa4,0x0,0xf8,0x5a,0x3,0xdc,0x84,0x9e,0xf,0x82,0x28,0x31,0x0,
0xbe,0xbe,0xc0,0x7d,0x91,0x25,0x5d,0x28,0x39,0x0,0x1d,0xa0,0xf,0x78,0x3,0x98,
0x1c,0x7a,0x60,0x5a,0x51,0x7a,0x0,0x7c,0xfd,0xb,0x3c,0x2,0x4c,0x8,0x3b,0x3c,
0xf5,0xab,0x25,0x0,0xbe,0x56,0x1,0xd7,0xa1,0xe7,0x83,0x3,0x56,0x5b,0x0,0x7c,
0x7d,0xa,0x9c,0x15,0x70,0x9c,0xaa,0x55,0x6b,0x0,0x3a,0xc0,0x6e,0xdc,0x62,0x17,
0x2d,0x5b,0x1f,0x42,0xcd,0x1,0xf0,0xf5,0x37,0xf0,0x0,0x5a,0xb6,0x3e,0xa0,0x16,
0x2,0xe0,0xeb,0x47,0xb4,0x6c,0x7d,0x3f,0x2d,0x5,0xc0,0xd7,0xc7,0x68,0xd9,0xfa,
0x1e,0x2d,0x6,0xa0,0x83,0x96,0xad,0xef,0xd1,0x6a,0x0,0x7c,0xf9,0x65,0xeb,0x7,
0x75,0x3b,0x90,0xa5,0x6a,0x3d,0x0,0xbe,0x8a,0x58,0xb6,0xae,0xc5,0x93,0x76,0xce,
0x6,0x3e,0x3,0x3e,0x4,0x4e,0x4b,0xdc,0x96,0x41,0x29,0x0,0xf6,0xae,0xc7,0x6d,
0x72,0x7d,0x9e,0x46,0x96,0xad,0xeb,0x16,0x30,0x78,0xfd,0x6,0xdc,0x49,0xe5,0x7f,
0x78,0xa,0xc0,0xf0,0xf5,0xd,0x99,0x2c,0x5b,0xaf,0x3a,0x89,0x19,0x3b,0xf,0x58,
0x44,0x6,0xcb,0xd6,0x15,0x80,0xb4,0x6e,0x1,0x56,0x2,0xcf,0x50,0xd1,0xb2,0x75,
0xdd,0x2,0x46,0x57,0xeb,0x80,0xdb,0x88,0xfc,0x47,0xa9,0x2b,0x40,0x3e,0x4e,0x0,
0xde,0x1,0x16,0x13,0xf1,0x6b,0x67,0x5,0x20,0x3f,0x17,0xe1,0x1e,0x12,0xef,0x8a,
0x71,0x32,0x5,0x20,0x4f,0x13,0x80,0x37,0x81,0xfb,0xac,0x4f,0xa4,0x0,0xe4,0xed,
0x15,0xe0,0x72,0xcb,0x13,0x28,0x0,0x79,0x1b,0x8b,0x5b,0xa1,0x6c,0xb6,0x30,0x55,
0x1,0xc8,0xdf,0xe9,0xb8,0x4d,0xad,0x26,0x14,0x80,0x32,0x98,0x3d,0x10,0x2a,0x0,
0x65,0xb8,0x18,0xf7,0xee,0xa5,0xe0,0x14,0x80,0x32,0x8c,0x1,0xa6,0x5b,0x1c,0x58,
0x1,0x28,0xc7,0x71,0x16,0x7,0x55,0x0,0xca,0x71,0xb0,0xc5,0x41,0x15,0x80,0x72,
0x6c,0xb2,0x38,0xa8,0x2,0x50,0x8e,0x15,0x16,0x7,0x55,0x0,0xca,0xf0,0x7,0xf0,
0x93,0xc5,0x81,0x15,0x80,0x32,0xbc,0x8f,0xdb,0x97,0x18,0x9c,0x2,0x90,0xbf,0xe,
0xee,0x3b,0x1,0x13,0xa,0x40,0xfe,0xe6,0xe0,0xf6,0x20,0x9a,0x50,0x0,0xf2,0xf6,
0x3d,0xf0,0x98,0xe5,0x9,0x14,0x80,0x7c,0x2d,0x7,0xae,0xc1,0xbd,0xca,0xce,0x8c,
0x2,0x90,0xa7,0xb9,0xb8,0x65,0xe3,0xeb,0xad,0x4f,0xa4,0x0,0xe4,0x65,0x15,0x70,
0x2d,0x70,0x2b,0xee,0x25,0x14,0xe6,0x14,0x80,0x3c,0xfc,0x3,0x3c,0x8c,0x5b,0xc,
0xba,0x20,0xe6,0x89,0x9b,0xdd,0xc2,0x9c,0x9,0xff,0x4e,0xc2,0x27,0x71,0xdb,0xca,
0xa3,0x53,0x0,0xd2,0x59,0x8,0x3c,0x88,0xdb,0x46,0x9e,0x8c,0x6e,0x1,0xf1,0xad,
0x6,0x6e,0x4,0xae,0x24,0xf1,0xe4,0x83,0xae,0x0,0x31,0x6d,0x1,0x9e,0xc3,0xfd,
0x3a,0x7a,0x6f,0xe2,0xb6,0x98,0xd2,0xd6,0xb0,0xbd,0xab,0xf,0x78,0xb,0xa3,0x5,
0x1d,0xdd,0xd2,0x15,0xc0,0xd6,0x62,0xdc,0x7d,0x7e,0x69,0xea,0x86,0xc,0x46,0xcf,
0x0,0x36,0x7e,0xc1,0x7d,0x96,0xbf,0x94,0x8c,0x27,0x1f,0x74,0x5,0x8,0x6d,0x1b,
0xee,0x55,0x30,0x2f,0x2,0x5b,0x13,0xb7,0x25,0x99,0x56,0x9f,0x1,0xde,0x3,0x4e,
0xa,0x30,0x7e,0x51,0xe9,0xa,0xd0,0xbd,0xaf,0x71,0xef,0xd,0x5e,0x92,0xba,0x21,
0xb9,0x68,0xe5,0xa,0xf0,0x2b,0x70,0x3b,0x7a,0x8e,0xda,0x4f,0xed,0x1,0xe8,0xc5,
0x7d,0x9e,0x3f,0x22,0xd4,0x80,0xd5,0xa6,0xe6,0x0,0xcc,0x7,0x4e,0x9,0x37,0x54,
0x75,0xaa,0x31,0x0,0xdf,0x2,0x97,0x85,0x1c,0xa4,0x9a,0xd5,0x14,0x80,0x8d,0xc0,
0xdd,0xc0,0xb8,0xa0,0x23,0x54,0xb9,0x1a,0x2,0xb0,0x3,0x78,0x1,0xe8,0x9,0x3c,
0x36,0x4d,0x28,0x3d,0x0,0x1f,0x1,0x53,0x83,0x8f,0x4a,0x43,0x4a,0xd,0xc0,0x32,
0xe0,0x2a,0x83,0xf1,0x68,0x4e,0x69,0x1,0xf8,0x13,0xb8,0x17,0xfd,0x53,0x2c,0x98,
0x52,0x2,0xb0,0xb,0xb7,0xe3,0xc6,0xe4,0xcd,0x1b,0x2d,0x2b,0x21,0x0,0x9f,0x0,
0x67,0x5a,0xd,0x40,0xeb,0x72,0xe,0xc0,0x4a,0xdc,0x66,0xb,0xfd,0xc,0xac,0xa1,
0x1c,0x3,0xb0,0x9,0x78,0x8,0xfd,0x10,0x74,0x14,0x39,0x5,0x60,0x37,0xf0,0x3a,
0x70,0x8c,0x69,0x8f,0x65,0x2f,0xb9,0x4,0xe0,0x73,0xe0,0x1c,0xe3,0xbe,0xca,0x0,
0xa6,0x91,0x76,0xe2,0x7f,0x6,0x6e,0x40,0xf7,0xf9,0x64,0x8e,0x26,0xcd,0xc4,0x6f,
0x6,0x1e,0x5,0xe,0xb1,0xef,0xa2,0xc,0x67,0x35,0xf1,0x26,0x3e,0xeb,0x65,0xd7,
0xad,0x7a,0x8d,0x38,0x93,0xff,0x25,0x30,0x23,0x52,0x9f,0x64,0x4,0xa6,0x63,0x3b,
0xf1,0x6b,0x71,0x3f,0xb8,0xa4,0xfb,0x7c,0xc6,0xe6,0x11,0x7e,0xe2,0xb7,0x2,0x4f,
0x1,0x87,0x45,0xec,0x87,0x8c,0xd2,0x64,0xdc,0x82,0x8a,0x50,0x93,0xff,0x2e,0x70,
0x62,0xd4,0x1e,0x48,0xd7,0x66,0xe2,0x36,0x45,0x76,0x33,0xf1,0x5f,0xe1,0x7e,0x48,
0x49,0xa,0x75,0x1,0x6e,0x9,0xf5,0x48,0x27,0x5e,0xcb,0xae,0x2b,0x32,0x9,0xf7,
0x51,0xad,0x8f,0xe1,0x27,0xbe,0x17,0x78,0x16,0x2d,0xbb,0xae,0xd2,0x54,0x60,0x36,
0xf0,0x1d,0xee,0xff,0xf4,0x7e,0xd2,0x77,0xe2,0x76,0xd8,0x3c,0x1,0x1c,0x9b,0xac,
0x75,0xd,0x4a,0xf9,0x31,0x6a,0x3c,0x6e,0xb2,0x3b,0xb8,0x87,0xc5,0x5d,0x9,0xdb,
0x22,0x22,0x22,0x22,0x22,0x22,0x22,0x22,0x22,0x22,0x22,0x22,0x22,0x22,0x22,0x52,
0x93,0xff,0x0,0xa3,0x4c,0xf2,0xda,0x4b,0x27,0x3b,0x3a,0x0,0x0,0x0,0x0,0x49,
0x45,0x4e,0x44,0xae,0x42,0x60,0x82,
// /home/cyrille/Documents/IHM/IHM_Lecteur_Audio/client_audio/resource/unmute_3.svg
0x0,0x0,0x3,0x82,
0x3c,
0x3f,0x78,0x6d,0x6c,0x20,0x76,0x65,0x72,0x73,0x69,0x6f,0x6e,0x3d,0x22,0x31,0x2e,
0x30,0x22,0x20,0x3f,0x3e,0x3c,0x73,0x76,0x67,0x20,0x68,0x65,0x69,0x67,0x68,0x74,
0x3d,0x22,0x31,0x30,0x32,0x34,0x22,0x20,0x77,0x69,0x64,0x74,0x68,0x3d,0x22,0x38,
0x39,0x36,0x22,0x20,0x78,0x6d,0x6c,0x6e,0x73,0x3d,0x22,0x68,0x74,0x74,0x70,0x3a,
0x2f,0x2f,0x77,0x77,0x77,0x2e,0x77,0x33,0x2e,0x6f,0x72,0x67,0x2f,0x32,0x30,0x30,
0x30,0x2f,0x73,0x76,0x67,0x22,0x3e,0x3c,0x70,0x61,0x74,0x68,0x20,0x64,0x3d,0x22,
0x4d,0x31,0x32,0x38,0x20,0x33,0x38,0x34,0x48,0x30,0x76,0x32,0x35,0x36,0x68,0x31,
0x32,0x38,0x6c,0x32,0x35,0x36,0x20,0x31,0x39,0x32,0x68,0x36,0x34,0x56,0x31,0x39,
0x32,0x68,0x2d,0x36,0x34,0x4c,0x31,0x32,0x38,0x20,0x33,0x38,0x34,0x7a,0x4d,0x35,
0x33,0x38,0x2e,0x35,0x31,0x20,0x34,0x32,0x31,0x2e,0x34,0x39,0x63,0x2d,0x31,0x32,
0x2e,0x34,0x39,0x36,0x2d,0x31,0x32,0x2e,0x34,0x39,0x37,0x2d,0x33,0x32,0x2e,0x37,
0x35,0x38,0x2d,0x31,0x32,0x2e,0x34,0x39,0x37,0x2d,0x34,0x35,0x2e,0x32,0x35,0x35,
0x20,0x30,0x2d,0x31,0x32,0x2e,0x34,0x39,0x36,0x20,0x31,0x32,0x2e,0x34,0x39,0x36,
0x2d,0x31,0x32,0x2e,0x34,0x39,0x36,0x20,0x33,0x32,0x2e,0x37,0x35,0x38,0x20,0x30,
0x20,0x34,0x35,0x2e,0x32,0x35,0x35,0x20,0x32,0x34,0x2e,0x39,0x39,0x34,0x20,0x32,
0x34,0x2e,0x39,0x39,0x33,0x20,0x32,0x34,0x2e,0x39,0x39,0x34,0x20,0x36,0x35,0x2e,
0x35,0x31,0x36,0x20,0x30,0x20,0x39,0x30,0x2e,0x35,0x31,0x2d,0x31,0x32,0x2e,0x34,
0x39,0x36,0x20,0x31,0x32,0x2e,0x34,0x39,0x36,0x2d,0x31,0x32,0x2e,0x34,0x39,0x36,
0x20,0x33,0x32,0x2e,0x37,0x35,0x38,0x20,0x30,0x20,0x34,0x35,0x2e,0x32,0x35,0x35,
0x20,0x31,0x32,0x2e,0x34,0x39,0x37,0x20,0x31,0x32,0x2e,0x34,0x39,0x36,0x20,0x33,
0x32,0x2e,0x37,0x35,0x39,0x20,0x31,0x32,0x2e,0x34,0x39,0x36,0x20,0x34,0x35,0x2e,
0x32,0x35,0x35,0x20,0x30,0x43,0x35,0x38,0x38,0x2e,0x34,0x39,0x37,0x20,0x35,0x35,
0x32,0x2e,0x35,0x32,0x31,0x20,0x35,0x38,0x38,0x2e,0x34,0x39,0x37,0x20,0x34,0x37,
0x31,0x2e,0x34,0x37,0x37,0x20,0x35,0x33,0x38,0x2e,0x35,0x31,0x20,0x34,0x32,0x31,
0x2e,0x34,0x39,0x7a,0x4d,0x36,0x32,0x39,0x2e,0x30,0x32,0x20,0x33,0x33,0x30,0x2e,
0x39,0x38,0x31,0x63,0x2d,0x31,0x32,0x2e,0x34,0x39,0x35,0x2d,0x31,0x32,0x2e,0x34,
0x39,0x37,0x2d,0x33,0x32,0x2e,0x37,0x35,0x38,0x2d,0x31,0x32,0x2e,0x34,0x39,0x37,
0x2d,0x34,0x35,0x2e,0x32,0x35,0x35,0x20,0x30,0x2d,0x31,0x32,0x2e,0x34,0x39,0x35,
0x20,0x31,0x32,0x2e,0x34,0x39,0x36,0x2d,0x31,0x32,0x2e,0x34,0x39,0x35,0x20,0x33,
0x32,0x2e,0x37,0x35,0x38,0x20,0x30,0x20,0x34,0x35,0x2e,0x32,0x35,0x35,0x20,0x37,
0x34,0x2e,0x39,0x38,0x31,0x20,0x37,0x34,0x2e,0x39,0x38,0x20,0x37,0x34,0x2e,0x39,
0x38,0x31,0x20,0x31,0x39,0x36,0x2e,0x35,0x34,0x38,0x20,0x30,0x20,0x32,0x37,0x31,
0x2e,0x35,0x32,0x38,0x2d,0x31,0x32,0x2e,0x34,0x39,0x35,0x20,0x31,0x32,0x2e,0x34,
0x39,0x37,0x2d,0x31,0x32,0x2e,0x34,0x39,0x35,0x20,0x33,0x32,0x2e,0x37,0x36,0x20,
0x30,0x20,0x34,0x35,0x2e,0x32,0x35,0x36,0x20,0x31,0x32,0x2e,0x34,0x39,0x37,0x20,
0x31,0x32,0x2e,0x34,0x39,0x36,0x20,0x33,0x32,0x2e,0x37,0x36,0x20,0x31,0x32,0x2e,
0x34,0x39,0x36,0x20,0x34,0x35,0x2e,0x32,0x35,0x35,0x20,0x30,0x43,0x37,0x32,0x38,
0x2e,0x39,0x39,0x34,0x20,0x35,0x39,0x33,0x2e,0x30,0x34,0x36,0x20,0x37,0x32,0x38,
0x2e,0x39,0x39,0x34,0x20,0x34,0x33,0x30,0x2e,0x39,0x35,0x35,0x20,0x36,0x32,0x39,
0x2e,0x30,0x32,0x20,0x33,0x33,0x30,0x2e,0x39,0x38,0x31,0x7a,0x4d,0x37,0x31,0x39,
0x2e,0x35,0x32,0x39,0x20,0x32,0x34,0x30,0x2e,0x34,0x37,0x31,0x63,0x2d,0x31,0x32,
0x2e,0x34,0x39,0x37,0x2d,0x31,0x32,0x2e,0x34,0x39,0x37,0x2d,0x33,0x32,0x2e,0x37,
0x36,0x2d,0x31,0x32,0x2e,0x34,0x39,0x37,0x2d,0x34,0x35,0x2e,0x32,0x35,0x35,0x20,
0x30,0x2d,0x31,0x32,0x2e,0x34,0x39,0x36,0x20,0x31,0x32,0x2e,0x34,0x39,0x36,0x2d,
0x31,0x32,0x2e,0x34,0x39,0x36,0x20,0x33,0x32,0x2e,0x37,0x35,0x38,0x20,0x30,0x20,
0x34,0x35,0x2e,0x32,0x35,0x35,0x20,0x31,0x32,0x34,0x2e,0x39,0x36,0x38,0x20,0x31,
0x32,0x34,0x2e,0x39,0x36,0x38,0x20,0x31,0x32,0x34,0x2e,0x39,0x36,0x38,0x20,0x33,
0x32,0x37,0x2e,0x35,0x38,0x20,0x30,0x20,0x34,0x35,0x32,0x2e,0x35,0x34,0x38,0x2d,
0x31,0x32,0x2e,0x34,0x39,0x36,0x20,0x31,0x32,0x2e,0x34,0x39,0x37,0x2d,0x31,0x32,
0x2e,0x34,0x39,0x36,0x20,0x33,0x32,0x2e,0x37,0x35,0x39,0x20,0x30,0x20,0x34,0x35,
0x2e,0x32,0x35,0x35,0x20,0x31,0x32,0x2e,0x34,0x39,0x35,0x20,0x31,0x32,0x2e,0x34,
0x39,0x37,0x20,0x33,0x32,0x2e,0x37,0x35,0x38,0x20,0x31,0x32,0x2e,0x34,0x39,0x37,
0x20,0x34,0x35,0x2e,0x32,0x35,0x35,0x20,0x30,0x43,0x38,0x36,0x39,0x2e,0x34,0x39,
0x20,0x36,0x33,0x33,0x2e,0x35,0x36,0x37,0x20,0x38,0x36,0x39,0x2e,0x34,0x39,0x20,
0x33,0x39,0x30,0x2e,0x34,0x33,0x32,0x20,0x37,0x31,0x39,0x2e,0x35,0x32,0x39,0x20,
0x32,0x34,0x30,0x2e,0x34,0x37,0x31,0x7a,0x22,0x2f,0x3e,0x3c,0x2f,0x73,0x76,0x67,
0x3e,
// /home/cyrille/Documents/IHM/IHM_Lecteur_Audio/client_audio/resource/sound_low.png
0x0,0x0,0x3,0x59,
0x89,
0x50,0x4e,0x47,0xd,0xa,0x1a,0xa,0x0,0x0,0x0,0xd,0x49,0x48,0x44,0x52,0x0,
0x0,0x0,0x80,0x0,0x0,0x0,0x80,0x8,0x6,0x0,0x0,0x0,0xc3,0x3e,0x61,0xcb,
0x0,0x0,0x0,0x4,0x73,0x42,0x49,0x54,0x8,0x8,0x8,0x8,0x7c,0x8,0x64,0x88,
0x0,0x0,0x0,0x9,0x70,0x48,0x59,0x73,0x0,0x0,0xb,0x13,0x0,0x0,0xb,0x13,
0x1,0x0,0x9a,0x9c,0x18,0x0,0x0,0x2,0xfb,0x49,0x44,0x41,0x54,0x78,0x9c,0xed,
0xdd,0x3f,0x88,0xcf,0x71,0x1c,0xc7,0xf1,0xe7,0xfd,0xf1,0xef,0x24,0xba,0x74,0xd1,
0x85,0x2b,0x29,0x25,0xa2,0x14,0xa5,0xc,0xc8,0x60,0xb8,0x45,0x19,0x28,0x83,0x45,
0x19,0x18,0x94,0x81,0x41,0x19,0x48,0x57,0x16,0x65,0x60,0x50,0x6,0x6,0x65,0x30,
0x18,0x88,0x52,0x6,0xa5,0x90,0x14,0x25,0xb9,0x94,0x24,0x49,0x22,0x5c,0xfe,0xe,
0xdf,0xc1,0xc0,0x9d,0xfb,0xdd,0xfd,0xee,0xfb,0xfe,0x7e,0xbf,0xef,0xe7,0xa3,0x6e,
0xbe,0x4f,0xbd,0x9e,0xf7,0xab,0xeb,0xfb,0xfd,0xfe,0xbe,0x20,0x49,0x92,0x24,0x49,
0x92,0x24,0x49,0x92,0x24,0x49,0x92,0x24,0x49,0x92,0x24,0x69,0x52,0x76,0x47,0x1f,
0x40,0x31,0x56,0x0,0xb7,0x81,0x5f,0xd1,0x7,0x51,0xb9,0x66,0x3,0x43,0xc0,0x37,
0x8a,0xf1,0xd,0x20,0x91,0xed,0xc0,0x4b,0xfe,0xc,0x6f,0x0,0x49,0x2c,0x5,0xae,
0xf1,0xf7,0xf0,0x6,0xd0,0x70,0x33,0x80,0xa3,0xc0,0x17,0x46,0x1f,0xdf,0x0,0x1a,
0x6a,0x2b,0xf0,0x8c,0xb1,0x87,0x37,0x80,0x6,0xea,0x7,0x2e,0x33,0xbe,0xe1,0xd,
0xa0,0x41,0xba,0x81,0x83,0xc0,0x47,0x5a,0x1b,0xdf,0x0,0x1a,0x60,0x3,0xf0,0x88,
0xd6,0x87,0x37,0x80,0x9a,0x9b,0xf,0x9c,0x7,0x7e,0x32,0xf1,0xf1,0xd,0xa0,0x86,
0x3a,0x80,0xbd,0xc0,0x3b,0x26,0x37,0xbc,0x1,0xd4,0xd0,0x1a,0xe0,0x2e,0xed,0x19,
0xde,0x0,0x6a,0x64,0x2e,0x70,0x1a,0xf8,0x4e,0x7b,0xc7,0x37,0x80,0x1a,0xd8,0x5,
0xbc,0xa6,0xfd,0xc3,0x1b,0x40,0xc5,0x2d,0x7,0x6e,0x31,0x75,0xc3,0x1b,0x40,0x45,
0xf5,0x0,0x27,0x80,0x11,0xa6,0x7e,0x7c,0x3,0xa8,0x98,0x41,0x60,0x98,0x72,0x86,
0x37,0x80,0xa,0x19,0x0,0xae,0x52,0xee,0xf0,0x6,0x50,0x1,0xd3,0x81,0x23,0xc0,
0x67,0x62,0xc6,0x37,0x80,0x40,0x9b,0x81,0xa7,0xc4,0xd,0x6f,0x0,0x41,0x16,0x2,
0x97,0x88,0x1f,0xde,0x0,0x4a,0xd6,0x5,0x1c,0x0,0x3e,0x10,0x3f,0xba,0x1,0x94,
0x6c,0x3d,0xf0,0x80,0xf8,0xb1,0xd,0xa0,0x64,0xbd,0xc0,0x39,0x26,0x7f,0xc5,0xae,
0xb1,0x1,0x74,0x47,0x1f,0xa0,0x5,0x73,0x28,0xee,0xb3,0x1b,0xaf,0x41,0xe0,0x24,
0xc5,0x65,0x5b,0xd5,0xd4,0x62,0x8a,0x6b,0xee,0xed,0xba,0xf4,0x5a,0xc5,0x1f,0x8d,
0x62,0x25,0xcd,0x1e,0xbe,0x12,0x1,0x74,0x44,0x1f,0x60,0x14,0x9d,0xc0,0x43,0x8a,
0x8,0x9a,0x2e,0x74,0x83,0xce,0xc8,0x5f,0x3e,0x86,0x2d,0xe4,0x18,0x3f,0x5c,0x95,
0x3,0x50,0x9,0xaa,0x1a,0xc0,0x92,0xe8,0x3,0x64,0x51,0xd5,0x0,0xba,0xa2,0xf,
0x90,0x45,0x55,0x3,0x50,0x49,0xc,0x20,0x39,0x3,0x48,0xce,0x0,0x92,0x33,0x80,
0xe4,0xc,0x20,0x39,0x3,0x48,0xce,0x0,0x92,0x33,0x80,0xe4,0xc,0x20,0x39,0x3,
0x48,0xce,0x0,0x92,0x33,0x80,0xe4,0xc,0x20,0x39,0x3,0x48,0xce,0x0,0x92,0x33,
0x80,0xe4,0xc,0x20,0x39,0x3,0x48,0xce,0x0,0x92,0x33,0x80,0xe4,0xaa,0x1a,0xc0,
0x8f,0xe8,0x3,0x64,0x51,0xd5,0x0,0x86,0xa3,0xf,0x90,0x45,0x55,0x3,0xb8,0x11,
0x7d,0x80,0x2c,0xaa,0xfa,0x70,0x68,0x7,0x70,0x1f,0x58,0x1d,0x7d,0x90,0x12,0xf8,
0x70,0xe8,0x3f,0xfc,0xa2,0xf8,0x8e,0xde,0xb7,0xd1,0x7,0x51,0xac,0x7e,0xe0,0x2c,
0xf0,0x86,0xf8,0xe7,0xf8,0xfd,0x7e,0x80,0x60,0xb3,0x68,0xfd,0x2b,0x62,0x86,0x80,
0xbe,0xa9,0x39,0x4e,0xdb,0xd4,0x69,0x83,0xda,0x99,0x7,0x9c,0xa1,0xf8,0xb7,0x32,
0xfa,0x2f,0xbd,0x92,0x9f,0x0,0x59,0xac,0x5,0xee,0x11,0x3f,0xb6,0x1,0x4,0xea,
0x4,0xf6,0x1,0xef,0x89,0x1f,0xdd,0x0,0x2,0xf5,0x1,0x17,0x88,0x1f,0xde,0x0,
0x82,0x6d,0x4,0x1e,0x63,0x0,0xa9,0x4d,0x3,0xe,0x1,0x9f,0x30,0x80,0xd4,0x16,
0x1,0x57,0x30,0x80,0xf4,0xb6,0x1,0xcf,0x31,0x80,0xd4,0x66,0x2,0xc7,0x80,0xaf,
0x18,0x40,0x6a,0xcb,0x80,0xeb,0x18,0x40,0x7a,0x3b,0x80,0x57,0x18,0x40,0x6a,0x73,
0x80,0x53,0xc0,0x37,0xc,0x20,0xb5,0x55,0xc0,0x1d,0xc,0x20,0xb5,0xe,0x60,0xf,
0xc5,0xbd,0xa,0x6,0x90,0x58,0x2f,0xc5,0xbd,0xa,0x93,0x7d,0x1d,0x8d,0x6a,0x6e,
0x1d,0xc5,0xed,0x6b,0x6,0x90,0x58,0x17,0xb0,0x9f,0x89,0xbd,0x92,0x4e,0xd,0xb2,
0x0,0xb8,0x88,0x1,0xa4,0xb7,0x9,0x78,0x82,0x1,0xa4,0x36,0x1d,0x38,0xcc,0xff,
0x5f,0x4c,0xad,0x86,0x1b,0x60,0xec,0x57,0xd3,0x2b,0x89,0x41,0xe0,0x5,0x6,0x90,
0x5a,0xf,0x70,0x1c,0x18,0xc1,0x0,0x52,0x5b,0xe,0xdc,0xc4,0x0,0xd2,0xdb,0x19,
0x7d,0x0,0x49,0x92,0x24,0x49,0x92,0x24,0x49,0x92,0x24,0x49,0x92,0x24,0x49,0x92,
0x24,0x35,0xc0,0x6f,0x75,0x9,0x94,0x7c,0x66,0x82,0xf0,0x6a,0x0,0x0,0x0,0x0,
0x49,0x45,0x4e,0x44,0xae,0x42,0x60,0x82,
// /home/cyrille/Documents/IHM/IHM_Lecteur_Audio/client_audio/resource/music_note.png
0x0,0x0,0x6,0x2,
0x89,
0x50,0x4e,0x47,0xd,0xa,0x1a,0xa,0x0,0x0,0x0,0xd,0x49,0x48,0x44,0x52,0x0,
0x0,0x0,0x80,0x0,0x0,0x0,0x80,0x8,0x6,0x0,0x0,0x0,0xc3,0x3e,0x61,0xcb,
0x0,0x0,0x0,0x4,0x73,0x42,0x49,0x54,0x8,0x8,0x8,0x8,0x7c,0x8,0x64,0x88,
0x0,0x0,0x0,0x9,0x70,0x48,0x59,0x73,0x0,0x0,0xb,0x13,0x0,0x0,0xb,0x13,
0x1,0x0,0x9a,0x9c,0x18,0x0,0x0,0x5,0xa4,0x49,0x44,0x41,0x54,0x78,0x9c,0xed,
0xdd,0x5d,0x88,0x15,0x75,0x18,0xc7,0xf1,0xef,0xba,0xbe,0x60,0x6a,0x65,0xf4,0xb6,
0x9,0x56,0xa4,0x6e,0x1a,0x88,0xb4,0x15,0xbd,0xbf,0xda,0x8b,0x2b,0x95,0x50,0xdd,
0x84,0x44,0x91,0xd1,0x95,0x8b,0x50,0xd8,0x5d,0xd1,0x85,0xd1,0x45,0x65,0xe1,0x45,
0x44,0x2f,0x90,0x5d,0x58,0x51,0x77,0xb1,0x6a,0x1a,0xb9,0x62,0x62,0xef,0x11,0x99,
0x5,0x96,0xb5,0x99,0x51,0x69,0xeb,0x92,0xdb,0x9a,0x5a,0xdb,0xc5,0xb3,0x35,0xed,
0x96,0xe7,0xcc,0x39,0x67,0xfe,0xff,0xe7,0xcc,0xcc,0xef,0x3,0xe7,0x42,0x58,0x67,
0x9e,0xb3,0xcf,0x6f,0x76,0x5e,0xfe,0x33,0xff,0x1,0x11,0x11,0x11,0x11,0x11,0x11,
0x11,0x11,0x11,0x11,0x11,0x11,0x11,0x11,0x11,0x11,0x89,0x65,0x32,0xb0,0x8,0x78,
0x6,0xf8,0xdc,0xb9,0x16,0x89,0x64,0xe,0x70,0x1f,0xf0,0x16,0xf0,0x3b,0x30,0x34,
0xfc,0x39,0xe0,0x59,0x94,0x84,0x73,0xc,0x70,0x23,0xf0,0x34,0xf0,0xd,0x49,0xc3,
0x47,0x7f,0x14,0x80,0x2,0x69,0x7,0x96,0x1,0x6f,0x2,0x7,0x39,0x7a,0xd3,0x15,
0x80,0x82,0x98,0x8,0x74,0x2,0xab,0x80,0x9d,0xa4,0x6b,0xb8,0x2,0x90,0x73,0x67,
0x1,0x4b,0x81,0xb5,0xc0,0x20,0xf5,0x35,0x3d,0x4a,0x0,0xc6,0x86,0x5a,0x70,0xc9,
0x4c,0x0,0xae,0xc4,0xb6,0xf4,0x5,0xc0,0x4c,0xd7,0x6a,0x6a,0xa0,0x0,0xd4,0xef,
0xc,0xac,0xe1,0x9d,0xc0,0x55,0xd8,0x1,0x5d,0xee,0x28,0x0,0xe9,0x8d,0x7,0x2e,
0x27,0xd9,0xca,0xcf,0xf6,0x2d,0x27,0x1b,0xa,0x40,0x65,0xd3,0xb1,0x66,0x77,0x2,
0x57,0x63,0x17,0x67,0xa,0x45,0x1,0x18,0x69,0x1c,0x70,0x29,0x49,0xd3,0xcf,0xf1,
0x2d,0x27,0x3c,0x5,0x0,0xa6,0x91,0x34,0x7c,0x3e,0x30,0xc5,0xb7,0x9c,0xb8,0xca,
0x18,0x80,0xb1,0xc0,0xc5,0x24,0xfb,0xf2,0xb9,0xbe,0xe5,0xf8,0x2a,0x4b,0x0,0x4e,
0x25,0xd9,0xca,0xaf,0x5,0x8e,0xf3,0x2d,0xa7,0x79,0x14,0x35,0x0,0xad,0xc0,0x85,
0x24,0x4d,0x9f,0x7,0xb4,0xb8,0x56,0xd4,0xa4,0x8a,0x14,0x80,0x93,0x81,0x1b,0xb0,
0x86,0x5f,0x7,0x4c,0xf5,0x2d,0x27,0x1f,0xf2,0x1e,0x80,0x76,0xe0,0x76,0xac,0xe9,
0x1d,0x68,0x2b,0x2f,0x9d,0xc7,0x68,0xfc,0x3a,0x7b,0x1e,0x3e,0xc1,0xc6,0x2,0xc6,
0x84,0x5a,0xb0,0xe4,0x83,0x2,0x50,0x72,0xa,0x40,0xc9,0x29,0x0,0x25,0xa7,0x0,
0xf8,0xf9,0x13,0x78,0x17,0x78,0x8,0x1b,0x4e,0x76,0x91,0xf7,0xd3,0xc0,0xbc,0xd9,
0xb,0xac,0xc7,0xee,0x14,0x5a,0x3f,0xfc,0x6f,0x70,0x1c,0x65,0x54,0x0,0xc2,0x1a,
0x2,0x3e,0x4,0xba,0xb1,0xa6,0xbf,0x87,0x6d,0xf9,0x4d,0x43,0x1,0xc8,0x5e,0x1f,
0x76,0xc7,0x6f,0x37,0xb0,0xe,0xf8,0xc9,0xb7,0x9c,0xca,0x14,0x80,0xc6,0xd,0x1,
0x9f,0x90,0x6c,0xe5,0xdb,0x80,0x3f,0x5c,0x2b,0xaa,0x81,0x2,0x50,0x9f,0x7e,0x60,
0x3,0xc9,0x56,0xfe,0x83,0x6f,0x39,0xf5,0x53,0x0,0xd2,0xfb,0x14,0xdb,0xc2,0xbb,
0x81,0xad,0xc0,0x11,0xdf,0x72,0xb2,0xa1,0x0,0x1c,0xdd,0xaf,0xc0,0x46,0xac,0xe9,
0x6b,0x81,0xdd,0xbe,0xe5,0x84,0xa1,0x0,0x8c,0xb4,0x9d,0x64,0x2b,0xdf,0x2,0x1c,
0xf6,0x2d,0x27,0xbc,0xb2,0x7,0x60,0x0,0x7b,0x12,0xf7,0xef,0xa6,0xf7,0xfa,0x96,
0x13,0x5f,0x19,0x3,0xf0,0x25,0xc9,0x11,0xfb,0x66,0xec,0x31,0xec,0xd2,0x2a,0x43,
0x0,0x6,0x81,0xb7,0xb1,0xa6,0x77,0x3,0xbb,0x7c,0xcb,0x69,0x2e,0x45,0xf,0xc0,
0x2a,0x60,0x39,0xf6,0x18,0xb6,0xfc,0x8f,0xa2,0xf,0x6,0xf5,0xa2,0xe6,0x57,0x54,
0xf4,0x0,0x48,0x15,0xa,0x40,0xc9,0x29,0x0,0x25,0xa7,0x0,0x94,0x9c,0x2,0x50,
0x72,0xa,0x40,0xc9,0x29,0x0,0x25,0xa7,0x0,0x94,0x9c,0x2,0x50,0x72,0xa,0x40,
0xc9,0x29,0x0,0x25,0xa7,0x0,0x94,0x5c,0xd1,0x47,0x3,0x3d,0x9c,0x8e,0x4d,0x29,
0x77,0x2e,0x30,0x3,0x38,0x1e,0x9b,0x49,0x74,0x0,0xf8,0x1e,0xbb,0xeb,0x68,0xb,
0x4d,0x72,0xc7,0x91,0x2,0x90,0x8d,0xf1,0xc0,0x62,0xe0,0x5e,0xe0,0x82,0x94,0xff,
0xa7,0xf,0x58,0x3,0x3c,0x5,0xec,0x9,0x54,0x57,0xe1,0x55,0x9b,0x20,0xe2,0xfe,
0x8,0x35,0xdc,0x6,0x7c,0x5b,0xa5,0x8e,0x4a,0x9f,0x23,0xc0,0x4b,0x55,0x7e,0x46,
0x93,0x45,0x37,0xa1,0x63,0x81,0xe7,0xb0,0x0,0x34,0xa2,0x15,0xfb,0xeb,0xe1,0x42,
0x1,0xa8,0xcf,0x34,0xec,0xe1,0xce,0xdc,0xcf,0x24,0xaa,0x0,0xd4,0xee,0x14,0xa0,
0x7,0x7b,0x27,0x40,0xee,0xe9,0x34,0xb0,0x36,0x13,0x80,0x37,0x28,0x48,0xf3,0x41,
0x1,0xa8,0xd5,0xa3,0xc0,0x79,0xde,0x45,0x64,0x49,0x1,0x48,0xaf,0x3,0xe8,0xf2,
0x2e,0x22,0x6b,0xa,0x40,0x7a,0x8f,0x50,0xc0,0xdf,0x57,0xe1,0xbe,0x50,0x20,0x73,
0xb1,0xe9,0x67,0xb,0x47,0x1,0x48,0xe7,0x4e,0xef,0x2,0x42,0x51,0x0,0xd2,0xb9,
0xc9,0xbb,0x80,0x50,0x14,0x80,0xea,0x4e,0xa3,0x40,0xa7,0x7d,0xa3,0x35,0xdb,0x85,
0xa0,0x93,0x80,0xd9,0xd8,0x2f,0x7d,0x32,0x76,0x1d,0x7c,0x1f,0xf0,0x15,0xb0,0x3,
0x9f,0x59,0x39,0x72,0x7f,0xb5,0xaf,0x92,0x66,0x8,0xc0,0x3c,0xe0,0xe,0x60,0x21,
0x30,0xab,0xc2,0xcf,0xd,0x0,0x9b,0x80,0x57,0x80,0xd7,0xb0,0xa7,0x7e,0x63,0x98,
0x1e,0x69,0x3d,0x2e,0x3c,0x3,0x70,0x11,0xb0,0x82,0xf4,0xb3,0x64,0x4e,0xc2,0x42,
0xb2,0x10,0x78,0x62,0xf8,0x33,0x31,0x4c,0x69,0x23,0x14,0xee,0x55,0x71,0xff,0xe6,
0x11,0x80,0x49,0xc0,0x4a,0x60,0x9,0xf5,0xbf,0xe0,0xe1,0x44,0xec,0xbc,0x3c,0x86,
0xa6,0x9a,0xd8,0x31,0x6b,0xb1,0x3,0x70,0x26,0x76,0x2d,0x7d,0x4e,0xe4,0xf5,0x36,
0x62,0xbf,0x77,0x1,0xd8,0x71,0x50,0x10,0x31,0x3,0xd0,0x8e,0xcd,0xd4,0xd1,0x16,
0x71,0x9d,0x59,0xf8,0xda,0xbb,0x0,0xe0,0xb3,0x50,0xb,0x8e,0x75,0x1a,0xd8,0x86,
0x4d,0x9f,0x9a,0xb7,0xe6,0x83,0xfd,0xf2,0xbd,0x77,0x3,0x1f,0x87,0x5a,0x70,0x8c,
0x0,0xb4,0x2,0x2f,0x93,0xdf,0xa3,0xe9,0x7e,0xe0,0x23,0xe7,0x1a,0x7a,0x42,0x2d,
0x38,0x46,0x0,0xba,0xb0,0xb7,0x6e,0xe7,0xd9,0xeb,0x8e,0xeb,0xde,0x87,0xed,0x3a,
0x83,0x8,0x1d,0x80,0x13,0x80,0x87,0x3,0xaf,0x23,0x86,0xd5,0xc0,0x21,0xa7,0x75,
0xbf,0x48,0xc0,0xb,0x60,0xa1,0x3,0xd0,0x45,0x31,0x5e,0xc6,0xbc,0x7,0xb,0x41,
0x6c,0x7,0x81,0x27,0x1d,0xd6,0x9b,0x89,0x31,0xd8,0x83,0x10,0x9e,0xef,0xdb,0xcb,
0xf2,0xb6,0xf0,0x36,0xec,0x78,0x20,0x66,0xfd,0x2b,0x32,0xac,0x3f,0xba,0x2b,0xf0,
0x7f,0xe1,0x62,0xd6,0xcf,0x5,0xdc,0x13,0xb1,0xf6,0xed,0xd8,0x3d,0x88,0x41,0x85,
0xdc,0x5,0x5c,0x13,0x70,0xd9,0x5e,0x9e,0x25,0xce,0xae,0xa0,0x1f,0xb8,0x85,0x8,
0xd3,0xd8,0x86,0xc,0x40,0x47,0xc0,0x65,0x7b,0x5a,0x82,0xcd,0x33,0x1c,0xca,0x6f,
0xc0,0x22,0xe0,0x8b,0x80,0xeb,0xf8,0x47,0xc8,0x0,0xcc,0x8,0xb8,0x6c,0x4f,0x87,
0xb1,0x6,0xad,0x9,0xb0,0xec,0xbd,0xc0,0xf5,0xd8,0xa8,0x67,0xee,0xfd,0x4c,0xf1,
0x8e,0x1,0x46,0x5b,0x8a,0x6d,0xb1,0x59,0xd4,0xda,0x83,0x3d,0x59,0x5c,0x18,0xfb,
0xf1,0xf,0xc0,0xb2,0xe0,0xdf,0xd2,0x6,0xb8,0x5e,0xc5,0x2e,0x17,0xd7,0x53,0xe3,
0x6e,0xe0,0x2e,0xa,0x78,0x77,0x96,0xf7,0x29,0xe0,0x10,0x70,0x77,0xf0,0x6f,0x99,
0x98,0xd,0x3c,0xe,0x7c,0x97,0xa2,0xae,0x43,0xd8,0xb3,0x85,0x8b,0x81,0x71,0x11,
0x6b,0xfc,0x8f,0x7a,0xc7,0xe3,0xd3,0x78,0x1f,0xff,0xa7,0x68,0x16,0x60,0x6f,0xf5,
0x8a,0x6d,0x16,0xc9,0x4,0x11,0x53,0xb1,0xf9,0x3,0xe,0x60,0x5b,0xfb,0xe,0xec,
0x95,0xb1,0x3,0xe,0x75,0x45,0xb5,0x1a,0xff,0xbf,0x0,0x79,0x1d,0x80,0x8a,0x26,
0xe4,0x7e,0xe7,0x9d,0x80,0xcb,0x4e,0xa3,0x97,0x12,0xbe,0x3,0xa8,0x56,0x21,0x3,
0xb0,0xe,0xdb,0xa,0xbd,0x84,0x3c,0x57,0x97,0x94,0x36,0xe1,0xf7,0xe7,0xff,0x92,
0xf0,0x5f,0x4f,0xaa,0xb9,0x19,0x9f,0xe6,0x6f,0x8b,0xf1,0xe5,0xa4,0xba,0x16,0xec,
0x88,0x37,0x76,0x0,0xe6,0xc7,0xf8,0x72,0x92,0x4e,0x7,0x76,0xf9,0x34,0x56,0xf3,
0x43,0x5c,0xa2,0x95,0x6,0x2d,0x27,0x4e,0xf3,0x77,0x61,0x13,0x33,0x4a,0x13,0x7a,
0x9e,0xb0,0xcd,0xff,0x85,0x7c,0x3d,0x6f,0x50,0x3a,0xad,0xc0,0xb,0x84,0x69,0xfe,
0x8f,0x14,0x77,0xf8,0xb9,0x70,0x1e,0x20,0xdb,0x63,0x82,0xf,0xb0,0x1,0x19,0xc9,
0x91,0xf3,0xb1,0xc6,0x35,0xd2,0xf8,0x41,0xe0,0x41,0xec,0x3a,0xbb,0xe4,0x50,0xb,
0x70,0x2b,0xb0,0x95,0xda,0xf7,0xf5,0x2b,0xb1,0xd9,0x3a,0xa5,0x41,0x21,0x47,0x3,
0x6b,0x31,0x13,0x1b,0xb9,0xbb,0x8c,0x64,0x82,0x88,0x29,0xd8,0xb0,0x69,0x1f,0xb0,
0x13,0x7b,0x3c,0x6a,0x23,0xb0,0x1,0xbf,0x7b,0xf4,0x45,0x44,0x44,0x44,0x44,0x44,
0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x9a,0xde,0x5f,0xf0,0xc4,0x4e,
0x4f,0xc6,0xf8,0x19,0x2f,0x0,0x0,0x0,0x0,0x49,0x45,0x4e,0x44,0xae,0x42,0x60,
0x82,
// /home/cyrille/Documents/IHM/IHM_Lecteur_Audio/client_audio/resource/pause_2.png
0x0,0x0,0x3,0x40,
0x89,
0x50,0x4e,0x47,0xd,0xa,0x1a,0xa,0x0,0x0,0x0,0xd,0x49,0x48,0x44,0x52,0x0,
0x0,0x0,0x80,0x0,0x0,0x0,0x80,0x8,0x6,0x0,0x0,0x0,0xc3,0x3e,0x61,0xcb,
0x0,0x0,0x0,0x4,0x73,0x42,0x49,0x54,0x8,0x8,0x8,0x8,0x7c,0x8,0x64,0x88,
0x0,0x0,0x0,0x9,0x70,0x48,0x59,0x73,0x0,0x0,0xb,0x13,0x0,0x0,0xb,0x13,
0x1,0x0,0x9a,0x9c,0x18,0x0,0x0,0x2,0xe2,0x49,0x44,0x41,0x54,0x78,0x9c,0xed,
0xdd,0x3b,0x6b,0x14,0x51,0x18,0xc6,0xf1,0xbf,0x97,0xd2,0xbb,0x82,0x28,0x69,0x95,
0x90,0xca,0xf,0x20,0x44,0x63,0x61,0x61,0x21,0x8,0x29,0xac,0x15,0xb4,0x15,0xc,
0x22,0x36,0x5a,0x4,0xb,0x3f,0x80,0x85,0xbd,0x22,0x41,0x45,0xad,0x55,0x44,0x6c,
0x44,0xc,0xf1,0x82,0x96,0x92,0x4e,0x25,0xa8,0x28,0x78,0x21,0xc9,0x5a,0x4c,0x4,
0x5,0x61,0xb3,0x99,0x77,0x76,0x8f,0xf3,0xfe,0x7f,0x70,0xca,0x7d,0x79,0x38,0xfb,
0xcc,0xd9,0x9d,0x69,0x6,0x24,0x49,0x92,0x24,0x49,0x92,0x24,0x49,0x92,0x24,0x49,
0x92,0x24,0x49,0x92,0x24,0x49,0x92,0x24,0x49,0x92,0x24,0x49,0x92,0x56,0x6e,0x18,
0x98,0x4,0x1e,0x3,0x73,0xc0,0x3c,0xf0,0x15,0x78,0x9,0x5c,0x1,0xe,0x2,0xab,
0xfa,0x9c,0x69,0x23,0x70,0x12,0xb8,0x3,0xcc,0x2,0x3f,0x97,0xd6,0x2c,0x70,0x1b,
0x38,0x1,0x6c,0xe8,0x73,0xa6,0xd6,0x19,0x2,0xa6,0x80,0x45,0xa0,0xd3,0x65,0xbd,
0x0,0xf6,0xf5,0x21,0xd3,0x5a,0xe0,0x2c,0xf0,0x79,0x19,0x99,0x3e,0x1,0x13,0xc0,
0x9a,0x3e,0xe4,0x6a,0x9d,0x31,0xaa,0xab,0xbd,0xdb,0x26,0xff,0xb9,0x16,0x81,0xf3,
0xd,0x66,0xda,0x46,0x75,0xa,0xf5,0x92,0xa9,0x3,0x3c,0x4,0xb6,0x34,0x98,0xab,
0x75,0xc6,0x80,0xef,0xf4,0xbe,0xd1,0xbf,0xd7,0xa5,0x6,0x32,0x6d,0xa6,0x3a,0x65,
0x56,0x9a,0x69,0x86,0xea,0x67,0x43,0x5d,0xc,0xd1,0xfb,0x95,0xff,0xaf,0x75,0x34,
0x38,0xd7,0xdd,0x80,0x4c,0x37,0x82,0x33,0xb5,0xd2,0x14,0xf5,0x37,0xba,0x3,0x7c,
0x20,0xee,0x8a,0x1b,0xf,0xca,0xd4,0x1,0xe,0x7,0x65,0x6a,0xa5,0x61,0x96,0xf7,
0x87,0x6f,0xb9,0xeb,0x4c,0x50,0xae,0x99,0xc0,0x4c,0x4f,0x83,0x32,0xb5,0xd2,0x24,
0x71,0x1b,0xdd,0x1,0x5e,0x5,0x64,0xda,0x13,0x9c,0xa9,0x3,0x8c,0x4,0xe4,0xa,
0xb7,0x7a,0xd0,0x1,0x88,0xbf,0x8d,0x1b,0x1,0xb6,0xd7,0x9c,0xb1,0x3f,0x22,0x48,
0x1f,0x66,0xd6,0x56,0x42,0x1,0x86,0xb,0x9c,0x59,0x62,0xa6,0x46,0x94,0x50,0x80,
0x4d,0xd,0xcc,0xac,0x7b,0xff,0x5d,0x62,0xa6,0x46,0x94,0x50,0x80,0x26,0x32,0xd4,
0x7d,0xa,0xd7,0xc4,0x53,0xbc,0x22,0x9f,0xc,0x96,0x50,0x0,0xd,0x90,0x5,0x48,
0xce,0x2,0x24,0x67,0x1,0x92,0xb3,0x0,0xc9,0x59,0x80,0xe4,0x2c,0x40,0x72,0x16,
0x20,0x39,0xb,0x90,0x9c,0x5,0x48,0xce,0x2,0x24,0x67,0x1,0x92,0xb3,0x0,0xc9,
0x59,0x80,0xe4,0x2c,0x40,0x72,0x16,0x20,0x39,0xb,0x90,0x9c,0x5,0x48,0xce,0x2,
0x24,0x67,0x1,0x92,0xb3,0x0,0xc9,0x59,0x80,0xe4,0x2c,0x40,0x72,0x16,0x20,0x39,
0xb,0x90,0x9c,0x5,0x48,0xce,0x2,0x24,0x67,0x1,0x92,0xb3,0x0,0xc9,0x59,0x80,
0xe4,0x2c,0x40,0x72,0x16,0x20,0x39,0xb,0x90,0x9c,0x5,0x48,0xce,0x2,0x24,0x67,
0x1,0x92,0xb3,0x0,0xc9,0x59,0x80,0xe4,0x2c,0x40,0x72,0x16,0x20,0x39,0xb,0x90,
0x5c,0x9,0x5,0x58,0x6c,0x60,0xe6,0x7c,0xcd,0xcf,0x2f,0x84,0xa4,0xf8,0x5b,0xdd,
0x4c,0x8d,0x28,0xa1,0x0,0x1f,0xb,0x9c,0x59,0x62,0xa6,0x46,0x94,0x50,0x80,0x37,
0xd,0xcc,0x7c,0x5d,0xf3,0xf3,0x25,0x66,0x6a,0x44,0x9,0x5,0x78,0x10,0x3c,0xef,
0x25,0xf0,0xbe,0xe6,0x8c,0xfb,0x11,0x41,0xfa,0x30,0xb3,0x15,0x76,0x13,0xfb,0xca,
0x98,0x89,0xa0,0x5c,0xd3,0x81,0x99,0x9e,0x4,0x65,0x6a,0xad,0x6b,0xc4,0x6c,0xf4,
0x3b,0x60,0x7d,0x50,0xa6,0x23,0x41,0x99,0x3a,0xc0,0xa1,0xa0,0x4c,0xad,0xb5,0x93,
0xea,0x8d,0x5f,0x75,0x37,0x7a,0x3c,0x38,0xd7,0xad,0x80,0x4c,0xd7,0x83,0x33,0xb5,
0xd6,0x28,0xf0,0x8d,0x95,0x6f,0xf4,0xc5,0x6,0x32,0x6d,0xa4,0xde,0xdb,0xc3,0x9e,
0x11,0x77,0x22,0xa5,0x30,0x4a,0xef,0x27,0xc1,0x2,0x70,0xae,0xc1,0x4c,0x5b,0xa9,
0x5e,0x3,0xdb,0xeb,0x97,0x7f,0x8f,0xea,0xcd,0xa3,0xea,0xd1,0xe,0xe0,0x2a,0xd5,
0x17,0xdb,0x6d,0x93,0xa7,0x81,0xbd,0x7d,0xc8,0xb4,0x6,0x38,0x4d,0x75,0x2f,0xdf,
0x2d,0xd3,0x1c,0x70,0x8a,0x32,0xee,0xb0,0xfe,0x6b,0xbb,0x80,0xb,0xc0,0x23,0xaa,
0x53,0x61,0x1e,0xf8,0x2,0x3c,0x7,0x2e,0x3,0x7,0x6,0x90,0x69,0x3d,0x70,0x9c,
0xea,0xbf,0xc1,0x5b,0xe0,0xc7,0xd2,0x7a,0xb,0xdc,0x4,0x8e,0x1,0xeb,0x6,0x90,
0x4b,0x92,0x24,0x49,0x92,0x24,0x49,0x92,0x24,0x49,0x92,0x24,0x49,0x92,0x24,0x49,
0x92,0x24,0x49,0x92,0x24,0x49,0x92,0x24,0xb5,0xd8,0x2f,0xb2,0x61,0xcf,0xca,0xcc,
0xf5,0x9,0x94,0x0,0x0,0x0,0x0,0x49,0x45,0x4e,0x44,0xae,0x42,0x60,0x82,
// /home/cyrille/Documents/IHM/IHM_Lecteur_Audio/client_audio/resource/next_2.png
0x0,0x0,0x3,0x71,
0x89,
0x50,0x4e,0x47,0xd,0xa,0x1a,0xa,0x0,0x0,0x0,0xd,0x49,0x48,0x44,0x52,0x0,
0x0,0x0,0x80,0x0,0x0,0x0,0x80,0x8,0x6,0x0,0x0,0x0,0xc3,0x3e,0x61,0xcb,
0x0,0x0,0x0,0x4,0x73,0x42,0x49,0x54,0x8,0x8,0x8,0x8,0x7c,0x8,0x64,0x88,
0x0,0x0,0x0,0x9,0x70,0x48,0x59,0x73,0x0,0x0,0xb,0x13,0x0,0x0,0xb,0x13,
0x1,0x0,0x9a,0x9c,0x18,0x0,0x0,0x3,0x13,0x49,0x44,0x41,0x54,0x78,0x9c,0xed,
0xdd,0xbf,0x6a,0x14,0x61,0x14,0x86,0xf1,0x27,0x6a,0x63,0x2,0x22,0x16,0x56,0x69,
0xbc,0x7,0x1b,0x41,0x54,0xd0,0xce,0xda,0x26,0x8d,0xb1,0xb2,0xf4,0x6,0x6c,0xd4,
0x42,0xbc,0x0,0x1b,0x41,0xd0,0x4,0xf1,0x1a,0xec,0xed,0x15,0xc1,0x1b,0xf0,0x6,
0x44,0x11,0x2d,0x54,0x62,0xb1,0x89,0xe6,0xcf,0xec,0xce,0xcc,0x37,0x6b,0xbe,0x99,
0x73,0x9e,0x1f,0x84,0x14,0xd9,0xc0,0x21,0xef,0xb3,0x43,0x48,0x13,0x90,0x24,0x49,
0x92,0x24,0x49,0x92,0x24,0x49,0x92,0x24,0x49,0x92,0x14,0xc7,0x4a,0xed,0x3,0x82,
0xb9,0x9,0x3c,0x2,0xce,0x34,0x7c,0xed,0x17,0xb0,0x5,0x3c,0x6,0x76,0x8e,0xf3,
0x28,0x1d,0x8f,0x55,0xe0,0x1b,0xb3,0x71,0x17,0x7d,0x5c,0xad,0x75,0x60,0x93,0x13,
0xb5,0xf,0x58,0xe0,0x12,0xf0,0x2,0xf8,0x0,0x7c,0x4,0x5e,0x3,0xd7,0x6b,0x1e,
0xd4,0xe2,0x1c,0xb0,0xd6,0xe1,0x75,0x17,0xfe,0xf7,0x21,0x53,0xb7,0x2,0x3c,0x61,
0xfe,0x3b,0xe8,0x19,0x70,0xaa,0xda,0x75,0xf3,0xad,0xd3,0xfe,0xee,0xdf,0x1,0x36,
0x2b,0xdd,0x37,0x19,0xf7,0x68,0xff,0x21,0xbe,0x62,0x7c,0x11,0x18,0xc0,0x12,0xac,
0x1,0x5f,0xe8,0xf6,0x83,0x1c,0x5b,0x4,0x93,0xc,0x60,0x6c,0xbf,0x3,0x5c,0xa3,
0xf9,0x37,0xe8,0x26,0x1b,0xc0,0x4b,0xc6,0x15,0xc1,0xe4,0x8c,0x2d,0x80,0xf5,0x9e,
0xaf,0x37,0x82,0x81,0xc6,0x16,0x40,0xc9,0xdf,0x25,0x8c,0x60,0x80,0xb1,0x5,0x50,
0xca,0x8,0xa,0x45,0x9,0x0,0x8c,0xa0,0x48,0xa4,0x0,0xc0,0x8,0x7a,0x8b,0x16,
0x0,0x18,0x41,0x2f,0x11,0x3,0x0,0x23,0xe8,0x2c,0x6a,0x0,0x60,0x4,0x9d,0x44,
0xe,0x0,0x8c,0xa0,0x55,0xf4,0x0,0xc0,0x8,0x16,0xca,0x10,0x0,0x18,0xc1,0x5c,
0x59,0x2,0x0,0x23,0x68,0x94,0x29,0x0,0x30,0x82,0x23,0xb2,0x5,0x0,0x46,0x70,
0x40,0xc6,0x0,0xc0,0x8,0xfe,0xca,0x1a,0x0,0x18,0x1,0x90,0x3b,0x0,0x30,0x82,
0xf4,0x1,0x40,0xf2,0x8,0xc,0x60,0x26,0x6d,0x4,0x6,0xf0,0x4f,0xca,0x8,0xc,
0xe0,0xa0,0x74,0x11,0x18,0xc0,0x51,0xa9,0x22,0x30,0x80,0x66,0x69,0x22,0x30,0x80,
0xf9,0x52,0x44,0x60,0x0,0x8b,0x85,0x8f,0xc0,0x0,0xda,0x85,0x8e,0xc0,0x0,0xba,
0x9,0x1b,0x81,0x1,0x74,0x17,0x32,0x2,0x3,0xe8,0x27,0x5c,0x4,0x6,0xd0,0x5f,
0xa8,0x8,0xc,0xa0,0x4c,0x98,0x8,0xc,0xa0,0x5c,0x88,0x8,0x26,0x7d,0xfc,0x8,
0x6c,0xec,0x7e,0xbe,0x5d,0xf5,0x8a,0x1,0x7c,0x2,0xc,0x37,0xe9,0x27,0xc1,0x24,
0x8f,0x1e,0xa1,0xd,0xe0,0x7c,0xed,0x23,0x4a,0xf8,0x4,0x58,0x9e,0x1b,0xb5,0xf,
0x28,0x61,0x0,0xc9,0x19,0x40,0x72,0x6,0x90,0x9c,0x1,0x24,0x67,0x0,0xc9,0x19,
0x40,0x72,0x6,0x90,0x9c,0x1,0x2c,0xcf,0x9b,0xda,0x7,0x94,0x30,0x80,0xe5,0xd8,
0x6,0xee,0xd6,0x3e,0xa2,0x84,0x1,0xc,0xb7,0xd,0xdc,0x1,0x7e,0xd7,0x3e,0xa4,
0x84,0x1,0xc,0x33,0xe9,0xf1,0xc1,0x0,0x86,0x98,0xfc,0xf8,0x60,0x0,0xa5,0x42,
0x8c,0xf,0x6,0x50,0x22,0xcc,0xf8,0x60,0x0,0x7d,0x85,0x1a,0x1f,0xc,0xa0,0x8f,
0x70,0xe3,0x83,0x1,0x74,0x15,0x72,0x7c,0x30,0x80,0x2e,0xc2,0x8e,0xf,0x6,0xd0,
0x26,0xf4,0xf8,0x60,0x0,0x8b,0x84,0x1f,0x1f,0xc,0x60,0x9e,0x14,0xe3,0x83,0x1,
0x34,0x49,0x33,0x3e,0x18,0xc0,0x61,0xa9,0xc6,0x7,0x3,0xd8,0x2f,0xdd,0xf8,0x60,
0x0,0x7b,0x52,0x8e,0xf,0x6,0x0,0x89,0xc7,0x7,0x3,0x48,0x3d,0x3e,0xe4,0xe,
0x20,0xfd,0xf8,0x90,0x37,0x0,0xc7,0xdf,0x95,0x31,0x0,0xc7,0xdf,0x27,0x5b,0x0,
0x8e,0x7f,0x48,0xa6,0x0,0x1c,0xbf,0x41,0x96,0x0,0x1c,0x7f,0x8e,0xc,0x1,0x38,
0xfe,0x2,0xd1,0x3,0x70,0xfc,0x16,0x91,0x3,0x70,0xfc,0xe,0xa2,0x6,0xe0,0xf8,
0x1d,0x45,0xc,0xc0,0xf1,0x7b,0x88,0x16,0x80,0xe3,0xf7,0x14,0x29,0x0,0xc7,0x2f,
0x10,0x25,0x0,0xc7,0x2f,0x34,0xb6,0x0,0x76,0xa,0xbe,0xc7,0xf1,0x7,0x18,0x5b,
0x0,0x9f,0x7a,0xbe,0xde,0xf1,0x83,0x59,0x5,0x3e,0x33,0x7b,0x12,0xb4,0x7d,0x6c,
0x1,0x27,0xeb,0x9c,0xd9,0x68,0x9d,0x6e,0x77,0x6f,0x56,0xba,0xaf,0xd1,0xd8,0x9e,
0x0,0xdf,0x81,0xfb,0x1d,0x5e,0xe7,0x3b,0x3f,0xb0,0x15,0xe0,0x21,0xf3,0xdf,0x41,
0x4f,0x19,0xd7,0x3b,0x7f,0xcf,0x24,0x9f,0x0,0x63,0x76,0x11,0x78,0xe,0xbc,0x3,
0xde,0x33,0x7b,0xe4,0x5f,0xa9,0x7a,0xd1,0x62,0x6,0x90,0xdc,0x69,0xe0,0x2b,0xed,
0x1,0x5c,0xae,0x75,0x60,0x13,0xff,0x63,0xc8,0xf2,0xfc,0x0,0x6e,0x1,0xf,0x80,
0xb3,0xd,0x5f,0xff,0xc9,0xec,0x5f,0xcb,0xbc,0x3d,0xce,0xa3,0x24,0x49,0x92,0x24,
0x49,0x92,0x24,0x49,0x92,0x24,0x49,0x92,0x24,0x65,0xf2,0x7,0xbd,0xd2,0xf6,0x60,
0x36,0x64,0xd2,0x8a,0x0,0x0,0x0,0x0,0x49,0x45,0x4e,0x44,0xae,0x42,0x60,0x82,
// /home/cyrille/Documents/IHM/IHM_Lecteur_Audio/client_audio/resource/next.png
0x0,0x0,0x4,0x2a,
0x89,
0x50,0x4e,0x47,0xd,0xa,0x1a,0xa,0x0,0x0,0x0,0xd,0x49,0x48,0x44,0x52,0x0,
0x0,0x0,0x80,0x0,0x0,0x0,0x80,0x8,0x6,0x0,0x0,0x0,0xc3,0x3e,0x61,0xcb,
0x0,0x0,0x0,0x4,0x73,0x42,0x49,0x54,0x8,0x8,0x8,0x8,0x7c,0x8,0x64,0x88,
0x0,0x0,0x0,0x9,0x70,0x48,0x59,0x73,0x0,0x0,0xb,0x13,0x0,0x0,0xb,0x13,
0x1,0x0,0x9a,0x9c,0x18,0x0,0x0,0x3,0xcc,0x49,0x44,0x41,0x54,0x78,0x9c,0xed,
0xdd,0xbd,0x8b,0x5c,0x55,0x18,0x80,0xf1,0x67,0x63,0x1a,0xd9,0x48,0x24,0xb6,0x86,
0x55,0xb1,0xf0,0x1f,0x10,0x62,0x22,0x58,0x6a,0x1a,0x6d,0x4,0x5,0xf5,0xf,0x10,
0x6d,0xec,0x52,0x5,0x2c,0x53,0x68,0x9b,0x76,0xd2,0xa5,0x8c,0x85,0x18,0x3f,0x20,
0x21,0x28,0xa,0xb6,0xa,0x8a,0x12,0x45,0x41,0x48,0x69,0xc4,0x74,0x71,0x2d,0xee,
0x4e,0x32,0x2c,0xb3,0xb3,0xf7,0xee,0x9c,0x39,0xef,0xf9,0x78,0x7e,0x30,0xd5,0x5e,
0xf6,0xbc,0xf0,0x3e,0x7b,0x77,0x76,0x8b,0xb9,0x20,0x49,0x92,0x24,0x49,0x92,0x24,
0x49,0x92,0x24,0x49,0x92,0x24,0xa9,0x1d,0x5b,0xd1,0x3,0xe8,0x40,0x27,0x80,0xcb,
0xc0,0xb,0x7,0x7c,0xfd,0x77,0xe0,0x5d,0xe0,0x97,0x5c,0x3,0x29,0xaf,0xf,0x81,
0xdd,0x43,0x5e,0x5f,0xae,0x7b,0xc8,0xb1,0x75,0xbf,0xc1,0x82,0x6d,0xe0,0x3,0xe0,
0x6,0xf0,0x33,0xf0,0x35,0x70,0x11,0x38,0x95,0xf0,0x8c,0x94,0x8e,0x3,0xef,0x0,
0x9f,0x2,0x3f,0x1,0xdf,0x3,0x1f,0x3,0x4f,0x47,0xe,0xb5,0x60,0x67,0xc4,0x35,
0xa5,0xcc,0xca,0x73,0xc0,0x6d,0x96,0x57,0x7a,0x87,0x83,0x6f,0x63,0x51,0x9e,0x0,
0xbe,0x61,0xf9,0xbc,0xf7,0x80,0x37,0xe2,0x46,0x7b,0x60,0xc6,0xe1,0x77,0x80,0x5f,
0xa3,0x86,0x5b,0xf4,0x18,0xf0,0x1b,0xab,0x7,0xfd,0x7,0x38,0x1b,0x35,0xe0,0x3e,
0x5b,0xc0,0x57,0xac,0x9e,0xf7,0x3e,0xf0,0x76,0xd4,0x80,0x7b,0x66,0x54,0x12,0xc0,
0x5,0xe,0x1f,0xb4,0xa4,0x8,0xce,0x33,0x6e,0xde,0xe8,0x8,0x66,0x4b,0x66,0x4a,
0x1e,0x40,0x8a,0xf7,0x0,0xaf,0x8d,0xbc,0xee,0x4,0xf0,0x39,0xf1,0x11,0xbc,0x3a,
0xf2,0xba,0x63,0xc0,0x15,0xe2,0xef,0x4,0x1b,0x95,0x22,0x80,0x27,0x27,0x5c,0x5b,
0x42,0x4,0x53,0xe6,0x6d,0x3e,0x82,0x14,0x1,0x4c,0xfd,0x5f,0x42,0x74,0x4,0x53,
0xe7,0x6d,0x3a,0x82,0x94,0x7f,0x6,0x4e,0x11,0x1d,0xc1,0x54,0xcd,0x46,0x10,0x15,
0x0,0x18,0x41,0x11,0x22,0x3,0x0,0x23,0x8,0x17,0x1d,0x0,0x3c,0x8c,0xe0,0x5c,
0xf4,0x20,0x23,0x35,0x15,0x41,0x9,0x1,0xc0,0x10,0xc1,0x75,0x8c,0x20,0xbb,0x52,
0x2,0x0,0x23,0x8,0x51,0x52,0x0,0x60,0x4,0xd9,0x95,0x16,0x0,0x18,0x41,0x56,
0x25,0x6,0x0,0x46,0x90,0x4d,0xa9,0x1,0x80,0x11,0x64,0x51,0x72,0x0,0x60,0x4,
0x1b,0x57,0x7a,0x0,0x60,0x4,0x1b,0x55,0x43,0x0,0xf0,0x30,0x82,0x17,0xa3,0x7,
0x19,0xa9,0x9a,0x8,0x6a,0x9,0x0,0x86,0x8,0x3e,0xc3,0x8,0x92,0xaa,0x29,0x0,
0x30,0x82,0xe4,0x6a,0xb,0x0,0x8c,0x20,0xa9,0x1a,0x3,0x0,0x23,0x48,0xa6,0xd6,
0x0,0xc0,0x8,0x92,0xa8,0x39,0x0,0x30,0x82,0xb5,0xd5,0x1e,0x0,0x18,0xc1,0x5a,
0x5a,0x8,0x0,0xfc,0x3f,0xc1,0x5a,0x83,0xb4,0x62,0x1b,0x23,0x38,0xd2,0x10,0x2d,
0x31,0x82,0x23,0xc,0xd0,0x1a,0x23,0x98,0x78,0x78,0x8b,0x8c,0x60,0xc2,0xc1,0xad,
0x32,0x82,0x11,0x8e,0xe7,0x3c,0x2c,0xc0,0x3c,0x82,0x57,0x18,0x3e,0xb0,0xa2,0x74,
0xf3,0x8,0xb2,0x1e,0xd8,0xba,0x5a,0xef,0x4,0x2f,0xe5,0x3a,0xac,0x7,0x35,0x46,
0xf0,0x54,0x8e,0x83,0x5a,0xff,0x15,0xb0,0x68,0x1e,0xc1,0x9d,0xe8,0x41,0x4a,0xd2,
0xcb,0x1d,0x60,0x6e,0x1b,0x78,0x26,0x7a,0x88,0x92,0xf4,0x16,0x80,0xf6,0x31,0x80,
0xce,0x19,0x40,0xe7,0xc,0xa0,0x73,0x6,0xd0,0x39,0x3,0xe8,0x9c,0x1,0x74,0xce,
0x0,0x3a,0x67,0x0,0x9d,0x33,0x80,0xce,0x19,0x40,0xe7,0xc,0xa0,0x73,0x6,0xd0,
0xb9,0xde,0x2,0xb8,0x4b,0x21,0xf,0x59,0x28,0x45,0x4f,0x1,0xdc,0x5,0x5e,0x66,
0x78,0x9e,0x91,0xf6,0xf4,0x12,0xc0,0x7c,0xf9,0xdf,0x45,0xf,0x32,0xd2,0x7f,0xc,
0x8f,0xe1,0xd9,0xb8,0x1e,0x2,0xa8,0x71,0xf9,0x6f,0x1,0xb7,0x72,0x1c,0xd6,0x7a,
0x0,0xb5,0x2e,0xff,0x6a,0xae,0x3,0x5b,0xe,0xc0,0xe5,0x8f,0xd0,0x6a,0x0,0x2e,
0x7f,0xa4,0x16,0x3,0x70,0xf9,0x13,0xb4,0x16,0x80,0xcb,0x9f,0xa8,0xa5,0x0,0x5c,
0xfe,0x11,0xb4,0x12,0x80,0xcb,0x3f,0xa2,0x16,0x2,0x70,0xf9,0x6b,0xa8,0x3d,0x0,
0x97,0xbf,0xa6,0x9a,0x3,0x70,0xf9,0x9,0xd4,0x1a,0x80,0xcb,0x4f,0xa4,0xc6,0x0,
0x5c,0x7e,0x42,0xb5,0x5,0xe0,0xf2,0x13,0xab,0x29,0x0,0x97,0xbf,0x1,0xb5,0x4,
0xe0,0xf2,0x37,0xa4,0x86,0x0,0x5c,0xfe,0x6,0x95,0x1e,0x80,0xcb,0xdf,0xb0,0x92,
0x3,0x70,0xf9,0x19,0x94,0x1a,0x80,0xcb,0xcf,0xa4,0xc4,0x0,0x5c,0x7e,0x46,0xa5,
0x5,0xe0,0xf2,0x33,0x2b,0x29,0x0,0x97,0x1f,0xa0,0x94,0x0,0x5c,0x7e,0x90,0x12,
0x2,0x70,0xf9,0x81,0xa2,0x3,0x70,0xf9,0xc1,0x22,0x3,0x70,0xf9,0x5,0x88,0xa,
0xc0,0xe5,0x17,0x22,0x45,0x0,0xbb,0x13,0xaf,0x8f,0x5e,0xfe,0xd4,0x79,0x9b,0x5d,
0x3e,0xa4,0x9,0xe0,0x8f,0x9,0xd7,0x46,0x2f,0x1f,0xe0,0xcf,0x9,0xd7,0x36,0xbd,
0x7c,0x48,0x13,0xc0,0xb5,0x91,0xd7,0x95,0xb0,0x7c,0x18,0x3f,0x6f,0xf3,0xcb,0x4f,
0x65,0x9b,0xe1,0x53,0x37,0x76,0x57,0xbc,0xfe,0x6,0xce,0x44,0xd,0xb8,0xcf,0x16,
0xc3,0x83,0x23,0x56,0xcd,0x7b,0x1f,0x78,0x33,0x6a,0xc0,0x3d,0x33,0x56,0xcf,0xb8,
0x4b,0x41,0x9f,0x76,0xf2,0x2c,0xc3,0x27,0x6f,0x2c,0x1b,0xf2,0x2f,0xe0,0xf9,0xb8,
0xd1,0x96,0x7a,0x1c,0xb8,0xc1,0xf2,0x79,0xff,0x5,0x5e,0x8f,0x1b,0xed,0x81,0x19,
0x15,0x5,0x0,0xf0,0x28,0xf0,0x3e,0xf0,0x5,0xf0,0x23,0x70,0x13,0xb8,0x0,0x9c,
0xc,0x9c,0x69,0x95,0x47,0x18,0x7e,0xca,0x3f,0x1,0x7e,0x0,0xbe,0x5,0x2e,0x1,
0xa7,0x23,0x87,0x5a,0x30,0xa3,0xb2,0x0,0x94,0xd6,0x45,0xe,0xf,0xe0,0xfa,0xba,
0x87,0xf4,0xf4,0xd0,0xa8,0xda,0x7c,0x4,0xec,0x0,0x67,0x19,0xde,0xb7,0xec,0x77,
0x1b,0x78,0x2f,0xeb,0x44,0x92,0x24,0x49,0x92,0x24,0x49,0x92,0x24,0x49,0x92,0x24,
0x49,0x92,0xa,0xf7,0x3f,0x7,0xf9,0x7f,0xa4,0x35,0x32,0x86,0xd8,0x0,0x0,0x0,
0x0,0x49,0x45,0x4e,0x44,0xae,0x42,0x60,0x82,
// /home/cyrille/Documents/IHM/IHM_Lecteur_Audio/client_audio/resource/back.png
0x0,0x0,0x4,0x55,
0x89,
0x50,0x4e,0x47,0xd,0xa,0x1a,0xa,0x0,0x0,0x0,0xd,0x49,0x48,0x44,0x52,0x0,
0x0,0x0,0x80,0x0,0x0,0x0,0x80,0x8,0x6,0x0,0x0,0x0,0xc3,0x3e,0x61,0xcb,
0x0,0x0,0x0,0x4,0x73,0x42,0x49,0x54,0x8,0x8,0x8,0x8,0x7c,0x8,0x64,0x88,
0x0,0x0,0x0,0x9,0x70,0x48,0x59,0x73,0x0,0x0,0xb,0x13,0x0,0x0,0xb,0x13,
0x1,0x0,0x9a,0x9c,0x18,0x0,0x0,0x3,0xf7,0x49,0x44,0x41,0x54,0x78,0x9c,0xed,
0xdd,0xbd,0x8b,0x5c,0x55,0x18,0x80,0xf1,0x27,0x2a,0xf8,0x11,0xc5,0x80,0xb5,0x1f,
0xd1,0x14,0x1,0xff,0x1,0x45,0xa2,0x90,0xc6,0x2e,0x56,0x16,0xa6,0xd8,0xc4,0x52,
0x4,0xd1,0x4a,0x92,0xca,0xda,0xc6,0x46,0x6c,0xc,0x4,0x12,0xad,0x4d,0x2,0x49,
0x44,0x2c,0x16,0x3f,0xb0,0xb0,0xd4,0xb0,0xb2,0x60,0x61,0xc,0x58,0xd8,0x29,0x44,
0x1b,0x93,0x14,0x97,0xc5,0x9d,0xec,0x64,0xe6,0xce,0x9d,0x73,0xcf,0x7b,0xce,0x3d,
0xcf,0xf,0xa6,0x5b,0xe6,0xbe,0x7b,0xde,0x67,0x67,0x77,0x96,0x9d,0x59,0x90,0x24,
0x49,0x92,0x24,0x49,0x92,0x24,0x49,0x92,0x24,0x49,0x92,0x34,0x1d,0xfb,0x12,0xdc,
0xc7,0x61,0xe0,0x13,0xe0,0xc9,0x39,0xf7,0x77,0xb,0xf8,0x1e,0x78,0x1b,0xb8,0x99,
0xe0,0x5a,0x2a,0xd0,0xb7,0xc0,0xed,0x25,0xb7,0xd3,0x61,0xd3,0x69,0xa1,0xfb,0x12,
0xdc,0xc7,0x33,0x3d,0x3e,0xe6,0x60,0x82,0xeb,0xa4,0xf0,0x2c,0xf0,0x11,0xf0,0x23,
0xb0,0x5,0x5c,0x2,0x8e,0x93,0xe6,0x1c,0xc6,0xf0,0x4,0xf0,0x1,0xf0,0x1d,0xf0,
0xb,0xf0,0x35,0xf0,0xe,0xf0,0x70,0xe0,0x4c,0x7b,0xdc,0x60,0xf9,0x23,0xc0,0x99,
0xb0,0xe9,0xfe,0x77,0x1c,0xf8,0x87,0xf9,0xf3,0x6d,0x2,0x8f,0x87,0x4d,0x36,0xdf,
0x4b,0xc0,0x9f,0xcc,0x9f,0x77,0x1b,0x78,0x2e,0x6e,0xb4,0x59,0x35,0x4,0xb0,0x1,
0xfc,0xc7,0xe2,0x19,0x2f,0x87,0x4d,0xb7,0xd7,0x11,0xe0,0x6f,0x16,0xcf,0xbb,0xd,
0x3c,0x12,0x35,0xe0,0x6e,0xa5,0x7,0xd0,0x67,0xf9,0x3b,0xb7,0xa3,0x41,0x33,0xee,
0xd6,0x67,0xf9,0x3b,0xb7,0xf7,0xd6,0xbd,0x58,0xa9,0xdf,0xfb,0x52,0xd9,0x0,0xce,
0xd2,0xff,0xf3,0x3c,0x36,0xe2,0x2c,0x7d,0x1c,0x1,0xae,0x0,0x8f,0xf6,0xfc,0xf8,
0xd7,0xd6,0xbd,0xe0,0x94,0x3,0x58,0x75,0xf9,0xd0,0x3d,0x95,0x8d,0xb2,0xea,0xf2,
0x21,0xc1,0xbc,0x53,0xd,0x60,0xc8,0xf2,0x1,0xee,0x1f,0x61,0x96,0x3e,0x86,0x2c,
0x1f,0x12,0xcc,0x3b,0xc5,0x0,0x86,0x2e,0x3f,0xca,0xd0,0xe5,0x27,0x51,0xcb,0x21,
0xf5,0xe5,0xf2,0x57,0x54,0xcb,0x41,0xf5,0xe1,0xf2,0x7,0xa8,0xe5,0xb0,0x96,0x71,
0xf9,0x3,0x3d,0x10,0x3d,0x40,0x2,0x35,0x2e,0xff,0x2a,0xb0,0x3f,0x7a,0x10,0xa8,
0xe7,0xd0,0xee,0xc5,0xe5,0xaf,0xa9,0x96,0x83,0x9b,0xc7,0xe5,0x27,0x50,0xcb,0xe1,
0xdd,0xcd,0xe5,0x27,0x52,0xcb,0x1,0xee,0xe6,0xf2,0x13,0xaa,0xe5,0x10,0x77,0xb8,
0xfc,0xc4,0x6a,0x39,0x48,0x70,0xf9,0xa3,0xa8,0xe5,0x30,0x5d,0xfe,0x48,0x6a,0x38,
0xd0,0xda,0x96,0xff,0x32,0x95,0x2c,0x1f,0xca,0x3f,0xd4,0x1a,0x97,0x7f,0x85,0x4a,
0x96,0xf,0x65,0x1f,0xac,0xcb,0xcf,0xa0,0xd4,0xc3,0x75,0xf9,0x99,0x94,0x78,0xc0,
0x2e,0x3f,0xa3,0xd2,0xe,0xd9,0xe5,0x67,0x56,0xd2,0x41,0xbb,0xfc,0x0,0xa5,0x1c,
0xb6,0xcb,0xf,0x52,0xc2,0x81,0xd7,0xb6,0xfc,0x57,0x98,0xc8,0xf2,0x21,0xfe,0xd0,
0x6b,0x5c,0xfe,0x65,0x26,0xb2,0x7c,0x88,0x3d,0x78,0x97,0x5f,0x80,0xa8,0xc3,0x77,
0xf9,0x85,0x88,0x58,0x80,0xcb,0x2f,0x48,0xee,0x25,0xb8,0xfc,0xc2,0xe4,0x5c,0x84,
0xcb,0x2f,0x50,0xae,0x65,0x1c,0xc5,0xe5,0x17,0x29,0xd7,0xeb,0x2,0x4a,0x79,0x8b,
0x98,0x3e,0x9a,0x59,0x3e,0xd4,0xf3,0x15,0x99,0xcb,0xf3,0x34,0xb4,0x7c,0x98,0xc6,
0x2b,0x83,0x52,0x3a,0x14,0x3d,0x40,0x6e,0x3e,0x2,0x34,0xce,0x0,0x1a,0x67,0x0,
0x8d,0x33,0x80,0xc6,0x19,0x40,0xe3,0xc,0xa0,0x71,0x6,0xd0,0x38,0x3,0x68,0x9c,
0x1,0x34,0xce,0x0,0x1a,0x67,0x0,0x8d,0x33,0x80,0xc6,0x19,0x40,0xe3,0xc,0x60,
0xd6,0x36,0xdd,0x7b,0xf5,0x37,0xc3,0x0,0x66,0x6d,0x1,0xaf,0xd2,0x50,0x4,0xb9,
0x2,0xf8,0x95,0xee,0xbf,0x76,0xd4,0xe0,0x7,0x1a,0x8a,0x20,0x57,0x0,0x9b,0xc0,
0x9,0xba,0xff,0x23,0x58,0x83,0x66,0x22,0xc8,0xf9,0x2d,0xe0,0x73,0xba,0xbf,0xc,
0x36,0x82,0x82,0xe4,0xfe,0x19,0xc0,0x8,0xa,0x13,0xf1,0x43,0xa0,0x11,0x14,0x24,
0xea,0x59,0x80,0x11,0x14,0x22,0xf2,0x69,0xa0,0x11,0x14,0x20,0xfa,0xf7,0x0,0x46,
0x10,0x2c,0x3a,0x0,0x30,0x82,0x50,0x25,0x4,0x0,0x5d,0x4,0xfe,0x9e,0x20,0x40,
0x29,0x1,0x0,0x7c,0x86,0x11,0x64,0x57,0x52,0x0,0x60,0x4,0xd9,0x95,0x16,0x0,
0x18,0x41,0x56,0x25,0x6,0x0,0x46,0x90,0x4d,0xa9,0x1,0x80,0x11,0x64,0x51,0x72,
0x0,0x60,0x4,0xa3,0x2b,0x3d,0x0,0x30,0x82,0x51,0xd5,0x10,0x0,0x74,0x11,0x9c,
0xc4,0x8,0x92,0xab,0x25,0x0,0x80,0xf3,0x18,0x41,0x72,0x35,0x5,0x0,0x46,0x90,
0x5c,0x6d,0x1,0x80,0x11,0x24,0x55,0x63,0x0,0x60,0x4,0xc9,0xd4,0x1a,0x0,0x18,
0x41,0x12,0x35,0x7,0x0,0x46,0xb0,0xb6,0xda,0x3,0x0,0x23,0x58,0xcb,0x14,0x2,
0x0,0x23,0x18,0x6c,0x2a,0x1,0x40,0x17,0xc1,0x9b,0x18,0xc1,0x4a,0xa6,0x14,0x0,
0xc0,0x39,0x8c,0x60,0x25,0x53,0xb,0x0,0x8c,0x60,0x25,0x53,0xc,0x0,0x86,0x47,
0x10,0xf5,0x2,0xd6,0xa1,0x11,0xac,0x3d,0xef,0x54,0x3,0x80,0x61,0x11,0x5c,0x1f,
0x69,0x96,0x3e,0x86,0x44,0xf0,0xdb,0xba,0x17,0x9d,0x72,0x0,0xb0,0x7a,0x4,0x17,
0x46,0x9c,0xa5,0x8f,0x55,0x23,0x88,0x9e,0x17,0x80,0x1b,0xc0,0xed,0x25,0xb7,0x33,
0x61,0xd3,0x75,0x36,0xe8,0x1e,0x2e,0x17,0xcd,0x78,0x31,0x6c,0xba,0xbd,0x5e,0x4,
0xfe,0x62,0xf1,0xbc,0x5b,0xc0,0x43,0x51,0x3,0xee,0x56,0x43,0x0,0x0,0x6f,0x0,
0x37,0x99,0x3f,0xdf,0x57,0xc0,0x63,0x71,0xa3,0xcd,0xf5,0x2,0xf0,0x7,0xf3,0xe7,
0xbd,0x6,0x3c,0x1d,0x37,0xda,0xac,0xdf,0x59,0x1e,0xc0,0xa7,0x61,0xd3,0xcd,0x7a,
0xa,0xf8,0x90,0xee,0xa1,0xf6,0x27,0xe0,0xb,0xe0,0x75,0x60,0x5f,0xe4,0x50,0xb,
0x1c,0x0,0x4e,0xd1,0xbd,0xc1,0xc6,0xcf,0xc0,0x97,0xc0,0x5b,0xc0,0x83,0x81,0x33,
0xed,0xb1,0xc9,0xf2,0x0,0xde,0x8f,0x1a,0x4e,0x8b,0xa5,0x28,0xff,0x10,0xf0,0x31,
0xdd,0x43,0xd2,0xdd,0xf7,0x77,0xb,0xf8,0x6,0x78,0x17,0xf8,0x37,0xc1,0xb5,0x24,
0x49,0x92,0x24,0x49,0x92,0x24,0x49,0x92,0x24,0x49,0x92,0x24,0x49,0xf7,0x74,0x7,
0x4b,0x36,0x81,0x7,0x89,0x88,0x97,0xf0,0x0,0x0,0x0,0x0,0x49,0x45,0x4e,0x44,
0xae,0x42,0x60,0x82,
// /home/cyrille/Documents/IHM/IHM_Lecteur_Audio/client_audio/resource/sound_high.png
0x0,0x0,0x9,0x72,
0x89,
0x50,0x4e,0x47,0xd,0xa,0x1a,0xa,0x0,0x0,0x0,0xd,0x49,0x48,0x44,0x52,0x0,
0x0,0x0,0x80,0x0,0x0,0x0,0x80,0x8,0x6,0x0,0x0,0x0,0xc3,0x3e,0x61,0xcb,
0x0,0x0,0x0,0x4,0x73,0x42,0x49,0x54,0x8,0x8,0x8,0x8,0x7c,0x8,0x64,0x88,
0x0,0x0,0x0,0x9,0x70,0x48,0x59,0x73,0x0,0x0,0xb,0x13,0x0,0x0,0xb,0x13,
0x1,0x0,0x9a,0x9c,0x18,0x0,0x0,0x9,0x14,0x49,0x44,0x41,0x54,0x78,0x9c,0xed,
0x9d,0x7b,0x8c,0x1f,0x55,0x15,0xc7,0x3f,0xfb,0x28,0x2d,0x60,0x5b,0xbb,0xb4,0x5b,
0x95,0x68,0x91,0x2,0x5d,0x50,0x13,0x7c,0x13,0x8d,0x46,0x30,0x52,0x54,0xa4,0x98,
0x60,0x2d,0x14,0x34,0x20,0xd5,0xa,0xa,0xc5,0x0,0x6,0x83,0x20,0xd1,0xf8,0x40,
0xc4,0x1a,0x94,0x60,0xb5,0x26,0xf2,0xa8,0x8,0x21,0xda,0x1a,0x54,0x40,0x62,0xc,
0x4a,0x28,0x20,0x54,0x20,0x11,0x10,0xa3,0x2d,0x84,0x6a,0x8b,0x48,0x6d,0xc0,0x5d,
0x70,0x77,0xfd,0xe3,0xee,0xe8,0x76,0xf9,0x3d,0xce,0xb9,0x33,0x73,0xcf,0xcc,0xce,
0xf9,0x24,0x27,0xa1,0xe4,0xcc,0x99,0xf3,0xdb,0xfb,0xfd,0xdd,0xdf,0xdc,0xb9,0x8f,
0x3,0x8e,0xe3,0x38,0x8e,0xe3,0x38,0x4e,0xe3,0xe8,0xb1,0x4e,0x20,0x31,0xbd,0xc0,
0x5b,0x81,0xb7,0x3,0x8b,0x81,0x79,0xc0,0x18,0xf0,0x37,0xe0,0x7e,0xe0,0x16,0x60,
0x87,0x59,0x76,0x4e,0x69,0xf4,0x3,0x6b,0x80,0xc7,0x81,0xf1,0xe,0xf6,0x2,0xf0,
0x63,0x60,0x89,0x4d,0x9a,0x4e,0x19,0xbc,0xc,0xd8,0x4c,0xe7,0x86,0x9f,0x6a,0x23,
0x4,0xc1,0x38,0x35,0x67,0x6f,0xe0,0x41,0x74,0x8d,0x3f,0xd9,0x2e,0x4f,0x9f,0xb2,
0x53,0x14,0x7d,0xc0,0x8d,0xc4,0x37,0x7e,0x66,0x67,0xa7,0x4e,0xdc,0x29,0x86,0xef,
0x93,0xbf,0xf1,0xc7,0x81,0x61,0xe0,0xe0,0xc4,0xb9,0x3b,0x39,0xb9,0x8c,0x62,0x1a,
0x3f,0xb3,0xd,0x69,0xd3,0x77,0xf2,0x70,0x31,0xc5,0x36,0xfe,0x38,0xf0,0x3c,0xb0,
0x5f,0xca,0xf,0xe1,0xc4,0x71,0x2e,0xc5,0x37,0x7e,0x66,0x1f,0x4e,0xf8,0x39,0x9c,
0x8,0x3e,0x45,0x79,0x8d,0x3f,0xe,0x7c,0x35,0xdd,0x47,0x71,0xb4,0x9c,0x4e,0x78,
0xa3,0x57,0xa6,0x0,0x7e,0x98,0xec,0xd3,0x24,0xa4,0xd7,0x3a,0x81,0x2,0xf8,0x28,
0xb0,0x8e,0xf2,0x5f,0x6b,0xcf,0x2c,0x39,0xbe,0x9,0x75,0x17,0xc0,0x4a,0xe0,0x7,
0x4c,0xff,0x39,0x8d,0xfe,0xb2,0x2,0xd7,0x59,0x0,0x27,0x12,0xba,0xe5,0x3a,0x7f,
0x6,0x9,0x73,0x80,0x7,0x80,0xe3,0xac,0x13,0xa9,0x12,0x2b,0x81,0xff,0x50,0xee,
0x6f,0xfe,0x54,0xbb,0x3e,0xc9,0x27,0x7b,0x31,0xd9,0xb,0xad,0x51,0xe0,0xb3,0x46,
0x39,0x54,0x8a,0x8f,0x10,0xfe,0x18,0x29,0x1b,0xdf,0x4a,0x0,0xc7,0xb4,0xc8,0xe3,
0x4a,0xa6,0x7f,0xaf,0xd7,0x96,0xd3,0xb1,0x69,0x7c,0xb,0x1,0xcc,0xa5,0xfd,0xf4,
0xf5,0x8f,0x80,0x19,0x89,0xf3,0x31,0xe7,0x4c,0xca,0x1f,0xea,0x55,0x49,0x0,0xeb,
0xbb,0xe4,0xb3,0x89,0x6,0x89,0xe0,0x7c,0xec,0x1a,0xde,0x42,0x0,0xad,0xba,0xfe,
0x56,0x76,0x23,0x61,0xd6,0x73,0x5a,0xf3,0x65,0xec,0x1b,0x3f,0xa5,0x0,0x3a,0x75,
0xfd,0xad,0xec,0x6a,0xa6,0xe9,0x30,0xb8,0x17,0xf8,0xe,0xf6,0xd,0x9f,0x5a,0x0,
0xdd,0xba,0xfe,0x56,0xf6,0xc5,0x44,0xb9,0x25,0x63,0x2f,0xc2,0x1f,0xdc,0xba,0xd1,
0x53,0xb,0xe0,0x88,0x1c,0xf9,0x9d,0x9a,0x20,0xbf,0x24,0xcc,0x6,0x6e,0xc5,0xbe,
0xc1,0x2d,0x4,0xd0,0x3,0x5c,0x1a,0x99,0xdf,0x8,0x61,0xc5,0x73,0xad,0x79,0x39,
0x61,0x79,0xb6,0x75,0x63,0x5b,0x9,0x20,0x63,0x35,0x71,0xc3,0xdd,0x6d,0xc0,0xfc,
0x84,0x79,0x16,0xca,0x6b,0x81,0xad,0xd8,0x37,0x74,0x15,0x4,0x0,0xf1,0x6f,0x3b,
0x6f,0xa1,0x86,0xf,0x85,0xef,0x3,0xfe,0x85,0x7d,0x23,0x57,0x49,0x0,0x10,0x16,
0xa1,0xc4,0xf4,0x4,0x67,0x19,0xe4,0x1a,0xcd,0x39,0xa4,0x7f,0xaf,0x5f,0x17,0x1,
0x40,0x78,0xfb,0xa9,0xcd,0xf5,0x39,0x6a,0xb0,0xb9,0x65,0x1f,0xe0,0x3a,0xec,0x1b,
0xb6,0xea,0x2,0x0,0xb8,0xb0,0x43,0x5e,0xed,0xec,0x4e,0x2a,0xfc,0x53,0x70,0x8,
0xb0,0x5,0xfb,0x46,0xad,0x8b,0x0,0x0,0xae,0x45,0x9f,0xf3,0x2a,0x93,0x4c,0xbb,
0x70,0x32,0xb0,0x1b,0xfb,0x6,0xad,0x9b,0x0,0x66,0x2,0xf7,0xa1,0xcb,0xf9,0x29,
0x2a,0xb4,0x9a,0xf9,0x75,0xc0,0x2f,0xb1,0x6f,0xc8,0x2a,0x8,0xe0,0x15,0x91,0xd7,
0x2d,0x6,0x76,0xa1,0xcb,0xfb,0x8a,0xbc,0xc9,0xe6,0x61,0x0,0x58,0xe,0xdc,0x8c,
0xed,0x4c,0x5e,0x95,0x4,0x30,0xf,0x78,0x92,0x30,0xc7,0x11,0xc3,0x49,0xe8,0xf2,
0x7e,0x1e,0x38,0xb0,0x5d,0xb0,0x6e,0x6b,0xcd,0xe,0x7,0x8e,0x4,0x86,0x80,0x97,
0x22,0x9b,0x79,0xea,0x27,0x4c,0x68,0x2c,0x2,0xe,0xa0,0xc2,0xf,0x22,0x46,0x5c,
0x41,0x78,0xe1,0x75,0x1,0xf0,0x12,0xf4,0x43,0xb6,0xd,0xc0,0x9,0xc0,0x7,0x85,
0xfe,0x33,0x8,0x73,0x5,0x2b,0x35,0x37,0xf9,0x10,0xf0,0x7,0xec,0xbf,0x75,0x55,
0xb2,0x22,0x7a,0x80,0x65,0x2d,0xe2,0x7e,0x23,0x22,0xce,0x20,0xf0,0x74,0x97,0x7c,
0x27,0xdb,0x28,0xe1,0xc1,0xbb,0x2b,0xf3,0x80,0x9f,0x29,0x2,0x37,0xc9,0xf2,0xa,
0x60,0x0,0xd8,0xde,0x26,0xf6,0xb9,0x11,0xf1,0xb4,0x1b,0x61,0xd6,0x75,0xb,0x38,
0x9f,0x7c,0x7b,0xe9,0xa7,0xbb,0xe5,0x15,0x40,0xa7,0x77,0x1e,0x63,0xc0,0x7,0x94,
0xf1,0xfa,0xd0,0xf5,0xd2,0xc3,0x84,0xc3,0x32,0x5a,0xd2,0xf,0xfc,0x4e,0x11,0xac,
0x89,0x96,0x47,0x0,0xc7,0xb,0xe2,0xef,0x2,0xe,0x52,0xc6,0x7d,0xbf,0xf2,0x33,
0x5c,0xd4,0x2e,0xd0,0x5,0xca,0x40,0x4d,0xb4,0x58,0x1,0xec,0x47,0x38,0x84,0x4a,
0x72,0x8f,0x7b,0xd0,0xaf,0xf3,0xd3,0x7c,0x71,0xb7,0xd2,0x62,0x45,0xf1,0x5c,0xf4,
0x63,0xcb,0x26,0x5a,0xac,0x0,0x36,0x28,0xef,0xf3,0x5,0x65,0xfc,0xa5,0xca,0xf8,
0xef,0x9d,0x1a,0x60,0xb5,0x32,0x40,0x53,0x2d,0x46,0x0,0x87,0x47,0xdc,0x67,0x4,
0x38,0x4c,0x79,0x1f,0xcd,0xb3,0xdb,0x1e,0x87,0x5d,0xf4,0x12,0xa6,0x62,0x9d,0x72,
0xd8,0x2,0x5c,0xa2,0xbc,0x66,0x2f,0x60,0xad,0xf2,0x1a,0x8d,0xff,0xb1,0xc0,0xac,
0xc9,0xff,0x63,0x1b,0xf6,0xdf,0xae,0x3a,0x58,0x9e,0x87,0xc0,0x6f,0x47,0xdc,0xef,
0x45,0x5d,0x75,0x7,0xf6,0x45,0xb7,0x9e,0x62,0x59,0x76,0x61,0x2f,0x1d,0x86,0x6,
0x4e,0x61,0x9c,0xd,0xdc,0xae,0xbc,0x46,0xd3,0x73,0x3c,0x8b,0x4e,0xa0,0xc7,0x4f,
0xfe,0x87,0xf5,0x37,0xab,0x2e,0x96,0xf7,0x3d,0xc0,0x20,0xf2,0xd1,0x40,0x66,0x47,
0x2b,0xe2,0xbf,0x4b,0x11,0xf7,0x89,0xec,0xa2,0xc6,0x6e,0x32,0x34,0x60,0x7,0xf0,
0x71,0xe5,0x35,0xe7,0x28,0x7c,0xef,0x0,0x76,0xa,0x7d,0xf7,0x7,0xe,0x5,0x17,
0x40,0x6a,0x36,0x1,0x3f,0x55,0xf8,0x2f,0x25,0x4c,0xa8,0x49,0x18,0x9d,0x88,0x2f,
0xe5,0x28,0x70,0x1,0x58,0x70,0x1e,0xe1,0x50,0x6a,0x9,0x3d,0x84,0xed,0xf0,0x52,
0x6e,0x53,0xf8,0xbe,0x5,0x5c,0x0,0x16,0x3c,0x46,0xd8,0xcf,0x27,0x65,0xb9,0xc2,
0xf7,0x76,0xc2,0x6f,0xbc,0x4,0x17,0x80,0x21,0x5f,0x57,0xf8,0xbe,0x6,0xf9,0x51,
0xb5,0x4f,0x1,0xf,0xb,0x7d,0x97,0x0,0xb3,0x5d,0x0,0x36,0x3c,0x2,0xfc,0x5a,
0xe1,0xff,0x1e,0x85,0xef,0xef,0x85,0x7e,0x3d,0xc0,0x90,0xb,0xc0,0x8e,0x6b,0x14,
0xbe,0x47,0x2a,0x7c,0xef,0x55,0xf8,0x1e,0xe2,0x2,0xb0,0x63,0x13,0x61,0x1d,0x80,
0x4,0xcd,0xa6,0xcf,0x3f,0x2a,0x7c,0x5d,0x0,0x86,0xfc,0x3,0x79,0x77,0xfd,0x4a,
0xe4,0x9b,0x3e,0xff,0xa4,0xc8,0x61,0x91,0xb,0xc0,0x96,0x3b,0x14,0xbe,0x43,0x42,
0xbf,0xad,0x84,0xad,0x76,0x12,0x16,0xba,0x0,0x6c,0xd9,0xa2,0xf0,0x5d,0x2c,0xf4,
0x1b,0x23,0x8c,0x6,0x24,0xc,0xba,0x0,0x6c,0x79,0x54,0xe1,0xbb,0xbf,0xc2,0x57,
0x5a,0xfa,0x6e,0x81,0xb,0xc0,0x96,0x6d,0xa,0xdf,0x5,0xa,0xdf,0xa7,0x85,0x7e,
0xfb,0xb8,0x0,0x6c,0x91,0x76,0xd5,0x10,0x8e,0xce,0x91,0x32,0x2c,0xf4,0x9b,0xe5,
0x2,0xb0,0xe5,0x5,0xc2,0x24,0x8e,0x84,0x59,0xdd,0x5d,0xfe,0xc7,0x88,0x34,0xa6,
0xb,0xa0,0xe1,0xb8,0x0,0x6c,0x99,0x81,0xfc,0xa4,0x4f,0x69,0xb7,0xe,0xf2,0xde,
0x62,0xd8,0x5,0x60,0x8b,0xe6,0x44,0xaf,0xdd,0xa,0x5f,0x69,0x75,0x13,0x17,0x80,
0x31,0xaf,0x52,0xf8,0x6a,0xaa,0x9a,0xf,0x8,0xfd,0x9e,0x73,0x1,0xd8,0x22,0xda,
0xb1,0x3b,0xc1,0x93,0xa,0xdf,0x41,0xa1,0xdf,0x4e,0x17,0x80,0x2d,0xaf,0x57,0xf8,
0x3e,0x26,0xf4,0xeb,0x45,0xfe,0xd3,0xf2,0x77,0x17,0x80,0x2d,0xef,0x50,0xf8,0x4a,
0x17,0x7a,0x2c,0x42,0x5e,0x64,0x6a,0x87,0xb,0xc0,0x8e,0xf9,0xc0,0x1b,0x84,0xbe,
0xdb,0x8,0xb3,0x87,0x12,0x34,0x85,0xae,0xb7,0xba,0x0,0xec,0x38,0xe,0xf9,0x30,
0x7c,0xb3,0x22,0xee,0xa1,0xa,0xdf,0x47,0x5d,0x0,0x76,0x9c,0xa2,0xf0,0xd5,0x2c,
0x1f,0x7b,0x93,0xc2,0xd7,0x5,0x60,0xc4,0x12,0xc2,0x4e,0x1e,0x29,0xb7,0x2a,0x7c,
0xdf,0x28,0xf4,0x1b,0x3,0x1e,0x76,0x1,0xd8,0x70,0xbe,0xc2,0xf7,0x21,0xe0,0xcf,
0x42,0xdf,0x5,0xc8,0x17,0x8e,0x3c,0x2,0xec,0x76,0x1,0xa4,0xe7,0x60,0x74,0x9b,
0x3d,0x6e,0x50,0xf8,0x1e,0x85,0xfc,0x58,0xbe,0x7b,0xc0,0xe7,0x2,0x2c,0xb8,0xc,
0xf9,0x30,0x6d,0xc,0x5d,0xd5,0x72,0xcd,0xf2,0xf1,0xbb,0xb3,0xff,0xb0,0xde,0x75,
0x5b,0x17,0x2b,0xe2,0x9c,0x40,0xc9,0x61,0x51,0x93,0xed,0x66,0x45,0xec,0x3e,0xc2,
0xeb,0x62,0x69,0xec,0x21,0xf0,0x1e,0x20,0x25,0xb,0x81,0xab,0x94,0xd7,0x7c,0x53,
0xe1,0xfb,0x4e,0xe4,0xab,0x86,0x9e,0x60,0xe2,0xc5,0x52,0x2f,0xf2,0x8d,0x8a,0x4e,
0x3c,0xfd,0x84,0x72,0xaf,0xb,0x15,0xd7,0x6c,0x6,0x7e,0xa5,0xf0,0x3f,0x51,0xe1,
0xbb,0xc7,0x26,0x52,0x3f,0x22,0xa6,0xfc,0x9f,0x80,0x2b,0x23,0xee,0xb7,0x54,0x11,
0x5f,0x7b,0x44,0xcc,0x1e,0xa5,0xe8,0x37,0x46,0x24,0xd7,0x44,0x8b,0x15,0xc0,0x25,
0x11,0xf7,0xfa,0x85,0xf2,0x1e,0x1f,0x53,0xc4,0xde,0xc5,0x94,0xf5,0x2,0x9f,0x88,
0x48,0xb0,0x89,0x96,0xea,0x98,0xb8,0x61,0xe4,0x63,0xf9,0x8c,0x87,0x14,0xf1,0xaf,
0x9b,0x7a,0xf1,0x1c,0xe0,0x99,0x88,0x44,0x9b,0x66,0xa9,0xe,0x8a,0xbc,0x50,0x19,
0x5f,0x5a,0x68,0x3a,0xb3,0x63,0x5a,0x5,0x39,0x4f,0x19,0xa4,0x89,0x96,0xe2,0xa8,
0xd8,0xbb,0x90,0xbf,0x23,0xc8,0xd0,0x1c,0x15,0xfb,0x17,0xda,0x8c,0xfc,0xfa,0x80,
0xdf,0x28,0x2,0x35,0xd1,0xca,0x3e,0x2c,0xfa,0x19,0x3a,0x54,0xf6,0x68,0xc3,0xb1,
0xca,0xcf,0xd0,0xb1,0x77,0x19,0xc0,0x8b,0x44,0x94,0x25,0x0,0xe8,0x7c,0x5c,0xfc,
0x28,0xba,0x83,0x21,0x21,0x7c,0x69,0x1f,0x50,0xe4,0x3f,0x8c,0x60,0x18,0x3a,0x17,
0xb8,0x49,0x11,0xb4,0x49,0x56,0x66,0xc1,0x88,0x35,0x11,0xf1,0x3e,0xad,0xc8,0x7d,
0x1c,0xf8,0xae,0x26,0xf8,0x32,0xc2,0x49,0x13,0xd6,0x7f,0xf4,0x2a,0x59,0x59,0x25,
0x63,0x2e,0x8d,0x88,0xb3,0x10,0xf8,0x67,0x97,0x7c,0x27,0xdb,0x28,0x6d,0x56,0xa,
0xb5,0x7b,0xe0,0xd8,0x38,0x61,0x87,0xf1,0xff,0xa2,0x51,0x3,0xc8,0x36,0x31,0xf4,
0x11,0x46,0x16,0x7,0x10,0xb6,0x34,0x4b,0x37,0x3e,0x34,0x81,0x8d,0x84,0x9f,0x82,
0xac,0x80,0xd3,0x5a,0x74,0x53,0xc3,0x19,0x57,0x11,0x8a,0x78,0x49,0xb9,0x1e,0xdd,
0xc1,0x11,0x85,0x31,0x9b,0x50,0xdd,0xea,0x27,0xc4,0x15,0x41,0xae,0x92,0x15,0x5d,
0x36,0xee,0x4b,0x91,0xd7,0x9f,0x8c,0x2e,0xef,0x11,0xe0,0xd5,0xf9,0x52,0x2e,0x86,
0x21,0xc2,0xb9,0x38,0xd6,0xd,0x69,0x2d,0x0,0x88,0x2f,0x1c,0x79,0x10,0xfa,0x2a,
0xeb,0xdf,0xca,0x9b,0x6c,0xd1,0xac,0xa0,0x9e,0x15,0x4a,0xaa,0x50,0x3a,0xf6,0x7e,
0x74,0x39,0xef,0x44,0xbe,0x4b,0x28,0x29,0x7,0x12,0x56,0xa4,0x58,0x37,0x6a,0x9d,
0x4,0x10,0x53,0x69,0xfd,0x34,0x93,0x4c,0x85,0xcc,0x4,0xd6,0x63,0xdf,0xb0,0x75,
0x10,0xc0,0xe7,0x3b,0xe4,0xd5,0xce,0x7e,0x4b,0x4d,0xaa,0xb6,0x7e,0x92,0xb0,0x26,
0xc1,0xba,0x81,0xab,0x2a,0x80,0x55,0x8a,0x1c,0x33,0x7b,0x16,0xdd,0x6,0x11,0x73,
0xde,0x8d,0x6e,0x5c,0xdb,0x14,0x1,0xac,0x20,0x6e,0xf4,0x74,0xa6,0x41,0xae,0xb9,
0x59,0x42,0x58,0xfe,0x6c,0xdd,0xd0,0x55,0x11,0xc0,0x29,0x84,0xf3,0xfe,0xb4,0x79,
0xfe,0x9c,0x9a,0x74,0xfd,0xad,0x18,0xa4,0xba,0xf,0x87,0x29,0x5,0x70,0x6,0x61,
0x45,0xb0,0x36,0xc7,0xbf,0x12,0x66,0x1f,0x6b,0xcd,0xbe,0x84,0xd5,0xb0,0xd6,0xd,
0x6e,0x21,0x80,0x1e,0xc2,0xb2,0xf1,0x98,0xfc,0x46,0x80,0x37,0x27,0xc8,0x31,0x9,
0xfd,0x84,0xa2,0xa,0xd6,0x8d,0x9e,0x5a,0x0,0x47,0xe4,0xc8,0x4f,0xb3,0xd9,0xa4,
0x16,0xf4,0x0,0x97,0x63,0xdf,0xf0,0x29,0x5,0x0,0x71,0x43,0xe3,0x8b,0x13,0xe5,
0x66,0xc2,0x45,0xd8,0x37,0x7e,0x4a,0x1,0xcc,0x5,0x1e,0x57,0xe4,0xb5,0x3e,0x51,
0x5e,0xa6,0xac,0x21,0xee,0xa1,0xa8,0x8e,0x2,0x0,0x79,0x41,0xe8,0xd,0x34,0x68,
0x73,0xcf,0x2a,0x6c,0x67,0x14,0x53,0xf,0x3,0xbf,0xd7,0x25,0x9f,0x9b,0xd0,0xaf,
0x1f,0xac,0x3d,0xb1,0x63,0xe3,0x3a,0xa,0x60,0xe,0xed,0x37,0xed,0x5c,0x4d,0x3,
0x1b,0x3f,0x63,0x5,0x36,0x22,0xb0,0x78,0x13,0x78,0x74,0x8b,0x3c,0xd6,0x52,0xe3,
0x17,0x3d,0x45,0xb1,0x9c,0xf4,0xf3,0x7,0x56,0x73,0x1,0xeb,0x26,0xee,0x3f,0xa,
0x7c,0xc6,0x28,0x87,0x4a,0x72,0x2,0x69,0x45,0x60,0x25,0x80,0xd9,0xc0,0x83,0xe8,
0x57,0xd,0x37,0x82,0x94,0x3d,0x81,0xe5,0x74,0x70,0x69,0xeb,0x2a,0xeb,0x3e,0x84,
0xb8,0x81,0xf0,0x60,0x28,0x2d,0xbf,0x56,0x57,0xa4,0x35,0x5,0xd4,0xd4,0x5d,0x0,
0x10,0xbe,0x99,0xa7,0x52,0xbe,0x8,0xa4,0x45,0x18,0x6a,0xc5,0x74,0x10,0x0,0x84,
0x61,0xd1,0xea,0x92,0xef,0xb1,0xbd,0xe4,0xf8,0x4e,0x1,0x9c,0x45,0x79,0xcf,0x0,
0x9a,0x2a,0xde,0x8e,0x21,0x9f,0xa3,0xf8,0xc6,0x1f,0xa1,0xa2,0xab,0x6b,0x9d,0xd6,
0x7c,0x85,0x62,0x5,0x70,0x6d,0xda,0xf4,0x9d,0x22,0x88,0x39,0x97,0xa7,0x95,0xfd,
0x1b,0x79,0xd5,0x4e,0xa7,0x42,0xf4,0x12,0x4e,0xe6,0xca,0x2b,0x80,0x33,0x52,0x27,
0xee,0x14,0xc7,0x2c,0xf4,0xbb,0x69,0x26,0xdb,0xd7,0xd2,0xa7,0xec,0x14,0xcd,0x2,
0x74,0xc7,0xa8,0x64,0xdd,0xbe,0x7f,0xf3,0xa7,0x11,0x7d,0x84,0xd,0x28,0xdd,0x96,
0x9d,0x8f,0x0,0xd7,0xa0,0x3f,0xaa,0xa5,0xb6,0x34,0x6d,0x5a,0xb1,0x87,0x50,0xa6,
0xe5,0x6d,0x84,0x9d,0xb6,0x3,0x84,0x37,0x88,0xdb,0x81,0xfb,0x8,0x27,0x73,0x4a,
0xb,0x2f,0x3b,0x8e,0xe3,0x38,0x8e,0xe3,0x38,0x4e,0x3d,0xf9,0x2f,0x91,0x6b,0xf5,
0x56,0x83,0xba,0x4e,0xc4,0x0,0x0,0x0,0x0,0x49,0x45,0x4e,0x44,0xae,0x42,0x60,
0x82,
// /home/cyrille/Documents/IHM/IHM_Lecteur_Audio/client_audio/resource/stop.png
0x0,0x0,0x2,0xe,
0x89,
0x50,0x4e,0x47,0xd,0xa,0x1a,0xa,0x0,0x0,0x0,0xd,0x49,0x48,0x44,0x52,0x0,
0x0,0x0,0x80,0x0,0x0,0x0,0x80,0x8,0x6,0x0,0x0,0x0,0xc3,0x3e,0x61,0xcb,
0x0,0x0,0x0,0x4,0x73,0x42,0x49,0x54,0x8,0x8,0x8,0x8,0x7c,0x8,0x64,0x88,
0x0,0x0,0x0,0x9,0x70,0x48,0x59,0x73,0x0,0x0,0xb,0x13,0x0,0x0,0xb,0x13,
0x1,0x0,0x9a,0x9c,0x18,0x0,0x0,0x1,0xb0,0x49,0x44,0x41,0x54,0x78,0x9c,0xed,
0xd6,0xb1,0x4d,0x3,0x41,0x14,0x45,0xd1,0x67,0x68,0x2,0xd1,0x6,0x99,0x63,0x9a,
0x80,0x3a,0x10,0x9,0xf5,0x38,0xa6,0xe,0x22,0xaa,0x0,0x97,0x40,0xb6,0x26,0x70,
0xe8,0xc4,0x48,0x7f,0x65,0xe0,0x9d,0x23,0x4d,0xfa,0x77,0x34,0x73,0x35,0xda,0x4,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x80,0x7f,0x62,0xb3,0xd2,0xdc,0x6d,0x92,
0x87,0x24,0x37,0x2b,0x7e,0xa3,0xc5,0x21,0xc9,0x3e,0xc9,0x2e,0xc9,0xdb,0x85,0xf7,
0x72,0x96,0x97,0x1c,0x37,0x6d,0xcd,0xae,0x25,0xc9,0xf3,0xf,0xee,0xe1,0x22,0xb6,
0xb9,0xfc,0x41,0xfd,0xe7,0xb5,0x24,0xb9,0x3b,0xfb,0x36,0xce,0x70,0x35,0x39,0x2c,
0xc7,0x67,0x9f,0xf5,0x6c,0x92,0x3c,0x4e,0xe,0x9c,0xe,0xe0,0x66,0x78,0x1e,0xa7,
0x6e,0x27,0x87,0x4d,0x7,0xe0,0x87,0x6f,0x7d,0xa3,0x67,0x3c,0x1d,0x0,0x7f,0x8c,
0x0,0xca,0x9,0xa0,0x9c,0x0,0xca,0x9,0xa0,0x9c,0x0,0xca,0x9,0xa0,0x9c,0x0,
0xca,0x9,0xa0,0x9c,0x0,0xca,0x9,0xa0,0x9c,0x0,0xca,0x9,0xa0,0x9c,0x0,0xca,
0x9,0xa0,0x9c,0x0,0xca,0x9,0xa0,0x9c,0x0,0xca,0x9,0xa0,0x9c,0x0,0xca,0x9,
0xa0,0x9c,0x0,0xca,0x9,0xa0,0x9c,0x0,0xca,0x9,0xa0,0x9c,0x0,0xca,0x9,0xa0,
0x9c,0x0,0xca,0x9,0xa0,0x9c,0x0,0xca,0x9,0xa0,0x9c,0x0,0xca,0x9,0xa0,0x9c,
0x0,0xca,0x9,0xa0,0x9c,0x0,0xca,0x9,0xa0,0x9c,0x0,0xca,0x9,0xa0,0x9c,0x0,
0xca,0x9,0xa0,0x9c,0x0,0xca,0x9,0xa0,0x9c,0x0,0xca,0x9,0xa0,0x9c,0x0,0xca,
0x9,0xa0,0x9c,0x0,0xca,0x9,0xa0,0x9c,0x0,0xca,0x9,0xa0,0x9c,0x0,0xca,0x9,
0xa0,0x9c,0x0,0xca,0x9,0xa0,0x9c,0x0,0xca,0x9,0xa0,0x9c,0x0,0xca,0x9,0xa0,
0x9c,0x0,0xca,0x9,0xa0,0x9c,0x0,0xca,0x9,0xa0,0x9c,0x0,0xca,0x9,0xa0,0x9c,
0x0,0xca,0x9,0xa0,0x9c,0x0,0xca,0x9,0xa0,0x9c,0x0,0xca,0x9,0xa0,0x9c,0x0,
0xca,0x9,0xa0,0x9c,0x0,0xca,0x9,0xa0,0x9c,0x0,0xca,0x9,0xa0,0x9c,0x0,0xca,
0x9,0xa0,0xdc,0x74,0x0,0x87,0xe1,0x79,0x9c,0x5a,0x26,0x87,0x4d,0x7,0xb0,0x1f,
0x9e,0xc7,0xa9,0xcf,0xc9,0x61,0xd3,0x1,0xec,0xe2,0x15,0x58,0xd3,0x92,0xe3,0x19,
0x8f,0xb9,0x9e,0x1c,0x96,0xe4,0x23,0xc9,0x57,0x92,0xfb,0x24,0x9b,0xe1,0xd9,0xed,
0x96,0x24,0x4f,0x49,0x5e,0x27,0x87,0xae,0x75,0x49,0x77,0x49,0x1e,0x93,0xdc,0xae,
0xf8,0x8d,0x16,0x4b,0x8e,0xcf,0xfe,0x2e,0xc9,0xfb,0x85,0xf7,0x2,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0xc0,0xef,0xf5,0xd,0x27,0x38,0xc3,0x99,0x60,0x40,0x63,
0xf4,0x0,0x0,0x0,0x0,0x49,0x45,0x4e,0x44,0xae,0x42,0x60,0x82,
// /home/cyrille/Documents/IHM/IHM_Lecteur_Audio/client_audio/resource/mute_2.png
0x0,0x0,0xc,0x6d,
0x89,
0x50,0x4e,0x47,0xd,0xa,0x1a,0xa,0x0,0x0,0x0,0xd,0x49,0x48,0x44,0x52,0x0,
0x0,0x0,0x80,0x0,0x0,0x0,0x80,0x8,0x6,0x0,0x0,0x0,0xc3,0x3e,0x61,0xcb,
0x0,0x0,0x0,0x4,0x73,0x42,0x49,0x54,0x8,0x8,0x8,0x8,0x7c,0x8,0x64,0x88,
0x0,0x0,0x0,0x9,0x70,0x48,0x59,0x73,0x0,0x0,0xb,0x13,0x0,0x0,0xb,0x13,
0x1,0x0,0x9a,0x9c,0x18,0x0,0x0,0xc,0xf,0x49,0x44,0x41,0x54,0x78,0x9c,0xed,
0x9d,0x7b,0x94,0x56,0x55,0x15,0xc0,0x7f,0xdf,0x30,0xcc,0x38,0xf2,0x56,0xd0,0x10,
0x32,0x4,0x53,0x8c,0x90,0xa0,0x14,0x12,0xb4,0x88,0x92,0x58,0xa6,0xa0,0x66,0x44,
0xcb,0x85,0xd8,0xc3,0x22,0x5b,0x46,0xef,0x92,0x2c,0xb5,0x34,0x4b,0xb3,0x97,0x25,
0x5a,0x49,0x6a,0xd6,0x2a,0x31,0xa4,0x92,0xc8,0x22,0x9,0xa8,0x5c,0x90,0x25,0x28,
0x4a,0x61,0x60,0x12,0x9a,0x8,0xc6,0xfb,0xed,0x7c,0xfd,0xb1,0xe7,0x73,0x5e,0xe7,
0xb1,0xcf,0xbd,0xdf,0xcc,0xbd,0xdf,0xc7,0xf9,0xad,0x75,0xd6,0x9a,0x3f,0xe6,0xec,
0xb3,0xbf,0x7b,0xf7,0xbd,0xf7,0x9c,0x7d,0xf6,0xde,0x7,0x22,0x91,0x48,0x24,0x12,
0x89,0x44,0x22,0x91,0x48,0x24,0x12,0x89,0x44,0x22,0x91,0x48,0x24,0x12,0x89,0x44,
0x22,0x91,0x48,0x24,0x12,0x89,0x44,0x22,0x91,0x48,0x24,0x12,0x89,0x44,0x22,0x91,
0xa,0x67,0x7a,0xd6,0xa,0x44,0xb2,0x61,0x18,0xf0,0x47,0xa0,0x98,0xb5,0x22,0x6d,
0xe8,0x95,0xb5,0x2,0xd5,0x4e,0x37,0xe0,0x46,0xe0,0x20,0x72,0xf3,0xf3,0x62,0x0,
0x5d,0x81,0xb9,0xc0,0x53,0xc0,0xf1,0x19,0xeb,0x52,0xb5,0x5c,0x8,0x3c,0x43,0xf3,
0x8d,0xcf,0x8b,0x1,0xf4,0x1,0x1e,0xa2,0x59,0x9f,0xa7,0x81,0xc1,0x59,0x2a,0x54,
0x6d,0xc,0x1,0x16,0xd2,0xfe,0xc6,0xe7,0xc1,0x0,0x86,0x0,0x6b,0x69,0xaf,0xd3,
0x7a,0xe0,0xb8,0xc,0xf5,0x4a,0xc4,0x18,0xa0,0x5f,0xd6,0x4a,0xb4,0xa0,0x1e,0xf8,
0x22,0xb0,0x17,0xfb,0xcd,0xcf,0xda,0x0,0x6e,0xc2,0xae,0xd7,0xe3,0xc0,0x51,0xd9,
0xa9,0x16,0x46,0x6f,0xe0,0x39,0xe0,0x5,0x60,0x5a,0xc6,0xba,0x0,0x9c,0xd,0xac,
0xc3,0x7d,0xe3,0xf3,0x60,0x0,0x5,0xe0,0x1b,0xd8,0x75,0x5b,0x82,0xcc,0xf,0x72,
0xcf,0x1d,0xb4,0x56,0xfc,0x7e,0xa0,0x7f,0x6,0x7a,0xc,0x0,0xee,0x45,0x77,0xe3,
0xf3,0x60,0x0,0x25,0xbe,0x8e,0x5d,0xbf,0x3b,0x32,0xd4,0x4b,0xc5,0xdb,0x30,0x2b,
0xfe,0x22,0x30,0xa3,0x93,0x74,0xa8,0x5,0x3e,0xe,0xec,0xb0,0xe8,0x92,0x77,0x3,
0x0,0xb8,0x15,0xbb,0x8e,0x97,0x67,0xa8,0x97,0x93,0x23,0x81,0xd,0xb8,0x2f,0xf0,
0x42,0x60,0x60,0x7,0xea,0x30,0x16,0x58,0xe5,0xd1,0xa1,0x12,0xc,0xa0,0x6,0x98,
0x8f,0x59,0xc7,0xfd,0xc0,0x69,0xd9,0xa9,0xe6,0xe6,0x32,0x60,0x3b,0xee,0x8b,0xbc,
0xbd,0xe9,0xff,0xca,0x49,0x5f,0xe4,0xf5,0xd8,0xe8,0x19,0xbb,0x52,0xc,0x0,0xe4,
0x81,0x5a,0x81,0x59,0xcf,0xf5,0x40,0xf7,0xec,0x54,0x73,0xf3,0x4a,0xe0,0x37,0xf8,
0x2f,0xf6,0xef,0x81,0x41,0x29,0xc7,0x2a,0x20,0xc6,0xb4,0x55,0x31,0x5e,0xa5,0x19,
0x0,0xc8,0x3c,0xe6,0x79,0xcc,0xba,0x7e,0x3f,0x43,0xbd,0x54,0xcc,0x0,0xfe,0x87,
0xfb,0x82,0xef,0x2,0x3e,0x82,0xdc,0xc8,0x50,0x46,0x2,0xf,0x7b,0xe4,0x57,0xba,
0x1,0x0,0xbc,0x19,0x38,0x84,0x59,0xdf,0x49,0xd9,0xa9,0xa5,0xa3,0x3f,0xb0,0x0,
0xff,0x85,0x5f,0xa,0x9c,0xa8,0x94,0xd9,0x13,0xf8,0x36,0xf6,0x8b,0x92,0x37,0x3,
0xb8,0x12,0xf8,0x31,0x50,0x97,0x42,0xc6,0xd5,0xd8,0x3f,0x5,0xd,0x29,0xf5,0xeb,
0x14,0xa6,0x1,0x5b,0x70,0x5f,0xfc,0x3d,0xc0,0x27,0x90,0x9,0x90,0x8b,0x1b,0x3c,
0x72,0xf2,0x62,0x0,0x5d,0x69,0xbd,0x24,0x5e,0x8c,0xec,0x3f,0x24,0xa1,0x16,0xfb,
0xdb,0xee,0xba,0xd4,0x9a,0x76,0x12,0xc7,0xa0,0x5b,0x97,0xff,0x5,0x38,0xc5,0x23,
0x6b,0x22,0xe2,0x27,0xcf,0xab,0x1,0xf4,0x46,0x6e,0x78,0x5b,0xf9,0xcb,0x48,0x3e,
0x79,0x1b,0x8a,0xac,0x0,0xda,0xca,0xdc,0xf,0x9c,0x90,0x52,0xdf,0x4e,0xe5,0x9d,
0xd8,0x27,0x36,0xa5,0xb6,0xf,0xf8,0x1c,0xd0,0xc5,0x21,0xa7,0x3b,0xf0,0x2d,0xe0,
0x25,0x8f,0xac,0x2c,0xc,0xe0,0xd7,0x8e,0x31,0x96,0x0,0x47,0x24,0x94,0x7b,0xad,
0x45,0xe6,0x3d,0xe9,0xd4,0xed,0x7c,0x8e,0x46,0xbe,0x8b,0xbe,0x1b,0xf2,0x57,0x60,
0xb8,0x47,0xd6,0x18,0x60,0x8d,0x42,0x56,0x67,0x1a,0x40,0x3f,0xe0,0xcf,0x8e,0x71,
0x7e,0x81,0xff,0x53,0x67,0xa2,0x1e,0xf9,0xee,0xb7,0x95,0xd7,0x8,0xbc,0x2e,0xb5,
0xd6,0x19,0x70,0x2e,0xb0,0x9,0xf7,0x4d,0x39,0x80,0x6c,0xe4,0xb8,0xfc,0xe0,0x75,
0xc0,0x35,0x4d,0xff,0x9b,0x7,0x3,0x0,0x99,0x9c,0x2d,0x72,0x8c,0xf5,0xd5,0x84,
0x72,0xa7,0x5a,0xe4,0xcd,0x4b,0xa9,0x6f,0x66,0xf4,0xa6,0xfd,0xfe,0x81,0xa9,0xad,
0x2,0x46,0x79,0x64,0xbd,0x96,0x74,0x4b,0xc3,0x72,0x53,0x87,0xfb,0x73,0x90,0x74,
0xb3,0xcc,0xf4,0x1b,0x1b,0xf1,0xcf,0x9d,0x72,0xcd,0x44,0xcc,0x41,0x1a,0x2d,0xdb,
0x41,0xe0,0x7a,0xe4,0x55,0x68,0xa3,0x6,0x98,0x85,0xf8,0x18,0xb2,0x36,0x0,0x90,
0xef,0xfd,0x43,0x96,0xf1,0x76,0xa0,0x5f,0xfe,0xb6,0x64,0x92,0x45,0xde,0xf,0xca,
0xa0,0x6f,0xa6,0xf4,0x0,0xe6,0xe0,0x77,0xe9,0xae,0x1,0x46,0x7b,0x64,0x9d,0x0,
0x3c,0xe8,0x91,0xd3,0x19,0x6,0x0,0xf2,0x96,0x7b,0xd2,0x32,0xe6,0xa,0xdc,0x93,
0x5d,0x1b,0x2b,0xd,0xb2,0x76,0x37,0x8d,0x55,0xf1,0xbc,0x5,0xf3,0x64,0xa7,0x65,
0x3b,0x84,0x4,0x51,0xf8,0x1c,0x21,0x33,0x90,0xdd,0xc8,0x2c,0xd,0x0,0x24,0xe2,
0xc7,0xe6,0x19,0xfd,0x4c,0x2,0x79,0xb6,0xb9,0xc0,0xc7,0xca,0xa1,0x6c,0x47,0x32,
0x1a,0x78,0x85,0xe2,0xff,0xba,0x21,0xcb,0x3c,0xdf,0xdb,0xe0,0x9f,0xc0,0x38,0x8f,
0xac,0x63,0xd1,0xf9,0x20,0x34,0x9c,0x4c,0xb2,0x27,0x16,0x60,0x8a,0x65,0xdc,0xbd,
0x88,0x81,0x84,0x50,0x8b,0x79,0x2,0xbd,0x2a,0xa1,0x6e,0x1d,0x4e,0x5f,0xe4,0x1b,
0x55,0x44,0x9e,0x84,0x4b,0xd1,0xed,0x1,0x8c,0x43,0x6e,0xb2,0xeb,0xc6,0x35,0x22,
0xee,0x61,0x9f,0xa7,0x6d,0xa,0xf0,0xac,0x43,0x8e,0x8f,0x69,0x88,0x8f,0x62,0x29,
0xc9,0x83,0x5c,0x6e,0xb3,0x8c,0x7d,0x7f,0x2,0x59,0x57,0x5b,0x64,0xf9,0x96,0xce,
0xa9,0x28,0x20,0xfe,0xf8,0xbe,0x1,0xed,0x7d,0x98,0x5d,0xc1,0xbf,0x43,0x17,0xf5,
0xda,0x80,0x84,0x70,0xfb,0x9c,0x3e,0xeb,0x91,0xcf,0x87,0x8b,0x5e,0xc0,0xed,0x98,
0xdf,0x2c,0x2e,0xae,0x6a,0xd3,0x67,0x13,0xc9,0xd6,0xde,0xdd,0xb1,0x7b,0x31,0xc7,
0x7,0xca,0x1a,0x6c,0x91,0x73,0x7d,0x2,0xbd,0xbc,0xbc,0xa,0xf8,0x11,0xfa,0xef,
0xa9,0xb6,0xed,0x46,0xbe,0x5b,0x9a,0xd7,0xea,0x68,0xfc,0x4e,0x9f,0x46,0xe4,0x29,
0xeb,0xe9,0x91,0x35,0x1e,0x89,0xbd,0xf7,0x19,0x40,0x1d,0x70,0xa7,0x65,0xac,0xed,
0xf8,0x3f,0x3f,0x26,0x6c,0x9f,0x82,0x65,0x9,0x64,0x2d,0x37,0xc8,0x59,0x93,0x40,
0x8e,0x93,0x53,0x29,0xff,0x8d,0x6f,0xdb,0x1e,0x46,0xd6,0xf1,0x3e,0xea,0x91,0xd,
0x90,0x96,0x9,0x1d,0xa6,0xf6,0xc,0xb2,0xb4,0x74,0xd1,0x0,0x7c,0x8d,0xe6,0x9d,
0x45,0x13,0xa3,0x70,0xef,0x3b,0xec,0x24,0x59,0x84,0xce,0x6f,0x2d,0xf2,0x26,0x4,
0xca,0x99,0x65,0x91,0x53,0xb6,0xfd,0x81,0x2e,0xc0,0x63,0x96,0x41,0xca,0xdd,0xe,
0x20,0xdf,0x35,0xd7,0x3a,0xbf,0xc4,0x28,0xe0,0x51,0x85,0xcc,0xb9,0xf8,0x97,0x46,
0xaf,0x6f,0x92,0x65,0xa3,0x7,0x70,0x97,0x63,0x8c,0xcd,0x84,0x5f,0xf0,0x51,0x98,
0x3f,0x43,0xf,0x4,0xca,0xb1,0x7d,0x6,0x3e,0x1c,0x28,0xc7,0xca,0x44,0xcb,0x0,
0x1d,0xd9,0xd6,0x20,0x3e,0x7e,0x1f,0x5d,0x81,0x2f,0xe0,0x77,0x1,0x6f,0x42,0xdc,
0xce,0x2e,0x6a,0x15,0xe3,0xcd,0xc2,0x3e,0xf,0x79,0x94,0xf0,0x4d,0x1e,0x53,0xdc,
0x5f,0x23,0xf0,0xea,0x40,0x39,0x4f,0x18,0xe4,0xfc,0x2c,0x50,0x86,0x95,0x1b,0xd,
0xc2,0x3b,0xa3,0x35,0x2,0xdf,0x44,0xb7,0x7d,0x3a,0x1c,0xd9,0x38,0xf2,0xc9,0xbc,
0x7,0xd9,0x88,0x4a,0xc3,0xc5,0xd8,0x8d,0xe0,0x96,0x40,0x59,0x63,0x2d,0x72,0x42,
0x27,0x71,0xdf,0x35,0xc8,0x78,0x2e,0x50,0x86,0x95,0x9f,0x5b,0x94,0xec,0xac,0xb6,
0x1,0x9,0x37,0xf7,0xd1,0x5,0xf8,0x2c,0xb2,0x4c,0x73,0xc9,0x7b,0x1e,0xd9,0x92,
0x4e,0xc3,0x65,0x16,0xd9,0x8d,0xc0,0x59,0x81,0xb2,0x4c,0x86,0xfb,0x1f,0xc2,0x76,
0xb,0x2f,0xb2,0xe8,0x53,0x96,0x79,0xc0,0x3c,0x8b,0xf0,0xce,0x6e,0x73,0xd1,0xa5,
0x47,0xd,0xc5,0xbd,0x15,0x5b,0x6a,0xf3,0x90,0x20,0x95,0xa4,0xd8,0xb2,0x78,0x56,
0x13,0xe6,0x28,0x9a,0x69,0x91,0x33,0x36,0x40,0xc6,0x0,0x8b,0x8c,0xf3,0x3,0x64,
0x58,0xc9,0x8b,0x1,0x14,0x81,0xff,0x22,0x4f,0xaf,0xcf,0x81,0x54,0x83,0x24,0x87,
0xec,0xf1,0xc8,0xdb,0x2,0xbc,0x27,0xd1,0x55,0x91,0xf9,0xc7,0x23,0x16,0xb9,0x97,
0x6,0xc8,0xe9,0x83,0x79,0xe,0x73,0x53,0xa0,0x3e,0x9b,0xd,0x32,0xae,0xd,0x94,
0x61,0x24,0x4f,0x6,0x50,0x6a,0xf3,0xd1,0x65,0xcc,0x9e,0x48,0x73,0xf1,0x7,0x57,
0x5b,0xa0,0x94,0xd7,0x96,0x11,0x98,0x83,0x53,0xd7,0x11,0xf6,0xa,0x37,0xc5,0xd,
0x3c,0x1e,0xa8,0x8b,0x69,0x59,0x79,0x6f,0xa0,0xc,0x23,0x79,0x34,0x80,0x22,0xb0,
0xd,0x78,0x3f,0xfe,0xb7,0x41,0x1,0x9,0x3d,0xf7,0x6d,0xf,0x97,0xdc,0xd3,0xa1,
0xcc,0xb1,0xc8,0xf3,0xad,0x3a,0x5a,0x72,0xb9,0x45,0x46,0xc8,0x27,0xea,0x3b,0x86,
0xfe,0x7f,0xb,0xe8,0x6f,0x25,0xaf,0x6,0x50,0x6a,0x8b,0xd1,0x6d,0xa4,0xc,0x42,
0x92,0x51,0x7c,0xf2,0x16,0x21,0xc9,0x2d,0x5a,0x6,0x62,0xe,0xd6,0xc,0xf1,0xed,
0x9f,0x6c,0xd1,0xe5,0x82,0x0,0x19,0x1f,0x35,0xf4,0xdf,0x16,0xd0,0xdf,0x4a,0xde,
0xd,0xa0,0x48,0x73,0x48,0xb9,0x66,0x2d,0xff,0x1,0xfc,0xe9,0x6b,0x3b,0x80,0xf,
0xa1,0x4f,0x58,0x31,0xc5,0x37,0x1e,0xc0,0xef,0x8e,0x6e,0x89,0x29,0x50,0x36,0x24,
0xe4,0xfb,0x3c,0x43,0xff,0x22,0xc9,0x43,0xd1,0x5f,0xa6,0x12,0xc,0xa0,0xd4,0x56,
0x22,0x6e,0x6b,0x1f,0x3,0x71,0x57,0xa,0x29,0xb5,0xc5,0xe8,0x96,0x52,0xe3,0x30,
0xcf,0x5,0x2e,0x52,0xf4,0x2d,0xf1,0x80,0xa1,0xff,0xc2,0x80,0xfe,0x63,0xc,0xfd,
0x8b,0xa4,0x4f,0xbf,0xab,0x28,0x3,0x28,0x22,0x7b,0x4,0x5f,0x42,0xe7,0x4e,0xbe,
0x4,0xff,0x1e,0xc7,0x2e,0xe0,0xa,0xfc,0x6f,0x83,0x37,0xd0,0x3e,0x33,0xf9,0x56,
0x85,0xe,0x25,0xae,0x33,0x8c,0xfd,0x54,0x40,0xff,0x21,0x86,0xfe,0x45,0xca,0x90,
0x49,0x5c,0x69,0x6,0x50,0x6a,0x4f,0x0,0x67,0x28,0x7e,0x5f,0x7f,0xe4,0x7b,0xed,
0x93,0xb7,0xc,0xbf,0x8b,0xb6,0x2b,0x30,0x9b,0x66,0x67,0x54,0xc8,0x24,0x6c,0x86,
0x61,0xcc,0x43,0xe8,0x3e,0x6b,0x20,0x3e,0x12,0x93,0xde,0xbe,0xed,0x71,0x2f,0x95,
0x6a,0x0,0x45,0x9a,0x3,0x45,0x34,0xee,0xe4,0x69,0x48,0x59,0x1b,0x97,0xbc,0x3d,
0xc0,0x27,0xf1,0x3b,0x7a,0x86,0x2,0x7f,0x42,0x26,0x87,0xda,0xe5,0xe0,0x99,0x96,
0x31,0x7,0x28,0xfb,0x77,0xb3,0xf4,0x4f,0x9d,0x40,0x5a,0xc9,0x6,0x50,0x6a,0xff,
0x6,0xde,0xae,0xf8,0xad,0xc7,0xa0,0x73,0x7d,0x3f,0xc,0xbc,0xc6,0x23,0xab,0x6,
0x59,0x7e,0x6a,0x97,0x72,0xb6,0x95,0xc0,0x48,0x65,0xff,0x5a,0x4b,0xff,0x29,0xca,
0xfe,0x56,0xaa,0xc1,0x0,0x4a,0xed,0x2e,0x74,0x9b,0x41,0x17,0x22,0x5e,0x47,0x97,
0xac,0x7d,0xc8,0xeb,0x5e,0xfb,0x8a,0xf6,0x61,0x7b,0x85,0x6b,0xe3,0x3,0xa,0x96,
0xfe,0x21,0x4b,0x49,0x23,0xd5,0x64,0x0,0x45,0xc4,0x65,0x3a,0x15,0xff,0xa4,0x4e,
0x9b,0xbe,0xf6,0x8,0xe2,0x11,0x4c,0x4b,0x83,0x45,0xfe,0x39,0xca,0xfe,0x75,0x96,
0xfe,0x21,0xe,0x29,0x23,0xd5,0x66,0x0,0xa5,0xb6,0x0,0xdd,0xf7,0x55,0x9b,0xbe,
0x76,0xd,0xe9,0xca,0xb8,0xd5,0x58,0x64,0x6b,0x9f,0xe0,0x3e,0x96,0xfe,0x6f,0x4d,
0xa1,0x13,0x50,0xbd,0x6,0x50,0xa4,0xb9,0x5e,0x91,0x6f,0xa2,0xd6,0xb,0xf8,0xa1,
0x42,0xde,0x6a,0x24,0xba,0x28,0x9,0x69,0xbf,0xe1,0x83,0x2c,0xfd,0x4f,0x4f,0xa8,
0xcf,0xcb,0x54,0xb3,0x1,0x94,0xda,0x12,0x74,0x51,0x38,0x13,0x91,0x9,0xa5,0x4b,
0xd6,0x21,0xe0,0x2b,0xe8,0xfc,0x10,0x2d,0xe9,0x61,0x91,0xa7,0x99,0xbc,0x82,0xf8,
0x21,0x4c,0xfd,0x93,0xa4,0x9e,0xb5,0xe2,0x70,0x30,0x80,0x22,0x92,0x9c,0xa1,0xa1,
0x7,0xe2,0xe0,0xf1,0x25,0xac,0x3c,0x9,0xbc,0x51,0x29,0x13,0x64,0xff,0xc1,0x24,
0x47,0x2b,0xe3,0x5c,0x4b,0xff,0x1e,0x5a,0x5,0x92,0xe4,0xab,0x57,0x13,0xda,0x78,
0xbe,0x9d,0x48,0x10,0xc7,0x4,0x24,0xf,0xc1,0xc6,0x50,0x24,0x64,0xfb,0x66,0x74,
0x75,0x7c,0x8e,0x40,0xde,0x1e,0x6d,0xd9,0xa2,0xd4,0xcb,0x54,0x5a,0x7e,0x67,0x53,
0x4b,0xc5,0xe1,0xf2,0x6,0x28,0x26,0xb8,0x36,0xa5,0xf4,0x35,0x5f,0xc2,0xca,0x3a,
0x74,0xa1,0x62,0x23,0x68,0x1f,0x64,0xa2,0xdd,0xcc,0xb9,0xd9,0x30,0xee,0x6a,0x65,
0x5f,0x27,0xd1,0x0,0xfc,0x8c,0x5,0xfe,0xe1,0x91,0xdd,0x88,0x4,0x8d,0xfa,0xbc,
0x92,0xb5,0x48,0xb2,0xe8,0x5e,0xf4,0x4f,0x3f,0x98,0x6b,0x33,0xde,0x17,0xd0,0xdf,
0x4a,0x34,0x0,0x1d,0xa5,0xf4,0x35,0x5f,0xf9,0xba,0xd,0xe8,0x9c,0x3b,0x27,0x35,
0xc9,0xd3,0x62,0xca,0x79,0x2c,0x4b,0x5,0xb1,0x68,0x0,0x61,0x9c,0x8e,0xae,0x66,
0xd1,0xed,0x84,0xc5,0xb,0xb8,0xe8,0x6f,0x19,0x63,0x6a,0x39,0x84,0x67,0x1d,0x16,
0x5e,0x69,0x6,0x0,0xe2,0x95,0xfb,0x32,0xfe,0xf4,0xb5,0x8d,0x94,0xa7,0xda,0xe7,
0xf9,0x16,0xf9,0xa9,0x97,0x80,0x20,0xb9,0x73,0x59,0xdf,0x98,0x4a,0x33,0x80,0x12,
0x23,0xd1,0xa5,0xaf,0xdd,0x89,0x78,0xf2,0x92,0x62,0xa,0x51,0x7f,0x21,0x85,0xbc,
0x56,0xd8,0xce,0x0,0xa8,0xc6,0x16,0x4a,0x2f,0xfc,0xf1,0x83,0xda,0xf4,0xb5,0x67,
0x81,0xc9,0x9,0x74,0x0,0x73,0xee,0xe6,0xfc,0x84,0xb2,0xda,0x51,0x83,0xce,0x8a,
0xab,0xa1,0x85,0x32,0x7,0x89,0x1f,0x9c,0x89,0xdf,0x8f,0x32,0x1c,0x73,0x5d,0x9f,
0xb6,0xed,0xa7,0x48,0x4d,0x5,0x2d,0x36,0x7,0xd2,0x15,0x1,0x32,0xbc,0xc,0xc3,
0x1f,0x2c,0x51,0xd,0x2d,0x84,0xc9,0x6d,0xfa,0x2e,0x45,0xf6,0xf4,0x5d,0x68,0xd3,
0xd7,0x36,0x3,0xef,0x52,0xea,0x31,0x9,0xb3,0x57,0xd2,0xa7,0x4b,0x30,0x3,0x91,
0x1a,0xf5,0xa6,0xc,0x94,0x6a,0x69,0x5a,0x86,0x61,0x3e,0x92,0x66,0x1f,0xfe,0xea,
0x65,0xa0,0x4f,0x5f,0xbb,0xf,0xa9,0x6f,0xe4,0x63,0x2c,0xad,0xab,0x90,0xad,0xd3,
0xff,0x94,0x64,0x34,0x20,0x39,0xf7,0xda,0x36,0x9d,0xca,0x30,0x1c,0xd,0x83,0x91,
0xd9,0xbb,0xa9,0xff,0x4a,0xf4,0x1,0x22,0x35,0x48,0x65,0x14,0x5f,0xfa,0xda,0x56,
0x24,0x23,0xd9,0x47,0x3d,0x12,0xc,0x7b,0x80,0xe4,0x55,0x48,0x3b,0x94,0x3e,0xc0,
0xf7,0x48,0x7f,0xac,0x4b,0x96,0x6,0x30,0xc,0xfb,0xcd,0xdf,0x85,0x3c,0xd9,0xa1,
0x68,0xd3,0xd7,0x7e,0x85,0x2e,0x7e,0xe1,0x54,0xc4,0x89,0x94,0x5b,0x4e,0x43,0x97,
0xcb,0x9f,0x37,0x3,0x98,0x8c,0x3b,0xa1,0x44,0xfb,0xcd,0x36,0x51,0x40,0xd2,0xc3,
0x76,0x7a,0xf4,0xdb,0x86,0x14,0xdc,0xaa,0x78,0xba,0x20,0x25,0x4c,0xb6,0x91,0xfd,
0x4d,0xd7,0x18,0xc0,0x50,0xa4,0x98,0x95,0xad,0xdf,0xec,0x34,0x17,0xa3,0x5,0x83,
0x90,0xca,0x69,0x3e,0x3d,0x1f,0x44,0x8a,0x76,0x55,0x3c,0xc7,0xe2,0xae,0xbd,0x93,
0x17,0x3,0x0,0xd9,0xa9,0xfb,0x97,0xa1,0xcf,0xd,0x24,0x3b,0xf3,0xc8,0x85,0x36,
0x7d,0x6d,0x66,0x7,0x8c,0x9d,0x9,0x6f,0xa2,0x7c,0x35,0xff,0x3b,0xca,0x0,0x40,
0xe6,0x31,0x2d,0xab,0x7f,0xcf,0x26,0xfc,0x6,0x14,0x80,0x4f,0xe1,0xf,0x17,0xd7,
0xa6,0xaf,0xfd,0x81,0x2a,0x39,0x61,0xbc,0xe,0xf8,0x34,0xee,0x57,0x6d,0xd6,0x6,
0x0,0x32,0x7b,0xbf,0x8a,0xe4,0x1b,0x2d,0xd3,0x9b,0xc6,0xda,0xda,0xf4,0xb7,0xcf,
0x80,0x2e,0xc1,0x9f,0xbe,0xb6,0x1b,0xc9,0xe,0xae,0x8a,0xa0,0x9e,0xe3,0x91,0x13,
0x35,0xf2,0x6a,0x0,0x69,0x18,0x44,0xfb,0x57,0xfb,0x22,0xfc,0x9,0x9c,0xda,0xf4,
0xb5,0xe5,0x74,0x80,0x3,0x28,0x2b,0xce,0xc1,0x5f,0x31,0xbc,0x92,0xc,0xa0,0x1e,
0xfb,0x49,0xa0,0xda,0x4a,0x1e,0xef,0xc6,0xef,0x91,0xdd,0x8b,0xbc,0x49,0x93,0x16,
0xb4,0xce,0x15,0xd,0x48,0x9d,0x1b,0x53,0x1,0x86,0x4a,0x32,0x80,0x2,0xf6,0xb0,
0xf2,0x6d,0x84,0x9d,0xa7,0xdc,0xf,0xa9,0x1,0xe8,0xfb,0x2d,0x2b,0x10,0xbf,0x45,
0x55,0x70,0x12,0xba,0xe5,0x51,0x5e,0xd,0xe0,0x4a,0xc7,0x98,0x49,0x8b,0x54,0x5d,
0x80,0x3f,0x7d,0x6d,0x3f,0xf0,0x79,0xca,0x97,0xbe,0x96,0x29,0x5,0xc4,0xd9,0xe2,
0x2a,0xf7,0x9e,0x47,0x3,0xf8,0xa0,0x63,0xbc,0xb4,0x47,0xbc,0x1c,0x5,0xdc,0xed,
0x90,0x5f,0x6a,0x7f,0xa7,0x42,0x4f,0x15,0x33,0xd1,0x13,0x89,0x80,0xad,0x84,0xa3,
0x63,0x6d,0x5,0x25,0x8b,0x88,0x37,0x54,0x7b,0xec,0xab,0x6f,0x76,0xff,0xe,0xa4,
0xb8,0xa4,0xeb,0xb7,0x1d,0x40,0xf6,0xa,0xd2,0x1c,0x61,0x9b,0x2b,0x46,0x20,0x39,
0xf8,0x79,0x35,0x80,0x33,0x1c,0xe3,0x6c,0x44,0x9f,0xf7,0x7f,0x26,0xb0,0x16,0xff,
0x59,0x2,0xda,0xf4,0xb5,0xc7,0x28,0x43,0xd5,0x90,0xbc,0x50,0x3,0xbc,0x17,0xff,
0xb9,0xc4,0x59,0xbd,0x1,0x2e,0xa6,0xfd,0x6e,0xdf,0x8b,0xe8,0x27,0x67,0xc7,0x21,
0x35,0x7f,0x4b,0x7d,0x6f,0x43,0x6e,0xb4,0x8b,0xb3,0xf1,0xa7,0xaf,0x2d,0xa,0xf9,
0x11,0x95,0xc0,0xd1,0x48,0x94,0x6d,0xde,0xc,0x0,0x5a,0xbb,0x90,0xb7,0xa3,0x7f,
0xfa,0x1a,0x30,0x9f,0xf,0xb8,0x9,0xb9,0xc9,0x2e,0x5c,0xe9,0x6b,0xbb,0x28,0x43,
0xe1,0xa8,0xbc,0x32,0x6,0x99,0xf0,0xe4,0xc9,0x0,0x40,0x5c,0xc8,0x3f,0x41,0x9f,
0xa9,0x5b,0x83,0xfd,0x90,0xab,0x83,0xe8,0xf3,0x5,0xc7,0xd3,0x7e,0xff,0xa2,0xac,
0xa1,0x62,0x79,0xa4,0x16,0xf9,0x91,0xa6,0x88,0x9d,0xac,0xc,0x20,0x84,0x2,0x52,
0xd7,0xc8,0xa6,0xe3,0xac,0x40,0x79,0x47,0x22,0x65,0xf7,0x5f,0x42,0x3c,0x85,0x55,
0xb1,0x79,0xa4,0xa1,0x3f,0xf2,0xd4,0x55,0x92,0x1,0x14,0x90,0xdd,0x45,0x9b,0x7e,
0x77,0x93,0xfc,0x6,0x8e,0x25,0xe7,0x81,0x22,0x1d,0xc5,0x4,0x64,0x16,0x9d,0x77,
0x3,0x28,0xe0,0xce,0xc1,0x58,0x4e,0xf2,0x63,0xe7,0xf,0x7b,0xea,0x11,0x6f,0xdc,
0x5e,0xf2,0x69,0x0,0xb5,0xb8,0x27,0xb1,0x6b,0x49,0x7f,0xd2,0x49,0x4,0x29,0xfb,
0xfa,0x4b,0xf2,0x65,0x0,0x5,0xdc,0xbb,0x9f,0x4f,0x13,0x56,0xbc,0x3a,0xa2,0xe0,
0x3c,0xcc,0x47,0xc1,0x65,0xc5,0x59,0x98,0xfd,0xfa,0x1b,0xa9,0x92,0x60,0x8f,0x3c,
0xd2,0xd,0x39,0x9c,0xa9,0x65,0xca,0x56,0x96,0xc,0xa0,0x75,0xae,0xc0,0x7a,0xca,
0x78,0xf6,0x5f,0xc4,0xce,0x29,0x48,0x58,0x55,0xd6,0x6,0x0,0xe2,0xa7,0xbf,0x5,
0x71,0xd7,0x6a,0x5d,0xc5,0x91,0x32,0x50,0x20,0xf9,0xb6,0x6c,0x47,0x10,0x5a,0x61,
0x2c,0x12,0x89,0x44,0x22,0x91,0x48,0x24,0x12,0x89,0x44,0x22,0x91,0x48,0x24,0x12,
0x89,0x44,0x22,0x91,0x48,0x24,0x12,0x89,0x44,0x22,0x91,0x48,0x24,0x12,0x89,0x44,
0x22,0x91,0x48,0x24,0x12,0x11,0xfe,0xf,0x7d,0x39,0x34,0x76,0x86,0x4d,0x6,0x60,
0x0,0x0,0x0,0x0,0x49,0x45,0x4e,0x44,0xae,0x42,0x60,0x82,
// /home/cyrille/Documents/IHM/IHM_Lecteur_Audio/client_audio/resource/sound_low_2.png
0x0,0x0,0x10,0x59,
0x89,
0x50,0x4e,0x47,0xd,0xa,0x1a,0xa,0x0,0x0,0x0,0xd,0x49,0x48,0x44,0x52,0x0,
0x0,0x0,0x80,0x0,0x0,0x0,0x80,0x8,0x6,0x0,0x0,0x0,0xc3,0x3e,0x61,0xcb,
0x0,0x0,0x10,0x20,0x49,0x44,0x41,0x54,0x78,0x5e,0xed,0xdd,0x69,0x70,0x1c,0xd7,
0x79,0x86,0xd1,0xe7,0xbb,0xb7,0x67,0x6,0xb,0x41,0x11,0x10,0x69,0x6e,0x12,0x45,
0x5b,0x14,0x49,0x2d,0x5e,0x22,0x51,0xb1,0xc,0xae,0x20,0x9,0x2e,0x90,0x44,0x6a,
0x23,0x64,0x59,0x15,0x25,0xa9,0x4a,0xec,0xf2,0x56,0xc9,0xf,0x3b,0xb1,0x5d,0x8e,
0x15,0xb9,0x9c,0x54,0x9c,0xd8,0x71,0xa5,0x62,0xc7,0x76,0x12,0x27,0x8e,0x22,0x89,
0xd6,0x90,0x92,0x4d,0xd9,0xe6,0x62,0x51,0xa4,0x24,0xd2,0x34,0xa9,0xd0,0xb6,0xe4,
0x45,0xb2,0x44,0x89,0x52,0x8,0x92,0x96,0x44,0x10,0xe0,0xa,0x60,0x66,0xba,0xfb,
0x66,0x50,0x85,0x2a,0x57,0x39,0x14,0xee,0x47,0x7a,0x8,0xc,0xa0,0x7b,0xaa,0xe6,
0x17,0xd0,0x17,0x8d,0xb9,0x6f,0x7f,0x5f,0x2f,0x33,0xdd,0xe2,0x9c,0xe3,0xcd,0x2b,
0x30,0x9c,0x2f,0x41,0x8,0x40,0x10,0x2,0x10,0x84,0x0,0x4,0x21,0x0,0x41,0x8,
0x40,0x10,0x2,0x10,0x84,0x0,0x4,0x21,0x0,0x41,0x8,0x40,0x10,0x2,0x10,0x84,
0x0,0x4,0x21,0x0,0x41,0x8,0x40,0x10,0x2,0x10,0x84,0x0,0x4,0xb,0xe6,0x2c,
0x98,0xdc,0x7c,0x6d,0xf3,0xef,0x5d,0x77,0xed,0xbc,0xd6,0x79,0xd7,0xcc,0x9b,0xff,
0x9e,0x6b,0x16,0x5e,0xde,0xdc,0xdc,0x5c,0xcb,0x79,0x56,0x5,0x1f,0x8,0x9,0x9a,
0xaf,0x69,0x9e,0x1,0x76,0x36,0xbf,0xc5,0x59,0xfa,0x6c,0xd6,0xed,0xd9,0xb9,0x73,
0xe7,0xc9,0x51,0x5a,0x1,0x82,0xeb,0xae,0x6b,0xb9,0xe8,0x4c,0x93,0xf,0x20,0x9,
0x35,0xae,0xcf,0xbd,0x67,0xce,0x9c,0x39,0x99,0x51,0x1a,0x80,0xc0,0xa6,0x6e,0x32,
0x83,0x70,0xce,0x64,0x6b,0x4c,0xcd,0x4c,0xce,0x93,0x88,0x61,0x15,0x88,0x8b,0xc7,
0x99,0x48,0x18,0x4c,0x9a,0x98,0xe9,0xef,0x7c,0xe7,0xf2,0x57,0x9e,0x79,0x66,0xcb,
0xe9,0x51,0x56,0x1,0x2,0x11,0x71,0x78,0x18,0xeb,0xa4,0xa1,0xa6,0x78,0xf9,0x28,
0x6c,0x1,0x41,0x92,0x9a,0xd7,0x50,0x10,0xe2,0x49,0xe5,0xa3,0x82,0xa6,0x51,0x16,
0x80,0x20,0xb1,0x7d,0x87,0x51,0x32,0x49,0xf6,0xca,0x51,0x16,0x80,0x60,0xcf,0x9e,
0x3d,0x47,0x31,0x1c,0x41,0x41,0x48,0x2e,0x58,0xd2,0xbc,0x64,0x6a,0x95,0x5,0x20,
0x10,0x11,0xd3,0x32,0xa7,0x65,0xfc,0xfc,0x39,0xf3,0xa7,0xb5,0x5c,0xd5,0x32,0x86,
0xb3,0xe4,0xac,0x7b,0x56,0x10,0x7,0x11,0xbe,0x57,0x29,0x76,0xb3,0xdb,0xdb,0xdb,
0x6d,0x95,0x9c,0x8,0xa,0x16,0x5e,0xb7,0xf0,0xb2,0x34,0x35,0x97,0x22,0x44,0xc,
0xc0,0x70,0xaa,0xb7,0x74,0xf2,0xa9,0xbd,0x7b,0xf7,0xf6,0xa8,0xc7,0x69,0x5e,0xf8,
0xf6,0x34,0x31,0x97,0xa0,0x60,0x24,0x7d,0xfe,0x89,0xdd,0x4f,0xec,0x1b,0xe6,0xa,
0x10,0xcc,0xff,0xfd,0xf9,0x6f,0x4b,0x9d,0x99,0x85,0x10,0xf1,0x1b,0x90,0x32,0xa6,
0x36,0xd3,0xd0,0xac,0xaf,0x6,0x70,0xf8,0xc8,0xe1,0x17,0x70,0xc4,0x28,0xf4,0x7,
0xae,0xed,0xb2,0xb6,0xdc,0x30,0x9e,0x7,0x8,0x5a,0x5a,0x5a,0x6a,0x88,0xa2,0x2b,
0x78,0x63,0x35,0xe9,0x58,0xf3,0xe,0x60,0x17,0xa,0xfb,0xf6,0xed,0x2b,0xb4,0x34,
0xb7,0xbc,0x18,0xc3,0x6c,0xfc,0xa2,0xd3,0x13,0x4e,0xcf,0x4,0x7e,0x3e,0x5c,0x15,
0x20,0x38,0xcd,0x38,0x3c,0x52,0xd2,0xa6,0x5,0xb,0x16,0x4c,0x46,0x69,0xd1,0xf2,
0x45,0xfb,0x5,0xe9,0x45,0x41,0x9c,0x5c,0x54,0xe,0x61,0x34,0x4c,0x1,0x8,0x62,
0xb1,0x63,0x51,0x90,0x24,0x73,0xf9,0x3d,0xf7,0xdc,0x63,0x50,0xb8,0xfb,0xee,0xbb,
0xd3,0xd4,0x44,0xcf,0xa1,0x90,0x88,0xd8,0x38,0x8e,0xa7,0xbc,0xe9,0x77,0x2,0x17,
0x35,0x2f,0xae,0x5,0x6e,0x6,0xde,0xa,0x3c,0xf6,0xf8,0xae,0x6d,0xbb,0x19,0x2,
0xe5,0x2d,0x7b,0x82,0x8d,0xed,0xbb,0xd1,0xf9,0xd5,0xf6,0x5d,0xdb,0x5f,0x44,0x69,
0xf1,0x7b,0x16,0xcf,0x75,0xe2,0x1a,0x15,0x55,0xa0,0x7b,0xdb,0x8f,0xb6,0xfd,0x70,
0xf4,0x55,0x0,0xfd,0xe4,0xaf,0x4,0xe,0x0,0xf7,0x3,0x9f,0x3,0x76,0x95,0x3,
0xf1,0x17,0xc,0x81,0x1d,0x3b,0x76,0x74,0xa6,0xa9,0x29,0xa2,0x33,0xa3,0xad,0x4d,
0xbf,0xd3,0x56,0x8a,0x4a,0xcf,0xa2,0xd0,0x1f,0x92,0x72,0x1b,0x18,0xf3,0xa6,0xab,
0x0,0x8b,0x9a,0x97,0xd8,0x81,0x9,0xff,0x4b,0x40,0x18,0x30,0xa0,0x8,0xbc,0xed,
0xf1,0x5d,0x8f,0x1d,0xe2,0x3c,0x9b,0xff,0xee,0xa5,0x33,0x23,0xcb,0x4c,0x14,0xc4,
0xa6,0x1d,0xdb,0x76,0x6c,0x7b,0x6,0xa5,0x96,0xeb,0x5a,0xe6,0x61,0xec,0x38,0x3c,
0x92,0x94,0xfd,0x4f,0xee,0xde,0xfa,0xec,0x9b,0xa6,0x2,0xb4,0xcc,0x5d,0x32,0x55,
0x84,0xed,0x22,0x7c,0x42,0x4,0x11,0x81,0xdf,0x7a,0x65,0x45,0x98,0xc9,0x10,0x98,
0x7c,0x49,0xd3,0x4b,0x42,0xda,0x8b,0x82,0x4b,0xcc,0xc5,0xad,0xad,0xad,0x17,0xa0,
0x64,0xac,0xe9,0x40,0xc1,0x44,0x4c,0x95,0xb2,0x91,0x1d,0x0,0xfd,0xe4,0xaf,0x0,
0x9e,0x6,0xe6,0x33,0xb8,0x2c,0xfa,0x31,0xa5,0xfc,0x7a,0x7b,0xf9,0x35,0x8e,0xb3,
0x94,0xcf,0xe7,0x93,0x48,0xb9,0xd3,0x6,0x90,0x9e,0x4e,0xaf,0x44,0x29,0xcd,0xa6,
0x87,0x9c,0x71,0x9,0x1e,0x92,0x92,0x5b,0x74,0xed,0xa2,0x89,0xa3,0xba,0x5,0xb4,
0xcc,0x5d,0x6a,0x81,0xcf,0x2,0x9f,0x4,0x4,0xbf,0x95,0xdb,0x7f,0xb8,0x75,0xb3,
0x67,0xcc,0x31,0xc0,0xdf,0x1,0x37,0x3,0x53,0x0,0x7,0x3c,0xf,0xfc,0x79,0x79,
0xd9,0x2d,0xe8,0x51,0x3e,0x3f,0xdf,0x9c,0x22,0x4d,0x28,0x14,0x88,0x76,0xed,0xda,
0xb5,0xb9,0x4b,0x17,0xce,0x65,0xef,0xc2,0xa5,0x17,0xe1,0x91,0xe0,0x5e,0x7f,0x72,
0xd7,0x63,0x4f,0x8d,0xca,0x13,0x41,0x8b,0xe7,0x2d,0x9d,0x22,0xc2,0x5a,0x60,0x41,
0x5,0xc7,0x8c,0x44,0x58,0x7,0xac,0xe0,0x37,0x4,0x98,0xd,0x7c,0xaf,0xfc,0xf3,
0xf,0x6e,0xdb,0xb9,0xf5,0xdf,0x51,0x32,0xf5,0xe6,0x97,0xae,0xc0,0x3c,0xe7,0x9c,
0xe0,0x91,0x4b,0xd3,0x69,0x80,0x2a,0x0,0x36,0x4e,0x3b,0x92,0x2c,0xde,0x0,0x44,
0xa9,0x99,0xd0,0x7f,0x62,0x6a,0xfb,0xf6,0xed,0x7d,0x9c,0x25,0x53,0xe5,0x93,0xbf,
0xc,0x78,0x5a,0x3d,0xf9,0x7a,0xf7,0x0,0x2b,0x6,0xd9,0x28,0xbe,0x56,0xe,0xc1,
0x3b,0x50,0x7a,0xf4,0xd1,0x47,0x8f,0x1b,0x9c,0xae,0x67,0x4b,0x32,0x59,0xfb,0x19,
0xbf,0xad,0x7b,0xb6,0x1e,0xb5,0x8e,0xd3,0x78,0x38,0xe3,0x84,0x42,0xee,0xa2,0x51,
0x53,0x1,0x16,0xcf,0x6b,0xb5,0xc0,0x3d,0x20,0x9f,0x2,0x84,0x8a,0x93,0x45,0xc,
0xce,0x2,0xff,0x52,0x5e,0x8f,0xf9,0xdb,0x76,0x3e,0xea,0x50,0xc8,0xfe,0x3a,0xfb,
0x7c,0xef,0xa4,0xe2,0x14,0x5f,0x55,0x4d,0x45,0x6c,0x43,0x66,0xc2,0x54,0xe0,0x15,
0x14,0x92,0x34,0xea,0xc0,0xc6,0xb3,0xf1,0xb0,0x26,0xbe,0x18,0x78,0x71,0xc4,0x7,
0x60,0xc9,0xfc,0xd6,0xc9,0x3,0x25,0x7f,0x21,0xe7,0x89,0x8,0x57,0xe2,0x37,0x17,
0xf8,0x23,0xe0,0x3f,0x51,0xd8,0xb8,0x6f,0x63,0xa1,0xa5,0x65,0xf9,0x2b,0x36,0x4e,
0x66,0xe0,0xe1,0xb2,0xe9,0x34,0x6d,0x0,0xc8,0x15,0xe,0x4a,0x12,0xcd,0x32,0xbe,
0xf6,0x22,0xd4,0xaf,0x9a,0xb3,0xaa,0xee,0x91,0xbd,0x8f,0xf4,0xa0,0x87,0xa9,0xb2,
0xc9,0x6f,0x1d,0x28,0xf9,0xb,0x39,0xbf,0x5e,0x47,0xe7,0xf3,0xe5,0x40,0x36,0xa2,
0xd4,0x70,0x32,0x77,0x0,0x5,0x49,0x93,0xb1,0xe5,0x9e,0x3d,0xe,0x85,0xfe,0xbe,
0x2e,0xa4,0x47,0x50,0x38,0x9d,0x3d,0xdd,0x38,0x22,0x2b,0xc0,0xd2,0x5,0xcb,0x2c,
0xf0,0xd7,0x22,0xf2,0xa9,0xa1,0x8,0xa5,0x88,0x7c,0x13,0xf8,0x1b,0xfc,0x26,0x0,
0x7f,0xb,0x7c,0x10,0x85,0xfe,0xad,0xaf,0x75,0x5e,0x6b,0xa7,0x13,0x33,0x1e,0xf,
0x9b,0x64,0xa6,0x1,0xc7,0x50,0xc8,0x90,0xe9,0x88,0x71,0x6f,0xc1,0x23,0xca,0xd1,
0x8,0x1c,0x42,0xf,0x53,0x5,0x93,0x3f,0x19,0xd8,0xa,0x7c,0x7a,0x8,0xd7,0xe7,
0x9b,0x40,0x2f,0x3a,0xef,0x2f,0x7,0xf4,0x6a,0x94,0x4,0x39,0x80,0x82,0x4b,0xd3,
0xa9,0xda,0xab,0x79,0x7,0xbb,0xe,0x1e,0x45,0x21,0x4e,0x69,0xe2,0x2c,0x99,0xe1,
0x9d,0xfc,0xe5,0x4b,0x41,0x9e,0x6,0x59,0x4,0x42,0x25,0x5f,0x83,0xd9,0xfa,0xe4,
0xf,0xe,0x83,0x7c,0x4e,0x39,0x96,0x1,0xf9,0x18,0x4a,0x73,0x5b,0xe7,0xbe,0xea,
0x8c,0x2b,0xe2,0x21,0x82,0x8d,0xe2,0x68,0xa,0xa,0xbf,0xf8,0xc5,0x2f,0x8a,0x38,
0x39,0x8d,0x87,0x71,0xd2,0xe0,0x9,0x55,0x75,0xb4,0x80,0xd6,0x85,0xcb,0xd,0x70,
0xb7,0x88,0x76,0xab,0xaf,0x3c,0x11,0xbe,0x0,0xdc,0x5,0xcc,0xc2,0xef,0xd6,0xf2,
0x3a,0x4f,0x7c,0xf4,0x89,0x2d,0xaf,0x69,0x2e,0xe9,0x2e,0x7d,0xac,0xed,0x20,0x24,
0x6f,0xc3,0xc3,0x64,0xcc,0x4,0xe0,0x0,0xa,0x51,0x96,0xae,0xb8,0x44,0x3d,0x83,
0x70,0xce,0x9,0x34,0x8c,0x3,0x3a,0x51,0x32,0xc3,0x30,0xf9,0x93,0x80,0xad,0xc0,
0x67,0x86,0xb3,0x2,0x95,0x27,0xb3,0x8,0x7c,0x18,0x9d,0x2c,0xf0,0x27,0x28,0x25,
0xb6,0x57,0x35,0xa9,0x89,0xbe,0x64,0x93,0x94,0x92,0x6e,0x14,0x6c,0xdc,0xd3,0x54,
0xb5,0xa7,0x82,0x5b,0x17,0xae,0x58,0x2,0xdc,0xf,0x4c,0xe4,0xfc,0x5a,0xf9,0xe8,
0x13,0x9b,0x37,0x2b,0xd7,0x69,0x2d,0xf0,0x5e,0xfc,0x3a,0x80,0xb7,0x96,0xc7,0x4d,
0x50,0x58,0xb6,0x60,0xd9,0xdc,0xd4,0x49,0x23,0x1e,0x75,0x8d,0xb9,0x6d,0x8f,0x3c,
0xe2,0x3f,0x74,0x9b,0x37,0x6f,0x75,0x43,0x8d,0xf4,0x2d,0xc4,0xc3,0xc2,0x91,0x2d,
0x3b,0xb6,0xec,0xa9,0xaa,0x16,0xb0,0x6c,0xd1,0xa,0x19,0x28,0xf9,0x7f,0x5,0x18,
0xaa,0xc8,0x40,0x1b,0xba,0x1d,0x10,0x6,0x77,0x31,0xb0,0xa,0xf8,0x36,0xa,0x36,
0xb2,0x9d,0xe2,0x52,0x6f,0x0,0xe2,0x93,0x71,0x13,0xe0,0xd,0xc0,0xce,0x9d,0x1b,
0x4e,0xb6,0x2e,0x5e,0x59,0x32,0x2e,0xcd,0x30,0x88,0x4,0x69,0x94,0x32,0x57,0x56,
0x4d,0x2d,0xe0,0x73,0xc0,0xdd,0x80,0xa1,0xca,0xfc,0xe0,0xf1,0xcd,0x2f,0x1,0x9b,
0xd0,0xf9,0x10,0x4a,0x69,0x21,0xed,0x46,0xc1,0x25,0xae,0x9,0x25,0x1b,0x3b,0xef,
0x98,0x16,0x17,0xad,0x9a,0xbb,0x6a,0xc,0x4a,0x91,0x7e,0x2b,0x5e,0xd9,0x6,0xfc,
0x29,0x50,0xcb,0xff,0xd7,0x9,0x7c,0xe9,0x7,0x8f,0x6f,0xfa,0xf1,0x19,0x96,0x1b,
0xb,0xf2,0x31,0xaa,0x9a,0x7c,0x5,0x68,0xc3,0x6f,0x49,0xf9,0xff,0x19,0x5f,0xfe,
0x3f,0x3b,0xf1,0x38,0x5a,0x38,0xda,0x7d,0x61,0xf6,0x42,0x7c,0x62,0x8b,0x3a,0x0,
0xa9,0xa4,0xdd,0x82,0xbc,0x5,0x8f,0x1e,0x71,0x8d,0xc0,0xc9,0x8a,0x5,0x60,0x79,
0xcb,0xca,0x71,0x22,0xe4,0x81,0x7a,0xde,0xd8,0x15,0xc0,0xd5,0x67,0x28,0xb1,0x6f,
0x7,0xb2,0x54,0x31,0x11,0x36,0x3,0xfb,0x1,0xdf,0x9e,0xbb,0x0,0xf3,0x35,0x6d,
0xa0,0xfc,0xa5,0x90,0xd2,0xb2,0xc5,0x6d,0x27,0xc5,0x25,0xd,0xc,0xc2,0x90,0x8e,
0xb9,0xea,0xaa,0xab,0xb2,0xfd,0x87,0x7a,0x78,0x94,0x4c,0x4d,0x77,0x96,0x2,0x3e,
0x36,0x53,0x6c,0x54,0x1f,0x5d,0xa0,0x22,0xd3,0x3c,0x93,0xf,0x70,0x19,0x67,0x24,
0x75,0x54,0xb9,0x2d,0xdb,0x37,0xa5,0xcb,0x5b,0xda,0xbe,0xa,0xfc,0x3,0x7e,0xb,
0xb4,0xfb,0x1,0x99,0x44,0xba,0x62,0x13,0x35,0xe0,0x31,0x69,0xd2,0xa5,0x8d,0xc0,
0x6b,0x78,0x9d,0x3c,0x26,0x92,0x73,0xce,0x59,0x61,0x10,0xe,0x6a,0x2a,0xda,0x2,
0x44,0xa8,0xc5,0xaf,0xf7,0xd,0x96,0xad,0x63,0x4,0x10,0xe1,0x41,0x75,0x0,0x94,
0x9c,0x71,0xdd,0x20,0x97,0xe0,0x21,0xa5,0xa4,0x9,0x78,0x4d,0x71,0x5d,0x20,0x5e,
0xbe,0xa4,0xad,0x17,0x47,0x9d,0xe7,0x5a,0x43,0x16,0x25,0x83,0x8a,0x2e,0x0,0x9e,
0x65,0xab,0xda,0xe6,0x6d,0x1b,0x3b,0x94,0x57,0xe8,0xde,0xb5,0x62,0x71,0xdb,0x5,
0x28,0x44,0xd,0x51,0x17,0xa,0x36,0x8a,0x1b,0x50,0x92,0x24,0x2d,0xe1,0xe1,0xac,
0xc9,0xa0,0x14,0xa1,0x22,0xaa,0x0,0xf8,0x5a,0x40,0xf5,0x93,0x1d,0xc0,0x74,0xc5,
0x46,0x33,0x17,0xd8,0x88,0x47,0xff,0xf1,0xfd,0xf2,0xa5,0xd7,0x17,0x48,0xc8,0x31,
0x8,0x49,0xb3,0x59,0x94,0x9c,0xb1,0x45,0x1c,0x83,0x92,0x54,0xb2,0xa1,0x5,0x9c,
0x3,0x11,0x76,0x0,0x7f,0xa0,0x6c,0x3,0x1b,0x51,0x10,0xa4,0xcf,0x59,0x97,0x63,
0x10,0xa9,0x8b,0xb3,0x28,0x59,0xeb,0x8a,0x89,0x13,0x6,0xe3,0x20,0xf2,0x9f,0xb,
0xa8,0x7c,0xb,0xe8,0xf1,0x2e,0x5b,0xfd,0x9e,0x44,0x67,0x6,0x4a,0x36,0x75,0x45,
0xa8,0xdc,0x16,0x6b,0x62,0x53,0x42,0x61,0xcd,0x95,0x6b,0x32,0x95,0x6c,0x1,0x35,
0x6f,0x86,0x16,0xb0,0xe9,0xb1,0xef,0x3f,0xbf,0x72,0xc9,0xd,0xc7,0x1,0x5f,0x8f,
0x1f,0x8f,0x92,0xb3,0x51,0x11,0x17,0x7b,0x7e,0x47,0xbf,0xc5,0x3a,0xeb,0x8a,0x28,
0x1c,0x99,0x40,0x16,0x28,0x86,0x16,0x70,0x96,0x44,0x78,0xbd,0x92,0x1,0x30,0x71,
0x52,0x12,0x8b,0xd7,0xca,0x95,0x2b,0xb3,0x40,0x1,0x8f,0x34,0x93,0x2d,0x46,0xa5,
0x22,0x3e,0x92,0x3b,0x91,0xd,0x3b,0x81,0xe7,0x44,0x3a,0x81,0xcb,0xb4,0x1,0xd0,
0x6d,0xb1,0x16,0x9f,0xcc,0x9,0x51,0x5,0x20,0x2a,0xc6,0xa5,0x54,0x91,0xa8,0x5c,
0x1c,0x65,0xc2,0x61,0xe0,0xb9,0xe9,0xc4,0xef,0xc2,0xb6,0xa5,0x37,0xa,0xa,0x69,
0x92,0x2d,0xa2,0x50,0x18,0x53,0xc8,0xa0,0x90,0xe4,0x12,0xd5,0x78,0x7d,0x25,0x39,
0xc7,0xa,0x10,0x5a,0x40,0xa7,0xb2,0x72,0x8e,0x3,0xba,0xf1,0x48,0x32,0x69,0xd1,
0xa4,0x78,0x59,0x6b,0xb3,0x28,0xf4,0xf6,0xe6,0x4a,0x75,0x36,0xc1,0x27,0x93,0x8d,
0x2b,0xba,0x13,0x98,0xc5,0xaf,0xc8,0x19,0x49,0x8e,0xa1,0xe7,0x7e,0xa7,0x16,0xa0,
0x33,0x5e,0x13,0x80,0x9a,0x92,0x2b,0x26,0x16,0x2f,0x5b,0xd4,0x5,0xa0,0xa1,0x21,
0x29,0x26,0x3d,0x78,0x19,0x63,0xb2,0x95,0x6c,0x1,0x5,0xfc,0x72,0x9c,0x59,0x1f,
0x43,0x4f,0x86,0x20,0x3c,0x82,0x42,0x64,0x23,0x47,0xd5,0xd2,0xb7,0x80,0x5e,0xfc,
0x6a,0xfd,0xcb,0x56,0x3f,0x11,0xc6,0xa3,0xd3,0x89,0x42,0x4f,0x24,0x59,0xeb,0xf0,
0x2a,0x4a,0xb1,0xa4,0x6b,0x1,0xbd,0x99,0xac,0xad,0xc5,0x27,0x8e,0xe3,0x52,0x25,
0x5b,0x40,0xdf,0xb9,0x6,0x0,0xa4,0x87,0x11,0x45,0x34,0x1,0x48,0x80,0x6e,0x14,
0x6c,0x89,0x2c,0x11,0x5e,0x75,0x71,0x5d,0x11,0x85,0x4c,0x26,0x93,0x25,0xc1,0x2b,
0x1b,0x65,0x8b,0xd5,0x52,0x1,0x7a,0x46,0x61,0x5,0xe8,0xfa,0xee,0x96,0xd,0xe,
0x5,0x63,0x8b,0x59,0x41,0xf0,0x49,0xea,0x75,0x7b,0xf7,0xb6,0x60,0xb3,0x12,0xa9,
0x6e,0x33,0x53,0xd1,0xa,0xd0,0xfb,0x26,0xaa,0x0,0x17,0xe2,0xd7,0x89,0x92,0x18,
0xc9,0xe2,0x22,0x7c,0x4a,0xa5,0x3e,0xdd,0x16,0x9b,0x8d,0x32,0x49,0xaa,0x8,0x54,
0x52,0xa3,0x1a,0xcf,0xa0,0xa3,0xa,0x80,0x6a,0xd9,0xea,0x37,0x11,0xbf,0x23,0x28,
0x49,0x22,0x59,0x14,0x36,0x6d,0xda,0x58,0x44,0xa1,0xa8,0x3c,0xbe,0x1f,0x5b,0x20,
0xb4,0x80,0xb3,0xb5,0x6a,0xc5,0x4d,0x97,0x8a,0x30,0xae,0xd2,0x15,0xc0,0x79,0xdb,
0x4e,0x12,0x3b,0x87,0x43,0x41,0x6c,0x31,0xb,0x59,0x7c,0x4e,0xd5,0x9e,0xa,0x2d,
0xe0,0xec,0xc9,0x2,0x74,0xf6,0xa3,0x14,0xb,0x59,0xe3,0x49,0x80,0x73,0xb6,0x88,
0x92,0xb5,0x36,0xe3,0x12,0xbc,0x36,0x6e,0xda,0x58,0x35,0x2d,0xa0,0x87,0x91,0x63,
0x3e,0x3a,0x3b,0x50,0xb2,0xce,0xd5,0xe0,0x63,0x28,0x56,0xb2,0xa5,0x88,0x10,0xe3,
0x70,0xe1,0x3c,0xc0,0x59,0x12,0x51,0x5,0xc0,0x69,0x3,0xd0,0xde,0xdc,0x5e,0xeb,
0x1a,0x6c,0xe,0xf,0x93,0xa6,0xa5,0x8a,0x56,0x94,0x81,0x40,0x85,0x16,0xa0,0xc7,
0xea,0x95,0xb7,0x4c,0x6,0x99,0x81,0xdf,0xcf,0x37,0x6c,0x7a,0xb8,0x1b,0x85,0xde,
0xda,0xde,0x26,0x21,0x83,0x8f,0xc9,0x98,0x13,0x28,0x19,0x63,0x32,0x24,0xc,0x2a,
0xd5,0x7,0xa,0x83,0xce,0xcb,0xc0,0x31,0xdf,0x1b,0xc3,0x99,0x9d,0x66,0x64,0xb8,
0xd,0x9d,0x27,0x51,0x72,0xb5,0x99,0x46,0x14,0xa,0xae,0xa0,0xa,0x54,0xff,0x93,
0x42,0x24,0x95,0x5a,0x3c,0x22,0x17,0x55,0xb6,0x2,0x94,0x13,0x7f,0xea,0xa6,0xb6,
0x5b,0x56,0x2,0x7f,0x38,0xc8,0x37,0x83,0xbe,0xc6,0x19,0x88,0xf0,0xc,0xd0,0x5b,
0xed,0x97,0x85,0x45,0xf8,0x50,0xa5,0x3,0x60,0x9d,0x34,0x69,0x2e,0x5,0xd4,0xd4,
0xd7,0x77,0xa1,0x10,0x77,0xc5,0xe3,0x6c,0xe,0xc1,0xc3,0x91,0x14,0x50,0x8a,0x50,
0xfa,0xce,0xc6,0x87,0x77,0x3,0xbb,0x19,0x80,0x7e,0xb9,0x9e,0x9b,0xda,0x6e,0xfd,
0x34,0xf0,0x45,0xaa,0x54,0x79,0xfd,0x96,0x80,0xcc,0xae,0x64,0x0,0xfa,0x6f,0xd4,
0x30,0x36,0xd7,0xd4,0x80,0x65,0x50,0x2e,0xb5,0xa7,0xf2,0xf9,0x7c,0x11,0x85,0x24,
0x8a,0x1a,0x2d,0x31,0x5e,0x29,0xc7,0x2a,0x10,0x0,0x3f,0x7d,0x8,0x1e,0xfa,0xc7,
0x9b,0xaf,0xbf,0xb5,0x7,0xf8,0x12,0x50,0x43,0x95,0x11,0xe1,0x23,0xe8,0xec,0xf8,
0xf6,0xf7,0x1f,0x7a,0xd,0x85,0x9,0xb5,0x13,0x1a,0x63,0x89,0x5,0xf,0x89,0x92,
0x6e,0x94,0x22,0x49,0x1a,0x1d,0x7e,0x5,0x29,0x74,0x55,0x55,0x0,0x0,0xca,0x6f,
0xdc,0xd7,0x6e,0xbe,0xfe,0xb6,0xdd,0xc0,0x3a,0x60,0x6,0x55,0xa2,0xbc,0x4e,0x17,
0x83,0xdc,0x88,0xce,0x97,0x51,0x8a,0xc5,0x34,0x82,0xc5,0x27,0x2d,0x46,0x5d,0x28,
0xa5,0x62,0x1a,0x5,0x1f,0x89,0x37,0x6d,0xda,0x74,0x12,0x25,0x3,0x30,0x74,0x21,
0x58,0xff,0x34,0x70,0x35,0x90,0xa7,0x7a,0xfc,0x35,0x60,0xf1,0x3b,0xc,0x3c,0xac,
0x9f,0xac,0x64,0x3c,0xa,0x63,0xc9,0xa8,0x2,0xd0,0xde,0xd2,0x3e,0x46,0x84,0x2c,
0x1e,0xe2,0x92,0x63,0xae,0x6c,0xe8,0x2b,0x80,0x3e,0x4,0x27,0x81,0xdb,0x6f,0xb9,
0xe1,0xb6,0xc7,0x7,0x5a,0x42,0x8e,0x61,0x52,0x5e,0x87,0x66,0x11,0xfe,0x18,0x9d,
0xaf,0x3f,0xfc,0xbd,0xf5,0x31,0xa,0xcb,0x97,0xdf,0x55,0x5f,0x1f,0xd1,0x84,0x87,
0xb3,0x14,0xef,0xfd,0xfe,0xbd,0xa7,0x51,0x28,0x5e,0x60,0x1b,0x4d,0x29,0xc6,0xc7,
0x49,0xa6,0x6b,0x44,0xdc,0x27,0xb0,0xfc,0x66,0x7e,0xf5,0x96,0x1b,0xd6,0xec,0x6,
0xf2,0xc3,0xd1,0x12,0xca,0x7f,0xdb,0x82,0x7c,0x15,0x10,0xfc,0x4a,0xc0,0xbf,0xa2,
0x54,0x9f,0x39,0x35,0xd,0x67,0xf1,0xb1,0x89,0xd3,0xf7,0x6a,0x57,0x6a,0x4c,0x11,
0xc5,0xef,0xa5,0xdd,0xe8,0x61,0x0,0x86,0x2f,0x4,0xeb,0x7e,0xa,0x5c,0x3,0xac,
0x63,0xe8,0x7d,0x14,0x78,0x7,0x3a,0xeb,0xcb,0xeb,0xfa,0x2a,0xa,0x52,0x86,0x8b,
0x2e,0x42,0x21,0x49,0x93,0x4e,0x94,0x52,0x67,0x1a,0x15,0x7f,0xdb,0x1d,0xe9,0x3d,
0xd2,0x5d,0x1d,0x15,0x40,0x1f,0x82,0x13,0x40,0xfb,0xad,0x37,0xae,0xf9,0x30,0xf0,
0xc5,0xa1,0x68,0x9,0xe5,0xbf,0x35,0x49,0x84,0xcf,0xa2,0xe3,0xf4,0x87,0xb0,0xb0,
0xa6,0x6d,0xcd,0xc4,0xd8,0xba,0x1c,0x1e,0x16,0x92,0x97,0x5f,0xeb,0x38,0x84,0xc2,
0x9c,0x39,0x1f,0xc8,0x4c,0x9b,0xe2,0xfc,0x87,0x94,0x70,0xaa,0xff,0x2b,0xe4,0x55,
0x14,0x0,0xbd,0x87,0xbe,0xbb,0xee,0x2b,0xb7,0xde,0xd8,0xfe,0x23,0x20,0xf,0x5c,
0xca,0x79,0x25,0x1f,0x7,0x1a,0xd0,0xf9,0xb7,0x87,0xbe,0x9b,0xff,0x31,0x5a,0x86,
0x69,0x28,0xc4,0x89,0xfc,0xba,0xff,0x2e,0x22,0x28,0x4c,0x9c,0xd8,0x7d,0x21,0xa,
0x46,0xd2,0xee,0x11,0xfd,0xbc,0x80,0xf2,0x1b,0xfd,0x13,0xe0,0x6a,0x60,0x3d,0xe7,
0xd7,0xfb,0xd1,0x39,0xa,0x7c,0x12,0x40,0x79,0xaa,0xb6,0x36,0x71,0x4c,0x40,0x21,
0x93,0x70,0x0,0xa5,0x5a,0x52,0x55,0x4b,0x71,0xa5,0x9a,0xae,0xea,0xbd,0x59,0xb4,
0x3e,0x4,0x27,0x80,0x35,0xb7,0xad,0xba,0xfd,0x23,0x3,0xa5,0x37,0x4b,0x5,0x95,
0xc7,0xad,0x17,0x91,0x31,0xe8,0x7c,0x62,0xfd,0x23,0xf,0x76,0xa1,0x64,0x62,0x73,
0xb1,0x33,0x8,0x3e,0x4e,0x4e,0xe5,0x37,0xaf,0x55,0x8d,0xdb,0xff,0xb8,0xb9,0x5a,
0x33,0x66,0xa2,0xc5,0xe0,0x53,0x9b,0x98,0x6a,0xaf,0x0,0x7a,0xe5,0x37,0xfe,0xcb,
0x40,0x33,0xb0,0x9f,0xca,0x4a,0x81,0x5e,0xfc,0xf6,0x0,0xdf,0x40,0xe9,0x3,0xe5,
0x3e,0x9d,0xc4,0x4c,0x47,0xc1,0xb9,0xd2,0x1,0x94,0xea,0x4c,0xe3,0x54,0x63,0x8c,
0x26,0x54,0xbd,0xf7,0x6e,0xb9,0xf7,0xf4,0xc8,0x8,0x80,0x3e,0x4,0x3f,0x1e,0x68,
0x9,0xf,0x57,0x70,0xcc,0x5e,0x60,0x83,0x22,0x24,0x1f,0x2a,0x87,0xd0,0xa1,0x74,
0x64,0xd2,0xf1,0x59,0x9a,0x6a,0xe5,0x9c,0x4b,0x4d,0x9d,0x39,0x88,0x92,0x48,0x71,
0x1a,0xa,0x49,0xea,0x3a,0x46,0xd6,0x23,0x63,0xf4,0x21,0x38,0xe,0xdc,0xba,0x66,
0xf5,0x7b,0x3f,0xa,0x7c,0xa1,0x12,0x2d,0x41,0x44,0x3e,0x3,0x2c,0x81,0x37,0xec,
0xd7,0x9f,0x5a,0xb7,0xe1,0x5b,0x3f,0x41,0x69,0xf5,0xea,0xd5,0xd,0x39,0x5b,0x77,
0x89,0xe6,0x4,0x9c,0x13,0x79,0x35,0x9f,0x7f,0xb0,0x88,0xc2,0x9d,0x37,0xdc,0xd9,
0x88,0xb1,0x63,0x34,0x87,0x7f,0x51,0x7d,0xd2,0x31,0xaa,0x9f,0x1b,0x58,0x9e,0x90,
0x7f,0x6,0xe6,0x2,0x2f,0xe3,0xe7,0x3c,0x63,0xed,0x3,0x56,0x0,0xbf,0x3d,0xc9,
0xc7,0x81,0x8f,0x97,0x7f,0xfe,0x79,0xf4,0xc8,0x48,0xdd,0x15,0xce,0x39,0x41,0x21,
0x87,0x39,0x80,0x52,0xc1,0xba,0x8b,0x51,0x48,0x85,0xce,0x7c,0x3e,0xdf,0x3b,0x72,
0x2b,0x80,0x3e,0x4,0x7b,0xdb,0x6f,0x7a,0xef,0xd5,0xc0,0x7f,0x0,0x37,0xff,0x2e,
0x1f,0xdb,0x1e,0xd8,0xc2,0xaf,0x29,0x8f,0x77,0x1d,0x30,0x15,0x28,0x1,0x5b,0xf3,
0xdf,0xf9,0x56,0xf,0x7a,0xb4,0x5f,0xdf,0x3e,0x49,0x72,0x66,0x2,0x46,0x35,0x53,
0xc7,0x1f,0xf8,0xce,0x3,0x9d,0xda,0xf,0x7f,0x18,0xa2,0x29,0x2e,0x52,0x1d,0x51,
0x74,0x70,0x8e,0x22,0x46,0x98,0xf2,0x4,0x1d,0x3,0x6e,0x69,0xbf,0xe9,0x8e,0x3f,
0x3,0xfe,0xfe,0xc,0x2d,0xa1,0x7,0xd8,0x8f,0x7e,0xbc,0xdd,0x9c,0xa3,0xfe,0xc7,
0xc2,0x63,0xa3,0x2b,0x20,0x45,0x43,0xfa,0x92,0x5f,0xa2,0x64,0x8b,0x76,0x4a,0x6c,
0xd3,0x8,0xf,0x93,0xba,0xd2,0xec,0xab,0x2f,0x7f,0x75,0xd4,0x3c,0x3a,0x56,0x1f,
0x84,0xb5,0xff,0x4,0xcc,0x3,0xf6,0xf1,0x1b,0x9,0x70,0x7b,0xf9,0x67,0xc7,0x18,
0x2,0xcf,0x3d,0xfd,0xdc,0x5b,0x5d,0x94,0xd6,0xa1,0x60,0x63,0xe,0xe7,0x37,0xe7,
0xbb,0x50,0x8a,0x41,0x55,0xfe,0x25,0x96,0x43,0xfd,0xf,0xa9,0x18,0x5d,0x15,0x40,
0x1f,0x82,0xff,0xb9,0xfd,0xe6,0x3b,0x66,0x1,0xcd,0xc0,0x14,0xe0,0x89,0x7,0xbf,
0xbd,0xf6,0x75,0x2a,0x40,0x53,0xa2,0xc5,0xc9,0xc,0x2b,0x82,0x8f,0x4b,0x5d,0x9a,
0xd6,0xb8,0xe7,0xd4,0x63,0xb7,0xb6,0x5f,0x60,0x1b,0x4c,0x13,0xa,0x51,0x1a,0x1d,
0xe0,0xdc,0x11,0x31,0xc2,0x95,0x27,0xdc,0x1,0x3f,0x64,0xe8,0x4d,0x15,0x93,0xc9,
0xa0,0xe0,0x9c,0xbc,0x94,0xcf,0xff,0x77,0x2f,0x5a,0xd,0xd1,0x15,0x60,0xf0,0x91,
0x34,0x39,0x7e,0xdf,0xc6,0xfb,0x4e,0x0,0xc,0x75,0xb,0x8,0xa,0xb9,0x5a,0x14,
0x5c,0xea,0xfa,0xc8,0x15,0x5e,0x44,0xe9,0x7d,0xab,0xdf,0x37,0xd1,0x60,0x2e,0x44,
0x43,0xe8,0x0,0x18,0x86,0x0,0x4,0xc6,0x96,0x1c,0xa,0x19,0x2b,0xbf,0xca,0xe7,
0xf3,0x9,0x3a,0x92,0x44,0x72,0x85,0x32,0x58,0xe9,0xbe,0x8e,0xb1,0x87,0x86,0x29,
0x0,0x41,0x6f,0x52,0xff,0x6b,0x3c,0xc,0xe9,0xb1,0xfb,0x1e,0xba,0xef,0x20,0x4a,
0xed,0xab,0xee,0x9a,0x2e,0x4e,0xea,0x51,0x10,0x63,0xe,0xed,0xdd,0xfb,0xf5,0xd2,
0x30,0x5,0x20,0xd8,0xb0,0xe1,0x1b,0x27,0xad,0x73,0x6f,0x18,0x82,0x94,0x34,0x36,
0x7d,0xe6,0x67,0xa0,0xbf,0x96,0x20,0x26,0x99,0x89,0x86,0x23,0x49,0xa3,0xc2,0xb,
0x0,0xc3,0x18,0x80,0x60,0xe6,0xbb,0x66,0xfe,0x54,0x4c,0xf2,0xea,0x19,0xb6,0xfc,
0x2,0x51,0xfc,0x94,0x7e,0x7,0xd,0x4e,0x4e,0x3f,0x39,0x53,0x8c,0x64,0x50,0x48,
0x33,0xb2,0xdf,0x73,0xe6,0x6f,0x28,0x2,0x10,0xf4,0x1f,0x7f,0xaf,0x5d,0xbf,0x76,
0x6f,0xd4,0xc7,0x93,0xd6,0xb8,0xe7,0xc1,0xbe,0x10,0x9,0x4f,0xcf,0x7a,0xe7,0xac,
0xc7,0xf2,0x79,0xfd,0x31,0xff,0x5d,0x77,0xdd,0x55,0xef,0x9c,0x9d,0x8e,0xcf,0x40,
0xb8,0x8e,0x1c,0x39,0xf8,0x12,0x15,0x22,0xce,0x39,0x86,0x57,0x70,0xc7,0x6d,0x77,
0xcc,0xb1,0x62,0x27,0xa1,0x50,0x14,0xfb,0xb3,0x7c,0xfe,0xbf,0xe,0x0,0x8c,0x82,
0xa,0x10,0xdc,0x79,0xe7,0x9d,0x8d,0xda,0xc9,0x77,0xa9,0x3b,0xb1,0x6e,0xdd,0xbd,
0x1d,0x0,0xa3,0x24,0x0,0x41,0x5a,0x88,0xa6,0xa3,0xe4,0x72,0xee,0x59,0x57,0x46,
0x5,0x45,0xc,0xab,0xc0,0x8a,0x4c,0x0,0x8b,0x8f,0x13,0x5e,0x7f,0xe0,0x81,0xfb,
0x3a,0x1,0x46,0x51,0x5,0x8,0x52,0x49,0xc,0x1e,0x22,0xa9,0x2b,0xd1,0xfb,0x2c,
0xc0,0xa8,0xb,0x40,0x60,0x4e,0xe1,0x51,0x32,0xf2,0xbf,0xf9,0x7c,0xfe,0xd4,0x28,
0xc,0x40,0xe0,0x6c,0xb4,0xdf,0xf3,0xec,0xc1,0x52,0x9a,0xf6,0xbd,0x0,0x30,0xa,
0x3,0x10,0xac,0x5d,0xfb,0x8d,0xc3,0xa9,0x93,0x97,0x39,0x3,0x11,0x13,0x13,0x25,
0x4f,0x79,0x6e,0x20,0x31,0xd2,0x3,0x10,0x3c,0xb0,0xfe,0x9b,0xbf,0x4c,0xa2,0xe8,
0x27,0xa9,0x70,0x54,0xc4,0x14,0x9c,0xa1,0x2f,0x75,0x1c,0x28,0x70,0x7a,0xe7,0xfd,
0xf7,0xdf,0xdf,0x8d,0x5e,0x38,0x11,0x14,0x84,0xa,0x10,0x84,0x0,0x4,0x21,0x0,
0x41,0x8,0x40,0x10,0x2,0x10,0x84,0x0,0x4,0x21,0x0,0x41,0x8,0x40,0x10,0x2,
0x10,0x84,0x0,0x4,0x21,0x0,0x41,0x8,0x40,0x10,0x2,0x10,0x84,0x0,0x4,0x21,
0x0,0x1,0xff,0x7,0xed,0xf0,0xc7,0xb5,0xf0,0x90,0x77,0x29,0x0,0x0,0x0,0x0,
0x49,0x45,0x4e,0x44,0xae,0x42,0x60,0x82,
};
static const unsigned char qt_resource_name[] = {
// new
0x0,0x3,
0x0,0x0,0x74,0xc7,
0x0,0x6e,
0x0,0x65,0x0,0x77,
// prefix1
0x0,0x7,
0x7,0x8b,0xd0,0x51,
0x0,0x70,
0x0,0x72,0x0,0x65,0x0,0x66,0x0,0x69,0x0,0x78,0x0,0x31,
// resource
0x0,0x8,
0xc,0xa6,0xc7,0x95,
0x0,0x72,
0x0,0x65,0x0,0x73,0x0,0x6f,0x0,0x75,0x0,0x72,0x0,0x63,0x0,0x65,
// mute_3.png
0x0,0xa,
0xb,0x2c,0xce,0x7,
0x0,0x6d,
0x0,0x75,0x0,0x74,0x0,0x65,0x0,0x5f,0x0,0x33,0x0,0x2e,0x0,0x70,0x0,0x6e,0x0,0x67,
// mute.png
0x0,0x8,
0xc,0xa8,0x59,0xc7,
0x0,0x6d,
0x0,0x75,0x0,0x74,0x0,0x65,0x0,0x2e,0x0,0x70,0x0,0x6e,0x0,0x67,
// sound_high_2.png
0x0,0x10,
0x7,0x70,0x13,0xe7,
0x0,0x73,
0x0,0x6f,0x0,0x75,0x0,0x6e,0x0,0x64,0x0,0x5f,0x0,0x68,0x0,0x69,0x0,0x67,0x0,0x68,0x0,0x5f,0x0,0x32,0x0,0x2e,0x0,0x70,0x0,0x6e,0x0,0x67,
// pause.png
0x0,0x9,
0xc,0x98,0xba,0x47,
0x0,0x70,
0x0,0x61,0x0,0x75,0x0,0x73,0x0,0x65,0x0,0x2e,0x0,0x70,0x0,0x6e,0x0,0x67,
// back_2.png
0x0,0xa,
0x1,0x28,0x58,0x7,
0x0,0x62,
0x0,0x61,0x0,0x63,0x0,0x6b,0x0,0x5f,0x0,0x32,0x0,0x2e,0x0,0x70,0x0,0x6e,0x0,0x67,
// volume_mixer.png
0x0,0x10,
0x6,0xaf,0x77,0xa7,
0x0,0x76,
0x0,0x6f,0x0,0x6c,0x0,0x75,0x0,0x6d,0x0,0x65,0x0,0x5f,0x0,0x6d,0x0,0x69,0x0,0x78,0x0,0x65,0x0,0x72,0x0,0x2e,0x0,0x70,0x0,0x6e,0x0,0x67,
// play.png
0x0,0x8,
0x2,0x8c,0x59,0xa7,
0x0,0x70,
0x0,0x6c,0x0,0x61,0x0,0x79,0x0,0x2e,0x0,0x70,0x0,0x6e,0x0,0x67,
// unmute_3.svg
0x0,0xc,
0x4,0xb0,0xc3,0x87,
0x0,0x75,
0x0,0x6e,0x0,0x6d,0x0,0x75,0x0,0x74,0x0,0x65,0x0,0x5f,0x0,0x33,0x0,0x2e,0x0,0x73,0x0,0x76,0x0,0x67,
// sound_low.png
0x0,0xd,
0x7,0xb2,0xc2,0xe7,
0x0,0x73,
0x0,0x6f,0x0,0x75,0x0,0x6e,0x0,0x64,0x0,0x5f,0x0,0x6c,0x0,0x6f,0x0,0x77,0x0,0x2e,0x0,0x70,0x0,0x6e,0x0,0x67,
// music_note.png
0x0,0xe,
0xf,0x9b,0x6e,0xc7,
0x0,0x6d,
0x0,0x75,0x0,0x73,0x0,0x69,0x0,0x63,0x0,0x5f,0x0,0x6e,0x0,0x6f,0x0,0x74,0x0,0x65,0x0,0x2e,0x0,0x70,0x0,0x6e,0x0,0x67,
// pause_2.png
0x0,0xb,
0xb,0xc8,0x4e,0x67,
0x0,0x70,
0x0,0x61,0x0,0x75,0x0,0x73,0x0,0x65,0x0,0x5f,0x0,0x32,0x0,0x2e,0x0,0x70,0x0,0x6e,0x0,0x67,
// next_2.png
0x0,0xa,
0xa,0x2b,0xce,0xa7,
0x0,0x6e,
0x0,0x65,0x0,0x78,0x0,0x74,0x0,0x5f,0x0,0x32,0x0,0x2e,0x0,0x70,0x0,0x6e,0x0,0x67,
// next.png
0x0,0x8,
0xc,0xf7,0x59,0xc7,
0x0,0x6e,
0x0,0x65,0x0,0x78,0x0,0x74,0x0,0x2e,0x0,0x70,0x0,0x6e,0x0,0x67,
// back.png
0x0,0x8,
0x7,0x9e,0x5a,0x47,
0x0,0x62,
0x0,0x61,0x0,0x63,0x0,0x6b,0x0,0x2e,0x0,0x70,0x0,0x6e,0x0,0x67,
// sound_high.png
0x0,0xe,
0x2,0x52,0x2,0x7,
0x0,0x73,
0x0,0x6f,0x0,0x75,0x0,0x6e,0x0,0x64,0x0,0x5f,0x0,0x68,0x0,0x69,0x0,0x67,0x0,0x68,0x0,0x2e,0x0,0x70,0x0,0x6e,0x0,0x67,
// stop.png
0x0,0x8,
0xb,0x63,0x58,0x7,
0x0,0x73,
0x0,0x74,0x0,0x6f,0x0,0x70,0x0,0x2e,0x0,0x70,0x0,0x6e,0x0,0x67,
// mute_2.png
0x0,0xa,
0xb,0x2b,0xce,0x7,
0x0,0x6d,
0x0,0x75,0x0,0x74,0x0,0x65,0x0,0x5f,0x0,0x32,0x0,0x2e,0x0,0x70,0x0,0x6e,0x0,0x67,
// sound_low_2.png
0x0,0xf,
0x5,0xb0,0xf8,0x27,
0x0,0x73,
0x0,0x6f,0x0,0x75,0x0,0x6e,0x0,0x64,0x0,0x5f,0x0,0x6c,0x0,0x6f,0x0,0x77,0x0,0x5f,0x0,0x32,0x0,0x2e,0x0,0x70,0x0,0x6e,0x0,0x67,
};
static const unsigned char qt_resource_struct[] = {
// :
0x0,0x0,0x0,0x0,0x0,0x2,0x0,0x0,0x0,0x1,0x0,0x0,0x0,0x1,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
// :/new
0x0,0x0,0x0,0x0,0x0,0x2,0x0,0x0,0x0,0x1,0x0,0x0,0x0,0x2,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
// :/new/prefix1
0x0,0x0,0x0,0xc,0x0,0x2,0x0,0x0,0x0,0x1,0x0,0x0,0x0,0x3,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
// :/new/prefix1/resource
0x0,0x0,0x0,0x20,0x0,0x2,0x0,0x0,0x0,0x12,0x0,0x0,0x0,0x4,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
// :/new/prefix1/resource/back_2.png
0x0,0x0,0x0,0xa4,0x0,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x1b,0x90,
0x0,0x0,0x1,0x5b,0x80,0x50,0x5e,0x91,
// :/new/prefix1/resource/sound_high.png
0x0,0x0,0x1,0xbc,0x0,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x45,0x2e,
0x0,0x0,0x1,0x5b,0x80,0x51,0x13,0x5b,
// :/new/prefix1/resource/play.png
0x0,0x0,0x0,0xe4,0x0,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x23,0xb9,
0x0,0x0,0x1,0x5b,0x80,0x50,0x2c,0xbd,
// :/new/prefix1/resource/unmute_3.svg
0x0,0x0,0x0,0xfa,0x0,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x29,0x5,
0x0,0x0,0x1,0x5b,0xd3,0x8c,0x69,0x84,
// :/new/prefix1/resource/sound_low_2.png
0x0,0x0,0x2,0xe,0x0,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x5d,0x27,
0x0,0x0,0x1,0x5b,0x80,0x52,0x2,0x8d,
// :/new/prefix1/resource/volume_mixer.png
0x0,0x0,0x0,0xbe,0x0,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x1e,0xfc,
0x0,0x0,0x1,0x5b,0x80,0x51,0x57,0x82,
// :/new/prefix1/resource/sound_high_2.png
0x0,0x0,0x0,0x66,0x0,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0xc,0x4a,
0x0,0x0,0x1,0x5b,0x80,0x52,0xf,0x25,
// :/new/prefix1/resource/back.png
0x0,0x0,0x1,0xa6,0x0,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x40,0xd5,
0x0,0x0,0x1,0x5b,0x80,0x50,0x88,0x18,
// :/new/prefix1/resource/sound_low.png
0x0,0x0,0x1,0x18,0x0,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x2c,0x8b,
0x0,0x0,0x1,0x5b,0x80,0x50,0xf9,0x53,
// :/new/prefix1/resource/next_2.png
0x0,0x0,0x1,0x76,0x0,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x39,0x32,
0x0,0x0,0x1,0x5b,0x80,0x50,0x69,0x81,
// :/new/prefix1/resource/mute_2.png
0x0,0x0,0x1,0xf4,0x0,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x50,0xb6,
0x0,0x0,0x1,0x5b,0x80,0x5e,0x2d,0x25,
// :/new/prefix1/resource/mute_3.png
0x0,0x0,0x0,0x36,0x0,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x0,0x0,
0x0,0x0,0x1,0x5b,0xd3,0xaf,0xd3,0xe2,
// :/new/prefix1/resource/stop.png
0x0,0x0,0x1,0xde,0x0,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x4e,0xa4,
0x0,0x0,0x1,0x5b,0x80,0x50,0x4b,0x39,
// :/new/prefix1/resource/pause_2.png
0x0,0x0,0x1,0x5a,0x0,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x35,0xee,
0x0,0x0,0x1,0x5b,0x80,0x57,0x8d,0x77,
// :/new/prefix1/resource/pause.png
0x0,0x0,0x0,0x8c,0x0,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x19,0x77,
0x0,0x0,0x1,0x5b,0x80,0x51,0x2c,0xfb,
// :/new/prefix1/resource/mute.png
0x0,0x0,0x0,0x50,0x0,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x8,0x20,
0x0,0x0,0x1,0x5b,0x80,0x50,0xd3,0x18,
// :/new/prefix1/resource/next.png
0x0,0x0,0x1,0x90,0x0,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x3c,0xa7,
0x0,0x0,0x1,0x5b,0x80,0x50,0x7d,0x5,
// :/new/prefix1/resource/music_note.png
0x0,0x0,0x1,0x38,0x0,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x2f,0xe8,
0x0,0x0,0x1,0x5b,0x80,0x50,0x93,0x1c,
};
#ifdef QT_NAMESPACE
# define QT_RCC_PREPEND_NAMESPACE(name) ::QT_NAMESPACE::name
# define QT_RCC_MANGLE_NAMESPACE0(x) x
# define QT_RCC_MANGLE_NAMESPACE1(a, b) a##_##b
# define QT_RCC_MANGLE_NAMESPACE2(a, b) QT_RCC_MANGLE_NAMESPACE1(a,b)
# define QT_RCC_MANGLE_NAMESPACE(name) QT_RCC_MANGLE_NAMESPACE2( \
QT_RCC_MANGLE_NAMESPACE0(name), QT_RCC_MANGLE_NAMESPACE0(QT_NAMESPACE))
#else
# define QT_RCC_PREPEND_NAMESPACE(name) name
# define QT_RCC_MANGLE_NAMESPACE(name) name
#endif
#ifdef QT_NAMESPACE
namespace QT_NAMESPACE {
#endif
bool qRegisterResourceData(int, const unsigned char *, const unsigned char *, const unsigned char *);
bool qUnregisterResourceData(int, const unsigned char *, const unsigned char *, const unsigned char *);
#ifdef QT_NAMESPACE
}
#endif
int QT_RCC_MANGLE_NAMESPACE(qInitResources_resources)();
int QT_RCC_MANGLE_NAMESPACE(qInitResources_resources)()
{
QT_RCC_PREPEND_NAMESPACE(qRegisterResourceData)
(0x02, qt_resource_struct, qt_resource_name, qt_resource_data);
return 1;
}
int QT_RCC_MANGLE_NAMESPACE(qCleanupResources_resources)();
int QT_RCC_MANGLE_NAMESPACE(qCleanupResources_resources)()
{
QT_RCC_PREPEND_NAMESPACE(qUnregisterResourceData)
(0x02, qt_resource_struct, qt_resource_name, qt_resource_data);
return 1;
}
namespace {
struct initializer {
initializer() { QT_RCC_MANGLE_NAMESPACE(qInitResources_resources)(); }
~initializer() { QT_RCC_MANGLE_NAMESPACE(qCleanupResources_resources)(); }
} dummy;
}
|
d0b4db3f871bd5ac1077b0d6a7400d74330703b2 | 97e0d023d36c14a1b7d8c5ae4d579066492b5c58 | /动态规划/hdu2844 多重背包二进制优化.cpp | f2118171ebf3a6fc5f5db6b35cd6d42dc52f35dd | [] | no_license | gmy987/ACM | f6f809811b54a1e106624b83eda56120ac85d852 | 4b807f61b35d07db0d35e2195a8d93cff648b7bb | refs/heads/master | 2021-01-13T01:28:55.209296 | 2015-09-03T07:09:28 | 2015-09-03T07:09:28 | 41,202,863 | 2 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 1,068 | cpp | hdu2844 多重背包二进制优化.cpp | #include <cstdio>
#include <cstring>
#include <iostream>
#define MAXN 105
#define MAXM 100005
using namespace std;
int a[MAXN],b[MAXN];
int cnt[MAXM];
int dp[MAXM];
int main()
{
int n,m;
int sum = 0;
while(~scanf("%d%d",&n,&m))
{
if( n == 0 && m == 0 )
break;
int num = 0;
memset(dp,0,sizeof(dp));
dp[0] = 1;
for( int i = 0 ; i < n ; i++ )
scanf("%d",&a[i]);
for( int i = 0 ; i < n ; i++ )
scanf("%d",&b[i]);
int cnt;
for( int i = 0 ; i < n ; i++ )
{
cnt = b[i];
for( int k = 1 ; k <= cnt ; k<<=1 )
{
for( int j = m ; j >= k*a[i] ;j-- )
dp[j] += dp[j-k*a[i]];
cnt-=k;
}
if(cnt)
for( int j = m ; j >= cnt*a[i] ; j-- )
dp[j] += dp[j-cnt*a[i]];
}
int ans = 0;
for( int i = 1 ; i <= m ; i++ )
if( dp[i] ) ans++;
printf("%d\n",ans);
}
return 0;
}
|
2ba6076427f5780bb23051efd5750ca77cf6678f | 2a44ec3f6fa2680d91d7b71378a2ae1a86398443 | /Book-Code/Chapter08/zju2100.cpp | d9736472ce010b8ed04829200183a8d7dfce9cb4 | [] | no_license | jiulix/tup-design-and-analysis-of-algorithm | 196f7e1a9a00f1ce58aba1cd060e12c0abca0909 | 2ee4bd206b0b450610908d9656864c7f2e24309e | refs/heads/master | 2022-04-06T05:22:46.077548 | 2017-11-10T08:07:57 | 2017-11-10T08:07:57 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 796 | cpp | zju2100.cpp | #include<stdio.h>
#define NUM 10
char field[NUM][NUM];
int n,m;
int visited;
int flag;
int count;
void dfs(int x,int y)
{
if ( x<0 || y<0 || x>=n || y>=m) return;
if (field[x][y]=='S') return;
if (flag) return;
count ++;
if (count>1500) return;
field[x][y] = 'S';
visited ++;
if (visited == n*m)
{
flag = 1;
return;
}
dfs(x+1,y);
dfs(x-1,y);
dfs(x,y+1);
dfs(x,y-1);
visited --;
field[x][y] = '.';
}
int main()
{
while (scanf("%d%d",&n,&m) && n && m)
{
int i, j;
for (i=0; i<n; i++)
scanf("%s", field[i]);
visited = 0;
for (i = 0; i<n ; i++)
for (j = 0; j<m; j++)
if (field[i][j]=='S') visited ++;
flag = 0;
count = 0;
dfs(0,0);
if (flag) printf("YES\n");
else printf("NO\n");
}
return 0;
}
|
b0e516c688d8a916c9dd6d5ff982a86156b9bbb5 | fb6ee00aa32a1ebfaa83dcc8e584d393268c7d27 | /FindMap/FindMap/Block.cpp | 0e32719b81edb4fc958848561a226d17a2da6dc0 | [] | no_license | Tocktock/HanGwa1994 | 2f6fcb05a3c2772575595da523daa027614fd16a | c57b060f1548583220ccd757f43c5f6edec1df11 | refs/heads/master | 2020-03-18T06:38:44.183643 | 2019-05-13T01:48:26 | 2019-05-13T01:48:26 | 134,407,558 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,253 | cpp | Block.cpp | #include "Block.h"
#include "Macro.h"
Block::Block()
{
m_isMine = false;
}
Block::~Block()
{
m_vecBlock.clear();
}
int Block::HowMuchMineIs(int x,int y, vector<Piece*> m_vecMine)
{
int MineCount = 2;
m_vecBlock = m_vecMine;
for (auto iter = m_vecBlock.begin(); iter != m_vecBlock.end(); iter++)
{
if ((*iter)->GetX() == x - 1 && (*iter)->GetY() == y - 1)
{
if ((*iter)->isMine())
MineCount++;
}
else if ((*iter)->GetX() == x && (*iter)->GetY() == y - 1)
{
if ((*iter)->isMine())
MineCount++;
}
else if ((*iter)->GetX() == x + 1 && (*iter)->GetY() == y - 1)
{
if ((*iter)->isMine())
MineCount++;
}
else if ((*iter)->GetX() == x - 1 && (*iter)->GetY() == y)
{
if ((*iter)->isMine())
MineCount++;
}
else if ((*iter)->GetX() == x + 1 && (*iter)->GetY() == y)
{
if ((*iter)->isMine())
MineCount++;
}
else if ((*iter)->GetX() == x - 1 && (*iter)->GetY() == y + 1)
{
if ((*iter)->isMine())
MineCount++;
}
else if ((*iter)->GetX() == x && (*iter)->GetY() == y + 1)
{
if ((*iter)->isMine())
MineCount++;
}
else if ((*iter)->GetX() == x + 1 && (*iter)->GetY() == y + 1)
{
if ((*iter)->isMine())
MineCount++;
}
}
return MineCount;
} |
e991fcf60ca3ef47f3747ef9540dfefecd6fe7a6 | 024f03b566889a4db30828de3c520f48e911626c | /Space Invaders/lib/OpenGL/GL/include/glrv/include/axis.h | ce7c2e7599ee228f5f05421d5771ee7cba7046f3 | [] | no_license | alvarocrego/Introduccion-a-la-Programaci-n-de-Videojuegos | 8ae56d8404086fb7418a2f9c237ca025527987bb | acc362e03c2110f6d83acba7d7efef3fd10c6af4 | refs/heads/master | 2021-09-09T11:03:20.489509 | 2018-03-15T10:57:49 | 2018-03-15T10:57:49 | 125,238,047 | 0 | 0 | null | null | null | null | MacCentralEurope | C++ | false | false | 792 | h | axis.h | /***************************************************
Ejes
Roberto Vivů, 2012 (v1.0)
Construye unos ejes en el origen de longitud 1 con una
esfera opcional en el origen. Usa inmediato para dibujar.
Dependencias:
glut.h
***************************************************/
#ifndef RV_AXIS_H
#define RV_AXIS_H
#include <GL/glut.h>
// EJES -------------------------------------
class Ejes{
protected:
GLuint id; //Id de la Display List
bool esfera; //true si se quiere una esfera en el origen
void construir(); //Construye la Display List
public:
Ejes(bool esferaEnOrigen=true):esfera(esferaEnOrigen){construir();}
void dibujarInmediato(){ glCallList(id); } //Dibuja en inmediato llamando a la DL
};
#endif // RV_AXIS_H
|
e5f1efa082801d53d3ade32359a1c3d0876b5495 | 3617447e44ae9a887cf0aed5f3bdce0f742a2b38 | /frameworks/base/libs/rs/rsProgramVertex.cpp | eea8b3b67068474420abb70e4a9fda87fef05dc7 | [
"Apache-2.0",
"LicenseRef-scancode-unicode"
] | permissive | ritesh96310/dexandroid | 8c044d46956da6649df2209fab7cebedcb40e7ee | 6bd3c2ac38887f76cca390ad8329cd619ded3ae7 | refs/heads/master | 2021-01-10T05:14:08.983878 | 2009-12-02T05:27:17 | 2009-12-02T05:27:17 | 55,339,910 | 0 | 1 | null | 2020-03-08T02:33:44 | 2016-04-03T09:54:36 | Java | UTF-8 | C++ | false | false | 5,803 | cpp | rsProgramVertex.cpp | /*
* Copyright (C) 2009 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "rsContext.h"
#include "rsProgramVertex.h"
#include <GLES/gl.h>
#include <GLES/glext.h>
using namespace android;
using namespace android::renderscript;
ProgramVertex::ProgramVertex(Context *rsc, Element *in, Element *out) :
Program(rsc, in, out)
{
mAllocFile = __FILE__;
mAllocLine = __LINE__;
mTextureMatrixEnable = false;
mLightCount = 0;
}
ProgramVertex::~ProgramVertex()
{
}
static void logMatrix(const char *txt, const float *f)
{
LOGV("Matrix %s, %p", txt, f);
LOGV("%6.2f, %6.2f, %6.2f, %6.2f", f[0], f[4], f[8], f[12]);
LOGV("%6.2f, %6.2f, %6.2f, %6.2f", f[1], f[5], f[9], f[13]);
LOGV("%6.2f, %6.2f, %6.2f, %6.2f", f[2], f[6], f[10], f[14]);
LOGV("%6.2f, %6.2f, %6.2f, %6.2f", f[3], f[7], f[11], f[15]);
}
void ProgramVertex::setupGL(const Context *rsc, ProgramVertexState *state)
{
if ((state->mLast.get() == this) && !mDirty) {
return;
}
state->mLast.set(this);
const float *f = static_cast<const float *>(mConstants->getPtr());
glMatrixMode(GL_TEXTURE);
if (mTextureMatrixEnable) {
glLoadMatrixf(&f[RS_PROGRAM_VERTEX_TEXTURE_OFFSET]);
} else {
glLoadIdentity();
}
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
if (mLightCount) {
int v = 0;
glEnable(GL_LIGHTING);
glLightModelxv(GL_LIGHT_MODEL_TWO_SIDE, &v);
for (uint32_t ct = 0; ct < mLightCount; ct++) {
const Light *l = mLights[ct].get();
glEnable(GL_LIGHT0 + ct);
l->setupGL(ct);
}
for (uint32_t ct = mLightCount; ct < MAX_LIGHTS; ct++) {
glDisable(GL_LIGHT0 + ct);
}
} else {
glDisable(GL_LIGHTING);
}
if (!f) {
LOGE("Must bind constants to vertex program");
}
glMatrixMode(GL_PROJECTION);
glLoadMatrixf(&f[RS_PROGRAM_VERTEX_PROJECTION_OFFSET]);
glMatrixMode(GL_MODELVIEW);
glLoadMatrixf(&f[RS_PROGRAM_VERTEX_MODELVIEW_OFFSET]);
mDirty = false;
}
void ProgramVertex::addLight(const Light *l)
{
if (mLightCount < MAX_LIGHTS) {
mLights[mLightCount].set(l);
mLightCount++;
}
}
void ProgramVertex::setProjectionMatrix(const rsc_Matrix *m) const
{
float *f = static_cast<float *>(mConstants->getPtr());
memcpy(&f[RS_PROGRAM_VERTEX_PROJECTION_OFFSET], m, sizeof(rsc_Matrix));
mDirty = true;
}
void ProgramVertex::setModelviewMatrix(const rsc_Matrix *m) const
{
float *f = static_cast<float *>(mConstants->getPtr());
memcpy(&f[RS_PROGRAM_VERTEX_MODELVIEW_OFFSET], m, sizeof(rsc_Matrix));
mDirty = true;
}
void ProgramVertex::setTextureMatrix(const rsc_Matrix *m) const
{
float *f = static_cast<float *>(mConstants->getPtr());
memcpy(&f[RS_PROGRAM_VERTEX_TEXTURE_OFFSET], m, sizeof(rsc_Matrix));
mDirty = true;
}
void ProgramVertex::transformToScreen(const Context *rsc, float *v4out, const float *v3in) const
{
float *f = static_cast<float *>(mConstants->getPtr());
Matrix mvp;
mvp.loadMultiply((Matrix *)&f[RS_PROGRAM_VERTEX_MODELVIEW_OFFSET],
(Matrix *)&f[RS_PROGRAM_VERTEX_PROJECTION_OFFSET]);
mvp.vectorMultiply(v4out, v3in);
}
ProgramVertexState::ProgramVertexState()
{
mPV = NULL;
}
ProgramVertexState::~ProgramVertexState()
{
delete mPV;
}
void ProgramVertexState::init(Context *rsc, int32_t w, int32_t h)
{
rsi_ElementBegin(rsc);
rsi_ElementAdd(rsc, RS_KIND_USER, RS_TYPE_FLOAT, false, 32, NULL);
RsElement e = rsi_ElementCreate(rsc);
rsi_TypeBegin(rsc, e);
rsi_TypeAdd(rsc, RS_DIMENSION_X, 48);
mAllocType.set((Type *)rsi_TypeCreate(rsc));
ProgramVertex *pv = new ProgramVertex(rsc, NULL, NULL);
Allocation *alloc = (Allocation *)rsi_AllocationCreateTyped(rsc, mAllocType.get());
mDefaultAlloc.set(alloc);
mDefault.set(pv);
pv->bindAllocation(alloc);
Matrix m;
m.loadOrtho(0,w, h,0, -1,1);
alloc->subData(RS_PROGRAM_VERTEX_PROJECTION_OFFSET, 16, &m.m[0], 16*4);
m.loadIdentity();
alloc->subData(RS_PROGRAM_VERTEX_MODELVIEW_OFFSET, 16, &m.m[0], 16*4);
}
void ProgramVertexState::deinit(Context *rsc)
{
mDefaultAlloc.clear();
mDefault.clear();
mAllocType.clear();
mLast.clear();
delete mPV;
mPV = NULL;
}
namespace android {
namespace renderscript {
void rsi_ProgramVertexBegin(Context *rsc, RsElement in, RsElement out)
{
delete rsc->mStateVertex.mPV;
rsc->mStateVertex.mPV = new ProgramVertex(rsc, (Element *)in, (Element *)out);
}
RsProgramVertex rsi_ProgramVertexCreate(Context *rsc)
{
ProgramVertex *pv = rsc->mStateVertex.mPV;
pv->incUserRef();
rsc->mStateVertex.mPV = 0;
return pv;
}
void rsi_ProgramVertexBindAllocation(Context *rsc, RsProgramVertex vpgm, RsAllocation constants)
{
ProgramVertex *pv = static_cast<ProgramVertex *>(vpgm);
pv->bindAllocation(static_cast<Allocation *>(constants));
}
void rsi_ProgramVertexSetTextureMatrixEnable(Context *rsc, bool enable)
{
rsc->mStateVertex.mPV->setTextureMatrixEnable(enable);
}
void rsi_ProgramVertexAddLight(Context *rsc, RsLight light)
{
rsc->mStateVertex.mPV->addLight(static_cast<const Light *>(light));
}
}
}
|
c5e0ff6aab89abd5c2576537738d69d3c2f8994f | 5509788aa5c5bacc053ea21796d3ef5ba878d744 | /Practice/2018/2018.9.9/BZOJ2281.cpp | 00581cba6b6237b7ef9bd15202ad5049e20f7c74 | [
"MIT"
] | permissive | SYCstudio/OI | 3c5a6a9c5c9cd93ef653ad77477ad1cd849b8930 | 6e9bfc17dbd4b43467af9b19aa2aed41e28972fa | refs/heads/master | 2021-06-25T22:29:50.276429 | 2020-10-26T11:57:06 | 2020-10-26T11:57:06 | 108,716,217 | 3 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,236 | cpp | BZOJ2281.cpp | #include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<algorithm>
using namespace std;
#define ll long long
#define mem(Arr,x) memset(Arr,x,sizeof(Arr))
const int maxN=10100;
const int maxK=110;
const int maxBit=16;
const int Mod=1e9+7;
const int inf=2147483647;
int n,K,D;
int C[maxN][maxK];
int F[maxBit][maxN];
void Init();
int GetC(int n,int m);
void Plus(int &x,int y);
int main(){
Init();
scanf("%d%d%d",&n,&K,&D);
F[0][0]=1;
for (int i=0;i<maxBit-1;i++){
int nowd=1<<i;
for (int j=0;j<=n-K;j++)
for (int k=0;(k*nowd+j<=n-K)&&(k<=K/2);k+=D+1)
Plus(F[i+1][j+k*nowd],1ll*F[i][j]*GetC(K/2,k)%Mod);
}
/*
for (int i=0;i<maxBit;i++){
for (int j=0;j<=n;j++)
cout<<F[i][j]<<" ";
cout<<endl;
}
//*/
int Ans=0;
for (int i=0;i<=n-K;i++)
Plus(Ans,1ll*F[maxBit-1][i]*GetC(n-i-K/2,K/2)%Mod);
//cout<<Ans<<endl;
Ans=(GetC(n,K)-Ans+Mod)%Mod;
printf("%d\n",Ans);return 0;
}
void Init(){
for (int i=0;i<maxN;i++){
C[i][0]=1;
for (int j=1;j<=min(i,maxK-1);j++)
C[i][j]=(C[i-1][j]+C[i-1][j-1])%Mod;
}
return;
}
int GetC(int n,int m){
if (m>n-m) m=n-m;
//cout<<"GetC:"<<n<<","<<m<<":"<<C[n][m]<<endl;
return C[n][m];
}
void Plus(int &x,int y){
x=(x+y)%Mod;return;
}
|
286737e9bc2a65e99842e86029c075f7781f7484 | 8fcea1c04341761635f690301d0d202b7b5b2fe8 | /src/canvas.cpp | ac38979c6a46d7b71ac8338e1f5eeae2aa2a53fa | [
"MIT"
] | permissive | bplaat/vroemvroem | 2704ae13b9cd604eb0f2b6fe8cb382e7b2ade6ad | 22cf628b4e4e0e3dd9a7008af21f4288ec5ea7a4 | refs/heads/master | 2023-01-05T14:00:36.124746 | 2020-11-04T09:08:48 | 2020-11-04T09:08:48 | 295,848,018 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,209 | cpp | canvas.cpp | // VroemVroem - Canvas
#include "canvas.hpp"
#include <iostream>
Canvas::Canvas(SDL_Window *window) {
renderer = std::unique_ptr<SDL_Renderer, SDL_deleter>(SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC));
if (!renderer) {
std::cerr << "[ERROR] Can't create the SDL renderer: " << SDL_GetError() << std::endl;
exit(EXIT_FAILURE);
}
}
SDL_Renderer *Canvas::getRenderer() const {
return renderer.get();
}
std::unique_ptr<Rect> Canvas::getRect() const {
std::unique_ptr<Rect> rect = std::make_unique<Rect>();
rect->x = 0;
rect->y = 0;
SDL_GetRendererOutputSize(renderer.get(), &rect->width, &rect->height);
return rect;
}
void Canvas::clear(const Color *color) {
SDL_SetRenderDrawColor(renderer.get(), color->red, color->green, color->blue, color->alpha);
SDL_RenderClear(renderer.get());
}
void Canvas::fillRect(const Rect *rect, const Color *color) {
SDL_SetRenderDrawColor(renderer.get(), color->red, color->green, color->blue, color->alpha);
SDL_RenderFillRect(renderer.get(), (SDL_Rect *)rect);
}
void Canvas::drawTexture(SDL_Texture *texture, const Rect *rect) {
SDL_RenderCopy(renderer.get(), texture, nullptr, (SDL_Rect *)rect);
}
void Canvas::drawTexture(SDL_Texture *texture, const Rect *rect, float angle) {
SDL_RenderCopyEx(renderer.get(), texture, nullptr, (SDL_Rect *)rect, degrees(angle), nullptr, SDL_FLIP_NONE);
}
void Canvas::drawTexture(SDL_Texture *texture, const Rect *destinationRect, const Rect *sourceRect) {
SDL_RenderCopy(renderer.get(), texture, (SDL_Rect *)sourceRect, (SDL_Rect *)destinationRect);
}
void Canvas::drawTexture(SDL_Texture *texture, const Rect *destinationRect, const Rect *sourceRect, float angle) {
SDL_RenderCopyEx(renderer.get(), texture, (SDL_Rect *)sourceRect, (SDL_Rect *)destinationRect, degrees(angle), nullptr, SDL_FLIP_NONE);
}
void Canvas::drawLine(int x0, int y0, int x1, int y1, const Color *color) {
SDL_SetRenderDrawColor(renderer.get(), color->red, color->green, color->blue, color->alpha);
SDL_RenderDrawLine(renderer.get(), x0, y0, x1, y1);
}
void Canvas::present() {
SDL_RenderPresent(renderer.get());
}
|
6f29562210dc7154e3e25bcba3e2573f2edbd06f | 549ccffeb6ddad8832ed36d0519ef15b5f141b25 | /source/WhatsApp/Contacts.h | 866c73ca81f83d97f34f6a36f5b061d106b3c8fc | [
"MIT"
] | permissive | andreas-mausch/whatsapp-viewer | 9e4a324e9fb66c64856ae0b0972c61d55715e9ac | f857da400a8b4a7e02138daf1c7f0947860fad17 | refs/heads/master | 2023-07-25T08:19:11.482464 | 2022-11-29T19:54:33 | 2022-11-29T19:54:33 | 18,067,526 | 1,232 | 373 | MIT | 2023-08-28T00:21:40 | 2014-03-24T15:34:22 | C | UTF-8 | C++ | false | false | 105 | h | Contacts.h | #pragma once
class Settings;
void importContacts(Settings &settings, const std::string &wadbFilename);
|
a4a5b3323ef3bec6f92fc40db6037f5064894302 | edb77c71fef5cc475d07eddbd36cae1c9867362b | /3DProject/3DProject/D3DApplication.h | a8a96dee2f7b7ee564093bfd938b8ed8365c824a | [] | no_license | KimRestad/3D-II-Lab2 | a95ee7a5743738a660b71b0f094ad69bb720ad18 | 15136b0470a54d60765eb1e11b09f41c917a2981 | refs/heads/master | 2021-01-22T09:27:22.157250 | 2012-07-06T13:38:19 | 2012-07-06T13:38:19 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,488 | h | D3DApplication.h | #ifndef D3DAPPLICATION_H
#define D3DAPPLICATION_H
#include <D3DX10.h>
#include "Globals.h"
#pragma comment(lib, "d3d10.lib")
class D3DApplication
{
public:
D3DApplication(HINSTANCE applicationInstance, LPCTSTR windowTitle = "ApplicationWindow",
UINT windowWidth = CW_USEDEFAULT, UINT windowHeight = CW_USEDEFAULT);
virtual ~D3DApplication();
int Run();
virtual LRESULT HandleAppMessages(UINT message, WPARAM wParam, LPARAM lParam);
private:
// Window variables
HWND mWindowHandle;
// Direct3D variables
IDXGISwapChain* mSwapChain;
//ID3D10RenderTargetView* mRenderTarget;
ID3D10Texture2D* mDepthStencilBuffer;
//ID3D10DepthStencilView* mDepthStencilView;
D3DXCOLOR mClearColor;
// Methods
D3DApplication(); // Default contstructor is private, the other constructor must be used
bool InitWindowsApplication(HINSTANCE applicationHandle, LPCTSTR title, int showSetting);
HRESULT InitializeDirect3D();
void CalculateWindowSize();
HRESULT SetUpView();
HRESULT CreateSwapChain();
HRESULT CreateRenderTargetView();
HRESULT CreateDepthStencil();
void SetUpViewport();
protected:
ID3D10Device* mDeviceD3D;
UINT mScreenWidth;
UINT mScreenHeight;
ID3D10DepthStencilView* mDepthStencilView;
ID3D10RenderTargetView* mRenderTarget;
void ShowErrorMessage(LPCSTR message);
virtual void ProgramLoop();
void ClearScene();
void RenderScene();
virtual void OnResize();
void Quit();
};
#endif |
3c4e9d50c0905b3324fbd0da9391de65517eb181 | 1d33f6391b5b1fe3ad3baf4c1552421b30feadcd | /CommProtoLib/interface/commproto/variable/VariableParser.h | 130e313fd272bf3b5abcca0de0c3160c1ce6fead | [] | no_license | Bluegent/CommProto | 35815011bc62a4c5f59f12c4531ebd693d1eaf26 | 20635cf4ee16b937b5ad58da6eb5bfcd4591c081 | refs/heads/master | 2023-06-11T12:10:28.611025 | 2021-06-30T08:11:03 | 2021-06-30T08:11:03 | 316,043,136 | 0 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 1,500 | h | VariableParser.h | #ifndef COMMPROTO_VARIABLE_PARSER_H
#define COMMPROTO_VARIABLE_PARSER_H
#include <commproto/variable/Variable.h>
#include <commproto/parser/Parser.h>
#include <commproto/logger/Logging.h>
namespace commproto
{
namespace variable
{
class VariableParser : public parser::Parser
{
public:
VariableParser(const parser::HandlerHandle& handler_)
: Parser(handler_)
{
}
template <typename T>
void parse(parser::ByteStream&& msg, const uint32_t index, const ValueType type);
void parse(parser::ByteStream&& msg) override;
};
inline void VariableParser::parse(parser::ByteStream&& msg)
{
uint8_t valueType = 0;
uint32_t index = 0;
uint32_t sender = 0;
msg.read(sender);
msg.read(valueType);
msg.read(index);
ValueType type = static_cast<ValueType>(valueType);
switch (type)
{
case ValueType::integer32:
parse<uint32_t>(std::move(msg), index, type);
break;
case ValueType::string:
parse<std::string>(std::move(msg), index, type);
break;
case ValueType::real32:
parse<float>(std::move(msg), index, type);
break;
case ValueType::bool8:
parse<bool>(std::move(msg), index, type);
break;
default: ;
}
}
template <typename T>
void VariableParser::parse(parser::ByteStream&& msg, const uint32_t index, const ValueType type)
{
T value{};
msg.read(value);
handler->handle(std::move(VariableMessageTemplated<T>(0, type, index, value)));
}
}
}
#endif //COMMPROTO_VARIABLE_PARSER_H
|
d965b9bb3687a4bb6319f111cb97356001a06d6c | 3d40dd8241e1570e240aaf5a1db3535d97351ba0 | /ConfigData.hpp | f89a5f199d234ca33da75621fc37644c0ce6ea07 | [
"BSD-2-Clause"
] | permissive | VSEiliNIChEGO/libvos | c651c3b360b275954ac299984c0792f64e7d9f07 | 749f59d71ac2d0e43ddbf44724bdd0964054b858 | refs/heads/master | 2021-01-17T21:38:09.461277 | 2011-11-03T04:46:33 | 2011-11-03T04:46:33 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,573 | hpp | ConfigData.hpp | /*
* Copyright (C) 2010 kilabit.org
* Author:
* - m.shulhan (ms@kilabit.org)
*/
#ifndef _LIBVOS_CONFIG_DATA_HPP
#define _LIBVOS_CONFIG_DATA_HPP 1
#include "Buffer.hpp"
namespace vos {
enum _config_type {
CONFIG_T_NONE = 0
, CONFIG_T_HEAD
, CONFIG_T_KEY
, CONFIG_T_VALUE
, CONFIG_T_MISC
};
/**
* @class : ConfigData
* @attr :
* - _t : type of config data.
* - _value : value of config data object.
* - _next_head : pointer to the next header.
* - _last_head : pointer to the last header.
* - _next_key : pointer to the next key.
* - _last_key : pointer to the last key.
* @desc :
* ConfigData is a class that mapping all header, key, value, and
* comments from ini config file to list of object in memory.
*/
class ConfigData : public Buffer {
public:
ConfigData();
~ConfigData();
int init(const int type, const char* data, int len = 0);
void add_head(const ConfigData* head);
int add_head_raw(const char* head, int len = 0);
void add_key(const ConfigData* key);
int add_key_raw(const char* key, int len = 0);
int add_value(const ConfigData* value);
int add_value_raw(const char* value, int len = 0);
void add_misc(const ConfigData* misc);
int add_misc_raw(const char* misc, int len = 0);
void dump();
int _t;
ConfigData* _value;
ConfigData* _next_head;
ConfigData* _last_head;
ConfigData* _next_key;
ConfigData* _last_key;
static int INIT(ConfigData** o, const int type, const char* data
, int len = 0);
private:
ConfigData(const ConfigData&);
void operator=(const ConfigData&);
};
} /* namespace::vos */
#endif
|
f50501f92549a231a193ffe99154fa30da7ddcde | 4c1f84b8e8323d6815e084907a883b6c0da8497a | /sociplus/include/sociplusquery.h | 48ea7c9683f77923488ef94f98af7098292b0a23 | [
"MIT"
] | permissive | ecmadrid/sociplus | 8f11797ebdf5253b9ec0ee0fe2ede5156c4b4c7c | 853543bc07e5b9c7b59b72883502fe6600377084 | refs/heads/master | 2020-05-15T23:24:50.144804 | 2014-09-01T15:31:34 | 2014-09-01T15:31:34 | null | 0 | 0 | null | null | null | null | WINDOWS-1250 | C++ | false | false | 2,770 | h | sociplusquery.h | //////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////
//
// copyright : (C) 2014 by Juan Sánchez Rangel
// file name : sociplusquery.h
//
// -------------------------------------------------------------------------
//
// SOCIPLUS
//
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the MIT License.
//
// -------------------------------------------------------------------------
//
// The MIT License (MIT)
//
// Copyright (c) 2014 Juan Sánchez Rangel
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in all
// copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
// SOFTWARE.
//
//////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////
#ifndef SOCIPLUSQUERY_H
#define SOCIPLUSQUERY_H
#include "sociplusconnection.h"
#include "sociplusdatatablemodel.h"
namespace SociPlus
{
/* Data type field definitions */
#define TYPE_UNKNOWN "unknown"
#define TYPE_STRING "string"
#define TYPE_DOUBLE "double"
#define TYPE_INTEGER "integer"
#define TYPE_LONG_LONG "long_long"
#define TYPE_UNSIGNED_LONG_LONG "unsigned_long_long"
#define TYPE_DATE "date"
/* End of data type field definitions */
class SociPlusQuery
{
public:
SociPlusQuery(SociPlusConnection *connection);
virtual ~SociPlusQuery();
virtual bool Execute(string query);
virtual SociPlusDataTableModel *ExecuteToModel(string query);
protected:
private:
SociPlusConnection *m_connection;
};
};
#endif // SOCIPLUSQUERY_H
|
943437c264e08a1efa95c5e7bf2d110e41218b83 | ea672ffcacf8dff1fcceb796ca61a5e0d35f0dee | /es_esami/tris/partita.cpp | b5942c8b1e96eb87fcf98408497031f5bfd37271 | [] | no_license | Loyakin/ExperiencingC-- | 3eb3b4142ebfbd99b8306083ac95ea56bb257e73 | 0148bd9ce886f6857ad20f87db33ea1596d67c37 | refs/heads/master | 2016-09-05T17:11:55.640998 | 2014-01-21T18:21:45 | 2014-01-21T18:21:45 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 570 | cpp | partita.cpp | #include<iostream>
#include"partita.h"
#include"giocatore.h"
#include"umano.h"
#include"computer.h"
#include"scacchiera.h"
using std::cout;
void Partita::set_partita(Giocatore& p1, Giocatore& p2, Scacchiera& b)
{
g1=&p1;
g2=&p2;
s=&b;
}
int Partita::play()
{
int game=0;
while (game==0)
{
cout<<"è il turno del giocatore 1\n";
game=g1->moove();
if(game==1) cout<<"il giocatore 1 ha vinto!\n";
else
{
cout<<"è il turno del goicatore 2\n";
game==g2->moove();
if (game==1) cout<<"il giocatore 2 ha vinto!\n";
}
return(game);
}
}
|
8296edcb6bd467b99443cbb2b3206dd06d7377c0 | 9c0451c4e534d178531cbf93928bcf8b512327af | /codes/programming-contest/leetcode/leetcode-0126-1.cpp | 5cf58a555c7598d21fe74dd59bb5916e1d8245d5 | [] | no_license | JM233333/jm233333.github.io | 491edc20e2e22709469dd8d1438bf631f0b453ad | ec341f14e48646d2670a487f1bba21e0645ca01e | refs/heads/master | 2023-07-21T06:03:55.692029 | 2023-07-12T12:03:00 | 2023-07-12T12:03:00 | 226,253,740 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,672 | cpp | leetcode-0126-1.cpp | class Solution {
public:
typedef vector<vector<int>> adjList;
const int INF = 1e9;
public:
vector<vector<string>> findLadders(const string & beginWord, const string & endWord, vector<string> & wordList) {
// 预处理
int st = -1, ed = -1;
for (int i = 0; i < wordList.size(); i ++) {
if (wordList[i] == beginWord) st = i;
if (wordList[i] == endWord) ed = i;
}
if (st == -1) {
wordList.push_back(beginWord);
st = wordList.size() - 1;
}
if (ed == -1) {
return vector<vector<string>>();
}
// 建图
int n = wordList.size();
adjList graph(n, vector<int>());
for (int i = 0; i < n; i ++) for (int j = i + 1; j < n; j ++) {
if (has_edge(wordList[i], wordList[j])) {
add_edge(graph, i, j);
}
}
// BFS
vector<int> dist(n, INF);
bfs(graph, st, ed, dist);
// 无解的情况
if (dist[ed] == INF) {
return vector<vector<string>>();
}
// DFS
vector<int> seq;
vector<vector<int>> vecseq;
dfs(st, seq, vecseq, graph, ed, dist);
// 返回
vector<vector<string>> res;
for (auto & seq : vecseq) {
vector<string> tmp;
for (auto & u : seq) {
tmp.push_back(wordList[u]);
}
res.push_back(tmp);
}
return res;
}
// 判断是否仅差一个字母
bool has_edge(const string & a, const string & b) {
// 特判
if (a.length() != b.length()) {
return false;
}
// 遍历
int cnt = 0;
for (int i = 0; i < a.length(); i ++) {
if (a[i] != b[i]) {
cnt ++;
if (cnt > 1) return false;
}
}
// 返回
return (cnt == 1);
}
// 加入新边
inline void add_edge(adjList & graph, int u, int v) {
graph[u].push_back(v);
graph[v].push_back(u);
}
// 广度优先搜索
void bfs(adjList & graph, int st, int ed, vector<int> & dist) {
// 初始化
int n = graph.size();
vector<bool> visited(n, false);
// 主循环
queue<int> q;
q.push(st);
visited[st] = true;
dist[st] = 0;
while (!q.empty()) {
// 出队
int u = q.front();
q.pop();
// 遍历邻接节点
for (int i = 0; i < graph[u].size(); i ++) {
int v = graph[u][i];
if (!visited[v]) {
q.push(v);
visited[v] = true;
dist[v] = dist[u] + 1;
}
}
}
}
// 深度优先搜索
void dfs(int u, vector<int> & seq, vector<vector<int>> & vecseq,
const adjList & graph, const int ed, const vector<int> & dist) {
// 递归终止
if (u == ed) {
seq.push_back(u);
vecseq.push_back(seq);
seq.pop_back();
return;
}
// 递归
seq.push_back(u);
for (int i = 0; i < graph[u].size(); i ++) {
int v = graph[u][i];
if (dist[v] == dist[u] + 1) {
dfs(v, seq, vecseq, graph, ed, dist);
}
}
// 回溯
seq.pop_back();
}
};
|
13bfd0acdde4eda67b9e7c7f9e1020b5a1f1d01e | 3271c9ba12bef2ab5110ad27d5a389ec0aee783d | /P3/pedido-articulo.hpp | 6dd3af319c1f5a816bd98cf2f5b1a8e60c83a560 | [] | no_license | lokeon-university/POO | 7dbb2056af90af727b9a0f21600008ac8f8823ae | 52f46df465206f4b17fe61660d866620723261f2 | refs/heads/master | 2020-03-12T13:42:47.302141 | 2018-05-24T17:13:27 | 2018-05-24T17:13:27 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,807 | hpp | pedido-articulo.hpp |
#ifndef PED_ART_HPP
#define PED_ART_HPP
#include <map>
#include <utility>
#include "pedido.hpp"
#include "articulo.hpp"
struct OrdenaPedidos: public std::binary_function <Pedido*,Pedido*,bool>
{
bool operator()(const Pedido* ped1, const Pedido* ped2) const { return ped1->numero() < ped2->numero() ;}
};
struct OrdenaArticulos: public std::binary_function<Articulo*,Articulo*,bool>
{
bool operator()(const Articulo* art1, const Articulo* art2) const { return art1->referencia() < art2->referencia() ;}
};
class LineaPedido
{
public:
explicit LineaPedido(double pre, unsigned int cant = 1);
double precio_venta() const ;
unsigned cantidad() const ;
private:
double precio_venta_ ;
unsigned cantidad_;
};
inline double LineaPedido::precio_venta() const
{
return precio_venta_ ;
}
inline unsigned LineaPedido::cantidad() const
{
return cantidad_ ;
}
std::ostream& operator << (std::ostream& os, const LineaPedido& op) ;
class Pedido_Articulo
{
public:
typedef std::map <Articulo*, LineaPedido, OrdenaArticulos> ItemsPedido ;
typedef std::map <Pedido*, LineaPedido, OrdenaPedidos > Pedidos ;
void pedir(Pedido& ped, Articulo& art,double precio, unsigned cantidad = 1) ;
void pedir(Articulo& art, Pedido& ped,double precio, unsigned cantidad = 1) ;
ItemsPedido& detalle(Pedido& ped) ;
Pedidos ventas(Articulo& art) ;
std::ostream& mostrarDetallePedidos(std::ostream& os) ;
std::ostream& mostrarVentasArticulos(std::ostream& os) ;
private:
std::map <Pedido*, ItemsPedido, OrdenaPedidos> Ped_Art_ ;
std::map <Articulo*, Pedidos, OrdenaArticulos> Art_Ped_ ;
};
std::ostream& operator <<(std::ostream& os, const Pedido_Articulo::ItemsPedido& A) ;
std::ostream& operator <<(std::ostream& os, const Pedido_Articulo::Pedidos& B) ;
#endif // PED_ART_HPP
|
dbc415d54f8634652d818dc1f93afa80faf57ba2 | a1c52daea199dd1888191771f714f77f46cbd46b | /jc2018/jc_atasat/surse/gordonramsay/tinca.cpp | 87b189ae05f8ed6720bbc6d5856ce57a1651d7d8 | [] | no_license | georgerapeanu/my_contests | 5a2ca0cd50ccbc8b8472da5a982bade652e7a817 | 943c646ff2cf14ab422001caaa6a75e9508f4e8c | refs/heads/master | 2020-08-20T19:20:45.504157 | 2019-10-18T15:48:13 | 2019-10-18T15:48:13 | 216,057,791 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 4,627 | cpp | tinca.cpp | #include <bits/stdc++.h>
/*
Solutie gordon
Complexitate in timp: O(N*K*log^2)
CU PARSARE
*/
class InParser {
private:
FILE *fin;
char *buff;
int sp;
char read_ch() {
++sp;
if (sp == 4096) {
sp = 0;
fread(buff, 1, 4096, fin);
}
return buff[sp];
}
public:
InParser(const char* nume) {
fin = fopen(nume, "r");
buff = new char[4096]();
sp = 4095;
}
InParser& operator >> (int &n) {
char c;
while (!isdigit(c = read_ch()) && c != '-');
int sgn = 1;
if (c == '-') {
n = 0;
sgn = -1;
} else {
n = c - '0';
}
while (isdigit(c = read_ch())) {
n = 10 * n + c - '0';
}
n *= sgn;
return *this;
}
InParser& operator >> (long long &n) {
char c;
n = 0;
while (!isdigit(c = read_ch()) && c != '-');
long long sgn = 1;
if (c == '-') {
n = 0;
sgn = -1;
} else {
n = c - '0';
}
while (isdigit(c = read_ch())) {
n = 10 * n + c - '0';
}
n *= sgn;
return *this;
}
} fin("gordonramsay.in");
using namespace std;
// Restrictiile problemei
const int MAX_N = 1000000;
const int MAX_K = 1000000;
// Comenzile noastre
int comenzi[MAX_N];
// Caracteristicile fiecarui aliment
int cost[MAX_K], profit[MAX_K], rezist[MAX_K];
// Pentru fiecare bucket vedem cate alimente putem satisface
int bucks[MAX_N + 1];
// Smenul lui Mars pentru fiecare aliment
// Ca sa aflam in O(1) cate alimente de un fel sunt intr-un interval
int **smen;
// Ne returneaza smenul lui Mars chiar si daca n-ul e in afara
static inline int getSmen(int k, int n, int maxn) {
if (n < 0)
return 0;
return smen[k][min(maxn - 1, n)];
}
// Numarul de alimente din fiecare tip
int lim[MAX_K];
// Solutia problemei
int trez;
int xrez[MAX_K];
// Profitul maxim scos
long long best;
// X-uri intermediare
int xint[MAX_K];
int main() {
// N si K din problema
int n, k;
// Fisierele din problema
FILE *fout = fopen("gordonramsay.out", "w");
// Citim alimentele
fin >> n >> k;
// Ne alocam dinamic o matrice
smen = new int*[k];
for(int i = 0; i < k; ++i)
smen[i] = new int[n];
for (int i = 0; i < n; ++i) {
fin >> comenzi[i];
// Decrementam comenzile ca sa fie indexate de la 0
--comenzi[i];
// Calculam frecventele pt fiecare aliment
lim[comenzi[i]]++;
// Initializam smenul lui Mars
smen[comenzi[i]][i]++;
}
for(int i = 0; i < k; ++i)
fin >> cost[i] >> profit[i] >> rezist[i];
// Calculam smenul lui Mars
for (int i = 0; i < k; ++i)
for (int j = 1; j < n; ++j)
smen[i][j] += smen[i][j - 1];
int start = 1;
if(n * k > 200000)
start = 100;
// Iteram prin toate t-urile
for (int t = start; t <= n; ++t) {
// Profitul scos pentru un t fixat
long long profitt = 0LL;
for (int i = 0; i < k; ++i) {
int top = 0;
for (int j = 0; j < n; j += t) // Pana aici e O(N*K*logN)
bucks[top++] = getSmen(i, min(j + rezist[i] - 1, j + t - 1), n) - getSmen(i, j - 1, n);
// Cel mai mare profit respectiv x-ul pt care se obtine profitul maximal
long long bestprofitx = 0LL;
int bestx = 0;
// Suma alimentelor din bucketurile care au marime mai mica decat un x fixat
int maimici = 0;
// Vrem sa testam si X == 0
bucks[top] = 0;
sort(bucks, bucks + top + 1);
for(int j = 0; j <= top; ++j) {
long long profitx = 0LL;
// Calculam profitul optim pentru un anumit punct
profitx = (long long)maimici * profit[i] + (long long)bucks[j] * (top - j + 1) * profit[i]
- (long long)cost[i] * bucks[j] * top;
// Actualizam optimul
if (profitx > bestprofitx) {
bestprofitx = profitx;
bestx = bucks[j];
}
// Avem grija de elementele care vor fi mai mici decat urmatorul X
maimici += bucks[j];
}
xint[i] = bestx;
profitt += bestprofitx;
}
// Daca obtinem o solutie mai buna o actualizam
if(profitt > best) {
best = profitt;
trez = t;
for(int i = 0; i < k; ++i)
xrez[i] = xint[i];
}
}
//Afisam rezultatele
fprintf(fout, "%lld\n%d\n", best, trez);
for(int i = 0; i < k; ++i)
fprintf(fout, "%d ", xrez[i]);
// Inchidem fisierele
fclose(fout);
return 0;
} |
44b507133d0197128c7d3c9fd66cd11e4cefbdea | 45e57ad1d7907f96e56028151db23cff469734f2 | /WinterFrameWork/AssemblyPlant.h | d701349be35c57d572d64f8b873da7faf11764f4 | [] | no_license | dongjingyang/WinterFrameWork | baf98a5e4eebe40b67252c24904fa73d86554afd | 60e1d7be084d57f4a62b81022a85b9865676244f | refs/heads/master | 2016-09-05T10:18:23.706790 | 2015-12-15T14:53:15 | 2015-12-15T14:53:15 | 19,060,502 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 260 | h | AssemblyPlant.h | #pragma once
#include "RunningObjTable.h"
namespace Winter
{
class CXmlMine;
class CRunningObjTable;
class CAssemblyPlant
{
public:
CAssemblyPlant(CXmlMine* xmlMine);
~CAssemblyPlant();
private:
HRESULT AssemblyLibrary(CXmlMine* xmlMine);
};
}
|
ada05fc192da3c3339092a0e3be19925be98b2bf | 14845f995a17618db2126c5766e8e4ab1549d0aa | /practica_1/include/objetos.h | 0dd848f7d0d63d883746af81a23a1874e176237f | [] | no_license | blancabgz/UGR-IG | c2480efcb8bf4d03a5a28dff5156daa8ad3e827f | 6bc6ad9ca5a8ce5845f26a59c7bf562dfa0fc963 | refs/heads/master | 2023-03-17T09:56:08.895405 | 2017-12-30T14:34:35 | 2017-12-30T14:34:35 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,810 | h | objetos.h | //**************************************************************************
// Práctica 1 usando objetos
//**************************************************************************
#include <vector>
#include <GL/gl.h>
#include "vertex.h"
#include <stdlib.h>
#include <cmath>
using namespace std;
// const float AXIS_SIZE = 5000;
//*************************************************************************
// clase punto
//*************************************************************************
class _puntos3D {
public:
vector<_vertex3f> vertices;
vector<_vertex3f> colores;
_puntos3D();
void draw_puntos(float r, float g, float b, int grosor);
};
//*************************************************************************
// clase triángulo
//*************************************************************************
class _triangulos3D : public _puntos3D {
private:
void draw_circulo(float radio, float x, float y, float z, int n);
public:
vector<_vertex3i> caras;
_triangulos3D();
void draw_color_vertices();
void draw_circulos_vertices(float radio, int resolucion);
void draw_aristas(float r, float g, float b, int grosor);
void draw_solido(float r, float g, float b);
void draw_solido_ajedrez(float r1, float g1, float b1, float r2, float g2, float b2);
};
//*************************************************************************
// clase cubo
//*************************************************************************
class _cubo : public _triangulos3D {
public:
_cubo(float tam=0.5);
};
//*************************************************************************
// clase piramide
//*************************************************************************
class _piramide : public _triangulos3D {
public:
_piramide(float tam=0.5, float al=0.75);
};
|
ee5dce0fe960aa0a5c87e338ee2566436eb81492 | 030ab431d764681a67d581388487416fdc7656f0 | /ThermocyclerV1/ThermocyclerV1.ino | 58e19e595b457f21d717b6470f250deb8a53c96a | [] | no_license | meduag/ThermocyclerV1 | 6faf33a555587f9f8af974fe990355e171947fb2 | 827912e9e52931e651fb1f42900e46ef05f9723c | refs/heads/master | 2020-12-24T20:10:35.037706 | 2017-04-02T23:04:55 | 2017-04-02T23:04:55 | 86,243,357 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,398 | ino | ThermocyclerV1.ino | #include <LiquidCrystal.h>
// select the pins used on the LCD panel
LiquidCrystal lcd(8, 13, 9, 4, 5, 6, 7);
int pinS = 52;
int lcd_key = 0;
int adc_key_in = 0;
#define btnRIGHT 0
#define btnUP 1
#define btnDOWN 2
#define btnLEFT 3
#define btnSELECT 4
#define btnNONE 5
void setup()
{
pinMode(pinS, OUTPUT);
digitalWrite(pinS, HIGH);
lcd.begin(16, 2); // inicializa a LCD
//dados iniciais mostrados na LCD
lcd.setCursor(0, 0);
lcd.print("TermoC v1");
Serial.begin(9600);
delay(2000);
digitalWrite(pinS, LOW);
}
void loop()
{
int sensorValue = analogRead(A8);
Serial.println(sensorValue);
float paso = 0.00488;//1024 representar 5 vol 5/1024 = 0.00488
float svc = (sensorValue * 0.00488) * 10;
//svc = map(sensorValue,0, 1024, 0, 5000);
lcd.setCursor(0, 0);
lcd.print("teste tempeatura");
lcd.setCursor(0, 1);
lcd.print(svc);
delay(300);
for (int i = 0; i <= 10; i++) {
digitalWrite(pinS, HIGH);
delay(3000);
digitalWrite(pinS, LOW);
delay(3000);
}
}
// read the buttons
int read_LCD_buttons()
{
adc_key_in = analogRead(0);
if (adc_key_in > 1000) return btnNONE;
if (adc_key_in < 50) return btnRIGHT;
if (adc_key_in < 250) return btnUP;
if (adc_key_in < 450) return btnDOWN;
if (adc_key_in < 650) return btnLEFT;
if (adc_key_in < 850) return btnSELECT;
return btnNONE;
}
|
5addd0e87087aa789f75613a9c7fc24090d1f413 | 2603f4c3166adf617d847b8b79fa5f017bfe4b02 | /string/q01.max_occuring_char.cpp | f85c0c177b2eabb84646a96c8b25113f847df1c2 | [] | no_license | rish2394/data-structures | 88c94e45745fa22a2a65993f37120e5b5c1100d8 | 89c27cb42141b952bbbedb4b9ac49e842d5c91ee | refs/heads/master | 2020-05-23T08:00:26.440830 | 2017-04-07T15:16:21 | 2017-04-07T15:16:21 | 80,484,323 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,385 | cpp | q01.max_occuring_char.cpp | #include<iostream>
using std::cout;
using std::endl;
using std::cin;
#include<string>
using std::string;
#include<unordered_map>
using std::unordered_map;
#include<climits>
typedef unordered_map<char, int> Map;
typedef Map::iterator iter;
/* unordered map is implementation of hash table which takes O(1) for searching on average */
void fillMap(string str, Map &myMap) {
for(int i=0; str[i] != '\0'; i++) {
iter it = myMap.find(str[i]);
if(it == myMap.end()) {
myMap.insert(Map::value_type(str[i], 1));
}
else {
it->second++;
}
}
}
char getMaxChar(Map myMap) {
int max = INT_MIN;
char answer;
for(iter it = myMap.begin(); it != myMap.end(); it++) {
if(max < it->second) {
max = it->second;
answer = it->first;
}
}
return answer;
}
int main() {
string str;
Map myMap;
cout << "Enter string:";
cin >> str;
getchar();
fillMap(str, myMap);
cout << "The first maximum occuring character is: " << getMaxChar(myMap) << endl;
return 0;
}
/*
Time Complexity - O(n) if we consider that look up in hash table takes O(1) on average, look up on hash table is much faster than tree
Time Complexity - O(n^2) if we consider that look up takes O(n) which is the worst case
If we solve this problem by map which is the implementation of the RBT which takes O(Logn) time to search n element
So, in that time cmpleixty will be O(nLogn)
*/
|
b3cafcc584a8d734f68b8957e76bed1e7e7634fd | 5e50cab1d6a6be4bf0565830556594c1b5839109 | /3/Ex2/函数定义.cpp | 8bba6ec5609a5adf3363aec45088d684a3b0aed6 | [] | no_license | ALOHAme/C- | 4c9ee028b89753439aff89a569ce24149ece092b | d98795bedca932b40d7028cdc1c025afeb742a0d | refs/heads/master | 2021-10-11T06:41:47.569393 | 2019-01-23T04:36:29 | 2019-01-23T04:36:29 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 783 | cpp | 函数定义.cpp | #include<iostream>
#include"Ex2.h";
using namespace std;
Salary::Salary(int salaryone,int salarytwo,double Percentage)
{
setSalary(salaryone, salarytwo);
setPercentage(Percentage);
}
void Salary::setSalary(int salaryone,int salarytwo)
{
salary1 =salaryone;
salary2 = salarytwo;
}
void Salary::setPercentage(double Percentage)
{
percentage = Percentage;
}
int Salary::getSalary1()
{
return salary1;
}
int Salary::getSalary2()
{
return salary2;
}
double Salary::getPercentage()
{
return percentage;
}
void Salary::displayMessage()
{
cout << "Employee 1:Bob Jones; Yearly Salary:" << getSalary1()*(1+getPercentage())
<< "\n"
<< "Employee 2:Susan Baker; Yearly Salary:" << getSalary2()*(1 + getPercentage())
<< "\n";
} |
54e81e9778155c2ef3a4d53376b2ea5a77c878e9 | fa35c5b787c1a35b0735dcf03a3e6e38f3f54a6d | /Silver/PrefixSums/subsequences_summing_to_sevens.cpp | 0a6543d7a6279809aabe89c5432021b9f620c278 | [] | no_license | rbruno95/usaco-guide | fc69d2b17f05609e97be7130f1f41abe144c7ec7 | bfbf38476f237a190b1d11684f16c42357911919 | refs/heads/master | 2023-06-21T00:07:13.107873 | 2021-07-19T01:18:46 | 2021-07-19T01:18:46 | 383,178,780 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 489 | cpp | subsequences_summing_to_sevens.cpp | #include <bits/stdc++.h>
#define endl '\n'
using namespace std;
int main(){
ios_base::sync_with_stdio(0);
cin.tie(0);
freopen("div7.in", "r", stdin);
freopen("div7.out", "w", stdout);
int n;
cin >> n;
map<int,int> mp;
mp[0] = 0;
int sum = 0;
int best = 0;
for(int i=1;i<=n;i++){
int x;
cin >> x;
(sum += x) %= 7;
if(mp.count(sum)) best = max(i - mp[sum], best);
else mp[sum] = i;
}
cout << best << endl;
return 0;
}
|
cf432859286c14d37e2b3d1ebd242804af7d1bea | 6419d0c57a7562536bb17f74dae3af1a2423bd64 | /whisperlib/http/http_consts.h | 7636844a5e8ebc1950785720a75aa47d042acac6 | [] | no_license | cpopescu/whisperlib | 919c9ec47b9396a3af7d7e79208b2d8a9f340095 | 65eb669602c43708d82c6aac3c8037db8c05d58d | refs/heads/master | 2020-04-06T06:58:26.946008 | 2016-07-18T23:28:44 | 2016-07-18T23:28:44 | 6,740,973 | 6 | 1 | null | 2014-04-08T19:45:12 | 2012-11-17T22:41:48 | C++ | UTF-8 | C++ | false | false | 12,192 | h | http_consts.h | // Copyright (c) 2009, Whispersoft s.r.l.
// 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 Whispersoft s.r.l. 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
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
// Author: Catalin Popescu
//
// Various HTTP specific constants
#ifndef __NET_HTTP_HTTP_CONSTS_H__
#define __NET_HTTP_HTTP_CONSTS_H__
#include "whisperlib/base/types.h"
namespace whisper {
namespace http {
//////////////////////////////////////////////////////////////////////
//
// HTTP Return codes
//
enum HttpReturnCode {
UNKNOWN = 0,
// Continuation codes
CONTINUE = 100,
SWITCHING_PROTOCOLS = 101,
// OK codes
OK = 200,
CREATED = 201,
ACCEPTED = 202,
NON_AUTHORITATIVE_INFORMATION = 203,
NO_CONTENT = 204,
RESET_CONTENT = 205,
PARTIAL_CONTENT = 206,
// Redirections / choices
MULTIPLE_CHOICES = 300,
MOVED_PERMANENTLY = 301,
FOUND = 302,
SEE_OTHER = 303,
NOT_MODIFIED = 304,
USE_PROXY = 305,
TEMPORARY_REDIRECT = 307,
// Client error codes
BAD_REQUEST = 400,
UNAUTHORIZED = 401,
PAYMENT_REQUIRED = 402,
FORBIDDEN = 403,
NOT_FOUND = 404,
METHOD_NOT_ALLOWED = 405,
NOT_ACCEPTABLE = 406,
PROXY_AUTHENTICATION_REQUIRED = 407,
REQUEST_TIME_OUT = 408,
CONFLICT = 409,
GONE = 410,
LENGTH_REQUIRED = 411,
PRECONDITION_FAILED = 412,
REQUEST_ENTITY_TOO_LARGE = 413,
REQUEST_URI_TOO_LARGE = 414,
UNSUPPORTED_MEDIA_TYPE = 415,
REQUESTED_RANGE_NOT_SATISFIABLE = 416,
EXPECTATION_FAILED = 417,
// Server error codes
INTERNAL_SERVER_ERROR = 500,
NOT_IMPLEMENTED = 501,
BAD_GATEWAY = 502,
SERVICE_UNAVAILABLE = 503,
GATEWAY_TIME_OUT = 504,
HTTP_VERSION_NOT_SUPPORTED = 505,
};
const char* GetHttpReturnCodeDescription(HttpReturnCode code);
const char* GetHttpCodeDescription(int32 code);
const char* GetHttpReturnCodeName(HttpReturnCode code);
//////////////////////////////////////////////////////////////////////
//
// Various standard HTTP header names
//
// General headers
static const char kHeaderCacheControl[] = "Cache-Control";
static const char kHeaderConnection[] = "Connection";
static const char kHeaderDate[] = "Date";
static const char kHeaderPragma[] = "Pragma";
static const char kHeaderTrailer[] = "Trailer";
static const char kHeaderTransferEncoding[] = "Transfer-Encoding";
static const char kHeaderUpgrade[] = "Upgrade";
static const char kHeaderVia[] = "Via";
static const char kHeaderWarning[] = "Warning";
// Request headers
static const char kHeaderAccept[] = "Accept";
static const char kHeaderAcceptCharset[] = "Accept-Charset";
static const char kHeaderAcceptEncoding[] = "Accept-Encoding";
static const char kHeaderAcceptLanguage[] = "Accept-Language";
static const char kHeaderAuthorization[] = "Authorization";
static const char kHeaderExpect[] = "Expect";
static const char kHeaderFrom[] = "From";
static const char kHeaderHost[] = "Host";
static const char kHeaderIfMatch[] = "If-Match";
static const char kHeaderIfModifiedSince[] = "If-Modified-Since";
static const char kHeaderIfNoneMatch[] = "If-None-Match";
static const char kHeaderIfRange[] = "If-Range";
static const char kHeaderIfUnmodifiedSince[] = "If-Unmodified-Since";
static const char kHeaderMaxForwards[] = "Max-Forwards";
static const char kHeaderProxyAuthorization[] = "Proxy-Authorization";
static const char kHeaderRange[] = "Range";
static const char kHeaderReferer[] = "Referer";
static const char kHeaderTE[] = "TE";
static const char kHeaderUserAgent[] = "User-Agent";
// Response headers
static const char kHeaderAcceptRanges[] = "Accept-Ranges";
static const char kHeaderAge[] = "Age";
static const char kHeaderETag[] = "ETag";
static const char kHeaderKeepAlive[] = "Keep-Alive";
static const char kHeaderProxyAuthenticate[] = "Proxy-Authenticate";
static const char kHeaderRetryAfter[] = "Retry-After";
static const char kHeaderServer[] = "Server";
static const char kHeaderVary[] = "Vary";
static const char kHeaderWWWAuthenticate[] = "WWW-Authenticate";
// Entity header
static const char kHeaderAllow[] = "Allow";
static const char kHeaderContentEncoding[] = "Content-Encoding";
static const char kHeaderContentLanguage[] = "Content-Language";
static const char kHeaderContentLength[] = "Content-Length";
static const char kHeaderContentLocation[] = "Content-Location";
static const char kHeaderContentMD5[] = "Content-MD5";
static const char kHeaderContentRange[] = "Content-Range";
static const char kHeaderContentType[] = "Content-Type";
static const char kHeaderExpires[] = "Expires";
static const char kHeaderLastModified[] = "Last-Modified";
// Non standard
static const char kHeaderLocation[] = "Location";
// Cookie headers (non standard)
static const char kHeaderCookie[] = "Cookie";
static const char kHeaderSetCookie[] = "Set-Cookie";
// Nonstandard - whispercast use internal
static const char kHeaderXRequestId[] = "X-Request-Id";
//////////////////////////////////////////////////////////////////////
//
// HTTP request methods
//
static const char kMethodOptions[] = "OPTIONS";
static const char kMethodGet[] = "GET";
static const char kMethodHead[] = "HEAD";
static const char kMethodPost[] = "POST";
static const char kMethodPut[] = "PUT";
static const char kMethodDelete[] = "DELETE";
static const char kMethodTrace[] = "TRACE";
static const char kMethodConnect[] = "CONNECT";
enum HttpMethod {
METHOD_UNKNOWN,
METHOD_OPTIONS,
METHOD_GET,
METHOD_HEAD,
METHOD_POST,
METHOD_PUT,
METHOD_DELETE,
METHOD_TRACE,
METHOD_CONNECT,
};
HttpMethod GetHttpMethod(const char* methoda);
const char* GetHttpMethodName(HttpMethod method);
//////////////////////////////////////////////////////////////////////
//
// HTTP versions
//
static const char kHttpVersion0_9[] = "HTTP/0.9";
static const char kHttpVersion1_0[] = "HTTP/1.0";
static const char kHttpVersion1_1[] = "HTTP/1.1";
enum HttpVersion {
VERSION_UNKNOWN = 0,
VERSION_0_9 = 1,
VERSION_1_0 = 2,
VERSION_1_1 = 3,
};
HttpVersion GetHttpVersion(const char* ver);
const char* GetHttpVersionName(HttpVersion ver);
//////////////////////////////////////////////////////////////////////
//
// NOTE: For the next piece of code (pulled from google-url library:)
//
// Copyright 2007, Google Inc.
// 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 Google Inc. 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
// OWNER 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.
//
//
// Character type discrimination functions
//
//
// CTL = <any US-ASCII control character
// (octets 0 - 31) and DEL (127)>
// CHAR = <any US-ASCII character (octets 0 - 127)>
// CR = <US-ASCII CR, carriage return (13)>
// LF = <US-ASCII LF, linefeed (10)>
// SP = <US-ASCII SP, space (32)>
// HT = <US-ASCII HT, horizontal-tab (9)>
//
// CRLF = CR LF
// LWS = [CRLF] 1*( SP | HT )
//
// token = 1*<any CHAR except CTLs or separators>
// separators = "(" | ")" | "<" | ">" | "@"
// | "," | ";" | ":" | "\" | <">
// | "/" | "[" | "]" | "?" | "="
// | "{" | "}" | SP | HT
// Bits that identify different character types. These types identify different
// bits that are set for each 8-bit character in the kSharedCharTypeTable.
enum SharedCharTypes {
// Characters can be HTTP separators
CHAR_SEPARATOR = 1,
// Characters can be in a LWF
CHAR_LWF = 2,
// Valid in an ASCII-representation of a hex digit (as in %-escaped).
CHAR_HEX = 4,
// Valid in an ASCII-representation of a decimal digit.
CHAR_DEC = 8,
// Valid in an ASCII-representation of an octal digit.
CHAR_OCT = 16,
};
extern const unsigned char kSharedCharTypeTable[0x100];
// More readable wrappers around the character type lookup table.
inline bool IsCharOfType(unsigned char c, SharedCharTypes type) {
return !!(kSharedCharTypeTable[c] & type);
}
inline bool IsCtlChar(unsigned char c) {
return c <= 31 || c == 127;
}
inline bool IsAsciiChar(unsigned char c) {
return c <= 127;
}
inline bool IsWhiteSpace(unsigned char c) {
return c == 32 || c == 9;
}
inline bool IsHexChar(unsigned char c) {
return IsCharOfType(c, CHAR_HEX);
}
inline bool IsSeparatorChar(unsigned char c) {
return IsCharOfType(c, CHAR_SEPARATOR);
}
inline bool IsLwfChar(unsigned char c) {
return IsCharOfType(c, CHAR_LWF);
}
inline bool IsTokenChar(unsigned char c) {
return IsAsciiChar(c) && !IsCtlChar(c) && !IsSeparatorChar(c);
}
//
// END NOTE (google-url library)
//
//////////////////////////////////////////////////////////////////////
} // namespace http
} // namespace whisper
#endif // __NET_HTTP_HTTP_CONSTS_H__
|
5c2cb0fd440ce0d1962215464c5156ace7aa4223 | 7254068226231bfc85b2bf22b38857d536614662 | /yellowEngine/include/yellowEngine/Collision/BroadPhase_BVH.hpp | 58f5685448af3423cfa13c801d45b07ec4da260e | [] | no_license | yellowisher/yellowEngine | d8273a2d5da727a4d3c75170a8ab8b053d350eec | 6edb781a8cf88fba418b13dd9a4009dc4c5f950c | refs/heads/master | 2021-12-14T04:34:09.450891 | 2021-11-29T15:42:58 | 2021-11-29T15:42:58 | 191,841,743 | 8 | 2 | null | null | null | null | UTF-8 | C++ | false | false | 1,432 | hpp | BroadPhase_BVH.hpp | #ifndef __H_BROADPHASE_BVH__
#define __H_BROADPHASE_BVH__
#include <map>
#include "yellowEngine/Collision/BroadPhase.hpp"
#include "yellowEngine/Utility/ObjectPool.hpp"
#include "yellowEngine/Math/AABB.hpp"
namespace yellowEngine
{
class Node : Poolable
{
friend class ObjectPool<Node>;
public:
void constructor() override;
void destructor() override;
inline bool isLeaf() { return rightChild == NullObject; }
int height;
union
{
int parent;
int next;
};
union
{
// only leaf node contains collider data; user leftChild as collider pointer
struct
{
int leftChild;
int PADDING_FOR_64BIT;
int rightChild;
};
Collider* collider;
};
AABB aabb;
private:
Node() {}
~Node() {}
};
class BroadPhase_BVH : public BroadPhase
{
public:
BroadPhase_BVH();
~BroadPhase_BVH();
void updateObject(Collider* target) override;
void addObjcet(Collider* target) override;
void removeObject(Collider* target) override;
void render(Renderer& renderer, Shader* shader, const Uniform* colorUniform) override;
float expandFactor;
protected:
void detect() override;
private:
void insertNode(ObjectId id);
void deleteNode(ObjectId id);
void updateNode(ObjectId id, AABB aabb);
ObjectId adjust(ObjectId target);
ObjectId balance(ObjectId target);
ObjectPool<Node> _nodePool;
ObjectId _root;
std::map<Collider*, ObjectId> _nodeMap;
};
}
#endif |
7d1505129daf06e6398a94f380b9c7b8c616d65e | ddb942d6afa5611b077fa796496db3ed14f3cf8a | /ARSA_P03 (1).cpp | a16f2fe24ee5495e41f52242b8297eb7f55e1bce | [] | no_license | Sarce23/Programas | 72912fa103d4ffe10d4e56ea6355e8552be49f9a | 55114e8fdc10a5b07ce948cdb2a053f85735a1e1 | refs/heads/master | 2020-03-29T07:38:18.741358 | 2018-09-20T21:57:32 | 2018-09-20T21:57:32 | 149,672,912 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 4,088 | cpp | ARSA_P03 (1).cpp | /**/
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <conio.h>
void menu(void);
void verdadero(void);
void falso(void);
void arbol(void);
int main ()
{
menu();
return 0;
}
void menu()
{
int op;
do{
system ("cls");
printf("\n M E N U");
printf("\n1.- ANIDADO POR EL VERDADERO");
printf("\n2.- ANIDADO POR EL FALSO");
printf("\n3.- ARBOL(OPTIMIZADO)");
printf("\n4.- Salir");
printf("\nESCOGE UNA OPCION.\n");
scanf ("%d",&op);
switch(op)
{
case 1: verdadero(); break;
case 2: falso(); break;
case 3: arbol(); break;
default:
printf("error, opcion invalida");
}
}while(op != 4);
}
void falso()
{
int cal1,cal2,cal3;
float prom;
printf("Ingresa cal 1: ");
scanf("%d",&cal1);
printf("Ingresa cal 2: ");
scanf("%d",&cal2);
printf("Ingresa cal 3: ");
scanf("%d",&cal3);
prom=(cal1+cal2+cal3)/3;
if ( prom < 30 )
{
printf("Repetir, Tu Promedio es %.2f",prom);
}
else
{
if ( prom < 60 )
{
printf("Extraordinario, Tu Promedio es %.2f",prom);
}
else
{
if ( prom < 70 )
{
printf("Suficiente, Tu Promedio es %.2f",prom);
}
else
{
if ( prom < 80 )
{
printf("Regular, Tu Promedio es %.2f",prom);
}
else
{
if ( prom < 90 )
{
printf("Bien, Tu Promedio es %.2f",prom);
}
else
{
if ( prom < 96 )
{
printf("Muy bien, Tu Promedio es %.2f",prom);
}
else
{
if ( prom <= 100 )
{
printf("Excelente, Tu Promedio es %.2f",prom);
}
else
{
printf("Error, Tu Promedio es %.2f",prom);
}
}
}
}
}
}
}
printf("\n\n");
system ("PAUSE");
}
void verdadero()
{
int cal1,cal2,cal3;
float prom;
printf("ingrese su primera calificacion:");
scanf("%d",&cal1);
printf("ingrese su segunda calificacion:");
scanf("%d",&cal2);
printf("ingrese su tercera calificacion:");
scanf("%d",&cal3);
prom= (cal1+cal2+cal3)/3;
if ( prom <= 100 )
{
if ( prom < 96 )
{
if ( prom < 90 )
{
if ( prom < 80 )
{
if ( prom < 70 )
{
if ( prom < 60 )
{
if ( prom < 30 )
{
printf("Repetir, Tu Promedio es %.2f\n",prom);
}
else
{
printf("Extraordinario, Tu Promedio es %.2f\n",prom);
}
}
else
{
printf("Suficiente, Tu Promedio es %.2f\n",prom);
}
}
else
{
printf("Regular, Tu Promedio es %.2f\n",prom);
}
}
else
{
printf("Bien, Tu Promedio es %.2f\n",prom);
}
}
else
{
printf("Muy bien, Tu Promedio es %.2f\n",prom);
}
}
else
{
printf("Excelente!!, Tu Promedio es %.2f\n",prom);
}
}
else
{
printf("Error, Tu Promedio es %.2f\n",prom);
}
system("pause");
}
void arbol()
{
int cal1,cal2,cal3;
float prom;
printf("Ingresa cal 1: ");
scanf("%d",&cal1);
printf("Ingresa cal 2: ");
scanf("%d",&cal2);
printf("Ingresa cal 3: ");
scanf("%d",&cal3);
prom=(cal1+cal2+cal3)/3;
if ( prom < 80 )
{
if ( prom < 60 )
{
if ( prom < 30 )
{
printf("Repetir, Tu Promedio es %.2f",prom);
}
else
{
printf("Extraordinario, Tu Promedio es %.2f",prom);
}
}
else
{
if ( prom < 70 )
{
printf("Suficiente, Tu Promedio es %.2f",prom);
}
else
{
printf("Regular, Tu Promedio es %.2f",prom);
}
}
}
else
{
if ( prom < 96 )
{
if ( prom < 90 )
{
printf("Bien, Tu Promedio es %.2f",prom);
}
else
{
printf("Muy bien, Tu Promedio es %.2f",prom);
}
}
else
{
if ( prom > 100 )
{
printf("Tu Promedio es %.2f, Error!!!!!",prom);
}
else
{
printf("Excelente!!, Tu Promedio es %.2f",prom);
}
}
}
printf("\n\n");
system ("PAUSE");
}
|
803691291f1220a5112d833b298305143747caf8 | e9a147e43d5db336e016c36c0cccf3577331ba41 | /readMotionFile/vectorOfVector/vectorOfVector/main.cpp | b0f927b20d4db826d79f89db71eee815520b3228 | [] | no_license | yuchuang1979/Event-Detection-and-Demo | 230b8aa3a10363841b4d01b2798f3c14c7da4f02 | 889e8d1517338d4699cafeb56c12adf9574361e6 | refs/heads/master | 2022-11-04T19:52:37.447446 | 2020-06-18T22:46:00 | 2020-06-18T22:46:00 | 273,349,133 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 637 | cpp | main.cpp | //
// main.cpp
// vectorOfVector
//
// Created by Huang, Yuchi on 12/3/16.
// Copyright © 2016 Huang, Yuchi. All rights reserved.
//
#include <iostream>
#include <vector>
using namespace std;
int main(int argc, const char * argv[]) {
// insert code here...
vector<int> temp;
vector<vector<int>> test(2, temp);
test[0].push_back(1);
test[0].push_back(2);
test[1].push_back(3);
test[1].push_back(4);
test[1].push_back(5);
cout<< test.size() << endl;
cout<< test[0].size() << endl;
cout<< test[1].size() << endl;
//cout<< test[0][0] << " " << test[0][1] << endl;
return 0;
}
|
da7afab706cc11192bfa47e065037d0f07e8d88e | 71912d6a6339c2c93698f0e53d9504c459ae5f3e | /Binary_Search_Tree/maxElement(withoutRecursion).cpp | a132ad9ec1ca2c0d0739e0bf2f1de8f67d64f17b | [] | no_license | Rahul-111/Competitivecode | e24f0124ed4d29048406e2df459b8dc8d8b156df | ab1c7026d1945dc4fb218bd5340b05f50445523c | refs/heads/master | 2020-03-20T21:56:39.654730 | 2020-02-21T08:02:36 | 2020-02-21T08:02:36 | 137,769,924 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,499 | cpp | maxElement(withoutRecursion).cpp | #include<iostream>
#include<queue>
using namespace std;
struct Node {
int data;
struct Node *left;
struct Node *right;
};
Node * newNode(int data)
{
Node *temp=new Node;
temp->data=data;
temp->left = temp->right=NULL;
return temp;
}
Node* Insert(Node *root,int data) {
/*if(root == NULL) {
root = new Node();
root->data = data;
root->left = root->right = NULL;
}*/
if(root==NULL)
return newNode(data);
else if(data <= root->data)
root->left = Insert(root->left,data);
else
root->right = Insert(root->right,data);
return root;
}
void Inorder(Node *root) {
if(root == NULL) return;
Inorder(root->left); //Visit left subtree
printf("%d ",root->data); //Print data
Inorder(root->right); // Visit right subtree
}
int MaxElement(Node *root)
{
if(root ==NULL)
return 0;
queue<Node *> q;
q.push(root);
int max = root->data;
while(q.empty()==false)
{
Node *node=q.front();
if(node->data > max)
max=node->data;
q.pop();
if(node->left!=NULL)
q.push(node->left);
if(node->right!=NULL)
q.push(node->right);
}
return max;
}
int main()
{
Node* root = NULL;
root = Insert(root,5);
root = Insert(root,10);
root = Insert(root,3);
root = Insert(root,4);
root = Insert(root,1);
root = Insert(root,11);
cout<<"Inorder: ";
Inorder(root);
cout<<"\n";
cout<<"\n Maximun = :"<<MaxElement(root);;
return 0;
}
//Time Complexity =O(n) and Space Complexity O(n)
|
bbac9d7d7c4d37a95b8ab4500621db8083ad46dd | 3bf94fd91a50b0c194fee4567c0f7e7c2acc765c | /src/core/jobs/collectioncopyjob.h | 537cd565e871059449e02f535d202ac13a9f2833 | [
"CC0-1.0",
"BSD-3-Clause"
] | permissive | KDE/akonadi | a1f29a137f6f35516a0ff1b41f85ffd77f695449 | 064b9f38dbfaf1127d12794cf295eb545c593978 | refs/heads/master | 2023-08-31T21:18:57.904918 | 2023-08-28T21:06:36 | 2023-08-28T21:06:36 | 42,715,907 | 25 | 7 | null | null | null | null | UTF-8 | C++ | false | false | 1,617 | h | collectioncopyjob.h | /*
SPDX-FileCopyrightText: 2008 Volker Krause <vkrause@kde.org>
SPDX-License-Identifier: LGPL-2.0-or-later
*/
#pragma once
#include "akonadicore_export.h"
#include "job.h"
namespace Akonadi
{
class Collection;
class CollectionCopyJobPrivate;
/**
* @short Job that copies a collection into another collection in the Akonadi storage.
*
* This job copies a single collection into a specified target collection.
*
* @code
*
* Akonadi::Collection source = ...
* Akonadi::Collection target = ...
*
* Akonadi::CollectionCopyJob *job = new Akonadi::CollectionCopyJob( source, target );
* connect( job, SIGNAL(result(KJob*)), SLOT(copyFinished(KJob*)) );
*
* ...
*
* MyClass::copyFinished( KJob *job )
* {
* if ( job->error() )
* qDebug() << "Error occurred";
* else
* qDebug() << "Copied successfully";
* }
*
* @endcode
*
* @author Volker Krause <vkrause@kde.org>
*/
class AKONADICORE_EXPORT CollectionCopyJob : public Job
{
Q_OBJECT
public:
/**
* Creates a new collection copy job to copy the given @p source collection into @p target.
*
* @param source The collection to copy.
* @param target The target collection.
* @param parent The parent object.
*/
CollectionCopyJob(const Collection &source, const Collection &target, QObject *parent = nullptr);
/**
* Destroys the collection copy job.
*/
~CollectionCopyJob() override;
protected:
void doStart() override;
bool doHandleResponse(qint64 tag, const Protocol::CommandPtr &response) override;
private:
Q_DECLARE_PRIVATE(CollectionCopyJob)
};
}
|
e9a8992bba1295fe560905abb285a8c25876314f | 12576deee2cda534293d4bcd555121f64339062e | /dotnet-5.0.0/runtime-5.0.0-rtm.20519.4/src/installer/corehost/cli/bundle/file_entry.h | fac8765b26aec8b21b5c8da226be108fcca2513a | [
"MIT"
] | permissive | dnobori/DN-OSS-Learn | ded1a0a04d47a7ca0c598bd23986128745437844 | 83ad725c20f48274c0908b6fb9c746a9f514d882 | refs/heads/master | 2022-12-09T14:46:14.518304 | 2021-11-16T14:02:37 | 2021-11-16T14:02:37 | 159,909,542 | 4 | 5 | null | 2022-12-08T01:46:27 | 2018-12-01T04:39:58 | null | UTF-8 | C++ | false | false | 2,327 | h | file_entry.h | // Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
#ifndef __FILE_ENTRY_H__
#define __FILE_ENTRY_H__
#include "file_type.h"
#include "reader.h"
namespace bundle
{
// FileEntry: Records information about embedded files.
//
// The bundle manifest records the following meta-data for each
// file embedded in the bundle:
// Fixed size portion (file_entry_fixed_t)
// - Offset
// - Size
// - File Entry Type
// Variable Size portion
// - relative path (7-bit extension encoded length prefixed string)
#pragma pack(push, 1)
struct file_entry_fixed_t
{
int64_t offset;
int64_t size;
file_type_t type;
};
#pragma pack(pop)
class file_entry_t
{
public:
file_entry_t()
: m_offset(0)
, m_size(0)
, m_type(file_type_t::__last)
, m_relative_path()
, m_force_extraction(false)
{
}
file_entry_t(
const file_entry_fixed_t *fixed_data,
const bool force_extraction = false)
: m_relative_path()
, m_force_extraction(force_extraction)
{
// File_entries in the bundle-manifest are expected to be used
// beyond startup (for loading files directly from bundle, lazy extraction, etc.).
// The contents of fixed_data are copied on to file_entry in order to
// avoid memory mapped IO later.
m_offset = fixed_data->offset;
m_size = fixed_data->size;
m_type = fixed_data->type;
}
const pal::string_t relative_path() const { return m_relative_path; }
int64_t offset() const { return m_offset; }
int64_t size() const { return m_size; }
file_type_t type() const { return m_type; }
bool needs_extraction() const;
static file_entry_t read(reader_t &reader, bool force_extraction);
private:
int64_t m_offset;
int64_t m_size;
file_type_t m_type;
pal::string_t m_relative_path; // Path of an embedded file, relative to the extraction directory.
bool m_force_extraction;
bool is_valid() const;
};
}
#endif // __FILE_ENTRY_H__
|
98d21957c031d12cb278bf6ab695170315f1c4cf | b84aa8a1745f3346f22b9a0ae1c977a244dfb3cd | /SDK/RC_BP_InWorld_Reticle_classes.hpp | a48edb1730f4bd3bfa0133f060f6cfb75cda69d5 | [] | no_license | frankie-11/Rogue-SDK-11.8 | 615a9e51f280a504bb60a4cbddb8dfc4de6239d8 | 20becc4b2fff71cfec160fb7f2ee3a9203031d09 | refs/heads/master | 2023-01-10T06:00:59.427605 | 2020-11-08T16:13:01 | 2020-11-08T16:13:01 | 311,102,184 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 915 | hpp | RC_BP_InWorld_Reticle_classes.hpp | #pragma once
// RogueCompany (4.24) SDK
#ifdef _MSC_VER
#pragma pack(push, 0x8)
#endif
namespace SDK
{
//---------------------------------------------------------------------------
//Classes
//---------------------------------------------------------------------------
// BlueprintGeneratedClass BP_InWorld_Reticle.BP_InWorld_Reticle_C
// 0xAC81680 (0x65C1F680 - 0x5AF9E000)
class ABP_InWorld_Reticle_C : public AActor
{
public:
unsigned char UnknownData00[0xAC81680]; // 0x5AF9E000(0xAC81680) MISSED OFFSET
static UClass* StaticClass()
{
static auto ptr = UObject::FindClass("BlueprintGeneratedClass BP_InWorld_Reticle.BP_InWorld_Reticle_C");
return ptr;
}
void SetWeaponComponent();
void SetPossession();
void ReceiveBeginPlay();
void ExecuteUbergraph_BP_InWorld_Reticle();
};
}
#ifdef _MSC_VER
#pragma pack(pop)
#endif
|
1cef5bb9d9ce09fa5d5222691249d1905e9f6830 | 4bde01bdd255cc2ed3ecf643046535a93a762fc3 | /hello/ConfigureDialog.h | 64732129e38fe5f40f208f11d6220d26c0c804b1 | [] | no_license | galepai/hello | 00e4d06c9b1ba4c1d866c39036dbd4d64cc54124 | fbfde1fe42561f46eac2d143c7d097929b54c09f | refs/heads/master | 2021-04-27T02:14:06.176706 | 2018-10-20T01:53:01 | 2018-10-20T01:53:01 | 121,824,867 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 725 | h | ConfigureDialog.h | #ifndef CONFIGUREDIALOG_H
#define CONFIGUREDIALOG_H
#include <QDialog>
#include <QWidget>
#include <QComboBox>
class ConfigSerial : public QWidget
{
Q_OBJECT
public:
explicit ConfigSerial(QWidget *parent = 0);
void CreateUi();
void ReadIni();
private slots:
void SavePortToIni();
private:
QComboBox* PortComboBox;
QComboBox* BaudComboBox;
QComboBox* DataBitsComboBox;
};
namespace Ui {
class ConfigureDialog;
}
class ConfigureDialog : public QDialog
{
Q_OBJECT
public:
explicit ConfigureDialog(QWidget *parent = 0);
~ConfigureDialog();
private:
Ui::ConfigureDialog *ui;
ConfigSerial configSerial;
private slots:
void currentRowChanged(int currentRow);
};
#endif // CONFIGUREDIALOG_H
|
5d5b841c51332415cb65fac9dbd99d611f9489e0 | bbe13b9fd16db3e1abc7818a812ad2c1269cf943 | /packager/media/base/key_fetcher.h | 10dd9bec5aa27e05c3ae063488f8fa2fcfc2acf6 | [
"BSD-3-Clause"
] | permissive | leandromoreira/edash-packager | a80622c0b9984272ffb37993d0dd812d9de67c99 | 44b2b077819c6a40ce98ef4b60764d4daf5a19e4 | refs/heads/master | 2020-12-26T13:11:37.432182 | 2015-07-23T01:49:26 | 2015-07-29T01:07:09 | 39,477,638 | 2 | 1 | null | 2015-07-22T01:01:03 | 2015-07-22T01:01:02 | null | UTF-8 | C++ | false | false | 1,120 | h | key_fetcher.h | // Copyright 2014 Google Inc. All rights reserved.
//
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file or at
// https://developers.google.com/open-source/licenses/bsd
#ifndef MEDIA_BASE_KEY_FETCHER_H_
#define MEDIA_BASE_KEY_FETCHER_H_
#include "base/macros.h"
#include "packager/media/base/status.h"
namespace edash_packager {
namespace media {
/// Base class for fetching keys from the license service.
class KeyFetcher {
public:
KeyFetcher();
virtual ~KeyFetcher();
/// Fetch Keys from license service.
/// |response| is owned by caller.
/// @param service_address license service address.
/// @param request JSON formatted request.
/// @param response JSON formatted response. Owned by caller.
/// @return OK on success.
virtual Status FetchKeys(const std::string& service_address,
const std::string& request,
std::string* response) = 0;
private:
DISALLOW_COPY_AND_ASSIGN(KeyFetcher);
};
} // namespace media
} // namespace edash_packager
#endif // MEDIA_BASE_KEY_FETCHER_H_
|
2a1d9aabe4dc93aa3e4d05a25133a9023d80d188 | 455ecd26f1439cd4a44856c743b01d711e3805b6 | /java/include/android.widget.ImageSwitcher.hpp | 51f35b2c66e789e5d778eba0ff07fb31052faf38 | [] | no_license | lbguilherme/duvidovc-app | 00662bf024f82a842c808673109b30fe2b70e727 | f7c86ea812d2ae8dd892918b65ea429e9906531c | refs/heads/master | 2021-03-24T09:17:17.834080 | 2015-09-08T02:32:44 | 2015-09-08T02:32:44 | 33,072,192 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,167 | hpp | android.widget.ImageSwitcher.hpp | #pragma once
#include "../src/java-core.hpp"
#include <jni.h>
#include <cstdint>
#include <memory>
#include <vector>
#include "java.lang.Object.hpp"
#include "android.widget.ViewSwitcher.hpp"
namespace android { namespace content { class Context; } }
namespace android { namespace graphics { namespace drawable { class Drawable; } } }
namespace android { namespace net { class Uri; } }
namespace android { namespace util { class AttributeSet; } }
namespace android {
namespace widget {
class ImageSwitcher : public virtual ::java::lang::Object,
public virtual ::android::widget::ViewSwitcher {
public:
static jclass _class;
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wreorder"
explicit ImageSwitcher(jobject _obj) : ::java::lang::Object(_obj), ::android::graphics::drawable::Drawable_Callback(_obj), ::android::view::KeyEvent_Callback(_obj), ::android::view::View(_obj), ::android::view::ViewGroup(_obj), ::android::view::ViewManager(_obj), ::android::view::ViewParent(_obj), ::android::view::accessibility::AccessibilityEventSource(_obj), ::android::widget::FrameLayout(_obj), ::android::widget::ViewAnimator(_obj), ::android::widget::ViewSwitcher(_obj) {}
#pragma GCC diagnostic pop
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wreorder"
ImageSwitcher(const ::android::widget::ImageSwitcher& x) : ::java::lang::Object((jobject)0), ::android::graphics::drawable::Drawable_Callback((jobject)0), ::android::view::KeyEvent_Callback((jobject)0), ::android::view::View((jobject)0), ::android::view::ViewGroup((jobject)0), ::android::view::ViewManager((jobject)0), ::android::view::ViewParent((jobject)0), ::android::view::accessibility::AccessibilityEventSource((jobject)0), ::android::widget::FrameLayout((jobject)0), ::android::widget::ViewAnimator((jobject)0), ::android::widget::ViewSwitcher((jobject)0) {obj = x.obj;}
ImageSwitcher(::android::widget::ImageSwitcher&& x) : ::java::lang::Object((jobject)0), ::android::graphics::drawable::Drawable_Callback((jobject)0), ::android::view::KeyEvent_Callback((jobject)0), ::android::view::View((jobject)0), ::android::view::ViewGroup((jobject)0), ::android::view::ViewManager((jobject)0), ::android::view::ViewParent((jobject)0), ::android::view::accessibility::AccessibilityEventSource((jobject)0), ::android::widget::FrameLayout((jobject)0), ::android::widget::ViewAnimator((jobject)0), ::android::widget::ViewSwitcher((jobject)0) {obj = x.obj; x.obj = JavaObjectHolder((jobject)0);}
#pragma GCC diagnostic pop
::android::widget::ImageSwitcher& operator=(const ::android::widget::ImageSwitcher& x) {obj = x.obj; return *this;}
::android::widget::ImageSwitcher& operator=(::android::widget::ImageSwitcher&& x) {obj = std::move(x.obj); return *this;}
ImageSwitcher(const ::android::content::Context&);
ImageSwitcher(const ::android::content::Context&, const ::android::util::AttributeSet&);
void setImageResource(int32_t) const;
void setImageURI(const ::android::net::Uri&) const;
void setImageDrawable(const ::android::graphics::drawable::Drawable&) const;
};
}
}
|
420b804a63f8c399ebd48c3ace3d0511b179b37b | cd6b8c3b5b558e3898acd58b2f9f883999740ba8 | /source/timer_private.cpp | fb8ff8ddd084e800b4e5c609acef94a398bb992f | [] | no_license | ErnestSzczepaniak/core_a9 | d5a4c0fee3ee1ff5ed1e66a67d4b9b048b990abb | a967f99fed02964289cc22bb651c1df5653830bd | refs/heads/master | 2020-12-13T22:53:08.342274 | 2020-08-28T13:05:24 | 2020-08-28T13:05:24 | 234,554,595 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,472 | cpp | timer_private.cpp | #include "timer_private.h"
#include "core.h"
Timer_private timer_private(core.private_base() + 0x0600);
void Timer_private::enable()
{
_map->control |= 0x1;
}
void Timer_private::disable()
{
_map->control &= ~0x1;
}
bool Timer_private::is_enabled()
{
return (_map->control & 0x1);
}
void Timer_private::reload_mode(Timer_private_reload_mode mode)
{
if (mode == Timer_private_reload_mode::Single_shot)
{
_map->control &= ~0x2;
}
else if (mode == Timer_private_reload_mode::Auto_reload)
{
_map->control |= 0x2;
}
}
Timer_private_reload_mode Timer_private::reload_mode()
{
return ((Timer_private_reload_mode) (_map->control >> 1));
}
void Timer_private::irq_enable()
{
_map->control |= 0x4;
}
void Timer_private::irq_disable()
{
_map->control &= ~0x4;
}
bool Timer_private::is_irq_enabled()
{
return (_map->control & 0x4);
}
void Timer_private::prescaler(unsigned int value)
{
_map->control &= 0xffff00ff;
_map->control |= value << 8;
}
unsigned int Timer_private::prescaler()
{
return ((_map->control >> 8) & 0xff);
}
void Timer_private::load(unsigned int value)
{
_map->load = value;
}
unsigned int Timer_private::load()
{
return _map->load;
}
unsigned int Timer_private::counter()
{
return _map->counter;
}
bool Timer_private::event_occured()
{
return _map->interrupt_status;
}
void Timer_private::event_clear()
{
_map->interrupt_status = 1;
}
|
cea9e909f15d55fe392dff62f408a0b0fc664539 | f9285898735714b3e301c310f7b6d2c0a2c22798 | /tests/IfSwitchInitHandlerTest.cpp | e2140a3ec63f7e6a5397353597f775e0d40ef2b4 | [
"MIT"
] | permissive | andreasfertig/cppinsights | dcb6c53e0c79770df383067e70b852fde7fb24f5 | 50b962d6bb6d96c567a5b0870c3c828405b40d14 | refs/heads/main | 2023-08-27T06:36:33.307787 | 2023-07-31T05:21:49 | 2023-07-31T05:21:49 | 131,510,015 | 2,465 | 156 | MIT | 2023-09-13T11:31:36 | 2018-04-29T16:21:08 | C++ | UTF-8 | C++ | false | false | 398 | cpp | IfSwitchInitHandlerTest.cpp | int Open() { return 0; }
int Write() { return 0; }
#define SUCCESS 1
auto Foo()
{
if( auto ret = Open(); SUCCESS != ret )
{
return ret;
} else if( auto ret = Write(); SUCCESS != ret ) {
return ret;
}
// ...
return SUCCESS;
}
void Fun()
{
if(Open(); true) {}
switch(Open(); 1) {
default: break;
}
}
int main()
{
Foo();
}
|
070af3f052c9ae79310acaf3ef94caff9d44fae8 | bb864e905a69b6dbe07a97d6d31d9b47cc97dabb | /LEETCODE/339.cpp | 16e36acab9b0515a0f298973b5c171f958230e70 | [] | no_license | k--chow/CompetitiveProgramming | 74b7eb58dfaca6375e55cfe1aa097d43bc154d81 | d5b00609141ae33aaaf736fd265b3db4a47dbe62 | refs/heads/master | 2021-01-17T01:57:54.378698 | 2016-12-30T01:01:21 | 2016-12-30T01:01:21 | 40,216,189 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 508 | cpp | 339.cpp | class Solution {
public:
int sum = 0;
void helper(vector<NestedInteger>& nestedList, int depth)
{
for(int i=0; i<nestedList.size(); i++)
{
if (nestedList[i].isInteger())
{
sum += depth * nestedList[i].getInteger();
} else {
helper(nestedList[i].getList(), depth + 1);
}
}
}
int depthSum(vector<NestedInteger>& nestedList) {
helper(nestedList, 1);
return sum;
}
};
|
81361b44ab92d7b558c438249bc50e55170fe33c | 1f77f63fc4bcf538fc892f6a5ba54058367ed0e5 | /plugins/EstimationPlugin/src/base/signal/SignalBase.cpp | 33678dfec44785a5e0c218961b40f8abaeae3a4f | [
"Apache-2.0"
] | permissive | ChristopherRabotin/GMAT | 5f8211051b620562947443796fa85c80aed5a7cf | 829b7c2c3c7ea73d759c338e7051f92f4f2f6f43 | refs/heads/GMAT-2020a | 2022-05-21T07:01:48.435641 | 2022-05-09T17:28:07 | 2022-05-09T17:28:07 | 84,392,259 | 24 | 10 | Apache-2.0 | 2022-05-11T03:48:44 | 2017-03-09T03:09:20 | C++ | UTF-8 | C++ | false | false | 80,131 | cpp | SignalBase.cpp | //$Id$
//------------------------------------------------------------------------------
// SignalBase
//------------------------------------------------------------------------------
// GMAT: General Mission Analysis Tool
//
// Copyright (c) 2002 - 2020 United States Government as represented by the
// Administrator of The National Aeronautics and Space Administration.
// All Other Rights Reserved.
//
// Developed jointly by NASA/GSFC and Thinking Systems, Inc. under the FDSS
// contract, Task Order 28
//
// Author: Darrel J. Conway, Thinking Systems, Inc.
// Created: Jan 9, 2014
/**
* Base class for signals between two measurement participants
*/
//------------------------------------------------------------------------------
#include "SignalBase.hpp"
#include "SpaceObject.hpp"
#include "BodyFixedPoint.hpp"
#include "MeasurementException.hpp"
#include "MessageInterface.hpp"
#include "PropSetup.hpp"
#include "Propagator.hpp"
#include "ODEModel.hpp"
#include "SpaceObject.hpp"
#include "StringUtil.hpp"
#include <sstream>
//#define DEBUG_SET_PARAMETER
//#define DEBUG_INITIALIZATION
//#define DEBUG_LIGHTTIME
//#define DEBUG_MOVETOEPOCH
//#define DEBUG_SOLVEFORS
//#define DEBUG_API
#ifdef DEBUG_API
#include <fstream>
std::ofstream apisbFile;
bool apisbFileOpen = false;
#endif
//---------------------------------
// static data
//---------------------------------
const Rmatrix33 SignalBase::I33 = Rmatrix33(true);
const Rmatrix33 SignalBase::zero33 = Rmatrix33(false);
const Rvector3 SignalBase::zeroVector = Rvector3(0.0,0.0,0.0);
const Rvector3 SignalBase::xUnit = Rvector3(1.0,0.0,0.0);
const Rvector3 SignalBase::yUnit = Rvector3(0.0,1.0,0.0);
const Rvector3 SignalBase::zUnit = Rvector3(0.0,0.0,1.0);
//------------------------------------------------------------------------------
// SignalBase(const std::string &typeStr, const std::string &name)
//------------------------------------------------------------------------------
/**
* Constructor
*
* @param typeStr The object type
* @param name Name of the new object
*/
//------------------------------------------------------------------------------
SignalBase::SignalBase(const std::string &typeStr, const std::string &name) :
GmatBase (Gmat::USER_OBJECT_ID_NEEDED, typeStr, name),
next (NULL),
previous (NULL),
tcs (NULL),
rcs (NULL),
ocs (NULL),
j2k (NULL),
satPrecEpoch (21545.0),
//satEpochID (-1),
signalIsFeasible (false), // Not feasible until calculated!
includeLightTime (true),
solarSystem (NULL),
navLog (NULL),
logLevel (1),
ionosphereCache (NULL)
{
#ifdef DEBUG_API
if (!apisbFileOpen)
{
apisbFile.open("SignalBase_API.txt");
apisbFileOpen = true;
}
apisbFile << "Signal base class debug for the API\n" << std::endl;
#endif
type = GmatType::GetTypeId("Signal");
}
//------------------------------------------------------------------------------
// ~SignalBase()
//------------------------------------------------------------------------------
/**
* Destructor
*/
//------------------------------------------------------------------------------
SignalBase::~SignalBase()
{
//MessageInterface::ShowMessage("SignalBase::~SignalBase() for leg <%p> start\n", this);
if (tcs)
{
if (tcs->GetAxisSystem()->GetTypeName() != "BodyFixed")
delete tcs;
}
if (rcs)
{
if (rcs->GetAxisSystem()->GetTypeName() != "BodyFixed")
delete rcs;
}
if (ocs)
delete ocs;
if (j2k)
delete j2k;
//MessageInterface::ShowMessage("SignalBase::~SignalBase() 1\n");
#ifdef DEBUG_API
if (apisbFileOpen)
{
apisbFile.close();
apisbFileOpen = false;
}
#endif
theData.CleanUp();
// clean up std::vector<RealArray> theDataDerivatives;
for (Integer i = 0; i < theDataDerivatives.size(); ++i)
theDataDerivatives[i].clear();
theDataDerivatives.clear();
//MessageInterface::ShowMessage("SignalBase::~SignalBase() 2\n");
// This step is handled by the delete of createdObjects in GmatBase
// Clear the entire list
//if (next)
// delete next;
//MessageInterface::ShowMessage("SignalBase::~SignalBase() for leg <%p> end\n", this);
}
//------------------------------------------------------------------------------
// SignalBase(const SignalBase& sb) :
//------------------------------------------------------------------------------
/**
* Copy constructor
*
* @param sb The signal base used to create this new one
*/
//------------------------------------------------------------------------------
SignalBase::SignalBase(const SignalBase& sb) :
GmatBase (sb),
next (NULL),
previous (NULL),
theData (sb.theData),
tcs (NULL),
rcs (NULL),
ocs (NULL),
j2k (NULL),
satPrecEpoch (21545.0),
//satEpochID (-1),
signalIsFeasible (false), // Never feasible until calculated!
includeLightTime (sb.includeLightTime),
solarSystem (sb.solarSystem),
navLog (sb.navLog),
logLevel (sb.logLevel),
ionosphereCache (NULL)
{
// Clone the list
if (sb.next)
{
GmatBase* clonedObj = sb.next->Clone(); // made changes by TUAN NGUYEN
createdObjects.push_back(clonedObj); // made changes by TUAN NGUYEN
Add((SignalBase*)clonedObj); // made changes by TUAN NGUYEN
}
}
//------------------------------------------------------------------------------
// SignalBase& operator=(const SignalBase& sb)
//------------------------------------------------------------------------------
/**
* Assignment operator
*
* @param sb The signal base used to configure this one
*
* @return This SignalBase, set to look like sb
*/
//------------------------------------------------------------------------------
SignalBase& SignalBase::operator=(const SignalBase& sb)
{
if (this != &sb)
{
GmatBase::operator=(sb);
theData = sb.theData;
if (tcs)
{
if (tcs->GetAxisSystem()->GetTypeName() != "BodyFixed")
delete tcs;
}
tcs = NULL;
if (rcs)
{
if (rcs->GetAxisSystem()->GetTypeName() != "BodyFixed")
delete rcs;
}
rcs = NULL;
if (ocs)
delete ocs;
ocs = NULL;
if (j2k)
delete j2k;
j2k = NULL;
satPrecEpoch = 21545.0;
//satEpochID = -1;
signalIsFeasible = false; // Never feasible until calculated!
includeLightTime = sb.includeLightTime;
solarSystem = sb.solarSystem;
navLog = sb.navLog;
logLevel = sb.logLevel;
//if (next) // made changes by TUAN NGUYEN
//{ // made changes by TUAN NGUYEN
// delete next; // made changes by TUAN NGUYEN
// next = NULL; // made changes by TUAN NGUYEN
//} // made changes by TUAN NGUYEN
next = NULL; // made changes by TUAN NGUYEN
previous = NULL;
if (sb.next)
{
GmatBase* clonedObj = sb.next->Clone(); // made changes by TUAN NGUYEN
createdObjects.push_back(clonedObj); // made changes by TUAN NGUYEN
Add((SignalBase*)clonedObj); // made changes by TUAN NGUYEN
}
isInitialized = false;
}
return *this;
}
//------------------------------------------------------------------------------
// bool SetProgressReporter(ProgressReporter* reporter)
//------------------------------------------------------------------------------
/**
* Sets the reporter that us used to collect run data
*
* @param reporter The progress reporter
*
* @return true is the reporter set, false if not
*/
//------------------------------------------------------------------------------
bool SignalBase::SetProgressReporter(ProgressReporter* reporter)
{
bool retval = false;
if (reporter)
{
navLog = reporter;
retval = true;
}
return retval;
}
//------------------------------------------------------------------------------
// bool SetTransmitParticipantName(std::string name)
//------------------------------------------------------------------------------
/**
* Sets the transmit node name
*
* @param name The name of the node that transmits the signal
*
* @return true on success, false on failure
*/
//------------------------------------------------------------------------------
bool SignalBase::SetTransmitParticipantName(std::string name)
{
#ifdef DEBUG_SET_PARAMETER
MessageInterface::ShowMessage("SignalBase<%p>::SetTransmitParticipantName('%s')\n", this, name.c_str());
#endif
theData.transmitParticipant = name;
bool retval = false;
if (name != "")
retval = true;
return retval;
}
//------------------------------------------------------------------------------
// bool SetReceiveParticipantName(std::string name)
//------------------------------------------------------------------------------
/**
* Sets the receive node name
*
* @param name The name of the node that receives the signal
*
* @return true on success, false on failure
*/
//------------------------------------------------------------------------------
bool SignalBase::SetReceiveParticipantName(std::string name)
{
#ifdef DEBUG_SET_PARAMETER
MessageInterface::ShowMessage("SignalBase<%p>::SetReceivrParticipantName('%s')\n", this, name.c_str());
#endif
theData.receiveParticipant = name;
bool retval = false;
if (name != "")
retval = true;
return retval;
}
//------------------------------------------------------------------------------
// const StringArray& GetRefObjectNameArray(const UnsignedInt type)
//------------------------------------------------------------------------------
/**
* Returns the list of signal nodes
*
* @param type The expected type for the return list (unused in this method)
*
* @return The list of nodes
*/
//------------------------------------------------------------------------------
const StringArray& SignalBase::GetRefObjectNameArray(
const UnsignedInt type)
{
refObjectNames.clear();
if (theData.transmitParticipant != "")
refObjectNames.push_back(theData.transmitParticipant);
if (theData.receiveParticipant != "")
refObjectNames.push_back(theData.receiveParticipant);
return refObjectNames;
}
//------------------------------------------------------------------------------
// bool SetRefObject(GmatBase* obj, const UnsignedInt type,
// const std::string& name)
//------------------------------------------------------------------------------
/**
* Sets the reference object pointers for the signal nodes
*
* @param obj The reference object
* @param type The type of the object (unused here)
* @param name The object's name
*
* @return true if the object was set, false if not
*/
//------------------------------------------------------------------------------
bool SignalBase::SetRefObject(GmatBase* obj, const UnsignedInt type,
const std::string& name)
{
#ifdef DEBUG_SET_PARAMETER
MessageInterface::ShowMessage("SignalBase<%p>::SetRefObject(obj = <%p>, type = %d, name = '%s')\n", this, obj, type, name.c_str());
#endif
bool retval = false;
if (obj != NULL)
{
if (obj->IsOfType("SpacePoint"))
{
//satEpochID = obj->GetParameterID("A1Epoch");
if (theData.transmitParticipant == name)
{
theData.tNode = (SpacePoint*)obj;
retval = true;
}
if (theData.receiveParticipant == name)
{
theData.rNode = (SpacePoint*)obj;
retval = true;
}
}
}
if (retval == false)
retval = GmatBase::SetRefObject(obj, type, name);
return retval;
}
//------------------------------------------------------------------------------
// bool RenameRefObject(const UnsignedInt type, const std::string& oldName,
// const std::string& newName)
//------------------------------------------------------------------------------
/**
* Renames the nodes when the core object name is changed
*
* @param type The node type (unused here)
* @param oldName The name the object had before the rename
* @param newName The name the object has after the rename
*
* @return true is a name was changed, false if not
*/
//------------------------------------------------------------------------------
bool SignalBase::RenameRefObject(const UnsignedInt type,
const std::string& oldName, const std::string& newName)
{
#ifdef DEBUG_SET_PARAMETER
MessageInterface::ShowMessage("SignalBase<%p>::RenameRefObject(type = %d, oldName = '%s', newName = '%s')\n", this, type, oldName.c_str(), newName.c_str());
#endif
bool retval = false;
if (oldName == theData.transmitParticipant)
{
theData.transmitParticipant = newName;
retval = true;
}
else if (oldName == theData.receiveParticipant)
{
theData.receiveParticipant = newName;
retval = true;
}
else retval = GmatBase::RenameRefObject(type, oldName, newName);
return retval;
}
//------------------------------------------------------------------------------
// void SetSolarSystem(SolarSystem* ss)
//------------------------------------------------------------------------------
/**
* Adds the solar system configuration to the signal
*
* @param ss The solar system in use in the run
*/
//------------------------------------------------------------------------------
void SignalBase::SetSolarSystem(SolarSystem* ss)
{
solarSystem = ss;
}
//------------------------------------------------------------------------------
// SignalBase* GetStart(bool epochIsAtEnd)
//------------------------------------------------------------------------------
/**
* Finds either the first or last node in the signal path
*
* @param epochIsAtEnd true to get the last node, false to get the first
*
* @return
*/
//------------------------------------------------------------------------------
SignalBase* SignalBase::GetStart(bool epochIsAtEnd)
{
SignalBase *retval = this;
if (epochIsAtEnd)
{
if (next)
retval = next->GetStart(epochIsAtEnd);
}
else
{
if (previous)
retval = previous->GetStart(epochIsAtEnd);
}
return retval;
}
//------------------------------------------------------------------------------
// SignalBase* GetNext()
//------------------------------------------------------------------------------
/**
* Returns the next node in the list
*
* @return The node pointer
*/
//------------------------------------------------------------------------------
SignalBase* SignalBase::GetNext()
{
return next;
}
//------------------------------------------------------------------------------
// bool Add(SignalBase* signalToAdd)
//------------------------------------------------------------------------------
/**
* Adds a signal to a signal path
*
* @param signalToAdd The signal that is added to the path
*
* @return true on success, false on failure
*/
//------------------------------------------------------------------------------
bool SignalBase::Add(SignalBase* signalToAdd)
{
if (next)
next->Add(signalToAdd);
else
{
next = signalToAdd;
//theData.next = &(signalToAdd->GetSignalData());
theData.next = signalToAdd->GetSignalDataObject();
signalToAdd->SetPrevious(this);
}
return true;
}
//------------------------------------------------------------------------------
// void SetPropagator(PropSetup* propagator, GmatBase* forObj)
//------------------------------------------------------------------------------
/**
* Clones propagators for use moving objects while finding light time solutions
*
* This method is used to assign propagators to signal participants so that
* the iteration needed for light time computations can be performed. The
* derived signal classes initialize the propagator for the specific participant
* it uses.
*
* This code is not likely to change when support for multiple propagators is
* implemented. Dense output propagators may impact this code, because the
* current approach involves cloning the propagator, resulting in a reset of the
* Internal data.
*
* @param propagator The propagator being passed to the signal
* @param forObj The participant that uses this propagator; if NULL it is set
* for both the transmitter and receiver
*/
//------------------------------------------------------------------------------
void SignalBase::SetPropagator(PropSetup* propagator, GmatBase* forObj)
{
#ifdef DEBUG_SET_PARAMETER
MessageInterface::ShowMessage("SignalBase<%p>::SetPropagator(propagator = <%p>, forObject = <%p,'%s'>)\n", this, propagator, forObj, forObj->GetName().c_str());
#endif
#ifdef DEBUG_INITIALIZATION
MessageInterface::ShowMessage("Setting a propagator <%p> in the Signal "
"class for %s\n", propagator, (forObj == NULL ?
"both participants" : forObj->GetName().c_str()));
#endif
if (propagator == NULL)
throw MeasurementException("The propagator passed in for the object " +
forObj->GetName() + " is NULL, so the object cannot be propagated "
"for light time evaluation");
if (theData.solveLightTime)
{
if ((theData.tNode == forObj) || (forObj == NULL))
{
theData.tPropagator = propagator;
#ifdef DEBUG_INITIALIZATION
MessageInterface::ShowMessage(" Transmitter propagator set\n");
#endif
}
if ((theData.rNode == forObj) || (forObj == NULL))
{
theData.rPropagator = propagator;
#ifdef DEBUG_INITIALIZATION
MessageInterface::ShowMessage(" Receiver propagator set\n");
#endif
}
if (next)
next->SetPropagator(propagator, forObj);
}
}
//------------------------------------------------------------------------------
// bool Initialize()
//------------------------------------------------------------------------------
/**
* Prepared the signal for processing by validating internal members
*
* @return true if the signal can be processed, false if not
*/
//------------------------------------------------------------------------------
bool SignalBase::Initialize()
{
#ifdef DEBUG_INITIALIZATION
MessageInterface::ShowMessage("Start SignalBase<%p>::Initialize()\n", this);
#endif
bool retval = false;
if (GmatBase::Initialize())
{
if (navLog)
logLevel = navLog->GetLogLevel("Signal");
else
logLevel = 32767;
if (theData.tNode && theData.rNode)
{
// 1. Set value for theData.stationParticipant
theData.stationParticipant =
((theData.tNode->IsOfType(Gmat::GROUND_STATION)) ||
(theData.rNode->IsOfType(Gmat::GROUND_STATION)));
// 2. Update theData.tPrecTime and theData.rPrecTime
theData.tPrecTime = theData.tNode->GetEpoch();
theData.rPrecTime = theData.rNode->GetEpoch();
// Initially, ground station epoch is set the same at epoch for spacecraft
if (theData.tNode->IsOfType(Gmat::GROUND_STATION))
theData.tPrecTime = theData.rPrecTime;
else if (theData.rNode->IsOfType(Gmat::GROUND_STATION))
theData.rPrecTime = theData.tPrecTime;
retval = true;
}
else if (theData.rNode)
{
// For GPS position measurement
// 1. Set value for theData.stationParticipant
theData.stationParticipant = theData.rNode->IsOfType(Gmat::GROUND_STATION);
// 2. Update theData.rPrecTime
theData.rPrecTime = theData.rNode->GetEpoch();
retval = true;
}
if (next)
retval = next->Initialize() && retval;
// Unset the init flag so InitializeSignal will get called
isInitialized = false;
}
#ifdef DEBUG_INITIALIZATION
MessageInterface::ShowMessage("End SignalBase<%p>::Initialize()\n", this);
#endif
return retval;
}
//------------------------------------------------------------------------------
// std::string GetPathDescription()
//------------------------------------------------------------------------------
/**
* Returns the path description
*
* @return The description, enclosed in curly braces
*/
//------------------------------------------------------------------------------
std::string SignalBase::GetPathDescription(bool fullList)
{
std::string retval = "{";
if (theData.transmitParticipant != "")
retval += theData.transmitParticipant;
else
retval += "transmit participant not set";
retval += " -> ";
if (theData.receiveParticipant != "")
retval += theData.receiveParticipant;
else
retval += "receive participant not set";
retval += "}";
if (fullList)
{
if (next)
retval += next->GetPathDescription();
}
return retval;
}
////------------------------------------------------------------------------------
//// SignalData& GetSignalData()
////------------------------------------------------------------------------------
///**
// * Retrieves the most recently calculated data set for the signal
// *
// * @return The data set
// */
////------------------------------------------------------------------------------
//SignalData& SignalBase::GetSignalData()
//{
// return theData;
//}
//------------------------------------------------------------------------------
// SignalData* GetSignalDataObject()
//------------------------------------------------------------------------------
/**
* Retrieves the reference to the SignalData object of the signal
*
* @return The data set
*/
//------------------------------------------------------------------------------
SignalData* SignalBase::GetSignalDataObject()
{
return &theData;
}
//------------------------------------------------------------------------------
// void SetSignalData(const SignalData& newData)
//------------------------------------------------------------------------------
/**
* Receives signal data from an outside source
*
* @param newData The new signal data
*/
//------------------------------------------------------------------------------
void SignalBase::SetSignalData(const SignalData& newData)
{
#ifdef DEBUG_LIGHTTIME
MessageInterface::ShowMessage("<%p>: Receiving data to update %s and %s...",
this, theData.transmitParticipant.c_str(),
theData.receiveParticipant.c_str());
Integer count = 0;
#endif
// Pass in the current computed data
if (theData.receiveParticipant == newData.receiveParticipant)
{
theData.rPrecTime = newData.rPrecTime;
theData.rLoc = newData.rLoc;
theData.rVel = newData.rVel;
#ifdef DEBUG_LIGHTTIME
++count;
#endif
}
if (theData.receiveParticipant == newData.transmitParticipant)
{
theData.rPrecTime = newData.tPrecTime;
theData.rLoc = newData.tLoc;
theData.rVel = newData.tVel;
#ifdef DEBUG_LIGHTTIME
++count;
#endif
}
if (theData.transmitParticipant == newData.receiveParticipant)
{
theData.tPrecTime = newData.rPrecTime;
theData.tLoc = newData.rLoc;
theData.tVel = newData.rVel;
#ifdef DEBUG_LIGHTTIME
++count;
#endif
}
if (theData.transmitParticipant == newData.transmitParticipant)
{
theData.tPrecTime = newData.tPrecTime;
theData.tLoc = newData.tLoc;
theData.tVel = newData.tVel;
#ifdef DEBUG_LIGHTTIME
++count;
#endif
}
#ifdef DEBUG_LIGHTTIME
MessageInterface::ShowMessage("%d matching data sets updated; epochs "
"%.12lf -> %.12lf\n", count, theData.tPrecTime.GetMjd(), theData.rPrecTime.GetMjd());
#endif
}
//------------------------------------------------------------------------------
// bool IsSignalFeasible()
//------------------------------------------------------------------------------
/**
* Returns feasibility for the last signal calculated
*
* @return true if the signal is feasible, false if not
*/
//------------------------------------------------------------------------------
bool SignalBase::IsSignalFeasible()
{
bool retval = signalIsFeasible;
if (next)
retval = retval && next->IsSignalFeasible();
return retval;
}
//------------------------------------------------------------------------------
// void SignalBase::UsesLighttime(const bool tf)
//------------------------------------------------------------------------------
/**
* Manages the light time computation flag
*
* @param tf true to include light time solutions, false to omit them
*/
//------------------------------------------------------------------------------
void SignalBase::UsesLighttime(const bool tf)
{
includeLightTime = tf;
if (next)
next->UsesLighttime(tf);
}
//------------------------------------------------------------------------------
// void InitializeSignal()
//------------------------------------------------------------------------------
/**
* Prepares the signal for use
*/
//------------------------------------------------------------------------------
void SignalBase::InitializeSignal(bool chainForwards)
{
#ifdef DEBUG_INITIALIZATION
MessageInterface::ShowMessage("SignalBase<%p>::InitializeSignal() for leg %s to %s\n", this,
(theData.tNode == NULL?"":theData.tNode->GetName().c_str()),
(theData.rNode == NULL?"":theData.rNode->GetName().c_str()));
#endif
#ifdef DEBUG_API
if (apisbFileOpen)
{
apisbFile << "Entered SignalBase::InitializeSignal for path "
<< GetPathDescription(false) << std::endl;
}
#endif
if (isInitialized)
{
return;
}
SpaceObject *spObj = NULL;
SpacePoint *origin = NULL;
CelestialBody *earth = solarSystem->GetBody("Earth");
GmatTime gsPrecEpoch = theData.tPrecTime;
// 1. processing for GSP measurement
if ((theData.tNode == NULL) && (theData.rNode != NULL))
{
if (theData.rNode->IsOfType(Gmat::SPACEOBJECT))
{
theData.tPrecTime = theData.rPrecTime = theData.rNode->GetEpoch();
gsPrecEpoch = theData.tPrecTime;
satPrecEpoch = theData.rPrecTime;
#ifdef DEBUG_INITIALIZATION
MessageInterface::ShowMessage("case 1: Initializing with epoch %.12lf\n", satPrecEpoch.GetMjd());
#endif
origin = ((SpaceObject*)theData.rNode)->GetOrigin();
if (rcs)
{
if (rcs->GetAxisSystem()->GetTypeName() != "BodyFixed")
delete rcs;
}
rcs = CoordinateSystem::CreateLocalCoordinateSystem("RCS", "MJ2000Eq",
origin, NULL, NULL, earth, solarSystem);
if (tcs)
{
if (tcs->GetAxisSystem()->GetTypeName() != "BodyFixed")
delete tcs;
}
tcs = CoordinateSystem::CreateLocalCoordinateSystem("TCS", "MJ2000Eq",
origin, NULL, NULL, earth, solarSystem);
if (ocs)
delete ocs;
ocs = CoordinateSystem::CreateLocalCoordinateSystem("OCS", "MJ2000Eq",
origin, NULL, NULL, earth, solarSystem);
if (j2k)
delete j2k;
j2k = CoordinateSystem::CreateLocalCoordinateSystem("j2k", "MJ2000Eq",
origin, NULL, NULL, earth, solarSystem);
}
else
throw MeasurementException("Error: GMAT cannot handle GPS tracking position of an object other than spacecraft.\n");
}
else
{
#ifdef DEBUG_INITIALIZATION
MessageInterface::ShowMessage("case 2: Initializing with epoch %.12lf\n", satPrecEpoch.GetMjd());
#endif
#ifdef DEBUG_API
if (apisbFileOpen)
{
apisbFile << " Building coordinate systems; ss = <"
<< solarSystem << ">\n Data dump:" << std::endl;
if (rcs)
{
if (rcs->GetAxisSystem()->GetTypeName() != "BodyFixed")
delete rcs;
}
rcs = CoordinateSystem::CreateLocalCoordinateSystem("RCS", "MJ2000Eq",
origin, NULL, NULL, earth, solarSystem);
if (ocs)
delete ocs;
ocs = CoordinateSystem::CreateLocalCoordinateSystem("OCS", "Topocentric",
bf, NULL, NULL, bf->GetJ2000Body(), solarSystem);
apisbFile << " epoch: " << gsPrecEpoch.GetMjd()
<< "\n t node: " << theData.tNode
<< " named "
<< (theData.tNode != NULL ? theData.tNode->GetName() : "???")
<< " of type "
<< (theData.tNode != NULL ? theData.tNode->GetTypeName() : "NULL")
<< "\n r node: " << theData.rNode
<< " named "
<< (theData.rNode != NULL ? theData.rNode->GetName() : "???")
<< " of type "
<< (theData.rNode != NULL ? theData.rNode->GetTypeName() : "NULL")
<< std::endl;
}
#endif
// 2. Set tcs, rcs, ocs, and j2k coordinate systems
if (theData.tNode->IsOfType(Gmat::GROUND_STATION))
{
#ifdef DEBUG_API
if (apisbFileOpen)
{
apisbFile << " 1.0";
}
#endif
BodyFixedPoint *bf = (BodyFixedPoint*)theData.tNode;
CoordinateSystem *bfcs = bf->GetBodyFixedCoordinateSystem();
tcs = CoordinateSystem::CreateLocalCoordinateSystem("TCS", bfcs->GetAxisSystem()->GetTypeName(),
bfcs->GetOrigin(), NULL, NULL, bfcs->GetJ2000Body(), bfcs->GetSolarSystem());
#ifdef DEBUG_API
if (apisbFileOpen)
{
apisbFile << " tcs = " << tcs << std::endl;
apisbFile << " 1.1";
}
#endif
spObj = (SpaceObject*) theData.rNode;
origin = spObj->GetOrigin();
#ifdef DEBUG_API
if (apisbFileOpen)
{
apisbFile << " origin = " << origin << std::endl;
apisbFile << " 1.2";
}
#endif
if (rcs)
delete rcs;
rcs = CoordinateSystem::CreateLocalCoordinateSystem("RCS", "MJ2000Eq",
origin, NULL, NULL, earth, solarSystem);
#ifdef DEBUG_API
if (apisbFileOpen)
{
apisbFile << " rcs = " << rcs << std::endl;
apisbFile << " 1.3";
}
#endif
if (ocs)
delete ocs;
ocs = CoordinateSystem::CreateLocalCoordinateSystem("OCS","Topocentric",
bf, NULL, NULL, bf->GetJ2000Body(), solarSystem);
#ifdef DEBUG_API
if (apisbFileOpen)
{
apisbFile << " ocs = " << ocs << std::endl;
apisbFile << " 1.4";
}
#endif
if (j2k)
delete j2k;
j2k = CoordinateSystem::CreateLocalCoordinateSystem("j2k", "MJ2000Eq",
tcs->GetOrigin(), NULL, NULL, earth, solarSystem);
#ifdef DEBUG_API
if (apisbFileOpen)
{
apisbFile << " j2k = " << j2k << std::endl;
apisbFile << " 1.5 Groundstation transmit code CS's set"
<< std::endl;
}
#endif
}
else if (theData.rNode->IsOfType(Gmat::GROUND_STATION))
{
gsPrecEpoch = theData.rPrecTime;
BodyFixedPoint *bf = (BodyFixedPoint*)theData.rNode;
CoordinateSystem *bfcs = bf->GetBodyFixedCoordinateSystem();
rcs = CoordinateSystem::CreateLocalCoordinateSystem("RCS", bfcs->GetAxisSystem()->GetTypeName(),
bfcs->GetOrigin(), NULL, NULL, bfcs->GetJ2000Body(), bfcs->GetSolarSystem());
if (tcs)
{
if (tcs->GetAxisSystem()->GetTypeName() != "BodyFixed")
delete tcs;
}
tcs = CoordinateSystem::CreateLocalCoordinateSystem("RCS", "MJ2000Eq",
origin, NULL, NULL, earth, solarSystem);
spObj = (SpaceObject*) theData.tNode;
origin = spObj->GetOrigin();
if (tcs)
delete tcs;
tcs = CoordinateSystem::CreateLocalCoordinateSystem("TCS", "MJ2000Eq",
origin, NULL, NULL, earth, solarSystem);
if (ocs)
delete ocs;
ocs = CoordinateSystem::CreateLocalCoordinateSystem("OCS","Topocentric",
bf, NULL, NULL, earth, solarSystem);
if (j2k)
delete j2k;
j2k = CoordinateSystem::CreateLocalCoordinateSystem("j2k", "MJ2000Eq",
rcs->GetOrigin(), NULL, NULL, earth, solarSystem);
}
else
{
origin = ((SpaceObject*)theData.tNode)->GetOrigin();
if (rcs)
{
if (rcs->GetAxisSystem()->GetTypeName() != "BodyFixed")
delete rcs;
}
rcs = CoordinateSystem::CreateLocalCoordinateSystem("RCS", "MJ2000Eq",
origin, NULL, NULL, earth, solarSystem);
if (tcs)
{
if (tcs->GetAxisSystem()->GetTypeName() != "BodyFixed")
delete tcs;
}
tcs = CoordinateSystem::CreateLocalCoordinateSystem("TCS", "MJ2000Eq",
origin, NULL, NULL, earth, solarSystem);
if (ocs)
delete ocs;
ocs = CoordinateSystem::CreateLocalCoordinateSystem("OCS", "MJ2000Eq",
origin, NULL, NULL, earth, solarSystem);
if (j2k)
delete j2k;
j2k = CoordinateSystem::CreateLocalCoordinateSystem("j2k", "MJ2000Eq",
origin, NULL, NULL, earth, solarSystem);
}
}
#ifdef DEBUG_API
if (apisbFileOpen)
{
apisbFile << " Updating rotation matrices" << std::endl;
}
#endif
// 3. Update all rotation matrixes at gs time (or at transmit time when both nodes are spacecrafts
std::string updateAll = "All";
UpdateRotationMatrix(gsPrecEpoch.GetMjd(), updateAll);
#ifdef DEBUG_INITIALIZATION
MessageInterface::ShowMessage("Late Binding Initialization complete:\n"
" SolarSystem pointer: %p\n"
" Transmitter CS: %p\n"
" Receiver CS: %p\n"
" Observation CS: %p\n"
" J2000 CS: %p\n",
solarSystem, tcs, rcs, ocs, j2k);
#endif
if (chainForwards)
{
if (next)
{
next->InitializeSignal(chainForwards);
}
}
else
{
if (previous)
{
previous->InitializeSignal(chainForwards);
}
}
#ifdef DEBUG_API
if (apisbFileOpen)
{
apisbFile << " Signal " << GetPathDescription(false)
<< " is ready" << std::endl;
}
#endif
isInitialized = true;
}
//------------------------------------------------------------------------------
// void CalculateRangeVectorInertial()
//------------------------------------------------------------------------------
/**
* 1. Computes the range vector in MJ2000 Equatorial coordinates.
* 2. Update roation matrix at ground station's time. If both nodes are
* spacecrafts, time is at transmit node.
*
* The default implementation here performs the instantaneous range vector
* calculation. Override this implementation for the light time corrected
* vector.
*/
//------------------------------------------------------------------------------
void SignalBase::CalculateRangeVectorInertial()
{
// 1. Update all rotation matrixes at time of ground station. If both tnode and rNode are spacecrafts, update at transmit time
std::string updateAll = "All";
GmatTime gsPrecEpoch = theData.tPrecTime;
if (theData.rNode->IsOfType(Gmat::GROUND_STATION))
gsPrecEpoch = theData.rPrecTime;
UpdateRotationMatrix(gsPrecEpoch.GetMjd(), updateAll);
// 2. Compute range vector in MJ2000 coordinate system
SpacePoint *origin1 = tcs->GetOrigin();
SpacePoint *origin2 = rcs->GetOrigin();
SpecialCelestialPoint* ssb = solarSystem->GetSpecialPoint("SolarSystemBarycenter");
theData.tOStateSSB = origin1->GetMJ2000PrecState(theData.tPrecTime) - ssb->GetMJ2000PrecState(theData.tPrecTime);
theData.rOStateSSB = origin2->GetMJ2000PrecState(theData.rPrecTime) - ssb->GetMJ2000PrecState(theData.rPrecTime);
theData.j2kOriginSep = (theData.rOStateSSB.GetR() - theData.tOStateSSB.GetR());
theData.j2kOriginVel = (theData.rOStateSSB.GetV() - theData.tOStateSSB.GetV());
// GMAT MathSpec Eq. 6.12
theData.rangeVecInertial = theData.rLoc + theData.j2kOriginSep - theData.tLoc;
// GMAT MathSpec Eq. 6.10
SpacePoint* propOrigin = nullptr;
if (theData.tNode->IsOfType(Gmat::SPACECRAFT))
{
if (theData.tPropagator->GetPropagator()->UsesODEModel())
propOrigin = theData.tPropagator->GetODEModel()->GetForceOrigin(); // the origin of the coordinate system used in forcemodel // fix bug GMT-5364
else
propOrigin = theData.tPropagator->GetPropagator()->GetPropOrigin();
}
else
{
if (theData.rPropagator->GetPropagator()->UsesODEModel())
propOrigin = theData.rPropagator->GetODEModel()->GetForceOrigin(); // the origin of the coordinate system used in forcemodel // fix bug GMT-5364
else
propOrigin = theData.rPropagator->GetPropagator()->GetPropOrigin();
}
Rvector6 tSSB2SunState = propOrigin->GetMJ2000PrecState(theData.tPrecTime)
- ssb->GetMJ2000PrecState(theData.tPrecTime);
Rvector6 rSSB2SunState = propOrigin->GetMJ2000PrecState(theData.rPrecTime)
- ssb->GetMJ2000PrecState(theData.rPrecTime);
Rvector3 disp = (rSSB2SunState - tSSB2SunState).GetR();
theData.rangeVecI = theData.rangeVecInertial - disp;
#ifdef DEBUG_LIGHTTIME
MessageInterface::ShowMessage("Origin Sep: %s\n tLoc: %s\n rLoc: %s\n",
(theData.j2kOriginSep.ToString(8).c_str()),
(theData.tLoc.ToString(8).c_str()),
(theData.rLoc.ToString(8)).c_str());
#endif
}
//------------------------------------------------------------------------------
// void CalculateRangeVectorObs()
//------------------------------------------------------------------------------
/**
* Computes the range vector in the observation coordinate system
*
* This method calls CalculateRangeVectorInertial() to generate a range vector,
* then transforms that vector into the coordinate system needed for the
* observation data.
*/
//------------------------------------------------------------------------------
void SignalBase::CalculateRangeVectorObs()
{
CalculateRangeVectorInertial();
// 1. Update R_Transmitter_j2k, R_receiver_j2k, and R_Obs_j2k matrixes
UpdateRotationMatrix(theData.tPrecTime.GetMjd(),"j2k_1");
UpdateRotationMatrix(theData.rPrecTime.GetMjd(),"j2k_2");
if (theData.stationParticipant)
{
if (theData.tNode->IsOfType(Gmat::GROUND_STATION))
UpdateRotationMatrix(theData.tPrecTime.GetMjd(),"o_j2k");
else
UpdateRotationMatrix(theData.rPrecTime.GetMjd(),"o_j2k");
}
else
R_Obs_j2k = I33;
// 2. Compute the positions of the participants in their own frames
theData.tLocTcs = theData.tJ2kRotation * theData.tLoc;
theData.rLocRcs = theData.rJ2kRotation * theData.rLoc;
// 3. Compute range vector observation
// @todo: handle this for arbitrary participants; currently rotates if there
// are any GS's in the participant list
if (theData.stationParticipant)
theData.rangeVecObs = R_Obs_j2k * theData.rangeVecInertial; // R_Obs_j2k matrix was computed in CalculateRangeVectorInertial() function
else
theData.rangeVecObs = theData.rangeVecInertial; // same, really, but skip
// multiplication by I33
}
//------------------------------------------------------------------------------
// void CalculateRangeRateVectorObs(Integer p1index, Integer p2index)
//------------------------------------------------------------------------------
/**
* Computes the range rate vector in the observation coordinate system
*
* This method calls CalculateRangeVectorInertial() to generate a range vector,
* then transforms that vector into the coordinate system needed for the
* observation data.
*/
//------------------------------------------------------------------------------
void SignalBase::CalculateRangeRateVectorObs()
{
SpacePoint *origin1 = tcs->GetOrigin();
SpacePoint *origin2 = rcs->GetOrigin();
SpecialCelestialPoint* ssb = solarSystem->GetSpecialPoint("SolarSystemBarycenter");
// 1. Compute tVel, rVel, j2kOriginVel, rangeRateVecInertial
// Velocity of origin2 at time rPrecTime w.r.t. origin1 at time tPrecTime
theData.j2kOriginVel = (origin1->GetMJ2000PrecVelocity(theData.tPrecTime) - ssb->GetMJ2000PrecVelocity(theData.tPrecTime)) - // velocity of origin1 w.r.t SSB at transmit time tPrecTime in MJ2000Eq coordinate system
(origin2->GetMJ2000PrecVelocity(theData.rPrecTime) - ssb->GetMJ2000PrecVelocity(theData.rPrecTime)); // velocity of origin2 w.r.t SSB at receive time rPrecTime in MJ2000Eq coordinate system
// theData.j2kOriginVel = origin2->GetMJ2000PrecVelocity(theData.rPrecTime) -
// origin1->GetMJ2000PrecVelocity(theData.tPrecTime);
// theData.tVel = theData.tNode->GetMJ2000PrecVelocity(theData.tPrecTime); // fix bug. It is incorrect because tVel is velocity of the transmited participant coordinate system MJ2000Eq. It has origin different from MJ2000 body
// theData.rVel = theData.rNode->GetMJ2000PrecVelocity(theData.rPrecTime); // fix bug. It is incorrect because tVel is velocity of the received participant coordinate system MJ2000Eq. It has origin different from MJ2000 body
theData.rangeRateVecInertial = theData.rVel - theData.j2kOriginVel - theData.tVel;
// 2. Compute the velocities of the participants in their own frames
CalculateRangeVectorObs(); // R_Transmitter_j2k, R_receiver_j2k, and R_Obs_j2k matrixes are updated in CalculateRangevectorObs() function
//theData.tVelTcs = theData.tJ2kRotation * theData.tVel;
//theData.rVelRcs = theData.rJ2kRotation * theData.rVel;
// 3. Compute rangeRateVecObs
if (theData.stationParticipant)
theData.rangeRateVecObs = RDot_Obs_j2k*theData.rangeVecInertial + R_Obs_j2k*theData.rangeRateVecInertial;
else
theData.rangeRateVecObs = theData.rangeRateVecInertial;
}
Real SignalBase::GetParamDerivative(GmatBase *forObj, std::string paramName, GmatBase *associateObj)
{
//MessageInterface::ShowMessage("SignalBase::GetParamDerivative(forObj = <%s>, paramName = <%s>, associateObj = <%s>) start\n", forObj->GetName().c_str(), paramName.c_str(), (associateObj == NULL?"":associateObj->GetName().c_str()));
// Get index for paramName
StringArray stmElemNames;
std::string paramFullName;
if (associateObj)
{
// associateObj is a Spacecraft object (example: estSat.Plate1.DiffuseFraction, associateObj is estSat, forObj is Plate1, and paramName is DiffuseFraction)
stmElemNames = associateObj->GetStringArrayParameter("StmElementNames");
paramFullName = forObj->GetName() + "." + paramName;
}
else
{
// forObj is a Spacecraft object (example: estSat.Cr, forObj is estSat, paramName is Cr)
stmElemNames = forObj->GetStringArrayParameter("StmElementNames");
paramFullName = paramName;
}
UnsignedInt paramIndex = 0;
bool found = false;
//for (int i = 0; i < stmElemNames.size(); i++)
// MessageInterface::ShowMessage("for i = %d: stmElemNames[%d] = <%s>\n", i, i, stmElemNames[i].c_str());
for (int i = 0; i < stmElemNames.size(); i++)
{
if (stmElemNames.at(i) == "CartesianState" || stmElemNames.at(i) == "KeplerianState")
paramIndex += 0; // vector that GetCDerivativeVector() returns does not include cartesian state
else if (stmElemNames.at(i) == paramFullName)
{
found = true;
break;
}
else
{
std::string name = stmElemNames.at(i);
size_t pos = name.find_last_of('.');
if (pos != name.npos)
name = name.substr(pos + 1);
paramIndex += forObj->GetEstimationParameterSize(forObj->GetParameterID(name));
}
}
if (!found)
{
//MessageInterface::ShowMessage("Not found paramFullName <%s> in StmElementNames: deriv = 0.0\n", paramFullName.c_str());
//MessageInterface::ShowMessage("SignalBase::GetParamDerivative(forObj = <%s>) end\n", forObj->GetName().c_str());
return 0.0;
}
// Get C derivative vector
Rvector dVector;
if (associateObj)
GetCDerivativeVector(associateObj, dVector, paramFullName);
else
GetCDerivativeVector(forObj, dVector, paramFullName);
// Get paramName partial derivative
Real deriv = dVector[paramIndex];
//MessageInterface::ShowMessage("Found parameter with name <%s> in StmElementNames: deriv = %.12le Index = %d\n", paramFullName.c_str(), deriv, paramIndex);
//MessageInterface::ShowMessage("SignalBase::GetParamDerivative(forObj = <%s>) end\n", forObj->GetName().c_str());
return deriv;
}
Real SignalBase::GetCrDerivative(GmatBase *forObj)
{
//MessageInterface::ShowMessage("SignalBase::GetCrDerivative(forObj = <%s>) start\n", forObj->GetName().c_str());
// get index for Cr
StringArray stmElemNames = forObj->GetStringArrayParameter("StmElementNames");
UnsignedInt CrIndex = 0;
bool found = false;
for (int i = 0; i < stmElemNames.size(); i++)
{
//MessageInterface::ShowMessage("for i = %d: stmElemNames[%d] = <%s>\n", i, i, stmElemNames[i].c_str());
if (stmElemNames.at(i) == "CartesianState" || stmElemNames.at(i) == "KeplerianState")
CrIndex += 0; // vector that GetCDerivativeVector() returns does not include cartesian state
else if ((stmElemNames.at(i) == "Cr") || (stmElemNames.at(i) == "SPADSRPScaleFactor")) // made changes by TUAN NGUYEN
{
found = true;
break;
}
else
{
CrIndex += forObj->GetEstimationParameterSize(forObj->GetParameterID(stmElemNames.at(i)));
}
}
if (!found)
{
//MessageInterface::ShowMessage("Not found Cr in StmElementNames: deriv = 0.0\n");
//MessageInterface::ShowMessage("SignalBase::GetCrDerivative(forObj = <%s>) end\n", forObj->GetName().c_str());
return 0.0;
}
// Get C derivative vector
Rvector dVector;
GetCDerivativeVector(forObj, dVector, "Cr");
// Get Cr partial derivative
Real deriv = dVector[CrIndex];
//MessageInterface::ShowMessage("Found Cr in StmElementNames: deriv = %.12le CrIndex = %d\n", deriv, CrIndex);
//MessageInterface::ShowMessage("SignalBase::GetCrDerivative(forObj = <%s>) end\n", forObj->GetName().c_str());
return deriv;
}
Real SignalBase::GetCdDerivative(GmatBase *forObj)
{
// get index for Cd
StringArray stmElemNames = forObj->GetStringArrayParameter("StmElementNames");
UnsignedInt CdIndex = 0;
bool found = false;
for (int i = 0; i < stmElemNames.size(); i++) {
if (stmElemNames.at(i) == "CartesianState" || stmElemNames.at(i) == "KeplerianState")
CdIndex += 0; // vector that GetCDerivativeVector() returns does not include cartesian state
else if ((stmElemNames.at(i) == "Cd") || (stmElemNames.at(i) == "SPADDragScaleFactor")) // made changes by TUAN NGUYEN
{
found = true;
break;
}
else
{
CdIndex += forObj->GetEstimationParameterSize(forObj->GetParameterID(stmElemNames.at(i)));
}
}
if (!found)
return 0.0;
// Get C derivative vector
Rvector dVector;
GetCDerivativeVector(forObj, dVector, "Cd");
// Get Cr partial derivative
Real deriv = dVector[CdIndex];
return deriv;
}
// Added for Thrust Scale Factor Solve For
Real SignalBase::GetTSFDerivative(GmatBase *forObj, const std::string ¶mName)
{
// paramName looks like <segmentName>.TSF_Epsilon
StringArray parts = GmatStringUtil::SeparateBy(paramName, ".");
std::string tsfName = parts.at(0) + ".ThrustScaleFactor";
// get index for TSF
StringArray stmElemNames = forObj->GetStringArrayParameter("StmElementNames");
UnsignedInt TSFIndex = 0;
bool found = false;
for (int i = 0; i < stmElemNames.size(); i++) {
if (stmElemNames.at(i) == "CartesianState" || stmElemNames.at(i) == "KeplerianState")
TSFIndex += 0; // vector that GetCDerivativeVector() returns does not include cartesian state
else if (stmElemNames.at(i) == tsfName) {
found = true;
break;
}
else {
TSFIndex += forObj->GetEstimationParameterSize(forObj->GetParameterID(stmElemNames.at(i)));
}
}
if (!found)
return 0.0;
// Get C derivative vector
Rvector dVector;
GetCDerivativeVector(forObj, dVector, "TSF");
// Get TSF partial derivative
Real deriv = dVector[TSFIndex];
return deriv;
}
void SignalBase::GetCDerivativeVector(GmatBase *forObj, Rvector &deriv, const std::string &solveForType)
{
// 1. Calculate phi matrix
//MessageInterface::ShowMessage("forObj = <%p,%s> theData.tNode = <%p,%s> theData.rNode = <%p,%s>\n",
// forObj, forObj->GetName().c_str(),
// theData.tNode, theData.tNode->GetName().c_str(),
// theData.rNode, theData.rNode->GetName().c_str());
bool forTransmitter = true;
if (theData.rNode == forObj)
forTransmitter = false;
else
{
if (theData.tNode != forObj)
throw MeasurementException(solveForType + " derivative requested, but "
"neither participant is the \"for\" object");
}
Rmatrix phi = (forTransmitter ? (theData.tSTM*theData.tSTMtm.Inverse()) : (theData.rSTM*theData.rSTMtm.Inverse()));
// 2. Calculate E matrix
Integer m = phi.GetNumColumns() - 6;
Rmatrix E(3,m);
for (Integer i = 0; i < 3; ++i)
{
for (Integer j = 0; j < m; ++j)
{
E(i, j) = phi(i, j + 6);
}
}
// 3. Calculate: sign * R * phi
Real sign = (forTransmitter ? -1.0 : 1.0);
Rmatrix33 body2FK5_matrix = (forTransmitter ? theData.tJ2kRotation :
theData.rJ2kRotation);
Rmatrix tempMatrix(3,m);
// tempMatrix = body2FK5_matrix * E;
for (Integer i = 0; i < 3; ++i)
{
for (Integer j = 0; j < m; ++j)
{
tempMatrix(i, j) = 0.0;
for (Integer k = 0; k < 3; ++k)
tempMatrix(i, j) += sign*body2FK5_matrix(i, k) * E(k, j);
}
}
// 4. Calculate range unit vector
Rvector3 rangeVec = theData.rangeVecInertial;
Rvector3 unitRange = rangeVec / rangeVec.GetMagnitude();
// 5. Calculate C vector derivative
deriv.SetSize(m);
for (Integer j = 0; j < m; ++j)
{
deriv[j] = 0.0;
for (Integer i = 0; i < 3; ++i)
deriv[j] += unitRange[i]*tempMatrix(i, j);
}
}
//------------------------------------------------------------------------------
// void GetRangeDerivative(GmatBase *forObj, bool wrtR, bool wrtV,
// Rvector &deriv)
//------------------------------------------------------------------------------
/**
* Calculates the range derivative of a signal in a measurement
*
* @param forObj Pointer for the participants that hold the w.r.t field
* @param wrtR Flag indicating if derivative with respect to position is desired
* @param wrtV Flag indicating if derivative with respect to velocity is desired
* @param deriv The structure that gets filled with derivative data
*/
//------------------------------------------------------------------------------
void SignalBase::GetRangeDerivative(GmatBase *forObj, bool wrtR, bool wrtV,
Rvector &deriv)
{
Rmatrix derivMatrix;
if (wrtR && wrtV)
derivMatrix.SetSize(6,6);
else
derivMatrix.SetSize(3,3);
GetRangeVectorDerivative(forObj, wrtR, wrtV, derivMatrix);
Rvector3 rangeVec = theData.rangeVecInertial;
Rvector3 temp;
Rmatrix33 mPart;
Rvector3 unitRange = rangeVec / rangeVec.GetMagnitude();
if (wrtR)
{
for (Integer i = 0; i < 3; ++i)
for (Integer j = 0; j < 3; ++j)
mPart(i,j) = derivMatrix(i,j);
temp = unitRange * mPart;
for (Integer i = 0; i < 3; ++i)
deriv[i] = temp(i);
}
if (wrtV)
{
Integer offset = (wrtR ? 3 : 0);
for (Integer i = 0; i < 3; ++i)
for (Integer j = 0; j < 3; ++j)
mPart(i,j) = derivMatrix(i+offset, j+offset);
temp = unitRange * mPart;
for (Integer i = 0; i < 3; ++i)
deriv[i+offset] = temp(i);
}
}
//------------------------------------------------------------------------------
// void GetRangeVectorDerivative(GmatBase *forObj, bool wrtR, bool wrtV,
// Rmatrix& derivMatrix)
//------------------------------------------------------------------------------
/**
* Calculates the range vector derivative of a signal in a measurement
*
* @param forObj Pointer for the participants that hold the w.r.t field
* @param usingData SignalData for the signal being evaluated
* @param wrtR Flag indicating if derivative with respect to position is desired
* @param wrtV Flag indicating if derivative with respect to velocity is desired
* @param derivMatrix The structure that gets filled with derivative data
*/
//------------------------------------------------------------------------------
void SignalBase::GetRangeVectorDerivative(GmatBase *forObj, bool wrtR,
bool wrtV, Rmatrix& derivMatrix)
{
bool forTransmitter = true;
if (theData.rNode == forObj)
forTransmitter = false;
else
{
if (theData.tNode != forObj)
throw MeasurementException("Range vector derivative requested, but "
"neither participant is the \"for\" object");
}
// For now ignoring the barycenter piece -- we'll add it once core code works
Rvector3 rangeVec = theData.rangeVecInertial; // Check sign?
// phi(t1,tm) = phi(t1, t0)* Inv(phi(tm, t0)) where: t0 is initial epoch; tm is measurement time; t1 is either transmit time or receive time
//Rmatrix phi = (forTransmitter ? theData.tSTM : theData.rSTM);
/// @todo Adjust the following code for multiple spacecraft
Rmatrix phi = (forTransmitter ? (theData.tSTM*theData.tSTMtm.Inverse()) : (theData.rSTM*theData.rSTMtm.Inverse()));
// Check: Not using old STM inverse approach -- STMs computed from initial
// (measurement epoch based) state, so STM inverse is identity
Rmatrix33 A, B;
for (Integer i = 0; i < 3; ++i)
{
for (Integer j = 0; j < 3; ++j)
{
if (wrtR)
A(i, j) = phi(i, j); // sub-matrix A of state transition matrix Phi in Equation 6.31 in GMAT MathSpec
if (wrtV)
{
//B(i,j) = phi(i+3,j+3); // ekf mod 12/16
B(i, j) = phi(i, j + 3); // sub-matrix B of state transition matrix Phi in Equation 6.31 in GMAT MathSpec
}
}
}
Real sign = (forTransmitter ? -1.0 : 1.0);
Rmatrix33 temp;
Rmatrix33 body2FK5_matrix = (forTransmitter ? theData.tJ2kRotation :
theData.rJ2kRotation);
if (wrtR)
{
// temp = dataToUse.rInertial2obj * A;
temp = body2FK5_matrix * A;
for (Integer i = 0; i < 3; ++i)
for (Integer j = 0; j < 3; ++j)
derivMatrix(i,j) = sign * temp(i,j);
}
if (wrtV)
{
// temp = dataToUse.rInertial2obj * B;
temp = body2FK5_matrix * B;
Integer offset = (wrtR ? 3 : 0);
for (Integer i = 0; i < 3; ++i)
for (Integer j = 0; j < 3; ++j)
derivMatrix(i+offset,j+offset) = sign * temp(i,j);
}
}
//------------------------------------------------------------------------------
// void UpdateRotationMatrix(Real atEpoch, const std::string& whichOne)
//------------------------------------------------------------------------------
/**
* Updates the rotation matrices for the passed-in epoch
*
* @param atEpoch The epoch of the update
* @param whichOne Identity of the matrix to update, or "All" for all
*/
//------------------------------------------------------------------------------
void SignalBase::UpdateRotationMatrix(Real atEpoch, const std::string& whichOne)
{
if ((theData.tNode == NULL) && (theData.rNode != NULL))
{
// for GPS measurement
R_j2k_Receiver = I33;
theData.rJ2kRotation = I33;
R_j2k_Transmitter = I33;
theData.tJ2kRotation = I33;
R_Obs_Receiver = I33;
R_Obs_Transmitter = I33;
R_Obs_j2k = I33;
RDot_Obs_Receiver = zero33;
RDot_Obs_Transmitter = zero33;
RDot_Obs_j2k = zero33;
return;
}
if ((theData.tNode->IsOfType(Gmat::GROUND_STATION)) ||
(theData.rNode->IsOfType(Gmat::GROUND_STATION)))
{
Rvector6 dummyIn(1.0,2.0,3.0, 4.0,5.0,6.0);
Rvector6 dummyOut;
A1Mjd itsEpoch(atEpoch);
bool updated = false;
if ((whichOne == "All") || (whichOne == "j2k_2"))
{
converter.Convert(itsEpoch,dummyIn,rcs,dummyOut,j2k);
R_j2k_Receiver = converter.GetLastRotationMatrix();
// RDot_j2k_2 = converter.GetLastRotationDotMatrix();
converter.Convert(itsEpoch,dummyIn,j2k,dummyOut,rcs);
theData.rJ2kRotation = converter.GetLastRotationMatrix();
updated = true;
}
if ((whichOne == "All") || (whichOne == "j2k_1"))
{
converter.Convert(itsEpoch,dummyIn,tcs,dummyOut,j2k);
R_j2k_Transmitter = converter.GetLastRotationMatrix();
// RDot_j2k_1 = converter.GetLastRotationDotMatrix();
converter.Convert(itsEpoch,dummyIn,j2k,dummyOut,tcs);
theData.tJ2kRotation = converter.GetLastRotationMatrix();
updated = true;
}
if ((whichOne == "All") || (whichOne == "o_2"))
{
converter.Convert(itsEpoch,dummyIn,rcs,dummyOut,ocs);
R_Obs_Receiver = converter.GetLastRotationMatrix();
RDot_Obs_Receiver = converter.GetLastRotationDotMatrix();
updated = true;
}
if ((whichOne == "All") || (whichOne == "o_1"))
{
converter.Convert(itsEpoch,dummyIn,tcs,dummyOut,ocs);
R_Obs_Transmitter = converter.GetLastRotationMatrix();
RDot_Obs_Transmitter = converter.GetLastRotationDotMatrix();
updated = true;
}
if ((whichOne == "All") || (whichOne == "o_j2k"))
{
converter.Convert(itsEpoch,dummyIn,j2k,dummyOut,ocs);
R_Obs_j2k = converter.GetLastRotationMatrix();
RDot_Obs_j2k = converter.GetLastRotationDotMatrix();
updated = true;
}
if (updated == false)
{
std::stringstream ss;
ss << "Error: UpdateRotationMatrix() input parameter whichOne (" << whichOne << ") has an invalid value\n";
throw MeasurementException(ss.str());
}
}
else
{
// When both participants are spacecraft, all frames are inertial, so all
// rotation matrices are I33 (which is the default on creation) and all
// Rotation Dot matrices are zero33
R_j2k_Receiver = I33;
theData.rJ2kRotation = I33;
R_j2k_Transmitter = I33;
theData.tJ2kRotation = I33;
R_Obs_Receiver = I33;
R_Obs_Transmitter = I33;
R_Obs_j2k = I33;
RDot_Obs_Receiver = zero33;
RDot_Obs_Transmitter = zero33;
RDot_Obs_j2k = zero33;
}
}
//-----------------------------------------------------------------------------
// Integer GetParmIdFromEstID(Integer forId, GmatBase *obj)
//-----------------------------------------------------------------------------
/**
* Uses a measurement ID and object to convert that id into a parameter ID
*
* @param forId The measurement ID
* @param obj The object that owns the id
*
* @return The parameter ID on the object
*/
//-----------------------------------------------------------------------------
Integer SignalBase::GetParmIdFromEstID(Integer forId, GmatBase *obj)
{
return forId - obj->GetType() * 250;
}
void SignalBase::MoveToEpoch(const GmatTime theEpoch, bool epochAtReceive,
bool moveAll)
{
GmatTime t = theEpoch;
#ifdef DEBUG_LIGHTTIME
MessageInterface::ShowMessage("Called MoveToEpoch(%.12lf, %s%s)\n",
t.GetMjd(),
(epochAtReceive ? "Epoch at Receive" : "Epoch at Transmit"),
(moveAll ? ", Moving all participants" : ""));
#endif
// 1. Propagate receive node at time theEpoch and update its SignalData
if (epochAtReceive || moveAll)
{
/// @todo Adjust the following code for multiple spacecraft
Real dt = (theEpoch - theData.rPrecTime).GetTimeInSec();
#ifdef DEBUG_LIGHTTIME
MessageInterface::ShowMessage(" dt = (%.12lf - %.12lf)*86400 => %.12le\n",
t.GetMjd(), theData.rPrecTime.GetMjd(), dt);
#endif
// Update model epoch
ODEModel *ode = NULL;
if (theData.tNode->IsOfType(Gmat::SPACEOBJECT))
{
if (theData.tPropagator != NULL)
{
if (theData.tPropagator->GetPropagator()->UsesODEModel())
{
ode = theData.tPropagator->GetODEModel();
ode->UpdateInitialData();
}
else
{
theData.tPropagator->GetPropagator()->UpdateSpaceObjectGT(theData.rPrecTime);
}
}
}
if (theData.rNode->IsOfType(Gmat::SPACEOBJECT))
{
if (theData.rPropagator != NULL)
{
if (theData.rPropagator->GetPropagator()->UsesODEModel())
{
ode = theData.rPropagator->GetODEModel();
ode->UpdateInitialData();
}
else
{
theData.rPropagator->GetPropagator()->UpdateSpaceObjectGT(theData.rPrecTime);
}
}
}
if (dt != 0.0)
{
StepParticipant(dt, false);
}
else
{
Rvector6 state;
Rmatrix stm; // state transition matrix
if (theData.rNode->IsOfType(Gmat::GROUND_STATION))
{
state = theData.rNode->GetMJ2000PrecState(theEpoch);
// For a ground station, its STM is I matrix
stm.SetSize(6,6,true);
for (UnsignedInt i = 0; i < 6; ++i)
stm(i,i) = 1.0;
}
else
{
// Retrieve spacecraft data from the propagator
const Real *pstate =
theData.rPropagator->GetPropagator()->AccessOutState();
// set value for state and STM
// This step is used to convert spacecraft's state to Spacecraft.CoordinateSystem
state.Set(pstate);
SpacePoint* spacecraftOrigin = ((Spacecraft*)(theData.rNode))->GetOrigin(); // the origin of the transmit spacecraft's cooridinate system // fix bug GMT-5364
SpacePoint* propOrigin = nullptr;
if (theData.rPropagator->GetPropagator()->UsesODEModel())
propOrigin = theData.rPropagator->GetODEModel()->GetForceOrigin(); // the origin of the coordinate system used in forcemodel // fix bug GMT-5364
else
propOrigin = theData.rPropagator->GetPropagator()->GetPropOrigin();
state = state + (propOrigin->GetMJ2000PrecState(theData.rPrecTime) - spacecraftOrigin->GetMJ2000PrecState(theData.rPrecTime)); // fix bug GMT-5364
// Set size for stm
Integer stmRowCount = theData.rNode->GetIntegerParameter("FullSTMRowCount");
stm.SetSize(stmRowCount, stmRowCount, true);
// Get start index of STM
const std::vector<ListItem*>* map = theData.rPropagator->GetPropStateManager()->GetStateMap();
UnsignedInt stmStartIndex = -1;
for (UnsignedInt index = 0; index < map->size(); ++index)
{
if (((*map)[index]->object == theData.rNode) && ((*map)[index]->elementName == "STM"))
{
stmStartIndex = index;
break;
}
}
// Set value for stm
for (UnsignedInt i = 0; i < stmRowCount; ++i)
for (UnsignedInt j = 0; j < stmRowCount; ++j)
stm(i,j) = pstate[stmStartIndex + i*stmRowCount + j];
}
theData.rLoc = state.GetR();
theData.rVel = state.GetV();
// Whenever updating participant's state in signal data, it needs to update participant's STM
theData.rSTM = stm;
SpecialCelestialPoint* ssb = solarSystem->GetSpecialPoint("SolarSystemBarycenter");
theData.rOStateSSB = rcs->GetOrigin()->GetMJ2000PrecState(theData.rPrecTime) -
ssb->GetMJ2000PrecState(theData.rPrecTime);
}
#ifdef DEBUG_MOVETOEPOCH
if (theData.rNode->IsOfType(Gmat::GROUND_STATION))
MessageInterface::ShowMessage("Move to epoch: %.12lf participant %s position in EarthMJ2000Eq [%.12lf %.12lf %.12lf] velocity [%.12lf %.12lf %.12lf]\n", t.GetMjd(), theData.rNode->GetName().c_str(), theData.rLoc[0], theData.rLoc[1], theData.rLoc[2], theData.rVel[0], theData.rVel[1], theData.rVel[2]);
else
MessageInterface::ShowMessage("Move to epoch: %.12lf participant %s position in %s [%.12lf %.12lf %.12lf] velocity [%.12lf %.12lf %.12lf]\n", t.GetMjd(), theData.rNode->GetName().c_str(), theData.rNode->GetStringParameter("CoordinateSystem").c_str(),theData.rLoc[0], theData.rLoc[1], theData.rLoc[2], theData.rVel[0], theData.rVel[1], theData.rVel[2]);
#endif
}
// 2. Propagate transmit node at time theEpoch and update it's SignalData
if (!epochAtReceive || moveAll)
{
Real dt = (theEpoch - theData.tPrecTime).GetTimeInSec();
#ifdef DEBUG_LIGHTTIME
MessageInterface::ShowMessage(" dt = (%.12lf - %.12lf)*86400 => %.12le\n",
t.GetMjd(), theData.tPrecTime.GetMjd(), dt);
#endif
if (dt != 0.0)
{
StepParticipant(dt, true);
}
else
{
Rvector6 state;
Rmatrix stm; // state transition matrix
if (theData.tNode->IsOfType(Gmat::GROUND_STATION))
{
state = theData.tNode->GetMJ2000PrecState(theEpoch);
// For a ground station, its STM is a 6x6 I matrix
stm.SetSize(6,6,true);
for (UnsignedInt i = 0; i < 6; ++i)
stm(i,i) = 1.0;
}
else
{
// Retrieve spacecraft data from the propagator
const Real *pstate =
theData.tPropagator->GetPropagator()->AccessOutState();
// set value for state and STM
// This step is used to convert spacecraft's state to Spacecraft.CoordinateSystem
state.Set(pstate);
SpacePoint* spacecraftOrigin = ((Spacecraft*)(theData.tNode))->GetOrigin(); // the origin of the transmit spacecraft's cooridinate system // fix bug GMT-5364
SpacePoint* propOrigin = nullptr;
if (theData.tPropagator->GetPropagator()->UsesODEModel())
propOrigin = theData.tPropagator->GetODEModel()->GetForceOrigin(); // the origin of the coordinate system used in forcemodel // fix bug GMT-5364
else
propOrigin = theData.tPropagator->GetPropagator()->GetPropOrigin();
state = state + (propOrigin->GetMJ2000PrecState(theData.tPrecTime) - spacecraftOrigin->GetMJ2000PrecState(theData.tPrecTime)); // fix bug GMT-5364
// Set size for stm
Integer stmRowCount = theData.tNode->GetIntegerParameter("FullSTMRowCount");
stm.SetSize(stmRowCount, stmRowCount, true);
// Get start index of STM
const std::vector<ListItem*>* map = theData.tPropagator->GetPropStateManager()->GetStateMap();
UnsignedInt stmStartIndex = -1;
for (UnsignedInt index = 0; index < map->size(); ++index)
{
if (((*map)[index]->object == theData.tNode) && ((*map)[index]->elementName == "STM"))
{
stmStartIndex = index;
break;
}
}
// Set value for stm
for (UnsignedInt i = 0; i < stmRowCount; ++i)
for (UnsignedInt j = 0; j < stmRowCount; ++j)
stm(i,j) = pstate[stmStartIndex + i*stmRowCount + j];
}
theData.tLoc = state.GetR();
theData.tVel = state.GetV();
// Whenever updating participant's state in signal data, it needs to update participant's STM
theData.tSTM = stm;
SpecialCelestialPoint* ssb = solarSystem->GetSpecialPoint("SolarSystemBarycenter");
theData.tOStateSSB = tcs->GetOrigin()->GetMJ2000PrecState(theData.tPrecTime) -
ssb->GetMJ2000PrecState(theData.tPrecTime);
}
#ifdef DEBUG_MOVETOEPOCH
if (theData.tNode->IsOfType(Gmat::GROUND_STATION))
MessageInterface::ShowMessage("Move to epoch: %.12lf participant %s position in EarthMJ2000Eq [%.12lf %.12lf %.12lf] velocity [%.12lf %.12lf %.12lf]\n", t.GetMjd(), theData.tNode->GetName().c_str(), theData.tLoc[0], theData.tLoc[1], theData.tLoc[2], theData.tVel[0], theData.tVel[1], theData.tVel[2]);
else
MessageInterface::ShowMessage("Move to epoch: %.12lf participant %s position in %s [%.12lf %.12lf %.12lf] velocity [%.12lf %.12lf %.12lf]\n", t.GetMjd(), theData.tNode->GetName().c_str(), theData.tNode->GetStringParameter("CoordinateSystem").c_str(), theData.tLoc[0], theData.tLoc[1], theData.tLoc[2], theData.tVel[0], theData.tVel[1], theData.tVel[2]);
#endif
}
}
//------------------------------------------------------------------------------
// void SetIonosphereCache(SignalDataCache::SimpleSignalDataCache* cache)
//------------------------------------------------------------------------------
/**
* Sets the ionosphere cache for the signal
*
* @param cache The ionosphere cache
*/
//------------------------------------------------------------------------------
void SignalBase::SetIonosphereCache(SignalDataCache::SimpleSignalDataCache * cache)
{
// Set it to all signals in the path
ionosphereCache = cache;
if (next)
next->SetIonosphereCache(cache);
}
//------------------------------------------------------------------------------
// void SetStrandId(unsigned long id)
//------------------------------------------------------------------------------
/**
* Sets the strand ID
*
* @param id The strand id
*/
//------------------------------------------------------------------------------
void SignalBase::SetStrandId(unsigned long id)
{
strandId = id;
}
//------------------------------------------------------------------------------
// void SetPrevious(SignalBase* prev)
//------------------------------------------------------------------------------
/**
* Build the backwards link for the doubly linked list
*
* @param prev Link to the owner of this signal in the list
*/
//------------------------------------------------------------------------------
void SignalBase::SetPrevious(SignalBase* prev)
{
previous = prev;
}
//------------------------------------------------------------------------------
// bool StepParticipant(Real stepToTake, bool forTransmitter)
//------------------------------------------------------------------------------
/**
* Steps a participant in time, and updates the J2k state buffer accordingly
*
* @param stepToTake The amount of time needed for the propagation
* @param forTransmitter True to step the transmitter participant, false to
* step the receiver
*
* @return true is a step succeeded, false if it failed
*/
//------------------------------------------------------------------------------
bool SignalBase::StepParticipant(Real stepToTake, bool forTransmitter)
{
#ifdef DEBUG_LIGHTTIME
MessageInterface::ShowMessage("Called StepParticipant(%.12le, %s)\n",
stepToTake, (forTransmitter ? "stepping transmitter" :
"stepping receiver"));
#endif
bool retval = false;
// 1. Get associated propagator for transmiter node (or receiver node)
Propagator *prop = NULL;
if (forTransmitter)
{
if (theData.tNode->IsOfType(Gmat::SPACEOBJECT))
{
if (theData.tPropagator != NULL)
prop = theData.tPropagator->GetPropagator();
else
throw MeasurementException("The propagator for the transmitting "
"participant \"" + theData.transmitParticipant +
"\" has not been set in the signal that needs it");
}
}
else
{
if (theData.rNode->IsOfType(Gmat::SPACEOBJECT))
{
if (theData.rPropagator != NULL)
prop = theData.rPropagator->GetPropagator();
else
throw MeasurementException("The propagator for the receiving "
"participant \"" + theData.transmitParticipant +
"\" has not been set in the signal that needs it");
}
}
// 2. Propagate transmiter node (or receiver node) for stepToTake and specify its state
Rvector6 state;
Rmatrix stm; // state transition matrix
GmatTime tPrecTimeNew = theData.tPrecTime + stepToTake / GmatTimeConstants::SECS_PER_DAY;
GmatTime rPrecTimeNew = theData.rPrecTime + stepToTake / GmatTimeConstants::SECS_PER_DAY;
if (prop) // Handle spacecraft
{
#ifdef DEBUG_LIGHTTIME
MessageInterface::ShowMessage("Propagating numerically\n");
#endif
const Real *outState = prop->AccessOutState();
#ifdef DEBUG_LIGHTTIME
MessageInterface::ShowMessage(" ---> Before: %.12lf\n", state[0]);
#endif
retval = prop->Step(stepToTake);
if (retval == false)
{
MessageInterface::ShowMessage("Failed to step %s by %le secs\n",
(forTransmitter ? theData.transmitParticipant.c_str() :
theData.receiveParticipant.c_str()), stepToTake);
}
/// @todo Adjust the following code for multiple spacecraft
// This step is used to convert spacecraft's state to Spacecraft.CoordinateSystem
state.Set(outState);
if (forTransmitter)
{
SpacePoint* spacecraftOrigin = ((Spacecraft*)(theData.tNode))->GetOrigin(); // the origin of the transmit spacecraft's cooridinate system
SpacePoint* propOrigin = nullptr;
if (theData.tPropagator->GetPropagator()->UsesODEModel())
propOrigin = theData.tPropagator->GetODEModel()->GetForceOrigin(); // the origin of the coordinate system used in forcemodel // fix bug GMT-5364
else
propOrigin = theData.tPropagator->GetPropagator()->GetPropOrigin();
state = state + (propOrigin->GetMJ2000PrecState(tPrecTimeNew) - spacecraftOrigin->GetMJ2000PrecState(tPrecTimeNew));
}
else
{
SpacePoint* spacecraftOrigin = ((Spacecraft*)(theData.rNode))->GetOrigin(); // the origin of the transmit spacecraft's cooridinate system
SpacePoint* propOrigin = nullptr;
if (theData.rPropagator->GetPropagator()->UsesODEModel())
propOrigin = theData.rPropagator->GetODEModel()->GetForceOrigin(); // the origin of the coordinate system used in forcemodel // fix bug GMT-5364
else
propOrigin = theData.rPropagator->GetPropagator()->GetPropOrigin();
state = state + (propOrigin->GetMJ2000PrecState(rPrecTimeNew) - spacecraftOrigin->GetMJ2000PrecState(rPrecTimeNew));
}
// Set size for stm
Integer stmRowCount;
if (forTransmitter)
stmRowCount = theData.tNode->GetIntegerParameter("FullSTMRowCount");
else
stmRowCount = theData.rNode->GetIntegerParameter("FullSTMRowCount");
stm.SetSize(stmRowCount, stmRowCount, true);
// Get start index of STM
UnsignedInt stmStartIndex = -1;
if (forTransmitter)
{
const std::vector<ListItem*>* map = theData.tPropagator->GetPropStateManager()->GetStateMap();
for (UnsignedInt index = 0; index < map->size(); ++index)
{
if (((*map)[index]->object == theData.tNode) && ((*map)[index]->elementName == "STM"))
{
stmStartIndex = index;
break;
}
}
}
else
{
const std::vector<ListItem*>* map = theData.rPropagator->GetPropStateManager()->GetStateMap();
for (UnsignedInt index = 0; index < map->size(); ++index)
{
if (((*map)[index]->object == theData.rNode) && ((*map)[index]->elementName == "STM"))
{
stmStartIndex = index;
break;
}
}
}
// Set value for stm
for (UnsignedInt i = 0; i < stmRowCount; ++i)
for (UnsignedInt j = 0; j < stmRowCount; ++j)
stm(i,j) = outState[stmStartIndex + i*stmRowCount + j];
// Buffer the STM
if (forTransmitter)
theData.tSTM = stm;
else
theData.rSTM = stm;
#ifdef DEBUG_LIGHTTIME
MessageInterface::ShowMessage(" ---> After %.12lf : %.12lf\n",
prop->GetStepTaken(), state(0));
#endif
#ifdef DEBUG_DERIVATIVES
MessageInterface::ShowMessage(" STM = %s\n", stm.ToString().c_str());
#endif
}
else // Handle ground stations and other analytic props
{
#ifdef DEBUG_LIGHTTIME
MessageInterface::ShowMessage("Propagating analytically\n");
#endif
if (forTransmitter)
{
state = theData.tNode->GetMJ2000PrecState(tPrecTimeNew);
}
else
{
state = theData.rNode->GetMJ2000PrecState(rPrecTimeNew);
}
// For ground station, its STM is a 6x6 I matrix
stm.SetSize(6,6,true);
for(UnsignedInt i = 0; i < 6; ++i)
stm(i,i) = 1.0;
}
// 3. Set value for SignalData object associated to transmiter node (or receiver node)
SpecialCelestialPoint* ssb = solarSystem->GetSpecialPoint("SolarSystemBarycenter");
if (forTransmitter)
{
theData.tLoc = state.GetR();
theData.tVel = state.GetV();
// whenever updating participant's state, it needs to update its STM
theData.tSTM = stm;
theData.tPrecTime += stepToTake / GmatTimeConstants::SECS_PER_DAY;
theData.tOStateSSB = tcs->GetOrigin()->GetMJ2000PrecState(theData.tPrecTime) -
ssb->GetMJ2000PrecState(theData.tPrecTime);
}
else
{
theData.rLoc = state.GetR();
theData.rVel = state.GetV();
// whenever updating participant's state, it needs to update its STM
theData.rSTM = stm;
theData.rPrecTime += stepToTake / GmatTimeConstants::SECS_PER_DAY;
theData.rOStateSSB = rcs->GetOrigin()->GetMJ2000PrecState(theData.rPrecTime) -
ssb->GetMJ2000PrecState(theData.rPrecTime);
}
retval = true;
return retval;
}
|
4504ae6a2698bbf995d4565691b67b4cbd3cde68 | ba444c530390b369d92d2a446b2667ed10674ac4 | /problems/11418.cpp | 081fc5e023273f8b2e6e47f14eb77c96290bca12 | [] | no_license | mkroflin/UVa | 62c00eede8b803487fa96c6f34dc089b7ea80df5 | aa9815f710db094fb67ceafb485b139de58e9745 | refs/heads/master | 2022-03-21T05:04:32.445579 | 2018-11-15T19:44:19 | 2018-11-15T19:44:19 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,426 | cpp | 11418.cpp | #include <iostream>
#include <algorithm>
#include <vector>
using namespace std;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<string> vs;
typedef vector<vs> vvs;
int n;
vi V, M;
vvi G;
vvs S;
void turn(int i, int j)
{
transform(S[i][j].begin(), S[i][j].end(), S[i][j].begin(), ::tolower);
S[i][j][0] = toupper(S[i][j][0]);
}
int Aug(vi& M, int u)
{
if (V[u])
return 0;
V[u] = true;
for (int v : G[u])
{
if (M[v] == -1 || Aug(M, M[v]))
{
M[v] = u;
return 1;
}
}
return 0;
}
int main()
{
int t, cs = 0, n, k;
cin >> t;
while (cin >> n, t--)
{
cout << "Case #" << ++cs << ":\n";
G.assign(n + 26, vi());
S.assign(n, vs());
for (int i = 0; i < n; ++i)
{
cin >> k;
S[i].resize(k);
for (int j = 0; j < k; ++j)
cin >> S[i][j], turn(i, j), G[S[i][j][0] - 'A'].push_back(26 + i);
}
M.assign(n + 26, -1);
int MCBM = 0;
for (int i = 0; i < 26; ++i)
V.assign(26, 0), MCBM += Aug(M, i);
string res[26];
for (int i = 26; i < 26 + n; ++i)
for (string s : S[i - 26])
if ('A' + M[i] == s[0])
res[M[i]] = s;
for (int i = 0; i < n; ++i)
cout << res[i] << '\n';
}
}
|
68cc0bf474a15b11cdf0778065fdbd97df1fa265 | 6b40e9dccf2edc767c44df3acd9b626fcd586b4d | /NT/com/netfx/src/clr/jit/ia64/gentree.cpp | bbc24085c8532430ea53547c2e548f11f1eb8c1f | [] | no_license | jjzhang166/WinNT5_src_20201004 | 712894fcf94fb82c49e5cd09d719da00740e0436 | b2db264153b80fbb91ef5fc9f57b387e223dbfc2 | refs/heads/Win2K3 | 2023-08-12T01:31:59.670176 | 2021-10-14T15:14:37 | 2021-10-14T15:14:37 | 586,134,273 | 1 | 0 | null | 2023-01-07T03:47:45 | 2023-01-07T03:47:44 | null | UTF-8 | C++ | false | false | 152,558 | cpp | gentree.cpp | // ==++==
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
// ==--==
/*XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
XX XX
XX GenTree XX
XX XX
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
*/
#include "jitpch.h"
#pragma hdrstop
/*****************************************************************************/
#define fflush(stdout) // why on earth does this crash inside NTDLL?
/*****************************************************************************/
const
unsigned char GenTree::gtOperKindTable[] =
{
#define GTNODE(en,sn,cm,ok) ok + GTK_COMMUTE*cm,
#include "gtlist.h"
#undef GTNODE
};
/*****************************************************************************
*
* The types of different GenTree nodes
*/
#ifdef DEBUG
static
const char * nodeNames[] =
{
#define GTNODE(en,sn,cm,ok) sn,
#include "gtlist.h"
};
const char * GenTree::NodeName(genTreeOps op)
{
assert(op < sizeof(nodeNames)/sizeof(nodeNames[0]));
return nodeNames[op];
}
#endif
/*****************************************************************************
*
* When 'SMALL_TREE_NODES' is enabled, we allocate tree nodes in 2 different
* sizes: 'GTF_NODE_SMALL' for most nodes and 'GTF_NODE_LARGE' for the few
* nodes (such as calls and statement list nodes) that have more fields and
* take up a lot more space.
*/
#if SMALL_TREE_NODES
/* static */
unsigned char GenTree::s_gtNodeSizes[GT_COUNT];
/* static */
void GenTree::InitNodeSize()
{
unsigned op;
/* 'GT_LCL_VAR' gets often changed to 'GT_REG_VAR' */
assert(GenTree::s_gtNodeSizes[GT_LCL_VAR] >= GenTree::s_gtNodeSizes[GT_REG_VAR]);
/* Set all sizes to 'small' first */
for (op = 0; op < GT_COUNT; op++)
GenTree::s_gtNodeSizes[op] = TREE_NODE_SZ_SMALL;
/* Now set all of the appropriate entries to 'large' */
GenTree::s_gtNodeSizes[GT_CALL ] = TREE_NODE_SZ_LARGE;
GenTree::s_gtNodeSizes[GT_INDEX ] = TREE_NODE_SZ_LARGE;
#if RNGCHK_OPT
GenTree::s_gtNodeSizes[GT_IND ] = TREE_NODE_SZ_LARGE;
#endif
#if INLINE_MATH
GenTree::s_gtNodeSizes[GT_MATH ] = TREE_NODE_SZ_LARGE;
#endif
#if INLINING
GenTree::s_gtNodeSizes[GT_FIELD ] = TREE_NODE_SZ_LARGE;
#endif
#ifdef DEBUG
/* GT_STMT is large in DEBUG */
GenTree::s_gtNodeSizes[GT_STMT ] = TREE_NODE_SZ_LARGE;
#endif
}
#if !defined(NDEBUG)
bool GenTree::IsNodeProperlySized()
{
size_t size;
if (gtFlags & GTF_NODE_SMALL)
size = TREE_NODE_SZ_SMALL;
else if (gtFlags & GTF_NODE_LARGE)
size = TREE_NODE_SZ_SMALL;
else
assert(!"bogus node size");
return (bool)(GenTree::s_gtNodeSizes[gtOper] >= size);
}
#endif
#else // SMALL_TREE_NODES
#if !defined(NDEBUG)
bool GenTree::IsNodeProperlySized()
{
return true;
}
#endif
#endif // SMALL_TREE_NODES
/*****************************************************************************/
int Compiler::fgWalkTreeRec(GenTreePtr tree)
{
int result;
genTreeOps oper;
unsigned kind;
AGAIN:
assert(tree);
assert(tree->gtOper != GT_STMT);
/* Visit this node */
if (!fgWalkLclsOnly)
{
result = fgWalkVisitorFn(tree, fgWalkCallbackData);
if (result)
return result;
}
/* Figure out what kind of a node we have */
oper = tree->OperGet();
kind = tree->OperKind();
/* Is this a constant or leaf node? */
if (kind & (GTK_CONST|GTK_LEAF))
{
if (fgWalkLclsOnly && oper == GT_LCL_VAR)
return fgWalkVisitorFn(tree, fgWalkCallbackData);
return 0;
}
/* Is it a 'simple' unary/binary operator? */
if (kind & GTK_SMPOP)
{
if (tree->gtOp.gtOp2)
{
result = fgWalkTreeRec(tree->gtOp.gtOp1);
if (result < 0)
return result;
tree = tree->gtOp.gtOp2;
goto AGAIN;
}
else
{
#if CSELENGTH
/* Some GT_IND have "secret" array length subtrees */
if ((tree->gtFlags & GTF_IND_RNGCHK) != 0 &&
(tree->gtOper == GT_IND) &&
(tree->gtInd.gtIndLen != NULL))
{
result = fgWalkTreeRec(tree->gtInd.gtIndLen);
if (result < 0)
return result;
}
#endif
tree = tree->gtOp.gtOp1;
if (tree)
goto AGAIN;
return 0;
}
}
/* See what kind of a special operator we have here */
switch (oper)
{
case GT_MKREFANY:
case GT_LDOBJ:
// assert op1 is the same place for ldobj and for fields
assert(&tree->gtField.gtFldObj == &tree->gtLdObj.gtOp1);
// fall through let field take care of it
case GT_FIELD:
tree = tree->gtField.gtFldObj;
break;
case GT_CALL:
assert(tree->gtFlags & GTF_CALL);
if (tree->gtCall.gtCallObjp)
{
result = fgWalkTreeRec(tree->gtCall.gtCallObjp);
if (result < 0)
return result;
}
if (tree->gtCall.gtCallArgs)
{
result = fgWalkTreeRec(tree->gtCall.gtCallArgs);
if (result < 0)
return result;
}
#if USE_FASTCALL
if (tree->gtCall.gtCallRegArgs)
{
result = fgWalkTreeRec(tree->gtCall.gtCallRegArgs);
if (result < 0)
return result;
}
#endif
if (tree->gtCall.gtCallVptr)
tree = tree->gtCall.gtCallVptr;
else if (tree->gtCall.gtCallType == CT_INDIRECT)
tree = tree->gtCall.gtCallAddr;
else
tree = NULL;
break;
case GT_JMP:
return 0;
break;
case GT_JMPI:
tree = tree->gtOp.gtOp1;
break;
#if CSELENGTH
case GT_ARR_RNGCHK:
if (tree->gtArrLen.gtArrLenCse)
{
result = fgWalkTreeRec(tree->gtArrLen.gtArrLenCse);
if (result < 0)
return result;
}
if (!(tree->gtFlags & GTF_ALN_CSEVAL))
return 0;
tree = tree->gtArrLen.gtArrLenAdr; assert(tree);
break;
#endif
default:
#ifdef DEBUG
gtDispTree(tree);
#endif
assert(!"unexpected operator");
}
if (tree)
goto AGAIN;
return 0;
}
int Compiler::fgWalkTreeDepRec(GenTreePtr tree)
{
int result;
genTreeOps oper;
unsigned kind;
assert(tree);
assert(tree->gtOper != GT_STMT);
/* Figure out what kind of a node we have */
oper = tree->OperGet();
kind = tree->OperKind();
/* Is this a prefix node? */
if (oper == fgWalkPrefixNode)
{
result = fgWalkVisitorDF(tree, fgWalkCallbackData, true);
if (result < 0)
return result;
}
/* Is this a constant or leaf node? */
if (kind & (GTK_CONST|GTK_LEAF))
goto DONE;
/* Is it a 'simple' unary/binary operator? */
if (kind & GTK_SMPOP)
{
if (tree->gtOp.gtOp1)
{
result = fgWalkTreeDepRec(tree->gtOp.gtOp1);
if (result < 0)
return result;
}
if (tree->gtOp.gtOp2)
{
result = fgWalkTreeDepRec(tree->gtOp.gtOp2);
if (result < 0)
return result;
}
#if CSELENGTH
/* Some GT_IND have "secret" array length subtrees */
if ((tree->gtFlags & GTF_IND_RNGCHK) != 0 &&
(tree->gtOper == GT_IND) &&
(tree->gtInd.gtIndLen != NULL))
{
result = fgWalkTreeDepRec(tree->gtInd.gtIndLen);
if (result < 0)
return result;
}
#endif
goto DONE;
}
/* See what kind of a special operator we have here */
switch (oper)
{
case GT_MKREFANY:
case GT_LDOBJ:
// assert op1 is the same place for ldobj and for fields
assert(&tree->gtField.gtFldObj == &tree->gtLdObj.gtOp1);
// fall through let field take care of it
case GT_FIELD:
if (tree->gtField.gtFldObj)
{
result = fgWalkTreeDepRec(tree->gtField.gtFldObj);
if (result < 0)
return result;
}
break;
case GT_CALL:
assert(tree->gtFlags & GTF_CALL);
if (tree->gtCall.gtCallObjp)
{
result = fgWalkTreeDepRec(tree->gtCall.gtCallObjp);
if (result < 0)
return result;
}
if (tree->gtCall.gtCallArgs)
{
result = fgWalkTreeDepRec(tree->gtCall.gtCallArgs);
if (result < 0)
return result;
}
#if USE_FASTCALL
if (tree->gtCall.gtCallRegArgs)
{
result = fgWalkTreeDepRec(tree->gtCall.gtCallRegArgs);
if (result < 0)
return result;
}
#endif
if (tree->gtCall.gtCallVptr)
{
result = fgWalkTreeDepRec(tree->gtCall.gtCallVptr);
if (result < 0)
return result;
}
else if (tree->gtCall.gtCallType == CT_INDIRECT)
{
result = fgWalkTreeDepRec(tree->gtCall.gtCallAddr);
if (result < 0)
return result;
}
break;
#if CSELENGTH
case GT_ARR_RNGCHK:
if (tree->gtArrLen.gtArrLenCse)
{
result = fgWalkTreeDepRec(tree->gtArrLen.gtArrLenCse);
if (result < 0)
return result;
}
if (tree->gtFlags & GTF_ALN_CSEVAL)
{
assert(tree->gtArrLen.gtArrLenAdr);
result = fgWalkTreeDepRec(tree->gtArrLen.gtArrLenAdr);
if (result < 0)
return result;
}
goto DONE;
#endif
break;
default:
#ifdef DEBUG
gtDispTree(tree);
#endif
assert(!"unexpected operator");
}
DONE:
/* Finally, visit the current node */
return fgWalkVisitorDF(tree, fgWalkCallbackData, false);
}
/*****************************************************************************
*
* Returns non-zero if the two trees are identical.
*/
bool GenTree::Compare(GenTreePtr op1, GenTreePtr op2, bool swapOK)
{
genTreeOps oper;
unsigned kind;
// printf("tree1:\n"); gtDispTree(op1);
// printf("tree2:\n"); gtDispTree(op2);
AGAIN:
#if CSELENGTH
if (op1 == NULL) return (op2 == NULL);
if (op2 == NULL) return false;
#else
assert(op1 && op2);
#endif
assert(op1->gtOper != GT_STMT);
assert(op2->gtOper != GT_STMT);
oper = op1->OperGet();
/* The operators must be equal */
if (oper != op2->gtOper)
return false;
/* The types must be equal */
if (op1->gtType != op2->gtType)
return false;
/* Figure out what kind of nodes we're comparing */
kind = op1->OperKind();
/* Is this a constant node? */
if (kind & GTK_CONST)
{
switch (oper)
{
case GT_CNS_INT:
if (op1->gtIntCon.gtIconVal != op2->gtIntCon.gtIconVal)
break;
return true;
// UNDONE [low pri]: match non-int constant values
}
return false;
}
/* Is this a leaf node? */
if (kind & GTK_LEAF)
{
switch (oper)
{
case GT_LCL_VAR:
if (op1->gtLclVar.gtLclNum != op2->gtLclVar.gtLclNum)
break;
return true;
case GT_CLS_VAR:
if (op1->gtClsVar.gtClsVarHnd != op2->gtClsVar.gtClsVarHnd)
break;
return true;
case GT_LABEL:
return true;
}
return false;
}
/* Is it a 'simple' unary/binary operator? */
if (kind & GTK_SMPOP)
{
if (op1->gtOp.gtOp2)
{
if (!Compare(op1->gtOp.gtOp1, op2->gtOp.gtOp1, swapOK))
{
if (swapOK)
{
/* Special case: "lcl1 + lcl2" matches "lcl2 + lcl1" */
if (oper == GT_ADD && op1->gtOp.gtOp1->gtOper == GT_LCL_VAR
&& op1->gtOp.gtOp2->gtOper == GT_LCL_VAR)
{
if (Compare(op1->gtOp.gtOp1, op2->gtOp.gtOp2, swapOK) &&
Compare(op1->gtOp.gtOp2, op2->gtOp.gtOp1, swapOK))
{
return true;
}
}
}
return false;
}
op1 = op1->gtOp.gtOp2;
op2 = op2->gtOp.gtOp2;
goto AGAIN;
}
else
{
#if CSELENGTH
/* Is either operand a GT_IND node with an array length? */
if (oper == GT_IND)
{
if ((op1->gtFlags|op2->gtFlags) & GTF_IND_RNGCHK)
{
GenTreePtr tmp1 = op1->gtInd.gtIndLen;
GenTreePtr tmp2 = op2->gtInd.gtIndLen;
if (!(op1->gtFlags & GTF_IND_RNGCHK)) tmp1 = NULL;
if (!(op2->gtFlags & GTF_IND_RNGCHK)) tmp2 = NULL;
if (tmp1)
{
if (!Compare(tmp1, tmp2, swapOK))
return false;
}
else
{
if (tmp2)
return false;
}
}
}
#endif
op1 = op1->gtOp.gtOp1;
op2 = op2->gtOp.gtOp1;
if (!op1) return ((bool)(op2 == 0));
if (!op2) return false;
goto AGAIN;
}
}
/* See what kind of a special operator we have here */
switch (oper)
{
case GT_MKREFANY:
case GT_LDOBJ:
if (op1->gtLdObj.gtClass != op2->gtLdObj.gtClass)
break;
op1 = op1->gtLdObj.gtOp1;
op2 = op2->gtLdObj.gtOp1;
goto AGAIN;
case GT_FIELD:
if (op1->gtField.gtFldHnd != op2->gtField.gtFldHnd)
break;
op1 = op1->gtField.gtFldObj;
op2 = op2->gtField.gtFldObj;
if (op1 || op2)
{
if (op1 && op2)
goto AGAIN;
}
return true;
case GT_CALL:
break;
#if CSELENGTH
case GT_ARR_RNGCHK:
if (!Compare(op1->gtArrLen.gtArrLenAdr,
op2->gtArrLen.gtArrLenAdr, swapOK))
{
return false;
}
op1 = op1->gtArrLen.gtArrLenCse;
op2 = op2->gtArrLen.gtArrLenCse;
goto AGAIN;
#endif
default:
assert(!"unexpected operator");
}
return false;
}
/*****************************************************************************
*
* Returns non-zero if the given tree contains a use of a local #lclNum.
*/
// @TODO: make this work with byrefs. In particular, calls with byref
// parameters should be counted as a def.
bool Compiler::gtHasRef(GenTreePtr tree, int lclNum, bool defOnly)
{
genTreeOps oper;
unsigned kind;
AGAIN:
assert(tree);
oper = tree->OperGet();
kind = tree->OperKind();
assert(oper != GT_STMT);
/* Is this a constant node? */
if (kind & GTK_CONST)
return false;
/* Is this a leaf node? */
if (kind & GTK_LEAF)
{
if (oper == GT_LCL_VAR)
{
if (tree->gtLclVar.gtLclNum == (unsigned)lclNum)
{
if (!defOnly)
return true;
}
}
return false;
}
/* Is it a 'simple' unary/binary operator? */
if (kind & GTK_SMPOP)
{
if (tree->gtOp.gtOp2)
{
if (gtHasRef(tree->gtOp.gtOp1, lclNum, defOnly))
return true;
tree = tree->gtOp.gtOp2;
goto AGAIN;
}
else
{
tree = tree->gtOp.gtOp1;
if (!tree)
return false;
if (kind & GTK_ASGOP)
{
// 'tree' is the gtOp1 of an assignment node. So we can handle
// the case where defOnly is either true or false.
if (tree->gtOper == GT_LCL_VAR &&
tree->gtLclVar.gtLclNum == (unsigned)lclNum)
{
return true;
}
else if (tree->gtOper == GT_FIELD &&
lclNum == (int)tree->gtField.gtFldHnd)
{
return true;
}
}
goto AGAIN;
}
}
/* See what kind of a special operator we have here */
switch (oper)
{
case GT_MKREFANY:
case GT_LDOBJ:
tree = tree->gtField.gtFldObj;
if (tree)
goto AGAIN;
break;
case GT_FIELD:
if (lclNum == (int)tree->gtField.gtFldHnd)
{
if (!defOnly)
return true;
}
tree = tree->gtField.gtFldObj;
if (tree)
goto AGAIN;
break;
case GT_CALL:
if (tree->gtCall.gtCallObjp)
if (gtHasRef(tree->gtCall.gtCallObjp, lclNum, defOnly))
return true;
if (tree->gtCall.gtCallArgs)
if (gtHasRef(tree->gtCall.gtCallArgs, lclNum, defOnly))
return true;
#if USE_FASTCALL
if (tree->gtCall.gtCallRegArgs)
if (gtHasRef(tree->gtCall.gtCallRegArgs, lclNum, defOnly))
return true;
#endif
if (tree->gtCall.gtCallVptr)
tree = tree->gtCall.gtCallVptr;
else if (tree->gtCall.gtCallType == CT_INDIRECT)
tree = tree->gtCall.gtCallAddr;
else
tree = NULL;
if (tree)
goto AGAIN;
break;
default:
#ifdef DEBUG
gtDispTree(tree);
#endif
assert(!"unexpected operator");
}
return false;
}
/*****************************************************************************/
#if RNGCHK_OPT || CSE
/*****************************************************************************
*
* Helper used to compute hash values for trees.
*/
inline
unsigned genTreeHashAdd(unsigned old, unsigned add)
{
return (old + old/2) ^ add;
}
inline
unsigned genTreeHashAdd(unsigned old, unsigned add1,
unsigned add2)
{
return (old + old/2) ^ add1 ^ add2;
}
/*****************************************************************************
*
* Given an arbitrary expression tree, compute a hash value for it.
*/
unsigned Compiler::gtHashValue(GenTree * tree)
{
genTreeOps oper;
unsigned kind;
unsigned hash = 0;
#if CSELENGTH
GenTreePtr temp;
#endif
AGAIN:
assert(tree);
assert(tree->gtOper != GT_STMT);
/* Figure out what kind of a node we have */
oper = tree->OperGet();
kind = tree->OperKind();
#if CSELENGTH
if (oper == GT_ARR_LENGTH)
{
/* GT_ARR_LENGTH must hash to the same thing as GT_ARR_RNGCHK */
hash = genTreeHashAdd(hash, GT_ARR_RNGCHK);
temp = tree->gtOp.gtOp1;
goto ARRLEN;
}
#endif
/* Include the operator value in the hash */
hash = genTreeHashAdd(hash, oper);
/* Is this a constant or leaf node? */
if (kind & (GTK_CONST|GTK_LEAF))
{
unsigned add;
switch (oper)
{
case GT_LCL_VAR: add = tree->gtLclVar.gtLclNum; break;
case GT_CNS_INT: add = (int)tree->gtIntCon.gtIconVal; break;
case GT_CNS_LNG: add = (int)tree->gtLngCon.gtLconVal; break;
case GT_CNS_FLT: add = (int)tree->gtFltCon.gtFconVal; break;
case GT_CNS_DBL: add = (int)tree->gtDblCon.gtDconVal; break;
default: add = 0; break;
}
hash = genTreeHashAdd(hash, add);
goto DONE;
}
/* Is it a 'simple' unary/binary operator? */
if (kind & GTK_SMPOP)
{
GenTreePtr op1 = tree->gtOp.gtOp1;
GenTreePtr op2 = tree->gtOp.gtOp2;
unsigned hsh1;
/* Is there a second sub-operand? */
if (!op2)
{
/* Special case: no sub-operands at all */
if (!op1)
goto DONE;
/* This is a unary operator */
tree = op1;
goto AGAIN;
}
/* This is a binary operator */
hsh1 = gtHashValue(op1);
/* Special case: addition of two values */
if (oper == GT_ADD)
{
unsigned hsh2 = gtHashValue(op2);
/* Produce a hash that allows swapping the operands */
hash = genTreeHashAdd(hash, hsh1, hsh2);
goto DONE;
}
/* Add op1's hash to the running value and continue with op2 */
hash = genTreeHashAdd(hash, hsh1);
tree = op2;
goto AGAIN;
}
#if CSELENGTH
if (oper == GT_ARR_RNGCHK)
{
/* GT_ARR_LENGTH must hash to the same thing as GT_ARR_RNGCHK */
temp = tree->gtArrLen.gtArrLenAdr; assert(temp && temp->gtType == TYP_REF);
ARRLEN:
hash = genTreeHashAdd(hash, gtHashValue(temp));
goto DONE;
}
#endif
#ifdef DEBUG
gtDispTree(tree);
#endif
assert(!"unexpected operator");
DONE:
return hash;
}
/*****************************************************************************
*
* Given an arbitrary expression tree, return the set of all local variables
* referenced by the tree. If the tree contains any references that are not
* local variables or constants, returns 'VARSET_NONE'. If there are any
* indirections or global refs in the expression, the "*refsPtr" argument
* will be assigned the appropriate bit set based on the 'varRefKinds' type.
* It won't be assigned anything when there are no indirections or global
* references, though, so this value should be initialized before the call.
* If we encounter an expression that is equal to *findPtr we set *findPtr
* to NULL.
*/
VARSET_TP Compiler::lvaLclVarRefs(GenTreePtr tree,
GenTreePtr *findPtr,
unsigned *refsPtr)
{
genTreeOps oper;
unsigned kind;
VARSET_TP vars = 0;
AGAIN:
assert(tree);
assert(tree->gtOper != GT_STMT);
/* Remember whether we've come across the expression we're looking for */
if (findPtr && *findPtr == tree) *findPtr = NULL;
/* Figure out what kind of a node we have */
oper = tree->OperGet();
kind = tree->OperKind();
/* Is this a constant or leaf node? */
if (kind & (GTK_CONST|GTK_LEAF))
{
if (oper == GT_LCL_VAR)
{
unsigned lclNum;
LclVarDsc * varDsc;
assert(tree->gtOper == GT_LCL_VAR);
lclNum = tree->gtLclVar.gtLclNum;
/* Should we use the variable table? */
if (findPtr)
{
if (lclNum >= VARSET_SZ)
return VARSET_NONE;
vars |= genVarIndexToBit(lclNum);
}
else
{
assert(lclNum < lvaCount);
varDsc = lvaTable + lclNum;
if (varDsc->lvTracked == false)
return VARSET_NONE;
/* Don't deal with expressions with volatile variables */
if (varDsc->lvVolatile)
return VARSET_NONE;
vars |= genVarIndexToBit(varDsc->lvVarIndex);
}
}
else if (oper == GT_CLS_VAR)
{
*refsPtr |= VR_GLB_REF;
}
return vars;
}
/* Is it a 'simple' unary/binary operator? */
if (kind & GTK_SMPOP)
{
if (oper == GT_IND)
{
assert(tree->gtOp.gtOp2 == 0);
/* Set the proper indirection bits */
*refsPtr |= (varTypeIsGC(tree->TypeGet()) ? VR_IND_PTR
: VR_IND_SCL );
#if CSELENGTH
/* Some GT_IND have "secret" array length subtrees */
if ((tree->gtFlags & GTF_IND_RNGCHK) && tree->gtInd.gtIndLen)
{
vars |= lvaLclVarRefs(tree->gtInd.gtIndLen, findPtr, refsPtr);
if (vars == VARSET_NONE)
return vars;
}
#endif
}
if (tree->gtOp.gtOp2)
{
/* It's a binary operator */
vars |= lvaLclVarRefs(tree->gtOp.gtOp1, findPtr, refsPtr);
if (vars == VARSET_NONE)
return vars;
tree = tree->gtOp.gtOp2; assert(tree);
goto AGAIN;
}
else
{
/* It's a unary (or nilary) operator */
tree = tree->gtOp.gtOp1;
if (tree)
goto AGAIN;
return vars;
}
}
#if CSELENGTH
/* An array length value depends on the array address */
if (oper == GT_ARR_RNGCHK)
{
tree = tree->gtArrLen.gtArrLenAdr;
goto AGAIN;
}
#endif
return VARSET_NONE;
}
/*****************************************************************************/
#endif//RNGCHK_OPT || CSE
/*****************************************************************************
*
* Return a relational operator that is the reverse of the given one.
*/
/* static */
genTreeOps GenTree::ReverseRelop(genTreeOps relop)
{
static
unsigned char reverseOps[] =
{
GT_NE, // GT_EQ
GT_EQ, // GT_NE
GT_GE, // GT_LT
GT_GT, // GT_LE
GT_LT, // GT_GE
GT_LE, // GT_GT
};
assert(reverseOps[GT_EQ - GT_EQ] == GT_NE);
assert(reverseOps[GT_NE - GT_EQ] == GT_EQ);
assert(reverseOps[GT_LT - GT_EQ] == GT_GE);
assert(reverseOps[GT_LE - GT_EQ] == GT_GT);
assert(reverseOps[GT_GE - GT_EQ] == GT_LT);
assert(reverseOps[GT_GT - GT_EQ] == GT_LE);
assert(OperIsCompare(relop));
assert(relop >= GT_EQ && relop - GT_EQ < sizeof(reverseOps));
return (genTreeOps)reverseOps[relop - GT_EQ];
}
/*****************************************************************************
*
* Return a relational operator that will work for swapped operands.
*/
/* static */
genTreeOps GenTree::SwapRelop(genTreeOps relop)
{
static
unsigned char swapOps[] =
{
GT_EQ, // GT_EQ
GT_NE, // GT_NE
GT_GT, // GT_LT
GT_GE, // GT_LE
GT_LE, // GT_GE
GT_LT, // GT_GT
};
assert(swapOps[GT_EQ - GT_EQ] == GT_EQ);
assert(swapOps[GT_NE - GT_EQ] == GT_NE);
assert(swapOps[GT_LT - GT_EQ] == GT_GT);
assert(swapOps[GT_LE - GT_EQ] == GT_GE);
assert(swapOps[GT_GE - GT_EQ] == GT_LE);
assert(swapOps[GT_GT - GT_EQ] == GT_LT);
assert(OperIsCompare(relop));
assert(relop >= GT_EQ && relop - GT_EQ < sizeof(swapOps));
return (genTreeOps)swapOps[relop - GT_EQ];
}
/*****************************************************************************
*
* Reverse the meaning of the given test condition.
*/
GenTreePtr FASTCALL Compiler::gtReverseCond(GenTree * tree)
{
if (tree->OperIsCompare())
{
tree->gtOper = GenTree::ReverseRelop(tree->OperGet());
/* Flip the GTF_CMP_NAN_UN bit */
if (varTypeIsFloating(tree->gtOp.gtOp1->TypeGet()))
tree->gtFlags ^= GTF_CMP_NAN_UN;
}
else
{
tree = gtNewOperNode(GT_NOT, TYP_INT, tree);
}
return tree;
}
/*****************************************************************************
*
* If the given tree is an assignment of the form "lcl = log0(lcl)",
* returns the variable number of the local. Otherwise returns -1.
*/
#if OPT_BOOL_OPS
int GenTree::IsNotAssign()
{
if (gtOper != GT_ASG)
return -1;
GenTreePtr dst = gtOp.gtOp1;
GenTreePtr src = gtOp.gtOp2;
if (dst->gtOper != GT_LCL_VAR)
return -1;
if (src->gtOper != GT_LOG0)
return -1;
src = src->gtOp.gtOp1;
if (src->gtOper != GT_LCL_VAR)
return -1;
if (dst->gtLclVar.gtLclNum != src->gtLclVar.gtLclNum)
return -1;
return dst->gtLclVar.gtLclNum;
}
#endif
/*****************************************************************************
*
* Returns non-zero if the given tree is a 'leaf'.
*/
int GenTree::IsLeafVal()
{
unsigned kind = OperKind();
if (kind & (GTK_LEAF|GTK_CONST))
return 1;
if (kind & GTK_SMPOP)
return 1;
if (gtOper == GT_FIELD && !gtField.gtFldObj)
return 1;
return 0;
}
/*****************************************************************************
*
* Figure out the evaluation order for a list of values.
*/
unsigned Compiler::gtSetListOrder(GenTree *list)
{
GenTreePtr tree;
GenTreePtr next;
unsigned lvl;
unsigned level = 0;
#if!TGT_IA64
regMaskTP ftreg = 0;
#endif
#if TGT_x86
unsigned FPlvlSave;
#endif
assert(list && list->gtOper == GT_LIST);
#if TGT_x86
/* Save the current FP stack level since an argument list
* will implicitly pop the FP stack when pushing the argument */
FPlvlSave = genFPstkLevel;
#endif
next = list->gtOp.gtOp2;
if (next)
{
//list->gtFlags |= GTF_REVERSE_OPS;
lvl = gtSetListOrder(next);
#if!TGT_IA64
ftreg |= next->gtRsvdRegs;
#endif
if (level < lvl)
level = lvl;
}
tree = list->gtOp.gtOp1;
lvl = gtSetEvalOrder(tree);
#if TGT_x86
/* restore the FP level */
genFPstkLevel = FPlvlSave;
#endif
#if!TGT_IA64
list->gtRsvdRegs = ftreg | tree->gtRsvdRegs;
#endif
if (level < lvl)
level = lvl;
return level;
}
/*****************************************************************************
*
* Figure out the evaluation order for a list of values.
*/
#if TGT_x86
#define gtSetRArgOrder(a,m) gtSetListOrder(a)
#else
unsigned Compiler::gtSetRArgOrder(GenTree *list, unsigned regs)
{
GenTreePtr tree;
GenTreePtr next;
unsigned lvl;
regNumber reg;
unsigned level = 0;
#if!TGT_IA64
regMaskTP ftreg = 0;
#endif
assert(list && list->gtOper == GT_LIST);
next = list->gtOp.gtOp2;
if (next)
{
list->gtFlags |= GTF_REVERSE_OPS;
lvl = gtSetRArgOrder(next, regs >> 4);
#if!TGT_IA64
ftreg |= next->gtRsvdRegs;
#endif
if (level < lvl)
level = lvl;
}
/* Get hold of the argument value */
tree = list->gtOp.gtOp1;
/* Figure out which register this argument will be passed in */
reg = (regNumber)(regs & 0x0F);
// printf("RegArgOrder [reg=%s]:\n", getRegName(reg)); gtDispTree(tree);
/* Process the argument value itself */
lvl = gtSetEvalOrder(tree);
#if!TGT_IA64
list->gtRsvdRegs = ftreg | tree->gtRsvdRegs;
/* Mark the interference with the argument register */
tree->gtIntfRegs |= genRegMask(reg);
#endif
if (level < lvl)
level = lvl;
return level;
}
#endif
/*****************************************************************************
*
* Given a tree, figure out the order in which its sub-operands should be
* evaluated.
*
* Returns the 'complexity' estimate for this tree (the higher the number,
* the more expensive it is to evaluate it).
*
* #if TGT_x86
*
* We compute the "FPdepth" value for each tree, i.e. the max. number
* of operands the tree will push on the x87 (coprocessor) stack.
*
* #else
*
* We compute an estimate of the number of temporary registers each
* node will require - this is used later for register allocation.
*
* #endif
*/
unsigned Compiler::gtSetEvalOrder(GenTree * tree)
{
genTreeOps oper;
unsigned kind;
unsigned level;
unsigned lvl2;
#if!TGT_IA64
regMaskTP ftreg;
#endif
#if CSE
unsigned cost;
#endif
#if TGT_x86
int isflt;
unsigned FPlvlSave;
#endif
assert(tree);
assert(tree->gtOper != GT_STMT);
#if TGT_RISC && !TGT_IA64
tree->gtIntfRegs = 0;
#endif
/* Assume no fixed registers will be trashed */
#if!TGT_IA64
ftreg = 0;
#endif
/* Since this function can be called several times
* on a tree (e.g. after nodes have been folded)
* reset the GTF_REVERSE_OPS flag */
tree->gtFlags &= ~GTF_REVERSE_OPS;
/* Is this a FP value? */
#if TGT_x86
isflt = varTypeIsFloating(tree->TypeGet()) ? 1 : 0;
#endif
/* Figure out what kind of a node we have */
oper = tree->OperGet();
kind = tree->OperKind();
/* Is this a constant or leaf node? */
if (kind & (GTK_CONST|GTK_LEAF))
{
/*
Note that some code below depends on constants always getting
moved to be the second operand of a binary operator. This is
easily accomplished by giving constants a level of 0, which
we do on the next line. If you ever decide to change this, be
aware that unless you make other arrangements for costants to
be moved, stuff will break.
*/
level = ((kind & GTK_CONST) == 0);
#if CSE
cost = 1; // CONSIDER: something more accurate?
#endif
#if TGT_x86
genFPstkLevel += isflt;
#endif
goto DONE;
}
/* Is it a 'simple' unary/binary operator? */
if (kind & GTK_SMPOP)
{
unsigned lvlb;
GenTreePtr op1 = tree->gtOp.gtOp1;
GenTreePtr op2 = tree->gtOp.gtOp2;
/* Check for a nilary operator */
if (!op1)
{
assert(op2 == 0);
#if TGT_x86
if (oper == GT_BB_QMARK || oper == GT_BB_COLON)
genFPstkLevel += isflt;
#endif
level = 0;
#if CSE
cost = 1;
#endif
goto DONE;
}
/* Is this a unary operator? */
if (!op2)
{
/* Process the operand of the operator */
UNOP:
level = gtSetEvalOrder(op1);
#if!TGT_IA64
ftreg |= op1->gtRsvdRegs;
#endif
#if CSE
cost = op1->gtCost + 1;
#endif
/* Special handling for some operators */
switch (oper)
{
case GT_NOP:
/* Special case: array range check */
if (tree->gtFlags & GTF_NOP_RNGCHK)
level++;
break;
case GT_ADDR:
#if TGT_x86
/* If the operand was floating point pop the value from the stack */
if (varTypeIsFloating(op1->TypeGet()))
{
assert(genFPstkLevel);
genFPstkLevel--;
}
#endif
break;
case GT_IND:
/* Indirect loads of FP values push a new value on the FP stack */
#if TGT_x86
genFPstkLevel += isflt;
#endif
#if CSELENGTH
if ((tree->gtFlags & GTF_IND_RNGCHK) && tree->gtInd.gtIndLen)
{
GenTreePtr len = tree->gtInd.gtIndLen;
/* Make sure the array length gets costed */
assert(len->gtOper == GT_ARR_RNGCHK);
gtSetEvalOrder(len);
}
#endif
#if TGT_SH3
/* Is this an indirection with an index address? */
if (op1->gtOper == GT_ADD)
{
int rev;
#if SCALED_ADDR_MODES
unsigned mul;
#endif
unsigned cns;
GenTreePtr adr;
GenTreePtr idx;
if (genCreateAddrMode(op1, // address
0, // mode
false, // fold
0, // reg mask
#if!LEA_AVAILABLE
tree->TypeGet(), // operand type
#endif
&rev, // reverse ops
&adr, // base addr
&idx, // index val
#if SCALED_ADDR_MODES
&mul, // scaling
#endif
&cns, // displacement
true)) // don't generate code
{
if (adr && idx)
{
/* The address is "[adr+idx]" */
ftreg |= RBM_r00;
}
}
}
#endif
/* An indirection should always have a non-zero level *
* Only constant leaf nodes have level 0 */
if (level == 0)
level = 1;
break;
}
goto DONE;
}
/* Binary operator - check for certain special cases */
lvlb = 0;
switch (oper)
{
case GT_MOD:
case GT_UMOD:
/* Modulo by a power of 2 is easy */
if (op2->gtOper == GT_CNS_INT)
{
unsigned ival = op2->gtIntCon.gtIconVal;
if (ival > 0 && ival == genFindLowestBit(ival))
break;
}
// Fall through ...
case GT_DIV:
case GT_UDIV:
/* Non-integer division is boring */
if (!varTypeIsIntegral(tree->TypeGet()))
break;
/* Note the fact that division always uses EAX/EDX */
#if TGT_x86
ftreg |= RBM_EAX|RBM_EDX;
#if LONG_MATH_REGPARAM
// UNDONE: Be smarter about the weighing of sub-operands
if (tree->gtType == TYP_LONG)
{
ftreg |= RBM_EBX|RBM_ECX;
break;
}
#endif
#endif
/* Encourage the second operand to be evaluated first (strongly) */
lvlb += 3;
case GT_MUL:
#if TGT_x86
#if LONG_MATH_REGPARAM
// UNDONE: Be smarter about the weighing of sub-operands
if (tree->gtType == TYP_LONG)
{
/* Does the second argument trash EDX:EAX ? */
if (op2->gtRsvdRegs & (RBM_EAX|RBM_EDX))
{
/* Encourage the second operand to go first (strongly) */
lvlb += 30;
}
ftreg |= RBM_EBX|RBM_ECX;
break;
}
#endif
#endif
/* Encourage the second operand to be evaluated first (weakly) */
lvlb++;
break;
case GT_CAST:
/* Estimate the cost of the cast */
switch (tree->gtType)
{
case TYP_LONG:
#if TGT_x86
/* Cast from int to long always requires the use of EAX:EDX */
//
// UNSIGNED_ISSUE : Unsigned casting doesnt need to use EAX:EDX
//
if (op1->gtType <= TYP_INT)
{
ftreg |= RBM_EAX|RBM_EDX;
lvlb += 3;
}
#endif
break;
}
lvlb++;
break;
case GT_COMMA:
/* Comma tosses the result of the left operand */
#if TGT_x86
FPlvlSave = genFPstkLevel;
level = gtSetEvalOrder(op1);
genFPstkLevel = FPlvlSave;
#else
level = gtSetEvalOrder(op1);
#endif
goto DONE_OP1;
case GT_COLON:
#if TGT_x86
FPlvlSave = genFPstkLevel;
#endif
level = gtSetEvalOrder(op1);
#if TGT_x86
genFPstkLevel = FPlvlSave;
#endif
lvl2 = gtSetEvalOrder(op2);
if (level < lvl2)
level = lvl2;
#if!TGT_IA64
ftreg |= op1->gtRsvdRegs|op2->gtRsvdRegs;
#endif
cost = op1->gtCost + op2->gtCost + 1;
goto DONE;
case GT_IND:
/* The second operand of an indirection is just a fake */
goto UNOP;
}
/* Assignments need a bit special handling */
if (kind & GTK_ASGOP)
{
/* Process the target */
level = gtSetEvalOrder(op1);
#if TGT_x86
/* If assigning an FP value, the target won't get pushed */
if (isflt)
{
op1->gtFPlvl--;
assert(genFPstkLevel);
genFPstkLevel--;
}
#endif
goto DONE_OP1;
}
/* Process the sub-operands */
level = gtSetEvalOrder(op1);
DONE_OP1:
lvl2 = gtSetEvalOrder(op2) + lvlb;
#if!TGT_IA64
ftreg |= op1->gtRsvdRegs|op2->gtRsvdRegs;
#endif
#if CSE
cost = op1->gtCost + op2->gtCost + 1;
#endif
#if TGT_x86
if (oper == GT_CAST)
{
/* Casts between non-FP and FP push on / pop from the FP stack */
if (varTypeIsFloating(op1->TypeGet()))
{
if (isflt == false)
{
assert(genFPstkLevel);
genFPstkLevel--;
}
}
else
{
if (isflt != false)
genFPstkLevel++;
}
}
else
{
/*
Binary FP operators pop 2 operands and produce 1 result;
assignments consume 1 value and don't produce anything.
*/
if (isflt)
{
switch (oper)
{
case GT_COMMA:
break;
default:
assert(genFPstkLevel);
genFPstkLevel--;
break;
}
}
}
#endif
if (kind & GTK_ASGOP)
{
/* If this is a local var assignment, evaluate RHS before LHS */
switch (op1->gtOper)
{
case GT_IND:
if (op1->gtOp.gtOp1->gtFlags & GTF_GLOB_EFFECT)
break;
if (op2->gtOper == GT_LCL_VAR)
break;
// fall through
case GT_LCL_VAR:
tree->gtFlags |= GTF_REVERSE_OPS;
break;
}
}
#if TGT_x86
else if (kind & GTK_RELOP)
{
/* Float compares remove both operands from the FP stack
* Also FP comparison uses EAX for flags */
if (varTypeIsFloating(op1->TypeGet()))
{
assert(genFPstkLevel >= 2);
genFPstkLevel -= 2;
ftreg |= RBM_EAX;
level++;
}
}
#endif
/* Check for any 'interesting' cases */
switch (oper)
{
case GT_LSH:
case GT_RSH:
case GT_RSZ:
case GT_ASG_LSH:
case GT_ASG_RSH:
case GT_ASG_RSZ:
#if TGT_x86
/* Shifts by a non-constant amount are expensive and use ECX */
if (op2->gtOper != GT_CNS_INT)
{
level += 5;
ftreg |= RBM_ECX;
}
#endif
break;
#if INLINE_MATH
case GT_MATH:
switch (tree->gtMath.gtMathFN)
{
case MATH_FN_EXP:
level += 4;
break;
case MATH_FN_POW:
level += 3;
break;
}
break;
#endif
}
/* Is the second operand more expensive? */
if (level < lvl2)
{
/* Relative of order of global / side effects cant be swapped */
bool canSwap = true;
if (op1->gtFlags & GTF_GLOB_EFFECT)
{
/* op1 has side efects - check some special cases
* where we may be able to still swap */
if (op2->gtFlags & GTF_GLOB_EFFECT)
{
/* op2 has also side effects - can't swap */
canSwap = false;
}
else
{
/* No side effects in op2 - we can swap iff
* op1 has no way of modifying op2, i.e. through assignments of byref calls
* op2 is a constant
*/
if (op1->gtFlags & (GTF_ASG | GTF_CALL))
{
/* We have to be conservative - can swap iff op2 is constant */
if (!op2->OperIsConst())
canSwap = false;
}
}
/* We cannot swap in the presence of special side effects such as QMARK COLON */
if (op1->gtFlags & GTF_OTHER_SIDEEFF)
canSwap = false;
}
if (canSwap)
{
/* Can we swap the order by commuting the operands? */
switch (oper)
{
unsigned tmpl;
case GT_ADD:
case GT_MUL:
case GT_OR:
case GT_XOR:
case GT_AND:
/* Swap the operands */
tree->gtOp.gtOp1 = op2;
tree->gtOp.gtOp2 = op1;
/* Swap the level counts */
tmpl = level;
level = lvl2;
lvl2 = tmpl;
/* We may have to recompute FP levels */
#if TGT_x86
if (op1->gtFPlvl)
fgFPstLvlRedo = true;
#endif
break;
#if INLINING
case GT_QMARK:
case GT_COLON:
break;
#endif
case GT_COMMA:
case GT_LIST:
break;
case GT_SUB:
/* CONSIDER: Re-enable reversing "-" operands for non-FP types */
#if TGT_x86
if (!isflt)
break;
#else
if (!varTypeIsFloating(tree->TypeGet()))
break;
#endif
// Fall through ....
default:
/* Mark the operand's evaluation order to be swapped */
tree->gtFlags |= GTF_REVERSE_OPS;
/* Swap the level counts */
tmpl = level;
level = lvl2;
lvl2 = tmpl;
/* We may have to recompute FP levels */
#if TGT_x86
if (op1->gtFPlvl)
fgFPstLvlRedo = true;
#endif
break;
}
}
}
#if TGT_RISC && !TGT_IA64 /////////////////////////////////////////////////////
if (op1 && op2 && ((op1->gtFlags|op2->gtFlags) & GTF_CALL) && oper != GT_COMMA)
{
GenTreePtr x1 = op1;
GenTreePtr x2 = op2;
if (tree->gtFlags & GTF_REVERSE_OPS)
{
x1 = op2;
x2 = op1;
}
if (x2->gtFlags & GTF_CALL)
{
if (oper != GT_ASG || op1->gtOper == GT_IND)
{
#ifdef DEBUG
printf("UNDONE: Needs spill/callee-saved temp\n");
// gtDispTree(tree);
#endif
}
}
}
#endif //////////////////////////////////////////////////////////////////
/* Compute the sethi number for this binary operator */
if (level < lvl2)
{
level = lvl2;
}
else
{
if (level == lvl2)
level++;
}
goto DONE;
}
/* See what kind of a special operator we have here */
switch (oper)
{
case GT_MKREFANY:
case GT_LDOBJ:
level = gtSetEvalOrder(tree->gtLdObj.gtOp1);
#if!TGT_IA64
ftreg |= tree->gtLdObj.gtOp1->gtRsvdRegs;
#endif
#if CSE
cost = tree->gtLdObj.gtOp1->gtCost + 1;
#endif
break;
case GT_FIELD:
assert(tree->gtField.gtFldObj == 0);
level = 1;
#if CSE
cost = 1;
#endif
#if TGT_x86
genFPstkLevel += isflt;
#endif
break;
case GT_CALL:
assert(tree->gtFlags & GTF_CALL);
level = 0;
#if CSE
cost = 0; // doesn't matter, calls can't be CSE's anyway
#endif
/* Evaluate the 'this' argument, if present */
if (tree->gtCall.gtCallObjp)
{
GenTreePtr thisVal = tree->gtCall.gtCallObjp;
level = gtSetEvalOrder(thisVal);
#if!TGT_IA64
ftreg |= thisVal->gtRsvdRegs;
#endif
}
/* Evaluate the arguments, right to left */
if (tree->gtCall.gtCallArgs)
{
#if TGT_x86
FPlvlSave = genFPstkLevel;
#endif
lvl2 = gtSetListOrder(tree->gtCall.gtCallArgs);
#if!TGT_IA64
ftreg |= tree->gtCall.gtCallArgs->gtRsvdRegs;
#endif
if (level < lvl2)
level = lvl2;
#if TGT_x86
genFPstkLevel = FPlvlSave;
#endif
}
#if USE_FASTCALL
/* Evaluate the temp register arguments list
* This is a "hidden" list and its only purpose is to
* extend the life of temps until we make the call */
if (tree->gtCall.gtCallRegArgs)
{
#if TGT_x86
FPlvlSave = genFPstkLevel;
#endif
lvl2 = gtSetRArgOrder(tree->gtCall.gtCallRegArgs,
tree->gtCall.regArgEncode);
#if!TGT_IA64
ftreg |= tree->gtCall.gtCallRegArgs->gtRsvdRegs;
#endif
if (level < lvl2)
level = lvl2;
#if TGT_x86
genFPstkLevel = FPlvlSave;
#endif
}
#endif
/* Evaluate the vtable pointer, if present */
if (tree->gtCall.gtCallVptr)
{
lvl2 = gtSetEvalOrder(tree->gtCall.gtCallVptr);
#if!TGT_IA64
ftreg |= tree->gtCall.gtCallVptr->gtRsvdRegs;
#endif
if (level < lvl2)
level = lvl2;
}
if (tree->gtCall.gtCallType == CT_INDIRECT)
{
GenTreePtr indirect = tree->gtCall.gtCallAddr;
level = gtSetEvalOrder(indirect);
#if!TGT_IA64
ftreg |= indirect->gtRsvdRegs;
#endif
if (level < lvl2)
level = lvl2;
}
/* Function calls are quite expensive unless regs are preserved */
if (tree->gtFlags & GTF_CALL_REGSAVE)
{
level += 1;
}
else
{
level += 10; // ISSUE: is '10' a good value?
#if!TGT_IA64
ftreg |= RBM_CALLEE_TRASH;
#endif
}
#if TGT_x86
genFPstkLevel += isflt;
#endif
break;
case GT_JMP:
level = 0;
break;
case GT_JMPI:
level = gtSetEvalOrder(tree->gtOp.gtOp1);
#if!TGT_IA64
ftreg |= tree->gtOp.gtOp1->gtRsvdRegs;
#endif
#if CSE
cost = tree->gtOp.gtOp1->gtCost + 1;
#endif
break;
#if CSELENGTH
case GT_ARR_RNGCHK:
{
GenTreePtr addr = tree->gtArrLen.gtArrLenAdr; assert(addr);
/* Has the address already been costed? */
if (tree->gtFlags & GTF_ALN_CSEVAL)
level = gtSetEvalOrder(addr) + 1;
else
level = 1;
#if!TGT_IA64
ftreg |= addr->gtRsvdRegs;
#endif
cost = addr->gtCost + 1;
}
break;
#endif
default:
#ifdef DEBUG
gtDispTree(tree);
#endif
assert(!"unexpected operator");
}
DONE:
#if TGT_x86
// printf("[FPlvl=%2u] ", genFPstkLevel); gtDispTree(tree, 0, true);
assert((int)genFPstkLevel >= 0);
tree->gtFPlvl = genFPstkLevel;
#endif
#if!TGT_IA64
tree->gtRsvdRegs = ftreg;
#endif
#if CSE
tree->gtCost = (cost > MAX_COST) ? MAX_COST : cost;
#endif
#if 0
#ifdef DEBUG
printf("ftregs=%04X ", ftreg);
gtDispTree(tree, 0, true);
#endif
#endif
return level;
}
/*****************************************************************************
*
* Returns non-zero if the given tree is an integer constant that can be used
* in a scaled index address mode as a multiplier (e.g. "[4*index]").
*/
unsigned GenTree::IsScaleIndexMul()
{
if (gtOper == GT_CNS_INT)
{
switch (gtIntCon.gtIconVal)
{
case 1:
case 2:
case 4:
case 8:
return gtIntCon.gtIconVal;
}
}
return 0;
}
/*****************************************************************************
*
* Returns non-zero if the given tree is an integer constant that can be used
* in a scaled index address mode as a multiplier (e.g. "[4*index]").
*/
unsigned GenTree::IsScaleIndexShf()
{
if (gtOper == GT_CNS_INT)
{
if (gtIntCon.gtIconVal > 0 &&
gtIntCon.gtIconVal < 4)
{
return 1 << gtIntCon.gtIconVal;
}
}
return 0;
}
/*****************************************************************************
*
* If the given tree is a scaled index (i.e. "op * 4" or "op << 2"), returns
* the multiplier (and in that case also makes sure the scaling constant is
* the second sub-operand of the tree); otherwise returns 0.
*/
unsigned GenTree::IsScaledIndex()
{
GenTreePtr scale;
switch (gtOper)
{
case GT_MUL:
scale = gtOp.gtOp2;
if (scale->IsScaleIndexMul())
return scale->gtIntCon.gtIconVal;
break;
case GT_LSH:
scale = gtOp.gtOp2;
if (scale->IsScaleIndexShf())
return 1 << scale->gtIntCon.gtIconVal;
break;
}
return 0;
}
#ifndef FAST
GenTreePtr FASTCALL Compiler::gtNewNode(genTreeOps oper, varType_t type)
{
#if SMALL_TREE_NODES
size_t size = GenTree::s_gtNodeSizes[oper];
#else
size_t size = sizeof(*node);
#endif
GenTreePtr node = (GenTreePtr)compGetMem(size);
#ifdef DEBUG
// if ((int)node == 0x02bc0a68) debugStop(0);
#endif
#if MEASURE_NODE_SIZE
genNodeSizeStats.genTreeNodeCnt += 1;
genNodeSizeStats.genTreeNodeSize += size;
#endif
#ifdef DEBUG
memset(node, 0xDD, size);
#endif
node->gtOper = oper;
node->gtType = type;
node->gtFlags = 0;
#if TGT_x86
node->gtUsedRegs = 0;
#endif
node->gtNext = 0;
#ifndef NDEBUG
#if SMALL_TREE_NODES
if (size == TREE_NODE_SZ_SMALL)
{
node->gtFlags |= GTF_NODE_SMALL;
}
else if (size == TREE_NODE_SZ_LARGE)
{
node->gtFlags |= GTF_NODE_LARGE;
}
else
assert(!"bogus node size");
#endif
#endif
return node;
}
#endif
GenTreePtr FASTCALL Compiler::gtNewOperNode(genTreeOps oper,
varType_t type, GenTreePtr op1,
GenTreePtr op2)
{
GenTreePtr node = gtNewNode(oper, type);
node->gtOp.gtOp1 = op1;
node->gtOp.gtOp2 = op2;
if (op1) node->gtFlags |= op1->gtFlags & GTF_GLOB_EFFECT;
if (op2) node->gtFlags |= op2->gtFlags & GTF_GLOB_EFFECT;
return node;
}
GenTreePtr FASTCALL Compiler::gtNewIconNode(long value, varType_t type)
{
GenTreePtr node = gtNewNode(GT_CNS_INT, type);
node->gtIntCon.gtIconVal = value;
return node;
}
GenTreePtr FASTCALL Compiler::gtNewFconNode(float value)
{
GenTreePtr node = gtNewNode(GT_CNS_FLT, TYP_FLOAT);
node->gtFltCon.gtFconVal = value;
return node;
}
/*****************************************************************************
*
* Allocates a integer constant entry that represents a HANDLE to something.
* It may not be allowed to embed HANDLEs directly into the JITed code (for eg,
* as arguments to JIT helpers). Get a corresponding value that can be embedded.
* If the handle needs to be accessed via an indirection, pValue points to it.
*/
GenTreePtr Compiler::gtNewIconEmbHndNode(void * value,
void * pValue,
unsigned flags,
unsigned handle1,
void * handle2)
{
GenTreePtr node;
assert((!value) != (!pValue));
if (value)
{
node = gtNewIconHandleNode((long)value, flags, handle1, handle2);
}
else
{
node = gtNewIconHandleNode((long)pValue, flags, handle1, handle2);
node->gtFlags |= GTF_NON_GC_ADDR;
node = gtNewOperNode(GT_IND, TYP_I_IMPL, node);
}
return node;
}
/*****************************************************************************/
GenTreePtr FASTCALL Compiler::gtNewLconNode(__int64 *value)
{
GenTreePtr node = gtNewNode(GT_CNS_LNG, TYP_LONG);
node->gtLngCon.gtLconVal = *value;
return node;
}
GenTreePtr FASTCALL Compiler::gtNewDconNode(double *value)
{
GenTreePtr node = gtNewNode(GT_CNS_DBL, TYP_DOUBLE);
node->gtDblCon.gtDconVal = *value;
return node;
}
GenTreePtr Compiler::gtNewSconNode(int CPX, SCOPE_HANDLE scpHandle)
{
#if SMALL_TREE_NODES
/* 'GT_CNS_STR' nodes later get transformed into 'GT_CALL' */
assert(GenTree::s_gtNodeSizes[GT_CALL] > GenTree::s_gtNodeSizes[GT_CNS_STR]);
GenTreePtr node = gtNewNode(GT_CALL, TYP_REF);
node->ChangeOper(GT_CNS_STR);
#else
GenTreePtr node = gtNewNode(GT_CNS_STR, TYP_REF);
#endif
node->gtStrCon.gtSconCPX = CPX;
/* Because this node can come from an inlined method we need to
* have the scope handle since it will become a helper call */
node->gtStrCon.gtScpHnd = scpHandle;
return node;
}
GenTreePtr Compiler::gtNewZeroConNode(var_types type)
{
static __int64 lzero = 0;
static double dzero = 0.0;
switch(type)
{
GenTreePtr zero;
case TYP_INT: return gtNewIconNode(0);
case TYP_BYREF:
case TYP_REF: zero = gtNewIconNode(0);
zero->gtType = type;
return zero;
case TYP_LONG: return gtNewLconNode(&lzero);
case TYP_FLOAT: return gtNewFconNode(0.0);
case TYP_DOUBLE: return gtNewDconNode(&dzero);
default: assert(!"Bad type");
return NULL;
}
}
GenTreePtr Compiler::gtNewCallNode(gtCallTypes callType,
METHOD_HANDLE callHnd,
varType_t type,
unsigned flags,
GenTreePtr args)
{
GenTreePtr node = gtNewNode(GT_CALL, type);
node->gtFlags |= GTF_CALL|flags;
node->gtCall.gtCallType = callType;
node->gtCall.gtCallMethHnd = callHnd;
node->gtCall.gtCallArgs = args;
node->gtCall.gtCallObjp =
node->gtCall.gtCallVptr = 0;
node->gtCall.gtCallMoreFlags = 0;
node->gtCall.gtCallCookie = 0;
#if USE_FASTCALL
node->gtCall.gtCallRegArgs = 0;
#endif
return node;
}
GenTreePtr FASTCALL Compiler::gtNewLclvNode(unsigned lnum,
varType_t type,
unsigned offs)
{
GenTreePtr node = gtNewNode(GT_LCL_VAR, type);
/* Cannot have this assert because the inliner uses this function
* to add temporaries */
//assert(lnum < lvaCount);
node->gtLclVar.gtLclNum = lnum;
node->gtLclVar.gtLclOffs = offs;
return node;
}
#if INLINING
GenTreePtr FASTCALL Compiler::gtNewLclLNode(unsigned lnum,
varType_t type,
unsigned offs)
{
GenTreePtr node;
#if SMALL_TREE_NODES
/* This local variable node may later get transformed into a large node */
assert(GenTree::s_gtNodeSizes[GT_CALL] > GenTree::s_gtNodeSizes[GT_LCL_VAR]);
node = gtNewNode(GT_CALL , type);
node->ChangeOper(GT_LCL_VAR);
#else
node = gtNewNode(GT_LCL_VAR, type);
#endif
node->gtLclVar.gtLclNum = lnum;
node->gtLclVar.gtLclOffs = offs;
return node;
}
#endif
/*****************************************************************************
*
* Create a list out of one value.
*/
GenTreePtr Compiler::gtNewArgList(GenTreePtr op)
{
return gtNewOperNode(GT_LIST, TYP_VOID, op, 0);
}
/*****************************************************************************
*
* Create a list out of the two values.
*/
GenTreePtr Compiler::gtNewArgList(GenTreePtr op1, GenTreePtr op2)
{
GenTreePtr tree;
tree = gtNewOperNode(GT_LIST, TYP_VOID, op2, 0);
tree = gtNewOperNode(GT_LIST, TYP_VOID, op1, tree);
return tree;
}
/*****************************************************************************
*
* Create a node that will assign 'src' to 'dst'.
*/
GenTreePtr FASTCALL Compiler::gtNewAssignNode(GenTreePtr dst, GenTreePtr src)
{
GenTreePtr asg;
/* Mark the target as being assigned */
if (dst->gtOper == GT_LCL_VAR) dst->gtFlags |= GTF_VAR_DEF;
/* Create the assignment node */
asg = gtNewOperNode(GT_ASG, dst->gtType, dst, src);
/* Mark the expression as containing an assignment */
asg->gtFlags |= GTF_ASG;
return asg;
}
/*****************************************************************************
*
* Clones the given tree value and returns a copy of the given tree. If the
* value of 'complexOK' is zero, the cloning is only done provided the tree
* is not too complex (whatever that may mean); if it is too complex, 0 is
* returned.
*
* Note that there is the fucntion gcCloneExpr which does a more complete
* job if you can't handle this funciton failing.
*/
GenTreePtr Compiler::gtClone(GenTree * tree, bool complexOK)
{
switch (tree->gtOper)
{
case GT_CNS_INT:
#if defined(JIT_AS_COMPILER) || defined (LATE_DISASM)
if (tree->gtFlags & GTF_ICON_HDL_MASK)
return gtNewIconHandleNode(tree->gtIntCon.gtIconVal,
tree->gtFlags,
tree->gtIntCon.gtIconHdl.gtIconHdl1,
tree->gtIntCon.gtIconHdl.gtIconHdl2);
else
#endif
return gtNewIconNode(tree->gtIntCon.gtIconVal, tree->gtType);
case GT_LCL_VAR:
return gtNewLclvNode(tree->gtLclVar.gtLclNum , tree->gtType,
tree->gtLclVar.gtLclOffs);
case GT_CLS_VAR:
return gtNewClsvNode(tree->gtClsVar.gtClsVarHnd, tree->gtType);
case GT_REG_VAR:
assert(!"clone regvar");
default:
if (complexOK)
{
if (tree->gtOper == GT_FIELD)
{
GenTreePtr copy;
GenTreePtr objp;
// copied from line 9850
objp = 0;
if (tree->gtField.gtFldObj)
{
objp = gtClone(tree->gtField.gtFldObj, false);
if (!objp)
return objp;
}
copy = gtNewFieldRef(tree->TypeGet(),
tree->gtField.gtFldHnd,
objp);
#if HOIST_THIS_FLDS
copy->gtField.gtFldHTX = tree->gtField.gtFldHTX;
#endif
copy->gtFlags = tree->gtFlags;
return copy;
}
else if (tree->gtOper == GT_ADD)
{
GenTreePtr op1 = tree->gtOp.gtOp1;
GenTreePtr op2 = tree->gtOp.gtOp2;
if (op1->OperIsLeaf() &&
op2->OperIsLeaf())
{
GenTreePtr clone = gtNewOperNode(GT_ADD,
tree->TypeGet(),
gtClone(op1),
gtClone(op2));
clone->gtFlags |= (tree->gtFlags &
(GTF_OVERFLOW|GTF_EXCEPT|GTF_UNSIGNED));
return clone;
}
}
else if (tree->gtOper == GT_ADDR)
{
GenTreePtr op1 = gtClone(tree->gtOp.gtOp1);
if (op1 == 0)
return 0;
GenTreePtr clone = gtNewOperNode(GT_ADDR, tree->TypeGet(), op1);
clone->gtFlags |= (tree->gtFlags &
(GTF_OVERFLOW|GTF_EXCEPT|GTF_UNSIGNED));
return clone;
}
}
break;
}
return 0;
}
/*****************************************************************************
*
* Clones the given tree value and returns a copy of the given tree. Any
* references to local variable varNum will be replaced with the integer
* constant varVal. If the expression cannot be cloned, 0 is returned.
*/
GenTreePtr Compiler::gtCloneExpr(GenTree * tree,
unsigned addFlags,
unsigned varNum,
long varVal)
{
genTreeOps oper;
unsigned kind;
GenTree * copy;
/* Figure out what kind of a node we have */
oper = tree->OperGet();
kind = tree->OperKind();
/* Is this a constant or leaf node? */
if (kind & (GTK_CONST|GTK_LEAF))
{
switch (tree->gtOper)
{
case GT_CNS_INT:
#if defined(JIT_AS_COMPILER) || defined (LATE_DISASM)
if (tree->gtFlags & GTF_ICON_HDL_MASK)
{
copy = gtNewIconHandleNode(tree->gtIntCon.gtIconVal,
tree->gtFlags,
tree->gtIntCon.gtIconCPX,
tree->gtIntCon.gtIconCls);
}
else
#endif
{
copy = gtNewIconNode (tree->gtIntCon.gtIconVal,
tree->gtType);
}
goto DONE;
case GT_CNS_LNG:
copy = gtNewLconNode(&tree->gtLngCon.gtLconVal);
goto DONE;
case GT_CNS_FLT:
copy = gtNewFconNode( tree->gtFltCon.gtFconVal);
goto DONE;
case GT_CNS_DBL:
copy = gtNewDconNode(&tree->gtDblCon.gtDconVal);
goto DONE;
case GT_CNS_STR:
copy = gtNewSconNode(tree->gtStrCon.gtSconCPX, tree->gtStrCon.gtScpHnd);
goto DONE;
case GT_LCL_VAR:
if (tree->gtLclVar.gtLclNum == varNum)
copy = gtNewIconNode(varVal, tree->gtType);
else
copy = gtNewLclvNode(tree->gtLclVar.gtLclNum , tree->gtType,
tree->gtLclVar.gtLclOffs);
goto DONE;
case GT_CLS_VAR:
copy = gtNewClsvNode(tree->gtClsVar.gtClsVarHnd, tree->gtType);
goto DONE;
case GT_REG_VAR:
assert(!"regvar should never occur here");
default:
assert(!"unexpected leaf/const");
}
}
/* Is it a 'simple' unary/binary operator? */
if (kind & GTK_SMPOP)
{
/* If necessary, make sure we allocate a "fat" tree node */
#if SMALL_TREE_NODES
switch (oper)
{
case GT_MUL:
case GT_DIV:
case GT_MOD:
case GT_CAST:
case GT_INDEX:
case GT_UDIV:
case GT_UMOD:
/* These nodes sometimes get bashed to "fat" ones */
copy = gtNewOperNode(GT_CALL, tree->TypeGet());
copy->ChangeOper(oper);
break;
default:
copy = gtNewOperNode(oper, tree->TypeGet());
break;
}
#else
copy = gtNewOperNode(oper, tree->TypeGet());
#endif
/* Some unary/binary nodes have extra fields */
switch (oper)
{
#if INLINE_MATH
case GT_MATH:
copy->gtMath.gtMathFN = tree->gtMath.gtMathFN;
break;
#endif
case GT_IND:
copy->gtInd.gtIndex = tree->gtInd.gtIndex;
#if CSELENGTH
copy->gtInd.gtIndLen = tree->gtInd.gtIndLen;
#endif
copy->gtInd.gtStkDepth = tree->gtInd.gtStkDepth;
#if CSELENGTH
if (tree->gtOper == GT_IND && tree->gtInd.gtIndLen)
{
if (tree->gtFlags & GTF_IND_RNGCHK)
{
GenTreePtr len = tree->gtInd.gtIndLen;
GenTreePtr tmp;
GenTreePtr gtSaveCopyVal;
GenTreePtr gtSaveCopyNew;
/* Make sure the array length value looks reasonable */
assert(len->gtOper == GT_ARR_RNGCHK);
/* Clone the array length subtree */
copy->gtInd.gtIndLen = tmp = gtCloneExpr(len, addFlags, varNum, varVal);
/*
When we clone the operand, we take care to find
the copied array address.
*/
gtSaveCopyVal = gtCopyAddrVal;
gtSaveCopyNew = gtCopyAddrNew;
gtCopyAddrVal = len->gtArrLen.gtArrLenAdr;
#ifndef NDEBUG
gtCopyAddrNew = (GenTreePtr)-1;
#endif
copy->gtOp.gtOp1 = gtCloneExpr(tree->gtOp.gtOp1, addFlags, varNum, varVal);
#ifndef NDEBUG
assert(gtCopyAddrNew != (GenTreePtr)-1);
#endif
tmp->gtArrLen.gtArrLenAdr = gtCopyAddrNew;
gtCopyAddrVal = gtSaveCopyVal;
gtCopyAddrNew = gtSaveCopyNew;
#if 0
{
unsigned svf = copy->gtFlags;
copy->gtFlags = tree->gtFlags;
printf("Copy %08X to %08X\n", tree, copy);
gtDispTree(tree);
printf("\n");
gtDispTree(copy);
printf("\n");
gtDispTree(len->gtArrLen.gtArrLenAdr);
printf("\n");
gtDispTree(tmp->gtArrLen.gtArrLenAdr);
printf("\n\n");
copy->gtFlags = svf;
}
#endif
goto DONE;
}
}
#endif // CSELENGTH
break;
}
if (tree->gtOp.gtOp1) copy->gtOp.gtOp1 = gtCloneExpr(tree->gtOp.gtOp1, addFlags, varNum, varVal);
if (tree->gtOp.gtOp2) copy->gtOp.gtOp2 = gtCloneExpr(tree->gtOp.gtOp2, addFlags, varNum, varVal);
/* HACK: Poor man's constant folder */
if (copy->gtOp.gtOp1 && copy->gtOp.gtOp1->gtOper == GT_CNS_INT &&
copy->gtOp.gtOp2 && copy->gtOp.gtOp2->gtOper == GT_CNS_INT)
{
long v1 = copy->gtOp.gtOp1->gtIntCon.gtIconVal;
long v2 = copy->gtOp.gtOp2->gtIntCon.gtIconVal;
switch (oper)
{
case GT_ADD: v1 += v2; break;
case GT_SUB: v1 -= v2; break;
case GT_MUL: v1 *= v2; break;
default:
goto DONE;
}
copy->gtOper = GT_CNS_INT;
copy->gtIntCon.gtIconVal = v1;
}
goto DONE;
}
/* See what kind of a special operator we have here */
switch (oper)
{
case GT_STMT:
copy = gtCloneExpr(tree->gtStmt.gtStmtExpr, addFlags, varNum, varVal);
copy = gtNewStmt(copy, tree->gtStmtILoffs);
goto DONE;
case GT_CALL:
copy = gtNewOperNode(oper, tree->TypeGet());
copy->gtCall.gtCallObjp = tree->gtCall.gtCallObjp ? gtCloneExpr(tree->gtCall.gtCallObjp, addFlags, varNum, varVal) : 0;
copy->gtCall.gtCallVptr = tree->gtCall.gtCallVptr ? gtCloneExpr(tree->gtCall.gtCallVptr, addFlags, varNum, varVal) : 0;
copy->gtCall.gtCallArgs = tree->gtCall.gtCallArgs ? gtCloneExpr(tree->gtCall.gtCallArgs, addFlags, varNum, varVal) : 0;
copy->gtCall.gtCallMoreFlags = tree->gtCall.gtCallMoreFlags;
#if USE_FASTCALL
copy->gtCall.gtCallRegArgs = tree->gtCall.gtCallRegArgs ? gtCloneExpr(tree->gtCall.gtCallRegArgs, addFlags, varNum, varVal) : 0;
copy->gtCall.regArgEncode = tree->gtCall.regArgEncode;
#endif
copy->gtCall.gtCallType = tree->gtCall.gtCallType;
copy->gtCall.gtCallCookie = tree->gtCall.gtCallCookie;
/* Copy all of the union */
copy->gtCall.gtCallMethHnd = tree->gtCall.gtCallMethHnd;
copy->gtCall.gtCallAddr = tree->gtCall.gtCallAddr;
goto DONE;
case GT_MKREFANY:
case GT_LDOBJ:
copy = gtNewOperNode(oper, TYP_STRUCT);
copy->gtLdObj.gtClass = tree->gtLdObj.gtClass;
copy->gtLdObj.gtOp1 = gtCloneExpr(tree->gtLdObj.gtOp1, addFlags, varNum, varVal);
goto DONE;
case GT_FIELD:
copy = gtNewFieldRef(tree->TypeGet(),
tree->gtField.gtFldHnd,
0);
copy->gtField.gtFldObj = tree->gtField.gtFldObj ? gtCloneExpr(tree->gtField.gtFldObj , addFlags, varNum, varVal) : 0;
#if HOIST_THIS_FLDS
copy->gtField.gtFldHTX = tree->gtField.gtFldHTX;
#endif
goto DONE;
#if CSELENGTH
case GT_ARR_RNGCHK:
copy = gtNewOperNode(oper, tree->TypeGet());
/*
Note: if we're being cloned as part of an GT_IND expression,
gtArrLenAdr will be filled in when the GT_IND is cloned. If
we're the root of the tree being copied, though, we need to
make a copy of the address expression.
*/
copy->gtArrLen.gtArrLenCse = tree->gtArrLen.gtArrLenCse ? gtCloneExpr(tree->gtArrLen.gtArrLenCse, addFlags, varNum, varVal) : 0;
copy->gtArrLen.gtArrLenAdr = NULL;
if (tree->gtFlags & GTF_ALN_CSEVAL)
{
assert(tree->gtArrLen.gtArrLenAdr);
copy->gtArrLen.gtArrLenAdr = gtCloneExpr(tree->gtArrLen.gtArrLenAdr, addFlags, varNum, varVal);
}
goto DONE;
#endif
default:
#ifdef DEBUG
gtDispTree(tree);
#endif
assert(!"unexpected operator");
}
DONE:
/* We assume the FP stack level will be identical */
#if TGT_x86
copy->gtFPlvl = tree->gtFPlvl;
#endif
/* Compute the flags for the copied node */
addFlags |= tree->gtFlags;
/* Make sure we preserve the node size flags */
#ifdef DEBUG
addFlags &= ~GTF_PRESERVE;
addFlags |= GTF_PRESERVE & copy->gtFlags;
#endif
copy->gtFlags = addFlags;
#if CSELENGTH
if (tree == gtCopyAddrVal)
gtCopyAddrNew = copy;
#endif
/* Make sure to copy back fields that may have been initialized */
copy->gtCost = tree->gtCost;
#if!TGT_IA64
copy->gtRsvdRegs = tree->gtRsvdRegs;
#endif
return copy;
}
/*****************************************************************************/
#ifdef DEBUG
/*****************************************************************************/
// "tree" may be NULL.
void Compiler::gtDispNode(GenTree * tree,
unsigned indent,
const char * name,
bool terse)
{
/* Indent the node accordingly */
if (indent)
printf("%*c ", 1+indent*3, ' ');
else if (!terse)
printf(">>");
/* Print the node address */
printf("[%08X] ", tree);
if (tree)
{
/* Print the flags associated with the node */
if (terse)
{
switch (tree->gtOper)
{
case GT_LCL_VAR:
case GT_REG_VAR:
printf("%c", (tree->gtFlags & GTF_VAR_DEF ) ? 'D' : ' ');
printf("%c", (tree->gtFlags & GTF_VAR_USE ) ? 'U' : ' ');
printf("%c", (tree->gtFlags & GTF_VAR_USEDEF ) ? 'b' : ' ');
printf(" ");
break;
default:
printf(" ");
break;
}
}
else
{
switch (tree->gtOper)
{
case GT_LCL_VAR:
case GT_REG_VAR:
printf("%c", (tree->gtFlags & GTF_VAR_DEF ) ? 'D' : ' ');
printf("%c", (tree->gtFlags & GTF_VAR_USE ) ? 'U' : ' ');
break;
default:
printf(" ");
break;
}
printf("%c", (tree->gtFlags & GTF_REVERSE_OPS ) ? 'R' : ' ');
printf("%c", (tree->gtFlags & GTF_ASG ) ? 'A' : ' ');
printf("%c", (tree->gtFlags & GTF_CALL ) ? 'C' : ' ');
printf("%c", (tree->gtFlags & GTF_EXCEPT ) ? 'X' : ' ');
printf("%c", (tree->gtFlags & GTF_GLOB_REF ) ? 'G' : ' ');
printf("%c", (tree->gtFlags & GTF_OTHER_SIDEEFF ) ? 'O' : ' ');
printf("%c", (tree->gtFlags & GTF_DONT_CSE ) ? 'N' : ' ');
printf(" ");
}
/* print the type of the node */
printf("%-6s ", varTypeName(tree->TypeGet()));
#if TGT_x86
if ((BYTE)tree->gtFPlvl == 0xDD)
printf(" ");
else
printf("FP=%u ", tree->gtFPlvl);
#else
if (!terse)
{
if ((unsigned char)tree->gtTempRegs == 0xDD)
printf(" ");
else
printf("T=%u ", tree->gtTempRegs);
}
#endif
// printf("RR="); dspRegMask(tree->gtRsvdRegs);
#if 0
// for tracking down problems in reguse prediction or liveness tracking
if (verbose)
{
dspRegMask(tree->gtUsedRegs);
printf(" liveset %s ", genVS2str(tree->gtLiveSet));
}
#endif
if (!terse)
{
if (tree->gtFlags & GTF_REG_VAL)
{
#if TGT_x86
if (tree->gtType == TYP_LONG)
printf("%s ", compRegPairName(tree->gtRegPair));
else
#endif
printf("%s ", compRegVarName(tree->gtRegNum));
}
}
}
/* print the node name */
assert(tree || name);
if (!name)
{
name = (tree->gtOper < GT_COUNT) ? GenTree::NodeName(tree->OperGet()) : "<ERROR>";
}
printf("%6s%3s ", name, tree->gtOverflowEx() ? "ovf" : "");
assert(tree == 0 || tree->gtOper < GT_COUNT);
}
/*****************************************************************************/
#ifdef DEBUG
const char * Compiler::findVarName(unsigned varNum, BasicBlock * block)
{
if (info.compLocalVarsCount <= 0 || !block)
return NULL;
unsigned blkBeg = block->bbCodeOffs;
unsigned blkEnd = block->bbCodeSize + blkBeg;
unsigned i;
LocalVarDsc * t;
#if RET_64BIT_AS_STRUCTS
/* Adjust the variable number if it follows secret arg */
if (fgRetArgUse)
{
if (varNum == fgRetArgNum)
break;
if (varNum > fgRetArgNum)
varNum--;
}
#endif
if ((int)info.compLocalVars == 0xDDDDDDDD) return NULL; // why is this needed?????
for (i = 0, t = info.compLocalVars;
i < info.compLocalVarsCount;
i++ , t++)
{
if (t->lvdVarNum != varNum)
continue;
if (t->lvdLifeBeg >= blkEnd)
continue;
if (t->lvdLifeEnd <= blkBeg)
continue;
return lvdNAMEstr(t->lvdName);
}
return NULL;
}
#endif
/*****************************************************************************/
void Compiler::gtDispTree(GenTree * tree,
unsigned indent,
bool topOnly)
{
unsigned kind;
if (tree == 0)
{
printf("%*c [%08X] <NULL>\n", 1+indent*3, ' ', tree);
fflush(stdout);
return;
}
assert((int)tree != 0xDDDDDDDD); /* Value used to initalize nodes */
if (tree->gtOper >= GT_COUNT)
{
gtDispNode(tree, indent, NULL, topOnly); assert(!"bogus operator");
}
kind = tree->OperKind();
/* Is tree a constant node? */
if (kind & GTK_CONST)
{
gtDispNode(tree, indent, NULL, topOnly);
switch (tree->gtOper)
{
case GT_CNS_INT: printf(" %ld" , tree->gtIntCon.gtIconVal); break;
case GT_CNS_LNG: printf(" %I64d" , tree->gtLngCon.gtLconVal); break;
case GT_CNS_FLT: printf(" %f" , tree->gtFltCon.gtFconVal); break;
case GT_CNS_DBL: printf(" %lf" , tree->gtDblCon.gtDconVal); break;
case GT_CNS_STR:
const char * str;
if (str = eeGetCPString(tree->gtStrCon.gtSconCPX))
printf("'%s'", str);
else
printf("<cannot get string constant>");
break;
default: assert(!"unexpected constant node");
}
printf("\n");
fflush(stdout);
return;
}
/* Is tree a leaf node? */
if (kind & GTK_LEAF)
{
gtDispNode(tree, indent, NULL, topOnly);
switch (tree->gtOper)
{
unsigned varNum;
const char * varNam;
case GT_LCL_VAR:
varNum = tree->gtLclVar.gtLclNum;
printf("#%u", varNum);
varNam = compCurBB ? findVarName(varNum, compCurBB) : NULL;
if (varNam)
printf(" '%s'", varNam);
break;
case GT_REG_VAR:
printf("#%u reg=" , tree->gtRegVar.gtRegVar);
if (tree->gtType == TYP_DOUBLE)
printf("ST(%u)", tree->gtRegVar.gtRegNum);
else
printf("%s", compRegVarName(tree->gtRegVar.gtRegNum));
#ifdef DEBUG
if (info.compLocalVarsCount>0 && compCurBB)
{
unsigned blkBeg = compCurBB->bbCodeOffs;
unsigned blkEnd = compCurBB->bbCodeSize + blkBeg;
unsigned i;
LocalVarDsc * t;
for (i = 0, t = info.compLocalVars;
i < info.compLocalVarsCount;
i++ , t++)
{
if (t->lvdVarNum != tree->gtRegVar.gtRegVar)
continue;
if (t->lvdLifeBeg > blkEnd)
continue;
if (t->lvdLifeEnd <= blkBeg)
continue;
printf(" '%s'", lvdNAMEstr(t->lvdName));
break;
}
}
#endif
break;
case GT_CLS_VAR:
printf("Hnd=%#x" , tree->gtClsVar.gtClsVarHnd);
break;
case GT_LABEL:
printf("dst=%u" , tree->gtLabel.gtLabBB->bbNum);
break;
case GT_FTN_ADDR:
printf("fntAddr=%d" , tree->gtVal.gtVal1);
break;
// Vanilla leaves. No qualifying information available. So do nothing
case GT_NO_OP:
case GT_RET_ADDR:
case GT_CATCH_ARG:
case GT_POP:
#if OPTIMIZE_QMARK
case GT_BB_QMARK:
#endif
break;
default:
assert(!"don't know how to display tree leaf node");
}
printf("\n");
fflush(stdout);
return;
}
/* Is it a 'simple' unary/binary operator? */
if (kind & GTK_SMPOP)
{
if (tree->gtOp.gtOp2 && !topOnly)
gtDispTree(tree->gtOp.gtOp2, indent + 1);
#if CSELENGTH
if (tree->gtOper == GT_IND && tree->gtInd.gtIndLen && !topOnly)
{
if (tree->gtFlags & GTF_IND_RNGCHK)
{
GenTreePtr len = tree->gtInd.gtIndLen;
/* Prevent recursive death */
if (!(len->gtFlags & GTF_CC_SET))
{
len->gtFlags |= GTF_CC_SET;
gtDispTree(len, indent + 1);
len->gtFlags &= ~GTF_CC_SET;
}
}
}
#endif
gtDispNode(tree, indent, NULL, topOnly);
#if CSELENGTH || RNGCHK_OPT
if (tree->gtOper == GT_IND)
{
int temp;
temp = tree->gtInd.gtIndex;
if (temp != 0xDDDDDDDD) printf(" indx=%u", temp);
temp = tree->gtInd.gtStkDepth;
if (temp != 0xDDDDDDDD) printf(" stkDepth=%u", temp);
}
#endif
printf("\n");
if (tree->gtOp.gtOp1 && !topOnly)
gtDispTree(tree->gtOp.gtOp1, indent + 1);
fflush(stdout);
return;
}
/* See what kind of a special operator we have here */
switch (tree->gtOper)
{
case GT_MKREFANY:
case GT_LDOBJ:
gtDispNode(tree, indent, NULL, topOnly);
printf("\n");
if (tree->gtOp.gtOp1 && !topOnly)
gtDispTree(tree->gtOp.gtOp1, indent + 1);
fflush(stdout);
return;
case GT_FIELD:
gtDispNode(tree, indent, NULL, topOnly);
#ifdef NOT_JITC
#if INLINING
printf("[");
printf("%08x] ", tree->gtField.gtFldHnd);
#endif
#endif
#if INLINING
printf("'%s'\n", eeGetFieldName(tree->gtField.gtFldHnd), 0);
#else
printf("'%s'\n", eeGetFieldName(tree->gtField.gtFldHnd), 0);
#endif
if (tree->gtField.gtFldObj && !topOnly) gtDispTree(tree->gtField.gtFldObj, indent + 1);
fflush(stdout);
return;
case GT_CALL:
assert(tree->gtFlags & GTF_CALL);
if (tree->gtCall.gtCallArgs && !topOnly)
{
#if USE_FASTCALL
if (tree->gtCall.gtCallRegArgs)
{
printf("%*c ", 1+indent*3, ' ');
printf("Call Arguments:\n");
}
#endif
gtDispTree(tree->gtCall.gtCallArgs, indent + 1);
}
#if USE_FASTCALL
if (tree->gtCall.gtCallRegArgs && !topOnly)
{
printf("%*c ", 1+indent*3, ' ');
printf("Register Arguments:\n");
gtDispTree(tree->gtCall.gtCallRegArgs, indent + 1);
}
#endif
gtDispNode(tree, indent, NULL, topOnly);
if (tree->gtCall.gtCallType == CT_INDIRECT)
{
printf("'indirect'\n");
}
else
{
const char * methodName;
const char * className;
methodName = eeGetMethodName(tree->gtCall.gtCallMethHnd, &className);
printf("'%s.%s'\n", className, methodName);
}
if (tree->gtCall.gtCallObjp && !topOnly) gtDispTree(tree->gtCall.gtCallObjp, indent + 1);
if (tree->gtCall.gtCallVptr && !topOnly) gtDispTree(tree->gtCall.gtCallVptr, indent + 1);
if (tree->gtCall.gtCallType == CT_INDIRECT && !topOnly)
gtDispTree(tree->gtCall.gtCallAddr, indent + 1);
fflush(stdout);
return;
case GT_JMP:
const char * methodName;
const char * className;
gtDispNode(tree, indent, NULL, topOnly);
methodName = eeGetMethodName((METHOD_HANDLE)tree->gtVal.gtVal1, &className);
printf("'%s.%s'\n", className, methodName);
fflush(stdout);
return;
case GT_JMPI:
gtDispNode(tree, indent, NULL, topOnly);
printf("\n");
if (tree->gtOp.gtOp1 && !topOnly)
gtDispTree(tree->gtOp.gtOp1, indent + 1);
fflush(stdout);
return;
case GT_STMT:
gtDispNode(tree, indent, NULL, topOnly); printf("\n");
if (!topOnly)
gtDispTree(tree->gtStmt.gtStmtExpr, indent + 1);
fflush(stdout);
return;
#if CSELENGTH
case GT_ARR_RNGCHK:
if (!(tree->gtFlags & GTF_CC_SET))
{
if (tree->gtArrLen.gtArrLenAdr && !topOnly)
gtDispTree(tree->gtArrLen.gtArrLenAdr, indent + 1);
}
gtDispNode(tree, indent, NULL, topOnly); printf(" [adr=%08X]\n", tree->gtArrLen.gtArrLenAdr);
if (tree->gtArrLen.gtArrLenCse && !topOnly)
gtDispTree(tree->gtArrLen.gtArrLenCse, indent + 1);
fflush(stdout);
return;
#endif
default:
gtDispNode(tree, indent, NULL, topOnly);
printf("<DON'T KNOW HOW TO DISPLAY THIS NODE>\n");
fflush(stdout);
return;
}
}
/*****************************************************************************/
void Compiler::gtDispTreeList(GenTree * tree)
{
for (/*--*/; tree != NULL; tree = tree->gtNext)
{
if (tree->gtOper == GT_STMT && opts.compDbgInfo)
printf("start IL : %03Xh, end IL : %03Xh\n",
tree->gtStmtILoffs, tree->gtStmt.gtStmtLastILoffs);
gtDispTree(tree, 0);
printf("\n");
}
}
/*****************************************************************************/
#endif // DEBUG
/*****************************************************************************
*
* Check if the given node can be folded,
* and call the methods to perform the folding
*/
GenTreePtr Compiler::gtFoldExpr(GenTreePtr tree)
{
unsigned kind = tree->OperKind();
/* We must have a simple operation to fold */
if (!(kind & GTK_SMPOP))
return tree;
/* Filter out non-foldable trees that can have constant children */
assert (kind & (GTK_UNOP | GTK_BINOP));
switch (tree->gtOper)
{
case GT_RETFILT:
case GT_RETURN:
case GT_IND:
case GT_NOP:
return tree;
}
GenTreePtr op1 = tree->gtOp.gtOp1;
GenTreePtr op2 = tree->gtOp.gtOp2;
/* try to fold the current node */
if ((kind & GTK_UNOP) && op1)
{
if (op1->OperKind() & GTK_CONST)
return gtFoldExprConst(tree);
}
else if ((kind & GTK_BINOP) && op1 && op2)
{
if ((op1->OperKind() & op2->OperKind()) & GTK_CONST)
{
/* both nodes are constants - fold the expression */
return gtFoldExprConst(tree);
}
else if ((op1->OperKind() | op2->OperKind()) & GTK_CONST)
{
/* at least one is a constant - see if we have a
* special operator that can use only one constant
* to fold - e.g. booleans */
return gtFoldExprSpecial(tree);
}
}
/* Return the original node (folded/bashed or not) */
return tree;
}
/*****************************************************************************
*
* Some binary operators can be folded even if they have only one
* operand constant - e.g. boolean operators, add with 0
* multiply with 1, etc
*/
GenTreePtr Compiler::gtFoldExprSpecial(GenTreePtr tree)
{
GenTreePtr op1 = tree->gtOp.gtOp1;
GenTreePtr op2 = tree->gtOp.gtOp2;
GenTreePtr op, cons;
unsigned val;
assert(tree->OperKind() & GTK_BINOP);
/* Filter out operators that cannot be folded here */
if ((tree->OperKind() & (GTK_ASGOP|GTK_RELOP)) ||
(tree->gtOper == GT_CAST) )
return tree;
/* We only consider TYP_INT for folding
* Do not fold pointer arythmetic (e.g. addressing modes!) */
if (tree->gtOper != GT_QMARK)
if ((tree->gtType != TYP_INT) || (tree->gtFlags & GTF_NON_GC_ADDR))
return tree;
/* Find out which is the constant node
* CONSIDER - allow constant other than INT */
if (op1->gtOper == GT_CNS_INT)
{
op = op2;
cons = op1;
}
else if (op2->gtOper == GT_CNS_INT)
{
op = op1;
cons = op2;
}
else
return tree;
/* Get the constant value */
val = cons->gtIntCon.gtIconVal;
/* Here op is the non-constant operand, val is the constant, first is true if the constant is op1
* IMPORTANT: Need to save the gtStmtList links of the initial node and restore them on the folded node */
GenTreePtr saveGtNext = tree->gtNext;
GenTreePtr saveGtPrev = tree->gtPrev;
switch (tree->gtOper)
{
case GT_ADD:
case GT_ASG_ADD:
if (val == 0) goto DONE_FOLD;
break;
case GT_MUL:
case GT_ASG_MUL:
if (val == 1)
goto DONE_FOLD;
else if (val == 0)
{
/* Multiply by zero - return the 'zero' node, but not if side effects */
if (!(op->gtFlags & (GTF_SIDE_EFFECT & ~GTF_OTHER_SIDEEFF)))
{
op = cons;
goto DONE_FOLD;
}
}
break;
case GT_DIV:
case GT_UDIV:
case GT_ASG_DIV:
if ((val == 1) && !(op1->OperKind() & GTK_CONST))
{
goto DONE_FOLD;
}
break;
case GT_AND:
if (val == 0)
{
/* AND with zero - return the 'zero' node, but not if side effects */
if (!(op->gtFlags & (GTF_SIDE_EFFECT & ~GTF_OTHER_SIDEEFF)))
{
op = cons;
goto DONE_FOLD;
}
}
else
{
/* The GTF_BOOLEAN flag is set for nodes that are part
* of a boolean expression, thus all their children
* are known to evaluate to only 0 or 1 */
if (tree->gtFlags & GTF_BOOLEAN)
{
/* The constant value must be 1
* AND with 1 stays the same */
assert(val == 1);
goto DONE_FOLD;
}
}
break;
case GT_OR:
if (val == 0)
goto DONE_FOLD;
else if (tree->gtFlags & GTF_BOOLEAN)
{
/* The constant value must be 1 - OR with 1 is 1 */
assert(val == 1);
/* OR with one - return the 'one' node, but not if side effects */
if (!(op->gtFlags & (GTF_SIDE_EFFECT & ~GTF_OTHER_SIDEEFF)))
{
op = cons;
goto DONE_FOLD;
}
}
break;
case GT_QMARK:
assert(op1->gtOper == GT_CNS_INT);
assert(op2->gtOper == GT_COLON);
assert(op2->gtOp.gtOp1 && op2->gtOp.gtOp2);
assert(val == 0 || val == 1);
if (val)
op = op2->gtOp.gtOp2;
else
op = op2->gtOp.gtOp1;
goto DONE_FOLD;
default:
break;
}
/* The node is not foldable */
return tree;
DONE_FOLD:
/* The node has beeen folded into 'op'
* Return 'op' with the restored links */
op->gtNext = saveGtNext;
op->gtPrev = saveGtPrev;
return op;
}
/*****************************************************************************
*
* Fold the given constant tree.
*/
GenTreePtr Compiler::gtFoldExprConst(GenTreePtr tree)
{
unsigned kind = tree->OperKind();
long i1, i2, itemp;
__int64 lval1, lval2, ltemp;
float f1, f2;
double d1, d2;
GenTreePtr op1;
GenTreePtr op2;
assert (kind & (GTK_UNOP | GTK_BINOP));
if (kind & GTK_UNOP)
{
op1 = tree->gtOp.gtOp1;
assert(op1->OperKind() & GTK_CONST);
#ifdef DEBUG
if (verbose&&1)
{
if (tree->gtOper == GT_NOT ||
tree->gtOper == GT_NEG ||
tree->gtOper == GT_CHS )
{
printf("Folding unary operator with constant node:\n");
gtDispTree(tree);
printf("\n");
}
}
#endif
switch(op1->gtType)
{
case TYP_INT:
/* Fold constant INT unary operator */
i1 = op1->gtIntCon.gtIconVal;
switch (tree->gtOper)
{
case GT_NOT: i1 = ~i1; break;
case GT_NEG:
case GT_CHS: i1 = -i1; break;
default:
return tree;
}
goto CNS_INT;
case TYP_LONG:
/* Fold constant LONG unary operator */
lval1 = op1->gtLngCon.gtLconVal;
switch (tree->gtOper)
{
case GT_NOT: lval1 = ~lval1; break;
case GT_NEG:
case GT_CHS: lval1 = -lval1; break;
default:
return tree;
}
goto CNS_LONG;
case TYP_FLOAT:
/* Fold constant FLOAT unary operator */
f1 = op1->gtFltCon.gtFconVal;
switch (tree->gtOper)
{
case GT_NEG:
case GT_CHS: f1 = -f1; break;
default:
return tree;
}
goto CNS_FLOAT;
case TYP_DOUBLE:
/* Fold constant DOUBLE unary operator */
d1 = op1->gtDblCon.gtDconVal;
switch (tree->gtOper)
{
case GT_NEG:
case GT_CHS: d1 = -d1; break;
default:
return tree;
}
goto CNS_DOUBLE;
default:
/* not a foldable typ - e.g. RET const */
return tree;
}
}
/* We have a binary operator */
assert(kind & GTK_BINOP);
op1 = tree->gtOp.gtOp1;
op2 = tree->gtOp.gtOp2;
assert(op1->OperKind() & GTK_CONST);
assert(op2->OperKind() & GTK_CONST);
#ifdef DEBUG
if (verbose&&1)
{
printf("\nFolding binary operator with constant nodes:\n");
gtDispTree(tree);
printf("\n");
}
#endif
switch(op1->gtType)
{
/*-------------------------------------------------------------------------
* Fold constant INT binary operator
*/
case TYP_INT:
assert (op2->gtType == TYP_INT || op2->gtType == TYP_NAT_INT);
assert (tree->gtType == TYP_INT ||
tree->gtType == TYP_NAT_INT ||
tree->gtType == TYP_REF ||
tree->gtType == TYP_BYREF || tree->gtOper == GT_CAST ||
tree->gtOper == GT_LIST );
i1 = op1->gtIntCon.gtIconVal;
i2 = op2->gtIntCon.gtIconVal;
switch (tree->gtOper)
{
case GT_EQ : i1 = (i1 == i2); break;
case GT_NE : i1 = (i1 != i2); break;
case GT_LT :
if (tree->gtFlags & GTF_UNSIGNED)
i1 = ((unsigned)i1 < (unsigned)i2);
else
i1 = (i1 < i2);
break;
case GT_LE :
if (tree->gtFlags & GTF_UNSIGNED)
i1 = ((unsigned)i1 <= (unsigned)i2);
else
i1 = (i1 <= i2);
break;
case GT_GE :
if (tree->gtFlags & GTF_UNSIGNED)
i1 = ((unsigned)i1 >= (unsigned)i2);
else
i1 = (i1 >= i2);
break;
case GT_GT :
if (tree->gtFlags & GTF_UNSIGNED)
i1 = ((unsigned)i1 > (unsigned)i2);
else
i1 = (i1 > i2);
break;
case GT_ADD:
itemp = i1 + i2;
if (tree->gtOverflow())
{
if (tree->gtFlags & GTF_UNSIGNED)
{
if (((__int64)(unsigned)itemp) != ((__int64)(unsigned)i1 + (__int64)(unsigned)i2))
goto INT_OVF;
}
else
if (((__int64)itemp) != ((__int64)i1+(__int64)i2)) goto INT_OVF;
}
i1 = itemp; break;
case GT_SUB:
itemp = i1 - i2;
if (tree->gtOverflow())
{
if (tree->gtFlags & GTF_UNSIGNED)
{
if (((__int64)(unsigned)itemp) != ((__int64)(unsigned)i1 - (__int64)(unsigned)i2))
goto INT_OVF;
}
else
if (((__int64)itemp) != ((__int64)i1-(__int64)i2)) goto INT_OVF;
}
i1 = itemp; break;
case GT_MUL:
itemp = (unsigned long)i1 * (unsigned long)i2;
if (tree->gtOverflow())
if (((unsigned __int64)itemp) !=
((unsigned __int64)i1*(unsigned __int64)i2)) goto INT_OVF;
i1 = itemp; break;
case GT_OR : i1 |= i2; break;
case GT_XOR: i1 ^= i2; break;
case GT_AND: i1 &= i2; break;
case GT_LSH: i1 <<= (i2 & 0x1f); break;
case GT_RSH: i1 >>= (i2 & 0x1f); break;
case GT_RSZ:
/* logical shift -> make it unsigned to propagate the sign bit */
i1 = (unsigned)i1 >> (i2 & 0x1f);
break;
/* DIV and MOD can generate an INT 0 - if division by 0
* or overflow - when dividing MIN by -1 */
// @TODO: Convert into std exception throw
case GT_DIV:
if (!i2) return tree;
if ((unsigned)i1 == 0x80000000 && i2 == -1)
{
/* In IL we have to throw an exception */
return tree;
}
i1 /= i2; break;
case GT_MOD:
if (!i2) return tree;
if ((unsigned)i1 == 0x80000000 && i2 == -1)
{
/* In IL we have to throw an exception */
return tree;
}
i1 %= i2; break;
case GT_UDIV:
if (!i2) return tree;
if ((unsigned)i1 == 0x80000000 && i2 == -1) return tree;
i1 = (unsigned)i1 / (unsigned)i2; break;
case GT_UMOD:
if (!i2) return tree;
if ((unsigned)i1 == 0x80000000 && i2 == -1) return tree;
i1 = (unsigned)i1 % (unsigned)i2; break;
case GT_CAST:
assert (genActualType((var_types)i2) == tree->gtType);
switch ((var_types)i2)
{
case TYP_BYTE:
itemp = (__int32)(signed __int8 )i1;
if (tree->gtOverflow()) if (itemp != i1) goto INT_OVF;
i1 = itemp; goto CNS_INT;
case TYP_SHORT:
itemp = (__int32)( __int16)i1;
if (tree->gtOverflow()) if (itemp != i1) goto INT_OVF;
i1 = itemp; goto CNS_INT;
case TYP_CHAR:
itemp = (__int32)(unsigned __int16)i1;
if (tree->gtOverflow())
if (itemp != i1) goto INT_OVF;
i1 = itemp;
goto CNS_INT;
case TYP_BOOL:
case TYP_UBYTE:
itemp = (__int32)(unsigned __int8 )i1;
if (tree->gtOverflow()) if (itemp != i1) goto INT_OVF;
i1 = itemp; goto CNS_INT;
case TYP_UINT:
if (!(tree->gtFlags & GTF_UNSIGNED) && tree->gtOverflow() && i1 < 0)
goto INT_OVF;
goto CNS_INT;
case TYP_INT:
if ((tree->gtFlags & GTF_UNSIGNED) && tree->gtOverflow() && i1 < 0)
goto INT_OVF;
goto CNS_INT;
case TYP_ULONG:
if (!(tree->gtFlags & GTF_UNSIGNED) && tree->gtOverflow() && i1 < 0)
{
op1->ChangeOper(GT_CNS_LNG); // need type of oper to be same as tree
op1->gtType = TYP_LONG;
// We don't care about the value as we are throwing an exception
goto LNG_OVF;
}
// Fall through
case TYP_LONG:
if (tree->gtFlags & GTF_UNSIGNED)
lval1 = (unsigned __int64) (unsigned) i1;
else
lval1 = ( __int64)i1;
goto CNS_LONG;
case TYP_FLOAT:
if (tree->gtFlags & GTF_UNSIGNED)
f1 = (float) (unsigned) i1;
else
f1 = (float) i1;
goto CNS_FLOAT;
case TYP_DOUBLE:
if (tree->gtFlags & GTF_UNSIGNED)
d1 = (double) (unsigned) i1;
else
d1 = (double) i1;
goto CNS_DOUBLE;
#ifdef DEBUG
default:
assert(!"BAD_TYP");
#endif
}
break;
default:
return tree;
}
/* We get here after folding to a GT_CNS_INT type
* bash the node to the new type / value and make sure the node sizes are OK */
CNS_INT:
FOLD_COND:
/* Also all conditional folding jumps here since the node hanging from
* GT_JTRUE has to be a GT_CNS_INT - value 0 or 1 */
tree->ChangeOper (GT_CNS_INT);
tree->gtType = TYP_INT;
tree->gtIntCon.gtIconVal = i1;
tree->gtFlags &= GTF_PRESERVE;
goto DONE;
/* This operation is going to cause an overflow exception. Morph into
an overflow helper. Put a dummy constant value for code generation.
We could remove all subsequent trees in the current basic block,
unless this node is a child of GT_COLON
NOTE: Since the folded value is not constant we should not bash the
"tree" node - otherwise we confuse the logic that checks if the folding
was successful - instead use one of the operands, e.g. op1
*/
INT_FROM_LNG_OVF:
op1->ChangeOper(GT_CNS_INT); // need type of oper to be same as tree
op1->gtType = TYP_INT;
INT_OVF:
assert(op1->gtType == TYP_INT);
goto OVF;
LNG_OVF:
assert(op1->gtType == TYP_LONG);
goto OVF;
OVF:
/* We will bashed cast to a GT_COMMA and atach the exception helper as gtOp.gtOp1
* the original constant expression becomes op2 */
assert(tree->gtOverflow());
assert(tree->gtOper == GT_CAST || tree->gtOper == GT_ADD ||
tree->gtOper == GT_SUB || tree->gtOper == GT_MUL);
assert(op1 && op2);
tree->ChangeOper(GT_COMMA);
tree->gtOp.gtOp2 = op1; // original expression becomes op2
tree->gtOp.gtOp1 = gtNewHelperCallNode(CPX_ARITH_EXCPN, TYP_VOID, GTF_EXCEPT,
gtNewOperNode(GT_LIST, TYP_VOID, gtNewIconNode(compCurBB->bbTryIndex)));
tree->gtFlags |= GTF_EXCEPT|GTF_CALL;
/* We use FASTCALL so we have to morph the arguments in registers */
fgMorphArgs(tree->gtOp.gtOp1);
return tree;
/*-------------------------------------------------------------------------
* Fold constant REF of BYREF binary operator
* These can only be comparissons or null pointers
* Currently cannot have constant byrefs
*/
case TYP_REF:
/* String nodes are an RVA at this point */
if (op1->gtOper == GT_CNS_STR || op2->gtOper == GT_CNS_STR)
return tree;
i1 = op1->gtIntCon.gtIconVal;
i2 = op2->gtIntCon.gtIconVal;
assert(i1 == 0);
switch (tree->gtOper)
{
case GT_EQ : i1 = 1; goto FOLD_COND;
case GT_NE : i1 = 0; goto FOLD_COND;
/* For the null pointer case simply keep the null pointer */
case GT_ADD:
tree->ChangeOper(GT_CNS_INT);
tree->gtType = TYP_REF;
tree->gtIntCon.gtIconVal = i1;
tree->gtFlags &= GTF_PRESERVE;
goto DONE;
default:
assert(!"Illegal operation on TYP_REF");
return tree;
}
case TYP_BYREF:
assert(!"Can we have constants of TYP_BYREF?");
return tree;
/*-------------------------------------------------------------------------
* Fold constant LONG binary operator
*/
case TYP_LONG:
lval1 = op1->gtLngCon.gtLconVal;
if (tree->gtOper == GT_CAST ||
tree->gtOper == GT_LSH ||
tree->gtOper == GT_RSH ||
tree->gtOper == GT_RSZ )
{
/* second operand is an INT */
assert (op2->gtType == TYP_INT);
i2 = op2->gtIntCon.gtIconVal;
}
else
{
/* second operand must be a LONG */
assert (op2->gtType == TYP_LONG);
lval2 = op2->gtLngCon.gtLconVal;
}
switch (tree->gtOper)
{
case GT_EQ : i1 = (lval1 == lval2); goto FOLD_COND;
case GT_NE : i1 = (lval1 != lval2); goto FOLD_COND;
case GT_LT :
if (tree->gtFlags & GTF_UNSIGNED)
i1 = ((unsigned __int64)lval1 < (unsigned __int64)lval2);
else
i1 = (lval1 < lval2);
goto FOLD_COND;
case GT_LE :
if (tree->gtFlags & GTF_UNSIGNED)
i1 = ((unsigned __int64)lval1 <= (unsigned __int64)lval2);
else
i1 = (lval1 <= lval2);
goto FOLD_COND;
case GT_GE :
if (tree->gtFlags & GTF_UNSIGNED)
i1 = ((unsigned __int64)lval1 >= (unsigned __int64)lval2);
else
i1 = (lval1 >= lval2);
goto FOLD_COND;
case GT_GT :
if (tree->gtFlags & GTF_UNSIGNED)
i1 = ((unsigned __int64)lval1 > (unsigned __int64)lval2);
else
i1 = (lval1 > lval2);
goto FOLD_COND;
case GT_ADD:
ltemp = lval1 + lval2;
LNG_ADD_CHKOVF:
/* For the SIGNED case - If there is one positive and one negative operand, there can be no overflow
* If both are positive, the result has to be positive, and similary for negatives.
*
* For the UNSIGNED case - If an (unsigned) operand is bigger than the result then OVF */
if (tree->gtOverflow())
{
if (tree->gtFlags & GTF_UNSIGNED)
{
if ( ((unsigned __int64)lval1 > (unsigned __int64)ltemp) ||
((unsigned __int64)lval2 > (unsigned __int64)ltemp) )
goto LNG_OVF;
}
else
if ( ((lval1<0) == (lval2<0)) && ((lval1<0) != (ltemp<0)) )
goto LNG_OVF;
}
lval1 = ltemp; break;
case GT_SUB:
ltemp = lval1 - lval2;
// If both operands are positive or both are negative, there can be no overflow
// Else use the logic for : lval1 + (-lval2)
if (tree->gtOverflow() && ((lval1<0) != (lval2<0)))
{
if (lval2 == INT_MIN) goto LNG_OVF;
lval2 = -lval2; goto LNG_ADD_CHKOVF;
}
lval1 = ltemp; break;
case GT_MUL:
ltemp = lval1 * lval2;
if (tree->gtOverflow())
if ((ltemp != 0) && ((ltemp/lval2) != lval1)) goto LNG_OVF;
lval1 = ltemp; break;
case GT_OR : lval1 |= lval2; break;
case GT_XOR: lval1 ^= lval2; break;
case GT_AND: lval1 &= lval2; break;
case GT_LSH: lval1 <<= (i2 & 0x3f); break;
case GT_RSH: lval1 >>= (i2 & 0x3f); break;
case GT_RSZ:
/* logical shift -> make it unsigned to propagate the sign bit */
lval1 = (unsigned __int64)lval1 >> (i2 & 0x3f);
break;
case GT_DIV:
if (!lval2) return tree;
if ((unsigned __int64)lval1 == 0x8000000000000000 && lval2 == (__int64)-1)
{
/* In IL we have to throw an exception */
return tree;
}
lval1 /= lval2; break;
case GT_MOD:
if (!lval2) return tree;
if ((unsigned __int64)lval1 == 0x8000000000000000 && lval2 == (__int64)-1)
{
/* In IL we have to throw an exception */
return tree;
}
lval1 %= lval2; break;
case GT_UDIV:
if (!lval2) return tree;
if ((unsigned __int64)lval1 == 0x8000000000000000 && lval2 == (__int64)-1) return tree;
lval1 = (unsigned __int64)lval1 / (unsigned __int64)lval2; break;
case GT_UMOD:
if (!lval2) return tree;
if ((unsigned __int64)lval1 == 0x8000000000000000 && lval2 == (__int64)-1) return tree;
lval1 = (unsigned __int64)lval1 % (unsigned __int64)lval2; break;
case GT_CAST:
assert (genActualType((var_types)i2) == tree->gtType);
switch ((var_types)i2)
{
case TYP_BYTE:
i1 = (__int32)(signed __int8 )lval1;
goto CHECK_INT_OVERFLOW;
case TYP_SHORT:
i1 = (__int32)( __int16)lval1;
goto CHECK_INT_OVERFLOW;
case TYP_CHAR:
i1 = (__int32)(unsigned __int16)lval1;
goto CHECK_UINT_OVERFLOW;
case TYP_UBYTE:
i1 = (__int32)(unsigned __int8 )lval1;
goto CHECK_UINT_OVERFLOW;
case TYP_INT:
i1 = (__int32)lval1;
CHECK_INT_OVERFLOW:
if (tree->gtOverflow())
{
if (i1 != lval1)
goto INT_FROM_LNG_OVF;
if ((tree->gtFlags & GTF_UNSIGNED) && i1 < 0)
goto INT_FROM_LNG_OVF;
}
goto CNS_INT;
case TYP_UINT:
i1 = (unsigned __int32)lval1;
CHECK_UINT_OVERFLOW:
if (tree->gtOverflow() && (unsigned) i1 != lval1)
goto INT_FROM_LNG_OVF;
goto CNS_INT;
case TYP_ULONG:
if (!(tree->gtFlags & GTF_UNSIGNED) && tree->gtOverflow() && lval1 < 0)
goto LNG_OVF;
goto CNS_INT;
case TYP_LONG:
if ((tree->gtFlags & GTF_UNSIGNED) && tree->gtOverflow() && lval1 < 0)
goto LNG_OVF;
goto CNS_INT;
case TYP_FLOAT:
f1 = (float) lval1;
// VC does not have unsigned convert to float, so we
// implement it by adding 2^64 if the number is negative
if ((tree->gtFlags & GTF_UNSIGNED) && lval1 < 0)
f1 += 4294967296.0 * 4294967296.0;
goto CNS_FLOAT;
case TYP_DOUBLE:
// VC does not have unsigned convert to double, so we
// implement it by adding 2^64 if the number is negative
d1 = (double) lval1;
if ((tree->gtFlags & GTF_UNSIGNED) && lval1 < 0)
d1 += 4294967296.0 * 4294967296.0;
goto CNS_DOUBLE;
#ifdef DEBUG
default:
assert(!"BAD_TYP");
#endif
}
break;
default:
return tree;
}
CNS_LONG:
assert ((GenTree::s_gtNodeSizes[GT_CNS_LNG] == TREE_NODE_SZ_SMALL) ||
(tree->gtFlags & GTF_NODE_LARGE) );
tree->ChangeOper(GT_CNS_LNG);
tree->gtLngCon.gtLconVal = lval1;
tree->gtFlags &= GTF_PRESERVE;
goto DONE;
/*-------------------------------------------------------------------------
* Fold constant FLOAT binary operator
*/
case TYP_FLOAT:
// @TODO: Add these cases
if (tree->gtOverflowEx()) return tree;
f1 = op1->gtFltCon.gtFconVal;
if (tree->gtOper == GT_CAST)
{
/* If not finite don't bother */
if (!_finite(f1)) return tree;
/* second operand is an INT */
assert (op2->gtType == TYP_INT);
i2 = op2->gtIntCon.gtIconVal;
}
else
{
/* second operand must be a FLOAT */
assert (op2->gtType == TYP_FLOAT);
f2 = op2->gtFltCon.gtFconVal;
/* Special case - check if we have NaN operands
* For comparissons if not an unordered operation always return 0
* For unordered operations (i.e the GTF_CMP_NAN_UN flag is set)
* the result is always true - return 1 */
if (_isnan(f1) || _isnan(f2))
{
#ifdef DEBUG
if (verbose)
printf("Float operator(s) is NaN\n");
#endif
if (tree->OperKind() & GTK_RELOP)
if (tree->gtFlags & GTF_CMP_NAN_UN)
{
/* Unordered comparisson with NaN always succeeds */
i1 = 1; goto FOLD_COND;
}
else
{
/* Normal comparisson with NaN always fails */
i1 = 0; goto FOLD_COND;
}
}
}
switch (tree->gtOper)
{
case GT_EQ : i1 = (f1 == f2); goto FOLD_COND;
case GT_NE : i1 = (f1 != f2); goto FOLD_COND;
case GT_LT : i1 = (f1 < f2); goto FOLD_COND;
case GT_LE : i1 = (f1 <= f2); goto FOLD_COND;
case GT_GE : i1 = (f1 >= f2); goto FOLD_COND;
case GT_GT : i1 = (f1 > f2); goto FOLD_COND;
case GT_ADD: f1 += f2; break;
case GT_SUB: f1 -= f2; break;
case GT_MUL: f1 *= f2; break;
case GT_DIV: if (!f2) return tree;
f1 /= f2; break;
case GT_CAST:
assert (genActualType((var_types)i2) == tree->gtType);
switch ((var_types)i2)
{
case TYP_BYTE:
i1 = (__int32)(signed __int8 )f1; goto CNS_INT;
case TYP_SHORT:
i1 = (__int32)( __int16)f1; goto CNS_INT;
case TYP_CHAR:
i1 = (__int32)(unsigned __int16)f1; goto CNS_INT;
case TYP_UBYTE:
i1 = (__int32)(unsigned __int8 )f1; goto CNS_INT;
case TYP_INT:
i1 = (__int32)f1; goto CNS_INT;
case TYP_UINT:
i1 = (unsigned __int32)f1; goto CNS_INT;
case TYP_LONG:
lval1 = (__int64)f1; goto CNS_LONG;
case TYP_ULONG:
lval1 = (unsigned __int64)f1; goto CNS_LONG;
case TYP_FLOAT: goto CNS_FLOAT; // redundant cast
case TYP_DOUBLE: d1 = (double )f1; goto CNS_DOUBLE;
#ifdef DEBUG
default:
assert(!"BAD_TYP");
#endif
}
break;
default:
return tree;
}
CNS_FLOAT:
assert ((GenTree::s_gtNodeSizes[GT_CNS_FLT] == TREE_NODE_SZ_SMALL) ||
(tree->gtFlags & GTF_NODE_LARGE) );
tree->ChangeOper(GT_CNS_FLT);
tree->gtFltCon.gtFconVal = f1;
tree->gtFlags &= GTF_PRESERVE;
goto DONE;
/*-------------------------------------------------------------------------
* Fold constant DOUBLE binary operator
*/
case TYP_DOUBLE:
// @TODO: Add these cases
if (tree->gtOverflowEx()) return tree;
d1 = op1->gtDblCon.gtDconVal;
if (tree->gtOper == GT_CAST)
{
/* If not finit don't bother */
if (!_finite(d1)) return tree;
/* second operand is an INT */
assert (op2->gtType == TYP_INT);
i2 = op2->gtIntCon.gtIconVal;
}
else
{
/* second operand must be a DOUBLE */
assert (op2->gtType == TYP_DOUBLE);
d2 = op2->gtDblCon.gtDconVal;
/* Special case - check if we have NaN operands
* For comparissons if not an unordered operation always return 0
* For unordered operations (i.e the GTF_CMP_NAN_UN flag is set)
* the result is always true - return 1 */
if (_isnan(d1) || _isnan(d2))
{
#ifdef DEBUG
if (verbose)
printf("Double operator(s) is NaN\n");
#endif
if (tree->OperKind() & GTK_RELOP)
if (tree->gtFlags & GTF_CMP_NAN_UN)
{
/* Unordered comparisson with NaN always succeeds */
i1 = 1; goto FOLD_COND;
}
else
{
/* Normal comparisson with NaN always fails */
i1 = 0; goto FOLD_COND;
}
}
}
switch (tree->gtOper)
{
case GT_EQ : i1 = (d1 == d2); goto FOLD_COND;
case GT_NE : i1 = (d1 != d2); goto FOLD_COND;
case GT_LT : i1 = (d1 < d2); goto FOLD_COND;
case GT_LE : i1 = (d1 <= d2); goto FOLD_COND;
case GT_GE : i1 = (d1 >= d2); goto FOLD_COND;
case GT_GT : i1 = (d1 > d2); goto FOLD_COND;
case GT_ADD: d1 += d2; break;
case GT_SUB: d1 -= d2; break;
case GT_MUL: d1 *= d2; break;
case GT_DIV: if (!d2) return tree;
d1 /= d2; break;
case GT_CAST:
assert (genActualType((var_types)i2) == tree->gtType);
switch ((var_types)i2)
{
case TYP_BYTE:
i1 = (__int32)(signed __int8 )d1; goto CNS_INT;
case TYP_SHORT:
i1 = (__int32)( __int16)d1; goto CNS_INT;
case TYP_CHAR:
i1 = (__int32)(unsigned __int16)d1; goto CNS_INT;
case TYP_UBYTE:
i1 = (__int32)(unsigned __int8 )d1; goto CNS_INT;
case TYP_INT:
i1 = (__int32)d1; goto CNS_INT;
case TYP_UINT:
i1 = (unsigned __int32)d1; goto CNS_INT;
case TYP_LONG:
lval1 = (__int64)d1; goto CNS_LONG;
case TYP_ULONG:
lval1 = (unsigned __int64)d1; goto CNS_LONG;
case TYP_FLOAT: f1 = (float )d1; goto CNS_FLOAT;
case TYP_DOUBLE: goto CNS_DOUBLE; // redundant cast
#ifdef DEBUG
default:
assert(!"BAD_TYP");
#endif
}
break;
default:
return tree;
}
CNS_DOUBLE:
assert ((GenTree::s_gtNodeSizes[GT_CNS_DBL] == TREE_NODE_SZ_SMALL) ||
(tree->gtFlags & GTF_NODE_LARGE) );
tree->ChangeOper(GT_CNS_DBL);
tree->gtDblCon.gtDconVal = d1;
tree->gtFlags &= GTF_PRESERVE;
goto DONE;
default:
/* not a foldable typ */
return tree;
}
//-------------------------------------------------------------------------
DONE:
/* Make sure no side effect flags are set on this constant node */
//assert(~(gtFlags & GTF_SIDE_EFFECT));
//if (gtFlags & GTF_SIDE_EFFECT)
// assert(!"Found side effect");
tree->gtFlags &= ~GTF_SIDE_EFFECT;
return tree;
}
/*****************************************************************************
*
* Create an assignment of the given value to a temp.
*/
GenTreePtr Compiler::gtNewTempAssign(unsigned tmp, GenTreePtr val)
{
GenTreePtr dst;
var_types typ = genActualType(val->gtType);
/* Create the temp target reference node */
dst = gtNewLclvNode(tmp, typ); dst->gtFlags |= GTF_VAR_DEF;
/* Create the assignment node */
dst = gtNewOperNode(GT_ASG, typ, dst, val);
/* Mark the expression as containing an assignment */
dst->gtFlags |= GTF_ASG;
return dst;
}
/*****************************************************************************
*
* If the field is a NStruct field of a simple type, then we can directly
* access it without using a helper call.
* This function returns NULL if the field is not a simple NStruct field
* Else it will create a tree to do the field access and return it.
* "assg" is 0 for ldfld, and the value to assign for stfld.
*/
GenTreePtr Compiler::gtNewDirectNStructField (GenTreePtr objPtr,
unsigned fldIndex,
var_types lclTyp,
GenTreePtr assg)
{
FIELD_HANDLE fldHnd = eeFindField(fldIndex, info.compScopeHnd, 0);
JIT_FIELDCATEGORY fldNdc;
#ifdef NOT_JITC
fldNdc = info.compCompHnd->getFieldCategory(fldHnd);
#else
fldNdc = JIT_FIELDCATEGORY_UNKNOWN;
#endif
/* Check if it is a simple type. If so, map it to "var_types" */
var_types type;
switch(fldNdc)
{
// Most simple types - exact match
case JIT_FIELDCATEGORY_I1_I1 : type = TYP_BYTE; break;
case JIT_FIELDCATEGORY_I2_I2 : type = TYP_SHORT; break;
case JIT_FIELDCATEGORY_I4_I4 : type = TYP_INT; break;
case JIT_FIELDCATEGORY_I8_I8 : type = TYP_LONG; break;
// These will need some extra work
case JIT_FIELDCATEGORY_BOOLEAN_BOOL : type = TYP_BYTE; break;
case JIT_FIELDCATEGORY_CHAR_CHAR : type = TYP_UBYTE; break;
// Others
default : //assert(fldNdc == JIT_FIELDCATEGORY_NORMAL ||
// fldNdc == JIT_FIELDCATEGORY_UNKNOWN);
type = TYP_UNDEF; break;
}
if (type == TYP_UNDEF)
{
/* If the field is not NStruct (must be a COM object), or if it is
* not of a simple type, we will simply use a helper call to
* access it. So just return NULL
*/
return NULL;
}
NO_WAY(!"I thought NStruct is now defunct?");
/* Create the following tree :
* GT_IND( GT_IND(obj + INDIR_OFFSET) + nativeFldOffs )
*/
GenTreePtr tree;
/* Get the offset of the field in the real native struct */
unsigned fldOffs = eeGetFieldOffset(fldHnd);
/* Get the real ptr from the proxy object */
tree = gtNewOperNode(GT_ADD, TYP_REF,
objPtr,
gtNewIconNode(Info::compNStructIndirOffset));
tree = gtNewOperNode(GT_IND, TYP_I_IMPL, tree);
tree->gtFlags |= GTF_EXCEPT;
/* Access the field using the real ptr */
tree = gtNewOperNode(GT_ADD, TYP_I_IMPL,
tree,
gtNewIconNode(fldOffs));
tree->gtFlags |= GTF_NON_GC_ADDR;
/* Check that we used the right suffix (ie, the XX in ldfld.XX)
to access the field */
assert(genActualType(lclTyp) == genActualType(type));
tree = gtNewOperNode(GT_IND, type, tree);
/* Morph tree for some of the categories, and
create the assignment node if needed */
if (assg)
{
if (fldNdc == JIT_FIELDCATEGORY_BOOLEAN_BOOL)
{
// Need to noramlize the "bool"
assg = gtNewOperNode(GT_NE, TYP_INT, assg, gtNewIconNode(0));
}
tree = gtNewAssignNode(tree, assg);
}
else
{
if (fldNdc == JIT_FIELDCATEGORY_BOOLEAN_BOOL)
{
// Need to noramlize the "bool"
tree = gtNewOperNode(GT_NE, TYP_INT, tree, gtNewIconNode(0));
}
/* Dont need to do anything for JIT_FIELDCATEGORY_CHAR_CHAR, as
we set the type to TYP_UBYTE, so it will be automatically
expanded to 16/32 bits as needed.
*/
}
return tree;
}
/*****************************************************************************
*
* Create a helper call to access a COM field (iff 'assg' is non-zero this is
* an assignment and 'assg' is the new value).
*/
GenTreePtr Compiler::gtNewRefCOMfield(GenTreePtr objPtr,
unsigned fldIndex,
var_types lclTyp,
GenTreePtr assg)
{
/* See if we can directly access the NStruct field */
GenTreePtr ntree = gtNewDirectNStructField(objPtr,
fldIndex,
lclTyp,
assg);
if (ntree)
return ntree;
/* If we cant access it directly, we need to call a helper function */
GenTreePtr args;
int CPX;
if (assg)
{
if (genTypeSize(lclTyp) == sizeof(double))
CPX = CPX_PUTFIELD64;
else if (lclTyp == TYP_REF)
CPX = CPX_PUTFIELDOBJ;
else if (varTypeIsGC(lclTyp))
{
NO_WAY("stfld: fields cannot be byrefs");
}
else
CPX = CPX_PUTFIELD32;
args = gtNewOperNode(GT_LIST, TYP_VOID, assg, 0);
/* The assignment call doesn't return a value */
lclTyp = TYP_VOID;
}
else
{
if (genTypeSize(lclTyp) == sizeof(double))
{
CPX = CPX_GETFIELD64;
}
else if (lclTyp == TYP_REF)
CPX = CPX_GETFIELDOBJ;
else if (varTypeIsGC(lclTyp))
{
NO_WAY("ldfld: fields cannot be byrefs");
}
else
{
CPX = CPX_GETFIELD32;
}
args = 0;
}
FIELD_HANDLE memberHandle = eeFindField(fldIndex, info.compScopeHnd, 0);
args = gtNewOperNode(GT_LIST,
TYP_VOID,
gtNewIconEmbFldHndNode(memberHandle,
fldIndex,
info.compScopeHnd),
args);
args = gtNewOperNode(GT_LIST, TYP_VOID, objPtr, args);
return gtNewHelperCallNode(CPX,
genActualType(lclTyp),
GTF_CALL_REGSAVE,
args);
}
/*****************************************************************************
/* creates a GT_COPYBLK which copies a block from 'src' to 'dest'. 'blkShape'
is either a size or a class handle (GTF_ICON_CLASS_HDL bit tells which) */
GenTreePtr Compiler::gtNewCpblkNode(GenTreePtr dest, GenTreePtr src, GenTreePtr blkShape)
{
GenTreePtr op1;
assert(genActualType(dest->gtType) == TYP_I_IMPL || dest->gtType == TYP_BYREF);
assert(genActualType( src->gtType) == TYP_I_IMPL || src->gtType == TYP_BYREF);
#if TGT_IA64
assert(genActualType(blkShape->gtType) == TYP_LONG);
#else
assert(genActualType(blkShape->gtType) == TYP_INT);
#endif
op1 = gtNewOperNode(GT_LIST, TYP_VOID, // GT_COPYBLK
dest, src); // / \.
op1 = gtNewOperNode(GT_COPYBLK, TYP_VOID, // GT_LIST(op2) [size/clsHnd]
op1, blkShape); // / \
// [dest] [src]
op1->gtFlags |= (GTF_EXCEPT | GTF_GLOB_REF);
return(op1);
}
/*****************************************************************************
*
* Return true if the given expression contains side effects.
*/
bool Compiler::gtHasSideEffects(GenTreePtr tree)
{
if (tree->OperKind() & GTK_ASGOP)
return true;
if (tree->gtFlags & GTF_OTHER_SIDEEFF)
return true;
switch (tree->gtOper)
{
case GT_CALL:
/* Some helper calls are not side effects */
if (tree->gtCall.gtCallType == CT_HELPER)
{
if (tree->gtCall.gtCallMethHnd == eeFindHelper(CPX_ARRADDR_ST))
{
}
else if (tree->gtCall.gtCallMethHnd == eeFindHelper(CPX_LONG_DIV) ||
tree->gtCall.gtCallMethHnd == eeFindHelper(CPX_LONG_MOD))
{
/* This is not a side effect if RHS is always non-zero */
tree = tree->gtCall.gtCallArgs;
assert(tree->gtOper == GT_LIST);
tree = tree->gtOp.gtOp1;
if (tree->gtOper == GT_CNS_LNG && tree->gtLngCon.gtLconVal)
return false;
}
else
// ISSUE: Any other helpers may contain side effects?
return false;
}
// printf("Call with side effects:\n"); dsc->lpoCmp->gtDispTree(tree); printf("\n\n");
return true;
case GT_IND:
// CONSIDER: If known to be non-null, it's not a side effect
return true;
case GT_DIV:
case GT_MOD:
case GT_UDIV:
case GT_UMOD:
tree = tree->gtOp.gtOp2;
if (tree->gtOper == GT_CNS_INT && tree->gtIntCon.gtIconVal)
return false;
if (tree->gtOper == GT_CNS_LNG && tree->gtLngCon.gtLconVal)
return false;
return true;
}
return false;
}
/*****************************************************************************
*
* Extracts side effects from the given expression
* and appends them to a given list (actually a GT_COMMA list)
*/
void Compiler::gtExtractSideEffList(GenTreePtr expr, GenTreePtr * list)
{
assert(expr); assert(expr->gtOper != GT_STMT);
/* If no side effect in the expression return */
if (!(expr->gtFlags & GTF_SIDE_EFFECT))
return;
genTreeOps oper = expr->OperGet();
unsigned kind = expr->OperKind();
GenTreePtr op1 = expr->gtOp.gtOp1;
GenTreePtr op2 = expr->gtOp.gtOp2;
/* NOTE - It may be that an indirection has the GTF_EXCEPT flag cleared so no side effect
* - What about range checks - are they marked as GTF_EXCEPT?
* UNDONE: For removed range checks do not extract them
*/
/* Look for side effects
* - Any assignment, GT_CALL, or operator that may throw
* (GT_IND, GT_DIV, GTF_OVERFLOW, etc)
* - Special case GT_ADDR which is a side effect */
if ((kind & GTK_ASGOP) ||
oper == GT_CALL || oper == GT_BB_QMARK || oper == GT_BB_COLON ||
expr->OperMayThrow())
{
/* Add the side effect to the list and return */
*list = (*list == 0) ? expr : gtNewOperNode(GT_COMMA, TYP_VOID, expr, *list);
#ifdef DEBUG
if (verbose && 0)
{
printf("Adding extracted side effects to the list:\n");
gtDispTree(expr);
printf("\n");
}
#endif
return;
}
if (kind & GTK_LEAF)
return;
assert(kind & GTK_SMPOP);
/* @MIHAII - Special case - GT_ADDR of GT_IND nodes of TYP_STRUCT
* have to be kept together
* CONSIDER: - This is a hack, remove after we fold this special construct */
if (oper == GT_ADDR)
{
assert(op1);
if (op1->gtOper == GT_IND && op1->gtType == TYP_STRUCT)
{
*list = (*list == 0) ? expr : gtNewOperNode(GT_COMMA, TYP_VOID, expr, *list);
#ifdef DEBUG
if (verbose)
printf("Keep the GT_ADDR and GT_IND together:\n");
#endif
}
return;
}
/* Continue searching for side effects in the subtrees of the expression
* NOTE: Be careful to preserve the right ordering - side effects are prepended
* to the list */
if (op2) gtExtractSideEffList(op2, list);
if (op1) gtExtractSideEffList(op1, list);
#ifdef DEBUG
/* Just to make sure side effects were not swapped */
if (expr->gtFlags & GTF_REVERSE_OPS)
{
assert(op1 && op2);
if (op1->gtFlags & GTF_SIDE_EFFECT)
assert(!(op2->gtFlags & GTF_SIDE_EFFECT));
}
#endif
}
/*****************************************************************************/
#if CSELENGTH
struct treeRmvDsc
{
GenTreePtr trFirst;
#ifndef NDEBUG
void * trSelf;
Compiler* trComp;
#endif
unsigned trPhase;
};
int Compiler::fgRemoveExprCB(GenTreePtr tree,
void * p)
{
treeRmvDsc * desc = (treeRmvDsc*)p;
Assert(desc && desc->trSelf == desc, desc->trComp);
if (desc->trPhase == 1)
{
/* In the first phase we mark all the nodes as dead */
Assert((tree->gtFlags & GTF_DEAD) == 0, desc->trComp);
tree->gtFlags |= GTF_DEAD;
}
else
{
/* In the second phase we notice the first node */
if (!tree->gtPrev || !(tree->gtPrev->gtFlags & GTF_DEAD))
{
/* We've found the first node in the subtree */
desc->trFirst = tree;
return -1;
}
}
return 0;
}
/*****************************************************************************
*
* For debugging only - displays a tree node list and makes sure all the
* links are correctly set.
*/
#ifdef DEBUG
void dispNodeList(GenTreePtr list, bool verbose)
{
GenTreePtr last = 0;
GenTreePtr next;
if (!list)
return;
for (;;)
{
next = list->gtNext;
if (verbose)
printf("%08X -> %08X -> %08X\n", last, list, next);
assert(!last || last->gtNext == list);
assert(next == 0 || next->gtPrev == list);
if (!next)
break;
last = list;
list = next;
}
fflush(stdout);
}
#endif
/*****************************************************************************
*
* Given a subtree and the head of the tree node list that contains it,
* remove all the nodes in the subtree from the list.
*
* When 'dead' is non-zero on entry, all the nodes in the subtree have
* already been marked with GTF_DEAD.
*/
void Compiler::fgRemoveSubTree(GenTreePtr tree,
GenTreePtr list,
bool dead)
{
GenTreePtr opr1;
GenTreePtr next;
GenTreePtr prev;
assert(list && list->gtOper == GT_STMT);
#if 0
printf("Remove subtree %08X from:\n", tree);
gtDispTree(list);
printf("\n");
dispNodeList(list->gtStmt.gtStmtList, true);
printf("\n\n");
#endif
/* Are we just removing a leaf node? */
if (tree->OperIsLeaf())
{
opr1 = tree;
goto RMV;
}
/* Special easy case: unary operator with a leaf sub-operand */
if (tree->OperKind() & GTK_SMPOP)
{
opr1 = tree->gtOp.gtOp1;
if (!tree->gtOp.gtOp2 && opr1->OperIsLeaf())
{
/* This is easy: the order is simply "prev -> opr1 -> tree -> next */
assert(opr1->gtNext == tree);
assert(tree->gtPrev == opr1);
goto RMV;
}
}
treeRmvDsc desc;
/* This is a non-trivial subtree, we'll remove it "the hard way" */
#ifndef NDEBUG
desc.trFirst = 0;
desc.trSelf = &desc;
desc.trComp = this;
#endif
/* First phase: mark the nodes in the subtree as dead */
if (!dead)
{
desc.trPhase = 1;
fgWalkTree(tree, fgRemoveExprCB, &desc);
}
/* Second phase: find the first node of the subtree within the global list */
desc.trPhase = 2;
fgWalkTree(tree, fgRemoveExprCB, &desc);
/* The second phase should have located the first node */
opr1 = desc.trFirst; assert(opr1);
RMV:
/* At this point, our subtree starts at "opr1" and ends at "tree" */
next = tree->gtNext;
prev = opr1->gtPrev;
/* Set the next node's prev field */
next->gtPrev = prev;
/* Is "opr1" the very first node in the tree list? */
if (prev == NULL)
{
/* Make sure the list indeed starts at opr1 */
assert(list->gtStmt.gtStmtList == opr1);
/* We have a new start for the list */
list->gtStmt.gtStmtList = next;
}
else
{
/* Not the first node, update the previous node's next field */
opr1->gtPrev->gtNext = next;
}
#if 0
printf("Subtree is gone:\n");
dispNodeList(list%08X->gtStmt.gtStmtList, true);
printf("\n\n\n");
#endif
}
#endif
/*
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
XX XX
XX BasicBlock XX
XX XX
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
*/
#if MEASURE_BLOCK_SIZE
/* static */
size_t BasicBlock::s_Size;
/* static */
size_t BasicBlock::s_Count;
#endif
#ifdef DEBUG
// The max # of tree nodes in any BB
/* static */
unsigned BasicBlock::s_nMaxTrees;
#endif
/*****************************************************************************
*
* Allocate a basic block but don't append it to the current BB list.
*/
BasicBlock * Compiler::bbNewBasicBlock(BBjumpKinds jumpKind)
{
BasicBlock * block;
/* Allocate the block descriptor and zero it out */
block = (BasicBlock *) compGetMem(sizeof(*block));
#if MEASURE_BLOCK_SIZE
BasicBlock::s_Count += 1;
BasicBlock::s_Size += sizeof(*block);
#endif
// ISSUE: The following memset is pretty expensive - do something else?
memset(block, 0, sizeof(*block));
// scopeInfo needs to be able to differentiate between blocks which
// correspond to some IL opcodes (and so may have some LocalVarInfo
// boundaries), or have been inserted by the JIT
// block->bbCodeSize = 0; // The above memset() does this
/* Give the block a number, set the ancestor count and weight to 1 */
block->bbNum = ++fgBBcount;
block->bbRefs = 1;
block->bbWeight = 1;
block->bbStkTemps = NO_BASE_TMP;
/* Record the jump kind in the block */
block->bbJumpKind = jumpKind;
return block;
}
/*****************************************************************************
*
* Find an unconditional jump block that follows the given one; if one isn't
* found, return 0.
*/
BasicBlock * BasicBlock::FindJump(bool allowThrow)
{
BasicBlock *block = this;
while (block)
{
switch (block->bbJumpKind)
{
case BBJ_THROW:
if (!allowThrow) break;
// fall through
case BBJ_RET:
case BBJ_RETURN:
case BBJ_ALWAYS:
/* Do not insert in front of catch handler */
if (block->bbNext && block->bbNext->bbCatchTyp)
break;
return block;
}
block = block->bbNext;
}
return block;
}
/*****************************************************************************
*
* If the given block is an unconditional jump, return the (final) jump
* target (otherwise simply return the same block).
*/
/* static */
BasicBlock * BasicBlock::JumpTarget()
{
BasicBlock *block = this;
int i = 0;
while (block->bbJumpKind == BBJ_ALWAYS &&
block->bbTreeList == 0)
{
if (i > 64) // break infinite loops
break;
block = block->bbJumpDest;
i++;
}
return block;
}
|
80e3a33336ed755f435af5b04c8f7e542f6ca833 | a7ddb56f634c0e2138a1856327ef698ce1d94a42 | /Hashira/Engine/Source/Component/DefaultComponents/DefaultGraphicsComponent.cpp | 2658bd12dd25018f8ea20407ba94c7fd79141465 | [] | no_license | Onbashira/Hashira | 3c84482a4c688bf762a8925ed4d4aa043cc06e91 | e5fb75800c2634c7079676e38e9711948b925137 | refs/heads/master | 2020-06-02T23:11:30.516684 | 2019-08-08T06:40:32 | 2019-08-08T06:40:32 | 191,338,620 | 3 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 195 | cpp | DefaultGraphicsComponent.cpp | #include "stdafx.h"
#include "DefaultGraphicsComponent.h"
Hashira::DefaultGraphicsComponent::DefaultGraphicsComponent()
{
}
Hashira::DefaultGraphicsComponent::~DefaultGraphicsComponent()
{
}
|
3b517bab3d29976210fecb3c502e8657f4ee7392 | 8a399f51abf9807a77e94f5e083968f431a964d0 | /Gancsos_Abel_Project/src/classes/amgpetagencycommon/amgbreed.cpp | 0e948312b9ede0681c3f83f27f96ad52058998da | [
"MIT"
] | permissive | agancsos2/METCS665 | e5f07c16b1c46b495e26c2f87940deec775997de | 9b0d9fd5a81ad657e41ac830ce652b76d41e7b83 | refs/heads/master | 2020-03-22T04:21:54.358250 | 2018-08-08T04:01:42 | 2018-08-08T04:01:42 | 139,493,071 | 0 | 0 | null | 2018-07-03T00:54:44 | 2018-07-02T20:48:34 | null | UTF-8 | C++ | false | false | 2,811 | cpp | amgbreed.cpp | #include "amgbreed.h"
namespace amgpetagencycommon {
/**
* This is the default constructor
* @precondition (There is a need for a new instance of the class)
* @postcondition (A new instance of the object is created)
*/
AMGBreed::AMGBreed(){
this->name = "";
this->father_breed = shared_ptr<AMGBreed>(new AMGBreed(""));
this->mother_breed = shared_ptr<AMGBreed>(new AMGBreed(""));
}
/**
* This is the deconstructor
* @postcondition (The instance of the object is removed from memory)
*/
AMGBreed::~AMGBreed(){
}
/**
* This is the common constructor
* @param name Name of the breed
* @precondition (There is a need for a new instance of the class)
* @postcondition (A new instance of the object is created)
*/
AMGBreed::AMGBreed(string name){
this->name = name;
}
/**
* This method sets the father breed
* @param a Father breed
* @precondition (The instance of the object exists)
* @postcondition (The father breed is set)
*/
void AMGBreed::SetFatherBreed(shared_ptr<AMGBreed> a){
father_breed = a;
}
/**
* This method sets the mother breed
* @param a Mother breed
* @precondition (The instance of the object exists)
* @postcondition (The mother breed is set)
*/
void AMGBreed::SetMotherBreed(shared_ptr<AMGBreed> a){
mother_breed = a;
}
/**
* This method gets the father breed
* @return Father breed
* @precondition (The instance of the object exists)
* @postcondition (The father breed is returned)
*/
shared_ptr<AMGBreed> AMGBreed:: GetFatherBreed(){
return father_breed;
}
/**
* This method gets the mother breed
* @return Mother breed
* @precondition (The instance of the object exists)
* @postcondition (The mother breed is returned)
*/
shared_ptr<AMGBreed> AMGBreed::GetMotherBreed(){
return mother_breed;
}
/**
* This method gets the name of the breed
* @return The name of the breed
* @precondition (The instance of the object exists)
* @postcondition (The name is returned)
*/
string AMGBreed::GetName(){
return name;
}
/**
* This method returns a string representation of the object
* @return String representation of the object
* @precondition (The instance of the object exists)
* @postcondition (The string representation of the object)
*/
string AMGBreed::ToString(){
string breed_name = "(";
breed_name += ("Name: " + name);
breed_name += (";Father: " + (this->father_breed ? this->father_breed->GetName() : ""));
breed_name += (";Mother: " + (this->mother_breed ? this->mother_breed->GetName() : ""));
breed_name += ")";
return breed_name;
}
}
|
b89183c842e18060bbe88141ea381543fc1c1685 | 3ccfec2da8e1ed37bf6c5d36084b6c18a20ef96b | /src/lumps.cpp | 94fccb87ec9f3f6a9208ff0efa138e1575f20f5a | [
"BSD-2-Clause"
] | permissive | Puche/CoD-BSP-Decompiler | 23f11eb7dd9db260c5e8ca66d6e5b8d95c83c480 | e74a65bbe8909abb2572bb2db28db4c1790b5b57 | refs/heads/master | 2023-04-01T23:30:32.466412 | 2015-04-15T03:07:40 | 2015-04-15T03:07:40 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 6,873 | cpp | lumps.cpp | #include "lumps.hpp"
#include "console.hpp"
#include "common.hpp"
#include <cmath>
using namespace BSP;
void write_raw_lumps(BSP_Handle *bsp, const std::string &path)
{
printf("Exporting raw lumps...");
retrieve_cursor_position();
unsigned int n = 0;
std::vector<Index>::iterator it;
for (it = bsp->index.begin(); it < bsp->index.end(); it++)
{
restore_cursor_position();
printf("%3.0f%%", ceil(((float) n / bsp->index.size()) * 100.0f));
if ((*it).size)
{
LumpReference reference = UNKNOWN;
if (bsp->lump_reference.find((*it).id) != bsp->lump_reference.end())
{
reference = bsp->lump_reference[(*it).id];
}
std::string filename(path);
if ((*it).id < 10)
{
filename += '0';
}
filename += to_str((*it).id) + "_" + LumpName[reference] + ".lump";
FILE *output = fopen(filename.c_str(), "wb+");
if (!output)
{
fprintf(stderr, "ERROR: Could not write to `%s'.\n\n", filename.c_str());
}
else
{
fwrite(bsp->data.buffer + (*it).offset, 1, (*it).size, output);
fclose(output);
}
}
n++;
}
restore_cursor_position();
printf("100%%\n");
}
void write_bsp(BSP_Handle *bsp, const std::string &path, std::string filename, bool export_html)
{
printf("Exporting BSP...");
retrieve_cursor_position();
if (export_html)
{
filename = path + filename + ".html";
}
else
{
filename = path + filename + ".txt";
}
FILE *output = fopen(filename.c_str(), "wb+");
if (!output)
{
fprintf(stderr, "ERROR: Could not write to `%s'.\n", filename.c_str());
}
else
{
std::vector<Index>::iterator it;
if (export_html)
{
fprintf(output, "<?xml version=\"1.0\" encoding=\"utf-8\" ?>\n<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.1//EN\" \"http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd\"><html xmlns=\"http://www.w3.org/1999/xhtml\" xml:lang=\"de\">\n<head>\n<title>BSP export - %s</title>\n<link rel=\"stylesheet\" type=\"text/css\" media=\"screen,print\" href=\"../../export.css\">\n</head>\n<body>\n<div id=\"all\">\n<h1>%s</h1>\n", bsp->map.c_str(), bsp->map.c_str());
fprintf(output, "<div>");
for (it = bsp->index.begin(); it < bsp->index.end(); it++)
{
if (bsp->lump_reference.find((*it).id) != bsp->lump_reference.end() && (*it).size)
{
fprintf(output, "<a href=\"#lump_%u\">%s</a> ", (*it).id, LumpName[bsp->lump_reference[(*it).id]]);
}
}
fprintf(output, "</div>\n");
}
unsigned int n = 0;
for (it = bsp->index.begin(); it < bsp->index.end(); it++)
{
restore_cursor_position();
printf("%3.0f%%", ceil(((float) n / bsp->index.size()) * 100.0f));
if (bsp->lump_reference.find((*it).id) != bsp->lump_reference.end())
{
LumpReference reference = bsp->lump_reference[(*it).id];
if ((*it).size && bsp->size(reference))
{
if (export_html)
{
fprintf(output, "<h2 id=\"lump_%u\">Lump %u - %s (%u)</h2><div><pre>", (*it).id, (*it).id, LumpName[reference], bsp->size(reference));
bsp->write(output, reference);
fprintf(output, "</pre></div>");
}
else
{
fprintf(output, "Lump %u - %s (%u)\r\n", (*it).id, LumpName[reference], bsp->size(reference));
bsp->write(output, reference);
fprintf(output, "\r\n\r\n");
}
}
}
n++;
}
if (export_html)
{
fprintf(output, "</div></body></html>");
}
fclose(output);
}
restore_cursor_position();
printf("100%%\n");
}
void write_lumps(BSP_Handle *bsp, const std::string &path, bool export_html)
{
printf("Exporting lumps...");
retrieve_cursor_position();
unsigned int n = 0;
std::vector<Index>::iterator it;
for (it = bsp->index.begin(); it < bsp->index.end(); it++)
{
restore_cursor_position();
printf("%3.0f%%", ceil(((float) n / bsp->index.size()) * 100.0f));
if (bsp->lump_reference.find((*it).id) != bsp->lump_reference.end())
{
LumpReference reference = bsp->lump_reference[(*it).id];
if ((*it).size && bsp->size(reference))
{
std::string tmp_filename(path);
if ((*it).id < 10)
{
tmp_filename += '0';
}
if (export_html)
{
tmp_filename += to_str((*it).id) + "_" + LumpName[reference] + ".html";
}
else
{
tmp_filename += to_str((*it).id) + "_" + LumpName[reference] + ".txt";
}
FILE *output = fopen(tmp_filename.c_str(), "wb+");
if (!output)
{
fprintf(stderr, "ERROR: Could not write to `%s'.\n", tmp_filename.c_str());
}
else
{
if (export_html)
{
fprintf(output, "<?xml version=\"1.0\" encoding=\"utf-8\" ?>\n<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.1//EN\" \"http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd\"><html xmlns=\"http://www.w3.org/1999/xhtml\" xml:lang=\"de\">\n<head>\n<title>Lump %u export - %s</title>\n<link rel=\"stylesheet\" type=\"text/css\" media=\"screen,print\" href=\"../../../export.css\">\n</head>\n<body>\n<div id=\"all\">\n<h1>%s</h1>\n", (*it).id, bsp->map.c_str(), bsp->map.c_str());
fprintf(output, "<h2 id=\"lump_%u\">Lump %u - %s (%u)</h2><div><pre>", (*it).id, (*it).id, LumpName[reference], bsp->size(reference));
bsp->write(output, reference);
fprintf(output, "</pre></div>");
fprintf(output, "</div></body></html>");
}
else
{
fprintf(output, "Lump %u - %s (%u)\r\n", (*it).id, LumpName[reference], bsp->size(reference));
bsp->write(output, reference);
}
fclose(output);
}
}
}
n++;
}
restore_cursor_position();
printf("100%%\n");
}
|
6faed9e98a5f0e8576e0a1dc6024ffdb3ad2e7e0 | 8883a445b263796f1385ded325ad0d795560c2fb | /Week4/CMP105App/Framework/Background.cpp | 849dda6df950796230da67044d4b157a764dbdd0 | [] | no_license | TheDuplicity/CMP105_W4 | e80f55607294c1bb7023d9ef70e85c2d2d4cca70 | 32f19bdfb1b64b80422ee0cd73fbce5438a01c12 | refs/heads/master | 2020-12-29T23:42:13.809684 | 2020-02-07T22:23:14 | 2020-02-07T22:23:14 | 238,781,011 | 0 | 0 | null | 2020-02-06T20:44:08 | 2020-02-06T20:44:07 | null | UTF-8 | C++ | false | false | 125 | cpp | Background.cpp | #include "BackGround.h";
Background::Background() {
}
Background::~Background() {
}
void Background::update(float dt) {
} |
33cc3988c197815c2aa892891c8d4d81639d133d | 777a75e6ed0934c193aece9de4421f8d8db01aac | /src/Providers/UNIXProviders/VoltageSensor/UNIX_VoltageSensor_LINUX.hxx | 40ba72146132a9c7dfc8990f622929ab7d9601ad | [
"MIT"
] | permissive | brunolauze/openpegasus-providers-old | 20fc13958016e35dc4d87f93d1999db0eae9010a | b00f1aad575bae144b8538bf57ba5fd5582a4ec7 | refs/heads/master | 2021-01-01T20:05:44.559362 | 2014-04-30T17:50:06 | 2014-04-30T17:50:06 | 19,132,738 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 122 | hxx | UNIX_VoltageSensor_LINUX.hxx | #ifdef PEGASUS_OS_LINUX
#ifndef __UNIX_VOLTAGESENSOR_PRIVATE_H
#define __UNIX_VOLTAGESENSOR_PRIVATE_H
#endif
#endif
|
38e1848422f1f4e34eeb9d99270e4d98a06e68f6 | cae63dae21561c4f39481278390f565ec5c419ec | /c++11/aula62 Container Map - smart pointer.cpp | 97702b9e8ef3b5c793f6ff16286b46c6044f077e | [] | no_license | HRsniper/CPP | d48f16159c5439febbf3bce8eb1445320704b251 | 86e5928292a05df6c332558c0b8240a66ae3aeee | refs/heads/main | 2023-08-22T17:57:16.941360 | 2021-10-16T19:02:29 | 2021-10-16T19:02:29 | 308,703,801 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,747 | cpp | aula62 Container Map - smart pointer.cpp | #include <iostream>
#include <memory>
using namespace std;
//-----------------------------------------------------
//class para unique_ptr
class carro{
public:
int vel=0;
int getvel(){
return vel;
}
void setvel(int v){// funçao para shared_ptr mudar vel
this->vel=v;
}
};
//-----------------------------------------------------
int main(){
//-----------------------------------------------------
//poteiro normal
//int *pnum; int num; num=10; pnum=#//&=endereço
//ponterio normal versao curta
int *pnum=new int(); *pnum=10;
cout<<"*P normal valor: "<<*pnum<<" - "<<"endereco: "<<pnum<<endl;
delete pnum;
//-----------------------------------------------------
cout << endl;
//-----------------------------------------------------
//smart pointer
//unique_ptr<int> stp(new int); *stp=10;
unique_ptr <int> stp(new int(10));// ele so poder ser usado um por vez
cout << "unique_ptr valor: " << *stp << " - " << "endereco: " << &stp << "\n\n";
//-----------------------------------------------------
shared_ptr <int> stp2(new int(10));// pode ser compartilhado
shared_ptr <int> stp3=stp2;
cout << "shared_ptr2 valor: " << *stp2 << " - " << "endereco: " << &stp2 << "\n";
cout << "shared_ptr3 valor: " << *stp3 << " - " << "endereco: " << &stp3 << "\n";
//-----------------------------------------------------
cout << endl;
//-----------------------------------------------------
/* //normal
string *nstring0(new string ("HRsniper"));
cout << "UNI string valor: " << *nstring0 << " - " << "UNI string tamanho: " << nstring0->size() << "\n";
delete nstring0;
*/
unique_ptr <string> nstring(new string ("HRsniper"));
cout << "UNI string valor: " << *nstring << " - " << "UNI string tamanho: " << nstring->size() << "\n";
//-----------------------------------------------------
cout << endl;
//-----------------------------------------------------
/* //normal
carro *c1=new carro();
cout << "vel: " << c1->getvel() << "\n";
delete c1;
*/
unique_ptr <carro> c1(new carro);
cout << "vel c1: " << c1->getvel() << "\n";
//-----------------------------------------------------
unique_ptr <carro> c2(new carro);
c2->setvel(50);
cout << "vel c2: " << c2->getvel() << "\n";
//-----------------------------------------------------
cout << endl;
//-----------------------------------------------------
shared_ptr <carro> c3(new carro);
shared_ptr <carro> c4=c3;
c3->setvel(100);
cout << "vel c3: " << c3->getvel() << "\n";
cout << "vel c4: " << c4->getvel() << "\n";
//-----------------------------------------------------
//-----------------------------------------------------
cout << endl;
system("pause");
return 0;
}
|
223a228694061faf99c37de13bb8137703883825 | ffb789dd717001da2da181593ecb562f19a210d0 | /src/screen/DemoScreen.cpp | f35e6a2f5e01769e5f861c8471236f8199cb3663 | [] | no_license | lithium/ym2612-synth | 26c7188667ed1ae7dcaee85c91b4adfd99eae27e | b541d01ccdc4cfb228a8f1a8fb17d27985530fb2 | refs/heads/master | 2020-03-12T16:49:05.209826 | 2018-06-15T05:33:44 | 2018-06-15T05:33:44 | 130,724,284 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,590 | cpp | DemoScreen.cpp |
#include "DemoScreen.h"
auto width = 40;
auto height = 20;
auto padding = 2;
#define num_enc_demos ENCODER_COUNT
DemoWidget enc_demos[num_enc_demos];
DemoWidget btn_demos[ANALOG_BUTTON_COUNT];
DemoWidget touch_demos[2];
DemoScreen::DemoScreen()
{
auto x = 110;
auto y = 20;
for (int i=0; i < num_enc_demos; i++) {
enc_demos[i].setBounds(x, y, width, height);
addWidget(&enc_demos[i]);
y += height+padding;
}
x = 240;
y = 20;
for (int i=0; i < ANALOG_BUTTON_COUNT; i++) {
btn_demos[i].setBounds(x, y, width, height);
addWidget(&btn_demos[i]);
y += height + padding;
}
for (int i=0; i < 2; i++) {
touch_demos[i].setBounds(x, y, width, height);
addWidget(&touch_demos[i]);
y += height + padding;
}
}
void DemoScreen::paint()
{
Serial.println("paint it ");
tft.fillScreen(ILI9341_BLACK);
tft.setTextSize(2);
tft.setTextColor(ILI9341_WHITE);
auto x = 20;
auto y = 20;
for (int i=0; i < num_enc_demos; i++) {
tft.setCursor(x,y);
tft.print("ENC #");
tft.print(i+1);
tft.print(": ");
y += height+padding;
}
x = 150;
y = 20;
for (int i=0; i < ANALOG_BUTTON_COUNT; i++) {
tft.setCursor(x,y);
tft.print("BTN #");
tft.print(i+1);
tft.print(": ");
y += height+padding;
}
y += padding*2;
tft.setCursor(x,y);
tft.print("TOUCHX:");
y += height+padding;
tft.setCursor(x,y);
tft.print("TOUCHY:");
repaint();
}
void DemoScreen::encoderTurned(int direction, GpioEncoder *e)
{
int enc = get_encoder_number(e);
Serial.print("encoder #");
Serial.print(enc+1);
Serial.print(" turned ");
Serial.println(direction == 1 ? "right" : "left");
DemoWidget *dw = &enc_demos[enc];
dw->counter += direction;
dw->setDirty(true);
repaint();
}
void DemoScreen::buttonPressed(Button *b)
{
int btn = b->number;
Serial.print("btn pressed #");
Serial.print(btn+1);
DemoWidget *dw = &btn_demos[btn % ANALOG_BUTTON_COUNT];
dw->counter += 1;
dw->setDirty(true);
repaint();
}
void DemoScreen::screenTouched(TS_Point p)
{
touch_demos[0].counter = p.x / 10;
touch_demos[0].setDirty();
touch_demos[1].counter = p.y / 10;
touch_demos[1].setDirty();
repaint();
}
void DemoWidget::paint() {
tft.fillRect(x, y, w, h, ILI9341_BLACK);
tft.setTextSize(2);
tft.setTextColor(ILI9341_WHITE);
tft.setCursor(x, y);
tft.print(counter);
} |
f67179ff881b269cd6d3243da4b7691e3948573e | e3505cfd86c57b1869c2885a3a44550af552d483 | /source/resource/view/Primitives/cxDepthPeeling.cpp | 6da8afefc2681ae47e0c38fba189c496d041b629 | [
"BSD-3-Clause"
] | permissive | leettran/CustusX | afb6a3bc6607bf28fa1c94f94b66cf9979728cd5 | b4e64e0db364da189ee9eafa54ce0ab258f5105a | refs/heads/master | 2021-07-14T03:33:55.038281 | 2017-02-09T09:29:57 | 2017-02-09T09:29:57 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 7,623 | cpp | cxDepthPeeling.cpp | /*=========================================================================
This file is part of CustusX, an Image Guided Therapy Application.
Copyright (c) 2008-2014, SINTEF Department of Medical Technology
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
1. Redistributions of source code must retain the above copyright notice,
this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation
and/or other materials provided with the distribution.
3. Neither the name of the copyright holder nor the names of its contributors
may be used to endorse or promote products derived from this software
without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
=========================================================================*/
#include "cxDepthPeeling.h"
#include "cxLogger.h"
/**
* Generate a bunch of overlapping spheres within one poly data set:
* one big sphere evenly surrounded by four small spheres that intersect the
* centered sphere.
* @param theta sphere sampling resolution (THETA)
* @param phi sphere sampling resolution (PHI)
* @return the set of spheres within one logical poly data set
**/
vtkSmartPointer<vtkAppendPolyData> GenerateOverlappingBunchOfSpheres(int theta, int phi)
{
vtkSmartPointer<vtkAppendPolyData> appendData =
vtkSmartPointer<vtkAppendPolyData>::New();
for (int i = 0; i < 5; i++)
{
vtkSmartPointer<vtkSphereSource> sphereSource =
vtkSmartPointer<vtkSphereSource>::New();
sphereSource->SetThetaResolution(theta);
sphereSource->SetPhiResolution(phi);
sphereSource->SetRadius(0.5); // all spheres except the center
// one should have radius = 0.5
switch (i)
{
case 0:
sphereSource->SetRadius(1);
sphereSource->SetCenter(0, 0, 0); break;
case 1:
sphereSource->SetCenter(1, 0, 0); break;
case 2:
sphereSource->SetCenter(-1, 0, 0); break;
case 3:
sphereSource->SetCenter(0, 1, 0); break;
case 4:
sphereSource->SetCenter(0, -1, 0); break;
}
sphereSource->Update();
appendData->AddInputConnection(sphereSource->GetOutputPort());
}
return appendData;
}
/**
* Setup the rendering environment for depth peeling (general depth peeling
* support is requested).
* @see IsDepthPeelingSupported()
* @param renderWindow a valid openGL-supporting render window
* @param renderer a valid renderer instance
* @param maxNoOfPeels maximum number of depth peels (multi-pass rendering)
* @param occlusionRatio the occlusion ration (0.0 means a perfect image,
* >0.0 means a non-perfect image which in general results in faster rendering)
* @return TRUE if depth peeling could be set up
*/
bool SetupEnvironmentForDepthPeeling(
vtkSmartPointer<vtkRenderWindow> renderWindow,
vtkSmartPointer<vtkRenderer> renderer, int maxNoOfPeels,
double occlusionRatio)
{
if (!renderWindow || !renderer)
{
cx::reportWarning("Can't set depth peeling. No render / renderwindow");
return false;
}
// 1. Use a render window with alpha bits (as initial value is 0 (false)):
renderWindow->SetAlphaBitPlanes(true);
// 2. Force to not pick a framebuffer with a multisample buffer
// (as initial value is 8):
renderWindow->SetMultiSamples(0);
// 3. Choose to use depth peeling (if supported) (initial value is 0 (false)):
renderer->SetUseDepthPeeling(true);
// 4. Set depth peeling parameters
// - Set the maximum number of rendering passes (initial value is 4):
renderer->SetMaximumNumberOfPeels(maxNoOfPeels);
// - Set the occlusion ratio (initial value is 0.0, exact image):
renderer->SetOcclusionRatio(occlusionRatio);
// Do a test render
renderWindow->Render();
// Check whether depth peeling was used
bool success = renderer->GetLastRenderingUsedDepthPeeling();
return success;
}
bool TurnOffDepthPeeling(
vtkSmartPointer<vtkRenderWindow> renderWindow,
vtkSmartPointer<vtkRenderer> renderer)
{
if (!renderWindow || !renderer)
{
cx::reportWarning("Can't turn off depth peeling. No render / renderwindow");
return false;
}
// Set values back to defaults
// TODO: Save defaults (see IsDepthPeelingSupported())
renderWindow->SetAlphaBitPlanes(false);
renderWindow->SetMultiSamples(8);
renderer->SetUseDepthPeeling(false);
renderer->SetMaximumNumberOfPeels(4);
renderer->SetOcclusionRatio(0.0);
return true;
}
/**
* Find out whether this box supports depth peeling. Depth peeling requires
* a variety of openGL extensions and appropriate drivers.
* @param renderWindow a valid openGL-supporting render window
* @param renderer a valid renderer instance
* @param doItOffScreen do the test off screen which means that nothing is
* rendered to screen (this requires the box to support off screen rendering)
* @return TRUE if depth peeling is supported, FALSE otherwise (which means
* that another strategy must be used for correct rendering of translucent
* geometry, e.g. CPU-based depth sorting)
*/
bool IsDepthPeelingSupported(vtkSmartPointer<vtkRenderWindow> renderWindow,
vtkSmartPointer<vtkRenderer> renderer, bool doItOffScreen)
{
if (!renderWindow || !renderer)
{
cx::reportWarning("Can't test depth peeling. No render / renderwindow");
return false;
}
bool success = true;
// Save original renderer / render window state
bool origOffScreenRendering = renderWindow->GetOffScreenRendering() == 1;
bool origAlphaBitPlanes = renderWindow->GetAlphaBitPlanes() == 1;
int origMultiSamples = renderWindow->GetMultiSamples();
bool origUseDepthPeeling = renderer->GetUseDepthPeeling() == 1;
int origMaxPeels = renderer->GetMaximumNumberOfPeels();
double origOcclusionRatio = renderer->GetOcclusionRatio();
// Activate off screen rendering on demand
renderWindow->SetOffScreenRendering(doItOffScreen);
// Setup environment for depth peeling (with some default parametrization)
success = success && SetupEnvironmentForDepthPeeling(renderWindow, renderer,
100, 0.1);
// Do a test render
renderWindow->Render();
// Check whether depth peeling was used
success = success && renderer->GetLastRenderingUsedDepthPeeling();
// recover original state
renderWindow->SetOffScreenRendering(origOffScreenRendering);
renderWindow->SetAlphaBitPlanes(origAlphaBitPlanes);
renderWindow->SetMultiSamples(origMultiSamples);
renderer->SetUseDepthPeeling(origUseDepthPeeling);
renderer->SetMaximumNumberOfPeels(origMaxPeels);
renderer->SetOcclusionRatio(origOcclusionRatio);
return success;
}
|
08bf35570b859a828bba87c82ce10be674c6a20a | e6d2fa803344cdce7375bbb3b9d0b9643aff58d6 | /110-balanced-binary-tree/main.cc | 51683a23fce9820fb1a181d505a9fecf14a17a48 | [] | no_license | ArisQ/leetcode | 511303d22defc584ff1fe410ae79bca8376d0a29 | 023894242fc36f7b7e67ed33926858c09d27618b | refs/heads/master | 2020-04-04T23:09:18.712895 | 2020-02-28T03:30:43 | 2020-02-28T03:30:43 | 156,348,900 | 0 | 0 | null | 2019-08-13T14:11:57 | 2018-11-06T08:13:24 | C++ | UTF-8 | C++ | false | false | 995 | cc | main.cc | #define CATCH_CONFIG_MAIN
#include <catch.hpp>
#include "tree_node.h"
using namespace std;
class Solution {
public:
bool isBalanced(TreeNode *root) {
return balancedDepth(root) != -1;
}
//return depth if balanced else -1
int balancedDepth(TreeNode *root) {
if (root == nullptr)
return 0;
int left = balancedDepth(root->left);
int right = balancedDepth(root->right);
if (left == -1 || right == -1)
return -1;
if (left == right + 1 || left == right)
return left + 1;
if (right == left + 1)
return right + 1;
return -1;
}
};
TEST_CASE("Balanced Binary Tree - Example 1") {
auto input = makeTree({3, 9, 20, nullptr, nullptr, 15, 7});
REQUIRE(Solution().isBalanced(input) == true);
}
TEST_CASE("Balanced Binary Tree - Example 2") {
auto input = makeTree({1, 2, 2, 3, 3, nullptr, nullptr, 4, 4});
REQUIRE(Solution().isBalanced(input) == false);
}
|
1862296756cf94831f3cd29898e8611c6ece3942 | 3a80805f6eb9addd18c8ce0aa060559ccb8e512a | /code/Mammal6.cpp | 69f0ac344890ee13b8b0c06054f89290551fc11a | [
"MIT"
] | permissive | formertrainer/tyc-24h | bfa24fd9df1b863aca9a42e0830c4d921b5d00d1 | 4e6f477d0a5ba32a8b4dbabf2470f2ae815dfeae | refs/heads/master | 2021-01-10T11:39:49.909358 | 2016-02-07T16:00:41 | 2016-02-07T16:00:41 | 51,253,016 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 965 | cpp | Mammal6.cpp | // this is the real thing, as in, a real error.
// a base class method is going to be overriden, but since it exists in two versions,
// two versions are now unavailable to the derived class.
// That's either an oversight or an error OR because the derived class should never call
// that function: the base class function is therefore hidden on purpose.
// NB: gcc does NOT produce a warning, even with -Wall.
#include <iostream>
class Mammal
{
protected:
int age;
int weight;
public:
void move() const { std::cout << "Mammal moves one step\n"; }
void move(int distance) const { std::cout << "Mammal moves " << distance << " steps\n"; }
};
class Dog : public Mammal
{
public:
void move() const { std::cout << "Dog moves 5 steps\n"; }
};
int main()
{
Mammal bigAnimal;
Dog fido;
bigAnimal.move();
bigAnimal.move(3);
fido.move();
// fido.move(4); // This cannot work, the base method is overriden.
fido.Mammal::move(7); // UBER KLUDGE...
return 0;
}
|
472b3b6d424f12fceed625d3155b9c1f036ec008 | a6a27b93ae66358f7d609677f44134ddd1c38de6 | /include/kimiko/parser.h | 47d54b59664c16f5c52efbdec5c68c3439ee8624 | [
"MIT"
] | permissive | AperLambda/kimikopp | 646b5c4cf2cbd2a86a1e2e41b6b34255c5b897dd | 77496d52601515e114becd31fe304e6734935bf7 | refs/heads/master | 2020-03-21T00:27:57.099490 | 2018-11-30T16:14:12 | 2018-11-30T16:14:12 | 137,895,059 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 282 | h | parser.h | /*
* Copyright © 2018 AperLambda <aperlambda@gmail.com>
*
* This file is part of kimiko++.
*
* Licensed under the MIT license. For more information,
* see the LICENSE file.
*/
#ifndef KIMIKO_PARSER_H
#define KIMIKO_PARSER_H
namespace kimiko
{
}
#endif //KIMIKO_PARSER_H |
dee7e3d93576d552ac06c355e00d08fdd6d14565 | 5c1e71282aee85c4bf5a5783ef0f64b293ce2be7 | /src/pre_processing/preprocessor.cpp | 2e7342e630a2049d868c8a0e867944a1bf50f19e | [] | no_license | asad-ahmed-pk/advanced-project-1 | ec13fbd0edef622e5e8ccf03dcfb3eef8e323a09 | 84d660829df3b40e483cf2bf220cd28ca636bd58 | refs/heads/master | 2022-03-04T20:37:39.857769 | 2019-06-01T19:50:20 | 2019-06-01T19:50:20 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 5,526 | cpp | preprocessor.cpp | // preprocessor.cpp
#include "preprocessor.h"
#include "../visualisation/point_cloud_renderer.h"
#include "pcl/io/pcd_io.h"
#include "pcl/filters/passthrough.h"
#include "pcl/filters/statistical_outlier_removal.h"
#include "pcl/filters/extract_indices.h"
#include "pcl/filters/uniform_sampling.h"
#include "Eigen/Eigen"
#include <algorithm>
#include <vector>
#include <map>
#include <numeric>
// TGI threshold values to filter out vegetation
float Preprocessor::TGI_THRESHOLD_VALUE_MIN = 30.0f;
float Preprocessor::TGI_THRESHOLD_VALUE_MAX = 100.0f;
Preprocessor::Preprocessor()
{
}
// Pre-process
void Preprocessor::ProcessPointCloud(const pcl::PointCloud<PointDefaultType>::Ptr& cloud, VegetationIndex indexType, pcl::PointCloud<PointDefaultType>::Ptr& result) const
{
pcl::PointCloud<pcl::PointXYZI>::Ptr vegetationIndexedCloud(new pcl::PointCloud<pcl::PointXYZI>);
std::vector<float> intensities;
// apply one of the RGB vegetation indices and create a new point cloud
float intensity = 0.0f;
uint32_t filteredIndex = 0;
for (uint32_t i = 0; i < cloud->width; i++)
{
Eigen::Vector3f rgb(cloud->points[i].getRGBVector3i().x(), cloud->points[i].getRGBVector3i().y(), cloud->points[i].getRGBVector3i().z());
if (indexType == VegetationIndex::TGI) {
intensity = rgb[1] - 0.39f * rgb[0] - 0.61f * rgb[2];
}
else
{
float denom = (rgb[1] + rgb[0] - rgb[2]);
if (denom > 0.0f) {
intensity = (rgb[1] - rgb[0]) / denom;
}
else {
intensity = 0.0f;
}
}
intensities.push_back(intensity);
pcl::PointXYZI point(intensity);
point.x = cloud->points[i].x;
point.y = cloud->points[i].y;
point.z = cloud->points[i].z;
vegetationIndexedCloud->push_back(point);
}
std::cout << "\nMax Intesity: " << *std::max_element(intensities.begin(), intensities.end());
std::cout << "\nMin Intensity: " << *std::min_element(intensities.begin(), intensities.end());
std::cout << "\nAverage Intensity: " << std::accumulate(intensities.begin(), intensities.end(), 0.0f) / intensities.size();
std::cout << std::endl;
// write to disk
//pcl::io::savePCDFile("../../data/tgi_cloud.pcd", *vegetationIndexedCloud, true);
PointCloudRenderer renderer(vegetationIndexedCloud);
renderer.Render();
// filter out non-vegetation and remove noise
std::vector<uint32_t> removedIndices;
FilterOutNonVegetation(vegetationIndexedCloud, indexType, removedIndices);
RemoveNoise(vegetationIndexedCloud);
std::cout << "\nFiltered Indices After TGI: " << removedIndices.size();
std::cout << "\nOriginal Cloud Indices: " << cloud->points.size();
std::cout << std::endl;
// filter out the original RGB cloud with the indices that were used in the vegetation and noise filter
pcl::PointIndicesPtr removedIndicesPtr(new pcl::PointIndices);
removedIndicesPtr->indices.insert(removedIndicesPtr->indices.end(), removedIndices.begin(), removedIndices.end());
pcl::ExtractIndices<PointDefaultType> extract;
extract.setInputCloud(cloud);
extract.setIndices(removedIndicesPtr);
extract.setNegative(true);
extract.filter(*result);
}
// Filter out non vegetation. This will be based on the intensity values and the vegetation index used.
void Preprocessor::FilterOutNonVegetation(pcl::PointCloud<pcl::PointXYZI>::Ptr &cloud, VegetationIndex indexType, std::vector<uint32_t>& removedIndices) const
{
// height filter
const float HEIGHT_FILTER_VALUE_MIN { 10.0f };
const float HEIGHT_FILTER_VALUE_MAX { 100.0f };
// intensity filter
pcl::PassThrough<pcl::PointXYZI> pass(true);
pass.setInputCloud(cloud);
pass.setFilterFieldName("intensity");
if (indexType == VegetationIndex::TGI) {
pass.setFilterLimits(Preprocessor::TGI_THRESHOLD_VALUE_MIN, Preprocessor::TGI_THRESHOLD_VALUE_MAX);
}
else {
std::cerr << "\nError: Only TGI filtering supported!" << std::endl;
return;
}
pass.filter(*cloud);
pass.getRemovedIndices();
// track indices that were removed
removedIndices.insert(removedIndices.end(), pass.getRemovedIndices()->begin(), pass.getRemovedIndices()->end());
// second pass - height filter
pcl::PassThrough<pcl::PointXYZI> heightPass;
heightPass.setInputCloud(cloud);
heightPass.setFilterFieldName("z");
heightPass.setFilterLimits(HEIGHT_FILTER_VALUE_MIN, HEIGHT_FILTER_VALUE_MAX);
heightPass.filter(*cloud);
}
// Is vegetation point
bool Preprocessor::IsPointVegetationPoint(const PointDefaultType& point)
{
// calculate TGI
Eigen::Vector3i rgb = point.getRGBVector3i();
float intensity = rgb[1] - 0.39f * rgb[0] - 0.61f * rgb[2];
return (intensity >= Preprocessor::TGI_THRESHOLD_VALUE_MIN && intensity <= Preprocessor::TGI_THRESHOLD_VALUE_MAX);
}
// Remove noise from the cloud
void Preprocessor::RemoveNoise(const pcl::PointCloud<pcl::PointXYZI>::Ptr &cloud) const
{
pcl::StatisticalOutlierRemoval<pcl::PointXYZI> sor;
sor.setInputCloud(cloud);
sor.setMeanK(50);
sor.setStddevMulThresh(2.0);
sor.filter(*cloud);
}
// Downsample
void Preprocessor::DownsampleCloud(pcl::PointCloud<PointDefaultType>::Ptr& cloud)
{
const double RADIUS { 0.01 };
pcl::UniformSampling<PointDefaultType> ufs;
ufs.setInputCloud(cloud);
ufs.setRadiusSearch(RADIUS);
ufs.filter(*cloud);
}
|
a07e8cd063891428ed5be1f223c0e5f7b1bd757f | 5e13159827f6ddd0a3b642481a63228d480e4b1e | /chap09/exercises/ex_9.33.cpp | 2970c144b4615c9a44deddfcee6708d44d09e5d2 | [] | no_license | jxzhsiwuxie/cppPrimer | d3bf9c2e4faa7d83a8634ceb5d239e745aaba288 | 99105606ff826f29d58961ab4b921da3f3311bd3 | refs/heads/master | 2022-04-26T18:17:50.858241 | 2022-03-13T06:39:25 | 2022-03-13T06:39:25 | 233,590,715 | 4 | 2 | null | null | null | null | UTF-8 | C++ | false | false | 1,422 | cpp | ex_9.33.cpp | //练习 9.33：在本节最后一个例子中，如果不将 insert 的结果赋予 begin，将会发生什么？
//编写程序，去掉此语句，验证你的答案。
/*
* 对于 vector，在插入新元素之后，如果存储空间被重新分配了，则指向容器的迭代器、指针和引用都会失效。
* 这样循环的终止条件可能永远无法满足。
*/
#include <ctime>
#include <iostream>
#include <random>
#include <vector>
using std::default_random_engine;
using std::uniform_int_distribution;
using std::cout;
using std::endl;
using std::vector;
int main() {
default_random_engine e(std::time(NULL));
uniform_int_distribution<int> u(10, 100);
//处理容器中的每个元素，在其后添加一个新元素。
//跳过新加的元素，只处理原有的元素。
vector<int> v = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
cout << "初始时 vector 包含元素：" << endl;
for (auto s : v)
cout << s << " ";
cout << endl;
auto begin = v.begin();
while (begin != v.end()) {
//做一些处理
//...
++begin;
//插入新值
// begin = v.insert(begin, u(e));
v.insert(begin, u(e)); //使用这一句则程序进入死循环。
++begin;
}
cout << "一顿操作之后 vector 包含元素：" << endl;
for (auto s : v)
cout << s << " ";
cout << endl;
return 0;
}
|
cdb0fb1688d3e247e5c019fa91d095fd59af487e | 6f1c7fff0bace5c20e027f7fd7ed35bafe4e1328 | /benchmark/benchmark2.cpp | 103749689819e48e9fc7e2bfbb75763dce7ae822 | [] | no_license | fhvilshoj/alg_eng_matrix | f5ffdc52e20355e93f4d0c7f217cebad53a41235 | 2772cc6d0faf08a73108cf2ae271e67586ff206c | refs/heads/master | 2021-01-20T04:22:14.267380 | 2017-03-20T18:25:46 | 2017-03-20T18:25:46 | 82,924,292 | 0 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 21,437 | cpp | benchmark2.cpp | #include<cstdlib>
#include<cstring>
#include<ctime>
#include<iostream>
#include<fstream>
#include "papi.h"
#include "../../pcm/cpucounters.h"
#include "../src/naive.hpp"
#include "../src/oblivious.hpp"
#include "../src/oblivious_s.hpp"
#include "../src/oblivious_cores.hpp"
#include "../src/helper.hpp"
#include "../src/naive_flip.hpp"
#include "../src/oblivious_s_flip.hpp"
#include "../src/tiled.hpp"
#include "../../pcm/types.h"
#include "../src/tiled_flip.hpp"
#ifdef __GNUC__
#include<x86intrin.h>
namespace clocking {
inline unsigned long long ticks() {
return __rdtsc();
}
}
#else
#ifdef __MSVC__
#include<intrin.h>
namespace clocking
{
inline unsigned long long ticks()
{
return __rdtsc();
}
}
#else
namespace clocking
{
inline unsigned long long ticks()
{
return std::clock();
}
}
#endif
#endif
struct argument {
char const *name;
char const *abbreviation;
char const *description;
unsigned min_count, max_count;
enum {
boolean, string, number
} type;
std::vector<bool> bool_values;
std::vector<std::string> string_values;
std::vector<unsigned> number_values;
bool is(char const *testee) const {
return std::strcmp(testee, abbreviation) == 0
|| std::strcmp(testee, name) == 0;
}
} arguments[] =
{
{"input", "i", "Sets the input query file. Multiple ones allowed.", 1u, 128u, argument::string},
{"output", "o", "Sets the output file name. Defaults to 'result'. This argument is ignored if algorithm is set.", 1u, 2u, argument::string, {}, {"result"}, {}},
{"refresh", "r", "Sets the number of extra iterations to run before measuring the time. Defaults to 0, at most 1.000.000.000.", 1u, 2u, argument::number, {}, {}, {2u}},
{"iterations", "l", "Sets the number of iterations to run when measuring the time. Defaults to 1000, at most 1.000.000.000.", 1u, 2u, argument::number, {}, {}, {5u}},
{"core", "c", "Sets the execution core index", 0u, 4u, argument::number, {}, {}, {0u}},
};
constexpr int ARG_INPUT = 0;
constexpr int ARG_OUTPUT = 1;
constexpr int ARG_REFRESH = 2;
constexpr int ARG_ITERATIONS = 3;
constexpr int ARG_CORE = 4;
std::vector<std::string> files;
std::string output;
unsigned refresh_count;
unsigned iteration_count;
unsigned core;
struct algorithm_profile {
typedef void (*multiply_delegate)(int const **A, int const **B, unsigned const m, unsigned const n,
unsigned const p, int **&destination, unsigned const option);
typedef bool (*build_delegate)(int **&A, int **&B, unsigned const m, unsigned const n, unsigned const p);
char const *name;
multiply_delegate multiply;
build_delegate build;
unsigned const option;
std::string short_name;
bool mutates_input;
unsigned max_input;
} algorithms[] =
{
{"naive", matmul::naive::multiply, matmul::naive::build, 0, "nai1", false, 3500},
{"naive:fl", matmul::naive_flip::multiply, matmul::naive_flip::build, 0, "nai.fl", true, 50000},
// {"naive:2", matmul::naive::multiply, matmul::naive::build, 2, "nai2", false},
// {"naive:4", matmul::naive::multiply, matmul::naive::build, 4, "nai4", false},
// {"naive:8", matmul::naive::multiply, matmul::naive::build, 8, "nai8", false},
// {"naive:16", matmul::naive::multiply, matmul::naive::build, 16, "nai16", false},
// {"naive:32", matmul::naive::multiply, matmul::naive::build, 16, "nai32", false},
// {"tiled:32", matmul::tiled::multiply, matmul::tiled::build, 32, "tiled.32", true, 25000},
// {"tiled:50", matmul::tiled::multiply, matmul::tiled::build, 50, "tiled.50", true, 25000},
// {"tiled:70", matmul::tiled::multiply, matmul::tiled::build, 75, "tiled.75", true, 25000},
// {"tiled:145", matmul::tiled::multiply, matmul::tiled::build, 145, "tiled.145", true, 25000},
// {"tiled:300", matmul::tiled::multiply, matmul::tiled::build, 300, "tiled.300", true, 25000},
// {"tiled:fl:20", matmul::tiled_flip::multiply, matmul::tiled_flip::build, 20, "tiled.fl.20", true, 25000},
// {"tiled:fl:50", matmul::tiled_flip::multiply, matmul::tiled_flip::build, 20, "tiled.fl.50", true, 25000},
{"tiled:fl:140", matmul::tiled_flip::multiply, matmul::tiled_flip::build, 20, "tiled.fl.140", true, 25000},
// {"obl:2", matmul::oblivious::multiply, matmul::oblivious::build, 2, "2", false, 1500},
// {"obl:10", matmul::oblivious_s::multiply, matmul::oblivious_s::build, 10, "10", false},
// {"obl:40", matmul::oblivious_s::multiply, matmul::oblivious_s::build, 40, "40", false},
// {"obl:130", matmul::oblivious_s::multiply, matmul::oblivious_s::build, 130, "obl.130", false, 25000},
// {"obl:145", matmul::oblivious_s::multiply, matmul::oblivious_s::build, 145, "obl.145", false, 25000},
{"obl:160", matmul::oblivious_s::multiply, matmul::oblivious_s::build, 160, "obl.160", false, 25000},
// {"obl:180", matmul::oblivious_s::multiply, matmul::oblivious_s::build, 180, "obl.180", false, 25000},
// {"obl:640", matmul::oblivious_s::multiply, matmul::oblivious_s::build, 640, "640", false},
// {"obl:1280", matmul::oblivious_s::multiply, matmul::oblivious_s::build, 1280, "1280", false},
// {"obl:fl:8", matmul::oblivious_s_flip::multiply, matmul::oblivious_s_flip::build, 8, "nai.fl.8", true},
// {"obl:fl:16", matmul::oblivious_s_flip::multiply, matmul::oblivious_s_flip::build, 16, "nai.fl.16", true},
// {"obl:fl:32", matmul::oblivious_s_flip::multiply, matmul::oblivious_s_flip::build, 32, "nai.fl.32", true},
// {"obl:fl:64", matmul::oblivious_s_flip::multiply, matmul::oblivious_s_flip::build, 64, "nai.fl.64", true},
// {"obl:fl:128", matmul::oblivious_s_flip::multiply, matmul::oblivious_s_flip::build, 128, "nai.fl.128", true},
// {"obl:fl:256", matmul::oblivious_s_flip::multiply, matmul::oblivious_s_flip::build, 256, "nai.fl.256", true},
// {"obl:fl:512", matmul::oblivious_s_flip::multiply, matmul::oblivious_s_flip::build, 512, "obl.fl.512", true},
{"obl:fl:1024", matmul::oblivious_s_flip::multiply, matmul::oblivious_s_flip::build, 1024, "obl.fl.1024", true,
50000},
// {"obl:fl:2048", matmul::oblivious_s_flip::multiply, matmul::oblivious_s_flip::build, 2048, "obl.fl.2048", true},
// {"obl_c:16", matmul::oblivious_c::multiply, matmul::oblivious_c::build, 16, "16", false},
// {"obl_c:8", matmul::oblivious_c::multiply, matmul::oblivious_c::build, 8, "8", false},
// {"obl_c:4", matmul::oblivious_c::multiply, matmul::oblivious_c::build, 4, "4", false},
// {"obl_c:2", matmul::oblivious_c::multiply, matmul::oblivious_c::build, 2, "2", false},
// {"obl_c:1", matmul::oblivious_c::multiply, matmul::oblivious_c::build, 1, "1", false},
};
algorithm_profile const *chosen;
struct pcm_hardware_counter {
uint64 umask;
uint64 event_select;
std::string short_description;
std::string description;
};
pcm_hardware_counter pcm_hdw_counters[] = {
{0x08, 0xD1, "L1_MISS", "Retired load uops misses in L1 cache as data sources."},
{0x10, 0xD1, "L2_MISS", "Miss in mid-level (L2) cache. Excludes Unknown data-source."},
{0x01, 0x08, "TLB_LM", "DTLB_LOAD_MISSES.MISS_CAUSES_A_WALK:Load misses in all DTLB levels that cause page walks"},
// {0x02, 0x08, "TLB_DLM", "Demand load Miss in all translation lookaside buffer (TLB) levels causes a page walk that completes (4K)."},
// {0x10, 0x49, "TLB_LCY", "DTLB_STORE_MISSES.WALK_DURATION:Cycles when PMH is busy with page walks"},
// {0x20, 0x49, "TLB_L2C_4k", "DTLB_STORE_MISSES.STLB_HIT_4K:Store misses that miss the DTLB and hit the STLB (4K)."},
// {0x40, 0x49, "TLB_L2C_2m", "DTLB_STORE_MISSES.STLB_HIT_2M:Store misses that miss the DTLB and hit the STLB (2M)."},
};
int pcm_cnt = sizeof(pcm_hdw_counters) / sizeof(pcm_hdw_counters[0]);
uint32 pcm_in_use = (uint32) std::min(pcm_cnt, 4);
std::string file_name_for_algorithm(algorithm_profile algorithm, std::string ending = ".data");
void print_usage();
bool parse_arguments(int argc, char **argv);
bool validate_arguments();
void run_test(std::string const &dataset, PCM *m);
EventSelectRegister regs[4];
int main(int argc, char **argv) {
std::cout << "Lets benchmark!" << std::endl;
if (argc < 2) {
print_usage();
return 1;
}
if (!parse_arguments(argc, argv)) {
return 2;
}
if (!validate_arguments()) {
return 2;
}
std::string header = "";
for (unsigned i = 0; i < pcm_in_use; i++) {
header += pcm_hdw_counters[i].short_description + " ";
}
header += "Build_T Mult_T Total_T l2_SYS_MISS l3_SYS_MISS m";
for (auto const a : algorithms) {
std::ofstream result_file;
result_file.open(file_name_for_algorithm(a));
result_file << header << std::endl;
result_file.close();
}
EventSelectRegister def_event_select_reg;
def_event_select_reg.value = 0;
def_event_select_reg.fields.usr = 1;
def_event_select_reg.fields.os = 1;
def_event_select_reg.fields.enable = 1;
PCM::ExtendedCustomCoreEventDescription conf;
conf.fixedCfg = NULL; // default
conf.nGPCounters = pcm_in_use;
conf.gpCounterCfg = regs;
for (int i = 0; i < pcm_in_use; ++i)
regs[i] = def_event_select_reg;
for (int i = 0; i < pcm_in_use; i++) {
pcm_hardware_counter c = pcm_hdw_counters[i];
regs[i].fields.event_select = c.event_select;
regs[i].fields.umask = c.umask;
}
PCM *m = PCM::getInstance();
PCM::ErrorCode status = m->program(PCM::EXT_CUSTOM_CORE_EVENTS, &conf);
switch (status) {
case PCM::Success:
break;
case PCM::MSRAccessDenied:
std::cerr << "Access to Processor Counter Monitor has denied (no MSR or PCI CFG space access)."
<< std::endl;
exit(EXIT_FAILURE);
case PCM::PMUBusy:
std::cerr
<< "Access to Processor Counter Monitor has denied (Performance Monitoring Unit is occupied by other application). Try to stop the application that uses PMU."
<< std::endl;
std::cerr << "Alternatively you can try to reset PMU configuration at your own risk. Try to reset? (y/n)"
<< std::endl;
char yn;
std::cin >> yn;
if ('y' == yn) {
m->resetPMU();
std::cerr << "PMU configuration has been reset. Try to rerun the program again." << std::endl;
}
exit(EXIT_FAILURE);
default:
std::cerr << "Access to Processor Counter Monitor has denied (Unknown error)." << std::endl;
exit(EXIT_FAILURE);
}
std::cout << header << std::endl;
for (auto const &file : files)
run_test(file, m);
return 0;
}
std::string file_name_for_algorithm(algorithm_profile algorithm, std::string ending) {
return output + "_" + algorithm.short_name + ending;
}
void print_usage() {
fputs
(
"Usage: benchmark <arguments>\n\n"
"When specifying arguments, use '-<name or abbreviation>:<value>'.\n"
"For boolean arguments (switches), you can also use '-<name or abbreviation>' to specify true.\n"
"Valid values for boolean arguments are true/t/on/yes/y and false/f/off/no/n.\n"
"Argument name and value are case-sensitive.\n\n",
stderr
);
for (auto const &a : arguments)
fprintf(stderr, "(%s) %s\n %s\n", a.abbreviation, a.name, a.description);
}
void print_meassures() {
for (int i = 0; i < pcm_in_use; i++) {
std::cout << pcm_hdw_counters[i].short_description << " ";
}
std::cout << "filename" << std::endl;
}
bool parse_uint(char const *str, unsigned &result) {
if (!str)
return false;
unsigned x = 0u;
for (unsigned digit; *str; ++str) {
if (*str < '0' || *str > '9')
return false;
digit = *str - '0';
if (x > 429496729u
|| (x == 429496729u && digit >= 6u))
return false;
x = x * 10u + digit;
}
result = x;
return true;
}
bool parse_bool(char const *str, bool &result) {
static char const *const bool_true[] =
{
"true", "t", "on", "yes", "y", nullptr
};
static char const *const bool_false[] =
{
"false", "f", "off", "no", "n", nullptr
};
for (char const *const *p = bool_true; *p; ++p)
if (std::strcmp(*p, str) == 0) {
result = true;
return true;
}
for (char const *const *p = bool_false; *p; ++p)
if (std::strcmp(*p, str) == 0) {
result = false;
return true;
}
return false;
}
bool parse_arguments(int argc, char **argv) {
for (int i = 1; i < argc; ++i) {
if (argv[i][0] != '-') {
fprintf(stderr, "Unknown argument: %s\n", argv[i]);
return false;
}
++argv[i];
char *value = std::strstr(argv[i], ":");
/* switch */
if (!value) {
for (auto &a : arguments)
if (a.type == argument::boolean && a.is(argv[i]))
a.bool_values.push_back(true);
} else {
*value++ = '\0';
bool found = false;
for (auto &a : arguments) {
if (a.is(argv[i])) {
found = true;
bool bv;
unsigned nv;
switch (a.type) {
case argument::boolean:
if (!parse_bool(value, bv)) {
fprintf(stderr, "Cannot parse %s as a boolean value.\n", value);
return false;
}
a.bool_values.push_back(bv);
break;
case argument::string:
a.string_values.push_back(value);
break;
case argument::number:
if (!parse_uint(value, nv)) {
fprintf(stderr, "Cannot parse %s as a number.\n", value);
return false;
}
a.number_values.push_back(nv);
break;
}
break;
}
}
if (!found) {
fprintf(stderr, "Unknown argument name: %s\n", argv[i]);
return false;
}
}
}
return true;
}
bool validate_arguments() {
for (auto const &a : arguments) {
unsigned n = a.bool_values.size() + a.string_values.size() + a.number_values.size();
if (n < a.min_count) {
fprintf(stderr, "Too few arguments provided for %s (%s).\n%s\n", a.name, a.abbreviation, a.description);
return false;
}
if (n > a.max_count) {
fprintf(stderr, "Too many arguments provided for %s (%s).\n%s\n", a.name, a.abbreviation, a.description);
return false;
}
}
files = arguments[ARG_INPUT].string_values;
output = arguments[ARG_OUTPUT].string_values.back();
refresh_count = arguments[ARG_REFRESH].number_values.back();
iteration_count = arguments[ARG_ITERATIONS].number_values.back();
core = arguments[ARG_CORE].number_values.back();
if (refresh_count > 100000000u) {
fputs("The number of extra queries must be at most 100000000.\n", stderr);
return false;
}
if (iteration_count > 100000000u) {
fputs("The number of iterations must be at most 100000000.\n", stderr);
return false;
}
return true;
}
void run_test(std::string const &dataset, PCM *m) {
std::cout << std::endl << dataset << std::endl;
bool B_flipped = false;
FILE *fq = fopen(dataset.c_str(), "r");
helper::file_handler::layout_file matrices{fq};
fclose(fq);
if (!matrices.valid) {
for (auto const &a : algorithms)
printf("N/A\t");
puts(dataset.c_str());
return;
}
int **dest;
const uint32 ncores = m->getNumCores();
uint64 BeforeTime = 0, AfterTime = 0;
SystemCounterState SysBeforeState, SysAfterState;
std::vector<CoreCounterState> BeforeState, AfterState;
std::vector<SocketCounterState> DummySocketStates;
helper::matrix::initialize_matrix(dest, matrices.layout_m, matrices.layout_p);
bool equal_iter = iteration_count % 2 == 0;
for (auto const &a : algorithms) {
if(a.max_input < matrices.layout_m){
std::cout << " # " << a.max_input << " < " << matrices.layout_m << " " << a.name << " skipping" << std::endl;
continue;
}
uint64 l2_acc = 0, l3_acc = 0;
uint64 transpose_acc = 0, transpose_start = 0, transpose_stop = 0;
algorithm_profile::build_delegate build = a.build;
unsigned reps = B_flipped ? (equal_iter ? iteration_count : iteration_count + 1)
: (equal_iter ? iteration_count + 1 : iteration_count);
unsigned c = core >= m->getNumCores() ? 0 : core;
transpose_start = m->getTickCount(1000000, c); // measure in ms on core we are running on.
for(unsigned i = 0; i < reps; i++) {
B_flipped = build(matrices.layoutA, matrices.layoutB, matrices.layout_m, matrices.layout_n,
matrices.layout_p);
}
transpose_stop = m->getTickCount(1000000, c);
transpose_acc = (transpose_stop - transpose_start) / reps;
algorithm_profile::multiply_delegate mult = a.multiply;
uint64 acc_time = 0;
uint64 acc_counts[ncores][pcm_in_use];
for(unsigned i = 0; i < ncores; i++)
for(unsigned j = 0; j < pcm_in_use; j++)
acc_counts[i][j] = 0;
for (unsigned i = refresh_count; i; --i) {
std::memset(dest[0], 0, sizeof(int) * matrices.layout_m * matrices.layout_p);
mult((int const **) matrices.layoutA, (int const **) matrices.layoutB, matrices.layout_m, matrices.layout_n,
matrices.layout_p, dest, a.option);
}
std::cout << "counting" << std::endl;
for (unsigned i = iteration_count; i; --i) {
std::memset(dest[0], 0, sizeof(int) * matrices.layout_m * matrices.layout_p);
BeforeTime = m->getTickCount(1000000, c);
m->getAllCounterStates(SysBeforeState, DummySocketStates, BeforeState);
mult((int const **) matrices.layoutA, (int const **) matrices.layoutB, matrices.layout_m, matrices.layout_n,
matrices.layout_p, dest, a.option);
m->getAllCounterStates(SysAfterState, DummySocketStates, AfterState);
AfterTime = m->getTickCount(1000000, c);
for (uint32 j = 0; j < ncores; j++) {
for (uint32 k = 0; k < pcm_in_use; k++) {
acc_counts[j][k] += getNumberOfCustomEvents(k, BeforeState[j], AfterState[j]);
}
}
acc_time += AfterTime - BeforeTime;
l2_acc += getL2CacheMisses(SysBeforeState, SysAfterState);
l3_acc += getL3CacheMisses(SysBeforeState, SysAfterState);
}
l2_acc /= iteration_count;
l3_acc /= iteration_count;
for (uint32 i = 0; i < ncores; i++){
for (uint32 j = 0; j < pcm_in_use; j++){
acc_counts[i][j] /= iteration_count;
}
}
acc_time /= iteration_count;
std::ofstream result_file;
result_file.open(file_name_for_algorithm(a), std::ios::app);
unsigned max_idx = 0;
if(core == 4){
uint64 max_value = 0;
for(unsigned i = 0; i < pcm_in_use; i++){
if(acc_counts[i][0] > max_value){
max_value = acc_counts[i][0];
max_idx = i;
core = i;
}
}
} else {
max_idx = core;
}
for (unsigned i = 0u; i < pcm_in_use; i ++){
result_file << acc_counts[max_idx][i] << " ";
std::cout << acc_counts[max_idx][i] << " ";
}
result_file << transpose_acc << " ";
result_file << acc_time << " " << transpose_acc + acc_time << " " << l2_acc << " " << l3_acc << " " << matrices.layout_m << " " << a.name << std::endl;
result_file.close();
std::cout << transpose_acc << " ";
std::cout << acc_time << " " << transpose_acc + acc_time << " " << l2_acc << " " << l3_acc << " " << matrices.layout_m << " " << a.name << std::endl;
std::swap(BeforeTime, AfterTime);
std::swap(BeforeState, AfterState);
std::swap(SysBeforeState, SysAfterState);
}
helper::matrix::destroy_matrix(dest);
}
|
b779bc59da8a770810e54b1ebdc8b6047305df7d | 74736ed1f56efcc18b5ef57358d4c484460ea9af | /src/script/node.cc | f459f05071fb092b50a51f6e9530245c57f19b44 | [] | no_license | peelonet/tempearly | 696bf65d21d7fec3cbeee816c723f05d4fc962ad | 90fb19a762327b7710c54df0a7819d02563ffcf2 | refs/heads/master | 2021-01-18T21:11:23.394499 | 2016-12-27T13:51:50 | 2016-12-27T13:51:50 | 24,793,526 | 0 | 0 | null | 2016-12-27T13:51:51 | 2014-10-04T15:41:10 | C++ | UTF-8 | C++ | false | false | 31,479 | cc | node.cc | #include "interpreter.h"
#include "node.h"
#include "parameter.h"
#include "api/list.h"
#include "api/map.h"
#include "api/range.h"
namespace tempearly
{
Node::Node() {}
bool Node::Evaluate(const Handle<Interpreter>& interpreter,
Handle<Object>& slot) const
{
Result result = Execute(interpreter);
if (result.Is(Result::KIND_SUCCESS))
{
if (result.HasValue())
{
slot = result.GetValue();
} else {
slot = Object::NewNull();
}
return true;
}
else if (result.Is(Result::KIND_BREAK))
{
interpreter->Throw(interpreter->eSyntaxError,
"Unexpected `break'");
}
else if (result.Is(Result::KIND_CONTINUE))
{
interpreter->Throw(interpreter->eSyntaxError,
"Unexpected `continue'");
}
else if (result.Is(Result::KIND_RETURN))
{
interpreter->Throw(interpreter->eSyntaxError,
"Unexpected `return'");
}
return false;
}
bool Node::Assign(const Handle<Interpreter>& interpreter,
const Handle<Object>& value) const
{
interpreter->Throw(interpreter->eSyntaxError,
"Node is not assignable");
return false;
}
bool Node::AssignLocal(const Handle<Interpreter>& interpreter,
const Handle<Object>& value) const
{
return Assign(interpreter, value);
}
EmptyNode::EmptyNode() {}
Result EmptyNode::Execute(const Handle<Interpreter>& interpreter) const
{
return Result();
}
TextNode::TextNode(const String& content)
: m_content(content) {}
Result TextNode::Execute(const Handle<Interpreter>& interpreter) const
{
interpreter->GetResponse()->Write(m_content);
return Result();
}
ExpressionNode::ExpressionNode(const Handle<Node>& expression, bool escape)
: m_expression(expression.Get())
, m_escape(escape) {}
Result ExpressionNode::Execute(const Handle<Interpreter>& interpreter) const
{
Handle<Object> value;
if (m_expression->Evaluate(interpreter, value))
{
String string;
if (value->ToString(interpreter, string))
{
if (m_escape)
{
string = string.EscapeXml();
}
interpreter->GetResponse()->Write(string);
return Result();
}
}
return Result(Result::KIND_ERROR);
}
void ExpressionNode::Mark()
{
Node::Mark();
if (!m_expression->IsMarked())
{
m_expression->Mark();
}
}
BlockNode::BlockNode(const Vector<Handle<Node>>& nodes)
: m_nodes(nodes) {}
Result BlockNode::Execute(const Handle<Interpreter>& interpreter) const
{
for (std::size_t i = 0; i < m_nodes.GetSize(); ++i)
{
const Result result = m_nodes[i]->Execute(interpreter);
if (!result.Is(Result::KIND_SUCCESS))
{
return result;
}
}
return Result();
}
void BlockNode::Mark()
{
Node::Mark();
for (std::size_t i = 0; i < m_nodes.GetSize(); ++i)
{
Node* node = m_nodes[i];
if (!node->IsMarked())
{
node->Mark();
}
}
}
IfNode::IfNode(const Handle<Node>& condition,
const Handle<Node>& then_statement,
const Handle<Node>& else_statement)
: m_condition(condition.Get())
, m_then_statement(then_statement.Get())
, m_else_statement(else_statement.Get()) {}
Result IfNode::Execute(const Handle<Interpreter>& interpreter) const
{
Handle<Object> condition;
bool b;
if (!m_condition->Evaluate(interpreter, condition)
|| !condition->ToBool(interpreter, b))
{
return Result(Result::KIND_ERROR);
}
else if (b)
{
return m_then_statement->Execute(interpreter);
}
else if (m_else_statement)
{
return m_else_statement->Execute(interpreter);
} else {
return Result();
}
}
void IfNode::Mark()
{
Node::Mark();
if (!m_condition->IsMarked())
{
m_condition->Mark();
}
if (!m_then_statement->IsMarked())
{
m_then_statement->Mark();
}
if (m_else_statement && !m_else_statement->IsMarked())
{
m_else_statement->Mark();
}
}
WhileNode::WhileNode(const Handle<Node>& condition,
const Handle<Node>& statement)
: m_condition(condition.Get())
, m_statement(statement.Get()) {}
Result WhileNode::Execute(const Handle<Interpreter>& interpreter) const
{
Handle<Object> condition;
bool b;
if (!m_condition->Evaluate(interpreter, condition)
|| !condition->ToBool(interpreter, b))
{
return Result(Result::KIND_ERROR);
}
while (b)
{
const Result result = m_statement->Execute(interpreter);
switch (result.GetKind())
{
case Result::KIND_SUCCESS:
break;
case Result::KIND_BREAK:
return Result();
case Result::KIND_CONTINUE:
break;
default:
return result;
}
if (!m_condition->Evaluate(interpreter, condition)
|| !condition->ToBool(interpreter, b))
{
return Result(Result::KIND_ERROR);
}
}
return Result();
}
void WhileNode::Mark()
{
Node::Mark();
if (!m_condition->IsMarked())
{
m_condition->Mark();
}
if (!m_statement->IsMarked())
{
m_statement->Mark();
}
}
ForNode::ForNode(const Handle<Node>& variable,
const Handle<Node>& collection,
const Handle<Node>& statement,
const Handle<Node>& else_statement)
: m_variable(variable.Get())
, m_collection(collection.Get())
, m_statement(statement.Get())
, m_else_statement(else_statement) {}
Result ForNode::Execute(const Handle<Interpreter>& interpreter) const
{
Handle<Object> collection;
Handle<Object> iterator;
Handle<Object> element;
if (!m_collection->Evaluate(interpreter, collection)
|| !collection->CallMethod(interpreter, iterator, "__iter__"))
{
return Result(Result::KIND_ERROR);
}
if (iterator->GetNext(interpreter, element))
{
do
{
if (m_variable->AssignLocal(interpreter, element))
{
const Result result = m_statement->Execute(interpreter);
switch (result.GetKind())
{
case Result::KIND_SUCCESS:
case Result::KIND_CONTINUE:
break;
case Result::KIND_BREAK:
return Result();
default:
return result;
}
} else {
return Result(Result::KIND_ERROR);
}
}
while (iterator->GetNext(interpreter, element));
if (interpreter->HasException())
{
return Result(Result::KIND_ERROR);
} else {
return Result();
}
}
else if (interpreter->HasException())
{
return Result(Result::KIND_ERROR);
}
else if (m_else_statement)
{
return m_else_statement->Execute(interpreter);
} else {
return Result();
}
}
void ForNode::Mark()
{
Node::Mark();
if (!m_variable->IsMarked())
{
m_variable->Mark();
}
if (!m_collection->IsMarked())
{
m_collection->Mark();
}
if (!m_statement->IsMarked())
{
m_statement->Mark();
}
if (m_else_statement && !m_else_statement->IsMarked())
{
m_else_statement->Mark();
}
}
CatchNode::CatchNode(const Handle<TypeHint>& type, const Handle<Node>& variable, const Handle<Node>& statement)
: m_type(type.Get())
, m_variable(variable.Get())
, m_statement(statement.Get()) {}
bool CatchNode::IsCatch(const Handle<Interpreter>& interpreter,
const Handle<Object>& exception,
bool& slot) const
{
if (m_type)
{
return m_type->Accepts(interpreter, exception, slot);
} else {
return slot = true;
}
}
Result CatchNode::Execute(const Handle<Interpreter>& interpreter) const
{
if (m_variable && !m_variable->Assign(interpreter, interpreter->GetCaughtException()))
{
return Result(Result::KIND_ERROR);
} else {
return m_statement->Execute(interpreter);
}
}
void CatchNode::Mark()
{
Node::Mark();
if (m_type && !m_type->IsMarked())
{
m_type->Mark();
}
if (m_variable && !m_variable->IsMarked())
{
m_variable->Mark();
}
if (!m_statement->IsMarked())
{
m_statement->Mark();
}
}
TryNode::TryNode(const Handle<Node>& statement,
const Vector<Handle<CatchNode> >& catches,
const Handle<Node>& else_statement,
const Handle<Node>& finally_statement)
: m_statement(statement.Get())
, m_catches(catches)
, m_else_statement(else_statement.Get())
, m_finally_statement(finally_statement.Get()) {}
Result TryNode::Execute(const Handle<Interpreter>& interpreter) const
{
Result result = m_statement->Execute(interpreter);
if (result.Is(Result::KIND_ERROR))
{
const Handle<ExceptionObject> exception = interpreter->GetException();
bool caught;
for (std::size_t i = 0; i < m_catches.GetSize(); ++i)
{
Handle<CatchNode> c = m_catches[i];
if (!c->IsCatch(interpreter, exception, caught))
{
break;
}
else if (caught)
{
interpreter->SetCaughtException(exception);
interpreter->ClearException();
result = c->Execute(interpreter);
interpreter->ClearCaughtException();
break;
}
}
}
else if (m_else_statement)
{
result = m_else_statement->Execute(interpreter);
}
if (m_finally_statement)
{
Result finally_result = m_finally_statement->Execute(interpreter);
if (finally_result.Is(Result::KIND_ERROR))
{
return finally_result;
}
}
return result;
}
void TryNode::Mark()
{
Node::Mark();
if (!m_statement->IsMarked())
{
m_statement->Mark();
}
for (std::size_t i = 0; i < m_catches.GetSize(); ++i)
{
if (!m_catches[i]->IsMarked())
{
m_catches[i]->Mark();
}
}
if (m_else_statement && m_else_statement->IsMarked())
{
m_else_statement->Mark();
}
if (m_finally_statement && m_finally_statement->IsMarked())
{
m_finally_statement->Mark();
}
}
BreakNode::BreakNode() {}
Result BreakNode::Execute(const Handle<Interpreter>& interpreter) const
{
return Result(Result::KIND_BREAK);
}
ContinueNode::ContinueNode() {}
Result ContinueNode::Execute(const Handle<Interpreter>& interpreter) const
{
return Result(Result::KIND_CONTINUE);
}
ReturnNode::ReturnNode(const Handle<Node>& value)
: m_value(value.Get()) {}
Result ReturnNode::Execute(const Handle<Interpreter>& interpreter) const
{
if (m_value)
{
Handle<Object> value;
if (m_value->Evaluate(interpreter, value))
{
return value;
} else {
return Result(Result::KIND_ERROR);
}
}
return Result(Result::KIND_RETURN);
}
void ReturnNode::Mark()
{
Node::Mark();
if (m_value && !m_value->IsMarked())
{
m_value->Mark();
}
}
ThrowNode::ThrowNode(const Handle<Node>& exception)
: m_exception(exception.Get()) {}
Result ThrowNode::Execute(const Handle<Interpreter>& interpreter) const
{
Handle<Object> exception;
if (m_exception)
{
if (!m_exception->Evaluate(interpreter, exception))
{
return Result(Result::KIND_ERROR);
}
else if (!exception->IsInstance(interpreter, interpreter->cException))
{
interpreter->Throw(
interpreter->eTypeError,
"Cannot throw instance of '"
+ exception->GetClass(interpreter)->GetName()
+ "'"
);
return Result(Result::KIND_ERROR);
}
} else {
exception = interpreter->GetCaughtException();
if (!exception)
{
interpreter->Throw(interpreter->eStateError, "No previously caught exception");
return Result(Result::KIND_ERROR);
}
interpreter->ClearCaughtException();
}
interpreter->SetException(exception.As<ExceptionObject>());
return Result(Result::KIND_ERROR);
}
void ThrowNode::Mark()
{
Node::Mark();
if (m_exception && !m_exception->IsMarked())
{
m_exception->Mark();
}
}
ValueNode::ValueNode(const Handle<Object>& value)
: m_value(value) {}
Result ValueNode::Execute(const Handle<Interpreter>& interpreter) const
{
return Handle<Object>(m_value);
}
void ValueNode::Mark()
{
Node::Mark();
if (!m_value->IsMarked())
{
m_value->Mark();
}
}
AndNode::AndNode(const Handle<Node>& left, const Handle<Node>& right)
: m_left(left.Get())
, m_right(right.Get()) {}
Result AndNode::Execute(const Handle<Interpreter>& interpreter) const
{
Handle<Object> condition;
bool b;
if (!m_left->Evaluate(interpreter, condition)
|| !condition->ToBool(interpreter, b))
{
return Result(Result::KIND_ERROR);
}
else if (b)
{
return m_right->Execute(interpreter);
} else {
return condition;
}
}
void AndNode::Mark()
{
Node::Mark();
if (!m_left->IsMarked())
{
m_left->Mark();
}
if (!m_right->IsMarked())
{
m_right->Mark();
}
}
OrNode::OrNode(const Handle<Node>& left, const Handle<Node>& right)
: m_left(left.Get())
, m_right(right.Get()) {}
Result OrNode::Execute(const Handle<Interpreter>& interpreter) const
{
Handle<Object> condition;
bool b;
if (!m_left->Evaluate(interpreter, condition)
|| !condition->ToBool(interpreter, b))
{
return Result(Result::KIND_ERROR);
}
else if (b)
{
return condition;
} else {
return m_right->Execute(interpreter);
}
}
void OrNode::Mark()
{
Node::Mark();
if (!m_left->IsMarked())
{
m_left->Mark();
}
if (!m_right->IsMarked())
{
m_right->Mark();
}
}
NotNode::NotNode(const Handle<Node>& condition)
: m_condition(condition.Get()) {}
Result NotNode::Execute(const Handle<Interpreter>& interpreter) const
{
Handle<Object> condition;
bool b;
if (!m_condition->Evaluate(interpreter, condition)
|| !condition->ToBool(interpreter, b))
{
return Result(Result::KIND_ERROR);
} else {
return Object::NewBool(!b);
}
}
void NotNode::Mark()
{
Node::Mark();
if (!m_condition->IsMarked())
{
m_condition->Mark();
}
}
AttributeNode::AttributeNode(const Handle<Node>& receiver,
const String& id,
bool null_safe)
: m_receiver(receiver.Get())
, m_id(id)
, m_null_safe(null_safe) {}
bool AttributeNode::IsVariable() const
{
return true;
}
Result AttributeNode::Execute(const Handle<Interpreter>& interpreter) const
{
Handle<Object> value;
if (!m_receiver->Evaluate(interpreter, value))
{
return Result(Result::KIND_ERROR);
}
else if (m_null_safe && value->IsNull())
{
return Result();
}
else if (value->GetAttribute(interpreter, m_id, value))
{
return value;
} else {
return Result(Result::KIND_ERROR);
}
}
bool AttributeNode::Assign(const Handle<Interpreter>& interpreter,
const Handle<Object>& value) const
{
Handle<Object> receiver;
if (!m_receiver->Evaluate(interpreter, receiver))
{
return false;
}
else if (m_null_safe && receiver->IsNull())
{
return true;
} else {
return receiver->SetOwnAttribute(m_id, value);
}
}
void AttributeNode::Mark()
{
Node::Mark();
if (!m_receiver->IsMarked())
{
m_receiver->Mark();
}
}
CallNode::CallNode(const Handle<Node>& receiver,
const String& id,
const Vector<Handle<Node> >& args,
bool null_safe)
: m_receiver(receiver.Get())
, m_id(id)
, m_args(args)
, m_null_safe(null_safe) {}
Result CallNode::Execute(const Handle<Interpreter>& interpreter) const
{
Handle<Object> value;
if (!m_receiver->Evaluate(interpreter, value))
{
return Result(Result::KIND_ERROR);
}
else if (m_null_safe && value->IsNull())
{
return Result();
} else {
Vector<Handle<Object>> args;
args.Reserve(m_args.GetSize());
for (std::size_t i = 0; i < m_args.GetSize(); ++i)
{
Handle<Object> argument;
if (!m_args[i]->Evaluate(interpreter, argument))
{
return Result(Result::KIND_ERROR);
}
args.PushBack(argument);
}
if (value->CallMethod(interpreter, value, m_id, args))
{
return value;
} else {
return Result(Result::KIND_ERROR);
}
}
}
void CallNode::Mark()
{
Node::Mark();
if (!m_receiver->IsMarked())
{
m_receiver->Mark();
}
for (std::size_t i = 0; i < m_args.GetSize(); ++i)
{
if (!m_args[i]->IsMarked())
{
m_args[i]->Mark();
}
}
}
PrefixNode::PrefixNode(const Handle<Node>& variable, Kind kind)
: m_variable(variable.Get())
, m_kind(kind) {}
Result PrefixNode::Execute(const Handle<Interpreter>& interpreter) const
{
Handle<Object> value;
if (!m_variable->Evaluate(interpreter, value))
{
return Result(Result::KIND_ERROR);
}
if (!value->CallMethod(interpreter, value, m_kind == INCREMENT ? "__inc__" : "__dec__")
|| !m_variable->Assign(interpreter, value))
{
return Result(Result::KIND_ERROR);
}
return value;
}
void PrefixNode::Mark()
{
Node::Mark();
if (!m_variable->IsMarked())
{
m_variable->Mark();
}
}
PostfixNode::PostfixNode(const Handle<Node>& variable, Kind kind)
: m_variable(variable.Get())
, m_kind(kind) {}
Result PostfixNode::Execute(const Handle<Interpreter>& interpreter) const
{
Handle<Object> value;
Handle<Object> result;
if (!m_variable->Evaluate(interpreter, value))
{
return Result(Result::KIND_ERROR);
}
if (!value->CallMethod(interpreter, result, m_kind == INCREMENT ? "__inc__" : "__dec__")
|| !m_variable->Assign(interpreter, result))
{
return Result(Result::KIND_ERROR);
}
return value;
}
void PostfixNode::Mark()
{
Node::Mark();
if (!m_variable->IsMarked())
{
m_variable->Mark();
}
}
SubscriptNode::SubscriptNode(const Handle<Node>& container,
const Handle<Node>& index)
: m_container(container.Get())
, m_index(index.Get()) {}
bool SubscriptNode::IsVariable() const
{
return true;
}
Result SubscriptNode::Execute(const Handle<Interpreter>& interpreter) const
{
Handle<Object> container;
Handle<Object> index;
Handle<Object> result;
if (!m_container->Evaluate(interpreter, container)
|| !m_index->Evaluate(interpreter, index)
|| !container->CallMethod(interpreter, result, "__getitem__", index))
{
return Result(Result::KIND_ERROR);
} else {
return result;
}
}
bool SubscriptNode::Assign(const Handle<Interpreter>& interpreter,
const Handle<Object>& value) const
{
Handle<Object> container;
Handle<Object> index;
Vector<Handle<Object>> args;
if (!m_container->Evaluate(interpreter, container)
|| !m_index->Evaluate(interpreter, index))
{
return false;
}
args.Reserve(2);
args.PushBack(index);
args.PushBack(value);
return container->CallMethod(interpreter, "__setitem__", args);
}
void SubscriptNode::Mark()
{
Node::Mark();
if (!m_container->IsMarked())
{
m_container->Mark();
}
if (!m_index->IsMarked())
{
m_index->Mark();
}
}
AssignNode::AssignNode(const Handle<Node>& variable,
const Handle<Node>& value)
: m_variable(variable.Get())
, m_value(value.Get()) {}
Result AssignNode::Execute(const Handle<Interpreter>& interpreter) const
{
Handle<Object> value;
if (m_value->Evaluate(interpreter, value)
&& m_variable->Assign(interpreter, value))
{
return value;
} else {
return Result(Result::KIND_ERROR);
}
}
void AssignNode::Mark()
{
Node::Mark();
if (!m_variable->IsMarked())
{
m_variable->Mark();
}
if (!m_value->IsMarked())
{
m_value->Mark();
}
}
IdentifierNode::IdentifierNode(const String& id)
: m_id(id) {}
bool IdentifierNode::IsVariable() const
{
return true;
}
Result IdentifierNode::Execute(const Handle<Interpreter>& interpreter) const
{
Handle<Object> value;
for (Handle<Frame> frame = interpreter->GetFrame(); frame; frame = frame->GetEnclosingFrame())
{
if (frame->GetLocalVariable(m_id, value))
{
return value;
}
}
if (interpreter->GetGlobalVariable(m_id, value))
{
return value;
}
interpreter->Throw(interpreter->eNameError, "Name '" + m_id + "' is not defined");
return Result(Result::KIND_ERROR);
}
bool IdentifierNode::Assign(const Handle<Interpreter>& interpreter,
const Handle<Object>& value) const
{
Handle<Frame> frame;
// First go through the scope chain and see if some scope already has
// the variable.
for (frame = interpreter->GetFrame(); frame; frame = frame->GetEnclosingFrame())
{
if (frame->ReplaceLocalVariable(m_id, value))
{
return true;
}
}
// If no scope has variable with given identifier, create a new variable
// at the topmost scope.
if ((frame = interpreter->GetFrame()))
{
frame->SetLocalVariable(m_id, value);
return true;
}
interpreter->Throw(interpreter->eNameError, "Name '" + m_id + "' is not defined");
return false;
}
bool IdentifierNode::AssignLocal(const Handle<Interpreter>& interpreter,
const Handle<Object>& value) const
{
Handle<Frame> frame = interpreter->GetFrame();
if (frame)
{
frame->SetLocalVariable(m_id, value);
return true;
}
interpreter->Throw(interpreter->eNameError, "Name '" + m_id + "' is not defined");
return false;
}
ListNode::ListNode(const Vector<Handle<Node> >& elements)
: m_elements(elements) {}
bool ListNode::IsVariable() const
{
if (m_elements.IsEmpty())
{
return false;
}
for (std::size_t i = 0; i < m_elements.GetSize(); ++i)
{
if (!m_elements[i]->IsVariable())
{
return false;
}
}
return true;
}
Result ListNode::Execute(const Handle<Interpreter>& interpreter) const
{
Handle<ListObject> list = new ListObject(interpreter->cList);
for (std::size_t i = 0; i < m_elements.GetSize(); ++i)
{
Handle<Object> value;
if (m_elements[i]->Evaluate(interpreter, value))
{
list->Append(value);
} else {
return Result(Result::KIND_ERROR);
}
}
return Result(Result::KIND_SUCCESS, list);
}
bool ListNode::Assign(const Handle<Interpreter>& interpreter,
const Handle<Object>& value) const
{
Handle<Object> iterator;
Handle<Object> element;
std::size_t index = 0;
if (!value->CallMethod(interpreter, iterator, "__iter__"))
{
return false;
}
while (iterator->GetNext(interpreter, element))
{
if (index < m_elements.GetSize())
{
if (!m_elements[index++]->Assign(interpreter, element))
{
return false;
}
} else {
return true;
}
}
return !interpreter->HasException();
}
void ListNode::Mark()
{
Node::Mark();
for (std::size_t i = 0; i < m_elements.GetSize(); ++i)
{
Node* node = m_elements[i];
if (!node->IsMarked())
{
node->Mark();
}
}
}
MapNode::MapNode(const Vector<Pair<Handle<Node> > >& entries)
: m_entries(entries) {}
Result MapNode::Execute(const Handle<Interpreter>& interpreter) const
{
Handle<MapObject> map = new MapObject(interpreter->cMap);
Handle<Object> key;
Handle<Object> value;
i64 hash;
for (std::size_t i = 0; i < m_entries.GetSize(); ++i)
{
const Pair<Node*>& entry = m_entries[i];
if (!entry.GetKey()->Evaluate(interpreter, key)
|| !entry.GetValue()->Evaluate(interpreter, value)
|| !key->GetHash(interpreter, hash))
{
return Result(Result::KIND_ERROR);
}
map->Insert(hash, key, value);
}
return Result(Result::KIND_SUCCESS, map);
}
void MapNode::Mark()
{
Node::Mark();
for (std::size_t i = 0; i < m_entries.GetSize(); ++i)
{
const Pair<Node*>& entry = m_entries[i];
if (!entry.GetKey()->IsMarked())
{
entry.GetKey()->Mark();
}
if (!entry.GetValue()->IsMarked())
{
entry.GetValue()->Mark();
}
}
}
RangeNode::RangeNode(const Handle<Node>& begin,
const Handle<Node>& end,
bool exclusive)
: m_begin(begin.Get())
, m_end(end.Get())
, m_exclusive(exclusive) {}
Result RangeNode::Execute(const Handle<Interpreter>& interpreter) const
{
Handle<Object> begin;
Handle<Object> end;
if (!m_begin->Evaluate(interpreter, begin)
|| !m_end->Evaluate(interpreter, end))
{
return Result(Result::KIND_ERROR);
}
return Result(
Result::KIND_SUCCESS,
new RangeObject(interpreter, begin, end, m_exclusive)
);
}
void RangeNode::Mark()
{
Node::Mark();
if (!m_begin->IsMarked())
{
m_begin->Mark();
}
if (!m_end->IsMarked())
{
m_end->Mark();
}
}
FunctionNode::FunctionNode(const Vector<Handle<Parameter> >& parameters,
const Vector<Handle<Node> >& nodes)
: m_parameters(parameters)
, m_nodes(nodes) {}
Result FunctionNode::Execute(const Handle<Interpreter>& interpreter) const
{
return Result(
Result::KIND_SUCCESS,
FunctionObject::NewScripted(interpreter, m_parameters, m_nodes)
);
}
void FunctionNode::Mark()
{
Node::Mark();
for (std::size_t i = 0; i < m_parameters.GetSize(); ++i)
{
if (!m_parameters[i]->IsMarked())
{
m_parameters[i]->Mark();
}
}
for (std::size_t i = 0; i < m_nodes.GetSize(); ++i)
{
if (!m_nodes[i]->IsMarked())
{
m_nodes[i]->Mark();
}
}
}
}
|
7069afca16344d0e2269d593134d3b9363febb53 | a93c9a25e6609b80ef7995cc40febff8f3fca6ae | /类Pascal语言编译器/标头.h | c8a5fb099e61ea148c8d9c3b3b7e1ee6bb6ce150 | [] | no_license | IsaacGuan/Pascal-Compiler | a689167e4c254f34279568564b09d86607741e49 | 5e177a58f24f0614abfc9007458d157cceec00b7 | refs/heads/master | 2020-05-21T08:41:13.198072 | 2017-04-05T01:04:43 | 2017-04-05T01:04:43 | 86,973,909 | 3 | 0 | null | null | null | null | GB18030 | C++ | false | false | 2,074 | h | 标头.h | #include <stdio.h>
#include <iostream>
using std:: string;
#define MAX 10000
#define ERROR -1
#define ＃ 0
#define id 1 //用户标识符
#define integer 2 //整数
#define decimal 3 //小数
#define plus 4 //加号
#define minus 5 //减号
#define mutiply 6 //乘号
#define divide 7 //除号
#define assign 8 //赋值
#define gthan 9 //大于
#define lthan 10 //小于
#define egthan 11 //大于等于
#define elthan 12 //小于等于
#define unequal 13 //不等于
#define equal 14 //等于
#define and 15 //与
#define or 16 //或
#define LP 17 //左括号
#define RP 18 //右括号
#define comma 29 //逗号
#define semi 20 //分号
#define keybegin 21 //保留字begin
#define keyas 22 //保留字as
#define keysub 23 //保留字sub
#define keyend 24 //保留字end
#define keyif 25 //保留字if
#define keythen 26 //保留字then
#define keyelse 27 //保留字else
#define keycall 28 //保留字call
#define keywhile 29 //保留字while
#define keydo 30 //保留字do
#define keyinteger 31 //保留字interger
#define keyfloat 32 //保留字float
#define keyinput 33 //保留字input
#define keyoutput 34 //保留字output
#define keyvar 35 //保留字var
#define processname 100
#define variablename 101
typedef struct{ //符号表结构体
string name; //符号名称
int used; //判断当前结构体内有没有内容，有为1，无为0
int type; //符号类型，有两种值：processname函数名，variablename变量名
int paranum; //参数个数，初值为0
}idtab;
typedef struct{ //四元式表结构体
int nxq; //当前四元式编号
string op; //运算符
string arg1; //运算对象1
string arg2; //运算对象2
string result; //结果
}intertable; |
b120bbdddd25478d060ffde8328e4b7dbe5f07f8 | 090d7ad3407513ff808393c8bc5aa6a31b463371 | /Blackjack/Blackjack/Player.cpp | f549c4dc6d6b9f5329051efc45a160e6cd4d66ca | [] | no_license | klemmert/School-Projects | dfac1afc3ff6948915dfa2363b65a26b4f8d5811 | e69f63f0f27e52f45b5f6ef2a46fdbbad8d6c979 | refs/heads/master | 2020-05-30T08:38:23.598600 | 2019-05-31T13:54:35 | 2019-05-31T13:54:35 | 80,969,868 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 602 | cpp | Player.cpp | #include "pch.h"
#include "Player.h"
#include <vector>
using namespace std;
Player::Player()
{
}
Player::Player(int playerID, int scoreCount, vector<int> hand)
{
id = playerID;
score = scoreCount;
playerHand = hand;
}
Player::~Player()
{
}
void Player::setPlayerScoreCount(int scoreCount)
{
score = scoreCount;
}
int Player::getPlayerScoreCount()
{
return score;
}
void Player::setID(int playerID)
{
id = playerID;
}
int Player::getID()
{
return id;
}
void Player::setPlayerHand(vector <int> hand)
{
playerHand = hand;
}
vector<int> Player::getPlayerHand()
{
return playerHand;
}
|
8109ac2a4f701f7d8e759c00cd3e2725251e8673 | 59992c2a61b97c656c0f1ffc37324b0bd2b5c05c | /Marvel/renderer/bindables/mvDepthStencil.h | 261aae159a817d96964681d3d33178f03da81638 | [] | no_license | mfkiwl/Marvel | 7f6aca2dd1da54721eee8f02a869782da7ed3686 | dd973859aca6800fbfc8ebd154f9d26bc6acf560 | refs/heads/master | 2023-04-27T08:42:59.017541 | 2021-05-25T16:39:03 | 2021-05-25T16:39:03 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,136 | h | mvDepthStencil.h | #pragma once
#include <d3d11.h>
#include "mvBindable.h"
#include "mvComPtr.h"
#include "mvBufferResource.h"
//-----------------------------------------------------------------------------
// forward declarations
//-----------------------------------------------------------------------------
struct ID3D11DepthStencilView;
namespace Marvel {
//-----------------------------------------------------------------------------
// forward declarations
//-----------------------------------------------------------------------------
class mvGraphics;
class mvRenderTarget;
//-----------------------------------------------------------------------------
// mvDepthStencil
//-----------------------------------------------------------------------------
class mvDepthStencil : public mvBindable, public mvBufferResource
{
public:
enum class Usage{ DepthStencil, ShadowDepth};
mvDepthStencil(mvGraphics& graphics, mvComPtr<ID3D11Texture2D> texture, UINT face);
mvDepthStencil(mvGraphics& graphics, int width, int height, bool shaderBinding = false, Usage usage = Usage::DepthStencil);
virtual ~mvDepthStencil() = default;
// bindable interface
void bind(mvGraphics& graphics) override {}
// buffer resource interface
void bindAsBuffer(mvGraphics& graphics) override;
void bindAsBuffer(mvGraphics& graphics, mvBufferResource* renderTarget) override;
void bindAsBuffer(mvGraphics& graphics, mvRenderTarget* renderTarget);
void clear(mvGraphics& graphics) override;
ID3D11DepthStencilView* getDepthStencilView();
void reset();
protected:
mvComPtr<ID3D11DepthStencilView> m_DSV;
};
//-----------------------------------------------------------------------------
// mvOutputDepthStencil
//-----------------------------------------------------------------------------
class mvOutputDepthStencil : public mvDepthStencil
{
public:
mvOutputDepthStencil(mvGraphics& graphics, int width, int height);
mvOutputDepthStencil(mvGraphics& graphics);
mvOutputDepthStencil(mvGraphics& graphics, mvComPtr<ID3D11Texture2D> texture, UINT face);
void bind(mvGraphics& graphics) override {}
};
} |
90321a5bba1fa5b66d9a4a3f6a0cbf1038f81c8f | 4e185ce04cff11c1731e624d5a85cd9b8a3ed957 | /RiD_RPGproject/RiD_RPGproject/Gold.cpp | 76667fe4d3527c10816af4f2a24da3bf23f158c6 | [] | no_license | reoskaro434/sfml-game | d509762a59bb16abf26d8e37e34c67083e51f18a | 084647502793cbdd5299ac8c1316f95988950077 | refs/heads/master | 2023-03-25T12:35:42.287522 | 2021-03-26T19:00:11 | 2021-03-26T19:00:11 | 330,765,265 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 698 | cpp | Gold.cpp | #include "Gold.h"
MP::Gold::Gold()
{
}
MP::Gold::Gold(sf::Texture* texturePtr, sf::Font& aFont)
{
aAnimation.loadObjectTextures(texturePtr, 1, 1, 64);
_item_amount_text.setFont(aFont);
setItemAmount(0);
_item_amount_text.setLetterSpacing(1);
_item_amount_text.setCharacterSize(25);
_item_amount_text.setFillColor(sf::Color(224, 224, 224));
_item_cost = 1;
}
void MP::Gold::setItemPosition(sf::Vector2f itemPosition)
{
setObjectCoord(itemPosition);
itemPosition.x += 68;
itemPosition.y += 30;
_item_amount_text.setPosition(itemPosition);
}
void MP::Gold::drawItem(sf::RenderWindow& mainWindow)
{
mainWindow.draw(aAnimation.getObjectSprite());
mainWindow.draw(_item_amount_text);
}
|
a3511d61b625c8c06f0180a1afb534edf0e024cd | 9d46d47a2e5aca33a138b271ef84dccbf9c695a4 | /svcman/WinServiceHelper.cpp | fa500e0c7694d3f0201f8e5a7c223d47f356de6e | [
"MIT"
] | permissive | azkurban/win-service-manager-demo | 9c6daca9eac81fd496a9bbaaedef49cb438eecd6 | 39799dcabe5cc4ad01698cbe32a83da4a0ea4cd0 | refs/heads/master | 2022-07-03T18:12:29.252522 | 2020-05-15T20:08:50 | 2020-05-15T20:08:50 | 264,137,957 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 25,301 | cpp | WinServiceHelper.cpp | #pragma once
#include "pch.h"
#include "WinServiceHelper.h"
#include "ServiceController.h"
#include "ServiceEnumerator.h"
// Globals
//
//SERVICE_STATUS ssService;
//SERVICE_STATUS_HANDLE hssService;
HANDLE g_hEvent;
WinServiceHelper::WinServiceHelper()
{
InitServiceList();
}
void WinServiceHelper::InitServiceList()
{
_winServices = ServiceEnumerator::EnumerateServices();
}
WinServiceHelper::~WinServiceHelper() {}
void WinServiceHelper::ServiceList(ServiceProcess* services, size_t count)
{
size_t size = min(_winServices.size(), count);
for (size_t i = 0; i < size; i++) {
auto ws = _winServices[i];
// open the service
auto service = ServiceController{ ws.ServiceName };
auto config = service.GetServiceConfig();
services[i].ProcessId = ws.Status.dwProcessId;
CopyStrValue(ws.ServiceName, services[i].Name);
CopyStrValue(ws.DisplayName, services[i].Description);
auto status = ServiceStatusToString(static_cast<ServiceStatus>(ws.Status.dwCurrentState));
CopyStrValue(status, services[i].Status);
auto path = config.GetBinaryPathName();
CopyStrValue(path, services[i].ImagePath);
}
}
size_t WinServiceHelper::ServiceCount()
{
return _winServices.size();
}
int WinServiceHelper::RestartSvc(LPCWSTR serviceName, ServiceControlState* pSCState) {
auto result = StopSvc(serviceName, pSCState);
if (result == SERVICE_CONTROL_OPERATOR_FAILED)
return SERVICE_CONTROL_OPERATOR_FAILED;
return StartSvc(serviceName, pSCState);
}
//
// Purpose:
// Starts the service if possible.
//
// Parameters:
// None
//
// Return value:
// None
// Original sample code here: https://docs.microsoft.com/en-us/windows/win32/services/starting-a-service
//
int WinServiceHelper::StartSvc(LPCWSTR serviceName, ServiceControlState* pSCState)
{
SERVICE_STATUS_PROCESS ssStatus;
DWORD dwOldCheckPoint;
DWORD dwStartTickCount;
DWORD dwWaitTime;
DWORD dwBytesNeeded;
DWORD errorCode = 0;
LPCWSTR statusMessage;
CopyStrValue(serviceName, pSCState->ServiceName);
// Get a handle to the SCM database.
auto schSCManager = OpenSCManager(
NULL, // local computer
NULL, // servicesActive database
SC_MANAGER_ALL_ACCESS); // full access rights
if (NULL == schSCManager)
{
errorCode = GetLastError();
statusMessage = _T("OpenSCManager failed");
FillStatus(statusMessage, pSCState, errorCode);
printf("%ws (%d)\n", statusMessage, errorCode);
return SERVICE_CONTROL_OPERATOR_FAILED;
}
// Get a handle to the service.
auto schService = OpenService(
schSCManager, // SCM database
serviceName, // name of service
SERVICE_ALL_ACCESS); // full access
if (schService == NULL)
{
errorCode = GetLastError();
statusMessage = _T("OpenService failed");
FillStatus(statusMessage, pSCState, errorCode);
printf("%ws (%d)\n", statusMessage, errorCode);
CloseServiceHandle(schSCManager);
return SERVICE_CONTROL_OPERATOR_FAILED;
}
// Check the status in case the service is not stopped.
if (!QueryServiceStatusEx(
schService, // handle to service
SC_STATUS_PROCESS_INFO, // information level
(LPBYTE)&ssStatus, // address of structure
sizeof(SERVICE_STATUS_PROCESS), // size of structure
&dwBytesNeeded)) // size needed if buffer is too small
{
errorCode = GetLastError();
statusMessage = _T("QueryServiceStatusEx failed");
FillStatus(statusMessage, ssStatus, pSCState, errorCode);
printf("%ws (%d)\n", statusMessage, errorCode);
CloseServiceHandle(schService);
CloseServiceHandle(schSCManager);
return SERVICE_CONTROL_OPERATOR_FAILED;
}
// Check if the service is already running. It would be possible
// to stop the service here, but for simplicity this example just returns.
if (ssStatus.dwCurrentState != SERVICE_STOPPED && ssStatus.dwCurrentState != SERVICE_STOP_PENDING)
{
statusMessage = _T("Service is already running");
FillStatus(statusMessage, ssStatus, pSCState, errorCode);
printf("%ws.\n", statusMessage);
CloseServiceHandle(schService);
CloseServiceHandle(schSCManager);
return SERVICE_CONTROL_OPERATOR_FAILED;
}
// Save the tick count and initial checkpoint.
dwStartTickCount = GetTickCount();
dwOldCheckPoint = ssStatus.dwCheckPoint;
// Wait for the service to stop before attempting to start it.
while (ssStatus.dwCurrentState == SERVICE_STOP_PENDING)
{
// Do not wait longer than the wait hint. A good interval is
// one-tenth of the wait hint but not less than 1 second
// and not more than 10 seconds.
dwWaitTime = ssStatus.dwWaitHint / 10;
if (dwWaitTime < 1000)
dwWaitTime = 1000;
else if (dwWaitTime > 10000)
dwWaitTime = 10000;
auto errorCode = StartMonitor(serviceName, schService, dwWaitTime);
Sleep(dwWaitTime);
if (errorCode != ERROR_SUCCESS)
{
statusMessage = _T("Unknown Error");
FillStatus(statusMessage, ssStatus, pSCState, errorCode);
printf("%ws (%d)\n", statusMessage, errorCode);
CloseServiceHandle(schService);
CloseServiceHandle(schSCManager);
return SERVICE_CONTROL_OPERATOR_FAILED;
}
// Check the status until the service is no longer stop pending.
if (!QueryServiceStatusEx(
schService, // handle to service
SC_STATUS_PROCESS_INFO, // information level
(LPBYTE)&ssStatus, // address of structure
sizeof(SERVICE_STATUS_PROCESS), // size of structure
&dwBytesNeeded)) // size needed if buffer is too small
{
errorCode = GetLastError();
statusMessage = _T("QueryServiceStatusEx failed");
FillStatus(statusMessage, ssStatus, pSCState, errorCode);
printf("%ws (%d)\n", statusMessage, errorCode);
CloseServiceHandle(schService);
CloseServiceHandle(schSCManager);
return SERVICE_CONTROL_OPERATOR_FAILED;
}
if (ssStatus.dwCheckPoint > dwOldCheckPoint)
{
// Continue to wait and check.
dwStartTickCount = GetTickCount();
dwOldCheckPoint = ssStatus.dwCheckPoint;
}
else
{
if (GetTickCount() - dwStartTickCount > ssStatus.dwWaitHint)
{
//errorCode = GetLastError();
statusMessage = _T("Timeout waiting for service to stop");
FillStatus(statusMessage, ssStatus, pSCState, errorCode);
printf("%ws\n", statusMessage);
CloseServiceHandle(schService);
CloseServiceHandle(schSCManager);
return SERVICE_CONTROL_OPERATOR_FAILED;
}
}
}
// Attempt to start the service.
if (!StartService(
schService, // handle to service
0, // number of arguments
NULL)) // no arguments
{
errorCode = GetLastError();
statusMessage = _T("StartService failed");
FillStatus(statusMessage, ssStatus, pSCState, errorCode);
printf("%ws (%d)\n", statusMessage, errorCode);
CloseServiceHandle(schService);
CloseServiceHandle(schSCManager);
return SERVICE_CONTROL_OPERATOR_FAILED;
}
else printf("Service start pending...\n");
// Check the status until the service is no longer start pending.
if (!QueryServiceStatusEx(
schService, // handle to service
SC_STATUS_PROCESS_INFO, // info level
(LPBYTE)&ssStatus, // address of structure
sizeof(SERVICE_STATUS_PROCESS), // size of structure
&dwBytesNeeded)) // if buffer too small
{
errorCode = GetLastError();
statusMessage = _T("QueryServiceStatusEx failed");
FillStatus(statusMessage, ssStatus, pSCState, errorCode);
printf("%ws (%d)\n", statusMessage, errorCode);
CloseServiceHandle(schService);
CloseServiceHandle(schSCManager);
return SERVICE_CONTROL_OPERATOR_FAILED;
}
// Save the tick count and initial checkpoint.
dwStartTickCount = GetTickCount();
dwOldCheckPoint = ssStatus.dwCheckPoint;
while (ssStatus.dwCurrentState == SERVICE_START_PENDING)
{
// Do not wait longer than the wait hint. A good interval is
// one-tenth the wait hint, but no less than 1 second and no
// more than 10 seconds.
dwWaitTime = ssStatus.dwWaitHint / 10;
if (dwWaitTime < 1000)
dwWaitTime = 1000;
else if (dwWaitTime > 10000)
dwWaitTime = 10000;
errorCode = StartMonitor(serviceName, schService, dwWaitTime);
Sleep(dwWaitTime);
if (errorCode != ERROR_SUCCESS)
{
statusMessage = _T("Fail to start service");
FillStatus(statusMessage, ssStatus, pSCState, errorCode);
CloseServiceHandle(schService);
CloseServiceHandle(schSCManager);
return SERVICE_CONTROL_OPERATOR_FAILED;
}
// Check the status again.
if (!QueryServiceStatusEx(
schService, // handle to service
SC_STATUS_PROCESS_INFO, // info level
(LPBYTE)&ssStatus, // address of structure
sizeof(SERVICE_STATUS_PROCESS), // size of structure
&dwBytesNeeded)) // if buffer too small
{
statusMessage = _T("QueryServiceStatusEx failed");
errorCode = GetLastError();
FillStatus(statusMessage, ssStatus, pSCState, errorCode);
printf("%ws (%d)\n", statusMessage, errorCode);
break;
}
if (ssStatus.dwCheckPoint > dwOldCheckPoint)
{
// Continue to wait and check.
dwStartTickCount = GetTickCount();
dwOldCheckPoint = ssStatus.dwCheckPoint;
}
else
{
if (GetTickCount() - dwStartTickCount > ssStatus.dwWaitHint)
{
// No progress made within the wait hint.
break;
}
}
}
// Determine whether the service is running.
if (ssStatus.dwCurrentState == SERVICE_RUNNING)
{
statusMessage = _T("Service started successfully");
}
else
{
statusMessage = _T("Service not started");
printf("Service not started. \n");
}
printf("%ws.\n", statusMessage);
printf(" Current State: %d\n", ssStatus.dwCurrentState);
printf(" Exit Code: %d\n", ssStatus.dwWin32ExitCode);
printf(" Check Point: %d\n", ssStatus.dwCheckPoint);
printf(" Wait Hint: %d\n", ssStatus.dwWaitHint);
FillStatus(statusMessage, ssStatus, pSCState, errorCode);
CloseServiceHandle(schService);
CloseServiceHandle(schSCManager);
return SERVICE_CONTROL_OPERATOR_SUCCEED;
}
//
// Purpose:
// Stops the service.
//
// Parameters:
// None
//
// Return value:
// None
// Original sample code here: https://docs.microsoft.com/en-us/windows/win32/services/stopping-a-service
//
int WinServiceHelper::StopSvc(LPCWSTR serviceName, ServiceControlState* pSCState)
{
SERVICE_STATUS_PROCESS ssStatus;
DWORD dwStartTime = GetTickCount();
DWORD dwBytesNeeded;
DWORD dwTimeout = 30000; // 30-second time-out
DWORD dwWaitTime;
DWORD errorCode = 0;
LPCWSTR statusMessage;
CopyStrValue(serviceName, pSCState->ServiceName);
// Get a handle to the SCM database.
auto schSCManager = OpenSCManager(
NULL, // local computer
NULL, // ServicesActive database
SC_MANAGER_ALL_ACCESS); // full access rights
if (NULL == schSCManager)
{
errorCode = GetLastError();
statusMessage = _T("OpenSCManager failed");
FillStatus(statusMessage, pSCState, errorCode);
printf("%ws (%d)\n", statusMessage, errorCode);
return SERVICE_CONTROL_OPERATOR_FAILED;
}
// Get a handle to the service.
auto schService = OpenService(
schSCManager, // SCM database
serviceName, // name of service
SERVICE_STOP |
SERVICE_QUERY_STATUS |
SERVICE_ENUMERATE_DEPENDENTS);
if (schService == NULL)
{
errorCode = GetLastError();
statusMessage = _T("OpenService failed");
FillStatus(statusMessage, pSCState, errorCode);
printf("%ws (%d)\n", statusMessage, errorCode);
CloseServiceHandle(schSCManager);
return SERVICE_CONTROL_OPERATOR_FAILED;
}
// Make sure the service is not already stopped.
if (!QueryServiceStatusEx(
schService,
SC_STATUS_PROCESS_INFO,
(LPBYTE)&ssStatus,
sizeof(SERVICE_STATUS_PROCESS),
&dwBytesNeeded))
{
errorCode = GetLastError();
statusMessage = _T("QueryServiceStatusEx");
FillStatus(statusMessage, ssStatus, pSCState, errorCode);
printf("%ws (%d)\n", statusMessage, errorCode);
goto stop_cleanup;
}
if (ssStatus.dwCurrentState == SERVICE_STOPPED)
{
statusMessage = _T("Service is already stopped");
errorCode = GetLastError();
FillStatus(statusMessage, ssStatus, pSCState, errorCode);
printf("%ws.\n", statusMessage);
goto stop_cleanup;
}
// If a stop is pending, wait for it.
while (ssStatus.dwCurrentState == SERVICE_STOP_PENDING)
{
printf("Service stop pending...\n");
// Do not wait longer than the wait hint. A good interval is
// one-tenth of the wait hint but not less than 1 second
// and not more than 10 seconds.
dwWaitTime = ssStatus.dwWaitHint / 10;
if (dwWaitTime < 1000)
dwWaitTime = 1000;
else if (dwWaitTime > 10000)
dwWaitTime = 10000;
Sleep(dwWaitTime);
if (!QueryServiceStatusEx(
schService,
SC_STATUS_PROCESS_INFO,
(LPBYTE)&ssStatus,
sizeof(SERVICE_STATUS_PROCESS),
&dwBytesNeeded))
{
errorCode = GetLastError();
statusMessage = _T("QueryServiceStatusEx failed");
FillStatus(statusMessage, ssStatus, pSCState, errorCode);
printf("%ws (%d)\n", statusMessage, errorCode);
goto stop_cleanup;
}
if (ssStatus.dwCurrentState == SERVICE_STOPPED)
{
statusMessage = _T("Service stopped successfully");
FillStatus(statusMessage, ssStatus, pSCState, errorCode);
printf("%ws.\n", statusMessage);
goto stop_cleanup;
}
if (GetTickCount() - dwStartTime > dwTimeout)
{
statusMessage = _T("Service stop timed out");
FillStatus(statusMessage, ssStatus, pSCState, errorCode);
printf("%ws.\n", statusMessage);
goto stop_cleanup;
}
}
// If the service is running, dependencies must be stopped first.
StopDependentServices(schService, schSCManager);
// Send a stop code to the service.
if (!ControlService(
schService,
SERVICE_CONTROL_STOP,
(LPSERVICE_STATUS)&ssStatus))
{
errorCode = GetLastError();
statusMessage = _T("ControlService failed");
FillStatus(statusMessage, ssStatus, pSCState, errorCode);
printf("%ws (%d)\n", statusMessage, errorCode);
goto stop_cleanup;
}
// Wait for the service to stop.
while (ssStatus.dwCurrentState != SERVICE_STOPPED)
{
Sleep(ssStatus.dwWaitHint);
if (!QueryServiceStatusEx(
schService,
SC_STATUS_PROCESS_INFO,
(LPBYTE)&ssStatus,
sizeof(SERVICE_STATUS_PROCESS),
&dwBytesNeeded))
{
errorCode = GetLastError();
statusMessage = _T("QueryServiceStatusEx failed");
FillStatus(statusMessage, ssStatus, pSCState, errorCode);
printf("%ws (%d)\n", statusMessage, errorCode);
goto stop_cleanup;
}
if (ssStatus.dwCurrentState == SERVICE_STOPPED)
break;
if (GetTickCount() - dwStartTime > dwTimeout)
{
statusMessage = _T("Wait timed out");
FillStatus(statusMessage, ssStatus, pSCState, errorCode);
printf("%ws.\n", statusMessage);
goto stop_cleanup;
}
}
statusMessage = _T("Service stopped successfully");
FillStatus(statusMessage, ssStatus, pSCState, errorCode);
printf("%ws.\n", statusMessage);
stop_cleanup:
CloseServiceHandle(schService);
CloseServiceHandle(schSCManager);
return SERVICE_CONTROL_OPERATOR_SUCCEED;
}
void WinServiceHelper::FillStatus(LPCWSTR statusMessage, SERVICE_STATUS_PROCESS ssStatus, ServiceControlState* pSCState, DWORD errorCode)
{
FillStatus(statusMessage, pSCState, errorCode);
pSCState->CurrentState = ssStatus.dwCurrentState;
pSCState->Win32ExitCode = ssStatus.dwWin32ExitCode;
pSCState->CheckPoint = ssStatus.dwCheckPoint;
pSCState->WaitHint = ssStatus.dwWaitHint;
pSCState->ProcessId = ssStatus.dwCurrentState == SERVICE_STOPPED ? 0 : ssStatus.dwProcessId;
}
void WinServiceHelper::FillStatus(LPCWSTR statusMessage, ServiceControlState* pSCState, DWORD errorCode)
{
CopyStrValue(statusMessage, pSCState->Message);
pSCState->ErrorCode = errorCode;
}
BOOL __stdcall WinServiceHelper::StopDependentServices(SC_HANDLE schService, SC_HANDLE schSCManager)
{
DWORD i;
DWORD dwBytesNeeded;
DWORD dwCount;
LPENUM_SERVICE_STATUS lpDependencies = NULL;
ENUM_SERVICE_STATUS ess;
SC_HANDLE hDepService;
SERVICE_STATUS_PROCESS ssp;
DWORD dwStartTime = GetTickCount();
DWORD dwTimeout = 30000; // 30-second time-out
// Pass a zero-length buffer to get the required buffer size.
if (EnumDependentServices(schService, SERVICE_ACTIVE,
lpDependencies, 0, &dwBytesNeeded, &dwCount))
{
// If the Enum call succeeds, then there are no dependent
// services, so do nothing.
return TRUE;
}
else
{
if (GetLastError() != ERROR_MORE_DATA)
return FALSE; // Unexpected error
// Allocate a buffer for the dependencies.
lpDependencies = (LPENUM_SERVICE_STATUS)HeapAlloc(
GetProcessHeap(), HEAP_ZERO_MEMORY, dwBytesNeeded);
if (!lpDependencies)
return FALSE;
__try {
// Enumerate the dependencies.
if (!EnumDependentServices(schService, SERVICE_ACTIVE,
lpDependencies, dwBytesNeeded, &dwBytesNeeded,
&dwCount))
return FALSE;
for (i = 0; i < dwCount; i++)
{
ess = *(lpDependencies + i);
// Open the service.
hDepService = OpenService(schSCManager,
ess.lpServiceName,
SERVICE_STOP | SERVICE_QUERY_STATUS);
if (!hDepService)
return FALSE;
__try {
// Send a stop code.
if (!ControlService(hDepService,
SERVICE_CONTROL_STOP,
(LPSERVICE_STATUS)&ssp))
return FALSE;
// Wait for the service to stop.
while (ssp.dwCurrentState != SERVICE_STOPPED)
{
Sleep(ssp.dwWaitHint);
if (!QueryServiceStatusEx(
hDepService,
SC_STATUS_PROCESS_INFO,
(LPBYTE)&ssp,
sizeof(SERVICE_STATUS_PROCESS),
&dwBytesNeeded))
return FALSE;
if (ssp.dwCurrentState == SERVICE_STOPPED)
break;
if (GetTickCount() - dwStartTime > dwTimeout)
return FALSE;
}
}
__finally
{
// Always release the service handle.
CloseServiceHandle(hDepService);
}
}
}
__finally
{
// Always free the enumeration buffer.
HeapFree(GetProcessHeap(), 0, lpDependencies);
}
}
return TRUE;
}
DWORD WinServiceHelper::StartMonitor(LPCWSTR serviceName, SC_HANDLE hService, DWORD timeOut)
{
long lResult;
DWORD dwError = ERROR_SUCCESS;
DWORD dwStatus;
DWORD dwMask;
DWORD dwBufSize;
NOTIFY_CONTEXT NotifyContext = { 0 };
SERVICE_NOTIFY snServiceNotify;
// Initialize callback context
NotifyContext.ServiceName = serviceName;
// Intialize notification struct
snServiceNotify.dwVersion = SERVICE_NOTIFY_STATUS_CHANGE;
snServiceNotify.pfnNotifyCallback = (PFN_SC_NOTIFY_CALLBACK)NotifyCallback;
snServiceNotify.pContext = &NotifyContext;
// We care about changes to RUNNING and STOPPED states only
dwMask = SERVICE_NOTIFY_RUNNING | SERVICE_NOTIFY_STOPPED;
//while (TRUE)
{
// Register for notification
dwStatus = NotifyServiceStatusChange(hService, dwMask, &snServiceNotify);
if (dwStatus != ERROR_SUCCESS)
{
SvcDebugOut(TEXT("NSSC failed - "), dwStatus);
dwError = dwStatus;
goto FnExit;
}
// Wait for notification to fire (or) for STOP control
//dwStatus = WaitForSingleObjectEx(g_hEvent, timeOut, TRUE);
// Check if this was signaled due to a SERVICE_STOP control
//if (dwStatus == WAIT_OBJECT_0)
//{
// break;
//}
}
FnExit:
return dwError;
}
void WinServiceHelper::CopyStrValue(std::wstring svalue, BSTR& target) {
size_t size = svalue.size() + 1;
if (!svalue.empty())
{
target = (wchar_t*)CoTaskMemAlloc(size * sizeof(wchar_t));
wmemcpy(target, svalue.c_str(), size);
}
}
VOID CALLBACK NotifyCallback(PVOID pParameter)
{
HRESULT hr = S_OK;
PSERVICE_NOTIFY pNotify = (PSERVICE_NOTIFY)pParameter;
PNOTIFY_CONTEXT pContext = (PNOTIFY_CONTEXT)pNotify->pContext;
TCHAR szStatus[1024];
if (pNotify->ServiceStatus.dwCurrentState == SERVICE_RUNNING)
{
hr = StringCchPrintf(szStatus, 1024, TEXT("%s %s.\r\n"), pContext->ServiceName, TEXT("entered running state"));
}
else
{
hr = StringCchPrintf(szStatus, 1024, TEXT("%s %s.\r\n"), pContext->ServiceName, TEXT("entered stopped state"));
}
if (hr != S_OK)
{
OutputDebugString(TEXT("Error creating status msg"));
}
else
{
WriteMonitorLog(szStatus);
}
}
VOID WriteMonitorLog(LPTSTR szStatus)
{
HANDLE hLogFile = INVALID_HANDLE_VALUE;
HRESULT hr = S_OK;
LPCTSTR szFileNameSuffix = TEXT("\\MonSvc\\SvcMonitor.log");
TCHAR szFileName[MAX_PATH];
BOOL bRet = FALSE;
DWORD dwSize;
if (szStatus == NULL)
{
SvcDebugOut(TEXT("Invalid service status - "), ERROR_INVALID_PARAMETER);
goto FnExit;
}
dwSize = ExpandEnvironmentStrings(TEXT("%ProgramFiles%"), szFileName, MAX_PATH);
if (dwSize == 0 || dwSize > MAX_PATH)
{
SvcDebugOut(TEXT("File name too long - "), GetLastError());
goto FnExit;
}
hr = StringCchCat(szFileName, MAX_PATH, szFileNameSuffix);
if (hr != S_OK)
{
SvcDebugOut(TEXT("File name too long - "), ERROR_INSUFFICIENT_BUFFER);
goto FnExit;
}
hLogFile = CreateFile(szFileName,
GENERIC_READ | GENERIC_WRITE,
0,
NULL,
OPEN_ALWAYS,
FILE_ATTRIBUTE_NORMAL,
NULL);
if (hLogFile == INVALID_HANDLE_VALUE)
{
SvcDebugOut(TEXT("Cannot open monitor log - "), GetLastError());
goto FnExit;
}
SetFilePointer(hLogFile, 0, NULL, FILE_END);
bRet = WriteFile(hLogFile, szStatus, DWORD((_tcslen(szStatus)) * sizeof(TCHAR)), &dwSize, NULL);
if (!bRet)
{
SvcDebugOut(TEXT("Cannot write to log - "), GetLastError());
}
FnExit:
CloseHandle(hLogFile);
}
VOID SvcDebugOut(const wchar_t* String, DWORD Status)
{
HRESULT hr = S_OK;
TCHAR Buffer[1024];
hr = StringCchPrintf(Buffer, 1024, String, Status);
if (hr == S_OK)
{
OutputDebugString(Buffer);
}
else
{
OutputDebugString(TEXT("Error in Dbg string"));
}
}
|
11cab570ae0f06b8ade9a88980679fb96b7b5818 | 3b43cf4cfc666798ebe85ed1db8858034b13d45c | /src/point_task.h | 372e52866fb0e025719948b6e35c7959e21df56f | [
"Apache-2.0"
] | permissive | Pandinosaurus/legate.numpy | 5428b80a0a53ab882cd74b5dbf5fd86c7ee82199 | 896f4fd9b32db445da6cdabf7b78d523fca96936 | refs/heads/master | 2023-06-27T04:33:52.982601 | 2021-07-01T21:39:52 | 2021-07-01T21:39:52 | 358,820,941 | 0 | 0 | Apache-2.0 | 2021-08-01T02:57:57 | 2021-04-17T08:06:05 | C++ | UTF-8 | C++ | false | false | 24,528 | h | point_task.h | /* Copyright 2021 NVIDIA Corporation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
#ifndef __NUMPY_POINT_TASK_H__
#define __NUMPY_POINT_TASK_H__
#include "numpy.h"
#include "proj.h"
#include <type_traits>
#if defined(LEGATE_USE_CUDA) && defined(__CUDACC__)
#include "cuda_help.h"
#endif
namespace legate {
namespace numpy {
// the primary template refers to an invalid task
template <NumPyOpCode op_code, NumPyVariantCode variant_code, class ResultType, class...>
constexpr int task_id = -1;
// nullary tasks themselves by ResultType
template <NumPyOpCode op_code, NumPyVariantCode variant_code, class ResultType>
constexpr int task_id<op_code, variant_code, ResultType> =
static_cast<int>(op_code) * NUMPY_TYPE_OFFSET + variant_code
+ legate_type_code_of<ResultType>* NUMPY_MAX_VARIANTS;
// unary tasks themselves by ArgumentType
template <NumPyOpCode op_code, NumPyVariantCode variant_code, class ResultType, class ArgumentType>
constexpr int task_id<op_code, variant_code, ResultType, ArgumentType> =
static_cast<int>(op_code) * NUMPY_TYPE_OFFSET + variant_code
+ legate_type_code_of<ArgumentType>* NUMPY_MAX_VARIANTS;
// binary tasks distinguish themselves by FirstArgumentType
template <NumPyOpCode op_code,
NumPyVariantCode variant_code,
class ResultType,
class FirstArgumentType,
class SecondArgumentType>
constexpr int task_id<op_code, variant_code, ResultType, FirstArgumentType, SecondArgumentType> =
static_cast<int>(op_code) * NUMPY_TYPE_OFFSET + variant_code
+ legate_type_code_of<FirstArgumentType>* NUMPY_MAX_VARIANTS;
// This is a small helper class that will also work if we have zero-sized arrays
// We also need to have this instead of std::array so that it works on devices
template <int DIM>
class Pitches {
public:
__CUDA_HD__
inline size_t flatten(const Legion::Rect<DIM + 1>& rect)
{
size_t pitch = 1;
size_t volume = 1;
for (int d = DIM; d >= 0; --d) {
// Quick exit for empty rectangle dimensions
if (rect.lo[d] > rect.hi[d]) return 0;
const size_t diff = rect.hi[d] - rect.lo[d] + 1;
volume *= diff;
if (d > 0) {
pitch *= diff;
pitches[d - 1] = pitch;
}
}
return volume;
}
__CUDA_HD__
inline Legion::Point<DIM + 1> unflatten(size_t index, const Legion::Point<DIM + 1>& lo) const
{
Legion::Point<DIM + 1> point = lo;
for (int d = 0; d < DIM; d++) {
point[d] += index / pitches[d];
index = index % pitches[d];
}
point[DIM] += index;
return point;
}
private:
size_t pitches[DIM];
};
// Specialization for the zero-sized case
template <>
class Pitches<0> {
public:
__CUDA_HD__
inline size_t flatten(const Legion::Rect<1>& rect)
{
if (rect.lo[0] > rect.hi[0])
return 0;
else
return (rect.hi[0] - rect.lo[0] + 1);
}
__CUDA_HD__
inline Legion::Point<1> unflatten(size_t index, const Legion::Point<1>& lo) const
{
Legion::Point<1> point = lo;
point[0] += index;
return point;
}
};
template <int DIM>
class CPULoop {
public:
static_assert(DIM <= 0, "Need more Looper instantiations");
};
// A small helper class that provides array index syntax for scalar
// value when abstracting over loop classes, this should be optimized
// away completely by the compiler's optimization passes
template <typename T, int DIM>
class Scalar {
public:
Scalar(const T& v) : value(v) {}
public:
inline Scalar<T, DIM - 1> operator[](coord_t) const { return Scalar<T, DIM - 1>(value); }
private:
const T& value;
};
template <typename T>
class Scalar<T, 1> {
public:
Scalar(const T& v) : value(v) {}
public:
inline const T& operator[](coord_t) const { return value; }
private:
const T& value;
};
template <>
class CPULoop<1> {
public:
template <typename Function, typename T, typename T1, typename... Args>
static inline void unary_loop(
const Function& func, const T& out, const T1& in, const Legion::Rect<1>& rect, Args&&... args)
{
for (int x = rect.lo[0]; x <= rect.hi[0]; ++x)
out[x] = func(in[x], std::forward<Args>(args)...);
}
template <typename Function, typename T, typename... Args>
static inline void unary_inplace(const Function& func,
const T& inout,
const Legion::Rect<1>& rect,
Args&&... args)
{
for (int x = rect.lo[0]; x <= rect.hi[0]; ++x)
inout[x] = func(inout[x], std::forward<Args>(args)...);
}
template <typename Function, typename T, typename T1, typename T2, typename... Args>
static inline void binary_loop(const Function& func,
const T& out,
const T1& in1,
const T2& in2,
const Legion::Rect<1>& rect,
Args&&... args)
{
for (int x = rect.lo[0]; x <= rect.hi[0]; ++x)
out[x] = func(in1[x], in2[x], std::forward<Args>(args)...);
}
template <typename Function, typename T, typename T1, typename... Args>
static inline void binary_inplace(
const Function& func, const T& inout, const T1& in, const Legion::Rect<1>& rect, Args&&... args)
{
for (int x = rect.lo[0]; x <= rect.hi[0]; ++x)
inout[x] = func(inout[x], in[x], std::forward<Args>(args)...);
}
};
template <>
class CPULoop<2> {
public:
template <typename Function, typename T, typename T1, typename... Args>
static inline void unary_loop(
const Function& func, const T& out, const T1& in1, const Legion::Rect<2>& rect, Args&&... args)
{
for (int x = rect.lo[0]; x <= rect.hi[0]; ++x)
for (int y = rect.lo[1]; y <= rect.hi[1]; ++y)
out[x][y] = func(in1[x][y], std::forward<Args>(args)...);
}
template <typename Function, typename T, typename... Args>
static inline void unary_inplace(const Function& func,
const T& inout,
const Legion::Rect<2>& rect,
Args&&... args)
{
for (int x = rect.lo[0]; x <= rect.hi[0]; ++x)
for (int y = rect.lo[1]; y <= rect.hi[1]; ++y)
inout[x][y] = func(inout[x][y], std::forward<Args>(args)...);
}
template <typename Function, typename T, typename T1, typename T2, typename... Args>
static inline void binary_loop(const Function& func,
const T& out,
const T1& in1,
const T2& in2,
const Legion::Rect<2>& rect,
Args&&... args)
{
for (int x = rect.lo[0]; x <= rect.hi[0]; ++x)
for (int y = rect.lo[1]; y <= rect.hi[1]; ++y)
out[x][y] = func(in1[x][y], in2[x][y], std::forward<Args>(args)...);
}
template <typename Function, typename T, typename T1, typename... Args>
static inline void binary_inplace(
const Function& func, const T& inout, const T1& in, const Legion::Rect<2>& rect, Args&&... args)
{
for (int x = rect.lo[0]; x <= rect.hi[0]; ++x)
for (int y = rect.lo[1]; y <= rect.hi[1]; ++y)
inout[x][y] = func(inout[x][y], in[x][y], std::forward<Args>(args)...);
}
};
template <>
class CPULoop<3> {
public:
template <typename Function, typename T, typename T1, typename... Args>
static inline void unary_loop(
const Function& func, const T& out, const T1& in1, const Legion::Rect<3>& rect, Args&&... args)
{
for (int x = rect.lo[0]; x <= rect.hi[0]; ++x)
for (int y = rect.lo[1]; y <= rect.hi[1]; ++y)
for (int z = rect.lo[2]; z <= rect.hi[2]; ++z)
out[x][y][z] = func(in1[x][y][z], std::forward<Args>(args)...);
}
template <typename Function, typename T, typename... Args>
static inline void unary_inplace(const Function& func,
const T& inout,
const Legion::Rect<3>& rect,
Args&&... args)
{
for (int x = rect.lo[0]; x <= rect.hi[0]; ++x)
for (int y = rect.lo[1]; y <= rect.hi[1]; ++y)
for (int z = rect.lo[2]; z <= rect.hi[2]; ++z)
inout[x][y][z] = func(inout[x][y][z], std::forward<Args>(args)...);
}
template <typename Function, typename T, typename T1, typename T2, typename... Args>
static inline void binary_loop(const Function& func,
const T& out,
const T1& in1,
const T2& in2,
const Legion::Rect<3>& rect,
Args&&... args)
{
for (int x = rect.lo[0]; x <= rect.hi[0]; ++x)
for (int y = rect.lo[1]; y <= rect.hi[1]; ++y)
for (int z = rect.lo[2]; z <= rect.hi[2]; ++z)
out[x][y][z] = func(in1[x][y][z], in2[x][y][z], std::forward<Args>(args)...);
}
template <typename Function, typename T, typename T1, typename... Args>
static inline void binary_inplace(
const Function& func, const T& inout, const T1& in, const Legion::Rect<3>& rect, Args&&... args)
{
for (int x = rect.lo[0]; x <= rect.hi[0]; ++x)
for (int y = rect.lo[1]; y <= rect.hi[1]; ++y)
for (int z = rect.lo[2]; z <= rect.hi[2]; ++z)
inout[x][y][z] = func(inout[x][y][z], in[x][y][z], std::forward<Args>(args)...);
}
};
template <>
class CPULoop<4> {
public:
template <typename Function, typename T, typename T1, typename... Args>
static inline void unary_loop(
const Function& func, const T& out, const T1& in1, const Legion::Rect<4>& rect, Args&&... args)
{
for (int x = rect.lo[0]; x <= rect.hi[0]; ++x)
for (int y = rect.lo[1]; y <= rect.hi[1]; ++y)
for (int z = rect.lo[2]; z <= rect.hi[2]; ++z)
for (int w = rect.lo[3]; w <= rect.hi[3]; ++w)
out[x][y][z][w] = func(in1[x][y][z][w], std::forward<Args>(args)...);
}
template <typename Function, typename T, typename... Args>
static inline void unary_inplace(const Function& func,
const T& inout,
const Legion::Rect<4>& rect,
Args&&... args)
{
for (int x = rect.lo[0]; x <= rect.hi[0]; ++x)
for (int y = rect.lo[1]; y <= rect.hi[1]; ++y)
for (int z = rect.lo[2]; z <= rect.hi[2]; ++z)
for (int w = rect.lo[3]; w <= rect.hi[3]; ++w)
inout[x][y][z][w] = func(inout[x][y][z][w], std::forward<Args>(args)...);
}
template <typename Function, typename T, typename T1, typename T2, typename... Args>
static inline void binary_loop(const Function& func,
const T& out,
const T1& in1,
const T2& in2,
const Legion::Rect<4>& rect,
Args&&... args)
{
for (int x = rect.lo[0]; x <= rect.hi[0]; ++x)
for (int y = rect.lo[1]; y <= rect.hi[1]; ++y)
for (int z = rect.lo[2]; z <= rect.hi[2]; ++z)
for (int w = rect.lo[3]; w <= rect.hi[3]; ++w)
out[x][y][z][w] = func(in1[x][y][z][w], in2[x][y][z][w], std::forward<Args>(args)...);
}
template <typename Function, typename T, typename T1, typename... Args>
static inline void binary_inplace(
const Function& func, const T& inout, const T1& in, const Legion::Rect<4>& rect, Args&&... args)
{
for (int x = rect.lo[0]; x <= rect.hi[0]; ++x)
for (int y = rect.lo[1]; y <= rect.hi[1]; ++y)
for (int z = rect.lo[2]; z <= rect.hi[2]; ++z)
for (int w = rect.lo[3]; w <= rect.hi[3]; ++w)
inout[x][y][z][w] =
func(inout[x][y][z][w], in[x][y][z][w], std::forward<Args>(args)...);
}
};
#ifdef LEGATE_USE_OPENMP
template <int DIM>
class OMPLoop {
public:
static_assert(DIM <= 0, "Need more OmpLooper instantiations");
};
template <>
class OMPLoop<1> {
public:
template <typename Function, typename T, typename T1, typename... Args>
static inline void unary_loop(
const Function& func, const T& out, const T1& in, const Legion::Rect<1>& rect, Args&&... args)
{
#pragma omp parallel for schedule(static)
for (int x = rect.lo[0]; x <= rect.hi[0]; ++x)
out[x] = func(in[x], std::forward<Args>(args)...);
}
template <typename Function, typename T, typename... Args>
static inline void unary_inplace(const Function& func,
const T& inout,
const Legion::Rect<1>& rect,
Args&&... args)
{
#pragma omp parallel for schedule(static)
for (int x = rect.lo[0]; x <= rect.hi[0]; ++x)
inout[x] = func(inout[x], std::forward<Args>(args)...);
}
template <typename Function, typename T, typename T1, typename T2, typename... Args>
static inline void binary_loop(const Function& func,
const T& out,
const T1& in1,
const T2& in2,
const Legion::Rect<1>& rect,
Args&&... args)
{
#pragma omp parallel for schedule(static)
for (int x = rect.lo[0]; x <= rect.hi[0]; ++x)
out[x] = func(in1[x], in2[x], std::forward<Args>(args)...);
}
template <typename Function, typename T, typename T1, typename... Args>
static inline void binary_inplace(
const Function& func, const T& inout, const T1& in, const Legion::Rect<1>& rect, Args&&... args)
{
#pragma omp parallel for schedule(static)
for (int x = rect.lo[0]; x <= rect.hi[0]; ++x)
inout[x] = func(inout[x], in[x], std::forward<Args>(args)...);
}
};
template <>
class OMPLoop<2> {
public:
template <typename Function, typename T, typename T1, typename... Args>
static inline void unary_loop(
const Function& func, const T& out, const T1& in1, const Legion::Rect<2>& rect, Args&&... args)
{
#pragma omp parallel for schedule(static), collapse(2)
for (int x = rect.lo[0]; x <= rect.hi[0]; ++x)
for (int y = rect.lo[1]; y <= rect.hi[1]; ++y)
out[x][y] = func(in1[x][y], std::forward<Args>(args)...);
}
template <typename Function, typename T, typename... Args>
static inline void unary_inplace(const Function& func,
const T& inout,
const Legion::Rect<2>& rect,
Args&&... args)
{
#pragma omp parallel for schedule(static), collapse(2)
for (int x = rect.lo[0]; x <= rect.hi[0]; ++x)
for (int y = rect.lo[1]; y <= rect.hi[1]; ++y)
inout[x][y] = func(inout[x][y], std::forward<Args>(args)...);
}
template <typename Function, typename T, typename T1, typename T2, typename... Args>
static inline void binary_loop(const Function& func,
const T& out,
const T1& in1,
const T2& in2,
const Legion::Rect<2>& rect,
Args&&... args)
{
#pragma omp parallel for schedule(static), collapse(2)
for (int x = rect.lo[0]; x <= rect.hi[0]; ++x)
for (int y = rect.lo[1]; y <= rect.hi[1]; ++y)
out[x][y] = func(in1[x][y], in2[x][y], std::forward<Args>(args)...);
}
template <typename Function, typename T, typename T1, typename... Args>
static inline void binary_inplace(
const Function& func, const T& inout, const T1& in, const Legion::Rect<2>& rect, Args&&... args)
{
#pragma omp parallel for schedule(static), collapse(2)
for (int x = rect.lo[0]; x <= rect.hi[0]; ++x)
for (int y = rect.lo[1]; y <= rect.hi[1]; ++y)
inout[x][y] = func(inout[x][y], in[x][y], std::forward<Args>(args)...);
}
};
template <>
class OMPLoop<3> {
public:
template <typename Function, typename T, typename T1, typename... Args>
static inline void unary_loop(
const Function& func, const T& out, const T1& in1, const Legion::Rect<3>& rect, Args&&... args)
{
#pragma omp parallel for schedule(static), collapse(3)
for (int x = rect.lo[0]; x <= rect.hi[0]; ++x)
for (int y = rect.lo[1]; y <= rect.hi[1]; ++y)
for (int z = rect.lo[2]; z <= rect.hi[2]; ++z)
out[x][y][z] = func(in1[x][y][z], std::forward<Args>(args)...);
}
template <typename Function, typename T, typename... Args>
static inline void unary_inplace(const Function& func,
const T& inout,
const Legion::Rect<3>& rect,
Args&&... args)
{
#pragma omp parallel for schedule(static), collapse(3)
for (int x = rect.lo[0]; x <= rect.hi[0]; ++x)
for (int y = rect.lo[1]; y <= rect.hi[1]; ++y)
for (int z = rect.lo[2]; z <= rect.hi[2]; ++z)
inout[x][y][z] = func(inout[x][y][z], std::forward<Args>(args)...);
}
template <typename Function, typename T, typename T1, typename T2, typename... Args>
static inline void binary_loop(const Function& func,
const T& out,
const T1& in1,
const T2& in2,
const Legion::Rect<3>& rect,
Args&&... args)
{
#pragma omp parallel for schedule(static), collapse(3)
for (int x = rect.lo[0]; x <= rect.hi[0]; ++x)
for (int y = rect.lo[1]; y <= rect.hi[1]; ++y)
for (int z = rect.lo[2]; z <= rect.hi[2]; ++z)
out[x][y][z] = func(in1[x][y][z], in2[x][y][z], std::forward<Args>(args)...);
}
template <typename Function, typename T, typename T1, typename... Args>
static inline void binary_inplace(
const Function& func, const T& inout, const T1& in, const Legion::Rect<3>& rect, Args&&... args)
{
#pragma omp parallel for schedule(static), collapse(3)
for (int x = rect.lo[0]; x <= rect.hi[0]; ++x)
for (int y = rect.lo[1]; y <= rect.hi[1]; ++y)
for (int z = rect.lo[2]; z <= rect.hi[2]; ++z)
inout[x][y][z] = func(inout[x][y][z], in[x][y][z], std::forward<Args>(args)...);
}
};
template <>
class OMPLoop<4> {
public:
template <typename Function, typename T, typename T1, typename... Args>
static inline void unary_loop(
const Function& func, const T& out, const T1& in1, const Legion::Rect<4>& rect, Args&&... args)
{
#pragma omp parallel for schedule(static), collapse(4)
for (int x = rect.lo[0]; x <= rect.hi[0]; ++x)
for (int y = rect.lo[1]; y <= rect.hi[1]; ++y)
for (int z = rect.lo[2]; z <= rect.hi[2]; ++z)
for (int w = rect.lo[3]; w <= rect.hi[3]; ++w)
out[x][y][z][w] = func(in1[x][y][z][w], std::forward<Args>(args)...);
}
template <typename Function, typename T, typename... Args>
static inline void unary_inplace(const Function& func,
const T& inout,
const Legion::Rect<4>& rect,
Args&&... args)
{
#pragma omp parallel for schedule(static), collapse(4)
for (int x = rect.lo[0]; x <= rect.hi[0]; ++x)
for (int y = rect.lo[1]; y <= rect.hi[1]; ++y)
for (int z = rect.lo[2]; z <= rect.hi[2]; ++z)
for (int w = rect.lo[3]; w <= rect.hi[3]; ++w)
inout[x][y][z][w] = func(inout[x][y][z][w], std::forward<Args>(args)...);
}
template <typename Function, typename T, typename T1, typename T2, typename... Args>
static inline void binary_loop(const Function& func,
const T& out,
const T1& in1,
const T2& in2,
const Legion::Rect<4>& rect,
Args&&... args)
{
#pragma omp parallel for schedule(static), collapse(4)
for (int x = rect.lo[0]; x <= rect.hi[0]; ++x)
for (int y = rect.lo[1]; y <= rect.hi[1]; ++y)
for (int z = rect.lo[2]; z <= rect.hi[2]; ++z)
for (int w = rect.lo[3]; w <= rect.hi[3]; ++w)
out[x][y][z][w] = func(in1[x][y][z][w], in2[x][y][z][w], std::forward<Args>(args)...);
}
template <typename Function, typename T, typename T1, typename... Args>
static inline void binary_inplace(
const Function& func, const T& inout, const T1& in, const Legion::Rect<4>& rect, Args&&... args)
{
#pragma omp parallel for schedule(static), collapse(4)
for (int x = rect.lo[0]; x <= rect.hi[0]; ++x)
for (int y = rect.lo[1]; y <= rect.hi[1]; ++y)
for (int z = rect.lo[2]; z <= rect.hi[2]; ++z)
for (int w = rect.lo[3]; w <= rect.hi[3]; ++w)
inout[x][y][z][w] =
func(inout[x][y][z][w], in[x][y][z][w], std::forward<Args>(args)...);
}
};
#endif
template <class Derived>
class PointTask : public NumPyTask<Derived> {
public:
static void cpu_variant(const Legion::Task* task,
const std::vector<Legion::PhysicalRegion>& regions,
Legion::Context,
Legion::Runtime*)
{
LegateDeserializer derez(task->args, task->arglen);
const int dim = derez.unpack_dimension();
switch (dim) {
#define DIMFUNC(DIM) \
case DIM: { \
Derived::template dispatch_cpu<DIM>(task, regions, derez); \
break; \
}
LEGATE_FOREACH_N(DIMFUNC)
#undef DIMFUNC
default: assert(false);
}
}
#ifdef LEGATE_USE_OPENMP
static void omp_variant(const Legion::Task* task,
const std::vector<Legion::PhysicalRegion>& regions,
Legion::Context ctx,
Legion::Runtime* runtime)
{
LegateDeserializer derez(task->args, task->arglen);
const int dim = derez.unpack_dimension();
switch (dim) {
#define DIMFUNC(DIM) \
case DIM: { \
Derived::template dispatch_omp<DIM>(task, regions, derez); \
break; \
}
LEGATE_FOREACH_N(DIMFUNC)
#undef DIMFUNC
default: assert(false);
}
}
#endif
#if defined(LEGATE_USE_CUDA) and defined(__CUDACC__)
static void gpu_variant(const Legion::Task* task,
const std::vector<Legion::PhysicalRegion>& regions,
Legion::Context ctx,
Legion::Runtime* runtime)
{
LegateDeserializer derez(task->args, task->arglen);
const int dim = derez.unpack_dimension();
switch (dim) {
#define DIMFUNC(DIM) \
case DIM: { \
Derived::template dispatch_gpu<DIM>(task, regions, derez); \
break; \
}
LEGATE_FOREACH_N(DIMFUNC)
#undef DIMFUNC
default: assert(false);
}
}
#elif defined(LEGATE_USE_CUDA)
static void gpu_variant(const Legion::Task* task,
const std::vector<Legion::PhysicalRegion>& regions,
Legion::Context ctx,
Legion::Runtime* runtime);
#endif
private:
struct StaticRegistrar {
StaticRegistrar() { PointTask::register_variants(); }
};
virtual void force_instantiation_of_static_registrar() { (void)&static_registrar; }
// this static member registers this task's variants during static initialization
static const StaticRegistrar static_registrar;
};
// this is the definition of PointTask::static_registrar
template <class Derived>
const typename PointTask<Derived>::StaticRegistrar PointTask<Derived>::static_registrar{};
} // namespace numpy
} // namespace legate
#endif // __NUMPY_POINT_TASK_H__
|
9304c2a59143f34c87ee1e878cb289bc4dd3acef | 91f82b843cf7f7ac1c074a62baed9424f0778ff7 | /code/c++/utils/trunk/utils/xml/test.cpp | 10bbec0be25c0d4198e182c0cfa06808fbbe3aeb | [] | no_license | zeuswang/code | 7009804c6851acf031a0aa176c03314eac682aef | d580f39acfe78fd94e73777547ddfc67591b27f7 | refs/heads/master | 2016-09-06T05:28:52.453145 | 2015-04-10T07:27:20 | 2015-04-10T07:27:20 | 19,226,711 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,723 | cpp | test.cpp | #include "sxml.h"
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdio.h>
int main(){
std::string xml=
"<?xml version=\"1.0\" encoding=\"gbk\"?> \
<DOCUMENT> \
<item> \
<key ><![CDATA[beijing]]></key> \
<display> \
<title><![CDATA[XXXXXXXXXXXXXXXX]]></title> \
<url><![CDATA[http://www.weather.com.cn/weather/101010100.shtml]]></url> \
</display> \
<classid>207302</classid> \
<term><![CDATA[(beijing)]]></term> \
</item> \
<item> \
<key ><![CDATA[beijing2]]></key> \
<display> \
<title><![CDATA[XXXXXXXXXXXXXXXX]]></title> \
<url><![CDATA[http://www.weather.com.cn/weather/101010100.shtml]]></url> \
</display> \
<classid>207302</classid> \
<term><![CDATA[(beijing2)]]></term> \
</item> \
</DOCUMENT>";
/*
SXmlDocument doc;
doc.Parse(xml,"utf-8");
SXmlNode old_node=doc.GetRoot().GetChildren();
for(SXmlNode i=old_node;!i.Null();i=i.GetNext()){
printf("term:%s",i.GetChildren("term").GetContent().c_str());
}
*/
char buf[4096];
int fd = open("1.test",O_RDONLY);
std::string tmp;
while (1)
{
int ret =read(fd, buf,4096);
if (ret <=0)
break;
tmp += std::string(buf,ret);
}
//printf("str=%s\n",tmp.c_str());
SXmlDocument doc;
doc.Parse(tmp,"gbk");
SXmlNode old_node=doc.GetRoot().GetChildren();
for(SXmlNode i=old_node;!i.Null();i=i.GetNext()){
printf("name=%s\n",i.GetName().c_str());
if (i.GetName() == "doc")
{
printf("title=%s\n",i.GetChildren("item").GetChildren("display").GetChildren("title").GetContent().c_str());
printf("TRank=%s\n",i.GetChildren("rank").GetAttribute("TRank").c_str());
}
//printf("title:%s\n",i.GetChildren("title").GetContent().c_str());
}
}
|
79b1e70e7b20836c81d4933b62b04e7198d36c07 | 9c6cfa12a1d7f6d85a1b1a261afb934ca02e88c4 | /90.cpp | 86b2f3521fd9cc250d2af7d55c2428a3615d28df | [] | no_license | wzl476227014/test | 92254475a79d0ed898bbb292ac306a1c1bf052ca | 76118c1f280a46374d61424ecd01b40a99b7e94c | refs/heads/master | 2021-01-19T08:48:21.498503 | 2017-11-18T06:15:19 | 2017-11-18T06:15:19 | 87,680,746 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 821 | cpp | 90.cpp | /*
* File Name : 90.cpp
* Author : Andrew ()
* Description :
* version 1.0: 2017-11-18 14:07:50
*/
class Solution {
public:
vector<vector<int>> subsetsWithDup(vector<int>& nums) {
vector<vector<int>> res(1);
if(nums.empty())
return {};
sort(nums.begin(),nums.end());
int size= 1;
int last=nums[0];
for(int i = 0;i < nums.size();i++){
if(last!=nums[i]){
last=nums[i];
size=res.size();
}
int newv=res.size();
for(int j=newv-size;j<newv;j++){
res.push_back(res[j]);
res.back().push_back(nums[i]);
}
}
return res;
}
};
|
38a3f89405fd66ffa2b70f6d3a0ba882cec7b395 | a5a500f0fcf4ace40c28f14b8e52d2d26ace24e9 | /CS389_HW1/P1.cpp | 09688c213fb9bda7b08177e3089029fdeabb1504 | [] | no_license | Ryman1262645/HelloWorld | 3108b52a579b8f98efee133c34a25ae77b3b5c6d | c42c895b69b707d7658200db9abb80190fa24819 | refs/heads/master | 2020-03-29T21:23:41.981395 | 2018-10-02T03:33:07 | 2018-10-02T03:33:07 | 150,364,290 | 0 | 0 | null | 2018-09-26T04:13:58 | 2018-09-26T03:37:12 | C++ | UTF-8 | C++ | false | false | 4,694 | cpp | P1.cpp | #include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <stdint.h>
#include <cmath>
#include <ctime>
#include <chrono>
#include <fstream>
#include <iostream>
#include <ratio>
#include <random>
#include <algorithm>
using namespace std;
//generates a list of length size with integers of values between 0 and bound
int8_t * generate_random_list(int64_t size, int16_t bound)
{
int8_t* list;
list = new int8_t [size];
if(!list){/*death*/}
//srand(size);
for(int64_t i = 0; i < size; i++)
{
list[i] = rand();
if(list[i] < 0) {list[i] = list[i] * -1;}
list[i] = list[i]%bound;
}
return list;
}
//returns a random integer smaller than sz/10
int64_t make_stride(int64_t sz)
{
int64_t stride = 0;
stride = rand();
if (stride < 0) {stride = -1 * stride;}
stride = stride % (sz/10); //the 10 is totally arbitrary, we just don't want stride to be huge
return stride;
}
//main takes argumeents size, iters, and loop_iters
//size is x in 2^x
//iters is the number of times the entire buffer will be strided through mod a particular prime
//loop_iters is the number of times the a new prime will be picked and the iters loop will be re-run.
//basically, the "iters" loop is nested in the "loop_iters" loop. so the number of actual iterations is (loop_iters * iters)
int main (int argc, char **argv)
{
if(argc != 4) {printf("Wrong # of arguments!! Need buffer size, #iterations, #loop_iterations.\n"); return 0;}
ofstream outfile; //open file
outfile.open("output.txt", std::ios_base::app);
//take arguments
int64_t size = atoi(argv[1]);
int64_t iters = atoi(argv[2]);
int64_t loop_iters = atoi(argv[3]);
srand(size); //seed random with size
size = pow(2,size);
int8_t *arrboy = generate_random_list(size, 256); //generate an array of 2^(N) random bytes
//LOOP
double loop_avg = 0;
for(int64_t l = 0; l < loop_iters; l++)
{
int64_t stride = make_stride(size); //randomly generate stride in N
int64_t reader;
for(int64_t r = 0; r < size; r++) {reader = reader + arrboy[r];} //read all the bytes once - try to give the cache a chance.
int64_t saved_reader = reader; //save the sum of all read bytes so compiler doesn't just skip this step
reader = 0;
struct timespec start, stop;
int64_t proportion = (size / 256);
clock_gettime(CLOCK_MONOTONIC_RAW, &start); //start the clock
//read all the bytes (iters) times -- read them weirdly so that we can foil AMD/Intel
for(int64_t ov = 0; ov < iters; ov++)
{
for(int64_t it = 0; it < size; it++) //explanation at bottom of file
{
reader = reader + arrboy[reader]; //(1)
if(reader > size) {reader = reader - size;}
if(reader < 1) {reader = 256;}
reader = reader * proportion; //(2)
reader = reader + stride; //(3)
while(reader > size) {reader = reader - size;}
}
}
clock_gettime(CLOCK_MONOTONIC_RAW, &stop); //stop the clock
long ss = (stop.tv_sec - start.tv_sec);
long ns = (stop.tv_nsec - start.tv_nsec);
cout << saved_reader << endl;
cout << reader << endl;
double time_elapsed = ((double)ss * 1000000000) + (double)ns;
double avg_time = time_elapsed/(size * iters); //compute N/time elapsed
printf("How many nanoseconds per access was it?\nWell, it was...... %fns/access!!\n", avg_time); //print it!
cout << "Time: " << avg_time << "ns/access\tN: " << size << "\tIters: " << iters << "\tLoop_iters:" << loop_iters << "\n";
loop_avg = loop_avg + avg_time;
}
loop_avg = loop_avg / loop_iters;
outfile << loop_avg << "," << iters << "," << size << "," << loop_iters << "\n"; //save the result to a text file
delete [] arrboy;
outfile.close();
}
//how does the block at line 79 work? well -
//every value in arrboy is 0-255, because it's a byte. proportion is (size/256). (1)
//If we read a (value * proportion), we pick 256 random points along arrboy. (2) + (1)
//But, the cache will just save those 256 items.
//So we add stride to reader, and keep reader as a running sum. (3) + (1)
//That way, on each loop, we break into 256 new possible indices.
//Therefore, to prefetch just one loop ahead, the cache would neet to store (256^2) possible indices.
//The cache then gets flooded with bytes and has to overflow upwards from cache, to cache, to cache, to DRAM.
//Josh&Ryan: 1, Intel/AMD: 0
//If we had to share our regrets -
//Line 88 is almost definitely creating some unecessary overhead.
//I tried for a very long time to make a function that could trick the CPU put wouldn't need that while loop,
//... but never could quite figure it out. It's not a huge amount of overhead, but it would be nice to remove.
//The fact that the while loop works but the mod operator does not is super super interesting, though. |
9f23b5d5b44728192bd593ae3112f1a6fd142e8c | 4612e46be4ccd2c05c67baa6359b7d0281fd5f1a | /util/concurrency/spin_lock.h | 718fc2a85fc44e9116126b2e0704b757ca377c02 | [
"Apache-2.0"
] | permissive | RedBeard0531/mongo_utils | eed1e06c18cf6ff0e6f076fdfc8a71d5791bb95c | 402c2023df7d67609ce9da8e405bf13cdd270e20 | refs/heads/master | 2021-03-31T01:03:41.719260 | 2018-06-03T11:27:47 | 2018-06-03T11:27:47 | 124,802,061 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,892 | h | spin_lock.h | // spin_lock.h
/**
* Copyright (C) 2008 10gen 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.
*/
#pragma once
#ifdef _WIN32
#include "mongo/platform/windows_basic.h"
#else
#include <atomic>
#endif
#include "mongo/base/disallow_copying.h"
#include "mongo/platform/compiler.h"
#include "mongo/stdx/mutex.h"
namespace mongo {
#if defined(_WIN32)
class SpinLock {
MONGO_DISALLOW_COPYING(SpinLock);
public:
SpinLock() {
InitializeCriticalSectionAndSpinCount(&_cs, 4000);
}
~SpinLock() {
DeleteCriticalSection(&_cs);
}
void lock() {
EnterCriticalSection(&_cs);
}
void unlock() {
LeaveCriticalSection(&_cs);
}
private:
CRITICAL_SECTION _cs;
};
#else
class SpinLock {
MONGO_DISALLOW_COPYING(SpinLock);
public:
SpinLock() = default;
void unlock() {
_locked.clear(std::memory_order_release);
}
void lock() {
if (MONGO_likely(_tryLock()))
return;
_lockSlowPath();
}
private:
bool _tryLock() {
bool wasLocked = _locked.test_and_set(std::memory_order_acquire);
return !wasLocked;
}
void _lockSlowPath();
// Initializes to the cleared state.
std::atomic_flag _locked = ATOMIC_FLAG_INIT; // NOLINT
};
#endif
using scoped_spinlock = stdx::lock_guard<SpinLock>;
} // namespace mongo
|
fdebe51c2f7e6552f3b98f160b8beb3c30162c3b | 88da7979f4b35a5093c83e8c7a5f469de2154612 | /postfix-mshaynerush-spu-master/main.cpp | 990d4c91b6a6acd39442bb0c927a9ccf1484d20b | [] | no_license | mshaynerush/postfix | 1cfd18433f35132634c83f05a897d2f5723f8041 | 016aa6da634132efe10b08c4b7a151d869a8d596 | refs/heads/main | 2023-07-02T00:08:49.667653 | 2021-08-11T18:35:11 | 2021-08-11T18:35:11 | 395,084,201 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 4,000 | cpp | main.cpp | #include "evaluator.h"
#include <cmath>
#include <iostream>
#include <iomanip>
#include <string>
#include <queue>
using std::cout;
using std::cerr;
using std::endl;
using std::string;
using std::queue;
using std::setw;
using std::fixed;
using std::setprecision;
bool DoubleEquals(double a, double b, double e = 1e-6);
int main(int argc, char* argv[]){
string tests[] = {
"2 14 + 1 5 + *", // 96
"2 5 ^ 5 +", // 37
"4 + 5", // Error
"2 3 ^ 3 * 21 3 / +", // 31
"15 2 /", // 7.5
"100 90 - 5 3 - /", // 5
"10 5 - 2 * 4 3 ^ 2 3 / / +", //106
"10 5+", // error
"some", // error
"2 2 + 4 + 5 * 30 - 5 * 25 /", // 2
"4 5 10 3 - * +" // 39
};
string correctResults[] ={
"96",
"37",
"E",
"31",
"7.5",
"5",
"106",
"E",
"E",
"2",
"39"
};
string extraCredit[] = {
"2.5 2 *",
"2.7172 3.0 ^ 3.1415954 /",
"1.2 5 * 0.75 0.75 + /"
};
string extraCreditResults[] = {
"5",
"6.385789014221246",
"4"
};
bool error;
double grade = 0;
const size_t TOTAL_TESTS = sizeof(tests)/sizeof(string);
cout << "Normal Tests: " << endl;
cout << "= = = = = = = = = = = = = = = = = = = = = = = = = = = = = " << endl;
for (size_t i = 0; i < TOTAL_TESTS; i++) {
double result = Evaluate(tests[i], error);
if (error && correctResults[i] == "E"){
grade++;
cerr << " * * * * There was an error * * * * \t" << tests[i]
<< "\t" << fixed << setprecision(2) << (grade / TOTAL_TESTS * 100) << endl;
}else if (!error && DoubleEquals(stod(correctResults[i]), result)){
grade++;
cout << setw(37) << tests[i] << " = " << setw(5) << result
<< "\t" << fixed << setprecision(2) << (grade / TOTAL_TESTS * 100) << endl;
}else{
cout << "Test " << (i + 1) << " Failed" << endl;
}
}
cout << "Unit Tests Grade: " << fixed << setprecision(2) << (grade / TOTAL_TESTS * 100) << endl;
double xGrade = 0;
const size_t XTOTAL_TESTS = sizeof(extraCredit)/sizeof(string);
cout << "Extra Credit Tests: " << endl;
cout << "= = = = = = = = = = = = = = = = = = = = = = = = = = = = = " << endl;
for (size_t i = 0; i < XTOTAL_TESTS; i++) {
double result = Evaluate(extraCredit[i], error);
if (error && extraCreditResults[i] == "E"){
xGrade++;
cerr << " * * * * There was an error * * * * \t" << extraCredit[i]
<< "\t" << fixed << setprecision(2) << (xGrade / XTOTAL_TESTS * 100) << endl;
}else if (!error && DoubleEquals(stod(extraCreditResults[i]), result)){
xGrade++;
cout << setw(37) << extraCredit[i] << " = " << setw(5) << result
<< "\t" << fixed << setprecision(2) << (xGrade / XTOTAL_TESTS * 100) << endl;
}else{
cout << "Test " << (i + 1) << " Failed" << endl;
}
}
cout << "Extra Credit Unit Tests Grade: " << fixed << setprecision(2) << (xGrade / XTOTAL_TESTS * 100 * 0.3) << endl;
double normalGrade = (grade / TOTAL_TESTS * 100);
double extraGrade = (xGrade / XTOTAL_TESTS * 100 * 0.3);
cout << "= = = = = = = = = = = = = = = = = = = = = = = = = = = = = " << endl << endl << endl;
cout << "Unit Tests Final Grade: " << endl;
cout << "Normal Test: " << setw(6) << fixed << setprecision(2) << normalGrade << endl;
cout << "Extra Credit: " << setw(6) << fixed << setprecision(2) << extraGrade << endl;
cout << endl;
cout << "Total: " << setw(6) << fixed << setprecision(2) << (normalGrade + extraGrade) << endl;
return 0;
}
bool DoubleEquals(double a, double b, double e){
return abs(a - b) < e;
}
|
7cac91286f3bc082d2e202a9bf55a5a798af11a4 | 674cad3c5f99f608f920b70c7ea865d72cfe940c | /Uri/Geral/uri2166.cpp | f8e0cd5dfcde334cc7805877f9cc934adc861fcd | [] | no_license | wellvolks/Problemas | c876b6120f1622d614767ecc99dba802c395e772 | 6513ea2b126977f45cb2388f753188e95328af2e | refs/heads/master | 2020-06-30T18:38:15.453372 | 2017-11-20T00:42:36 | 2017-11-20T00:42:36 | 67,306,714 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 321 | cpp | uri2166.cpp | #include <bits/stdc++.h>
using namespace std;
double solve(int qt){
if( qt == 1 ) return 2;
return 2 + 1./solve(qt-1);
}
int main(){
ios::sync_with_stdio(false);
int a;
cin >> a;
if( a == 0 ) cout << "1.0000000000\n";
else cout << fixed << setprecision(10) << 1+1./solve(a) << '\n';
return 0;
} |
0cd3e6e31ea421d927553fe6aa4d0bcb31df24e8 | 29d95430654dc0cb5d617d832d1b39f338b508ea | /main.cpp | 61fbfb3813b69ffeba6ba33cebc3d59dff26f8b0 | [] | no_license | lucaslefaucheur/Heightmap | 32313193488c411fce4cb21a92db98bb19055587 | 6956fa7dc3ca76eda048c143023f8e197ad5cceb | refs/heads/master | 2020-04-10T09:51:30.508924 | 2018-12-08T14:53:03 | 2018-12-08T14:53:03 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,174 | cpp | main.cpp | #include <GL/glew.h>
#include <GLFW/glfw3.h>
#include <iostream>
#include <cstdlib>
#include <vector>
#include "controls.h"
#include "mesh.h"
#define SCREEN_WIDTH 800
#define SCREEN_HEIGHT 800
int main() {
vector<GLfloat> pixels = loadImage("/Users/lucaslefaucheur/Desktop/Assignment1/Assignment1/test1.bmp");
// Create a window and its OpenGL context
GLFWwindow *window;
// Initialize the library
if (!glfwInit())
return -1;
window = glfwCreateWindow(SCREEN_WIDTH, SCREEN_HEIGHT, "Assignment1", NULL, NULL);
glfwSetKeyCallback(window, keyCallback);
glfwSetInputMode(window, GLFW_STICKY_KEYS, 1);
glfwSetScrollCallback(window, scrollCallback);
int screenWidth, screenHeight;
glfwGetFramebufferSize(window, &screenWidth, &screenHeight);
if (!window) {
glfwTerminate();
return -1;
}
glfwMakeContextCurrent(window); // Make the window's context current
glViewport(0.0f, 0.0f, screenWidth, screenHeight); // Part of the window to which OpenGL will draw
// Projection matrix: define the properties of the camera that views the objects in the world coordinate frame
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
// Modelview matrix: define how objects are transformed (translation, rotation; scaling) in the world coordinate frame
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glOrtho(0, SCREEN_WIDTH, 0, SCREEN_HEIGHT, 0, 20000); // Set coordinate system
// Loop until user closes the window
while (!glfwWindowShouldClose(window)) {
glClear(GL_COLOR_BUFFER_BIT);
// Render OpenGL
glPushMatrix();
glTranslatef(SCREEN_WIDTH/2, SCREEN_HEIGHT/2, -500);
glRotatef(rotationX, 1, 0, 0);
glRotatef(rotationY, 0, 1, 0);
glTranslatef(-SCREEN_WIDTH/2, -SCREEN_HEIGHT/2, 500);
DrawMesh(SCREEN_WIDTH/2, SCREEN_HEIGHT/2, -500, pixels);
glPopMatrix();
glfwSwapBuffers(window); // Swap front and back buffers
glfwPollEvents(); // Poll for and process events
}
glfwTerminate();
return 0;
}
|
fc49995ee7c4e6741d52847935fe424cfc55e0bc | bd194f11cc9a335c07d165d06d41fbfda75d8378 | /qframework/Root/TQNFManualSetter.cxx | f4d05aeaf52f43ce70af6c7230c8bb365a089016 | [] | no_license | sgnoohc/rooutil | f8f52d860c3bdd61433942ebcf1a7fb42ebfc821 | 12dc3198db7660d8402517c5db1b3c63f1dc285a | refs/heads/master | 2023-08-19T01:04:34.859279 | 2022-11-10T15:42:54 | 2022-11-10T15:42:54 | 104,544,253 | 1 | 5 | null | null | null | null | UTF-8 | C++ | false | false | 11,655 | cxx | TQNFManualSetter.cxx | #include "QFramework/TQNFManualSetter.h"
#include "QFramework/TQStringUtils.h"
#include "QFramework/TQIterator.h"
#include "QFramework/TQUtils.h"
#include "QFramework/TQFolder.h"
#include "TMath.h"
#include "TRandom.h"
#include "QFramework/TQHistogramUtils.h"
#include "QFramework/TQNFChainloader.h"
#include <limits>
#include <iostream>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <cmath>
#include <fstream>
//#define _DEBUG_
#include "QFramework/TQLibrary.h"
////////////////////////////////////////////////////////////////////////////////////////////////
//
// TQNFManualSetter
//
// This class allows to manually set a normalization scale factor (NF).
// While, in principle, this class can be used on its own, it is highly recommended
// to use the TQNFChainloader instead. An example for a configuration to run the
// TQNFManualSetter via the TQNFChainloader is provided in the HWWlvlv2015 package
// under HWWlvlv2015/share/normalization/example.cfg
////////////////////////////////////////////////////////////////////////////////////////////////
ClassImp(TQNFManualSetter)
TQNFManualSetter::TQNFManualSetter(TQSampleFolder* f):
TQNFBase("TQNFManual"),
status(-999)
{
// default constructor taking base sample folder
this->setSampleFolder(f);
}
TQNFManualSetter::TQNFManualSetter(TQSampleDataReader* rd):
TQNFBase("TQNFManual"),
status(-999)
{
// default constructor taking base sample folder
this->setReader(rd);
}
TQNFManualSetter::~TQNFManualSetter(){
// default destructor, cleaning up all pointer fields
this->finalize();
this->clear();
}
int TQNFManualSetter::deployNF(const TString& name, const TString& cutName, TQFolder* config) {
std::vector<TString> vecStart;
vecStart.push_back(cutName);
return this->deployNF(name, vecStart, std::vector<TString>(), config);
}
int TQNFManualSetter::deployNF(const TString& name, const std::vector<TString>& startAtCutNames, const std::vector<TString>& stopAtCutNames, TQFolder* config){
// deploys a selected NF in all known locations
// stop if this cut is an point of tree of cuts on which to apply the NFs
if (!config) {
ERRORclass("Invalid pointer to configuration object!");
return -1;
}
if(!this->success()){
//WARNclassargs(TQStringUtils::concatenate(3,name.Data(),cutName.Data(),TQStringUtils::getStringFromBool(config->getTagBoolDefault("overwrite",true)).Data()),"cannot deploy NF, no results available, status is %d!",this->status);
WARNclassargs(TQStringUtils::concatenate(3,name.Data(),TQListUtils::makeCSV(startAtCutNames).Data(),(config->getTagBoolDefault("overwrite",true) ? "true":"false")),"cannot deploy NF, no results available, status is %d!",this->status);
return -1;
}
/*
bool last = false;
for (size_t i=0; i<stopAtCutNames.size(); ++i) {
if (TQStringUtils::matches(cutName, stopAtCutNames[i])) {
last = true;
break;
}
}
*/
//@tag:[overwrite] This (sub-folder) argument tag determines if the result of the calculator replaces existing values or if it is multiplied with the previously existing value. Default: true
bool overwrite = config->getTagBoolDefault("overwrite",true);
DEBUGclass("deploying NF for %s (overwrite=%d)",name.Data(),overwrite?1:0);
// get the NF
//@tag:[value,uncertainty] These (sub-folder) argument tags determine the value and the uncertainty of the NF being set (or modified, see "overwrite")
double nf = config->getTagDoubleDefault("value",1.);
double sigma = config->getTagDoubleDefault("uncertainty",0.);
if (! (iterationNumber < 0)) {
double variation = this->chainLoader->getRelVariation(TQStringUtils::concatenate(3,"NFManualSetter::",config->getPath().Data(),config->getName().Data()),nf,sigma); //we are using a random variation to propagate the uncertainty of manually set NFs assuming no correlation to anything else.
nf *=variation;
}
int retval = 0;
TString readScheme;
bool hasReadScheme = config->getTagString("readScaleScheme",readScheme);
if (name.IsNull()) {
ERRORclass("No target path given for config %s",config->getName().Data());
return -1;
}
// set the NF according to the desired scale scheme(s)
//@tag:[writeScaleScheme] This (sub-folder) argument tag determines the list of scale schemes the results of the NF calculation are written to. Default: ".default"
std::vector<TString> writeScaleSchemes = config->getTagVString("writeScaleScheme");
if(writeScaleSchemes.size() < 1){
writeScaleSchemes.push_back(config->getTagStringDefault("writeScaleScheme",".default"));
}
std::vector<TString> targets = this->getTargetCuts(startAtCutNames,stopAtCutNames);
//---------------------------------------------
for (size_t c=0; c<targets.size(); ++c) {
TString cutName = targets.at(c);
TQSampleFolderIterator sItr(this->fReader->getListOfSampleFolders(name),true);
while(sItr.hasNext()){
TQSampleFolder* s = sItr.readNext();
if(!s) continue;
double readFactor = 1.;
double readSigma = 0.;
if (hasReadScheme) {
if (!s->getScaleFactor(readScheme+":"+cutName,readFactor,readSigma,false)) {
WARNclass("Failed to read scheme '%s' at cut '%s'",readScheme.Data(),cutName.Data());
readFactor = 1.;
readSigma = 0.;
}
}
for(size_t k=0; k<writeScaleSchemes.size(); k++){
int n = s->setScaleFactor(writeScaleSchemes[k]+":"+cutName+(overwrite>0?"":"<<"), nf*readFactor,sqrt(pow(sigma*readFactor,2) + pow(readSigma*nf,2)) );
#ifdef _DEBUG_
if (s->getFolder(".scalefactors")) s->getFolder(".scalefactors")->print();
#endif
if(n == 0){
ERRORclass("unable to set scale factor for cut '%s' on path '%s' with scheme '%s'",cutName.Data(),s->getPath().Data(),writeScaleSchemes[k].Data());
}
//keep track where a NF has been written to as required by TQNFBase for use in TQNFChainloader
this->addNFPath(s->getPath(),cutName,writeScaleSchemes[k]);
retval += n;
}
}
// if the info folder is set and valid, we should keep track of all the processes that have NFs applied
if(this->infoFolder){
// get the folder which contains the list of processes for which we have NFs
//@tag:[nfListPattern] This object tag determines the format how the existence of NFs for the target paths/cuts is written to the info folder (if present). Default: ".cut.%s+"
TQFolder * sfProcessList = this->infoFolder->getFolder(TString::Format(this->getTagStringDefault("nfListPattern",".cut.%s+").Data(),cutName.Data()));
// get the sample folder which contains the samples for this process
TList* sflist = this->fReader->getListOfSampleFolders(name);
TQSampleFolder * processSampleFolder = ( sflist && sflist->GetEntries() > 0 ) ? (TQSampleFolder*)(sflist->First()) : NULL;
if(sflist) delete sflist;
// retrieve the correct title of the process from this folder
// if there is no process title set, we will use the process name instead
TString processTitle = name;
if (processSampleFolder)
//@tag:[processTitleKey] This object tag determines the name of the process tag used to retrieve the process title from. Default: "style.default.title".
processSampleFolder->getTagString(this->getTagStringDefault("processTitleKey","style.default.title"), processTitle);
// after we have aquired all necessary information, we add a new entry
// to the list of processes to which NFs have been applied
sfProcessList->setTagString(TQFolder::makeValidIdentifier(processTitle),processTitle);
}
}
//---------------------------
/*
// if no recursion was required, we can stop here
if(stopAtCutNames.size() == 0 || !this->cutInfoFolder || last)
return retval;
// if stopAtCutNames is set, we need to recurse over the cut structure
// therefore, we first need to find out how the cuts are structured
*/
//TList * cuts = this->cutInfoFolder->getListOfFolders(TString::Format("*/%s/?",cutName.Data()));
/*if(!cuts) return retval;
TQIterator itr(cuts,true);
// iterate over all the cuts below the one we are investigating now
while(itr.hasNext()){
TQFolder* f = dynamic_cast<TQFolder*>(itr.readNext());
if(!f) continue;
// and deploy NFs at the corresponding cuts
retval += this->deployNF(name,f->GetName(),stopAtCutNames,config);
}
*/
return retval;
}
int TQNFManualSetter::deployResult(const std::vector<TString>& startAtCutNames, const std::vector<TString>& stopAtCutNames, int overwrite){
// The arguments are ignored, they are just there to comply with TQNFBase requirements. The individual
// start/stop cuts and overwrite are read from the sub configs.
if(!this->success()){
WARNclassargs(TQStringUtils::concatenate(3,TQListUtils::makeCSV(startAtCutNames).Data(),TQStringUtils::concat(stopAtCutNames).Data(),TQStringUtils::getStringFromBool(overwrite).Data()),"cannot deploy NFs, no results available, status is %d!",this->status);
return -1;
}
// deploys all NFs in all known locations
int retval = 0;
for(int i=0; i<configs->GetEntries(); i++){
TQFolder* config = dynamic_cast<TQFolder*> (configs->At(i));
//@tag:[path,applyToCut,stopAtCut] These sub-folder argument tags determine at which paths and cuts the NF is deployed. "stopAtCut" and applyToCut support list context.
retval += this->deployNF(config->getTagStringDefault("path",""), config->getTagVString("applyToCut"), config->getTagVString("stopAtCut"), config);
}
return retval;
}
void TQNFManualSetter::clear(){
// clear all names, paths and results
this->initialized = false;
this->status = -999;
}
bool TQNFManualSetter::finalizeSelf(){
return true;
}
bool TQNFManualSetter::initializeSelf(){
// initialize the NF Calculator
// - initializes the data histogram
// - initializeds the mc histograms
// will set the initialize flag to true
// further calls of initialize will have no effect
// until clear is called
if(!this->fReader){
return false;
}
this->status = 0;
return true;
}
int TQNFManualSetter::getStatus(){
// retrieve the status
return this->status;
}
TString TQNFManualSetter::getStatusMessage(){
// decode the integer status code
switch(this->status){
case -999:
return "uninitialized";
case -10:
return "error during initialization";
case 0:
return "all OK";
default:
return "unkown error";
}
}
void TQNFManualSetter::printStatus(){
// print the status
INFOclass("current status of instance '%s' is '%d': %s",this->GetName(),(int)(this->status),this->getStatusMessage().Data());
}
int TQNFManualSetter::execute(int itrNumber) {
//start calculation
this->iterationNumber = itrNumber;
return 0; //unless sth. went wrong, then possibly return sth. else
}
bool TQNFManualSetter::success(){
// return true if calculation was successful
// false otherwise
if(this->initialized && (this->status == 0))
return true;
return false;
}
bool TQNFManualSetter::readConfiguration(TQFolder* f){
// Sets the configuration folder. The folder is expected to contain subfolders
// having the following tags applied (* = required)
// ...to be written
if(!f) return false;
this->configs = f->getListOfFolders("?");
if(!configs || configs->GetEntries()<1) {
ERRORclass("Invalid configuration for TQNFManualSetter");
return false;
}
this->initialized = true;
this->status = 0;
return true;
}
|
ad45db4c4484ee95cabc4e1f91b5badabab16138 | a257886a1af2093b8dc094b5750cc78901b0a882 | /CppClassLibrary/undergraduate.h | 045d01a749619d4f40be6e70c9e0d58570476cda | [] | no_license | windwanghuiyong/cpp-class-library | 04962aba9d3db0fbec464105c83b58ad99c4c069 | cdbc957bdd96a64ba7f3465722f71df2cb0ea6c1 | refs/heads/master | 2021-01-11T18:53:00.208176 | 2017-01-21T13:27:53 | 2017-01-21T13:27:53 | 79,647,199 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 164 | h | undergraduate.h | #include "student.h"
class Undergraduate:public student
{
public:
double getGPA();
void setGPA(double g);
bool isAdult();
protected:
double GPA;
}; |
e2ff08fe08e859bd4ced7fbb27fd3209d935ac6b | ae6dbcfd6a333bf598b871e15a7741fef81f964f | /Components/Sourcecode/BSC/WSCompose/HTMLComparer/CompareChainsDepthGauge.cpp | 7386734de48d14f68dde221c95995c88bdbe6e32 | [] | no_license | xeon2007/WSProf | 7d431ec6a23071dde25226437583141f68ff6f85 | d02c386118bbd45237f6defa14106be8fd989cd0 | refs/heads/master | 2016-11-03T17:25:02.997045 | 2015-12-08T22:04:14 | 2015-12-08T22:04:14 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 886 | cpp | CompareChainsDepthGauge.cpp | #include "StdAfx.h"
#include "comparechainsdepthgauge.h"
#include "ComparisonContext.h"
const long CCompareChainsDepthGauge::max_depth = 100;
// paranoia rules
CCompareChainsDepthGauge::CCompareChainsDepthGauge(ComparisonContext* pContext) : m_pContext(pContext)
{
// Added a guard for recursive calls to compare chains - if you are here and "it aint broke" up the max depth
CHECK_ALGORITHM_INTEGRITY(m_pContext->m_bTesting || m_pContext->m_lDepth < max_depth);
if(m_pContext->m_lDepth>= max_depth)
ThrowComparisonException(E_FAIL,_T("Went past max depth for Compare chains recursion"));
InterlockedIncrement(&(m_pContext->m_lDepth));
}
CCompareChainsDepthGauge::~CCompareChainsDepthGauge(void)
{
CHECK_ALGORITHM_INTEGRITY(m_pContext->m_lDepth>0);
InterlockedDecrement(&(m_pContext->m_lDepth));
}
const long CCompareChainsDepthGauge::GetMaxDepth()
{
return max_depth;
}
|
e76bfd48c9f432de027b87c8a8eb1e9100a00d23 | 656228d86f1f2b9afa2b3680aa15291c9c275ac2 | /src/registerBank.hpp | f56f3498d9cb834065a0ffba2908f59e842b6eaa | [] | no_license | dpriver/GBcolorEmu | 645e54b6bb86b087ba4ed963b9dfd7a74fdbcebf | 39175cecf87db89676e9a4d6405fb89e62b15692 | refs/heads/master | 2021-08-19T16:43:51.292959 | 2017-11-27T00:40:44 | 2017-11-27T00:40:44 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 4,781 | hpp | registerBank.hpp | #ifndef __REGISTERBANK_HPP
#define __REGISTERBANK_HPP
#include <iostream>
namespace gbcoloremu
{
using regValue_t = uint8_t;
using doubleRegValue_t = uint16_t;
class RegisterBank
{
public:
// Posible 16bit pairings (15..8 | 7..0)
// A - F
// B - C
// D - E
// H - L
// regF stores results of various math operations
// PC points to the next instruction to be executed (initial value: 0x0100)
// SP points to the current stack position (initial value: 0xFFFE)
// SP grows downward in RAM memory.
// It decrements automatically before something is put in it
regValue_t A, B, C, D, E, F;
regValue_t H, L;
doubleRegValue_t SP, PC;
regValue_t cpuHalted;
regValue_t cpuStopped;
regValue_t intEnabled;
void setFlagZ() {F = F | 0x80;}
void setFlagN() {F = F | 0x40;}
void setFlagH() {F = F | 0x20;}
void setFlagC() {F = F | 0x10;}
void resetFlagZ() {F = F & ~0x80;}
void resetFlagN() {F = F & ~0x40;}
void resetFlagH() {F = F & ~0x20;}
void resetFlagC() {F = F & ~0x10;}
regValue_t getFlagZ() {return (F & 0x80) >> 7;}
regValue_t getFlagN() {return (F & 0x40) >> 6;}
regValue_t getFlagH() {return (F & 0x30) >> 5;}
regValue_t getFlagC() {return (F & 0x20) >> 4;}
void setValue(uint8_t regNum, doubleRegValue_t value)
{
switch(regNum)
{
case 0x0:
B = value;
break;
case 0x1:
C = value;
break;
case 0x2:
D = value;
break;
case 0x3:
E = value;
break;
case 0x4:
H = value;
break;
case 0x5:
L = value;
break;
case 0x6:
cout << "Invalid write to register HL" << endl;
break;
case 0x7:
A = value;
}
}
doubleRegValue_t getValue(uint8_t regNum)
{
doubleRegValue_t value;
switch(regNum)
{
case 0x0:
value = B;
break;
case 0x1:
value = C;
break;
case 0x2:
value = D;
break;
case 0x3:
value = E;
break;
case 0x4:
value = H;
break;
case 0x5:
value = L;
break;
case 0x6:
cout << "Invalid read from register HL" << endl;
break;
case 0x7:
value = A;
}
return value;
}
doubleRegValue_t getDoubleValue(uint8_t regNum)
{
doubleRegValue_t value;
switch(regNum)
{
case 0x0:
value = getBC();
break;
case 0x1:
value = getDE();
break;
case 0x2:
value = getHL();
break;
case 0x3:
value = SP;
break;
}
return value;
}
void setDoubleValue(uint8_t regNum, doubleRegValue_t value)
{
switch(regNum)
{
case 0x0:
setBC(value);
break;
case 0x1:
setDE(value);
break;
case 0x2:
setHL(value);
break;
case 0x3:
SP = value;
break;
}
}
doubleRegValue_t getHL() {
return ((doubleRegValue_t)H << 8) | L;
}
void setHL(doubleRegValue_t value) {
H = (value >> 8) & 0x7;
L = value & 0x7;
}
doubleRegValue_t getBC() {
return ((doubleRegValue_t)B << 8) | C;
}
void setBC(doubleRegValue_t value) {
B = (value >> 8) & 0x7;
C = value & 0x7;
}
doubleRegValue_t getDE() {
return ((doubleRegValue_t)D << 8) | E;
}
void setDE(doubleRegValue_t value) {
D = (value >> 8) & 0x7;
E = value & 0x7;
}
doubleRegValue_t getAF() {
return ((doubleRegValue_t)A << 8) | F;
}
void setAF(doubleRegValue_t value) {
A = (value >> 8) & 0x7;
F = value & 0x7;
}
friend std::ostream &operator<<(std::ostream &os, const RegisterBank &obj)
{
os << "A:" << unsigned(obj.A) << " F:" << unsigned(obj.F) << endl;
os << "B:" << unsigned(obj.B) << " C:" << unsigned(obj.C) << endl;
os << "D:" << unsigned(obj.D) << " E:" << unsigned(obj.E) << endl;
os << "H:" << unsigned(obj.H) << " L:" << unsigned(obj.L) << endl;
os << "SP:" << unsigned(obj.SP) << " PC:" << unsigned(obj.PC) << endl;
return os;
}
};
} /* namespace gbcoloremu */
#endif /* __REGISTERBANK_HPP */
|
5dbe179bd3c93c4cfc9896eff88f813670a88a96 | a3d6556180e74af7b555f8d47d3fea55b94bcbda | /components/autofill/content/renderer/test_password_autofill_agent.h | 1ffef6c633aa271a990e66e83f1a3333e8e06ddf | [
"BSD-3-Clause"
] | permissive | chromium/chromium | aaa9eda10115b50b0616d2f1aed5ef35d1d779d6 | a401d6cf4f7bf0e2d2e964c512ebb923c3d8832c | refs/heads/main | 2023-08-24T00:35:12.585945 | 2023-08-23T22:01:11 | 2023-08-23T22:01:11 | 120,360,765 | 17,408 | 7,102 | BSD-3-Clause | 2023-09-10T23:44:27 | 2018-02-05T20:55:32 | null | UTF-8 | C++ | false | false | 965 | h | test_password_autofill_agent.h | // Copyright 2013 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef COMPONENTS_AUTOFILL_CONTENT_RENDERER_TEST_PASSWORD_AUTOFILL_AGENT_H_
#define COMPONENTS_AUTOFILL_CONTENT_RENDERER_TEST_PASSWORD_AUTOFILL_AGENT_H_
#include "components/autofill/content/renderer/password_autofill_agent.h"
namespace autofill {
class TestPasswordAutofillAgent : public PasswordAutofillAgent {
public:
TestPasswordAutofillAgent(content::RenderFrame* render_frame,
blink::AssociatedInterfaceRegistry* registry);
~TestPasswordAutofillAgent() override;
private:
// Always returns true. This allows browser tests with "data: " URL scheme to
// work with the password manager.
// PasswordAutofillAgent:
bool FrameCanAccessPasswordManager() override;
};
} // namespace autofill
#endif // COMPONENTS_AUTOFILL_CONTENT_RENDERER_TEST_PASSWORD_AUTOFILL_AGENT_H_
|
07feeaeb05a9d3c7fc9388ccd615afb51afbe956 | 3746c4f773541269a811b248dc2b418f0c6c9e7e | /Interfaces/Plugin.h | 63e877eef1d4fac72cf8229ca554bde01ec97826 | [] | no_license | edwardoid/DarkKnight | e36f2d168e2e45b6fefc33613c6dea992666951f | 84b74fa45c2645ff393dd4dd68c337c61fa0d230 | refs/heads/master | 2021-01-17T12:37:37.324087 | 2013-05-27T20:19:49 | 2013-05-27T20:19:49 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 859 | h | Plugin.h | #ifndef PLUGIN_H
#define PLUGIN_H
#include "InterfacesGlobal.h"
#include <QObject>
#include "FrameworkUser.h"
class Framework;
class SettingsPageBase;
class EXPORT_INTERFACES Plugin : public QObject,
public FrameworkUser
{
public:
typedef enum
{
Concept = 0,
DataStore
} Type;
typedef quint32 ID;
Plugin(): m_settingsPage(NULL) {}
virtual Type type() const = 0;
virtual QString name() const = 0;
virtual QString version() const = 0;
virtual QString author() const = 0;
inline SettingsPageBase* settingsPage() const { return m_settingsPage; }
inline void setId(const ID id) { m_id = id; };
inline ID id() const { return m_id; };
virtual ~Plugin() {}
protected:
SettingsPageBase* m_settingsPage;
quint32 m_id;
};
Q_DECLARE_INTERFACE(Plugin, "ssc.darkknight.plugin")
#endif // PLUGIN_H
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.