blob_id stringlengths 40 40 | directory_id stringlengths 40 40 | path stringlengths 4 201 | content_id stringlengths 40 40 | detected_licenses listlengths 0 85 | license_type stringclasses 2
values | repo_name stringlengths 7 100 | snapshot_id stringlengths 40 40 | revision_id stringlengths 40 40 | branch_name stringclasses 260
values | visit_date timestamp[us] | revision_date timestamp[us] | committer_date timestamp[us] | github_id int64 11.4k 681M ⌀ | star_events_count int64 0 209k | fork_events_count int64 0 110k | gha_license_id stringclasses 17
values | gha_event_created_at timestamp[us] | gha_created_at timestamp[us] | gha_language stringclasses 80
values | src_encoding stringclasses 28
values | language stringclasses 1
value | is_vendor bool 1
class | is_generated bool 2
classes | length_bytes int64 8 9.86M | extension stringclasses 52
values | content stringlengths 8 9.86M | authors listlengths 1 1 | author stringlengths 0 119 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
a345d7b5b70bede203daac67789c6abbe6e83244 | c2011ac80f35e15e31061d75920c16e80a2b2c7c | /old_gui_stuff/old_gui_libraries/tui/generator/TemplateGenerator.cpp | 4cb83e79d68b3edf4f997200ccef21c61dbdffb4 | [] | no_license | antonbobkov/burn_n_turn | 40f81a18d1f6c02c1a5d7b653c3f689d85035423 | 2c6eecc1fe2c5acbbb327f8e998b09fbce818618 | refs/heads/master | 2020-03-13T09:48:48.835394 | 2019-03-31T15:18:16 | 2019-03-31T15:18:32 | 131,071,880 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,085 | cpp | #include <iostream>
#include <fstream>
#include <string>
using namespace std;
string sFunctorBaseName = "ThreadFunctor";
string sFunctorName = "ThreadFunctor";
string sTemplatedClasses = "T";
string sFnArgName = "fn";
string sArgName = "arg";
string sFnReturnType = "void";
string sTab = "\t";
void GenerateFunctorBase(ostream& ofs)
{
ofs << "struct " << sFunctorBaseName << "\n{\n";
ofs << sTab << "virtual void Apply()=0;\n\n";
ofs << sTab << "virtual ~" << sFunctorBaseName << "(){};\n};\n\n";
}
void GenerateSystemThread(ostream& ofs)
{
ofs << "void SystemNewThread(" << sFunctorBaseName << "* pF);\n\n";
}
void GenerateList(ostream& ofs, string sPrefix, int n)
{
for(int i = 0; i < n; ++i)
{
ofs << sPrefix << i;
if(i != n - 1)
ofs << ", ";
}
}
void GenerateListFancy(ostream& ofs, string sPrefix, string sMidFix, string sPostFix, bool bSep, int n)
{
for(int i = 0; i < n; ++i)
{
ofs << sPrefix << i << sMidFix << i << sPostFix;
if(i != n - 1 && bSep)
ofs << ", ";
}
}
void GenerateFunctorClass(ostream& ofs, int n)
{
if(n != 0)
{
ofs << "template <";
GenerateList(ofs, "class " + sTemplatedClasses, n);
ofs << ">\n";
}
ofs << "struct " << sFunctorName << n << ": public " << sFunctorBaseName << "\n{\n";
ofs << sTab << "void (*" << sFnArgName << ")(";
GenerateList(ofs, sTemplatedClasses, n);
ofs << ");\n\n";
GenerateListFancy(ofs, sTab + sTemplatedClasses, " " + sArgName, ";\n", false, n);
ofs << "\n";
ofs << sTab << sFunctorName << n << "(";
ofs << "void (*" << sFnArgName + "_" << ")(";
GenerateList(ofs, sTemplatedClasses, n);
ofs << ")";
if(n != 0)
ofs << ", ";
GenerateListFancy(ofs, sTemplatedClasses, " " + sArgName, "_", true, n);
ofs << ")\n";
ofs << sTab << sTab << ":" << sFnArgName << "(" << sFnArgName << "_)";
if(n != 0)
ofs << ", ";
GenerateListFancy(ofs, sArgName, "(" + sArgName, "_)", true, n);
ofs << "{}\n\n";
ofs << sTab << "/*virtual*/ void Apply()\n";
ofs << sTab << "{\n";
ofs << sTab << sTab << sFnArgName << "(";
GenerateList(ofs, sArgName, n);
ofs << ");\n";
ofs << sTab << "}\n";
ofs << "};\n\n";
};
void GenerateFunction(ostream& ofs, int n)
{
if(n != 0)
{
ofs << "template <";
GenerateList(ofs, "class " + sTemplatedClasses, n);
ofs << ">\n";
}
ofs << "void NewThread(";
ofs << "void (*" << sFnArgName << ")(";
GenerateList(ofs, sTemplatedClasses, n);
ofs << ")";
if(n != 0)
ofs << ", ";
GenerateListFancy(ofs, sTemplatedClasses, " " + sArgName, "", true, n);
ofs << ")\n{\n";
ofs << sTab << sFunctorBaseName << "* pF = new " << sFunctorName << n;
if(n != 0)
{
ofs << "<";
GenerateList(ofs, sTemplatedClasses, n);
ofs << ">";
}
ofs << "(" << sFnArgName;
if(n != 0)
ofs << ", ";
GenerateList(ofs, sArgName, n);
ofs << ");\n";
ofs << sTab << "SystemNewThread(pF);\n}\n\n";
};
int main()
{
int n = 10;
ofstream ofs("../../GenTui.h");
GenerateFunctorBase(ofs);
GenerateSystemThread(ofs);
for(int i = 0; i <= n; ++i)
{
GenerateFunctorClass(ofs, i);
GenerateFunction(ofs, i);
}
return 0;
} | [
"texfan@gmail.com"
] | texfan@gmail.com |
fb7021524ccfd23b30212861ba0830a21b78057d | e232de1f42a922dc0c94d889c1f72d4f66b325d6 | /src/rec/widget/status/TextComponent.cpp | 9c96193c3455a83c2fd4d5eb73aa99bb5c4698cc | [] | no_license | rec/slow_gold | b19fcd684e469978bf20cd0638fa83786fc5ffae | f4551785cf7f9cf45605a850d013eef5d80f4ea6 | refs/heads/master | 2022-10-20T06:37:00.370927 | 2017-02-04T11:39:59 | 2017-02-04T11:39:59 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,093 | cpp | #include "rec/widget/status/TextComponent.h"
#include "rec/util/FormatTime.h"
#include "rec/util/thread/CallAsync.h"
#include "rec/widget/Painter.h"
using rec::gui::Colors;
using rec::gui::Color;
using namespace juce;
namespace rec {
namespace widget {
namespace status {
namespace time {
// Skin
TextComponent::TextComponent(const Text& desc)
: gui::SimpleLabel(str(desc.widget().name())),
StateListener<SampleTime>(desc.use_global_clock()),
description_(desc),
length_(0),
sampleRate_(44100.0),
empty_(true) {
setJustificationType(Justification::centred);
setFont(Font(juce::Font::getDefaultMonospacedFontName(), 20, Font::plain));
}
SampleTime TextComponent::getTime() const {
Lock l(lock_);
return time_;
}
void TextComponent::operator()(const waveform::Viewport& vp) {
Lock l(lock_);
sampleRate_ = vp.loop_points().sample_rate();
empty_ = not vp.loop_points().has_sample_rate();
}
void TextComponent::languageChanged() {
Lock l(lock_);
setTooltip(Trans("Time Display: Shows the current playback time in minutes, "
"seconds and millseconds."));
}
void TextComponent::setTime(SampleTime t) {
if (doSetTime(t))
redisplay();
}
bool TextComponent::doSetTime(SampleTime t) {
bool res;
Lock l(lock_);
time_ = t;
if (empty_) {
res = timeDisplay_ == "";
timeDisplay_ = "";
} else {
bool f = description_.separator().flash();
TimeFormat tf(f ? TimeFormat::FLASH : TimeFormat::NO_FLASH);
String timeDisplay = tf.format(time_, length_, sampleRate_);
res = (timeDisplay == timeDisplay_);
timeDisplay_ = timeDisplay;
}
return res;
}
void TextComponent::redisplay() {
String dis;
{
Lock l(lock_);
dis = timeDisplay_;
}
MessageManagerLock l(thread());
if (l.lockWasGained())
setText(dis, juce::dontSendNotification);
}
} // namespace time
} // namespace status
} // namespace widget
} // namespace rec
| [
"tom@swirly.com"
] | tom@swirly.com |
61a6ea501259f410c738f25ceb6837372bd9c0a7 | 005dd75a02dca02048c22c9acd48b0e4c2b26e8b | /cc/commlink_test.cc | 1c51dd6947b1ec476b2911180a5551de21674c9e | [
"MIT"
] | permissive | funrollloops/tensixty | fff302cdfbbd0b589cc384aa8b26d067d1852122 | 1e659c7c4a37e0ae47bd66b62bff9c2a53d746fe | refs/heads/master | 2021-04-04T03:01:10.930026 | 2020-03-17T06:49:46 | 2020-03-17T06:49:46 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 4,756 | cc | // Using https://github.com/google/googletest
#include <gtest/gtest.h>
#include "commlink.h"
namespace tensixty {
namespace {
TEST(AckTest, SerializeDeserialize) {
Ack a;
EXPECT_EQ(a.index(), 0);
a.Parse(0x81);
EXPECT_EQ(a.index(), 1);
EXPECT_EQ(a.error(), true);
EXPECT_EQ(a.ok(), false);
a.Parse(0x71);
EXPECT_EQ(a.index(), 0x71);
EXPECT_EQ(a.error(), false);
EXPECT_EQ(a.ok(), true);
a.Parse(0xF1);
EXPECT_EQ(a.index(), 0x71);
EXPECT_EQ(a.error(), true);
EXPECT_EQ(a.ok(), false);
Ack b;
EXPECT_EQ(b.index(), 0);
b = a;
EXPECT_EQ(b.index(), 0x71);
EXPECT_EQ(b.error(), true);
EXPECT_EQ(b.ok(), false);
a.Parse(0x10);
EXPECT_EQ(b.index(), 0x71);
EXPECT_EQ(b.error(), true);
EXPECT_EQ(b.ok(), false);
EXPECT_EQ(a.index(), 0x10);
EXPECT_EQ(a.error(), false);
EXPECT_EQ(a.ok(), true);
}
TEST(PacketTest, ParseOkay) {
unsigned char header[7], data[15];
unsigned char data_bytes;
const unsigned char MESSAGE_SIZE = 4;
const unsigned char message_to_send[MESSAGE_SIZE] = {0x23, 0xFF, 0x01, 0x88};
{
Packet original;
original.IncludeAck(Ack(0xF1));
original.IncludeData(22, message_to_send, MESSAGE_SIZE);
EXPECT_EQ(original.ack().error(), true);
EXPECT_EQ(original.ack().index(), 0x71);
EXPECT_EQ(original.index_sending(), 22);
unsigned char length;
const unsigned char *contents = original.data(&length);
EXPECT_EQ(length, MESSAGE_SIZE);
for (int i = 0; i < length; ++i) {
EXPECT_EQ(contents[i], message_to_send[i]);
}
original.Serialize(header, data, &data_bytes);
EXPECT_EQ(data_bytes, MESSAGE_SIZE + 2);
}
{
Packet parsed;
for (int i = 0; i < 7; ++i) {
EXPECT_EQ(INCOMPLETE, parsed.ParseChar(header[i]));
}
EXPECT_EQ(parsed.ack().error(), true);
EXPECT_EQ(parsed.ack().index(), 0x71);
EXPECT_EQ(parsed.index_sending(), 22);
for (int i = 0; i < MESSAGE_SIZE + 1; ++i) {
EXPECT_EQ(INCOMPLETE, parsed.ParseChar(data[i]));
}
EXPECT_EQ(PARSED, parsed.ParseChar(data[MESSAGE_SIZE + 1]));
EXPECT_EQ(parsed.ack().error(), true);
EXPECT_EQ(parsed.ack().index(), 0x71);
EXPECT_EQ(parsed.index_sending(), 22);
unsigned char length;
const unsigned char *contents = parsed.data(&length);
EXPECT_EQ(length, MESSAGE_SIZE);
for (int i = 0; i < length; ++i) {
EXPECT_EQ(contents[i], message_to_send[i]);
}
}
}
TEST(PacketTest, ParseHeaderNotOkay) {
for (int i = 0; i < 7; ++i) {
unsigned char header[7], data[15];
unsigned char data_bytes;
const unsigned char MESSAGE_SIZE = 4;
const unsigned char message_to_send[MESSAGE_SIZE] = {0x23, 0xFF, 0x01, 0x88};
{
Packet original;
original.IncludeAck(Ack(0xF1));
original.IncludeData(22, message_to_send, MESSAGE_SIZE);
unsigned char length;
original.data(&length);
original.Serialize(header, data, &data_bytes);
}
header[i] += 1;
{
Packet parsed;
if (i == 0) {
EXPECT_EQ(HEADER_ERROR, parsed.ParseChar(header[0]));
continue;
} else if (i == 1) {
EXPECT_EQ(INCOMPLETE, parsed.ParseChar(header[0]));
EXPECT_EQ(HEADER_ERROR, parsed.ParseChar(header[1]));
continue;
}
for (int j = 0; j < 5; ++j) {
EXPECT_EQ(INCOMPLETE, parsed.ParseChar(header[j]));
}
if (i != 6) {
EXPECT_EQ(HEADER_ERROR, parsed.ParseChar(header[5]));
} else {
EXPECT_EQ(INCOMPLETE, parsed.ParseChar(header[5]));
EXPECT_EQ(HEADER_ERROR, parsed.ParseChar(header[6]));
}
}
}
}
TEST(PacketTest, ParseDataNotOkay) {
static const unsigned int MESSAGE_SIZE = 255;
unsigned char message_to_send[MESSAGE_SIZE];
for (int i = 0; i < MESSAGE_SIZE; ++i) {
message_to_send[i] = i;
}
for (int x = 0; x < MESSAGE_SIZE; ++x) {
unsigned char header[7], data[MESSAGE_SIZE + 2];
unsigned char data_bytes;
{
Packet original;
original.IncludeAck(Ack(0xF1));
original.IncludeData(22, message_to_send, MESSAGE_SIZE);
original.Serialize(header, data, &data_bytes);
}
data[x] += 1;
Packet parsed;
for (int i = 0; i < 7; ++i) {
EXPECT_EQ(INCOMPLETE, parsed.ParseChar(header[i]));
}
EXPECT_EQ(parsed.ack().error(), true);
EXPECT_EQ(parsed.ack().index(), 0x71);
EXPECT_EQ(parsed.index_sending(), 22);
for (int i = 0; i < MESSAGE_SIZE; ++i) {
EXPECT_EQ(INCOMPLETE, parsed.ParseChar(data[i]));
}
bool found_error = false;
for (int i = 0; i < 2; ++i) {
if (DATA_ERROR == parsed.ParseChar(data[MESSAGE_SIZE + i])) {
found_error = true;
break;
}
}
EXPECT_TRUE(found_error);
}
}
} // namespace
} // namespace tensixty
| [
"stevens.mark.a@gmail.com"
] | stevens.mark.a@gmail.com |
e4a996498b695c6165ad2993fe4738f0372a3a1e | 935927010571e2f820e70cead9a1fd471d88ea16 | /Online Judge/Codeforces/Contests/DIV2/DIV2-475/B.cpp | c33473a752ca627c103b95c0562fab6f3119443d | [] | no_license | muhammadhasan01/cp | ebb0869b94c2a2ab9487861bd15a8e62083193ef | 3b0152b9621c81190dd1a96dde0eb80bff284268 | refs/heads/master | 2023-05-30T07:18:02.094877 | 2023-05-21T22:03:57 | 2023-05-21T22:03:57 | 196,739,005 | 6 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 487 | cpp | #include<bits/stdc++.h>
using namespace std;
int n, a, b, c, t;
int ar[1005];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> a >> b >> c >> t;
for (int i = 1; i <= n; i++) {
cin >> ar[i];
}
if (c > b) {
int ans = n * a;
for (int i = 1; i <= n; i++) {
ans += (t - ar[i]) * (c - b);
}
cout << ans << '\n';
} else {
cout << n * a << '\n';
}
return 0;
}
| [
"39514247+muhammadhasan01@users.noreply.github.com"
] | 39514247+muhammadhasan01@users.noreply.github.com |
1001b395d64bc8cbc55c07b9f234962b5f14b84b | 6a53694b7b2af2bd2a1e344577e1dab4d5a87d43 | /src/Client/Graphics/GradientRect.cpp | b1ac05a4ea8545ed9fdabd61bc9c25b1c38bab2e | [
"MIT"
] | permissive | Adrthegamedev/NecroEdit | 784db1119b26fc99b3cc67b240f99e310c8bea2b | 4b2380cc3417c6578476a213e05f4cbc846e5a77 | refs/heads/master | 2023-03-16T13:41:18.062013 | 2020-08-26T06:01:41 | 2020-08-26T06:01:41 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,721 | cpp | #include "Client/Graphics/GradientRect.hpp"
GradientRect::GradientRect()
{
fill.resize(4);
fill.setPrimitiveType(sf::TrianglesStrip);
outline.setPointCount(4);
outline.setFillColor(sf::Color(0,0,0,0));
outline.setPosition(0, 0);
setDirection(Vertical);
my_skew = 0;
}
GradientRect::~GradientRect()
{
}
void GradientRect::setRect(sf::FloatRect rect)
{
setSize(rect.width, rect.height);
setPosition(rect.left, rect.top);
updateVertexPos();
}
sf::FloatRect GradientRect::getRect() const
{
return sf::FloatRect(getPosition().x, getPosition().y, my_size.x, my_size.y);
}
void GradientRect::setGradient(sf::Color a, sf::Color b, Direction dir)
{
color_a = a;
color_b = b;
direction = dir;
updateVertexColor();
}
void GradientRect::setOutline(sf::Color color, float thickness)
{
outline.setOutlineColor(color);
outline.setOutlineThickness(thickness);
}
void GradientRect::setSize(float w, float h)
{
setSize(sf::Vector2f(w,h));
}
sf::Vector2f GradientRect::getSize() const
{
return my_size;
}
void GradientRect::setSize(sf::Vector2f size)
{
my_size = size;
updateVertexPos();
}
void GradientRect::reverse()
{
const sf::Color temp = color_a;
color_a = color_b;
color_b = temp;
updateVertexColor();
}
void GradientRect::setColorA(sf::Color color)
{
color_a = color;
updateVertexColor();
}
void GradientRect::setColorB(sf::Color color)
{
color_b = color;
updateVertexColor();
}
void GradientRect::setColors(sf::Color a, sf::Color b)
{
color_a = a;
color_b = b;
updateVertexColor();
}
sf::Color GradientRect::getColorA() const
{
return color_a;
}
sf::Color GradientRect::getColorB() const
{
return color_b;
}
void GradientRect::setOutlineColor(sf::Color color)
{
outline.setOutlineColor(color);
}
void GradientRect::setOutlineThickness(float thickness)
{
outline.setOutlineThickness(thickness);
}
void GradientRect::setDirection(Direction dir)
{
direction = dir;
updateVertexColor();
}
void GradientRect::expand(float factor)
{
sf::FloatRect new_rect = getRect();
new_rect.left -= getRect().width * (factor-1);
new_rect.top -= getRect().height * (factor-1);
new_rect.width += getRect().width * (factor-1) * 2.0;
new_rect.height += getRect().height * (factor-1) * 2.0;
setRect(new_rect);
}
void GradientRect::setSkew(float skew)
{
my_skew = skew;
updateVertexPos();
}
void GradientRect::draw(sf::RenderTarget & target, sf::RenderStates states) const
{
states.transform *= getTransform();
target.draw(fill, states);
/* if (outline.getOutlineThickness() != 0) */ target.draw(outline, states);
}
void GradientRect::updateVertexPos()
{
fill[0].position = sf::Vector2f(0, 0);
fill[1].position = sf::Vector2f(my_size.x, 0);
fill[2].position = sf::Vector2f(0, my_size.y);
fill[3].position = sf::Vector2f(my_size.x, my_size.y);
if (my_skew != 0.0)
{
if (direction == Vertical)
{
fill[0].position += sf::Vector2f(my_skew, 0);
fill[1].position += sf::Vector2f(my_skew, 0);
fill[2].position -= sf::Vector2f(my_skew, 0);
fill[3].position -= sf::Vector2f(my_skew, 0);
}
else if (direction == Horizontal) {
fill[0].position += sf::Vector2f(0, my_skew);
fill[1].position -= sf::Vector2f(0, my_skew);
fill[2].position += sf::Vector2f(0, my_skew);
fill[3].position -= sf::Vector2f(0, my_skew);
}
}
outline.setPoint(0, fill[0].position);
outline.setPoint(1, fill[1].position);
outline.setPoint(2, fill[3].position);
outline.setPoint(3, fill[2].position);
}
void GradientRect::updateVertexColor()
{
fill[0].color = color_a;
fill[3].color = color_b;
if (direction == Horizontal) {
fill[1].color = color_b;
fill[2].color = color_a;
}
else if (direction == Vertical) {
fill[1].color = color_a;
fill[2].color = color_b;
}
}
| [
"defmenge@googlemail.com"
] | defmenge@googlemail.com |
beb1ffe37ba16486db28c0b12d4492341547d34b | dd8dd5cab1d4a678c412c64f30ef10f9c5d210f1 | /cpp/leetcode/744. find-smallest-letter-greater-than-target.cpp | 2ae9e8b8eebe7c6df150be55710005447eddf9a5 | [] | no_license | blacksea3/leetcode | e48a35ad7a1a1bb8dd9a98ffc1af6694c09061ee | 18f87742b64253861ca37a2fb197bb8cb656bcf2 | refs/heads/master | 2021-07-12T04:45:59.428804 | 2020-07-19T02:01:29 | 2020-07-19T02:01:29 | 184,689,901 | 6 | 2 | null | null | null | null | WINDOWS-1252 | C++ | false | false | 305 | cpp | #include "public.h"
//12ms, 91.70%
//¶þ·Ö²éÕÒ
class Solution {
public:
char nextGreatestLetter(vector<char>& letters, char target) {
vector<char>::iterator iter = upper_bound(letters.begin(), letters.end(), target);
if (iter == letters.end()) return letters[0];
else return *iter;
}
};
| [
"17865191779@163.com"
] | 17865191779@163.com |
d38f4f8b32bf51f535d839c8b74e663a4c6179cb | 8b742aa175bfb976c16302a5bf07d63a0fee5e24 | /Medium/343.cpp | 0e28a05a3cc550e2f60509ae76b04f6a54d311f2 | [] | no_license | miuhui/LeetCode | efad74058963a178921df2c825ab7739bf829d79 | ede89f75b96cb94bca7e4fa557932d711d671a3f | refs/heads/master | 2022-08-07T17:17:40.172757 | 2016-10-13T01:39:40 | 2016-10-13T01:39:40 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 489 | cpp | #include<vector>
#include<iostream>
using namespace std;
class Solution {
public:
int integerBreak(int n) {
vector<int> maxSum;
maxSum.push_back(0);
maxSum.push_back(0);
maxSum.push_back(1);
maxSum.push_back(2);
maxSum.push_back(4);
maxSum.push_back(6);
maxSum.push_back(9);
for (int i = 7; i <= n; i++) {
maxSum.push_back(maxSum[i-3]*3);
}
return maxSum[n];
}
};
int main()
{
Solution s;
cout << s.integerBreak(10);
return 0;
}
| [
"miaohui821@hotmail.com"
] | miaohui821@hotmail.com |
c99896e383e6438007b57bae003d4fad0322a6d5 | 67f8cddff0340af94beac1a316f85b8ce7b38ed3 | /catboost/cuda/models/oblivious_model.h | 26c4368fcb86ce6060b9ac7edbed960635ff285e | [
"Apache-2.0"
] | permissive | exprmntr/test2 | 963a2fcb9308e85f5b8af490e7753ae86a0c9918 | 7d7b87948918208558c59f5f528e36ceee671b75 | refs/heads/master | 2022-10-10T00:23:58.977551 | 2018-02-01T13:17:44 | 2018-02-01T13:17:44 | 116,815,397 | 0 | 2 | Apache-2.0 | 2022-10-01T12:14:49 | 2018-01-09T12:49:17 | C++ | UTF-8 | C++ | false | false | 2,493 | h | #pragma once
#include <catboost/cuda/data/feature.h>
#include <catboost/cuda/data/binarizations_manager.h>
#include <util/generic/vector.h>
namespace NCatboostCuda {
struct TObliviousTreeStructure {
TVector<TBinarySplit> Splits;
ui64 GetHash() const {
return static_cast<ui64>(TVecHash<TBinarySplit>()(Splits));
}
ui32 GetDepth() const {
return static_cast<ui32>(Splits.size());
}
ui32 LeavesCount() const {
return static_cast<ui32>(1 << GetDepth());
}
bool HasSplit(const TBinarySplit& candidate) {
for (const auto& split : Splits) {
if (split == candidate) {
return true;
}
}
return false;
}
bool operator==(const TObliviousTreeStructure& other) const {
return Splits == other.Splits;
}
bool operator!=(const TObliviousTreeStructure& other) const {
return !(*this == other);
}
Y_SAVELOAD_DEFINE(Splits);
};
class TObliviousTreeModel {
public:
TObliviousTreeModel(TObliviousTreeStructure&& modelStructure,
const TVector<float>& values)
: ModelStructure(std::move(modelStructure))
, LeafValues(values)
{
}
TObliviousTreeModel() = default;
TObliviousTreeModel(const TObliviousTreeStructure& modelStructure)
: ModelStructure(modelStructure)
, LeafValues(modelStructure.LeavesCount())
{
}
~TObliviousTreeModel() {
}
const TObliviousTreeStructure& GetStructure() const {
return ModelStructure;
}
inline void Rescale(double scale) {
for (ui32 i = 0; i < LeafValues.size(); ++i) {
LeafValues[i] *= scale;
}
}
void UpdateLeaves(TVector<float>&& newValues) {
LeafValues = std::move(newValues);
}
const TVector<float>& GetValues() const {
return LeafValues;
}
Y_SAVELOAD_DEFINE(ModelStructure, LeafValues);
private:
TObliviousTreeStructure ModelStructure;
TVector<float> LeafValues;
};
}
template <>
struct THash<NCatboostCuda::TObliviousTreeStructure> {
inline size_t operator()(const NCatboostCuda::TObliviousTreeStructure& value) const {
return value.GetHash();
}
};
| [
"exprmntr@yandex-team.ru"
] | exprmntr@yandex-team.ru |
c49c21d23af162734436369edbc661662d750f3b | 1a685a4635ab61d9caa2fd5c605745f28873720b | /src_FAZIA/FAZIASteppingAction.cc | 0d792caf036cd0f6da30ad8417fc454c0c1785da | [] | no_license | skatjsgh1030/E789 | 44436863a64e85a5d706f24958e4abd159016a91 | 388918c6b106d5971f67c8b08de7c62cd87d7563 | refs/heads/master | 2021-05-27T10:25:15.712869 | 2020-04-09T03:00:13 | 2020-04-09T03:00:13 | 254,247,575 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,350 | cc | #include "FAZIASteppingAction.hh"
#include "FAZIAEventAction.hh"
#include "G4Event.hh"
#include "G4RunManager.hh"
#include "G4SystemOfUnits.hh"
#include "G4OpticalPhoton.hh"
#include "G4Track.hh"
#include "G4Step.hh"
#include "G4ThreeVector.hh"
#include "G4EventManager.hh"
//#include "G4cvs.hh"
//#include "G4root.hh"
FAZIASteppingAction::FAZIASteppingAction()
: G4UserSteppingAction()
{
//fScintillationCounter = 0;
//fCerenkovCounter = 0;
//fEventNumber = 0;
}
FAZIASteppingAction::~FAZIASteppingAction()
{
}
void FAZIASteppingAction::UserSteppingAction(const G4Step* step)
{
G4int eventID = G4RunManager::GetRunManager() -> GetCurrentEvent() -> GetEventID();
G4int volumeID = step -> GetPreStepPoint() -> GetPhysicalVolume() -> GetCopyNo();
G4int kineticE = step -> GetPreStepPoint() -> GetKineticEnergy();
G4double edep = step -> GetTotalEnergyDeposit();
G4double x = step -> GetDeltaPosition().x();
G4double y = step -> GetDeltaPosition().y();
G4double z = step -> GetDeltaPosition().z();
//G4double moment = step -> GetDeltaMomentum();
G4AnalysisManager* analysisManager = G4AnalysisManager::Instance();
analysisManager -> FillNtupleIColumn(0, eventID);
analysisManager -> FillNtupleIColumn(1, volumeID);
analysisManager -> FillNtupleDColumn(2, edep);
analysisManager -> FillNtupleDColumn(3, x);
analysisManager -> FillNtupleDColumn(4, y);
analysisManager -> FillNtupleDColumn(5, z);
//analysisManager -> FillNtupleDColumn(6, moment);
analysisManager -> AddNtupleRow();
FAZIAEventAction *eventAction;
eventAction = (FAZIAEventAction *) G4EventManager::GetEventManager() -> GetUserEventAction();
if(step -> GetPostStepPoint() -> GetPhysicalVolume() != nullptr && step -> GetPreStepPoint() -> GetPhysicalVolume() != nullptr )
{
G4int prevolumeID = step -> GetPreStepPoint() -> GetPhysicalVolume() -> GetCopyNo();
G4int postvolumeID = step -> GetPostStepPoint() -> GetPhysicalVolume() -> GetCopyNo();
for(int volI = 0 ; volI < 593 ; volI++)
{
if (volumeID == volI)
{
eventAction -> AddEnergyDeposit(volI, edep);
}
if(prevolumeID == 0 && postvolumeID == volI)
{
eventAction -> FindPreStepKinetic(volI, kineticE);
//std::cout << "KE : volume = " << kineticE <<" : "<< volI << std::endl;
}
}
}
}
| [
"noreply@github.com"
] | noreply@github.com |
266005793d9424be41c07b50450239d4f6b94354 | a88ac615abac86882731df0b450aa272534be97b | /RapidJsonLib/dllOut.cpp | d4abb9014ab134164b0a57a8ee23343771fd1819 | [] | no_license | RustLyu/RapidJsonLib | 3fb52fc66b9cfcf3968e0d2be7b7b29a709df758 | a0bc7f69e69b079486496d2ed69ba5118a3bd754 | refs/heads/master | 2023-01-12T08:38:19.758700 | 2020-05-27T02:13:27 | 2020-05-27T02:13:27 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,662 | cpp | #include "dllOut.h"
#include "JsonOperater.h"
#include <stdarg.h>
int CreateContext(void*& ctx)
{
ctx = new JsonOperater();
return 1;
}
int DestoryContext(void * ctx)
{
delete ctx;
return 1;
}
JsonOperater* ConvertPtr(void* ctx)
{
return reinterpret_cast<JsonOperater*>(ctx);
}
void SetJsonPath(void * ctx, const char * path)
{
ConvertPtr(ctx)->setPath(path);
}
bool load(void * ctx)
{
return ConvertPtr(ctx)->loadJson();
}
extern "C" int ModifyNode_s(void* ctx, const char * v, int n, ...)
{
va_list vp;
va_start(vp, n);
int ret = ConvertPtr(ctx)->ModifyNode(v, n, vp);
va_end(vp);
return ret;
}
extern "C" int ModifyNode_i(void* ctx, const int v, int n, ...)
{
va_list vp;
va_start(vp, n);
int ret =ConvertPtr(ctx)->ModifyNode(v, n, vp);
va_end(vp);
return ret;
}
extern "C" int ModifyNode_b(void* ctx, const bool v, int n, ...)
{
va_list vp;
va_start(vp, n);
int ret = ConvertPtr(ctx)->ModifyNode(v, n, vp);
va_end(vp);
return ret;
}
extern "C" int ModifyNode_f(void* ctx, const float v, int n, ...)
{
va_list vp;
va_start(vp, n);
int ret = ConvertPtr(ctx)->ModifyNode(v, n, vp);
va_end(vp);
return ret;
}
extern "C" int RemoveNode(void * ctx, int n, ...)
{
va_list vp;
va_start(vp, n);
int ret = ConvertPtr(ctx)->RemoveNode(n, vp);
va_end(vp);
return ret;
}
extern "C" int AddNode_s(void* ctx, const char * v, int n, ...)
{
va_list vp;
va_start(vp, n);
int ret = ConvertPtr(ctx)->AddNode(v, n, vp);
va_end(vp);
return ret;
}
extern "C" int AddNode_i(void* ctx, const int v, int n, ...)
{
va_list vp;
va_start(vp, n);
int ret = ConvertPtr(ctx)->AddNode(v, n, vp);
va_end(vp);
return ret;
}
extern "C" int AddNode_b(void* ctx, const bool v, int n, ...)
{
va_list vp;
va_start(vp, n);
int ret = ConvertPtr(ctx)->AddNode(v, n, vp);
va_end(vp);
return ret;
}
extern "C" int AddNode_f(void* ctx, const float v, int n, ...)
{
va_list vp;
va_start(vp, n);
int ret = ConvertPtr(ctx)->AddNode(v, n, vp);
va_end(vp);
return ret;
}
extern "C" int GetNode_s(void* ctx, char * v, int n, ...)
{
va_list vp;
va_start(vp, n);
int ret = ConvertPtr(ctx)->GetValue(v, n, vp);
va_end(vp);
return ret;
}
extern "C" int GetNode_i(void* ctx, int & v, int n, ...)
{
va_list vp;
va_start(vp, n);
int ret = ConvertPtr(ctx)->GetValue(v, n, vp);
va_end(vp);
return ret;
}
extern "C" int GetNode_b(void* ctx, bool & v, int n, ...)
{
va_list vp;
va_start(vp, n);
int ret = ConvertPtr(ctx)->GetValue(v, n, vp);
va_end(vp);
return ret;
}
extern "C" int GetNode_f(void* ctx, float & v, int n, ...)
{
va_list vp;
va_start(vp, n);
int ret = ConvertPtr(ctx)->GetValue(v, n, vp);
va_end(vp);
return ret;
}
| [
"778324184@qq.com"
] | 778324184@qq.com |
5d0954335d29fa62b84f8212aff1831fdfbbed90 | b2e7fe2f06bf4df87c42e3d01add817710eb3861 | /frameworks/fluidservice/libs/include/messaging/SerialExecutor.h | fca7a1ef50eea38929b08c0ab1145a28e58dd320 | [] | no_license | ohsang1213/FLUID_Platform | 0e0624c679541e50b4d9817f83afd0a1dc4cab16 | 0b1c44ac491698fc637ee1d412dd2c645ef54d9d | refs/heads/master | 2022-04-11T07:05:38.884514 | 2020-03-11T01:40:02 | 2020-03-11T01:40:02 | 193,877,779 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,178 | h | /*
* Copyright (C) 2011 Daniel Himmelein
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef MESSAGING_SERIALEXECUTOR_H
#define MESSAGING_SERIALEXECUTOR_H
#include <messaging/Executor.h>
#include <messaging/LooperThread.h>
namespace android {
namespace messaging {
class Handler;
class SerialExecutor :
public Executor
{
public:
SerialExecutor();
virtual ~SerialExecutor();
virtual void execute(Runnable& runnable);
virtual bool cancel(Runnable& runnable);
private:
LooperThread<Handler> mLooperThread;
Handler* mHandler;
NO_COPY_CTOR_AND_ASSIGNMENT_OPERATOR(SerialExecutor)
};
} /* namespace messaging */
} /* namespace android */
#endif
| [
"ohsang1213@gmail.com"
] | ohsang1213@gmail.com |
4887502fe1cc3b55ea8eb55f45fba24d3b6f99f5 | a79cd48394f53428ff749a32d2f70b355c8af71a | /fibonacci/slow.cpp | 2caffffa34436230a72e3c350d3930503c7640ef | [] | no_license | Nicetiesniceties/Algorithm-Design-and-Analysis | a9678414e4f3ee4e83fa83a958c85236ebbc8e77 | 605e6613fc58fc6d1f3d0900a7dae70d83c1ea8a | refs/heads/master | 2020-03-21T05:09:56.691573 | 2018-06-21T09:10:15 | 2018-06-21T09:10:15 | 138,146,934 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 446 | cpp | #include<iostream>
using namespace std;
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(0);
unsigned long long a, b, n, temp, testcase;
cin >> testcase;
while(testcase--)
{
cin >> a >> b >> n;
if(n <= 2)
{
if(n == 1)cout << a << "\n";
if(n == 2)cout << b << "\n";
}
else
{
for(int i = 3; i <= n; i++)
{
temp = b;
b = (a + b) % 1000000007;
a = temp;
}
cout << b << "\n";
}
}
return 0;
}
| [
"Njceties@NjcetiesdeMacBook-Air.local"
] | Njceties@NjcetiesdeMacBook-Air.local |
3dd2d4f0821995d9d1c79160ff82b26a6e095581 | 91d4f2f7e1ff36706b1188534abed3c62b3fab45 | /camera_slam/slam14/lesson3/useSophus/useSophus.cpp | 25a9bff9aa47dddb3c8cb7a735699a7a11731f7d | [] | no_license | Qiyd81/shenlan | 590778b78bf697bbbbeebb4684226b763a46899b | 8e49d572caa603f5aadca4857abd50f1081693b8 | refs/heads/master | 2022-11-16T15:08:13.650547 | 2020-07-09T06:44:22 | 2020-07-09T06:44:25 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,690 | cpp | #include <iostream>
#include <cmath>
using namespace std;
#include <Eigen/Core>
#include <Eigen/Geometry>
#include "sophus/so3.h"
#include "sophus/se3.h"
int main( int argc, char** argv )
{
// 沿着Z轴旋转90度的旋转矩阵
Eigen::AngleAxisd Ax( M_PI/2, Eigen::Vector3d(0, 0, 1) );
Eigen::Matrix3d R = Ax.matrix();
Sophus::SO3 SO3_R(R); // Sophus::SO(3)可以直接从旋转矩阵构造
Sophus::SO3 SO3_v(0, 0, M_PI/2); // 可以从旋转向量构造
Sophus::SO3 SO3_v3((Ax.axis()*Ax.angle())(0), (Ax.axis()*Ax.angle())(1),(Ax.axis()*Ax.angle())(2));
Eigen::Vector3d v1(0, 0, M_PI/2);
Sophus::SO3 SO3_v2 = Sophus::SO3::exp(v1);
Eigen::Quaterniond q(R);
Sophus::SO3 SO3_q( q ); // 可以从四元数构造
// 上述等式等价
// 输出SO(3)时，以so(3)形式输出
cout << "SO(3) from matrix: \n" << SO3_R.matrix() << endl;
//cout << "SO(3) from vector: " << SO3_v << endl;
//cout << "SO(3) from quaternion: " << SO3_q << endl;
// 使用对数映射获得它的李代数
Eigen::Vector3d so3 = SO3_R.log();
cout << "so3 = " << so3.transpose() << endl;
// 使用指数映射获得它的李代数
Sophus::SO3 SO3_final= Sophus::SO3::exp(so3);
// hat()得到反对称矩阵
Eigen::Matrix3d so3_hat = Sophus::SO3::hat(so3);
Eigen::Vector3d so3_hat_vee = Sophus::SO3::vee(Sophus::SO3::hat(so3));
cout << endl << Sophus::SO3::exp(so3_hat_vee);
//增量模型的更新
Eigen::Vector3d update_so3(1e-4, 0, 0);
Eigen::Matrix3d updated_matrix = (Sophus::SO3::exp(update_so3)*SO3_R).matrix();
Sophus::SO3 SO3_updated = Sophus::SO3::exp(update_so3) * SO3_R;
cout << "SO3 updated: \n" << SO3_updated << endl;
cout << "SO3 updated: \n" << SO3_updated.matrix() << endl;
/**********************************************************************/
cout << "/*************************************************************/" << endl;
// 对SE(3)进行操作
Eigen::Vector3d t(1, 0, 0);
Sophus::SE3 SE3_Rt(R, t);
Sophus::SE3 SE3_qt(q, t);
Sophus::SE3 SE3_t(SO3_R, t);
cout << "SE3 from R,t = \n" << SE3_Rt << endl;
cout << "SE3 from q,t = \n" << SE3_qt << endl;
Eigen::Matrix<double, 6, 1> se3 = SE3_Rt.log();
cout << "se3 = \n" << se3 << endl;
cout << "se3 hat = \n" << Sophus::SE3::hat(se3) << endl;
cout << "se3 hat vee = \n" << Sophus::SE3::vee( Sophus::SE3::hat(se3) ) << endl;
Eigen::Matrix<double, 6, 1> update_se3;
update_se3.setZero();
update_se3(0, 0) = 1e-4;
Sophus::SE3 SE3_updated = Sophus::SE3::exp(update_se3)*SE3_Rt;
cout << "SE3 updated = " << endl << SE3_updated.matrix() << endl;
}
| [
"wuhuanyu@outlook.com"
] | wuhuanyu@outlook.com |
343338b7f21c5bf8d2112002bfe6eb2e3dbadeb4 | 7953fae2d2e2fdbe3a0d35f7cbac8cb094e96a23 | /build/moc_clientmodel.cpp | f480ef6d8b7755180f398f4619efe3f6d37555ba | [
"MIT"
] | permissive | gustav1976/Gridcoin-master | 56f3665f1d09d35af89cdc05798b7252287da9c3 | 1223875d0c9e6e6eb2954fb0b5152214af107940 | refs/heads/master | 2020-04-05T23:23:34.951002 | 2014-03-17T13:59:37 | 2014-03-17T13:59:37 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 5,050 | cpp | /****************************************************************************
** Meta object code from reading C++ file 'clientmodel.h'
**
** Created: Fri Dec 27 12:49:06 2013
** by: The Qt Meta Object Compiler version 63 (Qt 4.8.4)
**
** WARNING! All changes made in this file will be lost!
*****************************************************************************/
#include "../src/qt/clientmodel.h"
#if !defined(Q_MOC_OUTPUT_REVISION)
#error "The header file 'clientmodel.h' doesn't include <QObject>."
#elif Q_MOC_OUTPUT_REVISION != 63
#error "This file was generated using the moc from 4.8.4. It"
#error "cannot be used with the include files from this version of Qt."
#error "(The moc has changed too much.)"
#endif
QT_BEGIN_MOC_NAMESPACE
static const uint qt_meta_data_ClientModel[] = {
// content:
6, // revision
0, // classname
0, 0, // classinfo
7, 14, // methods
0, 0, // properties
0, 0, // enums/sets
0, 0, // constructors
0, // flags
4, // signalCount
// signals: signature, parameters, type, tag, flags
19, 13, 12, 12, 0x05,
65, 46, 12, 12, 0x05,
100, 91, 12, 12, 0x05,
143, 123, 12, 12, 0x05,
// slots: signature, parameters, type, tag, flags
173, 12, 12, 12, 0x0a,
202, 187, 12, 12, 0x0a,
240, 228, 12, 12, 0x0a,
0 // eod
};
static const char qt_meta_stringdata_ClientModel[] = {
"ClientModel\0\0count\0numConnectionsChanged(int)\0"
"count,countOfPeers\0numBlocksChanged(int,int)\0"
"warnings\0alertsChanged(QString)\0"
"title,message,style\0message(QString,QString,uint)\0"
"updateTimer()\0numConnections\0"
"updateNumConnections(int)\0hash,status\0"
"updateAlert(QString,int)\0"
};
void ClientModel::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
if (_c == QMetaObject::InvokeMetaMethod) {
Q_ASSERT(staticMetaObject.cast(_o));
ClientModel *_t = static_cast<ClientModel *>(_o);
switch (_id) {
case 0: _t->numConnectionsChanged((*reinterpret_cast< int(*)>(_a[1]))); break;
case 1: _t->numBlocksChanged((*reinterpret_cast< int(*)>(_a[1])),(*reinterpret_cast< int(*)>(_a[2]))); break;
case 2: _t->alertsChanged((*reinterpret_cast< const QString(*)>(_a[1]))); break;
case 3: _t->message((*reinterpret_cast< const QString(*)>(_a[1])),(*reinterpret_cast< const QString(*)>(_a[2])),(*reinterpret_cast< uint(*)>(_a[3]))); break;
case 4: _t->updateTimer(); break;
case 5: _t->updateNumConnections((*reinterpret_cast< int(*)>(_a[1]))); break;
case 6: _t->updateAlert((*reinterpret_cast< const QString(*)>(_a[1])),(*reinterpret_cast< int(*)>(_a[2]))); break;
default: ;
}
}
}
const QMetaObjectExtraData ClientModel::staticMetaObjectExtraData = {
0, qt_static_metacall
};
const QMetaObject ClientModel::staticMetaObject = {
{ &QObject::staticMetaObject, qt_meta_stringdata_ClientModel,
qt_meta_data_ClientModel, &staticMetaObjectExtraData }
};
#ifdef Q_NO_DATA_RELOCATION
const QMetaObject &ClientModel::getStaticMetaObject() { return staticMetaObject; }
#endif //Q_NO_DATA_RELOCATION
const QMetaObject *ClientModel::metaObject() const
{
return QObject::d_ptr->metaObject ? QObject::d_ptr->metaObject : &staticMetaObject;
}
void *ClientModel::qt_metacast(const char *_clname)
{
if (!_clname) return 0;
if (!strcmp(_clname, qt_meta_stringdata_ClientModel))
return static_cast<void*>(const_cast< ClientModel*>(this));
return QObject::qt_metacast(_clname);
}
int ClientModel::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QObject::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
if (_c == QMetaObject::InvokeMetaMethod) {
if (_id < 7)
qt_static_metacall(this, _c, _id, _a);
_id -= 7;
}
return _id;
}
// SIGNAL 0
void ClientModel::numConnectionsChanged(int _t1)
{
void *_a[] = { 0, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
QMetaObject::activate(this, &staticMetaObject, 0, _a);
}
// SIGNAL 1
void ClientModel::numBlocksChanged(int _t1, int _t2)
{
void *_a[] = { 0, const_cast<void*>(reinterpret_cast<const void*>(&_t1)), const_cast<void*>(reinterpret_cast<const void*>(&_t2)) };
QMetaObject::activate(this, &staticMetaObject, 1, _a);
}
// SIGNAL 2
void ClientModel::alertsChanged(const QString & _t1)
{
void *_a[] = { 0, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
QMetaObject::activate(this, &staticMetaObject, 2, _a);
}
// SIGNAL 3
void ClientModel::message(const QString & _t1, const QString & _t2, unsigned int _t3)
{
void *_a[] = { 0, const_cast<void*>(reinterpret_cast<const void*>(&_t1)), const_cast<void*>(reinterpret_cast<const void*>(&_t2)), const_cast<void*>(reinterpret_cast<const void*>(&_t3)) };
QMetaObject::activate(this, &staticMetaObject, 3, _a);
}
QT_END_MOC_NAMESPACE
| [
"contact@gridcoin.us"
] | contact@gridcoin.us |
ccaff0b20c0b9be16091dcf27915964bd14e8648 | acb29e5ca1a28f1a0510d6ea7e299fe684ba9ea9 | /SampleGame/LegendOfZelda/Code/itemNPC/ITEM/shields.h | 9b3ce168e80d73121b082e5ea6b24e9a8b7a5c6d | [] | no_license | ZTZEROS/Portfolio | 579aced98885803e1f7d158ecde6db64c4115cff | c65d4d375cdfa7a746d83a81dfa27006e8240ea0 | refs/heads/main | 2023-03-28T11:39:55.575872 | 2021-04-02T00:00:03 | 2021-04-02T00:00:03 | 347,345,688 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 140 | h | #pragma once
#include "items.h"
class shields : public items
{
public:
HRESULT shields::init(int x, int y);
shields();
~shields();
};
| [
"zt00000@naver.com"
] | zt00000@naver.com |
f2686f6c7e9fb9f0254853210bae99a6f464663a | ffc8a74313436a7982ddefdd50a9308219cedee3 | /DevC/16..cpp | 5e327ee90c97dd8973849068b262098b53a6b80e | [] | no_license | hieubui97/DevC | 659dff5428cb52d5740948e44cfdde0dcb37ed42 | cf058e0473bc5d752c853334a84c3738bef65bea | refs/heads/master | 2023-02-08T13:18:01.193367 | 2020-10-05T04:27:52 | 2020-10-05T04:27:52 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 189 | cpp | #include<stdio.h>
main()
{
int n ;
printf("nhap n :\n n = ");scanf("%d",&n) ;
int i;
for(i=1;i<=n;i++){
int j;
for(j=1;j<=n;j++)
printf("%-10d",(i-1)*n+j);
printf("\n");
}
}
| [
"hieubuim012@gmail.com"
] | hieubuim012@gmail.com |
8c5a49aa2b967a3be0c84a3a082692b0a2f527f7 | e0561a3078e38a4758587bf6b76b76041a371899 | /qtavplayer/src/imageprovider.h | ef6ba41db81f863a4da6dc15478b4273179b03cb | [] | no_license | Myweik/Myffmpeg | defe2cc9dd4b847d60e32ce912a3fc21afde2780 | 576ebb8e16176c3188de5e20f4d231ba9c784f11 | refs/heads/master | 2020-04-22T03:10:07.381888 | 2019-02-13T02:32:35 | 2019-02-13T02:32:35 | 170,076,083 | 2 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 707 | h | #ifndef IMAGEPROVIDER_H
#define IMAGEPROVIDER_H
#include <QQuickImageProvider>
#include<QImage>
#include<QTcpSocket>
#include <QTcpServer>
#include<QBuffer>
class ImageProvider : public QQuickImageProvider
{
public:
ImageProvider();
QImage requestImage(const QString &id, QSize *size, const QSize &requestedSize);
QPixmap requestPixmap(const QString &id, QSize *size, const QSize &requestedSize);
QImage img;
};
class ShowImage : public QObject
{
Q_OBJECT
public:
explicit ShowImage(QObject *parent = 0);
ImageProvider *m_pImgProvider;
public slots:
void sendimage(QImage);
signals:
void callQmlRefeshImg();
void sendPic(QImage image);
};
#endif // IMAGEPROVIDER_H
| [
"695926067@qq.com"
] | 695926067@qq.com |
3097bb24a270af968366d0940f6b70e1751ce69d | 0674e81a160161996251fb4b063c801330ccd1e2 | /tokilearning/Latihan/floorandceiling.cpp | 2d87f34aaf80a920fbfc76ea6cc35555fb33793b | [] | no_license | joshuabezaleel/cp | 8a2c9b44605810da4367efeb981f822ae5e1e9a2 | 57f365458cca38c3c0fb1f5af1c6b44b74f3b53e | refs/heads/master | 2022-07-19T00:39:34.395495 | 2020-05-23T20:37:20 | 2020-05-23T20:37:20 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 198 | cpp | #include <iostream>
#include <math.h>
using namespace std;
double n;
int main(){
cin >> n;
cout << floor(n) << " " << ceil(n) << endl;
//system("pause");
return 0;
}
| [
"ahmadzaky003@gmail.com"
] | ahmadzaky003@gmail.com |
715d520c22080b885b42faaed53921f7c3a1b8a8 | 11a09372cf812213ee88a5059e9f868f97faf309 | /Snackdown/Pre/snakdown2.cpp | a136b2c84ae451532de16370d806e4602f0964a2 | [] | no_license | RavirajWalke/online-contests | 52a755ae064caa9e70d0c847a64f2e9869090073 | bb61acd82ba852fdc2f8700ea27002a1a0215805 | refs/heads/master | 2020-03-14T02:58:02.353799 | 2018-04-28T13:13:23 | 2018-04-28T13:13:23 | 131,410,196 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 486 | cpp | /**
*
* @author Ravi
*/
#include<iostream>
#include<cmath>
using namespace std;
int main()
{
int T,te,n,a,b,l,i,j,min=1000000001,mini;
cin>>T;
for(te=0;te<T;te++)
{
cin>>n>>l>>a>>b;
int s[n];
for(i=0;i<n;i++)
{
cin>>s[i];
if(abs(a-s[i])<min)
{
min=abs(a-s[i]);
mini=i;
}
}
//cout<<mini;
}
return 0;
}
| [
"ravirajwalke9@gmail.com"
] | ravirajwalke9@gmail.com |
d06e012c6692095b0037d88275afa27dc01525b5 | 3427fd76cb364cdd9d5eadc04e98f7e93069ae81 | /src/interface/interface.cc | ad422c860faf4b24ba720b14d0c037e52524b447 | [] | no_license | Xianbo-X/Project3_CampusCardControl | e822ef501d1a2119f4afee082be3f9d087ef49a2 | b2b2ae311328e12343a0c4f5a5f851f95b991e22 | refs/heads/master | 2022-01-26T23:06:46.947885 | 2019-06-05T09:33:14 | 2019-06-05T09:33:14 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 23,656 | cc | #include "interface.h"
#include <limits.h>
#include <iostream>
#include "log_it.h"
namespace ui {
Interface* Interface::userInterface = NULL;
Interface::Interface(cardSystem::card_storage* _cardCore,
logit::LogIt* _logCore)
: cardCore{_cardCore}, logCore{_logCore}, selected{NULL} {}
Interface* Interface::InitInterface(cardSystem::card_storage* _cardCore,
logit::LogIt* _logCore) {
if (userInterface == NULL) userInterface = new Interface{_cardCore, _logCore};
return userInterface;
}
Interface::~Interface() {
foundedList.clear();
logCore = NULL;
selected = NULL;
}
int Interface::GetOpt() const { return opt; }
bool Interface::SetOpt(int _opt) {
opt = _opt;
return true;
}
bool Interface::Dispatch() {
bool exitFlag = false;
MenuType runMenu;
while (true) {
switch (GetOpt()) {
case EXIT:
exitFlag = true;
break;
case MAIN_MENU:
runMenu.MenuInfo = &Interface::MainMenuInfo;
runMenu.MenuAction = &Interface::MainMenu;
break;
case HOLDER_MENU:
runMenu.MenuInfo = &Interface::HolderMenuInfo;
runMenu.MenuAction = &Interface::HolderMenu;
break;
case ACCOUNT_MENU:
runMenu.MenuInfo = &Interface::AccountMainMenuInfo;
runMenu.MenuAction = &Interface::AccountMainMenu;
break;
}
if (exitFlag) break;
SetOpt(Guard(runMenu));
}
return true;
}
Interface::Menus Interface::Guard(MenuType& currentMenu) {
system("reset");
StatusBar();
std::string userMessage;
(this->*currentMenu.MenuInfo)();
// std::getline(std::cin, userMessage);
std::cout << "输入Exit 以退出程序" << std::endl;
std::cin >> userMessage;
if (userMessage == "Exit") return EXIT;
return (this->*currentMenu.MenuAction)(userMessage);
}
void Interface::MainMenuInfo() {
std::cout << " 请选择所需的服务" << std::endl;
std::cout << "[1]\t 管理全部持卡人信息" << std::endl;
std::cout << "[2]\t 管理个人账户" << std::endl;
std::cout << "[0]\t 退出" << std::endl;
std::cout << std::endl;
}
Interface::Menus Interface::MainMenu(std::string message) {
int option = MAIN_MENU;
if (!general::str2num(message, option) || option > DEPOSIT_MENU ||
option < EXIT) {
std::cout << "无效输入" << std::endl;
return MAIN_MENU;
}
switch (option) {
case 1:
return HOLDER_MENU;
case 2:
return ACCOUNT_MENU;
case 0:
return EXIT;
}
return MAIN_MENU;
}
void Interface::HolderMenuInfo() {
std::cout << "请选择所需的服务" << std::endl;
std::cout << "[1]\t 显示 全部持卡人信息" << std::endl;
std::cout << "[2]\t 查询/选择 持卡人信息" << std::endl;
std::cout << "[3]\t 添加 持卡人信息" << std::endl;
std::cout << "[4]\t 修改 持卡人信息" << std::endl;
std::cout << "[5]\t 注销 持卡人信息" << std::endl;
std::cout << "[0]\t 返回上级菜单" << std::endl;
}
Interface::Menus Interface::HolderMenu(std::string message) {
int option;
if (!general::str2num(message, option) || option > 6 || option < 0) {
std::cout << "无效输入" << std::endl;
return HOLDER_MENU;
}
switch (option) {
case 0:
return MAIN_MENU;
case 1:
cardCore->PrintAll("OneLine");
general::Pause();
break;
case 2:
LookUp();
selected = (foundedList.empty()) ? NULL : *(foundedList.begin());
Print(foundedList);
general::Pause();
break;
case 3:
Add();
break;
case 4:
Modify();
break;
case 5:
Delete();
break;
case 6:
return MAIN_MENU;
}
return HOLDER_MENU;
}
void Interface::AccountMainMenuInfo() {
while (selected == NULL) {
if (!ChooseAccount()) return;
}
std::cout << "请选择所需的服务" << std::endl;
std::cout << "[1]\t 校园卡业务" << std::endl;
std::cout << "[2]\t 储蓄卡业务" << std::endl;
std::cout << "[3]\t 更换账户" << std::endl;
std::cout << "[0]\t 返回上级菜单" << std::endl;
}
Interface::Menus Interface::AccountMainMenu(std::string message) {
int option;
if (!general::str2num(message, option) || option > 3 || option < 0) {
std::cout << "无效输入" << std::endl;
return MAIN_MENU;
}
switch (option) {
case 0:
return MAIN_MENU;
case 1:
system("reset");
StatusBar();
CampusAccount();
break;
case 2:
system("reset");
StatusBar();
DepositAccount();
break;
case 3:
selected = NULL;
break;
}
return ACCOUNT_MENU;
}
void Interface::CampusAccount() {
if (!selected->IsCampusCard()) {
std::cout << "不存在" << std::endl;
general::Pause();
return;
}
std::cout << "请选择所需的服务" << std::endl;
std::cout << "[1]\t 存款" << std::endl;
std::cout << "[2]\t 取款" << std::endl;
std::cout << "[3]\t 绑定账户转入" << std::endl;
std::cout << "[4]\t 查询记录" << std::endl;
std::cout << "[0]\t 返回上级菜单" << std::endl;
std::string message;
std::cin >> message;
int option;
while (!general::str2num(message, option)) {
std::cout << "输入有误,请重试" << std::endl;
std::cin >> message;
}
card::MoneyType amount;
switch (option) {
case 1:
std::cout << "请输入金额" << std::endl;
std::cin >> message;
while (!general::str2num(message, amount)) {
std::cout << "输入有误,请重试" << std::endl;
std::cin >> message;
}
if (!cardCore->Deposit(amount, *selected, card::CAMPUS_CARD))
std::cout << "操作失败" << std::endl;
{
std::cout << "操作成功" << std::endl;
logCore->InnerAccount(card::Campus_Card{*selected}, "存款", amount);
}
break;
case 2:
std::cout << "请输入金额" << std::endl;
std::cin >> message;
while (!general::str2num(message, amount)) {
std::cout << "输入有误,请重试" << std::endl;
std::cin >> message;
}
if (!cardCore->Withdraw(amount, *selected, card::DEPOSIT_CARD))
std::cout << "操作失败" << std::endl;
{
std::cout << "操作成功" << std::endl;
logCore->InnerAccount(card::Campus_Card{*selected}, "取款", amount);
}
break;
case 3:
std::cout << "请输入金额" << std::endl;
std::cin >> message;
while (!general::str2num(message, amount)) {
std::cout << "输入有误,请重试" << std::endl;
std::cin >> message;
}
if (!cardCore->InternalTransfer(amount, selected, card::DEPOSIT_CARD,
card::CAMPUS_CARD))
std::cout << "操作失败" << std::endl;
{
std::cout << "操作成功" << std::endl;
logCore->InnerAccount(card::Campus_Card{*selected}, "个人名下转账",
amount);
}
break;
case 4:
if (!logCore->GetUserLog(card::Campus_Card{*selected}, card::CAMPUS_CARD))
std::cout << "无日志" << std::endl;
else
general::Pause();
break;
case 0:
return;
}
}
void Interface::DepositAccount() {
if (!selected->IsDepositCard()) {
std::cout << "不存在" << std::endl;
general::Pause();
return;
}
std::cout << "请选择所需的服务" << std::endl;
std::cout << "[1]\t 存款" << std::endl;
std::cout << "[2]\t 取款" << std::endl;
std::cout << "[3]\t 转账" << std::endl;
std::cout << "[4]\t 查询记录" << std::endl;
std::cout << "[0]\t 返回上级菜单" << std::endl;
std::string message;
std::cin >> message;
int option;
while (!general::str2num(message, option)) {
std::cout << "输入有误,请重试" << std::endl;
std::cin >> message;
}
card::MoneyType amount;
int target_account;
switch (option) {
case 1:
std::cout << "请输入金额" << std::endl;
std::cin >> message;
while (!general::str2num(message, amount)) {
std::cout << "输入有误,请重试" << std::endl;
std::cin >> message;
}
if (!cardCore->Deposit(amount, *selected, card::DEPOSIT_CARD)) {
std::cout << "操作失败" << std::endl;
general::Pause();
} else {
std::cout << "操作成功" << std::endl;
logCore->InnerAccount(card::Deposit_Card{*selected}, "存款", amount);
}
break;
case 2:
std::cout << "请输入金额" << std::endl;
std::cin >> message;
while (!general::str2num(message, amount)) {
std::cout << "输入有误,请重试" << std::endl;
std::cin >> message;
}
if (!cardCore->Withdraw(amount, *selected, card::DEPOSIT_CARD)) {
std::cout << "操作失败" << std::endl;
general::Pause();
} else {
std::cout << "操作成功" << std::endl;
logCore->InnerAccount(card::Deposit_Card{*selected}, "取款", amount);
}
break;
case 3:
std::cout << "请输入金额" << std::endl;
std::cin >> message;
while (!general::str2num(message, amount)) {
std::cout << "输入有误,请重试" << std::endl;
std::cin >> message;
};
std::cout << "请输入目标账户" << std::endl;
std::cin >> message;
while (!general::str2num(message, target_account)) {
std::cout << "输入有误,请重试" << std::endl;
std::cin >> message;
}
if (!cardCore->ExternalTransfer(amount, selected,
cardCore->FindCard(target_account))) {
std::cout << "转账失败,请确认输入" << std::endl;
general::Pause();
} else {
std::cout << "操作成功" << std::endl;
logCore->ExternalAccount(
card::Deposit_Card{*selected},
card::Deposit_Card{*(cardCore->FindCard(target_account))}, "转出",
amount);
logCore->ExternalAccount(
card::Deposit_Card{*(cardCore->FindCard(target_account))},
card::Deposit_Card{*selected}, "收入", amount);
}
break;
case 4:
if (!logCore->GetUserLog(card::Deposit_Card{*selected},
card::DEPOSIT_CARD))
std::cout << "无日志" << std::endl;
else
general::Pause();
break;
case 0:
return;
}
}
void Interface::StatusBar() const {
std::cout << "欢迎使用校园卡管理系统--version 0.1.0" << std::endl;
std::cout << "当前选择账户: ";
if (selected == NULL)
std::cout << "当前无选择账户" << std::endl;
else {
std::cout << selected->GetIdentifier() << " " << selected->GetName()
<< std::endl;
if (selected->IsCampusCard())
std::cout << "校园卡余额\t" << selected->Campus_Card::GetBalance()
<< std::endl;
if (selected->IsDepositCard())
std::cout << "储蓄卡余额\t" << selected->Deposit_Card::GetBalance()
<< std::endl;
}
std::cout << "===========================================" << std::endl;
}
void Interface::LookUp() {
foundedList.clear();
std::cout << "请输入查询/选择用户名或标识符" << std::endl;
std::string message;
int _identifier;
// getline(std::cin, message);
std::cin >> message;
card::Binding_Card* holder = NULL;
if (general::str2num(message, _identifier)) {
holder = cardCore->FindCard(_identifier);
if (holder != NULL)
foundedList.push_back(holder);
else
std::cout << "未找到用户，请确认输入" << std::endl;
return;
}
foundedList = cardCore->FindCard(message);
return;
}
void Interface::Add() {
std::cout << "请选择办卡类型" << std::endl;
std::cout << "[1] 储蓄卡" << std::endl;
std::cout << "[2] 校园卡" << std::endl;
std::cout << "[3]同时办理并绑定" << std::endl;
std::string message;
std::cin >> message;
int option;
while (!general::str2num(message, option)) {
std::cout << "输入有误,请重试" << std::endl;
std::cin >> message;
}
int identifier;
std::string name;
ui::ReadInIdentifier(std::cin, identifier);
ui::ReadInName(std::cin, name);
if (option == 1 || option == 3) {
AddDepositCard(identifier, name);
}
if (option == 2 || option == 3) {
AddCampusCard(identifier, name);
}
if (option == 3) {
cardCore->BindingCard(identifier);
}
}
void Interface::AddCampusCard(int identifier, std::string name) {
std::string passwd;
std::string department;
std::string studentId;
card::MoneyType balance;
card::Campus_Card campusCard{};
std::cout << "Campus_Card" << std::endl;
ui::ReadInStudentId(std::cin, studentId);
ui::ReadInDepartment(std::cin, department);
ui::ReadInPasswd(std::cin, passwd);
ui::ReadInBalance(std::cin, balance);
campusCard.SetIdentifier(identifier);
campusCard.SetName(name);
campusCard.SetPasswd(passwd);
campusCard.SetStudentId(studentId);
campusCard.SetDepartment(department);
campusCard.SetBalance(balance);
cardCore->AddCampusCard(campusCard);
logCore->NewCard(campusCard);
}
void Interface::AddDepositCard(int identifier, std::string name) {
std::string passwd;
std::string cardCode;
card::MoneyType balance;
card::MoneyType overdraft;
card::Deposit_Card depositCard{};
std::cout << "Deposit_Card" << std::endl;
ui::ReadInCardCode(std::cin, cardCode);
ui::ReadInOverdraft(std::cin, overdraft);
ui::ReadInPasswd(std::cin, passwd);
ui::ReadInBalance(std::cin, balance);
depositCard.SetIdentifier(identifier);
depositCard.SetName(name);
depositCard.SetPasswd(passwd);
depositCard.SetCardCode(cardCode);
depositCard.SetBalance(balance);
depositCard.SetOverdraft(overdraft);
cardCore->AddDepositCard(depositCard);
logCore->NewCard(depositCard);
}
bool Interface::ChooseAccount() {
std::cout << "请选择账户" << std::endl;
std::cout << "[1] 显示全部账户" << std::endl;
std::cout << "[2] 选择账户" << std::endl;
std::cout << "[0] 返回上级菜单" << std::endl;
int option;
std::string message;
std::cin >> message;
while (!general::str2num(message, option)) {
std::cout << "输入有误,请重试" << std::endl;
std::cin >> message;
}
if (option == 0) return false;
if (option == 1) {
cardCore->PrintAll();
}
if (option == 2) {
LookUp();
selected = (foundedList.empty()) ? NULL : *(foundedList.begin());
}
return true;
}
void Interface::Modify() {
bool exitFlag = false;
while (selected == NULL) {
if (!ChooseAccount()) return;
}
while (!exitFlag) {
system("reset");
StatusBar();
std::cout << "请选择需要修改的卡片类型" << std::endl;
std::cout << "[1] 修改基本信息" << std::endl;
std::cout << "[2] 修改校园卡信息" << std::endl;
std::cout << "[3] 修改储蓄卡信息" << std::endl;
std::cout << "[4] 更改选择账户" << std::endl;
std::cout << "[0] 返回上级菜单" << std::endl;
int option;
std::string message;
std::cin >> message;
while (!general::str2num(message, option)) {
std::cout << "输入有误,请重试" << std::endl;
std::cin >> message;
}
switch (option) {
case 1:
ModifyBasic();
break;
case 2:
ModifyCampus();
break;
case 3:
ModifyDeposit();
break;
case 4:
ChooseAccount();
break;
case 0:
exitFlag = true;
default:
std::cout << "无效输入" << std::endl;
}
}
return;
}
void Interface::ModifyBasic() {
bool exitFlag = false;
while (!exitFlag) {
system("reset");
StatusBar();
Print(std::vector<card::Binding_Card*>{selected});
std::cout << "请选择需要修改的信息" << std::endl;
std::cout << "[1] 修改姓名" << std::endl;
std::cout << "[2] 修改密码" << std::endl;
std::cout << "[0] 返回上级菜单" << std::endl;
int option;
std::string message;
std::cin >> message;
while (!general::str2num(message, option)) {
std::cout << "输入有误,请重试" << std::endl;
std::cin >> message;
}
std::string name;
std::string passwd;
card::MoneyType amount;
switch (option) {
case 1:
ui::ReadInName(std::cin, name);
selected->Campus_Card::SetName(name);
selected->Deposit_Card::SetName(name);
break;
case 2:
ui::ReadInPasswd(std::cin, passwd);
selected->Campus_Card::SetPasswd(passwd);
selected->Deposit_Card::SetPasswd(passwd);
break;
case 0:
exitFlag = true;
break;
}
}
}
void Interface::ModifyCampus() {
if (!selected->IsCampusCard()) {
std::cout << "不存在" << std::endl;
general::Pause();
return;
}
bool exitFlag = false;
while (!exitFlag) {
system("reset");
StatusBar();
Print(std::vector<card::Binding_Card*>{selected});
std::cout << "请选择需要修改的信息" << std::endl;
std::cout << "[1] 修改学号" << std::endl;
std::cout << "[2] 修改学院" << std::endl;
std::cout << "[3] 修改余额" << std::endl;
std::cout << "[0] 返回上级菜单" << std::endl;
int option;
std::string message;
std::cin >> message;
while (!general::str2num(message, option)) {
std::cout << "输入有误,请重试" << std::endl;
std::cin >> message;
}
std::string studentId;
std::string department;
card::MoneyType amount;
switch (option) {
case 1:
ui::ReadInStudentId(std::cin, studentId);
selected->Campus_Card::SetStudentId(studentId);
break;
case 2:
ui::ReadInDepartment(std::cin, department);
selected->Campus_Card::SetDepartment(department);
break;
case 3:
ui::ReadInBalance(std::cin, amount);
selected->Campus_Card::SetBalance(amount);
break;
case 0:
exitFlag = true;
break;
}
}
}
void Interface::ModifyDeposit() {
if (!selected->IsDepositCard()) {
std::cout << "不存在" << std::endl;
general::Pause();
return;
}
bool exitFlag = false;
while (!exitFlag) {
system("reset");
StatusBar();
Print(std::vector<card::Binding_Card*>{selected});
std::cout << "请选择需要修改的信息" << std::endl;
std::cout << "[1] 修改卡号" << std::endl;
std::cout << "[2] 修改余额" << std::endl;
std::cout << "[3] 修改透支上限" << std::endl;
std::cout << "[0] 返回上级菜单" << std::endl;
int option;
std::string message;
std::cin >> message;
while (!general::str2num(message, option)) {
std::cout << "输入有误,请重试" << std::endl;
std::cin >> message;
}
std::string cardCode;
card::MoneyType amount;
switch (option) {
case 1:
ui::ReadInCardCode(std::cin, cardCode);
selected->Deposit_Card::SetCardCode(cardCode);
break;
case 2:
ui::ReadInBalance(std::cin, amount);
selected->Deposit_Card::SetBalance(amount);
break;
case 3:
ui::ReadInOverdraft(std::cin, amount);
selected->Deposit_Card::SetOverdraft(amount);
break;
case 0:
exitFlag = true;
break;
}
}
}
void Interface::Delete() {
bool exitFlag = false;
while (selected == NULL) {
if (!ChooseAccount()) return;
}
while (!exitFlag) {
system("reset");
StatusBar();
std::cout << "请选择需要删除的卡片类型" << std::endl;
std::cout << "[1] 删除该账户" << std::endl;
std::cout << "[2] 删除校园卡信息" << std::endl;
std::cout << "[3] 删除储蓄卡信息" << std::endl;
std::cout << "[4] 更改选择账户" << std::endl;
std::cout << "[0] 返回上级菜单" << std::endl;
int option;
std::string message;
std::cin >> message;
while (!general::str2num(message, option)) {
std::cout << "输入有误,请重试" << std::endl;
std::cin >> message;
}
switch (option) {
case 1: {
card::Campus_Card temp = *cardCore->FindCard(selected->GetIdentifier());
logCore->DeleteCard(temp);
cardCore->DeleteCard(selected->GetIdentifier());
selected = NULL;
exitFlag = true;
break;
}
case 2: {
card::Campus_Card temp = *cardCore->FindCard(selected->GetIdentifier());
logCore->DeleteCard(temp);
cardCore->DeleteCampusCard(selected->GetIdentifier());
break;
}
case 3: {
card::Deposit_Card temp =
*cardCore->FindCard(selected->GetIdentifier());
logCore->DeleteCard(temp);
cardCore->DeleteDepositCard(selected->GetIdentifier());
break;
}
case 4:
ChooseAccount();
break;
case 0:
exitFlag = true;
default:
std::cout << "无效输入" << std::endl;
}
}
if (selected != NULL && !selected->IsCampusCard() &&
!selected->IsDepositCard()) {
card::Deposit_Card temp = *cardCore->FindCard(selected->GetIdentifier());
logCore->DeleteCard(temp);
cardCore->DeleteDepositCard(selected->GetIdentifier());
std::cout << "名下无任何信息，删除账户" << std::endl;
}
return;
}
void Interface::Print(std::vector<card::Binding_Card*> list) {
if (list.empty()) {
std::cout << "不存在任何结果！" << std::endl;
return;
}
std::vector<card::Binding_Card*>::iterator it = list.begin();
while (it != list.end()) {
std::cout << (*it)->GetInfo() << std::endl;
it++;
}
return;
}
bool ReadInIdentifier(std::istream& in, int& num) {
if (in.rdbuf() == std::cin.rdbuf())
std::cout << std::endl
<< "请输入您的身份识别号[ID] 小于" << INT_MAX << ":\t";
std::string message;
in >> message;
while (!general::str2num(message, num)) {
std::cout << "输入有误,请重试1" << std::endl;
in >> message;
}
return true;
}
bool ReadInName(std::istream& in, std::string& str) {
if (in.rdbuf() == std::cin.rdbuf())
std::cout << std::endl << "请输入姓名:\t ";
in >> str;
return true;
}
bool ReadInPasswd(std::istream& in, std::string& str) {
if (in.rdbuf() == std::cin.rdbuf())
std::cout << std::endl << "请输入密码:\t ";
in >> str;
return true;
}
bool ReadInBalance(std::istream& in, card::MoneyType& num) {
if (in.rdbuf() == std::cin.rdbuf())
std::cout << std::endl << "请输入金额:\t ";
std::string message;
in >> message;
while (!general::str2num(message, num) || num < 0) {
std::cout << "输入有误,请重试" << std::endl;
in >> message;
}
return true;
}
bool ReadInOverdraft(std::istream& in, card::MoneyType& num) {
if (in.rdbuf() == std::cin.rdbuf())
std::cout << std::endl << "请输入设置透支上限:\t ";
std::string message;
in >> message;
while (!general::str2num(message, num)) {
std::cout << "输入有误,请重试" << std::endl;
in >> message;
}
return true;
}
bool ReadInCardCode(std::istream& in, std::string& message) {
if (in.rdbuf() == std::cin.rdbuf())
std::cout << std::endl << "请输入卡号:\t ";
in >> message;
return true;
}
bool ReadInStudentId(std::istream& in, std::string& message) {
if (in.rdbuf() == std::cin.rdbuf())
std::cout << std::endl << "请输入学号或教工号:\t ";
in >> message;
return true;
}
bool ReadInDepartment(std::istream& in, std::string& message) {
if (in.rdbuf() == std::cin.rdbuf())
std::cout << std::endl << "请输入所属学院:\t ";
in >> message;
return true;
}
} // namespace ui | [
"Silas_X@outlook.com"
] | Silas_X@outlook.com |
b08b180593173546cba16ad97a7ae0d24bc2b6ce | 67051fe5d6f7f640427c7a560f7e49db5baf5fbd | /test.cpp | d6eb550f6868fdb58581b6581dd55216e2e33452 | [] | no_license | HuangJhn/threadPool | cc0b22a65eb90f7d522488f37631ea1c7b3710b2 | ec53c0ad0c002a00e6be1e028884cf1dae635e5e | refs/heads/main | 2023-02-19T19:46:51.346791 | 2021-01-07T12:08:43 | 2021-01-07T12:14:57 | 326,944,020 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,026 | cpp |
#include<iostream>
#include<unistd.h>
#include"threadPool.hpp"
#include"mylog.hpp"
using namespace std;
void doTest(){
// cout << "other thread execute it" << endl;
mylog->printLog("other thread execute it");
}
int main(){
ThreadPool test(5);
test.pushTasks([]{
// std::cout << "this content running the thread" << std::endl;
mylog->printLog("this content running the thread");
});
test.pushTasks(std::bind(doTest));
test.pushTasks(std::bind(doTest));
test.pushTasks(std::bind(doTest));
test.pushTasks(std::bind(doTest));
test.pushTasks(std::bind(doTest));
test.pushTasks(std::bind(doTest));
test.pushTasks(std::bind(doTest));
test.pushTasks(std::bind(doTest));
test.pushTasks(std::bind(doTest));
test.pushTasks(std::bind(doTest));
std::vector<std::future<void>> ftVec;
for(int i = 0; i < 10; i++){
// ftVec = test.pushTasks();
ftVec.push_back(test.pushTasks(std::bind(doTest)));
}
return 0;
} | [
"1435054809@qq.com"
] | 1435054809@qq.com |
05dbef95696cc78d83b6173ce8f63dde2e778cac | 1fc6647001a5e0b84e209ed1dc02de747c511652 | /Medicine_task01/Medicine_task01/Templates.cpp | 430272d88ecbc674c1ba8e65b5391b791dc0f85d | [] | no_license | Pkotova/Object-Oriented-IS-2019-2020---Practice | ce117e9459ff3683d1eadab9fe96c9565ee13b97 | 836d02105fcd1e6f452443ceed015c5690406879 | refs/heads/master | 2021-07-04T07:32:09.808448 | 2021-05-20T12:57:57 | 2021-05-20T12:57:57 | 238,251,754 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 138 | cpp | #include"Medicine.h"
#include<cstring>
template<typename T>
T larger(T fieldA, T fieldB)
{
return (fieldA < fieldB) ? fieldA : fieldB;
}
| [
"petya.kotova@abv.bg"
] | petya.kotova@abv.bg |
f761d473ed35d0f5ab1173e0ddf1196111bed8b2 | f24b13e0db9c152a231ff2dce5658612c7888294 | /cpp/core_v2/internal/client_proxy.cc | 1aaaab81138a854f8bd16fd0f9fd0e5c3175bce7 | [
"Apache-2.0",
"LicenseRef-scancode-generic-cla"
] | permissive | jdapena/nearby-connections | 60ecf94d5b46a56b2c200a2a4bd020dd0c14a683 | ae277748ce068ef1730d5104002d4324fc4ed89e | refs/heads/master | 2022-11-22T07:20:42.040013 | 2020-07-15T18:20:27 | 2020-07-15T18:20:49 | 280,393,856 | 1 | 0 | Apache-2.0 | 2020-07-17T10:17:40 | 2020-07-17T10:17:39 | null | UTF-8 | C++ | false | false | 15,919 | cc | // Copyright 2020 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#include "core_v2/internal/client_proxy.h"
#include <cstdlib>
#include <limits>
#include <utility>
#include "platform_v2/base/base64_utils.h"
#include "platform_v2/base/prng.h"
#include "platform_v2/public/crypto.h"
#include "platform_v2/public/logging.h"
#include "platform_v2/public/mutex_lock.h"
#include "proto/connections_enums.pb.h"
#include "absl/container/flat_hash_map.h"
#include "absl/container/flat_hash_set.h"
#include "absl/strings/str_cat.h"
namespace location {
namespace nearby {
namespace connections {
ClientProxy::ClientProxy() : client_id_(Prng().NextInt64()) {}
ClientProxy::~ClientProxy() { Reset(); }
std::int64_t ClientProxy::GetClientId() const { return client_id_; }
std::string ClientProxy::GenerateLocalEndpointId() {
// 1) Concatenate the Random 64-bit value with "client" string.
// 2) Compute a hash of that concatenation.
// 3) Base64-encode that hash, to make it human-readable.
// 4) Use only the first kEndpointIdLength bytes to make ID.
ByteArray id_hash = Crypto::Sha256(
absl::StrCat("client", prng_.NextInt64()));
std::string id = Base64Utils::Encode(id_hash).substr(0, kEndpointIdLength);
NEARBY_LOG(
INFO, "ClientProxy [Local Endpoint Generated]: client=%p; endpoint_id=%s",
this, id.c_str());
return id;
}
void ClientProxy::Reset() {
MutexLock lock(&mutex_);
StoppedAdvertising();
StoppedDiscovery();
RemoveAllEndpoints();
}
void ClientProxy::StartedAdvertising(
const std::string& service_id, Strategy strategy,
const ConnectionListener& listener,
absl::Span<proto::connections::Medium> mediums) {
MutexLock lock(&mutex_);
advertising_info_ = {service_id, listener};
}
void ClientProxy::StoppedAdvertising() {
MutexLock lock(&mutex_);
if (IsAdvertising()) {
advertising_info_.Clear();
}
}
bool ClientProxy::IsAdvertising() const {
MutexLock lock(&mutex_);
return !advertising_info_.IsEmpty();
}
std::string ClientProxy::GetAdvertisingServiceId() const {
MutexLock lock(&mutex_);
return advertising_info_.service_id;
}
void ClientProxy::StartedDiscovery(
const std::string& service_id, Strategy strategy,
const DiscoveryListener& listener,
absl::Span<proto::connections::Medium> mediums) {
MutexLock lock(&mutex_);
discovery_info_ = DiscoveryInfo{service_id, listener};
}
void ClientProxy::StoppedDiscovery() {
MutexLock lock(&mutex_);
if (IsDiscovering()) {
discovered_endpoint_ids_.clear();
discovery_info_.Clear();
}
}
bool ClientProxy::IsDiscoveringServiceId(const std::string& service_id) const {
MutexLock lock(&mutex_);
return IsDiscovering() && service_id == discovery_info_.service_id;
}
bool ClientProxy::IsDiscovering() const {
MutexLock lock(&mutex_);
return !discovery_info_.IsEmpty();
}
std::string ClientProxy::GetDiscoveryServiceId() const {
MutexLock lock(&mutex_);
return discovery_info_.service_id;
}
void ClientProxy::OnEndpointFound(const std::string& service_id,
const std::string& endpoint_id,
const std::string& endpoint_name,
proto::connections::Medium medium) {
MutexLock lock(&mutex_);
NEARBY_LOG(INFO,
"ClientProxy [Endpoint Found]: [enter] id=%s; service=%s; name=%s",
endpoint_id.c_str(), service_id.c_str(), endpoint_name.c_str());
if (!IsDiscoveringServiceId(service_id)) {
NEARBY_LOG(INFO, "ClientProxy [Endpoint Found]: [no discovery] id=%s",
endpoint_id.c_str());
return;
}
if (discovered_endpoint_ids_.count(endpoint_id)) {
NEARBY_LOG(INFO, "ClientProxy [Endpoint Found]: [duplicate] id=%s",
endpoint_id.c_str());
return;
}
discovered_endpoint_ids_.insert(endpoint_id);
discovery_info_.listener.endpoint_found_cb(endpoint_id, endpoint_name,
service_id);
}
void ClientProxy::OnEndpointLost(const std::string& service_id,
const std::string& endpoint_id) {
MutexLock lock(&mutex_);
if (!IsDiscoveringServiceId(service_id)) return;
const auto it = discovered_endpoint_ids_.find(endpoint_id);
if (it == discovered_endpoint_ids_.end()) return;
discovered_endpoint_ids_.erase(it);
discovery_info_.listener.endpoint_lost_cb(endpoint_id);
}
void ClientProxy::OnConnectionInitiated(const std::string& endpoint_id,
const ConnectionResponseInfo& info,
const ConnectionListener& listener) {
MutexLock lock(&mutex_);
// Whether this is incoming or outgoing, the local and remote endpoints both
// still need to accept this connection, so set its establishment status to
// PENDING.
auto result = connections_.emplace(
endpoint_id, Connection{
.is_incoming = info.is_incoming_connection,
.connection_listener = listener,
});
// Instead of using structured binding which is nice, but banned
// (can not use c++17 features, until chromium does) we unpack manually.
auto& pair_iter = result.first;
bool inserted = result.second;
NEARBY_LOG(INFO,
"ClientProxy [Connection Initiated]: add Connection: client=%p, "
"id=%s; inserted=%d",
this, endpoint_id.c_str(), inserted);
DCHECK(inserted);
const Connection& item = pair_iter->second;
// Notify the client.
//
// Note: we allow devices to connect to an advertiser even after it stops
// advertising, so no need to check IsAdvertising() here.
item.connection_listener.initiated_cb(endpoint_id, info);
}
void ClientProxy::OnConnectionAccepted(const std::string& endpoint_id) {
MutexLock lock(&mutex_);
if (!HasPendingConnectionToEndpoint(endpoint_id)) {
NEARBY_LOG(
INFO, "ClientProxy [Connection Accepted]: no pending connection; id=%s",
endpoint_id.c_str());
return;
}
// Notify the client.
Connection* item = LookupConnection(endpoint_id);
if (item != nullptr) {
item->connection_listener.accepted_cb(endpoint_id);
item->status = Connection::kConnected;
}
}
void ClientProxy::OnConnectionRejected(const std::string& endpoint_id,
const Status& status) {
MutexLock lock(&mutex_);
if (!HasPendingConnectionToEndpoint(endpoint_id)) {
NEARBY_LOG(
INFO, "ClientProxy [Connection Rejected]: no pending connection; id=%s",
endpoint_id.c_str());
return;
}
// Notify the client.
const Connection* item = LookupConnection(endpoint_id);
if (item != nullptr) {
item->connection_listener.rejected_cb(endpoint_id, status);
OnDisconnected(endpoint_id, false /* notify */);
}
}
void ClientProxy::OnBandwidthChanged(const std::string& endpoint_id,
std::int32_t quality) {
MutexLock lock(&mutex_);
const Connection* item = LookupConnection(endpoint_id);
if (item != nullptr) {
item->connection_listener.bandwidth_changed_cb(endpoint_id, quality);
}
}
void ClientProxy::OnDisconnected(const std::string& endpoint_id, bool notify) {
MutexLock lock(&mutex_);
const Connection* item = LookupConnection(endpoint_id);
if (item != nullptr) {
if (notify) {
item->connection_listener.disconnected_cb({endpoint_id});
}
connections_.erase(endpoint_id);
}
}
bool ClientProxy::ConnectionStatusMatches(const std::string& endpoint_id,
Connection::Status status) const {
MutexLock lock(&mutex_);
const Connection* item = LookupConnection(endpoint_id);
if (item != nullptr) {
return item->status == status;
}
return false;
}
bool ClientProxy::IsConnectedToEndpoint(const std::string& endpoint_id) const {
return ConnectionStatusMatches(endpoint_id, Connection::kConnected);
}
std::vector<std::string> ClientProxy::GetMatchingEndpoints(
std::function<bool(const Connection&)> pred) const {
MutexLock lock(&mutex_);
std::vector<std::string> connected_endpoints;
for (const auto& pair : connections_) {
const auto& endpoint_id = pair.first;
const auto& connection = pair.second;
if (pred(connection)) {
connected_endpoints.push_back(endpoint_id);
}
}
return connected_endpoints;
}
std::vector<std::string> ClientProxy::GetPendingConnectedEndpoints() const {
return GetMatchingEndpoints([](const Connection& connection) {
return connection.status != Connection::kConnected;
});
}
std::vector<std::string> ClientProxy::GetConnectedEndpoints() const {
return GetMatchingEndpoints([](const Connection& connection) {
return connection.status == Connection::kConnected;
});
}
std::int32_t ClientProxy::GetNumOutgoingConnections() const {
return GetMatchingEndpoints([](const Connection& connection) {
return connection.status == Connection::kConnected &&
!connection.is_incoming;
})
.size();
}
std::int32_t ClientProxy::GetNumIncomingConnections() const {
return GetMatchingEndpoints([](const Connection& connection) {
return connection.status == Connection::kConnected &&
connection.is_incoming;
})
.size();
}
bool ClientProxy::HasPendingConnectionToEndpoint(
const std::string& endpoint_id) const {
MutexLock lock(&mutex_);
const Connection* item = LookupConnection(endpoint_id);
if (item != nullptr) {
return item->status != Connection::kConnected;
}
return false;
}
bool ClientProxy::HasLocalEndpointResponded(
const std::string& endpoint_id) const {
MutexLock lock(&mutex_);
return ConnectionStatusesContains(
endpoint_id,
static_cast<Connection::Status>(Connection::kLocalEndpointAccepted |
Connection::kLocalEndpointRejected));
}
bool ClientProxy::HasRemoteEndpointResponded(
const std::string& endpoint_id) const {
MutexLock lock(&mutex_);
return ConnectionStatusesContains(
endpoint_id,
static_cast<Connection::Status>(Connection::kRemoteEndpointAccepted |
Connection::kRemoteEndpointRejected));
}
void ClientProxy::LocalEndpointAcceptedConnection(
const std::string& endpoint_id, const PayloadListener& listener) {
MutexLock lock(&mutex_);
if (HasLocalEndpointResponded(endpoint_id)) {
NEARBY_LOG(
INFO,
"ClientProxy [Local Accepted]: local endpoint has responded; id=%s",
endpoint_id.c_str());
return;
}
AppendConnectionStatus(endpoint_id, Connection::kLocalEndpointAccepted);
Connection* item = LookupConnection(endpoint_id);
if (item != nullptr) {
item->payload_listener = listener;
}
}
void ClientProxy::LocalEndpointRejectedConnection(
const std::string& endpoint_id) {
MutexLock lock(&mutex_);
if (HasLocalEndpointResponded(endpoint_id)) {
NEARBY_LOG(
INFO,
"ClientProxy [Local Rejected]: local endpoint has responded; id=%s",
endpoint_id.c_str());
return;
}
AppendConnectionStatus(endpoint_id, Connection::kLocalEndpointRejected);
}
void ClientProxy::RemoteEndpointAcceptedConnection(
const std::string& endpoint_id) {
MutexLock lock(&mutex_);
if (HasRemoteEndpointResponded(endpoint_id)) {
NEARBY_LOG(
INFO,
"ClientProxy [Remote Accepted]: remote endpoint has responded; id=%s",
endpoint_id.c_str());
return;
}
AppendConnectionStatus(endpoint_id, Connection::kRemoteEndpointAccepted);
}
void ClientProxy::RemoteEndpointRejectedConnection(
const std::string& endpoint_id) {
MutexLock lock(&mutex_);
if (HasRemoteEndpointResponded(endpoint_id)) {
NEARBY_LOG(
INFO,
"ClientProxy [Remote Rejected]: remote endpoint has responded; id=%s",
endpoint_id.c_str());
return;
}
AppendConnectionStatus(endpoint_id, Connection::kRemoteEndpointRejected);
}
bool ClientProxy::IsConnectionAccepted(const std::string& endpoint_id) const {
MutexLock lock(&mutex_);
return ConnectionStatusesContains(endpoint_id,
Connection::kLocalEndpointAccepted) &&
ConnectionStatusesContains(endpoint_id,
Connection::kRemoteEndpointAccepted);
}
bool ClientProxy::IsConnectionRejected(const std::string& endpoint_id) const {
MutexLock lock(&mutex_);
return ConnectionStatusesContains(
endpoint_id,
static_cast<Connection::Status>(Connection::kLocalEndpointRejected |
Connection::kRemoteEndpointRejected));
}
bool ClientProxy::LocalConnectionIsAccepted(std::string endpoint_id) const {
return ConnectionStatusesContains(
endpoint_id, ClientProxy::Connection::kLocalEndpointAccepted);
}
bool ClientProxy::RemoteConnectionIsAccepted(std::string endpoint_id) const {
return ConnectionStatusesContains(
endpoint_id, ClientProxy::Connection::kRemoteEndpointAccepted);
}
void ClientProxy::OnPayload(const std::string& endpoint_id, Payload payload) {
MutexLock lock(&mutex_);
if (IsConnectedToEndpoint(endpoint_id)) {
const Connection* item = LookupConnection(endpoint_id);
if (item != nullptr) {
item->payload_listener.payload_cb(endpoint_id, std::move(payload));
}
}
}
const ClientProxy::Connection* ClientProxy::LookupConnection(
const std::string& endpoint_id) const {
auto item = connections_.find(endpoint_id);
return item != connections_.end() ? &item->second : nullptr;
}
ClientProxy::Connection* ClientProxy::LookupConnection(
const std::string& endpoint_id) {
auto item = connections_.find(endpoint_id);
return item != connections_.end() ? &item->second : nullptr;
}
void ClientProxy::OnPayloadProgress(const std::string& endpoint_id,
const PayloadProgressInfo& info) {
MutexLock lock(&mutex_);
if (IsConnectedToEndpoint(endpoint_id)) {
Connection* item = LookupConnection(endpoint_id);
if (item != nullptr) {
item->payload_listener.payload_progress_cb(endpoint_id, info);
}
}
}
bool operator==(const ClientProxy& lhs, const ClientProxy& rhs) {
return lhs.GetClientId() == rhs.GetClientId();
}
bool operator<(const ClientProxy& lhs, const ClientProxy& rhs) {
return lhs.GetClientId() < rhs.GetClientId();
}
void ClientProxy::RemoveAllEndpoints() {
MutexLock lock(&mutex_);
// Note: we may want to notify the client of onDisconnected() for each
// endpoint, in the case when this is called from stopAllEndpoints(). For now,
// just remove without notifying.
connections_.clear();
}
bool ClientProxy::ConnectionStatusesContains(
const std::string& endpoint_id, Connection::Status status_to_match) const {
const Connection* item = LookupConnection(endpoint_id);
if (item != nullptr) {
return (item->status & status_to_match) != 0;
}
return false;
}
void ClientProxy::AppendConnectionStatus(const std::string& endpoint_id,
Connection::Status status_to_append) {
Connection* item = LookupConnection(endpoint_id);
if (item != nullptr) {
item->status =
static_cast<Connection::Status>(item->status | status_to_append);
}
}
} // namespace connections
} // namespace nearby
} // namespace location
| [
"apolyudov@google.com"
] | apolyudov@google.com |
c4296b9ebcfb560a28a0306e0d2fdce5429b3a88 | 82265c2b8e594b5cf4a2c3f266f8358b10ac4d13 | /src/halfedge.cpp | bee01675515b8c09786bccd0dd8063acebc3defd | [] | no_license | dracarysq1/Computational-Graphics-Quadric-Error-Metrics | 4a7fe52d72ca840636ad879dc8dc7dd3a7111db9 | 098b3bd20e4f6a0eca9fd21070d574aca8d28613 | refs/heads/master | 2022-01-17T11:51:21.025353 | 2019-07-02T14:49:54 | 2019-07-02T14:49:54 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 13,371 | cpp | /*
* @Author: NanoApe
* @Date: 2019-06-25 21:11:52
* @Last Modified by: NanoApe
* @Last Modified time: 2019-06-29 12:25:01
*/
#include <algorithm>
#include <iostream>
#include <assert.h>
#include <fstream>
#include <climits>
#include <cstring>
#include <limits>
#include <vector>
#include <cstdio>
#include <math.h>
#include <time.h>
#include <cmath>
#include <queue>
#include <list>
#include <set>
#include <map>
using namespace std;
#define maxs_V 1000000
#define maxs_T 1000000
#define rep(i, n) for(int i = 0; i < n; i++)
#define traversal(ty, nm) for(ty::iterator it = nm.begin(); it != nm.end(); ++it)
#define _traversal(ty, nm) for(ty::iterator _it = nm.begin(); _it != nm.end(); ++_it)
#define sqr(x) ((x)*(x))
#define mp make_pair
struct Edge;
struct Vert
{
Vert(int _o, double _x, double _y, double _z, Edge* _e = NULL) : id(_o), x(_x), y(_y), z(_z), edge(_e) {}
int id;
double x, y, z;
Edge* edge; // one of the half-edges emantating from the vertex
double matrix[4][4] = {{0}};
};
struct Face
{
Face(Edge* _e = NULL) : edge(_e) {}
Edge* edge; // one of the half-edges bordering the face
double equa[4] = {0};
double matrix[4][4] = {{0}};
};
struct Edge
{
Edge(Vert* _v = NULL, Edge* _p = NULL, Face* _f = NULL, Edge* _n = NULL) : vert(_v), pair(_p), face(_f), next(_n) {}
Vert* vert; // vertex at the end of the half-edge
Edge* pair; // oppositely oriented adjacent half-edge
Face* face; // face the half-edge borders
Edge* next; // next half-edge around the face
};
struct Vec {
double x, y, z;
Vec(double _x = 0, double _y = 0, double _z = 0) : x(_x), y(_y), z(_z) {}
Vec operator+(const Vec& b) const { return Vec(x + b.x, y + b.y, z + b.z); }
Vec &operator+=(const Vec &b) { x += b.x, y += b.y, z += b.z; return *this; }
Vec operator-(const Vec& b) const { return Vec(x - b.x, y - b.y, z - b.z); }
Vec &operator-=(const Vec &b) { x -= b.x, y -= b.y, z -= b.z; return *this; }
Vec operator*(double b) const { return Vec(x * b, y * b, z * b); }
Vec operator/(double b) const { return Vec(x / b, y / b, z / b); }
Vec &operator/=(double b) { x /= b, y /= b, z /= b; return *this; }
Vec mult(const Vec &b) const { return Vec(x * b.x, y * b.y, z * b.z); }
double dot(const Vec &b) const { return x * b.x + y * b.y + z * b.z; }
Vec cross(const Vec &b) const { return Vec(y * b.z - z * b.y, z * b.x - x * b.z, x * b.y - y * b.x); }
Vec& norm() { return *this = *this * (1 / sqrt(x*x + y*y + z*z)); }
double len() const { return sqrt(x*x + y*y + z*z); }
double max() const { return (x>y && x>z) ? x : (y>z ? y : z); }
double min() const { return (x<y && x<z) ? x : (y<z ? y : z); }
void print() const { printf("%.12lf %.12lf %.12lf\n", x, y, z); }
};
struct Pair { int u, v; double cost; Vec bestV; int tag; Edge* edge; };
bool operator>(const Pair& a, const Pair& b) { return a.cost > b.cost; }
priority_queue<Pair, vector<Pair>, greater<Pair> > pairs;
int numV = 0, numT = 0;
int rmV = 0, rmT = 0;
Vert* V[maxs_V];
map<pair<int,int>,Edge*> Emap;
Edge* unpair[maxs_V];
int tag[maxs_V];
inline void getEquation(Face* f, Vert* a, Vert* b, Vert* c) {
f->equa[0] = (b->y - a->y) * (c->z - a->z) - (c->y - a->y) * (b->z - a->z);
f->equa[1] = (b->z - a->z) * (c->x - a->x) - (c->z - a->z) * (b->x - a->x);
f->equa[2] = (b->x - a->x) * (c->y - a->y) - (c->x - a->x) * (b->y - a->y);
double length = sqrt(sqr(f->equa[0]) + sqr(f->equa[1]) + sqr(f->equa[2]));
rep(i, 3) f->equa[i] /= length;
f->equa[3] = - f->equa[0] * a->x - f->equa[1] * a->y - f->equa[2] * a->z;
rep(i, 4) rep(j, 4) f->matrix[i][j] = f->equa[i] * f->equa[j];
}
inline void load(const char* filename) {
numV = numT = 0;
FILE* f = fopen(filename, "r");
char buf[256];
while(fscanf(f, "%s", buf) != EOF) {
switch (buf[0]) {
case '#':
fgets(buf, sizeof(buf), f);
break;
case 'v':
double x, y, z;
fscanf(f, "%lf %lf %lf", &x, &y, &z);
V[numV] = new Vert(numV, x, y, z, NULL);
numV++;
break;
case 'f': {
int a, b, c;
fscanf(f, "%d %d %d", &a, &b, &c); a--; b--; c--;
Face* F = new Face(NULL);
Edge* Ea = new Edge(V[b], NULL, F, NULL);
Edge* Eb = new Edge(V[c], NULL, F, NULL);
Edge* Ec = new Edge(V[a], NULL, F, NULL);
F->edge = Ea;
Ea->next = Eb;
Eb->next = Ec;
Ec->next = Ea;
V[a]->edge = Ea;
V[b]->edge = Eb;
V[c]->edge = Ec;
if (Emap.count(mp(a, b))) {
Ea->pair = Emap[mp(a, b)];
Ea->pair->pair = Ea;
Emap.erase(mp(a, b));
} else Emap[mp(b, a)] = Ea;
if (Emap.count(mp(b, c))) {
Eb->pair = Emap[mp(b, c)];
Eb->pair->pair = Eb;
Emap.erase(mp(b, c));
} else Emap[mp(c, b)] = Eb;
if (Emap.count(mp(c, a))) {
Ec->pair = Emap[mp(c, a)];
Ec->pair->pair = Ec;
Emap.erase(mp(c, a));
} else Emap[mp(a, c)] = Ec;
getEquation(F, V[a], V[b], V[c]);
rep(i, 4) rep(j, 4) {
V[a]->matrix[i][j] += F->matrix[i][j];
V[b]->matrix[i][j] += F->matrix[i][j];
V[c]->matrix[i][j] += F->matrix[i][j];
}
numT++;
break;
}
default:
fgets(buf, sizeof(buf), f);
}
}
fclose(f);
}
int newID[maxs_V];
inline void save(const char* filename) {
FILE* f = fopen(filename, "w");
fprintf(f, "# %d vertices %d triangles\n", numV-rmV, numT-rmT);
int total = 0;
rep(i, numV) if (V[i]) {
fprintf(f, "v %f %f %f\n", V[i]->x, V[i]->y, V[i]->z);
newID[V[i]->id] = ++total;
}
rep(i, numV) if (V[i]) {
Edge* p = V[i]->edge; while (true) {
if (V[i]->id == p->vert->id || p->vert->id == p->next->vert->id || p->vert->id == p->next->vert->id)
printf("%d %d %d\n", V[i]->id, p->vert->id, p->next->vert->id);
if (V[i]->id < p->vert->id && V[i]->id < p->next->vert->id)
fprintf(f, "f %d %d %d\n", newID[V[i]->id], newID[p->vert->id], newID[p->next->vert->id]);
if ((p = p->pair->next) == V[i]->edge) break;
}
}
fclose(f);
printf("Vertex Number = %d\nTriangle Number = %d\n", numV-rmV, numT-rmT);
printf("Writing to %s successfully\n", filename);
}
inline Pair getCost(Vert* u, Vert* v, Edge* e) {
double Q[4][4];
rep(i, 4) rep(j, 4) Q[i][j] = u->matrix[i][j] + v->matrix[i][j];
// getMidPoint
Vec bestV;
double delta = Q[0][0] * Q[1][1] * Q[2][2] - Q[0][0] * Q[1][2] * Q[1][2] - Q[0][1] * Q[0][1] * Q[2][2]
+ Q[0][1] * Q[1][2] * Q[0][2] + Q[0][2] * Q[0][1] * Q[1][2] - Q[0][2] * Q[1][1] * Q[0][2];
double deltaX, deltaY, deltaZ;
if (delta > 1e-7) {
deltaX = ( Q[0][3] * Q[1][1] * Q[2][2] - Q[0][3] * Q[1][2] * Q[1][2] - Q[1][3] * Q[0][1] * Q[2][2]
+ Q[1][3] * Q[1][2] * Q[0][2] + Q[2][3] * Q[0][1] * Q[1][2] - Q[2][3] * Q[1][1] * Q[0][2] ) / (-delta);
deltaY = ( Q[0][0] * Q[1][3] * Q[2][2] - Q[0][0] * Q[2][3] * Q[1][2] - Q[0][1] * Q[0][3] * Q[2][2]
+ Q[0][1] * Q[2][3] * Q[0][2] + Q[0][2] * Q[0][3] * Q[1][2] - Q[0][2] * Q[1][3] * Q[0][2] ) / (-delta);
deltaZ = ( Q[0][0] * Q[1][1] * Q[2][3] - Q[0][0] * Q[1][2] * Q[1][3] - Q[0][1] * Q[0][1] * Q[2][3]
+ Q[0][1] * Q[1][2] * Q[0][3] + Q[0][2] * Q[0][1] * Q[1][3] - Q[0][2] * Q[1][1] * Q[0][3] ) / (-delta);
} else {
deltaX = (u->x + v->x) / 2;
deltaY = (u->y + v->y) / 2;
deltaZ = (u->z + v->z) / 2;
}
bestV = Vec(deltaX, deltaY, deltaZ);
double tmp[4];
tmp[0] = bestV.x; tmp[1] = bestV.y; tmp[2] = bestV.z; tmp[3] = 1;
double deltaV = 0;
rep(i, 4) rep(j, 4) deltaV += tmp[j] * Q[j][i] * tmp[i];
return (Pair){u->id, v->id, deltaV, bestV, numV, e};
}
inline double dot(double* a, double* b) {
double sum = 0;
rep(i, 3) sum += a[i] * b[i];
return sum;
}
int col[maxs_V], _col;
inline bool flip(Pair& mn) {
Vert* c = new Vert(-1, mn.bestV.x, mn.bestV.y, mn.bestV.z);
Face* tmp = new Face();
_col++;
int count = 0;
Edge* e = mn.edge;
while ((e = e->pair->next) != mn.edge)
if (col[e->vert->id] == _col)
count++;
else
col[e->vert->id] = _col;
e = e->pair;
while ((e = e->pair->next) != mn.edge->pair)
if (col[e->vert->id] == _col)
count++;
else
col[e->vert->id] = _col;
if (count > 2) return true;
e = mn.edge;
while (true) {
Edge* p = e->pair->next; while ((p = p->pair->next) != e) {
getEquation(tmp, V[p->vert->id], V[p->next->vert->id], c);
if (dot(tmp->equa, p->face->equa) < 0) return true;
}
if ((e = e->pair) == mn.edge) break;
}
delete c;
delete tmp;
return false;
}
inline void subMatrix(Face *f) {
rep(i, 4) rep(j, 4) {
f->edge->vert->matrix[i][j] -= f->matrix[i][j];
f->edge->next->vert->matrix[i][j] -= f->matrix[i][j];
f->edge->next->next->vert->matrix[i][j] -= f->matrix[i][j];
}
}
inline void deleteV() {
Pair mn = pairs.top(); pairs.pop();
while (V[mn.u] == NULL || V[mn.v] == NULL || tag[mn.u] > mn.tag || tag[mn.v] > mn.tag) {
mn = pairs.top(); pairs.pop();
}
// if (mn.cost > 9) printf("%.12lf %d\n", mn.cost, numV - rmV);
if (flip(mn)) return;
int newV = numV++;
V[newV] = new Vert(newV, mn.bestV.x, mn.bestV.y, mn.bestV.z);
Edge* e = mn.edge; int a, b, c;
while (true) {
Edge* p = e->pair->next; while ((p = p->pair->next) != e) {
Face* F = new Face(NULL);
Edge* Ea = new Edge(p->vert, NULL, F, NULL);
Edge* Eb = new Edge(p->next->vert, NULL, F, NULL);
Edge* Ec = new Edge(V[newV], NULL, F, NULL);
F->edge = Ea;
Ea->next = Eb;
Eb->next = Ec;
Ec->next = Ea;
V[ a = newV ]->edge = Ea;
V[ b = p->vert->id ]->edge = Eb;
V[ c = p->next->vert->id ]->edge = Ec;
if (unpair[b]) {
Ea->pair = unpair[b];
Ea->pair->pair = Ea;
unpair[b] = NULL;
} else unpair[b] = Ea;
Eb->pair = p->next->pair;
Eb->pair->pair = Eb;
if (unpair[c]) {
Ec->pair = unpair[c];
Ec->pair->pair = Ec;
unpair[c] = NULL;
} else unpair[c] = Ec;
getEquation(F, V[a], V[b], V[c]);
rep(i, 4) rep(j, 4) {
V[a]->matrix[i][j] += F->matrix[i][j];
V[b]->matrix[i][j] += F->matrix[i][j];
V[c]->matrix[i][j] += F->matrix[i][j];
}
numT++;
}
if ((e = e->pair) == mn.edge) break;
}
while (true) {
Edge* p = e->pair->next;
while ((p = p->pair->next) != e) {
if (p->next->next->pair->next->vert != e->vert)
delete p->next->next->pair;
subMatrix(p->face); rmT++;
delete p->face;
delete p->next->next;
delete p->next;
}
delete p->next->next->pair;
if ((e = e->pair) == mn.edge) break;
}
subMatrix(e->pair->face); rmT++;
delete e->pair->face;
delete e->pair->next->next;
delete e->pair->next;
delete e->pair;
subMatrix(e->face); rmT++;
delete e->face;
delete e->next->next;
delete e->next;
delete e;
V[mn.u] = V[mn.v] = NULL;
rmV += 2;
tag[newV] = numV;
e = V[newV]->edge; while (true) {
tag[e->vert->id] = numV;
Edge* p = e->pair; while (p->pair->next->vert->id != newV) {
pairs.push(getCost(e->vert, p->vert, p));
p = p->pair->next;
}
if ((e = e->pair->next) == V[newV]->edge) break;
}
}
int main(int argc, char **argv) {
clock_t start = clock();
if (argc != 4) {
cout << "Usage: " << argv[0] << " <input obj file> <output obj file> <simplification ratio>" << endl;
return 0;
}
load(argv[1]);
printf("Loading from %s successfully.\n", argv[1]);
printf("Vertex Number = %d\n", numV);
printf("Triangle Number = %d\n", numT);
rep(i, numV) {
tag[i] = numV;
Edge* p = V[i]->edge; while (true) {
if (p->vert->id < i)
pairs.push(getCost(V[i], p->vert, p));
if ((p = p->pair->next) == V[i]->edge) break;
}
}
int tmpT = numT;
// int target = atof(argv[3]);
// while (tmpV - (numV - rmV) < target) deleteV();
double target = atof(argv[3]);
while (1. * (numT - rmT) / tmpT > target) deleteV();
printf("Used: %.3lf sec.\n", (double)(clock() - start) / CLOCKS_PER_SEC);
save(argv[2]);
return 0;
} | [
"nanoapezlk@gmail.com"
] | nanoapezlk@gmail.com |
6b9b260a666eea8820a30cb46a95def009a06414 | 955a639f380272dae0aad59659343ed035bea4f7 | /SLabCoreLib/Colors.h | 2d7b7e75f77372bffb4c344ab4e840220018ec59 | [
"CC-BY-4.0"
] | permissive | GabrieleGiuseppini/SpringLab | 29607cfd96b8056a4cad5dd177cac34f13e1d1f7 | da44ed79f660057cedcd7b7ec7876d4d17070278 | refs/heads/master | 2023-07-28T04:22:14.031259 | 2023-07-19T14:45:34 | 2023-07-19T14:45:34 | 264,458,602 | 1 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 7,785 | h | /***************************************************************************************
* Original Author: Gabriele Giuseppini
* Created: 2019-02-04
* Copyright: Gabriele Giuseppini (https://github.com/GabrieleGiuseppini)
***************************************************************************************/
#pragma once
#include "SLabMath.h"
#include "Vectors.h"
#include <cstdint>
#include <limits>
#include <ostream>
#include <string>
#pragma pack(push)
struct rgbColor
{
public:
typedef uint8_t data_type;
static constexpr uint8_t data_type_max = std::numeric_limits<uint8_t>::max();
public:
uint8_t r;
uint8_t g;
uint8_t b;
static constexpr rgbColor zero()
{
return rgbColor(0, 0, 0);
}
rgbColor()
{
}
inline constexpr rgbColor(
uint8_t _r,
uint8_t _g,
uint8_t _b)
: r(_r)
, g(_g)
, b(_b)
{
}
inline constexpr explicit rgbColor(vec3f const & c)
: r(static_cast<uint8_t>(c.x * 255.0f + 0.5f))
, g(static_cast<uint8_t>(c.y * 255.0f + 0.5f))
, b(static_cast<uint8_t>(c.z * 255.0f + 0.5f))
{
}
inline bool operator==(rgbColor const & other) const
{
return r == other.r
&& g == other.g
&& b == other.b;
}
inline bool operator!=(rgbColor const & other) const
{
return !(*this == other);
}
// (lexicographic comparison only)
inline bool operator<(rgbColor const & other) const
{
return r < other.r
|| (r == other.r && g < other.g)
|| (r == other.r && g == other.g && b < other.b);
}
inline constexpr vec3f toVec3f() const
{
return vec3f(
static_cast<float>(r) / 255.0f,
static_cast<float>(g) / 255.0f,
static_cast<float>(b) / 255.0f);
}
inline constexpr vec4f toVec4f(float a) const
{
return vec4f(
static_cast<float>(r) / 255.0f,
static_cast<float>(g) / 255.0f,
static_cast<float>(b) / 255.0f,
a);
}
static rgbColor fromString(std::string const & str);
std::string toString() const;
};
#pragma pack(pop)
static_assert(offsetof(rgbColor, r) == 0 * sizeof(uint8_t));
static_assert(offsetof(rgbColor, g) == 1 * sizeof(uint8_t));
static_assert(offsetof(rgbColor, b) == 2 * sizeof(uint8_t));
static_assert(sizeof(rgbColor) == 3 * sizeof(uint8_t));
inline std::basic_ostream<char> & operator<<(std::basic_ostream<char>& os, rgbColor const & c)
{
os << c.toString();
return os;
}
#pragma pack(push)
struct rgbaColor
{
public:
typedef uint8_t data_type;
static constexpr uint8_t data_type_max = std::numeric_limits<uint8_t>::max();
public:
uint8_t r;
uint8_t g;
uint8_t b;
uint8_t a;
static constexpr rgbaColor zero()
{
return rgbaColor(0, 0, 0, 0);
}
rgbaColor()
{
}
inline constexpr rgbaColor(
uint8_t _r,
uint8_t _g,
uint8_t _b,
uint8_t _a)
: r(_r)
, g(_g)
, b(_b)
, a(_a)
{
}
inline constexpr explicit rgbaColor(vec4f const & c)
: r(static_cast<uint8_t>(c.x * 255.0f + 0.5f))
, g(static_cast<uint8_t>(c.y * 255.0f + 0.5f))
, b(static_cast<uint8_t>(c.z * 255.0f + 0.5f))
, a(static_cast<uint8_t>(c.w * 255.0f + 0.5f))
{
}
inline constexpr rgbaColor(
rgbColor const & c,
uint8_t _a)
: r(c.r)
, g(c.g)
, b(c.b)
, a(_a)
{
}
inline constexpr rgbaColor(
vec3f const & c,
uint8_t _a)
: r(static_cast<uint8_t>(c.x * 255.0f + 0.5f))
, g(static_cast<uint8_t>(c.y * 255.0f + 0.5f))
, b(static_cast<uint8_t>(c.z * 255.0f + 0.5f))
, a(_a)
{
}
inline bool operator==(rgbaColor const & other) const
{
return r == other.r
&& g == other.g
&& b == other.b
&& a == other.a;
}
inline bool operator!=(rgbaColor const & other) const
{
return !(*this == other);
}
// (lexicographic comparison only)
inline bool operator<(rgbaColor const & other) const
{
return r < other.r
|| (r == other.r && g < other.g)
|| (r == other.r && g == other.g && b < other.b)
|| (r == other.r && g == other.g && b == other.b && a < other.a);
}
inline void alpha_multiply()
{
float const alpha = static_cast<float>(a) / 255.0f;
r = static_cast<uint8_t>(r * alpha + 0.5f);
g = static_cast<uint8_t>(g * alpha + 0.5f);
b = static_cast<uint8_t>(b * alpha + 0.5f);
}
inline rgbaColor blend(rgbaColor const & otherColor) const noexcept
{
float const thisAlpha = static_cast<float>(this->a) / 255.0f;
float const otherAlpha = static_cast<float>(otherColor.a) / 255.0f;
vec3f const result = Mix(
this->toVec3f(),
otherColor.toVec3f(),
otherAlpha);
float const finalAlpha = thisAlpha + otherAlpha * (1.0f - thisAlpha);
return rgbaColor(result, static_cast<uint8_t>(finalAlpha * 255.0f + 0.5f));
}
inline rgbaColor mix(
rgbColor const & otherColor,
float alpha) const noexcept
{
vec3f const result = Mix(this->toVec3f(), otherColor.toVec3f(), alpha);
return rgbaColor(result, this->a);
}
inline constexpr rgbColor toRgbColor() const
{
return rgbColor(r, g, b);
}
inline constexpr vec3f toVec3f() const noexcept
{
return vec3f(
static_cast<float>(r) / 255.0f,
static_cast<float>(g) / 255.0f,
static_cast<float>(b) / 255.0f);
}
inline constexpr vec4f toVec4f() const noexcept
{
return vec4f(
static_cast<float>(r) / 255.0f,
static_cast<float>(g) / 255.0f,
static_cast<float>(b) / 255.0f,
static_cast<float>(a) / 255.0f);
}
static rgbaColor fromString(std::string const & str);
std::string toString() const;
};
#pragma pack(pop)
static_assert(offsetof(rgbaColor, r) == 0 * sizeof(uint8_t));
static_assert(offsetof(rgbaColor, g) == 1 * sizeof(uint8_t));
static_assert(offsetof(rgbaColor, b) == 2 * sizeof(uint8_t));
static_assert(offsetof(rgbaColor, a) == 3 * sizeof(uint8_t));
static_assert(sizeof(rgbaColor) == 4 * sizeof(uint8_t));
inline std::basic_ostream<char> & operator<<(std::basic_ostream<char>& os, rgbaColor const & c)
{
os << c.toString();
return os;
}
struct rgbaColorAccumulation
{
public:
uint32_t r;
uint32_t g;
uint32_t b;
uint32_t a;
uint32_t count;
static constexpr rgbaColorAccumulation zero()
{
return rgbaColorAccumulation();
}
inline constexpr rgbaColorAccumulation()
: r(0)
, g(0)
, b(0)
, a(0)
, count(0)
{
}
inline constexpr rgbaColorAccumulation(rgbaColor const & c)
: r(c.r)
, g(c.g)
, b(c.b)
, a(c.a)
, count(1)
{
}
inline rgbaColorAccumulation & operator+=(rgbaColor const & c)
{
r += static_cast<uint32_t>(c.r);
g += static_cast<uint32_t>(c.g);
b += static_cast<uint32_t>(c.b);
a += static_cast<uint32_t>(c.a);
++count;
return *this;
}
inline rgbaColor toRgbaColor() const
{
if (count > 0)
return rgbaColor(
static_cast<uint8_t>(r / count),
static_cast<uint8_t>(g / count),
static_cast<uint8_t>(b / count),
static_cast<uint8_t>(a / count));
else
return rgbaColor::zero();
}
};
| [
"gabriele.giuseppini@gmail.com"
] | gabriele.giuseppini@gmail.com |
e9c4a24f484d26849886f6a258351eb3a09db5c8 | 59bddc3f3d6dd0d28c72225d2ee8d14f0495cd4d | /src/Bitmap.cpp | 52a4fb4d72b78cf1a57c33d2bb72c638c3570f33 | [
"MIT"
] | permissive | jflozanor/ISO8583Lib | 66a65cee7d40f822b85d66020001286523ae6c28 | 39f896e180bc76d52904d677aaa011aeb6eacdfe | refs/heads/master | 2023-03-16T03:38:30.525316 | 2020-08-12T06:04:16 | 2020-08-12T06:04:16 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,455 | cpp | #include <sstream>
#include <iostream>
#include <iomanip>
#include "Bitmap.h"
#include "Util.h"
#define CHECK_AND_DECREMENT_INDEX \
if (index < 1 || index > 64) \
throw std::out_of_range("index number must be under the 64-1"); \
\
--index;
Bitmap::Bitmap()
: _bitmap( { } )
{
this->clear();
}
void Bitmap::clear(void)
{
for (auto &item : this->_bitmap)
item = 0x00;
}
void Bitmap::printBits() const
{
std::stringstream ss;
int i = 0;
for (auto item : _bitmap ) {
ss << std::hex << std::uppercase << (int) item;
}
std::cout << i++ << " " << ss.str() << std::endl;
}
void Bitmap::set(int index)
{
CHECK_AND_DECREMENT_INDEX;
_bitmap[index/8] |= (0x01 << ( 7 - index%8 ) );
}
void Bitmap::unset(int index)
{
CHECK_AND_DECREMENT_INDEX;
_bitmap[index/8] &= ( 0x01 << ( 7 - index%8 )) ^ 0xFF;
}
bool Bitmap::get(int index) const
{
CHECK_AND_DECREMENT_INDEX;
return _bitmap[index/8] & (0x01 << ( 7 - index%8 ) );
}
void Bitmap::flip(int index)
{
CHECK_AND_DECREMENT_INDEX;
_bitmap[index/8] ^= ( (0x01 << ( 7 - index%8 )));
}
std::string Bitmap::toHex(void) const
{
std::stringstream ss;
for (auto item : _bitmap )
ss << Util::uchar2hex( item );
return ss.str();
}
| [
"mustafacoker@yandex.com"
] | mustafacoker@yandex.com |
c3c5dafcf1a454df8d2d0e80d638168832fe04f0 | 5e8d200078e64b97e3bbd1e61f83cb5bae99ab6e | /main/source/src/utility/graph/DFS_sort.hh | 0ee6457185329b1022612bc5211d546a479f3acc | [] | no_license | MedicaicloudLink/Rosetta | 3ee2d79d48b31bd8ca898036ad32fe910c9a7a28 | 01affdf77abb773ed375b83cdbbf58439edd8719 | refs/heads/master | 2020-12-07T17:52:01.350906 | 2020-01-10T08:24:09 | 2020-01-10T08:24:09 | 232,757,729 | 2 | 6 | null | null | null | null | UTF-8 | C++ | false | false | 6,806 | hh | // -*- mode:c++;tab-width:2;indent-tabs-mode:t;show-trailing-whitespace:t;rm-trailing-spaces:t -*-
// vi: set ts=2 noet:
//
// (c) Copyright Rosetta Commons Member Institutions.
// (c) This file is part of the Rosetta software suite and is made available under license.
// (c) The Rosetta software is developed by the contributing members of the Rosetta Commons.
// (c) For more information, see http://www.rosettacommons.org. Questions about this can be
// (c) addressed to University of Washington CoMotion, email: license@uw.edu.
// This file contains code derived from the Boost graph library.
// See Rosetta/main/source/external/boost_1_55_0/LICENSE_1_0.txt
// for the Boost library license.
/// @file utility/graph/DFS_sort.hh
/// @brief A depth first search with sorting for edge visitation.
/// @author Rocco Moretti (rmorettiase@gmail.com)
#ifndef INCLUDED_utility_graph_DFS_sort_HH
#define INCLUDED_utility_graph_DFS_sort_HH
#include <boost/graph/depth_first_search.hpp>
namespace utility {
namespace graph {
/// @brief depth_first_visit_sort_impl is a slightly
/// modified version of the recursive version of the
/// Boost function depth_first_visit_impl,
/// allowing the visitor class to prune nodes and edges.
/// See depth_first_search_sort for details
template <class IncidenceGraph, class DFSVisitor, class ColorMap,
class SortFunc>
void depth_first_visit_sort_impl
(const IncidenceGraph& g,
typename boost::graph_traits<IncidenceGraph>::vertex_descriptor u,
DFSVisitor& vis, // pass-by-reference here, important!
ColorMap color, SortFunc const & func)
{
using namespace boost;
typedef typename graph_traits<IncidenceGraph>::vertex_descriptor Vertex;
typedef typename graph_traits<IncidenceGraph>::edge_descriptor Edge;
typedef std::vector< Edge > Edges;
typedef typename property_traits<ColorMap>::value_type ColorValue;
typedef color_traits<ColorValue> Color;
put(color, u, Color::gray()); vis.discover_vertex(u, g);
// typedef typename unwrap_reference<SortFunc>::type SF;
// // Variable is needed to workaround a borland bug.
// SF& fn = static_cast<SF&>(func);
Edges edges;
{ // Anonymous namespace to limit ei/ei_end scope.
typename graph_traits<IncidenceGraph>::out_edge_iterator ei, ei_end;
for ( boost::tie(ei, ei_end) = out_edges(u, g); ei != ei_end; ++ei ) {
edges.push_back( *ei );
}
}
std::sort(edges.begin(),edges.end(),func); // Sort edges
for ( typename Edges::iterator ei( edges.begin() ), ei_end( edges.end() ); ei != ei_end; ++ei ) {
Vertex v = target(*ei, g); vis.examine_edge(*ei, g);
ColorValue v_color = get(color, v);
if ( v_color == Color::white() ) {
vis.tree_edge(*ei, g);
depth_first_visit_sort_impl(g, v, vis, color, func);
} else if ( v_color == Color::gray() ) {
vis.back_edge(*ei, g);
} else {
vis.forward_or_cross_edge(*ei, g);
}
}
put(color, u, Color::black()); vis.finish_vertex(u, g);
}
/// @brief A sorted depth first search.
/// The parameter func should be a callable object which takes two graph edge descriptors,
/// and returns true if the first should go before the second in ordering.
///
/// This version will start at start_vertex, but will restart arbitrarily for any disconnected graph portions.
template <class VertexListGraph, class DFSVisitor, class ColorMap, class SortFunc>
void
depth_first_search_sort(const VertexListGraph& g, DFSVisitor vis, ColorMap color,
typename boost::graph_traits<VertexListGraph>::vertex_descriptor start_vertex,
SortFunc const & func)
{
using namespace boost;
typedef typename graph_traits<VertexListGraph>::vertex_descriptor Vertex;
function_requires<DFSVisitorConcept<DFSVisitor, VertexListGraph> >();
typedef typename property_traits<ColorMap>::value_type ColorValue;
typedef color_traits<ColorValue> Color;
typename graph_traits<VertexListGraph>::vertex_iterator ui, ui_end;
for ( boost::tie(ui, ui_end) = vertices(g); ui != ui_end; ++ui ) {
Vertex u = implicit_cast<Vertex>(*ui);
put(color, u, Color::white()); vis.initialize_vertex(u, g);
}
if ( start_vertex != implicit_cast<Vertex>(*vertices(g).first) ) { vis.start_vertex(start_vertex, g);
depth_first_visit_sort_impl(g, start_vertex, vis, color, func);
}
for ( boost::tie(ui, ui_end) = vertices(g); ui != ui_end; ++ui ) {
Vertex u = implicit_cast<Vertex>(*ui);
ColorValue u_color = get(color, u);
if ( u_color == Color::white() ) { vis.start_vertex(u, g);
depth_first_visit_sort_impl(g, u, vis, color, func);
}
}
}
/// @brief A sorted depth first search.
/// The parameter func should be a callable object which takes two graph edge descriptors,
/// and returns true if the first should go before the second in ordering.
///
/// This version will start at an arbitrary vertex, and restart for disconnected portions of the graph
template <class VertexListGraph, class DFSVisitor, class ColorMap, class SortFunc>
void
depth_first_search_sort(const VertexListGraph& g, DFSVisitor vis, ColorMap color, SortFunc const & func)
{
using namespace boost;
typedef typename boost::graph_traits<VertexListGraph>::vertex_iterator vi;
std::pair<vi, vi> verts = vertices(g);
if ( verts.first == verts.second ) {
return;
}
depth_first_search_sort(g, vis, color, *verts.first, func);
}
/// @brief Named Parameter Variant
template <class VertexListGraph, class SortFunc, class P, class T, class R>
void
depth_first_search_sort(const VertexListGraph& g, SortFunc const & func,
const boost::bgl_named_params<P, T, R>& params)
{
using namespace boost;
typedef typename boost::graph_traits<VertexListGraph>::vertex_iterator vi;
std::pair<vi, vi> verts = vertices(g);
if ( verts.first == verts.second ) {
return;
}
using namespace boost::graph::keywords;
typedef bgl_named_params<P, T, R> params_type;
BOOST_GRAPH_DECLARE_CONVERTED_PARAMETERS(params_type, params)
depth_first_search_sort
(g,
arg_pack[_visitor | make_dfs_visitor(null_visitor())],
boost::detail::make_color_map_from_arg_pack(g, arg_pack),
arg_pack[_root_vertex | *vertices(g).first],
func
);
}
template <class IncidenceGraph, class DFSVisitor, class ColorMap, class SortFunc>
void depth_first_visit
(const IncidenceGraph& g,
typename boost::graph_traits<IncidenceGraph>::vertex_descriptor u,
DFSVisitor vis, ColorMap color, SortFunc const & func)
{
vis.start_vertex(u, g);
depth_first_visit_sort_impl(g, u, vis, color, func);
}
template <class IncidenceGraph, class DFSVisitor, class ColorMap, class SortFunc>
void depth_first_visit
(const IncidenceGraph& g,
typename boost::graph_traits<IncidenceGraph>::vertex_descriptor u,
DFSVisitor vis, ColorMap color, SortFunc func = SortFunc())
{
vis.start_vertex(u, g);
depth_first_visit_sort_impl(g, u, vis, color, func);
}
} // namespace graph
} // namespace utility
#endif
| [
"36790013+MedicaicloudLink@users.noreply.github.com"
] | 36790013+MedicaicloudLink@users.noreply.github.com |
73b426fc972114c45b79cc7cbb33fa867895ae44 | 513690464d0ecfd85c3aa35df84042329fd4d36f | /Puzza/Graphics.hpp | b67bc47e7d44c3ea738c9643fdb49c1f5fd81b52 | [
"MIT"
] | permissive | Hapaxia/MyPracticeBeginnerGames | 25d5860f649f6221a948199587256d3826d70ff9 | 47ab3dfe0568ac16266813087bdc35f776a6b2df | refs/heads/master | 2022-11-07T13:03:09.812427 | 2022-10-26T00:07:49 | 2022-10-26T00:07:49 | 41,216,006 | 7 | 1 | MIT | 2018-03-20T23:20:01 | 2015-08-22T16:37:05 | C++ | UTF-8 | C++ | false | false | 1,974 | hpp | #ifndef PUZZA_GRAPHICS_HPP
#define PUZZA_GRAPHICS_HPP
#include "Resources.hpp"
#include "Ball.hpp"
#include "Paddle.hpp"
#include <SFML/Graphics/Sprite.hpp>
#include <SFML/Graphics/Drawable.hpp>
#include <SFML/Graphics/RenderTarget.hpp>
#include <SFML/Graphics/RenderStates.hpp>
#include <SFML/Graphics/Rect.hpp>
#include <SFML/Graphics/View.hpp>
#include <SFML/System/Vector2.hpp>
class Graphics : public sf::Drawable
{
public:
Graphics(Resources& resources);
void updatePlayer(const sf::View& view, const Paddle& player, float dt);
void updateOpponent(const sf::View& view, const Paddle& opponent, float dt);
void updateBall(const Ball& ball, float dt);
void updateSize(const sf::View& view);
bool playerCollidesWith(const sf::FloatRect& bounds) const;
bool opponentCollidesWith(const sf::FloatRect& bounds) const;
bool isInLineWithPlayer(float y) const;
bool isHigherThanPlayer(float y) const;
bool isLowerThanPlayer(float y) const;
bool isToTheRightOfPlayer(float x) const;
bool isToTheRightOfPlayerBack(float x) const;
bool isInLineWithOpponent(float y) const;
bool isHigherThanOpponent(float y) const;
bool isLowerThanOpponent(float y) const;
bool isToTheLeftOfOpponent(float x) const;
bool isToTheLeftOfOpponentBack(float x) const;
float getPlayerFront() const;
float getPlayerTop() const;
float getPlayerBottom() const;
float getOpponentFront() const;
float getOpponentTop() const;
float getOpponentBottom() const;
float getBallDistanceLeftOfOpponent() const;
float getPaddleReachFromCenter() const;
void startBallAnimHit();
void startPlayerAnimHit();
void startOpponentAnimHit();
private:
const float m_paddleWidth;
float m_paddleReachFromCenter;
sf::Sprite m_ball, m_player, m_opponent;
bool m_animBallHit, m_animPlayerHit, m_animOpponentHit;
float m_animFrameBall, m_animFramePlayer, m_animFrameOpponent;
virtual void draw(sf::RenderTarget& target, sf::RenderStates states) const;
};
#endif // PUZZA_GRAPHICS_HPP | [
"MJSilk2@gmail.com"
] | MJSilk2@gmail.com |
40635a924ebe78f9bcb7370bf6fb9f01bac023b3 | e51d009c6c6a1633c2c11ea4e89f289ea294ec7e | /xr2-dsgn/sources/xray/sound/sources/ogg_file_contents_cook.cpp | 0fd9f1ebcf5764c9f2a18d0199b71f6c6f262d53 | [] | no_license | avmal0-Cor/xr2-dsgn | a0c726a4d54a2ac8147a36549bc79620fead0090 | 14e9203ee26be7a3cb5ca5da7056ecb53c558c72 | refs/heads/master | 2023-07-03T02:05:00.566892 | 2021-08-06T03:10:53 | 2021-08-06T03:10:53 | 389,939,196 | 3 | 2 | null | null | null | null | UTF-8 | C++ | false | false | 1,933 | cpp | ////////////////////////////////////////////////////////////////////////////
// Created : 24.02.2011
// Author : Dmitriy Kulikov
// Copyright (C) GSC Game World - 2011
////////////////////////////////////////////////////////////////////////////
#include "pch.h"
#include "ogg_file_contents_cook.h"
#include "ogg_file_contents.h"
#include "sound_world.h"
namespace xray {
namespace sound {
ogg_file_contents_cook::ogg_file_contents_cook( )
:super(resources::ogg_file_contents_class, reuse_false, use_resource_manager_thread_id)
{
}
ogg_file_contents_cook::~ogg_file_contents_cook( )
{
}
void ogg_file_contents_cook::translate_query( resources::query_result_for_cook& parent )
{
resources::request request_array[] = {
{ parent.get_requested_path(), resources::ogg_raw_file }
// { "request_options", resources::lua_config_class },
};
query_resources (
request_array,
array_size(request_array),
boost::bind(&ogg_file_contents_cook::on_sub_resources_loaded, this, _1),
parent.get_user_allocator(),
NULL,
&parent );
}
void ogg_file_contents_cook::on_sub_resources_loaded( resources::queries_result& data )
{
R_ASSERT(data.is_successful());
resources::query_result_for_cook* const parent = data.get_parent_query();
resources::managed_resource_ptr ogg_raw_file = data[0].get_managed_resource();
ogg_file_contents* file_contents;
UNMANAGED_NEW( file_contents, ogg_file_contents )( ogg_raw_file );
if ( !file_contents )
{
parent->set_out_of_memory ( resources::unmanaged_memory, sizeof( file_contents ) );
parent->finish_query ( result_out_of_memory );
return;
}
parent->set_unmanaged_resource ( file_contents, resources::nocache_memory, sizeof( file_contents ) );
parent->finish_query ( result_success );
}
void ogg_file_contents_cook::delete_resource( resources::resource_base* res )
{
UNMANAGED_DELETE ( res );
}
} // namespace sound
} // namespace xray
| [
"youalexandrov@icloud.com"
] | youalexandrov@icloud.com |
c90d282622d585070f2a0c6ee117fdd57a49c147 | 412490586f58cd690eea9bb0fdc30bb1fafa79e1 | /test/gtl_test_dtree/gtl_test_dtree.cpp | b96d55a4604f68ff3f47e9153fa6cf8eca406d14 | [] | no_license | xyfigo/gtl | a93e236557fc3eee73fe8025775cef22977be125 | 2468d858dec43d664e7aafa252e1d2b79623fba1 | refs/heads/master | 2020-04-15T15:55:41.025404 | 2017-03-29T04:09:30 | 2017-03-29T04:09:30 | null | 0 | 0 | null | null | null | null | GB18030 | C++ | false | false | 2,032 | cpp | // gtl_test_dtree.cpp : 定义控制台应用程序的入口点。
//
#include "stdafx.h"
#include <vector>
#include <string>
#include "console.h"
#include "spatiotemporalgenerator.h"
extern void prepare_test_data() ;
extern void test_dtree_rstartree_for_points();
extern void test_dtree_rstartree_for_segments();
extern void test_dtree_rstartree_for_trajectories();
extern void test_desompistiontree_tprtree(const std::string& filename);
extern void test_desompistiontree_bplustree();
extern void test_for_trajectories(const std::string& filename);
extern void test_for_trajectories_3d(const std::string& filename);
extern void test_for_future(const std::string& filename);
extern void test_import_brinkhoff( );
extern void test_dtree_bplustree_brinkhoff_100000_1000000();
extern void test_query_performace(const std::string& filename);
std::string _database = "d:\\gtl\\data\\";
gtl::Console<char> g_console;
gtl::Envelope<double,4> _cubeenvelope;
int _cube_size_length ;
int _tmain(int argc, _TCHAR* argv[])
{
_cube_size_length=10000;
for(int i=0;i<4;i++)
{
_cubeenvelope.setLowerBound(i,0);
_cubeenvelope.setUpperBound(i,_cube_size_length);
}
//prepare_test_data();
//test_dtree_rstartree_for_points();
//test_dtree_rstartree_for_segments();
//test_dtree_rstartree_for_trajectories();
//test_desompistiontree_tprtree("delft.mpf");
//test_desompistiontree_bplustree();
//test_for_trajectories("random");
//test_for_trajectories_3d("delft");
//test_for_future("random");
test_import_brinkhoff();
//test_dtree_bplustree_brinkhoff_100000_1000000();
/*test_query_performace("oldenburg100000");
test_query_performace("oldenburg200000");
test_query_performace("oldenburg300000");
test_query_performace("oldenburg400000");
test_query_performace("oldenburg500000");
test_query_performace("oldenburg600000");
test_query_performace("oldenburg700000");
test_query_performace("oldenburg800000");
test_query_performace("oldenburg900000");
test_query_performace("oldenburg1000000");*/
return 0;
}
| [
"zwhe@cug.edu.cn"
] | zwhe@cug.edu.cn |
64629d42b6bacb6ef82916b1c063e1e0baf64b84 | af0ecafb5428bd556d49575da2a72f6f80d3d14b | /CodeJamCrawler/dataset/08_963_50.cpp | 536fc480da82aad4fe1e9fa92f89d2574401a240 | [] | no_license | gbrlas/AVSP | 0a2a08be5661c1b4a2238e875b6cdc88b4ee0997 | e259090bf282694676b2568023745f9ffb6d73fd | refs/heads/master | 2021-06-16T22:25:41.585830 | 2017-06-09T06:32:01 | 2017-06-09T06:32:01 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,989 | cpp |
import java.io.*;
import java.util.*;
class SearchEngine{
public String name;
public int count;
public int pos;
}
class ProblemA {
static final Comparator<SearchEngine> MY_ORDER =
new Comparator<SearchEngine>() {
public int compare(SearchEngine s1, SearchEngine s2) {
/*if(s1.count < s2.count)
return -1;
else if(s1.count == s2.count){
if(s1.pos> s2.pos)
return -1;
else
return 1;
}
else
return 1;*/
if(s1.pos > s2.pos)
return -1;
else if(s1.pos == s2.pos){
if(s1.count < s2.count)
return -1;
else
return 1;
}
else
return 1;
}
};
public static void main (String [] args) throws IOException {
BufferedReader f = new BufferedReader(new FileReader("A-large.in"));
PrintWriter out = new PrintWriter(new BufferedWriter(new FileWriter("test.out")));
int N = Integer.parseInt(f.readLine());
for(int i=1; i<=N; i++){
int S = Integer.parseInt(f.readLine());
SearchEngine searchEng[] = new SearchEngine[S];
for(int j=0; j<S; j++){
searchEng[j] = new SearchEngine();
searchEng[j].name = f.readLine();
searchEng[j].count = 0;
}
ArrayList<String> queries = new ArrayList<String>();
int Q = Integer.parseInt(f.readLine());
for(int j=0; j<Q; j++){
String str = f.readLine();
queries.add(str);
}
int numSwitch = 0;
boolean flag = true;
while(true){
for(int j=0; j<S; j++){
String str = searchEng[j].name;
searchEng[j].count = 0;
for(int k=0; k<queries.size(); k++){
String str2 = queries.get(k);
if(str.equals(str2)){
searchEng[j].count++;
}
}
if(searchEng[j].count == 0){
flag = false;
break;
}
searchEng[j].pos = queries.indexOf(str);
}
if(!flag)
break;
Arrays.sort(searchEng, MY_ORDER);
/*
System.out.println("\nAfter Sort:"+ queries);
for(int j=0; j<S; j++){
System.out.println(searchEng[j].name+": "+searchEng[j].count+": "+searchEng[j].pos);
}*/
if(searchEng[0].count==0 || queries.size()<=0)
break;
numSwitch++;
int n=0;
if(searchEng[0].name.equals(queries.get(0)))
n=1;
for(int k=0; k<searchEng[n].pos; k++){
queries.remove(0);
}
}
out.println("Case #"+i+": "+numSwitch);
}
out.close();
System.exit(0);
}
}
| [
"nikola.mrzljak@fer.hr"
] | nikola.mrzljak@fer.hr |
aad11d3f5b70e484c1bd54371cf80a36723690ef | 6a69d57c782e0b1b993e876ad4ca2927a5f2e863 | /vendor/samsung/common/packages/apps/SBrowser/src/chrome/browser/metrics/variations/variations_service.cc | 5f1baacfb58caeca50c926dce589c1d978dcb71a | [
"BSD-3-Clause"
] | permissive | duki994/G900H-Platform-XXU1BOA7 | c8411ef51f5f01defa96b3381f15ea741aa5bce2 | 4f9307e6ef21893c9a791c96a500dfad36e3b202 | refs/heads/master | 2020-05-16T20:57:07.585212 | 2015-05-11T11:03:16 | 2015-05-11T11:03:16 | 35,418,464 | 2 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 18,546 | cc | // Copyright (c) 2012 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 "chrome/browser/metrics/variations/variations_service.h"
#include <set>
#include "base/build_time.h"
#include "base/command_line.h"
#include "base/metrics/histogram.h"
#include "base/metrics/sparse_histogram.h"
#include "base/prefs/pref_registry_simple.h"
#include "base/prefs/pref_service.h"
#include "base/version.h"
#include "chrome/browser/browser_process.h"
#include "chrome/browser/network_time/network_time_tracker.h"
#include "chrome/common/chrome_switches.h"
#include "chrome/common/pref_names.h"
#include "components/user_prefs/pref_registry_syncable.h"
#include "components/variations/proto/variations_seed.pb.h"
#include "components/variations/variations_seed_processor.h"
#include "content/public/browser/browser_thread.h"
#include "net/base/load_flags.h"
#include "net/base/net_errors.h"
#include "net/base/network_change_notifier.h"
#include "net/base/url_util.h"
#include "net/http/http_response_headers.h"
#include "net/http/http_status_code.h"
#include "net/http/http_util.h"
#include "net/url_request/url_fetcher.h"
#include "net/url_request/url_request_status.h"
#include "ui/base/device_form_factor.h"
#include "url/gurl.h"
#if defined(OS_CHROMEOS)
#include "chrome/browser/chromeos/settings/cros_settings.h"
#endif
namespace chrome_variations {
namespace {
// Default server of Variations seed info.
const char kDefaultVariationsServerURL[] =
"https://clients4.google.com/chrome-variations/seed";
const int kMaxRetrySeedFetch = 5;
// TODO(mad): To be removed when we stop updating the NetworkTimeTracker.
// For the HTTP date headers, the resolution of the server time is 1 second.
const int64 kServerTimeResolutionMs = 1000;
// Wrapper around channel checking, used to enable channel mocking for
// testing. If the current browser channel is not UNKNOWN, this will return
// that channel value. Otherwise, if the fake channel flag is provided, this
// will return the fake channel. Failing that, this will return the UNKNOWN
// channel.
Study_Channel GetChannelForVariations() {
switch (chrome::VersionInfo::GetChannel()) {
case chrome::VersionInfo::CHANNEL_CANARY:
return Study_Channel_CANARY;
case chrome::VersionInfo::CHANNEL_DEV:
return Study_Channel_DEV;
case chrome::VersionInfo::CHANNEL_BETA:
return Study_Channel_BETA;
case chrome::VersionInfo::CHANNEL_STABLE:
return Study_Channel_STABLE;
case chrome::VersionInfo::CHANNEL_UNKNOWN:
break;
}
const std::string forced_channel =
CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
switches::kFakeVariationsChannel);
if (forced_channel == "stable")
return Study_Channel_STABLE;
if (forced_channel == "beta")
return Study_Channel_BETA;
if (forced_channel == "dev")
return Study_Channel_DEV;
if (forced_channel == "canary")
return Study_Channel_CANARY;
DVLOG(1) << "Invalid channel provided: " << forced_channel;
return Study_Channel_UNKNOWN;
}
// Returns a string that will be used for the value of the 'osname' URL param
// to the variations server.
std::string GetPlatformString() {
#if defined(OS_WIN)
return "win";
#elif defined(OS_IOS)
return "ios";
#elif defined(OS_MACOSX)
return "mac";
#elif defined(OS_CHROMEOS)
return "chromeos";
#elif defined(OS_ANDROID)
return "android";
#elif defined(OS_LINUX) || defined(OS_BSD) || defined(OS_SOLARIS)
// Default BSD and SOLARIS to Linux to not break those builds, although these
// platforms are not officially supported by Chrome.
return "linux";
#else
#error Unknown platform
#endif
}
// Gets the restrict parameter from |policy_pref_service| or from Chrome OS
// settings in the case of that platform.
std::string GetRestrictParameterPref(PrefService* policy_pref_service) {
std::string parameter;
#if defined(OS_CHROMEOS)
chromeos::CrosSettings::Get()->GetString(
chromeos::kVariationsRestrictParameter, ¶meter);
#else
if (policy_pref_service) {
parameter =
policy_pref_service->GetString(prefs::kVariationsRestrictParameter);
}
#endif
return parameter;
}
enum ResourceRequestsAllowedState {
RESOURCE_REQUESTS_ALLOWED,
RESOURCE_REQUESTS_NOT_ALLOWED,
RESOURCE_REQUESTS_ALLOWED_NOTIFIED,
RESOURCE_REQUESTS_NOT_ALLOWED_EULA_NOT_ACCEPTED,
RESOURCE_REQUESTS_NOT_ALLOWED_NETWORK_DOWN,
RESOURCE_REQUESTS_NOT_ALLOWED_COMMAND_LINE_DISABLED,
RESOURCE_REQUESTS_ALLOWED_ENUM_SIZE,
};
// Records UMA histogram with the current resource requests allowed state.
void RecordRequestsAllowedHistogram(ResourceRequestsAllowedState state) {
UMA_HISTOGRAM_ENUMERATION("Variations.ResourceRequestsAllowed", state,
RESOURCE_REQUESTS_ALLOWED_ENUM_SIZE);
}
// Converts ResourceRequestAllowedNotifier::State to the corresponding
// ResourceRequestsAllowedState value.
ResourceRequestsAllowedState ResourceRequestStateToHistogramValue(
ResourceRequestAllowedNotifier::State state) {
switch (state) {
case ResourceRequestAllowedNotifier::DISALLOWED_EULA_NOT_ACCEPTED:
return RESOURCE_REQUESTS_NOT_ALLOWED_EULA_NOT_ACCEPTED;
case ResourceRequestAllowedNotifier::DISALLOWED_NETWORK_DOWN:
return RESOURCE_REQUESTS_NOT_ALLOWED_NETWORK_DOWN;
case ResourceRequestAllowedNotifier::DISALLOWED_COMMAND_LINE_DISABLED:
return RESOURCE_REQUESTS_NOT_ALLOWED_COMMAND_LINE_DISABLED;
case ResourceRequestAllowedNotifier::ALLOWED:
return RESOURCE_REQUESTS_ALLOWED;
}
NOTREACHED();
return RESOURCE_REQUESTS_NOT_ALLOWED;
}
// Get current form factor and convert it from enum DeviceFormFactor to enum
// Study_FormFactor.
Study_FormFactor GetCurrentFormFactor() {
switch (ui::GetDeviceFormFactor()) {
case ui::DEVICE_FORM_FACTOR_PHONE:
return Study_FormFactor_PHONE;
case ui::DEVICE_FORM_FACTOR_TABLET:
return Study_FormFactor_TABLET;
case ui::DEVICE_FORM_FACTOR_DESKTOP:
return Study_FormFactor_DESKTOP;
}
NOTREACHED();
return Study_FormFactor_DESKTOP;
}
} // namespace
VariationsService::VariationsService(PrefService* local_state)
: local_state_(local_state),
policy_pref_service_(local_state),
seed_store_(local_state),
create_trials_from_seed_called_(false),
initial_request_completed_(false),
resource_request_allowed_notifier_(
new ResourceRequestAllowedNotifier) {
resource_request_allowed_notifier_->Init(this);
}
VariationsService::VariationsService(ResourceRequestAllowedNotifier* notifier,
PrefService* local_state)
: local_state_(local_state),
policy_pref_service_(local_state),
seed_store_(local_state),
create_trials_from_seed_called_(false),
initial_request_completed_(false),
resource_request_allowed_notifier_(notifier) {
resource_request_allowed_notifier_->Init(this);
}
VariationsService::~VariationsService() {
}
bool VariationsService::CreateTrialsFromSeed() {
create_trials_from_seed_called_ = true;
VariationsSeed seed;
if (!seed_store_.LoadSeed(&seed))
return false;
const int64 date_value = local_state_->GetInt64(prefs::kVariationsSeedDate);
const base::Time seed_date = base::Time::FromInternalValue(date_value);
const base::Time build_time = base::GetBuildTime();
// Use the build time for date checks if either the seed date is invalid or
// the build time is newer than the seed date.
base::Time reference_date = seed_date;
if (seed_date.is_null() || seed_date < build_time)
reference_date = build_time;
const chrome::VersionInfo current_version_info;
if (!current_version_info.is_valid())
return false;
const base::Version current_version(current_version_info.Version());
if (!current_version.IsValid())
return false;
VariationsSeedProcessor().CreateTrialsFromSeed(
seed, g_browser_process->GetApplicationLocale(), reference_date,
current_version, GetChannelForVariations(), GetCurrentFormFactor());
// Log the "freshness" of the seed that was just used. The freshness is the
// time between the last successful seed download and now.
const int64 last_fetch_time_internal =
local_state_->GetInt64(prefs::kVariationsLastFetchTime);
if (last_fetch_time_internal) {
const base::Time now = base::Time::Now();
const base::TimeDelta delta =
now - base::Time::FromInternalValue(last_fetch_time_internal);
// Log the value in number of minutes.
UMA_HISTOGRAM_CUSTOM_COUNTS("Variations.SeedFreshness", delta.InMinutes(),
1, base::TimeDelta::FromDays(30).InMinutes(), 50);
}
return true;
}
void VariationsService::StartRepeatedVariationsSeedFetch() {
DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
// Initialize the Variations server URL.
variations_server_url_ = GetVariationsServerURL(policy_pref_service_);
// Check that |CreateTrialsFromSeed| was called, which is necessary to
// retrieve the serial number that will be sent to the server.
DCHECK(create_trials_from_seed_called_);
DCHECK(!request_scheduler_.get());
// Note that the act of instantiating the scheduler will start the fetch, if
// the scheduler deems appropriate. Using Unretained is fine here since the
// lifespan of request_scheduler_ is guaranteed to be shorter than that of
// this service.
request_scheduler_.reset(VariationsRequestScheduler::Create(
base::Bind(&VariationsService::FetchVariationsSeed,
base::Unretained(this)), local_state_));
request_scheduler_->Start();
}
// TODO(rkaplow): Handle this and the similar event in metrics_service by
// observing an 'OnAppEnterForeground' event in RequestScheduler instead of
// requiring the frontend code to notify each service individually. Since the
// scheduler will handle it directly the VariationService shouldn't need to
// know details of this anymore.
void VariationsService::OnAppEnterForeground() {
request_scheduler_->OnAppEnterForeground();
}
// static
GURL VariationsService::GetVariationsServerURL(
PrefService* policy_pref_service) {
std::string server_url_string(CommandLine::ForCurrentProcess()->
GetSwitchValueASCII(switches::kVariationsServerURL));
if (server_url_string.empty())
server_url_string = kDefaultVariationsServerURL;
GURL server_url = GURL(server_url_string);
const std::string restrict_param =
GetRestrictParameterPref(policy_pref_service);
if (!restrict_param.empty()) {
server_url = net::AppendOrReplaceQueryParameter(server_url,
"restrict",
restrict_param);
}
server_url = net::AppendOrReplaceQueryParameter(server_url, "osname",
GetPlatformString());
DCHECK(server_url.is_valid());
return server_url;
}
#if defined(OS_WIN)
void VariationsService::StartGoogleUpdateRegistrySync() {
registry_syncer_.RequestRegistrySync();
}
#endif
void VariationsService::SetCreateTrialsFromSeedCalledForTesting(bool called) {
create_trials_from_seed_called_ = called;
}
// static
std::string VariationsService::GetDefaultVariationsServerURLForTesting() {
return kDefaultVariationsServerURL;
}
// static
void VariationsService::RegisterPrefs(PrefRegistrySimple* registry) {
VariationsSeedStore::RegisterPrefs(registry);
registry->RegisterInt64Pref(prefs::kVariationsLastFetchTime, 0);
// This preference will only be written by the policy service, which will fill
// it according to a value stored in the User Policy.
registry->RegisterStringPref(prefs::kVariationsRestrictParameter,
std::string());
}
// static
void VariationsService::RegisterProfilePrefs(
user_prefs::PrefRegistrySyncable* registry) {
// This preference will only be written by the policy service, which will fill
// it according to a value stored in the User Policy.
registry->RegisterStringPref(
prefs::kVariationsRestrictParameter,
std::string(),
user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
}
// static
VariationsService* VariationsService::Create(PrefService* local_state) {
#if !defined(GOOGLE_CHROME_BUILD)
// Unless the URL was provided, unsupported builds should return NULL to
// indicate that the service should not be used.
if (!CommandLine::ForCurrentProcess()->HasSwitch(
switches::kVariationsServerURL)) {
DVLOG(1) << "Not creating VariationsService in unofficial build without --"
<< switches::kVariationsServerURL << " specified.";
return NULL;
}
#endif
return new VariationsService(local_state);
}
void VariationsService::DoActualFetch() {
pending_seed_request_.reset(net::URLFetcher::Create(
0, variations_server_url_, net::URLFetcher::GET, this));
pending_seed_request_->SetLoadFlags(net::LOAD_DO_NOT_SEND_COOKIES |
net::LOAD_DO_NOT_SAVE_COOKIES);
pending_seed_request_->SetRequestContext(
g_browser_process->system_request_context());
pending_seed_request_->SetMaxRetriesOn5xx(kMaxRetrySeedFetch);
if (!seed_store_.variations_serial_number().empty()) {
pending_seed_request_->AddExtraRequestHeader(
"If-Match:" + seed_store_.variations_serial_number());
}
pending_seed_request_->Start();
const base::TimeTicks now = base::TimeTicks::Now();
base::TimeDelta time_since_last_fetch;
// Record a time delta of 0 (default value) if there was no previous fetch.
if (!last_request_started_time_.is_null())
time_since_last_fetch = now - last_request_started_time_;
UMA_HISTOGRAM_CUSTOM_COUNTS("Variations.TimeSinceLastFetchAttempt",
time_since_last_fetch.InMinutes(), 0,
base::TimeDelta::FromDays(7).InMinutes(), 50);
last_request_started_time_ = now;
}
void VariationsService::FetchVariationsSeed() {
DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
const ResourceRequestAllowedNotifier::State state =
resource_request_allowed_notifier_->GetResourceRequestsAllowedState();
RecordRequestsAllowedHistogram(ResourceRequestStateToHistogramValue(state));
if (state != ResourceRequestAllowedNotifier::ALLOWED) {
DVLOG(1) << "Resource requests were not allowed. Waiting for notification.";
return;
}
DoActualFetch();
}
void VariationsService::OnURLFetchComplete(const net::URLFetcher* source) {
DCHECK_EQ(pending_seed_request_.get(), source);
const bool is_first_request = !initial_request_completed_;
initial_request_completed_ = true;
// The fetcher will be deleted when the request is handled.
scoped_ptr<const net::URLFetcher> request(pending_seed_request_.release());
const net::URLRequestStatus& request_status = request->GetStatus();
if (request_status.status() != net::URLRequestStatus::SUCCESS) {
UMA_HISTOGRAM_SPARSE_SLOWLY("Variations.FailedRequestErrorCode",
-request_status.error());
DVLOG(1) << "Variations server request failed with error: "
<< request_status.error() << ": "
<< net::ErrorToString(request_status.error());
// It's common for the very first fetch attempt to fail (e.g. the network
// may not yet be available). In such a case, try again soon, rather than
// waiting the full time interval.
if (is_first_request)
request_scheduler_->ScheduleFetchShortly();
return;
}
// Log the response code.
const int response_code = request->GetResponseCode();
UMA_HISTOGRAM_SPARSE_SLOWLY("Variations.SeedFetchResponseCode",
response_code);
const base::TimeDelta latency =
base::TimeTicks::Now() - last_request_started_time_;
base::Time response_date;
if (response_code == net::HTTP_OK ||
response_code == net::HTTP_NOT_MODIFIED) {
bool success = request->GetResponseHeaders()->GetDateValue(&response_date);
DCHECK(success || response_date.is_null());
if (!response_date.is_null()) {
NetworkTimeTracker::BuildNotifierUpdateCallback().Run(
response_date,
base::TimeDelta::FromMilliseconds(kServerTimeResolutionMs),
latency);
}
}
if (response_code != net::HTTP_OK) {
DVLOG(1) << "Variations server request returned non-HTTP_OK response code: "
<< response_code;
if (response_code == net::HTTP_NOT_MODIFIED) {
UMA_HISTOGRAM_MEDIUM_TIMES("Variations.FetchNotModifiedLatency", latency);
RecordLastFetchTime();
// Update the seed date value in local state (used for expiry check on
// next start up), since 304 is a successful response.
local_state_->SetInt64(prefs::kVariationsSeedDate,
response_date.ToInternalValue());
} else {
UMA_HISTOGRAM_MEDIUM_TIMES("Variations.FetchOtherLatency", latency);
}
return;
}
UMA_HISTOGRAM_MEDIUM_TIMES("Variations.FetchSuccessLatency", latency);
std::string seed_data;
bool success = request->GetResponseAsString(&seed_data);
DCHECK(success);
std::string seed_signature;
request->GetResponseHeaders()->EnumerateHeader(NULL,
"X-Seed-Signature",
&seed_signature);
if (seed_store_.StoreSeedData(seed_data, seed_signature, response_date))
RecordLastFetchTime();
}
void VariationsService::OnResourceRequestsAllowed() {
// Note that this only attempts to fetch the seed at most once per period
// (kSeedFetchPeriodHours). This works because
// |resource_request_allowed_notifier_| only calls this method if an
// attempt was made earlier that fails (which implies that the period had
// elapsed). After a successful attempt is made, the notifier will know not
// to call this method again until another failed attempt occurs.
RecordRequestsAllowedHistogram(RESOURCE_REQUESTS_ALLOWED_NOTIFIED);
DVLOG(1) << "Retrying fetch.";
DoActualFetch();
// This service must have created a scheduler in order for this to be called.
DCHECK(request_scheduler_.get());
request_scheduler_->Reset();
}
void VariationsService::RecordLastFetchTime() {
// local_state_ is NULL in tests, so check it first.
if (local_state_) {
local_state_->SetInt64(prefs::kVariationsLastFetchTime,
base::Time::Now().ToInternalValue());
}
}
} // namespace chrome_variations
| [
"duki994@gmail.com"
] | duki994@gmail.com |
fe28f4c622ff0b42bce54fbb6f312013c4c125a4 | ed505166a9c743ef5b897e683a933341cdb6cea8 | /LA/LA5139_RareOrder/main.cpp | 173ae47bb7d7794428f63ae6332d6673085d9e49 | [] | no_license | tada-s/ICPC_Training | fd0e8562d3c4723bf44da2c88c53bbfc8312e108 | 52e3b8ff094744deb454780aac7684a2f3ec7da3 | refs/heads/master | 2021-09-17T12:51:00.917086 | 2018-07-02T02:47:31 | 2018-07-02T02:47:31 | 64,604,455 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,602 | cpp | #include <bits/stdc++.h>
using namespace std;
typedef vector<int> vi;
#define pb push_back
#define n ('Z' - 'A' + 1)
int m[n][n];
bool visited[n];
vi ts;
void init(){
for(int i = 0; i < n; i++){
for(int j = 0; j < n; j++){
m[i][j] = 0;
}
visited[i] = false;
}
}
void toposort(int node){
visited[node] = true;
for(int i = 0; i < n; i++){
if(m[node][i] == 1 && !visited[i]){
toposort(i);
}
}
ts.pb(node);
}
void update(string& str1, string& str2){
int l = min(str1.size(), str2.size());
for(int i = 0; i < l; i++){
if(str1[i] != str2[i]){
int c1 = str1[i] - 'A';
int c2 = str2[i] - 'A';
m[c1][c2] = 1;
break;
}
}
}
int findroot(){
for(int i = 0; i < n; i++){
bool isRoot = false;
for(int j = 0; j < n; j++){
if(m[i][j] == 1){
isRoot = true;
break;
}
}
for(int j = 0; j < n; j++){
if(m[j][i] == 1){
isRoot = false;
break;
}
}
if(isRoot) return i;
}
return 0;
}
int main(){
//freopen("input.txt", "r", stdin);
vector<string> v;
char str[20+1];
init();
scanf("%s", str);
while(str[0] != '#'){
v.pb(str);
scanf("%s", str);
}
for(int i = 0; i < v.size()-1; i++){
update(v[i], v[i+1]);
}
toposort(findroot());
for(int i = ts.size()-1; i >= 0; i--){
printf("%c", ts[i]+'A');
}
printf("\n");
return 0;
}
| [
"akagi.tada@gmail.com"
] | akagi.tada@gmail.com |
8739b7e0f35e69c58bb868479f2952fb892046fd | cd34f29cf3106d4869bb819e57fcb3b0b56eb869 | /src/qt/networkstyle.cpp | 717b9019f265a639ce8c8f7d06b42a313fa85e64 | [
"MIT"
] | permissive | BitcoinBridgeOffical/Bitcoin-Bridge | 026618c6024e3ee3f853d13efdbad4d0a2cd6cea | d800625c9b4b6fe1ddc0f0615a854e43463b82ad | refs/heads/master | 2021-05-12T16:21:43.281020 | 2018-01-10T21:35:40 | 2018-01-10T21:35:40 | 117,009,438 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,107 | cpp | // Copyright (c) 2014-2016 The Bitcoin Core developers
// Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
#include "networkstyle.h"
#include "guiconstants.h"
#include <QApplication>
static const struct {
const char* networkId;
const char* appName;
const int iconColorHueShift;
const int iconColorSaturationReduction;
const char* titleAddText;
} network_styles[] = {
{"main", QAPP_APP_NAME_DEFAULT, 0, 0, ""},
{"test", QAPP_APP_NAME_TESTNET, 70, 30, QT_TRANSLATE_NOOP("SplashScreen", "[testnet]")},
{"regtest", QAPP_APP_NAME_TESTNET, 160, 30, "[regtest]"}};
static const unsigned network_styles_count = sizeof(network_styles) / sizeof(*network_styles);
// titleAddText needs to be const char* for tr()
NetworkStyle::NetworkStyle(const QString& _appName, const int iconColorHueShift, const int iconColorSaturationReduction, const char* _titleAddText) : appName(_appName),
titleAddText(qApp->translate("SplashScreen", _titleAddText))
{
// load pixmap
QPixmap pixmap(":/icons/bitcoinbridge");
if (iconColorHueShift != 0 && iconColorSaturationReduction != 0) {
// generate QImage from QPixmap
QImage img = pixmap.toImage();
int h, s, l, a;
// traverse though lines
for (int y = 0; y < img.height(); y++) {
QRgb* scL = reinterpret_cast<QRgb*>(img.scanLine(y));
// loop through pixels
for (int x = 0; x < img.width(); x++) {
// preserve alpha because QColor::getHsl doesen't return the alpha value
a = qAlpha(scL[x]);
QColor col(scL[x]);
// get hue value
col.getHsl(&h, &s, &l);
// rotate color on RGB color circle
// 70° should end up with the typical "testnet" green
h += iconColorHueShift;
// change saturation value
if (s > iconColorSaturationReduction) {
s -= iconColorSaturationReduction;
}
col.setHsl(h, s, l, a);
// set the pixel
scL[x] = col.rgba();
}
}
//convert back to QPixmap
#if QT_VERSION >= 0x040700
pixmap.convertFromImage(img);
#else
pixmap = QPixmap::fromImage(img);
#endif
}
appIcon = QIcon(pixmap);
trayAndWindowIcon = QIcon(pixmap.scaled(QSize(256, 256)));
}
const NetworkStyle* NetworkStyle::instantiate(const QString& networkId)
{
for (unsigned x = 0; x < network_styles_count; ++x) {
if (networkId == network_styles[x].networkId) {
return new NetworkStyle(
network_styles[x].appName,
network_styles[x].iconColorHueShift,
network_styles[x].iconColorSaturationReduction,
network_styles[x].titleAddText);
}
}
return 0;
}
| [
"info@thebitcoinbridge.com"
] | info@thebitcoinbridge.com |
98b510af580ee1d5bd4d491ea9089da7c5c76091 | 8e8632a45f90a790490c581a01b276e0f7e5aad8 | /wxbookexamples/改寫測試/wxbooke_02_01/wxbooke_02_01Main.h | ea5eaabe3bee86d622a5bbc92daee4a1f9230819 | [] | no_license | t2o0n321/Jash_LinuxC | bde6f51753bc23dd3cf8e3530fe080d492fc0554 | 8a53cf0cdaa610f0fd74e86e988f7ea7f30e95d8 | refs/heads/master | 2023-05-12T23:17:11.111674 | 2021-06-04T14:02:42 | 2021-06-04T14:02:42 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,131 | h | /***************************************************************
* Name: wxbooke_02_01Main.h
* Purpose: Defines Application Frame
* Author: jash.liao (jash.liao@gmail.com)
* Created: 2014-12-05
* Copyright: jash.liao (http://jashliao.pixnet.net/blog)
* License:
**************************************************************/
#ifndef WXBOOKE_02_01MAIN_H
#define WXBOOKE_02_01MAIN_H
#ifndef WX_PRECOMP
#include <wx/wx.h>
#endif
#include "wxbooke_02_01App.h"
#include <wx/button.h>
#include <wx/statline.h>
class wxbooke_02_01Dialog: public wxDialog
{
public:
wxbooke_02_01Dialog(wxDialog *dlg, const wxString& title);
~wxbooke_02_01Dialog();
protected:
enum
{
idBtnQuit = 1000,
idBtnAbout
};
wxStaticText* m_staticText1;
wxButton* BtnAbout;
wxStaticLine* m_staticline1;
wxButton* BtnQuit;
private:
void OnClose(wxCloseEvent& event);
void OnQuit(wxCommandEvent& event);
void OnAbout(wxCommandEvent& event);
DECLARE_EVENT_TABLE()
};
#endif // WXBOOKE_02_01MAIN_H
| [
"jash.liao@gmail.com"
] | jash.liao@gmail.com |
9a8ffa149ce97f431b2d207a7085f5fc1e24fb75 | e9094a72140f9d1509d02880776247a7dca6d6db | /game_framework/T94.cpp | 2a183a7ea261b5742a88ce210c838692583474fc | [] | no_license | Becktor/cpluscourse | 552cfa1e86cb4265e237404826a2c8db3ea77332 | cb8259a032ab9ec77ee1f68242d4f98a419f2697 | refs/heads/master | 2016-09-06T03:12:57.874972 | 2015-05-03T11:55:49 | 2015-05-03T11:55:49 | 34,984,260 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 415 | cpp | // Skeleton of implementation file for groups
#include "game.h"
#include "field.h"
#include "T94.h"
//////////////////////////////
T94::
T94(ISceneManager* smgr,
IVideoDriver* driver,
int x, int y, playground pg)
: Wall(smgr,driver,x,y,pg)
// calling the parent constructor
// (if you implement a Floor Field, replace "Wall" with "Floor")
{
} ;
fieldtype T94::getFieldType(){
return tT94;
}
| [
"JonathanBecktor@gmail.com"
] | JonathanBecktor@gmail.com |
ee1d000027f1113750ff907485ca7ef40bc7d65e | 6634672675b20366c2b1615d16bf2473df4f1928 | /WordFrequenciesClient.hpp | d07de1847c3495cb987dedbe0b24c85d4cfcfb6b | [] | no_license | alonemanuel/multi-threading-huji | 1a21e14bc53672523fd4596f6b3f7f8dcfc4c7f7 | fc013effc7d9d9b50a481244b91fdef76f1ea4ef | refs/heads/master | 2020-05-12T15:19:01.488928 | 2019-05-12T21:47:45 | 2019-05-12T21:47:45 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,149 | hpp | #ifndef OS_EX3_WORDFREQUENCIESCLIENT_HPP
#define OS_EX3_WORDFREQUENCIESCLIENT_HPP
#include <fstream>
#include <iostream>
#include <sstream>
#include <unistd.h>
#include "MapReduceClient.h"
#include "MapReduceFramework.h"
const int SLEEP_US = 20;
class Line : public K1
{
private:
const std::string line;
public:
Line(const std::string &line) : line(line)
{}
virtual bool operator<(const K1 &other) const
{
return this->line < ((Line &) other).line;
}
const std::string &getLine()
{
return line;
}
};
class Word : public K2, public K3
{
private:
const std::string word;
public:
Word(const std::string &word) : word(word)
{}
Word(const Word &other) = default;
virtual bool operator<(const K2 &other) const
{
return this->word < ((Word &) other).word;
}
virtual bool operator<(const K3 &other) const
{
return this->word < ((Word &) other).word;
}
const std::string &getWord()
{
return word;
}
};
class Integer : public V3
{
public:
int val;
Integer(int val) : val(val)
{}
};
class MapReduceWordFrequencies : public MapReduceClient
{
virtual void map(const K1 *const key, const V1 *const val, void *context) const
{
std::stringstream sstream(((Line *) key)->getLine());
std::string word;
while (sstream >> word)
{
Word *k2 = new Word(word);
emit2(k2, nullptr, context);
usleep(SLEEP_US);
}
delete key;
delete val;
}
virtual void reduce(const IntermediateVec *pairs, void *context) const
{
Word *k3 = new Word(((Word &) *(pairs->front().first)));
auto *frequency = new Integer(static_cast<int>(pairs->size()));
emit3(k3, frequency, context);
usleep(SLEEP_US * 5);
for (auto pair: *pairs)
{
delete pair.first;
delete pair.second;
}
// delete pairs;
}
};
#endif //OS_EX3_WORDFREQUENCIESCLIENT_HPP
| [
"alonemanuel@cs.huji.ac.il"
] | alonemanuel@cs.huji.ac.il |
cf78c014a521353aa199e5fabc6f60f0e2e31fcd | 633b3e358aff91a61bc29eea4302c9fd4e6f1f3b | /libs/liballocator/SmallObjAllocator.cpp | 235972e6467009a25202e80aa9be6ae96794e93d | [] | no_license | chupacabra007/otus-cpp | ccf6bcbc256f663fd340e3155768fcac0e657ff6 | fddbb2e96361b724655bb441eaf39aec9e6519f5 | refs/heads/master | 2021-05-06T05:55:05.084418 | 2018-02-06T20:40:23 | 2018-02-06T20:40:23 | 115,260,580 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 771 | cpp | #include "SmallObjAllocator.h"
SmallObjAllocator::SmallObjAllocator(size_t pageSize, size_t maxObjectSize_):
pool(nullptr),
maxObjectSize(maxObjectSize_)
{
pool = new FixedAllocator[maxObjectSize];
for (size_t i = 0; i < maxObjectSize; ++i)
{
pool[i].init(i + 1, pageSize);
}
}
void* SmallObjAllocator::allocate(size_t numBytes) {
if (numBytes > maxObjectSize)
{
return ::operator new(numBytes);
}
FixedAllocator& alloc = pool[numBytes-1];
return alloc.allocate();
}
void SmallObjAllocator::deallocate(void* p, size_t numBytes)
{
if (numBytes > maxObjectSize)
{
::operator delete(p);
return;
}
FixedAllocator& alloc = pool[numBytes-1];
alloc.deallocate(p);
} | [
"chupakabra007@mail.ru"
] | chupakabra007@mail.ru |
31e42057078c2e96d2eb1f1665b1a83472b2b380 | 2111c990abf908d53d89cc3646628b463f35f5f6 | /第三次上机第二题/第三次上机第二题.h | 24dcae16e6e7a0ac46da772e3fe186776697e556 | [] | no_license | kc345ws/Data | c81783260c7504236150d52602c24e7643256a7d | 2913abc0642e6d0a79a2a84c365eb90cc0d8fa97 | refs/heads/master | 2020-04-09T04:21:29.211599 | 2018-12-16T13:39:02 | 2018-12-16T13:39:02 | 160,019,235 | 0 | 0 | null | null | null | null | GB18030 | C++ | false | false | 403 | h | #pragma once
#ifndef _HEAD
#define _HEAD
class SortingAlgorithm
{
private:
int *Data;
int SortNumber;
int Times;//比较次数
public:
SortingAlgorithm();
void QSort(int *data,int m, int n);//快速排序算法
int Partition(int *Data, int m , int n);//分划算法
int ReturnSortNumber() { return SortNumber; }
int *ReturnData() { return Data; }
int ReturnTimes() { return Times; }
};
#endif | [
"598043446@qq.com"
] | 598043446@qq.com |
8d379da27ec924906704f60cea943579b47cb997 | c5bbed363b5d4e887271faeb0361ae7ac6af8b82 | /dp/geeksForGeeksProblems/Easy Problems/bellNumbers.cpp | 9cf8b7931e92743ca8e878aca739fac29b6d9cd8 | [] | no_license | adityachoudharyclg/codingFinalYear | f78be4d59086b1166274c1b0dece714d680c0acb | 9098ce79c65ec0e816b0c801a401a07c98eeb1af | refs/heads/master | 2023-02-12T21:45:22.026770 | 2020-12-31T23:46:49 | 2020-12-31T23:46:49 | 266,867,584 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 636 | cpp | #include <bits/stdc++.h>
#define ll long long
#define m 1000000007
using namespace std;
ll solve(int n) {
ll dp[100][100] = {0};
dp[1][1] = 1LL;
for (int i = 2; i <= n; i++) {
for (int j = 1; j <= i; j++) {
dp[i][j] += j * dp[i - 1][j] * 1LL + dp[i - 1][j - 1] * 1LL;
}
}
ll ans = 0;
for (int i = 0; i <= n; i++) {
ans += dp[n][i];
}
return ans;
}
int main() {
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
cout << solve(n)<<endl;
}
return 0;
} | [
"33027155+adityachoudary54@users.noreply.github.com"
] | 33027155+adityachoudary54@users.noreply.github.com |
9fc70cb3b442867d9105d1a2e4e0944cca504bb9 | dad3f1ab5de71704cf89a0c3f6c09eaa1e5d088a | /escultorabstrato/putellipsoid.h | efe0dd6d84d905690b7ece8153efa1049940c8e5 | [] | no_license | ricardomvv/EscultorParte2 | 788f353ea6f03e7bd391a7e973f4157ceae419c2 | 2e4795d574d6fd69256268f6aa706933fea7a618 | refs/heads/master | 2020-05-25T01:43:11.793036 | 2019-05-20T13:12:22 | 2019-05-20T13:12:22 | 187,562,547 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 402 | h | #ifndef PUTELLIPSOID_H
#define PUTELLIPSOID_H
#include "figurageometrica.h"
class putEllipsoid : public FiguraGeometrica{
protected:
int xcenter, ycenter, zcenter, rx, ry, rz;
float r,g,b,a;
public:
putEllipsoid(int _xc, int _yc, int _zc, int radx, int rady, int radz, float _r, float _g, float _b, float _a);
void draw(sculptor &t);
~putEllipsoid();
};
#endif // PUTELLIPSOID_H
| [
"ricardomvvarela@gmail.com"
] | ricardomvvarela@gmail.com |
5882c3b6e62727556914ba3d16ff0dd92340af48 | 189e2ed9b5ad2b5a0a9f0528a91af1b5e2d91190 | /src/http/v2/H2Frame.cpp | 45057872563ea1c9e25b5205e0e6e01301a38298 | [
"MIT"
] | permissive | dyu/kuma | 8c89d72d6e9c14dfb43dfc3a9c388682aa8cd81d | 2377cc967f491f27b20aa0952f092268c01f2c46 | refs/heads/master | 2021-01-21T12:11:11.693599 | 2017-08-23T10:00:34 | 2017-08-23T10:00:34 | 102,046,542 | 1 | 0 | null | 2017-08-31T21:21:24 | 2017-08-31T21:21:23 | null | UTF-8 | C++ | false | false | 14,635 | cpp | /* Copyright (c) 2016, Fengping Bao <jamol@live.com>
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS" 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.
*/
#include "H2Frame.h"
#include "util/util.h"
using namespace kuma;
//////////////////////////////////////////////////////////////////////////
int FrameHeader::encode(uint8_t *dst, size_t len)
{
if (!dst || len < H2_FRAME_HEADER_SIZE) {
return -1;
}
encode_u24(dst, length_);
dst[3] = type_;
dst[4] = flags_;
encode_u32(dst + 5, stream_id_);
return H2_FRAME_HEADER_SIZE;
}
bool FrameHeader::decode(const uint8_t *src, size_t len)
{
if (!src || len < H2_FRAME_HEADER_SIZE) {
return false;
}
if (src[5] & 0x80) { // check reserved bit
}
length_ = decode_u24(src);
type_ = src[3];
flags_ = src[4];
stream_id_ = decode_u32(src + 5) & 0x7FFFFFFF;
return true;
}
//////////////////////////////////////////////////////////////////////////
void H2Frame::setFrameHeader(const FrameHeader &hdr)
{
hdr_ = hdr;
}
int H2Frame::encodeHeader(uint8_t *dst, size_t len, FrameHeader &hdr)
{
return hdr.encode(dst, len);
}
int H2Frame::encodeHeader(uint8_t *dst, size_t len)
{
hdr_.setType(type());
hdr_.setLength((uint32_t)calcPayloadSize());
return hdr_.encode(dst, len);
}
H2Error H2Frame::decodePriority(const uint8_t *src, size_t len, h2_priority_t &pri)
{
if (len < H2_PRIORITY_PAYLOAD_SIZE) {
return H2Error::FRAME_SIZE_ERROR;
}
pri.stream_id = decode_u32(src);
pri.exclusive = !!(pri.stream_id & 0x80000000);
pri.stream_id &= 0x7FFFFFFF;
pri.weight = (uint16_t)(src[4]) + 1;
return H2Error::NOERR;
}
int H2Frame::encodePriority(uint8_t *dst, size_t len, h2_priority_t pri)
{
if (len < H2_PRIORITY_PAYLOAD_SIZE) {
return -1;
}
pri.stream_id &= 0x7FFFFFFF;
if (pri.exclusive) {
pri.stream_id |= 0x80000000;
}
encode_u32(dst, pri.stream_id);
dst[4] = (uint8_t)pri.weight;
return H2_PRIORITY_PAYLOAD_SIZE;
}
//////////////////////////////////////////////////////////////////////////
int DataFrame::encode(uint8_t *dst, size_t len)
{
uint8_t *ptr = dst;
const uint8_t *end = dst + len;
int ret = H2Frame::encodeHeader(ptr, end - ptr);
if (ret < 0) {
return ret;
}
ptr += ret;
if (end - ptr < size_) {
return -1;
}
memcpy(ptr, data_, size_);
ptr += size_;
return int(ptr - dst);
}
H2Error DataFrame::decode(const FrameHeader &hdr, const uint8_t *payload)
{
setFrameHeader(hdr);
if (hdr.getStreamId() == 0) {
return H2Error::PROTOCOL_ERROR;
}
const uint8_t *ptr = payload;
uint32_t len = hdr.getLength();
uint8_t pad_len = 0;
if (hdr.getFlags() & H2_FRAME_FLAG_PADDED) {
pad_len = *ptr++;
if (pad_len >= len) {
return H2Error::PROTOCOL_ERROR;
}
len -= pad_len + 1;
}
data_ = ptr;
size_ = len;
return H2Error::NOERR;
}
H2Error HeadersFrame::decode(const FrameHeader &hdr, const uint8_t *payload)
{
setFrameHeader(hdr);
if (hdr.getStreamId() == 0) {
return H2Error::PROTOCOL_ERROR;
}
const uint8_t *ptr = payload;
size_t len = hdr.getLength();
uint8_t pad_len = 0;
if (hdr.getFlags() & H2_FRAME_FLAG_PADDED) {
pad_len = *ptr++;
if (pad_len >= len) {
return H2Error::PROTOCOL_ERROR;
}
len -= pad_len + 1;
}
if (hdr.getFlags() & H2_FRAME_FLAG_PRIORITY) {
H2Error err = decodePriority(ptr, len, pri_);
if (err != H2Error::NOERR) {
return err;
}
ptr += H2_PRIORITY_PAYLOAD_SIZE;
len -= H2_PRIORITY_PAYLOAD_SIZE;
}
block_ = ptr;
bsize_ = len;
return H2Error::NOERR;
}
int HeadersFrame::encode(uint8_t *dst, size_t len, size_t bsize)
{
uint8_t *ptr = dst;
const uint8_t *end = dst + len;
bsize_ = bsize;
int ret = H2Frame::encodeHeader(ptr, end - ptr);
if (ret < 0) {
return ret;
}
ptr += ret;
if (hasPriority()) {
ret = encodePriority(ptr, end - ptr, pri_);
if (ret < 0) {
return ret;
}
ptr += ret;
}
return int(ptr - dst);
}
int HeadersFrame::encode(uint8_t *dst, size_t len)
{
uint8_t *ptr = dst;
const uint8_t *end = dst + len;
int ret = H2Frame::encodeHeader(ptr, end - ptr);
if (ret < 0) {
return ret;
}
ptr += ret;
if (hasPriority()) {
ret = encodePriority(ptr, end - ptr, pri_);
if (ret < 0) {
return ret;
}
ptr += ret;
}
if (end - ptr < bsize_) {
return -1;
}
memcpy(ptr, block_, bsize_);
ptr += bsize_;
return int(ptr - dst);
}
H2Error PriorityFrame::decode(const FrameHeader &hdr, const uint8_t *payload)
{
setFrameHeader(hdr);
if (hdr.getStreamId() == 0) {
return H2Error::PROTOCOL_ERROR;
}
const uint8_t *ptr = payload;
size_t len = hdr.getLength();
return decodePriority(ptr, len, pri_);
}
int PriorityFrame::encode(uint8_t *dst, size_t len)
{
uint8_t *ptr = dst;
const uint8_t *end = dst + len;
int ret = H2Frame::encodeHeader(ptr, end - ptr);
if (ret < 0) {
return ret;
}
ptr += ret;
ret = encodePriority(ptr, end - ptr, pri_);
if (ret < 0) {
return ret;
}
ptr += ret;
return int(ptr - dst);
}
H2Error RSTStreamFrame::decode(const FrameHeader &hdr, const uint8_t *payload)
{
setFrameHeader(hdr);
if (hdr.getStreamId() == 0) {
return H2Error::PROTOCOL_ERROR;
}
if (hdr.getLength() != 4) {
return H2Error::FRAME_SIZE_ERROR;
}
err_code_ = decode_u32(payload);
return H2Error::NOERR;
}
int RSTStreamFrame::encode(uint8_t *dst, size_t len)
{
uint8_t *ptr = dst;
const uint8_t *end = dst + len;
int ret = H2Frame::encodeHeader(ptr, end - ptr);
if (ret < 0) {
return ret;
}
ptr += ret;
encode_u32(ptr, err_code_);
ptr += 4;
return int(ptr - dst);
}
int SettingsFrame::encodePayload(uint8_t *dst, size_t len, ParamVector ¶ms)
{
uint8_t *ptr = dst;
const uint8_t *end = dst + len;
for (auto &p : params) {
if (ptr + 6 > end) {
return -1;
}
encode_u16(ptr, p.first);
ptr += 2;
encode_u32(ptr, p.second);
ptr += 4;
}
return int(ptr - dst);
}
int SettingsFrame::encode(uint8_t *dst, size_t len)
{
uint8_t *ptr = dst;
const uint8_t *end = dst + len;
int ret = H2Frame::encodeHeader(ptr, end - ptr);
if (ret < 0) {
return ret;
}
ptr += ret;
ret = encodePayload(ptr, end - ptr, params_);
if (ret < 0) {
return ret;
}
ptr += ret;
return int(ptr - dst);
}
H2Error SettingsFrame::decode(const FrameHeader &hdr, const uint8_t *payload)
{
setFrameHeader(hdr);
if (hdr.getStreamId() != 0) {
return H2Error::PROTOCOL_ERROR;
}
if (isAck() && hdr.getLength() != 0) {
return H2Error::FRAME_SIZE_ERROR;
}
if (hdr.getLength() % 6 != 0) {
return H2Error::FRAME_SIZE_ERROR;
}
const uint8_t *ptr = payload;
uint32_t len = hdr.getLength();
params_.clear();
while (len > 0) {
uint16_t id = decode_u16(ptr);
uint32_t val = decode_u32(ptr + 2);
params_.push_back(std::make_pair(id, val));
ptr += 6;
len -= 6;
}
return H2Error::NOERR;
}
int PushPromiseFrame::encode(uint8_t *dst, size_t len)
{
uint8_t *ptr = dst;
const uint8_t *end = dst + len;
int ret = H2Frame::encodeHeader(ptr, end - ptr);
if (ret < 0) {
return ret;
}
ptr += ret;
if (len - ret < calcPayloadSize()) {
return -1;
}
encode_u32(ptr, prom_stream_id_);
ptr += 4;
if (block_ && bsize_ > 0) {
memcpy(ptr, block_, bsize_);
ptr += bsize_;
}
return int(ptr - dst);
}
H2Error PushPromiseFrame::decode(const FrameHeader &hdr, const uint8_t *payload)
{
setFrameHeader(hdr);
if (hdr.getStreamId() == 0) {
return H2Error::PROTOCOL_ERROR;
}
const uint8_t *ptr = payload;
uint32_t len = hdr.getLength();
uint8_t pad_len = 0;
if (hdr.getFlags() & H2_FRAME_FLAG_PADDED) {
pad_len = *ptr++;
if (pad_len >= len) {
return H2Error::PROTOCOL_ERROR;
}
len -= pad_len + 1;
}
if (len < 4) {
return H2Error::FRAME_SIZE_ERROR;
}
prom_stream_id_ = decode_u32(ptr) & 0x7FFFFFFF;
ptr += 4;
len -= 4;
if (len > 0) {
block_ = ptr;
bsize_ = len;
}
return H2Error::NOERR;
}
int PingFrame::encode(uint8_t *dst, size_t len)
{
uint8_t *ptr = dst;
const uint8_t *end = dst + len;
int ret = H2Frame::encodeHeader(ptr, end - ptr);
if (ret < 0) {
return ret;
}
ptr += ret;
if (len - ret < H2_PING_PAYLOAD_SIZE) {
return -1;
}
memcpy(ptr, data_, H2_PING_PAYLOAD_SIZE);
ptr += H2_PING_PAYLOAD_SIZE;
return int(ptr - dst);
}
H2Error PingFrame::decode(const FrameHeader &hdr, const uint8_t *payload)
{
setFrameHeader(hdr);
if (hdr.getStreamId() != 0) {
return H2Error::PROTOCOL_ERROR;
}
if (hdr.getLength() != H2_PING_PAYLOAD_SIZE) {
return H2Error::FRAME_SIZE_ERROR;
}
memcpy(data_, payload, hdr.getLength());
return H2Error::NOERR;
}
void PingFrame::setData(const uint8_t *data, size_t len)
{
if (len != H2_PING_PAYLOAD_SIZE) {
return;
}
memcpy(data_, data, H2_PING_PAYLOAD_SIZE);
}
int GoawayFrame::encode(uint8_t *dst, size_t len)
{
uint8_t *ptr = dst;
const uint8_t *end = dst + len;
int ret = H2Frame::encodeHeader(ptr, end - ptr);
if (ret < 0) {
return ret;
}
ptr += ret;
if (len - ret < calcPayloadSize()) {
return -1;
}
encode_u32(ptr, last_stream_id_);
ptr += 4;
encode_u32(ptr, err_code_);
ptr += 4;
if (size_ > 0) {
memcpy(ptr, data_, size_);
ptr += size_;
}
return int(ptr - dst);
}
H2Error GoawayFrame::decode(const FrameHeader &hdr, const uint8_t *payload)
{
setFrameHeader(hdr);
if (hdr.getStreamId() != 0) {
return H2Error::PROTOCOL_ERROR;
}
if (hdr.getLength() < 8) {
return H2Error::FRAME_SIZE_ERROR;
}
const uint8_t *ptr = payload;
uint32_t len = hdr.getLength();
last_stream_id_ = decode_u32(ptr) & 0x7FFFFFFF;
ptr += 4;
len -= 4;
err_code_ = decode_u32(ptr);
ptr += 4;
len -= 4;
if (len > 0) {
data_ = ptr;
size_ = len;
}
return H2Error::NOERR;
}
int WindowUpdateFrame::encode(uint8_t *dst, size_t len)
{
uint8_t *ptr = dst;
const uint8_t *end = dst + len;
int ret = H2Frame::encodeHeader(ptr, end - ptr);
if (ret < 0) {
return ret;
}
ptr += ret;
if (len - ret < calcPayloadSize()) {
return -1;
}
encode_u32(ptr, window_size_increment_);
ptr += 4;
return int(ptr - dst);
}
H2Error WindowUpdateFrame::decode(const FrameHeader &hdr, const uint8_t *payload)
{
setFrameHeader(hdr);
if (hdr.getLength() != 4) {
return H2Error::FRAME_SIZE_ERROR;
}
window_size_increment_ = decode_u32(payload) & 0x7FFFFFFF;
return H2Error::NOERR;
}
int ContinuationFrame::encode(uint8_t *dst, size_t len)
{
uint8_t *ptr = dst;
const uint8_t *end = dst + len;
int ret = H2Frame::encodeHeader(ptr, end - ptr);
if (ret < 0) {
return ret;
}
ptr += ret;
if (len - ret < calcPayloadSize()) {
return -1;
}
if (block_ && bsize_ > 0) {
memcpy(ptr, block_, bsize_);
ptr += bsize_;
}
return int(ptr - dst);
}
H2Error ContinuationFrame::decode(const FrameHeader &hdr, const uint8_t *payload)
{
setFrameHeader(hdr);
if (hdr.getStreamId() == 0) {
return H2Error::PROTOCOL_ERROR;
}
const uint8_t *ptr = payload;
uint32_t len = hdr.getLength();
block_ = ptr;
bsize_ = len;
return H2Error::NOERR;
}
KUMA_NS_BEGIN
const std::string& H2FrameTypeToString(H2FrameType type)
{
#define CASE_FRAME_TYPE(TYPE) \
case H2FrameType::TYPE: { \
static const std::string str_frame_type(#TYPE); \
return str_frame_type; \
}
static const std::string unknown_type = "Unknown";
switch (type) {
CASE_FRAME_TYPE(DATA);
CASE_FRAME_TYPE(HEADERS);
CASE_FRAME_TYPE(PRIORITY);
CASE_FRAME_TYPE(RST_STREAM);
CASE_FRAME_TYPE(SETTINGS);
CASE_FRAME_TYPE(PUSH_PROMISE);
CASE_FRAME_TYPE(PING);
CASE_FRAME_TYPE(GOAWAY);
CASE_FRAME_TYPE(WINDOW_UPDATE);
CASE_FRAME_TYPE(CONTINUATION);
default:
return unknown_type;
}
#undef CASE_FRAME_TYPE
}
KUMA_NS_END
| [
"jamol@live.com"
] | jamol@live.com |
4b545de9e015f13f14684110c2d906836ee485b4 | 0fe27e6c63a755fe7df003f36acc079490a338f3 | /src/cpp/Valid-Triangle-Number.cpp | b387c0c42625286a2a920e1027ccf196356fd097 | [] | no_license | Finalcheat/leetcode | 83f9ceb7bd10783554133434347803a41260a713 | 985deb6142c6841aa7025c9b582010b33f694e6c | refs/heads/master | 2022-11-11T22:51:42.666150 | 2022-11-05T03:07:31 | 2022-11-05T03:07:31 | 53,241,690 | 2 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 1,566 | cpp | /**
* @file Valid-Triangle-Number.cpp
* @brief 有效的三角形边长(https://leetcode.com/problems/valid-triangle-number/description/)
* @author Finalcheat
* @date 2018-06-07
*/
/**
* Given an array consists of non-negative integers, your task is to count the number of triplets chosen from the array that can make triangles if we take them as side lengths of a triangle.
* Example 1:
* Input: [2,2,3,4]
* Output: 3
* Explanation:
* Valid combinations are:
* 2,3,4 (using the first 2)
* 2,3,4 (using the second 2)
* 2,2,3
*/
/**
* 一个三角形中，任意两边之和大于第三边，任意两边之差小于第三边。
* 利用这个规则循环遍历即可，先排序可减少遍历次数。
*/
class Solution {
public:
int triangleNumber(vector<int>& nums) {
std::sort(nums.begin(), nums.end());
int count = 0;
for (size_t i = 0; i < nums.size(); ++i) {
int first = nums[i];
for (size_t j = i + 1; j < nums.size(); ++j) {
int second = nums[j];
for (size_t k = j + 1; k < nums.size(); ++k) {
int third = nums[k];
if ((first + second) <= third) {
continue;
}
if (std::abs(first - third) >= second) {
break;
}
++count;
}
}
}
return count;
}
};
| [
"finalcheat@gmail.com"
] | finalcheat@gmail.com |
84058df919e9bb7c4335647a4f950200bcb6453c | a82db4d04c2e02777db581fcf25a70ea6906930f | /src/SOS/extensions/extensions.cpp | 0a5ca791f7bed71e0405c7cb6a29e59ceb7c2b9d | [
"MIT"
] | permissive | kkokosa/diagnostics | daaf467e766708ebd760708420c6d192964931d2 | fff5a538c23a80c3b1545bfe93481329e359189f | refs/heads/main | 2023-07-14T13:26:26.427548 | 2021-08-19T12:59:18 | 2021-08-19T12:59:18 | 398,265,337 | 1 | 0 | MIT | 2021-08-20T12:13:42 | 2021-08-20T12:13:42 | null | UTF-8 | C++ | false | false | 5,910 | cpp | // Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.
#include <windows.h>
#include <psapi.h>
#include <tchar.h>
#include <limits.h>
#include "target.h"
#include "arrayholder.h"
#include "extensions.h"
// Error output.
#define DEBUG_OUTPUT_ERROR 0x00000002
extern void UninitializeDesktopClrHost();
Extensions* Extensions::s_extensions = nullptr;
/// <summary>
/// The extension host initialize callback function
/// </summary>
/// <param name="punk">IUnknown</param>
/// <returns>error code</returns>
extern "C" HRESULT InitializeHostServices(
IUnknown* punk)
{
return Extensions::GetInstance()->InitializeHostServices(punk);
}
/// <summary>
/// Creates a new Extensions instance
/// </summary>
/// <param name="pDebuggerServices">debugger service or nullptr</param>
Extensions::Extensions(IDebuggerServices* pDebuggerServices) :
m_pHost(nullptr),
m_pTarget(nullptr),
m_pDebuggerServices(pDebuggerServices),
m_pHostServices(nullptr),
m_pSymbolService(nullptr)
{
if (pDebuggerServices != nullptr)
{
pDebuggerServices->AddRef();
}
}
/// <summary>
/// Cleans up the Extensions instance on debugger exit
/// </summary>
Extensions::~Extensions()
{
DestroyTarget();
if (m_pHost != nullptr)
{
m_pHost->Release();
m_pHost = nullptr;
}
if (m_pDebuggerServices != nullptr)
{
m_pDebuggerServices->Release();
m_pDebuggerServices = nullptr;
}
if (m_pSymbolService != nullptr)
{
m_pSymbolService->Release();
m_pSymbolService = nullptr;
}
if (m_pHostServices != nullptr)
{
m_pHostServices->Uninitialize();
m_pHostServices->Release();
m_pHostServices = nullptr;
}
s_extensions = nullptr;
}
/// <summary>
/// The extension host initialize callback function
/// </summary>
/// <param name="punk">IUnknown</param>
/// <returns>error code</returns>
HRESULT Extensions::InitializeHostServices(
IUnknown* punk)
{
if (m_pDebuggerServices == nullptr)
{
return E_INVALIDARG;
}
HRESULT hr = punk->QueryInterface(__uuidof(IHostServices), (void**)&m_pHostServices);
if (FAILED(hr)) {
return hr;
}
hr = m_pHostServices->GetHost(&m_pHost);
if (FAILED(hr)) {
return hr;
}
hr = m_pHostServices->RegisterDebuggerServices(m_pDebuggerServices);
if (FAILED(hr)) {
return hr;
}
ULONG processId = 0;
if (FAILED(m_pDebuggerServices->GetCurrentProcessSystemId(&processId)))
{
m_pHostServices->DestroyTarget();
return S_OK;
}
return m_pHostServices->UpdateTarget(processId);
}
/// <summary>
/// Returns the extension service interface or null
/// </summary>
IHostServices* Extensions::GetHostServices()
{
if (m_pHostServices == nullptr)
{
IHost* host = GetHost();
if (m_pHostServices == nullptr && host != nullptr)
{
host->GetService(__uuidof(IHostServices), (void**)&m_pHostServices);
}
}
return m_pHostServices;
}
/// <summary>
/// Returns the symbol service instance
/// </summary>
ISymbolService* Extensions::GetSymbolService()
{
if (m_pSymbolService == nullptr)
{
GetHost()->GetService(__uuidof(ISymbolService), (void**)&m_pSymbolService);
}
return m_pSymbolService;
}
/// <summary>
/// Create a new target with the extension services for
/// </summary>
/// <returns>error result</returns>
HRESULT Extensions::CreateTarget()
{
if (m_pHostServices != nullptr)
{
return m_pHostServices->CreateTarget();
}
return S_OK;
}
/// <summary>
/// Create a new target with the extension services for
/// </summary>
/// <returns>error result</returns>
HRESULT Extensions::UpdateTarget(ULONG processId)
{
if (m_pHostServices != nullptr)
{
return m_pHostServices->UpdateTarget(processId);
}
return S_OK;
}
/// <summary>
/// Flush the target instance
/// </summary>
void Extensions::FlushTarget()
{
if (m_pHostServices != nullptr)
{
m_pHostServices->FlushTarget();
}
}
/// <summary>
/// Create a new target with the extension services for
/// </summary>
void Extensions::DestroyTarget()
{
ReleaseTarget();
if (m_pHostServices != nullptr)
{
m_pHostServices->DestroyTarget();
}
}
/// <summary>
/// Returns the target instance
/// </summary>
ITarget* Extensions::GetTarget()
{
if (m_pTarget == nullptr)
{
GetHost()->GetCurrentTarget(&m_pTarget);
}
return m_pTarget;
}
/// <summary>
/// Releases and clears the target
/// </summary>
void Extensions::ReleaseTarget()
{
if (m_pTarget != nullptr)
{
m_pTarget->Release();
m_pTarget = nullptr;
}
}
/// <summary>
/// Returns the runtime or fails if no target or current runtime
/// </summary>
/// <param name="ppRuntime">runtime instance</param>
/// <returns>error code</returns>
HRESULT GetRuntime(IRuntime** ppRuntime)
{
ITarget* target = GetTarget();
if (target == nullptr)
{
return E_FAIL;
}
return target->GetRuntime(ppRuntime);
}
/// <summary>
/// Helper function to get the absolute path from a relative one
/// </summary>
/// <param name="path">relative path</param>
/// <param name="absolutePath">absolute path output</param>
/// <returns>true success, false invalid path</returns>
bool GetAbsolutePath(const char* path, std::string& absolutePath)
{
ArrayHolder<char> fullPath = new char[MAX_LONGPATH];
#ifdef FEATURE_PAL
if (realpath(path, fullPath) != nullptr && fullPath[0] != '\0')
#else
if (GetFullPathNameA(path, MAX_LONGPATH, fullPath, nullptr) != 0)
#endif
{
absolutePath.assign(fullPath);
return true;
}
return false;
}
| [
"noreply@github.com"
] | noreply@github.com |
673b6aaedf79ea6d33cef15b579386e5a988558e | 68a2c33e54db59eb028c646ff740688ad764c77c | /Bit Manipulation/1356. Sort Integers by The Number of 1 Bits.cpp | 3de9cca7c3a9db380af789ef62b5b2202fe7ce9d | [] | no_license | anuragdvd/LeetCodeSolutions | a48ebcd938e6fbe6beb33ce84f772c21fce4b14f | 1608c6df09284d85c929844fda7233a82154e120 | refs/heads/master | 2023-08-18T23:33:28.080129 | 2021-09-12T16:45:14 | 2021-09-12T16:45:14 | 296,173,835 | 0 | 0 | null | 2021-09-12T16:45:14 | 2020-09-17T00:01:05 | C++ | UTF-8 | C++ | false | false | 470 | cpp | // 1356. Sort Integers by The Number of 1 Bits :: https://leetcode.com/problems/sort-integers-by-the-number-of-1-bits/
bool comp(int a,int b)
{
if(__builtin_popcount(a)==__builtin_popcount(b))
return a<b;
else
return __builtin_popcount(a)<__builtin_popcount(b);
}
class Solution {
public:
vector<int> sortByBits(vector<int>& arr) {
sort(arr.begin(),arr.end(),comp);
return arr;
}
}; | [
"alltrickbyte@gmail.com"
] | alltrickbyte@gmail.com |
d69b08d02374bbada394b0e790cc171ff02db680 | 0577a46d8d28e1fd8636893bbdd2b18270bb8eb8 | /chromium/chrome/browser/download/android/download_dialog_bridge.cc | 434f89e014f89a9763debe3d5fafb95fb73d5f20 | [
"BSD-3-Clause"
] | permissive | ric2b/Vivaldi-browser | 388a328b4cb838a4c3822357a5529642f86316a5 | 87244f4ee50062e59667bf8b9ca4d5291b6818d7 | refs/heads/master | 2022-12-21T04:44:13.804535 | 2022-12-17T16:30:35 | 2022-12-17T16:30:35 | 86,637,416 | 166 | 41 | BSD-3-Clause | 2021-03-31T18:49:30 | 2017-03-29T23:09:05 | null | UTF-8 | C++ | false | false | 6,514 | cc | // Copyright 2018 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "chrome/browser/download/android/download_dialog_bridge.h"
#include "base/android/jni_android.h"
#include "base/android/jni_string.h"
#include "base/metrics/field_trial_params.h"
#include "base/metrics/histogram_macros.h"
#include "chrome/browser/download/android/download_controller.h"
#include "chrome/browser/download/android/jni_headers/DownloadDialogBridge_jni.h"
#include "chrome/browser/profiles/profile_manager.h"
#include "chrome/common/pref_names.h"
#include "components/download/public/common/download_features.h"
#include "components/prefs/pref_service.h"
#include "ui/android/window_android.h"
// -----------------------------------------------------------------------------
// DownloadDialogResult
DownloadDialogResult::DownloadDialogResult() = default;
DownloadDialogResult::DownloadDialogResult(const DownloadDialogResult&) =
default;
DownloadDialogResult::~DownloadDialogResult() = default;
// -----------------------------------------------------------------------------
// DownloadDialogBridge.
DownloadDialogBridge::DownloadDialogBridge() : is_dialog_showing_(false) {
JNIEnv* env = base::android::AttachCurrentThread();
java_obj_.Reset(env, Java_DownloadDialogBridge_create(
env, reinterpret_cast<intptr_t>(this))
.obj());
DCHECK(!java_obj_.is_null());
}
DownloadDialogBridge::~DownloadDialogBridge() {
JNIEnv* env = base::android::AttachCurrentThread();
Java_DownloadDialogBridge_destroy(env, java_obj_);
}
void DownloadDialogBridge::ShowDialog(
gfx::NativeWindow native_window,
int64_t total_bytes,
net::NetworkChangeNotifier::ConnectionType connection_type,
DownloadLocationDialogType dialog_type,
const base::FilePath& suggested_path,
bool is_incognito,
DialogCallback dialog_callback) {
if (!native_window)
return;
UMA_HISTOGRAM_ENUMERATION("MobileDownload.Location.Dialog.Type", dialog_type);
dialog_callback_ = std::move(dialog_callback);
// This shouldn't happen, but if it does, cancel download.
if (dialog_type == DownloadLocationDialogType::NO_DIALOG) {
NOTREACHED();
DownloadDialogResult dialog_result;
dialog_result.location_result = DownloadLocationDialogResult::USER_CANCELED;
CompleteSelection(std::move(dialog_result));
return;
}
// If dialog is showing, run the callback to continue without confirmation.
if (is_dialog_showing_) {
DownloadDialogResult dialog_result;
dialog_result.location_result =
DownloadLocationDialogResult::DUPLICATE_DIALOG;
dialog_result.file_path = suggested_path;
CompleteSelection(std::move(dialog_result));
return;
}
is_dialog_showing_ = true;
JNIEnv* env = base::android::AttachCurrentThread();
Java_DownloadDialogBridge_showDialog(
env, java_obj_, native_window->GetJavaObject(),
static_cast<long>(total_bytes), static_cast<int>(connection_type),
static_cast<int>(dialog_type),
base::android::ConvertUTF8ToJavaString(env,
suggested_path.AsUTF8Unsafe()),
is_incognito);
}
void DownloadDialogBridge::OnComplete(
JNIEnv* env,
const base::android::JavaParamRef<jobject>& obj,
const base::android::JavaParamRef<jstring>& returned_path) {
DownloadDialogResult dialog_result;
dialog_result.location_result = DownloadLocationDialogResult::USER_CONFIRMED;
dialog_result.file_path = base::FilePath(
base::android::ConvertJavaStringToUTF8(env, returned_path));
CompleteSelection(std::move(dialog_result));
is_dialog_showing_ = false;
}
void DownloadDialogBridge::OnCanceled(
JNIEnv* env,
const base::android::JavaParamRef<jobject>& obj) {
if (dialog_callback_) {
DownloadDialogResult dialog_result;
dialog_result.location_result = DownloadLocationDialogResult::USER_CANCELED;
CompleteSelection(std::move(dialog_result));
}
is_dialog_showing_ = false;
}
void DownloadDialogBridge::CompleteSelection(DownloadDialogResult result) {
if (!dialog_callback_)
return;
UMA_HISTOGRAM_ENUMERATION("MobileDownload.Location.Dialog.Result",
result.location_result);
std::move(dialog_callback_).Run(std::move(result));
}
// static
base::android::ScopedJavaLocalRef<jstring>
JNI_DownloadDialogBridge_GetDownloadDefaultDirectory(JNIEnv* env) {
PrefService* pref_service =
ProfileManager::GetActiveUserProfile()->GetOriginalProfile()->GetPrefs();
return base::android::ConvertUTF8ToJavaString(
env, pref_service->GetString(prefs::kDownloadDefaultDirectory));
}
// static
void JNI_DownloadDialogBridge_SetDownloadAndSaveFileDefaultDirectory(
JNIEnv* env,
const base::android::JavaParamRef<jstring>& directory) {
PrefService* pref_service =
ProfileManager::GetActiveUserProfile()->GetOriginalProfile()->GetPrefs();
base::FilePath path(base::android::ConvertJavaStringToUTF8(env, directory));
pref_service->SetFilePath(prefs::kDownloadDefaultDirectory, path);
pref_service->SetFilePath(prefs::kSaveFileDefaultDirectory, path);
}
jboolean JNI_DownloadDialogBridge_IsLocationDialogManaged(JNIEnv* env) {
PrefService* pref_service =
ProfileManager::GetActiveUserProfile()->GetOriginalProfile()->GetPrefs();
return pref_service->IsManagedPreference(prefs::kPromptForDownload);
}
// Vivaldi - External download manager support
bool DownloadDialogBridge::DownloadWithExternalDownloadManager(
gfx::NativeWindow native_window,
DownloadLocationDialogType dialog_type,
const base::FilePath& suggested_path,
download::DownloadItem* download) {
if (!native_window)
return false;
// This shouldn't happen, but if it does, cancel download.
if (dialog_type == DownloadLocationDialogType::NO_DIALOG) {
NOTREACHED();
DownloadDialogResult dialog_result;
dialog_result.location_result = DownloadLocationDialogResult::USER_CANCELED;
CompleteSelection(std::move(dialog_result));
return false;
}
JNIEnv* env = base::android::AttachCurrentThread();
return Java_DownloadDialogBridge_downloadWithExternalDownloadManager(
env, java_obj_, native_window->GetJavaObject(),
base::android::ConvertUTF8ToJavaString(env,
suggested_path.AsUTF8Unsafe()),
base::android::ConvertUTF8ToJavaString(env, download->GetURL().spec()));
}
| [
"mathieu.caroff@free.fr"
] | mathieu.caroff@free.fr |
1dec2c8744a517b6cacfb7b3bbe2872f3c7c79a3 | 22f023002854685679835235eb8be3b3482d086c | /CST328_Proj/CST328Proj.cpp | 796f5e267332f515b48f98170553cc12e1ef54ea | [] | no_license | Jettisawn/School-work | c4ddef1161ed6d74864ec1359424223165184e46 | dd5ce3d8d917f323aa2adff0ac1a43205d5ec68e | refs/heads/master | 2020-05-19T09:11:02.641987 | 2014-05-21T07:40:46 | 2014-05-21T07:40:46 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 84 | cpp | #include "GL\freeglut.h"
#include "GLFrame.h"
#include <math.h>
#include "camera.h"
| [
"Jettisawn@gmail.com"
] | Jettisawn@gmail.com |
15f8c81787f1ed703a1dceb3c8a438e0f505bc80 | f54e0fc4ee3be4ddc08728f2f41f5a6479c8f200 | /saper.cpp | 0e1f0d9fa283840a05da773ad8f0a44a47889d26 | [] | no_license | Parkrister/Saper | ed4842c70cd3461d795d4e40b4288c2083daa90f | a09b02b19ccde0a9633722e732ec2d40e6f6d2f8 | refs/heads/main | 2023-04-19T15:44:28.603090 | 2021-04-23T06:32:59 | 2021-04-23T06:32:59 | 360,786,099 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 7,660 | cpp | // saper.cpp : This file contains the 'main' function. Program execution begins and ends there.
//
#include <iostream>
#include <stdlib.h>
#include <time.h>
#include <stdio.h>
#include <Windows.h>
HANDLE nConsole = GetStdHandle(STD_OUTPUT_HANDLE);
COORD coord;
using std::cout;
using std::cin;
//color 1
#define grey 8
#define red 4
#define white 7
#define black 0
// color 2
#define blue 1
#define green 2
#define sh_blue 3
#define viol 5
#define orange 6
#define cyan 11
#define pink 12
#define dark_viol 12
// simbol
#define bomb_simbol 253
#define flag_simbol 63
#define clear_simbol 254
#define cell_simbol 219
// SETUP
#define bomb 160
const unsigned int m = 13;
unsigned short step = 0;
unsigned int mas[m][m];
unsigned int mark[m][m]; // mark for open()
unsigned short color = white;
int set_color(int c) {
switch (c) {
case 1:
return white;
break;
case 2:
return green;
break;
case 3:
return sh_blue;
break;
case 4:
return viol;
break;
case 5:
return cyan;
break;
case 6:
return pink;
break;
case 7:
return dark_viol;
break;
case 8:
return orange;
break;
}
}
// add_bomb v2.0
//void add_bomb(short x, short y) {
// for (int i = -1; i <= 1; i++) {
// for (int j = -1; j <= 1; j++) {
// if ((x + i >= 0) && (x + i < m) && (y + i >= 0) && (y + i < m)) {
// mas[x + i][y + j]++;
// }
// }
// }
//}
/// add_bomb() v1.0
void add_bomb(short x, short y) {
if ((x - 1 >= 0) && (x - 1 < m) && (y - 1 >= 0) && (y - 1 < m)) {
mas[x - 1][y - 1]++;
}
if ((x >= 0) && (x < m) && (y - 1 >= 0) && (y - 1 < m)) {
mas[x][y - 1]++;
}
if ((x + 1 >= 0) && (x + 1 < m) && (y - 1 >= 0) && (y - 1 < m)) {
mas[x + 1][y - 1]++;
}
if ((x - 1 >= 0) && (x - 1 < m) && (y >= 0) && (y < m)) {
mas[x - 1][y]++;
}
if ((x + 1 >= 0) && (x + 1 < m) && (y >= 0) && (y < m)) {
mas[x + 1][y]++;
}
if ((x - 1 >= 0) && (x - 1 < m) && (y + 1 >= 0) && (y + 1 < m)) {
mas[x - 1][y + 1]++;
}
if ((x >= 0) && (x < m) && (y + 1 >= 0) && (y + 1 < m)) {
mas[x][y + 1]++;
}
if ((x + 1 >= 0) && (x + 1 < m) && (y + 1 >= 0) && (y + 1 < m)) {
mas[x + 1][y + 1]++;
}
return;
}
///
///
bool open(short x, short y) {
Sleep(10);
if (mark[x][y] > 0) {
step++;
}
mark[x][y] *= 0;
coord = { m + 5, 2 };
SetConsoleCursorPosition(nConsole, coord);
printf("step == %d", step);
coord = { y, x };
SetConsoleCursorPosition(nConsole, coord);
if (mas[x][y] > 8) {
color = red;
SetConsoleTextAttribute(nConsole, red);
printf("%c", bomb_simbol);
SetConsoleTextAttribute(nConsole, white);
return false;
}
if (step >= (m * m - bomb)) {
SetConsoleTextAttribute(nConsole, set_color(mas[x][y]));
printf("%d", mas[x][y]);
SetConsoleTextAttribute(nConsole, white);
color = cyan;
return false;
}
if (mas[x][y] == 0) {
printf("%c", '.');
//for (int i = -1; i <= 1; i++) {
// for (int j = -1; j <= 1; j++) {
// if (mark[y + i][x + i] > 0) {
// if ((y + i >= 0) && (y + i < m) && (x + i >= 0) && (x + i < m)) {
// open(y + i, x + i);
// }
// }
// }
//}
if ((mark[x - 1][y - 1] > 0) && ((x - 1 >= 0) && (x - 1 < m) && (y - 1 >= 0) && (y - 1 < m))) {
open(x - 1, y - 1);
}
if ((mark[x][y - 1] > 0) && ((x >= 0) && (x < m) && (y - 1 >= 0) && (y - 1 < m))) {
open(x, y - 1);
}
if ((mark[x + 1][y - 1] > 0) && ((x + 1 >= 0) && (x + 1 < m) && (y - 1 >= 0) && (y - 1 < m))) {
open(x + 1, y - 1);
}
if ((mark[x - 1][y] > 0) && ((x - 1 >= 0) && (x - 1 < m) && (y >= 0) && (y < m))) {
open(x - 1, y);
}
if ((mark[x + 1][y] > 0) && ((x + 1 >= 0) && (x + 1 < m) && (y >= 0) && (y < m))) {
open(x + 1, y);
}
if ((mark[x - 1][y + 1] > 0) && ((x - 1 >= 0) && (x - 1 < m) && (y + 1 >= 0) && (y + 1 < m))) {
open(x - 1, y + 1);
}
if ((mark[x][y + 1] > 0) && ((x >= 0) && (x < m) && (y + 1 >= 0) && (y + 1 < m))) {
open(x, y + 1);
}
if ((mark[x + 1][y + 1] > 0) && ((x + 1 >= 0) && (x + 1 < m) && (y + 1 >= 0) && (y + 1 < m))) {
open(x + 1, y + 1);
}
return true;
}
if (mas[x][y] < 9) {
SetConsoleTextAttribute(nConsole, set_color(mas[x][y]));
printf("%d", mas[x][y]);
SetConsoleTextAttribute(nConsole, white);
return true;
}
}
///
int main() //////////// MAIN
{
long ltime = time(0);
int stime = (unsigned int)ltime / 2;
srand(stime);
short int x = 0, y = 0;
short xb, yb;
coord = { m + 5, 0 };
SetConsoleCursorPosition(nConsole, coord);
printf("need step == %i", (m * m - bomb));
// fill mas[][]
for (int i = 0; i < m; i++) {
for (int j = 0; j < m; j++) {
mas[i][j] = 0;
}
}
coord = { m + 5, 4 };
SetConsoleCursorPosition(nConsole, coord);
printf("| Enter x > %d for exit", m);
coord = { m + 5, 5 };
SetConsoleCursorPosition(nConsole, coord);
printf("| Enter x = -1 for flag");
// marks[][] for open()
for (int i = 0; i < m; i++) {
for (int j = 0; j < m; j++) {
mark[i][j] = 1;
}
}
// fill cels
coord = { 0, 0 };
SetConsoleCursorPosition(nConsole, coord);
for (int i = 0; i < m; i++) {
for (int j = 0; j < m; j++) {
SetConsoleTextAttribute(nConsole, white);
printf("%c", cell_simbol);
}
putchar('\n');
}
SetConsoleTextAttribute(nConsole, white);
// set bombs
for (int i = 0; i < bomb; i++) {
do {
xb = rand() % m;
yb = rand() % m;
} while (mas[xb][yb] > 8);
mas[xb][yb] = 9;
add_bomb(xb, yb);
}
//// GAME
do {
SetConsoleTextAttribute(nConsole, white);
coord = { m + 7, 11 };
SetConsoleCursorPosition(nConsole, coord);
printf(" ");
coord = { m + 7, 11 };
SetConsoleCursorPosition(nConsole, coord);
if (y < 0) { // flag
printf("Set flag: ");
do {
cin >> x >> y;
} while ((x < 0) && (y < 0));
coord = { x, y };
SetConsoleCursorPosition(nConsole, coord);
SetConsoleTextAttribute(nConsole, grey);
putchar(flag_simbol);
SetConsoleTextAttribute(nConsole, white);
y = 0;
continue;
}
if (step == (m * m - bomb)) {
color = cyan;
break;
}
printf("Enter x, y: ");
cin >> y;
if (y < 0) {
continue;
}
else {
if (y > m) {
break;
}
}
cin >> x;
if (!((x < m) && open(x, y) && (y < m))) {
break;
}
} while (1);
///
coord = { m + 5, 7 };
SetConsoleCursorPosition(nConsole, coord);
puts("-------------------");
if (color == cyan) {
for (short i = 0; i < m; i++) {
for (short j = 0; j < m; j++) {
if (mas[i][j] > 8) {
coord = { j, i };
SetConsoleCursorPosition(nConsole, coord);
SetConsoleTextAttribute(nConsole, color);
printf("%c", bomb_simbol);
}
}
}
coord = { m + 5, 8 };
SetConsoleCursorPosition(nConsole, coord);
SetConsoleTextAttribute(nConsole, color);
printf("\t W I N ");
}
else {
for (short i = 0; i < m; i++) {
for (short j = 0; j < m; j++) {
if (mas[i][j] > 8) {
coord = { j, i };
SetConsoleCursorPosition(nConsole, coord);
SetConsoleTextAttribute(nConsole, color);
printf("%c", bomb_simbol);
}
}
}
coord = { m + 5, 8 };
SetConsoleCursorPosition(nConsole, coord);
SetConsoleTextAttribute(nConsole, color);
printf(" L O S E ");
}
SetConsoleTextAttribute(nConsole, white);
coord = { m + 5, 9 };
SetConsoleCursorPosition(nConsole, coord);
puts("-------------------");
coord = { 0, m + 1 };
SetConsoleCursorPosition(nConsole, coord);
return 0;
} | [
"noreply@github.com"
] | noreply@github.com |
c633b301fca7ba75db10f4ab7a0ad53aeec255cd | cf163b4174022fa0996c6f865963f604ba597302 | /firmware/mpcnc-marlin/MPCNC813_GLCD_EB_T8/endstops.h | 268bf8c00da50ff5cce781afb232fc130fe688c9 | [
"Apache-2.0"
] | permissive | AravinthPanch/araBot | 9e6beb81f93b55ef82fb8c4bb8cd3b054b661f4a | 1c45a2aeceb3c956a5eba3835b87569046a4df5e | refs/heads/master | 2022-02-28T11:46:34.868836 | 2019-10-12T19:53:00 | 2019-10-12T19:53:00 | 108,847,466 | 9 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,895 | h | /**
* Marlin 3D Printer Firmware
* Copyright (C) 2016 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
*
* Based on Sprinter and grbl.
* Copyright (C) 2011 Camiel Gubbels / Erik van der Zalm
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*
*/
/**
* endstops.h - manages endstops
*/
#ifndef ENDSTOPS_H
#define ENDSTOPS_H
#include "enum.h"
class Endstops {
public:
static bool enabled, enabled_globally;
static volatile char endstop_hit_bits; // use X_MIN, Y_MIN, Z_MIN and Z_MIN_PROBE as BIT value
#if ENABLED(Z_DUAL_ENDSTOPS)
static uint16_t
#else
static byte
#endif
current_endstop_bits, old_endstop_bits;
Endstops() {};
/**
* Initialize the endstop pins
*/
void init();
/**
* Update the endstops bits from the pins
*/
static void update();
/**
* Print an error message reporting the position when the endstops were last hit.
*/
static void report_state(); //call from somewhere to create an serial error message with the locations the endstops where hit, in case they were triggered
/**
* Report endstop positions in response to M119
*/
static void M119();
// Enable / disable endstop checking globally
static void enable_globally(bool onoff=true) { enabled_globally = enabled = onoff; }
// Enable / disable endstop checking
static void enable(bool onoff=true) { enabled = onoff; }
// Disable / Enable endstops based on ENSTOPS_ONLY_FOR_HOMING and global enable
static void not_homing() { enabled = enabled_globally; }
// Clear endstops (i.e., they were hit intentionally) to suppress the report
static void hit_on_purpose() { endstop_hit_bits = 0; }
// Enable / disable endstop z-probe checking
#if HAS_BED_PROBE
static volatile bool z_probe_enabled;
static void enable_z_probe(bool onoff=true) { z_probe_enabled = onoff; }
#endif
private:
#if ENABLED(Z_DUAL_ENDSTOPS)
static void test_dual_z_endstops(const EndstopEnum es1, const EndstopEnum es2);
#endif
};
extern Endstops endstops;
#if HAS_BED_PROBE
#define ENDSTOPS_ENABLED (endstops.enabled || endstops.z_probe_enabled)
#else
#define ENDSTOPS_ENABLED endstops.enabled
#endif
#endif // ENDSTOPS_H
| [
"panch.aravinth@gmail.com"
] | panch.aravinth@gmail.com |
cd14746902ad2fef5138337b3f261fc9926a1c64 | 5a219234ed92701bcfd05ffce5bfcdc68c80f827 | /Pods/AudioKit/iOS/AudioKit.framework/Headers/AKModulatedDelay.hpp | d04b94d492855fb23711197dad3094219d88e448 | [] | no_license | rosagarza/MicSignal | 10d76ce3f0a1b872f918694f88c4791452c3c1a7 | f161d09aeac4202d08306078167c2e6d29cf4b9a | refs/heads/master | 2021-03-17T07:06:09.687426 | 2020-04-16T08:00:13 | 2020-04-16T08:00:13 | 246,966,199 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 129 | hpp | version https://git-lfs.github.com/spec/v1
oid sha256:588ff0f703ed6d127f0cb2a3f56d28bf3058a483aeb1aa10414dd568e475882e
size 1117
| [
"rosa.m.gee@gmail.com"
] | rosa.m.gee@gmail.com |
f24092233f810a2b4b15fa7c1ca1c39cc9a498aa | 658e7b32e91c2a32c5fa0abd70d6f6c640a819aa | /d07/ex02/Test.class.hpp | 3512d1793f694cb08267110241c2b302c726e792 | [] | no_license | Truphino/cpp | 27b5adbbc61d23e8de2c87b686f6450ad18f0671 | f22b72ca126d7a4e61fe958d55c2672d67780179 | refs/heads/master | 2021-01-22T19:09:40.181461 | 2018-04-25T09:33:16 | 2018-04-25T09:33:16 | 85,172,784 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,313 | hpp | /* ************************************************************************** */
/* */
/* ::: :::::::: */
/* Test.class.hpp :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: trecomps <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2017/04/06 10:53:53 by trecomps #+# #+# */
/* Updated: 2017/04/06 11:10:25 by trecomps ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef TEST_CLASS_H
# define TEST_CLASS_H
#include <iostream>
class Test {
public :
Test(void);
Test(int const foo, int const bar);
Test(Test const &rhs);
~Test(void);
Test &operator=(Test const &rhs);
void setParam(const int foo, const int bar);
int getFoo(void) const;
int getBar(void) const;
private :
int _foo;
int _bar;
};
std::ostream &operator<<(std::ostream &o, Test const &i);
#endif
| [
"trecomps@e2r5p7.42.fr"
] | trecomps@e2r5p7.42.fr |
ada419465350ecbc38fd3220dce3dd3f8e25a628 | 995d5b6de21b7e903d83784b3ebb068b05fdadb9 | /final_creatures/creatures_03_timersandFadeworking/touchSensors.ino | b709d194608ab31bb1fedcfefccec419d4d3924e | [] | no_license | jcontour/Jessie_OFanimation2015 | 2aa1369c7aa628a1c31c3a2045f4a8c66fd0092a | 52393e8b3febe49fe853c20a1e41da68e5bea78a | refs/heads/master | 2020-06-04T15:51:47.779390 | 2015-05-23T18:49:36 | 2015-05-23T18:49:36 | 31,288,991 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 917 | ino | void readTouch1() {
currtouched1 = cap1.touched();
for (uint8_t i = 0; i < 10; i++) {
if ((currtouched1 & _BV(i)) && !(lasttouched1 & _BV(i)) ) {
Serial.print(i); Serial.println(" #1 touched");
//when touched, trigger
turnRed(i);
}
if (!(currtouched1 & _BV(i)) && (lasttouched1 & _BV(i)) ) {
Serial.print(i); Serial.println(" #1 released");
isReleased[i] = true;
}
}
lasttouched1 = currtouched1;
}
void readTouch2() {
currtouched2 = cap2.touched();
for (uint8_t i = 0; i < 5; i++) {
if ((currtouched2 & _BV(i)) && !(lasttouched2 & _BV(i)) ) {
Serial.print(i); Serial.println(" #2 touched");
//when touched, trigger
turnRed(i+10);
}
if (!(currtouched2 & _BV(i)) && (lasttouched2 & _BV(i)) ) {
Serial.print(i); Serial.println(" #2 released");
isReleased[i+10] = true;
}
}
lasttouched2 = currtouched2;
}
| [
"Contour@jessies-air.home"
] | Contour@jessies-air.home |
3258b371ca38fdcf00c1c9d688625e51f67ac529 | bf80ee7fc14028c033aeba0cd4d097f5d1e75b61 | /src/main.cpp | 48d6466ca8cd1be85ca9555688d71f45f82b756e | [] | no_license | MoonFox2006/ESP14 | 7cd23c106aa9df41de3582210dc2f664cb3ecc98 | a02081e98be2f75286f42434b19cea15dcb170ad | refs/heads/master | 2022-04-23T01:47:43.317348 | 2020-04-23T08:22:58 | 2020-04-23T08:22:58 | 258,139,388 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,140 | cpp | #include <user_interface.h>
#include <Arduino.h>
#include <ESP8266WiFi.h>
#define LED_PIN 2
#define LED_LEVEL LOW
static const char WIFI_SSID[] PROGMEM = "ESP14";
static const char WIFI_PSWD[] PROGMEM = "1029384756";
static bool prepareWiFi() {
wifi_country_t wc;
wc.cc[0] = 'J';
wc.cc[1] = 'P';
wc.cc[2] = '\0';
wc.schan = 1;
wc.nchan = 14;
wc.policy = WIFI_COUNTRY_POLICY_MANUAL;
return wifi_set_country(&wc);
}
static bool connectWiFi(uint32_t timeout) {
uint32_t start = millis();
WiFi.mode(WIFI_STA);
Serial.print(F("Connecting to \""));
Serial.print(FPSTR(WIFI_SSID));
Serial.print('"');
WiFi.begin(FPSTR(WIFI_SSID), FPSTR(WIFI_PSWD), 14);
while (! WiFi.isConnected()) {
if (millis() - start >= timeout)
break;
Serial.write('.');
digitalWrite(LED_PIN, LED_LEVEL);
delay(25);
digitalWrite(LED_PIN, ! LED_LEVEL);
delay(500 - 25);
}
if (WiFi.isConnected()) {
Serial.print(F(" OK (IP "));
Serial.print(WiFi.localIP());
Serial.print(F(", channel "));
Serial.print(WiFi.channel());
Serial.println(')');
return true;
} else {
WiFi.disconnect();
Serial.println(F(" FAIL!"));
return false;
}
}
void setup() {
const uint32_t WIFI_TIMEOUT = 30000; // 30 sec.
pinMode(LED_PIN, OUTPUT);
digitalWrite(LED_PIN, ! LED_LEVEL);
Serial.begin(115200, SERIAL_8N1, SERIAL_TX_ONLY);
Serial.println();
if (! prepareWiFi()) {
Serial.println(F("wifi_set_country() fail!"));
Serial.flush();
ESP.deepSleep(0);
}
WiFi.persistent(false);
if (! connectWiFi(WIFI_TIMEOUT)) {
WiFi.mode(WIFI_AP);
Serial.print(F("Creating AP \""));
Serial.print(FPSTR(WIFI_SSID));
Serial.print(F("\" with password \""));
Serial.print(FPSTR(WIFI_PSWD));
Serial.print(F("\" on channel 14 "));
if (WiFi.softAP(FPSTR(WIFI_SSID), FPSTR(WIFI_PSWD), 14)) {
Serial.println(F("OK, waiting for clients..."));
} else {
Serial.println(F("FAIL!"));
Serial.flush();
ESP.restart();
}
}
}
void loop() {}
| [
"noreply@github.com"
] | noreply@github.com |
e5851641b90d5007c97747ead699bc72155b245f | 0a71629b54cab332a20e831335a966f9f908b1a4 | /SAMA_v1.ino | 2911d86dcbb75fe540b130251060a03f8bb6d7f7 | [] | no_license | RenatoMZ/Spaceapps2016 | 26fd07f8bbafaa503e9123a500454562638e4542 | b603bf5dfa3cae5c106ccfb2f99d148c38c7047a | refs/heads/master | 2016-09-13T09:00:17.281531 | 2016-04-25T22:29:32 | 2016-04-25T22:29:32 | 57,078,135 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 5,570 | ino | //This program reads the value of two FC22-MQ135 CO2 sensors, two Grove-Gas sensor O2 and a flowmeter YF S201
#include "MQ135.h"
#include <SoftwareSerial.h>
//Declare variables
//For O2 sensors
float O2_Inh = 0; // 4 bytes
float O2_Exh = 0; // 4 bytes
//For CO2 sensors
MQ135 gasSensorInh = MQ135(A2);
MQ135 gasSensorExh = MQ135(A3);
float CO2_Inh = 0; // 4 bytes
float CO2_Exh = 0; // 4 bytes
//For flowmeter
byte sensorInterrupt = 0; // 0 = digital pin 2
byte sensorPin = 2;
float calibrationFactor = 4.5; // 4 bytes
volatile byte pulseCount;
float flowRate; // 4 bytes
unsigned int flowMilliLitres; // Current Liquid Flowing. 2 bytes
unsigned long totalMilliLitres; // Output Liquid Quantity. 4 bytes
unsigned long oldTime; // 4 bytes
SoftwareSerial BTSerial(10, 11); // RX, TX
void setup() {
// put your setup code here, to run once:
Serial.begin(9600);
BTSerial.begin(9600);
//For flowmeter
pinMode(sensorPin, INPUT);
digitalWrite(sensorPin, HIGH);
pulseCount = 0;
flowRate = 0.0;
flowMilliLitres = 0;
totalMilliLitres = 0;
oldTime = 0;
// The Hall-effect sensor is connected to pin 2 which uses interrupt 0.
// Configured to trigger on a FALLING state change (transition from HIGH
// state to LOW state)
attachInterrupt(sensorInterrupt, pulseCounter, FALLING);
Serial.write(BTSerial.read()); //Send "Client Connected" from device to Monitor Serial
}
void loop() {
//O2 Sensor reading and conversion
O2_Inh = analogRead(A0);
O2_Exh = analogRead(A1);
O2_Inh = (((O2_Inh/1024)*5)/201*10000)/7.43; // %O2 inhaled
O2_Exh = (((O2_Exh/1024)*5)/201*10000)/7.43; // %O2 exhhaled
//CO2 Sensor reading and conversion
CO2_Inh = gasSensorInh.getPPM();
CO2_Exh = gasSensorExh.getPPM();
CO2_Inh = CO2_Inh/10000; // %CO2 inhaled
CO2_Exh = CO2_Exh/10000; // %CO2 exhaled
//Flow sensor
if((millis() - oldTime) > 1000) // Only process counters once per second
{
// Disable the interrupt while calculating flow rate and sending the value to
// the host
detachInterrupt(sensorInterrupt);
// Because this loop may not complete in exactly 1 second intervals we calculate
// the number of milliseconds that have passed since the last execution and use
// that to scale the output. We also apply the calibrationFactor to scale the output
// based on the number of pulses per second per units of measure (litres/minute in
// this case) coming from the sensor.
flowRate = ((1000.0 / (millis() - oldTime)) * pulseCount) / calibrationFactor;
// Note the time this processing pass was executed. Note that because we've
// disabled interrupts the millis() function won't actually be incrementing right
// at this point, but it will still return the value it was set to just before
// interrupts went away.
oldTime = millis();
// Divide the flow rate in litres/minute by 60 to determine how many litres have
// passed through the sensor in this 1 second interval, then multiply by 1000 to
// convert to millilitres.
flowMilliLitres = (flowRate / 60) * 1000;
// Add the millilitres passed in this second to the cumulative total
totalMilliLitres += flowMilliLitres;
unsigned int frac;
// Print the flow rate for this second in litres / minute
Serial.print("Flow rate: ");
Serial.print(int(flowRate)); // Print the integer part of the variable
Serial.print("."); // Print the decimal point
// Determine the fractional part. The 10 multiplier gives us 1 decimal place.
frac = (flowRate - int(flowRate)) * 10;
Serial.print(frac, DEC) ; // Print the fractional part of the variable
Serial.print("L/min");
String StringflowRate = String(int(flowRate)) + String(frac,DEC);
BTSerial.print(StringflowRate);//Send Flow Rate by BT
// Print the number of litres flowed in this second
Serial.print(" Current Liquid Flowing: "); // Output separator
Serial.print(flowMilliLitres);
Serial.print("mL/Sec");
BTSerial.write(flowMilliLitres);//Send Current Liquid Flowing by BT
// Print the cumulative total of litres flowed since starting
Serial.print("Output Liquid Quantity: "); // Output separator
Serial.print(totalMilliLitres);
Serial.println("mL");
Serial.println(" ");
BTSerial.write(totalMilliLitres);//Send Output Liquid Quantity by BT
// Reset the pulse counter so we can start incrementing again
pulseCount = 0;
// Enable the interrupt again now that we've finished sending output
attachInterrupt(sensorInterrupt, pulseCounter, FALLING);
}
Serial.print("Concentration of O2 inhaled is ");
Serial.print(O2_Inh,1);
Serial.println("%");
BTSerial.write(O2_Inh);//Send O2 inhaled by BT
Serial.print("Concentration of CO2 inhaled is ");
Serial.print(CO2_Inh,1);
Serial.println("%");
Serial.println(" ");
BTSerial.write(CO2_Inh);//Send CO2 inhaled by BT
Serial.print("Concentration of O2 exhaled is ");
Serial.print(O2_Exh,1);
Serial.println("%");
BTSerial.write(O2_Exh);//Send O2 exhaled by BT
Serial.print("Concentration of CO2 exhhaled is ");
Serial.print(CO2_Exh,1);
Serial.println("%");
Serial.println(" ");
BTSerial.write(CO2_Exh);//Send CO2 exhaled by BT
Serial.println("-------------------------------------------");
delay(1000);
}
/*
Insterrupt Service Routine
*/
void pulseCounter()
{
// Increment the pulse counter
pulseCount++;
}
| [
"r.mioz@pucp.edu.pe"
] | r.mioz@pucp.edu.pe |
3e8c81c4a577f64ed261c9c003f6dd4c1d9c3c3a | 6174f09aeebb1573f537941c118ab57ee6805d06 | /Shaders/CourseWork/TesselatedQuadMess.cpp | 58ed3e82595075771da2e6fbaca4ffa8d5459740 | [] | no_license | gamereat/Graphics-Programming-with-Shaders | 04de049c4ea5a29da41c1968e8ff470db641278b | 252fc04e809164aa346c497026c3c1f9c4f7b057 | refs/heads/master | 2021-01-19T09:20:44.738760 | 2016-12-13T16:12:09 | 2016-12-13T16:12:09 | 67,411,273 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 15,196 | cpp | #include "TesselatedQuadMess.h"
TesselatedQuadMess::TesselatedQuadMess(ID3D11Device* device, ID3D11DeviceContext* deviceContext, WCHAR* textureFilename, int resolution)
{
this->resolution = resolution;
// Initialize the vertex and index buffer that hold the geometry for the triangle.
InitBuffers(device);
// Load the texture for this model.
LoadTexture(device, deviceContext, textureFilename);
}
TesselatedQuadMess::~TesselatedQuadMess()
{
BaseMesh::~BaseMesh();
}
void TesselatedQuadMess::InitBuffers(ID3D11Device* device)
{
VertexType* vertices;
unsigned long* indices;
D3D11_BUFFER_DESC vertexBufferDesc, indexBufferDesc;
D3D11_SUBRESOURCE_DATA vertexData, indexData;
// Calculate vertex count
// 6 vertices per quad, res*res is face, times 6 for each face
// Set the number of vertices in the vertex array.
m_vertexCount = ((6 * resolution)*resolution) * 6;
// Set the number of indices in the index array.
m_indexCount = m_vertexCount;
// Create the vertex array.
vertices = new VertexType[m_vertexCount];
// Create the index array.
indices = new unsigned long[m_indexCount];
// Vertex variables
float yincrement = 2.0f / resolution;
float xincrement = 2.0f / resolution;
float ystart = 1.0f;
float xstart = -1.0f;
//UV variables
float txu = 0.0f;
float txv = 0.0f;
float txuinc = 1.0f / resolution; // UV increment
float txvinc = 1.0f / resolution;
//Counters
int v = 0; // vertex counter
int i = 0; // index counter
////front face
//for (int y = 0; y<resolution; y++) // for each quad in the y direction
//{
// for (int x = 0; x < resolution; x++) // for each quad in the x direction
// {
// // Load the vertex array with data.
// //2
// vertices[v].position = XMFLOAT3(xstart, ystart, -1.0f); // Top left. -1.0, 1.0
// vertices[v].texture = XMFLOAT2(txu, txv);
// vertices[v].normal = XMFLOAT3(0.0f, 0.0f, -1.0f);
// indices[i] = i;
// v++;
// i++;
// //0
// vertices[v].position = XMFLOAT3(xstart, ystart - yincrement, -1.0f); // Bottom left. -1. -1. 0
// vertices[v].texture = XMFLOAT2(txu, txv + txvinc);
// vertices[v].normal = XMFLOAT3(0.0f, 0.0f, -1.0f);
// indices[i] = i;
// v++;
// i++;
// //3
// vertices[v].position = XMFLOAT3(xstart + xincrement, ystart - yincrement, -1.0f); // Bottom right. 1.0, -1.0, 0.0
// vertices[v].texture = XMFLOAT2(txu + txuinc, txv + txvinc);
// vertices[v].normal = XMFLOAT3(0.0f, 0.0f, -1.0f);
// indices[i] = i;
// v++;
// i++;
// //1
// vertices[v].position = XMFLOAT3(xstart + xincrement, ystart, -1.0f); // Top right. 1.0, 1.0 0.0
// vertices[v].texture = XMFLOAT2(txu + txuinc, txv);
// vertices[v].normal = XMFLOAT3(0.0f, 0.0f, -1.0f);
// indices[i] = i;
// v++;
// i++;
// // increment
// xstart += xincrement;
// txu += txuinc;
// //ystart -= yincrement;
// }
// ystart -= yincrement;
// xstart = -1;
// txu = 0;
// txv += txvinc;
//}
//txv = 0;
////back face
//ystart = 1;
//xstart = 1;
//for (int y = 0; y<resolution; y++) // for each quad in the y direction
//{
// for (int x = 0; x < resolution; x++) // for each quad in the x direction
// {
// // Load the vertex array with data.
// //1
// vertices[v].position = XMFLOAT3(xstart, ystart, 1.0f); // Top left. -1.0, 1.0
// vertices[v].texture = XMFLOAT2(txu, txv);
// vertices[v].normal = XMFLOAT3(0.0f, 0.0f, 1.0f);
// indices[i] = i;
// v++;
// i++;
// //0
// vertices[v].position = XMFLOAT3(xstart, ystart - yincrement, 1.0f); // Bottom left. -1. -1. 0
// vertices[v].texture = XMFLOAT2(txu, txv + txvinc);
// vertices[v].normal = XMFLOAT3(0.0f, 0.0f, 1.0f);
// indices[i] = i;
// v++;
// i++;
// //3
// vertices[v].position = XMFLOAT3(xstart - xincrement, ystart - yincrement, 1.0f); // Bottom right. 1.0, -1.0, 0.0
// vertices[v].texture = XMFLOAT2(txu + txuinc, txv + txvinc);
// vertices[v].normal = XMFLOAT3(0.0f, 0.0f, 1.0f);
// indices[i] = i;
// v++;
// i++;
// //2
// vertices[v].position = XMFLOAT3(xstart - xincrement, ystart, 1.0f); // Top right. 1.0, 1.0 0.0
// vertices[v].texture = XMFLOAT2(txu + txuinc, txv);
// vertices[v].normal = XMFLOAT3(0.0f, 0.0f, 1.0f);
// indices[i] = i;
// v++;
// i++;
// ////0
// //vertices[v].position = XMFLOAT3(xstart, ystart - yincrement, 1.0f); // Bottom left. -1. -1. 0
// //vertices[v].texture = XMFLOAT2(txu, txv + txvinc);
// //vertices[v].normal = XMFLOAT3(0.0f, 0.0f, 1.0f);
// //indices[i] = i;
// //v++;
// //i++;
// ////2
// //vertices[v].position = XMFLOAT3(xstart - xincrement, ystart, 1.0f); // Top right. 1.0, 1.0 0.0
// //vertices[v].texture = XMFLOAT2(txu + txuinc, txv);
// //vertices[v].normal = XMFLOAT3(0.0f, 0.0f, 1.0f);
// //indices[i] = i;
// //v++;
// //i++;
// // increment
// xstart -= xincrement;
// //ystart -= yincrement;
// txu += txuinc;
// }
// ystart -= yincrement;
// xstart = 1;
// txu = 0;
// txv += txvinc;
//}
//txv = 0;
////right face
//ystart = 1;
//xstart = -1;
//for (int y = 0; y<resolution; y++) // for each quad in the y direction
//{
// for (int x = 0; x < resolution; x++) // for each quad in the x direction
// {
// // Load the vertex array with data.
// //1
// vertices[v].position = XMFLOAT3(1.0f, ystart, xstart); // Top left. -1.0, 1.0
// vertices[v].texture = XMFLOAT2(txu, txv);
// vertices[v].normal = XMFLOAT3(1.0f, 0.0f, 0.0f);
// indices[i] = i;
// v++;
// i++;
// //0
// vertices[v].position = XMFLOAT3(1.0f, ystart - yincrement, xstart); // Bottom left. -1. -1. 0
// vertices[v].texture = XMFLOAT2(txu, txv + txvinc);
// vertices[v].normal = XMFLOAT3(1.0f, 0.0f, 0.0f);
// indices[i] = i;
// v++;
// i++;
// //3
// vertices[v].position = XMFLOAT3(1.0f, ystart - yincrement, xstart + xincrement); // Bottom right. 1.0, -1.0, 0.0
// vertices[v].texture = XMFLOAT2(txu + txuinc, txv + txvinc);
// vertices[v].normal = XMFLOAT3(1.0f, 0.0f, 0.0f);
// indices[i] = i;
// v++;
// i++; //2
// vertices[v].position = XMFLOAT3(1.0f, ystart, xstart + xincrement); // Top right. 1.0, 1.0 0.0
// vertices[v].texture = XMFLOAT2(txu + txuinc, txv);
// vertices[v].normal = XMFLOAT3(1.0f, 0.0f, 0.0f);
// indices[i] = i;
// v++;
// i++;
// ////0
// //vertices[v].position = XMFLOAT3(1.0f, ystart - yincrement, xstart); // Bottom left. -1. -1. 0
// //vertices[v].texture = XMFLOAT2(txu, txv + txvinc);
// //vertices[v].normal = XMFLOAT3(1.0f, 0.0f, 0.0f);
// //indices[i] = i;
// //v++;
// //i++;
// ////2
// //vertices[v].position = XMFLOAT3(1.0f, ystart, xstart + xincrement); // Top right. 1.0, 1.0 0.0
// //vertices[v].texture = XMFLOAT2(txu + txuinc, txv);
// //vertices[v].normal = XMFLOAT3(1.0f, 0.0f, 0.0f);
// //indices[i] = i;
// //v++;
// //i++;
// // increment
// xstart += xincrement;
// //ystart -= yincrement;
// txu += txuinc;
// }
// ystart -= yincrement;
// xstart = -1;
// txu = 0;
// txv += txvinc;
//}
//txv = 0;
////left face
//ystart = 1;
//xstart = 1;
//for (int y = 0; y<resolution; y++) // for each quad in the y direction
//{
// for (int x = 0; x < resolution; x++) // for each quad in the x direction
// {
// // Load the vertex array with data.
// //1
// vertices[v].position = XMFLOAT3(-1.0f, ystart, xstart); // Top left. -1.0, 1.0
// vertices[v].texture = XMFLOAT2(txu, txv);
// vertices[v].normal = XMFLOAT3(-1.0f, 0.0f, 0.0f);
// indices[i] = i;
// v++;
// i++;
// //0
// vertices[v].position = XMFLOAT3(-1.0f, ystart - yincrement, xstart); // Bottom left. -1. -1. 0
// vertices[v].texture = XMFLOAT2(txu, txv + txvinc);
// vertices[v].normal = XMFLOAT3(-1.0f, 0.0f, 0.0f);
// indices[i] = i;
// v++;
// i++;
// //3
// vertices[v].position = XMFLOAT3(-1.0f, ystart - yincrement, xstart - xincrement); // Bottom right. 1.0, -1.0, 0.0
// vertices[v].texture = XMFLOAT2(txu + txuinc, txv + txvinc);
// vertices[v].normal = XMFLOAT3(-1.0f, 0.0f, 0.0f);
// indices[i] = i;
// v++;
// i++;
// //2
// vertices[v].position = XMFLOAT3(-1.0f, ystart, xstart - xincrement); // Top right. 1.0, 1.0 0.0
// vertices[v].texture = XMFLOAT2(txu + txuinc, txv);
// vertices[v].normal = XMFLOAT3(-1.0f, 0.0f, 0.0f);
// indices[i] = i;
// v++;
// i++;
// ////0
// //vertices[v].position = XMFLOAT3(-1.0f, ystart - yincrement, xstart); // Bottom left. -1. -1. 0
// //vertices[v].texture = XMFLOAT2(txu, txv + txvinc);
// //vertices[v].normal = XMFLOAT3(-1.0f, 0.0f, 0.0f);
// //indices[i] = i;
// //v++;
// //i++;
// ////2
// //vertices[v].position = XMFLOAT3(-1.0f, ystart, xstart - xincrement); // Top right. 1.0, 1.0 0.0
// //vertices[v].texture = XMFLOAT2(txu + txuinc, txv);
// //vertices[v].normal = XMFLOAT3(-1.0f, 0.0f, 0.0f);
// //indices[i] = i;
// //v++;
// //i++;
// // increment
// xstart -= xincrement;
// //ystart -= yincrement;
// txu += txuinc;
// }
// ystart -= yincrement;
// xstart = 1;
// txu = 0;
// txv += txvinc;
//}
//txv = 0;
//top face
ystart = 1;
xstart = -1;
for (int y = 0; y<resolution; y++) // for each quad in the y direction
{
for (int x = 0; x < resolution; x++) // for each quad in the x direction
{
// Load the vertex array with data.
//1
vertices[v].position = XMFLOAT3(xstart, 1.0f, ystart); // Top left. -1.0, 1.0
vertices[v].texture = XMFLOAT2(txu, txv);
vertices[v].normal = XMFLOAT3(0.0f, 1.0f, 0.0f);
indices[i] = i;
v++;
i++;
//0
vertices[v].position = XMFLOAT3(xstart, 1.0f, ystart - yincrement); // Bottom left. -1. -1. 0
vertices[v].texture = XMFLOAT2(txu, txv + txvinc);
vertices[v].normal = XMFLOAT3(0.0f, 1.0f, 0.0f);
indices[i] = i;
v++;
i++;
//3
vertices[v].position = XMFLOAT3(xstart + xincrement, 1.0f, ystart - yincrement); // Bottom right. 1.0, -1.0, 0.0
vertices[v].texture = XMFLOAT2(txu + txuinc, txv + txvinc);
vertices[v].normal = XMFLOAT3(0.0f, 1.0f, 0.0f);
indices[i] = i;
v++;
i++;
//2
vertices[v].position = XMFLOAT3(xstart + xincrement, 1.0f, ystart); // Top right. 1.0, 1.0 0.0
vertices[v].texture = XMFLOAT2(txu + txuinc, txv);
vertices[v].normal = XMFLOAT3(0.0f, 1.0f, 0.0f);
indices[i] = i;
v++;
i++;
////0
//vertices[v].position = XMFLOAT3(xstart, 1.0f, ystart - yincrement); // Bottom left. -1. -1. 0
//vertices[v].texture = XMFLOAT2(txu, txv + txvinc);
//vertices[v].normal = XMFLOAT3(0.0f, 1.0f, 0.0f);
//indices[i] = i;
//v++;
//i++;
////2
//vertices[v].position = XMFLOAT3(xstart + xincrement, 1.0f, ystart); // Top right. 1.0, 1.0 0.0
//vertices[v].texture = XMFLOAT2(txu + txuinc, txv);
//vertices[v].normal = XMFLOAT3(0.0f, 1.0f, 0.0f);
//indices[i] = i;
//v++;
//i++;
// increment
xstart += xincrement;
//ystart -= yincrement;
txu += txuinc;
}
ystart -= yincrement;
xstart = -1;
txu = 0;
txv += txvinc;
}
//txv = 0;
////bottom face
//ystart = -1;
//xstart = -1;
//for (int y = 0; y<resolution; y++) // for each quad in the y direction
//{
// for (int x = 0; x < resolution; x++) // for each quad in the x direction
// {
// // Load the vertex array with data.
// //1
// vertices[v].position = XMFLOAT3(xstart, -1.0f, ystart); // Top left. -1.0, 1.0
// vertices[v].texture = XMFLOAT2(txu, txv);
// vertices[v].normal = XMFLOAT3(0.0f, -1.0f, 0.0f);
// indices[i] = i;
// v++;
// i++;
// //0
// vertices[v].position = XMFLOAT3(xstart, -1.0f, ystart + yincrement); // Bottom left. -1. -1. 0
// vertices[v].texture = XMFLOAT2(txu, txv + txvinc);
// vertices[v].normal = XMFLOAT3(0.0f, -1.0f, 0.0f);
// indices[i] = i;
// v++;
// i++;
// //3
// vertices[v].position = XMFLOAT3(xstart + xincrement, -1.0f, ystart + yincrement); // Bottom right. 1.0, -1.0, 0.0
// vertices[v].texture = XMFLOAT2(txu + txuinc, txv + txvinc);
// vertices[v].normal = XMFLOAT3(0.0f, -1.0f, 0.0f);
// indices[i] = i;
// v++;
// i++;
// //2
// vertices[v].position = XMFLOAT3(xstart + xincrement, -1.0f, ystart); // Top right. 1.0, 1.0 0.0
// vertices[v].texture = XMFLOAT2(txu + txuinc, txv);
// vertices[v].normal = XMFLOAT3(0.0f, -1.0f, 0.0f);
// indices[i] = i;
// v++;
// i++;
// ////0
// //vertices[v].position = XMFLOAT3(xstart, -1.0f, ystart + yincrement); // Bottom left. -1. -1. 0
// //vertices[v].texture = XMFLOAT2(txu, txv + txvinc);
// //vertices[v].normal = XMFLOAT3(0.0f, -1.0f, 0.0f);
// //indices[i] = i;
// //v++;
// //i++;
// ////2
// //vertices[v].position = XMFLOAT3(xstart + xincrement, -1.0f, ystart); // Top right. 1.0, 1.0 0.0
// //vertices[v].texture = XMFLOAT2(txu + txuinc, txv);
// //vertices[v].normal = XMFLOAT3(0.0f, -1.0f, 0.0f);
// //indices[i] = i;
// //v++;
// //i++;
// // increment
// xstart += xincrement;
// //ystart -= yincrement;
// txu += txuinc;
// }
// ystart += yincrement;
// xstart = -1;
// txu = 0;
// txv += txvinc;
//}
// Set up the description of the static vertex buffer.
vertexBufferDesc.Usage = D3D11_USAGE_DEFAULT;
vertexBufferDesc.ByteWidth = sizeof(VertexType)* m_vertexCount;
vertexBufferDesc.BindFlags = D3D11_BIND_VERTEX_BUFFER;
vertexBufferDesc.CPUAccessFlags = 0;
vertexBufferDesc.MiscFlags = 0;
vertexBufferDesc.StructureByteStride = 0;
// Give the subresource structure a pointer to the vertex data.
vertexData.pSysMem = vertices;
vertexData.SysMemPitch = 0;
vertexData.SysMemSlicePitch = 0;
// Now create the vertex buffer.
device->CreateBuffer(&vertexBufferDesc, &vertexData, &m_vertexBuffer);
// Set up the description of the static index buffer.
indexBufferDesc.Usage = D3D11_USAGE_DEFAULT;
indexBufferDesc.ByteWidth = sizeof(unsigned long)* m_indexCount;
indexBufferDesc.BindFlags = D3D11_BIND_INDEX_BUFFER;
indexBufferDesc.CPUAccessFlags = 0;
indexBufferDesc.MiscFlags = 0;
indexBufferDesc.StructureByteStride = 0;
// Give the subresource structure a pointer to the index data.
indexData.pSysMem = indices;
indexData.SysMemPitch = 0;
indexData.SysMemSlicePitch = 0;
// Create the index buffer.
device->CreateBuffer(&indexBufferDesc, &indexData, &m_indexBuffer);
// Release the arrays now that the vertex and index buffers have been created and loaded.
delete[] vertices;
vertices = 0;
delete[] indices;
indices = 0;
}
void TesselatedQuadMess::SendData(ID3D11DeviceContext* deviceContext)
{
unsigned int stride;
unsigned int offset;
// Set vertex buffer stride and offset.
stride = sizeof(VertexType);
offset = 0;
// Set the vertex buffer to active in the input assembler so it can be rendered.
deviceContext->IASetVertexBuffers(0, 1, &m_vertexBuffer, &stride, &offset);
// Set the index buffer to active in the input assembler so it can be rendered.
deviceContext->IASetIndexBuffer(m_indexBuffer, DXGI_FORMAT_R32_UINT, 0);
// Set the type of primitive that should be rendered from this vertex buffer, in this case control patch for tessellation.
deviceContext->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_4_CONTROL_POINT_PATCHLIST);
}
| [
"="
] | = |
29ae5a3e1aa492953a6d6da44ae291f637e84165 | b41db21e54e088200157105345070f01e9557ced | /AtCoderBeginnerContest/165/b.cpp | c6eeacd42e0ae6cd58758540fbff0d5f526a22d5 | [] | no_license | tsugupoyo/AtCoder | e6ce8692e133028264eb8f85f765d988306feb97 | 3b1cd63097c47bf039de87f943346fc0d787cc83 | refs/heads/main | 2023-06-02T06:40:34.981731 | 2021-06-21T02:56:36 | 2021-06-21T02:56:36 | 378,789,517 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 316 | cpp | #include <bits/stdc++.h>
using namespace std;
using ll=long long;
#define rep(i,n) for(int i=0;i<(int)(n);i++)
const int INF =1001001001;
using P = pair<int,int>;
int main(void)
{
ll x;
cin >> x;
ll ans =0;
ll m = 100;
while(x > m){
m = m * 1.01;
ans++;
}
cout << ans << endl;
} | [
"fujiwaratakatsugu@fujiwaratakashinoMacBook-puro.local"
] | fujiwaratakatsugu@fujiwaratakashinoMacBook-puro.local |
afc66a9f923dec36c4771a69a7ddeda2b1a2e25c | d2a97eed1e9f2ad11bd9621a38fd3cfc464b4fd7 | /GameEngine/Game.cpp | 120c5f2a7afb8bdd5af9ca502b10503cd82e7b4b | [] | no_license | LakeToya/Rasengine | 69ae645ca37551e5750ffa231e221319b32c3545 | c70818eac899409b1e23fd72738b9232740bbd31 | refs/heads/master | 2021-01-21T20:29:46.018145 | 2017-05-24T02:58:29 | 2017-05-24T02:58:29 | 92,242,571 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,857 | cpp | #include "stdafx.h"
#include "Game.h"
#include "ImageLoader.h"
#include <iostream>
#include <GL/glew.h>
Game::Game() :
_currentState(GameState::PLAYING),
_window(nullptr),
_screenWidth(800),
_screenHeight(600),
_time(0.0f),
_desiredFPS(60.0f)
{
}
Game::~Game()
{
}
void Game::Run()
{
Init();
_sprites.push_back(new Sprite());
_sprites.back()->Init(-1.0f, -0.0f, 1.0f, 1.0f);
_sprites.back()->LoadTexture("Sprites/underworld.jpg");
_sprites.push_back(new Sprite());
_sprites.back()->Init(-1.0f, -1.0f, 1.0f, 1.0f);
_sprites.back()->LoadTexture("Sprites/underworld.jpg");
_sprites.push_back(new Sprite());
_sprites.back()->Init(-0.0f, -1.0f, 1.0f, 1.0f);
_sprites.back()->LoadTexture("Sprites/underworld.jpg");
_sprite.Init(-0.9f, -0.5f,1.0f,1.0f);
_sprite.LoadTexture("Sprites/underworld.jpg");
Loop();
}
void Game::GetFPS()
{
static const int NUM_SAMPLES = 10;
static float frametimes[NUM_SAMPLES];
static int index = 0;
static int printCount = 0;
static float prevTicks = SDL_GetTicks();
float currentTicks;
currentTicks = SDL_GetTicks();
_frameTime = currentTicks - prevTicks;
frametimes[index % NUM_SAMPLES] = _frameTime;
prevTicks = currentTicks;
int count;
index++;
if (index < NUM_SAMPLES)
{
count = index;
}
else
{
count = NUM_SAMPLES;
}
float frameTimeAverage = 0;
for (int i = 0; i < count; i++)
{
frameTimeAverage += frametimes[i];
}
frameTimeAverage /= count;
if (frameTimeAverage > 0)
{
_fps = 1000.0f/frameTimeAverage;
}
else
{
_fps = 0;
}
//Print out FPS
if (printCount > 30)
{
std::cout << _fps << std::endl;
printCount = 0;
}
printCount+=1;
}
void Game::Init()
{
SDL_Init(SDL_INIT_EVERYTHING);
//Tell SDL to use double buffer window
SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
_window = SDL_CreateWindow("GameEngine",SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED,
_screenWidth,_screenHeight,SDL_WINDOW_OPENGL);
SDL_GLContext glContex = SDL_GL_CreateContext(_window);
if (glContex == nullptr)
{
printf("SDL_GL context could not be created");
}
GLenum error = glewInit();
if (error != GLEW_OK)
{
printf("Could not initialize GLEW");
}
//Set Background Color
glClearColor(0.0f,0.0f,0.0f,1.0f);
//Check OpenGL Version
std::printf("*** OpenGL Version: %s ***", glGetString(GL_VERSION));
//Enable/Disable VSYNC
SDL_GL_SetSwapInterval(0);
InitShaders();
}
void Game::InitShaders()
{
_colorProgram.CompileShaders("Shaders/colorShading.vert", "Shaders/colorShading.frag");
_colorProgram.AddAttribute("vertexPosition");
_colorProgram.AddAttribute("vertexColor");
_colorProgram.AddAttribute("vertexUV");
_colorProgram.LinkShaders();
}
void Game::ProcessInput()
{
while (SDL_PollEvent(&event))
{
switch (event.type)
{
case SDL_QUIT:
_currentState = GameState::EXIT;
break;
}
}
}
void Game::Loop()
{
while (_currentState != GameState::EXIT)
{
float startTicks = SDL_GetTicks();
ProcessInput();
_time += 0.03f;
GetFPS();
Draw();
float frameTicks = SDL_GetTicks() - startTicks;
//LimitFPS
if ((1000.0f / _desiredFPS) > frameTicks)
{
SDL_Delay(1000.0f / _desiredFPS - frameTicks);
}
}
}
void Game::Draw()
{
//set base depth to zero
glClearDepth(1.0);
//clear the color and depth buffer
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
_colorProgram.Use();
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, _sprite.GetTexture().id);
GLuint timeLocation = _colorProgram.GetUnifromLocation("time");
glUniform1f(timeLocation, _time);
GLint textureLocation = _colorProgram.GetUnifromLocation("mySampler");
glUniform1f(textureLocation, 0);
for (int i = 0; i < _sprites.size();i++)
{
_sprites[i]->Draw();
}
glBindTexture(GL_TEXTURE_2D, 0);
_colorProgram.Unuse();
//swap our buffer and draw everything to screen
SDL_GL_SwapWindow(_window);
}
| [
"Flamenbst@gmail.com"
] | Flamenbst@gmail.com |
6956a4a3b3dc92ad4e1900241f72d4a99293b3ae | 353dd588948c176a1d99f1f1669c2351ad57cf90 | /libs/space.hpp | 65c55c7c12999b37926899e31a2fe218cc6776ea | [] | no_license | LordPax/graviter-simulator | 024cfddf04cecc2531b939f34afc0380852e6ba1 | 6a27012514f93ed5fd3647fe9030b3ddf8d3618e | refs/heads/master | 2023-04-20T06:51:27.775679 | 2021-05-08T20:59:21 | 2021-05-08T20:59:21 | 363,765,000 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 282 | hpp | #ifndef SPACE_HPP
#define SPACE_HPP
#include "graviter.hpp"
class Space {
private :
std::vector<Planets> planets;
int nb;
public:
Space(sf::RenderWindow *win, int nb, int masse);
void updatePlanets();
void drawPlanets();
};
#endif | [
"capitaine_ted@hotmail.fr"
] | capitaine_ted@hotmail.fr |
ca600aac29832dd49e9a10659b29a7495d66d4c8 | 4c6bd957eb453ca094c278758044707cdfe391f4 | /DirectXGame/DirectXCore/Camera.h | 4ae3e615ca07d0feb847aa621ae1364048496e04 | [
"MIT"
] | permissive | REVOLUTION-Game-Creation-Club/DirectX-11-Game | 6188957be32a08e7c0e12384c3f2601254ffa44b | a56b7ed0e6758ef37b338e07d0c120e0ff736963 | refs/heads/master | 2022-02-15T02:46:05.064718 | 2018-10-03T02:26:41 | 2018-10-03T02:26:41 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,106 | h | #pragma once
#include "stdafx.h"
namespace DirectXCore
{
class Camera
{
public:
Camera();
Camera(int _x, int _y);
void SetPosition(int _x, int _y);
void SetPosition(DirectX::SimpleMath::Vector2 _pos) { camPosition = _pos; }
DirectX::SimpleMath::Vector2 GetPosition() { return camPosition; }
RECT GetBound();
DirectX::SimpleMath::Matrix GetView() { return DirectX::XMMatrixLookAtRH(this->GetPosition(), DirectX::SimpleMath::Vector3::Forward, DirectX::SimpleMath::Vector3::Up); }
int GetWidth() { return camViewport.Width; }
int GetHeight() { return camViewport.Height; }
bool IsContain(DirectX::SimpleMath::Vector2 _objectPosition);
void SetViewPort(int _upperX, int _upperY, int _wid, int _hei);
void InitializeOthoMatrix(int _wid, int _hei, float _near, float _far);
void InitializeProjectionMatrix(float _fov, float _aspect, float _near, float _far);
~Camera();
private:
DirectX::SimpleMath::Vector2 camPosition;
D3D11_VIEWPORT camViewport;
DirectX::SimpleMath::Vector4 view;
DirectX::SimpleMath::Vector4 projection;
DirectX::SimpleMath::Vector4 ortho;
};
}
| [
"noreply@github.com"
] | noreply@github.com |
3ba50985a5d8f1bca5de9b8bf56add8636400fbc | 5838cf8f133a62df151ed12a5f928a43c11772ed | /NT/net/ipsec/nshipsec/staticshowlist.cpp | 590339733897c491c0212fc222fcb0dff072392a | [] | no_license | proaholic/Win2K3 | e5e17b2262f8a2e9590d3fd7a201da19771eb132 | 572f0250d5825e7b80920b6610c22c5b9baaa3aa | refs/heads/master | 2023-07-09T06:15:54.474432 | 2021-08-11T09:09:14 | 2021-08-11T09:09:14 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 41,636 | cpp | ////////////////////////////////////////////////////////////////////
// Module: Static/StaticShowList.cpp
//
// Purpose: Static Module Implementation.
//
// Developers Name: Surya
//
// History:
//
// Date Author Comments
// 10-8-2001 Surya Initial Version. SCM Base line 1.0
//
////////////////////////////////////////////////////////////////////
#include "nshipsec.h"
extern HINSTANCE g_hModule;
extern STORAGELOCATION g_StorageLocation;
////////////////////////////////////////////////////////////////////
//
//Function: PrintPolicyList()
//
//Date of Creation: 21st Aug 2001
//
//Parameters:
// IN PIPSEC_POLICY_DATA pPolicy,
// IN BOOL bVerb,
// IN BOOL bAssigned,
// IN BOOL bWide
//Return: DWORD
//
//Description:
// This function prints out the Policy information.
//
//Revision History:
//
//Date Author Comments
//
////////////////////////////////////////////////////////////////////
DWORD
PrintPolicyList(
IN PIPSEC_POLICY_DATA pPolicy,
IN BOOL bVerb,
IN BOOL bAssigned,
IN BOOL bWide
)
{
_TCHAR pszGUIDStr[BUFFER_SIZE]={0};
_TCHAR pszStrTime[BUFFER_SIZE]={0};
_TCHAR pszStrTruncated[BUFFER_SIZE]={0};
DWORD i=0,k=0,dwReturn = ERROR_SUCCESS;
BOOL bDsPolAssigned = FALSE;
PrintMessageFromModule(g_hModule,SHW_STATIC_PRTFSPEC_NEWLINE);
// print name
if(pPolicy->pszIpsecName)
{
TruncateString(pPolicy->pszIpsecName,pszStrTruncated,POL_TRUNC_LEN_TABLE_VER,bWide);
PrintMessageFromModule(g_hModule,SHW_STATIC_PRTPOLICY_POL_NAME_STR,pszStrTruncated);
}
// print desc
if(pPolicy->pszDescription)
{
TruncateString(pPolicy->pszDescription,pszStrTruncated,POL_TRUNC_LEN_TABLE_VER,bWide);
PrintMessageFromModule(g_hModule,SHW_STATIC_PRTPOLICY_POL_DESC_STR,pszStrTruncated);
}
else
{
PrintMessageFromModule(g_hModule,SHW_STATIC_PRTPOLICY_POL_DESC_NONE);
}
if (bVerb) // storage info
{
dwReturn = PrintStorageInfoList(FALSE);
if(dwReturn == ERROR_OUTOFMEMORY)
{
BAIL_OUT;
}
}
//last modified time
FormatTime((time_t)pPolicy->dwWhenChanged, pszStrTime);
PrintMessageFromModule(g_hModule,SHW_STATIC_PRTFILTERDATA_FL_LASTMODIFIED,pszStrTime);
if(bVerb)
{
i=StringFromGUID2(pPolicy->PolicyIdentifier,pszGUIDStr,BUFFER_SIZE);
if(i>0 && (_tcscmp(pszGUIDStr,_TEXT(""))!=0))
{
PrintMessageFromModule(g_hModule,SHW_STATIC_PRTFILTERDATA_FL_GUID,pszGUIDStr);
}
}
//whether the policy is active
if(g_StorageLocation.dwLocation !=IPSEC_DIRECTORY_PROVIDER)
{
if(bAssigned)
{
if (
ERROR_SUCCESS == IPSecIsDomainPolicyAssigned(&bDsPolAssigned) &&
g_StorageLocation.dwLocation != IPSEC_PERSISTENT_PROVIDER &&
bDsPolAssigned
)
{
PrintMessageFromModule(g_hModule,SHW_STATIC_PRTPOLICY_ASSIGNED_AD);
}
else
{
PrintMessageFromModule(g_hModule,SHW_STATIC_PRTPOLICY_ASSIGNED_YES_STR);
}
}
else
{
PrintMessageFromModule(g_hModule,SHW_STATIC_PRTPOLICY_ASSIGNED_NO_STR);
}
}
if(!bVerb)
{
if(pPolicy->pIpsecISAKMPData->ISAKMPPolicy.PfsIdentityRequired)
{
PrintMessageFromModule(g_hModule,SHW_STATIC_PRTPOLICY_MMPFS_YES_STR);
}
else
{
PrintMessageFromModule(g_hModule,SHW_STATIC_PRTPOLICY_MMPFS_NO_STR);
}
}
PrintMessageFromModule(g_hModule,SHW_STATIC_PRTPOLICY_POLL_INTERVAL, (pPolicy->dwPollingInterval)/60);
if (bVerb) //verbose mode
{
PrintMessageFromModule(g_hModule,SHW_STATIC_PRTISAKMP_MMLIFETIME_STR,(pPolicy->pIpsecISAKMPData->pSecurityMethods[0].Lifetime.Seconds)/60 ,pPolicy->pIpsecISAKMPData->pSecurityMethods[0].QuickModeLimit);
if(pPolicy->pIpsecISAKMPData->ISAKMPPolicy.PfsIdentityRequired)
{
PrintMessageFromModule(g_hModule,SHW_STATIC_PRTPOLICY_MMPFS_YES_STR);
}
else
{
PrintMessageFromModule(g_hModule,SHW_STATIC_PRTPOLICY_MMPFS_NO_STR);
}
if(pPolicy->pIpsecISAKMPData) // print the ISAKMP data structure details
{
PrintISAKMPDataList(pPolicy->pIpsecISAKMPData);
}
PrintMessageFromModule(g_hModule,SHW_STATIC_PRTPOLICY_RULE_COUNT, pPolicy->dwNumNFACount);
PrintMessageFromModule(g_hModule,SHW_STATIC_PRTPOLICY_RULE_DETAILS_TITLE);
PrintMessageFromModule(g_hModule,SHW_STATIC_PRTPOLICY_RULE_DETAILS_UNDERLINE);
//print rule data structures
for (DWORD j=0;j<pPolicy->dwNumNFACount;j++)
{
if(pPolicy->ppIpsecNFAData[j])
{
k=StringFromGUID2(pPolicy->ppIpsecNFAData[j]->NFAIdentifier,pszGUIDStr,BUFFER_SIZE);
if(k>0 && (_tcscmp(pszGUIDStr,_TEXT(""))!=0))
{
PrintMessageFromModule(g_hModule,SHW_STATIC_RULE_RULE_ID_GUID,j+1,pszGUIDStr);
}
dwReturn = PrintRuleList(pPolicy->ppIpsecNFAData[j],bVerb,bWide);
if(dwReturn == ERROR_OUTOFMEMORY)
{
BAIL_OUT;
}
}
}
}
error:
return dwReturn;
}
////////////////////////////////////////////////////////////////////
//
//Function: PrintRuleList()
//
//Date of Creation: 21st Aug 2001
//
//Parameters:
// IN PIPSEC_NFA_DATA pIpsecNFAData,
// IN BOOL bVerb,
// IN BOOL bWide
//
//Return: DWORD
//
//Description:
// This function prints out the Rule information.
//
//Revision History:
//
//Date Author Comments
//
////////////////////////////////////////////////////////////////////
DWORD
PrintRuleList(
IN PIPSEC_NFA_DATA pIpsecNFAData,
IN BOOL bVerb,
IN BOOL bWide
)
{
_TCHAR pszStrTime[BUFFER_SIZE]={0};
_TCHAR pszStrTruncated[BUFFER_SIZE]={0};
DWORD dwReturn = ERROR_SUCCESS;
if(pIpsecNFAData->pszIpsecName)
{
TruncateString(pIpsecNFAData->pszIpsecName,pszStrTruncated,POL_TRUNC_LEN_TABLE_VER,bWide);
PrintMessageFromModule(g_hModule,SHW_STATIC_PRTRULE_RULE_NAME_STR,pszStrTruncated);
}
else
{
PrintMessageFromModule(g_hModule,SHW_STATIC_PRTRULE_RULE_NAME_NONE);
}
if(bVerb)
{
if(pIpsecNFAData->pszDescription)
{
TruncateString(pIpsecNFAData->pszDescription,pszStrTruncated,POL_TRUNC_LEN_TABLE_VER,bWide);
PrintMessageFromModule(g_hModule,SHW_STATIC_PRTPOLICY_POL_DESC_STR,pszStrTruncated);
}
else
{
PrintMessageFromModule(g_hModule,SHW_STATIC_PRTPOLICY_POL_DESC_NONE);
}
}
//last modified time
FormatTime((time_t)pIpsecNFAData->dwWhenChanged, pszStrTime);
PrintMessageFromModule(g_hModule,SHW_STATIC_PRTFILTERDATA_FL_LASTMODIFIED,pszStrTime);
if(pIpsecNFAData->dwActiveFlag)
{
PrintMessageFromModule(g_hModule,SHW_STATIC_PRTRULE_ACTIVATED_YES_STR);
}
else
{
PrintMessageFromModule(g_hModule,SHW_STATIC_PRTRULE_ACTIVATED_NO_STR);
}
if(!bVerb) //non verbose
{
if(pIpsecNFAData->pIpsecFilterData && pIpsecNFAData->pIpsecFilterData->pszIpsecName)
{
TruncateString(pIpsecNFAData->pIpsecFilterData->pszIpsecName,pszStrTruncated,POL_TRUNC_LEN_TABLE_VER,bWide);
PrintMessageFromModule(g_hModule,SHW_STATIC_RULE_FL_NAME_STR,pszStrTruncated);
}
else
PrintMessageFromModule(g_hModule,SHW_STATIC_RULE_FL_NAME_NONE);
if(pIpsecNFAData->pIpsecNegPolData && pIpsecNFAData->pIpsecNegPolData->pszIpsecName)
{
TruncateString(pIpsecNFAData->pIpsecNegPolData->pszIpsecName,pszStrTruncated,POL_TRUNC_LEN_TABLE_VER,bWide);
PrintMessageFromModule(g_hModule,SHW_STATIC_PRTNEGPOL_FA_NAME_STR,pszStrTruncated);
}
else
PrintMessageFromModule(g_hModule,SHW_STATIC_PRTNEGPOL_FA_NAME_NONE);
}
if(pIpsecNFAData->dwTunnelIpAddr!=0)
{
PrintMessageFromModule(g_hModule,SHW_STATIC_PRTRULE_TUNNEL_IP);
PrintIPAddrList(pIpsecNFAData->dwTunnelIpAddr);
}
//interface type
if(pIpsecNFAData->dwInterfaceType==(DWORD)PAS_INTERFACE_TYPE_ALL)
{
PrintMessageFromModule(g_hModule,SHW_STATIC_PRTRULE_CONN_ALL_STR);
}
else if(pIpsecNFAData->dwInterfaceType==(DWORD)PAS_INTERFACE_TYPE_LAN)
{
PrintMessageFromModule(g_hModule,SHW_STATIC_PRTRULE_CONN_LAN_STR);
}
else if(pIpsecNFAData->dwInterfaceType==(DWORD)PAS_INTERFACE_TYPE_DIALUP)
{
PrintMessageFromModule(g_hModule,SHW_STATIC_PRTRULE_CONN_DIALUP_STR);
}
else
{
PrintMessageFromModule(g_hModule,SHW_STATIC_PRTRULE_CONN_NONE_STR);
}
//auth count
if ( pIpsecNFAData->dwAuthMethodCount)
{
PrintMessageFromModule(g_hModule,SHW_STATIC_PRTRULE_AUTH_TITLE,pIpsecNFAData->dwAuthMethodCount);
}
for (DWORD j=0;j<(pIpsecNFAData->dwAuthMethodCount);j++)
{
// print auth methods details
if(pIpsecNFAData->ppAuthMethods[j])
{
PrintAuthMethodsList(pIpsecNFAData->ppAuthMethods[j]);
}
}
if(bVerb)
{
//print the filter data details
if (pIpsecNFAData->pIpsecFilterData)
{
PrintMessageFromModule(g_hModule,SHW_STATIC_PRTRULE_FL_DETAILS_TITLE);
PrintMessageFromModule(g_hModule,SHW_STATIC_PRTRULE_FL_DETAILS_UNDERLINE);
if(pIpsecNFAData->pIpsecFilterData)
{
dwReturn = PrintFilterDataList(pIpsecNFAData->pIpsecFilterData,bVerb,FALSE,bWide);
if(dwReturn == ERROR_OUTOFMEMORY)
{
BAIL_OUT;
}
}
}
else
{
PrintMessageFromModule(g_hModule,SHW_STATIC_PRTRULE_NO_FL_FOR_DEF_RULE);
}
PrintMessageFromModule(g_hModule,SHW_STATIC_PRTRULE_FA_DETAILS_TITLE);
PrintMessageFromModule(g_hModule,SHW_STATIC_PRTRULE_FA_TITLE_UNDERLINE);
//print the filter action details
if(pIpsecNFAData->pIpsecNegPolData)
{
PrintNegPolDataList(pIpsecNFAData->pIpsecNegPolData,bVerb,bWide);
}
}
error:
return dwReturn;
}
////////////////////////////////////////////////////////////////////
//
//Function: PrintNegPolDataList()
//
//Date of Creation: 21st Aug 2001
//
//Parameters:
// IN PIPSEC_NEGPOL_DATA pIpsecNegPolData,
// IN BOOL bVerb,
// IN BOOL bWide
//
//Return: VOID
//
//Description:
// This function prints out the Negotiation Policy information.
//
//Revision History:
//
//Date Author Comments
//
////////////////////////////////////////////////////////////////////
VOID
PrintNegPolDataList(
IN PIPSEC_NEGPOL_DATA pIpsecNegPolData,
IN BOOL bVerb,
IN BOOL bWide
)
{
BOOL bSoft=FALSE;
_TCHAR pszGUIDStr[BUFFER_SIZE]={0};
_TCHAR pszStrTime[BUFFER_SIZE]={0};
_TCHAR pszStrTruncated[BUFFER_SIZE]={0};
DWORD i=0;
if(pIpsecNegPolData)
{
PrintMessageFromModule(g_hModule,SHW_STATIC_PRTFSPEC_NEWLINE);
//print filteraction name
if(pIpsecNegPolData->pszIpsecName)
{
TruncateString(pIpsecNegPolData->pszIpsecName,pszStrTruncated,POL_TRUNC_LEN_TABLE_VER,bWide);
PrintMessageFromModule(g_hModule,SHW_STATIC_PRTNEGPOL_FA_NAME_STR,pszStrTruncated);
}
else
{
PrintMessageFromModule(g_hModule,SHW_STATIC_PRTNEGPOL_FA_NAME_NONE);
}
if(pIpsecNegPolData->pszDescription)
{
TruncateString(pIpsecNegPolData->pszDescription,pszStrTruncated,POL_TRUNC_LEN_TABLE_VER,bWide);
PrintMessageFromModule(g_hModule,SHW_STATIC_PRTPOLICY_POL_DESC_STR,pszStrTruncated);
}
else
{
PrintMessageFromModule(g_hModule,SHW_STATIC_PRTPOLICY_POL_DESC_NONE);
}
if(bVerb) //storage info
{
PrintStorageInfoList(FALSE);
}
//print action
if (!(pIpsecNegPolData->NegPolType==GUID_NEGOTIATION_TYPE_DEFAULT))
{
if(pIpsecNegPolData->NegPolAction==GUID_NEGOTIATION_ACTION_NO_IPSEC)
{
PrintMessageFromModule(g_hModule,SHW_STATIC_PRTNEGPOL_ACTION_PERMIT);
}
else if(pIpsecNegPolData->NegPolAction==GUID_NEGOTIATION_ACTION_BLOCK)
{
PrintMessageFromModule(g_hModule,SHW_STATIC_PRTNEGPOL_ACTION_BLOCK);
}
else
{
PrintMessageFromModule(g_hModule,SHW_STATIC_PRTNEGPOL_ACTION_NEGOTIATE);
}
}
for (DWORD cnt=0;cnt<pIpsecNegPolData->dwSecurityMethodCount;cnt++)
{
if (CheckSoft(pIpsecNegPolData->pIpsecSecurityMethods[cnt])) { bSoft=TRUE; break;}
}
//soft association
if(bSoft)
{
PrintMessageFromModule(g_hModule,SHW_STATIC_PRTNEGPOL_SOFT_YES_STR);
}
else
{
PrintMessageFromModule(g_hModule,SHW_STATIC_PRTNEGPOL_SOFT_NO_STR);
}
if(pIpsecNegPolData->NegPolAction==GUID_NEGOTIATION_ACTION_INBOUND_PASSTHRU)
{
PrintMessageFromModule(g_hModule,SHW_STATIC_PRTNEGPOL_INPASS_YES_STR);
}
else
{
PrintMessageFromModule(g_hModule,SHW_STATIC_PRTNEGPOL_INPASS_NO_STR);
}
if(bVerb)
{
if (pIpsecNegPolData->dwSecurityMethodCount )
{
if(pIpsecNegPolData->pIpsecSecurityMethods && pIpsecNegPolData->pIpsecSecurityMethods[0].PfsQMRequired)
PrintMessageFromModule(g_hModule,SHW_STATIC_PRTNEGPOL_QMPFS_YES_STR);
else
PrintMessageFromModule(g_hModule,SHW_STATIC_PRTNEGPOL_QMPFS_NO_STR);
}
}
//last modified time
FormatTime((time_t)pIpsecNegPolData->dwWhenChanged, pszStrTime);
PrintMessageFromModule(g_hModule,SHW_STATIC_PRTFILTERDATA_FL_LASTMODIFIED,pszStrTime);
//print guid
i=StringFromGUID2(pIpsecNegPolData->NegPolIdentifier,pszGUIDStr,BUFFER_SIZE);
if(i>0 && (_tcscmp(pszGUIDStr,_TEXT(""))!=0))
PrintMessageFromModule(g_hModule,SHW_STATIC_PRTFILTERDATA_FL_GUID,pszGUIDStr);
if (bVerb)
{
//print security methods
if (pIpsecNegPolData->dwSecurityMethodCount)
{
PrintMessageFromModule(g_hModule,SHW_STATIC_TAB_PRTNEGPOL_SEC_MTHD_TITLE);
PrintMessageFromModule(g_hModule,SHW_STATIC_TAB_PRTNEGPOL_ALGO_TITLE);
PrintMessageFromModule(g_hModule,SHW_STATIC_TAB_PRTNEGPOL_ALGO_UNDERLINE);
}
for (DWORD cnt=0;cnt<pIpsecNegPolData->dwSecurityMethodCount;cnt++)
{
if(pIpsecNegPolData->pIpsecSecurityMethods)
{
PrintSecurityMethodsTable(pIpsecNegPolData->pIpsecSecurityMethods[cnt]);
}
}
}
}
}
////////////////////////////////////////////////////////////////////
//
//Function: PrintAuthMethodsList()
//
//Date of Creation: 21st Aug 2001
//
//Parameters:
// IN PIPSEC_AUTH_METHOD pIpsecAuthData
//
//Return: VOID
//
//Description:
// This function prints out Authentication details.
//
//Revision History:
//
//Date Author Comments
//
////////////////////////////////////////////////////////////////////
VOID
PrintAuthMethodsList(
IN PIPSEC_AUTH_METHOD pIpsecAuthData
)
{
if(pIpsecAuthData)
{
PrintMessageFromModule(g_hModule, DYNAMIC_SHOW_MMF_NEWLINE_TAB);
if(pIpsecAuthData->dwAuthType==IKE_SSPI) //kerb
{
PrintMessageFromModule(g_hModule,SHW_STATIC_PRTAUTH_KERBEROS);
}
else if(pIpsecAuthData->dwAuthType==IKE_RSA_SIGNATURE && pIpsecAuthData->pszAuthMethod)
{
DisplayCertInfo(pIpsecAuthData->pszAuthMethod, pIpsecAuthData->dwAuthFlags);
}
else if (pIpsecAuthData->dwAuthType==IKE_PRESHARED_KEY && pIpsecAuthData->pszAuthMethod)
{
//preshared key
PrintMessageFromModule(g_hModule,SHW_STATIC_PRTAUTH_PRE_STR,pIpsecAuthData->pszAuthMethod);
}
else
{
//none
PrintMessageFromModule(g_hModule,SHW_STATIC_PRTAUTH_NONE_STR);
}
}
}
////////////////////////////////////////////////////////////////////
//
//Function: PrintFilterDataList()
//
//Date of Creation: 21st Aug 2001
//
//Parameters:
// IN PIPSEC_FILTER_DATA pIpsecFilterData,
// IN BOOL bVerb,
// IN BOOL bResolveDNS,
// IN BOOL bWide
//
//Return: DWORD
//
//Description:
// This function prints out Filter list details.
//
//Revision History:
//
//Date Author Comments
//
////////////////////////////////////////////////////////////////////
DWORD
PrintFilterDataList(
IN PIPSEC_FILTER_DATA pIpsecFilterData,
IN BOOL bVerb,
IN BOOL bResolveDNS,
IN BOOL bWide
)
{
_TCHAR pszGUIDStr[BUFFER_SIZE]={0};
_TCHAR pszStrTime[BUFFER_SIZE]={0};
_TCHAR pszStrTruncated[BUFFER_SIZE]={0};
DWORD i=0 , dwReturn = ERROR_SUCCESS;
if (pIpsecFilterData)
{
//name
if(pIpsecFilterData->pszIpsecName)
{
TruncateString(pIpsecFilterData->pszIpsecName,pszStrTruncated,POL_TRUNC_LEN_TABLE_VER,bWide);
PrintMessageFromModule(g_hModule,SHW_STATIC_PRTFILTERDATA_FL_NAME_STR,pszStrTruncated);
}
else
{
PrintMessageFromModule(g_hModule,SHW_STATIC_PRTFILTERDATA_FL_NAME_NONE);
}
//desc
if(pIpsecFilterData->pszDescription)
{
TruncateString(pIpsecFilterData->pszDescription,pszStrTruncated,POL_TRUNC_LEN_TABLE_VER,bWide);
PrintMessageFromModule(g_hModule,SHW_STATIC_PRTPOLICY_POL_DESC_STR,pszStrTruncated);
}
else
{
PrintMessageFromModule(g_hModule,SHW_STATIC_PRTPOLICY_POL_DESC_NONE);
}
if(bVerb) // storage info
{
PrintStorageInfoList(FALSE);
}
if(!bVerb)
{
PrintMessageFromModule(g_hModule,SHW_STATIC_PRTFILTERDATA_FILTERS_COUNT,pIpsecFilterData->dwNumFilterSpecs);
}
//last modified
FormatTime((time_t)pIpsecFilterData->dwWhenChanged, pszStrTime);
PrintMessageFromModule(g_hModule,SHW_STATIC_PRTFILTERDATA_FL_LASTMODIFIED,pszStrTime);
//print guid
i=StringFromGUID2(pIpsecFilterData->FilterIdentifier,pszGUIDStr,BUFFER_SIZE);
if(i>0 && (_tcscmp(pszGUIDStr,_TEXT(""))!=0))
{
PrintMessageFromModule(g_hModule,SHW_STATIC_PRTFILTERDATA_FL_GUID,pszGUIDStr);
}
if(bVerb)
{
PrintMessageFromModule(g_hModule,SHW_STATIC_PRTFILTERDATA_FILTERS_COUNT,pIpsecFilterData->dwNumFilterSpecs);
}
if(bVerb)
{
//print filter specs
if(pIpsecFilterData->dwNumFilterSpecs)
{
PrintMessageFromModule(g_hModule,SHW_STATIC_PRTFILTERDATA_FILTERS_TITLE);
PrintMessageFromModule(g_hModule,SHW_STATIC_PRTFILTERDATA_FILTERS_TITLE_UNDERLINE);
}
for (DWORD k=0;k<pIpsecFilterData->dwNumFilterSpecs;k++)
{
dwReturn = PrintFilterSpecList(pIpsecFilterData->ppFilterSpecs[k],bResolveDNS,bWide);
if(dwReturn == ERROR_OUTOFMEMORY)
{
BAIL_OUT;
}
}
}
}
error:
return dwReturn;
}
////////////////////////////////////////////////////////////////////
//
//Function: PrintFilterSpecList()
//
//Date of Creation: 21st Aug 2001
//
//Parameters:
// IN PIPSEC_FILTER_SPEC pIpsecFilterSpec,
// IN BOOL bResolveDNS,
// IN BOOL bWide
//
//Return: DWORD
//
//Description:
// This function prints the Filter Spec details
//
//Revision History:
//
//Date Author Comments
//
////////////////////////////////////////////////////////////////////
DWORD
PrintFilterSpecList(
IN PIPSEC_FILTER_SPEC pIpsecFilterSpec,
IN BOOL bResolveDNS,
IN BOOL bWide
)
{
DWORD dwReturn = ERROR_SUCCESS;
_TCHAR pszStrTruncated[BUFFER_SIZE]={0};
PFILTERDNS pFilterDNS= new FILTERDNS ;
if(pFilterDNS==NULL)
{
dwReturn = ERROR_OUTOFMEMORY;
BAIL_OUT;
}
GetFilterDNSDetails(pIpsecFilterSpec, pFilterDNS);
if (pFilterDNS)
{
//desc
if ( WcsCmp0(pIpsecFilterSpec->pszDescription,_TEXT(""))!=0)
{
TruncateString(pIpsecFilterSpec->pszDescription,pszStrTruncated,POL_TRUNC_LEN_TABLE_VER,bWide);
PrintMessageFromModule(g_hModule,SHW_STATIC_PRTPOLICY_POL_DESC_STR, pszStrTruncated);
}
else
{
PrintMessageFromModule(g_hModule,SHW_STATIC_PRTPOLICY_POL_DESC_NONE);
}
//mirrored
if(pIpsecFilterSpec->dwMirrorFlag)
{
PrintMessageFromModule(g_hModule,SHW_STATIC_PRTFSPEC_MIR_YES_STR);
}
else
{
PrintMessageFromModule(g_hModule,SHW_STATIC_PRTFSPEC_MIR_NO_STR);
}
//special server and me
if ((pFilterDNS->FilterSrcNameID==FILTER_MYADDRESS)&&(pIpsecFilterSpec->Filter.SrcAddr==0))
{
if((pIpsecFilterSpec->Filter.ExType == EXT_NORMAL)||((pIpsecFilterSpec->Filter.ExType & EXT_DEST)== EXT_DEST))
{
//me
PrintMessageFromModule(g_hModule,SHW_STATIC_PRTFILTER_SRCIP_ME);
}
else if((pIpsecFilterSpec->Filter.ExType & EXT_DEST) != EXT_DEST)
{
if((pIpsecFilterSpec->Filter.ExType & EXT_DEFAULT_GATEWAY)==EXT_DEFAULT_GATEWAY)
{
PrintMessageFromModule(g_hModule,SHW_STATIC_PRTFILTER_SRCIP_DEFGATEWAY);
}
else if((pIpsecFilterSpec->Filter.ExType & EXT_DHCP_SERVER)==EXT_DHCP_SERVER)
{
PrintMessageFromModule(g_hModule,SHW_STATIC_PRTFILTER_SRCIP_DHCPSERVER);
}
else if((pIpsecFilterSpec->Filter.ExType & EXT_WINS_SERVER)== EXT_WINS_SERVER)
{
PrintMessageFromModule(g_hModule,SHW_STATIC_PRTFILTER_SRCIP_WINSSERVER);
}
else if((pIpsecFilterSpec->Filter.ExType & EXT_DNS_SERVER)==EXT_DNS_SERVER)
{
PrintMessageFromModule(g_hModule,SHW_STATIC_PRTFILTER_SRCIP_DNSSERVER);
}
}
}
else if ((pFilterDNS->FilterSrcNameID==FILTER_ANYADDRESS)&&(pIpsecFilterSpec->Filter.SrcAddr==0))
{
//any
PrintMessageFromModule(g_hModule,SHW_STATIC_PRTFILTER_SRCIP_ANY);
}
else
{
//other IP address
PrintMessageFromModule(g_hModule,SHW_STATIC_PRTFILTER_SRCIP_STR);
if(bResolveDNS && (WcsCmp0(pIpsecFilterSpec->pszSrcDNSName,_TEXT("")) != 0))
{
PrintIPAddrDNS(pIpsecFilterSpec->Filter.SrcAddr);
PrintMessageFromModule(g_hModule,SHW_STATIC_PRTFILTER_RESOLVES,pIpsecFilterSpec->pszSrcDNSName);
}
else
{
PrintIPAddrList(pIpsecFilterSpec->Filter.SrcAddr);
}
}
//mask
PrintMessageFromModule(g_hModule,SHW_STATIC_PRTFILTER_SRCIP_MASK);
PrintIPAddrList(pIpsecFilterSpec->Filter.SrcMask);
switch(pFilterDNS->FilterSrcNameID)
{
//dns name
case FILTER_MYADDRESS :
{
if((pIpsecFilterSpec->Filter.ExType == EXT_NORMAL)||((pIpsecFilterSpec->Filter.ExType & EXT_DEST)== EXT_DEST))
{
PrintMessageFromModule(g_hModule,SHW_STATIC_PRTFSPEC_SRCDNS_ME);
}
else if((pIpsecFilterSpec->Filter.ExType & EXT_DEST) != EXT_DEST)
{
if((pIpsecFilterSpec->Filter.ExType & EXT_DEFAULT_GATEWAY)==EXT_DEFAULT_GATEWAY)
{
PrintMessageFromModule(g_hModule,SHW_STATIC_PRTFSPEC_SRCDNS_DEFGATEWAY);
}
else if((pIpsecFilterSpec->Filter.ExType & EXT_DHCP_SERVER)==EXT_DHCP_SERVER)
{
PrintMessageFromModule(g_hModule,SHW_STATIC_PRTFSPEC_SRCDNS_DHCPSERVER);
}
else if((pIpsecFilterSpec->Filter.ExType & EXT_WINS_SERVER)== EXT_WINS_SERVER)
{
PrintMessageFromModule(g_hModule,SHW_STATIC_PRTFSPEC_SRCDNS_WINSSERVER);
}
else if((pIpsecFilterSpec->Filter.ExType & EXT_DNS_SERVER)==EXT_DNS_SERVER)
{
PrintMessageFromModule(g_hModule,SHW_STATIC_PRTFSPEC_SRCDNS_DNSSERVER);
}
}
}
break;
case FILTER_DNSADDRESS:
{
if(!bResolveDNS)
{
PrintMessageFromModule(g_hModule,SHW_STATIC_PRTFSPEC_SRCDNS_STR, pIpsecFilterSpec->pszSrcDNSName);
}
else
{
PrintMessageFromModule(g_hModule,SHW_STATIC_PRTFSPEC_SRCDNS_RESOLVE, pIpsecFilterSpec->pszSrcDNSName);
dwReturn = PrintResolveDNS(pIpsecFilterSpec->pszSrcDNSName);
if(dwReturn == ERROR_OUTOFMEMORY)
{
BAIL_OUT;
}
}
}
break;
case FILTER_ANYADDRESS:
PrintMessageFromModule(g_hModule,SHW_STATIC_PRTFSPEC_SRCDNS_ANY);
break;
case FILTER_IPADDRESS :
PrintMessageFromModule(g_hModule,SHW_STATIC_PRTFSPEC_SRCDNS_SPECIFIC_IP);
break;
case FILTER_IPSUBNET :
PrintMessageFromModule(g_hModule,SHW_STATIC_PRTFSPEC_SRCDNS_SPECIFIC_SUBNET);
break;
default:
PrintMessageFromModule(g_hModule,SHW_STATIC_PRTFSPEC_SRCDNS_ANY);
break;
};
//destination details
if ((pFilterDNS->FilterDestNameID==FILTER_MYADDRESS)&&(pIpsecFilterSpec->Filter.DestAddr==0))
{
if((pIpsecFilterSpec->Filter.ExType == EXT_NORMAL)||((pIpsecFilterSpec->Filter.ExType & EXT_DEST) != EXT_DEST))
{
PrintMessageFromModule(g_hModule,SHW_STATIC_PRTFILTER_DSTIP_ME);
}
else if((pIpsecFilterSpec->Filter.ExType & EXT_DEST) == EXT_DEST)
{
// server types
if((pIpsecFilterSpec->Filter.ExType & EXT_DEFAULT_GATEWAY)==EXT_DEFAULT_GATEWAY)
{
PrintMessageFromModule(g_hModule,SHW_STATIC_PRTFILTER_DSTIP_DEFGATEWAY);
}
else if((pIpsecFilterSpec->Filter.ExType & EXT_DHCP_SERVER)==EXT_DHCP_SERVER)
{
PrintMessageFromModule(g_hModule,SHW_STATIC_PRTFILTER_DSTIP_DHCPSERVER);
}
else if((pIpsecFilterSpec->Filter.ExType & EXT_WINS_SERVER)==EXT_WINS_SERVER)
{
PrintMessageFromModule(g_hModule,SHW_STATIC_PRTFILTER_DSTIP_WINSSERVER);
}
else if((pIpsecFilterSpec->Filter.ExType & EXT_DNS_SERVER)==EXT_DNS_SERVER)
{
PrintMessageFromModule(g_hModule,SHW_STATIC_PRTFILTER_DSTIP_DNSSERVER);
}
}
}
else if ((pFilterDNS->FilterDestNameID==FILTER_ANYADDRESS)&&(pIpsecFilterSpec->Filter.DestAddr==0))
{
PrintMessageFromModule(g_hModule,SHW_STATIC_PRTFILTER_DSTIP_ANY);
}
else
{
PrintMessageFromModule(g_hModule,SHW_STATIC_PRTFILTER_DSTIP_STR);
if(bResolveDNS && (WcsCmp0(pIpsecFilterSpec->pszDestDNSName,_TEXT("")) != 0))
{
PrintIPAddrDNS(pIpsecFilterSpec->Filter.DestAddr);
PrintMessageFromModule(g_hModule,SHW_STATIC_PRTFILTER_RESOLVES,pIpsecFilterSpec->pszDestDNSName);
}
else
{
PrintIPAddrList(pIpsecFilterSpec->Filter.DestAddr);
}
}
PrintMessageFromModule(g_hModule,SHW_STATIC_PRTFILTER_DSTIP_MASK); PrintIPAddrList(pIpsecFilterSpec->Filter.DestMask);
switch(pFilterDNS->FilterDestNameID)
{
case FILTER_MYADDRESS :
{
if((pIpsecFilterSpec->Filter.ExType == EXT_NORMAL)||((pIpsecFilterSpec->Filter.ExType & EXT_DEST) != EXT_DEST))
{
PrintMessageFromModule(g_hModule,SHW_STATIC_PRTFSPEC_DSTDNS_ME);
}
else if((pIpsecFilterSpec->Filter.ExType & EXT_DEST) == EXT_DEST)
{
if((pIpsecFilterSpec->Filter.ExType & EXT_DEFAULT_GATEWAY)==EXT_DEFAULT_GATEWAY)
{
PrintMessageFromModule(g_hModule,SHW_STATIC_PRTFSPEC_DSTDNS_DEFGATEWAY);
}
else if((pIpsecFilterSpec->Filter.ExType & EXT_DHCP_SERVER)==EXT_DHCP_SERVER)
{
PrintMessageFromModule(g_hModule,SHW_STATIC_PRTFSPEC_DSTDNS_DHCPSERVER);
}
else if((pIpsecFilterSpec->Filter.ExType & EXT_WINS_SERVER)==EXT_WINS_SERVER)
{
PrintMessageFromModule(g_hModule,SHW_STATIC_PRTFSPEC_DSTDNS_WINSSERVER);
}
else if((pIpsecFilterSpec->Filter.ExType & EXT_DNS_SERVER)==EXT_DNS_SERVER)
{
PrintMessageFromModule(g_hModule,SHW_STATIC_PRTFSPEC_DSTDNS_DNSSERVER);
}
}
}
break;
case FILTER_DNSADDRESS:
{
if(!bResolveDNS)
{
PrintMessageFromModule(g_hModule,SHW_STATIC_PRTFSPEC_DSTDNS_STR, pIpsecFilterSpec->pszDestDNSName);
}
else // resolve DNS address
{
PrintMessageFromModule(g_hModule,SHW_STATIC_PRTFSPEC_DST_DNS_RESOLVE, pIpsecFilterSpec->pszDestDNSName);
dwReturn = PrintResolveDNS(pIpsecFilterSpec->pszDestDNSName);
if(dwReturn == ERROR_OUTOFMEMORY)
{
BAIL_OUT;
}
}
}
break;
case FILTER_ANYADDRESS: //any
PrintMessageFromModule(g_hModule,SHW_STATIC_PRTFSPEC_DSTDNS_ANY);
break;
case FILTER_IPADDRESS : //a specific IP
PrintMessageFromModule(g_hModule,SHW_STATIC_PRTFSPEC_DSTDNS_SPECIFIC_IP);
break;
case FILTER_IPSUBNET : //a specific IP subnet
PrintMessageFromModule(g_hModule,SHW_STATIC_PRTFSPEC_DSTDNS_SPECIFIC_SUBNET);
break;
default:
PrintMessageFromModule(g_hModule,SHW_STATIC_PRTFSPEC_DSTDNS_ANY);
break;
};
//print protocol
PrintProtocolNameList(pIpsecFilterSpec->Filter.Protocol);
if(pIpsecFilterSpec->Filter.SrcPort)
{
PrintMessageFromModule(g_hModule,SHW_STATIC_PRTFILTER_SRCPORT_STR,pIpsecFilterSpec->Filter.SrcPort);
}
else
{
PrintMessageFromModule(g_hModule,SHW_STATIC_PRTFILTER_SRCPORT_ANY);
}
if(pIpsecFilterSpec->Filter.DestPort)
{
PrintMessageFromModule(g_hModule,SHW_STATIC_PRTFILTER_DSTPORT_STR,pIpsecFilterSpec->Filter.DestPort);
}
else
{
PrintMessageFromModule(g_hModule,SHW_STATIC_PRTFILTER_DSTPORT_ANY);
}
delete pFilterDNS;
PrintMessageFromModule(g_hModule,SHW_STATIC_PRTFSPEC_NEWLINE);
}
error:
return dwReturn;
}
////////////////////////////////////////////////////////////////////
//
//Function: PrintProtocolNameList()
//
//Date of Creation: 21st Aug 2001
//
//Parameters:
// DWORD dwProtocol
//
//Return: VOID
//
//Description:
// This function prints protocol name corresponding to protocoll ID.
//
//Revision History:
//
//Date Author Comments
//
////////////////////////////////////////////////////////////////////
VOID
PrintProtocolNameList(
DWORD dwProtocol
)
{
switch(dwProtocol)
{
case PROT_ID_ICMP :
PrintMessageFromModule(g_hModule, SHW_STATIC_PRTPROTOCOL_ICMP);
break;
case PROT_ID_TCP :
PrintMessageFromModule(g_hModule, SHW_STATIC_PRTPROTOCOL_TCP);
break;
case PROT_ID_UDP :
PrintMessageFromModule(g_hModule, SHW_STATIC_PRTPROTOCOL_UDP);
break;
case PROT_ID_RAW :
PrintMessageFromModule(g_hModule, SHW_STATIC_PRTPROTOCOL_RAW);
break;
case PROT_ID_ANY :
PrintMessageFromModule(g_hModule, SHW_STATIC_PRTPROTOCOL_ANY);
break;
default:
PrintMessageFromModule(g_hModule, SHW_STATIC_PRTPROTOCOL_OTHER, dwProtocol);
break;
};
}
////////////////////////////////////////////////////////////////////
//
//Function: PrintISAKMPDataList()
//
//Date of Creation: 21st Aug 2001
//
//Parameters:
// IN PIPSEC_ISAKMP_DATA pIpsecISAKMPData
//
//Return: VOID
//
//Description:
// This function prints out the ISAKMP details.
//
//Revision History:
//
//Date Author Comments
//
////////////////////////////////////////////////////////////////////
VOID
PrintISAKMPDataList(
IN PIPSEC_ISAKMP_DATA pIpsecISAKMPData
)
{
if(pIpsecISAKMPData)
{
PrintMessageFromModule(g_hModule,SHW_STATIC_PRTISAKMP_MMSEC_ORDER_TITLE);
PrintMessageFromModule(g_hModule,SHW_STATIC_PRTISAKMP_ALGO_TITLE_STR);
PrintMessageFromModule(g_hModule,SHW_STATIC_PRTISAKMP_ALGO_TITLE_UNDERLINE);
for (DWORD Loop=0;Loop<pIpsecISAKMPData->dwNumISAKMPSecurityMethods;Loop++)
{
// print mmsec details
if(pIpsecISAKMPData->pSecurityMethods)
{
PrintISAKAMPSecurityMethodsList(pIpsecISAKMPData->pSecurityMethods[Loop]);
}
}
}
}
////////////////////////////////////////////////////////////////////
//
//Function: PrintISAKAMPSecurityMethodsList()
//
//Date of Creation: 21st Aug 2001
//
//Parameters:
// IN CRYPTO_BUNDLE SecurityMethods
//
//Return: VOID
//
//Description:
// This function prints out the ISAKMP SecurityMethods details.
//
//Revision History:
//
//Date Author Comments
//
////////////////////////////////////////////////////////////////////
VOID
PrintISAKAMPSecurityMethodsList(
IN CRYPTO_BUNDLE SecurityMethods
)
{
// print encription detail
if(SecurityMethods.EncryptionAlgorithm.AlgorithmIdentifier==CONF_ALGO_DES)
{
PrintMessageFromModule(g_hModule,SHW_STATIC_PRTISAKMPSEC_DES_STR);
}
else
{
PrintMessageFromModule(g_hModule,SHW_STATIC_PRTISAKMPSEC_3DES_STR);
}
// print hash detail
if(SecurityMethods.HashAlgorithm.AlgorithmIdentifier==AUTH_ALGO_SHA1)
{
PrintMessageFromModule(g_hModule,SHW_STATIC_PRTISAKMPSEC_SHA1_STR);
}
else
{
PrintMessageFromModule(g_hModule,SHW_STATIC_PRTISAKMPSEC_MD5_STR);
}
// print DH group detail
if(SecurityMethods.OakleyGroup==POTF_OAKLEY_GROUP1)
{
PrintMessageFromModule(g_hModule,SHW_STATIC_PRTISAKMPSEC_DH_LOW_STR);
}
else if (SecurityMethods.OakleyGroup==POTF_OAKLEY_GROUP2)
{
PrintMessageFromModule(g_hModule,SHW_STATIC_PRTISAKMPSEC_DH_MED_STR);
}
else
{
PrintMessageFromModule(g_hModule,SHW_STATIC_PRTISAKMPSEC_DH_2048_STR);
}
}
////////////////////////////////////////////////////////////////////
//
//Function: PrintGPOList()
//
//Date of Creation: 21st Aug 2001
//
//Parameters:
// IN PGPO pGPO,
// IN BOOL bVerb
//
//Return: VOID
//
//Description:
// This function prints the details of GPO .
//
//Revision History:
//
//Date Author Comments
//
////////////////////////////////////////////////////////////////////
VOID
PrintGPOList(
IN PGPO pGPO
)
{
if(!pGPO)
{
BAIL_OUT;
}
if(_tcscmp(pGPO->pszLocalMachineName, _TEXT(""))!=0) //machine name
{
PrintMessageFromModule(g_hModule, SHW_STATIC_ASSIGNEDGPO_SRCMACHINE,pGPO->pszLocalMachineName);
}
else if(pGPO->pszDomainName) //domain name
{
PrintMessageFromModule(g_hModule,SHW_STATIC_ASSIGNEDGPO_SRCDOMAIN,pGPO->pszDomainName);
if (pGPO->pszDCName) //DC name
{
PrintMessageFromModule(g_hModule,SHW_STATIC_ASSIGNEDGPO_DC_NAME,pGPO->pszDCName);
}
}
if( pGPO->pszGPODisplayName ) // gpo name
{
if (pGPO->bDNPolicyOverrides && pGPO->pszGPODNName) //gpo DN
{
PrintMessageFromModule(g_hModule,SHW_STATIC_ASSIGNEDGPO_GPO_NAME_STR,pGPO->pszGPODNName);
}
else
{
PrintMessageFromModule(g_hModule,SHW_STATIC_ASSIGNEDGPO_GPO_NAME_STR,pGPO->pszGPODisplayName);
}
}
if(_tcscmp(pGPO->pszGPODisplayName,LocalGPOName)==0) // policy active - status
{
if(pGPO->bDNPolicyOverrides && (_tcscmp(pGPO->pszGPODisplayName,LocalGPOName)==0))
{
if(pGPO->pszLocalPolicyName) //local policy name
{
PrintMessageFromModule(g_hModule,SHW_STATIC_ASSIGNEDGPO_LOCAL_POL_NAME_STR,pGPO->pszLocalPolicyName);
}
else
{
PrintMessageFromModule(g_hModule,SHW_STATIC_ASSIGNEDGPO_LOC_POL_NAME_NONE);
}
if(pGPO->pszPolicyName)
{
PrintMessageFromModule(g_hModule,SHW_STATIC_ASSIGNEDGPO_AD_POL_NAME_STR,pGPO->pszPolicyName);
}
if(pGPO->pszPolicyDNName) // policy DN
{
PrintMessageFromModule(g_hModule,SHW_STATIC_ASSIGNEDGPO_AD_POL_DN_NAME,pGPO->pszPolicyDNName);
}
PrintMessageFromModule(g_hModule,SHW_STATIC_ASSIGNEDGPO_LOC_OPOL_ACTIVE_AD);
}
else if (_tcscmp(pGPO->pszGPODisplayName,LocalGPOName)==0)
{
if(pGPO->pszPolicyName)
{
PrintMessageFromModule(g_hModule,SHW_STATIC_ASSIGNEDGPO_LOCAL_POL_NAME_STR,pGPO->pszPolicyName);
}
if(pGPO->pszPolicyDNName) // policy DN
{
PrintMessageFromModule(g_hModule,SHW_STATIC_ASSIGNEDGPO_LOC_POL_ACTIVE_STR,pGPO->pszPolicyDNName);
}
PrintMessageFromModule(g_hModule,SHW_STATIC_ASSIGNEDGPO_AD_POL_NAME_NONE);
PrintMessageFromModule(g_hModule,SHW_STATIC_ASSIGNEDGPO_POL_ACTIVE_STR);
}
}
else // if domain policy is active
{
if(pGPO->pszGPODNName) //gpo DN
{
PrintMessageFromModule(g_hModule,SHW_STATIC_ASSIGNEDGPO_GPO_DN_NAME,pGPO->pszGPODNName);
}
if(pGPO->pszOULink) // OU link
{
PrintMessageFromModule(g_hModule,SHW_STATIC_ASSIGNEDGPO_GPO_OU_LINK,pGPO->pszOULink);
}
if(pGPO->pszPolicyName)
{
PrintMessageFromModule(g_hModule,SHW_STATIC_ASSIGNEDGPO_POL_NAME_STR,pGPO->pszPolicyName);
}
if(pGPO->pszPolicyDNName) //Policy DN
{
PrintMessageFromModule(g_hModule,SHW_STATIC_ASSIGNEDGPO_POL_DN_STR,pGPO->pszPolicyDNName);
}
PrintMessageFromModule(g_hModule,SHW_STATIC_ASSIGNEDGPO_POL_ACTIVE_STR);
}
error:
return;
}
////////////////////////////////////////////////////////////////////
//
//Function: PrintIPAddrList()
//
//Date of Creation: 21st Aug 2001
//
//Parameters:
// IN DWORD dwAddr
//
//Return: VOID
//
//Description:
// This function prints out IP Address.
//
//Revision History:
//
//Date Author Comments
//
////////////////////////////////////////////////////////////////////
VOID
PrintIPAddrList(
IN DWORD dwAddr
)
{
_TCHAR szIPAddr[20]= {0};
// not necessary to change to bounded printf
_stprintf(szIPAddr,_T("%d.%d.%d.%d"), (dwAddr & 0x000000FFL),((dwAddr & 0x0000FF00L) >> 8),((dwAddr & 0x00FF0000L) >> 16),((dwAddr & 0xFF000000L) >> 24) );
PrintMessageFromModule(g_hModule,SHW_STATIC_PRTFSPEC_FORMAT_NEWLINE,szIPAddr);
}
////////////////////////////////////////////////////////////////////
//
//Function: PrintStorageInfoList()
//
//Date of Creation: 21st Aug 2001
//
//Parameters:
// IN BOOL bDeleteAll
//
//Return: DWORD
//
//Description:
// This function prints out the the Security Methods information.
//
//Revision History:
//
//Date Author Comments
//
////////////////////////////////////////////////////////////////////
DWORD
PrintStorageInfoList(
IN BOOL bDeleteAll
)
{
DWORD dwReturn = ERROR_SUCCESS , dwStrLength = 0, dwStoreId;
if(g_StorageLocation.dwLocation!=IPSEC_DIRECTORY_PROVIDER) // if it is local GPO
{
if(_tcscmp(g_StorageLocation.pszMachineName,_TEXT(""))!=0)
{
if(!bDeleteAll)
{
if (g_StorageLocation.dwLocation == IPSEC_REGISTRY_PROVIDER)
{
dwStoreId = SHW_STATIC_POLICY_STORE_RM_NAME_STR;
}
else
{
dwStoreId = SHW_STATIC_POLICY_STORE_RM_NAME_STRP;
}
PrintMessageFromModule(g_hModule,dwStoreId,g_StorageLocation.pszMachineName);
}
else
{
PrintMessageFromModule(g_hModule,SHW_STATIC_POLICY_RM_STR,g_StorageLocation.pszMachineName);
}
}
else
{
_TCHAR pszLocalMachineName[MAXSTRLEN] = {0};
DWORD MaxStringLen=MAXSTRLEN;
// Get the computer name
GetComputerName(pszLocalMachineName,&MaxStringLen);
if(!bDeleteAll)
{
if(_tcscmp(pszLocalMachineName,_TEXT(""))!=0)
{
if (g_StorageLocation.dwLocation == IPSEC_REGISTRY_PROVIDER)
{
dwStoreId = SHW_STATIC_POLICY_STORE_LM_NAME_STR;
}
else
{
dwStoreId = SHW_STATIC_POLICY_STORE_LM_NAME_STRP;
}
PrintMessageFromModule(g_hModule,dwStoreId,pszLocalMachineName);
}
else
{
if (g_StorageLocation.dwLocation == IPSEC_REGISTRY_PROVIDER)
{
dwStoreId = SHW_STATIC_POLICY_STORE_LM_STR;
}
else
{
dwStoreId = SHW_STATIC_POLICY_STORE_LM_STRP;
}
PrintMessageFromModule(g_hModule,dwStoreId);
}
}
else
{
if(_tcscmp(pszLocalMachineName,_TEXT(""))!=0)
{
PrintMessageFromModule(g_hModule,SHW_STATIC_POLICY_LM_STR,pszLocalMachineName);
}
else
{
PrintMessageFromModule(g_hModule,SHW_STATIC_POLICY_LM);
}
}
}
}
else if(g_StorageLocation.dwLocation==IPSEC_DIRECTORY_PROVIDER) // if remote GPO
{
if(_tcscmp(g_StorageLocation.pszDomainName,_TEXT(""))!=0)
{
if(!bDeleteAll)
{
PrintMessageFromModule(g_hModule,SHW_STATIC_POLICY_STORE_LD_NAME_STR,g_StorageLocation.pszDomainName);
}
else
{
PrintMessageFromModule(g_hModule,SHW_STATIC_POLICY_RD_STR,g_StorageLocation.pszDomainName);
}
}
else
{
PDOMAIN_CONTROLLER_INFO pDomainControllerInfo = NULL;
LPTSTR pszDomainName = NULL;
DWORD Flags = DS_DIRECTORY_SERVICE_REQUIRED | DS_RETURN_DNS_NAME | DS_FORCE_REDISCOVERY;
// get the domain name and DC name
dwReturn = DsGetDcName(NULL, //machine name
NULL,
NULL,
NULL,
Flags,
&pDomainControllerInfo
) ;
if(dwReturn==NO_ERROR && pDomainControllerInfo && pDomainControllerInfo->DomainName)
{
dwStrLength = _tcslen(pDomainControllerInfo->DomainName);
pszDomainName= new _TCHAR[dwStrLength+1];
if(pszDomainName == NULL)
{
dwReturn = ERROR_OUTOFMEMORY;
BAIL_OUT;
}
_tcsncpy(pszDomainName,pDomainControllerInfo->DomainName,dwStrLength+1);
}
if (pDomainControllerInfo)
{
NetApiBufferFree(pDomainControllerInfo);
}
if(!bDeleteAll)
{
if(pszDomainName)
{
PrintMessageFromModule(g_hModule,SHW_STATIC_POLICY_STORE_RD_NAME_STR,pszDomainName);
}
else
{
PrintMessageFromModule(g_hModule,SHW_STATIC_POLICY_STORE_LD_STR);
}
}
else
{
if(pszDomainName)
{
PrintMessageFromModule(g_hModule,SHW_STATIC_POLICY_LD_STR,pszDomainName);
}
else
{
PrintMessageFromModule(g_hModule,SHW_STATIC_POLICY_LD);
}
}
if(pszDomainName) delete [] pszDomainName;
}
}
error:
return dwReturn;
}
////////////////////////////////////////////////////////////////////
//
//Function: PrintResolveDNS()
//
//Date of Creation: 21st Aug 2001
//
//Parameters:
// LPWSTR pszDNSName,
// IPAddr *pIpAddr
//
//Return: DWORD
//
//Description:
// This function prints DNS resolution details
//
//Revision History:
//
//Date Author Comments
//
////////////////////////////////////////////////////////////////////
DWORD
PrintResolveDNS(
LPWSTR pszDNSName
)
{
DNSIPADDR *pAddress=NULL;
struct addrinfo *pAddrInfo = NULL,*pNext=NULL;
char szDNSName[MAX_STR_LEN] = {0};
DWORD dwBufferSize=MAX_STR_LEN;
int iReturn=ERROR_SUCCESS;
DWORD dwReturn = ERROR_SUCCESS;
if(pszDNSName && _tcscmp(pszDNSName,_TEXT(""))!=0)
{
pAddress=new DNSIPADDR;
if(pAddress==NULL)
{
dwReturn = ERROR_OUTOFMEMORY;
BAIL_OUT;
}
iReturn = WideCharToMultiByte(CP_THREAD_ACP, 0, pszDNSName, -1,
szDNSName,dwBufferSize,NULL,NULL);
if(iReturn == 0)
{
//conversion failed due to some error. dont proceed . dive out of the function
BAIL_OUT;
}
// call this to resolve DNS name
iReturn = getaddrinfo((const char*)szDNSName,NULL,NULL,&pAddrInfo);
if (iReturn == ERROR_SUCCESS)
{
pNext = pAddrInfo;
for(DWORD i=1;pNext=pNext->ai_next;i++);
pAddress->dwNumIpAddresses = i;
pAddress->puIpAddr = new ULONG[pAddress->dwNumIpAddresses];
if(pAddress->puIpAddr==NULL)
{
dwReturn = ERROR_OUTOFMEMORY;
BAIL_OUT;
}
// careful : the output of getaddrinfo is linked list not array of pointers
pNext = pAddrInfo;
for(DWORD n=0;pNext; n++)
{
memcpy(&(pAddress->puIpAddr[n]),(ULONG *) &(((sockaddr_in *)(pNext->ai_addr))->sin_addr.S_un.S_addr), sizeof(ULONG));
PrintIPAddrDNS(pAddress->puIpAddr[n]);
if(n<(i-1))
{
PrintMessageFromModule(g_hModule,SHW_STATIC_PRTFSPEC_SPACE_COMMA);
}
else
{
PrintMessageFromModule(g_hModule,SHW_STATIC_PRTFSPEC_NEWLINE);
}
pNext=pNext->ai_next;
}
// free pAddrInfo after usage
if (pAddrInfo)
{
freeaddrinfo(pAddrInfo);
}
}
else
{
PrintMessageFromModule(g_hModule,SHW_STATIC_PRTFILTER_DNS_FAILED);
}
error:
if(pAddress)
{
delete pAddress;
}
}
return dwReturn;
}
////////////////////////////////////////////////////////////////////
//
//Function: PrintIPAddrDNS()
//
//Date of Creation: 21st Aug 2001
//
//Parameters:
// IN DWORD dwAddr
//
//Return: VOID
//
//Description:
// This function prints out IP Address.
//
//Revision History:
//
//Date Author Comments
//
////////////////////////////////////////////////////////////////////
VOID
PrintIPAddrDNS(
IN DWORD dwAddr
)
{
_TCHAR szIPAddr[20]= {0};
// not necessary to change to bounded printf
_stprintf(szIPAddr,_T("%d.%d.%d.%d"), (dwAddr & 0x000000FFL),((dwAddr & 0x0000FF00L) >> 8),((dwAddr & 0x00FF0000L) >> 16),((dwAddr & 0xFF000000L) >> 24) );
PrintMessageFromModule(g_hModule,SHW_STATIC_PRTFSPEC_FORMAT_NO_NEWLINE,szIPAddr);
}
| [
"blindtiger@foxmail.com"
] | blindtiger@foxmail.com |
d86b8cff924b282f3a6d34e0c9f065b98c78f0f1 | 2c580cddf12f29ed2264f77ee56f4099ba3c195f | /src/Magnet.cpp | 904c3c8c88355b35eb19f1952c1f2be4200a035b | [] | no_license | davetron5000/adventureclone | 2b4d6849b93b29a851c185798845ac173b79640b | e277a7e4cc15c0e6b2558d00dc3a8923fea3db68 | refs/heads/master | 2021-01-10T20:15:04.126958 | 2020-12-10T15:49:46 | 2020-12-10T15:49:46 | 64,907 | 5 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 2,366 | cpp | /*
Copyright 2001 by David Copeland
This file is part of Dave's Clone of Adventure.
Dave's Clone of Adventure 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.
Dave's Clone of Adventure is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with Dave's Clone of Adventure; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#include "Magnet.h"
#include "Room.h"
#include <math.h>
#define SHOULD_ATTRACT(object) ( (object != this) && (object->getIsMagnetic()) )
BOOL Magnet::update(DWORD currentTime)
{
SimpleArray *objects = getRoom()->getObjects();
UINT attracted = 0;
for (UINT i=0;i<objects->length();i++)
{
GameObject *object = (GameObject *)(objects->elementAt(i));
if ( SHOULD_ATTRACT(object) )
{
// we want to attract objects, so if the object we want is being held,
// count that as an attracted object, but don't actually move it
if (!object->getIsBeingHeld())
{
RECT myRect;
getRect(&myRect);
int xdelta = myRect.left - object->getX();
int ydelta = myRect.bottom - object->getY();
int normx = xdelta == 0 ? 0 : xdelta/abs(xdelta);
int normy = ydelta == 0 ? 0 : ydelta/abs(ydelta);
object->startMoving(currentTime,normx * itsMagnetismStrengh,normy * itsMagnetismStrengh);
object->setIsBeingAttracted(TRUE);
}
attracted++;
if (attracted == itsNumberOfObjectsToAttract)
break;
}
}
return GameObject::update(currentTime);
}
void Magnet::setRoom(Room *room)
{
if (getRoom() != NULL)
{
SimpleArray *objects = getRoom()->getObjects();
UINT attracted = 0;
for (UINT i=0;i<objects->length();i++)
{
GameObject *object = (GameObject *)(objects->elementAt(i));
if ( SHOULD_ATTRACT(object) )
{
object->setIsBeingAttracted(FALSE);
object->stopMoving(itsXLastMoveTime);
}
}
}
GameObject::setRoom(room);
}
| [
"davetron5000@gmail.com"
] | davetron5000@gmail.com |
ee23f660d2b115e41245c0958b0855a2ab864d92 | 7d93c1c735b2bcf4424708b05f37ff2d4301e48b | /File.cpp | 0018475df0f153dc70372e4144d79426a0a01e94 | [] | no_license | bnares/Financial-Application | 785da8c78a601ebf1f9ba6bb344c70a2ef553eb8 | 93670133263b5f3e60293935e1962e02e8e61756 | refs/heads/main | 2023-03-07T22:36:10.834842 | 2021-02-22T06:50:28 | 2021-02-22T06:50:28 | 335,772,213 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 6,510 | cpp | #include "File.h"
string File::changeCommaToDot(string number)
{
string tekst = number;
replace(tekst.begin(), tekst.end(), ',', '.');
return tekst;
}
bool File::chceckDateWord(vector <string> date)
{
if(date.size()!=3)
{
return false;
}
for(vector <string>:: iterator it = date.begin(); it!=date.end(); it++)
{
string iteratorWord = *it;
for(int i = 0; i<iteratorWord.length(); i++)
{
if(!isdigit(iteratorWord[i]))
{
return false;
}
if( it == date.begin()+1 || it == date.end()-1)
{
if(iteratorWord.length()<2)
{
cout<<"if number in day or month position is less than 10, use prefix 0 before number for example 2020-03-08"<<endl;
return false;
}
if(iteratorWord.length()>2)
{
cout<<"Too many digits in month or day parts"<<endl;
return false;
}
}
}
}
int year = AuxiliaryMethods::convertStringToNUmber(date[0]);
int month = AuxiliaryMethods::convertStringToNUmber(date[1]);
int day = AuxiliaryMethods::convertStringToNUmber(date[2]);
Date currentDate(day, month, year);
if(currentDate.ileDniMaMiesiac())
{
return true;
}
else
{
return false;
}
}
vector <string> File::createVectorFromDateWords(string date)
{
vector <string> words;
stringstream ss(date);
string token;
while(getline(ss,token,'-'))
{
words.push_back(token);
}
return words;
}
string File::createStringNumberFromStringVector(vector <string> data)
{
string stringNumber = "";
for(int i =0; i<data.size(); i++)
{
stringNumber += data.at(i);
}
return stringNumber;
}
string File::modifyFileName(string fileName)
{
int lengthOfWord = fileName.length()-4;
string word = fileName.erase(lengthOfWord,4);
return word;
}
int File::findIdNumberOfTheLastActivity()
{
string mainTitleOfFile = modifyFileName(FILE_NAME);
int number=0;
if(xml.Load(FILE_NAME.c_str()))
{
xml.FindElem();
xml.IntoElem();
while(xml.FindElem(mainTitleOfFile))
{
xml.IntoElem();
xml.FindElem("IdOfActivity");
string activityId = xml.GetData();
number = AuxiliaryMethods ::convertStringToNUmber(activityId);
xml.OutOfElem();
}
return number;
}
else
{
return 0;
}
}
int File::getIdNumberOfTheLastActivity()
{
return idNumberOfTheLastActivity;
}
void File::setIdNumberOfTheLastActivity(int newLastNumberActivity)
{
idNumberOfTheLastActivity = newLastNumberActivity;
}
void File::addToFile()
{
int vectorIndex = 0;
string mainTitleOfFile = modifyFileName(FILE_NAME);
string idActivity = "", idUser="", date="", descriptionOfActivity="", money="";
idActivity = AuxiliaryMethods::convertNumberToString(idNumberOfTheLastActivity+1);
idUser = AuxiliaryMethods::convertNumberToString(idNumberOfUser);
vector <string> data = {date, descriptionOfActivity, money};
vector <string> display = {"Date as yyyy-mm-dd: ", "Description: ","Amount of money: "};
int iter =0;
bool todayDate = false;
for(vector <string>:: iterator it= data.begin(); it != data.end(); it++ )
{
cout<<display.at(iter);
if(vectorIndex ==0)
{
cout<<endl;
cout<<"Do you want use today date Y/N?"<<endl;
string setBool;
cin.clear();
cin.sync();
cin>>setBool;
setBool[0] = toupper(setBool[0]);
while(setBool != "Y" || setBool != "N")
{
if(setBool == "Y")
{
todayDate = true;
break;
}
else if(setBool=="N")
{
todayDate = false;
break;
}
else
{
cout<<"Wrong answear, try again:";
cin.clear();
cin.sync();
cin>>setBool;
}
}
}
if(vectorIndex ==1 || vectorIndex==2)
{
*it = AuxiliaryMethods ::getText();
}
if(vectorIndex == 0 && todayDate==false)
{
cout<<"Date: ";
*it = AuxiliaryMethods ::getText();
while(*it=="")
{
cout<<"Date is empty. Please write a date: ";
*it = AuxiliaryMethods ::getText();
}
vector <string> word = createVectorFromDateWords(*it);
bool checkingDatePoint = chceckDateWord(word);
while(checkingDatePoint==false)
{
cout<<"Date is wrong, try again: ";
data[0] = AuxiliaryMethods::getText();
while(data[0]=="")
{
cout<<"Date is empty. Please write a date: ";
data[0] = AuxiliaryMethods ::getText();
}
checkingDatePoint = chceckDateWord(createVectorFromDateWords(data[0]));
}
}
if(vectorIndex ==0 && todayDate==true)
{
*it = Date::getTodayDate();
}
if(vectorIndex==2)
{
*it = changeCommaToDot(*it);
}
vectorIndex++;
iter++;
}
if(xml.Load(FILE_NAME.c_str()))
{
xml.FindElem();
xml.IntoElem();
xml.AddElem(mainTitleOfFile);
xml.IntoElem();
xml.AddElem("IdOfActivity", idActivity);
xml.AddElem("UserId", idUser);
xml.AddElem("Date", data[0]);
xml.AddElem("Descritpion", data[1]);
xml.AddElem("Amount", data[2]);
xml.Save(FILE_NAME.c_str());
setIdNumberOfTheLastActivity(idNumberOfTheLastActivity+1);
}
else
{
xml.AddElem("Activities");
xml.IntoElem();
xml.AddElem(mainTitleOfFile);
xml.IntoElem();
xml.AddElem("IdOfActivity", idActivity);
xml.AddElem("UserId", idUser);
xml.AddElem("Date", data[0]);
xml.AddElem("Descritpion", data[1]);
xml.AddElem("Amount", data[2]);
xml.Save(FILE_NAME.c_str());
setIdNumberOfTheLastActivity(idNumberOfTheLastActivity+1);
}
}
| [
"piotr.ostrouch@gmail.com"
] | piotr.ostrouch@gmail.com |
412fa56e453ca426d028177ac95edd5e3b758a40 | 672bb6ccd32ba2176f6eb63306e3831071ed3d30 | /cpp_learning/hw/4.12/4.12.cpp | cf4fc4c059bc69f55a355c2b6576c1e70fd21ff4 | [] | no_license | YahuiChen/Python_learning | 4e92c31017bda05235b557482a504f3c98bfdaed | 60dc9fe323118093e6c10e259ffc2e2ece56c541 | refs/heads/master | 2020-03-24T07:19:34.996434 | 2018-08-31T10:08:05 | 2018-08-31T10:08:05 | 142,560,940 | 0 | 0 | null | null | null | null | GB18030 | C++ | false | false | 1,078 | cpp | #include "map.h"
//#include <set>
//#include <utility>
#include <iostream>
using namespace std;
//using std::endl;
//using std::string;
void main()
{
int a;
/*
set<pair<int, int> > s;
s.insert(make_pair(3, 1));
s.insert(make_pair(3, 2));
s.insert(make_pair(1, 1));
s.insert(make_pair(1, 2));
s.insert(make_pair(2, 5));
s.insert(make_pair(2, 4));
set<pair<int, int> > ::iterator it;
for (it = s.begin(); it != s.end(); it++)
cout << it->first << ' ' << it->second << "\n";
it = s.upper_bound(make_pair(2, 4));
if (it != s.end())
printf("(2,4)后面接着是%d %d\n", it->first, it->second);*/
Map<string, int> m;
m["Jack"] = 98;
m["Bimi"] = 96;
m["Kate"] = 97;
// m.insert(make_pair("back", 1);
Map<string, int>::iterator it;
////先前遍历元素
//Map<string, int> ::iterator it;
//for (it = m.begin(); it != m.end(); it++)
//{
// //cout << it->first << " : " << (*it)->second << endl;
//}
cout << m["Jack"] << endl;
//s return 0;
} | [
"cyh85321@gmail.com"
] | cyh85321@gmail.com |
de0b97c6e7bcc7cb37a1ba31249f4fd71ac7312f | b4ad8495d6e353ec1dd75503da06e27c04c9e89d | /src/simulations/genetics_warped/clothosim/models/RandomSelectionModel.h | c334514f70412920f7807c3a2c4651a027ea7dcc | [
"BSD-2-Clause-Views",
"BSD-2-Clause"
] | permissive | putnampp/clotho-dev | a0efc5346c051460abab336c783a3977dbc26bf1 | dd6ffdb549f6669236745bbf80be6b12392ecc00 | refs/heads/master | 2021-01-25T06:36:32.056942 | 2014-09-15T14:28:17 | 2014-09-15T14:28:17 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,075 | h | /*******************************************************************************
* Copyright (c) 2013, Patrick P. Putnam (putnampp@gmail.com)
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice, this
* list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
* ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
* The views and conclusions contained in the software and documentation are those
* of the authors and should not be interpreted as representing official policies,
* either expressed or implied, of the FreeBSD Project.
******************************************************************************/
#ifndef RANDOMSELECTIONMODEL_H_
#define RANDOMSELECTIONMODEL_H_
#include "SelectionModel.h"
class RandomSelectionModel : public SelectionModel {
public:
RandomSelectionModel( const Environment * env );
OBJECT_ID select_individual( OBJECT_ID & ) const;
};
#endif // RANDOMSELECTIONMODEL_H_
| [
"patrick.putnam@cchmc.org"
] | patrick.putnam@cchmc.org |
e4c7f1dc35129fc58c2e09790ed74ff6219b6eb5 | 8aab714b0ea9d4f7af77dda1d874971e24c6816b | /SuperDocumentRetriever/SuperDocumentRetriever/Main.cpp | 98370e6d989ccb074e2717d379c80d39ff2ec5f9 | [] | no_license | zhangxu128/Project | 5d98596ce7fb7249d2b382d53679726f5281c1ad | 8a267748808698d5b76174c683b3b907e947607d | refs/heads/master | 2022-02-17T23:09:24.159489 | 2019-08-10T07:00:22 | 2019-08-10T07:00:22 | 198,150,341 | 0 | 0 | null | null | null | null | GB18030 | C++ | false | false | 1,619 | cpp | #pragma once
#include "DocScanManager.h"
#include "DataManager.h"
#include "Monitor.h"
#include <thread>
//初始化扫描
void InitScanManager() {
DocScanManager::GetInstance()->Scan("C:\\Users\\73117\\Desktop\\leihaoa");
}
//监控文件的实时变化
void MonitorFile() {
FileWatcher();
}
void RunSearch() {
while (1) {
//DataManager s;
std::vector<std::pair<std::string, std::string>> doc_path;
doc_path.clear();
cout << "================================开始查询===================================" << endl << endl;
std::string key;
cout << "请输入要查询的关键字：";
std::cin >> key;
DataManager::GetInstance()->Search(key, doc_path);
cout << std::left << std::setw(50) << "名称" << std::left << std::setw(50) << "路径" << endl;
for (auto& e : doc_path) {
transform(e.first.begin(), e.first.end(), e.first.begin(), tolower);
transform(key.begin(),key.end(),key.begin(),tolower);
std::string prefix, suffix, highlight;
DataManager::GetInstance()->SetHighLight(e.first, key, prefix, highlight, suffix);
cout << prefix;
ColourPrintf(highlight);
cout << suffix;
int size = prefix.size() + suffix.size() + highlight.size();
for (int i = 0; i < 50 - size; i++) {
cout << " ";
}
cout << std::left << std::setw(50) << e.second << endl;
}
cout << endl;
cout << "================================查询结束===================================" << endl << endl;
}
}
int main(void) {
InitScanManager();
std::thread _t(MonitorFile);//对指定文件目录实时监控
_t.detach();
RunSearch();
system("pause");
return 0;
} | [
"731172278@qq.com"
] | 731172278@qq.com |
5b2403e57740f769f130befd21d3ced1661d1657 | b8ff82ae6383896483cf89d4b0197ed9416da62f | /AudioEngine/BasicElaborationUnits/ElaborationUnits/MIDISequencePlayer.cpp | a558eafc1976a10c76ad044a0173a7a2aa05c273 | [] | no_license | eriser/synassembler | 208b1973813d9fca0b321669ad266f78a3d2d0ac | db6abfb803db7ad0c8c326b2438d692755d912f1 | refs/heads/master | 2021-01-12T14:06:18.600898 | 2016-09-20T06:09:54 | 2016-09-20T06:09:54 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 5,342 | cpp |
#include "MIDISequencePlayer.h"
#include <sstream>
#define NUM_NOTES 8
MIDISequencePlayer::MIDISequencePlayer(ModuleServices* pService) : VirtualElaborationUnit(pService,MIDISequencePlayer::kinna.getPropertyNumber(),&MIDISequencePlayer::kinna) ,MainOutPort(ElaborationUnitPort::OUTPUT_PORT,ElaborationUnitPort::MIDI_PORT,ElaborationUnitPort::MULTI_PORT)
{
beatCounter = 0;
currentNoteIndex = 0;
m_pModuleServices->timeBase->registerBeatObject(this);
for(int i=0;i<NUM_NOTES;i++)
{
NotesInfoArray[i].NoteOn = noteOnOffArray[i];
NotesInfoArray[i].Note = noteArray[i];
NotesInfoArray[i].duration = noteDurationArray[i];
}
}
MIDISequencePlayer::~MIDISequencePlayer()
{
this->m_pModuleServices->pLogger->writeLine("MIDISequencer destructor");
}
void MIDISequencePlayer::updateAudioSamples(EAG_SAMPLE_TYPE *pSamplesBuffer,int numsamples)
{
}
void MIDISequencePlayer::receiveMIDIMessage(MIDIChannelMessage& midimsg)
{
}
bool MIDISequencePlayer::setInputEU(ElaborationUnitPort* pPort, ElaborationUnit* pInputEU, ElaborationUnitPort* pInputPort)
{
return false;
}
bool MIDISequencePlayer::setOutputEU(ElaborationUnitPort* pPort, ElaborationUnit* pOutputEU, ElaborationUnitPort* pOutputPort)
{
if( pPort == &MainOutPort )
{
//MainOutPort.setNthEUandPort(pOutputEU,pOutputPort,MAIN_OUT_PORT_INDEX);
MainOutPort.setNthEUandPort(pOutputEU,pOutputPort,-1);
return true;
}
else
return false;
}
ElaborationUnitPort* MIDISequencePlayer::getNthInputPort(int n)
{
return NULL;
}
ElaborationUnitPort* MIDISequencePlayer::getNthOutputPort(int n)
{
switch(n)
{
case MAIN_OUT_PORT_INDEX:
return &MainOutPort;
default:
return NULL;
}
}
int MIDISequencePlayer::getInputPortNumber(void)
{
return 0;
}
int MIDISequencePlayer::getOutputPortNumber(void)
{
return 1;
}
ElaborationUnitPort* MIDISequencePlayer::getInputPortByEU(ElaborationUnit* pEU, int& n)
{
return NULL;
}
ElaborationUnitPort* MIDISequencePlayer::getOutputPortByEU(ElaborationUnit* pEU, int& n)
{
return NULL;
}
void MIDISequencePlayer::allocate(void)
{
}
void MIDISequencePlayer::deallocate(void)
{
}
void MIDISequencePlayer::play(void)
{
m_pModuleServices->pLogger->writeLine("Started MIDISequencer");
beatCounter = 0;
currentNoteIndex = 0;
AbstractElaborationUnit::play();
}
void MIDISequencePlayer::pause(void)
{
}
void MIDISequencePlayer::stop(void)
{
}
const EUKind* MIDISequencePlayer::getKind(void)
{
return s_GetKind();
}
void MIDISequencePlayer::setSamplesBufferMaximumSize(int size)
{
}
const int MIDISequencePlayer::NULL_NOTE = -1;
int MIDISequencePlayer::noteArray[] = { 50, 50, 54, 54, 57, 57, 62, 62 };
int MIDISequencePlayer::noteDurationArray[] = { 100, 10, 100, 10, 100, 10, 100, 10 };
bool MIDISequencePlayer::noteOnOffArray[] = { true, false, true, false, true, false, true, false };
class MIDISequencePlayer::MIDINoteInfo MIDISequencePlayer::NotesInfoArray[NUM_NOTES];
int MIDISequencePlayer::getNextMIDINoteDuration(void)
{
//Loops continously
if(currentNoteIndex==NUM_NOTES)
currentNoteIndex = 0;
//return noteDurationArray[currentNoteIndex];
return NotesInfoArray[currentNoteIndex].duration;
}
int MIDISequencePlayer::getNextMIDINote()
{
//return noteArray[currentNoteIndex];
return NotesInfoArray[currentNoteIndex].Note;
}
bool MIDISequencePlayer::getNextMIDIOnOff(void)
{
//return noteOnOffArray[currentNoteIndex];
return NotesInfoArray[currentNoteIndex].NoteOn;
}
void MIDISequencePlayer::beat(void)
{
if(isPlaying())
{
if(beatCounter==0)
{
int duration = getNextMIDINoteDuration();
beatCounter = duration;
int numConn = MainOutPort.getConnectionsNumber();
if(numConn!=0)
{
for(int i=0;i<numConn;i++)
{
ElaborationUnit* pEU = MainOutPort.getNthEU(i);
//Send MIDI note to connected EUs
MIDIChannelMessage midiMsg;
midiMsg.channel = 0;
midiMsg.data.NoteMessage.Note = getNextMIDINote();
midiMsg.data.NoteMessage.Velocity = 127;
midiMsg.data.NoteMessage.Frequency = MIDIChannelMessage::GetFreqByMIDINote(midiMsg.data.NoteMessage.Note);
if(getNextMIDIOnOff())
{
midiMsg.Kind = MIDIChannelMessage::e_NoteOn;
m_pModuleServices->pLogger->writeLine("Playing note On");
std::stringstream sstr;
sstr << "Frequency=";
sstr << midiMsg.data.NoteMessage.Frequency;
sstr << " Note=";
sstr << (int) midiMsg.data.NoteMessage.Note;
//printf("Note=%d\n", midiMsg.data.NoteMessage.Note);
m_pModuleServices->pLogger->writeLine(sstr.str().c_str());
}
else
{
midiMsg.Kind = MIDIChannelMessage::e_NoteOff;
m_pModuleServices->pLogger->writeLine("Playing note Off");
}
pEU->receiveMIDIMessage(midiMsg);
currentNoteIndex++;
}
}
}
else
beatCounter--;
}
}
const MIDISequencePlayerKind MIDISequencePlayer::kinna;
const EUKind* MIDISequencePlayer::s_GetKind(void)
{
return (EUKind *) &kinna;
}
int MIDISequencePlayer::setProperty(int propertyIndex, const char* value)
{
return 0;
}
int MIDISequencePlayer::getProperty(int propertyIndex, char* value, int bufferSize)
{
return NULL;
}
| [
"kernel255@gmail.com"
] | kernel255@gmail.com |
286102a89b0a99cf1c4cc4674cc6eb98785165d1 | 8892a0cf818df0d38f4ab4598ca550fdb9d4d557 | /calculator.cpp | 0d2b840b40f28d01639435b5203f60a4f077281d | [] | no_license | weizhiyuan-16/first | 119463babd4f9e21045345ad973d9f2f20328f4c | 2d1259d768c5864199cf03c57be3b750fb3c931f | refs/heads/master | 2023-06-20T03:53:57.557221 | 2021-07-09T02:22:55 | 2021-07-09T02:22:55 | 384,302,233 | 0 | 0 | null | null | null | null | GB18030 | C++ | false | false | 4,607 | cpp | #include <iostream>
#include <algorithm>
#include <cstring>
#include <iostream>
#include <algorithm>
#include <cstring>
#include <stack>
#include <cmath>
#include <iomanip>
using namespace std;
char s[1000];
int g_pos; // 字符数组的下标
/* 字符转数字 */
double Translation(int & pos)
{
double integer = 0.00; // 整数部分
double remainder = 0.00; // 小数部分
while (s[pos] >= '0' && s[pos] <= '9')
{
integer *= 10;
integer += (s[pos] - '0');
pos++;
}
if (s[pos] == '.')
{
pos++;
int c = 1;
while (s[pos] >= '0' && s[pos] <= '9')
{
double t = s[pos] - '0';
t *= pow(0.1, c);
c++;
remainder += t;
pos++;
}
}
return integer + remainder;
}
/* 返回运算符级别 */
int GetLevel(char ch)
{
switch (ch)
{
case '+':
case '-':
return 1;
case '*':
case '/':
return 2;
case '^':
case '%':
return 3;
case '(':
return 0;
case '#':
return -1;
};
}
/* 对两个数进行运算 */
double Operate(double a1, char op, double a2)
{
int a = a1;
int b = a2;
switch (op)
{
case '+':
return a1 + a2;
case '-':
return a1 - a2;
case '*':
return a1 * a2;
case '/':
return a1 / a2;
case '%':
return a % b;
case '^':
return pow(a1,a2);
};
}
/* 利用两个栈进行模拟计算 */
double Compute()
{
stack<char> optr; // 操作符栈
stack<double> opnd; // 操作数栈
optr.push('#'); //置于符栈顶
int len = strlen(s);
bool is_minus = true; // 判断是不是负号
for (g_pos = 0; g_pos < len;)
{
//1. 负号
if (s[g_pos] == '-' && is_minus) // 是负号
{
opnd.push(0);
optr.push('-');
g_pos++;
}
//2. 是右括号 )
else if (s[g_pos] == ')')
{
is_minus = false;
g_pos++;
while (optr.top() != '(' && optr.size() > 1)
{
double a2 = opnd.top();
opnd.pop();
double a1 = opnd.top();
opnd.pop();
char op = optr.top();
optr.pop();
double result = Operate(a1, op, a2);
opnd.push(result);
}
optr.pop(); // 删除'('
if (optr.size() < 1)
{
cout << "ERROR IN INFIX NOTATION" << endl;
return 0;
}
}
//3. 数字
else if (s[g_pos] >= '0' && s[g_pos] <= '9')
{
is_minus = false;
opnd.push(Translation(g_pos));
}
//4. ( 左括号
else if (s[g_pos] == '(')
{
is_minus = true;
optr.push(s[g_pos]);
g_pos++;
}
//5. + - * / ^ %
else if (s[g_pos] == '+' || s[g_pos] == '-' || s[g_pos] == '*' || s[g_pos] == '/' || s[g_pos] == '^' || s[g_pos] == '%' )
{
while (GetLevel(s[g_pos]) <= GetLevel(optr.top())) //当前优先级小于栈顶优先级
{
double a2 = opnd.top();
opnd.pop();
double a1 = opnd.top();
opnd.pop();
char op = optr.top();
optr.pop();
double result = Operate(a1, op, a2);
opnd.push(result);
}
optr.push(s[g_pos]);
g_pos++;
}
//6.输入字符不属于数字或规定运算符
else
{
cout << "ERROR IN INFIX NOTATION" << endl;
return 0;
}
}
//对剩余的运算符及操作数进行计算
while (optr.top() != '#' && opnd.size() >= 2)
{
double a2 = opnd.top();
opnd.pop();
double a1 = opnd.top();
opnd.pop();
char op = optr.top();
double result = Operate(a1, op, a2);
opnd.push(result);
optr.pop();
}
optr.pop();
//计算结束并弹出#后运算符栈仍不为空，说明最后弹出的不为#，有多余运算符
if (!optr.empty())
{
cout << "ERROR IN INFIX NOTATION" << endl;
return 0;
}
else if(opnd.size() != 1)
{
cout << "ERROR IN INFIX NOTATION" << endl;
return 0;
}
else
{
cout << setiosflags(ios::fixed) << setprecision(2) << opnd.top() << endl;
return 0;
}
}
int main()
{
cin >> s;
Compute();
return 0;
}
| [
"2500949756@qq.com"
] | 2500949756@qq.com |
d2ebfa8d85209de45408970549fcdf8dd7a0e486 | e73121fcfcc4df2e7092a82f4810ce9615e9dd83 | /Codeforces/Little C Loves 3 I.cpp | ab71a1efe2dcd657e81cf9e68ec66fcb54b6b519 | [] | no_license | Redwanuzzaman/Online-Judge-Problem-Solutions | 1aba5eda26a03ed8cafaf6281618bf13bea7699b | f2f4ccac708bd49e825f2788da886bf434523d3c | refs/heads/master | 2022-08-29T04:10:31.084874 | 2022-08-14T18:20:30 | 2022-08-14T18:20:30 | 142,601,682 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 183 | cpp | #include <bits/stdc++.h>
using namespace std;
int main()
{
int n;
cin >> n;
if((n-2) % 3 == 0) cout << "1 2 " << n - 3 << endl;
else cout << "1 1 " << n-2 << endl;
}
| [
"noreply@github.com"
] | noreply@github.com |
028fc3cc5c80359ff34573df0c72ebe7f30e531d | 3cf9e141cc8fee9d490224741297d3eca3f5feff | /C++ Benchmark Programs/Benchmark Files 1/classtester/autogen-sources/source-19391.cpp | 2c12afbc64f6fda6302a18142f6758b217bada1e | [] | no_license | TeamVault/tauCFI | e0ac60b8106fc1bb9874adc515fc01672b775123 | e677d8cc7acd0b1dd0ac0212ff8362fcd4178c10 | refs/heads/master | 2023-05-30T20:57:13.450360 | 2021-06-14T09:10:24 | 2021-06-14T09:10:24 | 154,563,655 | 0 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 4,084 | cpp | struct c0;
void __attribute__ ((noinline)) tester0(c0* p);
struct c0
{
bool active0;
c0() : active0(true) {}
virtual ~c0()
{
tester0(this);
active0 = false;
}
virtual void f0(){}
};
void __attribute__ ((noinline)) tester0(c0* p)
{
p->f0();
}
struct c1;
void __attribute__ ((noinline)) tester1(c1* p);
struct c1 : virtual c0
{
bool active1;
c1() : active1(true) {}
virtual ~c1()
{
tester1(this);
c0 *p0_0 = (c0*)(c1*)(this);
tester0(p0_0);
active1 = false;
}
virtual void f1(){}
};
void __attribute__ ((noinline)) tester1(c1* p)
{
p->f1();
if (p->active0)
p->f0();
}
struct c2;
void __attribute__ ((noinline)) tester2(c2* p);
struct c2 : virtual c1, virtual c0
{
bool active2;
c2() : active2(true) {}
virtual ~c2()
{
tester2(this);
c0 *p0_0 = (c0*)(c1*)(c2*)(this);
tester0(p0_0);
c0 *p0_1 = (c0*)(c2*)(this);
tester0(p0_1);
c1 *p1_0 = (c1*)(c2*)(this);
tester1(p1_0);
active2 = false;
}
virtual void f2(){}
};
void __attribute__ ((noinline)) tester2(c2* p)
{
p->f2();
if (p->active0)
p->f0();
if (p->active1)
p->f1();
}
struct c3;
void __attribute__ ((noinline)) tester3(c3* p);
struct c3 : virtual c0, virtual c1, c2
{
bool active3;
c3() : active3(true) {}
virtual ~c3()
{
tester3(this);
c0 *p0_0 = (c0*)(c3*)(this);
tester0(p0_0);
c0 *p0_1 = (c0*)(c1*)(c3*)(this);
tester0(p0_1);
c0 *p0_2 = (c0*)(c1*)(c2*)(c3*)(this);
tester0(p0_2);
c0 *p0_3 = (c0*)(c2*)(c3*)(this);
tester0(p0_3);
c1 *p1_0 = (c1*)(c3*)(this);
tester1(p1_0);
c1 *p1_1 = (c1*)(c2*)(c3*)(this);
tester1(p1_1);
c2 *p2_0 = (c2*)(c3*)(this);
tester2(p2_0);
active3 = false;
}
virtual void f3(){}
};
void __attribute__ ((noinline)) tester3(c3* p)
{
p->f3();
if (p->active2)
p->f2();
if (p->active0)
p->f0();
if (p->active1)
p->f1();
}
struct c4;
void __attribute__ ((noinline)) tester4(c4* p);
struct c4 : virtual c0, virtual c1, virtual c3
{
bool active4;
c4() : active4(true) {}
virtual ~c4()
{
tester4(this);
c0 *p0_0 = (c0*)(c4*)(this);
tester0(p0_0);
c0 *p0_1 = (c0*)(c1*)(c4*)(this);
tester0(p0_1);
c0 *p0_2 = (c0*)(c3*)(c4*)(this);
tester0(p0_2);
c0 *p0_3 = (c0*)(c1*)(c3*)(c4*)(this);
tester0(p0_3);
c0 *p0_4 = (c0*)(c1*)(c2*)(c3*)(c4*)(this);
tester0(p0_4);
c0 *p0_5 = (c0*)(c2*)(c3*)(c4*)(this);
tester0(p0_5);
c1 *p1_0 = (c1*)(c4*)(this);
tester1(p1_0);
c1 *p1_1 = (c1*)(c3*)(c4*)(this);
tester1(p1_1);
c1 *p1_2 = (c1*)(c2*)(c3*)(c4*)(this);
tester1(p1_2);
c2 *p2_0 = (c2*)(c3*)(c4*)(this);
tester2(p2_0);
c3 *p3_0 = (c3*)(c4*)(this);
tester3(p3_0);
active4 = false;
}
virtual void f4(){}
};
void __attribute__ ((noinline)) tester4(c4* p)
{
p->f4();
if (p->active2)
p->f2();
if (p->active0)
p->f0();
if (p->active1)
p->f1();
if (p->active3)
p->f3();
}
int __attribute__ ((noinline)) inc(int v) {return ++v;}
int main()
{
c0* ptrs0[25];
ptrs0[0] = (c0*)(new c0());
ptrs0[1] = (c0*)(c1*)(new c1());
ptrs0[2] = (c0*)(c1*)(c2*)(new c2());
ptrs0[3] = (c0*)(c2*)(new c2());
ptrs0[4] = (c0*)(c3*)(new c3());
ptrs0[5] = (c0*)(c1*)(c3*)(new c3());
ptrs0[6] = (c0*)(c1*)(c2*)(c3*)(new c3());
ptrs0[7] = (c0*)(c2*)(c3*)(new c3());
ptrs0[8] = (c0*)(c4*)(new c4());
ptrs0[9] = (c0*)(c1*)(c4*)(new c4());
ptrs0[10] = (c0*)(c3*)(c4*)(new c4());
ptrs0[11] = (c0*)(c1*)(c3*)(c4*)(new c4());
ptrs0[12] = (c0*)(c1*)(c2*)(c3*)(c4*)(new c4());
ptrs0[13] = (c0*)(c2*)(c3*)(c4*)(new c4());
for (int i=0;i<14;i=inc(i))
{
tester0(ptrs0[i]);
delete ptrs0[i];
}
c1* ptrs1[25];
ptrs1[0] = (c1*)(new c1());
ptrs1[1] = (c1*)(c2*)(new c2());
ptrs1[2] = (c1*)(c3*)(new c3());
ptrs1[3] = (c1*)(c2*)(c3*)(new c3());
ptrs1[4] = (c1*)(c4*)(new c4());
ptrs1[5] = (c1*)(c3*)(c4*)(new c4());
ptrs1[6] = (c1*)(c2*)(c3*)(c4*)(new c4());
for (int i=0;i<7;i=inc(i))
{
tester1(ptrs1[i]);
delete ptrs1[i];
}
c2* ptrs2[25];
ptrs2[0] = (c2*)(new c2());
ptrs2[1] = (c2*)(c3*)(new c3());
ptrs2[2] = (c2*)(c3*)(c4*)(new c4());
for (int i=0;i<3;i=inc(i))
{
tester2(ptrs2[i]);
delete ptrs2[i];
}
c3* ptrs3[25];
ptrs3[0] = (c3*)(new c3());
ptrs3[1] = (c3*)(c4*)(new c4());
for (int i=0;i<2;i=inc(i))
{
tester3(ptrs3[i]);
delete ptrs3[i];
}
c4* ptrs4[25];
ptrs4[0] = (c4*)(new c4());
for (int i=0;i<1;i=inc(i))
{
tester4(ptrs4[i]);
delete ptrs4[i];
}
return 0;
}
| [
"ga72foq@mytum.de"
] | ga72foq@mytum.de |
0a1af9974d8a559d6038c7481002b64309546eda | e4cd71a2180e731bdb72a301c27020ad571657c0 | /10824/10824.cpp | 834ac4eafd841d36c4417892dbac2a6186f42340 | [] | no_license | EEAIC/Baekjoon-Online-Judge | 65923fffeb09aefd6fcb5aa1defc03135d543efb | c736578c19df54ee86bf95de4ac73babb3ab3538 | refs/heads/master | 2023-01-23T19:33:14.018225 | 2020-12-06T10:25:32 | 2020-12-06T10:25:32 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 203 | cpp | #include <iostream>
#include <string>
using namespace std;
int main() {
string A, B, C, D;
cin >> A >> B >> C >> D;
A = A + B;
C = C + D;
cout << atoll(A.c_str()) + atoll(C.c_str());
return 0;
} | [
"artherlim@gmail.com"
] | artherlim@gmail.com |
35e6459eae73ba9afe0ab245a22465b4b5f7b853 | 8f1a921ab2ba30ad0506dad9674d0e00947ab708 | /mylibs/goyotsuya/GoYotsuya/yictrl/.svn/text-base/yctrlLayout.h.svn-base | ca8783b78333251d7f64df85c1ecc9fffc0f94e1 | [] | no_license | dongho-yoo-private/private | 5d40c5f01022a197d2f6f8b1d28d7bea7314fb99 | 848e7eef7b0f93f5adb718b2c643935ea674a523 | refs/heads/master | 2023-03-22T03:34:09.141416 | 2021-03-18T09:36:10 | 2021-03-18T09:36:10 | 347,271,316 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 776 | #pragma once
#include "yistd.h"
#include "yctrlbase.h"
enum eLayoutStyle {
};
// -------------------------------------
class cyctrlLayout
{
public:
cyctrlLayout(void);
~cyctrlLayout(void);
// -----------------------------------------------------
//Bool Create(int x, int y, int w, int h, sLayout* layout, Bitmap* bg);
//// -----------------------------------------------------
//void Destroy();
//// -----------------------------------------------------
//Bool Add(cyctrlbase* base);
//// -----------------------------------------------------
//Bool Add(cyctrlbase* base, int x, int y);
//// -----------------------------------------------------
//Bool Move(int x, int y, int w, int h);
private:
cyiList m_controls;
};
| [
"dongho@dongho-pro.local"
] | dongho@dongho-pro.local | |
6b11fac52d43b4832dfea28335fe7828eb8ebb3d | 6a63e27775b4b9d9087104605e1f70714149b904 | /Simulations/ranbin.cpp | 17e0d91325d9291374eff4bcfa1c9d0268127b4c | [] | no_license | Thomas-Lesaffre/On_deleterious_mutations_in_perennials | f601f7ff06824223e9e8f0cb710d66df14404ffa | a0d893a2b1543644370e95d14fd3387a0b0855fb | refs/heads/master | 2021-08-15T03:29:56.421659 | 2021-08-06T09:56:14 | 2021-08-06T09:56:14 | 225,906,219 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,400 | cpp | //Algorithms for sampling in probability distributions (gamma, poisson and binomial).
// From Numerical Recipes in C
#include "header.h"
#include <cmath>
#include "mt.h"
using namespace std;
extern MTRand rnd;
// Samples a random number from a gamma distribution:
double gammln(const double xx)
{
int j;
double x,y,tmp,ser;
static const double cof[6]={76.18009172947146,-86.50532032941677,
24.01409824083091,-1.231739572450155,0.1208650973866179e-2,
-0.5395239384953e-5};
y=x=xx;
tmp=x+5.5;
tmp -= (x+0.5)*log(tmp);
ser=1.000000000190015;
for (j=0;j<6;j++) ser += cof[j]/++y;
return -tmp+log(2.5066282746310005*ser/x);
}
// Samples a random number from a Poisson distribution:
double poisdev(const double xm)
{
const double PI=3.141592653589793238;
static double sq,alxm,g,oldm=(-1.0);
double em,t,y;
if (xm < 12.0) {
if (xm != oldm) {
oldm=xm;
g=exp(-xm);
}
em = -1;
t=1.0;
do {
++em;
t *= rnd.rand();;
} while (t > g);
} else {
if (xm != oldm) {
oldm=xm;
sq=sqrt(2.0*xm);
alxm=log(xm);
g=xm*alxm-gammln(xm+1.0);
}
do {
do {
y=tan(PI*rnd.rand());
em=sq*y+xm;
} while (em < 0.0);
em=floor(em);
t=0.9*(1.0+y*y)*exp(em*alxm-gammln(em+1.0)-g);
} while (rnd.rand() > t);
}
return em;
}
// Samples a random number from a binomial distribution:
double binldev(const double pp, const int n)
{
const double PI=3.141592653589793238;
int j;
static int nold=(-1);
double am,em,g,angle,p,bnl,sq,t,y;
static double pold=(-1.0),pc,plog,pclog,en,oldg;
p=(pp <= 0.5 ? pp : 1.0-pp);
am=n*p;
if (n < 25) {
bnl=0.0;
for (j=0;j<n;j++)
if (rnd.rand() < p) ++bnl;
} else if (am < 1.0) {
g=exp(-am);
t=1.0;
for (j=0;j<=n;j++) {
t *= rnd.rand();
if (t < g) break;
}
bnl=(j <= n ? j : n);
} else {
if (n != nold) {
en=n;
oldg=gammln(en+1.0);
nold=n;
} if (p != pold) {
pc=1.0-p;
plog=log(p);
pclog=log(pc);
pold=p;
}
sq=sqrt(2.0*am*pc);
do {
do {
angle=PI*rnd.rand();
y=tan(angle);
em=sq*y+am;
} while (em < 0.0 || em >= (en+1.0));
em=floor(em);
t=1.2*sq*(1.0+y*y)*exp(oldg-gammln(em+1.0)
-gammln(en-em+1.0)+em*plog+(en-em)*pclog);
} while (rnd.rand() > t);
bnl=em;
}
if (p != pp) bnl=n-bnl;
return bnl;
}
| [
"noreply@github.com"
] | noreply@github.com |
d97838dc531789755d4479826748172991043d0e | f1005070dcec14ed5a8eda63fa6765d734e03369 | /hardware/amlogic/camera/inc/CameraHal.h | e26e15607edd376578c876db102f15ac5e9a70cc | [] | no_license | niraj-algoworks/UVCHAL | d242ad4b48c6342d2d868d17d81d2f25f51f1b62 | 087be6a62b4d3fcac4fdb7c0aef3d435fb81304e | refs/heads/master | 2021-06-16T18:24:53.314439 | 2017-06-09T00:25:55 | 2017-06-09T00:25:55 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 38,878 | h | /*
* Copyright (C) 2011 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ANDROID_HARDWARE_CAMERA_HARDWARE_H
#define ANDROID_HARDWARE_CAMERA_HARDWARE_H
#include <stdio.h>
#include <stdarg.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <time.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <sys/mman.h>
#include <sys/stat.h>
#include <utils/Log.h>
#include <utils/threads.h>
#include <linux/videodev2.h>
#include "binder/MemoryBase.h"
#include "binder/MemoryHeapBase.h"
#include <utils/threads.h>
#include <camera/CameraParameters.h>
#include <hardware/camera.h>
#include "MessageQueue.h"
#include "Semaphore.h"
#include "CameraProperties.h"
#include "DebugUtils.h"
#include "SensorListener.h"
#include "util.h"
#include <ui/GraphicBufferAllocator.h>
#include <ui/GraphicBuffer.h>
#define MIN_WIDTH 640
#define MIN_HEIGHT 480
#define PICTURE_WIDTH 3264 /* 5mp - 2560. 8mp - 3280 */ /* Make sure it is a multiple of 16. */
#define PICTURE_HEIGHT 2448 /* 5mp - 2048. 8mp - 2464 */ /* Make sure it is a multiple of 16. */
#define PREVIEW_WIDTH 176
#define PREVIEW_HEIGHT 144
//#define PIXEL_FORMAT V4L2_PIX_FMT_UYVY
#define VIDEO_FRAME_COUNT_MAX 8 //NUM_OVERLAY_BUFFERS_REQUESTED
#define MAX_CAMERA_BUFFERS 8 //NUM_OVERLAY_BUFFERS_REQUESTED
#define MAX_ZOOM 3
#define THUMB_WIDTH 80
#define THUMB_HEIGHT 60
#define PIX_YUV422I 0
#define PIX_YUV420P 1
#define SATURATION_OFFSET 100
#define SHARPNESS_OFFSET 100
#define CONTRAST_OFFSET 100
#ifdef AMLOGIC_USB_CAMERA_SUPPORT
#define CAMHAL_GRALLOC_USAGE GRALLOC_USAGE_HW_TEXTURE | \
GRALLOC_USAGE_HW_RENDER | \
GRALLOC_USAGE_SW_READ_RARELY | \
GRALLOC_USAGE_SW_WRITE_NEVER
#else
#define CAMHAL_GRALLOC_USAGE GRALLOC_USAGE_HW_TEXTURE | \
GRALLOC_USAGE_HW_RENDER | \
GRALLOC_USAGE_SW_READ_RARELY | \
GRALLOC_USAGE_PRIVATE_1 | \
GRALLOC_USAGE_SW_WRITE_NEVER
#endif
//Enables Absolute PPM measurements in logcat
#define PPM_INSTRUMENTATION_ABS 1
#define LOCK_BUFFER_TRIES 5
//TODO this is wrong. fix this:
#define HAL_PIXEL_FORMAT_NV12 HAL_PIXEL_FORMAT_YCrCb_420_SP
//sensor listener is useless now, camera don't need to knwo the orientation now
//disable it now
//#define ENABLE_SENSOR_LISTENER 1
//#define AMLOGIC_CAMERA_OVERLAY_SUPPORT
//#define AMLOGIC_USB_CAMERA_SUPPORT
#define NONNEG_ASSIGN(x,y) \
if(x > -1) \
y = x
namespace android {
#define PARAM_BUFFER 6000
///Forward declarations
class CameraHal;
class CameraFrame;
class CameraHalEvent;
class DisplayFrame;
class CameraArea : public RefBase
{
public:
CameraArea(ssize_t top,
ssize_t left,
ssize_t bottom,
ssize_t right,
size_t weight) : mTop(top),
mLeft(left),
mBottom(bottom),
mRight(right),
mWeight(weight) {}
status_t transfrom(size_t width,
size_t height,
size_t &top,
size_t &left,
size_t &areaWidth,
size_t &areaHeight);
bool isValid()
{
return ( ( 0 != mTop ) || ( 0 != mLeft ) || ( 0 != mBottom ) || ( 0 != mRight) );
}
bool isZeroArea()
{
return ( (0 == mTop ) && ( 0 == mLeft ) && ( 0 == mBottom )
&& ( 0 == mRight ) && ( 0 == mWeight ));
}
size_t getWeight()
{
return mWeight;
}
bool compare(const sp<CameraArea> &area);
static status_t parseAreas(const char *area,
size_t areaLength,
Vector< sp<CameraArea> > &areas);
static status_t checkArea(ssize_t top,
ssize_t left,
ssize_t bottom,
ssize_t right,
ssize_t weight);
static bool areAreasDifferent(Vector< sp<CameraArea> > &, Vector< sp<CameraArea> > &);
protected:
static const ssize_t TOP = -1000;
static const ssize_t LEFT = -1000;
static const ssize_t BOTTOM = 1000;
static const ssize_t RIGHT = 1000;
static const ssize_t WEIGHT_MIN = 1;
static const ssize_t WEIGHT_MAX = 1000;
ssize_t mTop;
ssize_t mLeft;
ssize_t mBottom;
ssize_t mRight;
size_t mWeight;
};
class CameraFDResult : public RefBase
{
public:
CameraFDResult() : mFaceData(NULL) {};
CameraFDResult(camera_frame_metadata_t *faces) : mFaceData(faces) {};
virtual ~CameraFDResult() {
if ( ( NULL != mFaceData ) && ( NULL != mFaceData->faces ) ) {
free(mFaceData->faces);
free(mFaceData);
mFaceData=NULL;
}
if(( NULL != mFaceData ))
{
free(mFaceData);
mFaceData = NULL;
}
}
camera_frame_metadata_t *getFaceResult() { return mFaceData; };
static const ssize_t TOP = -1000;
static const ssize_t LEFT = -1000;
static const ssize_t BOTTOM = 1000;
static const ssize_t RIGHT = 1000;
static const ssize_t INVALID_DATA = -2000;
private:
camera_frame_metadata_t *mFaceData;
};
class CameraFrame
{
public:
enum FrameType
{
PREVIEW_FRAME_SYNC = 0x1, ///SYNC implies that the frame needs to be explicitly returned after consuming in order to be filled by camera again
PREVIEW_FRAME = 0x2 , ///Preview frame includes viewfinder and snapshot frames
IMAGE_FRAME_SYNC = 0x4, ///Image Frame is the image capture output frame
IMAGE_FRAME = 0x8,
VIDEO_FRAME_SYNC = 0x10, ///Timestamp will be updated for these frames
VIDEO_FRAME = 0x20,
FRAME_DATA_SYNC = 0x40, ///Any extra data assosicated with the frame. Always synced with the frame
FRAME_DATA= 0x80,
RAW_FRAME = 0x100,
SNAPSHOT_FRAME = 0x200,
ALL_FRAMES = 0xFFFF ///Maximum of 16 frame types supported
};
enum FrameQuirks
{
ENCODE_RAW_YUV422I_TO_JPEG = 0x1 << 0,
ENCODE_RAW_RGB24_TO_JPEG = 0x1 << 1,
ENCODE_RAW_YUV420SP_TO_JPEG = 0x1 << 2,
HAS_EXIF_DATA = 0x1 << 3,
};
enum PixelFormat
{
PIXEL_FMT_NV21 = 1,
PIXEL_FMT_YV12,
PIXEL_FMT_YU12,
PIXEL_FMT_YUYV,
PIXEL_FMT_RGB24,
};
//default contrustor
CameraFrame():
mCookie(NULL),
mCookie2(NULL),
mBuffer(NULL),
mFrameType(0),
mTimestamp(0),
mWidth(0),
mHeight(0),
mOffset(0),
mAlignment(0),
mFd(0),
mLength(0),
mFrameMask(0),
mQuirks(0),
mPixelFmt(0) {
mYuv[0] = 0;
mYuv[1] = 0;
mCanvas = 0;
}
//copy constructor
CameraFrame(const CameraFrame &frame) :
mCookie(frame.mCookie),
mCookie2(frame.mCookie2),
mBuffer(frame.mBuffer),
mFrameType(frame.mFrameType),
mTimestamp(frame.mTimestamp),
mWidth(frame.mWidth),
mHeight(frame.mHeight),
mOffset(frame.mOffset),
mAlignment(frame.mAlignment),
mFd(frame.mFd),
mLength(frame.mLength),
mFrameMask(frame.mFrameMask),
mQuirks(frame.mQuirks),
mPixelFmt(frame.mPixelFmt) {
mYuv[0] = frame.mYuv[0];
mYuv[1] = frame.mYuv[1];
mCanvas = frame.mCanvas;
}
void *mCookie;
void *mCookie2;
void *mBuffer;
int mFrameType;
nsecs_t mTimestamp;
unsigned int mWidth, mHeight;
uint32_t mOffset;
unsigned int mAlignment;
int mFd;
size_t mLength;
unsigned mFrameMask;
unsigned int mQuirks;
unsigned int mPixelFmt;
unsigned int mYuv[2];
unsigned int mCanvas;
///@todo add other member vars like stride etc
};
enum CameraHalError
{
CAMERA_ERROR_FATAL = 0x1, //Fatal errors can only be recovered by restarting media server
CAMERA_ERROR_HARD = 0x2, // Hard errors are hardware hangs that may be recoverable by resetting the hardware internally within the adapter
CAMERA_ERROR_SOFT = 0x4, // Soft errors are non fatal errors that can be recovered from without needing to stop use-case
};
///Common Camera Hal Event class which is visible to CameraAdapter,DisplayAdapter and AppCallbackNotifier
///@todo Rename this class to CameraEvent
class CameraHalEvent
{
public:
//Enums
enum CameraHalEventType {
NO_EVENTS = 0x0,
EVENT_FOCUS_LOCKED = 0x1,
EVENT_FOCUS_ERROR = 0x2,
EVENT_ZOOM_INDEX_REACHED = 0x4,
EVENT_SHUTTER = 0x8,
EVENT_FACE = 0x10,
EVENT_FOCUS_MOVE = 0x20,
///@remarks Future enum related to display, like frame displayed event, could be added here
ALL_EVENTS = 0xFFFF ///Maximum of 16 event types supported
};
///Class declarations
///@remarks Add a new class for a new event type added above
//Shutter event specific data
typedef struct ShutterEventData_t {
bool shutterClosed;
}ShutterEventData;
///Focus event specific data
typedef struct FocusEventData_t {
bool focusLocked;
bool focusError;
int currentFocusValue;
} FocusEventData;
typedef struct FocusMoveEventData_t {
bool focusStart;
int currentFocusValue;
} FocusMoveEventData;
///Zoom specific event data
typedef struct ZoomEventData_t {
int currentZoomIndex;
bool targetZoomIndexReached;
} ZoomEventData;
typedef struct FaceData_t {
ssize_t top;
ssize_t left;
ssize_t bottom;
ssize_t right;
size_t score;
} FaceData;
typedef sp<CameraFDResult> FaceEventData;
class CameraHalEventData : public RefBase{
public:
CameraHalEvent::FocusEventData focusEvent;
CameraHalEvent::FocusMoveEventData focusMoveEvent;
CameraHalEvent::ZoomEventData zoomEvent;
CameraHalEvent::ShutterEventData shutterEvent;
CameraHalEvent::FaceEventData faceEvent;
};
//default contrustor
CameraHalEvent():
mCookie(NULL),
mEventType(NO_EVENTS) {}
//copy constructor
CameraHalEvent(const CameraHalEvent &event) :
mCookie(event.mCookie),
mEventType(event.mEventType),
mEventData(event.mEventData) {};
void* mCookie;
CameraHalEventType mEventType;
sp<CameraHalEventData> mEventData;
};
/// Have a generic callback class based on template - to adapt CameraFrame and Event
typedef void (*frame_callback) (CameraFrame *cameraFrame);
typedef void (*event_callback) (CameraHalEvent *event);
//signals CameraHAL to relase image buffers
typedef void (*release_image_buffers_callback) (void *userData);
typedef void (*end_image_capture_callback) (void *userData);
/**
* Interface class implemented by classes that have some events to communicate to dependendent classes
* Dependent classes use this interface for registering for events
*/
class MessageNotifier
{
public:
static const uint32_t EVENT_BIT_FIELD_POSITION;
static const uint32_t FRAME_BIT_FIELD_POSITION;
///@remarks Msg type comes from CameraFrame and CameraHalEvent classes
/// MSB 16 bits is for events and LSB 16 bits is for frame notifications
/// FrameProvider and EventProvider classes act as helpers to event/frame
/// consumers to call this api
virtual void enableMsgType(int32_t msgs, frame_callback frameCb=NULL, event_callback eventCb=NULL, void* cookie=NULL) = 0;
virtual void disableMsgType(int32_t msgs, void* cookie) = 0;
virtual ~MessageNotifier() {};
};
class ErrorNotifier : public virtual RefBase
{
public:
virtual void errorNotify(int error) = 0;
virtual ~ErrorNotifier() {};
};
/**
* Interace class abstraction for Camera Adapter to act as a frame provider
* This interface is fully implemented by Camera Adapter
*/
class FrameNotifier : public MessageNotifier
{
public:
virtual void returnFrame(void* frameBuf, CameraFrame::FrameType frameType) = 0;
virtual void addFramePointers(void *frameBuf, void *buf) = 0;
virtual void removeFramePointers() = 0;
virtual ~FrameNotifier() {};
};
/** * Wrapper class around Frame Notifier, which is used by display and notification classes for interacting with Camera Adapter
*/
class FrameProvider
{
FrameNotifier* mFrameNotifier;
void* mCookie;
frame_callback mFrameCallback;
public:
FrameProvider(FrameNotifier *fn, void* cookie, frame_callback frameCallback)
:mFrameNotifier(fn), mCookie(cookie),mFrameCallback(frameCallback) { }
int enableFrameNotification(int32_t frameTypes);
int disableFrameNotification(int32_t frameTypes);
int returnFrame(void *frameBuf, CameraFrame::FrameType frameType);
void addFramePointers(void *frameBuf, void *buf);
void removeFramePointers();
};
/** Wrapper class around MessageNotifier, which is used by display and notification classes for interacting with
* Camera Adapter
*/
class EventProvider
{
public:
MessageNotifier* mEventNotifier;
void* mCookie;
event_callback mEventCallback;
public:
EventProvider(MessageNotifier *mn, void* cookie, event_callback eventCallback)
:mEventNotifier(mn), mCookie(cookie), mEventCallback(eventCallback) {}
int enableEventNotification(int32_t eventTypes);
int disableEventNotification(int32_t eventTypes);
};
/*
* Interface for providing buffers
*/
class BufferProvider
{
public:
virtual void* allocateBuffer(int width, int height, const char* format, int &bytes, int numBufs) = 0;
//additional methods used for memory mapping
virtual uint32_t * getOffsets() = 0;
virtual int getFd() = 0;
virtual int freeBuffer(void* buf) = 0;
virtual ~BufferProvider() {}
};
/**
* Class for handling data and notify callbacks to application
*/
class AppCallbackNotifier: public ErrorNotifier , public virtual RefBase
{
public:
///Constants
static const int NOTIFIER_TIMEOUT;
static const int32_t MAX_BUFFERS = 8;
enum NotifierCommands
{
NOTIFIER_CMD_PROCESS_EVENT,
NOTIFIER_CMD_PROCESS_FRAME,
NOTIFIER_CMD_PROCESS_ERROR
};
enum NotifierState
{
NOTIFIER_STOPPED,
NOTIFIER_STARTED,
NOTIFIER_EXITED
};
public:
~AppCallbackNotifier();
///Initialzes the callback notifier, creates any resources required
status_t initialize();
///Starts the callbacks to application
status_t start();
///Stops the callbacks from going to application
status_t stop();
void setEventProvider(int32_t eventMask, MessageNotifier * eventProvider);
void setFrameProvider(FrameNotifier *frameProvider);
//All sub-components of Camera HAL call this whenever any error happens
virtual void errorNotify(int error);
status_t startPreviewCallbacks(CameraParameters ¶ms, void *buffers, uint32_t *offsets, int fd, size_t length, size_t count);
status_t stopPreviewCallbacks();
status_t enableMsgType(int32_t msgType);
status_t disableMsgType(int32_t msgType);
//API for enabling/disabling measurement data
void setMeasurements(bool enable);
//thread loops
bool notificationThread();
///Notification callback functions
static void frameCallbackRelay(CameraFrame* caFrame);
static void eventCallbackRelay(CameraHalEvent* chEvt);
void frameCallback(CameraFrame* caFrame);
void eventCallback(CameraHalEvent* chEvt);
void flushAndReturnFrames();
void setCallbacks(CameraHal *cameraHal,
camera_notify_callback notify_cb,
camera_data_callback data_cb,
camera_data_timestamp_callback data_cb_timestamp,
camera_request_memory get_memory,
void *user);
//Set Burst mode
void setBurst(bool burst);
//Notifications from CameraHal for video recording case
status_t startRecording();
status_t stopRecording();
status_t initSharedVideoBuffers(void *buffers, uint32_t *offsets, int fd, size_t length, size_t count, void *vidBufs);
status_t releaseRecordingFrame(const void *opaque);
status_t useMetaDataBufferMode(bool enable);
void EncoderDoneCb(void*, void*, CameraFrame::FrameType type, void* cookie1, void* cookie2);
void useVideoBuffers(bool useVideoBuffers);
bool getUseVideoBuffers();
void setVideoRes(int width, int height);
void flushEventQueue();
//Internal class definitions
class NotificationThread : public Thread {
AppCallbackNotifier* mAppCallbackNotifier;
MSGUTILS::MessageQueue mNotificationThreadQ;
public:
enum NotificationThreadCommands
{
NOTIFIER_START,
NOTIFIER_STOP,
NOTIFIER_EXIT,
};
public:
NotificationThread(AppCallbackNotifier* nh)
: Thread(false), mAppCallbackNotifier(nh) { }
virtual bool threadLoop() {
return mAppCallbackNotifier->notificationThread();
}
MSGUTILS::MessageQueue &msgQ() { return mNotificationThreadQ;}
};
//Friend declarations
friend class NotificationThread;
private:
void notifyEvent();
void notifyFrame();
bool processMessage();
void releaseSharedVideoBuffers();
status_t dummyRaw();
void copyAndSendPictureFrame(CameraFrame* frame, int32_t msgType);
void copyAndSendPreviewFrame(CameraFrame* frame, int32_t msgType);
private:
mutable Mutex mLock;
mutable Mutex mBurstLock;
CameraHal* mCameraHal;
camera_notify_callback mNotifyCb;
camera_data_callback mDataCb;
camera_data_timestamp_callback mDataCbTimestamp;
camera_request_memory mRequestMemory;
void *mCallbackCookie;
//Keeps Video MemoryHeaps and Buffers within
//these objects
KeyedVector<unsigned int, unsigned int> mVideoHeaps;
KeyedVector<unsigned int, unsigned int> mVideoBuffers;
KeyedVector<unsigned int, unsigned int> mVideoMap;
//Keeps list of Gralloc handles and associated Video Metadata Buffers
KeyedVector<uint32_t, uint32_t> mVideoMetadataBufferMemoryMap;
KeyedVector<uint32_t, uint32_t> mVideoMetadataBufferReverseMap;
bool mBufferReleased;
sp< NotificationThread> mNotificationThread;
EventProvider *mEventProvider;
FrameProvider *mFrameProvider;
MSGUTILS::MessageQueue mEventQ;
MSGUTILS::MessageQueue mFrameQ;
NotifierState mNotifierState;
bool mPreviewing;
camera_memory_t* mPreviewMemory;
unsigned char* mPreviewBufs[MAX_BUFFERS];
int mPreviewBufCount;
const char *mPreviewPixelFormat;
KeyedVector<unsigned int, sp<MemoryHeapBase> > mSharedPreviewHeaps;
KeyedVector<unsigned int, sp<MemoryBase> > mSharedPreviewBuffers;
//Burst mode active
bool mBurst;
mutable Mutex mRecordingLock;
bool mRecording;
bool mMeasurementEnabled;
bool mUseMetaDataBufferMode;
bool mRawAvailable;
bool mUseVideoBuffers;
int mVideoWidth;
int mVideoHeight;
};
/**
* Class used for allocating memory for JPEG bit stream buffers, output buffers of camera in no overlay case
*/
class MemoryManager : public BufferProvider, public virtual RefBase
{
public:
MemoryManager(){ }
///Initializes the memory manager creates any resources required
status_t initialize() { return NO_ERROR; }
int setErrorHandler(ErrorNotifier *errorNotifier);
int setRequestMemoryCallback(camera_request_memory get_memory);
virtual void* allocateBuffer(int width, int height, const char* format, int &bytes, int numBufs);
virtual uint32_t * getOffsets();
virtual int getFd() ;
virtual int freeBuffer(void* buf);
private:
camera_request_memory mRequestMemory;
sp<ErrorNotifier> mErrorNotifier;
KeyedVector<unsigned int, unsigned int> mMemoryHandleMap;
};
/**
* CameraAdapter interface class
* Concrete classes derive from this class and provide implementations based on the specific camera h/w interface
*/
class CameraAdapter: public FrameNotifier, public virtual RefBase
{
protected:
enum AdapterActiveStates {
INTIALIZED_ACTIVE = 1 << 0,
LOADED_PREVIEW_ACTIVE = 1 << 1,
PREVIEW_ACTIVE = 1 << 2,
LOADED_CAPTURE_ACTIVE = 1 << 3,
CAPTURE_ACTIVE = 1 << 4,
BRACKETING_ACTIVE = 1 << 5,
AF_ACTIVE = 1 << 6,
ZOOM_ACTIVE = 1 << 7,
VIDEO_ACTIVE = 1 << 8,
};
public:
typedef struct
{
void *mBuffers;
uint32_t *mOffsets;
int mFd;
size_t mLength;
size_t mCount;
size_t mMaxQueueable;
} BuffersDescriptor;
enum CameraCommands
{
CAMERA_START_PREVIEW = 0,
CAMERA_STOP_PREVIEW = 1,
CAMERA_START_VIDEO = 2,
CAMERA_STOP_VIDEO = 3,
CAMERA_START_IMAGE_CAPTURE = 4,
CAMERA_STOP_IMAGE_CAPTURE = 5,
CAMERA_PERFORM_AUTOFOCUS = 6,
CAMERA_CANCEL_AUTOFOCUS = 7,
CAMERA_PREVIEW_FLUSH_BUFFERS = 8,
CAMERA_START_SMOOTH_ZOOM = 9,
CAMERA_STOP_SMOOTH_ZOOM = 10,
CAMERA_USE_BUFFERS_PREVIEW = 11,
CAMERA_SET_TIMEOUT = 12,
CAMERA_CANCEL_TIMEOUT = 13,
CAMERA_START_BRACKET_CAPTURE = 14,
CAMERA_STOP_BRACKET_CAPTURE = 15,
CAMERA_QUERY_RESOLUTION_PREVIEW = 16,
CAMERA_QUERY_BUFFER_SIZE_IMAGE_CAPTURE = 17,
CAMERA_QUERY_BUFFER_SIZE_PREVIEW_DATA = 18,
CAMERA_USE_BUFFERS_IMAGE_CAPTURE = 19,
CAMERA_USE_BUFFERS_PREVIEW_DATA = 20,
CAMERA_TIMEOUT_EXPIRED = 21,
CAMERA_START_FD = 22,
CAMERA_STOP_FD = 23,
CAMERA_SWITCH_TO_EXECUTING = 24,
CAMERA_DISABLE_MIRROR = 25,
CAMERA_FOCUS_MOVE_MSG = 26,
CAMERA_APK = 27,
};
enum CameraMode
{
CAMERA_PREVIEW,
CAMERA_IMAGE_CAPTURE,
CAMERA_VIDEO,
CAMERA_MEASUREMENT
};
enum AdapterState {
INTIALIZED_STATE = INTIALIZED_ACTIVE,
LOADED_PREVIEW_STATE = LOADED_PREVIEW_ACTIVE | INTIALIZED_ACTIVE,
PREVIEW_STATE = PREVIEW_ACTIVE | INTIALIZED_ACTIVE,
LOADED_CAPTURE_STATE = LOADED_CAPTURE_ACTIVE | PREVIEW_ACTIVE | INTIALIZED_ACTIVE,
CAPTURE_STATE = CAPTURE_ACTIVE | PREVIEW_ACTIVE | INTIALIZED_ACTIVE,
BRACKETING_STATE = BRACKETING_ACTIVE | CAPTURE_ACTIVE | PREVIEW_ACTIVE | INTIALIZED_ACTIVE ,
AF_STATE = AF_ACTIVE | PREVIEW_ACTIVE | INTIALIZED_ACTIVE,
ZOOM_STATE = ZOOM_ACTIVE | PREVIEW_ACTIVE | INTIALIZED_ACTIVE,
VIDEO_STATE = VIDEO_ACTIVE | PREVIEW_ACTIVE | INTIALIZED_ACTIVE,
VIDEO_AF_STATE = VIDEO_ACTIVE | AF_ACTIVE | PREVIEW_ACTIVE | INTIALIZED_ACTIVE,
VIDEO_ZOOM_STATE = VIDEO_ACTIVE | ZOOM_ACTIVE | PREVIEW_ACTIVE | INTIALIZED_ACTIVE,
VIDEO_LOADED_CAPTURE_STATE = VIDEO_ACTIVE | LOADED_CAPTURE_ACTIVE | PREVIEW_ACTIVE | INTIALIZED_ACTIVE,
VIDEO_CAPTURE_STATE = VIDEO_ACTIVE | CAPTURE_ACTIVE | PREVIEW_ACTIVE | INTIALIZED_ACTIVE,
AF_ZOOM_STATE = AF_ACTIVE | ZOOM_ACTIVE | PREVIEW_ACTIVE | INTIALIZED_ACTIVE,
BRACKETING_ZOOM_STATE = BRACKETING_ACTIVE | ZOOM_ACTIVE | PREVIEW_ACTIVE | INTIALIZED_ACTIVE,
};
public:
///Initialzes the camera adapter creates any resources required
virtual int initialize(CameraProperties::Properties*) = 0;
virtual int setErrorHandler(ErrorNotifier *errorNotifier) = 0;
//Message/Frame notification APIs
virtual void enableMsgType(int32_t msgs,
frame_callback callback = NULL,
event_callback eventCb = NULL,
void *cookie = NULL) = 0;
virtual void disableMsgType(int32_t msgs, void* cookie) = 0;
virtual void returnFrame(void* frameBuf, CameraFrame::FrameType frameType) = 0;
virtual void addFramePointers(void *frameBuf, void *buf) = 0;
virtual void removeFramePointers() = 0;
//APIs to configure Camera adapter and get the current parameter set
virtual int setParameters(const CameraParameters& params) = 0;
virtual void getParameters(CameraParameters& params) = 0;
//API to flush the buffers from Camera
status_t flushBuffers()
{
return sendCommand(CameraAdapter::CAMERA_PREVIEW_FLUSH_BUFFERS);
}
//Registers callback for returning image buffers back to CameraHAL
virtual int registerImageReleaseCallback(release_image_buffers_callback callback, void *user_data) = 0;
//Registers callback, which signals a completed image capture
virtual int registerEndCaptureCallback(end_image_capture_callback callback, void *user_data) = 0;
//API to send a command to the camera
virtual status_t sendCommand(CameraCommands operation, int value1=0, int value2=0, int value3=0) = 0;
virtual ~CameraAdapter() {};
//Retrieves the current Adapter state
virtual AdapterState getState() = 0;
//Retrieves the next Adapter state
virtual AdapterState getNextState() = 0;
// Receive orientation events from CameraHal
virtual void onOrientationEvent(uint32_t orientation, uint32_t tilt) = 0;
// Rolls the state machine back to INTIALIZED_STATE from the current state
virtual status_t rollbackToInitializedState() = 0;
protected:
//The first two methods will try to switch the adapter state.
//Every call to setState() should be followed by a corresponding
//call to commitState(). If the state switch fails, then it will
//get reset to the previous state via rollbackState().
virtual status_t setState(CameraCommands operation) = 0;
virtual status_t commitState() = 0;
virtual status_t rollbackState() = 0;
// Retrieves the current Adapter state - for internal use (not locked)
virtual status_t getState(AdapterState &state) = 0;
// Retrieves the next Adapter state - for internal use (not locked)
virtual status_t getNextState(AdapterState &state) = 0;
};
class DisplayAdapter : public BufferProvider, public virtual RefBase
{
public:
typedef struct S3DParameters_t
{
int mode;
int framePacking;
int order;
int subSampling;
} S3DParameters;
///Initializes the display adapter creates any resources required
virtual int initialize() = 0;
virtual int setPreviewWindow(struct preview_stream_ops *window) = 0;
virtual int setFrameProvider(FrameNotifier *frameProvider) = 0;
virtual int setErrorHandler(ErrorNotifier *errorNotifier) = 0;
virtual int enableDisplay(int width, int height, struct timeval *refTime = NULL, S3DParameters *s3dParams = NULL) = 0;
virtual int disableDisplay(bool cancel_buffer = true) = 0;
//Used for Snapshot review temp. pause
virtual int pauseDisplay(bool pause) = 0;
#if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS
//Used for shot to snapshot measurement
virtual int setSnapshotTimeRef(struct timeval *refTime = NULL) = 0;
#endif
virtual int useBuffers(void *bufArr, int num) = 0;
virtual bool supportsExternalBuffering() = 0;
// Get max queueable buffers display supports
// This function should only be called after
// allocateBuffer
virtual int maxQueueableBuffers(unsigned int& queueable) = 0;
};
static void releaseImageBuffers(void *userData);
static void endImageCapture(void *userData);
/**
Implementation of the Android Camera hardware abstraction layer
*/
class CameraHal
{
public:
///Constants
static const int NO_BUFFERS_PREVIEW;
static const int NO_BUFFERS_IMAGE_CAPTURE;
static const uint32_t VFR_SCALE = 1000;
/*--------------------Interface Methods---------------------------------*/
//@{
public:
/** Set the notification and data callbacks */
void setCallbacks(camera_notify_callback notify_cb,
camera_data_callback data_cb,
camera_data_timestamp_callback data_cb_timestamp,
camera_request_memory get_memory,
void *user);
/** Receives orientation events from SensorListener **/
void onOrientationEvent(uint32_t orientation, uint32_t tilt);
/**
* The following three functions all take a msgtype,
* which is a bitmask of the messages defined in
* include/ui/Camera.h
*/
/**
* Enable a message, or set of messages.
*/
void enableMsgType(int32_t msgType);
/**
* Disable a message, or a set of messages.
*/
void disableMsgType(int32_t msgType);
/**
* Query whether a message, or a set of messages, is enabled.
* Note that this is operates as an AND, if any of the messages
* queried are off, this will return false.
*/
int msgTypeEnabled(int32_t msgType);
/**
* Start preview mode.
*/
int startPreview();
/**
* Only used if overlays are used for camera preview.
*/
int setPreviewWindow(struct preview_stream_ops *window);
/**
* Stop a previously started preview.
*/
void stopPreview();
/**
* Returns true if preview is enabled.
*/
bool previewEnabled();
/**
* Start record mode. When a record image is available a CAMERA_MSG_VIDEO_FRAME
* message is sent with the corresponding frame. Every record frame must be released
* by calling releaseRecordingFrame().
*/
int startRecording();
/**
* Stop a previously started recording.
*/
void stopRecording();
/**
* Returns true if recording is enabled.
*/
int recordingEnabled();
/**
* Release a record frame previously returned by CAMERA_MSG_VIDEO_FRAME.
*/
void releaseRecordingFrame(const void *opaque);
/**
* Start auto focus, the notification callback routine is called
* with CAMERA_MSG_FOCUS once when focusing is complete. autoFocus()
* will be called again if another auto focus is needed.
*/
int autoFocus();
/**
* Cancels auto-focus function. If the auto-focus is still in progress,
* this function will cancel it. Whether the auto-focus is in progress
* or not, this function will return the focus position to the default.
* If the camera does not support auto-focus, this is a no-op.
*/
int cancelAutoFocus();
/**
* Take a picture.
*/
int takePicture();
/**
* Cancel a picture that was started with takePicture. Calling this
* method when no picture is being taken is a no-op.
*/
int cancelPicture();
/** Set the camera parameters. */
int setParameters(const char* params);
int setParameters(const CameraParameters& params);
/** Return the camera parameters. */
char* getParameters();
void putParameters(char *);
/**
* Send command to camera driver.
*/
int sendCommand(int32_t cmd, int32_t arg1, int32_t arg2);
/**
* Release the hardware resources owned by this object. Note that this is
* *not* done in the destructor.
*/
void release();
/**
* Dump state of the camera hardware
*/
int dump(int fd) const;
status_t storeMetaDataInBuffers(bool enable);
//@}
/*--------------------Internal Member functions - Public---------------------------------*/
public:
/** @name internalFunctionsPublic */
//@{
/** Constructor of CameraHal */
CameraHal(int cameraId);
// Destructor of CameraHal
~CameraHal();
/** Initialize CameraHal */
status_t initialize(CameraProperties::Properties*);
/** Deinitialize CameraHal */
void deinitialize();
#if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS
//Uses the constructor timestamp as a reference to calcluate the
// elapsed time
static void PPM(const char *);
//Uses a user provided timestamp as a reference to calcluate the
// elapsed time
static void PPM(const char *, struct timeval*, ...);
#endif
/** Free image bufs */
status_t freeImageBufs();
//Signals the end of image capture
status_t signalEndImageCapture();
//Events
static void eventCallbackRelay(CameraHalEvent* event);
void eventCallback(CameraHalEvent* event);
void setEventProvider(int32_t eventMask, MessageNotifier * eventProvider);
/*--------------------Internal Member functions - Private---------------------------------*/
private:
/** @name internalFunctionsPrivate */
//@{
/** Set the camera parameters specific to Video Recording. */
bool setVideoModeParameters(const CameraParameters&);
/** Reset the camera parameters specific to Video Recording. */
bool resetVideoModeParameters();
/** Restart the preview with setParameter. */
status_t restartPreview();
status_t parseResolution(const char *resStr, int &width, int &height);
void insertSupportedParams();
/** Allocate preview data buffers */
status_t allocPreviewDataBufs(size_t size, size_t bufferCount);
/** Free preview data buffers */
status_t freePreviewDataBufs();
/** Allocate preview buffers */
status_t allocPreviewBufs(int width, int height, const char* previewFormat, unsigned int bufferCount, unsigned int &max_queueable);
/** Allocate video buffers */
status_t allocVideoBufs(uint32_t width, uint32_t height, uint32_t bufferCount);
/** Allocate image capture buffers */
status_t allocImageBufs(unsigned int width, unsigned int height, size_t length, const char* previewFormat, unsigned int bufferCount);
/** Free preview buffers */
status_t freePreviewBufs();
/** Free video bufs */
status_t freeVideoBufs(void *bufs);
//Check if a given resolution is supported by the current camera
//instance
bool isResolutionValid(unsigned int width, unsigned int height, const char *supportedResolutions);
//Check if a given parameter is supported by the current camera
// instance
bool isParameterValid(const char *param, const char *supportedParams);
bool isParameterValid(int param, const char *supportedParams);
bool isParameterInRange(int param, const char *supportedParams);
status_t doesSetParameterNeedUpdate(const char *new_param, const char *old_params, bool &update);
/** Initialize default parameters */
void initDefaultParameters();
void dumpProperties(CameraProperties::Properties& cameraProps);
status_t startImageBracketing();
status_t stopImageBracketing();
void setShutter(bool enable);
void forceStopPreview();
void selectFPSRange(int framerate, int *min_fps, int *max_fps);
void setPreferredPreviewRes(int width, int height);
void resetPreviewRes(CameraParameters *mParams, int width, int height);
//@}
/*----------Member variables - Public ---------------------*/
public:
int32_t mMsgEnabled;
bool mRecordEnabled;
nsecs_t mCurrentTime;
bool mFalsePreview;
bool mPreviewEnabled;
uint32_t mTakePictureQueue;
bool mBracketingEnabled;
bool mBracketingRunning;
//User shutter override
bool mShutterEnabled;
bool mMeasurementEnabled;
//Google's parameter delimiter
static const char PARAMS_DELIMITER[];
CameraAdapter *mCameraAdapter;
sp<AppCallbackNotifier> mAppCallbackNotifier;
sp<DisplayAdapter> mDisplayAdapter;
sp<MemoryManager> mMemoryManager;
sp<IMemoryHeap> mPictureHeap;
int* mGrallocHandles;
bool mFpsRangeChangedByApp;
///static member vars
#if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS
//Timestamp from the CameraHal constructor
static struct timeval ppm_start;
//Timestamp of the autoFocus command
static struct timeval mStartFocus;
//Timestamp of the startPreview command
static struct timeval mStartPreview;
//Timestamp of the takePicture command
static struct timeval mStartCapture;
#endif
/*----------Member variables - Private ---------------------*/
private:
bool mDynamicPreviewSwitch;
//keeps paused state of display
bool mDisplayPaused;
//Index of current camera adapter
int mCameraIndex;
mutable Mutex mLock;
#ifdef ENABLE_SENSOR_LISTENER
sp<SensorListener> mSensorListener;
#endif
void* mCameraAdapterHandle;
CameraParameters mParameters;
bool mPreviewRunning;
bool mPreviewStateOld;
bool mRecordingEnabled;
EventProvider *mEventProvider;
int32_t *mPreviewDataBufs;
uint32_t *mPreviewDataOffsets;
int mPreviewDataFd;
int mPreviewDataLength;
int32_t *mImageBufs;
uint32_t *mImageOffsets;
int mImageFd;
int mImageLength;
int32_t *mPreviewBufs;
uint32_t *mPreviewOffsets;
int mPreviewLength;
int mPreviewFd;
int32_t *mVideoBufs;
uint32_t *mVideoOffsets;
int mVideoFd;
int mVideoLength;
int mBracketRangePositive;
int mBracketRangeNegative;
///@todo Rename this as preview buffer provider
BufferProvider *mBufProvider;
BufferProvider *mVideoBufProvider;
CameraProperties::Properties* mCameraProperties;
bool mPreviewStartInProgress;
bool mSetPreviewWindowCalled;
uint32_t mPreviewWidth;
uint32_t mPreviewHeight;
int32_t mMaxZoomSupported;
int mVideoWidth;
int mVideoHeight;
int refCount;
};
}; // namespace android
#endif
| [
"Satya.N@kpit.com"
] | Satya.N@kpit.com |
ce4b6b6554c7badb74b8c8ecaff5138a784bca2a | 382b54900a4b928a97c17149ae3a337bc0f3ba61 | /src/InstanceServiceActions/MsiApi.cpp | 9b1a491a49a7092f794d8456469967f3e196f1c7 | [] | no_license | dementeddevil/Zen.Trunk | 155de3100a1c3b1081c0e451fda73a974bec2d53 | ec030355aca64fbe4024162cc8bd32ac9b5a1906 | refs/heads/master | 2022-10-25T15:38:53.337946 | 2022-10-18T20:07:46 | 2022-10-18T20:07:46 | 66,139,568 | 4 | 0 | null | 2022-09-04T22:27:14 | 2016-08-20T09:44:17 | C# | UTF-8 | C++ | false | false | 40 | cpp | #include "stdafx.h"
#include "MsiApi.h"
| [
"zen_global@hotmail.com"
] | zen_global@hotmail.com |
8a38dd1a2f596855b3c4d759433f86a07bb95b95 | 9ae5edf1371569f182ba3dd87bd2414ec98f523c | /Leetcode/largest_sum_averages.cpp | a1716d7c530e17a74ca2c9be3cec85ef7b7f8573 | [] | no_license | Manan007224/street-coding | 19000ed422563ca776053ec33adcd4e0b2734a8d | d3337805e0406684bcb3392898df163d315db624 | refs/heads/master | 2020-03-08T02:01:33.063948 | 2019-09-16T04:33:22 | 2019-09-16T04:33:22 | 127,847,522 | 1 | 0 | null | 2019-07-06T13:06:05 | 2018-04-03T03:47:59 | C++ | UTF-8 | C++ | false | false | 1,137 | cpp | #include <bits/stdc++.h>
using namespace std;
typedef vector<int> vi;
typedef vector<double> vi_32;
typedef vector<vi_32> vii_32;
typedef vector<vi> vii;
typedef pair<int,int> pii;
typedef long long i64;
#define pb push_back
#define fi first
#define se second
class Solution {
public:
double largestSumOfAverages(vector<int>& A, int K) {
int n = A.size();
vii_32 dp(n+1, vi_32(K+1, 0.0));
vi_32 prefix(n+1, 0);
for(int i=0; i<n; i++) prefix[i+1] = prefix[i]+A[i];
for(int i=1; i<=n; i++) dp[i][1] = prefix[i]/i;
if(K<=1) return dp[n][1];
if(K>=n) return prefix[n];
for(int k=2; k<=K; k++) {
for(int i=k; i<=n; i++) {
for(int j=i-1; j>=k-1; j--) {
double next_average = (prefix[i]-prefix[j])/(i-j);
dp[i][k] = max(dp[i][k], dp[j][k-1] + next_average);
}
}
}
for(int i=1; i<=n; i++) cout << dp[i][1] << " ";
cout << endl;
for(int i=1; i<=n; ++i) cout << dp[i][2] << " ";
cout << endl;
return dp[n][K];
}
};
int main() {
vector<int> arr = {9,1,2,3,9};
Solution sln;
cout << sln.largestSumOfAverages(arr, 2) << endl;
return 0;
} | [
"maniyarmanan1996@gmail.com"
] | maniyarmanan1996@gmail.com |
a84613710cce9100eee6de20abbe95a8da4e4f20 | e3796fea20da8c7e7f74066bae04a398dc0781d7 | /Homework10-25/Homework10-25/main0503.cpp | 384d3cd505bcccd2c89bcc48f053bbaef4aa9c5f | [] | no_license | stories2/KangnamClass | 9a66ebd059e1def5a63dc9f3e6f27e33c95aff18 | 81c174789c9d6651dba8952e5b056781b4b8b768 | refs/heads/master | 2021-03-22T04:31:32.209771 | 2017-12-13T09:09:55 | 2017-12-13T09:09:55 | 105,345,153 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 236 | cpp | #include "CIrcle0503.h"
void increaseBy(Circle &, Circle);
int main() {
Circle x(10), y(5);
increaseBy(x, y);
x.show();
return 0;
}
void increaseBy(Circle &a, Circle b) {
int r = a.getRadius() + b.getRadius();
a.setRadius(r);
} | [
"stories2@naver.com"
] | stories2@naver.com |
60add11bdd4ad14492c066d02b174515476d935f | 8bc00d7a908f008d63494150a799337b8bbcd453 | /zaConsole/zaPicList.h | 67998a33e09ab6031ad55a6e775c3be8c5dd831f | [] | no_license | cubezone/zaOS | 29d9ecebeeef1cc2ced6444c20e1c01ab1d73e1b | 6f389186878d68cdc6285642b5b0ec3ffb5360a6 | refs/heads/master | 2021-01-18T22:09:51.626564 | 2016-06-12T01:39:00 | 2016-06-12T01:39:00 | 21,687,086 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 283 | h | /*
* zaPicList.h
*
* Created on: 2012-2-19
* Author: zhuxy
*/
#include "zaAll.h"
#ifndef ZAPICLIST_H_
#define ZAPICLIST_H_
class zaPicList : public zaObj {
public:
zaPicList();
void addPic();
zaWorker *m_worker;
virtual ~zaPicList();
};
#endif /* ZAPICLIST_H_ */
| [
"sisdaemo@hotmail.com"
] | sisdaemo@hotmail.com |
ace0ac401e5d08104b48ba474b32991c11e371a9 | d1636b2f69e922ec128a92e0fdd380cf2532288f | /Subtract_Command.cpp | 80151d34dfb3520745d2391f8dc191e5a0963390 | [] | no_license | vincentrc/DesignPatternsCalculator1 | 62f1331797e5d446b35bb94396e28e02148ddb65 | b8a545b9c09026f203296ce51a9ee9018d9a0abd | refs/heads/master | 2020-05-26T04:50:06.330022 | 2019-05-23T19:58:51 | 2019-05-23T19:58:51 | 188,111,111 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 398 | cpp | // Honor Pledge:
//
// I pledge that I have neither given nor receieved any help
// on this assignment.
#include "Subtract_Command.h"
#include "Binary_Op_Command.h"
#include "Stack.h"
//Constructor
Subtract_Command::Subtract_Command(Stack <int> & s)
: Binary_Op_Command (s)
{}
//Addition command
int Subtract_Command::evaluate (int n1, int n2) const
{
return n1 - n2;
}
| [
"noreply@github.com"
] | noreply@github.com |
839e40baa5bdf10aa5872a8671cab2138f89da38 | 3ea34c23f90326359c3c64281680a7ee237ff0f2 | /Data/50/H | e04c7218e2a3ad846e751e094ed1335d330b83e9 | [] | no_license | lcnbr/EM | c6b90c02ba08422809e94882917c87ae81b501a2 | aec19cb6e07e6659786e92db0ccbe4f3d0b6c317 | refs/heads/master | 2023-04-28T20:25:40.955518 | 2020-02-16T23:14:07 | 2020-02-16T23:14:07 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 266,040 | /*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | foam-extend: Open Source Cstd::filesystem::create_directory();FD |
| \\ / O peration | Version: 4.0 |
| \\ / A nd | Web: http://www.foam-extend.org |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class volVectorField;
location "Data/50";
object H;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
dimensions [0 1 -1 0 0 0 0];
internalField nonuniform List<vector>
17576
(
(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,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,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)
(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,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,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)
(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,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,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)
(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,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,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)
(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,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,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)
(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,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,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)
(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,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,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)
(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,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,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)
(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,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,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)
(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,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,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)
(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,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,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)
(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,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,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)
(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,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,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)
(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,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,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)
(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,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,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)
(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,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,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)
(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,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,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)
(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,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,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)
(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,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,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)
(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,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,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)
(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,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,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)
(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,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,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)
(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,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,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)
(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,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,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)
(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,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,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)
(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,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,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)
(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,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,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)
(0,0,0)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(0,0,0)
(0,0,0)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(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,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,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)
(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,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,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)
(0,0,0)
(0,0,0)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(0,0,0)
(0,0,0)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(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,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,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)
(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,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,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)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(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,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,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)
(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,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,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)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(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,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,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)
(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,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,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)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(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,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,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)
(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,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,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)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(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,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,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)
(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,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,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)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(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,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,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)
(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,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,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)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(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,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,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)
(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,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,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)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(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,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,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)
(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,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,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)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(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,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,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)
(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,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,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)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(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,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,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)
(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,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,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)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(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,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,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)
(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,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,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)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(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,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,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)
(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,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,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)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(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,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,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)
(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,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,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)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(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,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,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)
(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,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,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)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(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,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,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)
(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,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,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)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(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,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,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)
(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,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,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)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(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,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,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)
(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,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,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)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(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,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,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)
(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,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,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)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(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,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,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)
(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,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,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)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(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,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,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)
(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,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,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)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(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,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,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)
(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,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,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)
(0,0,0)
(0,0,0)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(0,0,0)
(0,0,0)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(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,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,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)
(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,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,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)
(0,0,0)
(0,0,0)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(0,0,0)
(0,0,0)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(0,0,0)
(0,0,0)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(-nan,-nan,-nan)
(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,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,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)
(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,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,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)
(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,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,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)
(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,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,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)
(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,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,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)
(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,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,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)
(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,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,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)
(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,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,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)
(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,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,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)
(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,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,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)
(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,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,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)
(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,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,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)
(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,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,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)
(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,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,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)
(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,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,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)
(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,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,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)
(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,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,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)
(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,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,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)
(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,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,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)
(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,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,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)
(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,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,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)
(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,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,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)
(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,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,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)
(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,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,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)
(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,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,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)
(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,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,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)
(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,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,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)
(0,0,0)
)
;
boundaryField
{
fuel
{
type fixedValue;
value uniform (0.1 0 0);
}
air
{
type fixedValue;
value uniform (-0.1 0 0);
}
outlet
{
type zeroGradient;
}
frontAndBack
{
type empty;
}
}
// ************************************************************************* //
| [
"huberlulu@gmail.com"
] | huberlulu@gmail.com | |
406c035f5c820e48fae0ece7ec14d43f517e1df2 | 8adc8f7c0d98a33f3f4db2b75cb0ae30b602fa1d | /source/Classes/Sprite.cpp | 826006f7e0a3f2c918087c4ea5f3e963bc2f988a | [
"MIT"
] | permissive | mkalte666/Dragon2D_FlushPrototype | 98328446c539ae122b30a5f006264b183a5702b2 | 30c581fddc54bbc5747ee1e1c0b33e619d497d30 | refs/heads/master | 2021-01-11T05:04:39.952078 | 2015-05-15T21:20:23 | 2015-05-15T21:20:23 | 46,530,004 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,169 | cpp | #include "Sprite.h"
#include "Env.h"
namespace Dragon2D
{
D2DCLASS_REGISTER(Sprite);
Sprite::Sprite()
: programName("defaultSprite"), textureName(), textureOffset(.0f, .0f, 1.f, 1.f)
{
Env::GetResourceManager().RequestGLProgramResource(programName);
}
Sprite::Sprite(std::string name)
: programName("defaultSprite"), textureName(name), textureOffset(.0f, .0f, 1.f, 1.f)
{
Env::GetResourceManager().RequestGLProgramResource(programName);
Env::GetResourceManager().RequestTextureResource(textureName);
}
Sprite::Sprite(std::string name, std::string program)
: programName(program), textureName(name), textureOffset(.0f, .0f, 1.f, 1.f)
{
Env::GetResourceManager().RequestGLProgramResource(programName);
Env::GetResourceManager().RequestTextureResource(textureName);
}
Sprite::~Sprite()
{
Env::GetResourceManager().FreeGLProgramResource(programName);
Env::GetResourceManager().FreeTextureResource(textureName);
}
void Sprite::UseProgram(std::string program)
{
Env::GetResourceManager().FreeGLProgramResource(programName);
programName = program;
Env::GetResourceManager().RequestGLProgramResource(programName);
}
void Sprite::UseTexture(std::string texture)
{
Env::GetResourceManager().FreeTextureResource(textureName);
textureName = texture;
Env::GetResourceManager().RequestTextureResource(textureName);
}
void Sprite::SetOffset(glm::vec4 offset)
{
textureOffset = offset;
}
glm::vec4 Sprite::GetOffset()
{
return textureOffset;
}
void Sprite::Render()
{
TextureResource &t = Env::GetResourceManager().GetTextureResource(textureName);
GLProgramResource &p = Env::GetResourceManager().GetGLProgramResource(programName);
p.Use();
glUniform4f(p["position"], position[0], position[1], position[2], position[3]);
glUniform4f(p["offset"], textureOffset[0], textureOffset[1], textureOffset[2], textureOffset[3]);
glActiveTexture(GL_TEXTURE0);
t.Bind();
glUniform1i(p["textureSampler"], 0);
Env::RenderQuad();
BaseClass::Render();
}
std::string Sprite::GetTexture()
{
return textureName;
}
std::string Sprite::GetProgram()
{
return programName;
}
}; //namespace Dragon2D
| [
"mkalte666@googlemail.com"
] | mkalte666@googlemail.com |
e7eb12e3228c848755f639854b0c856f87686e37 | d066c77e614e6ef05b44eee0120e84588f8b9741 | /RLogin/Kermit.h | 7c2e20ea8ec06779d279f747e6e7673c2698aaa2 | [
"MIT"
] | permissive | kmiya-culti/RLogin | 7b01f2591fefbf22430ac9b0cca7b2093b463259 | c4f120ad617857a27f96aedd210e1e8b680024ec | refs/heads/master | 2023-08-25T20:03:45.341336 | 2023-08-03T22:10:00 | 2023-08-03T22:10:00 | 98,845,585 | 436 | 28 | MIT | 2021-03-23T14:55:33 | 2017-07-31T03:44:42 | C++ | UTF-8 | C++ | false | false | 3,070 | h | #pragma once
#include "SyncSock.h"
#define KMT_CMARK 0x01
#define KMT_DATAMAX 4000
#define KMT_PKTMAX (KMT_DATAMAX + 32)
#define KMT_PKTQUE 16
#define KMT_TIMEOUT 't'
#define KMT_CANCEL 'c'
#define KMT_SUMERR 's'
#define KMT_CAP_CONTINE 001 // 0000 0001
#define KMT_CAP_LONGPKT 002 // 0000 0010 Long Packet capability
#define KMT_CAP_SLIDWIN 004 // 0000 0100 Sliding Window capability
#define KMT_CAP_FILATTR 010 // 0000 1000 Attribute capability
#define KMT_CAP_RESEND 020 // 0001 0000 RESEND capability
#define KMT_CAP_LOCKSFT 040 // 0010 0000 Locking Shift capability
#define KMT_ATTR_TIME 001
#define KMT_ATTR_MODE 002
#define KMT_ATTR_SIZE 003
#define KMT_ATTR_TYPE 004
class CKermit : public CSyncSock
{
public:
int m_Stage;
int m_SendSeq;
int m_RecvSeq;
BYTE m_MarkCh; /* Packet Start character def='\1' */
BYTE m_EolCh; /* End-Of-Line character def='\015' */
BYTE m_PadCh; /* Padding character def=0 */
BYTE m_CtlCh; /* Control character prefix def='#' */
BYTE m_EbitCh; /* 8th bit character prefix def='&' */
BYTE m_RepCh; /* Repeat character prefix def='~' */
BYTE m_HisEbitCh; /* 8th bit character prefix def='&' */
BYTE m_HisRepCh; /* Repeat character prefix def='~' */
BYTE m_MyEolCh; /* End-Of-Line character def='\015' */
BYTE m_MyPadCh; /* Padding character def=0 */
BYTE m_MyCtlCh; /* Control character prefix def='#' */
int m_MyPadLen; /* How much padding def=0 */
int m_TimeOut; /* When I want to be timed out def=7 */
int m_PadLen; /* How much padding def=0 */
int m_WindMax; /* Window size def=1 */
int m_PktMax; /* Maximum Packet Size def=94 */
int m_Caps; /* 2=LP 8=Attr */
int m_ChkType; /* Block check type def=3 */
int m_ChkReq;
int m_RepOld;
int m_RepLen;
BOOL m_FileType;
int m_AttrFlag;
time_t m_FileTime;
int m_FileMode;
LONGLONG m_FileSize;
LONGLONG m_TranSize;
int m_PktPos;
int m_PktCnt;
struct KmtPkt {
int Type;
int Seq;
int Len;
BYTE Buf[KMT_PKTMAX];
} m_InPkt, *m_OutPkt;
int m_Size;
BYTE *m_pData;
CBuffer m_Work;
void OnProc(int cmd);
inline BYTE ToChar(int ch) { return (BYTE)(ch + '\040'); }
inline int UnChar(BYTE ch) { return (ch - '\040'); }
inline BYTE ToCtrl(int ch) { return (BYTE)(ch ^ 64); }
inline int IncSeq(int seq) { return ((seq + 1) & 63); }
void Init();
void DownLoad();
void UpLoad(BOOL ascii);
int ChkSumType1(BYTE *p, int len);
int ChkSumType2(BYTE *p, int len);
int ChkSumType3(BYTE *p, int len);
time_t TimeStamp(LPCSTR p);
int ReadPacket();
BOOL DecodePacket();
int SizePacket();
int MakePacket(int type, int seq, BYTE *buf, int len);
int PktPos(int pos);
void SendPacket(int pos);
void EncodeChar(int ch);
void EncodeInit();
void EncodeData(int ch);
void EncodeFinish();
void SendInit(int type);
void RecvInit(int type);
void SendAttr();
void RecvAttr();
void SendStr(int type, LPCSTR msg);
CKermit(class CRLoginDoc *pDoc, CWnd *pWnd);
virtual ~CKermit();
};
| [
"kmiya@gem.or.jp"
] | kmiya@gem.or.jp |
e45166cca6ea56306704c2c8ae7e65dc7c641643 | d49b8536d996a81fd2a356f2ccd850abd4447217 | /VirusPack/M0ldbot.small/sources/fphost.cpp | 05aabbdcab009c66923cd58507dac04564b279a0 | [] | no_license | JonnyBanana/botnets | 28a90ab80f973478d54579f3d3eadc5feb33ff77 | 995b9c20aca5de0ae585ae17780a31e8bdfd9844 | refs/heads/master | 2021-07-01T01:51:01.211451 | 2020-10-22T23:14:57 | 2020-10-22T23:14:57 | 148,392,362 | 9 | 5 | null | null | null | null | UTF-8 | C++ | false | false | 3,134 | cpp | #include "../includes/includes.h"
#include "../includes/functions.h"
#include "../includes/extern.h"
char rpcfp_bindstr1[]=
"\x05\x00\x0b\x03\x10\x00\x00\x00\x48\x00\x00\x00\x01\x00\x00\x00"
"\xd0\x16\xd0\x16\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x01\x00"
"\x80\xbd\xa8\xaf\x8a\x7d\xc9\x11\xbe\xf4\x08\x00\x2b\x10\x29\x89"
"\x01\x00\x00\x00\x04\x5d\x88\x8a\xeb\x1c\xc9\x11\x9f\xe8\x08\x00"
"\x2b\x10\x48\x60\x02\x00\x00\x00";
char rpcfp_inqifids1[]=
"\x05\x00\x00\x03\x10\x00\x00\x00\x18\x00\x00\x00\x01\x00\x00\x00"
"\x00\x00\x00\x00\x00\x00\x00\x00";
char w2kuuid_sig1[]=
"\xB0\x01\x52\x97\xCA\x59\xD0\x11\xA8\xD5\x00\xA0\xC9\x0D\x80\x51";
char wxpuuid_sig1[]=
"\x26\xB5\x55\x1D\x37\xC1\xC5\x46\xAB\x79\x63\x8F\x2A\x68\xE8\x69";
bool MemContains1(const char *pMem, const int iMemLen, const char *pSearch, const int iSearchLen)
{
for(int i=0;i<iMemLen-iSearchLen;i++)
if(!memcmp(pMem+i, pSearch, iSearchLen))
return true;
return false;
}
int FpHost(const char *szHost, int iFpType)
{
switch(iFpType) {
case FP_RPC:
{
char szRecvBuf[8192];
int iRetVal=OS_UNKNOWN;
int sSocket=fsocket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
if(sSocket==SOCKET_ERROR || sSocket==INVALID_SOCKET)
return OS_UNKNOWN;
SOCKADDR_IN ssin;
memset(&ssin, 0, sizeof(ssin));
ssin.sin_family=AF_INET;
ssin.sin_port=fhtons(135);
ssin.sin_addr.s_addr=ResolveAddress((char *)szHost);
int iErr=fconnect(sSocket, (LPSOCKADDR)&ssin, sizeof(ssin));
if(iErr!=SOCKET_ERROR) {
iErr=fsend(sSocket, rpcfp_bindstr1, sizeof(rpcfp_bindstr1)-1, 0);
if(iErr==SOCKET_ERROR) {
fclosesocket(sSocket);
return iRetVal;
}
iErr=frecv(sSocket, szRecvBuf, sizeof(szRecvBuf), 0);
if(iErr==SOCKET_ERROR) {
fclosesocket(sSocket);
return iRetVal;
}
if(szRecvBuf[2]==DCE_PKT_BINDACK) {
iErr=fsend(sSocket, rpcfp_inqifids1, sizeof(rpcfp_inqifids1)-1,0);
if(iErr==SOCKET_ERROR) {
fclosesocket(sSocket);
return iRetVal;
}
iErr=frecv(sSocket, szRecvBuf, sizeof(szRecvBuf),0);
if(iErr==SOCKET_ERROR) {
fclosesocket(sSocket);
return iRetVal;
}
if(szRecvBuf[2]==DCE_PKT_RESPONSE) {
if(MemContains1(szRecvBuf, iErr, w2kuuid_sig1, sizeof(w2kuuid_sig1)-1)) {
if(iErr<300)
iRetVal=OS_WINNT;
else
iRetVal=OS_WIN2K;
} else
if(MemContains1(szRecvBuf, iErr, wxpuuid_sig1, sizeof(wxpuuid_sig1)-1))
iRetVal=OS_WINXP;
else
iRetVal=OS_UNKNOWN;
} else {
fclosesocket(sSocket);
return iRetVal;
}
} else {
fclosesocket(sSocket);
return iRetVal;
}
} else {
fclosesocket(sSocket);
return iRetVal;
}
fclosesocket(sSocket);
return iRetVal;
}
break;
case FP_PORT5K:
if(AdvPortOpen(finet_addr(szHost), 5000, 3)) return OS_WINXP;
break;
case FP_TTL:
return OS_UNKNOWN;
break;
default:
return OS_UNKNOWN;
break;
}
return OS_UNKNOWN;
}
| [
"mstr.be832920@gmail.com"
] | mstr.be832920@gmail.com |
081a3acea5c2649394a01cd164b5817adc926dd1 | 9f3cbb11bc2c4fd98745e1bbe7e05c5172dcdcf1 | /deploy/ios_demo/ocr_demo/pdocr/ocr_db_post_process.cpp | 76d7cd4da81dcfaeffdca194a87633a7bb5c27e7 | [
"Apache-2.0"
] | permissive | jm12138/License_plate_recognition | 35283556d4c1bb0b8eef62159a0e68d153aedd76 | 8c2c9de8b209c6c65dbec0289ada21b8a69f091b | refs/heads/main | 2023-04-23T10:01:47.291175 | 2021-05-13T14:57:18 | 2021-05-13T14:57:18 | 305,663,631 | 34 | 4 | Apache-2.0 | 2021-03-09T02:43:39 | 2020-10-20T09:55:45 | C++ | UTF-8 | C++ | false | false | 11,319 | cpp | // Copyright (c) 2020 PaddlePaddle 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 <iostream>
#include <vector>
#include <math.h>
#include "opencv2/core.hpp"
#include "opencv2/imgcodecs.hpp"
#include "opencv2/imgproc.hpp"
#include "ocr_clipper.hpp"
static void getcontourarea(float **box, float unclip_ratio, float &distance) {
int pts_num = 4;
float area = 0.0f;
float dist = 0.0f;
for (int i = 0; i < pts_num; i++) {
area += box[i][0] * box[(i + 1) % pts_num][1] - box[i][1] * box[(i + 1) % pts_num][0];
dist += sqrtf(
(box[i][0] - box[(i + 1) % pts_num][0]) * (box[i][0] - box[(i + 1) % pts_num][0]) +
(box[i][1] - box[(i + 1) % pts_num][1]) * (box[i][1] - box[(i + 1) % pts_num][1]));
}
area = fabs(float(area / 2.0));
distance = area * unclip_ratio / dist;
}
static cv::RotatedRect unclip(float **box) {
float unclip_ratio = 2.0;
float distance = 1.0;
getcontourarea(box, unclip_ratio, distance);
ClipperLib::ClipperOffset offset;
ClipperLib::Path p;
p << ClipperLib::IntPoint(int(box[0][0]), int(box[0][1]))
<< ClipperLib::IntPoint(int(box[1][0]), int(box[1][1])) <<
ClipperLib::IntPoint(int(box[2][0]), int(box[2][1]))
<< ClipperLib::IntPoint(int(box[3][0]), int(box[3][1]));
offset.AddPath(p, ClipperLib::jtRound, ClipperLib::etClosedPolygon);
ClipperLib::Paths soln;
offset.Execute(soln, distance);
std::vector<cv::Point2f> points;
for (int j = 0; j < soln.size(); j++) {
for (int i = 0; i < soln[soln.size() - 1].size(); i++) {
points.emplace_back(soln[j][i].X, soln[j][i].Y);
}
}
cv::RotatedRect res = cv::minAreaRect(points);
return res;
}
static float **Mat2Vec(cv::Mat mat) {
auto **array = new float *[mat.rows];
for (int i = 0; i < mat.rows; ++i)
array[i] = new float[mat.cols];
for (int i = 0; i < mat.rows; ++i) {
for (int j = 0; j < mat.cols; ++j) {
array[i][j] = mat.at<float>(i, j);
}
}
return array;
}
static void quickSort(float **s, int l, int r) {
if (l < r) {
int i = l, j = r;
float x = s[l][0];
float *xp = s[l];
while (i < j) {
while (i < j && s[j][0] >= x)
j--;
if (i < j)
std::swap(s[i++], s[j]);
while (i < j && s[i][0] < x)
i++;
if (i < j)
std::swap(s[j--], s[i]);
}
s[i] = xp;
quickSort(s, l, i - 1);
quickSort(s, i + 1, r);
}
}
static void quickSort_vector(std::vector<std::vector<int>> &box, int l, int r, int axis) {
if (l < r) {
int i = l, j = r;
int x = box[l][axis];
std::vector<int> xp(box[l]);
while (i < j) {
while (i < j && box[j][axis] >= x)
j--;
if (i < j)
std::swap(box[i++], box[j]);
while (i < j && box[i][axis] < x)
i++;
if (i < j)
std::swap(box[j--], box[i]);
}
box[i] = xp;
quickSort_vector(box, l, i - 1, axis);
quickSort_vector(box, i + 1, r, axis);
}
}
static std::vector<std::vector<int>> order_points_clockwise(std::vector<std::vector<int>> pts) {
std::vector<std::vector<int>> box = pts;
quickSort_vector(box, 0, int(box.size() - 1), 0);
std::vector<std::vector<int>> leftmost = {box[0], box[1]};
std::vector<std::vector<int>> rightmost = {box[2], box[3]};
if (leftmost[0][1] > leftmost[1][1])
std::swap(leftmost[0], leftmost[1]);
if (rightmost[0][1] > rightmost[1][1])
std::swap(rightmost[0], rightmost[1]);
std::vector<std::vector<int>> rect = {leftmost[0], rightmost[0], rightmost[1], leftmost[1]};
return rect;
}
static float **get_mini_boxes(cv::RotatedRect box, float &ssid) {
ssid = box.size.width >= box.size.height ? box.size.height : box.size.width;
cv::Mat points;
cv::boxPoints(box, points);
// sorted box points
auto array = Mat2Vec(points);
quickSort(array, 0, 3);
float *idx1 = array[0], *idx2 = array[1], *idx3 = array[2], *idx4 = array[3];
if (array[3][1] <= array[2][1]) {
idx2 = array[3];
idx3 = array[2];
} else {
idx2 = array[2];
idx3 = array[3];
}
if (array[1][1] <= array[0][1]) {
idx1 = array[1];
idx4 = array[0];
} else {
idx1 = array[0];
idx4 = array[1];
}
array[0] = idx1;
array[1] = idx2;
array[2] = idx3;
array[3] = idx4;
return array;
}
template <class T> T clamp(T x, T min, T max) {
if (x > max){
return max;
}
if (x < min){
return min;
}
return x;
}
static float clampf(float x, float min, float max) {
if (x > max)
return max;
if (x < min)
return min;
return x;
}
float box_score_fast(float **box_array, cv::Mat pred) {
auto array = box_array;
int width = pred.cols;
int height = pred.rows;
float box_x[4] = {array[0][0], array[1][0], array[2][0], array[3][0]};
float box_y[4] = {array[0][1], array[1][1], array[2][1], array[3][1]};
int xmin = clamp(int(std::floorf(*(std::min_element(box_x, box_x + 4)))), 0, width - 1);
int xmax = clamp(int(std::ceilf(*(std::max_element(box_x, box_x + 4)))), 0, width - 1);
int ymin = clamp(int(std::floorf(*(std::min_element(box_y, box_y + 4)))), 0, height - 1);
int ymax = clamp(int(std::ceilf(*(std::max_element(box_y, box_y + 4)))), 0, height - 1);
cv::Mat mask;
mask = cv::Mat::zeros(ymax - ymin + 1, xmax - xmin + 1, CV_8UC1);
cv::Point root_point[4];
root_point[0] = cv::Point(int(array[0][0]) - xmin, int(array[0][1]) - ymin);
root_point[1] = cv::Point(int(array[1][0]) - xmin, int(array[1][1]) - ymin);
root_point[2] = cv::Point(int(array[2][0]) - xmin, int(array[2][1]) - ymin);
root_point[3] = cv::Point(int(array[3][0]) - xmin, int(array[3][1]) - ymin);
const cv::Point *ppt[1] = {root_point};
int npt[] = {4};
cv::fillPoly(mask, ppt, npt, 1, cv::Scalar(1));
cv::Mat croppedImg;
pred(cv::Rect(xmin, ymin, xmax - xmin + 1, ymax - ymin + 1)).copyTo(croppedImg);
auto score = cv::mean(croppedImg, mask)[0];
return score;
}
std::vector<std::vector<std::vector<int>>>
boxes_from_bitmap(const cv::Mat& pred, const cv::Mat& bitmap) {
const int min_size = 3;
const int max_candidates = 1000;
const float box_thresh = 0.5;
int width = bitmap.cols;
int height = bitmap.rows;
std::vector<std::vector<cv::Point>> contours;
std::vector<cv::Vec4i> hierarchy;
cv::findContours(bitmap, contours, hierarchy, cv::RETR_LIST, cv::CHAIN_APPROX_SIMPLE);
int num_contours = contours.size() >= max_candidates ? max_candidates : contours.size();
std::vector<std::vector<std::vector<int>>> boxes;
for (int _i = 0; _i < num_contours; _i++) {
float ssid;
cv::RotatedRect box = cv::minAreaRect(contours[_i]);
auto array = get_mini_boxes(box, ssid);
auto box_for_unclip = array;
//end get_mini_box
if (ssid < min_size) {
continue;
}
float score;
score = box_score_fast(array, pred);
//end box_score_fast
if (score < box_thresh)
continue;
// start for unclip
cv::RotatedRect points = unclip(box_for_unclip);
// end for unclip
cv::RotatedRect clipbox = points;
auto cliparray = get_mini_boxes(clipbox, ssid);
if (ssid < min_size + 2) continue;
int dest_width = pred.cols;
int dest_height = pred.rows;
std::vector<std::vector<int>> intcliparray;
for (int num_pt = 0; num_pt < 4; num_pt++) {
std::vector<int> a{
int(clampf(roundf(cliparray[num_pt][0] / float(width) * float(dest_width)), 0,
float(dest_width))),
int(clampf(roundf(cliparray[num_pt][1] / float(height) * float(dest_height)), 0,
float(dest_height)))};
intcliparray.push_back(a);
}
boxes.push_back(intcliparray);
}//end for
return boxes;
}
int _max(int a, int b) {
return a >= b ? a : b;
}
int _min(int a, int b) {
return a >= b ? b : a;
}
std::vector<std::vector<std::vector<int>>>
filter_tag_det_res(const std::vector<std::vector<std::vector<int>>>& o_boxes,
float ratio_h, float ratio_w,const cv::Mat& srcimg) {
int oriimg_h = srcimg.rows;
int oriimg_w = srcimg.cols;
std::vector<std::vector<std::vector<int>>> boxes{o_boxes};
std::vector<std::vector<std::vector<int>>> root_points;
for (int n = 0; n < boxes.size(); n++) {
boxes[n] = order_points_clockwise(boxes[n]);
for (int m = 0; m < boxes[0].size(); m++) {
boxes[n][m][0] /= ratio_w;
boxes[n][m][1] /= ratio_h;
boxes[n][m][0] = int(_min(_max(boxes[n][m][0], 0), oriimg_w - 1));
boxes[n][m][1] = int(_min(_max(boxes[n][m][1], 0), oriimg_h - 1));
}
}
for (int n = 0; n < boxes.size(); n++) {
int rect_width, rect_height;
rect_width = int(sqrt(
pow(boxes[n][0][0] - boxes[n][1][0], 2) + pow(boxes[n][0][1] - boxes[n][1][1], 2)));
rect_height = int(sqrt(
pow(boxes[n][0][0] - boxes[n][3][0], 2) + pow(boxes[n][0][1] - boxes[n][3][1], 2)));
if (rect_width <= 10 || rect_height <= 10)
continue;
root_points.push_back(boxes[n]);
}
return root_points;
}
/*
using namespace std;
// read data from txt file
cv::Mat readtxt2(std::string path, int imgw, int imgh, int imgc) {
std::cout << "read data file from txt file! " << std::endl;
ifstream in(path);
string line;
int count = 0;
int i = 0, j = 0;
std::vector<float> img_mean = {0.485, 0.456, 0.406};
std::vector<float> img_std = {0.229, 0.224, 0.225};
float trainData[imgh][imgw*imgc];
while (getline(in, line)) {
stringstream ss(line);
double x;
while (ss >> x) {
// trainData[i][j] = float(x) * img_std[j % 3] + img_mean[j % 3];
trainData[i][j] = float(x);
j++;
}
i++;
j = 0;
}
cv::Mat pred_map(imgh, imgw*imgc, CV_32FC1, (float *) trainData);
cv::Mat reshape_img = pred_map.reshape(imgc, imgh);
return reshape_img;
}
*/
//using namespace std;
//
//void writetxt(vector<vector<float>> data, std::string save_path){
//
// ofstream fout(save_path);
//
// for (int i = 0; i < data.size(); i++) {
// for (int j=0; j< data[0].size(); j++){
// fout << data[i][j] << " ";
// }
// fout << endl;
// }
// fout << endl;
// fout.close();
//}
| [
"2286040843@qq.com"
] | 2286040843@qq.com |
8c298a488480fb6545a089c9491ef41a3fa7f652 | b22588340d7925b614a735bbbde1b351ad657ffc | /athena/LArCalorimeter/LArCalibUtils/LArCalibUtils/LArOFCAlg.h | 091b03504fef7dc791ed337782134c791e6bcb98 | [] | no_license | rushioda/PIXELVALID_athena | 90befe12042c1249cbb3655dde1428bb9b9a42ce | 22df23187ef85e9c3120122c8375ea0e7d8ea440 | refs/heads/master | 2020-12-14T22:01:15.365949 | 2020-01-19T03:59:35 | 2020-01-19T03:59:35 | 234,836,993 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 5,567 | h | //Dear emacs, this is -*- c++ -*-
/*
Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
*/
#ifndef LArOFCAlgorithm_H
#define LArOFCAlgorithm_H
#include <vector>
#include <string>
#include "LArRawConditions/LArWaveCumul.h"
#include "GaudiKernel/ToolHandle.h"
#include "LArElecCalib/ILArAutoCorrDecoderTool.h"
//#include "LArElecCalib/ILArPedestal.h"
#include "CaloIdentifier/CaloGain.h"
#include "LArRawConditions/LArCaliWaveContainer.h"
#include "LArRawConditions/LArPhysWaveContainer.h"
#include "LArRawConditions/LArOFCComplete.h"
#include "LArRawConditions/LArOFCBinComplete.h"
#include "LArRawConditions/LArShapeComplete.h"
#include "StoreGate/DataHandle.h"
#include "AthenaBaseComps/AthAlgorithm.h"
#include <Eigen/Dense>
#include "tbb/blocked_range.h"
class LArOnlineID;
class LArOnline_SuperCellID;
class CaloDetDescrManager_Base;
class LArDSPConfig;
class LArCablingBase;
#include "GaudiKernel/ToolHandle.h"
class LArOFCAlg:public AthAlgorithm {
public:
LArOFCAlg (const std::string& name, ISvcLocator* pSvcLocator);
StatusCode initialize();
StatusCode execute() {return StatusCode::SUCCESS;}
virtual StatusCode stop();
StatusCode finalize(){return StatusCode::SUCCESS;}
// Eigen::VectorXd getAmpCoef();
//Eigen::VectorXd getATauCoef();
private:
struct perChannelData_t {
//Input:
const LArWaveCumul* inputWave;
HWIdentifier chid;
unsigned gain;
//Output:
std::vector<std::vector<float> > ofc_a;
std::vector<std::vector<float> > ofc_b;
std::vector<std::vector<float> > ofcV2_a;
std::vector<std::vector<float> > ofcV2_b;
std::vector<std::vector<float> >shape;
std::vector<std::vector<float> >shapeDer;
float tstart;
float timeBinWidthOFC;
unsigned phasewMaxAt3;
bool faultyOFC;
bool shortWave;
perChannelData_t(const LArWaveCumul* wave, const HWIdentifier hi, const unsigned g) :
inputWave(wave), chid(hi), gain(g),tstart(0), timeBinWidthOFC(25./24), phasewMaxAt3(0), faultyOFC(false), shortWave(false) {};
};
std::vector<perChannelData_t> m_allChannelData;
void optFilt(const std::vector<float> &gWave_in, const std::vector<float> &gDerivWave_in, const Eigen::MatrixXd& autoCorrInv, //input variables
std::vector<float>& OFCa, std::vector<float>& OFCb // Output variables;
) const;
void optFiltDelta(const std::vector<float> &gWave_in, const std::vector<float> &gDerivWave_in, const Eigen::MatrixXd& autoCorrInv,
const Eigen::VectorXd& delta, //input variables
std::vector<float>& vecOFCa, std::vector<float>& vecOFCb // Output variables;
) const;
void process(perChannelData_t&) const;
bool verify(const HWIdentifier chid, const std::vector<float>& OFCa, const std::vector<float>& OFCb,
const std::vector<float>& Shape, const char* ofcversion, const unsigned phase) const;
void printOFCVec(const std::vector<float>& vec, MsgStream& mLog) const;
StatusCode initPhysWaveContainer();
StatusCode initCaliWaveContainer();
std::string m_dumpOFCfile ;
std::vector<std::string> m_keylist;
bool m_verify;
bool m_normalize;
bool m_timeShift;
int m_timeShiftByIndex ;
unsigned int m_nSamples;
unsigned int m_nPhases;
unsigned int m_dPhases; // number of samples between two neighboring phases (OFC sets)
unsigned int m_nDelays ;
unsigned int m_nPoints;
float m_addOffset;
ToolHandle<ILArAutoCorrDecoderTool> m_AutoCorrDecoder;
ToolHandle<ILArAutoCorrDecoderTool> m_AutoCorrDecoderV2;
LArCablingBase* m_cablingService;
const LArOnlineID_Base* m_onlineID;
const CaloDetDescrManager_Base* m_calo_dd_man;
const LArOFCBinComplete* m_larPhysWaveBin;
double m_errAmpl;
double m_errTime;
bool m_readCaliWave ;
bool m_fillShape ;
std::string m_ofcKey;
std::string m_ofcKeyV2;
std::string m_shapeKey;
bool m_storeMaxPhase;
std::string m_ofcBinKey;
// Grouping type
std::string m_groupingType;
std::string m_larPhysWaveBinKey;
int m_useDelta;
int m_useDeltaV2;
bool m_computeV2;
bool m_runThreaded;
bool m_readDSPConfig;
std::string m_DSPConfigFolder;
LArDSPConfig* m_DSPConfig;
bool m_forceShift;
Eigen::VectorXd getDelta(std::vector<float>& samples, const HWIdentifier chid, unsigned nSamples) const;
bool useDelta(const HWIdentifier chid, const int jobOFlag) const;
static const float m_fcal3Delta[5];
static const float m_fcal2Delta[5];
static const float m_fcal1Delta[5];
//Functor for processing with TBB
class Looper {
public:
Looper(std::vector<perChannelData_t>* p, const LArOFCAlg* a) : m_perChanData(p), m_ofcAlg(a) {};
void operator() (tbb::blocked_range<size_t>& r) const {
//std::cout << "TBB grainsize " << r.end() - r.begin() << std::endl;
for (size_t i=r.begin();i!=r.end();++i) {
m_ofcAlg->process(m_perChanData->at(i));
}
}
private:
std::vector<perChannelData_t>* m_perChanData;
const LArOFCAlg* m_ofcAlg;
};
// Running on cells or supercells?
bool m_isSC;
};
#endif
| [
"rushioda@lxplus754.cern.ch"
] | rushioda@lxplus754.cern.ch |
cee2d09a0ce74d37ac54f19ba298ebbc24296f27 | 995db27deb0a5378d7a769e245ae898a3f68b0ae | /лаб раб 1/Исходный код.cpp | 62c83dbfa02dd2f5fc8655add78665df30c98d19 | [] | no_license | irinaandreyuk/laba1 | 83a7285b9638029f86620b7bcb1f629288cf9369 | 5eba8031f1e2b6d7d1b032d5175000097406320d | refs/heads/master | 2021-01-13T09:09:23.461669 | 2016-09-24T03:57:59 | 2016-09-24T03:57:59 | 69,078,618 | 1 | 0 | null | null | null | null | WINDOWS-1251 | C++ | false | false | 1,498 | cpp | #include <iostream>
#include "Stack.h"
using namespace std;
int stack::size_lol = 6;
void main()
{
stack li;
li.Push(100);
li.Push(76);
li.Push(48);
li.Push(21);
li.Push(18);
li.Push(98);
li.Push(95);
li.print();
cout << "JJJJJJJ\n";
li.Pop();
li.Pop();
cout << "JJJJJJJ\n";
li.print();
li.~stack();
int max, min;
stack* g = stack::mass(stack::size_lol);//создание массива стеков
for (int i = 0; i < stack::size_lol; i++)//его вывод
{
cout << "Stack[" << i + 1 << "]\n";
g[i].print();
}
max = g[0].getHead();
min = g[0].getHead();
for (int i = 1; i < stack::size_lol; i++)//поиск наибольшей и наименьшй вершины стеков
{
if (min>g[i].getHead())
min = g[i].getHead();
if (max<g[i].getHead())
max = g[i].getHead();
}
cout << "Min Head = " << min << endl;//с нименьшей вершиной
for (int i = 0; i < stack::size_lol; i++)
{
if (min == g[i].getHead())
{
cout << "Stack [" << i + 1 << "]\n";
g[i].print();
}
}
cout << "Max Head = " << max << endl;// с наибольшей вершиной
for (int i = 0; i < stack::size_lol; i++)
{
if (max == g[i].getHead())
{
cout << "Stack [" << i + 1 << "]\n";
g[i].print();
}
}
cout << "Stack with otricateln element\n";//стеки с отрицательными элементами
for (int i = 0; i < stack::size_lol; i++)
{
if (g[i].is_otric())
{
cout << "Stack [" << i + 1 << "]\n";
}
}
} | [
"ira_andreyuk_98@mail.ru"
] | ira_andreyuk_98@mail.ru |
377f38b06ea56be99327d1b648d06d1bd449c291 | 23ac169cb634d10c683be90deb1938d1171b04cd | /04_Strings/07_toggle_case_function.cpp | f53dc59afd1212bc935a019d509570abc17f289b | [
"Apache-2.0"
] | permissive | krishna6431/Data-Structure-Algorithms-Implementation-Using_CPP | 4b260639e2f9512ef3b44a326667267d05a38a97 | 0eedb6fb8a395ff050ae37dc4b8c6470f5b47579 | refs/heads/master | 2022-11-04T22:04:40.577185 | 2020-07-02T10:32:27 | 2020-07-02T10:32:27 | 276,435,159 | 2 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 726 | cpp | //Data Structure Course
//All Codes Are Written by Krishna
//Strings
#include <iostream>
#include <string>
using namespace std;
string togglecase(string str)
{
for (int i = 0; i < str[i] != '\0'; i++)
{
if (str[i] == '\0')
{
continue;
}
if (str[i] >= 'a' && str[i] <= 120)
{
str[i] -= 32;
}
else
{
str[i] += 32;
}
}
return str;
}
int main()
{
#ifndef ONLINE_JUDGE
freopen("../input.txt", "r", stdin);
freopen("../output.txt", "w", stdout);
#endif
string name;
getline(cin, name);
string res = togglecase(name);
cout << res << endl;
}
| [
"noreply@github.com"
] | noreply@github.com |
58a4b4ae2e3003e4f13735b9f69895cb2c1788fb | 33f99c4b1c805e907412947702e9b82b67a743d7 | /policy/policy_moss.hpp | 3a2600e14f0b4168b2bcd89c680f7e3b38c4a7e2 | [
"MIT",
"LicenseRef-scancode-unknown-license-reference"
] | permissive | elmoose/banditlib | 0bfabb877effeddd4cde54a41f11840364ba2f39 | 64c37e74e63ed062afad72180f4e981866cdceb4 | refs/heads/master | 2022-04-01T01:55:08.738637 | 2019-12-10T22:53:53 | 2019-12-10T22:53:53 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 854 | hpp | #pragma once
#include "policy.hpp"
namespace bandit{
class MOSSPolicy : public Policy{
const uint K;
std::vector<int> Ni;
std::vector<double> Gi;
public:
MOSSPolicy(uint K): K(K) {
reset();
}
void reset(){
Ni = std::vector<int>(K, 0);
Gi = std::vector<double>(K, 0.0);
}
virtual int selectNextArm(){
double n = vectorSum(Ni);
std::vector<double> indices = std::vector<double>(K, 0.0);
for(uint k=0;k<K;++k){
if(Ni[k]==0){
return k;
}
indices[k] = (Gi[k]/Ni[k]) + sqrt( std::max<double>( log(n/(K*Ni[k])) , 0.0) / (double)Ni[k] );
}
int targetArm = vectorMaxIndex(indices);
return targetArm;
}
virtual void updateState(int k, double r){
Ni[k]+=1;
Gi[k]+=r;
}
virtual std::string toString(){
std::string str="MOSS";
return str;
}
};
} //namespace
| [
"junpeikomiyama@gmail.com"
] | junpeikomiyama@gmail.com |
36050e9387cae96da0a5f3ee8b8b694d148ff8ff | 75b5226d2f9b00a332fc427bfea73cb336fc3286 | /src/sbg_simu.cpp | d0f6a4a02010cbca32bde4870f49e34641c17f6c | [
"MIT"
] | permissive | SBG-Systems/sbg_ros_simu | 7cf18fab637de5b285307d99ab86748c1e7482f1 | 7cfbfd09c4ecd4997070e65d953829c566d80511 | refs/heads/main | 2023-08-25T02:14:47.499744 | 2021-10-13T15:04:42 | 2021-10-13T15:04:42 | 416,765,654 | 0 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 11,889 | cpp | // File header
#include "sbg_simu.h"
// Standard headers
#include <iomanip>
#include <fstream>
#include <ctime>
// Boost headers
#include <boost/lexical_cast.hpp>
#include <boost/regex.hpp>
#include <boost/thread/xtime.hpp>
#include <boost/date_time/local_time/local_time.hpp>
// SbgECom headers
#include <version/sbgVersion.h>
// ROS headers
#include <ros/ros.h>
#include <sensor_msgs/Imu.h>
#include <sensor_msgs/NavSatFix.h>
using namespace std;
using sbg::SbgSimu;
//---------------------------------------------------------------------//
//- Constructor -//
//---------------------------------------------------------------------//
SbgSimu::SbgSimu(ros::NodeHandle& ref_node_handle):
m_ref_node_(ref_node_handle)
{
connect();
}
SbgSimu::~SbgSimu(void)
{
SbgErrorCode error_code;
error_code = sbgEComClose(&m_com_handle_);
if (error_code != SBG_NO_ERROR)
{
ROS_ERROR("Unable to close the SBG communication handle - %s.", sbgErrorCodeToString(error_code));
}
error_code = sbgInterfaceSerialDestroy(&m_sbg_interface_);
if (error_code != SBG_NO_ERROR)
{
ROS_ERROR("SBG_SIMU - Unable to close the communication interface.");
}
}
//---------------------------------------------------------------------//
//- Private methods -//
//---------------------------------------------------------------------//
SbgErrorCode SbgSimu::sendDeviceInfo(SbgEComHandle *pHandle)
{
SbgErrorCode error_code;
SbgStreamBuffer streamBuf;
uint8_t buf[sizeof(SbgEComDeviceInfo)];
error_code = sbgStreamBufferInitForWrite(&streamBuf, &buf, sizeof(SbgEComDeviceInfo));
if (error_code == SBG_NO_ERROR)
{
SbgEComDeviceInfo deviceInfo;
error_code = sbgStreamBufferWriteBuffer(&streamBuf, "sbg_simu", SBG_ECOM_INFO_PRODUCT_CODE_LENGTH);
if (error_code == SBG_NO_ERROR)
{
deviceInfo.serialNumber = 1007;
deviceInfo.calibationRev = 1;
deviceInfo.calibrationYear = 2021;
deviceInfo.calibrationMonth = 10;
deviceInfo.calibrationDay = 1;
deviceInfo.hardwareRev = 1;
deviceInfo.firmwareRev = 1;
sbgStreamBufferWriteUint32LE(&streamBuf, deviceInfo.serialNumber);
sbgStreamBufferWriteUint32LE(&streamBuf, deviceInfo.calibationRev);
sbgStreamBufferWriteUint16LE(&streamBuf, deviceInfo.calibrationYear);
sbgStreamBufferWriteUint8LE (&streamBuf, deviceInfo.calibrationMonth);
sbgStreamBufferWriteUint8LE (&streamBuf, deviceInfo.calibrationDay);
sbgStreamBufferWriteUint32LE(&streamBuf, deviceInfo.hardwareRev);
sbgStreamBufferWriteUint32LE(&streamBuf, deviceInfo.firmwareRev);
error_code = sbgStreamBufferGetLastError(&streamBuf);
if (error_code == SBG_NO_ERROR)
{
size_t receivedSize;
uint8_t receivedBuffer[SBG_ECOM_MAX_BUFFER_SIZE];
uint32_t time_out_ms = 10*1000;
/*
* Wait for Driver command.
*/
error_code = sbgEComReceiveCmd(pHandle, SBG_ECOM_CLASS_LOG_CMD_0, SBG_ECOM_CMD_INFO, receivedBuffer, &receivedSize, sizeof(receivedBuffer), time_out_ms);
if (error_code == SBG_NO_ERROR)
{
error_code = sbgEComProtocolSend(&pHandle->protocolHandle, SBG_ECOM_CLASS_LOG_CMD_0, SBG_ECOM_CMD_INFO, buf, SBG_ARRAY_SIZE(buf));
}
}
}
}
return error_code;
}
void SbgSimu::connect(void)
{
SbgErrorCode error_code;
sbgIpAddress ip = sbgNetworkIpFromString("127.0.0.1");
uint32_t portIn = 6666;
uint32_t portOut = 6667;
//
// Initialize the communication interface.
//
error_code = sbgInterfaceUdpCreate(&m_sbg_interface_, ip, portIn, portOut);
if (error_code != SBG_NO_ERROR)
{
throw ros::Exception("SBG_SIMU - [Init] Unable to initialize the interface - " + std::string(sbgErrorCodeToString(error_code)));
}
//
// Initialize the sbgECom protocol.
//
error_code = sbgEComInit(&m_com_handle_, &m_sbg_interface_);
if (error_code != SBG_NO_ERROR)
{
throw ros::Exception("SBG_SIMU - [Init] Unable to initialize the SbgECom protocol - " + std::string(sbgErrorCodeToString(error_code)));
}
error_code = sendDeviceInfo(&m_com_handle_);
if (error_code != SBG_NO_ERROR)
{
throw ros::Exception("SBG_SIMU - [Init] Unable to write device info - " + std::string(sbgErrorCodeToString(error_code)));
}
ROS_WARN("SBG_SIMU - UDP: %d.%d.%d.%d in:%d out:%u", sbgIpAddrGetA(ip), sbgIpAddrGetB(ip), sbgIpAddrGetC(ip), sbgIpAddrGetD(ip), portIn, portOut);
}
SbgErrorCode SbgSimu::navDataToStream(SbgLogEkfNavData *pNavData, SbgStreamBuffer *pOutputStream)
{
assert(pNavData);
sbgStreamBufferWriteUint32LE(pOutputStream, pNavData->timeStamp);
for (unsigned i = 0; i < SBG_ARRAY_SIZE(pNavData->velocity); i++)
{
sbgStreamBufferWriteFloatLE(pOutputStream, pNavData->velocity[i]);
}
for (unsigned i = 0; i < SBG_ARRAY_SIZE(pNavData->velocityStdDev); i++)
{
sbgStreamBufferWriteFloatLE(pOutputStream, pNavData->velocityStdDev[i]);
}
sbgStreamBufferWriteDoubleLE(pOutputStream, pNavData->position[0]);
sbgStreamBufferWriteDoubleLE(pOutputStream, pNavData->position[1]);
sbgStreamBufferWriteDoubleLE(pOutputStream, pNavData->position[2]);
sbgStreamBufferWriteFloatLE(pOutputStream, pNavData->undulation);
for (unsigned i = 0; i < SBG_ARRAY_SIZE(pNavData->positionStdDev); i++)
{
sbgStreamBufferWriteFloatLE(pOutputStream, pNavData->positionStdDev[i]);
}
sbgStreamBufferWriteUint32LE(pOutputStream, pNavData->status);
return sbgStreamBufferGetLastError(pOutputStream);
}
SbgErrorCode SbgSimu::imuDataToStream(SbgLogImuData *pImuData, SbgStreamBuffer *pOutputStream)
{
assert(pImuData);
sbgStreamBufferWriteUint32LE(pOutputStream, pImuData->timeStamp);
sbgStreamBufferWriteUint16LE(pOutputStream, pImuData->status);
for (unsigned i = 0; i < SBG_ARRAY_SIZE(pImuData->accelerometers); i++)
{
sbgStreamBufferWriteFloatLE(pOutputStream, pImuData->accelerometers[i]);
}
for (unsigned i = 0; i < SBG_ARRAY_SIZE(pImuData->gyroscopes); i++)
{
sbgStreamBufferWriteFloatLE(pOutputStream, pImuData->gyroscopes[i]);
}
sbgStreamBufferWriteFloatLE(pOutputStream, pImuData->temperature);
for (unsigned i = 0; i < SBG_ARRAY_SIZE(pImuData->deltaVelocity); i++)
{
sbgStreamBufferWriteFloatLE(pOutputStream, pImuData->deltaVelocity[i]);
}
for (unsigned i = 0; i < SBG_ARRAY_SIZE(pImuData->deltaAngle); i++)
{
sbgStreamBufferWriteFloatLE(pOutputStream, pImuData->deltaAngle[i]);
}
return sbgStreamBufferGetLastError(pOutputStream);
}
SbgErrorCode SbgSimu::quatDataToStream(SbgLogEkfQuatData *pQuatData, SbgStreamBuffer *pOutputStream)
{
assert(pQuatData);
sbgStreamBufferWriteUint32LE(pOutputStream, pQuatData->timeStamp);
for (unsigned i = 0; i < SBG_ARRAY_SIZE(pQuatData->quaternion); i++)
{
sbgStreamBufferWriteFloatLE(pOutputStream, pQuatData->quaternion[i]);
}
for (unsigned i = 0; i < SBG_ARRAY_SIZE(pQuatData->eulerStdDev); i++)
{
sbgStreamBufferWriteFloatLE(pOutputStream, pQuatData->eulerStdDev[i]);
}
sbgStreamBufferWriteUint32LE(pOutputStream, pQuatData->status);
return sbgStreamBufferGetLastError(pOutputStream);
}
//---------------------------------------------------------------------//
//- Public methods -//
//---------------------------------------------------------------------//
// http://docs.ros.org/en/api/sensor_msgs/html/msg/Imu.html
void SbgSimu::imuCallback(const sensor_msgs::Imu &msg)
{
SbgErrorCode error_code;
SbgLogImuData imuData;
SbgLogEkfQuatData quatData;
uint8_t outputBuffer[SBG_ECOM_MAX_BUFFER_SIZE];
SbgStreamBuffer outputStream;
memset(&imuData, 0x0, sizeof(imuData));
memset(&quatData, 0x0, sizeof(quatData));
this->m_last_imu_time_ = ros::Time::now();
imuData.timeStamp = this->m_last_imu_time_.toNSec() / 1000;
imuData.status = SBG_ECOM_IMU_COM_OK | SBG_ECOM_IMU_STATUS_BIT | SBG_ECOM_IMU_ACCEL_X_BIT | SBG_ECOM_IMU_ACCEL_Y_BIT | SBG_ECOM_IMU_ACCEL_Z_BIT | SBG_ECOM_IMU_GYRO_X_BIT | SBG_ECOM_IMU_GYRO_Y_BIT | SBG_ECOM_IMU_GYRO_Z_BIT | SBG_ECOM_IMU_ACCELS_IN_RANGE | SBG_ECOM_IMU_GYROS_IN_RANGE;
imuData.temperature = 20;
/*
* Convert from ENU (/imu) to NED (SBG device).
*/
imuData.accelerometers[0] = msg.linear_acceleration.x;
imuData.accelerometers[1] = -msg.linear_acceleration.y;
imuData.accelerometers[2] = -msg.linear_acceleration.z;
// imuData.gyroscopes[0] = msg.;
// imuData.gyroscopes[1] = -msg.;
// imuData.gyroscopes[2] = -msg.;
//
// imuData.deltaVelocity[0] = msg.;
// imuData.deltaVelocity[1] = -msg.;
// imuData.deltaVelocity[2] = -msg.;
//
// imuData.deltaAngle[0] = msg.;
// imuData.deltaAngle[1] = -msg.;
// imuData.deltaAngle[2] = -msg.;
quatData.timeStamp = this->m_last_imu_time_.toNSec() / 1000;
quatData.status = SBG_ECOM_SOL_MODE_NAV_POSITION | SBG_ECOM_SOL_ATTITUDE_VALID;
quatData.quaternion[0] = msg.orientation.w;
quatData.quaternion[1] = msg.orientation.x;
quatData.quaternion[2] = msg.orientation.y;
quatData.quaternion[3] = msg.orientation.z;
// quatData.eulerStdDev[3];
sbgStreamBufferInitForWrite(&outputStream, outputBuffer, sizeof(outputBuffer));
error_code = imuDataToStream(&imuData, &outputStream);
if (error_code == SBG_NO_ERROR)
{
error_code = sbgEComProtocolSend(&this->m_com_handle_.protocolHandle, SBG_ECOM_CLASS_LOG_ECOM_0, SBG_ECOM_LOG_IMU_DATA, &imuData, sizeof(imuData));
if (error_code == SBG_NO_ERROR)
{
sbgStreamBufferInitForWrite(&outputStream, outputBuffer, sizeof(outputBuffer));
error_code = quatDataToStream(&quatData, &outputStream);
if (error_code == SBG_NO_ERROR)
{
error_code = sbgEComProtocolSend(&this->m_com_handle_.protocolHandle, SBG_ECOM_CLASS_LOG_ECOM_0, SBG_ECOM_LOG_EKF_QUAT, &quatData, sizeof(quatData));
if (error_code != SBG_NO_ERROR)
{
ROS_WARN("SBG_SIMU - EKF send error 0x%x (%s)", error_code, sbgErrorCodeToString(error_code));
}
}
else
{
ROS_WARN("SBG_SIMU - EKF stream error 0x%x (%s)", error_code, sbgErrorCodeToString(error_code));
}
}
else
{
ROS_WARN("SBG_SIMU - IMU send error 0x%x (%s)", error_code, sbgErrorCodeToString(error_code));
}
}
else
{
ROS_WARN("SBG_SIMU - IMU stream error 0x%x (%s)", error_code, sbgErrorCodeToString(error_code));
}
}
// http://docs.ros.org/en/api/sensor_msgs/html/msg/NavSatFix.html
void SbgSimu::gpsCallback(const sensor_msgs::NavSatFix &msg)
{
SbgErrorCode error_code;
SbgLogEkfNavData navData;
uint8_t outputBuffer[SBG_ECOM_MAX_BUFFER_SIZE];
SbgStreamBuffer outputStream;
memset(&navData, 0x0, sizeof(navData));
navData.timeStamp = this->m_last_imu_time_.toNSec() / 1000;
// navData.velocity[3]; /*!< North, East, Down velocity in m.s^-1. */
// navData.velocityStdDev[3]; /*!< North, East, Down velocity 1 sigma standard deviation in m.s^-1. */
navData.position[0] = msg.latitude;
navData.position[1] = msg.longitude;
navData.position[2] = msg.altitude;
// navData.undulation; /*!< Altitude difference between the geoid and the Ellipsoid in meters (Height above Ellipsoid = altitude + undulation). */
// navData.positionStdDev[3]; /*!< Latitude, longitude and altitude 1 sigma standard deviation in meters. */
navData.status = SBG_ECOM_SOL_MODE_NAV_POSITION | SBG_ECOM_SOL_POSITION_VALID;
sbgStreamBufferInitForWrite(&outputStream, outputBuffer, sizeof(outputBuffer));
error_code = navDataToStream(&navData, &outputStream);
if (error_code == SBG_NO_ERROR)
{
error_code = sbgEComProtocolSend(&this->m_com_handle_.protocolHandle, SBG_ECOM_CLASS_LOG_ECOM_0, SBG_ECOM_LOG_EKF_NAV, sbgStreamBufferGetLinkedBuffer(&outputStream), sbgStreamBufferGetLength(&outputStream));
if (error_code != SBG_NO_ERROR)
{
ROS_WARN("SBG_SIMU - GPS send error 0x%x (%s)", error_code, sbgErrorCodeToString(error_code));
}
}
else
{
ROS_WARN("SBG_SIMU - streambuffer error 0x%x (%s)", error_code, sbgErrorCodeToString(error_code));
}
}
| [
"michael.zemb@sbg-systems.com"
] | michael.zemb@sbg-systems.com |
d9ab2028840ebe7df1f205fe939fc42a95d72865 | c84e6b34d901dea1ffffa6a6a66d39bc34077b06 | /include/filtering/filter_max.hpp | e165d02b53c8de7b9336332341cf0a8e1d72272f | [] | no_license | ecarpita93/HPC_projet_1 | 9b4960650a4fa61ab3fa4d6184b784cb2e62fee4 | a2c00e056c03227711c43cf2ad23d75c6afbe698 | refs/heads/master | 2022-10-12T09:31:24.567005 | 2020-06-07T21:35:37 | 2020-06-07T21:35:37 | 270,436,773 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,494 | hpp | /*
PICCANTE
The hottest HDR imaging library!
http://vcg.isti.cnr.it/piccante
Copyright (C) 2014
Visual Computing Laboratory - ISTI CNR
http://vcg.isti.cnr.it
First author: Francesco Banterle
This Source Code Form is subject to the terms of the Mozilla Public
License, v. 2.0. If a copy of the MPL was not distributed with this
file, You can obtain one at http://mozilla.org/MPL/2.0/.
*/
#ifndef PIC_FILTERING_FILTER_MAX_HPP
#define PIC_FILTERING_FILTER_MAX_HPP
#include "../filtering/filter.hpp"
namespace pic {
/**
* @brief The FilterMax class
*/
class FilterMax: public Filter
{
protected:
int halfSize;
/**
* @brief ProcessBBox
* @param dst
* @param src
* @param box
*/
void ProcessBBox(Image *dst, ImageVec src, BBox *box)
{
int channels = dst->channels;
float *maxVal = new float[channels];
for(int j = box->y0; j < box->y1; j++) {
for(int i = box->x0; i < box->x1; i++) {
float *dst_data = (*dst)(i, j);
float *src_data = (*src[0])(i, j);
for(int k = 0; k < channels; k++) {
maxVal[k] = src_data[k];
}
for(int k = -halfSize; k <= halfSize; k++) {
for(int l = -halfSize; l <= halfSize; l++) {
src_data = (*src[0])(i + l, j + k);
for(int ch = 0; ch < channels; ch++) {
maxVal[ch] = maxVal[ch] > src_data[ch] ?
maxVal[ch] : src_data[ch];
}
}
}
for(int k = 0; k < channels; k++) {
dst_data[k] = maxVal[k];
}
}
}
delete[] maxVal;
}
public:
/**
* @brief FilterMax
* @param size
*/
FilterMax(int size) : Filter()
{
update(size);
}
~FilterMax()
{
release();
}
/**
* @brief update
* @param size
*/
void update(int size)
{
this->halfSize = checkHalfSize(size);
}
/**
* @brief execute
* @param imgIn
* @param imgOut
* @param size
* @return
*/
static Image *execute(Image *imgIn, Image *imgOut, int size)
{
FilterMax filter(size);
return filter.Process(Single(imgIn), imgOut);
}
};
} // end namespace pic
#endif /* PIC_FILTERING_FILTER_MAX_HPP */
| [
"ecarpita93@outlook.com"
] | ecarpita93@outlook.com |
94ff42924f7846550d810942dec35426b4f1bb55 | 2a9d6adc51d29e7a2573e3471c7b4d37860c9625 | /openmp/.svn/pristine/94/94ff42924f7846550d810942dec35426b4f1bb55.svn-base | af80de1dafb442e1e9e9a9e8b12f12a3f1d5a8c6 | [
"MIT",
"Apache-2.0",
"LLVM-exception",
"NCSA",
"LicenseRef-scancode-arm-llvm-sga",
"LicenseRef-scancode-generic-cla"
] | permissive | Ravbug/AMD-TrueAudioNext-Complete | 73f8639199c571a526fe03d550fabda78972d0bf | 238d33447c999e588016c2df71e3f14d18eb7657 | refs/heads/master | 2023-02-23T14:24:16.183491 | 2021-01-27T01:11:54 | 2021-01-27T01:11:54 | 333,009,466 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 53,987 | //===------ omptarget.cpp - Target independent OpenMP target RTL -- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
//
// Implementation of the interface to be used by Clang during the codegen of a
// target region.
//
//===----------------------------------------------------------------------===//
#include "device.h"
#include "private.h"
#include "rtl.h"
#include <cassert>
#include <vector>
/* All begin addresses for partially mapped structs must be 8-aligned in order
* to ensure proper alignment of members. E.g.
*
* struct S {
* int a; // 4-aligned
* int b; // 4-aligned
* int *p; // 8-aligned
* } s1;
* ...
* #pragma omp target map(tofrom: s1.b, s1.p[0:N])
* {
* s1.b = 5;
* for (int i...) s1.p[i] = ...;
* }
*
* Here we are mapping s1 starting from member b, so BaseAddress=&s1=&s1.a and
* BeginAddress=&s1.b. Let's assume that the struct begins at address 0x100,
* then &s1.a=0x100, &s1.b=0x104, &s1.p=0x108. Each member obeys the alignment
* requirements for its type. Now, when we allocate memory on the device, in
* CUDA's case cuMemAlloc() returns an address which is at least 256-aligned.
* This means that the chunk of the struct on the device will start at a
* 256-aligned address, let's say 0x200. Then the address of b will be 0x200 and
* address of p will be a misaligned 0x204 (on the host there was no need to add
* padding between b and p, so p comes exactly 4 bytes after b). If the device
* kernel tries to access s1.p, a misaligned address error occurs (as reported
* by the CUDA plugin). By padding the begin address down to a multiple of 8 and
* extending the size of the allocated chuck accordingly, the chuck on the
* device will start at 0x200 with the padding (4 bytes), then &s1.b=0x204 and
* &s1.p=0x208, as they should be to satisfy the alignment requirements.
*/
static const int64_t Alignment = 8;
/// Map global data and execute pending ctors
static int InitLibrary(DeviceTy &Device) {
/*
* Map global data
*/
int32_t device_id = Device.DeviceID;
int rc = OFFLOAD_SUCCESS;
Device.PendingGlobalsMtx.lock();
PM->TrlTblMtx.lock();
for (HostEntriesBeginToTransTableTy::iterator entry_it =
PM->HostEntriesBeginToTransTable.begin();
entry_it != PM->HostEntriesBeginToTransTable.end(); ++entry_it) {
TranslationTable *TransTable = &entry_it->second;
if (TransTable->HostTable.EntriesBegin ==
TransTable->HostTable.EntriesEnd) {
// No host entry so no need to proceed
continue;
}
if (TransTable->TargetsTable[device_id] != 0) {
// Library entries have already been processed
continue;
}
// 1) get image.
assert(TransTable->TargetsImages.size() > (size_t)device_id &&
"Not expecting a device ID outside the table's bounds!");
__tgt_device_image *img = TransTable->TargetsImages[device_id];
if (!img) {
REPORT("No image loaded for device id %d.\n", device_id);
rc = OFFLOAD_FAIL;
break;
}
// 2) load image into the target table.
__tgt_target_table *TargetTable = TransTable->TargetsTable[device_id] =
Device.load_binary(img);
// Unable to get table for this image: invalidate image and fail.
if (!TargetTable) {
REPORT("Unable to generate entries table for device id %d.\n", device_id);
TransTable->TargetsImages[device_id] = 0;
rc = OFFLOAD_FAIL;
break;
}
// Verify whether the two table sizes match.
size_t hsize =
TransTable->HostTable.EntriesEnd - TransTable->HostTable.EntriesBegin;
size_t tsize = TargetTable->EntriesEnd - TargetTable->EntriesBegin;
// Invalid image for these host entries!
if (hsize != tsize) {
REPORT("Host and Target tables mismatch for device id %d [%zx != %zx].\n",
device_id, hsize, tsize);
TransTable->TargetsImages[device_id] = 0;
TransTable->TargetsTable[device_id] = 0;
rc = OFFLOAD_FAIL;
break;
}
// process global data that needs to be mapped.
Device.DataMapMtx.lock();
__tgt_target_table *HostTable = &TransTable->HostTable;
for (__tgt_offload_entry *CurrDeviceEntry = TargetTable->EntriesBegin,
*CurrHostEntry = HostTable->EntriesBegin,
*EntryDeviceEnd = TargetTable->EntriesEnd;
CurrDeviceEntry != EntryDeviceEnd;
CurrDeviceEntry++, CurrHostEntry++) {
if (CurrDeviceEntry->size != 0) {
// has data.
assert(CurrDeviceEntry->size == CurrHostEntry->size &&
"data size mismatch");
// Fortran may use multiple weak declarations for the same symbol,
// therefore we must allow for multiple weak symbols to be loaded from
// the fat binary. Treat these mappings as any other "regular" mapping.
// Add entry to map.
if (Device.getTgtPtrBegin(CurrHostEntry->addr, CurrHostEntry->size))
continue;
DP("Add mapping from host " DPxMOD " to device " DPxMOD " with size %zu"
"\n",
DPxPTR(CurrHostEntry->addr), DPxPTR(CurrDeviceEntry->addr),
CurrDeviceEntry->size);
Device.HostDataToTargetMap.emplace(
(uintptr_t)CurrHostEntry->addr /*HstPtrBase*/,
(uintptr_t)CurrHostEntry->addr /*HstPtrBegin*/,
(uintptr_t)CurrHostEntry->addr + CurrHostEntry->size /*HstPtrEnd*/,
(uintptr_t)CurrDeviceEntry->addr /*TgtPtrBegin*/, nullptr,
true /*IsRefCountINF*/);
}
}
Device.DataMapMtx.unlock();
}
PM->TrlTblMtx.unlock();
if (rc != OFFLOAD_SUCCESS) {
Device.PendingGlobalsMtx.unlock();
return rc;
}
/*
* Run ctors for static objects
*/
if (!Device.PendingCtorsDtors.empty()) {
// Call all ctors for all libraries registered so far
for (auto &lib : Device.PendingCtorsDtors) {
if (!lib.second.PendingCtors.empty()) {
DP("Has pending ctors... call now\n");
for (auto &entry : lib.second.PendingCtors) {
void *ctor = entry;
int rc =
target(nullptr, device_id, ctor, 0, nullptr, nullptr, nullptr,
nullptr, nullptr, nullptr, 1, 1, true /*team*/);
if (rc != OFFLOAD_SUCCESS) {
REPORT("Running ctor " DPxMOD " failed.\n", DPxPTR(ctor));
Device.PendingGlobalsMtx.unlock();
return OFFLOAD_FAIL;
}
}
// Clear the list to indicate that this device has been used
lib.second.PendingCtors.clear();
DP("Done with pending ctors for lib " DPxMOD "\n", DPxPTR(lib.first));
}
}
}
Device.HasPendingGlobals = false;
Device.PendingGlobalsMtx.unlock();
return OFFLOAD_SUCCESS;
}
// Check whether a device has been initialized, global ctors have been
// executed and global data has been mapped; do so if not already done.
int CheckDeviceAndCtors(int64_t device_id) {
// Is device ready?
if (!device_is_ready(device_id)) {
REPORT("Device %" PRId64 " is not ready.\n", device_id);
return OFFLOAD_FAIL;
}
// Get device info.
DeviceTy &Device = PM->Devices[device_id];
// Check whether global data has been mapped for this device
Device.PendingGlobalsMtx.lock();
bool hasPendingGlobals = Device.HasPendingGlobals;
Device.PendingGlobalsMtx.unlock();
if (hasPendingGlobals && InitLibrary(Device) != OFFLOAD_SUCCESS) {
REPORT("Failed to init globals on device %" PRId64 "\n", device_id);
return OFFLOAD_FAIL;
}
return OFFLOAD_SUCCESS;
}
static int32_t getParentIndex(int64_t type) {
return ((type & OMP_TGT_MAPTYPE_MEMBER_OF) >> 48) - 1;
}
/// Call the user-defined mapper function followed by the appropriate
// targetData* function (targetData{Begin,End,Update}).
int targetDataMapper(ident_t *loc, DeviceTy &Device, void *arg_base, void *arg,
int64_t arg_size, int64_t arg_type,
map_var_info_t arg_names, void *arg_mapper,
TargetDataFuncPtrTy target_data_function) {
TIMESCOPE_WITH_IDENT(loc);
DP("Calling the mapper function " DPxMOD "\n", DPxPTR(arg_mapper));
// The mapper function fills up Components.
MapperComponentsTy MapperComponents;
MapperFuncPtrTy MapperFuncPtr = (MapperFuncPtrTy)(arg_mapper);
(*MapperFuncPtr)((void *)&MapperComponents, arg_base, arg, arg_size, arg_type,
arg_names);
// Construct new arrays for args_base, args, arg_sizes and arg_types
// using the information in MapperComponents and call the corresponding
// targetData* function using these new arrays.
std::vector<void *> MapperArgsBase(MapperComponents.Components.size());
std::vector<void *> MapperArgs(MapperComponents.Components.size());
std::vector<int64_t> MapperArgSizes(MapperComponents.Components.size());
std::vector<int64_t> MapperArgTypes(MapperComponents.Components.size());
std::vector<void *> MapperArgNames(MapperComponents.Components.size());
for (unsigned I = 0, E = MapperComponents.Components.size(); I < E; ++I) {
auto &C =
MapperComponents
.Components[target_data_function == targetDataEnd ? I : E - I - 1];
MapperArgsBase[I] = C.Base;
MapperArgs[I] = C.Begin;
MapperArgSizes[I] = C.Size;
MapperArgTypes[I] = C.Type;
MapperArgNames[I] = C.Name;
}
int rc = target_data_function(loc, Device, MapperComponents.Components.size(),
MapperArgsBase.data(), MapperArgs.data(),
MapperArgSizes.data(), MapperArgTypes.data(),
MapperArgNames.data(), /*arg_mappers*/ nullptr,
/*__tgt_async_info*/ nullptr);
return rc;
}
/// Internal function to do the mapping and transfer the data to the device
int targetDataBegin(ident_t *loc, DeviceTy &Device, int32_t arg_num,
void **args_base, void **args, int64_t *arg_sizes,
int64_t *arg_types, map_var_info_t *arg_names,
void **arg_mappers, __tgt_async_info *async_info_ptr) {
// process each input.
for (int32_t i = 0; i < arg_num; ++i) {
// Ignore private variables and arrays - there is no mapping for them.
if ((arg_types[i] & OMP_TGT_MAPTYPE_LITERAL) ||
(arg_types[i] & OMP_TGT_MAPTYPE_PRIVATE))
continue;
if (arg_mappers && arg_mappers[i]) {
// Instead of executing the regular path of targetDataBegin, call the
// targetDataMapper variant which will call targetDataBegin again
// with new arguments.
DP("Calling targetDataMapper for the %dth argument\n", i);
map_var_info_t arg_name = (!arg_names) ? nullptr : arg_names[i];
int rc = targetDataMapper(loc, Device, args_base[i], args[i], arg_sizes[i],
arg_types[i], arg_name, arg_mappers[i],
targetDataBegin);
if (rc != OFFLOAD_SUCCESS) {
REPORT("Call to targetDataBegin via targetDataMapper for custom mapper"
" failed.\n");
return OFFLOAD_FAIL;
}
// Skip the rest of this function, continue to the next argument.
continue;
}
void *HstPtrBegin = args[i];
void *HstPtrBase = args_base[i];
int64_t data_size = arg_sizes[i];
map_var_info_t HstPtrName = (!arg_names) ? nullptr : arg_names[i];
// Adjust for proper alignment if this is a combined entry (for structs).
// Look at the next argument - if that is MEMBER_OF this one, then this one
// is a combined entry.
int64_t padding = 0;
const int next_i = i + 1;
if (getParentIndex(arg_types[i]) < 0 && next_i < arg_num &&
getParentIndex(arg_types[next_i]) == i) {
padding = (int64_t)HstPtrBegin % Alignment;
if (padding) {
DP("Using a padding of %" PRId64 " bytes for begin address " DPxMOD
"\n",
padding, DPxPTR(HstPtrBegin));
HstPtrBegin = (char *)HstPtrBegin - padding;
data_size += padding;
}
}
// Address of pointer on the host and device, respectively.
void *Pointer_HstPtrBegin, *PointerTgtPtrBegin;
bool IsNew, Pointer_IsNew;
bool IsHostPtr = false;
bool IsImplicit = arg_types[i] & OMP_TGT_MAPTYPE_IMPLICIT;
// Force the creation of a device side copy of the data when:
// a close map modifier was associated with a map that contained a to.
bool HasCloseModifier = arg_types[i] & OMP_TGT_MAPTYPE_CLOSE;
bool HasPresentModifier = arg_types[i] & OMP_TGT_MAPTYPE_PRESENT;
// UpdateRef is based on MEMBER_OF instead of TARGET_PARAM because if we
// have reached this point via __tgt_target_data_begin and not __tgt_target
// then no argument is marked as TARGET_PARAM ("omp target data map" is not
// associated with a target region, so there are no target parameters). This
// may be considered a hack, we could revise the scheme in the future.
bool UpdateRef = !(arg_types[i] & OMP_TGT_MAPTYPE_MEMBER_OF);
if (arg_types[i] & OMP_TGT_MAPTYPE_PTR_AND_OBJ) {
DP("Has a pointer entry: \n");
// Base is address of pointer.
//
// Usually, the pointer is already allocated by this time. For example:
//
// #pragma omp target map(s.p[0:N])
//
// The map entry for s comes first, and the PTR_AND_OBJ entry comes
// afterward, so the pointer is already allocated by the time the
// PTR_AND_OBJ entry is handled below, and PointerTgtPtrBegin is thus
// non-null. However, "declare target link" can produce a PTR_AND_OBJ
// entry for a global that might not already be allocated by the time the
// PTR_AND_OBJ entry is handled below, and so the allocation might fail
// when HasPresentModifier.
PointerTgtPtrBegin = Device.getOrAllocTgtPtr(
HstPtrBase, HstPtrBase, sizeof(void *), nullptr, Pointer_IsNew,
IsHostPtr, IsImplicit, UpdateRef, HasCloseModifier,
HasPresentModifier);
if (!PointerTgtPtrBegin) {
REPORT("Call to getOrAllocTgtPtr returned null pointer (%s).\n",
HasPresentModifier ? "'present' map type modifier"
: "device failure or illegal mapping");
return OFFLOAD_FAIL;
}
DP("There are %zu bytes allocated at target address " DPxMOD " - is%s new"
"\n",
sizeof(void *), DPxPTR(PointerTgtPtrBegin),
(Pointer_IsNew ? "" : " not"));
Pointer_HstPtrBegin = HstPtrBase;
// modify current entry.
HstPtrBase = *(void **)HstPtrBase;
UpdateRef = true; // subsequently update ref count of pointee
}
void *TgtPtrBegin = Device.getOrAllocTgtPtr(
HstPtrBegin, HstPtrBase, data_size, HstPtrName, IsNew, IsHostPtr,
IsImplicit, UpdateRef, HasCloseModifier, HasPresentModifier);
// If data_size==0, then the argument could be a zero-length pointer to
// NULL, so getOrAlloc() returning NULL is not an error.
if (!TgtPtrBegin && (data_size || HasPresentModifier)) {
REPORT("Call to getOrAllocTgtPtr returned null pointer (%s).\n",
HasPresentModifier ? "'present' map type modifier"
: "device failure or illegal mapping");
return OFFLOAD_FAIL;
}
DP("There are %" PRId64 " bytes allocated at target address " DPxMOD
" - is%s new\n",
data_size, DPxPTR(TgtPtrBegin), (IsNew ? "" : " not"));
if (arg_types[i] & OMP_TGT_MAPTYPE_RETURN_PARAM) {
uintptr_t Delta = (uintptr_t)HstPtrBegin - (uintptr_t)HstPtrBase;
void *TgtPtrBase = (void *)((uintptr_t)TgtPtrBegin - Delta);
DP("Returning device pointer " DPxMOD "\n", DPxPTR(TgtPtrBase));
args_base[i] = TgtPtrBase;
}
if (arg_types[i] & OMP_TGT_MAPTYPE_TO) {
bool copy = false;
if (!(PM->RTLs.RequiresFlags & OMP_REQ_UNIFIED_SHARED_MEMORY) ||
HasCloseModifier) {
if (IsNew || (arg_types[i] & OMP_TGT_MAPTYPE_ALWAYS)) {
copy = true;
} else if ((arg_types[i] & OMP_TGT_MAPTYPE_MEMBER_OF) &&
!(arg_types[i] & OMP_TGT_MAPTYPE_PTR_AND_OBJ)) {
// Copy data only if the "parent" struct has RefCount==1.
// If this is a PTR_AND_OBJ entry, the OBJ is not part of the struct,
// so exclude it from this check.
int32_t parent_idx = getParentIndex(arg_types[i]);
uint64_t parent_rc = Device.getMapEntryRefCnt(args[parent_idx]);
assert(parent_rc > 0 && "parent struct not found");
if (parent_rc == 1) {
copy = true;
}
}
}
if (copy && !IsHostPtr) {
DP("Moving %" PRId64 " bytes (hst:" DPxMOD ") -> (tgt:" DPxMOD ")\n",
data_size, DPxPTR(HstPtrBegin), DPxPTR(TgtPtrBegin));
int rt = Device.submitData(TgtPtrBegin, HstPtrBegin, data_size,
async_info_ptr);
if (rt != OFFLOAD_SUCCESS) {
REPORT("Copying data to device failed.\n");
return OFFLOAD_FAIL;
}
}
}
if (arg_types[i] & OMP_TGT_MAPTYPE_PTR_AND_OBJ && !IsHostPtr) {
DP("Update pointer (" DPxMOD ") -> [" DPxMOD "]\n",
DPxPTR(PointerTgtPtrBegin), DPxPTR(TgtPtrBegin));
uint64_t Delta = (uint64_t)HstPtrBegin - (uint64_t)HstPtrBase;
void *TgtPtrBase = (void *)((uint64_t)TgtPtrBegin - Delta);
int rt = Device.submitData(PointerTgtPtrBegin, &TgtPtrBase,
sizeof(void *), async_info_ptr);
if (rt != OFFLOAD_SUCCESS) {
REPORT("Copying data to device failed.\n");
return OFFLOAD_FAIL;
}
// create shadow pointers for this entry
Device.ShadowMtx.lock();
Device.ShadowPtrMap[Pointer_HstPtrBegin] = {
HstPtrBase, PointerTgtPtrBegin, TgtPtrBase};
Device.ShadowMtx.unlock();
}
}
return OFFLOAD_SUCCESS;
}
namespace {
/// This structure contains information to deallocate a target pointer, aka.
/// used to call the function \p DeviceTy::deallocTgtPtr.
struct DeallocTgtPtrInfo {
/// Host pointer used to look up into the map table
void *HstPtrBegin;
/// Size of the data
int64_t DataSize;
/// Whether it is forced to be removed from the map table
bool ForceDelete;
/// Whether it has \p close modifier
bool HasCloseModifier;
DeallocTgtPtrInfo(void *HstPtr, int64_t Size, bool ForceDelete,
bool HasCloseModifier)
: HstPtrBegin(HstPtr), DataSize(Size), ForceDelete(ForceDelete),
HasCloseModifier(HasCloseModifier) {}
};
} // namespace
/// Internal function to undo the mapping and retrieve the data from the device.
int targetDataEnd(ident_t *loc, DeviceTy &Device, int32_t ArgNum,
void **ArgBases, void **Args, int64_t *ArgSizes,
int64_t *ArgTypes, map_var_info_t *ArgNames,
void **ArgMappers, __tgt_async_info *AsyncInfo) {
int Ret;
std::vector<DeallocTgtPtrInfo> DeallocTgtPtrs;
// process each input.
for (int32_t I = ArgNum - 1; I >= 0; --I) {
// Ignore private variables and arrays - there is no mapping for them.
// Also, ignore the use_device_ptr directive, it has no effect here.
if ((ArgTypes[I] & OMP_TGT_MAPTYPE_LITERAL) ||
(ArgTypes[I] & OMP_TGT_MAPTYPE_PRIVATE))
continue;
if (ArgMappers && ArgMappers[I]) {
// Instead of executing the regular path of targetDataEnd, call the
// targetDataMapper variant which will call targetDataEnd again
// with new arguments.
DP("Calling targetDataMapper for the %dth argument\n", I);
map_var_info_t ArgName = (!ArgNames) ? nullptr : ArgNames[I];
Ret =
targetDataMapper(loc, Device, ArgBases[I], Args[I], ArgSizes[I],
ArgTypes[I], ArgName, ArgMappers[I], targetDataEnd);
if (Ret != OFFLOAD_SUCCESS) {
REPORT("Call to targetDataEnd via targetDataMapper for custom mapper"
" failed.\n");
return OFFLOAD_FAIL;
}
// Skip the rest of this function, continue to the next argument.
continue;
}
void *HstPtrBegin = Args[I];
int64_t DataSize = ArgSizes[I];
// Adjust for proper alignment if this is a combined entry (for structs).
// Look at the next argument - if that is MEMBER_OF this one, then this one
// is a combined entry.
const int NextI = I + 1;
if (getParentIndex(ArgTypes[I]) < 0 && NextI < ArgNum &&
getParentIndex(ArgTypes[NextI]) == I) {
int64_t Padding = (int64_t)HstPtrBegin % Alignment;
if (Padding) {
DP("Using a Padding of %" PRId64 " bytes for begin address " DPxMOD
"\n",
Padding, DPxPTR(HstPtrBegin));
HstPtrBegin = (char *)HstPtrBegin - Padding;
DataSize += Padding;
}
}
bool IsLast, IsHostPtr;
bool IsImplicit = ArgTypes[I] & OMP_TGT_MAPTYPE_IMPLICIT;
bool UpdateRef = !(ArgTypes[I] & OMP_TGT_MAPTYPE_MEMBER_OF) ||
(ArgTypes[I] & OMP_TGT_MAPTYPE_PTR_AND_OBJ);
bool ForceDelete = ArgTypes[I] & OMP_TGT_MAPTYPE_DELETE;
bool HasCloseModifier = ArgTypes[I] & OMP_TGT_MAPTYPE_CLOSE;
bool HasPresentModifier = ArgTypes[I] & OMP_TGT_MAPTYPE_PRESENT;
// If PTR_AND_OBJ, HstPtrBegin is address of pointee
void *TgtPtrBegin = Device.getTgtPtrBegin(
HstPtrBegin, DataSize, IsLast, UpdateRef, IsHostPtr, !IsImplicit);
if (!TgtPtrBegin && (DataSize || HasPresentModifier)) {
DP("Mapping does not exist (%s)\n",
(HasPresentModifier ? "'present' map type modifier" : "ignored"));
if (HasPresentModifier) {
// This should be an error upon entering an "omp target exit data". It
// should not be an error upon exiting an "omp target data" or "omp
// target". For "omp target data", Clang thus doesn't include present
// modifiers for end calls. For "omp target", we have not found a valid
// OpenMP program for which the error matters: it appears that, if a
// program can guarantee that data is present at the beginning of an
// "omp target" region so that there's no error there, that data is also
// guaranteed to be present at the end.
MESSAGE("device mapping required by 'present' map type modifier does "
"not exist for host address " DPxMOD " (%" PRId64 " bytes)",
DPxPTR(HstPtrBegin), DataSize);
return OFFLOAD_FAIL;
}
} else {
DP("There are %" PRId64 " bytes allocated at target address " DPxMOD
" - is%s last\n",
DataSize, DPxPTR(TgtPtrBegin), (IsLast ? "" : " not"));
}
bool DelEntry = IsLast || ForceDelete;
if ((ArgTypes[I] & OMP_TGT_MAPTYPE_MEMBER_OF) &&
!(ArgTypes[I] & OMP_TGT_MAPTYPE_PTR_AND_OBJ)) {
DelEntry = false; // protect parent struct from being deallocated
}
if ((ArgTypes[I] & OMP_TGT_MAPTYPE_FROM) || DelEntry) {
// Move data back to the host
if (ArgTypes[I] & OMP_TGT_MAPTYPE_FROM) {
bool Always = ArgTypes[I] & OMP_TGT_MAPTYPE_ALWAYS;
bool CopyMember = false;
if (!(PM->RTLs.RequiresFlags & OMP_REQ_UNIFIED_SHARED_MEMORY) ||
HasCloseModifier) {
if ((ArgTypes[I] & OMP_TGT_MAPTYPE_MEMBER_OF) &&
!(ArgTypes[I] & OMP_TGT_MAPTYPE_PTR_AND_OBJ)) {
// Copy data only if the "parent" struct has RefCount==1.
int32_t ParentIdx = getParentIndex(ArgTypes[I]);
uint64_t ParentRC = Device.getMapEntryRefCnt(Args[ParentIdx]);
assert(ParentRC > 0 && "parent struct not found");
if (ParentRC == 1)
CopyMember = true;
}
}
if ((DelEntry || Always || CopyMember) &&
!(PM->RTLs.RequiresFlags & OMP_REQ_UNIFIED_SHARED_MEMORY &&
TgtPtrBegin == HstPtrBegin)) {
DP("Moving %" PRId64 " bytes (tgt:" DPxMOD ") -> (hst:" DPxMOD ")\n",
DataSize, DPxPTR(TgtPtrBegin), DPxPTR(HstPtrBegin));
Ret = Device.retrieveData(HstPtrBegin, TgtPtrBegin, DataSize,
AsyncInfo);
if (Ret != OFFLOAD_SUCCESS) {
REPORT("Copying data from device failed.\n");
return OFFLOAD_FAIL;
}
}
}
// If we copied back to the host a struct/array containing pointers, we
// need to restore the original host pointer values from their shadow
// copies. If the struct is going to be deallocated, remove any remaining
// shadow pointer entries for this struct.
uintptr_t LB = (uintptr_t)HstPtrBegin;
uintptr_t UB = (uintptr_t)HstPtrBegin + DataSize;
Device.ShadowMtx.lock();
for (ShadowPtrListTy::iterator Itr = Device.ShadowPtrMap.begin();
Itr != Device.ShadowPtrMap.end();) {
void **ShadowHstPtrAddr = (void **)Itr->first;
// An STL map is sorted on its keys; use this property
// to quickly determine when to break out of the loop.
if ((uintptr_t)ShadowHstPtrAddr < LB) {
++Itr;
continue;
}
if ((uintptr_t)ShadowHstPtrAddr >= UB)
break;
// If we copied the struct to the host, we need to restore the pointer.
if (ArgTypes[I] & OMP_TGT_MAPTYPE_FROM) {
DP("Restoring original host pointer value " DPxMOD " for host "
"pointer " DPxMOD "\n",
DPxPTR(Itr->second.HstPtrVal), DPxPTR(ShadowHstPtrAddr));
*ShadowHstPtrAddr = Itr->second.HstPtrVal;
}
// If the struct is to be deallocated, remove the shadow entry.
if (DelEntry) {
DP("Removing shadow pointer " DPxMOD "\n", DPxPTR(ShadowHstPtrAddr));
Itr = Device.ShadowPtrMap.erase(Itr);
} else {
++Itr;
}
}
Device.ShadowMtx.unlock();
// Add pointer to the buffer for later deallocation
if (DelEntry)
DeallocTgtPtrs.emplace_back(HstPtrBegin, DataSize, ForceDelete,
HasCloseModifier);
}
}
// We need to synchronize before deallocating data.
// If AsyncInfo is nullptr, the previous data transfer (if has) will be
// synchronous, so we don't need to synchronize again. If AsyncInfo->Queue is
// nullptr, there is no data transfer happened because once there is,
// AsyncInfo->Queue will not be nullptr, so again, we don't need to
// synchronize.
if (AsyncInfo && AsyncInfo->Queue) {
Ret = Device.synchronize(AsyncInfo);
if (Ret != OFFLOAD_SUCCESS) {
REPORT("Failed to synchronize device.\n");
return OFFLOAD_FAIL;
}
}
// Deallocate target pointer
for (DeallocTgtPtrInfo &Info : DeallocTgtPtrs) {
Ret = Device.deallocTgtPtr(Info.HstPtrBegin, Info.DataSize,
Info.ForceDelete, Info.HasCloseModifier);
if (Ret != OFFLOAD_SUCCESS) {
REPORT("Deallocating data from device failed.\n");
return OFFLOAD_FAIL;
}
}
return OFFLOAD_SUCCESS;
}
static int targetDataContiguous(ident_t *loc, DeviceTy &Device, void *ArgsBase,
void *HstPtrBegin, int64_t ArgSize,
int64_t ArgType) {
TIMESCOPE_WITH_IDENT(loc);
bool IsLast, IsHostPtr;
void *TgtPtrBegin = Device.getTgtPtrBegin(HstPtrBegin, ArgSize, IsLast, false,
IsHostPtr, /*MustContain=*/true);
if (!TgtPtrBegin) {
DP("hst data:" DPxMOD " not found, becomes a noop\n", DPxPTR(HstPtrBegin));
if (ArgType & OMP_TGT_MAPTYPE_PRESENT) {
MESSAGE("device mapping required by 'present' motion modifier does not "
"exist for host address " DPxMOD " (%" PRId64 " bytes)",
DPxPTR(HstPtrBegin), ArgSize);
return OFFLOAD_FAIL;
}
return OFFLOAD_SUCCESS;
}
if (PM->RTLs.RequiresFlags & OMP_REQ_UNIFIED_SHARED_MEMORY &&
TgtPtrBegin == HstPtrBegin) {
DP("hst data:" DPxMOD " unified and shared, becomes a noop\n",
DPxPTR(HstPtrBegin));
return OFFLOAD_SUCCESS;
}
if (ArgType & OMP_TGT_MAPTYPE_FROM) {
DP("Moving %" PRId64 " bytes (tgt:" DPxMOD ") -> (hst:" DPxMOD ")\n",
ArgSize, DPxPTR(TgtPtrBegin), DPxPTR(HstPtrBegin));
int Ret = Device.retrieveData(HstPtrBegin, TgtPtrBegin, ArgSize, nullptr);
if (Ret != OFFLOAD_SUCCESS) {
REPORT("Copying data from device failed.\n");
return OFFLOAD_FAIL;
}
uintptr_t LB = (uintptr_t)HstPtrBegin;
uintptr_t UB = (uintptr_t)HstPtrBegin + ArgSize;
Device.ShadowMtx.lock();
for (ShadowPtrListTy::iterator IT = Device.ShadowPtrMap.begin();
IT != Device.ShadowPtrMap.end(); ++IT) {
void **ShadowHstPtrAddr = (void **)IT->first;
if ((uintptr_t)ShadowHstPtrAddr < LB)
continue;
if ((uintptr_t)ShadowHstPtrAddr >= UB)
break;
DP("Restoring original host pointer value " DPxMOD
" for host pointer " DPxMOD "\n",
DPxPTR(IT->second.HstPtrVal), DPxPTR(ShadowHstPtrAddr));
*ShadowHstPtrAddr = IT->second.HstPtrVal;
}
Device.ShadowMtx.unlock();
}
if (ArgType & OMP_TGT_MAPTYPE_TO) {
DP("Moving %" PRId64 " bytes (hst:" DPxMOD ") -> (tgt:" DPxMOD ")\n",
ArgSize, DPxPTR(HstPtrBegin), DPxPTR(TgtPtrBegin));
int Ret = Device.submitData(TgtPtrBegin, HstPtrBegin, ArgSize, nullptr);
if (Ret != OFFLOAD_SUCCESS) {
REPORT("Copying data to device failed.\n");
return OFFLOAD_FAIL;
}
uintptr_t LB = (uintptr_t)HstPtrBegin;
uintptr_t UB = (uintptr_t)HstPtrBegin + ArgSize;
Device.ShadowMtx.lock();
for (ShadowPtrListTy::iterator IT = Device.ShadowPtrMap.begin();
IT != Device.ShadowPtrMap.end(); ++IT) {
void **ShadowHstPtrAddr = (void **)IT->first;
if ((uintptr_t)ShadowHstPtrAddr < LB)
continue;
if ((uintptr_t)ShadowHstPtrAddr >= UB)
break;
DP("Restoring original target pointer value " DPxMOD " for target "
"pointer " DPxMOD "\n",
DPxPTR(IT->second.TgtPtrVal), DPxPTR(IT->second.TgtPtrAddr));
Ret = Device.submitData(IT->second.TgtPtrAddr, &IT->second.TgtPtrVal,
sizeof(void *), nullptr);
if (Ret != OFFLOAD_SUCCESS) {
REPORT("Copying data to device failed.\n");
Device.ShadowMtx.unlock();
return OFFLOAD_FAIL;
}
}
Device.ShadowMtx.unlock();
}
return OFFLOAD_SUCCESS;
}
static int targetDataNonContiguous(ident_t *loc, DeviceTy &Device,
void *ArgsBase,
__tgt_target_non_contig *NonContig,
uint64_t Size, int64_t ArgType,
int CurrentDim, int DimSize,
uint64_t Offset) {
TIMESCOPE_WITH_IDENT(loc);
int Ret = OFFLOAD_SUCCESS;
if (CurrentDim < DimSize) {
for (unsigned int I = 0; I < NonContig[CurrentDim].Count; ++I) {
uint64_t CurOffset =
(NonContig[CurrentDim].Offset + I) * NonContig[CurrentDim].Stride;
// we only need to transfer the first element for the last dimension
// since we've already got a contiguous piece.
if (CurrentDim != DimSize - 1 || I == 0) {
Ret = targetDataNonContiguous(loc, Device, ArgsBase, NonContig, Size,
ArgType, CurrentDim + 1, DimSize,
Offset + CurOffset);
// Stop the whole process if any contiguous piece returns anything
// other than OFFLOAD_SUCCESS.
if (Ret != OFFLOAD_SUCCESS)
return Ret;
}
}
} else {
char *Ptr = (char *)ArgsBase + Offset;
DP("Transfer of non-contiguous : host ptr %lx offset %ld len %ld\n",
(uint64_t)Ptr, Offset, Size);
Ret = targetDataContiguous(loc, Device, ArgsBase, Ptr, Size, ArgType);
}
return Ret;
}
static int getNonContigMergedDimension(__tgt_target_non_contig *NonContig,
int32_t DimSize) {
int RemovedDim = 0;
for (int I = DimSize - 1; I > 0; --I) {
if (NonContig[I].Count * NonContig[I].Stride == NonContig[I - 1].Stride)
RemovedDim++;
}
return RemovedDim;
}
/// Internal function to pass data to/from the target.
// async_info_ptr is currently unused, added here so targetDataUpdate has the
// same signature as targetDataBegin and targetDataEnd.
int targetDataUpdate(ident_t *loc, DeviceTy &Device, int32_t ArgNum,
void **ArgsBase, void **Args, int64_t *ArgSizes,
int64_t *ArgTypes, map_var_info_t *ArgNames,
void **ArgMappers, __tgt_async_info *AsyncInfoPtr) {
// process each input.
for (int32_t I = 0; I < ArgNum; ++I) {
if ((ArgTypes[I] & OMP_TGT_MAPTYPE_LITERAL) ||
(ArgTypes[I] & OMP_TGT_MAPTYPE_PRIVATE))
continue;
if (ArgMappers && ArgMappers[I]) {
// Instead of executing the regular path of targetDataUpdate, call the
// targetDataMapper variant which will call targetDataUpdate again
// with new arguments.
DP("Calling targetDataMapper for the %dth argument\n", I);
map_var_info_t ArgName = (!ArgNames) ? nullptr : ArgNames[I];
int Ret = targetDataMapper(loc, Device, ArgsBase[I], Args[I], ArgSizes[I],
ArgTypes[I], ArgName, ArgMappers[I],
targetDataUpdate);
if (Ret != OFFLOAD_SUCCESS) {
REPORT("Call to targetDataUpdate via targetDataMapper for custom mapper"
" failed.\n");
return OFFLOAD_FAIL;
}
// Skip the rest of this function, continue to the next argument.
continue;
}
int Ret = OFFLOAD_SUCCESS;
if (ArgTypes[I] & OMP_TGT_MAPTYPE_NON_CONTIG) {
__tgt_target_non_contig *NonContig = (__tgt_target_non_contig *)Args[I];
int32_t DimSize = ArgSizes[I];
uint64_t Size =
NonContig[DimSize - 1].Count * NonContig[DimSize - 1].Stride;
int32_t MergedDim = getNonContigMergedDimension(NonContig, DimSize);
Ret = targetDataNonContiguous(
loc, Device, ArgsBase[I], NonContig, Size, ArgTypes[I],
/*current_dim=*/0, DimSize - MergedDim, /*offset=*/0);
} else {
Ret = targetDataContiguous(loc, Device, ArgsBase[I], Args[I], ArgSizes[I],
ArgTypes[I]);
}
if (Ret == OFFLOAD_FAIL)
return OFFLOAD_FAIL;
}
return OFFLOAD_SUCCESS;
}
static const unsigned LambdaMapping = OMP_TGT_MAPTYPE_PTR_AND_OBJ |
OMP_TGT_MAPTYPE_LITERAL |
OMP_TGT_MAPTYPE_IMPLICIT;
static bool isLambdaMapping(int64_t Mapping) {
return (Mapping & LambdaMapping) == LambdaMapping;
}
namespace {
/// Find the table information in the map or look it up in the translation
/// tables.
TableMap *getTableMap(void *HostPtr) {
std::lock_guard<std::mutex> TblMapLock(PM->TblMapMtx);
HostPtrToTableMapTy::iterator TableMapIt =
PM->HostPtrToTableMap.find(HostPtr);
if (TableMapIt != PM->HostPtrToTableMap.end())
return &TableMapIt->second;
// We don't have a map. So search all the registered libraries.
TableMap *TM = nullptr;
std::lock_guard<std::mutex> TrlTblLock(PM->TrlTblMtx);
for (HostEntriesBeginToTransTableTy::iterator Itr =
PM->HostEntriesBeginToTransTable.begin();
Itr != PM->HostEntriesBeginToTransTable.end(); ++Itr) {
// get the translation table (which contains all the good info).
TranslationTable *TransTable = &Itr->second;
// iterate over all the host table entries to see if we can locate the
// host_ptr.
__tgt_offload_entry *Cur = TransTable->HostTable.EntriesBegin;
for (uint32_t I = 0; Cur < TransTable->HostTable.EntriesEnd; ++Cur, ++I) {
if (Cur->addr != HostPtr)
continue;
// we got a match, now fill the HostPtrToTableMap so that we
// may avoid this search next time.
TM = &(PM->HostPtrToTableMap)[HostPtr];
TM->Table = TransTable;
TM->Index = I;
return TM;
}
}
return nullptr;
}
/// Get loop trip count
/// FIXME: This function will not work right if calling
/// __kmpc_push_target_tripcount in one thread but doing offloading in another
/// thread, which might occur when we call task yield.
uint64_t getLoopTripCount(int64_t DeviceId) {
DeviceTy &Device = PM->Devices[DeviceId];
uint64_t LoopTripCount = 0;
{
std::lock_guard<std::mutex> TblMapLock(PM->TblMapMtx);
auto I = Device.LoopTripCnt.find(__kmpc_global_thread_num(NULL));
if (I != Device.LoopTripCnt.end()) {
LoopTripCount = I->second;
Device.LoopTripCnt.erase(I);
DP("loop trip count is %lu.\n", LoopTripCount);
}
}
return LoopTripCount;
}
/// A class manages private arguments in a target region.
class PrivateArgumentManagerTy {
/// A data structure for the information of first-private arguments. We can
/// use this information to optimize data transfer by packing all
/// first-private arguments and transfer them all at once.
struct FirstPrivateArgInfoTy {
/// The index of the element in \p TgtArgs corresponding to the argument
const int Index;
/// Host pointer begin
const char *HstPtrBegin;
/// Host pointer end
const char *HstPtrEnd;
/// Aligned size
const int64_t AlignedSize;
/// Host pointer name
const map_var_info_t HstPtrName = nullptr;
FirstPrivateArgInfoTy(int Index, const void *HstPtr, int64_t Size,
const map_var_info_t HstPtrName = nullptr)
: Index(Index), HstPtrBegin(reinterpret_cast<const char *>(HstPtr)),
HstPtrEnd(HstPtrBegin + Size), AlignedSize(Size + Size % Alignment),
HstPtrName(HstPtrName) {}
};
/// A vector of target pointers for all private arguments
std::vector<void *> TgtPtrs;
/// A vector of information of all first-private arguments to be packed
std::vector<FirstPrivateArgInfoTy> FirstPrivateArgInfo;
/// Host buffer for all arguments to be packed
std::vector<char> FirstPrivateArgBuffer;
/// The total size of all arguments to be packed
int64_t FirstPrivateArgSize = 0;
/// A reference to the \p DeviceTy object
DeviceTy &Device;
/// A pointer to a \p __tgt_async_info object
__tgt_async_info *AsyncInfo;
// TODO: What would be the best value here? Should we make it configurable?
// If the size is larger than this threshold, we will allocate and transfer it
// immediately instead of packing it.
static constexpr const int64_t FirstPrivateArgSizeThreshold = 1024;
public:
/// Constructor
PrivateArgumentManagerTy(DeviceTy &Dev, __tgt_async_info *AsyncInfo)
: Device(Dev), AsyncInfo(AsyncInfo) {}
/// Add a private argument
int addArg(void *HstPtr, int64_t ArgSize, int64_t ArgOffset,
bool IsFirstPrivate, void *&TgtPtr, int TgtArgsIndex,
const map_var_info_t HstPtrName = nullptr) {
// If the argument is not first-private, or its size is greater than a
// predefined threshold, we will allocate memory and issue the transfer
// immediately.
if (ArgSize > FirstPrivateArgSizeThreshold || !IsFirstPrivate) {
TgtPtr = Device.allocData(ArgSize, HstPtr);
if (!TgtPtr) {
DP("Data allocation for %sprivate array " DPxMOD " failed.\n",
(IsFirstPrivate ? "first-" : ""), DPxPTR(HstPtr));
return OFFLOAD_FAIL;
}
#ifdef OMPTARGET_DEBUG
void *TgtPtrBase = (void *)((intptr_t)TgtPtr + ArgOffset);
DP("Allocated %" PRId64 " bytes of target memory at " DPxMOD
" for %sprivate array " DPxMOD " - pushing target argument " DPxMOD
"\n",
ArgSize, DPxPTR(TgtPtr), (IsFirstPrivate ? "first-" : ""),
DPxPTR(HstPtr), DPxPTR(TgtPtrBase));
#endif
// If first-private, copy data from host
if (IsFirstPrivate) {
int Ret = Device.submitData(TgtPtr, HstPtr, ArgSize, AsyncInfo);
if (Ret != OFFLOAD_SUCCESS) {
DP("Copying data to device failed, failed.\n");
return OFFLOAD_FAIL;
}
}
TgtPtrs.push_back(TgtPtr);
} else {
DP("Firstprivate array " DPxMOD " of size %" PRId64 " will be packed\n",
DPxPTR(HstPtr), ArgSize);
// When reach this point, the argument must meet all following
// requirements:
// 1. Its size does not exceed the threshold (see the comment for
// FirstPrivateArgSizeThreshold);
// 2. It must be first-private (needs to be mapped to target device).
// We will pack all this kind of arguments to transfer them all at once
// to reduce the number of data transfer. We will not take
// non-first-private arguments, aka. private arguments that doesn't need
// to be mapped to target device, into account because data allocation
// can be very efficient with memory manager.
// Placeholder value
TgtPtr = nullptr;
FirstPrivateArgInfo.emplace_back(TgtArgsIndex, HstPtr, ArgSize,
HstPtrName);
FirstPrivateArgSize += FirstPrivateArgInfo.back().AlignedSize;
}
return OFFLOAD_SUCCESS;
}
/// Pack first-private arguments, replace place holder pointers in \p TgtArgs,
/// and start the transfer.
int packAndTransfer(std::vector<void *> &TgtArgs) {
if (!FirstPrivateArgInfo.empty()) {
assert(FirstPrivateArgSize != 0 &&
"FirstPrivateArgSize is 0 but FirstPrivateArgInfo is empty");
FirstPrivateArgBuffer.resize(FirstPrivateArgSize, 0);
auto Itr = FirstPrivateArgBuffer.begin();
// Copy all host data to this buffer
for (FirstPrivateArgInfoTy &Info : FirstPrivateArgInfo) {
std::copy(Info.HstPtrBegin, Info.HstPtrEnd, Itr);
Itr = std::next(Itr, Info.AlignedSize);
}
// Allocate target memory
void *TgtPtr =
Device.allocData(FirstPrivateArgSize, FirstPrivateArgBuffer.data());
if (TgtPtr == nullptr) {
DP("Failed to allocate target memory for private arguments.\n");
return OFFLOAD_FAIL;
}
TgtPtrs.push_back(TgtPtr);
DP("Allocated %" PRId64 " bytes of target memory at " DPxMOD "\n",
FirstPrivateArgSize, DPxPTR(TgtPtr));
// Transfer data to target device
int Ret = Device.submitData(TgtPtr, FirstPrivateArgBuffer.data(),
FirstPrivateArgSize, AsyncInfo);
if (Ret != OFFLOAD_SUCCESS) {
DP("Failed to submit data of private arguments.\n");
return OFFLOAD_FAIL;
}
// Fill in all placeholder pointers
auto TP = reinterpret_cast<uintptr_t>(TgtPtr);
for (FirstPrivateArgInfoTy &Info : FirstPrivateArgInfo) {
void *&Ptr = TgtArgs[Info.Index];
assert(Ptr == nullptr && "Target pointer is already set by mistaken");
Ptr = reinterpret_cast<void *>(TP);
TP += Info.AlignedSize;
DP("Firstprivate array " DPxMOD " of size %" PRId64 " mapped to " DPxMOD
"\n",
DPxPTR(Info.HstPtrBegin), Info.HstPtrEnd - Info.HstPtrBegin,
DPxPTR(Ptr));
}
}
return OFFLOAD_SUCCESS;
}
/// Free all target memory allocated for private arguments
int free() {
for (void *P : TgtPtrs) {
int Ret = Device.deleteData(P);
if (Ret != OFFLOAD_SUCCESS) {
DP("Deallocation of (first-)private arrays failed.\n");
return OFFLOAD_FAIL;
}
}
TgtPtrs.clear();
return OFFLOAD_SUCCESS;
}
};
/// Process data before launching the kernel, including calling targetDataBegin
/// to map and transfer data to target device, transferring (first-)private
/// variables.
static int processDataBefore(ident_t *loc, int64_t DeviceId, void *HostPtr,
int32_t ArgNum, void **ArgBases, void **Args,
int64_t *ArgSizes, int64_t *ArgTypes,
map_var_info_t *ArgNames, void **ArgMappers,
std::vector<void *> &TgtArgs,
std::vector<ptrdiff_t> &TgtOffsets,
PrivateArgumentManagerTy &PrivateArgumentManager,
__tgt_async_info *AsyncInfo) {
TIMESCOPE_WITH_NAME_AND_IDENT("mappingBeforeTargetRegion", loc);
DeviceTy &Device = PM->Devices[DeviceId];
int Ret = targetDataBegin(loc, Device, ArgNum, ArgBases, Args, ArgSizes,
ArgTypes, ArgNames, ArgMappers, AsyncInfo);
if (Ret != OFFLOAD_SUCCESS) {
REPORT("Call to targetDataBegin failed, abort target.\n");
return OFFLOAD_FAIL;
}
// List of (first-)private arrays allocated for this target region
std::vector<int> TgtArgsPositions(ArgNum, -1);
for (int32_t I = 0; I < ArgNum; ++I) {
if (!(ArgTypes[I] & OMP_TGT_MAPTYPE_TARGET_PARAM)) {
// This is not a target parameter, do not push it into TgtArgs.
// Check for lambda mapping.
if (isLambdaMapping(ArgTypes[I])) {
assert((ArgTypes[I] & OMP_TGT_MAPTYPE_MEMBER_OF) &&
"PTR_AND_OBJ must be also MEMBER_OF.");
unsigned Idx = getParentIndex(ArgTypes[I]);
int TgtIdx = TgtArgsPositions[Idx];
assert(TgtIdx != -1 && "Base address must be translated already.");
// The parent lambda must be processed already and it must be the last
// in TgtArgs and TgtOffsets arrays.
void *HstPtrVal = Args[I];
void *HstPtrBegin = ArgBases[I];
void *HstPtrBase = Args[Idx];
bool IsLast, IsHostPtr; // unused.
void *TgtPtrBase =
(void *)((intptr_t)TgtArgs[TgtIdx] + TgtOffsets[TgtIdx]);
DP("Parent lambda base " DPxMOD "\n", DPxPTR(TgtPtrBase));
uint64_t Delta = (uint64_t)HstPtrBegin - (uint64_t)HstPtrBase;
void *TgtPtrBegin = (void *)((uintptr_t)TgtPtrBase + Delta);
void *PointerTgtPtrBegin = Device.getTgtPtrBegin(
HstPtrVal, ArgSizes[I], IsLast, false, IsHostPtr);
if (!PointerTgtPtrBegin) {
DP("No lambda captured variable mapped (" DPxMOD ") - ignored\n",
DPxPTR(HstPtrVal));
continue;
}
if (PM->RTLs.RequiresFlags & OMP_REQ_UNIFIED_SHARED_MEMORY &&
TgtPtrBegin == HstPtrBegin) {
DP("Unified memory is active, no need to map lambda captured"
"variable (" DPxMOD ")\n",
DPxPTR(HstPtrVal));
continue;
}
DP("Update lambda reference (" DPxMOD ") -> [" DPxMOD "]\n",
DPxPTR(PointerTgtPtrBegin), DPxPTR(TgtPtrBegin));
Ret = Device.submitData(TgtPtrBegin, &PointerTgtPtrBegin,
sizeof(void *), AsyncInfo);
if (Ret != OFFLOAD_SUCCESS) {
REPORT("Copying data to device failed.\n");
return OFFLOAD_FAIL;
}
}
continue;
}
void *HstPtrBegin = Args[I];
void *HstPtrBase = ArgBases[I];
void *TgtPtrBegin;
map_var_info_t HstPtrName = (!ArgNames) ? nullptr : ArgNames[I];
ptrdiff_t TgtBaseOffset;
bool IsLast, IsHostPtr; // unused.
if (ArgTypes[I] & OMP_TGT_MAPTYPE_LITERAL) {
DP("Forwarding first-private value " DPxMOD " to the target construct\n",
DPxPTR(HstPtrBase));
TgtPtrBegin = HstPtrBase;
TgtBaseOffset = 0;
} else if (ArgTypes[I] & OMP_TGT_MAPTYPE_PRIVATE) {
TgtBaseOffset = (intptr_t)HstPtrBase - (intptr_t)HstPtrBegin;
// Can be marked for optimization if the next argument(s) do(es) not
// depend on this one.
const bool IsFirstPrivate =
(I >= ArgNum - 1 || !(ArgTypes[I + 1] & OMP_TGT_MAPTYPE_MEMBER_OF));
Ret = PrivateArgumentManager.addArg(
HstPtrBegin, ArgSizes[I], TgtBaseOffset, IsFirstPrivate, TgtPtrBegin,
TgtArgs.size(), HstPtrName);
if (Ret != OFFLOAD_SUCCESS) {
REPORT("Failed to process %sprivate argument " DPxMOD "\n",
(IsFirstPrivate ? "first-" : ""), DPxPTR(HstPtrBegin));
return OFFLOAD_FAIL;
}
} else {
if (ArgTypes[I] & OMP_TGT_MAPTYPE_PTR_AND_OBJ)
HstPtrBase = *reinterpret_cast<void **>(HstPtrBase);
TgtPtrBegin = Device.getTgtPtrBegin(HstPtrBegin, ArgSizes[I], IsLast,
false, IsHostPtr);
TgtBaseOffset = (intptr_t)HstPtrBase - (intptr_t)HstPtrBegin;
#ifdef OMPTARGET_DEBUG
void *TgtPtrBase = (void *)((intptr_t)TgtPtrBegin + TgtBaseOffset);
DP("Obtained target argument " DPxMOD " from host pointer " DPxMOD "\n",
DPxPTR(TgtPtrBase), DPxPTR(HstPtrBegin));
#endif
}
TgtArgsPositions[I] = TgtArgs.size();
TgtArgs.push_back(TgtPtrBegin);
TgtOffsets.push_back(TgtBaseOffset);
}
assert(TgtArgs.size() == TgtOffsets.size() &&
"Size mismatch in arguments and offsets");
// Pack and transfer first-private arguments
Ret = PrivateArgumentManager.packAndTransfer(TgtArgs);
if (Ret != OFFLOAD_SUCCESS) {
DP("Failed to pack and transfer first private arguments\n");
return OFFLOAD_FAIL;
}
return OFFLOAD_SUCCESS;
}
/// Process data after launching the kernel, including transferring data back to
/// host if needed and deallocating target memory of (first-)private variables.
static int processDataAfter(ident_t *loc, int64_t DeviceId, void *HostPtr,
int32_t ArgNum, void **ArgBases, void **Args,
int64_t *ArgSizes, int64_t *ArgTypes,
map_var_info_t *ArgNames, void **ArgMappers,
PrivateArgumentManagerTy &PrivateArgumentManager,
__tgt_async_info *AsyncInfo) {
TIMESCOPE_WITH_NAME_AND_IDENT("mappingAfterTargetRegion", loc);
DeviceTy &Device = PM->Devices[DeviceId];
// Move data from device.
int Ret = targetDataEnd(loc, Device, ArgNum, ArgBases, Args, ArgSizes,
ArgTypes, ArgNames, ArgMappers, AsyncInfo);
if (Ret != OFFLOAD_SUCCESS) {
REPORT("Call to targetDataEnd failed, abort target.\n");
return OFFLOAD_FAIL;
}
// Free target memory for private arguments
Ret = PrivateArgumentManager.free();
if (Ret != OFFLOAD_SUCCESS) {
REPORT("Failed to deallocate target memory for private args\n");
return OFFLOAD_FAIL;
}
return OFFLOAD_SUCCESS;
}
} // namespace
/// performs the same actions as data_begin in case arg_num is
/// non-zero and initiates run of the offloaded region on the target platform;
/// if arg_num is non-zero after the region execution is done it also
/// performs the same action as data_update and data_end above. This function
/// returns 0 if it was able to transfer the execution to a target and an
/// integer different from zero otherwise.
int target(ident_t *loc, int64_t DeviceId, void *HostPtr, int32_t ArgNum,
void **ArgBases, void **Args, int64_t *ArgSizes, int64_t *ArgTypes,
map_var_info_t *ArgNames, void **ArgMappers, int32_t TeamNum,
int32_t ThreadLimit, int IsTeamConstruct) {
DeviceTy &Device = PM->Devices[DeviceId];
TableMap *TM = getTableMap(HostPtr);
// No map for this host pointer found!
if (!TM) {
REPORT("Host ptr " DPxMOD " does not have a matching target pointer.\n",
DPxPTR(HostPtr));
return OFFLOAD_FAIL;
}
// get target table.
__tgt_target_table *TargetTable = nullptr;
{
std::lock_guard<std::mutex> TrlTblLock(PM->TrlTblMtx);
assert(TM->Table->TargetsTable.size() > (size_t)DeviceId &&
"Not expecting a device ID outside the table's bounds!");
TargetTable = TM->Table->TargetsTable[DeviceId];
}
assert(TargetTable && "Global data has not been mapped\n");
__tgt_async_info AsyncInfo;
std::vector<void *> TgtArgs;
std::vector<ptrdiff_t> TgtOffsets;
PrivateArgumentManagerTy PrivateArgumentManager(Device, &AsyncInfo);
int Ret;
if (ArgNum) {
// Process data, such as data mapping, before launching the kernel
Ret = processDataBefore(loc, DeviceId, HostPtr, ArgNum, ArgBases, Args,
ArgSizes, ArgTypes, ArgNames, ArgMappers, TgtArgs,
TgtOffsets, PrivateArgumentManager, &AsyncInfo);
if (Ret != OFFLOAD_SUCCESS) {
REPORT("Failed to process data before launching the kernel.\n");
return OFFLOAD_FAIL;
}
}
// Get loop trip count
uint64_t LoopTripCount = getLoopTripCount(DeviceId);
// Launch device execution.
void *TgtEntryPtr = TargetTable->EntriesBegin[TM->Index].addr;
DP("Launching target execution %s with pointer " DPxMOD " (index=%d).\n",
TargetTable->EntriesBegin[TM->Index].name, DPxPTR(TgtEntryPtr), TM->Index);
{
TIMESCOPE_WITH_NAME_AND_IDENT(
IsTeamConstruct ? "runTargetTeamRegion" : "runTargetRegion", loc);
if (IsTeamConstruct)
Ret = Device.runTeamRegion(TgtEntryPtr, &TgtArgs[0], &TgtOffsets[0],
TgtArgs.size(), TeamNum, ThreadLimit,
LoopTripCount, &AsyncInfo);
else
Ret = Device.runRegion(TgtEntryPtr, &TgtArgs[0], &TgtOffsets[0],
TgtArgs.size(), &AsyncInfo);
}
if (Ret != OFFLOAD_SUCCESS) {
REPORT("Executing target region abort target.\n");
return OFFLOAD_FAIL;
}
if (ArgNum) {
// Transfer data back and deallocate target memory for (first-)private
// variables
Ret = processDataAfter(loc, DeviceId, HostPtr, ArgNum, ArgBases, Args,
ArgSizes, ArgTypes, ArgNames, ArgMappers,
PrivateArgumentManager, &AsyncInfo);
if (Ret != OFFLOAD_SUCCESS) {
REPORT("Failed to process data after launching the kernel.\n");
return OFFLOAD_FAIL;
}
}
return OFFLOAD_SUCCESS;
}
| [
"ravbuganimations@gmail.com"
] | ravbuganimations@gmail.com | |
25b5254f44263e971542243920b39a4281785706 | 82da0257863577580feafa0098df29df3ab2b6aa | /form/main_frame.h | f5c3cd17056a8a3833dace6da60c05bb50da90f6 | [] | no_license | ca2/app-simple | 0c9100d2a74b5fe41cb4e57f52f6bff2eb9db0f5 | e02530912edac7cbeb991b3cec738f50e624b810 | refs/heads/master | 2023-07-24T02:36:13.289195 | 2023-01-07T02:50:28 | 2023-01-07T02:50:28 | 98,308,270 | 1 | 0 | null | 2017-08-06T00:24:24 | 2017-07-25T13:19:27 | C++ | UTF-8 | C++ | false | false | 652 | h | #pragma once
namespace simple_form
{
class CLASS_DECL_APP_SIMPLE_FORM main_frame :
virtual public simple_main_frame
{
public:
bool m_bExplicitTranslucency;
main_frame();
virtual ~main_frame();
virtual void assert_valid() const override;
virtual void dump(dump_context & dumpcontext) const override;
//virtual ::user::e_translucency get_translucency(::user::style * pstyle) const override;
virtual ::experience::frame * experience_get_frame() override;
virtual bool has_pending_graphical_update() override;
};
} // namespace simple_form
| [
"camilo@ca2.email"
] | camilo@ca2.email |
73422e9172825fdf63f9908dac10b5117647dbe2 | 864626f2abd94f0c163475db7eb2675d2c032ebe | /src/LandIce/evaluators/LandIce_PressureMeltingEnthalpy.hpp | 62e65359ffe34ee4158b8340967c70bc93f6790e | [
"BSD-2-Clause"
] | permissive | mperego/Albany | e4237f36352d8f3af4c2eae18fccf06216afa82e | 308cf398d2df98cb8d4465108ed02da9b1fa0b85 | refs/heads/master | 2020-04-12T12:56:37.829708 | 2018-12-19T16:23:44 | 2018-12-19T16:23:44 | 162,507,066 | 0 | 0 | NOASSERTION | 2019-12-18T18:02:42 | 2018-12-20T00:49:19 | C++ | UTF-8 | C++ | false | false | 1,614 | hpp | /*
* LandIce_PressureMeltingEnthalpy.hpp
*
* Created on: Jun 6, 2016
* Author: abarone
*/
#ifndef LANDICE_PRESSUREMELTINGENTHALPY_HPP_
#define LANDICE_PRESSUREMELTINGENTHALPY_HPP_
#include "Phalanx_config.hpp"
#include "Phalanx_Evaluator_WithBaseImpl.hpp"
#include "Phalanx_Evaluator_Derived.hpp"
#include "Phalanx_MDField.hpp"
#include "Albany_Layouts.hpp"
namespace LandIce
{
/** \brief Pressure-melting enthalpy
This evaluator computes enthalpy of the ice at pressure-melting temperature Tm(p).
*/
template<typename EvalT, typename Traits, typename Type>
class PressureMeltingEnthalpy: public PHX::EvaluatorWithBaseImpl<Traits>,
public PHX::EvaluatorDerived<EvalT, Traits>
{
public:
PressureMeltingEnthalpy (const Teuchos::ParameterList& p,
const Teuchos::RCP<Albany::Layouts>& dl);
void postRegistrationSetup (typename Traits::SetupData d,
PHX::FieldManager<Traits>& fm);
void evaluateFields(typename Traits::EvalData d);
private:
typedef typename EvalT::ParamScalarT ParamScalarT;
// Input:
PHX::MDField<const Type,Cell,Node> meltingTemp; //[K]
PHX::MDField<const ParamScalarT,Cell,Node> surfaceTemp; //[K]
// Output:
PHX::MDField<Type,Cell,Node> enthalpyHs; //[MW s m^{-3}]
PHX::MDField<ParamScalarT,Cell,Node> surfaceEnthalpy; //[MW s m^{-3}]
int numNodes;
double c_i; //[J Kg^{-1} K^{-1}], Heat capacity of ice
double rho_i; //[kg m^{-3}]
double T0; //[K]
};
} // Namespace LandIce
#endif /* LandIce_PRESSUREMELTINGENTHALPY_HPP_ */
| [
"lbertag@sandia.gov"
] | lbertag@sandia.gov |
69f3c8e0e908c7b81c6ce9e70c6f0a998a3cc895 | d829ca7151fb26bbb0b8c3c41fbe7154f66d6444 | /CardG/RulesForm.cpp | 7913e5cdf48915385afd64503c5d3a3207a01866 | [] | no_license | DinuCristian/Card-G-Game | d363aa6854a301cf1efda80ab904c925b07145f1 | f06a16a5eb11a762f58f4a6ca5d60797d17073f8 | refs/heads/main | 2023-03-25T23:44:27.781692 | 2021-03-23T20:24:02 | 2021-03-23T20:24:02 | 350,824,779 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 12,732 | cpp | #include "RulesForm.h"
namespace CardG {
void RulesForm::displayRules()
{
System::ComponentModel::ComponentResourceManager^ resources = (gcnew System::ComponentModel::ComponentResourceManager(CardSelectionForm::typeid));
this->pictureBoxMinusCard->Image = (cli::safe_cast<System::Drawing::Image^>(resources->GetObject(this->gameEngine->getThemeColour() + "CardMinus1")));
this->pictureBoxPlusCard->Image = (cli::safe_cast<System::Drawing::Image^>(resources->GetObject(this->gameEngine->getThemeColour() + "CardPlus1")));
this->pictureBoxStealCard->Image = (cli::safe_cast<System::Drawing::Image^>(resources->GetObject(this->gameEngine->getThemeColour() + "CardSteal")));
this->pictureBoxDoubleCard->Image = (cli::safe_cast<System::Drawing::Image^>(resources->GetObject(this->gameEngine->getThemeColour() + "CardDouble")));
this->pictureBoxChangeCard->Image = (cli::safe_cast<System::Drawing::Image^>(resources->GetObject(this->gameEngine->getThemeColour() + "CardChange")));
// Description
this->richTextBoxDescription->SelectionColor = System::Drawing::Color::Black;
this->richTextBoxDescription->SelectionFont = gcnew System::Drawing::Font(this->richTextBoxCardMinus->Font, FontStyle::Bold);
this->richTextBoxDescription->SelectedText = "Description: ";
this->richTextBoxDescription->SelectionFont = gcnew System::Drawing::Font(this->richTextBoxCardMinus->Font, FontStyle::Regular);
this->richTextBoxDescription->SelectedText = "This is a turn-based card game that you can play against a virtual player (Neo). "
"It consists of two phases:" + Environment::NewLine;
this->richTextBoxDescription->SelectionColor = System::Drawing::Color::Black;
this->richTextBoxDescription->SelectionFont = gcnew System::Drawing::Font(this->richTextBoxCardMinus->Font, FontStyle::Bold);
this->richTextBoxDescription->SelectedText = " 1. Card selection. ";
this->richTextBoxDescription->SelectionColor = System::Drawing::Color::Black;
this->richTextBoxDescription->SelectionFont = gcnew System::Drawing::Font(this->richTextBoxCardMinus->Font, FontStyle::Regular);
this->richTextBoxDescription->SelectedText = "First, you select 5 cards from the card deck. "
"Then, the virtual player (Neo) selects 5 cards from the deck." + Environment::NewLine;
this->richTextBoxDescription->SelectionColor = System::Drawing::Color::Black;
this->richTextBoxDescription->SelectionFont = gcnew System::Drawing::Font(this->richTextBoxCardMinus->Font, FontStyle::Bold);
this->richTextBoxDescription->SelectedText = " 2. Game play. ";
this->richTextBoxDescription->SelectionColor = System::Drawing::Color::Black;
this->richTextBoxDescription->SelectionFont = gcnew System::Drawing::Font(this->richTextBoxCardMinus->Font, FontStyle::Regular);
this->richTextBoxDescription->SelectedText = "The virtual player (Neo) starts the game by playing a card. "
"Then, you can play a card from your set. The power score is updated according to the card played. "
"The game continues until you and the virtual player (Neo) have no more cards to play." + Environment::NewLine;
this->richTextBoxDescription->SelectionColor = System::Drawing::Color::Black;
this->richTextBoxDescription->SelectionFont = gcnew System::Drawing::Font(this->richTextBoxCardMinus->Font, FontStyle::Bold);
this->richTextBoxDescription->SelectedText = "Goal: ";
this->richTextBoxDescription->SelectionColor = System::Drawing::Color::Black;
this->richTextBoxDescription->SelectionFont = gcnew System::Drawing::Font(this->richTextBoxCardMinus->Font, FontStyle::Regular);
this->richTextBoxDescription->SelectedText = "The player with the highest power score wins.";
// Card Minus
this->richTextBoxCardMinus->SelectionColor = System::Drawing::Color::Black;
this->richTextBoxCardMinus->SelectionFont = gcnew System::Drawing::Font(this->richTextBoxCardMinus->Font, FontStyle::Bold);
this->richTextBoxCardMinus->SelectedText = "Card Type: ";
this->richTextBoxCardMinus->SelectionColor = System::Drawing::Color::Black;
this->richTextBoxCardMinus->SelectionFont = gcnew System::Drawing::Font(this->richTextBoxCardMinus->Font, FontStyle::Regular);
this->richTextBoxCardMinus->SelectedText = "Power-" + Environment::NewLine;
this->richTextBoxCardMinus->SelectionColor = System::Drawing::Color::Black;
this->richTextBoxCardMinus->SelectionFont = gcnew System::Drawing::Font(this->richTextBoxCardMinus->Font, FontStyle::Bold);
this->richTextBoxCardMinus->SelectedText = "Power Value: ";
this->richTextBoxCardMinus->SelectionColor = System::Drawing::Color::Black;
this->richTextBoxCardMinus->SelectionFont = gcnew System::Drawing::Font(this->richTextBoxCardMinus->Font, FontStyle::Regular);
this->richTextBoxCardMinus->SelectedText = "1 to 5" + Environment::NewLine;
this->richTextBoxCardMinus->SelectionColor = System::Drawing::Color::Black;
this->richTextBoxCardMinus->SelectionFont = gcnew System::Drawing::Font(this->richTextBoxCardMinus->Font, FontStyle::Bold);
this->richTextBoxCardMinus->SelectedText = "Effect: ";
this->richTextBoxCardMinus->SelectionColor = System::Drawing::Color::Black;
this->richTextBoxCardMinus->SelectionFont = gcnew System::Drawing::Font(this->richTextBoxCardMinus->Font, FontStyle::Regular);
this->richTextBoxCardMinus->SelectedText = "The power score of the opponent is decreased by the power value of the card.";
// Card Plus
this->richTextBoxCardPlus->SelectionColor = System::Drawing::Color::Black;
this->richTextBoxCardPlus->SelectionFont = gcnew System::Drawing::Font(this->richTextBoxCardMinus->Font, FontStyle::Bold);
this->richTextBoxCardPlus->SelectedText = "Card Type: ";
this->richTextBoxCardPlus->SelectionColor = System::Drawing::Color::Black;
this->richTextBoxCardPlus->SelectionFont = gcnew System::Drawing::Font(this->richTextBoxCardMinus->Font, FontStyle::Regular);
this->richTextBoxCardPlus->SelectedText = "Power+" + Environment::NewLine;
this->richTextBoxCardPlus->SelectionColor = System::Drawing::Color::Black;
this->richTextBoxCardPlus->SelectionFont = gcnew System::Drawing::Font(this->richTextBoxCardMinus->Font, FontStyle::Bold);
this->richTextBoxCardPlus->SelectedText = "Power Value: ";
this->richTextBoxCardPlus->SelectionColor = System::Drawing::Color::Black;
this->richTextBoxCardPlus->SelectionFont = gcnew System::Drawing::Font(this->richTextBoxCardMinus->Font, FontStyle::Regular);
this->richTextBoxCardPlus->SelectedText = "1 to 5" + Environment::NewLine;
this->richTextBoxCardPlus->SelectionColor = System::Drawing::Color::Black;
this->richTextBoxCardPlus->SelectionFont = gcnew System::Drawing::Font(this->richTextBoxCardMinus->Font, FontStyle::Bold);
this->richTextBoxCardPlus->SelectedText = "Effect: ";
this->richTextBoxCardPlus->SelectionColor = System::Drawing::Color::Black;
this->richTextBoxCardPlus->SelectionFont = gcnew System::Drawing::Font(this->richTextBoxCardMinus->Font, FontStyle::Regular);
this->richTextBoxCardPlus->SelectedText = "The power score of the player is increased by the power value of the card.";
// Card Steal
this->richTextBoxCardSteal->SelectionColor = System::Drawing::Color::Black;
this->richTextBoxCardSteal->SelectionFont = gcnew System::Drawing::Font(this->richTextBoxCardMinus->Font, FontStyle::Bold);
this->richTextBoxCardSteal->SelectedText = "Card Type: ";
this->richTextBoxCardSteal->SelectionColor = System::Drawing::Color::Black;
this->richTextBoxCardSteal->SelectionFont = gcnew System::Drawing::Font(this->richTextBoxCardMinus->Font, FontStyle::Regular);
this->richTextBoxCardSteal->SelectedText = "Steal" + Environment::NewLine;
this->richTextBoxCardSteal->SelectionColor = System::Drawing::Color::Black;
this->richTextBoxCardSteal->SelectionFont = gcnew System::Drawing::Font(this->richTextBoxCardMinus->Font, FontStyle::Bold);
this->richTextBoxCardSteal->SelectedText = "Power Value: ";
this->richTextBoxCardSteal->SelectionColor = System::Drawing::Color::Black;
this->richTextBoxCardSteal->SelectionFont = gcnew System::Drawing::Font(this->richTextBoxCardMinus->Font, FontStyle::Regular);
this->richTextBoxCardSteal->SelectedText = "1" + Environment::NewLine;
this->richTextBoxCardSteal->SelectionColor = System::Drawing::Color::Black;
this->richTextBoxCardSteal->SelectionFont = gcnew System::Drawing::Font(this->richTextBoxCardMinus->Font, FontStyle::Bold);
this->richTextBoxCardSteal->SelectedText = "Effect: ";
this->richTextBoxCardSteal->SelectionColor = System::Drawing::Color::Black;
this->richTextBoxCardSteal->SelectionFont = gcnew System::Drawing::Font(this->richTextBoxCardMinus->Font, FontStyle::Regular);
this->richTextBoxCardSteal->SelectedText = "The player can select a card to get from the opponent's set. "
"If the opponent's set is empty, this card is equivalent to a Power+ card with a power value of 1.";
// Card Double
this->richTextBoxCardDouble->SelectionColor = System::Drawing::Color::Black;
this->richTextBoxCardDouble->SelectionFont = gcnew System::Drawing::Font(this->richTextBoxCardMinus->Font, FontStyle::Bold);
this->richTextBoxCardDouble->SelectedText = "Card Type: ";
this->richTextBoxCardDouble->SelectionColor = System::Drawing::Color::Black;
this->richTextBoxCardDouble->SelectionFont = gcnew System::Drawing::Font(this->richTextBoxCardMinus->Font, FontStyle::Regular);
this->richTextBoxCardDouble->SelectedText = "Double" + Environment::NewLine;
this->richTextBoxCardDouble->SelectionColor = System::Drawing::Color::Black;
this->richTextBoxCardDouble->SelectionFont = gcnew System::Drawing::Font(this->richTextBoxCardMinus->Font, FontStyle::Bold);
this->richTextBoxCardDouble->SelectedText = "Power Value: ";
this->richTextBoxCardDouble->SelectionColor = System::Drawing::Color::Black;
this->richTextBoxCardDouble->SelectionFont = gcnew System::Drawing::Font(this->richTextBoxCardMinus->Font, FontStyle::Regular);
this->richTextBoxCardDouble->SelectedText = "2" + Environment::NewLine;
this->richTextBoxCardDouble->SelectionColor = System::Drawing::Color::Black;
this->richTextBoxCardDouble->SelectionFont = gcnew System::Drawing::Font(this->richTextBoxCardMinus->Font, FontStyle::Bold);
this->richTextBoxCardDouble->SelectedText = "Effect: ";
this->richTextBoxCardDouble->SelectionColor = System::Drawing::Color::Black;
this->richTextBoxCardDouble->SelectionFont = gcnew System::Drawing::Font(this->richTextBoxCardMinus->Font, FontStyle::Regular);
this->richTextBoxCardDouble->SelectedText = "The power score of the player is doubled.";
// Card Change
this->richTextBoxCardChange->SelectionColor = System::Drawing::Color::Black;
this->richTextBoxCardChange->SelectionFont = gcnew System::Drawing::Font(this->richTextBoxCardMinus->Font, FontStyle::Bold);
this->richTextBoxCardChange->SelectedText = "Card Type: ";
this->richTextBoxCardChange->SelectionColor = System::Drawing::Color::Black;
this->richTextBoxCardChange->SelectionFont = gcnew System::Drawing::Font(this->richTextBoxCardMinus->Font, FontStyle::Regular);
this->richTextBoxCardChange->SelectedText = "Change" + Environment::NewLine;
this->richTextBoxCardChange->SelectionColor = System::Drawing::Color::Black;
this->richTextBoxCardChange->SelectionFont = gcnew System::Drawing::Font(this->richTextBoxCardMinus->Font, FontStyle::Bold);
this->richTextBoxCardChange->SelectedText = "Power Value: ";
this->richTextBoxCardChange->SelectionColor = System::Drawing::Color::Black;
this->richTextBoxCardChange->SelectionFont = gcnew System::Drawing::Font(this->richTextBoxCardMinus->Font, FontStyle::Regular);
this->richTextBoxCardChange->SelectedText = "3" + Environment::NewLine;
this->richTextBoxCardChange->SelectionColor = System::Drawing::Color::Black;
this->richTextBoxCardChange->SelectionFont = gcnew System::Drawing::Font(this->richTextBoxCardMinus->Font, FontStyle::Bold);
this->richTextBoxCardChange->SelectedText = "Effect: ";
this->richTextBoxCardChange->SelectionColor = System::Drawing::Color::Black;
this->richTextBoxCardChange->SelectionFont = gcnew System::Drawing::Font(this->richTextBoxCardMinus->Font, FontStyle::Regular);
this->richTextBoxCardChange->SelectedText = "This cards changes the effect of the last card played by the opponent. "
"More precisely, the last card played by the opponent is interpreted as a card played by the player who plays the Change card. "
"If the opponent didn't play a card, this card has the same effect as when the last card played by the opponent is a Power+ card with a power value of 3. "
"If the last card played by the opponent is a Steal or Change card, it is interpreted as a Power+ card with a power value of 3.";
}
}
| [
"bringrednight@yahoo.com"
] | bringrednight@yahoo.com |
f966520c411918dd2d026297b75ae67ce8f74e47 | 84090973310d01d8fb38a391f9aa182a5886e17e | /challenge/2020/30-day-leetcoding-challenge/binary-tree-maximum-path-sum.cpp | ccf60ae3d3bb97a4d7c063583d1d8754346d5f14 | [] | no_license | VasuGoel/leetcode | 29e4d7fe6654d76ae625037e6266ec9e8d25f304 | 2de293a5acbbe653a9e0757fea99eca37ac84e54 | refs/heads/master | 2023-04-14T11:19:16.995592 | 2021-04-30T16:35:57 | 2021-04-30T16:35:57 | 324,527,300 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,566 | cpp | /**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
* };
*/
class Solution {
public:
int maxPathSum(TreeNode* root) {
int max_element = INT_MIN;
int res = dfs(root, max_element).first;
// if max path sum equals 0 (means all elements in tree are -ve), return max element in tree
return !res ? max_element : res;
}
// return pair of {max path sum, max depth sum (or max sum along deepest path from that node to leaf)}
pair<int,int> dfs(TreeNode *root, int &max_element) {
if(!root) return {0, 0};
max_element = max(max_element, root->val);
auto ls = dfs(root->left, max_element);
auto rs = dfs(root->right, max_element);
// max path sum at any node is max of left and right subtree and also the deepest path sum of left and right subtree (both maximized with 0, to avoid adding -ve node to sum) plus current node value
int maxpathsum = max({ls.first, rs.first, max(ls.second, 0) + max(rs.second, 0) + root->val});
// at each node return max path sum found upto that node and deepest path sum (maximized with 0 to avoid negative node in deepest path)
return {maxpathsum, max({ls.second, rs.second, 0}) + root->val};
}
};
| [
"goelvasu0712@gmail.com"
] | goelvasu0712@gmail.com |
5098655f2e01c9a2728dee4e1e091ae470fe7fcb | 25ef14d7bb2cf37b66870e7706d5b8dc77dcc48e | /src/Player.cpp | 8299a70664a24c1db777b69f49342adb98e6dc9d | [] | no_license | Tiernanze/SFML-space-invaders | 9471f8c4f785ac1be0db11395efe6d855562cf15 | d510c7750553b93a2da41519e23138a0efd69647 | refs/heads/main | 2023-04-19T16:28:10.737275 | 2021-05-10T19:30:05 | 2021-05-10T19:30:05 | 366,153,925 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 31,396 | cpp | #include "..\include\Player.h"
mainMenu menuCheck;
void Player::playerMovement(sf::RenderWindow& window)
{
if (!firstSet)
{
sPlayerShip.setPosition((window.getSize().x + vPlayerSize.x) / 2.f, window.getSize().y + - 62.8f);
currentPos = (window.getSize().x + vPlayerSize.x) / 2.f;
firstSet = true;
}
if (sf::Keyboard::isKeyPressed(sf::Keyboard::A))
{
xVelocity = -0.5f;
xSpeed = xSpeed + xVelocity;
}
if (xSpeed < -10)
{
xSpeed = -10;
}
if (sf::Keyboard::isKeyPressed(sf::Keyboard::D))
{
xVelocity = 0.5f;
xSpeed = xSpeed + xVelocity;
}
if (xSpeed > 10)
{
xSpeed = 10;
}
currentPos = currentPos + xSpeed;
if (currentPos < 0)
{
currentPos = 0;
xSpeed = 2;
}
if (currentPos > window.getSize().x - 40)
{
currentPos = window.getSize().x - 40;
xSpeed = -2;
}
sPlayerShip.setPosition(currentPos, window.getSize().y + -62.8f);
}
void Player::playerController(sf::RenderWindow& window)
{
if (!loadedShot)
{
playerFire.loadFromFile(".\\assets\\audio\\playerShoot.wav");
playerShoot.setBuffer(playerFire);
playerShoot.setPitch(0.8f);
loadedShot = true;
}
if (isShot1 == false)
{
playerShoot.play();
missilePosY1 = window.getSize().y - 62.8f;
missilePosX1 = currentPos + 20;
isShot1 = true;
}
else if(isShot2 == false)
{
playerShoot.play();
missilePosY2 = window.getSize().y - 62.8f;
missilePosX2 = currentPos + 20;
isShot2 = true;
}
else if (isShot3 == false)
{
playerShoot.play();
missilePosY3 = window.getSize().y - 62.8f;
missilePosX3 = currentPos + 20;
isShot3 = true;
}
else if (isShot4 == false)
{
playerShoot.play();
missilePosY4 = window.getSize().y - 62.8f;
missilePosX4 = currentPos + 20;
isShot4 = true;
}
else if (isShot5 == false)
{
playerShoot.play();
missilePosY5 = window.getSize().y - 62.8f;
missilePosX5 = currentPos + 20;
isShot5 = true;
}
}
void Player::playerRender(sf::RenderWindow& window)
{
tPlayerShip.loadFromFile(".\\assets\\textures\\playerShip.png");// 200 x 264
vPlayerSize.x = 200.f;
vPlayerSize.y = 264.f;
sPlayerShip.setScale((vPlayerSize.x / tPlayerShip.getSize().x) * 0.2f, (vPlayerSize.y / tPlayerShip.getSize().y) * 0.2f);
sPlayerShip.setTexture(tPlayerShip);
window.draw(sPlayerShip);
tMissile.loadFromFile(".\\assets\\textures\\bullet.png");// 15 x 52
vMissileSize.x = 15.f;
vMissileSize.y = 52.f;
sMissile1.setScale((vMissileSize.x / tMissile.getSize().x) * 0.4f, (vMissileSize.y / tMissile.getSize().y) * 0.4f);
sMissile1.setTexture(tMissile);
sMissile1Shot.setTexture(tMissile);
sMissile2.setScale((vMissileSize.x / tMissile.getSize().x) * 0.4f, (vMissileSize.y / tMissile.getSize().y) * 0.4f);
sMissile2.setTexture(tMissile);
sMissile2Shot.setTexture(tMissile);
sMissile3.setScale((vMissileSize.x / tMissile.getSize().x) * 0.4f, (vMissileSize.y / tMissile.getSize().y) * 0.4f);
sMissile3.setTexture(tMissile);
sMissile3Shot.setTexture(tMissile);
sMissile4.setScale((vMissileSize.x / tMissile.getSize().x) * 0.4f, (vMissileSize.y / tMissile.getSize().y) * 0.4f);
sMissile4.setTexture(tMissile);
sMissile4Shot.setTexture(tMissile);
sMissile5.setScale((vMissileSize.x / tMissile.getSize().x) * 0.4f, (vMissileSize.y / tMissile.getSize().y) * 0.4f);
sMissile5.setTexture(tMissile);
sMissile5Shot.setTexture(tMissile);
if (isShot1 == false)
{
int missilePosX = 50;
int missilePosY = 5;
sMissile1.setPosition(missilePosX, missilePosY);
window.draw(sMissile1);
}
else if (isShot1 == true)
{
missilePosY1 = missilePosY1 - mSpeed;
sMissile1Shot.setPosition(missilePosX1, missilePosY1);
sMissile1Shot.setScale((vMissileSize.x / tMissile.getSize().x) * 0.2f, (vMissileSize.y / tMissile.getSize().y) * 0.2f);
if (missilePosY1 < 0)
{
isShot1 = false;
}
window.draw(sMissile1Shot);
}
if (isShot2 == false)
{
missilePosX2 = 40;
missilePosY2 = 5;
sMissile2.setPosition(missilePosX2, missilePosY2);
window.draw(sMissile2);
}
else if (isShot2 == true)
{
missilePosY2 = missilePosY2 - mSpeed;
sMissile2Shot.setPosition(missilePosX2, missilePosY2);
sMissile2Shot.setScale((vMissileSize.x / tMissile.getSize().x) * 0.2f, (vMissileSize.y / tMissile.getSize().y) * 0.2f);
if (missilePosY2 < 0)
{
isShot2 = false;
}
window.draw(sMissile2Shot);
}
if (isShot3 == false)
{
missilePosX3 = 30;
missilePosY3 = 5;
sMissile3.setPosition(missilePosX3, missilePosY3);
window.draw(sMissile3);
}
else if (isShot3 == true)
{
missilePosY3 = missilePosY3 - mSpeed;
sMissile3Shot.setPosition(missilePosX3, missilePosY3);
sMissile3Shot.setScale((vMissileSize.x / tMissile.getSize().x) * 0.2f, (vMissileSize.y / tMissile.getSize().y) * 0.2f);
if (missilePosY3 < 0)
{
isShot3 = false;
}
window.draw(sMissile3Shot);
}
if (isShot4 == false)
{
missilePosX4 = 20;
missilePosY4 = 5;
sMissile4.setPosition(missilePosX4, missilePosY4);
window.draw(sMissile4);
}
else if (isShot4 == true)
{
missilePosY4 = missilePosY4 - mSpeed;
sMissile4Shot.setPosition(missilePosX4, missilePosY4);
sMissile4Shot.setScale((vMissileSize.x / tMissile.getSize().x) * 0.2f, (vMissileSize.y / tMissile.getSize().y) * 0.2f);
if (missilePosY4 < 0)
{
isShot4 = false;
}
window.draw(sMissile4Shot);
}
if (isShot5 == false)
{
missilePosX5 = 10;
missilePosY5 = 5;
sMissile5.setPosition(missilePosX5, missilePosY5);
window.draw(sMissile5);
}
else if (isShot5 == true)
{
missilePosY5 = missilePosY5 - mSpeed;
sMissile5Shot.setPosition(missilePosX5, missilePosY5);
sMissile5Shot.setScale((vMissileSize.x / tMissile.getSize().x) * 0.2f, (vMissileSize.y / tMissile.getSize().y) * 0.2f);
if (missilePosY5 < 0)
{
isShot5 = false;
}
window.draw(sMissile5Shot);
}
}
void Player::enemyLogic(sf::RenderWindow& window)
{
alienSize.x = 198.f;
alienSize.y = 138.f;
sf::Sprite alienSprite;
int index = 0;
float maxElement = 0;
if (!loadedHit)
{
enemyHit.loadFromFile(".\\assets\\audio\\enemyHit.wav");
enemyDestroyed.setBuffer(enemyHit);
loadedHit = true;
}
int speedAlter = 1;
int tempEnemies = iEnemies + iEnemyRow;
sf::Time checkTimer = timer.getElapsedTime();
if (checkTimer.asMilliseconds() > ticker1)
{
ticker1 = ticker1 + shipSpeed;
movementTime = true;
if (ticker1 > 100000)
{
ticker1 = 0;
timer.restart();
}
}
for (int i = 0; i < iEnemies; i++)
{
for (int j = 0; j < iEnemyRow; j++)
{
if (iSpawnShips < (iEnemies * iEnemyRow))
{
spriteGenerator(tInvaders, ".\\assets\\textures\\enemyShips.png", vSprites.size(), alienSize.x, alienSize.y, alienSprite);
vSprites.push_back(alienSprite);
vSprites[index].setPosition(i * 58, 50 + (j * 60));
}
if (iSpawnShips < (iEnemies * iEnemyRow))
{
shipAlive.push_back(true);
isRight.push_back(true);
iSpawnShips++;
}
int counter = 0;
for (int k = 0; k < vSprites.size(); k++)
{
if (maxElement <= vSprites[counter].getPosition().x)
{
if (shipAlive[counter])
{
maxElement = vSprites[counter].getPosition().x;
}
counter++;
}
}
float minElement = 100;
float counter2 = 0;
for (int k = 0; k < vSprites.size(); k++)
{
if (shipAlive[counter2])
{
if (minElement > counter2)
{
minElement = counter2;
}
}
counter2++;
}
int move = 0;
if(movementTime)
{
if (isRight[index] && move == 0)
{
if ((maxElement + 59) > window.getSize().x)
{
vSprites[index].setPosition(vSprites[index].getPosition().x, vSprites[index].getPosition().y + 50);
isRight[index] = false;
if (speedAlter == 1)
{
shipSpeed = shipSpeed - 40.f;
speedAlter = 0;
}
move++;
}
else
{
vSprites[index].setPosition(vSprites[index].getPosition().x + 58, vSprites[index].getPosition().y);
move++;
}
}
if (!isRight[index] && move == 0)
{
if (move == 0)
{
vSprites[index].setPosition(vSprites[index].getPosition().x - 58, vSprites[index].getPosition().y);
move++;
}
if (vSprites[minElement].getPosition().x <= 0)
{
vSprites[index].setPosition(vSprites[index].getPosition().x, vSprites[index].getPosition().y + 50);
isRight[index] = true;
if (speedAlter == 1)
{
shipSpeed = shipSpeed - -40.f;
speedAlter = 0;
}
move++;
}
}
}
if (shipAlive[index])
{
if (sMissile1Shot.getPosition().x + 3 >= vSprites[index].getPosition().x && sMissile1Shot.getPosition().y + 10.4 >= vSprites[index].getPosition().y &&
sMissile1Shot.getPosition().x <= vSprites[index].getPosition().x + 57.02f && sMissile1Shot.getPosition().y <= vSprites[index].getPosition().y + 39.74
&& isShot1)
{
enemyDestroyed.play();
shipAlive[index] = false;
isShot1 = false;
playerScore++;
}
if (sMissile2Shot.getPosition().x + 3 >= vSprites[index].getPosition().x && sMissile2Shot.getPosition().y + 10.4 >= vSprites[index].getPosition().y &&
sMissile2Shot.getPosition().x <= vSprites[index].getPosition().x + 57.02f && sMissile2Shot.getPosition().y <= vSprites[index].getPosition().y + 39.74
&& isShot2)
{
enemyDestroyed.play();
shipAlive[index] = false;
isShot2 = false;
playerScore++;
}
if (sMissile3Shot.getPosition().x + 3 >= vSprites[index].getPosition().x && sMissile3Shot.getPosition().y + 10.4 >= vSprites[index].getPosition().y &&
sMissile3Shot.getPosition().x <= vSprites[index].getPosition().x + 57.02f && sMissile3Shot.getPosition().y <= vSprites[index].getPosition().y + 39.74
&& isShot3)
{
enemyDestroyed.play();
shipAlive[index] = false;
isShot3 = false;
playerScore++;
}
if (sMissile4Shot.getPosition().x + 3 >= vSprites[index].getPosition().x && sMissile4Shot.getPosition().y + 10.4 >= vSprites[index].getPosition().y &&
sMissile4Shot.getPosition().x <= vSprites[index].getPosition().x + 57.02f && sMissile4Shot.getPosition().y <= vSprites[index].getPosition().y + 39.74
&& isShot4)
{
enemyDestroyed.play();
shipAlive[index] = false;
isShot4 = false;
playerScore++;
}
if (sMissile5Shot.getPosition().x + 3 >= vSprites[index].getPosition().x && sMissile5Shot.getPosition().y + 10.4 >= vSprites[index].getPosition().y &&
sMissile5Shot.getPosition().x <= vSprites[index].getPosition().x + 57.02f && sMissile5Shot.getPosition().y <= vSprites[index].getPosition().y + 39.74
&& isShot5)
{
enemyDestroyed.play();
shipAlive[index] = false;
isShot5 = false;
playerScore++;
}
}
if (shipAlive[index])
{
window.draw(vSprites[index]);
}
index++;
}
}
movementTime = false;
}
void Player::PlayerScore(sf::RenderWindow& window)
{
spaceFont.loadFromFile(".\\assets\\Fonts\\spaceText.ttf");
sf::Text score;
score.setFont(spaceFont);
score.setString(to_string(playerScore));
score.setCharacterSize(30);
score.setFillColor(spaceBlue);
score.setOutlineColor(sf::Color(52,133,188,255));
score.setOutlineThickness(1);
score.setStyle(sf::Text::Bold);
score.setPosition(window.getSize().x - 80, 0);
window.draw(score);
}
void Player::shipShooting(sf::RenderWindow& window)
{
tMissile.loadFromFile(".\\assets\\textures\\bullet.png");// 15 x 52
if (!loadedDestroy)
{
playerHit.loadFromFile(".\\assets\\audio\\playerHit.wav");
playerDestroyed.setBuffer(playerHit);
loadedDestroy = true;
}
if (!enemyLoaded)
{
enemyFire.loadFromFile(".\\assets\\audio\\enemyShoot.wav");
enemyShoot.setBuffer(enemyFire);
enemyShoot.setPitch(2);
enemyLoaded = true;
}
vMissileSize.x = 15.f;
vMissileSize.y = 52.f;
sAlienShot1.setScale((vMissileSize.x / tMissile.getSize().x) * 0.3f, (vMissileSize.y / tMissile.getSize().y) * 0.3f);
sAlienShot1.setTexture(tMissile);
sAlienShot1.setRotation(180);
sAlienShot2.setScale((vMissileSize.x / tMissile.getSize().x) * 0.3f, (vMissileSize.y / tMissile.getSize().y) * 0.3f);
sAlienShot2.setTexture(tMissile);
sAlienShot2.setRotation(180);
sAlienShot3.setScale((vMissileSize.x / tMissile.getSize().x) * 0.3f, (vMissileSize.y / tMissile.getSize().y) * 0.3f);
sAlienShot3.setTexture(tMissile);
sAlienShot3.setRotation(180);
srand(time(NULL));
int randShip = rand() % vSprites.size();
sf::Time checkTimer = timer2.getElapsedTime();
if (checkTimer.asSeconds() > ticker2)
{
shipShoot1 = true;
ticker2 = ticker2 + 5;
if (ticker2 > 200.f)
{
ticker2 = 0;
}
}
if (checkTimer.asSeconds() > ticker3)
{
shipShoot2 = true;
ticker3 = ticker3 + 5;
if (ticker3 > 200.f)
{
ticker3 = 0;
}
}
if (checkTimer.asSeconds() > ticker4)
{
shipShoot3 = true;
ticker4 = ticker4 + 5;
if (ticker4 > 200.f)
{
ticker4 = 0;
timer2.restart();
}
}
if (shipAlive[randShip])
{
if (!alienShot1 && shipShoot1)
{
enemyShoot.play();
shotPosY1 = vSprites[randShip].getPosition().y;
shotPosX1 = vSprites[randShip].getPosition().x + 28.5;
alienShot1 = true;
shipShoot1 = false;
}
if (!alienShot2 && shipShoot2)
{
enemyShoot.play();
shotPosY2 = vSprites[randShip].getPosition().y;
shotPosX2 = vSprites[randShip].getPosition().x + 28.5;
alienShot2 = true;
shipShoot2 = false;
}
if (!alienShot3 && shipShoot3)
{
enemyShoot.play();
shotPosY3 = vSprites[randShip].getPosition().y;
shotPosX3 = vSprites[randShip].getPosition().x + 28.5;
alienShot3 = true;
shipShoot3 = false;
}
}
if (alienShot1)
{
shotPosY1 = shotPosY1 + mEnemySpeed;
sAlienShot1.setPosition(shotPosX1, shotPosY1);
if (shotPosY1 > window.getSize().y)
{
alienShot1 = false;
}
window.draw(sAlienShot1);
}
if (alienShot2)
{
shotPosY2 = shotPosY2 + mEnemySpeed;
sAlienShot2.setPosition(shotPosX2, shotPosY2);
if (shotPosY2 > window.getSize().y)
{
alienShot2 = false;
}
window.draw(sAlienShot2);
}
if (alienShot3)
{
shotPosY3 = shotPosY3 + mEnemySpeed;
sAlienShot3.setPosition(shotPosX3, shotPosY3);
if (shotPosY3 > window.getSize().y)
{
alienShot3 = false;
}
window.draw(sAlienShot3);
}
if (sAlienShot1.getPosition().x < sPlayerShip.getPosition().x + 40 && sAlienShot1.getPosition().x + 4.5 > sPlayerShip.getPosition().x
&& sAlienShot1.getPosition().y < sPlayerShip.getPosition().y + 52.8 && sAlienShot1.getPosition().y + 15.6 > sPlayerShip.getPosition().y && alienShot1)
{
playerDestroyed.play();
alienShot1 = false;
playerHealth--;
}
if (sAlienShot2.getPosition().x < sPlayerShip.getPosition().x + 40 && sAlienShot2.getPosition().x + 4.5 > sPlayerShip.getPosition().x
&& sAlienShot2.getPosition().y < sPlayerShip.getPosition().y + 52.8 && sAlienShot2.getPosition().y + 15.6 > sPlayerShip.getPosition().y && alienShot2)
{
playerDestroyed.play();
alienShot2 = false;
playerHealth--;
}
if (sAlienShot3.getPosition().x < sPlayerShip.getPosition().x + 40 && sAlienShot3.getPosition().x + 4.5 > sPlayerShip.getPosition().x
&& sAlienShot3.getPosition().y < sPlayerShip.getPosition().y + 52.8 && sAlienShot3.getPosition().y + 15.6 > sPlayerShip.getPosition().y && alienShot3)
{
playerDestroyed.play();
alienShot3 = false;
playerHealth--;
}
}
void Player::shields(sf::RenderWindow& window)
{
tLowShield.loadFromFile(".\\assets\\textures\\lowShield.png");// 40 x 125
tMidShield.loadFromFile(".\\assets\\textures\\halfShield.png");// 40 x 125
tFullShield.loadFromFile(".\\assets\\textures\\fullShield.png");// 40 x 125
if (!shieldSound)
{
shieldDestroyed.setBuffer(playerHit);
shieldDestroyed.setPitch(1.4f);
shieldSound = true;
}
shieldSize.x = 40;
shieldSize.y = 125;
sShields1.setScale(shieldSize.x / tLowShield.getSize().x * 1, shieldSize.y / tLowShield.getSize().y * 1);
sShields2.setScale(shieldSize.x / tLowShield.getSize().x * 1, shieldSize.y / tLowShield.getSize().y * 1);
sShields3.setScale(shieldSize.x / tLowShield.getSize().x * 1, shieldSize.y / tLowShield.getSize().y * 1);
sShields1.setRotation(270);
sShields2.setRotation(270);
sShields3.setRotation(270);
sShields1.setPosition((window.getSize().x / 4) - 62.5, sPlayerShip.getPosition().y - 10);
sShields2.setPosition((window.getSize().x / 2) - 62.5, sPlayerShip.getPosition().y - 10);
sShields3.setPosition(((window.getSize().x / 4) * 3) - 62.5, sPlayerShip.getPosition().y - 10);
switch (shieldState1)
{
case 1:
sShields1.setTexture(tFullShield);
break;
case 2:
sShields1.setTexture(tMidShield);
break;
case 3:
sShields1.setTexture(tLowShield);
break;
}
switch (shieldState2)
{
case 1:
sShields2.setTexture(tFullShield);
break;
case 2:
sShields2.setTexture(tMidShield);
break;
case 3:
sShields2.setTexture(tLowShield);
break;
}
switch (shieldState3)
{
case 1:
sShields3.setTexture(tFullShield);
break;
case 2:
sShields3.setTexture(tMidShield);
break;
case 3:
sShields3.setTexture(tLowShield);
break;
}
if (shieldState1 <= 3)
{
if (shieldState1 == 3)
{
if (sAlienShot3.getPosition().x > sShields1.getPosition().x && sAlienShot3.getPosition().x + 4.5 < sShields1.getPosition().x + 125
&& sAlienShot3.getPosition().y + 15.6 > sShields1.getPosition().y && sAlienShot3.getPosition().y < sShields1.getPosition().y + 40 && alienShot3)
{
alienShot3 = false;
shieldState1++;
shieldDestroyed.play();
}
if (sAlienShot2.getPosition().x > sShields1.getPosition().x && sAlienShot2.getPosition().x + 4.5 < sShields1.getPosition().x + 125
&& sAlienShot2.getPosition().y + 15.6 > sShields1.getPosition().y && sAlienShot2.getPosition().y < sShields1.getPosition().y + 40 && alienShot2)
{
alienShot2 = false;
shieldState1++;
shieldDestroyed.play();
}
if (sAlienShot1.getPosition().x > sShields1.getPosition().x && sAlienShot1.getPosition().x + 4.5 < sShields1.getPosition().x + 125
&& sAlienShot1.getPosition().y + 15.6 > sShields1.getPosition().y && sAlienShot1.getPosition().y < sShields1.getPosition().y + 40 && alienShot1)
{
alienShot1 = false;
shieldState1++;
shieldDestroyed.play();
}
}
if (shieldState1 == 2)
{
if (sAlienShot3.getPosition().x > sShields1.getPosition().x && sAlienShot3.getPosition().x + 4.5 < sShields1.getPosition().x + 125
&& sAlienShot3.getPosition().y + 15.6 > sShields1.getPosition().y && sAlienShot3.getPosition().y < sShields1.getPosition().y + 40 && alienShot3)
{
alienShot3 = false;
shieldState1++;
shieldDestroyed.play();
}
if (sAlienShot2.getPosition().x > sShields1.getPosition().x && sAlienShot2.getPosition().x + 4.5 < sShields1.getPosition().x + 125
&& sAlienShot2.getPosition().y + 15.6 > sShields1.getPosition().y && sAlienShot2.getPosition().y < sShields1.getPosition().y + 40 && alienShot2)
{
alienShot2 = false;
shieldState1++;
shieldDestroyed.play();
}
if (sAlienShot1.getPosition().x > sShields1.getPosition().x && sAlienShot1.getPosition().x + 4.5 < sShields1.getPosition().x + 125
&& sAlienShot1.getPosition().y + 15.6 > sShields1.getPosition().y && sAlienShot1.getPosition().y < sShields1.getPosition().y + 40 && alienShot1)
{
alienShot1 = false;
shieldState1++;
shieldDestroyed.play();
}
}
if (shieldState1 == 1)
{
if (sAlienShot3.getPosition().x > sShields1.getPosition().x && sAlienShot3.getPosition().x + 4.5 < sShields1.getPosition().x + 125
&& sAlienShot3.getPosition().y + 15.6 > sShields1.getPosition().y && sAlienShot3.getPosition().y < sShields1.getPosition().y + 40 && alienShot3)
{
alienShot3 = false;
shieldState1++;
shieldDestroyed.play();
}
if (sAlienShot2.getPosition().x > sShields1.getPosition().x && sAlienShot2.getPosition().x + 4.5 < sShields1.getPosition().x + 125
&& sAlienShot2.getPosition().y + 15.6 > sShields1.getPosition().y && sAlienShot2.getPosition().y < sShields1.getPosition().y + 40 && alienShot2)
{
alienShot2 = false;
shieldState1++;
shieldDestroyed.play();
}
if (sAlienShot1.getPosition().x > sShields1.getPosition().x && sAlienShot1.getPosition().x + 4.5 < sShields1.getPosition().x + 125
&& sAlienShot1.getPosition().y + 15.6 > sShields1.getPosition().y && sAlienShot1.getPosition().y < sShields1.getPosition().y + 40 && alienShot1)
{
alienShot1 = false;
shieldState1++;
shieldDestroyed.play();
}
}
window.draw(sShields1);
}
if (shieldState2 <= 3)
{
if (shieldState2 == 3)
{
if (sAlienShot3.getPosition().x > sShields2.getPosition().x && sAlienShot3.getPosition().x + 4.5 < sShields2.getPosition().x + 125
&& sAlienShot3.getPosition().y + 15.6 > sShields2.getPosition().y && sAlienShot3.getPosition().y < sShields2.getPosition().y + 40 && alienShot3)
{
alienShot3 = false;
shieldState2++;
shieldDestroyed.play();
}
if (sAlienShot2.getPosition().x > sShields2.getPosition().x && sAlienShot2.getPosition().x + 4.5 < sShields2.getPosition().x + 125
&& sAlienShot2.getPosition().y + 15.6 > sShields2.getPosition().y && sAlienShot2.getPosition().y < sShields2.getPosition().y + 40 && alienShot2)
{
alienShot2 = false;
shieldState2++;
shieldDestroyed.play();
}
if (sAlienShot1.getPosition().x > sShields2.getPosition().x && sAlienShot1.getPosition().x + 4.5 < sShields2.getPosition().x + 125
&& sAlienShot1.getPosition().y + 15.6 > sShields2.getPosition().y && sAlienShot1.getPosition().y < sShields2.getPosition().y + 40 && alienShot1)
{
alienShot1 = false;
shieldState2++;
shieldDestroyed.play();
}
}
if (shieldState2 == 2)
{
if (sAlienShot3.getPosition().x > sShields2.getPosition().x && sAlienShot3.getPosition().x + 4.5 < sShields2.getPosition().x + 125
&& sAlienShot3.getPosition().y + 15.6 > sShields2.getPosition().y && sAlienShot3.getPosition().y < sShields2.getPosition().y + 40 && alienShot3)
{
alienShot3 = false;
shieldState2++;
shieldDestroyed.play();
}
if (sAlienShot2.getPosition().x > sShields2.getPosition().x && sAlienShot2.getPosition().x + 4.5 < sShields2.getPosition().x + 125
&& sAlienShot2.getPosition().y + 15.6 > sShields2.getPosition().y && sAlienShot2.getPosition().y < sShields2.getPosition().y + 40 && alienShot2)
{
alienShot2 = false;
shieldState2++;
shieldDestroyed.play();
}
if (sAlienShot1.getPosition().x > sShields2.getPosition().x && sAlienShot1.getPosition().x + 4.5 < sShields2.getPosition().x + 125
&& sAlienShot1.getPosition().y + 15.6 > sShields2.getPosition().y && sAlienShot1.getPosition().y < sShields2.getPosition().y + 40 && alienShot1)
{
alienShot1 = false;
shieldState2++;
shieldDestroyed.play();
}
}
if (shieldState2 == 1)
{
if (sAlienShot3.getPosition().x > sShields2.getPosition().x && sAlienShot3.getPosition().x + 4.5 < sShields2.getPosition().x + 125
&& sAlienShot3.getPosition().y + 15.6 > sShields2.getPosition().y && sAlienShot3.getPosition().y < sShields2.getPosition().y + 40 && alienShot3)
{
alienShot3 = false;
shieldState2++;
shieldDestroyed.play();
}
if (sAlienShot2.getPosition().x > sShields2.getPosition().x && sAlienShot2.getPosition().x + 4.5 < sShields2.getPosition().x + 125
&& sAlienShot2.getPosition().y + 15.6 > sShields2.getPosition().y && sAlienShot2.getPosition().y < sShields2.getPosition().y + 40 && alienShot2)
{
alienShot2 = false;
shieldState2++;
shieldDestroyed.play();
}
if (sAlienShot1.getPosition().x > sShields2.getPosition().x && sAlienShot1.getPosition().x + 4.5 < sShields2.getPosition().x + 125
&& sAlienShot1.getPosition().y + 15.6 > sShields2.getPosition().y && sAlienShot1.getPosition().y < sShields2.getPosition().y + 40 && alienShot1)
{
alienShot1 = false;
shieldState2++;
shieldDestroyed.play();
}
}
window.draw(sShields2);
}
if (shieldState3 <= 3)
{
if (shieldState3 == 3)
{
if (sAlienShot3.getPosition().x > sShields3.getPosition().x && sAlienShot3.getPosition().x + 4.5 < sShields3.getPosition().x + 125
&& sAlienShot3.getPosition().y + 15.6 > sShields3.getPosition().y && sAlienShot3.getPosition().y < sShields3.getPosition().y + 40 && alienShot3)
{
alienShot3 = false;
shieldState3++;
shieldDestroyed.play();
}
if (sAlienShot2.getPosition().x > sShields3.getPosition().x && sAlienShot2.getPosition().x + 4.5 < sShields3.getPosition().x + 125
&& sAlienShot2.getPosition().y + 15.6 > sShields3.getPosition().y && sAlienShot2.getPosition().y < sShields3.getPosition().y + 40 && alienShot2)
{
alienShot2 = false;
shieldState3++;
shieldDestroyed.play();
}
if (sAlienShot1.getPosition().x > sShields3.getPosition().x && sAlienShot1.getPosition().x + 4.5 < sShields3.getPosition().x + 125
&& sAlienShot1.getPosition().y + 15.6 > sShields3.getPosition().y && sAlienShot1.getPosition().y < sShields3.getPosition().y + 40 && alienShot1)
{
alienShot1 = false;
shieldState3++;
shieldDestroyed.play();
}
}
if (shieldState3 == 2)
{
if (sAlienShot3.getPosition().x > sShields3.getPosition().x && sAlienShot3.getPosition().x + 4.5 < sShields3.getPosition().x + 125
&& sAlienShot3.getPosition().y + 15.6 > sShields3.getPosition().y && sAlienShot3.getPosition().y < sShields3.getPosition().y + 40 && alienShot3)
{
alienShot3 = false;
shieldState3++;
shieldDestroyed.play();
}
if (sAlienShot2.getPosition().x > sShields3.getPosition().x && sAlienShot2.getPosition().x + 4.5 < sShields3.getPosition().x + 125
&& sAlienShot2.getPosition().y + 15.6 > sShields3.getPosition().y && sAlienShot2.getPosition().y < sShields3.getPosition().y + 40 && alienShot2)
{
alienShot2 = false;
shieldState3++;
shieldDestroyed.play();
}
if (sAlienShot1.getPosition().x > sShields3.getPosition().x && sAlienShot1.getPosition().x + 4.5 < sShields3.getPosition().x + 125
&& sAlienShot1.getPosition().y + 15.6 > sShields3.getPosition().y && sAlienShot1.getPosition().y < sShields3.getPosition().y + 40 && alienShot1)
{
alienShot1 = false;
shieldState3++;
shieldDestroyed.play();
}
}
if (shieldState3 == 1)
{
if (sAlienShot3.getPosition().x > sShields3.getPosition().x && sAlienShot3.getPosition().x + 4.5 < sShields3.getPosition().x + 125
&& sAlienShot3.getPosition().y + 15.6 > sShields3.getPosition().y && sAlienShot3.getPosition().y < sShields3.getPosition().y + 40 && alienShot3)
{
alienShot3 = false;
shieldState3++;
shieldDestroyed.play();
}
if (sAlienShot2.getPosition().x > sShields3.getPosition().x && sAlienShot2.getPosition().x + 4.5 < sShields3.getPosition().x + 125
&& sAlienShot2.getPosition().y + 15.6 > sShields3.getPosition().y && sAlienShot2.getPosition().y < sShields3.getPosition().y + 40 && alienShot2)
{
alienShot2 = false;
shieldState3++;
shieldDestroyed.play();
}
if (sAlienShot1.getPosition().x > sShields3.getPosition().x && sAlienShot1.getPosition().x + 4.5 < sShields3.getPosition().x + 125
&& sAlienShot1.getPosition().y + 15.6 > sShields3.getPosition().y && sAlienShot1.getPosition().y < sShields3.getPosition().y + 40 && alienShot1)
{
alienShot1 = false;
shieldState3++;
shieldDestroyed.play();
}
}
window.draw(sShields3);
}
}
void Player::healthRender(sf::RenderWindow& window)
{
tHeart.loadFromFile(".\\assets\\textures\\heart.png"); // 150 x 130
vHeart.x = 150;
vHeart.y = 130;
sHeart.setScale(vHeart.x / tHeart.getSize().x * .2f, vHeart.y / tHeart.getSize().y * .2f);
sHeart.setTexture(tHeart);
for (int i = 0; i < playerHealth; i++)
{
if (createHearts < playerHealth)
{
vsHeart.push_back(sHeart);
createHearts++;
}
vsHeart[i].setPosition(sPlayerShip.getPosition().x + (30 * i) + 54, sPlayerShip.getPosition().y + 14);
window.draw(vsHeart[i]);
}
}
void Player::levelUp(sf::RenderWindow& window)
{
sf::Text levelUp;
levelUp.setFont(spaceFont);
levelUp.setString("Current level = " + to_string(currentLevel));
levelUp.setCharacterSize(30);
levelUp.setFillColor(spaceBlue);
levelUp.setOutlineColor(sf::Color(52, 133, 188, 255));
levelUp.setOutlineThickness(1);
levelUp.setStyle(sf::Text::Bold);
levelUp.setPosition(400, 0);
if (maxScore == playerScore)
{
spaceFont.loadFromFile(".\\assets\\Fonts\\spaceText.ttf");
vSprites.clear();
shipAlive.clear();
isRight.clear();
timer.restart();
timer2.restart();
shipShoot1 = false;
shipShoot2 = false;
shipShoot3 = false;
if (shieldState1 >= 3 && shieldState1 > 1)
{
shieldState1--;
}
if (shieldState2 >= 3 && shieldState2 > 1)
{
shieldState2--;
}
if (shieldState3 >= 3 && shieldState3 > 1)
{
shieldState3--;
}
iSpawnShips = 0;
ticker1 = 1600.f;
ticker2 = 0;
ticker3 = 2;
ticker4 = 4;
shipSpeed = 800.f - maxScore;
isShot1 = false;
isShot2 = false;
isShot3 = false;
isShot4 = false;
isShot5 = false;
currentLevel++;
playerHealth = playerHealth + 1;
maxScore = maxScore + 50;
}
window.draw(levelUp);
}
bool Player::GameOver()
{
gameOver = false;
float maxElementy = 0;
int counter3 = 0;
for (int k = 0; k < vSprites.size(); k++)
{
if (maxElementy <= vSprites[counter3].getPosition().y)
{
if (shipAlive[counter3])
{
maxElementy = vSprites[counter3].getPosition().y;
}
counter3++;
}
}
if (maxElementy >= 700 || playerHealth <= 0)
{
vSprites.clear();
shipAlive.clear();
isRight.clear();
timer.restart();
timer2.restart();
shipShoot1 = false;
shipShoot2 = false;
shipShoot3 = false;
iSpawnShips = 0;
playerScore = 0;
currentLevel = 1;
ticker1 = 1600.f;
ticker2 = 0;
ticker3 = 2;
ticker4 = 4;
shieldState1 = 1;
shieldState3 = 1;
shieldState2 = 1;
shipSpeed = 800.f;
firstSet = false;
playerHealth = 3;
gameOver = true;
}
return gameOver;
}
void Player::spriteGenerator(sf::Texture& tex, std::string sFileName, size_t size,float x ,float y, sf::Sprite& sprite)
{
tex.loadFromFile(sFileName);
sprite.setScale((x / tex.getSize().x) * 0.288f, (y / tex.getSize().y) * 0.288f);
sprite.setTexture(tex);
}
| [
"noreply@github.com"
] | noreply@github.com |
f2b8c0f6c1ac261046afd178daae324fd9e6b030 | a2ee7bdda1ec77faf3f68b158da3523de425987e | /tp-entrega-02/common/view/BalaView.cpp | 87cf9610168f7378e3b30b8a954b586686dac013 | [] | no_license | MauroToscano/Taller-de-Programacion-I-Grupo-8 | e495cbc27b76533619e0fc36c9826fe8a51e1645 | 1b5e6c6e3eda8eb1c11ab905fa75e75a571234a5 | refs/heads/master | 2022-07-20T04:00:08.267771 | 2020-02-25T23:44:10 | 2020-02-25T23:44:10 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 653 | cpp | #include "BalaView.h"
BalaView::BalaView()
{
this->balaModel = NULL;
this->spriteXml = NULL;
this->textura = NULL;
this->posicion.x = -1;
this->posicion.y = -1;
this->posicion.w = 0;
this->posicion.h = 0;
this->activa = false;
}
BalaView::BalaView(BalaModel * balaModel,SpriteXml * spriteXml){
this->balaModel = balaModel;
this->spriteXml = spriteXml;
this->textura = NULL;
this->posicion.x = -1;
this->posicion.y = -1;
this->posicion.w = 0;
this->posicion.h = 0;
this->activa = false;
}
BalaView::~BalaView()
{
//solo se libera el model
if (this->balaModel != NULL){
delete this->balaModel;
}
}
| [
"cbenez@gmail.com"
] | cbenez@gmail.com |
97fd7393f5f9ba12d3132968970b4aa0f82794ab | cc3616aa6a889b198a5d90f771a1da87a1210156 | /ftmtxt.cpp | 8db4bf2117f5bc0ab60e755732bd13ebf038bf36 | [
"BSD-3-Clause"
] | permissive | Mistranger/ftmtxt2seq | 24b8812abc9d21a96f94420346b6af22d2c5787f | 6686bafe5ade9e4c9d35a4305e1e134d539b8a19 | refs/heads/master | 2020-05-21T07:21:10.454754 | 2017-03-10T19:54:36 | 2017-03-10T19:54:36 | 84,594,196 | 4 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 8,811 | cpp | #include "ftmtxt.h"
#include "util.h"
#include <fstream>
#include <iostream>
#include <string>
std::string strGetBetween(std::string &str, char c = '\"')
{
std::string::size_type start_position;
std::string::size_type end_position;
std::string found_text;
start_position = str.find(c);
if (start_position != std::string::npos) {
++start_position; // start after the double quotes.
// look for end position;
end_position = str.find(c, start_position);
if (end_position != std::string::npos) {
found_text = str.substr(start_position, end_position - start_position - 1);
}
}
return found_text;
}
std::vector<std::string> tokenize(const char *str, char c = ' ')
{
std::vector<std::string> result;
do
{
while (*str == c && *str) {
str++;
}
const char *begin = str;
while (*str != c && *str) {
str++;
}
result.push_back(std::string(begin, str));
} while (0 != *str++);
return result;
}
FTMtxt::FTMtxt(): isPal(false), fps(0), channelCount(0), expansionColSize(0), expansion(EC_NONE),
split(0), n163chanells(0), patternLength(0), trackSpeed(0), trackTempo(0)
{
}
FTMtxt::~FTMtxt()
{
}
void FTMtxt::parseInstruments(std::ifstream &iFile)
{
std::string buf;
do {
std::getline(iFile, buf);
if (!buf.empty()) {
std::vector<std::string> tokens = tokenize(buf.c_str());
if (!tokens[0].compare("INST2A03")) {
FTMInstrument *ins = new FTMInstrument;
ins->index = atoi(tokens[1].c_str());
ins->volMacro = atoi(tokens[2].c_str());
ins->arpMacro = atoi(tokens[3].c_str());
ins->pitchMacro = atoi(tokens[4].c_str());
ins->hipitchMacro = atoi(tokens[5].c_str());
ins->dutyMacro = atoi(tokens[6].c_str());
ins->name = strGetBetween(tokens[7]);
this->instrumentList.push_back(ins);
} else if (!tokens[0].compare("KEYDPCM")) {
FTMInstrument *ins = this->instrumentList.at(atoi(tokens[1].c_str()));
if (ins) {
ins->extra.keyDPCM.octave = atoi(tokens[2].c_str());
ins->extra.keyDPCM.note = atoi(tokens[3].c_str());
ins->extra.keyDPCM.sample = atoi(tokens[4].c_str());
ins->extra.keyDPCM.pitch = atoi(tokens[5].c_str());
ins->extra.keyDPCM.loop = atoi(tokens[6].c_str());
ins->extra.keyDPCM.loopPoint = atoi(tokens[7].c_str());
ins->extra.keyDPCM.delta = atoi(tokens[8].c_str());
}
}
}
} while (!buf.empty());
}
int FTMtxt::loadText(const char *fileName)
{
std::ifstream iFile(fileName, std::ios::in);
if (!iFile.is_open()) {
return -1;
}
std::string buf;
std::getline(iFile, buf);
if (buf.find("# FamiTracker text export") == std::string::npos) {
return -1;
}
while (!iFile.eof()) {
std::getline(iFile, buf);
if (buf.find("#") != std::string::npos) {
if (buf.find("# Song information") != std::string::npos) {
this->parseSongInfo(iFile);
} else if (buf.find("# Song comment") != std::string::npos) {
this->parseComment(iFile);
} else if (buf.find("# Global settings") != std::string::npos) {
this->parseGlobalSettings(iFile);
} else if (buf.find("# Macros") != std::string::npos) {
} else if (buf.find("# DPCM samples") != std::string::npos) {
this->parseDPCMSamples(iFile);
} else if (buf.find("# Instruments") != std::string::npos) {
this->parseInstruments(iFile);
} else if (buf.find("# Tracks") != std::string::npos) {
this->parseTracks(iFile);
}
}
}
return 0;
}
void FTMtxt::parseSongInfo(std::ifstream &iFile)
{
std::string buf;
std::getline(iFile, buf);
this->songTitle = strGetBetween(buf);
std::getline(iFile, buf);
this->songAuthor = strGetBetween(buf);
std::getline(iFile, buf);
this->songCopyright = strGetBetween(buf);
}
void FTMtxt::parseComment(std::ifstream &iFile)
{
std::string buf;
std::getline(iFile, buf);
this->songComment = strGetBetween(buf, '\"');
}
void FTMtxt::parseDPCMSamples(std::ifstream &iFile)
{
this->sampleList.clear();
std::string buf;
while (true) {
std::getline(iFile, buf);
std::vector<std::string> tokens = tokenize(buf.c_str());
if (tokens.size() != 4 || tokens[0].compare("DPCMDEF")) {
break;
}
DPCMSample *sample = new DPCMSample;
sample->length = atoi(tokens[2].c_str());
sample->sampleName = strGetBetween(tokens[3]);
uint8_t *samples = new uint8_t[sample->length];
int i = 0;
while (i < sample->length) {
std::getline(iFile, buf);
tokens = tokenize(buf.c_str());
for (size_t j = 0; j < tokens.size(); ++j) {
if (!tokens[j].compare("DPCM") || !tokens[j].compare(":")) {
continue;
}
samples[i++] = std::stoi(tokens[j], nullptr, 0x10);
}
}
sample->sample = samples;
sampleList.push_back(sample);
}
}
void FTMtxt::parseTracks(std::ifstream &iFile)
{
this->PatternList.clear();
this->columnSize.clear();
this->patternOrder.clear();
std::string buf;
do {
std::getline(iFile, buf);
if (!buf.empty()) {
std::vector<std::string> tokens = tokenize(buf.c_str());
if (!tokens[0].compare("TRACK")) {
this->patternLength = atoi(tokens[1].c_str());
this->trackSpeed = atoi(tokens[2].c_str());
this->trackTempo = atoi(tokens[3].c_str());
} else if (!tokens[0].compare("COLUMNS")) {
for (size_t i = 2; i < tokens.size(); ++i) {
this->columnSize.push_back(atoi(tokens[i].c_str()));
}
} else if (!tokens[0].compare("ORDER")) {
std::vector<int> order;
for (size_t i = 3; i < tokens.size(); ++i) {
order.push_back(std::stoul(tokens[i], nullptr, 0x10));
}
this->patternOrder.push_back(order);
} else if (!tokens[0].compare("PATTERN")) {
this->parsePattern(iFile, atoi(tokens[1].c_str()));
}
}
} while (buf.compare("# End of export"));
}
void FTMtxt::parseGlobalSettings(std::ifstream &iFile)
{
std::string buf;
do {
std::getline(iFile, buf);
if (!buf.empty()) {
std::vector<std::string> tokens = tokenize(buf.c_str());
if (!tokens[0].compare("MACHINE")) {
this->isPal = static_cast<bool>(atoi(tokens[1].c_str()));
} else if (!tokens[0].compare("EXPANSION")) {
this->expansion = static_cast<expansionChips>(atoi(tokens[1].c_str()));
switch (this->expansion) {
case EC_NONE:
channelCount = 5;
break;
case EC_VRC6:
channelCount = 8;
break;
case EC_VRC7:
channelCount = 11;
break;
case EC_FDS:
channelCount = 6;
break;
case EC_MMC5:
channelCount = 7;
break;
case EC_N163:
channelCount = 13;
break;
case EC_S5B:
channelCount = 8;
break;
default:
break;
}
}
}
} while (!buf.empty());
}
void FTMtxt::parsePattern(std::ifstream &iFile, int patternNum)
{
std::string buf;
FTMPattern *pattern = new FTMPattern;
for (int i = 0; i < this->patternLength; ++i) {
FTMPatternRow *row = new FTMPatternRow;
std::getline(iFile, buf);
std::vector<std::string> tokens = tokenize(buf.c_str());
int ct = 2; //current token
for (int j = 0; j < channelCount; ++j) {
FTMPatternRowEntry *entry = new FTMPatternRowEntry;
if (!tokens[++ct].compare("---")) {
entry->note = noteCut;
} else if (!tokens[ct].compare("...")) {
entry->note = noteNo;
} else if (!tokens[ct].compare("===")) {
entry->note = noteRelease;
} else {
entry->note = noteToInt(tokens[ct].c_str(), j == 3);
}
if (!tokens[++ct].compare("..")) {
entry->instrument = -1;
} else {
entry->instrument = atoi(tokens[ct].c_str());
}
if (tokens[++ct][0] != '.') {
entry->volume = Utility::hexCharToInt(tokens[ct][0]);
} else {
entry->volume = -1;
}
if (!tokens[++ct].compare("...")) {
entry->effect1 = 0;
entry->effect1data = -1;
} else {
entry->effect1 = tokens[ct][0];
entry->effect1data = std::stoi(tokens[ct].substr(1, 2), nullptr, 0x10);
}
if (columnSize[j] >= 2) {
if (!tokens[++ct].compare("...")) {
entry->effect2 = 0;
entry->effect2data = -1;
} else {
entry->effect2 = tokens[ct][0];
entry->effect2data = std::stoi(tokens[ct].substr(1, 2), nullptr, 0x10);
}
}
if (columnSize[j] >= 3) {
if (!tokens[++ct].compare("...")) {
entry->effect3 = 0;
entry->effect3data = -1;
} else {
entry->effect3 = tokens[ct][0];
entry->effect3data = std::stoi(tokens[ct].substr(1, 2), nullptr, 0x10);
}
}
++ct; // : delimeter
row->push_back(entry);
}
pattern->push_back(row);
}
this->PatternList.push_back(pattern);
}
int FTMtxt::noteToInt(const char *note, bool noise)
{
if (noise) {
return Utility::hexCharToInt(note[0]);
}
const char notes[] = { 'C', 'C', 'D', 'D', 'E', 'F', 'F', 'G', 'G', 'A', 'A', 'B' };
int res;
for (int i = 0; i < sizeof(notes) / sizeof(char); ++i) {
if (note[0] == notes[i]) {
res = i;
if (note[1] == '#') {
res += 1;
}
break;
}
}
return res + 12 * atoi(¬e[2]);
}
| [
"iddqd_mail@mail.ru"
] | iddqd_mail@mail.ru |
0ebabedb27226be5495e137471314f1190b24a0a | bde277f529956108d7091bda5fb333986476b6b3 | /unittests/core/test_array_stack.cpp | 40573968f1847177bf584132cc91f6826a7c4923 | [
"LLVM-exception",
"Apache-2.0"
] | permissive | SNSystems/pstore | 0f0ebd732937a1ea5a7d95a557af7288e285b907 | 05edd7d81e61be96083c582dc5d214c247806940 | refs/heads/master | 2022-05-19T20:59:45.355159 | 2022-03-29T08:39:28 | 2022-03-29T08:39:28 | 104,728,661 | 11 | 6 | NOASSERTION | 2022-03-07T15:52:02 | 2017-09-25T09:17:35 | C++ | UTF-8 | C++ | false | false | 2,076 | cpp | //===- unittests/core/test_array_stack.cpp --------------------------------===//
//* _ _ *
//* __ _ _ __ _ __ __ _ _ _ ___| |_ __ _ ___| | __ *
//* / _` | '__| '__/ _` | | | | / __| __/ _` |/ __| |/ / *
//* | (_| | | | | | (_| | |_| | \__ \ || (_| | (__| < *
//* \__,_|_| |_| \__,_|\__, | |___/\__\__,_|\___|_|\_\ *
//* |___/ *
//===----------------------------------------------------------------------===//
//
// Part of the pstore project, under the Apache License v2.0 with LLVM Exceptions.
// See https://github.com/SNSystems/pstore/blob/master/LICENSE.txt for license
// information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include "pstore/core/array_stack.hpp"
#include <algorithm>
#include <string>
#include <utility>
#include <gtest/gtest.h>
TEST (ArrayStack, Empty) {
pstore::array_stack<int, 2> stack;
EXPECT_EQ (0U, stack.size ());
EXPECT_TRUE (stack.empty ());
}
TEST (ArrayStack, MaxSize) {
pstore::array_stack<int, 2> stack;
EXPECT_EQ (2U, stack.max_size ());
}
TEST (ArrayStack, Push1Value) {
pstore::array_stack<int, 2> stack;
stack.push (17);
EXPECT_EQ (1U, stack.size ());
EXPECT_FALSE (stack.empty ());
EXPECT_EQ (17, stack.top ());
}
TEST (ArrayStack, PushMoveValue) {
pstore::array_stack<std::string, 2> stack;
std::string value{"Hello"};
stack.push (std::move (value));
std::string const & top = stack.top ();
EXPECT_STREQ ("Hello", top.c_str ());
}
TEST (ArrayStack, PushAndPop1Value) {
pstore::array_stack<int, 2> stack;
stack.push (31);
stack.pop ();
EXPECT_EQ (0U, stack.size ());
EXPECT_TRUE (stack.empty ());
}
TEST (ArrayStack, PushAndPopMaxValues) {
pstore::array_stack<int, 2> stack;
stack.push (31);
stack.push (33);
stack.pop ();
stack.pop ();
EXPECT_EQ (0U, stack.size ());
EXPECT_TRUE (stack.empty ());
}
| [
"paulhuggett@mac.com"
] | paulhuggett@mac.com |
a09a4c5114608e7380f242fa87ae2e5e82a6eab0 | ad85b2de24ac66683e7538209bf1bb98e89dfe9a | /Src/SmartOS/App/Sensor.h | 8da3d4fd4c3d54f7ecc0f8e7972bdabb7d6d4682 | [] | no_license | armku/SmartOSDemo | 7319a3f267beab8def4b935ed6772b37e7682d64 | 98044c7dfa75757a2a6e1d037d6761c95b638c7a | refs/heads/master | 2020-07-01T07:41:15.913111 | 2019-08-07T17:01:04 | 2019-08-07T17:01:04 | 201,092,990 | 0 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 989 | h | #ifndef __SENSOR_H__
#define __SENSOR_H__
#include "Kernel\Sys.h"
#include "Device\Port.h"
class Sensor
{
public:
cstring Name; //名字
int Index; //索引号
OutputPort* Led; // 指示灯
OutputPort* Buzzer; // 蜂鸣器
InputPort* Key; // 输入按键
InputPort* Pir; //人体感应
InputPort* Mag; //门磁
//I2C* Ifrared //红外转发
Delegate<Sensor&> Press;
// 构造函数。指示灯和继电器一般开漏输出，需要倒置
Sensor() { Init(); }
Sensor(Pin key, Pin led = P0, bool ledInvert = true, Pin buzzer = P0, bool keyInvert=true);
Sensor(Pin key, Pin led = P0, Pin buzzer = P0);
~Sensor();
bool GetValue();
void SetValue(bool value);
//void Register(EventHandler handler, void* param = nullptr);
private:
void Init();
static void OnPress(InputPort* port, bool down, void* param);
void OnPress(InputPort& port, bool down);
//EventHandler _Handler;
//void* _Param;
private:
bool _Value; // 状态
};
#endif
| [
"258613763@qq.com"
] | 258613763@qq.com |
c628948c38e797f63cf70d22ca54c90ab7177b9c | 2822b6cb8411fefc504427a3fb34a3f916bc43c4 | /ETWProviders/ETWProviders.cpp | bbe7de9a7cac3ef166f6f60ee9b5c0367571ed7c | [
"Apache-2.0"
] | permissive | google/UIforETW | e5b4b07cb2045e4a5af0d97793015394ff804295 | fd4d0f3ba7f3fb16ec5fcca787ff331bcc98a818 | refs/heads/main | 2023-08-29T04:46:43.958433 | 2023-07-28T16:08:25 | 2023-07-28T17:18:30 | 33,694,418 | 1,504 | 207 | Apache-2.0 | 2023-04-09T21:15:33 | 2015-04-09T21:46:04 | C++ | UTF-8 | C++ | false | false | 621 | cpp | /*
Copyright 2015 Google Inc. 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 "stdafx.h"
| [
"brucedawson@chromium.org"
] | brucedawson@chromium.org |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.