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
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
d245cc545a090df4fc5e876d431eef43ca43d5c1
|
f0556fbb206661c333277cfaacbd14418dbb29d8
|
/QtDownloadManager/cnetworkam.h
|
aa64991380482d413400ea0db4274ed126dc7e26
|
[] |
no_license
|
Usman-Sheik/MY14
|
878699b031bc40f24212fb7c6a883ea321d5a8fa
|
ed344b0bb233719f82d32a6d60705e24337c2d43
|
refs/heads/master
| 2021-05-26T12:33:31.231103
| 2012-01-04T13:47:32
| 2012-01-04T13:47:32
| null | 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 760
|
h
|
cnetworkam.h
|
#ifndef CNETWORKAM_H
#define CNETWORKAM_H
#include "mainwindow.h"
#include "ui_mainwindow.h"
#include "cprogressbar.h"
#include <QMainWindow>
#include <QMainWindow>
#include <QNetworkAccessManager>
#include <QtWebKit/QWebView>
#include <QUrl>
class cNetworkAM : public QObject
{
Q_OBJECT
QNetworkAccessManager *m_pmanager;
QNetworkRequest *m_prequest;
int m_uint;
public:
explicit cNetworkAM();
QNetworkReply *m_preply;
signals:
public slots:
void objInit(const QUrl &url,MainWindow *mainWindow);
void downloadFinished();
QString saveFileName(const QUrl &url);
bool writetoDisk(const QString &filename, QIODevice *data);
void DownloadAbort();
private:
Ui::MainWindow *ui;
};
#endif // CNETWORKAM_H
|
bf3af390c52373bcade03c00ec6b4ffdec1ed5b4
|
533c54472da78d183356180f128977977cbbb853
|
/src/ripple/core/JobCoro.h
|
9a762bd65ead43bc25b6de8b2fd29bfa5fce70ed
|
[
"MIT-Wu",
"MIT",
"ISC",
"BSL-1.0"
] |
permissive
|
gcbpay/R9RIppleRoutes
|
7d3caec3181f3075527656d4c96e7b5948e19aec
|
8fdef0379a3fa05cf783b805b07ef87570db8886
|
refs/heads/master
| 2021-01-19T06:08:23.662331
| 2018-03-23T03:17:31
| 2018-03-23T03:17:31
| 72,002,525
| 7
| 3
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 3,162
|
h
|
JobCoro.h
|
//------------------------------------------------------------------------------
/*
This file is part of rippled: https://github.com/ripple/rippled
Copyright (c) 2012, 2013 Ripple Labs Inc.
Permission to use, copy, modify, and/or distribute this software for any
purpose with or without fee is hereby granted, provided that the above
copyright notice and this permission notice appear in all copies.
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
ANY SPECIAL , DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
//==============================================================================
#ifndef RIPPLE_CORE_JOBCORO_H_INCLUDED
#define RIPPLE_CORE_JOBCORO_H_INCLUDED
#include <ripple/basics/win32_workaround.h>
#include <ripple/core/Job.h>
#include <ripple/basics/LocalValue.h>
#include <boost/coroutine/all.hpp>
#include <condition_variable>
#include <string>
#include <memory>
#include <mutex>
namespace ripple {
class JobQueue;
namespace detail {
struct JobCoro_create_t { };
} // detail
/** Coroutines must run to completion. */
class JobCoro : public std::enable_shared_from_this<JobCoro>
{
private:
detail::LocalValues lvs_;
JobQueue& jq_;
JobType type_;
std::string name_;
bool running_;
std::mutex mutex_;
std::mutex mutex_run_;
std::condition_variable cv_;
boost::coroutines::asymmetric_coroutine<void>::pull_type coro_;
boost::coroutines::asymmetric_coroutine<void>::push_type* yield_;
#ifndef NDEBUG
bool finished_ = false;
#endif
public:
// Private: Used in the implementation
template <class F>
JobCoro(detail::JobCoro_create_t, JobQueue&, JobType,
std::string const&, F&&);
// Not copy-constructible or assignable
JobCoro(JobCoro const&) = delete;
JobCoro& operator= (JobCoro const&) = delete;
~JobCoro();
/** Suspend coroutine execution.
Effects:
The coroutine's stack is saved.
The associated Job thread is released.
Note:
The associated Job function returns.
Undefined behavior if called consecutively without a corresponding post.
*/
void yield() const;
/** Schedule coroutine execution.
Effects:
Returns immediately.
A new job is scheduled to resume the execution of the coroutine.
When the job runs, the coroutine's stack is restored and execution
continues at the beginning of coroutine function or the statement
after the previous call to yield.
Undefined behavior if called consecutively without a corresponding yield.
*/
void post();
/** Waits until coroutine returns from the user function. */
void join();
};
} // ripple
#endif
|
01dafee6e7962e49d7a57d14c0ba6ef645fd1ce5
|
d723688f1e6c2c8a1dc36e6bec28f57d4ed2002a
|
/HEVD_Solutions/main.cpp
|
84055ba51372e10a563b4752e6569386b339feed
|
[] |
no_license
|
yuvaly0/HEVD_Solutions
|
bda17218a3c19b5e9fa8f412a5797389936e9f78
|
9f9198609f8305ed17ce9736c7db4e250160b2ab
|
refs/heads/master
| 2022-12-16T13:16:30.533434
| 2020-09-15T12:54:16
| 2020-09-15T12:54:16
| 286,802,900
| 2
| 1
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 757
|
cpp
|
main.cpp
|
#include <Windows.h>
#include <iostream>
#include <memory>
#include "utils.h"
#include "Solutions.h"
#define MAX_CHOICE 9
#define MIN_CHOICE 1
int main()
{
LPCWSTR lpFileName = L"\\\\.\\HacksysExtremeVulnerableDriver";
HANDLE hDeviceHandle = CreateFile(lpFileName,
GENERIC_WRITE | GENERIC_READ,
0,
NULL,
OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL,
NULL);
if (hDeviceHandle == INVALID_HANDLE_VALUE) {
std::cout << "[-] ERROR: invalid handle" << std::endl;
return 1;
}
print_menu();
const int choice = get_user_choice();
if (choice > MAX_CHOICE || choice < MIN_CHOICE) {
std::cout << "bad choice" << std::endl;
return 1;
}
auto solutions = std::make_unique<Solutions>(hDeviceHandle);
return solutions->TriggerExploit(choice);
}
|
4e4f6cd29b7ec68bc7ef548fa06c586630539de0
|
5a7d9584b703cb54b4a5d8058383ac5ad90669e3
|
/ClientGame/ScoreDoublePowerup.h
|
2922a98334f36a2c5bbb5100b8acaa31c8b38f5e
|
[] |
no_license
|
d909b/GADEL-Snake
|
049c435ff8b5ab9105ccde3db782071084c689cc
|
158153d04ec5f2ac8fe7817debd43ea3e929403b
|
refs/heads/master
| 2016-09-06T18:10:45.313346
| 2013-01-15T19:06:44
| 2013-01-15T19:06:44
| null | 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 558
|
h
|
ScoreDoublePowerup.h
|
//
// ScoreDoublePowerup.h
// ClientGame
//
// Created by Patrick Stapfer on 13.01.13.
//
//
#ifndef __ClientGame__ScoreDoublePowerup__
#define __ClientGame__ScoreDoublePowerup__
#include <iostream>
#include "Powerup.h"
class ScoreDoublePowerup : public Powerup
{
public:
ScoreDoublePowerup(Vector2 position, unsigned int ttl_milliseconds);
virtual void applyEffect(Snake* snake);
virtual void undoEffect(Snake* snake);
private:
unsigned int m_original_Multiplicator;
};
#endif /* defined(__ClientGame__ScoreDoublePowerup__) */
|
35b9653cb168c4669dd451f6511fa42bc4dbab16
|
a2b44d400211c8ab74b0beedd97f26c71b4dd0c2
|
/intersection-arrays.cpp
|
7b4e5ad3d962943793017586d0caa994720c50b8
|
[] |
no_license
|
unyieldingGlacier/coding-exercises
|
b8eddaed696f990a517e3ff3b586310d8a205c02
|
51fd18224b9ea66c6c373a55d66b3430efff7686
|
refs/heads/master
| 2021-09-06T13:02:57.030033
| 2018-02-06T20:45:01
| 2018-02-06T20:45:01
| 67,652,126
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 1,284
|
cpp
|
intersection-arrays.cpp
|
/* LC 349
* Given two arrays, write a function to compute their intersection.
Example:
Given nums1 = [1, 2, 2, 1], nums2 = [2, 2], return [2].
Note:
Each element in the result must be unique.
The result can be in any order.
*/
//approach 1 - sort and process duplicates while iterating
class Solution {
public:
vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
vector<int> out;
sort(nums1.begin(),nums1.end());
sort(nums2.begin(),nums2.end());
int i = 0, j = 0, n = nums1.size(), m = nums2.size();
while(i < n && j < m){
if(nums1[i] == nums2[j] && (out.size() == 0 || out.back() != nums1[i] )) {
out.push_back(nums1[i]);
i++;
j++;
} else if(nums1[i] < nums2[j]){
i++;
} else {
j++;
}
}
return out;
}
};
//approach 2 - extra storage
class Solution {
public:
vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
vector<int> out;
set<int> s(nums1.begin(),nums1.end());
for(int n: nums2){
if(s.count(n)){
s.erase(n);
out.push_back(n);
}
}
return out;
}
};
|
3cf30e15db2bdf1b0c4bb0b7d1047126e66a4421
|
36a4dbd239d0039ab28c216b0bf1f7710bda9df2
|
/Cilia.cpp
|
ec77771de498d606930f9028cb8bdec2c15cfc81
|
[] |
no_license
|
Haptic-Solutions/CiliaLinuxSDK
|
1350a4103cc02ac71a68d1ec45ab4bf9e07eff14
|
075b1477f6c765cf46054505c9e8cc2e34fd2e3c
|
refs/heads/main
| 2023-06-22T10:06:26.029763
| 2021-08-03T02:30:19
| 2021-08-03T02:30:19
| 392,161,630
| 1
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 4,316
|
cpp
|
Cilia.cpp
|
#include "Cilia.h"
namespace CiliaSDK
{
std::list<unsigned char> Cilia::sCiliaGroups[GVS::NUMBER_OF_SURROUND_POSITIONS];
std::list<unsigned char> Cilia::sActiveCilias;
RGB::RGB(const std::string aRGBString) : red(0), green(0), blue(0)
{
std::stringstream redStream;
std::stringstream greenStream;
std::stringstream blueStream;
if (redStream << aRGBString.substr(0, 3))
{
redStream >> red;
}
if (greenStream << aRGBString.substr(3, 3))
{
greenStream >> green;
}
if (blueStream << aRGBString.substr(6, 3))
{
blueStream >> blue;
}
}
RGB::RGB(unsigned char aRed, unsigned char aBlue, unsigned char aGreen)
{
red = aRed;
green = aGreen;
blue = aBlue;
}
std::string RGB::ToString()
{
std::stringstream redStream;
std::stringstream greenStream;
std::stringstream blueStream;
redStream << std::setw(3) << std::setfill('0') << red;
greenStream << std::setw(3) << std::setfill('0') << green;
blueStream << std::setw(3) << std::setfill('0') << blue;
std::string iString = redStream.str() + greenStream.str() + blueStream.str();
return iString;
}
Cilia::Cilia(unsigned char aCilia, std::string aInitializationValues[])
{
//store serial port
mSerialPort = aCilia;
//store surround position
std::stringstream initializationValue;
initializationValue << aInitializationValues[0];
initializationValue >> mSurroundPosition;
//store smells and lights
int i = 0;
for (auto smells : mSmells)
{
mSmells[i] = aInitializationValues[i + GVS::SMELLS_OFFSET];
mLights[i] = RGB(aInitializationValues[i + GVS::LIGHT_OFFSET]);
i++;
}
}
std::string Cilia::GetLightValue(int aLightIndex)
{
return mLights[aLightIndex].ToString();
}
void Cilia::SetLightValue(int aLightIndex, std::string aLightValue)
{
mLights[aLightIndex] = RGB(aLightValue);
}
void Cilia::prepareGroups()
{
for (int cPI = 0; cPI < GVS::NUMBER_OF_SURROUND_POSITIONS; cPI++)
sCiliaGroups[cPI] = std::list<unsigned char>();
}
void Cilia::SetCiliaPosition(unsigned char aGroup)
{
//if possible remove from previous group.
if
(
Find(sCiliaGroups[mSurroundPosition], mSerialPort)
)
{
sCiliaGroups[mSurroundPosition].remove(mSerialPort);
}
//assigne new group
mSurroundPosition = aGroup;
//add to group list and sortS
sCiliaGroups[aGroup].emplace_back(mSerialPort);
sCiliaGroups[aGroup].sort();
//add as an active Cilia
if
(
!Find(sActiveCilias, mSerialPort)
)
{
sActiveCilias.emplace_back(mSerialPort);
}
}
void Cilia::RemoveCiliaFromGroup(unsigned char aGroup, unsigned char aCilia)
{
if (Find(sCiliaGroups[aGroup], aCilia))
{
sCiliaGroups[aGroup].remove(aCilia);
}
if (Find(sActiveCilias, aCilia))
{
sActiveCilias.remove(aCilia);
}
}
int Cilia::GetCountOfGroup(unsigned char aGroup)
{
if (!sCiliaGroups[aGroup].empty())
return sCiliaGroups[aGroup].size();
else
return 0;
}
unsigned char Cilia::GetCiliaInPositions(unsigned char aGroup, unsigned char aIndex)
{
auto ciliaGroupsItterator = sCiliaGroups[aGroup].begin();
std::advance(ciliaGroupsItterator, aIndex);
return (unsigned char)*ciliaGroupsItterator;
}
unsigned char Cilia::GetCiliaPosition()
{
return mSurroundPosition;
}
std::list<unsigned char> Cilia::GetActiveCilias()
{
return sActiveCilias;
}
std::string Cilia::ToString()
{
std::string toReturn = mSerialPort + "," + std::to_string(mSurroundPosition);
for (unsigned int i = 0; i < mSmells.size(); i++)
{
toReturn += "," + mSmells[i];
}
for (unsigned int i = 0; i < mLights.size(); i++)
{
toReturn += "," + mLights[i].ToString();
}
return toReturn;
}
std::string Cilia::ToStringForWritingToFile()
{
std::string toReturn = std::to_string(mSurroundPosition);
for (auto smell : mSmells)
{
toReturn += "\n" + smell;
}
for (auto light : mLights)
{
toReturn += "\n" + light.ToString();
}
return toReturn;
}
std::list<int> Cilia::GetSmellIndexes(std::string aSmellValue)
{
std::list<int> smellIndexes;
int i = 0;
for (auto smell : mSmells)
{
if (smell.compare(aSmellValue))
{
smellIndexes.emplace_back(i + 1);
}
i++;
}
return smellIndexes;
}
void Cilia::SetSmell(int aSmellIndex, std::string aSmellValue)
{
mSmells[aSmellIndex] = aSmellValue;
}
}
|
617961c6eb8f5d7a74007276eadf5fcca1ba792b
|
f8699c3b4476df654e79d728a3eccae2ed345fec
|
/1 Semesters/3/Data structures/Programs/99Semester/1Lab Assingment/Enter data in specific INDEX.cpp
|
5b611c2ea31d58f9adb604ec350b196447542988
|
[] |
no_license
|
pseudo-usama/my-undergrad-coding
|
91e6953b4ef4382badf620fa944a11aa8d3810b5
|
1d54c09da5540581b00029c49a9ccb84c24a4cf7
|
refs/heads/master
| 2023-08-30T08:45:32.571317
| 2021-10-08T06:20:41
| 2021-10-08T06:20:41
| 374,524,915
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 1,124
|
cpp
|
Enter data in specific INDEX.cpp
|
// Enter data in specific INDEX.cpp : Defines the entry point for the console application.
//
#include "stdafx.h"
#include "iostream"
using namespace std;
void main() {
int const L = 10;
int Array[L];
int Index, Length = 0, Option;
do{
cout << endl << endl;
cout << "To enter Data : 1" << endl;
cout << "To Display Array : 2" << endl;
cout << "To Exit : 0" << endl;
cout << "Enter Option : ";
cin >> Option;
cout << endl << endl;
if (Option == 1) {
if (Length != 10) {
do
{
cout << "LENGTH of ARRAY is " << Length << endl << "Enter Index to set value : ";
cin >> Index;
} while (Index > Length);
for (int i = Length; i > Index; i--) //To shift the data to right
Array[i] = Array[i - 1];
Length++;
cout << "Enter Data to Store : ";
cin >> Array[Index]; //Input data from user
}
else
cout << "Sorry! Array is full.";
}
else if (Option == 2) {
cout << endl << endl << "The Array is :";
for (int i = 0; i < Length; i++) //Display Array
cout << Array[i] << ", ";
}
} while (Option != 0);
}
|
4e82a13a04e93e0434a3012cc85d0631dd927d75
|
dea204238c6e2090b62c4a14504128966ea1b13d
|
/c1/s2/TP_10/myMatrix.cpp
|
70c196f2f2a0bbdb4be3c52885c0d0a4b5cf6c4f
|
[] |
no_license
|
hijarian/KSU-algorithmization-courses
|
b8341050440f31e613d67fa85577b809f70b16f3
|
3cd8601f5df9f3bd405feb4d9bcdc6bdb2b82fe1
|
refs/heads/master
| 2020-04-16T12:33:06.326689
| 2012-07-16T09:48:55
| 2012-07-16T09:48:55
| null | 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 1,493
|
cpp
|
myMatrix.cpp
|
#include <iostream>
#include <iomanip>
#include <cstdlib>
#include <ctime>
#include <vector>
using namespace std;
typedef vector <int> intvec;
typedef vector < intvec > matrix;
const int intL=3;
void vecPrint(intvec* vec)
{
intvec::iterator It=(*vec).begin();
for(It; It!=(*vec).end(); ++It)
{
cout << setw(intL) << *It << ' ';
}
cout << endl;
}
intvec* vecFill(intvec* work, int Elems, int rSeed)
{
srand(rSeed);
for(int j=0; j<Elems; ++j)
{
(*work).push_back((int)(rand()/1000.-rand()/1000.));
}
return work;
}
matrix* arrFill(matrix* arrMain, int Rows, int Cols)
{
//for(colIterator=arrMain.begin(); colIterator!=arrMain.end(); ++colIterator)
for(int i=0; i<Cols; ++i)
{
intvec buffer;
(*arrMain).push_back(buffer);
(*arrMain)[i]=*vecFill(&(*arrMain)[i], Rows, rand());
/*for(int j=0; j<Rows; ++j)
{
buffer.push_back((int)(rand()/1000.-rand()/1000.));
}
(*arrMain).push_back(buffer);*/
}
return arrMain;
}
void arrPrintRaw(matrix* arrMain)
{
matrix::iterator colIterator;
intvec::iterator rowIterator;
unsigned i=0;
//for(int i=0; i<arrCols; ++i)
for(colIterator=(*arrMain).begin(); colIterator!=(*arrMain).end(); ++colIterator)
{
//for(int j=0; j<arrRows; ++j)
for(rowIterator=(*arrMain)[i].begin(); rowIterator!=(*arrMain)[i].end(); ++rowIterator)
{
//cout << ((*arrMain)[i])[j] << ' ';
cout << setw(intL) << *rowIterator << ' ';
}
++i;
cout << endl;
}
}
|
8413943cb91a871090174bba457d55baa344ff51
|
0532e09d56b586ab10fbb623c0386994e40ab87d
|
/Professional C++, 5th Edition/Exercises/c11_exercises/11-4/simulator_internals.cpp
|
7566953b58a53f70c160c1c303de41cd68db2eaa
|
[] |
no_license
|
chosungmann/book-examples
|
fae7245e8071f1326033971d0c108b61c7739f2f
|
368597886374131856aff3ea819dd5432a8de27b
|
refs/heads/main
| 2023-07-19T18:58:21.009598
| 2023-07-17T07:24:52
| 2023-07-17T07:24:52
| 115,195,777
| 2
| 1
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 129
|
cpp
|
simulator_internals.cpp
|
module simulator:internals;
namespace Simulator
{
double convertMilesToKm(double miles)
{
return miles * 1.6;
}
}
|
f25a171bfd92db276509b89aced7f0f5dec2cd05
|
057c0bd665943b517a467539fb8ae51645dc14c5
|
/src/joystick/joystickdata.cpp
|
64bd34120e7a691cda46046ddb133a8f97275a7b
|
[
"Apache-2.0"
] |
permissive
|
HaskiDuan/ROVGS
|
a00b655cea9604f2101ede99b22e0983116a3f1c
|
1194a86c1ab741e3c43b3fbacfbe9253339d1ffd
|
refs/heads/master
| 2021-09-15T22:43:40.062344
| 2018-06-12T00:59:23
| 2018-06-12T00:59:23
| 125,141,157
| 3
| 5
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 891
|
cpp
|
joystickdata.cpp
|
#include "joystickdata.h"
JoystickData::JoystickData(QObject* parent)
: QObject(parent)
{
}
JoystickData::JoystickData(const short &xValue,const short &yValue,const short &zValue,const short &yawValue,QObject* parent)
: _xValue(xValue),_yValue(yValue),_zValue(zValue),_yawValue(yawValue),QObject(parent)
{
}
short JoystickData::getXValue() const {
return _xValue;
}
short JoystickData::getYValue() const {
return _yValue;
}
short JoystickData::getZValue() const {
return _zValue;
}
short JoystickData::getYawValue() const {
return _yawValue;
}
void JoystickData::setXValue(const short &xValue){
_xValue = xValue;
}
void JoystickData::setYValue(const short &yValue){
_yValue = yValue;
}
void JoystickData::setZValue(const short &zValue){
_zValue = zValue;
}
void JoystickData::setYawValue(const short &yawValue){
_yawValue = yawValue;
}
|
f65d7e8c8643fbe5378c1a2cb96f1a038fbe3163
|
74b7d2e04a23f61a68485c43acfcb0678ca0b93b
|
/Source/Atrc/Core/Material/MicrofacetDistribution/BlinnPhong.h
|
8e97babd58e499e2c1a01785d7ce72e74376420c
|
[
"MIT"
] |
permissive
|
Ilinite/Atrc
|
bded8e19d60dbe32b7265e797bb0afab25551ca6
|
94db1512755eb4df1b01679bafbc60e471f03b42
|
refs/heads/master
| 2020-06-28T13:16:45.337518
| 2019-06-04T07:12:06
| 2019-06-04T07:12:06
| null | 0
| 0
| null | null | null | null |
GB18030
|
C++
| false
| false
| 669
|
h
|
BlinnPhong.h
|
#pragma once
#include <Atrc/Core/Core/CoordSystem.h>
#include <Atrc/Core/Material/Utility/MicrofacetDistribution.h>
namespace Atrc
{
class BlinnPhong : public MicrofacetDistribution
{
Real e_;
public:
explicit BlinnPhong(Real e) noexcept;
Real D(const Vec3 &H) const noexcept override;
Real G(const Vec3 &H, const Vec3 &wi, const Vec3 &wo) const noexcept override;
std::optional<SampleWiResult> SampleWi(const Vec3 &wo, const Vec2 &sample) const noexcept override;
// wi和wo必须在geo coord、shd coord中均处于正半平面
Real SampleWiPDF(const Vec3 &wi, const Vec3 &wo) const noexcept override;
};
} // namespace Atrc
|
cc01a824b0618b3cd7b8a3fe83980b406d4424e6
|
aadbdd69feb5b7fdbf6f57d5ebfc56477b452b04
|
/avsp.cpp
|
fec26b65e299fc97bff25b44d3da85c7b420c8a5
|
[] |
no_license
|
aryandosaj/CompetetiveProgramming
|
16c5dd0d7800288078d250973a9b1d5cb884ebf1
|
e1be46316f4d14eaaffa54b3f36728e8be1f2b1a
|
refs/heads/master
| 2021-06-05T12:37:13.868842
| 2020-07-20T10:24:26
| 2020-07-20T10:24:26
| 145,744,715
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 1,090
|
cpp
|
avsp.cpp
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
#define pll pair<ll, ll>
#define pb push_back
#define F first
#define S second
#define I insert
#define vll vector<ll>
ll power(ll a, ll b, ll mod)
{
ll c = 1;
while (b > 0)
{
if (b % 2)
c *= a, c %= mod;
b /= 2;
a *= a;
a %= mod;
}
return c;
}
#define MAX 1000000007
ll A[1000001];
int main()
{
ios_base::sync_with_stdio(0);
cin.tie(0);
ll n;
cin >> n;
for (int i = 0; i < n; i++)
{
cin >> A[i];
}
ll start = 0;
ll end = n - 1;
for (ll i = 0; i < n; i++)
{
ll element = A[i];
ll p = i + 1;
ll a = 0;
start = 0;
end = n - 1;
while (start <= end)
{
a++;
int mid = (start + end) / 2;
if (A[mid] == element)
break;
else if (A[mid] < element)
start = mid + 1;
else
end = mid - 1;
}
cout<<(p-a)<<" ";
}
}
|
a7ed15a1cd24a934cbc04dcfe63e92efe6078d0a
|
90aaa9b4b7f29faa591193f135d82b608e3518c0
|
/OrderBookVI/OrderBookVI/iTools.cpp
|
598cac907c232371983732dc020ba89ac35d48fa
|
[] |
no_license
|
kjw0612/hb
|
5f4c96177afa23deea533d0568c8867c6a1d9df4
|
c0a21aefec1f34ccf02b1d499c7dcae9966d04e6
|
refs/heads/master
| 2021-03-27T20:51:23.220903
| 2013-11-27T14:48:05
| 2013-11-27T14:48:05
| 7,850,298
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 417
|
cpp
|
iTools.cpp
|
#include "stdafx.h"
#include "iTools.h"
int stoi(string &S) {
int res = 0;
int mi = 0;
if (S.size() > 0 && S[0] == '-') mi = 1;
for(int i=mi;i<SZ(S);i++) res = res * 10 + (S[i]-'0');
if (mi == 1) res = -res;
return res;
}
LL stoi64(string &S) {
LL res = 0;
int mi = 0;
if (S.size() > 0 && S[0] == '-') mi = 1;
for(int i=mi;i<SZ(S);i++) res = res * 10 + (S[i]-'0');
if (mi == 1) res = -res;
return res;
}
|
1174a727aba40406b551c46e586b30d0f4952aec
|
2df8aa5b9ec4d925741c5d7cb42b225110d79948
|
/622.设计循环队列实现.cpp
|
bab4fe14451e34b2319981679eecb8e63eede63d
|
[] |
no_license
|
ljxia1994/leetcode111
|
214df185060e835943e369542c6d2c646e9e385a
|
1ee56a7ff1cc15618ab55e30cde763751fd2ba68
|
refs/heads/master
| 2022-12-09T02:29:00.798761
| 2020-09-03T16:44:19
| 2020-09-03T16:44:19
| 292,621,720
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 2,125
|
cpp
|
622.设计循环队列实现.cpp
|
////用vector设计循环队列类实现
//#include<iostream>
//#include<vector>
//
//using namespace std;
//
//class MyCircularQueue {
//private:
// vector<int> data;
// int head;
// int tail;
// int size;
//
//public:
// //初始化
// MyCircularQueue(int k) {
// data.resize(k);
// head = -1;
// tail = -1;
// size = k;
// }
// //插入元素
// bool enQueue(int value) {
// if (isFull()) {
// return false;
// }
// if (isEmpty()) {
// head = 0;
// }
// tail = (tail + 1) % size;
// data[tail] = value;
// return true;
// }
// //删除元素
// bool deQueue() {
// if (isEmpty()) return false;
// if (head == tail) {
// head = -1;
// tail = -1;
// return true;
// }
// head = (head + 1) % size;
// return true;
// }
// //得到队首元素的值
// int Front() {
// if (!isEmpty()) return data[head];
// return -1;
// }
// //得到队尾元素的值
// int Rear() {
// if (!isEmpty()) return data[tail];
// return -1;
// }
// //检查循环队列是否为空
// bool isEmpty() {
// return (head == -1);
// }
//
// //检查循环队列是否满了
// bool isFull() {
// return (tail + 1) % size == head;
// }
//};
//
//int main()
//{
// MyCircularQueue circularQueue = MyCircularQueue(3);// 设置长度为 3
// cout << circularQueue.enQueue(1) << endl; // 返回 true
// cout << circularQueue.enQueue(2) << endl; // 返回 true
// cout << circularQueue.enQueue(3) << endl; // 返回 true
// cout << circularQueue.enQueue(4) << endl; // 返回 false，队列已满
// cout << circularQueue.Rear() << endl; // 返回 3
// cout << circularQueue.isFull() << endl; // 返回 true
// cout << circularQueue.deQueue() << endl; // 返回 true
// cout << circularQueue.enQueue(4) << endl; // 返回 true
// cout << circularQueue.Rear() << endl; // 返回 4
// return 0;
//}
|
a63e8c7936c2f4575b14866027c9e8355b483f63
|
f2a2498ca53bf42e4b5f26544e9f4f30f1becb0a
|
/linearList/2.2/10.cpp
|
744f6916b2d4190e09cbb5c66dfc266e4daa9884
|
[] |
no_license
|
liqia/dataStructure
|
406253affa88fc551242cee56827dce8a8449944
|
2a9efd309c7302374efa4ffe85a40a818fe30d2a
|
refs/heads/master
| 2020-03-17T06:10:42.273739
| 2018-06-21T02:30:32
| 2018-06-21T02:30:32
| 133,344,781
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 504
|
cpp
|
10.cpp
|
#include<iostream>
#include<stdio.h>
#include<vector>
using namespace std;
void leftN(vector<int> &r,int n){
int *b=new int[n];
for(int i=0;i<n;i++){
b[i]=r[i];
}
for(int i=n;i<r.size();i++){
r[i-n]=r[i];
}
int j=0;
for(int i=r.size()-n;i<r.size();i++){
r[i]=b[j];
j++;
}
}
int main(void)
{
int a[5]={1,2,3,4,5};
vector<int> r(a,a+5);
leftN(r,3);
for(int i=0;i<r.size();i++){
cout<<r[i]<<endl;
}
return 0;
}
|
d9adff83b22eab8742c014882027ac6f98bb729e
|
7a615a4818cbad72fe6bc21d169200c8982d0cd1
|
/src/basic/vx_util/ascii_header.cc
|
27c1d69a1a9c32142c62651cd9e36f974f8c52e4
|
[
"Apache-2.0"
] |
permissive
|
dtcenter/MET
|
860f42331d22f6b616320bb4629aaecc8ac8db67
|
3f0411b65cef5719bf11b6fb75f7e8413fe633f0
|
refs/heads/main_v11.1
| 2023-08-02T00:38:11.726674
| 2023-08-01T22:36:19
| 2023-08-01T22:36:19
| 184,336,905
| 46
| 21
|
Apache-2.0
| 2023-09-14T18:50:21
| 2019-04-30T21:56:39
|
C++
|
UTF-8
|
C++
| false
| false
| 15,211
|
cc
|
ascii_header.cc
|
// *=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*
// ** Copyright UCAR (c) 1992 - 2023
// ** University Corporation for Atmospheric Research (UCAR)
// ** National Center for Atmospheric Research (NCAR)
// ** Research Applications Lab (RAL)
// ** P.O.Box 3000, Boulder, Colorado, 80307-3000, USA
// *=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*
////////////////////////////////////////////////////////////////////////
using namespace std;
#include <cstdio>
#include <iostream>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <cmath>
#include "vx_cal.h"
#include "vx_log.h"
#include "vx_util.h"
#include "ascii_header.h"
////////////////////////////////////////////////////////////////////////
//
// global instantiation of the AsciiHeader class
//
AsciiHeader METHdrTable;
////////////////////////////////////////////////////////////////////////
static const char * header_file_tmpl = "MET_BASE/table_files/met_header_columns_VERSION.txt";
static const char * ascii_header_delim = ":";
static const char * var_index_reg_exp = "^(.*)$";
static const char * var_col_name_str = "[0-9]*";
////////////////////////////////////////////////////////////////////////
static void parse_mctc_fi_oj(const char *, int &, int &);
////////////////////////////////////////////////////////////////////////
//
// Code for class AsciiHeaderLine
//
////////////////////////////////////////////////////////////////////////
AsciiHeaderLine::AsciiHeaderLine() {
init_from_scratch();
}
////////////////////////////////////////////////////////////////////////
AsciiHeaderLine::~AsciiHeaderLine() {
clear();
}
////////////////////////////////////////////////////////////////////////
AsciiHeaderLine::AsciiHeaderLine(const AsciiHeaderLine &a) {
init_from_scratch();
assign(a);
}
////////////////////////////////////////////////////////////////////////
AsciiHeaderLine & AsciiHeaderLine::operator=(const AsciiHeaderLine & a) {
if(this == &a) return(*this);
assign(a);
return(*this);
}
////////////////////////////////////////////////////////////////////////
void AsciiHeaderLine::init_from_scratch() {
clear();
return;
}
////////////////////////////////////////////////////////////////////////
void AsciiHeaderLine::assign(const AsciiHeaderLine &a) {
Version = a.Version;
DataType = a.DataType;
LineType = a.LineType;
NVarCols = a.NVarCols;
VarIndexName = a.VarIndexName;
VarIndexOffset = a.VarIndexOffset;
VarBegOffset = a.VarBegOffset;
ColNames = a.ColNames;
return;
}
////////////////////////////////////////////////////////////////////////
void AsciiHeaderLine::clear() {
Version.clear();
DataType.clear();
LineType.clear();
NVarCols = 0;
VarIndexName.clear();
VarIndexOffset = bad_data_int;
VarBegOffset = bad_data_int;
ColNames.clear();
ColNames.set_ignore_case(true);
return;
}
////////////////////////////////////////////////////////////////////////
void AsciiHeaderLine::set_col_names(const char *s) {
ConcatString cs;
StringArray tok;
const char *method_name = "AsciiHeaderLine::set_col_names(const char *) -> ";
// Parse the header column names
ColNames.parse_wsss(s);
// Handle variable lenght columns
for(int i=0; i<ColNames.n_elements(); i++) {
// Check for the variable index column
if(check_reg_exp(var_index_reg_exp, ColNames[i].c_str())) {
// Can only have one variable index column
if(VarIndexName.nonempty()) {
mlog << Error << "\n" << method_name
<< "can't have multiple variable index columns in line:\n"
<< s << "\n\n";
exit(1);
}
// Store the variable column name and offset
cs = ColNames[i];
tok = cs.split("()"); // Strip off parenthesis
VarIndexName = tok[0];
VarIndexOffset = i;
// Update the variable column name
ColNames.set(i, (string)VarIndexName);
}
// Check for a variable length column
else if(strstr(ColNames[i].c_str(), var_col_name_str) != 0) {
// Check that the variable index column has already been set
if(VarIndexName.empty()) {
mlog << Error << "\n" << method_name
<< "lines with variable length columns must also "
<< "contain a variable index column:\n"
<< s << "\n\n";
exit(1);
}
// Increment the variable column counter
NVarCols++;
// Check for the first variable length column
if(is_bad_data(VarBegOffset) || i < VarBegOffset) {
VarBegOffset = i;
}
} // end else if
} // end for i
return;
}
////////////////////////////////////////////////////////////////////////
bool AsciiHeaderLine::is_mctc() const {
return(LineType == "MCTC");
}
////////////////////////////////////////////////////////////////////////
bool AsciiHeaderLine::is_var_length() const {
return(NVarCols > 0);
}
////////////////////////////////////////////////////////////////////////
int AsciiHeaderLine::n_var_cols(int dim) const {
return(is_mctc() ? NVarCols * dim * dim : NVarCols * dim);
}
////////////////////////////////////////////////////////////////////////
int AsciiHeaderLine::length(int dim) const {
return(ColNames.n_elements() - NVarCols + n_var_cols(dim));
}
////////////////////////////////////////////////////////////////////////
int AsciiHeaderLine::col_offset(const char *name, const int dim) const {
int i, j, icur, match, offset;
ConcatString reg_exp;
// Handle fixed length lines
if(!is_var_length()) {
// Check for no match
if(!ColNames.has(name, offset)) return(bad_data_int);
}
// Handle variable length lines
else {
// Search for column names using regular expressions
for(i=0, match=bad_data_int; i<ColNames.n_elements(); i++) {
reg_exp.format("^%s$", ColNames[i].c_str());
if(check_reg_exp(reg_exp.c_str(), name)) {
match = i;
break;
}
}
// Check for no match
if(is_bad_data(match)) return(bad_data_int);
// Fixed columns before variable ones
if(match < VarBegOffset) {
offset = match; // Matching column offset
}
// Fixed columns after variable ones
else if(match >= (VarBegOffset + NVarCols)) {
// Handle MCTC special case for dim*dim
if(is_mctc()) {
offset = match + // Matching column offset
(dim * dim * NVarCols) - // Plus total of variable columns
NVarCols; // Minus variable column names
}
else {
offset = match + // Matching column offset
(dim * NVarCols) - // Plus total of variable columns
NVarCols; // Minus variable column names
}
}
// Variable columns
else {
// Handle MCTC special case (Fi_Oj) for NxN contingency table
if(is_mctc()) {
parse_mctc_fi_oj(name, i, j);
offset = VarBegOffset + (i-1)*dim + (j-1);
}
// Handle the rest
else {
// Parse index from the column name
icur = parse_thresh_index(name) - 1; // 0-based index
offset = VarBegOffset + // Beginning of variable columns
(icur * NVarCols) + // Plus index times variable columns
(match - VarBegOffset); // Plus matching column minus beginning
}
}
} // end else
return(offset);
}
////////////////////////////////////////////////////////////////////////
ConcatString AsciiHeaderLine::col_name(const int offset, int const dim) const {
int i, j;
ConcatString name, str;
const char *method_name = "AsciiHeaderLine::col_name() -> ";
// Range check
if(offset < 0 || offset >= length(dim)) {
mlog << Error << "\n" << method_name
<< "range check error for data/line type \""
<< DataType << "/" << LineType << "\" and offset = "
<< offset << "\n\n";
exit(1);
}
// Handle fixed length lines and columns
if(!is_var_length() || offset < VarBegOffset) {
name = ColNames[offset];
}
// Fixed columns after variable ones
else if(offset >= (VarBegOffset + n_var_cols(dim))) {
name = ColNames[offset - n_var_cols(dim) + 1];
}
// Variable columns
else {
// Handle MCTC special case (Fi_Oj) for NxN contingency table
if(is_mctc()) {
i = (offset - VarBegOffset) / dim;
j = (offset - VarBegOffset) % dim;
name.format("F%i_O%i", i+1, j+1);
}
// Handle the rest
else {
i = VarBegOffset + (offset - VarBegOffset) % NVarCols;
str << cs_erase << (offset - VarBegOffset) / NVarCols + 1;
name = str_replace(ColNames[i].c_str(), "[0-9]*", str.c_str());
} // end else
}
return(name);
}
////////////////////////////////////////////////////////////////////////
//
// Code for class AsciiHeader
//
////////////////////////////////////////////////////////////////////////
AsciiHeader::AsciiHeader() {
init_from_scratch();
ConcatString version_mm(parse_version_major_minor(met_version));
read(version_mm.c_str());
}
////////////////////////////////////////////////////////////////////////
AsciiHeader::~AsciiHeader() {
clear();
}
////////////////////////////////////////////////////////////////////////
AsciiHeader::AsciiHeader(const AsciiHeader &a) {
init_from_scratch();
assign(a);
}
////////////////////////////////////////////////////////////////////////
AsciiHeader::AsciiHeader(const char *version) {
init_from_scratch();
read(version);
}
////////////////////////////////////////////////////////////////////////
AsciiHeader & AsciiHeader::operator=(const AsciiHeader & a) {
if(this == &a) return(*this);
assign(a);
return(*this);
}
////////////////////////////////////////////////////////////////////////
void AsciiHeader::init_from_scratch() {
clear();
return;
}
////////////////////////////////////////////////////////////////////////
void AsciiHeader::assign(const AsciiHeader &a) {
Versions = a.Versions;
Headers = a.Headers;
return;
}
////////////////////////////////////////////////////////////////////////
void AsciiHeader::clear() {
Versions.clear();
Headers.clear();
return;
}
////////////////////////////////////////////////////////////////////////
void AsciiHeader::read(const char *version) {
ConcatString file_name;
DataLine line;
AsciiHeaderLine header_line;
LineDataFile in;
const char *method_name = "AsciiHeader::read() -> ";
// Set the delimiter for parsing this data
line.set_delimiter(ascii_header_delim);
// Read headers for the specified version of MET
if(!Versions.has(version)) {
// Substitute in the current version and handle MET_BASE
file_name = replace_path(str_replace(header_file_tmpl, "VERSION", version));
mlog << Debug(4)
<< "Reading MET header columns:\n" << file_name << "\n";
// Open the data file
if(!in.open(file_name.c_str())) {
mlog << Error << "\n" << method_name
<< "trouble reading file:\n" << file_name << "\n\n";
exit(1);
}
// Process each line from the input file
while(in >> line) {
// Check for blank line
if(line.n_items() == 0) continue;
// Check for the expected number of tokens
if(line.n_items() != 4) {
mlog << Error << "\n" << method_name
<< "expected 4 tokens but found " << line.n_items()
<< " on line number " << line.line_number()
<< " of file:\n" << file_name << "\n\n";
exit(1);
}
// Process data from the current line
header_line.clear();
header_line.set_version (line[0]);
header_line.set_data_type(line[1]);
header_line.set_line_type(line[2]);
header_line.set_col_names(line[3]);
// Store the current line
Headers.push_back(header_line);
}
// Store the version we just loaded
Versions.add(version);
}
return;
}
////////////////////////////////////////////////////////////////////////
const AsciiHeaderLine * AsciiHeader::header(const char *version,
const char *data_type,
const char *line_type) {
const char *method_name = "AsciiHeader::header() -> ";
ConcatString version_mm(parse_version_major_minor(version));
// Check if the version needs to be loaded
if(!Versions.has(version_mm)) read(version_mm.c_str());
// Find matching header line
// Allow NA for line_type to match any line type
vector<AsciiHeaderLine>::const_iterator it;
for(it = Headers.begin(); it != Headers.end(); ++it) {
if(strcmp(it->version(), version_mm.c_str()) == 0 &&
strcmp(it->data_type(), data_type) == 0 &&
(strcmp(it->line_type(), line_type) == 0 ||
strcmp(na_str, line_type) == 0)) break;
}
// Check for no match
if(it == Headers.end()) {
mlog << Error << "\n" << method_name
<< "can't find header columns for MET version \"" << version
<< "\", data type \"" << data_type << "\", line type \""
<< line_type << "\"!\n\n";
exit(1);
}
return(&(*it));
}
////////////////////////////////////////////////////////////////////////
int AsciiHeader::col_offset(const char *version, const char *data_type,
const char *line_type, const char *name,
const int dim) {
const AsciiHeaderLine *line = header(version, data_type, line_type);
return(line->col_offset(name, dim));
}
////////////////////////////////////////////////////////////////////////
ConcatString AsciiHeader::col_name(const char *version, const char *data_type,
const char *line_type, const int offset,
const int dim) {
const AsciiHeaderLine *line = header(version, data_type, line_type);
return(line->col_name(offset, dim));
}
////////////////////////////////////////////////////////////////////////
//
// Begin miscellaneous utility functions
//
////////////////////////////////////////////////////////////////////////
void parse_mctc_fi_oj(const char *str, int &i, int &j) {
const char *ptr = str + 1;
// Parse Fi_Oj strings
i = atoi(ptr);
if((ptr = strrchr(str, '_')) != nullptr) {
ptr += 2;
j = atoi(ptr);
}
else {
mlog << Error << "\nparse_mctc_fi_oj() -> "
<< "unexpected column name specified: \""
<< str << "\"\n\n";
exit(1);
}
return;
}
////////////////////////////////////////////////////////////////////////
|
1a0527322ea2425748149d97c9bbcae58d6d5ce9
|
fcb40f62a31fdf622bc454dd08554abbb3217177
|
/helper.h
|
cfb99b300257ea2fc7aeff3408fbcce18497c51e
|
[] |
no_license
|
chenreny/DNA-alignment
|
f69650ee5e0e1f095193301e0030c1e50a0c2730
|
d8adce08585ebacbee88dd49a6a7dc20ddb8ee7c
|
refs/heads/master
| 2020-03-28T15:00:36.013754
| 2018-09-13T07:08:26
| 2018-09-13T07:08:26
| 148,546,340
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 606
|
h
|
helper.h
|
//
// helper.h
// genome string problem
//
// Created by Renying Chen on 8/16/18.
// Copyright © 2018 Renying Chen. All rights reserved.
//
#ifndef helper_h
#define helper_h
#include <iostream>
#include <vector>
#include <map>
#include <unordered_map>
#include "murmur3.h"
using namespace std;
class Solver{
public:
void readFile();
void compute();
~Solver(){
delete refer;
}
private:
string* refer;
// char* refer;
unordered_map<int,vector<pair<string, int> > > refMap;
int size;
};
#endif /* helper_h */
|
9c4759eee264ccbfa62fe0090ea7bcee8da2c968
|
97e76ec354c5b7f74b3485317ce01a68e21dd8f2
|
/zsg/day01/LeetCode_0507_206_01.cpp
|
5c66c53c8bcf8fdd2393e70055df04286ed7ff3c
|
[] |
no_license
|
ShixianGuo/LeetCode
|
870c23929e361f20becf9b070eadbe4b95faa218
|
cefaca1f2b70e13b9894bc4bfaa28fe90454b8b4
|
refs/heads/master
| 2022-11-08T08:39:45.176535
| 2020-06-05T05:05:19
| 2020-06-05T05:05:19
| 259,957,334
| 11
| 34
| null | 2020-06-05T05:05:20
| 2020-04-29T14:59:09
|
C++
|
UTF-8
|
C++
| false
| false
| 954
|
cpp
|
LeetCode_0507_206_01.cpp
|
#include <bits/stdc++.h>
using namespace std;
//Definition for singly-linked list.
struct ListNode {
int val;
ListNode *next;
ListNode(int x) : val(x), next(NULL) {}
};
class Solution {
public:
ListNode* reverseList(ListNode* head) {
if (head == NULL || head->next == NULL) return head;
ListNode* head1 = head;
while (head->next != NULL) {
head = head->next;
}
ListNode* temp_head = head;
head = NULL;
temp_head->next = reverseList(head1);
return temp_head;
}
};
int main()
{
ListNode* head;
head->val = 1;
head->next->val = 2;
head->next->next->val = 3;
head->next->next->next->val = 4;
head->next->next->next->next->val = 5;
head->next->next->next->next->next = NULL;
Solution ss;
ListNode* temp = ss.reverseList(head);
while (temp->next != NULL) {
cout << temp->val << " ";
}
return 0;
}
|
12462ca3c1de6ef6c85aa0fdd9b432271b7d1599
|
6cd1bf6544347c85cabaf672a5ed2dad94a18b63
|
/kakomon/abc192_f.cpp
|
4572235dafd582d883d59613e73bc78d8230e410
|
[] |
no_license
|
Shell-Wataru/AtCoder
|
0a35f12478ac0ab54711171f653ce7bed5189c92
|
0ba32250f4e4a44459a4cd231ff47a5f46c4fe87
|
refs/heads/master
| 2023-01-10T04:21:25.199532
| 2023-01-09T04:16:30
| 2023-01-09T04:16:30
| 89,144,933
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 1,262
|
cpp
|
abc192_f.cpp
|
#include <iostream>
#include <algorithm>
#include <vector>
#include <deque>
#include <queue>
#include <set>
#include <map>
#include <limits>
#include <cmath>
#include <iomanip>
#include <functional>
#include <random>
#include <set>
using namespace std;
using ll = long long;
ll answer(vector<ll> &A,ll N, ll X,ll K){
vector<vector<ll>> DP(K+1,vector<ll>(K,numeric_limits<ll>::min()/2));
DP[0][X%K] = 0;
for(int i = 0;i < N;i++){
vector<vector<ll>> newDP = DP;
for(int j = 0;j < K;j++){
for(int k = 0;k < K;k++){
if (DP[j][k] != numeric_limits<ll>::min()/2){
newDP[j+1][(X - (DP[j][k] + A[i]))% K] = max(newDP[j+1][(X - (DP[j][k] + A[i]))% K], DP[j][k] + A[i]);
}
}
}
DP = newDP;
}
if (DP[K][0] == numeric_limits<ll>::min()/2){
return -1;
}else{
return (X - DP[K][0])/K;
}
}
int main()
{
ll N,X;
cin >> N >> X;
vector<ll> A(N);
for(int i = 0;i < N;i++){
cin >> A[i];
}
ll ans = numeric_limits<ll>::max();
for(int i = 1;i <= N;i++){
ll a = answer(A,N,X,i);
if (a != -1){
ans = min(ans,a);
}
}
cout << ans << endl;
return 0;
}
|
8138f77675975b21206a5953ce0465187ccc8d3e
|
12230a10063eabbcfa11da5b88ceacf01c720998
|
/main/src/nvs.cpp
|
b7eb27bad0a1faf009775bc57cdf456757c4916f
|
[] |
no_license
|
juliaschatz/die_ente_esp32
|
4f120e2e540be69f9a1337171f0eb5831a45968b
|
8e4ae242d4d87112ff6f7aa88a4d1b41668fb091
|
refs/heads/master
| 2021-11-28T00:33:53.458233
| 2021-11-21T23:56:00
| 2021-11-21T23:56:00
| 188,526,384
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 291
|
cpp
|
nvs.cpp
|
#include "nvs_flash.h"
#include "nvs.h"
void init_nvs() {
//Initialize NVS
esp_err_t ret = nvs_flash_init();
if (ret == ESP_ERR_NVS_NO_FREE_PAGES || ret == ESP_ERR_NVS_NEW_VERSION_FOUND) {
ESP_ERROR_CHECK(nvs_flash_erase());
ret = nvs_flash_init();
}
ESP_ERROR_CHECK(ret);
}
|
018c19fbafb9cee99fed78401e0626b6f9282bfd
|
d3a8d73036e63168b5d461564073c9c8da114a48
|
/EulerP78/main.cpp
|
871347ecfcf288dd7a657ccd2dd426aa729b4102
|
[] |
no_license
|
BhandariRupraj/projecteuler
|
42cb7b87c2e28129ee19ec0e3f07d7e05f629635
|
5e8aae487daa571b88f6a26bae323fb062a3a036
|
refs/heads/master
| 2021-08-23T21:57:23.374612
| 2017-12-06T18:21:51
| 2017-12-06T18:21:51
| 109,030,162
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 973
|
cpp
|
main.cpp
|
#include <iostream>
#include <vector>
using namespace std;
static vector<long long> pentagon;
vector<long long> A001318(long long max) {
int i;
vector<long long> r;
for(i = 1; i * (3 * i + 1) / 2 <= max; i++) {
r.push_back(i * (3 * i - 1) / 2);
r.push_back(i * (3 * i + 1) / 2);
}
return r;
}
int A000041(int max = 1000000) {
int i, j;
long long v;
vector<long long> r;
//Init
r = {1};
for(i = 1; i < max; i++) {
v = 0;
for(j = 0; j < pentagon.size() && pentagon[j] <= i; j++) {
if(j % 4 == 0 || j % 4 == 1)
v += r[i - pentagon[j]];
else
v -= r[i - pentagon[j]];
v %= 1000000;
}
r.push_back(v);
if(v == 0)
return i;
}
return -1;
}
int main() {
//Generate pentagon numbers
pentagon = A001318(60000);
cout << "Result = " << A000041() << endl;
return 0;
}
|
563c299bfaeae3cfb04b0ca24e817f001cfe6ac9
|
5e91517915556a26a84df1895b6566d461244075
|
/Source/Workshop/Interfaces/TurnBasedInterface.cpp
|
ad5f61e561375650017ab2a20ebe36693f7100b4
|
[
"MIT"
] |
permissive
|
MShepelin/TurnBasedWorkshop
|
2d0b1bd162846a3d63c7aab0b82f1a0677964fac
|
d7a170c4c84c0a3c1da5ab361396cddb03237280
|
refs/heads/master
| 2023-03-25T09:12:49.165217
| 2021-03-13T11:28:00
| 2021-03-13T11:28:00
| 287,909,426
| 6
| 0
| null | null | null | null |
WINDOWS-1252
|
C++
| false
| false
| 564
|
cpp
|
TurnBasedInterface.cpp
|
// Copyright © Dmitriy Shepelin 2021. MIT License.
#include "TurnBasedInterface.h"
void ITurnBasedInterface::OnConnectToManager_Implementation()
{
UE_LOG(LogTemp, Warning, TEXT("Successful connection"));
}
void ITurnBasedInterface::OnDisconnectFromManager_Implementation()
{
UE_LOG(LogTemp, Warning, TEXT("Disconnection"));
}
void ITurnBasedInterface::OnLoseTurnControl_Implementation()
{
UE_LOG(LogTemp, Warning, TEXT("Lost control"));
}
void ITurnBasedInterface::OnGetTurnControl_Implementation()
{
UE_LOG(LogTemp, Warning, TEXT("Got control"));
}
|
49e93b9d2f2a3c4f2708952d2361b265064cca23
|
5d83739af703fb400857cecc69aadaf02e07f8d1
|
/Archive2/1e/f25cdd076af0ae/main.cpp
|
1590ae8de937e738d98601ffb81c8ce3a361f964
|
[] |
no_license
|
WhiZTiM/coliru
|
3a6c4c0bdac566d1aa1c21818118ba70479b0f40
|
2c72c048846c082f943e6c7f9fa8d94aee76979f
|
refs/heads/master
| 2021-01-01T05:10:33.812560
| 2015-08-24T19:09:22
| 2015-08-24T19:09:22
| 56,789,706
| 3
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 2,510
|
cpp
|
main.cpp
|
#include <iostream>
#include <utility>
#include <functional>
#include <boost/any.hpp>
#include <vector>
#include <string>
#include <initializer_list>
using boost::any_cast;
template <typename F,typename... T>
using bind_type = decltype(std::bind(std::declval<std::function<F(T...)>>(),std::declval<T>()...));
template <typename F,typename... T>
class Action {
public:
template <typename... ConstrT>
Action(std::function<F(T...)> f, ConstrT&&... args)
: bind_(f,std::forward<ConstrT>(args)...)
{ }
F act()
{ return bind_(); }
bind_type<F,T...> bind_;
};
class Results{
public:
int size;
std::vector<boost::any> res;
Results(int n) : size(n) { }
template<typename T>
T returnit(int i){
return any_cast<T>(res[i]);
}
};
class Runner{
private:
std::vector<boost::any> ACTION_OBJS;
public:
Runner(const boost::any& a){
ACTION_OBJS.push_back(a);
}
Runner& add_action(const boost::any& a){
ACTION_OBJS.push_back(a);
return *this;
}
/* Does not work for some reason */
Runner operator=(std::initializer_list<boost::any> a){
for ( auto& x : a )
ACTION_OBJS.push_back(x);
return *this;
}
template <typename F,typename... T>
void run(Results& r,int start=0){
for( int i=start; i< ACTION_OBJS.size() && i < r.size ; i++ ){
auto temp_func = any_cast<Action<F,T...>>(ACTION_OBJS[i]);
try {
r.res.push_back( temp_func.act() );
} catch ( ... ) {
r.res.push_back( "Void function" );
}
}
}
};
int add (int y , int z){
return y+z;
}
int mul (int y , int z){
return y*z;
}
void print(std::string& x){
std::cout << x << std::endl;
}
int main()
{
using AO_Sig1 = Action<int,int,int>;
using AO_Sig2 = Action<void,std::string&>;
AO_Sig1 my_add(add,6, 4);
AO_Sig1 my_mul(mul,6, 4);
AO_Sig2 my_print(print,"a_normal_string");
Runner r { my_add };
r.add_action(my_mul);
r.add_action(my_print);
Results res(3);
r.run<int,int,int>(res);
std::cout << res.returnit<int>(0) << std::endl;
std::cout << res.returnit<int>(1) << std::endl;
//std::cout << res.returnit<std::string>(2) << std::endl;
//r.add_action(my_mul);
//r.run<int,int,int>(res,3);
//std::cout << res.returnit<int>(3) << std::endl;
return 0;
}
|
eeb978b3886ed29b1ee3322881c7f5b54dcebe38
|
3d6f999526ac252f5d68d564c553391c1c219825
|
/srcs/server_src/common/pool.h
|
f53959cba3210f2cd19abfc7fc323b3b3aae9dd4
|
[
"Unlicense"
] |
permissive
|
kdoggdev/cncn_m2
|
e77354257de654f6507bcd14f0589311318bcbc0
|
149087e114be2b35c3e1548f4d37d6618ae27442
|
refs/heads/main
| 2023-02-02T09:56:37.306125
| 2020-12-23T09:52:14
| 2020-12-23T09:52:14
| 337,634,606
| 0
| 1
|
Unlicense
| 2021-02-10T06:13:27
| 2021-02-10T06:13:27
| null |
UTF-8
|
C++
| false
| false
| 2,968
|
h
|
pool.h
|
#ifndef __INC_METIN_II_COMMON_POOL_H__
#define __INC_METIN_II_COMMON_POOL_H__
#include <assert.h>
#include <string>
template<typename T>
class CPoolNode : public T
{
public:
CPoolNode()
{
m_pNext = NULL;
m_pPrev = NULL;
}
virtual ~CPoolNode()
{
}
public:
CPoolNode<T> * m_pNext;
CPoolNode<T> * m_pPrev;
};
template<typename T>
class CDynamicPool
{
public:
typedef CPoolNode<T> TNode;
public:
CDynamicPool()
{
Initialize();
}
virtual ~CDynamicPool()
{
assert(m_pFreeList==NULL && "CDynamicPool::~CDynamicPool() - NOT Clear");
assert(m_pUsedList==NULL && "CDynamicPool::~CDynamicPool() - NOT Clear");
Clear();
}
void Initialize()
{
m_nodes = NULL;
m_nodeCount = 0;
m_pFreeList = NULL;
m_pUsedList = NULL;
}
void SetName(const char* c_szName)
{
m_stName = c_szName;
}
DWORD GetCapacity()
{
return m_nodeCount;
}
T* Alloc()
{
TNode* pnewNode;
if (m_pFreeList)
{
pnewNode = m_pFreeList;
m_pFreeList = m_pFreeList->m_pNext;
}
else
{
pnewNode = AllocNode();
}
if (!pnewNode)
return NULL;
if (!m_pUsedList)
{
m_pUsedList = pnewNode;
m_pUsedList->m_pPrev = m_pUsedList->m_pNext = NULL;
}
else
{
m_pUsedList->m_pPrev = pnewNode;
pnewNode->m_pNext = m_pUsedList;
pnewNode->m_pPrev = NULL;
m_pUsedList = pnewNode;
}
//Tracef("%s Pool Alloc %p\n", m_stName.c_str(), pnewNode);
return (T*) pnewNode;
}
void Free(T * pdata)
{
TNode* pfreeNode = (TNode*) pdata;
if (pfreeNode == m_pUsedList)
{
if (NULL != (m_pUsedList = m_pUsedList->m_pNext))
m_pUsedList->m_pPrev = NULL;
}
else
{
if (pfreeNode->m_pNext)
pfreeNode->m_pNext->m_pPrev = pfreeNode->m_pPrev;
if (pfreeNode->m_pPrev)
pfreeNode->m_pPrev->m_pNext = pfreeNode->m_pNext;
}
pfreeNode->m_pPrev = NULL;
pfreeNode->m_pNext = m_pFreeList;
m_pFreeList = pfreeNode;
//Tracef("%s Pool Free\n", m_stName.c_str());
}
void FreeAll()
{
TNode * pcurNode;
TNode * pnextNode;
pcurNode = m_pUsedList;
while (pcurNode)
{
pnextNode = pcurNode->m_pNext;
Free(pcurNode);
pcurNode = pnextNode;
}
}
void Clear()
{
TNode* pcurNode;
TNode* pnextNode;
DWORD count = 0;
pcurNode = m_pFreeList;
while (pcurNode)
{
pnextNode = pcurNode->m_pNext;
delete pcurNode;
pcurNode = pnextNode;
++count;
}
m_pFreeList = NULL;
pcurNode = m_pUsedList;
while (pcurNode)
{
pnextNode = pcurNode->m_pNext;
delete pcurNode;
pcurNode = pnextNode;
++count;
}
m_pUsedList = NULL;
assert(count==m_nodeCount && "CDynamicPool::Clear()");
m_nodeCount=0;
}
protected:
TNode* AllocNode()
{
++m_nodeCount;
return new TNode;
}
protected:
TNode * m_nodes;
TNode * m_pFreeList;
TNode * m_pUsedList;
DWORD m_nodeCount;
std::string m_stName;
};
#endif
|
29a9db115373a4390017ed5bcaeb0b7cd9fd8e21
|
bb7645bab64acc5bc93429a6cdf43e1638237980
|
/Official Windows Platform Sample/Windows 8.1 Store app samples/99866-Windows 8.1 Store app samples/Application resources and localization sample/C++/AppResourceClassLibrary/Class1.cpp
|
2b9ef53f9cee7bd02beb1d8c3ef327565c2500ae
|
[
"MIT"
] |
permissive
|
Violet26/msdn-code-gallery-microsoft
|
3b1d9cfb494dc06b0bd3d509b6b4762eae2e2312
|
df0f5129fa839a6de8f0f7f7397a8b290c60ffbb
|
refs/heads/master
| 2020-12-02T02:00:48.716941
| 2020-01-05T22:39:02
| 2020-01-05T22:39:02
| 230,851,047
| 1
| 0
|
MIT
| 2019-12-30T05:06:00
| 2019-12-30T05:05:59
| null |
UTF-8
|
C++
| false
| false
| 371
|
cpp
|
Class1.cpp
|
// Class1.cpp
#include "pch.h"
#include "Class1.h"
using namespace AppResourceClassLibrary;
using namespace Platform;
using namespace Windows::ApplicationModel::Resources;
Class1::Class1()
{
resourceLoader = ResourceLoader::GetForCurrentView("AppResourceClassLibrary/Resources");
}
String^ Class1::GetString()
{
return resourceLoader->GetString("string1");
}
|
ac41da721b65d10e98620457d9218cf5ebebcfb0
|
201bf36dedceebe088ffa93c006357b57f259d1f
|
/FlipdotConfig.h
|
0ba7d214a9db39b0d189966aa173cb7245ef620b
|
[] |
no_license
|
cfr34k/FlipdotCpp
|
f026e82bb694145eb90f720b9c2bbd18ce4fe4de
|
e97535d61fa0153f2d60cea7fbf961ab9cc45412
|
refs/heads/master
| 2021-01-11T03:19:36.331315
| 2016-10-18T19:24:39
| 2016-10-18T19:24:39
| 71,023,672
| 1
| 0
| null | 2016-10-16T01:32:35
| 2016-10-16T01:32:34
| null |
UTF-8
|
C++
| false
| false
| 314
|
h
|
FlipdotConfig.h
|
#pragma once
#include <FlipdotTypes.h>
constexpr int NUM_PANELS = 4;
constexpr int SCREEN_WIDTH = 32;
constexpr int SCREEN_HEIGHT = 40;
constexpr PanelConfig PANEL_CONFG[] = {
{ 0, 20, Orientation::DEG_180},
{ 0, 0, Orientation::DEG_180},
{16, 0, Orientation::DEG_0},
{16, 20, Orientation::DEG_0}
};
|
1adca82c951501ef74ab747848cf81be6b22cbcd
|
9bf801d026353682d13ef8aff1146c6380baafd9
|
/cpp/everydaycpp/第22章命名空间/6 未命名名字空间与全局变量的区别/1.cpp
|
e56140ae7130fac22eb9beb09470e15fc3f14f3d
|
[] |
no_license
|
wongzigii/harkcode
|
57ffd7d0d9ba382ce1d82496e958a366862c93ca
|
49ecdf2cb0097860d0f04285c095a8ca6accfac3
|
refs/heads/master
| 2021-01-14T10:18:18.986551
| 2015-12-19T07:02:10
| 2015-12-19T07:02:10
| null | 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 49
|
cpp
|
1.cpp
|
#include <iostream>
namespace
{
int x=5;
}
|
b48ca5852de8460f3f85e43070c5b53a8816fe61
|
a887e9eb9eb59ad3b3a2ba104e2c659768eab11b
|
/ex06/Buzz.hpp
|
7e3d562e3a6c6b30db87b292edc9d0fda1cfa1b6
|
[] |
no_license
|
Epitech-Tek2/CPPD13
|
3cb2c0e42695af90f3043bb5a3c8e39e787063f1
|
c94f844b96b61b603ece04008abd70554b8f06ff
|
refs/heads/master
| 2023-08-18T21:09:18.724125
| 2021-10-17T12:11:39
| 2021-10-17T12:11:39
| 418,120,397
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 407
|
hpp
|
Buzz.hpp
|
/*
** EPITECH PROJECT, 2021
** B-CPP-300-STG-3-1-CPPD13-clement.muth
** File description:
** Buzz
*/
#pragma once
#include "Toy.hpp"
class Buzz : public Toy
{
public:
Buzz(std::string const& name, std::string const& filename = "buzz.txt") noexcept;
Buzz(Buzz const& buzz) noexcept;
virtual ~Buzz() = default;
virtual bool speak(std::string const message) noexcept;
};
|
ee7460d5c3096e0af936784407dbea2c8beaf0c4
|
5e42800bf2f07f4697f22c89e64f89aa04f91de5
|
/c++/score/transbmp.cpp
|
94404cfa4207c985f756f4b788178073bccede6a
|
[] |
no_license
|
trieck/source
|
52cee310f8c28781996c546e05ce14baca28ac0f
|
ad8da1b70deef58005aa4226e36d5eefad71920a
|
refs/heads/master
| 2023-01-22T14:44:51.389815
| 2023-01-14T23:02:21
| 2023-01-14T23:02:21
| 13,166,584
| 1
| 0
| null | 2021-06-27T21:24:46
| 2013-09-28T03:42:40
|
C++
|
WINDOWS-1252
|
C++
| false
| false
| 3,347
|
cpp
|
transbmp.cpp
|
///////////////////////////////////////////////////////////////////////
//
// TRANSBMP.CPP : transparent bitmap
//
// Copyright © 1999 Rieck Enterprises
//
#include "stdafx.h"
#include "transbmp.h"
//
// Constructor
//
TransparentBitmap :: TransparentBitmap(UINT nID, COLORREF transparent)
{
m_fInitialized = FALSE;
m_pOldBitmapMem = NULL;
m_pOldBitmapXor = NULL;
m_pOldBitmapAnd = NULL;
m_transparent = transparent;
if (!LoadBitmap(nID))
AfxThrowUserException();
}
//
// Initialize
//
BOOL TransparentBitmap :: Initialize(CDC * pDC)
{
ASSERT((HBITMAP)*this != NULL);
ASSERT_VALID(pDC);
if (m_fInitialized)
return FALSE;
BITMAP bm;
GetObject(sizeof(BITMAP), &bm);
CPoint size(bm.bmWidth, bm.bmHeight);
CPoint org(0, 0);
// Create a memory DC and select the bitmap into it
CDC dcImage;
dcImage.CreateCompatibleDC(pDC);
CBitmap * pOldBitmapImage = dcImage.SelectObject(this);
dcImage.SetMapMode(pDC->GetMapMode());
// Create a second memory DC and in it create an AND mask
m_AndDC.CreateCompatibleDC(pDC);
m_AndDC.SetMapMode(pDC->GetMapMode());
CBitmap bitmapAnd;
bitmapAnd.CreateBitmap(bm.bmWidth, bm.bmHeight, 1, 1, NULL);
m_pOldBitmapAnd = m_AndDC.SelectObject(&bitmapAnd);
dcImage.SetBkColor(m_transparent);
m_AndDC.BitBlt(org.x, org.y, size.x, size.y, &dcImage, org.x, org.y, SRCCOPY);
// Create a third memory DC and in it create an XOR mask
m_XOrDC.CreateCompatibleDC(pDC);
m_XOrDC.SetMapMode(pDC->GetMapMode());
CBitmap bitmapXor;
bitmapXor.CreateCompatibleBitmap(&dcImage, bm.bmWidth, bm.bmHeight);
m_pOldBitmapXor = m_XOrDC.SelectObject(&bitmapXor);
m_XOrDC.BitBlt(org.x, org.y, size.x, size.y, &dcImage, org.x, org.y, SRCCOPY);
m_XOrDC.BitBlt(org.x, org.y, size.x, size.y, &m_AndDC, org.x, org.y, 0x220326);
// Copy the pixels in the destination rectangle to the memory DC
m_MemDC.CreateCompatibleDC(pDC);
m_MemDC.SetMapMode(pDC->GetMapMode());
CBitmap bitmapMem;
bitmapMem.CreateCompatibleBitmap(&dcImage, bm.bmWidth, bm.bmHeight);
m_pOldBitmapMem = m_MemDC.SelectObject(&bitmapMem);
dcImage.SelectObject(pOldBitmapImage);
m_fInitialized = TRUE;
return TRUE;
}
//
// Render
//
BOOL TransparentBitmap :: Render(CDC * pDC, int x, int y)
{
ASSERT_VALID(pDC);
if (!m_fInitialized)
return FALSE;
BITMAP bm;
GetObject(sizeof(BITMAP), &bm);
CPoint size(bm.bmWidth, bm.bmHeight);
CPoint org(0, 0);
m_MemDC.BitBlt(org.x, org.y, size.x, size.y, pDC, x, y, SRCCOPY);
// Generate the final image by applying the AND and XOR masks to
// the image in the temporary memory DC
m_MemDC.BitBlt(org.x, org.y, size.x, size.y, &m_AndDC, org.x, org.y, SRCAND);
m_MemDC.BitBlt(org.x, org.y, size.x, size.y, &m_XOrDC, org.x, org.y, SRCINVERT);
// Blit the resulting image to the screen
pDC->BitBlt(x, y, size.x, size.y, &m_MemDC, org.x, org.y, SRCCOPY);
return TRUE;
}
//
// Destructor
//
TransparentBitmap :: ~TransparentBitmap()
{
if (m_pOldBitmapMem != NULL)
m_MemDC.SelectObject(m_pOldBitmapMem);
if (m_pOldBitmapXor != NULL)
m_XOrDC.SelectObject(m_pOldBitmapXor);
if (m_pOldBitmapAnd != NULL)
m_AndDC.SelectObject(m_pOldBitmapAnd);
}
|
d9ba032736d2b28b1f51239f4819b3a70618fb4c
|
f5adc4e570e34ff478b19cf4c5863b1866d71537
|
/Main/ImportLibraryFromZip.cpp
|
f7989d6548ba3e92c2dc1e18ec8a93bb5c9c668d
|
[] |
no_license
|
cspark777/PDFManager
|
b42bafe122deaa687df634d11eaefb5d71ce23fa
|
3fb75c88eb0600fa994bf5985641fd9a9d408a51
|
refs/heads/master
| 2021-01-01T05:10:18.302326
| 2016-05-03T23:31:54
| 2016-05-03T23:31:54
| 58,008,155
| 1
| 2
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 2,678
|
cpp
|
ImportLibraryFromZip.cpp
|
// ImportLibraryFromZip.cpp : implementation file
//
#include "stdafx.h"
#include "Benubird.h"
#include "ImportLibraryFromZip.h"
#include "afxdialogex.h"
#include "FolderDlg.h"
// CImportLibraryFromZip dialog
IMPLEMENT_DYNAMIC(CImportLibraryFromZip, CDialogEx)
CImportLibraryFromZip::CImportLibraryFromZip(CWnd* pParent /*=NULL*/)
: CDialogEx(CImportLibraryFromZip::IDD, pParent)
{
}
CImportLibraryFromZip::~CImportLibraryFromZip()
{
}
BOOL CImportLibraryFromZip::OnInitDialog()
{
CDialog::OnInitDialog();
CString lStrFilter;
lStrFilter.LoadString(IDS_ZIP_FILES_FILTER);
m_txtZipFilePath.EnableFileBrowseButton(_T(".zip"), lStrFilter);
m_txtPassword.EnableWindow(0);
return TRUE;
}
void CImportLibraryFromZip::DoDataExchange(CDataExchange* pDX)
{
CDialogEx::DoDataExchange(pDX);
DDX_Control(pDX, IDC_CHECK_PASSWORD, m_chkIsPassword);
DDX_Control(pDX, IDC_EDIT_DEST_DIRECTORY, m_txtDestDirectory);
DDX_Control(pDX, IDC_EDIT_INPUT, m_txtZipFilePath);
DDX_Control(pDX, IDC_EDIT_PASSWORD, m_txtPassword);
DDX_Control(pDX, IDC_BUTTON_BROWSER, m_btnBrowser);
}
BEGIN_MESSAGE_MAP(CImportLibraryFromZip, CDialogEx)
ON_BN_CLICKED(IDC_CHECK_PASSWORD, &CImportLibraryFromZip::OnBnClickedCheckPassword)
ON_BN_CLICKED(IDOK, &CImportLibraryFromZip::OnBnClickedOk)
ON_BN_CLICKED(IDC_BUTTON_BROWSER, &CImportLibraryFromZip::OnBnClickedButtonBrowser)
END_MESSAGE_MAP()
// CImportLibraryFromZip message handlers
void CImportLibraryFromZip::OnBnClickedCheckPassword()
{
// TODO: Add your control notification handler code here
if(m_chkIsPassword.GetCheck()==1)
{
m_txtPassword.EnableWindow(1);
}
else
{
m_txtPassword.EnableWindow(0);
}
}
void CImportLibraryFromZip::OnBnClickedOk()
{
m_txtDestDirectory.GetWindowText(m_StrDestDirectory);
if(m_StrDestDirectory.IsEmpty())
{
MessageBox(_T("Invalid dest directory"));
m_txtDestDirectory.SetFocus();
return;
}
m_txtZipFilePath.GetWindowTextW(m_StrZipFilePath);
CFileFind lFinder;
if (m_StrZipFilePath.IsEmpty() || lFinder.FindFile(m_StrZipFilePath) == FALSE)
{
MessageBox(_T("Invalid archive file path"));
m_txtZipFilePath.SetFocus();
return;
}
m_StrPassword.Empty();
if (m_chkIsPassword.GetCheck() != 0)
m_txtPassword.GetWindowText(m_StrPassword);
OnOK();
}
void CImportLibraryFromZip::OnBnClickedButtonBrowser()
{
LPCTSTR lpszTitle = _T( "Select the root folder for the browse dialog:" );
UINT uFlags = BIF_RETURNONLYFSDIRS | BIF_USENEWUI;
CFolderDialog dlgRoot( lpszTitle, m_StrDestDirectory, this, uFlags );
if( dlgRoot.DoModal() == IDOK )
{
m_StrDestDirectory = dlgRoot.GetFolderPath();
m_txtDestDirectory.SetWindowTextW(m_StrDestDirectory);
}
}
|
3740857fcc94d380c479013e3785cccca50b3231
|
c01879d0e8a206fd6e97cb9869da3f17ce998162
|
/hud/TFollow.cpp
|
d53a75f04eb3eb8b21fb6b291ce1092778b54686
|
[] |
no_license
|
Arisego/cocotd
|
4be49cdf26d3a91505f1d200f5e13f2095a33bee
|
f271c5f100472b1ecbb2c012070f6cf04e5d05ad
|
refs/heads/master
| 2021-05-27T13:38:24.006039
| 2014-08-16T03:36:10
| 2014-08-16T03:36:10
| null | 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 2,207
|
cpp
|
TFollow.cpp
|
#include "hud/TFollow.h"
TFollow* TFollow::create( CCNode *pFollowedNode, const CCRect& rect/* = CCRectZero*/, bool alock )
{
TFollow *pRet = new TFollow();
if (pRet && pRet->initWithTarget(pFollowedNode, rect))
{
pRet->autorelease();
pRet->mbLock = alock;
return pRet;
}
CC_SAFE_DELETE(pRet);
return NULL;
}
void TFollow::step( float dt )
{
CC_UNUSED_PARAM(dt);
if(mbLock) return;
//[D] CCLog(">[TFollow] step() || id:%d", miID);
CCPoint tmpposition;
if(m_bBoundarySet)
{
// whole map fits inside a single screen, no need to modify the position - unless map boundaries are increased
if(m_bBoundaryFullyCovered)
return;
CCPoint tempPos = ccpSub( m_obHalfScreenSize, m_pobFollowedNode->getPosition());
tmpposition = ccp(clampf(tempPos.x, m_fLeftBoundary, m_fRightBoundary),
clampf(tempPos.y, m_fBottomBoundary, m_fTopBoundary));
//m_pTarget->setPosition();
}
else
{
tmpposition = ccpSub(m_obHalfScreenSize, m_pobFollowedNode->getPosition());
}
CCPoint moveVect;
CCPoint oldPos = m_pTarget->getPosition();
double dist = ccpDistance(tmpposition, oldPos);
if (dist > 1){
moveVect = ccpMult(ccpSub(tmpposition,oldPos),0.05); //0.05 is the smooth constant.
oldPos = ccpAdd(oldPos, moveVect);
m_pTarget->setPosition(oldPos);
}
}
void TFollow::FactMove()
{
CCPoint tmpposition;
if(m_bBoundarySet)
{
// whole map fits inside a single screen, no need to modify the position - unless map boundaries are increased
if(m_bBoundaryFullyCovered)
return;
CCPoint tempPos = ccpSub(m_obHalfScreenSize, m_pobFollowedNode->getPosition());
tmpposition = ccp(clampf(tempPos.x, m_fLeftBoundary, m_fRightBoundary),
clampf(tempPos.y, m_fBottomBoundary, m_fTopBoundary));
//m_pTarget->setPosition();
}
else
{
tmpposition = ccpSub(m_obHalfScreenSize, m_pobFollowedNode->getPosition());
}
CCPoint moveVect;
CCPoint oldPos = m_pTarget->getPosition();
double dist = ccpDistance(tmpposition, oldPos);
if (dist > 1){
moveVect = ccpMult(ccpSub(tmpposition,oldPos),0.99); //0.05 is the smooth constant.
oldPos = ccpAdd(oldPos, moveVect);
m_pTarget->setPosition(oldPos);
}
}
bool TFollow::init()
{
mbLock = false;
miID = 0;
return true;
}
|
f738374505d9c86efae433489160278b5f8e831c
|
5cabb19260371b30e40c1189a5cd3650aeafd7b0
|
/src/SpanningTreeTests.cpp
|
029ce7ea18c404e05980c8c7d427a4e86ef5d0da
|
[] |
no_license
|
QuentinDuval/Algorithms-Tests
|
639e22d9a9bd984785a2c4ab8a591724377a1946
|
d05db1cef812aeecd2c641863c4327b03c29ff01
|
refs/heads/master
| 2020-12-24T14:01:04.993845
| 2015-03-15T12:30:25
| 2015-03-15T12:30:25
| 31,845,130
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 2,827
|
cpp
|
SpanningTreeTests.cpp
|
#include "GraphTests.h"
#include "SpanningTree.h"
#include "Graph.h"
#include "WeightedGraph.h"
#include "GraphTestUtils.h"
#include "utils/Algorithms.h"
#include "utils/TestUtils.h"
#include "utils/Timer.h"
#include <iostream>
namespace algorithm
{
static void graphTreeTests()
{
Graph g(6);
std::vector<Edge> inputs{ { 0, 1 }, { 0, 2 }, { 1, 2 }, { 3, 4 } };
for (auto& e : inputs)
g.addEdge(e);
SpanningTree spt(g);
assert(3 == spt.connectedComponentCount());
assert(2 == spt.edges(0).size());
assert(1 == spt.edges(1).size());
assert(0 == spt.edges(2).size());
}
static double sumWeights(double weight, WeightedEdge const& e)
{
return weight + e.weight();
};
template<typename PrimsAlgorithm>
static void primsTests(PrimsAlgorithm const& spt)
{
assert(3 == spt.connectedComponentCount());
assert(2 == spt.edges(0).size());
assert(2. == accumulate(spt.edges(0), 0., sumWeights));
assert(1 == spt.edges(1).size());
assert(0 == spt.edges(2).size());
}
static void weightedGraphTreeTests()
{
WeightedGraph g(6);
std::vector<WeightedEdge> inputs{ { 0, 1, 5. }, { 0, 2, 1. }, { 1, 2, 1. }, { 3, 4, 1. } };
for (auto& e : inputs)
g.addEdge(e);
LazyPrimMinimumSpanningTree spt(g);
primsTests(spt);
EagerPrimMinimumSpanningTree espt(g);
primsTests(espt);
KruskalMinimumSpanningTree kspt(g);
assert(3 == kspt.edges().size());
assert(3. == accumulate(kspt.edges(), 0., sumWeights));
}
void spanningTreeTests()
{
graphTreeTests();
weightedGraphTreeTests();
}
//--------------------------------------------------------------------------
void spanningTreePerfTests()
{
size_t dim = 1000;
WeightedGraph g = make2DRandomWeightedPlane(dim, true);
std::cout << std::endl << "[Minimum spanning tree] Lazy prim's algorithm on " << dim * dim << " nodes." << std::endl;
utils::showTime(std::cout, [&]{
LazyPrimMinimumSpanningTree spt(g);
assert(1 == spt.connectedComponentCount());
assert((dim * dim - 1) == spt.edges(0).size());
});
std::cout << std::endl << "[Minimum spanning tree] Eager prim's algorithm on " << dim * dim << " nodes." << std::endl;
utils::showTime(std::cout, [&]{
EagerPrimMinimumSpanningTree spt(g);
assert(1 == spt.connectedComponentCount());
assert((dim * dim - 1) == spt.edges(0).size());
});
std::cout << std::endl << "[Minimum spanning tree] Kruskal's algorithm on " << dim * dim << " nodes." << std::endl;
utils::showTime(std::cout, [&]{
KruskalMinimumSpanningTree spt(g);
assert((dim * dim - 1) == spt.edges().size());
});
}
}
|
2409d22b857c12021c737992e16a73a2f918d818
|
b539adfd732c68af2c436447351022832e025633
|
/HIT.cpp
|
419ab87e8f600b150adfcee87bb4854ad4c59cef
|
[] |
no_license
|
r4n4sh/IFQ
|
a5d8e96f3d04ec36ddd53c34181aa47971899758
|
cc12efe316fd3d655d62696963b27d673d582912
|
refs/heads/master
| 2020-03-26T15:12:45.760433
| 2018-10-01T07:53:55
| 2018-10-01T07:53:55
| 145,028,468
| 1
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 9,172
|
cpp
|
HIT.cpp
|
//
// HIT.cpp
//
//
// Created by Rana Shahout on 3/15/17.
//
//
#include <stdlib.h>
#include <stdio.h>
#include <math.h>
#include <iostream>
#include "HIT.hpp"
using namespace std;
static inline int computeBlockLevels(unsigned int n)
{
if (!n) return 1;
int clz = __builtin_ctz(n);
return clz + 1;
}
void HIT::populateIncTable(unsigned int itemIdx)
{
unordered_map<unsigned int, unsigned int>* foundedTable = incTable;
if(foundedTable->find(itemIdx) == foundedTable->end())
foundedTable->insert(pair<int, int> (itemIdx, 1));
else
foundedTable->at(itemIdx) = foundedTable->at(itemIdx) + 1;
incTable = foundedTable;
}
void HIT::populateSkipListLevels(unsigned int blockNumber)
{
/* Level >=1 */
for (int level = 1; level < computeBlockLevels(blockNumber); ++level) {
unsigned int block = levelToidx[level] + ((blockNumber) >> level);
unsigned int prevLevelBlock = levelToidx[level -1] + ((blockNumber) >> (level -1));
unsigned int prevBlock = levelToidx[level -1] + (((blockNumber) - (1 << (level - 1))) >> (level -1));
unordered_map<unsigned int, unsigned int>* prevLevelTable = skiplistMap[prevLevelBlock];
unordered_map<unsigned int, unsigned int>* prevBlockTable = skiplistMap[prevBlock];
unordered_map<unsigned int, unsigned int>* mergedblockTables = new unordered_map<unsigned int, unsigned int> (maxOverflows);
if ( prevBlockTable->empty()) {
if (prevLevelTable->empty()) {
continue;
}
for (auto it = prevLevelTable->begin(); it != prevLevelTable->end(); ++it) {
mergedblockTables->insert(pair<unsigned int, unsigned int>(it->first, it->second));
}
} else {
for (auto it = prevBlockTable->begin(); it != prevBlockTable->end(); ++it) {
mergedblockTables->insert(pair<unsigned int, unsigned int>(it->first, it->second));
}
if (!prevLevelTable->empty()) {
for (auto it = prevLevelTable->begin(); it != prevLevelTable->end(); ++it) {
if (mergedblockTables->find(it->first) != mergedblockTables->end()) {
int prevValue = mergedblockTables->find(it->first)->second;
mergedblockTables->at(it->first) = prevValue + it->second;
} else {
mergedblockTables->insert(pair<unsigned int, unsigned int>(it->first, it->second));
}
}
}
}
skiplistMap[block] = mergedblockTables;
}
}
HIT::HIT(unsigned int windowSize, float gamma, unsigned int m, float epsilon)
{
frameItems = 0;
overflowsNumber = 0;
tail = 0;
idx = 0;
indexTail = 0;
this->blockSize = ceil((windowSize * epsilon)/6.f); // W/k; k= 6/epsilon
this->windowSize = windowSize;
this->blocksNumber = windowSize / blockSize;
this->m = m;
this->epsilon = epsilon;
lastBlock = 1;
maxOverflows = min(blocksNumber * 2, windowSize);
indexSize = maxOverflows + blocksNumber;
head = maxOverflows - 1;
indexHead = blocksNumber - 1;
index = new vector<int> (indexSize); // 0 means end of block
overflowsElements = new unsigned int[maxOverflows];
rss = new RSS_CPP(epsilon/6., m, gamma);//y
totalOverflows = new unordered_map<unsigned int, unsigned int> (maxOverflows);//B TODO: allocate static?
/* Query Interval Section */
skiplistSize = 2*blocksNumber -1;
skiplistMap = new unordered_map<unsigned int, unsigned int>*[skiplistSize];
for(int i = 0 ; i < skiplistSize ; i++)
skiplistMap[i] = new unordered_map<unsigned int, unsigned int> (maxOverflows);
incTable = new unordered_map<unsigned int, unsigned int> (maxOverflows);
int levelToidxSize = ceil(log2(blocksNumber));
levelToidx = new unsigned int[levelToidxSize + 1];
for(int i = 0 ; i < levelToidxSize ; i++) {
levelToidx[i] = (2 * blocksNumber) - (blocksNumber * pow(2, 1-i));
}
}
HIT::~HIT()
{
delete[] levelToidx;
delete (incTable);
for (int i = 0; i < skiplistSize; i++)
delete(skiplistMap[i]);
delete[] skiplistMap;
delete(totalOverflows);
delete(rss);
delete [] overflowsElements;
delete(index);
}
int HIT::getIndexInskiplist(int blockNumber, int level)
{
return levelToidx[level] + ((blockNumber -1) >> level);
}
void HIT::endBlock(int blockNumber)
{
lastBlock = 1 + (lastBlock % (int) (blocksNumber + 1));
indexTail = (indexTail + 1) % indexSize;
indexHead = (indexHead + 1) % indexSize;
index->at(indexHead) = 0;
for (auto it = incTable->begin(); it != incTable->end(); ++it)
skiplistMap[blockNumber]->insert(pair<unsigned int, unsigned int>(it->first, it->second));
incTable->clear();
populateSkipListLevels(blockNumber);
}
void HIT::update(unsigned int item, int wieght)
{
++frameItems;
int blockNumber = ceil(((double)frameItems / (double)blockSize));
// Remove oldest element in oldest block
try {
if (index->at(indexTail)) {
int oldId = overflowsElements[tail];
if (!(totalOverflows->at(oldId) - 1))
totalOverflows->erase(oldId);
else
totalOverflows->insert(make_pair(oldId,totalOverflows->at(oldId) - 1));
tail = (tail + 1) % maxOverflows;
--overflowsNumber;
indexTail = (indexTail + 1) % indexSize;
}
} catch (const out_of_range) {
}
// Add item to RSS_CPP
this->rss->update(item, wieght);
// overflow
// printf("IS OVERFLOW? : %d\n", this->rss->query(item));
if ((this->rss->query(item)%blockSize) == 0) {
head = (head + 1) % maxOverflows;
overflowsElements[head] = item;
if (idToIDx.find(item) == idToIDx.end()) {
idToIDx.insert(pair<unsigned int, unsigned int> (item, idx));
++idx;
}
++overflowsNumber;
assert(overflowsNumber <= maxOverflows);
indexHead = (indexHead + 1) % indexSize;
index->at(indexHead) = 1;
if (totalOverflows->find(item) == totalOverflows->end())
totalOverflows->insert(make_pair<unsigned int, unsigned int>((unsigned int)item,1));
else
totalOverflows->at(item) = totalOverflows->at(item) + 1;
populateIncTable(idToIDx.at(item));
}
/* Last frame in the current block */
/* NEW BLOCK */
if ((frameItems % blockSize) == 0) {
endBlock(blockNumber);
}
// New frame
if (frameItems == windowSize) {
frameItems = 0;
rss->clear();
}
}
double HIT::query(unsigned int item)
{
int minOverFlows;
double rssEstimation = this->rss->query(item);
unordered_map<unsigned int,unsigned int>::const_iterator foundedItem = totalOverflows->find(item);
if (foundedItem == totalOverflows->end()) // item has no oveflows
minOverFlows = 0;
else {
minOverFlows = totalOverflows->at(item);
//rssEstimation = (int) rssEstimation % (int) this->blockSize;//TODO
}
rssEstimation = (int) rssEstimation % (int) this->blockSize; //TODO
return (this->blockSize * (minOverFlows + 2 ) + rssEstimation);
}
unsigned int HIT::partialIntervalQuery(unsigned int itemIdx, unsigned int b2, unsigned int b1)
{
int b = b1;
unsigned int count = 0;
int d = 1 + (b1 - b2) % (blocksNumber + 1);
while (d > 0) {
int level = min((computeBlockLevels(b) - 1), (int)floor(log2(d)));
unsigned int block;
if (b <= 0)
block = levelToidx[level];
else
block = levelToidx[level] + ((b) >> level);
unordered_map<unsigned int, unsigned int>* foundedTable = skiplistMap[block];
if(skiplistMap[block]->find(itemIdx) != skiplistMap[block]->end()) {
count += skiplistMap[block]->at(itemIdx);
}
int power_level = 1 << level;
d = d - power_level;
b = b - power_level;
if (b <= 0)
b = blocksNumber;
}
return count;
}
double HIT::intervalQuery(unsigned int item, int i, int j)
{
int first = ((int)(lastBlock - i) % (int) (blocksNumber+1));
int last = ((int)(lastBlock - j) % (int) (blocksNumber+1));
unsigned int minOverFlows = 0;
int itemIdx;
unordered_map<unsigned int,unsigned int>::const_iterator foundedItem = idToIDx.find(item);
if (foundedItem == idToIDx.end()) // item has no overflows
minOverFlows = 0;
else {
itemIdx = idToIDx.at(item);
minOverFlows = partialIntervalQuery(itemIdx, last, first);
}
return minOverFlows;
//return block_size * (minOverFlows + 2);
}
double HIT::intervalFrequencyQuery(unsigned int item, int i, int j)
{
return blockSize *(intervalQuery(item, ceil(i/blockSize), floor(j/blockSize)) + 2);
// return blockSize *(intervalQuery(item, 0, floor(j/blockSize)) + 2);
}
double HIT::intervalQueryTest(unsigned int item, int i, int j)
{
unsigned int minOverFlows = 0;
int itemIdx;
unordered_map<unsigned int,unsigned int>::const_iterator foundedItem = idToIDx.find(item);
if (foundedItem == idToIDx.end()) // item has no overflows
minOverFlows = 0;
else {
itemIdx = idToIDx.at(item);
minOverFlows = partialIntervalQuery(itemIdx, i, j);
}
return blockSize * (minOverFlows + 2);
}
|
4bfd454b032bc4ed747100a7cdb7038c83b5ae5e
|
6c8b19bef62a8c5cdded566b564ae82eed60ee6b
|
/src/game/game_base.cpp
|
e7056f871780643402e64dc9a774c9b746de7553
|
[
"MIT"
] |
permissive
|
zhongjn/Maestro
|
d98ca44eb822f5bbb29c4dfbc61a43e1fd8e7e41
|
a57bd508586f787c66ac1cbebaa821b0ef10e0d0
|
refs/heads/master
| 2020-06-19T17:27:53.497535
| 2019-08-26T08:50:00
| 2019-08-26T08:50:00
| 196,800,561
| 0
| 0
|
MIT
| 2019-08-26T08:50:02
| 2019-07-14T06:08:12
|
C++
|
UTF-8
|
C++
| false
| false
| 35
|
cpp
|
game_base.cpp
|
#include <maestro/game/game_base.h>
|
7986d7edc60cd36af56469eaca71516bfac9b34a
|
868e8628acaa0bf276134f9cc3ced379679eab10
|
/firstCrude2D/we123/h10_refined/0.068/p_rgh
|
8e39a827da6ae29fd4dbb10d362519a5052f9774
|
[] |
no_license
|
stigmn/droplet
|
921af6851f88c0acf8b1cd84f5e2903f1d0cb87a
|
1649ceb0a9ce5abb243fb77569211558c2f0dc96
|
refs/heads/master
| 2020-04-04T20:08:37.912624
| 2015-11-25T11:20:32
| 2015-11-25T11:20:32
| 45,102,907
| 0
| 0
| null | 2015-10-28T09:46:30
| 2015-10-28T09:46:29
| null |
UTF-8
|
C++
| false
| false
| 139,944
|
p_rgh
|
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: 2.4.0 |
| \\ / A nd | Web: www.OpenFOAM.org |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class volScalarField;
location "0.068";
object p_rgh;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
dimensions [1 -1 -2 0 0 0 0];
internalField nonuniform List<scalar>
14400
(
107.852
111.345
116.779
119.183
117.892
115.531
112.982
110.45
108.145
106.289
104.977
104.089
103.453
103.034
102.922
103.197
103.857
104.822
105.962
107.148
108.278
109.287
110.14
110.831
111.368
111.767
112.05
112.236
112.345
112.394
107.828
111.337
116.795
119.207
117.9
115.533
112.98
110.441
108.127
106.264
104.95
104.062
103.423
102.999
102.883
103.156
103.821
104.794
105.947
107.148
108.292
109.313
110.175
110.874
111.415
111.818
112.103
112.291
112.401
112.45
107.783
111.316
116.828
119.258
117.918
115.539
112.98
110.428
108.097
106.218
104.897
104.01
103.367
102.932
102.803
103.07
103.737
104.721
105.889
107.109
108.272
109.308
110.183
110.89
111.438
111.845
112.133
112.322
112.433
112.483
107.716
111.28
116.879
119.339
117.945
115.549
112.982
110.413
108.054
106.149
104.819
103.932
103.282
102.83
102.684
102.941
103.61
104.608
105.799
107.043
108.227
109.281
110.168
110.882
111.434
111.843
112.131
112.32
112.431
112.48
107.629
111.229
116.948
119.448
117.981
115.563
112.987
110.395
107.997
106.057
104.714
103.829
103.17
102.693
102.521
102.763
103.435
104.452
105.67
106.943
108.154
109.228
110.129
110.851
111.406
111.816
112.104
112.292
112.402
112.451
107.519
111.164
117.036
119.588
118.026
115.582
112.995
110.374
107.927
105.941
104.581
103.701
103.03
102.52
102.314
102.533
103.206
104.245
105.496
106.804
108.047
109.145
110.062
110.794
111.353
111.765
112.052
112.24
112.349
112.398
107.388
111.082
117.142
119.76
118.078
115.605
113.006
110.351
107.844
105.801
104.421
103.548
102.862
102.31
102.059
102.248
102.919
103.982
105.271
106.62
107.901
109.027
109.963
110.706
111.271
111.685
111.973
112.16
112.269
112.317
107.236
110.984
117.269
119.964
118.137
115.631
113.021
110.327
107.746
105.635
104.233
103.37
102.666
102.062
101.754
101.9
102.564
103.656
104.988
106.385
107.709
108.87
109.829
110.584
111.156
111.572
111.861
112.048
112.156
112.204
107.061
110.867
117.415
120.204
118.202
115.661
113.039
110.301
107.635
105.441
104.014
103.169
102.443
101.772
101.395
101.484
102.134
103.258
104.637
106.088
107.465
108.667
109.653
110.424
111.003
111.422
111.711
111.897
112.005
112.053
106.865
110.732
117.584
120.48
118.27
115.694
113.062
110.275
107.509
105.219
103.765
102.945
102.192
101.44
100.978
100.992
101.617
102.778
104.205
105.718
107.159
108.411
109.429
110.218
110.807
111.228
111.517
111.702
111.81
111.857
106.646
110.575
117.774
120.795
118.34
115.73
113.089
110.248
107.369
104.965
103.484
102.7
101.915
101.063
100.497
100.411
100.997
102.2
103.673
105.257
106.777
108.092
109.149
109.961
110.559
110.983
111.272
111.456
111.56
111.605
106.405
110.397
117.987
121.153
118.41
115.769
113.122
110.223
107.212
104.677
103.169
102.436
101.613
100.638
99.9445
99.7291
100.255
101.508
103.014
104.682
106.304
107.698
108.805
109.644
110.253
110.681
110.967
111.146
111.248
111.293
106.142
110.195
118.223
121.556
118.478
115.81
113.16
110.2
107.039
104.355
102.819
102.156
101.285
100.16
99.3127
98.9251
99.3684
100.681
102.19
103.959
105.719
107.217
108.385
109.258
109.885
110.312
110.593
110.766
110.862
110.905
105.856
109.966
118.483
122.007
118.54
115.853
113.204
110.181
106.85
103.996
102.432
101.862
100.933
99.6254
98.5931
97.9757
98.3078
99.688
101.14
103.041
105
106.63
107.88
108.8
109.44
109.869
110.143
110.307
110.392
110.425
105.548
109.71
118.766
122.511
118.592
115.897
113.255
110.166
106.642
103.593
102.005
101.559
100.558
99.0288
97.7852
96.8621
97.0414
98.4575
99.7745
101.861
104.119
105.92
107.277
108.261
108.926
109.345
109.598
109.742
109.822
109.857
105.218
109.423
119.071
123.072
118.632
115.943
113.314
110.158
106.414
103.141
101.534
101.25
100.159
98.3617
96.891
95.627
95.5655
96.8143
97.95
100.335
103.057
105.068
106.579
107.641
108.32
108.733
108.959
109.073
109.125
109.15
104.866
109.103
119.398
123.692
118.655
115.991
113.38
110.159
106.166
102.635
101.015
100.939
99.7307
97.617
95.9005
94.3359
93.918
94.3819
95.473
98.3743
101.801
104.078
105.786
106.926
107.637
108.031
108.22
108.29
108.295
108.285
104.491
108.748
119.743
124.375
118.655
116.039
113.455
110.173
105.896
102.065
100.44
100.63
99.265
96.7851
94.8337
92.9802
91.8328
91.8105
92.5464
95.9809
100.213
102.8
104.85
106.143
106.89
107.213
107.32
107.33
107.302
107.279
104.095
108.355
120.099
125.123
118.627
116.088
113.539
110.201
105.603
101.423
99.7998
100.326
98.7432
95.8363
93.5877
91.4613
89.353
89.1001
88.4345
92.8544
98.2672
101.46
103.869
105.283
106.044
106.29
106.287
106.185
106.111
106.08
103.678
107.922
120.458
125.933
118.566
116.138
113.631
110.247
105.283
100.696
99.0785
100.03
98.1348
94.7373
92.3085
90.3464
85.5917
82.9513
80.7296
86.5881
94.8715
99.4631
102.694
104.457
105.208
105.342
105.143
104.84
104.647
104.568
103.24
107.446
120.802
126.801
118.464
116.19
113.733
110.316
104.936
99.8668
98.2583
99.7434
97.4169
93.3713
90.9678
88.8279
82.6431
75.0421
71.5736
78.8939
88.9433
96.9805
101.41
103.604
104.336
104.304
103.822
103.225
102.819
102.651
102.782
106.926
121.106
127.716
118.317
116.244
113.844
110.414
104.559
98.9143
97.3185
99.4616
96.6039
91.6059
89.7586
86.3393
79.5768
69.6515
64.9347
74.375
84.5744
94.6512
100.069
102.453
103.156
102.937
102.174
101.249
100.556
100.23
102.305
106.36
121.333
128.655
118.116
116.302
113.963
110.545
104.153
97.8214
96.2409
99.1751
95.5896
89.9852
88.4646
83.7304
77.3007
62.8156
57.4692
73.2988
84.4821
93.2389
98.399
100.726
101.56
101.106
100.051
98.8502
97.8813
97.3391
101.809
105.747
121.426
129.58
117.855
116.365
114.088
110.716
103.721
96.6102
95.0812
98.8438
94.2258
88.1926
85.8992
81.7628
76.032
1.56116
0.684087
59.7578
85.1381
92.87
97.0743
99.1293
99.9398
99.3355
97.9176
96.2321
94.7267
93.8225
101.297
105.088
121.308
130.427
117.529
116.437
114.217
110.937
103.274
95.3275
94.1444
98.426
92.5859
86.1332
84.3899
63.2928
0.0055918
0.0733021
0.141805
0.27299
82.3664
93.5622
96.8003
98.2934
98.6972
98.2428
96.4131
93.5839
90.771
89.0136
100.769
104.384
120.871
131.095
117.134
116.52
114.346
111.214
102.831
93.785
93.5935
98.1495
90.8024
84.1613
29.1349
-0.0333789
-0.000599104
0.0466449
0.0893206
0.0724733
0.438121
89.7427
98.6469
97.7684
97.2977
97.4846
95.8373
91.2547
85.6892
81.8111
100.227
103.639
119.967
131.439
116.665
116.62
114.47
111.555
102.432
91.6488
92.4086
98.9399
89.2634
6.80124
0.0662047
-0.0180942
-0.0288581
-0.00382992
0.027289
-0.00448087
-0.0564151
0.136667
33.3849
77.9731
87.1536
90.8723
85.5183
70.0653
51.6621
41.1799
99.6738
102.859
118.405
131.252
116.125
116.742
114.582
111.962
102.169
88.8162
90.9005
100.207
9.72766
0.0577309
0.0546814
-0.0129167
-0.0495881
-0.0458752
-0.0235889
-0.0695247
-0.0884121
-0.0827309
0.0359741
0.166002
0.297304
0.326242
0.238642
0.199174
0.19918
0.193995
99.1127
102.052
115.93
130.252
115.514
116.89
114.674
112.428
102.208
85.8054
82.9762
39.2875
0.0175263
0.0520094
0.0419469
-0.0091259
-0.0568595
-0.0625409
-0.0523589
-0.104099
-0.0945133
-0.0710276
-0.0442843
-0.0265588
0.00590195
0.0377614
0.0640803
0.0849718
0.100028
0.107017
98.5733
101.229
112.216
128.062
114.837
117.072
114.733
112.938
102.878
82.3304
0.145012
-0.239935
0.0217478
0.0635086
0.0327364
-0.014924
-0.0602856
-0.0630083
-0.06574
-0.113143
-0.0997058
-0.0709877
-0.0475503
-0.0252005
0.00186922
0.0308634
0.0545858
0.0725191
0.0837218
0.0893246
112.397
112.358
112.265
112.101
111.85
111.49
111.002
110.365
109.568
108.608
107.507
106.312
105.11
104.019
103.173
102.677
102.569
102.785
103.195
103.718
104.419
105.401
106.587
107.679
108.273
108.011
106.769
104.833
102.867
101.399
112.453
112.414
112.32
112.156
111.902
111.54
111.047
110.404
109.598
108.628
107.513
106.304
105.088
103.986
103.133
102.638
102.533
102.755
103.169
103.693
104.395
105.384
106.579
107.679
108.278
108.017
106.774
104.835
102.866
101.397
112.486
112.446
112.352
112.186
111.93
111.564
111.066
110.416
109.599
108.615
107.483
106.255
105.021
103.906
103.048
102.556
102.463
102.698
103.122
103.647
104.353
105.354
106.568
107.685
108.293
108.033
106.783
104.834
102.861
101.389
112.483
112.444
112.349
112.183
111.927
111.56
111.059
110.403
109.577
108.578
107.426
106.174
104.918
103.785
102.919
102.432
102.356
102.613
103.052
103.579
104.289
105.312
106.555
107.699
108.32
108.058
106.797
104.832
102.852
101.374
112.454
112.415
112.32
112.155
111.9
111.532
111.029
110.367
109.53
108.513
107.337
106.057
104.771
103.615
102.741
102.264
102.213
102.5
102.959
103.489
104.204
105.256
106.541
107.72
108.357
108.092
106.814
104.829
102.838
101.354
112.4
112.361
112.267
112.103
111.848
111.479
110.973
110.304
109.453
108.416
107.211
105.897
104.577
103.393
102.51
102.046
102.03
102.359
102.844
103.376
104.098
105.186
106.525
107.748
108.406
108.136
106.836
104.823
102.819
101.326
112.319
112.28
112.187
112.023
111.767
111.397
110.887
110.209
109.343
108.281
107.042
105.688
104.327
103.112
102.221
101.777
101.805
102.187
102.708
103.24
103.968
105.102
106.507
107.786
108.466
108.189
106.862
104.815
102.796
101.293
112.206
112.167
112.074
111.91
111.654
111.282
110.767
110.079
109.195
108.104
106.825
105.423
104.017
102.764
101.868
101.45
101.537
101.986
102.549
103.081
103.815
105.003
106.489
107.831
108.538
108.252
106.892
104.805
102.768
101.253
112.055
112.016
111.923
111.759
111.503
111.13
110.609
109.909
109.004
107.878
106.55
105.092
103.635
102.34
101.443
101.061
101.221
101.754
102.371
102.897
103.636
104.889
106.469
107.886
108.622
108.325
106.926
104.792
102.735
101.206
111.86
111.82
111.727
111.564
111.309
110.934
110.407
109.693
108.762
107.594
106.207
104.683
103.17
101.828
100.936
100.602
100.855
101.489
102.172
102.69
103.43
104.758
106.448
107.95
108.72
108.408
106.965
104.777
102.698
101.152
111.606
111.569
111.48
111.318
111.064
110.687
110.154
109.424
108.461
107.241
105.78
104.177
102.606
101.216
100.336
100.067
100.433
101.192
101.955
102.458
103.194
104.61
106.425
108.025
108.83
108.501
107.008
104.759
102.655
101.092
111.295
111.257
111.168
111.011
110.76
110.383
109.843
109.093
108.091
106.807
105.25
103.548
101.921
100.482
99.6297
99.4501
99.9524
100.859
101.721
102.201
102.927
104.44
106.403
108.111
108.954
108.605
107.055
104.737
102.607
101.024
110.906
110.87
110.786
110.635
110.39
110.017
109.467
108.691
107.642
106.277
104.591
102.761
101.082
99.6108
98.8037
98.7483
99.4089
100.49
101.473
101.919
102.625
104.243
106.38
108.209
109.093
108.72
107.106
104.712
102.554
100.949
110.425
110.395
110.322
110.182
109.945
109.575
109.018
108.215
107.096
105.629
103.768
101.763
100.035
98.5858
97.8396
97.9585
98.7982
100.081
101.211
101.613
102.284
104.022
106.357
108.321
109.246
108.845
107.162
104.682
102.495
100.867
109.858
109.827
109.754
109.628
109.414
109.061
108.496
107.65
106.441
104.843
102.741
100.479
98.6858
97.3967
96.7032
97.0801
98.1155
99.6302
100.94
101.283
101.901
103.773
106.336
108.446
109.415
108.982
107.222
104.648
102.43
100.778
109.149
109.125
109.073
108.978
108.794
108.458
107.89
107.001
105.669
103.909
101.47
98.7813
96.8489
95.9289
95.379
96.1137
97.3539
99.134
100.661
100.933
101.468
103.493
106.317
108.588
109.601
109.13
107.286
104.608
102.36
100.681
108.279
108.276
108.271
108.223
108.084
107.772
107.203
106.261
104.79
102.802
99.9261
96.4982
94.2996
93.9571
93.8138
94.9908
96.5074
98.5889
100.376
100.567
100.98
103.177
106.301
108.746
109.803
109.29
107.355
104.562
102.283
100.576
107.273
107.28
107.299
107.3
107.23
107.008
106.46
105.407
103.706
101.361
98.0761
93.6603
91.704
91.7577
91.9812
93.6209
95.5472
97.9925
100.087
100.193
100.429
102.819
106.291
108.924
110.024
109.463
107.428
104.51
102.2
100.464
106.074
106.09
106.134
106.218
106.273
106.142
105.626
104.492
102.553
99.6878
95.6517
89.5591
88.5445
89.3397
89.9223
92.189
94.4923
97.3446
99.7881
99.8171
99.8047
102.414
106.288
109.122
110.263
109.647
107.506
104.45
102.11
100.344
104.555
104.604
104.734
104.988
105.26
105.273
104.839
103.527
101.038
97.0886
90.7842
81.9365
81.011
84.9198
87.9226
90.8382
93.2469
96.6506
99.4587
99.4483
99.0927
101.952
106.295
109.342
110.522
109.844
107.588
104.382
102.013
100.217
102.626
102.732
103.017
103.547
104.125
104.372
104.029
102.488
99.2444
93.0252
83.5256
73.7989
71.6248
79.0072
85.6829
89.5731
91.8973
95.9008
99.052
99.089
98.2743
101.422
106.316
109.588
110.802
110.054
107.674
104.304
101.909
100.082
100.184
100.389
100.908
101.777
102.676
103.181
102.9
101.306
97.4651
89.8234
78.5252
69.2072
64.0772
75.0334
82.3156
88.653
90.6871
95.0547
98.4794
98.7252
97.3226
100.81
106.357
109.86
111.103
110.276
107.764
104.216
101.798
99.9418
97.2511
97.5886
98.4062
99.5533
100.767
101.577
101.393
99.6732
95.5508
88.6983
78.5749
67.2469
44.8927
72.0493
78.9418
87.0844
89.137
93.8084
97.5855
98.3103
96.2044
100.101
106.424
110.161
111.428
110.512
107.859
104.115
101.68
99.7956
93.6674
94.2495
95.5458
97.2448
98.9101
100.056
100.072
98.1592
94.789
88.5846
75.8416
13.2676
0.206679
25.8712
77.8728
84.6462
88.0134
92.1126
96.1131
97.7988
94.9539
99.2683
106.526
110.493
111.776
110.76
107.958
104.001
101.554
99.6451
88.6812
89.7856
92.2575
95.267
97.787
99.0995
99.3277
97.9998
95.3139
87.9844
16.7599
0.140643
0.163678
0.0272584
8.00877
82.733
86.9038
90.3037
93.8157
97.224
93.8181
98.2793
106.676
110.858
112.15
111.02
108.061
103.872
101.421
99.4921
81.0683
83.5065
88.6489
94.1007
97.4345
97.8627
99.2726
98.8507
98.3973
26.2846
0.042329
0.0748896
0.0874528
0.000234292
-0.0361425
0.757638
80.491
87.7971
90.6773
97.0387
92.9831
97.0642
106.887
111.256
112.551
111.293
108.168
103.725
101.282
99.3388
39.4166
46.3801
62.3428
81.1212
92.8926
92.23
91.8634
65.3642
10.7826
-0.0821179
-0.0261125
-0.00159836
-0.0159053
-0.0573928
-0.0399595
0.0827995
0.127989
75.787
86.3174
97.9235
91.664
95.4617
107.173
111.687
112.981
111.576
108.278
103.559
101.137
99.1884
0.197941
0.212269
0.229786
0.235757
0.329761
0.342751
0.393291
-0.00695025
-0.060292
-0.134194
-0.0937662
-0.0757937
-0.0911407
-0.097729
-0.035279
0.0635069
0.125402
0.135356
61.4448
99.3181
89.1589
93.2975
107.551
112.149
113.441
111.87
108.393
103.371
100.987
99.0447
0.108773
0.105281
0.0951511
0.0774773
0.0544908
0.021075
-0.0208005
-0.0700256
-0.0969922
-0.136584
-0.138003
-0.121264
-0.12237
-0.102427
-0.0180383
0.062313
0.121273
0.152396
0.542597
90.8402
87.2937
90.5512
108.076
112.635
113.935
112.173
108.51
103.159
100.834
98.9127
0.090567
0.087705
0.0801219
0.0660695
0.0443937
0.014249
-0.0225934
-0.0626451
-0.0998777
-0.143025
-0.158883
-0.142423
-0.126231
-0.106499
-0.0353367
0.0443505
0.170192
0.162308
0.504703
-0.232585
35.0587
87.0811
108.827
113.138
114.466
112.484
108.63
102.92
100.678
98.7998
26.2479
100.517
107.556
124.736
114.188
117.263
114.741
113.392
104.54
-1.40708
0.128024
-0.184553
0.0232354
0.0447696
0.0276027
-0.0142633
-0.0542928
-0.058181
-0.0690039
-0.108499
-0.0975769
-0.0696275
-0.0461531
-0.0275123
-0.00203917
0.0252639
0.0483128
0.0643286
0.0739392
0.0788755
0.0733229
61.2804
103.92
123.37
113.782
117.391
114.722
113.646
105.739
5.94203
0.10369
-0.157423
0.53328
0.0442129
0.0253838
-0.0125019
-0.0493158
-0.0548191
-0.0685744
-0.102315
-0.0927051
-0.0675003
-0.0479125
-0.0313156
-0.00713435
0.0194518
0.0421548
0.0579544
0.0675187
0.0724156
0.720352
5.76237
30.9213
103.25
113.32
117.544
114.675
113.898
108.587
0.0838663
0.115996
0.197132
0.106302
0.044037
0.0237273
-0.0104868
-0.0436606
-0.0511536
-0.0666857
-0.0945622
-0.085744
-0.0646067
-0.0495737
-0.035764
-0.0135574
0.0116333
0.0339589
0.0501554
0.0602003
0.0653352
-0.057271
0.00153582
30.0928
96.5088
112.991
117.719
114.552
114.142
111.823
0.0197152
0.102169
0.319662
0.100336
0.0406453
0.0212032
-0.00763126
-0.0376891
-0.0471637
-0.0634497
-0.0861927
-0.0771117
-0.0608066
-0.0508695
-0.0405492
-0.0206764
0.00290953
0.0248805
0.0415648
0.0521492
0.0575209
0.287376
-0.00767368
1.57815
62.1121
112.748
118.102
114.87
114.345
40.305
0.111399
0.0721565
0.325497
0.0831632
0.0371866
0.0194279
-0.00465969
-0.0316991
-0.0428435
-0.0590608
-0.0762243
-0.0670271
-0.0564957
-0.0524184
-0.045548
-0.0275522
-0.00565541
0.0156438
0.0324437
0.0432888
0.0487281
0.0301935
-0.0994332
-0.0787547
11.9334
108.875
118.125
114.646
114.17
2.7175
0.0882374
0.0355793
0.058386
0.0668962
0.0323165
0.0190388
-0.00213662
-0.025982
-0.0382083
-0.0536203
-0.0692903
-0.0412105
-0.0397811
-0.0487958
-0.050384
-0.0337448
-0.0135767
0.00664172
0.0231443
0.0339206
0.0392367
0.0129356
-0.109169
-0.0777753
-0.0471497
82.7416
118.282
113.892
84.2861
-0.210591
0.0688619
-0.00544319
0.0164877
0.0471611
0.0259544
0.0195552
0.000205362
-0.0208977
-0.0333201
-0.0470396
-0.0595489
-0.0535292
-0.0336586
-0.0205784
-0.0407978
-0.0381119
-0.0201575
-0.00130369
0.0143881
0.0247318
0.029835
0.00875558
-0.112829
-0.0831852
-0.0715031
10.3994
113.893
66.4418
0.00884109
-0.162271
0.0497978
-0.0234458
-0.0405083
0.0253331
0.0180747
0.0243838
0.000824671
-0.016639
-0.0282619
-0.0402208
-0.0496046
-0.0480991
-0.044104
-0.0421215
-0.0472367
-0.0394887
-0.0242796
-0.00716851
0.00734353
0.0169471
0.0216662
0.00886636
-0.108577
-0.0879047
-0.0758238
0.0700959
7.71025
0.00241183
0.00357496
-0.126339
0.0367619
-0.0363467
-0.0513353
0.00282415
0.0455987
0.0147812
0.000636339
-0.0132031
-0.0231116
-0.0327041
-0.0396745
-0.0400037
-0.0390173
-0.0404708
-0.043911
-0.0380524
-0.0249967
-0.00970725
0.00327275
0.0119201
0.0161266
-0.00113011
-0.120446
-0.0815723
-0.0761122
0.0535771
-0.00316134
-0.0043771
-0.00630215
-0.095595
0.0276501
0.149956
-0.0600351
-0.0204801
0.0527614
0.00296629
-0.000144953
-0.0105949
-0.0179653
-0.0248185
-0.0299563
-0.0302612
-0.031593
-0.035586
-0.0378523
-0.0327935
-0.0214629
-0.00814255
0.00323372
0.0107698
0.0144419
-0.0012309
-0.12477
-0.0567839
-0.0714883
0.0420673
-0.00368569
-0.00726884
-0.0116038
-0.0704316
0.0215769
-0.0165544
-0.0911851
-0.0470797
0.0345078
-0.00661461
-0.0020457
-0.00900458
-0.0129738
-0.0165811
-0.0201695
-0.0222314
-0.0233733
-0.0269121
-0.0281373
-0.0232046
-0.0133721
-0.00198625
0.00766335
0.0140619
0.0172163
0.00154954
-0.115942
-0.0996443
-0.0708311
0.0318282
-0.00446948
-0.0128529
-0.0133397
-0.050192
0.0166224
-0.00639011
-0.106385
-0.0540914
0.00759312
-0.00982037
-0.00541402
-0.00898069
-0.00848784
-0.00799561
-0.010265
-0.0123026
-0.0141209
-0.0150104
-0.0154169
-0.0103294
-0.00177565
0.00781958
0.0159255
0.0212862
0.0239799
-0.00246442
-0.039611
-0.0967538
-0.069304
0.0225512
-0.00478004
-0.013655
-0.0124043
-0.0336383
0.012992
-0.00271793
-0.0745062
-0.0302541
-0.00617535
-0.0235736
-0.01031
-0.0115532
-0.00538911
0.000641031
-0.000597084
-0.00230712
-0.00364519
-0.00307449
-0.000514598
0.00374421
0.010985
0.0190231
0.0258437
0.0304756
0.0329056
-0.00271007
-0.0222584
-0.0725985
-0.0639185
0.0144622
-0.00498301
-0.0131925
-0.0104564
-0.0206326
0.0112112
-0.00454171
-0.053715
-0.0186946
-0.0243638
-0.033222
-0.0176815
-0.0150505
0.00537871
0.00977556
0.00755752
0.00640965
0.00564055
0.00678866
0.0108375
0.0174096
0.0232997
0.0293921
0.0350753
0.0390897
0.0412803
-0.0031093
0.0164183
-0.105337
-0.058126
0.00755262
-0.00495859
-0.0117841
-0.00827867
-0.0109674
0.0104696
-0.00384952
-0.0461639
-0.0387916
-0.075995
-0.0417865
-0.0269552
-0.0110595
0.178517
0.109586
0.0165304
0.0122501
0.01134
0.0133846
0.0176699
0.0234192
0.0298987
0.0359342
0.0411278
0.0446699
0.0465457
-0.00320316
-0.0596996
-0.0939598
-0.0526721
0.0017179
-0.00487809
-0.00978536
-0.00614451
-0.00438069
0.0104633
-0.00189243
0.0221574
-0.0510245
-0.0955581
-0.0543817
-0.0378673
-0.0222361
-0.0197081
0.0730264
0.116042
0.0121717
0.0108816
0.0150849
0.0206899
0.0268498
0.0328963
0.0381773
0.0423123
0.0452113
0.0469557
-0.00330202
-0.0527304
-0.0869966
-0.0473652
-0.00285592
-0.004857
-0.00767955
-0.00412159
0.000786758
0.011108
0.00250851
-0.0375529
-0.0829452
-0.089006
-0.0712683
-0.0397766
-0.0325676
-0.0185243
-0.000432579
0.120068
0.104006
0.00232511
0.0127813
0.0205675
0.0272525
0.0329947
0.0376645
0.0411875
0.0436088
0.0450501
-0.00339819
-0.0458389
-0.0747383
-0.042318
-0.00627566
-0.00491681
-0.0057464
-0.00218814
0.00437693
0.0124389
0.00777402
-0.0243066
-0.0721458
-0.0904214
-0.0854679
-0.033761
-0.0403993
-0.0239134
-0.0131874
0.11219
0.113306
-0.00275489
0.0111351
0.0202063
0.0268858
0.0320646
0.0360097
0.0388598
0.0407631
0.0418791
-0.00344692
-0.0402178
-0.0640821
-0.0376077
-0.0086955
-0.00501691
-0.00409902
-0.00033446
0.00689807
0.0144556
0.014329
-0.000456557
-0.0502059
-0.0929907
-0.0603335
-0.018372
-0.0493147
-0.0272605
-0.017399
-0.0132984
-0.00853832
0.00454191
0.0146684
0.0217912
0.0271954
0.0312619
0.0342618
0.0363741
0.0377569
0.0385471
-0.00342893
-0.0354529
-0.0548522
-0.0332447
-0.0102702
-0.00509296
-0.00274875
0.00141073
0.00874467
0.0168777
0.0214545
0.0168724
-0.0275774
-0.0809753
-0.0698993
-0.0550494
-0.0470348
-0.0239122
-0.0119677
-0.00412293
0.00424109
0.0126938
0.0190346
0.023907
0.0276583
0.0305068
0.0325966
0.0340518
0.0349881
0.0355025
-0.00333745
-0.0312025
-0.0467553
-0.029226
-0.0111383
-0.00509298
-0.00167528
0.00291372
0.0102373
0.0190442
0.026749
0.0305867
-0.00853889
-0.0853574
-0.0509961
-0.0733979
-0.040101
-0.0184497
-0.00531458
0.003564
0.0108349
0.0170255
0.0214896
0.0248234
0.0273444
0.0292112
0.0305325
0.0314074
0.0319287
0.032177
-0.00318071
-0.0272847
-0.0395988
-0.0255571
-0.0114131
-0.0049866
-0.000846396
0.00409852
0.0113263
0.0201699
0.0287861
0.0381359
-0.000384011
-0.0710178
-0.0874798
-0.0558415
-0.0320526
-0.0126267
-0.000498722
0.0076379
0.0136715
0.0182142
0.021486
0.0238539
0.0255736
0.0268091
0.0276781
0.0282642
0.028622
0.0287876
-0.00299383
-0.0235979
-0.0332401
-0.0222441
-0.0111848
-0.00476832
-0.000235618
0.00488846
0.0117862
0.0199306
0.0276554
0.0322292
0.0109669
-0.0460628
-0.0544181
-0.0407864
-0.0213669
-0.00777377
0.0016801
0.00838442
0.0132634
0.0168302
0.0193974
0.0212272
0.0225241
0.0234407
0.0240923
0.0245596
0.0248833
0.0250648
-0.00284121
-0.0200919
-0.0275679
-0.0192342
-0.0105361
-0.00444832
0.00017823
0.00522903
0.011514
0.0184414
0.0243221
0.0252054
0.0141843
-0.01083
-0.0274096
-0.0222978
-0.0125079
-0.0039578
0.00264774
0.00767403
0.0114548
0.0142664
0.0163282
0.0178177
0.0188746
0.0196023
0.0200819
0.0203832
0.0205624
0.0206528
-0.00257216
-0.0167546
-0.0224922
-0.0163969
-0.0095502
-0.00404105
0.000408335
0.00512568
0.0105743
0.0160613
0.0199599
0.0194098
0.0105993
-0.00408008
-0.0112515
-0.0104815
-0.00615085
-0.00119164
0.00309422
0.00660881
0.00936728
0.0114761
0.0130575
0.0142215
0.0150554
0.0156251
0.0159826
0.016177
0.0162619
0.0162905
-0.00220775
-0.0135834
-0.0179314
-0.0136406
-0.00830818
-0.00356805
0.000471359
0.00463461
0.00911943
0.0131966
0.015515
0.014376
0.00881864
0.00119918
-0.00334783
-0.00391366
-0.00207558
0.00058646
0.00322448
0.00553232
0.00741822
0.00889974
0.0100311
0.0108747
0.0114912
0.0119296
0.0122203
0.0123805
0.0124352
0.0124366
-0.00178137
-0.0105703
-0.0137971
-0.0109149
-0.00688765
-0.00305018
0.000373471
0.0038346
0.00732605
0.0101903
0.0114653
0.0103184
0.0068873
0.00269464
2.54978e-05
-0.000594493
0.00015156
0.00154124
0.00307052
0.00449097
0.00570073
0.00667742
0.00743542
0.00801107
0.00844861
0.00877994
0.00900982
0.00912543
0.00913467
0.00909648
-0.00128985
-0.00769247
-0.0099882
-0.00819005
-0.00535285
-0.00250534
0.000141794
0.00279927
0.00533994
0.00725168
0.00792508
0.00706998
0.00503481
0.00276167
0.00128126
0.000803304
0.00108372
0.00177598
0.00260744
0.00342525
0.0041528
0.0047587
0.00523875
0.00560871
0.00589316
0.00610809
0.00625108
0.00631396
0.00630878
0.00627899
-0.000746721
-0.00490573
-0.00638818
-0.00544333
-0.00374165
-0.00194757
-0.000199061
0.00158087
0.00324602
0.0044331
0.00480381
0.00429741
0.00321633
0.00207059
0.00131051
0.00102362
0.00111568
0.00143226
0.00184487
0.00227329
0.00267075
0.00301179
0.00328489
0.00349128
0.00364085
0.0037442
0.00380946
0.00384595
0.00386575
0.00387878
-0.000157875
-0.00213703
-0.00286203
-0.00263894
-0.00206411
-0.00138754
-0.000640471
0.000209057
0.00105405
0.00168111
0.00191987
0.00176359
0.00136958
0.000942877
0.000655731
0.00053664
0.000557075
0.000666999
0.000820844
0.000987659
0.00114671
0.00128495
0.00139603
0.00147861
0.00153437
0.00156839
0.00159008
0.0016101
0.00163349
0.00165564
0.0800485
0.0777373
0.0713311
0.0592092
0.0389445
0.0103603
-0.023984
-0.060363
-0.0978912
-0.144762
-0.163201
-0.146594
-0.120556
-0.0939797
-0.0350933
0.0464926
0.130546
0.188048
0.623438
-0.177259
0.0958314
83.6306
109.756
113.578
114.967
112.765
108.737
102.686
100.545
98.7245
0.0735795
0.0713375
0.0649703
0.0529133
0.0329162
0.00478982
-0.0284052
-0.0630152
-0.0980648
-0.141848
-0.16072
-0.144265
-0.115784
-0.0866696
-0.0344665
0.0521172
0.119527
0.195501
0.402323
-0.183191
0.309874
94.6624
110.423
113.833
115.277
112.934
108.8
102.545
80.4144
0.867865
0.0665337
0.0641254
0.0573237
0.0445987
0.0242692
-0.00312235
-0.0344857
-0.0662794
-0.0970352
-0.134493
-0.152889
-0.138868
-0.109981
-0.079192
-0.0306502
0.0331222
0.157063
0.199974
0.242848
-0.156881
0.279422
16.5415
111.28
114.1
115.628
113.121
108.863
71.8666
17.5911
1.91811
0.0587392
0.0561393
0.0488049
0.0352528
0.0144261
-0.0122552
-0.0413415
-0.0693413
-0.0939743
-0.124086
-0.141602
-0.13084
-0.103229
-0.0718022
-0.0261356
0.0348688
0.109287
0.19204
0.369509
0.0914498
0.222337
5.00362
112.535
114.384
116.015
113.32
106.35
53.8371
4.59738
0.306353
0.0498997
0.0472034
0.0395102
0.0254384
0.00449667
-0.0211491
-0.0477591
-0.0719359
-0.089117
-0.11229
-0.129034
-0.12118
-0.0956732
-0.0646804
-0.021898
0.0342357
0.102864
0.175477
-0.0379063
-0.00115525
0.170219
-0.735377
112.34
114.682
116.295
113.454
99.243
19.2855
0.00811756
0.124524
0.0403292
0.0375922
0.0298264
0.0156221
-0.00490091
-0.0291009
-0.0532267
-0.0744893
-0.0829294
-0.101208
-0.111808
-0.110496
-0.0874673
-0.0578421
-0.0181287
0.0321804
0.0979016
0.146518
0.00945674
-0.231469
0.111062
-0.197344
98.9245
114.993
116.329
113.493
78.5623
0.736656
-0.00616897
0.127857
0.0308297
0.0280929
0.02047
0.00669395
-0.012943
-0.0355155
-0.0572919
-0.0743544
-0.0504151
-0.0718377
-0.0804757
-0.0999139
-0.0786697
-0.0512393
-0.0150268
0.0294162
0.0849913
0.123303
0.021156
-0.088267
0.0485407
-0.147306
0.46485
114.756
116.536
107.98
15.2774
0.065186
-0.0119425
0.129498
0.0225374
0.0199259
0.012726
-0.000248669
-0.0185635
-0.0393388
-0.0586363
-0.0719397
-0.0788898
-0.0730439
-0.0895488
-0.0872293
-0.0692746
-0.0448492
-0.012698
0.0253232
0.0789015
0.10048
0.0102003
0.170357
-0.00865677
-0.121176
-0.0438625
30.8579
113.706
50.3727
0.125544
0.0826265
-0.0208698
0.286967
0.0168611
0.0144814
0.00791105
-0.00391899
-0.0206127
-0.039434
-0.0564267
-0.0678765
-0.0728069
-0.0736415
-0.076708
-0.073909
-0.0597574
-0.038692
-0.0111075
0.0205985
0.0599121
0.0777046
0.0139633
0.337433
-0.0297214
-0.110401
-0.0527976
-0.0204624
0.239935
0.0303369
0.0943412
0.0418965
-0.0207748
-0.0939513
0.0150627
0.0129302
0.00712997
-0.00330741
-0.0181021
-0.0348854
-0.0498982
-0.0594544
-0.0623415
-0.062828
-0.0637747
-0.0609258
-0.0499528
-0.0328068
-0.0101567
0.0162363
0.0422839
0.0792876
0.0208759
-0.0562872
-0.0720143
-0.105038
-0.0622759
-0.0308998
-0.0129211
0.0286071
0.0499498
0.0118317
0.00114159
-0.0927043
0.0177721
0.0159288
0.0109508
0.00205141
-0.010646
-0.025279
-0.0385224
-0.0470437
-0.0495505
-0.0496946
-0.050305
-0.0478797
-0.0401267
-0.027253
-0.00981621
0.011903
0.0313587
0.0644543
0.0330587
-0.0887767
-0.0759186
-0.100077
-0.0682485
-0.0379686
-0.0138141
0.0262121
0.0258158
0.00656262
0.0153948
-0.0852652
0.0245043
0.0230064
0.0189196
0.0115655
0.000943778
-0.0114483
-0.0230325
-0.0310977
-0.0342024
-0.0360243
-0.0364102
-0.0350423
-0.0303485
-0.0221754
-0.0103535
0.00661766
0.0214298
0.0554612
-0.0395052
-0.066931
-0.0907678
-0.0938199
-0.0699742
-0.038857
-0.0136006
0.0226794
0.0117951
0.0022818
0.0106174
-0.0756261
0.0334802
0.0323317
0.0290042
0.0230244
0.0144828
0.00433753
-0.00570159
-0.0131539
-0.0182826
-0.0212188
-0.022392
-0.0224363
-0.0207025
-0.0179331
-0.0125276
-0.000628436
0.0117194
0.0452061
-0.0371365
0.0278936
-0.140012
-0.0852886
-0.0666329
-0.0365273
-0.0125402
0.0185953
0.0123992
-0.00133909
-0.00989622
-0.0657481
0.0419429
0.0411594
0.0385564
0.0339126
0.0276602
0.0194286
0.0107141
0.00257477
-0.00343366
-0.00698946
-0.00888892
-0.0102504
-0.0113888
-0.0153871
-0.0177988
-0.0109528
0.00156591
0.0198467
-0.0341819
0.198267
-0.120798
-0.0735318
-0.0595125
-0.03176
-0.0112226
0.0147682
-0.00199711
-0.00484458
-0.0396642
-0.0566833
0.0472275
0.0468453
0.0450467
0.0410723
0.0356812
0.0290683
0.0214025
0.0142487
0.00850531
0.00482036
0.00304254
0.00104335
-0.00283979
-0.0159402
-0.0280521
-0.0262489
-0.0113125
0.0040454
-0.0314237
0.012244
-0.0721355
-0.0598886
-0.0505083
-0.0261093
-0.00976946
0.0110492
-0.00272383
-0.00833528
-0.0339595
-0.0487541
0.0476712
0.0474082
0.0460647
0.0434439
0.0393475
0.0338815
0.0276092
0.0212729
0.0158052
0.0123491
0.0115275
0.0134734
0.0992374
-0.00621921
-0.0341164
-0.0486519
-0.0278284
-0.010323
-0.0251327
0.0102069
-0.0480441
-0.0471495
-0.0410986
-0.0208348
-0.00836838
0.0077225
-0.00366849
-0.0110921
-0.0287199
-0.0419505
0.0456755
0.045569
0.044597
0.0425798
0.0393732
0.0349815
0.029642
0.0238055
0.0181064
0.0135775
0.0116534
0.0944264
0.0913297
0.0622386
-0.0449492
-0.0650366
-0.0472524
-0.0284244
0.00953401
-0.00531494
-0.0357654
-0.0361126
-0.0322022
-0.0165174
-0.00713557
0.00489865
-0.00458499
-0.0130274
-0.0242862
-0.0362226
0.0423657
0.0422924
0.0415428
0.0399566
0.0373914
0.0337622
0.0290812
0.0234482
0.0169158
0.00885428
0.0832277
0.0931786
0.0309981
-0.0385003
-0.0494774
-0.0563956
-0.0686001
-0.035659
0.0142308
-0.0190461
-0.0273878
-0.0265741
-0.0242806
-0.0131519
-0.00610502
0.00261171
-0.0053331
-0.0141427
-0.0207126
-0.0310463
0.0388624
0.038749
0.0381171
0.0368389
0.0347707
0.0317722
0.0277255
0.0224997
0.0161018
0.00724887
0.0193117
0.0923752
-0.0226108
-0.04288
-0.0325922
-0.073805
-0.0854805
-0.046626
-0.00103345
-0.0234759
-0.0196659
-0.0183937
-0.0175186
-0.0105059
-0.00526592
0.000824126
-0.00587065
-0.0144939
-0.0178703
-0.0263452
0.0356676
0.0355007
0.0349333
0.0338753
0.0322165
0.0298307
0.0265804
0.0222981
0.016753
0.0106857
-0.000496133
-0.0116155
-0.0223871
-0.0376284
-0.0661253
-0.0599096
-0.0896957
-0.0584417
0.0189863
-0.0194755
-0.0123937
-0.0116957
-0.0120284
-0.00831904
-0.00457528
-0.000525349
-0.00619108
-0.0141969
-0.0154019
-0.0220546
0.0322173
0.0320613
0.0316419
0.0308759
0.0296701
0.0279228
0.0255209
0.022324
0.0181004
0.0124136
0.0067351
-0.00287063
-0.0126842
-0.0283876
-0.0542006
-0.0493565
-0.0826901
-0.048634
0.0189173
-0.0095615
-0.00571349
-0.00651993
-0.00785027
-0.00643475
-0.00398751
-0.00150086
-0.00628986
-0.0134149
-0.0131888
-0.0181324
0.0287891
0.0286265
0.0282617
0.0276554
0.0267618
0.0255185
0.0238357
0.0215917
0.0186149
0.0146351
0.00939896
0.00314303
-0.00521262
-0.0194519
-0.036218
-0.0685994
-0.0670775
-0.0348582
0.0049834
0.00141963
0.000116179
-0.0025523
-0.00473421
-0.00480102
-0.00346186
-0.00216411
-0.00617562
-0.0123208
-0.0112882
-0.0145676
0.0250822
0.0249168
0.024572
0.0240634
0.0233793
0.0224701
0.0212529
0.0196191
0.017431
0.0145085
0.0106442
0.00559203
-0.0014734
-0.0121327
-0.0274077
-0.048035
-0.0574101
-0.0132558
0.0189878
0.00925899
0.00455242
0.000447865
-0.00240343
-0.00341309
-0.00297604
-0.00256396
-0.00587798
-0.0110397
-0.00969537
-0.011381
0.0206644
0.0205882
0.0204078
0.0201088
0.0196572
0.0189992
0.0180706
0.0167992
0.0150929
0.0128292
0.0098592
0.00596749
0.000777791
-0.00616724
-0.0151009
-0.0245935
-0.0176713
0.0128828
0.0180783
0.0130794
0.00717473
0.00250781
-0.000699499
-0.00228231
-0.00252986
-0.00273873
-0.00544236
-0.00965107
-0.00829052
-0.00863816
0.016302
0.0162979
0.0162401
0.0160864
0.0157946
0.0153225
0.014627
0.0136623
0.0123718
0.0106816
0.00850099
0.00572882
0.00227788
-0.00181742
-0.00600764
-0.0082956
-0.00394287
0.0104865
0.0159674
0.012736
0.00804119
0.00367708
0.000446536
-0.00142002
-0.0021302
-0.00272823
-0.0049129
-0.00821214
-0.00700707
-0.00643637
0.0124474
0.0124824
0.012485
0.012394
0.0121802
0.0118334
0.0113362
0.0106541
0.00974882
0.00857398
0.00708947
0.00526993
0.00315134
0.000914199
-0.000862396
-0.000956892
0.00246923
0.00921721
0.0123758
0.0109782
0.00761205
0.00402311
0.00108348
-0.000826248
-0.00178567
-0.00257367
-0.00431317
-0.00677237
-0.00580157
-0.00476264
0.0090953
0.00915938
0.00921999
0.00919445
0.00905068
0.00880189
0.00846066
0.00801157
0.00741994
0.00665775
0.0057151
0.00460619
0.00339273
0.0022325
0.00151543
0.00184323
0.00384305
0.00706552
0.0089776
0.00851056
0.00640516
0.00371599
0.00127466
-0.00049123
-0.00150852
-0.00231683
-0.00364765
-0.00536546
-0.00463988
-0.00346437
0.00627861
0.00632694
0.00638472
0.00639644
0.00633078
0.00618988
0.00598666
0.0057171
0.00535858
0.00489359
0.00432811
0.00369225
0.00303915
0.00247306
0.00219335
0.00247103
0.00349343
0.00513684
0.00616337
0.00606279
0.00481477
0.00295691
0.00107918
-0.000379247
-0.00130482
-0.00199393
-0.00292308
-0.00400693
-0.00349038
-0.00240793
0.00388952
0.00389888
0.00390533
0.00390393
0.0038844
0.00383674
0.00375276
0.00362234
0.0034318
0.00317459
0.00286254
0.00252607
0.00220478
0.00195315
0.00185313
0.00201288
0.00250018
0.00323349
0.00377872
0.00375227
0.00305111
0.00186992
0.000572239
-0.000491683
-0.0011769
-0.00163353
-0.00215183
-0.00269349
-0.00232309
-0.00149473
0.00166643
0.00166102
0.00164646
0.00163422
0.00162865
0.00162307
0.00160474
0.00156248
0.00149029
0.00138811
0.00126348
0.00113317
0.00101621
0.000934376
0.000908897
0.000971851
0.00114283
0.0014009
0.00159177
0.00155178
0.00119026
0.000548353
-0.00018671
-0.000788181
-0.00112428
-0.00125713
-0.00134246
-0.00140115
-0.0011145
-0.000650285
109.083
114.136
118.627
118.817
116.759
114.267
111.703
109.254
107.149
105.568
104.492
103.746
103.211
102.932
103.007
103.481
104.308
105.377
106.555
107.725
108.8
109.733
110.505
111.118
111.583
111.922
112.154
112.299
112.376
112.4
109.071
114.138
118.653
118.832
116.763
114.267
111.697
109.241
107.128
105.541
104.465
103.718
103.179
102.895
102.967
103.441
104.275
105.355
106.548
107.732
108.821
109.765
110.545
111.163
111.633
111.974
112.208
112.355
112.432
112.457
109.039
114.139
118.711
118.866
116.773
114.27
111.692
109.22
107.089
105.49
104.413
103.665
103.118
102.821
102.883
103.356
104.195
105.289
106.5
107.702
108.809
109.767
110.557
111.183
111.658
112.003
112.239
112.387
112.465
112.49
108.987
114.14
118.8
118.917
116.788
114.276
111.687
109.191
107.032
105.414
104.334
103.585
103.025
102.709
102.757
103.226
104.074
105.188
106.421
107.647
108.773
109.746
110.546
111.177
111.655
112.001
112.237
112.384
112.462
112.487
108.916
114.138
118.923
118.986
116.809
114.287
111.682
109.155
106.956
105.312
104.23
103.48
102.902
102.558
102.584
103.047
103.907
105.044
106.307
107.562
108.711
109.701
110.512
111.148
111.628
111.974
112.209
112.356
112.433
112.458
108.824
114.135
119.081
119.073
116.834
114.301
111.679
109.111
106.86
105.184
104.099
103.349
102.746
102.366
102.362
102.816
103.687
104.853
106.15
107.439
108.617
109.627
110.451
111.094
111.576
111.922
112.157
112.303
112.38
112.404
108.711
114.128
119.276
119.177
116.865
114.319
111.676
109.06
106.745
105.028
103.942
103.193
102.558
102.13
102.087
102.526
103.408
104.608
105.946
107.275
108.486
109.52
110.358
111.01
111.496
111.843
112.078
112.223
112.299
112.323
108.578
114.118
119.512
119.298
116.899
114.341
111.675
109.002
106.609
104.843
103.758
103.012
102.337
101.847
101.754
102.172
103.064
104.303
105.687
107.062
108.313
109.375
110.231
110.892
111.382
111.731
111.966
112.111
112.186
112.21
108.423
114.102
119.791
119.435
116.936
114.368
111.677
108.937
106.451
104.628
103.547
102.806
102.081
101.515
101.356
101.746
102.644
103.927
105.362
106.793
108.092
109.187
110.064
110.736
111.231
111.581
111.815
111.96
112.035
112.059
108.245
114.079
120.118
119.587
116.975
114.398
111.681
108.865
106.271
104.381
103.309
102.577
101.789
101.13
100.889
101.238
102.146
103.47
104.96
106.456
107.813
108.949
109.851
110.535
111.036
111.387
111.621
111.765
111.84
111.863
108.045
114.047
120.499
119.752
117.016
114.433
111.688
108.787
106.066
104.1
103.044
102.326
101.46
100.687
100.344
100.636
101.538
102.913
104.46
106.035
107.465
108.653
109.584
110.284
110.791
111.143
111.375
111.517
111.589
111.61
107.822
114.003
120.94
119.929
117.058
114.473
111.698
108.704
105.837
103.781
102.752
102.055
101.092
100.182
99.7186
99.9271
100.815
102.236
103.837
105.511
107.037
108.287
109.255
109.975
110.487
110.839
111.068
111.205
111.277
111.299
107.574
113.943
121.449
120.116
117.098
114.517
111.714
108.616
105.575
103.421
102.434
101.764
100.681
99.6118
99.0092
99.0963
99.9554
101.404
103.053
104.857
106.511
107.84
108.856
109.6
110.121
110.468
110.691
110.822
110.889
110.91
107.302
113.865
122.037
120.308
117.136
114.567
111.735
108.524
105.281
103.017
102.09
101.455
100.225
98.9703
98.2151
98.1251
98.9444
100.363
102.056
104.038
105.868
107.298
108.381
109.151
109.678
110.023
110.237
110.358
110.414
110.429
107.004
113.764
122.716
120.502
117.17
114.622
111.762
108.429
104.951
102.564
101.725
101.132
99.719
98.2514
97.3383
96.9798
97.7698
99.0133
100.765
103.015
105.085
106.645
107.817
108.628
109.161
109.489
109.681
109.788
109.845
109.861
106.68
113.633
123.501
120.693
117.199
114.684
111.798
108.334
104.582
102.054
101.341
100.797
99.1568
97.446
96.3748
95.6453
96.3223
97.1647
99.0541
101.746
104.155
105.874
107.169
108.02
108.555
108.864
109.027
109.104
109.141
109.153
106.329
113.467
124.412
120.873
117.221
114.752
111.842
108.24
104.168
101.481
100.944
100.452
98.5326
96.5446
95.2373
94.0567
94.3383
94.5604
96.7429
100.199
103.048
104.996
106.427
107.329
107.864
108.147
108.266
108.298
108.289
108.281
105.951
113.258
125.473
121.034
117.235
114.828
111.896
108.151
103.702
100.835
100.544
100.1
97.8408
95.5184
93.8253
92.2179
92.0438
91.8004
93.8644
98.324
101.594
103.914
105.576
106.583
107.091
107.284
107.333
107.317
107.289
107.274
105.544
112.996
126.716
121.165
117.238
114.913
111.962
108.071
103.178
100.104
100.151
99.7398
97.0789
94.3874
92.3578
90.0994
89.6321
88.506
89.8939
95.9418
99.9583
102.794
104.675
105.745
106.212
106.312
106.237
106.142
106.091
106.074
105.108
112.671
128.185
121.251
117.23
115.007
112.041
108.004
102.584
99.272
99.7767
99.3648
96.249
93.0335
91.028
88.0857
85.3076
81.2669
82.5517
91.1603
97.42
101.286
103.715
104.949
105.325
105.277
104.986
104.725
104.597
104.554
104.643
112.272
129.937
121.276
117.208
115.112
112.134
107.959
101.905
98.319
99.4255
98.9505
95.3431
91.5336
89.7686
86.1481
79.0095
71.5126
74.9335
83.7959
93.5623
99.5861
102.705
104.119
104.387
104.104
103.515
102.986
102.713
102.622
104.149
111.783
132.045
121.216
117.17
115.229
112.244
107.944
101.122
97.2168
99.0886
98.4384
94.3376
90.2179
88.5256
83.1307
75.3787
63.975
69.5064
78.776
90.7293
97.9691
101.533
102.945
103.141
102.606
101.708
100.853
100.351
100.176
103.626
111.189
134.613
121.047
117.116
115.361
112.37
107.97
100.208
95.9318
98.7253
97.7081
92.9797
88.5945
86.9067
79.746
72.5707
46.2219
67.1929
78.5908
89.453
96.2016
99.8456
101.336
101.437
100.629
99.4375
98.3218
97.5453
97.2426
103.073
110.472
137.775
120.741
117.045
115.508
112.513
108.054
99.1242
94.4838
98.2843
96.5685
91.2822
87.3226
84.5505
78.7291
37.2247
0.19454
16.2582
76.621
89.7052
95.3768
98.1321
99.7887
99.7664
98.7001
97.0828
95.4239
94.1821
93.6556
102.49
109.614
141.71
120.27
116.957
115.675
112.673
108.213
97.8174
93.1001
97.7022
94.8578
89.2942
85.7233
82.7294
14.9522
0.00238382
0.132632
0.141122
24.2387
90.0515
95.7225
97.605
98.5846
98.6298
97.5076
95.07
92.1052
89.7136
88.6659
101.88
108.597
146.648
119.607
116.852
115.863
112.846
108.47
96.183
92.0294
97.3035
92.5398
86.7258
70.5636
0.496969
-0.0180078
0.0101165
0.0820717
0.0756273
0.0455147
36.7281
99.5461
97.7019
97.7285
97.3301
97.0913
93.82
88.4396
83.3756
81.0342
101.242
107.409
152.889
118.728
116.732
116.078
113.029
108.843
93.9786
90.6993
97.8025
89.2822
62.8686
0.0891174
0.0216603
-0.0273734
-0.0248684
0.0198078
0.0151495
-0.0324155
-0.0445681
14.0424
58.7596
85.3597
89.3565
90.1364
78.6645
60.1352
44.9925
39.25
100.576
106.046
160.809
117.616
116.598
116.325
113.215
109.357
90.9064
88.0156
98.9424
74.6384
0.0384194
0.0706971
0.0212298
-0.032816
-0.0580962
-0.028742
-0.0405879
-0.0795006
-0.0940549
0.00278642
0.0237468
0.321294
0.30016
0.29222
0.207822
0.202086
0.195476
0.193891
99.8835
104.514
170.888
116.257
116.456
116.61
113.393
110.071
86.7669
85.8426
93.8878
0.105794
0.0367234
0.0570535
0.0237542
-0.0374729
-0.0692484
-0.0512593
-0.0734659
-0.106945
-0.0864179
-0.0468925
-0.040466
-0.00957501
0.021918
0.0517163
0.0748146
0.0935784
0.10429
0.108525
99.1647
102.829
183.741
114.651
116.308
116.942
113.549
111.055
81.203
29.4164
0.110996
0.0901411
0.034235
0.0470998
0.0115841
-0.0413859
-0.0685502
-0.0583075
-0.0880211
-0.114461
-0.0859247
-0.0549551
-0.0382323
-0.0119051
0.0166741
0.0433429
0.0643725
0.0789484
0.0871348
0.0904489
112.383
112.319
112.193
111.988
111.685
111.263
110.703
109.987
109.108
108.073
106.917
105.706
104.544
103.559
102.878
102.578
102.644
102.974
103.442
104.038
104.874
105.983
107.168
108.061
108.261
107.504
105.85
103.815
102.072
101.079
112.439
112.374
112.248
112.041
111.736
111.311
110.745
110.022
109.133
108.087
106.916
105.691
104.516
103.523
102.838
102.54
102.612
102.946
103.416
104.014
104.853
105.97
107.164
108.064
108.268
107.51
105.854
103.815
102.071
101.078
112.472
112.407
112.279
112.07
111.762
111.333
110.761
110.029
109.128
108.065
106.877
105.633
104.442
103.439
102.754
102.463
102.548
102.895
103.371
103.969
104.815
105.949
107.162
108.076
108.284
107.523
105.858
103.812
102.066
101.07
112.469
112.404
112.276
112.068
111.759
111.328
110.751
110.012
109.099
108.019
106.808
105.54
104.328
103.312
102.625
102.347
102.453
102.819
103.303
103.901
104.76
105.921
107.164
108.098
108.311
107.543
105.864
103.805
102.057
101.056
112.44
112.375
112.248
112.04
111.732
111.299
110.719
109.971
109.044
107.943
106.706
105.408
104.169
103.136
102.45
102.191
102.326
102.719
103.213
103.812
104.686
105.885
107.169
108.129
108.349
107.57
105.87
103.795
102.043
101.036
112.386
112.322
112.195
111.988
111.679
111.245
110.66
109.902
108.958
107.832
106.563
105.23
103.959
102.906
102.223
101.99
102.165
102.594
103.101
103.699
104.594
105.842
107.178
108.171
108.398
107.605
105.877
103.78
102.026
101.01
112.306
112.241
112.115
111.907
111.598
111.161
110.57
109.801
108.837
107.682
106.375
105.001
103.692
102.617
101.94
101.744
101.969
102.444
102.968
103.562
104.482
105.79
107.192
108.224
108.458
107.646
105.885
103.762
102.004
100.978
112.192
112.128
112.002
111.795
111.484
111.044
110.446
109.663
108.676
107.486
106.134
104.712
103.362
102.261
101.596
101.45
101.737
102.271
102.814
103.401
104.349
105.73
107.209
108.287
108.53
107.695
105.894
103.74
101.978
100.94
112.041
111.977
111.851
111.644
111.333
110.89
110.283
109.483
108.468
107.237
105.831
104.355
102.957
101.828
101.185
101.103
101.468
102.073
102.639
103.215
104.194
105.662
107.232
108.363
108.613
107.751
105.904
103.714
101.949
100.896
111.846
111.782
111.655
111.449
111.138
110.691
110.075
109.256
108.208
106.925
105.455
103.916
102.469
101.307
100.697
100.7
101.16
101.852
102.444
103.001
104.015
105.585
107.26
108.45
108.708
107.814
105.914
103.683
101.916
100.846
111.593
111.532
111.409
111.204
110.893
110.442
109.816
108.973
107.884
106.537
104.988
103.376
101.882
100.682
100.122
100.236
100.811
101.609
102.231
102.759
103.808
105.497
107.294
108.549
108.815
107.885
105.925
103.648
101.879
100.79
111.282
111.22
111.099
110.899
110.589
110.136
109.497
108.626
107.486
106.059
104.407
102.711
101.182
99.933
99.448
99.7044
100.417
101.344
102.001
102.486
103.576
105.399
107.335
108.662
108.936
107.964
105.936
103.607
101.84
100.728
110.893
110.834
110.72
110.526
110.222
109.767
109.11
108.204
107
105.469
103.68
101.882
100.346
99.0357
98.655
99.0964
99.9749
101.058
101.756
102.181
103.318
105.289
107.384
108.789
109.069
108.05
105.947
103.561
101.797
100.659
110.414
110.365
110.262
110.077
109.779
109.323
108.652
107.697
106.41
104.744
102.761
100.831
99.3431
97.9579
97.7209
98.4042
99.4813
100.753
101.499
101.842
103.027
105.167
107.442
108.931
109.216
108.145
105.958
103.509
101.752
100.584
109.847
109.797
109.699
109.535
109.258
108.81
108.112
107.092
105.697
103.858
101.581
99.4725
98.1051
96.6622
96.6264
97.6266
98.931
100.429
101.232
101.465
102.699
105.032
107.511
109.088
109.377
108.247
105.969
103.452
101.704
100.502
109.14
109.102
109.033
108.9
108.649
108.207
107.493
106.393
104.843
102.792
100.059
97.6692
96.4558
95.1433
95.4123
96.7671
98.3155
100.085
100.958
101.046
102.329
104.881
107.591
109.262
109.553
108.357
105.98
103.387
101.655
100.414
108.277
108.275
108.256
108.168
107.954
107.528
106.78
105.599
103.854
101.535
98.1082
95.2443
94.0481
93.4961
94.1711
95.8219
97.6281
99.7176
100.678
100.579
101.913
104.715
107.685
109.453
109.743
108.475
105.99
103.315
101.604
100.319
107.275
107.289
107.305
107.277
107.146
106.788
105.997
104.659
102.579
99.9726
95.7314
92.4338
91.6141
91.4491
92.9101
94.8112
96.8585
99.3181
100.392
100.055
101.443
104.53
107.796
109.662
109.95
108.602
105.999
103.235
101.551
100.217
106.08
106.107
106.173
106.259
106.238
105.952
105.135
103.654
101.204
97.9824
92.5214
88.3324
88.9115
89.0208
91.5107
93.6186
95.9776
98.872
100.1
99.4622
100.913
104.325
107.926
109.89
110.173
108.736
106.007
103.146
101.499
100.107
104.572
104.656
104.846
105.137
105.311
105.13
104.309
102.469
99.1876
94.484
86.2494
80.4491
82.7787
85.5165
90.2648
92.3109
94.9618
98.3574
99.7999
98.7833
100.313
104.096
108.078
110.138
110.413
108.879
106.014
103.047
101.446
99.9893
102.662
102.845
103.257
103.851
104.312
104.288
103.458
101.117
96.5714
88.4338
78.7521
71.1473
75.4128
82.4674
88.3293
91.0253
93.7163
97.7601
99.4817
97.9967
99.6301
103.84
108.256
110.407
110.671
109.031
106.02
102.938
101.394
99.8631
100.253
100.603
101.312
102.247
102.999
103.158
102.334
99.6879
94.092
83.906
74.2967
64.5458
69.9348
79.1634
85.7836
89.8586
92.0938
97.1129
99.1219
97.0796
98.8477
103.553
108.464
110.696
110.948
109.191
106.024
102.817
101.342
99.7276
97.3643
97.9456
98.9513
100.178
101.251
101.674
100.697
98.0072
92.4946
83.9328
73.7324
55.8793
63.1133
76.8319
82.7301
88.6476
90.6554
96.3292
98.6759
96.0167
97.9513
103.231
108.709
111.006
111.244
109.359
106.027
102.683
101.291
99.582
93.862
94.8225
96.377
98.0985
99.5822
100.254
99.3219
96.8241
91.9808
84.0981
56.6794
0.386843
0.159919
71.884
80.5266
86.0782
89.0924
95.252
98.0552
94.8762
96.9443
102.869
108.997
111.336
111.562
109.537
106.029
102.534
101.242
99.425
89.0572
90.8786
93.7572
96.6371
98.5974
99.3251
98.9369
96.7429
92.1885
77.1666
0.293523
0.173889
0.100527
-0.026015
54.8922
84.8797
87.3814
93.9399
97.1996
93.9636
95.8263
102.466
109.334
111.684
111.903
109.723
106.03
102.368
101.193
99.2552
81.9203
85.8909
91.4931
96.1635
97.887
98.1793
99.6698
98.5416
85.2251
0.160522
0.0785145
0.0976501
0.0467708
-0.0352845
-0.00283644
38.2608
86.042
92.6507
96.4761
93.4232
94.3761
102.016
109.73
112.05
112.268
109.918
106.03
102.184
101.145
99.0707
41.97
53.7489
72.1329
87.9516
93.7258
91.0773
87.8065
33.132
0.188645
-0.0713803
-0.0105364
0.000804668
-0.0376456
-0.0594303
0.00424261
0.130056
20.5059
92.022
97.0228
92.2331
92.2186
101.52
110.191
112.429
112.661
110.122
106.03
101.978
101.097
98.8695
0.204274
0.221874
0.22782
0.270296
0.369333
0.357493
0.216557
-0.0552731
-0.131507
-0.118274
-0.0909377
-0.0779845
-0.0962992
-0.0726583
0.000758256
0.111943
0.173494
18.1363
98.0923
91.2935
89.2632
101.007
110.724
112.817
113.082
110.336
106.029
101.75
101.047
98.6488
0.107704
0.101111
0.0869318
0.0666358
0.0386993
0.000590758
-0.0448265
-0.0887531
-0.122746
-0.135062
-0.139431
-0.117476
-0.120179
-0.0227218
0.00588701
0.104891
0.153644
0.230483
21.962
86.2539
86.0563
100.534
111.327
113.209
113.534
110.56
106.028
101.494
100.992
98.4058
0.0896517
0.0845622
0.0740175
0.0561216
0.030594
-0.00428973
-0.0416049
-0.0826919
-0.12333
-0.15055
-0.158778
-0.130735
-0.118689
-0.075663
-0.018644
0.10252
0.145354
0.222987
0.0297001
-0.0219422
82.7438
100.232
111.995
113.595
114.019
110.795
106.027
101.21
100.93
98.1308
98.5074
101.243
198.018
113.05
116.181
117.284
113.652
112.191
74.87
0.122277
0.18833
0.0604579
0.0823982
0.0412404
0.0107485
-0.0384971
-0.0605236
-0.0588604
-0.0886743
-0.109749
-0.0846121
-0.0547056
-0.037896
-0.0153912
0.01181
0.0375497
0.0572461
0.0698369
0.0769484
0.0799098
1.63346
80.2067
164.742
112.03
116.107
117.508
113.692
112.949
87.4517
0.37079
0.226442
0.289213
0.0739971
0.0389417
0.0109664
-0.0353061
-0.0550647
-0.0579086
-0.0860933
-0.103465
-0.080957
-0.0553101
-0.0406361
-0.0198813
0.00638127
0.0316469
0.0509893
0.0634167
0.0704873
0.0734026
1.17658
9.40965
187.24
110.941
116.032
117.775
113.715
113.853
14.5119
0.37117
0.264669
0.811216
0.0713828
0.0370236
0.0115484
-0.0310769
-0.049258
-0.0560575
-0.081769
-0.0954594
-0.0755924
-0.0554587
-0.0436754
-0.0254959
-0.000935163
0.0234181
0.0428766
0.0558642
0.0633249
0.0663763
-0.115465
1.25383
129.198
107.368
115.97
118.079
113.728
114.922
-0.422877
0.344313
0.531359
0.296281
0.06568
0.0331315
0.0124593
-0.0262744
-0.0434023
-0.0532508
-0.0761673
-0.087147
-0.0689622
-0.0546795
-0.0467645
-0.0315736
-0.009028
0.0143459
0.0339956
0.0475855
0.0554257
0.0586003
-0.0468794
-0.109699
21.5618
102.341
115.824
118.711
113.89
114.073
-0.333365
0.288686
-0.0693719
0.181303
0.0581408
0.030327
0.0139068
-0.021308
-0.0377864
-0.0495482
-0.0697802
-0.0802113
-0.0619551
-0.0535192
-0.0501006
-0.0374434
-0.0168272
0.00535542
0.0247683
0.0386193
0.0466315
0.0497806
-0.0110533
-0.120106
0.624021
68.9963
115.533
118.776
114.013
94.4553
-0.176714
0.215407
-0.247
0.083753
0.0474119
0.0270109
0.0171404
-0.0165628
-0.032506
-0.0450353
-0.0626619
-0.0553672
-0.0404799
-0.0422858
-0.0525549
-0.0425823
-0.0239449
-0.00321993
0.0155537
0.0292797
0.0371953
0.0402471
-0.0116781
-0.121701
-0.136532
11.9505
111.076
118.626
112.813
0.559331
-0.108474
0.156373
0.00519997
0.0523371
0.0336792
0.0238364
0.0137091
-0.0122815
-0.0275148
-0.0398371
-0.0543096
-0.0592035
-0.0403539
-0.0279612
-0.0262938
-0.0454588
-0.0295449
-0.0105811
0.00713353
0.0202798
0.0278856
0.030779
-0.0796848
-0.121734
-0.115682
0.0145565
73.4228
118.017
14.4193
-0.0269633
-0.0755229
0.100873
-0.199938
0.0157831
0.0168958
0.0369896
0.00973751
-0.00884562
-0.0227749
-0.0340988
-0.0458745
-0.0500507
-0.0461198
-0.0423229
-0.0459289
-0.044736
-0.0324951
-0.0156558
0.000627198
0.0128006
0.0198679
0.0225245
-0.0827802
-0.12983
-0.0954927
-0.0134715
0.284906
15.5254
-0.0220539
-0.0380001
-0.0575134
0.051346
-0.202215
-0.00952142
-0.00221522
0.069227
0.00611401
-0.0064138
-0.0183295
-0.0279302
-0.0369208
-0.0405637
-0.0391727
-0.0392925
-0.0428993
-0.0421851
-0.0321145
-0.0174175
-0.00276996
0.00820588
0.014533
0.0168671
-0.0784418
-0.12762
-0.0731371
-0.014351
0.00961156
-0.0187606
-0.023419
-0.0429827
-0.0481278
0.0202622
0.10492
-0.0336718
-0.0223106
0.0485559
0.00318982
-0.00510744
-0.0143178
-0.021444
-0.0278546
-0.0311206
-0.0304749
-0.0338272
-0.0373675
-0.0363301
-0.0276867
-0.0147833
-0.00202532
0.0075202
0.0130488
0.0150876
-0.0709426
-0.107388
-0.064359
-0.0165177
0.0100425
-0.0157167
-0.0241283
-0.0442114
-0.0416996
0.0110053
0.186397
-0.044915
0.0299241
0.0539279
-0.00289695
-0.0051497
-0.0110194
-0.0147408
-0.0186185
-0.0213778
-0.0228795
-0.0247599
-0.0282471
-0.026486
-0.0187141
-0.00763318
0.00319036
0.0113026
0.0160159
0.0177799
-0.0719342
-0.087696
-0.0545364
-0.0231894
0.00949949
-0.0160103
-0.0229343
-0.0426295
-0.0359713
0.0178667
0.0120918
-0.0508191
-0.0368296
0.00215322
-0.00715733
-0.00667772
-0.00909181
-0.00801223
-0.00919694
-0.0113389
-0.0132783
-0.0142962
-0.0155434
-0.0134438
-0.00636521
0.0030563
0.0121821
0.0189699
0.0229409
0.0244857
0.00380153
-0.0927388
-0.0482962
-0.0233209
0.00757212
-0.0136784
-0.0202437
-0.0390152
-0.0293801
0.0190041
0.0343451
-0.0600232
-0.0549095
0.00385058
-0.0121135
-0.00991236
-0.00991508
-0.00174501
0.000146303
-0.00144797
-0.00308209
-0.00387658
-0.00214399
0.00120455
0.0071625
0.0150359
0.0226837
0.0284501
0.0319545
0.0333999
-0.0252576
-0.0972754
-0.0447937
-0.0235566
0.00505537
-0.01165
-0.0166685
-0.0335592
-0.0230451
0.0146225
0.0353394
-0.0702376
-0.0325435
-0.0480146
-0.0216713
-0.0149144
-0.00963033
0.0198495
0.00855605
0.00709038
0.00584273
0.00592289
0.00827605
0.014069
0.0209748
0.0262003
0.0323773
0.037336
0.0403984
0.0417828
-0.0257953
-0.0721305
-0.0417339
-0.0241396
0.00232498
-0.00969309
-0.0130013
-0.0270585
-0.016748
0.00957016
0.0212469
-0.0666584
-0.0761386
-0.0547661
-0.0320055
-0.0200704
0.129738
0.13032
0.0888551
0.0129869
0.0113312
0.0120273
0.0152874
0.0203978
0.0266413
0.0330432
0.0385613
0.0431757
0.0457805
0.0470158
-0.0262441
-0.0667132
-0.0394248
-0.0245649
-0.000205827
-0.00793992
-0.00964849
-0.0202203
-0.0100997
0.00674576
0.00998637
-0.0395799
-0.0572717
-0.0690882
-0.0463596
-0.0270581
-0.020818
-0.0123243
0.107735
0.0858929
0.0102235
0.0127006
0.0177704
0.0237345
0.0299286
0.0356647
0.0403993
0.0439175
0.0462229
0.0474307
-0.0249
-0.0929146
-0.037646
-0.0246948
-0.00247403
-0.00649887
-0.00681204
-0.0135575
-0.00402236
0.0074464
-0.00343444
-0.0587545
-0.0923688
-0.080429
-0.0610169
-0.0370146
-0.0246136
-0.0111728
0.0813142
0.123795
-0.0060957
0.0081404
0.0168577
0.0240219
0.0302484
0.035471
0.0395696
0.0425303
0.0444444
0.0454527
-0.0234483
-0.0782595
-0.0361509
-0.02441
-0.004376
-0.00538614
-0.00446234
-0.00734851
0.00179217
0.0107449
-0.00261339
-0.0405119
-0.0835988
-0.0932874
-0.0385765
-0.0515206
-0.0315011
-0.0179256
-0.000615821
0.141553
-0.0101324
0.00552791
0.0160769
0.0237653
0.0296407
0.0341836
0.0375645
0.0399216
0.0414115
0.0421906
-0.0218782
-0.066014
-0.0346379
-0.0236954
-0.00584886
-0.00454238
-0.00251912
-0.00208409
0.00708273
0.0154046
0.00715984
-0.026048
-0.0715425
-0.099967
-0.0444119
-0.0182447
-0.0360471
-0.0215563
-0.014744
-0.0112304
-0.00225432
0.0106505
0.0184195
0.0246862
0.0293759
0.0328842
0.0354197
0.0371488
0.03822
0.0387572
-0.0202274
-0.0556613
-0.0329183
-0.0226044
-0.00687154
-0.00388649
-0.00091108
0.00210793
0.0112889
0.0200329
0.0202121
0.003564
-0.0605514
-0.0487419
-0.0547623
-0.0626536
-0.0335582
-0.0171187
-0.00780089
-0.000122062
0.00866733
0.0160921
0.0216308
0.025907
0.0291864
0.0316392
0.0333965
0.0345787
0.0352936
0.0356249
-0.0184974
-0.0468202
-0.0308843
-0.0211873
-0.00746018
-0.0033508
0.000399752
0.00514315
0.0140893
0.0233549
0.029611
0.0189938
-0.0504393
-0.0891942
-0.0715808
-0.0550983
-0.0282873
-0.0110392
-0.000556078
0.00722234
0.0141565
0.0194307
0.0232731
0.0261733
0.0283525
0.0299341
0.0310203
0.0317076
0.0320834
0.0322208
-0.0166887
-0.0392356
-0.0284829
-0.0194941
-0.00766239
-0.00288991
0.00141837
0.00705882
0.015521
0.0247009
0.0330834
0.0266275
-0.038594
-0.0864031
-0.077008
-0.0440111
-0.0211029
-0.00589705
0.00392229
0.0108556
0.0161224
0.0199861
0.0227652
0.0247837
0.0262444
0.0272841
0.0280029
0.0284694
0.0287273
0.028808
-0.0147945
-0.0326756
-0.0256974
-0.0175848
-0.00754211
-0.00248048
0.00214186
0.00800943
0.0157545
0.0240182
0.0302049
0.0310163
-0.0208961
-0.0586923
-0.0464184
-0.0305282
-0.0139335
-0.00262485
0.00530995
0.0110141
0.0151889
0.0182227
0.0203913
0.0219323
0.0230224
0.023794
0.0243456
0.0247387
0.0249932
0.0250954
-0.0127774
-0.0269011
-0.0225935
-0.0155278
-0.0071597
-0.00211596
0.00255354
0.00819667
0.0149667
0.0216811
0.0258223
0.021028
0.00349504
-0.0197987
-0.0265882
-0.0173869
-0.00795144
-0.000436027
0.00533804
0.00970206
0.0129679
0.0153801
0.0171355
0.0183934
0.0192744
0.0198687
0.0202511
0.0204856
0.0206179
0.0206687
-0.0107347
-0.0218239
-0.0193198
-0.0133865
-0.00656213
-0.00179921
0.00265889
0.00776941
0.0133884
0.018358
0.0204973
0.0162419
0.00318419
-0.0089236
-0.011619
-0.00852333
-0.0035779
0.00104082
0.00495048
0.00807707
0.0104957
0.012326
0.0136862
0.0146755
0.0153702
0.0158277
0.0160973
0.01623
0.0162804
0.0162973
-0.00877081
-0.0173139
-0.0159878
-0.0112127
-0.00579012
-0.00153458
0.00248143
0.0068612
0.0112808
0.0146836
0.0154917
0.0121266
0.00494562
-0.00154225
-0.00406535
-0.00318649
-0.000775582
0.00193276
0.00442879
0.00652848
0.00820681
0.00950564
0.0104854
0.011208
0.0117309
0.0120927
0.0123159
0.0124186
0.0124384
0.0124384
-0.00687134
-0.0132565
-0.0126584
-0.00903361
-0.00488714
-0.00132849
0.00207171
0.00560554
0.00889443
0.0110943
0.0112304
0.00883362
0.00471034
0.00105503
-0.000507759
-0.000348377
0.000802629
0.0023072
0.00380309
0.00512475
0.00621798
0.00708191
0.00774336
0.00824478
0.00862697
0.00890856
0.00908261
0.00914082
0.00911608
0.00908765
-0.0050258
-0.00954217
-0.00936483
-0.00684961
-0.00389268
-0.00117662
0.00146265
0.00410986
0.0064163
0.00777863
0.00768775
0.00615601
0.00383527
0.00189225
0.000923486
0.000868567
0.00139695
0.00218495
0.0030237
0.00380298
0.00447171
0.00501374
0.00543596
0.00576028
0.00600919
0.00618934
0.00629264
0.00631799
0.00629347
0.00627271
-0.00321466
-0.00605365
-0.00610585
-0.00464107
-0.00283565
-0.00107639
0.000687481
0.00244609
0.00392548
0.0047364
0.00465071
0.00380172
0.00261895
0.00163073
0.00110926
0.00103098
0.0012545
0.00163186
0.00206041
0.00247784
0.00284935
0.0031571
0.00339602
0.00357248
0.00369779
0.00378113
0.00383068
0.00385734
0.00387278
0.00388424
-0.00140016
-0.00265444
-0.00283224
-0.00237575
-0.00173276
-0.00102759
-0.000226482
0.000643964
0.00140851
0.00185517
0.00188473
0.00158429
0.0011494
0.000777969
0.000575387
0.00053225
0.000603929
0.000740506
0.000904099
0.00106906
0.00121876
0.00134391
0.00144091
0.00150973
0.00155365
0.00158015
0.00159991
0.00162153
0.00164539
0.00166297
0.0793723
0.0751316
0.0661536
0.0501784
0.0255686
-0.00639684
-0.0418091
-0.0785947
-0.122713
-0.155348
-0.162176
-0.13082
-0.108838
-0.0667236
0.0080655
0.0983812
0.135156
0.571812
-0.109119
-0.0803473
-0.944312
100.389
112.625
113.92
114.473
111.01
106.028
100.934
100.879
95.3055
0.0728887
0.0687222
0.0598172
0.0440714
0.0198734
-0.0112915
-0.0454528
-0.0801079
-0.120301
-0.153466
-0.158447
-0.128132
-0.102359
-0.0620915
0.017019
0.0944218
0.136699
0.316887
-0.100877
-0.0903043
5.35946
100.341
113.007
114.102
114.751
111.14
106.03
100.636
43.1882
-0.336224
0.0657993
0.0613258
0.0517924
0.0354021
0.0113184
-0.0185116
-0.0504017
-0.0814345
-0.115629
-0.146007
-0.15093
-0.123439
-0.0955069
-0.0567583
0.00346449
0.0806099
0.136019
0.2774
-0.056782
-0.0820211
0.423234
99.5648
113.424
114.288
115.063
111.283
106.041
27.1544
4.81544
-0.332236
0.0579494
0.0531253
0.0428888
0.0257001
0.00158575
-0.0267498
-0.0556764
-0.0817259
-0.108497
-0.134669
-0.140528
-0.116902
-0.0883688
-0.0509953
0.00338943
0.0627641
0.137583
0.268387
0.228876
-0.100071
-0.169778
92.6859
113.887
114.466
115.37
111.133
81.9535
22.9849
0.326698
0.160024
0.0490774
0.0440689
0.0333361
0.0157622
-0.00794823
-0.0345297
-0.0603943
-0.0810102
-0.0997319
-0.121417
-0.128642
-0.108939
-0.0809926
-0.0452008
0.00436973
0.0565005
0.135162
0.196707
0.249981
-0.130713
-0.0647598
39.6993
114.328
114.812
116.123
110.401
71.282
1.11012
0.109968
-0.0192171
0.0394848
0.0344211
0.0235727
0.00604574
-0.0167553
-0.0413532
-0.0643451
-0.0802083
-0.0899491
-0.104092
-0.110545
-0.0999994
-0.0734128
-0.0396752
0.00546797
0.0553366
0.116205
0.16353
0.305715
-0.146841
-0.033426
1.8522
114.396
114.972
116.578
105.798
21.6711
0.030258
0.119165
-0.0305112
0.0299702
0.0249797
0.0143836
-0.00252496
-0.0240959
-0.0466819
-0.0669041
-0.0568325
-0.0630042
-0.0786118
-0.104368
-0.090097
-0.0656806
-0.0346059
0.0060453
0.043665
0.0955277
0.136591
-0.058071
-0.1631
-0.0331984
-0.166127
93.3357
114.935
117.02
72.5078
0.356214
0.0231897
0.128945
-0.0380497
0.0217115
0.0169754
0.00697734
-0.0088611
-0.0288825
-0.0493754
-0.0668693
-0.0773154
-0.0759789
-0.0827586
-0.0918715
-0.0786755
-0.0578532
-0.0300085
0.00585447
0.0347199
0.0766762
0.120228
-0.0583905
-0.176674
-0.0398202
-0.125697
-0.0391636
78.546
107.263
5.28303
0.0298605
0.0355598
0.183857
0.0443649
0.0161003
0.0117985
0.00267516
-0.0117995
-0.0299654
-0.0483936
-0.0630482
-0.070731
-0.0739992
-0.0750497
-0.0771953
-0.0678157
-0.0499792
-0.025829
0.00492381
0.0293584
0.0605912
0.0553086
-0.0903563
-0.172965
-0.0426631
-0.100259
-0.0203356
-0.0183946
0.0693502
0.0731441
0.0249389
0.00770472
0.118433
0.0235118
0.0143772
0.0105488
0.00251204
-0.0102483
-0.0264717
-0.0428348
-0.0555314
-0.0613896
-0.0627602
-0.0633422
-0.0634384
-0.056285
-0.0421049
-0.0220994
0.00336013
0.0249865
0.0494676
0.0383711
-0.0600814
-0.190949
-0.0434742
-0.0778537
-0.0207033
-0.019525
0.000645695
0.116852
0.0218544
-0.0536261
0.152708
-0.0674211
0.0171811
0.0138848
0.00700577
-0.00389817
-0.0178925
-0.0322825
-0.043516
-0.0489367
-0.0492974
-0.0503612
-0.0496873
-0.0446763
-0.0342766
-0.018913
0.00102771
0.0197194
0.0343092
0.0264992
-0.0654686
-0.161802
-0.0438744
-0.0591616
-0.0200342
-0.0210556
-0.000906918
0.0331911
-0.0123375
-0.164077
0.0597034
-0.0607742
0.0240295
0.0213275
0.0156756
0.00660212
-0.00517607
-0.0175096
-0.027634
-0.0329053
-0.0349559
-0.0364235
-0.036043
-0.0331456
-0.0265648
-0.0164575
-0.00239964
0.0129664
0.0247624
0.0361841
-0.0731789
-0.153499
-0.0430352
-0.0441916
-0.018669
-0.0207682
-0.00093601
0.0257199
0.00170391
-0.154575
0.0529125
-0.052349
0.0331387
0.0309717
0.0263556
0.0190262
0.00953802
-0.000873192
-0.00965634
-0.0159667
-0.0200908
-0.0219495
-0.0225566
-0.0217716
-0.0191464
-0.0155595
-0.00757796
0.00447345
0.0152526
0.0313474
-0.0543339
0.0834565
-0.0398113
-0.0331005
-0.0173392
-0.0198458
-0.000983931
0.0190099
-0.0215847
-0.136685
0.0422814
-0.0437364
0.0417446
0.0401106
0.0364573
0.0311953
0.0235214
0.0151733
0.00655908
-0.000836644
-0.00544398
-0.00808216
-0.00950449
-0.0107603
-0.0125363
-0.017522
-0.0157908
-0.00618513
0.00676371
0.0271533
-0.0417255
-0.0753568
-0.0348837
-0.0253773
-0.0166458
-0.0183834
-0.000960034
0.0242649
-0.0197784
-0.117357
0.0333204
-0.0358612
0.0471805
0.0461505
0.0432758
0.0386197
0.0324326
0.0253721
0.0176968
0.0111606
0.00639344
0.00379068
0.00232663
-0.000531104
-0.00772044
-0.0236676
-0.0289631
-0.0205752
-0.00496819
0.0229694
-0.0332775
-0.0620301
-0.0309236
-0.0202418
-0.0163398
-0.0165138
-0.000959284
0.0123798
-0.0177307
-0.0982478
0.0252658
-0.0289032
0.0476641
0.0468782
0.0449258
0.0415835
0.0367588
0.0308085
0.0244008
0.0183715
0.0137591
0.0116936
0.0111614
0.0510946
0.0775412
-0.0275077
-0.0439185
-0.0399418
-0.01803
0.0101676
-0.0255314
-0.040978
-0.0270748
-0.0167704
-0.0159372
-0.014432
-0.00105137
0.00814189
-0.01568
-0.0814588
0.018249
-0.0228788
0.0457165
0.0451995
0.0437267
0.041128
0.0373158
0.0324086
0.0267542
0.020897
0.0155675
0.0118451
0.0872642
0.0925257
0.0878878
-0.0417886
-0.0332289
-0.0633755
-0.0350739
0.0102414
-0.0135353
-0.0296727
-0.0231709
-0.014239
-0.0150754
-0.0123023
-0.00124525
0.00483687
-0.0138424
-0.0670196
0.0123164
-0.0177835
0.0424013
0.0420107
0.0408625
0.0388023
0.0357107
0.0315483
0.0263774
0.0203039
0.0132085
0.00305453
0.101961
0.0771461
-0.0222133
-0.0495515
-0.0493168
-0.0809001
-0.0533248
-0.0129766
0.0286945
-0.0243568
-0.0192833
-0.0121679
-0.0136239
-0.0102684
-0.00152289
0.00231497
-0.0122904
-0.0547421
0.00722212
-0.0135904
0.0388616
0.0385043
0.0375663
0.0359115
0.0333944
0.0298856
0.0252727
0.0193382
0.0129419
0.00105261
0.114279
-0.0100989
-0.0311421
-0.0591532
-0.0624281
-0.0779391
-0.064688
-0.0348748
-0.0203438
-0.0195969
-0.0152293
-0.0103475
-0.0116902
-0.0084188
-0.00183665
0.000386591
-0.0110458
-0.0444025
0.00308588
-0.0102497
0.035628
0.0352713
0.0344711
0.0331278
0.0311219
0.0283223
0.0245822
0.0196788
0.013809
0.00601633
-0.0062278
-0.0168196
-0.0286654
-0.0510566
-0.0490465
-0.0667339
-0.0735908
-0.0190663
0.000607838
-0.0137016
-0.0107308
-0.00839206
-0.00945109
-0.00680326
-0.00212815
-0.00109271
-0.0100748
-0.0357692
-0.00027259
-0.0076853
0.0321671
0.031889
0.0313071
0.0303333
0.0288699
0.0268106
0.0240323
0.0203608
0.015477
0.00912054
0.00297203
-0.00744473
-0.0194455
-0.0357008
-0.0734491
-0.0753325
-0.0712963
-0.00274617
-0.000611313
-0.00627117
-0.00578945
-0.0060386
-0.0071185
-0.00542636
-0.00235058
-0.00220147
-0.00929221
-0.0286102
-0.00290396
-0.00579034
0.0287301
0.0284712
0.027991
0.0272479
0.0261888
0.0247388
0.0227925
0.0202073
0.0167721
0.0121696
0.00637531
-0.000560565
-0.0113681
-0.0248142
-0.0554244
-0.0677391
-0.0638054
-0.00906611
0.00643428
0.00116786
-0.00122689
-0.00344584
-0.00495247
-0.00426299
-0.00247799
-0.00297399
-0.00859272
-0.0227143
-0.00473954
-0.00443592
0.0250223
0.0247654
0.0243384
0.0237459
0.0229573
0.021906
0.0204953
0.0186032
0.0160741
0.0127026
0.0082943
0.00240018
-0.00626985
-0.0192347
-0.0384773
-0.0557261
-0.0446788
0.00939317
0.0134872
0.00693494
0.00235075
-0.00107932
-0.0031309
-0.0032889
-0.00250483
-0.00343127
-0.00790048
-0.0178972
-0.00580331
-0.00348131
0.0206383
0.0205116
0.0202748
0.019905
0.0193574
0.0185724
0.0174824
0.0160065
0.0140393
0.0114432
0.00804638
0.00356533
-0.00245981
-0.0104773
-0.019937
-0.0267272
-0.00561592
0.0215054
0.0159558
0.0100021
0.00467127
0.000742489
-0.00169212
-0.00248654
-0.00243965
-0.00360175
-0.00716636
-0.0139903
-0.00622816
-0.002787
0.016304
0.0162782
0.0161776
0.01596
0.0155833
0.0150049
0.0141811
0.0130616
0.0115817
0.00965834
0.00719488
0.00409102
0.000299506
-0.00397737
-0.00758914
-0.00732364
0.00258159
0.0147056
0.0149558
0.0104763
0.00574746
0.00190921
-0.000652056
-0.0018487
-0.00229804
-0.00353076
-0.00635536
-0.0108301
-0.00605076
-0.00223508
0.0124649
0.0124916
0.0124532
0.012303
0.0120241
0.0116053
0.0110206
0.0102323
0.00919753
0.00787259
0.00622165
0.00424164
0.00203027
-8.58598e-05
-0.00121396
0.000115121
0.0057658
0.0114285
0.0120948
0.00940818
0.00577759
0.00244432
-6.8002e-07
-0.00137026
-0.00210272
-0.00327563
-0.00545747
-0.00825981
-0.00537108
-0.00176202
0.00912284
0.00919556
0.00922031
0.00913652
0.00893818
0.00864341
0.00825159
0.00773521
0.00706093
0.00620887
0.00517955
0.00400618
0.00278581
0.00178917
0.0015102
0.00260917
0.00542554
0.00829398
0.00900733
0.00759447
0.00507575
0.00243454
0.000298925
-0.00104775
-0.00187497
-0.00288872
-0.00449086
-0.00614112
-0.00440238
-0.00133351
0.00629871
0.00635829
0.00639853
0.00637314
0.0062686
0.00609589
0.00586138
0.00555015
0.00513929
0.00462199
0.00401662
0.00336389
0.002736
0.00228293
0.00224824
0.00289169
0.00419628
0.00573894
0.00630793
0.00555067
0.00392442
0.00198913
0.000285498
-0.000894209
-0.00163814
-0.00241137
-0.00348057
-0.00435557
-0.00330099
-0.000939474
0.00389443
0.00390271
0.00390618
0.00389714
0.00386445
0.00379969
0.0036942
0.00353516
0.00331106
0.00302406
0.00269549
0.00236119
0.00206647
0.00187858
0.00189507
0.00221708
0.00284621
0.00358263
0.00384977
0.00347839
0.00250047
0.0012116
-2.42445e-06
-0.000878748
-0.00140987
-0.00187413
-0.00244393
-0.00279523
-0.00215164
-0.00057781
0.00166543
0.00165416
0.00163973
0.00163098
0.0016266
0.00161624
0.00158708
0.00153
0.00144229
0.00132775
0.00119807
0.00107111
0.000969986
0.00091298
0.000927402
0.00104478
0.00127025
0.00151572
0.00160789
0.00141181
0.000895571
0.00017897
-0.000514648
-0.000990548
-0.00120408
-0.00129826
-0.00138408
-0.00135396
-0.000984677
-0.000239084
107.856
111.343
116.784
119.192
117.895
115.532
112.981
110.445
108.137
106.279
104.966
104.078
103.441
103.02
102.907
103.182
103.845
104.814
105.96
107.153
108.29
109.304
110.162
110.855
111.394
111.795
112.079
112.265
112.374
112.423
107.843
111.328
116.809
119.229
117.908
115.535
112.98
110.435
108.114
106.244
104.927
104.039
103.398
102.97
102.848
103.118
103.784
104.762
105.922
107.132
108.285
109.314
110.182
110.885
111.43
111.836
112.122
112.311
112.422
112.471
107.808
111.3
116.851
119.295
117.93
115.543
112.98
110.421
108.077
106.187
104.861
103.974
103.328
102.885
102.749
103.011
103.68
104.67
105.849
107.08
108.253
109.297
110.178
110.889
111.439
111.847
112.135
112.325
112.436
112.485
107.752
111.256
116.911
119.39
117.962
115.556
112.984
110.404
108.027
106.106
104.77
103.884
103.23
102.766
102.608
102.858
103.529
104.536
105.74
106.997
108.195
109.258
110.152
110.87
111.423
111.833
112.12
112.309
112.419
112.469
107.675
111.198
116.99
119.515
118.003
115.572
112.99
110.385
107.964
106.002
104.651
103.768
103.103
102.611
102.423
102.655
103.328
104.355
105.589
106.879
108.105
109.191
110.099
110.826
111.383
111.794
112.081
112.269
112.379
112.427
107.577
111.125
117.086
119.67
118.051
115.593
113
110.363
107.887
105.874
104.505
103.628
102.949
102.42
102.193
102.398
103.07
104.121
105.39
106.718
107.979
109.091
110.017
110.754
111.316
111.728
112.016
112.204
112.312
112.361
107.457
111.035
117.203
119.858
118.107
115.617
113.013
110.339
107.797
105.721
104.331
103.462
102.767
102.191
101.913
102.082
102.75
103.828
105.137
106.51
107.811
108.954
109.901
110.65
111.218
111.633
111.921
112.108
112.217
112.265
107.315
110.928
117.339
120.079
118.169
115.645
113.029
110.314
107.693
105.542
104.127
103.272
102.558
101.922
101.582
101.701
102.359
103.467
104.822
106.245
107.594
108.775
109.746
110.509
111.085
111.502
111.791
111.978
112.086
112.134
107.151
110.802
117.497
120.337
118.235
115.677
113.05
110.288
107.574
105.334
103.894
103.06
102.321
101.612
101.194
101.248
101.887
103.029
104.432
105.913
107.32
108.546
109.547
110.327
110.911
111.331
111.62
111.807
111.913
111.96
106.966
110.656
117.676
120.632
118.305
115.711
113.075
110.261
107.441
105.096
103.629
102.825
102.057
101.258
100.745
100.713
101.321
102.502
103.953
105.5
106.978
108.26
109.296
110.096
110.69
111.113
111.401
111.586
111.691
111.738
106.758
110.489
117.877
120.969
118.375
115.749
113.105
110.236
107.292
104.826
103.331
102.57
101.767
100.857
100.23
100.084
100.643
101.869
103.361
104.985
106.553
107.905
108.985
109.81
110.415
110.84
111.127
111.31
111.413
111.458
106.528
110.299
118.102
121.348
118.445
115.789
113.14
110.211
107.128
104.521
102.999
102.298
101.452
100.406
99.6391
99.3437
99.8317
101.113
102.626
104.341
106.027
107.469
108.604
109.46
110.077
110.505
110.788
110.965
111.065
111.109
106.276
110.084
118.35
121.775
118.51
115.831
113.181
110.19
106.947
104.181
102.631
102.01
101.112
99.8999
98.9642
98.4702
98.8618
100.209
101.698
103.528
105.379
106.939
108.143
109.041
109.671
110.1
110.379
110.548
110.639
110.676
106.002
109.842
118.621
122.253
118.567
115.875
113.229
110.172
106.748
103.8
102.224
101.711
100.749
99.3353
98.1998
97.4393
97.7028
99.1099
100.504
102.488
104.585
106.298
107.593
108.538
109.193
109.619
109.883
110.038
110.12
110.153
105.705
109.57
118.916
122.784
118.614
115.92
113.284
110.161
106.53
103.374
101.775
101.405
100.362
98.7047
97.3496
96.2532
96.3229
97.7125
98.9312
101.14
103.617
105.52
106.94
107.963
108.638
109.049
109.29
109.419
109.492
109.526
105.386
109.267
119.232
123.374
118.646
115.967
113.346
110.157
106.293
102.895
101.281
101.094
99.9486
97.9991
96.4072
94.9897
94.7826
95.7004
96.8069
99.3946
102.434
104.57
106.191
107.289
107.985
108.392
108.607
108.7
108.728
108.733
105.045
108.93
119.569
124.026
118.658
116.015
113.416
110.164
106.034
102.358
100.735
100.784
99.5036
97.214
95.3769
93.6664
92.9107
92.9781
94.0548
97.209
100.994
103.47
105.345
106.535
107.275
107.639
107.786
107.833
107.822
107.802
104.681
108.556
119.92
124.741
118.645
116.063
113.496
110.185
105.753
101.754
100.129
100.477
99.0126
96.3262
94.2458
92.2385
90.7057
90.7313
90.8503
94.6818
99.3641
102.204
104.4
105.728
106.474
106.758
106.819
106.78
106.736
106.711
104.296
108.144
120.279
125.52
118.601
116.113
113.584
110.221
105.446
101.071
99.4503
100.177
98.4524
95.3106
92.9151
90.826
87.5636
86.4195
85.0338
90.2034
96.8098
100.552
103.309
104.864
105.621
105.819
105.732
105.541
105.419
105.369
103.889
107.69
120.633
126.361
118.52
116.164
113.681
110.279
105.113
100.295
98.682
99.8858
97.788
94.102
91.6837
89.7867
84.08
78.8178
75.9876
82.6689
92.2342
98.2475
102.035
104.043
104.789
104.849
104.515
104.071
103.782
103.667
103.462
107.192
120.961
127.254
118.397
116.217
113.788
110.361
104.751
99.4074
97.8048
99.6026
97.0259
92.5205
90.2876
87.5749
81.0804
72.129
67.915
75.9381
86.4102
95.7583
100.804
103.098
103.797
103.673
103.049
102.288
101.738
101.502
103.013
106.649
121.232
128.185
118.223
116.272
113.903
110.474
104.359
98.3854
96.797
99.3219
96.1317
90.746
89.2445
85.0178
78.2709
67.06
62.3087
73.8486
84.1063
93.8573
99.2451
101.642
102.405
102.073
101.175
100.101
99.272
98.8499
102.546
106.06
121.401
129.123
117.993
116.333
114.025
110.625
103.939
97.2254
95.6596
99.0178
94.9564
89.1685
87.2433
82.5973
77.041
37.3872
27.2259
70.6748
84.8544
92.9401
97.6178
99.8355
100.727
100.163
98.932
97.5373
96.3689
95.6773
102.059
105.423
121.4
130.019
117.701
116.4
114.152
110.82
103.498
95.9803
94.5711
98.6456
93.4252
87.1438
84.9729
81.2718
27.8838
0.0864983
0.169361
16.6786
85.2898
93.112
96.6504
98.6655
99.2847
98.6485
97.0373
94.9089
92.8932
91.6678
101.555
104.741
121.138
130.791
117.34
116.477
114.281
111.068
103.05
94.6136
93.8349
98.2241
91.7074
85.1773
80.765
5.78757
0.010864
0.0632348
0.11732
0.114126
36.0503
93.6698
97.6491
97.9678
98.0014
97.9425
96.1404
92.4152
88.3648
85.7339
101.035
104.016
120.488
131.319
116.909
116.568
114.409
111.376
102.622
92.8045
93.2159
98.3667
90.0013
64.2373
0.0909557
-0.0240696
-0.0145703
0.0228946
0.0585057
0.0347557
-0.00513811
30.3909
97.3004
98.0408
96.9163
97.3841
95.4333
89.564
81.8278
76.5175
100.5
103.253
119.283
131.428
116.404
116.678
114.528
111.75
102.276
90.3039
91.4384
99.6639
70.6021
0.0639086
0.0609446
-0.0144448
-0.0418501
-0.0279635
-0.000909256
-0.0398867
-0.0798149
-0.0589182
0.571155
9.87727
20.4033
24.5664
18.7299
9.40372
3.88188
2.05941
99.9519
102.458
117.3
130.875
115.828
116.812
114.631
112.188
102.135
87.2811
90.4529
97.2785
0.0244447
0.0552062
0.0481034
-0.00746311
-0.0537504
-0.0570485
-0.040411
-0.0911382
-0.0920677
-0.0777967
-0.0317526
0.00829411
0.0419729
0.0735668
0.0882152
0.106167
0.119163
0.124638
99.3931
101.642
114.253
129.334
115.184
116.977
114.708
112.68
102.434
84.5037
23.0891
-0.270751
0.0218299
0.0483374
0.0368611
-0.0134695
-0.0590263
-0.064059
-0.0605384
-0.110865
-0.0975359
-0.0696726
-0.0487973
-0.0273116
0.00222905
0.0325105
0.0571278
0.0770747
0.0905191
0.0969649
98.8211
100.816
109.765
126.37
114.474
117.176
114.744
113.199
103.632
56.1943
0.141855
-0.2012
0.012409
0.0445532
0.0295409
-0.0149862
-0.0573958
-0.0605348
-0.0684783
-0.111796
-0.0998782
-0.0709403
-0.0457497
-0.0255746
0.000698126
0.0285505
0.0517463
0.0681453
0.0780584
0.0831565
112.426
112.387
112.294
112.13
111.878
111.518
111.027
110.388
109.587
108.623
107.516
106.314
105.106
104.009
103.16
102.663
102.555
102.773
103.184
103.707
104.409
105.394
106.583
107.678
108.274
108.013
106.771
104.834
102.867
101.399
112.474
112.435
112.34
112.175
111.92
111.556
111.06
110.413
109.602
108.625
107.502
106.283
105.059
103.951
103.096
102.602
102.502
102.73
103.148
103.673
104.377
105.371
106.574
107.681
108.284
108.024
106.778
104.835
102.864
101.394
112.488
112.449
112.354
112.188
111.932
111.565
111.065
110.412
109.591
108.599
107.458
106.219
104.974
103.851
102.989
102.5
102.414
102.659
103.09
103.616
104.324
105.335
106.562
107.691
108.305
108.044
106.79
104.834
102.857
101.382
112.472
112.432
112.338
112.172
111.917
111.549
111.047
110.388
109.557
108.549
107.386
106.121
104.85
103.706
102.836
102.354
102.289
102.56
103.008
103.537
104.25
105.285
106.548
107.708
108.337
108.074
106.805
104.831
102.845
101.365
112.43
112.391
112.297
112.132
111.877
111.509
111.004
110.339
109.496
108.469
107.279
105.983
104.68
103.511
102.633
102.161
102.126
102.433
102.905
103.435
104.154
105.223
106.533
107.733
108.38
108.113
106.825
104.826
102.829
101.341
112.364
112.324
112.231
112.066
111.811
111.442
110.934
110.261
109.403
108.354
107.132
105.799
104.459
103.26
102.373
101.919
101.923
102.277
102.779
103.311
104.036
105.146
106.516
107.766
108.434
108.161
106.848
104.819
102.808
101.31
112.268
112.228
112.135
111.97
111.715
111.344
110.831
110.149
109.274
108.199
106.94
105.563
104.18
102.947
102.053
101.621
101.677
102.091
102.631
103.163
103.895
105.055
106.498
107.807
108.5
108.219
106.876
104.81
102.783
101.273
112.136
112.097
112.004
111.84
111.584
111.211
110.693
110
109.105
107.998
106.695
105.267
103.835
102.562
101.665
101.264
101.385
101.874
102.463
102.992
103.729
104.948
106.479
107.857
108.579
108.287
106.909
104.799
102.752
101.23
111.962
111.924
111.832
111.668
111.412
111.038
110.514
109.808
108.889
107.744
106.388
104.898
103.413
102.096
101.2
100.84
101.045
101.626
102.274
102.797
103.537
104.825
106.458
107.917
108.669
108.365
106.945
104.785
102.717
101.18
111.741
111.702
111.61
111.448
111.193
110.817
110.287
109.566
108.619
107.427
106.005
104.443
102.901
101.537
100.648
100.344
100.651
101.345
102.066
102.577
103.316
104.686
106.437
107.986
108.773
108.453
106.986
104.768
102.677
101.123
111.459
111.422
111.333
111.173
110.92
110.544
110.006
109.267
108.286
107.036
105.53
103.879
102.28
100.865
99.9967
99.7689
100.2
101.03
101.84
102.333
103.065
104.53
106.414
108.067
108.89
108.552
107.031
104.748
102.632
101.059
111.111
111.074
110.987
110.831
110.583
110.208
109.663
108.903
107.877
106.556
104.939
103.177
101.523
100.065
99.2327
99.1101
99.6888
100.679
101.599
102.063
102.781
104.345
106.391
108.159
109.022
108.661
107.08
104.725
102.581
100.988
110.676
110.644
110.565
110.419
110.178
109.804
109.252
108.463
107.381
105.97
104.202
102.293
100.589
99.118
98.3405
98.3646
99.1122
100.29
101.343
101.769
102.46
104.136
106.369
108.263
109.167
108.781
107.134
104.697
102.525
100.909
110.153
110.123
110.052
109.918
109.69
109.33
108.765
107.941
106.786
105.262
103.28
101.165
99.4055
98.0131
97.2955
97.53
98.4663
99.8611
101.077
101.451
102.098
103.901
106.347
108.382
109.329
108.912
107.192
104.665
102.464
100.824
109.527
109.497
109.429
109.314
109.116
108.769
108.207
107.338
106.075
104.413
102.136
99.6942
97.8463
96.7171
96.0632
96.6096
97.745
99.388
100.801
101.11
101.691
103.637
106.326
108.515
109.506
109.055
107.254
104.628
102.396
100.73
108.729
108.716
108.69
108.618
108.453
108.123
107.552
106.639
105.227
103.354
100.717
97.714
95.6655
95.0064
94.6364
95.5792
96.9419
98.8678
100.519
100.752
101.232
103.339
106.309
108.665
109.7
109.209
107.32
104.586
102.322
100.629
107.795
107.799
107.809
107.781
107.671
107.408
106.833
105.843
104.278
102.072
98.9845
95.1473
92.9308
92.854
92.9206
94.338
96.0441
98.2971
100.233
100.381
100.713
103.003
106.295
108.833
109.911
109.375
107.391
104.537
102.242
100.521
106.706
106.716
106.742
106.778
106.761
106.582
106.053
104.984
103.194
100.62
97.0486
91.9864
90.4354
90.6815
90.9964
92.8803
95.0277
97.6752
99.9397
100.004
100.127
102.623
106.288
109.02
110.141
109.553
107.467
104.481
102.156
100.405
105.36
105.391
105.466
105.625
105.776
105.706
105.221
104.011
101.843
98.5812
93.6516
86.1423
85.4963
87.5503
88.8323
91.5324
93.9115
97.0021
99.6294
99.6314
99.4606
102.19
106.29
109.229
110.39
109.744
107.546
104.417
102.062
100.281
103.651
103.721
103.92
104.303
104.719
104.84
104.449
103.008
100.126
95.2207
87.1573
78.1461
76.3878
81.779
86.9821
90.1253
92.5414
96.2863
99.2694
99.2678
98.6983
101.696
106.303
109.462
110.659
109.947
107.63
104.344
101.962
100.15
101.472
101.618
102.009
102.713
103.449
103.825
103.523
101.942
98.4169
91.3619
80.4576
70.9307
67.8076
76.876
84.0488
89.2198
91.3106
95.4956
98.7938
98.9094
97.8172
101.127
106.334
109.72
110.95
110.163
107.719
104.261
101.854
100.013
98.7879
99.0477
99.7091
100.723
101.782
102.424
102.178
100.541
96.4327
88.7364
78.3627
68.807
59.2997
73.2419
80.5769
87.9323
89.9437
94.5131
98.0863
98.5273
96.7858
100.469
106.386
110.007
111.263
110.392
107.811
104.167
101.74
99.8693
95.5589
96.0048
97.0071
98.3618
99.778
100.762
100.665
98.8253
94.9874
88.7805
77.8321
55.8297
9.23472
70.2987
77.9975
85.8938
88.4568
92.9722
96.9391
98.069
95.5861
99.7016
106.47
110.323
111.599
110.634
107.908
104.06
101.618
99.7208
91.4514
92.2295
93.9877
96.1875
98.1957
99.489
99.6519
97.8816
94.9112
88.4058
64.397
0.254539
0.185686
0.0266202
63.7202
83.6302
87.6565
91.2642
95.0712
97.4973
94.3512
98.7962
106.594
110.671
111.96
110.889
108.009
103.938
101.489
99.5688
85.231
86.874
90.4547
94.6592
97.6764
98.6125
99.133
98.3699
96.3655
82.2146
0.24827
0.101338
0.12955
0.0198683
-0.0368942
49.3078
85.6545
89.0984
92.3673
97.0401
93.3765
97.7077
106.773
111.052
112.347
111.155
108.114
103.8
101.353
99.4153
75.5148
78.9367
86.09
93.1144
97.2951
97.3844
100.026
99.7736
76.876
0.198427
-0.00342358
0.0402014
0.0361255
-0.0273897
-0.0360963
0.0930031
26.7873
86.6466
88.5884
97.319
92.4918
96.3246
107.02
111.467
112.762
111.433
108.223
103.644
101.21
99.263
1.89975
3.06754
7.18941
16.442
27.8078
28.7035
22.6947
4.26703
0.211184
-0.125176
-0.0586354
-0.041926
-0.0594165
-0.0818427
-0.0427384
0.0725767
0.121591
15.9727
84.6766
98.7156
90.459
94.4545
107.348
111.914
113.207
111.722
108.335
103.468
101.063
99.1154
0.12698
0.125694
0.118371
0.103052
0.0880461
0.0632255
0.0356355
-0.0566951
-0.0958753
-0.136804
-0.120222
-0.10214
-0.111446
-0.0982177
-0.0188437
0.0607535
0.124667
0.148538
7.84994
99.1785
88.0323
91.9963
107.791
112.389
113.684
112.021
108.451
103.269
100.911
98.9769
0.0983799
0.0950414
0.0859349
0.0694166
0.0467174
0.0145305
-0.0236248
-0.06805
-0.0995386
-0.1386
-0.150501
-0.132234
-0.12643
-0.112627
-0.0192088
0.0533111
0.122844
0.152994
0.544277
27.5153
82.2523
88.9446
108.418
112.885
114.196
112.328
108.57
103.044
100.756
98.8539
0.084344
0.0818601
0.0751936
0.0627277
0.0421453
0.013277
-0.0222126
-0.0598209
-0.098442
-0.144673
-0.163345
-0.146557
-0.123654
-0.0993742
-0.034215
0.041976
0.125775
0.346399
0.562745
-0.192333
-0.2077
84.6354
109.316
113.39
114.747
112.643
108.691
102.79
100.601
98.7653
98.2936
100.301
105.761
124.223
113.992
117.324
114.735
113.519
105.209
10.9793
0.111665
-0.171233
0.0423852
0.0445109
0.0264454
-0.0135515
-0.0519002
-0.056538
-0.0689642
-0.105647
-0.0953586
-0.0686266
-0.0469666
-0.0293398
-0.00447207
0.0225676
0.0455242
0.0614105
0.0709371
0.0758072
0.0650649
2.34368
78.8401
115.492
113.557
117.464
114.703
113.772
105.708
-1.33104
0.111883
0.0115276
0.238844
0.043378
0.0244413
-0.0117251
-0.0465606
-0.0530266
-0.0678065
-0.0985856
-0.0895286
-0.0661422
-0.0487868
-0.0334595
-0.0101562
0.0157872
0.0382601
0.0541725
0.0639227
0.0689211
0.0712716
-0.0177224
18.0521
100.419
113.3
117.631
114.636
114.027
110.097
-0.160247
0.112676
0.274898
0.0993021
0.0417827
0.0238248
-0.00910854
-0.0406892
-0.0492005
-0.0652216
-0.0903809
-0.0815723
-0.06283
-0.0502564
-0.0380868
-0.017055
0.00731934
0.0294657
0.0459261
0.056267
0.0615416
-0.136561
0.0128502
5.97151
90.3787
112.857
117.812
115.14
114.249
92.1423
0.147109
0.0807915
0.317034
0.0925195
0.0391833
0.0204509
-0.00615333
-0.0347029
-0.045045
-0.0613847
-0.082228
-0.0724505
-0.0587073
-0.0515674
-0.0430635
-0.0242265
-0.00146903
0.0202368
0.0370502
0.0478133
0.0532442
-0.0630034
0.307842
-0.0862418
34.5016
111.58
118.029
114.835
114.439
4.07554
0.108571
0.0605955
0.344986
0.0751675
0.0349393
0.0184343
-0.00333844
-0.0287821
-0.0405636
-0.0564757
-0.0713209
-0.0476673
-0.0512218
-0.0535653
-0.0481171
-0.0307691
-0.00971849
0.011081
0.0277878
0.0386413
0.0440338
0.0472647
-0.108912
-0.0760685
1.15966
101.104
118.189
114.337
107.599
-0.254663
0.0788849
0.00803158
0.00862434
0.0575275
0.0293408
0.0195565
-0.000777541
-0.0233471
-0.0357918
-0.0505303
-0.0646061
-0.0440806
-0.0359131
-0.0185331
-0.0494619
-0.0362632
-0.0170936
0.0024888
0.0186406
0.0292403
0.0344664
0.0217749
-0.110994
-0.0595923
-0.0648894
48.7461
117.72
111.694
8.2484
-0.169104
0.0584087
-0.0136545
0.00203174
0.0363476
0.0222877
0.0196236
0.000679949
-0.0186648
-0.0308094
-0.0436828
-0.0543415
-0.0521132
-0.0423341
-0.0393677
-0.0461768
-0.0391633
-0.0225791
-0.00456559
0.0105801
0.0205872
0.0255189
0.00917817
-0.113191
-0.0865431
-0.0743355
0.0584815
72.1349
4.45336
0.0109136
-0.143695
0.0427422
-0.0366821
-0.0494569
0.014151
0.0226437
0.0206119
0.000773017
-0.0148234
-0.0256948
-0.0365182
-0.0446144
-0.044057
-0.0416382
-0.0416873
-0.0457684
-0.0391862
-0.0251081
-0.00892131
0.00486825
0.0140193
0.0184903
0.00715142
-0.11716
-0.0892835
-0.0771606
0.060599
0.0213221
-0.00122934
-0.00201645
-0.110228
0.0316214
-0.00817768
-0.0523656
-0.00865482
0.0576822
0.00840039
0.000356915
-0.0117943
-0.0205325
-0.0288064
-0.0348074
-0.0344909
-0.0357326
-0.0384562
-0.0413122
-0.0359588
-0.0237903
-0.00950447
0.0027129
0.0108182
0.0147555
0.00873228
-0.122428
-0.056077
-0.0726912
0.0474902
-0.00340602
-0.00613415
-0.00941323
-0.0823829
0.0245429
0.238092
-0.0734604
-0.0337925
0.0438614
-0.00147595
-0.000939735
-0.00965212
-0.0154379
-0.0207469
-0.0250848
-0.0268472
-0.0276956
-0.0318094
-0.0334731
-0.0284957
-0.0179487
-0.0056044
0.0049044
0.011869
0.0152801
-0.000844587
-0.127378
-0.0637043
-0.0699199
0.0368473
-0.00428956
-0.0118721
-0.0130015
-0.0597719
0.0187504
-0.00710042
-0.102204
-0.0531645
0.0209776
-0.00838909
-0.00353967
-0.00875122
-0.0106341
-0.0123309
-0.0152271
-0.017331
-0.0188764
-0.0209494
-0.0220221
-0.0170867
-0.00789415
0.00258187
0.0114286
0.0172792
0.0201888
0.00295347
-0.0358053
-0.0985245
-0.0715561
0.0270659
-0.00457782
-0.0134222
-0.0130647
-0.0414872
0.014505
-0.00216735
-0.0914517
-0.0548026
4.74497e-05
-0.0147329
-0.00763506
-0.00986254
-0.00667497
-0.00363356
-0.00534391
-0.00725307
-0.0089293
-0.00890453
-0.00806829
-0.00330466
0.00463388
0.0134017
0.0208331
0.0258001
0.0283334
-0.00188156
0.00391821
-0.0941639
-0.0667399
0.0183577
-0.00492252
-0.0135524
-0.0114769
-0.0267092
0.0119414
-0.00399359
-0.0618137
-0.00708753
-0.00942499
-0.0295238
-0.0136917
-0.0142824
-0.00496294
0.00464436
0.00378626
0.00231877
0.0012938
0.00194707
0.00573162
0.0113409
0.0175546
0.0243882
0.0306537
0.0349778
0.0373218
-0.00251243
0.0138477
-0.0373997
-0.0610266
0.0109247
-0.0049891
-0.0126102
-0.00938067
-0.0154129
0.010738
-0.00438814
-0.0489744
-0.0310161
-0.0680478
-0.0371227
-0.022154
-0.00574947
0.137421
0.0809148
0.010098
0.00965132
0.00907053
0.0106498
0.0145202
0.0203899
0.026757
0.0332026
0.0388942
0.0425232
0.0445184
-0.00296103
-0.0323599
-0.0997015
-0.0553309
0.00448116
-0.00491596
-0.0108227
-0.00719649
-0.00747234
0.0103871
-0.00310799
-0.0291028
-0.0422393
-0.0885568
-0.0472848
-0.0324543
-0.0125935
-0.0178971
0.102326
0.101691
0.0131416
0.0120598
0.0148434
0.0196849
0.0256292
0.0318785
0.0375142
0.0420092
0.0452623
0.0470779
-0.00316588
-0.0563593
-0.0935172
-0.0499981
-0.000717064
-0.00485714
-0.00872554
-0.00512065
-0.00161358
0.0107049
0.000115057
-0.0323583
-0.0674301
-0.0902063
-0.0625887
-0.0407506
-0.0276399
-0.0178547
0.0133801
0.115905
0.0386734
0.0078376
0.0142383
0.0208623
0.0272861
0.0331761
0.0381419
0.0419691
0.0446425
0.0462495
-0.00324891
-0.049139
-0.0806913
-0.0448052
-0.004697
-0.00487884
-0.00668255
-0.00314516
0.00276934
0.0116869
0.00505464
-0.0323023
-0.0787686
-0.0891697
-0.081395
-0.0473977
-0.0359452
-0.0206146
-0.00791198
0.122445
0.127881
-0.00211896
0.0114141
0.0202042
0.0270308
0.0325597
0.0369013
0.0401033
0.0422677
0.0435435
-0.00335437
-0.0428943
-0.0692186
-0.039922
-0.00759748
-0.00496562
-0.00488646
-0.00125201
0.00575016
0.0133701
0.0108474
-0.0113848
-0.0605529
-0.0918301
-0.0678296
-0.00837082
-0.0461411
-0.0267499
-0.0169022
0.000956163
0.0153285
-0.000335774
0.0122392
0.0207877
0.0269563
0.0316281
0.0351119
0.0375889
0.0392255
0.0401758
-0.00343032
-0.0377583
-0.0593165
-0.0353858
-0.00957676
-0.00506191
-0.00338901
0.000555907
0.00787577
0.0156489
0.0179763
0.00682097
-0.0386897
-0.0928682
-0.0700178
-0.0282042
-0.0488914
-0.0260094
-0.0154336
-0.00883602
-0.00120222
0.00925765
0.0170153
0.0229259
0.0274737
0.0309133
0.0334449
0.03522
0.0363748
0.0370242
-0.00344723
-0.0332797
-0.0506816
-0.0311949
-0.0107828
-0.00510478
-0.00218025
0.00220559
0.00952888
0.0180433
0.0244341
0.0244038
-0.0142838
-0.0834558
-0.0609066
-0.0774763
-0.0439407
-0.021358
-0.00847573
0.000188392
0.00796646
0.0152785
0.020563
0.0245672
0.0276456
0.0299665
0.0316459
0.0327917
0.0335076
0.0338811
-0.00339251
-0.0292118
-0.0430739
-0.0273495
-0.0113425
-0.00505382
-0.00123318
0.00354726
0.0108451
0.0197672
0.0281948
0.0348113
-0.00500928
-0.0795663
-0.0855541
-0.0662857
-0.0369391
-0.0154572
-0.00254256
0.00604035
0.0127373
0.017993
0.0217922
0.0245856
0.0266554
0.0281604
0.0292117
0.0299001
0.030301
0.0304781
-0.00326607
-0.0254186
-0.0363319
-0.0238593
-0.0113554
-0.004891
-0.000515728
0.00454724
0.0116437
0.020218
0.0285666
0.0374123
0.0040161
-0.0598929
-0.0730185
-0.0478591
-0.0266494
-0.010075
0.000820603
0.00830936
0.0137517
0.0177546
0.0206312
0.0226888
0.0241597
0.0252089
0.0259569
0.0264851
0.0268355
0.0270183
-0.00308686
-0.0218253
-0.0303277
-0.0207106
-0.0109071
-0.00462026
-5.9789e-06
0.00511478
0.0117389
0.0193216
0.0261884
0.0280581
0.0169484
-0.0272067
-0.0375464
-0.0307906
-0.0166387
-0.00574771
0.00225057
0.0081138
0.0124392
0.0156197
0.0179243
0.0195755
0.0207442
0.0215594
0.0221216
0.0225082
0.0227676
0.022912
-0.00292308
-0.0184038
-0.0249639
-0.0178026
-0.0100798
-0.00425454
0.000314918
0.00522923
0.0111182
0.0173363
0.0222029
0.022261
0.011082
-0.00837943
-0.0183591
-0.0156134
-0.00915532
-0.00241677
0.00291737
0.00715351
0.0104096
0.0128644
0.0146854
0.0160142
0.0169609
0.017607
0.0180176
0.0182526
0.0183705
0.0184201
-0.00272168
-0.0151501
-0.0201556
-0.0150135
-0.00895598
-0.00381144
0.000458775
0.00492353
0.00989972
0.0146667
0.017709
0.0167733
0.00977328
-0.00073978
-0.00653115
-0.00669176
-0.0038447
-0.000198069
0.00319302
0.00606539
0.00836521
0.0101477
0.0114975
0.0124973
0.0132192
0.0137192
0.0140389
0.014213
0.0142821
0.0142987
-0.00239801
-0.0120596
-0.0158195
-0.0122772
-0.00761589
-0.00331358
0.000445896
0.00426735
0.00825501
0.0116954
0.0134307
0.0122371
0.00783982
0.00216732
-0.00134553
-0.00195609
-0.000774115
0.00115999
0.00318443
0.0050105
0.00653352
0.00774606
0.00867921
0.00938064
0.00990232
0.0102862
0.0105495
0.0106909
0.0107232
0.0107028
-0.00200382
-0.0091181
-0.0118612
-0.00955483
-0.00613186
-0.00278046
0.000271929
0.00334212
0.00635016
0.00870728
0.00963669
0.00862557
0.00595723
0.00284112
0.000849023
0.000285413
0.000749506
0.00173898
0.00287752
0.00396579
0.00491268
0.00568828
0.00629615
0.00676264
0.00712234
0.00739776
0.00758639
0.00767358
0.00766779
0.00762466
-0.00154278
-0.00629277
-0.00817174
-0.00682198
-0.00455619
-0.00222734
-1.5392e-05
0.00221076
0.00430534
0.00582985
0.00632443
0.00564121
0.0041236
0.00248752
0.00140685
0.00102526
0.00119026
0.00166555
0.00226131
0.0028637
0.00341127
0.00387466
0.00424445
0.00452783
0.00474112
0.00489671
0.0049969
0.00504332
0.00504951
0.00504157
-0.00102401
-0.00352612
-0.00462685
-0.00405285
-0.00291255
-0.00166773
-0.000408145
0.000913701
0.00216472
0.00305637
0.00334745
0.0030163
0.00230234
0.00154262
0.00104226
0.000843407
0.00089127
0.00109165
0.00136225
0.00164909
0.00191966
0.00215408
0.00234179
0.0024816
0.00257878
0.00264156
0.00268087
0.00270934
0.00273586
0.00275959
-0.000457649
-0.000723992
-0.0010695
-0.00118856
-0.00119187
-0.00110628
-0.000899347
-0.000539814
-9.93164e-05
0.000282517
0.000487592
0.000505964
0.000408778
0.000280799
0.000186739
0.000142875
0.000144629
0.000179126
0.000230386
0.00028795
0.000344323
0.000393797
0.000433815
0.00046414
0.000485029
0.000497964
0.000506826
0.000515817
0.000526145
0.00053549
0.0769696
0.0747349
0.0684136
0.0563825
0.0362467
0.00778283
-0.026026
-0.0615667
-0.0979901
-0.14392
-0.16246
-0.145768
-0.11829
-0.0903676
-0.035715
0.051136
0.132376
0.192024
0.458595
-0.174841
0.308667
75.463
110.075
113.703
115.117
112.847
108.768
102.615
100.51
45.3842
0.0700993
0.0677876
0.0612464
0.0489444
0.0288776
0.00113798
-0.0312489
-0.0646171
-0.0977537
-0.138625
-0.157348
-0.14194
-0.113011
-0.0829397
-0.0329393
0.0424406
0.172911
0.19897
0.45345
-0.167413
0.293792
41.5622
110.817
113.965
115.447
113.025
108.832
101.882
14.3158
2.00699
0.0627579
0.0602408
0.0531554
0.0399999
0.019418
-0.00760215
-0.0378203
-0.0678207
-0.0957845
-0.129597
-0.147563
-0.135126
-0.106716
-0.0754757
-0.0283755
0.0340274
0.0900011
0.199372
0.27821
-0.102313
0.247436
2.05757
111.861
114.238
115.821
113.222
108.888
60.6431
11.0802
4.1207
0.0544459
0.0517876
0.044238
0.0303649
0.00939361
-0.016845
-0.0447208
-0.0707345
-0.0917433
-0.118224
-0.13531
-0.126138
-0.0995427
-0.0682057
-0.0239729
0.0342472
0.0973859
0.185341
1.62798
1.19768
0.18848
6.64026
112.897
114.529
116.097
113.433
102.098
40.6161
0.0238609
0.125173
0.0451691
0.0424482
0.0346898
0.0204912
-0.000301711
-0.0252658
-0.0506221
-0.0731607
-0.0861943
-0.10655
-0.123177
-0.116116
-0.0916455
-0.0612321
-0.0199415
0.0334088
0.101982
0.174935
-0.0206512
0.29112
0.142112
-0.3368
109.506
114.829
116.109
113.421
95.01
5.03172
-0.00204792
0.122988
0.0355108
0.0327654
0.0250411
0.0109957
-0.00914262
-0.0325452
-0.055489
-0.0757832
-0.0771353
-0.0847731
-0.0729399
-0.105667
-0.0831438
-0.0545168
-0.0164854
0.030927
0.0916848
0.135122
0.017496
-0.138387
0.0801276
-0.176707
24.651
115.167
116.44
112.602
50.9354
0.0555215
-0.0083839
0.126463
0.0264542
0.0237643
0.0163207
0.0029005
-0.0161187
-0.0378145
-0.0583529
-0.071974
-0.0389294
-0.0683152
-0.0923457
-0.093648
-0.0740735
-0.0480198
-0.013768
0.0275398
0.0823541
0.110914
0.0538077
0.000688844
0.0182224
-0.132099
0.526951
95.842
116.642
92.0829
0.486632
0.0637654
-0.0163544
0.171344
0.0192942
0.0167909
0.00988435
-0.00255832
-0.0200925
-0.0399097
-0.0580123
-0.0708359
-0.0778268
-0.0783831
-0.0832586
-0.0804481
-0.0645406
-0.0417427
-0.0118167
0.0229566
0.0707256
0.0885684
0.0109123
0.243425
-0.0303178
-0.114649
-0.0477587
0.0869723
47.7013
9.94237
0.0940257
0.083573
-0.0155209
-0.0932226
0.0154302
0.0131698
0.00697617
-0.00418385
-0.019959
-0.0377763
-0.0537519
-0.0641562
-0.067729
-0.0684428
-0.0700778
-0.0674423
-0.0548655
-0.035715
-0.010562
0.0183729
0.0487212
0.0683939
-0.0244836
0.323983
-0.0327852
-0.107499
-0.0581397
-0.0265634
-0.0118002
0.0296367
0.119529
0.0139557
-0.0247981
-0.0930629
0.0158637
0.013869
0.00846754
-0.00121015
-0.0149686
-0.0306876
-0.0447987
-0.0537513
-0.0564189
-0.0568159
-0.0571356
-0.0543818
-0.0450426
-0.0299843
-0.00990412
0.0141208
0.0370579
0.071251
0.000915662
-0.0996676
-0.0739899
-0.10268
-0.0658523
-0.0354266
-0.0124436
0.0276261
0.0253063
0.008649
0.0195419
-0.0893919
0.0207222
0.0190462
0.0145176
0.00640052
-0.00525937
-0.0187861
-0.0311817
-0.0394378
-0.0419112
-0.0425743
-0.0434042
-0.0414427
-0.0352303
-0.0246446
-0.00994725
0.00945587
0.0261487
0.0589798
-0.0408167
-0.0768505
-0.0798483
-0.0971549
-0.069753
-0.0387931
-0.0139867
0.024474
0.0075709
0.00449603
0.00884324
-0.0805086
0.0288712
0.0275537
0.02386
0.0172172
0.00765593
-0.00360934
-0.0144409
-0.0220365
-0.0261807
-0.0287124
-0.0293903
-0.0287093
-0.025506
-0.0199186
-0.0111692
0.00328549
0.016552
0.0530465
-0.0393153
-0.0644102
-0.118453
-0.0898908
-0.0688777
-0.0380655
-0.0131153
0.0207025
0.0123445
0.00037749
0.0114821
-0.0706388
0.0379429
0.0369665
0.0339995
0.0286359
0.0210237
0.011984
0.00306065
-0.00481307
-0.0107332
-0.0139207
-0.0155319
-0.0162776
-0.015986
-0.0163705
-0.0146609
-0.00530757
0.00683754
0.0314867
-0.0365563
0.158826
-0.131858
-0.079917
-0.0634223
-0.034355
-0.0119108
0.0165965
0.00453521
-0.00306913
-0.0421144
-0.0610862
0.0452051
0.0446466
0.042507
0.0381739
0.0324371
0.0255764
0.0169142
0.00886219
0.00303612
-0.000684771
-0.00265172
-0.00445914
-0.00698856
-0.0152023
-0.0222316
-0.0178498
-0.00444056
0.00974814
-0.0322447
0.0914226
-0.0937767
-0.0667324
-0.0551446
-0.0289539
-0.0105004
0.0130274
-0.00231495
-0.00660828
-0.0368189
-0.0525815
0.0477837
0.0475622
0.0459074
0.042747
0.0380661
0.0319002
0.0250625
0.0183598
0.0127719
0.00923946
0.00790176
0.00611356
0.0119604
-0.017459
-0.0352664
-0.0364392
-0.0191614
-0.00306653
-0.0282537
0.0154385
-0.0579754
-0.0533143
-0.0457857
-0.0233785
-0.00905358
0.00933346
-0.00318583
-0.00981713
-0.031238
-0.0452178
0.0469271
0.0467515
0.045603
0.0433072
0.0396986
0.0348222
0.0290573
0.0230168
0.0175325
0.0137779
0.0129859
0.0818967
0.0985197
0.0514091
-0.0159282
-0.0593126
-0.0371471
-0.0177931
-0.00872133
0.00261883
-0.0411755
-0.0413792
-0.0365596
-0.0185521
-0.0077285
0.0062453
-0.00414138
-0.0121602
-0.0264233
-0.0390064
0.0441045
0.0440317
0.043191
0.0414054
0.0385377
0.0345512
0.0295617
0.0238427
0.0177475
0.0115728
0.0555814
0.0929678
0.0755641
-0.0327686
-0.0516855
-0.0670385
-0.0580573
-0.0343123
0.0166652
-0.0124828
-0.0313693
-0.0311822
-0.0281027
-0.0147314
-0.00659536
0.00369189
-0.0049837
-0.0136827
-0.0223762
-0.0335748
0.0405775
0.0404883
0.0398079
0.038393
0.0360949
0.0327907
0.0284133
0.0229229
0.0161219
0.0074994
0.0803257
0.0986354
-0.0178696
-0.0418548
-0.0318329
-0.066938
-0.0778073
-0.0391616
0.00075032
-0.0230492
-0.0235055
-0.022316
-0.0207688
-0.0117591
-0.00566481
0.00166089
-0.00562838
-0.0144057
-0.019231
-0.0286434
0.0372614
0.0371171
0.0365136
0.035343
0.0334777
0.0307808
0.0271145
0.022319
0.0171057
0.00788772
-0.0005791
-0.00933632
-0.0245398
-0.0412136
-0.0440696
-0.0706814
-0.0870649
-0.0544591
0.00722567
-0.0224429
-0.0159698
-0.0148573
-0.0146094
-0.00936919
-0.00490519
0.000100368
-0.00605781
-0.0144155
-0.0166035
-0.0241547
0.033978
0.0338102
0.033311
0.0323961
0.0309646
0.0289019
0.0260802
0.0223427
0.0174251
0.0117461
0.00346113
-0.00703566
-0.017604
-0.0330203
-0.0604819
-0.0507838
-0.0875293
-0.0555523
0.0306626
-0.0148155
-0.00896972
-0.00893663
-0.00979166
-0.00734563
-0.00427204
-0.00105491
-0.00626797
-0.0138547
-0.014264
-0.0200513
0.0304862
0.0303345
0.0299636
0.0293035
0.0282797
0.0268097
0.0247943
0.0221062
0.0185494
0.0137782
0.00746877
0.000482005
-0.00844576
-0.0237768
-0.0450734
-0.0718381
-0.0746571
-0.042004
-0.00156815
-0.00335117
-0.0026697
-0.00441016
-0.00618718
-0.00558852
-0.00371864
-0.0018669
-0.00625736
-0.0128976
-0.0121962
-0.0163069
0.0270284
0.0268535
0.0264825
0.0259122
0.0251216
0.0240597
0.0226402
0.0207453
0.0182202
0.0148501
0.0104073
0.0047899
-0.00301718
-0.0155889
-0.0288158
-0.0592191
-0.0694185
-0.0252092
0.0129544
0.00586376
0.00253802
-0.000939831
-0.00348528
-0.0040768
-0.00321503
-0.00239417
-0.006047
-0.0116981
-0.0104637
-0.0129265
0.0229286
0.0228013
0.0225287
0.0221189
0.0215525
0.0207769
0.0197163
0.0182789
0.0163494
0.0137795
0.0103842
0.00591076
-0.000230643
-0.0089992
-0.0212108
-0.0359127
-0.0354883
0.0014147
0.0191752
0.0117376
0.00609246
0.00159089
-0.00148149
-0.00281559
-0.00274753
-0.00267622
-0.00567419
-0.0103554
-0.00897541
-0.00995
0.0184297
0.0183968
0.0182913
0.0180806
0.017722
0.0171651
0.0163568
0.0152401
0.0137434
0.0117713
0.00920318
0.00588412
0.00160446
-0.0037972
-0.0100272
-0.0151514
-0.0111804
0.0122398
0.0173419
0.0134548
0.00780335
0.00319897
-6.03108e-05
-0.00181879
-0.00232412
-0.00275375
-0.00518741
-0.00893514
-0.00763742
-0.00746815
0.0143118
0.0143281
0.0143017
0.0141824
0.0139349
0.0135314
0.0129406
0.0121227
0.0110302
0.00960766
0.00779099
0.00552206
0.00279395
-0.000266694
-0.00301439
-0.00377276
0.000335694
0.0101485
0.0142114
0.0120241
0.00795201
0.00394174
0.000822477
-0.00109048
-0.00195035
-0.00266597
-0.00462158
-0.00749041
-0.00639754
-0.00554349
0.0107075
0.0107605
0.0107955
0.0107371
0.0105564
0.0102588
0.00984374
0.00928746
0.00854748
0.00759297
0.00639991
0.00496648
0.00334774
0.00172784
0.000590939
0.000812422
0.00348096
0.00813499
0.0106125
0.00976591
0.00707623
0.00393658
0.0012304
-0.00062812
-0.00163847
-0.00245533
-0.00398864
-0.00606411
-0.00521776
-0.00407716
0.00762109
0.00768368
0.00775357
0.00775447
0.00765198
0.0074558
0.00718379
0.00682912
0.00636338
0.00576338
0.00502796
0.00418137
0.00328251
0.00246493
0.00201377
0.0023387
0.00379362
0.00605682
0.00749594
0.00726284
0.00564153
0.00338378
0.00121995
-0.000406324
-0.00139771
-0.00216177
-0.00329213
-0.00468062
-0.00406607
-0.00291354
0.00504675
0.005075
0.00510814
0.00511694
0.00507929
0.00498991
0.00485117
0.00465684
0.00438932
0.00403687
0.00360963
0.00313982
0.00267307
0.00228922
0.00211903
0.00233687
0.00305367
0.00414819
0.00492063
0.00488962
0.00394769
0.00244716
0.000860328
-0.000410026
-0.00123178
-0.00181705
-0.00254268
-0.00334618
-0.002911
-0.0019391
0.00277249
0.00277045
0.00275996
0.00274996
0.00274012
0.00272019
0.0026767
0.00259697
0.00247055
0.00229484
0.00208137
0.00185526
0.00164668
0.00149099
0.00143569
0.00154375
0.0018546
0.00231876
0.0026728
0.00264571
0.00213248
0.00123379
0.000219909
-0.000620043
-0.00114175
-0.00144688
-0.0017522
-0.00204785
-0.00172563
-0.00106843
0.0005402
0.000538405
0.000532414
0.0005269
0.000524784
0.000523892
0.000518614
0.00050487
0.000481413
0.000448129
0.000407308
0.000365343
0.000329683
0.000306664
0.000302734
0.000325936
0.000380965
0.000458374
0.00050381
0.000443406
0.000212807
-0.000187536
-0.000647766
-0.000994876
-0.00112475
-0.00106601
-0.000921164
-0.00074512
-0.000485803
-0.000233644
109.079
114.137
118.636
118.822
116.76
114.266
111.7
109.248
107.14
105.557
104.481
103.734
103.199
102.918
102.992
103.468
104.298
105.372
106.557
107.734
108.815
109.753
110.529
111.143
111.611
111.95
112.183
112.328
112.406
112.43
109.057
114.139
118.678
118.847
116.767
114.268
111.695
109.231
107.111
105.519
104.442
103.694
103.152
102.862
102.93
103.404
104.24
105.327
106.528
107.721
108.818
109.769
110.554
111.177
111.649
111.993
112.228
112.375
112.453
112.478
109.016
114.14
118.751
118.889
116.78
114.272
111.689
109.206
107.063
105.456
104.377
103.628
103.075
102.77
102.826
103.297
104.14
105.243
106.464
107.678
108.794
109.759
110.554
111.183
111.66
112.005
112.241
112.389
112.467
112.492
108.954
114.139
118.857
118.949
116.798
114.281
111.684
109.174
106.996
105.367
104.285
103.536
102.968
102.639
102.677
103.143
103.997
105.121
106.369
107.609
108.746
109.727
110.532
111.166
111.645
111.99
112.226
112.373
112.451
112.475
108.873
114.137
118.998
119.028
116.821
114.293
111.68
109.134
106.91
105.252
104.168
103.418
102.828
102.467
102.48
102.938
103.803
104.955
106.234
107.505
108.669
109.668
110.485
111.125
111.606
111.951
112.186
112.333
112.41
112.434
108.77
114.132
119.174
119.123
116.849
114.31
111.677
109.086
106.805
105.11
104.024
103.274
102.656
102.253
102.232
102.679
103.555
104.738
106.055
107.363
108.557
109.578
110.409
111.056
111.54
111.886
112.121
112.267
112.343
112.367
108.647
114.124
119.389
119.236
116.881
114.33
111.676
109.032
106.68
104.939
103.853
103.105
102.452
101.995
101.928
102.358
103.245
104.464
105.824
107.175
108.406
109.453
110.299
110.955
111.443
111.791
112.026
112.171
112.248
112.271
108.503
114.111
119.646
119.365
116.917
114.354
111.676
108.97
106.533
104.74
103.656
102.912
102.213
101.688
101.563
101.969
102.864
104.125
105.533
106.936
108.209
109.287
110.153
110.819
111.312
111.661
111.896
112.04
112.117
112.14
108.337
114.092
119.948
119.509
116.955
114.382
111.678
108.902
106.364
104.509
103.431
102.695
101.939
101.33
101.132
101.503
102.402
103.71
105.172
106.634
107.96
109.075
109.964
110.642
111.139
111.49
111.725
111.869
111.943
111.966
108.148
114.064
120.302
119.668
116.996
114.415
111.684
108.827
106.172
104.245
103.18
102.455
101.629
100.916
100.626
100.95
101.855
103.205
104.723
106.257
107.648
108.809
109.725
110.417
110.92
111.272
111.505
111.647
111.721
111.745
107.936
114.026
120.712
119.839
117.037
114.452
111.692
108.746
105.955
103.945
102.901
102.193
101.281
100.443
100.042
100.296
101.192
102.592
104.166
105.788
107.262
108.479
109.428
110.137
110.648
110.999
111.23
111.37
111.442
111.463
107.701
113.975
121.186
120.021
117.078
114.494
111.706
108.66
105.71
103.606
102.596
101.911
100.892
99.9056
99.3745
99.5279
100.403
101.842
103.468
105.202
106.787
108.074
109.066
109.795
110.312
110.662
110.888
111.024
111.094
111.115
107.441
113.907
121.733
120.211
117.117
114.541
111.724
108.57
105.432
103.225
102.265
101.612
100.459
99.3002
98.6228
98.6298
99.4695
100.914
102.586
104.47
106.207
107.582
108.628
109.385
109.908
110.256
110.475
110.602
110.663
110.68
107.156
113.818
122.364
120.405
117.153
114.594
111.748
108.477
105.12
102.797
101.91
101.296
99.9787
98.6211
97.7866
97.5768
98.3788
99.7339
101.456
103.551
105.502
106.989
108.107
108.897
109.432
109.766
109.972
110.086
110.141
110.157
106.845
113.702
123.094
120.598
117.185
114.652
111.779
108.382
104.771
102.316
101.535
100.966
99.4453
97.8601
96.8701
96.3351
97.0988
98.1702
99.9749
102.41
104.657
106.28
107.505
108.337
108.869
109.189
109.365
109.461
109.514
109.531
106.508
113.555
123.939
120.785
117.211
114.717
111.818
108.287
104.381
101.776
101.144
100.626
98.8529
97.0081
95.8363
94.8938
95.4052
95.963
97.9772
100.988
103.6
105.433
106.806
107.68
108.217
108.52
108.664
108.719
108.731
108.732
106.143
113.368
124.922
120.957
117.229
114.789
111.867
108.195
103.942
101.168
100.744
100.277
98.1953
96.0494
94.5654
93.1543
93.1855
93.1184
95.3753
99.2485
102.327
104.493
106.011
106.958
107.496
107.73
107.819
107.832
107.811
107.797
105.751
113.134
126.069
121.104
117.238
114.87
111.927
108.109
103.448
100.481
100.346
99.921
97.469
94.9622
93.0646
91.2197
90.954
90.4492
92.2197
97.293
100.864
103.406
105.152
106.172
106.659
106.807
106.805
106.756
106.721
106.706
105.33
112.842
127.42
121.215
117.236
114.959
112
108.035
102.89
99.7016
99.9612
99.5551
96.6714
93.7615
91.6916
88.9627
87.9777
85.4239
86.6098
93.976
98.8483
102.095
104.203
105.338
105.767
105.804
105.635
105.467
105.389
105.359
104.879
112.482
129.022
121.273
117.22
115.058
112.086
107.978
102.256
98.8122
99.5983
99.165
95.8078
92.2475
90.3775
87.2605
81.9565
76.4955
78.5981
87.5777
95.666
100.421
103.21
104.551
104.877
104.718
104.287
103.899
103.708
103.648
104.4
112.039
130.941
121.258
117.191
115.169
112.187
107.947
101.528
97.7886
99.2565
98.7124
94.859
90.8945
89.1954
84.7457
76.971
67.4765
71.2967
80.6072
91.7537
98.8177
102.17
103.595
103.816
103.406
102.665
101.968
101.588
101.465
103.891
111.5
133.264
121.147
117.145
115.293
112.305
107.951
100.683
96.599
98.9129
98.111
93.7251
89.4261
87.7989
81.3581
73.8024
59.2591
68.6315
78.4589
89.4226
97.0249
100.757
102.185
102.339
101.677
100.629
99.6379
99.0075
98.7791
103.353
110.847
136.11
120.913
117.083
115.432
112.44
108.004
99.69
95.221
98.5191
97.2013
92.1414
87.8767
85.7364
78.8883
72.4283
11.5925
58.3354
78.1891
89.6043
95.6309
98.9101
100.511
100.559
99.6052
98.2254
96.9071
95.9504
95.5495
102.785
110.062
139.633
120.528
117.003
115.589
112.591
108.123
98.503
93.7627
97.9952
95.7913
90.3716
86.7567
83.5713
70.932
0.0100419
0.132651
0.278329
69.0178
89.9482
95.3816
97.7057
99.1824
99.1106
97.9464
96.0066
93.8369
92.1521
91.4372
102.189
109.126
144.036
119.964
116.907
115.766
112.758
108.328
97.0525
92.5261
97.444
93.7775
88.0169
84.1479
49.2655
-0.016261
0.0141673
0.106093
0.099601
0.223006
88.3025
96.8718
97.6969
98.0303
98.071
97.3475
94.4385
90.3187
86.7889
85.2103
101.564
108.025
149.584
119.196
116.794
115.967
112.937
108.641
95.1721
91.5041
97.399
91.0256
85.5182
12.7377
0.019547
-0.0235541
-0.00451361
0.0512252
0.0476877
-0.0151919
0.48989
82.3373
97.7263
97.9709
96.9624
97.0545
92.8837
85.7311
78.6145
75.4417
100.912
106.749
156.612
118.202
116.666
116.197
113.122
109.08
92.5652
89.446
98.425
87.8711
5.75724
0.0779415
0.0227559
-0.031266
-0.0441771
-0.00782244
-0.0154111
-0.0551753
-0.0943919
0.287861
2.94552
16.7037
23.4376
23.0499
13.8412
5.99787
2.62915
1.83599
100.233
105.3
165.544
116.967
116.528
116.462
113.306
109.684
88.9828
86.7334
98.7936
15.4792
0.0399202
0.0634463
0.0210153
-0.0352659
-0.0653994
-0.0427386
-0.0594356
-0.0967246
-0.0899483
-0.0410538
-0.0253519
0.0362748
0.0574528
0.0801954
0.0970828
0.113725
0.122397
0.126143
99.5281
103.689
176.924
115.484
116.382
116.769
113.475
110.525
84.2136
78.5101
33.9009
0.105774
0.0327026
0.0517127
0.0129945
-0.0390369
-0.0707374
-0.0559879
-0.0829885
-0.112565
-0.0851148
-0.0522407
-0.0417964
-0.0122453
0.0173456
0.045521
0.0676778
0.0848034
0.0944659
0.0982482
98.807
101.936
191.449
113.761
116.235
117.13
113.613
111.666
77.3473
-0.601407
0.153824
0.0719749
0.0834704
0.0432363
0.0107369
-0.0402003
-0.0643099
-0.0591125
-0.0895953
-0.113279
-0.0862738
-0.0548736
-0.0367634
-0.0128945
0.0150304
0.0409012
0.0608463
0.0737922
0.081131
0.0841953
112.413
112.348
112.222
112.017
111.713
111.29
110.727
110.008
109.125
108.085
106.923
105.705
104.536
103.547
102.864
102.563
102.632
102.962
103.431
104.028
104.865
105.977
107.165
108.061
108.263
107.506
105.852
103.816
102.072
101.079
112.46
112.395
112.268
112.06
111.753
111.325
110.756
110.029
109.134
108.079
106.9
105.666
104.484
103.486
102.801
102.506
102.584
102.924
103.396
103.994
104.836
105.961
107.163
108.069
108.275
107.516
105.856
103.814
102.069
101.075
112.474
112.409
112.281
112.073
111.764
111.333
110.759
110.023
109.116
108.045
106.846
105.591
104.39
103.381
102.695
102.41
102.505
102.86
103.34
103.938
104.79
105.936
107.163
108.085
108.297
107.532
105.861
103.809
102.062
101.064
112.458
112.393
112.265
112.057
111.748
111.316
110.738
109.995
109.075
107.985
106.762
105.48
104.255
103.23
102.544
102.274
102.393
102.772
103.261
103.859
104.725
105.904
107.166
108.112
108.329
107.556
105.867
103.8
102.051
101.047
112.416
112.352
112.225
112.017
111.709
111.275
110.693
109.94
109.005
107.892
106.64
105.325
104.071
103.028
102.343
102.096
102.249
102.66
103.16
103.758
104.642
105.865
107.173
108.149
108.372
107.587
105.873
103.788
102.035
101.024
112.35
112.285
112.158
111.951
111.642
111.207
110.619
109.856
108.902
107.762
106.475
105.122
103.833
102.769
102.089
101.873
102.071
102.522
103.037
103.634
104.541
105.817
107.184
108.196
108.427
107.624
105.881
103.772
102.015
100.995
112.254
112.189
112.062
111.855
111.545
111.107
110.513
109.737
108.761
107.59
106.261
104.864
103.535
102.448
101.776
101.603
101.858
102.361
102.894
103.485
104.418
105.761
107.2
108.254
108.492
107.67
105.89
103.752
101.992
100.96
112.123
112.058
111.931
111.725
111.414
110.972
110.37
109.579
108.578
107.368
105.991
104.543
103.169
102.055
101.4
101.283
101.608
102.175
102.729
103.311
104.275
105.697
107.22
108.324
108.57
107.722
105.899
103.728
101.964
100.919
111.948
111.885
111.76
111.553
111.241
110.796
110.185
109.376
108.345
107.089
105.653
104.147
102.724
101.579
100.951
100.909
101.319
101.966
102.544
103.111
104.108
105.624
107.245
108.405
108.659
107.782
105.909
103.699
101.933
100.872
111.727
111.663
111.539
111.334
111.022
110.574
109.952
109.122
108.054
106.741
105.234
103.66
102.189
101.008
100.421
100.476
100.991
101.733
102.34
102.883
103.915
105.542
107.276
108.498
108.76
107.849
105.92
103.666
101.898
100.819
111.446
111.385
111.263
111.059
110.749
110.298
109.664
108.808
107.695
106.31
104.713
103.062
101.547
100.324
99.7988
99.9792
100.619
101.479
102.118
102.626
103.694
105.45
107.314
108.604
108.874
107.924
105.931
103.628
101.86
100.76
111.098
111.037
110.919
110.721
110.414
109.959
109.313
108.424
107.255
105.779
104.064
102.32
100.782
99.5048
99.0677
99.4105
100.202
101.203
101.88
102.338
103.451
105.346
107.359
108.724
109.001
108.006
105.942
103.585
101.819
100.694
110.665
110.612
110.502
110.313
110.01
109.553
108.892
107.96
106.721
105.126
103.247
101.389
99.8688
98.5216
98.2071
98.7612
99.7348
100.908
101.629
102.016
103.177
105.23
107.412
108.858
109.141
108.097
105.953
103.536
101.775
100.622
110.142
110.093
109.995
109.818
109.53
109.077
108.389
107.409
106.076
104.327
102.207
100.197
98.7613
97.3402
97.1939
98.0257
99.2137
100.594
101.367
101.659
102.868
105.101
107.475
109.007
109.295
108.195
105.964
103.481
101.728
100.544
109.516
109.468
109.378
109.229
108.964
108.523
107.815
106.755
105.296
103.356
100.862
98.6376
97.357
95.9231
96.0271
97.2076
98.632
100.26
101.096
101.261
102.519
104.959
107.549
109.173
109.463
108.301
105.975
103.42
101.68
100.459
108.724
108.706
108.663
108.551
108.313
107.875
107.142
106.005
104.344
102.173
99.1231
96.5449
95.3466
94.3485
94.7944
96.3041
97.9809
99.9046
100.818
100.819
102.127
104.8
107.636
109.355
109.646
108.415
105.985
103.352
101.629
100.367
107.795
107.805
107.803
107.738
107.567
107.17
106.389
105.153
103.234
100.732
96.951
93.8791
92.7079
92.5196
93.5428
95.3261
97.2556
99.5226
100.535
100.325
101.685
104.625
107.738
109.555
109.845
108.537
105.994
103.276
101.578
100.269
106.709
106.727
106.761
106.784
106.697
106.377
105.585
104.209
101.975
99.1177
94.4257
90.7629
90.5686
90.3126
92.2325
94.2517
96.4328
99.102
100.247
99.7682
101.186
104.43
107.858
109.773
110.059
108.668
106.003
103.192
101.525
100.163
105.371
105.42
105.536
105.714
105.777
105.535
104.712
103.082
100.294
96.5085
89.8143
84.8807
86.2509
87.3447
90.8604
92.9462
95.49
98.6252
99.9517
99.1348
100.623
104.213
107.999
110.012
110.291
108.807
106.01
103.098
101.472
100.049
103.675
103.799
104.091
104.525
104.834
104.724
103.895
101.782
97.8906
91.7618
82.4411
75.5593
78.9652
83.9905
89.5084
91.686
94.3815
98.0669
99.644
98.4049
99.9828
103.971
108.163
110.27
110.54
108.954
106.017
102.994
101.42
99.9273
101.52
101.774
102.333
103.098
103.706
103.77
102.961
100.464
95.2815
85.8034
75.8942
67.655
72.5719
80.798
87.0026
90.3873
92.9365
97.4443
99.3095
97.5559
99.2524
103.701
108.356
110.549
110.807
109.11
106.022
102.879
101.368
99.7966
98.8752
99.3273
100.184
101.277
102.172
102.455
101.551
98.8413
93.2035
83.5082
74.1519
61.8808
67.1103
77.7725
84.2925
89.382
91.3157
96.7476
98.9156
96.5659
98.4142
103.397
108.582
110.848
111.094
109.274
106.026
102.752
101.316
99.6562
95.7075
96.4481
97.6566
99.0867
100.352
100.921
99.9067
97.297
92.1101
84.0883
70.7998
21.8776
34.2808
76.5705
81.4267
87.4041
89.9508
95.8354
98.3933
95.4429
97.4602
103.055
108.847
111.168
111.401
109.447
106.029
102.61
101.266
99.505
91.7128
93.0057
95.0739
97.2444
98.9556
99.7391
99.0361
96.5383
92.0025
83.8785
12.2084
0.213599
0.108318
16.9837
79.9013
85.2923
88.1892
94.6072
97.6528
94.3722
96.4047
102.673
109.159
111.508
111.73
109.629
106.03
102.453
101.217
99.3418
85.7931
88.4778
92.5902
96.4087
98.3623
98.7809
99.1171
97.4529
92.6969
24.8664
0.130139
0.138424
0.0794299
-0.0302506
2.76558
83.1459
86.6922
93.276
96.76
93.6766
95.1682
102.247
109.524
111.865
112.082
109.819
106.031
102.278
101.169
99.1649
76.6761
82.2448
89.8059
95.648
97.6761
97.8155
100.979
97.2322
24.3647
-0.0213371
0.0347644
0.0503528
0.00499537
-0.0459155
0.00620671
0.162615
78.9914
92.2164
96.5404
92.9753
93.4037
101.773
109.952
112.238
112.461
110.019
106.03
102.084
101.121
98.9724
2.27894
4.64248
11.1467
22.2699
29.8077
25.9727
14.7242
0.379824
-0.0700796
-0.101924
-0.0533627
-0.043486
-0.0721626
-0.0701639
0.0013604
0.120791
0.185771
82.1006
97.6372
91.5468
90.817
101.263
110.449
112.622
112.867
110.228
106.029
101.867
101.072
98.7618
0.126831
0.123008
0.110907
0.0947477
0.0815475
0.0444169
-0.000232595
-0.0868989
-0.131597
-0.127549
-0.120085
-0.102094
-0.112552
-0.037968
0.0132854
0.103683
0.163704
0.242124
89.8594
91.0297
87.648
100.76
111.017
113.013
113.304
110.447
106.028
101.626
101.02
98.5304
0.0973059
0.0912884
0.0785398
0.0587549
0.0321015
-0.00475562
-0.0454156
-0.0877821
-0.121179
-0.14349
-0.151236
-0.12639
-0.121616
-0.074852
-0.00440906
0.107511
0.143932
0.229911
0.255227
29.4406
84.5711
100.347
111.653
113.403
113.772
110.676
106.027
101.356
100.962
98.2773
0.0835656
0.0790876
0.0698253
0.0535031
0.0287634
-0.00398033
-0.0403721
-0.0788189
-0.123945
-0.154992
-0.162335
-0.131865
-0.113497
-0.0700514
0.02813
0.0989101
0.187997
0.250642
0.0514265
-0.0582232
56.8774
100.233
112.349
113.783
114.274
110.916
106.027
101.056
100.895
98.0307
61.627
100.775
197.66
112.56
116.145
117.391
113.674
112.561
64.6487
0.355205
0.214354
0.0751735
0.0688737
0.0400206
0.0108432
-0.0371574
-0.0578696
-0.058484
-0.087604
-0.106811
-0.082974
-0.0549736
-0.0391993
-0.0175542
0.00921552
0.0348326
0.0543848
0.0668577
0.0739061
0.0768194
0.328577
22.0422
162.681
111.454
116.069
117.636
113.706
113.372
32.1303
0.366577
0.245766
0.876722
0.0738268
0.0380024
0.0112088
-0.0332723
-0.0521846
-0.0571022
-0.0841294
-0.0996327
-0.0784715
-0.0554635
-0.0421349
-0.0225871
0.00292214
0.0277529
0.0471004
0.0597443
0.0669739
0.0699437
0.0559854
1.03637
113.743
108.945
115.986
117.925
113.721
114.431
-2.63415
0.373527
0.256984
0.395224
0.0686539
0.0357944
0.0119691
-0.0287393
-0.0463188
-0.0547695
-0.0790864
-0.0912262
-0.0724009
-0.055184
-0.0451839
-0.0284464
-0.00489672
0.018958
0.0385138
0.051813
0.0594766
0.0626033
0.058136
-0.120622
46.032
107.95
115.891
118.192
114.47
114.979
1.50464
0.317951
1.77988
0.245308
0.0624702
0.0317055
0.0129692
-0.0237814
-0.0405558
-0.0515053
-0.0730362
-0.0836015
-0.0654483
-0.0541187
-0.0484086
-0.0345973
-0.0130333
0.00978811
0.0293911
0.0431707
0.0511343
0.0543139
-0.0122684
-0.114453
3.70154
91.2268
115.718
118.728
113.952
111.582
-0.236176
0.251804
-0.0545746
0.122016
0.0531417
0.0287179
0.0168603
-0.0189055
-0.0351078
-0.0473865
-0.0663298
-0.0262058
-0.0506209
-0.0528736
-0.0518851
-0.040191
-0.0205078
0.000979164
0.0201208
0.0339643
0.0419599
0.0450657
-0.0119699
-0.120721
-0.147574
39.2736
114.284
118.709
114.06
16.9089
-0.1357
0.183378
-0.0800025
0.0674314
0.040936
0.0253811
0.0156408
-0.0143472
-0.0299803
-0.0425134
-0.0586319
-0.0625602
-0.0365547
-0.0292523
-0.00812038
-0.0444109
-0.0270046
-0.00710851
0.0111917
0.0246783
0.0324644
0.0354456
-0.0177248
-0.120369
-0.126739
0.921087
101.619
118.588
80.2738
0.130354
-0.0892528
0.130726
-0.0836346
0.0319847
0.0256721
0.0221479
0.0120163
-0.0104439
-0.0251154
-0.0370306
-0.0499073
-0.0547162
-0.0486344
-0.0372724
-0.0470817
-0.0454524
-0.0313873
-0.0134632
0.0035717
0.0162741
0.0236372
0.0264228
-0.0836019
-0.124733
-0.105238
-0.0118833
20.956
83.9389
-0.0220885
-0.0322027
-0.0648589
0.0714746
-0.197684
0.00321859
0.00742729
0.0704537
0.00776325
-0.00750416
-0.0205115
-0.0310636
-0.0414244
-0.0452746
-0.0426194
-0.0410754
-0.0446085
-0.0437674
-0.0327522
-0.0169952
-0.00152624
0.0100748
0.0167908
0.0192921
-0.081806
-0.125915
-0.0860232
-0.017744
0.00835732
-0.0230936
-0.0228209
-0.0410131
-0.0522593
0.0338757
-0.0728935
-0.0222278
-0.0115583
0.0631852
0.00460207
-0.0056082
-0.0162598
-0.024722
-0.0324052
-0.0358266
-0.034396
-0.0369324
-0.0405431
-0.039755
-0.030451
-0.0166486
-0.00294997
0.00733956
0.0132664
0.015445
-0.0691287
-0.12287
-0.0702284
-0.0149093
0.00983109
-0.0183685
-0.0221632
-0.0440863
-0.0447323
0.0112493
0.142538
-0.0416753
-0.00960428
0.042171
0.000351185
-0.00494992
-0.0125526
-0.0181139
-0.0232648
-0.0263142
-0.02677
-0.0294324
-0.0332501
-0.0318901
-0.0237295
-0.0117431
4.05123e-05
0.00886313
0.013985
0.015884
-0.0619291
-0.090469
-0.0590569
-0.0220661
0.0100245
-0.0174934
-0.0237522
-0.043668
-0.0388403
0.0145492
0.190246
-0.0477772
-0.000867811
0.0481644
-0.00559624
-0.00573011
-0.00982449
-0.0113628
-0.0139289
-0.0163823
-0.0182837
-0.019739
-0.0224243
-0.0202548
-0.0128693
-0.00261175
0.0073359
0.0147539
0.0190726
0.0207216
0.0474158
-0.0882126
-0.0509882
-0.0232873
0.00881872
-0.0147458
-0.0218093
-0.041078
-0.0325968
0.0193776
0.0210781
-0.0549635
-0.0232593
-0.00549646
-0.00881642
-0.00804561
-0.00904107
-0.0047773
-0.00448069
-0.00632814
-0.00814193
-0.00908931
-0.00852047
-0.00641074
0.000420908
0.00905244
0.0173973
0.0236471
0.027351
0.0288246
-0.0260537
-0.0414552
-0.0463737
-0.0233476
0.00637523
-0.0126745
-0.0184921
-0.0364766
-0.0262064
0.0171467
0.0379476
-0.0653629
-0.0328876
-0.0384085
-0.0168619
-0.0123356
-0.0120105
0.0011763
0.00452848
0.00310303
0.00165438
0.00133216
0.00368992
0.00827728
0.0142757
0.020813
0.0277589
0.0330649
0.0363937
0.0378251
-0.0245576
-0.0805106
-0.0432519
-0.0238662
0.0036583
-0.0106547
-0.0148288
-0.0303912
-0.0199066
0.0119797
0.0290037
-0.0739874
-0.0561113
-0.0512452
-0.0264852
-0.0174609
0.053644
0.127086
0.0154671
0.0104645
0.00915851
0.00954747
0.0123136
0.0173132
0.0234747
0.0300675
0.0362431
0.0409665
0.0437021
0.0450105
-0.026777
-0.062181
-0.0404708
-0.0243771
0.00103586
-0.00878388
-0.011269
-0.0236492
-0.0133489
0.00774928
0.0168503
-0.0205511
-0.0835752
-0.0605139
-0.0386568
-0.0238899
-0.0186817
0.0295392
0.113126
0.0138472
0.0119745
0.0131057
0.0170671
0.022559
0.0287721
0.0348219
0.0399031
0.0438158
0.0463447
0.0475496
-0.0255787
-0.0980378
-0.0384719
-0.0246752
-0.00137851
-0.0071781
-0.00816699
-0.0168449
-0.00703026
0.00669341
0.00126881
-0.0630006
-0.0624667
-0.0760828
-0.0542449
-0.0245178
-0.0226511
-0.0101195
0.102393
0.120424
0.00446352
0.0108461
0.0175634
0.0241113
0.0303234
0.0357928
0.0402023
0.0434474
0.0455745
0.0466935
-0.0241928
-0.0852874
-0.0368859
-0.0246065
-0.00347398
-0.00590494
-0.00558313
-0.0103844
-0.00108032
0.00885839
-0.00407729
-0.050637
-0.0887013
-0.0856865
-0.0703045
-0.0441995
-0.027509
-0.0141131
0.0418196
0.129831
-0.00740051
0.00600491
0.0161559
0.023797
0.0299464
0.0348777
0.0386413
0.0413081
0.0430078
0.0439011
-0.022675
-0.0718757
-0.0354109
-0.024103
-0.00516684
-0.00493676
-0.00344695
-0.00459898
0.0045335
0.0129755
0.00179131
-0.0373359
-0.0780232
-0.100744
-0.0309615
-0.0311797
-0.0350412
-0.0209923
-0.0160087
0.0560132
-0.0101697
0.00734523
0.0169114
0.0240912
0.0294552
0.0335075
0.036467
0.0385036
0.0397793
0.0404368
-0.021063
-0.0606379
-0.0338124
-0.0231933
-0.00641478
-0.00419603
-0.0016781
0.000152292
0.0093449
0.0178146
0.0133655
-0.011486
-0.0653562
-0.0839338
-0.0535645
-0.0658114
-0.0351934
-0.0198684
-0.0119956
-0.00536453
0.00404895
0.0139304
0.0201314
0.0253556
0.0293184
0.0322835
0.0344187
0.0358677
0.0367573
0.0371889
-0.0193727
-0.0510763
-0.0319447
-0.0219336
-0.00721654
-0.00360773
-0.000220212
0.00375845
0.0128642
0.0219041
0.0261141
0.0155575
-0.0557269
-0.0527751
-0.0470059
-0.0599236
-0.0312823
-0.0140949
-0.00382993
0.00416585
0.0118573
0.0181161
0.0226973
0.0262093
0.0288934
0.03088
0.0322794
0.033198
0.0337332
0.0339613
-0.0176035
-0.0428894
-0.0297316
-0.0203717
-0.00760499
-0.00311295
0.000944491
0.00623198
0.0149621
0.0242844
0.0320054
0.0241797
-0.0450899
-0.091623
-0.0901038
-0.0471656
-0.0248057
-0.00823447
0.00209485
0.00955637
0.0155646
0.0200458
0.0232937
0.0256998
0.0274715
0.028737
0.0295966
0.0301329
0.0304146
0.0305013
-0.0157536
-0.0358663
-0.0271369
-0.0185626
-0.00763782
-0.00267997
0.00181685
0.00763811
0.0157746
0.0245969
0.0319215
0.0311291
-0.0303745
-0.0744604
-0.0600908
-0.0381473
-0.0174275
-0.00408385
0.00488982
0.0112356
0.0159181
0.019315
0.0217471
0.0234868
0.0247291
0.0256148
0.0262451
0.0266814
0.0269483
0.0270457
-0.0138085
-0.0296966
-0.0241772
-0.0165712
-0.00738009
-0.00229229
0.00238581
0.00818676
0.0154731
0.0230149
0.0282434
0.0260392
-0.00750685
-0.0353534
-0.037739
-0.0234388
-0.0107745
-0.00143509
0.00540847
0.0104413
0.0141542
0.0168672
0.0188207
0.0202115
0.0211892
0.0218668
0.0223331
0.0226522
0.0228548
0.0229377
-0.0117445
-0.0242874
-0.0209706
-0.0144648
-0.00688498
-0.0019516
0.00264311
0.00805055
0.014259
0.0201004
0.0231775
0.018588
0.00106312
-0.0155779
-0.0179327
-0.0124854
-0.0054334
0.000386284
0.00516917
0.00889344
0.011727
0.0138451
0.0154043
0.0165299
0.0173174
0.0178382
0.0181535
0.0183229
0.0184017
0.0184295
-0.00974568
-0.0195085
-0.0176577
-0.0123023
-0.00619545
-0.00165965
0.00260266
0.0073664
0.0123848
0.0165332
0.0179165
0.0140798
0.00447178
-0.00446971
-0.00718686
-0.0054832
-0.00201767
0.00155089
0.0047011
0.00728482
0.00931642
0.0108717
0.0120366
0.0128893
0.0134944
0.0138997
0.0141421
0.0142579
0.0142935
0.0143038
-0.00781413
-0.0152379
-0.0143214
-0.0101243
-0.00535241
-0.00142475
0.00229759
0.00626879
0.0101085
0.0128642
0.0132678
0.0103882
0.00494894
-0.000138382
-0.00195097
-0.00152374
0.00015013
0.00218301
0.00413175
0.00581195
0.0071773
0.00824483
0.00905588
0.00966134
0.0101098
0.0104331
0.0106357
0.0107183
0.0107144
0.0106986
-0.00594367
-0.0113657
-0.0110076
-0.00794408
-0.00439958
-0.00124656
0.00179026
0.00488152
0.00765872
0.00939975
0.00938536
0.00743409
0.00431517
0.00165425
0.00040296
0.000418552
0.00120433
0.00230428
0.00343542
0.00445959
0.00532214
0.00601197
0.00654498
0.00695384
0.00727023
0.00750419
0.00764337
0.00768013
0.00764576
0.0076144
-0.00411831
-0.00777935
-0.00773418
-0.00575086
-0.00337053
-0.00112062
0.00109335
0.0032959
0.00517238
0.00622912
0.0061232
0.00495168
0.00326277
0.00185873
0.00113211
0.00105218
0.00140167
0.00195677
0.00256599
0.0031463
0.00365465
0.00407146
0.00439596
0.00464205
0.00482594
0.00495402
0.00502643
0.0050501
0.00504554
0.00504128
-0.00231198
-0.00435399
-0.00447748
-0.00351894
-0.00229041
-0.00104644
0.000246484
0.00156335
0.00267507
0.00328749
0.00325116
0.00268716
0.00191245
0.00125472
0.000905264
0.000841886
0.000978211
0.00122168
0.00150565
0.00178785
0.00204242
0.00225413
0.00241753
0.00253519
0.00261398
0.0026634
0.00269575
0.00272265
0.00274849
0.00276779
-0.000471758
-0.000931531
-0.00115244
-0.00120156
-0.00116161
-0.00102209
-0.00073725
-0.000322053
0.000109807
0.000411304
0.000517287
0.000466091
0.000343912
0.000227632
0.000158134
0.000138849
0.000158867
0.000203164
0.000258917
0.000316769
0.000370097
0.000414952
0.000450219
0.000475774
0.000492266
0.00050258
0.000511182
0.00052093
0.000531134
0.000538519
0.0763091
0.0721535
0.0632623
0.0474331
0.0229625
-0.0086774
-0.0434823
-0.0792838
-0.12174
-0.154838
-0.160866
-0.129698
-0.10565
-0.0644746
0.0881026
0.097991
0.13614
0.41928
-0.137115
-0.0872809
10.3195
100.467
112.812
114.01
114.608
111.073
106.028
100.852
99.9956
16.4023
0.0694052
0.0651176
0.0559595
0.0399704
0.015878
-0.014677
-0.0478482
-0.0808322
-0.118232
-0.150336
-0.155118
-0.126033
-0.098977
-0.059507
0.00395258
0.0917744
0.136705
0.326082
-0.0892258
-0.0839378
-0.440107
99.7252
113.21
114.195
114.903
111.21
106.035
57.5513
1.20342
-0.329794
0.0619876
0.0573285
0.0474412
0.0306512
0.00655967
-0.0225125
-0.0529633
-0.0817271
-0.112359
-0.140717
-0.146013
-0.120375
-0.0919712
-0.0539084
0.00327122
0.0648272
0.133592
0.275665
0.050961
-0.0864355
-0.125789
99.496
113.651
114.381
115.229
111.357
98.345
33.0877
1.52895
0.414805
0.0536351
0.0486931
0.0381624
0.0207104
-0.00328339
-0.0307914
-0.0581807
-0.0814768
-0.104273
-0.128152
-0.134661
-0.113068
-0.0847103
-0.048083
0.003766
0.0596195
0.134869
0.220546
0.234524
-0.123333
-0.075146
99.95
114.112
115.3
116.138
110.887
79.6581
5.9556
0.106541
-0.0133315
0.0443339
0.0392843
0.0284413
0.0108278
-0.0124819
-0.0380883
-0.0624714
-0.0805384
-0.0949734
-0.114635
-0.122853
-0.104559
-0.0772278
-0.0423913
0.00495708
0.0553859
0.133397
0.179157
0.298885
-0.134281
-0.0309454
7.65518
114.524
114.921
116.415
109.112
50.8925
0.0261375
0.11439
-0.0247302
0.0346559
0.0296112
0.0188477
0.00156362
-0.0206619
-0.0442557
-0.0658751
-0.0799006
-0.0779815
-0.0850852
-0.090764
-0.0952062
-0.0695646
-0.0370807
0.00584024
0.0496698
0.102297
0.149335
0.0570657
-0.158596
-0.0322287
-0.193672
110.054
114.983
116.777
98.0565
3.45126
0.0255193
0.124048
-0.0340387
0.0256059
0.0207179
0.0103821
-0.00603721
-0.0268703
-0.0484183
-0.0672673
-0.0480278
-0.0543006
-0.0742111
-0.0989933
-0.0847317
-0.061778
-0.0322556
0.00604558
0.0389643
0.085994
0.125146
-0.0523625
-0.171633
-0.0373271
-0.135324
18.2709
114.687
116.23
34.4934
0.111347
0.0215325
0.14818
0.0191395
0.0184985
0.0139641
0.0043724
-0.0108198
-0.0299312
-0.0493961
-0.0653339
-0.0745812
-0.0795711
-0.0806294
-0.0845506
-0.0730613
-0.0539225
-0.0278688
0.00547248
0.0318892
0.0688288
0.193852
-0.0703458
-0.171307
-0.0416478
-0.112909
-0.0186544
7.03282
44.3078
0.069654
0.0205722
0.131634
0.116601
0.0417272
0.0147033
0.0106393
0.00203961
-0.0116106
-0.0288328
-0.046222
-0.0598403
-0.066391
-0.0684537
-0.0691297
-0.0702003
-0.0620994
-0.0460416
-0.0239074
0.00422224
0.0271572
0.0516176
0.0465739
-0.0593825
-0.167549
-0.043174
-0.0884673
-0.0205287
-0.0178262
0.000880711
0.0567774
0.028648
0.0233676
0.0869409
-0.0398151
0.0152227
0.0116495
0.00417996
-0.00765942
-0.0227851
-0.0381593
-0.0500761
-0.0555851
-0.0566787
-0.0569785
-0.056566
-0.0504796
-0.0381846
-0.0204295
0.00230834
0.0225115
0.0405203
0.032542
-0.0607589
-0.176068
-0.0437629
-0.0680989
-0.0203953
-0.018971
0.000935005
0.0397755
-0.0138376
0.0263764
0.0604208
-0.064438
0.0201869
0.0171835
0.0109283
0.000945034
-0.0119482
-0.0253137
-0.0359413
-0.0413556
-0.0422655
-0.0435085
-0.0428606
-0.0389023
-0.0304035
-0.0175989
-0.000520798
0.01655
0.0294171
0.027426
-0.06705
-0.153803
-0.043695
-0.051195
-0.0194295
-0.0211055
-0.000964316
0.029444
-0.0160578
-0.162098
0.0574189
-0.0566896
0.0284639
0.0260415
0.0209256
0.0127528
0.00212085
-0.0092312
-0.0188754
-0.0244253
-0.027651
-0.0291894
-0.0292714
-0.027436
-0.0228019
-0.0157592
-0.00471418
0.00910472
0.0204641
0.034148
-0.0740017
-0.0852068
-0.0416714
-0.0381934
-0.0179494
-0.0203683
-0.000949196
0.0221277
-0.0224445
-0.146216
0.047667
-0.0479898
0.0376709
0.0357529
0.031632
0.0250513
0.0166631
0.00730487
-0.00111526
-0.00798825
-0.0125514
-0.0148722
-0.0159772
-0.0162047
-0.0156921
-0.0160789
-0.0111962
-0.000502949
0.0115707
0.0290064
-0.0435347
0.0799996
-0.0372878
-0.0288751
-0.0168989
-0.0191765
-0.000981872
0.0311656
-0.0207499
-0.127402
0.0376216
-0.0396786
0.045094
0.043796
0.0406583
0.0354399
0.0295918
0.021254
0.0126234
0.00570266
0.000927715
-0.00180643
-0.00339008
-0.00552062
-0.00981768
-0.0200723
-0.0216642
-0.0128179
0.00123303
0.0256223
-0.039223
-0.0752921
-0.0327611
-0.0225456
-0.0164841
-0.0174851
-0.000951609
0.0152176
-0.0187316
-0.107588
0.0291842
-0.0322711
0.0477824
0.0469611
0.0444728
0.0406247
0.0351257
0.0285258
0.0216422
0.015373
0.010709
0.00840562
0.00734719
0.00427022
-0.000841924
-0.0283218
-0.0377123
-0.0296283
-0.0114248
0.0180968
-0.0274046
-0.0499428
-0.028988
-0.0183538
-0.0161731
-0.0154892
-0.000993718
0.0101421
-0.0166893
-0.0895102
0.0216219
-0.0257782
0.0469481
0.046306
0.0446072
0.0416695
0.0374023
0.0320206
0.02603
0.0201487
0.0153558
0.0129874
0.0150255
0.0953539
0.0961153
0.00612795
-0.0391692
-0.0512094
-0.0255699
-4.33737e-05
-0.0236077
-0.0343865
-0.0251255
-0.0154913
-0.0155761
-0.0133641
-0.00113583
0.00638398
-0.0147304
-0.0739699
0.0152089
-0.0202201
0.0441499
0.0437166
0.0424243
0.040111
0.0366804
0.0321686
0.0267735
0.0208257
0.0146834
0.00783013
0.0997968
0.0859529
0.0493276
-0.0443092
-0.0431293
-0.0749874
-0.0452635
0.0292174
0.00539615
-0.0265904
-0.0212321
-0.0131586
-0.0144186
-0.0112681
-0.00137634
0.00349287
-0.0130299
-0.0606337
0.00963596
-0.01558
0.0405966
0.0402293
0.0392001
0.0373616
0.0345729
0.0307374
0.0258126
0.0197105
0.0121081
0.00222633
0.10739
0.0570257
-0.0285268
-0.0520319
-0.0579115
-0.0825647
-0.059156
-0.0275955
-0.0170625
-0.0220316
-0.0172913
-0.0112344
-0.0127058
-0.00931798
-0.00167854
0.00128954
-0.0116319
-0.049353
0.00505218
-0.0118206
0.0372391
0.0368779
0.0360055
0.0345047
0.032241
0.029077
0.0248707
0.0194201
0.01364
0.0020569
0.00169025
-0.0196446
-0.0312595
-0.0571499
-0.0597816
-0.0524951
-0.0701873
-0.0408288
-0.0110727
-0.0168941
-0.0130571
-0.00941305
-0.0105974
-0.00758144
-0.00198858
-0.000401221
-0.0105316
-0.0398948
0.00131921
-0.00887915
0.0339301
0.0336062
0.0329107
0.0317512
0.0300189
0.0275938
0.0243381
0.0200548
0.0143547
0.00863047
-0.00198142
-0.0120557
-0.0241474
-0.0435427
-0.0446873
-0.0881849
-0.0737952
0.0326109
-0.000406849
-0.0100745
-0.00827245
-0.00726445
-0.00828225
-0.00608744
-0.00224979
-0.00168863
-0.0096672
-0.0320255
-0.00167891
-0.0066638
0.0304332
0.0301802
0.0296737
0.0288415
0.0276057
0.0258768
0.0235439
0.020452
0.0163461
0.0107952
0.00389376
-0.00341495
-0.0150743
-0.0300417
-0.0636149
-0.0599127
-0.0678367
-0.019537
0.000550724
-0.00245148
-0.00341605
-0.00474655
-0.00599509
-0.00482065
-0.0024268
-0.00262773
-0.00893817
-0.0255215
-0.00392235
-0.00505576
0.0269647
0.0266922
0.026223
0.0255469
0.0246291
0.0234011
0.0217603
0.019572
0.0166564
0.0127716
0.00776019
0.00130367
-0.00856723
-0.0238384
-0.0437877
-0.067543
-0.0570982
0.000327258
0.0122376
0.00434262
0.000702971
-0.00221065
-0.00399744
-0.00375399
-0.0025031
-0.00323919
-0.0082493
-0.0201859
-0.00535546
-0.00391856
0.0228834
0.0226822
0.0223414
0.0218579
0.0211949
0.0202869
0.0190505
0.0173833
0.0151543
0.012195
0.00830636
0.00310329
-0.00423432
-0.0146357
-0.0285984
-0.0373363
-0.0262191
0.0187525
0.0146626
0.00881769
0.00366962
-9.11423e-05
-0.00236376
-0.00286782
-0.00248313
-0.00354967
-0.00754123
-0.0158436
-0.00609021
-0.00311185
0.0184205
0.0183549
0.0182011
0.0179223
0.0174711
0.0167953
0.0158406
0.0145442
0.0128233
0.01057
0.00764883
0.00387839
-0.000956351
-0.00689117
-0.0129275
-0.0155026
-0.000271179
0.0161826
0.0158932
0.0105189
0.00535497
0.00140631
-0.00112304
-0.0021482
-0.00237697
-0.00359214
-0.00677201
-0.0123298
-0.00621106
-0.00249814
0.0143219
0.0143235
0.0142558
0.0140759
0.013754
0.0132615
0.0125625
0.0116136
0.0103637
0.00875248
0.00671566
0.00421186
0.00129812
-0.0017435
-0.00380019
-0.00235317
0.00498591
0.0131359
0.0136164
0.0100771
0.00587071
0.00224947
-0.000281009
-0.00159042
-0.00220551
-0.00342232
-0.00591673
-0.00948263
-0.00576013
-0.00199183
0.0107313
0.0107851
0.0107801
0.0106615
0.0104214
0.0100668
0.00958538
0.00894191
0.00809849
0.00702699
0.00571228
0.00417354
0.0025185
0.00105769
0.000470812
0.00177464
0.00577248
0.00979072
0.0105333
0.0085549
0.00549769
0.0024992
0.000189626
-0.00118996
-0.00199151
-0.00309569
-0.00498127
-0.00715366
-0.00491099
-0.00154338
0.00764697
0.00772258
0.00776517
0.00771573
0.00756419
0.00732888
0.00701811
0.0066119
0.00608073
0.00541143
0.00461601
0.00373361
0.00285012
0.00217199
0.00205553
0.00291767
0.00488318
0.00695434
0.00755107
0.00658203
0.00454394
0.00225916
0.000328188
-0.000954038
-0.00175685
-0.00265929
-0.00399005
-0.00521504
-0.00386193
-0.00113254
0.00505881
0.00509274
0.00511705
0.00510427
0.00504075
0.00492664
0.00476166
0.0045332
0.00422388
0.0038311
0.0033773
0.00290363
0.00246531
0.00216783
0.00217007
0.00263555
0.00355984
0.00457602
0.00503542
0.00451429
0.00323929
0.00163723
0.000172755
-0.000869802
-0.00152179
-0.00214856
-0.00296526
-0.00355488
-0.00272968
-0.000755156
0.00277301
0.00276552
0.00275469
0.00274561
0.00273221
0.0027021
0.00264209
0.00253991
0.00238834
0.00219172
0.00196827
0.00174662
0.00156036
0.00144793
0.00146571
0.00167489
0.0020776
0.00253331
0.00271647
0.00244752
0.00171688
0.000722661
-0.000234201
-0.000920386
-0.00130385
-0.00159044
-0.00191804
-0.00206743
-0.00157085
-0.000406697
0.000539982
0.000535701
0.000529371
0.00052543
0.000524571
0.000522201
0.000512779
0.000494161
0.000466022
0.000428533
0.000385946
0.000346175
0.000316417
0.000302043
0.000310569
0.000349561
0.000419392
0.000489308
0.000491464
0.000351293
2.92346e-05
-0.00042035
-0.000843695
-0.00108813
-0.00111173
-0.000998212
-0.000837776
-0.000639871
-0.000389109
-7.75392e-05
)
;
boundaryField
{
leftWall
{
type fixedFluxPressure;
gradient uniform 0;
value nonuniform List<scalar>
60
(
107.856
107.843
107.808
107.752
107.675
107.577
107.457
107.315
107.151
106.966
106.758
106.528
106.276
106.002
105.705
105.386
105.045
104.681
104.296
103.889
103.462
103.013
102.546
102.059
101.555
101.035
100.5
99.9519
99.3931
98.8211
107.852
107.828
107.783
107.716
107.629
107.519
107.388
107.236
107.061
106.865
106.646
106.405
106.142
105.856
105.548
105.218
104.866
104.491
104.095
103.678
103.24
102.782
102.305
101.809
101.297
100.769
100.227
99.6738
99.1127
98.5733
)
;
}
rightWall
{
type fixedFluxPressure;
gradient uniform 0;
value nonuniform List<scalar>
60
(
101.079
101.075
101.064
101.047
101.024
100.995
100.96
100.919
100.872
100.819
100.76
100.694
100.622
100.544
100.459
100.367
100.269
100.163
100.049
99.9273
99.7966
99.6562
99.505
99.3418
99.1649
98.9724
98.7618
98.5304
98.2773
98.0307
101.079
101.078
101.07
101.056
101.036
101.01
100.978
100.94
100.896
100.846
100.79
100.728
100.659
100.584
100.502
100.414
100.319
100.217
100.107
99.9893
99.8631
99.7276
99.582
99.425
99.2552
99.0707
98.8695
98.6488
98.4058
98.1308
)
;
}
lowerWall
{
type fixedFluxPressure;
gradient uniform 0;
value nonuniform List<scalar>
120
(
109.083
114.136
118.627
118.817
116.759
114.267
111.703
109.254
107.149
105.568
104.492
103.746
103.211
102.932
103.007
103.481
104.308
105.377
106.555
107.725
108.8
109.733
110.505
111.118
111.583
111.922
112.154
112.299
112.376
112.4
112.383
112.319
112.193
111.988
111.685
111.263
110.703
109.987
109.108
108.073
106.917
105.706
104.544
103.559
102.878
102.578
102.644
102.974
103.442
104.038
104.874
105.983
107.168
108.061
108.261
107.504
105.85
103.815
102.072
101.079
107.856
111.345
116.779
119.183
117.892
115.531
112.982
110.45
108.145
106.289
104.977
104.089
103.453
103.034
102.922
103.197
103.857
104.822
105.962
107.148
108.278
109.287
110.14
110.831
111.368
111.767
112.05
112.236
112.345
112.394
112.397
112.358
112.265
112.101
111.85
111.49
111.002
110.365
109.568
108.608
107.507
106.312
105.11
104.019
103.173
102.677
102.569
102.785
103.195
103.718
104.419
105.401
106.587
107.679
108.273
108.011
106.769
104.833
102.867
101.399
)
;
}
atmosphere
{
type totalPressure;
rho rho;
psi none;
gamma 1;
p0 uniform 0;
value nonuniform List<scalar>
240
(
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
-4.97435e-07
-9.22284e-07
-5.60029e-07
0
-2.55621e-06
-7.8341e-05
-0.000318254
-0.000616906
-0.000878462
-0.00102558
-0.00100257
-0.00081368
-0.000541845
-0.000302891
-0.000155535
-8.76493e-05
-6.5656e-05
-6.542e-05
-7.27868e-05
-7.94061e-05
-8.12357e-05
-7.7944e-05
-7.12973e-05
-6.32134e-05
-5.49934e-05
-4.74223e-05
-4.09429e-05
-3.56934e-05
-3.16034e-05
-2.85423e-05
-2.63545e-05
-2.48378e-05
-2.37556e-05
-2.28923e-05
-2.20359e-05
-2.11251e-05
-2.02993e-05
-1.97348e-05
-1.95772e-05
-1.98858e-05
-2.06404e-05
-2.17637e-05
-2.30824e-05
-2.43034e-05
-2.51237e-05
-2.52739e-05
-2.42168e-05
-2.11791e-05
-1.63366e-05
-1.18691e-05
-1.11069e-05
-2.04813e-05
-6.08968e-05
-0.00017759
-0.000411589
-0.000734616
-0.00102523
-0.00114751
-0.00107148
-0.000850695
-0.000567824
-0.000288432
-9.30523e-05
-2.05982e-06
0
0
0
0
0
0
0
0
0
0
-0.00184847
-0.00591644
-0.00567029
-0.00435243
-0.00322322
-0.00236741
-0.00172946
-0.0012623
-0.000922321
-0.000676994
-0.00049942
-0.000369733
-0.000273003
-0.000199009
-0.000140531
-9.33182e-05
-5.55114e-05
-2.67674e-05
-7.50649e-06
0
0
-2.14804e-05
-0.000181085
-0.000466376
-0.000757671
-0.000970099
-0.0010368
-0.000924402
-0.000680152
-0.000412552
-0.000217351
-0.000113884
-7.28958e-05
-6.39111e-05
-6.87857e-05
-7.65314e-05
-8.09909e-05
-8.01145e-05
-7.49024e-05
-6.73334e-05
-5.90388e-05
-5.10628e-05
-4.40125e-05
-3.81544e-05
-3.35055e-05
-2.99589e-05
-2.73669e-05
-2.55449e-05
-2.42686e-05
-2.3313e-05
-2.24588e-05
-2.15695e-05
-2.06905e-05
-1.99828e-05
-1.96095e-05
-1.96762e-05
-2.02045e-05
-2.11479e-05
-2.2389e-05
-2.37047e-05
-2.47933e-05
-2.53518e-05
-2.49716e-05
-2.29633e-05
-1.88889e-05
-1.3863e-05
-1.07455e-05
-1.37567e-05
-3.4477e-05
-0.000106075
-0.000279514
-0.00056825
-0.000894769
-0.00111196
-0.00113386
-0.000974102
-0.000712768
-0.000421245
-0.000171036
-2.93152e-05
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
-1.36987e-07
-8.01059e-07
-8.26037e-07
-2.13594e-07
0
0
0
0
0
0
0
0
0
0
0
0
-0.00453343
-0.00611744
-0.00501456
-0.00375006
-0.00276444
-0.00202341
-0.00147703
-0.00107834
-0.000789481
-0.000580841
-0.000429596
-0.000317851
-0.000233631
-0.000168118
-0.000115658
-7.32828e-05
-3.99802e-05
-1.59117e-05
-1.88821e-06
)
;
}
defaultFaces
{
type empty;
}
}
// ************************************************************************* //
|
|
b7065748ccb303e1ec5b56b4a510d2d8b9eccec9
|
3819fb04de99d68faee220a4d0dfddef2621cee4
|
/Code/HDU/hdu_4288.cpp
|
411b0ccf6d9bcd317582f66d110eb15c0530981e
|
[] |
no_license
|
aroslhy/acm
|
4a41e46099e2dbcf596c04e5f351f51465967598
|
26d1784e65d7513bc58549cf6d1b3926adc538ff
|
refs/heads/master
| 2021-01-22T06:54:26.587202
| 2015-07-20T11:11:53
| 2015-07-20T11:11:53
| 5,214,096
| 1
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 1,816
|
cpp
|
hdu_4288.cpp
|
//2012-09-17 22:25:47 Accepted 4288 1640MS 16496K 1823 B G++ Aros
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<map>
using namespace std;
const int MAXN = 100000+5;
int N, num[MAXN], r[MAXN];
int Tcnt[MAXN<<2];
long long Tsum[5][MAXN<<2];
char ope[MAXN][10];
map<int, int> mp;
bool cmp(const int a, const int b)
{
return num[a] < num[b];
}
void Build(int idx, int L, int R)
{
for (int i = 0; i < 5; i++)
Tsum[i][idx] = 0;
Tcnt[idx] = 0;
if (L == R)
return;
int mid = (L+R)>>1, left = idx<<1, right = idx<<1|1;
Build(left, L, mid);
Build(right, mid+1, R);
}
void Update(int idx, int L, int R, int x, int c)
{
if (x <= L && R <= x)
{
Tsum[0][idx] += c*num[r[x]];
Tcnt[idx] += c;
return;
}
int mid = (L+R)>>1, left = idx<<1, right = idx<<1|1;
if (x <= mid)
Update(left, L, mid, x, c);
else
Update(right, mid+1, R, x, c);
for (int i = 0; i < 5; i++)
Tsum[i][idx] = Tsum[i][left]+Tsum[((i-Tcnt[left])%5+5)%5][right];
Tcnt[idx] = Tcnt[left]+Tcnt[right];
}
int main()
{
while (scanf("%d", &N) != EOF)
{
mp.clear();
int n = 0;
for (int i = 0; i < N; i++)
{
scanf("%s", ope[i]);
if (ope[i][0] != 's')
{
scanf("%d", &num[i]);
if (ope[i][0] == 'a')
r[n++] = i;
}
}
sort(r, r+n, cmp);
for (int i = 0; i < n; i++)
mp[num[r[i]]] = i;
Build(1, 0, n-1);
for (int i = 0; i < N; i++)
{
if (ope[i][0] != 's')
Update(1, 0, n-1, mp[num[i]], (ope[i][0] == 'a') ? 1 : -1);
else
printf("%I64d\n", Tsum[2][1]);
}
}
return 0;
}
|
93ced69c52494d4fbed198dccbce908706b94240
|
1e0dcdc97c933a8b0226cfa8897ae4db73bd12ee
|
/mod_03/ex00/main.cpp
|
3593d9f25d9ccf094641593e2e7ee89f412fb63b
|
[] |
no_license
|
beeguy74/cpp_modules
|
95294e04896e604fd311ea39176c4e655febb97f
|
cc87f56b5c3d2999ff09a8b8e21c8c6690dd9e4b
|
refs/heads/main
| 2023-08-30T11:52:30.975889
| 2021-11-16T09:06:28
| 2021-11-16T09:06:28
| 394,993,374
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 257
|
cpp
|
main.cpp
|
#include <iostream>
#include "ClapTrap.hpp"
int main( void ) {
ClapTrap drZod = ClapTrap();
ClapTrap cheech = ClapTrap("Cheech");
ClapTrap chohng = ClapTrap("Chohng");
cheech.attack("Chohng");
chohng.takeDamage(2);
chohng.beRepaired(2);
return 0;
}
|
42e4ee630b478ac8c3e1567fe53cadf0a450f33b
|
49616bddf1f6cf68e76ab2d0be0899e233174152
|
/fmacsv/src/csv/Plugin.cpp
|
c39186fcb466e9d97b41492613edc17fedc68e91
|
[
"MIT"
] |
permissive
|
BenjaminSchulte/fma
|
40ed53a4a78f4bdf340d0b1e0a4f8656d6718abf
|
df2aa5b0644c75dd34a92defeff9beaa4a32ffea
|
refs/heads/master
| 2022-03-12T12:16:19.154084
| 2021-09-18T13:01:00
| 2021-09-18T13:01:00
| 110,001,614
| 15
| 0
|
MIT
| 2020-12-22T10:07:09
| 2017-11-08T16:32:16
|
C++
|
UTF-8
|
C++
| false
| false
| 919
|
cpp
|
Plugin.cpp
|
#include <csv/Plugin.hpp>
#include <csv/CsvClass.hpp>
#include <fma/Project.hpp>
#include <fma/types/Module.hpp>
#include <fma/types/Class.hpp>
#include <fma/types/RootModule.hpp>
using namespace FMA;
using namespace FMA::csv;
using namespace FMA::types;
// ----------------------------------------------------------------------------
CsvPlugin::CsvPlugin(Project *project)
: plugin::LanguagePlugin(project)
{
}
// ----------------------------------------------------------------------------
bool CsvPlugin::initialize() {
ModulePtr root(new Module("fmaCSV"));
const RootModulePtr &_root = project->root();
_root->setMember("fmaCSV", root);
const ClassPtr &klass = _root->getMember("Class")->asClass();
if (!klass) {
return false;
}
CsvClass::create(root, klass);
return true;
}
// ----------------------------------------------------------------------------
void CsvPlugin::release() {
}
|
780bddb9dbd4de042ef19e475903ca7ac76b82a2
|
d4a60ad0383d2175fd749ee2d9849caedc8955e4
|
/include/report/ReportResult.h
|
43ec087db3a4870f606c53e2a509bd9a91bf7432
|
[] |
no_license
|
woodpecker12/iii
|
5d2ff6d7286024b5680f54d83f7639d3e3a7cfbb
|
b5afa9e717c26f8d10288c54a4f5c5c412789e51
|
refs/heads/master
| 2021-08-15T08:04:01.923772
| 2017-11-17T16:27:49
| 2017-11-17T16:27:49
| 111,096,416
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 289
|
h
|
ReportResult.h
|
#ifndef INCLUDE_REPORTRESULT_H_
#define INCLUDE_REPORTRESULT_H_
#include "base/BaseTypes.h"
struct ReportResult
{
ReportResult(BYTE num);
void add(WORD32 report);
WORD32 getValue() const;
ReportResult convertTigerStickChicken();
private:
BYTE originNum;
WORD32 value;
};
#endif
|
9cb77ed1cb0f790e5894054229694cb06d3514ad
|
9a5c8e702f3fe75455626399b9d92e36dcbea713
|
/stringWildcard.cpp
|
d9f9accc7f30e7715880c96389d3e2945870dca9
|
[] |
no_license
|
smile-vampire/CPP
|
95ed59b00874b48ad9f3f42f031398250aa0dddf
|
389e64f72c6d594d5afb2090c4c3ae94defa1604
|
refs/heads/master
| 2021-04-13T00:53:45.764607
| 2020-08-30T11:25:49
| 2020-08-30T11:25:49
| 249,442,162
| 2
| 0
| null | null | null | null |
GB18030
|
C++
| false
| false
| 2,049
|
cpp
|
stringWildcard.cpp
|
//题目描述
//问题描述：在计算机中，通配符一种特殊语法，广泛应用于文件搜索、数据库、正则表达式等领域。
//现要求各位实现字符串通配符的算法。
//要求：
//实现如下2个通配符：
//* ：匹配0个或以上的字符（字符由英文字母和数字0 - 9组成，不区分大小写。下同）
//？：匹配1个字符
//解题思路：
//本题可以通过递归求解。从前向后一次匹配，遇到相同字符，都向后移动一个字符，如果通配符
//遇到"?"，则不需匹配，自动跳过一个字符，如果通配符遇到"*"，则可以匹配任意多个字符，包括
//0个，此时可以有三种选择，1，匹配0个，通配符向后移动一个字符，字符串不动。2，匹配1
//个，通配符和字符串都向后移动一个字符。3，匹配多个，通配符不动，字符串向后移动一个字
//符。
//递归的终止条件：通配符或者字符串遇到'\0'。当他们同时结束。
#include <iostream>
#include <string>
using namespace std;
bool match(const char* pattern, const char* str)
{
//当前字符结束，返回true
if (*pattern == '\0' && *str == '\0')
return true;
//两个字符串有一个先结束，则返回false
if (*pattern == '\0' || *str == '\0')
return false;
if (*pattern == '?')
{
//遇到?号，匹配一个字符，跳过一个位置
return match(pattern + 1, str + 1);
}
else if (*pattern == '*')
{
// 遇到*号，匹配0个(str不挪动)，1个（两者都向前挪动一个字符）或多个(str向前挪动一个
字符)
return match(pattern + 1, str) || match(pattern + 1, str + 1) ||
match(pattern, str + 1);
}
else if (*pattern == *str)
{
//如果当前字符相等，匹配下一个字符
return match(pattern + 1, str + 1);
}
return false;
}
int main()
{
string pattern, str;
while (cin >> pattern >> str)
{
bool ret = match(pattern.c_str(), str.c_str());
if (ret)
cout << "true" << endl;
else
cout << "false" << endl;
}
return 0;
}
|
ef7398fa10746395c0d1de9eb666acac35fa6ab0
|
5eb817ee3156e89ce3024d19f52e9631ac2969e0
|
/FrameWork/Monster.cpp
|
f677b09f49cd2845395f73fb7a83cd45f822aa6d
|
[] |
no_license
|
jabtem/D2D_Dungreed
|
1a872896054d92fcd3f7c8cee33e7bcfffebdab6
|
8f34fd6d8af70da00bc8958cdaf99f075b220f41
|
refs/heads/master
| 2023-04-17T18:04:09.031687
| 2021-04-26T20:26:33
| 2021-04-26T20:26:33
| 320,425,462
| 0
| 0
| null | null | null | null |
UHC
|
C++
| false
| false
| 2,876
|
cpp
|
Monster.cpp
|
#include "Include.h"
Monster monster;
Monster::Monster(void)
{
live = true;//몬스터 생사여부
state = EIdle;
next_Idle = 0;
next_Move = 0;
next_Attack = 0;
x = 400;
y = 640;
direction = Right;//캐릭터가 기본이 오른쪽이므로 반대인 왼쪽을 기본방향으로잡음
}
Monster::~Monster(void)
{
}
void Monster::Init()
{
char FileName[256];
sprintf_s(FileName, "./resources/images/Enemy/Skel/Big_Normal/idle.png");//가로로 132 세로로 120씩자름 총 660
Idle.Create(FileName, false, D3DCOLOR_XRGB(0, 0, 0));
sprintf_s(FileName, "./resources/images/Enemy/Skel/Big_Normal/attack.png");//가로로 284 세로로 192씩자름 총 3408
Attack.Create(FileName, false, D3DCOLOR_XRGB(0, 0, 0));
sprintf_s(FileName, "./resources/images/Enemy/Skel/Big_Normal/move.png");//가로로 132 세로로 120씩자름 총 792
Move.Create(FileName, false, D3DCOLOR_XRGB(0, 0, 0));
sprintf_s(FileName, "./resources/images/Enemy/Skel/Big_Normal/destroy.png");//가로로 160 세로로 160씩자름 총 1760
Destory.Create(FileName, false, D3DCOLOR_XRGB(0, 0, 0));
}
//몹을 해당위치에 스폰하는함수
void Monster::Spawn(int _x, int _y)
{
x = _x;
y = _y;
}
void Monster::Update()
{
cameraX = camera.Get_CameraX();//카메라의 X값
cameraY = camera.Get_CameraY();//카메라의 Y값
if (GetTickCount64() - animTime > 70)
{
next_Idle += 132;
if (next_Idle - 660 >= 0)
{
next_Idle -=660;
}
next_Move += 132;
if (next_Move - 660 >= 0)
{
next_Move -= 660;
}
next_Attack += 192;
if (next_Attack - 3408 >= 0)
{
next_Attack -= 3408;
}
next_Die += 160;
if (next_Die - 1760 >= 0)
{
next_Die -= 1760;
}
animTime = GetTickCount64();
}
MonsterX = x - cameraX;
MonsterY = y - cameraY;
}
void Monster::Draw()
{
if (live)
{
switch (state)
{
case EIdle:
if (direction == Right)
{
Idle.RenderDraw(MonsterX, MonsterY-120, next_Idle, 0, next_Idle + 132, 120, 0, 1.0, 1.0);
}
else if (direction == Left)
{
Idle.RenderDraw(MonsterX + 132, MonsterY - 120, next_Idle, 0, next_Idle + 132, 120, 0, -1.0, 1.0);
}
break;
case EMove:
if (direction == Right)
{
Move.RenderDraw(MonsterX, MonsterY - 120, next_Idle, 0, next_Idle + 132, 120, 0, 1.0, 1.0);
}
else if (direction == Left)
{
Move.RenderDraw(MonsterX + 132, MonsterY - 120, next_Idle, 0, next_Idle + 132, 120, 0, -1.0, 1.0);
}
break;
case EAttack:
if (direction == Right)
{
Attack.RenderDraw(MonsterX, MonsterY - 192, next_Idle, 0, next_Idle + 284, 192, 0, 1.0, 1.0);
}
else if (direction == Left)
{
Attack.RenderDraw(MonsterX + 284, MonsterY - 192, next_Idle, 0, next_Idle + 284, 120, 0, -1.0, 1.0);
}
break;
case EDie:
Destory.RenderDraw(MonsterX, MonsterY - 160, next_Die, 0, next_Die + 160, 160, 0, 1.0, 1.0);
break;
}
}
}
|
d22c1935deb98360c226d26c2dd8376dc255d3a1
|
dc0160bd39f42ce759c8d774e0c13219ad7f9a6f
|
/cp/lb/02_number_theory/euclid/cf_cardsForFriends.cpp
|
131b4c2bce11ebb2f180bf7a43475eefeb8596b6
|
[] |
no_license
|
aishwarya4444/codeChallenges
|
09f3db723aeb2348b9c6eb8574e17f768cb56945
|
44930432dfd72cefaa7a15db54cf05f174d0c1cb
|
refs/heads/master
| 2023-03-07T04:12:04.934955
| 2022-11-02T16:17:28
| 2022-11-02T16:17:28
| 71,717,257
| 1
| 2
| null | 2023-03-03T06:41:43
| 2016-10-23T17:09:06
|
C++
|
UTF-8
|
C++
| false
| false
| 507
|
cpp
|
cf_cardsForFriends.cpp
|
/*
https://codeforces.com/problemset/problem/1472/A
https://codeforces.com/blog/entry/86406
idea is to find out maximum power of 2 that is present in w and h
*/
#include <bits/stdc++.h>
#define si(n) scanf("%d", &n)
#define sll(n) scanf("%lld", &n)
#define ll long long
using namespace std;
int main() {
int t, w, h, n;
si(t);
while(t--) {
cin>>w>>h>>n;
int w2 = __gcd(1<<20, w);
int h2 = __gcd(1<<20, h);
if(w2*h2 >= n) {
cout<<"YES\n";
} else {
cout<<"NO\n";
}
}
return 0;
}
|
e9824d184b6b76856d950f20a2679911c68d2e6d
|
13508677af95d0940a6774e60002c5bcfba7ae9f
|
/155 - All Squares.cpp
|
3cf33da97e0960b2e43ac9bf17c15c0752bcba91
|
[] |
no_license
|
kuonanhong/UVa-2
|
f40686287e1aa717b6da4af81d0eafa07b0afd17
|
f58813d6a926f1ae4f61644d51dc1fe28b923cbd
|
refs/heads/master
| 2021-04-30T15:22:20.138385
| 2016-06-13T06:26:44
| 2016-06-13T06:26:44
| null | 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 598
|
cpp
|
155 - All Squares.cpp
|
/**
UVa 155 - All Squares
by Rico Tiongson
Submitted: Feb 2, 2014
Accepted 0.018s C++
O(logn) time
*/
#include <iostream>
using namespace std;
int abs( int x ){ return x < 0 ? -x : x; }
int k, x, y, c;
int main(){
while( cin >> k >> x >> y, k || x || y ){
c = 0;
for( int cx=1024, cy=1024; k>0; k >>= 1 ){
int dx = x - cx;
int dy = y - cy;
if( max( abs(dx), abs(dy) ) <= k ){
c++;
}
if( dx * dy == 0 ) break;
dx /= abs(dx);
dy /= abs(dy);
cx += dx * k;
cy += dy * k;
}
cout.width(3);
cout << right << c << endl;
}
}
|
78a05c1da44964fe44a83e2b5cb562c6b9daf2f0
|
8b5842c2795d84dbe698fcc756605f035863d70f
|
/Compiler_GC/ClassDecl.h
|
375eea805616b7e32076edf0aedca300a7a31bcd
|
[] |
no_license
|
feimengspirit/compiler
|
368adfcb557db09ea81664a283c110ea3474b515
|
17ca6d2b8fd6991bb3e2ea1c26ea97a9d3d171b4
|
refs/heads/master
| 2021-01-15T16:16:17.862910
| 2013-06-06T12:54:40
| 2013-06-06T12:54:40
| 10,526,360
| 2
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 373
|
h
|
ClassDecl.h
|
#ifndef __CLASSDECL_H__
#define __CLASSDECL_H__
#include "ClassNameDecl.h"
#include "VarDecls.h"
#include "MethodDecls.h"
class ClassDecl
{
public:
ClassDecl(ClassNameDecl *cnd,VarDecls *vds,MethodDecls *mds):
m_cnd(cnd),m_vds(vds),m_mds(mds){}
~ClassDecl(){}
virtual string GenCode() = 0;
ClassNameDecl *m_cnd;
VarDecls *m_vds;
MethodDecls *m_mds;
};
#endif
|
14d78e5478fb781c7bde9f2913dd188567fe6cf7
|
b4720fd87c7265197c7530912b899347242bde60
|
/src/Evaluators/PairEvaluateIso.h
|
961e0f6d316c860df223d9ceb63c5bfcaf9f439b
|
[] |
no_license
|
seankhl/md_engine
|
c794e3407e80f6639a1c0e6f2a3fab88cea64960
|
abf2a6b2fc28ee91e910b4b6d858496d1b4499c9
|
refs/heads/master
| 2021-08-27T16:01:43.135409
| 2016-06-09T19:41:48
| 2016-06-09T19:41:48
| null | 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 4,554
|
h
|
PairEvaluateIso.h
|
#include "BoundsGPU.h"
#include "cutils_func.h"
template <class T, int N>
__global__ void compute_force_iso(int nAtoms, float4 *xs, float4 *fs, uint16_t *neighborCounts, uint *neighborlist, uint32_t *cumulSumMaxPerBlock, int warpSize, float *parameters, int numTypes, BoundsGPU bounds, float onetwoStr, float onethreeStr, float onefourStr, T evaluator) {
float multipliers[4] = {1, onetwoStr, onethreeStr, onefourStr};
extern __shared__ float paramsAll[];
int sqrSize = numTypes*numTypes;
float *params_shr[N];
for (int i=0; i<N; i++) {
params_shr[i] = paramsAll + i * sqrSize;
}
copyToShared<float>(parameters, paramsAll, N*sqrSize);
__syncthreads();
int idx = GETIDX();
if (idx < nAtoms) {
int baseIdx = baseNeighlistIdx(cumulSumMaxPerBlock, warpSize);
float4 posWhole = xs[idx];
int type = __float_as_int(posWhole.w);
float3 pos = make_float3(posWhole);
float3 forceSum = make_float3(0, 0, 0);
int numNeigh = neighborCounts[idx];
for (int i=0; i<numNeigh; i++) {
int nlistIdx = baseIdx + warpSize * i;
uint otherIdxRaw = neighborlist[nlistIdx];
uint neighDist = otherIdxRaw >> 30;
float multiplier = multipliers[neighDist];
if (multiplier) {
uint otherIdx = otherIdxRaw & EXCL_MASK;
float4 otherPosWhole = xs[otherIdx];
int otherType = __float_as_int(otherPosWhole.w);
float3 otherPos = make_float3(otherPosWhole);
//then wrap and compute forces!
int sqrIdx = squareVectorIndex(numTypes, type, otherType);
float3 dr = bounds.minImage(pos - otherPos);
float lenSqr = lengthSqr(dr);
float params_pair[N];
for (int pIdx=0; pIdx<N; pIdx++) {
params_pair[pIdx] = params_shr[pIdx][sqrIdx];
}
evaluator.force(forceSum, dr, params_pair, lenSqr, multiplier);
}
}
// printf("LJ force %f %f %f \n", forceSum.x, forceSum.y, forceSum.z);
float4 forceCur = fs[idx];
forceCur += forceSum;
fs[idx] = forceCur;
//fs[idx] += forceSum;
}
}
template <class T, int N>
__global__ void compute_energy_iso(int nAtoms, float4 *xs, float *perParticleEng, uint16_t *neighborCounts, uint *neighborlist, uint32_t *cumulSumMaxPerBlock, int warpSize, float *parameters, int numTypes, BoundsGPU bounds, float onetwoStr, float onethreeStr, float onefourStr, T evaluator) {
float multipliers[4] = {1, onetwoStr, onethreeStr, onefourStr};
extern __shared__ float paramsAll[];
int sqrSize = numTypes*numTypes;
float *params_shr[N];
for (int i=0; i<N; i++) {
params_shr[i] = paramsAll + i * sqrSize;
}
copyToShared<float>(parameters, paramsAll, N*sqrSize);
__syncthreads();
int idx = GETIDX();
if (idx < nAtoms) {
int baseIdx = baseNeighlistIdx(cumulSumMaxPerBlock, warpSize);
float4 posWhole = xs[idx];
//int type = * (int *) &posWhole.w;
int type = __float_as_int(posWhole.w);
// printf("type is %d\n", type);
float3 pos = make_float3(posWhole);
float sumEng = 0;
int numNeigh = neighborCounts[idx];
//printf("start, end %d %d\n", start, end);
for (int i=0; i<numNeigh; i++) {
int nlistIdx = baseIdx + warpSize * i;
uint otherIdxRaw = neighborlist[nlistIdx];
uint neighDist = otherIdxRaw >> 30;
float multiplier = multipliers[neighDist];
if (multiplier) {
uint otherIdx = otherIdxRaw & EXCL_MASK;
float4 otherPosWhole = xs[otherIdx];
int otherType = __float_as_int(otherPosWhole.w);
float3 otherPos = make_float3(otherPosWhole);
float3 dr = bounds.minImage(pos - otherPos);
float lenSqr = lengthSqr(dr);
int sqrIdx = squareVectorIndex(numTypes, type, otherType);
float params_pair[N];
for (int pIdx=0; pIdx<N; pIdx++) {
params_pair[pIdx] = params_shr[pIdx][sqrIdx];
}
evaluator.energy(sumEng, params_pair, lenSqr, multiplier);
}
}
//printf("force %f %f %f with %d atoms \n", forceSum.x, forceSum.y, forceSum.z, end-start);
perParticleEng[idx] += sumEng;
//fs[idx] += forceSum;
}
}
|
97091e600d010e960ea7bf749fd718214f5870d7
|
ad3bed39a636caf7f6f0d3499e09ed8112381296
|
/575.cpp
|
60adaba91a151e0bf27aa5aede23ff514baf22a0
|
[
"MIT"
] |
permissive
|
JazzikPeng/UVa_Algorithm_CPP
|
019f92dec05ca4d2c56957bb1ce35498027acff4
|
5de29ebc44ae8dd94b767fd5815309e5eaa7c8bf
|
refs/heads/master
| 2020-03-19T05:49:58.395004
| 2018-06-04T03:31:31
| 2018-06-04T03:31:31
| 135,965,454
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 437
|
cpp
|
575.cpp
|
//Zhejian peng
#include <cstdio>
#include <cmath>
#include <cstring>
#include <iostream>
using namespace std;
int main() {
char num[1000];
int k=0, ans, i=0;
while (true)
{
gets_s(num);
if (strcmp(num,"0")== 0)
{
return 0;
}
k = strlen(num);
i = 0;
ans = 0;
while (k > 0) {
ans += (num[i] - '0') * (pow(2, k) - 1);
k--;
i++;
}
cout << ans << endl;
}
return 0;
}
|
3bdbadc47d6923c96e7da4fee91206d6b5cad2e7
|
cd726912664cea9c458ac8b609dd98bf33e3b9a0
|
/snippets/cpp/VS_Snippets_CLR_Classic/classic SortedList Example/CPP/source.cpp
|
bc3817bdcfe2ae0a9017364603ec423b21fa3a78
|
[
"MIT",
"CC-BY-4.0"
] |
permissive
|
dotnet/dotnet-api-docs
|
b41fc7fa07aa4d54205df81284bae4f491286ec2
|
70e7abc4bcd692cb4fb6b4cbcb34bb517261dbaf
|
refs/heads/main
| 2023-09-04T07:16:44.908599
| 2023-09-01T21:46:11
| 2023-09-01T21:46:11
| 111,510,915
| 630
| 1,856
|
NOASSERTION
| 2023-09-14T21:45:33
| 2017-11-21T06:52:13
|
C#
|
UTF-8
|
C++
| false
| false
| 1,131
|
cpp
|
source.cpp
|
// <Snippet1>
#using <system.dll>
using namespace System;
using namespace System::Collections;
public ref class SamplesSortedList
{
public:
static void PrintKeysAndValues( SortedList^ myList )
{
Console::WriteLine( "\t-KEY-\t-VALUE-" );
for ( int i = 0; i < myList->Count; i++ )
{
Console::WriteLine( "\t{0}:\t{1}", myList->GetKey( i ), myList->GetByIndex( i ) );
}
Console::WriteLine();
}
};
int main()
{
// Creates and initializes a new SortedList.
SortedList^ mySL = gcnew SortedList;
mySL->Add( "Third", "!" );
mySL->Add( "Second", "World" );
mySL->Add( "First", "Hello" );
// Displays the properties and values of the SortedList.
Console::WriteLine( "mySL" );
Console::WriteLine( " Count: {0}", mySL->Count );
Console::WriteLine( " Capacity: {0}", mySL->Capacity );
Console::WriteLine( " Keys and Values:" );
SamplesSortedList::PrintKeysAndValues( mySL );
}
/*
This code produces the following output.
mySL
Count: 3
Capacity: 16
Keys and Values:
-KEY- -VALUE-
First: Hello
Second: World
Third: !
*/
// </Snippet1>
|
e5dc22a40b7b29c0a8402bee039432a4f9d233b6
|
62cd4f7da988c4d6bc49661fa84a81a7afc3b19f
|
/Laba2/FileW.h
|
9d1467ed433093057f4db055349c7875a1a6391c
|
[] |
no_license
|
AndrewArtuhov/-Game-of-Life-
|
ef94d49c719884b30f4238e5047d42db7ae6501c
|
640926efd47141a284092d11f1c6dc684fb38113
|
refs/heads/master
| 2023-01-16T02:42:23.773082
| 2020-11-28T15:16:51
| 2020-11-28T15:16:51
| 316,762,636
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 406
|
h
|
FileW.h
|
#pragma once
#include <iostream>
#include <string>
#include <fstream>
#include <conio.h>
#include <filesystem>
#include <vector>
using namespace std;
class WorkFile {
enum menu_opt
{
Yes = 1,
No,
};
public:
void ReadFromFile();
void WriteToFile(vector<int> coordination);
bool IsFileOpenable(string path);
bool GetAnswer();
bool CreateFile(string path);
bool AreAllCharsInteger(string s);
};
|
c06519178cf2373e0c59dbe21f22f6adf2f57644
|
ed187ccb35155b7f981fa6939466913d208df2cc
|
/sc_goods.h
|
a1c4e1fd0326b5439020d14dd9823933f83daf08
|
[] |
no_license
|
End1-1/ShopControl
|
112d7f9810125196869233003bed1166f5f017c0
|
8c752e521b46b52110f6023ede59785c8bad7efc
|
refs/heads/master
| 2020-03-31T14:02:30.703516
| 2018-10-09T15:39:58
| 2018-10-09T15:39:58
| 152,277,365
| 1
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 325
|
h
|
sc_goods.h
|
#ifndef SC_GOODS_H
#define SC_GOODS_H
#include "sc_grid.h"
class SC_Goods : public SC_Grid
{
Q_OBJECT
public:
SC_Goods(QWidget *parent = 0);
virtual QString title();
protected:
virtual void aNew();
virtual void aEdit();
virtual void aPrepareSql();
virtual bool aDel();
};
#endif // SC_GOODS_H
|
ad9487261043f7b201023bc0b425e1036bbd31d0
|
b478344500dd269fd74bbb096bace02dbe862e05
|
/Icm.cpp
|
c8c1189a85296fe98f4a88a2a2a05c2bb9b4f840
|
[] |
no_license
|
Nomotech/ants06
|
3ad3bac566982f5c9b7974048cda1dbb5243232a
|
c4539d399441d4522d5ae1d474078c4bea5a3371
|
refs/heads/master
| 2020-08-08T21:35:43.234672
| 2019-10-09T13:32:26
| 2019-10-09T13:32:26
| 213,925,711
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 4,642
|
cpp
|
Icm.cpp
|
#include <Arduino.h>
#include "icm.hpp"
#include <SPI.h>
#define PI 3.1415926535897932384626433832795
ICM::ICM(int clk, int miso, int mosi, int ss) {
SS = ss;
hspi = new SPIClass(HSPI);
hspi->begin(clk, miso, mosi, ss);
Serial.begin(115200);
// SSをHightに
pinMode(SS, OUTPUT);
digitalWrite(SS, HIGH);
// 初期化
writeRegister(107,0b10000000); delay(200);
writeRegister(104,0b00000111); delay(200);
writeRegister(106,0b00010000); delay(200);
writeRegister( 27,0b00011000); delay(200);
carib(2000);
}
void ICM::update(){
get();
//加速度
xa_d = ((int16_t) icmData[0] <<8)|(int16_t) icmData[1];
ya_d = ((int16_t) icmData[2] <<8)|(int16_t) icmData[3];
za_d = ((int16_t) icmData[4] <<8)|(int16_t) icmData[5];
//温度
temp = ((int16_t) icmData[6] <<8)|(int16_t) icmData[7];
//ジャイロ
xg_d = ((int16_t) icmData[8] <<8)|(int16_t) icmData[9];
yg_d = ((int16_t) icmData[10]<<8)|(int16_t) icmData[11];
zg_d = ((int16_t) icmData[12]<<8)|(int16_t) icmData[13];
//加速度加算
xa += xa_d - mpuOffset[0];
ya += ya_d - mpuOffset[1];
za += za_d - mpuOffset[2];
// xa = xa_d;
// ya = ya_d;
// za = za_d;
xg += xg_d - mpuOffset[3];
yg += yg_d - mpuOffset[4];
zg += zg_d - mpuOffset[5];
// gyroAng = (float)zg * (90.0 / 0xffff); // 0xffff/2 * 180 (SI);
gyroT = zg * PI / 0xffff;
}
void ICM::writeRegister(char registerAddress, char value) {
hspi->beginTransaction(SPISettings(spiClk, MSBFIRST, SPI_MODE0));
digitalWrite(SS, LOW);
hspi->transfer(registerAddress);
hspi->transfer(value);
digitalWrite(SS, HIGH);
hspi->endTransaction();
}
char ICM::readRegister(char registerAddress) {
char value;
char address = 0x80 | registerAddress; // 書き込みフラグを立てる
hspi->beginTransaction(SPISettings(spiClk, MSBFIRST, SPI_MODE0));
digitalWrite(SS, LOW);
hspi->transfer(address);
digitalWrite(SS, HIGH);
value = hspi->transfer(0x00);
hspi->endTransaction();
return value;
}
void ICM::carib(int num){
for(int i = 0;i<num;i++){
get();
//加速度
xa_d = ((int16_t) icmData[0] <<8)|(int16_t) icmData[1];
ya_d = ((int16_t) icmData[2] <<8)|(int16_t) icmData[3];
za_d = ((int16_t) icmData[4] <<8)|(int16_t) icmData[5];
//温度
temp = ((int16_t) icmData[6] <<8)|(int16_t) icmData[7];
//ジャイロ
xg_d = ((int16_t) icmData[8] <<8)|(int16_t) icmData[9];
yg_d = ((int16_t) icmData[10]<<8)|(int16_t) icmData[11];
zg_d = ((int16_t) icmData[12]<<8)|(int16_t) icmData[13];
//加速度加算
xa += xa_d;
ya += ya_d;
za += za_d;
xg += xg_d;
yg += yg_d;
zg += zg_d;
}
mpuOffset[0] = xa/num;
mpuOffset[1] = ya/num;
mpuOffset[2] = za/num;
mpuOffset[3] = xg/num;
mpuOffset[4] = yg/num;
mpuOffset[5] = zg/num;
xa = 0.0; ya = 0.0; za = 0.0;
xg = 0.0; yg = 0.0; zg = 0.0;
Serial.printf("who am i %d\n",readRegister(117));
}
void ICM::get(){
icmData[0] = readRegister(59); delayMicroseconds(100);
icmData[1] = readRegister(60); delayMicroseconds(100);
icmData[2] = readRegister(61); delayMicroseconds(100);
icmData[3] = readRegister(62); delayMicroseconds(100);
icmData[4] = readRegister(63); delayMicroseconds(100);
icmData[5] = readRegister(64); delayMicroseconds(100);
icmData[6] = readRegister(65); delayMicroseconds(100);
icmData[7] = readRegister(66); delayMicroseconds(100);
icmData[8] = readRegister(67); delayMicroseconds(100);
icmData[9] = readRegister(68); delayMicroseconds(100);
icmData[10] = readRegister(69); delayMicroseconds(100);
icmData[11] = readRegister(70); delayMicroseconds(100);
icmData[12] = readRegister(71); delayMicroseconds(100);
icmData[13] = readRegister(72); delayMicroseconds(100);
Serial.printf("po : %d\t%d\t%d\t%d\n", icmData[0], icmData[1], icmData[2], icmData[3]);
}
void ICM::log(){
// ログ出力
// Serial.print("xa: "); Serial.print(xa); Serial.print("\t");
// Serial.print("ya: "); Serial.print(ya); Serial.print("\t");
// Serial.print("za: "); Serial.print(za); Serial.print("\t");
// Serial.print("temp: "); Serial.print(temp); Serial.print("\t");
Serial.print("xg: "); Serial.print(xg); Serial.print("\t");
Serial.print("yg: "); Serial.print(yg); Serial.print("\t");
Serial.print("zg: "); Serial.print(zg); Serial.print("\n");
}
|
71a5f81769158a930015352062ecb7ee3ba5013b
|
2aa75176e93bc5cee6e3c66a82acf3701af56678
|
/gl2/demo/shader.cpp
|
712c908d27c726302e1e9451cdff7a36aa5d152e
|
[] |
no_license
|
dedowsdi/journey
|
5d5c11a5e2c143f031ad2d801c731c2ca381c18a
|
0e9f1dd34a6bb7d5c9c8225ef1595a8cfd188593
|
refs/heads/master
| 2021-06-02T00:31:44.925551
| 2020-10-05T06:14:08
| 2020-10-05T06:14:08
| 116,079,146
| 12
| 1
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 3,890
|
cpp
|
shader.cpp
|
/*
* shader.c
* this program demonstrates GLSL shader. color is transformed as an extra
* vertex attribute.
*
* there are two ways to use vertex attribute:
* if you use glVertex.. kind stuff, use glVertexAttrib
* if you use vertex array, use glVertexAttribPointer.
*
* GLSL use varing qualified variable to output variable from vertex shader.
*
* applications are allowed to bind more than one user-defined attribute
* variable to the same generic vertex attribute index. this is called aliasing,
* and it is allowed only if just one of the aliased attributes is active in the
* executable program, or if no path through the shader consumes more than one
* attribute of a set of attributes aliased to the same location.
*
*/
#include <app.h>
#include <program.h>
namespace zxd {
GLint al_color;
GLfloat colors[][2] = {{1.0f, 0.0}, {0.0f, 1.0}, {0.0f, 0.0}};
GLfloat vertices[][2] = {{5, 5}, {25, 5}, {5, 25}};
struct program0 : public program {
GLint ul_iamge;
virtual void attach_shaders() {
const char* vs =
"attribute vec2 color; //vertex attribute \n"
"varying float blue; //pass to fragment \n"
" \n"
"void main(){ \n"
" gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex; \n"
" gl_FrontColor = vec4(color, 0, 1); \n"
" vec3 blues = vec3(0, 0, 1); \n"
" blue = blues[gl_VertexID]; \n"
"} \n";
const char* fs =
"varying float blue; \n"
"void main(){ \n"
" gl_FragColor = vec4(gl_Color.rg, blue, 1); \n"
"} \n";
string_vector sv;
sv.push_back(vs);
attach(GL_VERTEX_SHADER, sv);
sv.clear();
sv.push_back(fs);
attach(GL_FRAGMENT_SHADER, sv);
}
virtual void bind_uniform_locations() {
ul_iamge = get_uniform_location("image");
al_color = get_uniform_location("color");
};
virtual void bind_attrib_locations()
{
al_color = get_attrib_location("color");
}
} prg0;
class app0 : public app {
void init_info() {
app::init_info();
m_info.title = "shader";
m_info.display_mode = GLUT_SINGLE | GLUT_RGB;
m_info.wnd_width = 500;
m_info.wnd_height = 500;
}
void create_scene(void) {
glClearColor(0.0, 0.0, 0.0, 0.0);
glShadeModel(GL_SMOOTH);
prg0.init();
ZCGE(glVertexAttribPointer(al_color, 2, GL_FLOAT, 0, 0, colors));
ZCGE(glEnableVertexAttribArray(al_color));
glVertexPointer(2, GL_FLOAT, 0, vertices);
glEnableClientState(GL_VERTEX_ARRAY);
}
void display(void) {
glClear(GL_COLOR_BUFFER_BIT);
glUseProgram(prg0.get_object());
glDrawArrays(GL_TRIANGLES, 0, 3);
/*glBegin(GL_TRIANGLES);*/
/*glVertexAttrib3fv(al_color, colors[0]);*/
/*glVertex2f(5.0, 5.0);*/
/*glVertexAttrib3fv(al_color, colors[1]);*/
/*glVertex2f(25.0, 5.0);*/
/*glVertexAttrib3fv(al_color, colors[2]);*/
/*glVertex2f(5.0, 25.0);*/
/*glEnd();*/
glFlush();
}
void reshape(int w, int h) {
app::reshape(w, h);
glViewport(0, 0, (GLsizei)w, (GLsizei)h);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
if (w <= h)
gluOrtho2D(0.0, 30.0, 0.0, 30.0 * (GLfloat)h / (GLfloat)w);
else
gluOrtho2D(0.0, 30.0 * (GLfloat)w / (GLfloat)h, 0.0, 30.0);
glMatrixMode(GL_MODELVIEW);
}
void keyboard(unsigned char key, int x, int y) {
app::keyboard(key, x, y);
switch (key) {}
}
};
}
int main(int argc, char** argv) {
zxd::app0 _app0;
_app0.run(argc, argv);
return 0;
}
|
4ddaea9a579abe07f55dd7aedca309af10fa1cb3
|
e76e1d3bef8dda184f6ad869ef68e55b9a63f4bb
|
/eigen/trivialASOA.cpp
|
1d2a37af3513799f92a4346c847c4fe266b97756
|
[] |
no_license
|
VinInn/ctest
|
1dc634ba662e579ffe9ddabfde21fe17d9bc1534
|
8dbef5207cb3bd7d83e1874f0fce3f98e66c1915
|
refs/heads/master
| 2023-07-14T21:19:58.215969
| 2023-07-08T06:04:55
| 2023-07-08T06:04:55
| 21,533,811
| 3
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 1,707
|
cpp
|
trivialASOA.cpp
|
#include<cstdint>
constexpr uint32_t ilog2(uint32_t v) {
constexpr uint32_t b[] = {0x2, 0xC, 0xF0, 0xFF00, 0xFFFF0000};
constexpr uint32_t S[] = {1, 2, 4, 8, 16};
uint32_t r = 0; // result of log2(v) will go here
for (auto i = 4; i >= 0; i--)
if (v & b[i]) {
v >>= S[i];
r |= S[i];
}
return r;
}
constexpr bool isPowerOf2(uint32_t v) {
return v && !(v & (v - 1));
}
template<uint32_t S>
struct alignas(128) SOA {
static constexpr uint32_t stride() { return S; }
static constexpr uint32_t mask() { return S-1;}
static constexpr uint32_t shift() { return ilog2(S); }
float a[S];
float b[S];
static_assert(isPowerOf2(S),"stride not a power of 2");
static_assert(sizeof(a)%128 == 0,"size not a multiple of 128");
};
constexpr uint32_t N = 1024;
constexpr uint32_t S = 256;
using V = SOA<S>;
void sum(V * psoa) {
#pragma GCC ivdep
for (uint32_t i=0; i<N; i++) {
auto j = i>>V::shift();
auto k = i&V::mask();
auto & soa = psoa[j];
soa.b[k] += soa.a[k];
}
}
// should compile identically to above
void sum0(V * psoa) {
#pragma GCC ivdep
for (uint32_t i=0; i<N; i++) {
auto j = i/V::stride();
auto k = i%V::stride();
auto & soa = psoa[j];
soa.b[k] += soa.a[k];
}
}
void sum1(V * psoa) {
#pragma GCC ivdep
for (uint32_t i=0, j=0, k=0; i<N; i++) {
auto & soa = psoa[j];
soa.b[k] += soa.a[k];
k++;
if (k==V::stride()) {k=0; j++;}
}
}
void sum2(V * psoa) {
auto nb = (N+S-1)/S;
#pragma GCC ivdep
for (uint32_t j=0; j<nb; j++) {
auto & soa = psoa[j];
auto kmax = std::min(V::stride(),N - j*V::stride());
for(uint32_t k=0; k<kmax; k++) {
soa.b[k] += soa.a[k];
}
}
}
|
ba8aee913fffd1b77d01af4641299243ca7e615f
|
d6f2d7af06687e423e60e50d416fa8c777c09c36
|
/GSS3-14671378-src.cpp
|
fa3f9881a84fa3a3b6bbd9eb531ec7b5b15e5901
|
[] |
no_license
|
curiousTauseef/my-spoj-solutions
|
b9a70eaddaf0c3b9a43c278b9af1148806aff600
|
66b11d97073388fcebce3b74025c61839d8d5d18
|
refs/heads/master
| 2021-05-30T11:48:41.552433
| 2016-02-12T16:59:56
| 2016-02-12T16:59:56
| null | 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 1,831
|
cpp
|
GSS3-14671378-src.cpp
|
#include<bits/stdc++.h>
using namespace std;
#define INT -1000000
int k,n;
struct node{
int result,pre,suf,sum;
void split(node &a,node &b){}
void merge(node a,node b){
sum=a.sum+b.sum;
pre=max(a.pre,(a.sum+b.pre));
suf=max(b.suf,(b.sum+a.suf));
result=max(a.suf+b.pre,max(a.result,b.result));
}
node(){
result=pre=suf=sum=INT;
}
node(int temp){
result=pre=suf=sum=temp;
}
}tree[400005];
void update(int pos){
pos=pos>>1;
while(pos!=0){
tree[pos].merge(tree[pos*2],tree[pos*2+1]);
pos=pos>>1;
}
}
node range_query(int root,int left_most,int right_most,int l,int r){
if(l<=left_most && r>=right_most)
return tree[root];
int l_child=root<<1,r_child=l_child+1,mid=(left_most+right_most)>>1;
tree[root].split(tree[l_child],tree[r_child]);
node l_node=node(),r_node=node();
if(l<=mid)
l_node=range_query(l_child,left_most,mid,l,r);
if(r>mid)
r_node=range_query(r_child,mid+1,right_most,l,r);
tree[root].merge(tree[l_child],tree[r_child]);
node temp=node();
temp.merge(l_node,r_node);
return temp;
}
int main(){
int n,temp,l,r;
scanf("%d",&n);
k=ceil(log(n)/log(2));
int pos=(1<<k);
int a[n];
for(int i=0;i<n;++i){
scanf("%d",&temp);
tree[pos+i]=node(temp);
update(pos+i);
}
int q,c;
scanf("%d",&q);
while(q--){
scanf("%d%d%d",&c,&l,&r);
if(c==1)
printf("%d\n",(range_query(1,1,pos,l,r)).result);
else{
tree[pos+l-1]=node(r);
update(pos+l-1);
}
}
return 0;
}
|
dccad8ddf2846f6cc698a7d3e54f15163d823547
|
2031012d180e590e6a46099a4409efd54f526b97
|
/array.cpp
|
1bb9c1ae4a152a906b32351ca9fcae43fcabac24
|
[] |
no_license
|
Oslomayor/Come-on-Cpulspuls
|
885d4596f2c9df500467a30e82881a94ced55979
|
e447631d0dfbd11cfd0f508555c5c37be1782dfc
|
refs/heads/master
| 2020-03-18T11:31:11.107398
| 2018-06-02T08:13:20
| 2018-06-02T08:13:20
| 134,676,451
| 1
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 327
|
cpp
|
array.cpp
|
#include <iostream>
using namespace std;
#include <iomanip>
using std::setw;
// 数组
int main ()
{
int n[10];
int i;
for(i=0;i<10;i++)
n[i] = i + 555;
cout << setw(8) << "Element" << setw(8) << "Value" << endl;
for(i=0;i<10;i++)
cout << setw(6) << "n[" << i << "]" << setw(8) << n[i] << endl;
return 0;
}
|
6990908c897f0ee49d12c20e160fd14ca92127b7
|
3c364f1e3d0af0b650b96b1ac80aedd74940d3fb
|
/branches/unlabeled-1.9.2/plugins/jabber/jabbermessage.cpp
|
c5fcaa1ee419c64016cd92135d072aa31016b89c
|
[] |
no_license
|
dhyannataraj/sim-im
|
aa8e938766f6304d9f71be883f0ef4e10a7c8c65
|
6b0d058cd5ab06ba72a34f09d44b3f0598960572
|
refs/heads/master
| 2021-04-03T04:26:23.903185
| 2011-10-10T15:58:45
| 2011-10-10T15:58:45
| 124,702,761
| 1
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 5,980
|
cpp
|
jabbermessage.cpp
|
/***************************************************************************
jabbermessage.cpp - description
-------------------
begin : Sun Mar 17 2002
copyright : (C) 2002 by Vladimir Shutoff
email : vovan@shutoff.ru
***************************************************************************/
/***************************************************************************
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
***************************************************************************/
#include "jabbermessage.h"
#include "jabber.h"
#include "core.h"
static DataDef jabberMessageData[] =
{
{ "Subject", DATA_UTF, 1, 0 },
{ NULL, 0, 0, 0 }
};
JabberMessage::JabberMessage(const char *cfg)
: Message(MessageJabber, cfg)
{
load_data(jabberMessageData, &data, cfg);
}
JabberMessage::~JabberMessage()
{
free_data(jabberMessageData, &data);
}
string JabberMessage::save()
{
string res = Message::save();
string s = save_data(jabberMessageData, &data);
if (!s.empty()){
if (!res.empty())
res += "\n";
res += s;
}
return res;
}
QString JabberMessage::presentation()
{
QString res = i18n("<p>Subject: %1</p>")
.arg(getSubject());
res += Message::presentation();
return res;
}
static Message *createJabberMessage(const char *cfg)
{
return new JabberMessage(cfg);
}
static MessageDef defJabber =
{
NULL,
MESSAGE_DEFAULT,
MessageGeneric,
NULL,
NULL,
createJabberMessage,
NULL,
NULL
};
static DataDef jabberMessageErrorData[] =
{
{ "Error", DATA_UTF, 1, 0 },
{ "Code", DATA_ULONG, 1, 0 },
{ NULL, 0, 0, 0 }
};
JabberMessageError::JabberMessageError(const char *cfg)
: Message(MessageJabberError, cfg)
{
load_data(jabberMessageErrorData, &data, cfg);
}
JabberMessageError::~JabberMessageError()
{
free_data(jabberMessageErrorData, &data);
}
string JabberMessageError::save()
{
string res = Message::save();
string s = save_data(jabberMessageErrorData, &data);
if (!s.empty()){
if (!res.empty())
res += "\n";
res += s;
}
return res;
}
QString JabberMessageError::presentation()
{
QString res = "<p>";
res += i18n("Error");
if (getCode()){
res += " ";
res += QString::number(getCode());
}
QString err = getError();
if (!err.isEmpty()){
res += ": <b>";
res += err;
res += "</b>";
}
res += "<br>";
res += i18n("Original message:");
res += "</p>";
res += Message::presentation();
return res;
}
static Message *createJabberMessageError(const char *cfg)
{
return new JabberMessageError(cfg);
}
#if 0
i18n("Error", "%n errors", 1);
#endif
static MessageDef defJabberError =
{
NULL,
MESSAGE_DEFAULT,
0,
"Error",
"%n errors",
createJabberMessageError,
NULL,
NULL
};
static Message *createJabberOnlineMessage(const char *cfg)
{
return new AuthMessage(MessageJabberOnline, cfg);
}
static MessageDef defJabberOnline =
{
NULL,
MESSAGE_SILENT | MESSAGE_SENDONLY,
0,
I18N_NOOP("Log On"),
NULL,
createJabberOnlineMessage,
NULL,
NULL
};
static Message *createJabberOfflineMessage(const char *cfg)
{
return new AuthMessage(MessageJabberOffline, cfg);
}
static MessageDef defJabberOffline =
{
NULL,
MESSAGE_SILENT | MESSAGE_SENDONLY,
0,
I18N_NOOP("Log Off"),
NULL,
createJabberOfflineMessage,
NULL,
NULL
};
static DataDef jabberMessageFileData[] =
{
{ "", DATA_STRING, 1, 0 }, // ID
{ "", DATA_STRING, 1, 0 },
{ "", DATA_STRING, 1, 0 }, // Host
{ "", DATA_ULONG, 1, 0 }, // Port
{ NULL, 0, 0, 0 }
};
JabberFileMessage::JabberFileMessage(const char *cfg)
: FileMessage(MessageFile, cfg)
{
load_data(jabberMessageFileData, &data, cfg);
}
JabberFileMessage::~JabberFileMessage()
{
free_data(jabberMessageFileData, &data);
}
void JabberPlugin::registerMessages()
{
Command cmd;
cmd->id = MessageJabber;
cmd->text = "Jabber";
cmd->icon = "message";
cmd->flags = COMMAND_DEFAULT;
cmd->param = &defJabber;
Event eMsg(EventCreateMessageType, cmd);
eMsg.process();
cmd->id = MessageJabberOnline;
cmd->text = I18N_NOOP("Log On");
cmd->icon = "Jabber_online";
cmd->accel = "Ctrl+L";
cmd->menu_grp = 0x3020;
cmd->param = &defJabberOnline;
eMsg.process();
cmd->id = MessageJabberOffline;
cmd->text = I18N_NOOP("Log Off");
cmd->icon = "Jabber_offline";
cmd->param = &defJabberOffline;
eMsg.process();
cmd->id = MessageJabberError;
cmd->text = I18N_NOOP("Error");
cmd->icon = "error";
cmd->param = &defJabberError;
eMsg.process();
}
void JabberPlugin::unregisterMessages()
{
Event eMsg(EventRemoveMessageType, (void*)MessageJabber);
eMsg.process();
Event eMsgOnline(EventRemoveMessageType, (void*)MessageJabberOnline);
eMsgOnline.process();
Event eMsgOffline(EventRemoveMessageType, (void*)MessageJabberOffline);
eMsgOffline.process();
Event eMsgError(EventRemoveMessageType, (void*)MessageJabberError);
eMsgError.process();
}
|
d3c48f57e2160ab4c2ff219999446e2c30105ef5
|
d438954e2bb3d088190c2c0640bd3a817cacb4f5
|
/Common/network.h
|
1ba6a26c604015df5e00ab24e28f541c2670c2e1
|
[] |
no_license
|
danielpintocoutinho/NN-committee
|
9f518a8703a3bf6511c7aff19881460d14c7c78b
|
67d501739625a3acd8857f56e00c2d4572e9ec45
|
refs/heads/master
| 2020-12-24T10:57:39.404726
| 2016-11-09T17:49:17
| 2016-11-09T17:49:17
| 73,221,989
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 438
|
h
|
network.h
|
#ifndef __NETWORK_H__
#define __NETWORK_H__
#include <iostream>
using namespace std;
template <class Type>
class Network
{
public:
virtual void setAccuracy(double){}
virtual double getAccuracy(){}
virtual void train(Type**, Type**, int){}
virtual Type* answer(Type*){}
virtual int cluster(Type*){}
virtual void print(){cout << "Sou network" << endl;}
virtual void save(const char*){}
virtual void load(const char*){}
};
#endif
|
6195d0222e1bcbf80521de8d717343bde01086b4
|
76f73fdc27df2cc84502e7dd665cebf614812598
|
/(9465 dynamic programming)스티커.cpp
|
b833bbcf91ceacd6d6919c4e50f4141eb708f11f
|
[] |
no_license
|
borazvim/algorithm
|
7a60a20faca657084178c3f53727cd9e241a1e15
|
7afba583b5e563d5312fd0692f71cd55f0e3702c
|
refs/heads/master
| 2020-04-22T16:07:23.194645
| 2019-03-05T05:57:29
| 2019-03-05T05:57:29
| 170,498,152
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 795
|
cpp
|
(9465 dynamic programming)스티커.cpp
|
#include <iostream>
#define max(a,b)(((a)>(b))?(a):(b))
using namespace std;
long long v[100001][3];
long long d[100001][3];
int main() {
int T, N;
cin >> T;
while (T--) {
cin >> N;
for (int i = 1; i <= N; i++) {
cin >> v[i][1];
}
for (int i = 1; i <= N; i++) {
cin >> v[i][2];
}
d[0][0] = 0;
d[0][1] = 0;
d[0][2] = 0;
for (int i = 1; i <= N; i++) {
d[i][0] = max(max(d[i - 1][0], d[i - 1][1]), d[i - 1][2]);
d[i][1] = max(d[i - 1][0], d[i - 1][2]) + v[i][1];
d[i][2] = max(d[i - 1][0], d[i - 1][1]) + v[i][2];
}
/*long long ans = 0;
for (int i = 1; i <= N; i++) {
ans = max(max(ans, d[i][0]), max(d[i][1], d[i][2]));
}
cout << ans << '\n';
}*/
long long ans = 0;
ans = max(max(d[N][0], d[N][1]), d[N][2]);
cout << ans << '\n';
}
}
|
000b9acabea4e0c27654f56c9d357733c04e46c9
|
da65ca32eb0012092901bd1854cb3d6fed4008c9
|
/mume-game/mclient/src/plugins/mmapperplugin/preferences/parserpage.h
|
8179021959fcbc12a3cb894f3fe540cdd3d49f74
|
[] |
no_license
|
alex-games/a1
|
d2371f5588f4efbac8eaad0d49066ae63f293dc6
|
1521abc0092c83fcc79af9647f19bfe69a3707cf
|
refs/heads/master
| 2020-06-04T01:34:09.171971
| 2014-10-26T06:11:32
| 2014-10-26T06:11:32
| null | 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 2,257
|
h
|
parserpage.h
|
/************************************************************************
**
** Authors: Ulf Hermann <ulfonk_mennhar@gmx.de> (Alve),
** Marek Krejza <krejza@gmail.com> (Caligor)
**
** This file is part of the MMapper2 project.
** Maintained by Marek Krejza <krejza@gmail.com>
**
** Copyright: See COPYING file that comes with this distribution
**
** This file may be used under the terms of the GNU General Public
** License version 2.0 as published by the Free Software Foundation
** and appearing in the file COPYING included in the packaging of
** this file.
**
** 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 PARSERPAGE_H
#define PARSERPAGE_H
#include <QWidget>
#include "ui_parserpage.h"
class ParserPage : public QWidget, private Ui::ParserPage
{
Q_OBJECT
public slots:
void removeForcePatternClicked();
void removeCancelPatternClicked();
void removeEndDescPatternClicked();
void addForcePatternClicked();
void addCancelPatternClicked();
void addEndDescPatternClicked();
void testPatternClicked();
void validPatternClicked();
void forcePatternsListActivated(const QString&);
void cancelPatternsListActivated(const QString&);
void endDescPatternsListActivated(const QString&);
void anyColorToggleButtonToggled(bool);
void IACPromptCheckBoxStateChanged(int);
void suppressXmlTagsCheckBoxStateChanged(int);
public:
ParserPage(QWidget *parent = 0);
protected slots:
void roomDescColorChanged(const QString&);
void roomNameColorChanged(const QString&);
void roomDescColorBGChanged(const QString&);
void roomNameColorBGChanged(const QString&);
private:
void generateNewAnsiColor();
void updateColors();
void savePatterns();
};
#endif
|
a3dc271bbcc7bb881b3c371295f96c3c679a7107
|
6263b8313d4627b8cad28029ab084990a883e460
|
/transform.h
|
ffd4f8d29ecd6fe970055ed2ea1162ebc740d8f3
|
[] |
no_license
|
Analyse4/word_transform
|
b5f399229a170c296749020e331b025460fa1f04
|
8a53c05603eb1a29cfc6a5be34fae734848b4027
|
refs/heads/master
| 2021-01-01T19:37:20.291219
| 2017-07-30T03:18:17
| 2017-07-30T03:18:17
| 98,629,082
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 182
|
h
|
transform.h
|
#ifndef _TRANSFORM_H_
#define _TRANSFORM_H_
#include<string>
#include<map>
using namespace std;
const string &transform(const string &word, const map<string, string> &m);
#endif
|
9b94d18a49d92782aea2db8f1a8c6c7c88d1c3b0
|
453f28f5244bc02ccb38cea9a9f1614f6b0470c1
|
/src/Agent/NewRelic/Profiler/MethodRewriter/FunctionManipulator.h
|
56bbaf36837fb141f22423cf19ab92291420e86a
|
[
"Apache-2.0"
] |
permissive
|
newrelic/newrelic-dotnet-agent
|
a78c182d15265cc363ee2cec2991937afc30aa07
|
f52610594a24dcc3031f389b291997f70e98cf0e
|
refs/heads/main
| 2023-08-20T09:39:50.757533
| 2023-08-18T18:57:37
| 2023-08-18T18:57:37
| 274,994,065
| 85
| 71
|
Apache-2.0
| 2023-09-14T20:54:21
| 2020-06-25T19:03:04
|
C#
|
UTF-8
|
C++
| false
| false
| 23,812
|
h
|
FunctionManipulator.h
|
/*
* Copyright 2020 New Relic Corporation. All rights reserved.
* SPDX-License-Identifier: Apache-2.0
*/
#pragma once
#include <functional>
#include <stdint.h>
#include <sstream>
#include <algorithm>
#include <unordered_map>
#include "../Common/Macros.h"
#include "Exceptions.h"
#include "../Common/CorStandIn.h"
#include "IFunction.h"
#include "ISystemCalls.h"
#include "InstructionSet.h"
#include "InstantiatedGenericType.h"
#include "ExceptionHandlerManipulator.h"
#include "../Logging/Logger.h"
#include "../Configuration/InstrumentationPoint.h"
#include "../Sicily/codegen/ByteCodeGenerator.h"
#include "../SignatureParser/SignatureParser.h"
#include "IFunctionHeaderInfo.h"
#ifdef PAL_STDCPP_COMPAT
#include "../Profiler/UnixSystemCalls.h"
#else
#include "../Profiler/SystemCalls.h"
#endif
namespace NewRelic { namespace Profiler { namespace MethodRewriter
{
// Test unsafe rethrows exceptions throw while we create and finish tracers so you
// can debug what's being swallowed.
//#define TEST_UNSAFE 1
class FunctionManipulator
{
protected:
enum Scope
{
THREAD_LOCAL,
APP_DOMAIN
};
IFunctionPtr _function;
InstructionSetPtr _instructions;
ExceptionHandlerManipulatorPtr _exceptionHandlerManipulator;
ByteVector _newHeader;
ByteVector _oldCodeBytes;
ByteVector _newLocalVariablesSignature;
SignatureParser::MethodSignaturePtr _methodSignature;
std::shared_ptr<SystemCalls> _systemCalls;
public:
FunctionManipulator(IFunctionPtr function) :
_function(function),
_newHeader(sizeof(COR_ILMETHOD_FAT)),
_methodSignature(SignatureParser::SignatureParser::ParseMethodSignature(function->GetSignature()->begin(), function->GetSignature()->end())),
_systemCalls(std::make_shared<SystemCalls>())
{
}
protected:
void Initialize() {
ExtractHeaderBodyAndExtra();
ExtractLocalVariablesSignature();
_instructions = std::make_shared<InstructionSet>(_function->GetTokenizer(), _exceptionHandlerManipulator);
}
// rewrite this method with something else; handle FatalFunctionManipulatorException specially!
void Instrument()
{
LogTrace(_function->ToString(), L": Writing generated bytecode.");
// set the code size in the header
GetHeader()->SetCodeSize(uint32_t(_instructions->GetBytes().size()));
// set the extra section flag in the header
GetHeader()->SetFlags(GetHeader()->GetFlags() | CorILMethod_MoreSects);
// write the locals to the header
WriteLocalsToHeader();
// combine the header, instructions and extra sections into a single ByteVector
auto newMethod = CombineHeaderInstructionsAndExtraSections();
// write the new method to the function so it can be JIT compiled; this is the part that could be fatal
try
{
LogTrace(_function->ToString(), L": Writing method bytes to method for JIT compilation.");
_function->WriteMethod(newMethod);
}
catch (...)
{
LogError(_function->ToString(), L": A potentially fatal error occurred when attempting to instrument, this function may no longer be valid.");
throw;
}
}
void InstrumentTiny()
{
LogTrace(_function->ToString(), L": Writing generated bytecode.");
// re-initialize the header as a tiny header
_newHeader.resize(sizeof(COR_ILMETHOD_TINY));
std::fill(_newHeader.begin(), _newHeader.end(), static_cast<uint8_t>(0));
COR_ILMETHOD_TINY* tinyHeader = (COR_ILMETHOD_TINY*)_newHeader.data();
// set the 8 bits that make up the tiny header
auto tinyFlag = 0x2;
auto codeSize = _instructions->GetBytes().size();
tinyHeader->Flags_CodeSize = (uint8_t)((codeSize << 2) | tinyFlag);
// combine the header and the method body
ByteVector newMethodBytes;
AppendHeaderBytes(newMethodBytes);
AppendInstructionBytes(newMethodBytes);
// write the new method to the function so it can be JIT compiled; this is the part that could be fatal
try
{
LogTrace(_function->ToString(), L": Writing method bytes to method for JIT compilation.");
_function->WriteMethod(newMethodBytes);
}
catch (...)
{
LogError(_function->ToString(), L": A potentially fatal error occurred when attempting to instrument, this function may no longer be valid.");
throw;
}
}
// extract the header and body of the method into member variables, converting the header to fat along the way if necessary
void ExtractHeaderBodyAndExtra()
{
LogTrace(_function->ToString(), L": Breaking up the bytes into header, code and extra sections.");
auto originalMethodBytes = _function->GetMethodBytes();
uint8_t* header = originalMethodBytes->data();
COR_ILMETHOD_TINY* tinyHeader = (COR_ILMETHOD_TINY*)header;
COR_ILMETHOD_FAT* fatHeader = (COR_ILMETHOD_FAT*)header;
// fat headers can just be extracted1>------ Build started: Project: Profiler, Configuration: Debug x64 ------
if (fatHeader->IsFat())
{
uint8_t* headerBegin = &originalMethodBytes->front();
uint8_t* headerEnd = headerBegin + sizeof(COR_ILMETHOD_FAT);
uint8_t* codeBegin = fatHeader->GetCode();
uint8_t* codeEnd = codeBegin + fatHeader->GetCodeSize();
bool hasExtraSections = fatHeader->More();
_newHeader.assign(headerBegin, headerEnd);
_oldCodeBytes.assign(codeBegin, codeEnd);
if (hasExtraSections)
{
uint32_t extraSectionOffset = (uint32_t)((uint8_t*)fatHeader->GetSect() - (uint8_t*)fatHeader);
ByteVector::const_iterator iterStartBytes = originalMethodBytes->begin();
iterStartBytes += extraSectionOffset;
_exceptionHandlerManipulator = std::make_shared<ExceptionHandlerManipulator>(iterStartBytes);
//_exceptionHandlerManipulator = std::make_shared<ExceptionHandlerManipulator>(originalMethodBytes->begin() + extraSectionOffset);
}
else
{
_exceptionHandlerManipulator = std::make_shared<ExceptionHandlerManipulator>();
}
return;
}
if (!tinyHeader->IsTiny())
{
LogError(_function->ToString(), L": Is not tiny or fat.");
throw FunctionManipulatorException();
}
// tiny headers need to be converted
GetHeader()->SetSize(sizeof(COR_ILMETHOD_FAT) / 4);
// the max stack size of a tiny header is 8, so we default to 8 here
GetHeader()->SetMaxStack(8);
GetHeader()->SetFlags(CorILMethod_FatFormat | CorILMethod_InitLocals);
// tiny headers don't have any local variables so initialize the token to 0 when converting to FAT
GetHeader()->SetLocalVarSigTok(0);
uint8_t* codeBegin = tinyHeader->GetCode();
uint8_t* codeEnd = codeBegin + tinyHeader->GetCodeSize();
_oldCodeBytes.assign(codeBegin, codeEnd);
// tiny headers don't have extra sections, create empty ones
_exceptionHandlerManipulator = std::make_shared<ExceptionHandlerManipulator>();
}
// extract the local variables signature from the header
void ExtractLocalVariablesSignature()
{
LogTrace(_function->ToString(), L": Acquiring local variable signature.");
auto localVariablesSignatureToken = GetHeader()->GetLocalVarSigTok();
// if there are no local variables, create a new signature with a count of 0
if (localVariablesSignatureToken == 0)
{
// see ECMA-335 II.23.2.6
_newLocalVariablesSignature.clear();
_newLocalVariablesSignature.push_back(0x7);
_newLocalVariablesSignature.push_back(0x0);
return;
}
// if there was a signature previously, use it as a base
_newLocalVariablesSignature.clear();
auto originalLocalVariablesSignature = _function->GetSignatureFromToken(localVariablesSignatureToken);
_newLocalVariablesSignature.assign(originalLocalVariablesSignature->begin(), originalLocalVariablesSignature->end());
}
COR_ILMETHOD_FAT* GetHeader()
{
return (COR_ILMETHOD_FAT*)(_newHeader.data());
}
std::function<void()> GetArrayOfTypeParametersLamdba()
{
return [&]() {
// create a Type array big enough to hold all of the method parameters
uint16_t parameterCount = uint16_t(_methodSignature->_parameters->size());
_instructions->Append(CEE_LDC_I4, uint32_t(parameterCount));
_instructions->Append(CEE_NEWARR, _X("[mscorlib]System.Type"));
// pack the type of each method parameter into our new Type[]
for (uint16_t i = 0; i < parameterCount; ++i)
{
// get an extra copy of the array (it will be popped off the stack each time we add an element to it)
_instructions->Append(CEE_DUP);
// the index into the array that we want to set
_instructions->Append(CEE_LDC_I4, uint32_t(i));
// the type of the method parameter we want to add to the array
_instructions->AppendTypeOfArgument(_methodSignature->_parameters->at(i));
// write the element to the array (pops the array, the index and the parameter off the stack)
_instructions->Append(CEE_STELEM_REF);
}
};
}
void BuildObjectArrayOfParameters()
{
// create an object array big enough to hold all of the method parameters
uint16_t parameterCount = uint16_t(_methodSignature->_parameters->size());
_instructions->Append(CEE_LDC_I4, uint32_t(parameterCount));
_instructions->Append(CEE_NEWARR, _X("[mscorlib]System.Object"));
// pack all method parameters into our new object[]
for (uint16_t i = 0; i < parameterCount; ++i)
{
// get an extra copy of the array (it will be popped off the stack each time we add an element to it)
_instructions->Append(CEE_DUP);
// the index into the array that we want to set
_instructions->Append(CEE_LDC_I4, uint32_t(i));
// the method parameter we want to add to the array, boxed if necessary
_instructions->AppendLoadArgumentAndBox(i + (_methodSignature->_hasThis ? 1 : 0), _methodSignature->_parameters->at(i));
// write the element to the array (pops the array, the index and the parameter off the stack)
_instructions->Append(CEE_STELEM_REF);
}
}
void WriteLineToConsole(xstring_t message)
{
_instructions->AppendString(message);
_instructions->Append(CEE_CALL, _X("void [mscorlib]System.Console::WriteLine(string)"));
}
// Load the assembly using its full path and then load the given type from the assembly.
void LoadType(xstring_t assemblyPath, xstring_t typeName)
{
_instructions->AppendString(assemblyPath);
_instructions->Append(CEE_CALL, _X("class [mscorlib]System.Reflection.Assembly [mscorlib]System.Reflection.Assembly::LoadFrom(string)"));
_instructions->AppendString(typeName);
_instructions->Append(CEE_CALLVIRT, _X("instance class [mscorlib]System.Type [mscorlib]System.Reflection.Assembly::GetType(string)"));
#ifdef DEBUG
_instructions->Append(CEE_DUP);
auto afterMissing = _instructions->AppendJump(CEE_BRTRUE);
WriteLineToConsole(typeName + _X(" not found"));
_instructions->AppendLabel(afterMissing);
#endif
}
// Call System.Type.GetMethod with the given method name
void LoadMethodInfoFromType(xstring_t methodName, std::function<void()> argumentTypesLambda)
{
_instructions->AppendString(methodName);
if (argumentTypesLambda == NULL)
{
_instructions->Append(CEE_CALLVIRT, _X("instance class [mscorlib]System.Reflection.MethodInfo [mscorlib]System.Type::GetMethod(string)"));
}
else
{
argumentTypesLambda();
_instructions->Append(CEE_CALLVIRT, _X("instance class [mscorlib]System.Reflection.MethodInfo [mscorlib]System.Type::GetMethod(string, class [mscorlib]System.Type[])"));
}
#ifdef DEBUG
_instructions->Append(CEE_DUP);
auto afterMissing = _instructions->AppendJump(CEE_BRTRUE);
WriteLineToConsole(methodName + _X(" not found"));
_instructions->AppendLabel(afterMissing);
#endif
}
// Call MethodBase.Invoke(object, object[])
void InvokeMethodInfo()
{
_instructions->Append(CEE_CALLVIRT, _X("instance object [mscorlib]System.Reflection.MethodBase::Invoke(object, object[])"));
}
// Load the MethodInfo instance for the given class and method onto the stack.
// The MethodInfo will be cached in the AppDomain to improve performance if useCache is true.
// The function id is used as a tie-breaker for overloaded methods when computing the key name for the app domain cache.
void LoadMethodInfo(xstring_t assemblyPath, xstring_t className, xstring_t methodName, uintptr_t functionId, std::function<void()> argumentTypesLambda, bool useCache)
{
if (useCache && !_systemCalls->GetIsAppDomainCachingDisabled())
{
auto keyName = className + _X(".") + methodName + _X("_") + to_xstring((unsigned long)functionId);
_instructions->AppendString(keyName);
_instructions->AppendString(assemblyPath);
_instructions->AppendString(className);
_instructions->AppendString(methodName);
if (argumentTypesLambda == NULL)
{
_instructions->Append(CEE_LDNULL);
}
else
{
argumentTypesLambda();
}
_instructions->Append(CEE_CALL, _X("class [mscorlib]System.Reflection.MethodInfo [mscorlib]System.CannotUnloadAppDomainException::GetMethodFromAppDomainStorageOrReflectionOrThrow(string,string,string,string,class [mscorlib]System.Type[])"));
}
else
{
LoadType(assemblyPath, className);
LoadMethodInfoFromType(methodName, argumentTypesLambda);
}
}
// Creates an array of elementLoadLanbdas.size() and loads the elements into the array
// by invoking the lambdas.
void LoadArray(std::list<std::function<void()>> elementLoadLambdas)
{
_instructions->Append(CEE_LDC_I4, uint32_t(elementLoadLambdas.size()));
_instructions->Append(CEE_NEWARR, _X("[mscorlib]System.Object"));
uint32_t index = 0;
for (auto func : elementLoadLambdas)
{
auto nextIndex = index++;
// get an extra copy of the array (it will be popped off the stack each time we add an element to it)
_instructions->Append(CEE_DUP);
// the index into the array that we want to set
_instructions->Append(CEE_LDC_I4, nextIndex);
func();
// write the element to the array (pops the array, the index and the parameter off the stack)
_instructions->Append(CEE_STELEM_REF);
}
}
// Writes a try..catch block, invoking the try and catch lambdas to inject the code for those blocks.
void TryCatch(std::function<void()> tryLambda, std::function<void()> catchLambda)
{
// try {
_instructions->AppendTryStart();
tryLambda();
// } // end try
auto afterCatch = _instructions->AppendJump(CEE_LEAVE);
_instructions->AppendTryEnd();
// catch (System.Exception) {
_instructions->AppendCatchStart();
catchLambda();
#ifdef TEST_UNSAFE
_instructions->Append(CEE_RETHROW);
#endif
_instructions->AppendJump(afterCatch, CEE_LEAVE);
// } // catch end
_instructions->AppendCatchEnd();
_instructions->AppendLabel(afterCatch);
}
static void Return(const InstructionSetPtr& instructions, const SignatureParser::ReturnTypePtr& returnType, const uint16_t& resultLocalIndex)
{
if (returnType->_kind != SignatureParser::ReturnType::VOID_RETURN_TYPE)
instructions->AppendLoadLocal(resultLocalIndex);
instructions->Append(_X("ret"));
}
static void ThrowException(const InstructionSetPtr& instructions, const xstring_t& message, const bool& inMscorlib = false)
{
auto exception = inMscorlib ? _X("instance void System.Exception::.ctor(string)") : _X("instance void [[mscorlib]]System.Exception::.ctor(string)");
instructions->AppendString(message);
instructions->Append(CEE_NEWOBJ, exception);
instructions->Append(CEE_THROW);
}
static void ThrowExceptionIfStackItemIsNull(const InstructionSetPtr& instructions, const xstring_t& message, const bool& inMscorlib = false)
{
instructions->Append(CEE_DUP);
auto afterThrow = instructions->AppendJump(CEE_BRTRUE);
ThrowException(instructions, message, inMscorlib);
instructions->AppendLabel(afterThrow);
}
void WriteLocalsToHeader()
{
LogTrace(_function->ToString(), L": Writing locals to header.");
auto localSignaturesToken = _function->GetTokenFromSignature(_newLocalVariablesSignature);
GetHeader()->SetLocalVarSigTok(localSignaturesToken);
}
// append the return type of this function to the locals signature and return the index to it
static uint16_t AppendReturnTypeLocal(ByteVector& localsSignature, SignatureParser::MethodSignaturePtr signature)
{
return AppendToLocalsSignature(*signature->_returnType->ToBytes(), localsSignature);
}
// appends the given token to the new locals signature and returns the index to it
static uint16_t AppendToLocalsSignature(xstring_t typeString, sicily::codegen::ITokenizerPtr tokenizer, ByteVector& localsSignature)
{
// turn the type string into a type token
auto typeBytes = TypeStringToToken(typeString, tokenizer);
return AppendToLocalsSignature(typeBytes, localsSignature);
}
// append some bytes representing a type to the locals signature and return the index to it
static uint16_t AppendToLocalsSignature(const ByteVector& typeBytes, ByteVector& localsSignature)
{
// append the bytes
localsSignature.insert(localsSignature.end(), typeBytes.begin(), typeBytes.end());
// increment the local counter
auto newLocalIndex = IncrementLocalCount(localsSignature);
// return the local index to the new local
return newLocalIndex;
}
static uint16_t IncrementLocalCount(ByteVector& localsSignature)
{
// uncompress the local variable count and get an iterator that points to the next byte after the count
ByteVector::const_iterator iterator = localsSignature.begin() + 1;
//CorSigUncompressData advances 'iterator'
auto localCount = sicily::codegen::ByteCodeGenerator::CorSigUncompressData(iterator, localsSignature.end());
if (localCount >= 0xfffe)
{
LogError("Extracted local count (", std::hex, std::showbase, localCount, ") is too big to add locals to (>= 0xfffe)", std::resetiosflags(std::ios_base::basefield|std::ios_base::showbase));
throw FunctionManipulatorException();
}
// increment and compress the count
auto compressedCount = sicily::codegen::ByteCodeGenerator::CorSigCompressData(++localCount);
// erase the old count from the vector
localsSignature.erase(localsSignature.begin() + 1, iterator);
// insert the new count into the vector at the appropriate location
localsSignature.insert(localsSignature.begin() + 1, compressedCount.begin(), compressedCount.end());
return uint16_t(localCount - 1);
}
static ByteVector TypeStringToToken(xstring_t typeString, sicily::codegen::ITokenizerPtr tokenizer)
{
sicily::Scanner scanner(typeString);
sicily::Parser parser;
auto type = parser.Parse(scanner);
sicily::codegen::ByteCodeGenerator bytecodeGenerator(tokenizer);
return bytecodeGenerator.TypeToBytes(type);
}
ByteVector CombineHeaderInstructionsAndExtraSections()
{
LogTrace(_function->ToString(), L": Building the byte array for this method.");
ByteVector combined;
AppendHeaderBytes(combined);
AppendInstructionBytes(combined);
AppendExtraSectionBytes(combined);
return combined;
}
void AppendHeaderBytes(ByteVector& bytes)
{
LogTrace(_function->ToString(), L": Appending the header to the method byte array.");
bytes.insert(bytes.end(), _newHeader.begin(), _newHeader.end());
}
void AppendInstructionBytes(ByteVector& bytes)
{
LogTrace(_function->ToString(), L": Appending the bytecode to the method byte array.");
auto instructionBytes = _instructions->GetBytes();
bytes.insert(bytes.end(), instructionBytes.begin(), instructionBytes.end());
}
void AppendExtraSectionBytes(ByteVector& bytes)
{
LogTrace(_function->ToString(), L": Appending extra sections to the method byte array.");
// pad to the next 4-byte boundary
while (bytes.size() & 0x3)
{
bytes.push_back(0x00);
}
// get the bytes for the extra section
auto extraSectionBytes = _exceptionHandlerManipulator->GetExtraSectionBytes(_instructions->GetUserCodeOffset());
// and append them to the method bytes
bytes.insert(bytes.end(), extraSectionBytes->begin(), extraSectionBytes->end());
}
bool HasSignature(const ByteVector& signature)
{
if (*_function->GetSignature() == signature) return true;
return false;
}
};
}}}
|
648d868b4735a55ee2f9370c509bd6b1c2a88128
|
168f6fb6f97203ea05848425682361816e88c7b7
|
/include/Slim/Util/Reflection/ClassFactory.hpp
|
8bd494b669c259e97c97aa9c7c87e35d05f31edf
|
[
"Apache-2.0"
] |
permissive
|
zuocheng-liu/slim
|
1e258e5ab296db4b0831edcf88176ab3ab3f6f43
|
6610982481934de3da1a785b2eb7765082c9c1d0
|
refs/heads/master
| 2020-12-14T18:40:14.557151
| 2015-12-02T12:28:01
| 2015-12-02T12:28:01
| 19,131,750
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 1,546
|
hpp
|
ClassFactory.hpp
|
#ifndef SLIM_UTIL_REFLECTION_CLASSFACTORY_HPP
#define SLIM_UTIL_REFLECTION_CLASSFACTORY_HPP
#include <hash_map>
#include <string>
#include <cstring>
#include <cstdlib>
#include <Slim/Util/Reflection/Object.hpp>
#include <Slim/Exception.hpp>
namespace Slim {
namespace Util {
namespace Reflection {
class ClassFactory {
public :
Object* create(const std::string& className) {
Object *prototype = getPrototype(className);
Object *obj = (Object*)malloc(prototype->getClassSize());
memcpy(prototype, obj , prototype->getClassSize());
return obj;
}
Object* getPrototype(const std::string& className) {
std::hash_map<std::string, Object*> ::iterator it = reflectionMap.find(className);
if (it == reflectionMap.end()) {
throw new Slim::Exception("Class " + className + " is not in Reflection Map.");
}
Object *prototype = it->second;
return prototype;
}
static void registerClass(const Object* p) {
reflectionMap.insert(std::pair<std::string, Object*>(p->getClassName(), p));
}
protected :
static std::hash_map<std::string, Object*> reflectionMap;
}
}
}
}
#endif
|
1cb62f20eddc9469f0f29e5c4f729e89d2e81fd4
|
ac2d662df239581e80caff085a28158447fa584b
|
/Code Forces/1084/a.cpp
|
201533aacefe85bbd62ef29c68be53d20e2ec5e8
|
[] |
no_license
|
basimkhajwal/ProgrammingChallenges
|
4283b8a22c8ac2ccd6c0db642c607e9a5f0a797c
|
0f4ea3837a9085fc4fa4a9069b1e3fdfa124f442
|
refs/heads/master
| 2023-08-22T08:19:52.997699
| 2023-08-15T12:55:53
| 2023-08-15T12:55:53
| 72,464,921
| 0
| 1
| null | 2019-03-16T11:37:38
| 2016-10-31T18:14:39
|
C++
|
UTF-8
|
C++
| false
| false
| 381
|
cpp
|
a.cpp
|
#include <iostream>
#include <algorithm>
#include <cmath>
using namespace std;
int N, A[200];
int main() {
cin >> N;
for (int i = 1; i <= N; i++) cin >> A[i];
int ans = 100000000;
for (int x = 1; x <= N; x++) {
int t = 0;
for (int i = 1; i <= N; i++) {
t += A[i]*2*(abs(x-i)+i-1+x-1);
}
ans = min(ans,t);
}
cout << ans << endl;
return 0;
}
|
0b0dca4bc1def2c2deba2142ea304a7e9e53dd6f
|
29396c66f6aae81537b25c3b9e8d22ec2fbd57a8
|
/SurfaceVehicles/MRUH/Arduino/MasterArduino/a20190422_mainMega/io.ino
|
1b68cb0138cedb4815ea40b72fce4e0b615d8529
|
[] |
no_license
|
riplaboratory/Kanaloa
|
49cbbafb7235e5d185bb4522c4deca8a3fd2c087
|
36650e2daff733a55c6546ffb0ff083b57c8c1b8
|
refs/heads/master
| 2022-12-11T03:00:30.284107
| 2021-12-10T07:57:00
| 2021-12-10T07:57:00
| 121,706,694
| 11
| 14
| null | 2022-12-09T16:56:36
| 2018-02-16T02:11:52
|
Jupyter Notebook
|
UTF-8
|
C++
| false
| false
| 9,478
|
ino
|
io.ino
|
// Read kill state inputs
void readKill() {
// Read kill inputs
ch7Pulse = pulseIn(ch7Pin,HIGH); // ch 7 (remote kill switch channel)
int physKillRaw = digitalRead(physKillPin); // physical kill switch channel
// Determine remote kill swtich state (ch7)
if (ch7Pulse > ch7PulseMax - pulseTolerance && ch7Pulse < ch7PulseMax + pulseTolerance) {
remKillStatus = 0; // unkill
}
else if (ch7Pulse > ch7PulseMin - pulseTolerance && ch7Pulse < ch7PulseMin + pulseTolerance) {
remKillStatus = 1; // kill
}
else {
Serial.println("Error reading remote kill swtich signal (ch7) from receiver...killing");
remKillStatus = 2; // error
}
// Determine physical kill swtich state (from physical kill buttons
if (physKillRaw == 1) {
physKillStatus = 0; // unkill
}
else if (physKillRaw == 0) {
physKillStatus = 1; // kill
}
else {
Serial.println("Error reading remote physical kill state...this state should be impossible to trip");
physKillStatus = 2; // error
}
// Determine kill status
if (remKillStatus == 0 && physKillStatus == 0) {
killStatus = 0; // unkill
}
else {
killStatus = 1; // kill
}
}
// Read joystick inputs
void joy2Setpoint() {
// Read joystick inputs
ch1Pulse = pulseIn(ch1Pin,HIGH); // ch 1 (surge joystick channel)
ch2Pulse = pulseIn(ch2Pin,HIGH); // ch 2 (sway joystick channel)
ch3Pulse = pulseIn(ch3Pin,HIGH); // ch 3 (yaw joystick channel)
// Map joystick inputs from -1000 to 1000
int ch1Map = map(ch1Pulse,ch1PulseMin,ch1PulseMax,-1000,1000);
int ch2Map = map(ch2Pulse,ch2PulseMin,ch2PulseMax,-1000,1000);
int ch3Map = map(ch3Pulse,ch3PulseMin,ch3PulseMax,-1000,1000);
// Remove the deadzone
if (ch1Map < pulseDeadzone && ch1Map > -pulseDeadzone) {
ch1Map = 0;
}
if (ch2Map < pulseDeadzone && ch2Map > -pulseDeadzone) {
ch2Map = 0;
}
if (ch3Map < pulseDeadzone && ch3Map > -pulseDeadzone) {
ch3Map = 0;
}
// Calculate surge sway and yaw components
int surgeQ1 = ch1Map; // surge (forward positive)
int surgeQ2 = ch1Map;
int surgeQ3 = ch1Map;
int surgeQ4 = ch1Map;
int swayQ1 = -ch2Map; // sway (right positive)
int swayQ2 = ch2Map;
int swayQ3 = -ch2Map;
int swayQ4 = ch2Map;
int yawQ1 = -ch3Map; // yaw (CLOCKWISE positive)
int yawQ2 = ch3Map;
int yawQ3 = ch3Map;
int yawQ4 = -ch3Map;
// Map thruster components from -1000 to 1000
q1Setpoint = constrain(surgeQ1 + swayQ1 + yawQ1,-1000,1000);
q2Setpoint = constrain(surgeQ2 + swayQ2 + yawQ2,-1000,1000);
q3Setpoint = constrain(surgeQ3 + swayQ3 + yawQ3,-1000,1000);
q4Setpoint = constrain(surgeQ4 + swayQ4 + yawQ4,-1000,1000);
}
// Calculate acceleration-limited outputs as a function of the setpoint and send to thrusters
void setpoint2Output() {
// Calculate time delta since last loop
timeNow = millis();
float timeDelta = (timeNow - timeLast) * 0.001;
// Calculate maximum thrust delta
float thrustDelta = accLimit * 10 * timeDelta; // maximum change in thrust component percentage in this loop [%]
// Calculate actual thrust delta
int q1Delta = q1Setpoint - q1Last;
int q2Delta = q2Setpoint - q2Last;
int q3Delta = q3Setpoint - q3Last;
int q4Delta = q4Setpoint - q4Last;
// Limit Q1 output thrust if change in setpoint is greater than allowable delta
if (abs(q1Delta) > thrustDelta) {
if (q1Delta > 0) {
q1Out = q1Last + thrustDelta;
}
else {
q1Out = q1Last - thrustDelta;
}
}
else {
q1Out = q1Setpoint;
}
// Limit Q2 output thrust if change in setpoint is greater than allowable delta
if (abs(q2Delta) > thrustDelta) {
if (q2Delta > 0) {
q2Out = q2Last + thrustDelta;
}
else {
q2Out = q2Last - thrustDelta;
}
}
else {
q2Out = q2Setpoint;
}
// Limit Q3 output thrust if change in setpoint is greater than allowable delta
if (abs(q3Delta) > thrustDelta) {
if (q3Delta > 0) {
q3Out = q3Last + thrustDelta;
}
else {
q3Out = q3Last - thrustDelta;
}
}
else {
q3Out = q3Setpoint;
}
// Limit Q4 output thrust if change in setpoint is greater than allowable delta
if (abs(q4Delta) > thrustDelta) {
if (q4Delta > 0) {
q4Out = q4Last + thrustDelta;
}
else {
q4Out = q4Last - thrustDelta;
}
}
else {
q4Out = q4Setpoint;
}
// Save timeNow and thruster output components for calculation in next loop
timeLast = timeNow;
q1Last = q1Out;
q2Last = q2Out;
q3Last = q3Out;
q4Last = q4Out;
}
// Scale output to thrusters by a multiplier (typically to limit voltage output to thruster)
void scaleOutput() {
q1Out = q1Out*voltMult;
q2Out = q2Out*voltMult;
q3Out = q3Out*voltMult;
q4Out = q4Out*voltMult;
}
// Write output thruster values to motor controllers
void output2Thruster() {
// reverse = 31, neutral = 47, forward = 63
int q1Bit = map(q1Out,-1000,1000,31,63);
int q2Bit = map(q2Out,-1000,1000,31,63);
int q3Bit = map(q3Out,-1000,1000,31,63);
int q4Bit = map(q4Out,-1000,1000,31,63);
// Write to motor controller pins
analogWrite(q1Pin,q1Bit);
analogWrite(q2Pin,q2Bit);
analogWrite(q3Pin,q3Bit);
analogWrite(q4Pin,q4Bit);
}
// Changes color of light
void changeLight(int lightColor) {
// light color variable (0 = off, 1 = white, 2 = red, 3 = green, 4 = blue, 5 = yellow, 6 = light blue)
if (lightColor == 0) {
digitalWrite(redPin,HIGH);
digitalWrite(bluePin,HIGH);
digitalWrite(greenPin,HIGH);
}
else if (lightColor == 1) {
digitalWrite(redPin,LOW);
digitalWrite(bluePin,LOW);
digitalWrite(greenPin,LOW);
}
else if (lightColor == 2) {
digitalWrite(redPin,LOW);
digitalWrite(bluePin,HIGH);
digitalWrite(greenPin,HIGH);
}
else if (lightColor == 3) {
digitalWrite(redPin,HIGH);
digitalWrite(bluePin,HIGH);
digitalWrite(greenPin,LOW);
}
else if (lightColor == 4) {
digitalWrite(redPin,HIGH);
digitalWrite(bluePin,LOW);
digitalWrite(greenPin,HIGH);
}
else if (lightColor == 5) {
digitalWrite(redPin,LOW);
digitalWrite(bluePin,HIGH);
digitalWrite(greenPin,LOW);
}
else if (lightColor == 6) {
digitalWrite(redPin,HIGH);
digitalWrite(bluePin,LOW);
digitalWrite(greenPin,LOW);
}
}
// Read battery voltage
void battRead() {
battVoltBit = analogRead(batteryPin);
battVoltArd = battVoltBit/(205.0);
battVoltTrue = battVoltArd*4.625;
voltMult = 12/battVoltTrue;
if (voltMult >= 1) {
voltMult == 1;
}
}
// Perform battery check if user desires it
void batteryCheck() {
// Read channel 4
ch4Pulse = pulseIn(ch4Pin,HIGH);
if (ch4Pulse > ch4PulseMax - pulseTolerance && ch4Pulse < ch4PulseMax + pulseTolerance) {
int battLevel = 0;
// 0 = dead (V < 14)
// 1 = low (14<V<14.66)
// 2 = medium low (14.66<V<15.33)
// 3 = medium full (15.33<V<15.99)
// 4 = full (15.99<V<16.65)
// 5 = invalid
Serial.print("checking battery voltage...battery voltage is ");
Serial.println(battVoltTrue);
if (battVoltTrue < 14) {
battLevel = 0;
batteryLight(battLevel);
}
else if (battVoltTrue >= 14 && battVoltTrue < 14.66) {
battLevel = 1;
batteryLight(battLevel);
}
else if (battVoltTrue >= 14.66 && battVoltTrue < 15.33) {
battLevel = 2;
batteryLight(battLevel);
}
else if (battVoltTrue >= 15.33 && battVoltTrue < 15.99) {
battLevel = 3;
batteryLight(battLevel);
}
else if (battVoltTrue >= 15.99 && battVoltTrue < 16.65 + 0.25) {
battLevel = 4;
batteryLight(battLevel);
}
else {
battLevel = 5;
batteryLight(battLevel);
}
}
}
void batteryLight(int battLevel) {
if (battLevel == 0) {
changeLight(2);
delay(200);
changeLight(0);
delay(200);
changeLight(2);
delay(200);
changeLight(0);
delay(200);
changeLight(2);
delay(200);
changeLight(0);
delay(200);
changeLight(2);
delay(200);
changeLight(0);
delay(200);
changeLight(2);
delay(200);
changeLight(0);
delay(200);
}
else if (battLevel == 1) {
changeLight(2);
delay(200);
changeLight(4);
delay(200);
changeLight(2);
delay(200);
changeLight(4);
delay(200);
changeLight(2);
delay(200);
changeLight(4);
delay(200);
changeLight(2);
delay(200);
changeLight(4);
delay(200);
changeLight(2);
delay(200);
changeLight(4);
delay(200);
}
else if (battLevel == 2) {
changeLight(4);
delay(2000);
}
else if (battLevel == 3) {
changeLight(3);
delay(200);
changeLight(4);
delay(200);
changeLight(3);
delay(200);
changeLight(4);
delay(200);
changeLight(3);
delay(200);
changeLight(4);
delay(200);
changeLight(3);
delay(200);
changeLight(4);
delay(200);
changeLight(3);
delay(200);
changeLight(4);
delay(200);
}
else if (battLevel == 4) {
changeLight(3);
delay(2000);
}
else {
changeLight(1);
delay(200);
changeLight(0);
delay(200);
changeLight(1);
delay(200);
changeLight(0);
delay(200);
changeLight(1);
delay(200);
changeLight(0);
delay(200);
changeLight(1);
delay(200);
changeLight(0);
delay(200);
changeLight(1);
delay(200);
changeLight(0);
delay(200);
}
}
|
c01f98a6ef786b7471e9305bb883d910214dabd4
|
393aa0b9f22501f5e1972730efbbae6f6e0d34ba
|
/Juego/codigo/iCuartelGeneral.h
|
b8d9c1940bc0b705ee97088e59e1f23d4374efdd
|
[] |
no_license
|
riseven/JRK
|
5c18d7bfcf2482e2ef6ed2515a64b3e7c4b32c10
|
a91da8270cc2dde33c91611a92e64c1bb143794e
|
refs/heads/master
| 2021-01-10T18:26:35.998045
| 2012-10-09T14:49:02
| 2012-10-09T14:49:02
| 5,834,089
| 1
| 1
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 972
|
h
|
iCuartelGeneral.h
|
#ifndef __I_CUARTEL_GENERAL_H__
#define __I_CUARTEL_GENERAL_H__
#include "iUnidadUniSeleccionable.h"
#include "iApi.h"
#include <string>
namespace Interfaz
{
class CuartelGeneral : public UnidadUniSeleccionable
{
private:
bool construirIngeniero ;
bool desarrollarMotivacion ;
bool desarrollarMotivacionMasDistancia ;
int porcentajeConstruido ;
void MostrarBotonesTecnologia();
//----------
static int textura ;
static int modeloHandler[8] ;
public:
CuartelGeneral(int numJugador) ;
virtual ~CuartelGeneral() ;
void SetPorcentajeConstruido(int porcentaje);
void Seleccionar();
void Actualizar();
int GetTipo();
bool EsReparable(){return true;}
string GetPathRecursos() { return "Unidades\\CuartelGeneral\\"; }
static void Inicializar() ;
static void Cerrar();
static int GetModeloHandler(int numJugador){return modeloHandler[numJugador];}
};
}
#endif
|
337cc697c432d86559f61a046ee39e2c8fd0a339
|
a4b959855991fbca07d5f2730d6c38072962f844
|
/source_files/BinaryTree.h
|
c0ed6e1c2dabe3aeacc2f03e37b4e8521caaf686
|
[] |
no_license
|
syedsufyan1232/CIS22C-FinalProject
|
a9f2077e6a52119dda287f1695f0b3c95e8c447d
|
c5b872c3f282aa24a69a31737046ad5170add9fe
|
refs/heads/master
| 2020-05-28T02:29:36.684754
| 2017-03-26T01:32:39
| 2017-03-26T01:32:39
| 82,579,342
| 0
| 0
| null | 2017-03-23T04:56:12
| 2017-02-20T16:36:01
|
C++
|
UTF-8
|
C++
| false
| false
| 7,201
|
h
|
BinaryTree.h
|
// Syed Tihami
// BinaryTree.h
//
#ifndef BinaryTree_h
#define BinaryTree_h
#include <iostream>
using namespace std;
//***************************************************************************
//***************************************************************************
// Definition of Binary Tree:
//***************************************************************************
//***************************************************************************
template <class D>
class BinaryTree {
private:
struct btNode {
D data;
btNode *left;
btNode *right;
btNode() { left = right = nullptr; }
};
int count;
btNode *root;
public:
BinaryTree() : count(0), root(nullptr) {}
~BinaryTree() { deleteSubTree(root); }
BinaryTree(const BinaryTree &obj);
const BinaryTree &operator=(const BinaryTree &obj);
void deleteSubTree(btNode *);
void copySubTree(btNode *, btNode *&);
void resort();
void reinsert(btNode *);
void insert(D value) { insert(value, root); }
template <class C>
bool remove(C value) { return remove(value, root); }
template <class C>
btNode *search(C value) { return search(value, root); }
void printIndented(ostream &out = cout) { printIndented(root, 0, out); }
void printInorder(ostream &out = cout) { printInorder(root, out); }
btNode *getRoot() { return root; }
void insert(D, btNode*&);
template <class C>
bool remove(C, btNode*&);
void deleteNode(btNode*&);
template <class C>
btNode *search(C, btNode*);
void printIndented(btNode*, int, ostream &);
void printInorder(btNode*, ostream &);
operator LinkedList<D>();
LinkedList<D> &convertToList(btNode *node, LinkedList<D> &list);
LinkedList<D> &convertToList(LinkedList<D> &list) { return convertToList(root, list); }
//Specialized Traversals:
void printFilePreorder(ostream &out = cout) { printFilePreorder(root, out); }
void printFilePreorder(btNode*, ostream &);
void deAllocate() { deAllocate(root); }
void deAllocate(btNode*);
};
//***************************************************************************
//***************************************************************************
// Implementation of Binary Tree:
//***************************************************************************
//***************************************************************************
//***************************************************************************
//Definition of BinaryTree Template Class copy constructor *
//***************************************************************************
template <class D>
BinaryTree<D>::BinaryTree(const BinaryTree &obj) {
copySubTree(obj.root, root);
}
template <class D>
const BinaryTree<D> &BinaryTree<D>::operator=(const BinaryTree<D> &obj) {
copySubTree(obj.root, root);
return *this;
}
template <class D>
void BinaryTree<D>::deleteSubTree(btNode *node) {
if (node) {
if (node->left) deleteSubTree(node->left);
if (node->right) deleteSubTree(node->right);
delete node;
node = nullptr;
count--;
}
}
template <class D>
void BinaryTree<D>::copySubTree(btNode *node, btNode *&newNode) {
if (node) {
newNode = new btNode;
newNode->data = node->data;
count++;
if (node->left) {
copySubTree(node->left, newNode->left);
}
if (node->right) {
copySubTree(node->right, newNode->right);
}
}
}
template <class D>
void BinaryTree<D>::resort() {
if (root) {
BinaryTree<D> *newTree = new BinaryTree<D>;
newTree->insert(root->data);
newTree->reinsert(root->left);
newTree->reinsert(root->right);
deleteSubTree(root);
root = newTree->root;
newTree->root = nullptr;
}
}
template <class D>
void BinaryTree<D>::reinsert(btNode *oldNode) {
if (oldNode) {
insert(oldNode->data);
if (oldNode->left) reinsert(oldNode->left);
if (oldNode->right) reinsert(oldNode->right);
}
}
template <class D>
void BinaryTree<D>::insert(D value, btNode *&node) {
if (node) {
if (node->data >= value) {
insert(value, node->left);
}
else if (node->data < value) {
insert(value, node->right);
}
}
else {
node = new btNode;
node->data = value;
node->left = node->right = nullptr;
//balance();
count++;
}
}
template <class D>
template <class C>
bool BinaryTree<D>::remove(C value, btNode *&node) {
if (!node) return false;
else if (node->data < value)
return remove(value, node->right);
else if (node->data > value)
return remove(value, node->left);
else if (node->data == value) {
deleteNode(node);
count--;
return true;
}
return false;
}
template <class D>
void BinaryTree<D>::deleteNode(btNode *&node) {
if (!node) throw "ERROR: Cannot delete empty node!";
btNode *replacement = nullptr;
if (!node->left) {
replacement = node->right;
delete node;
node = replacement;
}
else if (!node->right) {
replacement = node->left;
delete node;
node = replacement;
}
else {
btNode *tempNode = node->right;
while (tempNode->left)
tempNode = tempNode->left;
btNode temp = *tempNode;
remove(tempNode->data, node);
node->data = temp.data;
}
}
template <class D>
template <class C>
typename BinaryTree<D>::btNode *BinaryTree<D>::search(C value, btNode *node) {
btNode *location = nullptr;
if (node) {
if (node->data == value) {
location = node;
}
else if (node->data >= value) {
location = search(value, node->left);
}
else if (node->data < value) {
location = search(value, node->right);
}
}
return location;
}
template <class D>
void BinaryTree<D>::printInorder(btNode *node, ostream &out) {
if (node != nullptr) {
if (node->left != nullptr) {
printInorder(node->left, out);
}
out <<"\t" << node->data << endl;
if (node->right != nullptr) {
printInorder(node->right, out);
}
}
}
template <class D>
void BinaryTree<D>::printIndented(btNode *node, int level, ostream &out) {
if (node) {
if (node->right) printIndented(node->right, level + 1, out);
for (int i = 0; i < (level * 3) + 7; i++) {
if (level == 0) {
if (i == 0)
out << "Root-> ";
}
else out << ' ';
}
out << node->data << endl;
if (node->left) printIndented(node->left, level + 1, out);
}
}
template <class D>
void BinaryTree<D>::printFilePreorder(btNode *node, ostream &out) {
if (node != nullptr) {
static_cast<Professor*>(node->data)->printToFile(out);
out << endl;
if (node->left != nullptr) {
printFilePreorder(node->left, out);
}
if (node->right != nullptr) {
printFilePreorder(node->right, out);
}
}
}
template <class D>
void BinaryTree<D>::deAllocate(btNode* node) {
if (node) {
deAllocate(node->left);
deAllocate(node->right);
delete static_cast<Professor*>(node->data);
}
}
template <class D>
LinkedList<D> &BinaryTree<D>::convertToList(btNode *node, LinkedList<D> &list) {
if (node) {
list.insertSorted(node->data);
convertToList(node->left, list);
convertToList(node->right, list);
}
return list;
}
#endif
|
b98c51c51104714f6d0ef5dac7f89d7e8360922b
|
25a7f5359c1101c8a494166815aa852d2b142a96
|
/MOC1_fi02mn_var2_Anatolii_Artem.cpp
|
720460261d21a5a3ae63010fcad71145b0feedbb
|
[] |
no_license
|
MOCLabs/Lab1
|
5545328954852cad735ecff18639dadf9c97d0db
|
d132a6e17232114ef39e0927ddf49bd38b69a322
|
refs/heads/master
| 2023-02-16T23:43:21.696835
| 2021-01-18T06:08:01
| 2021-01-18T06:08:01
| 329,137,227
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 8,804
|
cpp
|
MOC1_fi02mn_var2_Anatolii_Artem.cpp
|
#include <iostream>
#include <string>
#include <vector>
#include <iterator>
#include <fstream>
#include <numeric>
void collect_the_csv_values(std::vector<float>& pM, std::vector<float>& pK, std::vector<float>& pC, std::vector<std::vector<uint32_t>>& table)
{
std::fstream csv_read_probs("/home/ftl/moc1/vars/prob_06.csv", std::ios::in);
std::fstream csv_read_table("/home/ftl/moc1/vars/table_06.csv", std::ios::in);
std::string temp;
////////////////////////////reading prob_XX.csv ////////////////////////
getline(csv_read_probs, temp);
std::cout << temp << std::endl;
for(size_t i = 0; i < 20; ++i)
{
pM.push_back(std::stof(temp));
if(i != 19)
{
temp.erase(temp.begin(), temp.begin()+5);
}
}
getline(csv_read_probs, temp);
std::cout << temp << std::endl;
for(size_t i = 0; i < 20; ++i)
{
pK.push_back(std::stof(temp));
if(i != 19)
{
temp.erase(temp.begin(), temp.begin()+5);
}
}
//////////////////////////////////reading table_XX ////////////////////////////////
for(size_t i = 0; i < 20; ++i)
{
getline(csv_read_table, temp);
for(size_t j = 0; j < 20; ++j)
{
table[i][j] = (std::stoul(temp));
if(j != 19)
{
temp.erase(0 , temp.find_first_of(',')+1);
}
}
}
for(auto it = table.begin(); it != table.end(); ++it)
{
for(auto it1 = (*it).begin(); it1 != (*it).end(); ++it1)
{
std::cout << *it1 << ", ";
}
std::cout << std::endl;
}
///////////////////////////////////calculation of std::vector<float> pC /////////////////////////////
std::vector<std::vector<float>> pMandK(20, std::vector<float>(20,0));
for(size_t i = 0; i < 20; ++i)
{
for(size_t j = 0; j < 20; ++j)
{
pMandK[i][j] = (pM[i] * pK[j]);
}
}
for(size_t i = 0; i < 20; ++i)
{
for(size_t j = 0; j < 20; ++j)
{
pC[table[i][j]] += pMandK[j][i];
}
}
csv_read_probs.close();
csv_read_table.close();
}
void create_pMifC_csv(std::vector<float> pM, std::vector<float> pK, std::vector<float> pC, std::vector<std::vector<uint32_t>> table, std::vector<std::vector<float>>& pMandC, std::vector<std::vector<float>>& pMifC)
{
std::fstream csv_write_pMifC("/home/ftl/moc1/pMifC.csv", std::fstream::out);
//////////////////////////////calculation of pMandC /////////////////////////////
std::vector<std::vector<float>> pMandK(20, std::vector<float>(20,0));
for(size_t i = 0; i < 20; ++i)
{
for(size_t j = 0; j < 20; ++j)
{
pMandK[i][j] = (pM[i] * pK[j]);
}
}
for(size_t i = 0; i < 20; ++i)
{
for(size_t j = 0; j < 20; ++j)
{
pMandC[i][table[j][i]] += pMandK[i][j];
}
}
//////////////////////////////calculation of pMifC////////////////////////////
for(size_t i = 0; i < 20; ++i)
{
for(size_t j = 0; j < 20; ++j)
{
pMifC[i][j] = (pMandC[i][j] / pC[j]);
}
}
auto copypMifC = pMifC;
for(size_t i = 0; i < 20; ++i)
{
for(size_t j = 0; j < 20; ++j)
{
copypMifC[j][i] = pMifC[i][j];
std::cout << pMifC[i][j] << ", ";
}
std::cout << std::endl;
}
for(size_t i = 0; i < 20; ++i)
{
for(size_t j = 0; j < 20; ++j)
{
csv_write_pMifC << copypMifC[i][j] << ',';
}
csv_write_pMifC << '\n';
}
csv_write_pMifC.close();
}
std::vector<std::pair<uint32_t,uint32_t>> Deterministic(std::vector<std::vector<uint32_t>> table, std::vector<std::vector<float>> pMandC, std::vector<std::vector<float>> pMifC)
{
std::vector<std::pair<uint32_t,uint32_t>> CT_and_PT(20, std::pair<uint32_t, uint32_t>(0,0));
float vitrati = 0.0;
uint32_t answ = 0;
/* //DEBUG
std::cout << std::endl << "------------------------------------------------" << std::endl;
for(size_t i = 0; i < 20; ++i)
{
for(size_t j = 0; j < 20; ++j)
{
std::cout << pMandC[i][j] << ", ";
}
std::cout << std::endl;
}
std::cout << std::endl << "------------------------------------------------" << std::endl;
std::cout << std::endl << "------------------------------------------------" << std::endl;
for(size_t i = 0; i < 20; ++i)
{
for(size_t j = 0; j < 20; ++j)
{
std::cout << pMifC[i][j] << ", ";
}
std::cout << std::endl;
}
std::cout << std::endl << "------------------------------------------------" << std::endl;
*/
for(size_t col = 0; col < table.size(); ++col)
{
answ = 0;
for(size_t row = 0; row < table.size(); ++row)
{
if(pMifC[answ][col] < pMifC[row][col])
{
answ = row;//std::max_element if transponate the matrix
}
}
if(answ != table[col][answ])
{
vitrati = vitrati + pMandC[answ][col];
}
CT_and_PT[col] = {col, answ};
}
std::cout << "VIT " << vitrati << std::endl;
std::cout << "1.0 - VIT " << 1.0 - vitrati << std::endl;
return CT_and_PT;
}
std::vector<std::pair<uint32_t, uint32_t>> Stohastic(std::vector<std::vector<uint32_t>> table, std::vector<std::vector<float>> pMandC, std::vector<std::vector<float>> pMifC)
{
std::vector<std::pair<uint32_t, uint32_t>> ret(20, std::pair<uint32_t, uint32_t>(0,0));
float vitrati = 0.0;
uint32_t answ = 0;
float L = 0.0;
float cos = 0.0;
std::vector<std::vector<float>> L_matrix(20,std::vector<float>(20,1.0));
std::vector<std::vector<uint32_t>> Answ_coord (20, std::vector<uint32_t>(0,0));
for(size_t col = 0; col < table.size(); ++col)
{
ret[col].first = col;
answ = 0;
// vitrati = 0.0;
uint32_t amount = 0;
auto biggest = pMifC[0][col];
uint32_t it = 0;
for(size_t row = 0; row < table.size(); ++row)
{
if(pMifC[row][col] > pMifC[answ][col])
{
answ = row;
amount = 1;
biggest = pMifC[row][col];
it = row;
}
if(pMifC[row][col] == pMifC[answ][col])
{
amount += 1;
}
}
std::cout << "AMOUNT " <<amount << std::endl;
//std::cout << "BIGGEST " << biggest << std::endl;
for(size_t row = 0; row < table.size(); ++row)
{
if(pMifC[row][col] == pMifC[it][col])
{
Answ_coord[col].push_back(row);
}
}
/*
for(auto it = Answ_coord.begin(); it != Answ_coord.end(); ++it)
{
for(auto iter = (*it).begin(); iter != (*it).end(); ++iter)
{
std::cout << *iter << ", ";
}
std::cout << std::endl;
}
*/
L = 0.0;
// L = (20-amount) * (((float)(1.0) / (float)(amount)));
// L matrix 20x20
// L x pMandC ; sum (LxP; L)
vitrati += ((L) * ( pMandC[it][col]));
ret[col].second = it;
// std::cout << "prob for " << col << " is " << ((float)(1.0) / ((float)amount)) << std::endl;
// std::cout << "vitrati for " << col << " is " << vitrati << std::endl;
}
for(size_t i = 0; i < table.size(); ++i)
{
for(size_t j = 0; j < Answ_coord[i].size(); ++j)
{
L_matrix[i][Answ_coord[i][j]] = 1.0 - ( 1.0 / (float)(Answ_coord[i].size() ) );
//std::cout << Answ_coord[i][j] << ", ";
}
}
for(size_t i = 0; i < table.size(); ++i)
{
for(size_t j = 0; j < Answ_coord[i].size(); ++j)
{
std::cout << Answ_coord[i][j] << ", ";
}
std::cout << std::endl;
}
auto zigota = pMandC;
for(size_t i = 0; i < table.size(); ++i)
{
for(size_t j = 0; j < table.size(); ++j)
{
//scalar multuplication! this is a mistake
//for(size_t beg = 0; beg < table.size(); ++beg)
//{
// zigota[i][j] += (L_matrix[i][beg] * pMandC[beg][i]);
//}
zigota[i][j] = L_matrix[i][j] * pMandC[j][i];
std::cout << L_matrix[i][j] << ", ";
}
std::cout << std::endl;
}
for(size_t i = 0; i < table.size(); ++i)
{
for(size_t j = 0; j < table.size(); ++j)
{
std::cout << zigota[i][j] << ", ";
}
std::cout << std::endl;
}
float sum = 0.0;
for(auto it = zigota.begin(); it != zigota.end(); ++it)
{
sum += std::accumulate((*it).begin(), (*it).end(), 0.0);
std::cout <<"sum " << sum << std::endl;
}
std::cout << "VICTORYYYYYYYYYYYYY : " << sum << std::endl;
std::cout << "VIT_S " << vitrati << std::endl;
std::cout << "1.0 - VIT_S " << 1.0 - vitrati << std::endl;
return ret;
}
int main()
{
std::vector<float> pM(0, 0);
std::vector<float> pK(0, 0);
std::vector<std::vector<uint32_t>> table(20, std::vector<uint32_t>(20,0));
std::vector<float> pC(20,0);
std::vector<std::vector<float>> pMandC(20, std::vector<float>(20,0));
std::vector<std::vector<float>> pMifC(20, std::vector<float>(20,0));
collect_the_csv_values(pM, pK, pC, table);
create_pMifC_csv(pM, pK, pC, table, pMandC, pMifC);
auto answ_D = Deterministic(table, pMandC, pMifC);
std::cout << std::endl << "Deterministic Function" << std::endl;
for(auto it = answ_D.begin(); it != answ_D.end(); ++it)
{
std::cout << (*it).first << " ----> " << (*it).second << std::endl;
}
std::cout << std::endl << std::endl;
auto answ_S = Stohastic(table, pMandC, pMifC);
std::cout << std::endl << "Stohastic Function" << std::endl;
for(auto it = answ_S.begin(); it != answ_S.end(); ++it)
{
std::cout << (*it).first << " ----> " << (*it).second << std::endl;
}
return 0;
}
|
82c07ccbe2d3a18b7c3f91cfaec4e178fcfa083e
|
34a2718ee82284d30406084eebaae5465692dd37
|
/Classes/Utils/Common.cpp
|
72873b58d1ce01d9dd60d050d182ad2be964aa8e
|
[
"MIT"
] |
permissive
|
bacph178/MyCards
|
fc185b19ac3425a641cfb498e70c9c8f0207afef
|
392b3175d1927807ad72e545233297bb93dd4651
|
refs/heads/master
| 2020-12-11T09:22:44.437169
| 2016-04-13T04:30:47
| 2016-04-13T04:30:47
| 56,132,684
| 0
| 0
| null | 2016-04-13T08:01:34
| 2016-04-13T08:01:33
| null |
UTF-8
|
C++
| false
| false
| 1,987
|
cpp
|
Common.cpp
|
#include "Common.h"
#include <string>
#define TEST_ENVIRONMENT 1
Common::Common(std::string device_id, std::string device_info, std::string
app_version, std::string cp, std::string country, std::string language,
std::string ipaddress, int os, int channelId
) {
this->device_id = device_id;
this->device_info = device_info;
this->app_version = app_version;
this->cp = cp;
this->country = country;
this->language = language;
this->ipaddress = ipaddress;
this->os = os;
this->channelId = channelId;
}
Common::~Common() {
}
int Common::FACEBOOK_CHANNEL = 1;
int Common::GOOGLE_CHANNEL = 2;
int Common::ANDROID = 1;
int Common::IOS = 2;
int Common::TIENLENMIENNAM_ZONE = 5;
/* Singleton pattern */
Common* Common::instance = 0;
Common* Common::getInstance() {
if (!instance) {
instance = new Common();
}
return instance;
}
std::string Common::getDeviceId() const {
if (TEST_ENVIRONMENT)
return "00000000";
}
std::string Common::getDeviceInfo() const {
if (TEST_ENVIRONMENT)
return "Samsung Galaxy S2";
}
std::string Common::getAppVersion() const {
if (TEST_ENVIRONMENT)
return "1";
}
std::string Common::getCp() const {
if (TEST_ENVIRONMENT)
return "0";
}
std::string Common::getCountry() const {
if (TEST_ENVIRONMENT)
return "vn";
}
std::string Common::getLanguage() const {
if (TEST_ENVIRONMENT)
return "vi";
}
std::string Common::getIpaddress() const {
if (TEST_ENVIRONMENT)
return "127.0.0.1";
}
int Common::getOS() {
if (os == 0) {
#if (CC_TARGET_PLATFORM == CC_PLATFORM_ANDROID)
os = Common::ANDROID;
#elif (CC_TARGET_PLATFORM == CC_PLATFORM_IOS)
os =Common::IOS;
#else
os = 0;
#endif
}
return os;
}
int Common::getZoneId(int tag) const {
int result = -1;
switch (tag)
{
default:
result = Common::TIENLENMIENNAM_ZONE;
break;
}
return result;
}
int Common::getChannelId() {
if (channelId == 0) {
if (TEST_ENVIRONMENT)
channelId = Common::FACEBOOK_CHANNEL; //Facebook
}
return channelId;
}
|
f2a32e7ce243ca3956a410646735737012ea0587
|
d69a44e8174e108a0e3f221ac45dea81f6fcff3e
|
/include/VulkanRenderer.hpp
|
009ee651c94f5a7502a01325cfad9fa66ce45668
|
[
"MIT"
] |
permissive
|
azalac/VulkanGame
|
99f8b6e98660bca276c270fdd98a8283c6b4ebe3
|
29ebd7e111bbe6effe1c726cbe1423b54a74f7a4
|
refs/heads/master
| 2020-04-20T01:54:03.266878
| 2019-04-21T17:52:08
| 2019-04-21T17:52:08
| 168,557,710
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 9,112
|
hpp
|
VulkanRenderer.hpp
|
/*
* To change this license header, choose License Headers in Project Properties.
* To change this template file, choose Tools | Templates
* and open the template in the editor.
*/
/*
* File: VulkanRenderer.hpp
* Author: austin-z
*
* Created on February 9, 2019, 9:16 PM
*/
#ifndef VULKANRENDERER_HPP
#define VULKANRENDERER_HPP
#include "VulkanRenderPipeline.hpp"
#include "VulkanCommandBuffer.hpp"
#include "VulkanImage.hpp"
#include "VulkanSwap.hpp"
#include <mutex>
// Controls the direct screen buffer manipulation
// Does not control the command buffer recording
class VulkanScreenBufferController {
private:
vk::ClearValue clearValue;
vk::Rect2D screen;
class FrameInfo {
public:
vk::Semaphore renderFinished, imageAvailable;
vk::Fence fence;
size_t index;
std::mutex mutex;
FrameInfo(VulkanDevice & device, size_t frame) {
renderFinished = device->createSemaphore(vk::SemaphoreCreateInfo());
imageAvailable = device->createSemaphore(vk::SemaphoreCreateInfo());
fence = device->createFence(vk::FenceCreateInfo());
index = frame;
}
};
std::map<int, std::unique_ptr<FrameInfo>> frames;
VulkanDevice & device;
VulkanSwapchain & swapchain;
size_t currentImage = 0, frameIndex = 0, maxFrames;
public:
VulkanScreenBufferController(VulkanDevice & device, VulkanSwapchain & swapchain,
vk::ClearColorValue clearColor = std::array<float, 4>{0.0f, 0.0f, 0.0f, 0.0f},
size_t nframes = 0) :
device(device), swapchain(swapchain) {
screen.offset = vk::Offset2D(0, 0);
screen.extent = swapchain.getExtent();
clearValue.color = clearColor;
maxFrames = nframes < 1 ? swapchain.frameCount() : nframes;
for (size_t i = 0; i < maxFrames; i++) {
frames[i] = std::move(std::unique_ptr<FrameInfo>(new FrameInfo(device, i)));
}
}
uint32_t currentIndex() {
return currentImage;
}
size_t getFrameIndex() {
return frameIndex;
}
/**
* Acquires the next image from the swapchain
* @param fence The fence to use
* @return Whether the acquire was sucessful or not
*/
bool acquireImage(vk::Fence fence) {
try {
currentImage = device->acquireNextImageKHR(swapchain.getSwapchain().get(),
std::numeric_limits<uint64_t>::max(), frames[frameIndex]->imageAvailable, fence).value;
} catch (std::exception) {
return false;
}
return true;
}
/**
* Submits a command buffer for execution
* @param queue The queue to submit on
* @param buffer The buffer to submit
* @param fence The fence to wait for
* @return Whether the submit was successful or not
*/
bool submit(VulkanQueue & queue, vk::CommandBuffer buffer, vk::Fence fence) {
vk::SubmitInfo submitInfo;
vk::PipelineStageFlags waitStages[] = {vk::PipelineStageFlagBits::eColorAttachmentOutput};
submitInfo.waitSemaphoreCount = 1;
submitInfo.pWaitSemaphores = &frames[frameIndex]->imageAvailable;
submitInfo.pWaitDstStageMask = waitStages;
submitInfo.commandBufferCount = 1;
submitInfo.pCommandBuffers = &buffer;
submitInfo.signalSemaphoreCount = 1;
submitInfo.pSignalSemaphores = &frames[frameIndex]->renderFinished;
return queue.graphicsSubmit(submitInfo, fence) == vk::Result::eSuccess;
}
/**
* Presents the most recently acquired frame
* @param queue The queue to submit on
* @return Whether the present was successful or not
*/
bool present(VulkanQueue & queue) {
vk::PresentInfoKHR presentInfo;
presentInfo.waitSemaphoreCount = 1;
presentInfo.pWaitSemaphores = &frames[frameIndex]->renderFinished;
presentInfo.swapchainCount = 1;
presentInfo.pSwapchains = &swapchain.getSwapchain().get();
uint32_t indices[] = {
(uint32_t)currentImage
};
presentInfo.pImageIndices = indices;
presentInfo.pResults = nullptr;
try {
return queue.presentSubmit(presentInfo) == vk::Result::eSuccess;
} catch (std::exception) {
return false;
}
}
/**
* Controls the above three methods and wraps queueing in a simple to use
* interface
* @param queue The queue to submit on
* @param buffer The buffer to submit
* @param blocking Whether the method should wait for the render to finish
* or not
* @return Whether everything was successful or not
*/
bool queueDraw(VulkanQueue & queue, vk::CommandBuffer buffer, bool blocking = true) {
device->resetFences({frames[frameIndex]->fence});
if (!submit(queue, buffer, frames[frameIndex]->fence)) {
return false;
}
if (!present(queue)) {
return false;
}
if (blocking) {
device->waitForFences({frames[frameIndex]->fence}, true, std::numeric_limits<uint64_t>::max());
}
frameIndex = (frameIndex + 1) % maxFrames;
return true;
}
};
// Controls a secondary command buffer for recording a material.
class MaterialRenderer {
private:
VulkanQueue * queue;
VulkanSwapchain * swapchain;
VulkanRenderPass * renderPass;
VulkanCommandBufferGroup * buffers;
Material * material;
VulkanIndexBuffer * indexBuffer;
VulkanViewport * viewport;
std::vector<vk::Buffer> vBuffers;
std::set<int> recorded;
public:
MaterialRenderer(VulkanSwapchain * swapchain, VulkanRenderPass * renderPass,
VulkanQueue * queue, VulkanCommandBufferPool * pool, VulkanViewport * viewport,
Material * material, VulkanIndexBuffer * indexBuffer = nullptr) {
this->swapchain = swapchain;
this->renderPass = renderPass;
this->queue = queue;
this->material = material;
this->indexBuffer = indexBuffer;
this->viewport = viewport;
this->vBuffers = material->getVertexBuffers();
this->buffers = pool->allocateGroup(2, vk::CommandBufferLevel::eSecondary);
}
~MaterialRenderer() {
delete buffers;
}
std::shared_ptr<char> getPushConstant(int id) {
return material->pushconst(id);
}
void setIndexBuffer(VulkanIndexBuffer * indexBuffer) {
this->indexBuffer = indexBuffer;
}
/**
* Checks for updates in the descriptor set
* @param frame The current frame
*/
void checkForUpdates(size_t frame) {
material->checkForUpdates(true);
return;
// if the frame hasn't been recorded yet, update it
if (recorded.find(frame) == recorded.end()) {
material->checkForUpdates(true);
recorded.insert(frame);
} else {
// if no updates, don't record the buffer again
if (!material->checkForUpdates()) {
return;
}
}
}
/**
* Records a specific frame
* @param frame The frame to record
*/
void recordFrame(size_t frame) {
if (this->indexBuffer == nullptr) {
throw std::runtime_error("Index Buffer cannot be null");
}
vk::CommandBufferInheritanceInfo inheritance(renderPass->getRenderPass(), 0, swapchain->getFrame(frame));
vk::CommandBuffer buffer = buffers->get(frame);
buffer.begin(vk::CommandBufferBeginInfo(vk::CommandBufferUsageFlagBits::eRenderPassContinue, &inheritance));
buffer.setScissor(0,{viewport->getScissor()});
buffer.setViewport(0,{viewport->getView()});
if (material->hasDescriptors()) {
buffer.bindDescriptorSets(vk::PipelineBindPoint::eGraphics,
material->getPipeline()->getLayout(), 0, 1, &material->getDescriptorSet(), 0, nullptr);
}
if (vBuffers.size() > 0) {
std::vector<vk::DeviceSize> offsets(vBuffers.size());
buffer.bindVertexBuffers(0, vBuffers.size(), vBuffers.data(), offsets.data());
}
for (auto & pc : material->getPushConstants()) {
buffer.pushConstants(material->getPipeline()->getLayout(),
pc.second.stages, pc.second.offset, pc.second.size, pc.second.ptr.get());
}
indexBuffer->update((void*) &material->getDescriptorSet());
buffer.bindPipeline(vk::PipelineBindPoint::eGraphics, material->getPipeline()->get());
buffer.bindIndexBuffer(indexBuffer->getBuffer(), 0, vk::IndexType::eUint16);
buffer.drawIndexed(indexBuffer->getObjectCount(), 1, 0, 0, 0);
buffer.end();
}
vk::CommandBuffer getBuffer(size_t frame) {
return buffers->get(frame);
}
};
// An interface which builds a material renderer
class MaterialRendererBuilder {
public:
virtual MaterialRenderer * createRenderer(Material * material, VulkanIndexBuffer * indexbuffer = nullptr) = 0;
};
#endif /* VULKANRENDERER_HPP */
|
4e5ca44ddbd8e13c62399e292ff2d1d0bcc125bc
|
2e4f485ec35f5c525f28eaee0a1005555cf61a21
|
/mimetreeparser/src/bodyformatter/applicationpkcs7mime.cpp
|
13c8530a06bc6e571700f63c13ef4dc66a5da8b3
|
[
"CC0-1.0",
"BSD-3-Clause"
] |
permissive
|
KDE/messagelib
|
8b0174c5e4c95344a828b8bf1c31ff52cc6663d7
|
ab4f300a88bb9414734296d0031cbb905a53999c
|
refs/heads/master
| 2023-08-30T23:50:09.096181
| 2023-08-28T02:16:39
| 2023-08-28T02:16:39
| 47,712,197
| 13
| 6
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 5,948
|
cpp
|
applicationpkcs7mime.cpp
|
/*
SPDX-FileCopyrightText: 2016 Sandro Knauß <sknauss@kde.org>
SPDX-License-Identifier: LGPL-2.0-or-later
*/
#include "applicationpkcs7mime.h"
#include "messagepart.h"
#include "objecttreeparser.h"
#include <QGpgME/Protocol>
#include <KMime/Content>
#include <QTextCodec>
#include "mimetreeparser_debug.h"
using namespace MimeTreeParser;
const ApplicationPkcs7MimeBodyPartFormatter *ApplicationPkcs7MimeBodyPartFormatter::self;
const Interface::BodyPartFormatter *ApplicationPkcs7MimeBodyPartFormatter::create()
{
if (!self) {
self = new ApplicationPkcs7MimeBodyPartFormatter();
}
return self;
}
MessagePart::Ptr ApplicationPkcs7MimeBodyPartFormatter::process(Interface::BodyPart &part) const
{
KMime::Content *node = part.content();
if (node->head().isEmpty()) {
return {};
}
const auto smimeCrypto = QGpgME::smime();
if (!smimeCrypto) {
return {};
}
// we are also registered for octet-stream, in that case stop here if that's not a part for us
const auto ct = node->contentType(); // Create
const auto mt = ct->mimeType();
const auto isCorrectMimeType = mt == QByteArrayLiteral("application/pkcs7-mime") || mt == QByteArrayLiteral("application/x-pkcs7-mime");
const auto hasCorrectName = mt == QByteArrayLiteral("application/octet-stream")
&& (ct->name().endsWith(QLatin1String("p7m")) || ct->name().endsWith(QLatin1String("p7s")) || ct->name().endsWith(QLatin1String("p7c")));
if (!isCorrectMimeType && !hasCorrectName) {
return {};
}
const QString smimeType = node->contentType(false)->parameter(QStringLiteral("smime-type")).toLower();
if (smimeType == QLatin1String("certs-only")) {
part.processResult()->setNeverDisplayInline(true);
CertMessagePart::Ptr mp(new CertMessagePart(part.objectTreeParser(), node, smimeCrypto, part.source()->autoImportKeys()));
return mp;
}
bool isSigned = (smimeType == QLatin1String("signed-data"));
bool isEncrypted = (smimeType == QLatin1String("enveloped-data"));
// Analyze "signTestNode" node to find/verify a signature.
// If zero part.objectTreeParser() verification was successfully done after
// decrypting via recursion by insertAndParseNewChildNode().
KMime::Content *signTestNode = isEncrypted ? nullptr : node;
// We try decrypting the content
// if we either *know* that it is an encrypted message part
// or there is neither signed nor encrypted parameter.
MessagePart::Ptr mp;
if (!isSigned) {
if (isEncrypted) {
qCDebug(MIMETREEPARSER_LOG) << "pkcs7 mime == S/MIME TYPE: enveloped (encrypted) data";
} else {
qCDebug(MIMETREEPARSER_LOG) << "pkcs7 mime - type unknown - enveloped (encrypted) data ?";
}
auto _mp = EncryptedMessagePart::Ptr(
new EncryptedMessagePart(part.objectTreeParser(), node->decodedText(), smimeCrypto, part.nodeHelper()->fromAsString(node), node));
mp = _mp;
_mp->setIsEncrypted(true);
_mp->setDecryptMessage(part.source()->decryptMessage());
PartMetaData *messagePart(_mp->partMetaData());
if (!part.source()->decryptMessage()) {
isEncrypted = true;
signTestNode = nullptr; // PENDING(marc) to be abs. sure, we'd need to have to look at the content
} else {
_mp->startDecryption();
if (messagePart->isDecryptable) {
qCDebug(MIMETREEPARSER_LOG) << "pkcs7 mime - encryption found - enveloped (encrypted) data !";
isEncrypted = true;
part.nodeHelper()->setEncryptionState(node, KMMsgFullyEncrypted);
signTestNode = nullptr;
} else {
// decryption failed, which could be because the part was encrypted but
// decryption failed, or because we didn't know if it was encrypted, tried,
// and failed. If the message was not actually encrypted, we continue
// assuming it's signed
if (_mp->passphraseError() || (smimeType.isEmpty() && messagePart->isEncrypted)) {
isEncrypted = true;
signTestNode = nullptr;
}
if (isEncrypted) {
qCDebug(MIMETREEPARSER_LOG) << "pkcs7 mime - ERROR: COULD NOT DECRYPT enveloped data !";
} else {
qCDebug(MIMETREEPARSER_LOG) << "pkcs7 mime - NO encryption found";
}
}
}
if (isEncrypted) {
part.nodeHelper()->setEncryptionState(node, KMMsgFullyEncrypted);
}
}
// We now try signature verification if necessary.
if (signTestNode) {
if (isSigned) {
qCDebug(MIMETREEPARSER_LOG) << "pkcs7 mime == S/MIME TYPE: opaque signed data";
} else {
qCDebug(MIMETREEPARSER_LOG) << "pkcs7 mime - type unknown - opaque signed data ?";
}
const QTextCodec *aCodec(part.objectTreeParser()->codecFor(signTestNode));
const QByteArray signaturetext = signTestNode->decodedContent();
auto _mp = SignedMessagePart::Ptr(
new SignedMessagePart(part.objectTreeParser(), aCodec->toUnicode(signaturetext), smimeCrypto, part.nodeHelper()->fromAsString(node), signTestNode));
mp = _mp;
_mp->startVerificationDetached(signaturetext, nullptr, QByteArray());
if (_mp->isSigned()) {
if (!isSigned) {
qCDebug(MIMETREEPARSER_LOG) << "pkcs7 mime - signature found - opaque signed data !";
}
if (signTestNode != node) {
part.nodeHelper()->setSignatureState(node, KMMsgFullySigned);
}
} else {
qCDebug(MIMETREEPARSER_LOG) << "pkcs7 mime - NO signature found :-(";
}
}
return mp;
}
|
275393de52af85b87842a4890c36aca6095f6b21
|
4b187bd1e89f6bcce100b7bd05b4ff202522bc4d
|
/OnlineJudgeSolutions/LightOJ/light oj 1066.cpp
|
60cf2a41a85caec5e9c1757948af7f675b54ff55
|
[] |
no_license
|
codefresher32/CompetitiveProgramming
|
e53133a906081e7931966216b55d4537730d8ba3
|
923009b9893bdb0162ef02e88ea4223dc8d85449
|
refs/heads/master
| 2021-04-13T06:51:04.428078
| 2020-03-24T13:40:16
| 2020-03-24T13:40:16
| 249,144,621
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 2,055
|
cpp
|
light oj 1066.cpp
|
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
#define pii pair<int,int>
#define pi pair<char,char>
#define F first
#define S second
#define pb push_back
#define pp pop_back
#define mod 1000003
char s[20][20];
map<char,pii>mp;
int d[20][20],n;
int fx[]={1,-1,0,0};
int fy[]={0,0,1,-1};
bool valid(int x,int y,char ch)
{
if(x>=1&&x<=n&&y>=1&&y<=n&&y>=1&&d[x][y]==-1&&(s[x][y]=='.'||s[x][y]==ch)){
return true;
}
return false;
}
int bfs()
{
int nx,ny,ans=0,tx,ty;
bool f=0;
for(auto x:mp){
if(!f){
tx=x.S.F,ty=x.S.S;
}
f=1;
queue<pii>q;
memset(d,-1,sizeof(d));
q.push({tx,ty});
d[tx][ty]=0;
while(!q.empty()){
pii tp=q.front();
q.pop();
if(tp.F==x.S.F&&tp.S==x.S.S){
break;
}
for(int i=0;i<4;i++){
nx=fx[i]+tp.F;
ny=fy[i]+tp.S;
if(valid(nx,ny,x.F)){
d[nx][ny]=d[tp.F][tp.S]+1;
q.push({nx,ny});
}
}
}
if(d[x.S.F][x.S.S]==-1){
return -1;
}
else{
ans+=d[x.S.F][x.S.S];
s[x.S.F][x.S.S]='.';
tx=x.S.F,ty=x.S.S;
}
}
return ans;
}
int main ()
{
// ios_base::sync_with_stdio(false);
// cin.tie(NULL);
int T,id=0;
scanf("%d",&T);
while(T--){
scanf("%d",&n);
for(int i=1;i<=n;i++){
for(int j=1;j<=n;j++){
cin>>s[i][j];
if(s[i][j]>='A'&&s[i][j]<='Z'){
mp[s[i][j]]={i,j};
}
}
}
int ans;
ans=bfs();
printf("Case %d: ",++id);
if(ans==-1){
printf("Impossible\n");
}
else{
printf("%d\n",ans);
}
mp.clear();
}
return 0;
}
|
34195170a6820c909c3053ebc14b6fc1e1aa8443
|
325802f64a2eef46af4db2351efbb9ca08922db6
|
/PythonSupportSample/PythonSupport/psappinterface.h
|
5e5e25da97d26598907a51f26edd377e5cf8161f
|
[] |
no_license
|
3DGISKing/DesktopAppSamples
|
536905ec33b7f196560678bf1940fae4788b80c4
|
5926c001ba3c44b206ed4bed17b15e92ca53e1c6
|
refs/heads/master
| 2023-03-01T11:59:16.107999
| 2021-02-07T10:03:53
| 2021-02-07T10:03:53
| 336,226,357
| 1
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 535
|
h
|
psappinterface.h
|
#include "./../PythonBinding/appinterface.h"
class PythonSupport;
/**
* brief Interface class to provide access to private methods in Host App for use by plugins.
*
* Only those functions "exposed" by class AppInterface can be called from within a plugin.
*/
class PSAppInterface: public AppInterface
{
public:
PSAppInterface(PythonSupport *app);
void setLineEditText(QString text);
QString getLineEditText();
void setCheckBoxState(Qt::CheckState state);
Qt::CheckState getCheckBoxState();
private:
PythonSupport *app;
};
|
a1a5c1a2fe81622fa05fd7110cab3ed7616c9eb0
|
02d8629d0a7dd7f37a306d43987bab567ba5f053
|
/tests/test_http_server.cc
|
c1a4ced671ff29f43e75055ad02bbb48fd01dcb0
|
[] |
no_license
|
Fiee-ma/webserver
|
c34b25c9bbbfebaac96f270614bbf9f8ef3a8e91
|
01802b01eee7efc6538fd45e73604b71a6a9b855
|
refs/heads/main
| 2023-03-11T14:18:25.249824
| 2021-02-24T13:24:39
| 2021-02-24T13:24:39
| 332,288,549
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 1,133
|
cc
|
test_http_server.cc
|
#include "../webserver/http/http_server.h"
#include "../webserver/log.h"
static server_name::Logger::ptr g_logger = WEBSERVER_LOG_ROOT();
void run() {
server_name::http::HttpServer::ptr server(new server_name::http::HttpServer);
server_name::Address::ptr addr = server_name::Address::LookupAnyIPAdress("0.0.0.0:8020");
while(!server->bind(addr)) {
sleep(2);
}
auto sd = server->getServletDispatch();
sd->addServlet("/tmp/preamble-106dac.pch", [](server_name::http::HttpRequest::ptr req
, server_name::http::HttpResponse::ptr rsp
, server_name::http::HttpSession::ptr sessiom) {
rsp->setBody(req->toString());
return 0;
});
sd->addGlobServlet("/tmp/*", [](server_name::http::HttpRequest::ptr req
, server_name::http::HttpResponse::ptr rsp
, server_name::http::HttpSession::ptr sessiom) {
rsp->setBody("Glob:\r\n" + req->toString());
return 0;
});
server->start();
}
int main() {
server_name::IOManager iom(2);
iom.schedule(run);
return 0;
}
|
2d409811d84f30a81efb7779eead802343bcae2d
|
c84d6d4e0d9bbb2d628851cce996653b1ee57c9c
|
/Project In C++/BookStore_C++/BookStore/Person.h
|
31afb7c34e8685154dff647799236d356ca5b480
|
[] |
no_license
|
Shaoun18/C-Programming-Code
|
f9f2f9d39f73ab3d838b54a97eba50ba3223a748
|
5870469192de9e1b6e789224d9517db9d1b71310
|
refs/heads/main
| 2023-03-10T04:58:23.606288
| 2021-02-16T14:06:37
| 2021-02-16T14:06:37
| 339,137,154
| 1
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 445
|
h
|
Person.h
|
#ifndef PERSON_H
#define PERSON_H
#include <string>
#include <iostream>
using namespace std;
class Person
{
public:
Person();
string getLastName() const;
string getFirstName() const;
int getDateOfBirth() const;
void setName(const string& newLastName, const string& newFirstName);
void setDateOfBirth(const int newDateOfBirth);
void printName() const;
~Person();
private:
string lastName, firstName;
int dateOfBirth;
};
#endif
|
0cebf545a9ef780bc7208ca64ab4e752230a73d0
|
9019962eac23ee19856de9e245729a6eab55a460
|
/采用MQTT协议的嵌入式智能家居信息PC端采集显示系统/mainwindow.h
|
18ec2a5498b322a06273a2a7fe1e5f94ba02070a
|
[] |
no_license
|
Hppppppf/Qt_Client_IOT
|
445e536a0792e57f5b83bb732528741a16f29163
|
e41f398b44da4ef81a25ffe6f799a47fa9a524e6
|
refs/heads/master
| 2022-11-14T09:42:16.891977
| 2020-06-30T15:31:48
| 2020-06-30T15:31:48
| 276,124,950
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 1,287
|
h
|
mainwindow.h
|
//mainwindow.h
#ifndef MAINWINDOW_H
#define MAINWINDOW_H
#include <QMainWindow>
#include <QMouseEvent>
#include <QtMqtt/QMqttClient>
QT_BEGIN_NAMESPACE
namespace Ui { class MainWindow; }
QT_END_NAMESPACE
class MainWindow : public QMainWindow
{
Q_OBJECT
public:
MainWindow(QWidget *parent = nullptr);
~MainWindow();
private slots:
void on_lightButton_clicked();
void on_pushButton_clicked();
//拖拽窗口
void mousePressEvent(QMouseEvent* event);
void mouseMoveEvent(QMouseEvent* event);
void mouseReleaseEvent(QMouseEvent *event);
//连接服务器
void Connect();
void Subscribe();
//显示参数
void updateData(QString content);
void Display_Data(QString content);
void ChangeColor(float data,float standard,int (&color)[3]);
private:
Ui::MainWindow *ui;
//拖拽窗口
bool isDrag;
QPoint mouseStartPoint;
QPoint windowTopLeftPoint;
//智能家居环境参数
bool light_switch;
float temperature;
float humidity;
float PM25;
int CO2;
int light;
//mqtt client
QMqttClient * m_client;
QMqttClient * m_client_2;
void updateLogStateChange();
void brokerDisconnected();
};
#endif // MAINWINDOW_H
|
89971a20ab80552823dccf13a7b1f99617be4a41
|
947e6096a5d70992ce9a2ad0fc64ae2fc9c8509f
|
/src/solver/constraints/cNQueen.hpp
|
3eacebbde37f5b65e12d75c8836a0439601054d7
|
[] |
no_license
|
Asteip/KaboSolve
|
488ae67d2467d586e13ee60d5ae2c12c0124483e
|
644ceca5ab8ad0a67ec83cf11959c63c2ef1c73a
|
refs/heads/master
| 2021-01-23T08:10:08.983994
| 2017-03-26T14:41:13
| 2017-03-26T14:41:13
| 80,536,121
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 230
|
hpp
|
cNQueen.hpp
|
#ifndef C_N_QUEEN
#define C_N_QUEEN
#include "../constraint.hpp"
class CNQueen : public Constraint {
public:
CNQueen(Domain **domains, int size);
~CNQueen();
void display();
virtual bool applyConstraint(int id);
};
#endif
|
f7353196baaaddcff61e768642317fdbbd22c16b
|
93d37e668bed43232a837c5e9986ce8e75cefbaf
|
/1/mainFrame.h
|
6adcf3e8c738b3c4bb590ead63ab39427c4409c9
|
[] |
no_license
|
ttzztztz/UML-Course-Design
|
f6bdca62716b5c38e30fe5e93f59e503bf21727c
|
dfdc8c09fad8446ad799d1f1524c011faf8f1a67
|
refs/heads/master
| 2023-02-16T20:15:14.025543
| 2021-01-16T23:27:23
| 2021-01-16T23:27:23
| 305,312,759
| 0
| 1
| null | 2021-01-16T14:01:58
| 2020-10-19T08:21:25
|
C++
|
UTF-8
|
C++
| false
| false
| 116
|
h
|
mainFrame.h
|
/**
* Project Untitled
*/
#ifndef _MAINFRAME_H
#define _MAINFRAME_H
class MainFrame {
};
#endif //_MAINFRAME_H
|
1cecc5181d769c2f874831b3176b703ea43f9c05
|
744d843ae17e2ff6dd5fd9bdbb271b12ff807b62
|
/TMX/Plugins/SpatPlugin/src/SpatMessage_r41.cpp
|
7401492fafb01d5a9714aa0a3f013147404e6fe0
|
[
"Apache-2.0"
] |
permissive
|
ankit-derq/v2i-unofficial
|
46e84827c33950a85d7ce64ee1e83ab0e3dba917
|
bd0bad7724c8451eef42915d436253e40be00c23
|
refs/heads/master
| 2020-03-18T13:09:08.764987
| 2017-09-06T23:14:11
| 2017-09-06T23:14:11
| null | 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 8,503
|
cpp
|
SpatMessage_r41.cpp
|
#include <string>
#include <iostream>
#include <sstream>
#include <stdexcept>
#include <list>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <time.h>
#include <errno.h>
#include <asn_j2735_r41/SPAT.h>
#include <asn_j2735_r41/UPERframe.h>
#include "SpatMessage_r41.h"
//#include "SPaTData.h"
SpatMessage_r41::SpatMessage_r41()
{
std::cout << "SpatMessage_r41::SpatMessage_r41 Constructor Called" << std::endl;
frame = (UPERframe *) calloc(1, sizeof(UPERframe));
encodedBytes = 0;
derEncodedBytes = 0;
iterations = 0;
}
SpatMessage_r41::~SpatMessage_r41()
{
}
int SpatMessage_r41::createSpat()
{
ASN_STRUCT_FREE_CONTENTS_ONLY(asn_DEF_SPAT, &spatMessage);
// TODO: SPAT-P Not defined from ASN.1 using literal instead
spatMessage.msgID = 0x13; // SPAT-P
IntersectionState *intersection = (IntersectionState *)calloc(1, sizeof(IntersectionState));
intersection->name = (DescriptiveName_t *) calloc(1, sizeof(DescriptiveName_t));
intersection->name->size = strlen(spatData->IntersectionName);
intersection->name->buf = (uint8_t *) calloc(1, strlen(spatData->IntersectionName));
memcpy(intersection->name->buf, spatData->IntersectionName, strlen(spatData->IntersectionName));
intersection->id.id = spatData->IntersectionId;
intersection->revision = (MsgCount_t) 1;
// intersection->status = IntersectionStatusObject_fixedTimeOperation;
uint16_t statusIntersection = createIntersectionStatus(statusIntersection);
intersection->status.buf = (uint8_t *)calloc(2, sizeof(uint8_t));
intersection->status.size = 2 * sizeof(uint8_t);
intersection->status.bits_unused = 0;
intersection->status.buf[1] = statusIntersection;
intersection->status.buf[0] = (statusIntersection >> 8);
// Movement List
for (int m = 0; m < spatData->NumPTLMRecords; m++)
{
MovementState *movement = (MovementState *) calloc(1, sizeof(MovementState));
movement->signalGroup = spatData->PTLMTable[m].SignalGroup;
MovementEvent *stateTimeSpeed = (MovementEvent *) calloc(1, sizeof(MovementEvent));
if (spatData->PTLMTable[m].LanesType == pedLane)
{
if (spatData->PTLMTable[m].state == 0x03) { stateTimeSpeed->eventState = MovementPhaseState_permissive_Movement_Allowed; }
else if (spatData->PTLMTable[m].state == 0x02) { stateTimeSpeed->eventState = MovementPhaseState_permissive_clearance; }
else if (spatData->PTLMTable[m].state == 0x01) { stateTimeSpeed->eventState = MovementPhaseState_stop_And_Remain; }
}
else
{
if (spatData->PTLMTable[m].state & DarkBall) { stateTimeSpeed->eventState = MovementPhaseState_dark; }
else if (spatData->PTLMTable[m].state & GreenBall) { stateTimeSpeed->eventState = MovementPhaseState_permissive_Movement_Allowed; }
else if (spatData->PTLMTable[m].state & YellowBall) { stateTimeSpeed->eventState = MovementPhaseState_permissive_clearance; }
else if (spatData->PTLMTable[m].state & RedBall) { stateTimeSpeed->eventState = MovementPhaseState_stop_And_Remain; }
}
if (iterations == 20)
{
std::cout << "SigGrp: "<< spatData->PTLMTable[m].SignalGroup << " PTLMState: " << spatData->PTLMTable[m].state << " LightState: " << stateTimeSpeed->eventState << std::endl;
}
stateTimeSpeed->timing = (TimeChangeDetails * ) calloc(1, sizeof(TimeChangeDetails));
stateTimeSpeed->timing->minEndTime = getAdjustedTime(spatData->PTLMTable[m].minTime);
if (spatData->PTLMTable[m].maxTime > 0)
{
stateTimeSpeed->timing->maxEndTime = (TimeMark_t *) calloc(1, sizeof(TimeMark_t));
*(stateTimeSpeed->timing->maxEndTime) = getAdjustedTime(spatData->PTLMTable[m].maxTime);
}
// spatData->PTLMTable[m].callActive
if (spatData->PTLMTable[m].pedestrian == pc_oneormore)
{
movement->maneuverAssistList = (ManeuverAssistList *) calloc(1, sizeof(ManeuverAssistList));
ConnectionManeuverAssist *pedDetect = (ConnectionManeuverAssist *) calloc(1, sizeof(ConnectionManeuverAssist));
pedDetect->connectionID = 0;
pedDetect->pedBicycleDetect = (PedestrianBicycleDetect_t *) calloc(1, sizeof(PedestrianBicycleDetect_t));
*(pedDetect->pedBicycleDetect) = 1;
ASN_SEQUENCE_ADD(&movement->maneuverAssistList->list, pedDetect);
}
ASN_SEQUENCE_ADD(&movement->state_time_speed.list, stateTimeSpeed);
ASN_SEQUENCE_ADD(&intersection->states.list, movement);
}
ASN_SEQUENCE_ADD(&spatMessage.intersections.list, intersection);
asn_enc_rval_t rvalenc = uper_encode_to_buffer(&asn_DEF_SPAT, &spatMessage, encoded, 4000);
if (rvalenc.encoded == -1) {
fprintf(stderr, "Cannot encode %s\n", rvalenc.failed_type->name);
return -1;
} else {
encodedBytes = ((rvalenc.encoded + 7) / 8);
if (createUPERframe_DERencoded_msg())
{
#if 0
// Print every 2 seconds
if (iterations == 20)
{
xer_fprint(stdout, &asn_DEF_SPAT, &spatMessage);
printf("Structure successfully encoded %d\n", encodedBytes);
int i;
for(i = 0; i < encodedBytes; i++)
{
printf("%02x ", (unsigned char) encoded[i]);
}
printf("\n");
std::cout << "Spat Successfully DER encoded:" << derEncodedBytes << std::endl;
xer_fprint(stdout, &asn_DEF_UPERframe, frame);
// Print DER Encoded Message
printf("SPAT successfully DER encoded size: %d\nPayload: ", derEncodedBytes);
for (i=0; i < derEncodedBytes; i++) { printf("%02x ", derEncoded[i]); }
printf("\n");
}
#endif
}
else return false;
}
if (iterations == 20)
{
printf("\n");
iterations = 0;
}
iterations++;
return true;
}
bool SpatMessage_r41::createUPERframe_DERencoded_msg()
{
ASN_STRUCT_FREE_CONTENTS_ONLY(asn_DEF_UPERframe, frame);
frame->msgID = 0x11;
frame->contentID = 0x13;
frame->msgBlob.buf = (uint8_t *) calloc(encodedBytes, sizeof(uint8_t));
frame->msgBlob.size = encodedBytes;
memcpy(frame->msgBlob.buf, encoded, encodedBytes);
asn_enc_rval_t encResults = der_encode_to_buffer(&asn_DEF_UPERframe, frame, &derEncoded, 4000);
if (encResults.encoded == 0)
{
std::cout << "Did not Successfully DER encode message" << std::endl;
return false;
}
else
{
derEncodedBytes = encResults.encoded;
}
return true;
}
uint16_t SpatMessage_r41::createIntersectionStatus(unsigned short intStatus)
{
// printf("Int Status:%x\n", intStatus);
uint16_t intersectionBitString = 0;
if (intStatus & is_normal) { intersectionBitString |= 1 << (15 - IntersectionStatusObject_fixedTimeOperation); }
if (intStatus & is_manual) { intersectionBitString |= 1 << (15 - IntersectionStatusObject_manualControlIsEnabled); }
if (intStatus & is_stopped) { intersectionBitString |= 1 << (15 - IntersectionStatusObject_stopTimeIsActivated); }
if (intStatus & is_faultFlash) { intersectionBitString |= 1 << (15 - IntersectionStatusObject_manualControlIsEnabled); }
if (intStatus & is_preempt) { intersectionBitString |= 1 << (15 - IntersectionStatusObject_preemptIsActive); }
if (intStatus & is_priority) { intersectionBitString |= 1 << (15 - IntersectionStatusObject_transitSignalPriorityIsActive); }
if (intStatus & is_coordination) { intersectionBitString |= 1 << (15 - IntersectionStatusObject_manualControlIsEnabled); }
return intersectionBitString;
}
/*
DarkBall = 0x00,
GreenBall = 0x01,
YellowBall = 0x02,
RedBall = 0x04,
*/
uint16_t SpatMessage_r41::createEventState(unsigned short evStatus)
{
uint16_t eventBitString = 0;
// if (evStatus & unavailablePhaseStatus) { eventBitString |= 1 << (15 - MovementPhaseState_unavailable); }
if (evStatus & DarkBall) { eventBitString |= 1 << (15 - MovementPhaseState_dark); }
if (evStatus & GreenBall) { eventBitString |= 1 << (15 - MovementPhaseState_permissive_Movement_Allowed); }
if (evStatus & YellowBall) { eventBitString |= 1 << (15 - MovementPhaseState_permissive_clearance); }
if (evStatus & RedBall) { eventBitString |= 1 << (15 - MovementPhaseState_stop_And_Remain); }
return eventBitString;
}
// TODO move to common file
void SpatMessage_r41::printUINT16(uint16_t num)
{
uint16_t x = num;
for (int i = 0; i < 16; i++) {
printf("%d", (x & 0x8000) >> 15);
x <<= 1;
}
printf("\n");
}
void SpatMessage_r41::setSpatData(SPaTData* sd)
{
spatData = sd;
}
long SpatMessage_r41::getAdjustedTime(unsigned int offset)
{
time_t now = time(0);
time_t now_plus_offsets = now + offset;
struct tm now_tm = *gmtime(&now_plus_offsets);
long retTime = ((now_tm.tm_min * 60) + now_tm.tm_sec) * 10;
// printf("Adjustment %d Current Time: %02d:%02d:%02d Return Value:%ld\n", offset, now_tm.tm_hour, now_tm.tm_min, now_tm.tm_sec, retTime);
return retTime;
}
|
23b6d1a54f3861f2e28e4b1d05daaba1f3c26117
|
862aea3ca42b6a99d12755937638792ee6d819a5
|
/Lab_works/Lab3_functions/User_define_function/qn4.cpp
|
b26eeadc19cf7704c4f6f42f132ee8aa9fa6384b
|
[] |
no_license
|
Malisha-Maharjan/cpp_projects
|
95c9f8f926efe0f904257613fac74d060a92c35e
|
03ed4fdb792fce1a698d876209b840279b91ee9e
|
refs/heads/main
| 2023-07-19T05:38:53.732164
| 2021-09-14T11:36:11
| 2021-09-14T11:36:11
| 366,620,037
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 383
|
cpp
|
qn4.cpp
|
#include <iostream>
using namespace std;
float area();
int main()
{
float ans;
ans = area();
cout << "The area is " << ans << endl;
return 0;
}
float area()
{
float length, breadth;
float ans;
cout << "Enter length: ";
cin >> length;
cout << "Enter breadth: ";
cin >> breadth;
ans = (1 / 2.0) * length * breadth;
return ans;
}
|
edeaeda53ae9e8d779e332295a2a5fc68c3bf468
|
a4fa7020a1478a6531bcc2328d38b03f96072ceb
|
/common/interface__QT/helpers/vlabel.h
|
0b76772d65aa4c0c4ecce21b0f25df0fee46eeea
|
[] |
no_license
|
BearKidsTeam/CheeseTracker
|
6c6afdc7358d314283182b36dfcee0d6b82bebb1
|
b28694a22c88df9c71118342ec306dc2637e21a6
|
refs/heads/master
| 2020-04-10T05:43:45.512837
| 2018-12-09T08:34:53
| 2018-12-09T08:34:53
| 160,835,812
| 1
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 496
|
h
|
vlabel.h
|
//
// C++ Interface: vlabel
//
// Description:
//
//
// Author: Juan Linietsky <coding@reduz.com.ar>, (C) 2004
//
// Copyright: See COPYING file that comes with this distribution
//
//
#ifndef VLABEL_H
#define VLABEL_H
#include <qwidget.h>
//Added by qt3to4:
#include <QPaintEvent>
/**
@author Juan Linietsky
*/
class VLabel : public QWidget {
QString text;
void paintEvent( QPaintEvent * p_event );
public:
void setText(QString p_text);
VLabel(QWidget *p_parent);
~VLabel();
};
#endif
|
1a5b7304d2cb2f02b24e4767977f2b2e20cafa90
|
36209169c654129de7cb3bd784ff3225bfae9536
|
/AtCoder/AGC035/C.cpp
|
d575cea6b824e0472ccab56b569e3fde83e7ad58
|
[] |
no_license
|
tskch0626/programming_contest
|
839eff14cc44abc0937a5d9c1cb981d515c99968
|
bae9298f018327459522fb56d98111934d759646
|
refs/heads/master
| 2020-06-19T18:31:18.114493
| 2019-08-11T09:01:13
| 2019-08-11T09:01:13
| 196,823,020
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 714
|
cpp
|
C.cpp
|
#include<bits/stdc++.h>
using namespace std;
int N;
int main() {
scanf("%d", &N);
if (N==1) printf("No\n");
else if (N%2==0) {
int tmp = N;
int i;
for (i=N-1; i>0; i--) {
tmp ^= i;
if (tmp==0) break;
}
if (tmp==0) {
printf("Yes\n");
for (int j=1; j<2*N-1; j++) {
if (j%N==0) continue;
printf("%d %d\n", j, j+1);
}
printf("%d %d\n", N, N-1);
printf("%d %d\n", 2*N, i);
} else printf("No\n");
} else {
printf("Yes\n");
for (int i=1; i<2*N; i++) {
printf("%d %d\n", i, i+1);
}
}
return 0;
}
|
baa747ceb434bf17137cda62ebbac3d7fc5ca6fc
|
a3d6556180e74af7b555f8d47d3fea55b94bcbda
|
/third_party/crashpad/crashpad/test/file.cc
|
c7b00685934d13772facaaf66aa73adc7b446c44
|
[
"BSD-3-Clause",
"Apache-2.0",
"GPL-1.0-or-later",
"MIT",
"LGPL-2.0-or-later"
] |
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
| 2,467
|
cc
|
file.cc
|
// Copyright 2015 The Crashpad Authors
//
// 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 "test/file.h"
#include <errno.h>
#include <sys/stat.h>
#include "base/logging.h"
#include "base/strings/utf_string_conversions.h"
#include "build/build_config.h"
#include "gtest/gtest.h"
#include "test/errors.h"
#if BUILDFLAG(IS_WIN)
#include <windows.h>
#endif
namespace crashpad {
namespace test {
bool FileExists(const base::FilePath& path) {
#if BUILDFLAG(IS_POSIX)
struct stat st;
int rv = lstat(path.value().c_str(), &st);
static constexpr char stat_function[] = "lstat";
#elif BUILDFLAG(IS_WIN)
struct _stat st;
int rv = _wstat(path.value().c_str(), &st);
static constexpr char stat_function[] = "_wstat";
#else
#error "Not implemented"
#endif
if (rv < 0) {
EXPECT_EQ(errno, ENOENT) << ErrnoMessage(stat_function) << " "
<< path.value();
return false;
}
return true;
}
bool RemoveFileIfExists(const base::FilePath& path) {
#if BUILDFLAG(IS_POSIX)
if (unlink(path.value().c_str()) != 0 && errno != ENOENT) {
PLOG(ERROR) << "unlink " << path.value();
return false;
}
#elif BUILDFLAG(IS_WIN)
if (!DeleteFile(path.value().c_str()) &&
GetLastError() != ERROR_FILE_NOT_FOUND) {
PLOG(ERROR) << "DeleteFile " << base::WideToUTF8(path.value());
return false;
}
#else
#error "Not implemented"
#endif
return true;
}
FileOffset FileSize(const base::FilePath& path) {
#if BUILDFLAG(IS_POSIX)
struct stat st;
int rv = lstat(path.value().c_str(), &st);
static constexpr char stat_function[] = "lstat";
#elif BUILDFLAG(IS_WIN)
struct _stati64 st;
int rv = _wstati64(path.value().c_str(), &st);
static constexpr char stat_function[] = "_wstati64";
#else
#error "Not implemented"
#endif
if (rv < 0) {
ADD_FAILURE() << ErrnoMessage(stat_function) << " " << path.value();
return -1;
}
return st.st_size;
}
} // namespace test
} // namespace crashpad
|
7bcea2c87cf577554724528123b9d49f9e28a4cc
|
9db4ccf62f0f697c957949961751d45906c6b1ee
|
/Faction.h
|
de45c4ba1082b15da08b17f2883b4915d19ded91
|
[] |
no_license
|
JustinWang123/Wasteland
|
480b2c936b979720e2031cc51fe3c0cb3b3e1661
|
df7e6870dbb3eb7bf56bc739a3fa0f48eacd3579
|
refs/heads/master
| 2016-09-11T02:24:21.270687
| 2013-11-19T07:37:31
| 2013-11-19T07:37:31
| 14,517,396
| 1
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 674
|
h
|
Faction.h
|
#ifndef FACTION_H
#define FACTION_H
#include <list>
class CharacterInstanceSoldier;
class CharacterInstanceWorker;
class CharacterCommand;
class Faction
{
public:
Faction();
virtual ~Faction();
virtual void Update()=0;
void AddSoldier(CharacterInstanceSoldier* soldier);
void AddWorker(CharacterInstanceWorker* worker);
int GetFactionID() const {return factionID;}
protected:
void AddCommand(CharacterCommand* command);
std::list<CharacterInstanceSoldier*> soldierInstances;
std::list<CharacterInstanceWorker*> workerInstances;
std::list<CharacterCommand*> commandQueue;
static int nextFactionID;
int factionID;
};
#endif
|
e66085ae0e80ab77056d73ecf0c6a5e820038133
|
63936c4b82ff4ead2a4a90f7d253af117d585af0
|
/main.cpp
|
08e7cecc98e79da62b65de0ea02ab76ca8ab9804
|
[] |
no_license
|
yontwises/CS014
|
8f8faf5553e3af0eb83c1e0e7cbf2b4458ec4b53
|
e04435891b47d0334712401572ff5b164d5fe496
|
refs/heads/master
| 2020-12-06T15:41:33.774975
| 2020-01-09T09:13:32
| 2020-01-09T09:13:32
| 232,498,586
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 624
|
cpp
|
main.cpp
|
#include "Playlist.h"
#include <iostream>
#include <cstdlib>
#include <string>
using namespace std;
int main() {
// std::cout << "Hello World! " << '\n';
// Playlist list//
Playlist list;
list.AddSong("H103", "DuDu", "Blackpink", 340);
list.AddSong("H523", "Kill This Love ", "Blackpink", 200);
list.AddSong("H523", "Kill This Love ", "Blackpink", 200);
list.AddSong("H523", "Kill This Love ", "Blackpink", 200);
/*list.OutputFullPlayList();*/
list.RemoveSong("H523");
list.OutputFullPlayList();
// testNode->InsertAfter(testID, testName, testArtist, testLength);
return 0;
}
|
7491d479bb509a80bd81bbc1484670e8bc731a37
|
9eff4a0c6890bc8571bb1115d14159ce93c2f5a7
|
/include/kspp/internal/queue.h
|
d08a789b4030bee6ffa71e26d0b476323aa3cdcb
|
[
"BSL-1.0"
] |
permissive
|
bitbouncer/kspp
|
d06865e46a1e3820e65d24edb951a48a996dffbf
|
8539f359e32bd3dd1360ac4616eab88e79aab607
|
refs/heads/master
| 2022-10-20T22:45:11.118381
| 2022-09-28T14:50:00
| 2022-09-28T14:50:00
| 73,604,579
| 136
| 27
|
BSL-1.0
| 2022-05-16T19:20:41
| 2016-11-13T08:42:34
|
C++
|
UTF-8
|
C++
| false
| false
| 1,310
|
h
|
queue.h
|
#include <deque>
#include <memory>
#include <cstdint>
#include <kspp/utils/spinlock.h>
#pragma once
namespace kspp {
template<class ITEM>
class queue {
public:
queue() : empty_(true) {
}
inline size_t size() const {
spinlock::scoped_lock xxx(spinlock_);
return queue_.size();
}
inline bool empty() const {
return empty_;
}
inline void push_back(ITEM i) {
spinlock::scoped_lock xxx(spinlock_);
{
empty_ = false;
queue_.push_back(i);
}
}
inline void push_front(ITEM i) {
spinlock::scoped_lock xxx(spinlock_);
{
empty_ = false;
queue_.push_front(i);
}
}
inline ITEM front() {
spinlock::scoped_lock xxx(spinlock_);
return queue_.front();
}
inline void pop_front() {
spinlock::scoped_lock xxx(spinlock_);
{
queue_.pop_front();
if (queue_.size() == 0)
empty_ = true;
}
}
inline ITEM pop_and_get() {
spinlock::scoped_lock xxx(spinlock_);
{
auto p = queue_.front();
queue_.pop_front();
if (queue_.size() == 0)
empty_ = true;
return p;
}
}
private:
std::deque<ITEM> queue_;
bool empty_;
mutable spinlock spinlock_;
};
}
|
f7cd23a992e04997ce0295d3e3e0a10c28aa5b1f
|
4a83406f95a4ba8f15bb4bfff0bb34f5f36ddcde
|
/Practice/Bit Manipulation/Unique_Number_imp.cpp
|
e6d008cbe2188a8a98bbcb1076fb05e882ffd72d
|
[] |
no_license
|
2001adarsh/Contests
|
5d3523ca6a5eb3eab0505733dc9144890eecb45e
|
a162b2a11b00d70e2b49292854b2ba826ca01311
|
refs/heads/master
| 2021-12-15T02:11:30.852367
| 2021-12-12T11:22:55
| 2021-12-12T11:22:55
| 252,377,884
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 904
|
cpp
|
Unique_Number_imp.cpp
|
// We are given an array containg n numbers.
//All the numbers are present thrice except for one
//number which is only present once. Find the unique number.
//Only use - bitwise operators, and no extra space.
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, no;
cin>>n;
int cnt[64] = {0};
for(int i=0; i<n; i++){
cin>>no;
int j=0;
while(no > 0) {
cnt[j] += no&1;
j++;
no = no>>1;
}
}
//Since here the result is in form of either 3N or 3N+1.
//because there are numbers with either 3 times and one no. with just 1 time.
//Update the array and compute the result
int p = 0; //power of 2.
int result =0; //ans
for(int i=0; i<64; i++){
cnt[i] %= 3; //to have array only of 0 and 1.
result += cnt[i]*pow(2,p);
p++;
}
cout<<result;
}
|
7bf68eff85db6a52b3b09aa86ee6806c42535bef
|
125ae0adb562478b184bbb35d40f2c43b335415c
|
/MercuryUI_old/Panels/Alarms/tAlarmSmartCraftPage.h
|
26453203461b340c974c06f99040a6bb83e27b21
|
[] |
no_license
|
dulton/53_hero
|
ff49ce6096c379931d7649b654c5fa76de4630de
|
48057fe05e75f57b500a395e6ff8ff9c06da6895
|
refs/heads/master
| 2020-02-25T04:19:18.632727
| 2016-05-20T03:44:44
| 2016-05-20T03:44:44
| 62,197,327
| 3
| 2
| null | 2016-06-29T05:11:41
| 2016-06-29T05:11:38
| null |
WINDOWS-1252
|
C++
| false
| false
| 1,144
|
h
|
tAlarmSmartCraftPage.h
|
/*****************************************************/
// Copyright © 2007-2012 Navico
// Confidential and proprietary. All rights reserved.
/*****************************************************/
#ifndef T_ALARMSMARTCRAFTPAGE_H
#define T_ALARMSMARTCRAFTPAGE_H
#pragma warning(push, 1)
#include <QGraphicsItem>
#include <QObject>
#pragma warning(pop)
#include "tAlarmCommonPage.h"
class tAlarmSmartCraft;
class tAlarmSmartCraftPage : public tAlarmCommonPage
{
Q_OBJECT
public:
tAlarmSmartCraftPage( QSize size, tAlarmSmartCraft* pAlarm, QGraphicsItem* pParent = 0 );
void paint( QPainter* pPainter, const QStyleOptionGraphicsItem* pOption, QWidget* pWidget = 0 );
private slots:
void SmartCraftAlarmUpdated();
private:
void CalculatePaintingInfo();
tAlarmSmartCraft* m_pAlarmSmartCraft;
QRect m_ShortTextRect;
QRect m_EngineLocationRect;
QRect m_ActionTextRect;
QString m_ShortText;
QString m_EngineLocation;
QString m_ActionText;
MercuryPalette::tTextStyle m_ShortStyle;
MercuryPalette::tTextStyle m_EngineStyle;
MercuryPalette::tTextStyle m_ActionStyle;
};
#endif
|
2ebadd19387a6b09d978eba9062e92c702962048
|
2e9cb497dedb365194e21375bb19fc11442bd6f0
|
/april_leetcoding_challenge/16. Valid Parenthesis String.cpp
|
56912d307f59961b2c4a185dd21603a1277f2131
|
[] |
no_license
|
anshaljalota/leetcode
|
8d48d24b3b907cb5983ef4f805c634fd4fd672bf
|
eb3d386e7e49758000b676d0f80740a920185c4e
|
refs/heads/master
| 2022-12-20T19:16:12.851459
| 2020-09-30T13:35:54
| 2020-09-30T13:35:54
| 267,513,638
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 974
|
cpp
|
16. Valid Parenthesis String.cpp
|
/*
Given a string containing only three types of characters: '(', ')' and '*', write a function to check whether this string is valid. We define the validity of a string by these rules:
Any left parenthesis '(' must have a corresponding right parenthesis ')'.
Any right parenthesis ')' must have a corresponding left parenthesis '('.
Left parenthesis '(' must go before the corresponding right parenthesis ')'.
'*' could be treated as a single right parenthesis ')' or a single left parenthesis '(' or an empty string.
An empty string is also valid.
*/
class Solution {
public:
bool checkValidString(string s) {
int range = s.length();
if(range==0)
return true;
int low=0,high=0;
char c;
for(int i=0;i<range;i++){
c=s[i];
low+= c=='('?1:-1;
high+= c!=')'?1:-1;
if(high<0)
break;
low = max(0,low);
}
return low==0;
}
};
|
a1deb108f45944155fae81cbe213e0f113230aad
|
6ded783679718a04e62b4edfcccecba3c780f2e4
|
/hw2/2.cpp
|
c225c731dbffa4edba99f4a1a2be7b69a50523c3
|
[] |
no_license
|
lysa0/hwcpp
|
8ff8daf555f57efc71e326f7fdc45c685d57c497
|
ae95ac519dcb6126a80694473efc3dd3b38ebb1c
|
refs/heads/master
| 2021-01-21T05:10:44.139211
| 2017-05-12T20:07:42
| 2017-05-12T20:07:42
| 83,145,163
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 509
|
cpp
|
2.cpp
|
#include<bits/stdc++.h>
using namespace std;
void solve();
int main(){
solve();
return 0;
}
void solve(){
int * a[10]{};
int it{};
for(int **i=a; i<a+10; it++, i++){
*i = new int[it+1]{};
//memset(*i, -1, (it+1)*sizeof(int));
*(*i+it)=1;
}
it=0;
for(int **i = a; i < a+10; it++, i++){
for (int *j = *i; j <= *i+it; j++)
cout << *j << " \n"[j==*i+it];
}
//For testing
//for(int i=0; i<10; i++)
// for(int j=0; j<=i; j++)
// cout << a[i][j] << " \n"[j==i];
}
|
c214b27ad2daa21b2e77ef6e7a7c5c723e98a8f3
|
3d631d3677f073e1a6203c0f0a6d5cd9416f2e13
|
/src/test/region_split_test.cc
|
242eaf7e6fb158f205b074152ceaea309af6fe2b
|
[
"Apache-2.0"
] |
permissive
|
JaySon-Huang/client-c
|
79f018f2ca227e72778be4047494f53707fad8f1
|
91c642a4477b6b98149a75c291102b9e92ac4e41
|
refs/heads/master
| 2023-09-01T15:32:53.656872
| 2023-03-19T14:05:17
| 2023-03-19T14:05:17
| 239,755,094
| 0
| 0
|
Apache-2.0
| 2023-03-21T16:57:39
| 2020-02-11T12:20:27
|
C++
|
UTF-8
|
C++
| false
| false
| 2,531
|
cc
|
region_split_test.cc
|
#include <pingcap/Exception.h>
#include <pingcap/kv/Scanner.h>
#include <pingcap/kv/Snapshot.h>
#include <pingcap/kv/Txn.h>
#include <iostream>
#include "mock_tikv.h"
#include "test_helper.h"
namespace pingcap::tests
{
using namespace pingcap;
using namespace pingcap::kv;
class TestWithMockKVRegionSplit : public testing::Test
{
protected:
void SetUp() override
{
mock_kv_cluster = mockkv::initCluster();
std::vector<std::string> pd_addrs = mock_kv_cluster->pd_addrs;
test_cluster = createCluster(pd_addrs);
control_cluster = createCluster(pd_addrs);
}
mockkv::ClusterPtr mock_kv_cluster;
ClusterPtr test_cluster;
ClusterPtr control_cluster;
};
TEST_F(TestWithMockKVRegionSplit, testSplitRegionGet)
{
{
Txn txn(test_cluster.get());
txn.set("abc", "1");
txn.set("abd", "2");
txn.set("abe", "3");
txn.set("abf", "4");
txn.set("abg", "5");
txn.set("abz", "6");
txn.commit();
Snapshot snap(test_cluster.get(), test_cluster->pd_client->getTS());
std::string result = snap.Get("abf");
ASSERT_EQ(result, "4");
control_cluster->splitRegion("abf");
result = snap.Get("abc");
ASSERT_EQ(result, "1");
result = snap.Get("abf");
ASSERT_EQ(result, "4");
}
{
Txn txn(test_cluster.get());
txn.set("abf", "6");
txn.set("abg", "5");
txn.set("abz", "4");
txn.commit();
Snapshot snap(test_cluster.get(), test_cluster->pd_client->getTS());
std::string result = snap.Get("abf");
ASSERT_EQ(result, "6");
}
}
TEST_F(TestWithMockKVRegionSplit, testSplitRegionScan)
{
Txn txn(test_cluster.get());
txn.set("abc", "1");
txn.set("abd", "2");
txn.set("abe", "3");
txn.set("abf", "4");
txn.set("abg", "5");
txn.set("abh", "6");
txn.set("zzz", "7");
txn.commit();
Snapshot snap(test_cluster.get(), test_cluster->pd_client->getTS());
auto scanner = snap.Scan("", "");
int answer = 0;
while (scanner.valid)
{
ASSERT_EQ(scanner.value(), std::to_string(++answer));
scanner.next();
}
ASSERT_EQ(answer, 7);
answer = 0;
control_cluster->splitRegion("abe");
auto scanner1 = snap.Scan("ab", "ac");
while (scanner1.valid)
{
ASSERT_EQ(scanner1.value(), std::to_string(++answer));
scanner1.next();
}
ASSERT_EQ(answer, 6);
}
} // namespace pingcap::tests
|
b923c476c56f6da41f3438324cf4f87590c7f7fc
|
dd6d4ed4c5c8cf4c75790eae9eb25a18af3e55ea
|
/tensorflow/contrib/repeat/kernels/repeat_op_cpu_impl.cc
|
d70e3102b109c2fdb356f13fa7d23ad8d5aaa59c
|
[
"Apache-2.0"
] |
permissive
|
zycdragonball/tensorflow
|
e5eb309e7542d9f776ca978d8b89ef6345965167
|
150b11229f4937db9017b08a3737aa7172180644
|
refs/heads/master
| 2021-01-23T01:59:55.125101
| 2017-07-10T00:32:49
| 2017-07-10T00:32:49
| 85,953,842
| 0
| 0
| null | 2017-07-10T00:32:50
| 2017-03-23T13:37:17
|
C++
|
UTF-8
|
C++
| false
| false
| 5,745
|
cc
|
repeat_op_cpu_impl.cc
|
/* Copyright 2016 The TensorFlow Authors. All Rights Reserved.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
==============================================================================*/
#include "third_party/eigen3/unsupported/Eigen/CXX11/Tensor"
#include "tensorflow/core/framework/op.h"
#include "tensorflow/core/framework/op_kernel.h"
#include "tensorflow/core/framework/register_types.h"
#include "tensorflow/core/framework/tensor_types.h"
#include "tensorflow/core/util/work_sharder.h"
namespace tensorflow{
template <typename T>
void RepeatCPUImpl(const Tensor& input,
const typename TTypes<int32>::ConstFlat& repeats_flat,
int axis, Tensor* output) {
auto input_flat = input.flat<T>();
auto output_flat = output->flat<T>();
// a batch is inner axes > axis
size_t batch_size = 1;
int32 dims = input.shape().dims();
for (int32 i = axis + 1; i < dims; ++i) {
batch_size *= input.shape().dim_size(i);
}
int64 num_batch = input_flat.size() / batch_size;
const T* in = input_flat.data();
T* out = output_flat.data();
// copy an in_batch to its out_batches
auto handle_batch = [&in, batch_size, &out](int32 repeat) {
for (int64 j = 0; j < repeat; ++j) {
std::copy(in, in + batch_size, out);
out += batch_size;
}
in += batch_size;
return;
};
if (repeats_flat.size() == 1) {
for (int64 i = 0; i < num_batch; ++i) {
handle_batch(repeats_flat(0));
}
} else {
for (int64 i = 0; i < num_batch; ++i) {
handle_batch(repeats_flat(i % repeats_flat.size()));
}
}
}
template <typename T>
void RepeatCPUImplV2(DeviceBase* d, const Tensor& input,
const typename TTypes<int32>::ConstFlat& repeats_flat,
int axis, int64 cost_per_unit, Tensor* output) {
auto input_flat = input.flat<T>();
auto output_flat = output->flat<T>();
// a batch is inner axes > axis
// a group is inner axes >= axis
int64 batch_size = 1;
int32 dims = input.shape().dims();
for (int32 i = axis + 1; i < dims; ++i) {
batch_size *= input.shape().dim_size(i);
}
int64 group_pre_size = batch_size * input.shape().dim_size(axis);
int64 group_size = batch_size * output->shape().dim_size(axis);
auto worker_threads = d->tensorflow_cpu_worker_threads();
int num_threads = std::min(4, worker_threads->num_threads);
// strings define a different amount of work (generally much more) compared
// with standard POD, so we parallelize differently.
if (!std::is_same<T, string>::value) {
num_threads =
static_cast<int>(std::min<int64>(num_threads, output_flat.size() / 4096));
}
if (num_threads == 0) {
RepeatCPUImpl<T>(input, repeats_flat, axis, output);
}
auto work = [input_flat, repeats_flat, axis,
batch_size, group_pre_size, group_size, &output_flat](
int64 out_begin_index, int64 out_end_index) {
const T* in = input_flat.data();
T* out = output_flat.data();
T* out_start = out + out_begin_index;
T* out_end = out + out_end_index;
// handle partial group at start
int64 skip_group = out_begin_index / group_size;
in += skip_group * group_pre_size;
out += skip_group * group_size;
if (out_begin_index % group_size != 0) {
for (int64 j = 0; j < repeats_flat.size(); ++j) {
for (int64 k = 0; k < repeats_flat(j); ++k) {
if (out + batch_size <= out_start) {
out += batch_size;
continue;
}
int64 offset = out_start - out;
offset = offset>0 ? offset : 0;
if (out + batch_size > out_end) {
std::copy(in + offset, in + (out_end-out), out + offset);
return;
}
std::copy(in + offset, in + batch_size, out + offset);
out += batch_size;
}
in += batch_size;
}
}
// handle remaining data
int64 group_to_cpy = (out_end-out) / group_size + 1;
for (int64 i = 0; i < group_to_cpy; ++i) {
for (int64 j = 0; j < repeats_flat.size(); ++j) {
for (int64 k = 0; k < repeats_flat(j); ++k) {
if (out + batch_size > out_end) {
std::copy(in, in + (out_end-out), out);
return;
}
std::copy(in, in + batch_size, out);
out += batch_size;
}
in += batch_size;
}
}
};
Shard(worker_threads->num_threads, worker_threads->workers, output_flat.size(),
cost_per_unit, work);
}
#define REGISTER(T) \
template void RepeatCPUImpl<T>( \
const Tensor& input, \
const typename TTypes<int32>::ConstFlat& repeats_flat, \
int axis, Tensor* output);
#define REGISTER_V2(T) \
template void RepeatCPUImplV2<T>( \
DeviceBase* d, const Tensor& input, \
const typename TTypes<int32>::ConstFlat& repeats_flat, \
int axis, int64 cost_per_unit, Tensor* output);
TF_CALL_ALL_TYPES(REGISTER);
TF_CALL_ALL_TYPES(REGISTER_V2);
#undef REGISTER
#undef REGISTER_V2
} // end namespace tensorflow
|
814db2a5456d14b10a1cd011ae011d7c8e7947e9
|
11211916f39b9d98027b64d778e52743d0c519a1
|
/L3/code/design/musicphotos/doc/assignments/logic.cpp
|
f939e1775e30271abd424d2345b83840b2a9e2e2
|
[] |
no_license
|
mantasruigys3000/Group-Task
|
87baf1bc2747323c0508f6f32ef733c3f4b50978
|
6790d74ae7fa0fe6b13733efcd75a9f4aca70ab0
|
refs/heads/master
| 2020-04-23T20:54:09.696659
| 2019-02-22T01:29:53
| 2019-02-22T01:29:53
| 171,454,102
| 0
| 0
| null | 2019-02-19T10:31:09
| 2019-02-19T10:31:08
| null |
UTF-8
|
C++
| false
| false
| 302
|
cpp
|
logic.cpp
|
Sit aliquam dolor adipisci dolor tempora.
Labore etincidunt magnam modi ipsum.
Voluptatem voluptatem dolor quiquia consectetur.
Dolore voluptatem consectetur magnam magnam non quisquam.
Numquam quaerat neque tempora non dolorem.
Username: Fred
Password: 1202
Porro magnam modi dolore adipisci numquam.
|
c9e759cdfee9168dc9f0e5827e49a2c0ba53f61d
|
613e60d492bf656ca5b53af6d4d9719874637f16
|
/cpp excercise/zoo/whale.cpp
|
2338b52174f627b6f0c37dec9ac83ffb438e5f63
|
[] |
no_license
|
yehudis-k/c-cpp-exercises
|
759edc57fa1a6025075f75ef4aab656a226cc3a8
|
5a21cd9296ad2cbb0174ee59c7f47ff2868b4e96
|
refs/heads/master
| 2022-12-05T21:49:56.608104
| 2020-09-02T16:35:58
| 2020-09-02T16:35:58
| 275,856,616
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 375
|
cpp
|
whale.cpp
|
#include "whale.h"
const std::string Whale:: m_species="whale";
e_continent temp_cont3[] = {Antarctica,Europe};
const std::vector<e_continent>Whale:: m_continent(temp_cont3, temp_cont3 + sizeof(temp_cont3)/sizeof(temp_cont3[0]));
e_food temp_food3[] = {vegetable};
const std::vector<e_food>Whale:: m_foods(temp_food3, temp_food3 + sizeof(temp_food3)/sizeof(temp_food3[0]));
|
ac7a94496a7fc77b382b30273bbe2fce36d705e4
|
7f30cb109e574560873a5eb8bb398c027f85eeee
|
/src/PacsQueryWorkerThread.cxx
|
5648220d7ddbfe0370f915132fd9e666b698aa67
|
[] |
no_license
|
svn2github/MITO
|
e8fd0e0b6eebf26f2382f62660c06726419a9043
|
71d1269d7666151df52d6b5a98765676d992349a
|
refs/heads/master
| 2021-01-10T03:13:55.083371
| 2011-10-14T15:40:14
| 2011-10-14T15:40:14
| 47,415,786
| 1
| 0
| null | null | null | null |
IBM852
|
C++
| false
| false
| 3,248
|
cxx
|
PacsQueryWorkerThread.cxx
|
/**
* \file PacsQueryWorkerThread.cxx
* \brief Thread che gestisce le query al pacs, usato da wxPacsQueryGui
* \author ICAR-CNR Napoli
*/
#include "PacsQueryWorkerThread.h"
#include "wxPacsQueryGui.h"
#include <wx/busyinfo.h>
DEFINE_EVENT_TYPE(wxEVT_THREAD)
PacsQueryWorkerThread::PacsQueryWorkerThread(wxEvtHandler* pParent, wxTextCtrl *pOutBrowser, bool bDaemon)
: wxThread(), m_pParent(pParent), m_pStudyBrowser(NULL), m_bDaemon(bDaemon), m_pStartNode(NULL)
{
setOutput(pOutBrowser);
//setOutput(NULL); // Visto che siamo in ambiente multithread, evitiamo che interferisca
}
PacsQueryWorkerThread::~PacsQueryWorkerThread()
{
m_pStartNode = NULL;
}
wxThread::ExitCode PacsQueryWorkerThread::Entry()
{
/*
La logica di questa classe Ŕ molto semplice:
1) Se non abbiamo specificato m_pStudyBrowser ma c'Ŕ m_pStartNode, allora
vogliamo effettuare una richiesta C-MOVE
2) Se abbiamo specificato m_pStudyBrowser e m_pStartNode, allora stiamo
facendo una followup query (per trovare le serie a partire dagli studi)
3) Se Abbiamo specificato solo m_pStudyBrowser, vogliamo effettuare una
query a livello di studio.
*/
// Clear all browsers and lists
if(!m_bDaemon)
clearAll();
// m_pParent Ŕ in realtÓ la finestra chiamante, ovvero wxPacsQueryGui!
wxPacsQueryGUI *pQueryGui = (wxPacsQueryGUI*)m_pParent;
switch(m_eAction)
{
case E_PACS_CMOVESINGLE:
{
if(m_pStartNode)
send(NULL, m_pStartNode);
}break;
case E_PACS_CMOVEMULTI:
{
list<PacsData*>::iterator iteList = m_downloadQueue.begin();
while (iteList != m_downloadQueue.end())
{
PacsData *pData = *iteList;
if (pData)
{
send(NULL, pData);
}
++iteList;
}
m_downloadQueue.clear();
}break;
case E_PACS_FOLLOWUP:
{
if(!m_pStudyBrowser || !m_pStartNode)
break;
// Followup query
queryFollowUp(m_pStartNode, m_pStartNode->qLev, pQueryGui->getLists());
wxMutexGuiEnter();
wxTreeItemId lvlUp = m_pStudyBrowser->GetSelection();
if(lvlUp.IsOk())
{
m_pStudyBrowser->DeleteChildren(lvlUp);
pQueryGui->getList(1)->display(m_pStudyBrowser, SERIES);
// Activate send menuitem and etc..
//pQueryGui->Raise();
}
wxMutexGuiLeave();
}break;
case E_PACS_STUDYQUERY:
{
if(!m_pStudyBrowser || !m_pStartNode)
break;
// Make normal study query
if(!query((StudyData*)m_pStartNode, pQueryGui->getLists(), true))
{
// Errore query.. notifichiamo l'interfaccia grafica
wxCommandEvent evt(wxEVT_THREAD, wxID_ANY);
evt.SetInt(EVT_MITO_QUERY_ERROR);
m_pParent->AddPendingEvent(evt);
break;
}
wxMutexGuiEnter();
// Display results
pQueryGui->getList(0)->display(m_pStudyBrowser, STUDY);
// Activate send menuitem and etc..
//pQueryGui->Raise();
wxMutexGuiLeave();
}break;
default:
break;
}
// thread ends: notify parent
wxCommandEvent evt(wxEVT_THREAD, wxID_ANY);
evt.SetInt(EVT_MITO_QUERY_TERMINATA); // ID dell'errore (utilizziamolo per comunicare qualcosa al main thread!)
m_pParent->AddPendingEvent(evt);
return EXIT_SUCCESS;
}
|
bea8a2d609677ec5006176a929424b38837d6008
|
9ea9007009ad538027f07a4261fba34d038ced1e
|
/cpp/sdkkit.h
|
e0ab340029433b2c26134fe066a099eab820179a
|
[] |
no_license
|
openwayne/native_sdk
|
b73796e4bc427a13de735dcc589292337b946f60
|
5ff331ccccaccfa47e4b663ebbafc7bfff0bbf5c
|
refs/heads/master
| 2021-01-10T05:54:41.423395
| 2016-02-01T07:54:38
| 2016-02-01T07:54:38
| 45,177,173
| 0
| 1
| null | 2016-02-01T07:54:38
| 2015-10-29T10:48:06
|
C++
|
UTF-8
|
C++
| false
| false
| 3,309
|
h
|
sdkkit.h
|
#ifndef SDK_KIT_H_
#define SDK_KIT_H_
//#define HJR_USE_LUA_SDK 1
#include <iostream>
#include <map>
#ifdef HJR_USE_LUA_SDK
extern "C" {
#include "lua.h"
#include "lualib.h"
#include "lauxlib.h"
}
void initLuaFrame(lua_State* ls);
#endif
//////////////////////////////////////////////
#ifdef HJR_USE_LUA_SDK
int sdkkit_login(lua_State *L);
#else
int sdkkit_login();
#endif
#ifdef HJR_USE_LUA_SDK
int sdkkit_logout(lua_State *L);
#else
int sdkkit_logout();
#endif
#ifdef HJR_USE_LUA_SDK
int sdkkit_pay(lua_State *L);
#else
int sdkkit_pay(int payAmount, const char *productId, const char *productName, const char *payProductNum, const char *payOrderId, const char *payProductDesc, const char *extInfo);
#endif
#ifdef HJR_USE_LUA_SDK
int sdkkit_userCenter(lua_State *L);
#else
int sdkkit_userCenter();
#endif
#ifdef HJR_USE_LUA_SDK
int sdkkit_getOrderInfo(lua_State *L);
#else
int sdkkit_getOrderInfo(const char* payOrderId);
#endif
#ifdef HJR_USE_LUA_SDK
int sdkkit_exitGame(lua_State *L);
#else
int sdkkit_exitGame();
#endif
#ifdef HJR_USE_LUA_SDK
int sdkkit_getCurrentLoginedUserInfo(lua_State *L);
#else
std::string sdkkit_getCurrentLoginedUserInfo();
#endif
//////////////////////////////////////////////
#ifdef HJR_USE_LUA_SDK
int sdkkit_onEnterGame(lua_State *L);
#else
int sdkkit_onEnterGame(const char* roleId, const char* roleName, const char* roleLevel, const char* serverId, const char* serverName);
#endif
#ifdef HJR_USE_LUA_SDK
int sdkkit_onLogin(lua_State *L);
#else
int sdkkit_onLogin(const char* userId, const char* serverId);
#endif
#ifdef HJR_USE_LUA_SDK
int sdkkit_onPay(lua_State *L);
#else
int sdkkit_onPay(int amount, const char* orderNumber, const char* productDesc);
#endif
#ifdef HJR_USE_LUA_SDK
int sdkkit_onUpgrade(lua_State *L);
#else
int sdkkit_onUpgrade(const char* roleLevel);
#endif
#ifdef HJR_USE_LUA_SDK
int sdkkit_onCreateRole(lua_State *L);
#else
int sdkkit_onCreateRole(const char* roleId, const char* roleName, const char* serverId, const char* serverName);
#endif
#ifdef HJR_USE_LUA_SDK
int sdkkit_onButtonClick(lua_State *L);
#else
int sdkkit_onButtonClick(const char* userId, const char* buttonName);
#endif
#ifdef HJR_USE_LUA_SDK
int sdkkit_onServerRoleInfo(lua_State *L);
#else
int sdkkit_onServerRoleInfo(const char* roleId, const char* roleName, int roleLevel, const char* serverId, const char* serverName, const char* rolePartyName, const char* roleVipLevel);
#endif
//////////////////////////////////////////////
void SDKKitPlateformCallBackImplWrapper_initCallBack(int retStatus, std::string retMessage);
void SDKKitPlateformCallBackImplWrapper_loginCallBack(int retStatus, std::string s_retMessage, std::string s_loginUserId, std::string s_loginUserName, std::string s_loginAuthToken, std::string s_loginOpenId, int s_flag);
void SDKKitPlateformCallBackImplWrapper_logoutCallBack(int retStatus, std::string s_retMessage);
void SDKKitPlateformCallBackImplWrapper_payCallBack(int retStatus, std::string s_retMessage, std::string s_payKitOrderId);
void SDKKitPlateformCallBackImplWrapper_getOrderResultCallBack(int retStatus, std::string s_retMessage, std::string s_orderStatus);
void SDKKitPlateformCallBackImplWrapper_exitGameCallBack(int retStatus, std::string s_retMessage);
//////////////////////////////////////////////
#endif
|
7a9b2b28d14ffb9a2dd2e093993f50063cc0bea5
|
10b5248b8ea8ec5e84273df32afae0dcbabcbac2
|
/TP2/src/main_liste.cpp
|
40b9a3e75457cc0c3f1552680ea567059c7342e9
|
[] |
no_license
|
SimonClerbout/L3_CPP_etudiant
|
e19318925ced6766fd50793a1687a34ec1bc4558
|
ff0f6b06f6f65ea680294e162eb0b00b1d21e812
|
refs/heads/master
| 2021-05-05T03:43:27.770661
| 2018-04-19T09:57:04
| 2018-04-19T09:57:04
| 119,805,943
| 0
| 0
| null | 2018-02-01T08:25:57
| 2018-02-01T08:25:57
| null |
UTF-8
|
C++
| false
| false
| 300
|
cpp
|
main_liste.cpp
|
#include <iostream>
#include "Liste.hpp"
int main(){
Liste l;
//Noeud* n = new Noeud();
l.ajouterDevant(13);
l.ajouterDevant(37);
std::cout << l.getTaille() << std::endl;
for(int i = 0; i < l.getTaille(); i++){
std::cout << l.getElement(i) << std::endl;
}
return 0;
}
|
955338f6f031cf21fdabf0b299150f9e13d80745
|
5e4e2ae5c863dee1003c064ef70d74c9165fc65e
|
/trees/flatten-binary-tree-to-linked-list.cpp
|
0476a766ad87f441ef46cf79dbb8a36b99c51305
|
[] |
no_license
|
rootid/fft
|
3ec6f0e6ae1be96d531119b2571610646a7256e9
|
af187df0eafee37f69d6be95dc22685a96b96742
|
refs/heads/master
| 2020-12-14T09:24:18.915482
| 2019-07-25T23:52:21
| 2019-07-25T23:52:21
| 46,454,112
| 1
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 2,057
|
cpp
|
flatten-binary-tree-to-linked-list.cpp
|
//Given a binary tree, flatten it to a linked list in-place.
//For example,
//Given
// 1
// / \
// 2 5
// / \ \
// 3 4 6
//The flattened tree should look like:
// 1
// \
// 2
// \
// 3
// \
// 4
// \
// 5
// \
// 6
//If you notice carefully in the flattened tree, each node's right child points
//to the next node of a pre-order traversal.
//
//
//
//######################################### Recursive approach#########################################
public void flatten(TreeNode root) {
if(root == null) return;
TreeNode tmp = root;
TreeNode lastRight = root.right;
root.right = root.left;
root.left = null;
while(tmp.right != null) tmp = tmp.right;
tmp.right = lastRight;
flatten(root.right);
}
//######################################### Recursive approach#########################################
void flatten(TreeNode* root) {
if(!root) {
return;
}
TreeNode *tmp = root;
TreeNode *prev_right = root->right;
root->right = root->left;
root->left = NULL;
while(tmp->right != NULL) {
tmp = tmp->right;
}
tmp->right = prev_right;
flatten(root->right);
return;
}
//#########################################Iterative approach#########################################
void flatten(TreeNode *root) {
stack<TreeNode *> stk;
if(root==NULL)
return;
stk.push(root);
TreeNode *oldptr=NULL;
while(!stk.empty()){ // preorder traversal using a stack
TreeNode *ptr=stk.top(); // Using ptr to do travesal
stk.pop();
if(ptr->right)
stk.push(ptr->right);
if(ptr->left)
stk.push(ptr->left);
if(oldptr!=NULL){ // Using oldptr to change left and right pointer
oldptr->left=NULL;
oldptr->right=ptr;
}
oldptr=ptr;
}
}
int main() {
}
|
f2f38d1c46c98c633c515853346e00b82307b27e
|
ba86aa615a1455fd79ac3732b77d07f935a04ae3
|
/c++程序/最小倍数数位和.cpp
|
2c4cbc60739779da7c8a24ea6105ada347751584
|
[] |
no_license
|
300I/jjj
|
ce0c64bd3a535e593ec38f8b498b77e5ec71e334
|
942c708fc5994ae75cf96e254dac00ba00b94e88
|
refs/heads/master
| 2020-07-10T01:20:30.600985
| 2019-09-16T12:50:09
| 2019-09-16T12:50:09
| 204,130,261
| 1
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 519
|
cpp
|
最小倍数数位和.cpp
|
#include<stdio.h>
#include<algorithm>
using namespace std;
unsigned long long n,stp,tmp=1,re,x,s,ans=INT_MAX,check;
int main()
{
scanf("%lld",&n);
while(1)
{
x=n*tmp;
check=x;
// printf("%lld\n",x);
while(x)
{
s+=x%10;
x/=10;
}
if(check<=0 or check/tmp!=n)
{
printf("%lld",ans);
return 0;
}
else
{
ans=min(s,ans);
}
s=0;
tmp++;
stp++;
if(stp==5000000)
{
break;
}
else
{
continue;
}
}
printf("%lld",ans);
}
|
88566235cd9347352d7d49b8cea93d68fe15c7bc
|
986c21d401983789d9b3e5255bcf9d76070f65ec
|
/src/plugins/bittorrent/alertdispatcher.h
|
e90b601d3941a60ed2c64a9e2ec2fd7a1108561b
|
[
"BSL-1.0"
] |
permissive
|
0xd34df00d/leechcraft
|
613454669be3a0cecddd11504950372c8614c4c8
|
15c091d15262abb0a011db03a98322248b96b46f
|
refs/heads/master
| 2023-07-21T05:08:21.348281
| 2023-06-04T16:50:17
| 2023-06-04T16:50:17
| 119,854
| 149
| 71
| null | 2017-09-03T14:16:15
| 2009-02-02T13:52:45
|
C++
|
UTF-8
|
C++
| false
| false
| 2,410
|
h
|
alertdispatcher.h
|
/**********************************************************************
* LeechCraft - modular cross-platform feature rich internet client.
* Copyright (C) 2006-2014 Georg Rudoy
*
* Distributed under the Boost Software License, Version 1.0.
* (See accompanying file LICENSE or copy at https://www.boost.org/LICENSE_1_0.txt)
**********************************************************************/
#pragma once
#include <list>
#include <memory>
#include <QHash>
#include <util/sll/typegetter.h>
namespace libtorrent
{
class alert;
class session;
}
namespace LC::BitTorrent
{
using AlertHandler_f = std::function<bool (const libtorrent::alert&)>;
class AlertDispatcherRegGuard
{
std::list<AlertHandler_f>& HandlerList_;
std::list<AlertHandler_f>::iterator Pos_;
public:
AlertDispatcherRegGuard (std::list<AlertHandler_f>& list, std::list<AlertHandler_f>::iterator pos)
: HandlerList_ { list }
, Pos_ { pos }
{
}
AlertDispatcherRegGuard (AlertDispatcherRegGuard&&) = delete;
AlertDispatcherRegGuard (const AlertDispatcherRegGuard&) = delete;
AlertDispatcherRegGuard& operator= (AlertDispatcherRegGuard&&) = delete;
AlertDispatcherRegGuard& operator= (const AlertDispatcherRegGuard&) = delete;
~AlertDispatcherRegGuard ()
{
HandlerList_.erase (Pos_);
}
};
class AlertDispatcher
{
libtorrent::session& Session_;
QHash<int, std::list<AlertHandler_f>> Handlers_;
public:
explicit AlertDispatcher (libtorrent::session&);
template<typename F>
int RegisterHandler (F&& f)
{
using AlertType_t = std::decay_t<Util::ArgType_t<F, 0>>;
constexpr int type = AlertType_t::alert_type;
auto& list = Handlers_ [type];
list.push_front ([f] (const libtorrent::alert& alert)
{
if constexpr (std::is_same_v<Util::RetType_t<F>, bool>)
return f (static_cast<const AlertType_t&> (alert));
else
{
f (static_cast<const AlertType_t&> (alert));
return true;
}
});
return type;
}
template<typename F>
std::unique_ptr<AlertDispatcherRegGuard> RegisterTemporaryHandler (F&& f)
{
auto alertType = RegisterHandler (std::forward<F> (f));
auto& list = Handlers_ [alertType];
return std::make_unique<AlertDispatcherRegGuard> (list, list.begin ());
}
void Swallow (int alertType, bool logging);
void PollAlerts ();
private:
void DispatchAlert (const libtorrent::alert&) const;
};
}
|
1714ff3ac86073348d96ea6020083b31b6ebacbb
|
4e0f3e452a0646c03b9908a80560d194789a3727
|
/shell/browser/notifications/web_push_content_views.cc
|
1b6b403d304c5b5e5ce68b966a438a1bcb16a8bc
|
[] |
no_license
|
gregorykim/testdup
|
c35befad3a1827a1341f2b450eae44b1720d66f3
|
5d81cf84442e40102ff2972dd8d912e6fe5278bd
|
refs/heads/master
| 2021-01-01T06:57:48.121365
| 2017-07-18T06:44:03
| 2017-07-18T06:44:03
| 97,563,081
| 0
| 0
| null | 2017-07-21T02:16:54
| 2017-07-18T06:50:32
|
C++
|
UTF-8
|
C++
| false
| false
| 4,913
|
cc
|
web_push_content_views.cc
|
// Copyright 2013 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "content/shell/browser/notifications/web_push_content_views.h"
#include "base/strings/utf_string_conversions.h"
#include "ui/aura/window.h"
#include "ui/aura/window_event_dispatcher.h"
#include "ui/aura/window_tree_host.h"
#include "ui/base/resource/resource_bundle.h"
#include "ui/display/screen.h"
#include "ui/events/event.h"
#include "ui/views/background.h"
#include "ui/views/view.h"
#include "ui/views/widget/widget.h"
#include "ui/views/widget/widget_delegate.h"
namespace WebPushView {
#define DIALOG_TOP_POSITION false
#define DIALOG_WIDTH 400
#define DIALOG_HEIGHT 250
#define DIALOG_CONTROL_OK "OK"
/*
class WebPushViewRequestList{
public:
void Add();
void remove();
void finalize();
private:
};
*/
WebPushViewRequest::WebPushViewRequest()
{
}
WebPushViewRequest::~WebPushViewRequest()
{
}
WebPushViewRequest::WebPushViewRequest(std::unique_ptr<content::DesktopNotificationDelegate> delegate,base::string16 title,base::string16 message )
:title_(title),
message_(message),
delegate_(std::move(delegate))
{
}
void WebPushViewRequest::Add()
{
}
//void WebPushViewRequest::Layout(){}
void WebPushViewRequest::finalizeWebPush() const
{
if(delegate_)
delegate_->NotificationClosed();
}
void WebPushViewRequest::DisplayWebPush()
{
gfx::Size default_size(500,200);
window_widget_ = new views::Widget;
views::Widget::InitParams params;
params.remove_standard_frame = true;
params.type = views::Widget::InitParams::TYPE_POPUP;
params.opacity = views::Widget::InitParams::OPAQUE_WINDOW;
content_view_ = new WebPushContentViews(this);
params.bounds = gfx::Rect(default_size.width(),default_size.height());
params.delegate = content_view_;
window_widget_->Init(params);
content_view_->SetWebPushTitle(message_);
content_view_->SetWebPushMessage(message_);
gfx::NativeWindow window_;
window_ = window_widget_->GetNativeWindow();
window_->GetHost()->Show();
window_widget_->Show();
if(delegate_)
delegate_->NotificationDisplayed();
}
WebPushContentViews::WebPushContentViews(const WebPushViewRequest* req)
:request_(req)
{
}
void WebPushContentViews::ButtonPressed(views::Button* sender, const ui::Event& event)
{
getReq()->finalizeWebPush();
GetWidget()->Close();
}
void WebPushContentViews::CreateWidget()
{
set_background(views::Background::CreateStandardPanelBackground());
SetBorder(
views::Border::CreateSolidSidedBorder(0, 0, 1, 1, SkColorSetRGB(0xC0, 0xC0, 0xC0)));
// int label_width = 0;
views::GridLayout* layout = new views::GridLayout(this);
SetLayoutManager(layout);
views::ColumnSet* column_set = layout->AddColumnSet(0);
column_set->AddPaddingColumn(0, 5);
column_set->AddColumn(views::GridLayout::FILL, views::GridLayout::FILL, 1,
views::GridLayout::USE_PREF, 0, 0);
column_set->AddPaddingColumn(0, 5);
layout->AddPaddingRow(0, 2);
{ // Title
layout->StartRow(0, 0);
title_label_ = new views::Label();
title_label_->SetMultiLine(true);
layout->AddView(title_label_);
}
layout->AddPaddingRow(0, 5);
{ // message
message_label_ = new views::Label();
message_label_->SetMultiLine(true);
layout->StartRow(1, 0);
layout->AddView(message_label_);
}
layout->AddPaddingRow(0, 5);
layout->StartRow(0, 0);
button_view_ = new View();
views::GridLayout* button_layout = new views::GridLayout(button_view_);
button_view_->SetLayoutManager(button_layout);
views::ColumnSet* button_column_set =
button_layout->AddColumnSet(0);
exit_button_ = new views::LabelButton(this, base::ASCIIToUTF16(DIALOG_CONTROL_OK));
exit_button_->SetStyle(views::Button::STYLE_BUTTON);
gfx::Size cancel_button_size = exit_button_->GetPreferredSize();
button_column_set->AddColumn(views::GridLayout::FILL,
views::GridLayout::FILL, 1,
views::GridLayout::FIXED,
cancel_button_size.width(),
cancel_button_size.width() / 2);
button_layout->StartRow(0, 0);
button_layout->AddView(exit_button_);
layout->AddView(button_view_);
}
void WebPushContentViews::ViewHierarchyChanged(
const ViewHierarchyChangedDetails& details) {
if (details.is_add && details.child == this) {
CreateWidget();
}
}
void WebPushContentViews::SetWebPushTitle(const base::string16& title)
{
title_label_->SetText(title_);
}
void WebPushContentViews::SetWebPushMessage(const base::string16& msg)
{
message_label_->SetText(msg);
}
}
|
59fc28e78ae91849e43c096f982b84f0e5f78bb4
|
5d4b70ac5e555e3c8b68534ef1790ce041a0f65e
|
/deps/opencolorio-2.0.0/src/OpenColorIO/transforms/ExposureContrastTransform.cpp
|
49b8bbb316dcdfb5a3f3f21ae21f61a8bbc56691
|
[
"LicenseRef-scancode-unknown-license-reference",
"Apache-2.0",
"BSD-3-Clause",
"CC-BY-4.0"
] |
permissive
|
LuxCoreRender/LuxCore
|
eddb0e3710cbc8fa28cb80f16d908f1ec3cc72db
|
2f35684a04d9e1bd48d6ffa88b19a88871e90942
|
refs/heads/master
| 2023-08-17T01:28:23.931381
| 2023-05-28T22:25:00
| 2023-05-28T22:25:00
| 111,695,279
| 1,055
| 154
|
Apache-2.0
| 2023-08-03T20:21:05
| 2017-11-22T14:36:32
|
C++
|
UTF-8
|
C++
| false
| false
| 5,294
|
cpp
|
ExposureContrastTransform.cpp
|
// SPDX-License-Identifier: BSD-3-Clause
// Copyright Contributors to the OpenColorIO Project.
#include <OpenColorIO/OpenColorIO.h>
#include "transforms/ExposureContrastTransform.h"
namespace OCIO_NAMESPACE
{
ExposureContrastTransformRcPtr ExposureContrastTransform::Create()
{
return ExposureContrastTransformRcPtr(new ExposureContrastTransformImpl(),
&ExposureContrastTransformImpl::deleter);
}
void ExposureContrastTransformImpl::deleter(ExposureContrastTransform * t)
{
delete static_cast<ExposureContrastTransformImpl *>(t);
}
TransformRcPtr ExposureContrastTransformImpl::createEditableCopy() const
{
TransformRcPtr transform = ExposureContrastTransform::Create();
dynamic_cast<ExposureContrastTransformImpl*>(transform.get())->data() = data();
return transform;
}
TransformDirection ExposureContrastTransformImpl::getDirection() const noexcept
{
return data().getDirection();
}
void ExposureContrastTransformImpl::setDirection(TransformDirection dir) noexcept
{
data().setDirection(dir);
}
void ExposureContrastTransformImpl::validate() const
{
try
{
Transform::validate();
data().validate();
}
catch (Exception & ex)
{
std::string errMsg("ExposureContrastTransform validation failed: ");
errMsg += ex.what();
throw Exception(errMsg.c_str());
}
}
FormatMetadata & ExposureContrastTransformImpl::getFormatMetadata() noexcept
{
return data().getFormatMetadata();
}
const FormatMetadata & ExposureContrastTransformImpl::getFormatMetadata() const noexcept
{
return data().getFormatMetadata();
}
bool ExposureContrastTransformImpl::equals(const ExposureContrastTransform & other) const noexcept
{
if (this == &other) return true;
return data() == dynamic_cast<const ExposureContrastTransformImpl*>(&other)->data();
}
ExposureContrastStyle ExposureContrastTransformImpl::getStyle() const
{
return ExposureContrastOpData::ConvertStyle(data().getStyle());
}
void ExposureContrastTransformImpl::setStyle(ExposureContrastStyle style)
{
auto curDir = getDirection();
data().setStyle(ExposureContrastOpData::ConvertStyle(style, curDir));
}
double ExposureContrastTransformImpl::getExposure() const
{
return data().getExposure();
}
void ExposureContrastTransformImpl::setExposure(double exposure)
{
data().setExposure(exposure);
}
void ExposureContrastTransformImpl::makeExposureDynamic()
{
data().getExposureProperty()->makeDynamic();
}
void ExposureContrastTransformImpl::makeExposureNonDynamic()
{
data().getExposureProperty()->makeNonDynamic();
}
bool ExposureContrastTransformImpl::isExposureDynamic() const
{
return data().getExposureProperty()->isDynamic();
}
double ExposureContrastTransformImpl::getContrast() const
{
return data().getContrast();
}
void ExposureContrastTransformImpl::setContrast(double contrast)
{
data().setContrast(contrast);
}
void ExposureContrastTransformImpl::makeContrastDynamic()
{
data().getContrastProperty()->makeDynamic();
}
void ExposureContrastTransformImpl::makeContrastNonDynamic()
{
data().getContrastProperty()->makeNonDynamic();
}
bool ExposureContrastTransformImpl::isContrastDynamic() const
{
return data().getContrastProperty()->isDynamic();
}
double ExposureContrastTransformImpl::getGamma() const
{
return data().getGamma();
}
void ExposureContrastTransformImpl::setGamma(double gamma)
{
data().setGamma(gamma);
}
void ExposureContrastTransformImpl::makeGammaDynamic()
{
data().getGammaProperty()->makeDynamic();
}
void ExposureContrastTransformImpl::makeGammaNonDynamic()
{
data().getGammaProperty()->makeNonDynamic();
}
bool ExposureContrastTransformImpl::isGammaDynamic() const
{
return data().getGammaProperty()->isDynamic();
}
double ExposureContrastTransformImpl::getPivot() const
{
return data().getPivot();
}
void ExposureContrastTransformImpl::setPivot(double pivot)
{
data().setPivot(pivot);
}
double ExposureContrastTransformImpl::getLogExposureStep() const
{
return data().getLogExposureStep();
}
void ExposureContrastTransformImpl::setLogExposureStep(double logExposureStep)
{
data().setLogExposureStep(logExposureStep);
}
double ExposureContrastTransformImpl::getLogMidGray() const
{
return data().getLogMidGray();
}
void ExposureContrastTransformImpl::setLogMidGray(double logMidGray)
{
return data().setLogMidGray(logMidGray);
}
std::ostream& operator<< (std::ostream & os, const ExposureContrastTransform & t)
{
os << "<ExposureContrast ";
os << "direction=" << TransformDirectionToString(t.getDirection());
os << ", style=" << ExposureContrastStyleToString(t.getStyle());
os << ", exposure=" << t.getExposure();
os << ", contrast=" << t.getContrast();
os << ", gamma=" << t.getGamma();
os << ", pivot=" << t.getPivot();
os << ", logExposureStep=" << t.getLogExposureStep();
os << ", logMidGray=" << t.getLogMidGray();
if (t.isExposureDynamic())
{
os << ", exposureDynamic";
}
if (t.isContrastDynamic())
{
os << ", contrastDynamic";
}
if (t.isGammaDynamic())
{
os << ", gammaDynamic";
}
os << ">";
return os;
}
} // namespace OCIO_NAMESPACE
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.